def test_get_policy_negative_kappa_w_kappa_horizon(some_vars_fixture):
kappa_w, kappa, horizon = some_vars_fixture
num_buffers = 4
num_activities = 5
num_resources = 5
num_wl_vec = 4
constituency_matrix = np.eye(num_resources)
list_boundary_constraint_matrices = [
np.array([[1, 0]]), np.array([[0, 1]])
]
ind_surplus_buffers = None
cost_per_buffer = np.zeros((num_buffers, 1))
demand_rate = np.zeros((num_buffers, 1))
buffer_processing_matrix = np.zeros((num_buffers, num_activities))
workload_mat = np.zeros((num_wl_vec, num_buffers))
nu = np.zeros(num_resources)
boolean_action_flag = False,
convex_solver = 'cvx.CPLEX',
policy_params = BigStepPenaltyPolicyParams(convex_solver,
boolean_action_flag, kappa_w,
kappa)
with pytest.raises(AssertionError):
_ = BigStepPolicy(cost_per_buffer, constituency_matrix, demand_rate,
buffer_processing_matrix, workload_mat, nu,
list_boundary_constraint_matrices,
ind_surplus_buffers, policy_params)
def test_get_policy_examples_two_alternative_methods_multiple_horizons(
ex_env, horizon):
seed = 42
np.random.seed(seed)
env = eval('examples.' + ex_env)(job_gen_seed=seed)
kappa_w = 1e2
kappa = 1e2
safety_stocks_vec = 2 * np.ones((env.num_resources, 1))
policy_params = BigStepPenaltyPolicyParams('cvx.CPLEX', False, kappa_w,
kappa)
load, workload_mat, nu = workload.compute_load_workload_matrix(env)
num_wl_vec = workload_mat.shape[0]
k_idling_set = np.random.randint(0, workload_mat.shape[0], 1)
draining_bottlenecks = set(np.random.randint(0, workload_mat.shape[0], 1))
state = 20 * np.ones((env.num_buffers, 1))
policy_cvx = BigStepPolicy(env.cost_per_buffer, env.constituency_matrix,
env.job_generator.demand_rate,
env.job_generator.buffer_processing_matrix,
workload_mat, nu,
env.list_boundary_constraint_matrices,
env.ind_surplus_buffers, policy_params)
kwargs = {
'safety_stocks_vec': safety_stocks_vec,
'k_idling_set': k_idling_set,
'draining_bottlenecks': draining_bottlenecks,
'horizon': horizon
}
z_star_cvx, opt_val_cvx = policy_cvx.get_policy(state, **kwargs)
allowed_activities = get_allowed_activities(policy_cvx, num_wl_vec,
k_idling_set)
z_star_scipy, opt_val_scipy = policy_utils.feedback_policy_nonidling_penalty_scipy(
state,
env.cost_per_buffer,
env.constituency_matrix,
env.job_generator.buffer_processing_matrix,
workload_mat,
safety_stocks_vec,
k_idling_set,
draining_bottlenecks,
kappa_w,
env.list_boundary_constraint_matrices,
allowed_activities,
method='revised simplex',
demand_rate=env.job_generator.demand_rate,
horizon=horizon)
# SciPy has safety stock constraints, while CVX has a safety stock penalty.
opt_val_cvx = (
env.cost_per_buffer.T @ env.job_generator.buffer_processing_matrix
@ z_star_cvx)[0]
opt_val_scipy = (
env.cost_per_buffer.T @ env.job_generator.buffer_processing_matrix
@ z_star_scipy[:, None])[0]
np.testing.assert_allclose(opt_val_cvx, opt_val_scipy, rtol=5e-2)
def get_penalty_policy_object_for_simple_link_constrained_model(
env, kappa_w, kappa):
_, workload_mat, nu = workload.compute_load_workload_matrix(env, 6)
policy_params = BigStepPenaltyPolicyParams('cvx.CPLEX', False, kappa_w,
kappa)
policy_obj = BigStepPolicy(env.cost_per_buffer, env.constituency_matrix,
env.job_generator.demand_rate,
env.job_generator.buffer_processing_matrix,
env.workload_mat, env.nu,
env.list_boundary_constraint_matrices,
env.ind_surplus_buffers, policy_params)
return policy_obj
def test_get_policy_non_empty_buffers():
"""
We have a serial line of two resources with one buffer each:
demand --> q_1 + resource_1 --> q_2 + resource_2 -->
We relax the nonidling constraint for first resource. Since the cost in the second resource is
much higher, the LP will make the first resource to idle.
"""
k_idling_set = np.array([0])
draining_bottlenecks = {}
kappa_w = 1e2 # Very high to force the influence of the constraint
kappa = 1e2
policy_params = BigStepPenaltyPolicyParams('cvx.CPLEX', False, kappa_w,
kappa)
state = np.array([[10], [10]])
c_1 = 1
c_2 = 100
mu_1 = 100
mu_2 = 1
alpha = 0.9
cost_per_buffer = np.array([[c_1], [c_2]])
demand_rate = np.array([[alpha], [0]])
buffer_processing_matrix = np.array([[-mu_1, 0], [mu_1, -mu_2]])
constituency_matrix = np.eye(2)
safety_stocks_vec = np.zeros((2, 1))
list_boundary_constraint_matrices = []
ind_surplus_buffers = None
workload_mat = np.array([[1 / mu_1, 0], [1 / mu_2, 1 / mu_2]])
nu = np.eye(2)
horizon = 100
policy = BigStepPolicy(cost_per_buffer, constituency_matrix, demand_rate,
buffer_processing_matrix, workload_mat, nu,
list_boundary_constraint_matrices,
ind_surplus_buffers, policy_params)
kwargs = {
'safety_stocks_vec': safety_stocks_vec,
'k_idling_set': k_idling_set,
'draining_bottlenecks': draining_bottlenecks,
'horizon': horizon
}
z_star, _ = policy.get_policy(state, **kwargs)
np.testing.assert_allclose(z_star,
np.array([[0], [1]]),
rtol=1e-2,
atol=1e-2)
def test_big_step_policy_k_idling_set_relax_2nd_resource():
"""
We have a serial line of two resources with one buffer each:
demand --> q_1 + resource_1 --> q_2 + resource_2 -->
We relax the nonidling constraint for second resource. So even when the cost in the second
resource is much higher than the first resource, the LP will make the first resource to work.
"""
k_idling_set = np.array([])
draining_bottlenecks = {1}
kappa_w = 1e4
kappa = 1e2
state = np.array([[10], [10]])
c_1 = 1
c_2 = 100
mu_1 = 100
mu_2 = 1
cost_per_buffer = np.array([[c_1], [c_2]])
constituency_matrix = np.eye(2)
list_boundary_constraint_matrices = [
np.array([[1, 0]]), np.array([[0, 1]])
]
ind_surplus_buffers = None
demand_rate = np.ones((2, 1))
buffer_processing_matrix = np.array([[-mu_1, 0], [mu_1, -mu_2]])
workload_mat = np.array([[1 / mu_1, 0], [1 / mu_2, 1 / mu_2]])
nu = np.eye(2)
safety_stocks_vec = np.zeros((2, 1))
horizon = 1
policy_params = BigStepPenaltyPolicyParams('cvx.CPLEX', False, kappa_w,
kappa)
policy = BigStepPolicy(cost_per_buffer, constituency_matrix, demand_rate,
buffer_processing_matrix, workload_mat, nu,
list_boundary_constraint_matrices,
ind_surplus_buffers, policy_params)
kwargs = {
'safety_stocks_vec': safety_stocks_vec,
'k_idling_set': k_idling_set,
'draining_bottlenecks': draining_bottlenecks,
'horizon': horizon
}
z_star_pen, _ = policy.get_policy(state, **kwargs)
with pytest.raises(AssertionError):
np.testing.assert_almost_equal(z_star_pen[0], 0)
np.testing.assert_almost_equal(z_star_pen[1], 1, decimal=5)
def test_cum_cost_computation_switching_curve_regime_homogenous_cost():
neg_log_discount_factor = - np.log(0.99999)
env = examples.simple_reentrant_line_model(alpha1=0.33, mu1=0.7, mu2=0.34, mu3=0.7,
cost_per_buffer=np.array([1, 1.001, 1])[:, None])
num_wl_vec = 2
load, workload_mat, nu = wl.compute_load_workload_matrix(env, num_wl_vec)
strategic_idling_params = StrategicIdlingParams()
workload_cov = np.array([[2, 0.5], [0.5, 3]])
kappa_w = np.sum(env.cost_per_buffer) * 10
kappa = 1e4
policy_params = BigStepPenaltyPolicyParams('cvx.CPLEX', False, kappa_w, kappa)
policy_object = BigStepPolicy(
env.cost_per_buffer, env.constituency_matrix, env.job_generator.demand_rate,
env.job_generator.buffer_processing_matrix, workload_mat, nu,
env.list_boundary_constraint_matrices, env.ind_surplus_buffers, policy_params)
si_object = StrategicIdlingForesight(workload_mat=workload_mat,
neg_log_discount_factor=neg_log_discount_factor,
load=load,
cost_per_buffer=env.cost_per_buffer,
model_type=env.model_type,
policy_object=policy_object,
strategic_idling_params=strategic_idling_params,
workload_cov=workload_cov)
init_state = np.array([0, 0, 10000])[:, np.newaxis]
init_w = workload_mat @ init_state
si_object._current_state = init_state
cw_vars = si_object._non_negative_workloads(init_w)
cw_vars = super(StrategicIdlingForesight, si_object)._handle_switching_curve_regime(init_w,
cw_vars)
gto_cost = si_object._roll_out_gto_fluid_policy(cw_vars)
std_hedging_cost = si_object._roll_out_hedgehog_fluid_policy(cw_vars)
np.testing.assert_allclose(std_hedging_cost/1e6,1214,rtol=0.03)
np.testing.assert_allclose(gto_cost/1e6,950,rtol=0.03)
si_object.get_allowed_idling_directions(init_state)
assert si_object._current_regime == "gto"
assert si_object._original_target_dyn_bot_set == set([0,1])
def test_assertion_large_horizon_with_boolean_action_constraints():
horizon = 2
boolean_action_flag = True
policy_params = BigStepPenaltyPolicyParams('cvx.CPLEX',
boolean_action_flag, 1e2, 1e2)
policy = BigStepPolicy(
np.ones(
(2, 1)), np.eye(2), np.ones((2, 1)), -1.1 * np.eye(2), np.eye(2),
np.eye(2), [np.array([[1, 0]]), np.array([[0, 1]])], None,
policy_params)
kwargs = {
'safety_stocks_vec': np.zeros((2, 1)),
'k_idling_set': np.array([]),
'draining_bottlenecks': {},
'horizon': horizon
}
with pytest.raises(AssertionError):
policy.get_policy(np.zeros((2, 1)), **kwargs)
def test_big_step_policy_safety_stock_active():
"""
Resource is below safety stock threshold. Nonidling penalty is zero. Minimum cost is achieved by
draining buffer 3. However, resource 1 will drain buffer 1, so buffer 2 reaches its safety stock
level.
"""
state = np.array([0, 0, 100])[:, None]
alpha1 = 8
mu1 = 20
mu2 = 10
mu3 = 20
safety_stocks_vec = 8 * np.ones((2, 1))
horizon = 22
cost_per_buffer = np.array([[1.5], [1], [2]])
z_star_true = np.array([0.4, 0, 0.6])[:, None]
env = examples.simple_reentrant_line_model(alpha1, mu1, mu2, mu3,
cost_per_buffer)
load, workload_mat, nu = workload.compute_load_workload_matrix(env)
kappa_w = 0
kappa = 1e2
k_idling_set = np.array([])
draining_bottlenecks = {}
boolean_action_flag = False
policy_params = BigStepPenaltyPolicyParams('cvx.CPLEX',
boolean_action_flag, kappa_w,
kappa)
policy_cvx = BigStepPolicy(env.cost_per_buffer, env.constituency_matrix,
env.job_generator.demand_rate,
env.job_generator.buffer_processing_matrix,
workload_mat, nu,
env.list_boundary_constraint_matrices,
env.ind_surplus_buffers, policy_params)
kwargs = {
'safety_stocks_vec': safety_stocks_vec,
'k_idling_set': k_idling_set,
'draining_bottlenecks': draining_bottlenecks,
'horizon': horizon
}
z_star, _ = policy_cvx.get_policy(state, **kwargs)
np.testing.assert_allclose(z_star, z_star_true, rtol=1e-4)
def perform_boolean_constraints_simple_reentrant_line_test(state, z_star_true):
"""
Set parameters such that the objective is:
f(zeta) = -0.5 * mu1 * zeta_1 + 1 * mu2 * zeta_2 - 2 * mu3 * zeta_3.
State dynamics constraint is:
x_1 - mu1 * zeta_1 >= 0
x_2 + mu1 * zeta_1 - mu2 * zeta_2 >= 0
x_3 + mu2 * zeta_2 - mu3 * zeta_3 >= 0.
LP prioritises working on buffer 3 as much as possible. The only motivation to work on
buffers 1 and 2 is just to satisfy the state dynamics constraint.
"""
horizon = 1
boolean_action_flag = True
cost_per_buffer = np.array([[1.5], [1], [2]])
env = examples.simple_reentrant_line_model(cost_per_buffer=cost_per_buffer)
load, workload_mat, nu = workload.compute_load_workload_matrix(env)
safety_stocks_vec = np.zeros((env.num_resources, 1))
kappa_w = 0
kappa = 0
k_idling_set = np.array([])
draining_bottlenecks = {}
policy_params = BigStepPenaltyPolicyParams("cvx.CPLEX",
boolean_action_flag, kappa_w,
kappa)
policy_cvx = BigStepPolicy(env.cost_per_buffer, env.constituency_matrix,
env.job_generator.demand_rate,
env.job_generator.buffer_processing_matrix,
workload_mat, nu,
env.list_boundary_constraint_matrices,
env.ind_surplus_buffers, policy_params)
kwargs = {
'safety_stocks_vec': safety_stocks_vec,
'k_idling_set': k_idling_set,
'draining_bottlenecks': draining_bottlenecks,
'horizon': horizon
}
z_star, _ = policy_cvx.get_policy(state, **kwargs)
assert snc_tools.is_approx_binary(z_star)
np.testing.assert_almost_equal(z_star, z_star_true)
def test_feedback_policy_nonidling_constraint_two_alternative_methods():
np.random.seed(42)
num_buffers = 4
num_activities = 5
num_wl_vec = 4
constituency_matrix = np.array([[1, 1, 0, 0, 0], [0, 0, 1, 1, 0],
[0, 0, 0, 1, 1]])
nu = np.array([[0.5, 0, 0.5], [0, 1, 0], [0, 0, 1], [0, 0.5, 0.5]])
list_boundary_constraint_matrices = [
np.array([[1, 0, 0, 1]]),
np.array([[0, 1, 1, 0]])
]
ind_surplus_buffers = None
kappa_w = 1e2
kappa = 1e2
policy_params = BigStepPenaltyPolicyParams('cvx.CPLEX', False, kappa_w,
kappa)
horizon = 100
k_idling_set = np.array(range(num_buffers))
draining_bottlenecks = {0}
num_problems = 100
i = 0 # Num of feasible problems
diff_opt_val = 0
diff_z_star = 0
num_resources = constituency_matrix.shape[0]
for _ in range(num_problems):
state = 10 * np.random.random_sample((num_buffers, 1))
cost_per_buffer = np.random.random_sample((num_buffers, 1)) + 0.1
safety_stocks_vec = 0 * np.random.random_sample((num_resources, 1))
buffer_processing_matrix = 20 * (np.random.random_sample(
(num_buffers, num_activities)) - 1)
workload_mat = 0.5 * np.random.random_sample((num_wl_vec, num_buffers))
demand_rate = np.random.random_sample((num_buffers, 1))
policy_cvx = BigStepPolicy(cost_per_buffer, constituency_matrix,
demand_rate, buffer_processing_matrix,
workload_mat, nu,
list_boundary_constraint_matrices,
ind_surplus_buffers, policy_params)
allowed_activities = get_allowed_activities(policy_cvx, num_wl_vec,
k_idling_set)
z_star_scipy, opt_val_scipy = \
policy_utils.feedback_policy_nonidling_constraint_scipy(
state, cost_per_buffer, constituency_matrix, buffer_processing_matrix, workload_mat,
safety_stocks_vec, k_idling_set, draining_bottlenecks,
list_boundary_constraint_matrices, allowed_activities, demand_rate, horizon)
z_star_cvx, opt_val_cvx = \
policy_utils.feedback_policy_nonidling_constraint_cvx(
state, cost_per_buffer, constituency_matrix, buffer_processing_matrix, workload_mat,
safety_stocks_vec, k_idling_set, draining_bottlenecks,
list_boundary_constraint_matrices, allowed_activities, demand_rate, horizon)
if z_star_scipy is not None and z_star_cvx is not None:
z_star_scipy = z_star_scipy[:, None]
diff_opt_val_i = np.abs(
(opt_val_cvx - opt_val_scipy) / opt_val_cvx)
diff_z_star_i = np.linalg.norm(z_star_cvx - z_star_scipy)
print(i, "diff opt val=", diff_opt_val_i)
diff_opt_val += diff_opt_val_i
diff_z_star += diff_z_star_i
i += 1
# np.testing.assert_allclose(z_star_scipy, z_star_cvx, rtol=1e-2)
# np.testing.assert_allclose(opt_val_scipy, opt_val_cvx, rtol=1e-2)
rel_diff_opt_val = diff_opt_val / i
rel_diff_z_star = diff_z_star / i
np.testing.assert_almost_equal(rel_diff_opt_val, 0, decimal=2)
np.testing.assert_almost_equal(rel_diff_z_star, 0, decimal=2)
print("======================================")
print("relative error opt_val=", rel_diff_opt_val)
print("absolute error z_star=", rel_diff_z_star, "\n")
print("Num feasible problems: ", i)
def test_get_policy_with_two_alternative_methods():
np.random.seed(42)
num_buffers = 4
num_activities = 5
num_wl_vec = 4
constituency_matrix = np.array([[1, 1, 0, 0, 0], [0, 0, 1, 1, 0],
[0, 0, 0, 1, 1]])
list_boundary_constraint_matrices = [
np.array([[1, 1, 0, 0]]),
np.array([[0, 1, 1, 0]]),
np.array([[0, 0, 1, 1]])
]
ind_surplus_buffers = None
num_resources = constituency_matrix.shape[0]
k_idling_set = np.array([0])
draining_bottlenecks = {1}
nu = np.array([[0.5, 0, 0.5], [0, 1, 0], [0, 0, 1], [0, 0.5, 0.5]])
kappa_w = 1e2
kappa = 1e2
policy_params = BigStepPenaltyPolicyParams('cvx.CPLEX', False, kappa_w,
kappa)
for _ in range(100):
state = 10 * np.random.random_sample((num_buffers, 1))
cost_per_buffer = np.random.random_sample((num_buffers, 1))
demand_rate = 10 * np.random.random_sample((num_buffers, 1))
safety_stocks_vec = 2 * np.random.random_sample((num_resources, 1))
buffer_processing_matrix = 20 * (np.random.random_sample(
(num_buffers, num_activities)) - .5)
workload_mat = np.random.random_sample((num_wl_vec, num_buffers))
horizon = 100
policy_cvx = BigStepPolicy(cost_per_buffer, constituency_matrix,
demand_rate, buffer_processing_matrix,
workload_mat, nu,
list_boundary_constraint_matrices,
ind_surplus_buffers, policy_params)
kwargs = {
'safety_stocks_vec': safety_stocks_vec,
'k_idling_set': k_idling_set,
'draining_bottlenecks': draining_bottlenecks,
'horizon': horizon
}
z_star_pen_cvx, opt_val_pen_cvx = policy_cvx.get_policy(
state, **kwargs)
allowed_activities = get_allowed_activities(policy_cvx, num_wl_vec,
k_idling_set)
z_star_pen_scipy, opt_val_pen_scipy = policy_utils.feedback_policy_nonidling_penalty_scipy(
state,
cost_per_buffer,
constituency_matrix,
buffer_processing_matrix,
workload_mat,
safety_stocks_vec,
k_idling_set,
draining_bottlenecks,
kappa_w,
list_boundary_constraint_matrices,
allowed_activities,
method='revised simplex',
demand_rate=demand_rate,
horizon=horizon)
cvx_cost = get_cost(cost_per_buffer, buffer_processing_matrix,
z_star_pen_cvx)
scipy_cost = get_cost(cost_per_buffer, buffer_processing_matrix,
z_star_pen_scipy)
np.testing.assert_almost_equal(np.squeeze(cvx_cost),
scipy_cost,
decimal=3)