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)