def test_btree():
print("test_btree")
t = BTree()
for c in "berghain":
t.add_key(c)
print(f"\n{c}")
print(t.string())
def test_del_balance_bro_left(self):
p = BTreeNode(4)
p.items[0:8] = [15,20,30,40,None,None,None,None]
p.child[0:9] = [101, 102, 103, 104, 105, None, None, None, None]
p.setNumberOfKeys(4)
cur = BTreeNode(4)
cur.items[0:8] = [33,34,37,None,None,None,None,None]
cur.child[0:9] = [202, 203, 204, 205, None, None, None, None, None]
cur.setNumberOfKeys(3)
bro = BTreeNode(4)
bro.items[0:8] = [22,24,25,26,27,None,None,None]
bro.child[0:9] = [222, 223, 224, 225, 227, 229, None, None]
bro.setNumberOfKeys(5)
# cur on left, bro on right. parent item: 30
p.index = 1
cur.index = 104
bro.index = 103
BTree.balance(cur, bro, p, bro_left=True)
self.assertEquals(p.items, [15, 20, 27, 40, None, None, None, None])
self.assertEquals(p.child, [101, 102, 103, 104, 105, None, None, None, None])
self.assertEquals(cur.items, [30, 33, 34, 37, None, None, None, None])
self.assertEquals(cur.child, [229, 202, 203, 204, 205, None, None, None, None])
self.assertEquals(bro.items, [22, 24, 25, 26, None, None, None, None])
self.assertEquals(bro.child, [222, 223, 224, 225, 227, None, None, None])
def insertion(args):
tree = BTree()
for value in args.strip().split(" "):
tree.insert(value)
return tree
def __init__(self):
"""Sets the initial state of self, which includes the
contents of sourceCollection, if it's present."""
self._root = None
self.computer_mark = None
self.human_mark = None
BTree.__init__(self, root=None, computer_mark=None, human_mark=None)
def make_move_by_computer(self):
"""
Make move by computer
:return:None
"""
tree = BTree(self.board)
position = tree.build_tree(self.computer_character,
self.player_character)[1]
self.board.make_move(position, self.computer_character)
def test_add_insert_full_d2(self):
bt = BTree(2)
bt.insert(50)
self.assertEqual(bt.rootNode.items, [50, None, None, None])
bt.insert(27)
self.assertEqual(bt.rootNode.items, [27, 50, None, None])
bt.insert(11)
self.assertEqual(bt.rootNode.items, [11, 27, 50, None])
bt.insert(72)
self.assertEqual(bt.rootNode.items, [11, 27, 50, 72])
res = bt.insert(10)
self.assertEqual(res, 10)
def handle_comp(self):
"""
Method to work with computer
:return: None
"""
tree = BTree(self.board)
tree.build()
move = tree.f_move('x')
if self.board.positions[move[0], move[1]] is not None:
print("Computer made mistake")
raise UserError
self.board.add_pos(move, 'x')
print("Computer moved {}".format(move))
def test_add_insert_deep(self):
bt = BTree(1)
bt.insert(50)
bt.insert(27)
res = bt.insert(35)
self.assertEqual(res, 35) # full, root
bt.insert(98)
bt.insert(201)
def helper(field, pos=-1):
tree = BTree()
res = self.check_field(field)
if res == WIN1:
tree.add_root(tuple([field, 1, 1, pos]))
return tree
if res == WIN2:
tree.add_root(tuple([field, -1, 1, pos]))
return tree
if res == TIE:
tree.add_root(tuple([field, 0, 1, pos]))
return tree
tree.add_root(field)
root = tree.root()
left = helper(*self.random_step(field))
right = helper(*self.random_step(field))
points = left.root().element()[1] + right.root().element()[1]
count = left.root().element()[2] + right.root().element()[2]
tree.replace(root, tuple([field, points, count, pos]))
tree.attach(root, left, right)
return tree
def test(pairs=None):
try:
error_info = OrderedDict()
if pairs is not None:
pair_cnt = len(pairs)
seq = pairs
b_tree = BTree(pairs)
error_info['Insert sequence'] = seq
error_info['Tree'] = b_tree
else:
pair_cnt = 200
seq = []
b_tree = BTree()
error_info['Insert sequence'] = seq
error_info['Tree'] = b_tree
for i in range(pair_cnt):
pair = Pair(random.randint(1, 50), random.randint(1, 1000))
seq.append(pair)
b_tree.insert(pair)
assert b_tree.is_valid(), \
'Occur the error when inserting the pair.'
sorted_seq = sorted(seq)
tree_seq = [pair for pair in b_tree]
error_info['Sorted insert sequence'] = sorted_seq
error_info['Output sequence'] = tree_seq
assert len(sorted_seq) == len(tree_seq), \
'The length of the output sequence of the tree i not correct.'
for i in range(len(sorted_seq)):
assert id(sorted_seq[i]) == id(tree_seq[i]), \
'Input node and output nodes are not the same.'
del_seq = []
error_info['Delete sequence'] = del_seq
for_del = seq.copy()
for i in range(pair_cnt): # delete until zero node in the tree
idx = random.randint(0, len(for_del) - 1)
pair = for_del.pop(idx)
del_seq.append(pair)
b_tree.delete_one(pair)
assert b_tree.is_valid(), f'Deleting fails. Pair:{pair}'
return True
except Exception as e:
extra_msg = '\n\n'.join([f'{k}:\n{v}' for k, v in error_info.items()])
# The error message may be at the first item?
e.args = (e.args[0] + f'\n{extra_msg}', *e.args[1:])
raise e
class BTreeTest(unittest.TestCase):
def setUp(self):
self.btree = BTree()
self.btree.add(10)
self.btree.add(20)
self.btree.add(40)
self.btree.add(50)
def test_contains(self):
assert 10 in self.btree
assert 20 in self.btree
assert 40 in self.btree
assert 50 in self.btree
def test_does_not_contain(self):
assert 100 not in self.btree
assert 23423 not in self.btree
def init(cls, datafile):
buffer = Buffer.init(datafile)
try:
config_datablock = buffer.get_datablock(
int(buffer.datafile.NUM_DATABLOCKS) - 1)
btree_root = BTree(root=config_datablock.btree_root, buffer=buffer)
except (EnvironmentError):
btree_root = None
return cls(buffer=buffer, btree=btree_root)
def hybrid_training(threshold, use_threshold, stage_nums, core_nums, train_step_nums, batch_size_nums, learning_rate_nums,
keep_ratio_nums, train_data_x, train_data_y, test_data_x, test_data_y):
stage_length = len(stage_nums)
col_num = stage_nums[1]
# initial
tmp_inputs = [[[] for i in range(col_num)] for i in range(stage_length)]
tmp_labels = [[[] for i in range(col_num)] for i in range(stage_length)]
index = [[None for i in range(col_num)] for i in range(stage_length)]
tmp_inputs[0][0] = train_data_x
tmp_labels[0][0] = train_data_y
test_inputs = test_data_x
for i in range(0, stage_length):
for j in range(0, stage_nums[i]):
if len(tmp_labels[i][j]) == 0:
continue
inputs = tmp_inputs[i][j]
labels = []
test_labels = []
if i == 0:
# first stage, calculate how many models in next stage
divisor = stage_nums[i + 1] * 1.0 / (TOTAL_NUMBER / BLOCK_SIZE)
for k in tmp_labels[i][j]:
labels.append(int(k * divisor))
for k in test_data_y:
test_labels.append(int(k * divisor))
else:
labels = tmp_labels[i][j]
test_labels = test_data_y
# train model
tmp_index = TrainedNN(threshold[i], use_threshold[i], core_nums[i], train_step_nums[i], batch_size_nums[i],
learning_rate_nums[i],
keep_ratio_nums[i], inputs, labels, test_inputs, test_labels)
tmp_index.train()
# get parameters in model (weight matrix and bias matrix)
index[i][j] = AbstractNN(tmp_index.get_weights(), tmp_index.get_bias(), core_nums[i], tmp_index.cal_err())
del tmp_index
gc.collect()
if i < stage_length - 1:
# allocate data into training set for models in next stage
for ind in range(len(tmp_inputs[i][j])):
# pick model in next stage with output of this model
p = index[i][j].predict(tmp_inputs[i][j][ind])
if p > stage_nums[i + 1] - 1:
p = stage_nums[i + 1] - 1
tmp_inputs[i + 1][p].append(tmp_inputs[i][j][ind])
tmp_labels[i + 1][p].append(tmp_labels[i][j][ind])
for i in range(stage_nums[stage_length - 1]):
if index[stage_length - 1][i] is None:
continue
mean_abs_err = index[stage_length - 1][i].mean_err
if mean_abs_err > threshold[stage_length - 1]:
# replace model with BTree if mean error > threshold
print("Using BTree")
index[stage_length - 1][i] = BTree(2)
index[stage_length - 1][i].build(tmp_inputs[stage_length - 1][i], tmp_labels[stage_length - 1][i])
return index
def get_random_btree(items):
'''Return a BTree with elements from items inserted at random:
all insertions at leaf level;
at each level, go right with prob 50% and left with prob 50%.'''
node = None
for item in items:
node = random_insert(node, item)
return BTree(node)
def test_btree(self):
from btree import BTree
r = 500
array = range(r)
random.shuffle(array)
t = BTree(8, array)
self.assertTrue(t.sanity())
self.assertListEqual(t.as_list(), range(r))
self.assertTrue(t.find(100))
keys = t.as_list()
random.shuffle(keys)
length = len(keys)
for key in keys:
t.delete(key)
length -= 1
self.assertTrue(t.sanity())
self.assertEqual(length, len(t.as_list()))
self.assertFalse(t.find(key)) # key should gone
def setUp(self):
self.btree = BTree(5)
empty_leaf = [None, None, None, None, None]
self.btree._root = (1, [4, 6, 11, 20],
[(2, [1, 2, None, None], empty_leaf[:]),
(2, [5, None, None, None], empty_leaf[:]),
(2, [7, 8, 9, 10], empty_leaf[:]),
(2, [12, 14, 15, 16], empty_leaf[:]),
(2, [None, None, None, None], empty_leaf[:])])
def refresh(self, datafile):
buffer = Buffer.init(datafile)
try:
config_datablock = buffer.get_datablock(
int(buffer.datafile.NUM_DATABLOCKS) - 1)
btree_root = BTree(root=config_datablock.btree_root, buffer=buffer)
except (EnvironmentError):
btree_root = None
self.buffer = buffer
self.btree = btree_root
def __init__(self, eval_functions, degree):
"""
Initialize the Btree and the evaluation functions.
"""
self.trees = []
self.clauseDeleted = []
self.eval_functions = eval_functions
self.counter = 0
print(len(eval_functions.eval_descriptor))
for i in range(0, len(eval_functions.eval_descriptor)):
self.trees.append(BTree(degree))
def test_add_insert_not_full(self):
bt = BTree(2)
bt.insert(50)
self.assertEqual(bt.rootNode.items, [50, None, None, None])
bt.insert(27)
self.assertEqual(bt.rootNode.items, [27, 50, None, None])
res = bt.insert(30)
self.assertEqual(bt.rootNode.items, [27, 30, 50, None])
res = bt.insert(10)
self.assertEqual(bt.rootNode.items, [10, 27, 30, 50])
def insert(self, code, desc):
"""
Inserts code and desc into table
"""
if (self.btree is None):
new_config = self.buffer.new_datablock(
4, self.buffer.datafile.NUM_DATABLOCKS - 1)
self.btree = BTree(root=self.BTREE_ROOT_DEFAULT,
buffer=self.buffer)
self.btree.init()
new_record = Record(code=code, description=desc)
#Search if code already exists
if (self.btree.has_key(code)):
print('Record with code %s already exists' % code)
return None
dblock, position = self.buffer.search_dblock_with_free_space(
new_record.size() + 4, 1)
new_record = dblock.write_data(new_record, position)
self.btree.insert(new_record.code, new_record.rowid)
print('Record Inserted')
pass
def hybrid_training(threshold, use_threshold, stage_nums, core_nums, train_step_nums, batch_size_nums,
learning_rate_nums, keep_ratio_nums, train_data_x, train_data_y, test_data_x, test_data_y):
stage_length = len(stage_nums)
col_num = stage_nums[1]
tmp_inputs = [[[] for i in range(col_num)] for i in range(stage_length)]
tmp_labels = [[[] for i in range(col_num)] for i in range(stage_length)]
index = [[None for i in range(col_num)] for i in range(stage_length)]
tmp_inputs[0][0] = train_data_x
tmp_labels[0][0] = train_data_y
test_inputs = test_data_x
for i in range(0, stage_length):
for j in range(0, stage_nums[i]):
if len(tmp_labels[i][j]) == 0:
continue
inputs = tmp_inputs[i][j]
labels = []
test_labels = []
if i == 0:
divisor = stage_nums[i + 1] * 1.0 / (STORE_NUMBER / BLOCK_SIZE)
for k in tmp_labels[i][j]:
labels.append(int(k * divisor))
for k in test_data_y:
test_labels.append(int(k * divisor))
else:
labels = tmp_labels[i][j]
test_labels = test_data_y
tmp_index = TrainedNN(threshold[i], use_threshold[i], core_nums[i], train_step_nums[i], batch_size_nums[i],
learning_rate_nums[i],
keep_ratio_nums[i], inputs, labels, test_inputs, test_labels)
tmp_index.train()
index[i][j] = AbstractNN(tmp_index.get_weights(), tmp_index.get_bias(), core_nums[i], tmp_index.cal_err())
del tmp_index
gc.collect()
if i < stage_length - 1:
for ind in range(len(tmp_inputs[i][j])):
p = index[i][j].predict(tmp_inputs[i][j][ind])
if p > stage_nums[i + 1] - 1:
p = stage_nums[i + 1] - 1
tmp_inputs[i + 1][p].append(tmp_inputs[i][j][ind])
tmp_labels[i + 1][p].append(tmp_labels[i][j][ind])
for i in range(stage_nums[stage_length - 1]):
if index[stage_length - 1][i] is None:
continue
mean_abs_err = index[stage_length - 1][i].mean_err
if mean_abs_err > threshold[stage_length - 1]:
print("Using BTree")
index[stage_length - 1][i] = BTree(2)
index[stage_length - 1][i].build(tmp_inputs[stage_length - 1][i], tmp_labels[stage_length - 1][i])
return index
def test_add_insert_full(self):
bt = BTree(1)
bt.insert(50)
self.assertEqual(bt.rootNode.items, [50, None])
bt.insert(27)
self.assertEqual(bt.rootNode.items, [27, 50])
res = bt.insert(35)
self.assertEqual(res, 35)
class Board:
def __init__(self, n):
self.width = n
self.tree = BTree(n)
self.tree.build()
self.current_step = self.tree._root
self.first_is_x = True
def make_step(self, row, col):
if self.current_step.field.board[row][col] is not None:
raise Exception("Wrong move")
for step in self.current_step.children:
if step.step_row == row and step.step_col == col:
self.current_step = step
break
def get_best_step(self):
best_step = None
for step in self.current_step.children:
if best_step is None or best_step.rating < step.rating:
best_step = step
return best_step.step_row, best_step.step_col
def __str__(self):
s = ""
for row in range(self.width):
for col in range(self.width):
is_first = self.current_step.field.board[row][col]
if is_first is None:
s += " | "
elif self.first_is_x == is_first:
s += "X | "
else:
s += "O | "
s = s[:-3] + "\n"
s += ("-" * self.width * 3) + "\n"
return s[:-((self.width * 3)+1)]
def game():
"""
The game starts here.
"""
board = Board()
board_checks = {1: (0, 0), 2: (0, 1), 3: (0, 2), 4: (1, 0), 5: (1, 1), 6: (1, 2), 7: (2, 0), 8: (2, 1), 9: (2, 2)}
s = ''
print("\nGame Board:")
for i in range(1, 10):
if i % 3 != 0:
s += str(i) + ' '
else:
s += str(i) + '\n'
print(s)
for count in range(9):
k = int(input("Enter your move: "))
while board.set_value(board_checks[k], 1) is None:
k = int(input("\tCell isn't empty!\n\tEnter your move again: "))
print("\tYou've made a move:")
print(board)
if board.has_winner() == 1:
print("\n\tCongratulations! You win! :)\n")
print(board)
return new_game()
print("\tComputer has made a move:")
board1 = BTNode(board)
bnt = BTree(board1)
bnt.expand()
board = bnt.get_best_move()
print(board)
if board.has_winner() == -1:
print("\n\tUnfortunately, you lose :(\n")
print(board)
return new_game()
if board.still_have_move() == False:
print("It is a draw.")
return board
def main():
"""Create a BTree and add a few BNodes."""
# Create BNodes
kotei = BNode("固定資産")
mukei = BNode("無形固定資産", kotei)
yukei = BNode("有形固定資産", kotei)
tochi = BNode("土地", yukei)
tatemono = BNode("建物", yukei)
kouchiku = BNode("構築物", yukei)
# Create BTree with kotei BNode as root node
tree = BTree(kotei)
# Construct BTree
tree.insert(mukei)
tree.insert(yukei)
tree.insert(tochi)
tree.insert(tatemono)
tree.insert(kouchiku)
# Print location of tatemono
tree.locate("建物")
def main():
a = 2
b = 6
tree = BTree(b)
print("1 esercizio")
if tree.is_empty():
print("albero vuoto")
tree.insert(0, (42, 65))
if not tree.is_empty():
print("nodo inserito")
def main():
tree = BTree(1)
names = open('../names_uniq.txt').read().splitlines()
random.shuffle(names)
names = names[:10000]
for name in names:
tree.insert_rec(name)
print tree
for name in names:
print tree.search_rec(name)
for name in names:
tree.remove_rec(name)
print tree
def tree(self):
"""
Chooses one of two random moves using tree
"""
tree = BTree()
board1 = copy.deepcopy(self)
board2 = copy.deepcopy(self)
board1.make_random_move()
board2.make_random_move()
tree.set_left(BTNode(board1))
tree.set_right(BTNode(board2))
def recurse(board):
if board.item.has_winner() == 0:
l1 = copy.deepcopy(board.item)
l2 = copy.deepcopy(board.item)
l1.make_random_move()
l2.make_random_move()
board.left = BTNode(l1)
board.right = BTNode(l2)
return recurse(board.left) + recurse(board.right)
has_winner = board.item.has_winner()
if has_winner:
winner_scores = {
Board.NOUGHT_WINNER: 1,
Board.CROSS_WINNER: -1,
Board.DRAW: 0
}
return winner_scores[has_winner]
r1 = recurse(tree.root.left)
r2 = recurse(tree.root.right)
if r1 > r2:
return board1
else:
return board2
class Bot():
'''constructor of a Bot'''
def __init__(self, turn):
self.turn = turn
self.decision_tree = BTree(turn)
def make_first_move(self, board):
'''
method for making first move
:param board: gameboard
:return: gameboard
'''
coord = self.decision_tree.generate_coord()
moveMade = False
while not moveMade:
if board.put(self.turn, coord):
moveMade = True
else:
coord = self.decision_tree.generate_coord(board)
return board
def make_move(self, board):
'''
methot for making moves
:param board: gameboard
:return: gameboard
'''
self.decision_tree.new_generation(self.decision_tree.root)
coord = self.decision_tree.best_move()
moveMade = False
while not moveMade:
if board.put(self.turn, coord):
moveMade = True
else:
coord = self.decision_tree.generate_coord(board)
return board
def main(): tree = BTree(1) # tree = BTree(2) # for rec in ['cat', 'ant', 'dog', 'cow', 'rat', 'pig', 'gnu']: # for rec in [80, 50, 100, 90, 60, 65, 70, 75, 55, 64, 51, 76, 77, 78, 200, 300, 150]: # for rec in [51, 11, 30, 66, 78, 2, 7, 12, 15, 33, 41, 53, 54, 68, 69, 79, 84, 93, 22, 63, 71, 76]: # for rec in [1, 2, 3, 6, 7, 4, 5]: # for rec in [10, 20, 5, 6, 15, 16, 25, 26]: # for rec in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]: # for rec in [1, 2, 3, 4, 5, 6, 7, 8, 9]: # for rec in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]: for rec in [1, 2, 3]: # print '* insert %s' % rec tree.insert_rec(rec) # print tree a1 = BNode(2) a1.recs = [51] a2 = BNode(2) a2.recs = [11, 30] a3 = BNode(2) a3.recs = [66, 78] a4 = BNode(2) a4.recs = [2, 7] a5 = BNode(2) a5.recs = [12, 15, 22] a6 = BNode(2) a6.recs = [33, 41] a7 = BNode(2) a7.recs = [53, 54, 63] a8 = BNode(2) a8.recs = [68, 69, 71, 76] a9 = BNode(2) a9.recs = [79, 84, 93] a1.childs = [a2, a3] a2.childs = [a4, a5, a6] a3.childs = [a7, a8, a9] tree.root = a1 print tree # for rec in ['cat', 'ant', 'dog', 'cow', 'rat', 'pig', 'gnu']: for rec in [68, 51, 63, 53]: # for rec in [51, 11, 30, 66, 78, 2, 7, 12, 15, 33, 41, 53, 54, 68, 69, 79, 84, 93, 22, 63, 71, 76]: # for rec in [1, 2, 3, 6, 7, 4, 5]: # for rec in [15]: # for rec in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]: # for rec in [1, 2, 3, 4, 5, 6, 7, 8, 9]: # for rec in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]: # for rec in [1, 2, 3]: print '* remove %s' % rec tree.remove_rec(rec) print tree
def create_btree(array):
head = create_btree_helper(array, 0, len(array) - 1)
tree = BTree(head)
tree.show()
if n.l is not None:
nodes.append(n.l)
if n.r is not None:
nodes.append(n.r)
count = count - 1
l = LL(head)
ll.append(l)
for l in ll:
l.show()
if __name__ == "__main__":
head = BTreeNode(10)
head.l = BTreeNode(5)
head.r = BTreeNode(7)
head.l.l = BTreeNode(6)
head.l.r = BTreeNode(20)
head.r.l = BTreeNode(18)
head.r.r = BTreeNode(30)
head.r.r.r = BTreeNode(50)
head.r.r.r.r = BTreeNode(60)
head.r.r.r.l = BTreeNode(70)
tree = BTree(head)
tree.show()
ll_from_btree(tree)
from btree import BTree
import random
def walk(item, spaces=0):
print("{}{}={} {} {}".format(" " * spaces, item.key, item.value,
"leaf" if item.leaf else "", item.parent))
for child in item.children:
walk(child, spaces + 1)
root = BTree(False, 3, 0, None)\
.insert(1, "1")\
.insert(2, "2")\
.insert(3, "3")\
.insert(4, "4")
inserted = [1, 2, 3, 4]
for i in range(5, 100):
root = root.insert(i, str(i))
inserted.append(i)
walk(root)
print(root.children)
def keysonly(items):
for item in items:
yield item.key
def __init__(self, node):
BTree.__init__(self, node)
self.prlmb = lambda node: '({},{},{},{},{})'.format(
node.data, node.lr_child, node.deep, node.l_max_height, node.
r_max_height)
def setUp(self):
self.btree = BTree()
self.btree.add(10)
self.btree.add(20)
self.btree.add(40)
self.btree.add(50)
def test_is_root(self):
bt = BTree(1)
self.assertTrue(bt.isRoot(1))
self.assertFalse(bt.isRoot(0))
self.assertFalse(bt.isRoot(3))
def train_index(threshold, use_threshold, distribution, path):
# data = pd.read_csv("data/random_t.csv", header=None)
# data = pd.read_csv("data/exponential_t.csv", header=None)
data = pd.read_csv(path, header=None)
train_set_x = []
train_set_y = []
test_set_x = []
test_set_y = []
set_data_type(distribution)
# read parameter
if distribution == Distribution.RANDOM:
parameter = ParameterPool.RANDOM.value
elif distribution == Distribution.LOGNORMAL:
parameter = ParameterPool.LOGNORMAL.value
elif distribution == Distribution.EXPONENTIAL:
parameter = ParameterPool.EXPONENTIAL.value
elif distribution == Distribution.NORMAL:
parameter = ParameterPool.NORMAL.value
else:
return
stage_set = parameter.stage_set
# set number of models for second stage (1 model deal with 10000 records)
#stage_set[1] = int(round(data.shape[0] / 10000))
core_set = parameter.core_set
train_step_set = parameter.train_step_set
batch_size_set = parameter.batch_size_set
learning_rate_set = parameter.learning_rate_set
keep_ratio_set = parameter.keep_ratio_set
global TOTAL_NUMBER
TOTAL_NUMBER = data.shape[0]
for i in range(data.shape[0]):
train_set_x.append(data.ix[i, 0])
train_set_y.append(data.ix[i, 1])
#train_set_x.append(data.ix[i, 0])
#train_set_y.append(data.ix[i, 1])
test_set_x = train_set_x[:]
test_set_y = train_set_y[:]
# data = pd.read_csv("data/random_t.csv", header=None)
# data = pd.read_csv("data/exponential_t.csv", header=None)
# for i in range(data.shape[0]):
# test_set_x.append(data.ix[i, 0])
# test_set_y.append(data.ix[i, 1])
print("*************start Learned NN************")
print("Start Train")
start_time = time.time()
# train index
trained_index = hybrid_training(threshold, use_threshold, stage_set, core_set, train_step_set, batch_size_set, learning_rate_set,
keep_ratio_set, train_set_x, train_set_y, [], [])
end_time = time.time()
learn_time = end_time - start_time
print("Build Learned NN time ", learn_time)
print("Calculate Error")
err = 0
start_time = time.time()
# calculate error
for ind in range(len(test_set_x)):
# pick model in next stage
pre1 = trained_index[0][0].predict(test_set_x[ind])
if pre1 > stage_set[1] - 1:
pre1 = stage_set[1] - 1
# predict position
pre2 = trained_index[1][pre1].predict(test_set_x[ind])
err += abs(pre2 - test_set_y[ind])
end_time = time.time()
search_time = (end_time - start_time) / len(test_set_x)
print("Search time %f " % search_time)
mean_error = err * 1.0 / len(test_set_x)
print("mean error = ", mean_error)
print("*************end Learned NN************\n\n")
# write parameter into files
result_stage1 = {0: {"weights": trained_index[0][0].weights, "bias": trained_index[0][0].bias}}
result_stage2 = {}
for ind in range(len(trained_index[1])):
if trained_index[1][ind] is None:
continue
if isinstance(trained_index[1][ind], BTree):
tmp_result = []
for ind, node in trained_index[1][ind].nodes.items():
item = {}
for ni in node.items:
if ni is None:
continue
item = {"key": ni.k, "value": ni.v}
tmp = {"index": node.index, "isLeaf": node.isLeaf, "children": node.children, "items": item,
"numberOfkeys": node.numberOfKeys}
tmp_result.append(tmp)
result_stage2[ind] = tmp_result
else:
result_stage2[ind] = {"weights": trained_index[1][ind].weights,
"bias": trained_index[1][ind].bias}
result = [{"stage": 1, "parameters": result_stage1}, {"stage": 2, "parameters": result_stage2}]
with open("model/" + pathString[distribution] + "/full_train/NN/" + str(TOTAL_NUMBER) + ".json", "wb") as jsonFile:
json.dump(result, jsonFile)
# wirte performance into files
performance_NN = {"type": "NN", "build time": learn_time, "search time": search_time, "average error": mean_error,
"store size": os.path.getsize(
"model/" + pathString[distribution] + "/full_train/NN/" + str(TOTAL_NUMBER) + ".json")}
with open("performance/" + pathString[distribution] + "/full_train/NN/" + str(TOTAL_NUMBER) + ".json",
"wb") as jsonFile:
json.dump(performance_NN, jsonFile)
del trained_index
gc.collect()
# build BTree index
print("*************start BTree************")
bt = BTree(2)
print("Start Build")
start_time = time.time()
bt.build(test_set_x, test_set_y)
end_time = time.time()
build_time = end_time - start_time
print("Build BTree time ", build_time)
err = 0
print("Calculate error")
start_time = time.time()
for ind in range(len(test_set_x)):
pre = bt.predict(test_set_x[ind])
err += abs(pre - test_set_y[ind])
if err != 0:
flag = 1
pos = pre
off = 1
while pos != test_set_y[ind]:
pos += flag * off
flag = -flag
off += 1
end_time = time.time()
search_time = (end_time - start_time) / len(test_set_x)
print("Search time ", search_time)
mean_error = err * 1.0 / len(test_set_x)
print("mean error = ", mean_error)
print("*************end BTree************")
# write BTree into files
result = []
for ind, node in bt.nodes.items():
item = {}
for ni in node.items:
if ni is None:
continue
item = {"key": ni.k, "value": ni.v}
tmp = {"index": node.index, "isLeaf": node.isLeaf, "children": node.children, "items": item,
"numberOfkeys": node.numberOfKeys}
result.append(tmp)
with open("model/" + pathString[distribution] + "/full_train/BTree/" + str(TOTAL_NUMBER) + ".json",
"wb") as jsonFile:
json.dump(result, jsonFile)
# write performance into files
performance_BTree = {"type": "BTree", "build time": build_time, "search time": search_time,
"average error": mean_error,
"store size": os.path.getsize(
"model/" + pathString[distribution] + "/full_train/BTree/" + str(TOTAL_NUMBER) + ".json")}
with open("performance/" + pathString[distribution] + "/full_train/BTree/" + str(TOTAL_NUMBER) + ".json",
"wb") as jsonFile:
json.dump(performance_BTree, jsonFile)
del bt
gc.collect()
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
from btree import BTree, Node, flip_tree
tree = BTree(4, Node(2, Node(1), Node(3)), Node(7, Node(6), Node(9)))
tree.tree_print()
flip_tree(tree)
print("\nFlipping tree...")
tree.tree_print()
def test_add_insert_split_parent(self):
bt = BTree(1)
bt.insert(50)
bt.insert(27)
bt.insert(35)
bt.insert(98)
bt.insert(201)
bt.insert(73)
bt.insert(29)
bt.insert(150)
bt.insert(15)
def test_del_nonleaf(self):
bt = BTree(2)
bt.insert(20)
bt.insert(40)
bt.insert(10)
bt.insert(30)
bt.insert(15)
bt.insert(35)
bt.insert(7)
bt.insert(26)
bt.insert(18)
bt.insert(22)
bt.insert(5)
bt.insert(42)
bt.insert(13)
bt.insert(46)
bt.insert(27)
bt.insert(8)
bt.insert(32)
bt.insert(38)
bt.insert(24)
bt.insert(45)
bt.insert(25)
bt.delete(35)
bt.delete(38)
bt.delete(25)
def build_btree_index(_item_list):
index = BTree()
[index.insert(x, i) for i, x in enumerate(_item_list)]
return index
curr = node.right
while curr.left:
curr = curr.left
return curr
# otherwise it's the first parent which can be arrived from the left
else:
curr = node.parent
while curr: # this could be "and (curr.left and curr.left.data != ...)" then we would leave when ==
if curr.left and curr.left.data == node.data:
break
node = curr
curr = curr.parent
return curr
t = BTree()
t.insert(5)
t.insert(3)
t.insert(7)
t.insert(-1)
t.insert(4)
t.insert(6)
t.insert(8)
t.insert(-2)
t.insert(2)
t.insert(0)
t.insert(1)
node = t.root.left.left.right.left # 0, successor is 1
successor(node)
def opponent_move(self):
""" Computer turn """
tree = BTree(self.board)
self.board.move(tree.ai_turn(self.player, self.comp)[1], self.comp)
def __init__(self, turn):
self.turn = turn
self.decision_tree = BTree(turn)
from btree import BTree
from GreatestDistance import findDiameter
t = BTree("h")
t.insert("d")
t.insert("f")
t.insert("a1")
t.insert("a2")
t.insert("a3")
t.insert("a4")
t.insert("m1")
t.insert("m2")
t.insert("m3")
t.insert("m4")
t.display()
print findDiameter(t)
