Index: branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Implementations/PreprocessingContext.cs
===================================================================
--- branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Implementations/PreprocessingContext.cs	(revision 10535)
+++ branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Implementations/PreprocessingContext.cs	(revision 10536)
@@ -79,5 +79,5 @@
 
     private IDataAnalysisProblem SetupAlgorithm(IAlgorithm algorithm) {
-      algorithm.Name = "Cloned " + algorithm.Name;
+      algorithm.Name = algorithm.Name + "(Preprocessed)";
       algorithm.Runs.Clear();
 
@@ -85,5 +85,6 @@
     }
 
-    private T Export<T>(T original, Func<T, IDataAnalysisProblem> setup) where T : IItem {
+    private T Export<T>(T original, Func<T, IDataAnalysisProblem> setup)
+        where T : IItem {
       var creator = new ProblemDataCreator(this);
       var data = creator.CreateProblemData();
@@ -93,5 +94,5 @@
       var problem = setup(clone);
       problem.ProblemDataParameter.ActualValue = data;
-      problem.Name = "Cloned " + problem.Name;
+      problem.Name = "Preprocessed " + problem.Name;
 
       return clone;
Index: branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/ProblemDataCreator.cs
===================================================================
--- branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/ProblemDataCreator.cs	(revision 10535)
+++ branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/ProblemDataCreator.cs	(revision 10536)
@@ -21,8 +21,5 @@
 
 using System;
-using System.Linq;
-using HeuristicLab.Common;
-using HeuristicLab.Core;
-using HeuristicLab.Data;
+using System.Collections.Generic;
 using HeuristicLab.Problems.DataAnalysis;
 
@@ -37,30 +34,40 @@
 
     public IDataAnalysisProblemData CreateProblemData() {
+      var oldProblemData = context.Problem.ProblemData;
 
-      IDataAnalysisProblemData problemData = CloneProblemDataWithDataset();
+      IDataAnalysisProblemData problemData = null;
+
+      var dataSet = context.Data.ExportToDataset();
+      var inputVariables = context.Data.VariableNames;
+
+      if (oldProblemData is RegressionProblemData) {
+        problemData = CreateRegressionData((RegressionProblemData)oldProblemData, dataSet, inputVariables);
+      } else if (oldProblemData is ClassificationProblemData) {
+        problemData = CreateClassificationData((ClassificationProblemData)oldProblemData, dataSet, inputVariables);
+      } else if (oldProblemData is ClusteringProblemData) {
+        problemData = CreateClusteringData((ClusteringProblemData)oldProblemData, dataSet, inputVariables);
+      } else {
+        throw new NotImplementedException("The type of the DataAnalysisProblemData is not supported.");
+      }
 
       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();
+    private IDataAnalysisProblemData CreateRegressionData(RegressionProblemData oldProblemData, Dataset dataSet, IEnumerable<string> inputVariables) {
+      var targetVariable = oldProblemData.TargetVariable;
+      // target variable must be double and must exist in the new dataset
+      return new RegressionProblemData(dataSet, inputVariables, targetVariable);
+    }
 
-      var problemData = context.Problem.ProblemData;
+    private IDataAnalysisProblemData CreateClassificationData(ClassificationProblemData oldProblemData, Dataset dataSet, IEnumerable<string> inputVariables) {
+      var targetVariable = oldProblemData.TargetVariable;
+      // target variable must be double and must exist in the new dataset
+      return new ClassificationProblemData(dataSet, inputVariables, targetVariable);
+    }
 
-      Dataset dataset = context.Data.ExportToDataset();
-
-      cloner.RegisterClonedObject(problemData.Dataset, dataset);
-
-      return cloner.Clone(problemData);
+    private IDataAnalysisProblemData CreateClusteringData(ClusteringProblemData oldProblemData, Dataset dataSet, IEnumerable<string> inputVariables) {
+      return new ClusteringProblemData(dataSet, inputVariables);
     }
 
@@ -73,37 +80,4 @@
       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);
-    }
   }
 }
