def test_decorator(self):
decorator = DistancePerformanceDecorator(accumulated=False)
algorithm = IncrementalDistanceAlgorithm()
algorithm.prototypes = [simple_prototype()]
decorator.wrap_algorithm(algorithm)
self.assertIsNone(decorator.data())
decorator.start_tree()
self.assertEqual(decorator.descriptive_data(),
{"distance_performance": [[]]})
decorator.finish_tree()
self.assertEqual(decorator.descriptive_data(),
{"distance_performance": [[]]})
decorator.wrap_algorithm(algorithm)
decorator.start_tree()
for event in Event.from_tree(simple_monitoring_tree(),
supported={ProcessStartEvent: True}):
decorator.add_event(event)
decorator.finish_tree()
description = decorator.descriptive_data()
self.assertEqual(len(description["distance_performance"][0]), 4)
decorator.start_tree()
for event in Event.from_tree(simple_monitoring_tree(),
supported={ProcessStartEvent: True}):
decorator.add_event(event)
decorator.finish_tree()
description = decorator.descriptive_data()
self.assertEqual(len(description["distance_performance"]), 2)
self.assertEqual(len(description["distance_performance"][1]), 4)
def test_ensemble_with_prototypes(self):
decorator = AnomalyDecorator()
algorithm = IncrementalDistanceAlgorithm(
signature=EnsembleSignature(
signatures=[ParentChildByNameTopologySignature(),
ParentChildOrderByNameTopologySignature()]))
algorithm.prototypes = [simple_prototype(), simple_monitoring_tree()]
decorator.wrap_algorithm(algorithm)
algorithm.start_tree()
for event in Event.from_tree(simple_monitoring_tree(), supported={ProcessStartEvent: True}):
algorithm.add_event(event)
algorithm.finish_tree()
self.assertEqual(decorator.data(), [
[
[
[False, False, False, False, False],
[False, False, False, False, False]
],
[
[False, False, False, False, True],
[False, False, False, False, False]
]
]
])
def test_normalized_results(self):
decorator = DistanceDecorator(normalized=True)
algorithm = IncrementalDistanceAlgorithm(
signature=EnsembleSignature(
signatures=[ParentChildByNameTopologySignature(),
ParentChildOrderByNameTopologySignature()])
)
algorithm.prototypes = [simple_prototype(), simple_monitoring_tree()]
decorator.wrap_algorithm(algorithm)
algorithm.start_tree()
self.assertEqual([[[[], []], [[], []]]], decorator.data())
for event in Event.from_tree(simple_monitoring_tree(), supported={ProcessStartEvent: True}):
algorithm.add_event(event)
algorithm.finish_tree()
self.assertEqual([[
[ # ParentChildByNameTopologySignature
[2 / 3, 1 / 3, 1 / 3, 0.0], # simple_prototype
[2 / 3, 1 / 3, 1 / 3, 0.0] # simple_monitoring_tree
],
[ # ParentChildOrderByNameTopologySignature
[4 / 5, 3 / 5, 3 / 5, 2 / 5],
[2 / 3, 1 / 3, 1 / 3, 0.0]
]]], decorator.data())
def test_accumulated_decorator(self):
decorator = SignaturePerformanceDecorator()
algorithm = IncrementalDistanceAlgorithm()
algorithm.prototypes = [simple_prototype()]
decorator.wrap_algorithm(algorithm)
decorator.start_tree()
self.assertEqual(decorator.descriptive_data(),
{'accumulated_signature_performance': [[None]]})
decorator.finish_tree()
self.assertEqual(decorator.descriptive_data(),
{'accumulated_signature_performance': [[None]]})
decorator.wrap_algorithm(algorithm)
decorator.start_tree()
for event in Event.from_tree(simple_monitoring_tree(),
supported={ProcessStartEvent: True}):
decorator.add_event(event)
decorator.finish_tree()
description = decorator.descriptive_data()
self.assertEqual(
type(description["accumulated_signature_performance"][0][0]),
float)
decorator.start_tree()
for event in Event.from_tree(simple_monitoring_tree(),
supported={ProcessStartEvent: True}):
decorator.add_event(event)
decorator.finish_tree()
description = decorator.descriptive_data()
print(description)
self.assertEqual(len(description["accumulated_signature_performance"]),
2)
self.assertEqual(
type(description["accumulated_signature_performance"][1][0]),
float)
def test_signatures(self):
decorator = SignatureDecorator()
algorithm = IncrementalDistanceAlgorithm(
signature=ParentChildByNameTopologySignature())
algorithm.prototypes = [simple_prototype()]
decorator.wrap_algorithm(algorithm)
decorator.start_tree()
self.assertEqual(decorator.descriptive_data(), {"signature": [[[]]]})
decorator.finish_tree()
self.assertEqual(decorator.descriptive_data(), {"signature": [[[]]]})
decorator.wrap_algorithm(algorithm)
decorator.start_tree()
for event in Event.from_tree(simple_monitoring_tree(),
supported={ProcessStartEvent: True}):
decorator.add_event(event)
decorator.finish_tree()
description = decorator.descriptive_data()
self.assertEqual(len(description["signature"]), 1)
self.assertEqual(len(set(description["signature"][0][0])), 3)
self.assertEqual(len(description["signature"][0][0]), 4)
self.assertEqual(description["signature"][0][0][0], "root_1")
self.assertEqual(description["signature"][0][0][1], "test_149160533")
self.assertEqual(description["signature"][0][0][3], "muh_149160533")
decorator.start_tree()
for event in Event.from_tree(simple_monitoring_tree(),
supported={ProcessStartEvent: True}):
decorator.add_event(event)
decorator.finish_tree()
description = decorator.descriptive_data()
self.assertEqual(len(description["signature"]), 2)
def test_simple(self):
decorator = AnomalyDecorator()
algorithm = IncrementalDistanceAlgorithm()
algorithm.prototypes = [simple_prototype()]
decorator.wrap_algorithm(algorithm)
algorithm.start_tree()
for event in Event.from_tree(simple_monitoring_tree(), supported={ProcessStartEvent: True}):
algorithm.add_event(event)
algorithm.finish_tree()
self.assertEqual(decorator.data(), [
[
[
[False, False, False, False, False]
]
]
])
algorithm.start_tree()
for event in Event.from_tree(simple_monitoring_tree(), supported={ProcessStartEvent: True}):
algorithm.add_event(event)
algorithm.finish_tree()
self.assertEqual(decorator.data(), [
[
[
[False, False, False, False, False]
]
],
[
[
[False, False, False, False, False]
]
]
])
def test_simple_signature(self):
signature = EnsembleSignature(signatures=[ParentChildByNameTopologySignature()])
self.assertEqual(1, signature.count)
for node in simple_monitoring_tree().nodes():
signature.prepare_signature(node, parent=node.parent())
for node in simple_monitoring_tree().nodes():
token = signature.get_signature(node, parent=node.parent())
self.assertIsNotNone(token)
self.assertEqual(1, len(token))
def test_ensemble_signature(self):
decorator = SignatureDecorator()
algorithm = IncrementalDistanceAlgorithm(signature=EnsembleSignature(
signatures=[
ParentChildByNameTopologySignature(),
ParentChildOrderByNameTopologySignature()
]))
algorithm.prototypes = [simple_prototype(), simple_monitoring_tree()]
decorator.wrap_algorithm(algorithm)
algorithm.start_tree()
for event in Event.from_tree(simple_monitoring_tree(),
supported={ProcessStartEvent: True}):
algorithm.add_event(event)
algorithm.finish_tree()
self.assertEqual(
decorator.descriptive_data(), {
'signature': [[[
'root_1', 'test_149160533', 'test_149160533',
'muh_149160533'
],
[
'.0_root_1', '.0.0_test_245236498',
'.0.0_test_245236498', '.0.1_muh_245236498'
]]]
})
algorithm.start_tree()
for event in Event.from_tree(simple_prototype(),
supported={ProcessStartEvent: True}):
algorithm.add_event(event)
algorithm.finish_tree()
self.assertEqual(
decorator.descriptive_data(), {
'signature':
[[[
'root_1', 'test_149160533', 'test_149160533',
'muh_149160533'
],
[
'.0_root_1', '.0.0_test_245236498',
'.0.0_test_245236498', '.0.1_muh_245236498'
]],
[[
'root_1', 'test_149160533', 'muh_149160533',
'test_149160533', 'muh_149160533'
],
[
'.0_root_1', '.0.0_test_245236498', '.0.1_muh_245236498',
'.0.2_test_245236498', '.0.3_muh_245236498'
]]]
})
def test_two_prototypes(self):
decorator = DistanceDecorator(normalized=False)
algorithm = IncrementalDistanceAlgorithm()
algorithm.prototypes = [simple_prototype(), simple_monitoring_tree()]
decorator.wrap_algorithm(algorithm)
algorithm.start_tree()
self.assertEqual([[[[], []]]], decorator.data())
for event in Event.from_tree(simple_monitoring_tree(), supported={ProcessStartEvent: True}):
algorithm.add_event(event)
algorithm.finish_tree()
self.assertEqual([[[[2, 1, 1, 0], [2, 1, 1, 0]]]], decorator.data())
def test_simple_prototype_cache(self):
signature = EnsembleSignature(
signatures=[ParentChildByNameTopologySignature()])
cache = signature.prototype_signature_cache_class(
supported={ProcessExitEvent: True})
tree = simple_unique_node_tree()
for node in tree.nodes():
tokens = signature.get_signature(node, parent=node.parent())
if not cache.node_count():
# nothing added yet
self.assertEqual([], cache.get(signature=tokens))
else:
self.assertTrue(
isinstance(cache.get(signature=tokens)[0], dict))
cache[tokens, tree, ProcessExitEvent] = {"value": 1}
stats = cache.get_statistics(signature=tokens,
prototype=tree,
key="value",
event_type=ProcessExitEvent)
self.assertTrue(stats[0].count() >= 1)
self.assertEqual([4], cache.node_count())
self.assertEqual([4], cache.multiplicity())
signature = EnsembleSignature(
signatures=[ParentChildByNameTopologySignature()])
cache = signature.signature_cache_class()
for node in simple_monitoring_tree().nodes():
cache[signature.get_signature(node, parent=node.parent()),
ProcessStartEvent] = {
"value": 0
}
self.assertEqual([3], cache.node_count())
self.assertEqual([4], cache.multiplicity())
def test_simple_cache(self):
signature = EnsembleSignature(
signatures=[ParentChildByNameTopologySignature()])
cache = signature.signature_cache_class()
for node in simple_unique_node_tree().nodes():
tokens = signature.get_signature(node, parent=node.parent())
if not cache.node_count():
# nothing added yet
self.assertEqual([], cache.multiplicity(signature=tokens))
else:
self.assertEqual([0], cache.multiplicity(signature=tokens))
cache[tokens, ProcessStartEvent] = {"value": 0}
self.assertEqual([1], cache.multiplicity(signature=tokens))
self.assertEqual([4], cache.node_count())
self.assertEqual([4], cache.multiplicity())
signature = EnsembleSignature(
signatures=[ParentChildByNameTopologySignature()])
cache = signature.signature_cache_class()
for node in simple_monitoring_tree().nodes():
cache[signature.get_signature(node, parent=node.parent()),
ProcessStartEvent] = {
"value": 0
}
self.assertEqual([3], cache.node_count())
self.assertEqual([4], cache.multiplicity())
def test_ensemble(self):
def distance(**kwargs):
distance = StartExitDistance(weight=.5, **kwargs)
distance.supported[TrafficEvent] = False
return distance
signature = EnsembleSignature(
signatures=[
ParentChildByNameTopologySignature(), ParentSiblingSignature(width=2)])
algorithm = IncrementalDistanceAlgorithm(
signature=signature,
distance=distance,
cache_statistics=SetStatistics
)
decorator = DistanceMatrixDecorator(normalized=True)
decorator.wrap_algorithm(algorithm)
algorithm.prototypes = [simple_prototype()]
algorithm.start_tree()
for event in simple_monitoring_tree().event_iter(supported=algorithm.supported):
try:
algorithm.add_event(event)
except EventNotSupportedException:
pass
algorithm.finish_tree()
print(decorator.data())
self.assertTrue(False)
def test_two_prototypes_and_ensemble(self):
decorator = DistanceDecorator(normalized=False)
algorithm = IncrementalDistanceAlgorithm(
signature=EnsembleSignature(
signatures=[ParentChildByNameTopologySignature(),
ParentChildOrderByNameTopologySignature()]))
algorithm.prototypes = [simple_prototype(), simple_monitoring_tree()]
decorator.wrap_algorithm(algorithm)
algorithm.start_tree()
self.assertEqual([[[[], []], [[], []]]], decorator.data())
for event in Event.from_tree(simple_monitoring_tree(), supported={ProcessStartEvent: True}):
algorithm.add_event(event)
algorithm.finish_tree()
self.assertEqual(
[[[[2, 1, 1, 0], [2, 1, 1, 0]], [[4, 3, 3, 2], [2, 1, 1, 0]]]],
decorator.data()
)
def test_mean(self):
distance = ClusterDistance(distance=StartExitDistance())
prototype_one = simple_prototype()
prototype_two = simple_monitoring_tree()
signature = ParentChildByNameTopologySignature()
mean_prototype = distance.mean([
prototype_one.to_index(signature),
prototype_two.to_index(signature)
])
self.assertEqual(3, mean_prototype.node_count())
def test_two_ensembles_different_frequency(self):
signature = EnsembleSignature(signatures=[
ParentChildByNameTopologySignature(),
ParentChildOrderTopologySignature()
])
cache = signature.signature_cache_class()
for node in simple_monitoring_tree().nodes():
cache[signature.get_signature(node, parent=node.parent()),
ProcessStartEvent] = {
"value": 0
}
self.assertEqual([3, 4], cache.node_count())
self.assertEqual([4, 4], cache.multiplicity())
def test_empty_nodes(self):
signature = EnsembleSignature(
signatures=[ParentChildByNameTopologySignature(),
ParentCountedChildrenByNameTopologySignature(count=3)])
algorithm = IncrementalDistanceAlgorithm(signature=signature)
algorithm.prototypes = [simple_prototype()]
algorithm.start_tree()
for event in simple_monitoring_tree().event_iter(supported=algorithm.supported):
try:
distance = algorithm.add_event(event)
except EventNotSupportedException:
pass
algorithm.finish_tree()
self.assertEqual([[0], [7]], distance[-1])
def test_two_prototype_ensembles_different_frequency(self):
signature = EnsembleSignature(signatures=[
ParentChildByNameTopologySignature(),
ParentChildOrderTopologySignature()
])
cache = signature.prototype_signature_cache_class(
supported={ProcessExitEvent: True})
prototype = simple_monitoring_tree()
for node in prototype.nodes():
cache[signature.get_signature(node, parent=node.parent()),
prototype, ProcessExitEvent] = {
"value": 1
}
self.assertEqual([3, 4], cache.node_count())
self.assertEqual([4, 4], cache.multiplicity())
def test_compression_with_events(self):
decorator = CompressionFactorDecorator()
algorithm = IncrementalDistanceAlgorithm()
algorithm.prototypes = [simple_prototype(), simple_prototype()]
decorator.wrap_algorithm(algorithm)
decorator.start_tree()
for event in Event.from_tree(simple_monitoring_tree(),
supported={ProcessStartEvent: True}):
decorator.add_event(event)
decorator.finish_tree()
self.assertEqual(
decorator.descriptive_data(), {
"compression": {
"prototypes": [[.4, .4]],
"monitoring": [[.25]],
"accumulated": [.7]
}
})
def test_simple(self):
algorithm = IncrementalDistanceAlgorithm(
signature=ParentChildByNameTopologySignature(),
distance=StartDistance)
algorithm.prototypes = [simple_prototype()]
distance = algorithm.distance
distance.init_distance(
prototypes=algorithm.prototypes,
signature_prototypes=algorithm.signature_prototypes)
last_index = 0
for index, dist in enumerate(
distance.iter_on_prototypes(algorithm.prototypes)):
self.assertEqual(dist, [5])
last_index = index
self.assertEqual(last_index, 0)
self.assertTrue(distance.is_prototype_based_on_original())
for node in simple_monitoring_tree().nodes():
node_signature = algorithm.signature.get_signature(
node, node.parent())
matching_prototypes = algorithm.signature_prototypes.get(
signature=node_signature)
distance.update_distance(
prototypes=algorithm.prototypes,
signature_prototypes=algorithm.signature_prototypes,
matches=[{
token: matching_prototypes[index]
} for index, token in enumerate(node_signature)],
value=float(node.exit_tme) - float(node.tme),
)
for result in distance._monitoring_results_dict:
self.assertEqual(result[algorithm.prototypes[0]], 1)
result = distance._monitoring_results_dict
distance.finish_distance(
prototypes=algorithm.prototypes,
signature_prototypes=algorithm.signature_prototypes)
self.assertEqual(result, distance._monitoring_results_dict)
def test_distance(self):
distance = ClusterDistance(distance=StartExitDistance())
signature = EnsembleSignature(
signatures=[ParentChildByNameTopologySignature()])
cache_one = EnsembleSignatureCache(
supported=distance.distance.supported)
cache_one = simple_prototype().to_index(signature,
supported={
ProcessStartEvent: True,
ProcessExitEvent: True
},
cache=cache_one)
cache_two = EnsembleSignatureCache(
supported=distance.distance.supported)
cache_two = simple_monitoring_tree().to_index(signature,
supported={
ProcessStartEvent:
True,
ProcessExitEvent:
True
},
cache=cache_two)
self.assertAlmostEqual(0.11, distance(cache_one, cache_two), 2)
def test_ensemble_distance(self):
distance = ClusterDistance(distance=StartExitDistance(
signature_count=2))
signature = EnsembleSignature(signatures=[
ParentSiblingSignature(width=2),
ParentChildByNameTopologySignature()
])
# first cache
cache_one = EnsembleSignatureCache(
supported=distance.distance.supported)
cache_one = simple_prototype().to_index(signature=signature,
cache=cache_one)
# second cache
cache_two = EnsembleSignatureCache(
supported=distance.distance.supported)
cache_two = simple_monitoring_tree().to_index(signature=signature,
cache=cache_two)
# third cache
cache_three = EnsembleSignatureCache(
supported=distance.distance.supported)
cache_three = simple_prototype().to_index(signature=signature,
cache=cache_three)
print(distance([cache_one, cache_two], cache_three))
def test_decorator(self):
decorator = DataDecorator()
algorithm = IncrementalDistanceAlgorithm()
algorithm.prototypes = [simple_prototype()]
decorator.wrap_algorithm(algorithm)
decorator.start_tree()
self.assertEqual(
decorator.descriptive_data(), {
"data": {
"prototypes": {
"original": [[5]],
"converted": [[3]]
},
"monitoring": {}
}
})
decorator.finish_tree()
self.assertEqual(
decorator.descriptive_data(), {
"data": {
"prototypes": {
"original": [[5]],
"converted": [[3]]
},
"monitoring": {
"original": [[0]],
"converted": [[0]]
}
}
})
algorithm.prototypes = [simple_prototype(), simple_prototype()]
decorator.wrap_algorithm(algorithm)
decorator.start_tree()
for event in Event.from_tree(simple_monitoring_tree(),
supported={ProcessStartEvent: True}):
decorator.add_event(event)
decorator.finish_tree()
self.assertEqual(
decorator.descriptive_data(),
{
"data": {
"prototypes": {
# FIXME: hier bin ich mir nicht sicher, ob dass das sagt,
# was ich gern hätte...
"original": [[5, 5]],
"converted": [[3, 3]]
},
"monitoring": {
"original": [[4]],
"converted": [[3]]
}
}
})
decorator.start_tree()
for event in Event.from_tree(simple_monitoring_tree(),
supported={ProcessStartEvent: True}):
decorator.add_event(event)
decorator.finish_tree()
self.assertEqual(
decorator.descriptive_data(),
{
"data": {
"prototypes": {
"original": [[5, 5]], # FIXME: please check!
"converted": [[3, 3]]
},
"monitoring": {
"original": [[4], [4]],
"converted": [[3], [3]]
}
}
})
def test_format_tree_node_counts(self):
algorithm = TreeDistanceAlgorithm()
algorithm.prototypes = [simple_prototype()]
self.assertEqual(algorithm.tree_node_counts(signature=False), [])
algorithm._tree = simple_monitoring_tree()
self.assertEqual(algorithm.tree_node_counts(signature=False), [4])
