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

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)
• DefaultRule/AutoDefaultRule.cs (modified) (4 diffs)
• DefaultRule/DefaultRuleOperator.cs (modified) (2 diffs)
• DefaultRule/IDefaultRuleOperator.cs (modified) (1 diff)
• DefaultRule/MajorDefaultRule.cs (modified) (1 diff)
• DefaultRule/MinorDefaultRule.cs (modified) (1 diff)
• GAssist/IGAssistNichesProblemData.cs (added)
• GAssist/IGAssistProblem.cs (added)
• GAssist/Interfaces/IGAssistIndividual.cs (modified) (1 diff)
• GAssist/Interfaces/IGAssistNiche.cs (modified) (2 diffs)
• HeuristicLab.Optimization.Operators.LCS-3.3.csproj (modified) (6 diffs)
• Properties (modified) (1 prop)
• Selection/INichingSingleObjectiveSelector.cs (added)
• Selection/NichingTournamentSelector.cs (modified) (4 diffs)

branches/LearningClassifierSystems/HeuristicLab.Optimization.Operators.LCS/3.3/DefaultRule/AutoDefaultRule.cs

@@ -44 +44 @@
       get { return (ILookupParameter<ItemArray<DoubleValue>>)Parameters["Quality"]; }
     }
-    public ILookupParameter<ItemArray<IGAssistIndividual>> IndividualParameter {
-      get { return (ILookupParameter<ItemArray<IGAssistIndividual>>)Parameters["Individual"]; }
-    }
     public IValueLookupParameter<IntValue> AccuraciesCountParameter {
       get { return (IValueLookupParameter<IntValue>)Parameters["AccuraciesCount"]; }
@@ -70 +67 @@
       Parameters.Add(new ValueLookupParameter<ItemDictionary<IGAssistNiche, ItemList<DoubleValue>>>("AverageAccuracies"));
       Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Quality"));
-      Parameters.Add(new ScopeTreeLookupParameter<IGAssistIndividual>("Individual"));
       Parameters.Add(new LookupParameter<IRandom>("Random"));
-      Parameters.Add(new ValueLookupParameter<IntValue>("AccuraciesCount"));
+      Parameters.Add(new ValueLookupParameter<IntValue>("AccuraciesCount", new IntValue(15)));
       Parameters.Add(new ValueLookupParameter<IGAssistNicheEqualityComparer>("NicheComparer"));
-      Parameters.Add(new ValueLookupParameter<DoubleValue>("NicheStandardDeviation"));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("NicheStandardDeviation", new DoubleValue(0.005)));
     }
     public override IDeepCloneable Clone(Cloner cloner) {
@@ -82 +78 @@
     public override IOperation Apply() {
       if (NichingParameter.ActualValue == null) {
+        IList<IGAssistNiche> niches = GAssistNichesProblemDataParameter.ActualValue.GetPossibleNiches().ToList();
         NichingParameter.ActualValue = new BoolValue(true);
-        NichesParameter.ActualValue = new IntValue(PossibleDefaultClassesParameter.ActualValue.Count);
-        AverageAccuraciesParameter.ActualValue = new ItemDictionary<IGAssistNiche, ItemList<DoubleValue>>(NicheComparerParameter.ActualValue);
-        foreach (var niche in PossibleDefaultClassesParameter.ActualValue) {
+        NichesParameter.ActualValue = new IntValue(niches.Count);
+        AverageAccuraciesParameter.ActualValue = new ItemDictionary<IGAssistNiche, ItemList<DoubleValue>>(NicheComparerParameter.ActualValue as IEqualityComparer<IGAssistNiche>);
+        foreach (var niche in GAssistNichesProblemDataParameter.ActualValue.GetPossibleNiches()) {
           AverageAccuracies.Add(niche, new ItemList<DoubleValue>(AccuraciesCount));
         }
+
+        int i = 0;
+        foreach (var individual in IndividualParameter.ActualValue) {
+          individual.SetNiche(RandomParameter.ActualValue, niches[i]);
+          i++;
+          i %= niches.Count;
+        }
+
+        OperationCollection next = new OperationCollection();
+        next.Add(EvaluateSubScopes());
+        next.Add(base.Apply());
+        return next;
       } else {
         var nicheFitness = new Dictionary<IGAssistNiche, double>(NicheComparerParameter.ActualValue);
-        foreach (var niche in PossibleDefaultClassesParameter.ActualValue) {
+        foreach (var niche in GAssistNichesProblemDataParameter.ActualValue.GetPossibleNiches()) {
           nicheFitness[niche] = 0.0;
           while (AverageAccuracies[niche].Count >= AccuraciesCount) {
@@ -105 +114 @@
         }
 
-        foreach (var niche in PossibleDefaultClassesParameter.ActualValue) {
+        foreach (var niche in GAssistNichesProblemDataParameter.ActualValue.GetPossibleNiches()) {
           AverageAccuracies[niche].Insert(0, new DoubleValue(nicheFitness[niche]));
         }
 
-        var averages = new List<double>(PossibleDefaultClassesParameter.ActualValue.Count);
+        var averages = new List<double>(GAssistNichesProblemDataParameter.ActualValue.GetPossibleNiches().Count());
         if (AverageAccuracies.Values.First().Count >= AccuraciesCount) {
           foreach (var averageAccuracy in AverageAccuracies.Values) {

branches/LearningClassifierSystems/HeuristicLab.Optimization.Operators.LCS/3.3/DefaultRule/DefaultRuleOperator.cs

@@ -42 +42 @@
       get { return (IValueLookupParameter<IGAssistNiche>)Parameters["DefaultClass"]; }
     }
-    public ILookupParameter<ItemCollection<IGAssistNiche>> PossibleDefaultClassesParameter {
-      get { return (ILookupParameter<ItemCollection<IGAssistNiche>>)Parameters["PossibleDefaultClasses"]; }
+    public ILookupParameter<IGAssistNichesProblemData> GAssistNichesProblemDataParameter {
+      get { return (ILookupParameter<IGAssistNichesProblemData>)Parameters["GAssistNichesProblemData"]; }
+    }
+    public ILookupParameter<ItemArray<IGAssistIndividual>> IndividualParameter {
+      get { return (ILookupParameter<ItemArray<IGAssistIndividual>>)Parameters["Individual"]; }
+    }
+    public IValueLookupParameter<IOperator> EvaluatorParameter {
+      get { return (IValueLookupParameter<IOperator>)Parameters["Evaluator"]; }
     }
     #endregion
@@ -57 +63 @@
       Parameters.Add(new ValueLookupParameter<IntValue>("Niches"));
       Parameters.Add(new ValueLookupParameter<IGAssistNiche>("DefaultClass"));
-      Parameters.Add(new LookupParameter<ItemCollection<IGAssistNiche>>("PossibleDefaultClasses"));
+      Parameters.Add(new LookupParameter<IGAssistNichesProblemData>("GAssistNichesProblemData"));
+      Parameters.Add(new ScopeTreeLookupParameter<IGAssistIndividual>("Individual"));
+      Parameters.Add(new ValueLookupParameter<IOperator>("Evaluator"));
+    }
+
+    protected OperationCollection EvaluateSubScopes() {
+      IOperator evaluator = EvaluatorParameter.ActualValue;
+      OperationCollection evaluation = new OperationCollection();
+      if (evaluator != null) {
+        foreach (var subScope in ExecutionContext.Scope.SubScopes) {
+          evaluation.Add(ExecutionContext.CreateOperation(evaluator, subScope));
+        }
+      }
+      return evaluation;
     }
   }

branches/LearningClassifierSystems/HeuristicLab.Optimization.Operators.LCS/3.3/DefaultRule/IDefaultRuleOperator.cs

@@ -26 +26 @@
   public interface IDefaultRuleOperator : IOperator {
     IValueLookupParameter<BoolValue> NichingParameter { get; }
-    ILookupParameter<IntValue> NichesParameter { get; }
-    IValueLookupParameter<Item> DefaultClassParameter { get; }
-    ILookupParameter<ItemCollection<IGAssistNiche>> PossibleDefaultClassesParameter { get; }
+    IValueLookupParameter<IntValue> NichesParameter { get; }
+    IValueLookupParameter<IGAssistNiche> DefaultClassParameter { get; }
+    ILookupParameter<IGAssistNichesProblemData> GAssistNichesProblemDataParameter { get; }
+    ILookupParameter<ItemArray<IGAssistIndividual>> IndividualParameter { get; }
+    IValueLookupParameter<IOperator> EvaluatorParameter { get; }
   }
 }

branches/LearningClassifierSystems/HeuristicLab.Optimization.Operators.LCS/3.3/DefaultRule/MajorDefaultRule.cs

@@ -77 +77 @@
           index = indices[0];
         }
-        DefaultClassParameter.ActualValue = PossibleDefaultClassesParameter.ActualValue.ElementAt(index);
+        IGAssistNiche niche = GAssistNichesProblemDataParameter.ActualValue.GetPossibleNiches().ElementAt(index);
+        DefaultClassParameter.ActualValue = niche;
+
+        foreach (var individual in IndividualParameter.ActualValue) {
+          individual.SetNiche(RandomParameter.ActualValue, niche);
+        }
+
+        OperationCollection next = new OperationCollection();
+        next.Add(EvaluateSubScopes());
+        next.Add(base.Apply());
+        return next;
       }
       return base.Apply();

branches/LearningClassifierSystems/HeuristicLab.Optimization.Operators.LCS/3.3/DefaultRule/MinorDefaultRule.cs

@@ -77 +77 @@
           index = indices[0];
         }
-        DefaultClassParameter.ActualValue = PossibleDefaultClassesParameter.ActualValue.ElementAt(index);
+        IGAssistNiche niche = GAssistNichesProblemDataParameter.ActualValue.GetPossibleNiches().ElementAt(index);
+        DefaultClassParameter.ActualValue = niche;
+
+        foreach (var individual in IndividualParameter.ActualValue) {
+          individual.SetNiche(RandomParameter.ActualValue, niche);
+        }
+
+        OperationCollection next = new OperationCollection();
+        next.Add(EvaluateSubScopes());
+        next.Add(base.Apply());
+        return next;
       }
       return base.Apply();

branches/LearningClassifierSystems/HeuristicLab.Optimization.Operators.LCS/3.3/GAssist/Interfaces/IGAssistIndividual.cs

@@ -26 +26 @@
   public interface IGAssistIndividual : IItem {
     IGAssistNiche Niche { get; }
+    void SetNiche(IRandom random, IGAssistNiche niche);
     void ApplySplit(IRandom random, double probability);
     void ApplyMerge(IRandom random, double probability);

branches/LearningClassifierSystems/HeuristicLab.Optimization.Operators.LCS/3.3/GAssist/Interfaces/IGAssistNiche.cs

@@ -20 +20 @@
 #endregion
 
+using System.Collections.Generic;
 using HeuristicLab.Core;
 
@@ -25 +26 @@
   public interface IGAssistNiche : IItem {
     bool SameNiche(IGAssistNiche niche);
+    int GetNicheHashCode();
+    IEqualityComparer<IGAssistNiche> Comparer { get; }
   }
 }

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

@@ -46 +46 @@
       <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Common-3.3.dll</HintPath>
     </Reference>
-    <Reference Include="HeuristicLab.Core-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
-      <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Core-3.3.dll</HintPath>
-    </Reference>
     <Reference Include="HeuristicLab.Data-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
@@ -84 +80 @@
     <Reference Include="System" />
     <Reference Include="System.Core" />
+    <Reference Include="System.Drawing" />
     <Reference Include="System.Xml.Linq" />
     <Reference Include="System.Data.DataSetExtensions" />
@@ -92 +89 @@
   <ItemGroup>
     <Compile Include="DefaultRule\AutoDefaultRule.cs" />
+    <Compile Include="GAssist\IGAssistNichesProblemData.cs" />
     <Compile Include="DefaultRule\MajorDefaultRule.cs" />
     <Compile Include="DefaultRule\DefaultRuleOperator.cs" />
@@ -99 +97 @@
     <Compile Include="Discretizer\UniformWidthDiscretizer.cs" />
     <Compile Include="Discretizer\IDiscretizer.cs" />
+    <Compile Include="GAssist\IGAssistProblem.cs" />
     <Compile Include="GAssist\Interfaces\IGAssistIndividual.cs" />
     <Compile Include="GAssist\Interfaces\IGAssistIndividualCreator.cs" />
@@ -110 +109 @@
     <Compile Include="GAssist\SpecialStage\SplitOperator.cs" />
     <Compile Include="Plugin.cs" />
+    <Compile Include="Selection\INichingSingleObjectiveSelector.cs" />
     <Compile Include="Selection\NichingTournamentSelector.cs" />
     <Compile Include="Selection\PreservingRightReducer.cs" />
@@ -119 +119 @@
     <None Include="Plugin.cs.frame" />
   </ItemGroup>
-  <ItemGroup />
+  <ItemGroup>
+    <ProjectReference Include="..\..\HeuristicLab.Core\3.3\HeuristicLab.Core-3.3.csproj">
+      <Project>{c36bd924-a541-4a00-afa8-41701378ddc5}</Project>
+      <Name>HeuristicLab.Core-3.3</Name>
+    </ProjectReference>
+  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <PropertyGroup>

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");
     }
   }