import orange, orngTest, orngStat
import random
data = orange.ExampleTable("voting")
bayes = orange.BayesLearner(name="bayes")
tree = orange.TreeLearner(name="tree")
majority = orange.MajorityLearner(name="default")
learners = [bayes, tree, majority]
names = [x.name for x in learners]
def printResults(res):
CAs = orngStat.CA(res, reportSE=1)
for i in range(len(names)):
print "%s: %5.3f+-%5.3f " % (names[i], CAs[i][0], 1.96 * CAs[i][1]),
print
print "\nproportionsTest that will always give the same results"
for i in range(3):
res = orngTest.proportionTest(learners, data, 0.7)
printResults(res)
print "\nproportionsTest that will give different results, but the same each time the script is run"
myRandom = orange.RandomGenerator()
for i in range(3):
res = orngTest.proportionTest(learners,
data,
0.7,
randomGenerator=myRandom)
self.mainArea.layout().addWidget(self.sceneView)
# self.scene.setSceneRect(0,0,800,800)
self.navWidget = QWidget(None)
self.navWidget.setLayout(QVBoxLayout(self.navWidget))
scene = TreeGraphicsScene(self.navWidget)
self.treeNav = TreeNavigator(self.sceneView)
# self.treeNav.setScene(scene)
self.navWidget.layout().addWidget(self.treeNav)
# self.sceneView.setNavigator(self.treeNav)
self.navWidget.resize(400, 400)
# OWGUI.button(self.TreeTab,self,"Navigator",self.toggleNavigator)
if __name__ == "__main__":
a = QApplication(sys.argv)
ow = OWDefTreeViewer2D()
#data = orange.ExampleTable('../../doc/datasets/voting.tab')
data = orange.ExampleTable(r"..//doc//datasets//zoo.tab")
data = orange.ExampleTable(r"..//doc//datasets//iris.tab")
tree = orange.TreeLearner(data, storeExamples=1)
ow.activateLoadedSettings()
ow.ctree(None)
ow.ctree(tree)
# here you can test setting some stuff
ow.show()
a.exec_()
ow.saveSettings()
# Description: Builds a classification tree, and prunes it using minimal error
# prunning with different values of parameter m. Prints
# out m and the size of the tree.
# a tree in text and dot format
# Category: modelling
# Uses: iris
# Referenced: orngTree.htm
import orange, orngTree
data = orange.ExampleTable("../datasets/adult_sample.tab")
tree = orange.TreeLearner(data)
prunner = orange.TreePruner_m()
trees = [(0, tree.tree)]
for m in [0.0, 0.1, 0.5, 1, 5, 10, 50, 100]:
prunner.m = m
trees.append((m, prunner(tree)))
for m, t in trees:
print "m = %5.3f: %i nodes, %i leaves" % (m, t.treesize(), orngTree.countLeaves(t))
# Description: Shows how to derive a Python class from orange.TreeStopCriteria
# Category: classification, callbacks to Python
# Classes: TreeStopCriteria
# Uses: lenses
# Referenced: callbacks.htm
import orange, orngMisc, orngTree
data = orange.ExampleTable("lenses")
from random import randint, seed
seed(0)
defStop = orange.TreeStopCriteria()
treeLearner = orange.TreeLearner()
treeLearner.stop = lambda exs, wID, cont: defStop(exs, wID, cont) or randint(1, 5)==1
print "\n\nTree build with stop criteria as a function"
tree = treeLearner(data)
orngTree.printTxt(tree)
class StoppingCriterion_random(orange.TreeStopCriteria):
def __call__(self, gen, weightID, contingency):
return orange.TreeStopCriteria.__call__(self, gen, weightID, contingency) \
or randint(1, 5)==1
print "\n\nTree build with stop criteria as a class"
treeLearner.stop = StoppingCriterion_random()
tree = treeLearner(data)
orngTree.printTxt(tree)
folds = 10
for train_context, test_context in cv_split(context,
folds=folds,
random_seed=0):
# Find features on the train set
conv = RSDConverter(train_context)
rsd = RSD()
features, train_arff, _ = rsd.induce(
conv.background_knowledge(), # Background knowledge
examples=conv.all_examples(), # Training examples
cn2sd=False # Disable built-in subgroup discovery
)
# Train the classifier on the *train set*
train_data = arff_to_orange_table(train_arff)
tree_classifier = orange.TreeLearner(train_data, max_depth=5)
# Map the *test set* using the features from the train set
test_arff = mapper.domain_map(features,
'rsd',
train_context,
test_context,
format='arff')
# Classify the test set
test_data = arff_to_orange_table(test_arff)
fold_predictions = [(ex[-1], tree_classifier(ex)) for ex in test_data]
predictions.append(fold_predictions)
acc = 0
for fold_predictions in predictions:
# Description: Shows how to construct new attributes from the existing and use it seamlessly in sampling and testing
# Category: feature construction, constructive induction
# Classes: Variable, MakeRandomIndices2
# Uses: monk1
# Referenced: Variable.htm
import orange, orngTree
data = orange.ExampleTable("monk1")
indices = orange.MakeRandomIndices2(data, p0=0.7)
trainData = data.select(indices, 0)
testData = data.select(indices, 1)
e2 = orange.EnumVariable("e2", values=["not 1", "1"])
e2.getValueFrom = lambda example, returnWhat: \
orange.Value(e2, example["e"]=="1")
newDomain = orange.Domain(
[data.domain["a"], data.domain["b"], e2, data.domain.classVar])
newTrain = orange.ExampleTable(newDomain, trainData)
tree = orange.TreeLearner(newTrain)
orngTree.printTxt(tree)
for ex in testData[:10]:
print ex.getclass(), tree(ex)
import sys
sys.path.append('../')
import database
import warnings
warnings.simplefilter("ignore")
import math
from queryconstructor import QueryConstructor
from plotconstructor import *
import orange
warnings.filterwarnings("ignore", "", orange.AttributeWarning)
learner_data = orange.ExampleTable("learner_data")
print "starting learning"
treeLearner = orange.TreeLearner(learner_data)
majorityLearner = orange.MajorityLearner(learner_data)
print "done with learning"
eval_data = orange.ExampleTable("eval_data")
total=0.0
total_lame=0.0
total_true=0.0
count=0.0
print "starting evaluation"
for i in eval_data:
actual = i.getclass()
if (treeLearner(i)==actual):
total+=1
if (majorityLearner(i)==actual):
total_lame+=1
# Description: Shows the structure that represents decision trees in Orange
# Category: learning, decision trees, classification
# Classes: TreeLearner, TreeClassifire, TreeNode,
# Uses: lenses
# Referenced: TreeLearner.htm
import orange
data = orange.ExampleTable("lenses")
treeClassifier = orange.TreeLearner(data)
def treeSize(node):
if not node:
return 0
size = 1
if node.branchSelector:
for branch in node.branches:
size += treeSize(branch)
return size
print "Tree size:", treeSize(treeClassifier.tree)
def printTree0(node, level):
if not node:
print " "*level + "<null node>"
return
if node.branchSelector:
def instance(self):
learner = orange.TreeLearner()
hasSplit = hasattr(self, "split")
if hasSplit:
learner.split = self.split
else:
learner.split = orange.TreeSplitConstructor_Combined()
learner.split.continuousSplitConstructor = orange.TreeSplitConstructor_Threshold(
)
binarization = getattr(self, "binarization", 0)
if binarization == 1:
learner.split.discreteSplitConstructor = orange.TreeSplitConstructor_ExhaustiveBinary(
)
elif binarization == 2:
learner.split.discreteSplitConstructor = orange.TreeSplitConstructor_OneAgainstOthers(
)
else:
learner.split.discreteSplitConstructor = orange.TreeSplitConstructor_Attribute(
)
measures = {
"infoGain": orange.MeasureAttribute_info,
"gainRatio": orange.MeasureAttribute_gainRatio,
"gini": orange.MeasureAttribute_gini,
"relief": orange.MeasureAttribute_relief,
"retis": orange.MeasureAttribute_MSE
}
measure = getattr(self, "measure", None)
if type(measure) == str:
measure = measures[measure]()
if not hasSplit and not measure:
measure = orange.MeasureAttribute_gainRatio()
measureIsRelief = type(measure) == orange.MeasureAttribute_relief
relM = getattr(self, "reliefM", None)
if relM and measureIsRelief:
measure.m = relM
relK = getattr(self, "reliefK", None)
if relK and measureIsRelief:
measure.k = relK
learner.split.continuousSplitConstructor.measure = measure
learner.split.discreteSplitConstructor.measure = measure
wa = getattr(self, "worstAcceptable", 0)
if wa:
learner.split.continuousSplitConstructor.worstAcceptable = wa
learner.split.discreteSplitConstructor.worstAcceptable = wa
ms = getattr(self, "minSubset", 0)
if ms:
learner.split.continuousSplitConstructor.minSubset = ms
learner.split.discreteSplitConstructor.minSubset = ms
if hasattr(self, "stop"):
learner.stop = self.stop
else:
learner.stop = orange.TreeStopCriteria_common()
mm = getattr(self, "maxMajority", 1.0)
if mm < 1.0:
learner.stop.maxMajority = self.maxMajority
me = getattr(self, "minExamples", 0)
if me:
learner.stop.minExamples = self.minExamples
for a in [
"storeDistributions", "storeContingencies", "storeExamples",
"storeNodeClassifier", "nodeLearner", "maxDepth"
]:
if hasattr(self, a):
setattr(learner, a, getattr(self, a))
return learner