Modeling Winner-Take-All Competition in Sparse Binary Projections
Wenye Li
cs.LG stat.ML

Research Computing at a Business University
    J. Eric Coulter
    December 30, 2023
===========================================




Inspired by the advances in biological science, the study of sparse binary projection models has attracted considerable recent research attention. The models project dense input samples into a higher-dimensional space and output sparse binary data representations after the Winner-Take-All competition, subject to the constraint that the projection matrix is also sparse and binary. Following the work along this line, we developed a supervised-WTA model when training samples with both input and output representations are available, from which the optimal projection matrix can be obtained with a simple, effective yet efficient algorithm. We further extended the model and the algorithm to an unsupervised setting where only the input representation of the samples is available. In a series of empirical evaluation on similarity search tasks, the proposed models reported significantly improved results over the state-of-the-art methods in both search accuracies and running speed. The successful results give us strong confidence that the work provides a highly practical tool to real world applications.









§ INTRODUCTION



Random projection has emerged as a powerful tool in data analysis applications <cit.>. It is often used to reduce the dimension of data samples in the Euclidean space. It provides a simple and computationally efficient way to reduce the storage complexity of the data by trading a controlled amount of representation error for faster processing speed and smaller model sizes <cit.>.

Very recently, with strong biological evidence, a sparse binary projection model called the FLY algorithm was designed and attracted people's much attention. Instead of performing dimension reduction, the algorithm increases the dimension of the input samples with a random sparse binary projection matrix. After the winner-take-all (WTA) competition that happens in the output space, the samples are converted into a set of sparse binary vectors. In similarity search tasks, it was reported that such sparse binary vectors outperformed the hashed vectors produced by the classical locality sensitive hashing (LSH) method that is based on the random dense projection <cit.>.

Following the work along this line, we proposed two models with the explicit treatment of the WTA competition. Instead of residing on the random generation of the projection matrix, one of our models seeks the optimal projection matrix under a supervised setting, while the other model operates purely in an unsupervised manner. For each model, we derived an algorithm that is surprisingly simple. In empirical evaluations, both algorithms reported significantly improved results in similarity search accuracies and running speed over the state-of-the-art approaches, and hence provided a practical tool in data analysis applications with high potential.

A note on notation. Unless specified otherwise, a capital letter, such as W, denotes a matrix. A lower-cased letter, with or without a subscript, denotes a vector or a scalar. For example w_i. denotes the i-th row, w_.j denotes the j-th column, and w_ij denotes the (i,j)-th entry of the matrix W.

The paper is organized as follows. Section <ref> introduces the necessary background. Section <ref> presents our models and the algorithms. Section <ref> reports the experiments and the results, followed by the conclusion in Section <ref>.





§ BACKGROUND





 §.§ Sparse Binary Projection Algorithms



Different from classical projection methods that commonly map data from a higher-dimensional space to a lower-dimensional space, the FLY algorithm increases the dimension of the data. It was designed by simulating the fruit fly's olfactory circuit, whose function is to associate similar odors with similar tags. Each odor is initially represented as a 50-dimensional feature vector of firing rates. To associate each odor with a tag involves three steps. Firstly, a divisive normalization step <cit.> centers the mean of the feature vector. Secondly, the dimension of the feature vector is expanded from 50 to 2,000 with a sparse binary connection matrix <cit.>, which has the same number of ones in each row. Thirdly, the WTA competition is involved as a result of strong inhibitory feedback coming from an inhibitory neuron. After the competition, all but the highest-firing 5% out of the 2,000 features are silenced <cit.>. These remaining 5% features just correspond to the tag assigned to the input odor.

The FLY algorithm can be studied as a special form of the LSH method which produces similar hashes for similar input samples. But different from the classical LSH method which reduces the data dimension, the FLY algorithm increases the dimension with a random sparse binary matrix, while ensuring the sparsity and binarization of the data in the output space. Empirically, the FLY algorithm reported improved results over the LSH method <cit.> in similarity search applications. 

The success of the FLY algorithm inspired considerable research attention, among which one of particular interest to us is the LIFTING algorithm <cit.> that removes the randomness assumption of the projection matrix, which is partially supported by most recent biological discoveries <cit.>. In the work, the projection matrix is obtained through supervised learning. Suppose training samples with both dense input representation X∈ℛ^d× n and sparse output representation Y∈{0,1}^d^'× n are available. The LIFTING algorithm seeks the projection matrix W that minimizes ‖ WX-Y‖_F^2+β‖ W‖_1/2 in the feasible region of sparse binary matrices. To solve the optimization problem, the Frank-Wolfe algorithm was found to have quite good performance <cit.>.



 §.§ Winner-Take-All Competition



Evidences in neuroscience showed that excitation and inhibition are common activities in neurons <cit.>. Based on the lateral information, some neurons raise to the excitatory state, while the others get inhibited and remain silent. Such excitation and inhibition result in competitions among neurons. Modeling neuron competitions is of key importance, with which useful applications are found in a variety of tasks <cit.>. Specifically in machine learning, the competition mechanism has motivated the design of computer algorithms for a long time, from the early self-organizing map <cit.> to more recent work in developing novel neural network architectures <cit.>.

To model the competition stage, the WTA model is routinely adopted. We are interested with the following form of the WTA model. For a d-dimensional input vector x and a given hash length k(k≪ d), a function WTA_k^d:ℛ^d→{0,1}^d outputs a vector y=WTA_k^d(x) satisfying, for each 1≤ i≤ d,

    y_i={[ 1,   ; 0,    ]
    .

Thus the output entries with value 1 just mark the positions of top-k values of x. For simplicity and without causing ambiguity, we do not differentiate whether the input/output vector of the WTA function is a row vector or a column vector.




§ MODEL





 §.§ Supervised Training




We start from a supervised setting. Let a set of samples be given in the form of X∈ℛ^d× n and Y∈{0,1 }^d^'× n with each x_.m(1≤ m≤ n) being an input sample and y_.m being its output representation satisfying y_.m_1=k for a given integer k. We assume that, for a fixed integer c [As in <cit.>, c is set to ⌊ 0.1× d ⌋ in this paper.], there exists a projection matrix W∈{0,1}^d^'× d with w_i._1=c (1≤ i≤ d^') and y_.m=WTA_k^d^'(Wx_.m).

The WTA function defined in Eq. (<ref>) satisfies:

    w_i.x_.m≥ w_j.x_.m,
 
for all 1≤ m≤ n and 1≤ i,j≤ d^'.

Now we are interested in inferring such a projection matrix W from the given data. But unfortunately, seeking the matrix directly from Eq. (<ref>) is generally hard. A matrix that satisfies all the constraints may not exist due to the noise in the observed samples. Even if it exists, the computational requirement can be non-trivial. A straightforward modeling of the problem as a linear integer program would involve d^'× d variables and O(nk(d^'-k)+d^') constraints, which is infeasible to solve even for moderately small n and d^'.

To ensure the tractability, we resort to a relaxation approach. For any feasible m, i and j, we define a measure y_im(1-y_jm)(w_i.x_.m-w_j.x_.m) to quantify the compliance with the condition in Eq. (<ref>). When y_im=1 and y_jm=0, the measure is non-negative if the condition is met; otherwise, it is negative. Naturally, we sum up the values of the measure over all m, i and j, and define

    L_s(W) = ∑_m=1^n∑_i=1^d^'∑_j=1^d^'y_im(1-y_jm)(w_i.x_.m-w_j.x_.m).


The value of L_s(W) measures how well a matrix W meets the conditions in Eq. (<ref>). Maximizing L_s with respect to W in the feasible region of sparse binary matrices provides a principled solution to seeking the projection matrix. And we call it the supervised-WTA model.

Considering that

    max L_s(W) 
       max∑_m=1^n[ d^'∑_i=1^d^'y_imw_i.x_.m-k∑_j=1^d^'w_j.x_.m] 
       max∑_m=1^n[∑_i=1^d^'y_imw_i.x_.m-k/d^'∑_i=1^d^'w_i.x_.m] 
       max∑_m=1^n[∑_i=1^d^'(y_im-k/d^')w_i.x_.m] 
       ∑_i=1^d^'max{w_i.[ ∑_m=1^nx_.m(y_im-k/d^') ]}

Therefore, maximizing L_s(W) is equivalent to d^' maximization sub-problems. Each sub-problem seeks a row vector w_i.(1≤ i≤ d^') by

    max w_i.[∑_m=1^nx_.m(y_im-k/d^') ]

subject to:

    


Denote

    ℓ_.i=∑_m=1^nx_.m(y_im-k/d^'),
 
and the optimal solution of w_i. to Eq. (<ref>) is given by

    w^*_i.=WTA_c^d(ℓ_.i).




 §.§ Unsupervised Training



The supervised-WTA model utilizes both input and output representations to learn a projection matrix. When only the input representation is available, we can extend the work to an unsupervised-WTA model, by maximizing the objective:

    L_u(W,Y) = ∑_m=1^n∑_i=1^d^'∑_j=1^d^'y_im(1-y_jm)(w_i.x_.m-w_j.x_.m)

subject to the constraints:  
w_i.∈{0,1}^1× d, w_i._1=c, y_.m∈{0,1}^d^'× 1, and y_.m_1=k 
for all 1≤ i≤ d^' and 1≤ m≤ n.

Different from the supervised model, the unsupervised model treats the unknown output representation Y as a variable, and jointly optimizes on both W and Y. To maximize L_u, an alternating algorithm can be used. Start with a random initialization of W as W^1, and solve the model iteratively. In t-th (t=1,2,⋯) iteration, maximize L_u(W^t,Y) with respect to Y and get the optimal Y^t. Then maximize L_u(W,Y^t) with respect to W and get the optimal W^t+1.

The optimal Y^t is given by:

    y^t_.m=WTA_k^d^'(W^tx_.m)

for all 1≤ m≤ n. Similarly to the supervised model, the optimal W^t+1 is given by:

    w^t+1_i.=WTA_c^d(ℓ_.i^t)

for all 1≤ i≤ d^', where ℓ_.i^t=∑_m=1^nx_.m(y_im^t-k/d^').

Denote by L_u^t=L_u(W^t,Y^t). Obviously, the sequence {L_u^t} monotonically increases for t=1,2,⋯. Therefore the alternating optimization process is guaranteed to converge when the objective value L_u^t can't be increased any more.




It is worth mentioning that the unsupervised-WTA model can be studied as a generic clustering method <cit.>. The model puts m data samples into d^' clusters and each sample belongs to k clusters. A special case of k=1 leads to a hard clustering method. Two samples with the element of one in the same output dimension indicates that they have the same cluster membership.

The unsupervised-WTA model can also be treated as a feature selection method <cit.>. This can be seen from the fact that each output dimension is associated with a subset of c features, instead of all d features in the input space. The model is able to choose these c features automatically and encode the information in the projection matrix W. A detailed discussion of the clustering and the feature selection viewpoints goes beyond the scope of this paper and is hence omitted.



 §.§ Complexity Issues



Computing the optimal solution to the supervised-WTA model is straightforward and can be implemented with high efficiency. To obtain each projection vector w_i., a naïve implementation needs O(dn+dlog c) operations, among which O(dn) are for the summation operation in Eq. (<ref>) and O(dlog c) are for the sorting operations in Eq. (<ref>) by the Heapsort algorithm <cit.>. Therefore, computing the whole projection matrix needs O(d^'dn+d^'dlog c) operations. In fact, by utilizing the sparse structure of the output matrix Y, the computational complexity for W can be further reduced to O(kdn+d^'dlog c). As seen in Section <ref>, this is a highly efficient result.

To solve the unsupervised-WTA model, in each iteration we need to compute both Y and W. Computing one Y needs O(cdn+d^'dlog k) operations by utilizing the sparse structure of W, where O(cdn) are for multiplying W with X and O(d^'dlog k) are for the sorting operations in Eq. (<ref>). Computing one W has the same complexity as in the supervised-WTA model, O(kdn+d^'dlog c). Therefore, the total complexity per iteration is O((k+c)dn+d^'dlog(kc)), which is also an efficient solution as seen in Section <ref>.

For both WTA models, the memory requirement is mainly from the matrices X, Y and W, and the storage complexity is O(dn+d^'n+d^'d), which can be further reduced to O(dn+kn+d^'c) if sparse matrix representation is adopted.

The training algorithms are parallelizable. Each vector of W and Y can be solved independently with high parallel efficiency. It is also notable that, after simple pre-processing of the training data, all computations only involve simple vector addition and scalar comparison operations.





§ EVALUATION












 §.§ General Settings



To evaluate the performance of the proposed models, we carried out a series of experiments under the following settings.

Application: Similarly to the work of <cit.>, we applied the proposed models in similarity search tasks. Similarity search aims to find similar samples to a given query object among potential candidates, according to a certain distance or similarity measure <cit.>. The complexity of accurately determining similar samples relies heavily on both the number of candidates and their dimension. Computing the distances seems straightforward, but unfortunately could often become prohibitive if the number of candidates is too large or the dimension of the data is too high.

To handle the difficulty brought by the high dimension of the input data, we can either reduce the data dimension while approximately preserving their pairwise distances, or increase the dimension but confining the data in the output space to be sparse and binary, in the hope of significantly improved search speed with the new representation.

Objective: Our major objective is to evaluate and compare the similarity search accuracies for different algorithms. Each sample in a given dataset was used, in turn, as the query object, and the other samples in the same dataset were used as the search candidates. For each query object, we compared its 100 nearest neighbors in the output space with its 100 nearest neighbors in the input space, and recorded the ratio of common neighbors in both spaces. The ratio is averaged over all query objects as the search accuracy of each algorithm. Obviously, a higher similarity search accuracy indicates a better preserving of locality structures from the input space to the output space by the algorithm.

Datasets: In the evaluation, four real datasets and five artificially generated datasets were used. The real datasets have the input representation X only; while the artificial datasets have both the input representation X and the output representation Y. Specifically these datasets are:

  
  * GLOVE <cit.>: 100- to 1000-dimensional GloVe word vectors trained on a subset of 330 million tokens from wikimedia database dumps[https://dumps.wikimedia.org/] with the 50,000 most frequent words.
  
  * ImageNet <cit.>: a large collection of images represented as 1,000-dimensional visual words quantized from SIFT features.
  
  * MNIST <cit.>: 784-dimensional images of handwritten digits in gray-scale.
  
  * SIFT <cit.>: 128-dimensional SIFT descriptors of images used for similarity search.
  
  * ARTFC: five sets of 1,000-dimensional dense vectors (X) and 2,000-dimensional sparse binary vectors (Y). For each hash length of k=2/4/8/16/32, a set of 2,000-dimensional sparse binary vectors were randomly generated with the hash length. Then the vectors were projected to 1,000-dimensional dense vectors through principal component analysis. In this way, the samples' pairwise distances are roughly preserved between the input space and the output space; i.e., x_.m-x_.m^'^2≈y_.m-y_.m^'^2 for all pairs of samples in the same set. 


Algorithms to compare: We compared the proposed supervised-WTA (denoted by SUP) model and the unsupervised-WTA (UNSUP) model with the LSH algorithm <cit.>, the fast Jonson-Lindenstrauss projection (FJL) algorithm <cit.>, the FLY algorithm <cit.> and the LIFTING algorithm <cit.>. The LSH algorithm maps d-dimensional inputs to k-dimensional dense vectors with a random dense projection matrix. The FJL algorithm is a fast implementation of the LSH algorithm with a sparse projection matrix. The FLY algorithm uses a random sparse binary matrix to map d-dimensional inputs to d^'-dimensional vectors. The LIFTING algorithm trains a sparse binary projection matrix in a supervised manner for the d-dimensional to d^'-dimensional projection. Both the FLY and the LIFTING algorithms involve a WTA competition stage in the output space to generate sparse binary vectors for each hash length.

Besides, we conducted the comparison with a number of other hashing algorithms, including iterative quantization (ITQ) <cit.>, spherical hashing (SPH) <cit.> and isotrophic hashing (ISOH) <cit.>. These algorithms were popularly used in literature to produce sparse binary data embeddings.

Computing environment: All the algorithms were implemented in MATLAB platform running on an 8-way computing server, with which a maximum of 128 threads were enabled for each algorithm. For the LIFTING algorithm, IBM CPLEX was used as the linear program solver that was needed by the Frank-Wolfe algorithm.




 §.§ Similarity Search Accuracy




We carried out the experiment on the artificial datasets and the real datasets. From each ARTFC dataset, we randomly chose 10,000 training samples with both the input (X) and the output (Y) representations, and chose another 10,000 testing samples with the input representation only. For the two proposed WTA models, we trained a sparse binary projection matrix W each based on the training data. Then we generated 2,000-dimensional sparse binary output vectors via the WTA competition after projecting the testing samples with the matrix. For the LIFTING algorithm, the same training and testing procedures were applied. For all other algorithms, we applied each of them on the testing samples to get either dense or sparse binary output vectors. Then the output vectors are used in similarity search and compared against the input vectors, as illustrated in Section <ref>.

We repeated the process for fifty runs and recorded the average accuracies. The results are given in Table <ref>. Each row shows the similarity search accuracies with a specific hash length [As in <cit.>, the hash length is defined as the number of ones in each output vector for the FLY, LIFTING and WTA algorithms. For other algorithms, it is defined as the output dimension.]. Consistent with the results reported in <cit.>, the sparse binary projection algorithms reported improved results over the classical LSH method. Among the algorithms, it is evidently shown that, with the support of the supervised information, the LIFTING and the supervised-WTA algorithms reported further improved results over the FLY algorithm. Most prominently, with the hash length k=4, the FLY algorithm has an accuracy of 6.73%, while the supervised-WTA model's accuracy reaches 66.7%, almost ten times higher. When comparing the two supervised algorithms, the supervised-WTA model outperformed the LIFTING algorithm with all hash lengths.

Among the unsupervised learning algorithms, the proposed unsupervised-WTA model reported the best performances, significantly better than the results given by the LSH, FJL, FLY, ITQ, SPH and ISOH algorithms. Its accuracies are even better than the supervised-WTA model with the hash length k=8.

On GLOVE/MNIST/SIFT datasets, only the input representation X is available. We randomly chose 10,000 samples for training and 10,000 samples for testing. As suggested in <cit.>, we computed Y^∗=_Ymin1/2‖ X^TX-Y^TY‖_F^2+γ‖ Y‖_1/2 for the training data via the Frank-Wolfe algorithm, and used Y^* as the output representation for training. Then we carried out the experiment under the same setting as on ARTFC datasets. Again the two WTA models reported evidently improved results. 

When comparing the two WTA models on these datasets, the unsupervised-WTA model performed even better than the supervised-WTA model on most tests. In cases with known X only, an approximation of Y has to be obtained through matrix factorization. The quality of this approximated Y becomes critical to the supervised-WTA model. We believe this is the major reason why the supervised model no longer excels.

Besides, we tested the algorithms' performances on a much larger ImageNet dataset with one million images for training and 10,000 images for testing. Computing the output representation Y^∗ becomes infeasible on such a large training set, and therefore the results of SUP and LIFTING were not available. Comparing the with the other available algorithms, once again the unsupervised-WTA algorithm reported significantly improved search accuracies.

In addition to the experiment on similarity search accuracies, we further investigated the influence of different input/output dimensions on the performance of the proposed models. We fixed the output dimension to d^'=2,000 while varying the input dimension from 100 to 1,000 on GloVe word vectors. We recorded the similarity search accuracies by all the algorithms. From the results in Table <ref>, we can see that the WTA models reported consistently improved results.




 §.§ Running Speed



As a practical concern, we compared the training time of the proposed WTA models with the LIFTING algorithm. In the experiment, we used the ARTFC datasets with 1,000-dimensional inputs and 2,000-dimensional outputs, and the number of training samples varied from 1,000 to 50,000. 

We recorded the training time of each algorithm to compute the sparse binary projection matrix W. On all training sets, the proposed models reported significantly faster speed than the LIFTING algorithm. With 1,000 samples (ref. Fig. <ref>), the supervised-WTA model took less than 0.2 seconds to get the optimal solution, hundreds of times faster than the LIFTING algorithm which took around 50 seconds. 

The unsupervised-WTA model needs to solve multiple W^t and Y^t iteratively. It took 10 to 20 seconds with 1,000 samples, which was slower than the supervised-WTA model but several times faster than the LIFTING algorithm. With 50,000 samples (ref. Fig. <ref>), the supervised-WTA model took less than 10 seconds, and the unsupervised-WTA model took about 400 seconds to get the solutions. For the LIFTING algorithm, we didn't finish the execution in our platform within 12 hours. All these real results were consistent with the complexity analysis given in Section <ref>, and justified the running efficiency of the proposed WTA models.

We further carried out the experiment on the much larger ImageNet dataset and reported the results in Fig. <ref>. Due to the prohibitive computation to obtain the output representations, only the results of the UNSUP algorithm are available. From the results we can see, with a hash length k=32, the algorithm took less than 200 seconds to train a projection matrix with 10K samples, and took around 6,000 seconds to train with one million samples. We believe that these are reasonably efficient and promising results to practical application scenarios.




§ CONCLUSION



With strong evidence from biological science, the study of sparse binary projection models has attracted much research attention recently. By mapping lower-dimensional dense data to higher-dimensional sparse binary vectors, the models have reported excellent empirical results and proved to be useful in practical applications. 

Sparse binary projections are tightly coupled with WTA competitions. The competition is an important stage for pattern recognition activities that happen in the brain. Accordingly, our work started from the explicit treatment of the competition, and proposed two models to seek the desired projection matrix. Specifically, one model utilizes both input and output representations of the samples, and trains the projection matrix as a supervised learning problem. The other model utilizes the input representation only and trains the matrix in an unsupervised manner, which equips the model with wider application scenarios. For each model, we developed a simple, effective and efficient algorithm. In the evaluation, the models significantly outperformed the state-of-the-art methods, in both search accuracies and running speed.

Our work potentially triggers a number of topics to study. Firstly, the algorithms for both models only involve simple vector addition and scalar comparison operations, which are highly parallelizable. Such characteristics make the computing procedures suitable to be implemented with customized hardware <cit.>, which provides a high-throughput and economical solution for large-scale data analysis applications.

Secondly, the unsupervised-WTA model provides a unified framework that combines the clustering and the feature selection techniques. We firmly believe that new applications along this line are possible. Besides, this viewpoint may provide a potential bridge that helps to make clear why the WTA competition leads to algorithms that preserve the locality structures of the data well, as reported in this paper.

Thirdly, there is potential to design new artificial neural network architectures. The WTA competition and the relaxation techniques adopted in this paper can be used as an activation function of the neurons in an artificial neural network. We warmly anticipate future work along this direction <cit.>.




§ ACKNOWLEDGMENTS


This work was supported by Shenzhen Fundamental Research Fund (JCYJ20170306141038939, KQJSCX20170728162302784).



10

bingham2001random
E. Bingham and H. Mannila.
Random projection in dimensionality reduction: applications to image
  and text data.
In SIGKDD, pages 245–250. ACM, 2001.

johnson1984extensions
W. Johnson and J. Lindenstrauss.
Extensions of Lipschitz mappings into a Hilbert space.
Contemporary Mathematics, 26(189-206):1, 1984.

dasgupta2017neural
S. Dasgupta, C. Stevens, and S. Navlakha.
A neural algorithm for a fundamental computing problem.
Science, 358(6364):793–796, 2017.

olsen2010divisive
S. Olsen, V. Bhandawat, and R. Wilson.
Divisive normalization in olfactory population codes.
Neuron, 66(2):287–299, 2010.

caron2013random
S. Caron, V. Ruta, L. Abbott, and R. Axel.
Random convergence of olfactory inputs in the drosophila mushroom
  body.
Nature, 497(7447):113, 2013.

zheng2018complete
Z. Zheng, S. Lauritzen, E. Perlman, C. Robinson, et al.
A complete electron microscopy volume of the brain of adult
  drosophila melanogaster.
Cell, 174(3):730–743, 2018.

stevens2015fly
C. Stevens.
What the fly’s nose tells the fly’s brain.
Proceedings of the National Academy of Sciences,
  112(30):9460–9465, 2015.

li2018fast
W. Li, J. Mao, Y. Zhang, and S. Cui.
Fast similarity search via optimal sparse lifting.
In NIPS, pages 176–184, 2018.

frank1956algorithm
M. Frank and P. Wolfe.
An algorithm for quadratic programming.
Naval Research Logistics, 3(1-2):95–110, 1956.

jaggi2013revisiting
M. Jaggi.
Revisiting Frank-Wolfe: Projection-free sparse convex optimization.
In ICML, pages 427–435, 2013.

turner2008olfactory
G. Turner, M. Bazhenov, and G. Laurent.
Olfactory representations by drosophila mushroom body neurons.
Journal of Neurophysiology, 99(2):734–746, 2008.

arbib2003handbook
M. Arbib.
The Handbook of Brain Theory and Neural Networks.
MIT Press, 2003.

maass2000computational
W. Maass.
On the computational power of winner-take-all.
Neural computation, 12(11):2519–2535, 2000.

kohonen1990self
T. Kohonen.
The self-organizing map.
Proceedings of the IEEE, 78(9):1464–1480, 1990.

panousis2018nonparametric
K. Panousis, S. Chatzis, and S. Theodoridis.
Nonparametric bayesian deep networks with local competition.
In ICML, 2019.

lynch2019winner
N. Lynch, C. Musco, and M. Parter.
Winner-take-all computation in spiking neural networks.
arXiv preprint arXiv:1904.12591, 2019.

jain1999data
A. Jain, N. Murty, and P. Flynn.
Data clustering: A review.
ACM Computing Surveys, 31(3):264–323, 1999.

guyon2003introduction
I. Guyon and A. Elisseeff.
An introduction to variable and feature selection.
Journal of Machine Learning Research, 3(Mar):1157–1182, 2003.

knuth1998art
D. Knuth.
The Art of Computer Programming, Sorting and Searching,
  volume 3.
Addison-Wesley, Reading, 1998.

baeza1999modern
R. Baeza-Yates and B. Ribeiro-Neto.
Modern Information Retrieval, volume 463.
ACM Press, 1999.

pennington2014glove
J. Pennington, R. Socher, and C. Manning.
Glove: Global vectors for word representation.
In EMNLP, pages 1532–1543, 2014.

russakovsky2015imagenet
O. Russakovsky, J. Deng, H. Su, et al.
Imagenet large scale visual recognition challenge.
International Journal of Computer Vision, 115(3):211–252,
  2015.

lecun1998gradient
Y. LeCun, L. Bottou, Y. Bengio, and P. Haffner.
Gradient-based learning applied to document recognition.
Proceedings of the IEEE, 86(11):2278–2324, 1998.

jegou2011product
H. Jegou, M. Douze, and C. Schmid.
Product quantization for nearest neighbor search.
IEEE Transactions on Pattern Analysis and Machine Intelligence,
  33(1):117–128, 2011.

gionis1999similarity
A. Gionis, P. Indyk, and R. Motwani.
Similarity search in high dimensions via hashing.
In VLDB, volume 99, pages 518–529, 1999.

charikar2002similarity
M. Charikar.
Similarity estimation techniques from rounding algorithms.
In STOC, pages 380–388. ACM, 2002.

ailon2009fast
N. Ailon and B. Chazelle.
The fast Johnson–Lindenstrauss transform and approximate nearest
  neighbors.
SIAM Journal on Computing, 39(1):302–322, 2009.

gong2012iterative
Y. Gong, S. Lazebnik, A. Gordo, and F. Perronnin.
Iterative quantization: A procrustean approach to learning binary
  codes for large-scale image retrieval.
IEEE Transactions on Pattern Analysis and Machine Intelligence,
  35(12):2916–2929, 2012.

heo2015spherical
J. Heo, Y. Lee, J. He, S. Chang, and S. Yoon.
Spherical hashing: Binary code embedding with hyperspheres.
IEEE Transactions on Pattern Analysis and Machine Intelligence,
  37(11):2304–2316, 2015.

kong2012isotropic
W. Kong and W. Li.
Isotropic hashing.
In NIPS, pages 1646–1654, 2012.

omondi2006fpga
A. Omondi and J. Rajapakse.
FPGA Implementations of Neural Networks, volume 365.
Springer, 2006.

pehlevan2018similarity
C. Pehlevan, A. Sengupta, and D. Chklovskii.
Why do similarity matching objectives lead to hebbian/anti-hebbian
  networks?
Neural Computation, 30(1):84–124, 2018.




