CreateInputOutputsExample1() public static method

public static CreateInputOutputsExample1 ( double &inputs, int &outputs ) : void
inputs double
outputs int
return void
Beispiel #1
0
        public void RegressTest2()
        {
            Accord.Math.Random.Generator.Seed = 0;

            double[][] inputs;
            int[]      outputs;

            MultinomialLogisticRegressionTest.CreateInputOutputsExample1(out inputs, out outputs);

            // Create an algorithm to estimate the regression
            var msgd = new MultinomialLogisticLearning <ConjugateGradient>();

            // Now, we can iteratively estimate our model
            MultinomialLogisticRegression mlr = msgd.Learn(inputs, outputs);

            int[] predicted = mlr.Decide(inputs);

            double acc = new ZeroOneLoss(outputs).Loss(predicted);

            Assert.AreEqual(0.61088435374149663, acc, 1e-8);
        }
Beispiel #2
0
        public void GradientTest()
        {
            double[][] inputs;
            int[]      outputs;

            MultinomialLogisticRegressionTest.CreateInputOutputsExample1(out inputs, out outputs);

            // Create an algorithm to estimate the regression
            var msgd = new MultinomialLogisticLearning <ConjugateGradient>();

            msgd.Method.MaxIterations = 1;

            msgd.Learn(inputs, outputs);

            int variables = inputs.Columns() * outputs.DistinctCount();
            var fd        = new FiniteDifferences(variables, msgd.crossEntropy);

            double[] probe    = { 0.1, 0.2, 0.5, 0.6, 0.2, 0.1 };
            double[] expected = fd.Compute(probe);
            double[] actual   = msgd.crossEntropyGradient(probe);

            Assert.IsTrue(expected.IsEqual(actual, 1e-5));
        }
        public void learn_test_2()
        {
            double[][] inputs;
            int[]      outputs;

            MultinomialLogisticRegressionTest.CreateInputOutputsExample1(out inputs, out outputs);

            var analysis = new MultinomialLogisticRegressionAnalysis();

            analysis.Iterations = 100;
            analysis.Tolerance  = 1e-6;

            var regression = analysis.Learn(inputs, outputs);

            int inputCount  = 2;
            int outputCount = 3;
            int coeffCount  = inputCount + 1;

            var mlr = analysis.regression;

            Assert.AreEqual(inputCount, mlr.Inputs);
            Assert.AreEqual(outputCount, mlr.Categories);

            Assert.AreEqual(inputCount, analysis.Inputs.Length);
            Assert.AreEqual(outputCount, analysis.OutputNames.Length);

            Assert.AreEqual(outputCount - 1, analysis.CoefficientValues.Length);
            Assert.AreEqual(outputCount - 1, analysis.StandardErrors.Length);

            Assert.AreEqual(outputCount - 1, analysis.WaldTests.Length);
            Assert.AreEqual(outputCount - 1, analysis.Confidences.Length);

            for (int i = 0; i < analysis.CoefficientValues.Length; i++)
            {
                Assert.AreEqual(coeffCount, analysis.CoefficientValues[i].Length);
                Assert.AreEqual(coeffCount, analysis.StandardErrors[i].Length);

                Assert.AreEqual(coeffCount, analysis.WaldTests[i].Length);
                Assert.AreEqual(coeffCount, analysis.Confidences[i].Length);
            }

            var coefficients = analysis.CoefficientValues;

            // brand 2
            Assert.AreEqual(-11.774655, coefficients[0][0], 1e-3); // intercept
            Assert.AreEqual(0.523814, coefficients[0][1], 1e-3);   // female
            Assert.AreEqual(0.368206, coefficients[0][2], 1e-3);   // age

            // brand 3
            Assert.AreEqual(-22.721396, coefficients[1][0], 1e-3); // intercept
            Assert.AreEqual(0.465941, coefficients[1][1], 1e-3);   // female
            Assert.AreEqual(0.685908, coefficients[1][2], 1e-3);   // age

            var standard = analysis.StandardErrors;

            // Using the lower-bound approximation
            Assert.AreEqual(1.047378039787443, standard[0][0], 1e-6);
            Assert.AreEqual(0.153150051082552, standard[0][1], 1e-6);
            Assert.AreEqual(0.031640507386863, standard[0][2], 1e-6);

            Assert.AreEqual(1.047378039787443, standard[1][0], 1e-6);
            Assert.AreEqual(0.153150051082552, standard[1][1], 1e-6);
            Assert.AreEqual(0.031640507386863, standard[1][2], 1e-6);

            Assert.AreEqual(-702.97, analysis.LogLikelihood, 1e-2);
            Assert.AreEqual(185.85, analysis.ChiSquare.Statistic, 1e-2);
            Assert.AreEqual(1405.9414080469473, analysis.Deviance, 1e-4);

            var wald = analysis.WaldTests;

            Assert.AreEqual(-11.241995503283842, wald[0][0].Statistic, 1e-3);
            Assert.AreEqual(3.4202662152119889, wald[0][1].Statistic, 1e-4);
            Assert.AreEqual(11.637150673342207, wald[0][2].Statistic, 1e-3);

            Assert.AreEqual(-21.693553825772664, wald[1][0].Statistic, 1e-3);
            Assert.AreEqual(3.0423802097069097, wald[1][1].Statistic, 1e-4);
            Assert.AreEqual(21.678124991086548, wald[1][2].Statistic, 1e-3);
        }