Changeset 8246:cc2c905660ed in orange


Ignore:
Timestamp:
08/21/11 21:42:00 (3 years ago)
Author:
martin <martin@…>
Branch:
default
Convert:
17599d96b372e04b915f0f7655c49a8fc1f3d6a5
Message:

Some bugs removed (related to ABML mostly)

Location:
orange
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • orange/orngABCN2.py

    r8042 r8246  
    88from Orange.classification.rules import ABCN2M 
    99from Orange.classification.rules import ABBeamFilter 
    10 from Orange.classification.rules import ruleCoversArguments 
     10from Orange.classification.rules import RuleCoversArguments 
    1111from Orange.classification.rules import SelectorAdder 
    1212from Orange.classification.rules import ArgFilter 
  • orange/orngABML.py

    r8042 r8246  
    88import Orange.classification.rules 
    99import numpy 
     10import math 
    1011 
    1112# regular expressions 
     
    6263    this class is used as a value for ArgumentationVariable. """ 
    6364    def __init__(self): 
    64         self.positiveArguments = Orange.core.RuleList() 
    65         self.negativeArguments = Orange.core.RuleList() 
    66         self.notYetComputedArguments = [] # Arguments that need the whole data set 
     65        self.positive_arguments = Orange.core.RuleList() 
     66        self.negative_arguments = Orange.core.RuleList() 
     67        self.not_yet_computed_arguments = [] # Arguments that need the whole data set 
    6768                                          # when processing are stored here  
    6869     
    6970    # add an argument that supports the class of the example 
    7071    def addPositive(self, argument): 
    71         self.positiveArguments.append(argument) 
     72        self.positive_arguments.append(argument) 
    7273 
    7374    # add an argument that opposes the class of the example 
    7475    def addNegative(self, argument): 
    75         self.negativeArguments.append(argument) 
     76        self.negative_arguments.append(argument) 
    7677 
    7778    def addNotYetComputed(self, argument, notyet, positive): 
    78         self.notYetComputedArguments.append((argument,notyet,positive)) 
     79        self.not_yet_computed_arguments.append((argument,notyet,positive)) 
    7980 
    8081    def __str__(self): 
     
    8283        # iterate through positive arguments (rules) and 
    8384        # write them down as a text list 
    84         if len(self.positiveArguments)>0: 
    85             for (i,pos) in enumerate(self.positiveArguments[:-1]): 
     85        if len(self.positive_arguments)>0: 
     86            for (i,pos) in enumerate(self.positive_arguments[:-1]): 
    8687                retValue+="{"+listOfAttributeNames(pos)+"}" 
    8788                retValue+="," 
    88             retValue+="{"+listOfAttributeNames(self.positiveArguments[-1])+"}" 
     89            retValue+="{"+listOfAttributeNames(self.positive_arguments[-1])+"}" 
    8990            # do the same thing for negative argument, 
    9091            # just that this time use sign "~" in front of the list 
    91         if len(self.negativeArguments)>0: 
     92        if len(self.negative_arguments)>0: 
    9293            if len(retValue)>0: 
    9394                retValue += "," 
    94             for (i,neg) in enumerate(self.negativeArguments[:-1]): 
     95            for (i,neg) in enumerate(self.negative_arguments[:-1]): 
    9596                retValue+="~" 
    9697                retValue+="{"+listOfAttributeNames(neg,leave_ref=True)+"}" 
    9798                retValue+="," 
    98             retValue+="~{"+listOfAttributeNames(self.negativeArguments[-1],leave_ref=True)+"}" 
     99            retValue+="~{"+listOfAttributeNames(self.negative_arguments[-1],leave_ref=True)+"}" 
    99100        return retValue 
    100101 
     
    225226     
    226227class ArgumentFilter_hasSpecial: 
    227     def __call__(self, examples, attribute, targetClass=-1, negate=0): 
     228    def __call__(self, examples, attribute, target_class=-1, negate=0): 
    228229        indices = [0]*len(examples) 
    229230        for i in range(len(examples)): 
    230231            if examples[i][attribute].isSpecial(): 
    231232                indices[i]=1 
    232             elif targetClass>-1 and not int(examples[i].getclass()) == targetClass: 
     233            elif target_class>-1 and not int(examples[i].getclass()) == target_class: 
    233234                indices[i]=1 
    234             elif len(examples[i][attribute].value.positiveArguments) == 0: 
     235            elif len(examples[i][attribute].value.positive_arguments) == 0: 
    235236                indices[i]=1 
    236237        return examples.select(indices,0,negate=negate) 
     
    245246    for e in examples: 
    246247        if not e[argAtt].isSpecial(): 
    247             for r in e[argAtt].value.positiveArguments: 
     248            for r in e[argAtt].value.positive_arguments: 
    248249                r.filterAndStore(examples, 0, e[examples.domain.classVar]) 
    249250                r.quality = evaluateFunction(r,examples,0,int(e[examples.domain.classVar]),apriori) 
    250             e[argAtt].value.positiveArguments.sort(lambda x,y: -cmp(x.quality, y.quality)) 
     251            e[argAtt].value.positive_arguments.sort(lambda x,y: -cmp(x.quality, y.quality)) 
    251252 
    252253def isGreater(oper): 
     
    311312            else: 
    312313                return Orange.core.Value(self.newAtt, float(example[self.position])) 
     314 
     315 
     316def addErrors(test_data, classifier): 
     317    """ Main task of this function is to add probabilistic errors to examples. Function 
     318        also computes classification accuracy as a by product.""" 
     319    correct        = 0.0 
     320    clDistribution = orange.Distribution(test_data.domain.classVar) 
     321    for ex_i, ex in enumerate(test_data): 
     322        (cl,prob) = classifier(ex,orange.GetBoth) 
     323        # add prob difference to ProbError 
     324        if prob[ex.getclass()] < 0.01: 
     325            print prob 
     326        ex.setmeta("ProbError", ex.getmeta("ProbError") + 1.-prob[ex.getclass()])  
     327        ex.setmeta("ProbErrorSD", ex.getmeta("ProbErrorSD") + math.pow(1.-prob[ex.getclass()],2)) 
     328        if test_data.domain.hasmeta("CoveredRules"): 
     329            for r_i,r in enumerate(classifier.rules): 
     330                if r(ex) and (not hasattr(cl, "ruleBetas") or cl.ruleBetas[r_i]): 
     331                    ex.setmeta("CoveredRules", ex.getmeta("CoveredRules")+orngCN2.ruleToString(r)+";") 
     332        if cl == ex.getclass(): # compute classification accuracy (just for fun) 
     333            correct += 1. 
     334            clDistribution[ex.getclass()] += 1. 
     335    apriori = orange.Distribution(test_data.domain.classVar,test_data) 
     336    correct /= len(test_data) 
     337    for cl_v in test_data.domain.classVar: 
     338        clDistribution[cl_v] /= max(apriori[cl_v],1) 
     339    # add space between different test set in "covered rules" 
     340    for ex in test_data: 
     341        ex.setmeta("CoveredRules", ex.getmeta("CoveredRules")+";      ;") 
     342    return (correct,clDistribution) 
     343 
     344 
     345def nCrossValidation(data,learner,weightID=0,folds=5,n=4,gen=0): 
     346    """ Function performs n x fold crossvalidation. For each classifier 
     347        test set is updated by calling function addErrors. """ 
     348    acc = 0.0 
     349    dist = orange.Distribution(data.domain.classVar)     
     350    pick = orange.MakeRandomIndicesCV(folds=folds, randseed=gen, stratified = orange.MakeRandomIndices.StratifiedIfPossible)     
     351    for d in data: 
     352        d.setmeta("ProbError",0.) 
     353        d.setmeta("ProbErrorSD",0.) 
     354##        d.setmeta("Rules","") 
     355    for n_i in range(n): 
     356        pick.randseed = gen+10*n_i 
     357        selection = pick(data) 
     358        for folds_i in range(folds): 
     359            for data_i,e in enumerate(data): 
     360                try: 
     361                    if e["Arguments"]: # examples with arguments do not need to be tested 
     362                        selection[data_i]=folds_i+1 
     363                except: 
     364                    pass 
     365            train_data = data.selectref(selection, folds_i,negate=1) 
     366            test_data = data.selectref(selection, folds_i,negate=0) 
     367            classifier = learner(train_data,weightID) 
     368            classifier.setattr("data", train_data) 
     369            acc1,dist1 = addErrors(test_data, classifier) 
     370 
     371            print "N=%d, Folds=%d: %s %s" % (n_i+1, folds_i, acc1, dist1) 
     372            acc += acc1 
     373            for cl_i in range(len(data.domain.classVar.values)): 
     374                dist[cl_i] += dist1[cl_i] 
     375 
     376    for e in data: 
     377        avgProb = e.getmeta("ProbError")/n 
     378        sumSq = e.getmeta("ProbErrorSD") 
     379        sumProb = e.getmeta("ProbError") 
     380        if n>1 and (sumSq-2*avgProb*sumProb+n*math.pow(avgProb,2))/(n-1) > 0.: 
     381            e.setmeta("ProbErrorSD", math.sqrt((sumSq-2*avgProb*sumProb+n*math.pow(avgProb,2))/(n-1))) 
     382        else: 
     383            e.setmeta("ProbErrorSD", 0.) 
     384        e.setmeta("ProbError", avgProb) 
     385    acc = acc/n/folds 
     386    for cl_v in test_data.domain.classVar: 
     387        dist[cl_v] /= n*folds 
     388    return (acc,dist) 
     389 
     390 
     391def findProb(learner,examples,weightID=0,folds=5,n=4,gen=0): 
     392    """ General method for calling to find problematic example. 
     393        It returns all examples along with average probabilistic errors. 
     394        Taking the one with highest error is the same as taking the most 
     395        problematic example. """ 
     396    newDomain = orange.Domain(examples.domain.attributes, examples.domain.classVar) 
     397    newDomain.addmetas(examples.domain.getmetas()) 
     398    newExamples = orange.ExampleTable(newDomain, examples) 
     399    if not newExamples.domain.hasmeta("ProbError"): 
     400        newId = orange.newmetaid() 
     401        newDomain.addmeta(newId, orange.FloatVariable("ProbError")) 
     402        newExamples = orange.ExampleTable(newDomain, examples) 
     403    if not newExamples.domain.hasmeta("ProbErrorSD"): 
     404        newId = orange.newmetaid() 
     405        newDomain.addmeta(newId, orange.FloatVariable("ProbErrorSD")) 
     406        newExamples = orange.ExampleTable(newDomain, examples) 
     407    if not newExamples.domain.hasmeta("CoveredRules"): 
     408        newId = orange.newmetaid() 
     409        newDomain.addmeta(newId, orange.StringVariable("CoveredRules")) 
     410        newExamples = orange.ExampleTable(newDomain, examples)         
     411    if not newExamples.domain.hasmeta("SerialNumberPE"): 
     412        newId = orange.newmetaid() 
     413        newDomain.addmeta(newId, orange.FloatVariable("SerialNumberPE")) 
     414        newExamples = orange.ExampleTable(newDomain, examples) 
     415##        newExamples.domain.addmeta(newId, orange.FloatVariable("SerialNumberPE")) 
     416##        newExamples.addMetaAttribute("SerialNumberPE", 0.) 
     417        for i in range(len(newExamples)): 
     418            newExamples[i]["SerialNumberPE"] = float(i) 
     419    trs = nCrossValidation(newExamples,learner,weightID=weightID, folds=folds, n=n, gen=gen) 
     420    return newExamples             
  • orange/orngCN2.py

    r8042 r8246  
    1818from Orange.classification.rules import RuleStopping_SetRules as ruleSt_setRules 
    1919from Orange.classification.rules import CN2SDUnorderedLearner 
    20 from Orange.classification.rules import avg 
    21 from Orange.classification.rules import var 
    22 from Orange.classification.rules import median 
    23 from Orange.classification.rules import perc 
    24 from Orange.classification.rules import createRandomDataSet 
    25 from Orange.classification.rules import compParameters 
    26 from Orange.classification.rules import computeDists 
    27 from Orange.classification.rules import createEVDistList 
    2820from Orange.classification.rules import CovererAndRemover_Prob 
    29 from Orange.classification.rules import add_sub_rules 
    3021from Orange.classification.rules import CN2EVCUnorderedLearner 
Note: See TracChangeset for help on using the changeset viewer.