owcn2rulesviewer.py

orange源码 数据挖掘技术

                    items[i][j].fixGeom((textMapH[j+1])-textMapH[j]-10)
                items[i][j].move(textMapH[j], textMapV[i-1])
                items[i][j].setZ(0)
                items[i][j].show()
            r=QCanvasRectangle(0,textMapV[i], textMapH[-1], textMapV[i-1]-textMapV[i], self.canvas)
            r.setZ(-20)
            r.setPen(QPen(Qt.NoPen))
            r.show()
            r.index=i+1
            r.rule=self.text[i-1][-1]
            if r.rule in self.oldSelection:
                self.canvasView.addSelection(r)
            self.obj.append(r)
            self.rectObj.append(r)
        self.ctrlPressed=False
            
        self.canvas.resize(textMapH[-1], textMapV[-1])
        for i,t in enumerate(items[0][:-1]):
            t.move(textMapH[i],0)
            t.show()
        self.headerCanvas.update()
        self.headerCanvas.resize(textMapH[-1]+20,20)
        self.canvas.update()
        
    def ruleText(self, r):
        str=orngCN2.ruleToString(r)
        list=re.split("([0-9.]*)",str)
        #print list
        for i in range(len(list)):
            try:
                f=float(list[i])
                list[i]="%.3f" % f
                t=int(list[i])
                list[i]=str(t)
            except:
                pass
        str="".join(list)
        list=re.split("<[0-9., ]*>$", str)
        str=list[0]
        str="AND\n   ".join(str.split("AND"))
        str="\nTHEN".join(str.split("THEN"))
        return str

    def distText(self,r):
        #e=self.classifier.examples.filterref(r.filter)
        d=r.classDistribution#orange.Distribution(r.classifier.classVar,self.classifier.examples.filterref(r.filter))
        s=str(d).strip("<>")
        return "<"+",".join(["%.1f" % float(f) for f in s.split(",")])+">"

    def select(self):
        examples=[]
        source=self.classifier.examples
        for r in self.selRect:
            examples.extend(source.filterref(r.rule.filter))
            r.rule.filter.negate=1
            source=source.filterref(r.rule.filter)
            r.rule.filter.negate=0
        if not examples:
            self.examples=None
            self.commit()
            return
        self.examples=examples
        if self.Commit:
            self.commit()
            
    def data(self, classifier):
        #print classifier
        if classifier:
            self.clear()
            self.classifier=classifier
            self.rules=classifier.rules
            self.showRules()
        else:
            self.rules=None
            self.clear()
        self.examples=None
        self.commit()

    def compare(self,a,b):
        if str(a[self.sortBy])<str(b[self.sortBy]):
            return -1
        elif str(a[self.sortBy])>str(b[self.sortBy]):
            return 1
        else:
            return -1    
    def compareDist(self,a,b):
##        if max(a[-1].classDistribution)/a[-1].classDistribution.abs \
##                < max(b[-1].classDistribution)/b[-1].classDistribution.abs:
##            return -1
        if max(a[-1].classDistribution)/a[-1].classDistribution.abs \
               > max(b[-1].classDistribution)/b[-1].classDistribution.abs:
            return 1
        else:
            return -1
        
    def sort(self):
        text=[]
        if self.Sort==5:
            self.text.sort(self.compareDist)
        elif self.Sort==3 or self.Sort==1:
            self.text.sort(lambda a,b:-cmp(float(a[self.Sort]),float(b[self.Sort])))
        elif self.Sort==0:
            self.text.sort(lambda a,b:cmp(a[0],b[0]))
        else:
            if self.Sort>6:
                self.sortBy=self.Sort+1
            else:
                self.sortBy=self.Sort
            self.text.sort(self.compare)
        #print self.text
        if self.Sort>=2 and self.Sort!=4 and self.Sort !=6:
            self.text.reverse()     

    def selectAttributes(self):
        import sets
        selected=[]
        for r in self.selRect:
            string=orngCN2.ruleToString(r.rule)[2:].strip(" ").split("THEN")[0]
            list=string.split("AND")
            for l in list:
                s=re.split("[=<>]", l.strip(" "))
                selected.append(s[0])
        selected=reduce(lambda l,r:(r in l) and l or l+[r], selected, [])
        return selected          

    def commit(self):
        if self.examples:
            selected=self.selectAttributes()
            varList=[self.classifier.examples.domain[s] for s in selected]
            if self.SelectedAttrOnly:
                domain=orange.Domain(varList+[self.classifier.examples.domain.classVar])
                domain.addmetas(self.classifier.examples.domain.getmetas())
                examples=orange.ExampleTable(domain, self.examples)
            else:
                examples = orange.ExampleTable(self.examples)
            self.send("Classified Examples", examples)
            self.send("Examples", examples)
            self.send("Attribute List", orange.VarList(varList))
        else:
            self.send("Classified Examples", None)
            self.send("Examples",None)
            self.send("Attribute List", None)
            

    def saveRules(self):
        fileName=str(QFileDialog.getSaveFileName("Rules.txt",".txt"))
        try:
            f=open(fileName,"w")
        except :
            return
        for r in self.rules:
            f.write(orngCN2.ruleToString(r)+"\n")
            
    def keyPressEvent(self, key):
        if key.key()==Qt.Key_Control:
            self.ctrlPressed=True
        else:
            key.ignore()

    def keyReleaseEvent(self, key):
        if key.key()==Qt.Key_Control:
            self.ctrlPressed=False
        else:
            key.ignore()

barWidth=80
barHeight=10
class DistBar(QCanvasRectangle):
    def __init__(self, distText,showText,canvas, *args):
        apply(QCanvasRectangle.__init__,(self,canvas)+args)
        self.distText=distText
        self.showText=showText
        self.canvas=canvas
        self.rect=[]
        self.text=QCanvasText(distText,canvas)
        self.barWidth=max([barWidth, showText and self.text.boundingRect().width()])
        self.setSize(self.barWidth, barHeight)
        
    def fixGeom(self, width):
        distText=self.distText.strip("<>")
        dist=[float(f) for f in distText.split(",")]
        distSum=sum(dist)
        classColor=OWGraphTools.ColorPaletteHSV(len(dist))
        m=max(dist)
        for i in range(len(dist)):
            r=QCanvasRectangle(self.canvas)
            r.setSize(dist[i]/distSum*width,barHeight)
            r.setPen(QPen(QColor(classColor[i]),2))
            if dist[i]==m:
                r.setBrush(QBrush(classColor[i]))
            self.rect.append(r)
            
    def move(self, x,y):
        if self.showText:
            ty, ry=y, y+18
        else:
            ty, ry=0, y+3
        pos=0
        for r in self.rect:
            r.move(x+pos,ry)
            pos+=r.width()
        self.text.move(x,ty)
            
    def show(self):
        for r in self.rect:
            r.show()
        if self.showText:
            self.text.show()
    def setCanvas(self, canvas):
        for r in self.rect:
            r.setCanvas(canvas)
        self.text.setCanvas(canvas)
    
    
if __name__=="__main__":
    ap=QApplication(sys.argv)
    w=OWCN2RulesViewer()
    ap.setMainWidget(w)
    data=orange.ExampleTable("../../doc/datasets/car.tab")
    l=orngCN2.CN2UnorderedLearner()
    l.ruleFinder.ruleStoppingValidator=orange.RuleValidator_LRS()
    w.data(l(data))
    w.data(l(data))
    w.show()
    ap.exec_loop()