Changeset 9475

Timestamp:

05/09/13 18:57:22 (12 years ago)

Author:

sforsten

Message:

#1980: several small bug fixes

Location:

branches/LearningClassifierSystems

Files:

• HeuristicLab.Encodings.DecisionList/3.3/DecisionListSolution.cs (modified) (1 diff)
• HeuristicLab.Encodings.DecisionList/3.3/Evaluator/MDLEvaluator.cs (modified) (1 diff)
• HeuristicLab.Encodings.VariableVector/3.3/Manipulator/UniformActionManipulator.cs (modified) (1 diff)
• HeuristicLab.Encodings.VariableVector/3.3/Manipulator/UniformOnePositionInConditionManipulator.cs (modified) (2 diffs)
• HeuristicLab.Encodings.VariableVector/3.3/Manipulator/UniformSomePositionManipulator.cs (modified) (1 diff)
• HeuristicLab.Encodings.VariableVector/3.3/Variable/DoubleVariable.cs (modified) (3 diffs)
• HeuristicLab.Encodings.VariableVector/3.3/Variable/IVariable.cs (modified) (1 diff)
• HeuristicLab.Encodings.VariableVector/3.3/Variable/IntVariable.cs (modified) (1 diff)
• HeuristicLab.Encodings.VariableVector/3.3/Variable/StringVariable.cs (modified) (3 diffs)
• HeuristicLab.Encodings.VariableVector/3.3/Variable/Variable.cs (modified) (1 diff)
• HeuristicLab.Encodings.VariableVector/3.3/VariableVectorManipulator.cs (modified) (2 diffs)
• HeuristicLab.Optimization.Operators.LCS/3.3/GAssist/MDL/MDLCalculator.cs (modified) (3 diffs)
• HeuristicLab.Optimization.Operators.LCS/3.3/Selection/NichingTournamentSelector.cs (modified) (1 diff)
• HeuristicLab.Problems.VariableVectorClassification/3.3/VariableVectorClassificationProblem.cs (modified) (1 diff)
• HeuristicLab.Problems.VariableVectorClassification/3.3/VariableVectorClassificationProblemData.cs (modified) (1 diff)

branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/DecisionListSolution.cs

@@ -137 +137 @@
       double theoryLength;
       var estimatedTraining = Model.Evaluate(originalTrainingCondition, out aliveRules, out theoryLength);
-      TrainingNumberOfAliveRules = aliveRules.Count;
+      TrainingNumberOfAliveRules = aliveRules.Count + (Model.DefaultAction != null ? 1 : 0);
       TrainingAliveRules = aliveRules;
       TrainingTheoryLength = theoryLength;

branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Evaluator/MDLEvaluator.cs

@@ -145 +145 @@
 
     // default rule cannot be deleted, but it has to be considered in the rule set size
-    private void DoRuleDeletion(DecisionList dl, ItemSet<Rule> aliveRules, int minRules) {
+    private void DoRuleDeletion(DecisionList dl, IEnumerable<Rule> aliveRules, int minRules) {
       int ruleSetSize = dl.RuleSetSize;
       if (ruleSetSize <= minRules) { return; }

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

@@ -52 +52 @@
     }
 
-    protected override VariableVector Manipulate(IRandom random, VariableVectorInput input, VariableVector child) {
+    protected override VariableVector Manipulate(IRandom random, VariableVectorInput input, VariableVector child, double spreadpercentage) {
       return Manipulate(random, child, PossibleActionsParameter.ActualValue);
     }

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

@@ -45 +45 @@
     }
 
-    protected override VariableVector Manipulate(IRandom random, VariableVectorInput input, VariableVector child) {
-      return Manipulate(random, input, child, random.Next(child.Condition.VirtualLength));
+    protected override VariableVector Manipulate(IRandom random, VariableVectorInput input, VariableVector child, double spreadPercentage) {
+      return Manipulate(random, input, child, random.Next(child.Condition.VirtualLength), spreadPercentage);
     }
 
-    public static VariableVector Manipulate(IRandom random, VariableVectorInput input, VariableVector child, int index) {
+    public static VariableVector Manipulate(IRandom random, VariableVectorInput input, VariableVector child, int index, double spreadPercentage) {
       VariableVectorCondition condition = child.Condition;
       if (index >= condition.VirtualLength) {
@@ -61 +61 @@
         keyEnumerator.MoveNext();
       }
-      condition.VariableDictionary[keyEnumerator.Current].Manipulate(random, input.InputDictionary[keyEnumerator.Current], index - count);
+      condition.VariableDictionary[keyEnumerator.Current].Manipulate(random, input.InputDictionary[keyEnumerator.Current], index - count, spreadPercentage);
       return child;
     }

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

@@ -55 +55 @@
     }
 
-    protected override VariableVector Manipulate(IRandom random, VariableVectorInput input, VariableVector child) {
-      return Manipulate(random, input, child, ProbabilityParameter.ActualValue.Value, PossibleActionsParameter.ActualValue);
+    protected override VariableVector Manipulate(IRandom random, VariableVectorInput input, VariableVector child, double spreadPercentage) {
+      return Manipulate(random, input, child, ProbabilityParameter.ActualValue.Value, PossibleActionsParameter.ActualValue, spreadPercentage);
     }
 
-    public static VariableVector Manipulate(IRandom random, VariableVectorInput input, VariableVector child, double probability, IItemSet<VariableVectorAction> possibleActions) {
-      child = ManipulateCondition(random, input, child, probability);
+    public static VariableVector Manipulate(IRandom random, VariableVectorInput input, VariableVector child, double probability, IItemSet<VariableVectorAction> possibleActions, double spreadPercentage) {
+      child = ManipulateCondition(random, input, child, probability, spreadPercentage);
       return ManipulateAction(random, child, probability, possibleActions);
     }
 
-    public static VariableVector ManipulateCondition(IRandom random, VariableVectorInput input, VariableVector child, double probability) {
+    public static VariableVector ManipulateCondition(IRandom random, VariableVectorInput input, VariableVector child, double probability, double spreadPercentage) {
       for (int index = 0; index < child.Condition.VirtualLength; index++) {
         if (random.NextDouble() < probability) {
-          child = UniformOnePositionInConditionManipulator.Manipulate(random, input, child, index);
+          child = UniformOnePositionInConditionManipulator.Manipulate(random, input, child, index, spreadPercentage);
         }
       }

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

@@ -124 +124 @@
       double delta = Max - Min;
       CurrentCenter = random.NextDouble() * delta + Min;
-      CurrentSpread = random.NextDouble() * (delta * (spreadPercentage / 100));
+      CurrentSpread = random.NextDouble() * (delta * spreadPercentage);
     }
 
@@ -162 +162 @@
     }
 
+    public override void Manipulate(IRandom random, string stringValue, int pos,
+                                   double spreadPercentage) {
+      Manipulate(random, pos, spreadPercentage);
+    }
+
     public override void Manipulate(IRandom random, string stringValue, int pos) {
-      if (pos > 1 || pos < 0) { throw new ArgumentOutOfRangeException(); }
-      Manipulate(random, pos, 10);
+      throw new NotImplementedException("DoubleVariable.Manipulate(IRandom, string, int) cannot be used. Use DoubleVariable.Manipulate(IRandom, string, int, double) or DoubleVariable.Manipulate(IRandom, int, double) instead.");
     }
 
@@ -170 +174 @@
       if (pos > 1 || pos < 0) { throw new ArgumentOutOfRangeException(); }
       double delta = max - min;
-      double maxChange = delta * (percentage / 100);
+      double maxChange = delta * percentage;
       double actualChange = (random.NextDouble() * maxChange * 2) - maxChange;
       if (pos == 0) {

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

@@ -46 +46 @@
     void Manipulate(IRandom random, string stringValue, int pos);
 
+    void Manipulate(IRandom random, string stringValue, int pos, double spreadPercentage);
+
     void Cover(IRandom random, string stringValue, double changeSymbolProbability);
   }

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

@@ -166 +166 @@
     }
 
+    public override void Manipulate(IRandom random, string stringValue, int pos,
+                                   double spreadPercentage) {
+      Manipulate(random, stringValue, pos);
+    }
+
     public override void Manipulate(IRandom random, string stringValue, int pos) {
       if (pos != 0) { throw new ArgumentOutOfRangeException(); }

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

@@ -87 +87 @@
       featureMapping = new Dictionary<int, string>();
       var distinctValuesEnumerator = variableValues.Distinct().GetEnumerator();
-      possibleFeatures = Enumerable.Range(0, variableValues.Count());
+      possibleFeatures = Enumerable.Range(0, variableValues.Count()).ToList();
       var possibleFeaturesEnumerator = possibleFeatures.GetEnumerator();
       while (possibleFeaturesEnumerator.MoveNext() && distinctValuesEnumerator.MoveNext()) {
@@ -111 +111 @@
         throw new ArgumentException("featureMapping values have to be distinct.");
       }
-      this.possibleFeatures = featureMapping.Keys;
+      this.possibleFeatures = featureMapping.Keys.ToList();
       this.featureMapping = featureMapping;
       Wildcard = false;
@@ -212 +212 @@
     }
 
+    public override void Manipulate(IRandom random, string stringValue, int pos,
+                                    double spreadPercentage) {
+      Manipulate(random, stringValue, pos);
+    }
+
     public override void Manipulate(IRandom random, string stringValue, int pos) {
       if (pos != 0) { throw new ArgumentOutOfRangeException(); }

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

@@ -72 +72 @@
     public abstract void Manipulate(IRandom random, string stringValue, int pos);
 
+    public abstract void Manipulate(IRandom random, string stringValue, int pos, double spreadPercentage);
+
     public abstract void Cover(IRandom random, string stringValue, double changeSymbolProbability);
   }

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

@@ -42 +42 @@
       get { return (ILookupParameter<VariableVectorInput>)Parameters["Input"]; }
     }
+    public IValueLookupParameter<IVariableVectorClassificationProblemData> ProblemDataParameter {
+      get { return (IValueLookupParameter<IVariableVectorClassificationProblemData>)Parameters["ProblemData"]; }
+    }
     #endregion
 
@@ -54 +57 @@
       Parameters.Add(new LookupParameter<VariableVector>("Child"));
       Parameters.Add(new LookupParameter<VariableVectorInput>("Input"));
+      Parameters.Add(new ValueLookupParameter<IVariableVectorClassificationProblemData>("ProblemData", ""));
     }
 
     public sealed override IOperation Apply() {
-      ChildParameter.ActualValue = Manipulate(RandomParameter.ActualValue, FetchedInputParameter.ActualValue, ChildParameter.ActualValue);
+      ChildParameter.ActualValue = Manipulate(RandomParameter.ActualValue, FetchedInputParameter.ActualValue, ChildParameter.ActualValue, ProblemDataParameter.ActualValue.SpreadPercentageParameter.Value.Value);
       return base.Apply();
     }
 
-    protected abstract VariableVector Manipulate(IRandom random, VariableVectorInput input, VariableVector child);
+    protected abstract VariableVector Manipulate(IRandom random, VariableVectorInput input, VariableVector child, double spreadPercentage);
   }
 }

branches/LearningClassifierSystems/HeuristicLab.Optimization.Operators.LCS/3.3/GAssist/MDL/MDLCalculator.cs

@@ -82 +82 @@
         double error = bestSolution.TrainingExceptionsLength;
         double tl = (bestSolution.TrainingTheoryLength * bestSolution.Classes) / bestSolution.TrainingNumberOfAliveRules;
+        if (tl.IsAlmost(0.0)) {
+          //as done in the original implementation
+          tl = 0.00000001;
+        }
         theoryWeight = (initialTheoryLengthRatio / (1.0 - initialTheoryLengthRatio)) * (error / tl);
         iterationsSinceBest = 0;
@@ -87 +91 @@
 
       if (activated && !fixedWeight &&
-        GetLastIterationsAccuracyAverage(weightAdaptionIterations) == 1.0) {
+        GetLastIterationsAccuracyAverage(weightAdaptionIterations).IsAlmost(1.0)) {
         fixedWeight = true;
       }
 
       if (activated && !fixedWeight) {
-        if (bestSolution.TrainingAccuracy != 1.0) {
+        if (bestSolution.TrainingAccuracy.IsAlmost(1.0)) {
           if (iterationsSinceBest == weightAdaptionIterations) {
             theoryWeight *= weightRelaxFactor;
@@ -100 +104 @@
       }
 
-      //if (currentIteration != 0) {
       UpdateStatistic(bestSolution.TrainingAccuracy);
-      //}
     }
 

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

@@ -83 +83 @@
       //check if list with indexes is as long as the original scope list
       //otherwise invalid quality values were filtered
-      if (qualities.Count != scopes.Count && individuals.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.");
       }

branches/LearningClassifierSystems/HeuristicLab.Problems.VariableVectorClassification/3.3/VariableVectorClassificationProblem.cs

@@ -132 +132 @@
       manipulator.FetchedInputParameter.ActualName = ClassifierFetcher.CurrentInputToMatchParameter.ActualName;
       manipulator.PossibleActionsParameter.ActualName = PossibleActionsConcreteClassParameter.Name;
+      manipulator.ProblemDataParameter.ActualName = ProblemDataParameter.Name;
       return new List<IManipulator>() { manipulator };
     }

branches/LearningClassifierSystems/HeuristicLab.Problems.VariableVectorClassification/3.3/VariableVectorClassificationProblemData.cs

@@ -136 +136 @@
     protected override void ActionConditionVariablesChanged() {
       SampleVariableVectorParameter.Value = GenerateSampleVariableVector(Dataset, AllowedConditionVariables, AllowedActionVariables);
+      OnChanged();
     }
   }