Changeset 3877 for trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/SupportVectorMachine

Timestamp:

05/31/10 16:03:37 (15 years ago)

Author:

gkronber

Message:

Added linear regression and support vector machine algorithms for data analysis. #1012, #1009

Location:

trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/SupportVectorMachine

Files:

• ParameterAdjustmentProblem (added)
• ParameterAdjustmentProblem/SupportVectorRegressionParameterAdjustmentEvaluator.cs (added)
• ParameterAdjustmentProblem/SupportVectorRegressionParameterAdjustmentProblem.cs (added)
• SupportVectorMachineCrossValidationEvaluator.cs (added)
• SupportVectorMachineModelCreator.cs (modified) (6 diffs)

trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/SupportVectorMachine/SupportVectorMachineModelCreator.cs

@@ -46 +46 @@
     private const string NuParameterName = "Nu";
     private const string GammaParameterName = "Gamma";
+    private const string EpsilonParameterName = "Epsilon";
+    private const string SamplesStartParameterName = "SamplesStart";
+    private const string SamplesEndParameterName = "SamplesEnd";
     private const string ModelParameterName = "SupportVectorMachineModel";
 
@@ -52 +55 @@
       get { return (IValueLookupParameter<DataAnalysisProblemData>)Parameters[DataAnalysisProblemDataParameterName]; }
     }
-    public IValueParameter<StringValue> SvmTypeParameter {
-      get { return (IValueParameter<StringValue>)Parameters[SvmTypeParameterName]; }
+    public IValueLookupParameter<StringValue> SvmTypeParameter {
+      get { return (IValueLookupParameter<StringValue>)Parameters[SvmTypeParameterName]; }
     }
-    public IValueParameter<StringValue> KernelTypeParameter {
-      get { return (IValueParameter<StringValue>)Parameters[KernelTypeParameterName]; }
+    public IValueLookupParameter<StringValue> KernelTypeParameter {
+      get { return (IValueLookupParameter<StringValue>)Parameters[KernelTypeParameterName]; }
     }
     public IValueLookupParameter<DoubleValue> NuParameter {
@@ -66 +69 @@
     public IValueLookupParameter<DoubleValue> GammaParameter {
       get { return (IValueLookupParameter<DoubleValue>)Parameters[GammaParameterName]; }
+    }
+    public IValueLookupParameter<DoubleValue> EpsilonParameter {
+      get { return (IValueLookupParameter<DoubleValue>)Parameters[EpsilonParameterName]; }
+    }
+    public IValueLookupParameter<IntValue> SamplesStartParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters[SamplesStartParameterName]; }
+    }
+    public IValueLookupParameter<IntValue> SamplesEndParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters[SamplesEndParameterName]; }
     }
     public ILookupParameter<SupportVectorMachineModel> SupportVectorMachineModelParameter {
@@ -90 +102 @@
       get { return GammaParameter.ActualValue; }
     }
+    public DoubleValue Epsilon {
+      get { return EpsilonParameter.ActualValue; }
+    }
+    public IntValue SamplesStart {
+      get { return SamplesStartParameter.ActualValue; }
+    }
+    public IntValue SamplesEnd {
+      get { return SamplesEndParameter.ActualValue; }
+    }
     #endregion
 
     public SupportVectorMachineModelCreator()
       : base() {
-      #region svm types
-      StringValue cSvcType = new StringValue("C_SVC").AsReadOnly();
-      StringValue nuSvcType = new StringValue("NU_SVC").AsReadOnly();
-      StringValue eSvrType = new StringValue("EPSILON_SVR").AsReadOnly();
       StringValue nuSvrType = new StringValue("NU_SVR").AsReadOnly();
-      ItemSet<StringValue> allowedSvmTypes = new ItemSet<StringValue>();
-      allowedSvmTypes.Add(cSvcType);
-      allowedSvmTypes.Add(nuSvcType);
-      allowedSvmTypes.Add(eSvrType);
-      allowedSvmTypes.Add(nuSvrType);
-      #endregion
-      #region kernel types
       StringValue rbfKernelType = new StringValue("RBF").AsReadOnly();
-      StringValue linearKernelType = new StringValue("LINEAR").AsReadOnly();
-      StringValue polynomialKernelType = new StringValue("POLY").AsReadOnly();
-      StringValue sigmoidKernelType = new StringValue("SIGMOID").AsReadOnly();
-      ItemSet<StringValue> allowedKernelTypes = new ItemSet<StringValue>();
-      allowedKernelTypes.Add(rbfKernelType);
-      allowedKernelTypes.Add(linearKernelType);
-      allowedKernelTypes.Add(polynomialKernelType);
-      allowedKernelTypes.Add(sigmoidKernelType);
-      #endregion
       Parameters.Add(new ValueLookupParameter<DataAnalysisProblemData>(DataAnalysisProblemDataParameterName, "The data analysis problem data to use for training."));
-      Parameters.Add(new ConstrainedValueParameter<StringValue>(SvmTypeParameterName, "The type of SVM to use.", allowedSvmTypes, nuSvrType));
-      Parameters.Add(new ConstrainedValueParameter<StringValue>(KernelTypeParameterName, "The kernel type to use for the SVM.", allowedKernelTypes, rbfKernelType));
+      Parameters.Add(new ValueLookupParameter<StringValue>(SvmTypeParameterName, "The type of SVM to use.", nuSvrType));
+      Parameters.Add(new ValueLookupParameter<StringValue>(KernelTypeParameterName, "The kernel type to use for the SVM.", rbfKernelType));
       Parameters.Add(new ValueLookupParameter<DoubleValue>(NuParameterName, "The value of the nu parameter nu-SVC, one-class SVM and nu-SVR."));
       Parameters.Add(new ValueLookupParameter<DoubleValue>(CostParameterName, "The value of the C (cost) parameter of C-SVC, epsilon-SVR and nu-SVR."));
       Parameters.Add(new ValueLookupParameter<DoubleValue>(GammaParameterName, "The value of the gamma parameter in the kernel function."));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>(EpsilonParameterName, "The value of the epsilon parameter for epsilon-SVR."));
+      Parameters.Add(new ValueLookupParameter<IntValue>(SamplesStartParameterName, "The first index of the data set partition the support vector machine should use for training."));
+      Parameters.Add(new ValueLookupParameter<IntValue>(SamplesEndParameterName, "The last index of the data set partition the support vector machine should use for training."));
       Parameters.Add(new LookupParameter<SupportVectorMachineModel>(ModelParameterName, "The result model generated by the SVM."));
     }
 
     public override IOperation Apply() {
-
       SupportVectorMachineModel model = TrainModel(DataAnalysisProblemData,
+                             SamplesStart.Value, SamplesEnd.Value,
                              SvmType.Value, KernelType.Value,
-                             Cost.Value, Nu.Value, Gamma.Value);
+                             Cost.Value, Nu.Value, Gamma.Value, Epsilon.Value);
       SupportVectorMachineModelParameter.ActualValue = model;
 
@@ -135 +139 @@
     }
 
+    private static SupportVectorMachineModel TrainModel(
+      DataAnalysisProblemData problemData,
+      string svmType, string kernelType,
+      double cost, double nu, double gamma, double epsilon) {
+      return TrainModel(problemData, problemData.TrainingSamplesStart.Value, problemData.TrainingSamplesEnd.Value, svmType, kernelType, cost, nu, gamma, epsilon);
+    }
+
     public static SupportVectorMachineModel TrainModel(
       DataAnalysisProblemData problemData,
+      int start, int end,
       string svmType, string kernelType,
-      double cost, double nu, double gamma) {
+      double cost, double nu, double gamma, double epsilon) {
       int targetVariableIndex = problemData.Dataset.GetVariableIndex(problemData.TargetVariable.Value);
 
@@ -148 +160 @@
       parameter.Nu = nu;
       parameter.Gamma = gamma;
+      parameter.P = epsilon;
       parameter.CacheSize = 500;
       parameter.Probability = false;
 
 
-      SVM.Problem problem = SupportVectorMachineUtil.CreateSvmProblem(problemData, problemData.TrainingSamplesStart.Value, problemData.TrainingSamplesEnd.Value);
+      SVM.Problem problem = SupportVectorMachineUtil.CreateSvmProblem(problemData, start, end);
       SVM.RangeTransform rangeTransform = SVM.RangeTransform.Compute(problem);
       SVM.Problem scaledProblem = Scaling.Scale(rangeTransform, problem);
       var model = new SupportVectorMachineModel();
-
       model.Model = SVM.Training.Train(scaledProblem, parameter);
       model.RangeTransform = rangeTransform;