Add a new random rerank retriever (#111851)

* Add a new random rerank retriever, that reranks results in random order without requiring inference

* Update docs/changelog/111851.yaml

* PR feedback - remove null checks for field as it can never be null

* Update docs

* Revert "Update docs"

This reverts commit 3d61676.

* Remove minScore

* Random seed

* Delete docs/changelog/111851.yaml

* PR feedback

* Add optional seed to request, YAML test

* PR feedback

Author: kderusso

server/src/main/java/org/elasticsearch/TransportVersions.java

@@ -191,6 +191,7 @@ static TransportVersion def(int id) {
     public static final TransportVersion INGEST_PIPELINE_EXCEPTION_ADDED = def(8_721_00_0);
     public static final TransportVersion ZDT_NANOS_SUPPORT = def(8_722_00_0);
     public static final TransportVersion REMOVE_GLOBAL_RETENTION_FROM_TEMPLATES = def(8_723_00_0);
+    public static final TransportVersion RANDOM_RERANKER_RETRIEVER = def(8_724_00_0);
 
     /*
      * STOP! READ THIS FIRST! No, really,

x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/InferenceFeatures.java

@@ -9,6 +9,7 @@
 
 import org.elasticsearch.features.FeatureSpecification;
 import org.elasticsearch.features.NodeFeature;
+import org.elasticsearch.xpack.inference.rank.random.RandomRankRetrieverBuilder;
 import org.elasticsearch.xpack.inference.rank.textsimilarity.TextSimilarityRankRetrieverBuilder;
 
 import java.util.Set;
@@ -20,7 +21,10 @@ public class InferenceFeatures implements FeatureSpecification {
 
     @Override
     public Set<NodeFeature> getFeatures() {
-        return Set.of(TextSimilarityRankRetrieverBuilder.TEXT_SIMILARITY_RERANKER_RETRIEVER_SUPPORTED);
+        return Set.of(
+            TextSimilarityRankRetrieverBuilder.TEXT_SIMILARITY_RERANKER_RETRIEVER_SUPPORTED,
+            RandomRankRetrieverBuilder.RANDOM_RERANKER_RETRIEVER_SUPPORTED
+        );
     }
 
 }

x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/InferencePlugin.java

@@ -63,6 +63,8 @@
 import org.elasticsearch.xpack.inference.logging.ThrottlerManager;
 import org.elasticsearch.xpack.inference.mapper.SemanticTextFieldMapper;
 import org.elasticsearch.xpack.inference.queries.SemanticQueryBuilder;
+import org.elasticsearch.xpack.inference.rank.random.RandomRankBuilder;
+import org.elasticsearch.xpack.inference.rank.random.RandomRankRetrieverBuilder;
 import org.elasticsearch.xpack.inference.rank.textsimilarity.TextSimilarityRankBuilder;
 import org.elasticsearch.xpack.inference.rank.textsimilarity.TextSimilarityRankRetrieverBuilder;
 import org.elasticsearch.xpack.inference.registry.ModelRegistry;
@@ -243,6 +245,7 @@ public List<InferenceServiceExtension.Factory> getInferenceServiceFactories() {
     public List<NamedWriteableRegistry.Entry> getNamedWriteables() {
         var entries = new ArrayList<>(InferenceNamedWriteablesProvider.getNamedWriteables());
         entries.add(new NamedWriteableRegistry.Entry(RankBuilder.class, TextSimilarityRankBuilder.NAME, TextSimilarityRankBuilder::new));
+        entries.add(new NamedWriteableRegistry.Entry(RankBuilder.class, RandomRankBuilder.NAME, RandomRankBuilder::new));
         return entries;
     }
 
@@ -336,7 +339,8 @@ public List<QuerySpec<?>> getQueries() {
     @Override
     public List<RetrieverSpec<?>> getRetrievers() {
         return List.of(
-            new RetrieverSpec<>(new ParseField(TextSimilarityRankBuilder.NAME), TextSimilarityRankRetrieverBuilder::fromXContent)
+            new RetrieverSpec<>(new ParseField(TextSimilarityRankBuilder.NAME), TextSimilarityRankRetrieverBuilder::fromXContent),
+            new RetrieverSpec<>(new ParseField(RandomRankBuilder.NAME), RandomRankRetrieverBuilder::fromXContent)
         );
     }
 }

x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/rank/random/RandomRankBuilder.java

@@ -0,0 +1,165 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License
+ * 2.0; you may not use this file except in compliance with the Elastic License
+ * 2.0.
+ */
+
+package org.elasticsearch.xpack.inference.rank.random;
+
+import org.apache.lucene.search.Explanation;
+import org.apache.lucene.search.Query;
+import org.elasticsearch.TransportVersion;
+import org.elasticsearch.TransportVersions;
+import org.elasticsearch.client.internal.Client;
+import org.elasticsearch.common.io.stream.StreamInput;
+import org.elasticsearch.common.io.stream.StreamOutput;
+import org.elasticsearch.search.rank.RankBuilder;
+import org.elasticsearch.search.rank.RankDoc;
+import org.elasticsearch.search.rank.context.QueryPhaseRankCoordinatorContext;
+import org.elasticsearch.search.rank.context.QueryPhaseRankShardContext;
+import org.elasticsearch.search.rank.context.RankFeaturePhaseRankCoordinatorContext;
+import org.elasticsearch.search.rank.context.RankFeaturePhaseRankShardContext;
+import org.elasticsearch.search.rank.feature.RankFeatureDoc;
+import org.elasticsearch.search.rank.rerank.RerankingQueryPhaseRankCoordinatorContext;
+import org.elasticsearch.search.rank.rerank.RerankingQueryPhaseRankShardContext;
+import org.elasticsearch.search.rank.rerank.RerankingRankFeaturePhaseRankShardContext;
+import org.elasticsearch.xcontent.ConstructingObjectParser;
+import org.elasticsearch.xcontent.XContentBuilder;
+
+import java.io.IOException;
+import java.util.List;
+import java.util.Objects;
+
+import static org.elasticsearch.xcontent.ConstructingObjectParser.constructorArg;
+import static org.elasticsearch.xcontent.ConstructingObjectParser.optionalConstructorArg;
+import static org.elasticsearch.xpack.inference.rank.random.RandomRankRetrieverBuilder.FIELD_FIELD;
+import static org.elasticsearch.xpack.inference.rank.random.RandomRankRetrieverBuilder.SEED_FIELD;
+
+/**
+ * A {@code RankBuilder} that performs reranking with random scores, used for testing.
+ */
+public class RandomRankBuilder extends RankBuilder {
+
+    public static final String NAME = "random_reranker";
+
+    static final ConstructingObjectParser<RandomRankBuilder, Void> PARSER = new ConstructingObjectParser<>(NAME, args -> {
+        Integer rankWindowSize = args[0] == null ? DEFAULT_RANK_WINDOW_SIZE : (Integer) args[0];
+        String field = (String) args[1];
+        Integer seed = (Integer) args[2];
+
+        return new RandomRankBuilder(rankWindowSize, field, seed);
+    });
+
+    static {
+        PARSER.declareInt(optionalConstructorArg(), RANK_WINDOW_SIZE_FIELD);
+        PARSER.declareString(constructorArg(), FIELD_FIELD);
+        PARSER.declareInt(optionalConstructorArg(), SEED_FIELD);
+    }
+
+    private final String field;
+    private final Integer seed;
+
+    public RandomRankBuilder(int rankWindowSize, String field, Integer seed) {
+        super(rankWindowSize);
+
+        if (field == null || field.isEmpty()) {
+            throw new IllegalArgumentException("field is required");
+        }
+
+        this.field = field;
+        this.seed = seed;
+    }
+
+    public RandomRankBuilder(StreamInput in) throws IOException {
+        super(in);
+        // rankWindowSize deserialization is handled by the parent class RankBuilder
+        this.field = in.readString();
+        this.seed = in.readOptionalInt();
+    }
+
+    @Override
+    public String getWriteableName() {
+        return NAME;
+    }
+
+    @Override
+    public TransportVersion getMinimalSupportedVersion() {
+        return TransportVersions.RANDOM_RERANKER_RETRIEVER;
+    }
+
+    @Override
+    public void doWriteTo(StreamOutput out) throws IOException {
+        // rankWindowSize serialization is handled by the parent class RankBuilder
+        out.writeString(field);
+        out.writeOptionalInt(seed);
+    }
+
+    @Override
+    public void doXContent(XContentBuilder builder, Params params) throws IOException {
+        // rankWindowSize serialization is handled by the parent class RankBuilder
+        builder.field(FIELD_FIELD.getPreferredName(), field);
+        if (seed != null) {
+            builder.field(SEED_FIELD.getPreferredName(), seed);
+        }
+    }
+
+    @Override
+    public boolean isCompoundBuilder() {
+        return false;
+    }
+
+    @Override
+    public Explanation explainHit(Explanation baseExplanation, RankDoc scoreDoc, List<String> queryNames) {
+        if (scoreDoc == null) {
+            return baseExplanation;
+        }
+        if (false == baseExplanation.isMatch()) {
+            return baseExplanation;
+        }
+
+        assert scoreDoc instanceof RankFeatureDoc : "ScoreDoc is not an instance of RankFeatureDoc";
+        RankFeatureDoc rankFeatureDoc = (RankFeatureDoc) scoreDoc;
+
+        return Explanation.match(
+            rankFeatureDoc.score,
+            "rank after reranking: [" + rankFeatureDoc.rank + "] using seed [" + seed + "] with score: [" + rankFeatureDoc.score + "]",
+            baseExplanation
+        );
+    }
+
+    @Override
+    public QueryPhaseRankShardContext buildQueryPhaseShardContext(List<Query> queries, int from) {
+        return new RerankingQueryPhaseRankShardContext(queries, rankWindowSize());
+    }
+
+    @Override
+    public QueryPhaseRankCoordinatorContext buildQueryPhaseCoordinatorContext(int size, int from) {
+        return new RerankingQueryPhaseRankCoordinatorContext(rankWindowSize());
+    }
+
+    @Override
+    public RankFeaturePhaseRankShardContext buildRankFeaturePhaseShardContext() {
+        return new RerankingRankFeaturePhaseRankShardContext(field);
+    }
+
+    @Override
+    public RankFeaturePhaseRankCoordinatorContext buildRankFeaturePhaseCoordinatorContext(int size, int from, Client client) {
+        return new RandomRankFeaturePhaseRankCoordinatorContext(size, from, rankWindowSize(), seed);
+    }
+
+    public String field() {
+        return field;
+    }
+
+    @Override
+    protected boolean doEquals(RankBuilder other) {
+        RandomRankBuilder that = (RandomRankBuilder) other;
+        return Objects.equals(field, that.field) && Objects.equals(seed, that.seed);
+    }
+
+    @Override
+    protected int doHashCode() {
+        return Objects.hash(field, seed);
+    }
+}

x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/rank/random/RandomRankFeaturePhaseRankCoordinatorContext.java

@@ -0,0 +1,55 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License
+ * 2.0; you may not use this file except in compliance with the Elastic License
+ * 2.0.
+ */
+
+package org.elasticsearch.xpack.inference.rank.random;
+
+import org.elasticsearch.action.ActionListener;
+import org.elasticsearch.search.rank.context.RankFeaturePhaseRankCoordinatorContext;
+import org.elasticsearch.search.rank.feature.RankFeatureDoc;
+
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.Random;
+
+/**
+ * A {@code RankFeaturePhaseRankCoordinatorContext} that performs a rerank inference call to determine relevance scores for documents within
+ * the provided rank window.
+ */
+public class RandomRankFeaturePhaseRankCoordinatorContext extends RankFeaturePhaseRankCoordinatorContext {
+
+    private final Integer seed;
+
+    public RandomRankFeaturePhaseRankCoordinatorContext(int size, int from, int rankWindowSize, Integer seed) {
+        super(size, from, rankWindowSize);
+        this.seed = seed;
+    }
+
+    @Override
+    protected void computeScores(RankFeatureDoc[] featureDocs, ActionListener<float[]> scoreListener) {
+        // Generate random scores seeded by doc
+        float[] scores = new float[featureDocs.length];
+        for (int i = 0; i < featureDocs.length; i++) {
+            RankFeatureDoc featureDoc = featureDocs[i];
+            int doc = featureDoc.doc;
+            long docSeed = seed != null ? seed + doc : doc;
+            scores[i] = new Random(docSeed).nextFloat();
+        }
+        scoreListener.onResponse(scores);
+    }
+
+    /**
+     * Sorts documents by score descending.
+     * @param originalDocs documents to process
+     */
+    @Override
+    protected RankFeatureDoc[] preprocess(RankFeatureDoc[] originalDocs) {
+        return Arrays.stream(originalDocs)
+            .sorted(Comparator.comparing((RankFeatureDoc doc) -> doc.score).reversed())
+            .toArray(RankFeatureDoc[]::new);
+    }
+
+}