Changeset 9392 for branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Evaluator

Timestamp:

04/23/13 13:31:29 (12 years ago)

Author:

sforsten

Message:

#1980:

• several small bug fixes
• added windowing technique ILAS to GAssist
• GAssist and XCS work now with real-valued features
• severely improved the performance of XCS

Location:

branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3

Files:

• . (modified) (1 prop)
• Evaluator/DecisionListEvaluator.cs (deleted)
• Evaluator/MDLCalculator.cs (deleted)
• Evaluator/MDLEvaluator.cs (modified) (4 diffs)
• Evaluator/MDLIterationOperator.cs (deleted)

branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3

@@ -1 +1 @@
 *.user
 Plugin.cs
+obj

@@ -1 +1 @@
 *.user
 Plugin.cs
+obj

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

@@ -20 +20 @@
 #endregion
 
+using System.Collections.Generic;
+using System.Linq;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
 using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Optimization.Operators.LCS;
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
@@ -29 +34 @@
   [Item("MDLEvaluator", "Description missing")]
   [StorableClass]
-  public class MDLEvaluator : DecisionListEvaluator {
+  public class MDLEvaluator : SingleSuccessorOperator, IDecisionListEvaluator, IDecisionListOperator, IMDLCalculatorBasedOperator, IIterationBasedOperator, IStochasticOperator {
 
-    public IValueLookupParameter<MDLCalculator> MDLCalculatorParameter {
-      get { return (IValueLookupParameter<MDLCalculator>)Parameters["MDLCalculator"]; }
+    #region Parameter Properties
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
+    }
+    public ILookupParameter<DecisionList> DecisionListParameter {
+      get { return (ILookupParameter<DecisionList>)Parameters["DecisionList"]; }
+    }
+    public IValueLookupParameter<IntValue> SizePenaltyMinRulesParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["SizePenaltyMinRules"]; }
+    }
+    public ILookupParameter<DoubleValue> QualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["Quality"]; }
+    }
+    public IValueLookupParameter<IDecisionListClassificationProblemData> ProblemDataParameter {
+      get { return (IValueLookupParameter<IDecisionListClassificationProblemData>)Parameters["ProblemData"]; }
+    }
+
+    public ILookupParameter<MDLCalculator> MDLCalculatorParameter {
+      get { return (ILookupParameter<MDLCalculator>)Parameters["MDLCalculator"]; }
+    }
+    public ILookupParameter<IntValue> IterationsParameter {
+      get { return (ILookupParameter<IntValue>)Parameters["Iterations"]; }
+    }
+    public IValueLookupParameter<IntValue> MaximumIterationsParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["MaximumIterations"]; }
+    }
+
+    public IValueLookupParameter<IntValue> IterationRuleDeletionParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["IterationRuleDeletion"]; }
+    }
+    public IValueLookupParameter<IntValue> RuleDeletionMinRulesParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["RuleDeletionMinRules"]; }
+    }
+
+    public ILookupParameter<ItemList<ItemList<IntValue>>> StrataParameter {
+      get { return (ILookupParameter<ItemList<ItemList<IntValue>>>)Parameters["Strata"]; }
+    }
+    #endregion
+
+    public IRandom Random {
+      get { return RandomParameter.ActualValue; }
     }
 
@@ -42 +86 @@
     public MDLEvaluator()
       : base() {
-      Parameters.Add(new ValueLookupParameter<MDLCalculator>("MDLCalculator", ""));
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The random generator to use."));
+      Parameters.Add(new LookupParameter<DecisionList>("DecisionList", ""));
+      Parameters.Add(new ValueLookupParameter<IntValue>("SizePenaltyMinRules", ""));
+      Parameters.Add(new LookupParameter<DoubleValue>("Quality", ""));
+      Parameters.Add(new ValueLookupParameter<IDecisionListClassificationProblemData>("ProblemData", ""));
+      Parameters.Add(new LookupParameter<MDLCalculator>("MDLCalculator", ""));
+      Parameters.Add(new LookupParameter<IntValue>("Iterations", ""));
+      Parameters.Add(new ValueLookupParameter<IntValue>("MaximumIterations", ""));
+      Parameters.Add(new ValueLookupParameter<IntValue>("IterationRuleDeletion", "", new IntValue(5)));
+      Parameters.Add(new ValueLookupParameter<IntValue>("RuleDeletionMinRules", "", new IntValue(12)));
+      Parameters.Add(new ValueLookupParameter<ItemList<ItemList<IntValue>>>("Strata", ""));
     }
     public override IDeepCloneable Clone(Cloner cloner) {
@@ -51 +105 @@
       double penalty = 1;
 
-      var dls = new DecisionListSolution(DecisionListParameter.ActualValue, ProblemDataParameter.ActualValue);
+      var strata = StrataParameter.ActualValue;
+      int iteration = IterationsParameter.ActualValue.Value;
+      int numberOfStrata = strata.Count;
+      var dl = DecisionListParameter.ActualValue;
+      var problemData = ProblemDataParameter.ActualValue;
+      bool lastIteration = iteration == MaximumIterationsParameter.ActualValue.Value - 1;
+      IEnumerable<int> rows;
+      if (lastIteration) {
+        rows = from s in strata
+               from row in s
+               select row.Value;
+      } else {
+        rows = strata[iteration % numberOfStrata].Select(x => x.Value);
+      }
+      var input = problemData.FetchInput(rows);
+      var actions = problemData.FetchAction(rows);
+      ItemSet<Rule> aliveRules;
+      double theoryLength;
+      var estimated = dl.Evaluate(input, out aliveRules, out theoryLength);
 
-      if (dls.TrainingNumberOfAliveRules < SizePenaltyMinRulesParameter.ActualValue.Value) {
-        penalty = (1 - 0.025 * (SizePenaltyMinRulesParameter.ActualValue.Value - dls.TrainingNumberOfAliveRules));
+      if (aliveRules.Count < SizePenaltyMinRulesParameter.ActualValue.Value) {
+        penalty = (1 - 0.025 * (SizePenaltyMinRulesParameter.ActualValue.Value - aliveRules.Count));
         if (penalty <= 0) penalty = 0.01;
         penalty *= penalty;
       }
 
-      QualityParameter.ActualValue = new DoubleValue(MDLCalculatorParameter.ActualValue.CalculateFitness(dls) / penalty);
+      double accuracy = DecisionListSolution.CalculateAccuracy(actions, estimated);
+      QualityParameter.ActualValue = new DoubleValue(MDLCalculatorParameter.ActualValue.CalculateFitness(theoryLength, accuracy) / penalty);
+
+      if (iteration >= IterationRuleDeletionParameter.ActualValue.Value) {
+        if (lastIteration) {
+          DoRuleDeletion(dl, aliveRules, 1);
+        } else {
+          DoRuleDeletion(dl, aliveRules, RuleDeletionMinRulesParameter.ActualValue.Value);
+        }
+      }
       return base.Apply();
+    }
+
+    // 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) {
+      int ruleSetSize = dl.RuleSetSize;
+      if (ruleSetSize <= minRules) { return; }
+
+      var deadRules = dl.Rules.Except(aliveRules).ToList();
+      int numberOfDeadRules = deadRules.Count();
+
+      int keepRules = minRules - (ruleSetSize - numberOfDeadRules);
+
+      if (keepRules > 0) {
+        for (int i = 0; i < keepRules; i++) {
+          int pos = Random.Next(deadRules.Count);
+          deadRules.RemoveAt(pos);
+        }
+      }
+
+      dl.RemoveRules(deadRules);
     }
   }

@@ -1 +1 @@
 *.user
 Plugin.cs
+obj