def learn_from_instance(self, X, y, weight, hat, parent,
parent_branch):
true_class = y
k = np.random.poisson(1.0, self._classifierRandom)
if k > 0:
weight = weight * k
tmp = self.get_class_votes(X, hat)
class_prediction = get_max_value_key(tmp)
bl_correct = (true_class == class_prediction)
if self.estimationErrorWeight is None:
self.estimationErrorWeight = ADWIN()
old_error = self.get_error_estimation()
# Add element to Adwin
add = 0.0 if (bl_correct is True) else 1.0
self.estimationErrorWeight.add_element(add)
# Detect change with Adwin
self.ErrorChange = self.estimationErrorWeight.detected_change()
if self.ErrorChange is True and old_error > self.get_error_estimation(
):
self.ErrorChange = False
# Update statistics call LearningNodeNBAdaptive
super().learn_from_instance(X, y, weight,
hat) # CHECK changed self to super
# call ActiveLearningNode
weight_seen = self.get_weight_seen()
if weight_seen - self.get_weight_seen_at_last_split_evaluation(
) >= hat.grace_period:
hat._attempt_to_split(self, parent, parent_branch)
self.set_weight_seen_at_last_split_evaluation(weight_seen)
def test_get_max_value_key():
a_dictionary = {1: 10, 2: -10, 3: 1000, 4: 100, 5: 1}
key_max = get_max_value_key(a_dictionary)
assert key_max == 3
def learn_from_instance(self, X, y, weight, hat, parent,
parent_branch):
true_class = y
class_prediction = 0
if self.filter_instance_to_leaf(X, parent,
parent_branch).node is not None:
class_prediction = get_max_value_key(
self.filter_instance_to_leaf(
X, parent, parent_branch).node.get_class_votes(X, hat))
bl_correct = (true_class == class_prediction)
if self._estimation_error_weight is None:
self._estimation_error_weight = ADWIN()
old_error = self.get_error_estimation()
# Add element to ADWIN
add = 0.0 if (bl_correct is True) else 1.0
self._estimation_error_weight.add_element(add)
# Detect change with ADWIN
self.error_change = self._estimation_error_weight.detected_change()
if self.error_change is True and old_error > self.get_error_estimation(
):
self.error_change = False
# Check condition to build a new alternate tree
if self.error_change is True:
self._alternate_tree = hat._new_learning_node()
hat._alternateTrees += 1
# Condition to replace alternate tree
elif self._alternate_tree is not None and self._alternate_tree.is_null_error(
) is False:
if self.get_error_width() > error_width_threshold \
and self._alternate_tree.get_error_width() > error_width_threshold:
old_error_rate = self.get_error_estimation()
alt_error_rate = self._alternate_tree.get_error_estimation(
)
fDelta = .05
fN = 1.0 / self._alternate_tree.get_error_width() + 1.0 / (
self.get_error_width())
bound = math.sqrt(2.0 * old_error_rate *
(1.0 - old_error_rate) *
math.log(2.0 / fDelta) * fN)
# To check, bound never less than (old_error_rate - alt_error_rate)
if bound < (old_error_rate - alt_error_rate):
hat._active_leaf_node_cnt -= self.number_leaves()
hat._active_leaf_node_cnt += self._alternate_tree.number_leaves(
)
self.kill_tree_children(hat)
if parent is not None:
parent.set_child(parent_branch,
self._alternate_tree)
else:
hat._tree_root = hat._tree_root.alternateTree
hat._switchAlternateTrees += 1
elif bound < alt_error_rate - old_error_rate:
if isinstance(self._alternate_tree,
HAT.ActiveLearningNode):
self._alternate_tree = None
elif isinstance(self._alternate_tree,
HAT.ActiveLearningNode):
self._alternate_tree = None
else:
self._alternate_tree.kill_tree_children(hat)
hat._prunedalternateTree += 1 # hat._pruned_alternate_trees to check
# Learn_From_Instance alternate Tree and Child nodes
if self._alternate_tree is not None:
self._alternate_tree.learn_from_instance(
X, y, weight, hat, parent, parent_branch)
child_branch = self.instance_child_index(X)
child = self.get_child(child_branch)
if child is not None:
child.learn_from_instance(X, y, weight, hat, parent,
parent_branch)