Ignore:
Location:
Orange
Files:
9 edited

Legend:

Unmodified
Added
Removed
  • Orange/OrangeCanvas/orngCanvasItems.py

    r10560 r10732  
    1515        return None 
    1616     
    17 def setDropShadow(self): 
     17def setDropShadow(self, offset=QPointF(0.3, 0.5), blur_radius=5): 
    1818    if qVersion() >= "4.6" and self.canvasDlg.settings["enableCanvasDropShadows"]: 
    1919        effect = QGraphicsDropShadowEffect(self.scene()) 
    20         effect.setOffset(QPointF(0.3, 0.5)) 
    21         effect.setBlurRadius(5) 
     20        effect.setOffset(offset) 
     21        effect.setBlurRadius(blur_radius) 
    2222        self.setGraphicsEffect(effect) 
    2323     
     
    3333        self.setPen(QPen(QColor(180, 180, 180), 3, Qt.SolidLine)) 
    3434         
    35         self.setDropShadow() 
     35        self.setDropShadow(offset=QPointF(0.0, 0.0)) 
    3636     
    3737    setDropShadow = setDropShadow 
     
    146146        QObject.connect(self.outWidget.instance, SIGNAL("dynamicLinkEnabledChanged(PyQt_PyObject, bool)"), self.updateDynamicEnableState) 
    147147         
    148         self.setDropShadow() 
     148        self.setDropShadow(offset=QPointF(0.0, 0.0)) 
    149149         
    150150    setDropShadow = setDropShadow 
  • Orange/OrangeCanvas/orngView.py

    r9671 r10733  
    171171    def unselectAllWidgets(self): 
    172172        for item in self.doc.widgets: 
    173             item.setSelected(0) 
     173            item.setSelected(False) 
     174             
     175    def selectAllWidgets(self): 
     176        for item in self.doc.widgets: 
     177            item.setSelected(True) 
    174178 
    175179    def getItemsAtPos(self, pos, itemType = None): 
     
    225229            rect = self.maxSelectionRect(QRectF(self.mouseDownPosition, self.mouseDownPosition)) 
    226230            self.widgetSelectionRect = QGraphicsRectItem(rect, None, self.scene()) 
    227             self.widgetSelectionRect.setPen(QPen(QBrush(QColor(51, 153, 255, 192)), 1, Qt.SolidLine, Qt.RoundCap)) 
     231            self.widgetSelectionRect.setPen(QPen(QBrush(QColor(51, 153, 255, 192)), 0.4, Qt.SolidLine, Qt.RoundCap)) 
    228232            self.widgetSelectionRect.setBrush(QBrush(QColor(168, 202, 236, 192))) 
    229233            self.widgetSelectionRect.setZValue(-100) 
     
    233237        # we clicked on a widget or on a line 
    234238        else: 
    235             if type(activeItem) == orngCanvasItems.CanvasWidget:        # if we clicked on a widget 
     239            if type(activeItem) == orngCanvasItems.CanvasWidget: 
     240                # if we clicked on a widget 
    236241                self.tempWidget = activeItem 
    237242 
    238243                if ev.button() == Qt.LeftButton: 
    239244                    self.bWidgetDragging = True 
    240                     if ev.modifiers() & Qt.ControlModifier: #self.doc.ctrlPressed: 
     245                    if ev.modifiers() & Qt.ControlModifier: 
    241246                        activeItem.setSelected(not activeItem.isSelected()) 
    242247                    elif activeItem.isSelected() == 0: 
     
    254259                    activeItem.setSelected(True) 
    255260                    self.doc.canvasDlg.widgetPopup.popup(ev.globalPos()) 
    256                     return # Don't call QGraphicsView.mousePressEvent. It unselects the active item 
    257261                else: 
    258262                    self.unselectAllWidgets() 
     263                return # Don't call QGraphicsView.mousePressEvent. It unselects the active item 
    259264 
    260265            # if we right clicked on a line we show a popup menu 
     
    437442        sceneRect = minGeom.united(b_rect) 
    438443        return rect.intersected(sceneRect).adjusted(penWidth, penWidth, -penWidth, -penWidth) 
    439 #         
    440 #    def resizeEvent(self, event): 
    441 #        self.updateSceneRect() 
    442  
     444 
     445    def keyPressEvent(self, event): 
     446        if event == QKeySequence.SelectAll: 
     447            self.selectAllWidgets() 
     448        else: 
     449            return QGraphicsView.keyPressEvent(self, event) 
  • Orange/OrangeWidgets/Classify/OWSVM.py

    r9671 r10730  
    5757         
    5858        b.layout().addWidget(QLabel("Cost (C)", b), 0, 1, Qt.AlignRight) 
    59         b.layout().addWidget(OWGUI.doubleSpin(b, self, "C", 0.5, 512.0, 0.5,  
    60                                 addToLayout=False,  
    61                                 callback=lambda *x: self.setType(0),  
     59        b.layout().addWidget(OWGUI.doubleSpin(b, self, "C", 0.1, 512.0, 0.1, 
     60                                decimals=2, 
     61                                addToLayout=False, 
     62                                callback=lambda *x: self.setType(0), 
    6263                                alignment=Qt.AlignRight, 
    6364                                tooltip= "Cost for a mis-classified training instance."), 
    6465                             0, 2) 
    6566         
    66         b.layout().addWidget(OWGUI.appendRadioButton(b, self, "useNu", u"ν-SVM",  
     67        b.layout().addWidget(OWGUI.appendRadioButton(b, self, "useNu", u"ν-SVM", 
    6768                                                     addToLayout=False), 
    6869                             1, 0, Qt.AlignLeft) 
    69          
     70 
    7071        b.layout().addWidget(QLabel(u"Complexity bound (\u03bd)", b), 1, 1, Qt.AlignRight) 
    71         b.layout().addWidget(OWGUI.doubleSpin(b, self, "nu", 0.1, 1.0, 0.1,  
     72        b.layout().addWidget(OWGUI.doubleSpin(b, self, "nu", 0.05, 1.0, 0.05, 
    7273                                tooltip="Lower bound on the ratio of support vectors", 
    73                                 addToLayout=False,  
     74                                addToLayout=False, 
    7475                                callback=lambda *x: self.setType(1), 
    7576                                alignment=Qt.AlignRight), 
     
    8788        self.gcd = OWGUI.widgetBox(b, orientation="horizontal") 
    8889        self.leg = OWGUI.doubleSpin(self.gcd, self, "gamma",0.0,10.0,0.0001, 
     90                                decimals=5, 
    8991                                label="  g: ", 
    9092                                orientation="horizontal", 
     
    265267            params.append("degree") 
    266268        try: 
    267             learner.tuneParameters(self.data, params, 4, verbose=0, progressCallback=self.progres) 
     269            learner.tuneParameters(self.data, params, 4, verbose=0, 
     270                                   progressCallback=self.progres) 
    268271        except UnhandledException: 
    269272            pass 
  • Orange/OrangeWidgets/Data/OWEditDomain.py

    r10358 r10726  
    143143         
    144144        self.labels_edit = QTreeView() 
    145         self.labels_edit.setEditTriggers(QTreeView.DoubleClicked | \ 
    146                                          QTreeView.EditKeyPressed) 
     145        self.labels_edit.setEditTriggers(QTreeView.CurrentChanged) 
    147146        self.labels_edit.setRootIsDecorated(False) 
    148147         
     
    294293    def _setup_gui_values(self): 
    295294        self.values_edit = QListView() 
    296         self.values_edit.setEditTriggers(QListView.DoubleClicked | \ 
    297                                          QListView.EditKeyPressed) 
     295        self.values_edit.setEditTriggers(QTreeView.CurrentChanged) 
    298296        self.values_model = PyListModel(flags=Qt.ItemIsSelectable | \ 
    299297                                        Qt.ItemIsEnabled | Qt.ItemIsEditable) 
  • Orange/OrangeWidgets/Data/OWPaintData.py

    r9671 r10727  
    711711        self.classValuesView = listView = QListView() 
    712712        listView.setSelectionMode(QListView.SingleSelection) 
    713         listView.setEditTriggers(QListView.SelectedClicked) 
    714713         
    715714        self.classValuesModel = EnumVariableModel(self.classVariable, self, flags=Qt.ItemIsSelectable | Qt.ItemIsEnabled| Qt.ItemIsEditable) 
  • Orange/OrangeWidgets/Data/OWPythonScript.py

    r10462 r10727  
    297297        self.controlBox.layout().setSpacing(1) 
    298298        self.libraryView = QListView() 
    299         self.libraryView.pyqtConfigure(editTriggers=QListView.DoubleClicked | QListView.SelectedClicked) 
     299        self.libraryView.setEditTriggers(QListView.DoubleClicked | QListView.EditKeyPressed) 
    300300        self.libraryView.setSizePolicy(QSizePolicy.Ignored, QSizePolicy.Preferred) 
    301301        self.libraryView.setItemDelegate(ScriptItemDelegate(self)) 
  • Orange/OrangeWidgets/OWGUI.py

    r10608 r10728  
    265265         callback=None, debuggingEnabled = 1, controlWidth = None, callbackOnReturn = False, 
    266266         checked = "", checkCallback = None, posttext = None, addToLayout=True, alignment = Qt.AlignLeft, 
    267          keyboardTracking=True): #widget, master, value, min, max, step=1, box=None, label=None, labelWidth=None, orientation=None, tooltip=None, callback=None, controlWidth=None): 
     267         keyboardTracking=True, decimals=None): 
    268268    if box or label and not checked: 
    269269        b = widgetBox(widget, box, orientation) 
     
    285285 
    286286    wa = bi.control = DoubleSpinBoxWFocusOut(min, max, step, bi) 
     287 
     288    if decimals is not None: 
     289        wa.setDecimals(decimals) 
     290 
    287291    wa.setAlignment(alignment) 
    288292    wa.setKeyboardTracking(keyboardTracking) # If false it wont emit valueChanged signals while editing the text 
  • Orange/OrangeWidgets/OWItemModels.py

    r10459 r10725  
    3030    object.blockSignals(blocked) 
    3131 
    32      
     32 
    3333class PyListModel(QAbstractListModel): 
    3434    """ A model for displaying python list like objects in Qt item view classes 
    3535    """ 
    3636    MIME_TYPES = ["application/x-Orange-PyListModelData"] 
    37      
     37 
    3838    def __init__(self, iterable=[], parent=None, 
    3939                 flags=Qt.ItemIsSelectable | Qt.ItemIsEnabled, 
     
    4545        self._flags = flags 
    4646        self.list_item_role = list_item_role 
    47          
     47 
    4848        self._supportedDropActions = supportedDropActions 
    4949        self.extend(iterable) 
    50          
     50 
     51    def _is_index_valid_for(self, index, list_like): 
     52        if isinstance(index, QModelIndex) and index.isValid() : 
     53            row, column = index.row(), index.column() 
     54            return row < len(list_like) and row >= 0 and column == 0 
     55        elif isinstance(index, int): 
     56            return index < len(list_like) and index > -len(self) 
     57        else: 
     58            return False 
     59 
    5160    def wrap(self, list): 
    5261        """ Wrap the list with this model. All changes to the model 
     
    5665        self._other_data = [_store() for _ in list] 
    5766        self.reset() 
    58      
     67 
    5968    def index(self, row, column=0, parent=QModelIndex()): 
    60         return QAbstractListModel.createIndex(self, row, column, parent) 
    61      
     69        if self._is_index_valid_for(row, self) and column == 0: 
     70            return QAbstractListModel.createIndex(self, row, column, parent) 
     71        else: 
     72            return QModelIndex() 
     73 
    6274    def headerData(self, section, orientation, role=Qt.DisplayRole): 
    6375        if role == Qt.DisplayRole: 
    6476            return QVariant(str(section)) 
    65      
     77 
    6678    def rowCount(self, parent=QModelIndex()): 
    6779        return 0 if parent.isValid() else len(self) 
    68      
     80 
    6981    def columnCount(self, parent=QModelIndex()): 
    7082        return 0 if parent.isValid() else 1 
    71      
     83 
    7284    def data(self, index, role=Qt.DisplayRole): 
    7385        row = index.row() 
    74         if role in [self.list_item_role, Qt.EditRole]: 
    75             return QVariant(self[index.row()]) 
    76         else: 
    77             return QVariant(self._other_data[index.row()].get(role, QVariant())) 
    78      
     86        if role in [self.list_item_role, Qt.EditRole] \ 
     87                and self._is_index_valid_for(index, self): 
     88            return QVariant(self[row]) 
     89        elif self._is_index_valid_for(row, self._other_data): 
     90            return QVariant(self._other_data[row].get(role, QVariant())) 
     91        else: 
     92            return QVariant() 
     93 
    7994    def itemData(self, index): 
    8095        map = QAbstractListModel.itemData(self, index) 
    81         for key, value in self._other_data[index.row()].items(): 
     96        if self._is_index_valid_for(index, self._other_data): 
     97            items = self._other_data[index.row()].items() 
     98        else: 
     99            items = [] 
     100 
     101        for key, value in items: 
    82102            map[key] = QVariant(value) 
     103 
    83104        return map 
    84      
     105 
    85106    def parent(self, index=QModelIndex()): 
    86107        return QModelIndex() 
    87      
     108 
    88109    def setData(self, index, value, role=Qt.EditRole): 
    89         if role == Qt.EditRole: 
     110        if role == Qt.EditRole and self._is_index_valid_for(index, self): 
    90111            obj = value.toPyObject() 
    91             self[index.row()] = obj 
    92         else: 
     112            self[index.row()] = obj # Will emit proper dataChanged signal 
     113            return True 
     114        elif self._is_index_valid_for(index, self._other_data): 
    93115            self._other_data[index.row()][role] = value 
    94116            self.emit(SIGNAL("dataChanged(QModelIndex, QModelIndex)"), index, index) 
    95         return True 
    96          
     117            return True 
     118        else: 
     119            return False 
     120 
    97121    def setItemData(self, index, data): 
    98122        data = dict(data) 
    99123        with signal_blocking(self): 
    100124            for role, value in data.items(): 
    101                 if role == Qt.EditRole: 
     125                if role == Qt.EditRole and \ 
     126                        self._is_index_valid_for(index, self): 
    102127                    self[index.row()] = value.toPyObject() 
    103                 else: 
     128                elif self._is_index_valid_for(index, self._other_data): 
    104129                    self._other_data[index.row()][role] = value 
    105                      
     130 
    106131        self.emit(SIGNAL("dataChanged(QModelIndex, QModelIndex)"), index, index) 
    107132        return True 
    108 #        return QAbstractListModel.setItemData(self, index, data) 
    109      
     133 
    110134    def flags(self, index): 
    111         if index.isValid() and index.row() < len(self._other_data): 
     135        if self._is_index_valid_for(index, self._other_data): 
    112136            return self._other_data[index.row()].get("flags", self._flags) 
    113137        else: 
    114138            return self._flags | Qt.ItemIsDropEnabled 
    115          
     139 
    116140    def insertRows(self, row, count, parent=QModelIndex()): 
    117141        """ Insert ``count`` rows at ``row``, the list fill be filled  
    118142        with ``None``  
    119143        """ 
    120 #        print "Insert", row, count 
    121144        if not parent.isValid(): 
    122145            self.__setslice__(row, row, [None] * count) 
     
    124147        else: 
    125148            return False 
    126          
     149 
    127150    def removeRows(self, row, count, parent=QModelIndex()): 
     151        """Remove ``count`` rows starting at ``row`` 
    128152        """ 
    129         """ 
    130 #        print "Remove", row, count 
    131153        if not parent.isValid(): 
    132154            self.__delslice__(row, row + count) 
     
    134156        else: 
    135157            return False 
    136      
     158 
    137159    def extend(self, iterable): 
    138160        list_ = list(iterable) 
     
    141163        self._other_data.extend([_store() for _ in list_]) 
    142164        self.endInsertRows() 
    143      
     165 
    144166    def append(self, item): 
    145167        self.extend([item]) 
    146          
     168 
    147169    def insert(self, i, val): 
    148170        self.beginInsertRows(QModelIndex(), i, i) 
     
    150172        self._other_data.insert(i, _store()) 
    151173        self.endInsertRows() 
    152          
     174 
    153175    def remove(self, val): 
    154176        i = self._list.index(val) 
    155177        self.__delitem__(i) 
    156          
     178 
    157179    def pop(self, i): 
    158180        item = self._list[i] 
    159181        self.__delitem__(i) 
    160182        return item 
    161      
     183 
    162184    def __len__(self): 
    163185        return len(self._list) 
    164      
     186 
    165187    def __iter__(self): 
    166188        return iter(self._list) 
    167      
     189 
    168190    def __getitem__(self, i): 
    169191        return self._list[i] 
    170      
     192 
    171193    def __getslice__(self, i, j): 
    172194        return self._list[i:j] 
    173          
     195 
    174196    def __add__(self, iterable): 
    175         # Does not preserve flags or other data. 
    176         return PyListModel(self._list + iterable, self.parent()) 
    177      
     197        new_list = PyListModel(list(self._list),  
     198                           self.parent(), 
     199                           flags=self._flags, 
     200                           list_item_role=self.list_item_role, 
     201                           supportedDropActions=self.supportedDropActions() 
     202                           ) 
     203        new_list._other_data = list(self._other_data) 
     204        new_list.extend(iterable) 
     205        return new_list 
     206 
    178207    def __iadd__(self, iterable): 
    179208        self.extend(iterable) 
    180          
     209 
    181210    def __delitem__(self, i): 
    182211        self.beginRemoveRows(QModelIndex(), i, i) 
     
    184213        del self._other_data[i] 
    185214        self.endRemoveRows() 
    186          
     215 
    187216    def __delslice__(self, i, j): 
    188217        if j > i: 
     
    191220            del self._other_data[i:j] 
    192221            self.endRemoveRows() 
    193          
     222 
    194223    def __setitem__(self, i, value): 
    195224        self._list[i] = value 
    196225        self.emit(SIGNAL("dataChanged(QModelIndex, QModelIndex)"), self.index(i), self.index(i)) 
    197          
     226 
    198227    def __setslice__(self, i, j, iterable): 
    199228        self.__delslice__(i, j) 
     
    204233            self._other_data[i:i] = [_store() for _ in all] 
    205234            self.endInsertRows() 
    206          
     235 
    207236    def reverse(self): 
    208237        self._list.reverse() 
    209238        self._other_data.reverse() 
    210239        self.emit(SIGNAL("dataChanged(QModelIndex, QModelIndex)"), self.index(0), self.index(len(self) -1)) 
    211          
     240 
    212241    def sort(self, *args, **kwargs): 
    213242        indices = _argsort(self._list, *args, **kwargs) 
     
    217246            self._list[i] = new_l 
    218247            self._other_data[i] = new_o 
    219 #        self._list.sort(*args, **kwargs) 
    220248        self.emit(SIGNAL("dataChanged(QModelIndex, QModelIndex)"), self.index(0), self.index(len(self) -1)) 
    221          
     249 
    222250    def __repr__(self): 
    223251        return "PyListModel(%s)" % repr(self._list) 
    224      
     252 
    225253    def __nonzero__(self): 
    226254        return len(self) != 0 
    227      
     255 
    228256    #for Python 3000 
    229257    def __bool__(self): 
    230258        return len(self) != 0 
    231      
     259 
    232260    def emitDataChanged(self, indexList): 
    233261        if isinstance(indexList, int): 
    234262            indexList = [indexList] 
     263 
     264        #TODO: group indexes into ranges 
    235265        for ind in indexList: 
    236266            self.emit(SIGNAL("dataChanged(QModelIndex, QModelIndex)"), self.index(ind), self.index(ind)) 
    237              
     267 
    238268    ########### 
    239269    # Drag/drop 
    240270    ########### 
    241      
     271 
    242272    def supportedDropActions(self): 
    243273        return self._supportedDropActions 
    244      
     274 
    245275    def decode_qt_data(self, data): 
    246276        """ Decode internal Qt 'application/x-qabstractitemmodeldatalist' 
     
    260290            items.append((row, column, item)) 
    261291        return items 
    262      
     292 
    263293    def mimeTypes(self): 
    264294        return self.MIME_TYPES + list(QAbstractListModel.mimeTypes(self)) 
    265      
     295 
    266296    def mimeData(self, indexlist): 
    267297        if len(indexlist) <= 0: 
    268298            return None 
    269          
     299 
    270300        items = [self[i.row()] for i in indexlist] 
    271301        mime = QAbstractListModel.mimeData(self, indexlist) 
     
    274304        mime._items = items 
    275305        return mime 
    276      
     306 
    277307    def dropMimeData(self, mime, action, row, column, parent): 
    278308        if action == Qt.IgnoreAction: 
    279309            return True 
    280          
     310 
    281311        if not mime.hasFormat(self.MIME_TYPE): 
    282312            return False 
    283          
     313 
    284314        if hasattr(mime, "_vars"): 
    285315            vars = mime._vars 
     
    287317            desc = str(mime.data(self.MIME_TYPE)) 
    288318            vars = cPickle.loads(desc) 
    289          
     319 
    290320        return QAbstractListModel.dropMimeData(self, mime, action, row, column, parent) 
    291      
    292      
     321 
     322 
    293323import OWGUI 
    294324import orange 
     
    297327 
    298328class VariableListModel(PyListModel): 
    299      
     329 
    300330    MIME_TYPE = "application/x-Orange-VariableList" 
    301      
     331 
    302332    def data(self, index, role=Qt.DisplayRole): 
    303         i = index.row() 
    304         var = self[i] 
    305         if role == Qt.DisplayRole: 
    306             return QVariant(var.name) 
    307         elif role == Qt.DecorationRole: 
    308             return QVariant(OWGUI.getAttributeIcons().get(var.varType, -1)) 
    309         elif role == Qt.ToolTipRole: 
    310             return QVariant(self.variable_tooltip(var)) 
    311         else: 
    312             return PyListModel.data(self, index, role) 
    313          
     333        if self._is_index_valid_for(index, self): 
     334            i = index.row() 
     335            var = self[i] 
     336            if role == Qt.DisplayRole: 
     337                return QVariant(var.name) 
     338            elif role == Qt.DecorationRole: 
     339                return QVariant(OWGUI.getAttributeIcons().get(var.varType, -1)) 
     340            elif role == Qt.ToolTipRole: 
     341                return QVariant(self.variable_tooltip(var)) 
     342            else: 
     343                return PyListModel.data(self, index, role) 
     344        else: 
     345            return QVariant() 
     346 
    314347    def variable_tooltip(self, var): 
    315348        if isinstance(var, Orange.feature.Discrete): 
     
    319352        elif isinstance(var, Orange.feature.String): 
    320353            return self.string_variable_tooltip(var) 
    321          
     354 
    322355    def variable_labels_tooltip(self, var): 
    323356        text = "" 
     
    329362            text += "<br/>".join(labels) 
    330363        return text 
    331              
     364 
    332365    def discrete_variable_tooltip(self, var): 
    333366        text = "<b>%s</b><br/>Discrete with %i values: " % (safe_text(var.name), len(var.values)) 
     
    335368        text += self.variable_labels_tooltip(var) 
    336369        return text 
    337              
     370 
    338371    def continuous_variable_toltip(self, var): 
    339372        text = "<b>%s</b><br/>Continuous" % safe_text(var.name) 
    340373        text += self.variable_labels_tooltip(var) 
    341374        return text 
    342      
     375 
    343376    def string_variable_tooltip(self, var): 
    344377        text = "<b>%s</b><br/>String" % safe_text(var.name) 
    345378        text += self.variable_labels_tooltip(var) 
    346379        return text 
    347      
     380 
    348381    def python_variable_tooltip(self, var): 
    349382        text = "<b>%s</b><br/>Python" % safe_text(var.name) 
    350383        text += self.variable_labels_tooltip(var) 
    351384        return text 
    352      
     385 
    353386_html_replace = [("<", "&lt;"), (">", "&gt;")] 
    354387 
  • Orange/OrangeWidgets/Regression/OWSVMRegression.py

    r9671 r10729  
    1818 
    1919class OWSVMRegression(OWSVM): 
     20    settingsList = OWSVM.settingsList + ["C_epsilon", "C_nu"] 
     21 
    2022    def __init__(self, parent=None, signalManager=None, title="SVM Regression"): 
    2123        OWWidget.__init__(self, parent, signalManager, title, wantMainArea=False) 
    22          
     24 
    2325        self.inputs=[("Data", Orange.data.Table, self.setData),  
    2426                     ("Preprocess", PreprocessedLearner, self.setPreprocessor)] 
    25          
     27 
    2628        self.outputs=[("Learner", orange.Learner, Default), 
    2729                      ("Predictor", orange.Classifier, Default), 
     
    3537        self.coef0 = 0.0 
    3638        self.degree = 3 
    37         self.C = 1.0 
     39        self.C_epsilon = 1.0 
     40        self.C_nu = 1.0 
    3841        self.p = 0.1 
    3942        self.eps = 1e-3 
    4043        self.nu = 0.5 
    4144        self.shrinking = 1 
    42         self.probability=1 
    43         self.useNu=0 
    44         self.nomogram=0 
    45         self.normalization=1 
     45        self.probability = 1 
     46        self.useNu = 0 
     47        self.nomogram = 0 
     48        self.normalization = 1 
    4649        self.data = None 
    47         self.selFlag=False 
     50        self.selFlag = False 
    4851        self.preprocessor = None 
    4952        self.name = "SVM Regression" 
    50          
     53 
    5154        self.loadSettings() 
    5255 
    53          
    54         OWGUI.lineEdit(self.controlArea, self, 'name', box='Learner/predictor Name', 
     56        OWGUI.lineEdit(self.controlArea, self, 'name', 
     57                      box='Learner/predictor Name', 
    5558                       tooltip='Name to be used by other widgets to identify your learner/predictor.') 
    5659        OWGUI.separator(self.controlArea) 
    5760 
    5861        b = OWGUI.radioButtonsInBox(self.controlArea, self, "useNu", [],  
    59                                     box="SVM Type",  
    60                                     orientation = QGridLayout(),  
     62                                    box="SVM Type", 
     63                                    orientation = QGridLayout(), 
    6164                                    addSpace=True) 
    62          
     65 
    6366        # Epsilon SVR 
    6467        b.layout().addWidget(OWGUI.appendRadioButton(b, self,  
     
    6972         
    7073        b.layout().addWidget(QLabel("Cost (C)", b), 0, 1, Qt.AlignRight) 
    71         b.layout().addWidget(OWGUI.doubleSpin(b, self, "C", 0.5, 512.0, 0.5,  
    72                           addToLayout=False,  
    73                           callback=lambda *x: self.setType(0),  
     74        b.layout().addWidget(OWGUI.doubleSpin(b, self, "C_epsilon", 0.1, 512.0, 0.1, 
     75                          decimals=2, 
     76                          addToLayout=False, 
     77                          callback=lambda *x: self.setType(0), 
    7478                          alignment=Qt.AlignRight, 
    7579                          tooltip="Cost for out of epsilon training points."), 
    7680                          0, 2) 
    77          
     81     
    7882        b.layout().addWidget(QLabel(u"Loss Epsilon (ε)", b), 1, 1, Qt.AlignRight) 
    7983        b.layout().addWidget(OWGUI.doubleSpin(b, self, "p", 0.05, 1.0, 0.05, 
     
    8488                                      ), 
    8589                             1, 2) 
    86          
     90 
    8791        # Nu SVR 
    88         b.layout().addWidget(OWGUI.appendRadioButton(b, self,  
     92        b.layout().addWidget(OWGUI.appendRadioButton(b, self, 
    8993                                                "useNu", u"ν-SVR", 
    9094                                                tooltip="Nu SVR", 
     
    9296                             2, 0, Qt.AlignLeft) 
    9397         
    94         b.layout().addWidget(QLabel("Cost (C)", b),  
     98        b.layout().addWidget(QLabel("Cost (C)", b), 
    9599                             2, 1, Qt.AlignRight) 
    96         b.layout().addWidget(OWGUI.doubleSpin(b, self, "C", 0.5, 512.0, 0.5,  
    97                         addToLayout=False,  
    98                         callback=lambda *x: self.setType(0),  
     100        b.layout().addWidget(OWGUI.doubleSpin(b, self, "C_nu", 0.1, 512.0, 0.1, 
     101                        decimals=2,  
     102                        addToLayout=False, 
     103                        callback=lambda *x: self.setType(1), 
    99104                        alignment=Qt.AlignRight, 
    100105                        tooltip="Cost for out of epsilon training points."), 
     
    103108        b.layout().addWidget(QLabel(u"Complexity bound (\u03bd)", b), 
    104109                             3, 1, Qt.AlignRight) 
    105         b.layout().addWidget(OWGUI.doubleSpin(b, self, "nu", 0.1, 1.0, 0.1, 
     110        b.layout().addWidget(OWGUI.doubleSpin(b, self, "nu", 0.05, 1.0, 0.05, 
    106111                        tooltip="Lower bound on the ratio of support vectors", 
    107112                        addToLayout=False,  
     
    122127        self.gcd = OWGUI.widgetBox(b, orientation="horizontal") 
    123128        self.leg = OWGUI.doubleSpin(self.gcd, self, "gamma", 0.0, 10.0, 0.0001, 
     129                                    decimals=5, 
    124130                                    label="  g: ", orientation="horizontal", 
    125131                                    callback=self.changeKernel,  
     
    177183         
    178184    def applySettings(self): 
    179         learner = svm.SVMLearner(svm_type=svm.SVMLearner.Nu_SVR  
    180                                           if self.useNu else 
    181                                           svm.SVMLearner.Epsilon_SVR, 
    182                                  C=self.C, 
     185        if self.useNu: 
     186            svm_type = svm.SVMLearner.Nu_SVR 
     187            C = self.C_nu 
     188        else: 
     189            svm_type = svm.SVMLearner.Epsilon_SVR 
     190            C = self.C_epsilon 
     191 
     192        learner = svm.SVMLearner(svm_type=svm_type, 
     193                                 C=C, 
    183194                                 p=self.p, 
    184195                                 nu=self.nu, 
     
    195206        if self.preprocessor: 
    196207            learner = self.preprocessor.wrapLearner(learner) 
    197          
     208 
    198209        if self.data is not None: 
    199210            predictor = learner(self.data) 
    200211            support_vectors = predictor.support_vectors 
    201212            predictor.name = self.name 
    202              
     213 
    203214        self.send("Learner", learner) 
    204215        self.send("Predictor", predictor) 
    205216        self.send("Support Vectors", support_vectors) 
    206          
     217 
    207218    def sendReport(self): 
    208219        if self.useNu: 
    209220            settings = [("Type", "Nu SVM regression"), 
    210                         ("Cost (C)", "%.3f" % self.C), 
    211                         ("Complexity bound (nu)", "%.2f" % self.nu)] 
     221                        ("Cost (C)", "%.3f" % self.C_nu), 
     222                        ("Complexity bound (nu)", "%.3f" % self.nu)] 
    212223        else: 
    213224            settings = [("Type", "Epsilon SVM regression"), 
    214                         ("Cost (C)", "%.3f" % self.C), 
     225                        ("Cost (C)", "%.3f" % self.C_epsilon), 
    215226                        ("Loss epsilon", "%.3f" % self.p)] 
    216              
     227 
    217228        if self.kernel_type == 0: 
    218229            kernel = "Linear, x.y" 
     
    223234        else: 
    224235            kernel = "Sigmoid, tanh(%.4f*x.y+%.4f)" % (self.gamma, self.coef0) 
    225              
     236 
    226237        settings.extend([("Kernel", kernel), 
    227238                         ("Tolerance", self.eps), 
    228239                         ("Normalize data", OWGUI.YesNo[self.normalization])]) 
    229          
    230              
     240 
    231241        self.reportSettings("Settings", settings) 
    232242        self.reportData(self.data) 
    233              
    234          
     243 
     244    def search_(self): 
     245        learner = orngSVM.SVMLearner() 
     246        for attr in ("name", "kernel_type", "degree", "shrinking", "probability", "normalization"): 
     247            setattr(learner, attr, getattr(self, attr)) 
     248 
     249        for attr in ("gamma", "coef0", "p", "eps", "nu"): 
     250            setattr(learner, attr, float(getattr(self, attr))) 
     251 
     252        if self.useNu: 
     253            learner.svm_type = learner.Nu_SVR 
     254            learner.C = self.C_nu 
     255        else: 
     256            learner.svm_type = learner.Epsilon_SVR 
     257            learner.C = self.C_epsilon 
     258 
     259        params = []         
     260        params.append("C") 
     261        if self.kernel_type in [1, 2]: 
     262            params.append("gamma") 
     263        if self.kernel_type == 1: 
     264            params.append("degree") 
     265        try: 
     266            learner.tuneParameters(self.data, params, 4, verbose=0, 
     267                                   progressCallback=self.progres) 
     268        except UnhandledException: 
     269            pass 
     270        for param in params: 
     271            setattr(self, param, getattr(learner, param)) 
     272 
     273        if self.useNu: 
     274            self.C_nu = learner.C 
     275        else: 
     276            self.C_epsilon = learner.C 
     277 
     278        self.finishSearch() 
     279 
    235280if __name__ == "__main__": 
    236281    app = QApplication([]) 
Note: See TracChangeset for help on using the changeset viewer.