Changeset 3884 for trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3

Timestamp:

06/01/10 17:58:03 (14 years ago)

Author:

gkronber

Message:

Worked on support vector regression operators and views. #1009

Location:

trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3

Files:

• DataAnalysisProblem.cs (modified) (1 diff)
• DataAnalysisSolution.cs (modified) (6 diffs)
• HeuristicLab.Problems.DataAnalysis-3.3.csproj (modified) (1 diff)
• Interfaces/IDataAnalysisModel.cs (added)
• SupportVectorMachine/ParameterAdjustmentProblem/SupportVectorMachineParameterAdjustmentBestSolutionAnalyzer.cs (added)
• SupportVectorMachine/ParameterAdjustmentProblem/SupportVectorMachineParameterAdjustmentEvaluator.cs (moved) (moved from trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/SupportVectorMachine/ParameterAdjustmentProblem/SupportVectorRegressionParameterAdjustmentEvaluator.cs) (3 diffs)
• SupportVectorMachine/ParameterAdjustmentProblem/SupportVectorMachineParameterAdjustmentProblem.cs (moved) (moved from trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/SupportVectorMachine/ParameterAdjustmentProblem/SupportVectorRegressionParameterAdjustmentProblem.cs) (12 diffs)
• SupportVectorMachine/SupportVectorMachineCrossValidationEvaluator.cs (modified) (8 diffs)
• SupportVectorMachine/SupportVectorMachineModel.cs (modified) (5 diffs)
• Symbolic/ISymbolicRegressionEvaluator.cs (deleted)

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

@@ -71 +71 @@
 
     #region events
-    protected virtual void OnDataAnalysisProblemChanged(EventArgs e) { }
+    protected virtual void OnDataAnalysisProblemChanged(EventArgs e) {
+      RaiseReset(e);
+    }
 
     private void RegisterParameterEvents() {

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

@@ -36 +36 @@
   [StorableClass]
   public abstract class DataAnalysisSolution : NamedItem {
+    protected DataAnalysisSolution()
+      : base() { }
+    protected DataAnalysisSolution(DataAnalysisProblemData problemData) : this(problemData, double.NegativeInfinity, double.PositiveInfinity) { }
+    protected DataAnalysisSolution(DataAnalysisProblemData problemData, double lowerEstimationLimit, double upperEstimationLimit)
+      : this() {
+      this.problemData = problemData;
+      this.lowerEstimationLimit = lowerEstimationLimit;
+      this.upperEstimationLimit = upperEstimationLimit;
+      Initialize();
+    }
+
+    [StorableConstructor]
+    private DataAnalysisSolution(bool deserializing) : base(deserializing) { }
+    [StorableHook(HookType.AfterDeserialization)]
+    private void Initialize() {
+      if (problemData != null) RegisterProblemDataEvents();
+    }
+
     [Storable]
     private DataAnalysisProblemData problemData;
@@ -43 +61 @@
         if (problemData != value) {
           if (value == null) throw new ArgumentNullException();
+          if (model != null && problemData != null && !problemData.InputVariables.Select(c => c.Value).SequenceEqual(
+            value.InputVariables.Select(c => c.Value)))
+            throw new ArgumentException("Could not set new problem data with different structure");
+
           if (problemData != null) DeregisterProblemDataEvents();
           problemData = value;
           RegisterProblemDataEvents();
-          OnProblemDataChanged(EventArgs.Empty);
+          OnProblemDataChanged();
         }
       }
     }
+
+    [Storable]
+    private IDataAnalysisModel model;
+    public IDataAnalysisModel Model {
+      get { return model; }
+      set {
+        if (model != value) {
+          if (value == null) throw new ArgumentNullException();
+          model = value;
+          OnModelChanged();
+        }
+      }
+    }
+
     [Storable]
     private double lowerEstimationLimit;
@@ -57 +93 @@
         if (lowerEstimationLimit != value) {
           lowerEstimationLimit = value;
-          OnEstimatedValuesChanged(EventArgs.Empty);
+          RecalculateEstimatedValues();
         }
       }
@@ -69 +105 @@
         if (upperEstimationLimit != value) {
           upperEstimationLimit = value;
-          OnEstimatedValuesChanged(EventArgs.Empty);
+          RecalculateEstimatedValues();
         }
       }
@@ -77 +113 @@
     public abstract IEnumerable<double> EstimatedTrainingValues { get; }
     public abstract IEnumerable<double> EstimatedTestValues { get; }
-
-    protected DataAnalysisSolution() : base() {
-      Name = ItemName;
-      Description = ItemDescription;
-    }
-    protected DataAnalysisSolution(DataAnalysisProblemData problemData) : this(problemData, double.NegativeInfinity, double.PositiveInfinity) { }
-    protected DataAnalysisSolution(DataAnalysisProblemData problemData, double lowerEstimationLimit, double upperEstimationLimit)
-      : this() {
-      this.problemData = problemData;
-      this.lowerEstimationLimit = lowerEstimationLimit;
-      this.upperEstimationLimit = upperEstimationLimit;
-      Initialize();
-    }
-
-    [StorableConstructor]
-    private DataAnalysisSolution(bool deserializing) : base(deserializing) { }
-
-    [StorableHook(HookType.AfterDeserialization)]
-    private void Initialize() {
-      if (problemData != null) RegisterProblemDataEvents();
-    }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      DataAnalysisSolution clone = (DataAnalysisSolution)base.Clone(cloner);
-      // don't clone the problem data!
-      clone.problemData = problemData;
-      clone.lowerEstimationLimit = lowerEstimationLimit;
-      clone.upperEstimationLimit = upperEstimationLimit;
-      clone.Initialize();
-      return clone;
-    }
+    protected abstract void RecalculateEstimatedValues();
 
     #region Events
@@ -116 +122 @@
       ProblemData.ProblemDataChanged += new EventHandler(ProblemData_Changed);
     }
-
     private void ProblemData_Changed(object sender, EventArgs e) {
-      OnProblemDataChanged(EventArgs.Empty);
+      OnProblemDataChanged();
     }
 
     public event EventHandler ProblemDataChanged;
-    protected virtual void OnProblemDataChanged(EventArgs e) {
+    protected virtual void OnProblemDataChanged() {
+      RecalculateEstimatedValues();
       var listeners = ProblemDataChanged;
       if (listeners != null)
-        listeners(this, e);
+        listeners(this, EventArgs.Empty);
+    }
+
+    public event EventHandler ModelChanged;
+    protected virtual void OnModelChanged() {
+      RecalculateEstimatedValues();
+      EventHandler handler = ModelChanged;
+      if (handler != null)
+        handler(this, EventArgs.Empty);
     }
 
     public event EventHandler EstimatedValuesChanged;
-    protected virtual void OnEstimatedValuesChanged(EventArgs e) {
+    protected virtual void OnEstimatedValuesChanged() {
       var listeners = EstimatedValuesChanged;
       if (listeners != null)
-        listeners(this, e);
+        listeners(this, EventArgs.Empty);
     }
     #endregion
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      DataAnalysisSolution clone = (DataAnalysisSolution)base.Clone(cloner);
+      // don't clone the problem data!
+      clone.problemData = problemData;
+      clone.Model = (IDataAnalysisModel)cloner.Clone(model);
+      clone.lowerEstimationLimit = lowerEstimationLimit;
+      clone.upperEstimationLimit = upperEstimationLimit;
+      clone.Initialize();
+      return clone;
+    }
   }
 }

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\IDataAnalysisModel.cs" />
     <Compile Include="Interfaces\IDataAnalysisProblem.cs" />
     <Compile Include="MatrixExtensions.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="SupportVectorMachine\ParameterAdjustmentProblem\SupportVectorRegressionParameterAdjustmentBestSolutionAnalyzer.cs" />
     <Compile Include="SupportVectorMachine\ParameterAdjustmentProblem\SupportVectorRegressionParameterAdjustmentEvaluator.cs" />
     <Compile Include="SupportVectorMachine\ParameterAdjustmentProblem\SupportVectorRegressionParameterAdjustmentProblem.cs" />

trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/SupportVectorMachine/ParameterAdjustmentProblem/SupportVectorMachineParameterAdjustmentEvaluator.cs

@@ -34 +34 @@
 
 namespace HeuristicLab.Problems.DataAnalysis.SupportVectorMachine.ParameterAdjustmentProblem {
-  [Item("SupportVectorRegressionParameterAdjustmentEvaluator", "")]
+  [Item("SupportVectorMachineParameterAdjustmentEvaluator", "")]
   [StorableClass]
-  public class SupportVectorRegressionParameterAdjustmentEvaluator : AlgorithmOperator, ISingleObjectiveEvaluator {
+  public class SupportVectorMachineParameterAdjustmentEvaluator : AlgorithmOperator, ISingleObjectiveEvaluator {
     private const string ParameterVectorParameterName = "ParameterVector";
     private const string DataAnalysisProblemDataParameterName = "DataAnalysisProblemData";
@@ -112 +112 @@
     #endregion
 
-    public SupportVectorRegressionParameterAdjustmentEvaluator()
+    public SupportVectorMachineParameterAdjustmentEvaluator()
       : base() {
       StringValue nuSvrType = new StringValue("NU_SVR").AsReadOnly();
@@ -141 +141 @@
       GammaParameter.Value = new DoubleValue(Math.Pow(2, point[2]));
       EpsilonParameter.Value = new DoubleValue();
-
       return base.Apply();
     }

trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/SupportVectorMachine/ParameterAdjustmentProblem/SupportVectorMachineParameterAdjustmentProblem.cs

@@ -36 +36 @@
 
 namespace HeuristicLab.Problems.DataAnalysis.SupportVectorMachine.ParameterAdjustmentProblem {
-  [Item("Support Vector Regression Parameter Adjustment Problem", "Represents the problem of finding good parameter settings for support vector machines.")]
+  [Item("Support Vector Machine Parameter Adjustment Problem", "Represents the problem of finding good parameter settings for support vector machines.")]
   [StorableClass]
   [Creatable("Problems")]
-  public sealed class SupportVectorRegressionParameterAdjustmentProblem : DataAnalysisProblem, ISingleObjectiveProblem {
+  public sealed class SupportVectorMachineParameterAdjustmentProblem : DataAnalysisProblem, ISingleObjectiveProblem {
 
     #region Parameter Properties
@@ -60 +60 @@
       get { return SolutionCreatorParameter; }
     }
-    public new ValueParameter<SupportVectorRegressionParameterAdjustmentEvaluator> EvaluatorParameter {
-      get { return (ValueParameter<SupportVectorRegressionParameterAdjustmentEvaluator>)Parameters["Evaluator"]; }
+    public new ValueParameter<SupportVectorMachineParameterAdjustmentEvaluator> EvaluatorParameter {
+      get { return (ValueParameter<SupportVectorMachineParameterAdjustmentEvaluator>)Parameters["Evaluator"]; }
     }
     IParameter IProblem.EvaluatorParameter {
@@ -96 +96 @@
       get { return SolutionCreatorParameter.Value; }
     }
-    public new SupportVectorRegressionParameterAdjustmentEvaluator Evaluator {
+    public new SupportVectorMachineParameterAdjustmentEvaluator Evaluator {
       get { return EvaluatorParameter.Value; }
       set { EvaluatorParameter.Value = value; }
@@ -115 +115 @@
     }
     #endregion
-
-
-    //public int MinimumProblemSize {
-    //  get { return 3; }
-    //}
-    //public int MaximumProblemSize {
-    //  get { return 3; }
-    //}
 
     public IntValue TrainingSamplesStart {
@@ -139 +131 @@
 
     [StorableConstructor]
-    private SupportVectorRegressionParameterAdjustmentProblem(bool deserializing) : base() { }
-    public SupportVectorRegressionParameterAdjustmentProblem()
+    private SupportVectorMachineParameterAdjustmentProblem(bool deserializing) : base() { }
+    public SupportVectorMachineParameterAdjustmentProblem()
       : base() {
       UniformRandomRealVectorCreator creator = new UniformRandomRealVectorCreator();
-      SupportVectorRegressionParameterAdjustmentEvaluator evaluator = new SupportVectorRegressionParameterAdjustmentEvaluator();
+      SupportVectorMachineParameterAdjustmentEvaluator evaluator = new SupportVectorMachineParameterAdjustmentEvaluator();
 
       var bounds = new DoubleMatrix(new double[,] { 
@@ -155 +147 @@
       Parameters.Add(new ValueParameter<IntValue>("ProblemSize", "The dimension of the problem.", new IntValue(3)));
       Parameters.Add(new ValueParameter<IRealVectorCreator>("SolutionCreator", "The operator which should be used to create new test function solutions.", creator));
-      Parameters.Add(new ValueParameter<SupportVectorRegressionParameterAdjustmentEvaluator>("Evaluator", "The operator which should be used to evaluate test function solutions.", evaluator));
+      Parameters.Add(new ValueParameter<SupportVectorMachineParameterAdjustmentEvaluator>("Evaluator", "The operator which should be used to evaluate test function solutions.", evaluator));
       Parameters.Add(new OptionalValueParameter<DoubleValue>("BestKnownQuality", "The quality of the best known solution of this test function.", new DoubleValue(0)));
       Parameters.Add(new OptionalValueParameter<RealVector>("BestKnownSolution", "The best known solution for this test function instance."));
@@ -169 +161 @@
       ParameterizeSolutionCreator();
       ParameterizeEvaluator();
+      ParameterizeAnalyzers();
 
       Initialize();
@@ -175 +168 @@
 
     public override IDeepCloneable Clone(Cloner cloner) {
-      SupportVectorRegressionParameterAdjustmentProblem clone = (SupportVectorRegressionParameterAdjustmentProblem)base.Clone(cloner);
+      SupportVectorMachineParameterAdjustmentProblem clone = (SupportVectorMachineParameterAdjustmentProblem)base.Clone(cloner);
       clone.strategyVectorCreator = (StdDevStrategyVectorCreator)cloner.Clone(strategyVectorCreator);
       clone.strategyVectorCrossover = (StdDevStrategyVectorCrossover)cloner.Clone(strategyVectorCrossover);
@@ -191 +184 @@
     private void SolutionCreatorParameter_ValueChanged(object sender, EventArgs e) {
       ParameterizeSolutionCreator();
-      //ParameterizeAnalyzers();
+      ParameterizeAnalyzers();
       SolutionCreator_RealVectorParameter_ActualNameChanged(null, EventArgs.Empty);
     }
@@ -197 +190 @@
       ParameterizeEvaluator();
       ParameterizeOperators();
-      //ParameterizeAnalyzers();
+      ParameterizeAnalyzers();
     }
     private void EvaluatorParameter_ValueChanged(object sender, EventArgs e) {
       ParameterizeEvaluator();
-      //ParameterizeAnalyzers();
+      ParameterizeAnalyzers();
       RaiseReset(EventArgs.Empty);
     }
@@ -224 +217 @@
       operators = new List<IOperator>();
       operators.AddRange(ApplicationManager.Manager.GetInstances<IRealVectorOperator>().Cast<IOperator>());
+      operators.Add(new SupportVectorMachineParameterAdjustmentBestSolutionAnalyzer());
       operators.Add(strategyVectorCreator);
       operators.Add(strategyVectorCrossover);
@@ -254 +248 @@
         op.BoundsParameter.ActualName = BoundsParameter.Name;
       }
-      foreach (SupportVectorRegressionParameterAdjustmentEvaluator op in Operators.OfType<SupportVectorRegressionParameterAdjustmentEvaluator>()) {
+      foreach (SupportVectorMachineParameterAdjustmentEvaluator op in Operators.OfType<SupportVectorMachineParameterAdjustmentEvaluator>()) {
         op.QualityParameter.ActualName = Evaluator.QualityParameter.ActualName;
         op.ParameterVectorParameter.ActualName = SolutionCreator.RealVectorParameter.ActualName;

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

@@ -41 +41 @@
   [Item("SupportVectorMachineCrossValidationEvaluator", "Represents an operator that performs SVM cross validation with the given parameters.")]
   public class SupportVectorMachineCrossValidationEvaluator : SingleSuccessorOperator, ISingleObjectiveEvaluator {
+    private const string RandomParameterName = "Random";
     private const string DataAnalysisProblemDataParameterName = "DataAnalysisProblemData";
     private const string SvmTypeParameterName = "SvmType";
@@ -50 +51 @@
     private const string SamplesStartParameterName = "SamplesStart";
     private const string SamplesEndParameterName = "SamplesEnd";
+    private const string ActualSamplesParameterName = "ActualSamples";
     private const string NumberOfFoldsParameterName = "NumberOfFolds";
     private const string QualityParameterName = "Quality";
 
     #region parameter properties
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (ILookupParameter<IRandom>)Parameters[RandomParameterName]; }
+    }
     public IValueLookupParameter<DataAnalysisProblemData> DataAnalysisProblemDataParameter {
       get { return (IValueLookupParameter<DataAnalysisProblemData>)Parameters[DataAnalysisProblemDataParameterName]; }
@@ -80 +85 @@
     public IValueLookupParameter<IntValue> SamplesEndParameter {
       get { return (IValueLookupParameter<IntValue>)Parameters[SamplesEndParameterName]; }
+    }
+    public IValueLookupParameter<PercentValue> ActualSamplesParameter {
+      get { return (IValueLookupParameter<PercentValue>)Parameters[ActualSamplesParameterName]; }
     }
     public IValueLookupParameter<IntValue> NumberOfFoldsParameter {
@@ -123 +131 @@
     public SupportVectorMachineCrossValidationEvaluator()
       : base() {
+      Parameters.Add(new LookupParameter<IRandom>(RandomParameterName, "The random generator to use."));
       Parameters.Add(new ValueLookupParameter<DataAnalysisProblemData>(DataAnalysisProblemDataParameterName, "The data analysis problem data to use for training."));
       Parameters.Add(new ValueLookupParameter<StringValue>(SvmTypeParameterName, "The type of SVM to use."));
@@ -132 +141 @@
       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 ValueLookupParameter<PercentValue>(ActualSamplesParameterName, "The percentage of the training set that should be acutally used for cross-validation (samples are picked randomly from the training set)."));
       Parameters.Add(new ValueLookupParameter<IntValue>(NumberOfFoldsParameterName, "The number of folds to use for cross-validation."));
       Parameters.Add(new LookupParameter<DoubleValue>(QualityParameterName, "The cross validation quality reached with the given parameters."));
@@ -137 +147 @@
 
     public override IOperation Apply() {
-      double quality = PerformCrossValidation(DataAnalysisProblemData,
-                             SamplesStart.Value, SamplesEnd.Value,
+      double reductionRatio = 1.0;
+      if (ActualSamplesParameter.ActualValue != null)
+        reductionRatio = ActualSamplesParameter.ActualValue.Value;
+
+      int reducedRows = (int)((SamplesEnd.Value - SamplesStart.Value) * reductionRatio);
+      var reducedProblemData = (DataAnalysisProblemData)DataAnalysisProblemData.Clone();
+      ShuffleRows(RandomParameter.ActualValue, reducedProblemData.Dataset, SamplesStart.Value, SamplesEnd.Value);
+
+      double quality = PerformCrossValidation(reducedProblemData,
+                             SamplesStart.Value, SamplesStart.Value + reducedRows,
                              SvmType.Value, KernelType.Value,
                              Cost.Value, Nu.Value, Gamma.Value, Epsilon.Value, NumberOfFolds.Value);
@@ -144 +162 @@
       QualityParameter.ActualValue = new DoubleValue(quality);
       return base.Apply();
+    }
+
+    private void ShuffleRows(IRandom random, Dataset dataset, int start, int end) {
+      for (int row = end - 1; row > start ; row--) {
+        int otherRow = random.Next(start, row);
+        for (int column = 0; column < dataset.Columns; column++) {
+          double tmp = dataset[otherRow, column];
+          dataset[otherRow, column] = dataset[row, column];
+          dataset[row, column] = tmp;
+        }
+      }
     }
 
@@ -178 +207 @@
       SVM.Problem scaledProblem = Scaling.Scale(rangeTransform, problem);
 
-      return SVM.Training.PerformCrossValidation(scaledProblem, parameter, nFolds);
+      return SVM.Training.PerformCrossValidation(scaledProblem, parameter, nFolds, false);
     }
   }

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

@@ -29 +29 @@
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 using HeuristicLab.Common;
+using SVM;
+using System.Linq;
 
 namespace HeuristicLab.Problems.DataAnalysis.SupportVectorMachine {
@@ -36 +38 @@
   [StorableClass]
   [Item("SupportVectorMachineModel", "Represents a support vector machine model.")]
-  public class SupportVectorMachineModel : NamedItem {
+  public class SupportVectorMachineModel : NamedItem, IDataAnalysisModel {
+    public SupportVectorMachineModel()
+      : base() {
+    }
+
     private SVM.Model model;
     /// <summary>
@@ -67 +73 @@
     }
 
-    public SupportVectorMachineModel()
-      : base() {
+    public IEnumerable<double> GetEstimatedValues(DataAnalysisProblemData problemData, int start, int end) {
+      SVM.Problem problem = SupportVectorMachineUtil.CreateSvmProblem(problemData, start, end);
+      SVM.Problem scaledProblem = Scaling.Scale(RangeTransform, problem);
+
+      return (from row in Enumerable.Range(0, scaledProblem.Count)
+              select SVM.Prediction.Predict(Model, scaledProblem.X[row])).ToList();
     }
 
@@ -81 +91 @@
 
     #region persistence
+    [Storable]
+    private int[] SupportVectorIndizes {
+      get { return this.Model.SupportVectorIndizes; }
+      set { this.Model.SupportVectorIndizes = value; }
+    }
+
     [Storable]
     private string ModelAsString {
@@ -131 +147 @@
       StreamWriter writer = new StreamWriter(s);
       writer.WriteLine("RangeTransform:");
-      writer.Flush(); 
+      writer.Flush();
       using (MemoryStream memStream = new MemoryStream()) {
         SVM.RangeTransform.Write(memStream, model.RangeTransform);