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)