def create_model(rows, columns): model = QStandardItemModel() model.setRowCount(rows) model.setColumnCount(columns) for i in range(rows): for j in range(columns): model.setItemData(model.index(i, j), { Qt.DisplayRole: f"{i}x{j}", Qt.UserRole: i * j, }) return model
def test_blockselectionmodel(self): model = QStandardItemModel() model.setRowCount(4) model.setColumnCount(4) sel = BlockSelectionModel(model) sel.select(model.index(0, 0), BlockSelectionModel.Select) self.assertSetEqual(selected(sel), {(0, 0)}) sel.select(model.index(0, 1), BlockSelectionModel.Select) self.assertSetEqual(selected(sel), {(0, 0), (0, 1)}) sel.select(model.index(1, 1), BlockSelectionModel.Select) self.assertSetEqual(selected(sel), {(0, 0), (0, 1), (1, 0), (1, 1)}) sel.select(model.index(0, 0), BlockSelectionModel.Deselect) self.assertSetEqual(selected(sel), {(1, 1)}) sel.select(model.index(3, 3), BlockSelectionModel.ClearAndSelect) self.assertSetEqual(selected(sel), {(3, 3)})
def test_symmetricselectionmodel(self): model = QStandardItemModel() model.setRowCount(4) model.setColumnCount(4) sel = SymmetricSelectionModel(model) sel.select(model.index(0, 0), BlockSelectionModel.Select) self.assertSetEqual(selected(sel), {(0, 0)}) sel.select(model.index(0, 2), BlockSelectionModel.Select) self.assertSetEqual(selected(sel), {(0, 0), (0, 2), (2, 0), (2, 2)}) sel.select(model.index(0, 0), BlockSelectionModel.Deselect) self.assertSetEqual(selected(sel), {(2, 2)}) sel.select(model.index(2, 3), BlockSelectionModel.ClearAndSelect) self.assertSetEqual(selected(sel), {(2, 2), (2, 3), (3, 2), (3, 3)}) self.assertSetEqual(set(sel.selectedItems()), {2, 3}) sel.setSelectedItems([1, 2]) self.assertSetEqual(set(sel.selectedItems()), {1, 2})
def test_table_view_selection_finished(self): model = QStandardItemModel() model.setRowCount(10) model.setColumnCount(4) view = TableView() view.setModel(model) view.adjustSize() spy = QSignalSpy(view.selectionFinished) rect0 = view.visualRect(model.index(0, 0)) rect4 = view.visualRect(model.index(4, 2)) QTest.mousePress( view.viewport(), Qt.LeftButton, Qt.NoModifier, rect0.center(), ) self.assertEqual(len(spy), 0) QTest.mouseRelease( view.viewport(), Qt.LeftButton, Qt.NoModifier, rect4.center(), ) self.assertEqual(len(spy), 1)
def test_header_view_clickable(self): model = QStandardItemModel() model.setColumnCount(3) header = HeaderView(Qt.Horizontal) header.setModel(model) header.setSectionsClickable(True) header.adjustSize() pos = header.sectionViewportPosition(0) size = header.sectionSize(0) # center of first section point = QPoint(pos + size // 2, header.viewport().height() / 2) QTest.mousePress(header.viewport(), Qt.LeftButton, Qt.NoModifier, point) opt = QStyleOptionHeader() header.initStyleOptionForIndex(opt, 0) self.assertTrue(opt.state & QStyle.State_Sunken) QTest.mouseRelease(header.viewport(), Qt.LeftButton, Qt.NoModifier, point) opt = QStyleOptionHeader() header.initStyleOptionForIndex(opt, 0) self.assertFalse(opt.state & QStyle.State_Sunken)
class OWConfusionMatrix(widget.OWWidget): """Confusion matrix widget""" name = "Confusion Matrix" description = "Display a confusion matrix constructed from " \ "the results of classifier evaluations." icon = "icons/ConfusionMatrix.svg" priority = 1001 class Inputs: evaluation_results = Input("Evaluation Results", Orange.evaluation.Results) class Outputs: selected_data = Output("Selected Data", Orange.data.Table, default=True) annotated_data = Output(ANNOTATED_DATA_SIGNAL_NAME, Orange.data.Table) quantities = [ "Number of instances", "Proportion of predicted", "Proportion of actual" ] settings_version = 1 settingsHandler = settings.ClassValuesContextHandler() selected_learner = settings.Setting([0], schema_only=True) selection = settings.ContextSetting(set()) selected_quantity = settings.Setting(0) append_predictions = settings.Setting(True) append_probabilities = settings.Setting(False) autocommit = settings.Setting(True) UserAdviceMessages = [ widget.Message( "Clicking on cells or in headers outputs the corresponding " "data instances", "click_cell") ] class Error(widget.OWWidget.Error): no_regression = Msg("Confusion Matrix cannot show regression results.") invalid_values = Msg( "Evaluation Results input contains invalid values") def __init__(self): super().__init__() self.data = None self.results = None self.learners = [] self.headers = [] self.learners_box = gui.listBox(self.controlArea, self, "selected_learner", "learners", box=True, callback=self._learner_changed) self.outputbox = gui.vBox(self.controlArea, "Output") box = gui.hBox(self.outputbox) gui.checkBox(box, self, "append_predictions", "Predictions", callback=self._invalidate) gui.checkBox(box, self, "append_probabilities", "Probabilities", callback=self._invalidate) gui.auto_commit(self.outputbox, self, "autocommit", "Send Selected", "Send Automatically", box=False) self.mainArea.layout().setContentsMargins(0, 0, 0, 0) box = gui.vBox(self.mainArea, box=True) sbox = gui.hBox(box) gui.rubber(sbox) gui.comboBox(sbox, self, "selected_quantity", items=self.quantities, label="Show: ", orientation=Qt.Horizontal, callback=self._update) self.tablemodel = QStandardItemModel(self) view = self.tableview = QTableView( editTriggers=QTableView.NoEditTriggers) view.setModel(self.tablemodel) view.horizontalHeader().hide() view.verticalHeader().hide() view.horizontalHeader().setMinimumSectionSize(60) view.selectionModel().selectionChanged.connect(self._invalidate) view.setShowGrid(False) view.setItemDelegate(BorderedItemDelegate(Qt.white)) view.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.MinimumExpanding) view.clicked.connect(self.cell_clicked) box.layout().addWidget(view) selbox = gui.hBox(box) gui.button(selbox, self, "Select Correct", callback=self.select_correct, autoDefault=False) gui.button(selbox, self, "Select Misclassified", callback=self.select_wrong, autoDefault=False) gui.button(selbox, self, "Clear Selection", callback=self.select_none, autoDefault=False) def sizeHint(self): """Initial size""" return QSize(750, 340) def _item(self, i, j): return self.tablemodel.item(i, j) or QStandardItem() def _set_item(self, i, j, item): self.tablemodel.setItem(i, j, item) def _init_table(self, nclasses): item = self._item(0, 2) item.setData("Predicted", Qt.DisplayRole) item.setTextAlignment(Qt.AlignCenter) item.setFlags(Qt.NoItemFlags) self._set_item(0, 2, item) item = self._item(2, 0) item.setData("Actual", Qt.DisplayRole) item.setTextAlignment(Qt.AlignHCenter | Qt.AlignBottom) item.setFlags(Qt.NoItemFlags) self.tableview.setItemDelegateForColumn(0, gui.VerticalItemDelegate()) self._set_item(2, 0, item) self.tableview.setSpan(0, 2, 1, nclasses) self.tableview.setSpan(2, 0, nclasses, 1) font = self.tablemodel.invisibleRootItem().font() bold_font = QFont(font) bold_font.setBold(True) for i in (0, 1): for j in (0, 1): item = self._item(i, j) item.setFlags(Qt.NoItemFlags) self._set_item(i, j, item) for p, label in enumerate(self.headers): for i, j in ((1, p + 2), (p + 2, 1)): item = self._item(i, j) item.setData(label, Qt.DisplayRole) item.setFont(bold_font) item.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter) item.setFlags(Qt.ItemIsEnabled) if p < len(self.headers) - 1: item.setData("br"[j == 1], BorderRole) item.setData(QColor(192, 192, 192), BorderColorRole) self._set_item(i, j, item) hor_header = self.tableview.horizontalHeader() if len(' '.join(self.headers)) < 120: hor_header.setSectionResizeMode(QHeaderView.ResizeToContents) else: hor_header.setDefaultSectionSize(60) self.tablemodel.setRowCount(nclasses + 3) self.tablemodel.setColumnCount(nclasses + 3) @Inputs.evaluation_results def set_results(self, results): """Set the input results.""" prev_sel_learner = self.selected_learner.copy() self.clear() self.warning() self.closeContext() data = None if results is not None and results.data is not None: data = results.data[results.row_indices] if data is not None and not data.domain.has_discrete_class: self.Error.no_regression() data = results = None else: self.Error.no_regression.clear() nan_values = False if results is not None: assert isinstance(results, Orange.evaluation.Results) if np.any(np.isnan(results.actual)) or \ np.any(np.isnan(results.predicted)): # Error out here (could filter them out with a warning # instead). nan_values = True results = data = None if nan_values: self.Error.invalid_values() else: self.Error.invalid_values.clear() self.results = results self.data = data if data is not None: class_values = data.domain.class_var.values elif results is not None: raise NotImplementedError if results is None: self.report_button.setDisabled(True) else: self.report_button.setDisabled(False) nmodels = results.predicted.shape[0] self.headers = class_values + \ [unicodedata.lookup("N-ARY SUMMATION")] # NOTE: The 'learner_names' is set in 'Test Learners' widget. if hasattr(results, "learner_names"): self.learners = results.learner_names else: self.learners = [ "Learner #{}".format(i + 1) for i in range(nmodels) ] self._init_table(len(class_values)) self.openContext(data.domain.class_var) if not prev_sel_learner or prev_sel_learner[0] >= len( self.learners): if self.learners: self.selected_learner[:] = [0] else: self.selected_learner[:] = prev_sel_learner self._update() self._set_selection() self.unconditional_commit() def clear(self): """Reset the widget, clear controls""" self.results = None self.data = None self.tablemodel.clear() self.headers = [] # Clear learners last. This action will invoke `_learner_changed` self.learners = [] def select_correct(self): """Select the diagonal elements of the matrix""" selection = QItemSelection() n = self.tablemodel.rowCount() for i in range(2, n): index = self.tablemodel.index(i, i) selection.select(index, index) self.tableview.selectionModel().select( selection, QItemSelectionModel.ClearAndSelect) def select_wrong(self): """Select the off-diagonal elements of the matrix""" selection = QItemSelection() n = self.tablemodel.rowCount() for i in range(2, n): for j in range(i + 1, n): index = self.tablemodel.index(i, j) selection.select(index, index) index = self.tablemodel.index(j, i) selection.select(index, index) self.tableview.selectionModel().select( selection, QItemSelectionModel.ClearAndSelect) def select_none(self): """Reset selection""" self.tableview.selectionModel().clear() def cell_clicked(self, model_index): """Handle cell click event""" i, j = model_index.row(), model_index.column() if not i or not j: return n = self.tablemodel.rowCount() index = self.tablemodel.index selection = None if i == j == 1 or i == j == n - 1: selection = QItemSelection(index(2, 2), index(n - 1, n - 1)) elif i in (1, n - 1): selection = QItemSelection(index(2, j), index(n - 1, j)) elif j in (1, n - 1): selection = QItemSelection(index(i, 2), index(i, n - 1)) if selection is not None: self.tableview.selectionModel().select( selection, QItemSelectionModel.ClearAndSelect) def _prepare_data(self): indices = self.tableview.selectedIndexes() indices = {(ind.row() - 2, ind.column() - 2) for ind in indices} actual = self.results.actual learner_name = self.learners[self.selected_learner[0]] predicted = self.results.predicted[self.selected_learner[0]] selected = [ i for i, t in enumerate(zip(actual, predicted)) if t in indices ] extra = [] class_var = self.data.domain.class_var metas = self.data.domain.metas if self.append_predictions: extra.append(predicted.reshape(-1, 1)) var = Orange.data.DiscreteVariable( "{}({})".format(class_var.name, learner_name), class_var.values) metas = metas + (var, ) if self.append_probabilities and \ self.results.probabilities is not None: probs = self.results.probabilities[self.selected_learner[0]] extra.append(np.array(probs, dtype=object)) pvars = [ Orange.data.ContinuousVariable("p({})".format(value)) for value in class_var.values ] metas = metas + tuple(pvars) domain = Orange.data.Domain(self.data.domain.attributes, self.data.domain.class_vars, metas) data = self.data.transform(domain) if len(extra): data.metas[:, len(self.data.domain.metas):] = \ np.hstack(tuple(extra)) data.name = learner_name if selected: annotated_data = create_annotated_table(data, selected) data = data[selected] else: annotated_data = create_annotated_table(data, []) data = None return data, annotated_data def commit(self): """Output data instances corresponding to selected cells""" if self.results is not None and self.data is not None \ and self.selected_learner: data, annotated_data = self._prepare_data() else: data = None annotated_data = None self.Outputs.selected_data.send(data) self.Outputs.annotated_data.send(annotated_data) def _invalidate(self): indices = self.tableview.selectedIndexes() self.selection = {(ind.row() - 2, ind.column() - 2) for ind in indices} self.commit() def _set_selection(self): selection = QItemSelection() index = self.tableview.model().index for row, col in self.selection: sel = index(row + 2, col + 2) selection.select(sel, sel) self.tableview.selectionModel().select( selection, QItemSelectionModel.ClearAndSelect) def _learner_changed(self): self._update() self._set_selection() self.commit() def _update(self): def _isinvalid(x): return isnan(x) or isinf(x) # Update the displayed confusion matrix if self.results is not None and self.selected_learner: cmatrix = confusion_matrix(self.results, self.selected_learner[0]) colsum = cmatrix.sum(axis=0) rowsum = cmatrix.sum(axis=1) n = len(cmatrix) diag = np.diag_indices(n) colors = cmatrix.astype(np.double) colors[diag] = 0 if self.selected_quantity == 0: normalized = cmatrix.astype(np.int) formatstr = "{}" div = np.array([colors.max()]) else: if self.selected_quantity == 1: normalized = 100 * cmatrix / colsum div = colors.max(axis=0) else: normalized = 100 * cmatrix / rowsum[:, np.newaxis] div = colors.max(axis=1)[:, np.newaxis] formatstr = "{:2.1f} %" div[div == 0] = 1 colors /= div colors[diag] = normalized[diag] / normalized[diag].max() for i in range(n): for j in range(n): val = normalized[i, j] col_val = colors[i, j] item = self._item(i + 2, j + 2) item.setData( "NA" if _isinvalid(val) else formatstr.format(val), Qt.DisplayRole) bkcolor = QColor.fromHsl( [0, 240][i == j], 160, 255 if _isinvalid(col_val) else int(255 - 30 * col_val)) item.setData(QBrush(bkcolor), Qt.BackgroundRole) item.setData("trbl", BorderRole) item.setToolTip("actual: {}\npredicted: {}".format( self.headers[i], self.headers[j])) item.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter) item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable) self._set_item(i + 2, j + 2, item) bold_font = self.tablemodel.invisibleRootItem().font() bold_font.setBold(True) def _sum_item(value, border=""): item = QStandardItem() item.setData(value, Qt.DisplayRole) item.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter) item.setFlags(Qt.ItemIsEnabled) item.setFont(bold_font) item.setData(border, BorderRole) item.setData(QColor(192, 192, 192), BorderColorRole) return item for i in range(n): self._set_item(n + 2, i + 2, _sum_item(int(colsum[i]), "t")) self._set_item(i + 2, n + 2, _sum_item(int(rowsum[i]), "l")) self._set_item(n + 2, n + 2, _sum_item(int(rowsum.sum()))) def send_report(self): """Send report""" if self.results is not None and self.selected_learner: self.report_table( "Confusion matrix for {} (showing {})".format( self.learners[self.selected_learner[0]], self.quantities[self.selected_quantity].lower()), self.tableview) @classmethod def migrate_settings(cls, settings, version): if not version: # For some period of time the 'selected_learner' property was # changed from List[int] -> int # (commit 4e49bb3fd0e11262f3ebf4b1116a91a4b49cc982) and then back # again (commit 8a492d79a2e17154a0881e24a05843406c8892c0) if "selected_learner" in settings and \ isinstance(settings["selected_learner"], int): settings["selected_learner"] = [settings["selected_learner"]]
class ScoreTable(OWComponent, QObject): shown_scores = \ Setting(set(chain(*BUILTIN_SCORERS_ORDER.values()))) shownScoresChanged = Signal() class ItemDelegate(QStyledItemDelegate): def sizeHint(self, *args): size = super().sizeHint(*args) return QSize(size.width(), size.height() + 6) def displayText(self, value, locale): if isinstance(value, float): return f"{value:.3f}" else: return super().displayText(value, locale) def __init__(self, master): QObject.__init__(self) OWComponent.__init__(self, master) self.view = gui.TableView(wordWrap=True, editTriggers=gui.TableView.NoEditTriggers) header = self.view.horizontalHeader() header.setSectionResizeMode(QHeaderView.ResizeToContents) header.setDefaultAlignment(Qt.AlignCenter) header.setStretchLastSection(False) header.setContextMenuPolicy(Qt.CustomContextMenu) header.customContextMenuRequested.connect(self.show_column_chooser) self.model = QStandardItemModel(master) self.model.setHorizontalHeaderLabels(["Method"]) self.sorted_model = ScoreModel() self.sorted_model.setSourceModel(self.model) self.view.setModel(self.sorted_model) self.view.setItemDelegate(self.ItemDelegate()) def _column_names(self): return (self.model.horizontalHeaderItem(section).data(Qt.DisplayRole) for section in range(1, self.model.columnCount())) def show_column_chooser(self, pos): # pylint doesn't know that self.shown_scores is a set, not a Setting # pylint: disable=unsupported-membership-test def update(col_name, checked): if checked: self.shown_scores.add(col_name) else: self.shown_scores.remove(col_name) self._update_shown_columns() menu = QMenu() header = self.view.horizontalHeader() for col_name in self._column_names(): action = menu.addAction(col_name) action.setCheckable(True) action.setChecked(col_name in self.shown_scores) action.triggered.connect(partial(update, col_name)) menu.exec(header.mapToGlobal(pos)) def _update_shown_columns(self): # pylint doesn't know that self.shown_scores is a set, not a Setting # pylint: disable=unsupported-membership-test header = self.view.horizontalHeader() for section, col_name in enumerate(self._column_names(), start=1): header.setSectionHidden(section, col_name not in self.shown_scores) self.view.resizeColumnsToContents() self.shownScoresChanged.emit() def update_header(self, scorers): # Set the correct horizontal header labels on the results_model. self.model.setColumnCount(3 + len(scorers)) self.model.setHorizontalHeaderItem(0, QStandardItem("Model")) self.model.setHorizontalHeaderItem(1, QStandardItem("Train time [s]")) self.model.setHorizontalHeaderItem(2, QStandardItem("Test time [s]")) for col, score in enumerate(scorers, start=3): item = QStandardItem(score.name) item.setToolTip(score.long_name) self.model.setHorizontalHeaderItem(col, item) self._update_shown_columns()
class ContingencyTable(QTableView): """ A contingency table widget which can be used wherever ``QTableView`` could be used. Parameters ---------- parent : Orange.widgets.widget.OWWidget The containing widget to which the table is connected. Attributes ---------- classesv : :obj:`list` of :obj:`str` Vertical class headers. classesh : :obj:`list` of :obj:`str` Horizontal class headers. headerv : :obj:`str`, optional Vertical top header. headerh : :obj:`str`, optional Horizontal top header. corner_string : str String that is top right and bottom left corner of the table. Default is ``unicodedata.lookup("N-ARY SUMMATION")``. """ def __init__(self, parent): super().__init__(editTriggers=QTableView.NoEditTriggers) self.bold_headers = None self.circles = False self.classesv = None self.classesh = None self.headerv = None self.headerh = None self.parent = parent self.corner_string = unicodedata.lookup("N-ARY SUMMATION") self.tablemodel = QStandardItemModel(self) self.setModel(self.tablemodel) self.horizontalHeader().hide() self.verticalHeader().hide() self.horizontalHeader().setMinimumSectionSize(60) self.setShowGrid(False) self.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.MinimumExpanding) self.clicked.connect(self._cell_clicked) def mouseReleaseEvent(self, e): super().mouseReleaseEvent(e) self.parent._invalidate() def keyPressEvent(self, event): super().keyPressEvent(event) self.parent._invalidate() def _cell_clicked(self, model_index): """Handle cell click event""" i, j = model_index.row(), model_index.column() if not i or not j: return n = self.tablemodel.rowCount() m = self.tablemodel.columnCount() index = self.tablemodel.index selection = None if i == j == 1 or not self.circles and i == n - 1 and j == m - 1: selection = QItemSelection(index(2, 2), index(n - 1, m - 1)) elif i == 1 or not self.circles and i == n - 1: selection = QItemSelection(index(2, j), index(n - 1, j)) elif j == 1 or not self.circles and j == m - 1: selection = QItemSelection(index(i, 2), index(i, m - 1)) if selection is not None: self.selectionModel().select(selection, QItemSelectionModel.ClearAndSelect) def _item(self, i, j): return self.tablemodel.item(i, j) or QStandardItem() def _set_item(self, i, j, item): self.tablemodel.setItem(i, j, item) def set_variables(self, variablev, variableh, **kwargs): """ Sets class headers and top headers and initializes table structure. Parameters ---------- variablev : Orange.data.variable.DiscreteVariable Class headers are set to ``variablev.values``, top header is set to ``variablev.name``. variableh : Orange.data.variable.DiscreteVariable Class headers are set to ``variableh.values``, top header is set to ``variableh.name``. """ self.classesv = variablev.values self.classesh = variableh.values self.headerv = variablev.name self.headerh = variableh.name self.initialize(**kwargs) def set_headers(self, classesv, classesh, headerv=None, headerh=None, **kwargs): """ Sets class headers and top headers and initializes table structure. Parameters ---------- classesv : :obj:`list` of :obj:`str` Vertical class headers. classesh : :obj:`list` of :obj:`str` Horizontal class headers. headerv : :obj:`str`, optional Vertical top header. headerh : :obj:`str`, optional Horizontal top header. """ self.classesv = classesv self.classesh = classesh self.headerv = headerv self.headerh = headerh self.initialize(**kwargs) def _style_cells(self): """ Style all cells. """ if self.circles: self.setItemDelegate(CircleItemDelegate(Qt.white)) else: self.setItemDelegate(BorderedItemDelegate(Qt.white)) item = self._item(0, 2) item.setData(self.headerh, Qt.DisplayRole) item.setTextAlignment(Qt.AlignCenter) item.setFlags(Qt.NoItemFlags) self._set_item(0, 2, item) item = self._item(2, 0) item.setData(self.headerv, Qt.DisplayRole) item.setTextAlignment(Qt.AlignHCenter | Qt.AlignBottom) item.setFlags(Qt.NoItemFlags) self.setItemDelegateForColumn(0, gui.VerticalItemDelegate()) self._set_item(2, 0, item) self.setSpan(0, 2, 1, len(self.classesh) + 1) self.setSpan(2, 0, len(self.classesv) + 1, 1) for i in (0, 1): for j in (0, 1): item = self._item(i, j) item.setFlags(Qt.NoItemFlags) self._set_item(i, j, item) def _initialize_headers(self): """ Fill headers with content and style them. """ font = self.tablemodel.invisibleRootItem().font() bold_font = QFont(font) bold_font.setBold(True) for headers, ix in ((self.classesv + [self.corner_string], lambda p: (p + 2, 1)), (self.classesh + [self.corner_string], lambda p: (1, p + 2))): for p, label in enumerate(headers): i, j = ix(p) item = self._item(i, j) item.setData(label, Qt.DisplayRole) if self.bold_headers: item.setFont(bold_font) if not (i == 1 and self.circles): item.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter) item.setFlags(Qt.ItemIsEnabled) if p < len(headers) - 1: item.setData("br"[j == 1], BorderRole) item.setData(QColor(192, 192, 192), BorderColorRole) else: item.setData("", BorderRole) self._set_item(i, j, item) def _resize(self): """ Resize table to fit new contents and style. """ if self.circles: self.resizeRowToContents(1) self.horizontalHeader().setDefaultSectionSize(self.rowHeight(2)) self.resizeColumnToContents(1) self.tablemodel.setRowCount(len(self.classesv) + 2) self.tablemodel.setColumnCount(len(self.classesh) + 2) else: if len(' '.join(self.classesh + [self.corner_string])) < 120: self.horizontalHeader().setSectionResizeMode( QHeaderView.ResizeToContents) else: self.horizontalHeader().setDefaultSectionSize(60) self.tablemodel.setRowCount(len(self.classesv) + 3) self.tablemodel.setColumnCount(len(self.classesh) + 3) def initialize(self, circles=False, bold_headers=True): """ Initializes table structure. Class headers must be set beforehand. Parameters ---------- circles : :obj:`bool`, optional Turns on circle display. All table values should be between 0 and 1 (inclusive). Defaults to False. bold_headers : :obj:`bool`, optional Whether the headers are bold or not. Defaults to True. """ assert self.classesv is not None and self.classesh is not None self.circles = circles self.bold_headers = bold_headers self._style_cells() self._initialize_headers() self._resize() def get_selection(self): """ Get indexes of selected cells. Returns ------- :obj:`set` of :obj:`tuple` of :obj:`int` Set of pairs of indexes. """ return {(ind.row() - 2, ind.column() - 2) for ind in self.selectedIndexes()} def set_selection(self, indexes): """ Set indexes of selected cells. Parameters ---------- indexes : :obj:`set` of :obj:`tuple` of :obj:`int` Set of pairs of indexes. """ selection = QItemSelection() index = self.model().index for row, col in indexes: sel = index(row + 2, col + 2) selection.select(sel, sel) self.selectionModel().select(selection, QItemSelectionModel.ClearAndSelect) def _set_sums(self, colsum, rowsum): """ Set content of cells on bottom and right edge. Parameters ---------- colsum : numpy.array Content of cells on bottom edge. rowsum : numpy.array Content of cells on right edge. """ bold_font = self.tablemodel.invisibleRootItem().font() bold_font.setBold(True) def _sum_item(value, border=""): item = QStandardItem() item.setData(value, Qt.DisplayRole) item.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter) item.setFlags(Qt.ItemIsEnabled) item.setFont(bold_font) item.setData(border, BorderRole) item.setData(QColor(192, 192, 192), BorderColorRole) return item for i in range(len(self.classesh)): self._set_item( len(self.classesv) + 2, i + 2, _sum_item(int(colsum[i]), "t")) for i in range(len(self.classesv)): self._set_item(i + 2, len(self.classesh) + 2, _sum_item(int(rowsum[i]), "l")) self._set_item( len(self.classesv) + 2, len(self.classesh) + 2, _sum_item(int(rowsum.sum()))) def _set_values(self, matrix, colors, formatstr, tooltip): """ Set content of cells which aren't headers and don't represent aggregate values. Parameters ---------- matrix : numpy.array 2D array to be set as data. colors : :obj:`numpy.array` 2D array with color values. formatstr : :obj:`str`, optional Format string for cell data. tooltip : :obj:`(int, int) -> str` Function which takes vertical index and horizontal index as arguments and returns desired tooltip as a string. """ def _isinvalid(x): return isnan(x) or isinf(x) for i in range(len(self.classesv)): for j in range(len(self.classesh)): val = matrix[i, j] col_val = float('nan') if colors is None else colors[i, j] item = QStandardItem() if self.circles: item.setData(val, CircleAreaRole) else: item.setData( "NA" if _isinvalid(val) else formatstr.format(val), Qt.DisplayRole) bkcolor = QColor.fromHsl( [0, 240][i == j], 160, 255 if _isinvalid(col_val) else int(255 - 30 * col_val)) item.setData(QBrush(bkcolor), Qt.BackgroundRole) item.setData("trbl", BorderRole) if tooltip is not None: item.setToolTip(tooltip(i, j)) item.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter) item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable) self._set_item(i + 2, j + 2, item) def update_table(self, matrix, colsum=None, rowsum=None, colors=None, formatstr="{}", tooltip=None): """ Sets ``matrix`` as data of the table. Parameters ---------- matrix : numpy.array 2D array to be set as data. colsum : :obj:`numpy.array`, optional 1D optional array with aggregate values of columns, defaults to sum. rowsum : :obj:`numpy.array`, optional 1D optional array with aggregate values of rows, defaults to sum. colors : :obj:`numpy.array`, optional 2D array with color values, defaults to no color. formatstr : :obj:`str`, optional Format string for cell data, defaults to ``"{}"``. tooltip : :obj:`(int, int) -> str`, optional Function which takes vertical index and horizontal index as arguments and returns desired tooltip as a string. Defaults to no tooltips. """ selected_indexes = self.get_selection() self._set_values(matrix, colors, formatstr, tooltip) if not self.circles: if colsum is None: colsum = matrix.sum(axis=0) if rowsum is None: rowsum = matrix.sum(axis=1) self._set_sums(colsum, rowsum) self.set_selection(selected_indexes) def clear(self): """ Clears the table. """ self.tablemodel.clear()
def test_header(self): model = QStandardItemModel() hheader = HeaderView(Qt.Horizontal) vheader = HeaderView(Qt.Vertical) hheader.setSortIndicatorShown(True) # paint with no model. vheader.grab() hheader.grab() hheader.setModel(model) vheader.setModel(model) hheader.adjustSize() vheader.adjustSize() # paint with an empty model vheader.grab() hheader.grab() model.setRowCount(1) model.setColumnCount(1) icon = QIcon(StampIconEngine("A", Qt.red)) model.setHeaderData(0, Qt.Horizontal, icon, Qt.DecorationRole) model.setHeaderData(0, Qt.Vertical, icon, Qt.DecorationRole) model.setHeaderData(0, Qt.Horizontal, QColor(Qt.blue), Qt.ForegroundRole) model.setHeaderData(0, Qt.Vertical, QColor(Qt.blue), Qt.ForegroundRole) model.setHeaderData(0, Qt.Horizontal, QColor(Qt.white), Qt.BackgroundRole) model.setHeaderData(0, Qt.Vertical, QColor(Qt.white), Qt.BackgroundRole) # paint with single col/row model vheader.grab() hheader.grab() model.setRowCount(3) model.setColumnCount(3) hheader.adjustSize() vheader.adjustSize() # paint with single col/row model vheader.grab() hheader.grab() hheader.setSortIndicator(0, Qt.AscendingOrder) vheader.setHighlightSections(True) hheader.setHighlightSections(True) vheader.grab() hheader.grab() vheader.setSectionsClickable(True) hheader.setSectionsClickable(True) vheader.grab() hheader.grab() vheader.setTextElideMode(Qt.ElideRight) hheader.setTextElideMode(Qt.ElideRight) selmodel = QItemSelectionModel(model, model) vheader.setSelectionModel(selmodel) hheader.setSelectionModel(selmodel) selmodel.select(model.index(1, 1), QItemSelectionModel.Rows | QItemSelectionModel.Select) selmodel.select(model.index(1, 1), QItemSelectionModel.Columns | QItemSelectionModel.Select) vheader.grab() vheader.grab()
class OWKMeans(widget.OWWidget): name = "k-Means" description = "k-Means clustering algorithm with silhouette-based " \ "quality estimation." icon = "icons/KMeans.svg" priority = 2100 inputs = [("Data", Table, "set_data")] outputs = [("Annotated Data", Table, widget.Default), ("Centroids", Table)] class Error(widget.OWWidget.Error): failed = widget.Msg("Clustering failed\nError: {}") INIT_KMEANS, INIT_RANDOM = range(2) INIT_METHODS = "Initialize with KMeans++", "Random initialization" SILHOUETTE, INTERCLUSTER, DISTANCES = range(3) SCORING_METHODS = [ ("Silhouette", lambda km: km.silhouette, False, True), ("Inter-cluster distance", lambda km: km.inter_cluster, True, False), ("Distance to centroids", lambda km: km.inertia, True, False) ] OUTPUT_CLASS, OUTPUT_ATTRIBUTE, OUTPUT_META = range(3) OUTPUT_METHODS = ("Class", "Feature", "Meta") resizing_enabled = False k = Setting(3) k_from = Setting(2) k_to = Setting(8) optimize_k = Setting(False) max_iterations = Setting(300) n_init = Setting(10) smart_init = Setting(INIT_KMEANS) scoring = Setting(SILHOUETTE) append_cluster_ids = Setting(True) place_cluster_ids = Setting(OUTPUT_CLASS) output_name = Setting("Cluster") auto_run = Setting(True) def __init__(self): super().__init__() self.data = None self.km = None self.optimization_runs = [] box = gui.vBox(self.controlArea, "Number of Clusters") layout = QGridLayout() self.n_clusters = bg = gui.radioButtonsInBox(box, self, "optimize_k", [], orientation=layout, callback=self.update) layout.addWidget( gui.appendRadioButton(bg, "Fixed:", addToLayout=False), 1, 1) sb = gui.hBox(None, margin=0) self.fixedSpinBox = gui.spin(sb, self, "k", minv=2, maxv=30, controlWidth=60, alignment=Qt.AlignRight, callback=self.update_k) gui.rubber(sb) layout.addWidget(sb, 1, 2) layout.addWidget( gui.appendRadioButton(bg, "Optimized from", addToLayout=False), 2, 1) ftobox = gui.hBox(None) ftobox.layout().setContentsMargins(0, 0, 0, 0) layout.addWidget(ftobox) gui.spin(ftobox, self, "k_from", minv=2, maxv=29, controlWidth=60, alignment=Qt.AlignRight, callback=self.update_from) gui.widgetLabel(ftobox, "to") self.fixedSpinBox = gui.spin(ftobox, self, "k_to", minv=3, maxv=30, controlWidth=60, alignment=Qt.AlignRight, callback=self.update_to) gui.rubber(ftobox) layout.addWidget(gui.widgetLabel(None, "Scoring: "), 5, 1, Qt.AlignRight) layout.addWidget( gui.comboBox(None, self, "scoring", label="Scoring", items=list(zip(*self.SCORING_METHODS))[0], callback=self.update), 5, 2) box = gui.vBox(self.controlArea, "Initialization") gui.comboBox(box, self, "smart_init", items=self.INIT_METHODS, callback=self.update) layout = QGridLayout() box2 = gui.widgetBox(box, orientation=layout) box2.setSizePolicy(QSizePolicy.Maximum, QSizePolicy.Maximum) layout.addWidget(gui.widgetLabel(None, "Re-runs: "), 0, 0, Qt.AlignLeft) sb = gui.hBox(None, margin=0) layout.addWidget(sb, 0, 1) gui.lineEdit(sb, self, "n_init", controlWidth=60, valueType=int, validator=QIntValidator(), callback=self.update) layout.addWidget(gui.widgetLabel(None, "Maximal iterations: "), 1, 0, Qt.AlignLeft) sb = gui.hBox(None, margin=0) layout.addWidget(sb, 1, 1) gui.lineEdit(sb, self, "max_iterations", controlWidth=60, valueType=int, validator=QIntValidator(), callback=self.update) box = gui.vBox(self.controlArea, "Output") gui.comboBox(box, self, "place_cluster_ids", label="Append cluster ID as:", orientation=Qt.Horizontal, callback=self.send_data, items=self.OUTPUT_METHODS) gui.lineEdit(box, self, "output_name", label="Name:", orientation=Qt.Horizontal, callback=self.send_data) gui.separator(self.buttonsArea, 30) self.apply_button = gui.auto_commit(self.buttonsArea, self, "auto_run", "Apply", box=None, commit=self.commit) gui.rubber(self.controlArea) self.table_model = QStandardItemModel(self) self.table_model.setHorizontalHeaderLabels(["k", "Score"]) self.table_model.setColumnCount(2) self.table_box = gui.vBox(self.mainArea, "Optimization Report", addSpace=0) table = self.table_view = QTableView(self.table_box) table.setHorizontalScrollMode(QTableView.ScrollPerPixel) table.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff) table.setSelectionMode(QTableView.SingleSelection) table.setSelectionBehavior(QTableView.SelectRows) table.verticalHeader().hide() self.bar_delegate = gui.ColoredBarItemDelegate(self, color=Qt.cyan) table.setItemDelegateForColumn(1, self.bar_delegate) table.setModel(self.table_model) table.selectionModel().selectionChanged.connect( self.table_item_selected) table.setColumnWidth(0, 40) table.setColumnWidth(1, 120) table.horizontalHeader().setStretchLastSection(True) self.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred) self.mainArea.setSizePolicy(QSizePolicy.Maximum, QSizePolicy.Preferred) self.table_box.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.MinimumExpanding) self.table_view.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.MinimumExpanding) self.table_box.layout().addWidget(self.table_view) self.hide_show_opt_results() def adjustSize(self): self.ensurePolished() s = self.sizeHint() self.resize(s) def hide_show_opt_results(self): [self.mainArea.hide, self.mainArea.show][self.optimize_k]() QTimer.singleShot(100, self.adjustSize) def sizeHint(self): s = self.controlArea.sizeHint() if self.optimize_k and not self.mainArea.isHidden(): s.setWidth(s.width() + self.mainArea.sizeHint().width() + 4 * self.childrenRect().x()) return s def update_k(self): self.optimize_k = False self.update() def update_from(self): self.k_to = max(self.k_from + 1, self.k_to) self.optimize_k = True self.update() def update_to(self): self.k_from = min(self.k_from, self.k_to - 1) self.optimize_k = True self.update() def set_optimization(self): self.updateOptimizationGui() self.update() def check_data_size(self, n, msg_group): msg_group.add_message( "not_enough_data", "Too few ({}) unique data instances for {} clusters") if n > len(self.data): msg_group.not_enough_data(len(self.data), n) return False else: msg_group.not_enough_data.clear() return True def run_optimization(self): # Disabling is needed since this function is not reentrant # Fast clicking on, say, "To: " causes multiple calls try: self.controlArea.setDisabled(True) self.optimization_runs = [] error = "" if not self.check_data_size(self.k_from, self.Error): return self.check_data_size(self.k_to, self.Warning) k_to = min(self.k_to, len(self.data)) kmeans = KMeans( init=['random', 'k-means++'][self.smart_init], n_init=self.n_init, max_iter=self.max_iterations, compute_silhouette_score=self.scoring == self.SILHOUETTE) with self.progressBar(k_to - self.k_from + 1) as progress: for k in range(self.k_from, k_to + 1): progress.advance() kmeans.params["n_clusters"] = k try: self.optimization_runs.append((k, kmeans(self.data))) except BaseException as exc: error = str(exc) self.optimization_runs.append((k, error)) if all( isinstance(score, str) for _, score in self.optimization_runs): self.Error.failed(error) # Report just the last error self.optimization_runs = [] finally: self.controlArea.setDisabled(False) self.show_results() self.send_data() def cluster(self): if not self.check_data_size(self.k, self.Error): return try: self.km = KMeans(n_clusters=self.k, init=['random', 'k-means++'][self.smart_init], n_init=self.n_init, max_iter=self.max_iterations)(self.data) except BaseException as exc: self.Error.failed(str(exc)) self.km = None self.send_data() def run(self): self.clear_messages() if not self.data: return if self.optimize_k: self.run_optimization() else: self.cluster() def commit(self): self.run() def show_results(self): _, scoring_method, minimize, normal = self.SCORING_METHODS[ self.scoring] k_scores = [(k, scoring_method(run) if not isinstance(run, str) else run) for k, run in self.optimization_runs] scores = [score for _, score in k_scores if not isinstance(score, str)] min_score, max_score = min(scores, default=0), max(scores, default=1) best_score = min_score if minimize else max_score if normal: min_score, max_score = 0, 1 nplaces = 3 else: nplaces = min(5, np.floor(abs(math.log(max(max_score, 1e-10)))) + 2) score_span = (max_score - min_score) or 1 self.bar_delegate.scale = (min_score, max_score) self.bar_delegate.float_fmt = "%%.%if" % int(nplaces) model = self.table_model model.setRowCount(len(k_scores)) no_selection = True for i, (k, score) in enumerate(k_scores): item0 = model.item(i, 0) or QStandardItem() item0.setData(k, Qt.DisplayRole) item0.setTextAlignment(Qt.AlignCenter) model.setItem(i, 0, item0) item = model.item(i, 1) or QStandardItem() if not isinstance(score, str): item.setData(score, Qt.DisplayRole) item.setData(None, Qt.ToolTipRole) bar_ratio = 0.95 * (score - min_score) / score_span item.setData(bar_ratio, gui.BarRatioRole) if no_selection and score == best_score: self.table_view.selectRow(i) no_selection = False color = Qt.black flags = Qt.ItemIsEnabled | Qt.ItemIsSelectable else: item.setData("clustering failed", Qt.DisplayRole) item.setData(score, Qt.ToolTipRole) item.setData(None, gui.BarRatioRole) color = Qt.gray flags = Qt.NoItemFlags item0.setData(QBrush(color), Qt.ForegroundRole) item0.setFlags(flags) item.setData(QBrush(color), Qt.ForegroundRole) item.setFlags(flags) model.setItem(i, 1, item) self.table_view.resizeRowsToContents() self.table_view.show() if minimize: self.table_box.setTitle("Scoring (smaller is better)") else: self.table_box.setTitle("Scoring (bigger is better)") QTimer.singleShot(0, self.adjustSize) def update(self): self.hide_show_opt_results() self.run() def selected_row(self): indices = self.table_view.selectedIndexes() rows = {ind.row() for ind in indices} if len(rows) == 1: return rows.pop() def table_item_selected(self): row = self.selected_row() if row is not None: self.send_data() def send_data(self): if self.optimize_k: row = self.selected_row() if self.optimization_runs else None km = self.optimization_runs[row][1] if row is not None else None else: km = self.km if not self.data or not km: self.send("Annotated Data", None) self.send("Centroids", None) return clust_var = DiscreteVariable( self.output_name, values=["C%d" % (x + 1) for x in range(km.k)]) clust_ids = km(self.data) domain = self.data.domain attributes, classes = domain.attributes, domain.class_vars meta_attrs = domain.metas if self.place_cluster_ids == self.OUTPUT_CLASS: if classes: meta_attrs += classes classes = [clust_var] elif self.place_cluster_ids == self.OUTPUT_ATTRIBUTE: attributes += (clust_var, ) else: meta_attrs += (clust_var, ) domain = Domain(attributes, classes, meta_attrs) new_table = Table.from_table(domain, self.data) new_table.get_column_view(clust_var)[0][:] = clust_ids.X.ravel() centroids = Table(Domain(km.pre_domain.attributes), km.centroids) self.send("Annotated Data", new_table) self.send("Centroids", centroids) @check_sql_input def set_data(self, data): self.data = data if data is None: self.Error.clear() self.Warning.clear() self.table_model.setRowCount(0) self.send("Annotated Data", None) self.send("Centroids", None) else: self.data = data self.run() def send_report(self): k_clusters = self.k if self.optimize_k and self.optimization_runs and self.selected_row( ) is not None: k_clusters = self.optimization_runs[self.selected_row()][1].k self.report_items( (("Number of clusters", k_clusters), ("Optimization", self.optimize_k != 0 and "{}, {} re-runs limited to {} steps".format( self.INIT_METHODS[self.smart_init].lower(), self.n_init, self.max_iterations)), ("Cluster ID in output", self.append_cluster_ids and "'{}' (as {})".format( self.output_name, self.OUTPUT_METHODS[self.place_cluster_ids].lower())))) if self.data: self.report_data("Data", self.data) if self.optimize_k: self.report_table( "Scoring by {}".format( self.SCORING_METHODS[self.scoring][0]), self.table_view)
class OWConfusionMatrix(widget.OWWidget): """Confusion matrix widget""" name = "Confusion Matrix" description = "Display a confusion matrix constructed from " \ "the results of classifier evaluations." icon = "icons/ConfusionMatrix.svg" priority = 1001 class Inputs: evaluation_results = Input("Evaluation Results", Orange.evaluation.Results) class Outputs: selected_data = Output("Selected Data", Orange.data.Table, default=True) annotated_data = Output(ANNOTATED_DATA_SIGNAL_NAME, Orange.data.Table) quantities = ["Number of instances", "Proportion of predicted", "Proportion of actual"] settings_version = 1 settingsHandler = settings.ClassValuesContextHandler() selected_learner = settings.Setting([0], schema_only=True) selection = settings.ContextSetting(set()) selected_quantity = settings.Setting(0) append_predictions = settings.Setting(True) append_probabilities = settings.Setting(False) autocommit = settings.Setting(True) UserAdviceMessages = [ widget.Message( "Clicking on cells or in headers outputs the corresponding " "data instances", "click_cell")] class Error(widget.OWWidget.Error): no_regression = Msg("Confusion Matrix cannot show regression results.") invalid_values = Msg("Evaluation Results input contains invalid values") def __init__(self): super().__init__() self.data = None self.results = None self.learners = [] self.headers = [] self.learners_box = gui.listBox( self.controlArea, self, "selected_learner", "learners", box=True, callback=self._learner_changed ) self.outputbox = gui.vBox(self.controlArea, "Output") box = gui.hBox(self.outputbox) gui.checkBox(box, self, "append_predictions", "Predictions", callback=self._invalidate) gui.checkBox(box, self, "append_probabilities", "Probabilities", callback=self._invalidate) gui.auto_commit(self.outputbox, self, "autocommit", "Send Selected", "Send Automatically", box=False) self.mainArea.layout().setContentsMargins(0, 0, 0, 0) box = gui.vBox(self.mainArea, box=True) sbox = gui.hBox(box) gui.rubber(sbox) gui.comboBox(sbox, self, "selected_quantity", items=self.quantities, label="Show: ", orientation=Qt.Horizontal, callback=self._update) self.tablemodel = QStandardItemModel(self) view = self.tableview = QTableView( editTriggers=QTableView.NoEditTriggers) view.setModel(self.tablemodel) view.horizontalHeader().hide() view.verticalHeader().hide() view.horizontalHeader().setMinimumSectionSize(60) view.selectionModel().selectionChanged.connect(self._invalidate) view.setShowGrid(False) view.setItemDelegate(BorderedItemDelegate(Qt.white)) view.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.MinimumExpanding) view.clicked.connect(self.cell_clicked) box.layout().addWidget(view) selbox = gui.hBox(box) gui.button(selbox, self, "Select Correct", callback=self.select_correct, autoDefault=False) gui.button(selbox, self, "Select Misclassified", callback=self.select_wrong, autoDefault=False) gui.button(selbox, self, "Clear Selection", callback=self.select_none, autoDefault=False) def sizeHint(self): """Initial size""" return QSize(750, 340) def _item(self, i, j): return self.tablemodel.item(i, j) or QStandardItem() def _set_item(self, i, j, item): self.tablemodel.setItem(i, j, item) def _init_table(self, nclasses): item = self._item(0, 2) item.setData("Predicted", Qt.DisplayRole) item.setTextAlignment(Qt.AlignCenter) item.setFlags(Qt.NoItemFlags) self._set_item(0, 2, item) item = self._item(2, 0) item.setData("Actual", Qt.DisplayRole) item.setTextAlignment(Qt.AlignHCenter | Qt.AlignBottom) item.setFlags(Qt.NoItemFlags) self.tableview.setItemDelegateForColumn(0, gui.VerticalItemDelegate()) self._set_item(2, 0, item) self.tableview.setSpan(0, 2, 1, nclasses) self.tableview.setSpan(2, 0, nclasses, 1) font = self.tablemodel.invisibleRootItem().font() bold_font = QFont(font) bold_font.setBold(True) for i in (0, 1): for j in (0, 1): item = self._item(i, j) item.setFlags(Qt.NoItemFlags) self._set_item(i, j, item) for p, label in enumerate(self.headers): for i, j in ((1, p + 2), (p + 2, 1)): item = self._item(i, j) item.setData(label, Qt.DisplayRole) item.setFont(bold_font) item.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter) item.setFlags(Qt.ItemIsEnabled) if p < len(self.headers) - 1: item.setData("br"[j == 1], BorderRole) item.setData(QColor(192, 192, 192), BorderColorRole) self._set_item(i, j, item) hor_header = self.tableview.horizontalHeader() if len(' '.join(self.headers)) < 120: hor_header.setSectionResizeMode(QHeaderView.ResizeToContents) else: hor_header.setDefaultSectionSize(60) self.tablemodel.setRowCount(nclasses + 3) self.tablemodel.setColumnCount(nclasses + 3) @Inputs.evaluation_results def set_results(self, results): """Set the input results.""" prev_sel_learner = self.selected_learner.copy() self.clear() self.warning() self.closeContext() data = None if results is not None and results.data is not None: data = results.data[results.row_indices] if data is not None and not data.domain.has_discrete_class: self.Error.no_regression() data = results = None else: self.Error.no_regression.clear() nan_values = False if results is not None: assert isinstance(results, Orange.evaluation.Results) if np.any(np.isnan(results.actual)) or \ np.any(np.isnan(results.predicted)): # Error out here (could filter them out with a warning # instead). nan_values = True results = data = None if nan_values: self.Error.invalid_values() else: self.Error.invalid_values.clear() self.results = results self.data = data if data is not None: class_values = data.domain.class_var.values elif results is not None: raise NotImplementedError if results is None: self.report_button.setDisabled(True) else: self.report_button.setDisabled(False) nmodels = results.predicted.shape[0] self.headers = class_values + \ [unicodedata.lookup("N-ARY SUMMATION")] # NOTE: The 'learner_names' is set in 'Test Learners' widget. if hasattr(results, "learner_names"): self.learners = results.learner_names else: self.learners = ["Learner #{}".format(i + 1) for i in range(nmodels)] self._init_table(len(class_values)) self.openContext(data.domain.class_var) if not prev_sel_learner or prev_sel_learner[0] >= len(self.learners): if self.learners: self.selected_learner[:] = [0] else: self.selected_learner[:] = prev_sel_learner self._update() self._set_selection() self.unconditional_commit() def clear(self): """Reset the widget, clear controls""" self.results = None self.data = None self.tablemodel.clear() self.headers = [] # Clear learners last. This action will invoke `_learner_changed` self.learners = [] def select_correct(self): """Select the diagonal elements of the matrix""" selection = QItemSelection() n = self.tablemodel.rowCount() for i in range(2, n): index = self.tablemodel.index(i, i) selection.select(index, index) self.tableview.selectionModel().select( selection, QItemSelectionModel.ClearAndSelect) def select_wrong(self): """Select the off-diagonal elements of the matrix""" selection = QItemSelection() n = self.tablemodel.rowCount() for i in range(2, n): for j in range(i + 1, n): index = self.tablemodel.index(i, j) selection.select(index, index) index = self.tablemodel.index(j, i) selection.select(index, index) self.tableview.selectionModel().select( selection, QItemSelectionModel.ClearAndSelect) def select_none(self): """Reset selection""" self.tableview.selectionModel().clear() def cell_clicked(self, model_index): """Handle cell click event""" i, j = model_index.row(), model_index.column() if not i or not j: return n = self.tablemodel.rowCount() index = self.tablemodel.index selection = None if i == j == 1 or i == j == n - 1: selection = QItemSelection(index(2, 2), index(n - 1, n - 1)) elif i in (1, n - 1): selection = QItemSelection(index(2, j), index(n - 1, j)) elif j in (1, n - 1): selection = QItemSelection(index(i, 2), index(i, n - 1)) if selection is not None: self.tableview.selectionModel().select( selection, QItemSelectionModel.ClearAndSelect) def _prepare_data(self): indices = self.tableview.selectedIndexes() indices = {(ind.row() - 2, ind.column() - 2) for ind in indices} actual = self.results.actual learner_name = self.learners[self.selected_learner[0]] predicted = self.results.predicted[self.selected_learner[0]] selected = [i for i, t in enumerate(zip(actual, predicted)) if t in indices] extra = [] class_var = self.data.domain.class_var metas = self.data.domain.metas if self.append_predictions: extra.append(predicted.reshape(-1, 1)) var = Orange.data.DiscreteVariable( "{}({})".format(class_var.name, learner_name), class_var.values ) metas = metas + (var,) if self.append_probabilities and \ self.results.probabilities is not None: probs = self.results.probabilities[self.selected_learner[0]] extra.append(np.array(probs, dtype=object)) pvars = [Orange.data.ContinuousVariable("p({})".format(value)) for value in class_var.values] metas = metas + tuple(pvars) domain = Orange.data.Domain(self.data.domain.attributes, self.data.domain.class_vars, metas) data = self.data.transform(domain) if len(extra): data.metas[:, len(self.data.domain.metas):] = \ np.hstack(tuple(extra)) data.name = learner_name if selected: annotated_data = create_annotated_table(data, selected) data = data[selected] else: annotated_data = create_annotated_table(data, []) data = None return data, annotated_data def commit(self): """Output data instances corresponding to selected cells""" if self.results is not None and self.data is not None \ and self.selected_learner: data, annotated_data = self._prepare_data() else: data = None annotated_data = None self.Outputs.selected_data.send(data) self.Outputs.annotated_data.send(annotated_data) def _invalidate(self): indices = self.tableview.selectedIndexes() self.selection = {(ind.row() - 2, ind.column() - 2) for ind in indices} self.commit() def _set_selection(self): selection = QItemSelection() index = self.tableview.model().index for row, col in self.selection: sel = index(row + 2, col + 2) selection.select(sel, sel) self.tableview.selectionModel().select( selection, QItemSelectionModel.ClearAndSelect) def _learner_changed(self): self._update() self._set_selection() self.commit() def _update(self): def _isinvalid(x): return isnan(x) or isinf(x) # Update the displayed confusion matrix if self.results is not None and self.selected_learner: cmatrix = confusion_matrix(self.results, self.selected_learner[0]) colsum = cmatrix.sum(axis=0) rowsum = cmatrix.sum(axis=1) n = len(cmatrix) diag = np.diag_indices(n) colors = cmatrix.astype(np.double) colors[diag] = 0 if self.selected_quantity == 0: normalized = cmatrix.astype(np.int) formatstr = "{}" div = np.array([colors.max()]) else: if self.selected_quantity == 1: normalized = 100 * cmatrix / colsum div = colors.max(axis=0) else: normalized = 100 * cmatrix / rowsum[:, np.newaxis] div = colors.max(axis=1)[:, np.newaxis] formatstr = "{:2.1f} %" div[div == 0] = 1 colors /= div colors[diag] = normalized[diag] / normalized[diag].max() for i in range(n): for j in range(n): val = normalized[i, j] col_val = colors[i, j] item = self._item(i + 2, j + 2) item.setData( "NA" if _isinvalid(val) else formatstr.format(val), Qt.DisplayRole) bkcolor = QColor.fromHsl( [0, 240][i == j], 160, 255 if _isinvalid(col_val) else int(255 - 30 * col_val)) item.setData(QBrush(bkcolor), Qt.BackgroundRole) item.setData("trbl", BorderRole) item.setToolTip("actual: {}\npredicted: {}".format( self.headers[i], self.headers[j])) item.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter) item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable) self._set_item(i + 2, j + 2, item) bold_font = self.tablemodel.invisibleRootItem().font() bold_font.setBold(True) def _sum_item(value, border=""): item = QStandardItem() item.setData(value, Qt.DisplayRole) item.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter) item.setFlags(Qt.ItemIsEnabled) item.setFont(bold_font) item.setData(border, BorderRole) item.setData(QColor(192, 192, 192), BorderColorRole) return item for i in range(n): self._set_item(n + 2, i + 2, _sum_item(int(colsum[i]), "t")) self._set_item(i + 2, n + 2, _sum_item(int(rowsum[i]), "l")) self._set_item(n + 2, n + 2, _sum_item(int(rowsum.sum()))) def send_report(self): """Send report""" if self.results is not None and self.selected_learner: self.report_table( "Confusion matrix for {} (showing {})". format(self.learners[self.selected_learner[0]], self.quantities[self.selected_quantity].lower()), self.tableview) @classmethod def migrate_settings(cls, settings, version): if not version: # For some period of time the 'selected_learner' property was # changed from List[int] -> int # (commit 4e49bb3fd0e11262f3ebf4b1116a91a4b49cc982) and then back # again (commit 8a492d79a2e17154a0881e24a05843406c8892c0) if "selected_learner" in settings and \ isinstance(settings["selected_learner"], int): settings["selected_learner"] = [settings["selected_learner"]]
class OWKMeans(widget.OWWidget): name = "k-Means" description = "k-Means clustering algorithm with silhouette-based " \ "quality estimation." icon = "icons/KMeans.svg" priority = 2100 inputs = [("Data", Table, "set_data")] outputs = [("Annotated Data", Table, widget.Default), ("Centroids", Table)] INIT_KMEANS, INIT_RANDOM = range(2) INIT_METHODS = "Initialize with KMeans++", "Random initialization" SILHOUETTE, INTERCLUSTER, DISTANCES = range(3) SCORING_METHODS = [("Silhouette", lambda km: km.silhouette, False), ("Inter-cluster distance", lambda km: km.inter_cluster, True), ("Distance to centroids", lambda km: km.inertia, True)] OUTPUT_CLASS, OUTPUT_ATTRIBUTE, OUTPUT_META = range(3) OUTPUT_METHODS = ("Class", "Feature", "Meta") resizing_enabled = False k = Setting(3) k_from = Setting(2) k_to = Setting(8) optimize_k = Setting(False) max_iterations = Setting(300) n_init = Setting(10) smart_init = Setting(INIT_KMEANS) scoring = Setting(SILHOUETTE) append_cluster_ids = Setting(True) place_cluster_ids = Setting(OUTPUT_CLASS) output_name = Setting("Cluster") auto_run = Setting(True) def __init__(self): super().__init__() self.data = None self.km = None self.optimization_runs = [] box = gui.vBox(self.controlArea, "Number of Clusters") layout = QGridLayout() self.n_clusters = bg = gui.radioButtonsInBox( box, self, "optimize_k", [], orientation=layout, callback=self.update) layout.addWidget( gui.appendRadioButton(bg, "Fixed:", addToLayout=False), 1, 1) sb = gui.hBox(None, margin=0) self.fixedSpinBox = gui.spin( sb, self, "k", minv=2, maxv=30, controlWidth=60, alignment=Qt.AlignRight, callback=self.update_k) gui.rubber(sb) layout.addWidget(sb, 1, 2) layout.addWidget( gui.appendRadioButton(bg, "Optimized from", addToLayout=False), 2, 1) ftobox = gui.hBox(None) ftobox.layout().setContentsMargins(0, 0, 0, 0) layout.addWidget(ftobox) gui.spin( ftobox, self, "k_from", minv=2, maxv=29, controlWidth=60, alignment=Qt.AlignRight, callback=self.update_from) gui.widgetLabel(ftobox, "to") self.fixedSpinBox = gui.spin( ftobox, self, "k_to", minv=3, maxv=30, controlWidth=60, alignment=Qt.AlignRight, callback=self.update_to) gui.rubber(ftobox) layout.addWidget(gui.widgetLabel(None, "Scoring: "), 5, 1, Qt.AlignRight) layout.addWidget( gui.comboBox( None, self, "scoring", label="Scoring", items=list(zip(*self.SCORING_METHODS))[0], callback=self.update), 5, 2) box = gui.vBox(self.controlArea, "Initialization") gui.comboBox( box, self, "smart_init", items=self.INIT_METHODS, callback=self.update) layout = QGridLayout() box2 = gui.widgetBox(box, orientation=layout) box2.setSizePolicy(QSizePolicy.Maximum, QSizePolicy.Maximum) layout.addWidget(gui.widgetLabel(None, "Re-runs: "), 0, 0, Qt.AlignLeft) sb = gui.hBox(None, margin=0) layout.addWidget(sb, 0, 1) gui.lineEdit( sb, self, "n_init", controlWidth=60, valueType=int, validator=QIntValidator(), callback=self.update) layout.addWidget(gui.widgetLabel(None, "Maximal iterations: "), 1, 0, Qt.AlignLeft) sb = gui.hBox(None, margin=0) layout.addWidget(sb, 1, 1) gui.lineEdit(sb, self, "max_iterations", controlWidth=60, valueType=int, validator=QIntValidator(), callback=self.update) box = gui.vBox(self.controlArea, "Output") gui.comboBox(box, self, "place_cluster_ids", label="Append cluster ID as:", orientation=Qt.Horizontal, callback=self.send_data, items=self.OUTPUT_METHODS) gui.lineEdit(box, self, "output_name", label="Name:", orientation=Qt.Horizontal, callback=self.send_data) gui.separator(self.buttonsArea, 30) self.apply_button = gui.auto_commit( self.buttonsArea, self, "auto_run", "Apply", box=None, commit=self.commit ) gui.rubber(self.controlArea) self.table_model = QStandardItemModel(self) self.table_model.setHorizontalHeaderLabels(["k", "Score"]) self.table_model.setColumnCount(2) self.table_box = gui.vBox( self.mainArea, "Optimization Report", addSpace=0) table = self.table_view = QTableView(self.table_box) table.setHorizontalScrollMode(QTableView.ScrollPerPixel) table.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff) table.setSelectionMode(QTableView.SingleSelection) table.setSelectionBehavior(QTableView.SelectRows) table.verticalHeader().hide() table.setItemDelegateForColumn(1, gui.TableBarItem(self)) table.setModel(self.table_model) table.selectionModel().selectionChanged.connect( self.table_item_selected) table.setColumnWidth(0, 40) table.setColumnWidth(1, 120) table.horizontalHeader().setStretchLastSection(True) self.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred) self.mainArea.setSizePolicy(QSizePolicy.Maximum, QSizePolicy.Preferred) self.table_box.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.MinimumExpanding) self.table_view.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.MinimumExpanding) self.table_box.layout().addWidget(self.table_view) self.hide_show_opt_results() def adjustSize(self): self.ensurePolished() s = self.sizeHint() self.resize(s) def hide_show_opt_results(self): [self.mainArea.hide, self.mainArea.show][self.optimize_k]() QTimer.singleShot(100, self.adjustSize) def sizeHint(self): s = self.controlArea.sizeHint() if self.optimize_k and not self.mainArea.isHidden(): s.setWidth(s.width() + self.mainArea.sizeHint().width() + 4 * self.childrenRect().x()) return s def update_k(self): self.optimize_k = False self.update() def update_from(self): self.k_to = max(self.k_from + 1, self.k_to) self.optimize_k = True self.update() def update_to(self): self.k_from = min(self.k_from, self.k_to - 1) self.optimize_k = True self.update() def set_optimization(self): self.updateOptimizationGui() self.update() def check_data_size(self, n, msg_group): msg_group.add_message( "not_enough_data", "Too few ({}) unique data instances for {} clusters") if n > len(self.data): msg_group.not_enough_data(len(self.data), n) return False else: msg_group.not_enough_data.clear() return True def run_optimization(self): # Disabling is needed since this function is not reentrant # Fast clicking on, say, "To: " causes multiple calls try: self.controlArea.setDisabled(True) self.optimization_runs = [] if not self.check_data_size(self.k_from, self.Error): return self.check_data_size(self.k_to, self.Warning) k_to = min(self.k_to, len(self.data)) kmeans = KMeans( init=['random', 'k-means++'][self.smart_init], n_init=self.n_init, max_iter=self.max_iterations, compute_silhouette_score=self.scoring == self.SILHOUETTE) with self.progressBar(k_to - self.k_from + 1) as progress: for k in range(self.k_from, k_to + 1): progress.advance() kmeans.params["n_clusters"] = k self.optimization_runs.append((k, kmeans(self.data))) finally: self.controlArea.setDisabled(False) self.show_results() self.send_data() def cluster(self): if not self.check_data_size(self.k, self.Error): return self.km = KMeans( n_clusters=self.k, init=['random', 'k-means++'][self.smart_init], n_init=self.n_init, max_iter=self.max_iterations)(self.data) self.send_data() def run(self): self.clear_messages() if not self.data: return if self.optimize_k: self.run_optimization() else: self.cluster() def commit(self): self.run() def show_results(self): minimize = self.SCORING_METHODS[self.scoring][2] k_scores = [(k, self.SCORING_METHODS[self.scoring][1](run)) for k, run in self.optimization_runs] scores = list(zip(*k_scores))[1] if minimize: best_score, worst_score = min(scores), max(scores) else: best_score, worst_score = max(scores), min(scores) best_run = scores.index(best_score) score_span = (best_score - worst_score) or 1 max_score = max(scores) nplaces = min(5, np.floor(abs(math.log(max(max_score, 1e-10)))) + 2) fmt = "{{:.{}f}}".format(int(nplaces)) model = self.table_model model.setRowCount(len(k_scores)) for i, (k, score) in enumerate(k_scores): item = model.item(i, 0) if item is None: item = QStandardItem() item.setData(k, Qt.DisplayRole) item.setTextAlignment(Qt.AlignCenter) model.setItem(i, 0, item) item = model.item(i, 1) if item is None: item = QStandardItem() item.setData(fmt.format(score) if not np.isnan(score) else 'out-of-memory error', Qt.DisplayRole) bar_ratio = 0.95 * (score - worst_score) / score_span item.setData(bar_ratio, gui.TableBarItem.BarRole) model.setItem(i, 1, item) self.table_view.resizeRowsToContents() self.table_view.selectRow(best_run) self.table_view.show() if minimize: self.table_box.setTitle("Scoring (smaller is better)") else: self.table_box.setTitle("Scoring (bigger is better)") QTimer.singleShot(0, self.adjustSize) def update(self): self.hide_show_opt_results() self.run() def selected_row(self): indices = self.table_view.selectedIndexes() rows = {ind.row() for ind in indices} if len(rows) == 1: return rows.pop() def table_item_selected(self): row = self.selected_row() if row is not None: self.send_data(row) def send_data(self, row=None): if self.optimize_k: if row is None: row = self.selected_row() km = self.optimization_runs[row][1] else: km = self.km if not self.data or not km: self.send("Annotated Data", None) self.send("Centroids", None) return clust_var = DiscreteVariable( self.output_name, values=["C%d" % (x + 1) for x in range(km.k)]) clust_ids = km(self.data) domain = self.data.domain attributes, classes = domain.attributes, domain.class_vars meta_attrs = domain.metas if self.place_cluster_ids == self.OUTPUT_CLASS: if classes: meta_attrs += classes classes = [clust_var] elif self.place_cluster_ids == self.OUTPUT_ATTRIBUTE: attributes += (clust_var, ) else: meta_attrs += (clust_var, ) domain = Domain(attributes, classes, meta_attrs) new_table = Table.from_table(domain, self.data) new_table.get_column_view(clust_var)[0][:] = clust_ids.X.ravel() centroids = Table(Domain(km.pre_domain.attributes), km.centroids) self.send("Annotated Data", new_table) self.send("Centroids", centroids) @check_sql_input def set_data(self, data): self.data = data if data is None: self.table_model.setRowCount(0) self.send("Annotated Data", None) self.send("Centroids", None) else: self.data = data self.run() def send_report(self): k_clusters = self.k if self.optimize_k and self.optimization_runs and self.selected_row() is not None: k_clusters = self.optimization_runs[self.selected_row()][1].k self.report_items(( ("Number of clusters", k_clusters), ("Optimization", self.optimize_k != 0 and "{}, {} re-runs limited to {} steps".format( self.INIT_METHODS[self.smart_init].lower(), self.n_init, self.max_iterations)), ("Cluster ID in output", self.append_cluster_ids and "'{}' (as {})".format( self.output_name, self.OUTPUT_METHODS[self.place_cluster_ids].lower())) )) if self.data: self.report_data("Data", self.data) if self.optimize_k: self.report_table( "Scoring by {}".format(self.SCORING_METHODS[self.scoring][0] ), self.table_view)