Adds new simplified rescorer API to [Float|Byte]VectorValues (#15176)

Rescoring against a vector field should be simple and allow for lower level bulk scoring optimizations (e.g. scoring floating point values off heap, possibly bulk prefetching, etc.).

However, the current API always returns a scorer against the fastest fidelity vectors, not the most accurate.

This commit adds a new method to the vector-value classes that is specifically a `rescorer`, that allows scoring optimizations (including bulk scoring when possible) to take place.

Author: benwtrent

lucene/core/src/java/org/apache/lucene/codecs/lucene102/Lucene102BinaryQuantizedVectorsReader.java

@@ -431,6 +431,11 @@ public VectorScorer scorer(float[] query) throws IOException {
       return quantizedVectorValues.scorer(query);
     }
 
+    @Override
+    public VectorScorer rescorer(float[] query) throws IOException {
+      return rawVectorValues.rescorer(query);
+    }
+
     BinarizedByteVectorValues getQuantizedVectorValues() throws IOException {
       return quantizedVectorValues;
     }

lucene/core/src/java/org/apache/lucene/codecs/lucene99/Lucene99ScalarQuantizedVectorsReader.java

@@ -459,6 +459,11 @@ public VectorScorer scorer(float[] query) throws IOException {
       return quantizedVectorValues.scorer(query);
     }
 
+    @Override
+    public VectorScorer rescorer(float[] query) throws IOException {
+      return rawVectorValues.rescorer(query);
+    }
+
     @Override
     public DocIndexIterator iterator() {
       return rawVectorValues.iterator();

lucene/core/src/java/org/apache/lucene/index/ByteVectorValues.java

@@ -65,7 +65,8 @@ public static void checkField(LeafReader in, String field) {
   }
 
   /**
-   * Return a {@link VectorScorer} for the given query vector.
+   * Return a {@link VectorScorer} for the given query vector. When the underlying format quantizes
+   * the vectors, this will return a {@link VectorScorer} that scores against the quantized vectors.
    *
    * @param query the query vector
    * @return a {@link VectorScorer} instance or null
@@ -74,6 +75,23 @@ public VectorScorer scorer(byte[] query) throws IOException {
     throw new UnsupportedOperationException();
   }
 
+  /**
+   * Rescore using the given query vector and the current {@link ByteVectorValues}. This is unique
+   * from scorer() in that it is explicitly for rescoring an existing set of hits and thus will
+   * often utilize the highest fidelity scoring algorithm available. This is useful when the initial
+   * search used a quantized index or an approximate scoring algorithm, and now we want to rescore
+   * the hits using the full fidelity vectors. The default implementation is to call {@link
+   * #scorer(byte[])} assuming that the scorer is already the highest fidelity implementation
+   * available.
+   *
+   * @param target the query vector
+   * @return a {@link VectorScorer} instance or null
+   * @throws IOException if an I/O error occurs
+   */
+  public VectorScorer rescorer(byte[] target) throws IOException {
+    return scorer(target);
+  }
+
   @Override
   public VectorEncoding getEncoding() {
     return VectorEncoding.BYTE;

lucene/core/src/java/org/apache/lucene/index/FloatVectorValues.java

@@ -66,7 +66,8 @@ public static void checkField(LeafReader in, String field) {
 
   /**
    * Return a {@link VectorScorer} for the given query vector and the current {@link
-   * FloatVectorValues}.
+   * FloatVectorValues}. When the underlying format quantizes the vectors, this will return a {@link
+   * VectorScorer} that scores against the quantized vectors.
    *
    * @param target the query vector
    * @return a {@link VectorScorer} instance or null
@@ -75,6 +76,23 @@ public VectorScorer scorer(float[] target) throws IOException {
     throw new UnsupportedOperationException();
   }
 
+  /**
+   * Rescore using the given query vector and the current {@link FloatVectorValues}. This is unique
+   * from scorer() in that it is explicitly for rescoring an existing set of hits and thus will
+   * often utilize the highest fidelity scoring algorithm available. This is useful when the initial
+   * search used a quantized index or an approximate search algorithm, and now we want to rescore
+   * the hits using the full fidelity vectors. The default implementation is to call {@link
+   * #scorer(float[])} assuming that the scorer is already the highest fidelity implementation
+   * available.
+   *
+   * @param target the query vector
+   * @return a {@link VectorScorer} instance or null
+   * @throws IOException if an I/O error occurs
+   */
+  public VectorScorer rescorer(float[] target) throws IOException {
+    return scorer(target);
+  }
+
   @Override
   public VectorEncoding getEncoding() {
     return VectorEncoding.FLOAT32;

lucene/core/src/java/org/apache/lucene/search/FullPrecisionFloatVectorSimilarityValuesSource.java

@@ -86,7 +86,23 @@ public DoubleValues getValues(LeafReaderContext ctx, DoubleValues scores) throws
     }
 
     if (vectorSimilarityFunction == null) {
-      this.vectorSimilarityFunction = fi.getVectorSimilarityFunction();
+      VectorScorer scorer = vectorValues.rescorer(queryVector);
+      if (scorer == null) {
+        return DoubleValues.EMPTY;
+      }
+      DocIdSetIterator iterator = scorer.iterator();
+      return new DoubleValues() {
+        @Override
+        public double doubleValue() throws IOException {
+          return scorer.score();
+        }
+
+        @Override
+        public boolean advanceExact(int doc) throws IOException {
+          return doc >= iterator.docID()
+              && (iterator.docID() == doc || iterator.advance(doc) == doc);
+        }
+      };
     }
     final KnnVectorValues.DocIndexIterator iterator = vectorValues.iterator();
     return new DoubleValues() {