def test_choose_solver(model):
so = su.choose_solver(model, "glpk")
assert su.interface_to_str(so) == "glpk"
if any(s in su.solvers for s in su.qp_solvers):
qp_choice = su.choose_solver(model, qp=True)
assert su.interface_to_str(qp_choice) in su.qp_solvers
else:
with pytest.raises(su.SolverNotFound):
su.choose_solver(model, qp=True)
def test_choose_solver(model: "Model") -> Optional[su.SolverNotFound]:
"""Test that solver switching is working."""
so = su.choose_solver(model, "glpk")
assert su.interface_to_str(so) == "glpk"
if any(s in su.solvers for s in su.qp_solvers):
qp_choice = su.choose_solver(model, qp=True)
assert su.interface_to_str(qp_choice) in su.qp_solvers
else:
with pytest.raises(su.SolverNotFound):
su.choose_solver(model, qp=True)
def test_choose_solver(self, model):
so = su.choose_solver(model)
assert su.interface_to_str(so) == "glpk"
so = su.choose_solver(model, "glpk")
assert su.interface_to_str(so) == "glpk"
if any(s in su.solvers for s in su.qp_solvers):
qp_choice = su.choose_solver(model, qp=True)
assert su.interface_to_str(qp_choice) in su.qp_solvers
else:
with pytest.raises(su.SolverNotFound):
su.choose_solver(model, qp=True)
def optimize(self, objective_sense=None, raise_error=False, **kwargs):
"""
Optimize the model using flux balance analysis.
Parameters
----------
objective_sense : {None, 'maximize' 'minimize'}, optional
Whether fluxes should be maximized or minimized. In case of None,
the previous direction is used.
raise_error : bool
If true, raise an OptimizationError if solver status is not
optimal.
solver : {None, 'glpk', 'cglpk', 'gurobi', 'cplex'}, optional
If unspecified will use the currently defined `self.solver`
otherwise it will use the given solver and update the attribute.
quadratic_component : {None, scipy.sparse.dok_matrix}, optional
The dimensions should be (n, n) where n is the number of
reactions. This sets the quadratic component (Q) of the
objective coefficient, adding :math:`\\frac{1}{2} v^T \cdot Q
\cdot v` to the objective. Ignored for optlang based solvers.
tolerance_feasibility : float
Solver tolerance for feasibility. Ignored for optlang based
solvers
tolerance_markowitz : float
Solver threshold during pivot. Ignored for optlang based solvers
time_limit : float
Maximum solver time (in seconds). Ignored for optlang based solvers
Notes
-----
Only the most commonly used parameters are presented here. Additional
parameters for cobra.solvers may be available and specified with the
appropriate keyword argument.
"""
legacy, solver = choose_solver(self, solver=kwargs.get("solver"))
original_direction = self.objective.direction
if legacy:
if objective_sense is None:
objective_sense = {
"max": "maximize",
"min": "minimize"
}[original_direction]
solution = optimize(self,
objective_sense=objective_sense,
**kwargs)
check_solver_status(solution.status, raise_error=raise_error)
return solution
self.solver = solver
self.objective.direction = \
{"maximize": "max", "minimize": "min"}.get(
objective_sense, original_direction)
self.slim_optimize()
solution = get_solution(self, raise_error=raise_error)
self.objective.direction = original_direction
return solution
def test_choose_solver(self, model):
legacy, so = su.choose_solver(model)
assert not legacy
assert su.interface_to_str(so) == "glpk"
legacy, so = su.choose_solver(model, "optlang-glpk")
assert not legacy
assert su.interface_to_str(so) == "glpk"
assert su.choose_solver(model, "cglpk")[0]
if any(s in su.solvers for s in su.qp_solvers):
legacy, qp_choice = su.choose_solver(model, qp=True)
assert not legacy
assert su.interface_to_str(qp_choice) in su.qp_solvers
else:
with pytest.raises(su.SolverNotFound):
su.choose_solver(model, qp=True)
def add_moma(model0, solution=None, linear=False, runcopy=False):
r"""Add constraints and objective representing for MOMA.
This adds variables and constraints for the minimization of metabolic
adjustment (MOMA) to the model.
Parameters
----------
model : cobra.Model
The model to add MOMA constraints and objective to.
solution : cobra.Solution
A previous solution to use as a reference.
linear : bool
Whether to use the linear MOMA formulation or not.
Returns
-------
Nothing.
Notes
-----
In the original MOMA specification one looks for the flux distribution
of the deletion (v^d) closest to the fluxes without the deletion (v).
In math this means:
minimize \sum_i (v^d_i - v_i)^2
s.t. Sv^d = 0
lb_i <= v^d_i <= ub_i
Here, we use a variable transformation v^t := v^d_i - v_i. Substituting
and using the fact that Sv = 0 gives:
minimize \sum_i (v^t_i)^2
s.t. Sv^d = 0
v^t = v^d_i - v_i
lb_i <= v^d_i <= ub_i
So basically we just re-center the flux space at the old solution and than
find the flux distribution closest to the new zero (center). This is the
same strategy as used in cameo.
In the case of linear MOMA, we instead minimize \sum_i abs(v^t_i). The
linear MOMA is typically significantly faster. Also quadratic MOMA tends
to give flux distributions in which all fluxes deviate from the reference
fluxes a little bit whereas linear MOMA tends to give flux distributions
where the majority of fluxes are the same reference which few fluxes
deviating a lot (typical effect of L2 norm vs L1 norm).
The former objective function is saved in the optlang solver interface as
"moma_old_objective" and this can be used to immediately extract the value
of the former objective after MOMA optimization.
"""
if runcopy:
model = model0.copy()
else:
model = model0
if 'moma_old_objective' in model.solver.variables:
raise ValueError('model is already adjusted for MOMA')
# Fall back to default QP solver if current one has no QP capability
if not linear:
model.solver = sutil.choose_solver(model, qp=True)[1]
if solution is None:
solution = model.optimize()
prob = model.problem
v = prob.Variable("moma_old_objective")
c = prob.Constraint(model.solver.objective.expression - v,
lb=0.0,
ub=0.0,
name="moma_old_objective_constraint")
to_add = [v, c]
new_obj = S.Zero
for r in model.reactions:
flux = solution.fluxes[r.id]
if linear:
components = sutil.add_absolute_expression(model,
r.flux_expression,
name="moma_dist_" +
r.id,
difference=flux,
add=False)
to_add.extend(components)
new_obj += components.variable
else:
dist = prob.Variable("moma_dist_" + r.id)
const = prob.Constraint(r.flux_expression - dist,
lb=flux,
ub=flux,
name="moma_constraint_" + r.id)
to_add.extend([dist, const])
new_obj += dist**2
model.add_cons_vars(to_add)
model.objective = prob.Objective(new_obj, direction='min')
return model
def pfba(model,
already_irreversible=False,
fraction_of_optimum=1.0,
solver=None,
desired_objective_value=None,
objective=None,
reactions=None,
**optimize_kwargs):
"""Perform basic pFBA (parsimonious Enzyme Usage Flux Balance Analysis)
to minimize total flux.
pFBA [1] adds the minimization of all fluxes the the objective of the
model. This approach is motivated by the idea that high fluxes have a
higher enzyme turn-over and that since producing enzymes is costly,
the cell will try to minimize overall flux while still maximizing the
original objective function, e.g. the growth rate.
Parameters
----------
model : cobra.Model
The model
already_irreversible : bool, optional
By default, the model is converted to an irreversible one.
However, if the model is already irreversible, this step can be
skipped. Ignored for optlang solvers as not relevant.
fraction_of_optimum : float, optional
Fraction of optimum which must be maintained. The original objective
reaction is constrained to be greater than maximal_value *
fraction_of_optimum.
solver : str, optional
Name of the solver to be used. If None it will respect the solver set
in the model (model.solver).
desired_objective_value : float, optional
A desired objective value for the minimal solution that bypasses the
initial optimization result. Ignored for optlang solvers, instead,
define your objective separately and pass using the `objective`
argument.
objective : dict or model.problem.Objective
A desired objective to use during optimization in addition to the
pFBA objective. Dictionaries (reaction as key, coefficient as value)
can be used for linear objectives. Not used for non-optlang solvers.
reactions : iterable
List of reactions or reaction identifiers. Implies `return_frame` to
be true. Only return fluxes for the given reactions. Faster than
fetching all fluxes if only a few are needed. Only supported for
optlang solvers.
**optimize_kwargs : additional arguments for legacy solver, optional
Additional arguments passed to the legacy solver. Ignored for
optlang solver (those can be configured using
model.solver.configuration).
Returns
-------
cobra.Solution
The solution object to the optimized model with pFBA constraints added.
References
----------
.. [1] Lewis, N. E., Hixson, K. K., Conrad, T. M., Lerman, J. A.,
Charusanti, P., Polpitiya, A. D., Palsson, B. O. (2010). Omic data
from evolved E. coli are consistent with computed optimal growth from
genome-scale models. Molecular Systems Biology, 6,
390. doi:10.1038/msb.2010.47
"""
legacy, solver = sutil.choose_solver(model, solver)
if legacy:
return _pfba_legacy(model,
already_irreversible=already_irreversible,
fraction_of_optimum=fraction_of_optimum,
solver=solver,
desired_objective_value=desired_objective_value,
**optimize_kwargs)
else:
model.solver = solver
return _pfba_optlang(model,
objective=objective,
fraction_of_optimum=fraction_of_optimum,
reactions=reactions)
def add_moma(model, solution=None, linear=True):
r"""Add constraints and objective representing for MOMA.
This adds variables and constraints for the minimization of metabolic
adjustment (MOMA) to the model.
Parameters
----------
model : cobra.Model
The model to add MOMA constraints and objective to.
solution : cobra.Solution, optional
A previous solution to use as a reference. If no solution is given,
one will be computed using pFBA.
linear : bool, optional
Whether to use the linear MOMA formulation or not (default True).
Notes
-----
In the original MOMA [1]_ specification one looks for the flux distribution
of the deletion (v^d) closest to the fluxes without the deletion (v).
In math this means:
minimize \sum_i (v^d_i - v_i)^2
s.t. Sv^d = 0
lb_i <= v^d_i <= ub_i
Here, we use a variable transformation v^t := v^d_i - v_i. Substituting
and using the fact that Sv = 0 gives:
minimize \sum_i (v^t_i)^2
s.t. Sv^d = 0
v^t = v^d_i - v_i
lb_i <= v^d_i <= ub_i
So basically we just re-center the flux space at the old solution and then
find the flux distribution closest to the new zero (center). This is the
same strategy as used in cameo.
In the case of linear MOMA [2]_, we instead minimize \sum_i abs(v^t_i). The
linear MOMA is typically significantly faster. Also quadratic MOMA tends
to give flux distributions in which all fluxes deviate from the reference
fluxes a little bit whereas linear MOMA tends to give flux distributions
where the majority of fluxes are the same reference with few fluxes
deviating a lot (typical effect of L2 norm vs L1 norm).
The former objective function is saved in the optlang solver interface as
``"moma_old_objective"`` and this can be used to immediately extract the
value of the former objective after MOMA optimization.
See Also
--------
pfba : parsimonious FBA
References
----------
.. [1] Segrè, Daniel, Dennis Vitkup, and George M. Church. “Analysis of
Optimality in Natural and Perturbed Metabolic Networks.”
Proceedings of the National Academy of Sciences 99, no. 23
(November 12, 2002): 15112. https://doi.org/10.1073/pnas.232349399.
.. [2] Becker, Scott A, Adam M Feist, Monica L Mo, Gregory Hannum,
Bernhard Ø Palsson, and Markus J Herrgard. “Quantitative
Prediction of Cellular Metabolism with Constraint-Based Models:
The COBRA Toolbox.” Nature Protocols 2 (March 29, 2007): 727.
"""
if 'moma_old_objective' in model.solver.variables:
raise ValueError('model is already adjusted for MOMA')
# Fall back to default QP solver if current one has no QP capability
if not linear:
model.solver = sutil.choose_solver(model, qp=True)
if solution is None:
solution = pfba(model)
prob = model.problem
v = prob.Variable("moma_old_objective")
c = prob.Constraint(model.solver.objective.expression - v,
lb=0.0,
ub=0.0,
name="moma_old_objective_constraint")
to_add = [v, c]
model.objective = prob.Objective(Zero, direction="min", sloppy=True)
obj_vars = []
for r in model.reactions:
flux = solution.fluxes[r.id]
if linear:
components = sutil.add_absolute_expression(model,
r.flux_expression,
name="moma_dist_" +
r.id,
difference=flux,
add=False)
to_add.extend(components)
obj_vars.append(components.variable)
else:
dist = prob.Variable("moma_dist_" + r.id)
const = prob.Constraint(r.flux_expression - dist,
lb=flux,
ub=flux,
name="moma_constraint_" + r.id)
to_add.extend([dist, const])
obj_vars.append(dist**2)
model.add_cons_vars(to_add)
if linear:
model.objective.set_linear_coefficients({v: 1.0 for v in obj_vars})
else:
model.objective = prob.Objective(add(obj_vars),
direction="min",
sloppy=True)
def add_moma(model, solution=None, linear=True):
r"""Add constraints and objective representing for MOMA.
This adds variables and constraints for the minimization of metabolic
adjustment (MOMA) to the model.
Parameters
----------
model : cobra.Model
The model to add MOMA constraints and objective to.
solution : cobra.Solution, optional
A previous solution to use as a reference. If no solution is given,
one will be computed using pFBA.
linear : bool, optional
Whether to use the linear MOMA formulation or not (default True).
Notes
-----
In the original MOMA [1]_ specification one looks for the flux distribution
of the deletion (v^d) closest to the fluxes without the deletion (v).
In math this means:
minimize \sum_i (v^d_i - v_i)^2
s.t. Sv^d = 0
lb_i <= v^d_i <= ub_i
Here, we use a variable transformation v^t := v^d_i - v_i. Substituting
and using the fact that Sv = 0 gives:
minimize \sum_i (v^t_i)^2
s.t. Sv^d = 0
v^t = v^d_i - v_i
lb_i <= v^d_i <= ub_i
So basically we just re-center the flux space at the old solution and then
find the flux distribution closest to the new zero (center). This is the
same strategy as used in cameo.
In the case of linear MOMA [2]_, we instead minimize \sum_i abs(v^t_i). The
linear MOMA is typically significantly faster. Also quadratic MOMA tends
to give flux distributions in which all fluxes deviate from the reference
fluxes a little bit whereas linear MOMA tends to give flux distributions
where the majority of fluxes are the same reference with few fluxes
deviating a lot (typical effect of L2 norm vs L1 norm).
The former objective function is saved in the optlang solver interface as
``"moma_old_objective"`` and this can be used to immediately extract the
value of the former objective after MOMA optimization.
See Also
--------
pfba : parsimonious FBA
References
----------
.. [1] Segrè, Daniel, Dennis Vitkup, and George M. Church. “Analysis of
Optimality in Natural and Perturbed Metabolic Networks.”
Proceedings of the National Academy of Sciences 99, no. 23
(November 12, 2002): 15112. https://doi.org/10.1073/pnas.232349399.
.. [2] Becker, Scott A, Adam M Feist, Monica L Mo, Gregory Hannum,
Bernhard Ø Palsson, and Markus J Herrgard. “Quantitative
Prediction of Cellular Metabolism with Constraint-Based Models:
The COBRA Toolbox.” Nature Protocols 2 (March 29, 2007): 727.
"""
if 'moma_old_objective' in model.solver.variables:
raise ValueError('model is already adjusted for MOMA')
# Fall back to default QP solver if current one has no QP capability
if not linear:
model.solver = sutil.choose_solver(model, qp=True)
if solution is None:
solution = pfba(model)
prob = model.problem
v = prob.Variable("moma_old_objective")
c = prob.Constraint(model.solver.objective.expression - v,
lb=0.0, ub=0.0, name="moma_old_objective_constraint")
to_add = [v, c]
model.objective = prob.Objective(Zero, direction="min", sloppy=True)
obj_vars = []
for r in model.reactions:
flux = solution.fluxes[r.id]
if linear:
components = sutil.add_absolute_expression(
model, r.flux_expression, name="moma_dist_" + r.id,
difference=flux, add=False)
to_add.extend(components)
obj_vars.append(components.variable)
else:
dist = prob.Variable("moma_dist_" + r.id)
const = prob.Constraint(r.flux_expression - dist, lb=flux, ub=flux,
name="moma_constraint_" + r.id)
to_add.extend([dist, const])
obj_vars.append(dist ** 2)
model.add_cons_vars(to_add)
if linear:
model.objective.set_linear_coefficients({v: 1.0 for v in obj_vars})
else:
model.objective = prob.Objective(
add(obj_vars), direction="min", sloppy=True)
def model_summary(model, threshold=1E-8, fva=None, floatfmt='.3g',
**solver_args):
"""Print a summary of the input and output fluxes of the model.
threshold: float
tolerance for determining if a flux is zero (not printed)
fva: int or None
Whether or not to calculate and report flux variability in the
output summary
floatfmt: string
format method for floats, passed to tabulate. Default is '.3g'.
"""
legacy, _ = choose_solver(model, solver=solver_args.get("solver"))
if legacy:
raise NotImplementedError(
"Summary support for legacy solvers was removed.")
# Create a dataframe of objective fluxes
objective_reactions = linear_reaction_coefficients(model)
obj_fluxes = pd.DataFrame({key: key.flux * value for key, value in
iteritems(objective_reactions)},
index=['flux']).T
obj_fluxes['id'] = obj_fluxes.apply(
lambda x: format_long_string(x.name.id, 15), 1)
# Build a dictionary of metabolite production from the boundary reactions
# collect rxn.flux before fva which invalidates previous solver state
boundary_reactions = model.exchanges
metabolite_fluxes = {}
for rxn in boundary_reactions:
for met, stoich in iteritems(rxn.metabolites):
metabolite_fluxes[met] = {
'id': format_long_string(met.id, 15),
'flux': stoich * rxn.flux}
# Calculate FVA results if requested
if fva:
fva_results = flux_variability_analysis(
model, reaction_list=boundary_reactions, fraction_of_optimum=fva,
**solver_args)
for rxn in boundary_reactions:
for met, stoich in iteritems(rxn.metabolites):
imin = stoich * fva_results.loc[rxn.id]['minimum']
imax = stoich * fva_results.loc[rxn.id]['maximum']
# Correct 'max' and 'min' for negative values
metabolite_fluxes[met].update({
'fmin': imin if abs(imin) <= abs(imax) else imax,
'fmax': imax if abs(imin) <= abs(imax) else imin,
})
# Generate a dataframe of boundary fluxes
metabolite_fluxes = pd.DataFrame(metabolite_fluxes).T
metabolite_fluxes = _process_flux_dataframe(
metabolite_fluxes, fva, threshold, floatfmt)
# Begin building string output table
def get_str_table(species_df, fva=False):
"""Formats a string table for each column"""
if not fva:
return tabulate(species_df.loc[:, ['id', 'flux']].values,
floatfmt=floatfmt, tablefmt='plain').split('\n')
else:
return tabulate(
species_df.loc[:, ['id', 'flux', 'fva_fmt']].values,
floatfmt=floatfmt, tablefmt='simple',
headers=['id', 'Flux', 'Range']).split('\n')
in_table = get_str_table(
metabolite_fluxes[metabolite_fluxes.is_input], fva=fva)
out_table = get_str_table(
metabolite_fluxes[~metabolite_fluxes.is_input], fva=fva)
obj_table = get_str_table(obj_fluxes, fva=False)
# Print nested output table
print_(tabulate(
[entries for entries in zip_longest(in_table, out_table, obj_table)],
headers=['IN FLUXES', 'OUT FLUXES', 'OBJECTIVES'], tablefmt='simple'))
def production_envelope(model,
reactions,
objective=None,
c_source=None,
points=20,
solver=None):
"""Calculate the objective value conditioned on all combinations of
fluxes for a set of chosen reactions
The production envelope can be used to analyze a models ability to
produce a given compound conditional on the fluxes for another set of
reaction, such as the uptake rates. The model is alternately optimize
with respect to minimizing and maximizing the objective and record the
obtained fluxes. Ranges to compute production is set to the effective
bounds, i.e. the minimum / maximum fluxes that can be obtained given
current reaction bounds.
Parameters
----------
model : cobra.Model
The model to compute the production envelope for.
reactions : list or string
A list of reactions, reaction identifiers or single reaction
objective : string, dict, model.solver.interface.Objective
The objective (reaction) to use for the production envelope. Use the
model's current objective is left missing.
c_source : cobra.Reaction or string
A reaction or reaction identifier that is the source of carbon for
computing carbon (mol carbon in output over mol carbon in input) and
mass yield (gram product over gram output). Only objectives with a
carbon containing input and output metabolite is supported.
points : int
The number of points to calculate production for.
solver : string
The solver to use - only here for consistency with older
implementations (this argument will be removed in the future). The
solver should be set using `model.solver` directly. Only optlang
based solvers are supported.
Returns
-------
pandas.DataFrame
A data frame with one row per evaluated point and
- reaction id : one column per input reaction indicating the flux at
each given point,
- flux: the objective flux
- carbon_yield: if carbon source is defined and the product is a
single metabolite (mol carbon product per mol carbon feeding source)
- _mass_yield: if carbon source is defined and the product is a
single metabolite (gram product per 1 g of feeding source)
- direction: the direction of the optimization.
Only points that give a valid solution are returned.
Examples
--------
>>> import cobra.test
>>> from cobra.flux_analysis import production_envelope
>>> model = cobra.test.create_test_model("textbook")
>>> production_envelope(model, ["EX_glc__D_e", "EX_o2_e"])
"""
legacy, solver = sutil.choose_solver(model, solver)
if legacy:
raise ValueError('production_envelope is only implemented for optlang '
'based solver interfaces.')
reactions = model.reactions.get_by_any(reactions)
objective = model.solver.objective if objective is None else objective
with model:
model.objective = objective
carbon_io = _c_input_output(model, c_source)
min_max = fva(model, reactions, fraction_of_optimum=0)
grid = [
linspace(min_max.minimum[rxn.id],
min_max.maximum[rxn.id],
points,
endpoint=True) for rxn in reactions
]
grid_list = list(product(*grid))
result = _envelope_for_points(model, reactions, grid_list, carbon_io)
return pd.DataFrame(result)
def add_moma(model, solution=None, linear=False):
r"""Add constraints and objective representing for MOMA.
This adds variables and constraints for the minimization of metabolic
adjustment (MOMA) to the model.
Parameters
----------
model : cobra.Model
The model to add MOMA constraints and objective to.
solution : cobra.Solution
A previous solution to use as a reference.
linear : bool
Whether to use the linear MOMA formulation or not.
Returns
-------
Nothing.
Notes
-----
In the original MOMA specification one looks for the flux distribution
of the deletion (v^d) closest to the fluxes without the deletion (v).
In math this means:
minimize \sum_i (v^d_i - v_i)^2
s.t. Sv^d = 0
lb_i <= v^d_i <= ub_i
Here, we use a variable transformation v^t := v^d_i - v_i. Substituting
and using the fact that Sv = 0 gives:
minimize \sum_i (v^t_i)^2
s.t. Sv^d = 0
v^t = v^d_i - v_i
lb_i <= v^d_i <= ub_i
So basically we just re-center the flux space at the old solution and than
find the flux distribution closest to the new zero (center). This is the
same strategy as used in cameo.
In the case of linear MOMA, we instead minimize \sum_i abs(v^t_i). The
linear MOMA is typically significantly faster. Also quadratic MOMA tends
to give flux distributions in which all fluxes deviate from the reference
fluxes a little bit whereas linear MOMA tends to give flux distributions
where the majority of fluxes are the same reference which few fluxes
deviating a lot (typical effect of L2 norm vs L1 norm).
The former objective function is saved in the optlang solver interface as
"moma_old_objective" and this can be used to immediately extract the value
of the former objective after MOMA optimization.
"""
if 'moma_old_objective' in model.solver.variables:
raise ValueError('model is already adjusted for MOMA')
# Fall back to default QP solver if current one has no QP capability
if not linear:
model.solver = sutil.choose_solver(model, qp=True)
if solution is None:
solution = model.optimize()
prob = model.problem
v = prob.Variable("moma_old_objective")
c = prob.Constraint(model.solver.objective.expression - v,
lb=0.0, ub=0.0, name="moma_old_objective_constraint")
to_add = [v, c]
new_obj = Zero
for r in model.reactions:
flux = solution.fluxes[r.id]
if linear:
components = sutil.add_absolute_expression(
model, r.flux_expression, name="moma_dist_" + r.id,
difference=flux, add=False)
to_add.extend(components)
new_obj += components.variable
else:
dist = prob.Variable("moma_dist_" + r.id)
const = prob.Constraint(r.flux_expression - dist, lb=flux, ub=flux,
name="moma_constraint_" + r.id)
to_add.extend([dist, const])
new_obj += dist**2
model.add_cons_vars(to_add)
model.objective = prob.Objective(new_obj, direction='min')
def find_blocked_reactions(model,
reaction_list=None,
solver=None,
zero_cutoff=1e-9,
open_exchanges=False,
**solver_args):
"""Finds reactions that cannot carry a flux with the current
exchange reaction settings for a cobra model, using flux variability
analysis.
Parameters
----------
model : cobra.Model
The model to analyze
reaction_list : list
List of reactions to consider, use all if left missing
solver : string
The name of the solver to use
zero_cutoff : float
Flux value which is considered to effectively be zero.
open_exchanges : bool
If true, set bounds on exchange reactions to very high values to
avoid that being the bottle-neck.
**solver_args :
Additional arguments to the solver. Ignored for optlang based solvers.
Returns
-------
list
List with the blocked reactions
"""
legacy, solver_interface = sutil.choose_solver(model, solver)
with model:
if open_exchanges:
for reaction in model.exchanges:
reaction.bounds = (min(reaction.lower_bound,
-1000), max(reaction.upper_bound, 1000))
if reaction_list is None:
reaction_list = model.reactions
# limit to reactions which are already 0. If the reactions already
# carry flux in this solution, then they can not be blocked.
if legacy:
solution = solver_interface.solve(model, **solver_args)
reaction_list = [
i for i in reaction_list
if abs(solution.x_dict[i.id]) < zero_cutoff
]
else:
model.solver = solver_interface
model.solver.optimize()
solution = get_solution(model, reactions=reaction_list)
reaction_list = [
rxn for rxn in reaction_list
if abs(solution.fluxes[rxn.id]) < zero_cutoff
]
# run fva to find reactions where both max and min are 0
flux_span = flux_variability_analysis(model,
fraction_of_optimum=0.,
reaction_list=reaction_list,
solver=solver,
**solver_args)
return [
rxn_id for rxn_id, min_max in flux_span.iterrows()
if max(abs(min_max)) < zero_cutoff
]
def flux_variability_analysis(model,
reaction_list=None,
loopless=False,
fraction_of_optimum=1.0,
solver=None,
**solver_args):
"""Runs flux variability analysis to find the min/max flux values for each
each reaction in `reaction_list`.
Parameters
----------
model : a cobra model
The model for which to run the analysis. It will *not* be modified.
reaction_list : list of cobra.Reaction or str, optional
The reactions for which to obtain min/max fluxes. If None will use
all reactions in the model.
loopless : boolean, optional
Whether to return only loopless solutions. Ignored for legacy solvers,
also see `Notes`.
fraction_of_optimum : float, optional
Must be <= 1.0. Requires that the objective value is at least
fraction * max_objective_value. A value of 0.85 for instance means that
the objective has to be at least at 95% percent of its maximum.
solver : str, optional
Name of the solver to be used. If None it will respect the solver set
in the model (model.solver).
**solver_args : additional arguments for legacy solver, optional
Additional arguments passed to the legacy solver. Ignored for
optlang solver (those can be configured using
model.solver.configuration).
Returns
-------
pandas.DataFrame
DataFrame with reaction identifier as the index columns
- maximum: indicating the highest possible flux
- minimum: indicating the lowest possible flux
Notes
-----
This implements the fast version as described in [1]_. Please note that
the flux distribution containing all minimal/maximal fluxes does not have
to be a feasible solution for the model. Fluxes are minimized/maximized
individually and a single minimal flux might require all others to be
suboptimal.
Using the loopless option will lead to a significant increase in
computation time (about a factor of 100 for large models). However, the
algorithm used here (see [2]_) is still more than 1000x faster than the
"naive" version using `add_loopless(model)`. Also note that if you have
included constraints that force a loop (for instance by setting all fluxes
in a loop to be non-zero) this loop will be included in the solution.
References
----------
.. [1] Computationally efficient flux variability analysis.
Gudmundsson S, Thiele I.
BMC Bioinformatics. 2010 Sep 29;11:489.
doi: 10.1186/1471-2105-11-489, PMID: 20920235
.. [2] CycleFreeFlux: efficient removal of thermodynamically infeasible
loops from flux distributions.
Desouki AA, Jarre F, Gelius-Dietrich G, Lercher MJ.
Bioinformatics. 2015 Jul 1;31(13):2159-65.
doi: 10.1093/bioinformatics/btv096.
"""
legacy, solver = sutil.choose_solver(model, solver)
if reaction_list is None:
reaction_list = model.reactions
if not legacy:
fva_result = _fva_optlang(model, reaction_list, fraction_of_optimum,
loopless)
else:
fva_result = _fva_legacy(model, reaction_list, fraction_of_optimum,
"maximize", solver, **solver_args)
return pandas.DataFrame(fva_result).T
def add_moma(model):
"""Add constraints and objective representing a MOMA
(minimization of metabolic adjustment) model.
Parameters:
-----------
model : a cobra model
Returns:
--------
Nothing.
Notes
-----
In the original MOMA specification one looks for the flux distribution
of the deletion (v^d) closest to the fluxes without the deletion (v).
In math this means:
minimize \sum_i (v^d_i - v_i)^2
s.t. Sv^d = 0
lb_i <= v^d_i <= ub_i
Here, we use a variable transformation v^t := v^d_i - v_i. Substituting
and using the fact that Sv = 0 gives:
minimize \sum (v^t_i)^2
s.t. Sv^d = 0
v^t = v^d_i - v_i
lb_i <= v^d_i <= ub_i
So basically we just re-center the flux space at the old solution and than
find the flux distribution closest to the new zero (center). This is the
same strategy as used in cameo.
The former objective function is saved in the optlang solver interface as
"moma_old_objective" and this can be used to immediately extract the value
of the former objective after MOMA optimization.
"""
if 'moma_old_objective' in model.solver.variables:
raise ValueError('model is already adjusted for MOMA')
# Fall back to default QP solver if current one has no QP capability
model.solver = sutil.choose_solver(model, qp=True)[1]
solution = model.optimize()
prob = model.problem
v = prob.Variable("moma_old_objective")
c = prob.Constraint(model.solver.objective.expression - v,
lb=0.0,
ub=0.0,
name="moma_old_objective_constraint")
to_add = [v, c]
new_obj = S.Zero
for r in model.reactions:
flux = solution.fluxes[r.id]
dist = prob.Variable("moma_dist_" + r.id)
const = prob.Constraint(r.flux_expression - dist,
lb=flux,
ub=flux,
name="moma_constraint_" + r.id)
to_add.extend([dist, const])
new_obj += dist**2
model.add_cons_vars(to_add)
model.objective = prob.Objective(new_obj, direction='min')
