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()
def set_groups(self, keys, groups, relevant_keys, relevant_items,
all_values, uniquepos):
"""Set the current data groups and update the Group widget
"""
layout = QVBoxLayout()
header_widths = []
header_views = []
palette = self.palette()
all_values = all_values.keys()
def for_print(rd):
attrs = []
for d in rd:
attr = Orange.data.ContinuousVariable(next(inactive_name_gen))
attr.attributes.update(d)
attrs.append(attr)
return Orange.data.Domain(attrs, None)
for separatev, domain in [(None, for_print(relevant_items))] + groups:
label = None
if separatev is not None:
ann_vals = " <b>|</b> ".join(["<b>{0}</b> = {1}".format(key,val) \
for key, val in zip(keys, separatev)])
label = QLabel(ann_vals)
model = QStandardItemModel()
for i, attr in enumerate(domain.attributes):
item = QStandardItem()
if separatev is not None:
isunique = uniquepos[separatev][i]
else:
isunique = all(a[i] for a in uniquepos.values())
if str(attr.name).startswith("!!missing "): # TODO: Change this to not depend on name
header_text = ["{0}={1}".format(key, attr.attributes.get(key, "?")) \
for key in all_values if key not in relevant_items[i]]
header_text = "\n".join(header_text) if header_text else "Empty"
item.setData(header_text, Qt.DisplayRole)
item.setFlags(Qt.NoItemFlags)
item.setData(QColor(Qt.red), Qt.ForegroundRole)
item.setData(palette.color(QPalette.Disabled, QPalette.Window), Qt.BackgroundRole)
item.setData("Missing feature.", Qt.ToolTipRole)
elif str(attr.name).startswith("!!inactive "):
header_text = ["{0}={1}".format(key, attr.attributes.get(key, "?")) \
for key in all_values if key in relevant_items[i]]
header_text = "\n".join(header_text) if header_text else "No descriptor"
item.setData(header_text, Qt.DisplayRole)
item.setData(palette.color(QPalette.Disabled, QPalette.Window), Qt.BackgroundRole)
else:
header_text = ["{0}={1}".format(key, attr.attributes.get(key, "?")) \
for key in all_values if key not in relevant_items[i]]
header_text = "\n".join(header_text) if header_text else "Empty"
item.setData(header_text, Qt.DisplayRole)
item.setData(attr.name, Qt.ToolTipRole)
if not isunique:
item.setData(QColor(Qt.red), Qt.ForegroundRole)
model.setHorizontalHeaderItem(i, item)
attr_count = len(domain.attributes)
view = MyHeaderView(Qt.Horizontal)
view.setResizeMode(QHeaderView.Fixed)
view.setModel(model)
hint = view.sizeHint()
view.setMaximumHeight(hint.height())
widths = [view.sectionSizeHint(i) for i in range(attr_count)]
header_widths.append(widths)
header_views.append(view)
if label:
layout.addWidget(label)
layout.addWidget(view)
layout.addSpacing(8)
# Make all header sections the same width
width_sum = 0
max_header_count = max([h.count() for h in header_views])
for i in range(max_header_count):
max_width = max([w[i] for w in header_widths if i < len(w)] or [0])
for view in header_views:
if i < view.count():
view.resizeSection(i, max_width)
width_sum += max_width + 2
for h in header_views:
h.setMinimumWidth(h.length() + 4)
widget = QWidget()
widget.setLayout(layout)
widget.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.Maximum)
layout.activate()
max_width = max(h.length() for h in header_views) + 20
left, _, right, _ = self.getContentsMargins()
widget.setMinimumWidth(width_sum)
widget.setMinimumWidth(max_width + left + right)
self.groups_scroll_area.setWidget(widget)
def find_rules(self):
if self.data is None or not len(self.data):
return
if self._is_running:
self._is_running = False
return
self.button.button.setText('Cancel')
self._is_running = True
data = self.data
self.table.model().clear()
n_examples = len(data)
NumericItem = self.NumericItem
StandardItem = self.StandardItem
filterSearch = self.filterSearch
itemsetMin = self.filterAntecedentMin + self.filterConsequentMin
itemsetMax = self.filterAntecedentMax + self.filterConsequentMax
isSizeMatch = self.isSizeMatch
isRegexMatch = self.isRegexMatch
X, mapping = OneHot.encode(data, self.classify)
self.Error.need_discrete_data.clear()
if X is None:
self.Error.need_discrete_data()
self.onehot_mapping = mapping
ITEM_FMT = '{}' if issparse(data.X) else '{}={}'
names = {
item:
('{}={}' if var is data.domain.class_var else ITEM_FMT).format(
var.name, val)
for item, var, val in OneHot.decode(mapping, data, mapping)
}
# Items that consequent must include if classifying
class_items = {
item
for item, var, val in OneHot.decode(mapping, data, mapping)
if var is data.domain.class_var
} if self.classify else set()
assert bool(class_items) == bool(self.classify)
model = QStandardItemModel(self.table)
for col, (label, tooltip) in enumerate([
("Supp", "Support"),
("Conf", "Confidence (support / antecedent support)"),
("Covr", "Coverage (antecedent support / number of examples)"),
("Strg", "Strength (consequent support / antecedent support)"),
("Lift",
"Lift (number of examples * confidence / consequent support)"),
("Levr",
"Leverage ((support * number of examples - antecedent support * consequent support) / (number of examples)²)"
), ("Antecedent", None), ("", None), ("Consequent", None)
]):
item = QStandardItem(label)
item.setToolTip(tooltip)
model.setHorizontalHeaderItem(col, item)
#~ # Aggregate rules by common (support,confidence) for scatterplot
#~ scatter_agg = defaultdict(list)
# Find itemsets
nRules = 0
itemsets = {}
ARROW_ITEM = StandardItem('→')
ARROW_ITEM.setTextAlignment(Qt.AlignCenter)
with self.progressBar(self.maxRules + 1) as progress:
for itemset, support in frequent_itemsets(X,
self.minSupport / 100):
itemsets[itemset] = support
if class_items and not class_items & itemset:
continue
# Filter itemset by joined filters before descending into it
itemset_str = ' '.join(names[i] for i in itemset)
if (filterSearch and
(len(itemset) < itemsetMin or itemsetMax < len(itemset)
or not isRegexMatch(itemset_str, itemset_str))):
continue
for rule in association_rules(itemsets,
self.minConfidence / 100,
itemset):
left, right, support, confidence = rule
if class_items and right - class_items:
continue
if filterSearch and not isSizeMatch(len(left), len(right)):
continue
left_str = ', '.join(names[i] for i in sorted(left))
right_str = ', '.join(names[i] for i in sorted(right))
if filterSearch and not isRegexMatch(left_str, right_str):
continue
# All filters matched, calculate stats and add table row
_, _, _, _, coverage, strength, lift, leverage = next(
rules_stats((rule, ), itemsets, n_examples))
support_item = NumericItem(support / n_examples)
# Set row data on first column
support_item.setData(
(itemset - class_items, class_items and
(class_items & itemset).pop()), self.ROW_DATA_ROLE)
left_item = StandardItem(left_str, len(left))
left_item.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
model.appendRow([
support_item,
NumericItem(confidence),
NumericItem(coverage),
NumericItem(strength),
NumericItem(lift),
NumericItem(leverage), left_item,
ARROW_ITEM.clone(),
StandardItem(right_str, len(right))
])
#~ scatter_agg[(round(support / n_examples, 2), round(confidence, 2))].append((left, right))
nRules += 1
progress.advance()
if not self._is_running or nRules >= self.maxRules:
break
qApp.processEvents()
if not self._is_running or nRules >= self.maxRules:
break
# Populate the TableView
table = self.table
table.setHidden(True)
table.setSortingEnabled(False)
proxy_model = self.proxy_model
proxy_model.setSourceModel(model)
table.setModel(proxy_model)
for i in range(model.columnCount()):
table.resizeColumnToContents(i)
table.setSortingEnabled(True)
table.setHidden(False)
self.button.button.setText('Find Rules')
self.nRules = nRules
self.nFilteredRules = proxy_model.rowCount(
) # TODO: continue; also add in owitemsets
self.nSelectedRules = 0
self.nSelectedExamples = 0
self._is_running = False
