社会化搜索与推荐浅析-朴素贝叶斯+laplace平滑文本分类器推导过程及java版实现

本文由larrylgq编写，转载请注明出处：http://blog.csdn.net/larrylgq/article/details/7395261

作者:吕桂强

邮箱：larry.lv.word@gmail.com

朴素贝叶斯文本分类器用处挺广的，但是网上很少有实现demo，所以写了个java的实现小demo

朴素贝叶斯分类用于文本分类的正式定义如下：

    1、设为一个待分类项x，而每个xi为x的一个特征属性(关键字)。

    2、有类别集合C。

    3、计算。

          P(c1|x)=P（x1|c1）*P(c1),P（x2|c1）*P(c1),...,P（xm|c1）*P(c1);=


    4、如果P(ci|x)的值最大，则i为最接近待分类项的。

本例子训练数据使用http://www.sogou.com/labs/dl/c.html中的mini版

上代码：（为了阅读方便全写在一个类里）

/**
*
*/
package com.larry;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.StringReader;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

import org.apache.log4j.Logger;
import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.TokenStream;
import org.apache.lucene.analysis.tokenattributes.CharTermAttribute;
import org.wltea.analyzer.lucene.IKAnalyzer;

/**
* @author 吕桂强
* @email larry.lv.word@gmail.com
* @version 创建时间：2012-3-26 下午3:59:08
*/
public class my_bayes_demo {
static Logger logger = Logger.getLogger(my_bayes_demo.class.getName());
private String training_path = "/home/larry/桌面/lucenc/Sample";// 训练语料路径
private File traning_text_dir;// 训练语料
private String[] classes;// 训练语料分类集合
private Map<Double, String> classify_result = new HashMap<Double, String>();

/**
* @param args
*/
public static void main(String[] args) {
String text = "微软公司提出以446亿美元的价格收购雅虎中国网2月1日报道 美联社消息，微软公司提出以446亿美元现金加股票的价格收购搜索网站雅虎公司。微软提出以每股31美元的价格收购雅虎。微软的收购报价较雅虎1月31日的收盘价19.18美元溢价62%。微软公司称雅虎公司的股东可以选择以现金或股票进行交易。微软和雅虎公司在2006年底和2007年初已在寻求双方合作。而近两年，雅虎一直处于困境：市场份额下滑、运营业绩不佳、股价大幅下跌。对于力图在互联网市场有所作为的微软来说，收购雅虎无疑是一条捷径，因为双方具有非常强的互补性。(小桥)";
//String text = "联想THINKPAD近期几乎全系列笔记本电脑降价促销，最高降幅达到800美元，降幅达到42%。这是记者昨天从联想美国官方网站发现的。联想相关人士表示，这是为纪念新联想成立1周年而在美国市场推出的促销，产品包括THINKPADT、X以及Z系列笔记本。促销不是打价格战，THINK品牌走高端商务路线方向不会改变";
my_bayes_demo bayes = new my_bayes_demo();
bayes.load_training_data();
String[] terms = null;
terms = bayes.split(text, " ").split(" ");
double probility = 0.0;
for (int i = 0; i < bayes.classes.length; i++) {
String ci = bayes.classes[i];// 第i个分类
probility = bayes.conditional_probability(terms, ci);// 计算给定的文本属性向量terms在给定的分类ci中的分类条件概率
bayes.classify_result.put(probility, ci);// 分类，对应分类的概率
System.out.println(ci + "：" + probility);
}

//排序找到相似度最高的
Double max = null;
Iterator<Double> iterator = bayes.classify_result.keySet().iterator();
while(iterator.hasNext()){
double next = iterator.next();
if(max != null){
max = Math.max(next, max);
}else{
max = next;
}
}
System.out.println(bayes.classify_result.get(max));
}

/**
* @param terms
* @param ci
* @return 当前类别与输入文本的相似度
*/
private double conditional_probability(String[] terms, String ci) {
double ret = 1.0;
// 类条件概率连乘
for (int i = 0; i < terms.length; i++) {
String xi = terms[i];
ret *= calculate_pxc(xi, ci);
}

double nc = get_trainingfile_count_of_classification(ci);// 当前分类的训练文本数目
double nall = get_training_filecount();//全部文本数目
// 再乘以先验概率(全部文本数目比上当前类别的文本数目)
ret *= nc / nall;
return ret;
}

/**
* P(xi∣cj)=P(cjxi)/P(cj)=>
* @param x
* @param c
* @return 关键字为xi且类别为cj的概率
*/
public double calculate_pxc(String x, String c) {
double ret = 0;
double nxc = get_count_containkey_of_classification(c, x);// 当前分类中包含当前关键字的训练文本的数目
double nc = get_trainingfile_count_of_classification(c);// 当前分类的训练文本数目
ret = (nxc + 1) / (nc + 1);//laplace平滑
return ret;
}

/**
* @return 训练文本集中所有的文本数目
*/
public int get_training_filecount()
{
int ret = 0;
for (int i = 0; i < classes.length; i++)
{
ret += get_trainingfile_count_of_classification(classes[i]);
}
return ret;
}

/**
* @param classification
* @return 当前类别下的所有训练文本的路径
*/
public String[] get_files_path(String classification) {
File class_dir = new File(traning_text_dir.getPath() + File.separator + classification);
String[] ret = class_dir.list();
for (int i = 0; i < ret.length; i++) {
ret[i] = traning_text_dir.getPath() + File.separator + classification + File.separator + ret[i];
}
return ret;
}

/**
* @param classification
* @param key
* @return 当前类型中包含关键字key的训练样本数目
*/
public int get_count_containkey_of_classification(String classification, String key) {
int ret = 0;
try {
String[] filepath = get_files_path(classification);
for (int j = 0; j < filepath.length; j++) {
String text = get_text(filepath[j]);
if (text.contains(key)) {
ret++;
}
}
} catch (FileNotFoundException fnfex) {
logger.error("#" + fnfex.getStackTrace());
} catch (IOException ioex) {
logger.error("#" + ioex.getStackTrace());
}
return ret;
}

/**
* @param filepath
* @return 给定文本的文本内容
* @throws FileNotFoundException
* @throws IOException
*/
public String get_text(String filepath) throws FileNotFoundException, IOException {
InputStreamReader isReader = new InputStreamReader(new FileInputStream(filepath), "GBK");
BufferedReader reader = new BufferedReader(isReader);
String aline;
StringBuilder sb = new StringBuilder("");
while ((aline = reader.readLine()) != null) {
sb.append(aline + " ");
}
isReader.close();
reader.close();
return sb.toString();
}

/**
* @param classification
* @return 当前类别下的样本数量
*/
public int get_trainingfile_count_of_classification(String classification) {
// /home/larry/桌面/lucenc/Sample/C000008
File classDir = new File(traning_text_dir.getPath() + File.separator + classification);
return classDir.list().length;
}

/**
* 初始化语料库
*/
private void load_training_data() {
traning_text_dir = new File(training_path);
if (!traning_text_dir.isDirectory()) {
throw new IllegalArgumentException("训练语料库搜索失败！ [" + training_path + "]");
}
this.classes = traning_text_dir.list();
}

/**
* 中文分词->获取文本的关键字向量
*
* @param text
* @param splitToken
* @return
*/
public String split(String text, String splitToken) {
StringBuffer result = new StringBuffer("");
try {
Analyzer analyzer = new IKAnalyzer(true);
StringReader reader = new StringReader(text);
TokenStream ts = analyzer.tokenStream(null, reader);
ts.addAttribute(CharTermAttribute.class);
while (ts.incrementToken()) {
CharTermAttribute ta = ts.getAttribute(CharTermAttribute.class);
result.append(ta.toString() + splitToken);
}
} catch (IOException e) {
e.printStackTrace();
}
return result.toString();
}

}