def test_use_features_checked(self):
data = Table("iris")
attrs = data.domain.attributes
# prepare stored settings (check "Use input features")
in_features = AttributeList(attrs[:2])
self.send_signal(self.widget.Inputs.data, data)
self.send_signal(self.widget.Inputs.features, in_features)
self.widget.use_features_box.checkbox.setChecked(True)
self.assertControlsEnabled(False, False, True)
out_features = self.get_output(self.widget.Outputs.features)
self.assertListEqual(out_features, in_features)
settings = self.widget.settingsHandler.pack_data(self.widget)
# "Use input features" is checked by default
widget = self.create_widget(OWSelectAttributes, settings)
in_features = AttributeList(attrs[:3])
self.send_signal(widget.Inputs.data, data, widget=widget)
self.send_signal(widget.Inputs.features, in_features, widget=widget)
self.assertControlsEnabled(False, False, True, widget)
out_features = self.get_output(widget.Outputs.features, widget=widget)
self.assertListEqual(out_features, in_features)
# reset "Features"
widget.reset()
out_features = self.get_output(widget.Outputs.features, widget=widget)
self.assertFalse(widget.use_features_box.checkbox.isChecked())
self.assertListEqual(out_features, AttributeList(attrs))
self.assertControlsEnabled(True, True, True, widget)
def test_features(self):
w = self.widget
self.send_signal(w.Inputs.time_series, self.amzn)
self.assertEqual(1, len(w.configs))
sel = self.amzn.domain.attributes[3:6]
self.send_signal(w.Inputs.features, AttributeList(sel))
self.assertEqual(3, len(w.configs))
sel = self.amzn.domain.attributes[3:5]
self.send_signal(w.Inputs.features, AttributeList(sel))
self.assertEqual(2, len(w.configs))
def test_input_features_no_data(self):
data = Table("zoo")
in_features = AttributeList(data.domain.variables + data.domain.metas)
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))
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, 0)))]
for row in range(model.rowCount())])
# pylint: disable=protected-access
m = np.array([[
a.name
for a in model.data(model.index(row, 0), CorrelationRank._AttrRole)
] 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_features_and_data(self):
self.assertTrue(self.widget.attr_box.isEnabled())
self.send_signal(self.widget.Inputs.data, self.data)
x, y = self.widget.graph.scatterplot_item.getData()
np.testing.assert_array_equal(x, self.data.X[:, 0])
np.testing.assert_array_equal(y, self.data.X[:, 1])
self.send_signal(self.widget.Inputs.features,
AttributeList(self.data.domain[2:]))
self.assertIs(self.widget.attr_x, self.data.domain[2])
self.assertIs(self.widget.attr_y, self.data.domain[3])
self.assertFalse(self.widget.attr_box.isEnabled())
self.assertFalse(self.widget.vizrank.isEnabled())
x, y = self.widget.graph.scatterplot_item.getData()
np.testing.assert_array_equal(x, self.data.X[:, 2])
np.testing.assert_array_equal(y, self.data.X[:, 3])
self.send_signal(self.widget.Inputs.data, None)
self.send_signal(self.widget.Inputs.data, self.data)
self.assertIs(self.widget.attr_x, self.data.domain[2])
self.assertIs(self.widget.attr_y, self.data.domain[3])
self.assertFalse(self.widget.attr_box.isEnabled())
self.assertFalse(self.widget.vizrank.isEnabled())
self.send_signal(self.widget.Inputs.features, None)
self.assertTrue(self.widget.attr_box.isEnabled())
self.assertTrue(self.widget.vizrank.isEnabled())
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
attrs = [ContinuousVariable("Correlation"), ContinuousVariable("FDR")]
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 (Qt.DisplayRole, CorrelationRank.PValRole)
] for row in range(model.rowCount())])
x[:, 1] = FDR(list(x[:, 1]))
# pylint: disable=protected-access
m = np.array([[
a.name
for a in model.data(model.index(row, 0), CorrelationRank._AttrRole)
] 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(
[self.data.domain[name] for name, _ in self.selection]))
self.Outputs.correlations.send(corr_table)
def test_invalidated_same_time_features_first(self):
self.widget.setup_plot = Mock()
# send features and data at the same time (features first)
features = self.data.domain.attributes[:2]
signals = [(self.widget.Inputs.features, AttributeList(features)),
(self.widget.Inputs.data, self.data)]
self.send_signals(signals)
self.widget.setup_plot.assert_called_once()
self.assertListEqual(self.widget.effective_variables, list(features))
self.widget.setup_plot.reset_mock()
features = self.data.domain.attributes[2:]
signals = [(self.widget.Inputs.features, AttributeList(features)),
(self.widget.Inputs.data, self.data)]
self.send_signals(signals)
self.widget.setup_plot.assert_called_once()
def test_features_and_data(self):
data = Table("iris")
self.send_signal(self.widget.Inputs.data, data)
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])
def commit(self):
if self.data is None or self.cont_data is None:
self.send("Data", self.data)
self.send("Features", None)
self.send("Correlations", 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.send("Data", self.data)
# data has been imputed; send original attributes
self.send(
"Features",
AttributeList(
[attr.compute_value.variable for attr in self.selection]))
self.send("Correlations", corr_table)
def test_features_and_no_data(self):
"""
Prevent crashing when features are sent but no data.
"""
domain = Table("iris").domain
self.send_signal(self.widget.Inputs.features,
AttributeList(domain.variables))
self.send_signal(self.widget.Inputs.features, None)
def test_input_features_same_domain(self):
data = Table("zoo")
in_features = AttributeList(data.domain.variables + data.domain.metas)
self.send_signal(self.widget.Inputs.data, data)
self.send_signal(self.widget.Inputs.features, in_features)
self.assertControlsEnabled(True, False, True)
self.assertVariableCountsEqual(0, 16, 1, 1)
self.assertListEqual(self.get_output(self.widget.Outputs.features),
list(data.domain.attributes))
def test_input_features_sub_domain(self):
data = Table("zoo")
in_features = AttributeList(data.domain.attributes[::3])
self.send_signal(self.widget.Inputs.data, data)
self.send_signal(self.widget.Inputs.features, in_features)
self.assertControlsEnabled(True, True, True)
self.assertVariableCountsEqual(10, 6, 1, 1)
self.assertListEqual(self.get_output(self.widget.Outputs.features),
in_features)
def test_input_features_by_name_sub_domain(self):
data = Table("zoo")
in_features = AttributeList([DiscreteVariable(attr.name, attr.values)
for attr in data.domain.attributes[:5]])
self.send_signal(self.widget.Inputs.data, data)
self.send_signal(self.widget.Inputs.features, in_features)
self.assertControlsEnabled(True, True, True)
self.assertVariableCountsEqual(11, 5, 1, 1)
self.assertListEqual(self.get_output(self.widget.Outputs.features),
list(data.domain.attributes[:5]))
def test_input_features(self):
self.assertTrue(self.widget.attr_box.isEnabled())
self.send_signal(self.widget.Inputs.data, self.iris)
self.send_signal(self.widget.Inputs.features,
AttributeList(self.iris.domain.attributes))
self.assertFalse(self.widget.attr_box.isEnabled())
self.assertFalse(self.widget.vizrank.isEnabled())
self.send_signal(self.widget.Inputs.features, None)
self.assertTrue(self.widget.attr_box.isEnabled())
self.assertTrue(self.widget.vizrank.isEnabled())
def test_data_none(self):
w = self.widget
self.send_signal(w.Inputs.time_series, None)
# send selection when no data on the input
self.send_signal(
w.Inputs.features, AttributeList(self.airpassengers.attributes)
)
# send forecast on empty data
model1 = ARIMA((3, 1, 1)).fit(self.airpassengers)
prediction = model1.predict(10, as_table=True)
self.send_signal(w.Inputs.forecast, prediction, 1)
def test_input_features_diff_domain(self):
zoo = Table("zoo")
in_features = AttributeList(Table("iris").domain.attributes)
self.send_signal(self.widget.Inputs.data, zoo)
self.send_signal(self.widget.Inputs.features, in_features)
self.assertControlsEnabled(True, False, False)
self.assertVariableCountsEqual(0, 16, 1, 1)
self.assertListEqual(self.get_output(self.widget.Outputs.features),
list(zoo.domain.attributes))
self.assertTrue(self.widget.Warning.mismatching_domain.is_shown())
self.send_signal(self.widget.Inputs.features, None)
self.assertFalse(self.widget.Warning.mismatching_domain.is_shown())
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 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 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]]))
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)
