从原始文档到KNN分类算法实现(二）

1.复旦语料库train集中有6个类是多于1000个文档的，把它们取出来，分别删减至1000个文档，构成接下来我们要进行实验的训练集。
2.执行Predeal.java，它依次进行三项操作：把文件重命名为顺序的数字编号;把文件编号（即文件名）写入文档开头，用一个空格与正文内容隔开，去除正文每行末的换行符，把整个文档合并为一行，去除正文行间的空格;用ICTCLAS进行中文分词.由于一次运行对6000个文件进行分词程序会中断退出。所以只好一次只处理1000个文件。
这里去除停用词的方法我多说一句，程序中的代码是if (word.length()>=2 && (!Predeal.stopwords.contains(word)))，即我们不统计单个的数字、字母和汉字，也可避免把空格统计进去，所以用停用词表中全部是长度大于1的词语，并且根据语料库的情况多加了一些词，比如“期号、出处、原刊、原文、正文、标题”等。

/**
 * Author: Orisun
 * Date: Sep 2, 2011
 * FileName: Predeal.java
 * Function: 去除每行末的换行符，把整个文档合并为一行，去除行间的空格；用ICTCLAS进行中文分词；把文件重命名为顺序的数字编号，把该编号写入文档开头，用空格与正文内容隔开。
 */

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.HashSet;

import ICTCLAS.I3S.AC.ICTCLAS50;

public class Predeal {
    //文档顺序编号
    public static int seqnum=0;
    // 停用词集合
    public static HashSet<String> stopwords = new HashSet<String>();

    // 初始化停用词表
    public static void init_SW(String filePath) {
        File swFile = new File(filePath);
        if(!swFile.exists()){
            System.out.println("文件不存在，程序退出.");
            System.exit(2);
        }
        try {
            FileReader fr = new FileReader(swFile);
            BufferedReader br = new BufferedReader(fr);
            String word = null;
            while ((word = br.readLine()) != null) {
                stopwords.add(word);
            }
            br.close();
        } catch (IOException exp) {
            System.out.println("读取停用词时发生异常：" + exp.getMessage());
        }
    }
    
    //把文件重命名为顺序的数字编号
    public void renameDoc(File srcFile){
        if(srcFile.isDirectory()){
            File[] childFiles=srcFile.listFiles();
            for(File child:childFiles){
                renameDoc(child);
            }
        }
        else if(srcFile.isFile()){
            String newname=String.valueOf(seqnum);            
            if(!srcFile.renameTo(new File(srcFile.getParent(),newname))){
                System.out.println("文件重命名失败，程序退出。");
                System.exit(2);
            }
            seqnum++;
        }
    }
    //把文件编号（即文件名）写入文档开头，用一个空格与正文内容隔开。去除正文每行末的换行符，把整个文档合并为一行，去除正文行间的空格.
    public void delWrapAndSpace(File srcFile){
        if(srcFile.isDirectory()){
            File[] childFiles=srcFile.listFiles();
            for(File child:childFiles){
                delWrapAndSpace(child);
            }
        }
        else if(srcFile.isFile()){
            String filename=srcFile.getName();
            //文档开头写入文件名加空格
            StringBuffer content=new StringBuffer(filename+" ");
            try{
                FileReader fr=new FileReader(srcFile);
                BufferedReader br=new BufferedReader(fr);
                String line;
                while((line=br.readLine())!=null){        //readLine()并不读取末尾的换行符
                    content.append(line.replaceAll("\\s+",""));        //StringBuffer会自动扩容.同时去除行间的空格
                }
                br.close();
                FileWriter fw=new FileWriter(srcFile);
                BufferedWriter bw=new BufferedWriter(fw);
                bw.write(content.toString());
                bw.flush();
                bw.close();
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }

    //用ICTCLAS进行中文分词.一次运行对6000个文件进行分词程序会中断退出。所以只好一次只处理1000个文件。
    public void wordSeg(File srcFile) {
        if (srcFile.isDirectory()) {
            File[] childFiles = srcFile.listFiles();
            for (File child : childFiles) {
                wordSeg(child);
            }
        } else if (srcFile.isFile()) {
            try {
                ICTCLAS50 ictc = new ICTCLAS50();
                 // 指定Configure.xml和Data directory的存储位置
                String argu = "/home/orisun/master/ICTCLAS50_Linux_RHAS_32_JNI/API";
                if (ictc.ICTCLAS_Init(argu.getBytes("GB2312")) == false) { // UTF-8
                    System.out.println("Init Fail!");
                    return;
                }
                // 这里的参数“3”指定了待分词的文件是UTF-8编码
                if (ictc.ICTCLAS_FileProcess(srcFile.getAbsolutePath()
                        .getBytes(), 3, 0, srcFile.getAbsolutePath().getBytes()) == false) {
                    System.out.println(srcFile + "文件分词失败.");
                    return;
                }
                ictc.ICTCLAS_Exit(); // 释放分词组件资源
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
    
    public static void main(String[] args){
        Predeal predeal=new Predeal();
        //训练文本集
        File train=new File("/home/orisun/train");
        if(!train.exists()){
            System.out.println("文件不存在，程序退出.");
            System.exit(2);
        }
        predeal.renameDoc(train);
        predeal.delWrapAndSpace(train);
        predeal.wordSeg(new File(train,"C19"));    
        predeal.wordSeg(new File(train,"C31"));
        predeal.wordSeg(new File(train,"C32"));
        predeal.wordSeg(new File(train,"C33"));
        predeal.wordSeg(new File(train,"C38"));
        predeal.wordSeg(new File(train,"C39"));
    }
}

3.WordDocMatrix.java使用Hadoop的MapReduce技术，生成word-doc矩阵。在map阶段进行一项预处理--去除停用词，并报告一条“单词--文件名"。在reduce阶段统计每个单词在各个文档中出现的次数，当单词在至少4个文档中出现时把它记入文件matrix/part-r-0000.
由于采用了hadoop技术不能在Eclipse里面直接运行，具体方法是：
（1）进行工程的bin文件夹
    cd ~/workspace/TextClassify/bin
（2）对所有class文件进行打包
    jar -cvf ~/WordDocMatrix.jar *.class
（3）把用户根目录下的matrix文件删除，把~/train下面的6个文件夹下面的所有文本文件移动到~/train下，删除6个分类文件夹。
（4）回到用户根目录，使用hadoop运行jar包
    cd ~
    hadoop jar WordDocMatrix.jar WordDocMatrix
由于是在单机上采用standalone模式运行hadoop，所以执行时间特别长，大约用了310分钟（1G内存），生成的part-r-0000文件有44222行，这也就是说在训练集中去除食用词后有44222个单词至少在4篇文本中出现过，接下来我们要计算这44222个单词的增益值，并对其进行排序。
当然不采用hadoop行动时间肯定会大大缩短，但在实际中由于word-doc矩阵非常大，程序运行一两分钟后就内存溢出了。

/**
 * Author: Orisun 
 * Date: Sep 2, 2011 
 * FileName: WordDocMatrix.java 
 * Function: 使用Hadoop的MapReduce技术，生成word-doc矩阵。在map阶段进行一项预处理--去除停用词，并报告一条“单词--文件名"。在reduce阶段统计每个单词在各个文档中出现的次数，当单词在至少4个文档中出现时把它记入文件。
 */
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashSet;

import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;

public class WordDocMatrix {

    public static int docnum = 6000; // 训练文档总数
    public static int clanum = 6; // 训练分类总数

    static class WordDocMatrixMapper extends
            Mapper<LongWritable, Text, Text, Text> {
        public void map(LongWritable key, Text value, Context context)
                throws IOException, InterruptedException {
            // 经过Predeal后，一行就是一个文档的全部内容
            String line = value.toString();
            String[] words = line.split("\\s+");
            String fname = words[0];
            for (int i = 1; i < words.length; i++) {
                String word = words[i];
                //不统计单个的数字、字母和汉字，也可避免把空格统计进去
                if (word.length()>=2 && (!Predeal.stopwords.contains(word))) { // 去除停用词
                    context.write(new Text(word), new Text(fname));
                }
            }
        }
    }

    static class WordDocMatrixReducer extends Reducer<Text, Text, Text, Text> {
        public void reduce(Text key, Iterable<Text> files,Context context) throws IOException, InterruptedException {
            ArrayList<Integer> al = new ArrayList<Integer>(docnum);
            for (int i = 0; i < docnum; i++)
                al.add(0);
            HashSet<Integer> set=new HashSet<Integer>();
            boolean flag=false;
            for (Text file : files) {
                int index = Integer.parseInt(file.toString());
                int ori = al.get(index);
                al.set(index, ori + 1);
                if(!flag){
                    set.add(index);
                    if(set.size()>3){
                        flag=true;
                    }
                }
            }        
            if(flag){
                StringBuffer count = new StringBuffer();
                for(int i=0;i<al.size();i++){
                    count.append(al.get(i)+" ");
                }
                context.write(key, new Text(count.toString()));
            }
        }
    }

    public static void main(String[] args) throws Exception {
        Predeal.init_SW("/home/orisun/master/StopWordTable_ZH");
        Path inputPath=new Path("/home/orisun/train");
        Path outputPath=new Path("/home/orisun/matrix");
        Job job = new Job();
        job.setJarByClass(WordDocMatrix.class);
        FileInputFormat.addInputPath(job, inputPath);
        FileOutputFormat.setOutputPath(job, outputPath);
        job.setMapperClass(WordDocMatrixMapper.class);
        job.setReducerClass(WordDocMatrixReducer.class);
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(Text.class);
        System.exit(job.waitForCompletion(true) ? 0 : 1);
    }
}

4.运行FeatureSelect.java，计算每个单词的信息增益值，选择IG大的作为特征项。如果选用HashMap来存储单词及它对应的IG值，很快会内存溢出，所以我选择使用BerkelyDB来存储。
BerkelyDB是一个嵌入式数据库，它适合于管理海量的、简单的数据。Key/Value是BerkelyDB进行数据管理的基础。BerkelyDB底层实现采用B树，可以看成能够存储海量数据的HashMap。
程序计算了44222个单词的IG值，并把IG最大的300个特征项输出到文件，总共也只用了几分钟，确实挺快的！

/**
 * Author: Orisun
 * Date: Sep 3, 2011
 * FileName: FeatureSelect.java
 * Function: 读取word-doc矩阵，计算每个词的信息增益值，排序。输出IG最大的前300个特征项。
 */

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;

import com.sleepycat.bind.EntryBinding;
import com.sleepycat.bind.serial.SerialBinding;
import com.sleepycat.bind.serial.StoredClassCatalog;
import com.sleepycat.collections.StoredMap;
import com.sleepycat.je.Database;
import com.sleepycat.je.DatabaseConfig;
import com.sleepycat.je.DatabaseException;
import com.sleepycat.je.Environment;
import com.sleepycat.je.EnvironmentConfig;

public class FeatureSelect {
    private Environment env;
    protected Database database; // 用来存放url队列的数据库
    protected Database catalogdatabase; // 用来创建StoredClassCatalog实例的数据库
    private static final String CLASS_CATALOG = "java_class_catalog"; // catalogdatabase的数据库名
    protected StoredClassCatalog javaCatalog; // StoredClassCatalog实例用来序列化对象
    StoredMap<String, Double> FeaDB = null;

    public FeatureSelect(String homeDirectory) throws DatabaseException,
            FileNotFoundException {
        EnvironmentConfig envConfig = new EnvironmentConfig(); // 环境配置
        envConfig.setTransactional(true); // 允许事务
        envConfig.setAllowCreate(true); // 当环境配置不存在时就创建
        env = new Environment(new File(homeDirectory), envConfig); // 创建环境

        DatabaseConfig dbConfig0 = new DatabaseConfig(); // 数据库配置
        dbConfig0.setTransactional(true); // 允许事务
        dbConfig0.setAllowCreate(true); // 当数据库不存在时就创建
        catalogdatabase = env.openDatabase(null, CLASS_CATALOG, dbConfig0);
        javaCatalog = new StoredClassCatalog(catalogdatabase);
        
        DatabaseConfig dbConfig = new DatabaseConfig(); // 数据库配置
        dbConfig.setTransactional(true); // 允许事务
        dbConfig.setAllowCreate(true); // 当数据库不存在时就创建
        database = env.openDatabase(null, "URL", dbConfig); // 打开数据库
        
        EntryBinding<String> keyBinding = new SerialBinding<String>(
                javaCatalog, String.class);
        EntryBinding<Double> valueBinding = new SerialBinding<Double>(
                javaCatalog, Double.class);
        FeaDB = new StoredMap<String, Double>(database, keyBinding,
                valueBinding, true);
    }

    public void close() throws DatabaseException {
        database.close(); // 关闭存放url的数据库
        javaCatalog.close(); // 关闭用来序列化对象的javaCatalog类
        env.close(); // 关闭环境
    }

    public void calIG(File matrixFile) {
        if (!matrixFile.exists()) {
            System.out.println("Matrix文件不存在.程序退出.");
            System.exit(2);
        }

        double entropy = Math.log(WordDocMatrix.clanum);
        try {
            FileReader fr = new FileReader(matrixFile);
            BufferedReader br = new BufferedReader(fr);
            String line = null;
            while ((line = br.readLine()) != null) {
                String[] content = line.split("\\s+");
                String word = content[0];
                ArrayList<Short> al = new ArrayList<Short>(WordDocMatrix.docnum);
                for (int i = 0; i < WordDocMatrix.docnum; i++) {
                    short count = Short.parseShort(content[i + 1]);
                    al.add(count);
                }
                int category = WordDocMatrix.docnum / WordDocMatrix.clanum;
                int wcount = 0; // 出现word的文档的文档数量
                int[] wcount_class = new int[WordDocMatrix.clanum];// 每个类别中出现单词word的文档数
                double pw = 0.0; // 出现word的文档占全部文档的比重
                double[] pcw = new double[WordDocMatrix.clanum]; // 在单词word出现时各个类别所占的比重
                double[] pcw_b = new double[WordDocMatrix.clanum]; // 在单词word不出现时各个类别所占的比重
                for (int i = 0; i < WordDocMatrix.clanum; i++) {
                    for (int j = 0; j < category; j++) {
                        if (al.get(j + i * category) > 0) {
                            wcount_class[i]++;
                        }
                    }
                    wcount += wcount_class[i];
                }
                pw = 1.0 * wcount / WordDocMatrix.docnum;
                for (int i = 0; i < WordDocMatrix.clanum; i++) {
                    pcw[i] = 1.0 * wcount_class[i] / wcount;
                    pcw_b[i] = 1.0 * (category - wcount_class[i])
                            / (WordDocMatrix.docnum - wcount);
                }
                double d1 = 0.0;
                double d2 = 0.0;
                for (int i = 0; i < WordDocMatrix.clanum; i++) {
                    d1 += pcw[i] * Math.log(pcw[i] + Double.MIN_VALUE);
                    d2 += pcw_b[i] * Math.log(pcw_b[i] + Double.MIN_VALUE);
                }
                double ig = entropy + pw * d1 + (1.0 - pw) * d2;
                FeaDB.put(word, ig);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    // Map按value进行排序(从大到小)
    public ArrayList<Entry<String, Double>> sort() {
        ArrayList<Entry<String, Double>> al = new ArrayList<Entry<String, Double>>();
        //从数据库中读取数据
        if(!FeaDB.isEmpty()){
            Iterator<Entry<String,Double>> iter=FeaDB.entrySet().iterator();
            while(iter.hasNext()){
                Entry<String,Double> entry=iter.next();
                al.add(entry);
            }
        }
        Collections.sort(al, new Comparator<Map.Entry<String, Double>>() {
            public int compare(Map.Entry<String, Double> o1,
                    Map.Entry<String, Double> o2) {
                double res = o2.getValue() - o1.getValue();
                if (res < 0)
                    return -1;
                else if (res > 0)
                    return 1;
                else
                    return 0;
            }
        });
        return al;
    }

    public static void main(String[] args) throws Exception{
        FeatureSelect fs = new FeatureSelect("/home/orisun/develop/workspace");
        fs.calIG(new File("/home/orisun/matrix/part-r-00000"));
        ArrayList<Entry<String, Double>> al = fs.sort();
        fs.close();
        Iterator<Entry<String, Double>> iter = al.iterator();
        int n = 0;
        File file = new File("/home/orisun/features");
        try {
            file.createNewFile();
            FileWriter fw = new FileWriter(file);
            BufferedWriter bw = new BufferedWriter(fw);
            while (iter.hasNext() && n++ < 300) {
                Entry<String, Double> entry = iter.next();
                bw.write(entry.getKey() + "\t");
                bw.write(String.valueOf(entry.getValue()));
                bw.newLine();
            }
            bw.flush();
            bw.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

遇到内存溢出时我分别采取了两种解决方案：Hadoop和Berkely DB。由于Berkely DB出乎意料地快，而Hadoop独立模式又灰常地慢，所以可以考虑把WordDocMatrix.java采用Berkely DB来实现。