Pith. sign in

REVIEW 4 major objections 5 minor 37 references

Unsupervised Neural Quantization for Compressed-Domain Similarity Search

T0 review · 4 major / 5 minor · reviewed 2026-08-14 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗ Review JSON

Pith's one-line read This paper claims that an unsupervised deep network that quantizes descriptors into codewords via a hard Gumbel-Softmax and straight-through gradients outperforms shallow multi-codebook quantization, reporting state-of-the-art Recall@k on…

desk verdict A solid, well-engineered retrieval paper with real gains, but the SOTA claim needs an honest rewrite: it compares against the older LSQ, not the cited LSQ++, and skips reranking on the strongest baseline. read the letter →

arxiv 1908.03883 v1 pith:73GJVURA submitted 2019-08-11 cs.LG cs.CVstat.ML

Stanislav Morozov , Artem Babenko This is my paper · ORCID
classification cs.LGcs.CVstat.ML
keywords unsupervisedlearningmulti-codebookquantizationcompressed-domainretrievalsimilaritysearchGumbel-Softmaxstraight-throughestimatorvisualdescriptorcompressionlookuptable
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

Compressed-domain similarity search stores each database vector in a few bytes and ranks candidates by distances computed from those bytes. For visual descriptors, the previous state of the art was shallow multi-codebook quantization, such as LSQ and lattice-based methods. This paper argues that a deep unsupervised model can do better: it learns a nonlinear encoder that maps each descriptor to a tuple of codewords, plus a decoder, and trains them end-to-end with reconstruction, triplet, and code-balance losses. On the Deep and BigANN benchmark families, UNQ reports higher Recall@1, @10, and @100 than prior methods at 8 and 16 bytes per vector, except at Deep1B with 8 bytes, where Catalyst+Lattice keeps the edge on Recall@1 and @10. If correct, the result shows that deep learning closes the gap in unsupervised quantization and that neural codebooks can still be searched with simple lookup tables.

What carries the argument

The central object is the pair of distance functions defined in a learned space. The encoder $\mathrm{net}(x)$ has M heads, one per codebook, and the probability $p(c_{mk}|x) = \mathrm{softmax}_k\langle \mathrm{net}(x)_m, c_{mk}\rangle$. The fast distance $d_2$ factorizes into M terms, so after one encoder pass and $O(MK)$ dot products, ranking the database costs M additions per vector; the more accurate decoder distance $d_1$ is used only to rerank a small candidate set. The training mechanism that carries the argument is the hard Gumbel-Softmax relaxation with straight-through gradient estimation, combined with the triplet loss on $d_2$ and the coefficient-of-variation regularizer that keeps all codewords in use.

What would settle it

Replace the straight-through estimator in the released implementation with an unbiased discrete-variable gradient estimator such as REBAR while keeping the architecture, losses, and hyperparameters fixed, then measure Recall@1 on Deep1M at 8 bytes; if Recall@1 does not drop, the biased straight-through gradients are not necessary for the reported gain and the paper's stated training mechanism is not the cause.

Watch

Extended reading notes

Core claim

The central discovery is that discrete hidden variables trained with a hard Gumbel-Softmax relaxation and straight-through gradient estimation can serve as effective quantized codes for unsupervised nearest-neighbor retrieval, provided the training objective also shapes the learned space with a triplet loss and prevents code collapse with a coefficient-of-variation regularizer. The encoder maps a descriptor into M learned spaces, each holding K codewords, and the probability of picking codeword k is a softmax over dot products; the compressed code is the argmax tuple. Distances are computed either by decoding back to the original space or, for fast exhaustive search, by the factorized negative log-probability $d_2(q,i) = -\sum_m \langle \mathrm{net}(q)_m, c_{m i_m}\rangle + \mathrm{const}(q)$, which costs only M additions per database vector once the query is encoded. The paper reports that this combination produces the best published Recall@k on the two billion-scale benchmark families at 8 and 16 bytes, establishing that deep architectures can benefit unsupervised multi-codebook quantization.

Load-bearing premise

The load-bearing premise is that the straight-through gradient estimator, despite being biased, guides the encoder and codebooks toward codes whose learned-space distances rank true nearest neighbors first; if that premise fails, the reported recall gains would disappear.

Editorial extensions

If this is right

  • UNQ provides a new state-of-the-art for unsupervised compressed-domain retrieval on both deep CNN descriptors and SIFT histograms at 8 and 16 bytes per vector, in most operating points.
  • Neural quantization does not sacrifice search speed: $d_2$ supports lookup-table ranking with only M additions per vector after a single encoder pass, and reranking the top candidates adds milliseconds even at billion scale.
  • The accuracy gains persist as the database grows from one million to one billion vectors, so the method is relevant to production-scale retrieval systems.
  • The fixed memory overhead of the network parameters is negligible at billion scale, about 0.02 bytes per vector, so the promised compression ratio is preserved.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • The same encoder-decoder design could be plugged into a self-supervised representation learning pipeline, making the quantization learnable end-to-end from raw images rather than from precomputed descriptors; the paper notes this possibility but does not demonstrate it.
  • Because $d_2$ is a learned dot-product kernel, the approach may transfer to other compressed-domain tasks such as maximum-inner-product search or classification, provided the triplet sampling is adapted to that task's notion of similarity.
  • The paper fixes codebook size K=256 and uses two-layer MLPs, so it leaves untested whether the gains persist at longer codes such as 32 or 64 bytes or on higher-dimensional descriptors.
  • A direct stress test would be to train UNQ on descriptors whose coordinates are randomly permuted per vector, destroying real neighborhood structure; if Recall@1 stays high on that data, the losses would be fitting pipeline artifacts rather than true similarity structure.
Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

4 major / 5 minor

Summary. This paper introduces Unsupervised Neural Quantization (UNQ), a deep multi-codebook quantization method for unsupervised compressed-domain similarity search. An encoder network maps descriptors into multiple discrete codebooks via a Gumbel-Softmax relaxation with straight-through gradient estimation; a decoder reconstructs the vector, and retrieval uses (i) a lookup-table distance d2 in the learned space, optionally followed by (ii) reranking of top-L candidates with d1 in the original space. Training combines a reconstruction loss, a triplet loss on d2, and a coefficient-of-variation regularizer. Experiments on Deep1M/10M/1B and BigANN1M/10M/1B at 8 and 16 bytes per vector report Recall@1/10/100 and compare against OPQ, Catalyst+OPQ, Catalyst+Lattice, LSQ, and LSQ with reranking. The paper claims a new state-of-the-art on most operating points, with a public PyTorch implementation.

Significance. If the claims withstand scrutiny, UNQ is a significant step: it is the first deep unsupervised multi-codebook quantizer that consistently beats shallow MCQ baselines on billion-scale benchmarks while preserving lookup-table search efficiency. The paper has concrete strengths: the full implementation is released; experiments span 1M to 1B scales and two descriptor types; the ablation study isolates the contribution of reranking, triplet loss, Gumbel-Softmax, and the CV regularizer; and Section 4.2 honestly reports memory overhead and notes the exceptions on Deep1B. However, the headline state-of-the-art claim is not fully supported because a stronger published baseline (LSQ++) is omitted and because the strongest baseline on deep descriptors is not given the same reranking treatment.

major comments (4)
  1. [Section 2 and Section 4.1] The paper's state-of-the-art claim is undermined by an inconsistent baseline citation. Section 2 identifies LSQ [23] as the state-of-the-art method, and reference [23] is LSQ++ (ECCV 2018); however, the experimental comparison in Section 4.1 evaluates 'LSQ[22]', which is the older LSQ from ECCV 2016, and labels it 'the state-of-the-art shallow quantization method.' Because LSQ++ was designed to improve recall over LSQ, the omitted baseline could close the often small margins in Tables 2-4 (e.g., Table 3, BigANN10M 16B R@1: 52.1 vs 50.5; Table 4, BigANN1B 16B R@1: 38.3 vs 38.0). The authors must compare against LSQ++ or explicitly justify why LSQ [22] is the correct state-of-the-art baseline.
  2. [Section 4.1, Tables 2-4] The comparison is unfair to Catalyst+Lattice, the strongest baseline on deep descriptors. UNQ's reported numbers include a reranking stage of up to 1000 candidates, and LSQ is also augmented with a learned reranker ('LSQ + rerank'), but Catalyst+Lattice is not given the same reranking option. This matters directly for the central claim: on Deep1B 8 bytes, Catalyst+Lattice already beats UNQ without reranking (Table 4: R@1 16.8 vs 14.5, R@10 38.7 vs 37.8), and a reranked Catalyst+Lattice could remove additional operating points on which UNQ claims superiority. Please add a Catalyst+Lattice+rerank baseline or restrict the claims accordingly.
  3. [Section 4, Tables 2-4] No variance information is reported for any of the recall numbers. Since training involves stochastic Gumbel-Softmax sampling, random minibatches, and hyperparameter selection, one-run point estimates cannot support the strong 'outperforms by a large margin' conclusion, especially where margins are small (e.g., Table 4, BigANN1B 16B R@1: 38.3 vs 38.0). Report means and standard deviations over multiple runs, or justify the determinism of the pipeline.
  4. [Abstract and Section 4.2] The abstract's claim of 'outperforming the previous state-of-the-art by a large margin' is contradicted by the paper's own Section 4.2, which states that on Deep1B 8 bytes, Catalyst+Lattice achieves higher R@1 and R@10 than UNQ. Since the paper later acknowledges only 'most operating points,' the abstract and Introduction's contribution bullets should be revised to reflect the qualified nature of the SOTA claim.
minor comments (5)
  1. [Equation (3)] The product in Equation (3) uses the index 'i=m' but the factor is p(c_m | x); this appears to be a typo for 'i=1'. Please correct.
  2. [Equation (4)] In Equation (4), the first element of the argmax list writes 'c0k' whereas all other codebooks are indexed from 1; this is likely a typo for 'c1k'.
  3. [Section 4.3] The 'UNQ w/o hard' ablation refers to Gumbel-Softmax 'as in [13]', but [13] is the same arXiv preprint as [12]; please clarify the distinction or cite a separate source.
  4. [Table 2 caption] The caption states that UNQ 'outperforms all the competitors on both datasets and under both memory budgets'; this is true only for the two million-scale datasets in that table, so the caption should say so explicitly to avoid implying a global statement.
  5. [Section 4.4] The paper would benefit from stating the number of training epochs, batch size, and the exact One Cycle schedule parameters in the experimental section, since the released code is the only source for these details.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: recall@k is measured on held-out queries against uncompressed ground truth, so the SOTA claim is not a fitted prediction.

full rationale

The paper's central claim is empirical retrieval accuracy. The derivation chain is: define the stochastic encoder and lookup-table distance d2 from the codeword probability model (Eqs. 2, 5, 8), then train with a reconstruction loss L1 (Eq. 9), a triplet loss L2 using true nearest neighbors sampled from the training split (Eq. 10), and a codebook-balance regularizer (Eqs. 11-12). None of these training terms equals Recall@k; they are surrogate objectives. Evaluation is performed on 10,000 hold-out queries against true nearest neighbors in uncompressed base sets, with methods trained on a separate training split, so the reported recall numbers are external measurements rather than algebraic consequences of the fitted parameters. The only self-citations are [2] (Additive Quantization background) and [3] (dataset provenance); neither is used to justify the central SOTA claim, so they are not load-bearing under hard rule 4. The comparison concerns raised by a skeptical reader -- LSQ++ [23] is named as state of the art while LSQ [22] is evaluated, and Catalyst+Lattice is not given the reranking stage -- are baseline-selection and experimental-fairness issues that belong to correctness risk, not to circularity. No equation-level reduction of a prediction to its input was found.

Assumptions & free parameters 5 free parameters · 4 assumptions · 0 invented entities

The central claim depends on several hand-chosen or learned parameters (alpha, beta, tau_m, L, architecture) and on heuristic training assumptions. No new physical or conceptual entities are introduced.

free parameters (5)
  • alpha (triplet loss weight) = not reported, grid-searched over {0.1, 0.01, 0.001}
    Chosen via grid search per experiment; the selected value for each dataset is not reported.
  • beta (CV regularizer weight) = decreased linearly from 1.0 to 0.05 during training
    Hand-designed schedule; no ablation of the schedule itself.
  • tau_m (temperatures in Eq. 2) = learned, not reported
    Stated as regular model parameters optimized by backpropagation, but final values are not given.
  • L (number of reranking candidates) = 500 for 1M/10M, 1000 for 1B
    Chosen by hand; not ablated or justified in the paper.
  • Architecture hyperparameters = two 1024-unit layers, codeword dimension 256, K=256
    Fixed for all experiments; no ablation on architecture size or depth.
assumptions (4)
  • domain assumption Euclidean distance in the original descriptor space defines the ground truth for nearest neighbor recall.
    This is the standard assumption in ANN benchmarks; the paper relies on it to compute training triplets and evaluation recall.
  • domain assumption Conditional independence of codeword selection across codebooks, Eq. (3).
    The factorization p(c1,...,cM|x) = product of p(cm|x) is assumed without theoretical justification; d2 is only an approximation of the true likelihood if codebooks are not independent.
  • ad hoc to paper Straight-through gradient estimation provides useful gradients for the discrete encoder.
    The discretization (argmax) is non-differentiable and gradients are passed through unchanged; this is a known heuristic with no convergence guarantee, and the paper relies on it.
  • ad hoc to paper The coefficient-of-variation regularizer prevents code collapse and improves retrieval quality.
    Borrowed from Mixture-of-Experts; the paper empirically shows it helps, but there is no theoretical grounding for its effect on retrieval.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Unsupervised Neural Quantization for Compressed-Domain Similarity Search." pith.science (2026). https://pith.science/paper/73GJVURA

@misc{pith2026190803883,
  author       = {Pith},
  title        = {Pith review of: Unsupervised Neural Quantization for Compressed-Domain Similarity Search},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/73GJVURA}},
  note         = {Machine review of arXiv:1908.03883}
}
read the original abstract

We tackle the problem of unsupervised visual descriptors compression, which is a key ingredient of large-scale image retrieval systems. While the deep learning machinery has benefited literally all computer vision pipelines, the existing state-of-the-art compression methods employ shallow architectures, and we aim to close this gap by our paper. In more detail, we introduce a DNN architecture for the unsupervised compressed-domain retrieval, based on multi-codebook quantization. The proposed architecture is designed to incorporate both fast data encoding and efficient distances computation via lookup tables. We demonstrate the exceptional advantage of our scheme over existing quantization approaches on several datasets of visual descriptors via outperforming the previous state-of-the-art by a large margin.

Figures

Figures reproduced from arXiv: 1908.03883 by the authors.

Figure 1
Figure 1. The proposed Unsupervised Neural Quantization model architecture. The encoder(left) maps data vector into a product of learned [PITH_FULL_IMAGE:figures/full_fig_p003_1.png] view at source ↗

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

37 extracted references · 28 canonical work pages

  1. [23]

    Hoos, and James J

    Julieta Martinez, Shobhit Zakhmi, Holger H. Hoos, and James J. Little. LSQ++: lower running time and higher re- call in multi-codebook quantization. In Computer Vision - ECCV 2018 - 15th European Conference, Munich, Germany, September 8-14, 2018, Proceedings, Part XVI , pages 508– 523, 2018. 1, 2

    work page 2018

  2. [22]

    Hoos, and James J

    Julieta Martinez, Joris Clement, Holger H. Hoos, and James J. Little. Revisiting additive quantization. In Com- puter Vision - ECCV 2016 - 14th European Conference, Am- sterdam, The Netherlands, October 11-14, 2016, Proceed- ings, Part II, pages 137–153, 2016. 1, 2, 5, 6

    work page 2016

  3. [1]

    Soft-to-hard vector quantization for end-to-end learn- ing compressible representations

    Eirikur Agustsson, Fabian Mentzer, Michael Tschannen, Lukas Cavigelli, Radu Timofte, Luca Benini, and Luc V Gool. Soft-to-hard vector quantization for end-to-end learn- ing compressible representations. In Advances in Neural In- formation Processing Systems, pages 1141–1151, 2017. 8

    work page 2017

  4. [2]

    Lempitsky

    Artem Babenko and Victor S. Lempitsky. Additive quantiza- tion for extreme vector compression. 2014. 1, 2

    work page 2014

  5. [3]

    Lempitsky

    Artem Babenko and Victor S. Lempitsky. Efficient indexing of billion-scale datasets of deep descriptors. 2016. 5

    work page 2016

  6. [4]

    Deep clustering for unsupervised learning of visual features

    Mathilde Caron, Piotr Bojanowski, Armand Joulin, and Matthijs Douze. Deep clustering for unsupervised learning of visual features. In Computer Vision - ECCV 2018 - 15th European Conference, Munich, Germany, September 8-14, 2018, Proceedings, Part XIV, pages 139–156, 2018. 3

    work page 2018

  7. [5]

    Approximate nearest neighbor search by residual vector quantization

    Yongjian Chen, Tao Guan, and Cheng Wang. Approximate nearest neighbor search by residual vector quantization. In Sensors, 2010. 2

    work page 2010

  8. [6]

    Opti- mized product quantization for approximate nearest neigh- bor search

    Tiezheng Ge, Kaiming He, Qifa Ke, and Jian Sun. Opti- mized product quantization for approximate nearest neigh- bor search. 2013. 1, 2, 5, 6

    work page 2013

Show all 37 references
  1. [7]

    Iterative quantization: A procrustean approach to learning binary codes for large-scale im- age retrieval

    Yunchao Gong, Svetlana Lazebnik, Albert Gordo, and Florent Perronnin. Iterative quantization: A procrustean approach to learning binary codes for large-scale im- age retrieval. IEEE Trans. Pattern Anal. Mach. Intell. , 35(12):2916–2929, 2013. 2

    2013

  2. [8]

    Bour- dev

    Yunchao Gong, Liu Liu, Ming Yang, and Lubomir D. Bour- dev. Compressing deep convolutional networks using vector quantization. CoRR, abs/1412.6115, 2014. 1

    2014 arXiv

  3. [9]

    Spherical hashing

    Jae-Pil Heo, Youngwoon Lee, Junfeng He, Shih-Fu Chang, and Sung-Eui Yoon. Spherical hashing. In 2012 IEEE Con- ference on Computer Vision and Pattern Recognition, Provi- dence, RI, USA, June 16-21, 2012 , pages 2957–2964, 2012. 2

    2012

  4. [10]

    Batch normalization: Accelerating deep network training by reducing internal co- variate shift

    Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal co- variate shift. In Proceedings of the 32nd International Con- ference on Machine Learning, ICML 2015, Lille, France, 6- 11 July 2015, pages 448–456, 2015. 4

    2015

  5. [11]

    Subic: A supervised, structured binary code for image search

    Himalaya Jain, Joaquin Zepeda, Patrick P ´erez, and R ´emi Gribonval. Subic: A supervised, structured binary code for image search. In IEEE International Conference on Com- puter Vision, ICCV 2017, Venice, Italy, October 22-29, 2017, pages 833–842, 2017. 1, 2

    2017

  6. [12]

    Categorical repa- rameterization with gumbel-softmax

    Eric Jang, Shixiang Gu, and Ben Poole. Categorical repa- rameterization with gumbel-softmax. 2016. 1, 3, 4

    2016

  7. [13]

    Categorical reparameterization with gumbel-softmax

    Eric Jang, Shixiang Gu, and Ben Poole. Categorical reparameterization with gumbel-softmax. arXiv preprint arXiv:1611.01144, 2016. 8

    2016 arXiv

  8. [14]

    Prod- uct quantization for nearest neighbor search

    Herv ´e J´egou, Matthijs Douze, and Cordelia Schmid. Prod- uct quantization for nearest neighbor search. IEEE Trans. Pattern Anal. Mach. Intell., 33(1):117–128, 2011. 1, 2

    2011

  9. [15]

    Searching in one billion vectors: Re-rank with source coding

    Herve Jegou, Romain Tavenard, Matthijs Douze, and Lau- rent Amsaleg. Searching in one billion vectors: Re-rank with source coding. In Proc.ICASSP, 2011. 5

    2011

  10. [16]

    Billion- scale similarity search with gpus

    Jeff Johnson, Matthijs Douze, and Herv ´e J ´egou. Billion- scale similarity search with gpus. arXiv preprint arXiv:1702.08734, 2017. 6

    2017 arXiv

  11. [17]

    Fast de- coding in sequence models using discrete latent variables

    Lukasz Kaiser, Samy Bengio, Aurko Roy, Ashish Vaswani, Niki Parmar, Jakob Uszkoreit, and Noam Shazeer. Fast de- coding in sequence models using discrete latent variables. In Proceedings of the 35th International Conference on Ma- chine Learning, ICML 2018, Stockholmsm¨assan, S...

    2018

  12. [18]

    In defense of product quan- tization

    Benjamin Klein and Lior Wolf. In defense of product quan- tization. CoRR, abs/1711.08589, 2017. 1, 2

    2017 arXiv

  13. [19]

    Hesch, Marc Pollefeys, and Roland Siegwart

    Simon Lynen, Torsten Sattler, Michael Bosse, Joel A. Hesch, Marc Pollefeys, and Roland Siegwart. Get out of my lab: Large-scale, real-time visual-inertial localization. In Robotics: Science and Systems XI, Sapienza University of Rome, Rome, Italy, July 13-17, 2015, 2015. 1

    2015

  14. [20]

    Quasi-hyperbolic momentum and adam for deep learning

    Jerry Ma and Denis Yarats. Quasi-hyperbolic momentum and adam for deep learning. CoRR, abs/1810.06801, 2018. 5

    2018 arXiv

  15. [21]

    Maddison, Andriy Mnih, and Yee Whye Teh

    Chris J. Maddison, Andriy Mnih, and Yee Whye Teh. The concrete distribution: A continuous relaxation of discrete random variables. CoRR, abs/1611.00712, 2016. 1, 3, 4

    2016 arXiv

  16. [24]

    Mohammad Norouzi and David J. Fleet. Cartesian k-means

  17. [25]

    Competitive quantization for approximate nearest neighbor search

    Ezgi Can Ozan, Serkan Kiranyaz, and Moncef Gabbouj. Competitive quantization for approximate nearest neighbor search. IEEE Trans. Knowl. Data Eng., 28(11):2884–2894,

  18. [26]

    Spreading vectors for similarity search

    Alexandre Sablayrolles, Matthijs Douze, Cordelia Schmid, and Herv ´e J ´egou. Spreading vectors for similarity search

  19. [27]

    Alexandre Sablayrolles, Matthijs Douze, Nicolas Usunier, and Herve Jegou. How should we evaluate supervised hash- ing? In 2017 IEEE International Conference on Acoustics, Speech and Signal Processing, ICASSP 2017, New Orleans, LA, USA, March 5-9, 2017, pages 1732–1736, 2017. 1

    2017

  20. [28]

    Le, Geoffrey E

    Noam Shazeer, Azalia Mirhoseini, Krzysztof Maziarz, Andy Davis, Quoc V . Le, Geoffrey E. Hinton, and Jeff Dean. Outrageously large neural networks: The sparsely-gated mixture-of-experts layer. CoRR, abs/1701.06538, 2017. 5

    2017 arXiv

  21. [29]

    Compressing word embeddings via deep compositional code learning

    Raphael Shu and Hideki Nakayama. Compressing word embeddings via deep compositional code learning. CoRR, abs/1711.01068, 2017. 4

    2017 arXiv

  22. [30]

    Super-convergence: Very fast training of neural networks using large learning rates

    Leslie N Smith and Nicholay Topin. Super-convergence: Very fast training of neural networks using large learning rates. arXiv preprint arXiv:1708.07120, 2017. 5

    2017 arXiv

  23. [31]

    Maddison, John Law- son, and Jascha Sohl-Dickstein

    George Tucker, Andriy Mnih, Chris J. Maddison, John Law- son, and Jascha Sohl-Dickstein. REBAR: low-variance, un- biased gradient estimates for discrete latent variable mod- els. In Advances in Neural Information Processing Systems 30: Annual Conference on Neural Information P...

    2017

  24. [32]

    Neural discrete representation learning

    A ¨aron van den Oord, Oriol Vinyals, and Koray Kavukcuoglu. Neural discrete representation learning. In Advances in Neural Information Processing Systems 30: Annual Conference on Neural Information Processing Systems 2017, 4-9 December 2017, Long Beach, CA, USA , pages 6309–63...

    2017

  25. [33]

    Spec- tral hashing

    Yair Weiss, Antonio Torralba, and Robert Fergus. Spec- tral hashing. In Advances in Neural Information Processing Systems 21, Proceedings of the Twenty-Second Annual Con- ference on Neural Information Processing Systems, Vancou- ver, British Columbia, Canada, December 8-11, 20...

    2008

  26. [34]

    Learning product code- books using vector quantized autoencoders for image re- trieval

    Hanwei Wu and Markus Flierl. Learning product code- books using vector quantized autoencoders for image re- trieval. CoRR, abs/1807.04629, 2018. 3

    2018 arXiv

  27. [35]

    Product quantization network for fast image retrieval

    Tan Yu, Junsong Yuan, Chen Fang, and Hailin Jin. Product quantization network for fast image retrieval. In Computer Vision - ECCV 2018 - 15th European Conference, Munich, Germany, September 8-14, 2018, Proceedings, Part I, pages 191–206, 2018. 1, 2

    2018

  28. [36]

    PQ-CNN: accelerating prod- uct quantized convolutional neural network on FPGA

    Jialiang Zhang and Jing Li. PQ-CNN: accelerating prod- uct quantized convolutional neural network on FPGA. In 26th IEEE Annual International Symposium on Field- Programmable Custom Computing Machines, FCCM 2018, Boulder, CO, USA, April 29 - May 1, 2018, page 207, 2018. 1

    2018

  29. [37]

    Composite quan- tization for approximate nearest neighbor search

    Ting Zhang, Chao Du, and Jingdong Wang. Composite quan- tization for approximate nearest neighbor search. 2014. 1, 2

    2014

Pith tools

Reviewed August 14, 2026 · model on record in the stance chip above.