Changeset 15938

Timestamp:

05/17/18 10:03:01 (7 years ago)

Author:

pfleck

Message:

#2906

• added Offset to log transformation
• renamed parameter of linear transformation
• added RescaleTransformation

Location:

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

Files:

• HeuristicLab.Problems.DataAnalysis-3.4.csproj (modified) (1 diff)
• Implementation/Transformations/LinearTransformation.cs (modified) (3 diffs)
• Implementation/Transformations/LogarithmTransformation.cs (modified) (5 diffs)
• Implementation/Transformations/RescaleTransformation.cs (added)
• Interfaces/IDataAnalysisTransformationModel.cs (modified) (1 diff)

branches/2906_Transformations/HeuristicLab.Problems.DataAnalysis/3.4/HeuristicLab.Problems.DataAnalysis-3.4.csproj

@@ -231 +231 @@
     <Compile Include="Implementation\Transformations\LinearTransformation.cs" />
     <Compile Include="Implementation\Transformations\LogarithmTransformation.cs" />
+    <Compile Include="Implementation\Transformations\RescaleTransformation.cs" />
     <Compile Include="Implementation\Transformations\Transformation.cs" />
     <Compile Include="Implementation\Transformations\ZNormalizationTransformation.cs" />

branches/2906_Transformations/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Transformations/LinearTransformation.cs

@@ -30 +30 @@
 
 namespace HeuristicLab.Problems.DataAnalysis {
-  [Item("Linear", "Linear transformation x' = slope * x + intercept")]
+  [Item("Linear", "Linear transformation x' = Scale * x + Offset")]
   [StorableClass]
   public class LinearTransformation : Transformation<double> {
 
     #region Parameters
-    private FixedValueParameter<DoubleValue> SlopeParameter {
-      get { return (FixedValueParameter<DoubleValue>)Parameters["Slope"]; }
+    private FixedValueParameter<DoubleValue> ScaleParameter {
+      get { return (FixedValueParameter<DoubleValue>)Parameters["Scale"]; }
     }
 
-    private FixedValueParameter<DoubleValue> InterceptParameter {
-      get { return (FixedValueParameter<DoubleValue>)Parameters["Intercept"]; }
+    private FixedValueParameter<DoubleValue> OffsetParameter {
+      get { return (FixedValueParameter<DoubleValue>)Parameters["Offset"]; }
     }
     #endregion
 
     #region Properties
-    public double Slope {
-      get { return SlopeParameter.Value.Value; }
-      set { SlopeParameter.Value.Value = value; }
+    public double Scale {
+      get { return ScaleParameter.Value.Value; }
+      set { ScaleParameter.Value.Value = value; }
     }
 
-    public double Intercept {
-      get { return InterceptParameter.Value.Value; }
-      set { InterceptParameter.Value.Value = value; }
+    public double Offset {
+      get { return OffsetParameter.Value.Value; }
+      set { OffsetParameter.Value.Value = value; }
     }
     #endregion
@@ -59 +59 @@
     public LinearTransformation()
       : base() {
-      Parameters.Add(new FixedValueParameter<DoubleValue>("Slope", "Slope (multiplicative factor)", new DoubleValue(1.0)));
-      Parameters.Add(new FixedValueParameter<DoubleValue>("Intercept", "Intercept (additive factor)", new DoubleValue(0.0)));
+      Parameters.Add(new FixedValueParameter<DoubleValue>("Scale", "Multiplicative factor (Slope)", new DoubleValue(1.0)));
+      Parameters.Add(new FixedValueParameter<DoubleValue>("Offset", "Additive factor (Intercept)", new DoubleValue(0.0)));
     }
 
@@ -77 +77 @@
 
     public override IEnumerable<double> Apply(IEnumerable<double> data) {
-      return Apply(data, Slope, Intercept);
+      return Apply(data, Scale, Offset);
     }
 
     public override IEnumerable<double> InverseApply(IEnumerable<double> data) {
-      return InverseApply(data, Slope, Intercept);
+      return InverseApply(data, Scale, Offset);
     }
 
 
-    public static IEnumerable<double> Apply(IEnumerable<double> data, double slope = 1.0, double intercept = 0.0) {
-      if (slope.IsAlmost(0.0))
-        throw new InvalidOperationException($"Cannot transform with a {nameof(slope)} of zero because inverse transformation would be invalid.");
+    public static IEnumerable<double> Apply(IEnumerable<double> data, double scale = 1.0, double offset = 0.0) {
+      if (scale.IsAlmost(0.0))
+        throw new InvalidOperationException($"Cannot transform with a {nameof(scale)} of zero because inverse transformation would be invalid.");
 
-      return data.Select(x => slope * x + intercept);
+      return data.Select(x => scale * x + offset);
     }
 
-    public static IEnumerable<double> InverseApply(IEnumerable<double> data, double slope = 1.0, double intercept = 0.0) {
-      if (slope.IsAlmost(0.0))
-        throw new InvalidOperationException($"Cannot inverse transform with a {nameof(slope)} of zero.");
+    public static IEnumerable<double> InverseApply(IEnumerable<double> data, double scale = 1.0, double offset = 0.0) {
+      if (scale.IsAlmost(0.0))
+        throw new InvalidOperationException($"Cannot inverse transform with a {nameof(scale)} of zero.");
 
-      return data.Select(x => (x - intercept) / slope);
+      return data.Select(x => (x - offset) / scale);
     }
   }

branches/2906_Transformations/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Transformations/LogarithmTransformation.cs

@@ -37 +37 @@
       get { return (FixedValueParameter<DoubleValue>)Parameters["Base"]; }
     }
+    private FixedValueParameter<DoubleValue> OffsetParameter {
+      get { return (FixedValueParameter<DoubleValue>)Parameters["Offset"]; }
+    }
     #endregion
 
@@ -44 +47 @@
       set { BaseParameter.Value.Value = value; }
     }
+    public double Offset {
+      get { return OffsetParameter.Value.Value; }
+      set { OffsetParameter.Value.Value = value; }
+    }
     #endregion
 
@@ -50 +57 @@
       : base() {
       Parameters.Add(new FixedValueParameter<DoubleValue>("Base", "Base the logarithm", new DoubleValue(Math.E)));
+      Parameters.Add(new FixedValueParameter<DoubleValue>("Offset", "Offset before the logarithm", new DoubleValue(0.0)));
     }
 
@@ -66 +74 @@
 
     public override bool Check(IEnumerable<double> data, out string errorMessage) {
-      if (data.Any(x => x <= 0)) {
+      if (data.Any(x => x + Offset <= 0)) {
         errorMessage = "Log is not available for zero or negative values";
         return false;
@@ -74 +82 @@
 
     public override IEnumerable<double> Apply(IEnumerable<double> data) {
-      return Apply(data, Base);
+      return Apply(data, Base, Offset);
     }
 
     public override IEnumerable<double> InverseApply(IEnumerable<double> data) {
-      return InverseApply(data, Base);
+      return InverseApply(data, Base, Offset);
     }
 
 
-    public static IEnumerable<double> Apply(IEnumerable<double> data, double @base = Math.E) {
-      return data.Select(x => Math.Log(x, @base));
+    public static IEnumerable<double> Apply(IEnumerable<double> data, double @base = Math.E, double offset = 0.0) {
+      return data.Select(x => Math.Log(x + offset, @base));
     }
 
-    public static IEnumerable<double> InverseApply(IEnumerable<double> data, double @base = Math.E) {
-      return ExponentialTransformation.Apply(data, @base);
+    public static IEnumerable<double> InverseApply(IEnumerable<double> data, double @base = Math.E, double offset = 0.0) {
+      return ExponentialTransformation.InverseApply(data, @base).Select(x => x - offset);
     }
   }

branches/2906_Transformations/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/IDataAnalysisTransformationModel.cs

@@ -26 +26 @@
     IDataAnalysisModel OriginalModel { get; }
 
-    /// <summary>
-    /// Transformations that are used on the model's inputs.
-    /// </summary>
     IEnumerable<IDataAnalysisTransformation> InputTransformations { get; }
   }