def test_basic_performance(self):
data = orange.ExampleTable("iris.tab")
tic = time.time()
data = orange.ExampleTable("iris.tab")
l1 = orngSVM.SVMLearner()
l1.kernel_func = orngSVM.KernelWrapper(my_kernel)
l1.kernel_type = orange.SVMLearner.Custom
l1.probability = False
c1 = l1(data)
toc = time.time() - tic
print "With Wrapper: %s" % toc
tic = time.time()
l1 = SvmLearner()
l1.kernel = GbKernel(func=LinealKernel)
l1.probability = False
c1 = l1(data)
toc = time.time() - tic
print "Lambda Wrapper: %s" % toc
tic = time.time()
l1 = orngSVM.SVMLearner()
l1.kernel_type = orange.SVMLearner.Linear
l1.probability = False
c1 = l1(data)
toc = time.time() - tic
print "Native Wrapper: %s" % toc
def search_(self):
learner=orngSVM.SVMLearner()
for attr in ("name", "kernel_type", "degree", "shrinking", "probability", "normalization"):
setattr(learner, attr, getattr(self, attr))
for attr in ("gamma", "coef0", "C", "p", "eps", "nu"):
setattr(learner, attr, float(getattr(self, attr)))
learner.svm_type=0
if self.useNu:
learner.svm_type=1
params=[]
if self.useNu:
params.append("nu")
else:
params.append("C")
if self.kernel_type in [1,2]:
params.append("gamma")
if self.kernel_type==1:
params.append("degree")
try:
learner.tuneParameters(self.data, params, 4, verbose=0,
progressCallback=self.progres)
except UnhandledException:
pass
for param in params:
setattr(self, param, getattr(learner, param))
self.finishSearch()
def applySettings(self):
self.learner=orngSVM.SVMLearner()
for attr in ("name", "kernel_type", "degree", "shrinking", "probability", "normalization"):
setattr(self.learner, attr, getattr(self, attr))
for attr in ("gamma", "coef0", "C", "p", "eps", "nu"):
setattr(self.learner, attr, float(getattr(self, attr)))
self.learner.svm_type=orngSVM.SVMLearner.C_SVC
if self.useNu:
self.learner.svm_type=orngSVM.SVMLearner.Nu_SVC
if self.preprocessor:
self.learner = self.preprocessor.wrapLearner(self.learner)
self.classifier=None
self.supportVectors=None
if self.data:
if self.data.domain.classVar.varType==orange.VarTypes.Continuous:
self.learner.svm_type+=3
self.classifier=self.learner(self.data)
self.supportVectors=self.classifier.supportVectors
self.classifier.name=self.name
self.send("Learner", self.learner)
self.send("Classifier", self.classifier)
self.send("Support Vectors", self.supportVectors)
def test_integration_SVM(self):
data = orange.ExampleTable("iris.tab")
l1 = orngSVM.SVMLearner()
l1.kernel_func = orngSVM.KernelWrapper(MyKernel().my_kernel)
l1.kernel_type = orange.SVMLearner.Custom
l1.probability = True
c1 = l1(data)
def applySettings(self):
self.learner=orngSVM.SVMLearner()
for attr in ("name", "kernel_type", "degree", "shrinking", "probability", "normalization"):
setattr(self.learner, attr, getattr(self, attr))
for attr in ("gamma", "coef0", "C", "p", "eps", "nu"):
setattr(self.learner, attr, float(getattr(self, attr)))
self.learner.svm_type=orngSVM.SVMLearner.C_SVC
if self.useNu:
self.learner.svm_type=orngSVM.SVMLearner.Nu_SVC
self.classifier=None
self.supportVectors=None
if self.nomogram and self.data and self.data.domain.classVar.varType==orange.VarTypes.Discrete and \
len(self.data.domain.classVar.values)==2 and self.kernel_type==0:
import orngLR_Jakulin
self.learner=orngSVM.BasicSVMLearner()
for attr in ("name", "shrinking"):
setattr(self.learner, attr, getattr(self, attr))
for attr in ("gamma", "coef0", "C", "p", "eps", "nu"):
setattr(self.learner, attr, float(getattr(self, attr)))
self.learner.kernel=self.kernel_type
self.learner.for_nomogram=1
self.classifier=orngLR_Jakulin.MarginMetaLearner(self.learner, folds=1)(self.data)
self.classifier.name=self.name
self.classifier.domain=self.data.domain
self.classifier.data=self.data
self.supportVectors=self.data.getitemsref(self.classifier.classifier.model["SVi"])
elif self.data:
if self.data.domain.classVar.varType==orange.VarTypes.Continuous:
self.learner.svm_type+=3
self.classifier=self.learner(self.data)
self.supportVectors=self.classifier.supportVectors
self.classifier.name=self.name
if self.learner:
self.send("Learner", self.learner)
if self.classifier:
self.send("Classifier", self.classifier)
if self.supportVectors:
self.send("Support Vectors", self.supportVectors)
def applySettings(self):
if self.kernel_type == orngSVM.SVMLearner.Custom and None is self.kernel_func:
return
self.learner=orngSVM.SVMLearner()
parameters = {}
for attr in ("name", "kernel_type", "kernel_func", "degree", "shrinking", "probability", "normalization"):
setattr(self.learner, attr, getattr(self, attr))
parameters[attr] = getattr(self, attr)
for attr in ("gamma", "coef0", "C", "p", "eps", "nu"):
setattr(self.learner, attr, float(getattr(self, attr)))
parameters[attr] = getattr(self, attr)
self.learner.weight = ast.literal_eval(self.weight)
self.learner.svm_type=orngSVM.SVMLearner.C_SVC
if self.useNu:
self.learner.svm_type=orngSVM.SVMLearner.Nu_SVC
parameters["svm_type"] = orngSVM.SVMLearner.Nu_SVC
self.classifier=None
self.supportVectors=None
if self.data:
if self.data.domain.classVar.varType==orange.VarTypes.Continuous:
self.learner.svm_type+=3
self.classifier=self.learner(self.data)
self.supportVectors = self.classifier.supportVectors
self.classifier.name=self.name
self.send("Learner", self.learner)
self.send("Learner Factory", GbFactory(orngSVM.SVMLearner, parameters))
self.send("Classifier", self.classifier)
self.send("Support Vectors", self.supportVectors)
import orange, orngSVM
data = orange.ExampleTable("iris.tab")
l1 = orngSVM.SVMLearner()
l1.kernelFunc = orngSVM.RBFKernelWrapper(
orange.ExamplesDistanceConstructor_Euclidean(data), gamma=0.5)
l1.kernel_type = orange.SVMLearner.Custom
l1.probability = True
c1 = l1(data)
l1.name = "SVM - RBF(Euclidean)"
l2 = orngSVM.SVMLearner()
l2.kernelFunc = orngSVM.RBFKernelWrapper(
orange.ExamplesDistanceConstructor_Hamming(data), gamma=0.5)
l2.kernel_type = orange.SVMLearner.Custom
l2.probability = True
c2 = l2(data)
l2.name = "SVM - RBF(Hamming)"
l3 = orngSVM.SVMLearner()
l3.kernelFunc = orngSVM.CompositeKernelWrapper(
orngSVM.RBFKernelWrapper(
orange.ExamplesDistanceConstructor_Euclidean(data), gamma=0.5),
orngSVM.RBFKernelWrapper(orange.ExamplesDistanceConstructor_Hamming(data),
gamma=0.5),
l=0.5)
l3.kernel_type = orange.SVMLearner.Custom
l3.probability = True
c3 = l1(data)
l3.name = "SVM - Composite"
import orngTest, orngStat
def svm(input_dict):
import orngSVM
output_dict = {}
output_dict['svmout'] = orngSVM.SVMLearner(name='SVM (Orange)')
return output_dict
for j in range(len(learners)):
tneg[j] = tneg[j]/n
for j in range(len(learners)):
fpos[j] = fpos[j]/n
for j in range(len(learners)):
fneg[j] = fneg[j]/n
return (acc, tpos, tneg, fpos, fneg)
# set up the learners
bayes = Orange.classification.bayes.NaiveLearner(name="bayes")
adjustedbayes = Orange.classification.bayes.NaiveLearner(m=1, adjust_threshold=True, name="adjusted bayes")
tree = orngTree.TreeLearner(name="tree")
adjustedtree = orngTree.TreeLearner(m_pruning=2, max_depth=100, name="adjusted tree")
svmlinear = orngSVM.SVMLearner(svm_type = orngSVM.SVMLearner.Nu_SVC, kernel_type = orange.SVMLearner.Linear, name="svm linear")
svmrbf = orngSVM.SVMLearner(name="svm rbf")
svmpolynomial = orngSVM.SVMLearner(svm_type = orngSVM.SVMLearner.Nu_SVR, kernel_type = orange.SVMLearner.Polynomial, name="svm polynomial")
sop = Orange.classification.rules.CN2Learner(beam_width=100, name="sop")
adjustedsop = Orange.classification.rules.CN2Learner(beam_width=50, alpha=1, name="adjusted sop")
learners = [sop, tree, bayes, svmlinear, svmrbf, svmpolynomial]
# compute accuracies on data
data = orange.ExampleTable("1625-hiv-continuous-input.tab") #forest-fire-oregon.tab #breast-cancer-wisconsin.tab #forestfires0.tab
b = test_rnd_sampling(data, learners)
acc = b[0]
#sens = b[1]
#spec = b[2]
tpos = b[1]
import orange, orngSVM
data = orange.ExampleTable("iris.tab")
lin = orngSVM.SVMLearner(kernel_type=orngSVM.SVMLearner.Linear,
name="SVM - Linear")
poly = orngSVM.SVMLearner(kernel_type=orngSVM.SVMLearner.Polynomial,
name="SVM - Poly")
rbf = orngSVM.SVMLearner(kernel_type=orngSVM.SVMLearner.RBF, name="SVM - RBF")
learners = [lin, poly, rbf]
import orngTest, orngStat
res = orngTest.crossValidation(learners, data)
print "%15s%8s%8s" % ("Name", "CA", "AUC")
for l, ca, auc in zip(learners, orngStat.CA(res), orngStat.AUC(res)):
print "%-15s %.3f %.3f" % (l.name, ca, auc)
def train(self, keyword, learner="svm"):
training_docs, test_docs, train_label, test_label = self.get_training_test_sets(
keyword, 0.8)
if (len(train_label) == 0):
return None
F_train = []
print "--------------TRAIN:", keyword, "-------------------"
for i, doc_i in enumerate(training_docs):
#print self.documents[i]
myfeatures = self.get_features(keyword, self.documents[doc_i])
if (not '1' in myfeatures):
continue
myfeatures.append(str(int(train_label[i])))
F_train.append(myfeatures)
if (len(F_train) == 0):
return None
#create the attributes and domain
table = orange.ExampleTable(self.get_domain())
#define the rest of the table by addign elements to it
for i in range(len(F_train)):
#print self.known_objects
#print "i=", i
#print "ftrain[i]", zip(self.known_objects, F_train[i]),
#print " label[i]", train_label[i]
#F_train[i].append(str(int(train_label[i])))
table.append(F_train[i])
#perform the learning
if (learner == "bayes"):
print "running bayes"
classifier = orngBayes.BayesLearner(table)
#classifier = orngBayes.BayesLearner(table, m=2)
elif (learner == "tree"):
print "running tree"
classifier = orngTree.TreeLearner(table)
elif (learner == "svm"):
#can't load the svmlearner
print "running svm"
classifier = orngSVM.SVMLearner(table,
svm_type=orange.SVMLearner.Nu_SVC,
nu=0.3,
probability=True)
elif (learner == "boosting"):
#problem here too
#this is meant to be adaboost
classifier = orngTree.BoostedLearner(table)
elif (learner == "randomforest"):
#problem here too
classifier = orngEnsemble.RandomForestLearner(table,
trees=50,
name="forest")
else:
print "unknown learner"
raise
return classifier
def train(self):
F_train_obs = []
F_train_trans = []
print "--------------creating tables-------------------"
for i, obs in enumerate(self.dataset.observations):
print i, "of", len(self.dataset.observations)
f_obs, f_trans = self.dataset.to_orange_entries(obs)
for i, fs in enumerate(f_obs):
print i, f_obs[0]
F_train_obs.append(fs)
for fs in f_trans:
F_train_trans.append(fs)
if (len(F_train_obs) == 0):
return None
print ">> adding elements to tables"
#create the attributes and domain
#define the rest of the table by addign elements to it
table_obs = orange.ExampleTable(self.get_domain_obs())
for i in range(len(F_train_obs)):
table_obs.append(F_train_obs[i])
table_trans = orange.ExampleTable(self.get_domain_trans())
for i in range(len(F_train_trans)):
table_trans.append(F_train_trans[i])
#perform the learning
print "training"
if (self.learner == "bayes"):
print "training bayes obs"
self.classifier_obs = orngBayes.BayesLearner(table_obs)
print "training bayes trans"
self.classifier_trans = orngBayes.BayesLearner(table_trans)
elif (self.learner == "tree"):
print "running tree"
self.classifier_obs = orngTree.TreeLearner(table_obs)
self.classifier_trans = orngTree.TreeLearner(table_trans)
elif (self.learner == "svm"):
#can't load the svmlearner
print "trianing observation svm"
self.classifier_obs = orngSVM.SVMLearner(
table_obs,
svm_type=orange.SVMLearner.Nu_SVC,
nu=0.3,
probability=True)
print "trianing transition svm"
self.classifier_trans = orngSVM.SVMLearner(
table_trans,
svm_type=orange.SVMLearner.Nu_SVC,
nu=0.3,
probability=True)
elif (self.learner == "boosting"):
#problem here too
#this is meant to be adaboost
self.classifier_obs = orngTree.BoostedLearner(table_obs)
self.classifier_trans = orngTree.BoostedLearner(table_trans)
elif (self.learner == "randomforest"):
#problem here too
self.classifier_obs = orngEnsemble.RandomForestLearner(
table_obs, trees=50, name="forest")
self.classifier_trans = orngEnsemble.RandomForestLearner(
table_trans, trees=50, name="forest")
else:
print "unknown learner"
raise
return self.classifier_obs, self.classifier_trans