source: stable/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SymbolicDiscriminantFunctionClassificationSolution.cs @ 17097

Last change on this file since 17097 was 17097, checked in by mkommend, 3 years ago

#2520: Merged 16565 - 16579 into stable.

File size: 9.8 KB
Line 
1#region License Information
2/* HeuristicLab
3 * Copyright (C) 2002-2019 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
4 *
5 * This file is part of HeuristicLab.
6 *
7 * HeuristicLab is free software: you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation, either version 3 of the License, or
10 * (at your option) any later version.
11 *
12 * HeuristicLab is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
19 */
20#endregion
21
22using System.Linq;
23using HeuristicLab.Common;
24using HeuristicLab.Core;
25using HeuristicLab.Data;
26using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
27using HeuristicLab.Optimization;
28using HEAL.Attic;
29
30namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Classification {
31  /// <summary>
32  /// Represents a symbolic classification solution (model + data) and attributes of the solution like accuracy and complexity
33  /// </summary>
34  [StorableType("83BEB8F0-DEF7-4E51-876D-9819BA10F2E8")]
35  [Item(Name = "SymbolicDiscriminantFunctionClassificationSolution", Description = "Represents a symbolic classification solution (model + data) and attributes of the solution like accuracy and complexity.")]
36  public sealed class SymbolicDiscriminantFunctionClassificationSolution : DiscriminantFunctionClassificationSolution, ISymbolicClassificationSolution {
37    private const string ModelLengthResultName = "Model Length";
38    private const string ModelDepthResultName = "Model Depth";
39
40    private const string EstimationLimitsResultsResultName = "Estimation Limits Results";
41    private const string EstimationLimitsResultName = "Estimation Limits";
42    private const string TrainingUpperEstimationLimitHitsResultName = "Training Upper Estimation Limit Hits";
43    private const string TestLowerEstimationLimitHitsResultName = "Test Lower Estimation Limit Hits";
44    private const string TrainingLowerEstimationLimitHitsResultName = "Training Lower Estimation Limit Hits";
45    private const string TestUpperEstimationLimitHitsResultName = "Test Upper Estimation Limit Hits";
46    private const string TrainingNaNEvaluationsResultName = "Training NaN Evaluations";
47    private const string TestNaNEvaluationsResultName = "Test NaN Evaluations";
48
49    public new ISymbolicDiscriminantFunctionClassificationModel Model {
50      get { return (ISymbolicDiscriminantFunctionClassificationModel)base.Model; }
51      set { base.Model = value; }
52    }
53
54    ISymbolicClassificationModel ISymbolicClassificationSolution.Model {
55      get { return Model; }
56    }
57
58    ISymbolicDataAnalysisModel ISymbolicDataAnalysisSolution.Model {
59      get { return Model; }
60    }
61    public int ModelLength {
62      get { return ((IntValue)this[ModelLengthResultName].Value).Value; }
63      private set { ((IntValue)this[ModelLengthResultName].Value).Value = value; }
64    }
65
66    public int ModelDepth {
67      get { return ((IntValue)this[ModelDepthResultName].Value).Value; }
68      private set { ((IntValue)this[ModelDepthResultName].Value).Value = value; }
69    }
70
71    private ResultCollection EstimationLimitsResultCollection {
72      get { return (ResultCollection)this[EstimationLimitsResultsResultName].Value; }
73    }
74    public DoubleLimit EstimationLimits {
75      get { return (DoubleLimit)EstimationLimitsResultCollection[EstimationLimitsResultName].Value; }
76    }
77
78    public int TrainingUpperEstimationLimitHits {
79      get { return ((IntValue)EstimationLimitsResultCollection[TrainingUpperEstimationLimitHitsResultName].Value).Value; }
80      private set { ((IntValue)EstimationLimitsResultCollection[TrainingUpperEstimationLimitHitsResultName].Value).Value = value; }
81    }
82    public int TestUpperEstimationLimitHits {
83      get { return ((IntValue)EstimationLimitsResultCollection[TestUpperEstimationLimitHitsResultName].Value).Value; }
84      private set { ((IntValue)EstimationLimitsResultCollection[TestUpperEstimationLimitHitsResultName].Value).Value = value; }
85    }
86    public int TrainingLowerEstimationLimitHits {
87      get { return ((IntValue)EstimationLimitsResultCollection[TrainingLowerEstimationLimitHitsResultName].Value).Value; }
88      private set { ((IntValue)EstimationLimitsResultCollection[TrainingLowerEstimationLimitHitsResultName].Value).Value = value; }
89    }
90    public int TestLowerEstimationLimitHits {
91      get { return ((IntValue)EstimationLimitsResultCollection[TestLowerEstimationLimitHitsResultName].Value).Value; }
92      private set { ((IntValue)EstimationLimitsResultCollection[TestLowerEstimationLimitHitsResultName].Value).Value = value; }
93    }
94    public int TrainingNaNEvaluations {
95      get { return ((IntValue)EstimationLimitsResultCollection[TrainingNaNEvaluationsResultName].Value).Value; }
96      private set { ((IntValue)EstimationLimitsResultCollection[TrainingNaNEvaluationsResultName].Value).Value = value; }
97    }
98    public int TestNaNEvaluations {
99      get { return ((IntValue)EstimationLimitsResultCollection[TestNaNEvaluationsResultName].Value).Value; }
100      private set { ((IntValue)EstimationLimitsResultCollection[TestNaNEvaluationsResultName].Value).Value = value; }
101    }
102
103    [StorableConstructor]
104    private SymbolicDiscriminantFunctionClassificationSolution(StorableConstructorFlag _) : base(_) { }
105    private SymbolicDiscriminantFunctionClassificationSolution(SymbolicDiscriminantFunctionClassificationSolution original, Cloner cloner)
106      : base(original, cloner) {
107    }
108    public SymbolicDiscriminantFunctionClassificationSolution(ISymbolicDiscriminantFunctionClassificationModel model, IClassificationProblemData problemData)
109      : base(model, problemData) {
110      foreach (var node in model.SymbolicExpressionTree.Root.IterateNodesPrefix().OfType<SymbolicExpressionTreeTopLevelNode>())
111        node.SetGrammar(null);
112
113      Add(new Result(ModelLengthResultName, "Length of the symbolic classification model.", new IntValue()));
114      Add(new Result(ModelDepthResultName, "Depth of the symbolic classification model.", new IntValue()));
115
116      ResultCollection estimationLimitResults = new ResultCollection();
117      estimationLimitResults.Add(new Result(EstimationLimitsResultName, "", new DoubleLimit()));
118      estimationLimitResults.Add(new Result(TrainingUpperEstimationLimitHitsResultName, "", new IntValue()));
119      estimationLimitResults.Add(new Result(TestUpperEstimationLimitHitsResultName, "", new IntValue()));
120      estimationLimitResults.Add(new Result(TrainingLowerEstimationLimitHitsResultName, "", new IntValue()));
121      estimationLimitResults.Add(new Result(TestLowerEstimationLimitHitsResultName, "", new IntValue()));
122      estimationLimitResults.Add(new Result(TrainingNaNEvaluationsResultName, "", new IntValue()));
123      estimationLimitResults.Add(new Result(TestNaNEvaluationsResultName, "", new IntValue()));
124      Add(new Result(EstimationLimitsResultsResultName, "Results concerning the estimation limits of symbolic regression solution", estimationLimitResults));
125
126      CalculateResults();
127    }
128
129    public override IDeepCloneable Clone(Cloner cloner) {
130      return new SymbolicDiscriminantFunctionClassificationSolution(this, cloner);
131    }
132
133    [StorableHook(HookType.AfterDeserialization)]
134    private void AfterDeserialization() {
135      if (!ContainsKey(EstimationLimitsResultsResultName)) {
136        ResultCollection estimationLimitResults = new ResultCollection();
137        estimationLimitResults.Add(new Result(EstimationLimitsResultName, "", new DoubleLimit()));
138        estimationLimitResults.Add(new Result(TrainingUpperEstimationLimitHitsResultName, "", new IntValue()));
139        estimationLimitResults.Add(new Result(TestUpperEstimationLimitHitsResultName, "", new IntValue()));
140        estimationLimitResults.Add(new Result(TrainingLowerEstimationLimitHitsResultName, "", new IntValue()));
141        estimationLimitResults.Add(new Result(TestLowerEstimationLimitHitsResultName, "", new IntValue()));
142        estimationLimitResults.Add(new Result(TrainingNaNEvaluationsResultName, "", new IntValue()));
143        estimationLimitResults.Add(new Result(TestNaNEvaluationsResultName, "", new IntValue()));
144        Add(new Result(EstimationLimitsResultsResultName, "Results concerning the estimation limits of symbolic regression solution", estimationLimitResults));
145        CalculateResults();
146      }
147    }
148
149
150    private void CalculateResults() {
151      ModelLength = Model.SymbolicExpressionTree.Length;
152      ModelDepth = Model.SymbolicExpressionTree.Depth;
153
154      EstimationLimits.Lower = Model.LowerEstimationLimit;
155      EstimationLimits.Upper = Model.UpperEstimationLimit;
156
157      TrainingUpperEstimationLimitHits = EstimatedTrainingValues.Count(x => x.IsAlmost(Model.UpperEstimationLimit));
158      TestUpperEstimationLimitHits = EstimatedTestValues.Count(x => x.IsAlmost(Model.UpperEstimationLimit));
159      TrainingLowerEstimationLimitHits = EstimatedTrainingValues.Count(x => x.IsAlmost(Model.LowerEstimationLimit));
160      TestLowerEstimationLimitHits = EstimatedTestValues.Count(x => x.IsAlmost(Model.LowerEstimationLimit));
161      TrainingNaNEvaluations = Model.Interpreter.GetSymbolicExpressionTreeValues(Model.SymbolicExpressionTree, ProblemData.Dataset, ProblemData.TrainingIndices).Count(double.IsNaN);
162      TestNaNEvaluations = Model.Interpreter.GetSymbolicExpressionTreeValues(Model.SymbolicExpressionTree, ProblemData.Dataset, ProblemData.TestIndices).Count(double.IsNaN);
163    }
164
165    protected override void RecalculateResults() {
166      base.RecalculateResults();
167      CalculateResults();
168    }
169  }
170}
Note: See TracBrowser for help on using the repository browser.