`
dato0123
  • 浏览: 969970 次
文章分类
社区版块
存档分类
最新评论

基于朴素贝叶斯分类器的文本分类算法(下)

 
阅读更多

源代码下载:NaviveBayesClassify.rar

Preface

文本的分类和聚类是一个比较有意思的话题,我以前也写过一篇blog基于K-Means的文本聚类算法》,加上最近读了几本数据挖掘和机器学习的书籍,因此很想写点东西来记录下学习的所得。

在本文的上半部分《基于朴素贝叶斯分类器的文本分类算法(上)》一文中简单介绍了贝叶斯学习的基本理论,这一篇将展示如何将该理论运用到中文文本分类中来,具体的文本分类原理就不再介绍了,在上半部分有,也可以参见代码的注释。

文本特征向量

文本特征向量可以描述为文本中的字/词构成的属性。例如给出文本:

Good good study,Day day up.

可以获得该文本的特征向量集:{ Good, good, study, Day, day , up.}

朴素贝叶斯模型是文本分类模型中的一种简单但性能优越的的分类模型。为了简化计算过程,假定各待分类文本特征变量是相互独立的,即朴素贝叶斯模型的假设。相互独立表明了所有特征变量之间的表述是没有关联的。如上例中,[good][study]这两个特征变量就是没有任何关联的。

在上例中,文本是英文,但由于中文本身是没有自然分割符(如空格之类符号),所以要获得中文文本的特征变量向量首先需要对文本进行中文分词

中文分词

这里采用极易中文分词组件,这个中文分词组件可以免费使用,提供Lucene接口,跨平台,性能可靠。

<!--<br /> <br /> Code highlighting produced by Actipro CodeHighlighter (freeware)<br /> http://www.CodeHighlighter.com/<br /> <br /> -->packagecom.vista;
importjava.io.IOException;
importjeasy.analysis.MMAnalyzer;

/**
*中文分词器
*/
publicclassChineseSpliter
{
/**
*对给定的文本进行中文分词
*@paramtext给定的文本
*@paramsplitToken用于分割的标记,如"|"
*@return分词完毕的文本
*/
publicstaticStringsplit(Stringtext,StringsplitToken)
{
Stringresult
=null;
MMAnalyzeranalyzer
=newMMAnalyzer();
try
{
result
=analyzer.segment(text,splitToken);
}
catch(IOExceptione)
{
e.printStackTrace();
}
returnresult;
}
}

停用词处理

去掉文档中无意思的词语也是必须的一项工作,这里简单的定义了一些常见的停用词,并根据这些常用停用词在分词时进行判断。

<!--<br /> <br /> Code highlighting produced by Actipro CodeHighlighter (freeware)<br /> http://www.CodeHighlighter.com/<br /> <br /> -->packagecom.vista;

/**
*停用词处理器
*@authorphinecos
*
*/
publicclassStopWordsHandler
{
privatestaticStringstopWordsList[]={"","我们","","自己","","","","","","","","","","","","","","","","","","","","","","","","",""};//常用停用词
publicstaticbooleanIsStopWord(Stringword)
{
for(inti=0;i<stopWordsList.length;++i)
{
if(word.equalsIgnoreCase(stopWordsList[i]))
returntrue;
}
returnfalse;
}
}

训练集管理器

我们的系统首先需要从训练样本集中得到假设的先验概率和给定假设下观察到不同数据的概率。

<!--<br /> <br /> Code highlighting produced by Actipro CodeHighlighter (freeware)<br /> http://www.CodeHighlighter.com/<br /> <br /> -->packagecom.vista;
importjava.io.BufferedReader;
importjava.io.File;
importjava.io.FileInputStream;
importjava.io.FileNotFoundException;
importjava.io.IOException;
importjava.io.InputStreamReader;
importjava.util.Properties;
importjava.util.logging.Level;
importjava.util.logging.Logger;
/**
*训练集管理器
*/
publicclassTrainingDataManager
{
privateString[]traningFileClassifications;//训练语料分类集合
privateFiletraningTextDir;//训练语料存放目录
privatestaticStringdefaultPath="D://TrainningSet";

publicTrainingDataManager()
{
traningTextDir
=newFile(defaultPath);
if(!traningTextDir.isDirectory())
{
thrownewIllegalArgumentException("训练语料库搜索失败!["+defaultPath+"]");
}
this.traningFileClassifications=traningTextDir.list();
}
/**
*返回训练文本类别,这个类别就是目录名
*
@return训练文本类别
*/
publicString[]getTraningClassifications()
{
returnthis.traningFileClassifications;
}
/**
*根据训练文本类别返回这个类别下的所有训练文本路径(fullpath)
*
@paramclassification给定的分类
*
@return给定分类下所有文件的路径(fullpath)
*/
publicString[]getFilesPath(Stringclassification)
{
FileclassDir
=newFile(traningTextDir.getPath()+File.separator+classification);
String[]ret
=classDir.list();
for(inti=0;i<ret.length;i++)
{
ret[i]
=traningTextDir.getPath()+File.separator+classification+File.separator+ret[i];
}
returnret;
}
/**
*返回给定路径的文本文件内容
*
@paramfilePath给定的文本文件路径
*
@return文本内容
*
@throwsjava.io.FileNotFoundException
*
@throwsjava.io.IOException
*/
publicstaticStringgetText(StringfilePath)throwsFileNotFoundException,IOException
{
InputStreamReaderisReader
=newInputStreamReader(newFileInputStream(filePath),"GBK");
BufferedReaderreader
=newBufferedReader(isReader);
Stringaline;
StringBuildersb
=newStringBuilder();
while((aline=reader.readLine())!=null)
{
sb.append(aline
+"");
}
isReader.close();
reader.close();
returnsb.toString();
}
/**
*返回训练文本集中所有的文本数目
*
@return训练文本集中所有的文本数目
*/
publicintgetTrainingFileCount()
{
intret=0;
for(inti=0;i<traningFileClassifications.length;i++)
{
ret
+=getTrainingFileCountOfClassification(traningFileClassifications[i]);
}
returnret;
}
/**
*返回训练文本集中在给定分类下的训练文本数目
*
@paramclassification给定的分类
*
@return训练文本集中在给定分类下的训练文本数目
*/
publicintgetTrainingFileCountOfClassification(Stringclassification)
{
FileclassDir
=newFile(traningTextDir.getPath()+File.separator+classification);
returnclassDir.list().length;
}
/**
*返回给定分类中包含关键字/词的训练文本的数目
*
@paramclassification给定的分类
*
@paramkey给定的关键字/词
*
@return给定分类中包含关键字/词的训练文本的数目
*/
publicintgetCountContainKeyOfClassification(Stringclassification,Stringkey)
{
intret=0;
try
{
String[]filePath
=getFilesPath(classification);
for(intj=0;j<filePath.length;j++)
{
Stringtext
=getText(filePath[j]);
if(text.contains(key))
{
ret
++;
}
}
}
catch(FileNotFoundExceptionex)
{
Logger.getLogger(TrainingDataManager.
class.getName()).log(Level.SEVERE,null,ex);

}
catch(IOExceptionex)
{
Logger.getLogger(TrainingDataManager.
class.getName()).log(Level.SEVERE,null,ex);
}
returnret;
}
}

先验概率

先验概率是我们需要计算的两大概率值之一

<!--<br /> <br /> Code highlighting produced by Actipro CodeHighlighter (freeware)<br /> http://www.CodeHighlighter.com/<br /> <br /> -->packagecom.vista;
/**
*先验概率计算
*<h3>先验概率计算</h3>
*P(c<sub>j</sub>)=N(C=c<sub>j</sub>)<b>/</b>N<br>
*其中,N(C=c<sub>j</sub>)表示类别c<sub>j</sub>中的训练文本数量;
*N表示训练文本集总数量。
*/
publicclassPriorProbability
{
privatestaticTrainingDataManagertdm=newTrainingDataManager();
/**
*先验概率
*
@paramc给定的分类
*
@return给定条件下的先验概率
*/
publicstaticfloatcalculatePc(Stringc)
{
floatret=0F;
floatNc=tdm.getTrainingFileCountOfClassification(c);
floatN=tdm.getTrainingFileCount();
ret
=Nc/N;
returnret;
}
}

分类条件概率

这是另一个影响因子,和先验概率一起来决定最终结果

<!--<br /> <br /> Code highlighting produced by Actipro CodeHighlighter (freeware)<br /> http://www.CodeHighlighter.com/<br /> <br /> -->packagecom.vista;

/**
*<b>类</b>条件概率计算
*
*<h3>类条件概率</h3>
*P(x<sub>j</sub>|c<sub>j</sub>)=(N(X=x<sub>i</sub>,C=c<sub>j
*</sub>)+1)<b>/</b>(N(C=c<sub>j</sub>)+M+V)<br>
*其中,N(X=x<sub>i</sub>,C=c<sub>j</sub>)表示类别c<sub>j</sub>中包含属性x<sub>
*i</sub>的训练文本数量;N(C=c<sub>j</sub>)表示类别c<sub>j</sub>中的训练文本数量;M值用于避免
*N(X=x<sub>i</sub>,C=c<sub>j</sub>)过小所引发的问题;V表示类别的总数。
*
*<h3>条件概率</h3>
*<b>定义</b>设A,B是两个事件,且P(A)>0称<br>
*<tt>P(B∣A)=P(AB)/P(A)</tt><br>
*为在条件A下发生的条件事件B发生的条件概率。

*/

publicclassClassConditionalProbability
{
privatestaticTrainingDataManagertdm=newTrainingDataManager();
privatestaticfinalfloatM=0F;

/**
*计算类条件概率
*
@paramx给定的文本属性
*
@paramc给定的分类
*
@return给定条件下的类条件概率
*/
publicstaticfloatcalculatePxc(Stringx,Stringc)
{
floatret=0F;
floatNxc=tdm.getCountContainKeyOfClassification(c,x);
floatNc=tdm.getTrainingFileCountOfClassification(c);
floatV=tdm.getTraningClassifications().length;
ret
=(Nxc+1)/(Nc+M+V);//为了避免出现0这样极端情况,进行加权处理
returnret;
}
}

分类结果

用来保存各个分类及其计算出的概率值,

<!--<br /> <br /> Code highlighting produced by Actipro CodeHighlighter (freeware)<br /> http://www.CodeHighlighter.com/<br /> <br /> -->packagecom.vista;
/**
*分类结果
*/
publicclassClassifyResult
{
publicdoubleprobility;//分类的概率
publicStringclassification;//分类
publicClassifyResult()
{
this.probility=0;
this.classification=null;
}
}

朴素贝叶斯分类器

利用样本数据集计算先验概率和各个文本向量属性在分类中的条件概率,从而计算出各个概率值,最后对各个概率值进行排序,选出最大的概率值,即为所属的分类。

<!--<br /> <br /> Code highlighting produced by Actipro CodeHighlighter (freeware)<br /> http://www.CodeHighlighter.com/<br /> <br /> -->packagecom.vista;
importcom.vista.ChineseSpliter;
importcom.vista.ClassConditionalProbability;
importcom.vista.PriorProbability;
importcom.vista.TrainingDataManager;
importcom.vista.StopWordsHandler;
importjava.util.ArrayList;
importjava.util.Comparator;
importjava.util.List;
importjava.util.Vector;

/**
*朴素贝叶斯分类器
*/
publicclassBayesClassifier
{
privateTrainingDataManagertdm;//训练集管理器
privateStringtrainnigDataPath;//训练集路径
privatestaticdoublezoomFactor=10.0f;
/**
*默认的构造器,初始化训练集
*/
publicBayesClassifier()
{
tdm
=newTrainingDataManager();
}

/**
*计算给定的文本属性向量X在给定的分类Cj中的类条件概率
*<code>ClassConditionalProbability</code>连乘值
*
@paramX给定的文本属性向量
*
@paramCj给定的类别
*
@return分类条件概率连乘值,即<br>
*/
floatcalcProd(String[]X,StringCj)
{
floatret=1.0F;
//类条件概率连乘
for(inti=0;i<X.length;i++)
{
StringXi
=X[i];
//因为结果过小,因此在连乘之前放大10倍,这对最终结果并无影响,因为我们只是比较概率大小而已
ret*=ClassConditionalProbability.calculatePxc(Xi,Cj)*zoomFactor;
}
//再乘以先验概率
ret*=PriorProbability.calculatePc(Cj);
returnret;
}
/**
*去掉停用词
*
@paramtext给定的文本
*
@return去停用词后结果
*/
publicString[]DropStopWords(String[]oldWords)
{
Vector
<String>v1=newVector<String>();
for(inti=0;i<oldWords.length;++i)
{
if(StopWordsHandler.IsStopWord(oldWords[i])==false)
{
//不是停用词
v1.add(oldWords[i]);
}
}
String[]newWords
=newString[v1.size()];
v1.toArray(newWords);
returnnewWords;
}
/**
*对给定的文本进行分类
*
@paramtext给定的文本
*
@return分类结果
*/
@SuppressWarnings(
"unchecked")
publicStringclassify(Stringtext)
{
String[]terms
=null;
terms
=ChineseSpliter.split(text,"").split("");//中文分词处理(分词后结果可能还包含有停用词)
terms=DropStopWords(terms);//去掉停用词,以免影响分类

String[]Classes
=tdm.getTraningClassifications();//分类
floatprobility=0.0F;
List
<ClassifyResult>crs=newArrayList<ClassifyResult>();//分类结果
for(inti=0;i<Classes.length;i++)
{
StringCi
=Classes[i];//第i个分类
probility=calcProd(terms,Ci);//计算给定的文本属性向量terms在给定的分类Ci中的分类条件概率
//保存分类结果
ClassifyResultcr=newClassifyResult();
cr.classification
=Ci;//分类
cr.probility=probility;//关键字在分类的条件概率
System.out.println("Inprocess.");
System.out.println(Ci
+""+probility);
crs.add(cr);
}
//对最后概率结果进行排序
java.util.Collections.sort(crs,newComparator()
{
publicintcompare(finalObjecto1,finalObjecto2)
{
finalClassifyResultm1=(ClassifyResult)o1;
finalClassifyResultm2=(ClassifyResult)o2;
finaldoubleret=m1.probility-m2.probility;
if(ret<0)
{
return1;
}
else
{
return-1;
}
}
});
//返回概率最大的分类
returncrs.get(0).classification;
}

publicstaticvoidmain(String[]args)
{
Stringtext
="微软公司提出以446亿美元的价格收购雅虎中国网2月1日报道美联社消息,微软公司提出以446亿美元现金加股票的价格收购搜索网站雅虎公司。微软提出以每股31美元的价格收购雅虎。微软的收购报价较雅虎1月31日的收盘价19.18美元溢价62%。微软公司称雅虎公司的股东可以选择以现金或股票进行交易。微软和雅虎公司在2006年底和2007年初已在寻求双方合作。而近两年,雅虎一直处于困境:市场份额下滑、运营业绩不佳、股价大幅下跌。对于力图在互联网市场有所作为的微软来说,收购雅虎无疑是一条捷径,因为双方具有非常强的互补性。(小桥)";
BayesClassifierclassifier
=newBayesClassifier();//构造Bayes分类器
Stringresult=classifier.classify(text);//进行分类
System.out.println("此项属于["+result+"]");
}
}

训练集与分类测试

作为测试,这里选用Sogou实验室的文本分类数据,我只使用了mini版本。迷你版本有10个类别 ,共计100篇文章,总大小244KB

使用的测试文本:

<!--<br /> <br /> Code highlighting produced by Actipro CodeHighlighter (freeware)<br /> http://www.CodeHighlighter.com/<br /> <br /> -->微软公司提出以446亿美元的价格收购雅虎

中国网2月1日报道美联社消息,微软公司提出以446亿美元现金加股票的价格收购搜索网站雅虎公司。

微软提出以每股31美元的价格收购雅虎。微软的收购报价较雅虎1月31日的收盘价19
.18美元溢价62%。微软公司称雅虎公司的股东可以选择以现金或股票进行交易。

微软和雅虎公司在2006年底和2007年初已在寻求双方合作。而近两年,雅虎一直处于困境:市场份额下滑、运营业绩不佳、股价大幅下跌。对于力图在互联网市场有所作为的微软来说,收购雅虎无疑是一条捷径,因为双方具有非常强的互补性。
(小桥)

使用mini版本的测试结果:

<!--<br /> <br /> Code highlighting produced by Actipro CodeHighlighter (freeware)<br /> http://www.CodeHighlighter.com/<br /> <br /> -->Inprocess.
IT:
2.8119528E-5
Inprocess
.
体育:
2.791735E-21
Inprocess
.
健康:
3.3188528E-12
Inprocess
.
军事:
2.532662E-19
Inprocess
.
招聘:
2.3753596E-17
Inprocess
.
教育:
4.2023427E-19
Inprocess
.
文化:
6.0595915E-23
Inprocess
.
旅游:
5.1286412E-17
Inprocess
.
汽车:
4.085446E-8
Inprocess
.
财经:
3.7337095E-10
此项属于[IT]
分享到:
评论
2 楼 LongXiTianXia 2013-03-08  
我不知道哪里下载那个组件
1 楼 LongXiTianXia 2013-03-08  
可以说一下分词组件怎么使用吗?

相关推荐

    基于朴素贝叶斯分类器的文本分类算法

    朴素贝叶斯分类器是一种基于概率的机器学习方法,它在文本分类领域有着广泛的应用。该模型基于贝叶斯定理,并且通过“朴素”这一假设来简化计算,即假设特征之间是相互独立的。这一假设使得朴素贝叶斯分类器能够高效...

    基于朴素贝叶斯分类器的文本分类算法(C语言).doc

    基于朴素贝叶斯分类器的文本分类算法(C语言).doc

    基于朴素贝叶斯实现的文本分类

    朴素贝叶斯分类器基于贝叶斯定理,该定理表述为:P(A|B) = P(B|A) * P(A) / P(B),其中A和B是两个事件。在文本分类中,A代表类别,B代表特征。我们想要计算给定特征集B时,文档属于类别A的概率。 二、Python实现 ...

    朴素贝叶斯分类器算法

    朴素贝叶斯分类器是一种基于概率的机器学习算法,它基于贝叶斯定理和特征条件独立假设。在"朴素贝叶斯分类器算法"中,我们主要关注以下几个知识点: 1. **贝叶斯定理**:贝叶斯定理是统计学中的一个重要概念,用于...

    基于hadoop的朴素贝叶斯分类器

    朴素贝叶斯分类器是一种基于概率的机器学习算法,它基于贝叶斯定理和特征条件独立假设。在大数据处理领域,结合Hadoop框架可以实现大规模数据集的分类任务。Hadoop是一个开源分布式计算框架,它允许在大量廉价硬件上...

    人工智能-项目实践-朴素贝叶斯分类器-朴素贝叶斯文本分类器

    人工智能_项目实践_朴素贝叶斯分类器_朴素贝叶斯文本分类器 **数据:**搜狗文本分类语料库 **分类器:**朴素贝叶斯分类器 NBC(Naive Bayesian Classifier) **编程语言:**Python+jieba分词库+nltk+sklearn

    基于朴素贝叶斯分类器的文本分类算法(C语言)-综合文档

    基于朴素贝叶斯分类器的文本分类算法(C 语言)概述 基于朴素贝叶斯分类器的文本分类算法是自然语言处理领域中的一种常见算法。朴素贝叶斯分类器(Naive Bayes Classifier)是一种基于贝叶斯定理的分类算法,它假设每...

    基于朴素贝叶斯算法的文本分类程序_Python

    尽管在实际问题中这一假设往往过于简化,但在许多情况下,朴素贝叶斯分类器仍然能够取得不错的效果。 在文本分类中,每个文档可以看作是由一系列单词(特征)组成的,朴素贝叶斯算法计算每个类别的先验概率(文档...

    基于朴素贝叶斯的文本分类

    这一假设虽然往往不符合实际情况,但在很多情况下,朴素贝叶斯分类器仍然能够取得不错的分类效果,特别是在文本分类领域。 贝叶斯分类器在分类中的应用涉及计算先验概率和后验概率。先验概率通常基于训练集中的类...

    java实现朴素贝叶斯分类算法

    在Java中实现朴素贝叶斯分类器,我们需要理解以下几个关键知识点: 1. **贝叶斯定理**:贝叶斯定理是概率论中的一个公式,它描述了在已知某些条件下,事件A发生的条件概率P(A|B)如何根据先验概率P(A)和证据B的概率P...

    朴素贝叶斯分类器的文本分类算法

    朴素贝叶斯分类器之所以被称为“朴素”,是因为它假设特征之间相互独立,尽管在实际情况下这种假设往往并不成立,但在很多场景下,尤其是文本分类领域,朴素贝叶斯依然能表现出较好的分类效果。 ### 贝叶斯定理与...

    基于朴素贝叶斯机器学习算法实现情感文本分析与分类

    #清磁盘啦~,CSDN“网盘”真好用,感谢CSDN~ 机器学习,基于朴素贝叶斯机器学习算法实现对情感文本分析与分类(含数据集),sgns.weibo.bigram-char,使用gensim加载预训练中文分词

    基于Hadoop实现朴素贝叶斯文本分类器.zip

    最后,利用这些概率统计信息构建朴素贝叶斯分类器,当有新的文本数据需要分类时,同样通过MapReduce框架进行预测。 在这个项目中,“Hadoop-Naive-Bayes-main”可能包含了实现这个功能的源代码。源码可能包括了数据...

    一种文本处理中的朴素贝叶斯分类器

    朴素贝叶斯分类器作为一种基于概率的机器学习模型,在文本分类领域具有广泛的应用。该文首先介绍了朴素贝叶斯分类器的基本原理,包括特征独立性假设,并探讨了如何训练及应用朴素贝叶斯分类器来进行文本分类。此外,...

    朴素贝叶斯分类Iris数据

    在这个实例中,我们将探讨如何使用朴素贝叶斯分类器处理Iris数据集。 Iris数据集是一个经典的数据集,由生物学家Ronald Fisher于1936年收集,包含三种鸢尾花(Setosa、Versicolour和Virginica)的4个特征:萼片长度...

    朴素贝叶斯分类器,用于识别手写的数字A~J

    朴素贝叶斯分类器是一种基于概率的机器学习算法,它在数据分类中有着广泛的应用,尤其是在文本分类、垃圾邮件过滤和图像识别等领域。这个特定的案例是针对手写数字的识别,目标是从A到J这10个字符进行区分。 在手写...

    论文研究-朴素贝叶斯分类器的构建 .pdf

    朴素贝叶斯分类器是一种基于贝叶斯定理的概率分类方法,它简单且易于实现,广泛应用于文本分类、垃圾邮件过滤、情感分析等众多领域。朴素贝叶斯分类器的核心是基于属性条件独立的假设,即一个属性的出现不影响其他...

    C++实现朴素贝叶斯分类器

    朴素贝叶斯分类器是一种基于概率的机器学习算法,它基于贝叶斯定理和特征条件独立假设。在C++中实现朴素贝叶斯分类器,可以为各种数据分类任务提供一个高效且易于理解的解决方案。 首先,我们需要理解贝叶斯定理。...

    基于朴素贝叶斯方法的垃圾邮件分类器

    朴素贝叶斯分类器基于贝叶斯定理和特征条件独立假设,计算每个类别的先验概率以及每个特征在每个类别下的条件概率。 4. 测试与评估:将测试集(可能包含ham和spam邮件)输入到训练好的模型中,比较预测结果与真实...

Global site tag (gtag.js) - Google Analytics