Example #1
0
    def setUp(self):
        Monomer('A', ['a'])
        Monomer('B', ['b'])

        Parameter('ksynthA', 100)
        Parameter('ksynthB', 100)
        Parameter('kbindAB', 100)

        Parameter('A_init', 0)
        Parameter('B_init', 0)

        Initial(A(a=None), A_init)
        Initial(B(b=None), B_init)

        Observable("A_free", A(a=None))
        Observable("B_free", B(b=None))
        Observable("AB_complex", A(a=1) % B(b=1))

        Rule('A_synth', None >> A(a=None), ksynthA)
        Rule('B_synth', None >> B(b=None), ksynthB)
        Rule('AB_bind', A(a=None) + B(b=None) >> A(a=1) % B(b=1), kbindAB)

        self.model = model

        # This timespan is chosen to be enough to trigger a Jacobian evaluation
        # on the various solvers.
        self.time = np.linspace(0, 1)
        self.solver = Solver(self.model, self.time, integrator='vode')
Example #2
0
def visualize():
    for ACC_NO in ACC_NOs:
        dot_r = render_reactions.run(models[ACC_NO])
        dotfile_r = open('model_reactions-' + ACC_NO + '.dot', 'w')
        dotfile_r.write(dot_r)
        dotfile_r.close()
        system('dot -T pdf model_reactions-' + ACC_NO +
               '.dot -o model_reactions-' + ACC_NO + '.pdf')
        dot_s = render_species.run(models[ACC_NO])
        dotfile_s = open('model_species-' + ACC_NO + '.dot', 'w')
        dotfile_s.write(dot_s)
        dotfile_s.close()
        system('ccomps -x model_species-' + ACC_NO +
               '.dot | dot | gvpack -m0 | neato -n2 -T pdf -o model_species-' +
               ACC_NO + '.pdf')
        # Run the simulation
        solver = Solver(models[ACC_NO], t)
        solver.run()
        yout = solver.yobs
        # Plot simulation results for the observables in the model
        pl.ion()
        pl.figure()
        for observ in outputs[ACC_NO]:
            pl.plot(t, yout[observ], label=observ)
        pl.legend()
        pl.xlabel("Time (minutes)")
        pl.ylabel("Distribution of radioactive iron/body compartments")
        pl.savefig('model_results-' + ACC_NO + '.png')
        pl.clf()
Example #3
0
def scatter_plot():
    n = 100
    mod = models['adequate']
    for param in param_bounds.keys():
        prob = {
            'num_vars': 1,
            'names': [param],
            'bounds': [param_bounds[param]]
        }
        par_sets = [p[0] for p in sampling_method.sample(prob, n)]
        solver = Solver(mod, t)
        res_sets = {out: [] for out in outputs['adequate']}
        for par_set in par_sets:
            pars = {p.name: p.value for p in mod.parameters}
            pars[param] = par_set
            solver.run(pars)
            for out in outputs['adequate']:
                res_sets[out].append(solver.yobs[out][-1])  # last result
        # Plot simulation results for the observables in the model
        pl.ion()
        pl.figure(figsize=(8, 8))
        for res in res_sets.keys():
            pl.scatter(par_sets, res_sets[res], label=res)
        pl.legend()
        pl.xlabel(param)
        pl.ylabel("Outputs")
        pl.savefig('scatterplots/' + param + '.png', dpi=300)
        pl.clf()
Example #4
0
def run_query(model, query):
    m = re.match('Is the amount of (.+) ([^ ]+) in time?', query)
    target_str = m.groups()[0]
    pattern_str = m.groups()[1]

    ts = numpy.linspace(0, 100, 10)
    solver = Solver(model, ts)
    solver.run()

    if target_str == 'A-B complex':
        target = 'AB'

    if target_str == 'A':
        target = 'A'

    for i, a in enumerate(solver.yobs[target]):
        solver.yobs[target][i] = 1 if a > 50 else 0

    if pattern_str == 'sustained':
        fstr = sustained_formula(target)
    elif pattern_str == 'transient':
        fstr = transient_formula(target)
    elif pattern_str == 'unchanged':
        fstr = noact_formula(target)

    print '\n\n'
    print '-----------'
    print query
    print 'LTL formula: %s' % fstr
    mc = ModelChecker(fstr, solver.yobs)
    print solver.yobs[target]
    print 'Result:', mc.truth
    print '-----------'
Example #5
0
 def test_vode_jac_solver_run(self):
     """Test vode and analytic jacobian."""
     solver_vode_jac = Solver(self.model,
                              self.time,
                              integrator='vode',
                              use_analytic_jacobian=True)
     solver_vode_jac.run()
Example #6
0
 def test_lsoda_jac_solver_run(self):
     """Test lsoda and analytic jacobian."""
     solver_lsoda_jac = Solver(self.model,
                               self.time,
                               integrator='lsoda',
                               use_analytic_jacobian=True)
     solver_lsoda_jac.run()
Example #7
0
def test_integrate_with_expression():
    """Ensure a model with Expressions simulates."""

    Monomer('s1')
    Monomer('s9')
    Monomer('s16')
    Monomer('s20')

    # Parameters should be able to contain s(\d+) without error
    Parameter('ks0', 2e-5)
    Parameter('ka20', 1e5)

    Initial(s9(), Parameter('s9_0', 10000))

    Observable('s1_obs', s1())
    Observable('s9_obs', s9())
    Observable('s16_obs', s16())
    Observable('s20_obs', s20())

    Expression('keff', (ks0 * ka20) / (ka20 + s9_obs))

    Rule('R1', None >> s16(), ks0)
    Rule('R2', None >> s20(), ks0)
    Rule('R3', s16() + s20() >> s16() + s1(), keff)

    time = np.linspace(0, 40)

    solver = Solver(model, time)
    solver.run()

    assert solver.yexpr_view.shape == (len(time),
                                       len(model.expressions_dynamic()))
    assert solver.yobs_view.shape == (len(time), len(model.observables))
Example #8
0
def test_integrate_with_expression():
    """Ensure a model with Expressions simulates."""

    Monomer('s1')
    Monomer('s9')
    Monomer('s16')
    Monomer('s20')

    # Parameters should be able to contain s(\d+) without error
    Parameter('ks0',2e-5)
    Parameter('ka20', 1e5)

    Initial(s9(), Parameter('s9_0', 10000))

    Observable('s1_obs', s1())
    Observable('s9_obs', s9())
    Observable('s16_obs', s16())
    Observable('s20_obs', s20())

    Expression('keff', (ks0*ka20)/(ka20+s9_obs))

    Rule('R1', None >> s16(), ks0)
    Rule('R2', None >> s20(), ks0)
    Rule('R3', s16() + s20() >> s16() + s1(), keff)

    time = np.linspace(0, 40)

    solver = Solver(model, time)
    solver.run()

    assert solver.yexpr_view.shape == (len(time),
                                       len(model.expressions_dynamic()))
    assert solver.yobs_view.shape == (len(time), len(model.observables))
Example #9
0
def check_runtime(model, tspan, iterations, use_inline, use_analytic_jacobian):
    Solver._use_inline = use_inline
    sol = Solver(model, tspan, use_analytic_jacobian=use_analytic_jacobian)
    start_time = timeit.default_timer()
    for i in range(iterations):
        sol.run()
    elapsed = timeit.default_timer() - start_time
    print("use_inline=%s, use_analytic_jacobian=%s, %d iterations" %
          (use_inline, use_analytic_jacobian, iterations))
    print("Time: %f sec\n" % elapsed)
Example #10
0
def test_ic_expression_with_one_parameter():
    Monomer('A')
    Parameter('k1', 1)
    Expression('e1', k1)
    Rule('A_deg', A() >> None, k1)
    Initial(A(), e1)
    generate_equations(model)
    t = np.linspace(0, 1000, 100)
    sol = Solver(model, t, use_analytic_jacobian=True)
    sol.run()
Example #11
0
def simulate_vemurafenib_treatment(model, ts, y0):
    # New initial conditions for simulation post event
    y_init = y0
    y_init[model.observables['Vem_free'].species[0]] = 2e5

    # Continue model simulation with y_init as new initial condition
    solver = Solver(model, ts)
    solver.run(y0=y_init)

    # Concatenate the two simulations
    return solver.yobs, solver.y
Example #12
0
def run_one_model(model, data, prior_vals, ns, pool=None):
    # Vector of estimated parameters
    pe = [p for p in model.parameters if p.name.startswith('k')]

    # Generate model equations
    generate_equations(model)
    Solver._use_inline = True
    sol = Solver(model, numpy.linspace(0, 10, 10))
    sol.run()

    # Number of temperatures, dimensions and walkers
    ntemps = 20
    ndim = len(pe)
    blocksize = 48
    nwalkers = get_num_walkers(ndim, blocksize)
    print 'Running %d walkers at %d temperatures for %d steps.' %\
          (nwalkers, ntemps, ns)

    sampler = emcee.PTSampler(ntemps,
                              nwalkers,
                              ndim,
                              likelihood,
                              prior,
                              threads=1,
                              pool=pool,
                              betas=None,
                              a=2.0,
                              Tmax=None,
                              loglargs=[model, data],
                              logpargs=[model, prior_vals],
                              loglkwargs={},
                              logpkwargs={})

    # Random initial parameters for walkers
    p0 = numpy.ones((ntemps, nwalkers, ndim))
    for i in range(ntemps):
        for j in range(nwalkers):
            for k, pp in enumerate(pe):
                p0[i, j, k] = prior_vals.vals[j][pp.name]
    print p0
    # Run sampler
    fname = scratch_path + 'chain_%s.dat' % model.name
    step = 0
    for result in sampler.sample(p0, iterations=ns, storechain=True):
        print '---'
        position = result[0]
        with open(fname, 'a') as fh:
            for w in range(nwalkers):
                for t in range(ntemps):
                    pos_str = '\t'.join(['%f' % p for p in position[t][w]])
                    fh.write('%d\t%d\t%d\t%s\n' % (step, w, t, pos_str))
        step += 1
    return sampler
def sim_experiment(model, exp, pd=None):
    if pd is None:
        pd = {}
    pd['ERK_0'] = exp.ERKtot * exp.ERK[0]
    pd['ERKpT_0'] = exp.ERKtot * exp.ERKpT[0]
    pd['ERKpY_0'] = exp.ERKtot * exp.ERKpY[0]
    pd['ERKpTpY_0'] = exp.ERKtot * exp.ERKpTpY[0]
    pd['MEK_0'] = exp.MEKtot
    pd['MKP_0'] = exp.MKPtot

    solver = Solver(model, exp.ts, use_analytic_jacobian=True)
    solver.run(pd)
    return solver.yobs
Example #14
0
def get_steady_state(model, y0):
    sim_hours = 1
    t = np.linspace(0, sim_hours * 3600, sim_hours * 60)
    solver = Solver(model, t)
    ss = False
    y_init = y0
    while not ss:
        solver.run(y0=y_init)
        ss = is_steady_state(solver.yobs)
        y_init = solver.y[-1]
    steady_state = solver.yobs[-1]
    timecourse = solver.yobs
    return steady_state, timecourse
Example #15
0
def test_piecewise_expression():
    Monomer('A')
    Observable('A_total', A())
    Expression(
        'A_deg_expr',
        Piecewise((0, A_total < 400.0), (0.001, A_total < 500.0),
                  (0.01, True)))
    Initial(A(), Parameter('A_0', 1000))
    Rule('A_deg', A() >> None, A_deg_expr)
    generate_equations(model)
    t = np.linspace(0, 1000, 100)
    sol = Solver(model, t, use_analytic_jacobian=True)
    sol.run()
Example #16
0
def test_nested_expression():
    Monomer('A')
    Monomer('B')
    Parameter('k1', 1)
    Observable('o1', B())
    Expression('e1', o1 * 10)
    Expression('e2', e1 + 5)
    Initial(A(), Parameter('A_0', 1000))
    Initial(B(), Parameter('B_0', 1))
    Rule('A_deg', A() >> None, e2)
    generate_equations(model)
    t = np.linspace(0, 1000, 100)
    sol = Solver(model, t, use_analytic_jacobian=True)
    sol.run()
Example #17
0
    def _initiate_log(self):

        # retrieve time points from data
        for each in self.processed_data:
            self.time.append(float(each[0]))

        # set parameter values or prior ranges (log-space)
        for each in self.model.parameters:

            if each.name[-2:] == '_0':
                self.params.append(each.value)
            if each.name[-3:] == '1kf':
                self.params.append(self.prior_1kf)
            if each.name[-3:] == '2kf':
                self.params.append(self.prior_2kf)
            if each.name[-3:] == '1kr':
                self.params.append(self.prior_1kr)
            if each.name[-3:] == '1kc':
                self.params.append(self.prior_1kc)

        # create solver object
        self.model_solver = Solver(self.model,
                                   self.time,
                                   integrator='lsoda',
                                   integrator_options={
                                       'atol': 1e-12,
                                       'rtol': 1e-12,
                                       'mxstep': 20000
                                   })

        # construct the working population of N parameter sets
        k = 0
        while k < self.N:

            # randomly choose points from parameter space
            point = []
            for each in self.params:
                if isinstance(each, list):
                    point.append(10**(np.random.uniform(each[0], each[1])))
                else:
                    point.append(each)

            objective = self._compute_objective(point)
            if not isnan(objective):
                self.working_set.append([objective, point])
                print k, objective
                k += 1

        self.working_set.sort()
Example #18
0
def likelihood(p, model, data, plot=False):
    pd = parameter_dict(model, p)
    lh = 0
    tstart = time.time()
    Solver._use_inline = True
    sol = Solver(model, data[0].ts, nsteps=1e5)
    for i, exp in enumerate(data):
        # Experiment 1 is a control that is not relevant for
        # model fitting.
        if i == 1:
            continue
        yobs = sim_experiment(model, exp, pd, sol)
        erk = yobs['ERKu'] / exp.ERKtot
        erkpt = yobs['ERKpT'] / exp.ERKtot
        erkpy = yobs['ERKpY'] / exp.ERKtot

        lh += gauss_lh(erk[1:], exp.ERK[1:], exp.ERK_std[1:])
        lh += gauss_lh(erkpt[1:], exp.ERKpT[1:], exp.ERKpT_std[1:])
        lh += gauss_lh(erkpy[1:], exp.ERKpY[1:], exp.ERKpY_std[1:])

    tend = time.time()
    print lh, tend - tstart
    sys.stdout.flush()
    if numpy.isnan(lh):
        return -numpy.inf
    else:
        return lh
Example #19
0
    def plot_func(self, x=None):
        """Plots the timecourses with the parameter values given by x.

        Parameters
        ----------
        x : np.array or list
            The parameters to use for the plot. These should be in the same
            order used by the objective function: globally fit parameters
            first, then a set of local parameters for each of the timecourses
            being fit.
        """
        if x is None:
            if self.result is None:
                raise ValueError('x must be a vector of parameter values.')
            else:
                # If minimize was run, the parameters will be in the 'x'
                # attribute of the result object
                try:
                    x = 10**self.result.x
                # If leastsq was run, the parameters will be the first entry
                # in the result tuple
                except AttributeError:
                    x = 10**self.result[0]

        s = Solver(self.builder.model, self.time)
        # Iterate over each entry in the data array
        for data_ix, data in enumerate(self.data):
            # Set the parameters appropriately for the simulation:
            # Iterate over the globally fit parameters
            for g_ix, p in enumerate(self.builder.global_params):
                p.value = x[g_ix]
            # Iterate over the locally fit parameters
            for l_ix, p in enumerate(self.builder.local_params):
                ix_offset = len(self.builder.global_params) + \
                            data_ix * len(self.builder.local_params)
                p.value = x[l_ix + ix_offset]
            # Now fill in the initial condition parameters
            for p_name, values in self.params.iteritems():
                p = self.builder.model.parameters[p_name]
                p.value = values[data_ix]
            # Now run the simulation
            s.run()
            # Plot the observable
            if self.use_expr:
                plt.plot(self.time, s.yexpr[self.obs_name], color='r')
            else:
                plt.plot(self.time, s.yobs[self.obs_name], color='r')
Example #20
0
def test_earm_integration():
    t = np.linspace(0, 1e4, 1000)
    # Run with and without inline
    Solver._use_inline = False
    sol = Solver(earm_1_0.model, t, use_analytic_jacobian=True)
    sol.run()
    Solver._use_inline = True
    sol = Solver(earm_1_0.model, t, use_analytic_jacobian=True)
    sol.run()
Example #21
0
 def simulate_model(self, model, target_entity):
     '''
     Simulate a model and return the observed dynamics of
     a given target agent.
     '''
     # TODO: where does the maximal time point come from?
     monomer = self.get_monomer(model, target_entity)
     obs_name = self.get_obs_name(model, monomer)
     ts = numpy.linspace(0, 100, 100)
     solver = Solver(model, ts)
     solver.run()
     yobs_target = solver.yobs[obs_name]
     plt.ion()
     plt.plot(ts, yobs_target, label=obs_name)
     plt.show()
     plt.legend()
     return yobs_target
Example #22
0
def synthetic_data(model, tspan, obs_list=None, sigma=0.1):
    #from pysb.integrate import odesolve
    from pysb.integrate import Solver
    solver = Solver(model, tspan)
    solver.run()

    # Sample from a normal distribution with variance sigma and mean 1
    # (randn generates a matrix of random numbers sampled from a normal
    # distribution with mean 0 and variance 1)
    #
    # Note: This modifies yobs_view (the view on yobs) so that the changes
    # are reflected in yobs (which is returned by the function). Since a new
    # Solver object is constructed for each function invocation this does not
    # cause problems in this case.
    solver.yobs_view *= (
        (numpy.random.randn(*solver.yobs_view.shape) * sigma) + 1)
    return solver.yobs
Example #23
0
def run_model(model):
    sim_hours = 200
    ts = np.linspace(0, sim_hours * 3600, sim_hours * 60)
    solver = Solver(model, ts)
    solver.run()
    plt.figure(figsize=(2, 2), dpi=300)
    set_fig_params()
    plt.plot(ts, solver.yobs['p53_active'], 'r')
    #if model.name == 'p53_ATR':
    #    plt.plot(ts, solver.yobs['atr_active'], 'b')
    #else:
    #    plt.plot(ts, solver.yobs['atm_active'], 'b')
    plt.xticks([])
    plt.xlabel('Time (a.u.)', fontsize=12)
    plt.ylabel('Active p53', fontsize=12)
    plt.yticks([])
    plt.savefig(model.name + '.pdf')
    return ts, solver
Example #24
0
def test_robertson_integration():
    t = np.linspace(0, 100)
    # Run with and without inline
    Solver._use_inline = False
    sol = Solver(robertson.model, t, use_analytic_jacobian=True)
    sol.run()
    assert sol.y.shape[0] == t.shape[0]
    # Run with and without inline
    Solver._use_inline = True
    sol = Solver(robertson.model, t, use_analytic_jacobian=True)
    sol.run()
Example #25
0
def test_earm_integration():
    """Ensure earm_1_0 model simulates."""
    t = np.linspace(0, 1e3)
    # Run with or without inline
    sol = Solver(earm_1_0.model, t)
    sol.run()
    if Solver._use_inline:
        # Also run without inline
        Solver._use_inline = False
        sol = Solver(earm_1_0.model, t)
        sol.run()
        Solver._use_inline = True
Example #26
0
def run_model(model):
    sim_hours = 20
    ts = np.linspace(0, sim_hours * 3600, sim_hours * 60)
    tst = time.time()
    solver = Solver(model, ts)
    solver.run()
    te = time.time()
    print('Simulation took %.2fs' % (te - tst))
    plt.figure(figsize=(1.8, 1), dpi=300)
    set_fig_params()
    plt.plot(ts, solver.yobs['p53_active'], 'r')
    plt.xticks([])
    plt.xlabel('Time (a.u.)', fontsize=7)
    plt.ylabel('Active p53', fontsize=7)
    plt.yticks([])
    ax = plt.gca()
    format_axis(ax)
    #plt.subplots_adjust()
    plt.savefig(model.name + '.pdf')
    return ts, solver
Example #27
0
def test_robertson_integration():
    """Ensure robertson model simulates."""
    t = np.linspace(0, 100)
    # Run with or without inline
    sol = Solver(robertson.model, t)
    sol.run()
    assert sol.y.shape[0] == t.shape[0]
    if Solver._use_inline:
        # Also run without inline
        Solver._use_inline = False
        sol = Solver(robertson.model, t)
        sol.run()
        assert sol.y.shape[0] == t.shape[0]
        Solver._use_inline = True
Example #28
0
def sim_experiment(model, exp, pd=None, solver=None):
    if pd is None:
        pd = {}
    pd['ERK_0'] = exp.ERKtot * exp.ERK[0]
    pd['ERKpT_0'] = exp.ERKtot * exp.ERKpT[0]
    pd['ERKpY_0'] = exp.ERKtot * exp.ERKpY[0]
    pd['ERKpTpY_0'] = exp.ERKtot * exp.ERKpTpY[0]
    pd['MEK_0'] = exp.MEKtot
    pd['MKP_0'] = exp.MKPtot

    if solver is None:
        Solver._use_inline = True
        solver = Solver(model, exp.ts, use_analytic_jacobian=True)
    else:
        solver.set_tspan(exp.ts)
    solver.run(pd)
    return solver.yobs
Example #29
0
# for s in sos_range:
for r in Ras_range:
    wt_holder_row = []
    v600e_holder_row = []
    erk_holder_row = []
    kras_holder_row = []
    sos_holder_row = []
    for v in Vemurafenib_range:

        model.parameters['KRAS_0'].value = r
        # model.parameters['SOS_0'].value = s
        model.parameters['Vem_0'].value = v

        ts = np.linspace(0, 1e5, 100)
        solver = Solver(model, ts)
        solver.run()

        wt_holder_row.append(solver.yobs['BRAF_WT_active'][-1])
        v600e_holder_row.append(solver.yobs['BRAF_V600E_active'][-1])
        erk_holder_row.append(solver.yobs['ERK_P'][-1])
        kras_holder_row.append(solver.yobs['active_KRAS'][-1])
        sos_holder_row.append(solver.yobs['active_SOS'][-1])

    RAF_WT_level.append(wt_holder_row)
    RAF_V600E_level.append(v600e_holder_row)
    ERK_P_level.append(erk_holder_row)
    KRAS_level.append(kras_holder_row)
    SOS_level.append(sos_holder_row)

wt = np.array(RAF_WT_level, dtype='float')
from pysb.integrate import Solver
from pysb.sensitivity import Sensitivity
import scipy.optimize
from pyDOE import *
from scipy.stats.distributions import norm
import numdifftools as nd

# Simulate the model

# Create time vector using np.linspace function
num_timepoints = 101
num_dim = 3
t = np.linspace(0, 200, num_timepoints)

# Get instance of the Solver
sol = Solver(model, t, use_analytic_jacobian=False)

# Perform the integration
sol.run()

# Get instance of Sensitivity object
sens = Sensitivity(model, t)

# sol.y contains timecourses for all of the species
# (model.species gives matched list of species)

# sol.yobs contains timecourse only for the observables
# Indexed by the name of the observable

# Plot the timecourses for A, B, and C
plt.ion()
Example #31
0
from pydream.core import run_dream
from pysb.integrate import Solver
import numpy as np
from pydream.parameters import SampledParam
from pydream.convergence import Gelman_Rubin
from scipy.stats import norm
import inspect
import os.path

from .corm import model as cox2_model

pydream_path = os.path.dirname(inspect.getfile(run_dream))

#Initialize PySB solver object for running simulations.  Simulation timespan should match experimental data.
tspan = np.linspace(0, 10, num=100)
solver = Solver(cox2_model, tspan)
solver.run()

#Load experimental data to which CORM model will be fit here
location = pydream_path + '/examples/corm/exp_data/'
exp_data_PG = np.loadtxt(location + 'exp_data_pg.txt')
exp_data_PGG = np.loadtxt(location + 'exp_data_pgg.txt')

exp_data_sd_PG = np.loadtxt(location + 'exp_data_sd_pg.txt')
exp_data_sd_PGG = np.loadtxt(location + 'exp_data_sd_pgg.txt')

#Experimental starting values of AA and 2-AG species (all in microM).
exp_cond_AA = [0, .5, 1, 2, 4, 8, 16]
exp_cond_AG = [0, .5, 1, 2, 4, 8, 16]

#Experimentally measured parameter values. These will not be sampled with DREAM.