def run_demo_suite(self, target, patientIDs, patientsDynamicEvidence):
#-- Set Up Reasoner
self.reasoner = Reasoner(self.bkb, None)
self.reasoner.set_src_metadata(self.patient_data_file)
self.reasoner.cpp_reasoning = False
#queryResults = list()
#probs = list()
#summaries = list()
for idx, patID in tqdm.tqdm(enumerate(patientIDs)):
queryResults = list()
probs = list()
summaries = list()
evs = list()
probOneState = ""
probOne = 1
probTwoState = ""
probTwo = 1
badGenes = list()
for patientDynamicEvidence in tqdm.tqdm(
patientsDynamicEvidence[idx]):
prob, summary = self.run_demo_only(target, patID,
patientDynamicEvidence)
evs.append(patientDynamicEvidence)
queryResults.append(patID)
probs.append(prob)
summaries.append(summary)
for i in range(0, len(queryResults)):
probOneState = probs[i][0][1]
probTwoState = probs[i][1][1]
one = float(probs[i][0][2])
two = float(probs[i][1][2])
print(target, evs[i])
print(probOneState, one, probTwoState, two,
"$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$")
print(summaries[i])
if one == -1 and two == -1:
print("")
elif one == -1 and two != -1:
two = 1.0
one = 0.0
elif one != -1 and two == -1:
one = 1.0
two = 0
else:
sum = one + two
one /= sum
two /= sum
if one != 0 and two != 0:
probOne *= one
probTwo *= two
sum = probOne + probTwo
probOne /= sum
probTwo /= sum
else:
badGenes.append(evs[i])
print(patID, "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@")
print(probOneState, probTwoState)
print(probOne, probTwo)
for badGene in badGenes:
print(badGene, end='', sep=', ')
def run_demo_only(self, target, patID, evidence):
#-- Set Up Reasoner
self.reasoner = Reasoner(self.bkb, None)
self.reasoner.set_src_metadata(self.patient_data_file)
self.reasoner.cpp_reasoning = False
#print(evidence)
#print([target])
#-- Make query and analyze
query = Query(evidence=evidence,
targets=[],
meta_evidence=[],
meta_targets=[target],
type='updating')
probs = list()
if self.first:
query = self.reasoner.analyze_query(copy.deepcopy(query), save_dir=None)
self.processed_bkb = copy.deepcopy(query.bkb)
self.first = False
#query.result.summary()
for update, prob in query.result.updates.items():
comp_idx, state_idx = update
comp_name = query.bkb.getComponentName(comp_idx)
state_name = query.bkb.getComponentINodeName(comp_idx, state_idx)
probs.append((comp_name, state_name, prob))
else:
query = self.reasoner.analyze_query(copy.deepcopy(query), preprocessed_bkb=self.processed_bkb)
#query.result.summary()
for update, prob in query.result.updates.items():
comp_idx, state_idx = update
comp_name = query.bkb.getComponentName(comp_idx)
state_name = query.bkb.getComponentINodeName(comp_idx, state_idx)
probs.append((comp_name, state_name, prob))
return probs
def run_demo_only(self,
demo_target,
demo_evidence_static=list(),
demo_evidence_dynamic=list(),
demo_evidence_val=0):
#-- Set Up Reasoner
reasoner = Reasoner(self.bkb, None)
reasoner.set_src_metadata(self.patient_data_file)
reasoner.cpp_reasoning = False
#-- Initialize Result dict
result = {'X': demo_evidence_val, 'Compute_time': -1}
#-- Setup demographic evidence tuple
if len(demo_evidence_dynamic) > 0:
demo_evidence_dynamic_run = [
tuple(list(demo_evidence_dynamic) + [demo_evidence_val])
]
demo_evidence_run = demo_evidence_static + demo_evidence_dynamic_run
#-- Make query and analyze
query = Query(meta_evidence=demo_evidence_run,
meta_targets=[demo_target],
type='updating')
query = reasoner.analyze_query(copy.deepcopy(query), save_dir=None)
result['Compute_time'] = query.compute_time
#-- Collect Updates and put into results
for update, prob in query.result.updates.items():
comp_idx, state_idx = update
comp_name = query.bkb.getComponentName(comp_idx)
state_name = query.bkb.getComponentINodeName(comp_idx, state_idx)
result[('Updates', comp_name, state_name)] = prob
return result
def run_demo_suite(self, target, patientIDs, patientsMutationEvidence):
#-- Set Up Reasoner
self.reasoner = Reasoner(self.bkb, None)
self.reasoner.set_src_metadata(self.patient_data_file)
self.reasoner.cpp_reasoning = False
holdoutResults = list()
for idx, patID in tqdm.tqdm(enumerate(patientIDs)):
probs = list()
for mutationDrugEvidence in patientsMutationEvidence[idx]:
prob = self.run_demo_only(target, patID, mutationDrugEvidence)
probs.append(prob)
print(patID)
print(probs)
probOne = 1.0
probTwo = 1.0
for prob in probs:
sumProbs = prob[0][2] + prob[1][2]
probOne *= (prob[0][2] / sumProbs)
probTwo *= (prob[1][2] / sumProbs)
sumProbs = probOne + probTwo
probOne /= sumProbs
probTwo /= sumProbs
prob = list()
prob.append((probs[0][0], probs[0][1], probOne))
prob.append((probs[1][0], probs[1][1], probTwo))
holdoutResults.append((prob[0], prob[1]))
self.getResults(target, holdoutResults, patientIDs)
def run(self, args, atomspace):
print 'Received request inference ' + str(args)
bio = Bio(atomspace)
#bio.atomspace = bio.a = atomspace
r = Reasoner(atomspace)
r.do_one_steps(*args)
def run_demo_suite(self, target, patientIDs, patientsMutationVariantEvidence):
#-- Set Up Reasoner
self.reasoner = Reasoner(self.bkb, None)
self.reasoner.set_src_metadata(self.patient_data_file)
self.reasoner.cpp_reasoning = False
holdoutResults = list()
for idx, patID in tqdm.tqdm(enumerate(patientIDs)):
prob = self.run_demo_only(target, patID, patientsMutationVariantEvidence[idx])
holdoutResults.append((prob[0],prob[1]))
self.getResults(target, holdoutResults, patientIDs)
def __init__(self, config_file):
#-- Read in configuration from config file.
self.config = dict()
with open(config_file, 'r') as csv_file:
reader = csv.reader(csv_file)
for row in reader:
self.config[row[0]] = row[1]
self.fused_bkb_path = self.config['fused_bkb_path']
self.ncats_dir = self.config['ncats_dir']
self.src_metadata_path = self.config['src_metadata_path']
self.fused_bkb = BKB()
self.fused_bkb.load(self.fused_bkb_path)
self.reasoner = Reasoner(self.fused_bkb, None)
self.reasoner.set_src_metadata(self.src_metadata_path)
def __init__(self):
self.gateway = JavaGateway()
self.italian_lexicon = self.gateway.jvm.simplenlg.lexicon.italian.ITXMLLexicon(
)
self.italian_factory = self.gateway.jvm.simplenlg.framework.NLGFactory(
self.italian_lexicon)
self.realiser = self.gateway.jvm.simplenlg.realiser.Realiser()
self.word_translator = WordTanslator(language_from=Languages.ENGLISH,
language_to=Languages.ITALIAN)
self.features = self.gateway.jvm.simplenlg.features
self.Feature = self.gateway.jvm.simplenlg.features.Feature
self.Tense = self.gateway.jvm.simplenlg.features.Tense
self.Gender = self.gateway.jvm.simplenlg.features.Gender
self.reasoner = Reasoner()
self.parser = load_parser('simple-sem.fcfg', trace=0)
#-- Initalize a BKB
fused_bkb = BKB()
#-- Load in the fused bkb from our datafiles
fused_bkb.load(
'/home/public/data/ncats/AxleBKBS/AxleDemoBKB3-14-20/fusion.bkb')
#-- Here are the associated patient data files
patient_data_file = '/home/public/data/ncats/AxleBKBS/AxleDemoBKB3-14-20/patient_data.pk'
withheld_patients_file = '/home/public/data/ncats/AxleBKBS/AxleDemoBKB3-14-20/withheldPatients.csv'
gene_var_direct_file = '/home/public/data/ncats/AxleBKBS/AxleDemoBKB3-14-20/geneFreqAnal.csv'
#-- Instaniate reasoner
reasoner = Reasoner(fused_bkb=fused_bkb,
gene_var_direct=gene_var_direct_file,
max_new_ev=2)
#-- Set the patient data file
reasoner.set_src_metadata(patient_data_file)
#reasoner.collapsed_bkb.makeGraph()
#-- If you want to see what genetic or demographic evidence is avaliable, uncomment the line below
#print(reasoner.metadata_ranges)
#-- Make a query (evidence is for genetic info, and meta_ is for demographic info)
query0 = Query(name='sample_independ',
evidence={
"var_5'FLANK=": "True",
"var_3'UTR=": "True"
},
bkfs = patient_bkfs + pathway_bkfs
source_names = [str(hash(patient)) for patient in PATIENTS] + PATHWAYS
#-- Fuse patients together.
fused_bkb = fuse(bkfs, [1 for _ in range(len(source_names))],
source_names,
working_dir=os.getcwd())
#fused_bkb.makeGraph(layout='neato')
print(counts)
for gene in GENES:
print('=' * 20 + str(' No Connection:'))
#-- Instantiate Reasoner
fused_bkb_ = copy.deepcopy(fused_bkb)
reasoner = Reasoner(fused_bkb_, None)
reasoner.metadata = patient_data_hash
#-- Make query
query1 = Query(evidence={gene_: 'True'
for gene_ in [GENES[0], GENES[2]]},
targets=['_Source_[{}]_'.format(gene) for gene in GENES],
type='updating')
query1 = reasoner.analyze_query(query1)
query1.getReport()
query1.bkb._name = 'No Connection'
#query1.bkb.makeGraph(layout='neato')
#-- Structure Learn
fused_bkb_1 = copy.deepcopy(fused_bkb_)
[str(hash(patient)) for patient in PATIENTS],
working_dir=os.getcwd())
#fused_bkb.makeGraph(layout='neato')
#col_bkb = collapse_sources(fused_bkb)
#col_bkb.makeGraph(layout='neato')
patient_data_hash = dict()
for patient, dict_ in patient_data.items():
patient_data_hash[hash(patient)] = dict_
print(patient_data)
#-- Denote Demographic evidence.
demo_ev = [('Age', '>=', 50), ('Gender', '==', 'Male')]
demo_tar = [('Survival', '>=', 2)]
reasoner = Reasoner(fused_bkb, patient_data_hash)
query0 = Query(evidence=dict(),
targets=list(),
meta_evidence=demo_ev,
meta_targets=demo_tar,
type='updating')
query0 = reasoner.analyze_query(query0, target_strategy='topological')
query0.getReport()
print(checkMutex(query0.bkb))
query0.bkb.makeGraph()
import os
import sys
from pybkb import bayesianKnowledgeBase as BKB
#-- Change to your local data folder
NCATS_DIR = '/home/cyakaboski/src/python/pojects/bkb-pathway-provider'
sys.path.append(os.path.join(NCATS_DIR, 'core'))
from query import Query
from reasoner import Reasoner
if __name__ == '__main__':
bkb = BKB()
bkb.load('/home/public/data/ncats/fusedPatientBKBSmall/fusion.bkb')
reasoner = Reasoner(bkb)
query0 = Query(evidence={
'_sourceFusion_14_02_2020_16:35:04__mut_CACNA1H=':
'[0]_-7750956075882572850'
},
targets=['mut_CACNA1H=', 'mu-STD>=CACNA1H<=mu+STD='],
type='updating')
result = reasoner.analyze_query(query0)
def __init__(self, cfg):
super(GenericModel, self).__init__()
self.cfg = cfg
self.embedder = Embedder(cfg['embedder'])
self.reasoner = Reasoner(cfg['reasoner'])
# rand_rv = random.choice(bkb.components)
# #-- Get a random state
# rand_state = random.choice(rand_rv.states)
# evidence[rand_rv.name] = rand_state.name
#print('Got Evidence')
##-- Select Random Targets
#num_targets = 2
#targets = list()
#for _ in range(num_targets):
# rand_target = random.choice(bkb.components)
# while rand_target.name in targets or rand_target.name[:3] != 'mut':
# rand_target = random.choice(bkb.components)
# targets.append(rand_target.name)
#print('Got Targets')
reasoner = Reasoner(bkb, None)
reasoner.set_src_metadata(os.path.join(NCATS_DIR,'core','src_dict.pik'))
query0 = Query(evidence=dict(),
#targets=targets,
type='revision',
meta_evidence=[('Age_of_Diagnosis', '>=', 15000),
('Gender', '==', 'FEMALE')]
)
query0 = reasoner.analyze_query(query0)
query0.getReport()
def run_patients(self,
demo_target,
gene_evidence=False,
demo_evidence=None,
demo_value=0):
reasoner = Reasoner(self.bkb, None)
reasoner.set_src_metadata(self.patient_data_file)
reasoner.cpp_reasoning = False
#-- Comment this out for real thing
#self.test_patient_hashes = [list(reasoner.metadata.keys())[0]]
target_actual = '{} {} {} Actual'.format(demo_target[0],
demo_target[1],
demo_target[2])
results = {
'X':
[demo_value for _ in range(len(self.test_patient_hashes[:10]))],
'Patient': list(),
'Compute_time': list(),
'Length_evid': list(),
target_actual: list()
}
if gene_evidence is False and demo_evidence is None:
raise ValueError('Gene and demo evidence can not be None.')
if demo_evidence is not None:
title = 'Evidence = {} {} X'.format(demo_evidence[0],
demo_evidence[1])
demo_evidence_run = [tuple(list(demo_evidence) + [demo_value])]
for patient_hash in tqdm.tqdm(self.test_patient_hashes[:10]):
results['Patient'].append(patient_hash)
#-- Calculate Truth
prop_targ, op_targ, val_targ = demo_target
op_ = _process_operator(op_targ)
results[target_actual].append(
op_(reasoner.metadata[patient_hash][prop_targ], val_targ))
if gene_evidence:
gene_evidence_patient = {
gene: 'True'
for gene in patient_data[patient_hash]['Patient_Genes']
}
title += ' w/ GeneEvidence'
else:
title += ' w/o GeneEvidence'
gene_evidence_patient = dict()
#-- Make query
query = Query(evidence=gene_evidence_patient,
meta_evidence=demo_evidence_run,
meta_targets=[demo_target],
type='updating')
query = reasoner.analyze_query(copy.deepcopy(query),
save_dir=None)
results['Length_evid'].append(len(query.evidence))
results['Compute_time'].append(query.compute_time)
for update, prob in query.result.updates.items():
comp_idx, state_idx = update
comp_name = query.bkb.getComponentName(comp_idx)
state_name = query.bkb.getComponentINodeName(
comp_idx, state_idx)
try:
results[('Updates', comp_name,
state_name)].append(prob)
except:
results[('Updates', comp_name, state_name)] = [prob]
else:
title = 'No Demographic Evidence w/ Gene Evidence'
for i, patient_hash in enumerate(self.test_patient_hashes[:10]):
results['Patient'].append(patient_hash)
#-- Calculate Truth
prop_targ, op_targ, val_targ = demo_target
op_ = _process_operator(op_targ)
#-- Calculate Truth
results[target_actual].append(
op_(reasoner.metadata[patient_hash][prop_targ], val_targ))
#-- Take intersection between all bkb genes and patient genes
print('Intersecting genes')
genes_patient = set([
'mut_{}='.format(gene) for gene in
reasoner.metadata[patient_hash]['Patient_Genes']
])
bkb_comps = set(self.bkb.getAllComponentNames())
gene_intersect = genes_patient.intersection(bkb_comps)
gene_evidence_patient = {
gene: 'True'
for gene in gene_intersect
}
#print(set(gene_evidence_patient.keys()) - set(self.bkb.getAllComponentNames()))
#-- Make query
#print(gene_evidence_patient)
results['Length_evid'].append(len(gene_evidence_patient))
query = Query(evidence=gene_evidence_patient,
meta_targets=[demo_target],
type='updating',
name='Pat50-10_600_{}'.format(i))
print('Analyzing Query.')
query = reasoner.analyze_query(copy.deepcopy(query),
save_dir=None)
query.getReport()
results['Compute_time'].append(query.compute_time)
for update, prob in query.result.updates.items():
comp_idx, state_idx = update
comp_name = query.bkb.getComponentName(comp_idx)
state_name = query.bkb.getComponentINodeName(
comp_idx, state_idx)
try:
results[('Updates', comp_name,
state_name)].append(prob)
except:
results[('Updates', comp_name, state_name)] = [prob]
del query
print('Complete Patient {}.'.format(i))
return self.results_to_dataframe(results), title
from reasoner import Reasoner
from query import Query
#-- Initalize a BKB
fused_bkb = BKB()
#-- Load in the fused bkb from our datafiles
fused_bkb.load(
'/home/public/data/ncats/AxleBKBS/660Pats6HoldoutSTAGING/fusion.bkb')
#-- Here are the associated patient data files
patient_data_file = '/home/public/data/ncats/AxleBKBS/660Pats6HoldoutSTAGING/patient_data.pk'
withheld_patients_file = '/home/public/data/ncats/AxleBKBS/660Pats6HoldoutSTAGING/withheldPatients.csv'
#-- Instaniate reasoner
reasoner = Reasoner(fused_bkb=fused_bkb)
#-- Set the patient data file
reasoner.set_src_metadata(patient_data_file)
#reasoner.collapsed_bkb.makeGraph()
#-- If you want to see what genetic or demographic evidence is avaliable, uncomment the line below
#print(reasoner.metadata_ranges)
'''
#-- Make a query (evidence is for genetic info, and meta_ is for demographic info)
query0 = Query(evidence={'mut_TMEM245=': 'True'},
targets=list(),
meta_evidence=[('Age_of_Diagnosis', '>=',20000)],
meta_targets=[('Survival_Time', '>=', 300)])
#-- Run the query.
os.path.join("mappings",
args.country + "-" + args.flavor + ".json"),
args.globalmap, args.instance
]
#print files
files = map(path.isfile, files)
#print files
if all(files):
from reasoner import Reasoner
a = Reasoner(os.path.join("countries", args.country, "flow.json"),
local_map=os.path.join("countries", args.country,
"local.json"),
flavor_map=os.path.join("flavours", args.flavor,
"local.json"),
global_map=args.globalmap,
mapping=os.path.join(
"mappings",
args.country + "-" + args.flavor + ".json"),
detail=args.detail,
output=args.output,
language=os.path.join("countries", args.country,
"i18n",
args.language + ".json"))
a.parse_input(args.instance)
a.info()
if args.query is None:
a.run()
else:
a.query(args.query)
print a.get_result()
if args.mode == "url":
def _get_input(self, scene):
self.N, self.target, self.possible_situation = self._preprocess(scene)
self.length = 5
self.reasoner = Reasoner(self.N)
self.PO = self._get_po()
from flask_socketio import SocketIO
from uploader import Ontology
import roslibpy
from reasoner import Reasoner
app = Flask(__name__)
# Initialize SocketIO
socketio = SocketIO(app)
KnowledgeBase = Ontology()
# Connect with ROS
client = roslibpy.Ros(host='localhost', port=9090)
client.run()
reasoner = Reasoner(client)
camera_scan = reasoner.camera_scan
robot_move = reasoner.robot_move
gripper_grasp = reasoner.gripper_grasp
@app.route('/')
def index():
return render_template('tasks.html')
@socketio.on('refresh_data')
def load_data():
data = KnowledgeBase.get_instances()
if data:
for i in data:
import os
import sys
import pickle
sys.path.append('/home/cyakaboski/src/python/projects/bkb-pathway-provider/core')
from reasoner import Reasoner
from query import Query
from pybkb.core.common.bayesianKnowledgeBase import bayesianKnowledgeBase as BKB
#-- Load fused bkb
fused_bkb = BKB()
fused_bkb.load('10PatientFusion.bkb')
#-- Instantiate Reasoner
reasoner = Reasoner(fused_bkb, None)
reasoner.set_src_metadata('patient_data.pk')
#print(reasoner.metadata)
#-- Make query
query1 = Query(evidence=dict(),
targets=list(),
meta_evidence=[('Age_of_Diagnosis','>=', 20000)],
meta_targets=[('Survival_Time', '>=', 500)],
type='updating')
query1 = reasoner.analyze_query(query1)
query1.getReport()
query1.bkb.makeGraph()
'Survival': random.randrange(SURIVAL_YRS[0], SURIVAL_YRS[1])
}
for patient in PATIENTS
}
patient_data_hash = dict()
for patient, dict_ in patient_data.items():
patient_data_hash[hash(patient)] = dict_
print(patient_data)
#-- Denote Demographic evidence.
demo_ev = [('Age', '>=', 50), ('Gender', '==', 'Male')]
demo_tar = [('Survival', '>=', 2)]
reasoner1 = Reasoner(fused_bkb, None)
reasoner1.metadata = patient_data_hash
reasoner1.cpp_reasoning = True
reasoner2 = Reasoner(fused_bkb_wStruct, None)
reasoner2.metadata = patient_data_hash
reasoner2.cpp_reasoning = True
query0 = Query(
evidence={'Gene{}_mutated'.format(i): 'True'
for i in range(NUM_GENES)},
targets=list(),
meta_evidence=demo_ev,
meta_targets=demo_tar,
type='updating')