def main(): args = _parse_args() with_xhatshuffle = args.with_xhatshuffle with_lagrangian = args.with_lagrangian # This is multi-stage, so we need to supply node names hydro = PySPModel("./PySP/models/", "./PySP/nodedata/") rho_setter = None # Things needed for vanilla cylinders beans = (args, hydro.scenario_creator, hydro.scenario_denouement, hydro.all_scenario_names) # Vanilla PH hub hub_dict = vanilla.ph_hub(*beans, ph_extensions=None, rho_setter=rho_setter, all_nodenames=hydro.all_nodenames) # Standard Lagrangian bound spoke if with_lagrangian: lagrangian_spoke = vanilla.lagrangian_spoke( *beans, rho_setter=rho_setter, all_nodenames=hydro.all_nodenames) if with_xhatshuffle: xhatshuffle_spoke = vanilla.xhatshuffle_spoke(*beans, hydro.all_nodenames) list_of_spoke_dict = list() if with_lagrangian: list_of_spoke_dict.append(lagrangian_spoke) if with_xhatshuffle: list_of_spoke_dict.append(xhatshuffle_spoke) wheel = WheelSpinner(hub_dict, list_of_spoke_dict) wheel.spin() if wheel.global_rank == 0: # we are the reporting hub rank print( f"BestInnerBound={wheel.BestInnerBound} and BestOuterBound={wheel.BestOuterBound}" ) if write_solution: wheel.write_first_stage_solution('hydro_first_stage.csv') wheel.write_tree_solution('hydro_full_solution') hydro.close()
def main(): args = _parse_args() with_xhatshuffle = args.with_xhatshuffle with_lagrangian = args.with_lagrangian # This is multi-stage, so we need to supply node names hydro = PySPModel("./PySP/models/", "./PySP/nodedata/") rho_setter = None # Things needed for vanilla cylinders beans = (args, hydro.scenario_creator, hydro.scenario_denouement, hydro.all_scenario_names) # Vanilla PH hub hub_dict = vanilla.ph_hub(*beans, ph_extensions=None, rho_setter = rho_setter, all_nodenames=hydro.all_nodenames) # Standard Lagrangian bound spoke if with_lagrangian: lagrangian_spoke = vanilla.lagrangian_spoke(*beans, rho_setter = rho_setter, all_nodenames=hydro.all_nodenames) if with_xhatshuffle: xhatshuffle_spoke = vanilla.xhatshuffle_spoke(*beans, hydro.all_nodenames) list_of_spoke_dict = list() if with_lagrangian: list_of_spoke_dict.append(lagrangian_spoke) if with_xhatshuffle: list_of_spoke_dict.append(xhatshuffle_spoke) spcomm, opt_dict = sputils.spin_the_wheel(hub_dict, list_of_spoke_dict) if "hub_class" in opt_dict: # we are a hub rank if spcomm.opt.cylinder_rank == 0: # we are the reporting hub rank print("BestInnerBound={} and BestOuterBound={}".\ format(spcomm.BestInnerBound, spcomm.BestOuterBound)) if write_solution: sputils.write_spin_the_wheel_first_stage_solution(spcomm, opt_dict, 'hydro_first_stage.csv') sputils.write_spin_the_wheel_tree_solution(spcomm, opt_dict, 'hydro_full_solution') hydro.close()
def main(): args = _parse_args() inst = args.instance_name num_scen = int(inst.split("-")[-3]) if args.num_scens is not None and args.num_scens != num_scen: raise RuntimeError("Argument num-scens={} does not match the number " "implied by instance name={} " "\n(--num-scens is not needed for netdes)") with_fwph = args.with_fwph with_xhatlooper = args.with_xhatlooper with_xhatshuffle = args.with_xhatshuffle with_lagrangian = args.with_lagrangian with_slamup = args.with_slamup with_cross_scenario_cuts = args.with_cross_scenario_cuts if args.default_rho is None: raise RuntimeError("The --default-rho option must be specified") path = f"{netdes.__file__[:-10]}/data/{inst}.dat" scenario_creator = netdes.scenario_creator scenario_denouement = netdes.scenario_denouement all_scenario_names = [f"Scen{i}" for i in range(num_scen)] scenario_creator_kwargs = {"path": path} # Things needed for vanilla cylinders beans = (args, scenario_creator, scenario_denouement, all_scenario_names) if with_cross_scenario_cuts: ph_ext = CrossScenarioExtension else: ph_ext = None # Vanilla PH hub hub_dict = vanilla.ph_hub(*beans, scenario_creator_kwargs=scenario_creator_kwargs, ph_extensions=ph_ext, rho_setter=None) if with_cross_scenario_cuts: hub_dict["opt_kwargs"]["PHoptions"]["cross_scen_options"]\ = {"check_bound_improve_iterations" : args.cross_scenario_iter_cnt} # FWPH spoke if with_fwph: fw_spoke = vanilla.fwph_spoke( *beans, scenario_creator_kwargs=scenario_creator_kwargs) # Standard Lagrangian bound spoke if with_lagrangian: lagrangian_spoke = vanilla.lagrangian_spoke( *beans, scenario_creator_kwargs=scenario_creator_kwargs, rho_setter=None) # xhat looper bound spoke if with_xhatlooper: xhatlooper_spoke = vanilla.xhatlooper_spoke( *beans, scenario_creator_kwargs=scenario_creator_kwargs) # xhat shuffle bound spoke if with_xhatshuffle: xhatshuffle_spoke = vanilla.xhatshuffle_spoke( *beans, scenario_creator_kwargs=scenario_creator_kwargs) # slam up bound spoke if with_slamup: slamup_spoke = vanilla.slamup_spoke( *beans, scenario_creator_kwargs=scenario_creator_kwargs) # cross scenario cut spoke if with_cross_scenario_cuts: cross_scenario_cut_spoke = vanilla.cross_scenario_cut_spoke( *beans, scenario_creator_kwargs=scenario_creator_kwargs) list_of_spoke_dict = list() if with_fwph: list_of_spoke_dict.append(fw_spoke) if with_lagrangian: list_of_spoke_dict.append(lagrangian_spoke) if with_xhatlooper: list_of_spoke_dict.append(xhatlooper_spoke) if with_xhatshuffle: list_of_spoke_dict.append(xhatshuffle_spoke) if with_slamup: list_of_spoke_dict.append(slamup_spoke) if with_cross_scenario_cuts: list_of_spoke_dict.append(cross_scenario_cut_spoke) spin_the_wheel(hub_dict, list_of_spoke_dict)
def main(): args = _parse_args() num_scen = args.num_scens with_fwph = args.with_fwph with_xhatlooper = args.with_xhatlooper with_xhatshuffle = args.with_xhatshuffle with_lagrangian = args.with_lagrangian with_fixer = args.with_fixer fixer_tol = args.fixer_tol if num_scen not in (3, 10): raise RuntimeError(f"num_scen must the 3 or 10; was {num_scen}") scenario_creator_kwargs = {"scenario_count": num_scen} scenario_creator = sizes.scenario_creator scenario_denouement = sizes.scenario_denouement all_scenario_names = [f"Scenario{i+1}" for i in range(num_scen)] rho_setter = sizes._rho_setter variable_probability = sizes._variable_probability if with_fixer: ph_ext = Fixer else: ph_ext = None # Things needed for vanilla cylinders beans = (args, scenario_creator, scenario_denouement, all_scenario_names) # Vanilla PH hub hub_dict = vanilla.ph_hub(*beans, scenario_creator_kwargs=scenario_creator_kwargs, ph_extensions=ph_ext, rho_setter=rho_setter, variable_probability=variable_probability) if with_fixer: hub_dict["opt_kwargs"]["PHoptions"]["fixeroptions"] = { "verbose": False, "boundtol": fixer_tol, "id_fix_list_fct": sizes.id_fix_list_fct, } if args.default_rho is None: # since we are using a rho_setter anyway hub_dict.opt_kwargs.PHoptions["defaultPHrho"] = 1 # FWPH spoke if with_fwph: fw_spoke = vanilla.fwph_spoke( *beans, scenario_creator_kwargs=scenario_creator_kwargs) # Standard Lagrangian bound spoke if with_lagrangian: lagrangian_spoke = vanilla.lagrangian_spoke( *beans, scenario_creator_kwargs=scenario_creator_kwargs, rho_setter=rho_setter) # xhat looper bound spoke if with_xhatlooper: xhatlooper_spoke = vanilla.xhatlooper_spoke( *beans, scenario_creator_kwargs=scenario_creator_kwargs) # xhat shuffle bound spoke if with_xhatshuffle: xhatshuffle_spoke = vanilla.xhatshuffle_spoke( *beans, scenario_creator_kwargs=scenario_creator_kwargs) list_of_spoke_dict = list() if with_fwph: list_of_spoke_dict.append(fw_spoke) if with_lagrangian: list_of_spoke_dict.append(lagrangian_spoke) if with_xhatlooper: list_of_spoke_dict.append(xhatlooper_spoke) if with_xhatshuffle: list_of_spoke_dict.append(xhatshuffle_spoke) spin_the_wheel(hub_dict, list_of_spoke_dict)
def main(): args = _parse_args() num_scen = args.num_scens with_fwph = args.with_fwph with_xhatlooper = args.with_xhatlooper with_xhatshuffle = args.with_xhatshuffle with_lagrangian = args.with_lagrangian with_fixer = args.with_fixer fixer_tol = args.fixer_tol with_cross_scenario_cuts = args.with_cross_scenario_cuts scensavail = [3, 5, 10, 25, 50, 100] if num_scen not in scensavail: raise RuntimeError("num-scen was {}, but must be in {}".\ format(num_scen, scensavail)) scenario_creator_kwargs = { "scenario_count": num_scen, "path": str(num_scen) + "scenarios_r1", } scenario_creator = uc.scenario_creator scenario_denouement = uc.scenario_denouement all_scenario_names = [f"Scenario{i+1}" for i in range(num_scen)] rho_setter = uc._rho_setter # Things needed for vanilla cylinders beans = (args, scenario_creator, scenario_denouement, all_scenario_names) ### start ph spoke ### # Start with Vanilla PH hub hub_dict = vanilla.ph_hub(*beans, scenario_creator_kwargs=scenario_creator_kwargs, ph_extensions=MultiPHExtension, rho_setter=rho_setter) # Extend and/or correct the vanilla dictionary ext_classes = [Gapper] if with_fixer: ext_classes.append(Fixer) if with_cross_scenario_cuts: ext_classes.append(CrossScenarioExtension) if args.xhat_closest_tree: ext_classes.append(XhatClosest) hub_dict["opt_kwargs"]["PH_extension_kwargs"] = { "ext_classes": ext_classes } if with_cross_scenario_cuts: hub_dict["opt_kwargs"]["PHoptions"]["cross_scen_options"]\ = {"check_bound_improve_iterations" : args.cross_scenario_iter_cnt} if with_fixer: hub_dict["opt_kwargs"]["PHoptions"]["fixeroptions"] = { "verbose": args.with_verbose, "boundtol": fixer_tol, "id_fix_list_fct": uc.id_fix_list_fct, } if args.xhat_closest_tree: hub_dict["opt_kwargs"]["PHoptions"]["xhat_closest_options"] = { "xhat_solver_options": dict(), "keep_solution": True } if args.ph_mipgaps_json is not None: with open(args.ph_mipgaps_json) as fin: din = json.load(fin) mipgapdict = {int(i): din[i] for i in din} else: mipgapdict = None hub_dict["opt_kwargs"]["PHoptions"]["gapperoptions"] = { "verbose": args.with_verbose, "mipgapdict": mipgapdict } if args.default_rho is None: # since we are using a rho_setter anyway hub_dict.opt_kwargs.PHoptions["defaultPHrho"] = 1 ### end ph spoke ### # FWPH spoke if with_fwph: fw_spoke = vanilla.fwph_spoke( *beans, scenario_creator_kwargs=scenario_creator_kwargs) # Standard Lagrangian bound spoke if with_lagrangian: lagrangian_spoke = vanilla.lagrangian_spoke( *beans, scenario_creator_kwargs=scenario_creator_kwargs, rho_setter=rho_setter) # xhat looper bound spoke if with_xhatlooper: xhatlooper_spoke = vanilla.xhatlooper_spoke( *beans, scenario_creator_kwargs=scenario_creator_kwargs) # xhat shuffle bound spoke if with_xhatshuffle: xhatshuffle_spoke = vanilla.xhatshuffle_spoke( *beans, scenario_creator_kwargs=scenario_creator_kwargs) # cross scenario cut spoke if with_cross_scenario_cuts: cross_scenario_cut_spoke = vanilla.cross_scenario_cut_spoke( *beans, scenario_creator_kwargs=scenario_creator_kwargs) list_of_spoke_dict = list() if with_fwph: list_of_spoke_dict.append(fw_spoke) if with_lagrangian: list_of_spoke_dict.append(lagrangian_spoke) if with_xhatlooper: list_of_spoke_dict.append(xhatlooper_spoke) if with_xhatshuffle: list_of_spoke_dict.append(xhatshuffle_spoke) if with_cross_scenario_cuts: list_of_spoke_dict.append(cross_scenario_cut_spoke) spcomm, opt_dict = spin_the_wheel(hub_dict, list_of_spoke_dict) if args.solution_dir is not None: uc.write_solution(spcomm, opt_dict, args.solution_dir)
def main(): args = _parse_args() BFs = args.branching_factors xhat_scenario_dict = make_node_scenario_dict_balanced(BFs) all_nodenames = list(xhat_scenario_dict.keys()) with_xhatspecific = args.with_xhatspecific with_lagrangian = args.with_lagrangian with_xhatshuffle = args.with_xhatshuffle # This is multi-stage, so we need to supply node names #all_nodenames = ["ROOT"] # all trees must have this node # The rest is a naming convention invented for this problem. # Note that mpisppy does not have nodes at the leaves, # and node names must end in a serial number. ScenCount = np.prod(BFs) #ScenCount = _get_num_leaves(BFs) sc_options = {"args": args} scenario_creator_kwargs = aircond.kw_creator(sc_options) all_scenario_names = [f"scen{i}" for i in range(ScenCount)] #Scens are 0-based # print(all_scenario_names) scenario_creator = aircond.scenario_creator scenario_denouement = aircond.scenario_denouement primal_rho_setter = aircond.primal_rho_setter dual_rho_setter = aircond.dual_rho_setter # Things needed for vanilla cylinders beans = (args, scenario_creator, scenario_denouement, all_scenario_names) # Vanilla PH hub hub_dict = vanilla.ph_hub(*beans, scenario_creator_kwargs=scenario_creator_kwargs, ph_extensions=None, rho_setter=primal_rho_setter, all_nodenames=all_nodenames) # Standard Lagrangian bound spoke if with_lagrangian: lagrangian_spoke = vanilla.lagrangian_spoke( *beans, scenario_creator_kwargs=scenario_creator_kwargs, rho_setter=primal_rho_setter, all_nodenames=all_nodenames) # xhat specific bound spoke if with_xhatspecific: xhatspecific_spoke = vanilla.xhatspecific_spoke( *beans, xhat_scenario_dict, all_nodenames=all_nodenames, scenario_creator_kwargs=scenario_creator_kwargs) #xhat shuffle looper bound spoke if with_xhatshuffle: xhatshuffle_spoke = vanilla.xhatshuffle_spoke( *beans, all_nodenames=all_nodenames, scenario_creator_kwargs=scenario_creator_kwargs) list_of_spoke_dict = list() if with_lagrangian: list_of_spoke_dict.append(lagrangian_spoke) if with_xhatspecific: list_of_spoke_dict.append(xhatspecific_spoke) if with_xhatshuffle: list_of_spoke_dict.append(xhatshuffle_spoke) wheel = WheelSpinner(hub_dict, list_of_spoke_dict) wheel.spin() fname = 'aircond_cyl_nonants.npy' if wheel.global_rank == 0: print("BestInnerBound={} and BestOuterBound={}".\ format(wheel.BestInnerBound, wheel.BestOuterBound)) if write_solution: print(f"Writing first stage solution to {fname}") # all ranks need to participate because only the winner will write if write_solution: wheel.write_first_stage_solution('aircond_first_stage.csv') wheel.write_tree_solution('aircond_full_solution') wheel.write_first_stage_solution( fname, first_stage_solution_writer=first_stage_nonant_npy_serializer)
def main(): args = _parse_args() num_scen = args.num_scens crops_multiplier = args.crops_mult rho_setter = farmer._rho_setter if hasattr(farmer, '_rho_setter') else None if args.default_rho is None and rho_setter is None: raise RuntimeError( "No rho_setter so a default must be specified via --default-rho") if args.use_norm_rho_converger: if not args.use_norm_rho_updater: raise RuntimeError( "--use-norm-rho-converger requires --use-norm-rho-updater") else: ph_converger = NormRhoConverger else: ph_converger = None scenario_creator = farmer.scenario_creator scenario_denouement = farmer.scenario_denouement all_scenario_names = ['scen{}'.format(sn) for sn in range(num_scen)] scenario_creator_kwargs = { 'use_integer': False, "crops_multiplier": crops_multiplier, } scenario_names = [f"Scenario{i+1}" for i in range(num_scen)] # Things needed for vanilla cylinders beans = (args, scenario_creator, scenario_denouement, all_scenario_names) if args.run_async: # Vanilla APH hub hub_dict = vanilla.aph_hub( *beans, scenario_creator_kwargs=scenario_creator_kwargs, ph_extensions=None, rho_setter=rho_setter) else: # Vanilla PH hub hub_dict = vanilla.ph_hub( *beans, scenario_creator_kwargs=scenario_creator_kwargs, ph_extensions=None, ph_converger=ph_converger, rho_setter=rho_setter) ## hack in adaptive rho if args.use_norm_rho_updater: hub_dict['opt_kwargs']['extensions'] = NormRhoUpdater hub_dict['opt_kwargs']['options']['norm_rho_options'] = { 'verbose': True } # FWPH spoke if args.with_fwph: fw_spoke = vanilla.fwph_spoke( *beans, scenario_creator_kwargs=scenario_creator_kwargs) # Standard Lagrangian bound spoke if args.with_lagrangian: lagrangian_spoke = vanilla.lagrangian_spoke( *beans, scenario_creator_kwargs=scenario_creator_kwargs, rho_setter=rho_setter) # xhat looper bound spoke if args.with_xhatlooper: xhatlooper_spoke = vanilla.xhatlooper_spoke( *beans, scenario_creator_kwargs=scenario_creator_kwargs) # xhat shuffle bound spoke if args.with_xhatshuffle: xhatshuffle_spoke = vanilla.xhatshuffle_spoke( *beans, scenario_creator_kwargs=scenario_creator_kwargs) list_of_spoke_dict = list() if args.with_fwph: list_of_spoke_dict.append(fw_spoke) if args.with_lagrangian: list_of_spoke_dict.append(lagrangian_spoke) if args.with_xhatlooper: list_of_spoke_dict.append(xhatlooper_spoke) if args.with_xhatshuffle: list_of_spoke_dict.append(xhatshuffle_spoke) wheel = WheelSpinner(hub_dict, list_of_spoke_dict) wheel.spin() if write_solution: wheel.write_first_stage_solution('farmer_plant.csv') wheel.write_first_stage_solution('farmer_cyl_nonants.npy', first_stage_solution_writer=sputils. first_stage_nonant_npy_serializer) wheel.write_tree_solution('farmer_full_solution')
def main(): args = _parse_args() inst = args.instance_name num_scen = int(inst.split("_")[-1]) if args.num_scens is not None and args.num_scens != num_scen: raise RuntimeError("Argument num-scens={} does not match the number " "implied by instance name={} " "\n(--num-scens is not needed for sslp)") with_fwph = args.with_fwph with_fixer = args.with_fixer fixer_tol = args.fixer_tol with_xhatlooper = args.with_xhatlooper with_xhatshuffle = args.with_xhatshuffle with_lagrangian = args.with_lagrangian if args.default_rho is None: raise RuntimeError("The --default-rho option must be specified") scenario_creator_kwargs = { "data_dir": f"{sslp.__file__[:-8]}/data/{inst}/scenariodata" } scenario_creator = sslp.scenario_creator scenario_denouement = sslp.scenario_denouement all_scenario_names = [f"Scenario{i+1}" for i in range(num_scen)] if with_fixer: ph_ext = Fixer else: ph_ext = None # Things needed for vanilla cylinders beans = (args, scenario_creator, scenario_denouement, all_scenario_names) # Vanilla PH hub hub_dict = vanilla.ph_hub(*beans, scenario_creator_kwargs=scenario_creator_kwargs, ph_extensions=ph_ext, rho_setter=None) if with_fixer: hub_dict["opt_kwargs"]["PHoptions"]["fixeroptions"] = { "verbose": False, "boundtol": fixer_tol, "id_fix_list_fct": sslp.id_fix_list_fct, } # FWPH spoke if with_fwph: fw_spoke = vanilla.fwph_spoke( *beans, scenario_creator_kwargs=scenario_creator_kwargs) # Standard Lagrangian bound spoke if with_lagrangian: lagrangian_spoke = vanilla.lagrangian_spoke( *beans, scenario_creator_kwargs=scenario_creator_kwargs, rho_setter=None) # xhat looper bound spoke if with_xhatlooper: xhatlooper_spoke = vanilla.xhatlooper_spoke( *beans, scenario_creator_kwargs=scenario_creator_kwargs) # xhat shuffle bound spoke if with_xhatshuffle: xhatshuffle_spoke = vanilla.xhatshuffle_spoke( *beans, scenario_creator_kwargs=scenario_creator_kwargs) list_of_spoke_dict = list() if with_fwph: list_of_spoke_dict.append(fw_spoke) if with_lagrangian: list_of_spoke_dict.append(lagrangian_spoke) if with_xhatlooper: list_of_spoke_dict.append(xhatlooper_spoke) if with_xhatshuffle: list_of_spoke_dict.append(xhatshuffle_spoke) spin_the_wheel(hub_dict, list_of_spoke_dict)
def main(): args = _parse_args() BFs = args.branching_factors xhat_scenario_dict = make_node_scenario_dict_balanced(BFs) all_nodenames = list(xhat_scenario_dict.keys()) with_xhatspecific = args.with_xhatspecific with_lagrangian = args.with_lagrangian with_xhatshuffle = args.with_xhatshuffle # This is multi-stage, so we need to supply node names #all_nodenames = ["ROOT"] # all trees must have this node # The rest is a naming convention invented for this problem. # Note that mpisppy does not have nodes at the leaves, # and node names must end in a serial number. ScenCount = np.prod(BFs) #ScenCount = _get_num_leaves(BFs) scenario_creator_kwargs = {"BFs": BFs} all_scenario_names = [f"scen{i}" for i in range(ScenCount)] #Scens are 0-based # print(all_scenario_names) scenario_creator = aircond_submodels.scenario_creator scenario_denouement = aircond_submodels.scenario_denouement rho_setter = None # Things needed for vanilla cylinders beans = (args, scenario_creator, scenario_denouement, all_scenario_names) # Vanilla PH hub hub_dict = vanilla.ph_hub(*beans, scenario_creator_kwargs=scenario_creator_kwargs, ph_extensions=None, rho_setter=rho_setter, all_nodenames=all_nodenames) # Standard Lagrangian bound spoke if with_lagrangian: lagrangian_spoke = vanilla.lagrangian_spoke( *beans, scenario_creator_kwargs=scenario_creator_kwargs, rho_setter=rho_setter, all_nodenames=all_nodenames) # xhat specific bound spoke if with_xhatspecific: xhatspecific_spoke = vanilla.xhatspecific_spoke( *beans, xhat_scenario_dict, all_nodenames=all_nodenames, scenario_creator_kwargs=scenario_creator_kwargs) #xhat shuffle looper bound spoke if with_xhatshuffle: xhatshuffle_spoke = vanilla.xhatshuffle_spoke( *beans, all_nodenames=all_nodenames, scenario_creator_kwargs=scenario_creator_kwargs) list_of_spoke_dict = list() if with_lagrangian: list_of_spoke_dict.append(lagrangian_spoke) if with_xhatspecific: list_of_spoke_dict.append(xhatspecific_spoke) if with_xhatshuffle: list_of_spoke_dict.append(xhatshuffle_spoke) spcomm, opt_dict = sputils.spin_the_wheel(hub_dict, list_of_spoke_dict) if "hub_class" in opt_dict: # we are a hub rank if spcomm.opt.cylinder_rank == 0: # we are the reporting hub rank print("BestInnerBound={} and BestOuterBound={}".\ format(spcomm.BestInnerBound, spcomm.BestOuterBound)) if write_solution: sputils.write_spin_the_wheel_first_stage_solution( spcomm, opt_dict, 'aircond_first_stage.csv') sputils.write_spin_the_wheel_tree_solution(spcomm, opt_dict, 'aircond_full_solution')
def main(): args = _parse_args() num_scen = args.num_scens crops_multiplier = args.crops_mult rho_setter = farmer._rho_setter if hasattr(farmer, '_rho_setter') else None if args.default_rho is None and rho_setter is None: raise RuntimeError("No rho_setter so there must be --default-rho") scenario_creator = farmer.scenario_creator scenario_denouement = farmer.scenario_denouement all_scenario_names = ['scen{}'.format(sn) for sn in range(num_scen)] scenario_creator_kwargs = { 'use_integer': False, "crops_multiplier": crops_multiplier, } scenario_names = [f"Scenario{i+1}" for i in range(num_scen)] # Things needed for vanilla cylinders beans = (args, scenario_creator, scenario_denouement, all_scenario_names) # Vanilla PH hub hub_dict = vanilla.ph_hub(*beans, scenario_creator_kwargs=scenario_creator_kwargs, ph_extensions=None, rho_setter=rho_setter) ## hack in adaptive rho if args.use_norm_rho_updater: hub_dict['opt_kwargs']['PH_extensions'] = NormRhoUpdater hub_dict['opt_kwargs']['PHoptions']['norm_rho_options'] = { 'verbose': True } # FWPH spoke if args.with_fwph: fw_spoke = vanilla.fwph_spoke( *beans, scenario_creator_kwargs=scenario_creator_kwargs) # Standard Lagrangian bound spoke if args.with_lagrangian: lagrangian_spoke = vanilla.lagrangian_spoke( *beans, scenario_creator_kwargs=scenario_creator_kwargs, rho_setter=rho_setter) # xhat looper bound spoke if args.with_xhatlooper: xhatlooper_spoke = vanilla.xhatlooper_spoke( *beans, scenario_creator_kwargs=scenario_creator_kwargs) # xhat shuffle bound spoke if args.with_xhatshuffle: xhatshuffle_spoke = vanilla.xhatshuffle_spoke( *beans, scenario_creator_kwargs=scenario_creator_kwargs) list_of_spoke_dict = list() if args.with_fwph: list_of_spoke_dict.append(fw_spoke) if args.with_lagrangian: list_of_spoke_dict.append(lagrangian_spoke) if args.with_xhatlooper: list_of_spoke_dict.append(xhatlooper_spoke) if args.with_xhatshuffle: list_of_spoke_dict.append(xhatshuffle_spoke) mpisppy.cylinders.SPOKE_SLEEP_TIME = 0.1 spin_the_wheel(hub_dict, list_of_spoke_dict)
def main(): args = _parse_args() BFs = args.branching_factors if len(BFs) != 2: raise RuntimeError("Hydro is a three stage problem, so it needs 2 BFs") with_xhatshuffle = args.with_xhatshuffle with_lagrangian = args.with_lagrangian # This is multi-stage, so we need to supply node names all_nodenames = sputils.create_nodenames_from_branching_factors(BFs) ScenCount = BFs[0] * BFs[1] scenario_creator_kwargs = {"branching_factors": BFs} all_scenario_names = [f"Scen{i+1}" for i in range(ScenCount)] scenario_creator = hydro.scenario_creator scenario_denouement = hydro.scenario_denouement rho_setter = None # Things needed for vanilla cylinders beans = (args, scenario_creator, scenario_denouement, all_scenario_names) # Vanilla PH hub hub_dict = vanilla.ph_hub(*beans, scenario_creator_kwargs=scenario_creator_kwargs, ph_extensions=None, rho_setter=rho_setter, all_nodenames=all_nodenames, spoke_sleep_time=SPOKE_SLEEP_TIME) # Standard Lagrangian bound spoke if with_lagrangian: lagrangian_spoke = vanilla.lagrangian_spoke( *beans, scenario_creator_kwargs=scenario_creator_kwargs, rho_setter=rho_setter, all_nodenames=all_nodenames, spoke_sleep_time=SPOKE_SLEEP_TIME) # xhat looper bound spoke if with_xhatshuffle: xhatshuffle_spoke = vanilla.xhatshuffle_spoke( *beans, all_nodenames=all_nodenames, scenario_creator_kwargs=scenario_creator_kwargs, spoke_sleep_time=SPOKE_SLEEP_TIME) list_of_spoke_dict = list() if with_lagrangian: list_of_spoke_dict.append(lagrangian_spoke) if with_xhatshuffle: list_of_spoke_dict.append(xhatshuffle_spoke) wheel = WheelSpinner(hub_dict, list_of_spoke_dict) wheel.spin() if wheel.global_rank == 0: # we are the reporting hub rank print( f"BestInnerBound={wheel.BestInnerBound} and BestOuterBound={wheel.BestOuterBound}" ) if write_solution: wheel.write_first_stage_solution('hydro_first_stage.csv') wheel.write_tree_solution('hydro_full_solution')
def main(): args = _parse_args() BFs = [int(bf) for bf in args.BFs.split(',')] if len(BFs) != 2: raise RuntimeError("Hydro is a three stage problem, so it needs 2 BFs") with_xhatspecific = args.with_xhatspecific with_lagrangian = args.with_lagrangian # This is multi-stage, so we need to supply node names all_nodenames = ["ROOT"] # all trees must have this node # The rest is a naming convention invented for this problem. # Note that mpisppy does not have nodes at the leaves, # and node names must end in a serial number. for b in range(BFs[0]): all_nodenames.append("ROOT_" + str(b)) ScenCount = BFs[0] * BFs[1] scenario_creator_kwargs = {"branching_factors": BFs} all_scenario_names = [f"Scen{i+1}" for i in range(ScenCount)] scenario_creator = hydro.scenario_creator scenario_denouement = hydro.scenario_denouement rho_setter = None # Things needed for vanilla cylinders beans = (args, scenario_creator, scenario_denouement, all_scenario_names) # Vanilla PH hub hub_dict = vanilla.ph_hub(*beans, scenario_creator_kwargs=scenario_creator_kwargs, ph_extensions=None, rho_setter=rho_setter) hub_dict["opt_kwargs"]["all_nodenames"] = all_nodenames hub_dict["opt_kwargs"]["PHoptions"]["branching_factors"] = BFs # Standard Lagrangian bound spoke if with_lagrangian: lagrangian_spoke = vanilla.lagrangian_spoke( *beans, scenario_creator_kwargs=scenario_creator_kwargs, rho_setter=rho_setter) lagrangian_spoke["opt_kwargs"]["all_nodenames"] = all_nodenames lagrangian_spoke["opt_kwargs"]["PHoptions"]["branching_factors"] = BFs # xhat looper bound spoke xhat_scenario_dict = { "ROOT": "Scen1", "ROOT_0": "Scen1", "ROOT_1": "Scen4", "ROOT_2": "Scen7" } if with_xhatspecific: xhatspecific_spoke = vanilla.xhatspecific_spoke( *beans, xhat_scenario_dict, all_nodenames, BFs, scenario_creator_kwargs=scenario_creator_kwargs) list_of_spoke_dict = list() if with_lagrangian: list_of_spoke_dict.append(lagrangian_spoke) if with_xhatspecific: list_of_spoke_dict.append(xhatspecific_spoke) spcomm, opt_dict = spin_the_wheel(hub_dict, list_of_spoke_dict) if "hub_class" in opt_dict: # we are a hub rank if spcomm.opt.cylinder_rank == 0: # we are the reporting hub rank print("BestInnerBound={} and BestOuterBound={}".\ format(spcomm.BestInnerBound, spcomm.BestOuterBound))