Free cookie consent management tool by TermsFeed Policy Generator

source: trunk/sources/HeuristicLab.Tests/HeuristicLab.Problems.DataAnalysis-3.4/ThresholdCalculatorsTest.cs @ 8658

Last change on this file since 8658 was 8658, checked in by gkronber, 11 years ago

#1925 fixed some bugs in NormalDistributionCutPointsThresholdCalculator (probably more remaining)

File size: 8.7 KB
Line 
1#region License Information
2/* HeuristicLab
3 * Copyright (C) 2002-2012 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 HeuristicLab.Problems.DataAnalysis;
23using Microsoft.VisualStudio.TestTools.UnitTesting;
24namespace HeuristicLab.Problems.DataAnalysis_34.Tests {
25
26  [TestClass()]
27  public class ThresholdCalculatorsTest {
28    [TestMethod]
29    public void NormalDistributionCutPointsThresholdCalculatorTest() {
30
31      {
32        // simple two-class case
33        double[] estimatedValues = new double[] { 1.0, 0.99, 1.01, 2.0, 1.99, 2.01 };
34        double[] targetClassValues = new double[] { 0.0, 0.0, 0.0, 1.0, 1.0, 1.0 };
35        double[] classValues;
36        double[] thresholds;
37        NormalDistributionCutPointsThresholdCalculator.CalculateThresholds(null, estimatedValues, targetClassValues,
38                                                                           out classValues, out thresholds);
39
40        var expectedClassValues = new double[] { 0.0, 1.0 };
41        var expectedTresholds = new double[] { double.NegativeInfinity, 1.5 };
42
43        AssertEqual(expectedClassValues, classValues);
44        AssertEqual(expectedTresholds, thresholds);
45      }
46
47      {
48        // switched classes two-class case
49        double[] estimatedValues = new double[] { 1.0, 0.99, 1.01, 2.0, 1.99, 2.01 };
50        double[] targetClassValues = new double[] { 1.0, 1.0, 1.0, 0.0, 0.0, 0.0 };
51        double[] classValues;
52        double[] thresholds;
53        NormalDistributionCutPointsThresholdCalculator.CalculateThresholds(null, estimatedValues, targetClassValues,
54                                                                           out classValues, out thresholds);
55
56        var expectedClassValues = new double[] { 1.0, 0.0 };
57        var expectedTresholds = new double[] { double.NegativeInfinity, 1.5 };
58
59        AssertEqual(expectedClassValues, classValues);
60        AssertEqual(expectedTresholds, thresholds);
61      }
62
63      {
64        // three-class case with permutated estimated values
65        double[] estimatedValues = new double[] { 1.0, 0.99, 1.01, 2.0, 1.99, 2.01, -1.0, -0.99, -1.01 };
66        double[] targetClassValues = new double[] { 2.0, 2.0, 2.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0 };
67        double[] classValues;
68        double[] thresholds;
69        NormalDistributionCutPointsThresholdCalculator.CalculateThresholds(null, estimatedValues, targetClassValues,
70                                                                           out classValues, out thresholds);
71
72        var expectedClassValues = new double[] { 1.0, 2.0, 0.0 };
73        var expectedTresholds = new double[] { double.NegativeInfinity, 0.0, 1.5 };
74
75        AssertEqual(expectedClassValues, classValues);
76        AssertEqual(expectedTresholds, thresholds);
77      }
78
79      {
80        // constant output values for all classes
81        double[] estimatedValues = new double[] { 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 };
82        double[] targetClassValues = new double[] { 2.0, 2.0, 2.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0 };
83        double[] classValues;
84        double[] thresholds;
85        NormalDistributionCutPointsThresholdCalculator.CalculateThresholds(null, estimatedValues, targetClassValues,
86                                                                           out classValues, out thresholds);
87
88        var expectedClassValues = new double[] { 0.0 };
89        var expectedTresholds = new double[] { double.NegativeInfinity };
90
91        AssertEqual(expectedClassValues, classValues);
92        AssertEqual(expectedTresholds, thresholds);
93      }
94
95      {
96        // constant output values for two of three classes
97        double[] estimatedValues = new double[] { 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, -1.0, -0.99, -1.01 };
98        double[] targetClassValues = new double[] { 2.0, 2.0, 2.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0 };
99        double[] classValues;
100        double[] thresholds;
101        NormalDistributionCutPointsThresholdCalculator.CalculateThresholds(null, estimatedValues, targetClassValues,
102                                                                           out classValues, out thresholds);
103
104
105        var expectedClassValues = new double[] { 1.0, 0.0, 1.0 };
106        double range = 1.0 + 1.01;
107        var expectedTresholds = new double[] { double.NegativeInfinity, 1.0 - 0.001 * range, 1.0 + 0.001 * range };
108
109        AssertEqual(expectedClassValues, classValues);
110        AssertEqual(expectedTresholds, thresholds);
111      }
112
113
114      {
115        // normal operation
116        double[] estimatedValues = new double[]
117                                     {
118                                       2.9937,
119                                       2.9861,
120                                       1.0202,
121                                       0.9844,
122                                       1.9912,
123                                       1.9970,
124                                       0.9776,
125                                       0.9611,
126                                       1.9882,
127                                       1.9953,
128                                       2.0147,
129                                       2.0106,
130                                       2.9949,
131                                       0.9925,
132                                       3.0050,
133                                       1.9987,
134                                       2.9973,
135                                       1.0110,
136                                       2.0160,
137                                       2.9559,
138                                       1.9943,
139                                       2.9477,
140                                       2.0158,
141                                       2.0026,
142                                       1.9837,
143                                       3.0185,
144                                     };
145        double[] targetClassValues = new double[]
146                                       {
147                                          3,
148                                          3,
149                                          1,
150                                          1,
151                                          2,
152                                          2,
153                                          1,
154                                          1,
155                                          2,
156                                          2,
157                                          2,
158                                          2,
159                                          3,
160                                          1,
161                                          3,
162                                          2,
163                                          3,
164                                          1,
165                                          2,
166                                          3,
167                                          2,
168                                          3,
169                                          2,
170                                          2,
171                                          2,
172                                          3,
173                                       };
174
175        double[] classValues;
176        double[] thresholds;
177        NormalDistributionCutPointsThresholdCalculator.CalculateThresholds(null, estimatedValues, targetClassValues,
178                                                                           out classValues, out thresholds);
179
180
181        var expectedClassValues = new double[] { 2.0, 1.0, 2.0, 3.0 };
182        var expectedTresholds = new double[] { double.NegativeInfinity, -18.365068542315438, 1.6573010498191565, 2.314962133866949 };
183
184        AssertEqual(expectedClassValues, classValues);
185        AssertEqual(expectedTresholds, thresholds);
186      }
187    }
188
189
190    private static void AssertEqual(double[] expected, double[] actual) {
191      Assert.AreEqual(expected.Length, actual.Length);
192      for (int i = 0; i < expected.Length; i++)
193        Assert.AreEqual(expected[i], actual[i]);
194    }
195  }
196}
Note: See TracBrowser for help on using the repository browser.