Changeset 2349

Timestamp:

09/14/09 12:59:50 (15 years ago)

Author:

gkronber

Message:

Created a subclass for time-series prognosis with SVM and created a simple version of TheilInequalityCoefficientEvaluator in HL.Modeling. (#705)

Location:

trunk/sources

Files:

• HeuristicLab.Modeling/3.2/HeuristicLab.Modeling-3.2.csproj (modified) (1 diff)
• HeuristicLab.Modeling/3.2/SimpleTheilInequalityCoefficientEvaluator.cs (copied) (copied from trunk/sources/HeuristicLab.GP.StructureIdentification.TimeSeries/3.3/TheilInequalityCoefficientEvaluator.cs) (3 diffs)
• HeuristicLab.SupportVectorMachines/3.2/HeuristicLab.SupportVectorMachines-3.2.csproj (modified) (1 diff)
• HeuristicLab.SupportVectorMachines/3.2/SVMHelper.cs (modified) (2 diffs)
• HeuristicLab.SupportVectorMachines/3.2/SupportVectorCreator.cs (modified) (2 diffs)
• HeuristicLab.SupportVectorMachines/3.2/SupportVectorEvaluator.cs (modified) (2 diffs)
• HeuristicLab.SupportVectorMachines/3.2/SupportVectorRegression.cs (modified) (12 diffs)
• HeuristicLab.SupportVectorMachines/3.2/TimeSeriesSupportVectorRegression.cs (added)

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

@@ -85 +85 @@
     <Compile Include="BestSolutionStorer.cs" />
     <Compile Include="ClassificationProblemInjector.cs" />
+    <Compile Include="SimpleTheilInequalityCoefficientEvaluator.cs" />
     <Compile Include="SolutionExtractor.cs" />
     <Compile Include="PredictorBase.cs" />

trunk/sources/HeuristicLab.Modeling/3.2/SimpleTheilInequalityCoefficientEvaluator.cs

@@ -25 +25 @@
 using HeuristicLab.DataAnalysis;
 
-namespace HeuristicLab.GP.StructureIdentification.TimeSeries {
-  public class TheilInequalityCoefficientEvaluator : GPEvaluatorBase {
+namespace HeuristicLab.Modeling {
+  public class SimpleTheilInequalityCoefficientEvaluator : SimpleEvaluatorBase {
     public override string Description {
       get {
-        return @"Evaluates 'FunctionTree' for all samples of 'Dataset' and calculates
-the 'Theil inequality coefficient (Theil's U2 not U1!)' of estimated values vs. real values of 'TargetVariable'.
+        return @"Calculates the Theil inequality coefficient (Theil's U2 not U1!) of estimated values vs. real values of 'TargetVariable'.
 
 U2 = Sqrt(1/N * Sum(P_t - A_t)^2 ) / Sqrt(1/N * Sum(A_t)^2 ) 
@@ -42 +41 @@
     }
 
-    public TheilInequalityCoefficientEvaluator()
-      : base() {
-      AddVariableInfo(new VariableInfo("TheilInequalityCoefficient", "Theil's inequality coefficient (U2) of the model", typeof(DoubleData), VariableKind.New));
-      AddVariableInfo(new VariableInfo("TheilInequalityCoefficientBias", "Bias proportion of Theil's inequality coefficient", typeof(DoubleData), VariableKind.New));
-      AddVariableInfo(new VariableInfo("TheilInequalityCoefficientVariance", "Variance proportion of Theil's inequality coefficient", typeof(DoubleData), VariableKind.New));
-      AddVariableInfo(new VariableInfo("TheilInequalityCoefficientCovariance", "Covariance proportion of Theil's inequality coefficient", typeof(DoubleData), VariableKind.New));
+    public override string OutputVariableName {
+      get {
+        return "TheilInequalityCoefficient";
+      }
     }
 
-    public override void Evaluate(IScope scope, ITreeEvaluator evaluator, Dataset dataset, int targetVariable, int start, int end, bool updateTargetValues) {
-      #region create result variables
-      DoubleData theilInequaliy = GetVariableValue<DoubleData>("TheilInequalityCoefficient", scope, false, false);
-      if (theilInequaliy == null) {
-        theilInequaliy = new DoubleData();
-        scope.AddVariable(new HeuristicLab.Core.Variable(scope.TranslateName("TheilInequalityCoefficient"), theilInequaliy));
-      }
-      DoubleData uBias = GetVariableValue<DoubleData>("TheilInequalityCoefficientBias", scope, false, false);
-      if (uBias == null) {
-        uBias = new DoubleData();
-        scope.AddVariable(new HeuristicLab.Core.Variable(scope.TranslateName("TheilInequalityCoefficientBias"), uBias));
-      }
-      DoubleData uVariance = GetVariableValue<DoubleData>("TheilInequalityCoefficientVariance", scope, false, false);
-      if (uVariance == null) {
-        uVariance = new DoubleData();
-        scope.AddVariable(new HeuristicLab.Core.Variable(scope.TranslateName("TheilInequalityCoefficientVariance"), uVariance));
-      }
-      DoubleData uCovariance = GetVariableValue<DoubleData>("TheilInequalityCoefficientCovariance", scope, false, false);
-      if (uCovariance == null) {
-        uCovariance = new DoubleData();
-        scope.AddVariable(new HeuristicLab.Core.Variable(scope.TranslateName("TheilInequalityCoefficientCovariance"), uCovariance));
-      }
-      #endregion
+    public override double Evaluate(double[,] values) {
+      return Calculate(values);
+    }
 
+    public static double Calculate(double[,] values) {
+      int n = values.GetLength(0);
       double errorsSquaredSum = 0.0;
       double originalSquaredSum = 0.0;
-      double[] estimatedChanges = new double[end - start];
-      double[] originalChanges = new double[end - start];
       int nSamples = 0;
-      for (int sample = start; sample < end; sample++) {
-        double prevValue = dataset.GetValue(sample - 1, targetVariable);
-        double estimatedChange = evaluator.Evaluate(sample) - prevValue;
-        double originalChange = dataset.GetValue(sample, targetVariable) - prevValue;
-        if (updateTargetValues) {
-          dataset.SetValue(sample, targetVariable, estimatedChange + prevValue);
-        }
+      for (int sample = 1; sample < n; sample++) {
+        double prevValue = values[sample - 1, 1];
+        double estimatedChange = values[sample, 0] - prevValue;
+        double originalChange = values[sample, 1] - prevValue;
         if (!double.IsNaN(originalChange) && !double.IsInfinity(originalChange)) {
           double error = estimatedChange - originalChange;
           errorsSquaredSum += error * error;
           originalSquaredSum += originalChange * originalChange;
-          estimatedChanges[sample - start] = estimatedChange;
-          originalChanges[sample - start] = originalChange;
           nSamples++;
         }
@@ -98 +70 @@
       if (double.IsNaN(quality) || double.IsInfinity(quality))
         quality = double.MaxValue;
-      theilInequaliy.Data = quality; // U2
-
-      // decomposition into U_bias + U_variance + U_covariance parts
-      double bias = Statistics.Mean(estimatedChanges) - Statistics.Mean(originalChanges);
-      bias *= bias; // squared
-      uBias.Data = bias / (errorsSquaredSum / nSamples);
-
-      double variance = Statistics.StandardDeviation(estimatedChanges) - Statistics.StandardDeviation(originalChanges);
-      variance *= variance; // squared
-      uVariance.Data = variance / (errorsSquaredSum / nSamples);
-
-      // all parts add up to one so I don't have to calculate the correlation coefficient for the covariance proportion
-      uCovariance.Data = 1.0 - uBias.Data - uVariance.Data;
+      return quality;
     }
   }

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

@@ -83 +83 @@
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="TimeSeriesSupportVectorRegression.cs" />
     <Compile Include="PredictorView.cs">
       <SubType>UserControl</SubType>

trunk/sources/HeuristicLab.SupportVectorMachines/3.2/SVMHelper.cs

@@ -24 +24 @@
       }
 
-      int maxColumns = (dataset.Columns - skippedFeatures.Count()) * (maxTimeOffset-minTimeOffset);
+      int maxColumns = (dataset.Columns - skippedFeatures.Count()) * (maxTimeOffset - minTimeOffset + 1);
 
       double[] targetVector = new double[rowCount];
@@ -42 +42 @@
           if (!skippedFeatures.Contains(col) && col != targetVariable && columnMapping.ContainsKey(col)) {
             for (int timeOffset = minTimeOffset; timeOffset <= maxTimeOffset; timeOffset++) {
-              int actualColumn = columnMapping[col] * (maxTimeOffset - minTimeOffset) + (timeOffset - maxTimeOffset) + 1;
+              int actualColumn = columnMapping[col] * (maxTimeOffset - minTimeOffset + 1) + (timeOffset - minTimeOffset);
               double value = dataset.GetValue(start + row + timeOffset, col);
               if (!double.IsNaN(value))

trunk/sources/HeuristicLab.SupportVectorMachines/3.2/SupportVectorCreator.cs

@@ -42 +42 @@
       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", "Maximal time offset for time-series prognosis", typeof(IntData), VariableKind.In));
-      AddVariableInfo(new VariableInfo("MinTimeOffset", "Minimal time offset for time-series prognosis", 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));
 
       //SVM parameters
@@ -71 +71 @@
       int start = GetVariableValue<IntData>("SamplesStart", scope, true).Data;
       int end = GetVariableValue<IntData>("SamplesEnd", scope, true).Data;
-      int maxTimeOffset = GetVariableValue<IntData>("MaxTimeOffset", scope, true).Data;
-      int minTimeOffset = GetVariableValue<IntData>("MinTimeOffset", scope, true).Data;
+      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;
       string svmType = GetVariableValue<StringData>("SVMType", scope, true).Data;
       string svmKernelType = GetVariableValue<StringData>("SVMKernelType", scope, true).Data;

trunk/sources/HeuristicLab.SupportVectorMachines/3.2/SupportVectorEvaluator.cs

@@ -38 +38 @@
       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", "Maximal allowed time offset for input variables", typeof(IntData), VariableKind.In));
-      AddVariableInfo(new VariableInfo("MinTimeOffset", "Minimal allowed time offset for input variables", typeof(IntData), VariableKind.In));
+      AddVariableInfo(new VariableInfo("MaxTimeOffset", "(optional) Maximal allowed time offset for input variables", typeof(IntData), VariableKind.In));
+      AddVariableInfo(new VariableInfo("MinTimeOffset", "(optional) Minimal allowed time offset for input variables", typeof(IntData), VariableKind.In));
       AddVariableInfo(new VariableInfo("SVMModel", "Represent the model learned by the SVM", typeof(SVMModel), VariableKind.In));
       AddVariableInfo(new VariableInfo("Values", "Target vs predicted values", typeof(DoubleMatrixData), VariableKind.New | VariableKind.Out));
@@ -50 +50 @@
       int start = GetVariableValue<IntData>("SamplesStart", scope, true).Data;
       int end = GetVariableValue<IntData>("SamplesEnd", scope, true).Data;
-      int minTimeOffset = GetVariableValue<IntData>("MinTimeOffset", scope, true).Data;
-      int maxTimeOffset = GetVariableValue<IntData>("MaxTimeOffset", scope, true).Data;
+      IntData minTimeOffsetData = GetVariableValue<IntData>("MinTimeOffset", scope, true, false);
+      int minTimeOffset = minTimeOffsetData == null ? 0 : minTimeOffsetData.Data;
+      IntData maxTimeOffsetData = GetVariableValue<IntData>("MaxTimeOffset", scope, true, false);
+      int maxTimeOffset = maxTimeOffsetData == null ? 0 : maxTimeOffsetData.Data;
       SVMModel modelData = GetVariableValue<SVMModel>("SVMModel", scope, true);
       SVM.Problem problem = SVMHelper.CreateSVMProblem(dataset, targetVariable, start, end, minTimeOffset, maxTimeOffset);

trunk/sources/HeuristicLab.SupportVectorMachines/3.2/SupportVectorRegression.cs

@@ -39 +39 @@
   public class SupportVectorRegression : ItemBase, IEditable, IAlgorithm {
 
-    public string Name { get { return "SupportVectorRegression"; } }
-    public string Description { get { return "TODO"; } }
+    public virtual string Name { get { return "SupportVectorRegression"; } }
+    public virtual string Description { get { return "TODO"; } }
 
     private SequentialEngine.SequentialEngine engine;
@@ -107 +107 @@
     }
 
-    public int MaxTimeOffset {
-      get { return GetVariableInjector().GetVariable("MaxTimeOffset").GetValue<IntData>().Data; }
-      set { GetVariableInjector().GetVariable("MaxTimeOffset").GetValue<IntData>().Data = value; }
-    }
-
-    public int MinTimeOffset {
-      get { return GetVariableInjector().GetVariable("MinTimeOffset").GetValue<IntData>().Data; }
-      set { GetVariableInjector().GetVariable("MinTimeOffset").GetValue<IntData>().Data = value; }
-    }
-
     public SupportVectorRegression() {
       engine = new SequentialEngine.SequentialEngine();
@@ -125 +115 @@
       MaxNuIndex = NuList.Data.Length;
       MaxGammaIndex = GammaList.Data.Length;
-      MaxTimeOffset = 0;
-      MinTimeOffset = 0;
     }
 
@@ -149 +137 @@
     }
 
-    private IOperator CreateInitialization() {
+    protected virtual IOperator CreateInitialization() {
       SequentialProcessor seq = new SequentialProcessor();
       seq.Name = "Initialization";
@@ -159 +147 @@
       seq.AddSubOperator(new RandomInjector());
 
-      //DatasetShuffler shuffler = new DatasetShuffler();
-      //shuffler.GetVariableInfo("ShuffleStart").ActualName = "TrainingSamplesStart";
-      //shuffler.GetVariableInfo("ShuffleEnd").ActualName = "TrainingSamplesEnd";
-      //seq.AddSubOperator(shuffler);
+      DatasetShuffler shuffler = new DatasetShuffler();
+      shuffler.GetVariableInfo("ShuffleStart").ActualName = "TrainingSamplesStart";
+      shuffler.GetVariableInfo("ShuffleEnd").ActualName = "TrainingSamplesEnd";
+      seq.AddSubOperator(shuffler);
       return seq;
     }
@@ -279 +267 @@
       modelProcessor.AddSubOperator(trainingEvaluator);
       modelProcessor.AddSubOperator(CreateEvaluator("Validation"));
-      modelProcessor.AddSubOperator(CreateEvaluator("Test"));
 
       DataCollector collector = new DataCollector();
@@ -307 +294 @@
     }
 
-    private IOperator CreateEvaluator(string p) {
+    protected virtual IOperator CreateEvaluator(string p) {
       CombinedOperator op = new CombinedOperator();
       op.Name = p + "Evaluator";
@@ -379 +366 @@
     }
 
-    private IOperator CreateGlobalInjector() {
+    protected virtual VariableInjector CreateGlobalInjector() {
       VariableInjector injector = new VariableInjector();
       injector.AddVariable(new HeuristicLab.Core.Variable("CostIndex", new IntData(0)));
@@ -407 +394 @@
       injector.AddVariable(new HeuristicLab.Core.Variable("Type", new StringData("NU_SVR")));
       injector.AddVariable(new HeuristicLab.Core.Variable("PunishmentFactor", new DoubleData(1000.0)));
-      injector.AddVariable(new HeuristicLab.Core.Variable("MaxTimeOffset", new IntData()));
-      injector.AddVariable(new HeuristicLab.Core.Variable("MinTimeOffset", new IntData()));
       return injector;
     }
 
-    private IOperator CreateModelAnalyser() {
+    protected virtual IOperator CreateModelAnalyser() {
       CombinedOperator modelAnalyser = new CombinedOperator();
       modelAnalyser.Name = "Model Analyzer";
       SequentialSubScopesProcessor seqSubScopeProc = new SequentialSubScopesProcessor();
       SequentialProcessor seqProc = new SequentialProcessor();
+
       PredictorBuilder predictorBuilder = new PredictorBuilder();
       predictorBuilder.GetVariableInfo("SVMModel").ActualName = "Model";
@@ -426 +412 @@
       qualImpactCalc.GetVariableInfo("SamplesEnd").ActualName = "ActualTrainingSamplesEnd";
 
+      seqProc.AddSubOperator(CreateEvaluator("Test"));
       seqProc.AddSubOperator(predictorBuilder);
       seqProc.AddSubOperator(evalImpactCalc);
@@ -436 +423 @@
 
 
-    protected internal virtual IAnalyzerModel CreateSVMModel(IScope bestModelScope) {
+    protected virtual IAnalyzerModel CreateSVMModel(IScope bestModelScope) {
       AnalyzerModel model = new AnalyzerModel();
       model.SetResult("TrainingMeanSquaredError", bestModelScope.GetVariableValue<DoubleData>("Quality", false).Data);
@@ -486 +473 @@
     }
 
-    private IOperator GetVariableInjector() {
+    protected IOperator GetVariableInjector() {
       return GetMainOperator().SubOperators[0].SubOperators[0];
     }
 
-    private IOperator GetMainOperator() {
+    protected IOperator GetMainOperator() {
       CombinedOperator svm = (CombinedOperator)Engine.OperatorGraph.InitialOperator;
       return svm.OperatorGraph.InitialOperator;