def test_affine(self) -> None:
"""Test grad for affine atoms.
"""
expr = -self.a
self.a.value = 2
self.assertAlmostEqual(expr.grad[self.a], -1)
expr = 2 * self.a
self.a.value = 2
self.assertAlmostEqual(expr.grad[self.a], 2)
expr = self.a / 2
self.a.value = 2
self.assertAlmostEqual(expr.grad[self.a], 0.5)
expr = -(self.x)
self.x.value = [3, 4]
val = np.zeros((2, 2)) - np.diag([1, 1])
self.assertItemsAlmostEqual(expr.grad[self.x].toarray(), val)
expr = -(self.A)
self.A.value = [[1, 2], [3, 4]]
val = np.zeros((4, 4)) - np.diag([1, 1, 1, 1])
self.assertItemsAlmostEqual(expr.grad[self.A].toarray(), val)
expr = self.A[0, 1]
self.A.value = [[1, 2], [3, 4]]
val = np.zeros((4, 1))
val[2] = 1
self.assertItemsAlmostEqual(expr.grad[self.A].toarray(), val)
z = Variable(3)
expr = cp.hstack([self.x, z])
self.x.value = [1, 2]
z.value = [1, 2, 3]
val = np.zeros((2, 5))
val[:, 0:2] = np.eye(2)
self.assertItemsAlmostEqual(expr.grad[self.x].toarray(), val)
val = np.zeros((3, 5))
val[:, 2:] = np.eye(3)
self.assertItemsAlmostEqual(expr.grad[z].toarray(), val)
# cumsum
expr = cp.cumsum(self.x)
self.x.value = [1, 2]
val = np.ones((2, 2))
val[1, 0] = 0
self.assertItemsAlmostEqual(expr.grad[self.x].toarray(), val)
expr = cp.cumsum(self.x[:, None], axis=1)
self.x.value = [1, 2]
val = np.eye(2)
self.assertItemsAlmostEqual(expr.grad[self.x].toarray(), val)
def degree_sequence(self, n, matrix):
# for the variable matrix i'm trying to take the cumulative sum of a matrix that doesn't exist
degree_sequence = []
print(matrix)
for i in range(1, n):
print(i)
degree_sequence += [cvx.cumsum(matrix, i)]
return np.sort(degree_sequence) #sorted is important
def test_scalar_sum(self) -> None:
x = cp.Variable(pos=True)
problem = cp.Problem(cp.Minimize(cp.sum(1 / x)))
problem.solve(SOLVER, qcp=True)
self.assertAlmostEqual(problem.value, 0, places=3)
problem = cp.Problem(cp.Minimize(cp.cumsum(1 / x)))
problem.solve(SOLVER, qcp=True)
self.assertAlmostEqual(problem.value, 0, places=3)
def solve_min_cost(drivers, requests):
n_d = len(drivers)
n_r = len(requests)
if n_d <= 1 or n_r <= 1:
return None
dist = [[
haversine(d.pos, r.store_pos) + haversine(r.store_pos, r.pos)
for r in requests
] for d in drivers]
c = np.asarray(dist)
x = cvx.Variable((n_d, n_r), integer=True)
objective = cvx.Minimize(dot(c, x))
constraints = [
x <= 1, x >= 0,
cvx.cumsum(x) <= 1,
cvx.cumsum(x, axis=1) <= 1,
cvx.sum(x) == min(n_r, n_d)
]
p = cvx.Problem(objective, constraints)
p.solve(solver=cvx.ECOS_BB)
x_val = np.around(x.value).astype(int)
return x_val
def solve(Q, C, D):
q1 = cp.Variable(1)
c = cp.Variable(T)
q = cp.hstack([q1, cp.cumsum(c)[:-1]])
constraints = [
q <= Q,
q >= 0,
c <= C,
c >= -D,
q[-1] + c[-1] == q[0],
u + c >= 0,
]
obj = cp.Minimize(p @ (u + c))
problem = cp.Problem(obj, constraints)
problem.solve()
return q.value, c.value, problem.value
def simultaneous_planning_cvx(S,
A,
D,
t_max=2000,
delta=5,
file_suffix='',
save_dir=''):
# Setup problem parameters
# make p_tau uniform between 500 and 2000
p_tau = np.ones(t_max)
p_tau[:5] = 0
p_tau = p_tau / np.sum(p_tau)
n_dict_elem = D.shape[1]
# compute variance of dictionary elements.
stas_norm = np.expand_dims(np.sum(A**2, 0), 0) # 1 x # cells
var_dict = np.squeeze(np.dot(stas_norm, D * (1 - D))) # # dict
# Construct the problem.
y = cvxpy.Variable(n_dict_elem, t_max)
x = cvxpy.cumsum(y, 1)
S_expanded = np.repeat(np.expand_dims(S, 1), t_max, 1)
objective = cvxpy.Minimize((cvxpy.sum_entries(
(S_expanded - A * (D * x))**2, 0) + var_dict * x) * p_tau)
constraints = [
0 <= y,
cvxpy.sum_entries(y, 0).T <= delta * np.ones((1, t_max)).T
]
prob = cvxpy.Problem(objective, constraints)
# The optimal objective is returned by prob.solve().
result = prob.solve(verbose=True)
# The optimal value for x is stored in x.value.
print(x.value)
# The optimal Lagrange multiplier for a constraint
# is stored in constraint.dual_value.
print(constraints[0].dual_value)
def log_sum_exp_axis_1(x):
return cp.log_sum_exp(x, axis=1) # noqa E371
# Atom, solver pairs known to fail.
KNOWN_SOLVER_ERRORS = [
# See https://github.com/cvxgrp/cvxpy/issues/249
(log_sum_exp_axis_0, CVXOPT),
(log_sum_exp_axis_1, CVXOPT),
(cp.kl_div, CVXOPT),
]
atoms_minimize = [
(cp.abs, (2, 2), [[[-5, 2], [-3, 1]]], Constant([[5, 2], [3, 1]])),
(lambda x: cp.cumsum(x, axis=1), (2, 2), [[[-5, 2], [-3, 1]]],
Constant([[-5, 2], [-8, 3]])),
(lambda x: cp.cumsum(x, axis=0), (2, 2), [[[-5, 2], [-3, 1]]],
Constant([[-5, -3], [-3, -2]])),
(lambda x: cp.cummax(x, axis=1), (2, 2), [[[-5, 2], [-3, 1]]],
Constant([[-5, 2], [-3, 2]])),
(lambda x: cp.cummax(x, axis=0), (2, 2), [[[-5, 2], [-3, 1]]],
Constant([[-5, 2], [-3, 1]])),
(cp.diag, (2, ), [[[-5, 2], [-3, 1]]], Constant([-5, 1])),
(cp.diag, (2, 2), [[-5, 1]], Constant([[-5, 0], [0, 1]])),
(cp.exp, (2, 2), [[[1, 0], [2, -1]]],
Constant([[math.e, 1], [math.e**2, 1.0 / math.e]])),
(cp.huber, (2, 2), [[[0.5, -1.5], [4, 0]]], Constant([[0.25, 2], [7, 0]])),
(lambda x: cp.huber(x, 2.5), (2, 2), [[[0.5, -1.5], [4, 0]]],
Constant([[0.25, 2.25], [13.75, 0]])),
(cp.inv_pos, (2, 2), [[[1, 2], [3, 4]]],
from veh_speed_sched_data import n, a, b, c, d, smin, smax, tau_min, tau_max
#fixing data
d = np.asarray(d)
smin = np.asarray(smin)
smax = np.asarray(smax)
tau_min = np.asarray(tau_min)
tau_max = np.asarray(tau_max)
d = d[:, 0]
smin = smin[:, 0]
smax = smax[:, 0]
tau_min = tau_min[:, 0]
tau_max = tau_max[:, 0]
k = cp.Variable(n)
h = cp.cumsum(k)
phi = a * cp.multiply(cp.inv_pos(k), d**2) + c * k + cp.multiply(b, d)
obj = cp.Minimize(cp.sum(phi))
constraints = [
cp.multiply(smin, k) <= d,
cp.multiply(smax, k) >= d,
tau_min <= h,
tau_max >= h,
]
problem = cp.Problem(obj, constraints)
problem.solve()
print(f"status: {problem.status}")
if problem.status == 'optimal':
print(f"Total fuel: {problem.value}")
s = d / k.value
plt.step(np.arange(n), s)
def __total_variation_regularized_derivative__(x,
dt,
N,
gamma,
solver='MOSEK'):
"""
Use convex optimization (cvxpy) to solve for the Nth total variation regularized derivative.
Default solver is MOSEK: https://www.mosek.com/
:param x: (np.array of floats, 1xN) time series to differentiate
:param dt: (float) time step
:param N: (int) 1, 2, or 3, the Nth derivative to regularize
:param gamma: (float) regularization parameter
:param solver: (string) Solver to use. Solver options include: 'MOSEK' and 'CVXOPT',
in testing, 'MOSEK' was the most robust.
:return: x_hat : estimated (smoothed) x
dxdt_hat : estimated derivative of x
"""
# Normalize
mean = np.mean(x)
std = np.std(x)
x = (x - mean) / std
# Define the variables for the highest order derivative and the integration constants
var = cvxpy.Variable(len(x) + N)
# Recursively integrate the highest order derivative to get back to the position
derivatives = [var[N:]]
for i in range(N):
d = cvxpy.cumsum(derivatives[-1]) + var[i]
derivatives.append(d)
# Compare the recursively integration position to the noisy position
sum_squared_error = cvxpy.sum_squares(derivatives[-1] - x)
# Total variation regularization on the highest order derivative
r = cvxpy.sum(gamma * cvxpy.tv(derivatives[0]))
# Set up and solve the optimization problem
obj = cvxpy.Minimize(sum_squared_error + r)
prob = cvxpy.Problem(obj)
prob.solve(solver=solver)
# Recursively calculate the value of each derivative
final_derivative = var.value[N:]
derivative_values = [final_derivative]
for i in range(N):
d = np.cumsum(derivative_values[-1]) + var.value[i]
derivative_values.append(d)
for i, _ in enumerate(derivative_values):
derivative_values[i] = derivative_values[i] / (dt**(N - i))
# Extract the velocity and smoothed position
dxdt_hat = derivative_values[-2]
x_hat = derivative_values[-1]
dxdt_hat = (dxdt_hat[0:-1] + dxdt_hat[1:]) / 2
ddxdt_hat_f = dxdt_hat[-1] - dxdt_hat[-2]
dxdt_hat_f = dxdt_hat[-1] + ddxdt_hat_f
dxdt_hat = np.hstack((dxdt_hat, dxdt_hat_f))
# fix first point
d = dxdt_hat[2] - dxdt_hat[1]
dxdt_hat[0] = dxdt_hat[1] - d
return x_hat * std + mean, dxdt_hat * std
