/// <summary>
            /// Tests that method
            /// <see cref="RandomIndexPermutation.Next"/>
            /// terminates successfully as expected.
            /// </summary>
            /// <param name="indexes">
            /// The indexes to permute.
            /// </param>
            /// <param name="numberOfRandomPermutations">
            /// The number of permutations to draw.
            /// </param>
            /// <param name="criticalValue">
            /// A quantile of the chi-squared distribution with a number of
            /// degrees of freedom equal to the <see cref="IndexCollection.Count"/>
            /// of <paramref name="indexes"/>
            /// minus <c>1</c>.
            /// To serve as the critical value for the Pearson's
            /// chi-squared test whose null hypothesis assume that the
            /// the distinct possible permutations
            /// are equiprobable.
            /// </param>
            /// <param name="delta">The required accuracy.
            /// Defaults to <c>.01</c>.</param>
            public static void Succeed(
                IndexCollection indexes,
                int numberOfRandomPermutations,
                double criticalValue,
                double delta = .01)
            {
                var randomPermutation = new RandomIndexPermutation(indexes);

                // Generate permutations

                var permutations = new IndexCollection[numberOfRandomPermutations];

                for (int i = 0; i < numberOfRandomPermutations; i++)
                {
                    permutations[i] = randomPermutation.Next();
                }

                // Check the number of distinct generated permutations

                var permutationIdentifiers =
                    IndexCollection.Default(numberOfRandomPermutations - 1);

                var actualDistinctPermutations =
                    IndexPartition.Create(
                        permutationIdentifiers,
                        (i) => { return(permutations[i]); });

                int numberOfActualDistinctPermutations =
                    actualDistinctPermutations.Count;

                Assert.AreEqual(
                    expected: SpecialFunctions.Factorial(indexes.Count),
                    actual: numberOfActualDistinctPermutations);

                // Compute the actual permutation probabilities

                DoubleMatrix actualPermutationProbabilities =
                    DoubleMatrix.Dense(
                        numberOfActualDistinctPermutations, 1);

                int j = 0;

                foreach (var identifier in actualDistinctPermutations.Identifiers)
                {
                    actualPermutationProbabilities[j] =
                        (double)actualDistinctPermutations[identifier].Count
                        /
                        (double)numberOfRandomPermutations;
                    j++;
                }

                // Check that the Chebyshev Inequality holds true
                // for each permutation probability

                var expectedPermutationProbabilities =
                    DoubleMatrix.Dense(
                        numberOfActualDistinctPermutations,
                        1,
                        1.0
                        /
                        (double)numberOfActualDistinctPermutations);

                for (int i = 0; i < numberOfActualDistinctPermutations; i++)
                {
                    ProbabilityDistributionTest.CheckChebyshevInequality(
                        new BernoulliDistribution(expectedPermutationProbabilities[i]),
                        actualPermutationProbabilities[i],
                        numberOfRandomPermutations,
                        delta);
                }

                // Check how good the actual permutation probabilities fit
                // the expected ones

                ProbabilityDistributionTest.CheckGoodnessOfFit(
                    expectedPermutationProbabilities,
                    actualPermutationProbabilities,
                    criticalValue);
            }
Exemple #2
0
        public void GetOptimalStateTest()
        {
            // valid input - random ties resolution
            {
                var context = new CategoricalEntailmentEnsembleOptimizationContext(
                    objectiveFunction:
                    (DoubleMatrix state) => { return(Double.PositiveInfinity); },
                    featureCategoryCounts: new List <int>(1)
                {
                    6
                },
                    numberOfResponseCategories: 4,
                    numberOfCategoricalEntailments: 1,
                    allowEntailmentPartialTruthValues: true,
                    probabilitySmoothingCoefficient: .9,
                    optimizationGoal: OptimizationGoal.Maximization,
                    minimumNumberOfIterations: 5,
                    maximumNumberOfIterations: 1000);

                int    numberOfEvaluations = 10000;
                double delta = .01;

                var parameter = DoubleMatrix.Dense(1, 10, new double[10] {
                    .5, .5, .5, .5, .5, .5, .25, .25, .25, .25
                });

                // Generate states

                var states = new int[numberOfEvaluations];

                var responseIndexes = IndexCollection.Range(6, 9);

                for (int i = 0; i < numberOfEvaluations; i++)
                {
                    var state = context.GetOptimalState(parameter);

                    states[i] = state.Vec(responseIndexes).FindNonzero()[0];
                }

                // Compute the actual inclusion probabilities

                DoubleMatrix actualInclusionProbabilities =
                    DoubleMatrix.Dense(context.NumberOfResponseCategories, 1);

                var stateIndexes = IndexCollection.Default(numberOfEvaluations - 1);

                for (int j = 0; j < context.NumberOfResponseCategories; j++)
                {
                    var samplesContainingCurrentUnit =
                        IndexPartition.Create(
                            stateIndexes,
                            (i) => { return(states[i] == j); });

                    actualInclusionProbabilities[j] =
                        (double)samplesContainingCurrentUnit[true].Count
                        /
                        (double)numberOfEvaluations;
                }

                // Check the number of distinct generated states

                var distinctStates =
                    IndexPartition.Create(
                        states);

                int numberOfDistinctStates =
                    distinctStates.Count;

                Assert.AreEqual(
                    expected: context.NumberOfResponseCategories,
                    actual: numberOfDistinctStates);

                // Check that the Chebyshev Inequality holds true
                // for each inclusion probability

                var expectedInclusionProbabilities =
                    DoubleMatrix.Dense(context.NumberOfResponseCategories, 1,
                                       1.0 / context.NumberOfResponseCategories);

                for (int j = 0; j < context.NumberOfResponseCategories; j++)
                {
                    ProbabilityDistributionTest.CheckChebyshevInequality(
                        new BernoulliDistribution(expectedInclusionProbabilities[j]),
                        actualInclusionProbabilities[j],
                        numberOfEvaluations,
                        delta);
                }

                // Check how good the actual inclusion probabilities fit
                // the expected ones

                // The following assumes a number of response
                // categories equal to 4.
                //
                // The quantile of order .9 for
                // the chi-squared distribution having 4-1
                // degrees of freedom is 6.251389
                // (as from R function qchisq(.9, 3))
                var goodnessOfFitCriticalValue = 6.251389;

                ProbabilityDistributionTest.CheckGoodnessOfFit(
                    expectedInclusionProbabilities,
                    actualInclusionProbabilities,
                    goodnessOfFitCriticalValue);
            }
        }