Esempio n. 1
0
    # specify uncertainties
    lake_model.uncertainties = [
        RealParameter("b", 0.1, 0.45),
        RealParameter("q", 2.0, 4.5),
        RealParameter("mean", 0.01, 0.05),
        RealParameter("stdev", 0.001, 0.005),
        RealParameter("delta", 0.93, 0.99),
    ]

    # set levers, one for each time step
    lake_model.levers = [RealParameter(str(i), 0, 0.1) for i in range(lake_model.time_horizon)]

    # specify outcomes
    lake_model.outcomes = [
        ScalarOutcome("max_P"),
        ScalarOutcome("utility"),
        ScalarOutcome("inertia"),
        ScalarOutcome("reliability"),
    ]

    # override some of the defaults of the model
    lake_model.constants = [Constant("alpha", 0.41), Constant("nsamples", 150)]

    # generate some random policies by sampling over levers
    policies = samplers.sample_levers(lake_model, 4, sampler=samplers.MonteCarloSampler(), name=util.counter)

    # perform experiments
    nr_experiments = 100

    results = perform_experiments(lake_model, nr_experiments, policies, parallel=True)
Esempio n. 2
0
        self.uncertainties = [LookupUncertainty('hearne2', [(-1, 3), (-2, 1), (0, 0.9), (0.1, 1), (0.99, 1.01), (0.99, 1.01)],
                                                "accomplishments per hour lookup", self, 0, 1),
                              LookupUncertainty('hearne2', [(-0.75, 0.75), (-0.75, 0.75), (0, 1.5), (0.1, 1.6), (-0.3, 1.5), (0.25, 2.5)],
                                                "fractional change in expectations from perceived adequacy lookup", self, -1, 1),
                              LookupUncertainty('hearne2', [(-2, 2), (-1, 2), (0, 1.5), (0.1, 1.6), (0.5, 2), (0.5, 2)],
                                                "effect of perceived adequacy on energy drain lookup", self, 0, 10),
                              LookupUncertainty('hearne2', [(-2, 2), (-1, 2), (0, 1.5), (0.1, 1.6), (0.5, 1.5), (0.1, 2)],
                                                "effect of perceived adequacy of hours worked lookup", self, 0, 2.5),
                              LookupUncertainty('hearne2', [(-1, 1), (-1, 1), (0, 0.9), (0.1, 1), (0.5, 1.5), (1, 1.5)],
                                                "effect of energy levels on hours worked lookup", self, 0, 1.5),
                              LookupUncertainty('hearne2', [(-1, 1), (-1, 1), (0, 0.9), (0.1, 1), (0.5, 1.5), (1, 1.5)],
                                                "effect of high energy on further recovery lookup", self, 0, 1.25),
                              LookupUncertainty('hearne2', [(-2, 2), (-1, 1), (0, 100), (20, 120), (0.5, 1.5), (0.5, 2)],
                                                "effect of hours worked on energy recovery lookup", self, 0, 1.5),
                              LookupUncertainty('approximation', [(-0.5, 0.35), (3, 5), (1, 10), (0.2, 0.4), (0, 120)],
                                                "effect of hours worked on energy drain lookup", self, 0, 3),
                              LookupUncertainty('hearne1', [(0, 1), (0, 0.15), (1, 1.5), (0.75, 1.25)],
                                                "effect of low energy on further depletion lookup", self, 0, 1)]

        self._delete_lookup_uncertainties()


if __name__ == "__main__":
    ema_logging.log_to_stderr(ema_logging.INFO)
    model = Burnout(r'./models/burnout', "burnout")

    # run policy with old cases
    results = perform_experiments(model, 100)
    lines(results, 'Energy Level', density=BOXPLOT)
    plt.show()
Esempio n. 3
0
This file illustrated the use the EMA classes for a contrived vensim
example


.. codeauthor:: jhkwakkel <j.h.kwakkel (at) tudelft (dot) nl>
                chamarat <c.hamarat (at) tudelft (dot) nl>
'''
from __future__ import (division, unicode_literals, absolute_import,
                        print_function)

from ema_workbench import (TimeSeriesOutcome, perform_experiments,
                           RealParameter, ema_logging)

from ema_workbench.connectors.vensim import VensimModel

if __name__ == "__main__":
    # turn on logging
    ema_logging.log_to_stderr(ema_logging.INFO)

    # instantiate a model
    wd = './models/vensim example'
    vensimModel = VensimModel("simpleModel", wd=wd, model_file='model.vpm')
    vensimModel.uncertainties = [
        RealParameter("x11", 0, 2.5),
        RealParameter("x12", -2.5, 2.5)
    ]

    vensimModel.outcomes = [TimeSeriesOutcome('a')]

    results = perform_experiments(vensimModel, 1000)
Esempio n. 4
0
                        wd=r'./models/flu',
                        model_file=r'/FLUvensimV1basecase.vpm')

    #outcomes
    model.outcomes = [
        TimeSeriesOutcome('deceased population region 1'),
        TimeSeriesOutcome('infected fraction R1'),
        ScalarOutcome('max infection fraction',
                      variable_name='infected fraction R1',
                      function=np.max),
        ScalarOutcome('time of max',
                      variable_name=['infected fraction R1', 'TIME'],
                      function=time_of_max)
    ]

    #create uncertainties based on csv
    model.uncertainties = create_parameters(
        './models/flu/flu_uncertainties.csv')

    #add policies
    policies = [
        Policy('no policy', model_file=r'/FLUvensimV1basecase.vpm'),
        Policy('static policy', model_file=r'/FLUvensimV1static.vpm'),
        Policy('adaptive policy', model_file=r'/FLUvensimV1dynamic.vpm')
    ]

    results = perform_experiments(model,
                                  1000,
                                  policies=policies,
                                  parallel=True)
        RealParameter('additional seasonal immune population fraction R2', 0, 0.5),
        RealParameter('fatality ratio region 1', 0.0001, 0.1),
        RealParameter('fatality rate region 2', 0.0001, 0.1),
        RealParameter('initial immune fraction of the population of region 1', 0, 0.5),
        RealParameter('initial immune fraction of the population of region 2', 0, 0.5),
        RealParameter('normal interregional contact rate', 0, 0.9),
        RealParameter('permanent immune population fraction R1', 0, 0.5),
        RealParameter('permanent immune population fraction R2', 0, 0.5),
        RealParameter('recovery time region 1', 0.1, 0.75),
        RealParameter('recovery time region 2', 0.1, 0.75),
        RealParameter('susceptible to immune population delay time region 1', 0.5, 2),
        RealParameter('susceptible to immune population delay time region 2', 0.5, 2),
        RealParameter('root contact rate region 1', 0.01, 5),
        RealParameter('root contact ratio region 2', 0.01, 5),
        RealParameter('infection ratio region 1', 0, 0.15),
        RealParameter('infection rate region 2', 0, 0.15),
        RealParameter('normal contact rate region 1', 10, 100),
        RealParameter('normal contact rate region 2', 10, 200)]
 
    #add policies
    policies = [Policy('no policy',
                       model_file=r'FLUvensimV1basecase.vpm'),
                Policy('static policy',
                       model_file=r'FLUvensimV1static.vpm'),
                Policy('adaptive policy',
                       model_file=r'FLUvensimV1dynamic.vpm')
                ]
     
     
    results = perform_experiments(model, 1000, policies=policies)
Esempio n. 6
0
    def run_experiments(
        self,
        design: pd.DataFrame = None,
        evaluator=None,
        *,
        design_name=None,
        db=None,
    ):
        """
        Runs a design of combined experiments using this model.

        A combined experiment includes a complete set of input values for
        all exogenous uncertainties (a Scenario) and all policy levers
        (a Policy). Unlike the perform_experiments function in the EMA Workbench,
        this method pairs each Scenario and Policy in sequence, instead
        of running all possible combinations of Scenario and Policy.
        This change ensures compatibility with the EMAT database modules, which
        preserve the complete set of input information (both uncertainties
        and levers) for each experiment.  To conduct a full cross-factorial set
        of experiments similar to the default settings for EMA Workbench,
        use a factorial design, by setting the `jointly` argument for the
        `design_experiments` to False, or by designing experiments outside
        of EMAT with your own approach.

        Args:
            design (pandas.DataFrame, optional): experiment definitions
                given as a DataFrame, where each exogenous uncertainties and
                policy levers is given as a column, and each row is an experiment.
            evaluator (ema_workbench.Evaluator, optional): Optionally give an
                evaluator instance.  If not given, a default SequentialEvaluator
                will be instantiated.
            design_name (str, optional): The name of a design of experiments to
                load from the database.  This design is only used if
                `design` is None.
            db (Database, optional): The database to use for loading and saving experiments.
                If none is given, the default database for this model is used.
                If there is no default db, and none is given here,
                the results are not stored in a database. Set to False to explicitly
                not use the default database, even if it exists.

        Returns:
            pandas.DataFrame:
                A DataFrame that contains all uncertainties, levers, and measures
                for the experiments.

        Raises:
            ValueError:
                If there are no experiments defined.  This includes
                the situation where `design` is given but no database is
                available.

        """

        from ema_workbench import Scenario, Policy, perform_experiments

        # catch user gives only a design, not experiment_parameters
        if isinstance(design, str) and design_name is None:
            design_name, design = design, None

        if design_name is None and design is None:
            raise ValueError(f"must give design_name or design")

        if db is None:
            db = self.db

        if design_name is not None and design is None:
            if not db:
                raise ValueError(
                    f'cannot load design "{design_name}", there is no db')
            design = db.read_experiment_parameters(self.scope.name,
                                                   design_name)

        if design.empty:
            raise ValueError(f"no experiments available")

        scenarios = [
            Scenario(**dict(zip(self.scope.get_uncertainty_names(), i)))
            for i in design[self.scope.get_uncertainty_names()].itertuples(
                index=False, name='ExperimentX')
        ]

        policies = [
            Policy(f"Incognito{n}", **dict(zip(self.scope.get_lever_names(),
                                               i)))
            for n, i in enumerate(design[self.scope.get_lever_names()].
                                  itertuples(index=False, name='ExperimentL'))
        ]

        if not evaluator:
            from ema_workbench import SequentialEvaluator
            evaluator = SequentialEvaluator(self)

        experiments, outcomes = perform_experiments(
            self,
            scenarios=scenarios,
            policies=policies,
            zip_over={'scenarios', 'policies'},
            evaluator=evaluator)
        experiments.index = design.index

        outcomes = pd.DataFrame.from_dict(outcomes)
        outcomes.index = design.index

        if db:
            db.write_experiment_measures(self.scope.name, self.metamodel_id,
                                         outcomes)

        return self.ensure_dtypes(
            pd.concat([
                experiments.drop(columns=['scenario', 'policy', 'model']),
                outcomes
            ],
                      axis=1,
                      sort=False))
                        model_file=r'/FLUvensimV1basecase.vpm')

    # outcomes
    model.outcomes = [
        TimeSeriesOutcome('deceased population region 1'),
        TimeSeriesOutcome('infected fraction R1'),
        ScalarOutcome('max infection fraction',
                      variable_name='infected fraction R1',
                      function=np.max),
        ScalarOutcome('time of max',
                      variable_name=['infected fraction R1', 'TIME'],
                      function=time_of_max)
    ]

    # create uncertainties based on csv
    model.uncertainties = create_parameters(
        './models/flu/flu_uncertainties.csv')

    # add policies
    policies = [
        Policy('no policy', model_file=r'/FLUvensimV1basecase.vpm'),
        Policy('static policy', model_file=r'/FLUvensimV1static.vpm'),
        Policy('adaptive policy', model_file=r'/FLUvensimV1dynamic.vpm')
    ]

    with MultiprocessingEvaluator(model, 2) as evaluator:
        results = perform_experiments(model,
                                      1000,
                                      policies=policies,
                                      evaluator == evaluator)
Esempio n. 8
0
        ArrayOutcome('y3'),
        ScalarOutcome('y4'),
        ScalarOutcome('y5'),
        ScalarOutcome('y6'),
        ScalarOutcome('y7')
    ]

    # override some of the defaults of the model
    model.constants = [
        Constant("X4rSnow", 0.7),
        Constant("xCostDay", 6),
        Constant("xRevenueDay", 10)
    ]

    #results = perform_experiments(model, 1500, 5)
    results = perform_experiments(model, 200, 20)

    #with MultiprocessingEvaluator(model, n_processes=4) as evaluator:
    #    results = evaluator.perform_experiments(scenarios=4, policies=5)

print('end!')
training_time = time.time() - start_time

print("--- %s seconds ---" % (training_time))
print('training time : {} mins and {} seconds'.format(
    (training_time // 60), round((training_time % 60), 1)))
print('training time : {} hours {} mins and {} seconds '.format(
    training_time // 3600, round((training_time % 3600 // 60), 1),
    round((training_time % 3600) % 60, 1)))
# Save the outputs
from ema_workbench import save_results
    model = VensimModel("fluCase", wd=r'./models/flu',
                        model_file=r'/FLUvensimV1basecase.vpm')

    # outcomes
    model.outcomes = [TimeSeriesOutcome('deceased population region 1'),
                      TimeSeriesOutcome('infected fraction R1'),
                      ScalarOutcome('max infection fraction',
                                    variable_name='infected fraction R1',
                                    function=np.max),
                      ScalarOutcome('time of max',
                                    variable_name=[
                                        'infected fraction R1', 'TIME'],
                                    function=time_of_max)]

    # create uncertainties based on csv
    model.uncertainties = create_parameters(
        './models/flu/flu_uncertainties.csv')

    # add policies
    policies = [Policy('no policy',
                       model_file=r'/FLUvensimV1basecase.vpm'),
                Policy('static policy',
                       model_file=r'/FLUvensimV1static.vpm'),
                Policy('adaptive policy',
                       model_file=r'/FLUvensimV1dynamic.vpm')
                ]

    with MultiprocessingEvaluator(model, 2) as evaluator:
        results = perform_experiments(model, 1000, policies=policies,
                                      evaluator == evaluator)
Esempio n. 10
0
    model = VensimModel("fluCase", wd=r'./models/flu',
                        model_file = r'/FLUvensimV1basecase.vpm')
            
    #outcomes
    model.outcomes = [TimeSeriesOutcome('deceased population region 1'),
                      TimeSeriesOutcome('infected fraction R1'),
                      ScalarOutcome('max infection fraction', 
                                    variable_name='infected fraction R1', 
                                    function=np.max),
                      ScalarOutcome('time of max', 
                                    variable_name=['infected fraction R1', 'TIME'], 
                                    function=time_of_max)]
    
    #create uncertainties based on csv 
    model.uncertainties = create_parameters('./models/flu/flu_uncertainties.csv') 
    
    #add policies
    policies = [Policy('no policy',
                       model_file=r'/FLUvensimV1basecase.vpm'),
                Policy('static policy',
                       model_file=r'/FLUvensimV1static.vpm'),
                Policy('adaptive policy',
                       model_file=r'/FLUvensimV1dynamic.vpm')
                ]
     
     
    results = perform_experiments(model, 1000, policies=policies, 
                                  parallel=True)

Esempio n. 11
0
This file illustrated the use the EMA classes for a contrived vensim
example


.. codeauthor:: jhkwakkel <j.h.kwakkel (at) tudelft (dot) nl>
                chamarat <c.hamarat (at) tudelft (dot) nl>
'''
from __future__ import (division, unicode_literals, absolute_import,
                        print_function)

from ema_workbench import (TimeSeriesOutcome, perform_experiments,
                           RealParameter, ema_logging)

from ema_workbench.connectors.vensim import VensimModel

if __name__ == "__main__":
    #turn on logging
    ema_logging.log_to_stderr(ema_logging.INFO)

    #instantiate a model
    wd = r'./models/vensim example'
    vensimModel = VensimModel("simpleModel", wd=wd, model_file=r'\model.vpm')
    vensimModel.uncertainties = [
        RealParameter("x11", 0, 2.5),
        RealParameter("x12", -2.5, 2.5)
    ]

    vensimModel.outcomes = [TimeSeriesOutcome('a')]

    results = perform_experiments(vensimModel, 1000, parallel=True)
Esempio n. 12
0
        RealParameter('fatality rate region 2', 0.0001, 0.1),
        RealParameter('initial immune fraction of the population of region 1',
                      0, 0.5),
        RealParameter('initial immune fraction of the population of region 2',
                      0, 0.5),
        RealParameter('normal interregional contact rate', 0, 0.9),
        RealParameter('permanent immune population fraction R1', 0, 0.5),
        RealParameter('permanent immune population fraction R2', 0, 0.5),
        RealParameter('recovery time region 1', 0.1, 0.75),
        RealParameter('recovery time region 2', 0.1, 0.75),
        RealParameter('susceptible to immune population delay time region 1',
                      0.5, 2),
        RealParameter('susceptible to immune population delay time region 2',
                      0.5, 2),
        RealParameter('root contact rate region 1', 0.01, 5),
        RealParameter('root contact ratio region 2', 0.01, 5),
        RealParameter('infection ratio region 1', 0, 0.15),
        RealParameter('infection rate region 2', 0, 0.15),
        RealParameter('normal contact rate region 1', 10, 100),
        RealParameter('normal contact rate region 2', 10, 200)
    ]

    # add policies
    policies = [
        Policy('no policy', model_file=r'FLUvensimV1basecase.vpm'),
        Policy('static policy', model_file=r'FLUvensimV1static.vpm'),
        Policy('adaptive policy', model_file=r'FLUvensimV1dynamic.vpm')
    ]

    results = perform_experiments(model, 1000, policies=policies)
Esempio n. 13
0
# initiate ETM connection
ref_scenario = 769771
ETM = init_ETM(ref_scenario, metrics)

# override some of the defaults of the model
model.constants = [
    # standard = 1920 hours / year
    Constant("ETM_instance", ETM),
    Constant("flh_of_energy_power_wind_turbine_inland", 3000),
    Constant("flh_of_solar_pv_solar_radiation", 1000),  # standard = 867 / year
    Constant("costs_co2", 100),  # standard = 8 €/tonne
    Constant("total_supply", 55e6),  # MWh 35e6 minimum, RES 1.0 55e6
]

results = perform_experiments(model, policies=25)

experiments, outcomes = results

policies = experiments["policy"]
for i, policy in enumerate(np.unique(policies)):
    experiments.loc[policies == policy, "policy"] = str(i)

data = pd.DataFrame(outcomes)
data["solarVSwind"] = experiments["solarVSwind"]

#%% plotting section
colors = sns.color_palette("Set2", len(data.columns))
sns.set_style("whitegrid")

Esempio n. 14
0
#specify uncertainties
criticality_model.uncertainties = [
    IntegerParameter('det_idx', 1, 3),
    RealParameter('od_exp', 0.75, 1.5),
    RealParameter('od_loc1', 0.75, 1.5),
    RealParameter('od_loc2', 0.75, 1.5),
    RealParameter('od_loc3', 0.75, 1.5),
    RealParameter('od_loc4', 0.75, 1.5),
    RealParameter('theta', 30, 70),
    RealParameter('beta', 0.25, 0.75),
    RealParameter('cutoff', 0.025, 0.075),
    RealParameter('m10_buffer', 0.0025, 0.0075),
    RealParameter('penalty', 1, 1.5)
]

#specify outcomes
criticality_model.outcomes = [
    ScalarOutcome(key) for key, val in edge_dict.iteritems()
]

from ema_workbench import Policy, perform_experiments
from ema_workbench import ema_logging

ema_logging.log_to_stderr(ema_logging.INFO)

n_scenarios = 3
results = perform_experiments(criticality_model, n_scenarios)

fh = r'./data/{} experiments_22may_v01.tar.gz'.format(nr_experiments)
save_results(results, fh)
# initiate model
model = Model(name='taxidriver', function=ema_experiment)

# levers
model.levers = [
    RealParameter("startup_fee", 2, 5),
    RealParameter("km_fee", 0.2, 0.5),
    RealParameter("speed", 90, 130),
]

# uncertainties
model.uncertainties = [
    RealParameter("distance", 3, 60),
    RealParameter("fuel_price", 1.1, 1.8),
    RealParameter("driver_salary_rate", 10, 20),
]

# specify outcomes
model.outcomes = [
    ScalarOutcome("profit"),
    ScalarOutcome("fuel_use"),
    ScalarOutcome("time_spent"),
]

# run experiments
results = perform_experiments(model, scenarios=10, policies=3)

# # save results
# results_file_name = os.path.join(RESULT_FOLDER, f"cabelpooling_ema_results_{RUNID}.tar.gz")
# save_results(results, file_name=results_file_name)


if __name__ == '__main__':
    ema_logging.LOG_FORMAT = '[%(name)s/%(levelname)s/%(processName)s] %(message)s'
    ema_logging.log_to_stderr(ema_logging.INFO)
    
    model = Model('simpleModel', function=modelvpl) #instantiate the model

    #specify uncertainties
    model.uncertainties = [RealParameter("indice_custo", 0.9, 1.1),
                           RealParameter("indice_faturamento", 0.9,1.3),
                           RealParameter("i", 0.01,0.05)]
    #specify outcomes 
    model.outcomes = [ScalarOutcome('y')]

    results = perform_experiments(model, 1000)
    
    util.utilities.save_results(results, './results/results.tar.gz')

#    print(results)
    
    
    
    
#     ensemble = ModelEnsemble() #instantiate an ensemble
#     ensemble.model_structure = model #set the model on the ensemble
#     results = ensemble.perform_experiments(100, reporting_interval=1) #run 1000 experiments
    

Esempio n. 17
0
@author: Pedro
"""
from __future__ import (division, print_function, absolute_import, 
                        unicode_literals)

from ema_workbench import (RealParameter, ScalarOutcome, ema_logging,
                           perform_experiments)

from ema_workbench.connectors.excel import ExcelModel


if __name__ == "__main__":    
    ema_logging.log_to_stderr(level=ema_logging.DEBUG)
    
    model = ExcelModel("excelModel", wd="./models",
                      model_file= '/excelModel.xlsx')
    model.uncertainties = [RealParameter("B2", 0.04, 0.2), #we can refer to a cell in the normal way
                           RealParameter("B3", 4000,6000), # we can also use named cells
                           RealParameter("B4", 0.9,1.1),
                           RealParameter("B5", 0.9,1.1)]
    
    #specification of the outcomes
    model.outcomes = [ScalarOutcome("B7")] # we can also use named range
    
    #name of the sheet
    model.sheet = "EMA"
    
    results = perform_experiments(model, 100, parallel=True, reporting_interval=1)
    
    print("blaat")
Esempio n. 18
0
'''


'''

# Created on Jul 23, 2016
#
# .. codeauthor::jhkwakkel <j.h.kwakkel (at) tudelft (dot) nl>

from ema_workbench import (RealParameter, TimeSeriesOutcome, ema_logging,
                           perform_experiments)

from ema_workbench.connectors.pysd_connector import PysdModel

if __name__ == '__main__':
    ema_logging.log_to_stderr(ema_logging.INFO)

    mdl_file = './models/pysd/Teacup.mdl'

    model = PysdModel(mdl_file=mdl_file)

    model.uncertainties = [RealParameter('Room Temperature', 33, 120)]
    model.outcomes = [TimeSeriesOutcome('Teacup Temperature')]

    perform_experiments(model, 100)
Esempio n. 19
0
                           RealParameter('x21', 0.0001, 0.1),
                           RealParameter('x22', 0.0001, 0.1),
                           RealParameter('x31', 0, 0.5),
                           RealParameter('x32', 0, 0.5),
                           RealParameter('x41', 0, 0.9),
                           RealParameter('x51', 0, 0.5),
                           RealParameter('x52', 0, 0.5),
                           RealParameter('x61', 0, 0.8),
                           RealParameter('x62', 0, 0.8),
                           RealParameter('x81', 1, 10),
                           RealParameter('x82', 1, 10),
                           RealParameter('x91', 0, 0.1),
                           RealParameter('x92', 0, 0.1),
                           RealParameter('x101', 0, 200),
                           RealParameter('x102', 0, 200)]

    model.outcomes = [TimeSeriesOutcome("TIME"),
                      TimeSeriesOutcome("deceased_population_region_1")]

    nr_experiments = 500

    with MultiprocessingEvaluator(model) as evaluator:
        results = perform_experiments(model, nr_experiments,
                                      evaluator=evaluator)

    lines(results, outcomes_to_show="deceased_population_region_1",
          show_envelope=True, density=Density.KDE, titles=None,
          experiments_to_show=np.arange(0, nr_experiments, 10)
          )
    plt.show()
Esempio n. 20
0
#specify outcomes
model.outcomes = [ScalarOutcome('p_10'),
                  ScalarOutcome('r_10'),
                  ScalarOutcome('a_10'),
                  ScalarOutcome('p_30'),
                  ScalarOutcome('r_30'),
                  ScalarOutcome('a_30'),
                  ScalarOutcome('p_50'),
                  ScalarOutcome('r_50'),
                  ScalarOutcome('a_50'),
                  ScalarOutcome('p_70'),
                  ScalarOutcome('r_70'),
                  ScalarOutcome('a_70'),
                  ScalarOutcome('p_100'),
                  ScalarOutcome('r_100'),
                  ScalarOutcome('a_100'),
                  ScalarOutcome('p_avg'),
                  ScalarOutcome('r_avg'),
                  ScalarOutcome('a_avg')]


from ema_workbench import save_results
results = perform_experiments(model, 1000)
save_results(results, '1000_scenarios_%s_new_model_diverse.tar.gz'%domain)

sa_results = perform_experiments(model, 1050, uncertainty_sampling='sobol')
save_results(sa_results, '1050_scenarios_%s_sobol_new_model_diverse.tar.gz'%domain)


Esempio n. 21
0
        RealParameter('additional seasonal immune population fraction R2', 0,
                      0.5),
        RealParameter('fatality ratio region 1', 0.0001, 0.1),
        RealParameter('fatality rate region 2', 0.0001, 0.1),
        RealParameter('initial immune fraction of the population of region 1',
                      0, 0.5),
        RealParameter('initial immune fraction of the population of region 2',
                      0, 0.5),
        RealParameter('normal interregional contact rate', 0, 0.9),
        RealParameter('permanent immune population fraction R1', 0, 0.5),
        RealParameter('permanent immune population fraction R2', 0, 0.5),
        RealParameter('recovery time region 1', 0.1, 0.75),
        RealParameter('recovery time region 2', 0.1, 0.75),
        RealParameter('susceptible to immune population delay time region 1',
                      0.5, 2),
        RealParameter('susceptible to immune population delay time region 2',
                      0.5, 2),
        RealParameter('root contact rate region 1', 0.01, 5),
        RealParameter('root contact ratio region 2', 0.01, 5),
        RealParameter('infection ratio region 1', 0, 0.15),
        RealParameter('infection rate region 2', 0, 0.15),
        RealParameter('normal contact rate region 1', 10, 100),
        RealParameter('normal contact rate region 2', 10, 200)
    ]

    nr_experiments = 10
    with MultiprocessingEvaluator(model) as evaluator:
        results = perform_experiments(model,
                                      nr_experiments,
                                      evaluator=evaluator)
Esempio n. 22
0
from ema_workbench import (RealParameter, TimeSeriesOutcome, ema_logging,
                           perform_experiments)

from ema_workbench.connectors.excel import ExcelModel
from ema_workbench.em_framework.evaluators import MultiprocessingEvaluator


if __name__ == "__main__":
    ema_logging.log_to_stderr(level=ema_logging.INFO)

    model = ExcelModel("predatorPrey", wd="./models/excelModel",
                       model_file='excel example.xlsx')
    model.uncertainties = [RealParameter("K2", 0.01, 0.2),  # we can refer to a cell in the normal way
                           # we can also use named cells
                           RealParameter("KKK", 450, 550),
                           RealParameter("rP", 0.05, 0.15),
                           RealParameter("aaa", 0.00001, 0.25),
                           RealParameter("tH", 0.45, 0.55),
                           RealParameter("kk", 0.1, 0.3)]

    # specification of the outcomes
    model.outcomes = [TimeSeriesOutcome("B4:B1076"),  # we can refer to a range in the normal way
                      TimeSeriesOutcome("P_t")]  # we can also use named range

    # name of the sheet
    model.sheet = "Sheet1"

    with MultiprocessingEvaluator(model) as evaluator:
        results = perform_experiments(model, 100, reporting_interval=1,
                                      evaluator=evaluator)
Esempio n. 23
0
"""


"""
from __future__ import unicode_literals, print_function, absolute_import, division


# Created on Jul 23, 2016
#
# .. codeauthor::jhkwakkel <j.h.kwakkel (at) tudelft (dot) nl>

from ema_workbench import RealParameter, TimeSeriesOutcome, ema_logging, perform_experiments

from ema_workbench.connectors import PysdModel

if __name__ == "__main__":
    ema_logging.log_to_stderr(ema_logging.DEBUG)

    mdl_file = "./models/pysd/Teacup.mdl"

    model = PysdModel(mdl_file=mdl_file)

    model.uncertainties = [RealParameter("Room Temperature", 33, 120)]
    model.outcomes = [TimeSeriesOutcome("Teacup Temperature")]

    perform_experiments(model, 100)
                        model_file = 'FLUvensimV1basecase.vpm')
            
    #outcomes
    model.outcomes = [TimeSeriesOutcome('deceased population region 1'),
                      TimeSeriesOutcome('infected fraction R1')]
    
    #Plain Parametric Uncertainties 
    model.uncertainties = [
        RealParameter('additional seasonal immune population fraction R1', 0, 0.5),
        RealParameter('additional seasonal immune population fraction R2', 0, 0.5),
        RealParameter('fatality ratio region 1', 0.0001, 0.1),
        RealParameter('fatality rate region 2', 0.0001, 0.1),
        RealParameter('initial immune fraction of the population of region 1', 0, 0.5),
        RealParameter('initial immune fraction of the population of region 2', 0, 0.5),
        RealParameter('normal interregional contact rate', 0, 0.9),
        RealParameter('permanent immune population fraction R1', 0, 0.5),
        RealParameter('permanent immune population fraction R2', 0, 0.5),
        RealParameter('recovery time region 1', 0.1, 0.75),
        RealParameter('recovery time region 2', 0.1, 0.75),
        RealParameter('susceptible to immune population delay time region 1', 0.5, 2),
        RealParameter('susceptible to immune population delay time region 2', 0.5, 2),
        RealParameter('root contact rate region 1', 0.01, 5),
        RealParameter('root contact ratio region 2', 0.01, 5),
        RealParameter('infection ratio region 1', 0, 0.15),
        RealParameter('infection rate region 2', 0, 0.15),
        RealParameter('normal contact rate region 1', 10, 100),
        RealParameter('normal contact rate region 2', 10, 200)]

    nr_experiments = 100
    results = perform_experiments(model, nr_experiments, parallel=True)
Esempio n. 25
0
        RealParameter("x22", 0.0001, 0.1),
        RealParameter("x31", 0, 0.5),
        RealParameter("x32", 0, 0.5),
        RealParameter("x41", 0, 0.9),
        RealParameter("x51", 0, 0.5),
        RealParameter("x52", 0, 0.5),
        RealParameter("x61", 0, 0.8),
        RealParameter("x62", 0, 0.8),
        RealParameter("x81", 1, 10),
        RealParameter("x82", 1, 10),
        RealParameter("x91", 0, 0.1),
        RealParameter("x92", 0, 0.1),
        RealParameter("x101", 0, 200),
        RealParameter("x102", 0, 200),
    ]

    model.outcomes = [TimeSeriesOutcome("TIME"), TimeSeriesOutcome("deceased_population_region_1")]

    nr_experiments = 500
    results = perform_experiments(model, nr_experiments, parallel=True)

    lines(
        results,
        outcomes_to_show="deceased_population_region_1",
        show_envelope=True,
        density=KDE,
        titles=None,
        experiments_to_show=np.arange(0, nr_experiments, 10),
    )
    plt.show()
Esempio n. 26
0
    model.levers = [RealParameter("b", 0.0, 0.01)]

    # specify outcomes
    model.outcomes = [
        ScalarOutcome('c'),
        ScalarOutcome('d'),
        ScalarOutcome('e')
    ]

    #model.constants = [Constant('replications', 10)]

    n_scenarios = 10
    n_policies = 10

    res = perform_experiments(model, n_scenarios, n_policies)

    experiments, outcomes = res

    print(experiments)
    print(outcomes)
''' 
edgeColor = setEdgeColors(G)
finalColorCode = setNodeColors(G)

plt.figure(figsize=[15,10])
plt.subplot(121)
nx.draw(G, with_labels=True, node_color=initialColorCode,
        edge_color= edgeColor, pos = nx.planar_layout(G), font_weight='bold',
        node_size=[1000,300,300,300,300])
plt.subplot(122)
This file illustrated the use the EMA classes for a contrived vensim
example


.. codeauthor:: jhkwakkel <j.h.kwakkel (at) tudelft (dot) nl>
                chamarat <c.hamarat (at) tudelft (dot) nl>
'''
from __future__ import (division, unicode_literals, absolute_import, 
                        print_function)

from ema_workbench import (TimeSeriesOutcome, perform_experiments,
                           RealParameter, ema_logging)

from ema_workbench.connectors.vensim import VensimModel

if __name__ == "__main__":
    #turn on logging
    ema_logging.log_to_stderr(ema_logging.INFO)
    
    #instantiate a model
    wd = r'./models/vensim example'
    vensimModel = VensimModel("simpleModel", wd=wd,
                              model_file=r'\model.vpm')
    vensimModel.uncertainties = [RealParameter("x11", 0, 2.5),
                                 RealParameter("x12", -2.5, 2.5)]
    
    vensimModel.outcomes = [TimeSeriesOutcome('a')]
    
    results = perform_experiments(vensimModel, 1000, parallel=True)
    
# override some of the defaults of the model
lake_model.constants = [Constant('alpha', 0.41),
                        Constant('nsamples', 100),
                        Constant('timehorizon', lake_model.time_horizon),
                       ]

import os

from ema_workbench import (perform_experiments, ema_logging, save_results, 
                           load_results, Policy)
from ema_workbench.em_framework import samplers

# turn on logging
ema_logging.log_to_stderr(ema_logging.INFO)

# perform experiments
nr_experiments = 2
nr_policies = 1
fn = './data/{}_experiments_openloop_noApollution.tar.gz'.format(nr_experiments)
policy = Policy({'c1':0,
                'c2':0,
                'r1':1,
                'r2':0,
                'w1':0})
results = perform_experiments(lake_model, 10, policies=[policy])
#try:
    # why regenerate the data?
#    results = load_results(fn)
#except IOError:
#    results = perform_experiments(lake_model, scenarios=nr_experiments)
save_results(results, fn)