def test_fluxes_2():
# depends on tpt.committors
bmsm = BayesianMarkovStateModel(lag_time=1)
assignments = np.random.randint(3, size=(10, 1000))
bmsm.fit(assignments)
# forward committors
qplus = tpt.committors(0, 2, bmsm)
ref_fluxes = np.zeros((3, 3))
ref_net_fluxes = np.zeros((3, 3))
for el in zip(bmsm.all_populations_, bmsm.all_transmats_):
pop = el[0]
tprob = el[1]
for i in range(3):
for j in range(3):
if i != j:
# Eq. 2.24 in Metzner et al. Transition Path Theory.
# Multiscale Model. Simul. 2009, 7, 1192-1219.
ref_fluxes[i, j] += (pop[i] * tprob[i, j] *
(1 - qplus[i]) * qplus[j])
ref_fluxes /= 100.
for i in range(3):
for j in range(3):
ref_net_fluxes[i, j] = np.max([0, ref_fluxes[i, j] -
ref_fluxes[j, i]])
fluxes = tpt.fluxes(0, 2, bmsm)
net_fluxes = tpt.net_fluxes(0, 2, bmsm)
npt.assert_array_almost_equal(ref_fluxes, fluxes, decimal=2)
npt.assert_array_almost_equal(ref_net_fluxes, net_fluxes, decimal=2)
def test_harder_hubscore():
# depends on tpt.committors and tpt.conditional_committors
assignments = np.random.randint(10, size=(10, 1000))
msm = MarkovStateModel(lag_time=1)
msm.fit(assignments)
hub_scores = tpt.hub_scores(msm)
ref_hub_scores = np.zeros(10)
for A in range(10):
for B in range(10):
committors = tpt.committors(A, B, msm)
denom = msm.transmat_[A, :].dot(committors)
for C in range(10):
if A == B or A == C or B == C:
continue
cond_committors = tpt.conditional_committors(A, B, C, msm)
temp = 0.0
for i in range(10):
if i in [A, B]:
continue
temp += cond_committors[i] * msm.transmat_[A, i]
temp /= denom
ref_hub_scores[C] += temp
ref_hub_scores /= (9 * 8)
npt.assert_array_almost_equal(ref_hub_scores, hub_scores)
def test_cond_committors():
# depends on tpt.committors
msm = MarkovStateModel(lag_time=1)
assignments = np.random.randint(4, size=(10, 1000))
msm.fit(assignments)
tprob = msm.transmat_
for_committors = tpt.committors(0, 3, msm)
cond_committors = tpt.conditional_committors(0, 3, 2, msm)
# The committor for state one can be decomposed into paths that
# do and do not visit state 2 along the way. The paths that do not
# visit state 1 must look like 1, 1, 1, ..., 1, 1, 3. So we can
# compute them with a similar approximation as the forward committor
# Since we want the other component of the forward committor, we
# subtract that probability from the forward committor
ref = for_committors[1] - np.power(tprob[1, 1],
np.arange(5000)).sum() * tprob[1, 3]
#print (ref / for_committors[1])
ref = [0, ref, for_committors[2], 0]
#print(cond_committors, ref)
npt.assert_array_almost_equal(ref, cond_committors)
def test_fluxes_1():
# depends on tpt.committors
msm = MarkovStateModel(lag_time=1)
assignments = np.random.randint(3, size=(10, 1000))
msm.fit(assignments)
tprob = msm.transmat_
pop = msm.populations_
# forward committors
qplus = tpt.committors(0, 2, msm)
ref_fluxes = np.zeros((3, 3))
ref_net_fluxes = np.zeros((3, 3))
for i in range(3):
for j in range(3):
if i != j:
# Eq. 2.24 in Metzner et al. Transition Path Theory.
# Multiscale Model. Simul. 2009, 7, 1192-1219.
ref_fluxes[i, j] = (pop[i] * tprob[i, j] *
(1 - qplus[i]) * qplus[j])
for i in range(3):
for j in range(3):
ref_net_fluxes[i, j] = np.max([0, ref_fluxes[i, j] -
ref_fluxes[j, i]])
fluxes = tpt.fluxes(0, 2, msm)
net_fluxes = tpt.net_fluxes(0, 2, msm)
npt.assert_array_almost_equal(ref_fluxes, fluxes)
npt.assert_array_almost_equal(ref_net_fluxes, net_fluxes)
def test_cond_committors():
# depends on tpt.committors
msm = MarkovStateModel(lag_time=1)
assignments = np.random.randint(4, size=(10, 1000))
msm.fit(assignments)
tprob = msm.transmat_
for_committors = tpt.committors(0, 3, msm)
cond_committors = tpt.conditional_committors(0, 3, 2, msm)
# The committor for state one can be decomposed into paths that
# do and do not visit state 2 along the way. The paths that do not
# visit state 1 must look like 1, 1, 1, ..., 1, 1, 3. So we can
# compute them with a similar approximation as the forward committor
# Since we want the other component of the forward committor, we
# subtract that probability from the forward committor
ref = for_committors[1] - np.power(tprob[1, 1], np.arange(5000)).sum() * tprob[1, 3]
#print (ref / for_committors[1])
ref = [0, ref, for_committors[2], 0]
#print(cond_committors, ref)
npt.assert_array_almost_equal(ref, cond_committors)
def test_harder_hubscore():
# depends on tpt.committors and tpt.conditional_committors
assignments = np.random.randint(10, size=(10, 1000))
msm = MarkovStateModel(lag_time=1)
msm.fit(assignments)
hub_scores = tpt.hub_scores(msm)
ref_hub_scores = np.zeros(10)
for A in xrange(10):
for B in xrange(10):
committors = tpt.committors(A, B, msm)
denom = msm.transmat_[A, :].dot(committors) #+ msm.transmat_[A, B]
for C in xrange(10):
if A == B or A == C or B == C:
continue
cond_committors = tpt.conditional_committors(A, B, C, msm)
temp = 0.0
for i in xrange(10):
if i in [A, B]:
continue
temp += cond_committors[i] * msm.transmat_[A, i]
temp /= denom
ref_hub_scores[C] += temp
ref_hub_scores /= (9 * 8)
#print(ref_hub_scores, hub_scores)
npt.assert_array_almost_equal(ref_hub_scores, hub_scores)
def test_fluxes():
# depends on tpt.committors
msm = MarkovStateModel(lag_time=1)
assignments = np.random.randint(3, size=(10, 1000))
msm.fit(assignments)
tprob = msm.transmat_
pop = msm.populations_
# forward committors
qplus = tpt.committors(0, 2, msm)
ref_fluxes = np.zeros((3, 3))
ref_net_fluxes = np.zeros((3, 3))
for i in xrange(3):
for j in xrange(3):
if i != j:
# Eq. 2.24 in Metzner et al. Transition Path Theory.
# Multiscale Model. Simul. 2009, 7, 1192-1219.
ref_fluxes[i, j] = (pop[i] * tprob[i, j] * (1 - qplus[i]) *
qplus[j])
for i in xrange(3):
for j in xrange(3):
ref_net_fluxes[i, j] = np.max(
[0, ref_fluxes[i, j] - ref_fluxes[j, i]])
fluxes = tpt.fluxes(0, 2, msm)
net_fluxes = tpt.net_fluxes(0, 2, msm)
# print(fluxes)
# print(ref_fluxes)
npt.assert_array_almost_equal(ref_fluxes, fluxes)
npt.assert_array_almost_equal(ref_net_fluxes, net_fluxes)
def test_committors_2():
bmsm = BayesianMarkovStateModel(lag_time=1)
assignments = np.random.randint(3, size=(10, 1000))
bmsm.fit(assignments)
committors = tpt.committors([0], [2], bmsm)
ref = 0
for tprob in bmsm.all_transmats_:
ref += np.power(tprob[1, 1], np.arange(1000)).sum() * tprob[1, 2]
ref = np.array([0, ref / 100., 1])
npt.assert_array_almost_equal(ref, committors, decimal=2)
def test_cond_committors_2():
# depends on tpt.committors
bmsm = BayesianMarkovStateModel(lag_time=1)
assignments = np.random.randint(4, size=(10, 1000))
bmsm.fit(assignments)
for_committors = tpt.committors(0, 3, bmsm)
cond_committors = tpt.conditional_committors(0, 3, 2, bmsm)
ref = 0
for tprob in bmsm.all_transmats_:
ref += (for_committors[1] -
np.power(tprob[1, 1], np.arange(5000)).sum() *
tprob[1, 3])
ref = [0, ref / 100., for_committors[2], 0]
npt.assert_array_almost_equal(ref, cond_committors, decimal=2)
def do_tpt(ev_id):
plt.figure(figsize=(15, 10))
# TPT "FROM":
sources = [7]
# TPT "To":
sinks = [10]
net_flux = tpt.net_fluxes(sources, sinks, msm, for_committors=None)
np.savetxt('net_flux.txt', net_flux)
pfold = tpt.committors(sources, sinks, msm)
np.savetxt('pfold.txt', pfold)
paths = tpt.paths(sources,
sinks,
net_flux,
remove_path='subtract',
flux_cutoff=0.9999999999)
mfpts = tpt.mfpts(
msm, sinks=None, lag_time=1.0
) # Default is (1) which is in units of the lag time of the MSM.
print "mfpts:", mfpts
np.savetxt('mfpts_from_i_to_j.txt', np.array(mfpts))
total_flux = np.sum(paths[1])
print "total_flux:", total_flux
sort = np.argsort(pfold)
total_line_width = np.sum(paths[1][0:5])
# top 5 paths, to get all paths set this number higher
for j in range(5):
print "path:", paths[0][j]
print "flux:", paths[1][j], paths[1][j] / float(np.sum(paths[1]))
x = []
for k in range(len(paths[0][j])):
x.extend(np.where(np.arange(100)[sort] == paths[0][j][k])[0])
plt.plot(x,
pfold[paths[0][j]],
linewidth=np.log(paths[1][j] / float(total_line_width)))
plt.legend(['%1.8f' % i for i in paths[1][0:5]],
fontsize=18,
loc='upper left')
for i in range(len(pfold)):
plt.plot(i, pfold[sort[i]], 'o')
plt.text(i, pfold[sort[i]], sort[i])
plt.savefig('pfold_ev%d_0.01.png' % ev_id)
def test_committors_1():
msm = MarkovStateModel(lag_time=1)
assignments = np.random.randint(3, size=(10, 1000))
msm.fit(assignments)
tprob = msm.transmat_
committors = tpt.committors([0], [2], msm)
# The probability of hitting state 2 before going back to state 1
# is a sum over possible paths that don't go back to state 0.
# Since there are only three states the paths are all something
# of the form 1, 1, 1, 1, ..., 1, 1, 2
# Theoretically we need infinitely many 1->1 transitions, but
# that approaches zero, so the approximation below is probably
# just fine.
ref = np.power(tprob[1, 1], np.arange(1000)).sum() * tprob[1, 2]
ref = np.array([0, ref, 1])
# print(committors, ref)
npt.assert_array_almost_equal(ref, committors)
def test_committors():
msm = MarkovStateModel(lag_time=1)
assignments = np.random.randint(3, size=(10, 1000))
msm.fit(assignments)
tprob = msm.transmat_
committors = tpt.committors([0], [2], msm)
# The probability of hitting state 2 before going back to state 1
# is a sum over possible paths that don't go back to state 0.
# Since there are only three states the paths are all something
# of the form 1, 1, 1, 1, ..., 1, 1, 2
# Theoretically we need infinitely many 1->1 transitions, but
# that approaches zero, so the approximation below is probably
# just fine.
ref = np.power(tprob[1, 1], np.arange(1000)).sum() * tprob[1, 2]
ref = np.array([0, ref, 1])
# print(committors, ref)
npt.assert_array_almost_equal(ref, committors)
def rate_estimation_tpt(source_states,sink_states,msm):
tau = 5
#timescales_macro = 3788.1 #1st eigenmode
#timescales_micro = 12095.2 #1st eigenmode, may not be correct!
c_p53 = 7.1*10**-3 #Mol
committors = tpt.committors(sources=source_states,sinks=sink_states,msm=msm)
back_com = 1-committors
#print committors
F = 0
for i in source_states:
for j in range(msm.n_states_):
if j not in source_states:
F += msm.populations_[i]*msm.transmat_[i,j]*committors[j]
kab = F/((tau*1e-9)*np.dot(msm.populations_,back_com))
#print kab*(timescales_macro/timescales_micro)
#print kab*(1/c_p53)
#print "kAB:",kab*(1/c_p53)*(timescales_macro/timescales_micro)
return kab
import os, sys
import numpy as np
from msmbuilder import tpt
from scipy.sparse import coo_matrix
from scipy.io import mmwrite
from sklearn.externals import joblib
ids = range(6383, 6391)
for p_id in ids:
msm = joblib.load(
'MSMs-{pid}-macro40/MSMs-{pid}-macro40.pkl'.format(pid=p_id))
committors = tpt.committors(sources=[4], sinks=[13], msm=msm)
net_fluxes = tpt.net_fluxes(sources=[4],
sinks=[13],
msm=msm,
for_committors=committors)
top_10_paths_sub, top_10_fluxes_sub = tpt.paths(sources=[4],
sinks=[13],
net_flux=net_fluxes,
num_paths=10,
remove_path='subtract')
top_10_paths_bot, top_10_fluxes_bot = tpt.paths(sources=[4],
sinks=[13],
net_flux=net_fluxes,
num_paths=10,
remove_path='bottleneck')
output_dir = "Data-{pid}-macro40".format(pid=p_id)
print top_10_paths_sub, top_10_fluxes_sub
print top_10_paths_bot, top_10_fluxes_bot
