Example #1
0
        public void ComplementOVANaiveBayesianAlgorithm_PredictTokens()
        {
            // arrange
            var sample = getSample();
            var CLS1   = sample.CachedClasses.ElementAt(0);
            var CLS2   = sample.CachedClasses.ElementAt(1);
            var prep   = getDefaultPreprocessor();
            var alg    = new ComplementOVANaiveBayesianAlgorithm()
            {
                Preprocessor = prep
            };

            // act
            alg.Train(sample);
            var result1 = alg.PredictTokens(testDocs()[0], 2);
            var result2 = alg.PredictTokens(testDocs()[1], 2);

            // assert
            Assert.AreEqual(2, result1.Length);
            Assert.AreEqual(CLS1, result1[0].Class);
            Assert.AreEqual(1.42266200529D, result1[0].Score, EPS);
            Assert.AreEqual(CLS2, result1[1].Class);
            Assert.AreEqual(-2.9267394021D, result1[1].Score, EPS);
            Assert.AreEqual(CLS2, result2[0].Class);
            Assert.AreEqual(1.58549278826D, result2[0].Score, EPS);
            Assert.AreEqual(CLS1, result2[1].Class);
            Assert.AreEqual(-3.0895701850D, result2[1].Score, EPS);
        }
Example #2
0
        public void ComplementOVANaiveBayesianAlgorithm_Train()
        {
            // arrange
            var sample = getSample();
            var CLS1   = sample.CachedClasses.ElementAt(0);
            var CLS2   = sample.CachedClasses.ElementAt(1);
            var prep   = getDefaultPreprocessor();
            var alg    = new ComplementOVANaiveBayesianAlgorithm()
            {
                Preprocessor = prep
            };

            // act
            alg.Train(sample);

            // assert
            Assert.AreEqual(sample, alg.TrainingSample);
            Assert.AreEqual(prep, alg.Preprocessor);
            Assert.AreEqual(2, alg.ClassHist.Length);
            Assert.AreEqual(4, alg.ClassHist[0]);
            Assert.AreEqual(2, alg.ClassHist[1]);
            Assert.AreEqual(6, alg.DataCount);
            Assert.AreEqual(8, alg.DataDim);

            Assert.AreEqual(8, alg.Vocabulary.Count);
            Assert.AreEqual("cat", alg.Vocabulary[0]);
            Assert.AreEqual("like", alg.Vocabulary[1]);
            Assert.AreEqual("icecream", alg.Vocabulary[2]);
            Assert.AreEqual("at", alg.Vocabulary[3]);
            Assert.AreEqual("dog", alg.Vocabulary[4]);
            Assert.AreEqual("meet", alg.Vocabulary[5]);
            Assert.AreEqual("world", alg.Vocabulary[6]);
            Assert.AreEqual("seven", alg.Vocabulary[7]);

            Assert.AreEqual(2, alg.PriorProbs.Length);
            Assert.AreEqual(Math.Log(4 / 6.0D), alg.PriorProbs[0], EPS);
            Assert.AreEqual(Math.Log(2 / 6.0D), alg.PriorProbs[1], EPS);

            Assert.AreEqual(2, alg.Weights.Length);
            Assert.AreEqual(8, alg.Weights[0].Length);
            Assert.AreEqual(8, alg.Weights[1].Length);
            Assert.AreEqual(Math.Log(7.0 / 21) - Math.Log(1.0 / 14), alg.Weights[0][0]);
            Assert.AreEqual(Math.Log(2.0 / 21) - Math.Log(2.0 / 14), alg.Weights[0][1]);
            Assert.AreEqual(Math.Log(2.0 / 21) - Math.Log(1.0 / 14), alg.Weights[0][2]);
            Assert.AreEqual(Math.Log(2.0 / 21) - Math.Log(1.0 / 14), alg.Weights[0][3]);
            Assert.AreEqual(Math.Log(2.0 / 21) - Math.Log(4.0 / 14), alg.Weights[0][4]);
            Assert.AreEqual(Math.Log(3.0 / 21) - Math.Log(1.0 / 14), alg.Weights[0][5]);
            Assert.AreEqual(Math.Log(2.0 / 21) - Math.Log(2.0 / 14), alg.Weights[0][6]);
            Assert.AreEqual(Math.Log(1.0 / 21) - Math.Log(2.0 / 14), alg.Weights[0][7]);

            Assert.AreEqual(Math.Log(1.0 / 14) - Math.Log(7.0 / 21), alg.Weights[1][0]);
            Assert.AreEqual(Math.Log(2.0 / 14) - Math.Log(2.0 / 21), alg.Weights[1][1]);
            Assert.AreEqual(Math.Log(1.0 / 14) - Math.Log(2.0 / 21), alg.Weights[1][2]);
            Assert.AreEqual(Math.Log(1.0 / 14) - Math.Log(2.0 / 21), alg.Weights[1][3]);
            Assert.AreEqual(Math.Log(4.0 / 14) - Math.Log(2.0 / 21), alg.Weights[1][4]);
            Assert.AreEqual(Math.Log(1.0 / 14) - Math.Log(3.0 / 21), alg.Weights[1][5]);
            Assert.AreEqual(Math.Log(2.0 / 14) - Math.Log(2.0 / 21), alg.Weights[1][6]);
            Assert.AreEqual(Math.Log(2.0 / 14) - Math.Log(1.0 / 21), alg.Weights[1][7]);
        }
Example #3
0
        public static TextAlgorithmBase Create_ComplementOVAAlgorithm()
        {
            var proc = new TextPreprocessor(new EnglishSimpleTokenizer(),
                                            new EnglishStopwords(),
                                            new EnglishSimpleNormalizer(),
                                            new EnglishPorterStemmer());
            var alg = new ComplementOVANaiveBayesianAlgorithm()
            {
                Preprocessor = proc
            };

            return(alg);
        }
Example #4
0
        public void ComplementOVANaiveBayesianAlgorithm_ExtractFeatureVector()
        {
            // arrange
            var sample = getSample();
            var CLS1   = sample.CachedClasses.ElementAt(0);
            var CLS2   = sample.CachedClasses.ElementAt(1);
            var prep   = getDefaultPreprocessor();
            var alg    = new ComplementOVANaiveBayesianAlgorithm()
            {
                Preprocessor = prep
            };
            bool isEmpty;

            // act
            alg.Train(sample);
            var result1 = alg.ExtractFeatureVector(testDocs()[0], out isEmpty);
            var result2 = alg.ExtractFeatureVector(testDocs()[1], out isEmpty);

            // assert
            Assert.AreEqual(8, result1.Length);
            Assert.AreEqual(1, result1[0]);
            Assert.AreEqual(0, result1[1]);
            Assert.AreEqual(1, result1[2]);
            Assert.AreEqual(0, result1[3]);
            Assert.AreEqual(0, result1[4]);
            Assert.AreEqual(0, result1[5]);
            Assert.AreEqual(0, result1[6]);
            Assert.AreEqual(0, result1[7]);

            Assert.AreEqual(8, result2.Length);
            Assert.AreEqual(1, result2[0]);
            Assert.AreEqual(2, result2[1]);
            Assert.AreEqual(1, result2[2]);
            Assert.AreEqual(0, result2[3]);
            Assert.AreEqual(2, result2[4]);
            Assert.AreEqual(0, result2[5]);
            Assert.AreEqual(1, result2[6]);
            Assert.AreEqual(1, result2[7]);
        }
Example #5
0
        public void ComplementOVANaiveBayesianAlgorithm_Predict()
        {
            // arrange
            var sample = getSample();
            var CLS1   = sample.CachedClasses.ElementAt(0);
            var CLS2   = sample.CachedClasses.ElementAt(1);
            var prep   = getDefaultPreprocessor();
            var alg    = new ComplementOVANaiveBayesianAlgorithm()
            {
                Preprocessor = prep
            };

            // act
            alg.Train(sample);
            var result1 = alg.Predict(testDocs()[0]);
            var result2 = alg.Predict(testDocs()[1]);
            var result3 = alg.Predict(testDocs()[2]);

            // assert
            Assert.AreEqual(CLS1, result1);
            Assert.AreEqual(CLS2, result2);
            Assert.AreEqual(CLS2, result3);
        }