Changeset 9204 for branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3

Timestamp:

02/04/13 16:16:38 (12 years ago)

Author:

sforsten

Message:

#1980:

• deleted not needed interface IMatching
• finished VariableVector encoding
• the algorithm LearningClassifierSystem is now independent of a specific encoding. It still needs the ConditionActionEncoding.
• merged r9191:9203 HeuristicLab.Core from trunk to branch

Location:

branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3

Files:

• CombinedIntegerVectorManipulator.cs (modified) (2 diffs)
• Covering/CombinedIntegerVectorCoveringCreator.cs (modified) (3 diffs)
• Interfaces/ICombinedIntegerVectorManipulator.cs (modified) (1 diff)
• Manipulator/UniformActionManipulator.cs (modified) (1 diff)
• Manipulator/UniformOnePositionInConditionManipulator.cs (modified) (1 diff)
• Manipulator/UniformSomePositionManipulator.cs (modified) (3 diffs)
• Matching (deleted)

branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/CombinedIntegerVectorManipulator.cs

@@ -39 +39 @@
       get { return (ILookupParameter<CombinedIntegerVector>)Parameters["Child"]; }
     }
-    public ILookupParameter<CombinedIntegerVector> FetchedConditionParameter {
-      get { return (ILookupParameter<CombinedIntegerVector>)Parameters["Parent"]; }
+    public ILookupParameter<CombinedIntegerVector> FetchedInputParameter {
+      get { return (ILookupParameter<CombinedIntegerVector>)Parameters["Input"]; }
     }
     #endregion
@@ -53 +53 @@
       Parameters.Add(new LookupParameter<IRandom>("Random"));
       Parameters.Add(new LookupParameter<CombinedIntegerVector>("Child"));
-      Parameters.Add(new LookupParameter<CombinedIntegerVector>("Parent"));
+      Parameters.Add(new LookupParameter<CombinedIntegerVector>("Input"));
     }
 
     public sealed override IOperation Apply() {
-      ChildParameter.ActualValue = Manipulate(RandomParameter.ActualValue, FetchedConditionParameter.ActualValue, ChildParameter.ActualValue);
+      ChildParameter.ActualValue = Manipulate(RandomParameter.ActualValue, FetchedInputParameter.ActualValue, ChildParameter.ActualValue);
       return base.Apply();
     }
 
-    protected abstract CombinedIntegerVector Manipulate(IRandom random, CombinedIntegerVector parent, CombinedIntegerVector child);
+    protected abstract CombinedIntegerVector Manipulate(IRandom random, CombinedIntegerVector input, CombinedIntegerVector child);
   }
 }

branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Covering/CombinedIntegerVectorCoveringCreator.cs

@@ -22 +22 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Data;
 using HeuristicLab.Encodings.ConditionActionEncoding;
-using HeuristicLab.Operators;
-using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
@@ -31 +28 @@
   [Item("CombinedIntegerVectorCoveringCreator", "Description missing")]
   [StorableClass]
-  public class CombinedIntegerVectorCoveringCreator : SingleSuccessorOperator, ICoveringSolutionCreator {
-
-    #region Parameter Properties
-    public ILookupParameter<IInput> CoverInputParameter {
-      get { return (ILookupParameter<IInput>)Parameters["CoverInput"]; }
-    }
-    public ILookupParameter<IAction> ActionParameter {
-      get { return (ILookupParameter<IAction>)Parameters["Action"]; }
-    }
-    public IValueLookupParameter<IClassifier> CreatedClassifierParameter {
-      get { return (IValueLookupParameter<IClassifier>)Parameters["CreatedClassifier"]; }
-    }
-    public ILookupParameter<PercentValue> ChangeSymbolProbabilityParameter {
-      get { return (ILookupParameter<PercentValue>)Parameters["ChangeSymbolProbability"]; }
-    }
-    public ILookupParameter<IRandom> RandomParameter {
-      get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
-    }
-
-    #endregion
+  public class CombinedIntegerVectorCoveringCreator : CoveringSolutionCreator, ICombinedIntegerVectorOperator {
 
     [StorableConstructor]
@@ -62 +40 @@
     public CombinedIntegerVectorCoveringCreator()
       : base() {
-      Parameters.Add(new LookupParameter<IInput>("CoverInput"));
-      Parameters.Add(new LookupParameter<IAction>("Action"));
-      Parameters.Add(new ValueLookupParameter<IClassifier>("CreatedClassifier"));
-      Parameters.Add(new LookupParameter<PercentValue>("ChangeSymbolProbability"));
-      Parameters.Add(new LookupParameter<IRandom>("Random"));
     }
 
-    public override IOperation Apply() {
-      CombinedIntegerVector newCondition = (CombinedIntegerVector)CoverInputParameter.ActualValue.Clone();
+    protected override IClassifier CreateCoveredClassifier(IInput input, IAction action, IRandom random, double changeSymbolProbability) {
+      CombinedIntegerVector newCondition = (CombinedIntegerVector)input.Clone();
 
-      CombinedIntegerVector condition = (CombinedIntegerVector)CoverInputParameter.ActualValue;
-      CombinedIntegerVector action = (CombinedIntegerVector)ActionParameter.ActualValue;
+      CombinedIntegerVector condition = (CombinedIntegerVector)input;
+      CombinedIntegerVector newAction = (CombinedIntegerVector)action;
 
-      newCondition = UniformSomePositionManipulator.ManipulateCondition(RandomParameter.ActualValue, condition, newCondition, ChangeSymbolProbabilityParameter.ActualValue.Value);
+      newCondition = UniformSomePositionManipulator.ManipulateCondition(random, condition, newCondition, changeSymbolProbability);
 
-      CreatedClassifierParameter.ActualValue = new CombinedIntegerVector(newCondition, newCondition.Bounds, action, action.Bounds);
-      return base.Apply();
+      return new CombinedIntegerVector(newCondition, newCondition.Bounds, newAction, newAction.Bounds);
     }
   }

branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Interfaces/ICombinedIntegerVectorManipulator.cs

@@ -29 +29 @@
   public interface ICombinedIntegerVectorManipulator : IManipulator, ICombinedIntegerVectorOperator {
     ILookupParameter<CombinedIntegerVector> ChildParameter { get; }
-    ILookupParameter<CombinedIntegerVector> FetchedConditionParameter { get; }
+    ILookupParameter<CombinedIntegerVector> FetchedInputParameter { get; }
   }
 }

branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Manipulator/UniformActionManipulator.cs

@@ -47 +47 @@
     }
 
-    protected override CombinedIntegerVector Manipulate(IRandom random, CombinedIntegerVector child, CombinedIntegerVector parent) {
-      return Manipulate(random, parent, child, PossibleActionsParameter.ActualValue);
+    protected override CombinedIntegerVector Manipulate(IRandom random, CombinedIntegerVector child, CombinedIntegerVector input) {
+      return Manipulate(random, child, PossibleActionsParameter.ActualValue);
     }
 
-    public static CombinedIntegerVector Manipulate(IRandom random, CombinedIntegerVector parent, CombinedIntegerVector child, IEnumerable<CombinedIntegerVector> possibleActions) {
-      var otherActions = possibleActions.Except(((CombinedIntegerVector)parent.Action).ToEnumerable());
+    public static CombinedIntegerVector Manipulate(IRandom random, CombinedIntegerVector child, IEnumerable<CombinedIntegerVector> possibleActions) {
+      var otherActions = possibleActions.Except(((CombinedIntegerVector)child.Action).ToEnumerable());
       int actionIndex = random.Next(otherActions.Count());
       CombinedIntegerVector newAction = otherActions.ElementAt(actionIndex);

branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Manipulator/UniformOnePositionInConditionManipulator.cs

@@ -41 +41 @@
     }
 
-    protected override CombinedIntegerVector Manipulate(IRandom random, CombinedIntegerVector parent, CombinedIntegerVector child) {
-      return Manipulate(parent, child, random.Next(((CombinedIntegerVector)child.Condition).Length));
+    protected override CombinedIntegerVector Manipulate(IRandom random, CombinedIntegerVector input, CombinedIntegerVector child) {
+      return Manipulate(input, child, random.Next(((CombinedIntegerVector)child.Condition).Length));
     }
 
-    public static CombinedIntegerVector Manipulate(CombinedIntegerVector parent, CombinedIntegerVector child, int index) {
+    public static CombinedIntegerVector Manipulate(CombinedIntegerVector input, CombinedIntegerVector child, int index) {
       int max = child.Bounds[index % child.Bounds.Rows, 1] - 1;
       if (child[index].Equals(max)) {
-        child[index] = parent[index];
+        child[index] = input[index];
       } else {
         child[index] = max;

branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Manipulator/UniformSomePositionManipulator.cs

@@ -23 +23 @@
 using HeuristicLab.Core;
 using HeuristicLab.Data;
+using HeuristicLab.Encodings.ConditionActionEncoding;
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
 namespace HeuristicLab.Encodings.CombinedIntegerVectorEncoding {
-  public class UniformSomePositionManipulator : CombinedIntegerVectorManipulator {
+  public class UniformSomePositionManipulator : CombinedIntegerVectorManipulator, IProbabilityMutatorOperator {
 
     public IValueLookupParameter<PercentValue> ProbabilityParameter {
@@ -50 +51 @@
     }
 
-    protected override CombinedIntegerVector Manipulate(IRandom random, CombinedIntegerVector parent, CombinedIntegerVector child) {
-      return Manipulate(random, parent, child, ProbabilityParameter.ActualValue.Value, PossibleActionsParameter.ActualValue);
+    protected override CombinedIntegerVector Manipulate(IRandom random, CombinedIntegerVector input, CombinedIntegerVector child) {
+      return Manipulate(random, input, child, ProbabilityParameter.ActualValue.Value, PossibleActionsParameter.ActualValue);
     }
 
-    public static CombinedIntegerVector Manipulate(IRandom random, CombinedIntegerVector parent, CombinedIntegerVector child, double probability, IItemSet<CombinedIntegerVector> possibleActions) {
-      child = ManipulateCondition(random, parent, child, probability);
-      return ManipulateAction(random, parent, child, probability, possibleActions);
+    public static CombinedIntegerVector Manipulate(IRandom random, CombinedIntegerVector input, CombinedIntegerVector child, double probability, IItemSet<CombinedIntegerVector> possibleActions) {
+      child = ManipulateCondition(random, input, child, probability);
+      return ManipulateAction(random, child, probability, possibleActions);
     }
 
-    public static CombinedIntegerVector ManipulateCondition(IRandom random, CombinedIntegerVector parent, CombinedIntegerVector child, double probability) {
+    public static CombinedIntegerVector ManipulateCondition(IRandom random, CombinedIntegerVector input, CombinedIntegerVector child, double probability) {
       int conditionLength = child.Length - child.ActionLength;
       for (int index = 0; index < child.Length - child.ActionLength; index++) {
         if (random.NextDouble() < probability) {
-          child = UniformOnePositionInConditionManipulator.Manipulate(parent, child, index);
+          child = UniformOnePositionInConditionManipulator.Manipulate(input, child, index);
         }
       }
@@ -69 +70 @@
     }
 
-    public static CombinedIntegerVector ManipulateAction(IRandom random, CombinedIntegerVector parent, CombinedIntegerVector child, double probability, IItemSet<CombinedIntegerVector> possibleActions) {
+    public static CombinedIntegerVector ManipulateAction(IRandom random, CombinedIntegerVector child, double probability, IItemSet<CombinedIntegerVector> possibleActions) {
       if (child.ActionLength > 0 && random.NextDouble() < probability) {
-        UniformActionManipulator.Manipulate(random, parent, child, possibleActions);
+        UniformActionManipulator.Manipulate(random, child, possibleActions);
       }
       return child;