source: orange/Orange/OrangeWidgets/Evaluate/OWTestLearners.py @ 10450:6e03e9c44985

Revision 10450:6e03e9c44985, 27.1 KB checked in by Lan Zagar <lan.zagar@…>, 2 years ago (diff)

Removed automatic testing on changes when it is disabled in Test Learners widget.

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