Ignore:
Files:
1 added
17 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 r10682  
    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 
    733  
     724 
     725""" 
     726LIBLINEAR learners interface 
     727""" 
    734728class LinearSVMLearner(Orange.core.LinearLearner): 
    735729    """Train a linear SVM model.""" 
     
    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            ``LR2_L2LOSS_DUAL``, ``L2R_L2LOSS``,  
     744            ``LR2_L1LOSS_DUAL``, ``L2R_L1LOSS`` or  
     745            ``L1R_L2LOSS`` 
    748746         
    749747        :param C: Regularization parameter (default 1.0) 
     
    752750        :param eps: Stopping criteria (default 0.01) 
    753751        :type eps: float 
    754           
     752         
     753        :param normalization: Normalize the input data prior to learning 
     754            (default True) 
     755        :type normalization: bool 
     756         
    755757        """ 
    756758        self.solver_type = solver_type 
    757759        self.eps = eps 
    758760        self.C = C 
     761        self.normalization = normalization 
     762 
    759763        for name, val in kwargs.items(): 
    760764            setattr(self, name, val) 
    761765        if self.solver_type not in [self.L2R_L2LOSS_DUAL, self.L2R_L2LOSS, 
    762766                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 
     767            import warnings 
     768            warnings.warn("""\ 
     769Deprecated 'solver_type', use  
     770'Orange.classification.logreg.LibLinearLogRegLearner' 
     771to build a logistic regression model using LIBLINEAR. 
     772""", 
     773                DeprecationWarning) 
     774 
     775    def __call__(self, data, weight_id=None): 
     776        if not isinstance(data.domain.class_var, variable.Discrete): 
     777            raise TypeError("Can only learn a discrete class.") 
     778 
     779        if data.domain.has_discrete_attributes(False) or self.normalization: 
     780            dc = Orange.data.continuization.DomainContinuizer() 
     781            dc.multinomial_treatment = dc.NValues 
     782            dc.class_treatment = dc.Ignore 
     783            dc.continuous_treatment = \ 
     784                    dc.NormalizeBySpan if self.normalization else dc.Leave 
     785            c_domain = dc(data) 
     786            data = data.translate(c_domain) 
     787 
     788        return super(LinearSVMLearner, self).__call__(data, weight_id) 
    772789 
    773790LinearLearner = LinearSVMLearner 
     
    778795    __new__ = _orange__new__(base=Orange.core.LinearLearner) 
    779796 
    780     def __init__(self, C=1.0, eps=0.01, **kwargs): 
     797    def __init__(self, C=1.0, eps=0.01, normalization=True, **kwargs): 
    781798        """\ 
    782799        :param C: Regularization parameter (default 1.0) 
     
    786803        :type eps: float 
    787804         
     805        :param normalization: Normalize the input data prior to learning 
     806            (default True) 
     807        :type normalization: bool 
     808         
    788809        """ 
    789810        self.C = C 
    790811        self.eps = eps 
     812        self.normalization = normalization 
    791813        for name, val in kwargs.items(): 
    792814            setattr(self, name, val) 
    793815 
    794816        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 
     817 
     818    def __call__(self, data, weight_id=None): 
     819        if not isinstance(data.domain.class_var, variable.Discrete): 
     820            raise TypeError("Can only learn a discrete class.") 
     821 
     822        if data.domain.has_discrete_attributes(False) or self.normalization: 
     823            dc = Orange.data.continuization.DomainContinuizer() 
     824            dc.multinomial_treatment = dc.NValues 
     825            dc.class_treatment = dc.Ignore 
     826            dc.continuous_treatment = \ 
     827                    dc.NormalizeBySpan if self.normalization else dc.Leave 
     828            c_domain = dc(data) 
     829            data = data.translate(c_domain) 
     830 
     831        return super(MultiClassSVMLearner, self).__call__(data, weight_id) 
    801832 
    802833#TODO: Unified way to get attr weights for linear SVMs. 
     
    825856    SVs = classifier.support_vectors 
    826857    class_var = SVs.domain.class_var 
    827      
     858 
    828859    if classifier.svm_type in [SVMLearner.C_SVC, SVMLearner.Nu_SVC]: 
    829860        weights = []     
     
    838869                SVs = bin_classifier.support_vectors 
    839870                w = {} 
    840                  
     871 
    841872                for coef, sv_ind in bin_classifier.coef[0]: 
    842873                    SV = SVs[sv_ind] 
     
    846877                        if attr.varType == Orange.feature.Type.Continuous: 
    847878                            update_weights(w, attr, to_float(SV[attr]), coef) 
    848                      
     879 
    849880                weights.append(w) 
    850881        if sum: 
     
    857888            weights = dict(scores) 
    858889    else: 
    859 #        raise TypeError("SVM classification model expected.") 
    860890        weights = {} 
    861891        for coef, sv_ind in classifier.coef[0]: 
     
    866896                if attr.varType == Orange.feature.Type.Continuous: 
    867897                    update_weights(weights, attr, to_float(SV[attr]), coef) 
    868             
     898 
    869899    return weights  
    870      
     900 
    871901getLinearSVMWeights = get_linear_svm_weights 
    872902 
     
    881911class ScoreSVMWeights(Orange.feature.scoring.Score): 
    882912    """ 
    883     Score a feature by the squared sum of weights using a linear SVM 
    884     classifier. 
     913    Score a feature using squares of weights of a linear SVM 
     914    model. 
    885915         
    886916    Example: 
    887917     
    888918        >>> 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     """ 
     919        >>> svm_scores = [(score(f, table), f) for f in table.domain.features]  
     920        >>> for feature_score, feature in sorted(svm_scores, reverse=True): 
     921        ...     print "%-35s: %.3f" % (feature.name, feature_score) 
     922        kurtosis about major axis          : 47.113 
     923        pr.axis aspect ratio               : 44.949 
     924        max.length rectangularity          : 39.748 
     925        radius ratio                       : 29.098 
     926        scatter ratio                      : 26.133 
     927        skewness about major axis          : 24.403 
     928        compactness                        : 20.432 
     929        hollows ratio                      : 20.109 
     930        max.length aspect ratio            : 15.757 
     931        scaled radius of gyration          : 15.242 
     932        scaled variance along minor axis   : 14.289 
     933        pr.axis rectangularity             : 9.882 
     934        circularity                        : 8.293 
     935        distance circularity               : 7.785 
     936        scaled variance along major axis   : 6.179 
     937        elongatedness                      : 4.038 
     938        skewness about minor axis          : 1.351 
     939        kurtosis about minor axis          : 0.760 
     940 
     941    """ 
     942 
     943    handles_discrete = True 
     944    handles_continuous = True 
     945    computes_thresholds = False 
     946    needs = Orange.feature.scoring.Score.Generator 
    912947 
    913948    def __new__(cls, attr=None, data=None, weight_id=None, **kwargs): 
     
    924959    def __init__(self, learner=None, **kwargs): 
    925960        """ 
    926         :param learner: Learner used for weight estimation  
    927             (default LinearSVMLearner(solver_type=L2Loss_SVM_Dual)) 
     961        :param learner: Learner used for weight estimation 
     962            (by default ``LinearSVMLearner(solver_type=L2R_L2LOSS_DUAL, C=1.0)`` 
     963            will be used for classification problems and 
     964            ``SVMLearner(svm_type=Epsilon_SVR, kernel_type=Linear, C=1.0, p=0.25)`` 
     965            for regression problems. 
     966             
    928967        :type learner: Orange.core.LinearLearner  
    929968         
    930969        """ 
    931         if learner: 
    932             self.learner = learner 
    933         else: 
    934             self.learner = LinearSVMLearner(solver_type= 
    935                                     LinearSVMLearner.L2R_L2LOSS_DUAL) 
    936  
     970        self.learner = learner 
    937971        self._cached_examples = None 
    938972 
    939973    def __call__(self, attr, data, weight_id=None): 
     974        if attr not in data.domain.attributes: 
     975            raise ValueError("Feature %r is not from the domain." % attr) 
     976 
     977        if self.learner is not None: 
     978            learner = self.learner 
     979        elif isinstance(data.domain.class_var, variable.Discrete): 
     980            learner = LinearSVMLearner(solver_type= 
     981                                LinearSVMLearner.L2R_L2LOSS_DUAL, 
     982                                C=1.0) 
     983        elif isinstance(data.domain.class_var, variable.Continuous): 
     984            learner = SVMLearner(svm_type=SVMLearner.Epsilon_SVR, 
     985                                 kernel_type=kernels.Linear, 
     986                                 C=1.0, p=0.25) 
     987        else: 
     988            raise TypeError("Cannot handle the class variable type %r" % \ 
     989                                type(data.domain.class_var)) 
     990 
    940991        if data is self._cached_examples: 
    941992            weights = self._cached_weights 
    942993        else: 
    943             classifier = self.learner(data, weight_id) 
     994            classifier = learner(data, weight_id) 
    944995            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)) 
     996            weights = self._extract_weights(classifier, data.domain.attributes) 
    949997            self._cached_weights = weights 
    950998        return weights.get(attr, 0.0) 
     999 
     1000    def _extract_weights(self, classifier, original_features): 
     1001        """Extract weights from a svm classifer (``SVMClassifier`` or a  
     1002        ``LinearLearner`` instance). 
     1003         
     1004        """ 
     1005        import numpy as np 
     1006        if isinstance(classifier, SVMClassifier): 
     1007            weights = get_linear_svm_weights(classifier, sum=True) 
     1008            if isinstance(classifier.class_var, variable.Continuous): 
     1009                # The weights are in the the original non squared form 
     1010                weights = dict((f, w ** 2) for f, w in weights.items())  
     1011        elif isinstance(classifier, Orange.core.LinearClassifier): 
     1012            weights = np.array(classifier.weights) 
     1013            weights = np.sum(weights ** 2, axis=0) 
     1014            weights = dict(zip(classifier.domain.attributes, weights)) 
     1015        else: 
     1016            raise TypeError("Don't know how to use classifier type %r" % \ 
     1017                                type(classifier)) 
     1018 
     1019        # collect dummy variables that were created for discrete features 
     1020        sources = self._collect_source(weights.keys()) 
     1021        source_weights = dict.fromkeys(original_features, 0.0) 
     1022        for f in original_features: 
     1023            if f not in weights and f in sources: 
     1024                dummys = sources[f] 
     1025                # Use averege weight   
     1026                source_weights[f] = np.average([weights[d] for d in dummys]) 
     1027            else: 
     1028                raise ValueError(f) 
     1029 
     1030        return source_weights 
     1031 
     1032    def _collect_source(self, vars): 
     1033        """ Given a list of variables ``var``, return a mapping from source 
     1034        variables (``source_variable`` or ``get_value_from.variable`` members) 
     1035        back to the variables in ``vars``. 
     1036         
     1037        """ 
     1038        source = defaultdict(list) 
     1039        for var in vars: 
     1040            svar = None 
     1041            if var.source_variable: 
     1042                source[var.source_variable].append(var) 
     1043            elif isinstance(var.get_value_from, Orange.core.ClassifierFromVar): 
     1044                source[var.get_value_from.variable].append(var) 
     1045            elif isinstance(var.get_value_from, Orange.core.ImputeClassifier): 
     1046                source[var.get_value_from.classifier_from_var.variable].append(var) 
     1047            else: 
     1048                source[var].append(var) 
     1049        return dict(source) 
    9511050 
    9521051MeasureAttribute_SVMWeights = ScoreSVMWeights 
  • 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/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 r10685  
    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): 
  • 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.