Changeset 3261

Timestamp:

Nov 29, 2010 5:26:46 PM (10 years ago)

Author:

jwatson

Message:

Adding two options to the runef and runph pysp scripts, to facilitate scenario downsampling - the case where you have a big tree, but you don't want to use it all.

The options are:
--scenario-tree-downsample-fraction=X
--scenario-tree-random-seed

The options are fairly self-explanatory - the only possible nuance is that the downsample fraction is the fraction of scenarios retained.

Location:

coopr.pysp/trunk/coopr/pysp

Files:

• ef.py (modified) (3 diffs)
• ef_writer_script.py (modified) (3 diffs)
• phinit.py (modified) (3 diffs)
• scenariotree.py (modified) (2 diffs)

coopr.pysp/trunk/coopr/pysp/ef.py

@@ -508 +508 @@
 
 def write_ef_from_scratch(model_directory, instance_directory, output_filename,
-                          verbose_output, linearize,
+                          verbose_output, linearize_expressions, tree_downsample_fraction, tree_random_seed,
                           generate_weighted_cvar, cvar_weight, risk_alpha):
 
@@ -577 +577 @@
 
    #
+   # compress/down-sample the scenario tree, if operation is required.
+   #
+   if tree_downsample_fraction < 1.0:
+       
+      scenario_tree.downsample(tree_downsample_fraction, tree_random_seed, verbose_output)   
+
+   #
    # print the input tree for validation/information purposes.
    #
@@ -626 +633 @@
                                                       verbose=verbose_output,
                                                       preprocess=True,
-                                                      linearize=linearize)
+                                                      linearize=linearize_expressions)
 
       scenario_instances[scenario._name] = scenario_instance

coopr.pysp/trunk/coopr/pysp/ef_writer_script.py

@@ -41 +41 @@
    parser.usage=usage_string
 
-   inputOpts  = OptionGroup( parser, 'Input Options' )
-   efOpts     = OptionGroup( parser, 'EF Options' )
-   solverOpts = OptionGroup( parser, 'Solver Options' )
-   outputOpts = OptionGroup( parser, 'Output Options' )
-   otherOpts  = OptionGroup( parser, 'Other Options' )
+   inputOpts        = OptionGroup( parser, 'Input Options' )
+   scenarioTreeOpts = OptionGroup( parser, 'Scenario Tree Options' )   
+   efOpts           = OptionGroup( parser, 'EF Options' )
+   solverOpts       = OptionGroup( parser, 'Solver Options' )
+   outputOpts       = OptionGroup( parser, 'Output Options' )
+   otherOpts        = OptionGroup( parser, 'Other Options' )
    parser.add_option_group( inputOpts )
+   parser.add_option_group( scenarioTreeOpts )
    parser.add_option_group( efOpts )
    parser.add_option_group( solverOpts )
@@ -64 +66 @@
      type='string',
      default='.')
+
+   scenarioTreeOpts.add_option('--scenario-tree-seed',
+     help="The random seed associated with manipulation operations on the scenario tree (e.g., down-sampling). Default is 0, indicating unassigned.",
+     action="store",
+     dest="scenario_tree_random_seed",
+     type="int",
+     default=None)
+   scenarioTreeOpts.add_option('--scenario-tree-downsample-fraction',
+     help="The proportion of the scenarios in the scenario tree that are actually used. Specific scenarios are selected at random. Default is 1.0, indicating no down-sampling.",
+     action="store",
+     dest="scenario_tree_downsample_fraction",
+     type="float",
+     default=1.0)   
 
    efOpts.add_option('--cvar-weight',
@@ -192 +207 @@
                                                                                options.verbose,
                                                                                options.linearize_expressions,
+                                                                               options.scenario_tree_downsample_fraction,
+                                                                               options.scenario_tree_random_seed,
                                                                                generate_weighted_cvar, cvar_weight, risk_alpha)
 

coopr.pysp/trunk/coopr/pysp/phinit.py

@@ -51 +51 @@
    parser.usage = usage_string
 
-   inputOpts       = OptionGroup( parser, 'Input Options' )
-   phOpts          = OptionGroup( parser, 'PH Options' )
-   solverOpts      = OptionGroup( parser, 'Solver Options' )
-   postprocessOpts = OptionGroup( parser, 'Postprocessing Options' )   
-   outputOpts      = OptionGroup( parser, 'Output Options' )
-   otherOpts       = OptionGroup( parser, 'Other Options' )
+   # NOTE: these groups should eventually be queried from the PH, scenario tree, etc. classes (to facilitate re-use).
+   inputOpts        = OptionGroup( parser, 'Input Options' )
+   scenarioTreeOpts = OptionGroup( parser, 'Scenario Tree Options' )
+   phOpts           = OptionGroup( parser, 'PH Options' )
+   solverOpts       = OptionGroup( parser, 'Solver Options' )
+   postprocessOpts  = OptionGroup( parser, 'Postprocessing Options' )   
+   outputOpts       = OptionGroup( parser, 'Output Options' )
+   otherOpts        = OptionGroup( parser, 'Other Options' )
    parser.add_option_group( inputOpts )
+   parser.add_option_group( scenarioTreeOpts )
    parser.add_option_group( phOpts )
    parser.add_option_group( solverOpts )
@@ -81 +84 @@
      dest="bounds_cfgfile",
      default=None)
+
+   scenarioTreeOpts.add_option('--scenario-tree-seed',
+     help="The random seed associated with manipulation operations on the scenario tree (e.g., down-sampling). Default is 0, indicating unassigned.",
+     action="store",
+     dest="scenario_tree_random_seed",
+     type="int",
+     default=None)
+   scenarioTreeOpts.add_option('--scenario-tree-downsample-fraction',
+     help="The proportion of the scenarios in the scenario tree that are actually used. Specific scenarios are selected at random. Default is 1.0, indicating no down-sampling.",
+     action="store",
+     dest="scenario_tree_downsample_fraction",
+     type="float",
+     default=1.0)   
 
    phOpts.add_option('-r','--default-rho',
@@ -412 +428 @@
    scenario_tree = ScenarioTree(scenarioinstance=reference_instance,
                                 scenariotreeinstance=scenario_tree_instance)
+
+   #
+   # compress/down-sample the scenario tree, if operation is required.
+   #
+   if options.scenario_tree_downsample_fraction < 1.0:
+       
+      scenario_tree.downsample(options.scenario_tree_downsample_fraction, options.scenario_tree_random_seed, options.verbose)
 
    return reference_model, reference_instance, scenario_tree, scenario_tree_instance

coopr.pysp/trunk/coopr/pysp/scenariotree.py

@@ -16 +16 @@
 
 from math import fabs
+
+import random
 
 from coopr.pyomo import *
@@ -654 +656 @@
             probability = probability * tree_node._conditional_probability
          scenario._probability = probability
+
+   #
+   # utility for automatically selecting a proportion of scenarios from the
+   # tree to retain, eliminating the rest. 
+   #
+
+   def downsample(self, fraction_to_retain, random_seed, verbose=False):
+
+      random.seed(random_seed)
+
+      random_sequence=range(0,len(self._scenarios))
+      random.shuffle(random_sequence)
+
+      number_to_retain = max(int(round(float(len(random_sequence)*fraction_to_retain))), 1)
+
+      scenario_bundle_list = []
+      for i in range(0,number_to_retain):
+         scenario_bundle_list.append(self._scenarios[random_sequence[i]]._name)
+
+      if verbose is True:
+         print "Downsampling scenario tree - retained scenarios: "+str(scenario_bundle_list)
+
+      self.compress(scenario_bundle_list)
+
 
    #