Changeset 9154 for branches/LearningClassifierSystems/HeuristicLab.Problems.ConditionActionClassification/3.3

Timestamp:

01/14/13 15:23:17 (12 years ago)

Author:

sforsten

Message:

#1980:

• added XCSSolution, XCSModel, XCSClassifier to represent the xcs classifier
• XCSSolution also shows the current accuracy (training and test partition has to be added)
• added XCSSolutionAnalyzer to create a XCSSolution during the run of the algorithm
• added XCSModelView to show the xcs model
• fixed a bug in XCSDeletionOperator (sometimes it deleted less classifiers than it should)
• moved some parameter from ConditionActionClassificationProblem to ConditionActionClassificationProblemData

Location:

branches/LearningClassifierSystems/HeuristicLab.Problems.ConditionActionClassification/3.3

Files:

• HeuristicLab.Problems.ConditionActionClassification-3.3.csproj (modified) (3 diffs)
• Implementation/ConditionActionClassificationProblem.cs (modified) (8 diffs)
• Implementation/ConditionActionClassificationProblemData.cs (modified) (4 diffs)
• Reinforcement (deleted)

branches/LearningClassifierSystems/HeuristicLab.Problems.ConditionActionClassification/3.3/HeuristicLab.Problems.ConditionActionClassification-3.3.csproj

@@ -40 +40 @@
     <Reference Include="HeuristicLab.Collections-3.3">
       <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Collections-3.3.dll</HintPath>
+      <Private>False</Private>
     </Reference>
     <Reference Include="HeuristicLab.Common-3.3">
       <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Common-3.3.dll</HintPath>
+      <Private>False</Private>
     </Reference>
     <Reference Include="HeuristicLab.Core-3.3">
       <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Core-3.3.dll</HintPath>
+      <Private>False</Private>
     </Reference>
     <Reference Include="HeuristicLab.Data-3.3">
       <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Data-3.3.dll</HintPath>
+      <Private>False</Private>
     </Reference>
-    <Reference Include="HeuristicLab.Encodings.IntegerVectorEncoding-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL" />
-    <Reference Include="HeuristicLab.Operators-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL" />
-    <Reference Include="HeuristicLab.Optimization-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL" />
+    <Reference Include="HeuristicLab.Encodings.IntegerVectorEncoding-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Operators-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Optimization-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <Private>False</Private>
+    </Reference>
     <Reference Include="HeuristicLab.Parameters-3.3">
       <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Parameters-3.3.dll</HintPath>
+      <Private>False</Private>
     </Reference>
     <Reference Include="HeuristicLab.Persistence-3.3">
       <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Persistence-3.3.dll</HintPath>
+      <Private>False</Private>
     </Reference>
     <Reference Include="HeuristicLab.PluginInfrastructure-3.3">
       <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.PluginInfrastructure-3.3.dll</HintPath>
+      <Private>False</Private>
     </Reference>
-    <Reference Include="HeuristicLab.Problems.DataAnalysis-3.4, Version=3.4.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL" />
+    <Reference Include="HeuristicLab.Problems.DataAnalysis-3.4, Version=3.4.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <Private>False</Private>
+    </Reference>
     <Reference Include="System" />
     <Reference Include="System.Core" />
@@ -76 +91 @@
     <Compile Include="Implementation\ConditionActionClassificationProblemData.cs" />
     <Compile Include="Plugin.cs" />
-    <Compile Include="Reinforcement\CombinedIntegerVectorClassifierFetcher.cs" />
     <None Include="HeuristicLab.snk" />
     <None Include="Properties\AssemblyInfo.cs.frame" />
@@ -88 +102 @@
       <Project>{CE7163C5-BFFE-45F0-9BD0-E10EF24E8BD2}</Project>
       <Name>HeuristicLab.Encodings.CombinedIntegerVectorEncoding-3.3</Name>
+      <Private>False</Private>
     </ProjectReference>
     <ProjectReference Include="..\..\HeuristicLab.Encodings.ConditionActionEncoding\3.3\HeuristicLab.Encodings.ConditionActionEncoding-3.3.csproj">
       <Project>{422FB262-0845-4969-8D16-12F057AA90B1}</Project>
       <Name>HeuristicLab.Encodings.ConditionActionEncoding-3.3</Name>
+      <Private>False</Private>
     </ProjectReference>
   </ItemGroup>

branches/LearningClassifierSystems/HeuristicLab.Problems.ConditionActionClassification/3.3/Implementation/ConditionActionClassificationProblem.cs

@@ -76 +76 @@
       get { return (IFixedValueParameter<IntValue>)Parameters["ThetaMinimalNumberOfActions"]; }
     }
-    //for test purposes
-    public IFixedValueParameter<IntValue> LengthParameter {
-      get { return (IFixedValueParameter<IntValue>)Parameters["Length"]; }
-    }
-    public IFixedValueParameter<IntValue> ActionPartLengthParameter {
-      get { return (IFixedValueParameter<IntValue>)Parameters["ActionPartLength"]; }
-    }
-    public IFixedValueParameter<IntMatrix> BoundsParameter {
-      get { return (IFixedValueParameter<IntMatrix>)Parameters["Bounds"]; }
-    }
     #endregion
 
@@ -120 +110 @@
     }
     IParameter IConditionActionProblem.ActionExecuterParameter { get { return ActionExecuterParameter; } }
-    public CombinedIntegerVectorClassifierFetcher ClassifierFetcher {
+    public ClassifierFetcher ClassifierFetcher {
       get { return ClassifierFetcherParameter.Value; }
     }
-    public ValueParameter<CombinedIntegerVectorClassifierFetcher> ClassifierFetcherParameter {
-      get { return (ValueParameter<CombinedIntegerVectorClassifierFetcher>)Parameters[ClassifierFetcherParameterName]; }
+    public ValueParameter<ClassifierFetcher> ClassifierFetcherParameter {
+      get { return (ValueParameter<ClassifierFetcher>)Parameters[ClassifierFetcherParameterName]; }
     }
     IClassifierFetcher IConditionActionProblem.ClassifierFetcher { get { return ClassifierFetcher; } }
@@ -150 +140 @@
     IParameter IConditionActionProblem.CoveringSolutionCreatorParameter {
       get { return CoveringSolutionCreatorParameter; }
+    }
+    private XCSSolutionAnalyzer XCSSolutionAnalyzer {
+      get { return Operators.OfType<XCSSolutionAnalyzer>().FirstOrDefault(); }
     }
     #endregion
@@ -170 +163 @@
     public ConditionActionClassificationProblem(ConditionActionClassificationProblemData problemData, XCSEvaluator evaluator, UniformRandomCombinedIntegerVectorCreator solutionCreator, ICoveringSolutionCreator coveringSolutionCreator)
       : base(evaluator, solutionCreator) {
-      Parameters.Add(new FixedValueParameter<IntValue>("Length", "The operator to create a solution.", new IntValue(7)));
-      Parameters.Add(new FixedValueParameter<IntValue>("ActionPartLength", "The operator to create a solution.", new IntValue(1)));
-      int[,] elements = new int[,] { { 0, 3 }, { 0, 3 }, { 0, 3 }, { 0, 3 }, { 0, 3 }, { 0, 3 }, { 0, 2 } };
-      Parameters.Add(new FixedValueParameter<IntMatrix>("Bounds", "The operator to create a solution.", new IntMatrix(elements)));
       Parameters.Add(new ValueParameter<ConditionActionClassificationProblemData>("ProblemData", "", problemData));
       Parameters.Add(new FixedValueParameter<DoubleValue>("PositiveReward", "", new DoubleValue(1000)));
@@ -182 +171 @@
 
       Parameters.Add(new ValueParameter<IActionExecuter>(ActionExecuterParameterName, "", new ActionExecuter()));
-      Parameters.Add(new ValueParameter<CombinedIntegerVectorClassifierFetcher>(ClassifierFetcherParameterName, "", new CombinedIntegerVectorClassifierFetcher()));
+      Parameters.Add(new ValueParameter<ClassifierFetcher>(ClassifierFetcherParameterName, "", new ClassifierFetcher()));
       Parameters.Add(new FixedValueParameter<ItemSet<IClassifier>>("PossibleActions"));
       Parameters.Add(new FixedValueParameter<ItemSet<CombinedIntegerVector>>("PossibleActionsConcreteClass"));
@@ -196 +185 @@
       Evaluator.InitialPredictionParameter.ActualName = "InitialPrediction";
 
-      SolutionCreator.ActionPartLengthParameter.ActualName = ActionPartLengthParameter.Name;
-      SolutionCreator.LengthParameter.ActualName = LengthParameter.Name;
-      SolutionCreator.BoundsParameter.ActualName = BoundsParameter.Name;
+      SolutionCreator.ActionPartLengthParameter.ActualName = ProblemData.ActionLengthParameter.Name;
+      SolutionCreator.LengthParameter.ActualName = ProblemData.LengthParameter.Name;
+      SolutionCreator.BoundsParameter.ActualName = ProblemData.BoundsParameter.Name;
 
       coveringSolutionCreator.ChangeSymbolProbabilityParameter.ActualName = ChangeSymbolProbabilityInCoveringParameter.Name;
@@ -204 +193 @@
       coveringSolutionCreator.CreatedClassifierParameter.ActualName = "CombinedIntegerVector";
 
-      ClassifierFetcher.ActionPartLengthParameter.ActualName = ActionPartLengthParameter.Name;
-      ClassifierFetcher.BoundsParameter.ActualName = BoundsParameter.Name;
       ClassifierFetcher.ProblemDataParameter.ActualName = ProblemDataParameter.Name;
 
@@ -217 +204 @@
       ThetaMinimalNumberOfActions.Value = PossibleActions.Count;
 
-      BoundsParameter.ValueChanged += new System.EventHandler(BoundsParameter_ValueChanged);
-      LengthParameter.ValueChanged += new System.EventHandler(LengthParameter_ValueChanged);
-      ActionPartLengthParameter.ValueChanged += new System.EventHandler(ActionPartLengthParameter_ValueChanged);
-    }
-
-    #region event handler
-    private void ActionPartLengthParameter_ValueChanged(object sender, System.EventArgs e) {
+      InitializeOperators();
+
+      problemData.Changed += new System.EventHandler(problemData_Changed);
+    }
+
+    private void problemData_Changed(object sender, System.EventArgs e) {
       SetPossibleActions();
     }
-    private void LengthParameter_ValueChanged(object sender, System.EventArgs e) {
-      SetPossibleActions();
-    }
-    private void BoundsParameter_ValueChanged(object sender, System.EventArgs e) {
-      SetPossibleActions();
-    }
-    #endregion
+
+    private void InitializeOperators() {
+      Operators.Add(new XCSSolutionAnalyzer());
+
+      ParameterizeAnalyzers();
+    }
+
+    private void ParameterizeAnalyzers() {
+      if (XCSSolutionAnalyzer != null) {
+        XCSSolutionAnalyzer.ClassifierParameter.ActualName = SolutionCreator.CombinedIntegerVectorParameter.ActualName;
+        XCSSolutionAnalyzer.PredictionParameter.ActualName = Evaluator.PredictionParameter.ActualName;
+        XCSSolutionAnalyzer.ErrorParameter.ActualName = Evaluator.ErrorParameter.ActualName;
+        XCSSolutionAnalyzer.FitnessParameter.ActualName = Evaluator.FitnessParameter.ActualName;
+        XCSSolutionAnalyzer.ExperienceParameter.ActualName = Evaluator.ExperienceParameter.ActualName;
+        XCSSolutionAnalyzer.AverageActionSetSizeParameter.ActualName = Evaluator.AverageActionSetSizeParameter.ActualName;
+        XCSSolutionAnalyzer.NumerosityParameter.ActualName = Evaluator.NumerosityParameter.ActualName;
+        XCSSolutionAnalyzer.TimestampParameter.ActualName = Evaluator.TimestampParameter.ActualName;
+        XCSSolutionAnalyzer.ProblemDataParameter.ActualName = ProblemDataParameter.Name;
+        XCSSolutionAnalyzer.ResultsParameter.ActualName = "Results";
+      }
+    }
 
     private void SetPossibleActions() {
       //get bounds of action
-      IntMatrix actionBounds = GetElementsOfBoundsForAction(BoundsParameter.Value, LengthParameter.Value.Value, ActionPartLengthParameter.Value.Value);
-      int actionLength = ActionPartLengthParameter.Value.Value;
-      int start = LengthParameter.Value.Value - actionLength;
+      IntMatrix actionBounds = GetElementsOfBoundsForAction(ProblemData.Bounds, ProblemData.Length.Value, ProblemData.ActionLength.Value);
+      int actionLength = ProblemData.ActionLength.Value;
+      int start = ProblemData.Length.Value - actionLength;
       int[] elements = new int[actionLength];
       int[] curPos = new int[actionLength];

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

@@ -26 +26 @@
 using HeuristicLab.Core;
 using HeuristicLab.Data;
+using HeuristicLab.Encodings.CombinedIntegerVectorEncoding;
 using HeuristicLab.Encodings.ConditionActionEncoding;
 using HeuristicLab.Parameters;
@@ -54 +55 @@
       get { return (IFixedValueParameter<ReadOnlyCheckedItemList<StringValue>>)Parameters["ActionVariables"]; }
     }
+    public IFixedValueParameter<IntValue> LengthParameter {
+      get { return (IFixedValueParameter<IntValue>)Parameters["Length"]; }
+    }
+    public IFixedValueParameter<IntValue> ActionLengthParameter {
+      get { return (IFixedValueParameter<IntValue>)Parameters["ActionLength"]; }
+    }
+    public IFixedValueParameter<IntMatrix> BoundsParameter {
+      get { return (IFixedValueParameter<IntMatrix>)Parameters["Bounds"]; }
+    }
     #endregion
 
@@ -74 +84 @@
       get { return ActionVariables.CheckedItems.Select(x => x.Value.Value); }
     }
+
+    private IDictionary<int, IClassifier> fetchClassifiersCache = new Dictionary<int, IClassifier>();
 
 
@@ -105 +117 @@
       Parameters.Add(new FixedValueParameter<ReadOnlyCheckedItemList<StringValue>>("ActionVariables", "", actionVariables.AsReadOnly()));
       Parameters.Add(new FixedValueParameter<ReadOnlyCheckedItemList<StringValue>>("ConditionVariables", "", conditionVariables.AsReadOnly()));
+      Parameters.Add(new FixedValueParameter<IntValue>("Length", "", new IntValue(7)));
+      Parameters.Add(new FixedValueParameter<IntValue>("ActionLength", "", new IntValue(1)));
+      int[,] elements = new int[,] { { 0, 3 }, { 0, 3 }, { 0, 3 }, { 0, 3 }, { 0, 3 }, { 0, 3 }, { 0, 2 } };
+      Parameters.Add(new FixedValueParameter<IntMatrix>("Bounds", "", new IntMatrix(elements)));
 
       ((ValueParameter<Dataset>)DatasetParameter).ReactOnValueToStringChangedAndValueItemImageChanged = false;
     }
+
+    public event EventHandler Changed;
+    protected virtual void OnChanged() {
+      var listeners = Changed;
+      if (listeners != null) listeners(this, EventArgs.Empty);
+    }
+
+    public IntValue Length {
+      get { return LengthParameter.Value; }
+    }
+
+    public IntValue ActionLength {
+      get { return ActionLengthParameter.Value; }
+    }
+
+    public IntMatrix Bounds {
+      get { return BoundsParameter.Value; }
+    }
+
+    public IClassifier FetchClassifier(int rowNumber) {
+      if (!fetchClassifiersCache.ContainsKey(rowNumber)) {
+        int[] elements = new int[Length.Value];
+        var variableNamesList = Dataset.VariableNames.ToList();
+        int elementIndex = 0;
+        for (int i = 0; i < variableNamesList.Count; i++) {
+          if (AllowedConditionVariables.Contains(variableNamesList[i])) {
+            elements[elementIndex] = int.Parse(Dataset.GetValue(rowNumber, i));
+            elementIndex++;
+          }
+        }
+        for (int i = 0; i < variableNamesList.Count; i++) {
+          if (AllowedActionVariables.Contains(variableNamesList[i])) {
+            elements[elementIndex] = int.Parse(Dataset.GetValue(rowNumber, i));
+            elementIndex++;
+          }
+        }
+        if (elementIndex != Length.Value) {
+          throw new ArgumentException("Length of classifier is not equal to the number of allowed condition + action variables.");
+        }
+        fetchClassifiersCache.Add(rowNumber, new CombinedIntegerVector(elements, ActionLengthParameter.Value.Value, BoundsParameter.Value));
+      }
+      return fetchClassifiersCache[rowNumber];
+    }
   }
 }