def commit(self):
if not self.selected_attrs:
self.Outputs.reduced_data.send(None)
self.Outputs.features.send(None)
self.out_domain_desc = None
else:
reduced_domain = Domain(
self.selected_attrs, self.data.domain.class_var,
self.data.domain.metas)
data = self.data.transform(reduced_domain)
self.Outputs.reduced_data.send(data)
self.Outputs.features.send(AttributeList(self.selected_attrs))
self.out_domain_desc = report.describe_domain(data.domain)
def test_features_and_data(self):
data = Table("iris")
self.send_signal(self.widget.Inputs.data, data)
x, y = self.widget.graph.scatterplot_item.getData()
np.testing.assert_array_equal(x, data.X[:, 0])
np.testing.assert_array_equal(y, data.X[:, 1])
self.send_signal(self.widget.Inputs.features,
AttributeList(data.domain[2:]))
self.assertIs(self.widget.attr_x, data.domain[2])
self.assertIs(self.widget.attr_y, data.domain[3])
x, y = self.widget.graph.scatterplot_item.getData()
np.testing.assert_array_equal(x, data.X[:, 2])
np.testing.assert_array_equal(y, data.X[:, 3])
def test_input_combinations(self):
data = Table("iris")
in_features = AttributeList(data.domain.attributes[:2])
# check initial state
self.assertControlsEnabled(True, False, False)
self.assertVariableCountsEqual(0, 0, 0, 0)
self.assertIsNone(self.get_output(self.widget.Outputs.features))
# send data
self.send_signal(self.widget.Inputs.data, data)
self.assertControlsEnabled(True, False, False)
self.assertVariableCountsEqual(0, 4, 1, 0)
self.assertEqual(len(self.get_output(self.widget.Outputs.features)), 4)
# send features
self.send_signal(self.widget.Inputs.features, in_features)
self.assertControlsEnabled(True, True, True)
self.assertVariableCountsEqual(2, 2, 1, 0)
self.assertEqual(len(self.get_output(self.widget.Outputs.features)), 2)
# remove data
self.send_signal(self.widget.Inputs.data, None)
self.assertControlsEnabled(True, False, False)
self.assertVariableCountsEqual(0, 0, 0, 0)
self.assertIsNone(self.get_output(self.widget.Outputs.features))
# remove features
self.send_signal(self.widget.Inputs.features, None)
self.assertControlsEnabled(True, False, False)
self.assertVariableCountsEqual(0, 0, 0, 0)
self.assertIsNone(self.get_output(self.widget.Outputs.features))
# send features
self.send_signal(self.widget.Inputs.features, in_features)
self.assertControlsEnabled(True, False, False)
self.assertVariableCountsEqual(0, 0, 0, 0)
self.assertIsNone(self.get_output(self.widget.Outputs.features))
# send data
self.send_signal(self.widget.Inputs.data, data)
self.assertControlsEnabled(True, False, True)
self.assertVariableCountsEqual(2, 2, 1, 0)
self.assertEqual(len(self.get_output(self.widget.Outputs.features)), 2)
# remove features
self.send_signal(self.widget.Inputs.features, None)
self.assertControlsEnabled(True, False, False)
self.assertVariableCountsEqual(2, 2, 1, 0)
self.assertEqual(len(self.get_output(self.widget.Outputs.features)), 2)
def test_invalidated_diff_features_features_first(self):
self.widget.setup_plot = Mock()
# send features (not the same as defaults)
self.send_signal(self.widget.Inputs.features,
AttributeList(self.data.domain.attributes[2:4]))
self.assertListEqual(self.widget.effective_variables, [None, None])
self.widget.setup_plot.assert_called_once()
# send data
self.widget.setup_plot.reset_mock()
self.send_signal(self.widget.Inputs.data, self.data)
self.widget.setup_plot.assert_called_once()
self.assertListEqual(self.widget.effective_variables,
list(self.data.domain.attributes[2:4]))
def test_invalidated_diff_features(self):
self.widget.setup_plot = Mock()
# send data and set default features
self.send_signal(self.widget.Inputs.data, self.data)
self.widget.setup_plot.assert_called_once()
self.assertListEqual(self.widget.effective_variables,
list(self.data.domain.attributes[:2]))
# send different features
self.widget.setup_plot.reset_mock()
self.send_signal(self.widget.Inputs.features,
AttributeList(self.data.domain.attributes[2:4]))
self.widget.setup_plot.assert_called_once()
self.assertListEqual(self.widget.effective_variables,
list(self.data.domain.attributes[2:4]))
def commit(self):
self.update_domain_role_hints()
if self.data is not None:
attributes = list(self.used_attrs)
class_var = list(self.class_attrs)
metas = list(self.meta_attrs)
domain = Orange.data.Domain(attributes, class_var, metas)
newdata = self.data.transform(domain)
self.output_data = newdata
self.Outputs.data.send(newdata)
self.Outputs.features.send(AttributeList(attributes))
else:
self.output_data = None
self.Outputs.data.send(None)
self.Outputs.features.send(None)
def commit(self):
if not self.selected_attrs:
self.Outputs.reduced_data.send(None)
self.Outputs.features.send(None)
self.out_domain_desc = None
self.info.set_output_summary(self.info.NoOutput)
else:
reduced_domain = Domain(self.selected_attrs,
self.data.domain.class_var,
self.data.domain.metas)
data = self.data.transform(reduced_domain)
self.Outputs.reduced_data.send(data)
self.Outputs.features.send(AttributeList(self.selected_attrs))
self.out_domain_desc = report.describe_domain(data.domain)
self.info.set_output_summary(len(data),
format_summary_details(data))
def commit(self):
self.update_domain_role_hints()
self.Warning.multiple_targets.clear()
if self.data is not None:
attributes = list(self.used_attrs)
class_var = list(self.class_attrs)
metas = list(self.meta_attrs)
domain = Orange.data.Domain(attributes, class_var, metas)
newdata = self.data.transform(domain)
self.output_data = newdata
self.Outputs.data.send(newdata)
self.Outputs.features.send(AttributeList(attributes))
self.info.set_output_summary(len(newdata),
format_summary_details(newdata))
self.Warning.multiple_targets(shown=len(class_var) > 1)
else:
self.output_data = None
self.Outputs.data.send(None)
self.Outputs.features.send(None)
self.info.set_output_summary(self.info.NoOutput)
def commit(self):
if self.data is None or self.cont_data is None:
self.Outputs.data.send(self.data)
self.Outputs.features.send(None)
self.Outputs.correlations.send(None)
return
metas = [StringVariable("Feature 1"), StringVariable("Feature 2")]
domain = Domain([ContinuousVariable("Correlation")], metas=metas)
model = self.vizrank.rank_model
x = np.array([[float(model.data(model.index(row, 2)))] for row
in range(model.rowCount())])
m = np.array([[model.data(model.index(row, 0)),
model.data(model.index(row, 1))] for row
in range(model.rowCount())], dtype=object)
corr_table = Table(domain, x, metas=m)
corr_table.name = "Correlations"
self.Outputs.data.send(self.data)
# data has been imputed; send original attributes
self.Outputs.features.send(AttributeList([attr.compute_value.variable
for attr in self.selection]))
self.Outputs.correlations.send(corr_table)
def test_context_with_features(self):
"""
Test if context saves selection correctly afeter providing features
on the input.
"""
w = self.widget
self.send_signal(w.Inputs.time_series, self.amzn)
self.assertEqual(1, len(w.configs))
sel = self.amzn.domain.attributes[3:5]
w.configs[0].set_selection(sel)
sel_features = self.amzn.domain.attributes[2:4]
self.send_signal(w.Inputs.features, AttributeList(sel_features))
self.assertEqual(2, len(w.configs))
self.assertListEqual([sel_features[0]], w.configs[0].get_selection())
self.assertListEqual([sel_features[1]], w.configs[1].get_selection())
self.send_signal(w.Inputs.features, None)
self.assertEqual(1, len(w.configs))
self.assertListEqual(list(sel), w.configs[0].get_selection())
def main(argv=None): # pragma: no cover
from AnyQt.QtWidgets import QApplication
if argv is None:
argv = sys.argv
argv = list(argv)
app = QApplication(list(argv))
if len(argv) > 1:
filename = argv[1]
else:
filename = "brown-selected"
w = OWSelectAttributes()
data = Orange.data.Table(filename)
w.set_data(data)
w.set_features(AttributeList(data.domain.attributes[:2]))
w.handleNewSignals()
w.show()
w.raise_()
rval = app.exec_()
w.set_data(None)
w.saveSettings()
return rval
def commit(self):
if self.data is None or self.disc_data is None:
self.Outputs.features.send(None)
self.Outputs.interactions.send(None)
return
attrs = [ContinuousVariable("Interaction"), ContinuousVariable("Entropy Removed")]
metas = [StringVariable("Feature 1"), StringVariable("Feature 2")]
domain = Domain(attrs, metas=metas)
model = self.vizrank.rank_model
x = np.array(
[[float(model.data(model.index(row, 0), role))
for role in (InteractionRank.IntRole, InteractionRank.RemovedRole)]
for row in range(model.rowCount())])
m = np.array(
[[a.name for a in model.data(model.index(row, 0), InteractionRank._AttrRole)]
for row in range(model.rowCount())], dtype=object)
int_table = Table(domain, x, metas=m)
int_table.name = "Interactions"
# data has been imputed; send original attributes
self.Outputs.features.send(AttributeList(
[self.data.domain[var.name] for var in self.selection]))
self.Outputs.interactions.send(int_table)
def send_features(self):
features = [attr for attr in [self.attr_x, self.attr_y] if attr]
self.Outputs.features.send(AttributeList(features) or None)
self.available_attrs[:] = []
self.used_attrs[:] = self.data.domain.attributes
self.class_attrs[:] = self.data.domain.class_vars
self.meta_attrs[:] = self.data.domain.metas
self.update_domain_role_hints()
self.commit()
def send_report(self):
if not self.data or not self.output_data:
return
in_domain, out_domain = self.data.domain, self.output_data.domain
self.report_domain("Input data", self.data.domain)
if (in_domain.attributes, in_domain.class_vars,
in_domain.metas) == (out_domain.attributes,
out_domain.class_vars, out_domain.metas):
self.report_paragraph("Output data", "No changes.")
else:
self.report_domain("Output data", self.output_data.domain)
diff = list(
set(in_domain.variables + in_domain.metas) -
set(out_domain.variables + out_domain.metas))
if diff:
text = "%i (%s)" % (len(diff), ", ".join(x.name for x in diff))
self.report_items((("Removed", text), ))
if __name__ == "__main__": # pragma: no cover
brown = Orange.data.Table("brown-selected")
feats = AttributeList(brown.domain.attributes[:2])
WidgetPreview(OWSelectAttributes).run(set_data=brown, set_features=feats)
def update_scene(self):
self.clear_scene()
if self.domain is None or not len(self.points[0]):
self.Outputs.features.send(None)
return
n_attrs = self.n_attributes if self.display_index else int(1e10)
attr_inds, attributes = zip(*self.get_ordered_attributes()[:n_attrs])
self.Outputs.features.send(AttributeList(attributes))
name_items = [QGraphicsTextItem(attr.name) for attr in attributes]
point_text = QGraphicsTextItem("Points")
probs_text = QGraphicsTextItem("Probabilities (%)")
all_items = name_items + [point_text, probs_text]
name_offset = -max(t.boundingRect().width() for t in all_items) - 10
w = self.view.viewport().rect().width()
max_width = w + name_offset - 30
points = [self.points[i][self.target_class_index]
for i in attr_inds]
if self.align == OWNomogram.ALIGN_LEFT:
points = [p - p.min() for p in points]
max_ = np.nan_to_num(max(max(abs(p)) for p in points))
d = 100 / max_ if max_ else 1
minimums = [p[self.target_class_index].min() for p in self.points]
if self.scale == OWNomogram.POINT_SCALE:
points = [p * d for p in points]
if self.align == OWNomogram.ALIGN_LEFT:
self.scale_marker_values = lambda x: (x - minimums) * d
else:
self.scale_marker_values = lambda x: x * d
else:
if self.align == OWNomogram.ALIGN_LEFT:
self.scale_marker_values = lambda x: x - minimums
else:
self.scale_marker_values = lambda x: x
point_item, nomogram_head = self.create_main_nomogram(
attributes, attr_inds,
name_items, points, max_width, point_text, name_offset)
probs_item, nomogram_foot = self.create_footer_nomogram(
probs_text, d, minimums, max_width, name_offset)
for item in self.feature_items.values():
item.dot.point_dot = point_item.dot
item.dot.probs_dot = probs_item.dot
item.dot.vertical_line = self.hidden_vertical_line
self.nomogram = nomogram = NomogramItem()
nomogram.add_items([nomogram_head, self.nomogram_main, nomogram_foot])
self.scene.addItem(nomogram)
self.set_feature_marker_values()
rect = QRectF(self.scene.itemsBoundingRect().x(),
self.scene.itemsBoundingRect().y(),
self.scene.itemsBoundingRect().width(),
self.nomogram.preferredSize().height()).adjusted(10, 0, 20, 0)
self.scene.setSceneRect(rect)
# Clip top and bottom (60 and 150) parts from the main view
self.view.setSceneRect(rect.x(), rect.y() + 80, rect.width() - 10, rect.height() - 160)
self.view.viewport().setMaximumHeight(rect.height() - 160)
# Clip main part from top/bottom views
# below point values are imprecise (less/more than required) but this
# is not a problem due to clipped scene content still being drawn
self.top_view.setSceneRect(rect.x(), rect.y() + 3, rect.width() - 10, 20)
self.bottom_view.setSceneRect(rect.x(), rect.height() - 110, rect.width() - 10, 30)
self.available_attrs[:] = []
self.used_attrs[:] = self.data.domain.attributes
self.class_attrs[:] = self.data.domain.class_vars
self.meta_attrs[:] = self.data.domain.metas
self.update_domain_role_hints()
self.commit()
def send_report(self):
if not self.data or not self.output_data:
return
in_domain, out_domain = self.data.domain, self.output_data.domain
self.report_domain("Input data", self.data.domain)
if (in_domain.attributes, in_domain.class_vars,
in_domain.metas) == (out_domain.attributes,
out_domain.class_vars, out_domain.metas):
self.report_paragraph("Output data", "No changes.")
else:
self.report_domain("Output data", self.output_data.domain)
diff = list(
set(in_domain.variables + in_domain.metas) -
set(out_domain.variables + out_domain.metas))
if diff:
text = "%i (%s)" % (len(diff), ", ".join(x.name for x in diff))
self.report_items((("Removed", text), ))
if __name__ == "__main__": # pragma: no cover
data = Orange.data.Table("brown-selected")
features = AttributeList(data.domain.attributes[:2])
WidgetPreview(OWSelectAttributes).run(set_data=data, set_features=features)
def on_selection_changed(self, selected, deselected):
"""Called when the ranks view selection changes."""
a1 = selected.indexes()[1].data().replace('D_', '')
a2 = selected.indexes()[2].data().replace('D_', '')
d = self.data.domain
self.send("Features", AttributeList([d[a1], d[a2]]))
