基于朴素贝叶斯分类器的文本分类算法C#版（一）

昨天有幸拜读了洞庭散人的<基于朴素贝叶斯分类器的文本分类算法>，我正在学习这个，我从内心感谢洞庭散人的分享！随即我把它移植到了c#平台上。

该程序用到了Lucene.Net,用到了基于词典的ICTCLAS中文分词1.0.

ICTCLAS中文分词for Lucene.Net接口代码(实现Analyzer):

 1using System;
 2using System.Collections.Generic;
 3using System.Text;
 4using System.IO;
 5
 6using Lucene.Net.Analysis;
 7using Lucene.Net.Analysis.Standard;
 8
 9namespace AspxOn.Search.FenLei
{

    /**//// <summary>
    /// ICTCLAS分词组件for Lucene.net接口
    /// </summary>
    public class ICTCLASAnalyzer : Analyzer
    {
        //定义要过滤的词
        public static readonly System.String[] CHINESE_ENGLISH_STOP_WORDS = new string[428];
        public string NoisePath = Environment.CurrentDirectory + "\\data\\stopwords.txt";

        public ICTCLASAnalyzer()
        {
            StreamReader reader = new StreamReader(NoisePath, System.Text.Encoding.Default);
            string noise = reader.ReadLine();
            int i = 0;
            
            while (!string.IsNullOrEmpty(noise))
            {
                CHINESE_ENGLISH_STOP_WORDS[i] = noise;
                noise = reader.ReadLine();
                i++;
            }
            
        }

                /**//**//**//// Constructs a {@link StandardTokenizer} filtered by a {@link
       /// StandardFilter}, a {@link LowerCaseFilter} and a {@link StopFilter}. 
        /// 
        public override TokenStream TokenStream(System.String fieldName, System.IO.TextReader reader)
        {
            TokenStream result = new ICTCLASTokenizer(reader);
            result = new StandardFilter(result);
            result = new LowerCaseFilter(result);
            result = new StopFilter(result, CHINESE_ENGLISH_STOP_WORDS);
            return result;
        }


    }
}

 

ICTCLAS中文分词for Lucene.Net接口代码(实现Tokenizer):

 1using System;
 2using System.Collections.Generic;
 3using System.Text;
 4
 5using Lucene.Net.Analysis;
 6using SharpICTCLAS;
 7using System.IO;
 8
 9namespace AspxOn.Search.FenLei
{
    public class ICTCLASTokenizer : Tokenizer
    {
        int nKind = 1;
        List<WordResult[]> result;
        int startIndex = 0;
        int endIndex = 0;
        int i = 1;
        /**//**/
        /**//// 
        /// 待分词的句子
        /// 
        private string sentence;
        /**//**/
        /**//// Constructs a tokenizer for this Reader. 
        public ICTCLASTokenizer(System.IO.TextReader reader)
        {
            this.input = reader;
            sentence = input.ReadToEnd();
            sentence = sentence.Replace("\r\n", "");
            string DictPath = Path.Combine(Environment.CurrentDirectory, "Data") + Path.DirectorySeparatorChar;
            //Console.WriteLine("正在初始化字典库，请稍候");
            WordSegment wordSegment = new WordSegment();
            wordSegment.InitWordSegment(DictPath);
            result = wordSegment.Segment(sentence, nKind);
        }

        /**//**/
        /**//// 进行切词，返回数据流中下一个token或者数据流为空时返回null
        /// 
        public override Token Next()
        {
            Token token = null;
            while (i < result[0].Length - 1)
            {
                string word = result[0][i].sWord;
                endIndex = startIndex + word.Length - 1;
                token = new Token(word, startIndex, endIndex);
                startIndex = endIndex + 1;

                i++;
                return token;

            }
            return null;
        }

    }
}

 

中文分词器代码：

 1using System;
 2using System.Collections.Generic;
 3using System.Text;
 4using System.IO;
 5
 6using Lucene.Net.Analysis;
 7using Lucene.Net.Analysis.Standard;
 8using Lucene.Net.Documents;
 9
using Lucene.Net.Analysis.Cn;
using Lucene.Net.Analysis.KTDictSeg;

namespace AspxOn.Search.FenLei
{
    /**//// <summary>
    /// 中文分词器
    /// </summary>
    public class ChineseSpliter
    {
        public static string Split(string text, string splitToken)
        {
            StringBuilder sb = new StringBuilder();

            Analyzer an = new ICTCLASAnalyzer();

            //TokenStream ts = an.ReusableTokenStream("", new StringReader(text));

            TokenStream ts = an.TokenStream("", new StringReader(text));

            Lucene.Net.Analysis.Token token;
            while ((token = ts.Next()) != null)
            {
                sb.Append(splitToken + token.TermText());
            }

            return sb.ToString().Substring(1);
        }
    }
}

 

训练管理器代码：

  1using System;
  2using System.Collections.Generic;
  3using System.Text;
  4using System.IO;
  5
  6using System.Text.RegularExpressions;
  7
  8namespace AspxOn.Search.FenLei
  9{
 10
 11    /**//// <summary>
 12    /// 训练管理器
 13    /// </summary>
 14    public class TrainingDataManager
 15    {
 16        private string[] trainingFileClassicfications; //训练预料分类数组
 17        private DirectoryInfo trainingTextDir; //训练预料存放目录
 18        private string defaultDir = "D:\\SogouC.mini.20061127\\SogouC.mini\\Sample";
 19        //private string defaultDir = @"J:\SogouC.reduced.20061127\SogouC.reduced\Reduced";
 20
 21        public TrainingDataManager()
 22        {
 23            if (!Directory.Exists(defaultDir))
 24            {
 25                throw new Exception("当前语料目录不存在!");
 26            }
 27            trainingTextDir = new DirectoryInfo(defaultDir);
 28
 29            trainingFileClassicfications = Directory.GetDirectories(defaultDir,"*",SearchOption.TopDirectoryOnly);
 30
 31            for (int i = 0; i < trainingFileClassicfications.Length; i++)
 32            {
 33                trainingFileClassicfications[i] = (Regex.Split(trainingFileClassicfications[i], "\\\\"))[(Regex.Split(trainingFileClassicfications[i], "\\\\")).Length - 1];
 34                //Console.WriteLine(trainingFileClassicfications[i]);
 35            }
 36        }
 37
 38        /**//// <summary>
 39        /// 获取分类列表
 40        /// </summary>
 41        /// <returns></returns>
 42        public string[] GetTrainingClassifications()
 43        {
 44            return trainingFileClassicfications;
 45        }
 46
 47        /**//// <summary>
 48        /// 获取指定分类下的文件路径
 49        /// </summary>
 50        /// <param name="classification"></param>
 51        /// <returns></returns>
 52        public string[] GetFilesPath(string classification)
 53        {
 54            string[] ret = Directory.GetFiles(defaultDir+"\\"+classification);
 55           
 56            return ret;
 57        }
 58
 59        /**//// <summary>
 60        /// 获取指定位置的文件内容
 61        /// </summary>
 62        /// <param name="filepath"></param>
 63        /// <returns></returns>
 64        public string GetFileText(string filepath)
 65        {
 66            FileStream fs = new FileStream(filepath, FileMode.Open, FileAccess.Read, FileShare.Read);
 67            byte[] bt = new byte[fs.Length];
 68            fs.Read(bt, 0, bt.Length);
 69            fs.Close();
 70            string s = Encoding.Default.GetString(bt);
 71            return s;
 72        }
 73
 74        /**//// <summary>
 75        /// 获取训练文本集中的文本数目
 76        /// </summary>
 77        /// <returns></returns>
 78        public int GetTrainFileCount()
 79        {
 80            int ret = 0;
 81            for (int i = 0; i < trainingFileClassicfications.Length; i++)
 82            {
 83                ret += GetTrainFileCountOfCertainClassification(trainingFileClassicfications[i]);
 84            }
 85            return ret;
 86        }
 87
 88        /**//// <summary>
 89        /// 获取指定分类下的文本数目
 90        /// </summary>
 91        /// <param name="classification"></param>
 92        /// <returns></returns>
 93        public int GetTrainFileCountOfCertainClassification(string classification)
 94        {
 95            int ret = 0;
 96
 97            ret = Directory.GetFiles(defaultDir + "\\" + classification).Length;
 98
 99            return ret;
        }

        /**//// <summary>
        /// 获取指定分类包含关键字或关键词的样本数目
        /// </summary>
        /// <param name="classification">指定分类</param>
        /// <param name="key">关键词或关键字</param>
        /// <returns>样本数目</returns>
        public int GetCountContainKeyOfClassification(string classification, string key)
        {
            int ret = 0;
            string[] filepaths = GetFilesPath(classification);
            try
            {
                
                for (int i = 0; i < filepaths.Length; i++)
                {
                    string text = GetFileText(filepaths[i]);
                    if (text.Contains(key))
                    {
                        ret++;
                    }
                }
            }
            catch
            {
                throw new Exception("error!");
            }
            return ret;
        }
    }
}

 

先验概率计算代码：

 1using System;
 2using System.Collections.Generic;
 3using System.Text;
 4
 5namespace AspxOn.Search.FenLei
 6{
 7    /**//// <summary>
 8    /// 先验概率（事先概率）计算
 9    /// </summary>
    public class PriorProbability
    {
        private static TrainingDataManager tdm = new TrainingDataManager();

        /**//// <summary>
        /// 计算先验概率
        /// </summary>
        /// <param name="c">给定的分类</param>
        /// <returns>给定条件下的先验概率</returns>
        public static float CaculatePc(string c)
        {
            float ret = 0F;
            float Nc = tdm.GetTrainFileCountOfCertainClassification(c);
            float N = tdm.GetTrainFileCount();
            ret = Nc / N;
            return ret;
        }
    }
}

 

条件概率计算代码：

 1using System;
 2using System.Collections.Generic;
 3using System.Text;
 4
 5namespace AspxOn.Search.FenLei
 6{
 7    /**//// <summary>
 8    /// 条件概率计算
 9    /// </summary>
    public class ClassConditionalProbability
    {

        private static TrainingDataManager tdm = new TrainingDataManager();
        private static float M = 0F;

        /**//// <summary>
        /// 类条件概率
        /// </summary>
        /// <param name="x">给定关键字</param>
        /// <param name="c">给定分类</param>
        /// <returns></returns>
        public static float CaculatePxc(string x, string c)
        {
            float ret = 0F;
            float Nxc = tdm.GetCountContainKeyOfClassification(c, x);
            float Nc = tdm.GetTrainFileCountOfCertainClassification(c);
            float V = tdm.GetTrainingClassifications().Length;

            ret = (Nxc + 1) / (Nc + V + M);//为避免出现0这样的极端情况，进行加权处理

            return ret;
        }
    }
}

 

用于保存分类结果的类：

 1using System;
 2using System.Collections.Generic;
 3using System.Text;
 4
 5namespace AspxOn.Search.FenLei
 6{
 7    /**//// <summary>
 8    /// 保存分类结果
 9    /// </summary>
    public class ClassifyResult
    {

        public double probability; //分类概率
        public string classification;  //分类
        public ClassifyResult()
        {
            probability = 0;
            classification = string.Empty;
        }
    }
}

 

贝叶斯分类器代码：

 1using System;
 2using System.Collections.Generic;
 3using System.Text;
 4
 5namespace AspxOn.Search.FenLei
 6{
 7    /**//// <summary>
 8    /// 朴素贝叶斯分类器
 9    /// </summary>
    public class BayesClassifier
    {

        private TrainingDataManager tdm; //训练集合管理器
        //private string trainingDataPath; //训练集合路径
        private static float zoomFactor = 10.0F;

        /**//// <summary>
        /// 默认构造器，初始化训练集合
        /// </summary>
        public BayesClassifier()
        {
            tdm = new TrainingDataManager();
        }

        /**//// <summary>
        /// 计算给定的文本属性向量X在给定的分类Cj中的类条件概率
        /// </summary>
        /// <param name="X">文本属性向量X</param>
        /// <param name="Cj">给定的分类</param>
        /// <returns>分类条件概率连乘值</returns>
        protected float CaluProd(string[] X, string Cj)
        {
            float ret = 1.0F;
            for (int i = 0; i < X.Length; i++)
            {
                string Xi = X[i];
                ret *= ClassConditionalProbability.CaculatePxc(Xi, Cj) * zoomFactor;//因为数值过小，因此将连乘值放大10倍(通过乘以zoomFactor)
            }
            ret *= PriorProbability.CaculatePc(Cj); //再乘以先验概率
            return ret;
        }

        /**//// <summary>
        /// 对指定文本进行分类
        /// </summary>
        /// <param name="text">指定文本</param>
        /// <returns>分类结果</returns>
        public List<ClassifyResult> Classify(string text)
        {
            string[] terms = ChineseSpliter.Split(text, "|").Split('|'); //中文分词处理（分词结果可能包含停用词）
            string[] classes = tdm.GetTrainingClassifications();  //分类列表数组
            float probility = 0.0F;
            List<ClassifyResult> crs = new List<ClassifyResult>(); //分类结果
            for (int i = 0; i < classes.Length; i++)
            {
                string Ci = classes[i];
                probility = CaluProd(terms, Ci); //计算给定的文本属性向量terms在给定的分类Ci中的分类条件概率
                ClassifyResult cr = new ClassifyResult();
                cr.classification = Ci;
                cr.probability = probility;
                crs.Add(cr);
            }
            return crs;
        }

        public string GetMaxNum(List<ClassifyResult> crs)
        {
            double ret = 0;
            string classification = string.Empty;
            ret = crs[0].probability;
            for (int i = 0; i < crs.Count; i++)
            {
                if (crs[i].probability > ret)
                {
                    ret = crs[i].probability;
                    classification = crs[i].classification;
                }
            }
            return classification;
        }
    }
}

 

代码太多，编辑的时候卡的很，于是再整个（二）