def setUp(self): self.model = TEST_MODEL self.single_objective_function = product_yield('product', 'substrate') self.multiobjective_function = MultiObjectiveFunction([ product_yield('product', 'substrate'), number_of_knockouts() ])
def setUp(self): self.model = TEST_MODEL self.single_objective_function = product_yield('product', 'substrate') self.multiobjective_function = [ product_yield('product', 'substrate'), number_of_knockouts() ]
def process_strain_designs(self, strain_designs, model=None, pathway=None, aerobic=None, **kwargs): model = model.copy() assert isinstance(pathway, StrainDesign) assert isinstance(pathway, PathwayResult) final_strain_designs = [] fitness = [] yields = [] biomass = [] target_flux = [] pyield = product_yield(pathway.product, model.carbon_source) bpcy = biomass_product_coupled_min_yield(model.biomass, pathway.product, model.carbon_source) for strain_design in strain_designs: assert isinstance(strain_design, StrainDesign) _fitness, _yield, _target_flux, _biomass = self.evaluate_design( model, strain_design, pathway, aerobic, bpcy, pyield) fitness.append(_fitness) yields.append(_yield) final_strain_designs.append(strain_design) biomass.append(_biomass) target_flux.append(_target_flux) return final_strain_designs, fitness, yields, target_flux, biomass
def test_evaluate_swap(self): TEST_MODEL.objective = TEST_MODEL.reactions.EX_etoh_LPAREN_e_RPAREN_ py = product_yield(TEST_MODEL.reactions.EX_etoh_LPAREN_e_RPAREN_, TEST_MODEL.reactions.EX_glc_LPAREN_e_RPAREN_) reactions = ['ACALD', 'ALCD2x', 'G6PDH2r', 'GAPD'] optimization = CofactorSwapOptimization(model=TEST_MODEL, objective_function=py, candidate_reactions=reactions) optimization_result = optimization.run(max_evaluations=16, max_size=2) fitness = optimization_result.data_frame.iloc[0].fitness self.assertAlmostEqual(fitness, 0.66667, places=3)
def test_swap_reaction_identification(self): expected_reactions = ['ACALD', 'AKGDH', 'ALCD2x', 'G6PDH2r', 'GAPD', 'GLUDy', 'GLUSy', 'GND', 'ICDHyr', 'LDH_D', 'MDH', 'ME1', 'ME2', 'NADH16', 'PDH'] py = product_yield(TEST_MODEL.reactions.EX_etoh_LPAREN_e_RPAREN_, TEST_MODEL.reactions.EX_glc_LPAREN_e_RPAREN_) optimization = CofactorSwapOptimization(model=TEST_MODEL, objective_function=py) self.assertEquals(expected_reactions, optimization.representation) self.assertNotIn('PGI', optimization.representation)
def test_yield(self): solution = self._MockupSolution() solution.set_primal('biomass', 0.6) solution.set_primal('product', 2) solution.set_primal('substrate', -10) of = product_yield("product", "substrate") self.assertEqual(of.name, "yield = (product / substrate)") fitness = of(None, solution, None) self.assertAlmostEqual(2.0 / 10.0, fitness) solution.set_primal('substrate', 0) fitness = of(None, solution, None) self.assertEquals(0, fitness)
def test_initializer(self): objective1 = biomass_product_coupled_yield( "Biomass_Ecoli_core_N_LPAREN_w_FSLASH_GAM_RPAREN__Nmet2", "EX_ac_LPAREN_e_RPAREN_", "EX_glc_LPAREN_e_RPAREN_") decoder = ReactionSetDecoder(["PGI", "PDH", "FUM", "FBA", "G6PDH2r", "FRD7", "PGL", "PPC"], TEST_MODEL) evaluator = KnockoutEvaluator(TEST_MODEL, decoder, objective1, fba, {}) self.assertEquals(evaluator.decoder, decoder) self.assertEquals(evaluator.objective_function, objective1) self.assertTrue(hasattr(evaluator, "__call__")) objective2 = product_yield("EX_ac_LPAREN_e_RPAREN_", "EX_glc_LPAREN_e_RPAREN_") evaluator = KnockoutEvaluator(TEST_MODEL, decoder, MultiObjectiveFunction([objective1, objective2]), fba, {}) self.assertEquals(evaluator.objective_function.objectives, [objective1, objective2])
def test_yield(self): solution = self._MockupSolution() solution.set_primal('biomass', 0.6) solution.set_primal('product', 2) solution.set_primal('substrate', -10) of = product_yield("product", "substrate") self.assertEqual(of.name, "yield = (product / substrate)") fitness = of(None, solution, None) self.assertAlmostEqual(2.0 / 10.0, fitness) solution.set_primal('substrate', 0) fitness = of(None, solution, None) self.assertEquals(0, fitness)
def test_evaluate_multiobjective(self): representation = ["ATPS4r", "PYK", "GLUDy", "PPS", "CO2t", "PDH", "FUM", "FBA", "G6PDH2r", "FRD7", "PGL", "PPC"] decoder = ReactionKnockoutDecoder(representation, TEST_MODEL) objective1 = biomass_product_coupled_yield( "Biomass_Ecoli_core_N_LPAREN_w_FSLASH_GAM_RPAREN__Nmet2", "EX_ac_LPAREN_e_RPAREN_", "EX_glc_LPAREN_e_RPAREN_") objective2 = product_yield("EX_ac_LPAREN_e_RPAREN_", "EX_glc_LPAREN_e_RPAREN_") evaluator = KnockoutEvaluator(TEST_MODEL, decoder, [objective1, objective2], fba, {}) fitness = evaluator([[0, 1, 2, 3, 4]])[0] self.assertIsInstance(fitness, Pareto) self.assertAlmostEqual(fitness[0], 0.41, delta=0.02) self.assertAlmostEqual(fitness[1], 1.57, delta=0.035)
def test_initializer(self): objective1 = biomass_product_coupled_yield( "Biomass_Ecoli_core_N_LPAREN_w_FSLASH_GAM_RPAREN__Nmet2", "EX_ac_LPAREN_e_RPAREN_", "EX_glc_LPAREN_e_RPAREN_") decoder = ReactionKnockoutDecoder(["PGI", "PDH", "FUM", "FBA", "G6PDH2r", "FRD7", "PGL", "PPC"], TEST_MODEL) evaluator = KnockoutEvaluator(TEST_MODEL, decoder, objective1, fba, {}) self.assertEquals(evaluator.decoder, decoder) self.assertEquals(evaluator.objective_function, objective1) self.assertFalse(evaluator.is_mo) self.assertTrue(hasattr(evaluator, "__call__")) objective2 = product_yield("EX_ac_LPAREN_e_RPAREN_", "EX_glc_LPAREN_e_RPAREN_") evaluator = KnockoutEvaluator(TEST_MODEL, decoder, [objective1, objective2], fba, {}) self.assertEquals(evaluator.objective_function, [objective1, objective2]) self.assertTrue(evaluator.is_mo)
def cofactor_swap_optimization(pathway, model): with model: model.objective = model.biomass growth = model.slim_optimize() model.reactions.get_by_id(model.biomass).lower_bound = 0.05 * growth pathway.apply(model) model.objective = pathway.product.id pyield = product_yield(pathway.product.id, model.carbon_source) with model: # TODO (Moritz Beber): By default swaps NADH with NADPH using BiGG # notation. predictor = CofactorSwapOptimization(model=model, objective_function=pyield, plot=False) designs = predictor.run(max_size=5, diversify=True) return designs
def test_evaluate_multiobjective(self): representation = ["ATPS4r", "PYK", "GLUDy", "PPS", "CO2t", "PDH", "FUM", "FBA", "G6PDH2r", "FRD7", "PGL", "PPC"] decoder = ReactionSetDecoder(representation, TEST_MODEL) objective1 = biomass_product_coupled_yield( "Biomass_Ecoli_core_N_LPAREN_w_FSLASH_GAM_RPAREN__Nmet2", "EX_ac_LPAREN_e_RPAREN_", "EX_glc_LPAREN_e_RPAREN_") objective2 = product_yield("EX_ac_LPAREN_e_RPAREN_", "EX_glc_LPAREN_e_RPAREN_") objective = MultiObjectiveFunction([objective1, objective2]) evaluator = KnockoutEvaluator(TEST_MODEL, decoder, objective, fba, {}) fitness = evaluator([[0, 1, 2, 3, 4]])[0] self.assertIsInstance(fitness, Pareto) self.assertAlmostEqual(fitness[0], 0.41, delta=0.02) self.assertAlmostEqual(fitness[1], 1.57, delta=0.035)
def process_strain_designs(self, strain_designs, model=None, pathway=None, aerobic=None, **kwargs): model = model.copy() assert isinstance(pathway, StrainDesign) assert isinstance(pathway, PathwayResult) final_strain_designs = [] fitness = [] yields = [] biomass = [] target_flux = [] pyield = product_yield(pathway.product, model.carbon_source) bpcy = biomass_product_coupled_min_yield(model.biomass, pathway.product, model.carbon_source) for strain_design in strain_designs: assert isinstance(strain_design, StrainDesign) _fitness, _yield, _target_flux, _biomass = self.evaluate_design(model, strain_design, pathway, aerobic, bpcy, pyield) fitness.append(_fitness) yields.append(_yield) final_strain_designs.append(strain_design) biomass.append(_biomass) target_flux.append(_target_flux) return final_strain_designs, fitness, yields, target_flux, biomass
def evaluate_production( model: cobra.Model, production_id: str, carbon_source_id: str ) -> Tuple[Optional[float], Optional[float], Optional[float], Optional[float]]: """ Evaluate the production levels in the specific model conditions. Warnings -------- This function is expected to be called within a context since it modifies the model's objective. Parameters ---------- model : cobra.Model The constraint-based metabolic model of the production organism. production_id : str The identifier of the reaction representing production, for example, a demand reaction on the compound. carbon_source_id : str The identifier of the reaction representing carbon uptake, for example, a glucose exchange reaction. Returns ------- tuple float or None The theoretical maximum production rate if any. float or None The maximal product flux yield if any. float or None The maximal product carbon yield if any. float or None The maximal product yield by weight if any. """ pyield = product_yield(production_id, carbon_source_id) # Compute the number of weighted carbon atoms. carbon_uptake = model.reactions.get_by_id(carbon_source_id) production = model.reactions.get_by_id(production_id) input_components = [reaction_elements(carbon_uptake)] output_components = reaction_elements(production) # Compute the masses. try: input_weights = [reaction_weight(carbon_uptake)] output_weight = reaction_weight(production) # If the reactions are ill-defined or the metabolite weight is unknown. except (ValueError, TypeError): input_weights = [] output_weight = [] try: model.objective = production_id solution = model.optimize() production_flux = solution[production_id] except OptimizationError as error: logger.error( "Could not determine production due to a solver error. %r", error ) production_flux = None production_flux_yield = None production_carbon_yield = None production_mass_yield = None else: try: production_flux_yield = pyield(model, solution, None) except ZeroDivisionError: logger.error("Division by zero in yield calculation.") production_flux_yield = None production_carbon_yield = total_yield( [solution[carbon_source_id]], input_components, solution[production_id], output_components, ) if isnan(production_carbon_yield): production_carbon_yield = None production_mass_yield = total_yield( [solution[carbon_source_id]], input_weights, solution[production_id], output_weight, ) if isnan(production_mass_yield): production_mass_yield = None return ( production_flux, production_flux_yield, production_carbon_yield, production_mass_yield, )
def evaluate_opt_gene(designs, pathway, model, method): if designs is None: return [] logger.info(f"Evaluating {len(designs)} OptGene designs.") pyield = product_yield(pathway.product, model.carbon_source) bpcy = biomass_product_coupled_min_yield(model.biomass, pathway.product, model.carbon_source) results = [] with model: pathway.apply(model) for design_result in designs: with model: design_result.apply(model) try: model.objective = model.biomass solution = model.optimize() p_yield = pyield(model, solution, pathway.product) bpc_yield = bpcy(model, solution, pathway.product) target_flux = solution[pathway.product.id] biomass = solution[model.biomass] except (OptimizationError, ZeroDivisionError): p_yield = None bpc_yield = None target_flux = None biomass = None else: if isnan(p_yield): p_yield = None if isnan(bpc_yield): bpc_yield = None if isnan(target_flux): target_flux = None if isnan(biomass): biomass = None knockouts = { g for g in design_result.targets if isinstance(g, cameo.core.target.GeneKnockoutTarget) } gene_targets = {} for target in knockouts: gene_id = target.id gene = model.genes.get_by_id(gene_id) gene_targets[gene_id] = [] for reaction_target in gene.reactions: rxn_id = reaction_target.id rxn = model.reactions.get_by_id(rxn_id) gene_targets[gene_id].append({ "name": gene.name, "reaction_id": rxn_id, "reaction_name": rxn.name, "subsystem": rxn.subsystem, "gpr": rxn.gene_reaction_rule, "definition_of_stoichiometry": rxn.build_reaction_string(True), }) results.append({ "id": str(uuid4()), "knockouts": list(knockouts), "heterologous_reactions": pathway.reactions, "synthetic_reactions": find_synthetic_reactions(pathway), "fitness": bpc_yield, "yield": p_yield, "product": target_flux, "biomass": biomass, "method": method, "targets": gene_targets, }) return results