def test_psd_pipe(data, n):
if "psd_matrix" in data:
psd_t = data["psd_matrix"]
else:
psd_t = None
if "mrp_psd" in data:
mrp_psd = data["mrp_psd"]
else:
mrp_psd = None
# gold psdGraph
psd = PSDGraph(psd_t, mrp_psd)
graph = psd.graph
h_v = BOS_WORD
root_v = psd.root
root_symbol = PSDUniversal.TOP_PSDUniversal()
graph.add_node(h_v, value=root_symbol, align=[],gold=True,dep=1)
graph.add_edge(h_v, root_v, key=":top", role=":top")
graph.add_edge(root_v, h_v, key=":top-of", role=":top-of")
# to mrp
mrp_psd_back, _ = PSDDecoder.graph_to_mrpGraph(mrp_psd.id, graph, flavor=0, framework="psd")
mrp_psd_back.add_input(mrp_psd.input)
result = mces.evaluate([mrp_psd], [mrp_psd_back], trace = 2);
if result["all"]["f"] != 1.0:
logger.error("result is {} for {}\n grpah_nodes:{}\n graph_edges:{}\n gold:{}\n pred:{} \n\n".format(result,mrp_psd.id, graph.nodes.data(), graph.edges.data(), mrp_psd.encode(), mrp_psd_back.encode()))
def test_ucca_fixed_pipe(mrp_ucca, ucca, snt_token, tok_anchors):
# need a step transform tree to graph by adding missing reentrance edges
# fixed_graph hixed discontinuous, but with reentracne
new_graph = ucca.fixed_graph
for (h_role_align, d_role_align, ori_h_role_align) in ucca.fixed:
d_role = d_role_align[0][1]
ori_h_node = find_node_by_role_aligns(new_graph, ori_h_role_align)
h_node = find_node_by_role_aligns(new_graph, h_role_align)
d_node = find_node_by_role_aligns(new_graph, d_role_align)
try:
if ori_h_node!=None and h_node!=None and d_node!=None:
new_graph.remove_edge(ori_h_node, d_node)
new_graph.remove_edge(d_node, ori_h_node)
new_graph.add_edge(h_node, d_node, key=d_role, role=d_role)
new_graph.add_edge(d_node, h_node, key=d_role+"-of", role=d_role+"-of")
else:
logger.error("missing some discontinuous:{},{}".format((h_role_align, d_role_align, ori_h_role_align), (h_node, d_node, ori_h_node)))
except:
logger.error(traceback.format_exc())
logger.error("error happend when fix discontinuous nodes in {}, {}".format((h_role_align, d_role_align, ori_h_role_align), (ori_h_node, h_node, d_node)))
#logger.error("new_graph after adding reentrance and fixed: for {}\n graph_nodes:{}\n graph_edges:{}\n\n".format(mrp_ucca.id, new_graph.nodes.data(), new_graph.edges.data()))
mrp_ucca_fixed_back, M = UCCADecoder.graph_to_mrpGraph(mrp_ucca.id, new_graph, flavor=2, framework="ucca")
mrp_ucca_fixed_back.add_input(mrp_ucca.input)
new_result = mces.evaluate([mrp_ucca], [mrp_ucca_fixed_back], trace = 2);
if new_result["all"]["f"] != 1.0:
# logger.error("graph_nodes:{}\n graph_edges:{}\n".format(graph.nodes.data(), graph.edges.data()))
logger.error("fixed_graph: result is {} for {}\n graph_nodes:{}\n graph_edges:{}\n gold:{}\n pred:{} \n\n".format(new_result, mrp_ucca.id, M.nodes.data(), M.edges.data(), mrp_ucca.encode(), mrp_ucca_fixed_back.encode()))
def test_dm_pipe(data, n):
if "dm_matrix" in data:
dm_t = data["dm_matrix"]
else:
dm_t = None
if "mrp_dm" in data:
mrp_dm = data["mrp_dm"]
else:
mrp_dm = None
# gold dmGraph
dm = DMGraph(dm_t, mrp_dm)
graph = dm.graph
h_v = BOS_WORD
root_v = dm.root
root_symbol = DMUniversal.TOP_DMUniversal()
graph.add_node(h_v, value=root_symbol, align=[], gold=True, dep=1)
graph.add_edge(h_v, root_v, key=":top", role=":top")
graph.add_edge(root_v, h_v, key=":top-of", role=":top-of")
# to mrp
mrp_dm_back, _ = DMDecoder.graph_to_mrpGraph(mrp_dm.id,
graph,
flavor=0,
framework="dm")
mrp_psd_back.add_input(mrp_psd.input)
result = mces.evaluate([mrp_dm], [mrp_dm_back], trace=2)
if result["all"]["f"] != 1.0:
logger.error(
"result is {} for {}\n grpah_nodes:{}\n graph_edges:{}\n gold:{}\n pred:{} \n\n"
.format(result, mrp_dm.id, graph.nodes.data(), graph.edges.data(),
mrp_dm.encode(), mrp_dm_back.encode()))
def test_eds_pipe(data, n):
if "eds_matrix" in data:
eds_t = data["eds_matrix"]
else:
eds_t = None
if "mrp_eds" in data:
mrp_eds = data["mrp_eds"]
else:
mrp_eds = None
# gold edsGraph
eds = EDSGraph(eds_t, mrp_eds)
graph = eds.graph
h_v = BOS_WORD
root_v = eds.root
root_symbol = EDSUniversal.TOP_EDSUniversal()
graph.add_node(h_v, value=root_symbol, align=[], gold=True, dep=1)
graph.add_edge(h_v, root_v, key=":top", role=":top")
graph.add_edge(root_v, h_v, key=":top-of", role=":top-of")
# to mrp
mrp_eds_back, _ = EDSDecoder.graph_to_mrpGraph(mrp_eds.id,
graph,
flavor=1,
framework="eds",
sentence=mrp_eds.input)
result = mces.evaluate([mrp_eds], [mrp_eds_back], trace=2)
if result["all"]["f"] != 1.0:
logger.error(
"result is {} for {}\n grpah_nodes:{}\n graph_edges:{}\n gold:{}\n pred:{} \n\n"
.format(result, mrp_eds.id, graph.nodes.data(), graph.edges.data(),
mrp_eds.encode(), mrp_eds_back.encode()))
def test_ucca_graph_pipe(mrp_ucca, ucca):
# the original graph is also changed for splitting
graph = ucca.graph
h_v = BOS_WORD
root_v = ucca.root
mrp_ucca_back, _ = UCCADecoder.graph_to_mrpGraph(mrp_ucca.id, graph, flavor=2, framework="ucca")
mrp_ucca_back.add_input(mrp_ucca.input)
#result = mces.evaluate([mrp_ucca], [mrp_ucca], trace = 2);
result = mces.evaluate([mrp_ucca], [mrp_ucca_back], trace = 2);
if result["all"]["f"] != 1.0:
logger.error("original_graph: result is {} for {}\n grpah_nodes:{}\n graph_edges:{}\n gold:{}\n pred:{} \n\n".format(result,mrp_ucca.id, graph.nodes.data(), graph.edges.data(), mrp_ucca.encode(), mrp_ucca_back.encode()))
def test_ucca_tree_pipe(mrp_ucca, ucca, snt_token, tok_anchors):
# need a step transform tree to graph by adding missing reentrance edges
# step 1: tree to graph
# if tree has top node, then the graph will also have
graph = ucca.graph
tree = ucca.tree
if ucca.tree == None:
logger.info("tree is None".format(mrp_ucca.id))
return None
else:
logger.info("tree linearize: {}".format(tree.linearize()))
new_graph,root_id = ptb2ucca(tree, snt_token, tok_anchors)
# some me will be raised to make it connected
#logger.error("new_graph after ptb2graph: for {}\n graph_nodes:{}\n graph_edges:{}\n\n".format(mrp_ucca.id, new_graph.nodes.data(), new_graph.edges.data()))
# step 2: adding corefence to graph
# passed, now adding gold corefence here.
for (h_role_align, d_role_align, edge) in ucca.reents:
h_node = find_node_by_role_aligns(new_graph, h_role_align)
d_node = find_node_by_role_aligns(new_graph, d_role_align)
if h_node != None and d_node != None:
if "attributes" in edge:
new_graph.add_edge(h_node, d_node, key=edge["role"], role=edge["role"], attributes=edge["attributes"], values=edge["values"])
new_graph.add_edge(d_node, h_node, key=edge["role"]+"-of", role=edge["role"]+"-of", attributes=edge["attributes"], values=edge["values"])
else:
new_graph.add_edge(h_node, d_node, key=edge["role"], role=edge["role"])
new_graph.add_edge(d_node, h_node, key=edge["role"]+"-of", role=edge["role"]+"-of")
else:
logger.error("missing some reentrance :{}".format((h_role_align, d_role_align, edge)))
for (h_role_align, d_role_align, ori_h_role_align) in ucca.fixed:
d_role = d_role_align[0][1]
ori_h_node = find_node_by_role_aligns(new_graph, ori_h_role_align)
h_node = find_node_by_role_aligns(new_graph, h_role_align)
d_node = find_node_by_role_aligns(new_graph, d_role_align)
try:
if ori_h_node != None and h_node != None and d_node != None:
new_graph.remove_edge(ori_h_node, d_node)
new_graph.remove_edge(d_node, ori_h_node)
new_graph.add_edge(h_node, d_node, key=d_role, role=d_role)
new_graph.add_edge(d_node, h_node, key=d_role+"-of", role=d_role+"-of")
else:
logger.error("missing some discontinuous:{},{}".format((h_role_align, d_role_align, ori_h_role_align), (h_node, d_node, ori_h_node)))
except:
logger.error(traceback.format_exc())
logger.error("error happend when fix discontinuous nodes in {}, {}".format((h_role_align, d_role_align, ori_h_role_align), (ori_h_node, h_node, d_node)))
#logger.error("new_graph after adding reentrance and fixed: for {}\n graph_nodes:{}\n graph_edges:{}\n\n".format(mrp_ucca.id, new_graph.nodes.data(), new_graph.edges.data()))
mrp_ucca_tree_back, M = UCCADecoder.graph_to_mrpGraph(mrp_ucca.id, new_graph, flavor=2, framework="ucca")
mrp_ucca_tree_back.add_input(mrp_ucca.input)
new_result = mces.evaluate([mrp_ucca], [mrp_ucca_tree_back], trace = 2);
if new_result["all"]["f"] != 1.0:
# logger.error("graph_nodes:{}\n graph_edges:{}\n".format(graph.nodes.data(), graph.edges.data()))
logger.error("new_graph: result is {} for {}\n graph_nodes:{}\n graph_edges:{}\n gold:{}\n pred:{} \n\n".format(new_result, mrp_ucca.id, M.nodes.data(), M.edges.data(), mrp_ucca.encode(), mrp_ucca_tree_back.encode()))
def test_amr_pipe(data, n):
if "amr_t" in data:
amr_t = data["amr_t"]
else:
amr_t = None
if "mrp_amr" in data:
mrp_amr = data["mrp_amr"]
else:
mrp_amr = None
# gold amrGraph
amr = AMRGraph(amr_t, mrp_amr)
graph = amr.graph
h_v = BOS_WORD
root_v = amr.root
root_symbol = AMRUniversal(BOS_WORD, BOS_WORD, NULL_WORD)
graph.add_node(h_v, value=root_symbol, align=-1, gold=True, dep=1)
graph.add_edge(h_v, root_v, key=":top", role=":top")
graph.add_edge(root_v, h_v, key=":top-of", role=":top-of")
# to mrp
mrp_amr_back, amr_string = AMRDecoder.graph_to_mrpGraph(mrp_amr.id,
graph,
normalizeMod=True,
flavor=2,
framework="amr")
mrp_amr_back.add_input(mrp_amr.input)
mrp_amr_back.normalize(actions=['edges', 'case', 'attributes'])
mrp_amr.normalize(actions=['edges', 'case', 'attributes'])
result = mces.evaluate([mrp_amr], [mrp_amr_back], trace=2)
#result = mrp_smatch.evaluate([mrp_amr], [mrp_amr_back], format="json", limit= 10, trace=2)
if result["all"]["f"] != 1.0:
logger.error(
"result is {} for {}\n grpah_nodes:{}\n graph_edges:{}\n gold:{}\n pred:{}\n amr:{} \n\n"
.format(result, mrp_amr.id, graph.nodes.data(), graph.edges.data(),
mrp_amr.encode(), mrp_amr_back.encode(), amr_string))