文本分类——Naive Bayes
1 Naive Bayes算法介绍
算法简介摘自:http://zengkui.blog.163.com/blog/static/21230008220121012102727140/
博主用python实现，我把他的语料库下载了，然后用空格字符代替原文本奇怪的分割字符，作为训练集和测试集合
说起贝叶斯算法，不得不先提到概率论与数理统计课程里面的条件概率公式，对于随机试验E有两个随机事件A,B,且P(B) > 0 那么在B事件发生的条件下A发生的概率为：
这样就得到了贝叶斯公式。贝叶斯文本分类就是基于这个公式，利用先验概率来得到文本的分类。
其中 为第i个文本类别出现的概率， 为文本类别为Ci时出现特征向量(w1,w2…wn)的概率，P(w1,w2…wn)为特征向量出现的概率。一般的会假设特征——词，在文本中出现的概率是独立的，也就是说词和词之间是不相关的（虽然这个不一定成立，但是为了简化计算往往又不得不这么做），那么这时候的联合概率就可以表示为乘积的形式，如下：
对于特定的训练集合来说，上式中P(w1)P(w2)…P(wn)是一个固定的常数，那么在进行分类计算的时候可以省略掉这个分母的计算，如是得到：
这样，只需要计算给定文本和各个类别之间的条件概率值，取最大的那个概率值所在的类别代表文本的类别就行了。
2 参数训练
在贝叶斯分类器训练的时候，依照前面的公式可以知道，需要训练的参数有：
1. P(Ci) : 各个类别在所有的文档中出现的概率，这个只需要统计各个文本类别的数量，然后除以所有文档数就是需要的参数了。
2. P(w|C): 各个词在各个类别中出现的概率，在类别C中出现了w的文档数除以C类文档总数
3 代码实现
GitHub：https://github.com/fourbears/MachineLearning
<pre name="code" class="cpp">/************************************************************************/
/* 基于贝叶斯的文本分类 */
/* Keiko@20140823 */
/************************************************************************/
#include <math.h>
#include <algorithm>
#include <string>
#include <vector>
#include <set>
#include <map>
#include <fstream>
#include <sstream>
#include <iostream>
using namespace std;
class NaiveBayes
{
public:
void train(string file_path);//训练
void classfiy(string file_path);//分类
private:
double getProbality(vector<wstring> &attr,int &label);//根据测试向量计算它属于类别label下可能的概率
void readTrainingData(string file_path,vector<int>* classes,vector<vector<wstring>> *matrix);//读取训练集和测试集
private:
vector<int> m_classesTraining;//存储训练样本类别向量
vector<vector<wstring>> m_matrixTraining;//存储训练样本矩阵
vector<int> m_classesClassify;//存储测试样本类别向量
vector<vector<wstring>> m_matrixClassify;//存储测试样本矩阵
map<int,map<wstring,double>*> m_attrcooure;//矩阵(每行为一个文本样本)
map<int,int> m_unique_class_attr_counts;//（类别,特征向量维数）
int m_totalAttrCount;//总的特征向量个数
map<int,double> m_probCi;//计算样本中某个类别出现的概率P(Ci)
};
const wchar_t delim=' ';
void NaiveBayes::train(string file_path)
{
readTrainingData(file_path,&m_classesTraining,&m_matrixTraining);
//计算P(Ci)
map<int,double> countClass;//key:类别标识;value:训练样本中该类别的样本个数
for (vector<int>::iterator iter_vi=m_classesTraining.begin();iter_vi!=m_classesTraining.end();++iter_vi)
{
if (countClass.find(*iter_vi)==countClass.end())
{
countClass[*iter_vi]=1.0;
}
else
{
countClass[*iter_vi]++;
}
}
for (map<int,double>::iterator iter_mid=countClass.begin();iter_mid!=countClass.end();iter_mid++)
{
m_probCi[iter_mid->first]=(double)iter_mid->second/(double)m_classesTraining.size();
}
//P(Xi|Cj)=Count(Xi,Cj)/Count(Cj);各个词在各个类别中出现的概率=在类别Cj中出现Xi的文档数/类别Cj的文档数
m_totalAttrCount=0;
map<wstring,int> attrCount;
for (unsigned int i=0;i<m_matrixTraining.size();++i)
{
vector<wstring> wstr=m_matrixTraining[i];
map<wstring,int> cur_map;//记录当前样本中词出现的次数
for (vector<wstring>::iterator iter_vw=wstr.begin();iter_vw!=wstr.end();iter_vw++)
{
cur_map[*iter_vw]=0;
}
vector<wstring>::iterator iter_vw;
for (iter_vw=wstr.begin();iter_vw!=wstr.end();iter_vw++)
{
if (m_attrcooure.find(m_classesTraining[i])==m_attrcooure.end())
{
m_attrcooure[m_classesTraining[i]]=new map<wstring,double>;
(*m_attrcooure[m_classesTraining[i]])[*iter_vw]=1;
cur_map[*iter_vw]=1;
}
else
{
map<wstring,double> *exist_map=m_attrcooure[m_classesTraining[i]];
//如果该词不存在与Ci样本中，则插入该词
if ((*exist_map).find(*iter_vw)==(*exist_map).end())
{
(*exist_map)[*iter_vw]=1;
}
//如果该词已经存在于Ci样本，则只需递增它出现的次数
if (cur_map[*iter_vw]==0)
{
(*exist_map)[*iter_vw]++;
cur_map[*iter_vw]=1;
}
}
if (attrCount.find(*iter_vw)==attrCount.end())
{
attrCount[*iter_vw];
m_totalAttrCount++;
}
}
}
cout<<"特征向量维数"<<m_totalAttrCount<<endl;
map<int,map<wstring,double>*> class_attr_pairs;
for (unsigned int i=0;i<m_matrixTraining.size();i++)
{
if (class_attr_pairs.find(m_classesTraining[i])==class_attr_pairs.end())
{
class_attr_pairs[m_classesTraining[i]]=new map<wstring,double>;
}
map<wstring,double>* tmp=class_attr_pairs[m_classesTraining[i]];
vector<wstring> wv=m_matrixTraining[i];
for (vector<wstring>::iterator iter_vw=wv.begin();iter_vw!=wv.end();iter_vw++)
{
if ((*tmp).find(*iter_vw)==(*tmp).end())
{
(*tmp)[*iter_vw]=1;
}
}
}
for (map<int,map<wstring,double>*>::iterator iter_mimwd=class_attr_pairs.begin();iter_mimwd!=class_attr_pairs.end();++iter_mimwd)
{
map<wstring,double>* tmp=iter_mimwd->second;
double nCount=0;
for (map<wstring,double>::iterator iter_mwd=(*tmp).begin();iter_mwd!=(*tmp).end();iter_mwd++)
{
nCount+=iter_mwd->second;
}
m_unique_class_attr_counts[iter_mimwd->first]=(int)nCount;
cout<<"类别"<<iter_mimwd->first<<"的特征向量个数："<<nCount<<endl;
}
}
void NaiveBayes::readTrainingData(string file_path,vector<int>* classes,vector<vector<wstring>> *matrix)
{
locale china("chs");//使用中文
wcin.imbue(china);
wcout.imbue(china);
wstring s;
wchar_t wc=L' ';// L"宽字符"
std::wifstream file(file_path);
std::wstring line;
FILE* fp = fopen(file_path.c_str(), "rt+,ccs=UTF-8");
wchar_t temp[4096]={'\0'};
int nCount=0;
while (!feof(fp))
{
//cout<<"正在读取第"<<++nCount<<"个样本"<<endl;
fgetws(temp,4096,fp);//每次读一行
wstring wstr=wstring(temp);
wistringstream iss(wstr);
wstring attr;
vector<wstring> vw;
int classname;
bool flag=false;
while (getline(iss,attr,delim))
{
if (!flag)
{
classname=stoi(attr);//类别存储在第一列
flag=true;
}
else
{
vw.push_back(attr);
}
}
classes->push_back(classname);
matrix->push_back(vw);
}
}
double NaiveBayes::getProbality(vector<wstring> &attr,int &label)
{
//计算P(X|Ci)
double log_prob_x_given_ci=0;//给定Ci,P(X)的概率：P(X|Ci)
for (unsigned int i=0;i<attr.size();i++)
{
wstring ws=attr[i];
double count_xi_ci=0;//(Xi,Ci)出现测次数N
map<wstring,double>* tmp=m_attrcooure[label];//取出label类别的特征向量
map<wstring,double>::iterator iter_wd=tmp->find(ws);
if (iter_wd!=tmp->end())
{
count_xi_ci=iter_wd->second;//如果找到则把出现次数赋予count_xi_ci
}
double temp=(double)m_unique_class_attr_counts[label];//label类别的特征向量个数
double prob_xi_given_ci=(double)(count_xi_ci+1)/(double)(temp+m_totalAttrCount);
log_prob_x_given_ci +=log(prob_xi_given_ci);
}
return (log(m_probCi[label])+log_prob_x_given_ci);
}
void NaiveBayes::classfiy(string file_path)
{
readTrainingData(file_path,&m_classesClassify,&m_matrixClassify);
vector<vector<wstring>>::iterator iter_vvw;
vector<bool> accuracy;//用于存储是否判断正确
for (unsigned int i=0;i<m_matrixClassify.size();i++)
{
vector<wstring> vw=m_matrixClassify[i];
set<int> label;
vector<int>::iterator iter_vi;
int max_class;
double max_prob=-DBL_MAX;
for (iter_vi=m_classesTraining.begin();iter_vi!=m_classesTraining.end();iter_vi++)
{
if (label.find(*iter_vi)==label.end())
{
double prob=getProbality(vw,(*iter_vi));
if (prob>max_prob)
{
max_prob=prob;
max_class=*iter_vi;
}
label.insert(*iter_vi);//用于判断类别是否已存在
}
}
//统计准确度
(m_classesClassify[i]==max_class)?accuracy.push_back(true):accuracy.push_back(false);
}
double acc=0;
for (vector<bool>::iterator iter=accuracy.begin();iter!=accuracy.end();iter++)
{
if (*iter==true)
{
acc++;
}
}
acc/=(double)accuracy.size();
cout<<"分类正确率为:"<<acc<<"%";
}
int main(int argc,char *argv[])
{
NaiveBayes naivebayes;
string training_file_path="train.dat";
string test_file_path="test.dat";
naivebayes.train(training_file_path);
naivebayes.classfiy(test_file_path);
}在参数训练中，选定的特征——词，是事先从信息增益算法挑选出来的。
4 模型评价
选取搜狗实验室的分类语料：商务类新闻和娱乐类新闻各100篇作为分类样本，测试集中商务类新闻文章19926篇，娱乐类新闻文章11987篇。其中商务类标记为正样本，娱乐类标记为负样本。
5 模型的优缺点
贝叶斯分类模型很大的一个优点就是训练过程非常简单，甚至是可以做到增量式训练，特征是对海量的训练集表现非常高效。
另外一个优点就是，模型的可读性也是比较强的，对于分类得到的结果可以进行解释。
最大的缺点，也就是一开始的假设，在现实世界中，特征属性之间往往是不独立的，所以在相关性很强的特征里使用此模型得到的分类结果会比较差。
624
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
