source: branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/ProblemDataCreator.cs @ 10383

#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2013 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.Linq;
using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Data;
using HeuristicLab.Problems.DataAnalysis;

namespace HeuristicLab.DataPreprocessing {
  internal class ProblemDataCreator {

    private readonly IPreprocessingContext context;

    public ProblemDataCreator(IPreprocessingContext context) {
      this.context = context;
    }

    public IDataAnalysisProblemData CreateProblemData() {

      IDataAnalysisProblemData problemData = CloneProblemDataWithDataset();

      SetTrainingAndTestPartition(problemData);

      if (problemData is RegressionProblemData) {
        //SetRegressionData((RegressionProblemData)problemData);
      } else if (problemData is ClassificationProblemData) {
        //SetClassificationData((ClassificationProblemData)problemData);
      } else if (problemData is ClusteringProblemData) {
        throw new NotImplementedException();
      }

      return problemData;
    }

    private IDataAnalysisProblemData CloneProblemDataWithDataset() {
      var cloner = new Cloner();

      var problemData = context.Problem.ProblemData;

      Dataset dataset = context.Data.ExportToDataset();

      cloner.RegisterClonedObject(problemData.Dataset, dataset);

      return cloner.Clone(problemData);
    }

    private void SetTrainingAndTestPartition(IDataAnalysisProblemData problemData) {
      var ppData = context.Data;

      problemData.TrainingPartition.Start = ppData.TrainingPartition.Start;
      problemData.TrainingPartition.End = ppData.TrainingPartition.End;
      problemData.TestPartition.Start = ppData.TestPartition.Start;
      problemData.TestPartition.End = ppData.TestPartition.End;
    }

    private void SetRegressionData(RegressionProblemData regressionProblemData) {
      SetInputVariables(regressionProblemData, regressionProblemData.TargetVariable);
      SetTargetVariable(regressionProblemData.TargetVariableParameter);
    }

    private void SetClassificationData(ClassificationProblemData classificationProblemData) {
      SetInputVariables(classificationProblemData, classificationProblemData.TargetVariable);
      SetTargetVariable(classificationProblemData.TargetVariableParameter);
    }

    private void SetInputVariables(DataAnalysisProblemData problemData, string targetVariable) {
      //TODO: InputVariables Set is Readonly

      problemData.InputVariables.Clear();

      foreach (string variable in context.Data.VariableNames) {
        problemData.InputVariables.Add(new StringValue(variable), variable != targetVariable);
      }
    }

    private void SetTargetVariable(IConstrainedValueParameter<StringValue> targetVariableParameter) {
      string oldTarget = targetVariableParameter.Value.Value;

      var validValues = targetVariableParameter.ValidValues;
      validValues.Clear();

      foreach (string variable in context.Data.VariableNames.Where(x => context.Data.IsType<double>(x))) {
        validValues.Add(new StringValue(variable));
      }

      targetVariableParameter.ActualValue = validValues.FirstOrDefault(v => v.Value == oldTarget);
    }
  }
}