Index: /branches/HeuristicLab.DatastreamAnalysis/HeuristicLab.DatastreamAnalysis.Views/3.4/DataBarSetView.cs
===================================================================
--- /branches/HeuristicLab.DatastreamAnalysis/HeuristicLab.DatastreamAnalysis.Views/3.4/DataBarSetView.cs (revision 14709)
+++ /branches/HeuristicLab.DatastreamAnalysis/HeuristicLab.DatastreamAnalysis.Views/3.4/DataBarSetView.cs (revision 14710)
@@ -119,4 +119,5 @@
chart.Series.Clear();
+
Series series = chart.Series.Add(seriesName);
series.IsVisibleInLegend = false;
@@ -124,5 +125,11 @@
int i = 0;
foreach (var bar in Content.Bars) {
- series.Points.Add(new DataPoint(i, bar.Value) { AxisLabel = bar.Name, Color = bar.BarColor });
+ var dp = new DataPoint(i, bar.Value) {
+ AxisLabel = bar.Name,
+ ToolTip = bar.Name,
+ Color = bar.BarColor,
+ BorderWidth = 5
+ };
+ series.Points.Add(dp);
i++;
}
@@ -154,4 +161,5 @@
for (int i = 0; i < bars.Count; i++) {
chart.Series[seriesName].Points.ElementAt(i).SetValueY(bars[i].Value);
+ chart.Series[seriesName].Points.ElementAt(i).ToolTip = bars[i].Name + " = " + bars[i].Value;
}
@@ -163,16 +171,62 @@
}
+ public static Color DefaultColor = Color.FromArgb(65, 140, 240);
+ public static Color HighlightColor1 = Color.FromArgb(37, 105, 175);
+ public static Color HighlightColor2 = Color.FromArgb(247, 150, 70);
+ public static Color HighlightColor3 = Color.FromArgb(228, 108, 10);
+ //public static Color HighlightColor1 = Color.FromArgb(45, 120, 200);
+ //public static Color HighlightColor2 = Color.FromArgb(15, 90, 160);
+ //public static Color HighlightColor3 = Color.FromArgb(10, 60, 110);
private void CheckThresholds() {
var bars = Content.Bars.ToList();
+ var winner =
+ !bars.Any() ? -1 :
+ bars
+ .Select((value, index) => new {Value = value, Index = index})
+ .Aggregate((a, b) => ((a.Value.Value - a.Value.ThresholdUpperBound) > (b.Value.Value - b.Value.ThresholdUpperBound)) ? a : b)
+ .Index;
+
+ // color bars depending on the threshold boundaries they exceed
for (int i = 0; i < bars.Count; i++) {
var bar = bars[i];
- if (bar.Value > bar.Threshold) {
- chart.Series[seriesName].Points[i].Color = Color.Orange;
+ if (bar.Value > bar.ThresholdUpperBound) {
+ chart.Series[seriesName].Points[i].Color = HighlightColor2;
+ chart.Series[seriesName].Points[i].BorderColor = HighlightColor2;
+ } else if (bar.Value > bar.ThresholdLowerBound) {
+ chart.Series[seriesName].Points[i].Color = HighlightColor1;
+ chart.Series[seriesName].Points[i].BorderColor = HighlightColor1;
} else {
chart.Series[seriesName].Points[i].Color = bar.BarColor;
+ chart.Series[seriesName].Points[i].BorderColor = bar.BarColor;
}
}
- }
-
+
+ // color the winner's border
+ if (winner != -1 && bars[winner].Value > bars[winner].ThresholdUpperBound) {
+ chart.Series[seriesName].Points[winner].BorderColor = HighlightColor3;
+ }
+ }
+
+
+
+ private void AddThresholds() {
+ Series series = chart.Series.Add("Thresholds");
+ series.IsVisibleInLegend = false;
+ series.ChartType = SeriesChartType.ErrorBar;
+
+ int i = 0;
+ foreach (var bar in Content.Bars) {
+ string desc = string.Format("{0} - Threshold [{1},{2}]", bar.Name, bar.ThresholdLowerBound,bar.ThresholdUpperBound);
+ var threshold = new DataPoint(i, new[]
+ {(bar.ThresholdLowerBound + bar.ThresholdUpperBound)/2, bar.ThresholdLowerBound, bar.ThresholdUpperBound}) {
+ AxisLabel = desc,
+ ToolTip = desc,
+ Color = bar.ThresholdColor,
+ BorderWidth = 1
+ };
+ series.Points.Add(threshold);
+ i++;
+ }
+ }
private void AddThresholdsOld() {
Series series = chart.Series.Add("Thresholds");
@@ -183,10 +237,9 @@
foreach (var bar in Content.Bars) {
//series.Points.Add(new DataPoint(i, new [] { bar.Threshold, bar.Threshold + 0.05 }) { AxisLabel = bar.Name, Color = Color.Transparent, BorderWidth = 2, BorderColor = bar.ThresholdColor});
- series.Points.Add(new DataPoint(i, new[] { bar.Threshold, bar.Threshold + 0.05 }) { AxisLabel = bar.Name, Color = bar.ThresholdColor });
+ series.Points.Add(new DataPoint(i, new[] { bar.ThresholdLowerBound, bar.ThresholdUpperBound }) { AxisLabel = bar.Name, Color = bar.ThresholdColor });
i++;
}
}
-
- private void AddThresholds() {
+ private void AddThresholdsOld2() {
chart.Annotations.Clear();
@@ -202,5 +255,5 @@
annotation.AxisX = chart.ChartAreas[0].AxisX;
annotation.AxisY = chart.ChartAreas[0].AxisY;
- annotation.Y = bars[i].Threshold;
+ annotation.Y = bars[i].ThresholdLowerBound;
annotation.Alignment = ContentAlignment.MiddleCenter;
@@ -208,5 +261,5 @@
annotation.X = i - 0.4;
- annotation.Width = 52.0 / bars.Count;
+ annotation.Width = (46 - bars.Count) / bars.Count;
annotation.Name = bars[i].Name;
annotation.Tag = bars[i].Name;
Index: /branches/HeuristicLab.DatastreamAnalysis/HeuristicLab.DatastreamAnalysis.Views/3.4/DataBarSetView.resx
===================================================================
--- /branches/HeuristicLab.DatastreamAnalysis/HeuristicLab.DatastreamAnalysis.Views/3.4/DataBarSetView.resx (revision 14710)
+++ /branches/HeuristicLab.DatastreamAnalysis/HeuristicLab.DatastreamAnalysis.Views/3.4/DataBarSetView.resx (revision 14710)
@@ -0,0 +1,120 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ text/microsoft-resx
+
+
+ 2.0
+
+
+ System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089
+
+
+ System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089
+
+
Index: /branches/HeuristicLab.DatastreamAnalysis/HeuristicLab.DatastreamAnalysis.Views/3.4/DatastreamAnalysisOptimizerView.cs
===================================================================
--- /branches/HeuristicLab.DatastreamAnalysis/HeuristicLab.DatastreamAnalysis.Views/3.4/DatastreamAnalysisOptimizerView.cs (revision 14709)
+++ /branches/HeuristicLab.DatastreamAnalysis/HeuristicLab.DatastreamAnalysis.Views/3.4/DatastreamAnalysisOptimizerView.cs (revision 14710)
@@ -157,7 +157,7 @@
try {
var data = e.Data.GetData(HeuristicLab.Common.Constants.DragDropDataFormat);
- if (data is IRegressionEnsembleModel) {
- data = (IRegressionEnsembleModel) data;
- Content.Ensembles.Add((RegressionEnsembleModel) data);
+ if (data is IRatedEnsembleModel) {
+ data = (IRatedEnsembleModel) data;
+ Content.Ensembles.Add((RatedEnsembleModel) data);
}
}
@@ -175,5 +175,5 @@
var data = e.Data.GetData(HeuristicLab.Common.Constants.DragDropDataFormat);
- if (data is IRegressionEnsembleModel) {
+ if (data is IRatedEnsembleModel) {
if ((e.KeyState & 32) == 32) e.Effect = DragDropEffects.Link; // ALT key
else if ((e.KeyState & 4) == 4) e.Effect = DragDropEffects.Move; // SHIFT key
Index: /branches/HeuristicLab.DatastreamAnalysis/HeuristicLab.DatastreamAnalysis.Views/3.4/HeuristicLab.DatastreamAnalysis.Views.csproj
===================================================================
--- /branches/HeuristicLab.DatastreamAnalysis/HeuristicLab.DatastreamAnalysis.Views/3.4/HeuristicLab.DatastreamAnalysis.Views.csproj (revision 14709)
+++ /branches/HeuristicLab.DatastreamAnalysis/HeuristicLab.DatastreamAnalysis.Views/3.4/HeuristicLab.DatastreamAnalysis.Views.csproj (revision 14710)
@@ -111,4 +111,10 @@
DatastreamAnalysisOptimizerView.cs
+
+ Form
+
+
+ Form1.cs
+
@@ -142,4 +148,7 @@
DatastreamAnalysisOptimizerView.cs
+
+ Form1.cs
+
RegressionEnsembleModelView.cs
Index: /branches/HeuristicLab.DatastreamAnalysis/HeuristicLab.DatastreamAnalysis.Views/3.4/Plugin.cs
===================================================================
--- /branches/HeuristicLab.DatastreamAnalysis/HeuristicLab.DatastreamAnalysis.Views/3.4/Plugin.cs (revision 14709)
+++ /branches/HeuristicLab.DatastreamAnalysis/HeuristicLab.DatastreamAnalysis.Views/3.4/Plugin.cs (revision 14710)
@@ -23,5 +23,5 @@
namespace HeuristicLab.DatastreamAnalysis.Views {
- [Plugin("HeuristicLab.DatastreamAnalysis.Views", "3.4.14.14547")]
+ [Plugin("HeuristicLab.DatastreamAnalysis.Views", "3.4.14.14588")]
[PluginFile("HeuristicLab.DatastreamAnalysis.Views-3.4.dll", PluginFileType.Assembly)]
[PluginDependency("HeuristicLab.Collections", "3.3")]
Index: /branches/HeuristicLab.DatastreamAnalysis/HeuristicLab.DatastreamAnalysis.Views/3.4/Properties/AssemblyInfo.cs
===================================================================
--- /branches/HeuristicLab.DatastreamAnalysis/HeuristicLab.DatastreamAnalysis.Views/3.4/Properties/AssemblyInfo.cs (revision 14709)
+++ /branches/HeuristicLab.DatastreamAnalysis/HeuristicLab.DatastreamAnalysis.Views/3.4/Properties/AssemblyInfo.cs (revision 14710)
@@ -54,3 +54,3 @@
// [assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyVersion("3.4.0.0")]
-[assembly: AssemblyFileVersion("3.4.14.14547")]
+[assembly: AssemblyFileVersion("3.4.14.14588")]
Index: /branches/HeuristicLab.DatastreamAnalysis/HeuristicLab.DatastreamAnalysis.Views/3.4/RegressionEnsembleModelView.resx
===================================================================
--- /branches/HeuristicLab.DatastreamAnalysis/HeuristicLab.DatastreamAnalysis.Views/3.4/RegressionEnsembleModelView.resx (revision 14710)
+++ /branches/HeuristicLab.DatastreamAnalysis/HeuristicLab.DatastreamAnalysis.Views/3.4/RegressionEnsembleModelView.resx (revision 14710)
@@ -0,0 +1,129 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ text/microsoft-resx
+
+
+ 2.0
+
+
+ System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089
+
+
+ System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089
+
+
+ 17, 17
+
+
+ 17, 17
+
+
+ 140, 17
+
+
Index: /branches/HeuristicLab.DatastreamAnalysis/HeuristicLab.DatastreamAnalysis/3.4/DataBar.cs
===================================================================
--- /branches/HeuristicLab.DatastreamAnalysis/HeuristicLab.DatastreamAnalysis/3.4/DataBar.cs (revision 14709)
+++ /branches/HeuristicLab.DatastreamAnalysis/HeuristicLab.DatastreamAnalysis/3.4/DataBar.cs (revision 14710)
@@ -28,4 +28,5 @@
using HeuristicLab.Common;
using HeuristicLab.Core;
+using HeuristicLab.Data;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
@@ -38,4 +39,5 @@
public class DataBar : NamedItem, INotifyPropertyChanged {
private double value;
+ public static Color DefaultBarColor = Color.FromArgb(65, 140, 240);
public double Value {
@@ -50,9 +52,23 @@
}
- private double threshold;
+ private double thresholdLowerBound;
- public double Threshold {
- get { return threshold; }
+ public double ThresholdLowerBound {
+ get { return thresholdLowerBound; }
set {
+ if (this.value != value) {
+ this.value = value;
+ OnThresholdPropertyChanged("Threshold");
+ }
+ }
+ }
+
+ private double thresholdUpperBound;
+
+ public double ThresholdUpperBound
+ {
+ get { return thresholdUpperBound; }
+ set
+ {
if (this.value != value) {
this.value = value;
@@ -68,8 +84,14 @@
set { this.value = value; }
}
- [Storable(Name = "Threshold")]
- private double StorableThreshold {
- get { return threshold; }
- set { this.threshold = value; }
+ [Storable(Name = "ThresholdLowerBound")]
+ private double StorableThresholdLowerBound {
+ get { return thresholdLowerBound; }
+ set { this.thresholdLowerBound = value; }
+ }
+ [Storable(Name = "ThresholdUpperBound")]
+ private double StorableThresholdUpperBound
+ {
+ get { return thresholdUpperBound; }
+ set { this.thresholdUpperBound = value; }
}
#endregion
@@ -109,5 +131,5 @@
protected DataBar(DataBar original, Cloner cloner) : base(original, cloner) {
this.value = original.value;
- this.threshold = original.threshold;
+ this.thresholdLowerBound = original.thresholdLowerBound;
this.barColor = original.barColor;
this.thresholdColor = original.thresholdColor;
@@ -115,25 +137,26 @@
public DataBar() : this("DataBar") {
- barColor = Color.Empty;
- thresholdColor = Color.Red;
+ barColor = DefaultBarColor;
+ thresholdColor = Color.Black;
}
public DataBar(string name) : base(name) {
if (string.IsNullOrEmpty(name)) throw new ArgumentException("Name of a DataBar cannot be empty", name);
- barColor = Color.Empty;
- thresholdColor = Color.Red;
+ barColor = DefaultBarColor;
+ thresholdColor = Color.Black;
}
- public DataBar(string name, double threshold) : base(name) {
+ public DataBar(string name, double thresholdLowerBound, double thresholdUpperBound) : base(name) {
if (string.IsNullOrEmpty(name)) throw new ArgumentException("Name of a DataBar cannot be empty", name);
- this.threshold = threshold;
- barColor = Color.Empty;
- thresholdColor = Color.Red;
+ this.thresholdLowerBound = thresholdLowerBound;
+ this.thresholdUpperBound = thresholdUpperBound;
+ barColor = DefaultBarColor;
+ thresholdColor = Color.Black;
}
public DataBar(string name, string description) : base(name, description) {
if (string.IsNullOrEmpty(name)) throw new ArgumentException("Name of a DataBar cannot be empty", name);
- barColor = Color.Empty;
- thresholdColor = Color.Red;
+ barColor = DefaultBarColor;
+ thresholdColor = Color.Black;
}
Index: /branches/HeuristicLab.DatastreamAnalysis/HeuristicLab.DatastreamAnalysis/3.4/Datastream.cs
===================================================================
--- /branches/HeuristicLab.DatastreamAnalysis/HeuristicLab.DatastreamAnalysis/3.4/Datastream.cs (revision 14709)
+++ /branches/HeuristicLab.DatastreamAnalysis/HeuristicLab.DatastreamAnalysis/3.4/Datastream.cs (revision 14710)
@@ -42,6 +42,7 @@
protected const string SlidingWindowSizeParameterName = "SlidingWindowSize";
protected const string SlidingWindowStepWidthParameterName = "SlidingWindowStepWidth";
- protected const string SlidingWindowMovementIntervalParameterName = "SlidingWindowMovementInterval";
+ protected const string SlidingWindowMovementDelayParameterName = "SlidingWindowMovementDelay";
protected const string FitnessPartitionParameterName = "FitnessPartition";
+ protected const string SlidingWindowSonarRatioParameterName = "SlidingWindowSonarRatio";
#region parameter properites
@@ -63,6 +64,10 @@
}
- public IValueParameter SlidingWindowMovementIntervalParameter {
- get { return (IValueParameter) Parameters[SlidingWindowMovementIntervalParameterName]; }
+ public IValueParameter SlidingWindowMovementDelayParameter {
+ get { return (IValueParameter) Parameters[SlidingWindowMovementDelayParameterName]; }
+ }
+
+ public IValueParameter SlidingWindowSonarRatioParameter {
+ get { return (IValueParameter) Parameters[SlidingWindowSonarRatioParameterName]; }
}
@@ -78,5 +83,5 @@
get { return ProblemDataParameter.Value; }
set {
- if(value == null) throw new ArgumentNullException("problemData", "The provided value for the problemData is null.");
+ if(value == null) throw new ArgumentNullException("ProblemData", "The provided value for problemData is null.");
ProblemDataParameter.Value = value;
//OnProblemDataChanged();
@@ -100,7 +105,12 @@
}
- public IntValue SlidingWindowMovementInterval {
- get { return SlidingWindowMovementIntervalParameter.Value; }
- set { SlidingWindowMovementIntervalParameter.Value = value; }
+ public IntValue SlidingWindowMovementDelay {
+ get { return SlidingWindowMovementDelayParameter.Value; }
+ set { SlidingWindowMovementDelayParameter.Value = value; }
+ }
+
+ public DoubleValue SlidingWindowSonarRatio {
+ get { return SlidingWindowSonarRatioParameter.Value; }
+ set { SlidingWindowSonarRatioParameter.Value = value; }
}
@@ -181,8 +191,9 @@
public Datastream() : base() {
Parameters.Add(new ValueParameter(ProblemDataParameterName, "ProblemData for analysis with selected ensembles.", null));
- Parameters.Add(new FixedValueParameter(InitialSlidingWindowParameterName, "Initial sliding window boundaries", new IntRange(0, 20)));
- Parameters.Add(new FixedValueParameter(SlidingWindowSizeParameterName, "Sliding window size", new IntValue(20)));
+ Parameters.Add(new FixedValueParameter(InitialSlidingWindowParameterName, "Initial sliding window boundaries", new IntRange(0, 100)));
+ Parameters.Add(new FixedValueParameter(SlidingWindowSizeParameterName, "Sliding window size", new IntValue(100)));
Parameters.Add(new FixedValueParameter(SlidingWindowStepWidthParameterName, "Sliding window step width", new IntValue(1)));
- Parameters.Add(new FixedValueParameter(SlidingWindowMovementIntervalParameterName, "Sliding window movement interval (milliseconds)", new IntValue(500)));
+ Parameters.Add(new FixedValueParameter(SlidingWindowMovementDelayParameterName, "Sliding window movement delay interval (milliseconds)", new IntValue(0)));
+ Parameters.Add(new FixedValueParameter(SlidingWindowSonarRatioParameterName, "Sliding window sonar ratio", new DoubleValue(0.25)));
RegisterParameterEvents();
InitializeState();
Index: /branches/HeuristicLab.DatastreamAnalysis/HeuristicLab.DatastreamAnalysis/3.4/DatastreamAnalysisOptimizer.cs
===================================================================
--- /branches/HeuristicLab.DatastreamAnalysis/HeuristicLab.DatastreamAnalysis/3.4/DatastreamAnalysisOptimizer.cs (revision 14709)
+++ /branches/HeuristicLab.DatastreamAnalysis/HeuristicLab.DatastreamAnalysis/3.4/DatastreamAnalysisOptimizer.cs (revision 14710)
@@ -74,4 +74,11 @@
}
+ private double lastStateValue;
+ private double pR2Sum;
+ private int detectionCount;
+ private int evaluationCount;
+ private double exclusivitySum;
+ private double accuracySum;
+
private CancellationTokenSource cancellationTokenSource;
private bool stopPending;
@@ -100,14 +107,13 @@
}
-
[Storable]
- private IItemList ensembles;
-
- public IItemList Ensembles {
+ private IItemList ensembles;
+
+ public IItemList Ensembles {
get { return ensembles; }
set {
if (value == null || value == ensembles)
return;
- if(!(value is IRegressionEnsembleModel)) throw new ArgumentException("Invaid ensemble model type");
+ if (!(value is IRatedEnsembleModel)) throw new ArgumentException("Invaid ensemble model type");
DeregisterEnsembleEvents();
ensembles = value;
@@ -145,5 +151,9 @@
}
private DataTable ResultsQualities {
- get { return ((DataTable)Results["Qualities"].Value); }
+ get { return ((DataTable)Results["Qualities 1"].Value); }
+ }
+
+ private DataTable ResultsPeakQualities {
+ get { return ((DataTable) Results["Qualities 2"].Value); }
}
@@ -155,17 +165,71 @@
}
+ private DataTable ResultsStateDetection {
+ get { return ((DataTable) Results["State Detection"].Value);}
+ }
+
private const string ResultsTargetsReal = "Real";
- private DataBarSet ResultsQualitiesBars {
- get { return (DataBarSet) Results["Ensemble Comparison"].Value; }
- }
+ private DataBarSet ResultsSWQualitiesBars {
+ get { return (DataBarSet) Results["Ensemble Comparison [SW-Quality]"].Value; }
+ }
+
+ private DataBarSet ResultsSWVotingBars {
+ get { return (DataBarSet) Results["Ensemble Comparison [SW-Voting]"].Value; }
+ }
+
+ private DataBarSet ResultsSonarQualitiesBars {
+ get { return (DataBarSet)Results["Ensemble Comparison [Sonar-Quality]"].Value; }
+ }
+
+ private DataBarSet ResultsSWPeakQualitiesBars {
+ get { return (DataBarSet)Results["Ensemble Comparison [SW-PeakQuality]"].Value; }
+ }
+
+ private double ResultsMeanPR2 {
+ get { return ((DoubleValue) Results["Mean PR2"].Value).Value; }
+ set { ((DoubleValue)Results["Mean PR2"].Value).Value = value; }
+ }
+
+ private double ResultsDetectionAccuracy {
+ get { return ((DoubleValue)Results["Detection Accuracy"].Value).Value; }
+ set { ((DoubleValue)Results["Detection Accuracy"].Value).Value = value; }
+ }
+
+ private double ResultsDetectionExclusivity {
+ get { return ((DoubleValue)Results["Detection Exclusivity"].Value).Value; }
+ set { ((DoubleValue)Results["Detection Exclusivity"].Value).Value = value; }
+ }
+
+ //private int ResultsTrueDetectionCount {
+ // get { return ((IntValue)Results["True Detection Count"].Value).Value; }
+ // set { ((IntValue)Results["True Detection Count"].Value).Value = value; }
+ //}
+
+ //private int ResultsFalseDetectionCount {
+ // get { return ((IntValue)Results["False Detection Count"].Value).Value; }
+ // set { ((IntValue)Results["False Detection Count"].Value).Value = value; }
+ //}
protected void SetupResults() {
+ evaluationCount = 0;
+ lastStateValue = 0.0;
+ pR2Sum = 0.0;
+ exclusivitySum = 0.0;
+ accuracySum = 0.0;
+ detectionCount = 0;
Results.Clear();
-
Results.Add(new Result("Sliding Window Movements", new IntValue(0)));
- Results.Add(new Result("Qualities", new DataTable("Pearson R²")));
+ Results.Add(new Result("Qualities 1", new DataTable("Average Pearson R²")));
+ Results.Add(new Result("Qualities 2", new DataTable("Peak Pearson R²")));
Results.Add(new Result("Targets", new DataTable("Targets")));
- Results.Add(new Result("Ensemble Comparison", new DataBarSet("Ensemble Comparison")));
+ Results.Add(new Result("State Detection", new DataTable("State Detection")));
+ Results.Add(new Result("Ensemble Comparison [SW-Quality]", new DataBarSet("Ensemble Comparison [SW-Quality]")));
+ Results.Add(new Result("Ensemble Comparison [SW-Voting]", new DataBarSet("Ensemble Comparison [SW-Voting]")));
+ Results.Add(new Result("Ensemble Comparison [Sonar-Quality]", new DataBarSet("Ensemble Comparison [Sonar-Quality]")));
+ Results.Add(new Result("Ensemble Comparison [SW-PeakQuality]", new DataBarSet("Ensemble Comparison [SW-PeakQuality]")));
+ Results.Add(new Result("Mean PR2", new DoubleValue()));
+ Results.Add(new Result("Detection Accuracy", new DoubleValue()));
+ Results.Add(new Result("Detection Exclusivity", new DoubleValue()));
ResultsTargets.Rows.Add(new DataRow(ResultsTargetsReal));
@@ -174,10 +238,23 @@
ResultsTargets.Rows.Add(new DataRow(ensemble.Name));
+ ResultsStateDetection.Rows.Add(new DataRow(ensemble.Name));
+
// qualities (series)
//ResultsQualities.Rows.Add(new DataRow(ensemble.Name + " - " + ResultsQualitiesMSE));
- ResultsQualities.Rows.Add(new DataRow(ensemble.Name + " - " + ResultsQualitiesPR2));
+ ResultsQualities.Rows.Add(new DataRow(ensemble.Name));
+
+ ResultsPeakQualities.Rows.Add(new DataRow(ensemble.Name));
// qualities (bars)
- ResultsQualitiesBars.Bars.Add(new DataBar(ensemble.Name, 0.9));
+ ResultsSWQualitiesBars.Bars.Add(new DataBar(ensemble.Name, ensemble.QualityThreshold.Start, ensemble.QualityThreshold.End));
+
+ // voting (bars)
+ ResultsSWVotingBars.Bars.Add(new DataBar(ensemble.Name, ensemble.ConfidenceThreshold.Start, ensemble.ConfidenceThreshold.End));
+
+ // sonar quality (bars)
+ ResultsSonarQualitiesBars.Bars.Add(new DataBar(ensemble.Name, ensemble.QualityThreshold.Start, ensemble.QualityThreshold.End));
+
+ // quality peaks (bars)
+ ResultsSWPeakQualitiesBars.Bars.Add(new DataBar(ensemble.Name, ensemble.QualityThreshold.Start, ensemble.QualityThreshold.End));
}
}
@@ -190,5 +267,5 @@
log = new Log();
results = new ResultCollection();
- ensembles = new ItemList();
+ ensembles = new ItemList();
datastream = new Datastream();
runsCounter = 0;
@@ -210,5 +287,5 @@
log = cloner.Clone(original.log);
results = cloner.Clone(original.results);
- ensembles = (ItemList) original.Ensembles.Clone(cloner);
+ ensembles = (ItemList) original.Ensembles.Clone(cloner);
datastream = (Datastream) original.Datastream.Clone(cloner);
runsCounter = original.runsCounter;
@@ -373,5 +450,6 @@
// play and evaluate initial window
PlayDatastream();
- if(Datastream.SlidingWindowEvaluationPossible) Evaluate();
+ lastStateValue = Datastream.ProblemData.Dataset.GetDoubleValue("h", replayedIndex);
+ if (Datastream.SlidingWindowEvaluationPossible) Evaluate();
replayedIndex = Datastream.FitnessPartition.End;
@@ -381,5 +459,5 @@
// perform (delayed) window movement
- Thread.Sleep(Datastream.SlidingWindowMovementInterval.Value);
+ Thread.Sleep(Datastream.SlidingWindowMovementDelay.Value);
Datastream.MoveSlidingWindow();
ResultsSlidingWindowMovements++;
@@ -412,40 +490,180 @@
}
}
-
+
private void Evaluate() {
+ evaluationCount++;
var problemData = Datastream.ProblemData;
var dataset = problemData.Dataset;
var targetVarName = problemData.TargetVariable;
- var realRows = Enumerable.Range(Datastream.FitnessPartition.Start, Datastream.FitnessPartition.Size).ToList();
- var realValues = dataset.GetDoubleValues(targetVarName, realRows);
-
+ var rows = Enumerable.Range(Datastream.FitnessPartition.Start, Datastream.FitnessPartition.Size);
+ var realValues = dataset.GetDoubleValues(targetVarName, rows);
+
+ int sonarSize = (int)(Datastream.FitnessPartition.Size * Datastream.SlidingWindowSonarRatio.Value);
+ var sonarStart = Datastream.FitnessPartition.End - sonarSize;
+ var sonarRows = Enumerable.Range(sonarStart, sonarSize);
+ var sonarRealValues = dataset.GetDoubleValues(targetVarName, sonarRows);
+
+ var winningEnsembleName = ensembles[0].Name;
+ var winningEnsemblePR2 = 0.0;
+ var winningEnsembleIdx = 0;
+ var ec = 0;
+ bool stateChangeInStep = false;
+ var curDetectionCount = 0;
+ var changeDetectionCount = 0;
+ double curStateValue = 0.0;
foreach (var ensemble in Ensembles) {
- var rows = Enumerable.Range(Datastream.FitnessPartition.Start, Datastream.FitnessPartition.Size);
- var estimatedValuesPerModelPerRow = ensemble.Models.Select(x => x.GetEstimatedValues(datastream.ProblemData.Dataset, rows).ToArray());
- var estimatedValues = Enumerable.Range(0, Datastream.FitnessPartition.Size).Select(r => estimatedValuesPerModelPerRow.Select(e => e[r]).Average()).ToArray(); // per row
+ var sonarEstimatedValuesPerModelPerRow = ensemble.Model.Models.Select(x => x.GetEstimatedValues(datastream.ProblemData.Dataset, sonarRows).ToArray());
+ var sonarEstimatedValuesPerRow = Enumerable.Range(0, sonarSize).Select(r => sonarEstimatedValuesPerModelPerRow.Select(m => m[r]).Average()).ToArray();
+
+ var estimatedValuesPerModelPerRow = ensemble.Model.Models.Select(x => x.GetEstimatedValues(datastream.ProblemData.Dataset, rows).ToArray());
+ var estimatedValuesPerRow = Enumerable.Range(0, Datastream.FitnessPartition.Size).Select(r => estimatedValuesPerModelPerRow.Select(e => e[r]).Average()).ToArray(); // per row
var averageEstimatedValuesPerModel = estimatedValuesPerModelPerRow.Select(x => x.Average()); // per model
var averageEstimatedValue = averageEstimatedValuesPerModel.Average();
- // determine quality
- var mse = Math.Pow(averageEstimatedValue - realValues.Average(), 2);
+ // calulate quality
+ //var mse = Math.Pow(averageEstimatedValue - realValues.Average(), 2);
OnlineCalculatorError error;
- var pR = OnlinePearsonsRCalculator.Calculate(estimatedValues, realValues, out error);
+ var pR = OnlinePearsonsRCalculator.Calculate(estimatedValuesPerRow, realValues, out error);
var pR2 = error == OnlineCalculatorError.None ? pR * pR : 0.0;
+ var sonarPR = OnlinePearsonsRCalculator.Calculate(sonarEstimatedValuesPerRow, sonarRealValues, out error);
+ var sonarPR2 = error == OnlineCalculatorError.None ? sonarPR * sonarPR : 0.0;
+
+ var estimatedValuesPerModelPerRowArr = estimatedValuesPerModelPerRow.ToArray();
+ var curPR = 0.0;
+
+ var peakPR = OnlinePearsonsRCalculator.Calculate(estimatedValuesPerModelPerRowArr[0], realValues, out error);
+ for (int i = 1; i < estimatedValuesPerModelPerRow.Count(); i++) {
+ curPR = OnlinePearsonsRCalculator.Calculate(estimatedValuesPerModelPerRowArr[i], realValues, out error);
+ if (curPR > peakPR && error == OnlineCalculatorError.None) {
+ peakPR = curPR;
+ }
+ }
+ var peakPR2 = peakPR * peakPR;
+
+ // calculate confidence
+ var cm1 = CalulateEnsembleConfidenceCM1(ensemble, estimatedValuesPerModelPerRow, realValues);
+
int replayAmount = Datastream.FitnessPartition.End - replayedIndex;
- int replayCount = estimatedValues.Length - replayAmount;
+ int replayCount = estimatedValuesPerRow.Length - replayAmount;
for (int i = replayedIndex; i < Datastream.FitnessPartition.End; i++) {
//ResultsTargets.Rows[ensemble.Name].Values.Add(averageEstimatedValue);
- ResultsTargets.Rows[ensemble.Name].Values.Add(estimatedValues[replayCount]);
+ ResultsTargets.Rows[ensemble.Name].Values.Add(estimatedValuesPerRow[replayCount]);
replayCount++;
//ResultsQualities.Rows[ensemble.Name + " - " + ResultsQualitiesMSE].Values.Add(mse);
- ResultsQualities.Rows[ensemble.Name + " - " + ResultsQualitiesPR2].Values.Add(pR2);
- ResultsQualitiesBars.Bars[ensemble.Name].Value = pR2;
- }
- }
+ ResultsQualities.Rows[ensemble.Name].Values.Add(pR2);
+ ResultsPeakQualities.Rows[ensemble.Name].Values.Add(peakPR2);
+
+ double amp = (pR2 > ensemble.QualityThreshold.Start) ? 1.0 : 0.0;
+ ResultsStateDetection.Rows[ensemble.Name].Values.Add(amp);
+ }
+ ResultsSWQualitiesBars.Bars[ensemble.Name].Value = pR2;
+ ResultsSonarQualitiesBars.Bars[ensemble.Name].Value = sonarPR2;
+ ResultsSWVotingBars.Bars[ensemble.Name].Value = cm1;
+ ResultsSWPeakQualitiesBars.Bars[ensemble.Name].Value = peakPR2;
+
+ if (pR2 > ensemble.QualityThreshold.Start)
+ curDetectionCount++;
+
+ if (pR2 > winningEnsemblePR2) {
+ winningEnsemblePR2 = pR2;
+ winningEnsembleName = ensemble.Name;
+ winningEnsembleIdx = ec;
+ }
+ ec++;
+ }
+
+ // quality meassures
+ // =================================================
+
+ if (winningEnsemblePR2 > ensembles[winningEnsembleIdx].QualityThreshold.Start) {
+ // Mean PR2
+ pR2Sum += winningEnsemblePR2;
+ detectionCount++;
+ ResultsMeanPR2 = pR2Sum/detectionCount;
+
+ // detection exclusivity --> 1.0 - (x - 1) * (1.0 / n)
+ var fraction = 1.0 / ensembles.Count;
+ var curExclusivity = 1.0 - (curDetectionCount - 1) * fraction;
+ exclusivitySum += curExclusivity;
+ ResultsDetectionExclusivity = exclusivitySum / detectionCount;
+ }
+
+ double replCount = 0.0;
+ double accCount = 0.0;
+ for (int i = replayedIndex; i < Datastream.FitnessPartition.End; i++) {
+ replCount++;
+ curStateValue = problemData.Dataset.GetDoubleValue("h", i);
+ if (curStateValue <= 0.5 && winningEnsembleIdx == 0 && winningEnsemblePR2 > ensembles[winningEnsembleIdx].QualityThreshold.Start) {
+ accCount++;
+ } else if (curStateValue > 0.5 && winningEnsembleIdx == 1 && winningEnsemblePR2 > ensembles[winningEnsembleIdx].QualityThreshold.Start) {
+ accCount++;
+ }
+ }
+ accuracySum += accCount / replCount;
+ ResultsDetectionAccuracy = accuracySum / evaluationCount;
+
+ //if (accCount / replCount > 1.0) {
+ // Console.WriteLine();
+ //}
+
+ //if(accuracySum / evaluationCount > 1.0) {
+ // Console.WriteLine();
+ //}
+
+ //if (accCount < replCount && !accDiscount) accDiscount = true;
+ //if (accDiscount && accuracySum/evaluationCount >= 1.0) {
+ // Console.WriteLine();
+ //}
+
+ lastStateValue = curStateValue;
+
+ // detection of state change
+ //for (int i = replayedIndex; i < Datastream.FitnessPartition.End; i++) {
+ // curStateValue = problemData.Dataset.GetDoubleValue("h", i);
+ // if (lastStateValue > curStateValue || lastStateValue < curStateValue) {
+ // stateChangeInStep = true;
+ // changeDetectionCount++;
+ // }
+ //}
+ //lastStateValue = curStateValue;
+
+ // detection accuracy
+ //if (!stateChangeInStep && winningEnsemblePR2 > ensembles[winningEnsembleIdx].QualityThreshold.Start) {
+ // // (stable) state - detected
+ // accuracySum++;
+ //} else if(!stateChangeInStep && winningEnsemblePR2 < ensembles[winningEnsembleIdx].QualityThreshold.Start) {
+ // // (stable) state - not detected
+ // // no accuracy points (or penalty)
+ //} else if (stateChangeInStep && winningEnsemblePR2 < ensembles[winningEnsembleIdx].QualityThreshold.Start) {
+ // // change - detected
+ // accuracySum++;
+ //} else if (stateChangeInStep && winningEnsemblePR2 > ensembles[winningEnsembleIdx].QualityThreshold.Start) {
+ // // change - not detected
+ // // no accuracy points (or penalty)
+ //}
+ }
+ private bool accDiscount = false;
+
+ private double CalulateEnsembleConfidenceCM1(RatedEnsembleModel ensemble, IEnumerable estimatedValuesPerModelPerRow, IEnumerable realValues) {
+ int noModels = estimatedValuesPerModelPerRow.Count();
+ int votes = 0;
+
+ OnlineCalculatorError error;
+
+ foreach(var model in estimatedValuesPerModelPerRow) {
+ var pR = OnlinePearsonsRCalculator.Calculate(model, realValues, out error);
+ var pR2 = error == OnlineCalculatorError.None ? pR * pR : 0.0;
+ if (pR2 >= ensemble.QualityThreshold.End) {
+ votes++;
+ }
+ }
+
+
+ return (double)votes/noModels;
}
@@ -499,17 +717,17 @@
protected virtual void RegisterEnsembleEvents() {
- ensembles.ItemsAdded += new CollectionItemsChangedEventHandler>(Ensembles_ItemsChanged);
- ensembles.ItemsMoved += new CollectionItemsChangedEventHandler>(Ensembles_ItemsChanged);
- ensembles.ItemsRemoved += new CollectionItemsChangedEventHandler>(Ensembles_ItemsChanged);
- ensembles.ItemsReplaced += new CollectionItemsChangedEventHandler>(Ensembles_ItemsChanged);
- ensembles.CollectionReset += new CollectionItemsChangedEventHandler>(Ensembles_Reset);
+ ensembles.ItemsAdded += new CollectionItemsChangedEventHandler>(Ensembles_ItemsChanged);
+ ensembles.ItemsMoved += new CollectionItemsChangedEventHandler>(Ensembles_ItemsChanged);
+ ensembles.ItemsRemoved += new CollectionItemsChangedEventHandler>(Ensembles_ItemsChanged);
+ ensembles.ItemsReplaced += new CollectionItemsChangedEventHandler>(Ensembles_ItemsChanged);
+ ensembles.CollectionReset += new CollectionItemsChangedEventHandler>(Ensembles_Reset);
}
protected virtual void DeregisterEnsembleEvents() {
- ensembles.ItemsAdded -= new CollectionItemsChangedEventHandler>(Ensembles_ItemsChanged);
- ensembles.ItemsMoved -= new CollectionItemsChangedEventHandler>(Ensembles_ItemsChanged);
- ensembles.ItemsRemoved -= new CollectionItemsChangedEventHandler>(Ensembles_ItemsChanged);
- ensembles.ItemsReplaced -= new CollectionItemsChangedEventHandler>(Ensembles_ItemsChanged);
- ensembles.CollectionReset -= new CollectionItemsChangedEventHandler>(Ensembles_Reset);
+ ensembles.ItemsAdded -= new CollectionItemsChangedEventHandler>(Ensembles_ItemsChanged);
+ ensembles.ItemsMoved -= new CollectionItemsChangedEventHandler>(Ensembles_ItemsChanged);
+ ensembles.ItemsRemoved -= new CollectionItemsChangedEventHandler>(Ensembles_ItemsChanged);
+ ensembles.ItemsReplaced -= new CollectionItemsChangedEventHandler>(Ensembles_ItemsChanged);
+ ensembles.CollectionReset -= new CollectionItemsChangedEventHandler>(Ensembles_Reset);
}
#endregion
Index: /branches/HeuristicLab.DatastreamAnalysis/HeuristicLab.DatastreamAnalysis/3.4/HeuristicLab.DatastreamAnalysis.csproj
===================================================================
--- /branches/HeuristicLab.DatastreamAnalysis/HeuristicLab.DatastreamAnalysis/3.4/HeuristicLab.DatastreamAnalysis.csproj (revision 14709)
+++ /branches/HeuristicLab.DatastreamAnalysis/HeuristicLab.DatastreamAnalysis/3.4/HeuristicLab.DatastreamAnalysis.csproj (revision 14710)
@@ -110,6 +110,8 @@
+
+
Index: /branches/HeuristicLab.DatastreamAnalysis/HeuristicLab.DatastreamAnalysis/3.4/IRatedEnsembleModel.cs
===================================================================
--- /branches/HeuristicLab.DatastreamAnalysis/HeuristicLab.DatastreamAnalysis/3.4/IRatedEnsembleModel.cs (revision 14710)
+++ /branches/HeuristicLab.DatastreamAnalysis/HeuristicLab.DatastreamAnalysis/3.4/IRatedEnsembleModel.cs (revision 14710)
@@ -0,0 +1,14 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using HeuristicLab.Core;
+
+namespace HeuristicLab.DatastreamAnalysis {
+ public interface IRatedEnsembleModel : IParameterizedItem {
+ IEnumerable ExecutionContextItems { get; }
+ event EventHandler Reset;
+ event EventHandler ModelChanged;
+ }
+}
Index: /branches/HeuristicLab.DatastreamAnalysis/HeuristicLab.DatastreamAnalysis/3.4/Plugin.cs
===================================================================
--- /branches/HeuristicLab.DatastreamAnalysis/HeuristicLab.DatastreamAnalysis/3.4/Plugin.cs (revision 14709)
+++ /branches/HeuristicLab.DatastreamAnalysis/HeuristicLab.DatastreamAnalysis/3.4/Plugin.cs (revision 14710)
@@ -23,5 +23,5 @@
namespace HeuristicLab.DatastreamAnalysis {
- [Plugin("HeuristicLab.DatastreamAnalysis", "3.4.14.14547")]
+ [Plugin("HeuristicLab.DatastreamAnalysis", "3.4.14.14588")]
[PluginFile("HeuristicLab.DatastreamAnalysis-3.4.dll", PluginFileType.Assembly)]
[PluginDependency("HeuristicLab.Collections", "3.3")]
Index: /branches/HeuristicLab.DatastreamAnalysis/HeuristicLab.DatastreamAnalysis/3.4/Properties/AssemblyInfo.cs
===================================================================
--- /branches/HeuristicLab.DatastreamAnalysis/HeuristicLab.DatastreamAnalysis/3.4/Properties/AssemblyInfo.cs (revision 14709)
+++ /branches/HeuristicLab.DatastreamAnalysis/HeuristicLab.DatastreamAnalysis/3.4/Properties/AssemblyInfo.cs (revision 14710)
@@ -54,3 +54,3 @@
// [assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyVersion("3.4.0.0")]
-[assembly: AssemblyFileVersion("3.4.14.14547")]
+[assembly: AssemblyFileVersion("3.4.14.14588")]
Index: /branches/HeuristicLab.DatastreamAnalysis/HeuristicLab.DatastreamAnalysis/3.4/RatedEnsembleModel.cs
===================================================================
--- /branches/HeuristicLab.DatastreamAnalysis/HeuristicLab.DatastreamAnalysis/3.4/RatedEnsembleModel.cs (revision 14710)
+++ /branches/HeuristicLab.DatastreamAnalysis/HeuristicLab.DatastreamAnalysis/3.4/RatedEnsembleModel.cs (revision 14710)
@@ -0,0 +1,126 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see .
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Collections;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.DataAnalysis;
+namespace HeuristicLab.DatastreamAnalysis {
+ [StorableClass]
+ [Item("Rated Ensemble Model", "Represents a rated collection of models")]
+ [Creatable(CreatableAttribute.Categories.DataAnalysis)]
+ public class RatedEnsembleModel : ParameterizedNamedItem, IRatedEnsembleModel {
+ protected const string ModelParameterName = "Model";
+ protected const string QualityThresholdParameterName = "QualityThreshold";
+ protected const string ConfidenceThresholdParameterName = "ConfidenceThreshold";
+
+ #region parameter properties
+
+ public IValueParameter ModelParameter {
+ get { return (IValueParameter) Parameters[ModelParameterName]; }
+ }
+
+ public IValueParameter QualityThresholdParameter {
+ get { return (IValueParameter) Parameters[QualityThresholdParameterName]; }
+ }
+
+ public IValueParameter ConfidenceThresholdParameter {
+ get { return (IValueParameter)Parameters[ConfidenceThresholdParameterName]; }
+ }
+
+ public RegressionEnsembleModel Model {
+ get { return ModelParameter.Value; }
+ set {
+ if(value == null) throw new ArgumentNullException("Model", "The provided value for model is null.");
+ ModelParameter.Value = value;
+ }
+ }
+
+ public DoubleRange QualityThreshold {
+ get { return QualityThresholdParameter.Value; }
+ set { QualityThresholdParameter.Value = value; }
+ }
+
+ public DoubleRange ConfidenceThreshold {
+ get { return ConfidenceThresholdParameter.Value; }
+ set { ConfidenceThresholdParameter.Value = value; }
+ }
+
+ #endregion
+
+ #region constructors, clone ...
+ [StorableConstructor]
+ protected RatedEnsembleModel(bool deserializing) : base(deserializing) { }
+ protected RatedEnsembleModel(RatedEnsembleModel original, Cloner cloner) : base(original, cloner) {
+ RegisterParameterEvents();
+ }
+ public override IDeepCloneable Clone(Cloner cloner) {
+ return new RatedEnsembleModel(this, cloner);
+ }
+ public RatedEnsembleModel() : base() {
+ Parameters.Add(new ValueParameter(ModelParameterName, "Collection of models.", null));
+ Parameters.Add(new FixedValueParameter(QualityThresholdParameterName, "Quality threshold for the ensemble evaluation [0.0,1.0]", new DoubleRange(0.8,0.9)));
+ Parameters.Add(new FixedValueParameter(ConfidenceThresholdParameterName, "Confidence threshold for the ensemble evaluation [0.0,1.0]", new DoubleRange(0.8, 0.9)));
+ RegisterParameterEvents();
+ }
+ [StorableHook(HookType.AfterDeserialization)]
+ private void AfterDeserialization() {
+ RegisterParameterEvents();
+ }
+ #endregion
+
+ public event EventHandler Reset;
+ public event EventHandler ModelChanged;
+ public event EventHandler QualityThresholdChanged;
+ public event EventHandler ConfidenceThresholdChanged;
+
+ private void RegisterParameterEvents() {
+ ModelParameter.ValueChanged += new EventHandler(Model_ValueChanged);
+ QualityThresholdParameter.ValueChanged += new EventHandler(QualityTreshold_ValueChanged);
+ ConfidenceThresholdParameter.ValueChanged += new EventHandler(ConfidenceTreshold_ValueChanged);
+ }
+
+ private void Model_ValueChanged(object sender, EventArgs e) {
+ if (e == null) return;
+ DatastreamAnalysisUtil.RaiseEvent(this, ModelChanged);
+ }
+
+ private void QualityTreshold_ValueChanged(object sender, EventArgs e) {
+ if (e == null) return;
+ DatastreamAnalysisUtil.RaiseEvent(this, QualityThresholdChanged);
+ }
+
+ private void ConfidenceTreshold_ValueChanged(object sender, EventArgs e) {
+ if (e == null) return;
+ DatastreamAnalysisUtil.RaiseEvent(this, ConfidenceThresholdChanged);
+ }
+
+ // TODO
+ public IEnumerable ExecutionContextItems { get; }
+ }
+}
Index: /branches/HeuristicLab.DatastreamAnalysis/HeuristicLab.Problems.DataAnalysis/3.4/HeuristicLab.Problems.DataAnalysis-3.4.csproj
===================================================================
--- /branches/HeuristicLab.DatastreamAnalysis/HeuristicLab.Problems.DataAnalysis/3.4/HeuristicLab.Problems.DataAnalysis-3.4.csproj (revision 14709)
+++ /branches/HeuristicLab.DatastreamAnalysis/HeuristicLab.Problems.DataAnalysis/3.4/HeuristicLab.Problems.DataAnalysis-3.4.csproj (revision 14710)
@@ -173,4 +173,5 @@
+
Index: /branches/HeuristicLab.DatastreamAnalysis/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/RatedRegressionEnsembleModel.cs
===================================================================
--- /branches/HeuristicLab.DatastreamAnalysis/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/RatedRegressionEnsembleModel.cs (revision 14710)
+++ /branches/HeuristicLab.DatastreamAnalysis/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/RatedRegressionEnsembleModel.cs (revision 14710)
@@ -0,0 +1,260 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see .
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.DataAnalysis {
+ ///
+ /// Represents regression solutions that contain an ensemble of multiple regression models
+ ///
+ [StorableClass]
+ [Item("Rated Regression Ensemble Model", "A regression model that contains an ensemble of multiple regression models")]
+ [Creatable(CreatableAttribute.Categories.DataAnalysisEnsembles, Priority = 100)]
+ public sealed class RatedRegressionEnsembleModel : RegressionModel, IRegressionEnsembleModel {
+ public override IEnumerable VariablesUsedForPrediction {
+ get { return models.SelectMany(x => x.VariablesUsedForPrediction).Distinct().OrderBy(x => x); }
+ }
+
+ private List models;
+ public IEnumerable Models {
+ get { return new List(models); }
+ }
+
+ [Storable(Name = "Models")]
+ private IEnumerable StorableModels {
+ get { return models; }
+ set { models = value.ToList(); }
+ }
+
+ private List modelWeights;
+ public IEnumerable ModelWeights {
+ get { return modelWeights; }
+ }
+
+ [Storable(Name = "ModelWeights")]
+ private IEnumerable StorableModelWeights {
+ get { return modelWeights; }
+ set { modelWeights = value.ToList(); }
+ }
+
+ private DoubleRange qualityThreshold;
+ public DoubleRange QualityThreshold {
+ get { return qualityThreshold; }
+ set { qualityThreshold = value; }
+ }
+ [Storable(Name = "QualityThreshold")]
+ private DoubleRange StorableQualityThreshold {
+ get { return qualityThreshold; }
+ set { qualityThreshold = value; }
+ }
+
+ private DoubleRange confidenceThreshold;
+ public DoubleRange ConfidenceThreshold
+ {
+ get { return confidenceThreshold; }
+ set { confidenceThreshold = value; }
+ }
+ [Storable(Name = "QualityThreshold")]
+ private DoubleRange StorableConfidenceThreshold
+ {
+ get { return confidenceThreshold; }
+ set { confidenceThreshold = value; }
+ }
+
+ [Storable]
+ private bool averageModelEstimates = true;
+ public bool AverageModelEstimates {
+ get { return averageModelEstimates; }
+ set {
+ if (averageModelEstimates != value) {
+ averageModelEstimates = value;
+ OnChanged();
+ }
+ }
+ }
+
+ #region backwards compatiblity 3.3.5
+ [Storable(Name = "models", AllowOneWay = true)]
+ private List OldStorableModels {
+ set { models = value; }
+ }
+ #endregion
+
+ [StorableHook(HookType.AfterDeserialization)]
+ private void AfterDeserialization() {
+ // BackwardsCompatibility 3.3.14
+ #region Backwards compatible code, remove with 3.4
+ if (modelWeights == null || !modelWeights.Any())
+ modelWeights = new List(models.Select(m => 1.0));
+ #endregion
+ }
+
+ [StorableConstructor]
+ private RatedRegressionEnsembleModel(bool deserializing) : base(deserializing) { }
+ private RatedRegressionEnsembleModel(RatedRegressionEnsembleModel original, Cloner cloner)
+ : base(original, cloner) {
+ this.models = original.Models.Select(cloner.Clone).ToList();
+ this.modelWeights = new List(original.ModelWeights);
+ this.qualityThreshold = cloner.Clone(original.qualityThreshold);
+ this.confidenceThreshold = cloner.Clone(original.confidenceThreshold);
+ this.averageModelEstimates = original.averageModelEstimates;
+ }
+ public override IDeepCloneable Clone(Cloner cloner) {
+ return new RatedRegressionEnsembleModel(this, cloner);
+ }
+
+ public RatedRegressionEnsembleModel() : this(Enumerable.Empty()) { }
+ public RatedRegressionEnsembleModel(IEnumerable models) : this(models, models.Select(m => 1.0)) { }
+ public RatedRegressionEnsembleModel(IEnumerable models, IEnumerable modelWeights)
+ : base(string.Empty) {
+ this.name = ItemName;
+ this.description = ItemDescription;
+
+ this.models = new List(models);
+ this.modelWeights = new List(modelWeights);
+
+ if (this.models.Any()) this.TargetVariable = this.models.First().TargetVariable;
+ }
+
+ public void Add(IRegressionModel model) {
+ if (string.IsNullOrEmpty(TargetVariable)) TargetVariable = model.TargetVariable;
+ Add(model, 1.0);
+ }
+ public void Add(IRegressionModel model, double weight) {
+ if (string.IsNullOrEmpty(TargetVariable)) TargetVariable = model.TargetVariable;
+
+ models.Add(model);
+ modelWeights.Add(weight);
+ OnChanged();
+ }
+
+ public void AddRange(IEnumerable models) {
+ AddRange(models, models.Select(m => 1.0));
+ }
+ public void AddRange(IEnumerable models, IEnumerable weights) {
+ if (string.IsNullOrEmpty(TargetVariable)) TargetVariable = models.First().TargetVariable;
+
+ this.models.AddRange(models);
+ modelWeights.AddRange(weights);
+ OnChanged();
+ }
+
+ public void Remove(IRegressionModel model) {
+ var index = models.IndexOf(model);
+ models.RemoveAt(index);
+ modelWeights.RemoveAt(index);
+
+ if (!models.Any()) TargetVariable = string.Empty;
+ OnChanged();
+ }
+ public void RemoveRange(IEnumerable models) {
+ foreach (var model in models) {
+ var index = this.models.IndexOf(model);
+ this.models.RemoveAt(index);
+ modelWeights.RemoveAt(index);
+ }
+
+ if (!models.Any()) TargetVariable = string.Empty;
+ OnChanged();
+ }
+
+ public double GetModelWeight(IRegressionModel model) {
+ var index = models.IndexOf(model);
+ return modelWeights[index];
+ }
+ public void SetModelWeight(IRegressionModel model, double weight) {
+ var index = models.IndexOf(model);
+ modelWeights[index] = weight;
+ OnChanged();
+ }
+
+ #region evaluation
+ public IEnumerable> GetEstimatedValueVectors(IDataset dataset, IEnumerable rows) {
+ var estimatedValuesEnumerators = (from model in models
+ let weight = GetModelWeight(model)
+ select model.GetEstimatedValues(dataset, rows).Select(e => weight * e)
+ .GetEnumerator()).ToList();
+
+ while (estimatedValuesEnumerators.All(en => en.MoveNext())) {
+ yield return from enumerator in estimatedValuesEnumerators
+ select enumerator.Current;
+ }
+ }
+
+ public override IEnumerable GetEstimatedValues(IDataset dataset, IEnumerable rows) {
+ double weightsSum = modelWeights.Sum();
+ var summedEstimates = from estimatedValuesVector in GetEstimatedValueVectors(dataset, rows)
+ select estimatedValuesVector.DefaultIfEmpty(double.NaN).Sum();
+
+ if (AverageModelEstimates)
+ return summedEstimates.Select(v => v / weightsSum);
+ else
+ return summedEstimates;
+
+ }
+
+ public IEnumerable GetEstimatedValues(IDataset dataset, IEnumerable rows, Func modelSelectionPredicate) {
+ var estimatedValuesEnumerators = GetEstimatedValueVectors(dataset, rows).GetEnumerator();
+ var rowsEnumerator = rows.GetEnumerator();
+
+ while (rowsEnumerator.MoveNext() & estimatedValuesEnumerators.MoveNext()) {
+ var estimatedValueEnumerator = estimatedValuesEnumerators.Current.GetEnumerator();
+ int currentRow = rowsEnumerator.Current;
+ double weightsSum = 0.0;
+ double filteredEstimatesSum = 0.0;
+
+ for (int m = 0; m < models.Count; m++) {
+ estimatedValueEnumerator.MoveNext();
+ var model = models[m];
+ if (!modelSelectionPredicate(currentRow, model)) continue;
+
+ filteredEstimatesSum += estimatedValueEnumerator.Current;
+ weightsSum += modelWeights[m];
+ }
+
+ if (AverageModelEstimates)
+ yield return filteredEstimatesSum / weightsSum;
+ else
+ yield return filteredEstimatesSum;
+ }
+ }
+
+ #endregion
+
+ public event EventHandler Changed;
+ private void OnChanged() {
+ var handler = Changed;
+ if (handler != null)
+ handler(this, EventArgs.Empty);
+ }
+
+
+ public override IRegressionSolution CreateRegressionSolution(IRegressionProblemData problemData) {
+ return new RegressionEnsembleSolution(this, new RegressionEnsembleProblemData(problemData));
+ }
+ }
+}
Index: /branches/HeuristicLab.DatastreamAnalysis/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/RegressionEnsembleModel.cs
===================================================================
--- /branches/HeuristicLab.DatastreamAnalysis/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/RegressionEnsembleModel.cs (revision 14709)
+++ /branches/HeuristicLab.DatastreamAnalysis/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/RegressionEnsembleModel.cs (revision 14710)
@@ -33,5 +33,4 @@
[StorableClass]
[Item("Regression Ensemble Model", "A regression model that contains an ensemble of multiple regression models")]
- [Creatable(CreatableAttribute.Categories.DataAnalysisEnsembles, Priority = 100)]
public sealed class RegressionEnsembleModel : RegressionModel, IRegressionEnsembleModel {
public override IEnumerable VariablesUsedForPrediction {