Changeset 3482:00436aa26b43 in orange


Ignore:
Timestamp:
04/04/07 13:23:13 (7 years ago)
Author:
Gregor <Gregor@…>
Branch:
default
Convert:
82f1c850520954c9b232b5466d4dc09c3bc181ee
Message:
  • removed ExampleTableWithClass
  • changed signal names
Location:
orange/OrangeWidgets
Files:
16 edited

Legend:

Unmodified
Added
Removed
  • orange/OrangeWidgets/Classify/OWC45Tree.py

    r3394 r3482  
    33<description>C45 (classification tree) learner/classifier.</description> 
    44<icon>icons/C45.png</icon> 
    5 <contact>Janez Demsar (janez.demsar(@at@)fri.uni-lj.si)</contact>  
     5<contact>Janez Demsar (janez.demsar(@at@)fri.uni-lj.si)</contact> 
    66<priority>35</priority> 
    77""" 
     
    2020    def __init__(self, parent=None, signalManager = None, name='C4.5'): 
    2121        OWWidget.__init__(self, parent, signalManager, name) 
    22          
     22 
    2323        self.callbackDeposit = [] 
    2424 
    25         self.inputs = [("Classified Examples", ExampleTableWithClass, self.cdata)] 
     25        self.inputs = [("Examples", ExampleTable, self.setData)] 
    2626        self.outputs = [("Learner", orange.Learner),("Classifier", orange.Classifier),("Classification Tree", orange.TreeClassifier), ("C45 Tree", orange.C45Classifier)] 
    2727 
     
    3333 
    3434        self.convertToOrange = 1 
    35          
     35 
    3636        self.loadSettings() 
    37          
     37 
    3838        self.data = None                    # input data set 
    3939        self.preprocessor = None            # no preprocessing as default 
    40          
     40 
    4141        OWGUI.lineEdit(self.controlArea, self, 'name', box='Learner/Classifier Name', \ 
    4242                 tooltip='Name to be used by other widgets to identify your learner/classifier.') 
     
    6666 
    6767        OWGUI.separator(self.controlArea) 
    68          
     68 
    6969        OWGUI.checkBox(self.controlArea, self, 'convertToOrange', 'Convert to orange tree structure', box = 1) 
    7070 
    7171        OWGUI.separator(self.controlArea) 
    72          
     72 
    7373        OWGUI.button(self.controlArea, self, "&Apply Setting", callback = self.setLearner, disabled=0) 
    7474 
     
    7676 
    7777    def activateLoadedSettings(self): 
    78         self.setLearner()     
     78        self.setLearner() 
    7979 
    80     # main part:          
     80    # main part: 
    8181 
    82     def cdata(self,data): 
    83         self.data = data 
     82    def setData(self,data): 
     83        self.data = self.isDataWithClass(data, orange.VarTypes.Discrete) and data or None 
    8484        self.setLearner() 
    8585 
     
    8888        try: 
    8989            self.learner = orange.C45Learner(gainRatio=not self.infoGain, subset=self.subset, probThresh=self.probThresh, 
    90                                              minObjs=self.useMinObjs and self.minObjs or 0, prune=self.prune, cf=self.cf/100.,  
     90                                             minObjs=self.useMinObjs and self.minObjs or 0, prune=self.prune, cf=self.cf/100., 
    9191                                             batch = not self.iterative, window=self.manualWindow and self.window or 0, increment=self.manualIncrement and self.increment or 0, trials=self.trials, 
    9292                                             convertToOrange = self.convertToOrange, storeExamples = 1) 
     
    9797        self.learner.name = self.name 
    9898        self.send("Learner", self.learner) 
    99          
     99 
    100100        self.learn() 
    101101 
    102          
     102 
    103103    def learn(self): 
    104104        self.error() 
     
    137137 
    138138##    dataset = orange.ExampleTable('adult_sample') 
    139 ##    ow.cdata(dataset) 
     139##    ow.setData(dataset) 
    140140 
    141141    ow.show() 
  • orange/OrangeWidgets/Classify/OWCN2RulesViewer.py

    r3465 r3482  
    33<description>Viewer of classification rules.</description> 
    44<icon>CN2RulesViewer.png</icon> 
    5 <contact>Ales Erjavec (ales.erjavec(@at@)fri.uni-lj.si)</contact>  
     5<contact>Ales Erjavec (ales.erjavec(@at@)fri.uni-lj.si)</contact> 
    66<priority>2120</priority> 
    77""" 
     
    3434                self.parent.select() 
    3535                self.lastIndex=obj[-1].index 
    36      
     36 
    3737    def contentsMousePressEvent(self,e): 
    3838        self.buttonPressed=True 
     
    4242            for r in self.parent.rectObj: 
    4343                r.setBrush(QBrush(Qt.NoBrush)) 
    44                 
     44 
    4545    def contentsMouseReleaseEvent(self,e): 
    4646        self.flag=False 
     
    6363            self.parent.selRect.append(rect) 
    6464            rect.setBrush(self.brush) 
    65         self.parent.canvas.update()          
     65        self.parent.canvas.update() 
    6666 
    6767class OWCN2RulesViewer(OWWidget): 
     
    7070    def __init__(self, parent=None, signalManager=None): 
    7171        OWWidget.__init__(self, parent, signalManager,"CN2 Rules Viewer") 
    72          
    73         self.inputs=[("Rule Classifier", orange.RuleClassifier, self.data)] 
    74         self.outputs=[("Examples", ExampleTable), ("Classified Examples", ExampleTableWithClass), ("Attribute List", AttributeList)] 
     72 
     73        self.inputs=[("Rule Classifier", orange.RuleClassifier, self.setRuleClassifier)] 
     74        self.outputs=[("Examples", ExampleTable), ("Attribute List", AttributeList)] 
    7575        self.RuleLen=1 
    7676        self.RuleQ=1 
     
    9696        layout.addWidget(self.headerView) 
    9797        layout.addWidget(self.canvasView) 
    98          
     98 
    9999        box=OWGUI.widgetBox(self.controlArea,"Show info") 
    100100 
     
    108108        OWGUI.separator(self.controlArea) 
    109109        box=OWGUI.widgetBox(self.controlArea,"Sorting") 
     110        box.setSizePolicy(QSizePolicy(QSizePolicy.Fixed,QSizePolicy.Fixed)) 
    110111        self.sortBox=OWGUI.comboBox(box, self, "Sort",  
    111112                                    items=["No sorting", "Rule length", "Rule quality", "Coverage", "Predicted class", 
     
    119120 
    120121        QVBox(self.controlArea) 
    121          
    122         OWGUI.button(self.controlArea,self,"&Save rules to file",callback=self.saveRules) 
     122 
     123        OWGUI.button(self.controlArea,self,"&Save rules to file",callback=self.saveRules, debuggingEnabled = 0) 
    123124 
    124125        self.examples=None 
     
    126127        self.selRect=[] 
    127128        self.rectObj=[] 
    128          
     129 
    129130        self.ctrlPressed=False 
    130131        self.setFocusPolicy(QWidget.StrongFocus) 
     
    151152        #self.items=items 
    152153        self.drawRules() 
    153          
     154 
    154155 
    155156    def drawRules(self): 
     
    174175        items.append(l) 
    175176        self.obj.extend(l) 
    176          
     177 
    177178        for text in self.text: 
    178179            l=[] 
     
    199200            if self.DistBar: 
    200201                t=DistBar(text[5],self.Dist,self.canvas) 
    201                 l.append(t)                     
     202                l.append(t) 
    202203            if self.Rule: 
    203204                t=QCanvasText(self.canvas) 
     
    207208            self.obj.extend(l) 
    208209            items.append(l) 
    209                  
     210 
    210211        textMapV=[10]+map(lambda s:max([t.boundingRect().height()+10 for t in s]), items[1:]) 
    211212        textMapH=[[s[i].boundingRect().width()+10 for s in items] for i in range(len(items[0]))] 
     
    217218        for i in range(1,len(textMapH)): 
    218219            textMapH[i]+=textMapH[i-1] 
    219              
     220 
    220221        self.ctrlPressed=True 
    221222        for i in range(1,len(textMapV)): 
     
    237238            self.rectObj.append(r) 
    238239        self.ctrlPressed=False 
    239              
     240 
    240241        self.canvas.resize(textMapH[-1], textMapV[-1]) 
    241242        for i,t in enumerate(items[0][:-1]): 
     
    245246        self.headerCanvas.resize(textMapH[-1]+20,20) 
    246247        self.canvas.update() 
    247          
     248 
    248249    def ruleText(self, r): 
    249250        str=orngCN2.ruleToString(r) 
     
    285286        if self.Commit: 
    286287            self.commit() 
    287              
    288     def data(self, classifier): 
     288 
     289    def setRuleClassifier(self, classifier): 
    289290        if classifier: 
    290291            self.clear() 
     
    304305            return 1 
    305306        else: 
    306             return -1     
     307            return -1 
    307308    def compareDist(self,a,b): 
    308309##        if max(a[-1].classDistribution)/a[-1].classDistribution.abs \ 
     
    314315        else: 
    315316            return -1 
    316          
     317 
    317318    def sort(self): 
    318319        text=[] 
     
    330331            self.text.sort(self.compare) 
    331332        if self.Sort>=2 and self.Sort!=4 and self.Sort !=6: 
    332             self.text.reverse()      
     333            self.text.reverse() 
    333334 
    334335    def selectAttributes(self): 
     
    342343                selected.append(s[0]) 
    343344        selected=reduce(lambda l,r:(r in l) and l or l+[r], selected, []) 
    344         return selected           
     345        return selected 
    345346 
    346347    def commit(self): 
     
    354355            else: 
    355356                examples = orange.ExampleTable(self.examples) 
    356             self.send("Classified Examples", examples) 
    357357            self.send("Examples", examples) 
    358358            self.send("Attribute List", orange.VarList(varList)) 
    359359        else: 
    360             self.send("Classified Examples", None) 
    361360            self.send("Examples",None) 
    362361            self.send("Attribute List", None) 
    363              
     362 
    364363 
    365364    def saveRules(self): 
     
    371370        for r in self.rules: 
    372371            f.write(orngCN2.ruleToString(r)+"\n") 
    373              
     372 
    374373    def keyPressEvent(self, key): 
    375374        if key.key()==Qt.Key_Control: 
     
    396395        self.barWidth=max([barWidth, showText and self.text.boundingRect().width()]) 
    397396        self.setSize(self.barWidth, barHeight) 
    398          
     397 
    399398    def fixGeom(self, width): 
    400399        distText=self.distText.strip("<>") 
     
    410409                r.setBrush(QBrush(classColor[i])) 
    411410            self.rect.append(r) 
    412              
     411 
    413412    def move(self, x,y): 
    414413        if self.showText: 
     
    421420            pos+=r.width() 
    422421        self.text.move(x,ty) 
    423              
     422 
    424423    def show(self): 
    425424        for r in self.rect: 
     
    431430            r.setCanvas(canvas) 
    432431        self.text.setCanvas(canvas) 
    433      
    434      
     432 
     433 
    435434if __name__=="__main__": 
    436435    ap=QApplication(sys.argv) 
     
    440439    l=orngCN2.CN2UnorderedLearner() 
    441440    l.ruleFinder.ruleStoppingValidator=orange.RuleValidator_LRS() 
    442     w.data(l(data)) 
    443     w.data(l(data)) 
     441    w.setRuleClassifier(l(data)) 
     442    w.setRuleClassifier(l(data)) 
    444443    w.show() 
    445444    ap.exec_loop() 
    446      
     445 
  • orange/OrangeWidgets/Classify/OWClassificationTree.py

    r3350 r3482  
    33<description>Classification tree learner/classifier.</description> 
    44<icon>icons/ClassificationTree.png</icon> 
    5 <contact>Janez Demsar (janez.demsar(@at@)fri.uni-lj.si)</contact>  
     5<contact>Janez Demsar (janez.demsar(@at@)fri.uni-lj.si)</contact> 
    66<priority>30</priority> 
    77""" 
     
    2020 
    2121    measures = (("Information Gain", "infoGain"), ("Gain Ratio", "gainRatio"), ("Gini Index", "gini"), ("ReliefF", "relief")) 
    22      
     22 
    2323    def __init__(self, parent=None, signalManager = None, name='Classification Tree'): 
    2424        OWWidget.__init__(self, parent, signalManager, name) 
    2525 
    26         self.inputs = [("Classified Examples", ExampleTableWithClass, self.dataset)] 
     26        self.inputs = [("Examples", ExampleTable, self.setData)] 
    2727        self.outputs = [("Learner", orange.TreeLearner),("Classification Tree", orange.TreeClassifier)] 
    2828 
     
    3333        self.preLeafInst = 1; self.preNodeInst = 0; self.preNodeMaj = 0 
    3434        self.postMaj = 1; self.postMPruning = 1; self.postM = 2.0 
    35          
     35 
    3636        self.loadSettings() 
    37          
     37 
    3838        self.data = None 
    3939        self.preprocessor = None 
    4040        self.setLearner() 
    41          
     41 
    4242        OWGUI.lineEdit(self.controlArea, self, 'name', box='Learner/Classifier Name', tooltip='Name to be used by other widgets to identify your learner/classifier.') 
    4343        OWGUI.separator(self.controlArea) 
    44          
     44 
    4545        qBox = QVGroupBox(self.controlArea) 
    4646        qBox.setTitle('Attribute selection criterion') 
    4747 
    4848        self.qMea = OWGUI.comboBox(qBox, self, "estim", items = [m[0] for m in self.measures], callback = self.measureChanged) 
    49          
     49 
    5050        b1 = QHBox(qBox) 
    5151        OWGUI.separator(b1, 16, 0) 
     
    5555        self.hbxRel2 = OWGUI.spin(b2, self, "relK", 1, 50, orientation="horizontal", label="Number of neighbours in ReliefF  ") 
    5656        OWGUI.separator(self.controlArea) 
    57          
     57 
    5858        OWGUI.checkBox(self.controlArea, self, 'bin', 'Binarization', box='Tree Structure') 
    5959        OWGUI.separator(self.controlArea) 
     
    6767        self.preNodeInstBox, self.preNodeInstPBox = OWGUI.checkWithSpin(self.pBox, self, "Stop splitting nodes with ", 1, 1000, "preNodeInst", "preNodeInstP", " or fewer instances") 
    6868        self.preNodeMajBox, self.preNodeMajPBox = OWGUI.checkWithSpin(self.pBox, self, "Stop splitting nodes with ", 1, 100, "preNodeMaj", "preNodeMajP", "% of majority class") 
    69          
     69 
    7070        OWGUI.separator(self.controlArea) 
    7171        self.mBox = QVGroupBox(self.controlArea) 
     
    9292            mForPruning = self.postMPruning and self.postM, 
    9393            storeExamples = 1) 
    94                                     
     94 
    9595        self.learner.name = self.name 
    9696        self.send("Learner", self.learner) 
     
    9898        self.error() 
    9999        if self.data: 
    100             if not self.data.domain.classVar: 
    101                 self.error("This data set has no class.") 
     100            try: 
     101                self.classifier = self.learner(self.data) 
     102                self.classifier.name = self.name 
     103            except Exception, (errValue): 
     104                self.error(str(errValue)) 
    102105                self.classifier = None 
    103             elif self.data.domain.classVar.varType != orange.VarTypes.Discrete: 
    104                 self.error("This widget only works with discrete classes.\nThere is another one for regression classes.") 
    105                 self.classifier = None 
    106             else: 
    107                 try: 
    108                     self.classifier = self.learner(self.data) 
    109                     self.classifier.name = self.name 
    110                 except Exception, (errValue): 
    111                     self.error(str(errValue)) 
    112                     self.classifier = None 
    113106        else: 
    114107            self.classifier = None 
     
    122115        self.hbxRel2.setEnabled(relief) 
    123116        self.cbLimitRef.setEnabled(relief) 
    124          
    125     def dataset(self,data): 
    126         self.data = data 
    127         if self.data: 
    128             self.setLearner() 
    129         else: 
    130             self.send("Classification Tree", None) 
     117 
     118    def setData(self,data): 
     119        self.data = self.isDataWithClass(data, orange.VarTypes.Discrete) and data or None 
     120        self.setLearner() 
     121 
    131122 
    132123############################################################################## 
     
    141132 
    142133    d = orange.ExampleTable('adult_sample') 
    143     ow.dataset(d) 
     134    ow.setData(d) 
    144135 
    145136    ow.show() 
  • orange/OrangeWidgets/Classify/OWClassificationTreeGraph.py

    r3476 r3482  
    33<description>Classification tree viewer (graph view).</description> 
    44<icon>icons/ClassificationTreeGraph.png</icon> 
    5 <contact>Blaz Zupan (blaz.zupan(@at@)fri.uni-lj.si)</contact>  
     5<contact>Blaz Zupan (blaz.zupan(@at@)fri.uni-lj.si)</contact> 
    66<priority>2110</priority> 
    77""" 
     
    3232        self.addTextLine(fitSquare=False) 
    3333        self.addTextLine(self.name, fitSquare=False) 
    34              
     34 
    3535        self.rule=(isinstance(self.parent, QCanvasRectangle) and self.parent.rule+[(self.parent.tree.branchSelector.classVar, attrVal)]) or [] 
    36          
     36 
    3737        #print self.rule 
    3838        #self.textObj.extend([self.title, self.name]+self.textList) 
    39         self.textInd=[]         
     39        self.textInd=[] 
    4040        self.pieObj=[] 
    4141        distSum=sum(self.dist) 
     
    5656        self.pieObj.append(e) 
    5757        self.canvasObj.extend(self.pieObj) 
    58         self.isPieShown=True             
     58        self.isPieShown=True 
    5959 
    6060    def setSize(self,w,h): 
     
    7070        if self.textObj: 
    7171            self.textObj[0].setColor(Qt.black) 
    72              
     72 
    7373    def show(self): 
    7474        CanvasNode.show(self) 
     
    8585            for e in self.pieObj: 
    8686                e.hide() 
    87                  
     87 
    8888    def setText(self, textInd=[]): 
    8989        self.textInd=textInd 
     
    9494        for i in range(len(textInd),2): 
    9595            CanvasNode.setText(self, i+1, "", fitSquare=False) 
    96          
     96 
    9797    def updateText(self): 
    9898        self.textAdvance=float(self.height())/3 
     
    127127                    interval[i][0]=("=" in rule[i][1] and "[") or "(" 
    128128                    interval[i][1]=float(rule[i][1].strip("<>= ")) 
    129                 
     129 
    130130        inter=[None]*4 
    131131 
     
    137137            interval.reverse() 
    138138        inter[2:]=interval[0][2:] 
    139              
     139 
    140140 
    141141        if 1e1000 in inter or -1e1000 in inter: 
     
    146146            rule="in "+inter[0]+str(inter[1])+","+str(inter[2])+inter[3] 
    147147        return (rule1[0], rule) 
    148      
     148 
    149149    def joinDisc(rule1, rule2): 
    150150        r1,r2=rule1[1],rule2[1] 
     
    171171        else: 
    172172            newRules.append(r) 
    173     return newRules       
     173    return newRules 
    174174 
    175175BodyColor_Default = QColor(255, 225, 10) 
     
    182182        OWTreeViewer2D.__init__(self, parent, signalManager, name) 
    183183        self.settingsList=OWTreeViewer2D.settingsList+["ShowPies"] 
    184          
     184 
    185185        self.inputs = [("Classification Tree", orange.TreeClassifier, self.ctree)] 
    186186        self.outputs = [("Examples", ExampleTable)] 
     
    216216            self.NodeInfoW.append(w) 
    217217 
    218         OWGUI.comboBox(self.NodeTab, self, 'NodeColorMethod', items=['Default', 'Instances in node', 'Majority class probability', 'Target class probability', 'Target class distribution'], box='Node Color',                             
     218        OWGUI.comboBox(self.NodeTab, self, 'NodeColorMethod', items=['Default', 'Instances in node', 'Majority class probability', 'Target class probability', 'Target class distribution'], box='Node Color', 
    219219                                callback=self.toggleNodeColor) 
    220220 
     
    224224        self.NodeInfoSorted=list(self.NodeInfo) 
    225225        self.NodeInfoSorted.sort() 
    226          
     226 
    227227    def setNodeInfo(self, widget=None, id=None): 
    228228        if widget: 
     
    243243    def activateLoadedSettings(self): 
    244244        if not self.tree: 
    245             return  
     245            return 
    246246        OWTreeViewer2D.activateLoadedSettings(self) 
    247247        self.setNodeInfo() 
    248248        self.toggleNodeColor() 
    249          
     249 
    250250    def toggleNodeColor(self): 
    251251        for node in self.canvas.nodeList: 
     
    275275                n.setText(self.NodeInfoSorted) 
    276276        self.canvas.update() 
    277                  
     277 
    278278    def togglePies(self): 
    279279        for n in self.canvas.nodeList: 
     
    338338        if ext=="DOT": 
    339339            orngTree.printDot(self.tree, fileName) 
    340             return  
     340            return 
    341341        dSize= self.canvas.size() 
    342         buffer = QPixmap(dSize.width(),dSize.height()) # any size can do, now using the window size      
     342        buffer = QPixmap(dSize.width(),dSize.height()) # any size can do, now using the window size 
    343343        painter = QPainter(buffer) 
    344          
     344 
    345345        painter.fillRect(buffer.rect(), QBrush(QColor(255, 255, 255))) # make background same color as the widget's background 
    346346        self.canvasView.drawContents(painter,0,0,dSize.width(), dSize.height()) 
    347347        painter.end() 
    348348        buffer.save(fileName, ext) 
    349      
     349 
    350350if __name__=="__main__": 
    351351    a = QApplication(sys.argv) 
  • orange/OrangeWidgets/Classify/OWClassificationTreeViewer.py

    r2893 r3482  
    33<description>Classification tree viewer (hierarchical list view).</description> 
    44<icon>icons/ClassificationTreeViewer.png</icon> 
    5 <contact>Janez Demsar (janez.demsar(@at@)fri.uni-lj.si)</contact>  
     5<contact>Janez Demsar (janez.demsar(@at@)fri.uni-lj.si)</contact> 
    66<priority>2100</priority> 
    77""" 
     
    1919        self.f = f 
    2020        widget.callbackDeposit.append(self) 
    21          
     21 
    2222    def __call__(self, value): 
    2323        setattr(self.widget, self.attribute, self.f and self.f(value) or value) 
     
    4545        self.callbackDeposit = [] 
    4646 
    47         self.inputs = [("Classification Tree", orange.TreeClassifier, self.ctree), ("Target Class Value", int, self.target)] 
    48         self.outputs = [("Classified Examples", ExampleTableWithClass)] 
     47        self.inputs = [("Classification Tree", orange.TreeClassifier, self.setClassificationTree), ("Target Class Value", int, self.setTarget)] 
     48        self.outputs = [("Examples", ExampleTable)] 
    4949 
    5050        # Settings 
     
    5959        self.precision = 0 
    6060        self.precFrmt = "%%.%if" % self.precision 
    61          
     61 
    6262        # GUI 
    6363        # parameters 
    64          
     64 
    6565        self.dBox = QVGroupBox(self.controlArea) 
    6666        self.dBox.setTitle('Show Data') 
     
    7070 
    7171        OWGUI.separator(self.controlArea) 
    72          
     72 
    7373        self.expBox = QHGroupBox(self.controlArea) 
    7474        self.expBox.setSizePolicy(QSizePolicy(QSizePolicy.Minimum , QSizePolicy.Fixed )) 
     
    7878 
    7979        OWGUI.separator(self.controlArea) 
    80          
     80 
    8181        self.infBox = QVGroupBox(self.controlArea) 
    8282        self.infBox.setSizePolicy(QSizePolicy(QSizePolicy.Minimum , QSizePolicy.Fixed )) 
     
    8585        self.infob = QLabel('', self.infBox) 
    8686 
    87         OWGUI.rubber(self.controlArea)         
     87        OWGUI.rubber(self.controlArea) 
    8888 
    8989        # list view 
     
    103103        #self.rule.setMaximumHeight(100) 
    104104        #self.layout.add(self.rule) 
    105          
     105 
    106106        self.splitter.show() 
    107          
     107 
    108108        self.resize(800,400) 
    109109 
     
    111111        self.connect(self.slider, SIGNAL("valueChanged(int)"), self.sliderChanged) 
    112112 
    113     # main part:          
     113    # main part: 
    114114 
    115115    def setTreeView(self, updateonly = 0): 
     
    118118        def addNode(node, parent, desc, anew): 
    119119            return li 
    120                  
     120 
    121121        def walkupdate(listviewitem): 
    122122            node = self.nodeClassDict[listviewitem] 
     
    131131                    reduce(lambda x,y: x+':'+y, [self.precFrmt % x for x in dist]) 
    132132                   ) 
    133                     
     133 
    134134            col = 1 
    135135            for j in range(6): 
     
    156156                        self.nodeClassDict[li] = node.branches[i] 
    157157                        walkcreate(node.branches[i], li) 
    158              
     158 
    159159        while self.v.columns()>1: 
    160160            self.v.removeColumn(1) 
    161              
     161 
    162162        for i in range(len(self.dataLabels)): 
    163163            if getattr(self, self.settingsList[i]): 
     
    181181        self.v.show() 
    182182 
    183     # slots: handle input signals         
    184          
    185     def ctree(self, tree): 
     183    # slots: handle input signals 
     184 
     185    def setClassificationTree(self, tree): 
    186186        if tree and (not tree.classVar or tree.classVar.varType != orange.VarTypes.Discrete): 
    187187            self.error("This viewer only shows trees with discrete classes.\nThere is another viewer for regression trees") 
     
    190190            self.error() 
    191191            self.tree = tree 
    192              
     192 
    193193        self.setTreeView() 
    194194 
     
    200200            self.infob.setText('') 
    201201 
    202     def target(self, target): 
     202    def setTarget(self, target): 
    203203        def updatetarget(listviewitem): 
    204204            dist = self.nodeClassDict[listviewitem].distribution 
     
    209209                updatetarget(child) 
    210210                child = child.nextSibling() 
    211              
     211 
    212212        if self.ptarget and (self.tar <> target): 
    213213            self.tar = target 
     
    220220                    targetindex += 1 
    221221 
    222             f = self.precFrmt             
     222            f = self.precFrmt 
    223223            updatetarget(self.v.firstChild()) 
    224              
     224 
    225225    def expandTree(self, lev): 
    226226        def expandTree0(listviewitem, lev): 
     
    233233                    expandTree0(child, lev-1) 
    234234                    child = child.nextSibling() 
    235                      
     235 
    236236        expandTree0(self.v.firstChild(), lev) 
    237237 
     
    240240        if self.tree: 
    241241            data = self.nodeClassDict[item].examples 
    242             self.send("Classified Examples", data) 
     242            self.send("Examples", data) 
    243243 
    244244            tx = "" 
     
    251251                else: 
    252252                    tx = str(item.text(0)) + " AND\n    "+tx 
    253                      
     253 
    254254                item = item.parent() 
    255255 
     
    261261                self.rule.setText("%s = %s" % (className, classLabel)) 
    262262        else: 
    263             self.send("Classified Examples", None) 
     263            self.send("Examples", None) 
    264264            self.rule.setText("") 
    265265 
     
    281281 
    282282    tree = orange.TreeLearner(data, storeExamples = 1) 
    283     ow.ctree(tree) 
     283    ow.setClassificationTree(tree) 
    284284 
    285285    ow.show() 
  • orange/OrangeWidgets/Classify/OWITree.py

    r3191 r3482  
    33<description>Interactive Tree Builder</description> 
    44<icon>icons/ITree.png</icon> 
    5 <contact>Janez Demsar (janez.demsar(@at@)fri.uni-lj.si)</contact>  
     5<contact>Janez Demsar (janez.demsar(@at@)fri.uni-lj.si)</contact> 
    66<priority>50</priority> 
    77""" 
     
    2121class OWITree(OWClassificationTreeViewer): 
    2222    settingsList = OWClassificationTreeViewer.settingsList 
    23      
     23 
    2424    def __init__(self,parent = None, signalManager = None): 
    2525        OWClassificationTreeViewer.__init__(self, parent, signalManager, 'I&nteractive Tree Builder') 
    26         self.inputs = [("Examples", ExampleTable, self.cdata), ("Tree Learner", orange.Learner, self.learner)] 
    27         self.outputs = [("Classified Examples", ExampleTableWithClass), ("Classifier", orange.TreeClassifier), ("Tree Learner", orange.Learner)] 
     26        self.inputs = [("Examples", ExampleTable, self.setData), ("Tree Learner", orange.Learner, self.setLearner)] 
     27        self.outputs = [("Examples", ExampleTable), ("Classifier", orange.TreeClassifier), ("Tree Learner", orange.Learner)] 
    2828 
    2929        self.attridx = 0 
     
    6868        self.setTreeView() 
    6969        self.learner = FixedTreeLearner(self.tree, self.title) 
    70 #        self.send("Classified Examples", self.tree) 
     70#        self.send("Examples", self.tree) 
    7171        self.send("Classifier", self.tree) 
    7272        self.send("Tree Learner", self.learner) 
     
    9898        if not node: 
    9999            return 
    100          
     100 
    101101        attr = self.data.domain[self.attridx] 
    102102        if attr.varType == orange.VarTypes.Continuous: 
     
    141141        self.updateTree() 
    142142 
    143     def cdata(self, data): 
    144         if self.data and data and data.domain == self.data.domain and data.version == self.data.version: 
     143    def setData(self, data): 
     144        if self.data and data and data.domain.checksum() == self.data.domain.checksum(): 
    145145            return 
    146146 
    147147        self.attrsCombo.clear() 
    148148 
    149         if data and not data.domain.classVar: 
    150             self.error("This data set has no class.") 
    151             self.data = None 
    152         elif data and data.domain.classVar.varType != orange.VarTypes.Discrete: 
    153             self.error("This widget only works with discrete classes.") 
    154             self.data = None 
    155         else: 
    156             self.error() 
    157             self.data = data 
     149        self.data = self.isDataWithClass(data, orange.VarTypes.Discrete) and data or None 
     150 
    158151        if self.data: 
    159152            for attr in data.domain.attributes: 
     
    170163            self.send("Classifier", self.tree) 
    171164            self.send("Tree Learner", self.learner) 
    172          
    173         self.send("Classified Examples", None) 
     165 
     166        self.send("Examples", None) 
    174167        self.updateTree() 
    175168        self.v.setSelected(self.v.firstChild(), TRUE) 
    176169 
    177     def learner(self, learner): 
     170    def setLearner(self, learner): 
    178171        self.treeLearner = learner 
    179172 
     
    185178#    d = orange.ExampleTable('d:\\ai\\orange\\test\\iris') 
    186179    d = orange.ExampleTable('d:\\ai\\orange\\test\\crush') 
    187     owi.cdata(d) 
     180    owi.setData(d) 
    188181 
    189182    a.setMainWidget(owi) 
  • orange/OrangeWidgets/Classify/OWKNN.py

    r3419 r3482  
    33<description>K-nearest neighbours learner/classifier.</description> 
    44<icon>icons/kNearestNeighbours.png</icon> 
    5 <contact>Janez Demsar (janez.demsar(@at@)fri.uni-lj.si)</contact>  
     5<contact>Janez Demsar (janez.demsar(@at@)fri.uni-lj.si)</contact> 
    66<priority>25</priority> 
    77""" 
     
    1616    def __init__(self, parent=None, signalManager = None, name='kNN'): 
    1717        OWWidget.__init__(self, parent, signalManager, name) 
    18          
     18 
    1919        self.callbackDeposit = [] 
    2020 
    21         self.inputs = [("Classified Examples", ExampleTableWithClass, self.cdata)] 
     21        self.inputs = [("Examples", ExampleTable, self.setData)] 
    2222        self.outputs = [("Learner", orange.Learner),("KNN Classifier", orange.kNNClassifier)] 
    2323 
     
    2828#                       ("Dynamic time warp", orange.ExamplesDistanceConstructor_DTW) 
    2929                            ] 
    30          
     30 
    3131        # Settings 
    3232        self.name = 'kNN' 
     
    3434        self.ignoreUnknowns = 0; self.normalize = 1 
    3535        self.loadSettings() 
    36          
     36 
    3737        self.data = None                    # input data set 
    3838        self.preprocessor = None            # no preprocessing as default 
    3939        self.setLearner()                   # this just sets the learner, no data 
    4040                                            # has come to the input yet 
    41          
     41 
    4242        OWGUI.lineEdit(self.controlArea, self, 'name', box='Learner/Classifier Name', \ 
    4343                 tooltip='Name to be used by other widgets to identify your learner/classifier.') 
     
    6363 
    6464 
    65     def cdata(self,data): 
    66         if data and not data.domain.classVar: 
    67             self.error("This data set has no class") 
    68             self.data = None 
    69         else: 
    70             self.error() 
    71             self.data = data 
     65    def setData(self,data): 
     66        self.data = self.isDataWithClass(data, orange.VarTypes.Discrete) and data or None 
    7267        self.setLearner() 
    7368 
     
    106101 
    107102##    dataset = orange.ExampleTable('adult_sample') 
    108 ##    ow.cdata(dataset) 
     103##    ow.setData(dataset) 
    109104 
    110105    ow.show() 
  • orange/OrangeWidgets/Classify/OWLogisticRegression.py

    r3377 r3482  
    33<description>Logistic regression learner/classifier.</description> 
    44<icon>icons/LogisticRegression.png</icon> 
    5 <contact>Martin Mozina (martin.mozina(@at@)fri.uni-lj.si)</contact>  
     5<contact>Martin Mozina (martin.mozina(@at@)fri.uni-lj.si)</contact> 
    66<priority>15</priority> 
    77""" 
     
    1414    settingsList = ["removeSingular", "univariate", "name", "stepwiseLR", "addCrit", "removeCrit", "numAttr", "zeroPoint", "imputation", "limitNumAttr"] 
    1515 
    16     def __init__ (self, parent=None, signalManager = None, name = "Logistic regression"):     
     16    def __init__ (self, parent=None, signalManager = None, name = "Logistic regression"): 
    1717        OWWidget.__init__(self, parent, signalManager, name) 
    1818 
    19         self.inputs = [("Examples", ExampleTable, self.cdata)] 
     19        self.inputs = [("Examples", ExampleTable, self.setData)] 
    2020        self.outputs = [("Learner", orange.Learner),("Classifier", orange.Classifier),("Attributes", list)] 
    2121 
     
    4646        OWGUI.separator(self.controlArea) 
    4747 
    48         box = OWGUI.widgetBox(self.controlArea, "Attribute selection", addSpace=True)         
     48        box = OWGUI.widgetBox(self.controlArea, "Attribute selection", addSpace=True) 
    4949 
    5050        OWGUI.checkBox(box, self, "removeSingular", "Remove singular attributes", tooltip="Remove constant attributes and attributes causing singularities") 
     
    7474        if self.univariate: 
    7575            self.learner = Univariate_LogRegLearner() 
    76         else:             
     76        else: 
    7777            self.learner = LogRegLearner(removeSingular = self.removeSingular, imputer = imputer, removeMissing = removeMissing, 
    7878                                         stepwiseLR = self.stepwiseLR, addCrit = self.addCrit/100., removeCrit = self.removeCrit/100., 
     
    8080 
    8181        self.learner.name = self.name 
    82         self.send("Learner", self.learner)         
     82        self.send("Learner", self.learner) 
    8383        self.applyData() 
    84          
     84 
    8585    def applyData(self): 
    8686        classifier = None 
    87          
     87 
    8888        if self.data: 
    8989            if self.zeroPoint: 
     
    105105        self.send("Classifier", classifier) 
    106106 
    107          
    108     def cdata(self, data): 
     107 
     108    def setData(self, data): 
    109109        self.data = data 
    110110        self.applyData() 
    111111 
    112          
     112 
    113113if __name__=="__main__": 
    114114    a=QApplication(sys.argv) 
     
    117117 
    118118    dataset = orange.ExampleTable(r'..\..\doc\datasets\heart_disease') 
    119     ow.cdata(dataset) 
     119    ow.setData(dataset) 
    120120 
    121121    ow.show() 
    122122    a.exec_loop() 
    123     ow.saveSettings()  
     123    ow.saveSettings() 
  • orange/OrangeWidgets/Classify/OWMajority.py

    r3419 r3482  
    33<description>Majority class learner/classifier.</description> 
    44<icon>icons/Majority.png</icon> 
    5 <contact>Janez Demsar (janez.demsar(@at@)fri.uni-lj.si)</contact>  
     5<contact>Janez Demsar (janez.demsar(@at@)fri.uni-lj.si)</contact> 
    66<priority>20</priority> 
    77""" 
     
    1616    def __init__(self, parent=None, signalManager = None): 
    1717        OWWidget.__init__(self, parent, signalManager, 'Majority') 
    18          
     18 
    1919        self.callbackDeposit = [] 
    2020 
    21         self.inputs = [("Classified Examples", ExampleTableWithClass, self.cdata)] 
     21        self.inputs = [("Examples", ExampleTable, self.setData)] 
    2222        self.outputs = [("Learner", orange.Learner),("Classifier", orange.Classifier)] 
    2323 
     
    2828 
    2929        OWGUI.separator(self.controlArea) 
    30          
     30 
    3131        OWGUI.button(self.controlArea, self, "&Apply Setting", callback = self.setLearner, disabled=0) 
    3232 
     
    3939        self.send("Learner", self.learner) 
    4040 
    41     def cdata(self,data): 
    42         self.error(0) 
    43         self.error(1) 
    44         if data and not data.domain.classVar: 
    45             self.error(0, "This data set has no class") 
    46             data = None 
     41    def setData(self,data): 
     42        self.data = self.isDataWithClass(data, orange.VarTypes.Discrete) and data or None 
    4743 
    48         self.data = data 
    49         if data: 
     44        if self.data: 
    5045            try: 
    51                 self.classifier = self.learner(data) 
     46                self.classifier = self.learner(self.data) 
    5247                self.classifier.name = self.name 
     48                self.error(1) 
    5349            except Exception, (errValue): 
    5450                self.classifier = None 
     
    5753            self.classifier = None 
    5854        self.send("Classifier", self.classifier) 
    59              
    60   
     55 
     56 
    6157############################################################################## 
    6258# Test the widget, run from DOS prompt 
     
    7066 
    7167##    dataset = orange.ExampleTable('adult_sample') 
    72 ##    ow.cdata(dataset) 
     68##    ow.setData(dataset) 
    7369 
    7470    ow.show() 
  • orange/OrangeWidgets/Classify/OWNaiveBayes.py

    r3419 r3482  
    33<description>Naive Bayesian learner/classifier.</description> 
    44<icon>icons/NaiveBayes.png</icon> 
    5 <contact>Janez Demsar (janez.demsar(@at@)fri.uni-lj.si)</contact>  
     5<contact>Janez Demsar (janez.demsar(@at@)fri.uni-lj.si)</contact> 
    66<priority>10</priority> 
    77""" 
     
    1313class OWNaiveBayes(OWWidget): 
    1414    settingsList = ["m_estimator.m", "name", "probEstimation", "condProbEstimation", "adjustThreshold", "windowProportion"] 
    15      
     15 
    1616    def __init__(self, parent=None, signalManager = None, name='NaiveBayes'): 
    1717        OWWidget.__init__(self, parent, signalManager, name) 
    1818 
    19         self.inputs = [("Classified Examples", ExampleTableWithClass, self.cdata)] 
     19        self.inputs = [("Examples", ExampleTable, self.setData)] 
    2020        self.outputs = [("Learner", orange.Learner),("Naive Bayesian Classifier", orange.BayesClassifier)] 
    21              
     21 
    2222        self.m_estimator = orange.ProbabilityEstimatorConstructor_m() 
    2323        self.estMethods=[("Relative Frequency", orange.ProbabilityEstimatorConstructor_relative()), 
     
    3737        self.windowProportion = 0.5 
    3838        self.loessPoints = 100 
    39          
     39 
    4040        self.data = None 
    4141        self.loadSettings() 
    4242 
    43          
     43 
    4444        OWGUI.lineEdit(self.controlArea, self, 'name', box='Learner/Classifier Name', \ 
    4545                 tooltip='Name to be used by other widgets to identify your learner/classifier.') 
     
    5050 
    5151        glay.addWidget(OWGUI.separator(box, height=5), 0, 0) 
    52          
     52 
    5353        glay.addWidget(OWGUI.widgetLabel(box, "Unconditional"), 1, 0) 
    54         
     54 
    5555        glay.addWidget(OWGUI.comboBox(box, self, 'probEstimation', items=[e[0] for e in self.estMethods], tooltip='Method to estimate unconditional probability.'), 
    5656                        1, 2) 
    57          
     57 
    5858        glay.addWidget(OWGUI.widgetLabel(box, "Conditional (for discrete)"), 2, 0) 
    5959        glay.addWidget(OWGUI.comboBox(box, self, 'condProbEstimation', items=[e[0] for e in self.condEstMethods], tooltip='Conditional probability estimation method used for discrete attributes.', callback=self.refreshControls), 
     
    7878        glay.addWidget(OWGUI.widgetLabel(box, 'LOESS sample points'), 6, 0) 
    7979        pointsValid = QIntValidator(20, 1000, self.controlArea) 
    80         glay.addWidget(OWGUI.lineEdit(box, self, 'loessPoints',  
     80        glay.addWidget(OWGUI.lineEdit(box, self, 'loessPoints', 
    8181                       tooltip='Number of points in computation of LOESS (20-1000).', 
    8282                       valueType = int, validator = pointsValid), 
    8383                       6, 2) 
    84          
     84 
    8585        OWGUI.separator(self.controlArea) 
    8686 
    8787        OWGUI.checkBox(self.controlArea, self, "adjustThreshold", "Adjust threshold (for binary classes)", box = "Threshold") 
    88          
     88 
    8989        OWGUI.separator(self.controlArea) 
    9090        box = OWGUI.widgetBox(self.controlArea, "Apply", orientation=1) 
     
    108108            self.warning(0, "Parameter m should be positive") 
    109109            self.learner = None 
    110          
     110 
    111111        elif float(self.windowProportion) < 0 or float(self.windowProportion) > 1: 
    112112            self.warning(0, "Window proportion for LOESS should be between 0.0 and 1.0") 
     
    125125        self.changed = False 
    126126 
    127          
     127 
    128128    def applyData(self): 
    129129        if self.data and self.learner: 
    130             self.error(1) 
    131130            try: 
    132131                classifier = self.learner(self.data) 
    133132                classifier.setattr("data", self.data) 
    134133                classifier.name = self.name 
     134                self.error(1) 
    135135            except Exception, (errValue): 
    136136                classifier = None 
     
    142142 
    143143 
    144     def cdata(self,data): 
    145         if data and data.domain.classVar.varType != orange.VarTypes.Discrete: 
    146             self.error(0, "This widget only works with discrete classes.") 
    147             self.data = None 
    148         else: 
    149             self.data = data 
    150             self.error(0) 
     144    def setData(self,data): 
     145        self.data = self.isDataWithClass(data, orange.VarTypes.Discrete) and data or None 
     146        self.applyData() 
    151147 
    152         self.applyData() 
    153          
    154148 
    155149    def sendReport(self): 
     
    164158                            ]) 
    165159        self.finishReport() 
    166              
    167              
     160 
     161 
    168162if __name__=="__main__": 
    169163    a=QApplication(sys.argv) 
  • orange/OrangeWidgets/Classify/OWSVM.py

    r3385 r3482  
    33<description>Support Vector Machines learner/classifier.</description> 
    44<icon>icons/BasicSVM.png</icon> 
    5 <contact>Ales Erjavec (ales.erjavec(@at@)fri.uni-lj.si)</contact>  
     5<contact>Ales Erjavec (ales.erjavec(@at@)fri.uni-lj.si)</contact> 
    66<priority>100</priority> 
    77""" 
     
    1616    def __init__(self, parent=None, signalManager=None, name="SVM"): 
    1717        OWWidget.__init__(self, parent, signalManager, name) 
    18         self.inputs=[("Example Table", ExampleTable, self.cdata)] 
     18        self.inputs=[("Example Table", ExampleTable, self.setData)] 
    1919        self.outputs=[("Learner", orange.Learner),("Classifier", orange.Classifier),("Support Vectors", ExampleTable)] 
    2020 
     
    3434        self.selFlag=False 
    3535        self.name="SVM Learner/Classifier" 
    36          
     36 
    3737        OWGUI.lineEdit(self.controlArea, self, 'name', box='Learner/Classifier Name', tooltip='Name to be used by other widgets to identify your learner/classifier.') 
    3838        OWGUI.separator(self.controlArea) 
     
    4848 
    4949        OWGUI.separator(self.controlArea) 
    50          
     50 
    5151        self.optionsBox=b=OWGUI.widgetBox(self.controlArea, "Options", addSpace = True) 
    5252        OWGUI.doubleSpin(b,self, "C", 0.0, 100.0, 0.5, label="Model complexity (C)", labelWidth = 120, orientation="horizontal") 
     
    5454        OWGUI.doubleSpin(b,self, "eps", 0.0, 0.5, 0.001, label="Numeric precision (eps)", labelWidth = 120, orientation="horizontal") 
    5555 
    56         OWGUI.checkBox(b,self, "probability", label="Support probabilities")         
     56        OWGUI.checkBox(b,self, "probability", label="Support probabilities") 
    5757        OWGUI.checkBox(b,self, "shrinking", label="Shrinking") 
    5858        OWGUI.checkBox(b,self, "useNu", label="Limit the number of support vectors", callback=lambda:self.nuBox.setDisabled(not self.useNu)) 
     
    6161 
    6262        OWGUI.separator(self.controlArea) 
    63                  
     63 
    6464        self.paramButton=OWGUI.button(self.controlArea, self, "Automatic parameter search", callback=self.parameterSearch, 
    65                                       tooltip="Automaticaly searches for parameters that optimize classifier acuracy")  
     65                                      tooltip="Automaticaly searches for parameters that optimize classifier acuracy") 
    6666 
    6767        OWGUI.separator(self.controlArea) 
     
    7676        self.terminateThread=False 
    7777        self.applySettings() 
    78          
     78 
    7979    def changeKernel(self): 
    8080        if self.kernel_type==0: 
     
    9191                a.setDisabled(b) 
    9292 
    93     def cdata(self, data=None): 
     93    def setData(self, data=None): 
    9494        if data: 
    9595            self.data=data 
     
    107107 
    108108        self.learner.svm_type=0 
    109          
     109 
    110110        if self.useNu: 
    111111            self.learner.svm_type=1 
     
    157157            self.thread.start() 
    158158            self.paramButton.setText("Stop") 
    159              
     159 
    160160    def progres(self, f, best): 
    161161        self.best=best 
     
    168168            sys.exit() 
    169169            raise "thread exit" 
    170              
     170 
    171171    def finishSearch(self): 
    172172        del self.best["error"] 
     
    177177        self.optionsBox.setDisabled(0) 
    178178        self.paramButton.setText("Automatic parameter search") 
    179          
    180          
     179 
     180 
    181181class MyThread(Thread): 
    182182    def __init__(self, widget): 
     
    207207    w.show() 
    208208    d=orange.ExampleTable("../../doc/datasets/tic_tac_toe.tab") 
    209     w.cdata(d) 
     209    w.setData(d) 
    210210    app.exec_loop() 
    211211    w.saveSettings() 
  • orange/OrangeWidgets/Evaluate/OWConfusionMatrix.py

    r3069 r3482  
    2323        QTableItem.__init__(self, *args) 
    2424        self.isBold = isBold 
    25          
     25 
    2626    def alignment(self): 
    2727        return QWidget.AlignCenter 
     
    3535        sze.setWidth(sze.width()*1.15) 
    3636        return sze 
    37      
     37 
    3838class OWConfusionMatrix(OWWidget): 
    3939    settings = ["shownQuantity", "autoApply"] 
    40      
     40 
    4141    def __init__(self,parent=None, signalManager = None): 
    4242        OWWidget.__init__(self, parent, signalManager, "Confusion Matrix", 1) 
    4343 
    4444        # inputs 
    45         self.inputs=[("Evaluation Results", orngTest.ExperimentResults, self.test_results, Default)] 
    46         self.outputs=[("Selected Examples", ExampleTableWithClass, 8)] 
     45        self.inputs=[("Evaluation Results", orngTest.ExperimentResults, self.setTestResults, Default)] 
     46        self.outputs=[("Selected Examples", ExampleTable, 8)] 
    4747 
    4848        self.selectedLearner = [0] 
     
    7474        self.layout.addWidget(labpred, 0, 1, QWidget.AlignCenter) 
    7575        self.layout.addWidget(OWGUI.separator(self.mainArea),1, 0) 
    76          
     76 
    7777        labpred = OWGUI.widgetLabel(self.mainArea, "Correct Class  ") 
    7878        self.layout.addWidget(labpred, 2, 0, QWidget.AlignCenter) 
     
    8787        self.layout.addWidget(self.table, 2, 1) 
    8888        self.table.setSizePolicy(QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)) 
    89          
     89 
    9090        self.connect(self.table, SIGNAL("selectionChanged()"), self.sendIf) 
    91          
     91 
    9292        self.resize(750,450) 
    9393 
     
    9696            self.table.adjustSize() 
    9797        OWWidget.resizeEvent(self, *args) 
    98          
    99     def test_results(self, res): 
     98 
     99    def setTestResults(self, res): 
    100100        self.res = res 
    101101        if not res: 
     
    103103            self.table.setNumCols(0) 
    104104            return 
    105          
     105 
    106106        self.matrix = orngStat.confusionMatrices(res) 
    107107 
    108108        dim = len(res.classValues) 
    109          
     109 
    110110        self.table.setNumRows(dim+2) 
    111111        self.table.setNumCols(dim+2) 
     
    118118            self.table.item(0, ri+1).setText(cv) 
    119119            self.table.item(ri+1, 0).setText(cv) 
    120              
     120 
    121121        self.learnerNames = res.classifierNames[:] 
    122122 
     
    136136        else: 
    137137            self.isInteger = " %i " 
    138              
     138 
    139139        self.reprint() 
    140         self.sendIf()         
    141              
     140        self.sendIf() 
     141 
    142142 
    143143    def reprint(self): 
     
    175175        self.table.setText(dim+1, dim+1, self.isInteger % total) 
    176176 
    177         for ci in range(len(cm)+2):             
     177        for ci in range(len(cm)+2): 
    178178            self.table.adjustColumn(ci) 
    179179 
    180180        self.table.adjustSize() 
    181181 
    182              
     182 
    183183 
    184184    def selectCorrect(self): 
    185185        if not self.res: 
    186186            return 
    187          
     187 
    188188        self.table.clearSelection() 
    189189        for i in range(1, 1+len(self.matrix[0])): 
     
    198198        if not self.res: 
    199199            return 
    200          
     200 
    201201        self.table.clearSelection() 
    202202        dim = len(self.matrix[0]) 
     
    230230    def sendData(self): 
    231231        self.selectionDirty = False 
    232          
     232 
    233233        res = self.res 
    234234        if not res or not self.table.numSelections(): 
    235235            self.send("Selected Examples", None) 
    236236            return 
    237          
     237 
    238238        from sets import Set 
    239239        selected = Set() 
     
    249249        self.send("Selected Examples", data) 
    250250 
    251          
     251 
    252252if __name__ == "__main__": 
    253253    a = QApplication(sys.argv) 
  • orange/OrangeWidgets/Evaluate/OWPredictions.py

    r3475 r3482  
    33<description>Displays predictions of models for a particular data set.</description> 
    44<icon>icons/Predictions.png</icon> 
    5 <contact>Blaz Zupan (blaz.zupan(@at@)fri.uni-lj.si)</contact>  
     5<contact>Blaz Zupan (blaz.zupan(@at@)fri.uni-lj.si)</contact> 
    66<priority>300</priority> 
    77""" 
     
    3232 
    3333        self.callbackDeposit = [] 
    34         self.inputs = [("Examples", ExampleTable, self.dataset), ("Classifiers", orange.Classifier, self.classifier, Multiple)] 
    35         self.outputs = [("Selected Examples", ExampleTableWithClass)] 
     34        self.inputs = [("Examples", ExampleTable, self.setData),("Classifiers", orange.Classifier, self.setClassifier, Multiple)] 
     35        self.outputs = [("Selected Examples", ExampleTable)] 
    3636        self.classifiers = {} 
    3737 
     
    4444        self.freezeAttChange = 0 # 1 to block table update followed by changes in attribute list box 
    4545        self.data=None 
    46          
     46 
    4747        # GUI - Options 
    4848        self.options = QVButtonGroup("Options", self.controlArea) 
     
    8080        self.outBox.setDisabled(1) 
    8181 
    82         # GUI - Table         
     82        # GUI - Table 
    8383        self.layout = QVBoxLayout(self.mainArea) 
    8484        self.table = QTable(self.mainArea) 
     
    9999        if not self.data or not self.classifiers: 
    100100            return 
    101          
     101 
    102102        attsel = [self.lbClasses.isSelected(i) for i in range(len(self.data.domain.attributes))] 
    103103        showatt = attsel.count(1) 
     
    133133                    self.table.setText(self.rindx[i], col+c, '') 
    134134            col += len(self.classifiers) 
    135      
     135 
    136136        for i in range(sindx, col): 
    137137            self.table.adjustColumn(i) 
     
    159159                self.table.hideColumn(i+1) 
    160160 
    161     # defines the table and paints its contents     
     161    # defines the table and paints its contents 
    162162    def setTable(self): 
    163163        if self.data==None: 
     
    194194                self.classifications[i] = [c] 
    195195            col += 1 
    196      
     196 
    197197        for i in range(col): 
    198198            self.table.adjustColumn(i) 
     
    203203        self.updateTrueClass() 
    204204        self.table.hideColumn(0) # hide column with indices, we will use vertical header to show this info 
    205                  
     205 
    206206    def sort(self, col): 
    207207        "sorts the table by column col" 
     
    214214        for (i, indx) in enumerate(self.rindx): 
    215215            self.vheader.setLabel(i, self.table.item(i,0).text()) 
    216          
     216 
    217217    ############################################################################## 
    218218    # Input signals 
    219219 
    220     def dataset(self,data): 
    221         self.data = data 
    222         if not data: 
     220    def setData(self,data): 
     221        self.data = self.isDataWithClass(data) and data or None 
     222        if not self.data: 
    223223            self.table.hide() 
    224224            self.send("Selected Examples", None) 
     
    241241            if not self.classifiers: 
    242242                self.ShowTrueClass = 1 
    243              
     243 
    244244            self.rindx = range(len(self.data)) 
    245245            self.setTable() 
     
    247247            self.checkenable() 
    248248 
    249     def classifier(self, c, id): 
     249    def setClassifier(self, c, id): 
    250250        if not c: 
    251251            if self.classifiers.has_key(id): 
     
    271271        self.trueClassCheckBox.setEnabled(self.data<>None and self.data.domain.classVar<>None) 
    272272##        self.options.setEnabled(len(self.classifiers)>0) 
    273         self.att.setEnabled(self.data<>None)             
    274         self.options.setEnabled(self.data<>None)             
    275          
     273        self.att.setEnabled(self.data<>None) 
     274        self.options.setEnabled(self.data<>None) 
     275 
    276276 
    277277    ############################################################################## 
     
    284284    # assumes that the data and display conditions 
    285285    # (enough classes are displayed) have been checked 
    286      
     286 
    287287    def senddata(self): 
    288288        def cmpclasses(clist): 
     
    318318    if 0: # data set only 
    319319        data = orange.ExampleTable('sailing') 
    320         ow.dataset(data) 
    321     elif 0:  
     320        ow.setData(data) 
     321    elif 0: 
    322322        data = orange.ExampleTable('outcome') 
    323323        test = orange.ExampleTable('cheat', uses=data.domain) 
     
    328328        import orngTree 
    329329        tree = orngTree.TreeLearner(data, name="Tree") 
    330         ow.classifier(bayes, 1) 
    331         ow.classifier(tree, 2) 
    332         ow.dataset(test) 
     330        ow.setClassifier(bayes, 1) 
     331        ow.setClassifier(tree, 2) 
     332        ow.setData(test) 
    333333    elif 1: # two classifiers 
    334334        data = orange.ExampleTable('sailing.txt') 
    335335        bayes = orange.BayesLearner(data) 
    336336        bayes.name = "NBC" 
    337         ow.classifier(bayes, 1) 
     337        ow.setClassifier(bayes, 1) 
    338338        maj = orange.MajorityLearner(data) 
    339339        maj.name = "Majority" 
     
    342342        knn = orange.kNNLearner(data, k = 10) 
    343343        knn.name = "knn" 
    344         ow.classifier(maj, 2) 
    345         ow.classifier(knn, 3) 
    346         ow.dataset(data) 
     344        ow.setClassifier(maj, 2) 
     345        ow.setClassifier(knn, 3) 
     346        ow.setData(data) 
    347347    else: # regression 
    348348        data = orange.ExampleTable('auto-mpg') 
     
    351351        maj = orange.MajorityLearner(data) 
    352352        maj.name = "Majority" 
    353         ow.classifier(knn, 1) 
    354         ow.classifier(maj, 2) 
    355         ow.dataset(data) 
    356          
     353        ow.setClassifier(knn, 1) 
     354        ow.setClassifier(maj, 2) 
     355        ow.setData(data) 
     356 
    357357    a.exec_loop() 
    358358    ow.saveSettings() 
  • orange/OrangeWidgets/Evaluate/OWTestLearners.py

    r3466 r3482  
    33<description>Estimates the predictive performance of learners on a data set.</description> 
    44<icon>icons/TestLearners.png</icon> 
    5 <contact>Blaz Zupan (blaz.zupan(@at@)fri.uni-lj.si)</contact>  
     5<contact>Blaz Zupan (blaz.zupan(@at@)fri.uni-lj.si)</contact> 
    66<priority>200</priority> 
    77""" 
     
    2929             ('Brier score', 'Brier', 'BrierScore(res)') 
    3030           ) 
    31      
     31 
    3232    def __init__(self,parent=None, signalManager = None): 
    3333        OWWidget.__init__(self, parent, signalManager, "TestLearners") 
    34          
    35         self.inputs = [("Data", ExampleTableWithClass, self.cdata, Default), ("Separate Test Data", ExampleTableWithClass, self.testdata), ("Learner", orange.Learner, self.learner, Multiple)] 
     34 
     35        self.inputs = [("Data", ExampleTable, self.setData, Default), ("Separate Test Data", ExampleTable, self.setTestData), ("Learner", orange.Learner, self.setLearner, Multiple)] 
    3636        self.outputs = [("Evaluation Results", orngTest.ExperimentResults)] 
    3737 
     
    4444        self.precision = 4 
    4545        self.loadSettings() 
    46          
     46 
    4747        self.data = None                # input data set 
    4848        self.testdata = None            # separate test data set 
     
    5353        # GUI 
    5454        self.s = [None] * 5 
    55         self.sBox = QVButtonGroup("Sampling", self.controlArea)         
     55        self.sBox = QVButtonGroup("Sampling", self.controlArea) 
    5656        self.s[0] = QRadioButton('Cross validation', self.sBox) 
    5757 
     
    7272        box = QHBox(self.sBox) 
    7373        QWidget(box).setFixedSize(19, 8) 
    74         OWGUI.hSlider(box, self, 'pLearning', minValue=10, maxValue=100, step=1, ticks=10, labelFormat="   %d%%")         
    75  
    76         self.s[3] = QRadioButton('Test on train data', self.sBox)         
     74        OWGUI.hSlider(box, self, 'pLearning', minValue=10, maxValue=100, step=1, ticks=10, labelFormat="   %d%%") 
     75 
     76        self.s[3] = QRadioButton('Test on train data', self.sBox) 
    7777        self.s[4] = self.testDataBtn = QRadioButton('Test on test data', self.sBox) 
    7878 
     
    8383        if self.sampleMethod == 4: 
    8484            self.sampleMethod = 0 
    85         self.s[self.sampleMethod].setChecked(TRUE)         
     85        self.s[self.sampleMethod].setChecked(TRUE) 
    8686        OWGUI.separator(self.controlArea) 
    87          
     87 
    8888        # statistics 
    8989        self.statBox = QVGroupBox(self.controlArea) 
     
    104104 
    105105        self.lab = QLabel(self.g) 
    106              
     106 
    107107        # signals 
    108108        self.connect(self.applyBtn, SIGNAL("clicked()"), self.test) 
     
    147147        elif self.sampleMethod==3: 
    148148            res = orngTest.learnAndTestOnLearnData(learners, self.data) 
    149         elif self.sampleMethod==4:                 
     149        elif self.sampleMethod==4: 
    150150            res = orngTest.learnAndTestOnTestData(learners, self.data, self.testdata) 
    151151 
     
    186186#                        sys.excepthook(type, val, traceback)  # print the exception 
    187187                        self.error("Caught an exception while evaluating classifier %s" % learner.name) 
    188                      
     188 
    189189        else: # test on all learners, or on the new learner with no other learners in the memory 
    190190            self.results = res 
     
    208208 
    209209    # slots: handle input signals 
    210     def cdata(self, data): 
    211         if not data: 
    212             self.data = None 
     210    def setData(self, data): 
     211        self.data = self.isDataWithClass(data) and data or None 
     212        if not self.data: 
    213213            self.results = None 
    214214            self.setStatTable() 
    215             return 
    216  
    217         self.data = orange.Filter_hasClassValue(data) 
    218         self.classindex = 0 # data.targetValIndx 
    219         if self.learners: 
    220             self.applyBtn.setDisabled(FALSE) 
    221             self.results = None; self.scores = None 
    222             self.test() 
    223  
    224     def testdata(self, data): 
     215        else: 
     216            self.data = orange.Filter_hasClassValue(self.data) 
     217            self.classindex = 0 # data.targetValIndx 
     218            if self.learners: 
     219                self.applyBtn.setDisabled(FALSE) 
     220                self.results = None 
     221                self.scores = None 
     222                self.test() 
     223 
     224    def setTestData(self, data): 
    225225        self.testdata = data 
    226226        if self.sampleMethod == 4: 
    227227            self.test() 
    228228 
    229     def learner(self, learner, id=None): 
     229    def setLearner(self, learner, id=None): 
    230230        if learner: # a new or updated learner 
    231231            learner.id = id # remember id's of learners 
     
    258258 
    259259            del self.learners[indx] 
    260              
     260 
    261261    # signal processing 
    262262    def statChanged(self, value, id): 
     
    344344 
    345345    if testcase == 0: # 1(UPD), 3, 4 
    346         ow.cdata(data) 
     346        ow.setData(data) 
    347347        ow.learner(l1, 1) 
    348348        ow.learner(l2, 2) 
     
    357357        ow.learner(None, 2) 
    358358        ow.learner(None, 1) 
    359         ow.cdata(data) 
     359        ow.setData(data) 
    360360    if testcase == 2: # sends data, then learner, then removes the learner 
    361         ow.cdata(data) 
     361        ow.setData(data) 
    362362        ow.learner(l1, 1) 
    363363        ow.learner(None, 1) 
    364364    if testcase == 3: # sends data, then learner, then changes the name of the learner, then new data 
    365365        pass 
    366          
     366 
    367367    ow.show() 
    368368    a.exec_loop() 
  • orange/OrangeWidgets/Prototypes/OWScatterPlotXp.py

    r3428 r3482  
    99# 
    1010# Show data using scatterplot 
    11 #  
     11# 
    1212 
    1313from OWWidget import * 
     
    2020from OWGraph import OWGraph 
    2121 
    22         
     22 
    2323########################################################################################### 
    2424##### WIDGET : Scatterplot visualization 
     
    3333 
    3434    contextHandlers = {"": DomainContextHandler("", ["attrX", "attrY", (["attrLabel", "attrShape", "attrSize", "attrBrighten"], DomainContextHandler.Optional)])} 
    35      
     35 
    3636    def __init__(self, parent=None, signalManager = None): 
    3737        OWWidget.__init__(self, parent, signalManager, "ScatterPlot", TRUE) 
    3838 
    3939        self.inputs =  [("Examples", ExampleTable, self.cdata, Default), ("Example Subset", ExampleTable, self.subsetdata), ("Attribute selection", list, self.attributeSelection), ("Evaluation Results", orngTest.ExperimentResults, self.test_results), ("VizRank Learner", orange.Learner, self.vizRankLearner)] 
    40         self.outputs = [("Selected Examples", ExampleTableWithClass), ("Unselected Examples", ExampleTableWithClass), ("Learner", orange.Learner)] 
    41  
    42         # local variables     
     40        self.outputs = [("Selected Examples", ExampleTable), ("Unselected Examples", ExampleTable), ("Learner", orange.Learner)] 
     41 
     42        # local variables 
    4343        self.showGridlines = 0 
    4444        self.autoSendSelection = 1 
     
    5959        self.clusterDlg = ClusterOptimization(self, self.signalManager, self.graph, "ScatterPlot") 
    6060        self.optimizationDlg = self.vizrank 
    61         
     61 
    6262        self.data = None 
    6363 
     
    9595        self.attrBrighten = "" 
    9696        self.attrBrightenCombo = OWGUI.comboBox(OWGUI.indentedBox(box), self, "attrBrighten", label="Brighten by", orientation = 1, callback = self.updateGraph, sendSelectedValue=1, valueType = str, emptyString = "(No brightening)") 
    97          
     97 
    9898        # labelling 
    9999        self.attrLabel = "" 
     
    103103        self.attrShape = "" 
    104104        self.attrShapeCombo = OWGUI.comboBox(self.GeneralTab, self, "attrShape", " Shape Attribute ", callback = self.updateGraph, sendSelectedValue=1, valueType = str, emptyString = "(One shape)") 
    105                  
     105 
    106106        # sizing 
    107107        self.attrSize = "" 
    108108        self.attrSizeCombo = OWGUI.comboBox(self.GeneralTab, self, "attrSize", " Size Attribute ", callback = self.updateGraph, sendSelectedValue=1, valueType = str, emptyString = "(One size)") 
    109          
     109 
    110110        # cluster dialog 
    111111        self.clusterDlg.label1.hide() 
     
    114114        self.clusterDlg.attributeLabel.hide() 
    115115        self.graph.clusterOptimization = self.clusterDlg 
    116          
    117          
     116 
     117 
    118118        self.optimizationButtons = OWGUI.widgetBox(self.GeneralTab, " Optimization Dialogs ", orientation = "horizontal") 
    119119        OWGUI.button(self.optimizationButtons, self, "VizRank", callback = self.vizrank.reshow, tooltip = "Opens VizRank dialog, where you can search for interesting projections with different subsets of attributes.", debuggingEnabled = 0) 
     
    139139        self.jitterSizeCombo = OWGUI.comboBox(box3, self, "graph.jitterSize", callback = self.resetGraphData, items = self.jitterSizeNums, sendSelectedValue = 1, valueType = float) 
    140140        OWGUI.checkBox(box2, self, 'graph.jitterContinuous', 'Jitter continuous attributes', callback = self.resetGraphData, tooltip = "Does jittering apply also on continuous attributes?") 
    141          
     141 
    142142        # general graph settings 
    143143        box4 = OWGUI.collapsableWidgetBox(self.SettingsTab, " General Graph Settings ", self, "boxGeneral") 
     
    170170        self.colorButtonsBox = OWGUI.widgetBox(self.SettingsTab, " Colors ", orientation = "horizontal") 
    171171        OWGUI.button(self.colorButtonsBox, self, "Set Colors", self.setColors, tooltip = "Set the canvas background color, grid color and color palette for coloring continuous variables", debuggingEnabled = 0) 
    172          
     172 
    173173        box5 = OWGUI.widgetBox(self.SettingsTab, " Tooltips Settings ") 
    174174        OWGUI.comboBox(box5, self, "graph.tooltipKind", items = ["Don't show tooltips", "Show visible attributes", "Show all attributes"], callback = self.updateGraph) 
     
    176176        self.activeLearnerCombo = OWGUI.comboBox(self.SettingsTab, self, "learnerIndex", box = " Set Active Learner ", items = ["VizRank Learner", "Cluster Learner"], tooltip = "Select which of the possible learners do you want to send on the widget output.") 
    177177        self.connect(self.activeLearnerCombo, SIGNAL("activated(int)"), self.setActiveLearner) 
    178      
     178 
    179179        OWGUI.checkBox(self.SettingsTab, self, 'autoSendSelection', 'Auto send selected data', box = " Data selection ", callback = self.setAutoSendSelection, tooltip = "Send signals with selected data whenever the selection changes.") 
    180180        self.graph.autoSendSelectionCallback = self.setAutoSendSelection 
    181181 
    182         OWGUI.rubber(self.SettingsTab)         
     182        OWGUI.rubber(self.SettingsTab) 
    183183        self.SettingsTab.setMinimumWidth(max(self.GeneralTab.sizeHint().width(), self.SettingsTab.sizeHint().width())+20) 
    184184        self.icons = self.createAttributeIconDict() 
    185          
    186          
     185 
     186 
    187187        box = OWGUI.widgetBox(self.XPeroTab, "Triangulation") 
    188188        OWGUI.checkBox(box, self, "graph.showTriangulation", "Show triangulation", callback = self.updateGraph) 
    189          
     189 
    190190        box = OWGUI.widgetBox(self.XPeroTab, "Critical areas") 
    191191        OWGUI.checkBox(box, self, "graph.showBoundaries", "Show boundary regions", callback = self.updateGraph) 
     
    193193        OWGUI.checkBox(box, self, "graph.showUnexplored", "Show undersampled regions", callback = self.updateGraph) 
    194194        OWGUI.checkBox(box, self, "graph.showUnevenlySampled", "Show unevenly sampled regions", callback = self.updateGraph) 
    195          
     195 
    196196        cabox = OWGUI.indentedBox(box) 
    197197        self.debugSettings = ["attrX", "attrY", "attrColor", "attrLabel", "attrShape", "attrSize"] 
     
    199199        self.resize(700, 550) 
    200200 
    201      
     201 
    202202    def activateLoadedSettings(self): 
    203203        dlg = self.createColorDialog() 
     
    206206        self.graph.setCanvasBackground(dlg.getColor("Canvas")) 
    207207        self.graph.setGridPen(QPen(dlg.getColor("Grid"))) 
    208                  
     208 
    209209        self.graph.enableGridXB(self.showGridlines) 
    210210        self.graph.enableGridYL(self.showGridlines) 
     
    257257        self.classificationResults = None 
    258258        self.outlierValues = None 
    259          
     259 
    260260        self.vizrank.setData(data) 
    261261        self.clusterDlg.setData(data, clearResults) 
    262          
     262 
    263263        if not (self.data and exData and str(exData.domain.variables) == str(self.data.domain.variables)): # preserve attribute choice if the domain is the same 
    264264            self.initAttrValues() 
     
    277277        self.vizrank.setSubsetData(data) 
    278278        self.clusterDlg.setSubsetData(data) 
    279         
     279 
    280280 
    281281    # receive information about which attributes we want to show on x and y axis 
     
    288288 
    289289    # visualize the results of the classification 
    290     def test_results(self, results):         
     290    def test_results(self, results): 
    291291        self.classificationResults = None 
    292292        if isinstance(results, orngTest.ExperimentResults) and len(results.results) > 0 and len(results.results[0].probabilities) > 0: 
     
    314314    def setActiveLearner(self, idx): 
    315315        self.send("Learner", self.learnersArray[self.learnerIndex]) 
    316     
    317      
     316 
     317 
    318318    # ################################################################################################ 
    319319    # find projections that have tight clusters of points that belong to the same class value 
    320320    def optimizeClusters(self): 
    321321        if self.data == None: return 
    322          
     322 
    323323        self.clusterDlg.clearResults() 
    324324        self.clusterDlg.clusterStabilityButton.setOn(0) 
     
    346346 
    347347        self.majorUpdateGraph(attrs) 
    348          
     348 
    349349 
    350350    def showSelectedCluster(self): 
     
    360360        self.majorUpdateGraph(attrList, insideColors, (closure, enlargedClosure, classValue)) 
    361361 
    362         
     362 
    363363    # ############################################################################################################################################################## 
    364364    # ATTRIBUTE SELECTION 
     
    405405        if self.attrYCombo.count() > 1: self.attrY = str(self.attrYCombo.text(1)) 
    406406        else:                           self.attrY = str(self.attrYCombo.text(0)) 
    407              
     407 
    408408        if self.data.domain.classVar: 
    409409            self.attrColor = self.data.domain.classVar.name 
     
    423423        if not self.data: 
    424424            return 
    425      
     425 
    426426        if attrList: 
    427427            self.attrX = attrList[0] 
     
    434434        else: 
    435435            kNNExampleAccuracy = None 
    436              
     436 
    437437        self.graph.insideColors = insideColors or self.classificationResults or kNNExampleAccuracy or self.outlierValues 
    438438        self.graph.clusterClosure = clusterClosure 
     
    441441        self.graph.repaint() 
    442442 
    443      
     443 
    444444    # ############################################################################################################################################################## 
    445445    # SCATTERPLOT SETTINGS 
     
    510510    ow.show() 
    511511 
    512     #save settings  
     512    #save settings 
    513513    ow.saveSettings() 
  • orange/OrangeWidgets/Regression/OWPade.py

    r3400 r3482  
    1616    contextHandlers = {"": PerfectDomainContextHandler("", ["outputAttr", ContextField("attributes", selected="dimensions")])} 
    1717 
    18     methodNames = ["First Triangle", "Star Regression", "Star Univariate Regression", "Tube Regression", "1D Qing"]     
     18    methodNames = ["First Triangle", "Star Regression", "Star Univariate Regression", "Tube Regression", "1D Qing"] 
    1919    methods = [orngPade.firstTriangle, orngPade.starRegression, orngPade.starUnivariateRegression, orngPade.tubedRegression, orngPade.qing1D] 
    20      
     20 
    2121    def __init__(self, parent = None, signalManager = None, name = "Pade"): 
    2222        OWWidget.__init__(self, parent, signalManager, name)  #initialize base class 
    23         self.inputs = [("Examples", ExampleTableWithClass, self.onDataInput)] 
    24         self.outputs = [("Examples", ExampleTableWithClass)] 
     23        self.inputs = [("Examples", ExampleTable, self.onDataInput)] 
     24        self.outputs = [("Examples", ExampleTable)] 
    2525 
    2626        self.attributes = [] 
     
    3838        self.persistence = 40 
    3939 
    40         self.nNeighbours = 30         
    41          
     40        self.nNeighbours = 30 
     41 
    4242        self.loadSettings() 
    4343 
     
    6767        self.outputLB = OWGUI.comboBox(OWGUI.indentedBox(box), self, "outputAttr", callback=self.outputDiffChanged) 
    6868 
    69         box = OWGUI.widgetBox(self.controlArea, "Output meta attributes", addSpace = True)       
     69        box = OWGUI.widgetBox(self.controlArea, "Output meta attributes", addSpace = True) 
    7070        self.metaCB = OWGUI.checkBox(box, self, "derivativeAsMeta", label="Qualitative constraint") 
    7171        OWGUI.checkBox(box, self, "differencesAsMeta", label="Derivatives of selected attributes") 
     
    7878 
    7979        self.persistenceSpin.setEnabled(self.methods[self.method] == orngPade.qing1D) 
    80          
     80 
    8181        self.setFixedWidth(self.sizeHint().width()) 
    8282 
     
    116116    def onDataInput(self, data): 
    117117        self.closeContext() 
    118         if data: 
     118        if data and self.isDataWithClass(data, orange.VarTypes.Discrete): 
    119119            orngPade.makeBasicCache(data, self) 
    120120 
     
    123123            for attr in self.contAttributes: 
    124124                self.outputLB.insertItem(icons[attr.varType], attr.name) 
    125             
     125 
    126126            self.dimensions = range(len(self.attributes)) 
    127127        else: 
     
    156156        self.send("Examples", paded) 
    157157 
    158                              
    159         
     158 
     159 
    160160if __name__=="__main__": 
    161161    import sys 
     
    168168#    ow.onDataInput(orange.ExampleTable(r"c:\delo\qing\smartquin\x2y2.txt")) 
    169169    a.exec_loop() 
    170      
     170 
    171171    ow.saveSettings() 
Note: See TracChangeset for help on using the changeset viewer.