source: orange/Orange/OrangeWidgets/Evaluate/OWTestLearners.py @ 11000:21df3a59160c

Revision 11000:21df3a59160c, 27.3 KB checked in by Ales Erjavec <ales.erjavec@…>, 18 months ago (diff)

Fixed an error in 'sendReport' when evaluating on a regression problem.

Line 
1"""
2<name>Test Learners</name>
3<description>Estimates the predictive performance of learners on a data set.</description>
4<icon>icons/TestLearners.png</icon>
5<contact>Blaz Zupan (blaz.zupan(@at@)fri.uni-lj.si)</contact>
6<priority>200</priority>
7"""
8#
9# OWTestLearners.py
10#
11from OWWidget import *
12import orngTest, orngStat, OWGUI
13import time
14import warnings
15from orngWrap import PreprocessedLearner
16warnings.filterwarnings("ignore", "'id' is not a builtin attribute",
17                        orange.AttributeWarning)
18
19import Orange
20
21##############################################################################
22
23class Learner:
24    def __init__(self, learner, id):
25        self.learner = learner
26        self.name = learner.name
27        self.id = id
28        self.scores = []
29        self.results = None
30        self.time = time.time() # used to order the learners in the table
31
32class Score:
33    def __init__(self, name, label, f, show=True, cmBased=False):
34        self.name = name
35        self.label = label
36        self.f = f
37        self.show = show
38        self.cmBased = cmBased
39       
40def dispatch(score_desc, res, cm):
41    """ Dispatch the call to orngStat method.
42    """
43    return eval("orngStat." + score_desc.f)
44
45
46class OWTestLearners(OWWidget):
47    settingsList = ["nFolds", "pLearning", "pRepeat", "precision",
48                    "selectedCScores", "selectedRScores", "applyOnAnyChange",
49                    "resampling"]
50    contextHandlers = {"": DomainContextHandler("", ["targetClass"])}
51    callbackDeposit = []
52
53    # Classification
54    cStatistics = [Score(*s) for s in [\
55        ('Classification accuracy', 'CA', 'CA(res)', True),
56        ('Sensitivity', 'Sens', 'sens(cm)', True, True),
57        ('Specificity', 'Spec', 'spec(cm)', True, True),
58        ('Area under ROC curve', 'AUC', 'AUC(res)', True),
59        ('Information score', 'IS', 'IS(res)', False),
60        ('F-measure', 'F1', 'F1(cm)', False, True),
61        ('Precision', 'Prec', 'precision(cm)', False, True),
62        ('Recall', 'Recall', 'recall(cm)', False, True),
63        ('Brier score', 'Brier', 'BrierScore(res)', True),
64        ('Matthews correlation coefficient', 'MCC', 'MCC(cm)', False, True)]]
65
66    # Regression
67    rStatistics = [Score(*s) for s in [\
68        ("Mean squared error", "MSE", "MSE(res)", False),
69        ("Root mean squared error", "RMSE", "RMSE(res)"),
70        ("Mean absolute error", "MAE", "MAE(res)", False),
71        ("Relative squared error", "RSE", "RSE(res)", False),
72        ("Root relative squared error", "RRSE", "RRSE(res)"),
73        ("Relative absolute error", "RAE", "RAE(res)", False),
74        ("R-squared", "R2", "R2(res)")]]
75   
76    # Multi-Label
77    mStatistics = [Score(*s) for s in [\
78        ('Hamming Loss', 'HammingLoss', 'mlc_hamming_loss(res)', False),
79        ('Accuracy', 'Accuracy', 'mlc_accuracy(res)', False),
80        ('Precision', 'Precision', 'mlc_precision(res)', False),
81        ('Recall', 'Recall', 'mlc_recall(res)', False),                               
82        ]]
83   
84    resamplingMethods = ["Cross-validation", "Leave-one-out", "Random sampling",
85                         "Test on train data", "Test on test data"]
86
87    def __init__(self,parent=None, signalManager = None):
88        OWWidget.__init__(self, parent, signalManager, "Test Learners")
89
90        self.inputs = [("Data", ExampleTable, self.setData, Default),
91                       ("Separate Test Data", ExampleTable, self.setTestData),
92                       ("Learner", orange.Learner, self.setLearner, Multiple + Default),
93                       ("Preprocess", PreprocessedLearner, self.setPreprocessor)]
94
95        self.outputs = [("Evaluation Results", orngTest.ExperimentResults)]
96
97        # Settings
98        self.resampling = 0             # cross-validation
99        self.nFolds = 5                 # cross validation folds
100        self.pLearning = 70   # size of learning set when sampling [%]
101        self.pRepeat = 10
102        self.precision = 4
103        self.applyOnAnyChange = True
104        self.selectedCScores = [i for (i,s) in enumerate(self.cStatistics) if s.show]
105        self.selectedRScores = [i for (i,s) in enumerate(self.rStatistics) if s.show]
106        self.selectedMScores = [i for (i,s) in enumerate(self.mStatistics) if s.show]
107        self.targetClass = 0
108        self.loadSettings()
109
110        self.stat = self.cStatistics
111
112        self.data = None                # input data set
113        self.testdata = None            # separate test data set
114        self.learners = {}              # set of learners (input)
115        self.results = None             # from orngTest
116        self.preprocessor = None
117
118        self.controlArea.layout().setSpacing(8)
119        # GUI
120        self.sBtns = OWGUI.radioButtonsInBox(self.controlArea, self, "resampling", 
121                                             box="Sampling",
122                                             btnLabels=self.resamplingMethods[:1],
123                                             callback=self.newsampling)
124        indent = OWGUI.checkButtonOffsetHint(self.sBtns.buttons[-1])
125       
126        ibox = OWGUI.widgetBox(OWGUI.indentedBox(self.sBtns, sep=indent))
127        OWGUI.spin(ibox, self, 'nFolds', 2, 100, step=1,
128                   label='Number of folds:',
129                   callback=lambda p=0: self.conditionalRecompute(p),
130                   keyboardTracking=False)
131       
132        OWGUI.separator(self.sBtns, height = 3)
133       
134        OWGUI.appendRadioButton(self.sBtns, self, "resampling", self.resamplingMethods[1])      # leave one out
135        OWGUI.separator(self.sBtns, height = 3)
136        OWGUI.appendRadioButton(self.sBtns, self, "resampling", self.resamplingMethods[2])      # random sampling
137                       
138        ibox = OWGUI.widgetBox(OWGUI.indentedBox(self.sBtns, sep=indent))
139        OWGUI.spin(ibox, self, 'pRepeat', 1, 100, step=1,
140                   label='Repeat train/test:',
141                   callback=lambda p=2: self.conditionalRecompute(p),
142                   keyboardTracking=False)
143       
144        OWGUI.widgetLabel(ibox, "Relative training set size:")
145       
146        OWGUI.hSlider(ibox, self, 'pLearning', minValue=10, maxValue=100,
147                      step=1, ticks=10, labelFormat="   %d%%",
148                      callback=lambda p=2: self.conditionalRecompute(p))
149       
150        OWGUI.separator(self.sBtns, height = 3)
151        OWGUI.appendRadioButton(self.sBtns, self, "resampling", self.resamplingMethods[3])  # test on train
152        OWGUI.separator(self.sBtns, height = 3)
153        OWGUI.appendRadioButton(self.sBtns, self, "resampling", self.resamplingMethods[4])  # test on test
154
155        self.trainDataBtn = self.sBtns.buttons[-2]
156        self.testDataBtn = self.sBtns.buttons[-1]
157        self.testDataBtn.setDisabled(True)
158       
159        OWGUI.separator(self.sBtns)
160        OWGUI.checkBox(self.sBtns, self, 'applyOnAnyChange',
161                       label="Apply on any change", callback=self.applyChange)
162        self.applyBtn = OWGUI.button(self.sBtns, self, "&Apply",
163                                     callback=lambda f=True: self.recompute(f))
164        self.applyBtn.setDisabled(True)
165
166        if self.resampling == 4:
167            self.resampling = 3
168
169        # statistics
170        self.statLayout = QStackedLayout()
171        self.cbox = OWGUI.widgetBox(self.controlArea, addToLayout=False)
172        self.cStatLabels = [s.name for s in self.cStatistics]
173        self.cstatLB = OWGUI.listBox(self.cbox, self, 'selectedCScores',
174                                     'cStatLabels', box = "Performance scores",
175                                     selectionMode = QListWidget.MultiSelection,
176                                     callback=self.newscoreselection)
177       
178        self.cbox.layout().addSpacing(8)
179        self.targetCombo = OWGUI.comboBox(self.cbox, self, "targetClass", orientation=0,
180                                        callback=[self.changedTarget],
181                                        box="Target class")
182
183        self.rStatLabels = [s.name for s in self.rStatistics]
184        self.rbox = OWGUI.widgetBox(self.controlArea, "Performance scores", addToLayout=False)
185        self.rstatLB = OWGUI.listBox(self.rbox, self, 'selectedRScores', 'rStatLabels',
186                                     selectionMode = QListWidget.MultiSelection,
187                                     callback=self.newscoreselection)
188
189        self.mStatLabels = [s.name for s in self.mStatistics]
190        self.mbox = OWGUI.widgetBox(self.controlArea, "Performance scores", addToLayout=False)
191        self.mstatLB = OWGUI.listBox(self.mbox, self, 'selectedMScores', 'mStatLabels',
192                                     selectionMode = QListWidget.MultiSelection,
193                                     callback=self.newscoreselection)
194       
195        self.statLayout.addWidget(self.cbox)
196        self.statLayout.addWidget(self.rbox)
197        self.statLayout.addWidget(self.mbox)
198        self.controlArea.layout().addLayout(self.statLayout)
199       
200        self.statLayout.setCurrentWidget(self.cbox)
201
202        # score table
203        # table with results
204        self.g = OWGUI.widgetBox(self.mainArea, 'Evaluation Results')
205        self.tab = OWGUI.table(self.g, selectionMode = QTableWidget.NoSelection)
206
207        self.resize(680,470)
208
209    # scoring and painting of score table
210    def isclassification(self):
211        if not self.data or not self.data.domain.classVar:
212            return True
213        return self.data.domain.classVar.varType == orange.VarTypes.Discrete
214
215    def ismultilabel(self, data = 42):
216        if data==42:
217            data = self.data
218        if not data:
219            return False
220        return Orange.multilabel.is_multilabel(data)
221
222    def get_usestat(self):
223        return ([self.selectedRScores, self.selectedCScores, self.selectedMScores]
224                [2 if self.ismultilabel() else self.isclassification()])
225
226    def paintscores(self):
227        """paints the table with evaluation scores"""
228
229        self.tab.setColumnCount(len(self.stat)+1)
230        self.tab.setHorizontalHeaderLabels(["Method"] + [s.label for s in self.stat])
231       
232        prec="%%.%df" % self.precision
233
234        learners = [(l.time, l) for l in self.learners.values()]
235        learners.sort()
236        learners = [lt[1] for lt in learners]
237
238        self.tab.setRowCount(len(self.learners))
239        for (i, l) in enumerate(learners):
240            OWGUI.tableItem(self.tab, i,0, l.name)
241           
242        for (i, l) in enumerate(learners):
243            if l.scores:
244                for j in range(len(self.stat)):
245                    if l.scores[j] is not None:
246                        OWGUI.tableItem(self.tab, i, j+1, prec % l.scores[j])
247                    else:
248                        OWGUI.tableItem(self.tab, i, j+1, "N/A")
249            else:
250                for j in range(len(self.stat)):
251                    OWGUI.tableItem(self.tab, i, j+1, "")
252       
253        # adjust the width of the score table cloumns
254        self.tab.resizeColumnsToContents()
255        self.tab.resizeRowsToContents()
256        usestat = self.get_usestat()
257        for i in range(len(self.stat)):
258            if i not in usestat:
259                self.tab.hideColumn(i + 1)
260            else:
261                self.tab.showColumn(i + 1)
262
263    def sendReport(self):
264        method = [("Method", self.resamplingMethods[self.resampling])]
265
266        exset = []
267
268        if self.resampling == 0:
269            exset = [("Folds", self.nFolds)]
270        elif self.resampling == 2:
271            exset = [("Repetitions", self.pRepeat),
272                     ("Proportion of training instances", "%i%%" \
273                      % self.pLearning)]
274        else:
275            exset = []
276
277        if self.data and \
278                isinstance(self.data.domain.classVar, orange.EnumVariable):
279            target = [("Target class",
280                       self.data.domain.classVar.values[self.targetClass])]
281        else:
282            target = []
283
284        if not self.ismultilabel():
285            self.reportSettings("Validation method", method + exset + target)
286        else:
287            self.reportSettings("Validation method", method + exset)
288
289        self.reportData(self.data)
290
291        if self.data:
292            self.reportSection("Results")
293            learners = [(l.time, l) for l in self.learners.values()]
294            learners.sort()
295            learners = [lt[1] for lt in learners]
296            usestat = self.get_usestat()
297            # table header
298            res = "<table><tr><th></th>" + \
299                  "".join("<th><b>%s</b></th>" % s.label \
300                          for i, s in enumerate(self.stat) \
301                          if i in usestat) + \
302                  "</tr>"
303
304            for i, learner in enumerate(learners):
305                res += "<tr><th><b>%s</b></th>" % learner.name
306                if learner.scores:
307                    for j in usestat:
308                        score = learner.scores[j]
309                        score = "%.4f" % score if score is not None else ""
310                        res += "<td>" + score + "</td>"
311                res += "</tr>"
312            res += "</table>"
313            self.reportRaw(res)
314
315    def score(self, ids):
316        """compute scores for the list of learners"""
317        if (not self.data):
318            for id in ids:
319                self.learners[id].results = None
320                self.learners[id].scores = []
321            return
322        # test which learners can accept the given data set
323        # e.g., regressions can't deal with classification data
324        learners = []
325        used_ids = []
326        n = len(self.data.domain.attributes)*2
327        indices = orange.MakeRandomIndices2(p0=min(n, len(self.data)), stratified=orange.MakeRandomIndices2.StratifiedIfPossible)
328        new = self.data.selectref(indices(self.data), 0)
329
330        multilabel = self.ismultilabel()
331       
332        self.warning(0)
333        learner_exceptions = []
334        for l in [self.learners[id] for id in ids]:
335            learner = l.learner
336            if self.preprocessor:
337                learner = self.preprocessor.wrapLearner(learner)
338            try:
339                predictor = learner(new)
340                if (multilabel and isinstance(learner, Orange.multilabel.MultiLabelLearner)) or predictor(new[0]).varType == new.domain.classVar.varType:
341                    learners.append(learner)
342                    used_ids.append(l.id)
343                else:
344                    l.scores = []
345                    l.results = None
346
347            except Exception, ex:
348                learner_exceptions.append((l, ex))
349                l.scores = []
350                l.results = None
351
352        if learner_exceptions:
353            text = "\n".join("Learner %s ends with exception: %s" % (l.name, str(ex)) \
354                             for l, ex in learner_exceptions)
355            self.warning(0, text)
356           
357        if not learners:
358            return
359
360        # computation of results (res, and cm if classification)
361        pb = None
362        if self.resampling==0:
363            pb = OWGUI.ProgressBar(self, iterations=self.nFolds)
364            res = orngTest.crossValidation(learners, self.data, folds=self.nFolds,
365                                           strat=orange.MakeRandomIndices.StratifiedIfPossible,
366                                           callback=pb.advance, storeExamples = True)
367            pb.finish()
368        elif self.resampling==1:
369            pb = OWGUI.ProgressBar(self, iterations=len(self.data))
370            res = orngTest.leaveOneOut(learners, self.data,
371                                       callback=pb.advance, storeExamples = True)
372            pb.finish()
373        elif self.resampling==2:
374            pb = OWGUI.ProgressBar(self, iterations=self.pRepeat)
375            res = orngTest.proportionTest(learners, self.data, self.pLearning/100.,
376                                          times=self.pRepeat, callback=pb.advance, storeExamples = True)
377            pb.finish()
378        elif self.resampling==3:
379            pb = OWGUI.ProgressBar(self, iterations=len(learners))
380            res = orngTest.learnAndTestOnLearnData(learners, self.data, storeExamples = True, callback=pb.advance)
381            pb.finish()
382           
383        elif self.resampling==4:
384            if not self.testdata:
385                for l in self.learners.values():
386                    l.scores = []
387                return
388            pb = OWGUI.ProgressBar(self, iterations=len(learners))
389            res = orngTest.learnAndTestOnTestData(learners, self.data, self.testdata, storeExamples = True, callback=pb.advance)
390            pb.finish()
391           
392        if not self.ismultilabel() and self.isclassification():
393            cm = orngStat.computeConfusionMatrices(res, classIndex = self.targetClass)
394        else:
395            cm = None
396
397        if self.preprocessor: # Unwrap learners
398            learners = [l.wrappedLearner for l in learners]
399           
400        res.learners = learners
401       
402        for l in [self.learners[id] for id in ids]:
403            if l.learner in learners:
404                l.results = res
405            else:
406                l.results = None
407
408        self.error(range(len(self.stat)))
409        scores = []
410       
411        for i, s in enumerate(self.stat):
412            if s.cmBased:
413                try:
414                    scores.append(dispatch(s, res, cm))
415                except Exception, ex:
416                    self.error(i, "An error occurred while evaluating orngStat." + s.f + "on %s due to %s" % \
417                               (" ".join([l.name for l in learners]), ex.message))
418                    scores.append([None] * len(self.learners))
419            else:
420                scores_one = []
421                for res_one in orngStat.split_by_classifiers(res):
422                    try:
423                        scores_one.extend(dispatch(s, res_one, cm))
424                    except Exception, ex:
425                        self.error(i, "An error occurred while evaluating orngStat." + s.f + "on %s due to %s" % \
426                                   (res.classifierNames[0], ex.message))
427                        scores_one.append(None)
428                scores.append(scores_one)
429
430        for i, (id, l) in enumerate(zip(used_ids, learners)):
431            self.learners[id].scores = [s[i] if s else None for s in scores]
432           
433        self.sendResults()
434
435    def recomputeCM(self):
436        if not self.results:
437            return
438        cm = orngStat.computeConfusionMatrices(self.results, classIndex = self.targetClass)
439        scores = [(indx, eval("orngStat." + s.f))
440                  for (indx, s) in enumerate(self.stat) if s.cmBased]
441        for (indx, score) in scores:
442            for (i, l) in enumerate([l for l in self.learners.values() if l.scores]):
443                learner_indx = self.results.learners.index(l.learner)
444                l.scores[indx] = score[learner_indx]
445
446        self.paintscores()
447       
448    def clearScores(self, ids=None):
449        if ids is None:
450            ids = self.learners.keys()
451
452        for id in ids:
453            self.learners[id].scores = []
454            self.learners[id].results = None
455
456    # handle input signals
457    def setData(self, data):
458        """handle input train data set"""
459        self.closeContext()
460       
461        multilabel= self.ismultilabel(data)
462        if not multilabel:
463            self.data = self.isDataWithClass(data, checkMissing=True) and data or None
464        else:
465            self.data = data
466       
467        self.fillClassCombo()
468        if not self.data:
469            # data was removed, remove the scores
470            self.clearScores()
471            self.send("Evaluation Results", None)
472        else:
473            # new data has arrived
474            self.clearScores()
475
476            if not multilabel:
477                self.data = orange.Filter_hasClassValue(self.data)
478
479            self.statLayout.setCurrentWidget([self.rbox, self.cbox, self.mbox][2 if self.ismultilabel() else self.isclassification()])
480
481            self.stat = [self.rStatistics, self.cStatistics, self.mStatistics][2 if self.ismultilabel() else self.isclassification()]
482
483            if self.learners:
484                self.recompute()
485           
486        self.openContext("", data)
487        self.paintscores()
488
489    def setTestData(self, data):
490        """handle test data set"""
491        if data is None:
492            self.testdata = None
493        else:
494            self.testdata = orange.Filter_hasClassValue(data)
495        self.testDataBtn.setEnabled(self.testdata is not None)
496        if self.testdata is not None:
497            if self.resampling == 4:
498                if self.data:
499                    self.recompute()
500                else:
501                    for l in self.learners.values():
502                        l.scores = []
503                self.paintscores()
504        elif self.resampling == 4 and self.data:
505            # test data removed, switch to testing on train data
506            self.resampling = 3
507            self.recompute()
508
509    def fillClassCombo(self):
510        """upon arrival of new data appropriately set the target class combo"""
511        self.targetCombo.clear()
512        if not self.data or not self.data.domain.classVar or not self.isclassification():
513            return
514
515        domain = self.data.domain
516        self.targetCombo.addItems([str(v) for v in domain.classVar.values])
517       
518        if self.targetClass<len(domain.classVar.values):
519            self.targetCombo.setCurrentIndex(self.targetClass)
520        else:
521            self.targetCombo.setCurrentIndex(0)
522            self.targetClass=0
523
524    def setLearner(self, learner, id=None):
525        """add/remove a learner"""
526        if learner: # a new or updated learner
527            if id in self.learners: # updated learner
528                time = self.learners[id].time
529                self.learners[id] = Learner(learner, id)
530                self.learners[id].time = time
531            else: # new learner
532                self.learners[id] = Learner(learner, id)
533            if self.applyOnAnyChange:
534                self.score([id])
535            else:
536                self.recompute()
537        else: # remove a learner and corresponding results
538            if id in self.learners:
539                res = self.learners[id].results
540                if res and res.numberOfLearners > 1:
541                    old_learner = self.learners[id].learner
542                    indx = res.learners.index(old_learner)
543                    res.remove(indx)
544                    del res.learners[indx]
545                del self.learners[id]
546            self.sendResults()
547        self.paintscores()
548       
549    def setPreprocessor(self, pp):
550        self.preprocessor = pp
551        if self.learners:
552            self.recompute()
553
554    # handle output signals
555
556    def sendResults(self):
557        """commit evaluation results"""
558        # for each learner, we first find a list where a result is stored
559        # and remember the corresponding index
560
561        valid = [(l.results, l.results.learners.index(l.learner))
562                 for l in self.learners.values() if l.scores and l.results]
563           
564        if not (self.data and len(valid)):
565            self.send("Evaluation Results", None)
566            return
567
568        # find the result set for a largest number of learners
569        # and remove this set from the list of result sets
570        rlist = dict([(l.results,1) for l in self.learners.values() if l.scores and l.results]).keys()
571        rlen = [r.numberOfLearners for r in rlist]
572        results = rlist.pop(rlen.index(max(rlen)))
573       
574        for (i, l) in enumerate(results.learners):
575            if not l in [l.learner for l in self.learners.values()]:
576                results.remove(i)
577                del results.learners[i]
578
579        for r in rlist:
580            for (i, l) in enumerate(r.learners):
581                learner_id = [l1.id for l1 in self.learners.values() if l1.learner is l][0]
582                if (r, i) in valid:
583                    results.add(r, i)
584                    results.learners.append(r.learners[i])
585                    self.learners[learner_id].results = results
586        self.send("Evaluation Results", results)
587        self.results = results
588
589    # signal processing
590
591    def newsampling(self):
592        """handle change of evaluation method"""
593        if not self.applyOnAnyChange:
594            self.applyBtn.setDisabled(self.applyOnAnyChange)
595        else:
596            if self.learners:
597                self.recompute()
598
599    def newscoreselection(self):
600        """handle change in set of scores to be displayed"""
601        usestat = self.get_usestat()
602        for i in range(len(self.stat)):
603            if i in usestat:
604                self.tab.showColumn(i+1)
605                self.tab.resizeColumnToContents(i+1)
606            else:
607                self.tab.hideColumn(i+1)
608
609    def recompute(self, forced=False):
610        """recompute the scores for all learners,
611           if not forced, will do nothing but enable the Apply button"""
612        if self.applyOnAnyChange or forced:
613            self.score([l.id for l in self.learners.values()])
614            self.paintscores()
615            self.applyBtn.setDisabled(True)
616        else:
617            self.applyBtn.setEnabled(True)
618
619    def conditionalRecompute(self, option):
620        """calls recompute only if specific sampling option enabled"""
621        if self.resampling == option:
622            self.recompute(False)
623
624    def applyChange(self):
625        if self.applyOnAnyChange:
626            self.applyBtn.setDisabled(True)
627       
628    def changedTarget(self):
629        self.recomputeCM()
630
631##############################################################################
632# Test the widget, run from DOS prompt
633
634if __name__=="__main__":
635    a=QApplication(sys.argv)
636    ow=OWTestLearners()
637    ow.show()
638    a.exec_()
639
640    data1 = orange.ExampleTable(r'../../doc/datasets/voting')
641    data2 = orange.ExampleTable(r'../../golf')
642    datar = orange.ExampleTable(r'../../auto-mpg')
643    data3 = orange.ExampleTable(r'../../sailing-big')
644    data4 = orange.ExampleTable(r'../../sailing-test')
645    data5 = orange.ExampleTable('emotions')
646
647    l1 = orange.MajorityLearner(); l1.name = '1 - Majority'
648
649    l2 = orange.BayesLearner()
650    l2.estimatorConstructor = orange.ProbabilityEstimatorConstructor_m(m=10)
651    l2.conditionalEstimatorConstructor = \
652        orange.ConditionalProbabilityEstimatorConstructor_ByRows(
653        estimatorConstructor = orange.ProbabilityEstimatorConstructor_m(m=10))
654    l2.name = '2 - NBC (m=10)'
655
656    l3 = orange.BayesLearner(); l3.name = '3 - NBC (default)'
657
658    l4 = orange.MajorityLearner(); l4.name = "4 - Majority"
659
660    import orngRegression as r
661    r5 = r.LinearRegressionLearner(name="0 - lin reg")
662
663    l5 = Orange.multilabel.BinaryRelevanceLearner()
664
665    testcase = 4
666
667    if testcase == 0: # 1(UPD), 3, 4
668        ow.setData(data2)
669        ow.setLearner(r5, 5)
670        ow.setLearner(l1, 1)
671        ow.setLearner(l2, 2)
672        ow.setLearner(l3, 3)
673        l1.name = l1.name + " UPD"
674        ow.setLearner(l1, 1)
675        ow.setLearner(None, 2)
676        ow.setLearner(l4, 4)
677#        ow.setData(data1)
678#        ow.setData(datar)
679#        ow.setData(data1)
680    if testcase == 1: # data, but all learners removed
681        ow.setLearner(l1, 1)
682        ow.setLearner(l2, 2)
683        ow.setLearner(l1, 1)
684        ow.setLearner(None, 2)
685        ow.setData(data2)
686        ow.setLearner(None, 1)
687    if testcase == 2: # sends data, then learner, then removes the learner
688        ow.setData(data2)
689        ow.setLearner(l1, 1)
690        ow.setLearner(None, 1)
691    if testcase == 3: # regression first
692        ow.setData(datar)
693        ow.setLearner(r5, 5)
694    if testcase == 4: # separate train and test data
695        ow.setData(data3)
696        ow.setTestData(data4)
697        ow.setLearner(l2, 5)
698        ow.setTestData(None)
699    if testcase == 5: # MLC
700        ow.setData(data5)
701        ow.setLearner(l5, 6)
702
703    ow.saveSettings()
Note: See TracBrowser for help on using the repository browser.