Changeset 15847 for branches/2906_Transformations/HeuristicLab.Problems.DataAnalysis/3.4/Implementation

Timestamp:

03/19/18 17:46:57 (7 years ago)

Author:

pfleck

Message:

#2906 Implemented chained transformations on target and input variables.

Location:

branches/2906_Transformations/HeuristicLab.Problems.DataAnalysis/3.4/Implementation

Files:

• DataAnalysisProblemData.cs (modified) (1 diff)
• Regression/RegressionProblemData.cs (modified) (1 diff)
• Regression/TransformedRegressionModel.cs (modified) (4 diffs)
• Transformations/ExponentialTransformation.cs (added)
• Transformations/LinearTransformation.cs (added)
• Transformations/Transformation.cs (added)

branches/2906_Transformations/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/DataAnalysisProblemData.cs

@@ -241 +241 @@
       }
     }
+
+    public virtual IDataAnalysisProblemData InverseTransform() {
+      var newDataset = InverseTransform(Dataset, Transformations);
+
+      // TODO: Cannot create concrete instance here (maybe derived Create-method?)
+      var cloner = new Cloner();
+      cloner.RegisterClonedObject(Dataset, newDataset);
+      cloner.RegisterClonedObject(TransformationsParameter.Value, new ItemList<IDataAnalysisTransformation>().AsReadOnly());
+
+      return cloner.Clone(this);
+    }
+
+    public static IDataset Transform(IDataset dataset, IEnumerable<IDataAnalysisTransformation> transformations) {
+      var modifiableDataset = ((Dataset)dataset).ToModifiable();
+
+      foreach (var transformation in transformations) {
+        var trans = (ITransformation<double>)transformation.Transformation;
+
+        var originalData = modifiableDataset.GetDoubleValues(transformation.OriginalVariable);
+        if (!trans.Check(originalData, out string errorMessage))
+          throw new InvalidOperationException($"Cannot estimate Values, Transformation is invalid: {errorMessage}");
+
+        var transformedData = trans.Apply(originalData).ToList();
+        if (modifiableDataset.VariableNames.Contains(transformation.TransformedVariable))
+          modifiableDataset.ReplaceVariable(transformation.TransformedVariable, transformedData);
+        else
+          modifiableDataset.AddVariable(transformation.TransformedVariable, transformedData);
+      }
+
+      return modifiableDataset;
+    }
+
+    public static IDataset InverseTransform(IDataset dataset, IEnumerable<IDataAnalysisTransformation> transformations) {
+      var modifiableDataset = ((Dataset)dataset).ToModifiable();
+
+      foreach (var transformation in transformations.Reverse()) {
+        var trans = (ITransformation<double>)transformation.Transformation;
+
+        var transformedData = modifiableDataset.GetDoubleValues(transformation.TransformedVariable);
+
+        var originalData = trans.InverseApply(transformedData).ToList();
+        modifiableDataset.ReplaceVariable(transformation.OriginalVariable, originalData);
+      }
+
+      return modifiableDataset;
+    }
   }
 }

branches/2906_Transformations/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/RegressionProblemData.cs

@@ -180 +180 @@
       base.AdjustProblemDataProperties(problemData);
     }
+
+    public override IDataAnalysisProblemData InverseTransform() {
+      var transformedProblemData = (IRegressionProblemData)base.InverseTransform();
+      var targetVariable = GetOriginalTragetVariable(TargetVariable, Transformations);
+      transformedProblemData.TargetVariable = targetVariable;
+      return transformedProblemData;
+    }
+
+    public static string GetOriginalTragetVariable(string transformedTarget, IEnumerable<IDataAnalysisTransformation> transformations) {
+      var originalTarget = transformedTarget;
+      foreach (var transformation in transformations.Reverse()) {
+        if (transformation.TransformedVariable == originalTarget)
+          originalTarget = transformation.OriginalVariable;
+      }
+      return originalTarget;
+    }
   }
 }

branches/2906_Transformations/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/TransformedRegressionModel.cs

@@ -20 +20 @@
 #endregion
 
-using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -44 +43 @@
     #region Constructor, Cloning & Persistence
     public TransformedRegressionModel(IRegressionModel originalModel, IEnumerable<IDataAnalysisTransformation> transformations)
-      : base(GetOriginalTragetVariable(originalModel.TargetVariable, transformations)) {
+      : base(RegressionProblemData.GetOriginalTragetVariable(originalModel.TargetVariable, transformations)) {
+      Name = "Transformed " + originalModel.Name;
       OriginalModel = originalModel;
       Transformations = new ItemList<IDataAnalysisTransformation>(transformations);
@@ -64 +64 @@
     #endregion
 
+    // dataset in original data range
     public override IEnumerable<double> GetEstimatedValues(IDataset dataset, IEnumerable<int> rows) {
       var transformedDataset = TransformInputs(dataset, Transformations);
@@ -69 +70 @@
       var estimates = OriginalModel.GetEstimatedValues(transformedDataset, rows);
 
-      return TransformEstimates(estimates, Transformations, OriginalModel.TargetVariable);
+      return InverseTransformEstimates(estimates, Transformations, OriginalModel.TargetVariable);
     }
 
+    // problemData in original data range
     public override IRegressionSolution CreateRegressionSolution(IRegressionProblemData problemData) {
-      return new TransformedRegressionSolution(this, new RegressionProblemData(problemData) { TargetVariable = GetOriginalTragetVariable(TargetVariable, Transformations) });
+      return new TransformedRegressionSolution(this, new RegressionProblemData(problemData));
     }
 
     private static IDataset TransformInputs(IDataset dataset, IEnumerable<IDataAnalysisTransformation> transformations) {
-      return dataset;
+      return DataAnalysisProblemData.Transform(dataset, transformations);
+    }
 
-      var modifiableDataset = ((Dataset)dataset).ToModifiable();
+    private static IEnumerable<double> InverseTransformEstimates(IEnumerable<double> data, IEnumerable<IDataAnalysisTransformation> transformations, string targetVariable) {
+      var estimates = data.ToList();
 
       foreach (var transformation in transformations.Reverse()) {
-        var trans = (ITransformation<double>)transformation.Transformation;
+        if (transformation.TransformedVariable == targetVariable) {
+          var trans = (ITransformation<double>)transformation.Transformation;
 
-        // no transformations on target (but what if target is an input?)
+          estimates = trans.InverseApply(estimates).ToList();
 
-        var originalData = modifiableDataset.GetDoubleValues(transformation.OriginalVariable);
-        if (!trans.Check(originalData, out string errorMessage))
-          throw new InvalidOperationException($"Cannot estimate Values, Transformation is invalid: {errorMessage}");
-        var transformedData = trans.Apply(originalData).ToList();
-
-        if (modifiableDataset.VariableNames.Contains(transformation.TransformedVariable))
-          modifiableDataset.ReplaceVariable(transformation.TransformedVariable, transformedData);
-        else
-          modifiableDataset.AddVariable(transformation.TransformedVariable, transformedData);
+          // setup next iteration
+          targetVariable = transformation.OriginalVariable;
+        }
       }
 
-      return modifiableDataset;
-    }
-
-    private static IEnumerable<double> TransformEstimates(IEnumerable<double> data, IEnumerable<IDataAnalysisTransformation> transformations, string targetVariable) {
-      var targetTransformations = transformations.Where(x => x.TransformedVariable == targetVariable);
-
-      var transformedData = data.ToList();
-
-      foreach (var transformation in targetTransformations.Reverse()) {
-        var trans = (ITransformation<double>)transformation.Transformation;
-
-        if (!trans.Check(transformedData, out string errorMessage))
-          throw new InvalidOperationException($"Cannot estimate Values, Transformation is invalid: {errorMessage}");
-
-        transformedData = trans.InverseApply(transformedData).ToList();
-      }
-
-      return transformedData;
-    }
-
-    public static string GetOriginalTragetVariable(string transformedTarget, IEnumerable<IDataAnalysisTransformation> transformations) {
-      var target = transformedTarget;
-      foreach (var transformation in transformations.Reverse()) {
-        if (transformation.TransformedVariable == target)
-          target = transformation.OriginalVariable;
-      }
-      return target;
+      return estimates;
     }
   }