| import copy |
| import os |
| import pickle |
|
|
| import networkx as nx |
|
|
|
|
| class RST2ArgumentsMapper: |
| def argtree2rsttree(self, rsttree, argtree, key='txt_ru', mask_text=True): |
| """ Returns RST tree with presented ADUs as terminals. |
| Use mask_text=False to preserve the original EDU texts. """ |
|
|
| rsttree = copy.deepcopy(rsttree) |
| adus = [vars(adu).get(key) for adu in argtree.edus] |
|
|
| if rsttree.text.strip() in adus: |
| |
|
|
| if mask_text: |
| rsttree.text = 'ADU' + str(adus.index(rsttree.text.strip())) |
|
|
| if rsttree.relation == 'elementary': |
| return rsttree |
|
|
| rsttree.relation, rsttree.nuclearity = 'elementary', '_' |
| rsttree.left, rsttree.right = None, None |
|
|
| elif rsttree.relation == 'elementary': |
| inside_adu = [rsttree.text.strip() in adu for adu in adus] |
| if any(inside_adu): |
| |
| if mask_text: |
| rsttree.text = 'ADU' + str(inside_adu.index(True)) |
|
|
| extends_adu = [adu.strip() in rsttree.text.strip() for adu in adus] |
| if any(extends_adu): |
| |
| if mask_text: |
| numbers = ' '.join( |
| ['ADU' + str(i) for i, x in enumerate(adus) if x.strip() in rsttree.text.strip()]) |
| rsttree.text = numbers |
|
|
| else: |
| rsttree.left = self.argtree2rsttree(rsttree.left, argtree, key, mask_text) |
| rsttree.right = self.argtree2rsttree(rsttree.right, argtree, key, mask_text) |
|
|
| return rsttree |
|
|
| def convert_rst2dep(self, tree): |
| """ Converts RST tree to dependency tree.""" |
|
|
| def get_nucleus_edu(node): |
| if node.relation == 'elementary': |
| return node |
| elif node.nuclearity[0] == 'N': |
| return get_nucleus_edu(node.left) |
| else: |
| return get_nucleus_edu(node.right) |
|
|
| if tree.relation == 'elementary': |
| return [] |
|
|
| if tree.nuclearity == 'SN': |
| child, parent = get_nucleus_edu(tree.left).id, get_nucleus_edu(tree.right).id |
| else: |
| child, parent = get_nucleus_edu(tree.right).id, get_nucleus_edu(tree.left).id |
|
|
| return [(child, parent, tree.relation)] + self.convert_rst2dep(tree.left) + self.convert_rst2dep(tree.right) |
|
|
| def convert_rst2conll(self, trees): |
| """ Converts RST trees of a document to conll format. |
| >> tree = pickle.load(open('data/nlp_annot/en/micro_c121.pkl', 'rb')) |
| >> mapper.convert_rst2dep(tree) |
| << 1 Nuclear energy has been proven time and time again 2 Attribution |
| << 2 to be safe. 0 Root |
| << 3 It has been proven, over six decades, 2 Elaborate |
| << 4 to have a minimal impact on the environment, 3 Same-Unit |
| << 5 as they emit almost no greenhouse gases. 4 Background |
| << 6 The chances of anything untoward happening to a nuclear facility are also slim. 2 Elaborate |
| << 7 There have been a few nuclear events since Chernobyl, 8 Contrast |
| << 8 but there have been relatively few fatalities 2 Elaborate |
| << 9 associated with it. 8 Elaborate |
| """ |
|
|
| def get_edus(node): |
| if node.relation == 'elementary': |
| return [(node.id, node.text)] |
| else: |
| return get_edus(node.left) + get_edus(node.right) |
|
|
| def append_edu_root(edus, conll_tree): |
| """ Given a list of EDUs and a conll tree, appends the Root EDU. """ |
|
|
| result = [] |
| j = 0 |
| for i in range(len(edus)): |
| if j >= len(conll_tree): |
| |
| result.append([i + 1, edus[i], 0, 'Root']) |
| return result |
|
|
| if conll_tree[j][0] == i + 1: |
| edu = edus[i] |
| result.append(conll_tree[j]) |
| j += 1 |
| else: |
| result.append([i + 1, edus[i], 0, 'Root']) |
|
|
| return result |
|
|
| dependencies = [] |
| edus = [] |
| for tree in trees: |
| dependencies += self.convert_rst2dep(tree) |
| edus += get_edus(tree) |
|
|
| edus = dict(edus) |
| renumbering_dict = {edu: i + 1 for i, edu in enumerate(edus.keys())} |
| conll = [] |
| for i, dep in enumerate(dependencies): |
| conll.append([renumbering_dict[dep[0]], edus[dep[0]], renumbering_dict[dep[1]], dep[2]]) |
|
|
| conll = sorted(conll, key=lambda x: x[0]) |
| return '\n'.join(['\t'.join(map(str, row)) for row in append_edu_root(list(edus.values()), conll)]) |
|
|
| def convert_shrinkedrst2dep(self, tree): |
| """ Converts ADU-annotated RST tree to dependency tree. |
| >> tree = pickle.load(open('data/rst_shrinked/en/micro_c121.pkl', 'rb')) |
| >> mapper.convert_shrinkedrst2dep(tree) |
| << [('ADU5', 'ADU0', 'Elaborate'), |
| ('ADU3', 'ADU0', 'Elaborate'), |
| ('ADU1', 'ADU0', 'Elaborate'), |
| ('ADU1', 'ADU1', 'Same-Unit'), |
| ('ADU2', 'ADU1', 'Background'), |
| ('ADU4', 'ADU5', 'Contrast')] |
| """ |
|
|
| def get_nucleus_edu(node): |
| if node.relation == 'elementary': |
| return node |
| elif node.nuclearity[0] == 'N': |
| return get_nucleus_edu(node.left) |
| else: |
| return get_nucleus_edu(node.right) |
|
|
| if tree.relation == 'elementary': |
| return [] |
|
|
| if tree.nuclearity == 'SN': |
| child, parent = get_nucleus_edu(tree.left).text.strip(), get_nucleus_edu(tree.right).text.strip() |
| else: |
| child, parent = get_nucleus_edu(tree.right).text.strip(), get_nucleus_edu(tree.left).text.strip() |
|
|
| if parent[:3] != 'ADU' or child[:3] != 'ADU': |
| return self.convert_shrinkedrst2dep(tree.left) + self.convert_shrinkedrst2dep(tree.right) |
|
|
| return [(child, parent, tree.relation)] + self.convert_shrinkedrst2dep( |
| tree.left) + self.convert_shrinkedrst2dep(tree.right) |
|
|
| def joined_conll_shrinked(self, doc_annot: str, part: str): |
| """ Gets a document annotation in conll-like format: |
| id text role head function |
| as in the example: |
| |
| # id = micro_c058 |
| 1 A deposit on soft drink bottles is a really good idea, pro 0 cc |
| 2 it would help the environment pro 1 sup |
| ... |
| 5 The items you can make from recycling are good for the environment pro 1 sup |
| |
| and part ('en', 'ru', 'en2ru' or 'ru2en'). |
| |
| Returns the same annotation with RST dependencies: |
| id text rst_head rst_relation role head function |
| """ |
|
|
| doc_annot = doc_annot.strip().split('\n') |
| filename, contents = doc_annot[0][7:].strip(), doc_annot[1:] |
|
|
| if '(machine translation)' in filename: |
| _filename = filename.split(' (machine translation)')[0] |
| _part = 'ru2en' if part == 'en_aug' else 'en2ru' |
| rst_annot_path = os.path.join('data/rst_shrinked', _part, _filename + '.pkl') |
| rst_annot = pickle.load(open(rst_annot_path, 'rb')) |
|
|
| else: |
| _part = part.replace('_aug', '') |
| rst_annot_path = os.path.join('data/rst_shrinked', _part, filename + '.pkl') |
| rst_annot = pickle.load(open(rst_annot_path, 'rb')) |
|
|
| deps = self.convert_shrinkedrst2dep(rst_annot) |
|
|
| numerized_deps = dict() |
| for dep in deps: |
| child, parent = int(dep[0][3:]) + 1, int(dep[1][3:]) + 1 |
| numerized_deps[child] = (parent, dep[2]) |
|
|
| dannot = [doc_annot[0]] |
| for i, line in enumerate(contents): |
| line = line.split('\t') |
| if i + 1 in numerized_deps: |
| parent, relation = numerized_deps[i + 1] |
| line = line[:-3] + [str(parent), relation] + line[-3:] |
| else: |
| line = line[:-3] + ['0', 'root'] + line[-3:] |
|
|
| dannot.append('\t'.join(line)) |
|
|
| return '\n'.join(dannot) |
|
|
| def joined_conll(self, rst_conll: str, arg_conll: str): |
| """ Matches two conll annotations: one with RST structure and other with Argument structure. |
| Returns the RST annotation with EDU-based argumentative functions. |
| |
| >> rst_conll = \"""1 A deposit on soft drink bottles is a really good idea, 0 Root |
| 2 it would help the environment 1 Explanation |
| 3 and clean up the roads. 2 Joint |
| 4 The areas of green space are littered with cans. 1 Background |
| 5 The items 1 Evaluation |
| 6 you can make from recycling 5 Elaborate |
| 7 are good for the environment 5 Same-Unit |
| \""" |
| >> arg_conll = \"""1 A deposit on soft drink bottles is a really good idea, pro 0 cc |
| 2 it would help the environment pro 1 sup |
| 3 and clean up the roads. pro 1 sup |
| 4 The areas of green space are littered with cans. pro 3 sup |
| 5 The items you can make from recycling are good for the environment pro 1 sup |
| \""" |
| >> mapper.match_two_conlls(rst_conll, arg_conll) |
| << 1 A deposit on soft drink bottles is a really good idea, 0 Root pro 0 cc |
| 2 it would help the environment 1 Explanation pro 1 sup |
| 3 and clean up the roads. 2 Joint pro 1 sup |
| 4 The areas of green space are littered with cans. 1 Background pro 3 sup |
| 5 The items 1 Evaluation pro 1 sup |
| 6 you can make from recycling 5 Elaborate 5 same-arg |
| 7 are good for the environment 5 Same-Unit 5 same-arg |
| """ |
|
|
| def make_nx_subtree(triplets): |
| """ Make nx subtree from rst triplets (parent, child, relation) """ |
| nx_subtree = nx.DiGraph() |
| for triplet in triplets: |
| nx_subtree.add_edge(triplet[0], triplet[1], relation=triplet[2]) |
| return nx_subtree |
|
|
| def find_root(nx_subtree): |
| """ Find root of nx subtree """ |
| for node in nx_subtree.nodes(): |
| if nx_subtree.out_degree(node) == 0: |
| nx_subtree.remove_node(node) |
| break |
|
|
| for node in nx_subtree.nodes(): |
| if nx_subtree.out_degree(node) == 0: |
| return node |
|
|
| rst_conll = rst_conll.strip().split('\n') |
| arg_conll = arg_conll.strip().split('\n') |
|
|
| rst_id2text = dict() |
| for line in rst_conll: |
| line = line.split('\t') |
| rst_id2text[line[0]] = ' ' + line[1] + ' ' |
|
|
| arg_id2text = dict() |
| for line in arg_conll: |
| line = line.split('\t') |
| arg_id2text[line[0]] = ' ' + line[1] + ' ' |
|
|
| rst_id2arg_id = dict() |
| m_rst_id2arg_id = dict() |
| for rst_id, rst_text in rst_id2text.items(): |
| for arg_id, arg_text in arg_id2text.items(): |
| if rst_text == arg_text or arg_text in rst_text: |
| rst_id2arg_id[rst_id] = arg_id |
| break |
| elif rst_text in arg_text: |
| m_rst_id2arg_id[rst_id] = arg_id |
|
|
| |
| arg_id2rst_id = {v: k for k, v in rst_id2arg_id.items()} |
|
|
| |
| for rst_id, arg_id in m_rst_id2arg_id.items(): |
| if arg_id in arg_id2rst_id: |
| if type(arg_id2rst_id[arg_id]) == list: |
| arg_id2rst_id[arg_id].append(rst_id) |
| else: |
| arg_id2rst_id[arg_id] = [arg_id2rst_id[arg_id], rst_id] |
| else: |
| arg_id2rst_id[arg_id] = [rst_id] |
|
|
| matched_conll = [] |
| |
| for line in rst_conll: |
| line = line.split('\t') |
| if line[0] in rst_id2arg_id: |
| arg_id = rst_id2arg_id[line[0]] |
| for arg_line in arg_conll: |
| arg_line = arg_line.split('\t') |
| if arg_line[0] == arg_id: |
| if arg_line[3] == '0': |
| line = line + arg_line[2:] |
| elif arg_id2rst_id.get(arg_line[3]) and type(arg_id2rst_id.get(arg_line[3])) == str: |
| |
| line = line + [arg_line[2], arg_id2rst_id[arg_line[3]], arg_line[4]] |
| else: |
| |
| line = line + [arg_line[2], '-1', arg_line[4]] |
| break |
|
|
| matched_conll.append(line) |
|
|
| |
| unmatched_conll = [] |
| clusters = set(m_rst_id2arg_id.values()) |
| for cluster in clusters: |
| arg_line = [arg_line for arg_line in arg_conll if arg_line.split('\t')[0] == cluster][0] |
| arg_line = arg_line.split('\t') |
| rst_lines = [rst_line for rst_line in rst_conll if |
| rst_line.split('\t')[0] in m_rst_id2arg_id and m_rst_id2arg_id[ |
| rst_line.split('\t')[0]] == cluster] |
| rst_lines = [rst_line.split('\t') for rst_line in rst_lines] |
| matched_lines = [line + arg_line[2:] for line in rst_lines] |
| unmatched_conll.append([[line[0], line[2], line[3]] for line in matched_lines]) |
|
|
|
|
| |
| |
| |
| original_arg_id2rst_id = arg_id2rst_id.copy() |
| arg_id2rst_id = dict() |
| for rst_id, arg_id in m_rst_id2arg_id.items(): |
| if arg_id not in arg_id2rst_id: |
| arg_id2rst_id[arg_id] = [] |
| arg_id2rst_id[arg_id].append(rst_id) |
|
|
| unmatched_subgraphs = [make_nx_subtree(cluster) for cluster in unmatched_conll] |
| roots = [find_root(subgraph) for subgraph in unmatched_subgraphs] |
| arg_id2rst_id = {arg_id: [rst_id for rst_id in values if rst_id in roots][0] for arg_id, values in |
| arg_id2rst_id.items()} |
|
|
| |
| for root in roots: |
| for node in unmatched_subgraphs[roots.index(root)].nodes(): |
| line = [line for line in rst_conll if line.split('\t')[0] == node][0].split('\t') |
| if node not in [l[0] for l in matched_conll]: |
| if node == root: |
| |
| for arg_id, arg_text in arg_id2text.items(): |
| if line[1] in arg_text: |
| for arg_line in arg_conll: |
| arg_line = arg_line.split('\t') |
| id, text, role, head, function = arg_line |
| if id == arg_id: |
| arg_head_in_rst = arg_id2rst_id.get(head, original_arg_id2rst_id.get(head, head)) |
| if len(line) == 4: |
| line += [role, arg_head_in_rst, function] |
| else: |
| line[4] = 'pro' |
| line[5] = line[2] |
| line[6] = 'sup' |
| break |
| else: |
| |
| arg_line = [arg_line for arg_line in arg_conll if |
| arg_line.split('\t')[0] == m_rst_id2arg_id.get(root)][0].split('\t') |
|
|
| line += [arg_line[2], line[2], 'same-arg'] |
|
|
| matched_conll.append(line) |
|
|
| |
| |
| |
| for i, line in enumerate(matched_conll): |
| head = line[5] |
| if head == '-1': |
| |
| arg_id = rst_id2arg_id[line[0]] |
| arg_line = [arg_line for arg_line in arg_conll if arg_line.split('\t')[0] == arg_id][0].split('\t') |
| arg_head = arg_line[3] |
| converted_arg_head = arg_id2rst_id.get(arg_head, arg_head) |
| matched_conll[i][5] = converted_arg_head |
|
|
| |
| broken_lines = [line.split('\t') for line in [ |
| '5 Однако, поскольку скейт, шахматы и т.д. не принимаются в качестве олимпийских соревнований, компьютерные игры также не должны быть признаны олимпийскими событиями. 4 contrast pro 6 sup',]] |
|
|
| for node in range(1, len(rst_conll) + 1): |
| if str(node) not in [line[0] for line in matched_conll]: |
| line = [line for line in rst_conll if line.split('\t')[0] == str(node)][0].split('\t') |
| matched_conll.append(line + ['pro', line[2], 'same-arg']) |
|
|
| for i, line in enumerate(matched_conll): |
| if line in broken_lines: |
| matched_conll[i] = line[:-3] + ['pro', '0', 'cc'] |
|
|
| if int(line[5]) > len(matched_conll): |
| matched_conll[i][5] = str(len(matched_conll)) |
|
|
| return '\n'.join(['\t'.join(row) for row in sorted(matched_conll, key=lambda x: int(x[0]))]) |
|
|
