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

Attribute weight had wrong default () -> [].

File:
1 edited

Legend:

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

    r10133 r10300  
    160160                        SVMClassifier, \ 
    161161                        SVMClassifierSparse 
    162                          
     162 
    163163from Orange.preprocess import Preprocessor_impute, \ 
    164164                              Preprocessor_continuize, \ 
     
    182182    def pairs(seq): 
    183183        for i, n1 in enumerate(seq): 
    184             for n2 in seq[i+1:]: 
     184            for n2 in seq[i + 1:]: 
    185185                yield n1, n2 
    186186    return min([2.0 * min(n1, n2) / (n1 + n2) for n1, n2 in pairs(dist) \ 
    187                 if n1 != 0 and n2 !=0] + [nu]) 
    188      
     187                if n1 != 0 and n2 != 0] + [nu]) 
     188 
    189189maxNu = max_nu 
    190      
     190 
    191191class SVMLearner(_SVMLearner): 
    192192    """ 
     
    242242    """ 
    243243    __new__ = _orange__new__(_SVMLearner) 
    244      
     244 
    245245    C_SVC = _SVMLearner.C_SVC 
    246246    Nu_SVC = _SVMLearner.Nu_SVC 
     
    248248    Nu_SVR = _SVMLearner.Nu_SVR 
    249249    Epsilon_SVR = _SVMLearner.Epsilon_SVR 
    250              
     250 
    251251    @Orange.misc.deprecated_keywords({"kernelFunc": "kernel_func"}) 
    252     def __init__(self, svm_type=Nu_SVC, kernel_type=kernels.RBF,  
    253                  kernel_func=None, C=1.0, nu=0.5, p=0.1, gamma=0.0, degree=3,  
    254                  coef0=0, shrinking=True, probability=True, verbose=False,  
     252    def __init__(self, svm_type=Nu_SVC, kernel_type=kernels.RBF, 
     253                 kernel_func=None, C=1.0, nu=0.5, p=0.1, gamma=0.0, degree=3, 
     254                 coef0=0, shrinking=True, probability=True, verbose=False, 
    255255                 cache_size=200, eps=0.001, normalization=True, 
    256                  weight=(), **kwargs): 
     256                 weight=[], **kwargs): 
    257257        self.svm_type = svm_type 
    258258        self.kernel_type = kernel_type 
     
    287287         
    288288        """ 
    289          
     289 
    290290        examples = Orange.core.Preprocessor_dropMissingClasses(data) 
    291291        class_var = examples.domain.class_var 
    292292        if len(examples) == 0: 
    293293            raise ValueError("Example table is without any defined classes") 
    294          
     294 
    295295        # Fix the svm_type parameter if we have a class_var/svm_type mismatch 
    296         if self.svm_type in [0,1] and \ 
     296        if self.svm_type in [0, 1] and \ 
    297297            isinstance(class_var, Orange.feature.Continuous): 
    298298            self.svm_type += 3 
    299299            #raise AttributeError, "Cannot learn a discrete classifier from non descrete class data. Use EPSILON_SVR or NU_SVR for regression" 
    300         if self.svm_type in [3,4] and \ 
     300        if self.svm_type in [3, 4] and \ 
    301301            isinstance(class_var, Orange.feature.Discrete): 
    302302            self.svm_type -= 3 
     
    304304        if self.kernel_type == kernels.Custom and not self.kernel_func: 
    305305            raise ValueError("Custom kernel function not supplied") 
    306          
     306 
    307307        import warnings 
    308          
     308 
    309309        nu = self.nu 
    310310        if self.svm_type == SVMLearner.Nu_SVC: #is nu feasible 
    311             max_nu= self.max_nu(examples) 
     311            max_nu = self.max_nu(examples) 
    312312            if self.nu > max_nu: 
    313313                if getattr(self, "verbose", 0): 
     
    315315                    Setting nu to %.3f" % (self.nu, max_nu)) 
    316316                nu = max(max_nu - 1e-7, 0.0) 
    317              
    318         for name in ["svm_type", "kernel_type", "kernel_func", "C", "nu", "p",  
    319                      "gamma", "degree", "coef0", "shrinking", "probability",  
     317 
     318        for name in ["svm_type", "kernel_type", "kernel_func", "C", "nu", "p", 
     319                     "gamma", "degree", "coef0", "shrinking", "probability", 
    320320                     "verbose", "cache_size", "eps"]: 
    321321            setattr(self.learner, name, getattr(self, name)) 
    322322        self.learner.nu = nu 
    323323        self.learner.set_weights(self.weight) 
     324 
    324325        if self.svm_type == SVMLearner.OneClass and self.probability: 
    325326            self.learner.probability = False 
     
    335336 
    336337    @Orange.misc.deprecated_keywords({"progressCallback": "progress_callback"}) 
    337     def tune_parameters(self, data, parameters=None, folds=5, verbose=0,  
     338    def tune_parameters(self, data, parameters=None, folds=5, verbose=0, 
    338339                       progress_callback=None): 
    339340        """Tune the ``parameters`` on given ``data`` using  
     
    358359                     
    359360        """ 
    360          
     361 
    361362        import orngWrap 
    362          
     363 
    363364        if parameters is None: 
    364365            parameters = ["nu", "C", "gamma"] 
    365              
     366 
    366367        searchParams = [] 
    367368        normalization = self.normalization 
     
    371372        if self.svm_type in [SVMLearner.Nu_SVC, SVMLearner.Nu_SVR] \ 
    372373                    and "nu" in parameters: 
    373             numOfNuValues=9 
     374            numOfNuValues = 9 
    374375            if isinstance(data.domain.class_var, variable.Discrete): 
    375376                max_nu = max(self.max_nu(data) - 1e-7, 0.0) 
    376377            else: 
    377378                max_nu = 1.0 
    378             searchParams.append(("nu", [i/10.0 for i in range(1, 9) if \ 
    379                                         i/10.0 < max_nu] + [max_nu])) 
     379            searchParams.append(("nu", [i / 10.0 for i in range(1, 9) if \ 
     380                                        i / 10.0 < max_nu] + [max_nu])) 
    380381        elif "C" in parameters: 
    381             searchParams.append(("C", [2**a for a in  range(-5,15,2)])) 
    382         if self.kernel_type==2 and "gamma" in parameters: 
    383             searchParams.append(("gamma", [2**a for a in range(-5,5,2)]+[0])) 
     382            searchParams.append(("C", [2 ** a for a in  range(-5, 15, 2)])) 
     383        if self.kernel_type == 2 and "gamma" in parameters: 
     384            searchParams.append(("gamma", [2 ** a for a in range(-5, 5, 2)] + [0])) 
    384385        tunedLearner = orngWrap.TuneMParameters(object=self, 
    385                             parameters=searchParams,  
    386                             folds=folds,  
    387                             returnWhat=orngWrap.TuneMParameters.returnLearner,  
    388                             progressCallback=progress_callback  
     386                            parameters=searchParams, 
     387                            folds=folds, 
     388                            returnWhat=orngWrap.TuneMParameters.returnLearner, 
     389                            progressCallback=progress_callback 
    389390                            if progress_callback else lambda i:None) 
    390391        tunedLearner(data, verbose=verbose) 
     
    401402 
    402403SVMLearner = Orange.misc.deprecated_members({ 
    403     "learnClassifier": "learn_classifier",  
     404    "learnClassifier": "learn_classifier", 
    404405    "tuneParameters": "tune_parameters", 
    405406    "kernelFunc" : "kernel_func", 
     
    410411    def __new__(cls, wrapped): 
    411412        return Orange.core.SVMClassifier.__new__(cls, name=wrapped.name) 
    412      
     413 
    413414    def __init__(self, wrapped): 
    414415        self.wrapped = wrapped 
    415416        for name, val in wrapped.__dict__.items(): 
    416417            self.__dict__[name] = val 
    417          
     418 
    418419    def __call__(self, example, what=Orange.core.GetValue): 
    419420        example = Orange.data.Instance(self.wrapped.domain, example) 
    420421        return self.wrapped(example, what) 
    421      
     422 
    422423    def class_distribution(self, example): 
    423424        example = Orange.data.Instance(self.wrapped.domain, example) 
    424425        return self.wrapped.class_distribution(example) 
    425      
     426 
    426427    def get_decision_values(self, example): 
    427428        example = Orange.data.Instance(self.wrapped.domain, example) 
    428429        return self.wrapped.get_decision_values(example) 
    429      
     430 
    430431    def get_model(self): 
    431432        return self.wrapped.get_model() 
    432      
     433 
    433434    def __reduce__(self): 
    434435        return SVMClassifierWrapper, (self.wrapped,), dict([(name, val) \ 
    435436            for name, val in self.__dict__.items() \ 
    436437            if name not in self.wrapped.__dict__]) 
    437              
     438 
    438439SVMClassifierWrapper = Orange.misc.deprecated_members({ 
    439     "classDistribution": "class_distribution",  
     440    "classDistribution": "class_distribution", 
    440441    "getDecisionValues": "get_decision_values", 
    441442    "getModel" : "get_model", 
    442443    })(SVMClassifierWrapper) 
    443              
     444 
    444445class SVMLearnerSparse(SVMLearner): 
    445      
     446 
    446447    """A :class:`SVMLearner` that learns from 
    447448    meta attributes. 
     
    452453     
    453454    """ 
    454      
     455 
    455456    @Orange.misc.deprecated_keywords({"useNonMeta": "use_non_meta"}) 
    456457    def __init__(self, **kwds): 
     
    458459        self.use_non_meta = kwds.get("use_non_meta", False) 
    459460        self.learner = Orange.core.SVMLearnerSparse(**kwds) 
    460          
     461 
    461462    def _normalize(self, data): 
    462463        if self.use_non_meta: 
     
    470471 
    471472class SVMLearnerEasy(SVMLearner): 
    472      
     473 
    473474    """Apart from the functionality of :obj:`SVMLearner` it automatically scales the  
    474475    data and perform parameter optimization with the  
     
    477478     
    478479    """ 
    479      
     480 
    480481    def __init__(self, **kwds): 
    481         self.folds=4 
    482         self.verbose=0 
     482        self.folds = 4 
     483        self.verbose = 0 
    483484        SVMLearner.__init__(self, **kwds) 
    484485        self.learner = SVMLearner(**kwds) 
    485          
     486 
    486487    def learn_classifier(self, data): 
    487         transformer=Orange.core.DomainContinuizer() 
    488         transformer.multinomialTreatment=Orange.core.DomainContinuizer.NValues 
    489         transformer.continuousTreatment= \ 
     488        transformer = Orange.core.DomainContinuizer() 
     489        transformer.multinomialTreatment = Orange.core.DomainContinuizer.NValues 
     490        transformer.continuousTreatment = \ 
    490491            Orange.core.DomainContinuizer.NormalizeBySpan 
    491         transformer.classTreatment=Orange.core.DomainContinuizer.Ignore 
    492         newdomain=transformer(data) 
    493         newexamples=data.translate(newdomain) 
     492        transformer.classTreatment = Orange.core.DomainContinuizer.Ignore 
     493        newdomain = transformer(data) 
     494        newexamples = data.translate(newdomain) 
    494495        #print newexamples[0] 
    495         params={} 
     496        params = {} 
    496497        parameters = [] 
    497498        self.learner.normalization = False ## Normalization already done 
    498          
    499         if self.svm_type in [1,4]: 
    500             numOfNuValues=9 
     499 
     500        if self.svm_type in [1, 4]: 
     501            numOfNuValues = 9 
    501502            if self.svm_type == SVMLearner.Nu_SVC: 
    502503                max_nu = max(self.max_nu(newexamples) - 1e-7, 0.0) 
    503504            else: 
    504505                max_nu = 1.0 
    505             parameters.append(("nu", [i/10.0 for i in range(1, 9) \ 
    506                                       if i/10.0 < max_nu] + [max_nu])) 
     506            parameters.append(("nu", [i / 10.0 for i in range(1, 9) \ 
     507                                      if i / 10.0 < max_nu] + [max_nu])) 
    507508        else: 
    508             parameters.append(("C", [2**a for a in  range(-5,15,2)])) 
    509         if self.kernel_type==2: 
    510             parameters.append(("gamma", [2**a for a in range(-5,5,2)]+[0])) 
     509            parameters.append(("C", [2 ** a for a in  range(-5, 15, 2)])) 
     510        if self.kernel_type == 2: 
     511            parameters.append(("gamma", [2 ** a for a in range(-5, 5, 2)] + [0])) 
    511512        import orngWrap 
    512         tunedLearner = orngWrap.TuneMParameters(object=self.learner,  
    513                                                 parameters=parameters,  
     513        tunedLearner = orngWrap.TuneMParameters(object=self.learner, 
     514                                                parameters=parameters, 
    514515                                                folds=self.folds) 
    515          
     516 
    516517        return SVMClassifierWrapper(tunedLearner(newexamples, 
    517518                                                 verbose=self.verbose)) 
     
    533534class LinearSVMLearner(Orange.core.LinearLearner): 
    534535    """Train a linear SVM model.""" 
    535      
     536 
    536537    L2R_L2LOSS_DUAL = Orange.core.LinearLearner.L2R_L2Loss_SVC_Dual 
    537     L2R_L2LOSS = Orange.core.LinearLearner.L2R_L2Loss_SVC  
     538    L2R_L2LOSS = Orange.core.LinearLearner.L2R_L2Loss_SVC 
    538539    L2R_L1LOSS_DUAL = Orange.core.LinearLearner.L2R_L1Loss_SVC_Dual 
    539540    L2R_L1LOSS_DUAL = Orange.core.LinearLearner.L2R_L2Loss_SVC_Dual 
    540541    L1R_L2LOSS = Orange.core.LinearLearner.L1R_L2Loss_SVC 
    541      
     542 
    542543    __new__ = _orange__new__(base=Orange.core.LinearLearner) 
    543          
     544 
    544545    def __init__(self, solver_type=L2R_L2LOSS_DUAL, C=1.0, eps=0.01, **kwargs): 
    545546        """ 
     
    568569            pass 
    569570#            raise ValueError("Invalid solver_type parameter.") 
    570          
     571 
    571572        self.preproc = default_preprocessor() 
    572              
     573 
    573574    def __call__(self, instances, weight_id=None): 
    574575        instances = self.preproc(instances) 
    575576        classifier = super(LinearSVMLearner, self).__call__(instances, weight_id) 
    576577        return classifier 
    577          
     578 
    578579LinearLearner = LinearSVMLearner 
    579580 
     
    582583    """ 
    583584    __new__ = _orange__new__(base=Orange.core.LinearLearner) 
    584          
     585 
    585586    def __init__(self, C=1.0, eps=0.01, **kwargs): 
    586587        """\ 
     
    596597        for name, val in kwargs.items(): 
    597598            setattr(self, name, val) 
    598              
     599 
    599600        self.solver_type = self.MCSVM_CS 
    600601        self.preproc = default_preprocessor() 
    601          
     602 
    602603    def __call__(self, instances, weight_id=None): 
    603604        instances = self.preproc(instances) 
     
    617618         
    618619    """ 
    619      
     620 
    620621    def update_weights(w, key, val, mul): 
    621622        if key in w: 
    622             w[key]+=mul*val 
     623            w[key] += mul * val 
    623624        else: 
    624             w[key]=mul*val 
    625              
     625            w[key] = mul * val 
     626 
    626627    def to_float(val): 
    627         return float(val) if not val.isSpecial() else 0.0  
    628              
    629     SVs=classifier.support_vectors 
     628        return float(val) if not val.isSpecial() else 0.0 
     629 
     630    SVs = classifier.support_vectors 
    630631    weights = [] 
    631      
     632 
    632633    class_var = SVs.domain.class_var 
    633634    if classifier.svm_type in [SVMLearner.C_SVC, SVMLearner.Nu_SVC]: 
     
    638639        sv_ranges = [(0, classifier.nSV[0])] 
    639640        for n in classifier.nSV[1:]: 
    640             sv_ranges.append((sv_ranges[-1][1], sv_ranges[-1][1]+n)) 
     641            sv_ranges.append((sv_ranges[-1][1], sv_ranges[-1][1] + n)) 
    641642    else: 
    642643        sv_ranges = [(0, len(SVs))] 
    643          
     644 
    644645    for i in range(len(classes) - 1): 
    645         for j in range(i+1, len(classes)): 
     646        for j in range(i + 1, len(classes)): 
    646647            w = {} 
    647648            coef_ind = j - 1 
     
    653654                        update_weights(w, attr, to_float(SVs[sv_ind][attr]), \ 
    654655                                       classifier.coef[coef_ind][sv_ind]) 
    655             coef_ind=i 
     656            coef_ind = i 
    656657            for sv_ind in range(*sv_ranges[j]): 
    657658                attributes = SVs.domain.attributes + \ 
    658659                SVs[sv_ind].getmetas(False, Orange.feature.Descriptor).keys() 
    659660                for attr in attributes: 
    660                     if attr.varType==Orange.feature.Type.Continuous: 
     661                    if attr.varType == Orange.feature.Type.Continuous: 
    661662                        update_weights(w, attr, to_float(SVs[sv_ind][attr]), \ 
    662663                                       classifier.coef[coef_ind][sv_ind]) 
    663664            weights.append(w) 
    664              
     665 
    665666    if sum: 
    666667        scores = defaultdict(float) 
    667          
     668 
    668669        for w in weights: 
    669670            for attr, w_attr in w.items(): 
    670                 scores[attr] += w_attr**2 
     671                scores[attr] += w_attr ** 2 
    671672        for key in scores: 
    672673            scores[key] = math.sqrt(scores[key]) 
     
    678679 
    679680def example_weighted_sum(example, weights): 
    680     sum=0 
     681    sum = 0 
    681682    for attr, w in weights.items(): 
    682683        sum += float(example[attr]) * w 
    683684    return sum 
    684          
     685 
    685686exampleWeightedSum = example_weighted_sum 
    686687 
     
    714715               
    715716    """ 
    716      
     717 
    717718    def __new__(cls, attr=None, data=None, weight_id=None, **kwargs): 
    718719        self = Orange.feature.scoring.Score.__new__(cls, **kwargs) 
     
    722723        else: 
    723724            return self 
    724          
     725 
    725726    def __reduce__(self): 
    726727        return ScoreSVMWeights, (), dict(self.__dict__) 
    727      
     728 
    728729    def __init__(self, learner=None, **kwargs): 
    729730        """ 
     
    734735        """ 
    735736        if learner: 
    736             self.learner = learner  
     737            self.learner = learner 
    737738        else: 
    738739            self.learner = LinearSVMLearner(solver_type= 
    739740                                    LinearSVMLearner.L2R_L2LOSS_DUAL) 
    740               
     741 
    741742        self._cached_examples = None 
    742          
     743 
    743744    def __call__(self, attr, data, weight_id=None): 
    744745        if data is self._cached_examples: 
     
    757758 
    758759class RFE(object): 
    759      
     760 
    760761    """Recursive feature elimination using linear SVM derived attribute  
    761762    weights. 
     
    772773         
    773774    """ 
    774      
     775 
    775776    def __init__(self, learner=None): 
    776777        self.learner = learner or SVMLearner(kernel_type= 
     
    787788        attrs = data.domain.attributes 
    788789        attrScores = {} 
    789          
     790 
    790791        while len(attrs) > stop_at: 
    791792            weights = get_linear_svm_weights(self.learner(data), sum=False) 
     
    795796            for w in weights: 
    796797                for attr, wAttr in w.items(): 
    797                     score[attr] += wAttr**2 
     798                    score[attr] += wAttr ** 2 
    798799            score = score.items() 
    799             score.sort(lambda a,b:cmp(a[1],b[1])) 
    800             numToRemove = max(int(len(attrs)*1.0/(iter+1)), 1) 
     800            score.sort(lambda a, b:cmp(a[1], b[1])) 
     801            numToRemove = max(int(len(attrs) * 1.0 / (iter + 1)), 1) 
    801802            for attr, s in  score[:numToRemove]: 
    802803                attrScores[attr] = len(attrScores) 
     
    806807            iter += 1 
    807808        return attrScores 
    808      
     809 
    809810    @Orange.misc.deprecated_keywords({"numSelected": "num_selected", "progressCallback": "progress_callback"}) 
    810811    def __call__(self, data, num_selected=20, progress_callback=None): 
     
    819820        scores = self.get_attr_scores(data, progress_callback=progress_callback) 
    820821        scores = sorted(scores.items(), key=lambda item: item[1]) 
    821          
     822 
    822823        scores = dict(scores[-num_selected:]) 
    823824        attrs = [attr for attr in data.domain.attributes if attr in scores] 
     
    846847     
    847848    """ 
    848      
     849 
    849850    attrs = data.domain.attributes + data.domain.getmetas().values() 
    850     attrs = [attr for attr in attrs if attr.varType  
    851              in [Orange.feature.Type.Continuous,  
     851    attrs = [attr for attr in attrs if attr.varType 
     852             in [Orange.feature.Type.Continuous, 
    852853                 Orange.feature.Type.Discrete]] 
    853854    cv = data.domain.classVar 
    854      
     855 
    855856    for ex in data: 
    856857        if cv.varType == Orange.feature.Type.Discrete: 
    857             file.write(str(int(ex[cv])))   
     858            file.write(str(int(ex[cv]))) 
    858859        else: 
    859860            file.write(str(float(ex[cv]))) 
    860               
     861 
    861862        for i, attr in enumerate(attrs): 
    862863            if not ex[attr].isSpecial(): 
    863                 file.write(" "+str(i+1)+":"+str(float(ex[attr]))) 
     864                file.write(" " + str(i + 1) + ":" + str(float(ex[attr]))) 
    864865        file.write("\n") 
    865        
     866 
    866867tableToSVMFormat = table_to_svm_format 
Note: See TracChangeset for help on using the changeset viewer.