def __init__(self, id, opcode, op_array, context):
""" Create a tree representaiton of an Opcode
Arguments :
id : The id representing the new OPcode
opcode : An OPcode struct
op_array : The op_array of the OPcode
context : An OPcacheParser instance
"""
Tree.__init__(self)
# Identifier to be used by the tree and nodes
id_with_hash = str(hash(str(op_array))) + "_" + id
# OP name
op = OPcodeParser.get_opcode_name(opcode['opcode'])
# Parser
context = OPcodeParser(context)
# Parse operands and result
(op1, op2, result) = context.parse_operands(opcode, op_array)
# Create nodes
op1_node = Node("Operand 1: " + op1, id_with_hash + "_op1")
op2_node = Node("Operand 2: " + op2, id_with_hash + "_op2")
result_node = Node("Result: " + result, id_with_hash + "_result")
# Link nodes to tree
self.create_node(id + ": " + op, id_with_hash + "_opcode")
self.add_node(op1_node, parent=id_with_hash + "_opcode")
self.add_node(op2_node, parent=id_with_hash + "_opcode")
self.add_node(result_node, parent=id_with_hash + "_opcode")
def program(self):
'''
Program → Statement SEMICO Program |ε
P -> S ; P
'''
# node = Node (tag= 'a')
self.root = Node(tag='Program')
self.token = self.lexer.getToken()
self.tree.add_node(self.root)
node = self.root
while (self.token.type != Token_Type.NONTOKEN):
node1 = Node(tag='Statement')
node2 = Node(tag=';')
node3 = Node(tag='Program')
self.tree.add_node(node1, node)
self.tree.add_node(node2, node)
self.tree.add_node(node3, node)
self.statement(node1)
# self.token = self.lexer.getToken ()
# print (self.token.type)
self.typecheck(Token_Type.SEMICO)
self.token = self.lexer.getToken()
node = node3
if (self.state == self.ERROR):
raise SyntaxError('SyntaxError !')
self.add_node('Empty', node)
print('---------------------Object Tree----------------------')
self.tree.show()
self.getValue()
def build_ast(parent, task):
root = Node(parent)
for key in list(task.keys()):
node_key = Node(key, parent=root)
value_element = task[key]
Node(value_element, parent=node_key)
return root
def fit_tree(k, preds, y, i, parent=None):
if k > 0:
l_preds, l_y, l_model = fit_leaf(preds, y, i)
self.tree.add_node(Node(identifier=parent + 'l' + str(k),
data=l_model),
parent=parent)
fit_tree(k - 1, l_preds, l_y, i + 1, parent + 'l' + str(k))
r_preds, r_y, r_model = fit_leaf(preds, y, i)
self.tree.add_node(Node(identifier=parent + 'r' + str(k),
data=r_model),
parent=parent)
fit_tree(k - 1, r_preds, r_y, i + 1, parent + 'r' + str(k))
def node2TreeOfTwo(self, tuple1, tuple2):
t = Tree()
node1 = Node(tuple1, tuple1[0])
node2 = Node(tuple2, tuple2[0])
freq = tuple1[1] + tuple2[1]
tag = tuple1[0] + tuple2[0]
t.create_node("(" + str(tag) + ", " + str(freq) + ")", tag, None)
if tuple1[1] >= tuple2[1]:
t.add_node(node1, tag)
t.add_node(node2, tag)
else:
t.add_node(node2, tag)
t.add_node(node1, tag)
return t
def test_depth(self):
# Try getting the level of this tree
self.assertEqual(self.tree.depth(), 2)
self.tree.create_node("Jill", "jill", parent="george")
self.assertEqual(self.tree.depth(), 3)
self.tree.create_node("Mark", "mark", parent="jill")
self.assertEqual(self.tree.depth(), 4)
# Try getting the level of the node
"""
self.tree.show()
Hárry
|___ Bill
| |___ George
| |___ Jill
| |___ Mark
|___ Jane
| |___ Diane
"""
self.assertEqual(self.tree.depth(self.tree.get_node("mark")), 4)
self.assertEqual(self.tree.depth(self.tree.get_node("jill")), 3)
self.assertEqual(self.tree.depth(self.tree.get_node("george")), 2)
self.assertEqual(self.tree.depth("jane"), 1)
self.assertEqual(self.tree.depth("bill"), 1)
self.assertEqual(self.tree.depth("hárry"), 0)
# Try getting Exception
node = Node("Test One", "identifier 1")
self.assertRaises(NodeIDAbsentError, self.tree.depth, node)
# Reset the test case
self.tree.remove_node("jill")
def get_move(self, board, player):
self.board = board
self.player = player # The chess color [BLACK or WHITE] represent the player
empty_set, a, b = self.board.get_board_item()
if len(a) == 0 and len(b) == 0:
return (MIDDLE, MIDDLE)
if len(empty_set) == 1:
return (empty_set[0][0], empty_set[0][1])
if len(empty_set) == 0:
print("No place to play")
return None
self.MCTS_tree = Tree()
self.HeadNode = Node('HeadNode', 0)
self.MCTS_tree.add_node(self.HeadNode)
self.plays = {}
self.wins = {}
simulations = 0
start = time.time()
while time.time() - start < (self.max_cal_time - 0.5):
board_for_MCTS = copy.deepcopy(self.board)
player_for_MCTS = self.player
self.run_simulation(board_for_MCTS, player_for_MCTS)
simulations += 1
print("total simuations = ", simulations)
move = self.select_best_move()
print("MCTS move:", move[0], move[1])
return move
def _create_tree(self, initial_state):
"""
A tree object for visualization purposes is created.
Parameters
----------
initial_state: state
An initial state
"""
self.tree = Tree()
self.tree.add_node(
Node(f'({0}:{initial_state}:{self.policy[(0, initial_state)]})',
f'({0}:{initial_state}:{self.policy[(0, initial_state)]})'))
def add_sons(s, t):
a = self.policy[(t, s)]
if t == self.T:
for st in self.Q(s, a):
n = Node(f'({t + 1}:{st})', f'({t + 1}:{st})')
self.tree.add_node(node=n, parent=f'({t}:{s}:{a})')
elif t < self.T - 1:
for st in self.Q(s, a):
at = self.policy[(t + 1, st)]
n = Node(f'({t + 1}:{st}:{at})', f'({t + 1}:{st}:{at})')
if n.identifier not in map(lambda x: x.identifier,
self.tree.all_nodes()):
self.tree.add_node(node=n, parent=f'({t}:{s}:{a})')
add_sons(st, t + 1)
add_sons(initial_state, 0)
def help_func_compoundStmt(grammar, tokens):
# Called only by the help_func_manager
# PLACEHOLDER RETURN STATEMENT
print("Compound:", tokens)
tree = Tree()
tree.add_node(Node(tag="Placeholder Compound"), parent=None)
return [tree, 0]
def add_sons(s, t):
a = self.policy[(t, s)]
if t == self.T:
for st in self.Q(s, a):
n = Node(f'({t + 1}:{st})', f'({t + 1}:{st})')
self.tree.add_node(node=n, parent=f'({t}:{s}:{a})')
elif t < self.T - 1:
for st in self.Q(s, a):
at = self.policy[(t + 1, st)]
n = Node(f'({t + 1}:{st}:{at})', f'({t + 1}:{st}:{at})')
if n.identifier not in map(lambda x: x.identifier,
self.tree.all_nodes()):
self.tree.add_node(node=n, parent=f'({t}:{s}:{a})')
add_sons(st, t + 1)
def _build_tree(self, scores: ndarray, bin_edges: ndarray) -> Tree:
# Build tree with specified number of children at each level
tree = Tree()
tree.add_node(Node()) # root node
nodes_prev = [tree.get_node(tree.root)]
for level in range(self.depth):
nodes_current = []
for node in nodes_prev:
children = []
for _ in range(self.n_children[level]):
child = Node()
tree.add_node(child, parent=node)
children.append(child)
nodes_current.extend(children)
nodes_prev = nodes_current
assignments = np.digitize(scores, bin_edges) - 1
# Store instance ids in leaves
leaves = tree.leaves()
for k, node in enumerate(leaves):
instance_ids = np.where(assignments == k)[0]
if instance_ids.size == 0:
tree.remove_node(node.identifier)
else:
node.data = instance_ids
# Prune empty leaves
check_for_empty_leaves = True
while check_for_empty_leaves:
check_for_empty_leaves = False
leaves = tree.leaves()
for node in leaves:
if node.data is None and len(node.successors(
tree.identifier)) == 0:
# Node is empty and has no siblings
tree.remove_node(node.identifier)
check_for_empty_leaves = True
# Simplify tree: remove nodes that only have one child
for nid in tree.expand_tree(mode=tree.WIDTH):
children = tree.children(nid)
if len(children) == 1:
tree.link_past_node(nid)
return tree
def node2Tree(self, tuple1, tuple2, tuple3):
t = Tree()
#Id of each node = freq of that node(i[1])
#Node(tag,identifier(ID)) #create_node(tag,identifier(ID),parent)
#Nodes added in decreasing order of Frequency
node1 = Node(tuple1, tuple1[0])
node2 = Node(tuple2, tuple2[0])
node3 = Node(tuple3, tuple3[0])
freq = tuple1[1] + tuple2[1] + tuple3[1]
tag = tuple1[0] + tuple2[0] + tuple3[0]
t.create_node("(" + str(tag) + ", " + str(freq) + ")", tag, None)
#Addded the nodes as left right mid according to there frequency
#so the first node has always the highest frequency
if tuple1[1] >= tuple2[1] and tuple1[1] >= tuple3[1]:
if tuple2[1] >= tuple3[1]:
t.add_node(node1, tag)
t.add_node(node2, tag)
t.add_node(node3, tag)
else:
t.add_node(node1, tag)
t.add_node(node3, tag)
t.add_node(node2, tag)
elif tuple2[1] >= tuple3[1] and tuple2[1] >= tuple1[1]:
if tuple1[1] >= tuple3[1]:
t.add_node(node2, tag)
t.add_node(node1, tag)
t.add_node(node3, tag)
else:
t.add_node(node2, tag)
t.add_node(node3, tag)
t.add_node(node1, tag)
else:
if tuple1[1] >= tuple2[1]:
t.add_node(node3, tag)
t.add_node(node1, tag)
t.add_node(node2, tag)
else:
t.add_node(node3, tag)
t.add_node(node2, tag)
t.add_node(node1, tag)
#t.show()
return t
def parseDigit():
nonlocal ast, curr_node
if match(cst_nodes[curr_cst_node].data.type_, 'T_digit'):
cst_nodes[curr_cst_node].data.type_ = 'T_k_int'
digit_node = Node(cst_nodes[curr_cst_node].tag,
data=cst_nodes[curr_cst_node].data)
nextCSTNode()
return digit_node
else:
pass
def __init__(self, holes=0):
self.data = np.zeros((3, 3, 3, 3), dtype='int')
element = range(3)
order = direct_product(element, element, element, element)
i = 0
genTree = Tree()
root = Node(i, 'root', data=[order[0], self.data.copy()])
genTree.add_node(root)
currentNode = root
getData = lambda node: node.data[1][tuple(node.data[0])]
while i < len(order):
i += 1
a, b, c, d = order[i - 1]
numPool = pool(self.data, a, b, c, d) - set(
map(getData, genTree.children(currentNode.identifier)))
if numPool:
self.data[a, b, c, d] = np.random.choice(list(numPool))
node = Node(i, data=[order[i - 1], self.data.copy()])
genTree.add_node(node, currentNode)
currentNode = node
else:
prev = genTree.parent(currentNode.identifier)
while len(genTree.children(prev.identifier)) == len(
pool(prev.data[1], *(prev.data[0]))):
currentNode = prev
prev = genTree.parent(currentNode.identifier)
else:
currentNode = prev
self.data = currentNode.data[1].copy()
i = currentNode.tag
continue
h = np.random.choice(len(order), size=holes, replace=False)
self._answer = self.data.copy()
self.holes = np.array(order)[h]
self.data[tuple(self.holes.T.tolist())] = 0
def help_func_return(grammar, tokens, function=None):
tree = Tree()
return_node = Node(tag=tokens[0][1])
tree.add_node(return_node, parent=None)
skip_tokens = 0
if (tokens[1][0] != ';'):
expr_help_out = help_func_expression(grammar,
tokens[1:],
function=function)
tree.paste(return_node.identifier, expr_help_out[0])
skip_tokens = expr_help_out[1]
return [tree, skip_tokens + 2]
def most_similarity_nodes(T1, T2):
node_pairs = {}
for node1 in T1.all_nodes_itr():
highest_simil = -1
similar_node = Node()
for node2 in T2.all_nodes_itr():
node_simil = node_similarity(node1, node2)
if highest_simil < node_simil:
highest_simil = node_simil
similar_node = node2
node_pairs[node1] = similar_node
return node_pairs
def parseBoolVal():
nonlocal ast, curr_node
bool_node = None
if match(cst_nodes[curr_cst_node].data.type_, 'T_k_true') or match(
cst_nodes[curr_cst_node].data.type_, 'T_k_false'):
cst_nodes[curr_cst_node].data.type_ = 'T_k_boolean'
bool_node = Node(cst_nodes[curr_cst_node].tag,
data=cst_nodes[curr_cst_node].data)
nextCSTNode()
else:
pass
if bool_node:
return bool_node
def generate_expression(self, length: int) -> str:
self.state = State(target_len=length,
root_node=Node(tag="root", identifier=0))
logging.debug("Starting generation...")
self.__choose_generation_type()
self.__fix_length()
logging.debug(string_serializer.debug_serialize(self.state.tree))
logging.info("Result: {}".format(
string_serializer.serialize(self.state.tree)))
return string_serializer.serialize(self.state.tree)
def create_branch(tree_structure, types):
if not (tree_structure, types):
return
previous = None
for class_type in types:
node = Node(identifier=class_type, data=[])
if previous is None:
if tree_structure.get_node(node.identifier) is None:
tree_structure.add_node(node)
else:
if tree_structure.get_node(node.identifier) is None:
tree_structure.add_node(node, previous.identifier)
previous = node
def run_parser(tokens,
grammar,
look_for_brace=False,
root_name="program",
clear_symbol_table=False):
# Create dictionary of symbol tables
global __symbol_tables
if (clear_symbol_table):
__symbol_tables = {}
# Create base abstract syntax tree
tree = Tree()
# create root node
root = Node(tag=root_name)
tree.add_node(root, parent=None)
num_tokens_to_skip = 0
list_of_tokens = []
for i in range(0, len(tokens)):
if (num_tokens_to_skip > 0):
num_tokens_to_skip -= 1
continue
if (look_for_brace and tokens[i][0] == "}"):
break
list_of_tokens.append(tokens[i]) # append token and metadata
result = check_rules("program", list_of_tokens, grammar)
if (result[0] > 1): #matches more than one possible rule
continue
elif (result[0] == 1): #matches one possible rule
help_fun_tuple = help_func_manager(
result, grammar, tokens[i - len(list_of_tokens) + 1:])
sub_tree = help_fun_tuple[0]
num_tokens_to_skip = help_fun_tuple[1] - len(list_of_tokens)
tree.paste(root.identifier, sub_tree)
#call helper function
list_of_tokens = []
elif (result[0] == 0):
#matches zero rules. parser crash
tree.show(key=lambda x: x.identifier, line_type='ascii')
print("ERRONEOUS RESULT:", result)
print("ERRONEOUS TOKEN LIST:", list_of_tokens)
raise Exception(errors.ERR_NO_RULE + " '" + tokens[i][0] +
"' on line " + str(tokens[i][2]))
return [tree, num_tokens_to_skip, __symbol_tables]
def __init__(self, file_path):
self.ERROR = 0
self.RIGHT = 1
self.path = file_path
self.lexer = Lexer(file_path)
self.token = Token(Token_Type.ERRTOKEN, "", 0.0, None)
self.state = self.RIGHT
self.count = 0
self.iters = 0
self.origin_x = 0.0
self.origin_y = 0.0
self.rot_ang = 0.0
self.scale_x = 1.0
self.scale_y = 1.0
self.tree = Tree()
self.root = Node()
def AddNode(node_as_dict, tree_class_tree_funct_arg):
parsed_data = ParseNodeName(node_as_dict['name'])
node_as_node_class = Node(tag=parsed_data['sample_name'],
identifier=node_as_dict['id'],
data={
'country': parsed_data['country'],
'haplotype': parsed_data['haplotype'],
'date': parsed_data['date']
}) # no data yet
if node_as_dict['parentid'] == -1:
tree_class_tree_funct_arg.add_node(node_as_node_class, parent=None)
else:
tree_class_tree_funct_arg.add_node(node_as_node_class,
parent=node_as_dict['parentid'])
for child_node in node_as_dict['children']:
AddNode(child_node, tree_class_tree_funct_arg)
return tree_class_tree_funct_arg
def addScheduleTree(self, FlatTree):
length = len(self._nodes)
if isinstance(FlatTree, str):
FlatTree = StringIO(FlatTree)
FlatTree = ResultTrees.ImTreeUtil.read_csv(FlatTree)
self.FlatTree = self.FlatTree.append(FlatTree.iloc[1:]).reset_index(drop=True)
it = FlatTree.iterrows()
i = 0
data = ImNodeData(it.__next__()) # Throw Away root
data = ImNodeData(it.__next__())
self.create_node(tag = str(data), identifier=length, data=data, parent=0)
self.get_node(0).data.ExposureAmount += data.ExposureAmount
self.get_node(0).tag=str(self.get_node(0).data)
for row in it:
data=ImNodeData(row)
i += 1
node = Node(tag=str(data), identifier=i+length, data=data)
parent_id = self.identify_parent_id(node)
self.add_node(node, parent_id)
def __init__(self, FlatTree):
self.hasEulerAllocation = False
self.hasStandaloneAllocation = False
#if it isn't a String it should be a pandas Dataframe
if isinstance(FlatTree, str):
FlatTree = StringIO(FlatTree)
FlatTree = ResultTrees.ImTreeUtil.read_csv(FlatTree)
self.FlatTree = FlatTree
super(ImTree, self).__init__()
it = FlatTree.iterrows()
i = 0
data = ImNodeData(it.__next__())
self.create_node(tag=str(data), identifier=i, data=data)
while i<(FlatTree.shape[0] - 1):
i = i + 1
data = ImNodeData(it.__next__())
node = Node(tag=str(data), identifier=i, data=data)
parent_id = self.identify_parent_id(node)
self.create_node(tag = str(data), identifier=i, data=data, parent=parent_id)
def fit(self):
y = self.y
preds = np.zeros(len(y))
def fit_leaf(preds, y, i):
optimizer = self.optimizers[self.generator.randint(
0,
len(self.optimizers) - 1)](learning_rate=self.learning_rate)
model = network_builder(layers=self.layers,
ending_units=self.ending_units)
model.compile(loss=self.loss,
optimizer=optimizer,
metrics=self.metrics)
model.fit(self.X,
y,
epochs=self.epochs * (i + 1),
callbacks=[self.early_stop] if self.early_stop else [])
new_preds = preds + model.predict(self.X).reshape(-1)
new_y = self.y - new_preds
return new_preds, new_y, model
def fit_tree(k, preds, y, i, parent=None):
if k > 0:
l_preds, l_y, l_model = fit_leaf(preds, y, i)
self.tree.add_node(Node(identifier=parent + 'l' + str(k),
data=l_model),
parent=parent)
fit_tree(k - 1, l_preds, l_y, i + 1, parent + 'l' + str(k))
r_preds, r_y, r_model = fit_leaf(preds, y, i)
self.tree.add_node(Node(identifier=parent + 'r' + str(k),
data=r_model),
parent=parent)
fit_tree(k - 1, r_preds, r_y, i + 1, parent + 'r' + str(k))
i = 0
preds, y, root_model = fit_leaf(preds, y, i)
self.tree.add_node(Node(identifier='root', data=root_model))
fit_tree(self.k, preds, y, i + 1, parent='root')
def originstatement(self, node):
'''
OriginStatment → ORIGIN is
L_BRACKET Expression COMMA Expression R_BRACKET
'''
print('--Enter originstatement--')
temp_node = Node(tag=' ')
if (self.token.type == Token_Type.ORIGIN):
temp_node = self.add_node('ORIGIN', node)
self.token = self.lexer.getToken()
if (self.token.type == Token_Type.IS):
self.token = self.lexer.getToken()
temp_node = self.add_node('IS', node)
if (self.token.type == Token_Type.L_BRACKET):
temp_node = self.add_node('L_BRACKET', node)
self.token = self.lexer.getToken()
temp_node = self.add_node('Expression', node)
self.expression(temp_node)
# self.token = self.lexer.getToken ()
self.typecheck(Token_Type.COMMA)
temp_node = self.add_node('COMMA', node)
self.token = self.lexer.getToken()
temp_node = self.add_node('Expression', node)
self.expression(temp_node)
# self.token = self.lexer.getToken ()
if (self.token.type != Token_Type.R_BRACKET):
self.state = self.ERROR
temp_node = self.add_node('R_BRACKET', node)
self.token = self.lexer.getToken()
else:
self.state = self.ERROR
else:
self.state = self.ERROR
print(self.state)
print('--End originstatement--')
def run_simulation(self, board, player):
tree = self.MCTS_tree
node = self.HeadNode
availables = board.get_k_dist_empty_tuple(2)
visited_states = set()
winner = -1
expand = True
# Simulation Start
for t in range(1, self.max_actions + 1):
availables = board.get_k_dist_empty_tuple(2)
children = tree.children(node.identifier)
self.plays = {}
self.wins = {}
plays = self.plays
wins = self.wins
for n in children:
plays[n.tag] = n.data[0]
wins[n.tag] = n.data[1]
# Selection
noused_set = self.select_noused_node(availables, player)
if len(noused_set) == 0:
#print("ok")
#print(sum(plays[(player,move)] for move in availables))
log_total = log(
sum(plays[(player, move)] for move in availables))
value, move = max(
((wins[(player, move)] / plays[(player, move)]) +
sqrt(self.confidence * log_total / plays[(player, move)]),
move) for move in availables)
#print(move)
for n in children:
if n.tag == (player, move):
node = n
else:
#print('good')
random.shuffle(noused_set)
move = noused_set.pop()
new_node = Node(tag=(player, move), data=[0, 0])
tree.add_node(new_node, parent=node)
node = new_node
board.draw_xy(move[0], move[1], player)
#Expand
# if expand and (player,move,t) not in plays:
# expand = False
# plays[(player,move,t)] = 0
# wins[(player,move,t)] = 0
# if t > self.max_depth:
# self.max_depth = t
#visited_states.add((player,move))
availables = board.get_k_dist_empty_tuple(2)
is_full = not len(availables)
winner = board.anyone_win(move[0], move[1])
if winner is not EMPTY or is_full:
#print(str(move) + '----' + str(winner) + '-----' + str(player))
break
player = self.player_change(player)
while (node.is_root() == False):
if winner == self.player:
node.data[1] += 1
node.data[0] += 1
node = tree.parent(node.identifier)
def init_phase(rubik, steps_required=[]):
tree = Tree()
tree.add_node(Node(identifier=rubik.copy(), tag={'steps': steps_required}))
return tree
def setUp(self):
self.node1 = Node("Test One", "identifier 1")
self.node2 = Node("Test Two", "identifier 2")
def load(path):
gtype = None
graph = None
nodes = []
#TEMP: LOAD FILE FROM PATH#
file = open(path,"r",0)
#TEMP#
gtype = file.next()
gtype = int(gtype)
if (gtype == 0):
graph = Tree()
nodes = []
if (gtype == 1):
graph = digraph()
graph.nodeAttrs = []
graph.edgeAttrs = []
for linenum,line in enumerate(file):
if (linenum == 0):
parts = line.split()
nodeAttrs = parts[1].split(';')
numNodeAttrs = nodeAttrs.pop(0)
graph.nodeAttrs = nodeAttrs
continue
if (linenum == 1):
for node in line.split():
tokens = node.split(';')
index = tokens.pop(0)
if (isInt(index)):
index = int(index)
if (gtype == 0):
nodes.append(Node(identifier=index,data=tokens))
if (index == 0):
graph.add_node(nodes[0])
if (gtype == 1):
graph.add_node(index, attrs=tokens)
continue
if (linenum == 2):
if (gtype == 0):
numEdges = int(line)
if (gtype == 1):
parts = line.split()
lineAttrs = parts[1].split(';')
numLineAttrs = lineAttrs.pop(0)
continue
if (linenum > 2):
#CHECK THAT PARTS ARE INT
parts = line.split()
tail = int(parts[0])
head = int(parts[1])
if (gtype == 0):
graph.add_node(nodes[head],tail)
if (gtype == 1):
attributes = parts[2].split(';')
weight = attributes.pop(0)
graph.add_edge((tail,head),weight,attrs=attributes)
return graph
