FastText.zip: Compressing text classification models

Introduction

Text classification is an important problem in Natural Language Processing (NLP). Real world use-cases include spam filtering or e-mail categorization. It is a core component in more complex systems such as search and ranking. Recently, deep learning techniques based on neural networks have achieved state of the art results in various NLP applications. One of the main successes of deep learning is due to the effectiveness of recurrent networks for language modeling and their application to speech recognition and machine translation (Mikolov, 2012). However, in other cases including several text classification problems, it has been shown that deep networks do not convincingly beat the prior state of the art techniques (Wang & Manning, 2012; Joulin et al., 2016).

In spite of being (typically) orders of magnitude slower to train than traditional techniques based on n-grams, neural networks are often regarded as a promising alternative due to compact model sizes, in particular for character based models. This is important for applications that need to run on systems with limited memory such as smartphones.

This paper specifically addresses the compromise between classification accuracy and the model size. We extend our previous work implemented in the fastText libraryhttps://github.com/facebookresearch/fastText. It is based on n-gram features, dimensionality reduction, and a fast approximation of the softmax classifier (Joulin et al., 2016). We show that a few key ingredients, namely feature pruning, quantization, hashing, and re-training, allow us to produce text classification models with tiny size, often less than 100kB when trained on several popular datasets, without noticeably sacrificing accuracy or speed.

We plan to publish the code and scripts required to reproduce our results as an extension of the fastText library, thereby providing strong reproducible baselines for text classifiers that optimize the compromise between the model size and accuracy. We hope that this will help the engineering community to improve existing applications by using more efficient models.

This paper is organized as follows. Section 2 introduces related work, Section 3 describes our text classification model and explains how we drastically reduce the model size. Section 4 shows the effectiveness of our approach in experiments on multiple text classification benchmarks.

Related work

Text classification is a problem that has its roots in many applications such as web search, information retrieval and document classification (Deerwester et al., 1990; Pang & Lee, 2008). Linear classifiers often obtain state-of-the-art performance while being scalable (Agarwal et al., 2014; Joachims, 1998; Joulin et al., 2016; McCallum & Nigam, 1998). They are particularly interesting when associated with the right features (Wang & Manning, 2012). They usually require storing embeddings for words and n-grams, which makes them memory inefficient.

Compression of language models.

Our work is related to compression of statistical language models. Classical approaches include feature pruning based on entropy (Stolcke, 2000) and quantization. Pruning aims to keep only the most important n-grams in the model, leaving out those with probability lower than a specified threshold. Further, the individual n-grams can be compressed by quantizing the probability value, and by storing the n-gram itself more efficiently than as a sequence of characters. Various strategies have been developed, for example using tree structures or hash functions, and are discussed in (Talbot & Brants, 2008).

Compression for similarity estimation and search.

There is a large body of literature on how to compress a set of vectors into compact codes, such that the comparison of two codes approximates a target similarity in the original space. The typical use-case of these methods considers an indexed dataset of compressed vectors, and a query for which we want to find the nearest neighbors in the indexed set. One of the most popular is Locality-sensitive hashing (LSH) by Charikar (2002), which is a binarization technique based on random projections that approximates the cosine similarity between two vectors through a monotonous function of the Hamming distance between the two corresponding binary codes. In our paper, LSH refers to this binarization strategyIn the literature, LSH refers to multiple distinct strategies related to the Johnson-Lindenstrauss lemma. For instance, LSH sometimes refers to a partitioning technique with random projections allowing for sublinear search via cell probes, see for instance the E2LSH variant of Datar et al. (2004).. Many subsequent works have improved this initial binarization technique, such as spectal hashing (Weiss et al., 2009), or Iterative Quantization (ITQ) (Gong & Lazebnik, 2011), which learns a rotation matrix minimizing the quantization loss of the binarization. We refer the reader to two recent surveys by Wang et al. (2014) and Wang et al. (2015) for an overview of the binary hashing literature.

Beyond these binarization strategies, more general quantization techniques derived from Jegou et al. (2011) offer better trade-offs between memory and the approximation of a distance estimator. The Product Quantization (PQ) method approximates the distances by calculating, in the compressed domain, the distance between their quantized approximations. This method is statistically guaranteed to preserve the Euclidean distance between the vectors within an error bound directly related to the quantization error. The original PQ has been concurrently improved by Ge et al. (2013) and Norouzi & Fleet (2013), who learn an orthogonal transform minimizing the overall quantization loss. In our paper, we will consider the Optimized Product Quantization (OPQ) variant (Ge et al., 2013).

Softmax approximation

The aforementioned works approximate either the Euclidean distance or the cosine similarity (both being equivalent in the case of unit-norm vectors). However, in the context of fastText, we are specifically interested in approximating the maximum inner product involved in a softmax layer. Several approaches derived from LSH have been recently proposed to achieve this goal, such as Asymmetric LSH by Shrivastava & Li (2014), subsequently discussed by Neyshabur & Srebro (2015). In our work, since we are not constrained to purely binary codes, we resort a more traditional encoding by employing a magnitude/direction parametrization of our vectors. Therefore we only need to encode/compress an unitary d-dimensional vector, which fits the aforementioned LSH and PQ methods well.

Neural network compression models.

Recently, several research efforts have been conducted to compress the parameters of architectures involved in computer vision, namely for state-of-the-art Convolutional Neural Networks (CNNs) (Han et al., 2016; Lin et al., 2015). Some use vector quantization (Gong et al., 2014) while others binarize the network (Courbariaux et al., 2016). Denil et al. (2013) show that such classification models are easily compressed because they are over-parametrized, which concurs with early observations by LeCun et al. (1990).

Some of these works both aim at reducing the model size and the speed. In our case, since the fastText classifier on which our proposal is built upon is already very efficient, we are primilarly interested in reducing the size of the model while keeping a comparable classification efficiency.

Proposed approach

where $x_{n}$ is a bag of one-hot vectors and $y_{n}$ the label of the $n$-th document. In the case of a large vocabulary and a large output space, the matrices $A$ and $B$ are big and can require gigabytes of memory. Below, we describe how we reduce this memory usage.

2 Bottom-up product quantization

where the different subquantizers $q_{i}:x\mapsto q_{i}(x)$ are complementary in the sense that their respective centroids lie in distinct orthogonal subspaces, i.e., $\forall i\neq j,\ \forall x,y,\ \langle q_{i}(x)|q_{j}(y)\rangle=0$. In the original PQ, the subspaces are aligned with the natural axis, while OPQ learns a rotation, which amounts to alleviating this constraint and to not depend on the original coordinate system. Another way to see this is to consider that PQ splits a given vector $x$ into $k$ subvectors $x^{i}$, $i=1\dots k$, each of dimension $d/k$: $x=[x^{1}\dots x^{i}\dots x^{k}]$, and quantizes each sub-vector using a distinct k-means quantizer. Each subvector $x^{i}$ is thus mapped to the closest centroid amongst $2^{b}$ centroids, where $b$ is the number of bits required to store the quantization index of the subquantizer, typically $b=8$. The reconstructed vector can take $2^{kb}$ distinct reproduction values, and is stored in $kb$ bits.

PQ estimates the inner product in the compressed domain as

This is a straightforward extension of the square L2 distance estimation of Jegou et al. (2011). In practice, the vector estimate $\hat{x}$ is trivially reconstructed from the codes, i.e., from the quantization indexes, by concatenating these centroids.

The two parameters involved in PQ, namely the number of subquantizers $k$ and the number of bits $b$ per quantization index, are typically set to $k\in[2,d/2]$, and $b=8$ to ensure byte-alignment.

Discussion.

PQ offers several interesting properties in our context of text classification. Firstly, the training is very fast because the subquantizers have a small number of centroids, i.e., 256 centroids for $b=8$. Secondly, at test time it allows the reconstruction of the vectors with almost no computational and memory overhead. Thirdly, it has been successfully applied in computer vision, offering much better performance than binary codes, which makes it a natural candidate to compress relatively shallow models. As observed by Sánchez & Perronnin (2011), using PQ just before the last layer incurs a very limited loss in accuracy when combined with a support vector machine.

In the context of text classification, the norms of the vectors are widely spread, typically with a ratio of 1000 between the max and the min. Therefore kmeans performs poorly because it optimizes an absolute error objective, so it maps all low-norm vectors to 0. A simple solution is to separate the norm and the angle of the vectors and to quantize them separately. This allows a quantization with no loss of performance, yet requires an extra $b$ bits per vector.

Bottom-up strategy: re-training.

The first works aiming at compressing CNN models like the one proposed by (Gong et al., 2014) used the reconstruction from off-the-shelf PQ, i.e., without any re-training. However, as observed in Sablayrolles et al. (2016), when using quantization methods like PQ, it is better to re-train the layers occurring after the quantization, so that the network can re-adjust itself to the quantization. There is a strong argument arguing for this re-training strategy: the square magnitude of vectors is reduced, on average, by the average quantization error for any quantizer satisfying the Lloyd conditions; see Jegou et al. (2011) for details.

This suggests a bottom-up learning strategy where we first quantize the input matrix, then retrain and quantize the output matrix (the input matrix being frozen). Experiments in section 4 show that it is worth adopting this strategy.

Memory savings with PQ.

In practice, the bottom-up PQ strategy offers a compression factor of 10 without any noticeable loss of performance. Without re-training, we notice a drop in accuracy between $0.1\%$ and $0.5\%$, depending on the dataset and setting; see Section 4 and the appendix.

3 Further text specific tricks

The memory usage strongly depends on the size of the vocabulary, which can be large in many text classification tasks. While it is clear that a large part of the vocabulary is useless or redundant, directly reducing the vocabulary to the most frequent words is not satisfactory: most of the frequent words, like “the” or “is” are not discriminative, in contrast to some rare words, e.g., in the context of tag prediction. In this section, we discuss a few heuristics to reduce the space taken by the dictionary. They lead to major memory reduction, in extreme cases by a factor $100$. We experimentally show that this drastic reduction is complementary with the PQ compression method, meaning that the combination of both strategies reduces the model size by a factor up to $\times 1000$ for some datasets.

Discovering which word or n-gram must be kept to preserve the overall performance is a feature selection problem. While many approaches have been proposed to select groups of variables during training (Bach et al., 2012; Meier et al., 2008), we are interested in selecting a fixed subset of $K$ words and ngrams from a pre-trained model. This can be achieved by selecting the $K$ embeddings that preserve as much of the model as possible, which can be reduced to selecting the $K$ words and ngrams associated with the highest norms.

While this approach offers major memory savings, it has one drawback occurring in some particular cases: some documents may not contained any of the $K$ best features, leading to a significant drop in performance. It is thus important to keep the $K$ best features under the condition that they cover the whole training set. More formally, the problem is to find a subset ${\mathcal{S}}$ in the feature set ${\mathcal{V}}$ that maximizes the sum of their norms $w_{s}$ under the constraint that all the documents in the training set ${\mathcal{D}}$ are covered:

where $P$ is a matrix such that $P_{ds}=1$ if the $s$-th feature is in the $d$-th document, and otherwise. This problem is directly related to set covering problems that are NP-hard (Feige, 1998). Standard greedy approaches require the storing of an inverted index or to do multiple passes over the dataset, which is prohibitive on very large dataset (Chierichetti et al., 2010). This problem can be cast as an instance of online submodular maximization with a rank constraint (Badanidiyuru et al., 2014; Bateni et al., 2010). In our case, we use a simple online parallelizable greedy approach: For each document, we verify if it is already covered by a retained feature and, if not, we add the feature with the highest norm to our set of retained features. If the number of features is below $k$, we add the features with the highest norm that have not yet been picked.

Hashing trick & Bloom filter.

On small models, the dictionary can take a significant portion of the memory. Instead of saving it, we extend the hashing trick used in Joulin et al. (2016) to both words and n-grams. This strategy is also used in Vowpal Wabbit (Agarwal et al., 2014) in the context of online training. This allows us to save around 1-2Mb with almost no overhead at test time (just the cost of computing the hashing function).

Pruning the vocabulary while using the hashing trick requires keeping a list of the indices of the $K$ remaining buckets. At test time, a binary search over the list of indices is required. It has a complexity of $O(\log(K))$ and a memory overhead of a few hundreds of kilobytes. Using Bloom filters instead reduces the complexity ${\mathcal{O}}(1)$ at test time and saves a few hundred kilobytes. However, in practice, it degrades performance.

Experiments

This section evaluates the quality of our model compression pipeline and compare it to other compression methods on different text classification problems, and to other compact text classifiers.

Our experimental pipeline is as follows: we train a model using fastText with the default setting unless specified otherwise. That is $2$M buckets, a learning rate of $0.1$ and $10$ training epochs. The dimensionality $d$ of the embeddings is set to powers of $2$ to avoid border effects that could make the interpretation of the results more difficult. As baselines, we use Locality-Sensitive Hashing (LSH) (Charikar, 2002), PQ (Jegou et al., 2011) and OPQ (Ge et al., 2013) (the non-parametric variant). Note that we use an improved version of LSH where random orthogonal matrices are used instead of random matrix projection Jégou et al. (2008). In a first series of experiments, we use the $8$ datasets and evaluation protocol of Zhang et al. (2015). These datasets contain few million documents and have at most $10$ classes. We also explore the limit of quantization on a dataset with an extremely large output space, that is a tag dataset extracted from the YFCC100M collection (Thomee et al., 2016)Data available at https://research.facebook.com/research/fasttext/, referred to as FlickrTag in the rest of this paper.

1 Small datasets

We compare three popular methods used for similarity estimation with compact codes: LSH, PQ and OPQ on the datasets released by Zhang et al. (2015). Figure 1 shows the accuracy as a function of the number of bytes used per embedding, which corresponds to the number $k$ of subvectors in the case of PQ and OPQ. See more results in the appendix. As discussed in Section 2, LSH reproduces the cosine similarity and is therefore not adapted to un-normalized data. Therefore we only report results with normalization. Once normalized, PQ and OPQ are almost lossless even when using only $k=4$ subquantizers per embedding (equivalently, bytes). We observe in practice that using $k=d/2$, i.e., half of the components of the embeddings, works well in practice. In the rest of the paper and if not stated otherwise, we focus on this setting. The difference between the normalized versions of PQ and OPQ is limited and depends on the dataset. Therefore we adopt the normalized PQ (NPQ) for the rest of this study, since it is faster to train.

Pruning.

Figure 2 shows the performance of our model with different sizes. We fix $k=d/2$ and use different pruning thresholds. NPQ offers a compression rate of $\times 10$ compared to the full model. As the pruning becomes more agressive, the overall compression can increase up up to $\times 1,000$ with little drop of performance and no additional overhead at test time. In fact, using a smaller dictionary makes the model faster at test time. We also compare with character-level Convolutional Neural Networks (CNN) (Zhang et al., 2015; Xiao & Cho, 2016). They are attractive models for text classification because they achieve similar performance with less memory usage than linear models (Xiao & Cho, 2016). Even though fastText with the default setting uses more memory, NPQ is already on par with CNNs’ memory usage. Note that CNNs are not quantized, and it would be worth seeing how much they can be quantized with no drop of performance. Such a study is beyond the scope of this paper. Our pruning is based on the norm of the embeddings according to the guidelines of Section 3.3. Table 1 compares the ranking obtained with norms to the ranking obtained using entropy, which is commonly used in unsupervised settings Stolcke (2000).

Extreme compression.

Finally, in Table 2, we explore the limit of quantized model by looking at the performance obtained for models under $64$KiB. Surprisingly, even at $64$KiB and $32$KiB, the drop of performance is only around $0.8\%$ and $1.7\%$ despite a compression rate of $\times 1,000-4,000$.

2 Large dataset: FlickrTag

In this section, we explore the limit of compression algorithms on very large datasets. Similar to Joulin et al. (2016), we consider a hashtag prediction dataset containing $312,116$ labels. We set the minimum count for words at $10$, leading to a dictionary of $1,427,667$ words. We take $10$M buckets for n-grams and a hierarchical softmax. We refer to this dataset as FlickrTag.

We are interested in understanding how the performance degrades if the classifier is also quantized (i.e., the matrix $B$ in Eq. 1) and when the pruning is at the limit of the minimum number of features required to cover the full dataset.

Table 3 shows that quantizing both the “input” matrix (i.e., $A$ in Eq. 1) and the “output” matrix (i.e., $B$) does not degrade the performance compared to the full model. We use embeddings with $d=256$ dimensions and use $k=d/2$ subquantizers. We do not use any text specific tricks, which leads to a compression factor of $8$. Note that even if the output matrix is not retrained over the embeddings, the performance is only $0.2\%$ away from the full model. As shown in the Appendix, using less subquantizers significantly decreases the performance for a small memory gain.

Pruning.

Table 4 shows how the performance evolves with pruning. We measure this effect on top of a fully quantized model. The full model misses $11.6\%$ of the test set because of missing words (some documents are either only composed of hashtags or have only rare words). There are $312,116$ labels and thus it seems reasonable to keep embeddings in the order of the million. A naive pruning with $1$M features misses about $30-40\%$ of the test set, leading to a significant drop of performance. On the other hand, even though the max-coverage pruning approach was set on the train set, it does not suffer from any coverage loss on the test set. This leads to a smaller drop of performance. If the pruning is too aggressive, however, the coverage decreases significantly.

Future Work

It may be possible to obtain further reduction of the model size in the future. One idea is to condition the size of the vectors (both for the input features and the labels) based on their frequency (Chen et al., 2015; Grave et al., 2016). For example, it is probably not worth representing the rare labels by full 256-dimensional vectors in the case of the FlickrTag dataset. Thus, conditioning the vector size on the frequency and norm seems like an interesting direction to explore in the future.

We may also consider combining the entropy and norm pruning criteria: instead of keeping the features in the model based just on the frequency or the norm, we can use both to keep a good set of features. This could help to keep features that are both frequent and discriminative, and thereby to reduce the coverage problem that we have observed.

Additionally, instead of pruning out the less useful features, we can decompose them into smaller units (Mikolov et al., 2012). For example, this can be achieved by splitting every non-discriminative word into a sequence of character trigrams. This could help in cases where training and test examples are very short (for example just a single word).

Conclusion

In this paper, we have presented several simple techniques to reduce, by several orders of magnitude, the memory complexity of certain text classifiers without sacrificing accuracy nor speed. This is achieved by applying discriminative pruning which aims to keep only important features in the trained model, and by performing quantization of the weight matrices and hashing of the dictionary.

We will publish the code as an extension of the fastText library. We hope that our work will serve as a baseline to the research community, where there is an increasing interest for comparing the performance of various deep learning text classifiers for a given number of parameters. Overall, compared to recent work based on convolutional neural networks, fastText.zip is often more accurate, while requiring several orders of magnitude less time to train on common CPUs, and incurring a fraction of the memory complexity.

References

Appendix

In the appendix, we show some additional results. The model used in these experiments only had $1$M ngram buckets. In Table 5, we show a thorough comparison of LSH, PQ and OPQ on $8$ different datasets. Table 7 summarizes the comparison with CNNs in terms of accuracy and size. Table 8 show a thorough comparison of the hashing trick and the Bloom filters.