def setUp(self):
"""Store state of the rng"""
self.state = np.random.mtrand.get_state()
"""Reseed the rng to enforce 'deterministic' behavior"""
np.random.mtrand.seed(42)
"""Meta-stable birth-death chain"""
b = 2
q = np.zeros(7)
p = np.zeros(7)
q[1:] = 0.5
p[0:-1] = 0.5
q[2] = 1.0 - 10 ** (-b)
q[4] = 10 ** (-b)
p[2] = 10 ** (-b)
p[4] = 1.0 - 10 ** (-b)
bdc = BirthDeathChain(q, p)
P = bdc.transition_matrix()
self.dtraj = generate_traj(P, 10000, start=0)
self.tau = 1
"""Estimate MSM"""
self.C_MSM = cmatrix(self.dtraj, self.tau, sliding=True)
self.lcc_MSM = largest_connected_set(self.C_MSM)
self.Ccc_MSM = connected_cmatrix(self.C_MSM, lcc=self.lcc_MSM)
self.P_MSM = tmatrix(self.Ccc_MSM, reversible=True)
self.mu_MSM = statdist(self.P_MSM)
self.k = 3
self.ts = timescales(self.P_MSM, k=self.k, tau=self.tau)
def setUpClass(cls):
path = os.path.join(os.path.split(__file__)[0], 'data')
cls.pdb_file = os.path.join(path, 'bpti_ca.pdb')
cls.feat = MDFeaturizer(cls.pdb_file)
cls.feat.add_all()
cls.traj_files = [
os.path.join(path, 'bpti_001-033.xtc'),
os.path.join(path, 'bpti_067-100.xtc')
]
# generate HMM with two gaussians
p = np.array([[0.99, 0.01], [0.01, 0.99]])
t = 10000
means = [np.array([-1, 1]), np.array([1, -1])]
widths = [np.array([0.3, 2]), np.array([0.3, 2])]
# continuous trajectory
x = np.zeros((t, 2))
# hidden trajectory
dtraj = msmgen.generate_traj(p, t)
for t in range(t):
s = dtraj[t]
x[t, 0] = widths[s][0] * np.random.randn() + means[s][0]
x[t, 1] = widths[s][1] * np.random.randn() + means[s][1]
cls.generated_data = x
cls.generated_lag = 10
def test_discrete_4_2(self):
# 4x4 transition matrix
nstates = 2
P = np.array([[0.90, 0.10, 0.00, 0.00],
[0.10, 0.89, 0.01, 0.00],
[0.00, 0.01, 0.89, 0.10],
[0.00, 0.00, 0.10, 0.90]])
# generate realization
import pyemma.msm.generation as msmgen
T = 10000
dtrajs = [msmgen.generate_traj(P, T)]
# estimate initial HMM with 2 states - should be identical to P
hmm = initdisc.initial_model_discrete(dtrajs, nstates)
# Test if model fit is close to reference. Note that we do not have an exact reference, so we cannot set the
# tolerance in a rigorous way to test statistical significance. These are just sanity checks.
Tij = hmm.transition_matrix
B = hmm.output_model.output_probabilities
# Test stochasticity
import pyemma.msm.analysis as msmana
msmana.is_transition_matrix(Tij)
np.allclose(B.sum(axis=1), np.ones(B.shape[0]))
#if (B[0,0]<B[1,0]):
# B = B[np.array([1,0]),:]
Tij_ref = np.array([[0.99, 0.01],
[0.01, 0.99]])
Bref = np.array([[0.5, 0.5, 0.0, 0.0],
[0.0, 0.0, 0.5, 0.5]])
assert(np.max(Tij-Tij_ref) < 0.01)
assert(np.max(B-Bref) < 0.05 or np.max(B[[1,0]]-Bref) < 0.05)
def setUp(self):
"""Store state of the rng"""
self.state = np.random.mtrand.get_state()
"""Reseed the rng to enforce 'deterministic' behavior"""
np.random.mtrand.seed(42)
"""Meta-stable birth-death chain"""
b = 2
q = np.zeros(7)
p = np.zeros(7)
q[1:] = 0.5
p[0:-1] = 0.5
q[2] = 1.0 - 10**(-b)
q[4] = 10**(-b)
p[2] = 10**(-b)
p[4] = 1.0 - 10**(-b)
bdc = BirthDeathChain(q, p)
P = bdc.transition_matrix()
self.dtraj = generate_traj(P, 10000, start=0)
self.tau = 1
"""Estimate MSM"""
self.C_MSM = cmatrix(self.dtraj, self.tau, sliding=True)
self.lcc_MSM = largest_connected_set(self.C_MSM)
self.Ccc_MSM = connected_cmatrix(self.C_MSM, lcc=self.lcc_MSM)
self.P_MSM = tmatrix(self.Ccc_MSM, reversible=True)
self.mu_MSM = statdist(self.P_MSM)
self.k = 3
self.ts = timescales(self.P_MSM, k=self.k, tau=self.tau)
def setUp(self):
self.dtrajs = []
# simple case
dtraj_simple = [0, 1, 1, 1, 0]
self.dtrajs.append([dtraj_simple])
# as ndarray
self.dtrajs.append([np.array(dtraj_simple)])
dtraj_disc = [0, 1, 1, 0, 0]
self.dtrajs.append([dtraj_disc])
# multitrajectory case
self.dtrajs.append([[0], [1, 1, 1, 1], [0, 1, 1, 1, 0], [0, 1, 0, 1, 0, 1, 0, 1]])
# large-scale case
large_trajs = []
for i in range(10):
large_trajs.append(np.random.randint(10, size=1000))
self.dtrajs.append(large_trajs)
# Markovian timeseries with timescale about 5
self.P2 = np.array([[0.9, 0.1], [0.1, 0.9]])
self.dtraj2 = generate_traj(self.P2, 1000)
self.dtrajs.append([self.dtraj2])
# Markovian timeseries with timescale about 5
self.P4 = np.array([[0.95, 0.05, 0.0, 0.0],
[0.05, 0.93, 0.02, 0.0],
[0.0, 0.02, 0.93, 0.05],
[0.0, 0.0, 0.05, 0.95]])
self.dtraj4_2 = generate_traj(self.P4, 20000)
I = [0, 0, 1, 1] # coarse-graining
for i in range(len(self.dtraj4_2)):
self.dtraj4_2[i] = I[self.dtraj4_2[i]]
self.dtrajs.append([self.dtraj4_2])
def setUp(self):
self.dtrajs = []
# simple case
dtraj_simple = [0, 1, 1, 1, 0]
self.dtrajs.append([dtraj_simple])
# as ndarray
self.dtrajs.append([np.array(dtraj_simple)])
dtraj_disc = [0, 1, 1, 0, 0]
self.dtrajs.append([dtraj_disc])
# multitrajectory case
self.dtrajs.append([[0], [1, 1, 1, 1], [0, 1, 1, 1, 0],
[0, 1, 0, 1, 0, 1, 0, 1]])
# large-scale case
large_trajs = []
for i in range(10):
large_trajs.append(np.random.randint(10, size=1000))
self.dtrajs.append(large_trajs)
# Markovian timeseries with timescale about 5
self.P2 = np.array([[0.9, 0.1], [0.1, 0.9]])
self.dtraj2 = generate_traj(self.P2, 1000)
self.dtrajs.append([self.dtraj2])
# Markovian timeseries with timescale about 5
self.P4 = np.array([[0.95, 0.05, 0.0, 0.0], [0.05, 0.93, 0.02, 0.0],
[0.0, 0.02, 0.93, 0.05], [0.0, 0.0, 0.05, 0.95]])
self.dtraj4_2 = generate_traj(self.P4, 20000)
I = [0, 0, 1, 1] # coarse-graining
for i in range(len(self.dtraj4_2)):
self.dtraj4_2[i] = I[self.dtraj4_2[i]]
self.dtrajs.append([self.dtraj4_2])
def generate_synthetic_state_trajectory(self, nsteps, initial_Pi=None, start=None, stop=None, dtype=np.int32):
"""Generate a synthetic state trajectory.
Parameters
----------
nsteps : int
Number of steps in the synthetic state trajectory to be generated.
initial_Pi : np.array of shape (nstates,), optional, default=None
The initial probability distribution, if samples are not to be taken from the intrinsic
initial distribution.
start : int
starting state. Exclusive with initial_Pi
stop : int
stopping state. Trajectory will terminate when reaching the stopping state before length number of steps.
dtype : numpy.dtype, optional, default=numpy.int32
The numpy dtype to use to store the synthetic trajectory.
Returns
-------
states : np.array of shape (nstates,) of dtype=np.int32
The trajectory of hidden states, with each element in range(0,nstates).
Examples
--------
Generate a synthetic state trajectory of a specified length.
>>> from bhmm import testsystems
>>> model = testsystems.dalton_model()
>>> states = model.generate_synthetic_state_trajectory(nsteps=100)
"""
# consistency check
if initial_Pi is not None and start is not None:
raise ValueError("Arguments initial_Pi and start are exclusive. Only set one of them.")
# Generate first state sample.
if start is None:
if initial_Pi is not None:
start = np.random.choice(range(self._nstates), size=1, p=initial_Pi)
else:
start = np.random.choice(range(self._nstates), size=1, p=self._Pi)
# Generate and return trajectory
from pyemma.msm import generation as msmgen
traj = msmgen.generate_traj(self.transition_matrix, nsteps, start=start, stop=stop, dt=1)
return traj.astype(dtype)
def setUpClass(cls):
import pyemma.msm.generation as msmgen
# generate HMM with two Gaussians
cls.P = np.array([[0.99, 0.01], [0.01, 0.99]])
cls.T = 10000
means = [np.array([-1, 1]), np.array([1, -1])]
widths = [np.array([0.3, 2]), np.array([0.3, 2])]
# continuous trajectory
cls.X = np.zeros((cls.T, 2))
# hidden trajectory
dtraj = msmgen.generate_traj(cls.P, cls.T)
for t in range(cls.T):
s = dtraj[t]
cls.X[t, 0] = widths[s][0] * np.random.randn() + means[s][0]
cls.X[t, 1] = widths[s][1] * np.random.randn() + means[s][1]
cls.lag = 10
cls.pca_obj = pca(data=cls.X, dim=1)
def main():
args = handleArgs()
try:
_, ext = os.path.splitext(args.T)
if ext == '.npy':
pyemma.msm.io.load_matrix(args.T)
else:
T = pyemma.msm.io.read_matrix(args.T)
except IOError:
log.error('error during reading transition matrix file %s' % args.T)
traj = generate_traj(T, args.start_state, args.steps, args.dt)
try:
pyemma.msm.io.save_matrix(args.output, traj)
except IOError:
log.exception("error during saving resulting trajectory to %s" %
args.output)
def setUpClass(cls):
import pyemma.msm.generation as msmgen
# generate HMM with two Gaussians
cls.P = np.array([[0.99, 0.01],
[0.01, 0.99]])
cls.T = 10000
means = [np.array([-1,1]), np.array([1,-1])]
widths = [np.array([0.3,2]),np.array([0.3,2])]
# continuous trajectory
cls.X = np.zeros((cls.T, 2))
# hidden trajectory
dtraj = msmgen.generate_traj(cls.P, cls.T)
for t in range(cls.T):
s = dtraj[t]
cls.X[t,0] = widths[s][0] * np.random.randn() + means[s][0]
cls.X[t,1] = widths[s][1] * np.random.randn() + means[s][1]
cls.lag = 10
cls.pca_obj = pca(data = cls.X, dim=1)
def test_discrete_2_2(self):
# 2x2 transition matrix
P = np.array([[0.99,0.01],[0.01,0.99]])
# generate realization
import pyemma.msm.generation as msmgen
T = 10000
dtrajs = [msmgen.generate_traj(P, T)]
# estimate initial HMM with 2 states - should be identical to P
hmm = initdisc.initial_model_discrete(dtrajs, 2)
# test
A = hmm.transition_matrix
B = hmm.output_model.output_probabilities
# Test stochasticity
import pyemma.msm.analysis as msmana
msmana.is_transition_matrix(A)
np.allclose(B.sum(axis=1), np.ones(B.shape[0]))
# A should be close to P
if (B[0,0]<B[1,0]):
B = B[np.array([1,0]),:]
assert(np.max(A-P) < 0.01)
assert(np.max(B-np.eye(2)) < 0.01)
def test_discrete_6_3(self):
# 4x4 transition matrix
nstates = 3
P = np.array([[0.90, 0.10, 0.00, 0.00, 0.00, 0.00],
[0.20, 0.79, 0.01, 0.00, 0.00, 0.00],
[0.00, 0.01, 0.84, 0.15, 0.00, 0.00],
[0.00, 0.00, 0.05, 0.94, 0.01, 0.00],
[0.00, 0.00, 0.00, 0.02, 0.78, 0.20],
[0.00, 0.00, 0.00, 0.00, 0.10, 0.90]])
# generate realization
import pyemma.msm.generation as msmgen
T = 10000
dtrajs = [msmgen.generate_traj(P, T)]
# estimate initial HMM with 2 states - should be identical to P
hmm = initdisc.initial_model_discrete(dtrajs, nstates)
# Test stochasticity and reversibility
Tij = hmm.transition_matrix
B = hmm.output_model.output_probabilities
import pyemma.msm.analysis as msmana
msmana.is_transition_matrix(Tij)
msmana.is_reversible(Tij)
np.allclose(B.sum(axis=1), np.ones(B.shape[0]))
def setUp(self):
"""Store state of the rng"""
self.state = np.random.mtrand.get_state()
"""Reseed the rng to enforce 'deterministic' behavior"""
np.random.mtrand.seed(42)
"""Meta-stable birth-death chain"""
b = 2
q = np.zeros(7)
p = np.zeros(7)
q[1:] = 0.5
p[0:-1] = 0.5
q[2] = 1.0 - 10**(-b)
q[4] = 10**(-b)
p[2] = 10**(-b)
p[4] = 1.0 - 10**(-b)
bdc = BirthDeathChain(q, p)
P = bdc.transition_matrix()
dtraj = generate_traj(P, 10000, start=0)
tau = 1
"""Estimate MSM"""
C_MSM = cmatrix(dtraj, tau)
lcc_MSM = largest_connected_set(C_MSM)
Ccc_MSM = connected_cmatrix(C_MSM, lcc=lcc_MSM)
P_MSM = tmatrix(Ccc_MSM)
mu_MSM = statdist(P_MSM)
"""Meta-stable sets"""
A = [0, 1, 2]
B = [4, 5, 6]
w_MSM = np.zeros((2, mu_MSM.shape[0]))
w_MSM[0, A] = mu_MSM[A] / mu_MSM[A].sum()
w_MSM[1, B] = mu_MSM[B] / mu_MSM[B].sum()
K = 10
P_MSM_dense = P_MSM.toarray()
p_MSM = np.zeros((K, 2))
w_MSM_k = 1.0 * w_MSM
for k in range(1, K):
w_MSM_k = np.dot(w_MSM_k, P_MSM_dense)
p_MSM[k, 0] = w_MSM_k[0, A].sum()
p_MSM[k, 1] = w_MSM_k[1, B].sum()
"""Assume that sets are equal, A(\tau)=A(k \tau) for all k"""
w_MD = 1.0 * w_MSM
p_MD = np.zeros((K, 2))
eps_MD = np.zeros((K, 2))
p_MSM[0, :] = 1.0
p_MD[0, :] = 1.0
eps_MD[0, :] = 0.0
for k in range(1, K):
"""Build MSM at lagtime k*tau"""
C_MD = cmatrix(dtraj, k * tau, sliding=True) / (k * tau)
lcc_MD = largest_connected_set(C_MD)
Ccc_MD = connected_cmatrix(C_MD, lcc=lcc_MD)
c_MD = Ccc_MD.sum(axis=1)
P_MD = tmatrix(Ccc_MD).toarray()
w_MD_k = np.dot(w_MD, P_MD)
"""Set A"""
prob_MD = w_MD_k[0, A].sum()
c = c_MD[A].sum()
p_MD[k, 0] = prob_MD
eps_MD[k, 0] = np.sqrt(k * (prob_MD - prob_MD**2) / c)
"""Set B"""
prob_MD = w_MD_k[1, B].sum()
c = c_MD[B].sum()
p_MD[k, 1] = prob_MD
eps_MD[k, 1] = np.sqrt(k * (prob_MD - prob_MD**2) / c)
"""Input"""
self.P_MSM = P_MSM
self.lcc_MSM = lcc_MSM
self.dtraj = dtraj
self.tau = tau
self.K = K
self.A = A
self.B = B
"""Expected results"""
self.p_MSM = p_MSM
self.p_MD = p_MD
self.eps_MD = eps_MD
def setUp(self):
"""Store state of the rng"""
self.state = np.random.mtrand.get_state()
"""Reseed the rng to enforce 'deterministic' behavior"""
np.random.mtrand.seed(42)
"""Meta-stable birth-death chain"""
b = 2
q = np.zeros(7)
p = np.zeros(7)
q[1:] = 0.5
p[0:-1] = 0.5
q[2] = 1.0 - 10 ** (-b)
q[4] = 10 ** (-b)
p[2] = 10 ** (-b)
p[4] = 1.0 - 10 ** (-b)
bdc = BirthDeathChain(q, p)
P = bdc.transition_matrix()
dtraj = generate_traj(P, 10000, start=0)
tau = 1
"""Estimate MSM"""
MSM = estimate_markov_model(dtraj, tau)
C_MSM = MSM.count_matrix_full
lcc_MSM = MSM.largest_connected_set
Ccc_MSM = MSM.count_matrix_active
P_MSM = MSM.transition_matrix
mu_MSM = MSM.stationary_distribution
"""Meta-stable sets"""
A = [0, 1, 2]
B = [4, 5, 6]
w_MSM = np.zeros((2, mu_MSM.shape[0]))
w_MSM[0, A] = mu_MSM[A] / mu_MSM[A].sum()
w_MSM[1, B] = mu_MSM[B] / mu_MSM[B].sum()
K = 10
P_MSM_dense = P_MSM
p_MSM = np.zeros((K, 2))
w_MSM_k = 1.0 * w_MSM
for k in range(1, K):
w_MSM_k = np.dot(w_MSM_k, P_MSM_dense)
p_MSM[k, 0] = w_MSM_k[0, A].sum()
p_MSM[k, 1] = w_MSM_k[1, B].sum()
"""Assume that sets are equal, A(\tau)=A(k \tau) for all k"""
w_MD = 1.0 * w_MSM
p_MD = np.zeros((K, 2))
eps_MD = np.zeros((K, 2))
p_MSM[0, :] = 1.0
p_MD[0, :] = 1.0
eps_MD[0, :] = 0.0
for k in range(1, K):
"""Build MSM at lagtime k*tau"""
C_MD = cmatrix(dtraj, k * tau, sliding=True) / (k * tau)
lcc_MD = largest_connected_set(C_MD)
Ccc_MD = connected_cmatrix(C_MD, lcc=lcc_MD)
c_MD = Ccc_MD.sum(axis=1)
P_MD = tmatrix(Ccc_MD).toarray()
w_MD_k = np.dot(w_MD, P_MD)
"""Set A"""
prob_MD = w_MD_k[0, A].sum()
c = c_MD[A].sum()
p_MD[k, 0] = prob_MD
eps_MD[k, 0] = np.sqrt(k * (prob_MD - prob_MD ** 2) / c)
"""Set B"""
prob_MD = w_MD_k[1, B].sum()
c = c_MD[B].sum()
p_MD[k, 1] = prob_MD
eps_MD[k, 1] = np.sqrt(k * (prob_MD - prob_MD ** 2) / c)
"""Input"""
self.MSM = MSM
self.K = K
self.A = A
self.B = B
"""Expected results"""
self.p_MSM = p_MSM
self.p_MD = p_MD
self.eps_MD = eps_MD
