Ignore:
Files:
1 added
20 edited

Legend:

Unmodified
Added
Removed
  • Orange/OrangeCanvas/orngCanvas.pyw

    r10581 r10691  
    478478 
    479479        localHelp = 0 
    480         self.menuHelp = QMenu("&Help", self) 
    481         if os.path.exists(os.path.join(self.orangeDir, r"doc/reference/default.htm")): self.menuHelp.addAction("Orange Help", self.menuOpenLocalOrangeHelp) 
    482         if os.path.exists(os.path.join(self.orangeDir, r"doc/catalog/index.html")): self.menuHelp.addAction("Orange Widget Catalog", self.menuOpenLocalWidgetCatalog) 
    483         if os.path.exists(os.path.join(self.orangeDir, r"doc/canvas/default.htm")): self.menuHelp.addAction("Orange Canvas Help", self.menuOpenLocalCanvasHelp) 
    484  
     480        self.menuHelp = QMenu("&Help", self)  
     481        self.menuHelp.addAction("Orange Online Reference", self.menuOpenOnlineOrangeReference) 
     482#        if os.path.exists(os.path.join(self.orangeDir, r"doc/catalog/index.html")): 
     483#            self.menuHelp.addAction("Orange Widget Catalog", self.menuOpenLocalWidgetCatalog) 
     484#        if os.path.exists(os.path.join(self.orangeDir, r"doc/canvas/default.htm")): 
     485#            self.menuHelp.addAction("Orange Canvas Help", self.menuOpenLocalCanvasHelp) 
    485486        self.menuHelp.addAction("Orange Online Widget Catalog", self.menuOpenOnlineOrangeHelp) 
    486         #self.menuHelp.addAction("Orange Canvas Online Help", self.menuOpenOnlineCanvasHelp) 
    487  
    488 #        if os.path.exists(os.path.join(self.orangeDir, r"updateOrange.py")): 
    489 #            self.menuHelp.addSeparator() 
    490 #            self.menuHelp.addAction("Check for updates", self.menuCheckForUpdates) 
    491              
     487        #self.menuHelp.addAction("Orange Canvas Online Help", self.menuOpenOnlineCanvasHelp)             
    492488        self.menuHelp.addSeparator() 
    493489        self.menuHelp.addAction("About Orange", self.menuItemAboutOrange) 
     
    605601    def readRecentFiles(self): 
    606602        self.menuRecent.clear() 
    607         if not self.settings.has_key("RecentFiles"): return 
    608         recentDocs = self.settings["RecentFiles"] 
     603        recentDocs = self.settings.get("RecentFiles", []) 
    609604 
    610605        # remove missing recent files 
     
    615610        recentDocs = recentDocs[:9] 
    616611        self.settings["RecentFiles"] = recentDocs 
    617  
    618         for i in range(len(recentDocs)): 
    619             shortName = "&" + str(i + 1) + " " + os.path.basename(recentDocs[i]) 
    620             self.menuRecent.addAction(shortName, lambda ind=i: self.openRecentFile(ind + 1)) 
     612         
     613        if len(recentDocs) == 0 : 
     614            self.menuRecent.addAction("None").setEnabled(False) 
     615        else :             
     616            for i in range(len(recentDocs)): 
     617                shortName = "&" + str(i + 1) + " " + os.path.basename(recentDocs[i]) 
     618                self.menuRecent.addAction(shortName, lambda ind=i: self.openRecentFile(ind),) 
    621619 
    622620    def openRecentFile(self, index): 
    623         if len(self.settings["RecentFiles"]) >= index: 
    624             self.schema.clear() 
    625             name = self.settings["RecentFiles"][index - 1] 
    626             dirname = os.path.dirname(name) 
    627             os.chdir(dirname) 
    628             self.schema.loadDocument(name) 
    629             self.addToRecentMenu(name) 
     621        if index < len(self.settings["RecentFiles"]): 
     622            name = self.settings["RecentFiles"][index] 
     623            if self.schema.saveBeforeClose(): 
     624                self.schema.clear() 
     625                dirname = os.path.dirname(name) 
     626                os.chdir(dirname) 
     627                self.schema.loadDocument(name) 
     628                self.addToRecentMenu(name) 
    630629 
    631630    def addToRecentMenu(self, name): 
     
    747746        webbrowser.open(os.path.join(self.orangeDir, "doc/canvas/default.htm")) 
    748747 
     748    def menuOpenOnlineOrangeReference(self): 
     749        import webbrowser 
     750        webbrowser.open("http://orange.biolab.si/doc/reference/") 
     751         
    749752    def menuOpenOnlineOrangeHelp(self): 
    750753        import webbrowser 
    751         webbrowser.open("http://orange.biolab.si/doc/catalog") 
     754        webbrowser.open("http://orange.biolab.si/doc/widgets/") 
    752755 
    753756    def menuOpenOnlineCanvasHelp(self): 
  • Orange/OrangeWidgets/Data/OWSave.py

    r10462 r10674  
    8181 
    8282#        filename, selectedFilter = QFileDialog.getSaveFileNameAndFilter(self, 'Save Orange Data File', startfile, 
    83 #                        self.dlgFormats, self.dlgFormats.split("\n")[0]) 
     83#                        self.dlgFormats, self.dlgFormats.splitlines()[0]) 
    8484#        filename = str(filename) 
    8585#       The preceding lines should work as per API, but do not; it's probably a PyQt bug as per March 2010. 
     
    8787#       (As a consequence, filter selection is not taken into account when appending a default extension.) 
    8888        filename, selectedFilter = QFileDialog.getSaveFileName(self, 'Save Orange Data File', startfile, 
    89                          self.dlgFormats), self.dlgFormats.split("\n")[0] 
     89                         self.dlgFormats), self.dlgFormats.splitlines()[0] 
    9090        filename = unicode(filename) 
    9191        if not filename or not os.path.split(filename)[1]: 
  • Orange/classification/logreg.py

    r10580 r10684  
    998998    return prob 
    999999 
    1000     
     1000 
     1001""" 
     1002Logistic regression learner from LIBLINEAR 
     1003""" 
     1004 
     1005from Orange.data import preprocess 
     1006class LibLinearLogRegLearner(Orange.core.LinearLearner): 
     1007    """A logistic regression learner from `LIBLINEAR`_. 
     1008     
     1009    Supports L2 regularized learning. 
     1010     
     1011    .. _`LIBLINEAR`: http://www.csie.ntu.edu.tw/~cjlin/liblinear/ 
     1012      
     1013    """ 
     1014 
     1015    L2R_LR = Orange.core.LinearLearner.L2R_LR 
     1016    L2R_LR_DUAL = Orange.core.LinearLearner.L2R_LR_Dual 
     1017 
     1018    __new__ = Orange.utils._orange__new__(base=Orange.core.LinearLearner) 
     1019 
     1020    def __init__(self, solver_type=L2R_LR, C=1.0, eps=0.01, normalization=True, 
     1021                 **kwargs): 
     1022        """ 
     1023        :param solver_type: One of the following class constants:  
     1024            ``L2_LR`` or``L2_LR_DUAL`` 
     1025         
     1026        :param C: Regularization parameter (default 1.0) 
     1027        :type C: float 
     1028         
     1029        :param eps: Stopping criteria (default 0.01) 
     1030        :type eps: float 
     1031         
     1032        :param normalization: Normalize the input data prior to learning 
     1033            (default True) 
     1034        :type normalization: bool 
     1035         
     1036        """ 
     1037        self.solver_type = solver_type 
     1038        self.C = C 
     1039        self.eps = eps 
     1040        self.normalization = normalization 
     1041 
     1042        for name, valu in kwargs.items(): 
     1043            setattr(self, name, value) 
     1044 
     1045    def __call__(self, data, weight_id=None): 
     1046        if not isinstance(data.domain.class_var, Orange.feature.Discrete): 
     1047            raise TypeError("Can only learn a discrete class.") 
     1048 
     1049        if data.domain.has_discrete_attributes(False) or self.normalization: 
     1050            dc = Orange.data.continuization.DomainContinuizer() 
     1051            dc.multinomial_treatment = dc.NValues 
     1052            dc.class_treatment = dc.Ignore 
     1053            dc.continuous_treatment = \ 
     1054                    dc.NormalizeByVariance if self.normalization else dc.Leave 
     1055            c_domain = dc(data)  
     1056            data = data.translate(c_domain) 
     1057        return super(LibLinearLogRegLearner, self).__call__(data, weight_id) 
  • Orange/classification/svm/__init__.py

    r10665 r10695  
    722722        self.learner = SVMLearnerSparse(**kwargs) 
    723723 
    724 def default_preprocessor(): 
    725     # Construct and return a default preprocessor for use by 
    726     # Orange.core.LinearLearner learner. 
    727     impute = preprocess.Impute() 
    728     cont = preprocess.Continuize(multinomialTreatment= 
    729                                    preprocess.DomainContinuizer.AsOrdinal) 
    730     preproc = preprocess.PreprocessorList(preprocessors= 
    731                                             [impute, cont]) 
    732     return preproc 
     724 
     725""" 
     726LIBLINEAR learners interface 
     727""" 
    733728 
    734729class LinearSVMLearner(Orange.core.LinearLearner): 
     
    738733    L2R_L2LOSS = Orange.core.LinearLearner.L2R_L2Loss_SVC 
    739734    L2R_L1LOSS_DUAL = Orange.core.LinearLearner.L2R_L1Loss_SVC_Dual 
    740     L2R_L1LOSS_DUAL = Orange.core.LinearLearner.L2R_L2Loss_SVC_Dual 
    741735    L1R_L2LOSS = Orange.core.LinearLearner.L1R_L2Loss_SVC 
    742736 
    743737    __new__ = _orange__new__(base=Orange.core.LinearLearner) 
    744738 
    745     def __init__(self, solver_type=L2R_L2LOSS_DUAL, C=1.0, eps=0.01, **kwargs): 
    746         """ 
    747         :param solver_type: One of the following class constants: ``LR2_L2LOSS_DUAL``, ``L2R_L2LOSS``, ``LR2_L1LOSS_DUAL``, ``L2R_L1LOSS`` or ``L1R_L2LOSS`` 
     739    def __init__(self, solver_type=L2R_L2LOSS_DUAL, C=1.0, eps=0.01,  
     740                 normalization=True, **kwargs): 
     741        """ 
     742        :param solver_type: One of the following class constants: 
     743            ``L2R_L2LOSS_DUAL``, ``L2R_L2LOSS``, 
     744            ``L2R_L1LOSS_DUAL``, ``L1R_L2LOSS`` 
     745             
     746            The first part (``L2R`` or ``L1R``) is the regularization term  
     747            on the weight vector (squared or absolute norm respectively), 
     748            the ``L1LOSS`` or ``L2LOSS`` indicate absolute or squared 
     749            loss function ``DUAL`` means the optimization problem is 
     750            solved in the dual space (for more information see the 
     751            documentation on `LIBLINEAR`_). 
    748752         
    749753        :param C: Regularization parameter (default 1.0) 
    750         :type C: float   
     754        :type C: float 
    751755         
    752756        :param eps: Stopping criteria (default 0.01) 
    753757        :type eps: float 
    754           
     758         
     759        :param normalization: Normalize the input data prior to learning 
     760            (default True) 
     761        :type normalization: bool 
     762         
     763        Example 
     764         
     765            >>> linear_svm = LinearSVMLearner(solver_type=LinearSVMLearner.L1R_L2LOSS, 
     766            ...                               C=2.0) 
     767            ... 
     768         
    755769        """ 
    756770        self.solver_type = solver_type 
    757771        self.eps = eps 
    758772        self.C = C 
     773        self.normalization = normalization 
     774 
    759775        for name, val in kwargs.items(): 
    760776            setattr(self, name, val) 
    761777        if self.solver_type not in [self.L2R_L2LOSS_DUAL, self.L2R_L2LOSS, 
    762                 self.L2R_L1LOSS_DUAL, self.L2R_L1LOSS_DUAL, self.L1R_L2LOSS]: 
    763             pass 
    764 #            raise ValueError("Invalid solver_type parameter.") 
    765  
    766         self.preproc = default_preprocessor() 
    767  
    768     def __call__(self, instances, weight_id=None): 
    769         instances = self.preproc(instances) 
    770         classifier = super(LinearSVMLearner, self).__call__(instances, weight_id) 
    771         return classifier 
     778                self.L2R_L1LOSS_DUAL, self.L1R_L2LOSS]: 
     779            import warnings 
     780            warnings.warn("""\ 
     781Deprecated 'solver_type', use  
     782'Orange.classification.logreg.LibLinearLogRegLearner' 
     783to build a logistic regression model using LIBLINEAR. 
     784""", 
     785                DeprecationWarning) 
     786 
     787    def __call__(self, data, weight_id=None): 
     788        if not isinstance(data.domain.class_var, variable.Discrete): 
     789            raise TypeError("Can only learn a discrete class.") 
     790 
     791        if data.domain.has_discrete_attributes(False) or self.normalization: 
     792            dc = Orange.data.continuization.DomainContinuizer() 
     793            dc.multinomial_treatment = dc.NValues 
     794            dc.class_treatment = dc.Ignore 
     795            dc.continuous_treatment = \ 
     796                    dc.NormalizeBySpan if self.normalization else dc.Leave 
     797            c_domain = dc(data) 
     798            data = data.translate(c_domain) 
     799 
     800        return super(LinearSVMLearner, self).__call__(data, weight_id) 
    772801 
    773802LinearLearner = LinearSVMLearner 
     
    775804class MultiClassSVMLearner(Orange.core.LinearLearner): 
    776805    """ Multi-class SVM (Crammer and Singer) from the `LIBLINEAR`_ library. 
     806     
    777807    """ 
    778808    __new__ = _orange__new__(base=Orange.core.LinearLearner) 
    779809 
    780     def __init__(self, C=1.0, eps=0.01, **kwargs): 
     810    def __init__(self, C=1.0, eps=0.01, normalization=True, **kwargs): 
    781811        """\ 
    782812        :param C: Regularization parameter (default 1.0) 
     
    786816        :type eps: float 
    787817         
     818        :param normalization: Normalize the input data prior to learning 
     819            (default True) 
     820        :type normalization: bool 
     821         
    788822        """ 
    789823        self.C = C 
    790824        self.eps = eps 
     825        self.normalization = normalization 
    791826        for name, val in kwargs.items(): 
    792827            setattr(self, name, val) 
    793828 
    794829        self.solver_type = self.MCSVM_CS 
    795         self.preproc = default_preprocessor() 
    796  
    797     def __call__(self, instances, weight_id=None): 
    798         instances = self.preproc(instances) 
    799         classifier = super(MultiClassSVMLearner, self).__call__(instances, weight_id) 
    800         return classifier 
     830 
     831    def __call__(self, data, weight_id=None): 
     832        if not isinstance(data.domain.class_var, variable.Discrete): 
     833            raise TypeError("Can only learn a discrete class.") 
     834 
     835        if data.domain.has_discrete_attributes(False) or self.normalization: 
     836            dc = Orange.data.continuization.DomainContinuizer() 
     837            dc.multinomial_treatment = dc.NValues 
     838            dc.class_treatment = dc.Ignore 
     839            dc.continuous_treatment = \ 
     840                    dc.NormalizeBySpan if self.normalization else dc.Leave 
     841            c_domain = dc(data) 
     842            data = data.translate(c_domain) 
     843 
     844        return super(MultiClassSVMLearner, self).__call__(data, weight_id) 
    801845 
    802846#TODO: Unified way to get attr weights for linear SVMs. 
     
    825869    SVs = classifier.support_vectors 
    826870    class_var = SVs.domain.class_var 
    827      
     871 
    828872    if classifier.svm_type in [SVMLearner.C_SVC, SVMLearner.Nu_SVC]: 
    829873        weights = []     
     
    838882                SVs = bin_classifier.support_vectors 
    839883                w = {} 
    840                  
     884 
    841885                for coef, sv_ind in bin_classifier.coef[0]: 
    842886                    SV = SVs[sv_ind] 
     
    846890                        if attr.varType == Orange.feature.Type.Continuous: 
    847891                            update_weights(w, attr, to_float(SV[attr]), coef) 
    848                      
     892 
    849893                weights.append(w) 
    850894        if sum: 
     
    857901            weights = dict(scores) 
    858902    else: 
    859 #        raise TypeError("SVM classification model expected.") 
    860903        weights = {} 
    861904        for coef, sv_ind in classifier.coef[0]: 
     
    866909                if attr.varType == Orange.feature.Type.Continuous: 
    867910                    update_weights(weights, attr, to_float(SV[attr]), coef) 
    868             
     911 
    869912    return weights  
    870      
     913 
    871914getLinearSVMWeights = get_linear_svm_weights 
    872915 
     
    881924class ScoreSVMWeights(Orange.feature.scoring.Score): 
    882925    """ 
    883     Score a feature by the squared sum of weights using a linear SVM 
    884     classifier. 
     926    Score a feature using squared weights of a linear SVM model. 
    885927         
    886928    Example: 
    887929     
     930        >>> table = Orange.data.Table("vehicle.tab") 
    888931        >>> score = Orange.classification.svm.ScoreSVMWeights() 
    889         >>> for feature in table.domain.features: 
    890         ...     print "%-35s: %.3f" % (feature.name, score(feature, table)) 
    891         compactness                        : 0.019 
    892         circularity                        : 0.025 
    893         distance circularity               : 0.007 
    894         radius ratio                       : 0.010 
    895         pr.axis aspect ratio               : 0.076 
    896         max.length aspect ratio            : 0.010 
    897         scatter ratio                      : 0.046 
    898         elongatedness                      : 0.095 
    899         pr.axis rectangularity             : 0.006 
    900         max.length rectangularity          : 0.030 
    901         scaled variance along major axis   : 0.001 
    902         scaled variance along minor axis   : 0.001 
    903         scaled radius of gyration          : 0.002 
    904         skewness about major axis          : 0.004 
    905         skewness about minor axis          : 0.003 
    906         kurtosis about minor axis          : 0.001 
    907         kurtosis about major axis          : 0.060 
    908         hollows ratio                      : 0.029 
    909          
    910                
    911     """ 
     932        >>> svm_scores = [(score(f, table), f) for f in table.domain.features]  
     933        >>> for feature_score, feature in sorted(svm_scores, reverse=True): 
     934        ...     print "%-35s: %.3f" % (feature.name, feature_score) 
     935        kurtosis about major axis          : 47.113 
     936        pr.axis aspect ratio               : 44.949 
     937        max.length rectangularity          : 39.748 
     938        radius ratio                       : 29.098 
     939        scatter ratio                      : 26.133 
     940        skewness about major axis          : 24.403 
     941        compactness                        : 20.432 
     942        hollows ratio                      : 20.109 
     943        max.length aspect ratio            : 15.757 
     944        scaled radius of gyration          : 15.242 
     945        scaled variance along minor axis   : 14.289 
     946        pr.axis rectangularity             : 9.882 
     947        circularity                        : 8.293 
     948        distance circularity               : 7.785 
     949        scaled variance along major axis   : 6.179 
     950        elongatedness                      : 4.038 
     951        skewness about minor axis          : 1.351 
     952        kurtosis about minor axis          : 0.760 
     953 
     954    """ 
     955 
     956    handles_discrete = True 
     957    handles_continuous = True 
     958    computes_thresholds = False 
     959    needs = Orange.feature.scoring.Score.Generator 
    912960 
    913961    def __new__(cls, attr=None, data=None, weight_id=None, **kwargs): 
     
    924972    def __init__(self, learner=None, **kwargs): 
    925973        """ 
    926         :param learner: Learner used for weight estimation  
    927             (default LinearSVMLearner(solver_type=L2Loss_SVM_Dual)) 
     974        :param learner: Learner used for weight estimation 
     975            (by default ``LinearSVMLearner(solver_type=L2R_L2LOSS_DUAL, C=1.0)`` 
     976            will be used for classification problems and 
     977            ``SVMLearner(svm_type=Epsilon_SVR, kernel_type=Linear, C=1.0, p=0.25)`` 
     978            for regression problems. 
     979             
    928980        :type learner: Orange.core.LinearLearner  
    929981         
    930982        """ 
    931         if learner: 
    932             self.learner = learner 
    933         else: 
    934             self.learner = LinearSVMLearner(solver_type= 
    935                                     LinearSVMLearner.L2R_L2LOSS_DUAL) 
    936  
    937         self._cached_examples = None 
     983        self.learner = learner 
     984        self._cached_data = None 
     985        self._cached_data_crc = None 
     986        self._cached_weights = None 
     987        self._cached_classifier = None 
    938988 
    939989    def __call__(self, attr, data, weight_id=None): 
    940         if data is self._cached_examples: 
     990        if attr not in data.domain.attributes: 
     991            raise ValueError("Feature %r is not from the domain." % attr) 
     992 
     993        if self.learner is not None: 
     994            learner = self.learner 
     995        elif isinstance(data.domain.class_var, variable.Discrete): 
     996            learner = LinearSVMLearner(solver_type= 
     997                                LinearSVMLearner.L2R_L2LOSS_DUAL, 
     998                                C=1.0) 
     999        elif isinstance(data.domain.class_var, variable.Continuous): 
     1000            learner = SVMLearner(svm_type=SVMLearner.Epsilon_SVR, 
     1001                                 kernel_type=kernels.Linear, 
     1002                                 C=1.0, p=0.25) 
     1003        else: 
     1004            raise TypeError("Cannot handle the class variable type %r" % \ 
     1005                                type(data.domain.class_var)) 
     1006 
     1007        crc = data.checksum() 
     1008        if data is self._cached_data and crc == self._cached_data_crc: 
    9411009            weights = self._cached_weights 
    9421010        else: 
    943             classifier = self.learner(data, weight_id) 
    944             self._cached_examples = data 
    945             import numpy 
    946             weights = numpy.array(classifier.weights) 
    947             weights = numpy.sum(weights ** 2, axis=0) 
    948             weights = dict(zip(data.domain.attributes, weights)) 
     1011            classifier = learner(data, weight_id) 
     1012            self._cached_data = data 
     1013            self._cached_data_crc = data.checksum() 
     1014            self._cached_classifier = classifier 
     1015            weights = self._extract_weights(classifier, data.domain.attributes) 
    9491016            self._cached_weights = weights 
    9501017        return weights.get(attr, 0.0) 
    9511018 
     1019    def _extract_weights(self, classifier, original_features): 
     1020        """Extract weights from a svm classifer (``SVMClassifier`` or a  
     1021        ``LinearLearner`` instance). 
     1022         
     1023        """ 
     1024        import numpy as np 
     1025        if isinstance(classifier, SVMClassifier): 
     1026            weights = get_linear_svm_weights(classifier, sum=True) 
     1027            if isinstance(classifier.class_var, variable.Continuous): 
     1028                # The weights are in the the original non squared form 
     1029                weights = dict((f, w ** 2) for f, w in weights.items())  
     1030        elif isinstance(classifier, Orange.core.LinearClassifier): 
     1031            weights = np.array(classifier.weights) 
     1032            weights = np.sum(weights ** 2, axis=0) 
     1033            weights = dict(zip(classifier.domain.attributes, weights)) 
     1034        else: 
     1035            raise TypeError("Don't know how to use classifier type %r" % \ 
     1036                                type(classifier)) 
     1037 
     1038        # collect dummy variables that were created for discrete features 
     1039        sources = self._collect_source(weights.keys()) 
     1040        source_weights = dict.fromkeys(original_features, 0.0) 
     1041        for f in original_features: 
     1042            if f in weights: 
     1043                source_weights[f] = weights[f] 
     1044            elif f not in weights and f in sources: 
     1045                dummys = sources[f] 
     1046                # Use averege weight   
     1047                source_weights[f] = np.average([weights[d] for d in dummys]) 
     1048            else: 
     1049                raise ValueError(f) 
     1050 
     1051        return source_weights 
     1052 
     1053    def _collect_source(self, vars): 
     1054        """ Given a list of variables ``var``, return a mapping from source 
     1055        variables (``source_variable`` or ``get_value_from.variable`` members) 
     1056        back to the variables in ``vars``. 
     1057         
     1058        """ 
     1059        source = defaultdict(list) 
     1060        for var in vars: 
     1061            svar = None 
     1062            if var.source_variable: 
     1063                source[var.source_variable].append(var) 
     1064            elif isinstance(var.get_value_from, Orange.core.ClassifierFromVar): 
     1065                source[var.get_value_from.variable].append(var) 
     1066            elif isinstance(var.get_value_from, Orange.core.ImputeClassifier): 
     1067                source[var.get_value_from.classifier_from_var.variable].append(var) 
     1068            else: 
     1069                source[var].append(var) 
     1070        return dict(source) 
     1071 
    9521072MeasureAttribute_SVMWeights = ScoreSVMWeights 
    9531073 
     
    9591079    Example:: 
    9601080     
    961         import Orange 
    962         table = Orange.data.Table("vehicle.tab") 
    963         l = Orange.classification.svm.SVMLearner( 
    964             kernel_type=Orange.classification.svm.kernels.Linear,  
    965             normalization=False) # normalization=False will not change the domain 
    966         rfe = Orange.classification.svm.RFE(l) 
    967         data_subset_of_features = rfe(table, 5) 
     1081        >>> table = Orange.data.Table("promoters.tab") 
     1082        >>> svm_l = Orange.classification.svm.SVMLearner( 
     1083        ...     kernel_type=Orange.classification.svm.kernels.Linear)  
     1084        ...  
     1085        >>> rfe = Orange.classification.svm.RFE(learner=svm_l) 
     1086        >>> data_with_subset_of_features = rfe(table, 10) 
     1087        >>> data_with_subset_of_features.domain 
     1088        [p-45, p-36, p-35, p-34, p-33, p-31, p-18, p-12, p-10, p-04, y] 
    9681089         
    9691090    """ 
    9701091 
    9711092    def __init__(self, learner=None): 
    972         self.learner = learner or SVMLearner(kernel_type= 
    973                             kernels.Linear, normalization=False) 
     1093        """ 
     1094        :param learner: A linear svm learner for use with  
     1095            :class:`ScoreSVMWeights`. 
     1096         
     1097        """ 
     1098        self.learner = learner 
    9741099 
    9751100    @Orange.utils.deprecated_keywords({"progressCallback": "progress_callback", "stopAt": "stop_at" }) 
     
    9821107        iter = 1 
    9831108        attrs = data.domain.attributes 
    984         attrScores = {} 
     1109        attr_scores = {} 
     1110        scorer = ScoreSVMWeights(learner=self.learner) 
    9851111 
    9861112        while len(attrs) > stop_at: 
    987             weights = get_linear_svm_weights(self.learner(data), sum=False) 
     1113            scores = [(scorer(attr, data), attr) for attr in attrs] 
    9881114            if progress_callback: 
    9891115                progress_callback(100. * iter / (len(attrs) - stop_at)) 
    990             score = dict.fromkeys(attrs, 0) 
    991             for w in weights: 
    992                 for attr, wAttr in w.items(): 
    993                     score[attr] += wAttr ** 2 
    994             score = score.items() 
    995             score.sort(lambda a, b:cmp(a[1], b[1])) 
    996             numToRemove = max(int(len(attrs) * 1.0 / (iter + 1)), 1) 
    997             for attr, s in  score[:numToRemove]: 
    998                 attrScores[attr] = len(attrScores) 
    999             attrs = [attr for attr, s in score[numToRemove:]] 
     1116            scores = sorted(scores) 
     1117            num_to_remove = max(int(len(attrs) * 1.0 / (iter + 1)), 1) 
     1118            for s, attr in  scores[:num_to_remove]: 
     1119                attr_scores[attr] = len(attr_scores) 
     1120            attrs = [attr for s, attr in scores[num_to_remove:]] 
    10001121            if attrs: 
    1001                 data = data.select(attrs + [data.domain.classVar]) 
     1122                data = data.select(attrs + [data.domain.class_var]) 
    10021123            iter += 1 
    1003         return attrScores 
     1124        return attr_scores 
    10041125 
    10051126    @Orange.utils.deprecated_keywords({"numSelected": "num_selected", "progressCallback": "progress_callback"}) 
     
    10091130        :param data: Data 
    10101131        :type data: Orange.data.Table 
     1132         
    10111133        :param num_selected: number of features to preserve 
    10121134        :type num_selected: int 
     
    10611183 
    10621184tableToSVMFormat = table_to_svm_format 
    1063  
    1064  
    1065 def _doctest_args(): 
    1066     """For unittest framework to test the docstrings. 
    1067     """ 
    1068     import Orange 
    1069     table = Orange.data.Table("vehicle.tab") 
    1070     extraglobs = locals() 
    1071     return {"extraglobs": extraglobs} 
  • Orange/multitarget/tree.py

    r10432 r10699  
    104104        :type feature: :class:`Orange.feature.Descriptor` 
    105105 
    106         :param data: The data set to be split using the given continuous feature. 
    107         :type data: :class:`Orange.data.Table` 
    108  
    109         :return: :obj:`list` of :obj:`tuples <tuple>` [(threshold, score, None),] 
     106        :param data: The data set to be split using the given continuous 
     107                     feature. 
     108        :type data: :class:`Orange.data.Table` 
     109 
     110        :return: :obj:`list` of :obj:`tuples <tuple>` 
     111                 [(threshold, score, None),] 
    110112        """ 
    111113 
     
    131133        :type feature: :class:`Orange.feature.Descriptor` 
    132134 
    133         :param data: The data set to be split using the given continuous feature. 
     135        :param data: The data set to be split using the given continuous 
     136                     feature. 
    134137        :type data: :class:`Orange.data.Table` 
    135138 
     
    173176    .. attribute:: node_learner 
    174177         
    175         Standard trees use :class:`~Orange.classification.majority.MajorityLearner` 
     178        Standard trees use 
     179        :class:`~Orange.classification.majority.MajorityLearner` 
    176180        to construct prediction models in the leaves of the tree. 
    177181        MultiTreeLearner uses the multi-target equivalent which can be  
    178182        obtained simply by wrapping the majority learner: 
    179183 
    180         :class:`Orange.multitarget.MultitargetLearner` (:class:`Orange.classification.majority.MajorityLearner()`). 
     184        :class:`Orange.multitarget.MultitargetLearner` 
     185        (:class:`Orange.classification.majority.MajorityLearner()`). 
    181186 
    182187    """ 
     
    189194        """ 
    190195         
    191         measure = MultitargetVariance() 
    192         node_learner = Orange.multitarget.MultitargetLearner( 
    193             Orange.classification.majority.MajorityLearner()) 
    194         Orange.classification.tree.TreeLearner.__init__( 
    195             self, measure=measure, node_learner=node_learner, **kwargs) 
     196        if 'measure' not in kwargs: 
     197            kwargs['measure'] = MultitargetVariance() 
     198        if 'node_learner' not in kwargs: 
     199            kwargs['node_learner'] = Orange.multitarget.MultitargetLearner( 
     200                Orange.classification.majority.MajorityLearner()) 
     201        Orange.classification.tree.TreeLearner.__init__(self, **kwargs) 
    196202 
    197203    def __call__(self, data, weight=0): 
     
    204210        """ 
    205211         
     212        # Use the class, if data does not have class_vars 
     213        if not data.domain.class_vars and data.domain.class_var: 
     214            dom = Orange.data.Domain(data.domain.features, 
     215                data.domain.class_var, class_vars=[data.domain.class_var]) 
     216            data = Orange.data.Table(dom, data) 
     217 
     218        # Check for missing class values in data 
    206219        for ins in data: 
    207220            for cval in ins.get_classes(): 
    208221                if cval.is_special(): 
    209222                    raise ValueError('Data has missing class values.') 
     223 
    210224        # TreeLearner does not work on class-less domains, 
    211225        # so we set the class if necessary 
    212         if data.domain.class_var is None: 
    213             data2 = Orange.data.Table(Orange.data.Domain( 
    214                 data.domain.attributes, data.domain.class_vars[0], 
    215                 class_vars=data.domain.class_vars), data) 
     226        if not data.domain.class_var and data.domain.class_vars: 
     227            dom = Orange.data.Domain(data.domain.features, 
     228                data.domain.class_vars[0], class_vars=data.domain.class_vars) 
     229            data = Orange.data.Table(dom, data) 
     230 
    216231        tree = Orange.classification.tree.TreeLearner.__call__( 
    217             self, data2, weight) 
     232            self, data, weight) 
    218233        return MultiTree(base_classifier=tree) 
    219234 
  • Orange/network/readwrite.py

    r10469 r10674  
    370370    f.close() 
    371371     
    372     content = content.split('\n') 
     372    content = content.splitlines() 
    373373    comments = (line for line in content if line.strip().startswith('#')) 
    374374    content = (line for line in content if not line.strip().startswith('#')) 
  • Orange/orng/addOnPack.py

    r10581 r10674  
    144144            QTextEdit.focusOutEvent(control, ev) 
    145145        for listEdit in [self.e_tags, self.e_aauthors, self.e_acontributors, self.e_aorganizations]: 
    146             listEdit.parseEntries = lambda control=listEdit: [entry for entry in map(lambda x: x.strip(), unicode(control.toPlainText()).split("\n")) if entry] 
     146            listEdit.parseEntries = lambda control=listEdit: [entry for entry in map(lambda x: x.strip(), unicode(control.toPlainText()).splitlines()) if entry] 
    147147            listEdit.focusOutEvent = formatList 
    148148     
  • Orange/orng/updateOrange.py

    r9671 r10674  
    296296            return {}, [], [] 
    297297 
    298         data = f.read().split("\n") 
     298        data = f.read().splitlines() 
    299299        versions = {} 
    300300        updateGroups = []; dontUpdateGroups = [] 
  • Orange/testing/regression/results_reference/ensemble-stacking.py.txt

    r10627 r10688  
    22   bayes: 0.858 
    33    tree: 0.688 
    4       lr: 0.764 
     4      lr: 0.868 
    55     knn: 0.839 
  • Orange/testing/regression/results_reference/svm-recursive-feature-elimination.py.txt

    r10009 r10697  
    11[alpha 0, alpha 7, alpha 14, alpha 21, alpha 28, alpha 35, alpha 42, alpha 49, alpha 56, alpha 63, alpha 70, alpha 77, alpha 84, alpha 91, alpha 98, alpha 105, alpha 112, alpha 119, Elu 0, Elu 30, Elu 60, Elu 90, Elu 120, Elu 150, Elu 180, Elu 210, Elu 240, Elu 270, Elu 300, Elu 330, Elu 360, Elu 390, cdc15 10, cdc15 30, cdc15 50, cdc15 70, cdc15 90, cdc15 110, cdc15 130, cdc15 150, cdc15 170, cdc15 190, cdc15 210, cdc15 230, cdc15 250, cdc15 270, cdc15 290, spo 0, spo 2, spo 5, spo 7, spo 9, spo 11, spo5 2, spo5 7, spo5 11, spo- early, spo- mid, heat 0, heat 10, heat 20, heat 40, heat 80, heat 160, dtt 15, dtt 30, dtt 60, dtt 120, cold 0, cold 20, cold 40, cold 160, diau a, diau b, diau c, diau d, diau e, diau f, diau g, function], {-3:gene} 
    2 [Elu 120, cdc15 150, spo 5, spo- early, spo- mid, heat 10, cold 160, diau e, diau f, diau g, function], {-3:gene} 
     2[alpha 112, Elu 0, Elu 120, spo5 11, spo- early, spo- mid, heat 20, diau e, diau f, diau g, function], {-3:gene} 
  • Orange/testing/unit/tests/test_linear.py

    r10655 r10687  
    22from Orange.testing import testing 
    33from Orange.testing.testing import datasets_driven 
    4 from Orange.classification.svm import LinearLearner 
     4from Orange.classification.svm import LinearSVMLearner 
    55try: 
    66    import unittest2 as unittest 
     
    1818        self.assertEquals(len(self.classifier.weights), 1) 
    1919 
    20     n_features = len(dataset.domain.attributes) 
    21     self.assert_(all(len(w) == n_features for w in self.classifier.weights)) 
    22  
    2320@datasets_driven(datasets=testing.CLASSIFICATION_DATASETS) 
    24 class TestLinearLearnerL2R_L2LOSS_DUAL(testing.LearnerTestCase): 
    25     LEARNER = LinearLearner(sover_type=LinearLearner.L2R_L2LOSS_DUAL) 
     21class TestLinearSVMLearnerL2R_L2LOSS_DUAL(testing.LearnerTestCase): 
     22    LEARNER = LinearSVMLearner(sover_type=LinearSVMLearner.L2R_L2LOSS_DUAL) 
    2623 
    2724    test_learner_on = test_learner_on 
    2825 
    2926@datasets_driven(datasets=testing.CLASSIFICATION_DATASETS) 
    30 class TestLinearLearnerL2R_L2LOSS(testing.LearnerTestCase): 
    31     LEARNER = LinearLearner(sover_type=LinearLearner.L2R_L2LOSS) 
     27class TestLinearSVMLearnerL2R_L2LOSS(testing.LearnerTestCase): 
     28    LEARNER = LinearSVMLearner(sover_type=LinearSVMLearner.L2R_L2LOSS) 
    3229    test_learner_on = test_learner_on 
    3330 
    3431@datasets_driven(datasets=testing.CLASSIFICATION_DATASETS) 
    35 class TestLinearLearnerL2R_L1LOSS_DUAL(testing.LearnerTestCase): 
    36     LEARNER = LinearLearner(sover_type=LinearLearner.L2R_L1LOSS_DUAL) 
     32class TestLinearSVMLearnerL2R_L1LOSS_DUAL(testing.LearnerTestCase): 
     33    LEARNER = LinearSVMLearner(sover_type=LinearSVMLearner.L2R_L1LOSS_DUAL) 
    3734    test_learner_on = test_learner_on 
    3835 
    3936@datasets_driven(datasets=testing.CLASSIFICATION_DATASETS) 
    40 class TestLinearLearnerL2R_L1LOSS(testing.LearnerTestCase): 
    41     LEARNER = LinearLearner(sover_type=LinearLearner.L2R_L2LOSS) 
     37class TestLinearSVMLearnerL2R_L1LOSS(testing.LearnerTestCase): 
     38    LEARNER = LinearSVMLearner(sover_type=LinearSVMLearner.L2R_L2LOSS) 
    4239    test_learner_on = test_learner_on 
    4340 
    4441@datasets_driven(datasets=testing.CLASSIFICATION_DATASETS) 
    45 class TestLinearLearnerL1R_L2LOSS(testing.LearnerTestCase): 
    46     LEARNER = LinearLearner(sover_type=LinearLearner.L1R_L2LOSS) 
     42class TestLinearSVMLearnerL1R_L2LOSS(testing.LearnerTestCase): 
     43    LEARNER = LinearSVMLearner(sover_type=LinearSVMLearner.L1R_L2LOSS) 
    4744    test_learner_on = test_learner_on 
    4845 
    4946@datasets_driven(datasets=testing.CLASSIFICATION_DATASETS) 
    50 class TestLinearLearnerL1R_L2LOSS(testing.LearnerTestCase): 
    51     LEARNER = LinearLearner(sover_type=LinearLearner.MCSVM_CS) 
     47class TestLinearSVMLearnerL1R_L2LOSS(testing.LearnerTestCase): 
     48    LEARNER = LinearSVMLearner(sover_type=LinearSVMLearner.MCSVM_CS) 
    5249    test_learner_on = test_learner_on 
    5350 
  • Orange/testing/unit/tests/test_logreg.py

    r10655 r10678  
    77from orngLR import LogRegLearner, Univariate_LogRegLearner, StepWiseFSS, StepWiseFSS_Filter 
    88 
     9from Orange.classification.logreg import LibLinearLogRegLearner 
    910def datasets_iter(): 
    1011    for name, (data,) in testing.datasets_iter(testing.CLASSIFICATION_DATASETS): 
     
    2526 
    2627 
    27 #@testing.data_driven(data_iter=datasets_iter()) 
    28 #class TestUniLogRegLearner(testing.LearnerTestCase): 
    29 #    LEARNER = Univariate_LogRegLearner 
    30 #    @testing.test_on_data 
    31 #    def test_learner_on(self, dataset): 
    32 #        """ Test LogRegLearner. 
    33 #        """ 
    34 #        if len(dataset) < len(dataset.domain.attributes): 
    35 #            raise unittest.SkipTest("No enough examples") 
    36 #        testing.LearnerTestCase.test_learner_on(self, dataset) 
    37  
    3828@testing.data_driven(data_iter=datasets_iter()) 
    3929class TestStepWiseFSS(unittest.TestCase): 
     
    4939        self.assertTrue([a1 == a2 for a1, a2 in zip(attrs, new_dataset.domain.attributes)]) 
    5040 
     41@testing.datasets_driven(datasets=testing.CLASSIFICATION_DATASETS) 
     42class TestLibLinearLogRegLearner(testing.LearnerTestCase): 
     43    LEARNER = LibLinearLogRegLearner 
     44    @testing.test_on_data 
     45    def test_learner_on(self, dataset): 
     46        """ Test LibLinearLogRegLearner. 
     47        """ 
     48        testing.LearnerTestCase.test_learner_on(self, dataset) 
     49 
    5150if __name__ == "__main__": 
    5251    unittest.main() 
  • Orange/testing/unit/tests/test_svm.py

    r10666 r10698  
    66import Orange 
    77from Orange.classification.svm import SVMLearner, SVMLearnerSparse, \ 
    8                             ScoreSVMWeights, LinearLearner, RFE, \ 
     8                            ScoreSVMWeights, LinearSVMLearner, \ 
     9                            MultiClassSVMLearner, RFE, \ 
    910                            get_linear_svm_weights, \ 
    1011                            example_weighted_sum 
     
    188189@datasets_driven(datasets=testing.CLASSIFICATION_DATASETS) 
    189190class TestLinLearner(testing.LearnerTestCase): 
    190     LEARNER = LinearLearner 
     191    LEARNER = LinearSVMLearner 
     192     
     193     
     194@datasets_driven(datasets=testing.CLASSIFICATION_DATASETS) 
     195class TestMCSVMLearner(testing.LearnerTestCase): 
     196    LEARNER = MultiClassSVMLearner 
    191197 
    192198 
     
    195201    MEASURE = ScoreSVMWeights() 
    196202     
    197  
     203@datasets_driven(datasets=testing.CLASSIFICATION_DATASETS) 
     204class TestScoreSVMWeightsWithMCSVM(testing.MeasureAttributeTestCase): 
     205    MEASURE = ScoreSVMWeights(learner=MultiClassSVMLearner()) 
     206     
    198207@datasets_driven(datasets=["iris"]) 
    199208class TestRFE(testing.DataTestCase): 
     
    215224def load_tests(loader, tests, ignore): 
    216225    import doctest 
    217     tests.addTests(doctest.DocTestSuite(svm, **svm._doctest_args())) 
     226    tests.addTests(doctest.DocTestSuite(svm)) 
    218227    return tests 
    219228 
  • docs/reference/rst/Orange.classification.svm.rst

    r10369 r10696  
    7878 
    7979.. autoclass:: Orange.classification.svm.RFE 
     80   :members: __init__, __call__ 
    8081 
    8182.. autoclass:: Orange.classification.svm.ScoreSVMWeights 
    82     :show-inheritance: 
     83   :members: __init__, __call__ 
     84   :show-inheritance: 
    8385  
    8486  
  • docs/reference/rst/Orange.ensemble.rst

    r10540 r10688  
    9595substantial (numbers show classification accuracy):: 
    9696 
    97    stacking: 0.934 
     97   stacking: 0.915 
    9898      bayes: 0.858 
    9999       tree: 0.688 
    100          lr: 0.764 
    101         knn: 0.830 
     100         lr: 0.868 
     101        knn: 0.839 
    102102 
    103103************* 
  • install-scripts/mac/update-all-scripts.sh

    r10562 r10681  
    2626curl --silent --output build-source.sh https://bitbucket.org/biolab/orange/raw/tip/install-scripts/mac/build-source.sh 
    2727curl --silent --output dailyrun-sources.sh https://bitbucket.org/biolab/orange/raw/tip/install-scripts/mac/dailyrun-sources.sh 
     28curl --silent --output build-mpkg.sh https://bitbucket.org/biolab/orange/raw/tip/install-scripts/mac/build-mpkg.sh 
    2829 
    2930chmod +x *.sh 
  • install-scripts/orngServer/orngServerFilesServer.py

    r6538 r10674  
    2121    s = open(userfilename, 'rt').read() 
    2222    umap = {} 
    23     for line in s.split('\n'): 
     23    for line in s.splitlines(): 
    2424        try: 
    2525            uname, passw = line.split(',') 
     
    6363        f.close() 
    6464        #print "CONT", cont 
    65         name, protection, datetime, title, tags = cont.split("\n") 
     65        name, protection, datetime, title, tags = cont.splitlines() 
    6666        tags = tags.split(";") 
    6767        self.set(name, protection, datetime, title, tags) 
  • install-scripts/orngServer/serverUpdateScripts/updatemiRNA.py

    r6538 r10674  
    5656     
    5757    for s in sections: 
    58         org = str(re.findall('ID\s*(\S*)\s*standard;',s.split('\n')[0])[0]).split('-')[0] 
     58        org = str(re.findall('ID\s*(\S*)\s*standard;',s.splitlines()[0])[0]).split('-')[0] 
    5959        fastprint(os.path.join(path,'%s_sections.txt' % org),'a',s+'//\n') 
    6060         
     
    111111            my_locs=[] # if it's [61..81] you have to take from 60 to 81. 
    112112             
    113             rows = s.split('\n') 
     113            rows = s.splitlines() 
    114114                 
    115115            for r in rows: 
     
    243243     
    244244    zf = zipfile.ZipFile(StringIO.StringIO(urllib.urlopen(tarscan_url).read())) 
    245     arch = zf.read(zf.namelist()[0]).split('\n')[1:] 
     245    arch = zf.read(zf.namelist()[0]).splitlines()[1:] 
    246246    arch.pop() 
    247247    mirnas = [a.split('\t')[3] for a in arch] 
     
    269269         
    270270if flag: 
    271     orgs_des = dict(zip([re.findall('ID\s*(\S{3,4})-\S*\s*standard;',l)[0] for l in data_webPage.split('\n') if l[0:2]=='ID'],[re.findall('DE\s*(.*)\s\S*.*\sstem[\s|-]loop',l)[0] for l in data_webPage.split('\n') if l[0:2]=='DE'])) 
     271    orgs_des = dict(zip([re.findall('ID\s*(\S{3,4})-\S*\s*standard;',l)[0] for l in data_webPage.splitlines() if l[0:2]=='ID'],[re.findall('DE\s*(.*)\s\S*.*\sstem[\s|-]loop',l)[0] for l in data_webPage.splitlines() if l[0:2]=='DE'])) 
    272272     
    273273    file_org = get_intoFiles(path,data_webPage) 
  • setup.py

    r10507 r10674  
    1515""" 
    1616 
    17 DOCLINES = __doc__.split("\n") 
     17DOCLINES = __doc__.splitlines() 
    1818 
    1919import os, sys         
     
    6060DOWNLOAD_URL        = "https://bitbucket.org/biolab/orange/downloads" 
    6161LICENSE             = 'GNU General Public License (GPL)' 
    62 CLASSIFIERS         = filter(None, CLASSIFIERS.split('\n')) 
     62CLASSIFIERS         = filter(None, CLASSIFIERS.splitlines()) 
    6363AUTHOR              = "Bioinformatics Laboratory, FRI UL" 
    6464AUTHOR_EMAIL        = "orange@fri.uni-lj.si" 
    65 KEYWORDS            = filter(None, KEYWORDS.split('\n')) 
     65KEYWORDS            = filter(None, KEYWORDS.splitlines()) 
    6666MAJOR               = 2 
    6767MINOR               = 5 
  • source/orange/liblinear_interface.cpp

    r9409 r10683  
    340340        raiseError("LIBLINEAR error: %s" , error_msg); 
    341341    } 
    342     //cout << "trainig" << endl; 
     342    /* The solvers in liblinear use rand() function. 
     343     * To make the results reporoducible we set the seed from the data table's 
     344     * crc 
     345     */ 
     346    PExampleTable extable(examples); 
     347    srand(extable->checkSum(false)); 
     348 
    343349    model *model = train(prob, param); 
    344350    destroy_problem(prob); 
     
    371377 
    372378PDistribution TLinearClassifier::classDistribution(const TExample &example){ 
     379    TExample new_example(domain, example); 
    373380    int numClass = get_nr_class(linmodel); 
    374381    map<int, int> indexMap; 
    375     feature_node *x = feature_nodeFromExample(example, indexMap, false); 
     382    feature_node *x = feature_nodeFromExample(new_example, indexMap, false); 
    376383 
    377384    int *labels = new int [numClass]; 
     
    392399 
    393400TValue TLinearClassifier::operator () (const TExample &example){ 
     401    TExample new_example(domain, example); 
    394402    int numClass = get_nr_class(linmodel); 
    395403    map<int, int> indexMap; 
    396     feature_node *x = feature_nodeFromExample(example, indexMap, false); 
    397  
    398     int predict_label = predict(linmodel ,x); 
     404    feature_node *x = feature_nodeFromExample(new_example, indexMap, false); 
     405 
     406    int predict_label = predict(linmodel, x); 
    399407    delete[] x; 
    400408    return TValue(predict_label); 
Note: See TracChangeset for help on using the changeset viewer.