MasterMSM 2.0.1__py3-none-any.whl

mastermsm/__init__.py

@@ -0,0 +1 @@
+__version__ = "2.0.1"

mastermsm/fewsm/fewsm.py

@@ -0,0 +1,260 @@
+"""
+This file is part of the MasterMSM package.
+
+"""
+
+import copy
+import warnings
+#import random
+from ..msm import msm
+from ..trajectory import traj, traj_lib
+#import msm_lib
+from ..fewsm import fewsm_lib
+
+class FEWSM(msm.MSM):
+    """
+    A class for doing clustering of MSMs into few-state models
+
+    Attributes
+    ----------
+    keys : dict
+        A dictionary containing the clusters formed.
+    parent : class
+        Instance of the MSM class that we aim to cluster.
+
+    """
+    def __init__(self, parent, N=2, method="robust"):
+        """
+
+        Parameters
+        ----------
+        parent : class
+            Instance of the MSM class that we aim to cluster.
+        N : int
+            The desired number of clusters.
+
+        """
+        self.parent = parent
+        self.N = N
+        self.keys = list(range(N))
+        self.lagt = parent.lagt
+        self.sliding = parent.sliding
+        self.sym = parent.sym
+        self.macros = self.eigen_group(N=self.N, method=method)
+
+    def eigen_group(self, N=2, method="robust"):
+        """ Splits microstates into macrostates
+
+        Parameters
+        ----------
+        N : int
+            Number of clusters.
+        method : str
+            The method used for clustering.
+
+        Returns
+        -------
+        macros : dict
+            A dictionary with the membership to macrostates.
+
+        """
+
+        # generate eigenvectors in case the MSM does not have them
+        if not hasattr(self.parent, 'lvecsT'):
+            if not hasattr(self.parent, 'trans'):
+                self.parent.calc_trans()
+            self.parent.calc_evals(evecs=True)
+        lvecs = self.parent.lvecsT
+
+        # split in desired number of macrostates
+        macros = {}
+        keep_states = self.parent.keep_states
+        macros[0] = list(range(len(keep_states)))
+        for n in range(1, N):
+            if method == "robust":
+                macro_new, _ = fewsm_lib.split_sigma(macros, lvecs[:,n])
+            elif method == "sign":
+                macro_new, _ = fewsm_lib.split_sign(macros, lvecs[:,n])
+            macros = copy.deepcopy(macro_new)
+        print ("\n Initial membership of microstates to macrostates:")
+        if len(self.parent.keep_keys) < 100:
+            for k,v in macros.items():
+                print (k, [self.parent.keep_keys[x] for x in v])
+        else:
+            for k,v in macros.items():
+                print (k,":", len(v))
+        return macros
+
+    def map_trajectory(self):
+        """ Maps trajectory onto the PCCA clusters
+
+        Frames in microstates outside the connected set (not in
+        ``keep_keys``) are removed if they are at the start of a
+        trajectory, and otherwise inherit the macrostate of the
+        previous frame. A trajectory that never visits the connected
+        set is left out, with a warning.
+
+        Returns
+        -------
+        mappedtraj : list
+            One TimeSeries per parent trajectory, stored in
+            ``self.mappedtraj``.
+
+        """
+        print ("\n Mapping trajectory onto macrostates...")
+        mappedtraj = []
+        keep_keys = self.parent.keep_keys
+        # macrostate of each microstate key
+        macro_of = {keep_keys[i]: k for k, v in self.macros.items() \
+                for i in v}
+        for n, data in enumerate(self.parent.data):
+            # one mapped trajectory per parent trajectory; -1 marks
+            # frames outside the connected set
+            mt_states = [macro_of.get(s, -1) for s in data.distraj]
+            start = next((i for i, s in enumerate(mt_states) \
+                    if s >= 0), None)
+            if start is None:
+                warnings.warn("trajectory %i never visits the "
+                        "connected set; left out of mappedtraj"%n)
+                continue
+            mt_states = traj_lib._filter_states(mt_states[start:])
+            mt = traj.TimeSeries(distraj=mt_states, dt=data.dt)
+            mappedtraj.append(mt)
+        self.mappedtraj = mappedtraj
+        #super().__init__(mappedtraj, keys=range(self.N), lagt=self.parent.lagt)
+
+    def calc_count(self, nproc=None, sym=False):
+        """ Calculates the macrostate count matrix
+
+        Lumps the count matrix of the parent MSM according to the
+        current membership in self.macros. This is what counting
+        transitions on the mapped trajectories gives at the lag time
+        of the parent. The arguments are unused and kept only for
+        compatibility with MSM.calc_count.
+
+        """
+        self.count = fewsm_lib.map_micro2macro(self.parent.count, \
+                self.macros, self.parent.keep_states)
+
+    def metastability(self):
+        """ Calculate metastability according to the definition
+        in Chodera et al, J Chem Phys, (2007)
+
+        The macrostate transition matrix is rebuilt from the current
+        membership in self.macros on every call.
+
+        Returns
+        -------
+        float
+            Metastability
+
+        """
+        self.calc_count()
+        self.calc_trans()
+        return fewsm_lib.metastability(self.trans)
+
+#    def optim(self, nsteps=1, nwrite=None, fout="mc.dat"):
+#        """ MC optimization using the metastability Q as energy.
+#
+#        Parameters
+#        ----------
+#        nsteps : int
+#            Number of steps per round of MC and per microstate.
+#        nwrite : int
+#            Frequency of writing MC output.
+#        fout : string
+#            File for output of MC progress.
+#
+#        Returns
+#        -------
+#        macro_opt : dict
+#            Dictionary with the membership to macrostates.
+#
+#        """
+#        print "\n Optimizing the lumped MSM\n"
+#        out = open(fout, "w")
+#        out.write("#    iter       q \n")
+#
+#        nmac = self.N
+#        nmic = len(self.parent.keep_keys)
+#        mcsteps = len(self.count)*nsteps*nmic # mc steps per block
+#        mcsteps_max = nmic*20000 # maximum number of mc steps
+#        print self.count
+#        print self.trans
+#        q =  self.metastability()
+#        print " initial:", q
+#        q_opt = q
+#
+#        macro = copy.deepcopy(self.macros)
+#        cont = True
+#        nmc = 0 # number of mc blocks
+#        reject = 0
+#        while cont:
+#            imc = 0
+#            out.write ("%6i %12.10f %10.6e\n"%(imc + nmc*mcsteps,q,1))
+#            while imc < mcsteps:
+#                # try ramdom insertion of a microstate in a macrostate
+#                imac = 0
+#                jmac = 0
+#                while imc < mcsteps:
+#                    imc +=1
+#                    while True:
+#                        # choose microstate to move around
+#                        imic = random.choice(range(nmic))
+#                        imac = int([x for x in range(nmac) if imic in macro[x]][0])
+#                        if len(macro[imac]) > 1:
+#                            # choose destination macrostate
+#                            jmac = random.choice([x for x in range(nmac) if x is not imac])
+#                            break
+#                    # move microstate from i to j
+#                    macro_new = copy.deepcopy(macro)
+#                    macro_new[imac].remove(imic)
+#                    macro_new[jmac].append(imic)
+#                    # calculate transition count matrix for new mapping
+#                    count_mac_new = fewsm_lib.map_micro2macro(self.parent.count, macro_new, self.parent.keep_states)
+#                    Tmacro_new = msm_lib.calc_trans(nmac, range(nmac), count_mac_new)
+#                    # calculate metastability
+#                    q_new = fewsm_lib.metastability(Tmacro_new)
+#                    delta = fewsm_lib.beta(imc,mcsteps)*(q - q_new) # calculate increment (Q is a -Energy)
+#                    if fewsm_lib.metropolis(delta):
+#                        #print "ACCEPT"
+#                        macro = copy.deepcopy(macro_new)
+#                        count_mac = count_mac_new
+#                        q = q_new
+#                        if q > q_opt:
+#                            q_opt = q
+#                            macro_opt = copy.deepcopy(macro)
+#                            Tmacro_opt = Tmacro_new
+#                            self.macro = copy.deepcopy(macro_opt)
+#                    else:
+#                        reject+=1
+#                        #print " REJECT"
+#
+#                    out.write ("%6i %12.10e %10.6e\n"%(imc + nmc*mcsteps,q,1./fewsm_lib.beta(imc,mcsteps)))
+#                    imc +=1
+#                cont = False
+#        print " final :", q
+#        print " best :", q_opt
+#        print " acceptance:",1.-float(reject)/mcsteps
+#
+#        self.map_trajectory()
+#        self.do_count()
+#        self.do_trans()
+#
+#    def write_mapping(self):
+#        """
+#        Prints files with the mapping between states and clusters
+#
+#        """
+#        for mtraj in self.mappedtraj:
+#            try:
+#                idf = mtraj.filename.rfind(".dat")
+#                filename = mtraj.filename[:idf] + "_mapped_pcca%g.dat"%self.N
+#            except ValueError:
+#                filename = mtraj.filename + "_mapped_pcca%g.dat"%self.N
+#            print " ...writing mapped trajectory at %s"%filename
+#            fout = open(filename, "w")
+#            micro_data = [x for x in self.parent.data if x.filename == mtraj.filename][0]
+#            for x in zip(micro_data.time, micro_data.states, self.data[0].states):
+#                fout.write("%10.3f %s %8i\n"%(x[0], x[1], x[2]))
+#            fout.close()

mastermsm/fewsm/fewsm_lib.py

@@ -0,0 +1,106 @@
+"""
+This file is part of the MasterMSM package.
+
+"""
+import copy, itertools
+import numpy as np
+
+def map_micro2macro(cmic, mac, states):
+    """ maps microstates into macrostates """
+    m = len(mac)
+    cmac = np.zeros((m, m), int)
+    for i in range(m):
+        for j in range(m):
+            cmac[j,i] = sum(cmic[states[x],states[y]] for (x,y) in \
+                    itertools.product(mac[j],mac[i]))
+    return cmac
+
+def test_sign(v):
+    """check whether positive and negative signs are present in vector"""
+    test = False
+    if any(v > 0.) and  any(v<0):
+        test = True
+    return test
+
+def split_sign(macro, lvec):
+    """ split based on sign structure """
+    # calculate spread in eigenvector
+    nt = len(macro)
+    spread = []
+    vals = lvec
+    for _, v in macro.items():
+        # check that there are positive and negative values in evec
+        if test_sign(vals[v]):
+            #spread.append(np.sum(vals**2))
+            spread.append(np.mean(vals[v]**2))
+        else:
+            spread.append(0.)
+    isplit = np.argsort(-np.array(spread))[0]
+#    print "         macrostate to split: %i"%isplit,np.array(spread)
+    # split
+    lvec_split = lvec[macro[isplit]]
+#    print lvec_split
+    elems = []
+    for i in filter(lambda x: lvec_split[x] < 0.,\
+        range(len(macro[isplit]))):
+        elems.append(macro[isplit][i])
+    macro_new = copy.deepcopy(macro)
+    macro_new[nt] = elems
+    # update old macrostate
+    for i in elems:
+        macro_new[isplit].remove(i)
+    return macro_new, vals
+
+def split_sigma(macro, lvec):
+    """ split based on distribution """
+    nt = len(macro)
+
+    spread = []
+    for i in macro.keys():
+        spread.append(np.std(lvec[macro[i]]))
+    # split macrostates with maximum spread
+    isplit = np.argsort(-np.array(spread))[0]
+    #print "         macrostate to split: %i"%isplit,spread[isplit]
+    # split based on distribution
+    elems = []
+    keep = []
+    val_max =  np.max(lvec[macro[isplit]])
+    val_min =  np.min(lvec[macro[isplit]])
+    vals = (lvec[macro[isplit]] - val_min)/(val_max - val_min)
+    for i in filter(lambda x: vals[x] < 0.5,range(len(macro[isplit]))):
+        elems.append(macro[isplit][i])
+    for i in filter(lambda x: vals[x] >= 0.5,range(len(macro[isplit]))):
+        keep.append(macro[isplit][i])
+    macro_new = copy.deepcopy(macro)
+    macro_new[nt] = elems
+    #print macro_new
+    # update old macrostate
+    for i in elems:
+        macro_new[isplit].remove(i)
+    macro = copy.deepcopy(macro_new)
+    return macro, vals
+
+def metastability(T):
+    return np.sum(np.diag(T))
+
+def beta(imc,mcsteps):
+    # inverse temperature for MCSA
+    x = imc - 1
+    a = 4./mcsteps
+    temp = (1 + (np.exp(-a*x)-1.)/(1.- np.exp(-a*mcsteps))) # MCSA temperature
+    try:
+        beta = 1./temp
+    except ZeroDivisionError:
+        beta = 1e20
+    return beta
+
+def metropolis(delta):
+    if delta < 0:
+        return True
+    else:
+        accept = False
+        p = min(1.0,np.exp(-delta))
+        rand = np.random.random()
+        if (rand < p):
+            accept = True
+        return accept