Year: 2021

Abstract:
The mushroom body of the fruit fly brain is one of the best studied systems in neuroscience. At its core it consists of a population of Kenyon cells, which receive inputs from multiple sensory modalities. These cells are inhibited by the anterior paired lateral neuron, thus creating a sparse high dimensional representation of the inputs. In this work we study a mathematical formalization of this network motif and apply it to learning the correlational structure between words and their context in a corpus of unstructured text, a common natural language processing (NLP) task. We show that this network can learn semantic representations of words and can generate both static and context-dependent word embeddings. Unlike conventional methods (e.g., BERT, GloVe) that use dense representations for word embedding, our algorithm encodes semantic meaning of words and their context in the form of sparse binary hash codes. The quality of the learned representations is evaluated on word similarity analysis, word-sense disambiguation, and document classification. It is shown that not only can the fruit fly network motif achieve performance comparable to existing methods in NLP, but, additionally, it uses only a fraction of the computational resources (shorter training time and smaller memory footprint).

heading: 1 INTRODUCTION
text: Deep learning has made tremendous advances in computer vision, natural language processing and many other areas. While taking high-level inspiration from biology, the current generation of deep learning methods are not necessarily biologically realistic. This raises the question whether biological systems can further inform the development of new network architectures and learning algorithms that can lead to competitive performance on machine learning tasks or offer additional insights into intelligent behavior. Our work is inspired by this motivation. We study a well-established neurobiological network motif from the fruit fly brain and investigate the possibility of reusing it for solving common machine learning tasks in NLP. We consider this exercise as a toy model example illustrating the possibility of “reprogramming” of naturally occurring algorithms and behaviors (clustering combinations of input stimuli from olfaction, vision, and thermo-hydro sensory system) into a target algorithm of interest (learning word embeddings from raw text) that the original biological organism does not naturally engage in.
The mushroom body (MB) is a major area of the brain responsible for processing of sensory information in fruit flies. It receives inputs from a set of projection neurons (PN) conveying information
∗Yuchen Liang is an AI Horizons Scholar, part of the Rensselaer-IBM AI Research Collaboration (AIRC).
from several sensory modalities. The major modality is olfaction [2], but there are also inputs from the PN responsible for sensing temperature and humidity [29], as well as visual inputs [45; 6]. These sensory inputs are forwarded to a population of approximately 2000 Kenyon cells (KCs) through a set of synaptic weights [26]. KCs are reciprocally connected through an anterior paired lateral (APL) neuron, which sends a strong inhibitory signal back to KCs. This recurrent network effectively implements winner-takes-all competition between KCs, and silences all but a small fraction of top activated neurons [8]. This is the network motif that we study in this paper; its schematic is shown in Fig. 1. KCs also send their outputs to mushroom body output neurons (MBONs), but this part of the MB network is not included into our mathematical model.
In computational linguistics there is a long tradition [19] of using distributional properties of linguistic units for quantifying semantic similarities between them, as summarized in the famous quote by JR Firth: “a word is characterized by the company it keeps” [14]. This idea has led to powerful tools such as Latent Semantic Analysis [9], topic modelling [3], and language models like word2vec [30], GloVe [34], and, more recently, BERT [10] which relies on the Transformer model [44]. Specifically word2vec models are trained to maximize the likelihood of a word given its context, GloVe models utilize global word-word co-occurence statistics, and BERT uses a deep neural network with attention to predict masked words (and the next sentence). As such, all these methods utilize the correlations between individual words and their context in order to learn useful word embeddings.
In our work we ask the following question: can the correlations between words and their contexts be extracted from raw text by the biological network of KCs, shown in Fig. 1? Further, how do the word representations learned by KCs differ from those obtained by existing NLP methods? Although this network has evolved to process sensory stimuli from olfaction and other modalities and not to “understand” language it uses a general purpose algorithm to embed inputs (from different modalities) into a high dimensional space with several desirable properties, which we discuss below.
Our approach relies on a recent proposal that the recurrent network of mutually inhibited KCs can be used as a “biological” model for generating sparse binary hash codes for the input data presented at the projection neuron layer [8]. It was argued that a matrix of random weights projecting from PN layer into the KCs layer leads to the highly desirable property of making the generated hash codes locality sensitive, i.e., placing similar inputs close to each other in the embedding space and pushing distinct stimuli far apart. A subsequent study [39] has demonstrated that the locality sensitivity of the hash codes can be significantly increased, compared to the random case, if the matrix of weights from PN to KCs is learned from data. The idea of using the network of KCs with random projections for NLP tasks has also been previously explored in [37], see discussion in section 6.
Biologically, there is an ongoing debate in the neuroscience community regarding whether these projections are random. For instance, [5] argues for the random model, while [47] presents evidence of the non-random structure of this network, which is related to the frequency of presented odors. Since the goal of our work is to build a useful AI system and not mimic every detail of the biological system, we adopt the data-driven synaptic weight strategy even if fruit flies may use random projections. As is clearly demonstrated in [39], learned synapses lead to better performance.
Our main contributions in this work are the following:
1. Inspired by the fruit fly network, we propose an algorithm that makes it possible to generate binary (as opposed to continuous) word embeddings for words and their context. We systematically evaluate the performance of this algorithm on word similarity task, word-sense disambiguation, and document classification.
2. We demonstrate that our binary embeddings result in tighter and better separated clusters of concepts compared to continuous GloVe embeddings, and stand in line with clustering properties of binarized versions of GloVe.
3. We show that training the fruit fly network requires an order of magnitude smaller compute time than training the classical NLP architectures, like BERT, at the expense of relatively small decrease in classification accuracy.

heading: 2 LEARNING ALGORITHM
text: Consider a training corpus. Each sentence can be decomposed into a collection of w-grams of consecutive words. If the word tokens come from a predefined vocabulary of size Nvoc, the input to the algorithm is a vector of size 2Nvoc. This vector consists of two blocks: the context (the first Nvoc elements), and the target (the remaining Nvoc elements); see Fig. 2. In this work w is assumed to be an odd integer, and the target word is assumed to be the center of the w-gram. The target word
is one-hot encoded in the target block, and the context words are binary encoded as a bag of words in the context block (no positional information is used). The window w slides along the text corpus, and for each position generates a training vector vA = {vAi } 2Nvoc i=1 , where the index A enumerates different w-grams, and index i enumerates positions in the context-target vector. These training vectors are passed to the learning algorithm. The goal of the algorithm is to learn correlations between the context and the target blocks.

heading: 2.1 MATHEMATICAL FORMULATION
text: Mathematically, the objective of the training algorithm is to distribute a set of context-target pairs among K buckets, so that similar pairs end up in similar buckets. In order to achieve this, the learning algorithm takes two inputs: a set of training vectors vA ∈ {0, 1}2Nvoc , and a vector of occurrence probabilities p = {pi = f(i mod Nvoc)} 2Nvoc i=1 ∈ R2Nvoc , where fj is the probability of observing word j in the training corpus1. The learning can be formalized as a minimization of the
1In our notation vector f has Nvoc elements, while vector p has 2Nvoc elements. Given that index i runs from 1 to 2Nvoc, notation pi = f(i mod Nvoc) is a mathematical way to concatenate two vectors f into a twice longer vector p.
energy function, see [39] for additional details, defined by
E = − ∑ A∈data
〈 Wµ̂,v A/p 〉
〈 Wµ̂,Wµ̂ 〉1/2 , where µ̂ = arg max µ
〈 Wµ,v A 〉
(1)
In this equation W ∈ RK×2Nvoc is a matrix of synaptic connections, given as W = {Wµ} = {Wµi}, projecting from PN layer (individual neurons in the layer are denoted by the index i) to the KC layer (individual neurons in the KC layer are denoted by the index µ). There are 2Nvoc neurons in the PN layer andK neurons in the KC layer. The inner product 〈X,Y〉 = ∑2Nvoc i=1 XiYi is defined as a contraction over index i of PN cells. In the numerator of the energy function the binary encoded w-gram is divided by the probabilities of occurrences of individual words element-wise, so that the numerator can be written as 〈
Wµ̂,v A/p 〉 = 2Nvoc∑ i=1 Wµ̂i vAi pi
Probabilities p are calculated based on the frequencies of words in the training corpus. The vocabulary contains Nvoc most frequent words in the corpus, thus all the elements of pi are non-zero and the element-wise division is well defined.
Intuitively, the goal of the training algorithm is to adjust the weights of the neural network so that they are aligned with w-grams that are frequently present in the training corpus. We rely on the assumption that semantically related w-grams share several “core” words, while a few individual words might be substituted by synonyms/antonyms. The minimization of the energy function (1) is accomplished by the iterative update of the weights satisfying the following learning rule [25; 39; 17]
∆Wµi = εg [∑
j
Wµjv A j ][vAi pi − (∑
j
Wµj vAj pj
) Wµi ] (2)
In this equation the activation function is equal to one for a maximally driven hidden unit (Kenyon cell), and is equal to zero otherwise
g [ xµ ] = δµ,µ̂, where µ̂ = arg max
µ
[ xµ ] (3)
The learning rate is denoted by ε, and δµ,µ̂ is a Kronecker delta symbol.

heading: 2.2 BIO-HASHING
text: After learning is complete the hash codes for the inputs can be generated in the following way. Given the binary encoded w-gram vA,
Hµ = { 1, if 〈Wµ,vA〉 in the top k of all KCs activations 0, otherwise
(4)
This is a crude mathematical approximation of the biological computation performed by the PN– KC–APL neural network [8; 39]. An input vA generates an input current 〈Wµ,vA〉 into the KC neurons using feedforward weightsWµi. The recurrent network of KCs and the APL neuron silences all but a small fraction of KCs. Those cells that remain active are assigned state 1, while the rest of the KCs are assigned the inactive state 0.
Notice, that equation (4) makes it possible to generate the hash codes for both individual words (static word embeddings like word2vec and GloVe) and phrases (similar to Transformer models). In the static case, the input vA has all zeros in the context block and a one-hot encoded word in the target block. In the context-dependent case, both blocks have binary encoded input words. Importantly, both context-dependent and static embeddings are mapped into the same space of sparse binary hash codes (a vector of K elements, with k ones in it). We show below that these hash codes capture semantic meaning of the target word and the context in which it is used. For the rest of the paper we refer to the parameter k in equation (4) as the hash length.
In order to provide an intuition behind the learning algorithm defined by the energy function (1) and weight update rule (2) and connect it to some of the existing methods in machine learning, consider
the limit when all the words have equal probabilities in the training corpus, pi = 1Nvoc . In this limit the energy function (1) reduces to the familiar spherical K-means clustering algorithm [11]. In this limit the weights of each KC correspond to the centroids of the clusters of context-target vectors. The hashing rule (4) assigns active state 1 to the k closest centroids (and inactive state 0 to the remaining ones), defined with respect to cosine similarity distance. In this simple limit the learning algorithm that we use can be viewed as a biologically plausible implementation of this classical algorithm. For real datasets the probabilities of words are different, thus this correspondence does not hold. Notice that division by the probability appears only in the expression for the energy, but not in the definition of µ̂ in equation (1). Equivalently, division by pi appears in the second bracket of equation (2), but not in the argument of the activation function g[xµ]. Thus, in the general case (for different word probabilities pi) our algorithm is not equivalent to spherical K-means on context-target vectors rescaled by the probabilities. Rather, in the general case, the closest centroid is found for a given context-target vector (via the definition of µ̂ in equation (1) - no pi involved), but the “updates of the position” of that centroid are computed by enhancing the contributions of rare words (small pi) and suppressing the contributions of frequent words (large pi). Empirically, we have found that division by the probabilities improves performance of our method compared to the case of spherical K-means (when the factor 1/p is removed from the algorithm).

heading: 3 EMPIRICAL EVALUATION
text: The KC network shown in Fig. 1 was trained on the OpenWebText Corpus [15], which is a 32GB corpus of unstructured text containing approximately 6B tokens. The details of the training protocols and the hyperparameters are reported in section 7 in the supplement.

heading: 3.1 STATIC WORD EMBEDDINGS EVALUATION
text: Our aim here is to demonstrate that the sparse embeddings obtained by the fruit fly network motif are competitive with existing state-of-the-art word embeddings such as GloVe [34] and word2vec [30] and commonly used binarization tools for these continuous embeddings. We show this by evaluating the semantic similarity of static word embeddings. Several common benchmark datasets are used: WS353 [13], MEN [4], RW [28], SimLex [21], RG-65 [38], Mturk [18]. These datasets contain pairs of words with human-annotated similarity scores between them. Following previous work [43; 42], model similarity score for binary representations is evaluated as sim(v1, v2) = (n11 + n00)/n, where n11 (n00) is the number of bits in v1 and v2 that are both 1 (0), and n is the length of v1,2. Cosine similarity is used for real-valued representations. Spearman’s correlation coefficient is calculated between this similarity and the human annotated score. The results are reported in Table 1.
We observe that our word embeddings demonstrate competitive performance compared to GloVe, but worse performance than word2vec. At the same time, our embeddings are binary, as opposed to GloVe and word2vec, which are represented by continuous vectors. Thus, it is more appropriate to compare them with commonly used binarized versions of the continuous embeddings. Specifically, we compare the performance of fruit fly embeddings with a number of state-of-the-art binarization methods such as: LSH/SimHash [7] (random contractive projections followed by binarization based on sign), RandExp [8] (random expansive projections followed by k-winner take all binarization),
ITQ [16] (iterative quantization), SH (spectral hashing) [46], PCAH [16] (PCA followed by binarization based on sign). The complete evaluation of all these methods for varying hash length is presented in Section 8; please see Tables 7, 8, 9 for binarization of pretrained GloVe, pretrained word2vec, and GloVe trained on OpenWebText. In Table 7 we also include evaluation from NLB, “Near-Lossless Binarization” [43] (autoencoder-based binarization) for the hash lengths where those results are available. Here we only present a short summary of those results for a specific (small) hash length k = 4 in Table 2.
It is clear from Table 2 that fruit fly embeddings outperform existing methods for word embedding discretization on WS353 and Mturk, and demonstrate second best result (after LSH binarization of word2vec) on MEN. In general (see Tables 7, 8, 9), we find that fruit fly embeddings are particularly powerful compared to existing methods at small hash lengths (see k = 4, 8 in the aforementioned tables). These results indicate that the fruit fly network can learn meaningful binary semantic representations directly from raw text. We also note that an added advantage of binary embeddings is that they require only a fraction (approx. 3%) of the memory footprint required for continuous word embeddings (assuming they have the same length), since a real value requires 32-bits per vector element, whereas a boolean value requires only 1-bit.

heading: 3.2 WORD CLUSTERING
text: A nice aspect of binary embeddings is that they result in tighter and better separated clusters than continuous embeddings. To evaluate this property for our method we started with hash codes for individual words and performed agglomerative clustering via complete link, using the cosine distance as the metric. The clustering algorithm was terminated at 200 clusters (we experimented with possible choices of this parameter, such as 200, 500, 1000, 2000, 3000, 5000, and arrived at similar conclusions). We repeated the same analysis for continuous GloVe, binarization of GloVe embeddings via autoencoder-like method [43], and simple discretization method of GloVe when one declares the largest k elements of each word vector to be 1 and assigns 0 to the remaining elements (for k = 50, 75, 120, 200). The results for the inter-cluster similarity vs. intra-cluster similarity are shown in Fig. 3 (panel A). It is clear from this scatter plot that the average distance between the points within a cluster is smaller (higher similarity) for all considered binary embeddings compared to GloVe embeddings. At the same time, the distance between the closest clusters is larger or equal (smaller similarity) for the fruit fly embeddings and naive discretizations with k <≈ 120. We also observe that the clusters lose detail (i.e., both intra- and inter-cluster similarity increases) as the binarization threshold gets higher (shown for Glove). However, our embeddings maintain a balance between intra- and inter-clustering similarity, and thus still capture fine-grained cluster information. For instance, inspecting the semantic structure of the clusters obtained this way, an example of the hierarchical clustering diagram (lower part of the tree containing 42 leaves) is shown in Fig. 3 (panel B). We clearly observe semantically coherent clusters resulting from the fruit fly word embeddings.

heading: 3.3 CONTEXT-DEPENDENT WORD EMBEDDINGS
text: Here, we evaluate the effectiveness of our fruit fly inspired approach for contextual word embeddings, as opposed to static (or context-independent) embeddings from above. We use the WiC [35]
and SCWS [22] benchmarks for the evaluation of context-sensitive word embeddings for word sense disambiguation. Both the datasets comprise pairs of sentences that contain a target word, and the task is to determine whether the two target words share a similar semantic meaning in the corresponding contexts. The WiC dataset is modeled as a binary prediction task, with 1 denoting that the target words have the same sense, and 0 indicating that they mean different things. The SCWS dataset is modeled as a rank prediction task, since for each pair of sentences and target words, it reports the average human similarity scores (from 10 Amazon Mechanical Turkers per pair).
Before presenting quantitative results, we qualitatively examine how the fruit fly network performs on context sentence pairs for target words “apple” and “bank” in Fig. 4. We show the top q = 10 nearest neighbor words for the context dependent target word. These examples clearly indicate that the “correct” sense of the word has been found (“apple” the device manufacturer has different nearest neighbors from the fruit, and “bank” the financial institution from the natural feature).
For the quantitative comparison, we contrast our method against contextual embeddings from BERT [10], GloVe [34], word2vec [30] and Word2Sense [33]. For BERT we use the 768- dimensional embeddings from the uncased-large model, for GloVe and word2vec we use the 300- dimensional embeddings, and for Word2Sense we use the sparse 2250-dimensional pretrained embeddings. Since BERT outputs contextual embeddings for each word in a sentence, we simply compute the cosine similarity between the embedding vectors for the target words for each pair of instances. For GloVe/word2vec, we use a context window of size w centered at each of the target words and compute the average embedding for each window and compute the cosine similarity between the two window vectors. Similar approach is used for Word2Sense, but the similarity between two embeddings is based on the Jensen-Shannon divergence [33]. For the fruit fly network, given the effectiveness of the top-q nearest neighbor words (as seen in Fig. 4), we devise a two component scoring function. The first component is the dot-product between the context-dependent hash codes for the two target words plus w length context blocks, denoted Jdot. The second is the number of
common contextual nearest neighbors of the two target words among the top-q neighbors of each (scaled to be between 0 and 1), denoted Jnn. The final score is given as J = α ·Jdot+(1−α) ·Jnn, where α ∈ [0, 1] is a hyperparameter. For all the methods, we predict a WiC pair to be positive if the score is above a threshold value θ. For SCWS, the ranking is proportional to the scores above θ, with the rest scored as zero. The hyperparameter θ is tuned for all the methods independently. Finally, for a fair comparison, all methods use the same 20k vocabulary.
We report the performance of our context-dependent word embeddings for both SCWS and WiC in Table 3 and Table 4, respectively. For both benchmarks we report the results from a 5-fold crossvalidation study, where each fold (in turn) is used as a development set, and the remaining four folds as the test set. We select the optimal hyperparameters (including θ, α, q, k, w) for all the methods using only the first fold; no training is done since we evaluate only the pretrained embeddings. The tables report the Spearman rank correlation on SCWS, and the accuracy on WiC.
On SWCS (Table 3), we see that the context-independent embeddings (using w = 0) are better for GloVe, Word2Sense and our method, with word2vec yielding the best results. The reason is that about 86.5% of the word pairs in SCWS are different words, and can be distinguished without looking at the context. Unlike SCWS, the WiC benchmark uses the same target word (with only minor variations in some cases) in both contexts, and therefore a context-independent approach is not expected to perform well. Indeed, on WiC (Table 4), we clearly observe that context-independent vectors (w = 0) are not very good, and our method, that uses the joint scoring function J combining both the hash code and nearest neighbor scores, is better than context-dependent GloVe (w = 7), word2vec (w = 5) and Word2Sense (also w = 7).

heading: 3.4 DOCUMENT CLASSIFICATION
text: We also compare our binary embeddings with GloVe [34], Word2vec [31], BERT [10] and NearLossless Binarization [43] on document classification tasks. The benchmarks we use are 20 Newsgroups [1], Stanford Sentiment Treebank [41], WOS-11967[24] and TREC-6 datasets [27]. The 20 Newsgroups dataset contains around 18,000 documents, partitioned evenly into 20 different groups; the Stanford Sentiment Treebank dataset contains movie reviews reflecting their sentiment as either positive or negative; WOS-11967 dataset contains 11967 documents with 35 categories which include 7 parents categories; and TREC-6 dataset consists of open-domain, fact-based questions divided into broad semantic categories. We use the TextCNN [23] classifier that uses all the different embeddings mentioned above. For fair comparison, we use the same model parameters (e.g., kernel size, filter dimension) while testing different embeddings. The results in Table 5 show how our sparse binary encodings are competitive with other methods.

heading: 4 COMPUTATIONAL COMPLEXITY
text: The computational complexity of our method can be evaluated by analyzing equations (2,3) for the weight updates. In these equations vA is a sparse vector, which has only w non-zero elements in it. Thus, for a minibatch of size |BS|, the computational complexity of evaluating the dot product with weights is K · w · |BS|. Additionally, the argmax operation requires K · |BS| operations. We will assume that the largest parameters in our model are the size of the corpus |A| ≈ 1010, and the size of the vocabulary Nvoc ≈ 104− 105. Additionally we use large minibatches |BS| ≈ Nvoc. Calculation of the second term in (2) requires O(K ·Nvoc) operations in addition to K ·w · |BS| operations for calculating the dot-product for each data point. Since the algorithm has to go over the entire corpus, this computation needs to be repeated |A|/|BS| times per epoch. Thus, the overall computational complexity of our method is O ( K · |A|(w + Nvoc/|BS|) ) ≈ K · |A| · w per epoch. Thus, in the
leading order it does not grow with the size of the vocabulary, which is a nice computational feature.
From the practical perspective, typical wall-clock training time and memory requirements per epoch are shown in Table 6. As is shown in Fig. 5, accurate solutions are obtained after about 2 − 3 epochs; improvements beyond that are relatively small. Thus, our algorithm is capable of producing competitive models in a couple of hours. Contrast this with approximately 24 hours training time for GloVe [34]; 4 days of training on 16 TPUs for BERTBASE; and 4 days on 64 TPUs for BERTLARGE [10] (the last two numbers assume training corpus of size 250B tokens vs. 6B tokens considered in this paper). The record breaking training time of 47 minutes for BERT requires the use of 1472 NVIDIA V100 GPUs each with 32GB of memory and a specialized DGX server architecture [32]. In our own experiments, we trained GloVe embedding on OWT corpus using the same vocabulary of 20k words that we used for the fruit fly embeddings. The wall-clock training time was approximately 10 hours on 16 threads, see details in Section 11. These are substantially larger computational resources than those required for training the fruit fly network.

heading: 5 DISCUSSION AND CONCLUSIONS
text: In this work we asked the intriguing question whether the core computational algorithm of one of the best studied networks in neuroscience – the network of KCs in the fruit fly brain – can be repurposed for solving a well defined machine learning task, namely, learning word embeddings from text. We have shown that, surprisingly, this network can indeed learn the correlations between the words and their context, and produce high quality word embeddings. On the semantic similarity task the fruit fly word embeddings outperform common methods for binarizing continuous SOTA word embeddings (applied to GloVe, word2vec, and GloVe trained on OWT) at small hash lengths. On the word-in-context task the fruit fly network outperforms GloVe by almost 3%, word2vec by more than 6%, but looses to BERT by 3.5%, see Table 4. The small gap in classification accuracy compared with BERT, however, is outweighed by the benefit of requiring significantly smaller computational resources to obtain these fruit fly embeddings, as we have explained in Section 4, see Table 6. We view this result as an example of a general statement that biologically inspired algorithms might be more compute efficient compared with their classical (non-biological) counterparts, even if they slightly lose in terms of accuracy.

heading: 6 APPENDIX A. RELATED WORK.
text: Our work builds on several ideas previously discussed in the literature. The first idea is that fruit fly olfactory network can generate high quality hash codes for the input data in random [8] and datadriven [39] cases. There are two algorithmic differences of our approach compared to these previous studies. First, our network uses representational contraction, rather than expansion when we go from the PN layer to the KCs layer. Second, [8; 39] construct hash codes for data coming from a single modality (e.g., images, or word vectors), while the goal of the present paper is to learn correlations between two different “modalities”: target word and its context. The second idea pertains to the training algorithm for learning the PN−→KCs synapses. We use a biologically plausible algorithm of [25] to do this, with modifications that take into account the wide range of frequencies of different words in the training corpus (we discuss these differences in section 2.1). Also, similarly to [8; 39] the algorithm of [25] is used for learning the representations of the data, and not correlations between two types of data (context and target) as we do in this paper.
Another closely related work [37] uses the network of KCs with random weights for generating binary hash codes for individual words. There are several differences compared to our approach. First, in our system the synaptic weights from PNs to KCs are learned and not random. We have found that learning these weights improves the performance compared to the random case. Second, unlike [37] (and unlike fruit flies), in our system the number of KCs is smaller than the number of PNs, so there is no representational expansion as we move into the “mushroom body”. This expansion is essential for the system of [37], which uses random weights. Finally, our algorithm uses a different encoding scheme at the level of PNs, see Fig. 2.

heading: 7 APPENDIX B. TRAINING PROTOCOLS AND HYPERPARAMETER CHOICES.
text: The fruit fly network was trained on the OpenWebText Corpus [15], which is a 32GB corpus of unstructured text containing approximately 6B tokens. Individual documents were concatenated and split into sentences. A collection of w-grams were extracted from each sentence by sliding a window of size w along each sentence from the beginning to the end. Sentences shorter than w were removed. The vocabulary was composed of Nvoc = 20000 most frequent tokens in the corpus.
Training was done for Nepoch. At each epoch all the w-grams were shuffled, organized in minibatches, and presented to the learning algorithm. The learning rate was linearly annealed starting from the maximal value ε0 at the first epoch to nearly zero at the last epoch.
The training algorithm has the following hyperparameters: size of the KC layer K, window w, overall number of training epochs Nepoch, initial learning rate ε0, minibatch size, and hash length k. All models presented in this paper were trained for Nepoch = 15. The optimal ranges of the hyperparameters are: learning rate is ε0 ≈ 10−4−5 ·10−4; K ≈ 200−600; w ≈ 9−15; minibatch size ≈ 2000− 15000; hash length k is reported for each individual experiment.

heading: 8 APPENDIX C. COMPARISON WITH BINARIZED GLOVE AND WORD2VEC.
text: Our aim here is to demonstrate that the fruit fly word embeddings are competitive with existing state-of-the-art binarization methods applied to GloVe and word2vec embeddings. We show this by evaluating the semantic similarity of static word embeddings, using several common benchmark datasets: WS353 [13], MEN [4], RW [28], SimLex [21], RG-65 [38], and Mturk [18]. These datasets contain pairs of words with human-annotated similarity scores between them. Specifically, we compare with GloVe [34] word embeddings2 trained on Wiki2014 and Gigaword 5, GloVe embeddings trained on OpenWebText Corpus [15] and word2vec embeddings3.
Since our representations are binary (in contrast to GloVe and word2vec), we binarize GloVe and word2vec embeddings and report their performance using a number of common hashing methods, LSH/SimHash [7] (random contractive projections followed by binarization based on sign), RandExp [8] (random expansive projections followed by k-winner take all binarization), ITQ [16] (it-
2pretrained embeddings: https://nlp.stanford.edu/projects/glove 3pretrained embeddings: https://code.google.com/archive/p/word2vec
erative quantization), SH (spectral hashing) [46], PCAH [16] (PCA followed by binarization based on sign). Where available, we include evaluation from NLB, “Near-Lossless Binarization” [43] (autoencoder-based binarization).
Following previous work [43; 42], model similarity score for binary representations is evaluated as sim(v1, v2) = (n11 + n00)/n, where n11 (n00) is the number of bits in v1 and v2 that are both 1 (0), and n is the length of v1,2. Cosine similarity is used for real-valued representations. The results are reported in Tables 7, 8 and 9. For each dataset, we report performance across a range of hash lengths {4, 8, 16, 32, 64, 128}. For methods that incorporate randomness (LSH, RandExp, ITQ), we report the average across 5 runs. ITQ, SH and PCAH in Tables 7 and 8 were trained using the top 400k most frequent words. Table 9 compares our method to GloVe trained on OpenWebText (same dataset that our method is trained on) using the same vocabulary as our method uses.
Our binary word embeddings demonstrate competitive performance compared to published methods for GloVe and word2vec binarization, and our algorithm can learn meaningful binary semantic representations directly from raw text. Importantly, our algorithm does not require training GloVe or word2vec embeddings first before binarizing them.

heading: 9 APPENDIX D. DETAILS OF TECHNICAL IMPLEMENTATION.
text: From the practical perspective, efficient implementation of the learning algorithm for the fruit fly network requires the use of sparse algebra, atomic updates, and block-sparse data access. Our algorithm is implemented in CUDA as a back-end, while python is used as an interface with the main functions.
The typical memory footprint of our approach is very small. About 100− 270MB GPU memory is allocated for the operatorsWµi,vA and temporary fields; while approximately 140GB CPU memory is needed to store the input data, array of random numbers for shuffle operations and shuffled indices. For GPU implementation, the model data is stored in the GPU’s memory, while the input data
is stored in the CPU memory. The parallelization strategy in our implementation is based on two aspects. First, each minibatch of data is divided into smaller sub-minibatches which are processed on different GPUs. Second, all the operations (dense-sparse matrix multiplications, arg max operation, and weight updates) are executed in parallel using multiple threads.

heading: 10 APPENDIX E. QUALITATIVE EVALUATION OF CONTEXTUAL EMBEDDINGS.
text: In order to evaluate the quality of contextualized embeddings we have created an online tool, which we are planning to release with the paper, that allows users to explore the representations learned by our model for various inputs (context-target pairs). For a given query the tool returns the word cloud visualizations for each of the four top activated Kenyon cells. We show some examples of the outputs produced by this tool in Fig. 6. Each query is used to generate a bag of words input vector vA. This vector is then used to compute the activations of KCs using 〈 Wµ,v A 〉
. Top four KCs with the highest activations are selected. The corresponding four weight vectors are used to generate four probability distributions of individual words learned by those KCs by passing the weights through a softmax function. For example, for one of those vectors with index µ, the probability distribution is computed as probi = SM(Wµi). These probability distributions for the top four activated KCs are visualized as word clouds. In computing the softmax only the target block of the weight vector was used (we have checked that using only the context block gives qualitatively similar word clouds).
The results indicate that the fruit fly network indeed has learned meaningful representations. Consider for example the first query. The sentence: “Entertainment industry shares rise following the premiere of the mass destruction weapon documentary” results in the four top activated KCs shown in Fig. 6. The top activated KC has the largest weights for the words “weapon”, “mass”, etc. The second activated KC is sensitive to the words “market”, “stock”, etc. This illustrates how the fruit fly network processes the queries. In this example the query refers to several distinct combinations of concepts: “weapon of mass destruction”, “stock market”, “movie industry”. Each of those concepts has a dedicated KC responsible for it. As one can see the responses are not perfect. For example in this case one would expect to have the 4-th highest activated KC, which is responsible for the “movie industry” concept to have a higher activation than the 3-rd highest KC, which is responsible for the types of “weapons of mass destruction”. But overall all the concepts picked by the KCs are meaningful and related to the query.

heading: 11 APPENDIX F. DETAILS OF GLOVE RETRAINING
text: To directly compare our method to GloVe, we trained an uninitialized GloVe model on the same OpenWebText corpus using the code provided by the original GloVe authors [34]4. This model was optimized to have the same vocab size as our model (the 20k most frequent tokens), used an embedding size of 300, and a window size of 15. The model was trained for 180 iterations at about 3 minutes, 20 seconds per iteration on 16 threads, resulting in the total training time of approximately 10 hours.

heading: 12 ACKNOWLEDGEMENTS
text: We are thankful to L.Amini, S.Chang, D.Cox, J.Hopfield, Y.Kim, and H.Strobelt for helpful discussions. This work was supported by the Rensselaer-IBM AI Research Collaboration (http://airc.rpi.edu), part of the IBM AI Horizons Network (http://ibm.biz/AIHorizons).
4https://nlp.stanford.edu/projects/glove/

Review summaries:
Although the paper does not say so, my understanding is that the proposed word embedding method actually first perform Kmeans-like clustering on the context vector shown in Figure 2. In the binary word embedding of each word, we set the dimensions corresponding to the k closest cluster centers to 1 and 0 otherwise. Most parts of the paper are describing how the simple word embedding method is related to the neural system of a fruit fly and showing the method achieves comparable performance compared with GloVe in word similarity tasks, context-sensitive word similarity datasets, and document classification tasks.

The authors present a formalization of a simple biological network (the mushroom body of the fruit fly), that allows very efficient “biologically inspired” word embeddings. They train this network to generate both static (context-independent) and context dependent embeddings, and evaluate these embeddings using several metrics comparing mainly to GloVe embeddings, and to some extent to BERT embeddings. Although the results are sometimes inferior, they are overall comparable, and importantly achieved at significantly lower computational resources. The main contribution of this work is not this specific network formalization (which is nice), but rather demonstrating that formalizing biological networks can generate more efficient algorithms, that achieve results comparable to the complex algorithms used ubiquitously.