Changeset 2043

Timestamp:

06/15/09 16:46:25 (16 years ago)

Author:

gkronber

Message:

Added variable impact calculation operators for support vector machines. #644 (Variable impact of CEDMA models should be calculated and stored in the result DB)

Location:

trunk/sources

Files:

• HeuristicLab.GP.StructureIdentification/3.3/Evaluators/VariableEvaluationImpactCalculator.cs (modified) (1 diff)
• HeuristicLab.GP.StructureIdentification/3.3/Evaluators/VariableQualityImpactCalculator.cs (modified) (1 diff)
• HeuristicLab.Modeling/3.2/VariableEvaluationImpactCalculator.cs (modified) (2 diffs)
• HeuristicLab.Modeling/3.2/VariableImpactCalculatorBase.cs (modified) (4 diffs)
• HeuristicLab.Modeling/3.2/VariableQualityImpactCalculator.cs (modified) (1 diff)
• HeuristicLab.SupportVectorMachines/3.2/HeuristicLab.SupportVectorMachines-3.2.csproj (modified) (2 diffs)
• HeuristicLab.SupportVectorMachines/3.2/HeuristicLabSupportVectorMachinesPlugin.cs (modified) (1 diff)
• HeuristicLab.SupportVectorMachines/3.2/SupportVectorEvaluator.cs (modified) (1 diff)
• HeuristicLab.SupportVectorMachines/3.2/SupportVectorRegression.cs (modified) (8 diffs)
• HeuristicLab.SupportVectorMachines/3.2/VariableEvaluationImpactCalculator.cs (copied) (copied from trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/Evaluators/VariableEvaluationImpactCalculator.cs) (1 diff)
• HeuristicLab.SupportVectorMachines/3.2/VariableQualityImpactCalculator.cs (copied) (copied from trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/Evaluators/VariableQualityImpactCalculator.cs) (1 diff)

trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/Evaluators/VariableEvaluationImpactCalculator.cs

@@ -41 +41 @@
 
 
-    protected override double[] GetOutputs(IScope scope, Dataset dataset, int targetVariable, int start, int end) {
+    protected override double[] GetOutputs(IScope scope, Dataset dataset, int targetVariable, ItemList<IntData> allowedFeatures, int start, int end) {
       ITreeEvaluator evaluator = GetVariableValue<ITreeEvaluator>("TreeEvaluator", scope, true);
       IFunctionTree tree = GetVariableValue<IFunctionTree>("FunctionTree", scope, true);

trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/Evaluators/VariableQualityImpactCalculator.cs

@@ -40 +40 @@
     }
 
-    protected override double CalculateQuality(IScope scope, Dataset dataset, int targetVariable, int start, int end) {
+    protected override double CalculateQuality(IScope scope, Dataset dataset, int targetVariable, ItemList<IntData> allowedFeatures, int start, int end) {
       ITreeEvaluator evaluator = GetVariableValue<ITreeEvaluator>("TreeEvaluator", scope, true);
       IFunctionTree tree = GetVariableValue<IFunctionTree>("FunctionTree", scope, true);

trunk/sources/HeuristicLab.Modeling/3.2/VariableEvaluationImpactCalculator.cs

@@ -53 +53 @@
     }
 
-    protected override double[] CalculateValue(IScope scope, Dataset dataset, int targetVariable, int start, int end) {
-      return GetOutputs(scope, dataset, targetVariable, start, end);
+    protected override double[] CalculateValue(IScope scope, Dataset dataset, int targetVariable, ItemList<IntData> allowedFeatures, int start, int end) {
+      return GetOutputs(scope, dataset, targetVariable, allowedFeatures, start, end);
     }
 
@@ -66 +66 @@
     }
 
-    protected abstract double[] GetOutputs(IScope scope, Dataset dataset, int targetVariable, int start, int end);
+    protected abstract double[] GetOutputs(IScope scope, Dataset dataset, int targetVariable, ItemList<IntData> allowedFeatures, int start, int end);
   }
 }

trunk/sources/HeuristicLab.Modeling/3.2/VariableImpactCalculatorBase.cs

@@ -31 +31 @@
 namespace HeuristicLab.Modeling {
   public abstract class VariableImpactCalculatorBase<T> : OperatorBase {
+    private bool abortRequested = false;
+
     public override string Description {
       get { return @"Calculates the impact of all allowed input variables on the model."; }
@@ -36 +38 @@
 
     public abstract string OutputVariableName { get; }
+
+    public override void Abort() {
+      abortRequested = true;
+    }
 
     public VariableImpactCalculatorBase()
@@ -55 +61 @@
       int end = GetVariableValue<IntData>("TrainingSamplesEnd", scope, true).Data;
 
-      T referenceValue = CalculateValue(scope, dataset, targetVariable, start, end);
+      T referenceValue = CalculateValue(scope, dataset, targetVariable, allowedFeatures, start, end);
       double[] impacts = new double[allowedFeatures.Count];
 
-      for (int i = 0; i < allowedFeatures.Count; i++) {
+      for (int i = 0; i < allowedFeatures.Count && !abortRequested; i++) {
         int currentVariable = allowedFeatures[i].Data;
-        var oldValues = ReplaceVariableValues(dirtyDataset, currentVariable , CalculateNewValues(dirtyDataset, currentVariable, start, end), start, end);
-        T newValue = CalculateValue(scope, dirtyDataset, targetVariable, start, end);
+        var oldValues = ReplaceVariableValues(dirtyDataset, currentVariable, CalculateNewValues(dirtyDataset, currentVariable, start, end), start, end);
+        T newValue = CalculateValue(scope, dirtyDataset, targetVariable, allowedFeatures, start, end);
         impacts[i] = CalculateImpact(referenceValue, newValue);
         ReplaceVariableValues(dirtyDataset, currentVariable, oldValues, start, end);
       }
 
-      impacts = PostProcessImpacts(impacts);
+      if (!abortRequested) {
+        impacts = PostProcessImpacts(impacts);
 
-      ItemList variableImpacts = new ItemList();
-      for (int i = 0; i < allowedFeatures.Count; i++) {
-        int currentVariable = allowedFeatures[i].Data;
-        ItemList row = new ItemList();
-        row.Add(new StringData(dataset.GetVariableName(currentVariable)));
-        row.Add(new DoubleData(impacts[i]));
-        variableImpacts.Add(row);
+        ItemList variableImpacts = new ItemList();
+        for (int i = 0; i < allowedFeatures.Count; i++) {
+          int currentVariable = allowedFeatures[i].Data;
+          ItemList row = new ItemList();
+          row.Add(new StringData(dataset.GetVariableName(currentVariable)));
+          row.Add(new DoubleData(impacts[i]));
+          variableImpacts.Add(row);
+        }
+
+        scope.AddVariable(new Variable(scope.TranslateName(OutputVariableName), variableImpacts));
+        return null;
+      } else {
+        return new AtomicOperation(this, scope);
       }
-
-      scope.AddVariable(new Variable(scope.TranslateName(OutputVariableName), variableImpacts));
-      return null;
     }
 
-    protected abstract T CalculateValue(IScope scope, Dataset dataset, int targetVariable, int start, int end);
+    protected abstract T CalculateValue(IScope scope, Dataset dataset, int targetVariable, ItemList<IntData> allowedFeatures, int start, int end);
 
     protected abstract double CalculateImpact(T referenceValue, T newValue);
@@ -96 +106 @@
       int index = start;
       ds.FireChangeEvents = false;
-      foreach(double v in newValues) {
+      foreach (double v in newValues) {
         ds.SetValue(index++, variableIndex, v);
       }

trunk/sources/HeuristicLab.Modeling/3.2/VariableQualityImpactCalculator.cs

@@ -43 +43 @@
     }
 
-    protected override double CalculateValue(IScope scope, Dataset dataset, int targetVariable, int start, int end) {
-      return CalculateQuality(scope, dataset, targetVariable, start, end);
+    protected override double CalculateValue(IScope scope, Dataset dataset, int targetVariable, ItemList<IntData> allowedFeatures, int start, int end) {
+      return CalculateQuality(scope, dataset, targetVariable, allowedFeatures, start, end);
     }
 
-    protected abstract double CalculateQuality(IScope scope, Dataset dataset, int targetVariable, int start, int end);
+    protected abstract double CalculateQuality(IScope scope, Dataset dataset, int targetVariable, ItemList<IntData> allowedFeatures, int start, int end);
   }
 }

trunk/sources/HeuristicLab.SupportVectorMachines/3.2/HeuristicLab.SupportVectorMachines-3.2.csproj

@@ -88 +88 @@
     <Compile Include="SupportVectorEvaluator.cs" />
     <Compile Include="SVMHelper.cs" />
+    <Compile Include="VariableEvaluationImpactCalculator.cs" />
+    <Compile Include="VariableQualityImpactCalculator.cs" />
   </ItemGroup>
   <ItemGroup>
@@ -126 +128 @@
       <Name>HeuristicLab.PluginInfrastructure</Name>
     </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Random\3.2\HeuristicLab.Random-3.2.csproj">
+      <Project>{47019A74-F7F7-482E-83AA-D3F4F777E879}</Project>
+      <Name>HeuristicLab.Random-3.2</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Selection\3.2\HeuristicLab.Selection-3.2.csproj">
+      <Project>{F7CF0571-25CB-43D5-8443-0843A1E2861A}</Project>
+      <Name>HeuristicLab.Selection-3.2</Name>
+    </ProjectReference>
     <ProjectReference Include="..\..\HeuristicLab.SequentialEngine\3.2\HeuristicLab.SequentialEngine-3.2.csproj">
       <Project>{B4BE8E53-BA06-4237-9A01-24255F880201}</Project>

trunk/sources/HeuristicLab.SupportVectorMachines/3.2/HeuristicLabSupportVectorMachinesPlugin.cs

@@ -37 +37 @@
   [Dependency(Dependency = "HeuristicLab.Logging-3.2")]
   [Dependency(Dependency = "HeuristicLab.Operators.Programmable-3.2")]
+  [Dependency(Dependency = "HeuristicLab.Random-3.2")]
+  [Dependency(Dependency = "HeuristicLab.Selection-3.2")]
   public class HeuristicLabSupportVectorMachinesPlugin : PluginBase {
   }

trunk/sources/HeuristicLab.SupportVectorMachines/3.2/SupportVectorEvaluator.cs

@@ -59 +59 @@
       for (int i = 0; i < end - start; i++) {
         values[i,0] = SVM.Prediction.Predict(modelData.Model, scaledProblem.X[i]);
-        values[i,1] = dataset.Samples[(start + i) * dataset.Columns + targetVariable];
+        values[i,1] = dataset.GetValue(start + i,targetVariable);
       }
 

trunk/sources/HeuristicLab.SupportVectorMachines/3.2/SupportVectorRegression.cs

@@ -34 +34 @@
 using HeuristicLab.Operators.Programmable;
 using HeuristicLab.Modeling;
+using HeuristicLab.Random;
+using HeuristicLab.Selection;
 
 namespace HeuristicLab.SupportVectorMachines {
@@ -118 +120 @@
       main.AddSubOperator(CreateGlobalInjector());
       main.AddSubOperator(new ProblemInjector());
-
-      SequentialProcessor nuLoop = new SequentialProcessor();
-      nuLoop.Name = "NuLoop";
-      SequentialProcessor costLoop = new SequentialProcessor();
-      costLoop.Name = "CostLoop";
-      main.AddSubOperator(nuLoop);
-      nuLoop.AddSubOperator(CreateResetOperator("CostIndex"));
-      nuLoop.AddSubOperator(costLoop);
+      main.AddSubOperator(new RandomInjector());
+
       SubScopesCreater modelScopeCreator = new SubScopesCreater();
       modelScopeCreator.GetVariableInfo("SubScopes").Local = true;
       modelScopeCreator.AddVariable(new HeuristicLab.Core.Variable("SubScopes", new IntData(1)));
+      main.AddSubOperator(modelScopeCreator);
+
+      SequentialSubScopesProcessor seqSubScopesProc = new SequentialSubScopesProcessor();
+      IOperator modelProcessor = CreateModelProcessor();
+      seqSubScopesProc.AddSubOperator(modelProcessor);
+      main.AddSubOperator(seqSubScopesProc);
+
+      SequentialProcessor nuLoop = new SequentialProcessor();
+      nuLoop.Name = "NuLoop";
+
+      IOperator costCounter = CreateCounter("Cost");
+      IOperator costComparator = CreateComparator("Cost");
+      nuLoop.AddSubOperator(costCounter);
+      nuLoop.AddSubOperator(costComparator);
+      ConditionalBranch costBranch = new ConditionalBranch();
+      costBranch.Name = "IfValidCostIndex";
+      costBranch.GetVariableInfo("Condition").ActualName = "RepeatCostLoop";
+
+      // build cost loop
+      SequentialProcessor costLoop = new SequentialProcessor();
+      costLoop.Name = "CostLoop";
       costLoop.AddSubOperator(modelScopeCreator);
       SequentialSubScopesProcessor subScopesProcessor = new SequentialSubScopesProcessor();
       costLoop.AddSubOperator(subScopesProcessor);
+      subScopesProcessor.AddSubOperator(new EmptyOperator());
+      subScopesProcessor.AddSubOperator(modelProcessor);
+
+      Sorter sorter = new Sorter();
+      sorter.GetVariableInfo("Value").ActualName = "ValidationQuality";
+      sorter.GetVariableInfo("Descending").Local = true;
+      sorter.AddVariable(new Variable("Descending", new BoolData(false)));
+      costLoop.AddSubOperator(sorter);
+
+      LeftSelector selector = new LeftSelector();
+      selector.GetVariableInfo("Selected").Local = true;
+      selector.AddVariable(new Variable("Selected", new IntData(1)));
+      costLoop.AddSubOperator(selector);
+
+      RightReducer reducer = new RightReducer();
+      costLoop.AddSubOperator(reducer);
+
+      costLoop.AddSubOperator(costCounter);
+      costLoop.AddSubOperator(costComparator);
+
+      costBranch.AddSubOperator(costLoop);
+      costLoop.AddSubOperator(costBranch);
+
+      nuLoop.AddSubOperator(costBranch);
+      nuLoop.AddSubOperator(CreateResetOperator("CostIndex"));
+
+      nuLoop.AddSubOperator(CreateCounter("Nu"));
+      nuLoop.AddSubOperator(CreateComparator("Nu"));
+
+      ConditionalBranch nuBranch = new ConditionalBranch();
+      nuBranch.Name = "NuLoop";
+      nuBranch.GetVariableInfo("Condition").ActualName = "RepeatNuLoop";
+      nuBranch.AddSubOperator(nuLoop);
+      nuLoop.AddSubOperator(nuBranch);
+
+      main.AddSubOperator(nuLoop);
+      main.AddSubOperator(CreateModelAnalyser());
+      return main;
+    }
+
+    private IOperator CreateModelProcessor() {
       SequentialProcessor modelProcessor = new SequentialProcessor();
-      subScopesProcessor.AddSubOperator(modelProcessor);
       modelProcessor.AddSubOperator(CreateSetNextParameterValueOperator("Nu"));
       modelProcessor.AddSubOperator(CreateSetNextParameterValueOperator("Cost"));
@@ -160 +217 @@
       ((ItemList<StringData>)collector.GetVariable("VariableNames").Value).Add(new StringData("ValidationQuality"));
       modelProcessor.AddSubOperator(collector);
-
-      BestSolutionStorer solStorer = new BestSolutionStorer();
-      solStorer.GetVariableInfo("Quality").ActualName = "ValidationQuality";
-      solStorer.GetVariableInfo("Maximization").Local = true;
-      solStorer.GetVariableInfo("BestSolution").ActualName = "BestValidationSolution";
-      solStorer.AddVariable(new HeuristicLab.Core.Variable("Maximization", new BoolData(false)));
-
-      costLoop.AddSubOperator(solStorer);
-      SubScopesRemover remover = new SubScopesRemover();
-      costLoop.AddSubOperator(remover);
-      costLoop.AddSubOperator(CreateCounter("Cost"));
-      costLoop.AddSubOperator(CreateComparator("Cost"));
-      ConditionalBranch costBranch = new ConditionalBranch();
-      costBranch.Name = "CostLoop";
-      costBranch.GetVariableInfo("Condition").ActualName = "RepeatCostLoop";
-      costBranch.AddSubOperator(costLoop);
-      costLoop.AddSubOperator(costBranch);
-
-      nuLoop.AddSubOperator(CreateCounter("Nu"));
-      nuLoop.AddSubOperator(CreateComparator("Nu"));
-      ConditionalBranch nuBranch = new ConditionalBranch();
-      nuBranch.Name = "NuLoop";
-      nuBranch.GetVariableInfo("Condition").ActualName = "RepeatNuLoop";
-      nuBranch.AddSubOperator(nuLoop);
-      nuLoop.AddSubOperator(nuBranch);
-      return main;
+      return modelProcessor;
     }
 
@@ -271 +303 @@
       progOp.RemoveVariableInfo("Result");
       progOp.AddVariableInfo(new VariableInfo("Value", "Value", typeof(IntData), VariableKind.In | VariableKind.Out));
-      progOp.Code = "Value.Data = 0;";
+      progOp.Code = "Value.Data = -1;";
       progOp.GetVariableInfo("Value").ActualName = paramName;
       return progOp;
@@ -279 +311 @@
       VariableInjector injector = new VariableInjector();
       injector.AddVariable(new HeuristicLab.Core.Variable("CostIndex", new IntData(0)));
-      injector.AddVariable(new HeuristicLab.Core.Variable("CostList", new DoubleArrayData(new double[] { 0.1, 0.25, 0.5, 1.0, 2.0, 4.0, 8.0, 16.0, 32.0, 64.0, 128.0 })));
+      injector.AddVariable(new HeuristicLab.Core.Variable("CostList", new DoubleArrayData(new double[] { 0.1, 0.25, 0.5, 1.0, 2.0, 4.0, 8.0 })));
       injector.AddVariable(new HeuristicLab.Core.Variable("MaxCostIndex", new IntData()));
       injector.AddVariable(new HeuristicLab.Core.Variable("NuIndex", new IntData(0)));
-      injector.AddVariable(new HeuristicLab.Core.Variable("NuList", new DoubleArrayData(new double[] { 0.01, 0.05, 0.1, 0.5, 0.9 })));
+      injector.AddVariable(new HeuristicLab.Core.Variable("NuList", new DoubleArrayData(new double[] { 0.01, 0.05, 0.1, 0.5 })));
       injector.AddVariable(new HeuristicLab.Core.Variable("MaxNuIndex", new IntData()));
       injector.AddVariable(new HeuristicLab.Core.Variable("Log", new ItemList()));
@@ -291 +323 @@
       return injector;
     }
+
+    private IOperator CreateModelAnalyser() {
+      CombinedOperator modelAnalyser = new CombinedOperator();
+      modelAnalyser.Name = "Model Analyzer";
+      SequentialSubScopesProcessor seqSubScopeProc = new SequentialSubScopesProcessor();
+      SequentialProcessor seqProc = new SequentialProcessor();
+      VariableEvaluationImpactCalculator evalImpactCalc = new VariableEvaluationImpactCalculator();
+      evalImpactCalc.GetVariableInfo("SVMModel").ActualName = "Model";
+      VariableQualityImpactCalculator qualImpactCalc = new VariableQualityImpactCalculator();
+      qualImpactCalc.GetVariableInfo("SVMModel").ActualName = "Model";
+
+      seqProc.AddSubOperator(evalImpactCalc);
+      seqProc.AddSubOperator(qualImpactCalc);
+      seqSubScopeProc.AddSubOperator(seqProc);
+      modelAnalyser.OperatorGraph.InitialOperator = seqSubScopeProc;
+      modelAnalyser.OperatorGraph.AddOperator(seqSubScopeProc);
+      return modelAnalyser;
+    }
+
 
     protected internal virtual Model CreateSVMModel(IScope bestModelScope) {
@@ -309 +360 @@
       model.ValidationVarianceAccountedFor = bestModelScope.GetVariableValue<DoubleData>("ValidationVAF", false).Data;
       model.TestVarianceAccountedFor = bestModelScope.GetVariableValue<DoubleData>("TestVAF", false).Data;
-      
+
       model.Data = bestModelScope.GetVariableValue<SVMModel>("BestValidationModel", false);
       HeuristicLab.DataAnalysis.Dataset ds = bestModelScope.GetVariableValue<Dataset>("Dataset", true);
       model.Dataset = ds;
       model.TargetVariable = ds.GetVariableName(bestModelScope.GetVariableValue<IntData>("TargetVariable", true).Data);
+
+      ItemList evaluationImpacts = bestModelScope.GetVariableValue<ItemList>("VariableEvaluationImpacts", false);
+      ItemList qualityImpacts = bestModelScope.GetVariableValue<ItemList>("VariableQualityImpacts", false);
+      foreach (ItemList row in evaluationImpacts) {
+        string variableName = ((StringData)row[0]).Data;
+        double impact = ((DoubleData)row[0]).Data;
+        model.SetVariableEvaluationImpact(variableName, impact);
+      }
+      foreach (ItemList row in qualityImpacts) {
+        string variableName = ((StringData)row[0]).Data;
+        double impact = ((DoubleData)row[0]).Data;
+        model.SetVariableQualityImpact(variableName, impact);
+      }
+
       return model;
     }
@@ -337 +402 @@
 
     #endregion
-
   }
 }

trunk/sources/HeuristicLab.SupportVectorMachines/3.2/VariableEvaluationImpactCalculator.cs

@@ -29 +29 @@
 using System.Linq;
 
-namespace HeuristicLab.GP.StructureIdentification {
+namespace HeuristicLab.SupportVectorMachines {
   public class VariableEvaluationImpactCalculator : HeuristicLab.Modeling.VariableEvaluationImpactCalculator {
 
     public VariableEvaluationImpactCalculator()
       : base() {
-      AddVariableInfo(new VariableInfo("TreeEvaluator", "The evaluator that should be used to evaluate the expression tree", typeof(ITreeEvaluator), VariableKind.In));
-      AddVariableInfo(new VariableInfo("FunctionTree", "The function tree that should be evaluated", typeof(IFunctionTree), VariableKind.In));
-      AddVariableInfo(new VariableInfo("TreeSize", "Size (number of nodes) of the tree to evaluate", typeof(IntData), VariableKind.In));
-      AddVariableInfo(new VariableInfo("PunishmentFactor", "Punishment factor for invalid estimations", typeof(DoubleData), VariableKind.In));
+      AddVariableInfo(new VariableInfo("SVMModel", "The model that should be evaluated", typeof(SVMModel), VariableKind.In));
     }
 
 
-    protected override double[] GetOutputs(IScope scope, Dataset dataset, int targetVariable, int start, int end) {
-      ITreeEvaluator evaluator = GetVariableValue<ITreeEvaluator>("TreeEvaluator", scope, true);
-      IFunctionTree tree = GetVariableValue<IFunctionTree>("FunctionTree", scope, true);
-      double punishmentFactor = GetVariableValue<DoubleData>("PunishmentFactor", scope, true).Data;
-      evaluator.PrepareForEvaluation(dataset, targetVariable, start, end, punishmentFactor, tree);
+    protected override double[] GetOutputs(IScope scope, Dataset dataset, int targetVariable, ItemList<IntData> allowedFeatures, int start, int end) {
+      SVMModel model = GetVariableValue<SVMModel>("SVMModel", scope, true);
+      SVM.Problem problem = SVMHelper.CreateSVMProblem(dataset, allowedFeatures, targetVariable, start, end);
+      SVM.Problem scaledProblem = SVM.Scaling.Scale(problem, model.RangeTransform);
 
-      double[] result = new double[end - start];
-      for (int i = start; i < end; i++) {
-        result[i - start] = evaluator.Evaluate(i);
+      double[] values = new double[end - start];
+      for (int i = 0; i < end - start; i++) {
+        values[i] = SVM.Prediction.Predict(model.Model, scaledProblem.X[i]);
       }
-
-      return result;
+      return values;
     }
   }

trunk/sources/HeuristicLab.SupportVectorMachines/3.2/VariableQualityImpactCalculator.cs

@@ -29 +29 @@
 using System.Linq;
 
-namespace HeuristicLab.GP.StructureIdentification {
+namespace HeuristicLab.SupportVectorMachines {
   public class VariableQualityImpactCalculator : HeuristicLab.Modeling.VariableQualityImpactCalculator {
 
     public VariableQualityImpactCalculator()
       : base() {
-      AddVariableInfo(new VariableInfo("TreeEvaluator", "The evaluator that should be used to evaluate the expression tree", typeof(ITreeEvaluator), VariableKind.In));
-      AddVariableInfo(new VariableInfo("FunctionTree", "The function tree that should be evaluated", typeof(IFunctionTree), VariableKind.In));
-      AddVariableInfo(new VariableInfo("TreeSize", "Size (number of nodes) of the tree to evaluate", typeof(IntData), VariableKind.In));
-      AddVariableInfo(new VariableInfo("PunishmentFactor", "Punishment factor for invalid estimations", typeof(DoubleData), VariableKind.In));
+      AddVariableInfo(new VariableInfo("SVMModel", "The model that should be evaluated", typeof(SVMModel), VariableKind.In));
     }
 
-    protected override double CalculateQuality(IScope scope, Dataset dataset, int targetVariable, int start, int end) {
-      ITreeEvaluator evaluator = GetVariableValue<ITreeEvaluator>("TreeEvaluator", scope, true);
-      IFunctionTree tree = GetVariableValue<IFunctionTree>("FunctionTree", scope, true);
-      double punishmentFactor = GetVariableValue<DoubleData>("PunishmentFactor", scope, true).Data;
-      evaluator.PrepareForEvaluation(dataset, targetVariable, start, end, punishmentFactor, tree);
+    protected override double CalculateQuality(IScope scope, Dataset dataset, int targetVariable, ItemList<IntData> allowedFeatures, int start, int end) {
+      SVMModel model = GetVariableValue<SVMModel>("SVMModel", scope, true);
+      SVM.Problem problem = SVMHelper.CreateSVMProblem(dataset, allowedFeatures, targetVariable, start, end);
+      SVM.Problem scaledProblem = SVM.Scaling.Scale(problem, model.RangeTransform);
 
-      double[,] result = new double[end - start,2];
-      for (int i = start; i < end; i++) {
-        result[i - start, 0] = dataset.GetValue(i, targetVariable);
-        result[i - start,1] = evaluator.Evaluate(i);
+      double[,] values = new double[end - start, 2];
+      for (int i = 0; i < end - start; i++) {
+        values[i, 0] = SVM.Prediction.Predict(model.Model, scaledProblem.X[i]);
+        values[i, 1] = dataset.GetValue(start + i,targetVariable);
       }
 
-      return HeuristicLab.Modeling.SimpleMSEEvaluator.Calculate(result);
+      return HeuristicLab.Modeling.SimpleMSEEvaluator.Calculate(values);
     }
   }