def _get_exploratory_results(mediator, context): # turn logging on ema_logging.log_to_stderr(ema_logging.INFO) # create a EMA Model Object ema_model = _build_executable_model(mediator, context) with MultiprocessingEvaluator(ema_model, n_processes=context.num_processes, maxtasksperchild=4) as evaluator: # run model using EMA results = evaluator.perform_experiments(context.num_experiments) return results
def performReevaluation(model, params, policies, outputFile): if (params.createNewReevaluationResults): with MultiprocessingEvaluator(model) as evaluator: scenarios = params.evaluationScenarios results = evaluator.perform_experiments(scenarios=scenarios, policies=policies) if not os.path.exists(params.reevaluateOutputFolder): os.makedirs(params.reevaluateOutputFolder) save_results(results, params.reevaluateOutputFolder + outputFile) else: print('Loading reevaluation from ' + params.reevaluateOutputFolder + outputFile) results = load_results(params.reevaluateOutputFolder + outputFile) return results
# no dike increase, no warning, none of the rfr zero_policy = {'DaysToThreat': 0} zero_policy.update( {'DikeIncrease {}'.format(n): 0 for n in planning_steps}) zero_policy.update({'RfR {}'.format(n): 0 for n in planning_steps}) pol0 = {} for key in dike_model.levers: s1, s2 = key.name.split('_') pol0.update({key.name: zero_policy[s2]}) policy0 = Policy('Policy 0', **pol0) with MultiprocessingEvaluator(dike_model) as evaluator: results1 = evaluator.perform_experiments(scenarios=100, policies=policy0) experiments1, outcomes1 = results1 sns.pairplot(pd.DataFrame.from_dict(outcomes1)) plt.show() #%% visual analysis from ema_workbench.analysis import pairs_plotting fig, axes = pairs_plotting.pairs_scatter(experiments1, outcomes1, group_by='policy', legend=False) fig.set_size_inches(8, 8)
ArrayOutcome('Total Electricity use'), ArrayOutcome('Neighbourhood Data'), ArrayOutcome('Municipality Data') ] multi_model.replications = 4 multi_model.nrScenarios = 50 multi_model.nrPolicies = 30 #replications: 4 #scenarios: 50 #policies: 30 #results = perform_experiments(multi_model, 1, 1) with MultiprocessingEvaluator(multi_model, n_processes=50) as evaluator: results = perform_experiments(multi_model, multi_model.nrScenarios, multi_model.nrPolicies, evaluator=evaluator, callback=Extra_dim_Callback) end = datetime.now() print('Total experiments took ' + str(end - start)) no_categorical_results = [ 'SD_Average Gas Price', 'SD_Average Electricity Price', 'SD_Average Heat Price', 'SD_National Energy System Distribution[Natural Gas]', 'SD_National Energy System Distribution[Green Gas]',
variable_name= 'Use SP-A', function = np.sum), ScalarOutcome(name = 'Total green steam use by Nouryon (ton/week)', variable_name = 'Use SP-B', function = np.sum), ArrayOutcome(name = 'Chlorine storage stock at Nouryon (ton)', variable_name = 'Chlorine storage'), ArrayOutcome(name = 'Run-time (s)', variable_name = 'Run-time')] # define the full factorial set of policies with names policies = [Policy('None of the options', **{'Steam Pipe':False, 'E-boiler':False, 'Chlorine Storage':False}), Policy('Only Steam Pipe', **{'Steam Pipe':True, 'E-boiler':False, 'Chlorine Storage':False}), Policy('Only E-boiler', **{'Steam Pipe':False, 'E-boiler':True, 'Chlorine Storage':False}), Policy('Only Chlorine storage', **{'Steam Pipe':False, 'E-boiler':False, 'Chlorine Storage':True}), Policy('Steam Pipe & E-boiler', **{'Steam Pipe':True, 'E-boiler':True, 'Chlorine Storage':False}), Policy('Steam Pipe & Chlorine storage', **{'Steam Pipe':True, 'E-boiler':False, 'Chlorine Storage':True}), Policy('E-boiler & Chlorine storage', **{'Steam Pipe':False, 'E-boiler':True, 'Chlorine Storage':True}), Policy('All options', **{'Steam Pipe':True, 'E-boiler':True, 'Chlorine Storage':True})] # define the number of scenarios to be sampled scenarios = 100 # run the models with MultiprocessingEvaluator(model_list, n_processes = 56) as evaluator: results = evaluator.perform_experiments(policies = policies, scenarios = scenarios) # save the results save_results(results, f'./results/results_open_exploration_{scenarios}_scenarios_improved_model.tar.gz')
def main(): hybridmodel = Model('hybridmodel', function=hybridloop) hybridmodel.uncertainties = [ IntegerParameter("inputpowerfactor", 15, 25), #7 13 IntegerParameter("inputLNGprice", 200, 1000), IntegerParameter("inputtransferprice", 50, 300), IntegerParameter("inputCapincrease", 1000, 3000), IntegerParameter("inputCapincreasetime", 1, 2), IntegerParameter("inputLNGCapincrease", 1000, 3000), IntegerParameter("inputLNGCapincreasetime", 1, 2), # RealParameter("DemandBalanceSupplyEnergyPrice", 0.4, 0.7), RealParameter("MaximumChangeinDemand", 0.4, 0.7), RealParameter("SupplyElasticityGas", 0.06, 0.07), RealParameter("SupplyElasticityOil", 0.1, 0.2), RealParameter("SupplyElasticityCoal", 0.1, 0.2), RealParameter("SupplyElasticityNuclear", 0.007, 0.017), RealParameter("SupplyElasticityBiofuel", 0.1, 0.2), RealParameter("SupplyElasticityOR", 0.15, 0.3), IntegerParameter("EconomicGrowthScenario", 1, 3), IntegerParameter("EnergyIntensityScenario", 1, 3), RealParameter("CO2coal", 93.46, 113.67), RealParameter("CO2oil", 59.58, 102.12), RealParameter("Variancepower", -5.0, -0.1), IntegerParameter("POil", 8900, 9100), IntegerParameter("PCoal", 2800, 3100), IntegerParameter("PBio", 29000, 32000), IntegerParameter("PNuc", 16000, 17000), IntegerParameter("POR", 19000, 22000), IntegerParameter("PGasE", 6500, 7000), IntegerParameter("PGasNA", 2500, 2700), IntegerParameter("PGasSCA", 2500, 2700), IntegerParameter("PGasCIS", 6500, 7000), IntegerParameter("PGasME", 7000, 8000), IntegerParameter("PGasAF", 7000, 8000), IntegerParameter("PGasAP", 7000, 8000) ] hybridmodel.outcomes = [ TimeSeriesOutcome("EU_GasSup"), TimeSeriesOutcome("EU_GasDem"), TimeSeriesOutcome("EU_GasCon"), TimeSeriesOutcome("EU_OilSup"), TimeSeriesOutcome("EU_OilDem"), TimeSeriesOutcome("EU_OilCon"), TimeSeriesOutcome("EU_CoalSup"), TimeSeriesOutcome("EU_CoalDem"), TimeSeriesOutcome("EU_CoalCon"), TimeSeriesOutcome("EU_NucSup"), TimeSeriesOutcome("EU_NucDem"), # TimeSeriesOutcome("EU_NucCon"), TimeSeriesOutcome("EU_BioSup"), TimeSeriesOutcome("EU_BioDem"), TimeSeriesOutcome("EU_BioCon"), TimeSeriesOutcome("EU_ORSup"), TimeSeriesOutcome("EU_ORDem"), # TimeSeriesOutcome("EU_ORCon"), TimeSeriesOutcome("EU_EDem"), TimeSeriesOutcome("EU_ESup"), TimeSeriesOutcome("EU_GDP"), TimeSeriesOutcome("EU_CO2"), TimeSeriesOutcome("EU_RusGas"), TimeSeriesOutcome("EU_EUGI"), TimeSeriesOutcome("EU_GIC"), TimeSeriesOutcome("EU_RGperAG"), TimeSeriesOutcome("EU_RGperTES"), TimeSeriesOutcome("EU_RGperGC"), TimeSeriesOutcome("EU_GICperBBTU"), TimeSeriesOutcome("Oil_Price"), TimeSeriesOutcome("Coal_Price"), TimeSeriesOutcome("Bio_Price"), TimeSeriesOutcome("Gas_PriceE"), TimeSeriesOutcome("Nuc_PriceE"), TimeSeriesOutcome("OR_PriceE"), TimeSeriesOutcome("FuncpriceGas"), TimeSeriesOutcome("FuncpriceOil"), TimeSeriesOutcome("FuncpriceCoal") ] hybridmodel.levers = [ IntegerParameter("EnergyUnion", 0, 1), IntegerParameter("CO2Cost", 0, 1) ] # In[ ]: ema_logging.log_to_stderr(ema_logging.INFO) with MultiprocessingEvaluator(hybridmodel) as evaluator: results = evaluator.perform_experiments(scenarios=1, policies=4, levers_sampling='ff') # In[1]: save_results(results, r'./1000 runs V30.tar.gz')
# }) paraxes = parcoords.ParallelAxes(limits, rot=0) paraxes.plot(data) paraxes.fig.set_size_inches(25, 10) paraxes.legend() plt.show() paraxes.fig.savefig(os.path.join(fig_path, str(run) + '_v6__sc_disc_par_results2' + '.png')) # %% from ema_workbench.em_framework.optimization import (HyperVolume,EpsilonProgress) convergence_metrics = [HyperVolume(minimum=[0,0,0,0], maximum=[3, 2,1.01,1.01]), EpsilonProgress()] with MultiprocessingEvaluator(model) as evaluator: results, convergence = evaluator.optimize(nfe=1e3, searchover='levers', convergence=convergence_metrics, epsilons=[0.1,]*len(model.outcomes)) #%% from dicemodel.specs import nordhaus_policy, reference_scenario eps = [0.001, 0.1, 0.1, 0.1] * (int(len(dice_sm.outcomes)/4.0)) convergence_metrics = [EpsilonProgress()] nord_optimal_policy = Policy('nord_optimal_policy', **nordhaus_policy(np.mean(dice_opt.iloc[129]), 0.015, 0, 0, 29)) nfe = 100000 # Swtich to the worst case for outcome in dice_sm.outcomes: if outcome.kind == ScalarOutcome.MINIMIZE: outcome.kind = ScalarOutcome.MAXIMIZE else:
# .. codeauthor:: jhkwakkel if __name__ == '__main__': # turn on logging ema_logging.log_to_stderr(ema_logging.INFO) model = NetLogoModel('predprey', wd="./models/predatorPreyNetlogo", model_file="Wolf Sheep Predation.nlogo") model.run_length = 100 model.replications = 10 model.uncertainties = [RealParameter("grass-regrowth-time", 1, 99), RealParameter("initial-number-sheep", 50, 100), RealParameter("initial-number-wolves", 50, 100), RealParameter("sheep-reproduce", 5, 10), RealParameter("wolf-reproduce", 5, 10), ] model.outcomes = [TimeSeriesOutcome('sheep'), TimeSeriesOutcome('wolves'), TimeSeriesOutcome('grass')] # perform experiments n = 10 with MultiprocessingEvaluator(model, n_processes=2, maxtasksperchild=4) as evaluator: results = evaluator.perform_experiments(n)
df_unc['Max'] = df_unc['Reference'] * 1.5 vensimModel.uncertainties = [ RealParameter(row['Uncertainties'], row['Min'], row['Max']) for index, row in df_unc.iterrows() ] #vensimModel.outcomes = [TimeSeriesOutcome(out) for out in df_out['Outcomes']] vensimModel.outcomes = [ TimeSeriesOutcome('Total Agricultural and Land Use Emissions') ] sc = 0 n = 2500 vensimModel.constants = [Constant('SA Diet Composition Switch', sc)] with MultiprocessingEvaluator(vensimModel, n_processes=7) as evaluator: for sc in [0, 2, 3, 4]: start = time.time() results_sa = evaluator.perform_experiments( n, uncertainty_sampling=SOBOL, reporting_interval=5000) end = time.time() print("Experiments took {} seconds, {} hours.".format( end - start, (end - start) / 3600)) fn = './Diet_Sobol_n{}_sc{}_v4_2050.tar.gz'.format( n, sc ) #v2 is with narrow ranges for efficacy and removing some of the unimportant parameters #v3 is with the new multiplicative formulation, and new social norm parameters save_results(results_sa, fn) #
def runMoea(model, params, fileEnd, reference=None, refNum=None): archiveName = 'archives_' + fileEnd convergenceName = 'convergences_' + fileEnd if not params.createNewOptimizationResults: print('Loading archives from ' + params.optimizeOutputFolder + archiveName + '.csv') print('Loading convergences from ' + params.optimizeOutputFolder + convergenceName + '.csv') archives = pd.read_csv(params.optimizeOutputFolder + archiveName + '.csv', index_col=0) convergences = pd.read_csv(params.optimizeOutputFolder + convergenceName + '.csv', index_col=0) return (archives, convergences) archs = [] convs = [] if not os.path.exists(params.optimizeOutputFolder): os.makedirs(params.optimizeOutputFolder) tmpfolder = params.optimizeOutputFolder + model.name + '/' if not os.path.exists(tmpfolder): os.makedirs(tmpfolder) with MultiprocessingEvaluator(model) as evaluator: for i in range(params.numberOptimizationRepetitions): print('Optimizing Run ', i) if params.name == 'mordm': convergences = [ HyperVolume(minimum=[0, 0, 0, 0], maximum=[2.5, 2, 1, 1]), EpsilonProgress() ] else: convergences = [ HyperVolume(minimum=[0, 0, 0, 0], maximum=[10, 2, 1, 1]), EpsilonProgress() ] if (params.algoName == 'NSGAIIHybrid'): for j, name in enumerate(['SBX', 'PCX', 'DE', 'UNDX', 'UM']): Convergence.valid_metrics.add(name) convergences.append(OperatorProbabilities(name, j)) arch, conv = evaluator.optimize(algorithm=params.algorithm, nfe=params.nfeOptimize[model.name], searchover='levers', reference=reference, epsilons=params.epsilons, convergence=convergences, population_size=100) conv['run_index'] = i arch['run_index'] = i if refNum is not None: conv['reference_scenario'] = refNum arch['reference_scenario'] = refNum conv.to_csv(tmpfolder + convergenceName + '_' + str(i) + '.csv') arch.to_csv(tmpfolder + archiveName + '_' + str(i) + '.csv') convs.append(conv) archs.append(arch) archives = pd.concat(archs) convergences = pd.concat(convs) archives.to_csv(params.optimizeOutputFolder + archiveName + '.csv') convergences.to_csv(params.optimizeOutputFolder + convergenceName + '.csv') return (archives, convergences)
for k, dam in enumerate(dams): for j in range(12): l.append(RealParameter(dam[0][j], minimum[k], maximum[k])) l.append(RealParameter(dam[1][j], 0, 1)) l.append(RealParameter(dam[2][j], 0, 1)) basin_model.levers = l basin_model.outcomes = [ ScalarOutcome('pwsobjective', kind=ScalarOutcome.MINIMIZE, expected_range=(1, 33.3)), ScalarOutcome('energyobjective', kind=ScalarOutcome.MAXIMIZE, expected_range=(641, 3291)), ScalarOutcome('virobjective', kind=ScalarOutcome.MINIMIZE, expected_range=(315, 1341)) ] #ScalarOutcome('firobjective', kind=ScalarOutcome.MINIMIZE), convergence_metrics = [ HyperVolume.from_outcomes(basin_model.outcomes), EpsilonProgress() ] with MultiprocessingEvaluator(basin_model, 3) as evaluator: #results, convergence=evaluator.optimize(nfe=1, searchover='levers', #epsilons=[0.1, 0.1, 0.1], #convergence=convergence_metrics, reference=None)#constraints=m) experiments, outcomes = evaluator.perform_experiments(policies=3)
def runMoea(model, params, fileEnd, refNum=-1): archiveName = 'archives_' + fileEnd convergenceName = 'convergences_' + fileEnd if not params.createNewOptimizationResults: print('Loading archives from ' + params.optimizeOutputFolder + archiveName + '.csv') print('Loading convergences from ' + params.optimizeOutputFolder + convergenceName + '.csv') archives = pd.read_csv(params.optimizeOutputFolder + archiveName + '.csv', index_col=0) convergences = pd.read_csv(params.optimizeOutputFolder + convergenceName + '.csv', index_col=0) return (archives, convergences) archs = [] convs = [] if not os.path.exists(params.optimizeOutputFolder): os.makedirs(params.optimizeOutputFolder) tmpfolder = params.optimizeOutputFolder + model.name + '/' if not os.path.exists(tmpfolder): os.makedirs(tmpfolder) with MultiprocessingEvaluator(model) as evaluator: for i in range(params.numberOptimizationRepetitions): print('Run ', i) convergence_metrics = [ HyperVolume(minimum=[0, 0, 0, 0], maximum=[1, 1, 1, 1]), EpsilonProgress() ] if (params.algoName == 'NSGAIIHybrid'): for j, name in enumerate(['SBX', 'PCX', 'DE', 'UNDX', 'UM']): Convergence.valid_metrics.add(name) convergence_metrics.append(OperatorProbabilities(name, j)) arch, conv = evaluator.robust_optimize( robustnessFunctions, params.optimizationScenarios, algorithm=params.algorithm, nfe=params.nfeOptimize[model.name], constraints=[], epsilons=params.epsilons, convergence=convergence_metrics) arch['run_index'] = i conv['run_index'] = i archs.append(arch) convs.append(conv) arch.to_csv(tmpfolder + archiveName + '_' + str(i) + '.csv') conv.to_csv(tmpfolder + convergenceName + '_' + str(i) + '.csv') archives = pd.concat(archs) convergences = pd.concat(convs) archives.to_csv(params.optimizeOutputFolder + archiveName + '.csv') convergences.to_csv(params.optimizeOutputFolder + convergenceName + '.csv') return (archives, convergences)
def test_robust_evaluation(self): # %% import os test_dir = os.path.dirname(__file__) from ema_workbench import ema_logging, MultiprocessingEvaluator, SequentialEvaluator from emat.examples import road_test import numpy, pandas, functools from emat import Measure s, db, m = road_test() MAXIMIZE = Measure.MAXIMIZE MINIMIZE = Measure.MINIMIZE robustness_functions = [ Measure( 'Expected Net Benefit', kind=Measure.INFO, variable_name='net_benefits', function=numpy.mean, ), Measure( 'Probability of Net Loss', kind=MINIMIZE, variable_name='net_benefits', function=lambda x: numpy.mean(x < 0), min=0, max=1, ), Measure( '95%ile Travel Time', kind=MINIMIZE, variable_name='build_travel_time', function=functools.partial(numpy.percentile, q=95), min=60, max=150, ), Measure( '99%ile Present Cost', kind=Measure.INFO, variable_name='present_cost_expansion', function=functools.partial(numpy.percentile, q=99), ), Measure( 'Expected Present Cost', kind=Measure.INFO, variable_name='present_cost_expansion', function=numpy.mean, ), ] # %% numpy.random.seed(42) with MultiprocessingEvaluator(m) as evaluator: r1 = m.robust_evaluate( robustness_functions, scenarios=20, policies=5, evaluator=evaluator, ) import pandas correct = pandas.read_json( '{"amortization_period":{"0":19,"1":23,"2":50,"3":43,"4":35},"debt_type":{"0":"Rev Bond","1":"Paygo"' ',"2":"GO Bond","3":"Paygo","4":"Rev Bond"},"expand_capacity":{"0":26.3384401031,"1":63.3898549337,"2' '":51.1360252492,"3":18.7230954832,"4":93.9205959335},"interest_rate_lock":{"0":false,"1":true,"2":fal' 'se,"3":true,"4":false},"Expected Net Benefit":{"0":-157.486494925,"1":-244.2423401934,"2":-189.633908' '4553,"3":-4.2656265778,"4":-481.1208898635},"Probability of Net Loss":{"0":0.95,"1":1.0,"2":0.95,"3":' '0.7,"4":1.0},"95%ile Travel Time":{"0":74.6904209781,"1":65.8492894317,"2":67.6932507947,"3":79.09851' '23853,"4":63.203313888},"99%ile Present Cost":{"0":3789.8036648358,"1":9121.0832380586,"2":7357.89572' '71441,"3":2694.0416972887,"4":13514.111590462},"Expected Present Cost":{"0":3158.4461451444,"1":7601.' '5679809722,"2":6132.1164500957,"3":2245.2312484183,"4":11262.7453643551}}') correct['debt_type'] = correct['debt_type'].astype( pandas.CategoricalDtype(categories=['GO Bond', 'Rev Bond', 'Paygo'], ordered=True)) pandas.testing.assert_frame_equal(r1, correct) numpy.random.seed(7) from ema_workbench.em_framework.samplers import sample_uncertainties scenes = sample_uncertainties(m, 20) scenes0 = pandas.DataFrame(scenes) cachefile = os.path.join(test_dir,'test_robust_results.csv') if not os.path.exists(cachefile): scenes0.to_csv(os.path.join(test_dir,'test_robust_evaluation_scenarios.csv'), index=None) scenes1 = pandas.read_csv(os.path.join(test_dir,'test_robust_evaluation_scenarios.csv')) pandas.testing.assert_frame_equal(scenes0, scenes1) from emat import Constraint constraint_1 = Constraint( "Maximum Log Expected Present Cost", outcome_names="Expected Present Cost", function=Constraint.must_be_less_than(4000), ) constraint_2 = Constraint( "Minimum Capacity Expansion", parameter_names="expand_capacity", function=Constraint.must_be_greater_than(10), ) constraint_3 = Constraint( "Maximum Paygo", parameter_names='debt_type', outcome_names='99%ile Present Cost', function=lambda i, j: max(0, j - 1500) if i == 'Paygo' else 0, ) from emat.optimization import HyperVolume, EpsilonProgress, SolutionViewer, ConvergenceMetrics convergence_metrics = ConvergenceMetrics( HyperVolume.from_outcomes(robustness_functions), EpsilonProgress(), SolutionViewer.from_model_and_outcomes(m, robustness_functions), ) numpy.random.seed(8) random.seed(8) # Test robust optimize with SequentialEvaluator(m) as evaluator: robust_results, convergence = m.robust_optimize( robustness_functions, scenarios=scenes, nfe=25, constraints=[ constraint_1, constraint_2, constraint_3, ], epsilons=[0.05,]*len(robustness_functions), convergence=convergence_metrics, evaluator=evaluator, ) cachefile = os.path.join(test_dir,'test_robust_results.csv') if not os.path.exists(cachefile): robust_results.to_csv(cachefile, index=None) correct2 = pandas.read_csv(cachefile) correct2['debt_type'] = correct2['debt_type'].astype( pandas.CategoricalDtype(categories=['GO Bond', 'Rev Bond', 'Paygo'], ordered=True)) pandas.testing.assert_frame_equal(robust_results, correct2, check_less_precise=True)
def optimize_lake_problem(use_original_R_metrics=False, demo=True): """Analysis of the Lake Problem. (1) Runs a multi-objective robust optimisation of the Lake Problem using both standard and custom robustness metrics; (2) analyses the effects of different sets of scenarios on the robustness values and robustness rankings; (3) plots these effects; (4) analyses the effects of different robustness metrics on the robustness values and robustness rankings; and (5) plots these effects. """ filepath = './robust_results.h5' robustness_functions = (get_original_R_metrics() if use_original_R_metrics else get_custom_R_metrics_for_workbench()) lake_model = get_lake_model() if not os.path.exists(filepath): n_scenarios = 10 if demo else 200 # for demo purposes only, should in practice be higher scenarios = sample_uncertainties(lake_model, n_scenarios) nfe = 1000 if demo else 50000 # number of function evaluations # Needed on Linux-based machines multiprocessing.set_start_method('spawn', True) # Run optimisation with MultiprocessingEvaluator(lake_model) as evaluator: robust_results = evaluator.robust_optimize( robustness_functions, scenarios, nfe=nfe, population_size=(10 if demo else 50), epsilons=[ 0.1, ] * len(robustness_functions)) print(robust_results) robust_results = pd.read_hdf(filepath, key='df') # Results are performance in each timestep, followed by robustness # we only care about the robustness, so we get that col_names = robust_results.columns.values.tolist() col_names = col_names[-len(robustness_functions):] # Plot the robustness results sns.pairplot(robust_results, vars=col_names, diag_kind='kde') # plt.show() # Extract the decision alternatives from the results # We need to extract the decision alternatives decision_alternatives = robust_results.iloc[:, :-4].values decision_alternatives = [ Policy( idx, **{ str(idx): value for idx, value in enumerate( decision_alternatives[idx].tolist()) }) for idx in range(decision_alternatives.shape[0]) ] # Find the influence of scenarios. Here we are creating 5 # sets of 100 scenarios each, all using the same sampling # method. scenarios_per_set = 100 n_sets = 5 n_scenarios = scenarios_per_set * n_sets scenarios = sample_uncertainties(lake_model, n_scenarios) # Simulate optimal solutions across all scenarios with MultiprocessingEvaluator(lake_model) as evaluator: results = evaluator.perform_experiments(scenarios=scenarios, policies=decision_alternatives) # We will just look at the vulnerability ('max_P') for this example f = np.reshape(results[1]['max_P'], newshape=(-1, n_scenarios)) # Split the results into the different sets of scenarios split_f = np.split(f, n_sets, axis=1) # Calculate robustness for each set of scenarios # Note that each split_f[set_idx] is a 2D array, with each row being # a decision alternative, and each column a scenario R_metric = get_custom_R_metrics()[0] R = [R_metric(split_f[set_idx]) for set_idx in range(n_sets)] R = np.transpose(R) # Calculate similarity in robustness from different scenario sets delta, tau = analysis.scenarios_similarity(R) # Plot the deltas using a helper function analysis.delta_plot(delta) # Plot the Kendall's tau-b values using a helper function analysis.tau_plot(tau) # We now want to test the effects of different robustness metrics, # across all of the 100 scenarios. We first define a few new # robustness metrics (in addition to our original R metric for # the vulnerability). For this example we use some classic metrics R_metrics = [ R_metric, # The original robustness metric functools.partial(metrics.maximax, maximise=False), functools.partial(metrics.laplace, maximise=False), functools.partial(metrics.minimax_regret, maximise=False), functools.partial(metrics.percentile_kurtosis, maximise=False) ] # Calculate robustness for each robustness metric R = np.transpose([R_metric(f) for R_metric in R_metrics]) # Calculate similarity in robustness from different robustness metrics tau = analysis.R_metric_similarity(R) # Plot the Kendall's tau-b values using a helper function analysis.tau_plot(tau)
RICE.uncertainties = [ IntegerParameter('fdamage', 0, 2), IntegerParameter('t2xco2_index', 0, 999), IntegerParameter('t2xco2_dist', 0, 2), RealParameter('fosslim', 4000, 13649), IntegerParameter('scenario_pop_gdp', 0, 5), IntegerParameter('scenario_sigma', 0, 2), IntegerParameter('scenario_cback', 0, 1), IntegerParameter('scenario_elasticity_of_damages', 0, 2), IntegerParameter('scenario_limmiu', 0, 1) ] #same for all formulations RICE.outcomes = get_all_model_outcomes_uncertainty_search( optimization_formulation="utilitarian") ema_logging.log_to_stderr(ema_logging.INFO) #only needed on IPython console within Anaconda __spec__ = "ModuleSpec(name='builtins', loader=<class '_frozen_importlib.BuiltinImporter'>)" with MultiprocessingEvaluator(RICE) as evaluator: results = evaluator.perform_experiments( scenarios=nfe, policies=total_policy_list[principle_index]) file_name = "//root//util_gen//server//output//uncertainty_analsysis_" + principles_list[ principle_index] + "_runs_" + str(nfe) + ".tar.gz" save_results(results, file_name) print("uncertainty cycle " + principles_list[principle_index] + " completed")
##################################################################################################### from ema_workbench import Policy # performing experiments # generate experiments n_scenarios = 1000 n_policies = 4 policy = Policy("no release", **{l.name: 0 for l in model.levers}) from ema_workbench import (MultiprocessingEvaluator, ema_logging, perform_experiments) ema_logging.log_to_stderr(ema_logging.INFO) if __name__ == '__main__': freeze_support() with MultiprocessingEvaluator(model, n_processes=7) as evaluator: results = evaluator.perform_experiments(scenarios=1000, policies=4, levers_sampling=MC) ##################################################################################################### # process the results of the experiments experiments, outcomes = results print(experiments.shape) print(list(outcomes.keys())) stop = time.time() print(f"Runtime in minutes: { ((stop-start)/60) }") from ema_workbench.analysis import pairs_plotting
def test_robust_evaluation(self): # %% import os test_dir = os.path.dirname(__file__) from ema_workbench import ema_logging, MultiprocessingEvaluator, SequentialEvaluator from emat.examples import road_test import numpy, pandas, functools from emat import Measure s, db, m = road_test() MAXIMIZE = Measure.MAXIMIZE MINIMIZE = Measure.MINIMIZE robustness_functions = [ Measure( 'Expected Net Benefit', kind=Measure.INFO, variable_name='net_benefits', function=numpy.mean, ), Measure( 'Probability of Net Loss', kind=MINIMIZE, variable_name='net_benefits', function=lambda x: numpy.mean(x < 0), min=0, max=1, ), Measure( '95%ile Travel Time', kind=MINIMIZE, variable_name='build_travel_time', function=functools.partial(numpy.percentile, q=95), min=60, max=150, ), Measure( '99%ile Present Cost', kind=Measure.INFO, variable_name='present_cost_expansion', function=functools.partial(numpy.percentile, q=99), ), Measure( 'Expected Present Cost', kind=Measure.INFO, variable_name='present_cost_expansion', function=numpy.mean, ), ] # %% numpy.random.seed(42) with MultiprocessingEvaluator(m) as evaluator: r1 = m.robust_evaluate( robustness_functions, scenarios=20, policies=5, evaluator=evaluator, ) stable_df('./road_test_robust_evaluate.pkl.gz', r1) numpy.random.seed(7) from ema_workbench.em_framework.samplers import sample_uncertainties scenes = sample_uncertainties(m, 20) scenes0 = pandas.DataFrame(scenes) stable_df('./test_robust_evaluation_scenarios.pkl.gz', scenes0) from emat import Constraint constraint_1 = Constraint( "Maximum Log Expected Present Cost", outcome_names="Expected Present Cost", function=Constraint.must_be_less_than(4000), ) constraint_2 = Constraint( "Minimum Capacity Expansion", parameter_names="expand_capacity", function=Constraint.must_be_greater_than(10), ) constraint_3 = Constraint( "Maximum Paygo", parameter_names='debt_type', outcome_names='99%ile Present Cost', function=lambda i, j: max(0, j - 1500) if i == 'Paygo' else 0, ) from emat.optimization import HyperVolume, EpsilonProgress, SolutionViewer, ConvergenceMetrics convergence_metrics = ConvergenceMetrics( HyperVolume.from_outcomes(robustness_functions), EpsilonProgress(), SolutionViewer.from_model_and_outcomes(m, robustness_functions), ) numpy.random.seed(8) random.seed(8) # Test robust optimize with SequentialEvaluator(m) as evaluator: robust = m.robust_optimize( robustness_functions, scenarios=scenes, nfe=25, constraints=[ constraint_1, constraint_2, constraint_3, ], epsilons=[ 0.05, ] * len(robustness_functions), convergence=convergence_metrics, evaluator=evaluator, ) robust_results, convergence = robust.result, robust.convergence stable_df('test_robust_results.pkl.gz', robust_results)