def test_robust_regression(self):
#
# Compare cvxpy solutions to cvxopt ground truth
#
from cvxpy import (matrix, variable, program, minimize,
huber, sum, leq, geq, square, norm2,
ones, zeros, quad_form)
tol_exp = 5 # Check solution to within 5 decimal places
m, n = self.m, self.n
A = matrix(self.A)
b = matrix(self.b)
# Method 1: using huber directly
x = variable(n)
p = program(minimize(sum(huber(A*x - b, 1.0))))
p.solve(True)
np.testing.assert_array_almost_equal(
x.value, self.xh, tol_exp)
# Method 2: solving the dual QP
x = variable(n)
u = variable(m)
v = variable(m)
p = program(minimize(0.5*quad_form(u, 1.0) + sum(v)),
[geq(u, 0.0), leq(u, 1.0), geq(v, 0.0),
leq(A*x - b, u + v), geq(A*x - b, -u - v)])
p.solve(True)
np.testing.assert_array_almost_equal(
x.value, self.xh, tol_exp)
def test_robust_regression(self):
#
# Compare cvxpy solutions to cvxopt ground truth
#
from cvxpy import (matrix, variable, program, minimize, huber, sum,
leq, geq, square, norm2, ones, zeros, quad_form)
tol_exp = 5 # Check solution to within 5 decimal places
m, n = self.m, self.n
A = matrix(self.A)
b = matrix(self.b)
# Method 1: using huber directly
x = variable(n)
p = program(minimize(sum(huber(A * x - b, 1.0))))
p.solve(True)
np.testing.assert_array_almost_equal(x.value, self.xh, tol_exp)
# Method 2: solving the dual QP
x = variable(n)
u = variable(m)
v = variable(m)
p = program(minimize(0.5 * quad_form(u, 1.0) + sum(v)), [
geq(u, 0.0),
leq(u, 1.0),
geq(v, 0.0),
leq(A * x - b, u + v),
geq(A * x - b, -u - v)
])
p.solve(True)
np.testing.assert_array_almost_equal(x.value, self.xh, tol_exp)
def con_ctm(self):
return list(flatten([geq(link.v_flow, 0),
leq(link.v_flow, link.fd.q_max),
leq(link.v_flow, link.fd.v * link.v_dens),
leq(link.v_flow, link.fd.w * (link.fd.rho_max - link.v_dens)),
geq(link.v_dens, 0),
leq(link.v_dens, link.fd.rho_max),
] for link in self.get_links()))
def constraint(self):
if self.type == self.Type.EQ:
return eq(self.a, self.b)
if self.type == self.Type.LEQ:
return leq(self.a, self.b)
if self.type == self.Type.GEQ:
return geq(self.a, self.b)
def _MakeMinimalFeasbileConcentrationProblem(self, bounds=None, c_range=(1e-6, 1e-2)):
# Define and apply the constraints on the concentrations
constraints = []
# Define and apply the constraints on the concentrations
ln_conc = cvxpy.variable(1, self.Nc, name='lnC')
constraints += self._MakeLnConcentratonBounds(ln_conc, bounds=bounds,
c_range=c_range)
# find the row vector describing the overall stoichiometry
S = cvxpy.matrix(self.S)
dg0r_primes = cvxpy.matrix(self.dG0_r_prime)
# Make flux-based constraints on reaction free energies.
# All reactions must have negative dGr in the direction of the flux.
# Reactions with a flux of 0 must be in equilibrium.
for i in xrange(self.Nr):
# if the dG0 is unknown, this reaction imposes no new constraints
if np.isnan(self.dG0_r_prime[0, i]):
continue
curr_dgr = dg0r_primes[0, i] + RT * ln_conc * S[:, i]
if self.fluxes[0, i] != 0:
constraints.append(cvxpy.leq(curr_dgr * np.sign(self.fluxes[0, i]),
self.DEFAULT_REACTION_UB))
constraints.append(cvxpy.geq(curr_dgr * np.sign(self.fluxes[0, i]),
self.DEFAULT_REACTION_LB))
else:
constraints.append(cvxpy.eq(curr_dgr, 0))
# Set the constraints
return ln_conc, constraints
def attach_flownx_constraints( flownx ) :
""" add flow capacity constraints to edges """
for _,__, data in flownx.edges_iter( data=True ) :
flowvar = data.get('flow')
constr = []
minflow = data.get( 'minflow', -np.inf )
if minflow > -np.inf : constr.append( cvxpy.geq( flowvar, minflow ) )
maxflow = data.get( 'maxflow', np.inf )
if maxflow < np.inf : constr.append( cvxpy.leq( flowvar, maxflow ) )
data['constraints'] = constr
""" add flow conservation constraints to nodes, besides 's' and 't' """
for u, node_data in flownx.nodes_iter( data=True ) :
if u in [ 's', 't' ] : continue
in_flow = 0.
for _,__, data in flownx.in_edges_iter( u, data=True ) :
in_flow += data.get('flow')
out_flow = 0.
for _,__, data in flownx.out_edges_iter( u, data=True ) :
out_flow += data.get('flow')
node_data['constraints'] = [ cvxpy.eq( in_flow, out_flow ) ]
def FindMtdf_Regularized(self,
c_range=(1e-6, 1e-2),
bounds=None,
c_mid=1e-3,
min_mtdf=None,
max_mtdf=None):
"""Find the MTDF (Maximal Thermodynamic Driving Force).
Uses l2 regularization to minimize the log difference of
concentrations from c_mid.
Args:
c_range: a tuple (min, max) for concentrations (in M).
bounds: a list of (lower bound, upper bound) tuples for compound
concentrations.
c_mid: the defined midpoint concentration.
max_mtdf: the maximum value for the motive force.
Returns:
A 3 tuple (optimal dGfs, optimal concentrations, optimal mtdf).
"""
ln_conc, motive_force_lb, constraints = self._MakeMtdfProblem(
c_range, bounds)
# Set the objective and solve.
norm2_resid = cvxpy.norm2(ln_conc - np.log(c_mid))
if max_mtdf is not None and min_mtdf is not None:
constraints.append(cvxpy.leq(motive_force_lb, max_mtdf))
constraints.append(cvxpy.geq(motive_force_lb, min_mtdf))
objective = cvxpy.minimize(norm2_resid)
elif max_mtdf is not None:
constraints.append(cvxpy.leq(motive_force_lb, max_mtdf))
objective = cvxpy.minimize(norm2_resid)
elif min_mtdf is not None:
constraints.append(cvxpy.geq(motive_force_lb, min_mtdf))
objective = cvxpy.minimize(norm2_resid)
else:
objective = cvxpy.minimize(motive_force_lb + norm2_resid)
program = cvxpy.program(objective, constraints)
program.solve(quiet=True)
return ln_conc.value, program.objective.value
def _MakeMinimumFeasbileConcentrationsProblem(self,
bounds=None,
c_range=(1e-6, 1e-2)):
"""Creates the CVXOPT problem for finding minimum total concentrations.
Returns:
Two tuple (ln_concentrations var, problem).
"""
assert self.dG0_f_prime is not None
constraints = []
# Define and apply the constraints on the concentrations
ln_conc = cvxpy.variable(1, self.Nc, name='lnC')
constraints += self._MakeLnConcentratonBounds(ln_conc,
bounds=bounds,
c_range=c_range)
# Make the objective and problem.
S = cvxpy.matrix(self.S)
# Make flux-based constraints on reaction free energies.
# All reactions must have negative dGr in the direction of the flux.
# Reactions with a flux of 0 must be in equilibrium.
dgf_primes = RT * ln_conc + cvxpy.matrix(self.dG0_f_prime)
for i in xrange(self.Nr):
if self.fluxes[0, i] > 0:
constraints.append(
cvxpy.leq(S[i, :] * dgf_primes, self.DEFAULT_REACTION_UB))
constraints.append(
cvxpy.geq(S[i, :] * dgf_primes, self.DEFAULT_REACTION_LB))
elif self.fluxes[0, i] == 0:
constraints.append(cvxpy.eq(S[i, :] * dgf_primes, 0))
else:
constraints.append(
cvxpy.geq(S[i, :] * dgf_primes, -self.DEFAULT_REACTION_UB))
constraints.append(
cvxpy.leq(S[i, :] * dgf_primes, -self.DEFAULT_REACTION_LB))
return ln_conc, constraints
def _MakeMinimumFeasbileConcentrationsProblem(self, bounds=None,
c_range=(1e-6, 1e-2)):
"""Creates the CVXOPT problem for finding minimum total concentrations.
Returns:
Two tuple (ln_concentrations var, problem).
"""
assert self.dG0_f_prime is not None
constraints = []
# Define and apply the constraints on the concentrations
ln_conc = cvxpy.variable(1, self.Nc, name='lnC')
constraints += self._MakeLnConcentratonBounds(ln_conc, bounds=bounds,
c_range=c_range)
# Make the objective and problem.
S = cvxpy.matrix(self.S)
# Make flux-based constraints on reaction free energies.
# All reactions must have negative dGr in the direction of the flux.
# Reactions with a flux of 0 must be in equilibrium.
dgf_primes = RT * ln_conc + cvxpy.matrix(self.dG0_f_prime)
for i in xrange(self.Nr):
if self.fluxes[0, i] > 0:
constraints.append(cvxpy.leq(S[i, :] * dgf_primes,
self.DEFAULT_REACTION_UB))
constraints.append(cvxpy.geq(S[i, :] * dgf_primes,
self.DEFAULT_REACTION_LB))
elif self.fluxes[0, i] == 0:
constraints.append(cvxpy.eq(S[i, :] * dgf_primes,
0))
else:
constraints.append(cvxpy.geq(S[i, :] * dgf_primes,
-self.DEFAULT_REACTION_UB))
constraints.append(cvxpy.leq(S[i, :] * dgf_primes,
-self.DEFAULT_REACTION_LB))
return ln_conc, constraints
def FindMtdf_Regularized(self, c_range=(1e-6, 1e-2), bounds=None,
c_mid=1e-3,
min_mtdf=None,
max_mtdf=None):
"""Find the MTDF (Maximal Thermodynamic Driving Force).
Uses l2 regularization to minimize the log difference of
concentrations from c_mid.
Args:
c_range: a tuple (min, max) for concentrations (in M).
bounds: a list of (lower bound, upper bound) tuples for compound
concentrations.
c_mid: the defined midpoint concentration.
max_mtdf: the maximum value for the motive force.
Returns:
A 3 tuple (optimal dGfs, optimal concentrations, optimal mtdf).
"""
ln_conc, motive_force_lb, constraints = self._MakeMtdfProblem(c_range, bounds)
# Set the objective and solve.
norm2_resid = cvxpy.norm2(ln_conc - np.log(c_mid))
if max_mtdf is not None and min_mtdf is not None:
constraints.append(cvxpy.leq(motive_force_lb, max_mtdf))
constraints.append(cvxpy.geq(motive_force_lb, min_mtdf))
objective = cvxpy.minimize(norm2_resid)
elif max_mtdf is not None:
constraints.append(cvxpy.leq(motive_force_lb, max_mtdf))
objective = cvxpy.minimize(norm2_resid)
elif min_mtdf is not None:
constraints.append(cvxpy.geq(motive_force_lb, min_mtdf))
objective = cvxpy.minimize(norm2_resid)
else:
objective = cvxpy.minimize(motive_force_lb + norm2_resid)
program = cvxpy.program(objective, constraints)
program.solve(quiet=True)
return ln_conc.value, program.objective.value
def find_decoders_cvxopt(self, values, neus_in_pop, min_w = 0 , max_w = 1):
'''
find optimal decoders using convex bounded optimization
'''
tuning = self.tuning_curves[neus_in_pop]
A=np.array(tuning)
A_m = np.matrix(np.matrix(A))
aa = cx.zeros(np.shape(A))
aa[A_m.nonzero()] = A_m[A_m.nonzero()]
bb = cx.zeros(np.shape(value))
bb[value.nonzero()[0]] = value[value.nonzero()[0]]
m,n = np.shape(aa)
dec = cx.variable(m)
p = cx.program(cx.minimize(cx.norm2((aa)*(dec)-(bb))), [cx.leq(dec,max_w),cx.geq(dec,min_w)])
p.solve()
return dec.value
def PROGRAM( roadnet, surplus, objectives ) :
""" construct the program """
# optvars
assist = dict()
cost = dict()
DELTA = .00001 # cvxpy isn't quite robust to non-full dimensional optimization
for _,__,road in roadnet.edges_iter( keys=True ) :
assist[road] = cvxpy.variable( name='z_{%s}' % road )
cost[road] = cvxpy.variable( name='c_{%s}' % road )
#print assist
#print cost
objfunc = sum( cost.values() )
OBJECTIVE = cvxpy.minimize( objfunc )
CONSTRAINTS = []
# the flow conservation constraints
for u in roadnet.nodes_iter() :
INFLOWS = []
for _,__,road in roadnet.in_edges( u, keys=True ) :
INFLOWS.append( assist[road] + surplus[road] )
OUTFLOWS = []
for _,__,road in roadnet.out_edges( u, keys=True ) :
OUTFLOWS.append( assist[road] )
#conserve_u = cvxpy.eq( sum(OUTFLOWS), sum(INFLOWS) )
error_u = sum(OUTFLOWS) - sum(INFLOWS)
conserve_u = cvxpy.leq( cvxpy.abs( error_u ), DELTA )
CONSTRAINTS.append( conserve_u )
# the cost-form constraints
for road in cost :
for f, line in objectives[road].iter_items() :
# is this plus or minus alpha?
LB = cvxpy.geq( cost[road], line.offset + line.slope * assist[road] )
CONSTRAINTS.append( LB )
prog = cvxpy.program( OBJECTIVE, CONSTRAINTS )
return prog, assist
def _MakeMinimalFeasbileConcentrationProblem(self,
bounds=None,
c_range=(1e-6, 1e-2)):
# Define and apply the constraints on the concentrations
constraints = []
# Define and apply the constraints on the concentrations
ln_conc = cvxpy.variable(1, self.Nc, name='lnC')
constraints += self._MakeLnConcentratonBounds(ln_conc,
bounds=bounds,
c_range=c_range)
# find the row vector describing the overall stoichiometry
S = cvxpy.matrix(self.S)
dg0r_primes = cvxpy.matrix(self.dG0_r_prime)
# Make flux-based constraints on reaction free energies.
# All reactions must have negative dGr in the direction of the flux.
# Reactions with a flux of 0 must be in equilibrium.
for i in xrange(self.Nr):
# if the dG0 is unknown, this reaction imposes no new constraints
if np.isnan(self.dG0_r_prime[0, i]):
continue
curr_dgr = dg0r_primes[0, i] + RT * ln_conc * S[:, i]
if self.fluxes[0, i] != 0:
constraints.append(
cvxpy.leq(curr_dgr * np.sign(self.fluxes[0, i]),
self.DEFAULT_REACTION_UB))
constraints.append(
cvxpy.geq(curr_dgr * np.sign(self.fluxes[0, i]),
self.DEFAULT_REACTION_LB))
else:
constraints.append(cvxpy.eq(curr_dgr, 0))
# Set the constraints
return ln_conc, constraints
def compute_decoders_convex_bounded(x_values,A,nsteps,function=lambda x:x, min_x = -0.2, max_x = 0.2):
'''solve convex optimization problem with cvxpy '''
import cvxpy as cx
import numpy as np
A_m = np.matrix(np.matrix(A))
aa = cx.zeros(np.shape(A))
aa[A_m.nonzero()] = A_m[A_m.nonzero()]
#function to be encoded
value=np.array([[function(x)] for x in x_values])
value=np.reshape(value,nsteps)
bb = cx.zeros(np.shape(value))
bb[0,value.nonzero()[0]] = value[value.nonzero()[0]]
m,n = np.shape(aa)
dec = cx.variable(m)
p = cx.program(cx.minimize(cx.norm2(np.transpose(aa)*(dec)-np.transpose(bb))), [cx.leq(dec,max_x),cx.geq(dec,min_x)])
p.solve()
return dec.value
def _MakeLnConcentratonBounds(self, ln_conc, bounds=None, c_range=None):
"""Make bounds on logarithmic concentrations."""
_c_range = c_range or self.DEFAULT_C_RANGE
c_lower, c_upper = c_range
ln_conc_lb = np.ones((1, self.Nc)) * np.log(c_lower)
ln_conc_ub = np.ones((1, self.Nc)) * np.log(c_upper)
if bounds:
for i, bound in enumerate(bounds):
lb, ub = bound
log_lb = np.log(lb or c_lower)
log_ub = np.log(ub or c_upper)
if log_lb > log_ub:
raise Exception("Lower bound is greater than upper bound: "
"%d > %d" % (log_lb, log_ub))
elif abs(log_lb - log_ub) < 1e-2:
log_lb = log_ub - 1e-2
ln_conc_lb[0, i] = log_lb
ln_conc_ub[0, i] = log_ub
return [cvxpy.geq(ln_conc, cvxpy.matrix(ln_conc_lb)) + \
cvxpy.leq(ln_conc, cvxpy.matrix(ln_conc_ub))]
def _MakeLnConcentratonBounds(self, ln_conc, bounds=None, c_range=None):
"""Make bounds on logarithmic concentrations."""
_c_range = c_range or self.DEFAULT_C_RANGE
c_lower, c_upper = c_range
ln_conc_lb = np.ones((1, self.Nc)) * np.log(c_lower)
ln_conc_ub = np.ones((1, self.Nc)) * np.log(c_upper)
if bounds:
for i, bound in enumerate(bounds):
lb, ub = bound
log_lb = np.log(lb or c_lower)
log_ub = np.log(ub or c_upper)
if log_lb > log_ub:
raise Exception("Lower bound is greater than upper bound: "
"%d > %d" % (log_lb, log_ub))
elif abs(log_lb - log_ub) < 1e-2:
log_lb = log_ub - 1e-2
ln_conc_lb[0, i] = log_lb
ln_conc_ub[0, i] = log_ub
return [cvxpy.geq(ln_conc, cvxpy.matrix(ln_conc_lb)) + \
cvxpy.leq(ln_conc, cvxpy.matrix(ln_conc_ub))]
def con_route_tt(self): return [ leq(self.route_tt_heuristic(route), 10000.0) for route in self.all_routes() ]
def check_feasible_constraints(self):
return list(flatten(
[geq(link.v_flow, link.flow), geq(link.v_dens, link.rho),leq(link.v_flow, link.flow), leq(link.v_dens, link.rho)]
for link in self.get_links()
))
def MinimizeConcentration(self, metabolite_index=None,
concentration_bounds=None):
"""Finds feasible concentrations minimizing the concentration
of metabolite i.
Args:
metabolite_index: the index of the metabolite to minimize.
if == None, minimize the sum of all concentrations.
concentration_bounds: the Bounds objects setting concentration bounds.
"""
my_bounds = concentration_bounds or self.DefaultConcentrationBounds()
ln_conc = cvxpy.variable(m=1, n=self.Ncompounds, name='lnC')
ln_conc_lb, ln_conc_ub = my_bounds.GetLnBounds(self.compounds)
constr = [cvxpy.geq(ln_conc, cvxpy.matrix(ln_conc_lb)),
cvxpy.leq(ln_conc, cvxpy.matrix(ln_conc_ub))]
my_dG0_r_primes = np.matrix(self.dG0_r_prime)
# Make flux-based constraints on reaction free energies.
# All reactions must have negative dGr in the direction of the flux.
# Reactions with a flux of 0 must be in equilibrium.
S = np.matrix(self.S)
for i, flux in enumerate(self.fluxes):
curr_dg0 = my_dG0_r_primes[0, i]
# if the dG0 is unknown, this reaction imposes no new constraints
if np.isnan(curr_dg0):
continue
rcol = cvxpy.matrix(S[:, i])
curr_dgr = curr_dg0 + RT * ln_conc * rcol
if flux == 0:
constr.append(cvxpy.eq(curr_dgr, 0.0))
else:
constr.append(cvxpy.leq(curr_dgr, 0.0))
objective = None
if metabolite_index is not None:
my_conc = ln_conc[0, metabolite_index]
objective = cvxpy.minimize(cvxpy.exp(my_conc))
else:
objective = cvxpy.minimize(
cvxpy.sum(cvxpy.exp(ln_conc)))
name = 'CONC_OPT'
if metabolite_index:
name = 'CONC_%d_OPT' % metabolite_index
problem = cvxpy.program(objective, constr, name=name)
optimum = problem.solve(quiet=True)
"""
status = problem.solve(quiet=True)
if status != 'optimal':
status = optimized_pathway.OptimizationStatus.Infeasible(
'Pathway infeasible given bounds.')
return ConcentrationOptimizedPathway(
self._model, self._thermo,
my_bounds, optimization_status=status)
"""
opt_ln_conc = np.matrix(np.array(ln_conc.value))
result = ConcentrationOptimizedPathway(
self._model, self._thermo,
my_bounds, optimal_value=optimum,
optimal_ln_metabolite_concentrations=opt_ln_conc)
return result
def FindMTDF(self, concentration_bounds=None, normalization=None):
"""Finds the MTDF.
Args:
bounds: the Bounds objects setting concentration bounds.
"""
my_bounds = concentration_bounds or self.DefaultConcentrationBounds()
normalization = normalization or self.DeltaGNormalization.DEFAULT
# Constrain concentrations
ln_conc = cvxpy.variable(m=1, n=self.Ncompounds, name='lnC')
ln_conc_lb, ln_conc_ub = my_bounds.GetLnBounds(self.compounds)
constr = [cvxpy.geq(ln_conc, cvxpy.matrix(ln_conc_lb)),
cvxpy.leq(ln_conc, cvxpy.matrix(ln_conc_ub))]
# Make the objective
motive_force_lb = cvxpy.variable(name='B')
my_dG0_r_primes = np.matrix(self.dG0_r_prime)
# Make flux-based constraints on reaction free energies.
# All reactions must have negative dGr in the direction of the flux.
# Reactions with a flux of 0 must be in equilibrium.
S = np.matrix(self.S)
for i, flux in enumerate(self.fluxes):
curr_dg0 = my_dG0_r_primes[0, i]
# if the dG0 is unknown, this reaction imposes no new constraints
if np.isnan(curr_dg0):
continue
rcol = cvxpy.matrix(S[:, i])
curr_dgr = curr_dg0 + RT * ln_conc * rcol
if flux == 0:
constr.append(cvxpy.eq(curr_dgr, 0))
else:
motive_force = self.DeltaGNormalization.NormalizeDGByFlux(
curr_dgr, flux, normalization)
constr.append(cvxpy.geq(motive_force, motive_force_lb))
objective = cvxpy.maximize(motive_force_lb)
problem = cvxpy.program(objective, constr, name='MTDF_OPT')
problem.solve(quiet=True)
"""
if status != 'optimal':
status = optimized_pathway.OptimizationStatus.Infeasible(
'Pathway infeasible given bounds.')
return MTDFOptimizedPathway(
self._model, self._thermo,
my_bounds, optimization_status=status)
"""
mtdf = float(motive_force_lb.value)
opt_ln_conc = np.matrix(np.array(ln_conc.value))
result = MTDFOptimizedPathway(
self._model, self._thermo,
my_bounds, optimal_value=mtdf,
optimal_ln_metabolite_concentrations=opt_ln_conc)
result.SetNormalization(normalization)
return result
def MinimizeConcentration(self,
metabolite_index=None,
concentration_bounds=None):
"""Finds feasible concentrations minimizing the concentration
of metabolite i.
Args:
metabolite_index: the index of the metabolite to minimize.
if == None, minimize the sum of all concentrations.
concentration_bounds: the Bounds objects setting concentration bounds.
"""
my_bounds = concentration_bounds or self.DefaultConcentrationBounds()
ln_conc = cvxpy.variable(m=1, n=self.Ncompounds, name='lnC')
ln_conc_lb, ln_conc_ub = my_bounds.GetLnBounds(self.compounds)
constr = [
cvxpy.geq(ln_conc, cvxpy.matrix(ln_conc_lb)),
cvxpy.leq(ln_conc, cvxpy.matrix(ln_conc_ub))
]
my_dG0_r_primes = np.matrix(self.dG0_r_prime)
# Make flux-based constraints on reaction free energies.
# All reactions must have negative dGr in the direction of the flux.
# Reactions with a flux of 0 must be in equilibrium.
S = np.matrix(self.S)
for i, flux in enumerate(self.fluxes):
curr_dg0 = my_dG0_r_primes[0, i]
# if the dG0 is unknown, this reaction imposes no new constraints
if np.isnan(curr_dg0):
continue
rcol = cvxpy.matrix(S[:, i])
curr_dgr = curr_dg0 + RT * ln_conc * rcol
if flux == 0:
constr.append(cvxpy.eq(curr_dgr, 0.0))
else:
constr.append(cvxpy.leq(curr_dgr, 0.0))
objective = None
if metabolite_index is not None:
my_conc = ln_conc[0, metabolite_index]
objective = cvxpy.minimize(cvxpy.exp(my_conc))
else:
objective = cvxpy.minimize(cvxpy.sum(cvxpy.exp(ln_conc)))
name = 'CONC_OPT'
if metabolite_index:
name = 'CONC_%d_OPT' % metabolite_index
problem = cvxpy.program(objective, constr, name=name)
optimum = problem.solve(quiet=True)
"""
status = problem.solve(quiet=True)
if status != 'optimal':
status = optimized_pathway.OptimizationStatus.Infeasible(
'Pathway infeasible given bounds.')
return ConcentrationOptimizedPathway(
self._model, self._thermo,
my_bounds, optimization_status=status)
"""
opt_ln_conc = np.matrix(np.array(ln_conc.value))
result = ConcentrationOptimizedPathway(
self._model,
self._thermo,
my_bounds,
optimal_value=optimum,
optimal_ln_metabolite_concentrations=opt_ln_conc)
return result
def FindMTDF(self, concentration_bounds=None, normalization=None):
"""Finds the MTDF.
Args:
bounds: the Bounds objects setting concentration bounds.
"""
my_bounds = concentration_bounds or self.DefaultConcentrationBounds()
normalization = normalization or self.DeltaGNormalization.DEFAULT
# Constrain concentrations
ln_conc = cvxpy.variable(m=1, n=self.Ncompounds, name='lnC')
ln_conc_lb, ln_conc_ub = my_bounds.GetLnBounds(self.compounds)
constr = [
cvxpy.geq(ln_conc, cvxpy.matrix(ln_conc_lb)),
cvxpy.leq(ln_conc, cvxpy.matrix(ln_conc_ub))
]
# Make the objective
motive_force_lb = cvxpy.variable(name='B')
my_dG0_r_primes = np.matrix(self.dG0_r_prime)
# Make flux-based constraints on reaction free energies.
# All reactions must have negative dGr in the direction of the flux.
# Reactions with a flux of 0 must be in equilibrium.
S = np.matrix(self.S)
for i, flux in enumerate(self.fluxes):
curr_dg0 = my_dG0_r_primes[0, i]
# if the dG0 is unknown, this reaction imposes no new constraints
if np.isnan(curr_dg0):
continue
rcol = cvxpy.matrix(S[:, i])
curr_dgr = curr_dg0 + RT * ln_conc * rcol
if flux == 0:
constr.append(cvxpy.eq(curr_dgr, 0))
else:
motive_force = self.DeltaGNormalization.NormalizeDGByFlux(
curr_dgr, flux, normalization)
constr.append(cvxpy.geq(motive_force, motive_force_lb))
objective = cvxpy.maximize(motive_force_lb)
problem = cvxpy.program(objective, constr, name='MTDF_OPT')
problem.solve(quiet=True)
"""
if status != 'optimal':
status = optimized_pathway.OptimizationStatus.Infeasible(
'Pathway infeasible given bounds.')
return MTDFOptimizedPathway(
self._model, self._thermo,
my_bounds, optimization_status=status)
"""
mtdf = float(motive_force_lb.value)
opt_ln_conc = np.matrix(np.array(ln_conc.value))
result = MTDFOptimizedPathway(
self._model,
self._thermo,
my_bounds,
optimal_value=mtdf,
optimal_ln_metabolite_concentrations=opt_ln_conc)
result.SetNormalization(normalization)
return result
def solve(self):
''' solver for the optimal purchasing of gas at stations
does not return anything, but attaches some resulting properties at the end'''
n = len(self.route.stations)
if self.method == "dynamic":
def conditionallyFillUp(gas_in_tank,station):
print 'filling up'
distance_to_end = sum([self.route.distances[j]
for j in range(station,n)]
)
bought.append(max(0,min(distance_to_end / self.car.economy, self.car.tank_max) - gas_in_tank))
prices = [station.regular for station in self.route.stations]
print 'prices: ' + str(prices)
i = 0
range_of_car = (self.car.tank_max - self.gas_min) * self.car.economy
print 'range of car: ' + str(range_of_car)
#set initial stations
current_price = self.route.stations[i].regular
station_chosen = i
#Probably safe to assume both are zero, call api if necessary
distance_to_first_station = 0
distance_from_last_station = 0
if (self.car.start - distance_to_first_station / self.car.economy < self.gas_min):
raise Exception("Unfeasible to reach")
else:
gas_in_tank_at_last_station = self.car.start - (distance_to_first_station / self.car.economy)
#Make parameter (probably as proportion of full tank) on website
gas_at_end = self.gas_min
#for export
stations_chosen = []
bought = []
#simulte partially filled tank as miles already driven
miles_since_last_stop = (self.car.tank_max - gas_in_tank_at_last_station) * self.car.economy + distance_to_first_station
#make sure you can get home
self.route.distances.append(distance_from_last_station)
while i < n:
#for feasibility check
firstStationOnTank = i
#determine where car should stop
while i < n:
#check if next stop is cheaper
print i
print current_price
if self.route.stations[i].regular < current_price:
current_price = self.route.stations[i].regular
station_chosen = i
print 'station_chosen: ' + str(station_chosen)
#increment
miles_since_last_stop += self.route.distances[i]
i = i + 1
print 'miles_since_last_stop: ' + str(miles_since_last_stop)
if miles_since_last_stop > range_of_car:
print i
if (gas_in_tank_at_last_station - self.route.distances[firstStationOnTank] / self.car.economy < self.gas_min):
raise Exception("Unfeasible to reach")
stations_chosen.append(station_chosen)
current_price = self.route.stations[i].regular
station_chosen = i
break
#determine how much gas car should get
if len(stations_chosen) > 1:
distance_between_stations = sum([self.route.distances[j]
for j in range(stations_chosen[len(stations_chosen) - 2],stations_chosen[len(stations_chosen) - 1])]
)
print stations_chosen
print 'last_station: ' + str(stations_chosen[len(stations_chosen) - 2]) + ", price:" + str(self.route.stations[stations_chosen[len(stations_chosen) - 2]].regular)
print 'this station: ' + str(stations_chosen[len(stations_chosen) - 1]) + ", price:" + str(self.route.stations[stations_chosen[len(stations_chosen) - 1]].regular)
if (self.route.stations[stations_chosen[len(stations_chosen) - 2]].regular < self.route.stations[stations_chosen[len(stations_chosen) - 1]].regular):
#fill 'er up, errr, conditionally
conditionallyFillUp(gas_in_tank_at_last_station, stations_chosen[len(stations_chosen) - 2])
else:
#only get enough gas to get to next station
print 'getting minimum'
bought.append(distance_between_stations / self.car.economy)
gas_in_tank_at_last_station = gas_in_tank_at_last_station - (distance_between_stations / self.car.economy) + bought[len(bought) - 1]
miles_since_last_stop = 0
stations_chosen.append(station_chosen)
conditionallyFillUp(gas_in_tank_at_last_station, stations_chosen[len(stations_chosen) - 1])
print 'stations_chosen: ' + str(stations_chosen)
print 'bought: ' + str(bought)
objective_value = sum(
[self.route.stations[stations_chosen[j]].regular*bought[j]
for j in range(len(stations_chosen))]
)
self.stations_chosen = stations_chosen
else:
# how to constrain the LP
in_tank = variable(n,name ='gas in tank') # how much gas in tank var
bought = variable(n,name = 'gas bought') # how much to buy at each station var
constraints = ([eq(in_tank[0,0],self.car.start)] + # starting gas
[eq(in_tank[i+1,0], # mass balance
in_tank[i,0] +
bought[i,0] -
self.route.distances[i]/self.car.economy)#DV: Changed from * to /
for i in range(n-1)] +
[geq(in_tank,self.gas_min)] + # can't dip below certain amount
[leq(in_tank + bought,self.car.tank_max)] + # max size of tank
[geq(bought,0)] # physical constraint (cannot cyphon gas for sale to bum)
)
# the total cost of the fuel
fuel_cost = sum(
[self.route.stations[j].regular*bought[j,0]
for j in range(n)]
)
# define program
p = program(minimize(fuel_cost), constraints)
objective_value = p.solve()
# attach properties to access later
self.in_tank = in_tank
self.program = p
self.bought = bought
self.objective_value = objective_value
