Accord.Tests.MachineLearning.MeanShiftTest.WeightedMeanShiftConstructorTest2 C# (CSharp) Method

WeightedMeanShiftConstructorTest2() private method

private WeightedMeanShiftConstructorTest2 ( ) : void
return void
        public void WeightedMeanShiftConstructorTest2()
        {
            Accord.Math.Tools.SetupGenerator(1);

            // Declare some observations
            double[][] observations1 = 
            {
                new double[] { -5, -2, -4 },
                new double[] { -5, -5, -6 },
                new double[] {  1,  1,  2 },
                new double[] {  1,  1,  2 },
                new double[] {  1,  1,  2 },
                new double[] {  1,  1,  2 },
                new double[] { 11,  5,  4 },
                new double[] { 15,  5,  6 },
                new double[] { 10,  5,  6 },
            };

            int[] weights1 = { 1, 1, 1, 1, 1, 1, 1, 1, 1 };

            // Declare some observations
            double[][] observations2 = 
            {
                new double[] { -5, -2, -4 },
                new double[] { -5, -5, -6 },
                new double[] {  1,  1,  2 },
                // new double[] {  1,  1,  2 },
                // new double[] {  1,  1,  2 },
                // new double[] {  1,  1,  2 },
                new double[] { 11,  5,  4 },
                new double[] { 15,  5,  6 },
                new double[] { 10,  5,  6 },
            };

            int[] weights2 = { 1, 1, 4, 1, 1, 1 };


            Accord.Math.Random.Generator.Seed = 1;
            var ms1 = new MeanShift(dimension: 3, kernel: new UniformKernel(), bandwidth: 2);
            ms1.UseParallelProcessing = false;
            ms1.Compute(observations1);

            Accord.Math.Random.Generator.Seed = 1;
            var ms2 = new MeanShift(dimension: 3, kernel: new UniformKernel(), bandwidth: 2);
            ms2.UseParallelProcessing = false;
            ms2.Compute(observations1, weights1);

            Accord.Math.Random.Generator.Seed = 1;
            var ms3 = new MeanShift(dimension: 3, kernel: new UniformKernel(), bandwidth: 2);
            ms3.UseParallelProcessing = false;
            ms3.Compute(observations2, weights2);

            int[] labels1 = ms1.Clusters.Nearest(observations1);
            int[] labels2 = ms2.Clusters.Nearest(observations1);
            int[] labels3 = ms3.Clusters.Nearest(observations1);

            Assert.IsTrue(Matrix.IsEqual(labels1, labels2));
            Assert.IsTrue(Matrix.IsEqual(labels1, labels3));

            Assert.IsTrue(Matrix.IsEqual(ms1.Clusters.Modes, ms2.Clusters.Modes, 1e-3));
            Assert.IsTrue(Matrix.IsEqual(ms1.Clusters.Modes, ms3.Clusters.Modes, 1e-3));

            Assert.IsTrue(Matrix.IsEqual(ms1.Clusters.Proportions, ms2.Clusters.Proportions));
            Assert.IsTrue(Matrix.IsEqual(ms1.Clusters.Proportions, ms3.Clusters.Proportions));

            Assert.AreEqual(3 / 9.0, ms3.Clusters.Proportions[labels1[6]], 1e-6);
            Assert.AreEqual(2 / 9.0, ms3.Clusters.Proportions[labels1[0]], 1e-6);
            Assert.AreEqual(4 / 9.0, ms3.Clusters.Proportions[labels1[2]], 1e-6);
        }