Changeset 8990:5895df76d717 in orange


Ignore:
Timestamp:
09/20/11 14:05:23 (3 years ago)
Author:
miha <miha.stajdohar@…>
Branch:
default
Convert:
7e425d0972d34baf62f1b9b53c6bf298c8462a08
Message:

Converted from camelCase to under_scores.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • orange/Orange/classification/svm/__init__.py

    r8762 r8990  
    3939----------------- 
    4040 
    41 .. automethod:: Orange.classification.svm.maxNu 
    42  
    43 .. automethod:: Orange.classification.svm.getLinearSVMWeights 
    44  
    45 .. automethod:: Orange.classification.svm.tableToSVMFormat 
     41.. automethod:: Orange.classification.svm.max_nu 
     42 
     43.. automethod:: Orange.classification.svm.get_linear_svm_weights 
     44 
     45.. automethod:: Orange.classification.svm.table_to_svm_format 
    4646 
    4747SVM-derived feature weights 
     
    111111import Orange.core 
    112112import Orange.data 
     113import Orange.misc 
     114 
    113115import kernels 
    114116import warnings 
     
    152154    return _orange__new_wrapped 
    153155 
    154 def maxNu(examples): 
     156def max_nu(examples): 
    155157    """Return the maximum nu parameter for Nu_SVC support vector learning 
    156158     for the given data table.  
     
    165167    return min([2.0 * min(n1, n2) / (n1 + n2) for n1, n2 in pairs(dist) \ 
    166168                if n1 != 0 and n2 !=0] + [nu]) 
     169     
     170maxNu = max_nu 
    167171     
    168172class SVMLearner(_SVMLearner): 
     
    181185    :param coef0: kernel parameter (Polynomial/Sigmoid) (default 0) 
    182186    :type coef0: int 
    183     :param kernelFunc: function that will be called if `kernel_type` is 
     187    :param kernel_func: function that will be called if `kernel_type` is 
    184188        `Custom`. It must accept two :obj:`Orange.data.Instance` arguments and 
    185189        return a float (the distance between the instances). 
    186     :type kernelFunc: callable function 
     190    :type kernel_func: callable function 
    187191    :param C: C parameter for C_SVC, Epsilon_SVR, Nu_SVR 
    188192    :type C: float 
     
    204208    :type weights: list 
    205209     
     210    Example: 
     211     
     212        >>> import Orange 
     213        >>> table = Orange.data.Table("vehicle.tab") 
     214        >>> svm = Orange.classification.svm.SVMLearner() 
     215        >>> results = Orange.evaluation.testing.cross_validation([svm], table, folds=5) 
     216        >>> print Orange.evaluation.scoring.CA(results) 
     217     
    206218    """ 
    207219    __new__ = _orange__new__(_SVMLearner) 
     
    213225    Epsilon_SVR = _SVMLearner.Epsilon_SVR 
    214226             
     227    @Orange.misc.deprecated_keywords({"kernelFunc": "kernel_func"}) 
    215228    def __init__(self, svm_type=Nu_SVC, kernel_type=kernels.RBF,  
    216                  kernelFunc=None, C=1.0, nu=0.5, p=0.1, gamma=0.0, degree=3,  
     229                 kernel_func=None, C=1.0, nu=0.5, p=0.1, gamma=0.0, degree=3,  
    217230                 coef0=0, shrinking=True, probability=True, verbose=False,  
    218231                 cache_size=200, eps=0.001, normalization=True, 
     
    220233        self.svm_type = SVMLearner.Nu_SVC 
    221234        self.kernel_type = kernel_type 
    222         self.kernelFunc = kernelFunc 
     235        self.kernel_func = kernel_func 
    223236        self.C = C 
    224237        self.nu = nu 
     
    239252        self.weight = weight 
    240253 
    241     maxNu = staticmethod(maxNu) 
     254    max_nu = staticmethod(max_nu) 
    242255 
    243256    def __call__(self, examples, weight=0): 
     
    261274            self.svm_type-=3 
    262275            #raise AttributeError, "Cannot do regression on descrete class data. Use C_SVC or NU_SVC for classification" 
    263         if self.kernel_type==4 and not self.kernelFunc: 
     276        if self.kernel_type==4 and not self.kernel_func: 
    264277            raise AttributeError, "Custom kernel function not supplied" 
    265278        ################################################## 
     
    269282        nu = self.nu 
    270283        if self.svm_type == SVMLearner.Nu_SVC: #is nu feasibile 
    271             maxNu= self.maxNu(examples) 
    272             if self.nu > maxNu: 
     284            max_nu= self.max_nu(examples) 
     285            if self.nu > max_nu: 
    273286                if getattr(self, "verbose", 0): 
    274287                    import warnings 
    275288                    warnings.warn("Specified nu %.3f is infeasible. \ 
    276                     Setting nu to %.3f" % (self.nu, maxNu)) 
    277                 nu = max(maxNu - 1e-7, 0.0) 
    278              
    279         for name in ["svm_type", "kernel_type", "kernelFunc", "C", "nu", "p",  
     289                    Setting nu to %.3f" % (self.nu, max_nu)) 
     290                nu = max(max_nu - 1e-7, 0.0) 
     291             
     292        for name in ["svm_type", "kernel_type", "kernel_func", "C", "nu", "p",  
    280293                     "gamma", "degree", "coef0", "shrinking", "probability",  
    281294                     "verbose", "cache_size", "eps"]: 
     
    285298        return self.learnClassifier(examples) 
    286299 
    287     def learnClassifier(self, examples): 
     300    def learn_classifier(self, examples): 
    288301        if self.normalization: 
    289302            examples = self._normalize(examples) 
     
    295308        return self.learner(examples) 
    296309 
    297     def tuneParameters(self, examples, parameters=None, folds=5, verbose=0,  
    298                        progressCallback=None): 
     310    @Orange.misc.deprecated_keywords({"progressCallback": "progress_callback"}) 
     311    def tune_parameters(self, examples, parameters=None, folds=5, verbose=0,  
     312                       progress_callback=None): 
    299313        """Tune the parameters of the SVMLearner on given instances using  
    300314        cross validation. 
     
    308322        :param verbose: default False 
    309323        :type verbose: bool 
    310         :param progressCallback: report progress 
    311         :type progressCallback: callback function 
    312              
    313         Example:: 
     324        :param progress_callback: report progress 
     325        :type progress_callback: callback function 
     326             
     327        Example: 
     328         
    314329            >>> svm = SVMLearner() 
    315330            >>> svm.tuneParameters(examples, parameters=["gamma"], folds=3) 
     
    328343        if self.svm_type == SVMLearner.Nu_SVC and "nu" in parameters: 
    329344            numOfNuValues=9 
    330             maxNu = max(self.maxNu(examples) - 1e-7, 0.0) 
     345            max_nu = max(self.max_nu(examples) - 1e-7, 0.0) 
    331346            searchParams.append(("nu", [i/10.0 for i in range(1, 9) if \ 
    332                                         i/10.0 < maxNu] + [maxNu])) 
     347                                        i/10.0 < max_nu] + [max_nu])) 
    333348        elif "C" in parameters: 
    334349            searchParams.append(("C", [2**a for a in  range(-5,15,2)])) 
     
    339354                            folds=folds,  
    340355                            returnWhat=orngWrap.TuneMParameters.returnLearner,  
    341                             progressCallback=progressCallback  
    342                             if progressCallback else lambda i:None) 
     356                            progressCallback=progress_callback  
     357                            if progress_callback else lambda i:None) 
    343358        tunedLearner(examples, verbose=verbose) 
    344359        if normalization: 
     
    353368        return examples.translate(newdomain) 
    354369 
     370SVMLearner = Orange.misc.deprecated_members({ 
     371    "learnClassifier": "learn_classifier",  
     372    "tuneParameters": "tune_parameters", 
     373    "kernelFunc" : "kernel_func", 
     374    }, 
     375    wrap_methods=["__init__", "tune_parameters"])(SVMLearner) 
     376 
    355377class SVMClassifierWrapper(Orange.core.SVMClassifier): 
    356378    def __new__(cls, wrapped): 
     
    366388        return self.wrapped(example, what) 
    367389     
    368     def classDistribution(self, example): 
     390    def class_distribution(self, example): 
    369391        example = Orange.data.Instance(self.wrapped.domain, example) 
    370392        return self.wrapped.classDistribution(example) 
    371393     
    372     def getDecisionValues(self, example): 
     394    def get_decision_values(self, example): 
    373395        example = Orange.data.Instance(self.wrapped.domain, example) 
    374396        return self.wrapped.getDecisionValues(example) 
    375397     
    376     def getModel(self): 
     398    def get_model(self): 
    377399        return self.wrapped.getModel() 
    378400     
     
    381403            for name, val in self.__dict__.items() \ 
    382404            if name not in self.wrapped.__dict__]) 
     405             
     406SVMClassifierWrapper = Orange.misc.deprecated_members({ 
     407    "classDistribution": "class_distribution",  
     408    "getDecisionValues": "get_decision_values", 
     409    "getModel" : "get_model", 
     410    })(SVMClassifierWrapper) 
    383411             
    384412class SVMLearnerSparse(SVMLearner): 
     
    416444        self.learner = SVMLearner(**kwds) 
    417445         
    418     def learnClassifier(self, examples): 
     446    def learn_classifier(self, examples): 
    419447        transformer=Orange.core.DomainContinuizer() 
    420448        transformer.multinomialTreatment=Orange.core.DomainContinuizer.NValues 
     
    432460            numOfNuValues=9 
    433461            if self.svm_type == SVMLearner.Nu_SVC: 
    434                 maxNu = max(self.maxNu(newexamples) - 1e-7, 0.0) 
     462                max_nu = max(self.max_nu(newexamples) - 1e-7, 0.0) 
    435463            else: 
    436                 maxNu = 1.0 
     464                max_nu = 1.0 
    437465            parameters.append(("nu", [i/10.0 for i in range(1, 9) \ 
    438                                       if i/10.0 < maxNu] + [maxNu])) 
     466                                      if i/10.0 < max_nu] + [max_nu])) 
    439467        else: 
    440468            parameters.append(("C", [2**a for a in  range(-5,15,2)])) 
     
    449477                                                 verbose=self.verbose)) 
    450478 
     479SVMLearner = Orange.misc.deprecated_members({ 
     480    "learnClassifier": "learn_classifier", 
     481    })(SVMLearner) 
     482 
    451483class SVMLearnerSparseClassEasy(SVMLearnerEasy, SVMLearnerSparse): 
    452484    def __init__(self, **kwds): 
     
    478510            setattr(self, name, val) 
    479511 
    480 def getLinearSVMWeights(classifier, sum=True): 
     512def get_linear_svm_weights(classifier, sum=True): 
    481513    """Extract attribute weights from the linear svm classifier. 
    482514     
     
    491523         
    492524    """ 
    493     def updateWeights(w, key, val, mul): 
     525    def update_weights(w, key, val, mul): 
    494526        if key in w: 
    495527            w[key]+=mul*val 
     
    518550                for attr in attributes: 
    519551                    if attr.varType==Orange.data.Type.Continuous: 
    520                         updateWeights(w, attr, to_float(SVs[svInd][attr]), \ 
     552                        update_weights(w, attr, to_float(SVs[svInd][attr]), \ 
    521553                                      classifier.coef[coefInd][svInd]) 
    522554            coefInd=i 
     
    526558                for attr in attributes: 
    527559                    if attr.varType==Orange.data.Type.Continuous: 
    528                         updateWeights(w, attr, to_float(SVs[svInd][attr]), \ 
     560                        update_weights(w, attr, to_float(SVs[svInd][attr]), \ 
    529561                                      classifier.coef[coefInd][svInd]) 
    530562            weights.append(w) 
     
    542574        return weights 
    543575 
    544 def exampleWeightedSum(example, weights): 
     576getLinearSVMWeights = get_linear_svm_weights 
     577 
     578def example_weighted_sum(example, weights): 
    545579    sum=0 
    546580    for attr, w in weights.items(): 
     
    548582    return sum 
    549583         
     584exampleWeightedSum = example_weighted_sum 
     585 
    550586class MeasureAttribute_SVMWeights(Orange.core.MeasureAttribute): 
    551587     
     
    554590    classifier) as the returned measure. 
    555591         
    556     Example:: 
     592    Example: 
     593     
    557594        >>> measure = MeasureAttribute_SVMWeights() 
    558595        >>> for attr in table.domain.attributes: 
     
    604641    weights. 
    605642     
    606     Example:: 
     643    Example: 
    607644     
    608645        >>> rfe = RFE(SVMLearner(kernel_type=kernels.Linear,  
     
    618655                            kernels.Linear, normalization=False) 
    619656 
    620     def getAttrScores(self, data, stopAt=0, progressCallback=None): 
     657    @Orange.misc.deprecated_keywords({"progressCallback": "progress_callback"}) 
     658    def get_attr_scores(self, data, stopAt=0, progress_callback=None): 
    621659        """Return a dict mapping attributes to scores (scores are not scores  
    622660        in a general meaning; they represent the step number at which they  
     
    629667         
    630668        while len(attrs) > stopAt: 
    631             weights = getLinearSVMWeights(self.learner(data), sum=False) 
    632             if progressCallback: 
    633                 progressCallback(100. * iter / (len(attrs) - stopAt)) 
     669            weights = get_linear_svm_weights(self.learner(data), sum=False) 
     670            if progress_callback: 
     671                progress_callback(100. * iter / (len(attrs) - stopAt)) 
    634672            score = dict.fromkeys(attrs, 0) 
    635673            for w in weights: 
     
    646684            iter += 1 
    647685        return attrScores 
    648          
    649     def __call__(self, data, numSelected=20, progressCallback=None): 
     686     
     687    @Orange.misc.deprecated_keywords({"numSelected": "num_selected", "progressCallback": "progress_callback"}) 
     688    def __call__(self, data, num_selected=20, progress_callback=None): 
    650689        """Return a new dataset with only `numSelected` best scoring attributes 
    651690         
    652691        :param data: Data 
    653692        :type data: Orange.data.Table 
    654         :param numSelected: number of features to preserve 
    655         :type numSelected: int 
     693        :param num_selected: number of features to preserve 
     694        :type num_selected: int 
    656695         
    657696        """ 
    658         scores = self.getAttrScores(data, progressCallback=progressCallback) 
     697        scores = self.get_attr_scores(data, progressCallback=progress_callback) 
    659698        scores = sorted(scores.items(), key=lambda item: item[1]) 
    660699         
    661         scores = dict(scores[-numSelected:]) 
     700        scores = dict(scores[-num_selected:]) 
    662701        attrs = [attr for attr in data.domain.attributes if attr in scores] 
    663702        domain = Orange.data.Domain(attrs, data.domain.classVar) 
     
    666705        return data 
    667706 
    668 def exampleTableToSVMFormat(examples, file): 
    669     warnings.warn("Deprecated. Use tableToSVMFormat", DeprecationWarning) 
    670     tableToSVMFormat(examples, file) 
    671  
    672 def tableToSVMFormat(examples, file): 
     707RFE = Orange.misc.deprecated_members({ 
     708    "getAttrScores": "get_attr_scores"}, 
     709    wrap_methods=["get_attr_scores", "__call__"])(RFE) 
     710 
     711def example_table_to_svm_format(examples, file): 
     712    warnings.warn("Deprecated. Use table_to_svm_format", DeprecationWarning) 
     713    table_to_svm_format(examples, file) 
     714 
     715exampleTableToSVMFormat = example_table_to_svm_format 
     716 
     717def table_to_svm_format(examples, file): 
    673718    """Save :obj:`Orange.data.Table` to a format used by LibSVM.""" 
    674719    attrs = examples.domain.attributes + examples.domain.getmetas().values() 
     
    689734        file.write("\n") 
    690735       
     736tableToSVMFormat = table_to_svm_format 
Note: See TracChangeset for help on using the changeset viewer.