Add support for bitwise inner-product in painless #116082
Merged
Conversation
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
benwtrent
added
>enhancement
auto-backport
|
Documentation preview: |
elasticsearchmachine
added
the
Team:Search Relevance
|
Pinging @elastic/es-search-relevance (Team:Search Relevance) |
|
Hi @benwtrent, I've created a changelog YAML for you. |
rjernst
reviewed
Nov 1, 2024
| } | ||
| // tail: | ||
| for (; i < a.length; i++) { | ||
| distance += Integer.bitCount((a[i] & b[i]) & 0xFF); |
There was a problem hiding this comment.
Could the tail be done with a single Long.bitCount call, if using a mask based on the number of remaining bytes?
There was a problem hiding this comment.
Possibly? But I didn't want to bother with over optimizing. Especially since these methods are effectively copy-pastes of what exists in Lucene for xor (just changing to &).
libs/simdvec/src/main/java/org/elasticsearch/simdvec/ESVectorUtil.java
Outdated
Show resolved
Hide resolved
john-wagster
reviewed
Nov 4, 2024
|
|
||
| /** | ||
| * AND bit count computed over signed bytes. | ||
| * Copied from Lucene's XOR implementation |
There was a problem hiding this comment.
This is more so for my education. What's the thinking here for putting this in ES vs Lucene? given that we have XOR in Lucene VectorUtil and this seem complementary.
There was a problem hiding this comment.
@john-wagster there is no compelling reason for keeping it out of Lucene. But, its weird for there to be public utility methods in Lucene when nothing directly utilizes it.
|
@elasticmachine update branch |
There was a problem hiding this comment.
On line 19 we also say that dot_product is not supported for bit vectors.
| @@ -332,6 +332,9 @@ When using `bit` vectors, not all the vector functions are available. The suppor | |||
| * <<vector-functions-hamming,`hamming`>> – calculates Hamming distance, the sum of the bitwise XOR of the two vectors | |||
| * <<vector-functions-l1,`l1norm`>> – calculates L^1^ distance, this is simply the `hamming` distance | |||
| * <<vector-functions-l2,`l2norm`>> - calculates L^2^ distance, this is the square root of the `hamming` distance | |||
| * <<vector-functions-dot-product,`dotProduct`>> – calculates dot product. When comparing two `bit` vectors, | |||
There was a problem hiding this comment.
May be we can add that queryVector can be byte[] (of the same dims as docs or dims *8), or also can be a string, and can be of float[]
mayya-sharipova
approved these changes
Nov 4, 2024
There was a problem hiding this comment.
@benwtrent Thanks Ben, great change! I've added a small docs comment.
…om:benwtrent/elasticsearch into feature/allow-binary-dotproduct-in-scripts
benwtrent
added
the
auto-merge-without-approval
|
@elasticmachine update branch |
tteofili
approved these changes
Nov 5, 2024
Comment on lines
+348
to
+349
| isFloat = true; | ||
| } |
There was a problem hiding this comment.
We need to build both vectors and then pick the right now, breaking would prevent us from building the arrays.
…om:benwtrent/elasticsearch into feature/allow-binary-dotproduct-in-scripts
…y-dotproduct-in-scripts
💚 Backport successful
|
benwtrent
added a commit
to benwtrent/elasticsearch
that referenced
this pull request
Nov 5, 2024
This adds bitwise inner product to painless. The idea here is: - For two bit arrays, which we determine to be a byte array whose dimensions match `dense_vector.dim/8`, we simply return bitwise `&` - For a stored bit array (remember, with `dense_vector.dim/8` bytes), sum up the provided byte or float array using the bit array as a mask. This is effectively supporting asynchronous quantization. A prime example of how this works is: https://github.com/cohere-ai/BinaryVectorDB Basically, you do your initial search against the binary space and then rerank with a differently quantized vector allowing for more information without additional storage space. closes: elastic#111232
elasticsearchmachine
pushed a commit
that referenced
this pull request
Nov 6, 2024
…16285) * Add support for bitwise inner-product in painless (#116082) This adds bitwise inner product to painless. The idea here is: - For two bit arrays, which we determine to be a byte array whose dimensions match `dense_vector.dim/8`, we simply return bitwise `&` - For a stored bit array (remember, with `dense_vector.dim/8` bytes), sum up the provided byte or float array using the bit array as a mask. This is effectively supporting asynchronous quantization. A prime example of how this works is: https://github.com/cohere-ai/BinaryVectorDB Basically, you do your initial search against the binary space and then rerank with a differently quantized vector allowing for more information without additional storage space. closes: #111232 * removing unnecessary task adjustment --------- Co-authored-by: Elastic Machine <[email protected]>
jozala
pushed a commit
that referenced
this pull request
Nov 13, 2024
This adds bitwise inner product to painless. The idea here is: - For two bit arrays, which we determine to be a byte array whose dimensions match `dense_vector.dim/8`, we simply return bitwise `&` - For a stored bit array (remember, with `dense_vector.dim/8` bytes), sum up the provided byte or float array using the bit array as a mask. This is effectively supporting asynchronous quantization. A prime example of how this works is: https://github.com/cohere-ai/BinaryVectorDB Basically, you do your initial search against the binary space and then rerank with a differently quantized vector allowing for more information without additional storage space. closes: #111232
alexey-ivanov-es
pushed a commit
to alexey-ivanov-es/elasticsearch
that referenced
this pull request
Nov 28, 2024
This adds bitwise inner product to painless. The idea here is: - For two bit arrays, which we determine to be a byte array whose dimensions match `dense_vector.dim/8`, we simply return bitwise `&` - For a stored bit array (remember, with `dense_vector.dim/8` bytes), sum up the provided byte or float array using the bit array as a mask. This is effectively supporting asynchronous quantization. A prime example of how this works is: https://github.com/cohere-ai/BinaryVectorDB Basically, you do your initial search against the binary space and then rerank with a differently quantized vector allowing for more information without additional storage space. closes: elastic#111232
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
This adds bitwise inner product to painless.
The idea here is:
dense_vector.dim/8, we simply return bitwise&dense_vector.dim/8bytes), sum up the provided byte or float array using the bit array as a mask.This is effectively supporting asynchronous quantization. A prime example of how this works is: https://github.com/cohere-ai/BinaryVectorDB
Basically, you do your initial search against the binary space and then rerank with a differently quantized vector allowing for more information without additional storage space.
closes: #111232