Changeset 2360

Timestamp:

09/15/09 16:35:54 (15 years ago)

Author:

gkronber

Message:

Implemented #706 (Linear regression algorithm for time series).

Location:

trunk/sources/HeuristicLab.LinearRegression/3.2

Files:

• HeuristicLab.LinearRegression-3.2.csproj (modified) (1 diff)
• LinearRegression.cs (modified) (2 diffs)
• LinearRegressionOperator.cs (modified) (6 diffs)
• LinearTimeSeriesPrognosis.cs (copied) (copied from trunk/sources/HeuristicLab.LinearRegression/3.2/LinearClassification.cs) (1 diff)

trunk/sources/HeuristicLab.LinearRegression/3.2/HeuristicLab.LinearRegression-3.2.csproj

@@ -95 +95 @@
     <Compile Include="LinearRegression.cs" />
     <Compile Include="LinearRegressionOperator.cs" />
+    <Compile Include="LinearTimeSeriesPrognosis.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
   </ItemGroup>

trunk/sources/HeuristicLab.LinearRegression/3.2/LinearRegression.cs

@@ -60 +60 @@
       get {
         IOperator main = GetMainOperator();
-        return main.SubOperators[1];
+        return main.SubOperators[2];
       }
       set {
         IOperator main = GetMainOperator();
-        main.RemoveSubOperator(1);
-        main.AddSubOperator(value, 1);
+        main.RemoveSubOperator(2);
+        main.AddSubOperator(value, 2);
       }
     }
@@ -197 +197 @@
     }
 
+    protected virtual IOperator GetVariableInjector() {
+      return GetMainOperator().SubOperators[0];
+    }
+
     public override IView CreateView() {
       return engine.CreateView();

trunk/sources/HeuristicLab.LinearRegression/3.2/LinearRegressionOperator.cs

@@ -41 +41 @@
       AddVariableInfo(new VariableInfo("SamplesStart", "Start index of samples in dataset to evaluate", typeof(IntData), VariableKind.In));
       AddVariableInfo(new VariableInfo("SamplesEnd", "End index of samples in dataset to evaluate", typeof(IntData), VariableKind.In));
+      AddVariableInfo(new VariableInfo("MaxTimeOffset", "(optional) Maximal time offset for time-series prognosis", typeof(IntData), VariableKind.In));
+      AddVariableInfo(new VariableInfo("MinTimeOffset", "(optional) Minimal time offset for time-series prognosis", typeof(IntData), VariableKind.In));
       AddVariableInfo(new VariableInfo("LinearRegressionModel", "Formula that was calculated by linear regression", typeof(IGeneticProgrammingModel), VariableKind.Out | VariableKind.New));
     }
@@ -49 +51 @@
       int start = GetVariableValue<IntData>("SamplesStart", scope, true).Data;
       int end = GetVariableValue<IntData>("SamplesEnd", scope, true).Data;
-      List<int> allowedRows = CalculateAllowedRows(dataset, targetVariable, start, end);
+      IntData maxTimeOffsetData = GetVariableValue<IntData>("MaxTimeOffset", scope, true, false);
+      int maxTimeOffset = maxTimeOffsetData == null ? 0 : maxTimeOffsetData.Data;
+      IntData minTimeOffsetData = GetVariableValue<IntData>("MinTimeOffset", scope, true, false);
+      int minTimeOffset = minTimeOffsetData == null ? 0 : minTimeOffsetData.Data;
+
+      List<int> allowedRows = CalculateAllowedRows(dataset, targetVariable, start, end, minTimeOffset, maxTimeOffset);
       List<int> allowedColumns = CalculateAllowedColumns(dataset, targetVariable, start, end);
 
-      double[,] inputMatrix = PrepareInputMatrix(dataset, allowedColumns, allowedRows);
+      double[,] inputMatrix = PrepareInputMatrix(dataset, allowedColumns, allowedRows, minTimeOffset, maxTimeOffset);
       double[] targetVector = PrepareTargetVector(dataset, targetVariable, allowedRows);
       double[] coefficients = CalculateCoefficients(inputMatrix, targetVector);
-      IFunctionTree tree = CreateModel(coefficients, allowedColumns.Select(i => dataset.GetVariableName(i)).ToList());
+      IFunctionTree tree = CreateModel(coefficients, allowedColumns.Select(i => dataset.GetVariableName(i)).ToList(), minTimeOffset, maxTimeOffset);
 
       scope.AddVariable(new HeuristicLab.Core.Variable(scope.TranslateName("LinearRegressionModel"), new GeneticProgrammingModel(tree)));
@@ -61 +68 @@
     }
 
-    private IFunctionTree CreateModel(double[] coefficients, List<string> allowedVariables) {
+    private IFunctionTree CreateModel(double[] coefficients, List<string> allowedVariables, int minTimeOffset, int maxTimeOffset) {
       IFunctionTree root = new Addition().GetTreeNode();
       IFunctionTree actNode = root;
+      int timeOffsetRange = (maxTimeOffset - minTimeOffset + 1);
 
       Queue<IFunctionTree> nodes = new Queue<IFunctionTree>();
-      GP.StructureIdentification.Variable v;
-      for (int i = 0; i < coefficients.Length - 1; i++) {
-        var vNode = (VariableFunctionTree)new GP.StructureIdentification.Variable().GetTreeNode();
-        vNode.VariableName = allowedVariables[i];
-        vNode.Weight = coefficients[i];
-        vNode.SampleOffset = 0;
-        nodes.Enqueue(vNode);
+      for (int i = 0; i < allowedVariables.Count; i++) {
+        for (int timeOffset = minTimeOffset; timeOffset <= maxTimeOffset; timeOffset++) {
+          var vNode = (VariableFunctionTree)new GP.StructureIdentification.Variable().GetTreeNode();
+          vNode.VariableName = allowedVariables[i];
+          vNode.Weight = coefficients[(i * timeOffsetRange) + (timeOffset - minTimeOffset)];
+          vNode.SampleOffset = timeOffset;
+          nodes.Enqueue(vNode);
+        }
       }
       var cNode = (ConstantFunctionTree)new Constant().GetTreeNode();
@@ -101 +110 @@
 
     //returns list of valid row indexes (rows without NaN values)
-    private List<int> CalculateAllowedRows(Dataset dataset, int targetVariable, int start, int end) {
+    private List<int> CalculateAllowedRows(Dataset dataset, int targetVariable, int start, int end, int minTimeOffset, int maxTimeOffset) {
       List<int> allowedRows = new List<int>();
       bool add;
@@ -107 +116 @@
         add = true;
         for (int col = 0; col < dataset.Columns && add == true; col++) {
-          if (double.IsNaN(dataset.GetValue(row, col)) ||
-              double.IsNaN(dataset.GetValue(row, targetVariable)))
-            add = false;
+          for (int timeOffset = minTimeOffset; timeOffset <= maxTimeOffset; timeOffset++) {
+            if (
+              row + timeOffset < 0 ||
+              row + timeOffset > dataset.Rows ||
+              double.IsNaN(dataset.GetValue(row + timeOffset, col)) ||
+              double.IsNaN(dataset.GetValue(row + timeOffset, targetVariable))) {
+              add = false;
+            }
+          }
         }
         if (add)
@@ -130 +145 @@
     }
 
-    private double[,] PrepareInputMatrix(Dataset dataset, List<int> allowedColumns, List<int> allowedRows) {
+    private double[,] PrepareInputMatrix(Dataset dataset, List<int> allowedColumns, List<int> allowedRows, int minTimeOffset, int maxTimeOffset) {
       int rowCount = allowedRows.Count;
-      double[,] matrix = new double[rowCount, allowedColumns.Count + 1];
-      for (int col = 0; col < allowedColumns.Count; col++) {
-        for (int row = 0; row < allowedRows.Count; row++)
-          matrix[row, col] = dataset.GetValue(allowedRows[row], allowedColumns[col]);
-      }
+      int timeOffsetRange = (maxTimeOffset - minTimeOffset + 1);
+      double[,] matrix = new double[rowCount, (allowedColumns.Count * timeOffsetRange) + 1];
+      for (int row = 0; row < allowedRows.Count; row++)
+        for (int col = 0; col < allowedColumns.Count; col++) {
+          for (int timeOffset = minTimeOffset; timeOffset <= maxTimeOffset; timeOffset++)
+            matrix[row, (col * timeOffsetRange) + (timeOffset - minTimeOffset)] = dataset.GetValue(allowedRows[row] + timeOffset, allowedColumns[col]);
+        }
       //add constant 1.0 in last column
       for (int i = 0; i < rowCount; i++)
-        matrix[i, allowedColumns.Count] = constant;
+        matrix[i, allowedColumns.Count * timeOffsetRange] = constant;
       return matrix;
     }

trunk/sources/HeuristicLab.LinearRegression/3.2/LinearTimeSeriesPrognosis.cs

@@ -38 +38 @@
 
 namespace HeuristicLab.LinearRegression {
-  public class LinearClassification : LinearRegression, IClassificationAlgorithm {
+  public class LinearTimeSeriesPrognosis : LinearRegression, ITimeSeriesAlgorithm {
 
-    public override string Name { get { return "LinearClassification"; } }
+    public override string Name { get { return "LinearTimeSeriesPrognosis"; } }
+    public int MaxTimeOffset {
+      get { return GetVariableInjector().GetVariable("MaxTimeOffset").GetValue<IntData>().Data; }
+      set { GetVariableInjector().GetVariable("MaxTimeOffset").GetValue<IntData>().Data = value; }
+    }
 
-    public LinearClassification()
+    public int MinTimeOffset {
+      get { return GetVariableInjector().GetVariable("MinTimeOffset").GetValue<IntData>().Data; }
+      set { GetVariableInjector().GetVariable("MinTimeOffset").GetValue<IntData>().Data = value; }
+    }
+
+
+    public LinearTimeSeriesPrognosis()
       : base() {
+      MaxTimeOffset = -1;
+      MinTimeOffset = -1;
     }
 
     protected override IOperator CreateProblemInjector() {
-      return DefaultClassificationOperators.CreateProblemInjector();
+      return DefaultTimeSeriesOperators.CreateProblemInjector();
+    }
+
+    protected override VariableInjector CreateGlobalInjector() {
+      VariableInjector injector = base.CreateGlobalInjector();
+      injector.AddVariable(new HeuristicLab.Core.Variable("MinTimeOffset", new IntData()));
+      injector.AddVariable(new HeuristicLab.Core.Variable("MaxTimeOffset", new IntData()));
+      return injector;
     }
 
     protected override IOperator CreateModelAnalyzerOperator() {
-      return DefaultClassificationOperators.CreatePostProcessingOperator();
+      return DefaultTimeSeriesOperators.CreatePostProcessingOperator();
     }
 
     protected internal virtual IAnalyzerModel CreateLRModel(IScope bestModelScope) {
       var model = new AnalyzerModel();
-      DefaultClassificationOperators.PopulateAnalyzerModel(bestModelScope, model);
+      DefaultTimeSeriesOperators.PopulateAnalyzerModel(bestModelScope, model);
       return model;
     }