[WIP]: Enabling min max list

dependencies.xml

@@ -96,4 +96,4 @@ Note all install methods after "main" take
     <nomkl>remove</nomkl>
     <numexpr>remove</numexpr>
   </alternate>
-</dependencies>
+</dependencies>

ravenframework/Optimizers/GradientDescent.py

@@ -212,6 +212,7 @@ def __init__(self):
     self._followerProximity = 1e-2   # distance at which annihilation can start occurring, in ?normalized? space
     self._trajectoryFollowers = defaultdict(list) # map of trajectories to the trajectories following them
     self._functionalConstraintExplorationLimit = 500 # number of input-space explorations allowable for functional constraints
+    self._canHandleMultiObjective = False # Currently Gradient Descent cannot handle multiobjective optimization
     # __private
     # additional methods
     # register adaptive sample identification criteria
@@ -338,7 +339,11 @@ def _useRealization(self, info, rlz):
       @ Out, None
     """
     traj = info['traj']
-    optVal = rlz[self._objectiveVar]
+    # if not self._canHandleMultiObjective and len(self._objectiveVar) == 1:
+    #   self._objectiveVar = self._objectiveVar[0]
+    if len(self._objectiveVar) > 1 and type(self._objectiveVar)==list:
+      self.raiseAnError(IOError, 'Gradient Descent does not support multiObjective optimization yet! objective variable must be a single variable for now!')
+    optVal = rlz[self._objectiveVar[0]]
     info['optVal'] = optVal
     purpose = info['purpose']
     if purpose.startswith('opt'):
@@ -353,13 +358,13 @@ def _useRealization(self, info, rlz):
       gradMag, gradVersor, _ = self._gradientInstance.evaluate(opt,
                                                                grads,
                                                                gradInfos,
-                                                               self._objectiveVar)
+                                                               self._objectiveVar[0])
       self.raiseADebug(' ... gradient calculated ...')
       self._gradHistory[traj].append((gradMag, gradVersor))
       # get new step information
       try:
         newOpt, stepSize, stepInfo = self._stepInstance.step(opt,
-                                                  objVar=self._objectiveVar,
+                                                  objVar=self._objectiveVar[0],
                                                   optHist=self._optPointHistory[traj],
                                                   gradientHist=self._gradHistory[traj],
                                                   prevStepSize=self._stepHistory[traj],
@@ -378,7 +383,7 @@ def _useRealization(self, info, rlz):
       except NoConstraintResolutionFound:
         # we've tried everything, but we just can't hack it
         self.raiseAMessage(f'Optimizer "{self.name}" trajectory {traj} was unable to continue due to functional or boundary constraints.')
-        self._closeTrajectory(traj, 'converge', 'no constraint resolution', opt[self._objectiveVar])
+        self._closeTrajectory(traj, 'converge', 'no constraint resolution', opt[self._objectiveVar[0]])
         return
 
       # update values if modified by constraint handling
@@ -598,7 +603,7 @@ def _checkAcceptability(self, traj, opt, optVal, info):
     # Check acceptability
     if self._optPointHistory[traj]:
       old, _ = self._optPointHistory[traj][-1]
-      oldVal = old[self._objectiveVar]
+      oldVal = old[self._objectiveVar[0]]
       # check if following another trajectory
       if self._terminateFollowers:
         following = self._stepInstance.trajIsFollowing(traj, self.denormalizeData(opt), info,
@@ -815,7 +820,7 @@ def _checkConvObjective(self, traj):
       return False
     o1, _ = self._optPointHistory[traj][-1]
     o2, _ = self._optPointHistory[traj][-2]
-    delta = mathUtils.relativeDiff(o2[self._objectiveVar], o1[self._objectiveVar])
+    delta = mathUtils.relativeDiff(o2[self._objectiveVar[0]], o1[self._objectiveVar[0]])
     converged = abs(delta) < self._convergenceCriteria['objective']
     self.raiseADebug(self.convFormat.format(name='objective',
                                             conv=str(converged),

ravenframework/Optimizers/Optimizer.py

@@ -78,9 +78,9 @@ def getInputSpecification(cls):
     specs.description = 'Optimizers'
 
     # objective variable
-    specs.addSub(InputData.parameterInputFactory('objective', contentType=InputTypes.StringType, strictMode=True,
+    specs.addSub(InputData.parameterInputFactory('objective', contentType=InputTypes.StringListType, strictMode=True,
         printPriority=90, # more important than <variable>
-        descr=r"""Name of the response variable (or ``objective function'') that should be optimized
+        descr=r"""Name of the objective variable (or ``objective function'') that should be optimized
         (minimized or maximized)."""))
 
     # modify Sampler variable nodes
@@ -103,7 +103,8 @@ def getInputSpecification(cls):
         descr=r"""seed for random number generation. Note that by default RAVEN uses an internal seed,
               so this seed must be changed to observe changed behavior. \default{RAVEN-determined}""")
     minMaxEnum = InputTypes.makeEnumType('MinMax', 'MinMaxType', ['min', 'max'])
-    minMax = InputData.parameterInputFactory('type', contentType=minMaxEnum,
+    minMaxList = InputTypes.StringListType()
+    minMax = InputData.parameterInputFactory('type', contentType=minMaxList,
         descr=r"""the type of optimization to perform. \xmlString{min} will search for the lowest
               \xmlNode{objective} value, while \xmlString{max} will search for the highest value.""")
     init.addSub(seed)
@@ -161,7 +162,7 @@ def __init__(self):
     # public
     # _protected
     self._seed = None                   # random seed to apply
-    self._minMax = 'min'                # maximization or minimization?
+    self._minMax = ['min']                # maximization or minimization?
     self._activeTraj = []               # tracks live trajectories
     self._cancelledTraj = {}            # tracks cancelled trajectories, and reasons
     self._convergedTraj = {}            # tracks converged trajectories, and values obtained
@@ -249,7 +250,6 @@ def handleInput(self, paramInput):
       @ Out, None
     """
     # the reading of variables (dist or func) and constants already happened in _readMoreXMLbase in Sampler
-    # objective var
     self._objectiveVar = paramInput.findFirst('objective').value
 
     # sampler init
@@ -264,6 +264,10 @@ def handleInput(self, paramInput):
       minMax = init.findFirst('type')
       if minMax is not None:
         self._minMax = minMax.value
+        if len(self._minMax) != len(self._objectiveVar):
+          self.raiseAnError(IOError, 'type and objective must be of the same length!')
+        if list(set(self._minMax)-set(['min','max'])) != []:
+          self.raiseAnError(IOError, "type must be a list of 'min' and/or 'max'")
 
     # variables additional reading
     for varNode in paramInput.findAll('variable'):

ravenframework/Optimizers/RavenSampled.py

@@ -300,8 +300,16 @@ def localFinalizeActualSampling(self, jobObject, model, myInput):
     # # testing suggests no big deal on smaller problem
     # the sign of the objective function is flipped in case we do maximization
     # so get the correct-signed value into the realization
-    if self._minMax == 'max':
-      rlz[self._objectiveVar] *= -1
+
+    if 'max' in self._minMax:
+      if not self._canHandleMultiObjective and len(self._objectiveVar) == 1:
+        rlz[self._objectiveVar[0]] *= -1
+      elif type(self._objectiveVar) == list:
+        for i in range(len(self._objectiveVar)):
+          if self._minMax[i] == 'max':
+            rlz[self._objectiveVar[i]] *= -1
+      else:
+        rlz[self._objectiveVar] *= -1
     # TODO FIXME let normalizeData work on an xr.DataSet (batch) not just a dictionary!
     rlz = self.normalizeData(rlz)
     self._useRealization(info, rlz)
@@ -312,57 +320,127 @@ def finalizeSampler(self, failedRuns):
       @ In, failedRuns, list, runs that failed as part of this sampling
       @ Out, None
     """
-    # get and print the best trajectory obtained
-    bestValue = None
-    bestTraj = None
-    bestPoint = None
-    s = -1 if self._minMax == 'max' else 1
-    # check converged trajectories
-    self.raiseAMessage('*' * 80)
-    self.raiseAMessage('Optimizer Final Results:')
-    self.raiseADebug('')
-    self.raiseADebug(' - Trajectory Results:')
-    self.raiseADebug('  TRAJ   STATUS    VALUE')
-    statusTemplate = '   {traj:2d}  {status:^11s}  {val: 1.3e}'
-    # print cancelled traj
-    for traj, info in self._cancelledTraj.items():
-      val = info['value']
-      status = info['reason']
-      self.raiseADebug(statusTemplate.format(status=status, traj=traj, val=s * val))
-    # check converged traj
-    for traj, info in self._convergedTraj.items():
+    if not self._canHandleMultiObjective or len(self._objectiveVar) == 1:
+      # get and print the best trajectory obtained
+      bestValue = None
+      bestTraj = None
+      bestPoint = None
+      s = -1 if 'max' in self._minMax else 1
+      # check converged trajectories
+      self.raiseAMessage('*' * 80)
+      self.raiseAMessage('Optimizer Final Results:')
+      self.raiseADebug('')
+      self.raiseADebug(' - Trajectory Results:')
+      self.raiseADebug('  TRAJ   STATUS    VALUE')
+      statusTemplate = '   {traj:2d}  {status:^11s}  {val: 1.3e}'
+      # print cancelled traj
+      for traj, info in self._cancelledTraj.items():
+        val = info['value']
+        status = info['reason']
+        self.raiseADebug(statusTemplate.format(status=status, traj=traj, val=s * val))
+      # check converged traj
+      for traj, info in self._convergedTraj.items():
+        opt = self._optPointHistory[traj][-1][0]
+        val = info['value']
+        self.raiseADebug(statusTemplate.format(status='converged', traj=traj, val=s * val))
+        if bestValue is None or val < bestValue:
+          bestTraj = traj
+          bestValue = val
+      # further check active unfinished trajectories
+      # FIXME why should there be any active, unfinished trajectories when we're cleaning up sampler?
+      traj = 0 # FIXME why only 0?? what if it's other trajectories that are active and unfinished?
+      # sanity check: if there's no history (we never got any answers) then report rather than crash
+      if len(self._optPointHistory[traj]) == 0:
+        self.raiseAnError(RuntimeError, f'There is no optimization history for traj {traj}! ' +
+                          'Perhaps the Model failed?')
       opt = self._optPointHistory[traj][-1][0]
-      val = info['value']
-      self.raiseADebug(statusTemplate.format(status='converged', traj=traj, val=s * val))
+      val = opt[self._objectiveVar[0]]
+      self.raiseADebug(statusTemplate.format(status='active', traj=traj, val=s * val))
       if bestValue is None or val < bestValue:
-        bestTraj = traj
         bestValue = val
-    # further check active unfinished trajectories
-    # FIXME why should there be any active, unfinished trajectories when we're cleaning up sampler?
-    traj = 0 # FIXME why only 0?? what if it's other trajectories that are active and unfinished?
-    # sanity check: if there's no history (we never got any answers) then report than rather than crash
-    if len(self._optPointHistory[traj]) == 0:
-      self.raiseAnError(RuntimeError, f'There is no optimization history for traj {traj}! ' +
-                        'Perhaps the Model failed?')
-    opt = self._optPointHistory[traj][-1][0]
-    val = opt[self._objectiveVar]
-    self.raiseADebug(statusTemplate.format(status='active', traj=traj, val=s * val))
-    if bestValue is None or val < bestValue:
-      bestValue = val
-      bestTraj = traj
-    bestOpt = self.denormalizeData(self._optPointHistory[bestTraj][-1][0])
-    bestPoint = dict((var, bestOpt[var]) for var in self.toBeSampled)
-    self.raiseADebug('')
-    self.raiseAMessage(' - Final Optimal Point:')
-    finalTemplate = '    {name:^20s}  {value: 1.3e}'
-    finalTemplateInt = '    {name:^20s}  {value: 3d}'
-    self.raiseAMessage(finalTemplate.format(name=self._objectiveVar, value=s * bestValue))
-    self.raiseAMessage(finalTemplateInt.format(name='trajID', value=bestTraj))
-    for var, val in bestPoint.items():
-      self.raiseAMessage(finalTemplate.format(name=var, value=val))
-    self.raiseAMessage('*' * 80)
-    # write final best solution to soln export
-    self._updateSolutionExport(bestTraj, self.normalizeData(bestOpt), 'final', 'None')
+        bestTraj = traj
+      bestOpt = self.denormalizeData(self._optPointHistory[bestTraj][-1][0])
+      bestPoint = dict((var, bestOpt[var]) for var in self.toBeSampled)
+      self.raiseADebug('')
+      self.raiseAMessage(' - Final Optimal Point:')
+      finalTemplate = '    {name:^20s}  {value: 1.3e}'
+      finalTemplateInt = '    {name:^20s}  {value: 3d}'
+      self.raiseAMessage(finalTemplate.format(name=self._objectiveVar[0], value=s * bestValue))
+      self.raiseAMessage(finalTemplateInt.format(name='trajID', value=bestTraj))
+      for var, val in bestPoint.items():
+        self.raiseAMessage(finalTemplate.format(name=var, value=val))
+      self.raiseAMessage('*' * 80)
+      # write final best solution to soln export
+      self._updateSolutionExport(bestTraj, self.normalizeData(bestOpt), 'final', 'None')
+    else:
+      # get and print the best trajectory obtained
+      bestValue = None
+      bestTraj = None
+      bestPoint = None
+      s = -1 if self._minMax == 'max' else 1
+      # check converged trajectories
+      self.raiseAMessage('*' * 80)
+      self.raiseAMessage('Optimizer Final Results:')
+      self.raiseADebug('')
+      self.raiseADebug(' - Trajectory Results:')
+      self.raiseADebug('  TRAJ   STATUS    VALUE')
+      statusTemplate = '   {traj:2d}  {status:^11s}  {val: 1.3e}'
+      statusTemplate_multi = '   {traj:2d}  {status:^11s}  {val1: ^11s}  {val2: ^11s}'
+
+      # print cancelled traj
+      for traj, info in self._cancelledTraj.items():
+        val = info['value']
+        status = info['reason']
+        self.raiseADebug(statusTemplate.format(status=status, traj=traj, val=s * val))
+      # check converged traj
+      for traj, info in self._convergedTraj.items():
+        opt = self._optPointHistory[traj][-1][0]
+        val = info['value']
+        self.raiseADebug(statusTemplate.format(status='converged', traj=traj, val=s * val))
+        if bestValue is None or val < bestValue:
+          bestTraj = traj
+          bestValue = val
+      # further check active unfinished trajectories
+      # FIXME why should there be any active, unfinished trajectories when we're cleaning up sampler?
+      traj = 0 # FIXME why only 0?? what if it's other trajectories that are active and unfinished?
+      # sanity check: if there's no history (we never got any answers) then report rather than crash
+      if len(self._optPointHistory[traj]) == 0:
+        self.raiseAnError(RuntimeError, f'There is no optimization history for traj {traj}! ' +
+                          'Perhaps the Model failed?')
+
+      if type(self._objectiveVar) == str:
+        opt = self._optPointHistory[traj][-1][0]
+        val = opt[self._objectiveVar]
+        self.raiseADebug(statusTemplate.format(status='active', traj=traj, val=s * val))
+        if bestValue is None or val < bestValue:
+          bestValue = val
+          bestTraj = traj
+        bestOpt = self.denormalizeData(self._optPointHistory[bestTraj][-1][0])
+        bestPoint = dict((var, bestOpt[var]) for var in self.toBeSampled)
+        self.raiseADebug('')
+        self.raiseAMessage(' - Final Optimal Point:')
+        finalTemplate = '    {name:^20s}  {value: 1.3e}'
+        finalTemplateInt = '    {name:^20s}  {value: 3d}'
+        # self.raiseAMessage(finalTemplate.format(name=self._objectiveVar, value=s * bestValue))
+        self.raiseAMessage(finalTemplateInt.format(name='trajID', value=bestTraj))
+        for var, val in bestPoint.items():
+          self.raiseAMessage(finalTemplate.format(name=var, value=val))
+        self.raiseAMessage('*' * 80)
+        # write final best solution to soln export
+        self._updateSolutionExport(bestTraj, self.normalizeData(bestOpt), 'final', 'None')
+      else:
+        for i in range(len(self._optPointHistory[traj][-1][0][self._objectiveVar[0]])):
+          opt = self._optPointHistory[traj][-1][0]
+          key = list(opt.keys())
+          val = [item[i] for item in opt.values()]
+          optElm = {key[a]: val[a] for a in range(len(key))}
+          optVal = [(-1*(self._minMax[b]=='max')+(self._minMax[b]=='min'))*optElm[self._objectiveVar[b]] for b in range(len(self._objectiveVar))]
+
+          bestTraj = traj
+          bestOpt = self.denormalizeData(optElm)
+          bestPoint = dict((var, bestOpt[var]) for var in self.toBeSampled)
+
+          self._updateSolutionExport(bestTraj, self.normalizeData(bestOpt), 'final', 'None')
 
   def flush(self):
     """
@@ -498,10 +576,13 @@ def _handleImplicitConstraints(self, previous):
       @ Out, accept, bool, whether point was satisfied implicit constraints
     """
     normed = copy.deepcopy(previous)
-    oldVal = normed[self._objectiveVar]
-    normed.pop(self._objectiveVar, oldVal)
+    if type(self._objectiveVar) == str:
+      oldVal = normed[self._objectiveVar]
+    else:
+      oldVal = normed[self._objectiveVar[0]]
+    normed.pop(self._objectiveVar[0], oldVal)
     denormed = self.denormalizeData(normed)
-    denormed[self._objectiveVar] = oldVal
+    denormed[self._objectiveVar[0]] = oldVal
     accept = self._checkImpFunctionalConstraints(denormed)
 
     return accept
@@ -569,9 +650,12 @@ def _resolveNewOptPoint(self, traj, rlz, optVal, info):
       # TODO could we ever use old rerun gradients to inform the gradient direction as well?
       self._rerunsSinceAccept[traj] += 1
       N = self._rerunsSinceAccept[traj] + 1
-      oldVal = self._optPointHistory[traj][-1][0][self._objectiveVar]
+      if type(self._objectiveVar) == str:
+        oldVal = self._optPointHistory[traj][-1][0][self._objectiveVar]
+      else:
+        oldVal = self._optPointHistory[traj][-1][0][self._objectiveVar[0]]
       newAvg = ((N-1)*oldVal + optVal) / N
-      self._optPointHistory[traj][-1][0][self._objectiveVar] = newAvg
+      self._optPointHistory[traj][-1][0][self._objectiveVar[0]] = newAvg
     else:
       self.raiseAnError(f'Unrecognized acceptability: "{acceptable}"')
 
@@ -635,10 +719,17 @@ def _updateSolutionExport(self, traj, rlz, acceptable, rejectReason):
                      'rejectReason': rejectReason
                     })
     # optimal point input and output spaces
-    objValue = rlz[self._objectiveVar]
-    if self._minMax == 'max':
-      objValue *= -1
-    toExport[self._objectiveVar] = objValue
+    if len(self._objectiveVar) == 1: # Single Objective Optimization
+      objValue = rlz[self._objectiveVar[0]]
+      if 'max' in self._minMax:
+        objValue *= -1
+      toExport[self._objectiveVar[0]] = objValue
+    else: # Multi Objective Optimization
+      for i in range(len(self._objectiveVar)):
+        objValue = rlz[self._objectiveVar[i]]
+        if self._minMax[i] == 'max':
+          objValue *= -1
+        toExport[self._objectiveVar[i]] = objValue
     toExport.update(self.denormalizeData(dict((var, rlz[var]) for var in self.toBeSampled)))
     # constants and functions
     toExport.update(self.constants)