THUCTC源码解读(二)

在通过Demo初步了解了THUCTC的用法以后，开始深入探究THUCTC的结构，了解实现方式。只要了解了代码结构，才能了解背后的原理和优化方法，也方便在此基础上做出自己的改进。

THUCTC的主要原理

首先，会将训练文本进行分词处理，然后进行词频统计，通过统计词频和包含该词的文档频率，利用卡方(Chi-Square)检验来选择出特征词，并以此为依据构造文档向量(DocumentVector)，词向量中的每一项均代表一个特征（词），具体的值则为相应的权重，这里一般采用TF-IDF方式，即词的重要性与该文档中该次出现次数成正比，与包含该词的文件频率成反比。在构造完文档向量之后，则将训练和分类的任务交给了现成的库(liblinear或libsvm)。因此，也可以说，THUCTC主要完成的是文档的向量化工作。

Word类

Word类是THUCTC中最基本的类之一，功能很简单，就是存储单词信息，是词典的基本单元

存储的内容有:

id 该词在词典（Lexicon）中的id

name 该词本身，如”中国”

tf 即term frequency，词频，指该词在所有文档中出现次数

df 即document frequency ，文频，指出现该词的文档数

Lexicon类

Lexicon,即词典类，顾名思义，处理与词典相关的操作，其基本组成是Word对象。Lexicon类中的变量有:

Hashtable<Integer, Word> idHash     //从id到Word的映射，能够根据id获得对应Word对象
Hashtable<String, Word> nameHash    //从name到Word的映射，能够根据单词获得对应Word对象
long numDocs        // 处理过的文档数目
boolean locked      // 当词典被锁定时，locked=true 此时无法向词典中加入新Word

Set<Integer> termSet //是一个private项，用于保存一个文档中出现过的单词，用于统计df

在来看Lexicon类中的方法，主要有

[1] public Lexicon()
[2] public Word getWord( int id )
[3] public Word getWord( String name )
[4] public void addDocument ( String [] doc )
[5] public Word [] convertDocument ( String [] doc )
[6] protected Word buildWord ( String termString )
[7] public boolean loadFromFile( File f )
[8] public boolean loadFromInputStream(InputStream input)
[9] public Lexicon map( Map<Integer, Integer> translation )

我们一个个来看。

[1] public Lexicon()

public Lexicon () {
idHash = new Hashtable<Integer, Word>(50000);
nameHash = new Hashtable<String, Word>(50000);
locked = false;
numDocs = 0;
}

构建Lexicon对象的时候，

构建空的idHash和nameHash，容量为50000

将locked设为false, 即可以添加新单词

将numDocs设为0，表示未处理过文档

[2]public Word getWord( int id ), [3] public Word getWord( String name )

public Word getWord( int id ) {
return idHash.get ( id );
}
public Word getWord( String name ) {
return nameHash.get ( name );
}

[2]和[3]可以一起来看，前者是根据id提取出Word，后者根据name提取出Word

[4] public void addDocument ( String [] doc )

这个函数用于处理新文档以更新词典的状态(单词项，tf, df 值等等)

函数的输入doc需要是一个String数组，即此时的文档是分词完毕以后的结果，数组中的每一个字符串都是一个单词

public void addDocument ( String [] doc ) {
termSet.clear(); // 将termSet清空，准备处理新文档
for ( String token : doc ) {
Word t = nameHash.get(token); // 对于每个单词，使用nameHash获取对应Word对象
if ( t == null ) {
if ( locked )
continue;     // 若此时词典中无该单词但是locked=true,则跳过，即不添加新词
t = new Word(); // 若locked=false，则添加新词
t.name = token;
t.id = nameHash.size();
t.tf = 0;
t.df = 0;
nameHash.put(t.name, t); //将新词添加进idHash和nameHash
idHash.put(t.id, t);
}
t.tf += 1;  // 该词的term frequency +1
if ( ! termSet.contains(t.id) ) {
termSet.add(t.id); // 若该文档之前没出现过这个词，则该词的文档频率+1，否则不管
t.df++;
}
}
numDocs ++ ;  // numDocs++ ，表示处理过的文档数增加1
}

[5] public Word [] convertDocument ( String [] doc )

将分词后的文档转化成Word数组。如果出现新词，若locked=true 则更新词典，否则会跳过该新词

public Word [] convertDocument ( String [] doc ) {
Word [] terms = new Word[doc.length];  // 根据doc的长度来建立Word数组
int n = 0;
for ( int i = 0 ; i < doc.length ; i++ ) {
String token = doc[i];
Word t = nameHash.get( token );
if ( t == null ) {
if ( locked )
continue;
t = new Word ();
t.name = token;
t.tf = 1;
t.df = 1;
t.id = nameHash.size();
nameHash.put(t.name, t);
idHash.put(t.id, t);
}
terms[n++] = t; // 到此为止总体跟[4]addDocument比较相似，
//但是要注意当locked=true时，碰到新词是会跳过的
//也就是说，有可能会出现Word向量的长度小于doc长度的情况
}
if ( n < terms.length ) {
Word [] finalterms = new Word
; //这边就是处理上面提到过的情况
for ( int i = 0 ; i < n ; i++ ) {
finalterms[i] = terms[i];
}
terms = finalterms;
}
return terms;
}

[6] protected Word buildWord ( String termString )

这个方法是protected类型，不对外开放，是为下面两个方法loadFromInputStream服务的。

实现了根据一行字符串来新建Word对象的功能

protected Word buildWord ( String termString ) {
// 举例；  26163:附赠:114:94
Word t = null;
String [] parts = termString.split(":"); //将字符串根据';'分割成字符串数组
if ( parts.length == 4 ) {
t = new Word(); // 各项的值分别是: id,name,tf,df
t.id = Integer.parseInt(parts[0]);
t.name = parts[1].replace(COLON_REPLACER, ":");
t.tf = Integer.parseInt(parts[2]);
t.df = Integer.parseInt(parts[3]);
}
return t;
}

[7] public boolean loadFromFile( File f )

这个函数和后面的loadFromInputStream功能类似，都是用于从本地文件中载入之前构造好的词典

这个函数比较简单，先将文件转化成FileInputStream,然后调用[8]loadFromInputStream

public boolean loadFromFile( File f ) {
FileInputStream fis;
try {
fis = new FileInputStream(f); //FileInputStream能将文件转化成字节流
} catch (FileNotFoundException e) {
return false;
}
return loadFromInputStream(fis);
}

[8] public boolean loadFromInputStream(InputStream input)

用于从字节流中载入之前构造好的词典

public boolean loadFromInputStream(InputStream input) {
nameHash.clear();  // 先将之前的nameHash和idHash清空
idHash.clear();
try {
//BufferedReader( InputStreamReader( FileInputStream( File ) ) )
// FileInputStream 能把文件转化成字节流
// InputStreamReader 按照字节读取，一个汉字为2个字节
// BufferedReader 可以整行读取，效率更高
BufferedReader reader =
new BufferedReader( new InputStreamReader( input, "UTF-8") );

String termString;
numDocs = Integer.parseInt(reader.readLine()); //文件中的第一行为numDocs
while ( (termString = reader.readLine()) != null ) {
// lexion 中每一行，分别是id, name, tf, df
Word t = buildWord( termString );  // 调用[6]buildWord方法
if ( t != null ) {
nameHash.put( t.name, t); // 对于每一个词，都存入idHash和nameHash
idHash.put( t.id, t);
}
}
reader.close();   //关闭reader
} catch (UnsupportedEncodingException e) {
return false;
} catch (IOException e) {
return false;
}
return true;
}

[9] public Lexicon map( Map《Integer, Integer》 translation )

用于根据映射表来生成新的词典。

/**
* 紧缩词典，利用一个map把原来编号为key的word变为编号为value的word，去掉不在key
* 中的word
* @param translation 影射表
*/
public Lexicon map( Map<Integer, Integer> translation ) {
// 根据映射表生成新的词典
// 映射表的左边为该词在现有词典中的id
// 映射表的右边为该词在新词典中的id
// 注意，新词典的size只与映射表的长度有关，与旧词典的size无关
Lexicon newlex = new Lexicon();
Hashtable<Integer, Word> newIdHash = new Hashtable<Integer, Word>();
Hashtable<String, Word> newNameHash = new Hashtable<String, Word>();

for ( Entry<Integer, Integer> e : translation.entrySet()){
Word w = idHash.get(e.getKey());
Word nw = (Word) w.clone();
nw.id = e.getValue();
newIdHash.put(nw.id, nw);
newNameHash.put(nw.getName(), nw);
}
newlex.idHash = newIdHash;
newlex.nameHash = newNameHash;
newlex.numDocs = this.numDocs;
return newlex;
}