Changeset 10955:8fd59ece1784 in orange


Ignore:
Timestamp:
07/19/12 12:57:55 (21 months ago)
Author:
Ales Erjavec <ales.erjavec@…>
Branch:
default
Message:

Code style fixup.

File:
1 edited

Legend:

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

    r10954 r10955  
    2525from Orange.utils import _orange__new__ 
    2626 
     27 
    2728def max_nu(data): 
    2829    """ 
    2930    Return the maximum nu parameter for the given data table for 
    3031    Nu_SVC learning. 
    31      
     32 
    3233    :param data: Data with discrete class variable 
    3334    :type data: Orange.data.Table 
    34      
     35 
    3536    """ 
    3637    nu = 1.0 
    3738    dist = list(Orange.core.Distribution(data.domain.classVar, data)) 
     39 
    3840    def pairs(seq): 
    3941        for i, n1 in enumerate(seq): 
     
    6264    :param degree: kernel parameter (only for ``Polynomial``) 
    6365    :type degree: int 
    64     :param gamma: kernel parameter; if 0, it is set to 1.0/#features (for ``Polynomial``, ``RBF`` and ``Sigmoid``) 
     66    :param gamma: kernel parameter; if 0, it is set to 1.0/#features 
     67        (for ``Polynomial``, ``RBF`` and ``Sigmoid``) 
    6568    :type gamma: float 
    6669    :param coef0: kernel parameter (for ``Polynomial`` and ``Sigmoid``) 
     
    8184    :param probability: build a probability model 
    8285    :type probability: bool 
    83     :param shrinking: use shrinking heuristics  
     86    :param shrinking: use shrinking heuristics 
    8487    :type shrinking: bool 
    8588    :param normalization: normalize the input data prior to learning 
     
    8891    :param weight: a list of class weights 
    8992    :type weight: list 
     93    :param verbose: If `True` show training progress (default is `False`). 
     94    :type verbose: bool 
    9095 
    9196    Example: 
    92      
     97 
    9398        >>> import Orange 
    9499        >>> from Orange.classification import svm 
     
    101106        >>> print "AUC: %.4f" % scoring.AUC(results)[0] 
    102107        AUC: 0.9565 
    103          
    104      
     108 
    105109    """ 
    106110    __new__ = _orange__new__(_SVMLearner) 
     
    142146    def __call__(self, data, weight=0): 
    143147        """Construct a SVM classifier 
    144          
     148 
    145149        :param table: data with continuous features 
    146150        :type table: Orange.data.Table 
    147          
     151 
    148152        :param weight: ignored (required due to base class signature); 
    149153        """ 
     
    158162            isinstance(class_var, Orange.feature.Continuous): 
    159163            self.svm_type += 3 
    160             #raise AttributeError, "Cannot learn a discrete classifier from non descrete class data. Use EPSILON_SVR or NU_SVR for regression" 
     164 
    161165        if self.svm_type in [3, 4] and \ 
    162166            isinstance(class_var, Orange.feature.Discrete): 
    163167            self.svm_type -= 3 
    164             #raise AttributeError, "Cannot do regression on descrete class data. Use C_SVC or NU_SVC for classification" 
     168 
    165169        if self.kernel_type == kernels.Custom and not self.kernel_func: 
    166170            raise ValueError("Custom kernel function not supplied") 
    167171 
    168         import warnings 
    169  
    170172        nu = self.nu 
    171         if self.svm_type == SVMLearner.Nu_SVC: #is nu feasible 
     173        if self.svm_type == SVMLearner.Nu_SVC: 
     174            # Check if nu is feasible 
    172175            max_nu = self.max_nu(examples) 
    173176            if self.nu > max_nu: 
     
    181184                     "verbose", "cache_size", "eps"]: 
    182185            setattr(self.learner, name, getattr(self, name)) 
     186 
    183187        self.learner.nu = nu 
    184188        self.learner.set_weights(self.weight) 
     
    186190        if self.svm_type == SVMLearner.OneClass and self.probability: 
    187191            self.learner.probability = False 
    188             warnings.warn("One-class SVM probability output not supported yet.") 
     192            warnings.warn("One-class SVM probability output not supported.") 
    189193        return self.learn_classifier(examples) 
    190194 
     
    198202    def tune_parameters(self, data, parameters=None, folds=5, verbose=0, 
    199203                       progress_callback=None): 
    200         """Tune the ``parameters`` on the given ``data`` using  
     204        """Tune the ``parameters`` on the given ``data`` using 
    201205        internal cross validation. 
    202          
     206 
    203207        :param data: data for parameter tuning 
    204         :type data: Orange.data.Table  
     208        :type data: Orange.data.Table 
    205209        :param parameters: names of parameters to tune 
    206210            (default: ["nu", "C", "gamma"]) 
     
    212216        :param progress_callback: callback function for reporting progress 
    213217        :type progress_callback: callback function 
    214              
     218 
    215219        Here is example of tuning the `gamma` parameter using 
    216220        3-fold cross validation. :: 
     
    218222            svm = Orange.classification.svm.SVMLearner() 
    219223            svm.tune_parameters(table, parameters=["gamma"], folds=3) 
    220                      
     224 
    221225        """ 
    222226 
     
    233237        if self.svm_type in [SVMLearner.Nu_SVC, SVMLearner.Nu_SVR] \ 
    234238                    and "nu" in parameters: 
    235             numOfNuValues = 9 
    236239            if isinstance(data.domain.class_var, variable.Discrete): 
    237240                max_nu = max(self.max_nu(data) - 1e-7, 0.0) 
     
    242245        elif "C" in parameters: 
    243246            searchParams.append(("C", [2 ** a for a in  range(-5, 15, 2)])) 
     247 
    244248        if self.kernel_type == 2 and "gamma" in parameters: 
    245             searchParams.append(("gamma", [2 ** a for a in range(-5, 5, 2)] + [0])) 
     249            searchParams.append(("gamma", 
     250                                 [2 ** a for a in range(-5, 5, 2)] + [0]) 
     251                                ) 
    246252        tunedLearner = orngWrap.TuneMParameters(object=self, 
    247253                            parameters=searchParams, 
     
    249255                            returnWhat=orngWrap.TuneMParameters.returnLearner, 
    250256                            progressCallback=progress_callback 
    251                             if progress_callback else lambda i:None) 
     257                            if progress_callback else lambda i: None) 
    252258        tunedLearner(data, verbose=verbose) 
    253259        if normalization: 
     
    539545    def __reduce__(self): 
    540546        return SVMClassifier, (self.__wrapped,), dict(self.__dict__) 
    541      
     547 
    542548    def get_binary_classifier(self, c1, c2): 
    543549        """Return a binary classifier for classes `c1` and `c2`. 
     
    546552        if self.svm_type not in [SVMLearner.C_SVC, SVMLearner.Nu_SVC]: 
    547553            raise TypeError("SVM classification model expected.") 
    548          
     554 
    549555        c1 = int(self.class_var(c1)) 
    550556        c2 = int(self.class_var(c2)) 
    551                  
     557 
    552558        n_class = len(self.class_var.values) 
    553          
     559 
    554560        if c1 == c2: 
    555561            raise ValueError("Different classes expected.") 
    556          
     562 
    557563        bin_class_var = Orange.feature.Discrete("%s vs %s" % \ 
    558564                        (self.class_var.values[c1], self.class_var.values[c2]), 
    559565                        values=["0", "1"]) 
    560          
     566 
    561567        mult = 1.0 
    562568        if c1 > c2: 
    563569            c1, c2 = c2, c1 
    564570            mult = -1.0 
    565              
    566         classifier_i = n_class * (n_class - 1) / 2 - (n_class - c1 - 1) * (n_class - c1 - 2) / 2 - (n_class - c2) 
    567          
     571 
     572        classifier_i = n_class * (n_class - 1) / 2 - \ 
     573                       (n_class - c1 - 1) * (n_class - c1 - 2) / 2 - \ 
     574                       (n_class - c2) 
     575 
    568576        coef = self.coef[classifier_i] 
    569          
     577 
    570578        coef1 = [(mult * alpha, sv_i) for alpha, sv_i in coef \ 
    571579                 if int(self.support_vectors[sv_i].get_class()) == c1] 
    572580        coef2 = [(mult * alpha, sv_i) for alpha, sv_i in coef \ 
    573                  if int(self.support_vectors[sv_i].get_class()) == c2]  
    574          
     581                 if int(self.support_vectors[sv_i].get_class()) == c2] 
     582 
    575583        rho = mult * self.rho[classifier_i] 
    576          
    577         model = self._binary_libsvm_model_string(bin_class_var,  
     584 
     585        model = self._binary_libsvm_model_string(bin_class_var, 
    578586                                                 [coef1, coef2], 
    579587                                                 [rho]) 
    580          
     588 
    581589        all_sv = [self.support_vectors[sv_i] \ 
    582                   for c, sv_i in coef1 + coef2]  
    583                    
     590                  for c, sv_i in coef1 + coef2] 
     591 
    584592        all_sv = Orange.data.Table(all_sv) 
    585          
     593 
    586594        svm_classifier_type = type(self.__wrapped) 
    587          
     595 
    588596        # Build args for svm_classifier_type constructor 
    589597        args = (bin_class_var, self.examples, all_sv, model) 
    590          
     598 
    591599        if isinstance(svm_classifier_type, _SVMClassifierSparse): 
    592600            args = args + (int(self.__wrapped.use_non_meta),) 
    593          
     601 
    594602        if self.kernel_type == kernels.Custom: 
    595603            args = args + (self.kernel_func,) 
    596              
     604 
    597605        native_classifier = svm_classifier_type(*args) 
    598606        return SVMClassifier(native_classifier) 
    599      
     607 
    600608    def _binary_libsvm_model_string(self, class_var, coef, rho): 
    601609        """Return a libsvm formated model string for binary classifier 
    602610        """ 
    603611        import itertools 
    604          
     612 
    605613        if not isinstance(self.class_var, variable.Discrete): 
    606614            raise TypeError("SVM classification model expected") 
    607          
     615 
    608616        model = [] 
    609          
     617 
    610618        # Take the model up to nr_classes 
    611619        libsvm_model = self.__wrapped.get_model() 
     
    615623            else: 
    616624                model.append(line.rstrip()) 
    617          
    618         model.append("nr_class %i" % len(class_var.values)) 
     625        nr_class = len(class_var.values) 
     626        model.append("nr_class %i" % nr_class) 
    619627        model.append("total_sv %i" % reduce(add, [len(c) for c in coef])) 
    620628        model.append("rho " + " ".join(str(r) for r in rho)) 
    621         model.append("label " + " ".join(str(i) for i in range(len(class_var.values)))) 
     629        model.append("label " + " ".join(str(i) for i in range(nr_class))) 
    622630        # No probA and probB 
    623          
     631 
    624632        model.append("nr_sv " + " ".join(str(len(c)) for c in coef)) 
    625633        model.append("SV") 
    626          
     634 
    627635        def instance_to_svm(inst): 
    628636            values = [(i, float(inst[v])) \ 
     
    630638                      if not inst[v].is_special() and float(inst[v]) != 0.0] 
    631639            return " ".join("%i:%f" % (i + 1, v) for i, v in values) 
    632          
     640 
    633641        def sparse_instance_to_svm(inst): 
    634642            non_meta = [] 
     
    642650                    metas.append("%i:%f" % (base - m_id, float(value))) 
    643651            return " ".join(non_meta + metas) 
    644                  
     652 
    645653        if isinstance(self.__wrapped, _SVMClassifierSparse): 
    646654            converter = sparse_instance_to_svm 
    647655        else: 
    648656            converter = instance_to_svm 
    649          
     657 
    650658        if self.kernel_type == kernels.Custom: 
    651659            SV = libsvm_model.split("SV\n", 1)[1] 
    652660            # Get the sv indices (the last entry in the SV lines) 
    653             indices = [int(s.split(":")[-1]) for s in SV.splitlines() if s.strip()] 
    654              
    655             # Reorder the indices  
     661            indices = [int(s.split(":")[-1]) for s in SV.splitlines() \ 
     662                       if s.strip()] 
     663 
     664            # Reorder the indices 
    656665            label_map = self._get_libsvm_labels_map() 
    657666            start = 0 
     
    662671            reordered_indices = [reordered_indices[i] for i in label_map] 
    663672            indices = reduce(add, reordered_indices) 
    664              
     673 
    665674            for (c, sv_i) in itertools.chain(*coef): 
    666675                model.append("%f 0:%i" % (c, indices[sv_i])) 
    667676        else: 
    668677            for (c, sv_i) in itertools.chain(*coef): 
    669                 model.append("%f %s" % (c, converter(self.support_vectors[sv_i]))) 
    670                  
     678                model.append( 
     679                    "%f %s" % (c, converter(self.support_vectors[sv_i])) 
     680                ) 
     681 
    671682        model.append("") 
    672683        return "\n".join(model) 
    673          
     684 
    674685 
    675686SVMClassifier = Orange.utils.deprecated_members({ 
     
    678689    "getModel" : "get_model", 
    679690    }, wrap_methods=[])(SVMClassifier) 
    680      
     691 
     692 
    681693# Backwards compatibility (pickling) 
    682694SVMClassifierWrapper = SVMClassifier 
     695 
    683696 
    684697class SVMLearnerSparse(SVMLearner): 
     
    699712        if self.use_non_meta: 
    700713            dc = preprocess.DomainContinuizer() 
    701             dc.class_treatment = preprocess.DomainContinuizer.Ignore 
    702             dc.continuous_treatment = preprocess.DomainContinuizer.NormalizeBySpan 
    703             dc.multinomial_treatment = preprocess.DomainContinuizer.NValues 
     714            dc.class_treatment = dc.Ignore 
     715            dc.continuous_treatment = dc.NormalizeBySpan 
     716            dc.multinomial_treatment = dc.NValues 
    704717            newdomain = dc(data) 
    705718            data = data.translate(newdomain) 
    706719        return data 
    707720 
     721 
    708722class SVMLearnerEasy(SVMLearner): 
    709  
    710723    """A class derived from :obj:`SVMLearner` that automatically 
    711724    scales the data and performs parameter optimization using 
    712725    :func:`SVMLearner.tune_parameters`. The procedure is similar to 
    713726    that implemented in easy.py script from the LibSVM package. 
    714      
     727 
    715728    """ 
    716729 
     
    719732        :param folds: the number of folds to use in cross validation 
    720733        :type folds:  int 
    721          
     734 
    722735        :param verbose: verbosity of the tuning procedure. 
    723736        :type verbose: int 
    724          
     737 
    725738        ``kwargs`` is passed to :class:`SVMLearner` 
    726          
     739 
    727740        """ 
    728741        SVMLearner.__init__(self, **kwargs) 
    729742        self.folds = folds 
    730743        self.verbose = verbose 
    731          
     744 
    732745        self.learner = SVMLearner(**kwargs) 
    733746 
     
    740753        newdomain = transformer(data) 
    741754        newexamples = data.translate(newdomain) 
    742         #print newexamples[0] 
    743         params = {} 
     755 
    744756        parameters = [] 
    745         self.learner.normalization = False ## Normalization already done 
     757        self.learner.normalization = False  # Normalization already done 
    746758 
    747759        if self.svm_type in [1, 4]: 
    748             numOfNuValues = 9 
    749760            if self.svm_type == SVMLearner.Nu_SVC: 
    750761                max_nu = max(self.max_nu(newexamples) - 1e-7, 0.0) 
     
    756767            parameters.append(("C", [2 ** a for a in  range(-5, 15, 2)])) 
    757768        if self.kernel_type == 2: 
    758             parameters.append(("gamma", [2 ** a for a in range(-5, 5, 2)] + [0])) 
     769            parameters.append( 
     770                ("gamma", [2 ** a for a in range(-5, 5, 2)] + [0]) 
     771            ) 
     772 
    759773        import orngWrap 
    760774        tunedLearner = orngWrap.TuneMParameters(learner=self.learner, 
     
    763777 
    764778        return tunedLearner(newexamples, verbose=self.verbose) 
     779 
    765780 
    766781class SVMLearnerSparseEasy(SVMLearnerEasy): 
     
    775790""" 
    776791 
     792 
    777793class LinearSVMLearner(Orange.core.LinearLearner): 
    778794    """Train a linear SVM model.""" 
     
    785801    __new__ = _orange__new__(base=Orange.core.LinearLearner) 
    786802 
    787     def __init__(self, solver_type=L2R_L2LOSS_DUAL, C=1.0, eps=0.01,  
     803    def __init__(self, solver_type=L2R_L2LOSS_DUAL, C=1.0, eps=0.01, 
    788804                 bias=1.0, normalization=True, **kwargs): 
    789805        """ 
     
    791807            ``L2R_L2LOSS_DUAL``, ``L2R_L2LOSS``, 
    792808            ``L2R_L1LOSS_DUAL``, ``L1R_L2LOSS`` 
    793              
    794             The first part (``L2R`` or ``L1R``) is the regularization term  
     809 
     810            The first part (``L2R`` or ``L1R``) is the regularization term 
    795811            on the weight vector (squared or absolute norm respectively), 
    796812            the ``L1LOSS`` or ``L2LOSS`` indicate absolute or squared 
     
    798814            solved in the dual space (for more information see the 
    799815            documentation on `LIBLINEAR`_). 
    800          
     816 
    801817        :param C: Regularization parameter (default 1.0) 
    802818        :type C: float 
    803          
     819 
    804820        :param eps: Stopping criteria (default 0.01) 
    805821        :type eps: float 
    806          
     822 
    807823        :param bias: If non negative then each instance is appended a constant 
    808824            bias term (default 1.0). 
    809              
     825 
    810826        :type bias: float 
    811          
     827 
    812828        :param normalization: Normalize the input data prior to learning 
    813829            (default True) 
    814830        :type normalization: bool 
    815          
     831 
    816832        Example 
    817          
    818             >>> linear_svm = LinearSVMLearner(solver_type=LinearSVMLearner.L1R_L2LOSS, 
    819             ...                               C=2.0) 
     833 
     834            >>> linear_svm = LinearSVMLearner( 
     835            ...     solver_type=LinearSVMLearner.L1R_L2LOSS, 
     836            ...     C=2.0) 
    820837            ... 
    821          
     838 
    822839        """ 
    823840        self.solver_type = solver_type 
     
    831848        if self.solver_type not in [self.L2R_L2LOSS_DUAL, self.L2R_L2LOSS, 
    832849                self.L2R_L1LOSS_DUAL, self.L1R_L2LOSS]: 
    833             import warnings 
    834850            warnings.warn("""\ 
    835 Deprecated 'solver_type', use  
     851Deprecated 'solver_type', use 
    836852'Orange.classification.logreg.LibLinearLogRegLearner' 
    837853to build a logistic regression model using LIBLINEAR. 
     
    856872LinearLearner = LinearSVMLearner 
    857873 
     874 
    858875class MultiClassSVMLearner(Orange.core.LinearLearner): 
    859876    """ Multi-class SVM (Crammer and Singer) from the `LIBLINEAR`_ library. 
    860      
    861877    """ 
    862878    __new__ = _orange__new__(base=Orange.core.LinearLearner) 
     
    866882        """\ 
    867883        :param C: Regularization parameter (default 1.0) 
    868         :type C: float   
    869          
     884        :type C: float 
     885 
    870886        :param eps: Stopping criteria (default 0.01) 
    871887        :type eps: float 
    872          
     888 
    873889        :param bias: If non negative then each instance is appended a constant 
    874890            bias term (default 1.0). 
    875              
     891 
    876892        :type bias: float 
    877          
     893 
    878894        :param normalization: Normalize the input data prior to learning 
    879895            (default True) 
    880896        :type normalization: bool 
    881          
     897 
    882898        """ 
    883899        self.C = C 
     
    907923#TODO: Unified way to get attr weights for linear SVMs. 
    908924 
     925 
    909926def get_linear_svm_weights(classifier, sum=True): 
    910927    """Extract attribute weights from the linear SVM classifier. 
    911      
     928 
    912929    For multi class classification, the result depends on the argument 
    913930    :obj:`sum`. If ``True`` (default) the function computes the 
     
    916933    weights for each individual binary classifier (in the order of 
    917934    [class1 vs class2, class1 vs class3 ... class2 vs class3 ...]). 
    918          
     935 
    919936    """ 
    920937 
     
    932949 
    933950    if classifier.svm_type in [SVMLearner.C_SVC, SVMLearner.Nu_SVC]: 
    934         weights = []     
     951        weights = [] 
    935952        classes = classifier.class_var.values 
    936953        for i in range(len(classes) - 1): 
    937954            for j in range(i + 1, len(classes)): 
    938955                # Get the coef and rho values from the binary sub-classifier 
    939                 # Easier then using the full coef matrix (due to libsvm internal 
    940                 # class  reordering) 
     956                # Easier then using the full coef matrix (due to libsvm 
     957                # internal class  reordering) 
    941958                bin_classifier = classifier.get_binary_classifier(i, j) 
    942959                n_sv0 = bin_classifier.n_SV[0] 
     
    971988                    update_weights(weights, attr, to_float(SV[attr]), coef) 
    972989 
    973     return weights  
     990    return weights 
    974991 
    975992getLinearSVMWeights = get_linear_svm_weights 
     993 
    976994 
    977995def example_weighted_sum(example, weights): 
     
    9831001exampleWeightedSum = example_weighted_sum 
    9841002 
     1003 
    9851004class ScoreSVMWeights(Orange.feature.scoring.Score): 
    9861005    """ 
    9871006    Score a feature using squared weights of a linear SVM model. 
    988          
     1007 
    9891008    Example: 
    990      
     1009 
    9911010        >>> table = Orange.data.Table("vehicle.tab") 
    9921011        >>> score = Orange.classification.svm.ScoreSVMWeights() 
    993         >>> svm_scores = [(score(f, table), f) for f in table.domain.features]  
     1012        >>> svm_scores = [(score(f, table), f) for f in table.domain.features] 
    9941013        >>> for feature_score, feature in sorted(svm_scores, reverse=True): 
    9951014        ...     print "%-35s: %.3f" % (feature.name, feature_score) 
     
    10351054        """ 
    10361055        :param learner: Learner used for weight estimation 
    1037             (by default ``LinearSVMLearner(solver_type=L2R_L2LOSS_DUAL, C=1.0)`` 
     1056            (by default 
     1057            ``LinearSVMLearner(solver_type=L2R_L2LOSS_DUAL, C=1.0)`` 
    10381058            will be used for classification problems and 
    10391059            ``SVMLearner(svm_type=Epsilon_SVR, kernel_type=Linear, C=1.0, p=0.25)`` 
    1040             for regression problems. 
    1041              
    1042         :type learner: Orange.core.LinearLearner  
    1043          
     1060            for regression problems). 
     1061 
     1062        :type learner: Orange.core.LinearLearner 
     1063 
    10441064        """ 
    10451065        self.learner = learner 
     
    10561076            learner = self.learner 
    10571077        elif isinstance(data.domain.class_var, variable.Discrete): 
    1058             learner = LinearSVMLearner(solver_type= 
    1059                                 LinearSVMLearner.L2R_L2LOSS_DUAL, 
    1060                                 C=1.0) 
     1078            learner = LinearSVMLearner( 
     1079                            solver_type=LinearSVMLearner.L2R_L2LOSS_DUAL, 
     1080                            C=1.0) 
     1081 
    10611082        elif isinstance(data.domain.class_var, variable.Continuous): 
    10621083            learner = SVMLearner(svm_type=SVMLearner.Epsilon_SVR, 
     
    10801101 
    10811102    def _extract_weights(self, classifier, original_features): 
    1082         """Extract weights from a svm classifer (``SVMClassifier`` or a  
     1103        """Extract weights from a svm classifer (``SVMClassifier`` or a 
    10831104        ``LinearLearner`` instance). 
    1084          
     1105 
    10851106        """ 
    10861107        import numpy as np 
     
    10891110            if isinstance(classifier.class_var, variable.Continuous): 
    10901111                # The weights are in the the original non squared form 
    1091                 weights = dict((f, w ** 2) for f, w in weights.items())  
     1112                weights = dict((f, w ** 2) for f, w in weights.items()) 
    10921113        elif isinstance(classifier, Orange.core.LinearClassifier): 
    10931114            weights = np.array(classifier.weights) 
     
    11061127            elif f not in weights and f in sources: 
    11071128                dummys = sources[f] 
    1108                 # Use averege weight   
     1129                # Use averege weight 
    11091130                source_weights[f] = np.average([weights[d] for d in dummys]) 
    11101131            else: 
     
    11171138        variables (``source_variable`` or ``get_value_from.variable`` members) 
    11181139        back to the variables in ``vars``. 
    1119          
     1140 
    11201141        """ 
    11211142        source = defaultdict(list) 
    11221143        for var in vars: 
    1123             svar = None 
    11241144            if var.source_variable: 
    11251145                source[var.source_variable].append(var) 
     
    11271147                source[var.get_value_from.variable].append(var) 
    11281148            elif isinstance(var.get_value_from, Orange.core.ImputeClassifier): 
    1129                 source[var.get_value_from.classifier_from_var.variable].append(var) 
     1149                imputer = var.get_value_from.classifier_from_var 
     1150                source[imputer.variable].append(var) 
    11301151            else: 
    11311152                source[var].append(var) 
     
    11341155MeasureAttribute_SVMWeights = ScoreSVMWeights 
    11351156 
     1157 
    11361158class RFE(object): 
    11371159 
    11381160    """Iterative feature elimination based on weights computed by 
    11391161    linear SVM. 
    1140      
     1162 
    11411163    Example:: 
    1142      
     1164 
    11431165        >>> table = Orange.data.Table("promoters.tab") 
    11441166        >>> svm_l = Orange.classification.svm.SVMLearner( 
    1145         ...     kernel_type=Orange.classification.svm.kernels.Linear)  
    1146         ...  
     1167        ...     kernel_type=Orange.classification.svm.kernels.Linear) 
     1168        ... 
    11471169        >>> rfe = Orange.classification.svm.RFE(learner=svm_l) 
    11481170        >>> data_with_subset_of_features = rfe(table, 10) 
    11491171        >>> data_with_subset_of_features.domain 
    11501172        [p-45, p-36, p-35, p-34, p-33, p-31, p-18, p-12, p-10, p-04, y] 
    1151          
     1173 
    11521174    """ 
    11531175 
    11541176    def __init__(self, learner=None): 
    11551177        """ 
    1156         :param learner: A linear svm learner for use with  
     1178        :param learner: A linear svm learner for use with 
    11571179            :class:`ScoreSVMWeights`. 
    1158          
     1180 
    11591181        """ 
    11601182        self.learner = learner 
    11611183 
    1162     @Orange.utils.deprecated_keywords({"progressCallback": "progress_callback", "stopAt": "stop_at" }) 
     1184    @Orange.utils.deprecated_keywords({"progressCallback": "progress_callback", 
     1185                                       "stopAt": "stop_at"}) 
    11631186    def get_attr_scores(self, data, stop_at=0, progress_callback=None): 
    11641187        """Return a dictionary mapping attributes to scores. 
    11651188        A score is a step number at which the attribute 
    11661189        was removed from the recursive evaluation. 
    1167          
     1190 
    11681191        """ 
    11691192        iter = 1 
     
    11861209        return attr_scores 
    11871210 
    1188     @Orange.utils.deprecated_keywords({"numSelected": "num_selected", "progressCallback": "progress_callback"}) 
     1211    @Orange.utils.deprecated_keywords( 
     1212        {"numSelected": "num_selected", 
     1213         "progressCallback": "progress_callback"}) 
    11891214    def __call__(self, data, num_selected=20, progress_callback=None): 
    1190         """Return a new dataset with only `num_selected` best scoring attributes 
    1191          
     1215        """Return a new dataset with only `num_selected` best scoring 
     1216        attributes. 
     1217 
    11921218        :param data: Data 
    11931219        :type data: Orange.data.Table 
    1194          
     1220 
    11951221        :param num_selected: number of features to preserve 
    11961222        :type num_selected: int 
    1197          
     1223 
    11981224        """ 
    11991225        scores = self.get_attr_scores(data, progress_callback=progress_callback) 
     
    12071233        return data 
    12081234 
     1235 
    12091236RFE = Orange.utils.deprecated_members({ 
    12101237    "getAttrScores": "get_attr_scores"}, 
    12111238    wrap_methods=["get_attr_scores", "__call__"])(RFE) 
    12121239 
     1240 
    12131241def example_table_to_svm_format(table, file): 
    12141242    warnings.warn("Deprecated. Use table_to_svm_format", DeprecationWarning) 
     
    12171245exampleTableToSVMFormat = example_table_to_svm_format 
    12181246 
     1247 
    12191248def table_to_svm_format(data, file): 
    12201249    """Save :obj:`Orange.data.Table` to a format used by LibSVM. 
    1221      
     1250 
    12221251    :param data: Data 
    12231252    :type data: Orange.data.Table 
    12241253    :param file: file pointer 
    12251254    :type file: file 
    1226      
     1255 
    12271256    """ 
    12281257 
Note: See TracChangeset for help on using the changeset viewer.