Free cookie consent management tool by TermsFeed Policy Generator

Ignore:
Timestamp:
07/17/11 22:51:11 (13 years ago)
Author:
abeham
Message:

#1541

  • updated to latest trunk version
Location:
branches/QAPAlgorithms
Files:
22 edited

Legend:

Unmodified
Added
Removed

  • branches/QAPAlgorithms

  • branches/QAPAlgorithms/HeuristicLab.Problems.DataAnalysis

  • branches/QAPAlgorithms/HeuristicLab.Problems.DataAnalysis/3.3/HeuristicLabProblemsDataAnalysisPlugin.cs.frame

    r6099 r6569  
    2626
    2727namespace HeuristicLab.Problems.DataAnalysis {
    28   [Plugin("HeuristicLab.Problems.DataAnalysis", "3.3.4.$WCREV$")]
     28  [Plugin("HeuristicLab.Problems.DataAnalysis", "3.3.5.$WCREV$")]
    2929  [PluginFile("HeuristicLab.Problems.DataAnalysis-3.3.dll", PluginFileType.Assembly)]
    3030  [PluginDependency("HeuristicLab.ALGLIB", "3.1")]

  • branches/QAPAlgorithms/HeuristicLab.Problems.DataAnalysis/3.3/Properties/AssemblyInfo.frame

    r6099 r6569  
    5353// by using the '*' as shown below:
    5454[assembly: AssemblyVersion("3.3.0.0")]
    55 [assembly: AssemblyFileVersion("3.3.4.$WCREV$")]
     55[assembly: AssemblyFileVersion("3.3.5.$WCREV$")]

  • branches/QAPAlgorithms/HeuristicLab.Problems.DataAnalysis/3.3/Tests/Properties/AssemblyInfo.cs

    r5446 r6569  
    5252// by using the '*' as shown below:
    5353[assembly: AssemblyVersion("3.3.0.0")]
    54 [assembly: AssemblyFileVersion("3.3.3.0")]
     54[assembly: AssemblyFileVersion("3.3.5.0")]

  • branches/QAPAlgorithms/HeuristicLab.Problems.DataAnalysis/3.4/HeuristicLabProblemsDataAnalysisPlugin.cs.frame

    r5860 r6569  
    2626
    2727namespace HeuristicLab.Problems.DataAnalysis {
    28   [Plugin("HeuristicLab.Problems.DataAnalysis","Provides base classes for data analysis tasks.", "3.4.0.$WCREV$")]
     28  [Plugin("HeuristicLab.Problems.DataAnalysis","Provides base classes for data analysis tasks.", "3.4.1.$WCREV$")]
    2929  [PluginFile("HeuristicLab.Problems.DataAnalysis-3.4.dll", PluginFileType.Assembly)]
    3030  [PluginDependency("HeuristicLab.Collections", "3.3")]

  • branches/QAPAlgorithms/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ClassificationEnsembleModel.cs

    r6239 r6569  
    5858
    5959    #region IClassificationEnsembleModel Members
     60    public void Add(IClassificationModel model) {
     61      models.Add(model);
     62    }
    6063
    6164    public IEnumerable<IEnumerable<double>> GetEstimatedClassValueVectors(Dataset dataset, IEnumerable<int> rows) {

  • branches/QAPAlgorithms/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ClassificationEnsembleProblemData.cs

    r6239 r6569  
    3737    public override IEnumerable<int> TrainingIndizes {
    3838      get {
    39         return Enumerable.Range(TrainingPartition.Start, TestPartition.End - TestPartition.Start);
     39        return Enumerable.Range(TrainingPartition.Start, TrainingPartition.End - TrainingPartition.Start);
    4040      }
    4141    }

  • branches/QAPAlgorithms/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ClassificationEnsembleSolution.cs

    r6302 r6569  
    7979      this.trainingPartitions = new Dictionary<IClassificationModel, IntRange>();
    8080      this.testPartitions = new Dictionary<IClassificationModel, IntRange>();
    81       var modelEnumerator = models.GetEnumerator();
    82       var trainingPartitionEnumerator = trainingPartitions.GetEnumerator();
    83       var testPartitionEnumerator = testPartitions.GetEnumerator();
    84       while (modelEnumerator.MoveNext() & trainingPartitionEnumerator.MoveNext() & testPartitionEnumerator.MoveNext()) {
    85         this.trainingPartitions[modelEnumerator.Current] = (IntRange)trainingPartitionEnumerator.Current.Clone();
    86         this.testPartitions[modelEnumerator.Current] = (IntRange)testPartitionEnumerator.Current.Clone();
    87       }
    88       if (modelEnumerator.MoveNext() | trainingPartitionEnumerator.MoveNext() | testPartitionEnumerator.MoveNext()) {
    89         throw new ArgumentException();
    90       }
     81      AddModelsAndParitions(models,
     82        trainingPartitions,
     83        testPartitions);
    9184      RecalculateResults();
    9285    }
    … …  
    169162      .First();
    170163    }
     164
     165    public void AddModelsAndParitions(IEnumerable<IClassificationSolution> solutions) {
     166      foreach (var solution in solutions) {
     167        var ensembleSolution = solution as ClassificationEnsembleSolution;
     168        if (ensembleSolution != null) {
     169          var data = from m in ensembleSolution.Model.Models
     170                     let train = ensembleSolution.trainingPartitions[m]
     171                     let test = ensembleSolution.testPartitions[m]
     172                     select new { m, train, test };
     173
     174          foreach (var d in data) {
     175            Model.Add(d.m);
     176            trainingPartitions[d.m] = (IntRange)d.train.Clone();
     177            testPartitions[d.m] = (IntRange)d.test.Clone();
     178          }
     179        } else {
     180          Model.Add(solution.Model);
     181          trainingPartitions[solution.Model] = (IntRange)solution.ProblemData.TrainingPartition.Clone();
     182          testPartitions[solution.Model] = (IntRange)solution.ProblemData.TestPartition.Clone();
     183        }
     184      }
     185
     186      RecalculateResults();
     187    }
     188
     189    private void AddModelsAndParitions(IEnumerable<IClassificationModel> models, IEnumerable<IntRange> trainingPartitions, IEnumerable<IntRange> testPartitions) {
     190      var modelEnumerator = models.GetEnumerator();
     191      var trainingPartitionEnumerator = trainingPartitions.GetEnumerator();
     192      var testPartitionEnumerator = testPartitions.GetEnumerator();
     193
     194      while (modelEnumerator.MoveNext() & trainingPartitionEnumerator.MoveNext() & testPartitionEnumerator.MoveNext()) {
     195        this.trainingPartitions[modelEnumerator.Current] = (IntRange)trainingPartitionEnumerator.Current.Clone();
     196        this.testPartitions[modelEnumerator.Current] = (IntRange)testPartitionEnumerator.Current.Clone();
     197      }
     198      if (modelEnumerator.MoveNext() | trainingPartitionEnumerator.MoveNext() | testPartitionEnumerator.MoveNext()) {
     199        throw new ArgumentException();
     200      }
     201    }
    171202  }
    172203}

  • branches/QAPAlgorithms/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ClassificationProblemData.cs

    r6223 r6569  
    185185
    186186    #region parameter properties
    187     public IValueParameter<StringValue> TargetVariableParameter {
    188       get { return (IValueParameter<StringValue>)Parameters[TargetVariableParameterName]; }
     187    public ConstrainedValueParameter<StringValue> TargetVariableParameter {
     188      get { return (ConstrainedValueParameter<StringValue>)Parameters[TargetVariableParameterName]; }
    189189    }
    190190    public IFixedValueParameter<StringMatrix> ClassNamesParameter {

  • branches/QAPAlgorithms/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ClassificationSolution.cs

    r6184 r6569  
    2020#endregion
    2121
    22 using System;
    2322using System.Collections.Generic;
    2423using System.Linq;
    … …  
    6665      Add(new Result(TrainingAccuracyResultName, "Accuracy of the model on the training partition (percentage of correctly classified instances).", new PercentValue()));
    6766      Add(new Result(TestAccuracyResultName, "Accuracy of the model on the test partition (percentage of correctly classified instances).", new PercentValue()));
    68       RecalculateResults();
     67      CalculateResults();
    6968    }
    7069
    … …  
    7372    }
    7473
    75     protected override void OnProblemDataChanged(EventArgs e) {
    76       base.OnProblemDataChanged(e);
    77       RecalculateResults();
     74    protected override void RecalculateResults() {
     75      CalculateResults();
    7876    }
    7977
    80     protected override void OnModelChanged(EventArgs e) {
    81       base.OnModelChanged(e);
    82       RecalculateResults();
    83     }
    84 
    85     protected void RecalculateResults() {
     78    private void CalculateResults() {
    8679      double[] estimatedTrainingClassValues = EstimatedTrainingClassValues.ToArray(); // cache values
    8780      IEnumerable<double> originalTrainingClassValues = ProblemData.Dataset.GetEnumeratedVariableValues(ProblemData.TargetVariable, ProblemData.TrainingIndizes);

  • branches/QAPAlgorithms/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/DiscriminantFunctionClassificationSolution.cs

    r5942 r6569  
    2525using HeuristicLab.Common;
    2626using HeuristicLab.Core;
    27 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
    2827using HeuristicLab.Data;
    2928using HeuristicLab.Optimization;
     29using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
    3030
    3131namespace HeuristicLab.Problems.DataAnalysis {
    … …  
    8989      Add(new Result(TrainingRSquaredResultName, "Squared Pearson's correlation coefficient of the model output and the actual values on the training partition", new DoubleValue()));
    9090      Add(new Result(TestRSquaredResultName, "Squared Pearson's correlation coefficient of the model output and the actual values on the test partition", new DoubleValue()));
     91      SetAccuracyMaximizingThresholds();
     92
     93      //mkommend: important to recalculate accuracy because during the calculation before no thresholds were present     
     94      base.RecalculateResults();
     95      CalculateResults();
    9196      RegisterEventHandler();
    92       SetAccuracyMaximizingThresholds();
    93       RecalculateResults();
    9497    }
    9598
    … …  
    99102    }
    100103
    101     protected new void RecalculateResults() {
     104    protected override void OnModelChanged(EventArgs e) {
     105      DeregisterEventHandler();
     106      SetAccuracyMaximizingThresholds();
     107      RegisterEventHandler();
     108      base.OnModelChanged(e);
     109    }
     110
     111    protected override void RecalculateResults() {
     112      base.RecalculateResults();
     113      CalculateResults();
     114    }
     115
     116    private void CalculateResults() {
    102117      double[] estimatedTrainingValues = EstimatedTrainingValues.ToArray(); // cache values
    103118      IEnumerable<double> originalTrainingValues = ProblemData.Dataset.GetEnumeratedVariableValues(ProblemData.TargetVariable, ProblemData.TrainingIndizes);
    … …  
    119134    private void RegisterEventHandler() {
    120135      Model.ThresholdsChanged += new EventHandler(Model_ThresholdsChanged);
     136    }
     137    private void DeregisterEventHandler() {
     138      Model.ThresholdsChanged -= new EventHandler(Model_ThresholdsChanged);
    121139    }
    122140    private void Model_ThresholdsChanged(object sender, EventArgs e) {
    … …  
    142160    }
    143161
    144     protected override void OnModelChanged(EventArgs e) {
    145       base.OnModelChanged(e);
    146       SetAccuracyMaximizingThresholds();
    147       RecalculateResults();
    148     }
    149 
    150     protected override void OnProblemDataChanged(EventArgs e) {
    151       base.OnProblemDataChanged(e);
    152       SetAccuracyMaximizingThresholds();
    153       RecalculateResults();
    154     }
    155162    protected virtual void OnModelThresholdsChanged(EventArgs e) {
    156       base.OnModelChanged(e);
    157163      RecalculateResults();
    158164    }

  • branches/QAPAlgorithms/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Clustering/ClusteringSolution.cs

    r6184 r6569  
    4545    }
    4646
     47    protected override void RecalculateResults() {
     48    }
     49
    4750    #region IClusteringSolution Members
    4851

  • branches/QAPAlgorithms/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/DataAnalysisSolution.cs

    r5914 r6569  
    8686    }
    8787
     88    protected abstract void RecalculateResults();
     89
    8890    private void ProblemData_Changed(object sender, EventArgs e) {
    8991      OnProblemDataChanged(e);
    … …  
    9294    public event EventHandler ModelChanged;
    9395    protected virtual void OnModelChanged(EventArgs e) {
     96      RecalculateResults();
    9497      var listeners = ModelChanged;
    9598      if (listeners != null) listeners(this, e);
    … …  
    98101    public event EventHandler ProblemDataChanged;
    99102    protected virtual void OnProblemDataChanged(EventArgs e) {
     103      RecalculateResults();
    100104      var listeners = ProblemDataChanged;
    101105      if (listeners != null) listeners(this, e);

  • branches/QAPAlgorithms/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/RegressionEnsembleModel.cs

    r5809 r6569  
    5858    #region IRegressionEnsembleModel Members
    5959
     60    public void Add(IRegressionModel model) {
     61      models.Add(model);
     62    }
     63
    6064    public IEnumerable<IEnumerable<double>> GetEstimatedValueVectors(Dataset dataset, IEnumerable<int> rows) {
    6165      var estimatedValuesEnumerators = (from model in models

  • branches/QAPAlgorithms/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/RegressionEnsembleSolution.cs

    r6302 r6569  
    6464      trainingPartitions = new Dictionary<IRegressionModel, IntRange>();
    6565      testPartitions = new Dictionary<IRegressionModel, IntRange>();
    66       foreach (var model in models) {
    67         trainingPartitions[model] = (IntRange)problemData.TrainingPartition.Clone();
    68         testPartitions[model] = (IntRange)problemData.TestPartition.Clone();
    69       }
     66      AddModelsAndParitions(models,
     67        from m in models select (IntRange)problemData.TrainingPartition.Clone(),
     68        from m in models select (IntRange)problemData.TestPartition.Clone());
    7069      RecalculateResults();
    7170    }
    … …  
    7574      this.trainingPartitions = new Dictionary<IRegressionModel, IntRange>();
    7675      this.testPartitions = new Dictionary<IRegressionModel, IntRange>();
    77       var modelEnumerator = models.GetEnumerator();
    78       var trainingPartitionEnumerator = trainingPartitions.GetEnumerator();
    79       var testPartitionEnumerator = testPartitions.GetEnumerator();
    80       while (modelEnumerator.MoveNext() & trainingPartitionEnumerator.MoveNext() & testPartitionEnumerator.MoveNext()) {
    81         this.trainingPartitions[modelEnumerator.Current] = (IntRange)trainingPartitionEnumerator.Current.Clone();
    82         this.testPartitions[modelEnumerator.Current] = (IntRange)testPartitionEnumerator.Current.Clone();
    83       }
    84       if (modelEnumerator.MoveNext() | trainingPartitionEnumerator.MoveNext() | testPartitionEnumerator.MoveNext()) {
    85         throw new ArgumentException();
    86       }
     76      AddModelsAndParitions(models, trainingPartitions, testPartitions);
    8777      RecalculateResults();
    8878    }
    … …  
    160150      return estimatedValues.DefaultIfEmpty(double.NaN).Average();
    161151    }
     152
     153
     154    public void AddModelsAndParitions(IEnumerable<IRegressionSolution> solutions) {
     155      foreach (var solution in solutions) {
     156        var ensembleSolution = solution as RegressionEnsembleSolution;
     157        if (ensembleSolution != null) {
     158          var data = from m in ensembleSolution.Model.Models
     159                     let train = ensembleSolution.trainingPartitions[m]
     160                     let test = ensembleSolution.testPartitions[m]
     161                     select new { m, train, test };
     162
     163          foreach (var d in data) {
     164            Model.Add(d.m);
     165            trainingPartitions[d.m] = (IntRange)d.train.Clone();
     166            testPartitions[d.m] = (IntRange)d.test.Clone();
     167          }
     168        } else {
     169          Model.Add(solution.Model);
     170          trainingPartitions[solution.Model] = (IntRange)solution.ProblemData.TrainingPartition.Clone();
     171          testPartitions[solution.Model] = (IntRange)solution.ProblemData.TestPartition.Clone();
     172        }
     173      }
     174
     175      RecalculateResults();
     176    }
     177
     178    private void AddModelsAndParitions(IEnumerable<IRegressionModel> models, IEnumerable<IntRange> trainingPartitions, IEnumerable<IntRange> testPartitions) {
     179      var modelEnumerator = models.GetEnumerator();
     180      var trainingPartitionEnumerator = trainingPartitions.GetEnumerator();
     181      var testPartitionEnumerator = testPartitions.GetEnumerator();
     182
     183      while (modelEnumerator.MoveNext() & trainingPartitionEnumerator.MoveNext() & testPartitionEnumerator.MoveNext()) {
     184        this.trainingPartitions[modelEnumerator.Current] = (IntRange)trainingPartitionEnumerator.Current.Clone();
     185        this.testPartitions[modelEnumerator.Current] = (IntRange)testPartitionEnumerator.Current.Clone();
     186      }
     187      if (modelEnumerator.MoveNext() | trainingPartitionEnumerator.MoveNext() | testPartitionEnumerator.MoveNext()) {
     188        throw new ArgumentException();
     189      }
     190    }
    162191  }
    163192}

  • branches/QAPAlgorithms/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/RegressionProblemData.cs

    r6238 r6569  
    7777    #endregion
    7878
    79     public IValueParameter<StringValue> TargetVariableParameter {
    80       get { return (IValueParameter<StringValue>)Parameters[TargetVariableParameterName]; }
     79    public ConstrainedValueParameter<StringValue> TargetVariableParameter {
     80      get { return (ConstrainedValueParameter<StringValue>)Parameters[TargetVariableParameterName]; }
    8181    }
    8282    public string TargetVariable {

  • branches/QAPAlgorithms/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/RegressionSolution.cs

    r6238 r6569  
    2020#endregion
    2121
    22 using System;
    2322using System.Collections.Generic;
    2423using System.Linq;
    … …  
    110109      Add(new Result(TestNormalizedMeanSquaredErrorResultName, "Normalized mean of squared errors of the model on the test partition", new DoubleValue()));
    111110
    112       RecalculateResults();
     111      CalculateResults();
    113112    }
    114113
    … …  
    117116    }
    118117
    119     protected override void OnProblemDataChanged(EventArgs e) {
    120       base.OnProblemDataChanged(e);
    121       RecalculateResults();
    122     }
    123     protected override void OnModelChanged(EventArgs e) {
    124       base.OnModelChanged(e);
    125       RecalculateResults();
     118    protected override void RecalculateResults() {
     119      CalculateResults();
    126120    }
    127121
    128     protected void RecalculateResults() {
     122    private void CalculateResults() {
    129123      double[] estimatedTrainingValues = EstimatedTrainingValues.ToArray(); // cache values
    130124      IEnumerable<double> originalTrainingValues = ProblemData.Dataset.GetEnumeratedVariableValues(ProblemData.TargetVariable, ProblemData.TrainingIndizes);

  • branches/QAPAlgorithms/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/Classification/IClassificationEnsembleModel.cs

    r5809 r6569  
    2323namespace HeuristicLab.Problems.DataAnalysis {
    2424  public interface IClassificationEnsembleModel : IClassificationModel {
     25    void Add(IClassificationModel model);
    2526    IEnumerable<IClassificationModel> Models { get; }
    2627    IEnumerable<IEnumerable<double>> GetEstimatedClassValueVectors(Dataset dataset, IEnumerable<int> rows);

  • branches/QAPAlgorithms/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/Regression/IRegressionEnsembleModel.cs

    r5809 r6569  
    2323namespace HeuristicLab.Problems.DataAnalysis {
    2424  public interface IRegressionEnsembleModel : IRegressionModel {
     25    void Add(IRegressionModel model);
    2526    IEnumerable<IRegressionModel> Models { get; }
    2627    IEnumerable<IEnumerable<double>> GetEstimatedValueVectors(Dataset dataset, IEnumerable<int> rows);

  • branches/QAPAlgorithms/HeuristicLab.Problems.DataAnalysis/3.4/Properties/AssemblyInfo.frame

    r5860 r6569  
    5353// by using the '*' as shown below:
    5454[assembly: AssemblyVersion("3.4.0.0")]
    55 [assembly: AssemblyFileVersion("3.4.0.$WCREV$")]
     55[assembly: AssemblyFileVersion("3.4.1.$WCREV$")]

  • branches/QAPAlgorithms/HeuristicLab.Problems.DataAnalysis/3.4/Tests/Properties/AssemblyInfo.cs

    r5809 r6569  
    5252// by using the '*' as shown below:
    5353[assembly: AssemblyVersion("3.4.0.0")]
    54 [assembly: AssemblyFileVersion("3.4.0.0")]
     54[assembly: AssemblyFileVersion("3.4.1.0")]
Note: See TracChangeset for help on using the changeset viewer.