11. Solver Interface

Each cobrapy solver must expose the following API. The solvers all will have their own distinct LP object types, but each can be manipulated by these functions. This API can be used directly when implementing algorithms efficiently on linear programs because it has 2 primary benefits:

  1. Avoid the overhead of creating and destroying LP’s for each operation
  2. Many solver objects preserve the basis between subsequent LP’s, making each subsequent LP solve faster

We will walk though the API with the cglpk solver, which links the cobrapy solver API with GLPK‘s C API.

In [1]:

import cobra.test

model = cobra.test.create_test_model("textbook")
solver = cobra.solvers.cglpk

11.1. Attributes and functions

Each solver has some attributes:

11.1.1. solver_name

The name of the solver. This is the name which will be used to select the solver in cobrapy functions.

In [2]:

solver.solver_name

Out[2]:

'cglpk'

In [3]:

model.optimize(solver="cglpk")

Out[3]:

<Solution 0.87 at 0x7fd42ad90c18>

11.1.2. _SUPPORTS_MILP

The presence of this attribute tells cobrapy that the solver supports mixed-integer linear programming

In [4]:

solver._SUPPORTS_MILP

Out[4]:

True

11.1.3. solve

Model.optimize is a wrapper for each solver’s solve function. It takes in a cobra model and returns a solution

In [5]:

solver.solve(model)

Out[5]:

<Solution 0.87 at 0x7fd42ad90908>

11.1.4. create_problem

This creates the LP object for the solver.

In [6]:

lp = solver.create_problem(model, objective_sense="maximize")
lp

Out[6]:

<cobra.solvers.cglpk.GLP at 0x3e846e8>

11.1.5. solve_problem

Solve the LP object and return the solution status

In [7]:

solver.solve_problem(lp)

Out[7]:

'optimal'

11.1.6. format_solution

Extract a cobra.Solution object from a solved LP object

In [8]:

solver.format_solution(lp, model)

Out[8]:

<Solution 0.87 at 0x7fd42ad90668>

11.1.7. get_objective_value

Extract the objective value from a solved LP object

In [9]:

solver.get_objective_value(lp)

Out[9]:

0.8739215069684909

11.1.8. get_status

Get the solution status of a solved LP object

In [10]:

solver.get_status(lp)

Out[10]:

'optimal'

11.1.9. change_variable_objective

change the objective coefficient a reaction at a particular index. This does not change any of the other objectives which have already been set. This example will double and then revert the biomass coefficient.

In [11]:

model.reactions.index("Biomass_Ecoli_core")

Out[11]:

12

In [12]:

solver.change_variable_objective(lp, 12, 2)
solver.solve_problem(lp)
solver.get_objective_value(lp)

Out[12]:

1.7478430139369818

In [13]:

solver.change_variable_objective(lp, 12, 1)
solver.solve_problem(lp)
solver.get_objective_value(lp)

Out[13]:

0.8739215069684909

11.1.10. change variable_bounds

change the lower and upper bounds of a reaction at a particular index. This example will set the lower bound of the biomass to an infeasible value, then revert it.

In [14]:

solver.change_variable_bounds(lp, 12, 1000, 1000)
solver.solve_problem(lp)

Out[14]:

'infeasible'

In [15]:

solver.change_variable_bounds(lp, 12, 0, 1000)
solver.solve_problem(lp)

Out[15]:

'optimal'

11.1.11. change_coefficient

Change a coefficient in the stoichiometric matrix. In this example, we will set the entry for ADP in the ATMP reaction to in infeasible value, then reset it.

In [16]:

model.metabolites.index("atp_c")

Out[16]:

16

In [17]:

model.reactions.index("ATPM")

Out[17]:

10

In [18]:

solver.change_coefficient(lp, 16, 10, -10)
solver.solve_problem(lp)

Out[18]:

'infeasible'

In [19]:

solver.change_coefficient(lp, 16, 10, -1)
solver.solve_problem(lp)

Out[19]:

'optimal'

11.1.12. set_parameter

Set a solver parameter. Each solver will have its own particular set of unique paramters. However, some have unified names. For example, all solvers should accept “tolerance_feasibility.”

In [20]:

solver.set_parameter(lp, "tolerance_feasibility", 1e-9)

In [21]:

solver.set_parameter(lp, "objective_sense", "minimize")
solver.solve_problem(lp)
solver.get_objective_value(lp)

Out[21]:

0.0

In [22]:

solver.set_parameter(lp, "objective_sense", "maximize")
solver.solve_problem(lp)
solver.get_objective_value(lp)

Out[22]:

0.8739215069684912

11.2. Example with FVA

Consider flux variability analysis (FVA), which requires maximizing and minimizing every reaction with the original biomass value fixed at its optimal value. If we used the cobra Model API in a naive implementation, we would do the following:

In [23]:

%%time
# work on a copy of the model so the original is not changed
m = model.copy()

# set the lower bound on the objective to be the optimal value
f = m.optimize().f
for objective_reaction, coefficient in m.objective.items():
    objective_reaction.lower_bound = coefficient * f

# now maximize and minimze every reaction to find its bounds
fva_result = {}
for r in m.reactions:
    m.change_objective(r)
    fva_result[r.id] = {
        "maximum": m.optimize(objective_sense="maximize").f,
        "minimum": m.optimize(objective_sense="minimize").f
    }

CPU times: user 171 ms, sys: 0 ns, total: 171 ms
Wall time: 171 ms

Instead, we could use the solver API to do this more efficiently. This is roughly how cobrapy implementes FVA. It keeps uses the same LP object and repeatedly maximizes and minimizes it. This allows the solver to preserve the basis, and is much faster. The speed increase is even more noticeable the larger the model gets.

In [24]:

%%time
# create the LP object
lp = solver.create_problem(model)

# set the lower bound on the objective to be the optimal value
solver.solve_problem(lp)
f = solver.get_objective_value(lp)
for objective_reaction, coefficient in model.objective.items():
    objective_index = model.reactions.index(objective_reaction)
    # old objective is no longer the objective
    solver.change_variable_objective(lp, objective_index, 0.)
    solver.change_variable_bounds(
        lp, objective_index, f * coefficient,
        objective_reaction.upper_bound)

# now maximize and minimze every reaction to find its bounds
fva_result = {}
for index, r in enumerate(model.reactions):
    solver.change_variable_objective(lp, index, 1.)
    result = {}
    solver.solve_problem(lp, objective_sense="maximize")
    result["maximum"] = solver.get_objective_value(lp)
    solver.solve_problem(lp, objective_sense="minimize")
    result["minimum"] = solver.get_objective_value(lp)
    solver.change_variable_objective(lp, index, 0.)
    fva_result[r.id] = result

CPU times: user 8.28 ms, sys: 25 µs, total: 8.31 ms
Wall time: 8.14 ms