def setUp(self): """Set up the parameters for the individual tests.""" if self.id().split('.')[-1] == 'test_checkLinkoStructure': self.testParams = [ { 'linko': linkoCreate.Linkograph([({'L0'}, set(), {1, 2}), ({'L0'}, set(), {2}), ({'L0'}, {0, 1}, set())]), 'labels': False, 'expectedResult': False, 'expectedErrors': { 1: ({0}, set()) } }, { 'linko': linkoCreate.Linkograph([({'L0'}, set(), {1, 2}), ({'L0'}, {0}, set()), ({'L0'}, {0, 1}, set())]), 'labels': False, 'expectedResult': False, 'expectedErrors': { 1: (set(), {2}) } }, { 'linko': linkoCreate.Linkograph([({'L0'}, set(), {1, 2}), ({'L0'}, {0}, {2}), ({'L0'}, {0, 1}, set())]), 'labels': False, 'expectedResult': True, 'expectedErrors': {} }, { 'linko': linkoCreate.Linkograph([({'L0'}, set(), {1, 2, 5}), ({'L0'}, {0}, {2}), ({'L0'}, {0, 1}, set())]), 'labels': False, 'expectedResult': False, 'expectedErrors': { 'missing': {5}, 5: ({0}, set()) } }, ]
def profile_bfms(): print("profiling brute force minimum similarity") lg_0_items = [ ({"Look"}, set(), {1, 6}), ({"Transfer"}, set(), {2, 7}), ({"Move"}, set(), {3, 8}), ({"Execute"}, set(), {4, 9}), ({"Cleanup"}, set(), {5}), ({"Look"}, set(), {6}), ({"Transfer"}, set(), {7}), ({"Move"}, set(), {8}), ({"Execute"}, set(), {9}), ({"Cleanup"}, set(), set()) ] lg_0 = llinkoCreate.Linkograph(lg_0_items) null_ontology = {} for maximum_changes in range(1, 4): start_datetime = datetime.datetime.now() o_prime, accuracy_prime = brute_force_minimum_similarity(lg_0, null_ontology, maximum_changes) end_datetime = datetime.datetime.now() run_datetime = end_datetime - start_datetime print(" maximum changes =", maximum_changes, "runtime:", run_datetime)
def unit_test_hifms(): print("unit testing high impact first minimum similarity") result = True perfect_ontology = { "Look": ["Transfer"], "Transfer": ["Move"], "Move": ["Execute"], "Execute": ["Cleanup"], "Cleanup": ["Look"] } lg_0_items = [ ({"Look"}, set(), {1, 6}), ({"Transfer"}, set(), {2, 7}), ({"Move"}, set(), {3, 8}), ({"Execute"}, set(), {4, 9}), ({"Cleanup"}, set(), {5}), ({"Look"}, set(), {6}), ({"Transfer"}, set(), {7}), ({"Move"}, set(), {8}), ({"Execute"}, set(), {9}), ({"Cleanup"}, set(), set()) ] lg_0 = llinkoCreate.Linkograph(lg_0_items) null_ontology = {} for maximum_changes in range(1, 6): start_datetime = datetime.datetime.now() o_prime, accuracy_prime = high_impact_first_minimum_similarity(lg_0, null_ontology, maximum_changes) end_datetime = datetime.datetime.now() run_datetime = end_datetime - start_datetime print(" maximum changes =", maximum_changes, "runtime:", run_datetime) if maximum_changes >= 5: if o_prime != perfect_ontology: print("hifms unit test 0 failed") result = False complete_ontology = { "Look": ["Look", "Transfer", "Move", "Execute", "Cleanup"], "Transfer": ["Look", "Transfer", "Move", "Execute", "Cleanup"], "Move": ["Look", "Transfer", "Move", "Execute", "Cleanup"], "Execute": ["Look", "Transfer", "Move", "Execute", "Cleanup"], "Cleanup": ["Look", "Transfer", "Move", "Execute", "Cleanup"] } for maximum_changes in range(1, 21): start_datetime = datetime.datetime.now() o_prime, accuracy_prime = high_impact_first_minimum_similarity(lg_0, complete_ontology, maximum_changes) end_datetime = datetime.datetime.now() run_datetime = end_datetime - start_datetime print(" maximum changes =", maximum_changes, "runtime:", run_datetime) if maximum_changes >= 20: if o_prime != perfect_ontology: print("hifms unit test 1 failed") result = False return result
def unit_test_threshold(): print("unit testing threshold") result = True lg_items = [({"Look"}, set(), {1, 6}), ({"Transfer"}, set(), {2, 7}), ({"Move"}, set(), {3, 8}), ({"Execute"}, set(), {4, 9}), ({"Cleanup"}, set(), {5}), ({"Look"}, set(), {6}), ({"Transfer"}, set(), {7}), ({"Move"}, set(), {8}), ({"Execute"}, set(), {9}), ({"Cleanup"}, set(), set())] lg = llinkoCreate.Linkograph(lg_items) perfect_ontology = { "Look": ["Transfer"], "Transfer": ["Move"], "Move": ["Execute"], "Execute": ["Cleanup"], "Cleanup": ["Look"] } o = threshold_lg_to_ontology(lg) if o != perfect_ontology: print("threshold unit test 0 failed") result = False return result
def unit_test_windowed_refinement(): print("unit testing windowed refinement") result = True perfect_ontology = { "Look": ["Transfer"], "Transfer": ["Move"], "Move": ["Execute"], "Execute": ["Cleanup"], "Cleanup": ["Look"] } lg_0_items = [ ({"Look"}, set(), {1, 6}), ({"Transfer"}, set(), {2, 7}), ({"Move"}, set(), {3, 8}), ({"Execute"}, set(), {4, 9}), ({"Cleanup"}, set(), {5}), ({"Look"}, set(), {6}), ({"Transfer"}, set(), {7}), ({"Move"}, set(), {8}), ({"Execute"}, set(), {9}), ({"Cleanup"}, set(), set()) ] lg_0 = llinkoCreate.Linkograph(lg_0_items) null_ontology = {} for k in range(2, 7): o_prime = windowed_refinement(lg_0, null_ontology, k) if o_prime != perfect_ontology: print("windowed refinement unit test 0 failed") result = False complete_ontology = { "Look": ["Look", "Transfer", "Move", "Execute", "Cleanup"], "Transfer": ["Look", "Transfer", "Move", "Execute", "Cleanup"], "Move": ["Look", "Transfer", "Move", "Execute", "Cleanup"], "Execute": ["Look", "Transfer", "Move", "Execute", "Cleanup"], "Cleanup": ["Look", "Transfer", "Move", "Execute", "Cleanup"] } # k = 2: 0 rules removed # k = 3: 5 rules removed # k = 4: 7 rules removed # k = 5: 6 rules removed # k = 6: 5 rules removed # k = 7: 4 rules removed # k = 8: 3 rules removed # k = 9: 2 rules removed # k = 10: 1 rule removed for k in range(2, 12): o_prime = windowed_refinement(lg_0, complete_ontology, k) return result
def unit_test_greedy(): print("unit testing greedy refinement") result = True lg_0_items = [ ({"Look"}, set(), {1, 6}), ({"Transfer"}, set(), {2, 7}), ({"Move"}, set(), {3, 8}), ({"Execute"}, set(), {4, 9}), ({"Cleanup"}, set(), {5}), ({"Look"}, set(), {6}), ({"Transfer"}, set(), {7}), ({"Move"}, set(), {8}), ({"Execute"}, set(), {9}), ({"Cleanup"}, set(), set()) ] lg_0 = llinkoCreate.Linkograph(lg_0_items) perfect_ontology = { "Look": ["Transfer"], "Transfer": ["Move"], "Move": ["Execute"], "Execute": ["Cleanup"], "Cleanup": ["Look"] } o_prime = greedy_lg_o_to_o(lg_0, perfect_ontology, "perfect") if o_prime != perfect_ontology: print("greedy unit test 0 failed") result = False null_ontology = {} o_prime = greedy_lg_o_to_o(lg_0, null_ontology, "null") if o_prime != perfect_ontology: print("greedy unit test 1 failed") result = False complete_ontology = { "Look": ["Look", "Transfer", "Move", "Execute", "Cleanup"], "Transfer": ["Look", "Transfer", "Move", "Execute", "Cleanup"], "Move": ["Look", "Transfer", "Move", "Execute", "Cleanup"], "Execute": ["Look", "Transfer", "Move", "Execute", "Cleanup"], "Cleanup": ["Look", "Transfer", "Move", "Execute", "Cleanup"] } o_prime = greedy_lg_o_to_o(lg_0, complete_ontology, "complete") if o_prime != perfect_ontology: print("greedy unit test 2 failed") result = False return result
def regressionTest(): # Figure 1 from linkography.pdf test_linkograph = llinkoCreate.Linkograph() test_linkograph.append((set(), set(), {1, 2, 3})) test_linkograph.append((set(), {0}, {2})) test_linkograph.append((set(), {0, 1}, set())) test_linkograph.append((set(), {0}, set())) if (4 != lstats.links(test_linkograph) or (1.125, 4.5, 1.0, 1.75, 7, 2) != lstats.calculateCartesianStatistics(test_linkograph) or 0.0000000000000001 < abs( lstats.percentageOfLinks(test_linkograph) - 0.6666666666666666) or 0.0000000000000001 < abs(lstats.graphEntropy(test_linkograph) - 0.9182958340544896)): print("error calculating statistics for training data")
def unit_test_converging_windowed_refinement(): print("unit testing converging windowed refinement") result = True perfect_ontology = { "Look": ["Transfer"], "Transfer": ["Move"], "Move": ["Execute"], "Execute": ["Cleanup"], "Cleanup": ["Look"] } lg_0_items = [ ({"Look"}, set(), {1, 6}), ({"Transfer"}, set(), {2, 7}), ({"Move"}, set(), {3, 8}), ({"Execute"}, set(), {4, 9}), ({"Cleanup"}, set(), {5}), ({"Look"}, set(), {6}), ({"Transfer"}, set(), {7}), ({"Move"}, set(), {8}), ({"Execute"}, set(), {9}), ({"Cleanup"}, set(), set()) ] lg_0 = llinkoCreate.Linkograph(lg_0_items) null_ontology = {} for k in range(2, 11): o_prime = converging_windowed_refinement(lg_0, null_ontology, k) if o_prime != perfect_ontology: print("converging windowed refinement unit test 0 failed for k =", k) result = False complete_ontology = { "Look": ["Look", "Transfer", "Move", "Execute", "Cleanup"], "Transfer": ["Look", "Transfer", "Move", "Execute", "Cleanup"], "Move": ["Look", "Transfer", "Move", "Execute", "Cleanup"], "Execute": ["Look", "Transfer", "Move", "Execute", "Cleanup"], "Cleanup": ["Look", "Transfer", "Move", "Execute", "Cleanup"] } o_prime = converging_windowed_refinement(lg_0, complete_ontology, k) if k > 5: if o_prime != perfect_ontology: print("converging windowed refinement unit test 1 failed for k =", k) print(o_prime) result = False return result
def enumToLinko(enum): """Converts a linkograph enumeration to a linkograph. Arguments: enum -- an enumeration (length, enc) for a linkograph. Retstriction: length >= 0, enc < 2^(length*(legth-1)/2) the total number of linkographs on length nodes. The second inequality is strict since the enumeration starts counting at 0. Return: linkoCreate.Linkograph -- the corresponding linkograph. """ # Name the components of enum. length, enc = enum # Check for valid enumeration if enc >= totalLinkographs(length): raise invalidEnumerationObject("The enumeration does not" " correspond to a linkograph") # Initialize the linkograph. linko = [(set(), set(), set()) for n in range(length)] # Keep track of the node and backlink. node, link = 1, 0 while enc > 0: # Test for bit if enc & 1 == 1: # Add backlink linko[node][1].add(link) # Add forelink linko[link][2].add(node) # Shift off the bit. enc >>= 1 # Increment the link. link += 1 if link == node: node, link = node + 1, 0 return linkoCreate.Linkograph(linko)
def performOntologyRefinement(self, linkograph, ontology, max_changes, unique_id): to_send = { 'err': "", 'data': {}, } ontology = fs.loadFile(ontology, 'ontology', unique_id)['content'] #print("Here with ontology " + ontology + " and linkograph " + linkograph) ontology = json.loads(ontology) linkograph = json.loads(linkograph) linkoTupleList = [] for x in range(0, len(linkograph)): for label in list(linkograph[x].keys()): print("Node " + str(x) + ": " + label + " with links " + str(linkograph[x][label])) currLabel = set() currLabel.add(label) currLinks = set() for link in range(0, len(linkograph[x][label])): currLinks.add(linkograph[x][label][link]) linkoTupleList.append((currLabel, set(), currLinks)) #print("Final list " + str(linkoTupleList)) linkograph = linkoCreate.Linkograph(linkoTupleList) o_prime, accuracy_prime = ont_ext.high_impact_first_minimum_similarity( linkograph, ontology, int(max_changes)) print("Resulting accuracy " + str(accuracy_prime) + " with ontology " + str(o_prime)) to_send['data']['o_prime'] = o_prime to_send['data']['accuracy_prime'] = accuracy_prime return json.dumps(to_send)
def setUp(self): """Set up the parameters for the individual tests.""" ontology = {'A': ['C', 'D'], 'B': ['C'], 'C': ['B'], 'D': ['B', 'C']} trivialLinko = linkoCreate.Linkograph( [], []) linko0 = linkoCreate.Linkograph( [({'A'}, set(), set())], ['A']) linko1 = linkoCreate.Linkograph( [({'A'}, set(), {1}), ({'D'}, {0}, set())], ['A', 'D']) linko2 = linkoCreate.Linkograph( [({'A'}, set(), {1}), ({'D'}, {0}, {2}), ({'B'}, {1}, set())], ['A', 'D', 'B']) linko3 = linkoCreate.Linkograph( [({'A'}, set(), {1,3}), ({'D'}, {0}, {2,3}), ({'B'}, {1}, {3}), ({'C'}, {0,1,2}, set())], ['A', 'D', 'B', 'C']) linko4 = linkoCreate.Linkograph( [({'D'}, set(), {1,2,3}), ({'B'}, {0}, {2}), ({'C'}, {0,1}, {3}), ({'B'}, {0,2}, set())], ['A', 'D', 'B', 'C']) if self.id().split('.')[-1] == 'test_addNodeSize4': self.testParams = [ {'linko': trivialLinko, 'newLabels': {'A'}, 'ontology': ontology, 'size': 4, 'ExpectedLinkograph': linko0}, {'linko': linko0, 'newLabels': {'D'}, 'ontology': ontology, 'size': 4, 'ExpectedLinkograph': linko1}, {'linko': linko1, 'newLabels': {'B'}, 'ontology': ontology, 'size': 4, 'ExpectedLinkograph': linko2}, {'linko': linko2, 'newLabels': {'C'}, 'ontology': ontology, 'size': 4, 'ExpectedLinkograph': linko3}, {'linko': linko3, 'newLabels': {'B'}, 'ontology': ontology, 'size': 4, 'ExpectedLinkograph': linko4}, ]
def setUp(self): """Set up the parameters for the individual tests.""" singleLabels = linkoCreate.Linkograph([({'A'}, set(), {1, 2, 3}), ({'D'}, {0}, {3, 4}), ({'A'}, {0}, {4}), ({'C'}, {0, 1}, {4}), ({'A'}, {1, 2, 3}, set())], ['A', 'B', 'C', 'D']) singleSubLinko0_2 = linkoCreate.Linkograph([({'A'}, set(), {1, 2}), ({'D'}, {0}, set()), ({'A'}, {0}, set())], ['A', 'B', 'C', 'D']) singleSubLinko0_1 = linkoCreate.Linkograph([({'A'}, set(), {1}), ({'D'}, {0}, set())], ['A', 'B', 'C', 'D']) singleSubLinko0_0 = linkoCreate.Linkograph([({'A'}, set(), set())], ['A', 'B', 'C', 'D']) singleSubLinko1_2 = linkoCreate.Linkograph([({'D'}, set(), set()), ({'A'}, set(), set())], ['A', 'B', 'C', 'D']) singleSubLinko1_1 = linkoCreate.Linkograph([({'D'}, set(), set())], ['A', 'B', 'C', 'D']) trivialLinkograph = linkoCreate.Linkograph([], ['A', 'B', 'C', 'D']) singleSubLinko1_4 = linkoCreate.Linkograph([({'D'}, set(), {2, 3}), ({'A'}, set(), {3}), ({'C'}, {0}, {3}), ({'A'}, {0, 1, 2}, set())], ['A', 'B', 'C', 'D']) singleSubLinko2_4 = linkoCreate.Linkograph([({'A'}, set(), {2}), ({'C'}, set(), {2}), ({'A'}, {0, 1}, set())], ['A', 'B', 'C', 'D']) singleSubLinko3_4 = linkoCreate.Linkograph([({'C'}, set(), {1}), ({'A'}, {0}, set())], ['A', 'B', 'C', 'D']) singleSubLinko4_4 = linkoCreate.Linkograph([({'A'}, set(), set())], ['A', 'B', 'C', 'D']) simpleLinko = linkoCreate.Linkograph( [({'A', 'B', 'C'}, set(), {1, 2, 3}), ({'D'}, {0}, {3, 4}), ({'A'}, {0}, {4}), ({'B', 'C'}, {0, 1}, {4}), ({'A'}, {1, 2, 3}, set())], ['A', 'B', 'C', 'D']) if self.id().split( '.')[-1] == 'test_createSubLinkographWithoutCommands': self.testParams = [ { 'linko': singleLabels, 'lowerBound': None, 'upperBound': None, 'ExpectedLinkograph': singleLabels }, { 'linko': singleLabels, 'lowerBound': 0, 'upperBound': 4, 'ExpectedLinkograph': singleLabels }, { 'linko': singleLabels, 'lowerBound': 0, 'upperBound': 5, 'ExpectedLinkograph': singleLabels }, { 'linko': singleLabels, 'lowerBound': 0, 'upperBound': 2, 'ExpectedLinkograph': singleSubLinko0_2 }, { 'linko': singleLabels, 'lowerBound': -1, 'upperBound': 2, 'ExpectedLinkograph': singleSubLinko0_2 }, { 'linko': singleLabels, 'lowerBound': None, 'upperBound': 2, 'ExpectedLinkograph': singleSubLinko0_2 }, { 'linko': singleLabels, 'lowerBound': 0, 'upperBound': 1, 'ExpectedLinkograph': singleSubLinko0_1 }, { 'linko': singleLabels, 'lowerBound': 0, 'upperBound': 0, 'ExpectedLinkograph': singleSubLinko0_0 }, { 'linko': singleLabels, 'lowerBound': 0, 'upperBound': -1, 'ExpectedLinkograph': trivialLinkograph }, { 'linko': singleLabels, 'lowerBound': 1, 'upperBound': 2, 'ExpectedLinkograph': singleSubLinko1_2 }, { 'linko': singleLabels, 'lowerBound': 1, 'upperBound': 1, 'ExpectedLinkograph': singleSubLinko1_1 }, { 'linko': singleLabels, 'lowerBound': 1, 'upperBound': 0, 'ExpectedLinkograph': trivialLinkograph }, { 'linko': singleLabels, 'lowerBound': -1, 'upperBound': -1, 'ExpectedLinkograph': trivialLinkograph }, { 'linko': singleLabels, 'lowerBound': 1, 'upperBound': 4, 'ExpectedLinkograph': singleSubLinko1_4 }, { 'linko': singleLabels, 'lowerBound': 2, 'upperBound': 4, 'ExpectedLinkograph': singleSubLinko2_4 }, { 'linko': singleLabels, 'lowerBound': 3, 'upperBound': 4, 'ExpectedLinkograph': singleSubLinko3_4 }, { 'linko': singleLabels, 'lowerBound': 4, 'upperBound': 4, 'ExpectedLinkograph': singleSubLinko4_4 }, ]
def setUp(self): """Set up the parameters for the individual tests.""" # InverseLabeling invLabeling0 = {'L0': [0, 1, 2]} invLabeling1 = {'L0': [0, 2], 'L1': [1]} invLabeling2 = {'L0': [0], 'L1': [1], 'L2': [2]} invLabeling3 = {'L1': [0, 1], 'L2': [2]} invLabeling4 = {'L0': [0, 1], 'L1': [0], 'L2': [2]} invLabeling5 = {'L0': [0, 1, 2], 'L1': []} # Create some ontologies ontology0 = {'L0': ['L0']} ontology1 = {} ontology2 = {'L0': ['L1']} ontology3 = {'L0': ['L1', 'L2'], 'L1': ['L2'], 'L2': ['L0']} if self.id().split('.')[-1] == 'test_createLinkograph': self.testParams = [ { 'inverseLabeling': invLabeling0, 'ontology': ontology0, 'ExpectedLinkograph': linkoCreate.Linkograph([({'L0'}, set(), {1, 2}), ({'L0'}, {0}, {2}), ({'L0'}, {0, 1}, set())]) }, { 'inverseLabeling': invLabeling0, 'ontology': ontology1, 'ExpectedLinkograph': linkoCreate.Linkograph([({'L0'}, set(), set()), ({'L0'}, set(), set()), ({'L0'}, set(), set())]) }, { 'inverseLabeling': invLabeling0, 'ontology': ontology2, 'ExpectedLinkograph': linkoCreate.Linkograph([({'L0'}, set(), set()), ({'L0'}, set(), set()), ({'L0'}, set(), set())]) }, { 'inverseLabeling': invLabeling1, 'ontology': ontology0, 'ExpectedLinkograph': linkoCreate.Linkograph([({'L0'}, set(), {2}), ({'L1'}, set(), set()), ({'L0'}, {0}, set())]) }, { 'inverseLabeling': invLabeling1, 'ontology': ontology1, 'ExpectedLinkograph': linkoCreate.Linkograph([({'L0'}, set(), set()), ({'L1'}, set(), set()), ({'L0'}, set(), set())]) }, { 'inverseLabeling': invLabeling1, 'ontology': ontology2, 'ExpectedLinkograph': linkoCreate.Linkograph([({'L0'}, set(), {1}), ({'L1'}, {0}, set()), ({'L0'}, set(), set())]) }, { 'inverseLabeling': invLabeling0, 'ontology': ontology3, 'ExpectedLinkograph': linkoCreate.Linkograph([({'L0'}, set(), set()), ({'L0'}, set(), set()), ({'L0'}, set(), set())]) }, { 'inverseLabeling': invLabeling1, 'ontology': ontology3, 'ExpectedLinkograph': linkoCreate.Linkograph([({'L0'}, set(), {1}), ({'L1'}, {0}, set()), ({'L0'}, set(), set())]) }, { 'inverseLabeling': invLabeling2, 'ontology': ontology3, 'ExpectedLinkograph': linkoCreate.Linkograph([({'L0'}, set(), {1, 2}), ({'L1'}, {0}, {2}), ({'L2'}, {0, 1}, set())]) }, { 'inverseLabeling': invLabeling3, 'ontology': ontology3, 'ExpectedLinkograph': linkoCreate.Linkograph([({'L1'}, set(), {2}), ({'L1'}, set(), {2}), ({'L2'}, {0, 1}, set())]) }, { 'inverseLabeling': invLabeling4, 'ontology': ontology3, 'ExpectedLinkograph': linkoCreate.Linkograph([({'L0', 'L1'}, set(), {2}), ({'L0'}, set(), {2}), ({'L2'}, {0, 1}, set())]) }, { 'inverseLabeling': invLabeling5, 'ontology': ontology3, 'ExpectedLinkograph': linkoCreate.Linkograph([({'L0'}, set(), set()), ({'L0'}, set(), set()), ({'L0'}, set(), set())]) }, ]
args.lowerBound, args.upperBound, args.lineNumbers) if args.lineNumbers: for entry in result: print(entry, end='\n') else: print(json.dumps(result, indent=4)) ###################################################################### if __name__ == '__main__': linko = linkoCreate.Linkograph([({'A', 'B', 'C'}, {}, {1, 2, 3}), ({'D'}, {0}, {3, 4}), ({'A'}, {0}, {4}), ({'B', 'C'}, {0, 1}, {4}), ({'A'}, {1, 2, 3}, {})], ['A', 'B', 'C', 'D']) tcode = [0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 1, 0, 1] expandtcode = [[e] for e in tcode] print(totalLabels(linko)) print(percentageOfEntries(linko)) print(links(linko, 2)) print(percentageOfLinks(linko)) print(graphEntropy(linko)) print("top level is {}".format(tComplexityRecurse(expandtcode, []))) print(tComplexity(tcode))
def setUp(self): """ Set up parameters for individual tests. """ # Linkographs linko0_0 = linkoCreate.Linkograph([]) linko1_0 = linkoCreate.Linkograph( [(set(), set(), set())] ) linko2_0 = linkoCreate.Linkograph( [(set(), set(), set()), (set(), set(), set())] ) linko2_1 = linkoCreate.Linkograph( [(set(), set(), {1}), (set(), {0}, set())] ) linko3_0 = linkoCreate.Linkograph( [(set(), set(), set()), (set(), set(), set()), (set(), set(), set())] ) linko3_1 = linkoCreate.Linkograph( [(set(), set(), {1}), (set(), {0}, set()), (set(), set(), set())] ) linko3_2 = linkoCreate.Linkograph( [(set(), set(), {2}), (set(), set(), set()), (set(), {0}, set())] ) linko3_3 = linkoCreate.Linkograph( [(set(), set(), {1,2}), (set(), {0}, set()), (set(), {0}, set())] ) linko3_4 = linkoCreate.Linkograph( [(set(), set(), set()), (set(), set(), {2}), (set(), {1}, set())] ) linko3_5 = linkoCreate.Linkograph( [(set(), set(), {1}), (set(), {0}, {2}), (set(), {1}, set())] ) linko3_6 = linkoCreate.Linkograph( [(set(), set(), {2}), (set(), set(), {2}), (set(), {0,1}, set())] ) linko3_7 = linkoCreate.Linkograph( [(set(), set(), {1,2}), (set(), {0}, {2}), (set(), {0,1}, set())] ) if self.id().split('.')[-1] == 'test_enumToLinko': self.testParams = [ {'enum': (0,0), 'ExpectedLinkograph': linko0_0}, {'enum': (1,0), 'ExpectedLinkograph': linko1_0}, {'enum': (2,0), 'ExpectedLinkograph': linko2_0}, {'enum': (2,1), 'ExpectedLinkograph': linko2_1}, {'enum': (3,0), 'ExpectedLinkograph': linko3_0}, {'enum': (3,1), 'ExpectedLinkograph': linko3_1}, {'enum': (3,2), 'ExpectedLinkograph': linko3_2}, {'enum': (3,3), 'ExpectedLinkograph': linko3_3}, {'enum': (3,4), 'ExpectedLinkograph': linko3_4}, {'enum': (3,5), 'ExpectedLinkograph': linko3_5}, {'enum': (3,6), 'ExpectedLinkograph': linko3_6}, {'enum': (3,7), 'ExpectedLinkograph': linko3_7}]
def addNode(linko, newLabels, ontology, size=None): """Adds a node to the linkograph and optionally maintains a size. Adds a node to the linkograph. If the size is not none, then the first node is dropped if the linkograph is already at the size provided by the size argument. Thus, when the linkograph is at the provided size, adding the node kicks the first node out. Arguments: linko -- the linkograph. newLabels -- A set of abstraction classes for the new node. size -- the size to maintain. Return: The resulting linkograph. """ newLinko = linkoCreate.Linkograph() # Copy over the labels. newLinko.labels = [l for l in linko.labels] # Add any necessary new labels. for l in newLabels: if l not in newLinko.labels: newLinko.labels.append(l) updateFunction = lambda x : x newNodeNumber = len(linko) # The lowerBound value is used to drop the first node off if # necessary. lowerBound = 0 # If the linkograph is at the size, then the first node needs to # be dropped off before adding a new node. if (size is not None) and (len(linko) >= size): # The updateFunction is used to decrement the indecies. updateFunction = lambda x : x-1 # Setting the lowerBound to 1 effectively drops the first # node off when slicing later. lowerBound = 1 # The last index number does not change if the limiting size # has been reached. newNodeNumber += -1 # Create a record for the new node. It will be built as part of # the next for loop. newNode = (newLabels, set(), set()) # Loop through all the entries starting at 1 and not 0, which # effectively removes the first node. for (presentLineNumber, entry) in enumerate(linko[lowerBound:]): lineLabel = entry[0] # Make a copy of the backlinks, remove node 0, and possible # decrement entry by 1. lineBackLinks = {updateFunction(x) for x in entry[1]} # Any reference to the 0 node becomes -1. So remove # it. Does nothing if -1 is not present. lineBackLinks = lineBackLinks - {-1} # Make a copy of the forelinks and possibly decrement each # entry by 1. lineForeLinks = {updateFunction(x) for x in entry[2]} # Add in forelink to new node and backlink to present node. for lTerminal in newLabels: for lInitial in lineLabel: # Check if the edge lInitial -> lTerminal is in the # ontolgoy. if lTerminal in ontology[lInitial]: # The edge is present, so add the last nodes # number to the forelinks and the present node's # line number to the backlinks. lineForeLinks.add(newNodeNumber) newNode[1].add(presentLineNumber) newLinko.append((lineLabel, lineBackLinks, lineForeLinks)) # Add in the new node. newLinko.append(newNode) return newLinko
if args.transition: fh.write(str(linko.labels)) fh.write('\n') fh.write(str(markovChain)) fh.write('\n') elif args.latex: latexString = markovToLatex(markovChain, linko.labels, args.precision) fh.write(latexString) else: # markovToDot(markovChain, linko.labels, fh, # args.precision) dotString = markovToDot(markovChain, linko.labels, args.precision) fh.write(dotString) fh.close() #--------------------------------------------------------------------- if __name__ == "__main__": linko = linkoCreate.Linkograph([({'A'}, set(), {1, 2, 3, 4}), ({'B'}, {0}, {4, 5}), ({'C'}, {0}, {3, 4}), ({'A'}, {0, 2}, {5}), ({'B'}, {0, 1, 2}, set()), ({'C'}, {1, 3}, set())], ['A', 'B', 'C']) m = createMarkov(linko) print(m)
def setUp(self): """ Set up parameters for individual tests. """ # Linkographs linko0_0 = linkoCreate.Linkograph([]) linko1_0 = linkoCreate.Linkograph( [(set(), set(), set())] ) linko2_0 = linkoCreate.Linkograph( [(set(), set(), set()), (set(), set(), set())] ) linko2_1 = linkoCreate.Linkograph( [(set(), set(), {1}), (set(), {0}, set())] ) linko3_0 = linkoCreate.Linkograph( [(set(), set(), set()), (set(), set(), set()), (set(), set(), set())] ) linko3_1 = linkoCreate.Linkograph( [(set(), set(), {1}), (set(), {0}, set()), (set(), set(), set())] ) linko3_2 = linkoCreate.Linkograph( [(set(), set(), {2}), (set(), set(), set()), (set(), {0}, set())] ) linko3_3 = linkoCreate.Linkograph( [(set(), set(), {1,2}), (set(), {0}, set()), (set(), {0}, set())] ) linko3_4 = linkoCreate.Linkograph( [(set(), set(), set()), (set(), set(), {2}), (set(), {1}, set())] ) linko3_5 = linkoCreate.Linkograph( [(set(), set(), {1}), (set(), {0}, {2}), (set(), {1}, set())] ) linko3_6 = linkoCreate.Linkograph( [(set(), set(), {2}), (set(), set(), {2}), (set(), {0,1}, set())] ) linko3_7 = linkoCreate.Linkograph( [(set(), set(), {1,2}), (set(), {0}, {2}), (set(), {0,1}, set())] ) if self.id().split('.')[-1] == 'test_linkoToEnum': self.testParams = [ {'linko': linko0_0, 'ExpectedEnumeration': (0,0)}, {'linko': linko1_0, 'ExpectedEnumeration': (1,0)}, {'linko': linko2_0, 'ExpectedEnumeration': (2,0)}, {'linko': linko2_1, 'ExpectedEnumeration': (2,1)}, {'linko': linko3_0, 'ExpectedEnumeration': (3,0)}, {'linko': linko3_1, 'ExpectedEnumeration': (3,1)}, {'linko': linko3_2, 'ExpectedEnumeration': (3,2)}, {'linko': linko3_3, 'ExpectedEnumeration': (3,3)}, {'linko': linko3_4, 'ExpectedEnumeration': (3,4)}, {'linko': linko3_5, 'ExpectedEnumeration': (3,5)}, {'linko': linko3_6, 'ExpectedEnumeration': (3,6)}, {'linko': linko3_7, 'ExpectedEnumeration': (3,7)}]
# a perfect match ontology is possible with this linkograph # simple and threshold implementations perform perfectly lg_0_items = [ ({"Look"}, set(), {1, 6}), ({"Transfer"}, set(), {2, 7}), ({"Move"}, set(), {3, 8}), ({"Execute"}, set(), {4, 9}), ({"Cleanup"}, set(), {5}), ({"Look"}, set(), {6}), ({"Transfer"}, set(), {7}), ({"Move"}, set(), {8}), ({"Execute"}, set(), {9}), ({"Cleanup"}, set(), set()) ] lg_0 = llinkoCreate.Linkograph(lg_0_items) # persist linkograph to JSON for visualization llinkoCreate.writeLinkoJson(lg_0, "lg_0.json") # calculate the ontologies o_0 = oe.simple_lg_to_ontology(lg_0) summarize_results(o_0, lg_0, "simple") out_file = open("extracted_ontology_simple_lg_0.json", "w") json.dump(o_0, out_file, indent=4) out_file.close() o_0 = oe.threshold_lg_to_ontology(lg_0) summarize_results(o_0, lg_0, "threshold") out_file = open("extracted_ontology_threshold_lg_0.json", "w") json.dump(o_0, out_file, indent=4) out_file.close() # no perfect match ontology is possible