def test_act_phos_to_af():
act_st = Activation(Agent('A', activity=ActivityCondition('kinase', True)),
Agent('B'))
phos_st = Phosphorylation(Agent('A'), Agent('B'))
ml = MechLinker([act_st, phos_st])
linked_stmts = ml.infer_active_forms(ml.statements)
assert len(linked_stmts) == 1
def test_act_phos_to_af():
act_st = Activation(Agent('A', activity=ActivityCondition('kinase', True)),
Agent('B'))
phos_st = Phosphorylation(Agent('A'), Agent('B'))
ml = MechLinker([act_st, phos_st])
linked_stmts = ml.infer_active_forms(ml.statements)
assert len(linked_stmts) == 1
def run_assembly(stmts, folder, pmcid, background_assertions=None):
'''Run assembly on a list of statements, for a given PMCID.'''
# Folder for index card output (scored submission)
indexcard_prefix = folder + '/index_cards/' + pmcid
# Folder for other outputs (for analysis, debugging)
otherout_prefix = folder + '/other_outputs/' + pmcid
# Do grounding mapping here
# Load the TRIPS-specific grounding map and add to the default
# (REACH-oriented) grounding map:
trips_gm = load_grounding_map('trips_grounding_map.csv')
default_grounding_map.update(trips_gm)
gm = GroundingMapper(default_grounding_map)
mapped_agent_stmts = gm.map_agents(stmts)
renamed_agent_stmts = gm.rename_agents(mapped_agent_stmts)
# Filter for grounding
grounded_stmts = []
for st in renamed_agent_stmts:
if all([is_protein_or_chemical(a) for a in st.agent_list()]):
grounded_stmts.append(st)
# Instantiate the Preassembler
pa = Preassembler(bio_ontology)
pa.add_statements(grounded_stmts)
print('== %s ====================' % pmcid)
print('%d statements collected in total.' % len(pa.stmts))
# Combine duplicates
unique_stmts = pa.combine_duplicates()
print('%d statements after combining duplicates.' % len(unique_stmts))
# Run BeliefEngine on unique statements
epe = BeliefEngine()
epe.set_prior_probs(pa.unique_stmts)
# Build statement hierarchy
related_stmts = pa.combine_related()
# Run BeliefEngine on hierarchy
epe.set_hierarchy_probs(related_stmts)
print('%d statements after combining related.' % len(related_stmts))
# Instantiate the mechanism linker
# Link statements
linked_stmts = MechLinker.infer_active_forms(related_stmts)
linked_stmts += MechLinker.infer_modifications(related_stmts)
linked_stmts += MechLinker.infer_activations(related_stmts)
# Run BeliefEngine on linked statements
epe.set_linked_probs(linked_stmts)
# Print linked statements for debugging purposes
print('Linked\n=====')
for ls in linked_stmts:
print(ls.inferred_stmt.belief, ls.inferred_stmt)
print('=============')
# Combine all statements including linked ones
all_statements = related_stmts + [ls.inferred_stmt for ls in linked_stmts]
# Instantiate a new preassembler
pa = Preassembler(bio_ontology, all_statements)
# Build hierarchy again
pa.combine_duplicates()
# Choose the top-level statements
related_stmts = pa.combine_related()
# Remove top-level statements that came only from the prior
if background_assertions is not None:
nonbg_stmts = [
stmt for stmt in related_stmts if stmt not in background_assertions
]
else:
nonbg_stmts = related_stmts
# Dump top-level statements in a pickle
with open(otherout_prefix + '.pkl', 'wb') as fh:
pickle.dump(nonbg_stmts, fh)
# Flatten evidence for statements
flattened_evidence_stmts = flatten_evidence(nonbg_stmts)
# Start a card counter
card_counter = 1
# We don't limit the number of cards reported in this round
card_lim = float('inf')
top_stmts = []
###############################################
# The belief cutoff for statements
belief_cutoff = 0.3
###############################################
# Sort by amount of evidence
for st in sorted(flattened_evidence_stmts,
key=lambda x: x.belief,
reverse=True):
if st.belief >= belief_cutoff:
print(st.belief, st)
if st.belief < belief_cutoff:
print('SKIP', st.belief, st)
# If it's background knowledge, we skip the statement
if is_background_knowledge(st):
print('This statement is background knowledge - skipping.')
continue
# Assemble IndexCards
ia = IndexCardAssembler([st], pmc_override=pmcid)
ia.make_model()
# If the index card was actually made
# (not all statements can be assembled into index cards to
# this is often not the case)
if ia.cards:
# Save the index card json
ia.save_model(indexcard_prefix + '-%d.json' % card_counter)
card_counter += 1
top_stmts.append(st)
if card_counter > card_lim:
break
# Print the English-assembled model for debugging purposes
ea = EnglishAssembler(top_stmts)
print('=======================')
print(ea.make_model().encode('utf-8'))
print('=======================')
# Print the statement graph
graph = render_stmt_graph(nonbg_stmts)
graph.draw(otherout_prefix + '_graph.pdf', prog='dot')
# Print statement diagnostics
print_stmts(pa.stmts, otherout_prefix + '_statements.tsv')
print_stmts(related_stmts, otherout_prefix + '_related_statements.tsv')
from indra.mechlinker import MechLinker
from indra.assemblers.english import EnglishAssembler
def print_linked_stmt(stmt):
source_txts = []
for source_stmt in stmt.source_stmts:
source_txt = EnglishAssembler([source_stmt]).make_model()
source_txts.append(source_txt)
query_txt = EnglishAssembler([stmt.inferred_stmt]).make_model()
final_txt = 'I know that '
for i, t in enumerate(source_txts):
final_txt += '(%d) %s ' % (i+1, t)
if i < len(source_txts) -1:
final_txt = final_txt[:-2] + ', and '
final_txt += 'Is it therefore true that ' + query_txt[:-1] + '?'
print(final_txt)
return final_txt
if __name__ == '__main__':
fname = 'models/rasmachine/rem/model.pkl'
model = IncrementalModel(fname)
model.preassemble()
stmts = model.assembled_stmts
linked_stmts = MechLinker.infer_active_forms(stmts)
linked_stmts += MechLinker.infer_modifications(stmts)
linked_stmts += MechLinker.infer_activations(stmts)
for stmt in linked_stmts:
print_linked_stmt(stmt)
def run_assembly(stmts, folder, pmcid, background_assertions=None):
'''Run assembly on a list of statements, for a given PMCID.'''
# Folder for index card output (scored submission)
indexcard_prefix = folder + '/index_cards/' + pmcid
# Folder for other outputs (for analysis, debugging)
otherout_prefix = folder + '/other_outputs/' + pmcid
# Do grounding mapping here
# Load the TRIPS-specific grounding map and add to the default
# (REACH-oriented) grounding map:
trips_gm = load_grounding_map('trips_grounding_map.csv')
default_grounding_map.update(trips_gm)
gm = GroundingMapper(default_grounding_map)
mapped_agent_stmts = gm.map_agents(stmts)
renamed_agent_stmts = gm.rename_agents(mapped_agent_stmts)
# Filter for grounding
grounded_stmts = []
for st in renamed_agent_stmts:
if all([is_protein_or_chemical(a) for a in st.agent_list()]):
grounded_stmts.append(st)
# Instantiate the Preassembler
pa = Preassembler(hierarchies)
pa.add_statements(grounded_stmts)
print('== %s ====================' % pmcid)
print('%d statements collected in total.' % len(pa.stmts))
# Combine duplicates
unique_stmts = pa.combine_duplicates()
print('%d statements after combining duplicates.' % len(unique_stmts))
# Run BeliefEngine on unique statements
epe = BeliefEngine()
epe.set_prior_probs(pa.unique_stmts)
# Build statement hierarchy
related_stmts = pa.combine_related()
# Run BeliefEngine on hierarchy
epe.set_hierarchy_probs(related_stmts)
print('%d statements after combining related.' % len(related_stmts))
# Instantiate the mechanism linker
# Link statements
linked_stmts = MechLinker.infer_active_forms(related_stmts)
linked_stmts += MechLinker.infer_modifications(related_stmts)
linked_stmts += MechLinker.infer_activations(related_stmts)
# Run BeliefEngine on linked statements
epe.set_linked_probs(linked_stmts)
# Print linked statements for debugging purposes
print('Linked\n=====')
for ls in linked_stmts:
print(ls.inferred_stmt.belief, ls.inferred_stmt)
print('=============')
# Combine all statements including linked ones
all_statements = related_stmts + [ls.inferred_stmt for ls in linked_stmts]
# Instantiate a new preassembler
pa = Preassembler(hierarchies, all_statements)
# Build hierarchy again
pa.combine_duplicates()
# Choose the top-level statements
related_stmts = pa.combine_related()
# Remove top-level statements that came only from the prior
if background_assertions is not None:
nonbg_stmts = [stmt for stmt in related_stmts
if stmt not in background_assertions]
else:
nonbg_stmts = related_stmts
# Dump top-level statements in a pickle
with open(otherout_prefix + '.pkl', 'wb') as fh:
pickle.dump(nonbg_stmts, fh)
# Flatten evidence for statements
flattened_evidence_stmts = flatten_evidence(nonbg_stmts)
# Start a card counter
card_counter = 1
# We don't limit the number of cards reported in this round
card_lim = float('inf')
top_stmts = []
###############################################
# The belief cutoff for statements
belief_cutoff = 0.3
###############################################
# Sort by amount of evidence
for st in sorted(flattened_evidence_stmts,
key=lambda x: x.belief, reverse=True):
if st.belief >= belief_cutoff:
print(st.belief, st)
if st.belief < belief_cutoff:
print('SKIP', st.belief, st)
# If it's background knowledge, we skip the statement
if is_background_knowledge(st):
print('This statement is background knowledge - skipping.')
continue
# Assemble IndexCards
ia = IndexCardAssembler([st], pmc_override=pmcid)
ia.make_model()
# If the index card was actually made
# (not all statements can be assembled into index cards to
# this is often not the case)
if ia.cards:
# Save the index card json
ia.save_model(indexcard_prefix + '-%d.json' % card_counter)
card_counter += 1
top_stmts.append(st)
if card_counter > card_lim:
break
# Print the English-assembled model for debugging purposes
ea = EnglishAssembler(top_stmts)
print('=======================')
print(ea.make_model().encode('utf-8'))
print('=======================')
# Print the statement graph
graph = render_stmt_graph(nonbg_stmts)
graph.draw(otherout_prefix + '_graph.pdf', prog='dot')
# Print statement diagnostics
print_stmts(pa.stmts, otherout_prefix + '_statements.tsv')
print_stmts(related_stmts, otherout_prefix + '_related_statements.tsv')
from indra.mechlinker import MechLinker
from indra.assemblers import EnglishAssembler
def print_linked_stmt(stmt):
source_txts = []
for source_stmt in stmt.source_stmts:
source_txt = EnglishAssembler([source_stmt]).make_model()
source_txts.append(source_txt)
query_txt = EnglishAssembler([stmt.inferred_stmt]).make_model()
final_txt = 'I know that '
for i, t in enumerate(source_txts):
final_txt += '(%d) %s ' % (i + 1, t)
if i < len(source_txts) - 1:
final_txt = final_txt[:-2] + ', and '
final_txt += 'Is it therefore true that ' + query_txt[:-1] + '?'
print(final_txt)
return final_txt
if __name__ == '__main__':
fname = 'models/rasmachine/rem/model.pkl'
model = IncrementalModel(fname)
model.preassemble()
stmts = model.assembled_stmts
linked_stmts = MechLinker.infer_active_forms(stmts)
linked_stmts += MechLinker.infer_modifications(stmts)
linked_stmts += MechLinker.infer_activations(stmts)
for stmt in linked_stmts:
print_linked_stmt(stmt)