Changeset 15885 for branches/2906_Transformations/HeuristicLab.Problems.DataAnalysis/3.4

Timestamp:

04/06/18 11:35:10 (7 years ago)

Author:

pfleck

Message:

#2906 Updated project references + small refactoring

Location:

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

Files:

• Dataset.cs (modified) (1 diff)
• Implementation/Classification/ClassificationProblemData.cs (modified) (1 diff)
• Implementation/Classification/ClassificationTransformationModel.cs (modified) (1 diff)
• Implementation/Clustering/ClusteringProblemData.cs (modified) (1 diff)
• Implementation/DataAnalysisTransformation.cs (modified) (11 diffs)
• Implementation/Regression/RegressionTransformationModel.cs (modified) (1 diff)
• Implementation/TimeSeriesPrognosis/TimeSeriesPrognosisProblemData.cs (modified) (1 diff)

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

@@ -142 +142 @@
     }
 
-    protected Dataset(Dataset dataset) : this(dataset.variableNames, dataset.variableValues.Values) { }
+    public Dataset(Dataset dataset) : this(dataset.variableNames, dataset.variableValues.Values) { }
 
     #region Backwards compatible code, remove with 3.5

branches/2906_Transformations/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ClassificationProblemData.cs

@@ -314 +314 @@
 
     public ClassificationProblemData(IClassificationProblemData classificationProblemData)
-      : this(classificationProblemData.Dataset, classificationProblemData.AllowedInputVariables, classificationProblemData.TargetVariable) {
+      : this(classificationProblemData.Dataset, classificationProblemData.AllowedInputVariables, classificationProblemData.TargetVariable, classificationProblemData.Transformations) {
       TrainingPartition.Start = classificationProblemData.TrainingPartition.Start;
       TrainingPartition.End = classificationProblemData.TrainingPartition.End;

branches/2906_Transformations/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ClassificationTransformationModel.cs

@@ -38 +38 @@
     public ClassificationTransformationModel(IClassificationModel originalModel, IEnumerable<IDataAnalysisTransformation> transformations)
       : base(originalModel, transformations) {
-      if (DataAnalysisTransformation.GetTransitiveVariables(new[] { originalModel.TargetVariable }, transformations).Any())
+      if (transformations.Any(t => t.TransformedVariable == originalModel.TargetVariable))
         throw new NotSupportedException("Classification with a transformed target variable is not allowed");
     }

branches/2906_Transformations/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Clustering/ClusteringProblemData.cs

@@ -87 +87 @@
     }
 
-    public ClusteringProblemData(Dataset dataset, IEnumerable<string> allowedInputVariables, IEnumerable<IDataAnalysisTransformation> transformations = null)
+    public ClusteringProblemData(IDataset dataset, IEnumerable<string> allowedInputVariables, IEnumerable<IDataAnalysisTransformation> transformations = null)
       : base(dataset, allowedInputVariables, transformations ?? Enumerable.Empty<IDataAnalysisTransformation>()) {
     }

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

@@ -66 +66 @@
       Parameters.Add(new FixedValueParameter<StringValue>("Original Variable", new StringValue(originalVariable).AsReadOnly()));
       Parameters.Add(new FixedValueParameter<StringValue>("Transformed Variable", new StringValue(transformedVariable).AsReadOnly()));
-      Parameters.Add(new ValueParameter<ITransformation>("Transformation", transformation)); // TODO: should be readonly/fixed
+      Parameters.Add(new ValueParameter<ITransformation>("Transformation", transformation)); // TODO: should be readonly/fixed; alternatively lock in view
     }
 
@@ -92 +92 @@
     // originals => include extended
     public static IEnumerable<string> ExtendVariables(IEnumerable<string> variables, IEnumerable<IDataAnalysisTransformation> transformations) {
-      return GetTransitiveVariables(variables, transformations);
+      return GetTransitiveVariables(variables, transformations, inverse: false);
     }
 
@@ -98 +98 @@
     public static IEnumerable<string> ReduceVariables(IEnumerable<string> variables, IEnumerable<IDataAnalysisTransformation> transformations) {
       var originalVariables = new HashSet<string>();
-      foreach (var variable in variables)
-        originalVariables.Add(GetLastTransitiveVariable(variable, transformations, inverse: true));
+      foreach (var variable in variables) {
+        var originalVariable = GetStrictTransitiveVariables(variable, transformations, inverse: true).Last();
+        originalVariables.Add(originalVariable);
+      }
+
       return originalVariables;
     }
 
+    // return all reachable variables
     public static IEnumerable<string> GetTransitiveVariables(IEnumerable<string> variables, IEnumerable<IDataAnalysisTransformation> transformations, bool inverse = false) {
       var reachableVariables = new HashSet<string>(variables);
@@ -116 +120 @@
     }
 
-    public static string GetLastTransitiveVariable(string variable, IEnumerable<IDataAnalysisTransformation> transformations, bool inverse = false) {
+    // return the (unique) chain of transformations for a given variable
+    public static IEnumerable<string> GetStrictTransitiveVariables(string variable, IEnumerable<IDataAnalysisTransformation> transformations, bool inverse = false) {
+      yield return variable;
       if (inverse) transformations = transformations.Reverse();
       foreach (var transformation in transformations) {
         var source = inverse ? transformation.TransformedVariable : transformation.OriginalVariable;
         var target = inverse ? transformation.OriginalVariable : transformation.TransformedVariable;
-        if (variable == source)
+        if (variable == source) {
           variable = target;
-      }
-
-      return variable;
+          yield return variable;
+        }
+      }
     }
     #endregion
@@ -137 +143 @@
 
         var originalData = modifiableDataset.GetDoubleValues(transformation.OriginalVariable);
-        //if (!trans.Check(originalData, out string errorMessage))
-        //  throw new InvalidOperationException($"Cannot estimate Values, Transformation is invalid: {errorMessage}");
-        // TODO: check was already called before configure (in preprocessing)
-        // TODO: newly specified data might not pass the check but it does not matter because the data is not configured with
-        // e.g. impact calculation -> replacement=most common -> originalMean is zero
-
         var transformedData = trans.Apply(originalData).ToList();
         if (modifiableDataset.VariableNames.Contains(transformation.TransformedVariable))
@@ -150 +150 @@
       }
 
-      return modifiableDataset; // TODO: to regular dataset?
+      return new Dataset(modifiableDataset);
     }
 
@@ -178 +178 @@
       }
 
-      return modifiableDataset; // TODO: to regular dataset?
+      return new Dataset(modifiableDataset);
     }
     #endregion
@@ -200 +200 @@
       IDataAnalysisProblemData newProblemData;
       if (problemData is IRegressionProblemData regressionProblemData) {
-        var newTargetVariable = GetLastTransitiveVariable(regressionProblemData.TargetVariable, problemData.Transformations, inverse);
-        newProblemData = new RegressionProblemData(dataset, inputs, newTargetVariable, problemData.Transformations);
+        var newTargetVariable = GetStrictTransitiveVariables(regressionProblemData.TargetVariable, problemData.Transformations, inverse).Last();
+        if (problemData is ITimeSeriesPrognosisProblemData timeSeriesPrognosisProblemData) {
+          newProblemData = new TimeSeriesPrognosisProblemData(dataset, inputs, newTargetVariable, problemData.Transformations) {
+            TrainingHorizon = timeSeriesPrognosisProblemData.TrainingHorizon,
+            TestHorizon = timeSeriesPrognosisProblemData.TestHorizon,
+          };
+
+        } else
+          newProblemData = new RegressionProblemData(dataset, inputs, newTargetVariable, problemData.Transformations);
       } else if (problemData is IClassificationProblemData classificationProblemData) {
         newProblemData = new ClassificationProblemData(dataset, inputs, classificationProblemData.TargetVariable, problemData.Transformations);
+      } else if (problemData is IClusteringProblemData) {
+        newProblemData = new ClusteringProblemData(dataset, inputs, problemData.Transformations);
       } else throw new NotSupportedException("Type of ProblemData not supported");
 
@@ -216 +225 @@
 
     #region Transform Model
-    public static IDataAnalysisTransformationModel CreateTransformationIntegratedModel(IDataAnalysisModel model, IEnumerable<IDataAnalysisTransformation> transformations) {
+    // problemdata required for type-switch. cannot differ based on model type (e.g. RF model is both regression and classification)
+    public static IDataAnalysisTransformationModel CreateTransformationIntegratedModel(IDataAnalysisModel model, IEnumerable<IDataAnalysisTransformation> transformations, IDataAnalysisProblemData problemData) {
       if (model is IDataAnalysisTransformationModel)
         throw new InvalidOperationException("Model already is a transformation model.");
 
-      switch (model) {
-        case ITimeSeriesPrognosisModel timeSeriesPrognosisModel:
-          return new TimeSeriesPrognosisTransformationModel(timeSeriesPrognosisModel, transformations);
-        case IRegressionModel regressionModel:
-          return new RegressionTransformationModel(regressionModel, transformations);
-        case IClassificationModel classificationModel:
-          return new ClassificationTransformationModel(classificationModel, transformations);
-        case IClusteringModel clusteringModel:
-          return new ClusteringTransformationModel(clusteringModel, transformations);
-        default:
-          throw new NotSupportedException("Type of the model is not supported;");
-      }
+      if (problemData is ITimeSeriesPrognosisProblemData)
+        return new TimeSeriesPrognosisTransformationModel((ITimeSeriesPrognosisModel)model, transformations);
+      if (problemData is IRegressionProblemData)
+        return new RegressionTransformationModel((IRegressionModel)model, transformations);
+      if (problemData is IClassificationProblemData)
+        return new ClassificationTransformationModel((IClassificationModel)model, transformations);
+      if (problemData is IClusteringProblemData)
+        return new ClusteringTransformationModel((IClusteringModel)model, transformations);
+
+      throw new NotSupportedException("Type of the model is not supported;");
     }
 
@@ -247 +255 @@
       var model = solution.Model is IDataAnalysisTransformationModel // TODO: what if model is a integrated sym-reg model?
         ? RestoreTrainedModel(solution.Model, transformations)
-        : CreateTransformationIntegratedModel(solution.Model, transformations);
+        : CreateTransformationIntegratedModel(solution.Model, transformations, solution.ProblemData);
 
       var data = solution.Model is IDataAnalysisTransformationModel
@@ -257 +265 @@
 
     private static IDataAnalysisSolution CreateSolution(IDataAnalysisModel model, IDataAnalysisProblemData problemData) {
-      switch (model) {
-        case ITimeSeriesPrognosisModel timeSeriesPrognosisModel:
-          return timeSeriesPrognosisModel.CreateTimeSeriesPrognosisSolution((ITimeSeriesPrognosisProblemData)problemData);
-        case IRegressionModel regressionModel:
-          return regressionModel.CreateRegressionSolution((IRegressionProblemData)problemData);
-        case IClassificationModel classificationModel:
-          return classificationModel.CreateClassificationSolution((IClassificationProblemData)problemData);
-        default:
-          throw new NotSupportedException("Cannot create Solution of the model type.");
-      }
+      if (problemData is ITimeSeriesPrognosisProblemData)
+        return ((ITimeSeriesPrognosisModel)model).CreateTimeSeriesPrognosisSolution((ITimeSeriesPrognosisProblemData)problemData);
+      if (problemData is IRegressionProblemData)
+        return ((IRegressionModel)model).CreateRegressionSolution((IRegressionProblemData)problemData);
+      if (problemData is IClassificationProblemData)
+        return ((IClassificationModel)model).CreateClassificationSolution((IClassificationProblemData)problemData);
+      //if (problemData is IClusteringProblemData)
+      //  return ((IClusteringModel)model).CreateClusteringSolution((IClusteringProblemData)problemData);
+
+      throw new NotSupportedException("Cannot create Solution of the model type.");
     }
     #endregion

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

@@ -42 +42 @@
     public RegressionTransformationModel(IRegressionModel originalModel, IEnumerable<IDataAnalysisTransformation> transformations)
       : base(originalModel, transformations) {
-      var transitiveTargets = DataAnalysisTransformation.GetTransitiveVariables(new[] { originalModel.TargetVariable }, transformations, inverse: true).ToList();
-      TargetTransformations = new ItemList<IDataAnalysisTransformation>(transformations.Where(t => transitiveTargets.Contains(t.OriginalVariable))).AsReadOnly();
-      TargetVariable = DataAnalysisTransformation.GetLastTransitiveVariable(originalModel.TargetVariable, TargetTransformations, inverse: true);
+      var learnedTarget = DataAnalysisTransformation.GetStrictTransitiveVariables(originalModel.TargetVariable, transformations, true).Last();
+      var transitiveTargets = DataAnalysisTransformation.GetStrictTransitiveVariables(learnedTarget, transformations, inverse: false).ToList();
+      TargetTransformations = new ItemList<IDataAnalysisTransformation>(transformations.Where(t => transitiveTargets.Contains(t.TransformedVariable))).AsReadOnly();
+
+      TargetVariable = DataAnalysisTransformation.GetStrictTransitiveVariables(originalModel.TargetVariable, TargetTransformations, true).Last();
     }
 

branches/2906_Transformations/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/TimeSeriesPrognosis/TimeSeriesPrognosisProblemData.cs

@@ -1596 +1596 @@
 
     public TimeSeriesPrognosisProblemData(ITimeSeriesPrognosisProblemData timeseriesProblemData)
-      : this(timeseriesProblemData.Dataset, timeseriesProblemData.AllowedInputVariables, timeseriesProblemData.TargetVariable) {
+      : this(timeseriesProblemData.Dataset, timeseriesProblemData.AllowedInputVariables, timeseriesProblemData.TargetVariable, timeseriesProblemData.Transformations) {
 
       TrainingPartition.Start = timeseriesProblemData.TrainingPartition.Start;