def test_basic(self):
data = Table("iris")[::3]
self.send_signal(self.widget.Inputs.train_data, data)
self.send_signal(self.widget.Inputs.learner,
MajorityLearner(),
0,
wait=5000)
res = self.get_output(self.widget.Outputs.evaluations_results)
self.assertIsInstance(res, Results)
self.assertIsNotNone(res.domain)
self.assertIsNotNone(res.data)
self.assertIsNotNone(res.probabilities)
self.send_signal(self.widget.Inputs.learner, None, 0, wait=5000)
res = self.get_output(self.widget.Outputs.evaluations_results)
self.assertIsNone(res)
data = Table("housing")[::10]
self.send_signal(self.widget.Inputs.train_data, data)
self.send_signal(self.widget.Inputs.learner,
MeanLearner(),
0,
wait=5000)
res = self.get_output(self.widget.Outputs.evaluations_results)
self.assertIsInstance(res, Results)
self.assertIsNotNone(res.domain)
self.assertIsNotNone(res.data)
def test_augmented_data_regression(self):
data = Table("housing")
res = CrossValidation(store_data=True)(data,
[LinearRegressionLearner()])
table = res.get_augmented_data(['Linear Regression'])
self.assertEqual(len(table), len(data))
self.assertEqual(len(table.domain.attributes),
len(data.domain.attributes))
self.assertEqual(len(table.domain.class_vars),
len(data.domain.class_vars))
# +1 for class, +1 for fold
self.assertEqual(len(table.domain.metas),
len(data.domain.metas) + 1 + 1)
res = CrossValidation(store_data=True)(
data, [LinearRegressionLearner(),
MeanLearner()])
table = res.get_augmented_data(['Linear Regression', 'Mean Learner'])
self.assertEqual(len(table), len(data))
self.assertEqual(len(table.domain.attributes),
len(data.domain.attributes))
self.assertEqual(len(table.domain.class_vars),
len(data.domain.class_vars))
# +2 for class, +1 for fold
self.assertEqual(len(table.domain.metas),
len(data.domain.metas) + 2 + 1)
def test_Regression(self):
ridge = RidgeRegressionLearner()
lasso = LassoRegressionLearner()
elastic = ElasticNetLearner()
elasticCV = ElasticNetCVLearner()
mean = MeanLearner()
learners = [ridge, lasso, elastic, elasticCV, mean]
res = CrossValidation(self.housing, learners, k=2)
rmse = RMSE(res)
for i in range(len(learners) - 1):
self.assertLess(rmse[i], rmse[-1])
def test_support(self):
table = data.Table.from_file("iris")
continuous = table.domain.variables[0]
discrete = table.domain.variables[-1]
imputer = impute.Model(MajorityLearner())
self.assertTrue(imputer.supports_variable(discrete))
self.assertFalse(imputer.supports_variable(continuous))
imputer = impute.Model(MeanLearner())
self.assertFalse(imputer.supports_variable(discrete))
self.assertTrue(imputer.supports_variable(continuous))
def test_show_error_on_regression(self):
"""On regression data, the widget must show error"""
housing = Table("housing")
results = TestOnTrainingData(housing, [MeanLearner()], store_data=True)
self.send_signal(self.widget.Inputs.evaluation_results, results)
self.assertTrue(self.widget.Error.no_regression.is_shown())
self.send_signal(self.widget.Inputs.evaluation_results, None)
self.assertFalse(self.widget.Error.no_regression.is_shown())
self.send_signal(self.widget.Inputs.evaluation_results, results)
self.assertTrue(self.widget.Error.no_regression.is_shown())
self.send_signal(self.widget.Inputs.evaluation_results, self.results_1_iris)
self.assertFalse(self.widget.Error.no_regression.is_shown())
def test_mean(self):
nrows = 1000
ncols = 10
x = np.random.random_integers(1, 3, (nrows, ncols))
y = np.random.random_integers(0, 4, (nrows, 1)) / 3.0
t = Table(x, y)
learn = MeanLearner()
clf = learn(t)
true_mean = np.average(y)
x2 = np.random.random_integers(1, 3, (nrows, ncols))
y2 = clf(x2)
self.assertTrue(np.allclose(y2, true_mean))
def test_weights(self):
nrows = 100
ncols = 10
x = np.random.random_integers(1, 3, (nrows, ncols))
y = np.random.random_integers(0, 4, (nrows, 1)) / 3.0
heavy = 1
w = ((y == heavy) * 123 + 1.0) / 124.0
t = Table(x, y, W=w)
learn = MeanLearner()
clf = learn(t)
expected_mean = np.average(y, weights=w)
x2 = np.random.random_integers(1, 3, (nrows, ncols))
y2 = clf(x2)
self.assertTrue(np.allclose(y2, expected_mean))
def test_replacement(self):
from Orange.classification import MajorityLearner, SimpleTreeLearner
from Orange.regression import MeanLearner
nan = np.nan
X = [
[1.0, nan, 0.0],
[2.0, 1.0, 3.0],
[nan, nan, nan]
]
unknowns = np.isnan(X)
domain = data.Domain(
(data.DiscreteVariable("A", values=["0", "1", "2"]),
data.ContinuousVariable("B"),
data.ContinuousVariable("C"))
)
table = data.Table.from_numpy(domain, np.array(X))
v = impute.Model(MajorityLearner())(table, domain[0])
self.assertTrue(np.all(np.isfinite(v.compute_value(table))))
self.assertTrue(np.all(v.compute_value(table) == [1., 2., 1.])
or np.all(v.compute_value(table) == [1., 2., 2.]))
v = impute.Model(MeanLearner())(table, domain[1])
self.assertTrue(np.all(np.isfinite(v.compute_value(table))))
self.assertTrue(np.all(v.compute_value(table) == [1., 1., 1.]))
imputer = preprocess.Impute(impute.Model(SimpleTreeLearner()))
itable = imputer(table)
# Original data should keep unknowns
self.assertTrue(np.all(np.isnan(table.X) == unknowns))
self.assertTrue(np.all(itable.X[~unknowns] == table.X[~unknowns]))
Aimp = itable.domain["A"].compute_value
self.assertIsInstance(Aimp, impute.ReplaceUnknownsModel)
col = Aimp(table)
self.assertEqual(col.shape, (len(table),))
self.assertTrue(np.all(np.isfinite(col)))
v = Aimp(table[-1])
self.assertEqual(v.shape, (1,))
self.assertTrue(np.all(np.isfinite(v)))
def test_basic(self):
data = Table("iris")[::3]
self.send_signal("Data", data)
self.send_signal("Learner", MajorityLearner(), 0)
res = self.get_output("Evaluation Results")
self.assertIsInstance(res, Results)
self.assertIsNotNone(res.domain)
self.assertIsNotNone(res.data)
self.assertIsNotNone(res.probabilities)
self.send_signal("Learner", None, 0)
data = Table("housing")[::10]
self.send_signal("Data", data)
self.send_signal("Learner", MeanLearner(), 0)
res = self.get_output("Evaluation Results")
self.assertIsInstance(res, Results)
self.assertIsNotNone(res.domain)
self.assertIsNotNone(res.data)
def test_replacement(self):
nan = np.nan
X = [[1.0, nan, 0.0], [2.0, 1.0, 3.0], [nan, nan, nan]]
unknowns = np.isnan(X)
domain = data.Domain(
(data.DiscreteVariable("A", values=("0", "1", "2")),
data.ContinuousVariable("B"), data.ContinuousVariable("C")),
# the class is here to ensure the backmapper in model does not
# run and raise exception
data.DiscreteVariable("Z", values=("P", "M")))
table = data.Table.from_numpy(domain, np.array(X), [
0,
] * 3)
v = impute.Model(MajorityLearner())(table, domain[0])
self.assertTrue(np.all(np.isfinite(v.compute_value(table))))
self.assertTrue(
np.all(v.compute_value(table) == [1., 2., 1.])
or np.all(v.compute_value(table) == [1., 2., 2.]))
v = impute.Model(MeanLearner())(table, domain[1])
self.assertTrue(np.all(np.isfinite(v.compute_value(table))))
self.assertTrue(np.all(v.compute_value(table) == [1., 1., 1.]))
imputer = preprocess.Impute(impute.Model(SimpleTreeLearner()))
itable = imputer(table)
# Original data should keep unknowns
self.assertTrue(np.all(np.isnan(table.X) == unknowns))
self.assertTrue(np.all(itable.X[~unknowns] == table.X[~unknowns]))
Aimp = itable.domain["A"].compute_value
self.assertIsInstance(Aimp, impute.ReplaceUnknownsModel)
col = Aimp(table)
self.assertEqual(col.shape, (len(table), ))
self.assertTrue(np.all(np.isfinite(col)))
v = Aimp(table[-1])
self.assertEqual(v.shape, (1, ))
self.assertTrue(np.all(np.isfinite(v)))
def test_no_stratification(self):
w = self.widget
w.cv_stratified = True
self._test_scores(
Table("zoo"), None, MajorityLearner(),
OWTestAndScore.KFold, 2)
self.assertTrue(w.Warning.cant_stratify.is_shown())
w.controls.cv_stratified.click()
self.assertFalse(w.Warning.cant_stratify.is_shown())
w.controls.cv_stratified.click()
self.assertTrue(w.Warning.cant_stratify.is_shown())
w.controls.n_folds.setCurrentIndex(0)
w.controls.n_folds.activated[int].emit(0)
self.assertFalse(w.Warning.cant_stratify.is_shown())
w.controls.n_folds.setCurrentIndex(2)
w.controls.n_folds.activated[int].emit(2)
self.assertTrue(w.Warning.cant_stratify.is_shown())
self._test_scores(
Table("iris"), None, MajorityLearner(), OWTestAndScore.KFold, 2)
self.assertFalse(w.Warning.cant_stratify.is_shown())
self._test_scores(
Table("zoo"), None, MajorityLearner(), OWTestAndScore.KFold, 2)
self.assertTrue(w.Warning.cant_stratify.is_shown())
self._test_scores(
Table("housing"), None, MeanLearner(), OWTestAndScore.KFold, 2)
self.assertFalse(w.Warning.cant_stratify.is_shown())
self.assertTrue(w.Information.cant_stratify_numeric.is_shown())
w.controls.cv_stratified.click()
self.assertFalse(w.Warning.cant_stratify.is_shown())
def setUpClass(cls):
cls.learn = MeanLearner()
def test_discrete(self):
iris = Table('iris')
learn = MeanLearner()
self.assertRaises(ValueError, learn, iris)
def test_empty(self):
autompg = Table('auto-mpg')
learn = MeanLearner()
clf = learn(autompg[:0])
y = clf(autompg[0])
self.assertEqual(y, 0)
