Accord.Tests.MachineLearning.ProbabilisticOutputLearningTest.RunTest2 C# (CSharp) Method

        public void RunTest2()
        {
            double[][] inputs =
            {
                new double[] { 0, 1, 1, 0 }, // 0
                new double[] { 0, 1, 0, 0 }, // 0
                new double[] { 0, 0, 1, 0 }, // 0
                new double[] { 0, 1, 1, 0 }, // 0
                new double[] { 0, 1, 0, 0 }, // 0
                new double[] { 1, 0, 0, 0 }, // 1
                new double[] { 1, 0, 0, 0 }, // 1
                new double[] { 1, 0, 0, 1 }, // 1
                new double[] { 0, 0, 0, 1 }, // 1
                new double[] { 0, 0, 0, 1 }, // 1
                new double[] { 1, 1, 1, 1 }, // 2
                new double[] { 1, 0, 1, 1 }, // 2
                new double[] { 1, 1, 0, 1 }, // 2
                new double[] { 0, 1, 1, 1 }, // 2
                new double[] { 1, 1, 1, 1 }, // 2
            };

            int[] outputs =
            {
                0, 0, 0, 0, 0,
                1, 1, 1, 1, 1,
                2, 2, 2, 2, 2,
            };

            IKernel kernel = new Linear();
            var machine = new MulticlassSupportVectorMachine(4, kernel, 3);
            var target = new MulticlassSupportVectorLearning(machine, inputs, outputs);

            target.Algorithm = (svm, classInputs, classOutputs, i, j) =>
                new SequentialMinimalOptimization(svm, classInputs, classOutputs);

            double error1 = target.Run();
            Assert.AreEqual(0, error1);

            int[] actual = new int[outputs.Length];
            var paths = new Decision[outputs.Length][];
            for (int i = 0; i < actual.Length; i++)
            {
                actual[i] = machine.Decide(inputs[i]);
                paths[i] = machine.GetLastDecisionPath();
                Assert.AreEqual(outputs[i], actual[i]);
            }

            var original = (MulticlassSupportVectorMachine)machine.Clone();

            target.Algorithm = (svm, classInputs, classOutputs, i, j) =>
                new ProbabilisticOutputCalibration(svm, classInputs, classOutputs);

            double error2 = target.Run();
            Assert.AreEqual(0, error2);

            int[] actual2 = new int[outputs.Length];
            var paths2 = new Decision[outputs.Length][];
            for (int i = 0; i < actual.Length; i++)
            {
                actual2[i] = machine.Decide(inputs[i]);
                paths2[i] = machine.GetLastDecisionPath();
                Assert.AreEqual(outputs[i], actual[i]);
            }

            var svm21 = machine[2, 1];
            var org21 = original[2, 1];
            var probe = inputs[12];
            var w21 = svm21.Weights;
            var o21 = org21.Weights;
            Assert.IsFalse(w21.IsEqual(o21, rtol: 1e-2));
            bool b = svm21.Decide(probe);
            bool a = org21.Decide(probe);
            Assert.AreEqual(a, b);

            double[][] probabilities = machine.Probabilities(inputs);

            //string str = probabilities.ToString(CSharpJaggedMatrixFormatProvider.InvariantCulture);

            double[][] expected = new double[][]
            {
                new double[] { 0.978013252309678, 0.00665988562670578, 0.015326862063616 },
                new double[] { 0.923373734751393, 0.0433240974867644, 0.033302167761843 },
                new double[] { 0.902265207121918, 0.0651939200306017, 0.0325408728474804 },
                new double[] { 0.978013252309678, 0.00665988562670578, 0.015326862063616 },
                new double[] { 0.923373734751393, 0.0433240974867644, 0.033302167761843 },
                new double[] { 0.0437508203303804, 0.79994737664453, 0.156301803025089 },
                new double[] { 0.0437508203303804, 0.79994737664453, 0.156301803025089 },
                new double[] { 0.0147601290467641, 0.948443224264852, 0.0367966466883842 },
                new double[] { 0.0920231845129213, 0.875878175972548, 0.0320986395145312 },
                new double[] { 0.0920231845129213, 0.875878175972548, 0.0320986395145312 },
                new double[] { 0.00868243281954335, 0.00491075178001821, 0.986406815400439 },
                new double[] { 0.0144769600209954, 0.0552754387307989, 0.930247601248206 },
                new double[] { 0.0144769600209954, 0.0552754387307989, 0.930247601248206 },
                new double[] { 0.0584631682316073, 0.0122104663095354, 0.929326365458857 },
                new double[] { 0.00868243281954335, 0.00491075178001821, 0.986406815400439 } 
            };

            Assert.IsTrue(probabilities.IsEqual(expected, rtol: 1e-8));
        }