1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
|
// Copyright Vespa.ai. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
package com.yahoo.search.ranking;
import com.yahoo.component.annotation.Inject;
import com.yahoo.search.Query;
import com.yahoo.search.Result;
import com.yahoo.search.query.Sorting;
import com.yahoo.search.result.ErrorMessage;
import com.yahoo.search.result.FeatureData;
import com.yahoo.search.result.Hit;
import com.yahoo.search.result.HitGroup;
import com.yahoo.tensor.Tensor;
import com.yahoo.data.access.helpers.MatchFeatureData;
import com.yahoo.data.access.helpers.MatchFeatureFilter;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Optional;
import java.util.function.Supplier;
import java.util.logging.Logger;
public class GlobalPhaseRanker {
private static final Logger logger = Logger.getLogger(GlobalPhaseRanker.class.getName());
private final RankProfilesEvaluatorFactory factory;
@Inject
public GlobalPhaseRanker(RankProfilesEvaluatorFactory factory) {
this.factory = factory;
logger.fine(() -> "Using factory: " + factory);
}
public Optional<ErrorMessage> validateNoSorting(Query query, String schema) {
var setup = globalPhaseSetupFor(query, schema).orElse(null);
if (setup == null) return Optional.empty();
var sorting = query.getRanking().getSorting();
if (sorting == null || sorting.fieldOrders() == null) return Optional.empty();
for (var fieldOrder : sorting.fieldOrders()) {
if (!fieldOrder.getSorter().getName().equals("[rank]")
|| fieldOrder.getSortOrder() != Sorting.Order.DESCENDING) {
return Optional.of(ErrorMessage.createIllegalQuery("Sorting is not supported with global phase"));
}
}
return Optional.empty();
}
public void rerankHits(Query query, Result result, String schema) {
var setup = globalPhaseSetupFor(query, schema).orElse(null);
if (setup == null) return;
var mainSrc = withQueryPrep(setup.globalPhaseEvalCtx, query);
var mainMF = setup.globalPhaseEvalCtx.fromMF();
int rerankCount = setup.rerankCount;
var normalizers = new ArrayList<NormalizerContext>();
for (var nSetup : setup.normalizers) {
var normEvalSrc = withQueryPrep(nSetup.evalCtx(), query);
normalizers.add(new NormalizerContext(nSetup.name(), nSetup.supplier().get(), normEvalSrc, nSetup.evalCtx().fromMF()));
}
var rescorer = new HitRescorer(mainSrc, mainMF, normalizers);
var reranker = new ResultReranker(rescorer, rerankCount);
reranker.rerankHits(result);
hideImplicitMatchFeatures(result, setup.matchFeaturesToHide);
}
static Supplier<Evaluator> withQueryPrep(FunEvalCtx evalCtx, Query query) {
var prepared = PreparedInput.findFromQuery(query, evalCtx.fromQuery());
Supplier<Evaluator> supplier = () -> {
var result = evalCtx.evalSrc().get();
for (var entry : prepared) {
result.bind(entry.name(), entry.value());
}
return result;
};
return supplier;
}
private void hideImplicitMatchFeatures(Result result, Collection<String> namesToHide) {
if (namesToHide.size() == 0) return;
var filter = new MatchFeatureFilter(namesToHide);
for (var iterator = result.hits().deepIterator(); iterator.hasNext();) {
Hit hit = iterator.next();
if (hit.isMeta() || hit instanceof HitGroup) {
continue;
}
if (hit.getField("matchfeatures") instanceof FeatureData matchFeatures) {
if (matchFeatures.inspect() instanceof MatchFeatureData.HitValue hitValue) {
var newValue = hitValue.subsetFilter(filter);
if (newValue.fieldCount() == 0) {
hit.removeField("matchfeatures");
} else {
hit.setField("matchfeatures", newValue);
}
}
}
}
}
private Optional<GlobalPhaseSetup> globalPhaseSetupFor(Query query, String schema) {
return factory.evaluatorForSchema(schema)
.flatMap(evaluator -> evaluator.getGlobalPhaseSetup(query.getRanking().getProfile()));
}
}
|
