Ignore:
Timestamp:
03/23/12 20:20:57 (2 years ago)
Author:
mstajdohar
Branch:
default
Message:

Changed obsolete names.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • Orange/evaluation/scoring.py

    r10580 r10633  
    5050    if res.number_of_iterations < 2: 
    5151        return [res] 
    52          
     52 
    5353    ress = [Orange.evaluation.testing.ExperimentResults( 
    5454                1, res.classifier_names, res.class_values, 
     
    6868        r = Orange.evaluation.testing.ExperimentResults(res.numberOfIterations, 
    6969                    [res.classifierNames[i]], res.classValues, 
    70                     weights=res.weights, baseClass=res.baseClass, 
     70                    weights=res.weights, base_class=res.base_class, 
    7171                    classifiers=[res.classifiers[i]] if res.classifiers else [], 
    7272                    test_type=res.test_type, labels=res.labels) 
     
    118118    if not stats[0]: 
    119119        raise ValueError, "Cannot compute the score: no examples or sum of weights is 0." 
    120      
     120 
    121121    if report_se: 
    122122        return [(statc.mean(x), statc.sterr(x)) for x in stats] 
    123123    else: 
    124124        return [statc.mean(x) for x in stats] 
    125      
     125 
    126126def ME(res, **argkw): 
    127127    MEs = [0.] * res.number_of_learners 
     
    129129    if argkw.get("unweighted", 0) or not res.weights: 
    130130        for tex in res.results: 
    131             MEs = map(lambda res, cls, ac = float(tex.actual_class): 
     131            MEs = map(lambda res, cls, ac=float(tex.actual_class): 
    132132                      res + abs(float(cls) - ac), MEs, tex.classes) 
    133133        totweight = gettotsize(res) 
     
    216216                    norm[tex.iteration_number] += abs(ai - a[tex.iteration_number]) 
    217217                elif argkw.get("norm-sqr", 0): 
    218                     norm[tex.iteration_number] += (ai - a[tex.iteration_number])**2 
     218                    norm[tex.iteration_number] += (ai - a[tex.iteration_number]) ** 2 
    219219 
    220220                # iterate accross results of different regressors 
     
    223223                        scores[i][tex.iteration_number] += abs(float(cls) - ai) 
    224224                    else: 
    225                         scores[i][tex.iteration_number] += (float(cls) - ai)**2 
     225                        scores[i][tex.iteration_number] += (float(cls) - ai) ** 2 
    226226        else: # unweighted != 0 
    227227            raise NotImplementedError, "weighted error scores with SE not implemented yet" 
     
    239239 
    240240        return [(statc.mean(x), statc.std(x)) for x in scores] 
    241          
     241 
    242242    else: # single iteration (testing on a single test set) 
    243243        scores = [0.] * res.number_of_learners 
     
    253253                else: 
    254254                    scores = map(lambda res, cls, ac=float(tex.actual_class): 
    255                                  res + (float(cls) - ac)**2, scores, tex.classes) 
     255                                 res + (float(cls) - ac) ** 2, scores, tex.classes) 
    256256 
    257257                if argkw.get("norm-abs", 0): 
    258258                    norm += abs(tex.actual_class - a) 
    259259                elif argkw.get("norm-sqr", 0): 
    260                     norm += (tex.actual_class - a)**2 
     260                    norm += (tex.actual_class - a) ** 2 
    261261            totweight = gettotsize(res) 
    262262        else: 
     
    266266                MSEs = map(lambda res, cls, ac=float(tex.actual_class), 
    267267                           tw=tex.weight: 
    268                            res + tw * (float(cls) - ac)**2, MSEs, tex.classes) 
     268                           res + tw * (float(cls) - ac) ** 2, MSEs, tex.classes) 
    269269            totweight = gettotweight(res) 
    270270 
     
    285285    """Compute mean-squared error.""" 
    286286    return regression_error(res, **argkw) 
    287      
     287 
    288288def RMSE(res, **argkw): 
    289289    """Compute root mean-squared error.""" 
     
    330330                nIter[tex.iteration_number] += 1 
    331331                for i, cls in enumerate(tex.classes): 
    332                     MSEs[i][tex.iteration_number] += (float(cls) - ac)**2 
     332                    MSEs[i][tex.iteration_number] += (float(cls) - ac) ** 2 
    333333        else: 
    334334            raise ValueError, "weighted RMSE with SE not implemented yet" 
     
    337337            MSEs = [[math.sqrt(x) for x in y] for y in MSEs] 
    338338        return [(statc.mean(x), statc.std(x)) for x in MSEs] 
    339          
     339 
    340340    else: 
    341341        MSEs = [0.] * res.number_of_learners 
     
    343343            for tex in res.results: 
    344344                MSEs = map(lambda res, cls, ac=float(tex.actual_class): 
    345                            res + (float(cls) - ac)**2, MSEs, tex.classes) 
     345                           res + (float(cls) - ac) ** 2, MSEs, tex.classes) 
    346346            totweight = gettotsize(res) 
    347347        else: 
    348348            for tex in res.results: 
    349349                MSEs = map(lambda res, cls, ac=float(tex.actual_class), 
    350                            tw=tex.weight: res + tw * (float(cls) - ac)**2, 
     350                           tw=tex.weight: res + tw * (float(cls) - ac) ** 2, 
    351351                           MSEs, tex.classes) 
    352352            totweight = gettotweight(res) 
     
    386386    @deprecated_keywords({"reportSE": "report_se", 
    387387                          "unweighted": "ignore_weights"}) 
    388     def __init__(self, test_results, report_se = False, ignore_weights=False): 
     388    def __init__(self, test_results, report_se=False, ignore_weights=False): 
    389389        super(CA, self).__init__() 
    390390        self.report_se = report_se 
     
    449449            w = 1. if self.ignore_weights else tex.weight 
    450450            for lrn in range(test_results.number_of_learners): 
    451                 CAsByFold[lrn][tex.iteration_number] += (tex.classes[lrn] ==  
     451                CAsByFold[lrn][tex.iteration_number] += (tex.classes[lrn] == 
    452452                    tex.actual_class) and w 
    453453            foldN[tex.iteration_number] += w 
     
    472472    """Compute the average probability assigned to the correct class.""" 
    473473    if res.number_of_iterations == 1: 
    474         APs=[0.] * res.number_of_learners 
     474        APs = [0.] * res.number_of_learners 
    475475        if ignore_weights or not res.weights: 
    476476            for tex in res.results: 
     
    525525 
    526526    if res.number_of_iterations == 1: 
    527         MSEs=[0.] * res.number_of_learners 
     527        MSEs = [0.] * res.number_of_learners 
    528528        if ignore_weights or not res.weights: 
    529529            totweight = 0. 
    530530            for tex in res.results: 
    531531                MSEs = map(lambda res, probs: res + reduce( 
    532                     lambda s, pi: s + pi**2, probs, 0) -  
     532                    lambda s, pi: s + pi ** 2, probs, 0) - 
    533533                    2 * probs[tex.actual_class], MSEs, tex.probabilities) 
    534534                totweight += tex.weight 
     
    536536            for tex in res.results: 
    537537                MSEs = map(lambda res, probs: res + tex.weight * reduce( 
    538                     lambda s, pi: s + pi**2, probs, 0) -  
     538                    lambda s, pi: s + pi ** 2, probs, 0) - 
    539539                    2 * probs[tex.actual_class], MSEs, tex.probabilities) 
    540540            totweight = gettotweight(res) 
     
    553553        for tex in res.results: 
    554554            BSs[tex.iteration_number] = map(lambda rr, probs: rr + reduce( 
    555                 lambda s, pi: s + pi**2, probs, 0) - 
     555                lambda s, pi: s + pi ** 2, probs, 0) - 
    556556                2 * probs[tex.actual_class], BSs[tex.iteration_number], 
    557557                tex.probabilities) 
     
    560560        for tex in res.results: 
    561561            BSs[tex.iteration_number] = map(lambda res, probs: 
    562                 res + tex.weight * reduce(lambda s, pi: s + pi**2, probs, 0) - 
     562                res + tex.weight * reduce(lambda s, pi: s + pi ** 2, probs, 0) - 
    563563                2 * probs[tex. actual_class], BSs[tex.iteration_number], 
    564564                tex.probabilities) 
     
    572572 
    573573def BSS(res, **argkw): 
    574     return [1 - x / 2 for x in apply(Brier_score, (res, ), argkw)] 
     574    return [1 - x / 2 for x in apply(Brier_score, (res,), argkw)] 
    575575 
    576576def IS_ex(Pc, P): 
     
    614614            return [IS / totweight for IS in ISs] 
    615615 
    616          
     616 
    617617    ISs = [[0.] * res.number_of_iterations 
    618618           for _ in range(res.number_of_learners)] 
     
    636636 
    637637    return statistics_by_folds(ISs, foldN, report_se, False) 
    638      
     638 
    639639 
    640640def Wilcoxon(res, statistics, **argkw): 
     
    664664                      "classIndex": "class_index", 
    665665                      "unweighted": "ignore_weights"}) 
    666 def confusion_matrices(test_results, class_index=-1, 
     666def confusion_matrices(test_results, class_index= -1, 
    667667                       ignore_weights=False, cutoff=.5): 
    668668    """ 
     
    678678    """ 
    679679    tfpns = [ConfusionMatrix() for _ in range(test_results.number_of_learners)] 
    680      
     680 
    681681    if class_index < 0: 
    682682        numberOfClasses = len(test_results.class_values) 
     
    699699                            cm[li][trueClass][predClass] += tex.weight 
    700700            return cm 
    701              
    702         elif test_results.baseClass >= 0: 
    703             class_index = test_results.baseClass 
     701 
     702        elif test_results.base_class >= 0: 
     703            class_index = test_results.base_class 
    704704        else: 
    705705            class_index = 1 
     
    708708        if ignore_weights or not test_results.weights: 
    709709            for lr in test_results.results: 
    710                 isPositive=(lr.actual_class==class_index) 
     710                isPositive = (lr.actual_class == class_index) 
    711711                for i in range(test_results.number_of_learners): 
    712712                    tfpns[i].addTFPosNeg(lr.probabilities[i][class_index] > 
     
    714714        else: 
    715715            for lr in test_results.results: 
    716                 isPositive=(lr.actual_class == class_index) 
     716                isPositive = (lr.actual_class == class_index) 
    717717                for i in range(test_results.number_of_learners): 
    718                     tfpns[i].addTFPosNeg(lr.probabilities[i][class_index] >  
     718                    tfpns[i].addTFPosNeg(lr.probabilities[i][class_index] > 
    719719                                         cutoff, isPositive, lr.weight) 
    720720    else: 
     
    766766            if not e: 
    767767                return -1, -1, -1 
    768             ss += (o - e)**2 / e 
    769     df = (dim - 1)**2 
     768            ss += (o - e) ** 2 / e 
     769    df = (dim - 1) ** 2 
    770770    return ss, df, statc.chisqprob(ss, df) 
    771771 
     
    807807    @classmethod 
    808808    def compute(self, confusion_matrix): 
    809         tot = confusion_matrix.TP+confusion_matrix.FN 
     809        tot = confusion_matrix.TP + confusion_matrix.FN 
    810810        if tot < 1e-6: 
    811811            import warnings 
     
    831831    @classmethod 
    832832    def compute(self, confusion_matrix): 
    833         tot = confusion_matrix.FP+confusion_matrix.TN 
     833        tot = confusion_matrix.FP + confusion_matrix.TN 
    834834        if tot < 1e-6: 
    835835            import warnings 
     
    851851            warnings.warn("Can't compute PPV: one or both classes have no instances") 
    852852            return None 
    853         return confusion_matrix.TP/tot 
     853        return confusion_matrix.TP / tot 
    854854 
    855855 
     
    885885        p = Precision.compute(confusion_matrix) 
    886886        r = Recall.compute(confusion_matrix) 
    887         if p is not None and r is not None and (p+r) != 0: 
     887        if p is not None and r is not None and (p + r) != 0: 
    888888            return 2. * p * r / (p + r) 
    889889        else: 
     
    918918        # code by Boris Gorelik 
    919919        TP, TN, FP, FN = cm.TP, cm.TN, cm.FP, cm.FN 
    920            
     920 
    921921        try: 
    922             return (TP*TN - FP*FN) /\ 
    923                  math.sqrt((TP+FP) * (TP+FN) * (TN+ FP) * (TN+FN)) 
     922            return (TP * TN - FP * FN) / \ 
     923                 math.sqrt((TP + FP) * (TP + FN) * (TN + FP) * (TN + FN)) 
    924924        except ZeroDivisionError: 
    925925            # Zero division occurs when there is either no true positives 
     
    991991@deprecated_keywords({"classIndex": "class_index", 
    992992                      "unweighted": "ignore_weights"}) 
    993 def AUCWilcoxon(res, class_index=-1, ignore_weights=False, **argkw): 
     993def AUCWilcoxon(res, class_index= -1, ignore_weights=False, **argkw): 
    994994    """Compute the area under ROC (AUC) and its standard error using 
    995995    Wilcoxon's approach proposed by Hanley and McNeal (1982). If  
     
    10151015            highPos -= thisPos 
    10161016            W += thisNeg * (highPos + thisPos / 2.) 
    1017             Q2 += thisPos * (lowNeg**2  + lowNeg*thisNeg  + thisNeg**2 / 3.) 
    1018             Q1 += thisNeg * (highPos**2 + highPos*thisPos + thisPos**2 / 3.) 
     1017            Q2 += thisPos * (lowNeg ** 2 + lowNeg * thisNeg + thisNeg ** 2 / 3.) 
     1018            Q1 += thisNeg * (highPos ** 2 + highPos * thisPos + thisPos ** 2 / 3.) 
    10191019 
    10201020            lowNeg += thisNeg 
    10211021 
    1022         W  /= (totPos*totNeg) 
    1023         Q1 /= (totNeg*totPos**2) 
    1024         Q2 /= (totPos*totNeg**2) 
    1025  
    1026         SE = math.sqrt((W * (1 - W) + (totPos - 1) * (Q1 - W**2) + 
    1027                        (totNeg - 1) * (Q2 - W**2)) / (totPos * totNeg)) 
     1022        W /= (totPos * totNeg) 
     1023        Q1 /= (totNeg * totPos ** 2) 
     1024        Q2 /= (totPos * totNeg ** 2) 
     1025 
     1026        SE = math.sqrt((W * (1 - W) + (totPos - 1) * (Q1 - W ** 2) + 
     1027                       (totNeg - 1) * (Q2 - W ** 2)) / (totPos * totNeg)) 
    10281028        results.append((W, SE)) 
    10291029    return results 
     
    10341034@deprecated_keywords({"classIndex": "class_index", 
    10351035                      "unweighted": "ignore_weights"}) 
    1036 def compare_2_AUCs(res, lrn1, lrn2, class_index=-1, 
     1036def compare_2_AUCs(res, lrn1, lrn2, class_index= -1, 
    10371037                   ignore_weights=False, **argkw): 
    10381038    return corn.compare2ROCs(res, lrn1, lrn2, class_index, 
     
    10401040 
    10411041# for backward compatibility, compare_2_AROCs is obsolete 
    1042 compare_2_AROCs = compare_2_AUCs  
     1042compare_2_AROCs = compare_2_AUCs 
    10431043 
    10441044 
    10451045@deprecated_keywords({"classIndex": "class_index"}) 
    1046 def compute_ROC(res, class_index=-1): 
     1046def compute_ROC(res, class_index= -1): 
    10471047    """Compute a ROC curve as a list of (x, y) tuples, where x is  
    10481048    1-specificity and y is sensitivity. 
     
    10541054 
    10551055    for plist in problists: 
    1056         curve=[(1., 1.)] 
     1056        curve = [(1., 1.)] 
    10571057        TP, TN = totPos, 0. 
    10581058        FN, FP = 0., totNeg 
     
    10711071        results.append(curve) 
    10721072 
    1073     return results     
     1073    return results 
    10741074 
    10751075## TC's implementation of algorithms, taken from: 
     
    11031103@deprecated_keywords({"classIndex": "class_index", 
    11041104                      "keepConcavities": "keep_concavities"}) 
    1105 def TC_compute_ROC(res, class_index=-1, keep_concavities=1): 
     1105def TC_compute_ROC(res, class_index= -1, keep_concavities=1): 
    11061106    problists, tots = corn.computeROCCumulative(res, class_index) 
    11071107 
     
    11141114        TP = 0. 
    11151115        FP = 0. 
    1116         curve=[] 
     1116        curve = [] 
    11171117        fPrev = 10e300 # "infinity" score at 0., 0. 
    11181118        for prob in plist: 
     
    11701170        else: 
    11711171            if abs(d - mind) <= 0.0001: ## close enough 
    1172                 closestPoints.append( (x, y, fscore) ) 
    1173     return closestPoints           
     1172                closestPoints.append((x, y, fscore)) 
     1173    return closestPoints 
    11741174 
    11751175def frange(start, end=None, inc=None): 
     
    11931193            break 
    11941194        L.append(next) 
    1195          
     1195 
    11961196    return L 
    11971197 
     
    12031203## returns the average ROC curve and an array of (vertical) standard deviations 
    12041204@deprecated_keywords({"ROCcurves": "roc_curves"}) 
    1205 def TC_vertical_average_ROC(roc_curves, samples = 10): 
     1205def TC_vertical_average_ROC(roc_curves, samples=10): 
    12061206    def INTERPOLATE((P1x, P1y, P1fscore), (P2x, P2y, P2fscore), X): 
    12071207        if (P1x == P2x) or P1x < X > P2x or P1x > X < P2x: 
     
    13101310            else: 
    13111311                stdv = 0. 
    1312             TPstdV.append( stdv ) 
     1312            TPstdV.append(stdv) 
    13131313            ## horizontal standard deviation 
    13141314            if len(FPsum) > 1: 
     
    13161316            else: 
    13171317                stdh = 0. 
    1318             TPstdH.append( stdh ) 
     1318            TPstdH.append(stdh) 
    13191319 
    13201320        average.append(TPavg) 
     
    13311331##  - noClassRugPoints is an array of (x, 0) points 
    13321332@deprecated_keywords({"classIndex": "class_index"}) 
    1333 def compute_calibration_curve(res, class_index=-1): 
     1333def compute_calibration_curve(res, class_index= -1): 
    13341334    ## merge multiple iterations into one 
    13351335    mres = Orange.evaluation.testing.ExperimentResults(1, res.classifier_names, 
     
    13461346 
    13471347    for plist in problists: 
    1348         yesClassRugPoints = []  
     1348        yesClassRugPoints = [] 
    13491349        noClassRugPoints = [] 
    13501350 
     
    13551355            noClassRugPoints.append((f, thisNeg)) # 1. 
    13561356 
    1357             index = int(f * bins ) 
     1357            index = int(f * bins) 
    13581358            index = min(index, bins - 1) ## just in case for value 1. 
    13591359            yesBinsVals[index] += thisPos 
     
    13681368            if allVal == 0.: continue 
    13691369            y = float(yesVal) / float(allVal) 
    1370             curve.append((f,  y)) 
     1370            curve.append((f, y)) 
    13711371 
    13721372        ## smooth the curve 
     
    13971397##    on the Lift Curve 
    13981398@deprecated_keywords({"classIndex": "class_index"}) 
    1399 def compute_lift_curve(res, class_index=-1): 
     1399def compute_lift_curve(res, class_index= -1): 
    14001400    ## merge multiple iterations into one 
    14011401    mres = Orange.evaluation.testing.ExperimentResults(1, res.classifier_names, 
     
    14281428  def __init__(self, C=0., D=0., T=0.): 
    14291429    self.C, self.D, self.T = C, D, T 
    1430     
     1430 
    14311431def is_CDT_empty(cdt): 
    14321432    return cdt.C + cdt.D + cdt.T < 1e-20 
     
    14351435@deprecated_keywords({"classIndex": "class_index", 
    14361436                      "unweighted": "ignore_weights"}) 
    1437 def compute_CDT(res, class_index=-1, ignore_weights=False, **argkw): 
     1437def compute_CDT(res, class_index= -1, ignore_weights=False, **argkw): 
    14381438    """Obsolete, don't use.""" 
    14391439    if class_index < 0: 
    1440         if res.baseClass >= 0: 
    1441             class_index = res.baseClass 
     1440        if res.base_class >= 0: 
     1441            class_index = res.base_class 
    14421442        else: 
    14431443            class_index = 1 
    1444              
     1444 
    14451445    useweights = res.weights and not ignore_weights 
    14461446    weightByClasses = argkw.get("weightByClasses", True) 
    14471447 
    1448     if res.number_of_iterations>1: 
     1448    if res.number_of_iterations > 1: 
    14491449        CDTs = [CDT() for _ in range(res.number_of_learners)] 
    14501450        iterationExperiments = split_by_iterations(res) 
     
    14581458            if is_CDT_empty(CDTs[0]): 
    14591459                return corn.computeCDT(res, class_index, useweights) 
    1460          
     1460 
    14611461        return CDTs 
    14621462    else: 
     
    15261526        super(AUC, self).__init__() 
    15271527 
    1528         self.ignore_weights=ignore_weights 
    1529         self.method=multiclass 
     1528        self.ignore_weights = ignore_weights 
     1529        self.method = multiclass 
    15301530 
    15311531        if test_results is not None: 
     
    16001600 
    16011601        if usefulClassPairs > 0: 
    1602             sum_aucs = [x/usefulClassPairs for x in sum_aucs] 
     1602            sum_aucs = [x / usefulClassPairs for x in sum_aucs] 
    16031603 
    16041604        return sum_aucs 
     
    16141614        subsum_aucs = [0.] * iterations[0].number_of_learners 
    16151615        for ite in iterations: 
    1616             aucs, foldsUsed = auc_computer(*(ite, ) + computer_args) 
     1616            aucs, foldsUsed = auc_computer(*(ite,) + computer_args) 
    16171617            if not aucs: 
    16181618                import warnings 
     
    16861686        Compute AUC using a :obj:`cdt_computer`. 
    16871687        """ 
    1688         cdts = cdt_computer(*(ite, ) + computer_args) 
     1688        cdts = cdt_computer(*(ite,) + computer_args) 
    16891689        if not is_CDT_empty(cdts[0]): 
    16901690            return [(cdt.C + cdt.T / 2) / (cdt.C + cdt.D + cdt.T) / 
     
    16921692 
    16931693        if all_ite: 
    1694             cdts = cdt_computer(*(all_ite, ) + computer_args) 
     1694            cdts = cdt_computer(*(all_ite,) + computer_args) 
    16951695            if not is_CDT_empty(cdts[0]): 
    16961696                return [(cdt.C + cdt.T / 2) / (cdt.C + cdt.D + cdt.T) 
     
    17041704    out and all other classes are treated as a single class. 
    17051705    """ 
    1706     def __init__(self, test_results=None, class_index=-1, ignore_weights=False): 
     1706    def __init__(self, test_results=None, class_index= -1, ignore_weights=False): 
    17071707        if class_index < 0: 
    17081708            if test_results and test_results.base_class >= 0: 
     
    18581858            su = mcm[l1][l2] + mcm[l2][l1] 
    18591859            if su: 
    1860                 mcm[l2][l1] = (abs(mcm[l1][l2] - mcm[l2][l1]) - 1)**2 / su 
     1860                mcm[l2][l1] = (abs(mcm[l1][l2] - mcm[l2][l1]) - 1) ** 2 / su 
    18611861            else: 
    18621862                mcm[l2][l1] = 0 
    18631863 
    18641864    for l1 in range(nLearners): 
    1865         mcm[l1]=mcm[l1][:l1] 
     1865        mcm[l1] = mcm[l1][:l1] 
    18661866 
    18671867    return mcm 
     
    18931893    su = tf + ft 
    18941894    if su: 
    1895         return (abs(tf - ft) - 1)**2 / su 
     1895        return (abs(tf - ft) - 1) ** 2 / su 
    18961896    else: 
    18971897        return 0 
     
    19051905    res_split = split_by_iterations(res) 
    19061906    res = [stat(r) for r in res_split] 
    1907      
     1907 
    19081908    N = len(res) 
    19091909    k = len(res[0]) 
     
    19181918    sums = [x / N for x in sums] 
    19191919 
    1920     F = 12. / (N * k * (k + 1)) * T  - 3 * N * (k + 1) 
     1920    F = 12. / (N * k * (k + 1)) * T - 3 * N * (k + 1) 
    19211921 
    19221922    return F, statc.chisqprob(F, k - 1), sums 
     
    19411941        for m2 in range(m1 + 1, k): 
    19421942            t, p = statc.wilcoxont([r[m1] for r in res], [r[m2] for r in res]) 
    1943             if avgranks[m1]<avgranks[m2]: 
     1943            if avgranks[m1] < avgranks[m2]: 
    19441944                nl.append(p) 
    1945             elif avgranks[m2]<avgranks[m1]: 
     1945            elif avgranks[m2] < avgranks[m1]: 
    19461946                nl.append(-p) 
    19471947            else: 
     
    19691969        file = open(file, "wt") 
    19701970        fopened = 1 
    1971          
     1971 
    19721972    file.write("set yrange [0:1]\n") 
    19731973    file.write("set xrange [%f:%f]\n" % (proportions[0], proportions[-1])) 
     
    19781978    for i in range(len(legend) - 1): 
    19791979        if not no_confidence: 
    1980             file.write("'-' title '' with yerrorbars pointtype %i,\\\n" % (i+1)) 
    1981         file.write("'-' title '%s' with linespoints pointtype %i,\\\n" % (legend[i], i+1)) 
     1980            file.write("'-' title '' with yerrorbars pointtype %i,\\\n" % (i + 1)) 
     1981        file.write("'-' title '%s' with linespoints pointtype %i,\\\n" % (legend[i], i + 1)) 
    19821982    if not no_confidence: 
    19831983        file.write("'-' title '' with yerrorbars pointtype %i,\\\n" % (len(legend))) 
     
    19871987        if not no_confidence: 
    19881988            for p in range(len(proportions)): 
    1989                 file.write("%f\t%f\t%f\n" % (proportions[p], CAs[p][i][0], 1.96*CAs[p][i][1])) 
     1989                file.write("%f\t%f\t%f\n" % (proportions[p], CAs[p][i][0], 1.96 * CAs[p][i][1])) 
    19901990            file.write("e\n\n") 
    19911991 
     
    20002000def print_single_ROC_curve_coordinates(file, curve): 
    20012001    import types 
    2002     fopened=0 
    2003     if type(file)==types.StringType: 
    2004         file=open(file, "wt") 
    2005         fopened=1 
     2002    fopened = 0 
     2003    if type(file) == types.StringType: 
     2004        file = open(file, "wt") 
     2005        fopened = 1 
    20062006 
    20072007    for coord in curve: 
     
    20142014def plot_ROC_learners(file, curves, learners): 
    20152015    plot_ROC(file, curves, [Orange.misc.getobjectname(learners[i], "Learner %i" % i) for i in range(len(learners))]) 
    2016      
     2016 
    20172017def plot_ROC(file, curves, legend): 
    20182018    import types 
    2019     fopened=0 
    2020     if type(file)==types.StringType: 
    2021         file=open(file, "wt") 
    2022         fopened=1 
     2019    fopened = 0 
     2020    if type(file) == types.StringType: 
     2021        file = open(file, "wt") 
     2022        fopened = 1 
    20232023 
    20242024    file.write("set yrange [0:1]\n") 
     
    20362036        file.write("e\n\n") 
    20372037 
    2038     file.write("1.0\t1.0\n0.0\t0.0e\n\n")           
     2038    file.write("1.0\t1.0\n0.0\t0.0e\n\n") 
    20392039 
    20402040    if fopened: 
     
    20432043 
    20442044@deprecated_keywords({"allResults": "all_results"}) 
    2045 def plot_McNemar_curve_learners(file, all_results, proportions, learners, reference=-1): 
     2045def plot_McNemar_curve_learners(file, all_results, proportions, learners, reference= -1): 
    20462046    plot_McNemar_curve(file, all_results, proportions, [Orange.misc.getobjectname(learners[i], "Learner %i" % i) for i in range(len(learners))], reference) 
    20472047 
    20482048 
    20492049@deprecated_keywords({"allResults": "all_results"}) 
    2050 def plot_McNemar_curve(file, all_results, proportions, legend, reference=-1): 
    2051     if reference<0: 
    2052         reference=len(legend)-1 
    2053          
     2050def plot_McNemar_curve(file, all_results, proportions, legend, reference= -1): 
     2051    if reference < 0: 
     2052        reference = len(legend) - 1 
     2053 
    20542054    import types 
    2055     fopened=0 
    2056     if type(file)==types.StringType: 
    2057         file=open(file, "wt") 
    2058         fopened=1 
    2059          
     2055    fopened = 0 
     2056    if type(file) == types.StringType: 
     2057        file = open(file, "wt") 
     2058        fopened = 1 
     2059 
    20602060    #file.write("set yrange [0:1]\n") 
    20612061    #file.write("set xrange [%f:%f]\n" % (proportions[0], proportions[-1])) 
    20622062    file.write("set multiplot\n\n") 
    20632063    file.write("plot \\\n") 
    2064     tmap=range(reference)+range(reference+1, len(legend)) 
     2064    tmap = range(reference) + range(reference + 1, len(legend)) 
    20652065    for i in tmap[:-1]: 
    2066         file.write("'-' title '%s' with linespoints pointtype %i,\\\n" % (legend[i], i+1)) 
     2066        file.write("'-' title '%s' with linespoints pointtype %i,\\\n" % (legend[i], i + 1)) 
    20672067    file.write("'-' title '%s' with linespoints pointtype %i\n" % (legend[tmap[-1]], tmap[-1])) 
    20682068    file.write("\n") 
     
    20762076        file.close() 
    20772077 
    2078 default_point_types=("{$\\circ$}", "{$\\diamond$}", "{$+$}", "{$\\times$}", "{$|$}")+tuple([chr(x) for x in range(97, 122)]) 
    2079 default_line_types=("\\setsolid", "\\setdashpattern <4pt, 2pt>", "\\setdashpattern <8pt, 2pt>", "\\setdashes", "\\setdots") 
     2078default_point_types = ("{$\\circ$}", "{$\\diamond$}", "{$+$}", "{$\\times$}", "{$|$}") + tuple([chr(x) for x in range(97, 122)]) 
     2079default_line_types = ("\\setsolid", "\\setdashpattern <4pt, 2pt>", "\\setdashpattern <8pt, 2pt>", "\\setdashes", "\\setdots") 
    20802080 
    20812081@deprecated_keywords({"allResults": "all_results"}) 
     
    20872087def learning_curve_to_PiCTeX(file, all_results, proportions, **options): 
    20882088    import types 
    2089     fopened=0 
    2090     if type(file)==types.StringType: 
    2091         file=open(file, "wt") 
    2092         fopened=1 
    2093  
    2094     nexamples=len(all_results[0].results) 
     2089    fopened = 0 
     2090    if type(file) == types.StringType: 
     2091        file = open(file, "wt") 
     2092        fopened = 1 
     2093 
     2094    nexamples = len(all_results[0].results) 
    20952095    CAs = [CA(x, report_se=True) for x in all_results] 
    20962096 
    2097     graphsize=float(options.get("graphsize", 10.0)) #cm 
    2098     difprop=proportions[-1]-proportions[0] 
    2099     ntestexamples=nexamples*proportions[-1] 
    2100     xunit=graphsize/ntestexamples 
    2101  
    2102     yshift=float(options.get("yshift", -ntestexamples/20.)) 
    2103      
    2104     pointtypes=options.get("pointtypes", default_point_types) 
    2105     linetypes=options.get("linetypes", default_line_types) 
     2097    graphsize = float(options.get("graphsize", 10.0)) #cm 
     2098    difprop = proportions[-1] - proportions[0] 
     2099    ntestexamples = nexamples * proportions[-1] 
     2100    xunit = graphsize / ntestexamples 
     2101 
     2102    yshift = float(options.get("yshift", -ntestexamples / 20.)) 
     2103 
     2104    pointtypes = options.get("pointtypes", default_point_types) 
     2105    linetypes = options.get("linetypes", default_line_types) 
    21062106 
    21072107    if options.has_key("numberedx"): 
    2108         numberedx=options["numberedx"] 
    2109         if type(numberedx)==types.IntType: 
    2110             if numberedx>0: 
    2111                 numberedx=[nexamples*proportions[int(i/float(numberedx)*len(proportions))] for i in range(numberedx)]+[proportions[-1]*nexamples] 
    2112             elif numberedx<0: 
     2108        numberedx = options["numberedx"] 
     2109        if type(numberedx) == types.IntType: 
     2110            if numberedx > 0: 
     2111                numberedx = [nexamples * proportions[int(i / float(numberedx) * len(proportions))] for i in range(numberedx)] + [proportions[-1] * nexamples] 
     2112            elif numberedx < 0: 
    21132113                numberedx = -numberedx 
    2114                 newn=[] 
    2115                 for i in range(numberedx+1): 
    2116                     wanted=proportions[0]+float(i)/numberedx*difprop 
    2117                     best=(10, 0) 
     2114                newn = [] 
     2115                for i in range(numberedx + 1): 
     2116                    wanted = proportions[0] + float(i) / numberedx * difprop 
     2117                    best = (10, 0) 
    21182118                    for t in proportions: 
    2119                         td=abs(wanted-t) 
    2120                         if td<best[0]: 
    2121                             best=(td, t) 
     2119                        td = abs(wanted - t) 
     2120                        if td < best[0]: 
     2121                            best = (td, t) 
    21222122                    if not best[1] in newn: 
    21232123                        newn.append(best[1]) 
    21242124                newn.sort() 
    2125                 numberedx=[nexamples*x for x in newn] 
    2126         elif type(numberedx[0])==types.FloatType: 
    2127             numberedx=[nexamples*x for x in numberedx] 
     2125                numberedx = [nexamples * x for x in newn] 
     2126        elif type(numberedx[0]) == types.FloatType: 
     2127            numberedx = [nexamples * x for x in numberedx] 
    21282128    else: 
    2129         numberedx=[nexamples*x for x in proportions] 
     2129        numberedx = [nexamples * x for x in proportions] 
    21302130 
    21312131    file.write("\\mbox{\n") 
    21322132    file.write("  \\beginpicture\n") 
    2133     file.write("  \\setcoordinatesystem units <%10.8fcm, %5.3fcm>\n\n" % (xunit, graphsize))     
    2134     file.write("  \\setplotarea x from %5.3f to %5.3f, y from 0 to 1\n" % (0, ntestexamples))     
     2133    file.write("  \\setcoordinatesystem units <%10.8fcm, %5.3fcm>\n\n" % (xunit, graphsize)) 
     2134    file.write("  \\setplotarea x from %5.3f to %5.3f, y from 0 to 1\n" % (0, ntestexamples)) 
    21352135    file.write("  \\axis bottom invisible\n")# label {#examples}\n") 
    2136     file.write("      ticks short at %s /\n" % reduce(lambda x,y:x+" "+y, ["%i"%(x*nexamples+0.5) for x in proportions])) 
     2136    file.write("      ticks short at %s /\n" % reduce(lambda x, y:x + " " + y, ["%i" % (x * nexamples + 0.5) for x in proportions])) 
    21372137    if numberedx: 
    2138         file.write("            long numbered at %s /\n" % reduce(lambda x,y:x+y, ["%i " % int(x+0.5) for x in numberedx])) 
     2138        file.write("            long numbered at %s /\n" % reduce(lambda x, y:x + y, ["%i " % int(x + 0.5) for x in numberedx])) 
    21392139    file.write("  /\n") 
    21402140    file.write("  \\axis left invisible\n")# label {classification accuracy}\n") 
     
    21462146        file.write("  \\setdashpattern<1pt, 1pt>\n") 
    21472147        file.write("  \\plot %5.3f %5.3f %5.3f %5.3f /\n" % (0., options["default"], ntestexamples, options["default"])) 
    2148      
     2148 
    21492149    for i in range(len(CAs[0])): 
    2150         coordinates=reduce(lambda x,y:x+" "+y, ["%i %5.3f" % (proportions[p]*nexamples, CAs[p][i][0]) for p in range(len(proportions))]) 
     2150        coordinates = reduce(lambda x, y:x + " " + y, ["%i %5.3f" % (proportions[p] * nexamples, CAs[p][i][0]) for p in range(len(proportions))]) 
    21512151        if linetypes: 
    21522152            file.write("  %s\n" % linetypes[i]) 
     
    21642164def legend_learners_to_PiCTeX(file, learners, **options): 
    21652165  return apply(legend_to_PiCTeX, (file, [Orange.misc.getobjectname(learners[i], "Learner %i" % i) for i in range(len(learners))]), options) 
    2166      
     2166 
    21672167def legend_to_PiCTeX(file, legend, **options): 
    21682168    import types 
    2169     fopened=0 
    2170     if type(file)==types.StringType: 
    2171         file=open(file, "wt") 
    2172         fopened=1 
    2173  
    2174     pointtypes=options.get("pointtypes", default_point_types) 
    2175     linetypes=options.get("linetypes", default_line_types) 
     2169    fopened = 0 
     2170    if type(file) == types.StringType: 
     2171        file = open(file, "wt") 
     2172        fopened = 1 
     2173 
     2174    pointtypes = options.get("pointtypes", default_point_types) 
     2175    linetypes = options.get("linetypes", default_line_types) 
    21762176 
    21772177    file.write("\\mbox{\n") 
     
    21832183        if linetypes: 
    21842184            file.write("  %s\n" % linetypes[i]) 
    2185             file.write("  \\plot %5.3f 6 %5.3f 6 /\n" % (i, i+0.2)) 
     2185            file.write("  \\plot %5.3f 6 %5.3f 6 /\n" % (i, i + 0.2)) 
    21862186        if pointtypes: 
    2187             file.write("  \\put {%s} at %5.3f 6\n" % (pointtypes[i], i+0.1)) 
    2188         file.write("  \\put {%s} [lb] at %5.3f 0\n" % (legend[i], i+0.25)) 
     2187            file.write("  \\put {%s} at %5.3f 6\n" % (pointtypes[i], i + 0.1)) 
     2188        file.write("  \\put {%s} [lb] at %5.3f 0\n" % (legend[i], i + 0.25)) 
    21892189 
    21902190    file.write("  \\endpicture\n") 
     
    22052205 
    22062206    def friedman(N, k, ranks): 
    2207         return 12*N*(sum([rank**2.0 for rank in ranks]) - (k*(k+1)*(k+1)/4.0) )/(k*(k+1)) 
     2207        return 12 * N * (sum([rank ** 2.0 for rank in ranks]) - (k * (k + 1) * (k + 1) / 4.0)) / (k * (k + 1)) 
    22082208 
    22092209    def iman(fried, N, k): 
    2210         return (N-1)*fried/(N*(k-1) - fried) 
     2210        return (N - 1) * fried / (N * (k - 1) - fried) 
    22112211 
    22122212    f = friedman(N, k, avranks) 
    22132213    im = iman(f, N, k) 
    2214     fdistdof = (k-1, (k-1)*(N-1)) 
    2215  
    2216     return (f, k-1), (im, fdistdof) 
     2214    fdistdof = (k - 1, (k - 1) * (N - 1)) 
     2215 
     2216    return (f, k - 1), (im, fdistdof) 
    22172217 
    22182218def compute_CD(avranks, N, alpha="0.05", type="nemenyi"): 
     
    22242224 
    22252225    k = len(avranks) 
    2226     
     2226 
    22272227    d = {("nemenyi", "0.05"): [0, 0, 1.959964, 2.343701, 2.569032, 2.727774, 
    22282228                               2.849705, 2.94832, 3.030879, 3.101730, 3.163684, 
     
    22432243    q = d[(type, alpha)] 
    22442244 
    2245     cd = q[k]*(k*(k+1)/(6.0*N))**0.5 
     2245    cd = q[k] * (k * (k + 1) / (6.0 * N)) ** 0.5 
    22462246 
    22472247    return cd 
    2248   
     2248 
    22492249 
    22502250def graph_ranks(filename, avranks, names, cd=None, cdmethod=None, lowv=None, highv=None, width=6, textspace=1, reverse=False, **kwargs): 
     
    22822282    textspace = float(textspace) 
    22832283 
    2284     def nth(l,n): 
     2284    def nth(l, n): 
    22852285        """ 
    22862286        Returns only nth elemnt in a list. 
    22872287        """ 
    2288         n = lloc(l,n) 
     2288        n = lloc(l, n) 
    22892289        return [ a[n] for a in l ] 
    22902290 
    2291     def lloc(l,n): 
     2291    def lloc(l, n): 
    22922292        """ 
    22932293        List location in list of list structure. 
     
    22962296        """ 
    22972297        if n < 0: 
    2298             return len(l[0])+n 
    2299         else: 
    2300             return n  
     2298            return len(l[0]) + n 
     2299        else: 
     2300            return n 
    23012301 
    23022302    def mxrange(lr): 
     
    23342334    sums = avranks 
    23352335 
    2336     tempsort =  sorted([ (a,i) for i,a in  enumerate(sums) ], reverse=reverse) 
     2336    tempsort = sorted([ (a, i) for i, a in  enumerate(sums) ], reverse=reverse) 
    23372337    ssums = nth(tempsort, 0) 
    23382338    sortidx = nth(tempsort, 1) 
    23392339    nnames = [ names[x] for x in sortidx ] 
    2340      
     2340 
    23412341    if lowv is None: 
    23422342        lowv = min(1, int(math.floor(min(ssums)))) 
     
    23512351 
    23522352    linesblank = 0 
    2353     scalewidth = width - 2*textspace 
     2353    scalewidth = width - 2 * textspace 
    23542354 
    23552355    def rankpos(rank): 
     
    23582358        else: 
    23592359            a = highv - rank 
    2360         return textspace+scalewidth/(highv-lowv)*a 
     2360        return textspace + scalewidth / (highv - lowv) * a 
    23612361 
    23622362    distanceh = 0.25 
    23632363 
    23642364    if cd and cdmethod is None: 
    2365      
     2365 
    23662366        #get pairs of non significant methods 
    23672367 
     
    23702370            #get all pairs 
    23712371            lsums = len(sums) 
    2372             allpairs = [ (i,j) for i,j in mxrange([[lsums], [lsums]]) if j > i ] 
     2372            allpairs = [ (i, j) for i, j in mxrange([[lsums], [lsums]]) if j > i ] 
    23732373            #remove not significant 
    2374             notSig = [ (i,j) for i,j in allpairs if abs(sums[i]-sums[j]) <= hsd ] 
     2374            notSig = [ (i, j) for i, j in allpairs if abs(sums[i] - sums[j]) <= hsd ] 
    23752375            #keep only longest 
    2376              
    2377             def no_longer((i,j), notSig): 
    2378                 for i1,j1 in notSig: 
     2376 
     2377            def no_longer((i, j), notSig): 
     2378                for i1, j1 in notSig: 
    23792379                    if (i1 <= i and j1 > j) or (i1 < i and j1 >= j): 
    23802380                        return False 
    23812381                return True 
    23822382 
    2383             longest = [ (i,j) for i,j in notSig if no_longer((i,j),notSig) ] 
    2384              
     2383            longest = [ (i, j) for i, j in notSig if no_longer((i, j), notSig) ] 
     2384 
    23852385            return longest 
    23862386 
    23872387        lines = get_lines(ssums, cd) 
    2388         linesblank = 0.2 + 0.2 + (len(lines)-1)*0.1 
     2388        linesblank = 0.2 + 0.2 + (len(lines) - 1) * 0.1 
    23892389 
    23902390        #add scale 
     
    23932393 
    23942394    #calculate height needed height of an image 
    2395     minnotsignificant = max(2*0.2, linesblank) 
    2396     height = cline + ((k+1)/2)*0.2 + minnotsignificant 
     2395    minnotsignificant = max(2 * 0.2, linesblank) 
     2396    height = cline + ((k + 1) / 2) * 0.2 + minnotsignificant 
    23972397 
    23982398    fig = Figure(figsize=(width, height)) 
    2399     ax = fig.add_axes([0,0,1,1]) #reverse y axis 
     2399    ax = fig.add_axes([0, 0, 1, 1]) #reverse y axis 
    24002400    ax.set_axis_off() 
    24012401 
    2402     hf = 1./height # height factor 
    2403     wf = 1./width 
    2404  
    2405     def hfl(l):  
    2406         return [ a*hf for a in l ] 
    2407  
    2408     def wfl(l):  
    2409         return [ a*wf for a in l ] 
     2402    hf = 1. / height # height factor 
     2403    wf = 1. / width 
     2404 
     2405    def hfl(l): 
     2406        return [ a * hf for a in l ] 
     2407 
     2408    def wfl(l): 
     2409        return [ a * wf for a in l ] 
    24102410 
    24112411 
    24122412    # Upper left corner is (0,0). 
    24132413 
    2414     ax.plot([0,1], [0,1], c="w") 
     2414    ax.plot([0, 1], [0, 1], c="w") 
    24152415    ax.set_xlim(0, 1) 
    24162416    ax.set_ylim(1, 0) 
     
    24202420        Input is a list of pairs of points. 
    24212421        """ 
    2422         ax.plot(wfl(nth(l,0)), hfl(nth(l,1)), color=color, **kwargs) 
     2422        ax.plot(wfl(nth(l, 0)), hfl(nth(l, 1)), color=color, **kwargs) 
    24232423 
    24242424    def text(x, y, s, *args, **kwargs): 
    2425         ax.text(wf*x, hf*y, s, *args, **kwargs) 
    2426  
    2427     line([(textspace, cline), (width-textspace, cline)], linewidth=0.7) 
    2428      
     2425        ax.text(wf * x, hf * y, s, *args, **kwargs) 
     2426 
     2427    line([(textspace, cline), (width - textspace, cline)], linewidth=0.7) 
     2428 
    24292429    bigtick = 0.1 
    24302430    smalltick = 0.05 
     
    24362436        tick = smalltick 
    24372437        if a == int(a): tick = bigtick 
    2438         line([(rankpos(a), cline-tick/2),(rankpos(a), cline)], linewidth=0.7) 
    2439  
    2440     for a in range(lowv, highv+1): 
    2441         text(rankpos(a), cline-tick/2-0.05, str(a), ha="center", va="bottom") 
     2438        line([(rankpos(a), cline - tick / 2), (rankpos(a), cline)], linewidth=0.7) 
     2439 
     2440    for a in range(lowv, highv + 1): 
     2441        text(rankpos(a), cline - tick / 2 - 0.05, str(a), ha="center", va="bottom") 
    24422442 
    24432443    k = len(ssums) 
    24442444 
    2445     for i in range((k+1)/2): 
    2446         chei = cline+ minnotsignificant + i *0.2 
    2447         line([(rankpos(ssums[i]), cline), (rankpos(ssums[i]), chei), (textspace-0.1, chei)], linewidth=0.7) 
    2448         text(textspace-0.2, chei, nnames[i], ha="right", va="center") 
    2449  
    2450     for i in range((k+1)/2, k): 
    2451         chei = cline + minnotsignificant + (k-i-1)*0.2 
    2452         line([(rankpos(ssums[i]), cline), (rankpos(ssums[i]), chei), (textspace+scalewidth+0.1, chei)], linewidth=0.7) 
    2453         text(textspace+scalewidth+0.2, chei, nnames[i], ha="left", va="center") 
     2445    for i in range((k + 1) / 2): 
     2446        chei = cline + minnotsignificant + i * 0.2 
     2447        line([(rankpos(ssums[i]), cline), (rankpos(ssums[i]), chei), (textspace - 0.1, chei)], linewidth=0.7) 
     2448        text(textspace - 0.2, chei, nnames[i], ha="right", va="center") 
     2449 
     2450    for i in range((k + 1) / 2, k): 
     2451        chei = cline + minnotsignificant + (k - i - 1) * 0.2 
     2452        line([(rankpos(ssums[i]), cline), (rankpos(ssums[i]), chei), (textspace + scalewidth + 0.1, chei)], linewidth=0.7) 
     2453        text(textspace + scalewidth + 0.2, chei, nnames[i], ha="left", va="center") 
    24542454 
    24552455    if cd and cdmethod is None: 
     
    24572457        #upper scale 
    24582458        if not reverse: 
    2459             begin, end = rankpos(lowv), rankpos(lowv+cd) 
     2459            begin, end = rankpos(lowv), rankpos(lowv + cd) 
    24602460        else: 
    24612461            begin, end = rankpos(highv), rankpos(highv - cd) 
    2462              
     2462 
    24632463        line([(begin, distanceh), (end, distanceh)], linewidth=0.7) 
    2464         line([(begin, distanceh + bigtick/2), (begin, distanceh - bigtick/2)], linewidth=0.7) 
    2465         line([(end, distanceh + bigtick/2), (end, distanceh - bigtick/2)], linewidth=0.7) 
    2466         text((begin+end)/2, distanceh - 0.05, "CD", ha="center", va="bottom") 
     2464        line([(begin, distanceh + bigtick / 2), (begin, distanceh - bigtick / 2)], linewidth=0.7) 
     2465        line([(end, distanceh + bigtick / 2), (end, distanceh - bigtick / 2)], linewidth=0.7) 
     2466        text((begin + end) / 2, distanceh - 0.05, "CD", ha="center", va="bottom") 
    24672467 
    24682468        #non significance lines     
    24692469        def draw_lines(lines, side=0.05, height=0.1): 
    24702470            start = cline + 0.2 
    2471             for l,r in lines:   
    2472                 line([(rankpos(ssums[l])-side, start), (rankpos(ssums[r])+side, start)], linewidth=2.5)  
     2471            for l, r in lines: 
     2472                line([(rankpos(ssums[l]) - side, start), (rankpos(ssums[r]) + side, start)], linewidth=2.5) 
    24732473                start += height 
    24742474 
     
    24762476 
    24772477    elif cd: 
    2478         begin = rankpos(avranks[cdmethod]-cd) 
    2479         end = rankpos(avranks[cdmethod]+cd) 
    2480         line([(begin, cline), (end, cline)], linewidth=2.5)  
    2481         line([(begin, cline + bigtick/2), (begin, cline - bigtick/2)], linewidth=2.5) 
    2482         line([(end, cline + bigtick/2), (end, cline - bigtick/2)], linewidth=2.5) 
    2483   
     2478        begin = rankpos(avranks[cdmethod] - cd) 
     2479        end = rankpos(avranks[cdmethod] + cd) 
     2480        line([(begin, cline), (end, cline)], linewidth=2.5) 
     2481        line([(begin, cline + bigtick / 2), (begin, cline - bigtick / 2)], linewidth=2.5) 
     2482        line([(end, cline + bigtick / 2), (end, cline - bigtick / 2)], linewidth=2.5) 
     2483 
    24842484    print_figure(fig, filename, **kwargs) 
    24852485 
     
    24902490    :math:`HammingLoss(H,D)=\\frac{1}{|D|} \\sum_{i=1}^{|D|} \\frac{Y_i \\vartriangle Z_i}{|L|}` 
    24912491    """ 
    2492     losses = [0]*res.number_of_learners 
     2492    losses = [0] * res.number_of_learners 
    24932493    label_num = len(res.labels) 
    24942494    example_num = gettotsize(res) 
     
    25032503                if labels[j] != aclass[j]: 
    25042504                    losses[i] += 1 
    2505              
    2506     return [float(x)/(label_num*example_num) for x in losses] 
    2507  
    2508 def mlc_accuracy(res, forgiveness_rate = 1.0): 
     2505 
     2506    return [float(x) / (label_num * example_num) for x in losses] 
     2507 
     2508def mlc_accuracy(res, forgiveness_rate=1.0): 
    25092509    """ 
    25102510    Godbole & Sarawagi, 2004 uses the metrics accuracy, precision, recall as follows: 
     
    25172517    :math:`Accuracy(H,D)=\\frac{1}{|D|} \\sum_{i=1}^{|D|} (\\frac{|Y_i \\cap Z_i|}{|Y_i \\cup Z_i|})^{\\alpha}` 
    25182518    """ 
    2519     accuracies = [0.0]*res.number_of_learners 
     2519    accuracies = [0.0] * res.number_of_learners 
    25202520    example_num = gettotsize(res) 
    2521      
     2521 
    25222522    for e in res.results: 
    25232523        aclass = e.actual_class 
     
    25262526            if len(labels) <> len(aclass): 
    25272527                raise ValueError, "The dimensions of the classified output and the actual class array do not match." 
    2528              
     2528 
    25292529            intersection = 0.0 
    25302530            union = 0.0 
     
    25372537            if union: 
    25382538                accuracies[i] += intersection / union 
    2539              
    2540     return [math.pow(x/example_num,forgiveness_rate) for x in accuracies] 
     2539 
     2540    return [math.pow(x / example_num, forgiveness_rate) for x in accuracies] 
    25412541 
    25422542def mlc_precision(res): 
     
    25442544    :math:`Precision(H,D)=\\frac{1}{|D|} \\sum_{i=1}^{|D|} \\frac{|Y_i \\cap Z_i|}{|Z_i|}` 
    25452545    """ 
    2546     precisions = [0.0]*res.number_of_learners 
     2546    precisions = [0.0] * res.number_of_learners 
    25472547    example_num = gettotsize(res) 
    2548      
     2548 
    25492549    for e in res.results: 
    25502550        aclass = e.actual_class 
     
    25532553            if len(labels) <> len(aclass): 
    25542554                raise ValueError, "The dimensions of the classified output and the actual class array do not match." 
    2555              
     2555 
    25562556            intersection = 0.0 
    25572557            predicted = 0.0 
     
    25632563            if predicted: 
    25642564                precisions[i] += intersection / predicted 
    2565              
    2566     return [x/example_num for x in precisions] 
     2565 
     2566    return [x / example_num for x in precisions] 
    25672567 
    25682568def mlc_recall(res): 
     
    25702570    :math:`Recall(H,D)=\\frac{1}{|D|} \\sum_{i=1}^{|D|} \\frac{|Y_i \\cap Z_i|}{|Y_i|}` 
    25712571    """ 
    2572     recalls = [0.0]*res.number_of_learners 
     2572    recalls = [0.0] * res.number_of_learners 
    25732573    example_num = gettotsize(res) 
    2574      
     2574 
    25752575    for e in res.results: 
    25762576        aclass = e.actual_class 
     
    25792579            if len(labels) <> len(aclass): 
    25802580                raise ValueError, "The dimensions of the classified output and the actual class array do not match." 
    2581              
     2581 
    25822582            intersection = 0.0 
    25832583            actual = 0.0 
     
    25892589            if actual: 
    25902590                recalls[i] += intersection / actual 
    2591              
    2592     return [x/example_num for x in recalls] 
     2591 
     2592    return [x / example_num for x in recalls] 
    25932593 
    25942594#def mlc_ranking_loss(res): 
     
    26712671################################################################################ 
    26722672if __name__ == "__main__": 
    2673     avranks =  [3.143, 2.000, 2.893, 1.964] 
     2673    avranks = [3.143, 2.000, 2.893, 1.964] 
    26742674    names = ["prva", "druga", "tretja", "cetrta" ] 
    26752675    cd = compute_CD(avranks, 14) 
Note: See TracChangeset for help on using the changeset viewer.