def test_ensemble_result(self): """ I recognised that apparently sometimes (or ever?) values of ensemble methods don't match results from single calculations. Therefore this test should uniquely test for this. """ tree = real_tree() tree_generator = TEDGenerator( operation_generator=RandomOperation( insert_probability=.5, delete_probability=.5), costs=[TreeEditDistanceCost()], seed=1234) disturbed_tree = tree_generator.generate(tree) signatures = [ParentChildByNameTopologySignature(), ParentCountedChildrenByNameTopologySignature(count=2)] # First test results from ensemble ensemble_signature = EnsembleSignature(signatures=signatures) decorator = DistanceMatrixDecorator(normalized=False) algorithm = IncrementalDistanceAlgorithm( signature=ensemble_signature, distance=StartDistance ) decorator.wrap_algorithm(algorithm) algorithm.prototypes = [tree] algorithm.start_tree() for event in disturbed_tree.event_iter(supported=algorithm.supported): try: algorithm.add_event(event) except EventNotSupportedException: pass algorithm.finish_tree() ensemble_data = decorator.data() # Second, validate this result with single measurements single_data = {} for index, signature in enumerate(signatures): decorator = DistanceMatrixDecorator(normalized=False) algorithm = IncrementalDistanceAlgorithm( signature=signature, distance=StartDistance ) decorator.wrap_algorithm(algorithm) algorithm.prototypes = [real_tree()] algorithm.start_tree() for event in disturbed_tree.event_iter(supported=algorithm.supported): try: algorithm.add_event(event) except EventNotSupportedException: pass algorithm.finish_tree() single_data[index] = decorator.data() for index, _ in enumerate(signatures): self.assertEqual(ensemble_data[0][index][0], single_data[index][0][0][0])
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_parameter_distance(self): prototype = Prototype() root = prototype.add_node("root", tme=0, exit_tme=0, pid=1, ppid=0, param=1) for i in range(5): root.add_node("child_%d" % i, tme=0, exit_tme=0, pid=i + 2, ppid=1, param=1) next(root.children()).add_node("child", tme=0, exit_tme=0, pid=8, ppid=2, param=1) tree = Prototype() root = tree.add_node("root", tme=0, exit_tme=0, pid=1, ppid=0, param=1) for i in range(5): root.add_node("child_%d" % i, tme=0, exit_tme=0, pid=i + 2, ppid=1, param=4) next(root.children()).add_node("child", tme=0, exit_tme=0, pid=8, ppid=2, param=4) for weight, result in [(1, 0), (.5, 6), (0, 12)]: def distance(**kwargs): distance = StartExitDistance(weight=weight, **kwargs) distance.supported = { ProcessStartEvent: True, ProcessExitEvent: True, ParameterEvent: True } return distance signature = EnsembleSignature(signatures=[ParentChildByNameTopologySignature()]) algorithm = IncrementalDistanceAlgorithm( signature=signature, distance=distance, cache_statistics=SetStatistics ) decorator = DistanceMatrixDecorator(normalized=False) decorator.wrap_algorithm(algorithm) algorithm.prototypes = [prototype] algorithm.start_tree() algorithm.add_events(tree.event_iter(supported=algorithm.supported)) algorithm.finish_tree() self.assertEqual(result, decorator.data()[0][0][0])
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_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_same_attributes_different_count(self): tree_1 = Prototype() root = tree_1.add_node("root", pid=1, ppid=0, tme=0, exit_tme=0) for _ in range(5): root.add_node("node", pid=2, ppid=1, tme=0, exit_tme=0) tree_2 = Prototype() root = tree_2.add_node("root", pid=1, ppid=0, tme=0, exit_tme=0) for _ in range(35): root.add_node("node", pid=2, ppid=1, tme=0, exit_tme=0) signature = ParentChildByNameTopologySignature() algorithm = IncrementalDistanceAlgorithm( signature=signature, distance=lambda **kwargs: StartExitDistance(weight=0, **kwargs), cache_statistics=SplittedStatistics) algorithm.prototypes = [tree_1, tree_2] decorator = DistanceMatrixDecorator(normalized=False) decorator.wrap_algorithm(algorithm) algorithm.start_tree() for event in tree_1.event_iter(supported=algorithm.supported): try: algorithm.add_event(event) except EventNotSupportedException: pass algorithm.finish_tree() algorithm.start_tree() for event in tree_2.event_iter(supported=algorithm.supported): try: algorithm.add_event(event) except EventNotSupportedException: pass algorithm.finish_tree() data = decorator.data() self.assertEqual(data[0][0][1], data[1][0][0])
def test_negative_values(self): def distance_builder(**kwargs): distance = SimpleDistance(**kwargs) return distance tree_one = real_tree(path="data/c01-007-102/2/1078-2-process.csv", absolute=True) tree_two = real_tree(path="data/c01-007-102/2/1165-2-process.csv", absolute=True) signature = ParentChildByNameTopologySignature() algorithm = IncrementalDistanceAlgorithm( signature=signature, distance=distance_builder, cache_statistics=SetStatistics) algorithm.prototypes = [tree_one, tree_two] decorator = DistanceMatrixDecorator(normalized=True) decorator.wrap_algorithm(algorithm) algorithm.start_tree() for event in tree_one.event_iter(supported=algorithm.supported): try: algorithm.add_event(event) except EventNotSupportedException: pass algorithm.finish_tree() algorithm.start_tree() for event in tree_two.event_iter(supported=algorithm.supported): try: algorithm.add_event(event) except EventNotSupportedException: pass algorithm.finish_tree() print(decorator.data()) self.assertTrue(False)
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_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_external(self): def distance(**kwargs): distance = StartExitDistance(weight=0, **kwargs) distance.supported[TrafficEvent] = True return distance algorithm = IncrementalDistanceAlgorithm( signature=ParentChildByNameTopologySignature(), distance=distance, cache_statistics=SplittedStatistics) decorator = DistanceMatrixDecorator(normalized=False) decorator.wrap_algorithm(algorithm) the_tree = real_tree( path="data/c01-007-102/2/1146-2-process.csv", absolute=True ) algorithm.prototypes = [the_tree] algorithm.start_tree() for event in the_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_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_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_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_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_maximum_generator_incremental_distance(self): rg = RandomGenerator(relative_matching=1) alg = IncrementalDistanceAlgorithm() alg.prototypes = [rg.prototype] decorator = DistanceDecorator(normalized=True) decorator.algorithm = alg decorator.start_tree() for event in rg: distance = decorator.add_event(event)[0] decorator.finish_tree() self.assertEqual(distance[0], [0])
def test_default_generator_incremental_distance(self): rg = RandomGenerator(seed=1234) alg = IncrementalDistanceAlgorithm() alg.prototypes = [rg.prototype] vector_decorator = DistanceDecorator() vector_decorator._algorithm = alg vector_decorator.start_tree() for event in rg: distance = vector_decorator.add_event(event)[0] vector_decorator.finish_tree() self.assertEqual(distance[0], [110])
def test_maximum_generator_newerincremental_with_signature_distance(self): rg = RandomGenerator(relative_matching=1) signature = ParentChildByNameTopologySignature() alg = IncrementalDistanceAlgorithm(signature=signature) alg.prototypes = [rg.prototype] decorator = DistanceDecorator(normalized=True) decorator.algorithm = alg decorator.start_tree() for event in rg: decorator.add_event(event) decorator.finish_tree() self.assertEqual(decorator.data()[-1][-1][-1][-1], 0)
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_count_signature_for_correct_zero_distance(self): signature = ParentCountedChildrenByNameTopologySignature(count=3) algorithm = IncrementalDistanceAlgorithm(signature=signature) decorator = DistanceMatrixDecorator(normalized=False) decorator.wrap_algorithm(algorithm) algorithm.prototypes = [real_tree()] algorithm.start_tree() for event in real_tree().event_iter(include_marker=True, supported=algorithm.supported): try: algorithm.add_event(event) except EventNotSupportedException: pass algorithm.finish_tree() print(algorithm._signature_prototypes._prototype_dict[0]._prototype_dict.keys()) self.assertEqual([[[0]]], decorator.data())
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 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_bigger_tree(self): rg = RandomGenerator(prototype_node_count=100, tree_node_count=200, relative_matching=.9, relative_repetition=.5, seed=1234) signature = ParentChildByNameTopologySignature() alg = IncrementalDistanceAlgorithm(signature=signature) alg.prototypes = [rg.prototype] decorator = DistanceDecorator(normalized=True) decorator.wrap_algorithm(alg) decorator.start_tree() for event in rg: decorator.add_event(event) decorator.finish_tree() self.assertAlmostEqual(decorator.data()[-1][-1][-1][-1], 0.185, 2)
def test_attribute_distance(self): def distance_buidler(**kwargs): distance = StartExitDistance(weight=0, **kwargs) distance.supported = { ProcessStartEvent: True, ProcessExitEvent: True, TrafficEvent: True } return distance tree_builder = CSVTreeBuilder() tree_1 = tree_builder.build( os.path.join(os.path.dirname(assess_tests.__file__), "data/c01-007-102/2/1129-2-process.csv")) tree_2 = tree_builder.build( os.path.join(os.path.dirname(assess_tests.__file__), "data/c01-007-102/2/1136-3-process.csv")) signature = ParentChildByNameTopologySignature() algorithm = IncrementalDistanceAlgorithm( signature=signature, distance=distance_buidler, cache_statistics=SplittedStatistics) algorithm.prototypes = [tree_1, tree_2] decorator = DistanceMatrixDecorator(normalized=False) decorator.wrap_algorithm(algorithm) algorithm.start_tree() for event in tree_1.event_iter(supported=algorithm.supported): try: algorithm.add_event(event) except EventNotSupportedException: pass algorithm.finish_tree() algorithm.start_tree() for event in tree_2.event_iter(supported=algorithm.supported): try: algorithm.add_event(event) except EventNotSupportedException: pass algorithm.finish_tree() data = decorator.data() print(decorator.data()) self.assertEqual(4, abs(data[0][0][1] - data[1][0][0]))
def test_symmetry_optimisation(self): tree = CSVTreeBuilder().build( os.path.join(os.path.dirname(assess_tests.__file__), "data/c01-007-102/2/1129-2-process.csv")) signature = ParentChildByNameTopologySignature() algorithm = IncrementalDistanceAlgorithm( signature=signature, distance=lambda **kwargs: StartExitDistance(weight=0, **kwargs), cache_statistics=SplittedStatistics) algorithm.prototypes = [tree] decorator = DistanceMatrixDecorator(normalized=False) decorator.wrap_algorithm(algorithm) algorithm.start_tree() for event in tree.event_iter(supported=algorithm.supported): try: algorithm.add_event(event) except EventNotSupportedException: pass algorithm.finish_tree() self.assertEqual(0, decorator.data()[0][0][0])
def test_node_count_for_correct_zero_distance(self): signature = EnsembleSignature( signatures=[ParentChildByNameTopologySignature(), ParentCountedChildrenByNameTopologySignature(count=3)]) algorithm = IncrementalDistanceAlgorithm( signature=signature, distance=SimpleDistance) data_decorator = DataDecorator() data_decorator.wrap_algorithm(algorithm) algorithm.prototypes = [real_tree()] algorithm.start_tree() for event in real_tree().event_iter(include_marker=True, supported=algorithm.supported): try: algorithm.add_event(event) except EventNotSupportedException: pass algorithm.finish_tree() self.assertEqual([tree_value for values in data_decorator.data().get( "prototypes", {}).get("converted", []) for tree_value in values], [tree_value for values in data_decorator.data().get( "monitoring", {}).get("converted", []) for tree_value in values])
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_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_attributes_nodes_only(self): def distance(**kwargs): distance = StartExitDistance(weight=1, **kwargs) distance.supported[TrafficEvent] = True return distance algorithm = IncrementalDistanceAlgorithm( signature=ParentChildByNameTopologySignature(), distance=distance, cache_statistics=SetStatistics ) decorator = DistanceMatrixDecorator(normalized=False) decorator.wrap_algorithm(algorithm) algorithm.prototypes = [real_tree("data/c01-007-102/2/1129-2-process.csv")] monitoring_tree = real_tree("data/c01-007-102/2/1129-2-process.csv") algorithm.start_tree() for event in monitoring_tree.event_iter(supported=algorithm.supported): try: algorithm.add_event(event) except EventNotSupportedException: pass algorithm.finish_tree() self.assertEqual([[[0]]], decorator.data())
def test_simple_functionality(self): decorator = CompressionFactorDecorator() algorithm = IncrementalDistanceAlgorithm() decorator.wrap_algorithm(algorithm=algorithm) decorator.start_tree() self.assertEqual( decorator.descriptive_data(), { "compression": { "prototypes": [], "monitoring": [None], "accumulated": [] } }) decorator.finish_tree() self.assertEqual( decorator.descriptive_data(), { "compression": { "prototypes": [], "monitoring": [[0]], "accumulated": [] } }) algorithm.prototypes = [simple_prototype()] decorator.algorithm = algorithm decorator.start_tree() decorator.finish_tree() self.assertEqual( decorator.descriptive_data(), { "compression": { "prototypes": [[.4]], "monitoring": [[0]], "accumulated": [.4] } }) decorator.wrap_algorithm(algorithm) self.assertEqual(decorator.descriptive_data(), {"compression": None})