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
geneNames=geneDicts[0].keys()
for node in graph.nodes():
if node in geneNames:
print(node)
else:
print(node)
for k in range(10):
q=randint(0,len(geneNames)-1)
geneDicts[k][str.upper(node)]=geneDicts[k][geneNames[q]]
for j in range(10):
sampleLists[k][j][str.upper(node)]=sampleLists[k][j][str.upper(geneNames[q])]
print([sampleLists[k][j][str.upper(node)] for j in range(10)])
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
# print(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][str.upper(node)]=min(max(0,sampleLists[j][i+5][str.upper(node)]*(perturbationSize)),1)
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 simTest():
sampleList, geneDict, cvDict = readFpkmData('testInput.txt', '\t')
with open('testRules.txt') as csvfile:
model, individual, graph = makeModelRules(csvfile.readlines(),
sss=sampleList,
equal_sign='=')
boolValues1 = genInitValueList(sampleList, model)
boolValues2 = []
updateBooler = cdll.LoadLibrary('./simulator.so')
boolC = updateBooler.syncBool
params = sim.paramClass()
model.initValueList = boolValues1
model.updateCpointers()
KOs, KIs = setupEmptyKOKI(len(sampleList))
for j in range(len(boolValues1)):
boolValues2.append(
sim.NPsync(individual, model, params.cells, boolValues1[j], params,
KOs[j], KIs[j], boolC, True))
print(boolValues2)
sampleList3, geneDict3, cvDict3 = readFpkmData('testOutput.txt', '\t')
boolValues3 = genInitValueList(sampleList3, model)
print(boolValues3)
print(boolValues3 == boolValues2)
def RPKNnoiseTester(graph, name, noiseNum): # runs experiment using graph and rule from Liu et al. 2016 along with additional false positive edges # loop over number of times we want to generate fake data and perform sequence of events params=sim.paramClass() # load in parameters noiseEdges=findRPKNnoise(noiseNum) runExperiment(graph, name, params.samples, 0. , noiseEdges, params)
def omicsNoiseTester(graph, name, noise): params=sim.paramClass() # load in parameters runExperiment(graph, name, params.samples, noise,0, params)
def sampleTester(graph, name, sampleNum): samples=findSamples(sampleNum) params=sim.paramClass() # load in parameters runExperiment(graph, name, samples, 0., 0, params)
def sampleTester(graph, name, samples):
params = sim.paramClass() # load in parameters
runExperiment(graph, name, samples, 0., 0, params)
parser.add_argument("iterNum")
results = parser.parse_args()
graphName=results.graph
iterNum=int(results.iterNum)
name=graphName[:-8]+'_'+results.iterNum
graph = nx.read_gpickle(graphName)
# read in C function to run simulations
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
for x in graph.in_degree():
if x > 1:
checker = True
if (checker):
nx.write_graphml(graph, coder + '.graphml')
nx.write_gpickle(graph, coder + '.gpickle')
graph = simplifyNetworkMod(graph)
nx.write_graphml(graph, coder + '_red.graphml')
nx.write_gpickle(graph, coder + '_red.gpickle')
graph = mc.cutMotifs(graph)
nx.write_graphml(graph, coder + '_cut.graphml')
nx.write_gpickle(graph, coder + '_cut.gpickle')
print(coder)
codelist.append(coder)
if __name__ == '__main__':
params = sim.paramClass()
ifngStimTestSetup(params)
# # graph=nx.DiGraph()
# # coder=str('ko'+code[:-1])
# # nc.uploadKEGGcodes([coder], graph, dict2)
# # coder=str('hsa'+code[:-1])
# # nc.uploadKEGGcodes_hsa([coder], graph,dict1, dict2)
# # if(len(graph.edges())>1):
# # graph=nc.simplifyNetwork(graph, data)
# #graph = simpleNetBuild()
# graph=liu.LiuNetwork1Builder()
# # coder='liu'
