def test_log1p(self) -> None:
"""Test domain for log1p.
"""
expr = cp.log1p(self.a)
self.a.value = 2
self.assertAlmostEqual(expr.grad[self.a], 1.0 / 3)
self.a.value = 3
self.assertAlmostEqual(expr.grad[self.a], 1.0 / 4)
self.a.value = -1
self.assertAlmostEqual(expr.grad[self.a], None)
expr = cp.log1p(self.x)
self.x.value = [3, 4]
val = np.zeros((2, 2)) + np.diag([1 / 4, 1 / 5])
self.assertItemsAlmostEqual(expr.grad[self.x].toarray(), val)
expr = cp.log1p(self.x)
self.x.value = [-1e-9 - 1, 4]
self.assertAlmostEqual(expr.grad[self.x], None)
expr = cp.log1p(self.A)
self.A.value = [[1, 2], [3, 4]]
val = np.zeros((4, 4)) + np.diag([1 / 2, 1 / 3, 1 / 4, 1 / 5])
self.assertItemsAlmostEqual(expr.grad[self.A].toarray(), val)
def test_log1p(self):
"""Test the log1p atom.
"""
expr = cp.log1p(1)
self.assertEqual(expr.sign, s.NONNEG)
self.assertEqual(expr.curvature, s.CONSTANT)
self.assertEqual(expr.shape, tuple())
expr = cp.log1p(-0.5)
self.assertEqual(expr.sign, s.NONPOS)
def cvx_power_alloc_unequal_power(W, Pa, nt, nc, nac):
#Pc = Pa*np.ones((nt,1)) ## per-antenna power constraint
d = cvx.Variable(nc * nac)
objective = cvx.Maximize(cvx.sum_entries(cvx.log1p(d) / np.log(2)))
constraints = [cvx.sum_entries(W @ d) <= Pa, d >= 0, d <= 10**3.6]
prob = cvx.Problem(objective, constraints)
prob.solve(max_iters=50000)
return np.asarray(np.abs(d.value)).flatten()
def cvx_power_alloc_unequal_power(W, Pa, nt, nc, nac):
Pc = Pa*np.ones((nt,1))
d = cvx.Variable(nc*nac)
objective = cvx.Maximize(cvx.sum_entries(cvx.log1p(d)/np.log(2)))
constraints = [W @ d <= Pc, d >= 0]
prob = cvx.Problem(objective, constraints)
prob.solve(solver='SCS')
print('Problem status: {}'.format(prob.status))
return np.asarray(np.abs(d.value)).flatten()
def cvx_power_alloc_equal_power(W, Pa, nt, nc, nac):
#Pc = Pa*np.ones((nt, 1)) ## per-antenna power constraint
Q = np.kron(np.eye(nc), np.ones((nac, 1)))
d = cvx.Variable(nc)
objective = cvx.Maximize(cvx.sum_entries(cvx.log1p(d) / np.log(2)))
if nc > 1:
constraints = [cvx.sum_entries(W @ Q @ d) <= Pa, d >= 0, d <= 10**3.6]
if nc == 1:
constraints = [cvx.sum_entries(W @ Q) * d <= Pa, d >= 0, d <= 10**3.6]
prob = cvx.Problem(objective, constraints)
prob.solve(max_iters=50000)
return np.asarray(np.abs(d.value)).flatten(), prob.status
def cvx_power_alloc_equal_power(W, Pa, nt, nc, nac):
Pc = Pa*np.ones((nt, 1))
Q = np.kron(np.eye(nc), np.ones((nac, 1)))
d = cvx.Variable(nc)
objective = cvx.Maximize(cvx.sum_entries(cvx.log1p(d)/np.log(2)))
## Constraining SNR to be between min required for MCS = 0 ( = 3.9 dB) and for MCS = 12 ( = 36 dB)
constraints = [W @ Q @ d <= Pc, d >= 0, d <= 10**3.6]
prob = cvx.Problem(objective, constraints)
# prob.solve(solver='SCS')
prob.solve(max_iters=50000)
# print('Problem status: {}'.format(prob.status))
return np.asarray(np.abs(d.value)).flatten(), prob.status
def apply(self, network_configuration, firedex_configuration,
publishers_configuration, network_flows):
bandwidth = network_configuration.bandwidth()
rho_tolerance = firedex_configuration.rho_tolerance()
publication_collection = publishers_configuration.publication_collection(
)
# variable
n = network_flows.__len__()
# ---
# problem to solve
alpha = [x.adjusted_utility_function() for x in network_flows]
success_rate = cvxpy.Variable(n, name="success_rates")
objective = cvxpy.Maximize(
cvxpy.sum(cvxpy.multiply(alpha, cvxpy.log1p(success_rate))))
# ---
# constraint
network_flows_load = []
for network_flow in network_flows:
subscriptions = network_flow.subscriptions()
current_load = 0
for subscription in subscriptions:
topic = subscription.topic()
current_load += publication_collection.publications_load_by_topic(
topic=topic)
network_flows_load.append(current_load)
a = network_flows_load * success_rate
network_load = cvxpy.sum(
cvxpy.multiply(network_flows_load, success_rate))
constraints = [
network_load <= bandwidth * (1 - rho_tolerance), success_rate >= 0,
success_rate <= 1
]
# ---
# solution
prob = cvxpy.Problem(objective, constraints)
prob.solve()
solution = success_rate.value
solution = [round(x, 2) for x in solution]
# ---
for network_flow, success_rate in zip(network_flows, solution):
drop_rate = 1 - success_rate
network_flow.set_drop_rate(drop_rate=drop_rate)
def solve_log(hist, v, wmax):
wrs = list(hist.keys())
z = np.array([[w - 1.0, w * r - v] for w, r in wrs])
c = np.array([hist[wr] for wr in wrs])
c = c / np.sum(c)
lam = cp.Variable(2)
constraints = [
lam.T @ np.array([w - 1.0, w * r - vv]) >= -0.5 for w in (0, wmax)
for r in (0, 1) for vv in (0, 1)
]
objective = c.T @ cp.log1p(z @ lam)
p = cp.Problem(cp.Maximize(objective), constraints)
p.solve()
return lam.value
def optim_with_cvxpy2(rtns,levs,mns,mcovs,headers,labels,worst,log_tdiscount,row_weight,ob):
barrier=worst+1
merit=pd.DataFrame(index=headers,columns=labels)
nrows,ncols=rtns.shape
nlevs=len(levs)
alloc=np.ones((nlevs,ncols),dtype='float64')
prtns=np.zeros((nlevs,nrows),dtype='float64')
xx=cp.Variable(ncols)
for i in range(nlevs):
lev=levs[i]
levreturn=(rtns*lev)
print("Risk Aversion: ",lev)
if ob=='MV':
constraints =[sum(xx)==1, 0<=xx, xx<=1] #Long-only portfolios
objective=cp.Minimize(-cp.sum(cp.multiply(mns,xx)) + lev*cp.quad_form(xx,mcovs)/2.0)
prob=cp.Problem(objective,constraints)
result=prob.solve(eps_abs=1e-7,eps_rel=1e-7)
xxvalue=xx.value
prtns[i]=np.dot(rtns,xxvalue)
merit['M_objective'][headers[i]]= np.sum(mns*xxvalue) - levs[i]*np.dot(np.dot(xxvalue,mcovs),xxvalue.T)/2.0
merit['W_objective'][headers[i]]= np.sum(np.multiply(row_weight,(np.log1p(np.dot(levreturn,xxvalue.T))+log_tdiscount)))
elif ob=='LLS':
constraints =[sum(xx)==1, 0<=xx, xx<=1, -1.0+barrier <= levreturn @ xx ] #Long-only portfolios
objective=cp.Maximize(cp.sum(cp.multiply(row_weight,cp.log1p(levreturn @ xx)+log_tdiscount)))
prob=cp.Problem(objective,constraints)
result=prob.solve(abstol=1e-7,reltol=1e-7,verbose=False)/nrows
xxvalue=xx.value
if xxvalue is None:
print('WARNING!!!! cvxpy problem appears not feasible.')
raise
prtns[i]=np.dot(rtns,xxvalue)
merit['M_objective'][headers[i]]= sum(mns*xxvalue) - levs[i]*np.dot(np.dot(xxvalue,mcovs),xxvalue.T)/2.0
merit['W_objective'][headers[i]]= np.sum(np.multiply(row_weight,(np.log1p(np.dot(levreturn,xxvalue.T))+log_tdiscount)))
alloc[i]=xxvalue
merit['norm2'][headers[i]] = np.dot(xxvalue,xxvalue)
return (prtns[::].T,alloc[::],pd.DataFrame.copy(merit,deep=True))
def __achieved_utility(network_flow):
success_rate = 1 - network_flow.get_drop_rate()
achieved_utility = float(network_flow.adjusted_utility_function()) * float(
cvxpy.log1p(success_rate).value)
return achieved_utility
def test_log1p(self) -> None:
"""Test domain for log1p.
"""
dom = cp.log1p(self.a).domain
Problem(Minimize(self.a), dom).solve(solver=cp.SCS, eps=1e-6)
self.assertAlmostEqual(self.a.value, -1)
def get_costs(dataset, pi):
if pi.size(
-1
) == 1: # In case all tours directly return to depot, prevent further problems
assert (
pi == 0).all(), "If all length 1 tours, they should be zero"
# Return
return torch.zeros(pi.size(0), dtype=torch.float,
device=pi.device), None
# Check that tours are valid, i.e. contain 0 to n -1
sorted_pi = pi.data.sort(1)[0]
# Make sure each node visited once at most (except for depot)
assert ((sorted_pi[:, 1:] == 0) |
(sorted_pi[:, 1:] > sorted_pi[:, :-1])).all(), "Duplicates"
chGain = dataset['chGain'].cpu().numpy() #(batch_size, n_loc)
minRateReq = dataset['minRateReq'].cpu().numpy(
) #(batch_size, n_users)
sharedFlag = dataset['sharedFlag'].cpu().numpy() #(batch_size, n_RBs)
numerology = dataset['numerology'].cpu().numpy() #(batch_size)
availRBNum = dataset['availRBNum'].cpu().numpy() #(batch_size)
availPower = dataset['availPower'].cpu().numpy() #(batch_size)
batch_size, n_loc = chGain.shape
_, n_users = minRateReq.shape
_, n_RBs = sharedFlag.shape
ids = torch.arange(pi.size(1), dtype=torch.int64)
penaltyFactor = 1000.
scaleFactor = 1000.
penalizedAggregateThroughput = torch.zeros(batch_size,
dtype=torch.float,
device=pi.device)
for i in range(pi.size(0)):
selected = pi[i, :]
ids_withoutDepot = ids[selected >= 1]
selectedUsers = ((selected[ids_withoutDepot] - 1) //
n_RBs).cpu().numpy() # -1 because of depot
selectedRBs = ((selected[ids_withoutDepot] - 1) %
n_RBs).cpu().numpy() # -1 because of depot
U = n_users
K = availRBNum[i]
if K == 0:
penalizedAggregateThroughput[i] = 0.
continue
alpha_val = np.zeros((U, K), dtype=int)
alpha_val[selectedUsers, selectedRBs] = 1
P = cp.Variable(shape=(U, K))
Delta = cp.Variable(shape=U)
g_val = chGain[i, :]
gain = g_val[g_val != 0].reshape((U, K))
b_embb = ML.PRB_BW[numerology[i]] / scaleFactor
# This function will be used as the objective so must be DCP;
# i.e. elementwise multiplication must occur inside kl_div,
# not outside otherwise the solver does not know if it is DCP...
R = cp.multiply((b_embb / np.log(2)),
cp.multiply(alpha_val,
cp.log1p(cp.multiply(P, gain))))
objective = cp.Minimize(
-cp.sum(R) +
cp.multiply(penaltyFactor, cp.sum(cp.power(Delta, 2))))
constraints = [
cp.sum(cp.multiply(alpha_val, P)) <= availPower[i],
(Delta + cp.sum(R, axis=1)) >=
(minRateReq[i, :] / scaleFactor), P >= 0.0, Delta >= 0.0
]
prob = cp.Problem(objective, constraints)
prob.solve(solver=cp.MOSEK)
penalizedAggregateThroughput[i] = prob.value
return (penalizedAggregateThroughput), None
along with CVXPY. If not, see <http://www.gnu.org/licenses/>.
"""
import cvxpy as cvx
import numpy.random as r
import numpy as np
from cvxpy.reductions.dcp2cone.dcp2cone import Dcp2Cone
n = 5
x = cvx.Variable(n)
y = cvx.Variable()
A = r.rand(n, n)
b = r.rand(n, 1)
l = np.random.randn(5, 4)
c = [cvx.abs(A * x + b) <= 2, cvx.abs(y) + x[0] <= 1, cvx.log1p(x) >= 5]
c.append(cvx.log_sum_exp(l, axis=0) <= 10)
X = cvx.Variable((5, 5))
c.append(cvx.log_det(X) >= 10)
cvx.Minimize(x[0])
prob = cvx.Problem(cvx.Minimize(x[0] + x[1] + y), c)
d2c = Dcp2Cone()
d2c.accepts(prob)
new_prob = d2c.apply(prob)
print(prob)
print('\n\n')
print(new_prob)
prob.solve()
def test_log1p(self):
"""Test domain for log1p.
"""
dom = cp.log1p(self.a).domain
Problem(Minimize(self.a), dom).solve()
self.assertAlmostEqual(self.a.value, -1)
