source: orange/Orange/OrangeWidgets/Evaluate/OWTestLearners.py @ 10999:d6c3b7928f64

Revision 10999:d6c3b7928f64, 27.1 KB checked in by Ales Erjavec <ales.erjavec@…>, 18 months ago (diff)

Fixed selection indices for learner prechecking.

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        exset = []
265        if self.resampling == 0:
266            exset = [("Folds", self.nFolds)]
267        elif self.resampling == 2:
268            exset = [("Repetitions", self.pRepeat), ("Proportion of training instances", "%i%%" % self.pLearning)]
269        else:
270            exset = []
271        if not self.ismultilabel():
272            self.reportSettings("Validation method",
273                            [("Method", self.resamplingMethods[self.resampling])]
274                            + exset +
275                            ([("Target class", self.data.domain.classVar.values[self.targetClass])] if self.data else []))
276        else:
277             self.reportSettings("Validation method",
278                            [("Method", self.resamplingMethods[self.resampling])]
279                            + exset)
280       
281        self.reportData(self.data)
282
283        if self.data:       
284            self.reportSection("Results")
285            learners = [(l.time, l) for l in self.learners.values()]
286            learners.sort()
287            learners = [lt[1] for lt in learners]
288            usestat = self.get_usestat()
289            res = "<table><tr><th></th>"+"".join("<th><b>%s</b></th>" % hr for hr in [s.label for i, s in enumerate(self.stat) if i in usestat])+"</tr>"
290            for i, l in enumerate(learners):
291                res += "<tr><th><b>%s</b></th>" % l.name
292                if l.scores:
293                    for j in usestat:
294                        scr = l.scores[j]
295                        res += "<td>" + ("%.4f" % scr if scr is not None else "") + "</td>"
296                res += "</tr>"
297            res += "</table>"
298            self.reportRaw(res)
299           
300    def score(self, ids):
301        """compute scores for the list of learners"""
302        if (not self.data):
303            for id in ids:
304                self.learners[id].results = None
305                self.learners[id].scores = []
306            return
307        # test which learners can accept the given data set
308        # e.g., regressions can't deal with classification data
309        learners = []
310        used_ids = []
311        n = len(self.data.domain.attributes)*2
312        indices = orange.MakeRandomIndices2(p0=min(n, len(self.data)), stratified=orange.MakeRandomIndices2.StratifiedIfPossible)
313        new = self.data.selectref(indices(self.data), 0)
314
315        multilabel = self.ismultilabel()
316       
317        self.warning(0)
318        learner_exceptions = []
319        for l in [self.learners[id] for id in ids]:
320            learner = l.learner
321            if self.preprocessor:
322                learner = self.preprocessor.wrapLearner(learner)
323            try:
324                predictor = learner(new)
325                if (multilabel and isinstance(learner, Orange.multilabel.MultiLabelLearner)) or predictor(new[0]).varType == new.domain.classVar.varType:
326                    learners.append(learner)
327                    used_ids.append(l.id)
328                else:
329                    l.scores = []
330                    l.results = None
331
332            except Exception, ex:
333                learner_exceptions.append((l, ex))
334                l.scores = []
335                l.results = None
336
337        if learner_exceptions:
338            text = "\n".join("Learner %s ends with exception: %s" % (l.name, str(ex)) \
339                             for l, ex in learner_exceptions)
340            self.warning(0, text)
341           
342        if not learners:
343            return
344
345        # computation of results (res, and cm if classification)
346        pb = None
347        if self.resampling==0:
348            pb = OWGUI.ProgressBar(self, iterations=self.nFolds)
349            res = orngTest.crossValidation(learners, self.data, folds=self.nFolds,
350                                           strat=orange.MakeRandomIndices.StratifiedIfPossible,
351                                           callback=pb.advance, storeExamples = True)
352            pb.finish()
353        elif self.resampling==1:
354            pb = OWGUI.ProgressBar(self, iterations=len(self.data))
355            res = orngTest.leaveOneOut(learners, self.data,
356                                       callback=pb.advance, storeExamples = True)
357            pb.finish()
358        elif self.resampling==2:
359            pb = OWGUI.ProgressBar(self, iterations=self.pRepeat)
360            res = orngTest.proportionTest(learners, self.data, self.pLearning/100.,
361                                          times=self.pRepeat, callback=pb.advance, storeExamples = True)
362            pb.finish()
363        elif self.resampling==3:
364            pb = OWGUI.ProgressBar(self, iterations=len(learners))
365            res = orngTest.learnAndTestOnLearnData(learners, self.data, storeExamples = True, callback=pb.advance)
366            pb.finish()
367           
368        elif self.resampling==4:
369            if not self.testdata:
370                for l in self.learners.values():
371                    l.scores = []
372                return
373            pb = OWGUI.ProgressBar(self, iterations=len(learners))
374            res = orngTest.learnAndTestOnTestData(learners, self.data, self.testdata, storeExamples = True, callback=pb.advance)
375            pb.finish()
376           
377        if not self.ismultilabel() and self.isclassification():
378            cm = orngStat.computeConfusionMatrices(res, classIndex = self.targetClass)
379        else:
380            cm = None
381
382        if self.preprocessor: # Unwrap learners
383            learners = [l.wrappedLearner for l in learners]
384           
385        res.learners = learners
386       
387        for l in [self.learners[id] for id in ids]:
388            if l.learner in learners:
389                l.results = res
390            else:
391                l.results = None
392
393        self.error(range(len(self.stat)))
394        scores = []
395       
396        for i, s in enumerate(self.stat):
397            if s.cmBased:
398                try:
399                    scores.append(dispatch(s, res, cm))
400                except Exception, ex:
401                    self.error(i, "An error occurred while evaluating orngStat." + s.f + "on %s due to %s" % \
402                               (" ".join([l.name for l in learners]), ex.message))
403                    scores.append([None] * len(self.learners))
404            else:
405                scores_one = []
406                for res_one in orngStat.split_by_classifiers(res):
407                    try:
408                        scores_one.extend(dispatch(s, res_one, cm))
409                    except Exception, ex:
410                        self.error(i, "An error occurred while evaluating orngStat." + s.f + "on %s due to %s" % \
411                                   (res.classifierNames[0], ex.message))
412                        scores_one.append(None)
413                scores.append(scores_one)
414
415        for i, (id, l) in enumerate(zip(used_ids, learners)):
416            self.learners[id].scores = [s[i] if s else None for s in scores]
417           
418        self.sendResults()
419
420    def recomputeCM(self):
421        if not self.results:
422            return
423        cm = orngStat.computeConfusionMatrices(self.results, classIndex = self.targetClass)
424        scores = [(indx, eval("orngStat." + s.f))
425                  for (indx, s) in enumerate(self.stat) if s.cmBased]
426        for (indx, score) in scores:
427            for (i, l) in enumerate([l for l in self.learners.values() if l.scores]):
428                learner_indx = self.results.learners.index(l.learner)
429                l.scores[indx] = score[learner_indx]
430
431        self.paintscores()
432       
433    def clearScores(self, ids=None):
434        if ids is None:
435            ids = self.learners.keys()
436
437        for id in ids:
438            self.learners[id].scores = []
439            self.learners[id].results = None
440
441    # handle input signals
442    def setData(self, data):
443        """handle input train data set"""
444        self.closeContext()
445       
446        multilabel= self.ismultilabel(data)
447        if not multilabel:
448            self.data = self.isDataWithClass(data, checkMissing=True) and data or None
449        else:
450            self.data = data
451       
452        self.fillClassCombo()
453        if not self.data:
454            # data was removed, remove the scores
455            self.clearScores()
456            self.send("Evaluation Results", None)
457        else:
458            # new data has arrived
459            self.clearScores()
460
461            if not multilabel:
462                self.data = orange.Filter_hasClassValue(self.data)
463
464            self.statLayout.setCurrentWidget([self.rbox, self.cbox, self.mbox][2 if self.ismultilabel() else self.isclassification()])
465
466            self.stat = [self.rStatistics, self.cStatistics, self.mStatistics][2 if self.ismultilabel() else self.isclassification()]
467
468            if self.learners:
469                self.recompute()
470           
471        self.openContext("", data)
472        self.paintscores()
473
474    def setTestData(self, data):
475        """handle test data set"""
476        if data is None:
477            self.testdata = None
478        else:
479            self.testdata = orange.Filter_hasClassValue(data)
480        self.testDataBtn.setEnabled(self.testdata is not None)
481        if self.testdata is not None:
482            if self.resampling == 4:
483                if self.data:
484                    self.recompute()
485                else:
486                    for l in self.learners.values():
487                        l.scores = []
488                self.paintscores()
489        elif self.resampling == 4 and self.data:
490            # test data removed, switch to testing on train data
491            self.resampling = 3
492            self.recompute()
493
494    def fillClassCombo(self):
495        """upon arrival of new data appropriately set the target class combo"""
496        self.targetCombo.clear()
497        if not self.data or not self.data.domain.classVar or not self.isclassification():
498            return
499
500        domain = self.data.domain
501        self.targetCombo.addItems([str(v) for v in domain.classVar.values])
502       
503        if self.targetClass<len(domain.classVar.values):
504            self.targetCombo.setCurrentIndex(self.targetClass)
505        else:
506            self.targetCombo.setCurrentIndex(0)
507            self.targetClass=0
508
509    def setLearner(self, learner, id=None):
510        """add/remove a learner"""
511        if learner: # a new or updated learner
512            if id in self.learners: # updated learner
513                time = self.learners[id].time
514                self.learners[id] = Learner(learner, id)
515                self.learners[id].time = time
516            else: # new learner
517                self.learners[id] = Learner(learner, id)
518            if self.applyOnAnyChange:
519                self.score([id])
520            else:
521                self.recompute()
522        else: # remove a learner and corresponding results
523            if id in self.learners:
524                res = self.learners[id].results
525                if res and res.numberOfLearners > 1:
526                    old_learner = self.learners[id].learner
527                    indx = res.learners.index(old_learner)
528                    res.remove(indx)
529                    del res.learners[indx]
530                del self.learners[id]
531            self.sendResults()
532        self.paintscores()
533       
534    def setPreprocessor(self, pp):
535        self.preprocessor = pp
536        if self.learners:
537            self.recompute()
538
539    # handle output signals
540
541    def sendResults(self):
542        """commit evaluation results"""
543        # for each learner, we first find a list where a result is stored
544        # and remember the corresponding index
545
546        valid = [(l.results, l.results.learners.index(l.learner))
547                 for l in self.learners.values() if l.scores and l.results]
548           
549        if not (self.data and len(valid)):
550            self.send("Evaluation Results", None)
551            return
552
553        # find the result set for a largest number of learners
554        # and remove this set from the list of result sets
555        rlist = dict([(l.results,1) for l in self.learners.values() if l.scores and l.results]).keys()
556        rlen = [r.numberOfLearners for r in rlist]
557        results = rlist.pop(rlen.index(max(rlen)))
558       
559        for (i, l) in enumerate(results.learners):
560            if not l in [l.learner for l in self.learners.values()]:
561                results.remove(i)
562                del results.learners[i]
563
564        for r in rlist:
565            for (i, l) in enumerate(r.learners):
566                learner_id = [l1.id for l1 in self.learners.values() if l1.learner is l][0]
567                if (r, i) in valid:
568                    results.add(r, i)
569                    results.learners.append(r.learners[i])
570                    self.learners[learner_id].results = results
571        self.send("Evaluation Results", results)
572        self.results = results
573
574    # signal processing
575
576    def newsampling(self):
577        """handle change of evaluation method"""
578        if not self.applyOnAnyChange:
579            self.applyBtn.setDisabled(self.applyOnAnyChange)
580        else:
581            if self.learners:
582                self.recompute()
583
584    def newscoreselection(self):
585        """handle change in set of scores to be displayed"""
586        usestat = self.get_usestat()
587        for i in range(len(self.stat)):
588            if i in usestat:
589                self.tab.showColumn(i+1)
590                self.tab.resizeColumnToContents(i+1)
591            else:
592                self.tab.hideColumn(i+1)
593
594    def recompute(self, forced=False):
595        """recompute the scores for all learners,
596           if not forced, will do nothing but enable the Apply button"""
597        if self.applyOnAnyChange or forced:
598            self.score([l.id for l in self.learners.values()])
599            self.paintscores()
600            self.applyBtn.setDisabled(True)
601        else:
602            self.applyBtn.setEnabled(True)
603
604    def conditionalRecompute(self, option):
605        """calls recompute only if specific sampling option enabled"""
606        if self.resampling == option:
607            self.recompute(False)
608
609    def applyChange(self):
610        if self.applyOnAnyChange:
611            self.applyBtn.setDisabled(True)
612       
613    def changedTarget(self):
614        self.recomputeCM()
615
616##############################################################################
617# Test the widget, run from DOS prompt
618
619if __name__=="__main__":
620    a=QApplication(sys.argv)
621    ow=OWTestLearners()
622    ow.show()
623    a.exec_()
624
625    data1 = orange.ExampleTable(r'../../doc/datasets/voting')
626    data2 = orange.ExampleTable(r'../../golf')
627    datar = orange.ExampleTable(r'../../auto-mpg')
628    data3 = orange.ExampleTable(r'../../sailing-big')
629    data4 = orange.ExampleTable(r'../../sailing-test')
630    data5 = orange.ExampleTable('emotions')
631
632    l1 = orange.MajorityLearner(); l1.name = '1 - Majority'
633
634    l2 = orange.BayesLearner()
635    l2.estimatorConstructor = orange.ProbabilityEstimatorConstructor_m(m=10)
636    l2.conditionalEstimatorConstructor = \
637        orange.ConditionalProbabilityEstimatorConstructor_ByRows(
638        estimatorConstructor = orange.ProbabilityEstimatorConstructor_m(m=10))
639    l2.name = '2 - NBC (m=10)'
640
641    l3 = orange.BayesLearner(); l3.name = '3 - NBC (default)'
642
643    l4 = orange.MajorityLearner(); l4.name = "4 - Majority"
644
645    import orngRegression as r
646    r5 = r.LinearRegressionLearner(name="0 - lin reg")
647
648    l5 = Orange.multilabel.BinaryRelevanceLearner()
649
650    testcase = 4
651
652    if testcase == 0: # 1(UPD), 3, 4
653        ow.setData(data2)
654        ow.setLearner(r5, 5)
655        ow.setLearner(l1, 1)
656        ow.setLearner(l2, 2)
657        ow.setLearner(l3, 3)
658        l1.name = l1.name + " UPD"
659        ow.setLearner(l1, 1)
660        ow.setLearner(None, 2)
661        ow.setLearner(l4, 4)
662#        ow.setData(data1)
663#        ow.setData(datar)
664#        ow.setData(data1)
665    if testcase == 1: # data, but all learners removed
666        ow.setLearner(l1, 1)
667        ow.setLearner(l2, 2)
668        ow.setLearner(l1, 1)
669        ow.setLearner(None, 2)
670        ow.setData(data2)
671        ow.setLearner(None, 1)
672    if testcase == 2: # sends data, then learner, then removes the learner
673        ow.setData(data2)
674        ow.setLearner(l1, 1)
675        ow.setLearner(None, 1)
676    if testcase == 3: # regression first
677        ow.setData(datar)
678        ow.setLearner(r5, 5)
679    if testcase == 4: # separate train and test data
680        ow.setData(data3)
681        ow.setTestData(data4)
682        ow.setLearner(l2, 5)
683        ow.setTestData(None)
684    if testcase == 5: # MLC
685        ow.setData(data5)
686        ow.setLearner(l5, 6)
687
688    ow.saveSettings()
Note: See TracBrowser for help on using the repository browser.