Finalize Hunt's algorithm script

Author: RoundofThree

huntsDT/README.md

@@ -1,3 +1,152 @@
 # Hunt's algorithm to build Decision Trees 
 
-Build a Decision Tree by splitting based on GINI index. Also outputs the GINI values to explain why the algo chose some attribute. 
+Build a Decision Tree by splitting based on GINI index. Also outputs the GINI values to explain why the algo chose some attribute. 
+
+## Example 
+
+Input:
+
+*Note*: The last column must be the class identifier
+
+```bash
+python3 huntDT_driver.py -v --table_csv table.csv
+```
+
+Output:
+
+*Note*: Each node in the tree is represented as (attribute column number that this node was previously splitted: attribute value). That's why the root node is always (0: None). 
+
+```
+Gini split for 0: 0.48
+Gini split for 1: 0.16250000000000003
+Gini split for 2: 0.4789285714285715
+Choose att 1
+     Gini split for 0: 0.375
+     Gini split for 2: 0.0
+     Choose att 2
+          Gini split for 0: 0.0
+          Choose att 0
+          Gini split for 0: 0.0
+          Choose att 0
+          Gini split for 0: 0.0
+          Choose att 0
+     Gini split for 0: 0.21428571428571433
+     Gini split for 2: 0.16666666666666666
+     Choose att 2
+          Gini split for 0: 0.3333333333333333
+          Choose att 0
+          Gini split for 0: 0.0
+          Choose att 0
+          Gini split for 0: 0.0
+          Choose att 0
+     Gini split for 0: 0.0
+     Gini split for 2: 0.0
+     Choose att 0
+          Gini split for 2: 0.0
+          Choose att 2
+          Gini split for 2: 0.0
+          Choose att 2
+|-> (0: None)
+
+     |-> (1: High)
+
+          |-> (2: Poor)
+
+               |-> (0: F)
+
+               |-> (0: M)
+
+                    |-> (B: 1)
+
+                    |-> (A: 0)
+
+          |-> (2: Fair)
+
+               |-> (0: F)
+
+               |-> (0: M)
+
+                    |-> (B: 0)
+
+                    |-> (A: 1)
+
+          |-> (2: Excellent)
+
+               |-> (0: F)
+
+               |-> (0: M)
+
+                    |-> (B: 2)
+
+                    |-> (A: 0)
+
+     |-> (1: Low)
+
+          |-> (2: Poor)
+
+               |-> (0: F)
+
+                    |-> (B: 1)
+
+                    |-> (A: 1)
+
+               |-> (0: M)
+
+                    |-> (B: 1)
+
+                    |-> (A: 0)
+
+          |-> (2: Fair)
+
+               |-> (0: F)
+
+                    |-> (B: 2)
+
+                    |-> (A: 0)
+
+               |-> (0: M)
+
+          |-> (2: Excellent)
+
+               |-> (0: F)
+
+                    |-> (B: 3)
+
+                    |-> (A: 0)
+
+               |-> (0: M)
+
+     |-> (1: Medium)
+
+          |-> (0: F)
+
+               |-> (2: Poor)
+
+               |-> (2: Fair)
+
+                    |-> (B: 0)
+
+                    |-> (A: 2)
+
+               |-> (2: Excellent)
+
+                    |-> (B: 0)
+
+                    |-> (A: 1)
+
+          |-> (0: M)
+
+               |-> (2: Poor)
+
+                    |-> (B: 0)
+
+                    |-> (A: 3)
+
+               |-> (2: Fair)
+
+               |-> (2: Excellent)
+
+                    |-> (B: 0)
+
+                    |-> (A: 2)
+```

huntsDT/huntDS.py

@@ -0,0 +1,101 @@
+import numpy as np 
+
+
+class Node:
+    def __init__(self, records, visited=None):
+        self.records = records 
+        self.attribute_id = 0 
+        self.attribute_val = None 
+        self.children = []
+        self.visited = visited or [False for i in range(len(records)-1)]
+
+    def set_attribute(self, att_id, att_val):
+        self.attribute_id = att_id
+        self.attribute_val = att_val
+
+    def add_child(self, node):
+        self.children.append(node)
+
+    def display(self, level=0):
+        out = level * 5 * ' '
+        out += f"|-> ({self.attribute_id}: {self.attribute_val})"
+        out += "\n"
+        print(out)
+        for child in self.children:
+            child.display(level=level+1) 
+    
+
+class HuntDT:
+    def __init__(self, records=[], verbose=False):
+        self.records = records 
+        self.verbose = verbose
+        # build domain of each attribute: att id -> list of str 
+        self.domains = [self.domain(i) for i in range(len(records[0]))]
+
+    # return set of different values the attribute can take 
+    def domain(self, att_id):
+        s = set()
+        for r in self.records:
+            s.add(r[att_id])
+        return s
+
+    # build tree
+    def build(self):
+        root = Node(self.records)
+        root = self.build_tree(root)
+        return root 
+
+    def build_tree(self, node, level=0):
+        split_att = self.select(node, level)
+        if split_att == -1: return node 
+        visited = node.visited.copy() 
+        visited[split_att] = True 
+        for val in self.domains[split_att]:
+            group = filter(lambda r: r[split_att]==val, node.records)
+            child = Node(list(group), visited=visited) 
+            child.set_attribute(split_att, val)
+            node.add_child(self.build_tree(child, level+1))
+        return node 
+
+    # select based on gini split index 
+    def select(self, node, level=0):
+        records = node.records
+        if len(records) == 0: return -1
+        min_gini = np.inf 
+        chosen = -1 
+        for att_id in range(len(self.domains)-1):
+            if node.visited[att_id]: continue 
+            gini = self.gini_index(records, att_id)
+            if self.verbose:
+                margin = level * 5 * ' '
+                # print(f"{margin}At state {node.visited}")
+                print(f"{margin}Gini split for {att_id}: {gini}")
+            if gini < min_gini:
+                min_gini = gini 
+                chosen = att_id 
+        if chosen != -1 and self.verbose: print(f"{level*5*' '}Choose att {chosen}")
+        else:
+            # find the frequency of classes 
+            for class_id in self.domains[-1]:
+                count = len(list(filter(lambda r: r[-1]==class_id, records)))
+                child = Node(records)
+                child.set_attribute(class_id, count)
+                node.add_child(child)
+        return chosen
+
+    def gini_index(self, records, split_att_id):
+        n_records = len(records)
+        gini = 0.0
+        # split records by attribute 
+        for val in self.domains[split_att_id]:
+            group = list(filter(lambda r: r[split_att_id]==val, records))
+            if len(group) == 0:
+                continue 
+            squared_sum = 0.0
+            classes = [r[-1] for r in group]
+            for class_id in self.domains[-1]:
+                p = classes.count(class_id) / len(group)
+                squared_sum += p * p 
+            gini += (1.0 - squared_sum) * (len(group)/n_records)
+        return gini 
+

huntsDT/huntDT.py

@@ -1,12 +1,31 @@
 import argparse
-from huntDS import * 
+import csv
+from huntDT import * 
 
 def main():
     parser = argparse.ArgumentParser(description="Hunt's algorithm walkthrough. By Roundofthree.")
     parser.add_argument("-v", action='store_true', help="Print the intermediate GINI indexes.")
-    parser.add_argument("--table_csv", type=str, help="File path to a .csv file with the records.")
+    parser.add_argument("--table_csv", type=str, required=True, help="File path to a .csv file with the records.")
     arg = parser.parse_args()
-    verbose = arg.v   
+    verbose = arg.v
+    table_csv = arg.table_csv 
+    records = []
+
+    with open(table_csv, 'r') as f:
+        f = csv.reader(f, delimiter=',')
+        for line in f:
+            r = [i for i in line]
+            records.append(r)
+
+    # n_records = len(records)
+    # n_attributes = len(records[0]) - 1 # minus class column
+
+    huntDT = HuntDT(records=records, verbose=verbose)
+    root = huntDT.build()
+    root.display() # display a tree with 
+    # |-> (att_id: att_val) 
+    #      |-> (att_id: att_val)
+
 
 if __name__ == '__main__':
     main()

huntsDT/huntDT_driver.py

@@ -0,0 +1,20 @@
+M,High,Fair,A
+M,Medium,Excellent,A
+M,Medium,Excellent,A
+M,Medium,Poor,A
+M,Medium,Poor,A
+M,Medium,Poor,A
+F,Medium,Fair,A
+F,Medium,Fair,A
+F,Medium,Excellent,A
+F,Low,Poor,A
+M,High,Poor,B
+M,High,Excellent,B
+M,High,Excellent,B
+M,Low,Poor,B
+F,Low,Fair,B
+F,Low,Fair,B
+F,Low,Excellent,B
+F,Low,Excellent,B
+F,Low,Excellent,B
+F,Low,Poor,B