《Lucene In Action》第四章.Analysis（分词）

Leave a reply

简单来说，Analysis就是把field Text转化成基本的Term的形式。

通过分词，将Text转化为Token，Token+对应的Field即为Term。

分词的处理包括：萃取、丢弃标点、移除发音、小写、移除常用单词、去除变形（去掉过去时等）等。

本章将介绍如何使用内置的分词器，以及如何根据语言、环境等特点创建自己的分词器。

4.1  使用Analysis

分词用于所有需要将Text转化成Term的场合，在Lucene中主要有两个：

1、Index（索引）

2、使用QueryParser的时候。

首先从一个简单例子看各内置分词器的效果：

例子1

对 "The quick brown fox jumped over the lazy dogs" 进行分词的结果：
WhitespaceAnalyzer :
[The] [quick] [brown] [fox] [jumped] [over] [the] [lazy] [dogs]

SimpleAnalyzer :
[the] [quick] [brown] [fox] [jumped] [over] [the] [lazy] [dogs]

StopAnalyzer :
[quick] [brown] [fox] [jumped] [over] [lazy] [dogs]

StandardAnalyzer:
[quick] [brown] [fox] [jumped] [over] [lazy] [dogs]

只有被分词处理后的Term才能被检索到。

例子2

对 "XY&Z Corporation - xyz@example.com" 进行分词
WhitespaceAnalyzer:
[XY&Z] [Corporation] [-] [xyz@example.com]

SimpleAnalyzer:
[xy] [z] [corporation] [xyz] [example] [com]

StopAnalyzer:
[xy] [z] [corporation] [xyz] [example] [com]

StandardAnalyzer:
[xy&z] [corporation] [xyz@example.com]

各个内置分词器的简介

WhitespaceAnalyzer：仅仅按照空白分隔开

SimpleAnalyzer：在非字母处分隔开，并小写化，它将丢弃所有数字。

StopAnalyzer：与SimpleAnalyser相同，除此之外，去除英文中所有的stop words（如a the等），可以自己指定这个集合。

StandardAnalyzer：较为高级的一个，能识别公司名字、E-mail地址、主机名等同时小写化并移除stop words。

在Index时使用Anaylsis

Analyzer analyzer = new StandardAnalyzer(Version.LUCENE_CURRENT);
IndexWriter writer = new IndexWriter(directory, analyzer, IndexWriter.MaxFieldLength.UNLIMITED);

注意如果需要分词，在创建Field的时候，必须指定Field.Index.ANALYZED或者Field.Index.ANALYZED_NO_NORMS。

如果Text想被整体索引而不被分词，使用Field.Index.NOT_ANALYZED或者Field.Index.NOT_ANALYZED_NO_NORMS

另外，对于是否存储分词前原文，由Field.Store.YES or Field.Store.NO控制。

在QueryParser时使用Anaylsis

QueryParser parser = new QueryParser(Version.LUCENE_CURRENT , "contents", analyzer);
Query query = parser.parse(expression);

Anaylsis将expression拆分为必要的Term以用于检索，但Lucene并不会把全部的expression交给Analysis处理，而是分块进行。

例如对于

“president obama” +harvard +professor

会单独地触发analyser三次，分别是

1.president obama

2.harvard

3.professor

一般来说，index和parser应该使用相同的Analysis.

Analysis不适用的场景

Analysis只适用于文本内部使用，只限制在一个Field中用。对于HTML这种包含<body>、<head>等多个属性即多个Field的不适用，在这种情况下，需要在Analysis前进行Parsing，即预处理。

4.2  Analyzer内部详解

Analyzer类是抽象类，将text转换为TokenStream，一般只需要实现这个方法即可：

public TokenStream tokenStream(String fieldName, Reader reader)

例如SimpleAnalyzer

public final class SimpleAnalyzer extends Analyzer {
@Override

public TokenStream tokenStream(String fieldName, Reader reader) {
return new LowerCaseTokenizer(reader);
}

@Override
public TokenStream reusableTokenStream(String fieldName, Reader reader
throws IOException {
Tokenizer tokenizer = (Tokenizer) getPreviousTokenStream();
if (tokenizer == null) {
tokenizer = new LowerCaseTokenizer(reader);
setPreviousTokenStream(tokenizer);
} else
tokenizer.reset(reader);
return tokenizer;
}
}

LowerCaseTokenizer将text在非字母处分隔开，移除非字母的字符，并对字母小写化。

reusableTokenStream允许对已经使用过的TokenStream进行重用。

Token内部

Token除了存储每个独立词之外，还包含了每个词的Meta信息，例如在Text中的偏移pos，以及position increment，默认为1，但也可以调整以用于它用。

例如position increment = 0 可用于注入同义词

position increment = 2 表示中间有被删除的单词

Token还可以包含由Application指定的额外数据payload(byte [ ])。

TokenStream

TokenStream用来产生一系列的Token，主要有Tokenizer和TokenFilter两种，他们均继承自TokenStream。

Tokenizer：从Reader读取字符，并创建Tokens

TokenFilter：读入Tokens，并由此产生新的Token，或删除部分Token。

处理流程：

Reader  ->  Tokenizer -> TokenFilter -> ...... -> TokenFilter -> Tokens

核心的Tokenizer

Tokenizer：以Reader为输入的Token处理抽象类。

CharTokenizer：基于字符的Tokenizer抽象类，当isTokenChar()返回true的时候，产生新Token，也具备小（大）写化的功能。

WhitespaceTokenizer：继承自CharTokenizer，所有非空白的char，isTokenChar()均返回true，其他false。

KeywordTokenizer：将全部输入作为一个Token。

LetterTokenizer：继承自CharTokenizer，所有字母的char，isTokenChar()均返回true，其他false。

LowerCaseTokenizer：继承自，LetterTokenizer，并让所有字母变成小写。

SinkTokenizer：吸收Tokens，可结合TeeTokenizer用于分隔Token。

StandardTokenizer：基于语法的Tokenizer，例如可分离出高级结构例如E-Mail地址，可能要结合StandardFilter使用。

核心的TokenFilter

LowerCaseFilter：将Token小写化。

StopFilter：将存在于list中的Stopwords 移除

PorterStemFilter：同一化词根，例如country和countries被转化为countri。

TeeTokenFilter：分隔TokenStream。

ASCIIFoldingFilter：？？

CachingTokenFilter：

LengthFilter：只接受Token长度在指定范围内的，其余丢弃。

StandardFilter：与StandardTokenizer配合使用，移除缩略词中的.省略号等。

在Analyzer中，可以把这些Tokenizer和TokenFilter结合起来使用。

public TokenStream tokenStream(String fieldName, Reader reader) {
return new StopFilter(true,  new LowerCaseTokenizer(reader),  stopWords);

}

如何查看Analyzer的结果

AnalyzerUtils.displayTokens(analyzer, text);

AnalyzerUtils将调用Analyzer模拟进行分词，并将生成的Token显示出来。

具体过程如下：

public static void displayTokens(Analyzer analyzer,
String text) throws IOException {
displayTokens(analyzer.tokenStream("contents", new StringReader(text)));  //A
}

public static void displayTokens(TokenStream stream)
throws IOException {

TermAttribute term = (TermAttribute) stream.addAttribute(TermAttribute.class)
while(stream.incrementToken()) {
System.out.print("[" + term.term() + "] ");    //B
}
}

步骤：

1、调用analyzer的tokenStream，生成TokenStream（N多Token）。

2、在TokenStream上注册Attibute，

2、使用stream.incrementToken()遍历TokenStream，使用注册的Attribute获取每一个Term。

也可以注册PositionIncrementAttribute、OffsetAttribute、TypeAttribute等以获取更详细的Term信息。

关于Attribute和AttributeSource

在Lucene2.9之后，废弃了单独的Token类，采用Attrubute来遍历Token以提升系统性能。

TokenStream继承自AttributeSource，它可以提供可拓展的强类型而无需耗时的运行时强制转换。

用法：

1.注册：通过TokenStream的addAttribute获得对应的Attribute，

2.遍历：在stream.incrementToken()返回true的情况下，通过attribute来读取具体属性。

这个属性是双向的，通过对Attribute的更改可同步更新到实际的Token中。

Start、End Offset能做什么？

一般被存储于TermVectors中，用于高亮。

TokenType

一般来说，在TokenStream总，Token是有类型的，并且是有用的。

TypeAttribute可获得Token的具体类型

StandardAnalyzer和StandardTokenizer会自动给Token加上不同的类型。

Type不计入Index中，而只在Analysis中使用。

TokenFilter的顺序很重要

Filter需要在Token基础上进一步处理，因此经常依赖某一些处理结果。

例如StopFilter是大小写敏感的，所以要求之前Filter已经把字母全部小写化，否则可能The这种StopWord就没法被过滤了。

记住Analyzer是一个链条，因此一定要注意顺序。

4.3  使用内置的Analyzer

内置的Analyzer：WhitespaceAnalyzer、SimpleAnalyzer、StopAnalyzer、KeywordAnalyzer、StandardAnalyzer，几乎可用于处理所有西方文字（西欧语系）。

StopAnalyzer

除了基础的分词、小写化外，还从Token中移除StopWords，这个StopWords的List可以指定，默认为：

"a", "an", "and", "are", "as", "at", "be", "but", "by",
"for", "if", "in", "into", "is", "it",  "no", "not", "of", "on", "or", "such",
"that", "the", "their", "then", "there", "these",
"they", "this", "to", "was", "will", "with"

StandardAnalyzer

StandardAnalyzer有“最通用”Analyzer之城，内置了JFlex进行语法分析。

能处理数字、字母、首字母缩略、公司名、电子邮件、计算机主机名、内部省略号的单词、数字、IP、中文字符等。

同时还包含StopWords、

4.4  Sounds Like查询

例如Indexs中的cool cat  但是查询词是kool cat，这就是Sounds Like。

可以构造下述的分词器：

public class MetaphoneReplacementFilter extends TokenFilter {
public static final String METAPHONE = "METAPHONE";

private Metaphone metaphoner = new Metaphone();    //#A
private TermAttribute termAttr;
private TypeAttribute typeAttr;

public MetaphoneReplacementFilter(TokenStream input) {
super(input);
termAttr = (TermAttribute) addAttribute(TermAttribute.class);
typeAttr = (TypeAttribute) addAttribute(TypeAttribute.class);
}

public boolean incrementToken() throws IOException {
if (!input.incrementToken())                    //#B
return false;                                 //#C

String encoded;
encoded = metaphoner.encode(termAttr.term());   //#D
termAttr.setTermBuffer(encoded); //#E
typeAttr.setType(METAPHONE);                    //#F
return true;
}
}

标红的部分，将本kool替换成了cool，实际上可能是更简单的形式。

例如，对于The quick brown fox jumped over the lazy dogs

将被metaphoner.encode整理为[0] [KK] [BRN] [FKS] [JMPT] [OFR] [0] [LS] [TKS]

对于Sounds Like的文本：Tha quik brown phox jumpd ovvar tha lazi dogz

也就是两个类似的词被整理为精简版的单词，显然这个方法挺土的。

4.5  同义词检索

SynonymAnalyzer的目的是，将同义词替换为一个统一的，替换掉原来的位置。

public class SynonymAnalyzer extends Analyzer {
private SynonymEngine engine;

public SynonymAnalyzer(SynonymEngine engine) {
this.engine = engine;
}

public TokenStream tokenStream(String fieldName, Reader reader) {
TokenStream result = new SynonymFilter(
new StopFilter(true,
new LowerCaseFilter(
new StandardFilter(
new StandardTokenizer(
Version.LUCENE_CURRENT, reader))),
StopAnalyzer.ENGLISH_STOP_WORDS_SET),
engine
);
return result;
}
}

这个Analyzer除了在最后的Chain加上了SynonymFilter外并没有什么其他区别。

public class SynonymFilter extends TokenFilter {
public static final String TOKEN_TYPE_SYNONYM = "SYNONYM";

private Stack synonymStack;
private SynonymEngine engine;
private TermAttribute termAttr;
private AttributeSource save;

public SynonymFilter(TokenStream in, SynonymEngine engine) {
super(in);
synonymStack = new Stack();  //#1
termAttr = (TermAttribute) addAttribute(TermAttribute.class);
save = in.cloneAttributes();
this.engine = engine;
}

public boolean incrementToken() throws IOException {
if (synonymStack.size() > 0) {       //#2
State syn = (State) synonymStack.pop(); //#2
restoreState(syn);             //#2
return true;

}

if (!input.incrementToken())   //#3
return false;

addAliasesToStack();  //#4

return true;       //#5
}

private void addAliasesToStack() throws IOException {
String[] synonyms = engine.getSynonyms(termAttr.term());   //#6
if (synonyms == null) return;
State current = captureState();

for (int i = 0; i < synonyms.length; i++) {            //#7
save.restoreState(current);
AnalyzerUtils.setTerm(save, synonyms[i]);        //#7
AnalyzerUtils.setType(save, TOKEN_TYPE_SYNONYM); //#7
AnalyzerUtils.setPositionIncrement(save, 0);     //#8
synonymStack.push(save.captureState());          //#7
}
}
}

4.8  处理其他语言

处理其他语言面临的问题，特别是亚洲语言：无法通过空格来分词！

关于编码：应该统一使用UTF8。

对于其他西欧语言，可以使用SnowballAnalyzer（在contrib中）

Character规则化

对于某些场景，需要在Analyzer(Tokenizer)之前，对Reader读入的字符进行规则化。

例如：将繁体中文字符替换成简体中文。

Lucene提供了CharFilters，用于包装Reader，从而完成字符的替换、规则化工作。

Core提供的唯一、具体的实现类是：MappingCharFilter，提供一个Mapping，将原始字符替换为目标字符~

对亚洲语言进行分词

简言之：最好不要使用SimpleAnalyzer、StandardAnalyzer，书中推荐的是SmartChineseAnalyzer，类似的还有很多，网上一搜一大把~

您可能也喜欢如下文章:

  1. 《Lucene In Action》第三章.搜索
  2. Lucene in Action(2nd)--第二章 索引
  3. 7－13位前缀码生成
  4. 《数据结构》读书笔记 第四章 文本编辑
  5. Struts2同名对象转换--只成功了局部转换器

Leave a Reply

Your email address will not be published. Required fields are marked *