WSABIE: Scaling Up to Large Vocabulary Image Annotation

1 Introduction

The emergence of the web as a tool for sharing information has caused a massive increase in the size of potential datasets available for machines to learn from. Millions of images on web pages have tens of thousands of possible annotations in the form of HTML tags (which can be conveniently collected by querying search engines [Torralba et al., 2008a]), tags such as in www.flickr.com, or human-curated labels such as in www.image-net.org [Deng et al., 2009]. We therefore need machine learning algorithms for image annotation that can scale to learn from and annotate such data. This includes: (i) scalable training and testing times, and (ii) scalable memory usage. In the ideal case we would like a fast algorithm that fits on a laptop, at least at annotation time. For many recently proposed models tested on small datasets, e.g. [Makadia et al., 2008], it is unclear if they satisfy these constraints.

In this work we study feasible methods for just such a goal. We consider models that learn to represent images and annotations jointly in a low dimension embedding space. Such embeddings are fast at testing time because the low dimension implies fast computations for ranking annotations. Simultaneously, the low dimension also implies small memory usage. To obtain good performance for such a model, we propose to train its parameters by learning to rank, optimizing for the top annotations in the list, e.g. optimizing precision at k (p@k). Unfortunately, such measures can be costly to train. To make training time efficient we propose the WARP loss (Weighted Approximate-Rank Pairwise loss). The WARP loss is related to the recently proposed Ordered Weighted Pairwise Classification (OWPC) loss [Usunier et al., 2009] which has been shown to be state-of-the-art on (small) text retrieval tasks. WARP uses stochastic gradient descent and a novel sampling trick to approximate ranks resulting in an efficient online optimization strategy which we show is superior to standard stochastic gradient descent applied to the same loss, enabling us to train on datasets that do not even fit in memory. Moreover, WARP can be applied to our embedding models (in fact, to arbitrary differentiable models) whereas the OWPC loss, which relies on SVMstruct cannot.

Overall the novelty of the paper is:

• (i) reporting image annotation results on a larger scale than ever previously reported (10 million training examples and 100 thousand annotations);
• (ii) showing for the first time the utility of optimizing precision at k for image annotation;
• (iii) proposing a large scale algorithm for (approximately) optimizing precision at k (WARP loss);
• (iv) showing that our embedding model yields low memory usage and fast computation time;
• (v) showing that using an embeddingmodel trainedwith the WARP loss yields better performance than any known competing approach for this task.

The structure of the paper is as follows. Section 2 defines the embedding models that we use. Section 3 defines the WARP loss and how to train our models with it. Section 4 details prior work, Section 5 describes experiments on large scale datasets, and Section 6 concludes. Note that parts of this paper were published previously in [Weston et al., 2010].

2 Joint Word-Image Model

We propose to learn a mapping into a feature space where images and annotations are both represented. The mapping functions are therefore different, but are learnt jointly to optimize the supervised loss of interest for our final task, that of annotating images. We start with a representation of images x ∈ Rd and a representation of annotations i ∈ Y = {1, . . . , Y }, indices into a dictionary of possible annotations. We then learn a mapping from the image feature space to the joint space RD :

while jointly learning a mapping for annotations:

These are chosen to be linear maps, i.e. ΦI(x) = V x and ΦW(i) = Wi, where Wi indexes the ith column of a D × Y matrix, but potentially any mapping could be used. In our work, we use sparse high dimensional feature vectors of bagsof-visual terms for image vectors x and each annotation has its own learnt representation (even if, for example, multiword annotations share words).

Our goal is to rank the possible annotations of a given image such that the highest ranked ones best describe the semantic content of the image. We consider the following model:

where the possible annotations i are ranked according to the magnitude of fi(x), largest first, and our family of models have constrained norm:

which acts as a regularizer in the same way as is used in lasso [Tibshirani, 1996]. In the next section we describe the kind of loss function we employ with our model, and thus subsequently the algorithm to train it.

3 Weighted Approximate-Rank Pairwise (WARP) Loss

We consider the task of ranking labels i ∈ Y given an example x. In our setting labeled pairs (x, y) will be provided for training where only a single annotation yi ∈ Y is labeled correct 1 . Let f(x) ∈ RY be a vector function providing a score for each of the labels, where fi(x) is the value for label i.

A class of ranking error functions was recently defined in [Usunier et al., 2009] as:

where ranky(f(x)) is the rank of the true label y given by f (x):

where I is the indicator function, and L(·) transforms this rank into a loss:

This class of functions allows one to define different choices of L(·) with different minimizers. Minimizing L with αj = 1 Y-1 would optimize the mean rank, α1 = 1 and αj>1 = 0 the proportion of top-ranked correct labels, and larger values of α in the first few positions optimize the top k in the ranked list, which is of interest for optimizing precision at k. For example, given two images, if one choice of function ranks their true labels at position 1 and position 100 respectively, and another function both at position 50, then a choice of αj = 1 Y-1 prefers these functions equally, whereas a choice of αj = 1/j prefers the first function, which gives superior precision at 1.

1 However, the methods described in this paper could be generalized to the multi-label case, naively by averaging the loss over all positive labels.

The authors of [Usunier et al., 2009] used this loss (calling their method OWPC) in an SVMstruct formalism to train on (small) text retrieval datasets, showing experimentally that the choice of αj = 1/j yields state-of-the-art results measuring precision at k. We hence adopt the same choice but are interested in a method that can: (i) train embedding models of the form (1) which cannot be trained using SVMstruct; and (ii) can be trained efficiently online when the data will not even fit into memory. In the following section we show how this can be done by employing a novel sampling trick to make stochastic gradient descent (SGD) feasible for optimizing precision at k for arbitrary differentiable models, including our embedding model formulation.

Online Learning to Rank

The loss (4) is equal to:

with the convention 0/0 = 0 when the correct label y is topranked. Using the hinge loss instead of the indicator function to add a margin and make the loss continuous, err can be approximated by:

where |t|+ is the positive part of t and rank1 y (f(x)) is the margin-penalized rank of y:

The overall risk we want to minimize is then:

An unbiased estimator of this risk can be obtained by stochastically sampling in the following way:

1. Sample a pair (x, y) according to P(x, y);
2. For the chosen (x, y) sample a violating label ¯ y such that 1 + f¯ y(x) > fy(x).

This chosen triplet (x, y, ¯ y) has contribution:

to the total risk, i.e. taking the expectation of these contributions approximates (8) because we have probability 1/rank1 y (f(x)) of drawing ¯ y in step (2) (or a contribution of 0 if rank1 y (f(x)) = 0) which accounts for the denominator of (6).

Algorithm 1 Online WARP Loss Optimization

until validation error does not improve.

This suggests for learning we can thus perform the following stochastic update procedure [Robbins and Monro, 1951] over the parameters β that define a family of possible functions f ∈ F:

where γt is the learning rate.

Weighted Approximate Ranking

To perform the SGD described above we still have two problems that make this procedure inefficient:

• (i) In step (2), we need to compute the values fi(x) for i = 1, . . . , Y to know which labels ¯ y are violators, which is expensive for large Y .
• (ii) rank1 y (f(x)) in (10) is also unknown without computing fi(x) for i ∈ Y, which again is expensive.

We propose to solve both problems with the following approach: for step (2), we sample labels i uniformly with replacement until we find a violating label.

Now if there are k = rank1 y (f(x)) violating labels, the random variable Nk which counts the number of trials in our sampling step follows a geometric distribution of parameter k Y-1 (i.e. Pr(Nk > q)=(1k Y-1 )q ). Thus k = Y -1 E[Nk] . This suggests that the value of rank1 y (f(x)) in Equation (9) may be approximated by:

where ⌊.⌋ is the floor function and N the number of trials in the sampling step.

Training Our Models

To summarize, our overall method which we call WSABIE (Web Scale Annotation by Image Embedding, pronounced "wasabi") consists of the joint word-image embedding model of Section 2 trained with the WARP loss of Section 3. The mapping matrices V and W are initialized at random with mean 0, standard deviation 1 √d , which is a common choice, e.g. as implemented in the Torch Machine Learning library 2 (which is the software we used for our experiments). Note, the initial weights are rescaled if they violate the constraints (2)-(3). Pseudocode for training with WARP loss is given in Algorithm 1. We use a fixed learning rate γ, chosen using a validation set (a decaying schedule over time t is also possible, but we did not implement that approach). The validation error in the last line of Algorithm 1 is in practice only evaluated after every hour on a subset of the validation set for computational efficiency.

4 Related Approaches

The problem of image annotation, including the related task of image classification, has been the subject of much research in the computer vision literature. However, this research mostly concentrates on tasks with a rather small number of classes, in part due to the availability of appropriate databases. Well known databases such as Caltech-256 [Griffin et al., 2007] and Pascal-VOC [Everingham et al., 2007] have a limited number of categories, ranging from 20 to 256. More recently, projects such as the TinyImage database [Torralba et al., 2008a] and ImageNet [Deng et al., 2009] have started proposing larger sets of annotated images with a larger set of categories, in the order of 104 different categories. Note that for now, even with these new large datasets, published results about image annotation/classification have concentrated on subsets pertaining to a few hundred different categories or less only, e.g. [Torralba et al., 2008a; Fergus et al., 2009]. Much research in the literature has in fact concentrated on extracting better image features, then training independently simple classifiers such as linear or kernel SVMs for each category (e.g. [Grauman and Darrell, 2007a]).

An alternative approach, championed by [Makadia et al., 2008; Torralba et al., 2008b], and others, is to use k-nearest neighbors in the image feature space. This has shown good annotation performance, in particular as the size of the training set grows. On the other hand, as the data grows, finding the exact neighbors becomes infeasible in terms of time and space requirements. Various approximate approaches have thus been proposed to alleviate this problem, ranging from trees to hashes, but can suffer from being fast but not precise, or precise but slow.

Embedding words in a low dimensional space to capture semantics is a classic (unsupervised) approach in text retrieval which has been adapted for image annotation before, for example PLSA has been used for images [Monay and Gatica-Perez, 2004] but has been shown to perform worse than (non-embedding based) supervised ranking models like PAMIR [Grangier and Bengio, 2008]. Embedding for image retrieval (rather than annotation) using KCCA was also explored in [Zhou et al., 2007].

Several loss functions have also recently been proposed to optimize the top of the ranked list. The most similar to our work is the so-called OWPC loss of [Usunier et al., 2009], which is similar to Eq. (6) except that the weight given to each pair of labels (y, i) depends on the rank of the incorrect label i rather than the rank of y. In its original formulation, the algorithm of [Usunier et al., 2009] relies on SVMstruct for the optimization, which cannot be used to train our embedding models. Moreover, even if one tries to train our models with SGD on the OWPC loss, each step would necessarily be more costly as it would require additional sampling steps to compute or approximate the rank of the incorrect label. This argument also applies to the loss functions proposed for other algorithms such as ListNet [Xia et al., 2008] or SVMmap [Yue et al., 2007] because the contribution to these losses of a single annotation is tightly bound to the scores of all other annotations. Thus, to our knowledge none of these existing methods would scale to our setup as they either cannot be trained online, or do not avoid computing fi(x) for each i ∈ Y as the WARP loss does.

2 http://torch5.sourceforge.net/

5 Experiments

5.1 Datasets

ImageNet Dataset

ImageNet [Deng et al., 2009] is a new image dataset organized according to WordNet [Fellbaum, 1998]. Concepts in WordNet, described by multiple words or word phrases, are hierarchically organized. ImageNet is a growing image dataset that attaches quality-controlled human-verified images to these concepts. We split the data into 2.5M images for training, 0.8M for validation and 0.8M for testing, removing duplicates between train, validation and test by throwing away test examples which had too close a nearest neighbor training or validation example in feature space. The most frequent annotation only appears 0.04% of the time 3 .

Web-data Dataset

We had access to a very large proprietary database of images taken from the web, together with a very noisy annotation based on anonymized user click information, processed similarly to ImageNet. The most frequent annotation appears 0.01% of the time.

Table 1 provides summary statistics of the number of images and labels for the ImageNet and Web-data datasets used in our experiments.

5.2 Image Representation

In this work we focus on learning algorithms, not feature representations. Hence, for all methods we try we use a standard bag-of-visual-terms type representation, which has a sparse vector representation. In particular, we use the bagof-terms feature setup of [Grangier and Bengio, 2008], which was shown to perform very well on the related task of image ranking. Each image is first segmented into several overlapping square blocks at various scales. Each block is then represented by the concatenation of color and edge features. These are discretized into a dictionary of d = 10, 000 blocks, by training k-means on a large corpus of images. Each image can then be represented as a bag of visual words: a histogram of the number of times each visual word was present in the image, yielding vectors in Rd with an average of d¯ø = 245 non-zero values. It takes on average 0.5 seconds to extract these features per image (and via sampling the pixels this is invariant to the resolution).

3 This is a commonly measured sanity check in case there is an annotation that occurs rather often, artificially inflating precision.

5.3 Baselines

We compare our proposed approach to several baselines: approximate k-nearest neighbors (k-NN), one-versus-rest large margin classifiers (One-Vs-Rest) of the form fi(x) = w⊤ i x trained using the Passive Aggressive algorithm [Crammer et al., 2006], or the same models trained with a ranking loss instead, which we call PAMIRIA as it is like the PAMIR model used in [Grangier and Bengio, 2008] but applied to image annotation rather than ranking. For all methods, hyperparameters are chosen via the validation set.

We tested approximate k-NN (ANN) because k-NN is not feasible. There are many flavors of approximation (see, e.g [Torralba et al., 2008b]). We chose the following: a random projection at each node of the tree is chosen with a threshold to go left or right that is the median of the projected training data to make the tree balanced. After traversing p nodes we arrive at a leaf node containing t ≈ n/2p of the original n training points from which we calculate the nearest neighbors. Choosing p trades off accuracy with speed.

5.4 Results

The results of comparing all methods on ImageNet and Webdata are summarized in Table 2. WSABIE outperforms all competing methods. We give a deeper analysis of the results, including time/space requirements in subsequent sections.

Word-Image Embeddings

Example word embeddings learnt by WSABIE for Web-data are given in Table 3 and some example image annotations are given in Table 8. Overall, we observe that the embeddings capture the semantic structure of the annotations (and images are also embedded in this space).

WARP Loss

We compared different models trained with either WARP or AUC optimization (via the margin ranking loss |1 - fy(x) + f¯x(y)|+ as is used in PAMIR [Grangier and Bengio, 2008]). The results given in Table 4 show WARP consistently gives superior performance. We also compared training time using WARP (with eq. (1), D = 100), AUC or a standard implementation of SGD for (4) where the rank (7) is computed explicitly rather than using our approximation method (note, in that case updates can be made for all violations for a given image at once) which we call OWPC-SGD. For all methods we report results using their best learning rate γ as measured on the validation set. Figure 1 shows after 36 hours WARP and AUC are well trained, but AUC does not perform as well, and OWPC-SGD has hardly got anywhere. Hence, the trick of approximating the rank introduced in Section 3 is very important for our task.

Computational Expense

A summary of the test time and space complexity of the various algorithms we compare is given in Table 5 (not including cost of pre-processing of features) as well as concrete numbers on the Web-data using a single computer, and assuming the data fits in memory (for WSABIE we give values for D = 100). In particular k-NN would take 3913 days to compute the test error on the Web data, corresponding to 103 seconds per image, making it infeasible to use. In comparison, PAMIRIA takes 0.5 seconds to compute per image and requires 8.2GB. WSABIE takes 0.17 seconds, and requires far less memory, only 82MB. In summary, WSABIE can be feasibly run on a laptop using limited resources whereas k-NN requires all the resources of an entire cluster. Moreover as kNN has time and space complexity O(n · d¯ø), where n is the number of training examples and d¯ø is the number of nonzero features, as n increases its use of resources only gets worse, whereas the other algorithms do not depend on n at test time.

Ensemble Models

Ensembles of models are known to provide a performance boost [Wolpert, 1992], so we linearly combined various pretrained WSABIE annotation models with different embedding sizes. We estimated the weights of the linear combination using the validation set in order to minimize the overall cost. Table 6 shows a summary of the results. In fact, ensembles of our model do give an impressive boost in performance. Combining 100, 200 and 300 dimensional models provides the best overall performance, while still yielding a scalable solution, both in terms of memory and time.

Ensembles of Features and Models

In this paper we have concentrated on learning algorithms, not feature representations, but of course good feature representations can improve results a lot. So far we have only used one type of feature representation, a bag of visual terms model, but many other types of feature representation appear in the literature. Here, we explore the possibility that an ensemble of feature representations can improve performance as has been shown before [Makadia et al., 2008]. We thus combined multiple feature representations which are the concatenation of various spatial [Grauman and Darrell, 2007b] and multiscale color and texton histograms [Leung and Malik, 1999] for a total of about 5 × 105 dimensions. The descriptors are somewhat sparse, with about 50000 nonzero weights per image. Some of the constituent histograms are normalized and some are not. We then perform Kernel PCA [Schoelkopf et al., 1999] on the combined feature representation using the intersection kernel [Barla et al., 2003] to produce a 1024 dimensional input vector for training WSABIE. We then train WSABIE as before. We consider both a single WSABIE model and an ensemble of trained models as in the previous section, this time with either 3 or 10 models all of dimension 100. We also compare to exact nearestneighbor using the KPCA features as the representation for finding neighbors, so we have a comparable input to WSABIE. The results are given in Table 7. Our results show an ensemble of features and of trained models gives our best performance of around 10% p@1.

Note that although the numerical performance in terms of p@k still might appear relatively low (the correct annotation is top-ranked "only" 10% of the time), this is actually much better than it seems for several reasons. Firstly, in the ImageNet task there are ∼16,000 possible labels so it is of course hard to get the right label top-ranked. Secondly, the p@k metric is in fact a worst case result. The reason for this is that there are many labels that are actually either correct or almost correct, which is not captured by this metric. This is especially true in the Web-data where annotations include synonyms or near-synonyms such as "barack obama" and "obama" (see Table 3). Similarly, predicting "toad" instead of "frog" is simply labeled as wrong in our system, which does not capture the semantics that the system got it almost right. To this end in another work we have developed a metric called sibling-precision which attempts to capture these semantics, which is detailed in [Weston et al., 2010], but we do not have space to describe it here. Overall, we believe the performance of our method actually gives a practically useful system.

6 Conclusions

We have introduced a scalable model for image annotation based upon learning a joint representation of images and annotations that optimizes top-of-the-list ranking measures.

To our knowledge this is the first data analysis of image annotation (considering all classes at once, with millions of data points) at such a scale. We have shown that our embedding model trained with the WARP loss is faster, takes less memory, and yields better performance than any known competing approach for this task. Stochastic gradient descent is the standard method for optimizing non-convex models such as our embedding model, but SGD applied to the loss function of interest is too slow, and the novelty of our training algorithm is to use an approximation of the rank, which is otherwise slow to compute, via a sampling trick that makes such optimization feasible for the first time. In fact, to the best of our knowledge this is the largest scale optimization of a rank-dependent measure attempting to maximize the precision at the top positions of the ranking reported on any dataset (not just for image annotation).

Acknowledgements

We thank N. Petrovic for his help with the k-NN experiments.