lucene实现自定义的评分 - 学习笔记 - 博客频道 - CSDN.NET

Lucene按一个或多个字段进行排序是基本的功能，但可能需要更高级的自定义排序功能，并通过调整得分。Lucene自定义排序调整打分方法，有下面几种：

1、在索引阶段设置Document Boost和Field Boost，提升文档或字段的排名，例如：

Document doc1 = new Document();
Field f1 = new Field("contents", "common hello hello", Field.Store.NO, Field.Index.ANALYZED);
doc1.add(f1);
doc1.setBoost(100);
writer.addDocument(doc1);

Document doc1 = new Document();
Field f1 = new Field("title", "common hello hello", Field.Store.NO, Field.Index.ANALYZED);
f1.setBoost(100);
doc1.add(f1);
writer.addDocument(doc1);

2、通过继承并实现自己的Similarity，覆盖方法float scorePayload(int docId, String fieldName, int start, int end, byte [] payload, int offset, int length)

class PayloadSimilarity extends DefaultSimilarity {

@Override
public float scorePayload(int docId, String fieldName, int start, int end, byte[] payload, int offset, int length) {
    int isbold = BoldFilter.bytes2int(payload);
    if(isbold == BoldFilter.IS_BOLD){
      System.out.println("It is a bold char.");
      return 10;
    } else {
      System.out.println("It is not a bold char.");
      return 1;
    }
}
}

3、继承并实现自己的collector

4、继承并实现自定义CustomScoreProvider和CustomScoreQuery，对评分进行干预，影响排名排序，例如：

[java]view plaincopy 
package util;  
  
import java.io.IOException;  
import org.apache.lucene.index.IndexReader;  
import org.apache.lucene.index.Term;  
import org.apache.lucene.search.IndexSearcher;  
import org.apache.lucene.search.Query;  
import org.apache.lucene.search.TermQuery;  
import org.apache.lucene.search.TopDocs;  
import org.apache.lucene.search.function.CustomScoreProvider;  
import org.apache.lucene.search.function.CustomScoreQuery;  
import org.apache.lucene.search.function.FieldScoreQuery;  
import org.apache.lucene.search.function.ValueSourceQuery;  
import org.apache.lucene.search.function.FieldScoreQuery.Type;  
  
public class MyScoreQuery1{  
      
    public void searchByScoreQuery() throws Exception{  
        IndexSearcher searcher = DocUtil.getSearcher();  
        Query query = new TermQuery(new Term("content","java"));  
          
        //1、创建评分域，如果Type是String类型，那么是Type.BYTE  
        //该域必须是数值型的，并且不能使用norms索引，以及每个文档中该域只能由一个语汇  
        //单元，通常可用Field.Index.not_analyzer_no_norms来进行创建索引  
        FieldScoreQuery fieldScoreQuery = new FieldScoreQuery("size",Type.INT);  
        //2、根据评分域和原有的Query创建自定义的Query对象  
        //query是原有的query，fieldScoreQuery是专门做评分的query  
        MyCustomScoreQuery customQuery = new MyCustomScoreQuery(query, fieldScoreQuery);  
          
        TopDocs topdoc = searcher.search(customQuery, 100);  
        DocUtil.printDocument(topdoc, searcher);  
        searcher.close();  
          
    }  
      
    @SuppressWarnings("serial")  
    private class MyCustomScoreQuery extends CustomScoreQuery{  
  
        public MyCustomScoreQuery(Query subQuery, ValueSourceQuery valSrcQuery) {  
            super(subQuery, valSrcQuery);  
        }  
          
        /** 
         * 这里的reader是针对段的，意思是如果索引包含的段不止一个，那么搜索期间会多次调用 
         * 这个方法，强调这点是重要的，因为它使你的评分逻辑能够有效使用段reader来对域缓存 
         * 中的值进行检索 
         */  
        @Override  
        protected CustomScoreProvider getCustomScoreProvider(IndexReader reader)  
                throws IOException {  
            //默认情况实现的评分是通过原有的评分*传入进来的评分域所获取的评分来确定最终打分的  
            //为了根据不同的需求进行评分，需要自己进行评分的设定  
            /** 
             * 自定评分的步骤 
             * 创建一个类继承于CustomScoreProvider 
             * 覆盖customScore方法 
             */  
//          return super.getCustomScoreProvider(reader);  
            return new MyCustomScoreProvider(reader);  
        }  
          
          
    }  
      
    private class MyCustomScoreProvider extends CustomScoreProvider{  
  
        public MyCustomScoreProvider(IndexReader reader) {  
            super(reader);  
        }  
          
        /** 
         * subQueryScore表示默认文档的打分 
         * valSrcScore表示的评分域的打分 
         * 默认是subQueryScore*valSrcScore返回的 
         */  
        @Override  
        public float customScore(int doc, float subQueryScore, float valSrcScore)throws IOException {  
            System.out.println("Doc:"+doc);  
            System.out.println("subQueryScore:"+subQueryScore);  
            System.out.println("valSrcScore:"+valSrcScore);  
//          return super.customScore(doc, subQueryScore, valSrcScore);  
            return subQueryScore / valSrcScore;  
        }  
          
    }  
}  

根据特定的几个文件名来评分，选中的文件名权重变大

[java]view plaincopy 
package util;  
  
import java.io.IOException;  
import org.apache.lucene.index.IndexReader;  
import org.apache.lucene.index.Term;  
import org.apache.lucene.search.FieldCache;  
import org.apache.lucene.search.IndexSearcher;  
import org.apache.lucene.search.Query;  
import org.apache.lucene.search.TermQuery;  
import org.apache.lucene.search.TopDocs;  
import org.apache.lucene.search.function.CustomScoreProvider;  
import org.apache.lucene.search.function.CustomScoreQuery;  
/** 
 * 此类的功能是给特定的文件名加权，也就是加评分 
 * 也可以实现搜索书籍的时候把近一两年的出版的图书给增加权重 
 * @author user 
 */  
public class MyScoreQuery2 {  
    public void searchByFileScoreQuery() throws Exception{  
        IndexSearcher searcher = DocUtil.getSearcher();  
        Query query = new TermQuery(new Term("content","java"));  
          
        FilenameScoreQuery fieldScoreQuery = new FilenameScoreQuery(query);  
          
        TopDocs topdoc = searcher.search(fieldScoreQuery, 100);  
        DocUtil.printDocument(topdoc, searcher);  
        searcher.close();  
          
    }  
      
    @SuppressWarnings("serial")  
    private class FilenameScoreQuery extends CustomScoreQuery{  
  
        public FilenameScoreQuery(Query subQuery) {  
            super(subQuery);  
        }  
  
        @Override  
        protected CustomScoreProvider getCustomScoreProvider(IndexReader reader)  
                throws IOException {  
//          return super.getCustomScoreProvider(reader);  
            return new FilenameScoreProvider(reader);  
        }  
    }  
      
    private class FilenameScoreProvider extends CustomScoreProvider{  
        String[] filenames = null;  
        public FilenameScoreProvider(IndexReader reader) {  
            super(reader);  
            try {  
                filenames = FieldCache.DEFAULT.getStrings(reader, "filename");  
            } catch (IOException e) {e.printStackTrace();}  
        }  
  
        //如何根据doc获取相应的field的值  
        /* 
         * 在reader没有关闭之前，所有的数据会存储要一个域缓存中，可以通过域缓存获取很多有用 
         * 的信息filenames = FieldCache.DEFAULT.getStrings(reader, "filename");可以获取 
         * 所有的filename域的信息 
         */  
        @Override  
        public float customScore(int doc, float subQueryScore, float valSrcScore)  
                throws IOException {  
            String fileName = filenames[doc];  
            System.out.println(doc+":"+fileName);  
//          return super.customScore(doc, subQueryScore, valSrcScore);  
            if("9.txt".equals(fileName) || "4.txt".equals(fileName)) {  
                return subQueryScore*1.5f;  
            }  
            return subQueryScore/1.5f;  
        }  
          
    }  
}  
 

阅读全文……

标签 : database, java, lucene

发表评论

IT瘾于2015年3月11日下午01时34分00秒发布 #

Lucene索引阶段设置Document Boost和Field Boost 实现合理打分 - 漫步天涯-IT - 博客频道 - CSDN.NET

在索引阶段设置Document Boost和Field Boost，存储在(.nrm)文件中。

如果希望某些文档和某些域比其他的域更重要，如果此文档和此域包含所要查询的词则应该得分较高，则可以在索引阶段设定文档的boost和域的boost值。

这些值是在索引阶段就写入索引文件的，存储在标准化因子(.nrm)文件中，一旦设定，除非删除此文档，否则无法改变。

如果不进行设定，则Document Boost和Field Boost默认为1。

Document Boost及FieldBoost的设定方式如下：

Document doc = new Document();

Field f = new Field("contents", "hello world", Field.Store.NO, Field.Index.ANALYZED);

f.setBoost(100);

doc.add(f);

doc.setBoost(100);

两者是如何影响Lucene的文档打分的呢？

让我们首先来看一下Lucene的文档打分的公式：

score(q,d) = coord(q,d) · queryNorm(q) · ∑( tf(t in d) · idf(t)² · t.getBoost() · norm(t,d) )

t in q

Document Boost和Field Boost影响的是norm(t, d)，其公式如下：

norm(t,d) = doc.getBoost() · lengthNorm(field) · ∏f.getBoost()

field f in d named as t

它包括三个参数：

Document boost：此值越大，说明此文档越重要。
Field boost：此域越大，说明此域越重要。
lengthNorm(field) = (1.0 / Math.sqrt(numTerms))：一个域中包含的Term总数越多，也即文档越长，此值越小，文档越短，此值越大。

其中第三个参数可以在自己的Similarity中影响打分，下面会论述。

当然，也可以在添加Field的时候，设置Field.Index.ANALYZED_NO_NORMS或Field.Index.NOT_ANALYZED_NO_NORMS，完全不用norm，来节约空间。

根据Lucene的注释，No norms means that index-time field and document boosting and field length normalization are disabled. The benefit is less memory usage as norms take up one byte of RAM per indexed field for every document in the index, during searching. Note that once you index a given field with norms enabled, disabling norms will have no effect. 没有norms意味着索引阶段禁用了文档boost和域的boost及长度标准化。好处在于节省内存，不用在搜索阶段为索引中的每篇文档的每个域都占用一个字节来保存norms信息了。但是对norms信息的禁用是必须全部域都禁用的，一旦有一个域不禁用，则其他禁用的域也会存放默认的norms值。因为为了加快norms的搜索速度，Lucene是根据文档号乘以每篇文档的norms信息所占用的大小来计算偏移量的，中间少一篇文档，偏移量将无法计算。也即norms信息要么都保存，要么都不保存。

下面几个试验可以验证norms信息的作用：

试验一：Document Boost的作用

public void testNormsDocBoost() throws Exception {
File indexDir = new File("testNormsDocBoost");
IndexWriter writer = new IndexWriter(FSDirectory.open(indexDir), new StandardAnalyzer(Version.LUCENE_CURRENT), true, IndexWriter.MaxFieldLength.LIMITED);
writer.setUseCompoundFile(false);
Document doc1 = new Document();
Field f1 = new Field("contents", "common hello hello", Field.Store.NO, Field.Index.ANALYZED);
doc1.add(f1);
doc1.setBoost(100);
writer.addDocument(doc1);
Document doc2 = new Document();
Field f2 = new Field("contents", "common common hello", Field.Store.NO, Field.Index.ANALYZED_NO_NORMS);
doc2.add(f2);
writer.addDocument(doc2);
Document doc3 = new Document();
Field f3 = new Field("contents", "common common common", Field.Store.NO, Field.Index.ANALYZED_NO_NORMS);
doc3.add(f3);
writer.addDocument(doc3);
writer.close();

IndexReader reader = IndexReader.open(FSDirectory.open(indexDir));
IndexSearcher searcher = new IndexSearcher(reader);
TopDocs docs = searcher.search(new TermQuery(new Term("contents", "common")), 10);
for (ScoreDoc doc : docs.scoreDocs) {
System.out.println("docid : " + doc.doc + " score : " + doc.score);
}
}

如果第一篇文档的域f1也为Field.Index.ANALYZED_NO_NORMS的时候，搜索排名如下：

docid : 2 score : 1.2337708
docid : 1 score : 1.0073696
docid : 0 score : 0.71231794

如果第一篇文档的域f1设为Field.Index.ANALYZED，则搜索排名如下：

docid : 0 score : 39.889805
docid : 2 score : 0.6168854
docid : 1 score : 0.5036848

试验二：Field Boost的作用

如果我们觉得title要比contents要重要，可以做一下设定。

public void testNormsFieldBoost() throws Exception {
File indexDir = new File("testNormsFieldBoost");
IndexWriter writer = new IndexWriter(FSDirectory.open(indexDir), new StandardAnalyzer(Version.LUCENE_CURRENT), true, IndexWriter.MaxFieldLength.LIMITED);
writer.setUseCompoundFile(false);
Document doc1 = new Document();
Field f1 = new Field("title", "common hello hello", Field.Store.NO, Field.Index.ANALYZED);
f1.setBoost(100);
doc1.add(f1);
writer.addDocument(doc1);
Document doc2 = new Document();
Field f2 = new Field("contents", "common common hello", Field.Store.NO, Field.Index.ANALYZED_NO_NORMS);
doc2.add(f2);
writer.addDocument(doc2);
writer.close();

IndexReader reader = IndexReader.open(FSDirectory.open(indexDir));
IndexSearcher searcher = new IndexSearcher(reader);
QueryParser parser = new QueryParser(Version.LUCENE_CURRENT, "contents", new StandardAnalyzer(Version.LUCENE_CURRENT));
Query query = parser.parse("title:common contents:common");
TopDocs docs = searcher.search(query, 10);
for (ScoreDoc doc : docs.scoreDocs) {
System.out.println("docid : " + doc.doc + " score : " + doc.score);
}
}

如果第一篇文档的域f1也为Field.Index.ANALYZED_NO_NORMS的时候，搜索排名如下：

docid : 1 score : 0.49999997
docid : 0 score : 0.35355338

如果第一篇文档的域f1设为Field.Index.ANALYZED，则搜索排名如下：

docid : 0 score : 19.79899
docid : 1 score : 0.49999997

试验三：norms中文档长度对打分的影响

public void testNormsLength() throws Exception {
File indexDir = new File("testNormsLength");
IndexWriter writer = new IndexWriter(FSDirectory.open(indexDir), new StandardAnalyzer(Version.LUCENE_CURRENT), true, IndexWriter.MaxFieldLength.LIMITED);
writer.setUseCompoundFile(false);
Document doc1 = new Document();
Field f1 = new Field("contents", "common hello hello", Field.Store.NO, Field.Index.ANALYZED_NO_NORMS);
doc1.add(f1);
writer.addDocument(doc1);
Document doc2 = new Document();
Field f2 = new Field("contents", "common common hello hello hello hello", Field.Store.NO, Field.Index.ANALYZED_NO_NORMS);
doc2.add(f2);
writer.addDocument(doc2);
writer.close();

当norms被禁用的时候，包含两个common的第二篇文档打分较高：

docid : 1 score : 0.13928263
docid : 0 score : 0.09848769

当norms起作用的时候，虽然包含两个common的第二篇文档，由于长度较长，因而打分较低：

docid : 0 score : 0.09848769
docid : 1 score : 0.052230984

试验四：norms信息要么都保存，要么都不保存的特性

public void testOmitNorms() throws Exception {
File indexDir = new File("testOmitNorms");
IndexWriter writer = new IndexWriter(FSDirectory.open(indexDir), new StandardAnalyzer(Version.LUCENE_CURRENT), true, IndexWriter.MaxFieldLength.LIMITED);
writer.setUseCompoundFile(false);
Document doc1 = new Document();
Field f1 = new Field("title", "common hello hello", Field.Store.NO, Field.Index.ANALYZED);
doc1.add(f1);
writer.addDocument(doc1);
for (int i = 0; i < 10000; i++) {
 Document doc2 = new Document();
 Field f2 = new Field("contents", "common common hello hello hello hello", Field.Store.NO, Field.Index.ANALYZED_NO_NORMS);
 doc2.add(f2);
 writer.addDocument(doc2);
}
writer.close();
}

当我们添加10001篇文档，所有的文档都设为Field.Index.ANALYZED_NO_NORMS的时候，我们看索引文件，发现.nrm文件只有1K，也即其中除了保持一定的格式信息，并无其他数据。

当我们把第一篇文档设为Field.Index.ANALYZED，而其他10000篇文档都设为Field.Index.ANALYZED_NO_NORMS的时候，发现.nrm文件又10K，也即所有的文档都存储了norms信息，而非只有第一篇文档。

在搜索语句中，设置Query Boost.

在搜索中，我们可以指定，某些词对我们来说更重要，我们可以设置这个词的boost：

common^4 hello

使得包含common的文档比包含hello的文档获得更高的分数。

由于在Lucene中，一个Term定义为Field:Term，则也可以影响不同域的打分：

title:common^4 content:common

使得title中包含common的文档比content中包含common的文档获得更高的分数。

实例：

public void testQueryBoost() throws Exception {
File indexDir = new File("TestQueryBoost");
IndexWriter writer = new IndexWriter(FSDirectory.open(indexDir), new StandardAnalyzer(Version.LUCENE_CURRENT), true, IndexWriter.MaxFieldLength.LIMITED);
Document doc1 = new Document();
Field f1 = new Field("contents", "common1 hello hello", Field.Store.NO, Field.Index.ANALYZED);
doc1.add(f1);
writer.addDocument(doc1);
Document doc2 = new Document();
Field f2 = new Field("contents", "common2 common2 hello", Field.Store.NO, Field.Index.ANALYZED);
doc2.add(f2);
writer.addDocument(doc2);
writer.close();

IndexReader reader = IndexReader.open(FSDirectory.open(indexDir));
IndexSearcher searcher = new IndexSearcher(reader);
QueryParser parser = new QueryParser(Version.LUCENE_CURRENT, "contents", new StandardAnalyzer(Version.LUCENE_CURRENT));
Query query = parser.parse("common1 common2");
TopDocs docs = searcher.search(query, 10);
for (ScoreDoc doc : docs.scoreDocs) {
System.out.println("docid : " + doc.doc + " score : " + doc.score);
}
}

根据tf/idf，包含两个common2的第二篇文档打分较高：

docid : 1 score : 0.24999999
docid : 0 score : 0.17677669

如果我们输入的查询语句为："common1^100 common2"，则第一篇文档打分较高：

docid : 0 score : 0.2499875
docid : 1 score : 0.0035353568

那Query Boost是如何影响文档打分的呢？

根据Lucene的打分计算公式：

score(q,d) = coord(q,d) · queryNorm(q) · ∑( tf(t in d) · idf(t)² · t.getBoost() · norm(t,d) )

t in q

注：在queryNorm的部分，也有q.getBoost()的部分，但是对query向量的归一化(见向量空间模型与Lucene的打分机制[http://forfuture1978.javaeye.com/blog/588721])。

继承并实现自己的Similarity

Similariy是计算Lucene打分的最主要的类，实现其中的很多借口可以干预打分的过程。

(1) float computeNorm(String field, FieldInvertState state)

(2) float lengthNorm(String fieldName, int numTokens)

(3) float queryNorm(float sumOfSquaredWeights)

(4) float tf(float freq)

(5) float idf(int docFreq, int numDocs)

(6) float coord(int overlap, int maxOverlap)

(7) float scorePayload(int docId, String fieldName, int start, int end, byte [] payload, int offset, int length)

它们分别影响Lucene打分计算的如下部分：

score(q,d) = (6)coord(q,d) · (3)queryNorm(q) · ∑( (4)tf(t in d) · (5)idf(t)² · t.getBoost() · (1)norm(t,d) )

t in q

norm(t,d) = doc.getBoost() · (2)lengthNorm(field) · ∏f.getBoost()

field f in d named as t

下面逐个进行解释：

(1) float computeNorm(String field, FieldInvertState state)

影响标准化因子的计算，如上述，他主要包含了三部分：文档boost，域boost，以及文档长度归一化。此函数一般按照上面norm(t, d)的公式进行计算。

(2) float lengthNorm(String fieldName, int numTokens)

主要计算文档长度的归一化，默认是1.0 / Math.sqrt(numTerms)。

因为在索引中，不同的文档长度不一样，很显然，对于任意一个term，在长的文档中的tf要大的多，因而分数也越高，这样对小的文档不公平，举一个极端的例子，在一篇1000万个词的鸿篇巨著中，"lucene"这个词出现了11次，而在一篇12个词的短小文档中，"lucene"这个词出现了10次，如果不考虑长度在内，当然鸿篇巨著应该分数更高，然而显然这篇小文档才是真正关注"lucene"的。

因而在此处是要除以文档的长度，从而减少因文档长度带来的打分不公。

然而现在这个公式是偏向于首先返回短小的文档的，这样在实际应用中使得搜索结果也很难看。

于是在实践中，要根据项目的需要，根据搜索的领域，改写lengthNorm的计算公式。比如我想做一个经济学论文的搜索系统，经过一定时间的调研，发现大多数的经济学论文的长度在8000到10000词，因而lengthNorm的公式应该是一个倒抛物线型的，8000到10000词的论文分数最高，更短或更长的分数都应该偏低，方能够返回给用户最好的数据。

(3) float queryNorm(float sumOfSquaredWeights)

这是按照向量空间模型，对query向量的归一化。此值并不影响排序，而仅仅使得不同的query之间的分数可以比较。

(4) float tf(float freq)

freq是指在一篇文档中包含的某个词的数目。tf是根据此数目给出的分数，默认为Math.sqrt(freq)。也即此项并不是随着包含的数目的增多而线性增加的。

(5) float idf(int docFreq, int numDocs)

idf是根据包含某个词的文档数以及总文档数计算出的分数，默认为(Math.log(numDocs/(double)(docFreq+1)) + 1.0)。

由于此项计算涉及到总文档数和包含此词的文档数，因而需要全局的文档数信息，这给跨索引搜索造成麻烦。

从下面的例子我们可以看出，用MultiSearcher来一起搜索两个索引和分别用IndexSearcher来搜索两个索引所得出的分数是有很大差异的。

究其原因是MultiSearcher的docFreq(Term term)函数计算了包含两个索引中包含此词的总文档数，而IndexSearcher仅仅计算了每个索引中包含此词的文档数。当两个索引包含的文档总数是有很大不同的时候，分数是无法比较的。

public void testMultiIndex() throws Exception{
MultiIndexSimilarity sim = new MultiIndexSimilarity();
File indexDir01 = new File("TestMultiIndex/TestMultiIndex01");
File indexDir02 = new File("TestMultiIndex/TestMultiIndex02");
IndexReader reader01 = IndexReader.open(FSDirectory.open(indexDir01));
IndexReader reader02 = IndexReader.open(FSDirectory.open(indexDir02));
IndexSearcher searcher01 = new IndexSearcher(reader01);
searcher01.setSimilarity(sim);
IndexSearcher searcher02 = new IndexSearcher(reader02);
searcher02.setSimilarity(sim);
MultiSearcher multiseacher = new MultiSearcher(searcher01, searcher02);
multiseacher.setSimilarity(sim);
QueryParser parser = new QueryParser(Version.LUCENE_CURRENT, "contents", new StandardAnalyzer(Version.LUCENE_CURRENT));
Query query = parser.parse("common");
TopDocs docs = searcher01.search(query, 10);
System.out.println("----------------------------------------------");
for (ScoreDoc doc : docs.scoreDocs) {
    System.out.println("docid : " + doc.doc + " score : " + doc.score);
}
System.out.println("----------------------------------------------");
docs = searcher02.search(query, 10);
for (ScoreDoc doc : docs.scoreDocs) {
    System.out.println("docid : " + doc.doc + " score : " + doc.score);
}
System.out.println("----------------------------------------------");
docs = multiseacher.search(query, 20);
for (ScoreDoc doc : docs.scoreDocs) {
    System.out.println("docid : " + doc.doc + " score : " + doc.score);
}

结果为：

-------------------------------
docid : 0 score : 0.49317428
docid : 1 score : 0.49317428
docid : 2 score : 0.49317428
docid : 3 score : 0.49317428
docid : 4 score : 0.49317428
docid : 5 score : 0.49317428
docid : 6 score : 0.49317428
docid : 7 score : 0.49317428
-------------------------------
docid : 0 score : 0.45709616
docid : 1 score : 0.45709616
docid : 2 score : 0.45709616
docid : 3 score : 0.45709616
docid : 4 score : 0.45709616
-------------------------------
docid : 0 score : 0.5175894
docid : 1 score : 0.5175894
docid : 2 score : 0.5175894
docid : 3 score : 0.5175894
docid : 4 score : 0.5175894
docid : 5 score : 0.5175894
docid : 6 score : 0.5175894
docid : 7 score : 0.5175894
docid : 8 score : 0.5175894
docid : 9 score : 0.5175894
docid : 10 score : 0.5175894
docid : 11 score : 0.5175894
docid : 12 score : 0.5175894

如果几个索引都是在一台机器上，则用MultiSearcher或者MultiReader就解决问题了，然而有时候索引是分布在多台机器上的，虽然Lucene也提供了RMI，或用NFS保存索引的方法，然而效率和并行性一直是一个问题。

一个可以尝试的办法是在Similarity中，idf返回1，然后多个机器上的索引并行搜索，在汇总结果的机器上，再融入idf的计算。

如下面的例子可以看出，当idf返回1的时候，打分可以比较了：

class MultiIndexSimilarity extends Similarity {

@Override
public float idf(int docFreq, int numDocs) {
return 1.0f;
}

-----------------------------
docid : 0 score : 0.559017
docid : 1 score : 0.559017
docid : 2 score : 0.559017
docid : 3 score : 0.559017
docid : 4 score : 0.559017
docid : 5 score : 0.559017
docid : 6 score : 0.559017
docid : 7 score : 0.559017
-----------------------------
docid : 0 score : 0.559017
docid : 1 score : 0.559017
docid : 2 score : 0.559017
docid : 3 score : 0.559017
docid : 4 score : 0.559017
-----------------------------
docid : 0 score : 0.559017
docid : 1 score : 0.559017
docid : 2 score : 0.559017
docid : 3 score : 0.559017
docid : 4 score : 0.559017
docid : 5 score : 0.559017
docid : 6 score : 0.559017
docid : 7 score : 0.559017
docid : 8 score : 0.559017
docid : 9 score : 0.559017
docid : 10 score : 0.559017
docid : 11 score : 0.559017
docid : 12 score : 0.559017

(6) float coord(int overlap, int maxOverlap)

一次搜索可能包含多个搜索词，而一篇文档中也可能包含多个搜索词，此项表示，当一篇文档中包含的搜索词越多，则此文档则打分越高。

public void TestCoord() throws Exception {
MySimilarity sim = new MySimilarity();
File indexDir = new File("TestCoord");
IndexWriter writer = new IndexWriter(FSDirectory.open(indexDir), new StandardAnalyzer(Version.LUCENE_CURRENT), true, IndexWriter.MaxFieldLength.LIMITED);
Document doc1 = new Document();
Field f1 = new Field("contents", "common hello world", Field.Store.NO, Field.Index.ANALYZED);
doc1.add(f1);
writer.addDocument(doc1);
Document doc2 = new Document();
Field f2 = new Field("contents", "common common common", Field.Store.NO, Field.Index.ANALYZED);
doc2.add(f2);
writer.addDocument(doc2);
for(int i = 0; i < 10; i++){
 Document doc3 = new Document();
 Field f3 = new Field("contents", "world", Field.Store.NO, Field.Index.ANALYZED);
 doc3.add(f3);
 writer.addDocument(doc3);
}
writer.close();

IndexReader reader = IndexReader.open(FSDirectory.open(indexDir));
IndexSearcher searcher = new IndexSearcher(reader);
searcher.setSimilarity(sim);
QueryParser parser = new QueryParser(Version.LUCENE_CURRENT, "contents", new StandardAnalyzer(Version.LUCENE_CURRENT));
Query query = parser.parse("common world");
TopDocs docs = searcher.search(query, 2);
for (ScoreDoc doc : docs.scoreDocs) {
System.out.println("docid : " + doc.doc + " score : " + doc.score);
}
}

class MySimilarity extends Similarity {

@Override
public float coord(int overlap, int maxOverlap) {
return 1;
}

}

如上面的实例，当coord返回1，不起作用的时候，文档一虽然包含了两个搜索词common和world，但由于world的所在的文档数太多，而文档二包含common的次数比较多，因而文档二分数较高：

docid : 1 score : 1.9059997
docid : 0 score : 1.2936771

而当coord起作用的时候，文档一由于包含了两个搜索词而分数较高：

class MySimilarity extends Similarity {

@Override
public float coord(int overlap, int maxOverlap) {
return overlap / (float)maxOverlap;
}

}

docid : 0 score : 1.2936771
docid : 1 score : 0.95299983

(7) float scorePayload(int docId, String fieldName, int start, int end, byte [] payload, int offset, int length)

由于Lucene引入了payload，因而可以存储一些自己的信息，用户可以根据自己存储的信息，来影响Lucene的打分。

由payload的定义我们知道，索引是以倒排表形式存储的，对于每一个词，都保存了包含这个词的一个链表，当然为了加快查询速度，此链表多用跳跃表进行存储。Payload信息就是存储在倒排表中的，同文档号一起存放，多用于存储与每篇文档相关的一些信息。当然这部分信息也可以存储域里(stored Field)，两者从功能上基本是一样的，然而当要存储的信息很多的时候，存放在倒排表里，利用跳跃表，有利于大大提高搜索速度。

Payload的存储方式如下图：

由payload的定义，我们可以看出，payload可以存储一些不但与文档相关，而且与查询词也相关的信息。比如某篇文档的某个词有特殊性，则可以在这个词的这个文档的position信息后存储payload信息，使得当搜索这个词的时候，这篇文档获得较高的分数。

要利用payload来影响查询需要做到以下几点，下面举例用标记的词在payload中存储1，否则存储0：

首先要实现自己的Analyzer从而在Token中放入payload信息：

class BoldAnalyzer extends Analyzer {

@Override
public TokenStream tokenStream(String fieldName, Reader reader) {
    TokenStream result = new WhitespaceTokenizer(reader);
    result = new BoldFilter(result);
    return result;
}

}

class BoldFilter extends TokenFilter {
public static int IS_NOT_BOLD = 0;
public static int IS_BOLD = 1;

private TermAttribute termAtt;
private PayloadAttribute payloadAtt;

protected BoldFilter(TokenStream input) {
    super(input);
    termAtt = addAttribute(TermAttribute.class);
    payloadAtt = addAttribute(PayloadAttribute.class);
}

@Override
public boolean incrementToken() throws IOException {
if (input.incrementToken()) {

final char[] buffer = termAtt.termBuffer();
final int length = termAtt.termLength();

String tokenstring = new String(buffer, 0, length);
 if (tokenstring.startsWith("") && tokenstring.endsWith("")) {
 tokenstring = tokenstring.replace("", "");
 tokenstring = tokenstring.replace("", "");
 termAtt.setTermBuffer(tokenstring);
 payloadAtt.setPayload(new Payload(int2bytes(IS_BOLD)));
 } else {
 payloadAtt.setPayload(new Payload(int2bytes(IS_NOT_BOLD)));
 }
 return true;
 } else
 return false;
}

public static int bytes2int(byte[] b) {
 int mask = 0xff;
 int temp = 0;
 int res = 0;
 for (int i = 0; i < 4; i++) {
 res <<= 8;
 temp = b[i] & mask;
 res |= temp;
 }
 return res;
}

public static byte[] int2bytes(int num) {
 byte[] b = new byte[4];
 for (int i = 0; i < 4; i++) {
 b[i] = (byte) (num >>> (24 - i * 8));
 }
 return b;
}

}

然后，实现自己的Similarity，从payload中读出信息，根据信息来打分。

class PayloadSimilarity extends DefaultSimilarity {

@Override
public float scorePayload(int docId, String fieldName, int start, int end, byte[] payload, int offset, int length) {
    int isbold = BoldFilter.bytes2int(payload);
    if(isbold == BoldFilter.IS_BOLD){
      System.out.println("It is a bold char.");
    } else {
      System.out.println("It is not a bold char.");
    }
    return 1;
}
}

最后，查询的时候，一定要用PayloadXXXQuery(在此用PayloadTermQuery，在Lucene 2.4.1中，用BoostingTermQuery)，否则scorePayload不起作用。

public void testPayloadScore() throws Exception {
PayloadSimilarity sim = new PayloadSimilarity();
File indexDir = new File("TestPayloadScore");
IndexWriter writer = new IndexWriter(FSDirectory.open(indexDir), new BoldAnalyzer(), true, IndexWriter.MaxFieldLength.LIMITED);
Document doc1 = new Document();
Field f1 = new Field("contents", "common hello world", Field.Store.NO, Field.Index.ANALYZED);
doc1.add(f1);
writer.addDocument(doc1);
Document doc2 = new Document();
Field f2 = new Field("contents", "common hello world", Field.Store.NO, Field.Index.ANALYZED);
doc2.add(f2);
writer.addDocument(doc2);
writer.close();

IndexReader reader = IndexReader.open(FSDirectory.open(indexDir));
IndexSearcher searcher = new IndexSearcher(reader);
searcher.setSimilarity(sim);
PayloadTermQuery query = new PayloadTermQuery(new Term("contents", "hello"), new MaxPayloadFunction());
TopDocs docs = searcher.search(query, 10);
for (ScoreDoc doc : docs.scoreDocs) {
System.out.println("docid : " + doc.doc + " score : " + doc.score);
}
}

如果scorePayload函数始终是返回1，则结果如下，不起作用。

It is not a bold char.
It is a bold char.
docid : 0 score : 0.2101998
docid : 1 score : 0.2101998

如果scorePayload函数如下：

class PayloadSimilarity extends DefaultSimilarity {

则结果如下，同样是包含hello，包含加粗的文档获得较高分：

It is not a bold char.
It is a bold char.
docid : 1 score : 2.101998
docid : 0 score : 0.2101998

继承并实现自己的collector

以上各种方法，已经把Lucene score计算公式的所有变量都涉及了，如果这还不能满足您的要求，还可以继承实现自己的collector。

在Lucene 2.4中，HitCollector有个函数public abstract void collect(int doc, float score)，用来收集搜索的结果。

其中TopDocCollector的实现如下：

public void collect(int doc, float score) {
if (score > 0.0f) {
    totalHits++;
    if (reusableSD == null) {
      reusableSD = new ScoreDoc(doc, score);
    } else if (score >= reusableSD.score) {
      reusableSD.doc = doc;
      reusableSD.score = score;
    } else {
      return;
    }
    reusableSD = (ScoreDoc) hq.insertWithOverflow(reusableSD);
}
}

此函数将docid和score插入一个PriorityQueue中，使得得分最高的文档先返回。

我们可以继承HitCollector，并在此函数中对score进行修改，然后再插入PriorityQueue，或者插入自己的数据结构。

比如我们在另外的地方存储docid和文档创建时间的对应，我们希望当文档时间是一天之内的分数最高，一周之内的分数其次，一个月之外的分数很低。

我们可以这样修改：

public static long milisecondsOneDay = 24L * 3600L * 1000L;

public static long millisecondsOneWeek = 7L * 24L * 3600L * 1000L;

public static long millisecondsOneMonth = 30L * 24L * 3600L * 1000L;

public void collect(int doc, float score) {
if (score > 0.0f) {

long time = getTimeByDocId(doc);

if(time < milisecondsOneDay) {

score = score * 1.0;

} else if (time < millisecondsOneWeek){

score = score * 0.8;

} else if (time < millisecondsOneMonth) {

score = score * 0.3;

} else {

score = score * 0.1;

}

    totalHits++;
    if (reusableSD == null) {
      reusableSD = new ScoreDoc(doc, score);
    } else if (score >= reusableSD.score) {
      reusableSD.doc = doc;
      reusableSD.score = score;
    } else {
      return;
    }
    reusableSD = (ScoreDoc) hq.insertWithOverflow(reusableSD);
}
}

在Lucene 3.0中，Collector接口为void collect(int doc)，TopScoreDocCollector实现如下：

public void collect(int doc) throws IOException {
float score = scorer.score();
totalHits++;
if (score <= pqTop.score) {
return;
}
pqTop.doc = doc + docBase;
pqTop.score = score;
pqTop = pq.updateTop();
}

同样可以用上面的方式影响其打分。

阅读全文……

标签 : database, java, lucene

发表评论

IT瘾于2015年3月10日下午03时48分00秒发布 #

lucene FieldCache 实现分组统计 - 记录我的点点滴滴 - 51CTO技术博客

所谓分组统计，就是类似sql里group by的功能。在solr里，这个功能称为faceting。lucene本身不支持分组统计，不过可以使用fieldCache来实现分组统计功能，而且也有很好的性能。solr根据不同的情况，还提供了其他方法（filterCache和UnInvertedField)来实现，这个以后再说。
fieldCache是lucene用来排序的缓存。对要用来排序的字段，lucene会从索引中将每篇文档该字段的值都读出来，放到一个大小为maxDoc的数组中。maxDoc是lucene内部文档编号的最大值。有两点需要注意一下：

fieldCache中的字段值是从倒排表中读出来的，而不是从索引文件中存储的字段值，所以排序的字段必须是为设为索引字段
用来排序的字段在索引的时候不能拆分（tokenized），因为fieldCache数组中，每个文档只对应一个字段值，拆分的话，cache中只会保存在词典中靠后的值。

fieldcache是lucene最占用的内存的部分，大部分内存溢出的错误都是由它而起，需要特别注意。

分组统计可以借用fieldCache来高效率的实现。调用lucene进行查询，通过读取倒排表并进行boolean运算，得到一个满足条件的文档的集合。通过每个结果文档号读取fieldCache数组中的值，并分不同的值累加数目，即可实现分组统计的功能。其中，如果某个字段对应多值，则在索引的时候不拆分，从filedCache数组读出后，再进行拆分统计。
好了，说了半天，现在来看看实现代码：Test.java
import java.io.IOException;
import java.util.List;
import jeasy.analysis.MMAnalyzer;
import org.apache.lucene.analysis.PerFieldAnalyzerWrapper;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;
import org.apache.lucene.document.Field.Index;
import org.apache.lucene.document.Field.Store;
import org.apache.lucene.index.CorruptIndexException;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.index.IndexWriter.MaxFieldLength;
import org.apache.lucene.queryParser.ParseException;
import org.apache.lucene.search.FieldCache;
import org.apache.lucene.search.HBxx2Similarity;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.MatchAllDocsQuery;
import org.apache.lucene.search.ScoreDoc;
import org.apache.lucene.search.Searcher;
import org.apache.lucene.search.TopDocsCollector;
import org.apache.lucene.search.TopScoreDocCollector;
import org.apache.lucene.store.FSDirectory;
import org.apache.lucene.store.LockObtainFailedException;
import org.apache.lucene.util.Version;

public class Test {

String path = "D:\\index";
Version version = Version.LUCENE_29;

@SuppressWarnings("deprecation")
public void search(int pageNO, int pageSize) throws ParseException {
try {

Long start1 = System.currentTimeMillis();

   int start = (pageNO - 1) * pageSize;
   int topCount = pageSize * pageNO;
   IndexReader reader = IndexReader.open(FSDirectory
     .getDirectory(path));
   Searcher searcher = new IndexSearcher(reader);

   TopDocsCollector collector = TopScoreDocCollector.create(topCount,
     false);
   // 读取"fenlei"字段值，放到fieldCache中
   final String[] fc = FieldCache.DEFAULT.getStrings(reader, "fenlei");
   // GroupCollector是自定义文档收集器，用于实现分组统计
   GroupCollector groupCollector = new GroupCollector(collector, fc);

searcher.search(new MatchAllDocsQuery(), groupCollector);

// GroupField用来保存分组统计的结果
 GroupField gf = groupCollector.getGroupField();
 System.out.println("分组信息");
 List<String> values = gf.getValues();
 for (String value : values) {
 System.out.println(value + "=" + gf.getCountMap().get(value));
 }

   // 搜索结果总数
   int totalHits = collector.getTotalHits();
   System.out.println("总数:" + totalHits);

System.out.println("分页结果");
 // 获取分页后搜索结果
 ScoreDoc[] scoreDocs = collector.topDocs(start, pageSize).scoreDocs;
 for (int i = 0; i < scoreDocs.length; i++) {
 int docId = scoreDocs[i].doc;
 Document doc = reader.document(docId);
 System.out.println("id:" + doc.get("id") + " fenlei:"
 + doc.get("fenlei") + " title:" + doc.get("title"));
 }

Long time = System.currentTimeMillis() - start1;
System.out.println("搜索所用时间为：" + time + "毫秒");

  } catch (IOException e) {
   e.printStackTrace();
  }

}

@SuppressWarnings("deprecation")
public void WriteIndex() throws CorruptIndexException,
LockObtainFailedException, IOException {

Long start = System.currentTimeMillis();

  // 分词器
  PerFieldAnalyzerWrapper analyzer = new PerFieldAnalyzerWrapper(
    new StandardAnalyzer(version));
  analyzer.addAnalyzer("title", new MMAnalyzer());// 中文分词器

  IndexWriter writer = new IndexWriter(FSDirectory.getDirectory(path),
    analyzer, MaxFieldLength.LIMITED);
  writer.setSimilarity(new HBxx2Similarity());
  writer.setMaxBufferedDocs(2048);
  writer.setRAMBufferSizeMB(256);

  int count = 0;
  String title = "中国人民测试数据";
  String fenlei = "分类";

// 开始读取数据创建索引
 int max = 1000000;
 int groupMax = 75000;
 for (int i = 0; i < max; i++) {
 if (i % groupMax == 0) {
 count++;
 System.out.println(i);
 }

Document document = new Document();

   Field idField = new Field("id", Integer.toString(i + 1), Store.YES,
     Index.NOT_ANALYZED);
   Field titleField = new Field("title", title + (i + 1), Store.YES,
     Index.ANALYZED);
   Field fenleiField = new Field("fenlei", fenlei + count, Store.YES,
     Index.NOT_ANALYZED);

   document.add(idField);
   document.add(titleField);
   document.add(fenleiField);

   writer.addDocument(document);
  }
  writer.commit();
  writer.optimize();
  writer.close();

Long time = System.currentTimeMillis() - start;
System.out.println("创建索引所用时间为：" + time + "毫秒");
}

public static void main(String[] args) throws CorruptIndexException,
   IOException, ParseException {
  Test test = new Test();
  // 建立索引
  // test.WriteIndex();
  // 搜索索引
  int pageNO = 100, pageSize = 20;
  test.search(pageNO, pageSize);
}
}

GroupField.java

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
* 用于保存分组统计后每个字段的分组结果
*/
public class GroupField {
/**
* 字段名
*/
private String name;

/**
* 所有可能的分组字段值，排序按每个字段值的文档个数大小排序
*/
private List<String> values = new ArrayList<String>();

/**
* 保存字段值和文档个数的对应关系
*/
private Map<String, Integer> countMap = new HashMap<String, Integer>();

public Map<String, Integer> getCountMap() {
return countMap;
}

public void setCountMap(Map<String, Integer> countMap) {
this.countMap = countMap;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public List<String> getValues() {
Collections.sort(values, new ValueComparator());
return values;
}

public void setValues(List<String> values) {
this.values = values;
}

public void addValue(String value) {
  if (value == null || "".equals(value))
   return;
  // 对于多值的字段，支持按空格拆分
  String[] temp = value.split(" ");
  for (String str : temp) {
   if (countMap.get(str) == null) {
    countMap.put(str, 1);
    values.add(str);
   } else {
    countMap.put(str, countMap.get(str) + 1);
   }
  }
}

class ValueComparator implements Comparator<String> {

public int compare(String value0, String value1) {
 if (countMap.get(value0) > countMap.get(value1)) {
 return -1;
 } else if (countMap.get(value0) < countMap.get(value1)) {
 return 1;
 }
 return 0;
 }
}
}

GroupCollector.java

import java.io.IOException;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.search.Collector;
import org.apache.lucene.search.Scorer;
import org.apache.lucene.search.TopDocsCollector;

public class GroupCollector extends TopDocsCollector {

Collector collector;
int docBase;

private String[] fc; // fieldCache
private GroupField gf = new GroupField();// 保存分组统计结果

GroupCollector(Collector topDocsCollector, String[] fieldCache)
   throws IOException {
  super(null);
  collector = topDocsCollector;
  this.fc = fieldCache;
}

@Override
public void collect(int doc) throws IOException {
  collector.collect(doc);
  // 因为doc是每个segment的文档编号，需要加上docBase才是总的文档编号
  int docId = doc + docBase;
  // 添加的GroupField中，由GroupField负责统计每个不同值的数目
  gf.addValue(fc[docId]);
}

@Override
public void setNextReader(IndexReader reader, int docBase)
   throws IOException {
  collector.setNextReader(reader, docBase);
  this.docBase = docBase;
}

@Override
public void setScorer(Scorer scorer) throws IOException {
collector.setScorer(scorer);
}

@Override
public boolean acceptsDocsOutOfOrder() {
return collector.acceptsDocsOutOfOrder();
}

public void setFc(String[] fc) {
this.fc = fc;
}

public GroupField getGroupField() {
return gf;
}
}

阅读全文……

标签 : database, java, lucene

发表评论

IT瘾于2015年3月10日下午03时15分00秒发布 #