Changeset 9605 for branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList

Timestamp:

06/11/13 13:32:32 (12 years ago)

Author:

sforsten

Message:

#1980:

• set plugin dependencies
• added smart initialization
• added hierarchical selection
• fixed major and minor default rule
• fixed several smaller bugs
• some refactoring has been done

Location:

branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3

Files:

• Action/IAction.cs (modified) (1 diff)
• Action/IntAction.cs (modified) (1 diff)
• Action/StringAction.cs (modified) (1 diff)
• Creators/SmartDecisionListCreator.cs (added)
• Creators/UniformRandomDecisionListCreator.cs (modified) (1 diff)
• Crossover/SinglePointCrossover.cs (modified) (2 diffs)
• DecisionList.cs (modified) (3 diffs)
• DecisionListCreator.cs (modified) (3 diffs)
• Evaluator/MDLEvaluator.cs (modified) (8 diffs)
• HeuristicLab.Encodings.DecisionList-3.3.csproj (modified) (1 diff)
• Interfaces/IDecisionListCreator.cs (modified) (1 diff)
• Interfaces/IDecisionListEvaluator.cs (modified) (1 diff)
• Plugin.cs.frame (modified) (1 diff)
• Rule.cs (modified) (2 diffs)
• Variable/DoubleVariable.cs (modified) (1 diff)
• Variable/IVariable.cs (modified) (2 diffs)
• Variable/IntVariable.cs (modified) (1 diff)
• Variable/StringVariable.cs (modified) (1 diff)
• Variable/Variable.cs (modified) (2 diffs)

branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Action/IAction.cs

@@ -34 +34 @@
     bool Match(IAction action);
     void SetTo(string value);
+    void SetTo(IGAssistNiche action);
 
     IEnumerable<int> GetPossibleActionPositions();

branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Action/IntAction.cs

@@ -117 +117 @@
 
     public void SetTo(string value) {
-      currentAction = int.Parse(value);
+      SetToPosition(int.Parse(value));
+    }
+
+    public void SetTo(IGAssistNiche action) {
+      var castAction = action as IntAction;
+      if (castAction == null) throw new ArgumentException("action has to be IntAction");
+      SetToPosition(castAction.CurrentAction);
     }
 

branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Action/StringAction.cs

@@ -122 +122 @@
 
     public void SetTo(string value) {
-      currentActionIndex = possibleFeatures.IndexOf(value);
+      SetToPosition(possibleFeatures.IndexOf(value));
+    }
+
+    public void SetTo(IGAssistNiche action) {
+      var castAction = action as StringAction;
+      if (castAction == null) throw new ArgumentException("action has to be IntAction");
+      SetToPosition(castAction.CurrentPosition);
     }
 

branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Creators/UniformRandomDecisionListCreator.cs

@@ -43 +43 @@
     }
 
-    protected override DecisionList Create(IRandom random, Rule sampleRule, int initialNumberOfRules, double oneProbability, ItemCollection<IDiscretizer> discretizers) {
+    protected override DecisionList Create(IRandom random, Rule sampleRule, int initialNumberOfRules, double oneProbability, ItemCollection<IDiscretizer> discretizers, IAction niche) {
       List<Rule> rules = new List<Rule>();
       for (int i = 0; i < initialNumberOfRules; i++) {
         var newRule = (Rule)sampleRule.Clone();
-        newRule.Randomize(random, oneProbability, discretizers);
+        if (niche != null) {
+          newRule.Randomize(random, oneProbability, discretizers, new List<IAction>() { niche });
+        } else {
+          newRule.Randomize(random, oneProbability, discretizers);
+        }
         rules.Add(newRule);
       }
 
-      return new DecisionList(rules);
+      if (niche != null) {
+        return new DecisionList(rules, niche);
+      } else {
+        return new DecisionList(rules);
+      }
     }
   }

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

@@ -48 +48 @@
 
     public static DecisionList Apply(IRandom random, DecisionList parent1, DecisionList parent2) {
-      if (!parent1.DefaultAction.Match(parent2.DefaultAction)) { throw new ArgumentException("Default action of parents have to match!"); }
+      if (parent1 == null && parent1 != parent2) { throw new ArgumentException("Either both parents have a default action or none does."); }
+      if (parent1.DefaultAction != null && !parent1.DefaultAction.Match(parent2.DefaultAction)) { throw new ArgumentException("Default action of parents have to match!"); }
 
       int rulesP1 = random.Next(0, parent1.Rules.Count());
@@ -64 +65 @@
       }
 
+      if (parent1.DefaultAction == null) {
+        return new DecisionList(rules);
+      }
       return new DecisionList(rules, parent1.DefaultAction);
     }

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

@@ -44 +44 @@
     }
 
+    public double Length {
+      get { return 1 + rules.Sum(r => r.Length); }
+    }
+
     // default rule (action) is part of the rule set size
     public int RuleSetSize {
@@ -53 +57 @@
     protected DecisionList(DecisionList original, Cloner cloner)
       : base(original, cloner) {
-      defaultAction = original.DefaultAction;
+      defaultAction = cloner.Clone(original.DefaultAction);
       rules = new List<Rule>(original.rules.Count);
       foreach (var rule in original.Rules) {
@@ -124 +128 @@
     }
 
-    public void SetNiche(IRandom random, IGAssistNiche niche) {
-      var action = niche as IAction;
-      if (action == null) {
-        throw new ArgumentException("Niche has to be an action");
-      }
-      if (Niche != null) {
-        throw new ArgumentException("Niche has already been set. It cannot be set again.");
-      }
-      defaultAction = action;
-      var except = new List<IAction>() { action };
-      foreach (var rule in rules.Where(x => x.Action.SameNiche(niche))) {
-        rule.Action.Randomize(random, except);
-      }
-    }
-
     public void ApplySplit(IRandom random, double probability) {
       foreach (var rule in rules) {

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

@@ -20 +20 @@
 #endregion
 
+using System;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -52 +53 @@
       get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
     }
+    public ILookupParameter<IGAssistNiche> GAssistNicheParameter {
+      get { return (ILookupParameter<IGAssistNiche>)Parameters["GAssistNiche"]; }
+    }
     #endregion
 
@@ -67 +71 @@
       Parameters.Add(new LookupParameter<DecisionList>("DecisionList", ""));
       Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator which should be used for stochastic manipulation operators."));
-      Parameters.Add(new ValueLookupParameter<IAction>("DefaultAction", ""));
+      Parameters.Add(new LookupParameter<IGAssistNiche>("GAssistNiche", ""));
     }
 
     public override IOperation Apply() {
-      DecisionListParameter.ActualValue = Create(RandomParameter.ActualValue, ProblemDataParameter.ActualValue.SampleRuleParameter.Value, InitialNumberOfRulesParameter.ActualValue.Value, OneProbabilityParameter.ActualValue.Value, DiscretizersParameter.ActualValue);
+      if (GAssistNicheParameter.ActualValue != null && !(GAssistNicheParameter.ActualValue is IAction)) throw new ArgumentException("GAssistNiche has to be a IAction.");
+      DecisionListParameter.ActualValue = Create(RandomParameter.ActualValue,
+                                              ProblemDataParameter.ActualValue.SampleRuleParameter.Value,
+                                              InitialNumberOfRulesParameter.ActualValue.Value,
+                                              OneProbabilityParameter.ActualValue.Value,
+                                              DiscretizersParameter.ActualValue,
+                                              (IAction)GAssistNicheParameter.ActualValue);
       return base.Apply();
     }
 
-    protected abstract DecisionList Create(IRandom random, Rule sampleRule, int initialNumberOfRules, double oneProbability, ItemCollection<IDiscretizer> discretizers);
+    protected abstract DecisionList Create(IRandom random, Rule sampleRule, int initialNumberOfRules, double oneProbability, ItemCollection<IDiscretizer> discretizers, IAction niche);
   }
 }

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

@@ -49 +49 @@
       get { return (ILookupParameter<DoubleValue>)Parameters["Quality"]; }
     }
+    public ILookupParameter<DoubleValue> LengthParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["Length"]; }
+    }
     public IValueLookupParameter<IDecisionListClassificationProblemData> ProblemDataParameter {
       get { return (IValueLookupParameter<IDecisionListClassificationProblemData>)Parameters["ProblemData"]; }
     }
 
+    public IValueLookupParameter<BoolValue> UseMDLParameter {
+      get { return (IValueLookupParameter<BoolValue>)Parameters["UseMDL"]; }
+    }
     public ILookupParameter<MDLCalculator> MDLCalculatorParameter {
       get { return (ILookupParameter<MDLCalculator>)Parameters["MDLCalculator"]; }
@@ -73 +79 @@
       get { return (ILookupParameter<ItemList<ItemList<IntValue>>>)Parameters["Strata"]; }
     }
+    public IValueLookupParameter<BoolValue> MaximizationParameter {
+      get { return (IValueLookupParameter<BoolValue>)Parameters["Maximization"]; }
+    }
     #endregion
 
@@ -90 +99 @@
       Parameters.Add(new ValueLookupParameter<IntValue>("SizePenaltyMinRules", ""));
       Parameters.Add(new LookupParameter<DoubleValue>("Quality", ""));
+      Parameters.Add(new LookupParameter<DoubleValue>("Length", ""));
       Parameters.Add(new ValueLookupParameter<IDecisionListClassificationProblemData>("ProblemData", ""));
+      Parameters.Add(new ValueLookupParameter<BoolValue>("UseMDL", "", new BoolValue(true)));
       Parameters.Add(new LookupParameter<MDLCalculator>("MDLCalculator", ""));
       Parameters.Add(new LookupParameter<IntValue>("Iterations", ""));
@@ -97 +108 @@
       Parameters.Add(new ValueLookupParameter<IntValue>("RuleDeletionMinRules", "", new IntValue(12)));
       Parameters.Add(new ValueLookupParameter<ItemList<ItemList<IntValue>>>("Strata", ""));
+      Parameters.Add(new ValueLookupParameter<BoolValue>("Maximization", "", new BoolValue(false)));
+
+      UseMDLParameter.Value.ValueChanged += UseMDLParameter_ValueChanged;
+    }
+
+    private void UseMDLParameter_ValueChanged(object sender, System.EventArgs e) {
+      MaximizationParameter.Value.Value = !UseMDLParameter.Value.Value;
     }
     public override IDeepCloneable Clone(Cloner cloner) {
@@ -103 +121 @@
 
     public override IOperation Apply() {
-      double penalty = 1;
-
       var strata = StrataParameter.ActualValue;
       int iteration = IterationsParameter.ActualValue.Value;
@@ -125 +141 @@
       var estimated = dl.Evaluate(input, out aliveRules, out theoryLength);
 
+      double penalty = 1;
       if (aliveRules.Count < SizePenaltyMinRulesParameter.ActualValue.Value) {
         penalty = (1 - 0.025 * (SizePenaltyMinRulesParameter.ActualValue.Value - aliveRules.Count));
@@ -132 +149 @@
 
       double accuracy = DecisionListSolution.CalculateAccuracy(actions, estimated);
-      QualityParameter.ActualValue = new DoubleValue(MDLCalculatorParameter.ActualValue.CalculateFitness(theoryLength, accuracy) / penalty);
+      if (UseMDLParameter.ActualValue.Value) {
+        QualityParameter.ActualValue =
+          new DoubleValue(MDLCalculatorParameter.ActualValue.CalculateFitness(theoryLength, accuracy) / penalty);
+      } else {
+        QualityParameter.ActualValue = new DoubleValue(accuracy * accuracy * penalty);
+      }
 
       if (iteration >= IterationRuleDeletionParameter.ActualValue.Value) {
@@ -141 +163 @@
         }
       }
+
+      LengthParameter.ActualValue = new DoubleValue(dl.Length * aliveRules.Count / dl.RuleSetSize);
       return base.Apply();
     }

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

@@ -93 +93 @@
     <Compile Include="Action\IntAction.cs" />
     <Compile Include="Analyzer\BestTrainingDecisionListAnalyzer.cs" />
+    <Compile Include="Creators\SmartDecisionListCreator.cs" />
     <Compile Include="Creators\UniformRandomDecisionListCreator.cs" />
     <Compile Include="Crossover\SinglePointCrossover.cs" />

branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Interfaces/IDecisionListCreator.cs

@@ -26 +26 @@
 
 namespace HeuristicLab.Encodings.DecisionList {
-  public interface IDecisionListCreator : IDecisionListOperator, ISolutionCreator, IStochasticOperator, IGAssistIndividualCreator {
+  public interface IDecisionListCreator : IDecisionListOperator, ISolutionCreator, IStochasticOperator, IGAssistSolutionCreator {
     IValueLookupParameter<IDecisionListClassificationProblemData> ProblemDataParameter { get; }
     ILookupParameter<DecisionList> DecisionListParameter { get; }

branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Interfaces/IDecisionListEvaluator.cs

@@ -25 +25 @@
 
 namespace HeuristicLab.Encodings.DecisionList {
-  public interface IDecisionListEvaluator : IStrataSingleObjectiveEvaluator {
+  public interface IDecisionListEvaluator : IGAssistObjectiveEvaluator {
     ILookupParameter<DecisionList> DecisionListParameter { get; }
     IValueLookupParameter<IDecisionListClassificationProblemData> ProblemDataParameter { get; }

branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Plugin.cs.frame

@@ -27 +27 @@
   [PluginDependency("HeuristicLab.Collections", "3.3")]
   [PluginDependency("HeuristicLab.Common", "3.3")]
-  [PluginDependency("HeuristicLab.Common.Resources", "3.3")]
+  [PluginDependency("HeuristicLab.Core", "3.3")]
+  [PluginDependency("HeuristicLab.Data", "3.3")]
+  [PluginDependency("HeuristicLab.Operators", "3.3")]
+  [PluginDependency("HeuristicLab.Optimization", "3.3")]
+  [PluginDependency("HeuristicLab.Optimization.Operators.LCS", "3.3")]
+  [PluginDependency("HeuristicLab.Parameters", "3.3")]
   [PluginDependency("HeuristicLab.Persistence", "3.3")]
+  [PluginDependency("HeuristicLab.Problems.DataAnalysis", "3.4")]
   public class HeuristicLabEncodingsDecisionListPlugin : PluginBase {
   }

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

@@ -43 +43 @@
     public IAction Action { get { return action; } }
 
+    public double Length {
+      get { return variables.Values.Sum(x => x.Length); }
+    }
+
     [StorableConstructor]
     protected Rule(bool deserializing) : base(deserializing) { }
@@ -77 +81 @@
     }
 
-    public void Randomize(IRandom random, double onePercentage, IEnumerable<IDiscretizer> discretizer) {
+    public void Randomize(IRandom random, double oneProbability, IEnumerable<IDiscretizer> discretizers, IEnumerable<IAction> exceptActions = null) {
       foreach (var variable in variables.Values) {
-        variable.Randomize(random, onePercentage, discretizer);
+        variable.Randomize(random, oneProbability, discretizers);
       }
-      action.Randomize(random);
+      if (exceptActions == null) {
+        action.Randomize(random);
+      } else {
+        action.Randomize(random, exceptActions);
+      }
+    }
+
+    public void SetToMatchInput(IGAssistInput input) {
+      foreach (var variable in variables) {
+        if (!input.VariableNames.Contains(variable.Key)) {
+          throw new ArgumentException("input does not contain variable name of rule");
+        }
+        variable.Value.SetToMatch(input.GetVariableValue(variable.Key));
+      }
     }
 

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

@@ -191 +191 @@
     public override void Reinitialize(IRandom random, double onePercentage, IEnumerable<IDiscretizer> descretizers) {
       Randomize(random, onePercentage, descretizers);
-      return;
+    }
+
+    public override void SetToMatch(string variableValue) {
+      var value = double.Parse(variableValue);
+      var realCutpoints = GetValuesToCutPoints(discretizer.GetCutPoints(variableName), curIntervals);
+      int pos = 0;
+      while (value >= realCutpoints[pos]) {
+        pos++;
+      }
+      attributes[pos] = true;
     }
   }

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

@@ -27 +27 @@
 namespace HeuristicLab.Encodings.DecisionList {
   public interface IVariable : IItem {
+    double Length { get; }
     string VariableName { get; }
     Type VariableType { get; }
@@ -43 +44 @@
 
     void Split(IRandom Random);
+
+    void SetToMatch(string variableValue);
   }
 }

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

@@ -68 +68 @@
       return attributes[possibleFeatures.IndexOf(input)];
     }
+
+    public override void SetToMatch(string variableValue) {
+      var value = int.Parse(variableValue);
+      if (!possibleFeatures.Contains(value)) throw new ArgumentException("variableValue " + variableValue + " is not a possible value of variable " + variableName);
+
+      attributes[possibleFeatures.IndexOf(value)] = true;
+    }
   }
 }

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

@@ -64 +64 @@
       return attributes[possibleFeatures.IndexOf(input)];
     }
+
+    public override void SetToMatch(string variableValue) {
+      var valueIndex = possibleFeatures.IndexOf(variableValue);
+      if (valueIndex == -1) throw new ArgumentException("variableValue " + variableValue + " is not a possible value of variable " + variableName);
+
+      attributes[valueIndex] = true;
+    }
   }
 }

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

@@ -38 +38 @@
     }
 
+    public double Length {
+      get { return attributes.Count; }
+    }
+
     [Storable]
     protected string variableName;
@@ -72 +76 @@
     public abstract bool Match(string input);
 
+    public abstract void SetToMatch(string variableValue);
+
     public virtual string ToFullString() { throw new NotImplementedException(); }