Changeset 9352 for branches/LearningClassifierSystems/HeuristicLab.Optimization.Operators.LCS/3.3/Selection/NichingTournamentSelector.cs

Timestamp:

04/10/13 15:15:13 (11 years ago)

Author:

sforsten

Message:

#1980:

• added DecisionListView
• added event handlers in *ProblemData
• renamed project Problems.XCS.Views to Problems.lCS.Views and Problems.Instances.ConditionActionClassification to Problems.Instances.LCS
• integrated niching in GAssist and added NichingTournamentSelector
• minor code improvements and property changes

Location:

branches/LearningClassifierSystems/HeuristicLab.Optimization.Operators.LCS/3.3

Files:

• . (modified) (1 prop)
• Selection/NichingTournamentSelector.cs (modified) (4 diffs)

branches/LearningClassifierSystems/HeuristicLab.Optimization.Operators.LCS/3.3/Selection/NichingTournamentSelector.cs

@@ -30 +30 @@
 using HeuristicLab.Selection;
 
-namespace HeuristicLab.Optimization.Operators.LCS.Selection {
+namespace HeuristicLab.Optimization.Operators.LCS {
   [Item("NichingTournamentSelector", "Description missing")]
   [StorableClass]
-  public class NichingTournamentSelector : StochasticSingleObjectiveSelector, ISingleObjectiveSelector {
+  public class NichingTournamentSelector : StochasticSingleObjectiveSelector, INichingSingleObjectiveSelector {
 
     #region Parameter Properties
@@ -39 +39 @@
       get { return (ValueLookupParameter<IntValue>)Parameters["GroupSize"]; }
     }
-    public LookupParameter<IntValue> NichesParameter {
-      get { return (LookupParameter<IntValue>)Parameters["Niches"]; }
+    public ILookupParameter<IGAssistNichesProblemData> GAssistNichesProblemDataParameter {
+      get { return (LookupParameter<IGAssistNichesProblemData>)Parameters["GAssistNichesProblemData"]; }
+    }
+    public ILookupParameter<BoolValue> NichingParameter {
+      get { return (LookupParameter<BoolValue>)Parameters["Niching"]; }
+    }
+    public IValueLookupParameter<IntValue> ParentsPerChildParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["ParentsPerChild"]; }
+    }
+    public ILookupParameter<ItemArray<IGAssistIndividual>> IndividualParameter {
+      get { return (ILookupParameter<ItemArray<IGAssistIndividual>>)Parameters["Individual"]; }
     }
     #endregion
@@ -52 +61 @@
       : base() {
       Parameters.Add(new ValueLookupParameter<IntValue>("GroupSize", "The size of the tournament group.", new IntValue(2)));
-      Parameters.Add(new LookupParameter<IntValue>("Niches", ""));
+      Parameters.Add(new LookupParameter<IGAssistNichesProblemData>("GAssistNichesProblemData", ""));
+      Parameters.Add(new LookupParameter<BoolValue>("Niching", ""));
+      Parameters.Add(new ValueLookupParameter<IntValue>("ParentsPerChild", ""));
+      Parameters.Add(new ScopeTreeLookupParameter<IGAssistIndividual>("Individual", ""));
     }
     public override IDeepCloneable Clone(Cloner cloner) {
@@ -64 +76 @@
       bool maximization = MaximizationParameter.ActualValue.Value;
       List<double> qualities = QualityParameter.ActualValue.Where(x => IsValidQuality(x.Value)).Select(x => x.Value).ToList();
+      List<IGAssistIndividual> individuals = IndividualParameter.ActualValue.ToList();
       int groupSize = GroupSizeParameter.ActualValue.Value;
       IScope[] selected = new IScope[count];
+      bool doNiching = NichingParameter.ActualValue.Value;
 
       //check if list with indexes is as long as the original scope list
       //otherwise invalid quality values were filtered
-      if (qualities.Count != scopes.Count) {
+      if (qualities.Count != scopes.Count && individuals.Count != scopes.Count) {
         throw new ArgumentException("The scopes contain invalid quality values (either infinity or double.NaN) on which the selector cannot operate.");
       }
 
-      for (int i = 0; i < count; i++) {
-        int best = random.Next(scopes.Count);
-        int index;
-        for (int j = 1; j < groupSize; j++) {
-          index = random.Next(scopes.Count);
-          if (((maximization) && (qualities[index] > qualities[best])) ||
-              ((!maximization) && (qualities[index] < qualities[best]))) {
-            best = index;
+      int parentsPerChild = ParentsPerChildParameter.ActualValue.Value;
+      var possibleNiches = GAssistNichesProblemDataParameter.ActualValue.GetPossibleNiches().ToList();
+      var selectPerNiche = new Dictionary<IGAssistNiche, int>(possibleNiches.First().Comparer);
+
+      var nicheScope = new Dictionary<IGAssistNiche, List<int>>(possibleNiches.First().Comparer);
+      foreach (var niche in possibleNiches) {
+        nicheScope.Add(niche, new List<int>());
+        selectPerNiche.Add(niche, count / possibleNiches.Count);
+      }
+
+      for (int i = 0; i < individuals.Count; i++) {
+        nicheScope[individuals[i].Niche].Add(i);
+      }
+
+      int curCount = 0;
+      while (curCount < count) {
+        IGAssistNiche niche = null;
+        int best = -1;
+        if (doNiching) {
+          niche = GetNiche(random, selectPerNiche, possibleNiches);
+        } else {
+          best = random.Next(scopes.Count);
+        }
+        for (int i = 0; i < parentsPerChild; i++) {
+          int index;
+          if (doNiching) {
+            best = nicheScope[niche][random.Next(nicheScope[niche].Count)];
           }
-        }
+          for (int j = 1; j < groupSize; j++) {
+            if (niche != null) {
+              index = nicheScope[niche][random.Next(nicheScope[niche].Count)];
+            } else {
+              index = random.Next(scopes.Count);
+            }
+            if (((maximization) && (qualities[index] > qualities[best])) ||
+                ((!maximization) && (qualities[index] < qualities[best]))) {
+              best = index;
+            }
+          }
 
-        if (copy)
-          selected[i] = (IScope)scopes[best].Clone();
-        else {
-          selected[i] = scopes[best];
-          scopes.RemoveAt(best);
-          qualities.RemoveAt(best);
+          niche = individuals[best].Niche;
+
+          if (copy)
+            selected[curCount] = (IScope)scopes[best].Clone();
+          else {
+            selected[curCount] = scopes[best];
+            scopes.RemoveAt(best);
+            qualities.RemoveAt(best);
+          }
+          selectPerNiche[niche]--;
+          curCount++;
         }
       }
+
       return selected;
+    }
+
+    private IGAssistNiche GetNiche(IRandom random, Dictionary<IGAssistNiche, int> nicheScope, List<IGAssistNiche> possibleNiches) {
+      int sum = nicheScope.Values.Sum();
+      if (sum <= 0) { return possibleNiches[random.Next(possibleNiches.Count)]; }
+      int pos = random.Next(sum);
+      int total = 0;
+      IGAssistNiche niche = nicheScope.Keys.First();
+      foreach (var item in nicheScope) {
+        total += item.Value;
+        niche = item.Key;
+        if (pos < total) {
+          return niche;
+        }
+      }
+      throw new ArgumentException("error in code");
     }
   }