def optgp(model): """Return OptGPSampler instance for tests.""" sampler = OptGPSampler(model, processes=1, thinning=1) assert ((sampler.n_warmup > 0) and (sampler.n_warmup <= 2 * len(model.variables))) assert all(sampler.validate(sampler.warmup) == "v") return sampler
def capitulo_7(): file = open("resultados_capitulo_7.txt", "w") model = create_test_model("textbook") s = sample(model, 100) s.head() print("One process:") s = sample(model, 1000) print("Two processes:") s = sample(model, 1000, processes=2) s = sample(model, 100, method="achr") from cobra.flux_analysis.sampling import OptGPSampler, ACHRSampler achr = ACHRSampler(model, thinning=10) optgp = OptGPSampler(model, processes=4) s1 = achr.sample(100) s2 = optgp.sample(100) import numpy as np bad = np.random.uniform(-1000, 1000, size=len(model.reactions)) achr.validate(np.atleast_2d(bad)) achr.validate(s1) counts = [ np.mean(s.Biomass_Ecoli_core > 0.1) for s in optgp.batch(100, 10) ] file.write("Usually {:.2f}% +- {:.2f}% grow...".format( np.mean(counts) * 100.0, np.std(counts) * 100.0)) file.write("\n") co = model.problem.Constraint( model.reactions.Biomass_Ecoli_core.flux_expression, lb=0.1) model.add_cons_vars([co]) s = sample(model, 10) file.write(s.Biomass_Ecoli_core) file.write("\n") file.close()
def test_complicated_model(): """Test a complicated model. Difficult model since the online mean calculation is numerically unstable so many samples weakly violate the equality constraints. """ model = Model('flux_split') reaction1 = Reaction('V1') reaction2 = Reaction('V2') reaction3 = Reaction('V3') reaction1.bounds = (0, 6) reaction2.bounds = (0, 8) reaction3.bounds = (0, 10) A = Metabolite('A') reaction1.add_metabolites({A: -1}) reaction2.add_metabolites({A: -1}) reaction3.add_metabolites({A: 1}) model.add_reactions([reaction1, reaction2, reaction3]) optgp = OptGPSampler(model, 1, seed=42) achr = ACHRSampler(model, seed=42) optgp_samples = optgp.sample(100) achr_samples = achr.sample(100) assert any(optgp_samples.corr().abs() < 1.0) assert any(achr_samples.corr().abs() < 1.0) # > 95% are valid assert sum(optgp.validate(optgp_samples) == "v") > 95 assert sum(achr.validate(achr_samples) == "v") > 95
def test_complicated_model(self): """Difficult model since the online mean calculation is numerically unstable so many samples weakly violate the equality constraints.""" model = Model('flux_split') reaction1 = Reaction('V1') reaction2 = Reaction('V2') reaction3 = Reaction('V3') reaction1.lower_bound = 0 reaction2.lower_bound = 0 reaction3.lower_bound = 0 reaction1.upper_bound = 6 reaction2.upper_bound = 8 reaction3.upper_bound = 10 A = Metabolite('A') reaction1.add_metabolites({A: -1}) reaction2.add_metabolites({A: -1}) reaction3.add_metabolites({A: 1}) model.add_reactions([reaction1]) model.add_reactions([reaction2]) model.add_reactions([reaction3]) optgp = OptGPSampler(model, 1, seed=42) achr = ACHRSampler(model, seed=42) optgp_samples = optgp.sample(100) achr_samples = achr.sample(100) assert any(optgp_samples.corr().abs() < 1.0) assert any(achr_samples.corr().abs() < 1.0) # > 95% are valid assert (sum(optgp.validate(optgp_samples) == "v") > 95) assert (sum(achr.validate(achr_samples) == "v") > 95)
def getFluxSample(self, nsamples=5000): """ Generates a sample of the flux cone. It uses the default sampler in cobrapy """ optGPS = OptGPSampler(self.GEM, thinning=100, processes=3) samplerSample = optGPS.sample(nsamples) sample = samplerSample[optGPS.validate(samplerSample) == "v"] return sample
def setup_class(self): from . import create_test_model model = create_test_model("textbook") achr = ACHRSampler(model, thinning=1) assert ((achr.n_warmup > 0) and (achr.n_warmup <= 2 * len(model.variables))) assert all(achr.validate(achr.warmup) == "v") self.achr = achr optgp = OptGPSampler(model, processes=1, thinning=1) assert ((optgp.n_warmup > 0) and (optgp.n_warmup <= 2 * len(model.variables))) assert all(optgp.validate(optgp.warmup) == "v") self.optgp = optgp
def setup_class(self): from . import create_test_model model = create_test_model("textbook") arch = ARCHSampler(model, thinning=1) assert ((arch.n_warmup > 0) and (arch.n_warmup <= 2 * len(model.reactions))) assert all(arch.validate(arch.warmup) == "v") self.arch = arch optgp = OptGPSampler(model, processes=1, thinning=1) assert ((optgp.n_warmup > 0) and (optgp.n_warmup <= 2 * len(model.reactions))) assert all(optgp.validate(optgp.warmup) == "v") self.optgp = optgp
def fluxSampling(model): from cobra.test import create_test_model from cobra.flux_analysis import sample model = create_test_model("textbook") s = sample(model, 100) #number of samples to generate s.head() s = sample(model, 1000) s #The sampling process can be controlled on a lower level by using the sampler classes directly. from cobra.flux_analysis.sampling import OptGPSampler, ACHRSampler achr = ACHRSampler( model, thinning=10 ) #“Thinning” means only recording samples every n iterations. A higher thinning factor means less correlated samples but also larger computation times. optgp = OptGPSampler( model, processes=4 ) #an additional processes argument specifying how many processes are used to create parallel sampling chains. #For OptGPSampler the number of samples should be a multiple of the number of # processes, otherwise it will be increased to the nearest multiple automatically. s1 = achr.sample(100) s2 = optgp.sample(100) # Sampling and validation import numpy as np bad = np.random.uniform(-1000, 1000, size=len(model.reactions)) achr.validate(np.atleast_2d(bad)) #should not be feasible achr.validate(s1) # Batch sampling counts = [ np.mean(s.Biomass_Ecoli_core > 0.1) for s in optgp.batch(100, 10) ] print("Usually {:.2f}% +- {:.2f}% grow...".format( np.mean(counts) * 100.0, np.std(counts) * 100.0)) # Adding constraints co = model.problem.Constraint( model.reactions.Biomass_Ecoli_core.flux_expression, lb=0.1) model.add_cons_vars([co]) # Note that this is only for demonstration purposes. usually you could set # the lower bound of the reaction directly instead of creating a new constraint. s = sample(model, 10) print(s.Biomass_Ecoli_core)
def test_optgp_init_benchmark(model, benchmark): """Benchmark inital OptGP sampling.""" benchmark(lambda: OptGPSampler(model, processes=2))
#!/usr/bin/env python2 # -*- coding: utf-8 -*- """ Created on Wed Jul 19 10:58:51 2017 @author: rohanroy """ from pandas import * from cobra.flux_analysis.sampling import OptGPSampler sampler1 = OptGPSampler(dnamodel1, processes=2, thinning=200) sampler2 = OptGPSampler(dnamodel2, processes=2, thinning=200) dnamodel1samples = sampler1.sample(4500) dnamodel2samples = sampler2.sample(4500) #%% for reaction in dnamodel1.reactions: reaction.averageflux=dnamodel1samples[reaction.id].mean() reaction.stdflux=dnamodel1samples[reaction.id].std() reaction.medianflux=dnamodel1samples[reaction.id].median() for reaction in dnamodel2.reactions: reaction.averageflux = dnamodel2samples[reaction.id].mean() reaction.stdflux=dnamodel2samples[reaction.id].std() reaction.medianflux=dnamodel2samples[reaction.id].median()
def test_optgp_init_benchmark(self, model, benchmark): benchmark(lambda: OptGPSampler(model, processes=2))
def pfba_gapfill(model, reaction_bag, obj=None, obj_lb=10., obj_constraint=False, iters=1, tasks=None, task_lb=0.05, add_exchanges=True, extracellular='e'): ''' Function that utilizes iterations of pFBA solution with a universal reaction bag in order to gapfill a model. Parameters ---------- model : cobra.Model Model to be gapfilled reaction_bag : cobra.Model Reaction bag reference to use during gapfilling obj : string Reaction ID for objective function in model to be gapfilled. obj_lb : float Lower bound for objective function obj_constraint : bool Sets objective as contstraint which must be maximized tasks : list or None List of reactions IDs (strings) of metabolic tasks to set a minimum lower bound for task_lb : float Lower bound for any metabolic tasks iters : int Number of gapfilling rounds. Unique reactions from each round are saved and the union is added simulatneously to the model add_exchanges : bool Identifies extracellular metabolites added during gapfilling that are not associated with exchange reactions and creates them extracellular : string Label for extracellular compartment of model ''' start_time = time.time() # Save some basic network info for downstream membership testing orig_rxn_ids = set([str(x.id) for x in model.reactions]) orig_cpd_ids = set([str(y.id) for y in model.metabolites]) univ_rxn_ids = set([str(z.id) for z in reaction_bag.reactions]) # Find overlap in model and reaction bag overlap_rxn_ids = univ_rxn_ids.intersection(orig_rxn_ids) # Get model objective reaction ID if obj == None: obj = get_objective(model) else: obj = obj # Modify universal reaction bag new_rxn_ids = set() print('Creating universal model...') with reaction_bag as universal: # Remove overlapping reactions from universal bag, and reset objective if needed for rxn in overlap_rxn_ids: universal.reactions.get_by_id(rxn).remove_from_model() # Set objective in universal if told by user # Made constraint as fraction of minimum in next step if obj_constraint: universal.add_reactions([model.reactions.get_by_id(obj)]) universal.objective = obj orig_rxn_ids.remove(obj) orig_rxns = [] for rxn in orig_rxn_ids: orig_rxns.append(copy.deepcopy(model.reactions.get_by_id(rxn))) else: orig_rxns = list(copy.deepcopy(model.reactions)) # Add pFBA to universal model and add model reactions add_pfba(universal) #universal = copy.deepcopy(universal) # reset solver universal.add_reactions(orig_rxns) # If previous objective not set as constraint, set minimum lower bound if not obj_constraint: universal.reactions.get_by_id(obj).lower_bound = obj_lb # Set metabolic tasks that must carry flux in gapfilled solution if tasks != None: for task in tasks: try: universal.reactions.get_by_id(task).lower_bound = task_lb except: print(task + 'not found in model. Ignoring.') continue # Run FBA and save solution print('Optimizing model with combined reactions...') solution = universal.optimize() if iters > 1: print('Generating flux sampling object...') optgp_object = OptGPSampler(universal, processes=4) # Assess the sampled flux distributions print('Sampling ' + str(iters) + ' flux distributions...') flux_samples = optgp_object.sample(iters) rxns = list(flux_samples.columns) for distribution in flux_samples.iterrows(): for flux in range(0, len(list(distribution[1]))): if abs(list(distribution[1])[flux]) > 1e-6: new_rxn_ids |= set([rxns[flux] ]).difference(orig_rxn_ids) else: rxns = list(solution.fluxes.index) fluxes = list(solution.fluxes) for flux in range(0, len(fluxes)): if abs(fluxes[flux]) > 1e-6: new_rxn_ids |= set([rxns[flux]]) # Screen new reaction IDs if obj in new_rxn_ids: new_rxn_ids.remove(obj) for rxn in orig_rxn_ids: try: new_rxn_ids.remove(rxn) except: continue # Get reactions and metabolites to be added to the model print('Gapfilling model...') new_rxns = copy.deepcopy( [reaction_bag.reactions.get_by_id(rxn) for rxn in new_rxn_ids]) new_cpd_ids = set() for rxn in new_rxns: new_cpd_ids |= set([str(x.id) for x in list(rxn.metabolites)]) new_cpd_ids = new_cpd_ids.difference(orig_cpd_ids) new_cpds = copy.deepcopy( [reaction_bag.metabolites.get_by_id(cpd) for cpd in new_cpd_ids]) # Copy model and gapfill new_model = copy.deepcopy(model) new_model.add_metabolites(new_cpds) new_model.add_reactions(new_rxns) # Identify extracellular metabolites with no exchanges if add_exchanges == True: new_exchanges = extend_exchanges(new_model, new_cpd_ids, extracellular) if len(new_exchanges) > 0: new_rxn_ids |= new_exchanges duration = int(round(time.time() - start_time)) print('Took ' + str(duration) + ' seconds to gapfill ' + str(len(new_rxn_ids)) + \ ' reactions and ' + str(len(new_cpd_ids)) + ' metabolites.') new_obj_val = new_model.slim_optimize() if new_obj_val > 1e-6: print('Gapfilled model objective now carries flux (' + str(new_obj_val) + ').') else: print('Gapfilled model objective still does not carry flux.') return new_model
def sampling_analysis(self, measurements): self.add_constraint(measurements) return OptGPSampler(self.model, processes=8).sample(10000)