Changeset 10302:e576bf56ae8e in orange


Ignore:
Timestamp:
02/18/12 15:06:49 (2 years ago)
Author:
Miha Stajdohar <miha.stajdohar@…>
Branch:
default
Message:

Fixed number of decimals in print-out.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • Orange/optimization/__init__.py

    r10077 r10302  
    9797 
    9898class TuneParameters(Orange.classification.Learner): 
    99      
     99 
    100100    """.. attribute:: data 
    101101     
     
    165165     
    166166    """ 
    167      
     167 
    168168    RETURN_NONE = 0 
    169169    RETURN_PARAMETERS = 1 
    170170    RETURN_LEARNER = 2 
    171171    RETURN_CLASSIFIER = 3 
    172      
     172 
    173173    returnNone = \ 
    174174        deprecated_class_attribute("returnNone", "RETURN_NONE") 
     
    179179    returnClassifier = \ 
    180180        deprecated_class_attribute("returnClassifier", "RETURN_CLASSIFIER") 
    181      
    182     @deprecated_keywords({"examples": "data","weightID": "weight_id"}) 
    183     def __new__(cls, data = None, weight_id = 0, **argkw): 
     181 
     182    @deprecated_keywords({"examples": "data", "weightID": "weight_id"}) 
     183    def __new__(cls, data=None, weight_id=0, **argkw): 
    184184        self = Orange.classification.Learner.__new__(cls, **argkw) 
    185185        if data: 
     
    198198            lastobj = getattr(lastobj, i) 
    199199        return lastobj, names[-1] 
    200      
     200 
    201201TuneParameters = deprecated_members( 
    202202    {"returnWhat": "return_what", 
    203203     "object": "learner"}, 
    204204    )(TuneParameters) 
    205      
    206      
     205 
     206 
    207207class Tune1Parameter(TuneParameters): 
    208      
     208 
    209209    """Class :obj:`Orange.optimization.Tune1Parameter` tunes a single parameter. 
    210210     
     
    262262     
    263263    """ 
    264      
     264 
    265265    def __call__(self, data, weight=None, verbose=0): 
    266266        verbose = verbose or getattr(self, "verbose", 0) 
     
    268268        folds = getattr(self, "folds", 5) 
    269269        compare = getattr(self, "compare", cmp) 
    270         return_what = getattr(self, "return_what",  
     270        return_what = getattr(self, "return_what", 
    271271                             Tune1Parameter.returnClassifier) 
    272272 
    273         if (type(self.parameter)==list) or (type(self.parameter)==tuple): 
     273        if (type(self.parameter) == list) or (type(self.parameter) == tuple): 
    274274            to_set = [self.findobj(ld) for ld in self.parameter] 
    275275        else: 
     
    277277 
    278278        cvind = Orange.core.MakeRandomIndicesCV(data, folds) 
    279         findBest = Orange.misc.selection.BestOnTheFly(seed = data.checksum(),  
    280                                          callCompareOn1st = True) 
     279        findBest = Orange.misc.selection.BestOnTheFly(seed=data.checksum(), 
     280                                         callCompareOn1st=True) 
    281281        tableAndWeight = weight and (data, weight) or data 
    282282        for par in self.values: 
     
    286286                                        [self.object], tableAndWeight, cvind)) 
    287287            findBest.candidate((res, par)) 
    288             if verbose==2: 
    289                 print '*** optimization  %s: %s:' % (par, res) 
     288            if verbose == 2: 
     289                print '*** optimization  %s: %s:' % (par, ", ".join("%.8f" % r for r in res)) 
    290290 
    291291        bestpar = findBest.winner()[1] 
     
    296296            print "*** Optimal parameter: %s = %s" % (self.parameter, bestpar) 
    297297 
    298         if return_what==Tune1Parameter.returnNone: 
     298        if return_what == Tune1Parameter.returnNone: 
    299299            return None 
    300         elif return_what==Tune1Parameter.returnParameters: 
     300        elif return_what == Tune1Parameter.returnParameters: 
    301301            return bestpar 
    302         elif return_what==Tune1Parameter.returnLearner: 
     302        elif return_what == Tune1Parameter.returnLearner: 
    303303            return self.object 
    304304        else: 
     
    310310 
    311311class TuneMParameters(TuneParameters): 
    312      
     312 
    313313    """The use of :obj:`Orange.optimization.TuneMParameters` differs from  
    314314    :obj:`Orange.optimization.Tune1Parameter` only in specification of tuning 
     
    328328     
    329329    """ 
    330      
     330 
    331331    def __call__(self, data, weight=None, verbose=0): 
    332332        evaluate = getattr(self, "evaluate", Orange.evaluation.scoring.CA) 
     
    336336        return_what = getattr(self, "return_what", Tune1Parameter.returnClassifier) 
    337337        progress_callback = getattr(self, "progress_callback", lambda i: None) 
    338          
     338 
    339339        to_set = [] 
    340340        parnames = [] 
    341341        for par in self.parameters: 
    342             if (type(par[0])==list) or (type(par[0])==tuple): 
     342            if (type(par[0]) == list) or (type(par[0]) == tuple): 
    343343                to_set.append([self.findobj(ld) for ld in par[0]]) 
    344344                parnames.append(par[0]) 
     
    349349 
    350350        cvind = Orange.core.MakeRandomIndicesCV(data, folds) 
    351         findBest = Orange.misc.selection.BestOnTheFly(seed = data.checksum(),  
    352                                          callCompareOn1st = True) 
     351        findBest = Orange.misc.selection.BestOnTheFly(seed=data.checksum(), 
     352                                         callCompareOn1st=True) 
    353353        tableAndWeight = weight and (data, weight) or data 
    354354        numOfTests = sum([len(x[1]) for x in self.parameters]) 
    355355        milestones = set(range(0, numOfTests, max(numOfTests / 100, 1))) 
    356         for itercount, valueindices in enumerate(Orange.misc.counters.LimitedCounter( \ 
     356        for itercount, valueindices in enumerate(Orange.misc.counters.LimitedCounter(\ 
    357357                                        [len(x[1]) for x in self.parameters])): 
    358             values = [self.parameters[i][1][x] for i,x \ 
     358            values = [self.parameters[i][1][x] for i, x \ 
    359359                      in enumerate(valueindices)] 
    360360            for pi, value in enumerate(values): 
    361361                for i, par in enumerate(to_set[pi]): 
    362362                    setattr(par[0], par[1], value) 
    363                     if verbose==2: 
     363                    if verbose == 2: 
    364364                        print "%s: %s" % (parnames[pi][i], value) 
    365                          
     365 
    366366            res = evaluate(Orange.evaluation.testing.test_with_indices( 
    367367                                        [self.object], tableAndWeight, cvind)) 
    368368            if itercount in milestones: 
    369369                progress_callback(100.0 * itercount / numOfTests) 
    370              
     370 
    371371            findBest.candidate((res, values)) 
    372             if verbose==2: 
     372            if verbose == 2: 
    373373                print "===> Result: %s\n" % res 
    374374 
     
    384384            print 
    385385 
    386         if return_what==Tune1Parameter.returnNone: 
     386        if return_what == Tune1Parameter.returnNone: 
    387387            return None 
    388         elif return_what==Tune1Parameter.returnParameters: 
     388        elif return_what == Tune1Parameter.returnParameters: 
    389389            return bestpar 
    390         elif return_what==Tune1Parameter.returnLearner: 
     390        elif return_what == Tune1Parameter.returnLearner: 
    391391            return self.object 
    392392        else: 
     
    396396            classifier.fitted_parameters = bestpar 
    397397            return classifier 
    398          
     398 
    399399TuneMParameters = deprecated_members( 
    400400    {"progressCallback": "progress_callback"}, 
     
    402402 
    403403class ThresholdLearner(Orange.classification.Learner): 
    404      
     404 
    405405    """:obj:`Orange.optimization.ThresholdLearner` is a class that wraps  
    406406    another learner. When given the data, it calls the wrapped learner to build 
     
    430430     
    431431    """ 
    432      
    433     @deprecated_keywords({"examples": "data","weightID": "weight_id"}) 
    434     def __new__(cls, data = None, weight_id = 0, **kwds): 
     432 
     433    @deprecated_keywords({"examples": "data", "weightID": "weight_id"}) 
     434    def __new__(cls, data=None, weight_id=0, **kwds): 
    435435        self = Orange.classification.Learner.__new__(cls, **kwds) 
    436436        if data: 
     
    439439        else: 
    440440            return self 
    441          
     441 
    442442    @deprecated_keywords({"storeCurve": "store_curve"}) 
    443443    def __init__(self, learner=None, store_curve=False, **kwds): 
     
    447447            setattr(self, name, value) 
    448448 
    449     @deprecated_keywords({"examples": "data","weightID": "weight_id"}) 
    450     def __call__(self, data, weight_id = 0): 
     449    @deprecated_keywords({"examples": "data", "weightID": "weight_id"}) 
     450    def __call__(self, data, weight_id=0): 
    451451        if self.learner is None: 
    452452            raise AttributeError("Learner not set.") 
    453          
     453 
    454454        classifier = self.learner(data, weight_id) 
    455         threshold, optCA, curve = Orange.wrappers.ThresholdCA(classifier,  
    456                                                           data,  
     455        threshold, optCA, curve = Orange.wrappers.ThresholdCA(classifier, 
     456                                                          data, 
    457457                                                          weight_id) 
    458458        if self.store_curve: 
    459             return ThresholdClassifier(classifier, threshold, curve = curve) 
     459            return ThresholdClassifier(classifier, threshold, curve=curve) 
    460460        else: 
    461461            return ThresholdClassifier(classifier, threshold) 
    462462 
    463463ThresholdLearner = deprecated_members( 
    464     {"storeCurve": "store_curve"},  
     464    {"storeCurve": "store_curve"}, 
    465465    wrap_methods=["__init__"] 
    466466    )(ThresholdLearner) 
    467      
     467 
    468468class ThresholdClassifier(Orange.classification.Classifier): 
    469      
     469 
    470470    """:obj:`Orange.optimization.ThresholdClassifier`, used by both  
    471471    :obj:`Orange.optimization.ThredholdLearner` and 
     
    490490     
    491491    """ 
    492      
     492 
    493493    def __init__(self, classifier, threshold, **kwds): 
    494494        self.classifier = classifier 
     
    497497            setattr(self, name, value) 
    498498 
    499     def __call__(self, instance, what = Orange.classification.Classifier.GetValue): 
     499    def __call__(self, instance, what=Orange.classification.Classifier.GetValue): 
    500500        probs = self.classifier(instance, self.GetProbabilities) 
    501501        if what == self.GetProbabilities: 
     
    507507        else: 
    508508            return (value, probs) 
    509          
    510      
     509 
     510 
    511511class ThresholdLearner_fixed(Orange.classification.Learner): 
    512512    """ This is a convinience  variant of  
     
    529529    """ 
    530530    @deprecated_keywords({"examples": "data", "weightID": "weight_id"}) 
    531     def __new__(cls, data = None, weight_id = 0, **kwds): 
     531    def __new__(cls, data=None, weight_id=0, **kwds): 
    532532        self = Orange.classification.Learner.__new__(cls, **kwds) 
    533533        if data: 
     
    536536        else: 
    537537            return self 
    538          
     538 
    539539    def __init__(self, learner=None, threshold=None, **kwds): 
    540540        self.learner = learner 
     
    542542        for name, value in kwds.items(): 
    543543            setattr(name, value) 
    544              
     544 
    545545    @deprecated_keywords({"examples": "data", "weightID": "weight_id"}) 
    546     def __call__(self, data, weight_id = 0): 
     546    def __call__(self, data, weight_id=0): 
    547547        if self.learner is None: 
    548548            raise AttributeError("Learner not set.") 
     
    551551        if len(data.domain.classVar.values) != 2: 
    552552            raise ValueError("ThresholdLearner handles binary classes only.") 
    553          
    554         return ThresholdClassifier(self.learner(data, weight_id),  
     553 
     554        return ThresholdClassifier(self.learner(data, weight_id), 
    555555                                   self.threshold) 
    556556 
    557557class PreprocessedLearner(object): 
    558     def __new__(cls, preprocessor = None, learner = None): 
     558    def __new__(cls, preprocessor=None, learner=None): 
    559559        self = object.__new__(cls) 
    560560        if learner is not None: 
     
    563563        else: 
    564564            return self 
    565          
    566     def __init__(self, preprocessor = None, learner = None): 
     565 
     566    def __init__(self, preprocessor=None, learner=None): 
    567567        if isinstance(preprocessor, list): 
    568568            self.preprocessors = preprocessor 
     
    574574        if learner: 
    575575            self.wrapLearner(learner) 
    576          
    577     def processData(self, data, weightId = None): 
     576 
     577    def processData(self, data, weightId=None): 
    578578        hadWeight = hasWeight = weightId is not None 
    579579        for preprocessor in self.preprocessors: 
    580580            if hasWeight: 
    581                 t = preprocessor(data, weightId)   
     581                t = preprocessor(data, weightId) 
    582582            else: 
    583583                t = preprocessor(data) 
    584                  
     584 
    585585            if isinstance(t, tuple): 
    586586                data, weightId = t 
     
    598598            wrappedLearner = learner 
    599599            name = getattr(learner, "name", "") 
    600             def __call__(self, data, weightId=0, getData = False): 
     600            def __call__(self, data, weightId=0, getData=False): 
    601601                t = self.preprocessor.processData(data, weightId or 0) 
    602602                processed, procW = t if isinstance(t, tuple) else (t, 0) 
     
    606606                else: 
    607607                    return classifier # super(WrappedLearner, self).__call__(processed, procW) 
    608                  
     608 
    609609            def __reduce__(self): 
    610610                return PreprocessedLearner, (self.preprocessor.preprocessors, \ 
    611611                                             self.wrappedLearner) 
    612              
     612 
    613613            def __getattr__(self, name): 
    614614                return getattr(learner, name) 
    615              
     615 
    616616        return WrappedLearner() 
Note: See TracChangeset for help on using the changeset viewer.