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
