Changeset 10634:1ebc6f592252 in orange


Ignore:
Timestamp:
03/23/12 20:45:56 (2 years ago)
Author:
mstajdohar
Branch:
default
Message:

Fixed some more obsolete stuff and added ignore DeprecationWarning on tutorial tests.

Files:
5 edited

Legend:

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

    r10621 r10634  
    275275        self.kernel_type = wrapped.kernel_type 
    276276        self.__wrapped = wrapped 
    277          
     277 
    278278        assert(type(wrapped) in [_SVMClassifier, _SVMClassifierSparse]) 
    279          
     279 
    280280        if self.svm_type in [SVMLearner.C_SVC, SVMLearner.Nu_SVC]: 
    281281            # Reorder the support vectors 
     
    290290        else: 
    291291            self.support_vectors = wrapped.support_vectors 
    292      
     292 
    293293    @property 
    294294    def coef(self): 
     
    303303        # for more information on how the coefs are stored by libsvm 
    304304        # internally. 
    305          
     305 
    306306        import numpy as np 
    307307        c_map = self._get_libsvm_bin_classifier_map() 
     
    320320                nj = label_map[j] 
    321321                bc_index, mult = c_map[p] 
    322                  
     322 
    323323                if ni > nj: 
    324324                    ni, nj = nj, ni 
    325                  
     325 
    326326                # Original class indices 
    327327                c1_range = range(libsvm_class_indices[ni], 
    328328                                 libsvm_class_indices[ni + 1]) 
    329                 c2_range = range(libsvm_class_indices[nj],  
     329                c2_range = range(libsvm_class_indices[nj], 
    330330                                 libsvm_class_indices[nj + 1]) 
    331                  
     331 
    332332                coef1 = mult * coef_array[nj - 1, c1_range] 
    333333                coef2 = mult * coef_array[ni, c2_range] 
    334                  
     334 
    335335                # Mapped class indices 
    336336                c1_range = range(class_indices[i], 
    337337                                 class_indices[i + 1]) 
    338                 c2_range = range(class_indices[j],  
     338                c2_range = range(class_indices[j], 
    339339                                 class_indices[j + 1]) 
    340340                if mult == -1.0: 
    341341                    c1_range, c2_range = c2_range, c1_range 
    342                      
     342 
    343343                nonzero1 = np.abs(coef1) > 0.0 
    344344                nonzero2 = np.abs(coef2) > 0.0 
    345                  
     345 
    346346                coef1 = coef1[nonzero1] 
    347347                coef2 = coef2[nonzero2] 
    348                  
     348 
    349349                c1_range = [sv_i for sv_i, nz in zip(c1_range, nonzero1) if nz] 
    350350                c2_range = [sv_i for sv_i, nz in zip(c2_range, nonzero2) if nz] 
    351                  
     351 
    352352                coef.append(list(zip(coef1, c1_range)) + list(zip(coef2, c2_range))) 
    353                  
     353 
    354354                p += 1 
    355355        return coef 
    356      
     356 
    357357    @property 
    358358    def rho(self): 
     
    362362        rho = self.__wrapped.rho 
    363363        return [rho[i] * m for i, m in c_map] 
    364      
     364 
    365365    @property 
    366366    def n_SV(self): 
     
    369369        if self.__wrapped.n_SV is not None: 
    370370            c_map = self._get_libsvm_labels_map() 
    371             n_SV= self.__wrapped.n_SV 
     371            n_SV = self.__wrapped.n_SV 
    372372            return [n_SV[i] for i in c_map] 
    373373        else: 
    374374            return None 
    375      
     375 
    376376    @property 
    377377    def prob_a(self): 
     
    383383        else: 
    384384            return None 
    385      
     385 
    386386    @property 
    387387    def prob_b(self): 
     
    393393        else: 
    394394            return None 
    395      
     395 
    396396    def __call__(self, instance, what=Orange.core.GetValue): 
    397397        """Classify a new ``instance`` 
     
    417417        c_map = self._get_libsvm_bin_classifier_map() 
    418418        return [dec_values[i] * m for i, m in c_map] 
    419          
     419 
    420420    def get_model(self): 
    421421        """Return a string representing the model in the libsvm model format. 
    422422        """ 
    423423        return self.__wrapped.get_model() 
    424      
     424 
    425425    def _get_libsvm_labels_map(self): 
    426426        """Get the internal libsvm label mapping.  
     
    451451                bin_c_map.append((cls_index, mult)) 
    452452        return bin_c_map 
    453                  
     453 
    454454    def __reduce__(self): 
    455455        return SVMClassifier, (self.__wrapped,), dict(self.__dict__) 
    456      
     456 
    457457    def get_binary_classifier(self, c1, c2): 
    458458        """Return a binary classifier for classes `c1` and `c2`. 
     
    461461        if self.svm_type not in [SVMLearner.C_SVC, SVMLearner.Nu_SVC]: 
    462462            raise TypeError("SVM classification model expected.") 
    463          
     463 
    464464        c1 = int(self.class_var(c1)) 
    465465        c2 = int(self.class_var(c2)) 
    466                  
     466 
    467467        n_class = len(self.class_var.values) 
    468          
     468 
    469469        if c1 == c2: 
    470470            raise ValueError("Different classes expected.") 
    471          
     471 
    472472        bin_class_var = Orange.feature.Discrete("%s vs %s" % \ 
    473473                        (self.class_var.values[c1], self.class_var.values[c2]), 
    474474                        values=["0", "1"]) 
    475          
     475 
    476476        mult = 1.0 
    477477        if c1 > c2: 
    478478            c1, c2 = c2, c1 
    479479            mult = -1.0 
    480              
     480 
    481481        classifier_i = n_class * (n_class - 1) / 2 - (n_class - c1 - 1) * (n_class - c1 - 2) / 2 - (n_class - c2) 
    482          
     482 
    483483        coef = self.coef[classifier_i] 
    484          
     484 
    485485        coef1 = [(mult * alpha, sv_i) for alpha, sv_i in coef \ 
    486486                 if int(self.support_vectors[sv_i].get_class()) == c1] 
    487487        coef2 = [(mult * alpha, sv_i) for alpha, sv_i in coef \ 
    488                  if int(self.support_vectors[sv_i].get_class()) == c2]  
    489          
     488                 if int(self.support_vectors[sv_i].get_class()) == c2] 
     489 
    490490        rho = mult * self.rho[classifier_i] 
    491          
    492         model = self._binary_libsvm_model_string(bin_class_var,  
     491 
     492        model = self._binary_libsvm_model_string(bin_class_var, 
    493493                                                 [coef1, coef2], 
    494494                                                 [rho]) 
    495          
     495 
    496496        all_sv = [self.support_vectors[sv_i] \ 
    497                   for c, sv_i in coef1 + coef2]  
    498                    
     497                  for c, sv_i in coef1 + coef2] 
     498 
    499499        all_sv = Orange.data.Table(all_sv) 
    500          
     500 
    501501        svm_classifier_type = type(self.__wrapped) 
    502          
     502 
    503503        # Build args for svm_classifier_type constructor 
    504504        args = (bin_class_var, self.examples, all_sv, model) 
    505          
     505 
    506506        if isinstance(svm_classifier_type, _SVMClassifierSparse): 
    507507            args = args + (int(self.__wrapped.use_non_meta),) 
    508          
     508 
    509509        if self.kernel_type == kernels.Custom: 
    510510            args = args + (self.kernel_func,) 
    511              
     511 
    512512        native_classifier = svm_classifier_type(*args) 
    513513        return SVMClassifier(native_classifier) 
    514      
     514 
    515515    def _binary_libsvm_model_string(self, class_var, coef, rho): 
    516516        """Return a libsvm formated model string for binary classifier 
    517517        """ 
    518518        import itertools 
    519          
     519 
    520520        model = [] 
    521                  
     521 
    522522        # Take the model up to nr_classes 
    523523        libsvm_model = self.__wrapped.get_model() 
     
    527527            else: 
    528528                model.append(line.rstrip()) 
    529          
     529 
    530530        model.append("nr_class %i" % len(class_var.values)) 
    531531        model.append("total_sv %i" % reduce(add, [len(c) for c in coef])) 
     
    533533        model.append("label " + " ".join(str(i) for i in range(len(class_var.values)))) 
    534534        # No probA and probB 
    535          
     535 
    536536        model.append("nr_sv " + " ".join(str(len(c)) for c in coef)) 
    537537        model.append("SV") 
    538          
     538 
    539539        def instance_to_svm(inst): 
    540540            values = [(i, float(inst[v])) \ 
     
    542542                      if not inst[v].is_special() and float(inst[v]) != 0.0] 
    543543            return " ".join("%i:%f" % (i + 1, v) for i, v in values) 
    544          
     544 
    545545        def sparse_instance_to_svm(inst): 
    546546            non_meta = [] 
     
    554554                    metas.append("%i:%f" % (base - m_id, float(value))) 
    555555            return " ".join(non_meta + metas) 
    556                  
     556 
    557557        if isinstance(self.__wrapped, _SVMClassifierSparse): 
    558558            converter = sparse_instance_to_svm 
    559559        else: 
    560560            converter = instance_to_svm 
    561          
     561 
    562562        if self.kernel_type == kernels.Custom: 
    563563            SV = libsvm_model.split("SV\n", 1)[1] 
    564564            # Get the sv indices (the last entry in the SV lines) 
    565565            indices = [int(s.split(":")[-1]) for s in SV.splitlines() if s.strip()] 
    566              
     566 
    567567            # Reorder the indices  
    568568            label_map = self._get_libsvm_labels_map() 
     
    574574            reordered_indices = [reordered_indices[i] for i in label_map] 
    575575            indices = reduce(add, reordered_indices) 
    576              
     576 
    577577            for (c, sv_i) in itertools.chain(*coef): 
    578578                model.append("%f 0:%i" % (c, indices[sv_i])) 
     
    580580            for (c, sv_i) in itertools.chain(*coef): 
    581581                model.append("%f %s" % (c, converter(self.support_vectors[sv_i]))) 
    582                  
     582 
    583583        model.append("") 
    584584        return "\n".join(model) 
    585          
     585 
    586586 
    587587SVMClassifier = Orange.utils.deprecated_members({ 
     
    590590    "getModel" : "get_model", 
    591591    }, wrap_methods=[])(SVMClassifier) 
    592      
     592 
    593593# Backwards compatibility (pickling) 
    594594SVMClassifierWrapper = SVMClassifier 
     
    659659            parameters.append(("gamma", [2 ** a for a in range(-5, 5, 2)] + [0])) 
    660660        import orngWrap 
    661         tunedLearner = orngWrap.TuneMParameters(object=self.learner, 
     661        tunedLearner = orngWrap.TuneMParameters(learner=self.learner, 
    662662                                                parameters=parameters, 
    663663                                                folds=self.folds) 
    664664 
    665         return tunedLearner(newexamples,verbose=self.verbose) 
     665        return tunedLearner(newexamples, verbose=self.verbose) 
    666666 
    667667class SVMLearnerSparseEasy(SVMLearnerEasy): 
     
    777777    if classifier.svm_type not in [SVMLearner.C_SVC, SVMLearner.Nu_SVC]: 
    778778        raise TypeError("SVM classification model expected.") 
    779      
     779 
    780780    classes = classifier.class_var.values 
    781      
     781 
    782782    for i in range(len(classes) - 1): 
    783783        for j in range(i + 1, len(classes)): 
     
    789789            SVs = bin_classifier.support_vectors 
    790790            w = {} 
    791              
     791 
    792792            for alpha, sv_ind in bin_classifier.coef[0]: 
    793793                SV = SVs[sv_ind] 
     
    797797                    if attr.varType == Orange.feature.Type.Continuous: 
    798798                        update_weights(w, attr, to_float(SV[attr]), alpha) 
    799                  
     799 
    800800            weights.append(w) 
    801              
     801 
    802802    if sum: 
    803803        scores = defaultdict(float) 
  • Orange/doc/reference/c45.py

    r9671 r10634  
    1919    print tree(i), i.getclass() 
    2020 
    21 print "\n\nC4.5 with minObjs=100" 
    22 tree = orange.C45Learner(data, minObjs=100) 
     21print "\n\nC4.5 with min_objs=100" 
     22tree = orange.C45Learner(data, min_objs=100) 
    2323for i in data[:5]: 
    2424    print tree(i), i.getclass() 
  • Orange/testing/regression/xtest_one.py

    r10628 r10634  
    8686 
    8787# when testing backward compatibility support suppress deprecation warnings 
    88 if "tests_20" in t__outputsdir: 
     88if "tests_20" in t__outputsdir or "tutorial" in t__outputsdir: 
    8989    t__warnings.filterwarnings("ignore", category=DeprecationWarning) 
    9090 
  • docs/reference/rst/code/optimization-tuning1.py

    r10077 r10634  
    66                           parameter="min_subset", 
    77                           values=[1, 2, 3, 4, 5, 10, 15, 20], 
    8                            evaluate = Orange.evaluation.scoring.AUC, verbose=2) 
     8                           evaluate=Orange.evaluation.scoring.AUC, verbose=2) 
    99classifier = tuner(voting) 
    1010 
     
    2020learner = Orange.classification.tree.TreeLearner(min_subset=10).instance() 
    2121voting = Orange.data.Table("voting") 
    22 tuner = Orange.optimization.Tune1Parameter(object=learner, 
    23                     parameter=["split.continuous_split_constructor.min_subset",  
     22tuner = Orange.optimization.Tune1Parameter(learner=learner, 
     23                    parameter=["split.continuous_split_constructor.min_subset", 
    2424                               "split.discrete_split_constructor.min_subset"], 
    2525                    values=[1, 2, 3, 4, 5, 10, 15, 20], 
    26                     evaluate = Orange.evaluation.scoring.AUC, verbose=2) 
     26                    evaluate=Orange.evaluation.scoring.AUC, verbose=2) 
    2727 
    2828classifier = tuner(voting) 
  • docs/reference/rst/code/statExamples.py

    r10633 r10634  
    113113print 
    114114print "AUC for detecting class 'van' in 'vehicle'" 
    115 AUCs = Orange.evaluation.scoring.AUC_single(resVeh, class_index=vehicle.domain.class_var.values.index("van")) 
     115AUCs = Orange.evaluation.scoring.AUC_for_single_class(resVeh, class_index=vehicle.domain.class_var.values.index("van")) 
    116116print "%5.3f\t%5.3f\t%5.3f" % tuple(AUCs) 
    117117 
Note: See TracChangeset for help on using the changeset viewer.