def copy_no_rules(model): ''' Copies a model without rules. Parameters ---------- model : pysb.Model Model to copy. ''' m = Model(_export=False) for comp in model.all_components(): if comp.__class__ is not Rule: m.add_component(comp) for ini in model.initial_conditions: m.initial(*ini) return m
def build_model(mek_seq_rand, mkp_seq_rand, erk_dimerization, mkp_activation): Model() mapk_model.mapk_monomers() if mek_seq_rand == 'seq': mapk_model.mek_phos_erk_seq() else: mapk_model.mek_phos_erk_random() if mkp_seq_rand == 'seq': mapk_model.mkp_dephos_erk_seq() else: mapk_model.mkp_dephos_erk_random() if erk_dimerization == 'any': mapk_model.erk_dimerize_any() elif erk_dimerization == 'uT': mapk_model.erk_dimerize_uT() elif erk_dimerization == 'phos': mapk_model.erk_dimerize_phos() if erk_dimerization: mapk_model.erk_autophos() if mkp_activation: mapk_model.erk_activate_mkp() mapk_model.mapk_initials() mapk_model.mapk_observables() model.name = 'mek_%s_mkp_%s_erkauto_%s_mkpact_%s' % \ (mek_seq_rand, mkp_seq_rand, erk_dimerization, mkp_activation) return model
def generate_per_sample_pretraining_problems( ae: MechanisticAutoEncoder) -> Dict[str, PetabImporterPysb]: """ Creates a pypesto problem that can be used to train the mechanistic model individually on every sample :param ae: Mechanistic autoencoder that will be pretrained :returns: Dict of pypesto problems. Keys are sample names. """ # construct problem based on petab for pypesto subproblem ae.petab_importer.petab_problem.parameter_df['estimate'] = [ not x.startswith(MODEL_FEATURE_PREFIX) and ae.petab_importer.petab_problem.parameter_df['estimate'][x] for x in ae.petab_importer.petab_problem.parameter_df.index ] pp = ae.petab_importer.petab_problem pp.parameter_df[petab.LOWER_BOUND] /= 10**ae.par_modulation_scale pp.parameter_df[petab.UPPER_BOUND] *= 10**ae.par_modulation_scale # create fresh model from scratch since the petab imported one already # has the observables added and this might lead to issues. clean_model = load_pathway('pw_' + ae.pathway_name) samples = [ c for c in pp.condition_df.index if c in pp.measurement_df[ petab.PREEQUILIBRATION_CONDITION_ID].unique() ] return { sample: PetabImporterPysb(PysbPetabProblem( parameter_df=pp.parameter_df[[ not name.startswith(MODEL_FEATURE_PREFIX) or name.endswith(sample) for name in pp.parameter_df.index ]], observable_df=pp.observable_df, measurement_df=pp.measurement_df[pp.measurement_df[ petab.PREEQUILIBRATION_CONDITION_ID] == sample], condition_df=pp.condition_df[[ name.startswith(sample) for name in pp.condition_df.index ]], visualization_df=pd.read_csv(os.path.join( 'data', f'{ae.data_name}__' f'{sample}__visualization.tsv'), sep='\t'), pysb_model=Model(base=clean_model, name=pp.pysb_model.name), ), output_folder=os.path.join( basedir, 'amici_models', f'{pp.pysb_model.name}_' f'{ae.data_name}_petab')) for sample in samples }
def make_model(self, initial_conditions=True, policies=None): model = Model() # Keep track of which policies we're using self.policies = policies self.agent_set = BaseAgentSet() # Collect information about the monomers/self.agent_set from the # statements for stmt in self.statements: stmt.monomers(self.agent_set, policies=policies) # Add the monomers to the model based on our BaseAgentSet for agent_name, agent in self.agent_set.iteritems(): m = Monomer(agent_name, agent.sites, agent.site_states) model.add_component(m) # Iterate over the statements to generate rules for stmt in self.statements: stmt.assemble(model, self.agent_set, policies=policies) # Add initial conditions if initial_conditions: add_default_initial_conditions(model) return model
def make_model(self, initial_conditions=True): self.model = Model() self.agent_set = BaseAgentSet() # Collect information about the monomers/self.agent_set from the # statements self.monomers() # Add the monomers to the model based on our BaseAgentSet for agent_name, agent in self.agent_set.iteritems(): m = Monomer(agent_name, agent.sites, agent.site_states) self.model.add_component(m) for db_name, db_ref in agent.db_refs.iteritems(): a = get_annotation(m, db_name, db_ref) if a is not None: self.model.add_annotation(a) # Iterate over the statements to generate rules self.assemble() # Add initial conditions if initial_conditions: add_default_initial_conditions(self.model) return self.model
def _get_gk_model(): SelfExporter.do_export = True Model() Monomer('DUSP6', ['mapk1']) Monomer('MAP2K1', ['mapk1']) Monomer('MAPK1', ['phospho', 'map2k1', 'dusp6'], {'phospho': ['u', 'p']}) Parameter('kf_mm_bind_1', 1e-06) Parameter('kr_mm_bind_1', 0.001) Parameter('kc_mm_phos_1', 0.001) Parameter('kf_dm_bind_1', 1e-06) Parameter('kr_dm_bind_1', 0.001) Parameter('kc_dm_dephos_1', 0.001) Parameter('DUSP6_0', 100.0) Parameter('MAP2K1_0', 100.0) Parameter('MAPK1_0', 100.0) Rule('MAP2K1_phospho_bind_MAPK1_phospho_1', MAP2K1(mapk1=None) + \ MAPK1(phospho='u', map2k1=None) >> MAP2K1(mapk1=1) % MAPK1(phospho='u', map2k1=1), kf_mm_bind_1) Rule('MAP2K1_phospho_MAPK1_phospho_1', MAP2K1(mapk1=1) % \ MAPK1(phospho='u', map2k1=1) >> MAP2K1(mapk1=None) + MAPK1(phospho='p', map2k1=None), kc_mm_phos_1) Rule( 'MAP2K1_dissoc_MAPK1', MAP2K1(mapk1=1) % MAPK1(map2k1=1) >> MAP2K1(mapk1=None) + MAPK1(map2k1=None), kr_mm_bind_1) Rule( 'DUSP6_dephos_bind_MAPK1_phospho_1', DUSP6(mapk1=None) + MAPK1(phospho='p', dusp6=None) >> DUSP6(mapk1=1) % MAPK1(phospho='p', dusp6=1), kf_dm_bind_1) Rule( 'DUSP6_dephos_MAPK1_phospho_1', DUSP6(mapk1=1) % MAPK1(phospho='p', dusp6=1) >> DUSP6(mapk1=None) + MAPK1(phospho='u', dusp6=None), kc_dm_dephos_1) Rule( 'DUSP6_dissoc_MAPK1', DUSP6(mapk1=1) % MAPK1(dusp6=1) >> DUSP6(mapk1=None) + MAPK1(dusp6=None), kr_dm_bind_1) Initial(DUSP6(mapk1=None), DUSP6_0) Initial(MAP2K1(mapk1=None), MAP2K1_0) Initial(MAPK1(phospho='u', map2k1=None, dusp6=None), MAPK1_0) SelfExporter.do_export = False return model
class PysbAssembler(object): def __init__(self, policies=None): self.statements = [] self.agent_set = None self.model = None if policies is None: self.policies = {'other': 'default'} elif isinstance(policies, basestring): self.policies = {'other': policies} else: self.policies = {'other': 'default'} self.policies.update(policies) def statement_exists(self, stmt): for s in self.statements: if stmt == s: return True return False def add_statements(self, stmts): for stmt in stmts: if not self.statement_exists(stmt): self.statements.append(stmt) def dispatch(self, stmt, stage, *args): class_name = stmt.__class__.__name__ try: policy = self.policies[class_name] except KeyError: policy = self.policies['other'] func_name = '%s_%s_%s' % (class_name.lower(), stage, policy) func = globals().get(func_name) if func is None: raise UnknownPolicyError('%s function %s not defined' % (stage, func_name)) return func(stmt, *args) def monomers(self): """Calls the appropriate monomers method based on policies.""" for stmt in self.statements: self.dispatch(stmt, 'monomers', self.agent_set) def assemble(self): for stmt in self.statements: self.dispatch(stmt, 'assemble', self.model, self.agent_set) def make_model(self, initial_conditions=True): self.model = Model() self.agent_set = BaseAgentSet() # Collect information about the monomers/self.agent_set from the # statements self.monomers() # Add the monomers to the model based on our BaseAgentSet for agent_name, agent in self.agent_set.iteritems(): m = Monomer(agent_name, agent.sites, agent.site_states) self.model.add_component(m) for db_name, db_ref in agent.db_refs.iteritems(): a = get_annotation(m, db_name, db_ref) if a is not None: self.model.add_annotation(a) # Iterate over the statements to generate rules self.assemble() # Add initial conditions if initial_conditions: add_default_initial_conditions(self.model) return self.model def print_model(self, fname='pysb_model.py'): if self.model is not None: with open(fname, 'wt') as fh: fh.write(pysb.export.export(self.model, 'pysb_flat')) def print_rst(self, fname='pysb_model.rst', module_name='pysb_module'): if self.model is not None: with open(fname, 'wt') as fh: fh.write('.. _%s:\n\n' % module_name) fh.write('Module\n======\n\n') fh.write('INDRA-assembled model\n---------------------\n\n') fh.write('::\n\n') model_str = pysb.export.export(self.model, 'pysb_flat') model_str = '\t' + model_str.replace('\n', '\n\t') fh.write(model_str)
from pysb import Model from mEncoder.mechanistic_model import ( add_monomer_synth_deg, generate_pathway, add_activation, add_abundance_observables, add_phospho_observables ) model = Model('FLT3_MAPK') # FLT3 for rtkf_name in ['FL']: add_monomer_synth_deg(rtkf_name) rtk_cascade = [ ('FLT3', {'Y843': ['FL']}), ] generate_pathway(model, rtk_cascade) # ERK for ras_name in ['HRAS', 'KRAS', 'NRAS']: add_monomer_synth_deg(ras_name, nsites=['N']) add_activation( model, ras_name, 'N', 'nucleotide_exchange', ['FLT3__Y843_p'] ) mapk_cascade = [ ('RAF1', {'S338': ['KRAS__N_gtp', 'HRAS__N_gtp', 'NRAS__N_gtp']}), ('BRAF', {'S447': ['KRAS__N_gtp', 'HRAS__N_gtp', 'NRAS__N_gtp']}), ('MAP2K1', {'S218_S222': ['RAF1__S338_p', 'BRAF__S447_p']}),
from pysb import Monomer, Parameter, Initial, Rule, Observable, Model from pysb.simulator import ScipyOdeSimulator from pylab import linspace, plot, xlabel, ylabel, show # A simple model with a reversible binding rule model = Model(name="t1", base=) # Declare the monomers L = Model.monomers('L', ['s']) R = Monomer('R', ['s']) # Declare the parameters L_0 = Parameter('L_0', 100) R_0 = Parameter('R_0', 200) kf = Parameter('kf', 1e-3) kr = Parameter('kr', 1e-3) # Declare the initial conditions Initial(L(s=None), L_0) Initial(R(s=None), R_0) # Declare the binding rule Rule('L_binds_R', L(s=None) + R(s=None) | L(s=1) % R(s=1), kf, kr) # Observe the complex Observable('LR', L(s=1) % R(s=1)) if __name__ == '__main__': # Simulate the model through 40 seconds time = linspace(0, 40, 100) print("Simulating...")
from pysb import Model, Observable from mEncoder.mechanistic_model import (add_monomer_synth_deg, generate_pathway, add_activation, add_observables, add_inhibitor, add_gf_bolus, cleanup_unused) model = Model('EGFR_MAPK') rtkfs = ['EGF'] # EGFR for rtkf_name in rtkfs: add_monomer_synth_deg(rtkf_name) add_gf_bolus(model, rtkf_name, [rtkf_name]) erbb_cascade = [ ('EGFR', { 'Y1173': ['EGF'] }), ('ERBB2', { 'Y1248': ['EGFR__Y1173_p'] }), ] generate_pathway(model, erbb_cascade) active_rtks = ['EGFR__Y1173_p', 'ERBB2__Y1248_p'] mapk_cascade = [ ('RAF1', { 'S338': active_rtks + ['EGF']
from mEncoder.mechanistic_model import ( add_monomer_synth_deg, generate_pathway, add_activation, add_abundance_observables, add_phospho_observables ) from pysb import Model model = Model('FLT3_MAPK_AKT_STAT') # FLT3 for rtkf_name in ['FL']: add_monomer_synth_deg(rtkf_name) rtk_cascade = [ ('FLT3', {'Y843': ['FL']}), ] generate_pathway(model, rtk_cascade) # STAT stat_cascade = [ ('STAT1', {'Y701': ['FLT3__Y843_p']}), ('STAT3', {'Y705': ['FLT3__Y843_p']}), ('STAT5A', {'Y694': ['FLT3__Y843_p']}), ('STAT5B', {'Y699': ['FLT3__Y843_p']}), ] generate_pathway(model, stat_cascade) # ERK for ras_name in ['HRAS', 'KRAS', 'NRAS']: add_monomer_synth_deg(ras_name, nsites=['N'])
from pysb import Model, Observable from mEncoder.mechanistic_model import (add_monomer_synth_deg, generate_pathway, add_activation, add_observables, add_inhibitor, add_gf_bolus) model = Model('EGFR_MAPK_AKT_STAT') rtkfs = ['EGF'] # EGFR for rtkf_name in rtkfs: add_monomer_synth_deg(rtkf_name) add_gf_bolus(model, rtkf_name, [rtkf_name]) erbb_cascade = [ ('EGFR', { 'Y1173': ['EGF'] }), ('ERBB2', { 'Y1248': ['EGF'] }), ] generate_pathway(model, erbb_cascade) active_rtks = ['EGFR__Y1173_p', 'ERBB2__Y1248_p'] stat_rtks = ['EGFR__Y1173_p', 'ERBB2__Y1248_p'] # MAPK for ras_name in ['HRAS', 'KRAS', 'NRAS']:
from model_cell_cycle_no_M import model from pysb import Model, Parameter, Rule model = Model('cell_cycle_no_M_washout', base=model) Rule('washout', model.monomers.dead_cell() >> None, Parameter('kwash', 0.1))
from pysb import Model, Observable from mEncoder.mechanistic_model import (add_monomer_synth_deg, generate_pathway, add_activation, add_observables, add_inhibitor, add_gf_bolus) model = Model('ERBB_MAPK_AKT_STAT') rtkfs = ['EGF', 'HGF', 'INSULIN', 'IGF1', 'FGF', 'NRG1'] # EGFR for rtkf_name in rtkfs: add_monomer_synth_deg(rtkf_name) add_gf_bolus(model, rtkf_name, [rtkf_name]) erbb_cascade = [('EGFR', { 'Y1173_Y992': ['EGF', 'NRG1'] }), ('ERBB2', { 'Y1248': ['EGF', 'NRG1'] }), ('ERBB3', { 'Y1289': ['NRG1'] }), ('ERBB4', { 'Y733': ['EGF', 'NRG1'] }), ('IGF1R', { 'Y1135_Y1136': ['INSULIN', 'IGF1'] }), ('CMET', { 'Y1234_Y1235': ['HGF'] }), ('FGFR', { 'Y653': ['FGF'] })]
from model_cell_cycle_no_M import model from sympy import log from pysb import Expression, Model model = Model('cell_cycle_no_M_ridge', base=model) for par in model.parameters: if par.name.startswith('r'): Expression(f'{par.name}_obs', log(par))
# -*- coding: utf-8 -*- """ Created on Mon Dec 8 19:56:12 2014 @author: Erin """ from pysb import Model, Monomer, Parameter, Initial, Rule, Observable from pysb.macros import bind, bind_complex, catalyze Model() #Define individual species in model Monomer('COX2', ['allo', 'cat']) #Cyclooxygenase-2 enzyme Monomer('AG', ['b']) #2-arachidonoylglycerol, a substrate of COX2 Monomer('AA', ['b']) #arachidonic acid, a substrate of COX2 Monomer('PG') #Prostaglandin, product of COX2 turnover of AA Monomer('PGG') #Prostaglandin glycerol, product of COX2 turnover of 2-AG #Initial starting concentrations in micromolar Parameter('COX2_0', 15e-3) Parameter('AG_0', 16) Parameter('AA_0', 16) Parameter('PG_0', 0) Parameter('PGG_0', 0) Initial(COX2(allo=None, cat=None), COX2_0) Initial(AG(b=None), AG_0) Initial(AA(b=None), AA_0) Initial(PG(), PG_0) Initial(PGG(), PGG_0)
from pysb import (Model, Monomer, Parameter, Expression, Observable, Rule, Initial) model = Model('cell_cycle_no_M') C = Monomer('live_cell', sites=['cycle'], site_states={'cycle': ['G1', 'G2', 'S']}) D = Monomer('dead_cell') Observable('G1_obs', C(cycle='G1')) Observable('S_obs', C(cycle='S')) Observable('G2_plus_M_obs', C(cycle='G2')) Observable('D_obs', D()) Rule('G1_S', C(cycle='G1') >> C(cycle='S'), Expression('rateG1S', Parameter('kG1S', 0.1) * Parameter('rG1S', 0.1))) Rule('S_G2', C(cycle='S') >> C(cycle='G2'), Expression('rateSG2', Parameter('kSG2', 0.1) * Parameter('rSG2', 0.1))) Rule( 'G2_M_G1', C(cycle='G2') >> C(cycle='G1') + C(cycle='G1'), Expression('rateG2MG1', Parameter('kG2MG1', 0.1) * Parameter('rG2MG1', 0.1)))