Changeset 14538 for branches/HeuristicLab.DatastreamAnalysis/HeuristicLab.DatastreamAnalysis/3.4/DatastreamAnalysisOptimizer.cs

Timestamp:

01/03/17 23:04:56 (7 years ago)

Author:

jzenisek

Message:

#2719 enhanced the optimizer's functionality

File:

• branches/HeuristicLab.DatastreamAnalysis/HeuristicLab.DatastreamAnalysis/3.4/DatastreamAnalysisOptimizer.cs (modified) (16 diffs)

branches/HeuristicLab.DatastreamAnalysis/HeuristicLab.DatastreamAnalysis/3.4/DatastreamAnalysisOptimizer.cs

@@ -24 +24 @@
 using System;
 using System.Collections.Generic;
+using System.ComponentModel;
 using System.Diagnostics;
 using System.Drawing;
@@ -76 +77 @@
     private bool stopPending;
     private DateTime lastUpdateTime;
+    private bool prepared;
+    private bool finished;
 
     [Storable]
@@ -106 +109 @@
         if (value == null || value == ensembles)
           return;
-
+        if(!(value is IRegressionEnsembleModel)) throw new ArgumentException("Invaid ensemble model type");
+        DeregisterEnsembleEvents();
         ensembles = value;
+        RegisterEnsembleEvents();
+        OnEnsemblesChanged();
+        Prepare();
       }
     }
@@ -121 +128 @@
         if (value == null || value == datastream)
           return;
-
+        if(!(value is IDatastream)) throw new ArgumentException("Invalid datastream type");
+        DeregisterDatastreamEvents();
         datastream = value;
+        RegisterDatastreamEvents();
+        OnDatastreamChanged();
+        Prepare();
       }
     }
@@ -128 +139 @@
     #endregion properties
 
-    #region ResultsProperties
-    private double ResultsBestQuality
-    {
+    #region results properties
+    private int ResultsSlidingWindowMovements {
+      get { return ((IntValue)Results["Sliding Window Movements"].Value).Value; }
+      set { ((IntValue)Results["Sliding Window Movements"].Value).Value = value; }
+    }
+    private double ResultsBestQuality {
       get { return ((DoubleValue)Results["Best Quality"].Value).Value; }
       set { ((DoubleValue)Results["Best Quality"].Value).Value = value; }
     }
-    private DataTable ResultsQualities
-    {
+    private DataTable ResultsQualities {
       get { return ((DataTable)Results["Qualities"].Value); }
     }
+
+    private const string ResultsQualitiesR2 = "R²";
+    private const string ResultsQualitiesPearson = "Pearson";
+
+    private DataTable ResultsTargets {
+      get { return ((DataTable) Results["Targets"].Value); }
+    }
+
+    private const string ResultsTargetsReal = "Real";
+
+    protected void SetupResults() {
+      Results.Clear();
+
+      Results.Add(new Result("Sliding Window Movements", new IntValue(0)));
+      Results.Add(new Result("Best Quality", new DoubleValue(0)));
+      Results.Add(new Result("Qualities", new DataTable("Qualities")));
+      Results.Add(new Result("Targets", new DataTable("Targets")));
+
+      ResultsQualities.Rows.Add(new DataRow(ResultsQualitiesR2));
+      ResultsQualities.Rows.Add(new DataRow(ResultsQualitiesPearson));
+      ResultsTargets.Rows.Add(new DataRow(ResultsTargetsReal));
+      foreach (var ensemble in Ensembles) {
+        ResultsTargets.Rows.Add(new DataRow(ensemble.Name));
+      }
+    }
+
     #endregion
 
     #region constructors, cloner,...
 
-    public DatastreamAnalysisOptimizer() {
+    public DatastreamAnalysisOptimizer() : base() {
       name = "Datastream Analysis";
       log = new Log();
@@ -159 +198 @@
     [StorableHook(HookType.AfterDeserialization)]
     private void AfterDeserialization() {
-      // nothing to do in here
+      Initialize();
     }
 
@@ -179 +218 @@
     private void Initialize() {
       if (runs != null) RegisterRunsEvents();
+      if (datastream != null) RegisterDatastreamEvents();
+      if (ensembles != null) RegisterEnsembleEvents();
     }
     #endregion
@@ -185 +226 @@
 
     public override void Prepare() {
-      if (ensembles == null || datastream == null) return;
-      Prepare(true);
+      if (ensembles == null || ensembles.Count == 0 || datastream == null || !datastream.SlidingWindowEvaluationPossible) return;
+      //if (ensembles.SelectMany(x => x.Models).Count() == 0) return;
+      base.Prepare();
+      OnPrepared();
     }
 
     public void Prepare(bool clearRuns) {
-      if (ensembles == null || datastream == null) return;
+      if (ensembles == null || ensembles.Count == 0 || datastream == null || !datastream.SlidingWindowEvaluationPossible) return;
+
       base.Prepare();
-      if (clearRuns) results.Clear();
+      if (clearRuns) runs.Clear();
       OnPrepared();
     }
@@ -201 +245 @@
       cancellationTokenSource = new CancellationTokenSource();
       stopPending = false;
+
+      if (prepared) {
+        SetupResults();
+        //prepared = false;
+      }
 
       Task task = Task.Factory.StartNew(Run, cancellationTokenSource.Token, cancellationTokenSource.Token);
@@ -219 +268 @@
 
         // handle stop/pause
-        if(stopPending) { }
-        if(!Datastream.SlidingWindowMovementPossible) OnStopped();
-        else OnPaused();
+        if (stopPending || finished) {
+          OnStopped();
+        } else {
+          OnPaused();
+        }
+        //if(!Datastream.SlidingWindowMovementPossible) OnStopped();
+        //else OnPaused();
       });
 
@@ -244 +297 @@
 
     protected override void OnPrepared() {
+      ExecutionTime = TimeSpan.Zero;
+      foreach (IStatefulItem statefulItem in this.GetObjectGraphObjects(new HashSet<object>() {Runs}).OfType<IStatefulItem>()) {
+        statefulItem.InitializeState();
+      }
+      results.Clear();
+      prepared = true;
+      finished = false;
       Log.LogMessage("Datastream analysis prepared");
       base.OnPrepared();
@@ -259 +319 @@
 
     protected override void OnStopped() {
-      Log.LogMessage("Datastream analysis stopped");
-      base.OnStopped();
+      try {
+        runsCounter++;
+        var run = new Run();
+        run.Filename = Filename;
+        run.Name = string.Format("{0} Run {1}", Name, runsCounter);
+        CollectParameterValues(run.Parameters);
+        CollectResultValues(run.Results);
+        runs.Add(run);
+      }
+      finally {
+        Log.LogMessage("Datastream analysis stopped");
+        base.OnStopped();
+      }
     }
 
     #endregion
 
-
+    #region run
     private void Run(object state) {
       CancellationToken cancellationToken = (CancellationToken) state;
@@ -287 +358 @@
     }
 
+    private int replayedIndex;
+
     protected void Run(CancellationToken cancellationToken) {
-
-      // setup results
-      var slidingWindowMovements = new IntValue(0);
-      Results.Add(new Result("Sliding Window Movements", slidingWindowMovements));
-
-      var qtable = new DataTable("Qualities");
-      qtable.Rows.Add(new DataRow("R²"));
-      qtable.Rows.Add(new DataRow("Pearson"));
-      Results.Add(new Result("Qualities", qtable));
-
-      var curLoss = new DoubleValue();
-      Results.Add(new Result("R²", curLoss));
-      Results.Add(new Result("Best Quality", curLoss));
-
-
       // init algorithm
       var problemData = Datastream.ProblemData;
       var targetVarName = problemData.TargetVariable;
       var activeVariables = problemData.AllowedInputVariables;
+
+      if (prepared) {
+        // replay datastream until FitnessPartition.End
+        //for (int i = 0; i < Datastream.FitnessPartition.End; i++) {
+        //  var val = problemData.Dataset.GetDoubleValue(targetVarName, i);
+        //  ResultsTargets.Rows[ResultsTargetsReal].Values.Add(val);
+        //}
+        //replayedIndex = Datastream.FitnessPartition.End;
+        replayedIndex = 0;
+        prepared = false;
+      }
+
+
       Random rnd = new Random();
 
       try {
-        while (Datastream.SlidingWindowMovementPossible) {
-          cancellationToken.ThrowIfCancellationRequested();
-
-          Task.Delay(Datastream.SlidingWindowMovementInterval.Value);
-
-          Datastream.MoveSlidingWindow();
-
-          // TODO do the window evaluation
-
-          // TODO: collect results and display them
-
-          curLoss.Value = rnd.Next(100);
-          qtable.Rows["R²"].Values.Add(curLoss.Value);
-          qtable.Rows["Pearson"].Values.Add(curLoss.Value % 10);
-
-          slidingWindowMovements.Value++;
-        }
-
-        // TODO: collect runs (c.f. goal seeking)
+        do {
+          do {
+            cancellationToken.ThrowIfCancellationRequested();
+
+            Thread.Sleep(Datastream.SlidingWindowMovementInterval.Value);
+            Datastream.MoveSlidingWindow();
+
+            if (Datastream.SlidingWindowEvaluationPossible) {
+              foreach (var ensemble in Ensembles) {
+                // TODO do the window evaluation
+                double estimatedVal = problemData.Dataset.GetDoubleValue(targetVarName, replayedIndex)
+                                      * (1.0 + (((double)rnd.Next(0, 30)) / 100));
+                for (int i = replayedIndex; i < Datastream.FitnessPartition.End; i++) {
+                  ResultsTargets.Rows[ensemble.Name].Values.Add(estimatedVal);
+                }
+              }
+            }
+
+            // replay datastream until FitnessPartition.End
+            for (int i = replayedIndex; i < Datastream.FitnessPartition.End; i++) {
+              var val = problemData.Dataset.GetDoubleValue(targetVarName, i);
+              ResultsTargets.Rows[ResultsTargetsReal].Values.Add(val);
+            }
+            replayedIndex = Datastream.FitnessPartition.End;
+
+
+            // TODO: collect results and display them
+
+            int exp = rnd.Next(100);
+            ResultsQualities.Rows[ResultsQualitiesR2].Values.Add(exp);
+            ResultsQualities.Rows[ResultsQualitiesPearson].Values.Add((double)exp / 10);
+            ResultsSlidingWindowMovements++;
+            ResultsBestQuality = (double)exp / 42;
+
+          } while (Datastream.SlidingWindowMovementPossible);
+        } while (Datastream.UpdateAvailable);
+        finished = true;
       }
       catch (Exception ex) {
@@ -349 +438 @@
     }
 
+    public void CollectParameterValues(IDictionary<string, IItem> values) {
+      values.Add("Datastream Analysis Name", new StringValue(Name));
+      if (Datastream != null) {
+        Datastream.CollectParameterValues(values);
+        values.Add("Datastream Name", new StringValue(Datastream.Name));
+      }
+    }
+
     public void CollectResultValues(IDictionary<string, IItem> values) {
       values.Add("Execution Time", new TimeSpanValue(ExecutionTime));
       Results.CollectResultValues(values);
     }
+    #endregion
 
     #region events
+
+    #region events registration
 
     public EventHandler EnsemblesChanged;
@@ -367 +467 @@
     }
 
+    protected virtual void RegisterDatastreamEvents() {
+      datastream.Reset += new EventHandler(Datastream_Reset);
+      datastream.ProblemDataChanged += new EventHandler(Datastream_ProblemDataChanged);
+    }
+
+    protected virtual void DeregisterDatastreamEvents() {
+      datastream.Reset -= new EventHandler(Datastream_Reset);
+      datastream.ProblemDataChanged -= new EventHandler(Datastream_ProblemDataChanged);
+    }
+
+    protected virtual void RegisterEnsembleEvents() {
+      ensembles.ItemsAdded += new CollectionItemsChangedEventHandler<IndexedItem<RegressionEnsembleModel>>(Ensembles_ItemsChanged);
+      ensembles.ItemsMoved += new CollectionItemsChangedEventHandler<IndexedItem<RegressionEnsembleModel>>(Ensembles_ItemsChanged);
+      ensembles.ItemsRemoved += new CollectionItemsChangedEventHandler<IndexedItem<RegressionEnsembleModel>>(Ensembles_ItemsChanged);
+      ensembles.ItemsReplaced += new CollectionItemsChangedEventHandler<IndexedItem<RegressionEnsembleModel>>(Ensembles_ItemsChanged);
+      ensembles.CollectionReset += new CollectionItemsChangedEventHandler<IndexedItem<RegressionEnsembleModel>>(Ensembles_Reset);
+    }
+
+    protected virtual void DeregisterEnsembleEvents() {
+      ensembles.ItemsAdded -= new CollectionItemsChangedEventHandler<IndexedItem<RegressionEnsembleModel>>(Ensembles_ItemsChanged);
+      ensembles.ItemsMoved -= new CollectionItemsChangedEventHandler<IndexedItem<RegressionEnsembleModel>>(Ensembles_ItemsChanged);
+      ensembles.ItemsRemoved -= new CollectionItemsChangedEventHandler<IndexedItem<RegressionEnsembleModel>>(Ensembles_ItemsChanged);
+      ensembles.ItemsReplaced -= new CollectionItemsChangedEventHandler<IndexedItem<RegressionEnsembleModel>>(Ensembles_ItemsChanged);
+      ensembles.CollectionReset -= new CollectionItemsChangedEventHandler<IndexedItem<RegressionEnsembleModel>>(Ensembles_Reset);
+    }
+    #endregion
+
+    #region event handling
+
     protected virtual void Runs_CollectionReset(object sender, CollectionItemsChangedEventArgs<IRun> e) {
       runsCounter = runs.Count;
     }
 
-    #region event handling
+    protected virtual void Datastream_Reset(object sender, EventArgs e) {
+      Prepare();
+    }
+
+    protected virtual void Datastream_ProblemDataChanged(object sender, EventArgs e) {
+      Prepare();
+    }
+
+    protected virtual void Ensembles_Reset(object sender, EventArgs e) {
+      Prepare();
+    }
+
+    protected virtual void Ensembles_ItemsChanged(object sender, EventArgs e) {
+      Prepare();
+    }
 
     private void OnEnsemblesChanged() {
@@ -389 +532 @@
     #endregion
 
-    #region nameditem
-
-    [Storable] protected string name;
+    #region NamedItem
+
+    [Storable]
+    protected string name;
 
     /// <inheritdoc/>