Library for fast text representation and classification.
We consider the problem of producing compact architectures for text classification, such that the full model fits in a limited amount of memory. After considering different solutions inspired by the hashing literature, we propose a method built upon product quantization to store word embeddings. While the original technique leads to a loss in accuracy, we adapt this method to circumvent quantization artefacts. Our experiments carried out on several benchmarks show that our approach typically requires two orders of magnitude less memory than fastText while being only slightly inferior with respect to accuracy. As a result, it outperforms the state of the art by a good margin in terms of the compromise between memory usage and accuracy.READ FULL TEXT VIEW PDF
Library for fast text representation and classification.
Java interface for fastText
R wrapper for fastText
Lightning Fast Language Prediction ?
Library for fast text representation and classification
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 library111https://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.
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.
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).
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) byCharikar (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 strategy222In 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 ELSH 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 byGe 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).
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 byShrivastava & 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.
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.
In the context of text classification, linear classifiers (Joulin et al., 2016) remain competitive with more sophisticated, deeper models, and are much faster to train. On top of standard tricks commonly used in linear text classification (Agarwal et al., 2014; Wang & Manning, 2012; Weinberger et al., 2009), Joulin et al. (2016) use a low rank constraint to reduce the computation burden while sharing information between different classes. This is especially useful in the case of a large output space, where rare classes may have only a few training examples. In this paper, we focus on a similar model, that is, which minimizes the softmax loss over documents:
where is a bag of one-hot vectors and the label of the -th document. In the case of a large vocabulary and a large output space, the matrices and are big and can require gigabytes of memory. Below, we describe how we reduce this memory usage.
is a popular method for compressed-domain approximate nearest neighbor search (Jegou et al., 2011). As a compression technique, it approximates a real-valued vector by finding the closest vector in a pre-defined structured set of centroids, referred to as a codebook. This codebook is not enumerated, since it is extremely large. Instead it is implicitly defined by its structure: a -dimensional vector is approximated as
where the different subquantizers are complementary in the sense that their respective centroids lie in distinct orthogonal subspaces, i.e., . 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 into subvectors , , each of dimension :
, and quantizes each sub-vector using a distinct k-means quantizer. Each subvectoris thus mapped to the closest centroid amongst centroids, where is the number of bits required to store the quantization index of the subquantizer, typically . The reconstructed vector can take distinct reproduction values, and is stored in 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 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 and the number of bits per quantization index, are typically set to , and to ensure byte-alignment.
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 . 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 bits per vector.
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.
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 and , depending on the dataset and setting; see Section 4 and the appendix.
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. 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 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 words and ngrams from a pre-trained model. This can be achieved by selecting the embeddings that preserve as much of the model as possible, which can be reduced to selecting the 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 best features, leading to a significant drop in performance. It is thus important to keep the best features under the condition that they cover the whole training set. More formally, the problem is to find a subset in the feature set that maximizes the sum of their norms under the constraint that all the documents in the training set are covered:
where is a matrix such that if the -th feature is in the -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 , we add the features with the highest norm that have not yet been picked.
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 remaining buckets. At test time, a binary search over the list of indices is required. It has a complexity of and a memory overhead of a few hundreds of kilobytes. Using Bloom filters instead reduces the complexity at test time and saves a few hundred kilobytes. However, in practice, it degrades performance.
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 M buckets, a learning rate of and
training epochs. The dimensionalityof the embeddings is set to powers of 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 projectionJégou et al. (2008). In a first series of experiments, we use the datasets and evaluation protocol of Zhang et al. (2015). These datasets contain few million documents and have at most 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)333Data available at https://research.facebook.com/research/fasttext/, referred to as FlickrTag in the rest of this paper.
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 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 subquantizers per embedding (equivalently, bytes). We observe in practice that using , 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.
Figure 2 shows the performance of our model with different sizes. We fix and use different pruning thresholds. NPQ offers a compression rate of compared to the full model. As the pruning becomes more agressive, the overall compression can increase up up to 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).
|Average diff. ||0||-0.8||-1.7||-3.5|
Finally, in Table 2, we explore the limit of quantized model by looking at the performance obtained for models under KiB. Surprisingly, even at KiB and KiB, the drop of performance is only around and despite a compression rate of .
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 labels. We set the minimum count for words at , leading to a dictionary of words. We take 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 in Eq. 1) and when the pruning is at the limit of the minimum number of features required to cover the full dataset.
|full (uncompressed)||45.4||12 GiB|
Table 3 shows that quantizing both the “input” matrix (i.e., in Eq. 1) and the “output” matrix (i.e., ) does not degrade the performance compared to the full model. We use embeddings with dimensions and use subquantizers. We do not use any text specific tricks, which leads to a compression factor of . Note that even if the output matrix is not retrained over the embeddings, the performance is only away from the full model. As shown in the Appendix, using less subquantizers significantly decreases the performance for a small memory gain.
|Model||full||Entropy pruning||Norm pruning||Max-Cover 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 of the test set because of missing words (some documents are either only composed of hashtags or have only rare words). There are labels and thus it seems reasonable to keep embeddings in the order of the million. A naive pruning with M features misses about 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.
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).
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.
Journal of Machine Learning Research, 15(1):1111–1133, 2014.
Approximation, Randomization, and Combinatorial Optimization. Algorithms and Techniques, pp. 39–52. Springer, 2010.
A comparison of event models for naive bayes text classification.In AAAI workshop on learning for text categorization, 1998.
The group lasso for logistic regression.Journal of the Royal Statistical Society: Series B (Statistical Methodology), 70(1):53–71, 2008.
Opinion mining and sentiment analysis.Foundations and trends in information retrieval, 2008.
In the appendix, we show some additional results. The model used in these experiments only had M ngram buckets. In Table 5, we show a thorough comparison of LSH, PQ and OPQ on 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.
|AG||Amz. f.||Amz. p.||DBP||Sogou||Yah.||Yelp f.||Yelp p.|
|k||co||AG||Amz. f.||Amz. p.||DBP||Sogou||Yah.||Yelp f.||Yelp p.|
|Dataset||Zhang et al. (2015)||Xiao & Cho (2016)||fastText+PQ,|
|co||AG||Amz. f.||Amz. p.||DBP||Sogou||Yah.||Yelp f.||Yelp p.|
|Input+Output, n co=1M||128||x||x||43.9||179M|