def test_predict_table(self):
forest = RandomForestLearner()
c = forest(self.iris)
c(self.iris)
vals, probs = c(self.iris, c.ValueProbs)
def test_predict_numpy(self):
forest = RandomForestLearner()
c = forest(self.iris)
c(self.iris.X)
vals, probs = c(self.iris.X, c.ValueProbs)
def test_RandomForest(self):
forest = RandomForestLearner()
results = CrossValidation(self.iris, [forest], k=10)
ca = CA(results)
self.assertGreater(ca, 0.9)
self.assertLess(ca, 0.99)
def test_predict_single_instance(self):
forest = RandomForestLearner()
c = forest(self.iris)
for ins in self.iris:
c(ins)
val, prob = c(ins, c.ValueProbs)
def test_unique_output_domain(self):
data = possible_duplicate_table('random forest')
self.send_signal(self.widget.Inputs.train_data, data)
self.send_signal(self.widget.Inputs.learner, RandomForestLearner(), 0)
output = self.get_output(self.widget.Outputs.predictions)
self.assertEqual(output.domain.metas[0].name, 'random forest (1)')
self.Outputs.scores.send(scores)
def send_report(self):
if not self.data or not self.background_data or not self.model:
return
items = {"Target class": "None"}
if self.model.domain.has_discrete_class:
class_var = self.model.domain.class_var
items["Target class"] = class_var.values[self.target_index]
self.report_items(items)
self.report_plot()
def set_visual_settings(self, key: Tuple[str, str, str], value: Any):
self.visual_settings[key] = value
self.graph.parameter_setter.set_parameter(key, value)
if __name__ == "__main__":
from Orange.classification import RandomForestLearner
from Orange.regression import RandomForestRegressionLearner
table = Table("housing")
kwargs = {"n_estimators": 10, "random_state": 0}
if table.domain.has_continuous_class:
model_ = RandomForestRegressionLearner(**kwargs)(table)
else:
model_ = RandomForestLearner(**kwargs)(table)
WidgetPreview(OWExplainPredictions).run(
set_background_data=table, set_data=table[:50], set_model=model_
)
def test_predict_numpy(self):
table = Table('iris')
forest = RandomForestLearner()
c = forest(table)
c(table.X)
vals, probs = c(table.X, c.ValueProbs)
headerState = headerState[0]
if isinstance(headerState, bytes):
hview = QHeaderView(Qt.Horizontal)
hview.restoreState(headerState)
column, order = hview.sortIndicatorSection() - 1, hview.sortIndicatorOrder()
settings["sorting"] = (column, order)
@classmethod
def migrate_context(cls, context, version):
if version is None or version < 3:
# Selections were stored as indices, so these contexts matched
# any domain. The only safe thing to do is to remove them.
raise IncompatibleContext
if __name__ == "__main__": # pragma: no cover
from Orange.classification import RandomForestLearner
previewer = WidgetPreview(OWRank)
previewer.run(Table("heart_disease.tab"), no_exit=True)
previewer.send_signals(
set_learner=(RandomForestLearner(), (3, 'Learner', None)))
previewer.run()
# pylint: disable=pointless-string-statement
"""
WidgetPreview(OWRank).run(
set_learner=(RandomForestLearner(), (3, 'Learner', None)),
set_data=Table("heart_disease.tab"))
"""
def test_check_model_cls_true(self):
data = self.heart
model = RandomForestLearner(random_state=0)(data)
self.assertTrue(_check_model(model, data))
def test_check_model_cls_false(self):
data = self.iris
model = RandomForestLearner(random_state=0)(data)
self.assertFalse(_check_model(model, data))
def test_inadequate_model(self):
model = RandomForestLearner()(self.iris)
args = model, self.housing, self.n_repeats
self.assertRaises(ValueError, permutation_feature_importance, *args)
def test_inadequate_data(self):
model = RandomForestLearner()(self.iris)
args = model, self.titanic, self.n_repeats
self.assertRaises(DomainTransformationError,
permutation_feature_importance, *args)
def test_auc_missing_values(self):
data = self.heart
model = RandomForestLearner(random_state=0)(data)
res = permutation_feature_importance(model, data, AUC(),
self.n_repeats)
self.assertAlmostEqual(res[0].mean(), 0.013, 3)
from Orange.data import Domain, Table
from Orange.classification import LogisticRegressionLearner
from Orange.classification import NaiveBayesLearner
from Orange.classification import TreeLearner
from Orange.classification import RandomForestLearner
from Orange.classification import KNNLearner
from Orange.classification import SVMLearner
### create models ###
models = [
LogisticRegressionLearner(),
NaiveBayesLearner(),
TreeLearner(),
RandomForestLearner(),
KNNLearner(),
SVMLearner(),
]
### read train data ###
train = Table.from_file('train.csv')
# move `sex` from X to Y (from attributes/features to class_var/target)
domain = Domain(train.domain.attributes[1:], train.domain.attributes[0])
train = train.transform(domain)
print('\n=== train.X ===')
print(train.X)
print('\n=== train.Y ===')
print(train.Y)
self.shutdown()
super().onDeleteWidget()
def sizeHint(self) -> QSizeF:
sh = self.controlArea.sizeHint()
return sh.expandedTo(QSize(700, 700))
def send_report(self):
if not self.data or not self.background_data or not self.model:
return
items = {"Target class": "None"}
if self.model.domain.has_discrete_class:
class_var = self.model.domain.class_var
items["Target class"] = class_var.values[self.target_index]
self.report_items(items)
self.report_plot()
if __name__ == "__main__": # pragma: no cover
from Orange.classification import RandomForestLearner
from Orange.regression import RandomForestRegressionLearner
table = Table("heart_disease")
if table.domain.has_continuous_class:
rf_model = RandomForestRegressionLearner(random_state=42)(table)
else:
rf_model = RandomForestLearner(random_state=42)(table)
WidgetPreview(OWExplainPrediction).run(set_background_data=table,
set_data=table[:1],
set_model=rf_model)
def test_init_learner(self):
"""
Test init
"""
w = self.widget
learner = TreeLearner()
# check if empty
self.assertTrue(isinstance(w.learner, LogisticRegressionLearner))
self.assertTrue(isinstance(w.learner, w.LEARNER))
self.assertTrue(
reduce(lambda x, y: x or isinstance(y, w.default_preprocessor),
w.learner.preprocessors, False))
self.send_signal(w.Inputs.learner, learner)
# check if learners set correctly
self.assertEqual(type(w.learner), type(learner))
# after learner is removed there should be LEARNER used
self.send_signal(w.Inputs.learner, None)
self.assertTrue(isinstance(w.learner, LogisticRegressionLearner))
self.assertTrue(isinstance(w.learner, w.LEARNER))
self.assertTrue(
reduce(lambda x, y: x or isinstance(y, w.default_preprocessor),
w.learner.preprocessors, False))
# set it again just in case something goes wrong
learner = RandomForestLearner()
self.send_signal(w.Inputs.learner, learner)
self.assertEqual(type(w.learner), type(learner))
self.assertTrue(
reduce(lambda x, y: x or isinstance(y, w.default_preprocessor),
w.learner.preprocessors, False))
# change learner this time not from None
learner = TreeLearner()
self.send_signal(w.Inputs.learner, learner)
self.assertEqual(type(w.learner), type(learner))
self.assertTrue(
reduce(lambda x, y: x or isinstance(y, w.default_preprocessor),
w.learner.preprocessors, False))
# set other preprocessor
preprocessor = Discretize
# selected this preprocessor because know that not exist in LogReg
self.send_signal(w.Inputs.preprocessor, preprocessor())
self.assertEqual(type(w.learner), type(learner))
self.assertTrue(
reduce(lambda x, y: x or isinstance(y, w.default_preprocessor),
w.learner.preprocessors, False))
self.assertTrue(
reduce(lambda x, y: x or isinstance(y, preprocessor),
w.learner.preprocessors, False))
# remove preprocessor
self.send_signal(w.Inputs.preprocessor, None)
self.assertEqual(type(w.learner), type(learner))
self.assertTrue(
reduce(lambda x, y: x or isinstance(y, w.default_preprocessor),
w.learner.preprocessors, False))
self.assertFalse(
reduce(lambda x, y: x or isinstance(y, preprocessor),
w.learner.preprocessors, False))
if isinstance(headerState, bytes):
hview = QHeaderView(Qt.Horizontal)
hview.restoreState(headerState)
column, order = (
hview.sortIndicatorSection() - 1,
hview.sortIndicatorOrder(),
)
settings["sorting"] = (column, order)
@classmethod
def migrate_context(cls, context, version):
if version is None or version < 2:
# Old selection was saved as sorted indices. New selection is original indices.
# Since we can't devise the latter without first computing the ranks,
# just reset the selection to avoid confusion.
context.values["selected_rows"] = []
if __name__ == "__main__":
from AnyQt.QtWidgets import QApplication
from Orange.classification import RandomForestLearner
a = QApplication([])
ow = OWRank()
ow.set_learner(RandomForestLearner(), (3, "Learner", None))
ow.setData(Table("heart_disease.tab"))
ow.show()
a.exec_()
ow.saveSettings()
def init_learner(learner: Type[Learner], table: Table) -> Learner:
if learner in (CalibratedLearner, ThresholdLearner):
return CalibratedLearner(RandomForestLearner())
return init_reg_learner(learner, table)
return (np.arange(shap_values.shape[0]), pos_data, neg_data, pos_labels,
neg_labels)
if __name__ == "__main__":
import matplotlib.pyplot as plt
from Orange.classification import RandomForestLearner
from Orange.regression import RandomForestRegressionLearner
table = Table("housing")
if table.domain.has_continuous_class:
model_ = RandomForestRegressionLearner(n_estimators=10,
random_state=0)(table)
else:
model_ = RandomForestLearner(n_estimators=10, random_state=0)(table)
shap_values_, transformed_, _, base_value_ = \
compute_shap_values(model_, table[:50], table)
idxs = get_instance_ordering(shap_values_[0], None, transformed_,
SIMILARITY_ORDER)
x_data_, pos_data_, neg_data_, pos_labels_, neg_labels_ = \
prepare_force_plot_data_multi_inst(
shap_values_[0][idxs], base_value_[0], transformed_.domain
)
for y1, y2 in pos_data_:
color = tuple(np.array(RGB_HIGH) / 255)
light_color = tuple(
if isinstance(headerState, bytes):
hview = QHeaderView(Qt.Horizontal)
hview.restoreState(headerState)
column, order = hview.sortIndicatorSection(
) - 1, hview.sortIndicatorOrder()
settings["sorting"] = (column, order)
@classmethod
def migrate_context(cls, context, version):
if version is None or version < 3:
# Selections were stored as indices, so these contexts matched
# any domain. The only safe thing to do is to remove them.
raise IncompatibleContext
if __name__ == "__main__": # pragma: no cover
from Orange.classification import RandomForestLearner
previewer = WidgetPreview(OWRank)
previewer.run(Table("heart_disease.tab"), no_exit=True)
previewer.send_signals(set_learner=(RandomForestLearner(), (3, 'Learner',
None)))
previewer.run()
# pylint: disable=pointless-string-statement
"""
WidgetPreview(OWRank).run(
set_learner=(RandomForestLearner(), (3, 'Learner', None)),
set_data=Table("heart_disease.tab"))
"""
def test_predict_table(self):
table = Orange.data.Table('iris')
forest = RandomForestLearner()
c = forest(table)
c(table)
vals, probs = c(table, c.ValueProbs)
