def plotFluxPathways(self, statetype='macro', mode='net_flux', fraction=1.0): """ Plot flux pathways between source and sink state. The flux is in units of transition events per lag time used to construct the Markov model. Parameters ---------- statetype : {'macro','coarse','micro'} What type of states to plot mode : {'net_flux', 'gross_flux'} Type of fluxes to plot fraction : float Fraction of fluxes for which to report pathways. Doesn't change the plot, only the text output. """ # Make mode a radio button with interactive plot from pyemma import msm from pyemma.plots import plot_flux from matplotlib import pylab as plt self._intergrityCheck() plt.figure() if statetype == 'micro': tpt = msm.tpt(self.model.msm, [self.sourcemicro], [self.sinkmicro]) fig, pos = plot_flux(tpt, attribute_to_plot=mode) elif statetype == 'macro' or statetype == 'coarse': metastable_sets = [] for i in range(self.model.macronum): metastable_sets.append( np.where(self.model.macro_ofmicro == i)[0]) tpt = msm.tpt(self.model.msm, metastable_sets[self.source], metastable_sets[self.sink]) #from IPython.core.debugger import Tracer #Tracer()() newsets, tpt = tpt.coarse_grain(metastable_sets) setmap = [] # getting the mapping of new sets to old sets for set1 in newsets: for idx2, set2 in enumerate(metastable_sets): if set(set1) == set(set2): setmap.append(idx2) continue setmap = np.array(setmap) fig, pos = plot_flux(tpt, attribute_to_plot=mode, state_labels=setmap) fig.show() paths, pathfluxes = tpt.pathways(fraction=fraction) cumflux = 0 print("Path flux\t\t%path\t%of total\tpath") for i in range(len(paths)): cumflux += pathfluxes[i] print('{}\t{:3.1f}%\t{:3.1f}%\t\t{}'.format( pathfluxes[i], 100.0 * pathfluxes[i] / tpt.total_flux, 100.0 * cumflux / tpt.total_flux, setmap[paths[i]]))
def plotFluxPathways(self, statetype='macro', mode='net_flux', fraction=1.0): """ Plot flux pathways between source and sink state. Parameters ---------- statetype : {'macro','coarse','micro'} What type of states to plot mode : {'net_flux', 'gross_flux'} Type of fluxes to plot fraction : float Fraction of fluxes for which to report pathways. Doesn't change the plot, only the text output. """ # Make mode a radio button with interactive plot from pyemma import msm from pyemma.plots import plot_flux from matplotlib import pylab as plt self._intergrityCheck() plt.figure() if statetype == 'micro': tpt = msm.tpt(self.model.msm, [self.sourcemicro], [self.sinkmicro]) fig, pos = plot_flux(tpt, attribute_to_plot=mode) elif statetype == 'macro' or statetype == 'coarse': metastable_sets = [] for i in range(self.model.macronum): metastable_sets.append(np.where(self.model.macro_ofmicro == i)[0]) tpt = msm.tpt(self.model.msm, metastable_sets[self.source], metastable_sets[self.sink]) #from IPython.core.debugger import Tracer #Tracer()() newsets, tpt = tpt.coarse_grain(metastable_sets) setmap = [] # getting the mapping of new sets to old sets for set1 in newsets: for idx2, set2 in enumerate(metastable_sets): if set(set1) == set(set2): setmap.append(idx2) continue setmap = np.array(setmap) fig, pos = plot_flux(tpt, attribute_to_plot=mode, state_labels=setmap) fig.show() paths, pathfluxes = tpt.pathways(fraction=fraction) cumflux = 0 print("Path flux\t\t%path\t%of total\tpath") for i in range(len(paths)): cumflux += pathfluxes[i] print('{}\t{:3.1f}%\t{:3.1f}%\t\t{}'.format( pathfluxes[i], 100.0*pathfluxes[i]/tpt.total_flux, 100.0*cumflux/tpt.total_flux, setmap[paths[i]]))
def calculate_macro_TPT_and_MFPT_basedon_micro_MSM(microTPM, mapping, source_state, sink_state, lagtime, time_unit): P = pyemma_msm.markov_model(microTPM) #TPM is row-normalized A = np.where(mapping == source_state)[0] B = np.where(mapping == sink_state)[0] print('MFPT from state %d to state %d = %f %s' % (source_state, sink_state, msmtools.analysis.mfpt(microTPM, A, B) * lagtime, time_unit)) #get TPT tpt = pyemma_msm.tpt(P, A, B) (paths, pathfluxes) = tpt.pathways() cumflux = 0 print("summarizing the pathways in macrostate form") temp_file = open('tpt_temp.log', 'w') for i in range(len(paths)): cumflux += pathfluxes[i] temp_file.write("%16.9f\t%16.9f\t%16.9f\t%s\n" % (pathfluxes[i], 100.0 * pathfluxes[i] / tpt.total_flux, 100.0 * cumflux / tpt.total_flux, mapping[paths[i]])) temp_file.close() os.system('bash lump.sh') #may do this in bash for line in open('tpt_pathlump.log'): print(line.strip()) print('############################################################') print("more details about the paths in the microstate form") print("Path flux\t\t%path\t%of total\tpaths") for i in range(len(paths)): cumflux += pathfluxes[i] print(pathfluxes[i], '\t', '%3.1f' % (100.0 * pathfluxes[i] / tpt.total_flux), '%\t', '%3.1f' % (100.0 * cumflux / tpt.total_flux), '%\t', paths[i])
def test_flux(self): r = tpt(self.msm, self.A, self.B) fig, pos = plot_flux(r) assert type(fig) is matplotlib.figure.Figure # matplotlib.pyplot.show(fig) # x values should be close to committor np.testing.assert_allclose(pos[:,0], r.committor)
def calculate_flux(mm, topic_labels, A=[8], B=[2, 13]): #A=[8],B=[2,13], # Calculate the flux between two states camp arrival and camp liquidiation / camp transfer ) tpt = msm.tpt(mm, A, B) nCut = 1 (bestpaths, bestpathfluxes) = tpt.pathways(fraction=0.7) cumflux = 0 # Print the best path between the two states print("Path flux\t\t%path\t%of total\tpath") topic_sequences = {} for i in range(len(bestpaths)): cumflux += bestpathfluxes[i] flux = 100.0 * bestpathfluxes[i] / tpt.total_flux if flux > 0: #print(bestpathfluxes[i],'\t','%3.1f'%(100.0*bestpathfluxes[i]/tpt.total_flux),'%\t','%3.1f'%(100.0*cumflux/tpt.total_flux),'%\t\t',bestpaths[i]) topic_sequence = [] for element in bestpaths[i]: #print (topic_labels[element]) topic_sequence.append(topic_labels[element]) topic_sequence = '-'.join(topic_sequence) topic_sequences[ topic_sequence] = 100.0 * bestpathfluxes[i] / tpt.total_flux return topic_sequences
def test_state_labels_flux_auto(self): """ ensure auto generated labels show up in the plot""" A = [0,1] B = [2,4] flux = tpt(self.msm, A, B) fig, pos = plot_flux(flux, state_labels='auto') labels_in_fig = np.array([text.get_text() for text in fig.axes[0].texts]) self.assertEqual((labels_in_fig == "A").sum(), len(A)) self.assertEqual((labels_in_fig == "B").sum(), len(B))
def test_state_labels_flux(self): """ ensure our labels show up in the plot""" flux = tpt(self.msm, [0,1], [2,4]) labels = ['foo', '0', '1', '2', 'bar'] fig, pos = plot_flux(flux, state_labels=labels) labels_in_fig = np.array([text.get_text() for text in fig.axes[0].texts]) for l in labels: self.assertEqual((labels_in_fig == l).sum(), 1)
def calc_flux(self): def get_map(cg,member): sort1 = [sorted(x) for x in cg] sort2 = [sorted(x) for x in member] mapping = [-1]*len(cg) ll = len(cg) for ii in range(ll): for jj in range(ll): if(len(sort1[ii]) != len(sort2[jj])): continue for el1,el2 in zip(sort1[ii],sort2[jj]): if(el1 != el2): break mapping[ii] = jj return mapping # find cluster of helix and loop cluster_h = self.cluster_labels[self.idx_source] cluster_l = self.cluster_labels[self.idx_sink] if(cluster_h == cluster_l): print "# Fatal error. Source and sink belong to the same cluster (eRMSD= %f)" % (self.dmat[self.idx_source,self.idx_sink]) sys.exit(1) A = self.cluster_members[cluster_h] B = self.cluster_members[cluster_l] # get fluxes # import pyemma import pyemma.msm as msm M = msm.MSM(self.kmat.T,pi=self.weight) fluxAB = msm.tpt(M,A,B) cg, cgflux = fluxAB.coarse_grain(self.cluster_members) paths, path_fluxes = cgflux.pathways(fraction=0.99) # find mapping (pyemma messes up the indeces) mapping = get_map(cg,self.cluster_members) # write to file fh_c = open(self.name + ".pathways.dat",'w') fh_c.write("# cluster source " + str(cluster_h) + "\n") fh_c.write("# cluster sink " + str(cluster_l) + "\n") stri = "# Flux % - List of clusters \n" for i in range(len(paths)): stri += "%5.3f - " % (path_fluxes[i] / np.sum(path_fluxes)) for el in paths[i]: stri += "%3i " % mapping[el] stri += "\n" fh_c.write(stri) fh_c.close()
def calculate_in_out_rates(self, coarse=False): from pyemma import msm from IDP_htmd.model_utils import metastable_states try: self.model.metastable_sets lookup = self.model.set_ofmicros except: print("Recalculating metastable sets") metastable_states(self.model) lookup = self.model.macro_ofmicro if self.statetype == "macro": if (self.sink < 0 or self.sink > len(self.model.metastable_sets) or self.source < 0 or self.source > len(self.model.metastable_sets)): raise Exception("Sink or source out of bounds") tpt = msm.tpt(self.model.msm, self.model.metastable_sets[self.source], self.model.metastable_sets[self.sink]) elif self.statetype == "micro": tpt = msm.tpt(self.model.msm, self.source, self.sink) if coarse: newsets, tpt = tpt.coarse_grain(self.model.metastable_sets) paths, pathfluxes = tpt.pathways(fraction=self.fraction) # Create a lookup table for new datasets if self.statetype == "macro": macro2macro = np.zeros(len(self.model.metastable_sets), dtype=int) for idx, micro in enumerate(newsets): macro2macro[idx] = lookup[micro[0]] elif self.statetype == "micro": macro2macro = np.zeros(len(newsets), dtype=int) for idx, micro in enumerate(newsets): macro2macro[idx] = lookup[micro[0]] else: paths, pathfluxes = tpt.pathways(fraction=self.fraction) macro2macro = lookup self.tpt = tpt return paths, pathfluxes, macro2macro
def fluxPathways(self): import pyemma.plots as mplt import pyemma.msm as msm import matplotlib.pylab as plt self._intergrityCheck() plt.ion() tpt = msm.tpt(self.model.coarsemsm, [self.source], [self.sink]) mplt.plot_flux(tpt[1], show_committor=False) plt.show()
def evaluate_dominant_paths(TPM, lagtime, source_state, sink_state, time_unit): M = pyemma_msm.markov_model(TPM) tpt = pyemma_msm.tpt(M, [source_state], [sink_state]) (paths,pathfluxes) = tpt.pathways() cumflux = 0 print("Dominant pathways from state %d to state %d:"%(source_state, sink_state)) print("path\t percentage") for i in range(len(paths)): print(paths[i], '\t','%3.1f'%(100.0*pathfluxes[i]/tpt.total_flux)) print('MFPT from state %d to state %d = %f %s'% (source_state, sink_state, M.mfpt(source_state, sink_state)*lagtime, time_unit))
def calculate_mean_passage_time_between_states(mm,topic_labels): #Create a matrix that will hold the data passage_times = np.zeros(shape=(len(topic_labels),len(topic_labels))) df_passage_times = pd.DataFrame(passage_times) for f,row in enumerate(topic_labels): for l,column in enumerate(topic_labels): try: df_passage_times.iloc()[f][l]=msm.tpt(mm,[f],[l]).mfpt except: df_passage_times.iloc()[f][l]=0 column_names = {v: k for v, k in enumerate(topic_labels)} df_passage_times = df_passage_times.rename(columns=column_names,index=column_names) return df_passage_times
def calculate_mean_passage_time_between_states(mm, topic_labels): #Create a matrix that will hold the data #topic_labels = {i:topic_labels[j] for i, j in enumerate(mm.active_set)} passage_times = np.zeros(shape=(len(topic_labels), len(topic_labels))) df_passage_times = pd.DataFrame(passage_times) for f, row in enumerate(topic_labels): for l, column in enumerate(topic_labels): try: #TODO: why no active set? #df_passage_times.iloc()[f][l]=msm.tpt(mm,[mm._full2active[f]],[mm._full2active[l]]).mfpt df_passage_times.iloc()[f][l] = msm.tpt(mm, [f], [l]).mfpt except: df_passage_times.iloc()[f][l] = 0 column_names = {v: k for v, k in enumerate(topic_labels)} df_passage_times = df_passage_times.rename(columns=column_names, index=column_names) return df_passage_times
def test_time_units(self): dtraj = np.random.randint(0, 4, 1000) tau = 12 dt = 0.456 msmobj = estimate_markov_model(dtraj, lag=tau, dt_traj='%f ns' % dt) # check MFPT consistency mfpt_ref = msmobj.mfpt([0], [1]) tptobj = tpt(msmobj, [0], [1]) assert_allclose(tptobj.mfpt, mfpt_ref) assert_allclose( msmana.mfpt(msmobj.P, [1], [0], tau=tau) * dt, mfpt_ref) assert_allclose( np.dot(msmobj.stationary_distribution, tptobj.backward_committor) / tptobj.total_flux, mfpt_ref) # check flux consistency total_flux_ref = tptobj.total_flux A = tptobj.A B = tptobj.B I = tptobj.I assert_allclose( tptobj.gross_flux[A, :][:, B].sum() + tptobj.gross_flux[A, :][:, I].sum(), total_flux_ref) assert_allclose( tptobj.net_flux[A, :][:, B].sum() + tptobj.net_flux[A, :][:, I].sum(), total_flux_ref) assert_allclose( tptobj.flux[A, :][:, B].sum() + tptobj.flux[A, :][:, I].sum(), total_flux_ref) mf = tptobj.major_flux(1.0) assert_allclose(mf[A, :][:, B].sum() + mf[A, :][:, I].sum(), total_flux_ref) # check that the coarse-grained version is consistent too _, tptobj2 = tptobj.coarse_grain([A, I, B]) assert_allclose(tptobj2.total_flux, total_flux_ref) assert_allclose(tptobj2.mfpt, mfpt_ref)
def createTPT(MSM_object, A, B): """ Calculate the reactive flux between sets A and B. Return a ReactiveFlux object""" return msm.tpt(MSM_object, A, B)
def plotFluxPathways( self, statetype="macro", mode="net_flux", fraction=1.0, plot=True, save=None ): """Plot flux pathways between source and sink state. The flux is in units of transition events per lag time used to construct the Markov model. Parameters ---------- statetype : {'macro','coarse','micro'} What type of states to plot mode : {'net_flux', 'gross_flux'} Type of fluxes to plot fraction : float Fraction of fluxes for which to report pathways. Doesn't change the plot, only the text output. plot : bool If set it False the plot will not show up in a figure save : str If a path is passed to save, the plot will be saved to the specified file """ # Make mode a radio button with interactive plot from pyemma import msm from pyemma.plots import plot_flux from matplotlib import pylab as plt self._intergrityCheck() plt.figure() if statetype == "micro": tpt = msm.tpt(self.model.msm, [self.sourcemicro], [self.sinkmicro]) fig, pos = plot_flux(tpt, attribute_to_plot=mode) elif statetype == "macro" or statetype == "coarse": metastable_sets = [] for i in range(self.model.macronum): metastable_sets.append(np.where(self.model.macro_ofmicro == i)[0]) tpt = msm.tpt( self.model.msm, metastable_sets[self.source], metastable_sets[self.sink] ) newsets, tpt = tpt.coarse_grain(metastable_sets) setmap = [] # getting the mapping of new sets to old sets for set1 in newsets: for idx2, set2 in enumerate(metastable_sets): if set(set1) == set(set2): setmap.append(idx2) continue setmap = np.array(setmap) fig, pos = plot_flux(tpt, attribute_to_plot=mode, state_labels=setmap) if save is not None: fig.savefig(save, dpi=300, bbox_inches="tight", pad_inches=0.2) if plot: fig.show() paths, pathfluxes = tpt.pathways(fraction=fraction) cumflux = 0 print("Path flux\t\t%path\t%of total\tpath") for i in range(len(paths)): cumflux += pathfluxes[i] print( "{}\t{:3.1f}%\t{:3.1f}%\t\t{}".format( pathfluxes[i], 100.0 * pathfluxes[i] / tpt.total_flux, 100.0 * cumflux / tpt.total_flux, setmap[paths[i]], ) )
def setUp(self): # 5-state toy system self.P = np.array([[0.8, 0.15, 0.05, 0.0, 0.0], [0.1, 0.75, 0.05, 0.05, 0.05], [0.05, 0.1, 0.8, 0.0, 0.05], [0.0, 0.2, 0.0, 0.8, 0.0], [0.0, 0.02, 0.02, 0.0, 0.96]]) self.A = [0] self.B = [4] self.I = [1, 2, 3] # REFERENCE SOLUTION FOR PATH DECOMP self.ref_committor = np.array( [0., 0.35714286, 0.42857143, 0.35714286, 1.]) self.ref_backwardcommittor = np.array( [1., 0.65384615, 0.53125, 0.65384615, 0.]) self.ref_grossflux = np.array( [[0., 0.00771792, 0.00308717, 0., 0.], [0., 0., 0.00308717, 0.00257264, 0.00720339], [0., 0.00257264, 0., 0., 0.00360169], [0., 0.00257264, 0., 0., 0.], [0., 0., 0., 0., 0.]]) self.ref_netflux = np.array([[ 0.00000000e+00, 7.71791768e-03, 3.08716707e-03, 0.00000000e+00, 0.00000000e+00 ], [ 0.00000000e+00, 0.00000000e+00, 5.14527845e-04, 0.00000000e+00, 7.20338983e-03 ], [ 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 3.60169492e-03 ], [ 0.00000000e+00, 4.33680869e-19, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00 ], [ 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00 ]]) self.ref_totalflux = 0.0108050847458 self.ref_kAB = 0.0272727272727 self.ref_mfptAB = 36.6666666667 self.ref_paths = [[0, 1, 4], [0, 2, 4], [0, 1, 2, 4]] self.ref_pathfluxes = np.array( [0.00720338983051, 0.00308716707022, 0.000514527845036]) self.ref_paths_99percent = [[0, 1, 4], [0, 2, 4]] self.ref_pathfluxes_99percent = np.array( [0.00720338983051, 0.00308716707022]) self.ref_majorflux_99percent = np.array( [[0., 0.00720339, 0.00308717, 0., 0.], [0., 0., 0., 0., 0.00720339], [0., 0., 0., 0., 0.00308717], [0., 0., 0., 0., 0.], [0., 0., 0., 0., 0.]]) msmobj = markov_model(self.P) msmobj.mu = msmana.statdist(self.P) msmobj.estimated = True msmobj1 = msmobj # Testing: # self.tpt1 = tpt(self.P, self.A, self.B) self.tpt1 = tpt(msmobj1, self.A, self.B) # 16-state toy system P2_nonrev = np.array([[ 0.5, 0.2, 0.0, 0.0, 0.3, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ], [ 0.2, 0.5, 0.1, 0.0, 0.0, 0.2, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ], [ 0.0, 0.1, 0.5, 0.2, 0.0, 0.0, 0.2, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ], [ 0.0, 0.0, 0.1, 0.5, 0.0, 0.0, 0.0, 0.4, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ], [ 0.3, 0.0, 0.0, 0.0, 0.5, 0.1, 0.0, 0.0, 0.1, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ], [ 0.0, 0.1, 0.0, 0.0, 0.2, 0.5, 0.1, 0.0, 0.0, 0.1, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ], [ 0.0, 0.0, 0.1, 0.0, 0.0, 0.1, 0.5, 0.2, 0.0, 0.0, 0.1, 0.0, 0.0, 0.0, 0.0, 0.0 ], [ 0.0, 0.0, 0.0, 0.1, 0.0, 0.0, 0.3, 0.5, 0.0, 0.0, 0.0, 0.1, 0.0, 0.0, 0.0, 0.0 ], [ 0.0, 0.0, 0.0, 0.0, 0.1, 0.0, 0.0, 0.0, 0.5, 0.1, 0.0, 0.0, 0.3, 0.0, 0.0, 0.0 ], [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.1, 0.0, 0.0, 0.2, 0.5, 0.1, 0.0, 0.0, 0.1, 0.0, 0.0 ], [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.1, 0.0, 0.0, 0.1, 0.5, 0.1, 0.0, 0.0, 0.2, 0.0 ], [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.1, 0.0, 0.0, 0.2, 0.5, 0.0, 0.0, 0.0, 0.2 ], [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.3, 0.0, 0.0, 0.0, 0.5, 0.2, 0.0, 0.0 ], [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.1, 0.0, 0.0, 0.3, 0.5, 0.1, 0.0 ], [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.2, 0.0, 0.0, 0.1, 0.5, 0.2 ], [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.3, 0.0, 0.0, 0.2, 0.5 ]]) pstat2_nonrev = msmana.statdist(P2_nonrev) # make reversible C = np.dot(np.diag(pstat2_nonrev), P2_nonrev) Csym = C + C.T self.P2 = Csym / np.sum(Csym, axis=1)[:, np.newaxis] pstat2 = msmana.statdist(self.P2) self.A2 = [0, 4] self.B2 = [11, 15] self.coarsesets2 = [ [2, 3, 6, 7], [10, 11, 14, 15], [0, 1, 4, 5], [8, 9, 12, 13], ] # REFERENCE SOLUTION CG self.ref2_tpt_sets = [ set([0, 4]), set([2, 3, 6, 7]), set([10, 14]), set([1, 5]), set([8, 9, 12, 13]), set([11, 15]) ] self.ref2_cgA = [0] self.ref2_cgI = [1, 2, 3, 4] self.ref2_cgB = [5] self.ref2_cgpstat = np.array([ 0.15995388, 0.18360442, 0.12990937, 0.11002342, 0.31928127, 0.09722765 ]) self.ref2_cgcommittor = np.array( [0., 0.56060272, 0.73052426, 0.19770537, 0.36514272, 1.]) self.ref2_cgbackwardcommittor = np.array( [1., 0.43939728, 0.26947574, 0.80229463, 0.63485728, 0.]) self.ref2_cggrossflux = np.array( [[0., 0., 0., 0.00427986, 0.00282259, 0.], [0., 0, 0.00234578, 0.00104307, 0., 0.00201899], [0., 0.00113892, 0, 0., 0.00142583, 0.00508346], [0., 0.00426892, 0., 0, 0.00190226, 0.], [0., 0., 0.00530243, 0.00084825, 0, 0.], [0., 0., 0., 0., 0., 0.]]) self.ref2_cgnetflux = np.array( [[0., 0., 0., 0.00427986, 0.00282259, 0.], [0., 0., 0.00120686, 0., 0., 0.00201899], [0., 0., 0., 0., 0., 0.00508346], [0., 0.00322585, 0., 0., 0.00105401, 0.], [0., 0., 0.0038766, 0., 0., 0.], [0., 0., 0., 0., 0., 0.]]) """Dummy dtraj to trick trick constructor of MSM""" dtraj = [0, 0] tau = 1 msmobj = markov_model(self.P2) msmobj.mu = msmana.statdist(self.P2) msmobj.estimated = True msmobj2 = msmobj # Testing self.tpt2 = tpt(msmobj2, self.A2, self.B2)
import pdb import matplotlib.pyplot as plt P = np.array([[0.8, 0.15, 0.05, 0.0, 0.0], [0.1, 0.75, 0.05, 0.05, 0.05], [0.05, 0.1, 0.8, 0.0, 0.05], [0.0, 0.2, 0.0, 0.8, 0.0], [0.0, 0.02, 0.02, 0.0, 0.96]]) M = msm.markov_model(P) pos = np.array([[2.0, -1.5], [1, 0], [2.0, 1.5], [0.0, -1.5], [0.0, 1.5]]) pl = mplt.plot_markov_model(M, pos=pos) #pl[0].show() A = [0] B = [4] tpt = msm.tpt(M, A, B) # get tpt gross flux F = tpt.gross_flux print('**Flux matrix**:') print(F) print('**forward committor**:') print(tpt.committor) print('**backward committor**:') print(tpt.backward_committor) # we position states along the y-axis according to the commitor tptpos = np.array([tpt.committor, [0, 0, 0.5, -0.5, 0]]).transpose() print('\n**Gross flux illustration**: ') pl = mplt.plot_flux(tpt, pos=tptpos, arrow_label_format="%10.4f",
# Get the model # ------ kin_zip = np.load('../kin_zip.npz') TNres_CG = kin_zip['T_zip'] # Let's compute the conditional path entropy for each path and then perform a weighted sum according to the fractional flux from copy import deepcopy s = 0 d = 31 # we are going to need the probability that a traj passes from i to j through d Alpha_CG = np.zeros(shape=(TNres_CG.shape[0],TNres_CG.shape[1])) for row in range(TNres_CG.shape[0]): for col in np.delete(np.arange(TNres_CG.shape[0]),[row]): mle_Nres_CG = pyemma.msm.markov_model(TNres_CG) tpt_tmp = msm.tpt(mle_Nres_CG,[row],[col]) try: # some of the node pairs have too low connections for this analysis?? paths_tmp = np.array(tpt_tmp.pathways()) # grab only paths that pass through d subpaths = np.where( np.array([d in path for path in paths_tmp[0]]) == True ) Alpha_CG[row,col] = np.sum(paths_tmp[1][subpaths]) / np.sum(paths_tmp[1]) except: Alpha_CG[row,col] = 0. np.save('Alpha_unf',Alpha_CG) s = 31 d = 0 # we are going to need the probability that a traj passes from i to j through d Alpha_CG = np.zeros(shape=(TNres_CG.shape[0],TNres_CG.shape[1])) for row in range(TNres_CG.shape[0]):
1.94053514e-02, 0.00000000e+00 ], [ 9.75896673e-03, 0.00000000e+00, -3.56068076e-02, 1.53539843e-02, 1.04938566e-02 ], [ 4.98873182e-05, 6.06203157e-03, 3.28301032e-03, -9.39492921e-03, 0.00000000e+00 ], [ 1.35496766e-02, 0.00000000e+00, 1.17575223e-02, 0.00000000e+00, -2.53071990e-02 ]]) tau = 1.E-2 T = expm(K * tau) # NB TPT results should be invariant with tau my_msm = msm.markov_model(T) A = [0] B = [4] my_msm_tpt = msm.tpt(my_msm, A, B) print("Stationary distribution:") print(my_msm_tpt.mu) print("Forward committor:") print(my_msm_tpt.committor) print("Backward committor:") print(my_msm_tpt.backward_committor)
print(topic_list_with_labels[element]) print(topic_list[element]) print('\n') if i == 10: break # Print the eigenvalues of states '''for element in mm.eigenvalues().argsort()[::-1]: print (topic_list[element]) ''' # Calculate the flux between two states (topic_2, selection and topic_8_14 camp liquidiation / camp transfer ) A = [topic_list.index('topic_2')] B = [topic_list.index('topic_8_14')] tpt = msm.tpt(mm, A, B) nCut = 1 (bestpaths, bestpathfluxes) = tpt.pathways(fraction=0.95) cumflux = 0 # Print the best path between the two states print("Path flux\t\t%path\t%of total\tpath") for i in range(len(bestpaths)): cumflux += bestpathfluxes[i] print(bestpathfluxes[i], '\t', '%3.1f' % (100.0 * bestpathfluxes[i] / tpt.total_flux), '%\t', '%3.1f' % (100.0 * cumflux / tpt.total_flux), '%\t\t', bestpaths[i])
'topic_name': topic_labels[element], 'stationary_prob': mm.pi[element] }) if i == 12: break # Print the eigenvalues of states '''for element in mm.eigenvalues().argsort()[::-1]: print (topic_list[element]) ''' # Calculate the flux between two states (topic_2, selection and topic_8_14 camp liquidiation / camp transfer ) A = [8] B = [2, 13] tpt = msm.tpt(mm, A, B) nCut = 1 (bestpaths, bestpathfluxes) = tpt.pathways(fraction=0.5) cumflux = 0 # Print the best path between the two states print("Path flux\t\t%path\t%of total\tpath") for i in range(len(bestpaths)): cumflux += bestpathfluxes[i] print(bestpathfluxes[i], '\t', '%3.1f' % (100.0 * bestpathfluxes[i] / tpt.total_flux), '%\t', '%3.1f' % (100.0 * cumflux / tpt.total_flux), '%\t\t',
from msmtools.analysis.dense.decomposition import eigenvectors, eigenvalues import operator from copy import deepcopy # Get the model TNres_CG = np.load('../MLE/T_mle.npy') # Get the probability that a traj passes from i to j through d Alpha_CG = np.load('Alpha_fol.npy') # Let's compute the conditional path entropy for each of the dominant reaction pathways s = 31 d = 0 # get the reaction pathways from s to d mle_Nres_CG = pyemma.msm.markov_model(TNres_CG) tpt_mle_CG = msm.tpt(mle_Nres_CG, [s], [d]) paths_CG_fol = np.array(tpt_mle_CG.pathways()) # compute the conditional path entropy according to Kafsi et al. IEEE Inf Theory (2013) H_path_cond_CG = [] for path in paths_CG_fol[0]: tmp = 1. H_tmp = 0. for node in range(len(path) - 2): # Get Tp Tp = deepcopy(TNres_CG) for row in range(TNres_CG.shape[0]): if ((row == path[node + 1]) or (row == d)): Tp[row] *= 0. Tp[row, row] = 1. continue
reversible_type='mle', sliding_window=1, ergodic_cutoff='on', prior_counts=0, verbose=True) msm_model.fit(assignment_array) print msm_model.transmat_ TPM = msm.markov_model(msm_model.transmat_) ########################using pyemma to get transition paths set1 = numpy.where(mapping == source)[0] set2 = numpy.where(mapping == sink)[0] #print set1 #print set2 tpt = msm.tpt(TPM, set1, set2) ## get tpt gross flux #print "grpss flux matrix" #print tpt.gross_flux #print "forward committor matrix" #print tpt.committor #print "backward committor matrix" #print tpt.backward_committor_matrix # ## get tpt net flux #Fp = tpt.net_flux #print "net flux matrix" #print Fp # #print "###########################################################"