NSGA-II features Update on Optimizers/GeneticAlgorithm

ravenframework/Optimizers/GeneticAlgorithm.py

@@ -41,8 +41,7 @@
 from .crossOverOperators.crossovers import returnInstance as crossoversReturnInstance
 from .mutators.mutators import returnInstance as mutatorsReturnInstance
 from .survivorSelectors.survivorSelectors import returnInstance as survivorSelectionReturnInstance
-from .survivorSelectors import survivorSelectors 
-from .survivorSelectors import survivorSelectors 
+from .survivorSelection import survivorSelection as survivorSelectionProcess 
 from .fitness.fitness import returnInstance as fitnessReturnInstance
 from .repairOperators.repair import returnInstance as repairReturnInstance
 
@@ -618,9 +617,9 @@ def multiConstraint(self, info, rlz):
     g0 = np.zeros((np.shape(offSprings)[0],len(self._constraintFunctions)+len(self._impConstraintFunctions)))
 
     g = xr.DataArray(g0,
-                      dims=['chromosome','Constraint'],
-                      coords={'chromosome':np.arange(np.shape(offSprings)[0]),
-                              'Constraint':[y.name for y in (self._constraintFunctions + self._impConstraintFunctions)]})
+                     dims=['chromosome','Constraint'],
+                     coords={'chromosome':np.arange(np.shape(offSprings)[0]),
+                             'Constraint':[y.name for y in (self._constraintFunctions + self._impConstraintFunctions)]})
 
     for index,individual in enumerate(offSprings):
       newOpt = individual
@@ -674,8 +673,8 @@ def _useRealization(self, info, rlz):
 
     if self._activeTraj:
       # Step 0 @ n-1: Survivor selection(rlz): Update population container given obtained children
-      survivorSelectionFuncs: dict = {1: survivorSelectors.singleObjSurvivorSelect, 2: survivorSelectors.multiObjSurvivorSelect}
-      survivorSelection = survivorSelectionFuncs.get(objInd, survivorSelectors.singleObjSurvivorSelect)
+      survivorSelectionFuncs: dict = {1: survivorSelectionProcess.singleObjSurvivorSelect, 2: survivorSelectionProcess.multiObjSurvivorSelect}
+      survivorSelection = survivorSelectionFuncs.get(objInd, survivorSelectionProcess.singleObjSurvivorSelect)
       survivorSelection(self, info, rlz, traj, offSprings, offSpringFitness, objectiveVal, g)
 
       # Step 1 @ n-1: Plot results

ravenframework/Optimizers/survivorSelection/survivorSelection.py

@@ -0,0 +1,96 @@
+# Copyright 2017 Battelle Energy Alliance, LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""
+  Implementation of survivorSelection step for new generation
+  selection process in Genetic Algorithm. 
+
+  Created Apr,3,2024
+  @authors: Mohammad Abdo, Junyung Kim
+"""
+# External Modules----------------------------------------------------------------------------------
+import numpy as np
+import xarray as xr
+from ravenframework.utils import frontUtils
+# External Modules End------------------------------------------------------------------------------
+
+# Internal Modules----------------------------------------------------------------------------------
+from ...utils.gaUtils import dataArrayToDict, datasetToDataArray
+# Internal Modules End------------------------------------------------------------------------------
+
+# @profile
+
+def singleObjSurvivorSelect(self, info, rlz, traj, offSprings, offSpringFitness, objectiveVal, g):
+    if self.counter == 1:
+      self.population = offSprings
+      self.fitness = offSpringFitness
+      self.objectiveVal = rlz[self._objectiveVar[0]].data
+    else:
+      self.population, self.fitness,\
+      self.popAge,self.objectiveVal = self._survivorSelectionInstance(age=self.popAge,
+                                                                      variables=list(self.toBeSampled),
+                                                                      population=self.population,
+                                                                      fitness=self.fitness,
+                                                                      newRlz=rlz,
+                                                                      offSpringsFitness=offSpringFitness,
+                                                                      popObjectiveVal=self.objectiveVal)
+
+def multiObjSurvivorSelect(self, info, rlz, traj, offSprings, offSpringFitness, objectiveVal, g):
+    if self.counter == 1:
+      self.population = offSprings
+      self.fitness = offSpringFitness
+      self.constraintsV = g
+      # offspringObjsVals for Rank and CD calculation
+      offObjVal = []
+      for i in range(len(self._objectiveVar)):
+        offObjVal.append(list(np.atleast_1d(rlz[self._objectiveVar[i]].data)))
+
+      # offspringFitVals for Rank and CD calculation
+      fitVal           = datasetToDataArray(self.fitness, self._objectiveVar).data
+      offspringFitVals = fitVal.tolist()
+      offSpringRank = frontUtils.rankNonDominatedFrontiers(np.array(offspringFitVals))
+      self.rank     = xr.DataArray(offSpringRank,
+                                    dims=['rank'],
+                                    coords={'rank': np.arange(np.shape(offSpringRank)[0])})
+      offSpringCD           = frontUtils.crowdingDistance(rank=offSpringRank,
+                                                          popSize=len(offSpringRank),
+                                                          objectives=np.array(offspringFitVals))
+
+      self.crowdingDistance = xr.DataArray(offSpringCD,
+                                            dims=['CrowdingDistance'],
+                                            coords={'CrowdingDistance': np.arange(np.shape(offSpringCD)[0])})
+      self.objectiveVal = []
+      for i in range(len(self._objectiveVar)):
+        self.objectiveVal.append(list(np.atleast_1d(rlz[self._objectiveVar[i]].data)))
+    else:
+      self.population,self.rank, \
+      self.popAge,self.crowdingDistance, \
+      self.objectiveVal,self.fitness, \
+      self.constraintsV                  = self._survivorSelectionInstance(age=self.popAge,
+                                                                           variables=list(self.toBeSampled),
+                                                                           population=self.population,
+                                                                           offsprings=rlz,
+                                                                           popObjectiveVal=self.objectiveVal,
+                                                                           offObjectiveVal=objectiveVal,
+                                                                           popFit = self.fitness,
+                                                                           offFit = offSpringFitness,
+                                                                           popConstV = self.constraintsV,
+                                                                           offConstV = g)
+
+    self._collectOptPointMulti(self.population,
+                               self.rank,
+                               self.crowdingDistance,
+                               self.objectiveVal,
+                               self.fitness,
+                               self.constraintsV)
+    self._resolveNewGenerationMulti(traj, rlz, info)

ravenframework/Optimizers/survivorSelectors/survivorSelectors.py

@@ -33,74 +33,6 @@
 
 # @profile
 
-def singleObjSurvivorSelect(self, info, rlz, traj, offSprings, offSpringFitness, objectiveVal, g):
-    if self.counter == 1:
-      self.population = offSprings
-      self.fitness = offSpringFitness
-      self.objectiveVal = rlz[self._objectiveVar[0]].data
-    else:
-      self.population, self.fitness,\
-      self.popAge,self.objectiveVal = self._survivorSelectionInstance(age=self.popAge,
-                                                                      variables=list(self.toBeSampled),
-                                                                      population=self.population,
-                                                                      fitness=self.fitness,
-                                                                      newRlz=rlz,
-                                                                      offSpringsFitness=offSpringFitness,
-                                                                      popObjectiveVal=self.objectiveVal)
-
-def multiObjSurvivorSelect(self, info, rlz, traj, offSprings, offSpringFitness, objectiveVal, g):
-    if self.counter == 1:
-      self.population = offSprings
-      self.fitness = offSpringFitness
-      self.constraintsV = g
-      # offspringObjsVals for Rank and CD calculation
-      offObjVal = []
-      for i in range(len(self._objectiveVar)):
-        offObjVal.append(list(np.atleast_1d(rlz[self._objectiveVar[i]].data)))
-
-      # offspringFitVals for Rank and CD calculation
-      fitVal           = datasetToDataArray(self.fitness, self._objectiveVar).data
-      offspringFitVals = fitVal.tolist()
-      offSpringRank = frontUtils.rankNonDominatedFrontiers(np.array(offspringFitVals))
-      self.rank     = xr.DataArray(offSpringRank,
-                                    dims=['rank'],
-                                    coords={'rank': np.arange(np.shape(offSpringRank)[0])})
-      offSpringCD           = frontUtils.crowdingDistance(rank=offSpringRank,
-                                                          popSize=len(offSpringRank),
-                                                          objectives=np.array(offspringFitVals))
-
-      self.crowdingDistance = xr.DataArray(offSpringCD,
-                                            dims=['CrowdingDistance'],
-                                            coords={'CrowdingDistance': np.arange(np.shape(offSpringCD)[0])})
-      self.objectiveVal = []
-      for i in range(len(self._objectiveVar)):
-        self.objectiveVal.append(list(np.atleast_1d(rlz[self._objectiveVar[i]].data)))
-    else:
-      self.population,self.rank, \
-      self.popAge,self.crowdingDistance, \
-      self.objectiveVal,self.fitness, \
-      self.constraintsV                  = self._survivorSelectionInstance(age=self.popAge,
-                                                                            variables=list(self.toBeSampled),
-                                                                            population=self.population,
-                                                                            offsprings=rlz,
-                                                                            popObjectiveVal=self.objectiveVal,
-                                                                            offObjectiveVal=objectiveVal,
-                                                                            popFit = self.fitness,
-                                                                            offFit = offSpringFitness,
-                                                                            popConstV = self.constraintsV,
-                                                                            offConstV = g)
-
-    self._collectOptPointMulti(self.population,
-                                self.rank,
-                                self.crowdingDistance,
-                                self.objectiveVal,
-                                self.fitness,
-                                self.constraintsV)
-    self._resolveNewGenerationMulti(traj, rlz, info)
-
-
-
-
 def ageBased(newRlz,**kwargs):
   """
     ageBased survivorSelection mechanism for new generation selection.