owroc.py

orange源码 数据挖掘技术

        self.mergedConvexHullData = []
        if len(mergedIterations.results) > 0:
            curves = self.computeCurve(mergedIterations, self.targetClass, 1)
            convexCurves = self.computeCurve(mergedIterations, self.targetClass, 0)
            classifier = 0
            for c in curves:
                x = [px for (px, py, pf) in c]
                y = [py for (px, py, pf) in c]
                ckey = self.mergedCKeys[classifier]
                self.setCurveData(ckey, x, y)

		# points of defualt threshold classifiers
                defPoint = [(abs(pf-0.5), pf, px, py) for (px, py, pf) in c]
                defPoints = []
                if len(defPoint) > 0:
                	defPoint.sort()
                	defPoints = [(px, py, pf) for (d, pf, px, py) in defPoint if d == defPoint[0][0]]
                else:
                	defPoints = []
                defX = [px for (px, py, pf) in defPoints]
                defY = [py for (px, py, pf) in defPoints]
                ckey = self.mergedCThresholdKeys[classifier]
                self.setCurveData(ckey, defX, defY)
                
                for mkey in self.mergedCThresholdMarkers[classifier]:
                	self.removeMarker(mkey)
                self.mergedCThresholdMarkers[classifier] = []
                for (dx, dy, pf) in defPoints:
                	mkey = self.insertMarker('%3.2g' % (pf))
                	dx = max(min(0.95, dx + 0.01), 0.01)
                	dy = min(max(0.01, dy - 0.02), 0.95)
                	self.marker(mkey).setXValue(dx)
                	self.marker(mkey).setYValue(dy)
                	self.marker(mkey).setLabelAlignment(Qt.AlignRight)
                	self.mergedCThresholdMarkers[classifier].append(mkey)
                classifier += 1
            classifier = 0
            for c in convexCurves:
                self.mergedConvexHullData.append(c) ## put all points of all curves into one big array
                x = [px for (px, py, pf) in c]
                y = [py for (px, py, pf) in c]
                ckey = self.mergedConvexCKeys[classifier]
                self.setCurveData(ckey, x, y)
                classifier += 1
        else:
            for c in range(len(self.mergedCKeys)):
                self.setCurveData(self.mergedCKeys[c], [], [])
                self.setCurveData(self.mergedCThresholdKeys[c], [], [])
                for mkey in self.mergedCThresholdMarkers[c]:
                	self.removeMarker(mkey)
                self.mergedCThresholdMarkers[c] = []
                self.setCurveData(self.mergedConvexCKeys[c], [], [])

        ## prepare a common input structure for vertical and threshold averaging
        ROCS = []
        somethingToShow = 0
        for c in self.classifierIterationROCdata:
            ROCS.append([])
            i = 0
            for s in self.showIterations:
                if s:
                    somethingToShow = 1
                    ROCS[-1].append(c[i])
                i += 1

        ## remove curve
        self.verticalConvexHullData = []
        self.thresholdConvexHullData = []

        if somethingToShow == 0:
            for ckey in self.verticalCKeys:
                self.setCurveData(ckey, [], [])

            for ckey in self.thresholdCKeys:
                self.setCurveData(ckey, [], [])
            return

        ##
        ## self.averagingMethod == 'vertical':
        ## calculated from the self.classifierIterationROCdata data
        (averageCurves, verticalErrorBarValues) = orngStat.TCverticalAverageROC(ROCS, self.VTAsamples)
        classifier = 0
        for c in averageCurves:
            self.verticalConvexHullData.append(c)
            xs = []
            mps = []
            for pcn in range(len(c)):
                (px, py) = c[pcn]
                ## for the error bar plot
                xs.append(px)
                mps.append(py + 0.0)

                xs.append(px)
                mps.append(py + verticalErrorBarValues[classifier][pcn])

                xs.append(px)
                mps.append(py - verticalErrorBarValues[classifier][pcn])

            ckey =  self.verticalCKeys[classifier]
            self.setCurveData(ckey, xs, mps)
            classifier += 1

        ##
        ## self.averagingMethod == 'threshold':
        ## calculated from the self.classifierIterationROCdata data
        (averageCurves, verticalErrorBarValues, horizontalErrorBarValues) = orngStat.TCthresholdlAverageROC(ROCS, self.VTAsamples)
        classifier = 0
        for c in averageCurves:
            self.thresholdConvexHullData.append(c)
            xs = []
            mps = []
            for pcn in range(len(c)):
                (px, py) = c[pcn]
                ## for the error bar plot
                xs.append(px + 0.0)
                mps.append(py + 0.0)

                xs.append(px - horizontalErrorBarValues[classifier][pcn])
                mps.append(py + verticalErrorBarValues[classifier][pcn])

                xs.append(px + horizontalErrorBarValues[classifier][pcn])
                mps.append(py - verticalErrorBarValues[classifier][pcn])

            ckey = self.thresholdCKeys[classifier]
            self.setCurveData(ckey, xs, mps)
            classifier += 1

        ## self.averagingMethod == 'None'
        ## already calculated

    def calcConvexHulls(self):
        ## self.classifierConvexHullCKey = -1
        hullData = []
        for cNum in range(len(self.showClassifiers)):
            for iNum in range(len(self.showIterations)):
                if (self.showClassifiers[cNum] <> 0) and (self.showIterations[iNum] <> 0):
                    hullData.append(self.classifierIterationROCdata[cNum][iNum])

        convexHullCurve = TCconvexHull(hullData)
        x = [px for (px, py, pf) in convexHullCurve]
        y = [py for (px, py, pf) in convexHullCurve]
        self.setCurveData(self.classifierConvexHullCKey, x, y)

        ## self.mergedConvexHullCKey = -1
        hullData = []
        for cNum in range(len(self.mergedConvexHullData)):
            if (self.showClassifiers[cNum] <> 0):
                ncurve = []
                for (px, py, pfscore) in self.mergedConvexHullData[cNum]:
                    ncurve.append( (px, py, (cNum, pfscore)) )
                hullData.append(ncurve)

        self.hullCurveDataForPerfLine = TCconvexHull(hullData) # keep data about curve for performance line drawing
        x = [px for (px, py, pf) in self.hullCurveDataForPerfLine]
        y = [py for (px, py, pf) in self.hullCurveDataForPerfLine]
        self.setCurveData(self.mergedConvexHullCKey, x, y)

        ## self.verticalConvexHullCKey = -1
        hullData = []
        for cNum in range(len(self.verticalConvexHullData)):
            if (self.showClassifiers[cNum] <> 0):
                hullData.append(self.verticalConvexHullData[cNum])

        convexHullCurve = TCconvexHull(hullData)
        x = [px for (px, py, pf) in convexHullCurve]
        y = [py for (px, py, pf) in convexHullCurve]
        self.setCurveData(self.verticalConvexHullCKey, x, y)

        ## self.thresholdConvexHullCKey = -1
        hullData = []
        for cNum in range(len(self.thresholdConvexHullData)):
            if (self.showClassifiers[cNum] <> 0):
                hullData.append(self.thresholdConvexHullData[cNum])

        convexHullCurve = TCconvexHull(hullData)
        x = [px for (px, py, pf) in convexHullCurve]
        y = [py for (px, py, pf) in convexHullCurve]
        self.setCurveData(self.thresholdConvexHullCKey, x, y)

    def setAveragingMethod(self, m):
        self.averagingMethod = m
        self.updateCurveDisplay()

    ## performance line
    def calcUpdatePerformanceLine(self):
    	closestpoints = orngStat.TCbestThresholdsOnROCcurve(self.FPcost, self.FNcost, self.pvalue, self.hullCurveDataForPerfLine)
    	m = (self.FPcost*(1.0 - self.pvalue)) / (self.FNcost*self.pvalue)

        ## now draw the closest line to the curve
        b = (self.averagingMethod == 'merge') and self.showPerformanceLine
        lpx = []
        lpy = []
        first = 1
        ## remove old markers
        for mkey in self.performanceMarkerKeys:
        	self.removeMarker(mkey)
       	self.performanceMarkerKeys = []
        for (x, y, fscorelist) in closestpoints:
            if first:
                first = 0
                lpx.append(x - 2.0)
                lpy.append(y - 2.0*m)
            lpx.append(x)
            lpy.append(y)
            px = x
            py = y
            for (cNum, threshold) in fscorelist:
                s = "%1.3f %s" % (threshold, self.classifierNames[cNum])
               	px = max(min(0.95, px + 0.01), 0.01)
                py = min(max(0.01, py - 0.02), 0.95)
                mkey = self.insertMarker(s)
                self.marker(mkey).setXValue(px)
                self.marker(mkey).setYValue(py)
                self.marker(mkey).setLabelAlignment(Qt.AlignRight)
                self.marker(mkey).setEnabled(b)
                self.performanceMarkerKeys.append(mkey)
        if len(closestpoints) > 0:
            lpx.append(x + 2.0)
            lpy.append(y + 2.0*m)

        self.setCurveData(self.performanceLineCKey, lpx, lpy)
        self.curve(self.performanceLineCKey).setEnabled(b)
        self.update()

    def costChanged(self, FPcost, FNcost):
        self.FPcost = float(FPcost)
        self.FNcost = float(FNcost)
        self.calcUpdatePerformanceLine()

    def pChanged(self, pvalue):
        self.pvalue = float(pvalue)
        self.calcUpdatePerformanceLine()

    def setPointWidth(self, v):
        self.performanceLineSymbol.setSize(v, v)
        self.setCurveSymbol(self.performanceLineCKey, self.performanceLineSymbol)
        self.update()

    def setCurveWidth(self, v):
        for cNum in range(len(self.showClassifiers)):
            self.setCurvePen(self.mergedCKeys[cNum], QPen(self.classifierColor[cNum], v))
            self.setCurvePen(self.verticalCKeys[cNum], QPen(self.classifierColor[cNum], v))
            self.setCurvePen(self.thresholdCKeys[cNum], QPen(self.classifierColor[cNum], v))
            for iNum in range(len(self.showIterations)):
                self.setCurvePen(self.classifierIterationCKeys[cNum][iNum], QPen(self.classifierColor[cNum], v))
        self.update()

    def setConvexCurveWidth(self, v):
        for cNum in range(len(self.showClassifiers)):
            self.setCurvePen(self.mergedConvexCKeys[cNum], QPen(self.classifierColor[cNum], v))
            for iNum in range(len(self.showIterations)):
                self.setCurvePen(self.classifierIterationConvexCKeys[cNum][iNum], QPen(self.classifierColor[cNum], v))
        self.update()

    def setShowDiagonal(self, v):
        self.showDiagonal = v
        self.updateCurveDisplay()

    def setConvexHullCurveWidth(self, v):
        self.convexHullPen.setWidth(v)
        self.setCurvePen(self.mergedConvexHullCKey, self.convexHullPen)
        self.setCurvePen(self.verticalConvexHullCKey, self.convexHullPen)
        self.setCurvePen(self.thresholdConvexHullCKey, self.convexHullPen)
        self.setCurvePen(self.classifierConvexHullCKey, self.convexHullPen)
        self.update()

    def setHullColor(self, c):
        self.convexHullPen.setColor(c)
        self.setCurvePen(self.mergedConvexHullCKey, self.convexHullPen)
        self.setCurvePen(self.verticalConvexHullCKey, self.convexHullPen)
        self.setCurvePen(self.thresholdConvexHullCKey, self.convexHullPen)
        self.setCurvePen(self.classifierConvexHullCKey, self.convexHullPen)
        self.update()

    def sizeHint(self):
        return QSize(100, 100)

class OWROC(OWWidget):
    settingsList = ["PointWidth", "CurveWidth", "ConvexCurveWidth", "ShowDiagonal",
                    "ConvexHullCurveWidth", "HullColor", "AveragingMethodIndex",
                    "ShowConvexHull", "ShowConvexCurves", "EnablePerformance", "DefaultThresholdPoint"]
    def __init__(self,parent=None, signalManager = None):
        OWWidget.__init__(self, parent, signalManager, "ROC Analysis", 1)

        # inputs
        self.inputs=[("Evaluation Results", orngTest.ExperimentResults, self.test_results, Default)]

        # default settings
        self.PointWidth = 7
        self.CurveWidth = 3
        self.ConvexCurveWidth = 1
        self.ShowDiagonal = TRUE
        self.ConvexHullCurveWidth = 3
        self.HullColor = str(Qt.yellow.name())
        self.AveragingMethodIndex = 0 ##'merge'
        self.ShowConvexHull = TRUE
        self.ShowConvexCurves = FALSE
        self.EnablePerformance = TRUE
        self.DefaultThresholdPoint = TRUE

        #load settings
        self.loadSettings()

        # temp variables
        self.dres = None
        self.classifierColor = None
        self.numberOfClasses  = 0
        self.targetClass = None
        self.numberOfClassifiers = 0
        self.numberOfIterations = 0
        self.graphs = []
        self.maxp = 1000
        self.defaultPerfLinePValues = []

        # performance analysis (temporary values
        self.FPcost = 500.0
        self.FNcost = 500.0
        self.pvalue = 50.0 ##0.400

        # list of values (remember for each class)
        self.FPcostList = []
        self.FNcostList = []
        self.pvalueList = []

        self.AveragingMethodNames = ['merge', 'vertical', 'threshold', None]
        self.AveragingMethod = self.AveragingMethodNames[self.AveragingMethodIndex]

        # GUI
        self.grid.expand(3, 3)
        self.graphsGridLayoutQGL = QGridLayout(self.mainArea)
        # save each ROC graph in separate file
        self.connect(self.graphButton, SIGNAL("clicked()"), self.saveToFile)

        ## general tab
        self.tabs = QTabWidget(self.controlArea, 'tabWidget')
        self.generalTab = QVGroupBox(self)

        ## target class
        self.classCombo = OWGUI.comboBox(self.generalTab, self, 'targetClass', box='Target Class', items=[], callback=self.target)