def test_predictor_fails(self):
titanic = Table("titanic")
failing_model = ConstantLearner()(titanic)
failing_model.predict = Mock(side_effect=ValueError("foo"))
self.send_signal(self.widget.Inputs.predictors, failing_model, 1)
self.send_signal(self.widget.Inputs.data, titanic)
model2 = ConstantLearner()(titanic)
self.send_signal(self.widget.Inputs.predictors, model2, 2)
def test_predictor_fails(self):
titanic = Table("titanic")
failing_model = ConstantLearner()(titanic)
failing_model.predict = Mock(side_effect=ValueError("foo"))
self.send_signal(self.widget.Inputs.predictors, failing_model, 1)
self.send_signal(self.widget.Inputs.data, titanic)
model2 = ConstantLearner()(titanic)
self.send_signal(self.widget.Inputs.predictors, model2, 2)
def test_multi_inputs(self):
w = self.widget
data = self.iris[::5].copy()
p1 = ConstantLearner()(data)
p1.name = "P1"
p2 = ConstantLearner()(data)
p2.name = "P2"
p3 = ConstantLearner()(data)
p3.name = "P3"
for i, p in enumerate([p1, p2, p3], 1):
self.send_signal(w.Inputs.predictors, p, i)
self.send_signal(w.Inputs.data, data)
def check_evres(expected):
out = self.get_output(w.Outputs.evaluation_results)
self.assertSequenceEqual(out.learner_names, expected)
check_evres(["P1", "P2", "P3"])
self.send_signal(w.Inputs.predictors, None, 2)
check_evres(["P1", "P3"])
self.send_signal(w.Inputs.predictors, p2, 2)
check_evres(["P1", "P2", "P3"])
self.send_signal(w.Inputs.predictors,
w.Inputs.predictors.closing_sentinel, 2)
check_evres(["P1", "P3"])
self.send_signal(w.Inputs.predictors, p2, 2)
check_evres(["P1", "P3", "P2"])
def test_mismatching_targets(self):
error = self.widget.Error
titanic = Table("titanic")
majority_titanic = ConstantLearner()(titanic)
majority_iris = ConstantLearner()(self.iris)
self.send_signal(self.widget.Inputs.data, self.iris)
self.send_signal(self.widget.Inputs.predictors, majority_iris, 1)
self.send_signal(self.widget.Inputs.predictors, majority_titanic, 2)
self.assertTrue(error.predictors_target_mismatch.is_shown())
self.assertIsNone(self.get_output(self.widget.Outputs.predictions))
self.send_signal(self.widget.Inputs.predictors, None, 1)
self.assertFalse(error.predictors_target_mismatch.is_shown())
self.assertTrue(error.data_target_mismatch.is_shown())
self.assertIsNone(self.get_output(self.widget.Outputs.predictions))
self.send_signal(self.widget.Inputs.data, None)
self.assertFalse(error.predictors_target_mismatch.is_shown())
self.assertFalse(error.data_target_mismatch.is_shown())
self.assertIsNone(self.get_output(self.widget.Outputs.predictions))
self.send_signal(self.widget.Inputs.predictors, None, 2)
self.assertFalse(error.predictors_target_mismatch.is_shown())
self.assertFalse(error.data_target_mismatch.is_shown())
self.assertIsNone(self.get_output(self.widget.Outputs.predictions))
self.send_signal(self.widget.Inputs.predictors, majority_titanic, 2)
self.assertFalse(error.predictors_target_mismatch.is_shown())
self.assertFalse(error.data_target_mismatch.is_shown())
self.assertIsNone(self.get_output(self.widget.Outputs.predictions))
self.send_signal(self.widget.Inputs.data, self.iris)
self.assertFalse(error.predictors_target_mismatch.is_shown())
self.assertTrue(error.data_target_mismatch.is_shown())
self.assertIsNone(self.get_output(self.widget.Outputs.predictions))
self.send_signal(self.widget.Inputs.predictors, majority_iris, 2)
self.assertFalse(error.predictors_target_mismatch.is_shown())
self.assertFalse(error.data_target_mismatch.is_shown())
output = self.get_output(self.widget.Outputs.predictions)
self.assertEqual(len(output.domain.metas), 4)
self.send_signal(self.widget.Inputs.predictors, majority_iris, 1)
self.send_signal(self.widget.Inputs.predictors, majority_titanic, 3)
self.assertTrue(error.predictors_target_mismatch.is_shown())
self.assertFalse(error.data_target_mismatch.is_shown())
self.assertIsNone(self.get_output(self.widget.Outputs.predictions))
def test_no_values_target(self):
train = Table("titanic")
model = ConstantLearner()(train)
self.send_signal(self.widget.Inputs.predictors, model)
domain = Domain([DiscreteVariable("status", values=("first", "third")),
DiscreteVariable("age", values=("adult", "child")),
DiscreteVariable("sex", values=("female", "male"))],
[DiscreteVariable("survived", values=())])
test = Table(domain, np.array([[0, 0, 1], [0, 1, 0], [1, 0, 0]]),
np.full((3, 1), np.nan))
self.send_signal(self.widget.Inputs.data, test)
pred = self.get_output(self.widget.Outputs.predictions)
self.assertEqual(len(pred), len(test))
results = self.get_output(self.widget.Outputs.evaluation_results)
cm_widget = self.create_widget(OWConfusionMatrix)
self.send_signal(cm_widget.Inputs.evaluation_results, results,
widget=cm_widget)
ra_widget = self.create_widget(OWROCAnalysis)
self.send_signal(ra_widget.Inputs.evaluation_results, results,
widget=ra_widget)
lc_widget = self.create_widget(OWLiftCurve)
self.send_signal(lc_widget.Inputs.evaluation_results, results,
widget=lc_widget)
cp_widget = self.create_widget(OWCalibrationPlot)
self.send_signal(cp_widget.Inputs.evaluation_results, results,
widget=cp_widget)
def test_nan_target_input(self):
data = self.iris[::10].copy()
data.Y[1] = np.nan
yvec, _ = data.get_column_view(data.domain.class_var)
self.send_signal(self.widget.Inputs.data, data)
self.send_signal(self.widget.Inputs.predictors,
ConstantLearner()(data), 1)
pred = self.get_output(self.widget.Outputs.predictions)
self.assertIsInstance(pred, Table)
np.testing.assert_array_equal(
yvec,
pred.get_column_view(data.domain.class_var)[0])
evres = self.get_output(self.widget.Outputs.evaluation_results)
self.assertIsInstance(evres, Results)
self.assertIsInstance(evres.data, Table)
ev_yvec, _ = evres.data.get_column_view(data.domain.class_var)
self.assertTrue(np.all(~np.isnan(ev_yvec)))
self.assertTrue(np.all(~np.isnan(evres.actual)))
data.Y[:] = np.nan
self.send_signal(self.widget.Inputs.data, data)
evres = self.get_output(self.widget.Outputs.evaluation_results)
self.assertEqual(len(evres.data), 0)
def test_CrossValidationByFeature(self):
data = Table("iris")
attrs = data.domain.attributes
domain = Domain(attrs[:-1], attrs[-1], data.domain.class_vars)
data_with_disc_metas = Table.from_table(domain, data)
rb = self.widget.controls.resampling.buttons[
OWTestLearners.FeatureFold]
self.send_signal(self.widget.Inputs.learner, ConstantLearner(), 0)
self.send_signal(self.widget.Inputs.train_data, data)
self.assertFalse(rb.isEnabled())
self.assertFalse(self.widget.features_combo.isEnabled())
self.get_output(self.widget.Outputs.evaluations_results, wait=5000)
self.send_signal(self.widget.Inputs.train_data, data_with_disc_metas)
self.assertTrue(rb.isEnabled())
rb.click()
self.assertEqual(self.widget.resampling, OWTestLearners.FeatureFold)
self.assertTrue(self.widget.features_combo.isEnabled())
self.assertEqual(self.widget.features_combo.currentText(), "iris")
self.assertEqual(len(self.widget.features_combo.model()), 1)
self.get_output(self.widget.Outputs.evaluations_results, wait=5000)
self.send_signal(self.widget.Inputs.train_data, None)
self.assertFalse(rb.isEnabled())
self.assertEqual(self.widget.resampling, OWTestLearners.KFold)
self.assertFalse(self.widget.features_combo.isEnabled())
def test_unique_output_domain(self):
data = possible_duplicate_table('constant')
predictor = ConstantLearner()(data)
self.send_signal(self.widget.Inputs.data, data)
self.send_signal(self.widget.Inputs.predictors, predictor)
output = self.get_output(self.widget.Outputs.predictions)
self.assertEqual(output.domain.metas[0].name, 'constant (1)')
def test_scores_constant_all_same(self):
table = Table(self.scores_domain,
list(zip(*self.scores_table_values + [list("yyyy")])))
self.assertTupleEqual(
self._test_scores(table, table, ConstantLearner(),
OWTestLearners.TestOnTest, None),
(None, 1, 1, 1, 1))
def test_NN_regression(self):
const = ConstantLearner()
results = CrossValidation(self.housing, [NNRegressionLearner(), const],
k=3)
mse = MSE()
res = mse(results)
self.assertLess(res[0], 35)
self.assertLess(res[0], res[1])
def test_colors_continuous(self):
"""
When only continuous variables in predictor no color should be selected
we do not work with classes.
When we add one classifier there should be colors.
"""
# pylint: disable=protected-access
data = Table("housing")
cl_data = ConstantLearner()(data)
self.send_signal(self.widget.Inputs.predictors, cl_data)
self.send_signal(self.widget.Inputs.data, data)
colors = self.widget._get_colors()
self.assertListEqual([], colors)
predictor_iris = ConstantLearner()(self.iris)
self.send_signal(self.widget.Inputs.predictors, predictor_iris, 1)
colors = self.widget._get_colors()
self.assertEqual(3, len(colors))
def test_scores_constant(self):
table = Table.from_list(
self.scores_domain,
list(zip(*self.scores_table_values + [list("yyyn")])))
self.assertTupleEqual(
self._test_scores(table, table[:3], ConstantLearner(),
OWTestAndScore.TestOnTest, None),
(None, 1, 1, 1, 1))
def test_summary(self):
"""Check if the status bar updates when data is recieved"""
data = self.iris
info = self.widget.info
no_input, no_output = "No data on input", "No data on output"
predictor1 = ConstantLearner()(self.iris)
predictor2 = LogisticRegressionLearner()(self.iris)
self.send_signal(self.widget.Inputs.predictors, predictor1)
details = f"Data:<br>{no_input}.<hr>" + \
"Model: 1 model (1 failed)<ul><li>constant</li></ul>"
self.assertEqual(info._StateInfo__input_summary.brief, "0")
self.assertEqual(info._StateInfo__input_summary.details, details)
self.assertEqual(info._StateInfo__output_summary.brief, "")
self.assertEqual(info._StateInfo__output_summary.details, no_output)
self.send_signal(self.widget.Inputs.data, data)
details = "Data:<br>" + \
format_summary_details(data).replace('\n', '<br>') + \
"<hr>Model: 1 model<ul><li>constant</li></ul>"
self.assertEqual(info._StateInfo__input_summary.brief, "150")
self.assertEqual(info._StateInfo__input_summary.details, details)
output = self.get_output(self.widget.Outputs.predictions)
summary, details = f"{len(output)}", format_summary_details(output)
self.assertEqual(info._StateInfo__output_summary.brief, summary)
self.assertEqual(info._StateInfo__output_summary.details, details)
self.send_signal(self.widget.Inputs.predictors, predictor2, 1)
details = "Data:<br>"+ \
format_summary_details(data).replace('\n', '<br>') + \
"<hr>Model: 2 models<ul><li>constant</li>" + \
"<li>logistic regression</li></ul>"
self.assertEqual(info._StateInfo__input_summary.brief, "150")
self.assertEqual(info._StateInfo__input_summary.details, details)
output = self.get_output(self.widget.Outputs.predictions)
summary, details = f"{len(output)}", format_summary_details(output)
self.assertEqual(info._StateInfo__output_summary.brief, summary)
self.assertEqual(info._StateInfo__output_summary.details, details)
self.send_signal(self.widget.Inputs.predictors, None)
self.send_signal(self.widget.Inputs.predictors, None, 1)
details = "Data:<br>" + \
format_summary_details(data).replace('\n', '<br>') + \
"<hr>Model:<br>No model on input."
self.assertEqual(info._StateInfo__input_summary.brief, "150")
self.assertEqual(info._StateInfo__input_summary.details, details)
output = self.get_output(self.widget.Outputs.predictions)
summary, details = f"{len(output)}", format_summary_details(output)
self.assertEqual(info._StateInfo__output_summary.brief, summary)
self.assertEqual(info._StateInfo__output_summary.details, details)
self.send_signal(self.widget.Inputs.data, None)
self.assertEqual(info._StateInfo__input_summary.brief, "")
self.assertEqual(info._StateInfo__input_summary.details, no_input)
self.assertEqual(info._StateInfo__output_summary.brief, "")
self.assertEqual(info._StateInfo__output_summary.details, no_output)
def test_no_class_on_test(self):
"""Allow test data with no class"""
titanic = Table("titanic")
majority_titanic = ConstantLearner()(titanic)
no_class = titanic.transform(Domain(titanic.domain.attributes, None))
self.send_signal(self.widget.Inputs.predictors, majority_titanic, 1)
self.send_signal(self.widget.Inputs.data, no_class)
out = self.get_output(self.widget.Outputs.predictions)
np.testing.assert_allclose(out.get_column_view("constant")[0], 0)
def test_colors_same_domain(self):
"""
Test whether the color selection for values is correct.
"""
# pylint: disable=protected-access
self.send_signal(self.widget.Inputs.data, self.iris)
# case 1: one same model
predictor_iris = ConstantLearner()(self.iris)
self.send_signal(self.widget.Inputs.predictors, predictor_iris)
colors = self.widget._get_colors()
np.testing.assert_array_equal(
colors, self.iris.domain.class_var.colors)
# case 2: two same models
predictor_iris1 = ConstantLearner()(self.iris)
predictor_iris2 = ConstantLearner()(self.iris)
self.send_signal(self.widget.Inputs.predictors, predictor_iris1)
self.send_signal(self.widget.Inputs.predictors, predictor_iris2, 1)
colors = self.widget._get_colors()
# assume that colors have same order since values have same order
np.testing.assert_array_equal(
colors, self.iris.domain.class_var.colors)
# case 3: two same models - changed color order
idom = self.iris.domain
dom = Domain(
idom.attributes,
DiscreteVariable(idom.class_var.name, idom.class_var.values)
)
dom.class_var.colors = dom.class_var.colors[::-1]
iris2 = self.iris.transform(dom)
predictor_iris1 = ConstantLearner()(iris2)
predictor_iris2 = ConstantLearner()(iris2)
self.send_signal(self.widget.Inputs.predictors, predictor_iris1)
self.send_signal(self.widget.Inputs.predictors, predictor_iris2, 1)
colors = self.widget._get_colors()
np.testing.assert_array_equal(colors, iris2.domain.class_var.colors)
def test_mismatching_targets(self):
warning = self.widget.Warning
maj_iris = ConstantLearner()(self.iris)
dom = self.iris.domain
iris3 = self.iris.transform(Domain(dom[:3], dom[3]))
maj_iris3 = ConstantLearner()(iris3)
self.send_signal(self.widget.Inputs.predictors, maj_iris, 1)
self.send_signal(self.widget.Inputs.predictors, maj_iris3, 2)
self.assertFalse(warning.wrong_targets.is_shown())
self.send_signal(self.widget.Inputs.data, self.iris)
self.assertTrue(warning.wrong_targets.is_shown())
self.send_signal(self.widget.Inputs.predictors, None, 2)
self.assertFalse(warning.wrong_targets.is_shown())
self.send_signal(self.widget.Inputs.predictors, maj_iris3, 2)
self.assertTrue(warning.wrong_targets.is_shown())
self.send_signal(self.widget.Inputs.data, None)
self.assertFalse(warning.wrong_targets.is_shown())
def test_no_class_on_test(self):
"""Allow test data with no class"""
error = self.widget.Error
titanic = Table("titanic")
majority_titanic = ConstantLearner()(titanic)
majority_iris = ConstantLearner()(self.iris)
no_class = Table(Domain(titanic.domain.attributes, None), titanic)
self.send_signal(self.widget.Inputs.predictors, majority_titanic, 1)
self.send_signal(self.widget.Inputs.data, no_class)
out = self.get_output(self.widget.Outputs.predictions)
np.testing.assert_allclose(out.get_column_view("constant")[0], 0)
self.send_signal(self.widget.Inputs.predictors, majority_iris, 2)
self.assertTrue(error.predictors_target_mismatch.is_shown())
self.assertFalse(error.data_target_mismatch.is_shown())
self.assertIsNone(self.get_output(self.widget.Outputs.predictions))
self.send_signal(self.widget.Inputs.predictors, None, 2)
self.send_signal(self.widget.Inputs.data, titanic)
out = self.get_output(self.widget.Outputs.predictions)
np.testing.assert_allclose(out.get_column_view("constant")[0], 0)
def test_changed_class_var(self):
def set_input(data, model):
self.send_signals([
(self.widget.Inputs.data, data),
(self.widget.Inputs.predictors, model)
])
iris = self.iris
learner = ConstantLearner()
heart_disease = Table("heart_disease")
# catch exceptions in item delegates etc. during switching inputs
with excepthook_catch():
set_input(iris[:5], learner(iris))
set_input(Table("housing"), None)
set_input(heart_disease[:5], learner(heart_disease))
def test_continuous_class(self):
data = Table("housing")
cl_data = ConstantLearner()(data)
self.send_signal("Predictors", cl_data, 1)
self.send_signal("Data", data)
def test_colors_diff_domain(self):
"""
Test whether the color selection for values is correct.
"""
# pylint: disable=protected-access
self.send_signal(self.widget.Inputs.data, self.iris)
# case 1: two domains one subset other
idom = self.iris.domain
dom1 = Domain(
idom.attributes,
DiscreteVariable(idom.class_var.name, idom.class_var.values))
dom2 = Domain(
idom.attributes,
DiscreteVariable(idom.class_var.name, idom.class_var.values[:2]))
iris1 = self.iris[:100].transform(dom1)
iris2 = self.iris[:100].transform(dom2)
predictor_iris1 = ConstantLearner()(iris1)
predictor_iris2 = ConstantLearner()(iris2)
self.send_signal(self.widget.Inputs.predictors, predictor_iris1)
self.send_signal(self.widget.Inputs.predictors, predictor_iris2, 1)
colors = self.widget._get_colors()
np.testing.assert_array_equal(colors, iris1.domain.class_var.colors)
# case 2: two domains one subset other - different color order
idom = self.iris.domain
colors = idom.class_var.colors[::-1]
dom1 = Domain(
idom.attributes,
DiscreteVariable(idom.class_var.name, idom.class_var.values))
dom2 = Domain(
idom.attributes,
DiscreteVariable(idom.class_var.name, idom.class_var.values[:2]))
dom1.class_var.colors = colors
dom2.class_var.colors = colors[:2]
iris1 = self.iris[:100].transform(dom1)
iris2 = self.iris[:100].transform(dom2)
predictor_iris1 = ConstantLearner()(iris1)
predictor_iris2 = ConstantLearner()(iris2)
self.send_signal(self.widget.Inputs.predictors, predictor_iris1)
self.send_signal(self.widget.Inputs.predictors, predictor_iris2, 1)
colors = self.widget._get_colors()
np.testing.assert_array_equal(colors, iris1.domain.class_var.colors)
# case 3: domain color, values miss-match - use default colors
idom = self.iris.domain
dom1 = Domain(
idom.attributes,
DiscreteVariable(idom.class_var.name, idom.class_var.values))
dom2 = Domain(
idom.attributes,
DiscreteVariable(idom.class_var.name, idom.class_var.values))
dom1.class_var.colors = dom1.class_var.colors[::-1]
iris1 = self.iris.transform(dom1)
iris2 = self.iris.transform(dom2)
predictor_iris1 = ConstantLearner()(iris1)
predictor_iris2 = ConstantLearner()(iris2)
self.send_signal(self.widget.Inputs.predictors, predictor_iris1)
self.send_signal(self.widget.Inputs.predictors, predictor_iris2, 1)
colors = self.widget._get_colors()
np.testing.assert_array_equal(colors, ColorPaletteGenerator.palette(3))
# case 4: two domains different values order, matching colors
idom = self.iris.domain
# this way we know that default colors are not used
colors = ColorPaletteGenerator.palette(5)[2:]
dom1 = Domain(
idom.attributes,
DiscreteVariable(idom.class_var.name, idom.class_var.values))
dom2 = Domain(
idom.attributes,
DiscreteVariable(idom.class_var.name, idom.class_var.values[::-1]))
dom1.class_var.colors = colors
dom2.class_var.colors = colors[::-1] # colors mixed same than values
iris1 = self.iris[:100].transform(dom1)
iris2 = self.iris[:100].transform(dom2)
predictor_iris1 = ConstantLearner()(iris1)
predictor_iris2 = ConstantLearner()(iris2)
self.send_signal(self.widget.Inputs.predictors, predictor_iris1)
self.send_signal(self.widget.Inputs.predictors, predictor_iris2, 1)
colors = self.widget._get_colors()
np.testing.assert_array_equal(colors, iris1.domain.class_var.colors)
def test_continuous_class(self):
data = Table("housing")
cl_data = ConstantLearner()(data)
self.send_signal(self.widget.Inputs.predictors, cl_data, 1)
self.send_signal(self.widget.Inputs.data, data)
