def PAtester(graph, name):
controls=5
experimentals=5
true=10
false=true
params=sim.paramClass()
sampleLists,geneDicts= [],[]
# import starting points
for i in range(1,11):
sampleList, geneDict=readFpkmData2('neg_binom_gen_'+str(i)+'.csv', ',') # read in data
sampleLists.append(sampleList)
geneDicts.append(geneDict)
knockoutLists, knockinLists= setupEmptyKOKI(len(sampleList))
updateBooler=cdll.LoadLibrary('./simulator.so')
boolC=updateBooler.syncBool
for j in range(10): # iterate over imported starting points
model= sim.modelClass(graph,sampleLists[j], True)
rule=ga.genBits(model)
newInitValueList=genInitValueList(sampleLists[j],model)
model.initValueList=newInitValueList
model.updateCpointers()
output=[sim.NPsync(rule[1], model, params.cells, newInitValueList[k], params, knockinLists[k], knockoutLists[k], boolC) for k in range(5)]
controlSampleList=compileOuts(output,sampleLists[j], controls, model)
# generate model
# loop over number of times we want to generate fake data and perform sequence of events
# generate Boolean model for this trial
genelist=geneDicts[j].keys()
for perturbation in [0,5,10,15,20]:
tSampleList=list(sampleLists[j][5:10])
perturbationSize=2.**(-.1*perturbation)
for i in range(5):
# generate values across samples
for node in graph.nodes():
if len(graph.predecessors(node))==0:
tSampleList[i][node]=min(max(0,sampleLists[j][i+5][node]*(perturbationSize)),1)
newInitValueList=genInitValueList(tSampleList,model)
newout=[sim.NPsync(rule[1], model, params.cells, newInitValueList[k], params, knockinLists[k], knockoutLists[k], boolC) for k in range(5)]
tSampleList=compileOuts(newout,tSampleList, experimentals, model)
outputData(controlSampleList, tSampleList, genelist,name+str(perturbation)+'_true_'+str(j)+'.csv', geneDicts[j])
def transformTest(graph, name, fileName):
# can't fit a rule to only one node
if len(graph.nodes()) < 2:
print('not enough overlap')
return
# load in C function
#updateBooler=ctypes.cdll.LoadLibrary('./testRun.so')
updateBooler = cdll.LoadLibrary('./testRun.so')
boolC = updateBooler.syncBool
# load data, params, make empty knockout and knockin lists (no KO or KI in transform tests)
sampleDict = constructBinInput(fileName)
params = sim.paramClass()
# generate turn sample dict into sample list (list of dicts instead of dict of lists)
keyList = sampleDict.keys()
sampleList = [{} for i in range(len(sampleDict[keyList[0]]))]
for i in range(len(sampleList)):
for key in keyList:
if key in graph.nodes():
sampleList[i][key] = sampleDict[key][i]
knockoutLists, knockinLists = setupEmptyKOKI(len(sampleList))
# generate model encompassing graph and samples to do rule inference on
model = sim.modelClass(graph, sampleList, False)
model.updateCpointers()
# cpy data into correct order for simulation
newInitValueList = genInitValueList(sampleList, model)
model.initValueList = newInitValueList
print('setup successful')
# find the rules
model, dev1, bruteOut = ga.GAsearchModel(model, sampleList, params,
knockoutLists, knockinLists, name,
boolC)
bruteOut, equivalents, dev2 = ga.localSearch(model, bruteOut, sampleList,
params, knockoutLists,
knockinLists, boolC)
pickle.dump([[dev1], [dev2], [bruteOut], [model]],
open(name + "_output.pickle", "wb"))
def GAsearchModel(model, sampleList, params, KOlist, KIlist, namer, boolC):
newInitValueList = genInitValueList(sampleList,
model) # set up initial value list
model.initValueList = newInitValueList # append initial value list to model
toolbox, stats = buildToolbox(model.size, params.bitFlipProb, model,
params) # set up toolbox
# run GA, find best in population, return
population, logbook = eaMuPlusLambdaAdaptive(toolbox,
model,
mu=params.mu,
lambda_=params.lambd,
stats=stats,
cxpb=params.crossoverProb,
mutpb=params.mutationProb,
ngen=params.generations,
namer=namer,
newSSS=sampleList,
KOlist=KOlist,
KIlist=KIlist,
params=params,
verbose=params.verbose,
boolC=boolC)
out1, out2, model = findPopBest(population)
return model, out1, out2
def runExperiment(graph, name, samples, noise, edgeNoise, params):
#creates a model, runs simulations, then tests reverse engineering capabilities of models in a single function
#samples is the number of different initial conditions to provide per trial
#graph specifies the network we are testing.
# does everything except params
# load in C function
#updateBooler=ctypes.cdll.LoadLibrary('./testRun.so')
updateBooler=cdll.LoadLibrary('./testRun.so')
boolC=updateBooler.syncBool
params.sample=samples
sampleList=synthesizeInputs(graph,samples) # get empty list of inputs
model=sim.modelClass(graph,sampleList, True) # generate empty model
model.updateCpointers()
individual=ga.genBits(model) #generate random set of logic rules to start with
if edgeNoise > 0:
individual[1]= [0,1,1,1,1,1,0,0,1,0,1,1,1]
initModel=[(model.size), list(model.nodeList), list(model.individualParse), list(model.andNodeList) , list(model.andNodeInvertList), list(model.andLenList), list(model.nodeList), dict(model.nodeDict), list(model.initValueList)]
knockoutLists, knockinLists= setupEmptyKOKI(samples)
# generate some simulated samples
output=ga.runProbabilityBooleanSims(individual[1], model, samples, params.cells, params, knockoutLists, knockinLists, boolC)
# add noise in omics data
if noise>0:
multiplier=findNoiseValue(noise)
for sample in output:
for i in range(len(sample)):
sample[i]=min(max(0,sample[i]+multiplier*(random()*2-1)),1)
# add noise in RPKN
if edgeNoise > 0:
newgraph=graph.copy()
edgelist=newgraph.edges()
nodelist=newgraph.nodes()
for newer in range(edgeNoise): # add edgeNoise FP edges
rand1=randint(0,len(nodelist)-1)
rand2=randint(0,len(nodelist)-1)
edgeCandidate=(nodelist[rand1],nodelist[rand2])
while edgeCandidate in edgelist or edgeCandidate[0]==edgeCandidate[1]:
rand1=randint(0,len(nodelist)-1)
rand2=randint(0,len(nodelist)-1)
edgeCandidate=(nodelist[rand1],nodelist[rand2])
if random()<.5:
activity1='a'
else:
activity1='i'
print(edgeCandidate)
newgraph.add_edge(nodelist[rand1],nodelist[rand2], signal=activity1)
edgelist.append((nodelist[rand1],nodelist[rand2]))
print(edgelist)
print(newgraph.edges())
else:
newgraph=graph
# output the initial generated data
pickle.dump( output, open( name+"_input.pickle", "wb" ) )
# copy simulated data into right format
newSampleList=genSampleList(output, sampleList, samples, model)
testModel=sim.modelClass(newgraph,newSampleList, False)
testModel.updateCpointers()
# put initial values into correct format, add to model
newInitValueList=genInitValueList(newSampleList,testModel)
testModel.initValueList=newInitValueList
#find rules
testModel, dev, bruteOut =ga.GAsearchModel(testModel, newSampleList, params, knockoutLists, knockinLists, name, boolC) # run GA
bruteOut, equivalents, dev2 = ga.localSearch(testModel, bruteOut, newSampleList, params, knockoutLists, knockinLists, boolC) # run local search
storeModel3=[(testModel.size), list(testModel.nodeList), list(testModel.individualParse), list(testModel.andNodeList) , list(testModel.andNodeInvertList), list(testModel.andLenList), list(testModel.nodeList), dict(testModel.nodeDict), list(testModel.initValueList)]
outputList=[individual[1],bruteOut,initModel, storeModel3, equivalents, dev2]
pickle.dump( outputList, open( name+"_local1.pickle", "wb" ) )
updateBooler=cdll.LoadLibrary('./simulator.so')
boolC=updateBooler.syncBool
# load data
sampleList=pickle.Unpickler(open( graphName[:-8]+'_sss.pickle', "rb" )).load()
# set up parameters of run, model
params=paramClass()
model=modelClass(graph,sampleList, False)
model.updateCpointers()
storeModel=[(model.size), list(model.nodeList), list(model.individualParse), list(model.andNodeList) , list(model.andNodeInvertList), list(model.andLenList), list(model.nodeList), dict(model.nodeDict), list(model.initValueList)]
# put lack of KOs, initial values into correct format
knockoutLists, knockinLists= setupEmptyKOKI(len(sampleList))
newInitValueList=genInitValueList(sampleList,model)
model.initValueList=newInitValueList
# find rules by doing GA then local search
model1, dev, bruteOut =GAsearchModel(model, sampleList, params, knockoutLists, knockinLists, name, boolC) # run GA
bruteOut1, equivalents, dev2 = localSearch(model1, bruteOut, sampleList, params, knockoutLists, knockinLists, boolC) # run local search
# output results
storeModel3=[(model.size), list(model.nodeList), list(model.individualParse), list(model.andNodeList) , list(model.andNodeInvertList), list(model.andLenList), list(model.nodeList), dict(model.nodeDict), list(model.initValueList)]
outputList=[bruteOut1,dev,storeModel, storeModel3, equivalents, dev2]
pickle.dump( outputList, open( name+"_local1.pickle", "wb" ) ) # output rules
# calculate importance scores and output
scores1=calcImportance(bruteOut1,params,model1, sampleList,knockoutLists, knockinLists, boolC)
pickle.dump( scores1, open( name+"_scores1.pickle", "wb" ) )
