예제 #1
0
        public void DerivativeTest2()
        {
            double beta     = 4.2;
            double constant = 0.57;

            double[] expected =
            {
                0.230745,   0.197519,  0.157726,  0.119128, 0.0862579,
                0.0605722, 0.0416275, 0.0281864, 0.0188941,   0.01258, 0.00833836
            };

            LogitLinkFunction target = new LogitLinkFunction(beta, constant);

            for (int i = 0; i < 11; i++)
            {
                double x = i / 10.0;
                double y = target.Inverse(x);

                double d1 = target.Derivative(x);
                double d2 = target.Derivative2(y);

                Assert.AreEqual(expected[i], d1, 1e-6);
                Assert.AreEqual(expected[i], d2, 1e-6);

                Assert.IsFalse(Double.IsNaN(d1));
                Assert.IsFalse(Double.IsNaN(d2));
            }
        }
예제 #2
0
        public void DerivativeTest()
        {
            double[] expected =
            {
                0.25,     0.249376, 0.247517, 0.244458, 0.240261, 0.235004,
                0.228784, 0.221713,  0.21391,   0.2055, 0.196612
            };

            LogitLinkFunction target = new LogitLinkFunction();

            for (int i = 0; i < 11; i++)
            {
                double x = i / 10.0;
                double y = target.Inverse(x);

                double d1 = target.Derivative(x);
                double d2 = target.Derivative2(y);

                Assert.AreEqual(expected[i], d1, 1e-6);
                Assert.AreEqual(expected[i], d2, 1e-6);

                Assert.IsFalse(Double.IsNaN(d1));
                Assert.IsFalse(Double.IsNaN(d2));
            }
        }
        public static ILinkFunction Get(LinkFunctionType link)
        {
            ILinkFunction result = null;

            switch (link)
            {
            case LinkFunctionType.Absolute: result = new AbsoluteLinkFunction(); break;

            case LinkFunctionType.Cauchit: result = new CauchitLinkFunction(); break;

            case LinkFunctionType.Identity: result = new IdentityLinkFunction(); break;

            case LinkFunctionType.Inverse: result = new InverseLinkFunction(); break;

            case LinkFunctionType.InverseSquared: result = new InverseSquaredLinkFunction(); break;

            case LinkFunctionType.Logit: result = new LogitLinkFunction(); break;

            case LinkFunctionType.Log: result = new LogLinkFunction(); break;

            case LinkFunctionType.LogLog: result = new LogLogLinkFunction(); break;

            case LinkFunctionType.Probit: result = new ProbitLinkFunction(); break;

            case LinkFunctionType.Sin: result = new SinLinkFunction(); break;

            case LinkFunctionType.Threshold: result = new ThresholdLinkFunction(); break;
            }

            return(result);
        }
예제 #4
0
        public void TestException()
        {
            var fn = new LogitLinkFunction();

            double[] x = { 1, 2 };
            fn.Evaluate(x);
        }
예제 #5
0
        public void TestEvaluate()
        {
            var fn = new LogitLinkFunction();

            double[] x = { 2 };
            double   y = fn.Evaluate(x);

            Assert.AreEqual(0.8807970779778823, y, AIFH.DefaultPrecision);
        }
예제 #6
0
        public void LogitLinkFunctionConstructorTest()
        {
            LogitLinkFunction target = new LogitLinkFunction();

            Assert.AreEqual(0, target.A);
            Assert.AreEqual(1, target.B);

            for (int i = 0; i < 11; i++)
            {
                double x = i / 10.0;
                double y = Math.Log(x) - Math.Log(1 - x);

                Assert.AreEqual(y, target.Function(x), 1e-10);
                Assert.AreEqual(x, target.Inverse(y), 1e-10);
            }
        }
예제 #7
0
        public void LogitLinkFunctionConstructorTest1()
        {
            double beta     = 3.14;
            double constant = 2.91;

            LogitLinkFunction target = new LogitLinkFunction(beta, constant);

            Assert.AreEqual(constant, target.A);
            Assert.AreEqual(beta, target.B);

            for (int i = 0; i < 11; i++)
            {
                double x = i / 10.0;
                double y = ((Math.Log(x) - Math.Log(1 - x)) - constant) / beta;

                Assert.AreEqual(y, target.Function(x), 1e-10);
                Assert.AreEqual(x, target.Inverse(y), 1e-10);
            }
        }
        public void scores_probabilities_test()
        {
            double[][] input =
            {
                new double[] { 55, 0 }, // 0 - no cancer
                new double[] { 28, 0 }, // 0
                new double[] { 65, 1 }, // 0
                new double[] { 46, 0 }, // 1 - have cancer

                new double[] { 86, 1 }, // 1
                new double[] { 86, 1 }, // 1
                new double[] { 56, 1 }, // 1
                new double[] { 85, 0 }, // 0

                new double[] { 33, 0 }, // 0
                new double[] { 21, 1 }, // 0
                new double[] { 42, 1 }, // 1
            };

            double[] output =
            {
                0, 0, 0, 1,
                1, 1, 1, 0,
                0, 0, 1
            };

            double[] weights =
            {
                1.0, 1.0, 1.0, 1.0,
                0.5, 0.5, 1.0, 1.0,
                1.0, 1.0, 1.0
            };


            var teacher = new IterativeReweightedLeastSquares <LogisticRegression>()
            {
                Regularization = 0
            };

            var target = teacher.Learn(input, output, weights);

            LogitLinkFunction link = (LogitLinkFunction)target.Link;

            Assert.AreEqual(0, link.A);
            Assert.AreEqual(1, link.B);

            Assert.AreEqual(-2.4577464307294092, target.Intercept, 1e-8);
            Assert.AreEqual(-2.4577464307294092, target.Coefficients[0], 1e-8);
            Assert.AreEqual(0.020645118265359252, target.Coefficients[1], 1e-8);
            Assert.AreEqual(1.7678893101571855, target.Coefficients[2], 1e-8);

            // Test Scores, LogLikelihoods and Probability functions
            // https://github.com/accord-net/framework/issues/570

            double[][] scoresAllSamples         = target.Scores(input);
            double[][] logLikelihoodsAllSamples = target.LogLikelihoods(input);
            double[][] probabilitiesAllSamples  = target.Probabilities(input);
            Assert.IsTrue(scoresAllSamples.IsEqual(Matrix.Apply(probabilitiesAllSamples, link.Function), rtol: 1e-5));

            Assert.IsTrue(probabilitiesAllSamples.IsEqual(logLikelihoodsAllSamples.Exp()));
            Assert.IsTrue(probabilitiesAllSamples.Sum(dimension: 1).IsEqual(Vector.Ones(11), rtol: 1e-6));


            bool[] decideAllSamples = target.Decide(input);
            double err = new ZeroOneLoss(output).Loss(decideAllSamples);

            Assert.AreEqual(0.18181818181818182, err, 1e-5);
            Assert.AreEqual(decideAllSamples, scoresAllSamples.ArgMax(dimension: 1).ToBoolean());
            Assert.AreEqual(decideAllSamples.ToInt32(), logLikelihoodsAllSamples.ArgMax(dimension: 1));
            Assert.AreEqual(decideAllSamples, probabilitiesAllSamples.ArgMax(dimension: 1).ToBoolean());

            double[] scoreAllSamples = target.Score(input);
            Assert.AreEqual(scoreAllSamples, scoresAllSamples.GetColumn(1));
            double[] logLikelihoodAllSamples = target.LogLikelihood(input);
            Assert.AreEqual(logLikelihoodAllSamples, logLikelihoodsAllSamples.GetColumn(1));
            double[] probabilityAllSamples = target.Probability(input);
            Assert.AreEqual(probabilityAllSamples, probabilitiesAllSamples.GetColumn(1));

            for (int i = 0; i < input.Length; i++)
            {
                double[] scoresOneSample = target.Scores(input[i]);
                Assert.AreEqual(scoresOneSample, scoresAllSamples[i]);

                double[] logLikelihoodsOneSample = target.LogLikelihoods(input[i]);
                Assert.AreEqual(logLikelihoodsOneSample, logLikelihoodsAllSamples[i]);

                double[] probabilitiesOneSample = target.Probabilities(input[i]);
                Assert.AreEqual(probabilitiesOneSample, probabilitiesAllSamples[i]);

                bool decideOneSample = target.Decide(input[i]);
                Assert.AreEqual(decideOneSample, decideAllSamples[i]);

                double scoreOneSample = target.Score(input[i]);
                Assert.AreEqual(scoreOneSample, scoreAllSamples[i]);

                double logLikelihoodOneSample = target.LogLikelihood(input[i]);
                Assert.AreEqual(logLikelihoodOneSample, logLikelihoodAllSamples[i]);

                double probabilityOneSample = target.Probability(input[i]);
                Assert.AreEqual(probabilityOneSample, probabilityAllSamples[i]);
            }

            bool[] decideScoresAllSamples         = null; target.Scores(input, ref decideScoresAllSamples);
            bool[] decideLogLikelihoodsAllSamples = null; target.LogLikelihoods(input, ref decideLogLikelihoodsAllSamples);
            Assert.AreEqual(decideScoresAllSamples, decideLogLikelihoodsAllSamples);
            bool[] decideProbabilitiesAllSamples = null; target.Probabilities(input, ref decideProbabilitiesAllSamples);
            Assert.AreEqual(decideScoresAllSamples, decideProbabilitiesAllSamples);

            bool[] decideScoreAllSamples = null; target.Score(input, ref decideScoreAllSamples);
            Assert.AreEqual(decideScoreAllSamples, decideScoresAllSamples);
            bool[] decideLogLikelihoodAllSamples = null; target.LogLikelihood(input, ref decideLogLikelihoodAllSamples);
            Assert.AreEqual(decideScoreAllSamples, decideLogLikelihoodAllSamples);
            bool[] decideProbabilityAllSamples = null; target.Probability(input, ref decideProbabilityAllSamples);
            Assert.AreEqual(decideScoreAllSamples, decideProbabilityAllSamples);


            for (int i = 0; i < input.Length; i++)
            {
                bool decideScoresOneSample; target.Scores(input[i], out decideScoresOneSample);
                Assert.AreEqual(decideScoresOneSample, decideScoresAllSamples[i]);

                bool decideLogLikelihoodsOneSample; target.LogLikelihoods(input[i], out decideLogLikelihoodsOneSample);
                Assert.AreEqual(decideLogLikelihoodsOneSample, decideLogLikelihoodsAllSamples[i]);

                bool decideProbabilitiesOneSample; target.Probabilities(input[i], out decideProbabilitiesOneSample);
                Assert.AreEqual(decideProbabilitiesOneSample, decideProbabilitiesAllSamples[i]);

                bool decideScoreOneSample; target.Score(input[i], out decideScoreOneSample);
                Assert.AreEqual(decideScoreOneSample, decideScoreAllSamples[i]);

                bool decideLogLikelihoodOneSample; target.LogLikelihood(input[i], out decideLogLikelihoodOneSample);
                Assert.AreEqual(decideLogLikelihoodOneSample, decideLogLikelihoodAllSamples[i]);

                bool decideProbabilityOneSample; target.Probability(input: input[i], decision: out decideProbabilityOneSample);
                Assert.AreEqual(decideProbabilityOneSample, decideProbabilityAllSamples[i]);
            }


            //bool[][] decidesScoresAllSamples = null; target.Scores(input, ref decidesScoresAllSamples);
            //bool[][] decidesLogLikelihoodsAllSamples = null; target.LogLikelihoods(input, ref decidesLogLikelihoodsAllSamples);
            //bool[][] decidesProbabilitiesAllSamples = null; target.Probabilities(input, ref decidesProbabilitiesAllSamples);


            //bool[][] decidesScoreAllSamples = null; target.Score(input, ref decidesScoreAllSamples);
            //bool[][] decidesLogLikelihoodAllSamples = null; target.LogLikelihood(input, ref decidesLogLikelihoodAllSamples);
            //bool[][] decidesProbabilityAllSamples = null; target.Probability(input, ref decidesProbabilityAllSamples);
        }