def get_candidate_actions(self, vocab):
candidate_actions = []
if self.is_end():
ac = Action(CODE.NO_ACTION, -1)
candidate_actions.append(ac)
if self.allow_shift():
ac = Action(CODE.SHIFT, -1)
candidate_actions.append(ac)
if self.allow_arc_left():
for idx in range(0, vocab.rel_size):
ac = Action(CODE.ARC_LEFT, idx)
if ac in vocab._id2ac:
candidate_actions.append(ac)
if self.allow_arc_right():
for idx in range(0, vocab.rel_size):
ac = Action(CODE.ARC_RIGHT, idx)
if ac in vocab._id2ac:
candidate_actions.append(ac)
if self.allow_pop_root():
ac = Action(CODE.POP_ROOT, vocab.ROOT)
candidate_actions.append(ac)
return candidate_actions
def create_action_table(self, all_actions):
self._id2ac.append(Action(CODE.NO_ACTION, -1))
ac_counter = Counter()
for actions in all_actions:
for ac in actions:
ac_counter[ac] += 1
for ac, count in ac_counter.most_common():
self._id2ac.append(ac)
reverse = lambda x: dict(zip(x, range(len(x))))
self._ac2id = reverse(self._id2ac)
if len(self._ac2id) != len(self._id2ac):
print("serious bug: actions dumplicated, please check!")
print("action num: ", len(self._ac2id))
print("action: ", end=' ')
self.mask_shift = np.array([False] * self.ac_size)
self.mask_arc_left = np.array([False] * self.ac_size)
self.mask_arc_right = np.array([False] * self.ac_size)
self.mask_arc_label = np.array([False] * self.ac_size)
self.mask_pop_root = np.array([False] * self.ac_size)
self.mask_no_action = np.array([False] * self.ac_size)
for (idx, ac) in enumerate(self._id2ac):
if ac.is_shift():
self.mask_shift[idx] = True
if ac.is_arc_left():
self.mask_arc_left[idx] = True
if ac.is_arc_right():
self.mask_arc_right[idx] = True
if ac.is_arc_label():
self.mask_arc_label[idx] = True
if ac.is_finish():
self.mask_pop_root[idx] = True
if ac.is_none():
self.mask_no_action[idx] = True
print(ac.str(self), end=', ')
print()
def get_gold_action(self, vocab):
gold_action = Action(CODE.NO_ACTION, -1)
if self._stack_size == 0:
gold_action.set(CODE.SHIFT, -1)
elif self._stack_size == 1:
if self._next_index == self._word_size:
gold_action.set(CODE.POP_ROOT, vocab.ROOT)
else:
gold_action.set(CODE.SHIFT, -1)
elif self._stack_size > 1: # arc
top0 = self._stack[self._stack_size - 1]
top1 = self._stack[self._stack_size - 2]
assert top0 < self._word_size and top1 < self._word_size
if top0 == self._inst.heads[top1]: # top1 <- top0
gold_action.set(CODE.ARC_LEFT,
vocab._rel2id[self._inst.rels[top1]])
elif top1 == self._inst.heads[top0]: # top1 -> top0,
# if top0 have right child, shift.
have_right_child = False
for idx in range(self._next_index, self._word_size):
if self._inst.heads[idx] == top0:
have_right_child = True
break
if have_right_child:
gold_action.set(CODE.SHIFT, -1)
else:
gold_action.set(CODE.ARC_RIGHT,
vocab._rel2id[self._inst.rels[top0]])
else: # can not arc
gold_action.set(CODE.SHIFT, -1)
return gold_action
def clear(self):
self._next_index = 0
self._stack_size = 0
self._word_size = 0
self._is_gold = True
self._is_start = True
self._pre_action = Action(CODE.NO_ACTION, -1)
self.done_mark()
def __init__(self):
self._stack = [-3] * max_length
self._stack_size = 0
self._rel = [-3] * max_length
self._head = [-3] * max_length
self._have_parent = [-1] * max_length
self._next_index = 0
self._word_size = 0
self._is_start = True
self._is_gold = True
self._inst = None
self._atom_feat = AtomFeat()
self._pre_action = Action(CODE.NO_ACTION, -1)
def __init__(self):
self._stack = []
for idx in range(max_length):
self._stack.append(Node())
self._stack_size = 0
self._edu_size = 0
self._next_index = 0
self._word_size = 0
self._is_start = True
self._is_gold = True
self._inst = None
self._pre_state = None
self._atom_feat = AtomFeat()
self._pre_action = Action(CODE.NO_ACTION)
def create_action_table(self, all_actions):
self._id2ac.append(Action(CODE.NO_ACTION, -1))
ac_counter = Counter()
for actions in all_actions:
for ac in actions:
ac_counter[ac] += 1
for ac, count in ac_counter.most_common():
self._id2ac.append(ac)
reverse = lambda x: dict(zip(x, range(len(x))))
self._ac2id = reverse(self._id2ac)
if len(self._ac2id) != len(self._id2ac):
print("serious bug: actions dumplicated, please check!")
print("action num: ", len(self._ac2id))
print("action: ", end=' ')
for ac in self._id2ac:
print(ac.str(self), end=', ')
print()
def parseTree(self, tree_str):
buffer = tree_str.strip().split(" ")
buffer_size = len(buffer)
step = 0
subtree_stack = [] # edu index
op_stack = []
relation_stack = []
action_stack = []
while True:
assert step <= buffer_size
if step == buffer_size:
break
if buffer[step] == "(":
op_stack.append(buffer[step])
relation_stack.append(buffer[step + 1])
action_stack.append(buffer[step + 2])
if buffer[step + 1] == 'leaf' and buffer[step + 2] == 't':
start = int(buffer[step + 3])
end = int(buffer[step + 4])
step += 2
step += 3
elif buffer[step] == ")":
action = action_stack[-1]
if action == 't':
for sent_type in self.sent_types:
assert len(sent_type) == 3
if start >= sent_type[0] and end <= sent_type[1]:
e = EDU(start, end, sent_type[2])
edu_start = len(self.EDUs)
edu_end = len(self.EDUs)
subtree_stack.append([edu_start, edu_end])
self.EDUs.append(e)
assert relation_stack[-1] == "leaf"
ac = Action(CODE.SHIFT, -1, -1, relation_stack[-1])
self.gold_actions.append(ac)
break
elif action == 'l' or action == 'r' or action == 'c':
if action == 'l':
nuclear = NUCLEAR.NS
if action == 'r':
nuclear = NUCLEAR.SN
if action == 'c':
nuclear = NUCLEAR.NN
code = CODE.REDUCE
ac = Action(code, nuclear, -1, relation_stack[-1])
self.gold_actions.append(ac)
assert len(subtree_stack) >= 2
l_index = subtree_stack[-2]
r_index = subtree_stack[-1]
assert l_index[1] + 1 == r_index[0]
left_subtree = SubTree(nullkey, nullkey, l_index[0],
l_index[1])
right_subtree = SubTree(nullkey, nullkey, r_index[0],
r_index[1])
if action == "l": #NS
left_subtree.nuclear = nuclear_str
left_subtree.relation = span_str
right_subtree.nuclear = satellite_str
right_subtree.relation = ac.label_str
if action == "r": #SN
left_subtree.nuclear = satellite_str
left_subtree.relation = ac.label_str
right_subtree.nuclear = nuclear_str
right_subtree.relation = span_str
if action == "c": #NN
left_subtree.nuclear = nuclear_str
left_subtree.relation = ac.label_str
right_subtree.nuclear = nuclear_str
right_subtree.relation = ac.label_str
self.result.subtrees.append(left_subtree)
self.result.subtrees.append(right_subtree)
l_index[1] = r_index[1]
subtree_stack.pop()
relation_stack.pop()
op_stack.pop()
action_stack.pop()
step += 1
ac = Action(CODE.POP_ROOT)
self.gold_actions.append(ac)
assert len(subtree_stack) == 1
root = subtree_stack[0]
assert root[0] == 0 and root[1] == len(self.EDUs) - 1
subtree_stack.pop() # pop root
#### check stack, all stack empty
assert op_stack == [] and relation_stack == [] and action_stack == [] and subtree_stack == []
#### check edu index
for idx in range(len(self.EDUs)):
edu = self.EDUs[idx]
assert edu.start >= 0 and edu.end < len(self.total_words)
assert edu.start <= edu.end
if idx < len(self.EDUs) - 1:
assert edu.end + 1 == self.EDUs[idx + 1].start
#### initialize edu word and tag
sum = 0
for edu in self.EDUs:
for idx in range(edu.start, edu.end + 1):
if self.total_tags[idx] != nullkey:
edu.words.append(self.total_words[idx])
edu.tags.append(self.total_tags[idx])
sum += len(edu.words)
assert sum == len(self.words)
#### check subtree
for subtree in self.result.subtrees:
assert subtree.relation != nullkey and subtree.nuclear != nullkey