Changeset 9504:c386e6edfaaf in orange


Ignore:
Timestamp:
12/29/11 18:13:10 (2 years ago)
Author:
matija <matija.polajnar@…>
Branch:
default
Convert:
10ac9f8989ee0cf8cb5f8142f6433148ce6750b8
Message:

Adapt testing and scoring to MLC, fix mlc-evaluator regression test, some more refactoring (to lower_case) in testing.py.

Location:
orange
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • orange/Orange/evaluation/scoring.py

    r9502 r9504  
    26022602    :math:`HammingLoss(H,D)=\\frac{1}{|D|} \\sum_{i=1}^{|D|} \\frac{Y_i \\vartriangle Z_i}{|L|}` 
    26032603    """ 
    2604     losses = [0.0]*res.number_of_learners 
    2605     label_num = len(res.class_values) 
     2604    losses = [0]*res.number_of_learners 
     2605    label_num = len(res.labels) 
    26062606    example_num = gettotsize(res) 
    26072607     
    26082608    for e in res.results: 
    26092609        aclass = e.actual_class 
    2610         for i in range(len(e.classes)): 
    2611             labels = e.classes[i] 
    2612             #print labels,aclass 
     2610        for i, labels in enumerate(e.classes): 
     2611            labels = map(int, labels) 
    26132612            if len(labels) <> len(aclass): 
    26142613                raise ValueError, "The dimensions of the classified output and the actual class array do not match." 
    26152614            for j in range(label_num): 
    2616                 if labels[j] <> aclass[j]: 
    2617                     losses[i] = losses[i]+1 
     2615                if labels[j] != aclass[j]: 
     2616                    losses[i] += 1 
    26182617             
    2619     return [x/label_num/example_num for x in losses] 
     2618    return [float(x)/(label_num*example_num) for x in losses] 
    26202619 
    26212620def mlc_accuracy(res, forgiveness_rate = 1.0): 
     
    26312630    """ 
    26322631    accuracies = [0.0]*res.number_of_learners 
    2633     label_num = len(res.class_values) 
     2632    label_num = len(res.labels) 
    26342633    example_num = gettotsize(res) 
    26352634     
    26362635    for e in res.results: 
    26372636        aclass = e.actual_class 
    2638         for i in range(len(e.classes)): 
    2639             labels = e.classes[i]  
     2637        for i, labels in enumerate(e.classes): 
     2638            labels = map(int, labels) 
    26402639            if len(labels) <> len(aclass): 
    26412640                raise ValueError, "The dimensions of the classified output and the actual class array do not match." 
     
    26432642            intersection = 0.0 
    26442643            union = 0.0 
    2645             for j in range(label_num): 
    2646                 if labels[j]=='1' and aclass[j]=='1': 
     2644            for real, pred in zip(labels, aclass): 
     2645                if real and pred: 
    26472646                    intersection = intersection+1 
    2648                 if labels[j]=='1' or aclass[j]=='1': 
     2647                if real or pred: 
    26492648                    union = union+1 
    2650             #print intersection, union 
    2651             if union <> 0: 
     2649 
     2650            if union != 0: 
    26522651                accuracies[i] = accuracies[i] + intersection/union 
    26532652             
     
    26592658    """ 
    26602659    precisions = [0.0]*res.number_of_learners 
    2661     label_num = len(res.class_values) 
     2660    label_num = len(res.labels) 
    26622661    example_num = gettotsize(res) 
    26632662     
    26642663    for e in res.results: 
    26652664        aclass = e.actual_class 
    2666         for i in range(len(e.classes)): 
    2667             labels = e.classes[i]  
     2665        for i, labels in enumerate(e.classes): 
     2666            labels = map(int, labels) 
    26682667            if len(labels) <> len(aclass): 
    26692668                raise ValueError, "The dimensions of the classified output and the actual class array do not match." 
     
    26712670            intersection = 0.0 
    26722671            predicted = 0.0 
    2673             for j in range(label_num): 
    2674                 if labels[j]=='1' and aclass[j]=='1': 
     2672            for real, pred in zip(labels, aclass): 
     2673                if real and pred: 
    26752674                    intersection = intersection+1 
    2676                 if labels[j] == '1': 
     2675                if real: 
    26772676                    predicted = predicted + 1 
    26782677            if predicted <> 0: 
     
    26862685    """ 
    26872686    recalls = [0.0]*res.number_of_learners 
    2688     label_num = len(res.class_values) 
     2687    label_num = len(res.labels) 
    26892688    example_num = gettotsize(res) 
    26902689     
    26912690    for e in res.results: 
    26922691        aclass = e.actual_class 
    2693         for i in range(len(e.classes)): 
    2694             labels = e.classes[i]  
     2692        for i, labels in enumerate(e.classes): 
     2693            labels = map(int, labels) 
    26952694            if len(labels) <> len(aclass): 
    26962695                raise ValueError, "The dimensions of the classified output and the actual class array do not match." 
     
    26982697            intersection = 0.0 
    26992698            actual = 0.0 
    2700             for j in range(label_num): 
    2701                 if labels[j]=='1' and aclass[j]=='1': 
     2699            for real, pred in zip(labels, aclass): 
     2700                if real and pred: 
    27022701                    intersection = intersection+1 
    2703                 if aclass[j] == '1': 
     2702                if pred: 
    27042703                    actual = actual + 1 
    27052704            if actual <> 0: 
     
    27082707    return [x/example_num for x in recalls] 
    27092708 
    2710 def mlc_ranking_loss(res): 
    2711     pass 
    2712  
    2713 def mlc_average_precision(res): 
    2714     pass 
    2715  
    2716 def mlc_hierarchical_loss(res): 
    2717     pass 
     2709#def mlc_ranking_loss(res): 
     2710#    pass 
     2711# 
     2712#def mlc_average_precision(res): 
     2713#    pass 
     2714# 
     2715#def mlc_hierarchical_loss(res): 
     2716#    pass 
    27182717 
    27192718######################################################################################### 
  • orange/Orange/evaluation/testing.py

    r9503 r9504  
    1515    :var classes: A list of predictions of type Value, one for each classifier. 
    1616    :var probabilities: A list of probabilities of classes, one for each classifier. 
    17     :var iterationNumber: Iteration number (e.g. fold) in which the TestedExample was created/tested. 
    18     :var actualClass: The correct class of the example 
     17    :var iteration_number: Iteration number (e.g. fold) in which the TestedExample was created/tested. 
     18    :var actual_class: The correct class of the example 
    1919    :var weight: Example's weight. Even if the example set was not weighted, this attribute is present and equals 1.0. 
    2020    """ 
    2121 
    22     @deprecated_keywords({"iterationNumber": "iteration_number", 
    23                           "actualClass": "actual_class"}) 
     22    @deprecated_keywords({"iteration_number": "iteration_number", 
     23                          "actual_class": "actual_class"}) 
    2424    def __init__(self, iteration_number=None, actual_class=None, n=0, weight=1.0): 
    2525        """ 
     
    3131        self.classes = [None]*n 
    3232        self.probabilities = [None]*n 
    33         self.iterationNumber = iteration_number 
    34         self.actualClass= actual_class 
     33        self.iteration_number = iteration_number 
     34        self.actual_class= actual_class 
    3535        self.weight = weight 
    3636 
     
    6363        return str(self.__dict__) 
    6464 
     65TestedExample = deprecated_members({"iterationNumber": "iteration_number", 
     66                                    "actualClass": "actual_class" 
     67                                    })(TestedExample) 
     68 
    6569class ExperimentResults(object): 
    6670    """ 
     
    7377      of classifiers, one for each learner. This field is used only if storing is enabled by ``storeClassifiers=1``. 
    7478    :var number_of_iterations: Number of iterations. This can be the number of folds (in cross validation) 
    75       or the number of repetitions of some test. ``TestedExample``'s attribute ``iterationNumber`` should 
     79      or the number of repetitions of some test. ``TestedExample``'s attribute ``iteration_number`` should 
    7680      be in range ``[0, number_of_iterations-1]``. 
    7781    :var number_of_learners: Number of learners. Lengths of lists classes and probabilities in each :obj:`TestedExample` 
     
    111115                    self.converter = float 
    112116            elif test_type==TEST_TYPE_MLC: 
     117                self.labels = [var.name for var in domain.class_vars] 
    113118                self.converter = lambda vals: [int(val) if val.variable.var_type == Orange.data.Type.Discrete 
    114119                                               else float(val) for val in vals] 
     
    332337 
    333338        examples, weight = demangle_examples(examples) 
     339        test_type = self.check_test_type(examples, learners) 
    334340 
    335341        # If preprocessors are not used, we use the same dataset for learning and testing. Otherwise we need to 
     
    344350 
    345351        test_results = ExperimentResults(1, 
    346                                         classifierNames = [getobjectname(l) for l in learners], 
     352                                        classifier_names = [getobjectname(l) for l in learners], 
     353                                        test_type = test_type, 
    347354                                        domain=examples.domain, 
    348355                                        weights=weight) 
     
    380387        test_set, test_weight = demangle_examples(test_set) 
    381388 
     389        test_type = self.check_test_type(learn_set, learners) 
     390        self.check_test_type(test_set, learners) 
     391         
    382392        test_results = ExperimentResults(1, 
    383                                         classifierNames = [getobjectname(l) for l in learners], 
     393                                        classifier_names = [getobjectname(l) for l in learners], 
    384394                                        domain=test_set.domain, 
     395                                        test_type = test_type, 
    385396                                        weights=test_weight) 
    386397        test_results.results = [test_results.create_tested_example(0, example) 
     
    427438        examples, weight = demangle_examples(examples) 
    428439 
     440        test_type = self.check_test_type(examples, learners) 
     441         
    429442        test_results = ExperimentResults(times, 
    430443                                        classifierNames = [getobjectname(l) for l in learners], 
    431444                                        domain=examples.domain, 
     445                                        test_type = test_type, 
    432446                                        weights=weight) 
    433447        test_results.classifiers = [] 
     
    556570        learn_set, learn_weight = demangle_examples(learn_set) 
    557571        test_set, test_weight = demangle_examples(test_set) 
    558  
     572        test_type = self.check_test_type(learn_set, learners) 
     573        self.check_test_type(test_set, learners) 
     574         
    559575        indices = Orange.core.MakeRandomIndices2(stratified = stratification, randomGenerator = random_generator) 
    560576         
     
    564580                                        classifierNames = [getobjectname(l) for l in learners], 
    565581                                        domain=test_set.domain, 
     582                                        test_type = test_type, 
    566583                                        weights=test_weight) 
    567584            offset = 0 
     
    594611 
    595612        examples, weight = demangle_examples(examples) 
     613        test_type = self.check_test_type(examples, learners) 
    596614 
    597615        test_results = ExperimentResults(1, 
    598616                                        classifierNames = [getobjectname(l) for l in classifiers], 
    599617                                        domain=examples.domain, 
     618                                        test_type = test_type, 
    600619                                        weights=weight) 
    601620        test_results.results = [test_results.create_tested_example(0, example) 
  • orange/doc/Orange/rst/code/mlc-evaluator.py

    r9468 r9504  
    11import Orange 
    22 
    3 learners = [Orange.multilabel.BinaryRelevanceLearner(name="br")] 
    4 data = Orange.data.Table("multidata.tab") 
    5  
    6 res = Orange.evaluation.testing.cross_validation(learners, data) 
    7 loss = Orange.evaluation.scoring.mlc_hamming_loss(res) 
    8 accuracy = Orange.evaluation.scoring.mlc_accuracy(res) 
    9 precision = Orange.evaluation.scoring.mlc_precision(res) 
    10 recall = Orange.evaluation.scoring.mlc_recall(res) 
    11 print 'loss=', loss 
    12 print 'accuracy=', accuracy 
    13 print 'precision=', precision 
    14 print 'recall=', recall 
    15  
    16 res = Orange.evaluation.testing.leave_one_out(learners, data) 
    17 loss = Orange.evaluation.scoring.mlc_hamming_loss(res) 
    18 accuracy = Orange.evaluation.scoring.mlc_accuracy(res) 
    19 precision = Orange.evaluation.scoring.mlc_precision(res) 
    20 recall = Orange.evaluation.scoring.mlc_recall(res) 
    21 print 'loss=', loss 
    22 print 'accuracy=', accuracy 
    23 print 'precision=', precision 
    24 print 'recall=', recall 
    25  
    26 res = Orange.evaluation.testing.proportion_test(learners, data, 0.5) 
    27 loss = Orange.evaluation.scoring.mlc_hamming_loss(res) 
    28 accuracy = Orange.evaluation.scoring.mlc_accuracy(res) 
    29 precision = Orange.evaluation.scoring.mlc_precision(res) 
    30 recall = Orange.evaluation.scoring.mlc_recall(res) 
    31 print 'loss=', loss 
    32 print 'accuracy=', accuracy 
    33 print 'precision=', precision 
    34 print 'recall=', recall 
    35  
    36 reses = Orange.evaluation.testing.learning_curve(learners, data) 
    37 for res in reses: 
     3def print_results(res): 
    384    loss = Orange.evaluation.scoring.mlc_hamming_loss(res) 
    395    accuracy = Orange.evaluation.scoring.mlc_accuracy(res) 
    406    precision = Orange.evaluation.scoring.mlc_precision(res) 
    417    recall = Orange.evaluation.scoring.mlc_recall(res) 
    42     print 'loss=', loss, 
    43     print 'accuracy=', accuracy, 
    44     print 'precision=', precision, 
    45     print 'recall=', recall, 
     8    print 'loss=', loss 
     9    print 'accuracy=', accuracy 
     10    print 'precision=', precision 
     11    print 'recall=', recall 
    4612    print 
     13 
     14learners = [Orange.multilabel.MLkNNLearner(k=5)] 
     15data = Orange.data.Table("emotions.tab") 
     16 
     17res = Orange.evaluation.testing.cross_validation(learners, data) 
     18print_results(res) 
     19 
     20res = Orange.evaluation.testing.leave_one_out(learners, data) 
     21print_results(res) 
     22 
     23res = Orange.evaluation.testing.proportion_test(learners, data, 0.5) 
     24print_results(res) 
     25 
     26reses = Orange.evaluation.testing.learning_curve(learners, data) 
     27for res in reses: 
     28    print_results(res) 
Note: See TracChangeset for help on using the changeset viewer.