Changeset 1979

Timestamp:

Dec 11, 2009 12:23:17 AM (11 years ago)

Author:

jwatson

Message:

Biggest enhancement: The efwriter command-line script now has the option to output a CVaR-weighted objective term. Not extensively tested, but behaves sane on a number of small test cases.

Improved exception handling and error diagnostics in both the runph and efwriter scripts.

Location:

coopr.pysp/trunk

Files:

• coopr/pysp/ef.py (modified) (4 diffs)
• coopr/pysp/ef_writer_script.py (modified) (2 diffs)
• coopr/pysp/ph_script.py (modified) (1 diff)
• scripts/efwriter (modified) (1 diff)
• scripts/runph (modified) (1 diff)

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

@@ -54 +54 @@
 
 # the main extensive-form writer routine - including read of scenarios/etc.
-def write_ef_from_scratch(model_directory, instance_directory, output_filename):
+def write_ef_from_scratch(model_directory, instance_directory, output_filename, \
+                          generate_weighted_cvar, cvar_weight, risk_alpha):
 
    start_time = time.time()
@@ -66 +67 @@
    #### INITIALIZATION ############################################################################
    ################################################################################################
+
+   #
+   # validate cvar options, if specified.
+   #
+   if generate_weighted_cvar is True:
+      if cvar_weight <= 0.0:
+         raise RuntimeError, "Weight of CVaR term must be >= 0.0 - value supplied="+str(cvar_weight)
+      if (risk_alpha <= 0.0) or (risk_alpha >= 1.0):
+         raise RuntimeError, "CVaR risk alpha must be between 0 and 1, exclusive - value supplied="+str(risk_alpha)
+
+      print "Writing CVaR weighted objective"
+      print "CVaR term weight="+str(cvar_weight)
+      print "CVaR alpha="+str(risk_alpha)
+      print ""
    
    #
@@ -272 +287 @@
             setattr(master_binding_instance, expected_cost_variable_name, expected_cost_variable)
 
+   # if we're generating the weighted CVaR objective term, create the corresponding variable and
+   # the master CVaR eta variable.
+   if generate_weighted_cvar is True:
+      root_node = scenario_tree._stages[0]._tree_nodes[0]
+      
+      cvar_cost_variable_name = "CVAR_COST_" + root_node._name
+      cvar_cost_variable = Var(name=cvar_cost_variable_name)
+      cvar_cost_variable._construct(master_binding_instance, None)
+      setattr(master_binding_instance, cvar_cost_variable_name, cvar_cost_variable)
+
+      cvar_eta_variable_name = "CVAR_ETA_" + root_node._name
+      cvar_eta_variable = Var(name=cvar_eta_variable_name)
+      cvar_eta_variable._construct(master_binding_instance, None)
+      setattr(master_binding_instance, cvar_eta_variable_name, cvar_eta_variable)      
+
    master_binding_instance.presolve()
 
@@ -348 +378 @@
             opt_sense = an_objective[an_objective.keys()[0]].sense
 
+            opt_expression = node_expected_cost_variable
+
+            if generate_weighted_cvar is True:
+               cvar_cost_variable_name = "CVAR_COST_" + tree_node._name
+               cvar_cost_variable = getattr(master_binding_instance, cvar_cost_variable_name)
+               opt_expression += cvar_weight * cvar_cost_variable
+
             new_objective = Objective(name="MASTER", sense=opt_sense)
-            new_objective._data[None].expr = node_expected_cost_variable
+            new_objective._data[None].expr = opt_expression
             setattr(master_binding_instance, "MASTER", new_objective)
+
+   # CVaR requires the addition of a variable per scenario to represent the cost excess,
+   # and a constraint to compute the cost excess relative to eta. we also replicate (following
+   # what we do for node cost variables) an eta variable for each scenario instance, and
+   # require equality with the master eta variable via constraints.
+   if generate_weighted_cvar is True:
+      
+      root_node = scenario_tree._stages[0]._tree_nodes[0]
+
+      master_cvar_eta_variable_name = "CVAR_ETA_" + root_node._name
+      master_cvar_eta_variable = getattr(master_binding_instance, master_cvar_eta_variable_name)
+      
+      for scenario_name in instances.keys():
+         scenario_instance = instances[scenario_name]
+
+         # unique names are required because the presolve isn't
+         # aware of the "owning" models for variables.
+         cvar_excess_variable_name = "CVAR_EXCESS_"+scenario_name
+         cvar_excess_variable = Var(name=cvar_excess_variable_name, domain=NonNegativeReals)
+         cvar_excess_variable._construct(scenario_instance, None)
+         setattr(scenario_instance, cvar_excess_variable_name, cvar_excess_variable)
+
+         cvar_eta_variable_name = "CVAR_ETA"
+         cvar_eta_variable = Var(name=cvar_eta_variable_name)
+         cvar_eta_variable._construct(scenario_instance, None)
+         setattr(scenario_instance, cvar_eta_variable_name, cvar_eta_variable)
+
+         compute_excess_constraint_name = "COMPUTE_SCENARIO_EXCESS"
+         compute_excess_constraint = Constraint(name=compute_excess_constraint_name)
+         compute_excess_expression = cvar_excess_variable
+         for node in scenario_tree._scenario_map[scenario_name]._node_list:
+            (cost_variable, cost_variable_idx) = node._stage._cost_variable
+            compute_excess_expression -= getattr(scenario_instance, cost_variable.name)[cost_variable_idx]
+         compute_excess_expression += cvar_eta_variable
+         compute_excess_constraint._initialize_constraint(None, (0.0, compute_excess_expression, None), scenario_instance, compute_excess_constraint_name)
+         compute_excess_constraint._model = scenario_instance
+         setattr(scenario_instance, compute_excess_constraint_name, compute_excess_constraint)
+
+         eta_equality_constraint_name = "MASTER_ETA_EQUALITY_WITH_" + scenario_instance.name
+         eta_equality_constraint = Constraint(name=eta_equality_constraint_name)
+         eta_equality_expr = master_cvar_eta_variable - cvar_eta_variable
+         eta_equality_constraint._initialize_constraint(None, (0.0, eta_equality_expr, 0.0), master_binding_instance, eta_equality_constraint_name)
+         eta_equality_constraint._model = master_binding_instance
+         setattr(master_binding_instance, eta_equality_constraint_name, eta_equality_constraint)
+
+      # add the constraint to compute the master CVaR variable value. iterate
+      # over scenario instances to create the expected excess component first.
+      cvar_cost_variable_name = "CVAR_COST_" + root_node._name
+      cvar_cost_variable = getattr(master_binding_instance, cvar_cost_variable_name)
+      cvar_eta_variable_name = "CVAR_ETA_" + root_node._name
+      cvar_eta_variable = getattr(master_binding_instance, cvar_eta_variable_name)
+      
+      cvar_cost_expression = cvar_cost_variable - cvar_eta_variable
+      
+      for scenario_name in instances.keys():
+         scenario_instance = instances[scenario_name]
+         scenario_probability = scenario_tree._scenario_map[scenario_name]._probability
+
+         scenario_excess_variable_name = "CVAR_EXCESS_"+scenario_name
+         scenario_excess_variable = getattr(scenario_instance, scenario_excess_variable_name)
+
+         cvar_cost_expression = cvar_cost_expression - (scenario_probability * scenario_excess_variable) / (1.0 - risk_alpha)
+
+      compute_cvar_cost_constraint_name = "COMPUTE_CVAR_COST"
+      compute_cvar_cost_constraint = Constraint(name=compute_cvar_cost_constraint_name)
+      compute_cvar_cost_constraint._initialize_constraint(None, (0.0, cvar_cost_expression, 0.0), master_binding_instance, compute_cvar_cost_constraint_name)
+      compute_cvar_cost_constraint._model = master_binding_instance
+      setattr(master_binding_instance, compute_cvar_cost_constraint_name, compute_cvar_cost_constraint)
+
+   # after mucking with instances, presolve to collect terms required prior to output.         
+   # IMPT: Do the scenario instances first, as the master depends on variables in the scenarios.
+   for scenario_name in instances.keys():
+      scenario_instance = instances[scenario_name]   
+      scenario_instance.presolve()         
 
    master_binding_instance.presolve()

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

@@ -40 +40 @@
                   type="string",
                   default=".")
+parser.add_option("--generate-weighted-cvar",
+                  help="Add a weighted CVaR term to the primary objective",
+                  action="store_true",
+                  dest="generate_weighted_cvar",
+                  default=False)
+parser.add_option("--cvar-weight",
+                  help="The weight associated with the CVaR term in the risk-weighted objective formulation.",
+                  action="store",
+                  dest="cvar_weight",
+                  type="float",
+                  default=1.0)
+parser.add_option("--risk-alpha",
+                  help="The probability threshold associated with cvar (or any future) risk-oriented performance metrics.",
+                  action="store",
+                  dest="risk_alpha",
+                  type="float",
+                  default=0.95)
 parser.add_option("--output-file",
                   help="Specify the name of the extensive form output file",
@@ -55 +72 @@
 def run_ef_writer(options, args):
 
-   write_ef_from_scratch(options.model_directory, options.instance_directory, options.output_file)
+   # if the user enabled the addition of the weighted cvar term to the objective,
+   # then validate the associated parameters.
+   generate_weighted_cvar = False
+   cvar_weight = None
+   risk_alpha = None
+
+   if options.generate_weighted_cvar is True:
+
+      generate_weighted_cvar = True
+      cvar_weight = options.cvar_weight
+      risk_alpha = options.risk_alpha
+
+   write_ef_from_scratch(options.model_directory, options.instance_directory, options.output_file, \
+                         generate_weighted_cvar, cvar_weight, risk_alpha)
 
    return

coopr.pysp/trunk/coopr/pysp/ph_script.py

@@ -436 +436 @@
 
       if options.user_defined_extension is not None:
-         print "User-defined PH extension specified - module name="+options.user_defined_extension
-         try:
-            __import__(options.user_defined_extension)
-         except:
-            raise RuntimeError, "Failed to load user-defined module="+options.user_defined_extension
+         print "Trying to import user-defined PH extension module="+options.user_defined_extension
+         # JPW removed the exception handling logic, as the module importer
+         # can raise a broad array of exceptions. 
+         __import__(options.user_defined_extension)
+         print "Module successfully loaded"
 
       #

coopr.pysp/trunk/scripts/efwriter

@@ -51 +51 @@
     coopr.pysp.ef_writer_script.run()
 except ValueError, str:
+    print "VALUE ERROR:"   
     print str
 except IOError, str:
+    print "IO ERROR:"   
     print str
+except RuntimeError, str:
+    print "RUN-TIME ERROR:"   
+    print str    
 except pyutilib.common.ApplicationError, str:
+    print "APPLICATION ERROR:"   
     print str
 except:

coopr.pysp/trunk/scripts/runph

@@ -59 +59 @@
     print "APPLICATION ERROR:"
     print str
+except RuntimeError, str:
+    print "RUN-TIME ERROR:"   
+    print str        
 except:
    print "Encountered unhandled exception"