Changeset 9162 for branches/Sliding Window GP/HeuristicLab.Problems.DataAnalysis.Symbolic

Timestamp:

01/15/13 13:19:28 (12 years ago)

Author:

mkommend

Message:

#1837: Refactored sliding window analyzers and updated the provided algorithm.

Location:

branches/Sliding Window GP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4

Files:

• HeuristicLab.Problems.DataAnalysis.Symbolic-3.4.csproj (modified) (1 diff)
• SlidingWindow/GenerationalSlidingWindowAnalyzer.cs (modified) (3 diffs)
• SlidingWindow/OffspringSelectionSlidingWindowAnalyzer.cs (modified) (2 diffs)
• SlidingWindow/SlidingWindowAnalyzer.cs (modified) (4 diffs)
• SlidingWindow/SlidingWindowData.cs (modified) (4 diffs)
• SlidingWindow/SlidingWindowVisualizer.cs (added)

branches/Sliding Window GP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4.csproj

@@ -198 +198 @@
     <Compile Include="Interfaces\ISymbolicDataAnalysisExpressionTreeInterpreter.cs" />
     <Compile Include="Interfaces\ISymbolicDataAnalysisProblem.cs" />
+    <Compile Include="SlidingWindow\SlidingWindowVisualizer.cs" />
     <Compile Include="SymbolicDataAnalysisModel.cs">
       <SubType>Code</SubType>

branches/Sliding Window GP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SlidingWindow/GenerationalSlidingWindowAnalyzer.cs

@@ -30 +30 @@
   [Item("Generational Sliding Window GP Analyzer", "Analyzer which moves a sliding window every n-th generation over the training partition.")]
   [StorableClass]
-  public class GenerationalSlidingWindowAnalyzer<T> : SlidingWindowAnalyzer<T>, IIterationBasedOperator
-    where T : class, IDataAnalysisProblemData {
+  public class GenerationalSlidingWindowAnalyzer : SlidingWindowAnalyzer, IIterationBasedOperator {
     private const string GenerationsIntervalParameterName = "Generation Interval";
     private const string GenerationsIntervalStartParameterName = "Generation Interval Start";
@@ -64 +63 @@
     [StorableConstructor]
     protected GenerationalSlidingWindowAnalyzer(bool deserializing) : base(deserializing) { }
-    protected GenerationalSlidingWindowAnalyzer(GenerationalSlidingWindowAnalyzer<T> original, Cloner cloner) : base(original, cloner) { }
+    protected GenerationalSlidingWindowAnalyzer(GenerationalSlidingWindowAnalyzer original, Cloner cloner) : base(original, cloner) { }
     public override IDeepCloneable Clone(Cloner cloner) {
-      return new GenerationalSlidingWindowAnalyzer<T>(this, cloner);
+      return new GenerationalSlidingWindowAnalyzer(this, cloner);
     }
 
@@ -74 +73 @@
       Parameters.Add(new FixedValueParameter<IntValue>(GenerationsIntervalParameterName, "", new IntValue(5)));
       Parameters.Add(new FixedValueParameter<IntValue>(GenerationsIntervalStartParameterName, "", new IntValue(0)));
+
+      IterationsParameter.ActualName = "Generations";
+      MaximumIterationsParameter.Hidden = true;
     }
 

branches/Sliding Window GP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SlidingWindow/OffspringSelectionSlidingWindowAnalyzer.cs

@@ -29 +29 @@
   [Item("Offspring Selection Sliding Window GP Analyzer", "Analyzer which moves a sliding window whenever the selection pressure exceeds a certain threshold.")]
   [StorableClass]
-  public class OffspringSelectionSlidingWindowAnalyzer<T> : SlidingWindowAnalyzer<T>
-    where T : class, IDataAnalysisProblemData {
+  public class OffspringSelectionSlidingWindowAnalyzer : SlidingWindowAnalyzer {
     private const string SelectionPressureParameterName = "SelectionPressure";
     private const string SelectionPressureThresholdParameterName = "SelectionPressureThreshold";
@@ -52 +51 @@
     [StorableConstructor]
     protected OffspringSelectionSlidingWindowAnalyzer(bool deserializing) : base(deserializing) { }
-    protected OffspringSelectionSlidingWindowAnalyzer(OffspringSelectionSlidingWindowAnalyzer<T> original, Cloner cloner) : base(original, cloner) { }
+    protected OffspringSelectionSlidingWindowAnalyzer(OffspringSelectionSlidingWindowAnalyzer original, Cloner cloner) : base(original, cloner) { }
     public override IDeepCloneable Clone(Cloner cloner) {
-      return new OffspringSelectionSlidingWindowAnalyzer<T>(this, cloner);
+      return new OffspringSelectionSlidingWindowAnalyzer(this, cloner);
     }
 

branches/Sliding Window GP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SlidingWindow/SlidingWindowAnalyzer.cs

@@ -20 +20 @@
 #endregion
 
-using System;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
 using HeuristicLab.Data;
-using HeuristicLab.Operators;
-using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
@@ -32 +29 @@
   [StorableClass]
   [Item("Sliding Window GP Analyzer", "Base class for concrete sliding window GP analyzers.")]
-  public abstract class SlidingWindowAnalyzer<T> : SingleSuccessorOperator, IAnalyzer where T : class,IDataAnalysisProblemData {
+  public abstract class SlidingWindowAnalyzer : SymbolicDataAnalysisAnalyzer {
     private const string ProblemDataParameterName = "ProblemData";
-    private const string ResultCollectionParameterName = "Results";
     private const string FitnessCalculationPartitionParameterName = "FitnessCalculationPartition";
     private const string SlidingWindowSizeParameterName = "Sliding Window Size";
     private const string SlidingWindowStepWidthParameterName = "Sliding Window Step Width";
     private const string InitialSlidingWindowParameterName = "Initial Sliding Window";
-
-    private const string SlidingWindowDataResultName = "Sliding Window";
+    private const string TerminateSlidingWindowParameterName = "TerminateSlidingWindow";
 
     #region parameter properties
-    public IValueLookupParameter<T> ProblemDataParameter {
-      get { return (IValueLookupParameter<T>)Parameters[ProblemDataParameterName]; }
-    }
-    public ILookupParameter<ResultCollection> ResultCollectionParameter {
-      get { return (ILookupParameter<ResultCollection>)Parameters[ResultCollectionParameterName]; }
+    public IValueLookupParameter<IDataAnalysisProblemData> ProblemDataParameter {
+      get { return (IValueLookupParameter<IDataAnalysisProblemData>)Parameters[ProblemDataParameterName]; }
     }
     public ILookupParameter<IntRange> FitnessCalculationPartitionParameter {
       get { return (ILookupParameter<IntRange>)Parameters[FitnessCalculationPartitionParameterName]; }
     }
-
     public IFixedValueParameter<IntValue> SlidingWindowSizeParameter {
       get { return (IFixedValueParameter<IntValue>)Parameters[SlidingWindowSizeParameterName]; }
@@ -60 +51 @@
     }
     public IFixedValueParameter<IntRange> InitialSlidingWindowParameter {
-      get {
-        return (IFixedValueParameter<IntRange>)Parameters[InitialSlidingWindowParameterName];
-      }
+      get { return (IFixedValueParameter<IntRange>)Parameters[InitialSlidingWindowParameterName]; }
+    }
+    public ILookupParameter<BoolValue> TerminateSlidingWindowParameter {
+      get { return (ILookupParameter<BoolValue>)Parameters[TerminateSlidingWindowParameterName]; }
     }
     #endregion
 
     #region properties
-    public bool EnabledByDefault { get { return false; } }
+    public override bool EnabledByDefault { get { return false; } }
     public IntValue SlidingWindowSize { get { return SlidingWindowSizeParameter.Value; } }
     public IntValue SlidingWindowStepWidth { get { return SlidingWindowStepWidthParameter.Value; } }
@@ -76 +68 @@
     [StorableConstructor]
     protected SlidingWindowAnalyzer(bool deserializing) : base(deserializing) { }
-    protected SlidingWindowAnalyzer(SlidingWindowAnalyzer<T> original, Cloner cloner)
+    protected SlidingWindowAnalyzer(SlidingWindowAnalyzer original, Cloner cloner)
       : base(original, cloner) { }
 
-    protected SlidingWindowAnalyzer() {
-      Parameters.Add(new LookupParameter<ResultCollection>(ResultCollectionParameterName, "The result collection to store the analysis results."));
-      Parameters.Add(new ValueLookupParameter<T>(ProblemDataParameterName, "The problem data on which the symbolic data analysis solution should be evaluated."));
+    protected SlidingWindowAnalyzer()
+      : base() {
+      Parameters.Add(new ValueLookupParameter<IDataAnalysisProblemData>(ProblemDataParameterName, "The problem data on which the symbolic data analysis solution should be evaluated."));
       Parameters.Add(new LookupParameter<IntRange>(FitnessCalculationPartitionParameterName, ""));
       Parameters.Add(new FixedValueParameter<IntValue>(SlidingWindowSizeParameterName, "", new IntValue(1)));
       Parameters.Add(new FixedValueParameter<IntValue>(SlidingWindowStepWidthParameterName, "", new IntValue(1)));
       Parameters.Add(new FixedValueParameter<IntRange>(InitialSlidingWindowParameterName, "", new IntRange(0, 1)));
+      Parameters.Add(new LookupParameter<BoolValue>(TerminateSlidingWindowParameterName, ""));
 
-      FitnessCalculationPartitionParameter.ActualName = "Sliding Window";
+      ProblemDataParameter.Hidden = true;
     }
 
     public override IOperation Apply() {
+      //intialize sliding window
       if (FitnessCalculationPartitionParameter.ActualValue == null) {
+        TerminateSlidingWindowParameter.ActualValue = new BoolValue(false);
         FitnessCalculationPartitionParameter.ActualValue = (IntRange)InitialSlidingWindow.Clone();
-      } else if (CheckForUpdate()) {
-        var fitnessPartition = FitnessCalculationPartitionParameter.ActualValue;
-        if (fitnessPartition.End - fitnessPartition.Start == SlidingWindowSize.Value)
-          fitnessPartition.Start += SlidingWindowStepWidth.Value;
-
-        fitnessPartition.End += SlidingWindowStepWidth.Value;
-        if (fitnessPartition.End - fitnessPartition.Start > SlidingWindowSize.Value)
-          fitnessPartition.End = fitnessPartition.Start + SlidingWindowSize.Value;
-
-        //TODO check if fitnesspartition exceeds training partition
+        return base.Apply();
       }
 
-      //create and update result
-      var results = ResultCollectionParameter.ActualValue;
-      SlidingWindowData slidingWindowData;
-      if (!results.ContainsKey(SlidingWindowDataResultName)) {
-        string targetVariable;
-        var classificationProblemData = ProblemDataParameter.ActualValue as IClassificationProblemData;
-        var regressionProblemData = ProblemDataParameter.ActualValue as IRegressionProblemData;
-        if (classificationProblemData != null) targetVariable = classificationProblemData.TargetVariable;
-        else if (regressionProblemData != null) targetVariable = regressionProblemData.TargetVariable;
-        else throw new NotSupportedException();
+      if (!CheckForUpdate()) return base.Apply();
 
-        var targetData = ProblemDataParameter.ActualValue.Dataset.GetDoubleValues(targetVariable);
-        slidingWindowData = new SlidingWindowData(FitnessCalculationPartitionParameter.ActualValue, targetData);
-        results.Add(new Result(SlidingWindowDataResultName, slidingWindowData));
-      } else slidingWindowData = (SlidingWindowData)results[SlidingWindowDataResultName].Value;
+      //update necessary - move sliding window
+      var fitnessPartition = (IntRange)FitnessCalculationPartitionParameter.ActualValue.Clone();
+      if (fitnessPartition.End - fitnessPartition.Start == SlidingWindowSize.Value)
+        fitnessPartition.Start += SlidingWindowStepWidth.Value;
 
-      slidingWindowData.SlidingWindowPosition.Start = FitnessCalculationPartitionParameter.ActualValue.Start;
-      slidingWindowData.SlidingWindowPosition.End = FitnessCalculationPartitionParameter.ActualValue.End;
+      fitnessPartition.End += SlidingWindowStepWidth.Value;
+      if (fitnessPartition.End - fitnessPartition.Start > SlidingWindowSize.Value)
+        fitnessPartition.End = fitnessPartition.Start + SlidingWindowSize.Value;
+
+      //check if update should be performed or if the algorithm should stop
+      if (fitnessPartition.End > ProblemDataParameter.ActualValue.TrainingPartition.End)
+        TerminateSlidingWindowParameter.ActualValue.Value = true;
+      else {
+        FitnessCalculationPartitionParameter.ActualValue.Start = fitnessPartition.Start;
+        FitnessCalculationPartitionParameter.ActualValue.End = fitnessPartition.End;
+      }
 
       return base.Apply();
     }
 
-
     protected abstract bool CheckForUpdate();
   }

branches/Sliding Window GP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SlidingWindow/SlidingWindowData.cs

@@ -20 +20 @@
 #endregion
 
+using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -28 +29 @@
 
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
-  [Item("Sliding Window Position", "TODO")]
-  public class SlidingWindowData : Item {
+  [StorableClass]
+  [Item("Sliding Window Position", "")]
+  public sealed class SlidingWindowData : Item {
 
     [Storable]
@@ -43 +45 @@
     }
 
-    protected SlidingWindowData(bool deserializing) : base(deserializing) { }
-    protected SlidingWindowData(SlidingWindowData original, Cloner cloner)
+    [Storable]
+    private IEnumerable<double> estimatedValues;
+    public IEnumerable<double> EstimatedValues {
+      get { return estimatedValues; }
+      set {
+        if (value == null) throw new ArgumentNullException();
+        estimatedValues = value.ToArray();
+        OnEstimatedValuesChanged();
+      }
+    }
+
+    [StorableConstructor]
+    private SlidingWindowData(bool deserializing) : base(deserializing) { }
+    private SlidingWindowData(SlidingWindowData original, Cloner cloner)
       : base(original, cloner) {
       slidingWindowPosition = cloner.Clone(original.slidingWindowPosition);
@@ -58 +72 @@
       this.targetValues = targetValues.ToArray();
     }
+
+    public event EventHandler EstimatedValuesChanged;
+    private void OnEstimatedValuesChanged() {
+      var handler = EstimatedValuesChanged;
+      if (handler != null) EstimatedValuesChanged(this, EventArgs.Empty);
+    }
   }
 }