def test_persistent_basic(self):
options = self._copy_of_base_options()
options["PHIterLimit"] = 10
ph = mpisppy.opt.ph.PH(
options,
self.all3_scenario_names,
scenario_creator,
scenario_denouement,
scenario_creator_kwargs={"scenario_count": 3},
)
conv, basic_obj, tbound = ph.ph_main()
options = self._copy_of_base_options()
options["PHIterLimit"] = 10
options["solvername"] = persistentsolvername
ph = mpisppy.opt.ph.PH(
options,
self.all3_scenario_names,
scenario_creator,
scenario_denouement,
scenario_creator_kwargs={"scenario_count": 3},
)
conv, pobj, tbound = ph.ph_main()
sig2basic = round_pos_sig(basic_obj, 2)
sig2pobj = round_pos_sig(pobj, 2)
self.assertEqual(sig2basic, sig2pobj)
def test_persistent_bundles(self):
""" This excercises complicated code.
"""
options = self._copy_of_base_options()
options["PHIterLimit"] = 2
options["bundles_per_rank"] = 2
ph = mpisppy.opt.ph.PH(
options,
self.all10_scenario_names,
scenario_creator,
scenario_denouement,
scenario_creator_kwargs={"scenario_count": 10},
)
conv, basic_obj, tbound = ph.ph_main()
options = self._copy_of_base_options()
options["PHIterLimit"] = 2
options["bundles_per_rank"] = 2
options["solvername"] = persistentsolvername
ph = mpisppy.opt.ph.PH(
options,
self.all10_scenario_names,
scenario_creator,
scenario_denouement,
scenario_creator_kwargs={"scenario_count": 10},
)
conv, pbobj, tbound = ph.ph_main()
sig2basic = round_pos_sig(basic_obj, 2)
sig2pbobj = round_pos_sig(pbobj, 2)
self.assertEqual(sig2basic, sig2pbobj)
def test_MMW_running(self):
options = _get_base_options()
xhat = ciutils.read_xhat(self.xhat_path)
MMW = MMWci.MMWConfidenceIntervals(refmodelname, options['opt'], xhat,
options['num_batches'])
r = MMW.run()
s = round_pos_sig(r['std'], 2)
bound = round_pos_sig(r['gap_inner_bound'], 2)
self.assertEqual((s, bound), (43.0, 280.0))
def test_gap_estimators(self):
scenario_names = farmer.scenario_names_creator(50, start=1000)
estim = ciutils.gap_estimators(
self.xhat,
self.refmodelname,
solvername=solvername,
scenario_names=scenario_names,
)
G = estim['G']
s = estim['s']
G, s = round_pos_sig(G, 3), round_pos_sig(s, 3)
self.assertEqual((G, s), (110.0, 426.0))
def test_MMW_running(self):
options = self._get_base_options()
xhat = ciutils.read_xhat(self.xhat_path)
MMW = MMWci.MMWConfidenceIntervals(self.refmodelname,
options['opt'],
xhat,
options['num_batches'],
batch_size=options["batch_size"],
start=options['opt']['num_scens'])
r = MMW.run()
s = round_pos_sig(r['std'], 2)
bound = round_pos_sig(r['gap_inner_bound'], 2)
self.assertEqual((s, bound), (1.5, 96.0))
def test_zhat4xhat(self):
cmdline = [
self.arefmodelname, self.xhat_path, "--solver-name", solvername,
"--branching-factors", "5"
] # mainly defaults
parser = zhat4xhat._parser_setup()
afarmer.inparser_adder(parser)
args = parser.parse_args(cmdline)
model_module = importlib.import_module(self.arefmodelname)
zhatbar, eps_z = zhat4xhat._main_body(args, model_module)
z2 = round_pos_sig(-zhatbar, 2)
self.assertEqual(z2, 130000.)
e2 = round_pos_sig(eps_z, 2)
self.assertEqual(e2, 6600.0)
def test_zhat4xhat(self):
cmdline = [self.refmodelname, self.xhat_path, "--solver-name",
solvername, "--branching-factors", "4" ] # mainly using defaults
parser = zhat4xhat._parser_setup()
aircond.inparser_adder(parser)
args = parser.parse_args(cmdline)
# I couldnt't figure out how to get the branching factors parsed from this list, so
args.branching_factors = [4, 3, 2]
model_module = importlib.import_module(self.refmodelname)
zhatbar, eps_z = zhat4xhat._main_body(args, model_module)
z2 = round_pos_sig(zhatbar, 2)
self.assertEqual(z2, 1400.)
e2 = round_pos_sig(eps_z, 2)
self.assertEqual(e2, 84.)
def test_indepscens_seqsampling_running(self):
options = self._get_base_options()
branching_factors= options['kwoptions']['branching_factors']
xhat_gen_options = self._get_xhat_gen_options(branching_factors)
# We want a very small instance for testing on GitHub.
optionsBM = {'h':1.75,
'hprime':0.5,
'eps':0.2,
'epsprime':0.1,
"p":0.1,
"q":1.2,
"branching_factors": branching_factors,
"xhat_gen_options": xhat_gen_options,
"start_ups": False,
"start_seed": 0,
"solvername":solvername,
}
seq_pb = multi_seqsampling.IndepScens_SeqSampling(self.refmodelname,
aircond.xhat_generator_aircond,
optionsBM,
stochastic_sampling=False,
stopping_criterion="BM",
solving_type="EF-mstage",
)
x = seq_pb.run(maxit=50)
T = x['T']
ub = round_pos_sig(x['CI'][1],2)
self.assertEqual((T,ub), (4, 67.0))
def test_seqsampling_running(self):
#We need a very small instance for testing on GitHub.
optionsBM = {
'h': 1.75,
'hprime': 0.5,
'eps': 0.2,
'epsprime': 0.1,
"p": 0.1,
"q": 1.2,
"solvername": solvername,
"xhat_gen_options": {
"crops_multiplier": 3
},
"crops_multiplier": 3,
}
seq_pb = seqsampling.SeqSampling(
"mpisppy.tests.examples.farmer",
seqsampling.xhat_generator_farmer,
optionsBM,
stochastic_sampling=False,
stopping_criterion="BM",
solving_type="EF-2stage",
)
x = seq_pb.run(maxit=50)
T = x['T']
ub = round_pos_sig(x['CI'][1], 2)
self.assertEqual((T, ub), (1, 7400.0))
def test_ama_running(self):
options = self._get_base_options()
ama_options = options['kwoptions']
ama_object = ama.from_module(self.refmodelname,
ama_options, use_command_line=False)
ama_object.run()
obj = round_pos_sig(ama_object.EF_Obj,2)
self.assertEqual(obj, 810.)
def test_xhat_eval_evaluate(self):
ev = self._eval_creator()
base_options = self._get_base_options()
branching_factors= base_options['kwoptions']['branching_factors']
full_xhat = self._make_full_xhat(branching_factors)
obj = round_pos_sig(ev.evaluate(full_xhat),2)
self.assertEqual(obj, 960.0) # rebaselined 28 Dec 2021
def test_gap_estimators(self):
options = self._get_base_options()
branching_factors= options['kwoptions']['branching_factors']
scen_count = np.prod(branching_factors)
scenario_names = aircond.scenario_names_creator(scen_count, start=1000)
sample_options = {"seed": 0,
"branching_factors": options['kwoptions']['branching_factors']}
estim = ciutils.gap_estimators(self.xhat,
self.refmodelname,
solving_type="EF-mstage",
sample_options=sample_options,
scenario_creator_kwargs = options['kwargs'],
solvername=solvername,
scenario_names=scenario_names,
)
G = estim['G']
s = estim['s']
G,s = round_pos_sig(G,3),round_pos_sig(s,3)
self.assertEqual((G,s), (64.5, 31.8)) # rebaselined 28 Dec 2021 (see also 5 dec)
def test_ama_running(self):
options = self._get_base_options()
ama_options = {"EF-2stage": True}
ama_options.update(options['opt'])
ama_object = ama.from_module(self.refmodelname,
ama_options,
use_command_line=False)
ama_object.run()
obj = round_pos_sig(ama_object.EF_Obj, 2)
self.assertEqual(obj, -130000)
def test_ph_solve(self):
options = self._copy_of_base_options()
ph = mpisppy.opt.ph.PH(
options,
self.all_scenario_names,
hydro.scenario_creator,
hydro.scenario_denouement,
all_nodenames=self.all_nodenames,
scenario_creator_kwargs={
"branching_factors": self.branching_factors
},
)
conv, obj, tbound = ph.ph_main()
sig2tbnd = round_pos_sig(tbound, 2)
self.assertEqual(180, sig2tbnd)
ph.disable_W_and_prox()
sig2eobj = round_pos_sig(ph.Eobjective(), 2)
self.assertEqual(190, sig2eobj)
def test_ph_rhosetter(self):
options = self._copy_of_base_options()
options["PHIterLimit"] = 2
ph = mpisppy.opt.ph.PH(
options,
self.all3_scenario_names,
scenario_creator,
scenario_denouement,
scenario_creator_kwargs={"scenario_count": 3},
rho_setter=_rho_setter,
)
conv, obj, tbound = ph.ph_main()
sig2obj = round_pos_sig(obj, 2)
def test_ef_solve(self):
options = self._copy_of_base_options()
solver = pyo.SolverFactory(options["solvername"])
ScenCount = 3
ef = mpisppy.utils.sputils.create_EF(
self.all3_scenario_names,
scenario_creator,
scenario_creator_kwargs={"scenario_count": ScenCount},
suppress_warnings=True)
if '_persistent' in options["solvername"]:
solver.set_instance(ef)
results = solver.solve(ef, tee=False)
sig2eobj = round_pos_sig(pyo.value(ef.EF_Obj), 2)
self.assertEqual(220000.0, sig2eobj)
def test_xhat_eval_evaluate(self):
options = self._get_xhatEval_options()
MMW_options = self._get_base_options()
scenario_creator_kwargs = MMW_options['kwargs']
scenario_creator_kwargs['num_scens'] = MMW_options['batch_size']
ev = Xhat_Eval(options,
farmer.scenario_names_creator(100),
farmer.scenario_creator,
scenario_denouement=None,
scenario_creator_kwargs=scenario_creator_kwargs)
xhat = ciutils.read_xhat(self.xhat_path)
obj = round_pos_sig(ev.evaluate(xhat), 2)
self.assertEqual(obj, -1300000.0)
def test_xhat_eval_evaluate_one(self):
ev = self._eval_creator()
options = self._get_base_options()
branching_factors= options['kwoptions']['branching_factors']
full_xhat = self._make_full_xhat(branching_factors)
num_scens = np.prod(branching_factors)
scenario_creator_kwargs = options['kwargs']
scenario_creator_kwargs['num_scens'] = num_scens
all_scenario_names = aircond.scenario_names_creator(num_scens)
k = all_scenario_names[0]
obj = ev.evaluate_one(full_xhat,k,ev.local_scenarios[k])
obj = round_pos_sig(obj,2)
self.assertEqual(obj, 990.0) # rebaselined 28 Dec 2021
def test_xhat_eval_evaluate_one(self):
options = self._get_xhatEval_options()
MMW_options = self._get_base_options()
xhat = ciutils.read_xhat(self.xhat_path)
scenario_creator_kwargs = MMW_options['kwargs']
scenario_creator_kwargs['num_scens'] = MMW_options['batch_size']
scenario_names = farmer.scenario_names_creator(100)
ev = Xhat_Eval(options,
scenario_names,
farmer.scenario_creator,
scenario_denouement=None,
scenario_creator_kwargs=scenario_creator_kwargs)
k = scenario_names[0]
obj = ev.evaluate_one(xhat, k, ev.local_scenarios[k])
obj = round_pos_sig(obj, 2)
self.assertEqual(obj, -48000.0)
def test_fix_ef_solve(self):
options = self._copy_of_base_options()
solver = pyo.SolverFactory(options["solvername"])
ScenCount = 3
ef = mpisppy.utils.sputils.create_EF(
self.all3_scenario_names,
self._fix_creator,
scenario_creator_kwargs={"scenario_count": ScenCount},
)
if '_persistent' in options["solvername"]:
solver.set_instance(ef)
results = solver.solve(ef, tee=False)
sig2eobj = round_pos_sig(pyo.value(ef.EF_Obj), 2)
# the fix creator fixed num prod first stage for size 5 to 1134
self.assertEqual(pyo.value(ef.Scenario1.NumProducedFirstStage[5]),
1134)
def test_ef_solve(self):
options = self._copy_of_base_options()
solver = pyo.SolverFactory(options["solvername"])
ef = mpisppy.utils.sputils.create_EF(
self.all_scenario_names,
hydro.scenario_creator,
scenario_creator_kwargs={
"branching_factors": self.branching_factors
},
)
if '_persistent' in options["solvername"]:
solver.set_instance(ef)
results = solver.solve(ef, tee=False)
mpisppy.utils.sputils.ef_nonants_csv(ef, "delme.csv")
df = pd.read_csv("delme.csv", index_col=1)
val2 = round_pos_sig(df.loc[" Scen7.Pgt[2]"].at[" Value"])
self.assertEqual(val2, 60)
os.remove("delme.csv")
def test_xhat_extension(self):
""" Make sure least one of the xhat extensions runs.
"""
from mpisppy.extensions.xhatlooper import XhatLooper
options = self._copy_of_base_options()
options["PHIterLimit"] = 1
options["xhat_looper_options"] = {"xhat_solver_options":\
options["iterk_solver_options"],
"scen_limit": 3}
ph = mpisppy.opt.ph.PH(
options,
self.all3_scenario_names,
scenario_creator,
scenario_denouement,
scenario_creator_kwargs={"scenario_count": 3},
extensions=XhatLooper,
)
conv, basic_obj, tbound = ph.ph_main()
# in this particular case, the extobject is an xhatter
xhatobj1 = round_pos_sig(ph.extobject._xhat_looper_obj_final, 1)
self.assertEqual(xhatobj1, 200000)
def test_ph_xhat(self):
options = self._copy_of_base_options()
options["PHIterLimit"] = 10 # xhat is feasible
options["xhat_specific_options"] = {"xhat_solver_options":
options["iterk_solver_options"],
"xhat_scenario_dict": \
{"ROOT": "Scen1",
"ROOT_0": "Scen1",
"ROOT_1": "Scen4",
"ROOT_2": "Scen7"},
"csvname": "specific.csv"}
ph = mpisppy.opt.ph.PH(options,
self.all_scenario_names,
hydro.scenario_creator,
hydro.scenario_denouement,
all_nodenames=self.all_nodenames,
scenario_creator_kwargs={
"branching_factors": self.branching_factors
},
extensions=XhatSpecific)
conv, obj, tbound = ph.ph_main()
sig2xhatobj = round_pos_sig(ph.extobject._xhat_specific_obj_final, 2)
self.assertEqual(190, sig2xhatobj)
