def directo(tree, exp):
new_tree = trees.Tree()
new_tree.data = "."
right_t = trees.Tree()
right_t.data = "#"
new_tree.right = right_t
new_tree.left = tree
# Estados importantes
# Se crea un diccionario "table"
# key = estado importante
# value = sus follow_pos (llenado en follow_pos())
importantes = estados_importantes(new_tree)
# FirstPos
first = first_pos(new_tree)
#Lastpos
last = last_pos(new_tree)
# Followpos
table = {}
for pos in importantes:
table[pos] = []
followpos(new_tree, table)
inicial = first_pos(new_tree)
final = last_pos(new_tree)
auto_direct = create(inicial, final, table, exp)
return auto_direct
def question(tree, automata):
temp = trees.Tree()
temp2 = trees.Tree()
temp2.data = EPSILON
temp.data = "|"
temp.left = tree.left
temp.right = temp2
st1, fn1 = option(temp, automata)
return st1, fn1
def main():
"""Program to demonstrate trees of different types."""
# Let's make some trees of different classes (subclasses)
tree_list = [
trees.Tree(),
trees.EvenTree(),
trees.UpsideDownTree(),
trees.WideTree(),
trees.QuickTree(),
trees.FruitTree(),
trees.PineTree()
]
# display all the trees
for tree in tree_list:
print(tree.__class__)
print(tree)
print("Time to grow!")
# grow them several times
for _ in range(5):
for tree in tree_list:
tree.grow(5, 2)
# display all the trees again
for tree in tree_list:
print(tree.__class__)
print(tree)
def test_inits(self):
tree0 = trees.Tree()
self.assertIsInstance(tree0.id, int)
self.assertIsNone(tree0.value)
self.assertIsNone(tree0.left)
self.assertIsNone(tree0.right)
self.assertEqual(tree0.__str__(), '<Tree {}: len:0.1 left:None right:None parent:None>'.format(tree0.id))
def test_get_two_random_orphans(self):
nodes = [trees.Tree() for i in range(4)]
nodes[0].left = nodes[1]
nodes[0].right = nodes[2]
self.assertEqual(nodes[1].parent, nodes[0])
self.assertEqual(nodes[2].parent, nodes[0])
orphans = trees.get_two_random_orphans(nodes)
self.assertEqual(len(orphans), 2)
for i in orphans:
self.assertIsNone(i.parent)
def insert(tree, x):
if is_nil(tree):
return trees.Tree(x)
if x < tree.data:
if is_nil(tree.left):
tree.left = trees.Tree(x)
tree.left.parent = tree
return tree.left
else:
return insert(tree.left, x)
if x > tree.data:
if is_nil(tree.right):
tree.right = trees.Tree(x)
tree.right.parent = tree
return tree.right
else:
return insert(tree.right, x)
return tree
def test_binary():
data = set()
tree = trees.Tree()
for c in range(1, COUNT + 1):
for i in range(c):
value = random.randint(-MAX_INT, MAX_INT)
tree.insert(value)
data.add(value)
assert list(tree) == sorted(list(data))
for value in list(data):
tree.delete(value)
data.remove(value)
assert list(tree) == sorted(list(data))
assert list(tree) == []
def test_binary1():
tree = trees.Tree()
tree.insert(50)
tree.insert(30)
tree.insert(20)
tree.insert(40)
tree.insert(70)
tree.insert(60)
tree.insert(80)
assert list(tree) == [20, 30, 40, 50, 60, 70, 80]
tree.delete(20)
assert list(tree) == [30, 40, 50, 60, 70, 80]
tree.delete(30)
assert list(tree) == [40, 50, 60, 70, 80]
tree.delete(50)
assert list(tree) == [40, 60, 70, 80]
def eval_parser_output(fname):
print(
"Note: this function uses scripts from past work to evaluate (NOT evalb)."
)
print("These numbers should match those in the paper.")
print(fname)
treebank = tr.load_ptb('../data/23.auto.clean_fixed', lower=False)
treebank_nopunct = tr.load_ptb('../data/23.auto.clean_fixed',
nopunct=True,
lower=False)
treebank_compare = tr.load_ptb('../data/ptb-test.txt', lower=False)
pred = tr.load_ptb(fname)
# align ptb-test with 23.auto.clean
treebank_compare_aligned = []
sents1 = [exmp['sent'] for exmp in treebank_nopunct]
sents2 = [exmp['sent'] for exmp in treebank_compare]
for sent in sents1:
if sent not in sents2:
print(sent)
sent = [
'The', 'only', 'thing', 'you', 'do', "n't", 'have', 'he',
'said', 'is', 'the', 'portfolio', 'insurance', 'phenomenon',
'overlaid', 'on', 'the', 'rest'
]
ind = sents2.index(sent)
treebank_compare_aligned.append(treebank_compare[ind])
# remove punct from pred for comparison
for tree1, tree2 in zip(pred, treebank):
try:
tr.transfer_leaves(tree1['tree'], tree2['tree'])
except Exception as e:
print(e)
print(tree1['sent'], tree2['sent'])
tree1['tree'] = tr.remove_labels(
tr.collapse_unary_chains(
tr.clean_empty(tr.standardize_punct(tree1['tree'], True))))
if len(tree1['tree'].sent()) == 1:
print(tree1['tree'].sent())
tree1['tree'] = tr.Tree('X', [tree1['tree']], None)
f1 = pcfg_compute_f1(
[str(exmp['tree']) for exmp in treebank_compare_aligned],
[str(exmp['tree']) for exmp in pred])
print(f1)
def plus(tree, automata):
symbol = tree.data
if tree.left.data in OPERATORS:
st1, fn1 = t_handler(tree.left, automata)
else:
st1, fn1 = single(tree.left, automata)
temp = trees.Tree()
temp.data = "*"
temp.left = tree.left
st2, fn2 = kleene(temp, automata)
fn1.transitions.append(nfa.Transition(EPSILON, st2.id))
return st1, fn2
import trees as trees
# let's make some trees
treeList = [
trees.Tree(),
trees.EvenTree(),
trees.UpsideDownTree(),
trees.WideTree(),
trees.QuickTree(),
trees.FruitTree(),
trees.PineTree()
]
# display all the trees
for tree in treeList:
print(tree.__class__)
print(tree)
print("Time to grow!")
# grow them several times
for i in range(5):
for tree in treeList:
tree.grow(5, 2)
# display all the trees again
for tree in treeList:
print(tree.__class__)
print(tree)
# when you complete all the subclasses, you'll see that they behave differently
err = np.abs(dL[j][i] - numGrad)
err2+=err
count+=1
if 0.001 > err2/count:
print "Grad Check Passed for dL"
else:
print "Grad Check Failed for dL: Sum of Error = %.9f" % (err2/count)
if __name__ == '__main__':
import trees as treeM
f = open('data/trees')
dataSize = 4
mbData = []
for j in range(dataSize):
mbData.append(treeM.Tree(f.readline().split('\t')[1].strip('\n')))
#import tree as treeM
#train = treeM.loadTrees()
#numW = len(treeM.loadWordMap())
wvecDim = 10
middleDim = 10
paramDim = 3
numW = np.load('data/Lmat.npy').shape[0]
rnn = TLSTM(wvecDim,middleDim,paramDim,numW,mbSize=4)
rnn.initParams()
#mbData = train[:4]
#
def test_get_orphans(self):
nodes = [trees.Tree() for i in range(4)]
self.assertEqual(len(trees.get_orphans(nodes)), 4)
nodes[0].parent = nodes[1]
self.assertEqual(len(trees.get_orphans(nodes)), 3)
def test_tree_ids_increment_automatically(self):
tree0 = trees.Tree()
tree1 = trees.Tree()
self.assertEqual(tree1.id, tree0.id + 1)
