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

Question

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

javahibernateindexinglucenehibernate-search

13

我希望为我的用户提供最相关和最好的结果。例如，我正在奖励那些具有大标题、描述、附加照片等内容的记录。为了更好地理解，这些记录是自行车路线，包括路点（坐标）和元数据，如照片、评论等。

现在，我使用Hibernate对这些记录进行了索引，然后使用Lucene在Hibernate Search中搜索。为了评分我的结果，我基于文档属性构建查询，并将它们提升（使用boostedTo()）在一个should的BooleanJunction clause中：

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;
    }
}

Hibernate配置：

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

这种方法在大部分情况下都有效，但我仍然看到一些看起来不合适的奇怪结果。我发现这些路线（文档）的大小非常大。普通路线大约有20-30个路点，但这些不合适的结果有100-150个路点。这让我相信默认的Lucene评分仍在发生（因为文档大小而得到更高的评分）。

我在关闭Lucene的评分方面做错了什么吗？还有其他的解释吗？

- Thermometer

不是答案，而是一个考虑：我不会禁用Lucene的默认评分，而是会在索引阶段进行处理。我会为您的文档构建一个自定义索引器，为大型文档设置（减少的）增强，而不是禁用评分；您可以在索引器上调用document.setBoost()来设置基于路点数量的自定义值，并检查结果。类似于setBoost(100/routepoints_count)或某些指数函数。 - Alex Mazzariol

谢谢您的评论！但是，即使考虑到路线点数，这是否仍会给文档大小带来（尽管很小的）提升呢？这就是我不想要的，因为对于我们的评分系统来说，一条路线有2个或200个路线点并不重要，它应该只由其元数据得分。 - Thermometer

是的，那样做可以，但既然您已经使用大因子来提升文档，我认为那不会有太大影响。您真的需要索引路线点吗？您能添加一小段代码以了解索引的内容吗？ - Alex Mazzariol

1个回答

网页内容由stack overflow 提供, 点击上面的

可以查看英文原文，
原文链接

- Alexander Kuznetsov · Accepted 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