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

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

Files:

• DataAnalysisProblem.cs (modified) (3 diffs)
• HeuristicLab.Problems.DataAnalysis-3.3.csproj (modified) (3 diffs)
• Interfaces (added)
• Interfaces/IDataAnalysisProblem.cs (added)
• SupportVectorMachine/ParameterAdjustmentProblem (added)
• SupportVectorMachine/ParameterAdjustmentProblem/SupportVectorRegressionParameterAdjustmentEvaluator.cs (added)
• SupportVectorMachine/ParameterAdjustmentProblem/SupportVectorRegressionParameterAdjustmentProblem.cs (added)
• SupportVectorMachine/SupportVectorMachineCrossValidationEvaluator.cs (added)
• SupportVectorMachine/SupportVectorMachineModelCreator.cs (modified) (6 diffs)

trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/DataAnalysisProblem.cs

@@ -31 +31 @@
 using System.Drawing;
 using System.IO;
+using HeuristicLab.Optimization;
 
 namespace HeuristicLab.Problems.DataAnalysis {
@@ -36 +37 @@
   [Creatable("Problems")]
   [StorableClass]
-  public class DataAnalysisProblem : ParameterizedNamedItem {
+  public class DataAnalysisProblem : ParameterizedNamedItem, IDataAnalysisProblem {
     private const string DataAnalysisProblemDataParameterName = "DataAnalysisProblemData";
     public override Image ItemImage {
@@ -90 +91 @@
 
     public override IDeepCloneable Clone(Cloner cloner) {
-      DataAnalysisProblem clone = (DataAnalysisProblem) base.Clone(cloner);
+      DataAnalysisProblem clone = (DataAnalysisProblem)base.Clone(cloner);
       clone.RegisterParameterEvents();
       clone.RegisterParameterValueEvents();
       return clone;
     }
+
+    #region IProblem Members
+
+    public virtual IParameter SolutionCreatorParameter {
+      get { return null; }
+    }
+
+    public virtual ISolutionCreator SolutionCreator {
+      get { return null; }
+    }
+
+    public virtual IParameter EvaluatorParameter {
+      get { return null; }
+    }
+
+    public virtual IEvaluator Evaluator {
+      get { return null; }
+    }
+
+    public virtual IEnumerable<IOperator> Operators {
+      get { return new IOperator[0]; }
+    }
+
+    public event EventHandler SolutionCreatorChanged;
+    protected void RaiseSolutionCreatorChanged(EventArgs e) {
+      var changed = SolutionCreatorChanged;
+      if (changed != null)
+        changed(this, e);
+    }
+
+    public event EventHandler EvaluatorChanged;
+    protected void RaiseEvaluatorChanged(EventArgs e) {
+      var changed = EvaluatorChanged;
+      if (changed != null)
+        changed(this, e);
+    }
+
+    public event EventHandler OperatorsChanged;
+    protected void RaiseOperatorsChanged(EventArgs e) {
+      var changed = OperatorsChanged;
+      if (changed != null)
+        changed(this, e);
+    }
+
+    public event EventHandler Reset;
+    protected void RaiseReset(EventArgs e) {
+      var changed = Reset;
+      if (changed != null)
+        changed(this, e);
+    }
+    #endregion
   }
 }

trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/HeuristicLab.Problems.DataAnalysis-3.3.csproj

@@ -98 +98 @@
     <Compile Include="Evaluators\SimpleVarianceAccountedForEvaluator.cs" />
     <Compile Include="HeuristicLabProblemsDataAnalysisPlugin.cs" />
+    <Compile Include="Interfaces\IDataAnalysisProblem.cs" />
     <Compile Include="MatrixExtensions.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="SupportVectorMachine\ParameterAdjustmentProblem\SupportVectorRegressionParameterAdjustmentEvaluator.cs" />
+    <Compile Include="SupportVectorMachine\ParameterAdjustmentProblem\SupportVectorRegressionParameterAdjustmentProblem.cs" />
+    <Compile Include="SupportVectorMachine\SupportVectorMachineCrossValidationEvaluator.cs" />
     <Compile Include="SupportVectorMachine\SupportVectorMachineModel.cs" />
     <Compile Include="SupportVectorMachine\SupportVectorMachineModelCreator.cs" />
@@ -154 +158 @@
       <Name>HeuristicLab.Data-3.3</Name>
     </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Encodings.RealVectorEncoding\3.3\HeuristicLab.Encodings.RealVectorEncoding-3.3.csproj">
+      <Project>{BB6D334A-4BB6-4674-9883-31A6EBB32CAB}</Project>
+      <Name>HeuristicLab.Encodings.RealVectorEncoding-3.3</Name>
+    </ProjectReference>
     <ProjectReference Include="..\..\HeuristicLab.Encodings.SymbolicExpressionTreeEncoding\3.3\HeuristicLab.Encodings.SymbolicExpressionTreeEncoding-3.3.csproj">
       <Project>{125D3006-67F5-48CB-913E-73C0548F17FA}</Project>
@@ -169 +177 @@
       <Project>{23DA7FF4-D5B8-41B6-AA96-F0561D24F3EE}</Project>
       <Name>HeuristicLab.Operators-3.3</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Optimization\3.3\HeuristicLab.Optimization-3.3.csproj">
+      <Project>{14AB8D24-25BC-400C-A846-4627AA945192}</Project>
+      <Name>HeuristicLab.Optimization-3.3</Name>
     </ProjectReference>
     <ProjectReference Include="..\..\HeuristicLab.Parameters\3.3\HeuristicLab.Parameters-3.3.csproj">

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;