Changeset 8723


Ignore:
Timestamp:
10/03/12 11:38:57 (7 years ago)
Author:
mkommend
Message:

#1964: Added new results to symbolic classification and regression solutions. Additionally, the way results are calculated was refactored and unified.

Location:
trunk/sources
Files:
18 edited

Legend:

Unmodified
Added
Removed
  • trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/Linear/MultinomialLogitClassificationSolution.cs

    r7259 r8723  
    4545    public MultinomialLogitClassificationSolution(IClassificationProblemData problemData, MultinomialLogitModel logitModel)
    4646      : base(logitModel, problemData) {
    47       RecalculateResults();
    4847    }
    4948
     
    5150      return new MultinomialLogitClassificationSolution(this, cloner);
    5251    }
    53 
    54     protected override void RecalculateResults() {
    55       CalculateResults();
    56     }
    5752  }
    5853}
  • trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/Nca/NcaClassificationSolution.cs

    r8471 r8723  
    4242    public NcaClassificationSolution(IClassificationProblemData problemData, INcaModel ncaModel)
    4343      : base(ncaModel, problemData) {
    44       RecalculateResults();
    4544    }
    4645
     
    4847      return new NcaClassificationSolution(this, cloner);
    4948    }
    50 
    51     protected override void RecalculateResults() {
    52       CalculateResults();
    53     }
    5449  }
    5550}
  • trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/NearestNeighbour/NearestNeighbourClassificationSolution.cs

    r7259 r8723  
    4545    public NearestNeighbourClassificationSolution(IClassificationProblemData problemData, INearestNeighbourModel nnModel)
    4646      : base(nnModel, problemData) {
    47       RecalculateResults();
    4847    }
    4948
     
    5150      return new NearestNeighbourClassificationSolution(this, cloner);
    5251    }
    53 
    54     protected override void RecalculateResults() {
    55       CalculateResults();
    56     }
    5752  }
    5853}
  • trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/NeuralNetwork/NeuralNetworkClassificationSolution.cs

    r7259 r8723  
    4545    public NeuralNetworkClassificationSolution(IClassificationProblemData problemData, INeuralNetworkModel nnModel)
    4646      : base(nnModel, problemData) {
    47       RecalculateResults();
    4847    }
    4948
     
    5150      return new NeuralNetworkClassificationSolution(this, cloner);
    5251    }
    53     protected override void RecalculateResults() {
    54       CalculateResults();
    55     }
     52
    5653  }
    5754}
  • trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/NeuralNetwork/NeuralNetworkEnsembleClassificationSolution.cs

    r7259 r8723  
    4545    public NeuralNetworkEnsembleClassificationSolution(IClassificationProblemData problemData, INeuralNetworkEnsembleModel nnModel)
    4646      : base(nnModel, problemData) {
    47       RecalculateResults();
    4847    }
    4948
     
    5150      return new NeuralNetworkEnsembleClassificationSolution(this, cloner);
    5251    }
    53 
    54     protected override void RecalculateResults() {
    55       CalculateResults();
    56     }
    5752  }
    5853}
  • trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/RandomForest/RandomForestClassificationSolution.cs

    r7259 r8723  
    4545    public RandomForestClassificationSolution(IClassificationProblemData problemData, IRandomForestModel randomForestModel)
    4646      : base(randomForestModel, problemData) {
    47       RecalculateResults();
    4847    }
    4948
     
    5150      return new RandomForestClassificationSolution(this, cloner);
    5251    }
    53 
    54     protected override void RecalculateResults() {
    55       CalculateResults();
    56     }
    5752  }
    5853}
  • trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/SupportVectorMachine/SupportVectorClassificationSolution.cs

    r7259 r8723  
    4545    public SupportVectorClassificationSolution(SupportVectorMachineModel model, IClassificationProblemData problemData)
    4646      : base(model, problemData) {
    47       RecalculateResults();
    4847    }
    4948
     
    5150      return new SupportVectorClassificationSolution(this, cloner);
    5251    }
    53 
    54     protected override void RecalculateResults() {
    55       CalculateResults();
    56     }
    5752  }
    5853}
  • trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SymbolicClassificationSolution.cs

    r7259 r8723  
    7171
    7272    protected override void RecalculateResults() {
     73      base.RecalculateResults();
    7374      ModelLength = Model.SymbolicExpressionTree.Length;
    7475      ModelDepth = Model.SymbolicExpressionTree.Depth;
    75       CalculateResults();
    7676    }
    7777  }
  • trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SymbolicDiscriminantFunctionClassificationSolution.cs

    r8684 r8723  
    2020#endregion
    2121
     22using System.Linq;
    2223using HeuristicLab.Common;
    2324using HeuristicLab.Core;
     
    3536    private const string ModelLengthResultName = "Model Length";
    3637    private const string ModelDepthResultName = "Model Depth";
     38
     39    private const string EstimationLimitsResultsResultName = "Estimation Limits Results";
     40    private const string EstimationLimitsResultName = "Estimation Limits";
     41    private const string TrainingUpperEstimationLimitHitsResultName = "Training Upper Estimation Limit Hits";
     42    private const string TestLowerEstimationLimitHitsResultName = "Test Lower Estimation Limit Hits";
     43    private const string TrainingLowerEstimationLimitHitsResultName = "Training Lower Estimation Limit Hits";
     44    private const string TestUpperEstimationLimitHitsResultName = "Test Upper Estimation Limit Hits";
     45    private const string TrainingNaNEvaluationsResultName = "Training NaN Evaluations";
     46    private const string TestNaNEvaluationsResultName = "Test NaN Evaluations";
    3747
    3848    public new ISymbolicDiscriminantFunctionClassificationModel Model {
     
    5767      private set { ((IntValue)this[ModelDepthResultName].Value).Value = value; }
    5868    }
     69
     70    private ResultCollection EstimationLimitsResultCollection {
     71      get { return (ResultCollection)this[EstimationLimitsResultsResultName].Value; }
     72    }
     73    public DoubleLimit EstimationLimits {
     74      get { return (DoubleLimit)EstimationLimitsResultCollection[EstimationLimitsResultName].Value; }
     75    }
     76
     77    public int TrainingUpperEstimationLimitHits {
     78      get { return ((IntValue)EstimationLimitsResultCollection[TrainingUpperEstimationLimitHitsResultName].Value).Value; }
     79      private set { ((IntValue)EstimationLimitsResultCollection[TrainingUpperEstimationLimitHitsResultName].Value).Value = value; }
     80    }
     81    public int TestUpperEstimationLimitHits {
     82      get { return ((IntValue)EstimationLimitsResultCollection[TestUpperEstimationLimitHitsResultName].Value).Value; }
     83      private set { ((IntValue)EstimationLimitsResultCollection[TestUpperEstimationLimitHitsResultName].Value).Value = value; }
     84    }
     85    public int TrainingLowerEstimationLimitHits {
     86      get { return ((IntValue)EstimationLimitsResultCollection[TrainingLowerEstimationLimitHitsResultName].Value).Value; }
     87      private set { ((IntValue)EstimationLimitsResultCollection[TrainingLowerEstimationLimitHitsResultName].Value).Value = value; }
     88    }
     89    public int TestLowerEstimationLimitHits {
     90      get { return ((IntValue)EstimationLimitsResultCollection[TestLowerEstimationLimitHitsResultName].Value).Value; }
     91      private set { ((IntValue)EstimationLimitsResultCollection[TestLowerEstimationLimitHitsResultName].Value).Value = value; }
     92    }
     93    public int TrainingNaNEvaluations {
     94      get { return ((IntValue)EstimationLimitsResultCollection[TrainingNaNEvaluationsResultName].Value).Value; }
     95      private set { ((IntValue)EstimationLimitsResultCollection[TrainingNaNEvaluationsResultName].Value).Value = value; }
     96    }
     97    public int TestNaNEvaluations {
     98      get { return ((IntValue)EstimationLimitsResultCollection[TestNaNEvaluationsResultName].Value).Value; }
     99      private set { ((IntValue)EstimationLimitsResultCollection[TestNaNEvaluationsResultName].Value).Value = value; }
     100    }
     101
    59102    [StorableConstructor]
    60103    private SymbolicDiscriminantFunctionClassificationSolution(bool deserializing) : base(deserializing) { }
     
    66109      Add(new Result(ModelLengthResultName, "Length of the symbolic classification model.", new IntValue()));
    67110      Add(new Result(ModelDepthResultName, "Depth of the symbolic classification model.", new IntValue()));
    68       CalculateSymbolicDiscriminantFunctionClassificationResults();
     111
     112
     113      ResultCollection estimationLimitResults = new ResultCollection();
     114      estimationLimitResults.Add(new Result(EstimationLimitsResultName, "", new DoubleLimit()));
     115      estimationLimitResults.Add(new Result(TrainingUpperEstimationLimitHitsResultName, "", new IntValue()));
     116      estimationLimitResults.Add(new Result(TestUpperEstimationLimitHitsResultName, "", new IntValue()));
     117      estimationLimitResults.Add(new Result(TrainingLowerEstimationLimitHitsResultName, "", new IntValue()));
     118      estimationLimitResults.Add(new Result(TestLowerEstimationLimitHitsResultName, "", new IntValue()));
     119      estimationLimitResults.Add(new Result(TrainingNaNEvaluationsResultName, "", new IntValue()));
     120      estimationLimitResults.Add(new Result(TestNaNEvaluationsResultName, "", new IntValue()));
     121      Add(new Result(EstimationLimitsResultsResultName, "Results concerning the estimation limits of symbolic regression solution", estimationLimitResults));
     122
     123      CalculateResults();
    69124    }
    70125
     
    73128    }
    74129
    75     private void CalculateSymbolicDiscriminantFunctionClassificationResults() {
    76       CalculateResults();
    77       CalculateRegressionResults();
     130    [StorableHook(HookType.AfterDeserialization)]
     131    private void AfterDeserialization() {
     132      if (!ContainsKey(EstimationLimitsResultsResultName)) {
     133        ResultCollection estimationLimitResults = new ResultCollection();
     134        estimationLimitResults.Add(new Result(EstimationLimitsResultName, "", new DoubleLimit()));
     135        estimationLimitResults.Add(new Result(TrainingUpperEstimationLimitHitsResultName, "", new IntValue()));
     136        estimationLimitResults.Add(new Result(TestUpperEstimationLimitHitsResultName, "", new IntValue()));
     137        estimationLimitResults.Add(new Result(TrainingLowerEstimationLimitHitsResultName, "", new IntValue()));
     138        estimationLimitResults.Add(new Result(TestLowerEstimationLimitHitsResultName, "", new IntValue()));
     139        estimationLimitResults.Add(new Result(TrainingNaNEvaluationsResultName, "", new IntValue()));
     140        estimationLimitResults.Add(new Result(TestNaNEvaluationsResultName, "", new IntValue()));
     141        Add(new Result(EstimationLimitsResultsResultName, "Results concerning the estimation limits of symbolic regression solution", estimationLimitResults));
     142        CalculateResults();
     143      }
     144    }
     145
     146
     147    private void CalculateResults() {
    78148      ModelLength = Model.SymbolicExpressionTree.Length;
    79149      ModelDepth = Model.SymbolicExpressionTree.Depth;
     150
     151      EstimationLimits.Lower = Model.LowerEstimationLimit;
     152      EstimationLimits.Upper = Model.UpperEstimationLimit;
     153
     154      TrainingUpperEstimationLimitHits = EstimatedTrainingValues.Count(x => x.IsAlmost(Model.UpperEstimationLimit));
     155      TestUpperEstimationLimitHits = EstimatedTestValues.Count(x => x.IsAlmost(Model.UpperEstimationLimit));
     156      TrainingLowerEstimationLimitHits = EstimatedTrainingValues.Count(x => x.IsAlmost(Model.LowerEstimationLimit));
     157      TestLowerEstimationLimitHits = EstimatedTestValues.Count(x => x.IsAlmost(Model.LowerEstimationLimit));
     158      TrainingNaNEvaluations = Model.Interpreter.GetSymbolicExpressionTreeValues(Model.SymbolicExpressionTree, ProblemData.Dataset, ProblemData.TrainingIndices).Count(double.IsNaN);
     159      TestNaNEvaluations = Model.Interpreter.GetSymbolicExpressionTreeValues(Model.SymbolicExpressionTree, ProblemData.Dataset, ProblemData.TestIndices).Count(double.IsNaN);
    80160    }
    81161
    82162    protected override void RecalculateResults() {
    83       CalculateSymbolicDiscriminantFunctionClassificationResults();
     163      base.RecalculateResults();
     164      CalculateResults();
    84165    }
    85166  }
  • trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SymbolicRegressionSolution.cs

    r7259 r8723  
    2020#endregion
    2121
     22using System.Linq;
    2223using HeuristicLab.Common;
    2324using HeuristicLab.Core;
     
    3536    private const string ModelLengthResultName = "Model Length";
    3637    private const string ModelDepthResultName = "Model Depth";
     38
     39    private const string EstimationLimitsResultsResultName = "Estimation Limits Results";
     40    private const string EstimationLimitsResultName = "Estimation Limits";
     41    private const string TrainingUpperEstimationLimitHitsResultName = "Training Upper Estimation Limit Hits";
     42    private const string TestLowerEstimationLimitHitsResultName = "Test Lower Estimation Limit Hits";
     43    private const string TrainingLowerEstimationLimitHitsResultName = "Training Lower Estimation Limit Hits";
     44    private const string TestUpperEstimationLimitHitsResultName = "Test Upper Estimation Limit Hits";
     45    private const string TrainingNaNEvaluationsResultName = "Training NaN Evaluations";
     46    private const string TestNaNEvaluationsResultName = "Test NaN Evaluations";
    3747
    3848    public new ISymbolicRegressionModel Model {
     
    5363    }
    5464
     65    private ResultCollection EstimationLimitsResultCollection {
     66      get { return (ResultCollection)this[EstimationLimitsResultsResultName].Value; }
     67    }
     68    public DoubleLimit EstimationLimits {
     69      get { return (DoubleLimit)EstimationLimitsResultCollection[EstimationLimitsResultName].Value; }
     70    }
     71
     72    public int TrainingUpperEstimationLimitHits {
     73      get { return ((IntValue)EstimationLimitsResultCollection[TrainingUpperEstimationLimitHitsResultName].Value).Value; }
     74      private set { ((IntValue)EstimationLimitsResultCollection[TrainingUpperEstimationLimitHitsResultName].Value).Value = value; }
     75    }
     76    public int TestUpperEstimationLimitHits {
     77      get { return ((IntValue)EstimationLimitsResultCollection[TestUpperEstimationLimitHitsResultName].Value).Value; }
     78      private set { ((IntValue)EstimationLimitsResultCollection[TestUpperEstimationLimitHitsResultName].Value).Value = value; }
     79    }
     80    public int TrainingLowerEstimationLimitHits {
     81      get { return ((IntValue)EstimationLimitsResultCollection[TrainingLowerEstimationLimitHitsResultName].Value).Value; }
     82      private set { ((IntValue)EstimationLimitsResultCollection[TrainingLowerEstimationLimitHitsResultName].Value).Value = value; }
     83    }
     84    public int TestLowerEstimationLimitHits {
     85      get { return ((IntValue)EstimationLimitsResultCollection[TestLowerEstimationLimitHitsResultName].Value).Value; }
     86      private set { ((IntValue)EstimationLimitsResultCollection[TestLowerEstimationLimitHitsResultName].Value).Value = value; }
     87    }
     88    public int TrainingNaNEvaluations {
     89      get { return ((IntValue)EstimationLimitsResultCollection[TrainingNaNEvaluationsResultName].Value).Value; }
     90      private set { ((IntValue)EstimationLimitsResultCollection[TrainingNaNEvaluationsResultName].Value).Value = value; }
     91    }
     92    public int TestNaNEvaluations {
     93      get { return ((IntValue)EstimationLimitsResultCollection[TestNaNEvaluationsResultName].Value).Value; }
     94      private set { ((IntValue)EstimationLimitsResultCollection[TestNaNEvaluationsResultName].Value).Value = value; }
     95    }
     96
    5597    [StorableConstructor]
    5698    private SymbolicRegressionSolution(bool deserializing) : base(deserializing) { }
     
    62104      Add(new Result(ModelLengthResultName, "Length of the symbolic regression model.", new IntValue()));
    63105      Add(new Result(ModelDepthResultName, "Depth of the symbolic regression model.", new IntValue()));
     106
     107      ResultCollection estimationLimitResults = new ResultCollection();
     108      estimationLimitResults.Add(new Result(EstimationLimitsResultName, "", new DoubleLimit()));
     109      estimationLimitResults.Add(new Result(TrainingUpperEstimationLimitHitsResultName, "", new IntValue()));
     110      estimationLimitResults.Add(new Result(TestUpperEstimationLimitHitsResultName, "", new IntValue()));
     111      estimationLimitResults.Add(new Result(TrainingLowerEstimationLimitHitsResultName, "", new IntValue()));
     112      estimationLimitResults.Add(new Result(TestLowerEstimationLimitHitsResultName, "", new IntValue()));
     113      estimationLimitResults.Add(new Result(TrainingNaNEvaluationsResultName, "", new IntValue()));
     114      estimationLimitResults.Add(new Result(TestNaNEvaluationsResultName, "", new IntValue()));
     115      Add(new Result(EstimationLimitsResultsResultName, "Results concerning the estimation limits of symbolic regression solution", estimationLimitResults));
     116
    64117      RecalculateResults();
    65118    }
     
    69122    }
    70123
     124    [StorableHook(HookType.AfterDeserialization)]
     125    private void AfterDeserialization() {
     126      if (!ContainsKey(EstimationLimitsResultsResultName)) {
     127        ResultCollection estimationLimitResults = new ResultCollection();
     128        estimationLimitResults.Add(new Result(EstimationLimitsResultName, "", new DoubleLimit()));
     129        estimationLimitResults.Add(new Result(TrainingUpperEstimationLimitHitsResultName, "", new IntValue()));
     130        estimationLimitResults.Add(new Result(TestUpperEstimationLimitHitsResultName, "", new IntValue()));
     131        estimationLimitResults.Add(new Result(TrainingLowerEstimationLimitHitsResultName, "", new IntValue()));
     132        estimationLimitResults.Add(new Result(TestLowerEstimationLimitHitsResultName, "", new IntValue()));
     133        estimationLimitResults.Add(new Result(TrainingNaNEvaluationsResultName, "", new IntValue()));
     134        estimationLimitResults.Add(new Result(TestNaNEvaluationsResultName, "", new IntValue()));
     135        Add(new Result(EstimationLimitsResultsResultName, "Results concerning the estimation limits of symbolic regression solution", estimationLimitResults));
     136        CalculateResults();
     137      }
     138    }
     139
    71140    protected override void RecalculateResults() {
    72141      base.RecalculateResults();
     142      CalculateResults();
     143    }
     144
     145    private void CalculateResults() {
    73146      ModelLength = Model.SymbolicExpressionTree.Length;
    74147      ModelDepth = Model.SymbolicExpressionTree.Depth;
     148
     149      EstimationLimits.Lower = Model.LowerEstimationLimit;
     150      EstimationLimits.Upper = Model.UpperEstimationLimit;
     151
     152      TrainingUpperEstimationLimitHits = EstimatedTrainingValues.Count(x => x.IsAlmost(Model.UpperEstimationLimit));
     153      TestUpperEstimationLimitHits = EstimatedTestValues.Count(x => x.IsAlmost(Model.UpperEstimationLimit));
     154      TrainingLowerEstimationLimitHits = EstimatedTrainingValues.Count(x => x.IsAlmost(Model.LowerEstimationLimit));
     155      TestLowerEstimationLimitHits = EstimatedTestValues.Count(x => x.IsAlmost(Model.LowerEstimationLimit));
     156      TrainingNaNEvaluations = Model.Interpreter.GetSymbolicExpressionTreeValues(Model.SymbolicExpressionTree, ProblemData.Dataset, ProblemData.TrainingIndices).Count(double.IsNaN);
     157      TestNaNEvaluations = Model.Interpreter.GetSymbolicExpressionTreeValues(Model.SymbolicExpressionTree, ProblemData.Dataset, ProblemData.TestIndices).Count(double.IsNaN);
    75158    }
    76159  }
  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ClassificationEnsembleSolution.cs

    r8528 r8723  
    153153    }
    154154
    155     protected override void RecalculateResults() {
    156       CalculateResults();
    157     }
    158155
    159156    #region Evaluation
  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ClassificationSolution.cs

    r8174 r8723  
    4545      : base(model, problemData) {
    4646      evaluationCache = new Dictionary<int, double>(problemData.Dataset.Rows);
     47      CalculateClassificationResults();
    4748    }
    4849
  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ClassificationSolutionBase.cs

    r8139 r8723  
    8585    }
    8686
    87     protected void CalculateResults() {
     87    protected void CalculateClassificationResults() {
    8888      double[] estimatedTrainingClassValues = EstimatedTrainingClassValues.ToArray(); // cache values
    8989      double[] originalTrainingClassValues = ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TrainingIndices).ToArray();
     
    114114
    115115    public abstract IEnumerable<double> GetEstimatedClassValues(IEnumerable<int> rows);
     116
     117    protected override void RecalculateResults() {
     118      CalculateClassificationResults();
     119    }
    116120  }
    117121}
  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/DiscriminantFunctionClassificationSolution.cs

    r8684 r8723  
    5151      valueEvaluationCache = new Dictionary<int, double>();
    5252      classValueEvaluationCache = new Dictionary<int, double>();
    53       CalculateDiscriminantFunctionClassificationResults();
     53      CalculateRegressionResults();
     54      CalculateClassificationResults();
    5455    }
    5556
     
    117118      base.OnProblemDataChanged();
    118119    }
    119 
    120 
    121     private void CalculateDiscriminantFunctionClassificationResults() {
    122       CalculateResults();
    123       CalculateRegressionResults();
    124     }
    125 
    126     protected override void RecalculateResults() {
    127       CalculateDiscriminantFunctionClassificationResults();
    128     }
    129120  }
    130121}
  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/DiscriminantFunctionClassificationSolutionBase.cs

    r8552 r8723  
    8585      Add(new Result(TrainingRSquaredResultName, "Squared Pearson's correlation coefficient of the model output and the actual values on the training partition", new DoubleValue()));
    8686      Add(new Result(TestRSquaredResultName, "Squared Pearson's correlation coefficient of the model output and the actual values on the test partition", new DoubleValue()));
    87 
    8887      RegisterEventHandler();
    8988    }
     
    139138
    140139    public abstract IEnumerable<double> GetEstimatedValues(IEnumerable<int> rows);
     140
     141    protected override void RecalculateResults() {
     142      base.RecalculateResults();
     143      CalculateRegressionResults();
     144    }
    141145  }
    142146}
  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/RegressionEnsembleSolution.cs

    r8174 r8723  
    155155    }
    156156
    157     protected override void RecalculateResults() {
    158       CalculateResults();
    159     }
    160 
    161157    #region Evaluation
    162158    public override IEnumerable<double> EstimatedTrainingValues {
  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/RegressionSolution.cs

    r8139 r8723  
    4545      : base(model, problemData) {
    4646      evaluationCache = new Dictionary<int, double>(problemData.Dataset.Rows);
     47      CalculateRegressionResults();
    4748    }
    4849
    49     protected override void RecalculateResults() {
    50       CalculateResults();
    51     }
    5250
    5351    public override IEnumerable<double> EstimatedValues {
  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/RegressionSolutionBase.cs

    r8139 r8723  
    164164    }
    165165
    166     protected void CalculateResults() {
     166    protected override void RecalculateResults() {
     167      CalculateRegressionResults();
     168    }
     169
     170    protected void CalculateRegressionResults() {
    167171      IEnumerable<double> estimatedTrainingValues = EstimatedTrainingValues; // cache values
    168172      IEnumerable<double> originalTrainingValues = ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TrainingIndices);
Note: See TracChangeset for help on using the changeset viewer.