def lp(S, A, r, T, s0):
"""
Solve the LP problem to find out the optimal occupancy
Args:
S: state set
A: action set
r: reward
T: transition function
s0: init state
"""
m = CPlexModel()
if not config.VERBOSE or config.DEBUG: m.setVerbosity(0)
# useful constants
Sr = range(len(S))
v = m.new(len(S), name='v')
for s in Sr:
for a in A:
m.constrain(v[s] >= r(S[s], a) + sum(v[sp] * T(S[s], a, S[sp]) for sp in Sr))
# obj
obj = m.minimize(v[s0])
ret = util.Counter()
for s in Sr:
ret[S[s]] = m[v][s]
return ret
def lp(S, A, r, T, s0):
"""
Solve the LP problem to find out the optimal occupancy
Args:
S: state set
A: action set
r: reward
T: transition function
s0: init state
"""
m = CPlexModel()
if not config.VERBOSE or config.DEBUG: m.setVerbosity(0)
# useful constants
Sr = range(len(S))
v = m.new(len(S), name='v')
for s in Sr:
for a in A:
m.constrain(v[s] >= r(S[s], a) + sum(v[sp] * T(S[s], a, S[sp]) for sp in Sr))
# obj
obj = m.minimize(v[s0])
ret = util.Counter()
for s in Sr:
ret[S[s]] = m[v][s]
return ret
def opt(e_init, e_target, hrv_hist, hrv_en):
# verbosity is how much log is reported back from CPlex. 3 is the most verbose
verbosity = 3
m = CPlexModel(verbosity)
b = m.new((epochs_per_day, nodes, mod_levels),
vtype=int,
lb=0,
ub=1,
name='b')
l = m.new((epochs_per_day, nodes, bin_num),
vtype=float,
lb=-1,
ub=battery_cap,
name='l')
fixed_prob = np.linespace(0, 1, num=bin_num, endpoint=True, dtype=float)
e_init_hist = np.zeros(e_init.shape, dtype=float)
e_init_hist[:, 0] = 1
hist_rv = np.zeros((epochs_per_day, nodes, bin_num), dtype=float)
hist_rv[0] = e_init_hist
# prepare the energy vector here
en_rv = np.zeros((epochs_per_day, nodes, bin_num), dtype=float)
en_rv[0] = e_init
for i in xrange(1, epochs_per_day):
en_rv[i], hist_rv[i] = next_battery_level(en_rv[i - 1], hist_rv[i - 1],\
hrv_en[i, :, :] - (np.vectorize(energy))(b[i, :]), hrv_hist[i, :, :])
m.constrain(en_rv[i] >= 0)
m.constrain(sum(np.vectorize(time)(b[i, :])) <= D)
m.maximize(objective_function(en_rv[-1], hist_rv[-1]))
return m
def findUndominatedReward(mdpH, mdpR, newPi, humanPi, localDifferentPis,
domPis):
"""
Implementation of the linear programming problem (Eq.2) in report 12.5
Returns the objective value and a reward function (which is only useful when the obj value is > 0)
newPi is \hat{\pi} in the linear programming problem in the report.
The robot tries to see if there exists a reward function where newPi is better than the best policy in domPis.
"""
m = CPlexModel()
if not config.VERBOSE: m.setVerbosity(0)
S = mdpH.S
robotA = mdpR.A
humanA = mdpH.A
# index of states and actions
Sr = range(len(S))
robotAr = range(len(robotA))
humanAr = range(len(humanA))
r = m.new(len(S), lb=0, ub=1, name='r')
z = m.new(
name='z'
) # when the optimal value is attained, z = \max_{domPi \in domPis} V^{domPi}_r
for domPi in domPis:
m.constrain(z >= sum(
[domPi[S[s], robotA[a]] * r[s] for s in Sr for a in robotAr]))
# make sure r is consistent with humanPi
for s in S:
for a in humanA:
# humanPi is better than a locally different policy which takes action a in state a
m.constrain(sum(sum((humanPi[S[sp], humanA[ap]] - localDifferentPis[s, a][S[sp], humanA[ap]]) for ap in humanAr)\
* r[sp] for sp in Sr) >= 0)
# maxi_r { V^{newPi}_r - \max_{domPi \in domPis} V^{domPi}_r }
cplexObj = m.maximize(
sum(newPi[S[s], robotA[a]] * r[s] for s in Sr for a in robotAr) - z)
obj = sum([newPi[S[s], robotA[a]] * m[r][s] for s in Sr
for a in robotAr]) - m[z]
# the reward function has the same values for same states, but need to convert back to the S x A space
rFunc = lambda s, a: m[r][Sr.index(s)]
print 'cplexobj', cplexObj
print 'obj', obj
print 'newPi'
printPi(newPi)
print 'z', m[z], 'r', m[r]
return obj, rFunc
def rewardUncertainMILP(S, A, R, T, s0, terminal, k, optV, gamma=1):
"""
The algorithm adapted from
Viappiani, Paolo and Boutilier, CraigOptimal. set recommendations based on regret
This algorithm would find the minimax-regret policy query in our problem.
Not sure how to use this algorithm.
"""
m = CPlexModel()
if not config.VERBOSE: m.setVerbosity(0)
M = 100000
# state range
Sr = range(len(S))
# action range
Ar = range(len(A))
mr = m.new(name='mr')
# decision variables
x = m.new((k, len(S), len(A)), lb=0, name='x')
v = m.new((k, len(R)), name='v')
I = m.new((k, len(R)), vtype=bool, name='I')
for r in range(len(R)):
m.constrain(mr >= sum(v[i, r]) for i in range(k))
for r in range(len(R)):
for i in range(k):
m.constrain(v[i, r] >= optV[r] - sum(x[i, s, a] * R[r](S[s], A[a])
for s in Sr for a in Ar) +
(I[i, r] - 1) * M)
# make sure x is a valid occupancy
for i in range(k):
for sp in Sr:
m.constrain(
sum(x[i, s, a] * ((s == sp) - gamma * T(S[s], A[a], S[sp]))
for s in Sr for a in Ar) == (S[sp] == s0))
for r in range(len(R)):
m.constrain(sum(I[i, r] for i in range(k)) == 1)
for r in range(len(R)):
for i in range(k):
m.constrain(v[i, r] >= 0)
obj = m.minimize(mr)
return obj, m[I]
def findUndominatedReward(mdpH, mdpR, newPi, humanPi, localDifferentPis, domPis):
"""
Implementation of the linear programming problem (Eq.2) in report 12.5
Returns the objective value and a reward function (which is only useful when the obj value is > 0)
newPi is \hat{\pi} in the linear programming problem in the report.
The robot tries to see if there exists a reward function where newPi is better than the best policy in domPis.
"""
m = CPlexModel()
if not config.VERBOSE: m.setVerbosity(0)
S = mdpH.S
robotA = mdpR.A
humanA = mdpH.A
# index of states and actions
Sr = range(len(S))
robotAr = range(len(robotA))
humanAr = range(len(humanA))
r = m.new(len(S), lb=0, ub=1, name='r')
z = m.new(name='z') # when the optimal value is attained, z = \max_{domPi \in domPis} V^{domPi}_r
for domPi in domPis:
m.constrain(z >= sum([domPi[S[s], robotA[a]] * r[s] for s in Sr for a in robotAr]))
# make sure r is consistent with humanPi
for s in S:
for a in humanA:
# humanPi is better than a locally different policy which takes action a in state a
m.constrain(sum(sum((humanPi[S[sp], humanA[ap]] - localDifferentPis[s, a][S[sp], humanA[ap]]) for ap in humanAr)\
* r[sp] for sp in Sr) >= 0)
# maxi_r { V^{newPi}_r - \max_{domPi \in domPis} V^{domPi}_r }
cplexObj = m.maximize(sum(newPi[S[s], robotA[a]] * r[s] for s in Sr for a in robotAr) - z)
obj = sum([newPi[S[s], robotA[a]] * m[r][s] for s in Sr for a in robotAr]) - m[z]
# the reward function has the same values for same states, but need to convert back to the S x A space
rFunc = lambda s, a: m[r][Sr.index(s)]
print 'cplexobj', cplexObj
print 'obj', obj
print 'newPi'
printPi(newPi)
print 'z', m[z], 'r', m[r]
return obj, rFunc
def lwaLP(graph_object):
capabilites = graph_object.capabilities
no_vertices = graph_object.n
attacker_strategy = list()
m = CPlexModel()
cv = m.new(no_vertices, vtype=float, ub=1, lb=0)
U = m.new(vtype=float)
diag = np.diag(capabilites)
m.constrain(U <= -diag * (1 - cv))
m.constrain(sum(cv) <= graph_object.R)
m.maximize(U)
for i in xrange(m[cv]):
if m[cv][i] > 0:
attacker_strategy.append(i)
start = findStrategySet(m[cv], graph_object.R)
return start, attacker_strategy
def rewardUncertainMILP(S, A, R, T, s0, terminal, k, optV, gamma=1):
"""
The algorithm adapted from
Viappiani, Paolo and Boutilier, CraigOptimal. set recommendations based on regret
This algorithm would find the minimax-regret policy query in our problem.
Not sure how to use this algorithm.
"""
m = CPlexModel()
if not config.VERBOSE: m.setVerbosity(0)
M = 100000
# state range
Sr = range(len(S))
# action range
Ar = range(len(A))
mr = m.new(name='mr')
# decision variables
x = m.new((k, len(S), len(A)), lb=0, name='x')
v = m.new((k, len(R)), name='v')
I = m.new((k, len(R)), vtype=bool, name='I')
for r in range(len(R)):
m.constrain(mr >= sum(v[i, r]) for i in range(k))
for r in range(len(R)):
for i in range(k):
m.constrain(v[i, r] >= optV[r] - sum(x[i, s, a] * R[r](S[s], A[a]) for s in Sr for a in Ar) + (I[i, r] - 1) * M)
# make sure x is a valid occupancy
for i in range(k):
for sp in Sr:
m.constrain(sum(x[i, s, a] * ((s == sp) - gamma * T(S[s], A[a], S[sp])) for s in Sr for a in Ar) == (S[sp] == s0))
for r in range(len(R)):
m.constrain(sum(I[i, r] for i in range(k)) == 1)
for r in range(len(R)):
for i in range(k):
m.constrain(v[i, r] >= 0)
obj = m.minimize(mr)
return obj, m[I]
def milp(S, A, R, T, s0, psi, maxV):
"""
Solve the MILP problem in greedy construction of policy query
Args:
S: state set
A: action set
R: reward candidate set
T: transition function
s0: init state
psi: prior belief on rewards
maxV: maxV[i] = max_{\pi \in q} V_{r_i}^\pi
"""
m = CPlexModel()
if not config.VERBOSE: m.setVerbosity(0)
# useful constants
rLen = len(R)
M = 10000 # a large number
Sr = range(len(S))
Ar = range(len(A))
# decision variables
# FIXME i removed upper bound of x. it shoundn't have such bound without transient-state assumption, right?
x = m.new((len(S), len(A)), lb=0, name='x')
z = m.new(rLen, vtype=bool, name='z')
y = m.new(rLen, name='y')
# constraints on y
m.constrain([y[i] <= sum([x[s, a] * R[i](S[s], A[a]) for s in Sr for a in Ar]) - maxV[i] + (1 - z[i]) * M for i in xrange(rLen)])
m.constrain([y[i] <= z[i] * M for i in xrange(rLen)])
# constraints on x (valid occupancy)
for sp in Sr:
if S[sp] == s0:
m.constrain(sum([x[sp, ap] for ap in Ar]) == 1)
else:
m.constrain(sum([x[sp, ap] for ap in Ar]) == sum([x[s, a] * T(S[s], A[a], S[sp]) for s in Sr for a in Ar]))
# obj
obj = m.maximize(sum([psi[i] * y[i] for i in xrange(rLen)]))
if config.VERBOSE:
print 'obj', obj
print 'x', m[x]
print 'y', m[y]
print 'z', m[z]
# build occupancy as S x A -> x[.,.]
# z[i] == 1 then this policy is better than maxV on the i-th reward candidate
res = util.Counter()
for s in Sr:
for a in Ar:
res[S[s], A[a]] = m[x][s, a]
return res
def domPiMilp(S, A, r, T, s0, terminal, domPis, consIdx, gamma=1):
"""
Finding dominating policies by representing constraints as possible negative rewards.
Described in the report on aug.19, 2017.
"""
rmax = 10000
M = 0.001
consLen = len(consIdx)
m = CPlexModel()
if not config.VERBOSE: m.setVerbosity(0)
# state range
Sr = range(len(S))
# action range
Ar = range(len(A))
# decision variables
x = m.new((len(S), len(A)), lb=0, name='x')
z = m.new(consLen, vtype=bool, name='z')
#z = [0, 1, 0] # test for office nav domain
t = m.new(name='t')
# flow conservation
for sp in Sr:
# x (x(s) - \gamma * T) = \sigma
# and make sure there is no flow back from the terminal states
if not terminal(S[sp]):
m.constrain(sum(x[s, a] * ((s == sp) - gamma * T(S[s], A[a], S[sp]) * (not terminal(S[s]))) for s in Sr for a in Ar) == (S[sp] == s0))
#print S[sp], [(S[s], A[a]) for s in Sr for a in Ar if T(S[s], A[a], S[sp]) > 0]
else:
m.constrain(sum(x[s, a] * ((s == sp) - gamma * T(S[s], A[a], S[sp]) * (not terminal(S[sp]))) for s in Sr for a in Ar) == (S[sp] == s0))
# t is the lower bound of the difference between x and y
# note: i don't think expressions in constraints can call other functions
for y in domPis:
# note that y is indexed by elements in S x A, not numbered indices
m.constrain(sum(x[s, a] * r(S[s], A[a]) for s in Sr for a in Ar) -\
sum(y[S[s], A[a]] *
(r(S[s], A[a]) + sum(- rmax * (S[s][consIdx[i]] != s0[consIdx[i]]) * z[i] for i in range(consLen)))\
for s in Sr for a in Ar)\
>= t)
for s in Sr:
for i in range(consLen):
if S[s][consIdx[i]] != s0[consIdx[i]]:
for a in Ar:
m.constrain(z[i] + M * x[s, a] <= 1)
# obj
obj = m.maximize(t)
print m[z]
return obj, {(S[s], A[a]): m[x][s, a] for s in Sr for a in Ar}
def milp(S, A, R, T, s0, psi, maxV):
"""
Solve the MILP problem in greedy construction of policy query
Args:
S: state set
A: action set
R: reward candidate set
T: transition function
s0: init state
psi: prior belief on rewards
maxV: maxV[i] = max_{\pi \in q} V_{r_i}^\pi
"""
m = CPlexModel()
if not config.VERBOSE: m.setVerbosity(0)
# useful constants
rLen = len(R)
M = 10000 # a large number
Sr = range(len(S))
Ar = range(len(A))
# decision variables
# FIXME i removed upper bound of x. it shoundn't have such bound without transient-state assumption, right?
x = m.new((len(S), len(A)), lb=0, name='x')
z = m.new(rLen, vtype=bool, name='z')
y = m.new(rLen, name='y')
# constraints on y
m.constrain([y[i] <= sum([x[s, a] * R[i](S[s], A[a]) for s in Sr for a in Ar]) - maxV[i] + (1 - z[i]) * M for i in xrange(rLen)])
m.constrain([y[i] <= z[i] * M for i in xrange(rLen)])
# constraints on x (valid occupancy)
for sp in Sr:
if S[sp] == s0:
m.constrain(sum([x[sp, ap] for ap in Ar]) == 1)
else:
m.constrain(sum([x[sp, ap] for ap in Ar]) == sum([x[s, a] * T(S[s], A[a], S[sp]) for s in Sr for a in Ar]))
# obj
obj = m.maximize(sum([psi[i] * y[i] for i in xrange(rLen)]))
if config.VERBOSE:
print 'obj', obj
print 'x', m[x]
print 'y', m[y]
print 'z', m[z]
# build occupancy as S x A -> x[.,.]
# z[i] == 1 then this policy is better than maxV on the i-th reward candidate
res = util.Counter()
for s in Sr:
for a in Ar:
res[S[s], A[a]] = m[x][s, a]
return res
def domPiMilp(S, A, r, T, s0, terminal, domPis, consIdx, gamma=1):
"""
Finding dominating policies by representing constraints as possible negative rewards.
Described in the report on aug.19, 2017.
"""
rmax = 10000
M = 0.001
consLen = len(consIdx)
m = CPlexModel()
if not config.VERBOSE: m.setVerbosity(0)
# state range
Sr = range(len(S))
# action range
Ar = range(len(A))
# decision variables
x = m.new((len(S), len(A)), lb=0, name='x')
z = m.new(consLen, vtype=bool, name='z')
#z = [0, 1, 0] # test for office nav domain
t = m.new(name='t')
# flow conservation
for sp in Sr:
# x (x(s) - \gamma * T) = \sigma
# and make sure there is no flow back from the terminal states
if not terminal(S[sp]):
m.constrain(sum(x[s, a] * ((s == sp) - gamma * T(S[s], A[a], S[sp]) * (not terminal(S[s]))) for s in Sr for a in Ar) == (S[sp] == s0))
#print S[sp], [(S[s], A[a]) for s in Sr for a in Ar if T(S[s], A[a], S[sp]) > 0]
else:
m.constrain(sum(x[s, a] * ((s == sp) - gamma * T(S[s], A[a], S[sp]) * (not terminal(S[sp]))) for s in Sr for a in Ar) == (S[sp] == s0))
# t is the lower bound of the difference between x and y
# note: i don't think expressions in constraints can call other functions
for y in domPis:
# note that y is indexed by elements in S x A, not numbered indices
m.constrain(sum(x[s, a] * r(S[s], A[a]) for s in Sr for a in Ar) -\
sum(y[S[s], A[a]] *
(r(S[s], A[a]) + sum(- rmax * (S[s][consIdx[i]] != s0[consIdx[i]]) * z[i] for i in range(consLen)))\
for s in Sr for a in Ar)\
>= t)
for s in Sr:
for i in range(consLen):
if S[s][consIdx[i]] != s0[consIdx[i]]:
for a in Ar:
m.constrain(z[i] + M * x[s, a] <= 1)
# obj
obj = m.maximize(t)
print m[z]
return obj, {(S[s], A[a]): m[x][s, a] for s in Sr for a in Ar}
def solve_GT_LP_relax_noisy_CPLEX(A, y, lambda_reg, do_binary=False):
''' solve the LP formulation of noisy boolean
compressed sensing using CPLEX'''
M, N = A.shape
assert np.linalg.norm(y - y**2) <= 1e-10, "Inputs must be binary"
inds_1 = np.where(y == 1)[0]
inds_0 = np.where(y == 0)[0]
A1 = A[inds_1, :]
A0 = A[inds_0, :]
### introduce random small perturbations to avoid degenerate solutions
w_pert_x = np.ones(N) + 0.001 * np.random.rand(N)
w_pert_xi = np.ones(M) + 0.001 * np.random.rand(M, 1)
### try cplex directy:
M1 = len(inds_1)
M0 = len(inds_0)
w_pert_xi_pos = w_pert_xi[inds_1]
w_pert_xi_neg = w_pert_xi[inds_0]
m = CPlexModel(verbosity=0)
if do_binary: ### solve the binary problem using cuts + branch and bound
x_sdp = m.new(N, vtype='bool', lb=0, ub=1)
xi_sdp0 = m.new(M0, vtype='bool', lb=0)
xi_sdp1 = m.new(M1, vtype='bool', lb=0)
else:
x_sdp = m.new(N, vtype='real', lb=0, ub=1)
xi_sdp0 = m.new(M0, vtype='real', lb=0)
xi_sdp1 = m.new(M1, vtype='real', lb=0)
m.constrain(A1 * x_sdp + xi_sdp1 >= 1)
m.constrain(A0 * x_sdp == 0 + xi_sdp0)
value = m.minimize(x_sdp.sum() + lambda_reg *
(xi_sdp0.sum() + xi_sdp1.sum()))
#m.minimize(w_pert_x*x_sdp + lambda_reg*w_pert_xi*xi_sdp)
x_hat = m[x_sdp]
xi_hat0 = m[xi_sdp0]
xi_hat1 = m[xi_sdp1]
xi_hat = np.zeros(M)
xi_hat[inds_0] = xi_hat0
xi_hat[inds_1] = xi_hat1
return x_hat, xi_hat
def lpDualCPLEX(mdp,
zeroConstraints=(),
positiveConstraints=(),
positiveConstraintsOcc=1):
"""
DEPRECATED since we moved to gurobi. but leave the function here for sanity check
Solve the dual problem of lp, maybe with some constraints
Same arguments
Note that this is a lower level function that does not consider feature extraction.
r should be a reward function, not a reward parameter.
"""
S = mdp.S
A = mdp.A
T = mdp.T
r = mdp.r
gamma = mdp.gamma
alpha = mdp.alpha
m = CPlexModel()
if not config.VERBOSE: m.setVerbosity(0)
# useful constants
Sr = range(len(S))
Ar = range(len(A))
x = m.new((len(S), len(A)), lb=0, name='x')
# make sure x is a valid occupancy
for sp in Sr:
# x (x(s) - \gamma * T) = \sigma
m.constrain(
sum(x[s, a] * ((s == sp) - gamma * T(S[s], A[a], S[sp]))
for s in Sr for a in Ar) == alpha(S[sp]))
# == constraints
if len(zeroConstraints) > 0:
m.constrain(
sum(x[S.index(s), A.index(a)] for s, a in zeroConstraints) == 0)
# >= constraints
if len(positiveConstraints) > 0:
m.constrain(
sum(x[S.index(s), A.index(a)]
for s, a in positiveConstraints) >= positiveConstraintsOcc)
# obj
try:
obj = m.maximize(sum([x[s, a] * r(S[s], A[a]) for s in Sr
for a in Ar]))
except CPlexException as err:
print 'Exception', err
# we return obj value as None and occ measure as {}. this should be handled correctly
return {'feasible': False}
return {
'feasible': True,
'obj': obj,
'pi': {(S[s], A[a]): m[x][s, a]
for s in Sr for a in Ar}
}
def decomposePiLP(S, A, T, s0, terminal, rawX, x, gamma=1):
"""
DEPRECATED.
This tries to decouple a policy into the optimal policy (following no constraints) and another policy \pi'.
\pi' may be a dominating policy.
Described in Eq. 2 on Aug.29, 2017.
"""
m = CPlexModel()
if not config.VERBOSE: m.setVerbosity(0)
# useful constants
Sr = range(len(S))
Ar = range(len(A))
y = m.new((len(S), len(A)), lb=0, name='y')
sigma = m.new(lb=0, ub=1, name='sigma')
for s in Sr:
for a in Ar:
# note that x and rawX use S x A as domains
m.constrain(sigma * rawX[S[s], A[a]] + y[s, a] == x[S[s], A[a]])
# make sure y is a valid occupancy
for sp in Sr:
# x (x(s) - \gamma * T) = \sigma
# and make sure there is no flow back from the terminal states
if not terminal(S[sp]):
m.constrain(sum(y[s, a] * ((s == sp) - gamma * T(S[s], A[a], S[sp]) * (not terminal(S[s]))) for s in Sr for a in Ar) == (1 - sigma) * (S[sp] == s0))
else:
m.constrain(sum(y[s, a] * ((s == sp) - gamma * T(S[s], A[a], S[sp]) * (not terminal(S[sp]))) for s in Sr for a in Ar) == (1 - sigma) * (S[sp] == s0))
obj = m.maximize(sigma)
# return sigma and the value of y
return obj, {(S[s], A[a]): m[y][s, a] for s in Sr for a in Ar}
def decomposePiLP(S, A, T, s0, terminal, rawX, x, gamma=1):
"""
This tries to decouple a policy into the optimal policy (following no constraints) and another policy \pi'.
\pi' may be a dominating policy.
Described in Eq. 2 on Aug.29, 2017.
"""
m = CPlexModel()
if not config.VERBOSE: m.setVerbosity(0)
# useful constants
Sr = range(len(S))
Ar = range(len(A))
y = m.new((len(S), len(A)), lb=0, name='y')
sigma = m.new(lb=0, ub=1, name='sigma')
for s in Sr:
for a in Ar:
# note that x and rawX use S x A as domains
m.constrain(sigma * rawX[S[s], A[a]] + y[s, a] == x[S[s], A[a]])
# make sure y is a valid occupancy
for sp in Sr:
# x (x(s) - \gamma * T) = \sigma
# and make sure there is no flow back from the terminal states
if not terminal(S[sp]):
m.constrain(sum(y[s, a] * ((s == sp) - gamma * T(S[s], A[a], S[sp]) * (not terminal(S[s]))) for s in Sr for a in Ar) == (1 - sigma) * (S[sp] == s0))
else:
m.constrain(sum(y[s, a] * ((s == sp) - gamma * T(S[s], A[a], S[sp]) * (not terminal(S[sp]))) for s in Sr for a in Ar) == (1 - sigma) * (S[sp] == s0))
obj = m.maximize(sigma)
# return sigma and the value of y
return obj, {(S[s], A[a]): m[y][s, a] for s in Sr for a in Ar}
def lpDualCPLEX(mdp, zeroConstraints=[], positiveConstraints=[], positiveConstraintsOcc=1):
"""
Solve the dual problem of lp, maybe with some constraints
Same arguments
Note that this is a lower level function that does not consider feature extraction.
r should be a reward function, not a reward parameter.
"""
S = mdp.S
A = mdp.A
T = mdp.T
r = mdp.r
gamma = mdp.gamma
alpha = mdp.alpha
m = CPlexModel()
if not config.VERBOSE: m.setVerbosity(0)
# useful constants
Sr = range(len(S))
Ar = range(len(A))
x = m.new((len(S), len(A)), lb=0, name='x')
# make sure x is a valid occupancy
for sp in Sr:
# x (x(s) - \gamma * T) = \sigma
m.constrain(sum(x[s, a] * ((s == sp) - gamma * T(S[s], A[a], S[sp])) for s in Sr for a in Ar) == alpha(S[sp]))
# == constraints
if len(zeroConstraints) > 0:
m.constrain(sum(x[S.index(s), A.index(a)] for s, a in zeroConstraints) == 0)
# >= constraints
if len(positiveConstraints) > 0:
m.constrain(sum(x[S.index(s), A.index(a)] for s, a in positiveConstraints) >= positiveConstraintsOcc)
# obj
try:
obj = m.maximize(sum([x[s, a] * r(S[s], A[a]) for s in Sr for a in Ar]))
except CPlexException as err:
print 'Exception', err
# we return obj value as None and occ measure as {}. this should be handled correctly
return {'feasible': False}
return {'feasible': True, 'obj': obj, 'pi': {(S[s], A[a]): m[x][s, a] for s in Sr for a in Ar}}
def create_problem(self, data):
host_attacked = data["attacked"]
host_executing = data["executing"]
metrics_used = data["metric"]
damage_used = data["damage"]
responses_used = data["response"]
numResp = len(responses_used)
damageMapper = {}
costMapper = {}
conflictMapper = []
responseList = []
for response in responses_used:
responseList.append(response.name)
logging.info('Responses Used: %s', numResp)
if damage_used is not None:
for elem in damage_used:
damageMapper[elem.name] = elem.value
for elem in metrics_used:
costMapper[elem.name] = []
costs = []
for response in responses_used:
cost = 0
for r in response.metrics:
cost = cost + r.value
costMapper[r.name].append(cost)
costs.append(cost)
if response.conflicting_responses:
for r in response.conflicting_responses:
tmp = [0] * numResp
tmp[responseList.index(response.name)] = 1
tmp[responseList.index(r)] = 1
conflictMapper.append(tmp)
costs = np.array(costs)
hostMatrix = []
for host in host_attacked:
hostRow = []
host = host.name
for response in responses_used:
if host in response.dest:
hostRow.append(1)
else:
hostRow.append(0)
hostMatrix.append(hostRow)
m = CPlexModel(verbosity=0)
# Each Response can only be executed once
x = m.new(numResp, vtype='bool', name='x')
i = 0
# all attacked hosts are freed
for elem in hostMatrix:
elemArr = np.array(elem)
m.constrain(sum(x.mult(elemArr)) >= 1)
i = i + 1
logging.info('Freed Constraints: %s', i)
i = 0
# all single metrics used have to be below damage
for key, elem in damageMapper.iteritems():
elemArr = np.array(costMapper[key])
m.constrain(sum(x.mult(elemArr)) <= elem)
i = i + 1
logging.info('Damage Constraints: %s', i)
i = 0
# no conflicting actions are executed
for elem in conflictMapper:
elemArr = np.array(elem)
m.constrain(sum(x.mult(elemArr)) <= 1)
i = i + 1
logging.info('Conflicting Constraints: %s', i)
return [m, x, costs]
startAssign[19,33] = 1
startAssign[31,34] = 1
startAssign[36,34] = 1
startAssign[2,35] = 1
startAssign[24,35] = 1
startAssign[25,36] = 1
startAssign[35,36] = 1
startAssign[22,37] = 1
startAssign[14,38] = 1
startAssign[8,39] = 1
startAssign[16,39] = 1
for b in range(numBins):
totalSize = sum([assign[i,b] * sizeItems[i] for i in range(numItems)])
m.constrain(totalSize <= sizeBin)
upperBound = sum(sizeItems)
m.constrain(totalSize <= binUsed[b] * upperBound)
m.constrain(binUsed[b] <= totalSize)
pass
# each item assigned to exactly one bin
for i in range(numItems):
numBinsForItem = sum([assign[i,b] for b in range(numBins)])
m.constrain(numBinsForItem == 1)
pass
numBinsUsed = sum(binUsed)
try:
m.minimize(numBinsUsed, starting_dict={assign:startAssign}, emphasis=1,\
def create_problem(self, data):
host_attacked = data["attacked"]
host_executing = data["executing"]
metrics_used = data["metric"]
damage_used = data["damage"]
responses_used = data["response"]
numResp = len(responses_used)
damageMapper = {}
costMapper = {}
conflictMapper = []
responseList = []
for response in responses_used:
responseList.append(response.name)
logging.info('Responses Used: %s', numResp)
if damage_used is not None:
for elem in damage_used:
damageMapper[elem.name] = elem.value
for elem in metrics_used:
costMapper[elem.name] = []
costs = []
for response in responses_used:
cost = 0
for r in response.metrics:
cost = cost + r.value
costMapper[r.name].append(cost)
costs.append(cost)
if response.conflicting_responses:
for r in response.conflicting_responses:
tmp = [0] * numResp
tmp[responseList.index(response.name)] = 1
tmp[responseList.index(r)] = 1
conflictMapper.append(tmp)
costs = np.array(costs)
hostMatrix = []
for host in host_attacked:
hostRow = []
host = host.name
for response in responses_used:
if host in response.dest:
hostRow.append(1)
else:
hostRow.append(0)
hostMatrix.append(hostRow)
m = CPlexModel(verbosity = 0)
# Each Response can only be executed once
x = m.new(numResp,vtype='bool', name='x')
i = 0
# all attacked hosts are freed
for elem in hostMatrix:
elemArr = np.array(elem)
m.constrain(sum(x.mult(elemArr)) >= 1)
i = i + 1
logging.info('Freed Constraints: %s', i)
i = 0
# all single metrics used have to be below damage
for key, elem in damageMapper.iteritems():
elemArr = np.array(costMapper[key])
m.constrain(sum(x.mult(elemArr)) <= elem)
i = i + 1
logging.info('Damage Constraints: %s', i)
i = 0
# no conflicting actions are executed
for elem in conflictMapper:
elemArr = np.array(elem)
m.constrain(sum(x.mult(elemArr)) <= 1)
i = i + 1
logging.info('Conflicting Constraints: %s', i)
return [m, x, costs]