Bayes算法对垃圾邮件的过滤

 这段时间抽空做了一个利用Bayes算法来模拟对邮件进行过滤的小东东，算是对自己的一个锻炼吧。前前后后总共花了一周多的时间。 
      有关Bayes算法在反垃圾邮件中的应用，请看这里:

            http://www.5dmail.net/html/2006-5-18/2006518234548.htm

      很显然，上面的链接给的一个demo中，有一个比较大的缺陷，那就是它只是一个一个地统计字，而不是词语。在处理中文的问题上，demo的思路是行不通的，必须统计词语而不是一个一个的单字。从大量的文本中提取一个一个的我们熟悉的词语，说起来容易，做起来就相当的困难了，这个问题纠结了我很多天，终于发现原来就在javaEye首页上有对中文分词器IKAnalyzer的介绍，真的是“踏破铁鞋无觅处，得来全不费功夫”，立马把IKAnalyzer“偷”了过去，自己使用了一下，果然是非常的强大。

      有关IKAnalyzer中文分词器，请参看如下地址：

           http://www.iteye.com/wiki/interview/1899-ik-analyzer

     下面贴一段代码，看看这个分词器的强大: 

<SPAN style="FONT-SIZE: small">package ik.com.cn.test;

 import java.io.IOException;

package ik.com.cn.test; import java.io.IOException; import java.io.StringReader; import org.apache.lucene.analysis.Analyzer; import org.apache.lucene.analysis.Token; import org.apache.lucene.analysis.TokenStream; import org.wltea.analyzer.lucene.IKAnalyzer; /* * 分词的小Demo * 这个分词工具确实比较强悍 * 相关的jar包在附件eclipse工程下lib包下 */ public class SecondTest { public static void main(String args[]) throws IOException{ Analyzer analyzer = new IKAnalyzer(); String text="中华人民共和国"; StringReader reader = new StringReader(text); TokenStream ts = analyzer.tokenStream(text, reader); Token t = ts.next(new Token()); while (t != null) { String s=t.term(); System.out.println(s); t = ts.next(new Token()); } } }

 

 

 输出结果：

<SPAN style="FONT-SIZE: small">中华人民共和国
中华人民
中华
华人
人民共和国
人民
共和国
共和</SPAN>

中华人民共和国 中华人民 中华 华人 人民共和国 人民 共和国 共和

 

   下面贴出一个比较核心的类Bayes，主要是实现具体的算法。

 

<SPAN style="FONT-SIZE: small">package com.cn.bayes;

 import java.util.*;

 public class Bayes {
     private Hashtable<String, Integer> hashtable_good;
     private Hashtable<String, Integer> hashtabel_bad;
     private Hashtable<String, Double> hashtable_good_p;
     private Hashtable<String, Double> hashtable_bad_p;
     private Hashtable<String, Double> hashtable_probability;

     public Hashtable<String, Double> getHashtable_probability() {
         return hashtable_probability;
    }

     public void setHashtable_probability(
            Hashtable<String, Double> hashtableProbability) {
        hashtable_probability = hashtableProbability;
    }

     public Bayes(Hashtable<String, Integer> hashtable_good,
            Hashtable<String, Integer> hashtabel_bad) {
         this.hashtable_good = hashtable_good;
         this.hashtabel_bad = hashtabel_bad;
         this.hashtable_good_p = this.getGoodOrBadPercent(hashtable_good);
         this.hashtable_bad_p = this.getGoodOrBadPercent(hashtabel_bad);

         Set<String> set_allkeys = this.combineHasetableByKeys(this
                 .getHashtable_good(), this.getHashtabel_bad());
 //      Set s=hashtable_good_p.entrySet();
 //      System.out.println("hashtable_good_p");
 //      for (Object o :s.toArray()) {
 //          System.out.print("  "+o);
 //      }
 //      s=hashtable_bad_p.entrySet();
 //      System.out.println("hashtable_bad_p");
 //      for (Object o :s.toArray()) {
 //          System.out.print("  "+o);
 //      }
 //
 //      for (Object o : set_allkeys.toArray()) {
 //          System.out.print("  "+o);
 //      }
         this.hashtable_probability = this
                .calcHashtable_probability(set_allkeys);
 //      System.out.println();
 //        s=hashtable_probability.entrySet();
 //      for (Object o : s.toArray()) {
 //          System.out.print("  "+o);
 //      }
    }

     /*
     * 通过统计计算 得到 hashtable_good_p 或 hashtable_bad_p
     */
     @SuppressWarnings("unchecked")
     private Hashtable<String, Double> getGoodOrBadPercent(
            Hashtable hashtable_goodOrBad) {
         Hashtable<String, Double> percent = new Hashtable<String, Double>();
         int total = 0;
        String key;
        Integer value;
        Enumeration enumeration = hashtable_goodOrBad.elements();
         while (enumeration.hasMoreElements()) {
            total = total + (Integer) enumeration.nextElement();
        }
 //      System.out.println("total=" + total);

        enumeration = hashtable_goodOrBad.keys();
         while (enumeration.hasMoreElements()) {
            key = (String) enumeration.nextElement();
            value = (Integer) hashtable_goodOrBad.get(key);
 //          System.out.println(key + "   " + value);
             percent.put(key, new Double((value + 0.0) / total));
        }
 //       Set s = percent.entrySet();
 //       for (Object o : s.toArray()) {
 //       System.out.println(o);
 //       }
         return percent;
    }

     /*
     * 将两个hash表的所有key值保存在一个Set中，Set是不允许出现重复的元素
     *
     * 注意：这个也比较容易扩展将多个hash表的所有key保存在一个Set中
     *
     */
     @SuppressWarnings("unchecked")
     private Set<String> combineHasetableByKeys(
            Hashtable<String, Integer> hashtable_good,
            Hashtable<String, Integer> hashtabel_bad) {
         Set<String> allkeysSet = new HashSet();

        Set<String> goodKeysSet = hashtable_good.keySet();
        Set<String> badKeysSet = hashtabel_bad.keySet();
        Iterator it;
        it = goodKeysSet.iterator();
         while (it.hasNext()) {
            allkeysSet.add(it.next().toString());
        }
        it = badKeysSet.iterator();
         while (it.hasNext()) {
            allkeysSet.add(it.next().toString());
        }
         return allkeysSet;
    }

     /*
     * 根据Set提供的key值，计算每个key对应出现的可能性，并封装到hashtable中
     *
     */
     @SuppressWarnings("unchecked")
     private Hashtable<String, Double> calcHashtable_probability(
            Set<String> set_allkeys) {
        Iterator it = set_allkeys.iterator();
         Hashtable<String, Double> hashtable_probability = new Hashtable();
         while (it.hasNext()) {
            String key = it.next().toString();
             Double good_p_value = this.hashtable_good_p.get(key);
             Double bad_p_value = this.hashtable_bad_p.get(key);
             if (null == good_p_value) {
                 good_p_value = 0.0;
            }
             if (null == bad_p_value) {
                 bad_p_value = 0.0;
            }
            Double result = good_p_value + bad_p_value;
             Double percent=null;
             if (result != 0.0) {
                percent = bad_p_value / result;
            }
            hashtable_probability.put(key, percent);
        }
         return hashtable_probability;
    }

     public Hashtable<String, Integer> getHashtable_good() {
         return hashtable_good;
    }

     public Hashtable<String, Integer> getHashtabel_bad() {
         return hashtabel_bad;
    }
}</SPAN>