Ignore:
Files:
2 added
12 edited

Legend:

Unmodified
Added
Removed
  • .hgtags

    r11530 r11554  
    6684d3895ad2a55acb7e69173e22314a602c87a29f 2.6 
    778adaabe1a15bdc88d3baa633042c02c1a7bc7fa9 2.6.1 
     819b97395b702366db35cc58615e3d016ce1c9701 2.7 
  • MANIFEST.in

    r11537 r11552  
    2121exclude source/orangene/lib_vectors.cpp 
    2222 
    23 recursive-include docs *.rst *.py *.png *.css *.txt Makefile 
     23recursive-include docs *.rst *.py *.png *.gif *.css *.txt *.tab *.basket *.arff *.csv *.res Makefile 
     24prune docs/build 
    2425 
    2526graft docs/sphinx-ext 
  • Orange/OrangeCanvas/application/canvasmain.py

    r11547 r11557  
    434434            QAction(self.tr("Get Started"), self, 
    435435                    objectName="get-started-action", 
    436                     toolTip=self.tr("View a 'Getting Started' video."), 
     436                    toolTip=self.tr("View a 'Get Started' introduction."), 
    437437                    triggered=self.get_started, 
    438438                    icon=canvas_icons("Get Started.svg") 
  • Orange/OrangeCanvas/canvas/scene.py

    r11464 r11558  
    771771        return items[0] if items else None 
    772772 
    773     if PYQT_VERSION_STR < "4.9": 
     773    if map(int, PYQT_VERSION_STR.split('.')) < [4, 9]: 
    774774        # For QGraphicsObject subclasses items, itemAt ... return a 
    775775        # QGraphicsItem wrapper instance and not the actual class instance. 
  • Orange/OrangeCanvas/scheme/widgetsscheme.py

    r11540 r11563  
    1717 
    1818""" 
     19import sys 
    1920import logging 
    2021 
     
    392393                handler(*args) 
    393394            except Exception: 
    394                 log.exception("Error") 
     395                sys.excepthook(*sys.exc_info()) 
     396                log.exception("Error calling '%s' of '%s'", 
     397                              handler.__name__, node.title) 
    395398            finally: 
    396399                app.restoreOverrideCursor() 
     
    400403            widget.handleNewSignals() 
    401404        except Exception: 
    402             log.exception("Error") 
     405            sys.excepthook(*sys.exc_info()) 
     406            log.exception("Error calling 'handleNewSignals()' of '%s'", 
     407                          node.title) 
    403408        finally: 
    404409            app.restoreOverrideCursor() 
  • Orange/OrangeWidgets/Data/OWDataTable.py

    r11358 r11565  
    77""" 
    88 
     9from xml.sax.saxutils import escape 
     10import Orange 
     11 
    912from OWWidget import * 
    1013import OWGUI 
     
    1316import OWColorPalette 
    1417 
    15  
    1618NAME = "Data Table" 
    1719 
     
    3638           ("Other Data", ExampleTable)] 
    3739 
    38 ############################################################################## 
    39  
    40 def safe_call(func): 
    41     from functools import wraps 
    42     @wraps(func) 
    43     def wrapper(*args, **kwargs): 
    44         try: 
    45             return func(*args, **kwargs) 
    46         except Exception, ex: 
    47             print >> sys.stderr, func.__name__, "call error", ex  
    48             return QVariant() 
    49     return wrapper 
    50      
     40 
     41def header_text(feature, labels=None): 
     42    """ 
     43    Return an header text for an `Orange.feature.Descriptor` instance 
     44    `feature`. If labels is not none it should be a sequence of keys into 
     45    `feature.attributes` to include in the header (one per line). If the 
     46    `feature.attribures` does not contain a value for the key the returned 
     47    text will include an empty line for it. 
     48 
     49    """ 
     50    lines = [feature.name] 
     51    if labels is not None: 
     52        lines += [str(feature.attributes.get(label, "")) 
     53                  for label in labels] 
     54    return "\n".join(lines) 
     55 
     56 
     57def header_tooltip(feature, labels=None): 
     58    """ 
     59    Return an header tooltip text for an `Orange.feature.Decriptor` instance. 
     60    """ 
     61 
     62    if labels is None: 
     63        labels = feature.attributes.keys() 
     64 
     65    pairs = [(escape(key), escape(str(feature.attributes[key]))) 
     66             for key in labels if key in feature.attributes] 
     67    tip = "<b>%s</b>" % escape(feature.name) 
     68    tip = "<br/>".join([tip] + ["%s = %s" % pair for pair in pairs]) 
     69    return tip 
     70 
    5171 
    5272class ExampleTableModel(QAbstractItemModel): 
     73    Attribute, ClassVar, ClassVars, Meta = range(4) 
     74 
    5375    def __init__(self, examples, dist, *args): 
    5476        QAbstractItemModel.__init__(self, *args) 
    5577        self.examples = examples 
     78        self.domain = examples.domain 
    5679        self.dist = dist 
    57         self.attributes = list(self.examples.domain.attributes) 
    58         self.class_var = self.examples.domain.classVar 
     80        self.attributes = list(examples.domain.attributes) 
     81        self.class_var = self.examples.domain.class_var 
     82        self.class_vars = list(self.examples.domain.class_vars) 
    5983        self.metas = self.examples.domain.getmetas().values() 
    60         self.all_attrs = self.attributes + ([self.class_var] if self.class_var else []) + self.metas 
    61         self.cls_color = QColor(160,160,160) 
    62         self.meta_color = QColor(220,220,200) 
     84        # Attributes/features for all table columns 
     85        self.all_attrs = (self.attributes + 
     86                          ([self.class_var] if self.class_var else []) + 
     87                          self.class_vars + self.metas) 
     88        # Table roles for all table columns 
     89        self.table_roles = \ 
     90            (([ExampleTableModel.Attribute] * len(self.attributes)) + 
     91             ([ExampleTableModel.ClassVar] if self.class_var else []) + 
     92             ([ExampleTableModel.ClassVars] * len(self.class_vars)) + 
     93             ([ExampleTableModel.Meta] * len(self.metas))) 
     94 
     95        # True if an feature at column i is continuous 
     96        self._continuous_mask = [isinstance(attr, Orange.feature.Continuous) 
     97                                 for attr in self.all_attrs] 
     98 
     99        self._meta_mask = [role == ExampleTableModel.Meta 
     100                           for role in self.table_roles] 
     101 
     102        self.cls_color = QColor(160, 160, 160) 
     103        self.meta_color = QColor(220, 220, 200) 
     104 
     105        role_to_color = {ExampleTableModel.Attribute: None, 
     106                         ExampleTableModel.ClassVar: self.cls_color, 
     107                         ExampleTableModel.ClassVars: self.cls_color, 
     108                         ExampleTableModel.Meta: self.meta_color} 
     109 
     110        self.background_colors = map(role_to_color.get, self.table_roles) 
     111 
     112        # all attribute labels (annotation) keys 
     113        self.attr_labels = sorted( 
     114            reduce(set.union, 
     115                   [attr.attributes for attr in self.all_attrs], 
     116                   set()) 
     117        ) 
     118 
     119        # text for all header items (no attr labels by default) 
     120        self.header_labels = [header_text(feature) 
     121                              for feature in self.all_attrs] 
     122 
    63123        self.sorted_map = range(len(self.examples)) 
    64          
    65         self.attr_labels = sorted(reduce(set.union, [attr.attributes for attr in self.all_attrs], set())) 
     124 
    66125        self._show_attr_labels = False 
    67126        self._other_data = {} 
    68          
     127 
    69128    def get_show_attr_labels(self): 
    70129        return self._show_attr_labels 
    71      
     130 
    72131    def set_show_attr_labels(self, val): 
    73         self.emit(SIGNAL("layoutAboutToBeChanged()")) 
    74         self._show_attr_labels = val 
    75         self.emit(SIGNAL("headerDataChanged(Qt::Orientation, int, int)"), 
    76                   Qt.Horizontal,  
    77                   0,  
    78                   len(self.all_attrs) - 1 
    79                   ) 
    80         self.emit(SIGNAL("layoutChanged()")) 
    81         self.emit(SIGNAL("dataChanged(QModelIndex, QModelIndex)"),  
    82                   self.index(0,0), 
    83                   self.index(len(self.examples) - 1, len(self.all_attrs) - 1) 
    84                   ) 
    85          
    86     show_attr_labels = pyqtProperty("bool",  
    87                                    fget=get_show_attr_labels, 
    88                                    fset=set_show_attr_labels, 
    89                                    ) 
    90      
    91     @safe_call 
    92     def data(self, index, role): 
     132        if self._show_attr_labels != val: 
     133            self.emit(SIGNAL("layoutAboutToBeChanged()")) 
     134            self._show_attr_labels = val 
     135            if val: 
     136                labels = self.attr_labels 
     137            else: 
     138                labels = None 
     139            self.header_labels = [header_text(feature, labels) 
     140                                  for feature in self.all_attrs] 
     141 
     142            self.emit(SIGNAL("headerDataChanged(Qt::Orientation, int, int)"), 
     143                      Qt.Horizontal, 
     144                      0, 
     145                      len(self.all_attrs) - 1) 
     146 
     147            self.emit(SIGNAL("layoutChanged()")) 
     148 
     149            self.emit(SIGNAL("dataChanged(QModelIndex, QModelIndex)"), 
     150                      self.index(0, 0), 
     151                      self.index(len(self.examples) - 1, 
     152                                 len(self.all_attrs) - 1) 
     153                      ) 
     154 
     155    show_attr_labels = pyqtProperty("bool", 
     156                                    fget=get_show_attr_labels, 
     157                                    fset=set_show_attr_labels) 
     158 
     159    def data(self, index, role, 
     160             # For optimizing out LOAD_GLOBAL byte code instructions in 
     161             # the item role tests (goes from 14 us to 9 us average). 
     162             _str=str, 
     163             _Qt_DisplayRole=Qt.DisplayRole, 
     164             _Qt_BackgroundRole=Qt.BackgroundRole, 
     165             _OWGUI_TableBarItem_BarRole=OWGUI.TableBarItem.BarRole, 
     166             _OWGUI_TableValueRole=OWGUI.TableValueRole, 
     167             _OWGUI_TableClassValueRole=OWGUI.TableClassValueRole, 
     168             _OWGUI_TableVariable=OWGUI.TableVariable, 
     169             # Some cached local precomputed values. 
     170             # All of the above roles we respond to 
     171             _recognizedRoles=set([Qt.DisplayRole, 
     172                                   Qt.BackgroundRole, 
     173                                   OWGUI.TableBarItem.BarRole, 
     174                                   OWGUI.TableValueRole, 
     175                                   OWGUI.TableClassValueRole, 
     176                                   OWGUI.TableVariable]), 
     177             ): 
     178        """ 
     179        Return the data for `role` for an value at `index`. 
     180        """ 
     181        if role not in _recognizedRoles: 
     182            return self._other_data.get((index.row(), index.column(), role), 
     183                                        None) 
     184 
    93185        row, col = self.sorted_map[index.row()], index.column() 
    94186        example, attr = self.examples[row], self.all_attrs[col] 
     187 
    95188        val = example[attr] 
    96         domain = self.examples.domain 
    97         if role == Qt.DisplayRole: 
    98                 return QVariant(str(val)) 
    99         elif role == Qt.BackgroundRole: 
    100             #check if attr is actual class or a duplication in the meta attributes 
    101             if attr == self.class_var and col == len(domain.attributes) and domain.classVar: 
    102                 return QVariant(self.cls_color) 
    103             elif attr in self.metas: 
    104                 return QVariant(self.meta_color) 
    105         elif role == OWGUI.TableBarItem.BarRole and val.varType == orange.VarTypes.Continuous \ 
    106                     and not val.isSpecial() and attr not in self.metas: 
     189 
     190        if role == _Qt_DisplayRole: 
     191            return _str(val) 
     192        elif role == _Qt_BackgroundRole: 
     193            return self.background_colors[col] 
     194        elif role == _OWGUI_TableBarItem_BarRole and \ 
     195                self._continuous_mask[col] and not val.isSpecial() and \ 
     196                col < len(self.dist): 
    107197            dist = self.dist[col] 
    108             return QVariant((float(val) - dist.min) / (dist.max - dist.min or 1)) 
    109         elif role == OWGUI.TableValueRole: 
    110             # The actual value 
    111             return QVariant(val) 
    112         elif role == OWGUI.TableClassValueRole:  
     198            return (float(val) - dist.min) / (dist.max - dist.min or 1) 
     199        elif role == _OWGUI_TableValueRole: 
     200            # The actual value instance (should it be EditRole?) 
     201            return val 
     202        elif role == _OWGUI_TableClassValueRole and self.class_var is not None: 
    113203            # The class value for the row's example 
    114             return QVariant(example.get_class()) 
    115         elif role == OWGUI.TableVariable:  
     204            return example.get_class() 
     205        elif role == _OWGUI_TableVariable: 
    116206            # The variable descriptor for column 
    117             return QVariant(val.variable) 
    118          
    119         return self._other_data.get((index.row(), index.column(), role), QVariant()) 
    120          
     207            return attr 
     208 
     209        return None 
     210 
    121211    def setData(self, index, variant, role): 
    122212        self._other_data[index.row(), index.column(), role] = variant 
     
    133223            return 0 
    134224        else: 
    135             return max([len(self.examples)] + [row for row, _, _ in self._other_data.keys()]) 
    136          
    137     def columnCount(self, index=QModelIndex()): 
    138         return max([len(self.all_attrs)] + [col for _, col, _ in self._other_data.keys()]) 
    139      
    140     @safe_call 
     225            return len(self.examples) 
     226 
     227    def columnCount(self, parent=QModelIndex()): 
     228        if parent.isValid(): 
     229            return 0 
     230        else: 
     231            return len(self.all_attrs) 
     232 
    141233    def headerData(self, section, orientation, role): 
    142234        if orientation == Qt.Horizontal: 
    143235            attr = self.all_attrs[section] 
    144             if role ==Qt.DisplayRole: 
    145                 values = [attr.name] + ([str(attr.attributes.get(label, "")) for label in self.attr_labels] if self.show_attr_labels else []) 
    146                 return QVariant("\n".join(values)) 
     236            if role == Qt.DisplayRole: 
     237                return self.header_labels[section] 
    147238            if role == Qt.ToolTipRole: 
    148                 pairs = [(key, str(attr.attributes[key])) for key in self.attr_labels if key in attr.attributes] 
    149                 tip = "<b>%s</b>" % attr.name 
    150                 tip = "<br>".join([tip] + ["%s = %s" % pair for pair in pairs]) 
    151                 return QVariant(tip)   
     239                return header_tooltip(attr, self.attr_labels) 
    152240        else: 
    153241            if role == Qt.DisplayRole: 
    154242                return QVariant(section + 1) 
    155243        return QVariant() 
    156      
     244 
    157245    def sort(self, column, order=Qt.AscendingOrder): 
    158246        self.emit(SIGNAL("layoutAboutToBeChanged()")) 
     
    668756             
    669757        self.selectionChangedFlag = False 
    670              
    671          
    672  
    673 if __name__=="__main__": 
     758 
     759 
     760def test(): 
    674761    a = QApplication(sys.argv) 
    675762    ow = OWDataTable() 
    676763 
    677     #d1 = orange.ExampleTable(r'..\..\doc\datasets\auto-mpg') 
    678     #d2 = orange.ExampleTable('test-labels') 
    679     #d3 = orange.ExampleTable(r'..\..\doc\datasets\sponge.tab') 
    680     #d4 = orange.ExampleTable(r'..\..\doc\datasets\wpbc.csv') 
    681     d5 = orange.ExampleTable('../../doc/datasets/adult_sample.tab') 
    682     #d5 = orange.ExampleTable(r"E:\Development\Orange Datasets\UCI\wine.tab") 
    683 #    d5 = orange.ExampleTable("adult_sample") 
    684 #    d5 = orange.ExampleTable("/home/marko/tdw") 
    685     #d5 = orange.ExampleTable(r"e:\Development\Orange Datasets\Cancer\SRBCT.tab") 
     764    d1 = orange.ExampleTable("auto-mpg") 
     765    d2 = orange.ExampleTable("sponge.tab") 
     766    d3 = orange.ExampleTable("wpbc.csv") 
     767    d4 = orange.ExampleTable("adult_sample.tab") 
     768    d5 = orange.ExampleTable("wine.tab") 
     769 
    686770    ow.show() 
    687     #ow.dataset(d1,"auto-mpg") 
    688     #ow.dataset(d2,"voting") 
    689     #ow.dataset(d4,"wpbc") 
    690     ow.dataset(d5,"adult_sample") 
     771    ow.dataset(d1, "auto-mpg") 
     772    ow.dataset(d2, "sponge") 
     773    ow.dataset(d3, "wpbc") 
     774    ow.dataset(d4, "adult_sample") 
     775    ow.dataset(d5, "wine") 
    691776    a.exec_() 
    692777    ow.saveSettings() 
     778 
     779 
     780if __name__ == "__main__": 
     781    test() 
  • Orange/OrangeWidgets/Evaluate/OWTestLearners.py

    r11217 r11562  
    1414import warnings 
    1515from orngWrap import PreprocessedLearner 
    16 warnings.filterwarnings("ignore", "'id' is not a builtin attribute", 
    17                         orange.AttributeWarning) 
    1816 
    1917import Orange 
     
    338336            try: 
    339337                predictor = learner(new) 
     338            except Exception, ex: 
     339                learner_exceptions.append((l, ex)) 
     340                l.scores = [] 
     341                l.results = None 
     342            else: 
    340343                if (multilabel and isinstance(learner, Orange.multilabel.MultiLabelLearner)) or predictor(new[0]).varType == new.domain.classVar.varType: 
    341344                    learners.append(learner) 
     
    344347                    l.scores = [] 
    345348                    l.results = None 
    346  
    347             except Exception, ex: 
    348                 learner_exceptions.append((l, ex)) 
    349                 l.scores = [] 
    350                 l.results = None 
    351349 
    352350        if learner_exceptions: 
     
    447445         
    448446    def clearScores(self, ids=None): 
     447        """ 
     448        Clear/invalidate evaluation results/scores for learners for an 
     449        `ids` sequence (keys into self.learners). If `ids` is None then 
     450        invalidate data for all learners. 
     451 
     452        """ 
    449453        if ids is None: 
    450454            ids = self.learners.keys() 
     
    456460    # handle input signals 
    457461    def setData(self, data): 
    458         """handle input train data set""" 
     462        """ 
     463        Set the input train data set. 
     464        """ 
    459465        self.closeContext() 
    460          
    461         multilabel= self.ismultilabel(data) 
     466 
     467        self.clearScores() 
     468 
     469        multilabel = self.ismultilabel(data) 
    462470        if not multilabel: 
    463             self.data = self.isDataWithClass(data, checkMissing=True) and data or None 
     471            if self.isDataWithClass(data, checkMissing=True): 
     472                self.data = orange.Filter_hasClassValue(data) 
     473            else: 
     474                self.data = None 
    464475        else: 
    465476            self.data = data 
    466          
     477 
    467478        self.fillClassCombo() 
    468         if not self.data: 
    469             # data was removed, remove the scores 
    470             self.clearScores() 
    471             self.send("Evaluation Results", None) 
    472         else: 
    473             # new data has arrived 
    474             self.clearScores() 
    475  
    476             if not multilabel: 
    477                 self.data = orange.Filter_hasClassValue(self.data) 
    478  
    479             self.statLayout.setCurrentWidget([self.rbox, self.cbox, self.mbox][2 if self.ismultilabel() else self.isclassification()]) 
    480  
    481             self.stat = [self.rStatistics, self.cStatistics, self.mStatistics][2 if self.ismultilabel() else self.isclassification()] 
    482  
    483             if self.learners: 
    484                 self.recompute() 
    485              
    486         self.openContext("", data) 
    487         self.paintscores() 
     479 
     480        if self.data is not None: 
     481            # Ensure the correct statistics selection is visible. 
     482            if self.ismultilabel(): 
     483                statwidget = self.mbox 
     484                stat = self.mStatistics 
     485            elif self.isclassification(): 
     486                statwidget = self.cbox 
     487                stat = self.cStatistics 
     488            else: 
     489                statwidget = self.rbox 
     490                stat = self.rStatistics 
     491 
     492            self.statLayout.setCurrentWidget(statwidget) 
     493 
     494            self.stat = stat 
    488495 
    489496    def setTestData(self, data): 
    490         """handle test data set""" 
     497        """ 
     498        Set the 'Separate Test Data' input. 
     499        """ 
    491500        if data is None: 
    492501            self.testdata = None 
     
    496505        if self.testdata is not None: 
    497506            if self.resampling == 4: 
    498                 if self.data: 
    499                     self.recompute() 
    500                 else: 
    501                     for l in self.learners.values(): 
    502                         l.scores = [] 
    503                 self.paintscores() 
     507                self.clearScores() 
     508 
    504509        elif self.resampling == 4 and self.data: 
    505510            # test data removed, switch to testing on train data 
    506511            self.resampling = 3 
    507             self.recompute() 
     512            self.clearScores() 
    508513 
    509514    def fillClassCombo(self): 
     
    523528 
    524529    def setLearner(self, learner, id=None): 
    525         """add/remove a learner""" 
    526         if learner: # a new or updated learner 
    527             if id in self.learners: # updated learner 
     530        """ 
     531        Set the input learner with `id`. 
     532        """ 
     533        if learner is not None: 
     534            # a new or updated learner 
     535            if id in self.learners: 
    528536                time = self.learners[id].time 
    529537                self.learners[id] = Learner(learner, id) 
    530538                self.learners[id].time = time 
    531             else: # new learner 
     539                self.learners[id] = self.learners[id] 
     540                self.clearScores([id]) 
     541            else: 
    532542                self.learners[id] = Learner(learner, id) 
    533             if self.applyOnAnyChange: 
    534                 self.score([id]) 
    535             else: 
    536                 self.recompute() 
    537         else: # remove a learner and corresponding results 
     543        else: 
     544            # remove a learner and corresponding results 
    538545            if id in self.learners: 
    539546                res = self.learners[id].results 
    540547                if res and res.numberOfLearners > 1: 
     548                    # Remove the learner from the shared results instance 
    541549                    old_learner = self.learners[id].learner 
    542550                    indx = res.learners.index(old_learner) 
     
    544552                    del res.learners[indx] 
    545553                del self.learners[id] 
    546             self.sendResults() 
    547         self.paintscores() 
    548          
     554 
    549555    def setPreprocessor(self, pp): 
    550556        self.preprocessor = pp 
    551         if self.learners: 
    552             self.recompute() 
     557        self.clearScores() 
     558 
     559    def handleNewSignals(self): 
     560        """ 
     561        Update the evaluations/scores after new inputs were received. 
     562        """ 
     563        def needsupdate(learner_id): 
     564            return not (self.learners[learner_id].scores or 
     565                        self.learners[learner_id].results) 
     566 
     567        if self.applyOnAnyChange: 
     568            self.score(filter(needsupdate, self.learners)) 
     569            self.applyBtn.setEnabled(False) 
     570        else: 
     571            self.applyBtn.setEnabled(True) 
     572 
     573        self.paintscores() 
     574 
     575        if self.data is not None: 
     576            self.openContext("", self.data) 
     577        else: 
     578            self.send("Evaluation Results", None) 
    553579 
    554580    # handle output signals 
     
    594620            self.applyBtn.setDisabled(self.applyOnAnyChange) 
    595621        else: 
     622            self.clearScores() 
    596623            if self.learners: 
    597624                self.recompute() 
     
    623650 
    624651    def applyChange(self): 
     652        """ 
     653        A change of 'Apply on any change' check box. 
     654        """ 
     655        def needsupdate(learner_id): 
     656            return not (self.learners[learner_id].scores or 
     657                        self.learners[learner_id].results) 
     658 
    625659        if self.applyOnAnyChange: 
    626660            self.applyBtn.setDisabled(True) 
    627          
     661            pending = filter(needsupdate, self.learners) 
     662            if pending: 
     663                self.score(pending) 
     664                self.paintscores() 
     665 
    628666    def changedTarget(self): 
    629667        self.recomputeCM() 
  • Orange/classification/neural.py

    r10984 r11559  
    127127class NeuralNetworkLearner(Orange.classification.Learner): 
    128128    """ 
    129     NeuralNetworkLearner uses jzbontar's implementation of neural networks and wraps it in 
    130     an Orange compatible learner.  
    131  
    132     NeuralNetworkLearner supports all types of data and returns a classifier, regression is currently not supported. 
    133  
    134     More information about neural networks can be found at http://en.wikipedia.org/wiki/Artificial_neural_network. 
     129    NeuralNetworkLearner implements a multilayer perceptron. Learning is performed by minimizing an L2-regularized 
     130    cost function with scipy's implementation of L-BFGS. The current implementations is limited to a single 
     131    hidden layer.  
     132 
     133    Regression is currently not supported. 
    135134 
    136135    :param name: learner name. 
     
    138137 
    139138    :param n_mid: Number of nodes in the hidden layer 
    140     :type n_mid: integer 
     139    :type n_mid: int 
    141140 
    142141    :param reg_fact: Regularization factor. 
     
    144143 
    145144    :param max_iter: Maximum number of iterations. 
    146     :type max_iter: integer 
     145    :type max_iter: int 
     146 
     147    :param normalize: Normalize the data prior to learning (subtract each column by the mean and divide by the standard deviation) 
     148    :type normalize: bool 
    147149 
    148150    :rtype: :class:`Orange.multitarget.neural.neuralNetworkLearner` or  
     
    159161            return self(data,weight) 
    160162 
    161     def __init__(self, name="NeuralNetwork", n_mid=10, reg_fact=1, max_iter=1000, rand=None): 
     163    def __init__(self, name="NeuralNetwork", n_mid=10, reg_fact=1, max_iter=300, normalize=True, rand=None): 
    162164        """ 
    163165        Current default values are the same as in the original implementation (neural_networks.py) 
    164166        """ 
    165  
    166167        self.name = name 
    167168        self.n_mid = n_mid 
     
    169170        self.max_iter = max_iter 
    170171        self.rand = rand 
     172        self.normalize = normalize 
    171173 
    172174        if not self.rand: 
     
    193195        X = data.to_numpy()[0]  
    194196 
     197        mean = X.mean(axis=0) 
     198        std = X.std(axis=0) 
     199        if self.normalize: 
     200            X = (X - mean) / std 
     201 
    195202        #converts multi-target or single-target classes to numpy 
    196  
    197  
    198203        if data.domain.class_vars: 
    199204            for cv in data.domain.class_vars: 
     
    228233        self.nn.fit(X,Y) 
    229234                
    230         return NeuralNetworkClassifier(classifier=self.nn.predict, domain = data.domain) 
     235        return NeuralNetworkClassifier(classifier=self.nn.predict, 
     236            domain=data.domain, normalize=self.normalize, mean=mean, std=std) 
    231237 
    232238class NeuralNetworkClassifier(): 
     
    258264        input = np.array([[float(e) for e in example]]) 
    259265 
     266        if self.normalize: 
     267            input = (input - self.mean) / self.std 
     268 
    260269        # transform results from numpy 
    261270        results = self.classifier(input).tolist()[0] 
     271        if len(results) == 1: 
     272            prob_positive = results[0] 
     273            results = [1 - prob_positive, prob_positive] 
    262274        mt_prob = [] 
    263275        mt_value = [] 
     
    295307    global_timer = time.time() 
    296308 
    297     data = Orange.data.Table('iris') 
    298     l1 = NeuralNetworkLearner(n_mid=10, reg_fact=1, max_iter=1000) 
    299     res = Orange.evaluation.testing.cross_validation([l1],data, 3) 
     309    data = Orange.data.Table('wine') 
     310    l1 = NeuralNetworkLearner(n_mid=40, reg_fact=1, max_iter=200) 
     311 
     312#    c1 = l1(data) 
     313#    print c1(data[0], 3), data[0] 
     314 
     315    l2 = Orange.classification.bayes.NaiveLearner() 
     316    res = Orange.evaluation.testing.cross_validation([l1, l2],data, 5) 
    300317    scores = Orange.evaluation.scoring.CA(res) 
    301  
    302318    for i in range(len(scores)): 
    303319        print res.classifierNames[i], scores[i] 
  • docs/tutorial/rst/code/data-instances1.py

    r11052 r11556  
    77 
    88print "25-th data instance:" 
    9 print data[26] 
     9print data[24] 
    1010 
    1111name = "sepal width" 
    1212print "Value of '%s' for the first instance:" % name, data[0][name] 
    13 print "The 3rd value of the 25th data instance:", data[26][2] 
     13print "The 3rd value of the 25th data instance:", data[24][2] 
  • docs/tutorial/rst/data.rst

    r11052 r11556  
    113113   [4.7, 3.2, 1.3, 0.2, 'Iris-setosa'] 
    114114   25-th data instance: 
    115    [5.0, 3.4, 1.6, 0.4, 'Iris-setosa'] 
     115   [4.8, 3.4, 1.9, 0.2, 'Iris-setosa'] 
    116116   Value of 'sepal width' for the first instance: 3.5 
    117    The 3rd value of the 25th data instance: 1.6 
     117   The 3rd value of the 25th data instance: 1.9 
    118118 
    119119Iris data set we have used above has four continous attributes. Here's a script that computes their mean: 
  • docs/widgets/rst/classify/randomforest.rst

    r11359 r11551  
    2222   - Random Forest Classifier 
    2323      Trained random forest 
    24    - Choosen Tree 
    25       One of the classification trees from the random forest classifer 
    2624 
    2725 
     
    7068   :alt: Random forest evaluation 
    7169 
    72 A simple use of this widget where we wanted to explore how do the actual 
    73 trees in the forest look like is presented in the following snapshot. In 
    74 our case, the 5-th tree from the forest was rendered in the Classification 
    75 Tree Graph widget. 
    76  
    77 .. image:: images/RandomForest-TreeGraph.png 
    78    :alt: Visualization of a tree from random forest 
    7970 
    8071References 
  • setup.py

    r11537 r11555  
    3232NAME = 'Orange' 
    3333 
    34 VERSION = '2.7rc1' 
     34VERSION = '2.7.1' 
    3535ISRELEASED = False 
    3636 
Note: See TracChangeset for help on using the changeset viewer.