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/reliability.py

    r10393 r10633  
    5555 
    5656def get_prediction_error_list(res): 
    57     return [result.actualClass - result.classes[0] for result in res.results] 
     57    return [result.actual_class - result.classes[0] for result in res.results] 
    5858 
    5959def get_description_list(res, i): 
     
    124124    sig = [0 for _ in xrange(number_of_estimates)] 
    125125    method_list = [0 for _ in xrange(number_of_estimates)] 
    126      
     126 
    127127    for res in results_by_fold: 
    128128        prediction_error = get_prediction_error_list(res) 
     
    139139            sig[i] = signed_or_absolute 
    140140            method_list[i] = method 
    141      
     141 
    142142    # Calculate p-values 
    143143    results = [float(res) / number_of_folds for res in results] 
    144144    ps = [p_value_from_r(r, number_of_instances) for r in results] 
    145      
     145 
    146146    return zip(results, ps, sig, method_list) 
    147147 
     
    151151    """ 
    152152    df = n - 2 
    153     t = r * (df /((-r + 1.0 + 1e-30) * (r + 1.0 + 1e-30)) )**0.5 
    154     return statc.betai (df * 0.5, 0.5, df/(df + t*t)) 
     153    t = r * (df / ((-r + 1.0 + 1e-30) * (r + 1.0 + 1e-30))) ** 0.5 
     154    return statc.betai (df * 0.5, 0.5, df / (df + t * t)) 
    155155 
    156156class Estimate: 
     
    188188 
    189189    """ 
    190     def __init__(self, estimate, signed_or_absolute, method, icv_method = -1): 
     190    def __init__(self, estimate, signed_or_absolute, method, icv_method= -1): 
    191191        self.estimate = estimate 
    192192        self.signed_or_absolute = signed_or_absolute 
     
    202202        self.procentage = procentage 
    203203        self.estimator = estimator 
    204      
     204 
    205205    def __call__(self, instances, weight=None, **kwds): 
    206          
     206 
    207207        # Calculate borders using cross validation 
    208208        res = Orange.evaluation.testing.cross_validation([self.estimator], instances) 
     
    210210        for i in xrange(len(res.results[0].probabilities[0].reliability_estimate)): 
    211211            estimates, signed_or_absolute, method = get_reliability_estimation_list(res, i) 
    212             sorted_estimates = sorted( abs(x) for x in estimates) 
    213             borders = [sorted_estimates[int(len(estimates)*p)-1]  for p in self.procentage] 
     212            sorted_estimates = sorted(abs(x) for x in estimates) 
     213            borders = [sorted_estimates[int(len(estimates) * p) - 1]  for p in self.procentage] 
    214214            all_borders.append(borders) 
    215          
     215 
    216216        # Learn on whole train data 
    217217        estimator_classifier = self.estimator(instances) 
    218          
     218 
    219219        return DescriptiveAnalysisClassifier(estimator_classifier, all_borders, self.desc) 
    220220 
     
    224224        self.all_borders = all_borders 
    225225        self.desc = desc 
    226      
     226 
    227227    def __call__(self, instance, result_type=Orange.core.GetValue): 
    228228        predicted, probabilities = self.estimator_classifier(instance, Orange.core.GetBoth) 
    229          
     229 
    230230        for borders, estimate in zip(self.all_borders, probabilities.reliability_estimate): 
    231231            estimate.text_description = self.desc[0] 
     
    233233                if estimate.estimate >= lower_border: 
    234234                    estimate.text_description = text_desc 
    235          
     235 
    236236        # Return the appropriate type of result 
    237237        if result_type == Orange.core.GetValue: 
     
    269269    def __init__(self, e=[0.01, 0.1, 0.5, 1.0, 2.0]): 
    270270        self.e = e 
    271      
     271 
    272272    def __call__(self, instances, learner): 
    273273        min_value = max_value = instances[0].getclass().value 
     
    278278                min_value = ex.getclass().value 
    279279        return SensitivityAnalysisClassifier(self.e, instances, min_value, max_value, learner) 
    280      
     280 
    281281class SensitivityAnalysisClassifier: 
    282282    def __init__(self, e, instances, min_value, max_value, learner): 
     
    286286        self.min_value = min_value 
    287287        self.learner = learner 
    288      
     288 
    289289    def __call__(self, instance, predicted, probabilities): 
    290290        # Create new dataset 
    291291        r_data = Orange.data.Table(self.instances) 
    292          
     292 
    293293        # Create new instance 
    294294        modified_instance = Orange.data.Instance(instance) 
    295          
     295 
    296296        # Append it to the data 
    297297        r_data.append(modified_instance) 
    298          
     298 
    299299        # Calculate SAvar & SAbias 
    300300        SAvar = SAbias = 0 
    301          
     301 
    302302        for eps in self.e: 
    303303            # +epsilon 
    304             r_data[-1].setclass(predicted.value + eps*(self.max_value - self.min_value)) 
     304            r_data[-1].setclass(predicted.value + eps * (self.max_value - self.min_value)) 
    305305            c = self.learner(r_data) 
    306306            k_plus = c(instance, Orange.core.GetValue) 
    307              
     307 
    308308            # -epsilon 
    309             r_data[-1].setclass(predicted.value - eps*(self.max_value - self.min_value)) 
     309            r_data[-1].setclass(predicted.value - eps * (self.max_value - self.min_value)) 
    310310            c = self.learner(r_data) 
    311311            k_minus = c(instance, Orange.core.GetValue) 
     
    316316            # calculate part SAvar and SAbias 
    317317            SAvar += k_plus.value - k_minus.value 
    318             SAbias += k_plus.value + k_minus.value - 2*predicted.value 
    319          
     318            SAbias += k_plus.value + k_minus.value - 2 * predicted.value 
     319 
    320320        SAvar /= len(self.e) 
    321         SAbias /= 2*len(self.e) 
    322          
     321        SAbias /= 2 * len(self.e) 
     322 
    323323        return [Estimate(SAvar, ABSOLUTE, SAVAR_ABSOLUTE), 
    324324                Estimate(SAbias, SIGNED, SABIAS_SIGNED), 
    325325                Estimate(abs(SAbias), ABSOLUTE, SABIAS_ABSOLUTE)] 
    326      
     326 
    327327class BaggingVariance: 
    328328    """ 
     
    345345    def __init__(self, m=50): 
    346346        self.m = m 
    347      
     347 
    348348    def __call__(self, instances, learner): 
    349349        classifiers = [] 
    350          
     350 
    351351        # Create bagged classifiers using sampling with replacement 
    352352        for _ in xrange(self.m): 
     
    359359    def __init__(self, classifiers): 
    360360        self.classifiers = classifiers 
    361      
     361 
    362362    def __call__(self, instance, *args): 
    363363        BAGV = 0 
    364          
     364 
    365365        # Calculate the bagging variance 
    366366        bagged_values = [c(instance, Orange.core.GetValue).value for c in self.classifiers if c is not None] 
    367          
     367 
    368368        k = sum(bagged_values) / len(bagged_values) 
    369          
    370         BAGV = sum( (bagged_value - k)**2 for bagged_value in bagged_values) / len(bagged_values) 
    371          
     369 
     370        BAGV = sum((bagged_value - k) ** 2 for bagged_value in bagged_values) / len(bagged_values) 
     371 
    372372        return [Estimate(BAGV, ABSOLUTE, BAGV_ABSOLUTE)] 
    373          
     373 
    374374class LocalCrossValidation: 
    375375    """ 
     
    397397    def __init__(self, k=0): 
    398398        self.k = k 
    399      
     399 
    400400    def __call__(self, instances, learner): 
    401401        nearest_neighbours_constructor = Orange.classification.knn.FindNearestConstructor() 
    402402        nearest_neighbours_constructor.distanceConstructor = Orange.distance.Euclidean() 
    403          
     403 
    404404        distance_id = Orange.feature.Descriptor.new_meta_id() 
    405405        nearest_neighbours = nearest_neighbours_constructor(instances, 0, distance_id) 
    406          
     406 
    407407        if self.k == 0: 
    408             self.k = max(5, len(instances)/20) 
    409          
     408            self.k = max(5, len(instances) / 20) 
     409 
    410410        return LocalCrossValidationClassifier(distance_id, nearest_neighbours, self.k, learner) 
    411411 
     
    416416        self.k = k 
    417417        self.learner = learner 
    418      
     418 
    419419    def __call__(self, instance, *args): 
    420420        LCVer = 0 
    421421        LCVdi = 0 
    422          
     422 
    423423        # Find k nearest neighbors 
    424          
     424 
    425425        knn = [ex for ex in self.nearest_neighbours(instance, self.k)] 
    426          
     426 
    427427        # leave one out of prediction error 
    428428        for i in xrange(len(knn)): 
    429429            train = knn[:] 
    430430            del train[i] 
    431              
     431 
    432432            classifier = self.learner(Orange.data.Table(train)) 
    433              
     433 
    434434            returned_value = classifier(knn[i], Orange.core.GetValue) 
    435              
     435 
    436436            e = abs(knn[i].getclass().value - returned_value.value) 
    437              
     437 
    438438            LCVer += e * math.exp(-knn[i][self.distance_id]) 
    439439            LCVdi += math.exp(-knn[i][self.distance_id]) 
    440          
     440 
    441441        LCV = LCVer / LCVdi if LCVdi != 0 else 0 
    442442        if math.isnan(LCV): 
     
    464464    def __init__(self, k=5): 
    465465        self.k = k 
    466      
     466 
    467467    def __call__(self, instances, learner): 
    468468        nearest_neighbours_constructor = Orange.classification.knn.FindNearestConstructor() 
    469469        nearest_neighbours_constructor.distanceConstructor = Orange.distance.Euclidean() 
    470          
     470 
    471471        distance_id = Orange.feature.Descriptor.new_meta_id() 
    472472        nearest_neighbours = nearest_neighbours_constructor(instances, 0, distance_id) 
     
    477477        self.nearest_neighbours = nearest_neighbours 
    478478        self.k = k 
    479      
     479 
    480480    def __call__(self, instance, predicted, probabilities): 
    481481        CNK = 0 
    482          
     482 
    483483        # Find k nearest neighbors 
    484          
     484 
    485485        knn = [ex for ex in self.nearest_neighbours(instance, self.k)] 
    486          
     486 
    487487        # average label of neighbors 
    488488        for ex in knn: 
    489489            CNK += ex.getclass().value 
    490          
     490 
    491491        CNK /= self.k 
    492492        CNK -= predicted.value 
    493          
     493 
    494494        return [Estimate(CNK, SIGNED, CNK_SIGNED), 
    495495                Estimate(abs(CNK), ABSOLUTE, CNK_ABSOLUTE)] 
    496      
     496 
    497497class Mahalanobis: 
    498498    """ 
     
    511511    def __init__(self, k=3): 
    512512        self.k = k 
    513      
     513 
    514514    def __call__(self, instances, *args): 
    515515        nnm = Orange.classification.knn.FindNearestConstructor() 
    516516        nnm.distanceConstructor = Orange.distance.Mahalanobis() 
    517          
     517 
    518518        mid = Orange.feature.Descriptor.new_meta_id() 
    519519        nnm = nnm(instances, 0, mid) 
     
    525525        self.nnm = nnm 
    526526        self.mid = mid 
    527      
     527 
    528528    def __call__(self, instance, *args): 
    529529        mahalanobis_distance = 0 
    530          
     530 
    531531        mahalanobis_distance = sum(ex[self.mid].value for ex in self.nnm(instance, self.k)) 
    532          
     532 
    533533        return [ Estimate(mahalanobis_distance, ABSOLUTE, MAHAL_ABSOLUTE) ] 
    534534 
     
    545545    def __init__(self): 
    546546        pass 
    547      
     547 
    548548    def __call__(self, instances, *args): 
    549549        dc = Orange.core.DomainContinuizer() 
     
    551551        dc.continuousTreatment = Orange.core.DomainContinuizer.NormalizeBySpan 
    552552        dc.multinomialTreatment = Orange.core.DomainContinuizer.NValues 
    553          
     553 
    554554        new_domain = dc(instances) 
    555555        new_instances = instances.translate(new_domain) 
    556          
     556 
    557557        X, _, _ = new_instances.to_numpy() 
    558558        instance_avg = numpy.average(X, 0) 
    559          
     559 
    560560        distance_constructor = Orange.distance.Mahalanobis() 
    561561        distance = distance_constructor(new_instances) 
    562          
     562 
    563563        average_instance = Orange.data.Instance(new_instances.domain, list(instance_avg) + ["?"]) 
    564          
     564 
    565565        return MahalanobisToCenterClassifier(distance, average_instance, new_domain) 
    566566 
     
    570570        self.average_instance = average_instance 
    571571        self.new_domain = new_domain 
    572      
     572 
    573573    def __call__(self, instance, *args): 
    574          
     574 
    575575        inst = Orange.data.Instance(self.new_domain, instance) 
    576          
     576 
    577577        mahalanobis_to_center = self.distance(inst, self.average_instance) 
    578          
     578 
    579579        return [ Estimate(mahalanobis_to_center, ABSOLUTE, MAHAL_TO_CENTER_ABSOLUTE) ] 
    580580 
     
    598598        self.bagv = bagv 
    599599        self.cnk = cnk 
    600      
     600 
    601601    def __call__(self, instances, learner): 
    602602        bagv_classifier = self.bagv(instances, learner) 
     
    608608        self.bagv_classifier = bagv_classifier 
    609609        self.cnk_classifier = cnk_classifier 
    610      
     610 
    611611    def __call__(self, instance, predicted, probabilities): 
    612612        bagv_estimates = self.bagv_classifier(instance, predicted, probabilities) 
    613613        cnk_estimates = self.cnk_classifier(instance, predicted, probabilities) 
    614          
    615         bvck_value = (bagv_estimates[0].estimate + cnk_estimates[1].estimate)/2 
     614 
     615        bvck_value = (bagv_estimates[0].estimate + cnk_estimates[1].estimate) / 2 
    616616        bvck_estimates = [ Estimate(bvck_value, ABSOLUTE, BVCK_ABSOLUTE) ] 
    617617        bvck_estimates.extend(bagv_estimates) 
     
    622622    def __init__(self): 
    623623        pass 
    624      
     624 
    625625    def __call__(self, instances, learner): 
    626626        res = Orange.evaluation.testing.cross_validation([learner], instances) 
    627627        prediction_errors = get_prediction_error_list(res) 
    628          
     628 
    629629        new_domain = Orange.data.Domain(instances.domain.attributes, Orange.core.FloatVariable("pe")) 
    630630        new_dataset = Orange.data.Table(new_domain, instances) 
    631          
     631 
    632632        for instance, prediction_error in izip(new_dataset, prediction_errors): 
    633633            instance.set_class(prediction_error) 
    634          
     634 
    635635        rf = Orange.ensemble.forest.RandomForestLearner() 
    636636        rf_classifier = rf(new_dataset) 
    637          
     637 
    638638        return ErrorPredictingClassification(rf_classifier, new_domain) 
    639          
     639 
    640640class ErrorPredictingClassification: 
    641641    def __init__(self, rf_classifier, new_domain): 
    642642        self.rf_classifier = rf_classifier 
    643643        self.new_domain = new_domain 
    644      
     644 
    645645    def __call__(self, instance, predicted, probabilities): 
    646646        new_instance = Orange.data.Instance(self.new_domain, instance) 
    647647        value = self.rf_classifier(new_instance, Orange.core.GetValue) 
    648          
     648 
    649649        return [Estimate(value.value, SIGNED, SABIAS_SIGNED)] 
    650650 
     
    682682        self.box_learner = box_learner 
    683683        self.blending = False 
    684          
    685      
     684 
     685 
    686686    def __call__(self, instances, weight=None, **kwds): 
    687687        """Learn from the given table of data instances. 
     
    693693        :rtype: :class:`Orange.evaluation.reliability.Classifier` 
    694694        """ 
    695          
     695 
    696696        blending_classifier = None 
    697697        new_domain = None 
    698          
     698 
    699699        if instances.domain.class_var.var_type != Orange.feature.Continuous.Continuous: 
    700700            raise Exception("This method only works on data with continuous class.") 
    701          
     701 
    702702        return Classifier(instances, self.box_learner, self.estimators, self.blending, new_domain, blending_classifier) 
    703      
     703 
    704704    def internal_cross_validation(self, instances, folds=10): 
    705705        """ Perform the internal cross validation for getting the best 
     
    720720        sorted_results = sorted(results) 
    721721        return sorted_results[-1][3] 
    722      
     722 
    723723    def internal_cross_validation_testing(self, instances, folds=10): 
    724724        """ Perform internal cross validation (as in Automatic selection of 
     
    735735        """ 
    736736        cv_indices = Orange.core.MakeRandomIndicesCV(instances, folds) 
    737          
     737 
    738738        list_of_rs = [] 
    739          
     739 
    740740        sum_of_rs = defaultdict(float) 
    741          
     741 
    742742        for fold in xrange(folds): 
    743743            data = instances.select(cv_indices, fold) 
     
    751751        sorted_sum_of_rs = sorted(sum_of_rs.items(), key=lambda estimate: estimate[1], reverse=True) 
    752752        return sorted_sum_of_rs[0][0] 
    753      
     753 
    754754    labels = ["SAvar", "SAbias", "BAGV", "CNK", "LCV", "BVCK", "Mahalanobis", "ICV"] 
    755755 
     
    774774        self.blending_domain = blending_domain 
    775775        self.rf_classifier = rf_classifier 
    776          
     776 
    777777        # Train the learner with original data 
    778778        self.classifier = box_learner(instances) 
    779          
     779 
    780780        # Train all the estimators and create their classifiers 
    781781        self.estimation_classifiers = [estimator(instances, box_learner) for estimator in estimators] 
    782      
     782 
    783783    def __call__(self, instance, result_type=Orange.core.GetValue): 
    784784        """ 
     
    802802        """ 
    803803        predicted, probabilities = self.classifier(instance, Orange.core.GetBoth) 
    804          
     804 
    805805        # Create a place holder for estimates 
    806806        if probabilities is None: 
     
    809809        #    warnings.simplefilter("ignore") 
    810810        probabilities.setattr('reliability_estimate', []) 
    811          
     811 
    812812        # Calculate all the estimates and add them to the results 
    813813        for estimate in self.estimation_classifiers: 
    814814            probabilities.reliability_estimate.extend(estimate(instance, predicted, probabilities)) 
    815          
     815 
    816816        # Return the appropriate type of result 
    817817        if result_type == Orange.core.GetValue: 
Note: See TracChangeset for help on using the changeset viewer.