`

【Lucene3.0 初窥】文本分析器Analyzer

阅读更多

一个优秀的IR system要做好的第一件事就是利用自然语言处理技术(NLP)对文本进行分析。其中分词是最基本的,其性能直接决定IR system的搜索精度和速度。因此,大型Web搜索引擎都有自己的分词工具。

 

Lucene3.0 的分析器由三个包组成:

(1) org.apache.lucene.analysis 是Lucene分析器的基本结构包。包含了分析器最底层的结构(Analyzer、Tokenizer、TokenFilter接口和抽象类),一些简单分析器的具体实现类(如SimpleAnayzer, StopAnalyzer),一些常用的分词器和过滤器(如LowerCaseTokenizer、LowerCaseFilter)。


(2) org.apache.lucene.analysis.standard 是Lucene标准分析器的实现包。其功能就是为了实现英文的标准分词。


(3) org.apache.lucene.analysis.tokenattribute 是分词后token的属性结构包。其实Lucene分词并不仅仅只是得到词语本身,而是要得到每个词语的多种信息(属性)。比如词语字符串、类型、位置信息、存储的时候元数据信息等等。

 

 

一、 Lucene的分析器结构 

 

org.apache.lucene.analysis 是Lucene Analyzer底层结构包。主要包括Analyzer、Tokenizer和TokenFilter的接口规定。实际上,Lucene的Analyzer主要功能包括两个部分:(1)Tokenzier 分词器  (2)TokenFilter过滤器。

 

/**
 * Analyzer 定义了从文本中抽取词的一组规范。
 * 首先要实现一个Tokenizer,这个类会把输入流中的字符串切分成原始的词元。
 * 然后多个TokenFilter 就能够将这些词元规范化得到分词的结果
 */
public abstract class Analyzer implements Closeable {
      //具体实现应该是要返回一个嵌套了分词器和过滤器的对象。     
      public abstract TokenStream tokenStream(String fieldName, Reader reader);
      //......
}
 

要实现一种Lucene的分析器(Analyzer),至少要实现一个分词器(Tokenizer)。对于特定语言来说,必要的过滤器(TokenFilter)也是不可缺少的。其中过滤器有很多种,主要可以用来对分词结果进行标准化。比如去停用词、转换大小写、英文的词干化(stemming)和词类归并 (lemmatization)等等。下面我们看看Tokenizer和TokenFilter的主要代码:

//Tokenizer
public abstract class Tokenizer extends TokenStream {
     /**待分词的文本输入流 */
     protected Reader input;
     /**无参构造器 */
     protected Tokenizer() {
     }
     /** 带输入流的构造器*/
     protected Tokenizer(Reader input) {
          this.input = CharReader.get(input);
     }
     /** 关闭输入流 */
     @Override
     public void close() throws IOException {
         input.close();
     }
}
//TokenFilter
public abstract class TokenFilter extends TokenStream {
  /** 待过滤的词元流 */
  protected final TokenStream input;
  /** 构造器 */
  protected TokenFilter(TokenStream input) {
       super(input);
        this.input = input;
  }
  /** 关闭流 */
  @Override
  public void close() throws IOException {
        input.close();
  }
}

分词器和过滤器都是TokenStream的子类。而过滤器的构造参数需要的就是TokenStream。这是一种装饰者的模式设计,我们可以通过嵌套调用来达到不同的过滤目的。比如: new XTokenFilter(new YTokenFilter( new XTokenizer))。

 

相对于老版本的Lucene分词器,3.0版本的Lucene的Tokenizer多了一种构造器。

 protected Tokenizer(AttributeSource source) 

 

二、Lucene的标准分析器——StandardAnalyzer

 

org.apache.lucene.analysis.standard 包含了Lucene的标准分析器(StandardAnalyzer),它由标准分词器(StandardTokenizer)和标准过滤器(StandardFilter)构成。都只能处理英文。

 

StandardAnalyzer 部分源代码如下:

public class StandardAnalyzer extends Analyzer {
        /**英语停用词表*/
        public static final Set<?> STOP_WORDS_SET = StopAnalyzer.ENGLISH_STOP_WORDS_SET;
        /**若干构造器*/
        public StandardAnalyzer(Version matchVersion) {
           this(matchVersion, STOP_WORDS_SET);
        }
        /**分词并进行标准过滤、大小写过滤和停用词过滤*/
        @Override
        public TokenStream tokenStream(String fieldName, Reader reader) {
                 //构造一个标准分词器,并进行分词
                 StandardTokenizer tokenStream = new StandardTokenizer(matchVersion, reader);
                 //设置分词后词元流的最大长度
                 tokenStream.setMaxTokenLength(maxTokenLength);
                 //进行标准过滤
                 TokenStream result = new StandardFilter(tokenStream);
                 //进行大小写过滤
                 result = new LowerCaseFilter(result);
                 //进行停用词过滤
                 result = new StopFilter(enableStopPositionIncrements, result, stopSet);
                 return result;
       }

}

StandardAnalyzer是Lucene索引建立和检索索引时都需要使用的分析器,tokenStream方法的作用就是对输入流reader先进行分词,再进行一系列的过滤。

 

标准分词器:StandardTokenizer

 

public final class StandardTokenizer extends Tokenizer {

       /**JFlex扫描器*/
       private final StandardTokenizerImpl scanner;
      /**从输入流字串中解析出的词元的各种信息*/
       private TermAttribute termAtt; //词元的内容,如"tearcher"  "xy12@yahoo.com"  "1421"
       private OffsetAttribute offsetAtt;  //词元的首字母和尾字母在文本中的位置信息
       private PositionIncrementAttribute posIncrAtt;  //当前词元在TokenStream中相对于前一个token的位置,用于短语搜索
       private TypeAttribute typeAtt;  //词元所属的类别,,如<ALPHANUM>、<EMAIL>、<NUM>

       //标准分词器构造器,并用JFlex对象解析输入流
       public StandardTokenizer(Version matchVersion, Reader input) {
              super();
              this.scanner = new StandardTokenizerImpl(input);
              init(input, matchVersion);
       }
        //初始化词元的属性信息
       private void init(Reader input, Version matchVersion) {
           if (matchVersion.onOrAfter(Version.LUCENE_24)) {
                  replaceInvalidAcronym = true;
           } else {
                 replaceInvalidAcronym = false;
           }
            this.input = input;    
            termAtt = addAttribute(TermAttribute.class);
            offsetAtt = addAttribute(OffsetAttribute.class);
            posIncrAtt = addAttribute(PositionIncrementAttribute.class);
            typeAtt = addAttribute(TypeAttribute.class);
       }

       //将JFlex扫描后的匹配结果按词元的不同属性存储
       //比如当前词元是I'm  则将I'm存储到TermAttribute中,而<APOSTROPHE>则存放到TypeAttribute中。
       @Override
       public final boolean incrementToken() throws IOException {
            clearAttributes();
            int posIncr = 1;

            while(true) {
                 //通过JFlex扫描器scanner取得与规则相匹配的当前词元,否则返回-1
                 int tokenType = scanner.getNextToken();

                 if (tokenType == StandardTokenizerImpl.YYEOF) {
                     return false;
                 }
                 //scanner.yylength() 是当前词元的长度,maxTokenLength是词元允许的最大长度,值为255    
                 if (scanner.yylength() <= maxTokenLength) {
                       posIncrAtt.setPositionIncrement(posIncr);
                       //将当前词元字串储记录在TermAttribute属性中,比如“I'm”
                       scanner.getText(termAtt);
                       //得到当前词元首字母在整个文本内容中的位置
                       final int start = scanner.yychar();             
                       //将当前词元的位置信息(开始位置,结束位置)记录在OffsetAttribute属性中      
                       offsetAtt.setOffset(correctOffset(start), correctOffset(start+termAtt.termLength()));
                       //确定当前词元的类别信息,并记录在TypeAttribute属性中
                       if (tokenType == StandardTokenizerImpl.ACRONYM_DEP) {
                       if (replaceInvalidAcronym) {
                           typeAtt.setType(StandardTokenizerImpl.TOKEN_TYPES[StandardTokenizerImpl.HOST]);
                           termAtt.setTermLength(termAtt.termLength() - 1); 
                       } else {
                           typeAtt.setType(StandardTokenizerImpl.TOKEN_TYPES[StandardTokenizerImpl.ACRONYM]);
                       }
                  } else {
                       typeAtt.setType(StandardTokenizerImpl.TOKEN_TYPES[tokenType]);
                  }
                  return true;
             } else
                 posIncr++;
            }
       }
 }

Lucene的英文分词器使用了JFlex的词法扫描方法。其具体实现在初始化StandardTokenizerImpl类时,通过调用类中的静态方法和StandardTokenizerImpl.jflex词法描述文件来一起解析待分词的输入流。并将最后扫描出来的词语分成    <ALPHANUM>、<APOSTROPHE>、<ACRONYM>、<COMPANY>、<EMAIL>、<HOST>、<NUM>、<CJ>、 <ACRONYM_DEP>九大类。这一过程和Java编译器的词法分析程序对Java程序的关键字、变量名等进行解析是一样的。因此想要了解JFlex,必须知道编译原理的相关知识,这里就不展开了(因为我也不知道)。

 

scanner是StandardTokenizerImpl类初始化的对象,这个对象里存储了扫描输入流字串得到的词元信息(词元的内容、长度、所属的类别、所在位置等)。相对于较早的版本,Lucene 3.0在这里有很大的变化。它没有用next()方法直接得到TokenStream的下一个词元内容,而是使用incrementToken()方法将每一个scanner.getNextToken()的各种词元信息保存在不同类型的Attribute里面,比如TermAttribute用于保存词元的内容,TyteAttribute用于保存词元的类型。

 

 

标准过滤器:StandardFilter

public final class StandardFilter extends TokenFilter {
 
   /**
    * 去除词语末尾的“'s”   如  it's-> it
    * 去除缩略语中的“.”  如U.S.A -> USA
    */
    @Override
    public final boolean incrementToken() throws java.io.IOException {
         if (!input.incrementToken()) {
             return false;
         }
         char[] buffer = termAtt.termBuffer();
         final int bufferLength = termAtt.termLength();
         final String type = typeAtt.type();
         if (type == APOSTROPHE_TYPE && bufferLength >= 2 && buffer[bufferLength-2] == '\'' && (buffer[bufferLength-1] == 's' || buffer[bufferLength-1] == 'S')) {
      
                 termAtt.setTermLength(bufferLength - 2);
          } else if (type == ACRONYM_TYPE) {    
                 int upto = 0;
                 for(int i=0;i<bufferLength;i++) {
                       char c = buffer[i];
                       if (c != '.')
                             buffer[upto++] = c;
                 }
                 termAtt.setTermLength(upto);
           }
       return true;
    }
}

 

 

三、token的属性结构Attribute

 

首先我们用下面的代码来看看打印标准分词器的运行结果

 

class StandardTest{
	public static void main(String[] args) throws IOException{
		//输入流
		StringReader s=new StringReader(new String("I'm a student. these are apples"));
                //标准分词
		TokenStream tokenStream = new StandardTokenizer(Version.LUCENE_CURRENT, s);
		//标准过滤
                tokenStream=new StandardFilter(tokenStream);
                //大小写过滤
		tokenStream=new LowerCaseFilter(tokenStream);
		
		TermAttribute termAtt=(TermAttribute)tokenStream.getAttribute(TermAttribute.class);
		TypeAttribute typeAtt=(TypeAttribute)tokenStream.getAttribute(TypeAttribute.class);
		OffsetAttribute offsetAtt=(OffsetAttribute)tokenStream.getAttribute(OffsetAttribute.class);
		PositionIncrementAttribute  posAtt=(PositionIncrementAttribute)tokenStream.getAttribute(PositionIncrementAttribute.class);
  		
		
		System.out.println("termAtt       typeAtt       offsetAtt       posAtt");
		while (tokenStream.incrementToken())  {  
			System.out.println(termAtt.term()+" "+typeAtt.type()+" ("+offsetAtt.startOffset()+","+offsetAtt.endOffset()+")   "+posAtt.getPositionIncrement());  
		} 
        }
}

 

打印结果:

termAtt typeAtt offsetAtt posAtt
i'm <APOSTROPHE> (0,3) 1
a <ALPHANUM> (4,5) 1
student <ALPHANUM> (6,13) 1
these <ALPHANUM> (15,20) 1
are <ALPHANUM> (21,34) 1
apples <ALPHANUM> (25,31) 1

 

前面讲 StandardTokenizer的的时候,我们已经谈到了token的这四种属性。在这里我们再次强调一下这些Lucene的基础知识。

 

Lucene 3.0之后,TokenStream中的每一个token不再用next()方法返回,而是采用了incrementToken()方法(具体参见上面)。每调用一次incrementToken(),都会得到token的四种属性信息(org.apache.lucene.analysis.tokenattributes包中):

 

如上例:

原文本:I'm a student. these are apples     

TokenSteam: [1:  I'm ]  [2:a]   [3:student]     [4:these]   [5:are ]   [6:apples]

 

(1) TermAttribute: 表示token的字符串信息。比如"I'm"

(2) TypeAttribute: 表示token的类别信息(在上面讲到)。比如 I'm 就属于<APOSTROPHE>,有撇号的类型

(3) OffsetAttribute:表示token的首字母和尾字母在原文本中的位置。比如 I'm 的位置信息就是(0,3)

(4) PositionIncrementAttribute:这个有点特殊,它表示tokenStream中的当前token与前一个token在实际的原文本中相隔的词语数量。

       比如: 在tokenStream中[2:a] 的前一个token是[1:  I'm ] ,它们在原文本中相隔的词语数是1,则token="a"的PositionIncrementAttribute值为1。如果token是原文本中的第一个词,则默认值为1。因此上面例子的PositionIncrementAttribute结果就全是1了。

       如果我们使用停用词表来进行过滤之后的话:TokenSteam就会变成: [1:  I'm ]   [2:student]    [3:apples]这时student的PositionIncrementAttribute值就不会再是1,而是与[1:  I'm ]在原文本中相隔词语数量=2。而apples则变成了5。

       那么这个属性有什么用呢,用处很大的。加入我们想搜索一个短语student apples(假如有这个短语)。很显然,用户是要搜索出student apples紧挨着出现的文档。这个时候我们找到了某一篇文档(比如上面例子的字符串)都含有student apples。但是由于apples的PositionIncrementAttribute值是5,说明肯定没有紧挨着。怎么样,用处很大吧。轻而易举的解决了短语搜索的难题哦。

 

其实还有两种:PayloadAttribute和FlagsAttribute。我暂时还不知道他们的具体作用

 

 

 

 

 

 

3
0
分享到:
评论
1 楼 onewind 2012-01-11  
TokenSteam: [1:  I'm ]  [2:a]   [3:student]     [4:these]   [5:are ]   [6:apples]

过滤后TokenSteam: [1:  I'm ]   [2:student]    [3:apples]

按照定义:PositionIncrementAttribute表示tokenStream中的当前token与前一个token在实际的原文本中相隔的词语数量

student对应的PositionIncrementAttribute为2
那么apples对应的PositionIncrementAttribute不应该是3么?求解释...

相关推荐

    Lucene 3.0 原理与代码分析完整版

    5. Analyzer:文本分析器,处理分词和标准化。 6. QueryParser:解析用户查询,生成Query对象。 五、高级特性 1. 分词器插件:允许自定义分词策略,适应不同领域的语料。 2. 基于位置的搜索:支持短语查询和近似...

    Lucene 3.0 原理与代码分析

    《Lucene 3.0 原理与代码分析》一书主要涵盖了Lucene 3.0版本的核心概念、工作原理及其源代码解析。Lucene是Apache软件基金会的一个开源项目,是一个高性能、全文检索库,提供了Java API,使得开发者能够方便地在...

    lucene3.0全文检索入门实例

    相比于 2.0 版本,3.0 引入了更高级的分析器(Analyzer)和文档(Document)处理,使得对文本的预处理更为精细,支持更多的语言和特性。 ```java Analyzer analyzer = new StandardAnalyzer(Version.LUCENE_30); ...

    lucene3.0核心jar包

    2. **分词器(Analyzer)**:Lucene 提供了多种分词器,如 StandardAnalyzer、SimpleAnalyzer 和 WhitespaceAnalyzer,它们负责将输入文本拆分成可搜索的词汇单元。在 Lucene 3.0 中,开发者可以根据需求选择或...

    Lucene3.0全文信息检索

    5. **增强的分析器**:Analyzer在3.0中有了更多可定制的选项,可以更好地处理各种语言和文本格式,支持更多的字符集和编码。 6. **更好的国际化支持**:Lucene 3.0增加了对多种语言的支持,包括中文,改进了对非...

    lucene3.0使用介绍及实例

    Lucene 3.0提供多种预定义的分词器,如StandardAnalyzer,针对英文文本进行标准化处理。 #### 1.3 索引(Index) 索引是Lucene的核心,它允许快速地查找和排序文档。创建索引的过程包括分析文本、建立倒排索引等...

    lucene3.0庖丁+索引搜索程序

    1. 文档索引:Lucene通过分词器(Tokenizer)将输入的文本分解成一系列的词语(Term),并为每个词语创建一个文档频率(Document Frequency, DF)。同时,使用Term频率-逆文档频率(Term Frequency-Inverse Document...

    Lucene3.0原理与代码分析完整版.docx

    在Lucene学习总结之二中,我们看到,Lucene的核心组件包括Analyzer(分析器)、Document(文档对象)、Field(字段)、IndexWriter(索引写入器)和Searcher(搜索器),它们协同工作以实现高效的信息检索。...

    lucene3.0英文API

    3. **分析(Analysis)**:分析器(Analyzer)负责将输入文本分解为一系列的词汇项(Terms),这是构建索引的基础。 4. **文档(Document)**:在Lucene中,文档是存储和检索的基本单元,可以包含多个字段(Field),每个字段...

    lucene 3.0 入门实例

    4. **分词器(Analyzer)**: 分词器负责将文本分割成独立的搜索词(Token),不同的语言可能需要不同的分词策略。 5. **查询解析(Query Parsing)**: 用户输入的查询字符串被解析成 Lucene 可理解的查询对象,可以...

    lucene 2.0 api以及lucene 3.0 api

    4. **分析器(Analyzer)**: Lucene 2.0 提供了多种预定义的分析器,如 `StandardAnalyzer`,处理文本分词、大小写转换等预处理工作。 5. **内存索引与磁盘索引**: `RAMDirectory` 用于内存中的索引,而 `FSDirectory...

    lucene 3.0 中的demo项目部署

    Lucene的核心组件包括Analyzer(分析器)、IndexWriter(索引写入器)、IndexReader(索引读取器)和Searcher(搜索器)。Analyzer负责将文本分解为可搜索的词项,IndexWriter则用于创建和更新索引,IndexReader用于...

    Lucene3.0做的文件搜索

    3.0版本中,预设了多种分析器,如StandardAnalyzer、SimpleAnalyzer和StopAnalyzer等,适用于不同语言和应用场景。用户还可以根据需求自定义分析器,例如,创建一个不区分大小写的分析器,或者去除特定停用词的分析...

    lucene 3.0 API 中文帮助文档

    1. **Analyzer**: 分析器是Lucene中的核心组件之一,负责将输入的文本分解成可搜索的词项(tokens)。在3.0版本中,Lucene提供了多种预定义的Analyzer,如StandardAnalyzer,它们可以处理不同语言的文本。 2. **...

    适合lucene3.0用的paoding-analysis的jar包

    同时,为了满足中文分词的需求,Paoding-Analysis应运而生,它是一款专门针对中文的分析器,能够高效准确地进行中文分词,为Lucene的中文搜索提供了强大支持。 Paoding-Analysis是Java开发的开源项目,其核心功能是...

Global site tag (gtag.js) - Google Analytics