如何在 Hibernate Search/Lucene 中禁用默认评分/提升?

Posted

技术标签:

【中文标题】如何在 Hibernate Search/Lucene 中禁用默认评分/提升?【英文标题】:How to disable default scoring/boosting in Hibernate Search/Lucene? 【发布时间】:2015-08-22 21:37:36 【问题描述】:

我想为我的用户提供最相关和最好的结果。例如,我奖励具有大标题、描述、附加照片等的记录。对于上下文:记录是自行车路线,具有路线点(坐标)和照片、评论等元数据。

现在,我使用Hibernate 为这些记录编制了索引,然后在Hibernate Search 中使用Lucene 在索引中进行搜索。为了给我的结果打分,我根据文档属性构建查询并在should BooleanJunction clause 中提升它们(使用boostedTo()):

bj.should(qb.range().onField("descriptionLength").above(3000).createQuery()).boostedTo(3.0f);   
bj.should(qb.range().onField("views.views").above(5000).createQuery()).boostedTo(3.0f);     
bj.should(qb.range().onField("nameLength").above(20).createQuery()).boostedTo(1.0f);     
bj.should(qb.range().onField("picturesLength").above(0).createQuery()).boostedTo(5.0f);
bj.should(qb.keyword().onField("routePoints.poi.participant").matching("true").createQuery()).boostedTo(10.0f);

为了尝试禁用 Lucene 的评分,我重写了 DefaultSimilarity 类,将所有比较设置为 1.0f 分数并通过 Hibernate 配置启用它:

public class IgnoreScoringSimilarity extends DefaultSimilarity 
    @Override
    public float idf(long docFreq, long numDocs) 
        return 1.0f;
    

    @Override
    public float tf(float freq) 
        return 1.0f;
    

    @Override
    public float coord(int overlap, int maxOverlap) 
        return 1.0f;
    

    @Override
    public float lengthNorm(FieldInvertState state) 
        return 1.0f;
    

    @Override
    public float queryNorm(float sumOfSquaredWeights) 
        return 1.0f;
    
 

休眠配置:

<property name="hibernate.search.default.similarity" value="com.search.IgnoreScoringSimilarity"/>

这种方法在 90% 的情况下都有效,但是,我仍然看到一些奇怪的结果,似乎不合适。我认识到的模式是这些路线(文档)的大小非常大。一条正常的路线大约有 20-30 个路线点,但是这些不合适的结果有 100-150 个。这让我相信默认的 Lucene 评分仍在发生(由于文档大小而得分更高)。

我在禁用 Lucene 的评分时做错了什么吗?能不能有别的解释?

【问题讨论】:

不是一个答案,而是一个考虑:我不会禁用 Lucene 的默认评分,但会在索引阶段工作。我会为您的文档构建一个自定义索引器,为大文档设置(减少)提升;您可以在索引器上调用document.setBoost() 以根据路由点的数量设置自定义值,并检查结果。 setBoost(100/routepoints_count) 之类的东西,或者某种指数函数。 感谢您的评论!但是,通过考虑路由点数,这是否仍然会(尽管很小)增加文档大小?这就是我不想要的,因为对于我们的评分系统,一条路线有 2 或 200 个路线点并不重要,它应该只通过它的元数据进行评分。 是的,那会,但是由于您已经在用大的因素增加文档,我认为这并不重要。你真的需要索引路由点吗?您可以添加索引器的 sn-p 以了解索引的内容吗? 【参考方案1】:

我可以建议另一种基于自定义结果排序的方法。您可以在answer 中了解它。这个答案有点过时了,所以我根据Lucene API 4.10.1修改了这个例子。比较器

public abstract class CustomComparator extends FieldComparator<Double> 
    double[] scoring;
    double bottom;
    double topValue;
    private FieldCache.Ints[] currentReaderValues;
    private String[] fields;

    protected abstract double getScore(int[] value);

    public CustomComparator(int hitNum, String[] fields) 
        this.fields = fields;
        scoring = new double[hitNum];
    

    int[] fromReaders(int doc) 
        int[] result = new int[currentReaderValues.length];
        for (int i = 0; i < result.length; i++) 
            result[i] = currentReaderValues[i].get(doc);
        
        return result;
    

    @Override
    public int compare(int slot1, int slot2) 
        return Double.compare(scoring[slot1], scoring[slot2]);
    

    @Override
    public void setBottom(int slot) 
        this.bottom = scoring[slot];
    

    @Override
    public void setTopValue(Double top) 
        topValue = top;
    

    @Override
    public int compareBottom(int doc) throws IOException 
        double v2 = getScore(fromReaders(doc));
        return Double.compare(bottom, v2);
    

    @Override
    public int compareTop(int doc) throws IOException 
        double docValue = getScore(fromReaders(doc));
        return Double.compare(topValue, docValue);
    

    @Override
    public void copy(int slot, int doc) throws IOException 
        scoring[slot] = getScore(fromReaders(doc));
    

    @Override
    public FieldComparator<Double> setNextReader(AtomicReaderContext atomicReaderContext) throws IOException 
        currentReaderValues = new FieldCache.Ints[fields.length];
        for (int i = 0; i < fields.length; i++) 
            currentReaderValues[i] = FieldCache.DEFAULT.getInts(atomicReaderContext.reader(), fields[i], null, false);
        
        return this;
    

    @Override
    public Double value(int slot) 
        return scoring[slot];
    

搜索示例

public class SortExample 

    public static void main(String[] args) throws IOException 

        final String[] fields = new String[]"descriptionLength", "views.views", "nameLength";

        Sort sort = new Sort(
                new SortField(
                        "",
                        new FieldComparatorSource() 
                            public FieldComparator newComparator(String fieldname, int numHits, int sortPos, boolean reversed) throws IOException 
                                return new CustomComparator(numHits, fields) 
                                    @Override
                                    protected double getScore(int[] value) 
                                        int descriptionLength = value[0];
                                        int views = value[1];
                                        int nameLength = value[2];
                                        return -((descriptionLength > 2000.0 ? 5.0 : 0.0) +
                                                (views > 5000.0 ? 3.0 : 0.0) +
                                                (nameLength > 20.0 ? 1.0 : 0.0));
                                    
                                ;
                            
                        
                )
        );

        IndexWriterConfig indexWriterConfig = new IndexWriterConfig(Version.LUCENE_4_10_4, new StandardAnalyzer());
        Directory directory = new RAMDirectory();
        IndexWriter indexWriter = new IndexWriter(directory, indexWriterConfig);

        addDoc(indexWriter, "score 0", 1000, 1000, 10);
        addDoc(indexWriter, "score 5", 3000, 1000, 10);
        addDoc(indexWriter, "score 3", 1000, 6000, 10);
        addDoc(indexWriter, "score 1", 1000, 1000, 30);
        addDoc(indexWriter, "score 4", 1000, 6000, 30);
        addDoc(indexWriter, "score 6", 5000, 1000, 30);
        addDoc(indexWriter, "score 9", 5000, 6000, 30);

        final IndexReader indexReader = DirectoryReader.open(indexWriter, false);
        IndexSearcher indexSearcher = new IndexSearcher(indexReader);
        Query query = new TermQuery(new Term("all", "all"));
        int nDocs = 100;

        final TopDocs search = indexSearcher.search(query, null, nDocs, sort);
        System.out.println("Max " + search.scoreDocs.length + " " + search.getMaxScore());
        for (ScoreDoc sd : search.scoreDocs) 
            Document document = indexReader.document(sd.doc);
            System.out.println(document.getField("name").stringValue());
        

    

    private static void addDoc(IndexWriter indexWriter, String name, int descriptionLength, int views, int nameLength) throws IOException 
        Document doc = new Document();
        doc.add(new TextField("name", name, Field.Store.YES));
        doc.add(new TextField("all", "all", Field.Store.YES));
        doc.add(new IntField("descriptionLength", descriptionLength, Field.Store.YES));
        doc.add(new IntField("views.views", views, Field.Store.YES));
        doc.add(new IntField("nameLength", nameLength, Field.Store.YES));
        indexWriter.addDocument(doc);
    

代码会输出

score 9
score 6
score 5
score 4
score 3
score 1
score 0

【讨论】:

感谢您的建议!这似乎是一个有趣的方法。但是,我不确定这是否适用于我想要提升的方式。您链接的答案似乎只会提升字段本身?这样我就不能做诸如“使用isRoundtrip = false 提升路由”x 或“用x 提升标题长度> 50 的路由”之类的事情。如果我错了,请纠正我! 您可以在评分中更改排名公式,而不是提升查询。例如你有field1 * 0.5 + field2 * 1.4 + field3 * 1.8,你可以把它改成titleLength &gt; 50.0 ? 3.0 : 0.0 + nameLength &gt; 0.0 ? 1.0 : 0.0等等。在这种方法中,您可以更好地控制排名,因为您可以使用任何评分公式。 有趣,我会尝试一下这种方法,感谢您的建议,+1。 希望你能成功。 我正在尝试实施您的建议,但是遇到了一些兼容性问题。我使用的是 Hibernate Search 5.2,所以我猜这使用的是 Lucene 4.7?我在setNextReader 方法中返回什么,我返回this?在强制的compareTopsetTopValue 方法中我需要做什么? (需要覆盖那些以扩展FieldComparator。还想知道如何使用NumericDocValues,我是否需要使用它而不是int[][] currentReaderValues?很难理解我需要使用的那些新属性的概念。

以上是关于如何在 Hibernate Search/Lucene 中禁用默认评分/提升?的主要内容,如果未能解决你的问题,请参考以下文章

如何在Eclipse上安装hibernate Tool

如何在 JPA/Hibernate 中执行本机 SQL 脚本?

如何在hibernate中为count(*)编写查询

如何避免在 Hibernate 中获取 javassist 惰性实体代理实例

如何在 Hibernate 中执行非多态 HQL 查询?

如何在 Hibernate 和 JDBC 之间进行选择?