def plantclass(X, y, num):
"""
Input:
X - macierz z przykladami budujacymi drzewo
y - wektor z decyzjami
num - liczba cech, sposrod ktorych gini wybiera wartosc podzialu
Rekurencyjna funkcja budujaca drzewo. Wybiera wartosc podzialu na podstawie
wlasnosci Gini impurity. Budowanie drzewa konczy sie, kiedy wartosc Gini w wezle
jest rowna 0.0 - wtedy tez tworzone sa liscie z decyzjami.
"""
gini_tup = gini.gini(X, y, num)
if gini_tup[2] == 0:
set1, set2, y1, y2 = Tree.divideset(X, gini_tup[0], gini_tup[1], y)
if len(y1) == 0 and len(y2) > 0:
fbval = float(y2[0])
tbval = abs(fbval - 1)
elif len(y2) == 0 and len(y1) > 0:
tbval = float(y1[0])
fbval = abs(tbval - 1)
elif len(y1) > 0 and len(y2) > 0:
tbval = y1[0]
fbval = y2[0]
return node.Node(tb=leaf.Leaf(tbval),
fb=leaf.Leaf(fbval),
value=gini_tup[1],
index=gini_tup[0],
gn=gini_tup[2])
else:
set1, set2, y1, y2 = Tree.divideset(X, gini_tup[0], gini_tup[1], y)
if len(set1) != 0:
trueBranch = Tree.plantclass(set1, y1, num)
else:
trueBranch = leaf.Leaf(random.randint(0, 1))
if len(set2) != 0:
falseBranch = Tree.plantclass(set2, y2, num)
else:
falseBranch = leaf.Leaf(random.randint(0, 1))
return node.Node(tb=trueBranch,
fb=falseBranch,
value=gini_tup[1],
index=gini_tup[0],
gn=gini_tup[2])
def test_08_three_level(self):
# start a new three level tree
seq = [8, 5, 1, 7, 3, 12, 2, 10, 4, 9, 6, 11]
TestBTree.node = leaf.Leaf([])
for n in seq:
TestBTree.node = TestBTree.node.insert(n)
seq.sort()
assert seq == TestBTree.node.get() and TestBTree.node.depth() == 3
def test_02_insert(self):
TestBTree.node = leaf.Leaf([])
for n in [8, 5, 1, 7, 3]:
TestBTree.node = TestBTree.node.insert(n)
all = TestBTree.node.get()
assert all == [1, 3, 5, 7, 8] and TestBTree.node.depth() == 2
def Draw(self):
vs.BeginXtrd(0,self.thickness)
vs.Rect(-self.width/2.0, self.height/2.0, self.width/2.0, self.height/2.0-self.thickness)
r1 = vs.LNewObj()
vs.Rect(-self.width/2.0, self.height/2.0-self.thickness, -self.width/2.0+self.thickness, -self.height/2.0+self.thickness)
r2 = vs.LNewObj()
r2 = vs.AddSurface(r1, r2)
vs.Rect(self.width/2.0-self.thickness, self.height/2.0-self.thickness, self.width/2.0, -self.height/2.0+self.thickness)
r3 = vs.LNewObj()
r3 = vs.AddSurface(r2,r3)
vs.Rect(-self.width/2.0, -self.height/2.0+self.thickness, self.width/2.0, -self.height/2.0)
r4 = vs.LNewObj()
r4 = vs.AddSurface(r3,r4)
if (self.wingsNum == 2):
vs.Rect(-self.thickness/2.0, self.height/2.0-self.thickness, self.thickness/2.0, -self.height/2.0+self.thickness)
r5 = vs.LNewObj()
r4 = vs.AddSurface(r4,r5)
vs.EndXtrd()
vs.SetRot3D(vs.LNewObj(), 90, 0, 0, 0, -self.height/2.0, 0)
vs.Move3DObj(vs.LNewObj(), 0, self.height/2.0+self.thickness/2.0, 0)
vs.Move3DObj(vs.LNewObj(), 0, 0, self.elevation)
#instert leafs
upi = vs.GetPrefReal(152) / 25.4
leafPosOffsetY = self.thickness - leaf.Leaf.kFrameThicknessNotUPI*upi
posFirstLeaf = (-self.width/2.0+self.thickness,
-self.thickness/2.0+leafPosOffsetY,
self.elevation+self.thickness )
if self.wingsNum == 0:
wingsWidth = self.width - 2.0*self.thickness
wingsHeight = self.height - 2.0*self.thickness
firstLeaf = leaf.Leaf(wingsWidth, wingsHeight, posFirstLeaf)
firstLeaf.SetType(leaf.kTypeNone, self.isGlass)
firstLeaf.Draw()
elif self.wingsNum == 1:
wingsWidth = self.width - 2.0*self.thickness
wingsHeight = self.height - 2.0*self.thickness
firstLeaf = leaf.Leaf(wingsWidth, wingsHeight, posFirstLeaf)
firstLeaf.SetType(leaf.kTypeLeft, self.isGlass)
firstLeaf.Draw()
firstLeaf.SetOpening(self.openingAngle)
elif self.wingsNum == 2:
wingsWidth = (self.width - 3.0*self.thickness)/2.0
wingsHeight = self.height - 2.0*self.thickness
firstLeaf = leaf.Leaf(wingsWidth, wingsHeight, posFirstLeaf)
firstLeaf.SetType(leaf.kTypeLeft, self.isGlass)
firstLeaf.Draw()
firstLeaf.SetOpening(self.openingAngle)
posSecondLeaf = (self.thickness/2.0, -self.thickness/2.0+leafPosOffsetY, self.elevation+self.thickness)
secondLeaf = leaf.Leaf(wingsWidth, wingsHeight, posSecondLeaf)
secondLeaf.SetType(leaf.kTypeRight, self.isGlass)
secondLeaf.Draw()
secondLeaf.SetOpening(self.openingAngle)
def plantreg(X, y, num):
"""
Input:
X - macierz z przykladami budujacymi drzewo
y - wektor z decyzjami
num - liczba cech, sposrod ktorych gini wybiera wartosc podzialu
Rekurencyjna funkcja budujaca drzewo. Wybiera wartosc podzialu na podstawie
wartosci RSS.
"""
rss_tup = rss.rss(X, y, num)
set1, set2, y1, y2 = Tree.divideset(X, rss_tup[0], rss_tup[1], y)
if rss_tup[2] == 100000000000000000:
if len(y1) == 0:
y1 = y2
if len(y2) == 0:
y2 = y1
y1avg = float(sum(y1)) / len(y1)
y2avg = float(sum(y2)) / len(y2)
return node.Node(tb=leaf.Leaf(y1avg),
fb=leaf.Leaf(y2avg),
value=rss_tup[1],
index=rss_tup[0],
gn=rss_tup[2])
if len(set1) > 3 and len(set2) > 3:
trueBranch = Tree.plantreg(set1, y1, num)
falseBranch = Tree.plantreg(set2, y2, num)
return node.Node(tb=trueBranch,
fb=falseBranch,
value=rss_tup[1],
index=rss_tup[0],
gn=rss_tup[2])
elif len(set1) > 3 and len(set2) <= 3:
trueBranch = Tree.plantreg(set1, y1, num)
y2avg = float(sum(y2)) / len(y2)
falseBranch = leaf.Leaf(y2avg)
return node.Node(tb=trueBranch,
fb=falseBranch,
value=rss_tup[1],
index=rss_tup[0],
gn=rss_tup[2])
elif len(set2) > 3 and len(set1) <= 3:
y1avg = float(sum(y1)) / len(y1)
trueBranch = leaf.Leaf(y1avg)
falseBranch = Tree.plantreg(set2, y2, num)
return node.Node(tb=trueBranch,
fb=falseBranch,
value=rss_tup[1],
index=rss_tup[0],
gn=rss_tup[2])
else:
if len(y1) == 0:
y1 = y2
if len(y2) == 0:
y2 = y1
y1avg = float(sum(y1)) / len(y1)
y2avg = float(sum(y2)) / len(y2)
return node.Node(tb=leaf.Leaf(y1avg),
fb=leaf.Leaf(y2avg),
value=rss_tup[1],
index=rss_tup[0],
gn=rss_tup[2])