Changeset 9494

Timestamp:

05/14/13 16:54:01 (11 years ago)

Author:

sforsten

Message:

#1980:

• renamed algorithm Learning Classifier System to XCS
• DecisionListSolution and XCSSolution show more information
• VariableVectorClassificationProblemData can now also import datasets where the last variable is not the target variable

Location:

branches/LearningClassifierSystems

Files:

• HeuristicLab.Algorithms.LearningClassifierSystems/3.3/LearningClassifierSystem.cs (modified) (1 diff)
• HeuristicLab.Encodings.ConditionActionEncoding/3.3/XCSSolution.cs (modified) (4 diffs)
• HeuristicLab.Encodings.DecisionList/3.3/DecisionListSolution.cs (modified) (4 diffs)
• HeuristicLab.Problems.ConditionActionClassification/3.3/ConditionActionClassificationProblemData.cs (modified) (2 diffs)
• HeuristicLab.Problems.VariableVectorClassification/3.3/VariableVectorClassificationProblemData.cs (modified) (3 diffs)

branches/LearningClassifierSystems/HeuristicLab.Algorithms.LearningClassifierSystems/3.3/LearningClassifierSystem.cs

@@ -38 +38 @@
   /// A learning classifier system.
   /// </summary>
-  [Item("Learning Classifier System", "A genetic algorithm.")]
+  [Item("XCS", "A learning classifier system")]
   [Creatable("Algorithms")]
   [StorableClass]

branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/XCSSolution.cs

@@ -37 +37 @@
     private const string TrainingAccuracyResultName = "Accuracy (training)";
     private const string TestAccuracyResultName = "Accuracy (test)";
+    private const string NumberOfMacroClassifiersName = "Number of Macroclassifiers";
 
     public string Filename { get; set; }
@@ -47 +48 @@
       get { return ((DoubleValue)this[TestAccuracyResultName].Value).Value; }
       private set { ((DoubleValue)this[TestAccuracyResultName].Value).Value = value; }
+    }
+    public int NumberOfMacroClassifiers {
+      get { return ((IntValue)this[NumberOfMacroClassifiersName].Value).Value; }
+      private set { ((IntValue)this[NumberOfMacroClassifiersName].Value).Value = value; }
     }
 
@@ -97 +102 @@
       Add(new Result(TrainingAccuracyResultName, "Accuracy of the model on the training partition (percentage of correctly classified instances).", new PercentValue()));
       Add(new Result(TestAccuracyResultName, "Accuracy of the model on the test partition (percentage of correctly classified instances).", new PercentValue()));
+      Add(new Result(NumberOfMacroClassifiersName, new IntValue(model.ClassifierCount)));
 
       problemData.Changed += new EventHandler(ProblemData_Changed);
@@ -104 +110 @@
 
     private void RecalculateResults() {
+      NumberOfMacroClassifiers = Model.ClassifierCount;
       var originalTrainingCondition = ProblemData.FetchInput(ProblemData.TrainingIndices);
       var originalTestCondition = ProblemData.FetchInput(ProblemData.TestIndices);

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

@@ -40 +40 @@
     private const string TrainingNumberOfAliveRulesName = "Number of alive rules (training)";
     private const string TrainingAliveRulesName = "Alive Rules (training)";
-    //private const string TestNumberOfAliveRules = "Number of alive rules (test)";
+    private const string TestNumberOfAliveRulesName = "Number of alive rules (test)";
+    private const string TestAliveRulesName = "Alive Rules (test)";
     private const string TrainingTheoryLengthName = "Theory Length (training)";
     private const string TrainingExceptionsLengthName = "Exceptions Length (training)";
+    private const string DefaultRuleName = "Default Rule Action";
+    private const string RulesName = "Rules";
+    private const string NumberOfRulesName = "Number of Rules";
 
     public double TrainingAccuracy {
@@ -67 +71 @@
       get { return ((DoubleValue)this[TrainingExceptionsLengthName].Value).Value; }
       private set { ((DoubleValue)this[TrainingExceptionsLengthName].Value).Value = value; }
+    }
+    public int TestNumberOfAliveRules {
+      get { return ((IntValue)this[TestNumberOfAliveRulesName].Value).Value; }
+      private set { ((IntValue)this[TestNumberOfAliveRulesName].Value).Value = value; }
+    }
+    public ItemSet<Rule> TestAliveRules {
+      get { return (ItemSet<Rule>)this[TestAliveRulesName].Value; }
+      private set { this[TestAliveRulesName].Value = value; }
+    }
+    public IAction DefaultRule {
+      get { return (IAction)this[DefaultRuleName].Value; }
+      private set { this[DefaultRuleName].Value = value; }
+    }
+    public ItemList<Rule> Rules {
+      get { return (ItemList<Rule>)this[RulesName].Value; }
+      private set { this[RulesName].Value = value; }
+    }
+    public int NumberOfRules {
+      get { return ((IntValue)this[NumberOfRulesName].Value).Value; }
+      private set { ((IntValue)this[NumberOfRulesName].Value).Value = value; }
     }
 
@@ -122 +146 @@
       Add(new Result(TrainingTheoryLengthName, "", new DoubleValue()));
       Add(new Result(TrainingExceptionsLengthName, "", new DoubleValue()));
+      Add(new Result(TestNumberOfAliveRulesName, "", new IntValue()));
+      Add(new Result(TestAliveRulesName, "", new ItemSet<Rule>()));
+      Add(new Result(DefaultRuleName, model.DefaultAction));
+      Add(new Result(RulesName, new ItemList<Rule>(model.Rules)));
+      Add(new Result(NumberOfRulesName, new IntValue(model.RuleSetSize)));
 
       problemData.Changed += new EventHandler(ProblemData_Changed);
@@ -132 +161 @@
 
     private void RecalculateResults() {
+      DefaultRule = Model.DefaultAction;
+      Rules = new ItemList<Rule>(Model.Rules);
+      NumberOfRules = Model.RuleSetSize;
       var originalTrainingCondition = ProblemData.FetchInput(ProblemData.TrainingIndices);
       var originalTestCondition = ProblemData.FetchInput(ProblemData.TestIndices);
-      ItemSet<Rule> aliveRules;
-      double theoryLength;
-      var estimatedTraining = Model.Evaluate(originalTrainingCondition, out aliveRules, out theoryLength);
-      TrainingNumberOfAliveRules = aliveRules.Count + (Model.DefaultAction != null ? 1 : 0);
-      TrainingAliveRules = aliveRules;
-      TrainingTheoryLength = theoryLength;
-      var estimatedTest = Model.Evaluate(originalTestCondition);
+      ItemSet<Rule> trainingAliveRules;
+      double trainingTheoryLength;
+      var estimatedTraining = Model.Evaluate(originalTrainingCondition, out trainingAliveRules, out trainingTheoryLength);
+      TrainingNumberOfAliveRules = trainingAliveRules.Count + (Model.DefaultAction != null ? 1 : 0);
+      TrainingAliveRules = trainingAliveRules;
+      TrainingTheoryLength = trainingTheoryLength;
+      ItemSet<Rule> testAliveRules;
+      var estimatedTest = Model.Evaluate(originalTestCondition, out testAliveRules);
+      TestNumberOfAliveRules = testAliveRules.Count + (Model.DefaultAction != null ? 1 : 0);
+      TestAliveRules = testAliveRules;
 
       var originalTrainingAction = ProblemData.FetchAction(ProblemData.TrainingIndices);

branches/LearningClassifierSystems/HeuristicLab.Problems.ConditionActionClassification/3.3/ConditionActionClassificationProblemData.cs

@@ -128 +128 @@
       if (allowedConditionVariables == null) throw new ArgumentNullException("The allowedActionVariables must not be null.");
 
-      var actionVariables = new CheckedItemList<StringValue>(dataset.VariableNames.Select(x => new StringValue(x)));
-      var conditionVariables = new CheckedItemList<StringValue>(actionVariables);
+      var actionVariables = CheckVariablesForPossibleTargetVariables(dataset);
       foreach (StringValue x in actionVariables) {
         actionVariables.SetItemCheckedState(x, allowedActionVariables.Contains(x.Value));
+      }
+      var conditionVariables = new CheckedItemList<StringValue>(dataset.VariableNames.Select(x => new StringValue(x)));
+      foreach (StringValue x in conditionVariables) {
         conditionVariables.SetItemCheckedState(x, allowedConditionVariables.Contains(x.Value));
       }
@@ -149 +151 @@
 
       RegisterParameterEvents();
+    }
+
+    protected virtual CheckedItemList<StringValue> CheckVariablesForPossibleTargetVariables(DataAnalysis.Dataset dataset) {
+      return new CheckedItemList<StringValue>(dataset.VariableNames.Select(x => new StringValue(x)));
     }
 

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

@@ -74 +74 @@
     public VariableVectorClassificationProblemData(Dataset dataset, IEnumerable<string> allowedConditionVariables, IEnumerable<string> allowedActionVariables) :
       base(dataset, allowedConditionVariables, allowedActionVariables) {
-      Parameters.Add(new ValueParameter<VariableVector>("SampleVariableVector", "", GenerateSampleVariableVector(dataset, allowedConditionVariables, allowedActionVariables)));
+      Parameters.Add(new ValueParameter<VariableVector>("SampleVariableVector", "", GenerateSampleVariableVector(dataset, AllowedConditionVariables, AllowedActionVariables)));
       Parameters.Add(new FixedValueParameter<PercentValue>("SpreadPercentage", "", new PercentValue(0.5)));
+    }
+
+    protected override CheckedItemList<StringValue> CheckVariablesForPossibleTargetVariables(Dataset dataset) {
+      var allVariables = GetVariablesOfDataSet(dataset, dataset.VariableNames).Where(v => v is StringVariable || v is IntVariable).Select(v => new StringValue(v.VariableName));
+      return new CheckedItemList<StringValue>(allVariables);
     }
 
@@ -81 +86 @@
       var conditionVariables = GetVariablesOfDataSet(dataset, allowedConditionVariables);
       var actionVariables = GetVariablesOfDataSet(dataset, allowedActionVariables);
-      if (actionVariables.Count() == 0 || !actionVariables.All(x => x is IActionVariable)) {
+      if (!actionVariables.All(x => x is IActionVariable)) {
         throw new ArgumentException("Action variable can not be empty and all action variables have to be of type int or string.");
       }
@@ -87 +92 @@
     }
 
-    private IEnumerable<Encodings.VariableVector.IVariable> GetVariablesOfDataSet(DataAnalysis.Dataset dataset, IEnumerable<string> allowedVariables) {
+    private IEnumerable<Encodings.VariableVector.IVariable> GetVariablesOfDataSet(Dataset dataset, IEnumerable<string> allowedVariables) {
       var variables = new List<HeuristicLab.Encodings.VariableVector.IVariable>();
       foreach (var variableName in allowedVariables) {