source: orange/orange2/OrangeWidgets/Evaluate/OWTestLearners.py @ 9670:5548406b18c0

Revision 9670:5548406b18c0, 27.2 KB checked in by anze <anze.staric@…>, 2 years ago (diff)

Moved orange to Orange (part 1)

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        self.resampling = 0             # cross-validation
110
111        self.stat = self.cStatistics
112
113        self.data = None                # input data set
114        self.testdata = None            # separate test data set
115        self.learners = {}              # set of learners (input)
116        self.results = None             # from orngTest
117        self.preprocessor = None
118
119        self.controlArea.layout().setSpacing(8)
120        # GUI
121        self.sBtns = OWGUI.radioButtonsInBox(self.controlArea, self, "resampling", 
122                                             box="Sampling",
123                                             btnLabels=self.resamplingMethods[:1],
124                                             callback=self.newsampling)
125        indent = OWGUI.checkButtonOffsetHint(self.sBtns.buttons[-1])
126       
127        ibox = OWGUI.widgetBox(OWGUI.indentedBox(self.sBtns, sep=indent))
128        OWGUI.spin(ibox, self, 'nFolds', 2, 100, step=1,
129                   label='Number of folds:',
130                   callback=lambda p=0: self.conditionalRecompute(p),
131                   keyboardTracking=False)
132       
133        OWGUI.separator(self.sBtns, height = 3)
134       
135        OWGUI.appendRadioButton(self.sBtns, self, "resampling", self.resamplingMethods[1])      # leave one out
136        OWGUI.separator(self.sBtns, height = 3)
137        OWGUI.appendRadioButton(self.sBtns, self, "resampling", self.resamplingMethods[2])      # random sampling
138                       
139        ibox = OWGUI.widgetBox(OWGUI.indentedBox(self.sBtns, sep=indent))
140        OWGUI.spin(ibox, self, 'pRepeat', 1, 100, step=1,
141                   label='Repeat train/test:',
142                   callback=lambda p=2: self.conditionalRecompute(p),
143                   keyboardTracking=False)
144       
145        OWGUI.widgetLabel(ibox, "Relative training set size:")
146       
147        OWGUI.hSlider(ibox, self, 'pLearning', minValue=10, maxValue=100,
148                      step=1, ticks=10, labelFormat="   %d%%",
149                      callback=lambda p=2: self.conditionalRecompute(p))
150       
151        OWGUI.separator(self.sBtns, height = 3)
152        OWGUI.appendRadioButton(self.sBtns, self, "resampling", self.resamplingMethods[3])  # test on train
153        OWGUI.separator(self.sBtns, height = 3)
154        OWGUI.appendRadioButton(self.sBtns, self, "resampling", self.resamplingMethods[4])  # test on test
155
156        self.trainDataBtn = self.sBtns.buttons[-2]
157        self.testDataBtn = self.sBtns.buttons[-1]
158        self.testDataBtn.setDisabled(True)
159       
160        OWGUI.separator(self.sBtns)
161        OWGUI.checkBox(self.sBtns, self, 'applyOnAnyChange',
162                       label="Apply on any change", callback=self.applyChange)
163        self.applyBtn = OWGUI.button(self.sBtns, self, "&Apply",
164                                     callback=lambda f=True: self.recompute(f))
165        self.applyBtn.setDisabled(True)
166
167        if self.resampling == 4:
168            self.resampling = 3
169
170        # statistics
171        self.statLayout = QStackedLayout()
172        self.cbox = OWGUI.widgetBox(self.controlArea, addToLayout=False)
173        self.cStatLabels = [s.name for s in self.cStatistics]
174        self.cstatLB = OWGUI.listBox(self.cbox, self, 'selectedCScores',
175                                     'cStatLabels', box = "Performance scores",
176                                     selectionMode = QListWidget.MultiSelection,
177                                     callback=self.newscoreselection)
178       
179        self.cbox.layout().addSpacing(8)
180        self.targetCombo = OWGUI.comboBox(self.cbox, self, "targetClass", orientation=0,
181                                        callback=[self.changedTarget],
182                                        box="Target class")
183
184        self.rStatLabels = [s.name for s in self.rStatistics]
185        self.rbox = OWGUI.widgetBox(self.controlArea, "Performance scores", addToLayout=False)
186        self.rstatLB = OWGUI.listBox(self.rbox, self, 'selectedRScores', 'rStatLabels',
187                                     selectionMode = QListWidget.MultiSelection,
188                                     callback=self.newscoreselection)
189
190        self.mStatLabels = [s.name for s in self.mStatistics]
191        self.mbox = OWGUI.widgetBox(self.controlArea, "Performance scores", addToLayout=False)
192        self.mstatLB = OWGUI.listBox(self.mbox, self, 'selectedMScores', 'mStatLabels',
193                                     selectionMode = QListWidget.MultiSelection,
194                                     callback=self.newscoreselection)
195       
196        self.statLayout.addWidget(self.cbox)
197        self.statLayout.addWidget(self.rbox)
198        self.statLayout.addWidget(self.mbox)
199        self.controlArea.layout().addLayout(self.statLayout)
200       
201        self.statLayout.setCurrentWidget(self.cbox)
202
203        # score table
204        # table with results
205        self.g = OWGUI.widgetBox(self.mainArea, 'Evaluation Results')
206        self.tab = OWGUI.table(self.g, selectionMode = QTableWidget.NoSelection)
207
208        self.resize(680,470)
209
210    # scoring and painting of score table
211    def isclassification(self):
212        if not self.data or not self.data.domain.classVar:
213            return True
214        return self.data.domain.classVar.varType == orange.VarTypes.Discrete
215
216    def ismultilabel(self, data = 42):
217        if data==42:
218            data = self.data
219        if not data:
220            return False
221        return Orange.multilabel.is_multilabel(data)
222
223    def get_usestat(self):
224        return ([self.selectedRScores, self.selectedCScores, self.selectedMScores]
225                [2 if self.ismultilabel() else self.isclassification()])
226
227    def paintscores(self):
228        """paints the table with evaluation scores"""
229
230        self.tab.setColumnCount(len(self.stat)+1)
231        self.tab.setHorizontalHeaderLabels(["Method"] + [s.label for s in self.stat])
232       
233        prec="%%.%df" % self.precision
234
235        learners = [(l.time, l) for l in self.learners.values()]
236        learners.sort()
237        learners = [lt[1] for lt in learners]
238
239        self.tab.setRowCount(len(self.learners))
240        for (i, l) in enumerate(learners):
241            OWGUI.tableItem(self.tab, i,0, l.name)
242           
243        for (i, l) in enumerate(learners):
244            if l.scores:
245                for j in range(len(self.stat)):
246                    if l.scores[j] is not None:
247                        OWGUI.tableItem(self.tab, i, j+1, prec % l.scores[j])
248                    else:
249                        OWGUI.tableItem(self.tab, i, j+1, "N/A")
250            else:
251                for j in range(len(self.stat)):
252                    OWGUI.tableItem(self.tab, i, j+1, "")
253       
254        # adjust the width of the score table cloumns
255        self.tab.resizeColumnsToContents()
256        self.tab.resizeRowsToContents()
257        usestat = self.get_usestat()
258        for i in range(len(self.stat)):
259            if i not in usestat:
260                self.tab.hideColumn(i+1)
261
262    def sendReport(self):
263        exset = []
264        if self.resampling == 0:
265            exset = [("Folds", self.nFolds)]
266        elif self.resampling == 2:
267            exset = [("Repetitions", self.pRepeat), ("Proportion of training instances", "%i%%" % self.pLearning)]
268        else:
269            exset = []
270        if not self.ismultilabel():
271            self.reportSettings("Validation method",
272                            [("Method", self.resamplingMethods[self.resampling])]
273                            + exset +
274                            ([("Target class", self.data.domain.classVar.values[self.targetClass])] if self.data else []))
275        else:
276             self.reportSettings("Validation method",
277                            [("Method", self.resamplingMethods[self.resampling])]
278                            + exset)
279       
280        self.reportData(self.data)
281
282        if self.data:       
283            self.reportSection("Results")
284            learners = [(l.time, l) for l in self.learners.values()]
285            learners.sort()
286            learners = [lt[1] for lt in learners]
287            usestat = self.get_usestat()
288            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>"
289            for i, l in enumerate(learners):
290                res += "<tr><th><b>%s</b></th>" % l.name
291                if l.scores:
292                    for j in usestat:
293                        scr = l.scores[j]
294                        res += "<td>" + ("%.4f" % scr if scr is not None else "") + "</td>"
295                res += "</tr>"
296            res += "</table>"
297            self.reportRaw(res)
298           
299    def score(self, ids):
300        """compute scores for the list of learners"""
301        if (not self.data):
302            for id in ids:
303                self.learners[id].results = None
304                self.learners[id].scores = []
305            return
306        # test which learners can accept the given data set
307        # e.g., regressions can't deal with classification data
308        learners = []
309        used_ids = []
310        n = len(self.data.domain.attributes)*2
311        indices = orange.MakeRandomIndices2(p0=min(n, len(self.data)), stratified=orange.MakeRandomIndices2.StratifiedIfPossible)
312        new = self.data.selectref(indices(self.data))
313       
314        multilabel = self.ismultilabel()
315       
316        self.warning(0)
317        learner_exceptions = []
318        for l in [self.learners[id] for id in ids]:
319            learner = l.learner
320            if self.preprocessor:
321                learner = self.preprocessor.wrapLearner(learner)
322            try:
323                predictor = learner(new)
324                if (multilabel and isinstance(learner, Orange.multilabel.MultiLabelLearner)) or predictor(new[0]).varType == new.domain.classVar.varType:
325                    learners.append(learner)
326                    used_ids.append(l.id)
327                else:
328                    l.scores = []
329                    l.results = None
330
331            except Exception, ex:
332                learner_exceptions.append((l, ex))
333                l.scores = []
334                l.results = None
335
336        if learner_exceptions:
337            text = "\n".join("Learner %s ends with exception: %s" % (l.name, str(ex)) \
338                             for l, ex in learner_exceptions)
339            self.warning(0, text)
340           
341        if not learners:
342            return
343
344        # computation of results (res, and cm if classification)
345        pb = None
346        if self.resampling==0:
347            pb = OWGUI.ProgressBar(self, iterations=self.nFolds)
348            res = orngTest.crossValidation(learners, self.data, folds=self.nFolds,
349                                           strat=orange.MakeRandomIndices.StratifiedIfPossible,
350                                           callback=pb.advance, storeExamples = True)
351            pb.finish()
352        elif self.resampling==1:
353            pb = OWGUI.ProgressBar(self, iterations=len(self.data))
354            res = orngTest.leaveOneOut(learners, self.data,
355                                       callback=pb.advance, storeExamples = True)
356            pb.finish()
357        elif self.resampling==2:
358            pb = OWGUI.ProgressBar(self, iterations=self.pRepeat)
359            res = orngTest.proportionTest(learners, self.data, self.pLearning/100.,
360                                          times=self.pRepeat, callback=pb.advance, storeExamples = True)
361            pb.finish()
362        elif self.resampling==3:
363            pb = OWGUI.ProgressBar(self, iterations=len(learners))
364            res = orngTest.learnAndTestOnLearnData(learners, self.data, storeExamples = True, callback=pb.advance)
365            pb.finish()
366           
367        elif self.resampling==4:
368            if not self.testdata:
369                for l in self.learners.values():
370                    l.scores = []
371                return
372            pb = OWGUI.ProgressBar(self, iterations=len(learners))
373            res = orngTest.learnAndTestOnTestData(learners, self.data, self.testdata, storeExamples = True, callback=pb.advance)
374            pb.finish()
375           
376        if not self.ismultilabel() and self.isclassification():
377            cm = orngStat.computeConfusionMatrices(res, classIndex = self.targetClass)
378        else:
379            cm = None
380
381        if self.preprocessor: # Unwrap learners
382            learners = [l.wrappedLearner for l in learners]
383           
384        res.learners = learners
385       
386        for l in [self.learners[id] for id in ids]:
387            if l.learner in learners:
388                l.results = res
389            else:
390                l.results = None
391
392        self.error(range(len(self.stat)))
393        scores = []
394       
395        for i, s in enumerate(self.stat):
396            if s.cmBased:
397                try:
398                    scores.append(dispatch(s, res, cm))
399                except Exception, ex:
400                    self.error(i, "An error occurred while evaluating orngStat." + s.f + "on %s due to %s" % \
401                               (" ".join([l.name for l in learners]), ex.message))
402                    scores.append([None] * len(self.learners))
403            else:
404                scores_one = []
405                for res_one in orngStat.split_by_classifiers(res):
406                    try:
407                        scores_one.extend(dispatch(s, res_one, cm))
408                    except Exception, ex:
409                        self.error(i, "An error occurred while evaluating orngStat." + s.f + "on %s due to %s" % \
410                                   (res.classifierNames[0], ex.message))
411                        scores_one.append(None)
412                scores.append(scores_one)
413
414        for i, (id, l) in enumerate(zip(used_ids, learners)):
415            self.learners[id].scores = [s[i] if s else None for s in scores]
416           
417        self.sendResults()
418
419    def recomputeCM(self):
420        if not self.results:
421            return
422        cm = orngStat.computeConfusionMatrices(self.results, classIndex = self.targetClass)
423        scores = [(indx, eval("orngStat." + s.f))
424                  for (indx, s) in enumerate(self.stat) if s.cmBased]
425        for (indx, score) in scores:
426            for (i, l) in enumerate([l for l in self.learners.values() if l.scores]):
427                learner_indx = self.results.learners.index(l.learner)
428                l.scores[indx] = score[learner_indx]
429
430        self.paintscores()
431       
432    def clearScores(self, ids=None):
433        if ids is None:
434            ids = self.learners.keys()
435
436        for id in ids:
437            self.learners[id].scores = []
438            self.learners[id].results = None
439
440    # handle input signals
441    def setData(self, data):
442        """handle input train data set"""
443        self.closeContext()
444       
445        multilabel= self.ismultilabel(data)
446        if not multilabel:
447            self.data = self.isDataWithClass(data, checkMissing=True) and data or None
448        else:
449            self.data = data
450       
451        self.fillClassCombo()
452        if not self.data:
453            # data was removed, remove the scores
454            self.clearScores()
455            self.send("Evaluation Results", None)
456        else:
457            # new data has arrived
458            self.clearScores()
459
460            if not multilabel:
461                self.data = orange.Filter_hasClassValue(self.data)
462
463            self.statLayout.setCurrentWidget([self.rbox, self.cbox, self.mbox][2 if self.ismultilabel() else self.isclassification()])
464
465            self.stat = [self.rStatistics, self.cStatistics, self.mStatistics][2 if self.ismultilabel() else self.isclassification()]
466
467            if self.learners:
468                self.score([l.id for l in self.learners.values()])
469           
470        self.openContext("", data)
471        self.paintscores()
472
473    def setTestData(self, data):
474        """handle test data set"""
475        if data is None:
476            self.testdata = None
477        else:
478            self.testdata = orange.Filter_hasClassValue(data)
479        self.testDataBtn.setEnabled(self.testdata is not None)
480        if self.testdata is not None:
481            if self.resampling == 4:
482                if self.data:
483                    self.score([l.id for l in self.learners.values()])
484                else:
485                    for l in self.learners.values():
486                        l.scores = []
487                self.paintscores()
488        elif self.resampling == 4 and self.data:
489            # test data removed, switch to testing on train data
490            self.resampling = 3
491            self.recompute()
492
493    def fillClassCombo(self):
494        """upon arrival of new data appropriately set the target class combo"""
495        self.targetCombo.clear()
496        if not self.data or not self.data.domain.classVar or not self.isclassification():
497            return
498
499        domain = self.data.domain
500        self.targetCombo.addItems([str(v) for v in domain.classVar.values])
501       
502        if self.targetClass<len(domain.classVar.values):
503            self.targetCombo.setCurrentIndex(self.targetClass)
504        else:
505            self.targetCombo.setCurrentIndex(0)
506            self.targetClass=0
507
508    def setLearner(self, learner, id=None):
509        """add/remove a learner"""
510        if learner: # a new or updated learner
511            if id in self.learners: # updated learner
512                time = self.learners[id].time
513                self.learners[id] = Learner(learner, id)
514                self.learners[id].time = time
515            else: # new learner
516                self.learners[id] = Learner(learner, id)
517            if self.applyBtn.isEnabled():
518                self.recompute(True)
519            else:
520                self.score([id])
521        else: # remove a learner and corresponding results
522            if id in self.learners:
523                res = self.learners[id].results
524                if res and res.numberOfLearners > 1:
525                    old_learner = self.learners[id].learner
526                    indx = res.learners.index(old_learner)
527                    res.remove(indx)
528                    del res.learners[indx]
529                del self.learners[id]
530            self.sendResults()
531        self.paintscores()
532       
533    def setPreprocessor(self, pp):
534        self.preprocessor = pp
535        if self.learners:
536            self.score([l.id for l in self.learners.values()])
537            self.paintscores()
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.