Пример #1
0
        public void TestDiscretePointEstimator()
        {
            var distribution = new Discrete(1, 1, 4, 2);

            Assert.Equal(2, distribution.GetMode());
            Assert.Equal(2, PointEstimator.GetEstimate(distribution, Metrics.ZeroOneError));          // Mode
            Assert.Equal(2, Convert.ToInt32(distribution.GetMean()));
            Assert.Equal(2, PointEstimator.GetEstimate(distribution, Metrics.SquaredError));          // Mean
            Assert.Equal(2, distribution.GetMedian());
            Assert.Equal(2, PointEstimator.GetEstimate(distribution, Metrics.AbsoluteError));         // Median
            Assert.Equal(2, PointEstimator.GetEstimate(distribution, this.LinearLossFunction()));     // Median

            Assert.Equal(1, PointEstimator.GetEstimate(distribution, this.LinearLossFunction(3)));    // 1st quartile
            Assert.Equal(2, PointEstimator.GetEstimate(distribution, this.LinearLossFunction(1, 3))); // 3rd quartile
            Assert.Equal(3, PointEstimator.GetEstimate(distribution, this.LinearLossFunction(1, 4))); // 4th quintile

            distribution = new Discrete(0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1);
            Assert.Equal(0, distribution.GetMode());
            Assert.Equal(4.5, distribution.GetMean(), 1e-10);
            int median = distribution.GetMedian();

            Assert.True(median == 4 || median == 5);
            Assert.Equal(3, PointEstimator.GetEstimate(distribution, this.LinearLossFunction(3, 2)));   // 2nd quintile
            Assert.Equal(7, PointEstimator.GetEstimate(distribution, this.LinearLossFunction(1, 3)));   // 3rd quartile
            Assert.Equal(9, PointEstimator.GetEstimate(distribution, this.LinearLossFunction(1, 999))); // 999th permille

            Assert.Throws <ArgumentNullException>(() => PointEstimator.GetEstimate(null, Metrics.AbsoluteError));
            Assert.Throws <ArgumentNullException>(() => PointEstimator.GetEstimate(distribution, null));

            // Test generic representation of distribution
            var genericDistribution = new Dictionary <int, double> {
                { 0, 1 }, { 1, 1 }, { 2, 4 }, { 3, 2 }
            };

            Assert.Equal(2, genericDistribution.GetMode());
            Assert.Equal(2, PointEstimator.GetEstimate(genericDistribution, Metrics.ZeroOneError));          // Mode
            Assert.Equal(2, PointEstimator.GetEstimate(genericDistribution, Metrics.SquaredError));          // Mean
            Assert.Equal(2, PointEstimator.GetEstimate(genericDistribution, Metrics.AbsoluteError));         // Median
            Assert.Equal(2, PointEstimator.GetEstimate(genericDistribution, this.LinearLossFunction()));     // Median
            Assert.Equal(1, PointEstimator.GetEstimate(genericDistribution, this.LinearLossFunction(3)));    // 1st quartile
            Assert.Equal(2, PointEstimator.GetEstimate(genericDistribution, this.LinearLossFunction(1, 3))); // 3rd quartile
            Assert.Equal(3, PointEstimator.GetEstimate(genericDistribution, this.LinearLossFunction(1, 4))); // 4th quintile

            genericDistribution = new Dictionary <int, double> {
                { 0, 0.1 }, { 1, 0.1 }, { 2, 0.1 }, { 3, 0.1 }, { 4, 0.1 }, { 5, 0.1 }, { 6, 0.1 }, { 7, 0.1 }, { 8, 0.1 }, { 9, 0.1 }
            };
            Assert.Equal(0, genericDistribution.GetMode());
            Assert.Equal(0, PointEstimator.GetEstimate(genericDistribution, Metrics.ZeroOneError));            // Mode
            Assert.Equal(4, PointEstimator.GetEstimate(genericDistribution, this.LinearLossFunction()));       // Median
            Assert.Equal(3, PointEstimator.GetEstimate(genericDistribution, this.LinearLossFunction(3, 2)));   // 2nd quintile
            Assert.Equal(7, PointEstimator.GetEstimate(genericDistribution, this.LinearLossFunction(1, 3)));   // 3rd quartile
            Assert.Equal(9, PointEstimator.GetEstimate(genericDistribution, this.LinearLossFunction(1, 999))); // 999th permille

            Assert.Throws <ArgumentNullException>(() => PointEstimator.GetEstimate(null, Metrics.AbsoluteError));
            Assert.Throws <ArgumentNullException>(() => PointEstimator.GetEstimate(genericDistribution, null));
        }
Пример #2
0
        public void TestBernoulliPointEstimator()
        {
            var distribution = new Bernoulli(0.25);

            Assert.False(distribution.GetMode());
            Assert.False(PointEstimator.GetEstimate(distribution, Metrics.ZeroOneError));  // Mode
            Assert.False(distribution.GetMean() >= 0.5);
            Assert.False(PointEstimator.GetEstimate(distribution, Metrics.SquaredError));  // Mean
            Assert.False(PointEstimator.GetEstimate(distribution, Metrics.AbsoluteError)); // Median = Mode

            distribution = new Bernoulli(0.5);
            Assert.True(distribution.GetMode());
            Assert.True(PointEstimator.GetEstimate(distribution, Metrics.ZeroOneError));  // Mode
            Assert.True(distribution.GetMean() >= 0.5);
            Assert.True(PointEstimator.GetEstimate(distribution, Metrics.SquaredError));  // Mean
            Assert.True(PointEstimator.GetEstimate(distribution, Metrics.AbsoluteError)); // Median = Mode

            distribution = new Bernoulli(0.6);
            Assert.True(distribution.GetMode());
            Assert.True(PointEstimator.GetEstimate(distribution, Metrics.ZeroOneError));  // Mode
            Assert.True(distribution.GetMean() >= 0.5);
            Assert.True(PointEstimator.GetEstimate(distribution, Metrics.SquaredError));  // Mean
            Assert.True(PointEstimator.GetEstimate(distribution, Metrics.AbsoluteError)); // Median = Mode

            Assert.Throws <ArgumentNullException>(() => PointEstimator.GetEstimate(distribution, null));

            // Test generic representation of distribution
            var genericDistribution = new Dictionary <bool, double> {
                { true, 0.25 }, { false, 0.75 }
            };                                                                                    // Order matters!

            Assert.False(PointEstimator.GetEstimate(genericDistribution, Metrics.ZeroOneError));  // Mode
            Assert.False(PointEstimator.GetEstimate(genericDistribution, Metrics.SquaredError));  // Mean
            Assert.False(PointEstimator.GetEstimate(genericDistribution, Metrics.AbsoluteError)); // Median = Mode

            genericDistribution = new Dictionary <bool, double> {
                { true, 0.5 }, { false, 0.5 }
            };
            Assert.True(PointEstimator.GetEstimate(genericDistribution, Metrics.ZeroOneError));  // Mode
            Assert.True(PointEstimator.GetEstimate(genericDistribution, Metrics.SquaredError));  // Mean
            Assert.True(PointEstimator.GetEstimate(genericDistribution, Metrics.AbsoluteError)); // Median = Mode

            genericDistribution = new Dictionary <bool, double> {
                { true, 0.6 }, { false, 0.4 }
            };
            Assert.True(PointEstimator.GetEstimate(genericDistribution, Metrics.ZeroOneError));  // Mode
            Assert.True(PointEstimator.GetEstimate(genericDistribution, Metrics.SquaredError));  // Mean
            Assert.True(PointEstimator.GetEstimate(genericDistribution, Metrics.AbsoluteError)); // Median = Mode

            Assert.Throws <ArgumentNullException>(() => PointEstimator.GetEstimate(distribution, null));
        }