HT_extensive.solve(outputFlag=0, TimeLimit=time_limit)
print('lower bound', HT_extensive.objBound)
print('upper bound', HT_extensive.objVal)
print('total time', HT_extensive.total_time)
print('gap', HT_extensive.MIPGap)
if solver == 'SDDiP':
HydroThermal.binarize(bin_stage=T)
HT_sddp = SDDiP(HydroThermal)
HT_sddp.solve(
logFile=0,
logToConsole=0,
cuts=[cut],
n_processes=1,
n_steps=1,
max_iterations=n_iterations,
)
result = Evaluation(HydroThermal)
if T in [2, 3]:
result.run(random_state=666, n_simulations=-1)
else:
result.run(random_state=666, n_simulations=3000)
resultTrue = EvaluationTrue(HydroThermal)
resultTrue.run(random_state=666, n_simulations=3000)
print('lower bound', result.db)
if T in [2, 3]:
print('upper bound', result.epv)
else:
print('CI appr.', result.CI)
print('gap', result.gap)
print('CI true', resultTrue.CI)
AssetMgt.add_Markovian_uncertainty(g)
for t in range(T):
m = AssetMgt[t]
now, past = m.addStateVars(2, lb=0, obj=0)
if t == 0:
m.addConstr(now[0] + now[1] == 55)
if t in [1, 2]:
m.addConstr(past[0] + past[1] == now[0] + now[1],
uncertainty_dependent={
past[0]: 0,
past[1]: 1
})
if t == 3:
y = m.addVar(obj=1)
w = m.addVar(obj=-4)
m.addConstr(past[0] + past[1] - y + w == 80,
uncertainty_dependent={
past[0]: 0,
past[1]: 1
})
AssetMgt.discretize(
n_Markov_states=25,
n_sample_paths=10000,
)
# Extensive(AssetMgt).solve()
SDDP(AssetMgt).solve(max_iterations=400)
result = Evaluation(AssetMgt)
result.run(n_simulations=1000)
resultTrue = EvaluationTrue(AssetMgt)
resultTrue.run(n_simulations=1000)
fig_mca.text(0, 0.5, 'demand', va='center', rotation='vertical')
for j_idx, j in enumerate(J):
fig_mca = fan_plot(true[:, :, j_idx], ax=ax_mca[j_idx][0])
fig_mca = fan_plot(simulation[:, :, j_idx], ax=ax_mca[j_idx][1])
fig_mca.tight_layout()
fig_mca.savefig("./result/airline_MCA.png", dpi=1200)
fig_bound, ax_bound = plt.subplots(2, 1, figsize=(10, 5), sharey=True)
for cut_index, cut in enumerate(['B', 'SB']):
airline_sddp = SDDiP(airline)
airline_sddp.solve(cuts=[cut],
n_processes=1,
n_steps=1,
max_iterations=100)
result = Evaluation(airline)
result.run(random_state=666, n_simulations=3000)
resultTrue = EvaluationTrue(airline)
resultTrue.run(random_state=666, n_simulations=3000)
summary['model'].append(idx)
summary['cut'].append(cut)
summary['time'].append(airline_sddp.total_time)
summary['gap'].append(result.gap)
summary['bound'].append(result.db)
summary['CI_approx_lower'].append(result.CI[0])
summary['CI_approx_upper'].append(result.CI[1])
summary['CI_true_lower'].append(resultTrue.CI[0])
summary['CI_true_upper'].append(resultTrue.CI[1])
if idx == 2:
fig_bound = airline_sddp.plot_bounds(window=1,
smooth=1,
ax=ax_bound[cut_index])
if idx == 2:
import numpy
import gurobipy
numpy.random.seed(2)
T = 5
numSeats = 5
numScen = 5
offer = numpy.random.randint(numSeats, size=(T, numScen, numSeats))
price = [[3 + t for _ in range(20)] for t in range(T)]
selling = MSIP(T=T, sense=-1, bound=100)
for t in range(T):
m = selling.models[t]
now, past = m.addStateVars(numSeats, vtype='B', name="seatCondition")
if t == 0:
m.addConstrs(past[i] == 1 for i in range(numSeats))
else:
accept_offer = m.addVars(numSeats,
vtype='B',
obj=price[t],
name="acceptOffer")
m.addConstrs(
(accept_offer[i] <= 0 for i in range(numSeats)),
uncertainty=offer[t],
)
m.addConstrs(now[i] == past[i] - accept_offer[i]
for i in range(numSeats))
SDDiP(selling).solve(max_iterations=20, cuts=['LG'])
resultTrue = EvaluationTrue(selling)
resultTrue.run(n_simulations=100)
def evaluate_policy(self, n_simulations):
evaluate = [False]
# When evaluating the obtained policy from TS approach we sometimes get computational issues
if self.markov:
evaluate.append(True)
for true_distribution in evaluate: #[True,False]
if true_distribution:
result = EvaluationTrue(self.model_ip)
string = '_true'
else:
result = Evaluation(self.model_ip)
string = ''
result.run(n_simulations=n_simulations,
query_stage_cost=True,
query=self.data.dat['query'])
#I could add this to the dataframe
self.data.evaluation['db_eval' + string] = result.db
self.data.evaluation['CI_eval' + string] = result.CI
self.data.evaluation['gap_eval' + string] = result.gap
self.data.evaluation['pv2_eval' + string] = result.pv
self.data.evaluation['epv_eval' + string] = result.epv
decision_matrix = pd.DataFrame(index=list(range(n_simulations)),
columns=self.data.dat['T_STAGES'])
decision_matrix = decision_matrix.fillna('-')
for i in range(n_simulations):
for (t, a) in self.data.dat['x_act_combinations']:
if result.solution["x_act[{},{}]".format(t, a)].at[i,
t] == 1:
decision_matrix.at[i, t] = a
operating = True
for t in self.data.dat['T_STAGES']:
if result.solution['y_sd'].at[i, t] == 1 and operating:
decision_matrix.at[i, t] = 'y_sd'
operating = False
self.data.evaluation['decision_matrix' + string] = decision_matrix
self.data.evaluation['prices' + string] = result.solution['price']
if self.two_factor:
self.data.evaluation['eq_fact' +
string] = result.solution['eq_fact']
self.data.evaluation['dev_fact' +
string] = result.solution['dev_fact']
#######################
### DECISION MATRIX ###
#######################
if self.print_decision_matrix:
if self.markov:
decision_matrix = self.data.evaluation['decision_matrix_true']
prices = self.data.evaluation['prices_true']
else:
decision_matrix = self.data.evaluation['decision_matrix']
prices = self.data.evaluation['prices']
summary_decision_matrix = decision_matrix.groupby(
decision_matrix.columns.tolist(), as_index=False).size()
unique_solutions = decision_matrix.drop_duplicates()
unique_solutions = unique_solutions.reset_index(drop=True)
rows_to_instances = {i: []
for i in range(len(unique_solutions))
} #rows are the unique solutions
for index, row in decision_matrix.iterrows():
for index2, row2 in unique_solutions.iterrows():
if list(row) == list(row2):
rows_to_instances[index2].append(index)
unique_solutions['count'] = 0
rows_dec_mat = list(summary_decision_matrix.index)
for i in range(len(rows_dec_mat)):
for j in range(len(unique_solutions)):
if list(summary_decision_matrix.iloc[i, 0:6]) == list(
unique_solutions.iloc[j, 0:6]):
unique_solutions['count'][j] = summary_decision_matrix[
'size'][i]
ordering = {
'new_wells8': 0,
'new_wells4': 1,
'sidetrack2': 2,
'sidetrack1': 3,
'-': 4,
'y_sd': 5
}
unique_solutions['order'] = 0
for i in [5, 4, 3, 2, 1, 0]:
unique_solutions['order'] = [
ordering[j] for j in unique_solutions[i]
]
unique_solutions = unique_solutions.sort_values(by='order',
ascending=True)
order = list(unique_solutions.index)
def manual_sorting(col):
output = []
for i in col:
for j in range(len(order)):
if i == order[j]:
output.append(j)
return output
vars = ['prices']
statistics = [
i + '_' + j for i in vars for j in ['mean', 'min', 'max']
]
stat_df = {
s: pd.DataFrame(index=range(len(unique_solutions)))
for s in statistics
}
num_stages = len(decision_matrix.columns)
for t in range(num_stages): # initialize
for stat in statistics:
stat_df[stat][str(t)] = 0.0
for i in range(len(unique_solutions)):
subset = prices.iloc[rows_to_instances[i], :]
for t in range(num_stages):
var = 'prices'
stat_df[var + '_min'][str(t)][i] = subset.iloc[:, t].min()
stat_df[var + '_max'][str(t)][i] = subset.iloc[:, t].max()
stat_df[var + '_mean'][str(t)][i] = subset.iloc[:,
t].mean()
for stat in statistics:
print(stat)
stat_df[stat]['row_number'] = list(stat_df[stat].index)
print((stat_df[stat].sort_values(by='row_number',
key=manual_sorting)))
X_now, X_past = m.addStateVars(I, name='accumulated purchase')
if t == 0:
m.addConstrs(X_now[j] == 0 for j in range(J))
else:
# u_jt #
u = m.addVars(J, name='shortage', uncertainty=beta_generator)
# v_ijkt #
v = m.addVars(I, J, K, name='allocation')
# w_jt #
w = m.addVars(J, name='production')
# x_it #
x = m.addVars(I, name='purchase', uncertainty=alpha_generator)
## accumulated number of purchased tools updated ##
m.addConstrs(X_now[i] == X_past[i] + x[i] for i in range(I))
# time allocation constraint
m.addConstrs(
gurobipy.quicksum(
gurobipy.quicksum(a[i][j][k] * v[(i, j, k)] for k in range(K))
for j in range(J)) <= c[i] * X_now[i] for i in range(I))
# production allocation constraint
m.addConstrs(
gurobipy.quicksum(v[(i, j, k)] for i in range(I)) >= w[j]
for j in range(J) for k in range(K))
# demand constraint
m.addConstrs((w[j] + u[j] >= 0 for j in range(J)),
uncertainty=d_generator)
semiconductor.discretize(n_samples=20)
SDDP(semiconductor).solve(max_iterations=10)
result = EvaluationTrue(semiconductor)
result.run(n_simulations=1000)
m.addConstr(past[j] == capm[j], uncertainty_dependent={past[j]:j})
m.addConstr(past[j] == idio[j], uncertainty={past[j]:f(alpha[j],sigma[j])})
m.addConstr(now[N] == (1+rf) * past[N])
AssetMgt.discretize(
n_samples=100,
method='input',
Markov_states=Markov_states,
transition_matrix=transition_matrix,
random_state=888,
)
AssetMgt.set_AVaR(lambda_=lambda_, alpha_=0.25)
AssetMgt_SDDP = SDDP(AssetMgt)
AssetMgt_SDDP.solve(max_iterations=50, n_steps=3, n_processes=3)
evaluation = Evaluation(AssetMgt)
evaluation.run(n_simulations=1000, random_state=666)
evaluationTrue = EvaluationTrue(AssetMgt)
evaluationTrue.run(n_simulations=1000, random_state=666)
result = {
'mean':numpy.mean(evaluation.pv)-100,
'std':numpy.std(evaluation.pv),
'VAR': numpy.quantile(evaluation.pv,0.05)-100,
'skewness': stats.skew(evaluation.pv),
'kurtosis': 3+stats.kurtosis(evaluation.pv),
'Sharpe Ratio':
(numpy.mean(evaluation.pv)-100-0.005513771)/numpy.std(evaluation.pv)
}
evaluation_tab.append(pandas.Series(result))
resultTrue = {
'mean':numpy.mean(evaluationTrue.pv)-100,
'std':numpy.std(evaluationTrue.pv),
'VAR': numpy.quantile(evaluationTrue.pv,0.05)-100,
m.addConstr(chi_now[0] == x[0] + 2*x[1] + slack[0])
m.addConstr(chi_now[1] == x[1] + 2*x[0] + slack[1])
else:
y = m.addVars(2, obj=[4.4,3.0], vtype='I', name='y')
m.addConstr(
2*y[0] + 3*y[1] - chi_past[0] >= 0,
uncertainty={'rhs': [-2.8,-2]}
)
m.addConstr(
4*y[0] + 1*y[1] - chi_past[1] >= 0,
uncertainty = {'rhs': [-1.2, -3]}
)
print('extensive solver: ', Extensive(MIP).solve(outputFlag=0))
MIP.binarize(bin_stage=2, precision=precision)
SDDiP(MIP).solve(cuts=['LG'], max_iterations=128)
resultTrue = EvaluationTrue(MIP)
resultTrue.run(n_simulations=100)
resultTrue.CI
####################################verification##############################################
### extensive model ##
#from gurobipy import *
#m = Model()
#y = m.addVars(2, 2, vtype = GRB.INTEGER, obj = [2.2, 1.5, 2.2, 1.5])
#x = m.addVars(2, obj = [-2.5, -2.0], name = 'x', lb = - GRB.INFINITY)
#xi = m.addVars(2, name = 'xi', lb = [1.4, 1.4], ub = [6, 7.5])
#m.update()
#m.addConstr(4 * x[0] + 5 * x[1] <= 15)
#m.addConstr(x[0] + x[1] >= 1.5)
#m.addConstr(xi[0] == x[0] + 2 * x[1])
#m.addConstr(xi[1] == x[1] + 2 * x[0])
#m.addConstr(2 * y[(0,0)] + 3 * y[(0,1)] - xi[0] >= -2.8)