Free cookie consent management tool by TermsFeed Policy Generator

Changeset 3884 for trunk


Ignore:
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
Files:
4 added
1 deleted
20 edited
2 moved

Legend:

Unmodified
Added
Removed

  • trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.3/SupportVectorMachine.cs

    r3877 r3884  
    168168    }
    169169
     170    protected override void Problem_Reset(object sender, EventArgs e) {
     171      TrainingSamplesStartParameter.ActualValue = Problem.DataAnalysisProblemData.TrainingSamplesStart;
     172      TrainingSamplesEndParameter.ActualValue = Problem.DataAnalysisProblemData.TrainingSamplesEnd;
     173      base.Problem_Reset(sender, e);
     174    }
     175
    170176    #region Events
    171177    protected override void OnProblemChanged() {
    … …  
    175181      TrainingSamplesStartParameter.ActualValue = Problem.DataAnalysisProblemData.TrainingSamplesStart;
    176182      TrainingSamplesEndParameter.ActualValue = Problem.DataAnalysisProblemData.TrainingSamplesEnd;
     183      Problem.Reset += new EventHandler(Problem_Reset);
    177184      base.OnProblemChanged();
    178185    }
    … …  
    210217        evaluator.DataAnalysisProblemDataParameter.ActualName = Problem.DataAnalysisProblemDataParameter.Name;
    211218        analyzer.ProblemDataParameter.ActualName = Problem.DataAnalysisProblemDataParameter.Name;
     219        Problem.Reset += new EventHandler(Problem_Reset);
    212220      }
    213221    }

  • trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.LibSVM/1.6.3/LibSVM-1.6.3/Model.cs

    r3858 r3884  
    217217      model.ClassLabels = null;
    218218      model.NumberOfSVPerClass = null;
     219      model.SupportVectorIndizes = new int[0];
    219220
    220221      bool headerFinished = false;

  • trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.LibSVM/1.6.3/LibSVM-1.6.3/ParameterSelection.cs

    r2645 r3884  
    150150                    parameters.C = CValues[i];
    151151                    parameters.Gamma = GammaValues[j];
    152                     double test = Training.PerformCrossValidation(problem, parameters, nrfold);
     152                    double test = Training.PerformCrossValidation(problem, parameters, nrfold, true);
    153153                    Console.Write("{0} {1} {2}", parameters.C, parameters.Gamma, test);
    154154                    if(output != null)

  • trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.LibSVM/1.6.3/LibSVM-1.6.3/Solver.cs

    r3858 r3884  
    15551555            Parameter newparam = (Parameter)param.Clone();
    15561556            newparam.Probability = false;
    1557             svm_cross_validation(prob, newparam, nr_fold, ymv);
     1557            svm_cross_validation(prob, newparam, nr_fold, ymv, true);
    15581558            for (i = 0; i < prob.Count; i++)
    15591559            {
    … …  
    18721872
    18731873        // Stratified cross validation
    1874         public static void svm_cross_validation(Problem prob, Parameter param, int nr_fold, double[] target)
     1874        public static void svm_cross_validation(Problem prob, Parameter param, int nr_fold, double[] target, bool shuffleTraining)
    18751875        {
    18761876            Random rand = new Random();
    … …  
    19361936            {
    19371937                for (i = 0; i < l; i++) perm[i] = i;
    1938                 for (i = 0; i < l; i++)
    1939                 {
     1938                if (shuffleTraining) {
     1939                  for (i = 0; i < l; i++) {
    19401940                    int j = i + (int)(rand.NextDouble() * (l - i));
    19411941                    do { int _ = perm[i]; perm[i] = perm[j]; perm[j] = _; } while (false);
     1942                  }
    19421943                }
    19431944                for (i = 0; i <= nr_fold; i++)

  • trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.LibSVM/1.6.3/LibSVM-1.6.3/Training.cs

    r3879 r3884  
    4343        }
    4444
    45         private static double doCrossValidation(Problem problem, Parameter parameters, int nr_fold)
     45        private static double doCrossValidation(Problem problem, Parameter parameters, int nr_fold, bool shuffleTraining)
    4646        {
    4747            int i;
    4848            double[] target = new double[problem.Count];
    49             Procedures.svm_cross_validation(problem, parameters, nr_fold, target);
     49            Procedures.svm_cross_validation(problem, parameters, nr_fold, target, shuffleTraining);
    5050            int total_correct = 0;
    5151            double total_error = 0;
    … …  
    8787            parseCommandLine(args, out parameters, out problem, out crossValidation, out nrfold, out modelFilename);
    8888            if (crossValidation)
    89                 PerformCrossValidation(problem, parameters, nrfold);
     89                PerformCrossValidation(problem, parameters, nrfold, true);
    9090            else Model.Write(modelFilename, Train(problem, parameters));
    9191        }
    … …  
    9898        /// <param name="nrfold">The number of cross validations to use</param>
    9999        /// <returns>The cross validation score</returns>
    100         public static double PerformCrossValidation(Problem problem, Parameter parameters, int nrfold)
     100        public static double PerformCrossValidation(Problem problem, Parameter parameters, int nrfold, bool shuffleTraining)
    101101        {
    102102            string error = Procedures.svm_check_parameter(problem, parameters);
    103103            if (error == null)
    104                 return doCrossValidation(problem, parameters, nrfold);
     104                return doCrossValidation(problem, parameters, nrfold, shuffleTraining);
    105105            else throw new Exception(error);
    106106        }

  • trunk/sources/HeuristicLab.Problems.DataAnalysis.Regression/3.3/SupportVectorRegression/BestSupportVectorRegressionSolutionAnalyzer.cs

    r3877 r3884  
    169169      return base.Apply();
    170170    }
    171 
    172     private IEnumerable<string> GetInputVariables(SymbolicExpressionTree tree) {
    173       return (from varNode in tree.IterateNodesPrefix().OfType<VariableTreeNode>()
    174               select varNode.VariableName).Distinct();
    175     }
    176171  }
    177172}

  • trunk/sources/HeuristicLab.Problems.DataAnalysis.Regression/3.3/SupportVectorRegression/SupportVectorRegressionSolution.cs

    r3858 r3884  
    3939  [StorableClass]
    4040  public sealed class SupportVectorRegressionSolution : DataAnalysisSolution {
     41    public SupportVectorRegressionSolution() : base() { }
     42    public SupportVectorRegressionSolution(DataAnalysisProblemData problemData, SupportVectorMachineModel model, IEnumerable<string> inputVariables, double lowerEstimationLimit, double upperEstimationLimit)
     43      : base(problemData, lowerEstimationLimit, upperEstimationLimit) {
     44      this.Model = model;
     45    }
     46
    4147    public override Image ItemImage {
    4248      get { return HeuristicLab.Common.Resources.VS2008ImageLibrary.Function; }
    4349    }
    4450
    45     [Storable]
    46     private SupportVectorMachineModel model;
    47     public SupportVectorMachineModel Model {
    48       get { return model; }
     51    public new SupportVectorMachineModel Model {
     52      get { return (SupportVectorMachineModel)base.Model; }
     53      set { base.Model = value; }
    4954    }
    5055
    … …  
    5358    }
    5459
    55     public SupportVectorRegressionSolution() : base() { }
    56     public SupportVectorRegressionSolution(DataAnalysisProblemData problemData, SupportVectorMachineModel model, IEnumerable<string> inputVariables, double lowerEstimationLimit, double upperEstimationLimit)
    57       : base(problemData, lowerEstimationLimit, upperEstimationLimit) {
    58       this.model = model;
    59     }
    60 
    61     protected override void OnProblemDataChanged(EventArgs e) {
    62       RecalculateEstimatedValues();
    63       model.Model.SupportVectorIndizes = new int[0];
     60    protected override void OnProblemDataChanged() {
     61      Model.Model.SupportVectorIndizes = new int[0];
     62      base.OnProblemDataChanged();
    6463    }
    6564
    6665    private Dataset CalculateSupportVectors() {
    67       if (model.Model.SupportVectorIndizes.Length == 0)
     66      if (Model.Model.SupportVectorIndizes.Length == 0)
    6867        return new Dataset();
    6968
    70       Dataset dataset = new Dataset(ProblemData.Dataset.VariableNames, new double[model.Model.SupportVectorCount, ProblemData.Dataset.Columns]);
    71       for (int i = 0; i < model.Model.SupportVectorIndizes.Length; i++) {
     69      Dataset dataset = new Dataset(ProblemData.Dataset.VariableNames, new double[Model.Model.SupportVectorCount, ProblemData.Dataset.Columns]);
     70      for (int i = 0; i < Model.Model.SupportVectorIndizes.Length; i++) {
    7271        for (int column = 0; column < ProblemData.Dataset.Columns; column++)
    73           dataset[i, column] = ProblemData.Dataset[model.Model.SupportVectorIndizes[i], column];
     72          dataset[i, column] = ProblemData.Dataset[Model.Model.SupportVectorIndizes[i], column];
    7473      }
    7574      return dataset;
    7675    }
    7776
    78     private void RecalculateEstimatedValues() {
     77    protected override void RecalculateEstimatedValues() {
    7978      SVM.Problem problem = SupportVectorMachineUtil.CreateSvmProblem(ProblemData, 0, ProblemData.Dataset.Rows);
    80       SVM.Problem scaledProblem = Scaling.Scale(model.RangeTransform, problem);
     79      SVM.Problem scaledProblem = Scaling.Scale(Model.RangeTransform, problem);
    8180
    8281      estimatedValues = (from row in Enumerable.Range(0, scaledProblem.Count)
    83                          let prediction = SVM.Prediction.Predict(model.Model, scaledProblem.X[row])
     82                         let prediction = SVM.Prediction.Predict(Model.Model, scaledProblem.X[row])
    8483                         let boundedX = Math.Min(UpperEstimationLimit, Math.Max(LowerEstimationLimit, prediction))
    8584                         select double.IsNaN(boundedX) ? UpperEstimationLimit : boundedX).ToList();
    86       OnEstimatedValuesChanged(EventArgs.Empty);
     85      OnEstimatedValuesChanged();
    8786    }
    8887
    … …  
    112111      }
    113112    }
    114 
    115     public override IDeepCloneable Clone(Cloner cloner) {
    116       SupportVectorRegressionSolution clone = (SupportVectorRegressionSolution)base.Clone(cloner);
    117       clone.model = (SupportVectorMachineModel)cloner.Clone(model);
    118       return clone;
    119     }
    120113  }
    121114}

  • trunk/sources/HeuristicLab.Problems.DataAnalysis.Regression/3.3/Symbolic/SymbolicRegressionModel.cs

    r3541 r3884  
    3939  [StorableClass]
    4040  [Item("SymbolicRegressionModel", "A symbolic regression model represents an entity that provides estimated values based on input values.")]
    41   public class SymbolicRegressionModel : Item {
     41  public class SymbolicRegressionModel : NamedItem, IDataAnalysisModel {
     42    private SymbolicRegressionModel() : base() { } // for cloning
     43    [StorableConstructor]
     44    protected SymbolicRegressionModel(bool deserializing)
     45      : base(deserializing) {
     46    }
     47    public SymbolicRegressionModel(ISymbolicExpressionTreeInterpreter interpreter, SymbolicExpressionTree tree, IEnumerable<string> inputVariables)
     48      : base() {
     49      this.tree = tree;
     50      this.interpreter = interpreter;
     51      this.inputVariables = inputVariables.ToList();
     52    }
     53
    4254    [Storable]
    4355    private SymbolicExpressionTree tree;
    … …  
    5062      get { return interpreter; }
    5163    }
     64    [Storable]
    5265    private List<string> inputVariables;
    53     [Storable]
    5466    public IEnumerable<string> InputVariables {
    5567      get { return inputVariables.AsEnumerable(); }
    … …  
    5971      }
    6072    }
    61     public SymbolicRegressionModel() : base() { } // for cloning
    6273
    63     public SymbolicRegressionModel(ISymbolicExpressionTreeInterpreter interpreter, SymbolicExpressionTree tree, IEnumerable<string> inputVariables)
    64       : base() {
    65       this.tree = tree;
    66       this.interpreter = interpreter;
    67       this.inputVariables = inputVariables.ToList();
    68     }
    69 
    70     public IEnumerable<double> GetEstimatedValues(Dataset dataset, int start, int end) {
    71       return interpreter.GetSymbolicExpressionTreeValues(tree, dataset, Enumerable.Range(start, end - start));
     74    public IEnumerable<double> GetEstimatedValues(DataAnalysisProblemData problemData, int start, int end) {
     75      return interpreter.GetSymbolicExpressionTreeValues(tree, problemData.Dataset, Enumerable.Range(start, end - start));
    7276    }
    7377

  • trunk/sources/HeuristicLab.Problems.DataAnalysis.Regression/3.3/Symbolic/SymbolicRegressionSolution.cs

    r3710 r3884  
    3737  [StorableClass]
    3838  public sealed class SymbolicRegressionSolution : DataAnalysisSolution {
     39    public SymbolicRegressionSolution() : base() { }
     40    public SymbolicRegressionSolution(DataAnalysisProblemData problemData, SymbolicRegressionModel model, double lowerEstimationLimit, double upperEstimationLimit)
     41      : base(problemData, lowerEstimationLimit, upperEstimationLimit) {
     42      this.Model = model;
     43    }
     44
    3945    public override Image ItemImage {
    4046      get { return HeuristicLab.Common.Resources.VS2008ImageLibrary.Function; }
    4147    }
    42     [Storable]
    43     private SymbolicRegressionModel model;
    44     public SymbolicRegressionModel Model {
    45       get { return model; }
    46       set {
    47         if (model != value) {
    48           if (value == null) throw new ArgumentNullException();
    49           model = value;
    50           OnModelChanged(EventArgs.Empty);
    51         }
    52       }
     48
     49    public new SymbolicRegressionModel Model {
     50      get { return (SymbolicRegressionModel)base.Model; }
     51      set { base.Model = value; }
    5352    }
    5453
    55     public SymbolicRegressionSolution() : base() { }
    56     public SymbolicRegressionSolution(DataAnalysisProblemData problemData, SymbolicRegressionModel model, double lowerEstimationLimit, double upperEstimationLimit)
    57       : base(problemData, lowerEstimationLimit, upperEstimationLimit) {
    58       this.model = model;
    59     }
    60 
    61     public event EventHandler ModelChanged;
    62     private void OnModelChanged(EventArgs e) {
    63       RecalculateEstimatedValues();
    64       var listeners = ModelChanged;
    65       if (listeners != null)
    66         listeners(this, e);
    67     }
    68 
    69     protected override void OnProblemDataChanged(EventArgs e) {
    70       RecalculateEstimatedValues();
    71     }
    72 
    73     private void RecalculateEstimatedValues() {
    74       estimatedValues = (from x in model.GetEstimatedValues(ProblemData.Dataset, 0, ProblemData.Dataset.Rows)
     54    protected override void RecalculateEstimatedValues() {
     55      estimatedValues = (from x in Model.GetEstimatedValues(ProblemData, 0, ProblemData.Dataset.Rows)
    7556                         let boundedX = Math.Min(UpperEstimationLimit, Math.Max(LowerEstimationLimit, x))
    7657                         select double.IsNaN(boundedX) ? UpperEstimationLimit : boundedX).ToList();
    77       OnEstimatedValuesChanged(EventArgs.Empty);
     58      OnEstimatedValuesChanged();
    7859    }
    7960
    … …  
    10384      }
    10485    }
    105 
    106     public override IDeepCloneable Clone(Cloner cloner) {
    107       SymbolicRegressionSolution clone = (SymbolicRegressionSolution)base.Clone(cloner);
    108       clone.model = (SymbolicRegressionModel)cloner.Clone(model);
    109       return clone;
    110     }
    11186  }
    11287}

  • trunk/sources/HeuristicLab.Problems.DataAnalysis.Views/3.3/DataAnalysisProblemDataView.cs

    r3758 r3884  
    3939    public new DataAnalysisProblemData Content {
    4040      get { return (DataAnalysisProblemData)base.Content; }
    41       set {
    42         base.Content = value;
    43       }
     41      set { base.Content = value; }
    4442    }
    4543

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

    r3853 r3884  
    8686    <None Include="HeuristicLabProblemsDataAnalysisViewsPlugin.cs.frame" />
    8787    <None Include="Properties\AssemblyInfo.frame" />
     88    <Compile Include="DataAnalysisSolutionView.cs">
     89      <SubType>UserControl</SubType>
     90    </Compile>
     91    <Compile Include="DataAnalysisSolutionView.Designer.cs">
     92      <DependentUpon>DataAnalysisSolutionView.cs</DependentUpon>
     93    </Compile>
    8894    <Compile Include="SupportVectorRegressionSolutionView.cs">
    8995      <SubType>UserControl</SubType>

  • trunk/sources/HeuristicLab.Problems.DataAnalysis.Views/3.3/SupportVectorRegressionSolutionView.Designer.cs

    r3858 r3884  
    4444    /// </summary>
    4545    private void InitializeComponent() {
    46       this.modelTabControl = new System.Windows.Forms.TabControl();
    47       this.modelTabPage = new System.Windows.Forms.TabPage();
    48       this.modelPanel = new HeuristicLab.MainForm.WindowsForms.ViewHost();
    49       this.dataTabPage = new System.Windows.Forms.TabPage();
    50       this.dataPanel = new HeuristicLab.MainForm.WindowsForms.ViewHost();
    5146      this.supportVectorTabControl = new System.Windows.Forms.TabPage();
    5247      this.supportVectorViewHost = new HeuristicLab.MainForm.WindowsForms.ViewHost();
    53       this.modelTabControl.SuspendLayout();
    54       this.modelTabPage.SuspendLayout();
    55       this.dataTabPage.SuspendLayout();
    5648      this.supportVectorTabControl.SuspendLayout();
    5749      this.SuspendLayout();
    58       //
    59       // modelTabControl
    60       //
    61       this.modelTabControl.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom)
    62                   | System.Windows.Forms.AnchorStyles.Left)
    63                   | System.Windows.Forms.AnchorStyles.Right)));
    64       this.modelTabControl.Controls.Add(this.modelTabPage);
    65       this.modelTabControl.Controls.Add(this.dataTabPage);
    66       this.modelTabControl.Controls.Add(this.supportVectorTabControl);
    67       this.modelTabControl.Location = new System.Drawing.Point(3, 3);
    68       this.modelTabControl.Name = "modelTabControl";
    69       this.modelTabControl.SelectedIndex = 0;
    70       this.modelTabControl.Size = new System.Drawing.Size(247, 245);
    71       this.modelTabControl.TabIndex = 0;
    72       //
    73       // modelTabPage
    74       //
    75       this.modelTabPage.Controls.Add(this.modelPanel);
    76       this.modelTabPage.Location = new System.Drawing.Point(4, 22);
    77       this.modelTabPage.Name = "modelTabPage";
    78       this.modelTabPage.Padding = new System.Windows.Forms.Padding(3);
    79       this.modelTabPage.Size = new System.Drawing.Size(239, 219);
    80       this.modelTabPage.TabIndex = 0;
    81       this.modelTabPage.Text = "Model";
    82       this.modelTabPage.UseVisualStyleBackColor = true;
    83       //
    84       // modelPanel
    85       //
    86       this.modelPanel.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom)
    87                   | System.Windows.Forms.AnchorStyles.Left)
    88                   | System.Windows.Forms.AnchorStyles.Right)));
    89       this.modelPanel.Caption = "View";
    90       this.modelPanel.Content = null;
    91       this.modelPanel.Location = new System.Drawing.Point(6, 6);
    92       this.modelPanel.Name = "modelPanel";
    93       this.modelPanel.ReadOnly = false;
    94       this.modelPanel.Size = new System.Drawing.Size(227, 207);
    95       this.modelPanel.TabIndex = 0;
    96       this.modelPanel.ViewType = null;
    97       //
    98       // dataTabPage
    99       //
    100       this.dataTabPage.Controls.Add(this.dataPanel);
    101       this.dataTabPage.Location = new System.Drawing.Point(4, 22);
    102       this.dataTabPage.Name = "dataTabPage";
    103       this.dataTabPage.Padding = new System.Windows.Forms.Padding(3);
    104       this.dataTabPage.Size = new System.Drawing.Size(239, 219);
    105       this.dataTabPage.TabIndex = 1;
    106       this.dataTabPage.Text = "Data";
    107       this.dataTabPage.UseVisualStyleBackColor = true;
    108       //
    109       // dataPanel
    110       //
    111       this.dataPanel.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom)
    112                   | System.Windows.Forms.AnchorStyles.Left)
    113                   | System.Windows.Forms.AnchorStyles.Right)));
    114       this.dataPanel.Caption = "View";
    115       this.dataPanel.Content = null;
    116       this.dataPanel.Location = new System.Drawing.Point(6, 6);
    117       this.dataPanel.Name = "dataPanel";
    118       this.dataPanel.ReadOnly = false;
    119       this.dataPanel.Size = new System.Drawing.Size(227, 207);
    120       this.dataPanel.TabIndex = 0;
    121       this.dataPanel.ViewType = null;
    12250      //
    12351      // supportVectorTabControl
    … …  
    15179      this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
    15280      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
    153       this.Controls.Add(this.modelTabControl);
    15481      this.Name = "SupportVectorRegressionSolutionView";
    155       this.Size = new System.Drawing.Size(253, 251);
    156       this.modelTabControl.ResumeLayout(false);
    157       this.modelTabPage.ResumeLayout(false);
    158       this.dataTabPage.ResumeLayout(false);
     82      this.tabControl.TabPages.Add(supportVectorTabControl);
    15983      this.supportVectorTabControl.ResumeLayout(false);
    16084      this.ResumeLayout(false);
    … …  
    16488    #endregion
    16589
    166     private System.Windows.Forms.TabControl modelTabControl;
    167     private System.Windows.Forms.TabPage modelTabPage;
    168     private HeuristicLab.MainForm.WindowsForms.ViewHost modelPanel;
    169     private System.Windows.Forms.TabPage dataTabPage;
    170     private HeuristicLab.MainForm.WindowsForms.ViewHost dataPanel;
    17190    private System.Windows.Forms.TabPage supportVectorTabControl;
    17291    private HeuristicLab.MainForm.WindowsForms.ViewHost supportVectorViewHost;
    173 
    174 
    17592  }
    17693}

  • trunk/sources/HeuristicLab.Problems.DataAnalysis.Views/3.3/SupportVectorRegressionSolutionView.cs

    r3858 r3884  
    4040  [View("Support Vector Regression Solution View")]
    4141  [Content(typeof(SupportVectorRegressionSolution))]
    42   public partial class SupportVectorRegressionSolutionView : AsynchronousContentView {
     42  public partial class SupportVectorRegressionSolutionView : DataAnalysisSolutionView {
    4343
    4444    public new SupportVectorRegressionSolution Content {
    4545      get { return (SupportVectorRegressionSolution)base.Content; }
    46       set {
    47         base.Content = value;
    48       }
     46      set { base.Content = value; }
    4947    }
    5048
    … …  
    5755      base.OnContentChanged();
    5856      if (Content != null) {
    59         dataPanel.Content = Content.ProblemData;
    60         modelPanel.Content = Content.Model;
    6157        supportVectorViewHost.Content = Content.SupportVectors;
    6258      } else {
    63         dataPanel.Content = null;
    64         modelPanel.Content = null;
    6559        supportVectorViewHost.Content = null;
    6660      }
    6761    }
    68     protected override void RegisterContentEvents() {
    69       base.RegisterContentEvents();
    70       Content.ProblemDataChanged += new EventHandler(Content_ProblemDataChanged);
    71     }
    72 
    73     protected override void DeregisterContentEvents() {
    74       base.DeregisterContentEvents();
    75     }
    76 
    77     private void Content_ProblemDataChanged(object sender, EventArgs e) {
    78       dataPanel.Content = Content.ProblemData;
    79     }
    8062  }
    8163}

  • trunk/sources/HeuristicLab.Problems.DataAnalysis.Views/3.3/Symbolic/SimplifiedSymbolicExpressionModelView.cs

    r3797 r3884  
    3939namespace HeuristicLab.Problems.DataAnalysis.Views.Symbolic {
    4040  [View("Simplified Symbolic Expression Model View")]
    41   [Content(typeof(SymbolicRegressionSolution))]
     41  [Content(typeof(SymbolicRegressionModel))]
    4242  public partial class SimplifiedSymbolicExpressionModelView : AsynchronousContentView {
    43     public new SymbolicRegressionSolution Content {
    44       get { return (SymbolicRegressionSolution)base.Content; }
    45       set { base.Content = value; }
    46     }
    47 
    48 
    4943    public SimplifiedSymbolicExpressionModelView()
    5044      : base() {
    … …  
    5246    }
    5347
    54     protected override void RegisterContentEvents() {
    55       base.RegisterContentEvents();
    56       Content.ModelChanged += new EventHandler(Content_ModelChanged);
    57     }
    58 
    59     protected override void DeregisterContentEvents() {
    60       base.DeregisterContentEvents();
    61       Content.ModelChanged -= new EventHandler(Content_ModelChanged);
    62     }
    63 
    64     void Content_ModelChanged(object sender, EventArgs e) {
    65       UpdateTreeChart();
     48    public new SymbolicRegressionModel Content {
     49      get { return (SymbolicRegressionModel)base.Content; }
     50      set { base.Content = value; }
    6651    }
    6752
    6853    protected override void OnContentChanged() {
    6954      base.OnContentChanged();
    70       UpdateTreeChart();
     55      if (Content != null)
     56        UpdateTreeChart();
     57      else
     58        viewHost.Content = null;
    7159    }
    7260
    7361    private void UpdateTreeChart() {
    7462      var simplifier = new SymbolicSimplifier();
    75       var simplifiedTree = simplifier.Simplify(Content.Model.SymbolicExpressionTree);
     63      var simplifiedTree = simplifier.Simplify(Content.SymbolicExpressionTree);
    7664      viewHost.Content = simplifiedTree;
    7765    }

  • trunk/sources/HeuristicLab.Problems.DataAnalysis.Views/3.3/Symbolic/SymbolicExpressionModelView.cs

    r3797 r3884  
    3939namespace HeuristicLab.Problems.DataAnalysis.Views.Symbolic {
    4040  [View("Symbolic Expression Model View")]
    41   [Content(typeof(SymbolicRegressionSolution))]
     41  [Content(typeof(SymbolicRegressionModel),true)]
    4242  public partial class SymbolicExpressionModelView : AsynchronousContentView {
    43     public new SymbolicRegressionSolution Content {
    44       get { return (SymbolicRegressionSolution)base.Content; }
    45       set { base.Content = value; }
    46     }
    47 
    4843    public SymbolicExpressionModelView()
    4944      : base() {
    … …  
    5146    }
    5247
    53     protected override void RegisterContentEvents() {
    54       base.RegisterContentEvents();
    55       Content.ModelChanged += new EventHandler(Content_ModelChanged);
    56     }
    57 
    58     protected override void DeregisterContentEvents() {
    59       base.DeregisterContentEvents();
    60       Content.ModelChanged -= new EventHandler(Content_ModelChanged);
    61     }
    62 
    63     void Content_ModelChanged(object sender, EventArgs e) {
    64       UpdateTreeChart();
     48    public new SymbolicRegressionModel Content {
     49      get { return (SymbolicRegressionModel)base.Content; }
     50      set { base.Content = value; }
    6551    }
    6652
    6753    protected override void OnContentChanged() {
    6854      base.OnContentChanged();
    69       UpdateTreeChart();
     55      if (Content != null)
     56        UpdateTreeChart();
     57      else
     58        viewHost.Content = null;
    7059    }
    7160
    7261    private void UpdateTreeChart() {
    73       viewHost.Content = Content.Model.SymbolicExpressionTree;
     62      viewHost.Content = Content.SymbolicExpressionTree;
    7463    }
    7564  }

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

    r3877 r3884  
    7171
    7272    #region events
    73     protected virtual void OnDataAnalysisProblemChanged(EventArgs e) { }
     73    protected virtual void OnDataAnalysisProblemChanged(EventArgs e) {
     74      RaiseReset(e);
     75    }
    7476
    7577    private void RegisterParameterEvents() {

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

    r3710 r3884  
    3636  [StorableClass]
    3737  public abstract class DataAnalysisSolution : NamedItem {
     38    protected DataAnalysisSolution()
     39      : base() { }
     40    protected DataAnalysisSolution(DataAnalysisProblemData problemData) : this(problemData, double.NegativeInfinity, double.PositiveInfinity) { }
     41    protected DataAnalysisSolution(DataAnalysisProblemData problemData, double lowerEstimationLimit, double upperEstimationLimit)
     42      : this() {
     43      this.problemData = problemData;
     44      this.lowerEstimationLimit = lowerEstimationLimit;
     45      this.upperEstimationLimit = upperEstimationLimit;
     46      Initialize();
     47    }
     48
     49    [StorableConstructor]
     50    private DataAnalysisSolution(bool deserializing) : base(deserializing) { }
     51    [StorableHook(HookType.AfterDeserialization)]
     52    private void Initialize() {
     53      if (problemData != null) RegisterProblemDataEvents();
     54    }
     55
    3856    [Storable]
    3957    private DataAnalysisProblemData problemData;
    … …  
    4361        if (problemData != value) {
    4462          if (value == null) throw new ArgumentNullException();
     63          if (model != null && problemData != null && !problemData.InputVariables.Select(c => c.Value).SequenceEqual(
     64            value.InputVariables.Select(c => c.Value)))
     65            throw new ArgumentException("Could not set new problem data with different structure");
     66
    4567          if (problemData != null) DeregisterProblemDataEvents();
    4668          problemData = value;
    4769          RegisterProblemDataEvents();
    48           OnProblemDataChanged(EventArgs.Empty);
     70          OnProblemDataChanged();
    4971        }
    5072      }
    5173    }
     74
     75    [Storable]
     76    private IDataAnalysisModel model;
     77    public IDataAnalysisModel Model {
     78      get { return model; }
     79      set {
     80        if (model != value) {
     81          if (value == null) throw new ArgumentNullException();
     82          model = value;
     83          OnModelChanged();
     84        }
     85      }
     86    }
     87
    5288    [Storable]
    5389    private double lowerEstimationLimit;
    … …  
    5793        if (lowerEstimationLimit != value) {
    5894          lowerEstimationLimit = value;
    59           OnEstimatedValuesChanged(EventArgs.Empty);
     95          RecalculateEstimatedValues();
    6096        }
    6197      }
    … …  
    69105        if (upperEstimationLimit != value) {
    70106          upperEstimationLimit = value;
    71           OnEstimatedValuesChanged(EventArgs.Empty);
     107          RecalculateEstimatedValues();
    72108        }
    73109      }
    … …  
    77113    public abstract IEnumerable<double> EstimatedTrainingValues { get; }
    78114    public abstract IEnumerable<double> EstimatedTestValues { get; }
    79 
    80     protected DataAnalysisSolution() : base() {
    81       Name = ItemName;
    82       Description = ItemDescription;
    83     }
    84     protected DataAnalysisSolution(DataAnalysisProblemData problemData) : this(problemData, double.NegativeInfinity, double.PositiveInfinity) { }
    85     protected DataAnalysisSolution(DataAnalysisProblemData problemData, double lowerEstimationLimit, double upperEstimationLimit)
    86       : this() {
    87       this.problemData = problemData;
    88       this.lowerEstimationLimit = lowerEstimationLimit;
    89       this.upperEstimationLimit = upperEstimationLimit;
    90       Initialize();
    91     }
    92 
    93     [StorableConstructor]
    94     private DataAnalysisSolution(bool deserializing) : base(deserializing) { }
    95 
    96     [StorableHook(HookType.AfterDeserialization)]
    97     private void Initialize() {
    98       if (problemData != null) RegisterProblemDataEvents();
    99     }
    100 
    101     public override IDeepCloneable Clone(Cloner cloner) {
    102       DataAnalysisSolution clone = (DataAnalysisSolution)base.Clone(cloner);
    103       // don't clone the problem data!
    104       clone.problemData = problemData;
    105       clone.lowerEstimationLimit = lowerEstimationLimit;
    106       clone.upperEstimationLimit = upperEstimationLimit;
    107       clone.Initialize();
    108       return clone;
    109     }
     115    protected abstract void RecalculateEstimatedValues();
    110116
    111117    #region Events
    … …  
    116122      ProblemData.ProblemDataChanged += new EventHandler(ProblemData_Changed);
    117123    }
    118 
    119124    private void ProblemData_Changed(object sender, EventArgs e) {
    120       OnProblemDataChanged(EventArgs.Empty);
     125      OnProblemDataChanged();
    121126    }
    122127
    123128    public event EventHandler ProblemDataChanged;
    124     protected virtual void OnProblemDataChanged(EventArgs e) {
     129    protected virtual void OnProblemDataChanged() {
     130      RecalculateEstimatedValues();
    125131      var listeners = ProblemDataChanged;
    126132      if (listeners != null)
    127         listeners(this, e);
     133        listeners(this, EventArgs.Empty);
     134    }
     135
     136    public event EventHandler ModelChanged;
     137    protected virtual void OnModelChanged() {
     138      RecalculateEstimatedValues();
     139      EventHandler handler = ModelChanged;
     140      if (handler != null)
     141        handler(this, EventArgs.Empty);
    128142    }
    129143
    130144    public event EventHandler EstimatedValuesChanged;
    131     protected virtual void OnEstimatedValuesChanged(EventArgs e) {
     145    protected virtual void OnEstimatedValuesChanged() {
    132146      var listeners = EstimatedValuesChanged;
    133147      if (listeners != null)
    134         listeners(this, e);
     148        listeners(this, EventArgs.Empty);
    135149    }
    136150    #endregion
     151
     152    public override IDeepCloneable Clone(Cloner cloner) {
     153      DataAnalysisSolution clone = (DataAnalysisSolution)base.Clone(cloner);
     154      // don't clone the problem data!
     155      clone.problemData = problemData;
     156      clone.Model = (IDataAnalysisModel)cloner.Clone(model);
     157      clone.lowerEstimationLimit = lowerEstimationLimit;
     158      clone.upperEstimationLimit = upperEstimationLimit;
     159      clone.Initialize();
     160      return clone;
     161    }
    137162  }
    138163}

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

    r3877 r3884  
    9898    <Compile Include="Evaluators\SimpleVarianceAccountedForEvaluator.cs" />
    9999    <Compile Include="HeuristicLabProblemsDataAnalysisPlugin.cs" />
     100    <Compile Include="Interfaces\IDataAnalysisModel.cs" />
    100101    <Compile Include="Interfaces\IDataAnalysisProblem.cs" />
    101102    <Compile Include="MatrixExtensions.cs" />
    102103    <Compile Include="Properties\AssemblyInfo.cs" />
     104    <Compile Include="SupportVectorMachine\ParameterAdjustmentProblem\SupportVectorRegressionParameterAdjustmentBestSolutionAnalyzer.cs" />
    103105    <Compile Include="SupportVectorMachine\ParameterAdjustmentProblem\SupportVectorRegressionParameterAdjustmentEvaluator.cs" />
    104106    <Compile Include="SupportVectorMachine\ParameterAdjustmentProblem\SupportVectorRegressionParameterAdjustmentProblem.cs" />

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

    r3883 r3884  
    3434
    3535namespace HeuristicLab.Problems.DataAnalysis.SupportVectorMachine.ParameterAdjustmentProblem {
    36   [Item("SupportVectorRegressionParameterAdjustmentEvaluator", "")]
     36  [Item("SupportVectorMachineParameterAdjustmentEvaluator", "")]
    3737  [StorableClass]
    38   public class SupportVectorRegressionParameterAdjustmentEvaluator : AlgorithmOperator, ISingleObjectiveEvaluator {
     38  public class SupportVectorMachineParameterAdjustmentEvaluator : AlgorithmOperator, ISingleObjectiveEvaluator {
    3939    private const string ParameterVectorParameterName = "ParameterVector";
    4040    private const string DataAnalysisProblemDataParameterName = "DataAnalysisProblemData";
    … …  
    112112    #endregion
    113113
    114     public SupportVectorRegressionParameterAdjustmentEvaluator()
     114    public SupportVectorMachineParameterAdjustmentEvaluator()
    115115      : base() {
    116116      StringValue nuSvrType = new StringValue("NU_SVR").AsReadOnly();
    … …  
    141141      GammaParameter.Value = new DoubleValue(Math.Pow(2, point[2]));
    142142      EpsilonParameter.Value = new DoubleValue();
    143 
    144143      return base.Apply();
    145144    }

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

    r3883 r3884  
    3636
    3737namespace HeuristicLab.Problems.DataAnalysis.SupportVectorMachine.ParameterAdjustmentProblem {
    38   [Item("Support Vector Regression Parameter Adjustment Problem", "Represents the problem of finding good parameter settings for support vector machines.")]
     38  [Item("Support Vector Machine Parameter Adjustment Problem", "Represents the problem of finding good parameter settings for support vector machines.")]
    3939  [StorableClass]
    4040  [Creatable("Problems")]
    41   public sealed class SupportVectorRegressionParameterAdjustmentProblem : DataAnalysisProblem, ISingleObjectiveProblem {
     41  public sealed class SupportVectorMachineParameterAdjustmentProblem : DataAnalysisProblem, ISingleObjectiveProblem {
    4242
    4343    #region Parameter Properties
    … …  
    6060      get { return SolutionCreatorParameter; }
    6161    }
    62     public new ValueParameter<SupportVectorRegressionParameterAdjustmentEvaluator> EvaluatorParameter {
    63       get { return (ValueParameter<SupportVectorRegressionParameterAdjustmentEvaluator>)Parameters["Evaluator"]; }
     62    public new ValueParameter<SupportVectorMachineParameterAdjustmentEvaluator> EvaluatorParameter {
     63      get { return (ValueParameter<SupportVectorMachineParameterAdjustmentEvaluator>)Parameters["Evaluator"]; }
    6464    }
    6565    IParameter IProblem.EvaluatorParameter {
    … …  
    9696      get { return SolutionCreatorParameter.Value; }
    9797    }
    98     public new SupportVectorRegressionParameterAdjustmentEvaluator Evaluator {
     98    public new SupportVectorMachineParameterAdjustmentEvaluator Evaluator {
    9999      get { return EvaluatorParameter.Value; }
    100100      set { EvaluatorParameter.Value = value; }
    … …  
    115115    }
    116116    #endregion
    117 
    118 
    119     //public int MinimumProblemSize {
    120     //  get { return 3; }
    121     //}
    122     //public int MaximumProblemSize {
    123     //  get { return 3; }
    124     //}
    125117
    126118    public IntValue TrainingSamplesStart {
    … …  
    139131
    140132    [StorableConstructor]
    141     private SupportVectorRegressionParameterAdjustmentProblem(bool deserializing) : base() { }
    142     public SupportVectorRegressionParameterAdjustmentProblem()
     133    private SupportVectorMachineParameterAdjustmentProblem(bool deserializing) : base() { }
     134    public SupportVectorMachineParameterAdjustmentProblem()
    143135      : base() {
    144136      UniformRandomRealVectorCreator creator = new UniformRandomRealVectorCreator();
    145       SupportVectorRegressionParameterAdjustmentEvaluator evaluator = new SupportVectorRegressionParameterAdjustmentEvaluator();
     137      SupportVectorMachineParameterAdjustmentEvaluator evaluator = new SupportVectorMachineParameterAdjustmentEvaluator();
    146138
    147139      var bounds = new DoubleMatrix(new double[,] {
    … …  
    155147      Parameters.Add(new ValueParameter<IntValue>("ProblemSize", "The dimension of the problem.", new IntValue(3)));
    156148      Parameters.Add(new ValueParameter<IRealVectorCreator>("SolutionCreator", "The operator which should be used to create new test function solutions.", creator));
    157       Parameters.Add(new ValueParameter<SupportVectorRegressionParameterAdjustmentEvaluator>("Evaluator", "The operator which should be used to evaluate test function solutions.", evaluator));
     149      Parameters.Add(new ValueParameter<SupportVectorMachineParameterAdjustmentEvaluator>("Evaluator", "The operator which should be used to evaluate test function solutions.", evaluator));
    158150      Parameters.Add(new OptionalValueParameter<DoubleValue>("BestKnownQuality", "The quality of the best known solution of this test function.", new DoubleValue(0)));
    159151      Parameters.Add(new OptionalValueParameter<RealVector>("BestKnownSolution", "The best known solution for this test function instance."));
    … …  
    169161      ParameterizeSolutionCreator();
    170162      ParameterizeEvaluator();
     163      ParameterizeAnalyzers();
    171164
    172165      Initialize();
    … …  
    175168
    176169    public override IDeepCloneable Clone(Cloner cloner) {
    177       SupportVectorRegressionParameterAdjustmentProblem clone = (SupportVectorRegressionParameterAdjustmentProblem)base.Clone(cloner);
     170      SupportVectorMachineParameterAdjustmentProblem clone = (SupportVectorMachineParameterAdjustmentProblem)base.Clone(cloner);
    178171      clone.strategyVectorCreator = (StdDevStrategyVectorCreator)cloner.Clone(strategyVectorCreator);
    179172      clone.strategyVectorCrossover = (StdDevStrategyVectorCrossover)cloner.Clone(strategyVectorCrossover);
    … …  
    191184    private void SolutionCreatorParameter_ValueChanged(object sender, EventArgs e) {
    192185      ParameterizeSolutionCreator();
    193       //ParameterizeAnalyzers();
     186      ParameterizeAnalyzers();
    194187      SolutionCreator_RealVectorParameter_ActualNameChanged(null, EventArgs.Empty);
    195188    }
    … …  
    197190      ParameterizeEvaluator();
    198191      ParameterizeOperators();
    199       //ParameterizeAnalyzers();
     192      ParameterizeAnalyzers();
    200193    }
    201194    private void EvaluatorParameter_ValueChanged(object sender, EventArgs e) {
    202195      ParameterizeEvaluator();
    203       //ParameterizeAnalyzers();
     196      ParameterizeAnalyzers();
    204197      RaiseReset(EventArgs.Empty);
    205198    }
    … …  
    224217      operators = new List<IOperator>();
    225218      operators.AddRange(ApplicationManager.Manager.GetInstances<IRealVectorOperator>().Cast<IOperator>());
     219      operators.Add(new SupportVectorMachineParameterAdjustmentBestSolutionAnalyzer());
    226220      operators.Add(strategyVectorCreator);
    227221      operators.Add(strategyVectorCrossover);
    … …  
    254248        op.BoundsParameter.ActualName = BoundsParameter.Name;
    255249      }
    256       foreach (SupportVectorRegressionParameterAdjustmentEvaluator op in Operators.OfType<SupportVectorRegressionParameterAdjustmentEvaluator>()) {
     250      foreach (SupportVectorMachineParameterAdjustmentEvaluator op in Operators.OfType<SupportVectorMachineParameterAdjustmentEvaluator>()) {
    257251        op.QualityParameter.ActualName = Evaluator.QualityParameter.ActualName;
    258252        op.ParameterVectorParameter.ActualName = SolutionCreator.RealVectorParameter.ActualName;

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

    r3877 r3884  
    4141  [Item("SupportVectorMachineCrossValidationEvaluator", "Represents an operator that performs SVM cross validation with the given parameters.")]
    4242  public class SupportVectorMachineCrossValidationEvaluator : SingleSuccessorOperator, ISingleObjectiveEvaluator {
     43    private const string RandomParameterName = "Random";
    4344    private const string DataAnalysisProblemDataParameterName = "DataAnalysisProblemData";
    4445    private const string SvmTypeParameterName = "SvmType";
    … …  
    5051    private const string SamplesStartParameterName = "SamplesStart";
    5152    private const string SamplesEndParameterName = "SamplesEnd";
     53    private const string ActualSamplesParameterName = "ActualSamples";
    5254    private const string NumberOfFoldsParameterName = "NumberOfFolds";
    5355    private const string QualityParameterName = "Quality";
    5456
    5557    #region parameter properties
     58    public ILookupParameter<IRandom> RandomParameter {
     59      get { return (ILookupParameter<IRandom>)Parameters[RandomParameterName]; }
     60    }
    5661    public IValueLookupParameter<DataAnalysisProblemData> DataAnalysisProblemDataParameter {
    5762      get { return (IValueLookupParameter<DataAnalysisProblemData>)Parameters[DataAnalysisProblemDataParameterName]; }
    … …  
    8085    public IValueLookupParameter<IntValue> SamplesEndParameter {
    8186      get { return (IValueLookupParameter<IntValue>)Parameters[SamplesEndParameterName]; }
     87    }
     88    public IValueLookupParameter<PercentValue> ActualSamplesParameter {
     89      get { return (IValueLookupParameter<PercentValue>)Parameters[ActualSamplesParameterName]; }
    8290    }
    8391    public IValueLookupParameter<IntValue> NumberOfFoldsParameter {
    … …  
    123131    public SupportVectorMachineCrossValidationEvaluator()
    124132      : base() {
     133      Parameters.Add(new LookupParameter<IRandom>(RandomParameterName, "The random generator to use."));
    125134      Parameters.Add(new ValueLookupParameter<DataAnalysisProblemData>(DataAnalysisProblemDataParameterName, "The data analysis problem data to use for training."));
    126135      Parameters.Add(new ValueLookupParameter<StringValue>(SvmTypeParameterName, "The type of SVM to use."));
    … …  
    132141      Parameters.Add(new ValueLookupParameter<IntValue>(SamplesStartParameterName, "The first index of the data set partition the support vector machine should use for training."));
    133142      Parameters.Add(new ValueLookupParameter<IntValue>(SamplesEndParameterName, "The last index of the data set partition the support vector machine should use for training."));
     143      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)."));
    134144      Parameters.Add(new ValueLookupParameter<IntValue>(NumberOfFoldsParameterName, "The number of folds to use for cross-validation."));
    135145      Parameters.Add(new LookupParameter<DoubleValue>(QualityParameterName, "The cross validation quality reached with the given parameters."));
    … …  
    137147
    138148    public override IOperation Apply() {
    139       double quality = PerformCrossValidation(DataAnalysisProblemData,
    140                              SamplesStart.Value, SamplesEnd.Value,
     149      double reductionRatio = 1.0;
     150      if (ActualSamplesParameter.ActualValue != null)
     151        reductionRatio = ActualSamplesParameter.ActualValue.Value;
     152
     153      int reducedRows = (int)((SamplesEnd.Value - SamplesStart.Value) * reductionRatio);
     154      var reducedProblemData = (DataAnalysisProblemData)DataAnalysisProblemData.Clone();
     155      ShuffleRows(RandomParameter.ActualValue, reducedProblemData.Dataset, SamplesStart.Value, SamplesEnd.Value);
     156
     157      double quality = PerformCrossValidation(reducedProblemData,
     158                             SamplesStart.Value, SamplesStart.Value + reducedRows,
    141159                             SvmType.Value, KernelType.Value,
    142160                             Cost.Value, Nu.Value, Gamma.Value, Epsilon.Value, NumberOfFolds.Value);
    … …  
    144162      QualityParameter.ActualValue = new DoubleValue(quality);
    145163      return base.Apply();
     164    }
     165
     166    private void ShuffleRows(IRandom random, Dataset dataset, int start, int end) {
     167      for (int row = end - 1; row > start ; row--) {
     168        int otherRow = random.Next(start, row);
     169        for (int column = 0; column < dataset.Columns; column++) {
     170          double tmp = dataset[otherRow, column];
     171          dataset[otherRow, column] = dataset[row, column];
     172          dataset[row, column] = tmp;
     173        }
     174      }
    146175    }
    147176
    … …  
    178207      SVM.Problem scaledProblem = Scaling.Scale(rangeTransform, problem);
    179208
    180       return SVM.Training.PerformCrossValidation(scaledProblem, parameter, nFolds);
     209      return SVM.Training.PerformCrossValidation(scaledProblem, parameter, nFolds, false);
    181210    }
    182211  }

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

    r3853 r3884  
    2929using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
    3030using HeuristicLab.Common;
     31using SVM;
     32using System.Linq;
    3133
    3234namespace HeuristicLab.Problems.DataAnalysis.SupportVectorMachine {
    … …  
    3638  [StorableClass]
    3739  [Item("SupportVectorMachineModel", "Represents a support vector machine model.")]
    38   public class SupportVectorMachineModel : NamedItem {
     40  public class SupportVectorMachineModel : NamedItem, IDataAnalysisModel {
     41    public SupportVectorMachineModel()
     42      : base() {
     43    }
     44
    3945    private SVM.Model model;
    4046    /// <summary>
    … …  
    6773    }
    6874
    69     public SupportVectorMachineModel()
    70       : base() {
     75    public IEnumerable<double> GetEstimatedValues(DataAnalysisProblemData problemData, int start, int end) {
     76      SVM.Problem problem = SupportVectorMachineUtil.CreateSvmProblem(problemData, start, end);
     77      SVM.Problem scaledProblem = Scaling.Scale(RangeTransform, problem);
     78
     79      return (from row in Enumerable.Range(0, scaledProblem.Count)
     80              select SVM.Prediction.Predict(Model, scaledProblem.X[row])).ToList();
    7181    }
    7282
    … …  
    8191
    8292    #region persistence
     93    [Storable]
     94    private int[] SupportVectorIndizes {
     95      get { return this.Model.SupportVectorIndizes; }
     96      set { this.Model.SupportVectorIndizes = value; }
     97    }
     98
    8399    [Storable]
    84100    private string ModelAsString {
    … …  
    131147      StreamWriter writer = new StreamWriter(s);
    132148      writer.WriteLine("RangeTransform:");
    133       writer.Flush(); 
     149      writer.Flush();
    134150      using (MemoryStream memStream = new MemoryStream()) {
    135151        SVM.RangeTransform.Write(memStream, model.RangeTransform);
Note: See TracChangeset for help on using the changeset viewer.