Changeset 9204 for branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/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.VariableVector/3.3

Files:

• . (modified) (1 prop)
• Covering (added)
• Covering/VariableVectorCoveringCreator.cs (added)
• Crossover/SinglePointCrossover.cs (modified) (1 diff)
• HeuristicLab.Encodings.VariableVector-3.3.csproj (modified) (1 diff)
• Interfaces/IVariableVectorCoveringCreator.cs (added)
• Interfaces/IVariableVectorManipulator.cs (added)
• Manipulator (added)
• Manipulator/UniformActionManipulator.cs (added)
• Manipulator/UniformOnePositionInConditionManipulator.cs (added)
• Manipulator/UniformSomePositionManipulator.cs (added)
• Plugin.cs (added)
• Properties/AssemblyInfo.cs (added)
• Variable/DoubleVariable.cs (modified) (2 diffs)
• Variable/IVariable.cs (modified) (1 diff)
• Variable/IntVariable.cs (modified) (2 diffs)
• Variable/StringVariable.cs (modified) (2 diffs)
• Variable/Variable.cs (modified) (1 diff)
• VariableVector.cs (modified) (2 diffs)
• VariableVectorAction.cs (modified) (3 diffs)
• VariableVectorCondition.cs (modified) (3 diffs)
• VariableVectorInput.cs (modified) (2 diffs)
• VariableVectorManipulator.cs (added)

branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Crossover/SinglePointCrossover.cs

@@ -62 +62 @@
       IList<IVariable> newCondition = new List<IVariable>(parent1Condition.Count);
 
-      var keyEnumerator = parent1Condition.Keys.GetEnumerator();
+      var keyEnumerator = parent1Condition.Order.GetEnumerator();
 
       int index = 0;

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

@@ -71 +71 @@
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="Covering\VariableVectorCoveringCreator.cs" />
     <Compile Include="Crossover\SinglePointCrossover.cs" />
+    <Compile Include="Interfaces\IVariableVectorCoveringCreator.cs" />
     <Compile Include="Interfaces\IVariableVectorCrossover.cs" />
+    <Compile Include="Interfaces\IVariableVectorManipulator.cs" />
+    <Compile Include="Manipulator\UniformActionManipulator.cs" />
+    <Compile Include="Manipulator\UniformOnePositionInConditionManipulator.cs" />
+    <Compile Include="Manipulator\UniformSomePositionManipulator.cs" />
     <Compile Include="VariableVectorCrossover.cs" />
+    <Compile Include="VariableVectorManipulator.cs" />
     <Compile Include="Variable\IActionVariable.cs" />
     <Compile Include="Variable\IVariable.cs" />

branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/DoubleVariable.cs

@@ -137 +137 @@
     public override double GetGenerality() {
       double delta = max - min;
-      double intervalWidth = 2 * currentSpread;
-      double generality = intervalWidth / delta;
+      double intervalInBoundsWidth = Math.Min(max, currentCenter + currentSpread) - Math.Max(min, currentCenter - currentSpread);
+      double generality = intervalInBoundsWidth / delta;
       return generality > 1 ? 1 : generality;
     }
@@ -159 +159 @@
       return crossed;
     }
+
+    public override void Manipulate(IRandom random, string stringValue, int pos) {
+      if (pos > 1 || pos < 0) { throw new ArgumentOutOfRangeException(); }
+      Manipulate(random, pos, 10);
+    }
+
+    public void Manipulate(IRandom random, int pos, double percentage) {
+      if (pos > 1 || pos < 0) { throw new ArgumentOutOfRangeException(); }
+      double delta = max - min;
+      double maxChange = delta * (percentage / 100);
+      double actualChange = (random.NextDouble() * maxChange * 2) - maxChange;
+      if (pos == 0) {
+        currentCenter += actualChange;
+      } else if (pos == 1) {
+        currentSpread += actualChange;
+        //otherwise the interval could be corrupt and no input could match the rule.
+        currentSpread = currentSpread > 0 ? currentSpread : 0;
+      }
+    }
+
+    public override void Cover(IRandom random, string stringValue, double changeSymbolProbability) {
+      Cover(random, stringValue, 50);
+    }
+
+    public void CoverWithSpreadPercentage(IRandom random, string stringValue, double spreadPercentage) {
+      currentCenter = double.Parse(stringValue);
+      double delta = max - min;
+      currentSpread = random.NextDouble() * (delta * (spreadPercentage / 100));
+    }
   }
 }

branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/IVariable.cs

@@ -41 +41 @@
 
     IVariable CrossParentsAtPosition(IVariable parent2, int pos);
+
+    void Manipulate(IRandom random, string stringValue, int pos);
+
+    void Cover(IRandom random, string stringValue, double changeSymbolProbability);
   }
 }

branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/IntVariable.cs

@@ -86 +86 @@
 
     public override string ToString() {
-      return currentValue.ToString();
+      return Wildcard ? "#" : currentValue.ToString();
     }
 
@@ -145 +145 @@
       return this.GetSetCopy();
     }
+
+    public override void Manipulate(IRandom random, string stringValue, int pos) {
+      if (pos != 0) { throw new ArgumentOutOfRangeException(); }
+      Wildcard = !Wildcard;
+      if (!Wildcard) {
+        currentValue = int.Parse(stringValue);
+      }
+    }
+
+    public override void Cover(IRandom random, string stringValue, double changeSymbolProbability) {
+      Wildcard = random.NextDouble() < changeSymbolProbability;
+      if (!Wildcard) {
+        currentValue = int.Parse(stringValue);
+      }
+    }
   }
 }

branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/StringVariable.cs

@@ -134 +134 @@
 
     public override string ToString() {
-      return CurrentStringValue;
+      return Wildcard ? "#" : CurrentStringValue;
     }
 
@@ -197 +197 @@
       return this.GetSetCopy();
     }
+
+    public override void Manipulate(IRandom random, string stringValue, int pos) {
+      if (pos != 0) { throw new ArgumentOutOfRangeException(); }
+      Wildcard = !Wildcard;
+      if (!Wildcard) {
+        int newValue = featureMapping.First(x => x.Value.Equals(stringValue)).Key;
+        currentValue = newValue;
+      }
+    }
+
+    public override void Cover(IRandom random, string stringValue, double changeSymbolProbability) {
+      Wildcard = random.NextDouble() < changeSymbolProbability;
+      if (!Wildcard) {
+        int newValue = featureMapping.First(x => x.Value.Equals(stringValue)).Key;
+        currentValue = newValue;
+      }
+    }
   }
 }

branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/Variable.cs

@@ -69 +69 @@
 
     public virtual IVariable CrossParentsAtPosition(IVariable parent2, int pos) { throw new NotSupportedException("This method is not supported."); }
+
+    public abstract void Manipulate(IRandom random, string stringValue, int pos);
+
+    public abstract void Cover(IRandom random, string stringValue, double changeSymbolProbability);
   }
 }

branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/VariableVector.cs

@@ -33 +33 @@
   [Item("VariableVector", "")]
   public class VariableVector : Item, IClassifier {
+
     [Storable]
     protected VariableVectorCondition condition;
@@ -131 +132 @@
       return true;
     }
+
+    [StorableClass]
+    [Item("VariableVectorActionComparer", "")]
+    public class VariableVectorActionComparer : Item, IEqualityComparer<VariableVectorAction>, IClassifierComparer {
+
+      [StorableConstructor]
+      protected VariableVectorActionComparer(bool deserializing) : base(deserializing) { }
+      protected VariableVectorActionComparer(VariableVectorActionComparer original, Cloner cloner)
+        : base(original, cloner) {
+      }
+      public override IDeepCloneable Clone(Cloner cloner) {
+        return new VariableVectorActionComparer(this, cloner);
+      }
+      public VariableVectorActionComparer() : base() { }
+
+      public bool Equals(VariableVectorAction x, VariableVectorAction y) {
+        throw new NotImplementedException();
+      }
+
+      public int GetHashCode(VariableVectorAction obj) {
+        throw new NotImplementedException();
+      }
+
+      public bool Equals(IAction x, IAction y) {
+        var xCast = x as VariableVectorAction;
+        var yCast = y as VariableVectorAction;
+        return x != null && y != null && Equals(xCast, yCast);
+      }
+
+      public int GetHashCode(IAction obj) {
+        var objCast = obj as VariableVectorAction;
+        return objCast != null ? GetHashCode(objCast) : obj.GetHashCode();
+      }
+    }
   }
 }

branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/VariableVectorAction.cs

@@ -35 +35 @@
   public class VariableVectorAction : ItemDictionary<StringValue, IActionVariable>, IAction {
 
+    public IOrderedEnumerable<StringValue> Order { get { return this.Keys.OrderBy(x => x.Value); } }
+
     public int VirtualLength { get { return this.Values.Sum(x => x.VirtualLength); } }
 
@@ -61 +63 @@
       var targetCast = target as VariableVectorAction;
       if (targetCast == null) { return false; }
-      if (!(this.Keys.Except(targetCast.Keys).Count() == 0 && targetCast.Keys.Except(this.Keys).Count() == 0)) { return false; }
+      if (this.Order.SequenceEqual(targetCast.Order)) { return false; }
       foreach (var keyValuePair in targetCast) {
         if (!this[keyValuePair.Key].MatchVariable(keyValuePair.Value)) {
@@ -97 +99 @@
 
     public bool Identical(VariableVectorCondition target) {
-      if (!(target.Keys.Except(this.Keys).Count() == 0 && this.Keys.Except(target.Keys).Count() == 0)) { return false; }
+      if (this.Order.SequenceEqual(target.Order)) { return false; }
       foreach (var keyValuePair in target) {
         if (!this[keyValuePair.Key].Identical(keyValuePair.Value)) {

branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/VariableVectorCondition.cs

@@ -34 +34 @@
   public class VariableVectorCondition : ItemDictionary<StringValue, IVariable>, ICondition {
 
+    public IOrderedEnumerable<StringValue> Order { get { return this.Keys.OrderBy(x => x.Value); } }
+
     public int VirtualLength { get { return this.Values.Sum(x => x.VirtualLength); } }
 
@@ -51 +53 @@
       var targetCast = target as VariableVectorInput;
       if (targetCast == null) { return false; }
-      if (!(targetCast.Keys.Except(this.Keys).Count() == 0 && this.Keys.Except(targetCast.Keys).Count() == 0)) { return false; }
+      if (this.Order.SequenceEqual(targetCast.Order)) { return false; }
       foreach (var keyValuePair in targetCast) {
         if (!this[keyValuePair.Key].MatchInput(keyValuePair.Value.Value)) {
@@ -91 +93 @@
 
     public bool Identical(VariableVectorCondition target) {
-      if (!(target.Keys.Except(this.Keys).Count() == 0 && this.Keys.Except(target.Keys).Count() == 0)) { return false; }
+      if (this.Order.SequenceEqual(target.Order)) { return false; }
       foreach (var keyValuePair in target) {
         if (!this[keyValuePair.Key].Identical(keyValuePair.Value)) {

branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/VariableVectorInput.cs

@@ -21 +21 @@
 
 using System.Collections.Generic;
+using System.Linq;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -31 +32 @@
   [Item("VariableVectorInput", "")]
   public class VariableVectorInput : ItemDictionary<StringValue, StringValue>, IInput {
+
+    public IOrderedEnumerable<StringValue> Order { get { return this.Keys.OrderBy(x => x.Value); } }
 
     [StorableConstructor]