Changeset 15867 for branches/2719_HeuristicLab.DatastreamAnalysis/HeuristicLab.DatastreamAnalysis/3.4

Timestamp:

03/27/18 17:34:41 (6 years ago)

Author:

jzenisek

Message:

#2719: added proxy ensemble model

Location:

branches/2719_HeuristicLab.DatastreamAnalysis/HeuristicLab.DatastreamAnalysis/3.4

Files:

• Datastream.cs (modified) (11 diffs)
• DatastreamAnalysisOptimizer.cs (modified) (14 diffs)
• HeuristicLab.DatastreamAnalysis.csproj (modified) (2 diffs)
• HeuristicLab.DatastreamAnalysis.csproj.user (modified) (1 diff)
• IProxyEnsembleModel.cs (added)
• Plugin.cs (modified) (1 diff)
• Properties/AssemblyInfo.cs (modified) (1 diff)
• ProxyEnsembleModel.cs (added)

branches/2719_HeuristicLab.DatastreamAnalysis/HeuristicLab.DatastreamAnalysis/3.4/Datastream.cs

@@ -39 +39 @@
 
     protected const string ProblemDataParameterName = "ProblemData";
+    protected const string DataSourceAddressParameterName = "DataSourceAdress";
     protected const string InitialSlidingWindowParameterName = "InitialSlidingWindowParameter";
     protected const string SlidingWindowSizeParameterName = "SlidingWindowSize";
@@ -45 +46 @@
     protected const string FitnessPartitionParameterName = "FitnessPartition";
     protected const string SlidingWindowSonarRatioParameterName = "SlidingWindowSonarRatio";
+    protected const string SlidingWindowEvaluationSchemeParameterName = "SlidingWindowEvaluationScheme";
 
     #region parameter properites
 
-    public IValueParameter<RegressionProblemData> ProblemDataParameter {
-      get { return (IValueParameter<RegressionProblemData>) Parameters[ProblemDataParameterName]; }  
-    }
-
-    public IValueParameter<IntRange> InitialSlidingWindowParameter {
-      get { return (IValueParameter<IntRange>) Parameters[InitialSlidingWindowParameterName]; }
-    }
-
-    public IValueParameter<IntValue> SlidingWindowSizeParameter {
-      get { return (IValueParameter<IntValue>) Parameters[SlidingWindowSizeParameterName]; }
-    }
-
-    public IValueParameter<IntValue> SlidingWindowStepWidthParameter {
-      get { return (IValueParameter<IntValue>) Parameters[SlidingWindowStepWidthParameterName]; }
-    }
-
-    public IValueParameter<IntValue> SlidingWindowMovementDelayParameter {
-      get { return (IValueParameter<IntValue>) Parameters[SlidingWindowMovementDelayParameterName]; }
-    }
-
-    public IValueParameter<DoubleValue> SlidingWindowSonarRatioParameter {
-      get { return (IValueParameter<DoubleValue>) Parameters[SlidingWindowSonarRatioParameterName]; }
+    public enum EvaluationScheme { none, equal, linear, quadratic, cubic, exponential }
+
+    public IValueParameter<RegressionProblemData> ProblemDataParameter
+    {
+      get { return (IValueParameter<RegressionProblemData>)Parameters[ProblemDataParameterName]; }
+    }
+
+    public IValueParameter<StringValue> DataSourceAddressParameter
+    {
+      get { return (IValueParameter<StringValue>)Parameters[DataSourceAddressParameterName]; }
+    }
+
+    public IValueParameter<IntRange> InitialSlidingWindowParameter
+    {
+      get { return (IValueParameter<IntRange>)Parameters[InitialSlidingWindowParameterName]; }
+    }
+
+    public IValueParameter<IntValue> SlidingWindowSizeParameter
+    {
+      get { return (IValueParameter<IntValue>)Parameters[SlidingWindowSizeParameterName]; }
+    }
+
+    public IValueParameter<IntValue> SlidingWindowStepWidthParameter
+    {
+      get { return (IValueParameter<IntValue>)Parameters[SlidingWindowStepWidthParameterName]; }
+    }
+
+    public IValueParameter<IntValue> SlidingWindowMovementDelayParameter
+    {
+      get { return (IValueParameter<IntValue>)Parameters[SlidingWindowMovementDelayParameterName]; }
+    }
+
+    public IValueParameter<DoubleValue> SlidingWindowSonarRatioParameter
+    {
+      get { return (IValueParameter<DoubleValue>)Parameters[SlidingWindowSonarRatioParameterName]; }
+    }
+
+    public IValueParameter<EnumValue<EvaluationScheme>> SlidingWindowEvaluationSchemeParameter
+    {
+      get
+      {
+        return (IValueParameter<EnumValue<EvaluationScheme>>)Parameters[SlidingWindowEvaluationSchemeParameterName];
+      }
     }
 
@@ -80 +103 @@
     #region properties
 
-    public RegressionProblemData ProblemData {
+    public RegressionProblemData ProblemData
+    {
       get { return ProblemDataParameter.Value; }
-      set {
-        if(value == null) throw new ArgumentNullException("ProblemData", "The provided value for problemData is null.");
+      set
+      {
+        if (value == null) throw new ArgumentNullException("ProblemData", "The provided value for problemData is null.");
         ProblemDataParameter.Value = value;
         //OnProblemDataChanged();
       }
     }
-    
-
-    public IntRange InitialSlidingWindow {
+
+    public StringValue DataSourceAddress
+    {
+      get { return DataSourceAddressParameter.Value; }
+      set { DataSourceAddressParameter.Value = value; }
+    }
+
+    public IntRange InitialSlidingWindow
+    {
       get { return InitialSlidingWindowParameter.Value; }
       set { InitialSlidingWindowParameter.Value = value; }
     }
 
-    public IntValue SlidingWindowSize {
+    public IntValue SlidingWindowSize
+    {
       get { return SlidingWindowSizeParameter.Value; }
       set { SlidingWindowSizeParameter.Value = value; }
     }
 
-    public IntValue SlidingWindowStepWidth {
+    public IntValue SlidingWindowStepWidth
+    {
       get { return SlidingWindowStepWidthParameter.Value; }
       set { SlidingWindowStepWidthParameter.Value = value; }
     }
 
-    public IntValue SlidingWindowMovementDelay {
+    public IntValue SlidingWindowMovementDelay
+    {
       get { return SlidingWindowMovementDelayParameter.Value; }
       set { SlidingWindowMovementDelayParameter.Value = value; }
     }
 
-    public DoubleValue SlidingWindowSonarRatio {
+    public DoubleValue SlidingWindowSonarRatio
+    {
       get { return SlidingWindowSonarRatioParameter.Value; }
       set { SlidingWindowSonarRatioParameter.Value = value; }
     }
 
+    public EnumValue<EvaluationScheme> SlidingWindowEvaluationScheme
+    {
+      get { return SlidingWindowEvaluationSchemeParameter.Value; }
+      set { SlidingWindowEvaluationSchemeParameter.Value = value; }
+    }
+
+
     #endregion
 
@@ -121 +163 @@
     public IntRange FitnessPartition { get; set; }
 
-    public bool UpdateAvailable {
-      get { return false; }
-    }
-
-    public bool SlidingWindowMovementPossible {
-      get {
+    public bool UpdateAvailable
+    {
+      get { return !String.IsNullOrWhiteSpace(DataSourceAddress.Value); }
+    }
+
+    public bool SlidingWindowMovementPossible
+    {
+      get
+      {
         return ProblemData != null && ProblemData.Dataset != null &&
                (
@@ -135 +180 @@
     }
 
-    public bool SlidingWindowEvaluationPossible {
-      get {
+    public bool SlidingWindowEvaluationPossible
+    {
+      get
+      {
         //return ProblemData != null && ProblemData.Dataset != null && ProblemData.Dataset.Rows > 0 && FitnessPartition.Size > 0;
         return FitnessPartition.Size > 0;
@@ -149 +196 @@
         FitnessPartition.Start += SlidingWindowStepWidth.Value;
         FitnessPartition.End += SlidingWindowStepWidth.Value;
-      } else { 
+      } else {
         FitnessPartition.End += SlidingWindowStepWidth.Value;
         FitnessPartition.Start += FitnessPartition.End - SlidingWindowSize.Value;
-      } 
+      }
 
       //if (FitnessPartition.Size > SlidingWindowSize.Value) {
@@ -191 +238 @@
     public Datastream() : base() {
       Parameters.Add(new ValueParameter<RegressionProblemData>(ProblemDataParameterName, "ProblemData for analysis with selected ensembles.", null));
+      Parameters.Add(new FixedValueParameter<StringValue>(DataSourceAddressParameterName, "Source address of data stream", new StringValue("")));
       Parameters.Add(new FixedValueParameter<IntRange>(InitialSlidingWindowParameterName, "Initial sliding window boundaries", new IntRange(0, 100)));
       Parameters.Add(new FixedValueParameter<IntValue>(SlidingWindowSizeParameterName, "Sliding window size", new IntValue(100)));
@@ -196 +244 @@
       Parameters.Add(new FixedValueParameter<IntValue>(SlidingWindowMovementDelayParameterName, "Sliding window movement delay interval (milliseconds)", new IntValue(0)));
       Parameters.Add(new FixedValueParameter<DoubleValue>(SlidingWindowSonarRatioParameterName, "Sliding window sonar ratio", new DoubleValue(0.25)));
+      Parameters.Add(new FixedValueParameter<EnumValue<EvaluationScheme>>(SlidingWindowEvaluationSchemeParameterName, "Sliding window evaluation scheme", new EnumValue<EvaluationScheme>(EvaluationScheme.none)));
       RegisterParameterEvents();
       InitializeState();
@@ -201 +250 @@
     #endregion
 
-    public void InitializeState(){
+    public void InitializeState() {
       if (ProblemData == null || ProblemData.Dataset == null || ProblemData.Dataset.Rows == 0) {
         FitnessPartition = new IntRange(0, 0);
@@ -216 +265 @@
         FitnessPartition = new IntRange(0, 0);
       } else {
-        if(FitnessPartition == null) FitnessPartition = (IntRange)InitialSlidingWindow.Clone();
+        if (FitnessPartition == null) FitnessPartition = (IntRange)InitialSlidingWindow.Clone();
         if (FitnessPartition.End > ProblemData.Dataset.Rows) {
           FitnessPartition.End = ProblemData.Dataset.Rows;
@@ -258 +307 @@
     // TODO
     public IEnumerable<IParameterizedItem> ExecutionContextItems { get; }
-    
+
   }
 }

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

@@ -74 +74 @@
     }
 
-    private double lastStateValue;
+    //private double lastStateValue;
     private double pR2Sum;
     private int detectionCount;
@@ -108 +108 @@
 
     [Storable]
-    private IItemList<RatedEnsembleModel> ensembles;
-
-    public IItemList<RatedEnsembleModel> Ensembles {
+    private IItemList<ProxyEnsembleModel> ensembles;
+
+    public IItemList<ProxyEnsembleModel> Ensembles {
       get { return ensembles; }
       set {
         if (value == null || value == ensembles)
           return;
-        if (!(value is IRatedEnsembleModel)) throw new ArgumentException("Invaid ensemble model type");
+        if (!(value is IProxyEnsembleModel)) throw new ArgumentException("Invaid ensemble model type");
         DeregisterEnsembleEvents();
         ensembles = value;
@@ -214 +214 @@
     protected void SetupResults() {
       evaluationCount = 0;
-      lastStateValue = 0.0;
+      //lastStateValue = 0.0;
       pR2Sum = 0.0;
       exclusivitySum = 0.0;
@@ -267 +267 @@
       log = new Log();
       results = new ResultCollection();
-      ensembles = new ItemList<RatedEnsembleModel>();
+      ensembles = new ItemList<ProxyEnsembleModel>();
       datastream = new Datastream();
       runsCounter = 0;
@@ -287 +287 @@
       log = cloner.Clone(original.log);
       results = cloner.Clone(original.results);
-      ensembles = (ItemList<RatedEnsembleModel>) original.Ensembles.Clone(cloner);
+      ensembles = (ItemList<ProxyEnsembleModel>) original.Ensembles.Clone(cloner);
       datastream = (Datastream) original.Datastream.Clone(cloner);
       runsCounter = original.runsCounter;
@@ -322 +322 @@
     }
 
-    public override void Start() {
+    public override void Start(CancellationToken cancellationToken) {
+      base.Start(cancellationToken);
       if (ensembles == null || datastream == null) return;
-      base.Start();
-      cancellationTokenSource = new CancellationTokenSource();
+
+      cancellationTokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
       stopPending = false;
 
@@ -450 +451 @@
         // play and evaluate initial window
         PlayDatastream();
-        lastStateValue = Datastream.ProblemData.Dataset.GetDoubleValue("h", replayedIndex);
+        //lastStateValue = Datastream.ProblemData.Dataset.GetDoubleValue("h", replayedIndex);
         if (Datastream.SlidingWindowEvaluationPossible) Evaluate();
         replayedIndex = Datastream.FitnessPartition.End;
@@ -490 +491 @@
       }
     }
-    
+
+    private void Smoothen(double[] estimatedValuesPerRow) {
+      if (Datastream.SlidingWindowEvaluationScheme.Value == Datastream.EvaluationScheme.equal) {
+        var avg = estimatedValuesPerRow.Average();
+        for (int i = 0; i < estimatedValuesPerRow.Length; i++) {
+          estimatedValuesPerRow[i] = avg;
+        }
+      }
+    }
+
     private void Evaluate() {
       evaluationCount++;
@@ -512 +522 @@
       var curDetectionCount = 0;
       var changeDetectionCount = 0;
-      double curStateValue = 0.0;
+      //double curStateValue = 0.0;
+
       foreach (var ensemble in Ensembles) {
 
         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
@@ -550 +561 @@
         int replayCount = estimatedValuesPerRow.Length - replayAmount;
 
+        Smoothen(estimatedValuesPerRow);
+
         for (int i = replayedIndex; i < Datastream.FitnessPartition.End; i++) {
           //ResultsTargets.Rows[ensemble.Name].Values.Add(averageEstimatedValue);
@@ -594 +607 @@
       }
 
-      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;
+      //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) {
@@ -621 +637 @@
       //}
 
-      lastStateValue = curStateValue;
+      //lastStateValue = curStateValue;
 
       // detection of state change
@@ -650 +666 @@
     private bool accDiscount = false;
 
-    private double CalulateEnsembleConfidenceCM1(RatedEnsembleModel ensemble, IEnumerable<double[]> estimatedValuesPerModelPerRow, IEnumerable<double> realValues) {
+    private double CalulateEnsembleConfidenceCM1(ProxyEnsembleModel ensemble, IEnumerable<double[]> estimatedValuesPerModelPerRow, IEnumerable<double> realValues) {
       int noModels = estimatedValuesPerModelPerRow.Count();
       int votes = 0;
@@ -717 +733 @@
 
     protected virtual void RegisterEnsembleEvents() {
-      ensembles.ItemsAdded += new CollectionItemsChangedEventHandler<IndexedItem<RatedEnsembleModel>>(Ensembles_ItemsChanged);
-      ensembles.ItemsMoved += new CollectionItemsChangedEventHandler<IndexedItem<RatedEnsembleModel>>(Ensembles_ItemsChanged);
-      ensembles.ItemsRemoved += new CollectionItemsChangedEventHandler<IndexedItem<RatedEnsembleModel>>(Ensembles_ItemsChanged);
-      ensembles.ItemsReplaced += new CollectionItemsChangedEventHandler<IndexedItem<RatedEnsembleModel>>(Ensembles_ItemsChanged);
-      ensembles.CollectionReset += new CollectionItemsChangedEventHandler<IndexedItem<RatedEnsembleModel>>(Ensembles_Reset);
+      ensembles.ItemsAdded += new CollectionItemsChangedEventHandler<IndexedItem<ProxyEnsembleModel>>(Ensembles_ItemsChanged);
+      ensembles.ItemsMoved += new CollectionItemsChangedEventHandler<IndexedItem<ProxyEnsembleModel>>(Ensembles_ItemsChanged);
+      ensembles.ItemsRemoved += new CollectionItemsChangedEventHandler<IndexedItem<ProxyEnsembleModel>>(Ensembles_ItemsChanged);
+      ensembles.ItemsReplaced += new CollectionItemsChangedEventHandler<IndexedItem<ProxyEnsembleModel>>(Ensembles_ItemsChanged);
+      ensembles.CollectionReset += new CollectionItemsChangedEventHandler<IndexedItem<ProxyEnsembleModel>>(Ensembles_Reset);
     }
 
     protected virtual void DeregisterEnsembleEvents() {
-      ensembles.ItemsAdded -= new CollectionItemsChangedEventHandler<IndexedItem<RatedEnsembleModel>>(Ensembles_ItemsChanged);
-      ensembles.ItemsMoved -= new CollectionItemsChangedEventHandler<IndexedItem<RatedEnsembleModel>>(Ensembles_ItemsChanged);
-      ensembles.ItemsRemoved -= new CollectionItemsChangedEventHandler<IndexedItem<RatedEnsembleModel>>(Ensembles_ItemsChanged);
-      ensembles.ItemsReplaced -= new CollectionItemsChangedEventHandler<IndexedItem<RatedEnsembleModel>>(Ensembles_ItemsChanged);
-      ensembles.CollectionReset -= new CollectionItemsChangedEventHandler<IndexedItem<RatedEnsembleModel>>(Ensembles_Reset);
+      ensembles.ItemsAdded -= new CollectionItemsChangedEventHandler<IndexedItem<ProxyEnsembleModel>>(Ensembles_ItemsChanged);
+      ensembles.ItemsMoved -= new CollectionItemsChangedEventHandler<IndexedItem<ProxyEnsembleModel>>(Ensembles_ItemsChanged);
+      ensembles.ItemsRemoved -= new CollectionItemsChangedEventHandler<IndexedItem<ProxyEnsembleModel>>(Ensembles_ItemsChanged);
+      ensembles.ItemsReplaced -= new CollectionItemsChangedEventHandler<IndexedItem<ProxyEnsembleModel>>(Ensembles_ItemsChanged);
+      ensembles.CollectionReset -= new CollectionItemsChangedEventHandler<IndexedItem<ProxyEnsembleModel>>(Ensembles_Reset);
     }
     #endregion

branches/2719_HeuristicLab.DatastreamAnalysis/HeuristicLab.DatastreamAnalysis/3.4/HeuristicLab.DatastreamAnalysis.csproj

@@ -18 +18 @@
     <DebugType>full</DebugType>
     <Optimize>false</Optimize>
-    <OutputPath>..\..\..\..\trunk\sources\bin\</OutputPath>
+    <OutputPath>..\..\..\..\trunk\bin\</OutputPath>
     <DefineConstants>DEBUG;TRACE</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
@@ -110 +110 @@
     <Compile Include="IAnalysisBase.cs" />
     <Compile Include="IDatastream.cs" />
-    <Compile Include="IRatedEnsembleModel.cs" />
+    <Compile Include="IProxyEnsembleModel.cs" />
     <Compile Include="Plugin.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
-    <Compile Include="RatedEnsembleModel.cs" />
+    <Compile Include="ProxyEnsembleModel.cs" />
   </ItemGroup>
   <ItemGroup>

branches/2719_HeuristicLab.DatastreamAnalysis/HeuristicLab.DatastreamAnalysis/3.4/HeuristicLab.DatastreamAnalysis.csproj.user

@@ -3 +3 @@
   <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|AnyCPU'">
     <StartAction>Program</StartAction>
-    <StartProgram>C:\dev\workspaces\hl-core\trunk\sources\bin\HeuristicLab 3.3.exe</StartProgram>
-    <StartArguments>/hidestarter /start:Optimizer</StartArguments>
+    <StartProgram>C:\dev\workspaces\hl-core\trunk\bin\HeuristicLab 3.3.exe</StartProgram>
+    <StartArguments>/start:Optimizer /hideStarter</StartArguments>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|AnyCPU'">

branches/2719_HeuristicLab.DatastreamAnalysis/HeuristicLab.DatastreamAnalysis/3.4/Plugin.cs

@@ -23 +23 @@
 
 namespace HeuristicLab.DatastreamAnalysis {
-  [Plugin("HeuristicLab.DatastreamAnalysis", "3.4.14.14710")]
+  [Plugin("HeuristicLab.DatastreamAnalysis", "3.4.14.15025")]
   [PluginFile("HeuristicLab.DatastreamAnalysis-3.4.dll", PluginFileType.Assembly)]
   [PluginDependency("HeuristicLab.Collections", "3.3")]

branches/2719_HeuristicLab.DatastreamAnalysis/HeuristicLab.DatastreamAnalysis/3.4/Properties/AssemblyInfo.cs

@@ -54 +54 @@
 // [assembly: AssemblyVersion("1.0.*")]
 [assembly: AssemblyVersion("3.4.0.0")]
-[assembly: AssemblyFileVersion("3.4.14.14710")]
+[assembly: AssemblyFileVersion("3.4.14.15025")]