Changeset 4391 for branches/HeuristicLab.Classification/HeuristicLab.Problems.DataAnalysis.Classification

Timestamp:

09/14/10 18:46:12 (14 years ago)

Author:

mkommend

Message:

updated classification branch (ticket #939)

Location:

branches/HeuristicLab.Classification/HeuristicLab.Problems.DataAnalysis.Classification/3.3

Files:

• ClassificationProblemData.cs (modified) (3 diffs)
• HeuristicLab.Problems.DataAnalysis.Classification-3.3.csproj (moved) (moved from branches/HeuristicLab.Classification/HeuristicLab.Problems.DataAnalysis.Classification/3.3/HeuristicLab.Problems.DataAnalysis.Classification.csproj) (1 diff)
• Interfaces/ISymbolicClassificationAnalyzer.cs (modified) (1 diff)
• Interfaces/ISymbolicClassificationEvaluator.cs (modified) (1 diff)
• Symbolic/Analyzer/ValidationBestSymbolicClassificationSolutionAnalyzer.cs (modified) (11 diffs)
• Symbolic/Evaluators (added)
• Symbolic/Evaluators/SymbolicClassificationMeanSquaredErrorEvaluator.cs (moved) (moved from branches/HeuristicLab.Classification/HeuristicLab.Problems.DataAnalysis.Classification/3.3/Symbolic/SymbolicClassificationMeanSquaredErrorEvaluator.cs) (1 diff)
• Symbolic/SingleObjectiveSymbolicClassificationEvaluator.cs (deleted)
• Symbolic/SymbolicClassificationProblem.cs (modified) (4 diffs)
• Symbolic/SymbolicClassificationSolution.cs (modified) (8 diffs)

branches/HeuristicLab.Classification/HeuristicLab.Problems.DataAnalysis.Classification/3.3/ClassificationProblemData.cs

@@ -34 +34 @@
   [StorableClass]
   public class ClassificationProblemData : DataAnalysisProblemData {
+    #region default data
+    private static string[] defaultInputs = new string[] { "sample", "clump thickness", "cell size", "cell shape", "marginal adhesion", "epithelial cell size", "bare nuclei", "chromatin", "nucleoli", "mitoses", "class" };
+    private static double[,] defaultData = new double[,]{
+     {1000025,5,1,1,1,2,1,3,1,1,2      },
+     {1002945,5,4,4,5,7,10,3,2,1,2     },
+     {1015425,3,1,1,1,2,2,3,1,1,2      },
+     {1016277,6,8,8,1,3,4,3,7,1,2      },
+     {1017023,4,1,1,3,2,1,3,1,1,2      },
+     {1017122,8,10,10,8,7,10,9,7,1,4   },
+     {1018099,1,1,1,1,2,10,3,1,1,2     },
+     {1018561,2,1,2,1,2,1,3,1,1,2      },
+     {1033078,2,1,1,1,2,1,1,1,5,2      },
+     {1033078,4,2,1,1,2,1,2,1,1,2      },
+     {1035283,1,1,1,1,1,1,3,1,1,2      },
+     {1036172,2,1,1,1,2,1,2,1,1,2      },
+     {1041801,5,3,3,3,2,3,4,4,1,4      },
+     {1043999,1,1,1,1,2,3,3,1,1,2      },
+     {1044572,8,7,5,10,7,9,5,5,4,4     },
+     {1047630,7,4,6,4,6,1,4,3,1,4      },
+     {1048672,4,1,1,1,2,1,2,1,1,2      },
+     {1049815,4,1,1,1,2,1,3,1,1,2      },
+     {1050670,10,7,7,6,4,10,4,1,2,4    },
+     {1050718,6,1,1,1,2,1,3,1,1,2      },
+     {1054590,7,3,2,10,5,10,5,4,4,4    },
+     {1054593,10,5,5,3,6,7,7,10,1,4    },
+     {1056784,3,1,1,1,2,1,2,1,1,2      },
+     {1057013,8,4,5,1,2,2,7,3,1,4      },
+     {1059552,1,1,1,1,2,1,3,1,1,2      },
+     {1065726,5,2,3,4,2,7,3,6,1,4      },
+     {1066373,3,2,1,1,1,1,2,1,1,2      },
+     {1066979,5,1,1,1,2,1,2,1,1,2      },
+     {1067444,2,1,1,1,2,1,2,1,1,2      },
+     {1070935,1,1,3,1,2,1,1,1,1,2      },
+     {1070935,3,1,1,1,1,1,2,1,1,2      },
+     {1071760,2,1,1,1,2,1,3,1,1,2      },
+     {1072179,10,7,7,3,8,5,7,4,3,4     },
+     {1074610,2,1,1,2,2,1,3,1,1,2      },
+     {1075123,3,1,2,1,2,1,2,1,1,2      },
+     {1079304,2,1,1,1,2,1,2,1,1,2      },
+     {1080185,10,10,10,8,6,1,8,9,1,4   },
+     {1081791,6,2,1,1,1,1,7,1,1,2      },
+     {1084584,5,4,4,9,2,10,5,6,1,4     },
+     {1091262,2,5,3,3,6,7,7,5,1,4      },
+     {1096800,6,6,6,9,6,4,7,8,1,2      },
+     {1099510,10,4,3,1,3,3,6,5,2,4     },
+     {1100524,6,10,10,2,8,10,7,3,3,4   },
+     {1102573,5,6,5,6,10,1,3,1,1,4     },
+     {1103608,10,10,10,4,8,1,8,10,1,4  },
+     {1103722,1,1,1,1,2,1,2,1,2,2      },
+     {1105257,3,7,7,4,4,9,4,8,1,4      },
+     {1105524,1,1,1,1,2,1,2,1,1,2      },
+     {1106095,4,1,1,3,2,1,3,1,1,2      },
+     {1106829,7,8,7,2,4,8,3,8,2,4      },
+     {1108370,9,5,8,1,2,3,2,1,5,4      },
+     {1108449,5,3,3,4,2,4,3,4,1,4      },
+     {1110102,10,3,6,2,3,5,4,10,2,4    },
+     {1110503,5,5,5,8,10,8,7,3,7,4     },
+     {1110524,10,5,5,6,8,8,7,1,1,4     },
+     {1111249,10,6,6,3,4,5,3,6,1,4     },
+     {1112209,8,10,10,1,3,6,3,9,1,4    },
+     {1113038,8,2,4,1,5,1,5,4,4,4      },
+     {1113483,5,2,3,1,6,10,5,1,1,4     },
+     {1113906,9,5,5,2,2,2,5,1,1,4      },
+     {1115282,5,3,5,5,3,3,4,10,1,4     },
+     {1115293,1,1,1,1,2,2,2,1,1,2      },
+     {1116116,9,10,10,1,10,8,3,3,1,4   },
+     {1116132,6,3,4,1,5,2,3,9,1,4      },
+     {1116192,1,1,1,1,2,1,2,1,1,2      },
+     {1116998,10,4,2,1,3,2,4,3,10,4    },
+     {1117152,4,1,1,1,2,1,3,1,1,2      },
+     {1118039,5,3,4,1,8,10,4,9,1,4     },
+     {1120559,8,3,8,3,4,9,8,9,8,4      },
+     {1121732,1,1,1,1,2,1,3,2,1,2      },
+     {1121919,5,1,3,1,2,1,2,1,1,2      },
+     {1123061,6,10,2,8,10,2,7,8,10,4   },
+     {1124651,1,3,3,2,2,1,7,2,1,2      },
+     {1125035,9,4,5,10,6,10,4,8,1,4    },
+     {1126417,10,6,4,1,3,4,3,2,3,4     },
+     {1131294,1,1,2,1,2,2,4,2,1,2      },
+     {1132347,1,1,4,1,2,1,2,1,1,2      },
+     {1133041,5,3,1,2,2,1,2,1,1,2      },
+     {1133136,3,1,1,1,2,3,3,1,1,2      },
+     {1136142,2,1,1,1,3,1,2,1,1,2      },
+     {1137156,2,2,2,1,1,1,7,1,1,2      },
+     {1143978,4,1,1,2,2,1,2,1,1,2      },
+     {1143978,5,2,1,1,2,1,3,1,1,2      },
+     {1147044,3,1,1,1,2,2,7,1,1,2      },
+     {1147699,3,5,7,8,8,9,7,10,7,4     },
+     {1147748,5,10,6,1,10,4,4,10,10,4  },
+     {1148278,3,3,6,4,5,8,4,4,1,4      },
+     {1148873,3,6,6,6,5,10,6,8,3,4     },
+     {1152331,4,1,1,1,2,1,3,1,1,2      },
+     {1155546,2,1,1,2,3,1,2,1,1,2      },
+     {1156272,1,1,1,1,2,1,3,1,1,2      },
+     {1156948,3,1,1,2,2,1,1,1,1,2      },
+     {1157734,4,1,1,1,2,1,3,1,1,2      },
+     {1158247,1,1,1,1,2,1,2,1,1,2      },
+     {1160476,2,1,1,1,2,1,3,1,1,2      },
+     {1164066,1,1,1,1,2,1,3,1,1,2      },
+     {1165297,2,1,1,2,2,1,1,1,1,2      },
+     {1165790,5,1,1,1,2,1,3,1,1,2      },
+     {1165926,9,6,9,2,10,6,2,9,10,4    },
+     {1166630,7,5,6,10,5,10,7,9,4,4    },
+     {1166654,10,3,5,1,10,5,3,10,2,4   },
+     {1167439,2,3,4,4,2,5,2,5,1,4      },
+     {1167471,4,1,2,1,2,1,3,1,1,2      },
+     {1168359,8,2,3,1,6,3,7,1,1,4      },
+     {1168736,10,10,10,10,10,1,8,8,8,4 },
+     {1169049,7,3,4,4,3,3,3,2,7,4      },
+     {1170419,10,10,10,8,2,10,4,1,1,4  },
+     {1170420,1,6,8,10,8,10,5,7,1,4    },
+     {1171710,1,1,1,1,2,1,2,3,1,2      },
+     {1171710,6,5,4,4,3,9,7,8,3,4      },
+     {1171795,1,3,1,2,2,2,5,3,2,2      },
+     {1171845,8,6,4,3,5,9,3,1,1,4      },
+     {1172152,10,3,3,10,2,10,7,3,3,4   },
+     {1173216,10,10,10,3,10,8,8,1,1,4  },
+     {1173235,3,3,2,1,2,3,3,1,1,2      },
+     {1173347,1,1,1,1,2,5,1,1,1,2      },
+     {1173347,8,3,3,1,2,2,3,2,1,2      },
+     {1173509,4,5,5,10,4,10,7,5,8,4    },
+     {1173514,1,1,1,1,4,3,1,1,1,2      },
+     {1173681,3,2,1,1,2,2,3,1,1,2      },
+     {1174057,1,1,2,2,2,1,3,1,1,2      },
+     {1174057,4,2,1,1,2,2,3,1,1,2      },
+     {1174131,10,10,10,2,10,10,5,3,3,4 },
+     {1174428,5,3,5,1,8,10,5,3,1,4     },
+     {1175937,5,4,6,7,9,7,8,10,1,4     },
+     {1176406,1,1,1,1,2,1,2,1,1,2      },
+     {1176881,7,5,3,7,4,10,7,5,5,4        }
+};
+    #endregion
+
     private const int MaximumClasses = 20;
     private const string ClassNamesParameterName = "ClassNames";
@@ -64 +197 @@
 
     public ClassificationProblemData()
-      : base() {
+      : base(new Dataset(defaultInputs, defaultData), defaultInputs, defaultInputs[defaultInputs.Length - 1], 0, 60, 60, 120) {
       Parameters.Add(new ValueParameter<StringArray>(ClassNamesParameterName, "An array of the names for all class values."));
       Parameters.Add(new ValueParameter<DoubleMatrix>(MisclassificationMatrixParameterName, "A matrix that describles the penalties for misclassifaction between the single classes."));
       sortedClassValues = new List<double>();
 
+      InputVariables.SetItemCheckedState(InputVariables[InputVariables.Count - 1], false);
       RegisterParameterEvents();
       UpdateClassValues();
@@ -173 +307 @@
 
     private void UpdateMisclassifciationMatrixHeaders() {
-      MisclassificationMatrix.RowNames = ClassNames;
-      MisclassificationMatrix.ColumnNames = ClassNames;
+      MisclassificationMatrix.RowNames = ClassNames.Select(name => "Estimated " + name);
+      MisclassificationMatrix.ColumnNames = ClassNames.Select(name => "Actual " + name);
     }
 

branches/HeuristicLab.Classification/HeuristicLab.Problems.DataAnalysis.Classification/3.3/HeuristicLab.Problems.DataAnalysis.Classification-3.3.csproj

@@ -156 +156 @@
     <Compile Include="Interfaces\ISymbolicClassificationAnalyzer.cs" />
     <Compile Include="Symbolic\Analyzer\ValidationBestSymbolicClassificationSolutionAnalyzer.cs" />
+    <Compile Include="Symbolic\Evaluators\SymbolicClassificationPearsonRSquaredEvaluator.cs" />
     <Compile Include="Symbolic\SymbolicClassificationSolution.cs" />
-    <Compile Include="Symbolic\SingleObjectiveSymbolicClassificationEvaluator.cs" />
-    <Compile Include="Symbolic\SymbolicClassificationMeanSquaredErrorEvaluator.cs" />
+    <Compile Include="Symbolic\Evaluators\SymbolicClassificationMeanSquaredErrorEvaluator.cs" />
     <Compile Include="Symbolic\SymbolicClassificationProblem.cs" />
   </ItemGroup>

branches/HeuristicLab.Classification/HeuristicLab.Problems.DataAnalysis.Classification/3.3/Interfaces/ISymbolicClassificationAnalyzer.cs

@@ -20 +20 @@
 #endregion
 
-using HeuristicLab.Core;
-using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
-using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Interfaces;
-using HeuristicLab.Optimization;
-using HeuristicLab.Parameters;
-
-// This interface is exactly the same as ISymbolicRegressionAnalyzer
-// consider creating a base interface for both analyzer
-
+using HeuristicLab.Problems.DataAnalysis.Regression.Symbolic.Analyzers;
 namespace HeuristicLab.Problems.DataAnalysis.Classification {
-  public interface ISymbolicClassificationAnalyzer : ISymbolicExpressionTreeAnalyzer {
-    ILookupParameter<ResultCollection> ResultsParameter { get; }
+  public interface ISymbolicClassificationAnalyzer : ISymbolicRegressionAnalyzer {
   }
 }

branches/HeuristicLab.Classification/HeuristicLab.Problems.DataAnalysis.Classification/3.3/Interfaces/ISymbolicClassificationEvaluator.cs

@@ -20 +20 @@
 #endregion
 
-using System.Collections.Generic;
-using HeuristicLab.Core;
-using HeuristicLab.Data;
-using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
-using HeuristicLab.Optimization;
-using HeuristicLab.Problems.DataAnalysis.Symbolic;
+using HeuristicLab.Problems.DataAnalysis.Regression.Symbolic;
 namespace HeuristicLab.Problems.DataAnalysis.Classification {
-  public interface ISymbolicClassificationEvaluator : ISingleObjectiveEvaluator {
-    ILookupParameter<ISymbolicExpressionTreeInterpreter> SymbolicExpressionTreeInterpreterParameter { get; }
-    ILookupParameter<SymbolicExpressionTree> SymbolicExpressionTreeParameter { get; }
-    ILookupParameter<ClassificationProblemData> RegressionProblemDataParameter { get; }
-    IValueLookupParameter<IntValue> SamplesStartParameter { get; }
-    IValueLookupParameter<IntValue> SamplesEndParameter { get; }
-    IValueLookupParameter<DoubleValue> UpperEstimationLimitParameter { get; }
-    IValueLookupParameter<DoubleValue> LowerEstimationLimitParameter { get; }
-
-
-    double Evaluate(ISymbolicExpressionTreeInterpreter interpreter, SymbolicExpressionTree tree,
-          double lowerEstimationLimit, double upperEstimationLimit,
-          Dataset dataset, string targetVariable, IEnumerable<double> sortedClassValues, IEnumerable<int> rows);
+  public interface ISymbolicClassificationEvaluator : ISymbolicRegressionEvaluator {
+    ClassificationProblemData ClassificationProblemData { get; }
   }
 }

branches/HeuristicLab.Classification/HeuristicLab.Problems.DataAnalysis.Classification/3.3/Symbolic/Analyzer/ValidationBestSymbolicClassificationSolutionAnalyzer.cs

@@ -21 +21 @@
 
 using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Analysis;
 using HeuristicLab.Core;
 using HeuristicLab.Data;
@@ -29 +31 @@
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 using HeuristicLab.Problems.DataAnalysis.Regression.Symbolic;
+using HeuristicLab.Problems.DataAnalysis.Regression.Symbolic.Analyzers;
 using HeuristicLab.Problems.DataAnalysis.Symbolic;
 
@@ -50 +53 @@
 
     private const string ResultsParameterName = "Results";
-    private const string BestValidationQualityParameterName = "BestValidationQuality";
-    private const string BestValidationSolutionParameterName = "BestValidationSolution";
+    private const string BestValidationQualityParameterName = "Best validation quality";
+    private const string BestValidationSolutionParameterName = "Best validation solution";
+    private const string BestSolutionGenerationParameterName = "Best solution generation";
+    private const string BestSolutionInputvariableCountParameterName = "Variables used by best solution";
+    private const string VariableFrequenciesParameterName = "VariableFrequencies";
+    private const string VariableImpactsParameterName = "Variable Impacts";
 
     #region parameter properties
@@ -91 +98 @@
       get { return (IValueLookupParameter<DoubleValue>)Parameters[LowerEstimationLimitParameterName]; }
     }
+    public ILookupParameter<DataTable> VariableFrequenciesParameter {
+      get { return (ILookupParameter<DataTable>)Parameters[VariableFrequenciesParameterName]; }
+    }
 
     public ILookupParameter<ResultCollection> ResultsParameter {
@@ -100 +110 @@
     public ILookupParameter<SymbolicClassificationSolution> BestValidationSolutionParameter {
       get { return (ILookupParameter<SymbolicClassificationSolution>)Parameters[BestValidationSolutionParameterName]; }
+    }
+    public ILookupParameter<IntValue> BestSolutionGenerationParameter {
+      get { return (ILookupParameter<IntValue>)Parameters[BestSolutionGenerationParameterName]; }
+    }
+    public ILookupParameter<DoubleMatrix> VariableImpactsParameter {
+      get { return (ILookupParameter<DoubleMatrix>)Parameters[VariableImpactsParameterName]; }
+    }
+    public ILookupParameter<IntValue> BestSolutionInputvariableCountParameter {
+      get { return (ILookupParameter<IntValue>)Parameters[BestSolutionInputvariableCountParameterName]; }
     }
     #endregion
@@ -140 +159 @@
       get { return LowerEstimationLimitParameter.ActualValue; }
     }
+    public DataTable VariableFrequencies {
+      get { return VariableFrequenciesParameter.ActualValue; }
+    }
 
     public ResultCollection Results {
@@ -151 +173 @@
       get { return BestValidationSolutionParameter.ActualValue; }
       protected set { BestValidationSolutionParameter.ActualValue = value; }
+    }
+    public IntValue BestSolutionGeneration {
+      get { return BestSolutionGenerationParameter.ActualValue; }
+      protected set { BestSolutionGenerationParameter.ActualValue = value; }
+    }
+    public IntValue BestSolutionInputvariableCount {
+      get { return BestSolutionInputvariableCountParameter.ActualValue; }
+      protected set { BestSolutionInputvariableCountParameter.ActualValue = value; }
+    }
+    public DoubleMatrix VariableImpacts {
+      get { return VariableImpactsParameter.ActualValue; }
+      protected set { VariableImpactsParameter.ActualValue = value; }
     }
     #endregion
@@ -169 +203 @@
       Parameters.Add(new ValueLookupParameter<DoubleValue>(UpperEstimationLimitParameterName, "The upper estimation limit that was set for the evaluation of the symbolic expression trees."));
       Parameters.Add(new ValueLookupParameter<DoubleValue>(LowerEstimationLimitParameterName, "The lower estimation limit that was set for the evaluation of the symbolic expression trees."));
+      Parameters.Add(new LookupParameter<DataTable>(VariableFrequenciesParameterName, "The variable frequencies table to use for the calculation of variable impacts"));
 
       Parameters.Add(new ValueLookupParameter<ResultCollection>(ResultsParameterName, "The results collection where the analysis values should be stored."));
       Parameters.Add(new LookupParameter<DoubleValue>(BestValidationQualityParameterName, "The validation quality of the best solution in the current run."));
       Parameters.Add(new LookupParameter<SymbolicClassificationSolution>(BestValidationSolutionParameterName, "The best solution on the validation data found in the current run."));
+      Parameters.Add(new LookupParameter<IntValue>(BestSolutionGenerationParameterName, "The generation in which the best solution was found."));
+      Parameters.Add(new LookupParameter<DoubleMatrix>(VariableImpactsParameterName, "The impacts of the input variables calculated during the run."));
+      Parameters.Add(new LookupParameter<IntValue>(BestSolutionInputvariableCountParameterName, "The number of input variables used by the best solution."));
+
     }
 
@@ -199 +238 @@
         double quality = Evaluator.Evaluate(SymbolicExpressionTreeInterpreter, tree,
           lowerEstimationLimit, upperEstimationLimit, ClassificationProblemData.Dataset,
-          targetVariable, ClassificationProblemData.SortedClassValues, rows);
+          targetVariable, rows);
 
         if ((Maximization.Value && quality > bestQuality) ||
@@ -214 +253 @@
         (!Maximization.Value && bestQuality < BestValidationQuality.Value);
       if (newBest) {
+        double alpha, beta;
+        int trainingStart = ClassificationProblemData.TrainingSamplesStart.Value;
+        int trainingEnd = ClassificationProblemData.TrainingSamplesEnd.Value;
+        IEnumerable<int> trainingRows = Enumerable.Range(trainingStart, trainingEnd - trainingStart);
+        SymbolicRegressionScaledMeanSquaredErrorEvaluator.Calculate(SymbolicExpressionTreeInterpreter, bestTree,
+          lowerEstimationLimit, upperEstimationLimit,
+          ClassificationProblemData.Dataset, targetVariable,
+          trainingRows, out beta, out alpha);
+
+        // scale tree for solution
+        var scaledTree = SymbolicRegressionSolutionLinearScaler.Scale(bestTree, alpha, beta);
         var model = new SymbolicRegressionModel((ISymbolicExpressionTreeInterpreter)SymbolicExpressionTreeInterpreter.Clone(),
-          bestTree);
+          scaledTree);
 
         if (BestValidationSolution == null) {
@@ -222 +272 @@
           BestValidationSolution.Description = "Best solution on validation partition found over the whole run.";
           BestValidationQuality = new DoubleValue(bestQuality);
+          BestSolutionGeneration = (IntValue)Generations.Clone();
+          BestSolutionInputvariableCount = new IntValue(BestValidationSolution.Model.InputVariables.Count());
+
           Results.Add(new Result(BestValidationSolutionParameterName, BestValidationSolution));
           Results.Add(new Result(BestValidationQualityParameterName, BestValidationQuality));
+          Results.Add(new Result(BestSolutionGenerationParameterName, BestSolutionGeneration));
+
+          Results.Add(new Result(BestSolutionInputvariableCountParameterName, BestSolutionInputvariableCount));
+
+          if (VariableFrequencies != null) {
+            VariableImpacts = CalculateVariableImpacts(VariableFrequencies);
+            Results.Add(new Result(VariableImpactsParameterName, VariableImpacts));
+          }
 
         } else {
           BestValidationSolution.Model = model;
           BestValidationQuality.Value = bestQuality;
+          BestSolutionGeneration.Value = Generations.Value;
+          BestSolutionInputvariableCount.Value = BestValidationSolution.Model.InputVariables.Count();
+
+          if (VariableFrequencies != null) {
+            VariableImpacts = CalculateVariableImpacts(VariableFrequencies);
+            Results[VariableImpactsParameterName].Value = VariableImpacts;
+          }
         }
       }
       return base.Apply();
     }
+
+    private static DoubleMatrix CalculateVariableImpacts(DataTable variableFrequencies) {
+      if (variableFrequencies != null) {
+        var impacts = new DoubleMatrix(variableFrequencies.Rows.Count, 1, new string[] { "Impact" }, variableFrequencies.Rows.Select(x => x.Name));
+        impacts.SortableView = true;
+        int rowIndex = 0;
+        foreach (var dataRow in variableFrequencies.Rows) {
+          string variableName = dataRow.Name;
+          impacts[rowIndex++, 0] = dataRow.Values.Average();
+        }
+        return impacts;
+      } else return new DoubleMatrix(1, 1);
+    }
   }
 }

branches/HeuristicLab.Classification/HeuristicLab.Problems.DataAnalysis.Classification/3.3/Symbolic/Evaluators/SymbolicClassificationMeanSquaredErrorEvaluator.cs

@@ -20 +20 @@
 #endregion
 
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Problems.DataAnalysis.Evaluators;
-using HeuristicLab.Problems.DataAnalysis.Symbolic;
+using HeuristicLab.Problems.DataAnalysis.Regression.Symbolic;
 
 namespace HeuristicLab.Problems.DataAnalysis.Classification {
   [Item("SymbolicClassificationMeanSquaredErrorEvaluator", "Calculates the mean squared error of a symbolic classification solution.")]
   [StorableClass]
-  public class SymbolicClassifacitionMeanSquaredErrorEvaluator : SingleObjectiveSymbolicClassificationEvaluator {
+  public class SymbolicClassifacitionMeanSquaredErrorEvaluator : SymbolicRegressionMeanSquaredErrorEvaluator, ISymbolicClassificationEvaluator {
+    public ClassificationProblemData ClassificationProblemData {
+      get { return (ClassificationProblemData)RegressionProblemData; }
+    }
 
     public SymbolicClassifacitionMeanSquaredErrorEvaluator()
       : base() {
     }
-
-    public override double Evaluate(ISymbolicExpressionTreeInterpreter interpreter, SymbolicExpressionTree solution, double lowerEstimationLimit, double upperEstimationLimit, Dataset dataset, string targetVariable, IEnumerable<double> sortedClassValues, IEnumerable<int> rows) {
-      double mse = Calculate(interpreter, solution, lowerEstimationLimit, upperEstimationLimit, dataset, targetVariable, sortedClassValues, rows);
-      return mse;
-    }
-
-    public static double Calculate(ISymbolicExpressionTreeInterpreter interpreter, SymbolicExpressionTree solution, double lowerEstimationLimit, double upperEstimationLimit, Dataset dataset, string targetVariable, IEnumerable<double> sortedClassValues, IEnumerable<int> rows) {
-      IEnumerable<double> estimatedValues = interpreter.GetSymbolicExpressionTreeValues(solution, dataset, rows);
-      IEnumerable<double> originalValues = dataset.GetEnumeratedVariableValues(targetVariable, rows);
-      IEnumerator<double> originalEnumerator = originalValues.GetEnumerator();
-      IEnumerator<double> estimatedEnumerator = estimatedValues.GetEnumerator();
-      OnlineMeanSquaredErrorEvaluator mseEvaluator = new OnlineMeanSquaredErrorEvaluator();
-
-
-      double firstClassValue = sortedClassValues.First();
-      double lastClassValue = sortedClassValues.Last();
-      while (originalEnumerator.MoveNext() && estimatedEnumerator.MoveNext()) {
-        double estimated = estimatedEnumerator.Current;
-        double original = originalEnumerator.Current;
-        if (double.IsNaN(estimated))
-          estimated = upperEstimationLimit;
-        else if (estimated < original && original.IsAlmost(firstClassValue))
-          estimated = original;
-        else if (estimated > original && original.IsAlmost(lastClassValue))
-          estimated = original;
-        else
-          estimated = Math.Min(upperEstimationLimit, Math.Max(lowerEstimationLimit, estimated));
-        mseEvaluator.Add(original, estimated);
-      }
-
-      if (estimatedEnumerator.MoveNext() || originalEnumerator.MoveNext()) {
-        throw new ArgumentException("Number of elements in original and estimated enumeration doesn't match.");
-      } else {
-        return mseEvaluator.MeanSquaredError;
-      }
-    }
   }
 }

branches/HeuristicLab.Classification/HeuristicLab.Problems.DataAnalysis.Classification/3.3/Symbolic/SymbolicClassificationProblem.cs

@@ -33 +33 @@
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 using HeuristicLab.PluginInfrastructure;
+using HeuristicLab.Problems.DataAnalysis.Regression.Symbolic.Analyzers;
 using HeuristicLab.Problems.DataAnalysis.Symbolic;
 using HeuristicLab.Problems.DataAnalysis.Symbolic.Symbols;
@@ -228 +229 @@
       Operators.AddRange(ApplicationManager.Manager.GetInstances<ISymbolicExpressionTreeOperator>().OfType<IOperator>());
       Operators.Add(new MinAverageMaxSymbolicExpressionTreeSizeAnalyzer());
+      Operators.Add(new SymbolicRegressionVariableFrequencyAnalyzer());
       Operators.Add(new ValidationBestSymbolicClassificationSolutionAnalyzer());
     }
@@ -294 +296 @@
 
     private void ParameterizeAnalyzers() {
-      foreach (ISymbolicExpressionTreeAnalyzer analyzer in Operators.OfType<ISymbolicExpressionTreeAnalyzer>()) {
+      foreach (ISymbolicRegressionAnalyzer analyzer in Operators.OfType<ISymbolicRegressionAnalyzer>()) {
         analyzer.SymbolicExpressionTreeParameter.ActualName = SolutionCreator.SymbolicExpressionTreeParameter.ActualName;
         var bestValidationSolutionAnalyzer = analyzer as ValidationBestSymbolicClassificationSolutionAnalyzer;
@@ -306 +308 @@
           bestValidationSolutionAnalyzer.ValidationSamplesEndParameter.Value = ValidationSamplesEnd;
         }
+        var varFreqAnalyzer = analyzer as SymbolicRegressionVariableFrequencyAnalyzer;
+        if (varFreqAnalyzer != null) {
+          varFreqAnalyzer.ProblemDataParameter.ActualName = ClassificationProblemDataParameter.Name;
+        }
       }
     }

branches/HeuristicLab.Classification/HeuristicLab.Problems.DataAnalysis.Classification/3.3/Symbolic/SymbolicClassificationSolution.cs

@@ -31 +31 @@
 namespace HeuristicLab.Problems.DataAnalysis.Classification {
   /// <summary>
-  /// Represents a solution for a symbolic regression problem which can be visualized in the GUI.
+  /// Represents a solution for a symbolic classification problem which can be visualized in the GUI.
   /// </summary>
   [Item("SymbolicClassificationSolution", "Represents a solution for a symbolic classification problem which can be visualized in the GUI.")]
   [StorableClass]
-  public sealed class SymbolicClassificationSolution : DataAnalysisSolution, IClassificationSolution {
+  public class SymbolicClassificationSolution : DataAnalysisSolution, IClassificationSolution {
     private SymbolicClassificationSolution() : base() { }
     public SymbolicClassificationSolution(ClassificationProblemData problemData, SymbolicRegressionModel model, double lowerEstimationLimit, double upperEstimationLimit)
@@ -46 +46 @@
     }
 
+    public new SymbolicRegressionModel Model {
+      get { return (SymbolicRegressionModel)base.Model; }
+      set { base.Model = value; }
+    }
+
     public new ClassificationProblemData ProblemData {
       get { return (ClassificationProblemData)base.ProblemData; }
       set { base.ProblemData = value; }
-    }
-
-    public new SymbolicRegressionModel Model {
-      get { return (SymbolicRegressionModel)base.Model; }
-      set { base.Model = value; }
     }
 
@@ -65 +65 @@
     }
 
+    protected List<double> estimatedValues;
+    public override IEnumerable<double> EstimatedValues {
+      get {
+        if (estimatedValues == null) RecalculateEstimatedValues();
+        return estimatedValues.AsEnumerable();
+      }
+    }
+
+    public override IEnumerable<double> EstimatedTrainingValues {
+      get {
+        if (estimatedValues == null) RecalculateEstimatedValues();
+        int start = ProblemData.TrainingSamplesStart.Value;
+        int n = ProblemData.TrainingSamplesEnd.Value - start;
+        return estimatedValues.Skip(start).Take(n).ToList();
+      }
+    }
+
+    public override IEnumerable<double> EstimatedTestValues {
+      get {
+        if (estimatedValues == null) RecalculateEstimatedValues();
+        int start = ProblemData.TestSamplesStart.Value;
+        int n = ProblemData.TestSamplesEnd.Value - start;
+        return estimatedValues.Skip(start).Take(n).ToList();
+      }
+    }
+
     private void RecalculateClassIntermediates() {
-      int slices = 1000;
+      int slices = 100;
+
+      List<int> classInstances = (from classValue in ProblemData.Dataset.GetVariableValues(ProblemData.TargetVariable.Value)
+                                  group classValue by classValue into grouping
+                                  select grouping.Count()).ToList();
 
       List<KeyValuePair<double, double>> estimatedTargetValues =
-        (from row in Enumerable.Range(ProblemData.TrainingSamplesStart.Value, ProblemData.TrainingSamplesEnd.Value - ProblemData.TrainingSamplesStart.Value)
-         select new KeyValuePair<double, double>(
-           estimatedValues[row],
-           ProblemData.Dataset[ProblemData.TargetVariable.Value, row])).ToList();
-
-      List<double> originalClasses = ProblemData.Dataset.GetVariableValues(ProblemData.TargetVariable.Value).Distinct().OrderBy(x => x).ToList();
-      int numberOfClasses = originalClasses.Count;
-
-      double[] thresholds = new double[numberOfClasses + 1];
+         (from row in Enumerable.Range(ProblemData.TrainingSamplesStart.Value, ProblemData.TrainingSamplesEnd.Value - ProblemData.TrainingSamplesStart.Value)
+          select new KeyValuePair<double, double>(
+            estimatedValues[row],
+            ProblemData.Dataset[ProblemData.TargetVariable.Value, row])).ToList();
+
+      List<double> originalClasses = ProblemData.SortedClassValues.ToList();
+      double[] thresholds = new double[ProblemData.NumberOfClasses + 1];
       thresholds[0] = double.NegativeInfinity;
       thresholds[thresholds.Length - 1] = double.PositiveInfinity;
-
 
       for (int i = 1; i < thresholds.Length - 1; i++) {
@@ -88 +115 @@
 
         double bestThreshold = double.NaN;
-        double bestQuality = double.NegativeInfinity;
+        double bestClassificationScore = double.PositiveInfinity;
 
         while (actualThreshold < originalClasses[i]) {
-          int truePosivites = 0;
-          int falsePosivites = 0;
-          int trueNegatives = 0;
-          int falseNegatives = 0;
+          double classificationScore = 0.0;
 
           foreach (KeyValuePair<double, double> estimatedTarget in estimatedTargetValues) {
@@ -100 +124 @@
             if (estimatedTarget.Value.IsAlmost(originalClasses[i - 1])) {
               if (estimatedTarget.Key > lowerThreshold && estimatedTarget.Key < actualThreshold)
-                truePosivites++;
+                //true positive
+                classificationScore += ProblemData.MisclassificationMatrix[i - 1, i - 1] / classInstances[i - 1];
               else
-                falseNegatives++;
+                //false negative
+                classificationScore += ProblemData.MisclassificationMatrix[i, i - 1] / classInstances[i - 1];
             }
               //all negatives
             else {
               if (estimatedTarget.Key > lowerThreshold && estimatedTarget.Key < actualThreshold)
-                falsePosivites++;
+                classificationScore += ProblemData.MisclassificationMatrix[i - 1, i] / classInstances[i];
               else
-                trueNegatives++;
+                //true negative, consider only upper class
+                classificationScore += ProblemData.MisclassificationMatrix[i, i] / classInstances[i];
             }
           }
-
-          //mkommend 30.08.2010
-          //matthews correlation coefficient taken from http://en.wikipedia.org/wiki/Matthews_correlation_coefficient
-          //MCC = [(TP * FP) - (FP * FN)] / sqrt((TP + FP) * (TP + FN) * (TN + FP) * (TN + FN))
-          double dividend = truePosivites * falsePosivites - falsePosivites * falseNegatives;
-          double divisor = Math.Sqrt((truePosivites + falsePosivites) * (truePosivites + falsePosivites) *
-            (trueNegatives + falsePosivites) * (trueNegatives + falseNegatives));
-          if (divisor == 0)
-            divisor = 1;
-
-          double mcc = dividend / divisor;
-
-          if (bestQuality < mcc) {
-            bestQuality = mcc;
+          if (classificationScore < bestClassificationScore) {
+            bestClassificationScore = classificationScore;
             bestThreshold = actualThreshold;
           }
@@ -149 +164 @@
         actualThresholds = new List<double>(value);
         OnThresholdsChanged();
-      }
-    }
-
-    private List<double> estimatedValues;
-    public override IEnumerable<double> EstimatedValues {
-      get {
-        if (estimatedValues == null) RecalculateEstimatedValues();
-        return estimatedValues.AsEnumerable();
       }
     }
@@ -172 +179 @@
     }
 
-    public override IEnumerable<double> EstimatedTrainingValues {
-      get {
-        if (estimatedValues == null) RecalculateEstimatedValues();
-        int start = ProblemData.TrainingSamplesStart.Value;
-        int n = ProblemData.TrainingSamplesEnd.Value - start;
-        return estimatedValues.Skip(start).Take(n).ToList();
-      }
-    }
     public IEnumerable<double> EstimatedTrainingClassValues {
       get {
@@ -188 +187 @@
     }
 
-    public override IEnumerable<double> EstimatedTestValues {
-      get {
-        if (estimatedValues == null) RecalculateEstimatedValues();
-        int start = ProblemData.TestSamplesStart.Value;
-        int n = ProblemData.TestSamplesEnd.Value - start;
-        return estimatedValues.Skip(start).Take(n).ToList();
-      }
-    }
     public IEnumerable<double> EstimatedTestClassValues {
       get {