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_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 __iter__(self): exit_event_queue = [] root = self._prototype.root() picking_list = root.children_list()[:] yield Event.start(tme=0, pid=1, ppid=0, name=self._prototype.root().name) exit_event_queue.append( Event.exit(tme=0, pid=1, ppid=0, start_tme=0, name=root.name)) picked = 0 for i in range(self._tree_node_count): if random.random() <= self._relative_matching: try: node = random.choice(picking_list) picking_list.remove(node) except IndexError: node = random.choice(root.children_list()) node_name = node.name pid = node.pid picked += 1 else: node_name = id_generator() pid = i + 2 yield Event.start(tme=0, pid=pid, ppid=1, name=node_name) exit_event_queue.append( Event.exit(tme=0, pid=pid, ppid=1, name=node_name, start_tme=0)) while exit_event_queue: yield exit_event_queue.pop()
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_number_of_events(self): tree = Prototype() root = tree.add_node("root", pid=1, ppid=0, tme=0, exit_tme=0, param=2) for i in range(5): root.add_node("child_%d" % i, pid=i+2, ppid=1, tme=0, exit_tme=0, param=i*2) child = next(root.children()) child.add_node("child", pid=10, ppid=child.pid, tme=0, exit_tme=0, param=5) event_count = 0 for _ in Event.from_tree(tree, supported={ ProcessStartEvent: True, ProcessExitEvent: False, ParameterEvent: False }): event_count += 1 self.assertEqual(7, event_count) event_count = 0 for _ in Event.from_tree(tree, supported={ ProcessStartEvent: True, ProcessExitEvent: True, ParameterEvent: False }): event_count += 1 self.assertEqual(14, event_count) event_count = 0 for _ in Event.from_tree(tree, supported={ ProcessStartEvent: True, ProcessExitEvent: True, ParameterEvent: True }): event_count += 1 self.assertEqual(21, event_count)
def test_creation(self): event = Event.start(0, 0, 1) self.assertEqual(type(event), ProcessStartEvent) event_2 = Event.exit(1, 0, 1, 0) self.assertEqual(type(event_2), ProcessExitEvent) self.assertEqual(event_2.start_tme, 0) event_3 = Event.add(1, 0, 1, .5) self.assertEqual(type(event_3), TrafficEvent) self.assertEqual(event_3.value, .5)
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_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_algorithm(self, prototype=None, tree=None): signature = Signature() algorithm = TreeEditDistanceAlgorithm(signature=signature) algorithm.prototypes = [prototype] algorithm.start_tree() algorithm.add_events(Event.from_tree(tree, supported={ProcessStartEvent: True})) result = algorithm.finish_tree() return result[0]
def test_simple_normalized_matrix(self): decorator = DistanceMatrixDecorator(normalized=True) algorithm = IncrementalDistanceAlgorithm() algorithm.prototypes = [simple_prototype()] decorator.wrap_algorithm(algorithm) decorator.start_tree() self.assertEqual(decorator.descriptive_data(), {"normalized_matrix": [[[None]]]}) decorator.finish_tree() self.assertEqual(decorator.descriptive_data(), {"normalized_matrix": [[[1]]]}) decorator.wrap_algorithm(algorithm) decorator.start_tree() for event in Event.from_tree(simple_prototype(), supported={ProcessStartEvent: True}): decorator.add_event(event) decorator.finish_tree() self.assertEqual(decorator.descriptive_data(), {"normalized_matrix": [[[0]]]}) algorithm.prototypes = [ simple_prototype(), simple_additional_monitoring_tree() ] decorator.wrap_algorithm(algorithm) decorator.start_tree() for event in Event.from_tree(simple_prototype(), supported={ProcessStartEvent: True}): decorator.add_event(event) decorator.finish_tree() self.assertEqual(decorator.descriptive_data(), {"normalized_matrix": [[[0, .4]]]}) decorator.start_tree() for event in Event.from_tree(simple_additional_monitoring_tree(), supported={ProcessStartEvent: True}): decorator.add_event(event) decorator.finish_tree() self.assertEqual(decorator.descriptive_data(), {"normalized_matrix": [[[0.0, .4]], [[.4, 0.0]]]}) self.assertRaises(MatrixDoesNotMatchBounds, decorator.start_tree)
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_manual_creation(self): start = ProcessStartEvent(0, 0, 0) start.pid = 2 start.ppid = 1 start.tme = 1 self.assertEqual(start, Event.start(1, 2, 1)) exit = ProcessExitEvent(0, 0, 0, 0) exit.pid = 2 exit.ppid = 1 exit.tme = 1 exit.start_tme = 0 exit.value = 1 self.assertEqual(exit, Event.exit(1, 2, 1, 0)) traffic = TrafficEvent(0, 0, 0, 0) traffic.pid = 2 traffic.ppid = 1 traffic.tme = 1 traffic.value = 5 self.assertEqual(traffic.value, 5) self.assertEqual(traffic, Event.add(1, 2, 1, 5))
def test_parameter_event_generation(self): prototype = Prototype() root = prototype.add_node("root", pid=1, ppid=0, test=2, muh=3, tme=3, exit_tme=3) events = 0 matches = 0 for event in Event.events_from_node(root, supported={ParameterEvent: True}): events += 1 if event.name == "test": self.assertEqual(2, event.value) matches += 1 if event.name == "muh": self.assertEqual(3, event.value) matches += 1 self.assertEqual(2, events) self.assertEqual(2, matches)
def test_ensemble(self): decorator = DistanceDecorator(normalized=False) algorithm = IncrementalDistanceAlgorithm( signature=EnsembleSignature( signatures=[ParentChildByNameTopologySignature(), ParentChildOrderByNameTopologySignature()])) algorithm.prototypes = [simple_prototype()] 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]], [[4, 3, 3, 2]]]], decorator.data())
def event_iter(self, include_marker=True, supported=None): exit_event_queue = deque( ) # (tme, -#events, event); leftmost popped FIRST event_count = 0 for node in self.node_iter(include_marker=include_marker): try: now = node.tme except AttributeError: # EmptyNode Event only needs to be forwarded event = EmptyProcessEvent() event.node = node yield event continue # yield any exit events that should have happened so far while exit_event_queue and exit_event_queue[0][0] < now: yield exit_event_queue.popleft()[2] existing_parameter_nodes = {} for event in Event.events_from_node(node, supported=supported): event_count += 1 if isinstance(event, ProcessStartEvent): event.node = node yield event continue elif isinstance(event, ProcessExitEvent): event.node = node else: try: current_node = existing_parameter_nodes[event.name] except KeyError: existing_parameter_nodes[event.name] = OrderedTreeNode( 1, **event.__dict__) current_node = existing_parameter_nodes[event.name] current_node._parent = node event.node = current_node if event.tme <= now: yield event continue try: bisect.insort_right(exit_event_queue, (event.tme, -event_count, event)) except AttributeError: pass while exit_event_queue: yield exit_event_queue.popleft()[2]
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_start_exit(self): signature = ParentChildByNameTopologySignature() alg = IncrementalDistanceAlgorithm(signature=signature, distance=StartExitDistance) alg.prototypes = [self._simple_prototype] alg.start_tree() alg.add_event(Event.start(tme=0, pid=2, ppid=1, name="root_node")) alg.add_event(Event.start(tme=1, pid=3, ppid=2, name="first_child")) alg.add_event(Event.start(tme=1, pid=4, ppid=2, name="second_child")) alg.add_event( Event.exit(tme=3, start_tme=1, pid=3, ppid=2, name="first_child")) alg.add_event( Event.exit(tme=4, start_tme=1, pid=4, ppid=2, name="second_child")) alg.add_event(Event.start(tme=5, pid=5, ppid=2, name="first_child")) alg.add_event( Event.exit(tme=7, start_tme=5, pid=5, ppid=2, name="first_child")) distance = alg.add_event( Event.exit(tme=10, start_tme=0, pid=2, ppid=1, name="root_node")) alg.finish_tree() self.assertEqual(distance[0][0], [0])
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]] } } })