Changeset 899

Timestamp:

Feb 22, 2008, 2:08:40 PM (16 years ago)

Author:

mmc

Message:

Added a -fitness option to the "perform" operation. Right now, you can
specify just the name of an output quantity, and that quantity can be
minimized or maximized. In the future, there should be an expression
parser so you can enter any function of Rappture quantities.

Fixed up the example so that it runs the Rosenbrock function, which is
difficult to minimize. Added a visualize.tcl script, so you can visualize
the output from many different runXXXX.xml files.

Location:

trunk/optimizer

Files:

• examples/rosenbrock.tcl (added)
• examples/simple.tcl (modified) (1 diff)
• examples/tool.xml (modified) (1 diff)
• examples/visualize.tcl (added)
• src/plugin_pgapack.c (modified) (4 diffs)
• src/rp_optimizer.c (modified) (2 diffs)
• src/rp_optimizer.h (modified) (4 diffs)
• src/rp_optimizer_plugin.h (deleted)
• src/rp_optimizer_tcl.c (modified) (19 diffs)

trunk/optimizer/examples/simple.tcl

@@ -48 +48 @@
 Rappture::optimizer optim -tool $tool -using pgapack
 
-optim add number input.number(temperature) -min 200 -max 400
-optim add number input.number(Ef) -min 0 -max 1.1
-optim configure -popsize 500 -maxruns 5
+optim add number input.number(x1) -min -2 -max 2
+optim add number input.number(x2) -min -2 -max 2
+optim configure -operation minimize -popsize 100 -maxruns 200
 
-set status [optim perform -updatecommand {puts "checking"}]
+set status [optim perform \
+    -fitness output.number(f).current \
+    -updatecommand {puts "checking"}]
 
 puts "done: $status"

trunk/optimizer/examples/tool.xml

@@ -2 +2 @@
 <run>
     <tool>
-        <about>Press Simulate to view results.</about>
-        <command>tclsh @tool/fermi.tcl @driver</command>
+        <about>This tool is a good example for optimization.  It implements the Rosenbrock function:
+
+f(x1,x2) = 100(x2 - x1**2)**2 + (1-x1)**2
+
+This has a minimum at (x1,x2) = (1,1).
+
+Press Simulate to view results.</about>
+        <command>tclsh @tool/rosenbrock.tcl @driver</command>
     </tool>
     <input>
-        <number id="temperature">
+        <number id="x1">
             <about>
-                <label>Ambient temperature</label>
-                <description>Temperature of the environment.</description>
+                <label>X1</label>
+                <description>first coordinate</description>
             </about>
-            <units>K</units>
-            <min>0K</min>
-            <max>500K</max>
-            <default>300K</default>
-            <preset>
-                <value>300K</value>
-                <label>300K (room temperature)</label>
-            </preset>
-            <preset>
-                <value>77K</value>
-                <label>77K (liquid nitrogen)</label>
-            </preset>
-            <preset>
-                <value>4.2K</value>
-                <label>4.2K (liquid helium)</label>
-            </preset>
+            <min>-2</min>
+            <max>2</max>
+            <default>0</default>
         </number>
-        <number id="Ef">
+        <number id="x2">
             <about>
-                <label>Fermi Level</label>
-                <description>Energy at center of distribution.</description>
+                <label>X2</label>
+                <description>second coordinate</description>
             </about>
-            <units>eV</units>
-            <min>-10eV</min>
-            <max>10eV</max>
-            <default>0eV</default>
+            <min>-2</min>
+            <max>2</max>
+            <default>0</default>
         </number>
     </input>
 </run>
-

trunk/optimizer/src/plugin_pgapack.c

@@ -15 +15 @@
  */
 #include "pgapack.h"
-#include "rp_optimizer_plugin.h"
+#include "rp_optimizer.h"
 
 typedef struct PgapackData {
@@ -92 +92 @@
  */
 RpOptimStatus
-PgapackRun(envPtr, evalProc)
+PgapackRun(envPtr, evalProc, fitnessExpr)
     RpOptimEnv *envPtr;           /* optimization environment */
     RpOptimEvaluator *evalProc;   /* call this proc to run tool */
+    char *fitnessExpr;            /* fitness function in string form */
 {
     PgapackData *dataPtr =(PgapackData*)envPtr->pluginData;
@@ -109 +110 @@
     PGASetPopSize(ctx, dataPtr->popSize);
     PGASetPopReplaceType(ctx, dataPtr->popRepl);
+    PGASetCrossoverType(ctx, PGA_CROSSOVER_UNIFORM);
 
     PGASetUserFunction(ctx, PGA_USERFUNCTION_CREATESTRING, PgapCreateString);
@@ -118 +120 @@
     PGASetUserFunction(ctx, PGA_USERFUNCTION_BUILDDATATYPE, PgapBuildDT);
 
-    envPtr->evalProc = evalProc;  /* call this later for evaluations */
+    envPtr->evalProc = evalProc;   /* plug these in for later during eval */
+    envPtr->fitnessExpr = fitnessExpr;
 
     /*

trunk/optimizer/src/rp_optimizer.c

@@ -33 +33 @@
  */
 RpOptimEnv*
-RpOptimCreate(pluginData, cleanupProc)
-    ClientData pluginData;        /* special data created for this env */
-    RpOptimCleanup *cleanupProc;  /* routine to clean up pluginData */
+RpOptimCreate(pluginDefn)
+    RpOptimPlugin *pluginDefn;    /* plug-in handling this optimization */
 {
     RpOptimEnv *envPtr;
     envPtr = (RpOptimEnv*)malloc(sizeof(RpOptimEnv));
-    envPtr->pluginData  = pluginData;
-    envPtr->cleanupProc = cleanupProc;
-    envPtr->toolData    = NULL;
+
+    envPtr->pluginDefn = pluginDefn;
+    envPtr->pluginData = NULL;
+    envPtr->toolData   = NULL;
+
+    if (pluginDefn->initProc) {
+        envPtr->pluginData = (*pluginDefn->initProc)();
+    }
 
     envPtr->numParams = 0;
@@ -211 +215 @@
     int n;
 
+    if (envPtr->pluginDefn && envPtr->pluginDefn->cleanupProc) {
+        (*envPtr->pluginDefn->cleanupProc)(envPtr->pluginData);
+    }
     for (n=0; n < envPtr->numParams; n++) {
         RpOptimCleanupParam(envPtr->paramList[n]);
-    }
-    if (envPtr->cleanupProc) {
-        (*envPtr->cleanupProc)(envPtr->pluginData);
     }
     free(envPtr->paramList);

trunk/optimizer/src/rp_optimizer.h

@@ -23 +23 @@
 #include <string.h>
 #include <malloc.h>
+#include "rp_tcloptions.h"
 
 /*
@@ -48 +49 @@
 
 typedef RpOptimStatus (RpOptimHandler) _ANSI_ARGS_((
-    struct RpOptimEnv *envPtr, RpOptimEvaluator *evalProc));
+    struct RpOptimEnv *envPtr, RpOptimEvaluator *evalProc,
+    char *fitnessExpr));
+
+/*
+ * Each optimization package is plugged in to this infrastructure
+ * by defining the following data at the top of rp_optimizer_tcl.c
+ */
+typedef struct RpOptimPlugin {
+    char *name;                   /* name of this package for -using */
+    RpOptimInit *initProc;        /* initialization routine */
+    RpOptimHandler *runProc;      /* handles the core optimization */
+    RpOptimCleanup *cleanupProc;  /* cleanup routine */
+    RpTclOption *optionSpec;      /* specs for config options */
+} RpOptimPlugin;
 
 /*
@@ -98 +112 @@
  */
 typedef struct RpOptimEnv {
+    RpOptimPlugin *pluginDefn;      /* plug-in handling this optimization */
+    ClientData pluginData;          /* data created by plugin init routine */
     RpOptimEvaluator *evalProc;     /* called during optimization to do run */
-    ClientData pluginData;          /* data created by plugin init routine */
-    RpOptimCleanup *cleanupProc;    /* cleanup routine for pluginData */
+    char *fitnessExpr;              /* fitness function in string form */
     ClientData toolData;            /* data used during tool execution */
     RpOptimParam **paramList;       /* list of input parameters to vary */
@@ -110 +125 @@
  *  Here are the functions in the API:
  */
-EXTERN RpOptimEnv* RpOptimCreate _ANSI_ARGS_((ClientData pluginData,
-    RpOptimCleanup *cleanupProc));
+EXTERN RpOptimEnv* RpOptimCreate _ANSI_ARGS_((RpOptimPlugin *pluginDefn));
 
 EXTERN RpOptimParam* RpOptimAddParamNumber _ANSI_ARGS_((RpOptimEnv *envPtr,

trunk/optimizer/src/rp_optimizer_tcl.c

@@ -15 +15 @@
  */
 #include "rp_optimizer.h"
-#include "rp_optimizer_plugin.h"
 
 /*
@@ -35 +34 @@
 };
 
-typedef struct RpOptimPluginData {
-    RpOptimPlugin *pluginDefn;      /* points back to plugin definition */
-    ClientData clientData;          /* data needed for particular plugin */
-} RpOptimPluginData;
-
 typedef struct RpOptimToolData {
     Tcl_Interp *interp;             /* interp handling this tool */
@@ -67 +61 @@
 static int RpOptimInstanceCmd _ANSI_ARGS_((ClientData clientData,
     Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]));
-static void RpOptimInstanceCleanup _ANSI_ARGS_((ClientData cdata));
 static RpOptimStatus RpOptimizerPerformInTcl _ANSI_ARGS_((RpOptimEnv *envPtr,
     RpOptimParam *values, int numValues, double *fitnessPtr));
-static int RpOptimizerUpdateInTcl _ANSI_ARGS_((RpOptimEnv *envPtr));
 
 #ifdef BUILD_Rappture
@@ -129 +121 @@
     RpOptimEnv* envPtr;
     RpOptimPlugin* pluginPtr;
-    RpOptimPluginData* pluginDataPtr;
     RpOptimToolData* toolDataPtr;
 
@@ -222 +213 @@
      * Create an optimizer and install a Tcl command to access it.
      */
-    pluginDataPtr = (RpOptimPluginData*)malloc(sizeof(RpOptimPluginData));
-    pluginDataPtr->pluginDefn = usingPluginPtr;
-    pluginDataPtr->clientData = NULL;
-    if (usingPluginPtr->initProc) {
-        pluginDataPtr->clientData = (*usingPluginPtr->initProc)();
-    }
-    envPtr = RpOptimCreate((ClientData)pluginDataPtr, RpOptimInstanceCleanup);
+    envPtr = RpOptimCreate(usingPluginPtr);
 
     toolDataPtr = (RpOptimToolData*)malloc(sizeof(RpOptimToolData));
@@ -298 +283 @@
  *      <name> get ?<glob>? ?-option?
  *      <name> configure ?-option? ?value -option value ...?
- *      <name> perform ?-tool <tool>? ?-updatecommand <varName>?
+ *      <name> perform ?-tool <tool>? ?-fitness <expr>? \
+ *                     ?-updatecommand <varName>?
  *      <name> using
  *
@@ -314 +300 @@
 {
     RpOptimEnv* envPtr = (RpOptimEnv*)cdata;
-    RpOptimPluginData* pluginDataPtr = (RpOptimPluginData*)envPtr->pluginData;
     RpOptimToolData* toolDataPtr = (RpOptimToolData*)envPtr->toolData;
 
     int n, j, nvals, nmatches;
-    char *option, *type, *path;
+    char *option, *type, *path, *fitnessExpr;
     RpOptimParam *paramPtr;
     RpOptimParamString *strPtr;
@@ -510 +495 @@
      */
     else if (*option == 'c' && strcmp(option,"configure") == 0) {
-        optSpecPtr = pluginDataPtr->pluginDefn->optionSpec;
+        optSpecPtr = envPtr->pluginDefn->optionSpec;
         if (objc == 2) {
             /* report all values: -option val -option val ... */
@@ -519 +504 @@
             for (n=0; optSpecPtr[n].optname; n++) {
                 if (RpTclOptionGet(interp, optSpecPtr,
-                    (ClientData)pluginDataPtr->clientData,
+                    (ClientData)envPtr->pluginData,
                     optSpecPtr[n].optname) != TCL_OK) {
                     Tcl_DecrRefCount(rval);
@@ -543 +528 @@
             option = Tcl_GetStringFromObj(objv[2], (int*)NULL);
             return RpTclOptionGet(interp, optSpecPtr,
-                (ClientData)pluginDataPtr->clientData, option);
+                (ClientData)envPtr->pluginData, option);
         }
         else {
             return RpTclOptionsProcess(interp, objc-2, objv+2,
-                optSpecPtr, pluginDataPtr->clientData);
-        }
-    }
-
-    /*
-     * OPTION:  perform ?-tool name? ?-updatecommand name?
+                optSpecPtr, envPtr->pluginData);
+        }
+    }
+
+    /*
+     * OPTION:  perform ?-tool name? ?-fitness expr? ?-updatecommand name?
      */
     else if (*option == 'p' && strcmp(option,"perform") == 0) {
         /* use this tool by default */
         toolPtr = toolDataPtr->toolPtr;
+
+        /* no -fitness function by default */
+        fitnessExpr = NULL;
 
         /* no -updatecommand by default */
@@ -574 +562 @@
                 n += 2;
             }
+            else if (strcmp(option,"-fitness") == 0) {
+                fitnessExpr = Tcl_GetStringFromObj(objv[n+1], (int*)NULL);
+                n += 2;
+            }
             else if (strcmp(option,"-updatecommand") == 0) {
                 updateCmdPtr = objv[n+1];
@@ -580 +572 @@
             else {
                 Tcl_AppendStringsToObj(Tcl_GetObjResult(interp),
-                    "bad option \"", option, "\": should be -tool,"
+                    "bad option \"", option, "\": should be -fitness, -tool,"
                     " -updatecommand", (char*)NULL);
                 return TCL_ERROR;
@@ -587 +579 @@
 
         /*
-         * Must have a tool object at this point, or else we
-         * don't know what to optimize.
+         * Must have a tool object and a fitness function at this point,
+         * or else we don't know what to optimize.
          */
         if (toolPtr == NULL) {
@@ -596 +588 @@
             return TCL_ERROR;
         }
+        if (fitnessExpr == NULL) {
+            Tcl_AppendStringsToObj(Tcl_GetObjResult(interp),
+                "missing -fitness function for optimization",
+                (char*)NULL);
+            return TCL_ERROR;
+        }
 
         Tcl_IncrRefCount(toolPtr);
@@ -604 +602 @@
 
         /* call the main optimization routine here */
-        status = (*pluginDataPtr->pluginDefn->runProc)(envPtr,
-            RpOptimizerPerformInTcl);
+        status = (*envPtr->pluginDefn->runProc)(envPtr,
+            RpOptimizerPerformInTcl, fitnessExpr);
 
         Tcl_DecrRefCount(toolPtr);
@@ -639 +637 @@
             return TCL_ERROR;
         }
-        Tcl_SetResult(interp, pluginDataPtr->pluginDefn->name, TCL_STATIC);
+        Tcl_SetResult(interp, envPtr->pluginDefn->name, TCL_STATIC);
         return TCL_OK;
     }
@@ -650 +648 @@
     }
     return TCL_OK;
-}
-
-/*
- * ----------------------------------------------------------------------
- * RpOptimInstanceCleanup()
- *
- * Called whenever a optimizer environment is being delete to clean
- * up any plugin data associated with it.  It's a little convoluted.
- * Here's the sequence:  A Tcl command is deleted, RpOptimCmdDelete()
- * gets called to clean it up, RpOptimDelete() is called within that,
- * and this method gets called to clean up the client data associated
- * with the underlying environment.
- * ----------------------------------------------------------------------
- */
-static void
-RpOptimInstanceCleanup(cdata)
-    ClientData cdata;   /* plugin data being deleted */
-{
-    RpOptimPluginData *pluginDataPtr = (RpOptimPluginData*)cdata;
-
-    /* if there are config options, clean them up first */
-    if (pluginDataPtr->pluginDefn->optionSpec) {
-        RpTclOptionsCleanup(pluginDataPtr->pluginDefn->optionSpec,
-            pluginDataPtr->clientData);
-    }
-
-    /* call a specialized cleanup routine to handle the rest */
-    if (pluginDataPtr->pluginDefn->cleanupProc) {
-        (*pluginDataPtr->pluginDefn->cleanupProc)(pluginDataPtr->clientData);
-    }
-    pluginDataPtr->clientData = NULL;
-
-    /* free the container */
-    free((char*)pluginDataPtr);
 }
 
@@ -706 +670 @@
     double *fitnessPtr;       /* returns: computed value of fitness func */
 {
-    printf("running...\n");
-    *fitnessPtr = 0.0;
-    return RP_OPTIM_SUCCESS;
-}
-
-/*
- * ------------------------------------------------------------------------
- *  RpOptimizerUpdateInTcl()
- *
- *  Invoked as a call-back within RpOptimPerform() to update the
- *  application and look for an "abort" signal.  Evaluates a bit of
- *  optional code stored in the optimization environment.  Returns 0
- *  if everything is okay, and non-zero if the user wants to abort.
- * ------------------------------------------------------------------------
- */
-static int
-RpOptimizerUpdateInTcl(envPtr)
-    RpOptimEnv *envPtr;       /* optimization environment */
-{
+    RpOptimStatus result = RP_OPTIM_SUCCESS;
     RpOptimToolData *toolDataPtr = (RpOptimToolData*)envPtr->toolData;
-    int status;
-
+    Tcl_Interp *interp = toolDataPtr->interp;
+    int n, status;
+#define MAXBUILTIN 10
+    int objc; Tcl_Obj **objv, *storage[MAXBUILTIN], *getcmd[3];
+    int rc; Tcl_Obj **rv;
+    Tcl_Obj *dataPtr;
+    char *out;
+
+    /*
+     * Set up the arguments for a Tcl evaluation.
+     */
+    objc = 2*numValues + 2;  /* "tool run" + (name value)*numValues */
+    if (objc > MAXBUILTIN) {
+        objv = (Tcl_Obj**)malloc(objc*sizeof(Tcl_Obj));
+    } else {
+        objv = storage;
+    }
+    objv[0] = toolDataPtr->toolPtr;
+    objv[1] = Tcl_NewStringObj("run",-1); Tcl_IncrRefCount(objv[1]);
+    for (n=0; n < numValues; n++) {
+        objv[2*n+2] = Tcl_NewStringObj(values[n].name, -1);
+        Tcl_IncrRefCount(objv[2*n+2]);
+
+        switch (values[n].type) {
+        case RP_OPTIMPARAM_NUMBER:
+            objv[2*n+3] = Tcl_NewDoubleObj(values[n].value.dval);
+            Tcl_IncrRefCount(objv[2*n+3]);
+            break;
+        case RP_OPTIMPARAM_STRING:
+            objv[2*n+3] = Tcl_NewStringObj(values[n].value.sval.str,-1);
+            Tcl_IncrRefCount(objv[2*n+3]);
+            break;
+        default:
+            panic("bad parameter type in RpOptimizerPerformInTcl()");
+        }
+    }
+
+    /*
+     *  Invoke the tool and pick apart its results.
+     */
+    status = Tcl_EvalObjv(interp, objc, objv, TCL_EVAL_GLOBAL);
+
+    if (status != TCL_OK) {
+        result = RP_OPTIM_FAILURE;
+        fprintf(stderr, "== JOB FAILED: %s\n", Tcl_GetStringResult(interp));
+    } else {
+        dataPtr = Tcl_GetObjResult(interp);
+        /* hang on to this while we pick it apart into rv[] */
+        Tcl_IncrRefCount(dataPtr);
+
+        if (Tcl_ListObjGetElements(interp, dataPtr, &rc, &rv) != TCL_OK) {
+            result = RP_OPTIM_FAILURE;
+            fprintf(stderr, "== JOB FAILED: %s\n", Tcl_GetStringResult(interp));
+        } else if (rc != 2
+                    || Tcl_GetIntFromObj(interp, rv[0], &status) != TCL_OK) {
+            result = RP_OPTIM_FAILURE;
+            fprintf(stderr, "== JOB FAILED: malformed result: expected {status output}\n");
+        } else {
+            out = Tcl_GetStringFromObj(rv[1], (int*)NULL);
+            if (status != 0) {
+                result = RP_OPTIM_FAILURE;
+                fprintf(stderr, "== JOB FAILED with status code %d:\n%s\n",
+                    status, out);
+            } else {
+                /*
+                 *  Get the output value from the tool output in the
+                 *  result we just parsed above:  {status xmlobj}
+                 *
+                 *  Eventually, we should write a whole parser to
+                 *  handle arbitrary fitness functions.  For now,
+                 *  just query a single output value by calling:
+                 *    xmlobj get fitnessExpr
+                 */
+                getcmd[0] = rv[1];
+                getcmd[1] = Tcl_NewStringObj("get",-1);
+                getcmd[2] = Tcl_NewStringObj(envPtr->fitnessExpr,-1);
+                for (n=0; n < 3; n++) {
+                    Tcl_IncrRefCount(getcmd[n]);
+                }
+
+                status = Tcl_EvalObjv(interp, 3, getcmd, TCL_EVAL_GLOBAL);
+
+                if (status != TCL_OK) {
+                    result = RP_OPTIM_FAILURE;
+                    fprintf(stderr, "== UNEXPECTED ERROR while extracting output value:%s\n", Tcl_GetStringResult(interp));
+                } else if (Tcl_GetDoubleFromObj(interp,
+                      Tcl_GetObjResult(interp), fitnessPtr) != TCL_OK) {
+                    result = RP_OPTIM_FAILURE;
+                    fprintf(stderr, "== ERROR while extracting output value:%s\n", Tcl_GetStringResult(interp));
+                }
+                for (n=0; n < 3; n++) {
+                    Tcl_DecrRefCount(getcmd[n]);
+                }
+            }
+        }
+        Tcl_DecrRefCount(dataPtr);
+    }
+
+    /*
+     * Clean up objects created for command invocation.
+     */
+    for (n=1; n < objc; n++) {
+        Tcl_DecrRefCount(objv[n]);
+    }
+    if (objv != storage) {
+        free(objv);
+    }
+
+    /*
+     * If there's the -updatecommand was specified, execute it here
+     * to bring the application up-to-date and see if the user wants
+     * to abort.
+     */
     if (toolDataPtr->updateCmdPtr) {
         status = Tcl_GlobalEvalObj(toolDataPtr->interp,
@@ -734 +791 @@
         if (status == TCL_ERROR) {
             Tcl_BackgroundError(toolDataPtr->interp);
-            return 0;
-        }
-        if (status == TCL_BREAK || status == TCL_RETURN) {
-            return 1;  /* abort! */
-        }
-    }
-    return 0;  /* keep going... */
+        }
+        else if (status == TCL_BREAK || status == TCL_RETURN) {
+            return RP_OPTIM_ABORTED;
+        }
+    }
+    return RP_OPTIM_SUCCESS;
 }