This is an automated email from the ASF dual-hosted git repository.
asf-gitbox-commits pushed a commit to branch branch_9_11
in repository https://gitbox.apache.org/repos/asf/solr.git
The following commit(s) were added to refs/heads/branch_9_11 by this push:
new 13440526586 Ref guide: remove quantized DenseVectorField docs not
present in 9.x (#4975)
13440526586 is described below
commit 134405265865de09e1a2509d3e0b7b4eb5145933
Author: David Smiley <[email protected]>
AuthorDate: Fri Oct 2 21:29:41 2026 -0400
Ref guide: remove quantized DenseVectorField docs not present in 9.x (#4975)
Co-authored-by: Claude Sonnet 5.5 <[email protected]>
(cherry picked from commit 566c2ef8287b364b679c20066a20903579255f9d)
---
.../query-guide/pages/dense-vector-search.adoc | 101 ---------------------
1 file changed, 101 deletions(-)
diff --git
a/solr/solr-ref-guide/modules/query-guide/pages/dense-vector-search.adoc
b/solr/solr-ref-guide/modules/query-guide/pages/dense-vector-search.adoc
index 8562228aec0..27547b55532 100644
--- a/solr/solr-ref-guide/modules/query-guide/pages/dense-vector-search.adoc
+++ b/solr/solr-ref-guide/modules/query-guide/pages/dense-vector-search.adoc
@@ -284,107 +284,6 @@ client.add(Arrays.asList(d1, d2));
====
======
-=== ScalarQuantizedDenseVectorField
-Because dense vectors can have a costly size, it may be worthwhile to use a
technique called "quantization"
-which creates a compressed representation of the original vectors. This allows
more of the index to be stored in faster memory
-at the cost of some precision.
-
-This dense vector type uses a conversion that projects a 32 bit float
precision feature down to an 8 bit int (or smaller)
-by linearly mapping the float range of each dimension down to evenly sized
"buckets" of values that fit into an int. For example:
-with 8 bits we can store up to 256 discrete values, so a float dimension with
values from 0.0 to 1.0 may be mapped as
-
-[0.0, 0.0039) => 0, [0.0039, 0.0078) => 1 ... etc
-
-As a specific type of DenseVectorField, this field type supports all the same
configurable properties outlined above as well
-as some additional ones.
-
-Here is how a ScalarQuantizedDenseVectorField can be defined in the schema:
-
-[source,xml]
-<fieldType name="scalar_quantized_vector"
class="solr.ScalarQuantizedDenseVectorField" vectorDimension="4"
similarityFunction="cosine"/>
-<field name="vector" type="scalar_quantized_vector" indexed="true"
stored="true"/>
-
-`bits`::
-+
-[%autowidth,frame=none]
-|===
-s|Optional |Default: `7`
-|===
-+
-The number of bits to use for each quantized dimension value
-+
-Accepted values: 4 (half byte) or 7 (unsigned byte).
-
-`confidenceInterval`::
-+
-[%autowidth,frame=none]
-|===
-s|Optional |Default: `dimension-scaled`
-|===
-+
-Statistically, outlier values are rarely meaningfully relevant to searches, so
to increase the size of each bucket for
-quantization (and therefore information gain) we can scale the quantization
intervals to the middle n % of values and place the remaining
-outliers in the outermost intervals.
-+
-For example: 0.9 means scale interval sizes to the middle 90% of values
-+
-If this param is omitted a default is used; scaled to the number of dimensions
according to `1-1/(vector_dimensions + 1)`
-+
-Accepted values: `FLOAT32` (within 0.9 and 1.0)
-
-`dynamicConfidenceInterval`::
-+
-[%autowidth,frame=none]
-|===
-s|Optional |Default: `false`
-|===
-+
-If set to true, enables dynamically determining confidence interval (per
dimension) by sampling values each time a merge occurs.
-+
-`NOTE: when this is enabled, it will take precedence over any value configured
for confidenceInterval`
-+
-Accepted values: `BOOLEAN`
-
-`compress`::
-+
-[%autowidth,frame=none]
-|===
-s|Optional |Default: `false`
-|===
-+
-If set to true, this will further pack multiple dimension values within a one
byte alignment. This further decreases the
-quantized vector disk storage size by 50% at some decode penalty. This does
not affect the raw vector which is always
-preserved when `stored` is true.
-+
-`NOTE: this can only be enabled when bits=4`
-+
-Accepted values: `BOOLEAN`
-
-=== BinaryQuantizedDenseVectorField
-
-Binary quantization is a quantization technique that extends scalar
quantization, and is even more aggressive in its compression;
-able to reduce in-memory representation of each vector dimension from a 32 bit
float down to a single bit.
-This is done by normalizing each dimension of a vector relative to a centroid
(mid-point pre-calculated against all vectors in the index)
-with the stored bit representing whether the actual value is "above" or
"below" the centroid's value. A further "corrective factor" is also computed
-and stored to help compensate accuracy in the estimated distance. At query
time asymmetric quantization is applied to the query
-vector (reducing its dimension values down to 4 bits each), but allowing
comparison with the stored binary quantized vector via bit arithmetic.
-
-This implementation comprises of LVQ, proposed in
https://arxiv.org/abs/2304.04759[Similarity Search in the Blink of an Eye With
Compressed Indices]
-by Cecilia Aguerrebere et al., previous work on globally optimized scalar
quantization in Apache Lucene, and ideas from
-https://arxiv.org/abs/1908.10396[Accelerating Large-Scale Inference with
Anisotropic Vector Quantization] by Ruiqi Guo et al.
-
-This vector type is best utilized for data sets consisting of large amounts of
high dimensionality vectors.
-
-Here is how a BinaryQuantizedDenseVectorField can be defined in the schema:
-
-[source,xml]
-<fieldType name="binary_quantized_vector"
class="solr.BinaryQuantizedDenseVectorField" vectorDimension="4"/>
-<field name="vector" type="binary_quantized_vector" indexed="true"
stored="true"/>
-
-BinaryQuantizedDenseVectorField accepts the same parameters as
`DenseVectorField` with the only notable exception being
-`similarityFunction`. Bit quantization uses its own distance calculation and
so does not require nor use the `similarityFunction`
-param.
-
== Query Time
Apache Solr provides three query parsers that work with dense vector fields,
that each support different ways of matching documents based on vector
similarity: The `knn` query parser, the `vectorSimilarity` query parser and the
`knn_text_to_vector` query parser.
