Changeset 9110 for branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3

Timestamp:

01/04/13 20:46:18 (12 years ago)

Author:

sforsten

Message:

#1980:

• added GA subsumption
• simplified deletion before covering
• simplified XCSDeletionOperator

Location:

branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3

Files:

• Covering/CoveringOperator.cs (modified) (1 diff)
• Covering/DoDeletionBeforeCovering.cs (modified) (4 diffs)
• Deletion/XCSDeletionOperator.cs (modified) (5 diffs)
• Evaluators/XCSEvaluator.cs (modified) (3 diffs)
• GA/InsertInPopulationOperator.cs (added)
• GA/TempSubScopeIDAssigner.cs (added)
• GA/XCSAfterCrossoverOperator.cs (modified) (3 diffs)
• HeuristicLab.Encodings.ConditionActionEncoding-3.3.csproj (modified) (3 diffs)
• Interfaces/IConditionActionProblem.cs (modified) (1 diff)
• Operator/MatchConditionOperator.cs (modified) (1 diff)
• Operator/SubScopeVariableCopier.cs (deleted)
• Subsumption/ActionSetSubsumptionOperator.cs (moved) (moved from branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Subsumption/ActionSetSubsumptionoperator.cs) (5 diffs)
• Subsumption/CheckGASubsumptionOperator.cs (added)
• Subsumption/ExecuteGASubsumptionOperator.cs (added)
• Subsumption/IActionSetSubsumption.cs (modified) (1 diff)

branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Covering/CoveringOperator.cs

@@ -101 +101 @@
         throw new ArgumentException("More classifiers with unique actions shall be created than unique actions are available.");
       }
+      if (count > 0) {
+        CurrentPopulationSizeParameter.ActualValue.Value += count;
 
-      CurrentPopulationSizeParameter.ActualValue.Value += count;
+        int current = CurrentScope.SubScopes.Count;
+        for (int i = 0; i < count; i++) {
+          CurrentScope.SubScopes.Add(new Scope((current + i).ToString()));
+        }
 
-      int current = CurrentScope.SubScopes.Count;
-      for (int i = 0; i < count; i++) {
-        CurrentScope.SubScopes.Add(new Scope((current + i).ToString()));
+        creator.ActionParameter.ActualName = "Action";
+        OperationCollection variableCreation = new OperationCollection() { Parallel = parallel };
+        OperationCollection creation = new OperationCollection();
+        OperationCollection evaluation = new OperationCollection() { Parallel = parallel };
+        for (int i = 0; i < count; i++) {
+          VariableCreator variableCreator = new VariableCreator();
+          int pos = RandomParameter.ActualValue.Next(clone.Count);
+          IClassifier action = clone.ElementAt(pos);
+          clone.Remove(action);
+          variableCreator.CollectedValues.Add(new ValueParameter<IClassifier>("Action", action));
+          variableCreation.Add(ExecutionContext.CreateOperation(variableCreator, CurrentScope.SubScopes[current + i]));
+          creation.Add(ExecutionContext.CreateOperation(creator, CurrentScope.SubScopes[current + i]));
+          evaluation.Add(ExecutionContext.CreateOperation(evaluator, CurrentScope.SubScopes[current + i]));
+        }
+        OperationCollection next = new OperationCollection();
+        next.Add(variableCreation);
+        next.Add(creation);
+        next.Add(evaluation);
+        next.Add(base.Apply());
+        return next;
+      } else {
+        return base.Apply();
       }
-
-      creator.ActionParameter.ActualName = "Action";
-      OperationCollection variableCreation = new OperationCollection() { Parallel = parallel };
-      OperationCollection creation = new OperationCollection();
-      OperationCollection evaluation = new OperationCollection() { Parallel = parallel };
-      for (int i = 0; i < count; i++) {
-        VariableCreator variableCreator = new VariableCreator();
-        int pos = RandomParameter.ActualValue.Next(clone.Count);
-        IClassifier action = clone.ElementAt(pos);
-        clone.Remove(action);
-        variableCreator.CollectedValues.Add(new ValueParameter<IClassifier>("Action", action));
-        variableCreation.Add(ExecutionContext.CreateOperation(variableCreator, CurrentScope.SubScopes[current + i]));
-        creation.Add(ExecutionContext.CreateOperation(creator, CurrentScope.SubScopes[current + i]));
-        evaluation.Add(ExecutionContext.CreateOperation(evaluator, CurrentScope.SubScopes[current + i]));
-      }
-      OperationCollection next = new OperationCollection();
-      next.Add(variableCreation);
-      next.Add(creation);
-      next.Add(evaluation);
-      next.Add(base.Apply());
-      return next;
     }
   }

branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Covering/DoDeletionBeforeCovering.cs

@@ -20 +20 @@
 #endregion
 
+using System;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -33 +34 @@
 
     #region Parameter Properties
+    public ILookupParameter<ItemArray<IClassifier>> ClassifiersParameter {
+      get { return (ILookupParameter<ItemArray<IClassifier>>)Parameters["Classifiers"]; }
+    }
+    public ILookupParameter<ItemArray<BoolValue>> MatchConditionParameter {
+      get { return (ILookupParameter<ItemArray<BoolValue>>)Parameters["MatchCondition"]; }
+    }
     public ILookupParameter<IntValue> MinimalNumberOfUniqueActionsParameter {
       get { return (ILookupParameter<IntValue>)Parameters["MinimalNumberOfUniqueActions"]; }
-    }
-    public ILookupParameter<IntValue> NumberOfUniqueActionsParameter {
-      get { return (ILookupParameter<IntValue>)Parameters["NumberOfUniqueActions"]; }
     }
     public ILookupParameter<IntValue> CurrentPopulationSizeParameter {
@@ -60 +64 @@
     public DoDeletionBeforeCoveringOperator()
       : base() {
+      Parameters.Add(new ScopeTreeLookupParameter<IClassifier>("Classifiers"));
+      Parameters.Add(new ScopeTreeLookupParameter<BoolValue>("MatchCondition"));
       Parameters.Add(new LookupParameter<IntValue>("MinimalNumberOfUniqueActions"));
-      Parameters.Add(new LookupParameter<IntValue>("NumberOfUniqueActions"));
       Parameters.Add(new LookupParameter<IntValue>("CurrentPopulationSize"));
       Parameters.Add(new LookupParameter<IntValue>("PopulationSize"));
@@ -72 +77 @@
 
     public override IOperation Apply() {
+      IItemSet<IClassifier> uniqueActions = new ItemSet<IClassifier>();
+      var classifiers = ClassifiersParameter.ActualValue;
+      var matchcondition = MatchConditionParameter.ActualValue;
+
+      if (classifiers.Length != matchcondition.Length) {
+        throw new ArgumentException("Number of classifiers is not equal to the number of 'MatchCondition' variables.");
+      }
+
+      for (int i = 0; i < classifiers.Length; i++) {
+        if (matchcondition[i].Value) {
+          uniqueActions.Add(classifiers[i].Action);
+        }
+      }
+
       int populationAfterCovering = MinimalNumberOfUniqueActionsParameter.ActualValue.Value
-                                    - NumberOfUniqueActionsParameter.ActualValue.Value
+                                    - uniqueActions.Count
                                     + CurrentPopulationSizeParameter.ActualValue.Value;
       BoolValue doDeletion = new BoolValue(populationAfterCovering > PopulationSizeParameter.ActualValue.Value);

branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Deletion/XCSDeletionOperator.cs

@@ -51 +51 @@
       get { return (ILookupParameter<ItemArray<IntValue>>)Parameters["Experiences"]; }
     }
+    public ILookupParameter<ItemArray<BoolValue>> HasToBeDeletedParameter {
+      get { return (ILookupParameter<ItemArray<BoolValue>>)Parameters["HasToBeDeleted"]; }
+    }
     public ILookupParameter<IntValue> ThetaDeletionParameter {
       get { return (ILookupParameter<IntValue>)Parameters["ThetaDeletion"]; }
@@ -63 +66 @@
       get { return (ILookupParameter<IntValue>)Parameters["CurrentPopulationSize"]; }
     }
-    protected ScopeParameter CurrentScopeParameter {
-      get { return (ScopeParameter)Parameters["CurrentScope"]; }
-    }
-    public IScope CurrentScope {
-      get { return CurrentScopeParameter.ActualValue; }
-    }
-    public string HasToBeDeletedVariableName { get { return "HasToBeDeleted"; } }
     #endregion
 
@@ -89 +85 @@
       Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Fitnesses"));
       Parameters.Add(new ScopeTreeLookupParameter<IntValue>("Experiences"));
+      Parameters.Add(new ScopeTreeLookupParameter<BoolValue>("HasToBeDeleted"));
       Parameters.Add(new LookupParameter<IntValue>("ThetaDeletion"));
       Parameters.Add(new LookupParameter<PercentValue>("Delta"));
       Parameters.Add(new LookupParameter<IRandom>("Random"));
-      Parameters.Add(new ScopeParameter("CurrentScope"));
       Parameters.Add(new LookupParameter<IntValue>("CurrentPopulationSize"));
     }
@@ -104 +100 @@
       var experiences = ExperiencesParameter.ActualValue;
       var averageActionSetSizes = AverageActionSetSizesParameter.ActualValue;
-      var subscopes = CurrentScope.SubScopes;
+      var hasToBeDeleted = HasToBeDeletedParameter.ActualValue;
       double fitnessSum = fitnesses.Select(x => x.Value).Sum();
       double numerositySum = numerosities.Select(x => x.Value).Sum();
 
-      if (fitnesses.Length != numerosities.Length && fitnesses.Length != experiences.Length && fitnesses.Length != subscopes.Count) {
+      if (fitnesses.Length != numerosities.Length && fitnesses.Length != experiences.Length) {
         throw new ArgumentException("Different number of fitness, numerosity and experience values.");
-      }
-
-      for (int cl = 0; cl < fitnesses.Length; cl++) {
-        if (subscopes[cl].Variables.ContainsKey(HasToBeDeletedVariableName)) {
-          ((BoolValue)subscopes[cl].Variables[HasToBeDeletedVariableName].Value).Value = false;
-        } else {
-          subscopes[cl].Variables.Add(new Variable(HasToBeDeletedVariableName, new BoolValue(false)));
-        }
       }
 
@@ -131 +119 @@
         voteSum = 0;
         for (int cl = 0; cl < fitnesses.Length; cl++) {
-          if (numerosities[cl].Value > 0) {
+          if (numerosities[cl].Value > 0 && !hasToBeDeleted[cl].Value) {
             voteSum += DeletionVote(averageFitnessInPopulation, averageActionSetSizes[cl].Value, numerosities[cl].Value, fitnesses[cl].Value, experiences[cl].Value);
             if (voteSum > choicePoint) {
               if (numerosities[cl].Value <= 1) {
-                ((BoolValue)subscopes[cl].Variables[HasToBeDeletedVariableName].Value).Value = true;
+                hasToBeDeleted[cl].Value = true;
                 fitnessSum -= fitnesses[cl].Value;
               }

branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Evaluators/XCSEvaluator.cs

@@ -56 +56 @@
     public IValueLookupParameter<IntValue> NumerosityParameter {
       get { return (IValueLookupParameter<IntValue>)Parameters["Numerosity"]; }
+    }
+    public IValueLookupParameter<BoolValue> InsertInPopulationParameter {
+      get { return (IValueLookupParameter<BoolValue>)Parameters["InsertInPopulation"]; }
     }
     public ILookupParameter<DoubleValue> InitialPredictionParameter {
@@ -156 +159 @@
       Parameters.Add(new LookupParameter<DoubleValue>("AccuracySum", ""));
       Parameters.Add(new ValueLookupParameter<IntValue>("Numerosity", ""));
+      Parameters.Add(new ValueLookupParameter<BoolValue>("InsertInPopulation", ""));
 
       Parameters.Add(new LookupParameter<DoubleValue>("InitialPrediction"));
@@ -178 +182 @@
         AverageActionSetSizeParameter.ActualValue = new DoubleValue(1);
         NumerosityParameter.ActualValue = new IntValue(1);
+        InsertInPopulationParameter.ActualValue = new BoolValue(false);
       } else {
         Experience += 1;

branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/GA/XCSAfterCrossoverOperator.cs

@@ -55 +55 @@
       get { return (IValueLookupParameter<DoubleValue>)Parameters["Fitness"]; }
     }
+    public IValueLookupParameter<BoolValue> InsertInPopulationParameter {
+      get { return (IValueLookupParameter<BoolValue>)Parameters["InsertInPopulation"]; }
+    }
+    public IValueLookupParameter<IntValue> TempIDParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["TempID"]; }
+    }
     public ILookupParameter<IntValue> CurrentIterationParameter {
       get { return (ILookupParameter<IntValue>)Parameters["CurrentIteration"]; }
@@ -86 +92 @@
       Parameters.Add(new ValueLookupParameter<DoubleValue>("Error"));
       Parameters.Add(new ValueLookupParameter<DoubleValue>("Fitness"));
+      Parameters.Add(new ValueLookupParameter<BoolValue>("InsertInPopulation"));
+      Parameters.Add(new ValueLookupParameter<IntValue>("TempID"));
       Parameters.Add(new LookupParameter<IntValue>("CurrentIteration"));
       Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("ParentAverageActionSetSize"));
@@ -108 +116 @@
       ErrorParameter.ActualValue = new DoubleValue(0.25 * parentPrecisionError.Select(x => x.Value).Average());
       FitnessParameter.ActualValue = new DoubleValue(0.1 * parentFitness.Select(x => x.Value).Average());
+      InsertInPopulationParameter.ActualValue = new BoolValue(true);
+      TempIDParameter.ActualValue = new IntValue(-1);
       return base.Apply();
     }

branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/HeuristicLab.Encodings.ConditionActionEncoding-3.3.csproj

@@ -92 +92 @@
     <Compile Include="Evaluators\IConditionActionEvaluator.cs" />
     <Compile Include="Evaluators\IXCSEvaluator.cs" />
+    <Compile Include="GA\InsertInPopulationOperator.cs" />
     <Compile Include="GA\XCSAfterCrossoverOperator.cs" />
     <Compile Include="IClassifier.cs" />
@@ -102 +103 @@
     <Compile Include="Operator\MatchActionOperator.cs" />
     <Compile Include="Operator\MatchConditionOperator.cs" />
-    <Compile Include="Operator\SubScopeVariableCopier.cs" />
     <Compile Include="Operator\SumAccuracy.cs" />
+    <Compile Include="GA\TempSubScopeIDAssigner.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="Plugin.cs" />
@@ -111 +112 @@
     <Compile Include="Selectors\IMatchSelector.cs" />
     <Compile Include="Selectors\MatchSelector.cs" />
-    <Compile Include="Subsumption\ActionSetSubsumptionoperator.cs" />
+    <Compile Include="Subsumption\ActionSetSubsumptionOperator.cs" />
+    <Compile Include="Subsumption\CheckGASubsumptionOperator.cs" />
+    <Compile Include="Subsumption\ExecuteGASubsumptionOperator.cs" />
     <Compile Include="Subsumption\IActionSetSubsumption.cs" />
     <None Include="Properties\AssemblyInfo.cs.frame" />

branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Interfaces/IConditionActionProblem.cs

@@ -33 +33 @@
     IParameter ThetaMinimalNumberOfActionsParameter { get; }
 
+    IParameter PossibleActionsConcreteClassParameter { get; }
     IParameter PossibleActionsParameter { get; }
-    IItemSet<IClassifier> PossibleActions { get; }
+    //IItemSet<IClassifier> PossibleActions { get; }
 
     ICoveringSolutionCreator CoveringSolutionCreator { get; }

branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Operator/MatchConditionOperator.cs

@@ -31 +31 @@
   [StorableClass]
   public class MatchConditionOperator : SingleSuccessorOperator {
-    protected ILookupParameter<BoolValue> MatchConditionParameter {
+    public ILookupParameter<BoolValue> MatchConditionParameter {
       get { return (ILookupParameter<BoolValue>)Parameters["MatchCondition"]; }
     }

branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Subsumption/ActionSetSubsumptionOperator.cs

@@ -31 +31 @@
   [Item("ActionSetSubsumptionoperator", "Description missing")]
   [StorableClass]
-  public class ActionSetSubsumptionoperator : SingleSuccessorOperator, IActionSetSubsumption {
+  public class ActionSetSubsumptionOperator : SingleSuccessorOperator, IActionSetSubsumption {
 
     #region Parameter Properties
@@ -46 +46 @@
       get { return (ILookupParameter<ItemArray<DoubleValue>>)Parameters["Errors"]; }
     }
+    public ILookupParameter<ItemArray<BoolValue>> HasBeenSubsumedParameter {
+      get { return (ILookupParameter<ItemArray<BoolValue>>)Parameters["HasBeenSubsumed"]; }
+    }
     public ILookupParameter<DoubleValue> ErrorZeroParameter {
       get { return (ILookupParameter<DoubleValue>)Parameters["ErrorZero"]; }
@@ -52 +55 @@
       get { return (ILookupParameter<IntValue>)Parameters["ThetaSubsumption"]; }
     }
-    protected ScopeParameter CurrentScopeParameter {
-      get { return (ScopeParameter)Parameters["CurrentScope"]; }
-    }
-    public IScope CurrentScope {
-      get { return CurrentScopeParameter.ActualValue; }
-    }
-
-    public string HasBeenSubsumedParameterName {
-      get { return "HasBeenSubsumed"; }
-    }
     #endregion
 
     [StorableConstructor]
-    protected ActionSetSubsumptionoperator(bool deserializing) : base(deserializing) { }
-    protected ActionSetSubsumptionoperator(ActionSetSubsumptionoperator original, Cloner cloner)
+    protected ActionSetSubsumptionOperator(bool deserializing) : base(deserializing) { }
+    protected ActionSetSubsumptionOperator(ActionSetSubsumptionOperator original, Cloner cloner)
       : base(original, cloner) {
     }
-    public ActionSetSubsumptionoperator()
+    public ActionSetSubsumptionOperator()
       : base() {
       Parameters.Add(new ScopeTreeLookupParameter<IClassifier>("Classifiers"));
@@ -75 +68 @@
       Parameters.Add(new ScopeTreeLookupParameter<IntValue>("Experiences"));
       Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Errors"));
+      Parameters.Add(new ScopeTreeLookupParameter<BoolValue>("HasBeenSubsumed"));
       Parameters.Add(new LookupParameter<DoubleValue>("ErrorZero"));
       Parameters.Add(new LookupParameter<IntValue>("ThetaSubsumption"));
-      Parameters.Add(new ScopeParameter("CurrentScope"));
     }
     public override IDeepCloneable Clone(Cloner cloner) {
-      return new ActionSetSubsumptionoperator(this, cloner);
+      return new ActionSetSubsumptionOperator(this, cloner);
     }
 
     public override IOperation Apply() {
-      var subscopes = CurrentScope.SubScopes;
       var classifiers = ClassifiersParameter.ActualValue;
       var numerosities = NumerositiesParameter.ActualValue;
       var experiences = ExperiencesParameter.ActualValue;
+      var hasBeenSubsumed = HasBeenSubsumedParameter.ActualValue;
       var errors = ErrorsParameter.ActualValue;
-      if (subscopes.Count != classifiers.Length || subscopes.Count != numerosities.Length
-        || subscopes.Count != experiences.Length || subscopes.Count != errors.Length) {
-        throw new ArgumentException("The number of subscopes is not equal to the number of classifiers.");
+      if (errors.Length != classifiers.Length || errors.Length != numerosities.Length
+        || errors.Length != experiences.Length || errors.Length != hasBeenSubsumed.Length) {
+        throw new ArgumentException("The number of classifiers, error, numerosity, hasBeenSubsumed and experience values is not equal.");
       }
 
@@ -108 +101 @@
           if (classifiers[subsumptionClassifier].IsMoreGeneral(classifiers[i])) {
             numerosities[subsumptionClassifier].Value += numerosities[i].Value;
-            AddVariableToScope(subscopes[i], new BoolValue(true));
-          } else {
-            AddVariableToScope(subscopes[i], new BoolValue(false));
+            hasBeenSubsumed[i].Value = true;
           }
-        }
-      } else {
-        for (int i = 0; i < classifiers.Length; i++) {
-          AddVariableToScope(subscopes[i], new BoolValue(false));
         }
       }
 
       return base.Apply();
-    }
-
-    private void AddVariableToScope(IScope scope, BoolValue boolValue) {
-      if (scope.Variables.ContainsKey(HasBeenSubsumedParameterName)) {
-        scope.Variables[HasBeenSubsumedParameterName].Value = boolValue;
-      } else {
-        scope.Variables.Add(new Variable(HasBeenSubsumedParameterName, boolValue));
-      }
     }
 

branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Subsumption/IActionSetSubsumption.cs

@@ -31 +31 @@
     ILookupParameter<ItemArray<IntValue>> ExperiencesParameter { get; }
     ILookupParameter<ItemArray<DoubleValue>> ErrorsParameter { get; }
+    ILookupParameter<ItemArray<BoolValue>> HasBeenSubsumedParameter { get; }
     ILookupParameter<DoubleValue> ErrorZeroParameter { get; }
     ILookupParameter<IntValue> ThetaSubsumptionParameter { get; }
-
-    string HasBeenSubsumedParameterName { get; }
   }
 }