def test_print(self):
m1 = Module('a', ModuleType.HARD, Dimensions(1, 1), Vector2(0, 0))
m2 = Module('b', ModuleType.HARD, Dimensions(1, 1), Vector2(0, 0))
n2 = Node(m2)
n1 = Node(m1, right=n2)
t = Tree(n1, [n1, n2])
t.print()
def init(self, _lines, _attributes):
self.attributes = CSV().createAttributeDict(_attributes, self.discretization)
lines = _lines
self.root = Node(0, 0, "", "")
lastNode = self.root
depth = 0
for line in lines:
if len(line)==0:
continue
d = len(line.split("|"))
condition = line.split("|")[-1].split(" : ")[0].strip(" ")
result = ""
if " : " in line and "(" in line:
result = line.split("|")[-1].strip(" ").split(" : ")[1].split("(")[0]
self.leaves += 1
# TODO: IF THE RESULT IS NOMIMAL, ADD ""
self.depth = max(d, self.depth)
if d>depth: # left child -> if
node = Node(lastNode, d, condition, result)
self.nodes += 1
lastNode.leftChild = node
lastNode = node
elif d<depth:
delta = depth - d
parent = lastNode.parent
for i in range(0, delta):
parent = parent.parent
node = Node(parent, d, "else", result)
self.nodes += 1
parent.rightChild = node
lastNode = node
else: # right child -> else
parent = lastNode.parent
node = Node(parent, d, "else", result)
parent.rightChild = node
lastNode = node
depth = d
return self.root
def __init__(self, game_map):
self.width = game_map.width
self.height = game_map.height
self.nodes_count = self.width * self.height
self.links_count = self.nodes_count * 4
self._nodes = [
Node(number, number % self.width, number // self.height)
for number in range(self.nodes_count)
]
self._links = []
self.build_links()
self._set_weight(game_map)
def test_insert3(self):
modules = [Module(str(i), ModuleType.HARD, Dimensions(100, 100), Vector2(0, 0)) for i in range(20)]
t = TreeBuilder.random_tree(modules, seed=1)
random.seed(1)
n = Node(Module(str(21), ModuleType.HARD, Dimensions(100, 100), Vector2(0, 0)))
p = None
insertLeft = False
print(f"inserting node {n.id} as root")
logging.getLogger("pyfloorplanner").setLevel(logging.DEBUG)
t.nodes.append(n)
t.insert(n, p, insertLeft)
def balanced_tree(modules: List[Module]) -> Tree:
nodes = [Node(m) for m in modules]
for i in range(len(modules)):
nodes[i].id = i
nodes[i].parent = nodes[int((i + 1) / 2 - 1)]
nodes[i].left = nodes[2 * i +
1] if 2 * i + 1 < len(modules) else None
nodes[i].right = nodes[2 * i +
2] if 2 * i + 2 < len(modules) else None
nodes[0].parent = None
root = nodes[0]
return Tree(root, nodes)
def random_tree(modules: List[Module], seed=None) -> Tree:
'''
Creates a random tree for the given list of modules
:param seed: Seed for randomness
:param modules: list of modules for to create nodes
:return: A B-tree
'''
random.seed(seed)
reset_node_id()
nodes = [Node(m) for m in modules]
queue = nodes.copy()
random.shuffle(nodes)
root = queue.pop()
# (node, True) for indicating that the left child of node is free, (node, False) for the right child of node
free_places = [(root, True), (root, False)]
while len(queue) > 0:
placement_node = queue.pop()
free_place = random.choice(free_places)
free_places.remove(free_place)
parent, left = free_place
# Place node in free place
if left:
parent.left = placement_node
else:
parent.right = placement_node
placement_node.parent = parent
free_places.extend([(placement_node, True),
(placement_node, False)])
return Tree(root, nodes)
def make_node(self, df: DataFrame, mainEntropy):
nodes = list()
attributes_info_gain = dict()
columns = df.columns[:-1]
for column in columns:
attributes_info_gain.update({
column:
self.calculate_attribute_entropy(column, df, mainEntropy)
})
best_attribute = max(attributes_info_gain,
key=attributes_info_gain.get)
values = df[best_attribute].unique().tolist()
if attributes_info_gain.get(
best_attribute
) < 0.05: #jeśli info gain mniejsze niż 0,05 nie ma sensu dzielić
return None # przerywam wykonane funkcji
for value in values:
tmp_df = df.loc[df[best_attribute] == value]
classes = tmp_df[tmp_df.columns[-1]].nunique()
if classes == 1 or len(
columns) == 1: # obiekty jednej klasy - robimy liść
node: Node = Node('leaf', '', tmp_df)
nodes.append(node)
else:
tmp_df = tmp_df.drop([best_attribute], axis=1)
node: Node = Node('node', '', tmp_df)
node_main_entropy = self.calculate_main_entropy(tmp_df)
children_nodes = self.make_node(tmp_df, node_main_entropy)
if children_nodes == None: # z aktualnego węzła robimy liść
counter = Counter(
([element for element in tmp_df[df.columns[-1]]]))
node = Node('leaf',
'',
tmp_df,
node_class=counter.most_common(1)[0][0])
nodes.append(node)
else:
node.add_children(children_nodes)
nodes.append(node)
return nodes
def build_tree(self):
mainEntropy = self.calculate_main_entropy(self.df)
root: Node = Node('root', '', self.df)
root.add_children(self.make_node(self.df, mainEntropy))