Changeset 8492 for branches/DatasetFeatureCorrelation/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/FeatureCorrelation.cs

Timestamp:

08/14/12 17:35:07 (12 years ago)

Author:

sforsten

Message:

#1292:

• added TimeframeFeatureCorrelationView

File:

• branches/DatasetFeatureCorrelation/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/FeatureCorrelation.cs (modified) (8 diffs)

branches/DatasetFeatureCorrelation/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/FeatureCorrelation.cs

@@ -98 +98 @@
     }
 
+    public void CalculateTimeframeElements(string calc, string partition, string variable, int frames) {
+      CalculateElements(problemData.Dataset, calc, partition, variable, frames);
+    }
+
     private void CalculateElements(Dataset dataset) {
       CalculateElements(dataset, CorrelationCalculators.First(), Partitions.First());
     }
 
-    private void CalculateElements(Dataset dataset, string calc, string partition) {
+    private void CalculateElements(Dataset dataset, string calc, string partition, string variable = null, int frames = 0) {
       if (bw == null || bw.IsBusy) {
         if (bw != null) {
@@ -110 +114 @@
         bw.WorkerReportsProgress = true;
         bw.WorkerSupportsCancellation = true;
-        bw.DoWork += new DoWorkEventHandler(bw_DoWork);
-        bw.ProgressChanged += new ProgressChangedEventHandler(bw_ProgressChanged);
-        bw.RunWorkerCompleted += new RunWorkerCompletedEventHandler(bw_RunWorkerCompleted);
-      }
-      bw.RunWorkerAsync(new BackgroundWorkerInfo { Dataset = dataset, Calculator = calc, Partition = partition });
+        bw.DoWork += new DoWorkEventHandler(BwDoWork);
+        bw.ProgressChanged += new ProgressChangedEventHandler(BwProgressChanged);
+        bw.RunWorkerCompleted += new RunWorkerCompletedEventHandler(BwRunWorkerCompleted);
+      }
+      bw.RunWorkerAsync(new BackgroundWorkerInfo { Dataset = dataset, Calculator = calc, Partition = partition, Variable = variable, Frames = frames });
       if (calc.Equals(PearsonsR) || calc.Equals(SpearmansRank)) {
         Maximum = 1.0;
@@ -127 +131 @@
     }
 
-    private void bw_DoWork(object sender, DoWorkEventArgs e) {
+    #region backgroundworker
+    private void BwDoWork(object sender, DoWorkEventArgs e) {
+      BackgroundWorkerInfo bwInfo = (BackgroundWorkerInfo)e.Argument;
+      if (bwInfo.Variable == null) {
+        BwCalculateCorrelation(sender, e);
+      } else {
+        BwCalculateTimeframeCorrelation(sender, e);
+      }
+    }
+
+    private void BwCalculateCorrelation(object sender, DoWorkEventArgs e) {
       BackgroundWorker worker = sender as BackgroundWorker;
 
@@ -139 +153 @@
       int length = doubleVariableNames.Count;
       double[,] elements = new double[length, length];
-
       double calculations = (Math.Pow(length, 2) + length) / 2;
 
@@ -151 +164 @@
           }
 
-          IEnumerable<double> var1 = dataset.GetDoubleValues(doubleVariableNames[i]);
-          IEnumerable<double> var2 = dataset.GetDoubleValues(doubleVariableNames[j]);
-          if (partition.Equals(TrainingSamples)) {
-            var1 = var1.Skip(problemData.TrainingPartition.Start).Take(problemData.TrainingPartition.End - problemData.TrainingPartition.Start);
-            var2 = var2.Skip(problemData.TrainingPartition.Start).Take(problemData.TrainingPartition.End - problemData.TrainingPartition.Start);
-          } else if (partition.Equals(TestSamples)) {
-            var1 = var1.Skip(problemData.TestPartition.Start).Take(problemData.TestPartition.End - problemData.TestPartition.Start);
-            var2 = var2.Skip(problemData.TestPartition.Start).Take(problemData.TestPartition.End - problemData.TestPartition.Start);
-          }
-
-          if (calc.Equals(HoeffdingsDependence)) {
-            elements[i, j] = HoeffdingsDependenceCalculator.Calculate(var1, var2, out error);
-          } else if (calc.Equals(SpearmansRank)) {
-            elements[i, j] = SpearmansRankCorrelationCoefficientCalculator.Calculate(var1, var2, out error);
-          } else if (calc.Equals(PearsonsRSquared)) {
-            elements[i, j] = OnlinePearsonsRSquaredCalculator.Calculate(var1, var2, out error);
-          } else {
-            elements[i, j] = OnlinePearsonsRSquaredCalculator.CalculateR(var1, var2, out error);
-          }
+          IEnumerable<double> var1 = GetRelevantValues(problemData, partition, doubleVariableNames[i]);
+          IEnumerable<double> var2 = GetRelevantValues(problemData, partition, doubleVariableNames[j]);
+
+          elements[i, j] = CalculateElementWithCalculator(calc, var1, var2, out error);
+
           elements[j, i] = elements[i, j];
           if (!error.Equals(OnlineCalculatorError.None)) {
@@ -181 +180 @@
     }
 
-    private void bw_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e) {
+    private void BwCalculateTimeframeCorrelation(object sender, DoWorkEventArgs e) {
+      BackgroundWorker worker = sender as BackgroundWorker;
+
+      BackgroundWorkerInfo bwInfo = (BackgroundWorkerInfo)e.Argument;
+      Dataset dataset = bwInfo.Dataset;
+      string partition = bwInfo.Partition;
+      string calc = bwInfo.Calculator;
+      string variable = bwInfo.Variable;
+      int frames = bwInfo.Frames;
+
+      IList<string> doubleVariableNames = dataset.DoubleVariables.ToList();
+      OnlineCalculatorError error;
+      int length = doubleVariableNames.Count;
+      double[,] elements = new double[length, frames + 1];
+      double calculations = (frames + 1) * length;
+
+      worker.ReportProgress(0);
+
+      for (int i = 0; i < length; i++) {
+        for (int j = 0; j <= frames; j++) {
+          if (worker.CancellationPending) {
+            e.Cancel = true;
+            return;
+          }
+
+          IEnumerable<double> var1 = GetRelevantValues(problemData, partition, variable);
+          IEnumerable<double> var2 = GetRelevantValues(problemData, partition, doubleVariableNames[i]);
+
+          var valuesInFrame = var1.Take(j);
+          var help = var1.Skip(j).ToList();
+          help.AddRange(valuesInFrame);
+          var1 = help;
+
+          elements[i, j] = CalculateElementWithCalculator(calc, var1, var2, out error);
+
+          if (!error.Equals(OnlineCalculatorError.None)) {
+            worker.ReportProgress(100);
+            throw new ArgumentException("Calculator returned " + error + Environment.NewLine + "Maybe try another calculator.");
+          }
+          worker.ReportProgress((int)((100.0 / calculations) * (i * (frames + 1) + j + 1)));
+        }
+      }
+      e.Result = elements;
+    }
+
+    private IEnumerable<double> GetRelevantValues(IDataAnalysisProblemData problemData, string partition, string variable) {
+      IEnumerable<double> var = problemData.Dataset.GetDoubleValues(variable);
+      if (partition.Equals(TrainingSamples)) {
+        var = var.Skip(problemData.TrainingPartition.Start).Take(problemData.TrainingPartition.End - problemData.TrainingPartition.Start);
+      } else if (partition.Equals(TestSamples)) {
+        var = var.Skip(problemData.TestPartition.Start).Take(problemData.TestPartition.End - problemData.TestPartition.Start);
+      }
+      return var;
+    }
+
+    private double CalculateElementWithCalculator(string calc, IEnumerable<double> var1, IEnumerable<double> var2, out OnlineCalculatorError error) {
+      if (calc.Equals(HoeffdingsDependence)) {
+        return HoeffdingsDependenceCalculator.Calculate(var1, var2, out error);
+      } else if (calc.Equals(SpearmansRank)) {
+        return SpearmansRankCorrelationCoefficientCalculator.Calculate(var1, var2, out error);
+      } else if (calc.Equals(PearsonsRSquared)) {
+        return OnlinePearsonsRSquaredCalculator.Calculate(var1, var2, out error);
+      } else {
+        return OnlinePearsonsRSquaredCalculator.CalculateR(var1, var2, out error);
+      }
+    }
+
+    private void BwRunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e) {
       BackgroundWorker worker = sender as BackgroundWorker;
       if (!e.Cancelled && !worker.CancellationPending) {
@@ -188 +254 @@
         } else {
           matrix = (double[,])e.Result;
-          OnReset();
-        }
-      }
-    }
+          OnCorrelationCalculationFinished();
+        }
+      }
+    }
+    #endregion
 
     #region events
+    public event EventHandler CorrelationCalculationFinished;
+    protected virtual void OnCorrelationCalculationFinished() {
+      EventHandler handler = CorrelationCalculationFinished;
+      if (handler != null)
+        handler(this, EventArgs.Empty);
+    }
+
     public delegate void ProgressCalculationHandler(object sender, ProgressChangedEventArgs e);
     public event ProgressCalculationHandler ProgressCalculation;
-    protected void bw_ProgressChanged(object sender, ProgressChangedEventArgs e) {
+    protected void BwProgressChanged(object sender, ProgressChangedEventArgs e) {
       BackgroundWorker worker = sender as BackgroundWorker;
       if (!worker.CancellationPending && ProgressCalculation != null) {
@@ -215 +289 @@
       public string Calculator { get; set; }
       public string Partition { get; set; }
+      public string Variable { get; set; }
+      public int Frames { get; set; }
     }
   }