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

#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2018 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
 *
 * This file is part of HeuristicLab.
 *
 * HeuristicLab is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * HeuristicLab is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
 */
#endregion

using System;
using System.Collections.Generic;
using System.Linq;
using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Data;
using HeuristicLab.Parameters;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;

namespace HeuristicLab.Problems.DataAnalysis {
  [Item("Transformation", "A transformation applied to a DataAnalysisProblemData")]
  [StorableClass]
  public sealed class DataAnalysisTransformation : ParameterizedNamedItem, IDataAnalysisTransformation {
    #region Parameter Properties
    private IFixedValueParameter<StringValue> OriginalVariableParameter {
      get { return (IFixedValueParameter<StringValue>)Parameters["Original Variable"]; }
    }

    private IFixedValueParameter<StringValue> TransformedVariableParameter {
      get { return (IFixedValueParameter<StringValue>)Parameters["Transformed Variable"]; }
    }

    private ValueParameter<ITransformation> TransformationParameter {
      get { return (ValueParameter<ITransformation>)Parameters["Transformation"]; }
    }
    #endregion

    #region Properties
    public string OriginalVariable {
      get { return OriginalVariableParameter.Value.Value; }
    }

    public string TransformedVariable {
      get { return TransformedVariableParameter.Value.Value; }
    }

    public ITransformation Transformation {
      get { return TransformationParameter.Value; }
    }
    #endregion

    #region Constructor, Cloning & Persistence
    public DataAnalysisTransformation(string originalVariable, string transformedVariable, ITransformation transformation)
      : base() {
      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; alternatively lock in view
    }

    private DataAnalysisTransformation(DataAnalysisTransformation original, Cloner cloner)
      : base(original, cloner) { }

    public override IDeepCloneable Clone(Cloner cloner) {
      return new DataAnalysisTransformation(this, cloner);
    }

    [StorableConstructor]
    private DataAnalysisTransformation(bool deserializing)
      : base(deserializing) { }

    [StorableHook(HookType.AfterDeserialization)]
    #endregion

    public override string ToString() {
      return $"{Transformation} ({OriginalVariable} -> {TransformedVariable})";
    }

    #region Transformation

    #region Variable Extension & Reduction
    // originals => include extended
    public static IEnumerable<string> ExtendVariables(IEnumerable<string> variables, IEnumerable<IDataAnalysisTransformation> transformations) {
      return GetTransitiveVariables(variables, transformations, inverse: false);
    }

    // extended => originals
    public static IEnumerable<string> ReduceVariables(IEnumerable<string> variables, IEnumerable<IDataAnalysisTransformation> transformations) {
      var originalVariables = new HashSet<string>();
      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);
      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 (reachableVariables.Contains(source))
          reachableVariables.Add(target);
      }

      return reachableVariables;
    }

    // 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) {
          variable = target;
          yield return variable;
        }
      }
    }
    #endregion

    #region Transform Dataset
    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);
        var transformedData = trans.Apply(originalData).ToList();
        if (modifiableDataset.VariableNames.Contains(transformation.TransformedVariable))
          modifiableDataset.ReplaceVariable(transformation.TransformedVariable, transformedData);
        else
          modifiableDataset.AddVariable(transformation.TransformedVariable, transformedData);
      }

      return new Dataset(modifiableDataset);
    }

    public static IDataset InverseTransform(IDataset dataset, IEnumerable<IDataAnalysisTransformation> transformations, bool removeVirtualVariables = true) {
      var modifiableDataset = ((Dataset)dataset).ToModifiable();

      var transformationsStack = new Stack<IDataAnalysisTransformation>(transformations);
      while (transformationsStack.Any()) {
        var transformation = transformationsStack.Pop();
        var trans = (ITransformation<double>)transformation.Transformation;

        var prevTransformations = transformations.Except(transformationsStack);
        bool originalWasChanged = prevTransformations.Any(x => x.TransformedVariable == transformation.OriginalVariable);
        if (originalWasChanged) {
          var transformedData = modifiableDataset.GetDoubleValues(transformation.TransformedVariable);

          var originalData = trans.InverseApply(transformedData).ToList();
          modifiableDataset.ReplaceVariable(transformation.OriginalVariable, originalData);
        }
      }

      if (removeVirtualVariables) {
        var originalVariables = ReduceVariables(dataset.VariableNames, transformations);
        var virtualVariables = dataset.VariableNames.Except(originalVariables);
        foreach (var virtualVariable in virtualVariables)
          modifiableDataset.RemoveVariable(virtualVariable);
      }

      return new Dataset(modifiableDataset);
    }
    #endregion

    #region Transform ProblemData
    public static IDataAnalysisProblemData ApplyTransformations(IDataAnalysisProblemData problemData) {
      var newDataset = Transform(problemData.Dataset, problemData.Transformations);
      var extendedInputs = ExtendVariables(problemData.AllowedInputVariables, problemData.Transformations);

      return CreateNewProblemData(problemData, newDataset, extendedInputs, inverse: false);
    }

    public static IDataAnalysisProblemData InverseApplyTransformations(IDataAnalysisProblemData problemData) {
      var newDataset = InverseTransform(problemData.Dataset, problemData.Transformations);
      var reducedInputs = ReduceVariables(problemData.AllowedInputVariables, problemData.Transformations);

      return CreateNewProblemData(problemData, newDataset, reducedInputs, inverse: true);
    }

    private static IDataAnalysisProblemData CreateNewProblemData(IDataAnalysisProblemData problemData, IDataset dataset, IEnumerable<string> inputs, bool inverse = false) {
      IDataAnalysisProblemData newProblemData;
      if (problemData is IRegressionProblemData regressionProblemData) {
        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");

      newProblemData.TrainingPartition.Start = problemData.TrainingPartition.Start;
      newProblemData.TrainingPartition.End = problemData.TrainingPartition.End;
      newProblemData.TestPartition.Start = problemData.TestPartition.Start;
      newProblemData.TestPartition.End = problemData.TestPartition.End;

      return newProblemData;
    }
    #endregion

    #region Transform Model
    // 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.");

      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;");
    }

    public static IDataAnalysisModel RestoreTrainedModel(IDataAnalysisModel transformationModel, IEnumerable<IDataAnalysisTransformation> transformations) {
      if (!(transformationModel is IDataAnalysisTransformationModel model))
        throw new InvalidOperationException("Cannot restore because model is not a TransformationModel");
      return model.OriginalModel;
    }
    #endregion

    #region Transform Solution
    public static IDataAnalysisSolution TransformSolution(IDataAnalysisSolution solution) {
      var transformations = solution.ProblemData.Transformations;

      var model = solution.Model is IDataAnalysisTransformationModel // TODO: what if model is a integrated sym-reg model?
        ? RestoreTrainedModel(solution.Model, transformations)
        : CreateTransformationIntegratedModel(solution.Model, transformations, solution.ProblemData);

      var data = solution.Model is IDataAnalysisTransformationModel
        ? ApplyTransformations(solution.ProblemData) // original -> transformed
        : InverseApplyTransformations(solution.ProblemData); // transformed -> original

      return CreateSolution(model, data);
    }

    private static IDataAnalysisSolution CreateSolution(IDataAnalysisModel model, IDataAnalysisProblemData problemData) {
      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

    #endregion
  }
}