Binary Stochastic Representations for Large Multi-class Classification

TL;DR

This paper introduces Deep Stochastic Neural Codes (DSNC), an end-to-end model for large multi-class classification that learns to assign binary codes to categories and map inputs to codes, maintaining sublinear inference complexity without prior tuning.

Contribution

The proposed DSNC model jointly learns binary code assignment and input-to-code mapping in an end-to-end manner, eliminating the need for heuristic code-category association.

Findings

Effective on multiple datasets compared to baselines.

Maintains sublinear inference complexity.

No need for pre-defined code-category mappings.

Abstract

Classification with a large number of classes is a key problem in machine learning and corresponds to many real-world applications like tagging of images or textual documents in social networks. If one-vs-all methods usually reach top performance in this context, these approaches suffer from a high inference complexity, linear w.r.t the number of categories. Different models based on the notion of binary codes have been proposed to overcome this limitation, achieving in a sublinear inference complexity. But they a priori need to decide which binary code to associate to which category before learning using more or less complex heuristics. We propose a new end-to-end model which aims at simultaneously learning to associate binary codes with categories, but also learning to map inputs to binary codes. This approach called Deep Stochastic Neural Codes (DSNC) keeps the sublinear inference complexity but do not need any a priori tuning. Experimental results on different datasets show the effectiveness of the approach w.r.t baseline methods.

Tables

Table 1. Table 1: Characteristics of the datasets.

Dataset Name	number of classes	number of examples
DMOZ-1K	1000	$41,846\pm 5,255$
DMOZ-12K	12275	$155,775$
ALOI	1000	$108,000$
IMAGENET	1000	$14,197,122$

Table 2. Table 2: Accuracy of the proposed model DSNC and the two baselines on the different datasets. The gray background indicates a constant decoding time.

	model	DSNC				MLP		ECOC
dataset	code size	linear	NN	linear+Reg.	NN+Reg.		Reg.
DMOZ-1K	12	31.772	22.425	33.156	23.492	39.204	39.716	10.738
	24	39.736	36.779	41.326	37.028	48.496	48.748	22.144
	36	42.928	41.208	45.414	42.776	51.48	51.716	27.589
	60	46.84	44.734	48.742	47.41	53.532	54.084	33.850
	100	49.164	46.807	50.984	49.888	54.954	55.658	38.212
	200	51.058	49.065	53.052	52.355	56.262	56.908	41.33
DMOZ-12k	12	15.09	15.2	15.34	15.24	20.05	20.18	3.8
	24	21.15	18.79	21.64	19.27	28.74	29.3	17.591
	36	24.83	22.21	25.95	24.17	32.14	32.05	21.71
	60	28.36	25.97	29.71	29.96	35.41	35.36	25.079
	100	30.42	27.6	31.98	33.94	37.45	37.23	27
	200	32.22	29.32	33.95	35.95	39.12	38.25	27.91
	400	31.96	33.02	33.6	38.65	36.71	39.75	28.08
ALOI	12	34.918	34.84	33.328	33.366	82.04	81.992	1.53
	24	67.92	63.66	66.064	64.19	88.174	87.27	4.21
	36	76.73	74.19	75.84	79.94	89.91	88.18	5.81
	60	83.478	83.19	82.66	81.74	92.22	89.78	9.03
	100	88.014	88.58	87.606	88.72	99.96	90.79	13.8
	200	91.288	91.88	90.542	91.26	95.15	92.41	22.4
IMAGENET	12	1.5	0.82	1.49	0.805	14.6	13.11	12.32
	24	15.6	7.705	9.01	4.595	53.19	53.46	32.42
	36	53.82	36.46	45.74	25.14	59.11	58.85	45.03
	60	60.07	48.61	63	53.655	60.83	63.66	56.5
	100	68.66	63.405	68.81	63.515	65.9	66.81	64.5
	200	70.67	66.935	71.61	68.54	-	67.3	69.76

Table 3. Table 3: Latent space characteristics on DMOZ-1K dataset

Corpus	Distance	24		60		100		200
		Reg	No Reg	Reg	No Reg	Reg	No Reg	Reg	No Reg
train	intra-class	$1.1\pm 1$	$2.3\pm 1$	$2.8\pm 3$	$10.9\pm 3$	$8.82\pm 6$	$23\pm 5$	$18.4\pm 11$	$59.3\pm 10$
	inter-class	$11.78\pm 0$	$11.6\pm 0$	$29.4\pm 0$	$26.6\pm 0$	$47\pm 1$	$40.8\pm 1$	$94.4\pm 2$	$72.3\pm 2$
	$\#$ codes	$8k$	$15k$	$15k$	$28k$	$24k$	$29k$	$26k$	$30k$
test	intra-class	$4.8\pm 3$	$5.9\pm 3$	$12.1\pm 6$	$16.6\pm 6$	$20.1\pm 10$	$29.6\pm 9$	$37\pm 19$	$63.9\pm 17$
	inter-class	$10.8\pm 1.$	$10.5\pm 1.$	$27.0\pm 2$	$25.6\pm 2$	$45.0\pm 3$	$41.6\pm 4$	$90.8\pm 5$	$80.6\pm 9$

Equations

$$\arg \underset{\varphi ,\theta }{\min }J(\varphi ,\theta )=$$

$$=$$

$$\nabla J(\varphi ,\theta )$$

$$=\int P_{\varphi }(\mathbf{b}|\mathbf{x})\nabla (log(P_{\varphi }(\mathbf{b}|\mathbf{x})))\nabla (\mathcal{L}(d_{\theta }(\mathbf{b}),y))P(y|\mathbf{x})P(\mathbf{x})d\mathbf{x}dyd\mathbf{b}$$

$$+\int \nabla (P_{\varphi }(\mathbf{b}|x))(\mathcal{L}(d_{\theta }(\mathbf{b}),y))P(y|\mathbf{x})P(\mathbf{x})d\mathbf{x}dyd\mathbf{b}$$

$${\nabla }_{\varphi ,\theta }J(\varphi ,\theta )\approx \frac{1}{\left|\mathcal{D}\right|}\sum _{(x,y)\in \mathcal{D}}\left[\frac{1}{M}\sum _1^M{\nabla }_{\varphi ,\theta }\left(log(\varphi \left(\mathbf{x})\right)\right)\mathcal{L}(d_{\theta }({\mathbf{b}}^{\mathbf{x}}),y)+{\nabla }_{\varphi ,\theta }\mathcal{L}\left(d_{\theta }({\mathbf{b}}^{\mathbf{x}}),y\right)\right]$$

$${\mathbf{\theta }}_{t+1}$$

$${\mathbf{\varphi }}_{t+1}$$

$${\mathcal{D}}_{intra}=[((\mathbf{x},y),({\mathbf{x}}^{\prime },y^{\prime }))\in {\mathcal{D}}^2|y=y^{\prime }]$$

$${\mathcal{D}}_{inter}=[((\mathbf{x},y),({\mathbf{x}}^{\prime },y^{\prime }))\in {\mathcal{D}}^2|y\ne y^{\prime }]$$

$$J(\mathbf{\varphi },\mathbf{\theta })=$$

$$+\beta \sum _{((\mathbf{x},y),({\mathbf{x}}^{\prime },y^{\prime }))\in {\mathcal{D}}_{intra}}\Vert \varphi (x)-\varphi (x^{\prime }){\Vert }^2$$

$$-\gamma \sum _{((\mathbf{x},y),({\mathbf{x}}^{\prime },y^{\prime }))\in {\mathcal{D}}_{inter}}\Vert \varphi (x)-\varphi (x^{\prime }){\Vert }^2$$

Full text

1 Introduction

Classification problems involving very large number of classes have progressively emerged over the last years and are attracting an increased attention in the machine learning community (for instances challenges LSHTC [1] or ImageNet [2] with up to thousands of classes). When facing such a large number of categories, one challenge is to keep the inference complexity as a reasonnable level: classical approaches have an inference complexity which is linear w.r.t the number of categories. Concerning neural networks, this complexity is due to the last layer that computes one score for each category. If the use of GPUs can drastically reduce the computation time, the complexity still remains very high. Note that one versus all techniques are, up to now, among the strongest contender in terms of classification performances for large number of classes [3].

In this paper, we propose a new deep neural model called Deep Stochastic Neural Codes (DSNC) with a sublinear inference time thanks to a discrete binary hidden layer: an input is first mapped to a small binary code and then a decoding process assigns the corresponding label. The proposed model aims to learn simultaneously which code to associate with which category and how to map inputs to codes in an end-to-end manner. The presented work is closely related to the field of binary hashing which use binary coding to index items (images, documents, …). However, the goal differs largely : semantic hashing looks to preserve similarities between the projected representations; the objective of our model is to discover codes able to represent the latent organization of the classes. Therefore, contrarily to most existing neural approaches using continuous derivation and thresholding to learn the mapping, the proposed model integrated stochastic units to sample efficiently the code space. Since our architecture involves a discrete non-differentiable layer, we propose a learning algorithm based on the Straight Through estimator proposed in [4]. The contributions of the paper are thus threefolds: 1) we propose a new family of discrete deep neural network aiming at classifying when the number of categories is large by learning to map inputs to binary codes, and codes to categories; 2) we present an end-to-end learning algorithm that do not need any a priori heavy work, the model being able to decide by itself which code to associate to which categories; 3) we show that this model is able to outperform existing techniques in term of accuracy while keeping a low inference complexity. The paper is organized as follows: section 2 presents the state of the art in multi-class classification and related work in binary hashing representation; section 3 presents the proposed model and the learning procedure; section 4 presents the evaluation of the proposed model on usual large scale datasets and the analysis of the results.

2 Related Work

One of the main issue in large scale multi-class classification is the trade-off between the prediction accuracy and the time complexity for the classification of an example - the inference time with respect to $K$ the number of classes. The classical meta-algorithm one-versus-one trains $O(K^{2})$ classifiers to pairwise discriminate labels; one-versus-rest trains $O(K)$ classifiers to distinguish each class from all the others. Both algorithms show efficient to deal with thousand classes but at the price of at best an inference time which is linear with the number of classes. Both methods are thus prohibitive when considering a very large number of classes. Different approaches have been proposed for reducing the complexity to a sublinear complexity w.r.t the number of categories. For example, especially when an existing hierarchy is available, one can use hierarchical models [5, 6, 7] classifying in logarithmic time. When the structure of the output space is unknown (no class ontology), the state of the art approach is the Error Correcting Output Code approach (ECOC, [8]): a binary code is associated to each category, and a function is learned to map any input to one possible code. Since defining binary codes of size $\log K$ is sufficient111In practice, a code of size $k\log K$ is needed with $k$ ranging between $10$ and $20$. to encode $K$ categories, the resulting inference complexity will be $O(\log K)$. But those approaches suffer from two main drawbacks: (i) choosing which code to associate to which category is usually made by hand, even by using random codes or by using complex heuristics [9, 10] that need a heavy learning process. (ii) Even if codes are carefully chosen, the performances is usually lower than classical one-vs-all approaches. Learning the mapping corresponds to multiple binary classification subtasks involving large number of classes. The ECOC performances are thus highly dependent on the separability of subsets of classes, which is know to be increasingly hardest with a growing number of classes.

On the other hand, mapping continuous representation to a binary one (known as hashing) has been a topic of growing interest in indexing large scale dataset. As large scale dataset contains an huge number of features , performing a neighbors search to retrieve similar data requires an expensive computational time. Finding hashing functions from the initial description space to a lower binary one allow to perform a nearest neighbors query in sublinear time [11]. Hashing algorithms can be divided in two categories: Local Sensitive Hashing which use random projections of the data [12, 13], and learning to hash algorithms which are data-driven, optimizing a loss function to preserve similarities [14, 15, 16]. Those algorithms have shown impressive results for performance measures related to information retrieval as mean average precision [17]. However, they fail in classification tasks due to a poor recall rate: the hash functions are designed to preserve kind of metrics in the hamming space but not to encourage discriminant codes between classes. As noted by [18], the compactness of the code is crucial: a larger code ensures a better precision measure and less false positive, but at the same time decreases the recall and more false negative are retrieved. These approaches are better to fragment original space than to perform generalization especially when the code length increases [18].

3 Deep Stochastic Neural Codes

Model description

Let consider $\mathbb{R}^{n}$ and $\mathcal{K}=\{1,2,...,K\}$ the input and the categories space respectively and $\mathcal{D}\in\mathbb{R}^{n}\times\mathcal{K}$ the training dataset. Let consider a size of code $c$ and the code space (or Hamming space) $\mathcal{B}=\{{\boldsymbol{b}}\in\{0,1\}^{c}\}$, and $b_{i}$ the i-th bit of a code ${\boldsymbol{b}}$.

Given an input $\mathbf{x}\in\mathbb{R}^{n}$, the proposed model uses three different steps for a stochastic inference of the label as illustrated by Fig. 1:

• •

the first step maps the input $\mathbf{x}$ to a probability distribution $P(\mathbf{x}|x)$ over the binary codes noted $\phi(\mathbf{x})$;

• •

the distribution is used in a second step to sample a code;

• •

the last step decodes the drawn code to a label.

To model the distribution $\phi$, we assume that the bits of a code are independents: each code bit $b_{i}$ can be modeled by a Bernoulli distribution of parameter noted $\phi_{i}(\mathbf{x})=P(b_{i}=1|\mathbf{x})$ and the probability of a code given $\mathbf{x}$ can be decomposed as $P({\boldsymbol{b}}|\mathbf{x})=\prod_{i=1}^{c}\phi_{i}(\mathbf{x})^{b_{i}}(1-\phi_{i}(\mathbf{x}))^{1-b_{i}}$.

Two functions needto be learned simultaneously: $\phi:\mathbb{R}^{n}\to[0,1]^{c}$ which encodes the input to a code distribution; and the decoding function, noted $d_{\theta}:\{0,1\}^{c}\to\mathcal{K}$, which maps a category to each code. In the inference process instead of sampling we will choose directly the most probable value for each component in respect to $\phi(\mathbf{x})$.

Given a code, we propose two different decoding methods to infer the corresponding class. The first one consists in using a function trained during the learning phase to compute the probability of each category for a given code: we will refer this decoding function as linear-decoding. The second one retrieves the nearest neighbor of the queried code among the codes encountered during the learning phase and outputs the associated class. We refer this decoding methods as nearest-neighbor-decoding.

Learning procedure

Due to the stochastic sampling of the codes, the loss for a given couple $(\mathbf{x},y)\in\mathbb{R}^{n}\times\mathcal{K}$ is expressed as an expectation over the distribution of codes determined by $\phi(\mathbf{x})$ : $E_{{\boldsymbol{b}}\sim\phi(\mathbf{x})}[\mathcal{L}(d_{\theta}({\boldsymbol{b}}),y)]$, with $\mathcal{L}$ an usual loss function (in the following we will use the negative likelihood as loss function, as it is usual in multi-class problems). The optimization problem associated to the proposed model considering ${\boldsymbol{b}}$ drawn from the distribution $\phi(\mathbf{x})$ can be written :

[TABLE]

Optimizing this function using gradient descent algorithm requires an estimation of the gradient of $J(\phi,\theta)$ :

[TABLE]

A first approach to optimize this error function consist in using the REINFORCE algorithm [19], a Monte-Carlo approximation of the gradient using $M$ sampling over $\phi$ for each example:

[TABLE]

The first term of the equation is relative to the update of the $\phi$ function and the second term to the update of the $d_{\theta}$. This approximation is unbiased, however it involves a long learning time and does not scale well in a large action space. Recent alternative methods have been developed to approximate such non-differentiable gradient problem. We propose to use the Straight-Through estimator (STE, [4]) which reported great performances. The STE estimates the gradient over a hard threshold function by considering this non-differentiable function as the identity function for the back-propagating procedure: it is an approximation gradient computation that allows to back-propagate through a single layer of such stochastic units, as clearly the sign of the derivative is coherent with the wanted weights correction. The update of the parameters is produced as follows:

[TABLE]

Structured Binary Latent Space

The main objective of the model is to guarantee a latent code space able to generalize: through the learning process, several codes can be associated to a given class. However, to avoid the fragmentation of the space as in binary hashing, codes of a same class have to be close in the latent space. Toward this objective, we introduce a regularization term to minimize the intra-class and maximize the inter-class distances. Considering the two following sets :

[TABLE]

[TABLE]

Thus the new objective function is:

[TABLE]

Where the minimization of the intra-class distance is represented by the first term 7 and the maximization of the inter-class distance by the second term 8 with $\beta$, $\gamma$ the coefficients associated to each of those regularizations.

Complexity

The complexity of the inference is essentially due to the decoding function. For the first investigated variant, the linear-decoding, the complexity is the same as usual multi-class neural networks: the inference takes $O(cK)$ operations to compute the $K$ probabilities of each class, linearly dependent to the number of classes. Concerning the nearest neighbor decoding variant, finding with brute force the nearest neighbor has a time complexity in $O(kc)$ with $k$ the number of training codes. However, nearest neighbors search in hamming space is a well known problematic and hence sub-linear methods have been developed to face the problem.

For instance, the proposed method in [11] achieves a complexity in $O(\frac{c~{}\sqrt[]{k}}{\log_{2}{k}})$. However, for both methods, all codes can be stored in memory when the size of code is small. In this case, after the model training step, all possible codes are enumerated and decoded by one of the two decoding methods to associate them the corresponding class. The time complexity is constant and negligible in this case, but the space complexity is high in $O(2^{c})$ to store the codes which prevent to use large codes.

4 Experiments

This section presents the evaluation of the proposed model on three usual large scale datasets with a large numbers of classes (see Table 1 for the detailed characteristics):

• •

ALOI [20] is a dataset of 1k classes of sift features extracted from image objects;

• •

DMOZ dataset [1] is composed of short text description preprocessed in a bag of word representation; this dataset contains $12275$ classes and a large vocabulary input size. In the evaluation, we use the complete dataset but also subsampled datasets with 1k classes which will be referred as DMOZ-1K.

• •

The last dataset is ImageNet with 1k image categories. Instead of using raw images, the features from the pre-trained model resnet-152 are used as inputs [21].

The protocol setting is identical for all datasets: $80\%$ of data are randomly drawn to form the training set, $10\%$ to be used as a validation set and the last $10\%$ as a test set where the accuracy is evaluated. The experiments are conducted using the STE gradient estimator. and using an adaptive gradient descent optimizer namely Adam [22] using mini-batch from size 100 to 1000 samples each. In all experiments, the encoder is a linear function followed by a sigmoid activation and the decoder used to train the network a linear function followed by a softmax activation.

We evaluate the proposed model DSNC with the two decoding variants - the learned linear decoder, noted linear and the nearest neighbor decoder, noted NN - and for both variants, we tested the regularization proposed in section 3, noted Reg, and without. Moreover we adapt the regularization factor during learning, in increasing the factor when ($\times 2$) the validation accuracy increase and decreasing the factor ($\times\frac{1}{2}$) when the validation accuracy decrease.

For selecting the best hyper-parameters we selected the best validation accuracy for the learning-rate and the initial values of the regularization factor.

We compare the results to a classical multi-class multi-layer perceptron (MLP) with a hidden layer fully-connected222The code size denotes in this case the number of hidden units. and to an ECOC algorithm with linear classifiers333One-versus-all algorithm has been tested with results similar to the best MLP score.. The table 2 sums up the accuracy obtained in test and the Fig. 2 shows the accuracy w.r.t. the theoretical decoding t ime achieved by DSNC with NN decoder compared to ECOC and MLP models on the DMOZ-12K dataset444All the models share the same encoding complexity (fowarding the input to the hidden layer, discrete or not). using the formulas reported in section 3. The ECOC and DSNC models on the left of the figure have a code size smaller than $30$ and thus have all the same complexity, a negligible constant decoding time as codes can be stored in memory. The model with the highest complexity - linear in the number of classes - are the MLP model (and our variant using the linear decoder not represented in the figure). The models with middle complexity, DSNC-NN and ECOC, are obtained by varying the code size between $30$ and $400$. The inference time is sub-linear w.r.t. the number of classes, the exact complexity depending on the trade-off between space and time complexity. On this dataset, the results show that our model outperforms ECOC models for a same complexity and is competitive with MLP for a great gain of complexity.

Looking into details the results of Table 2, it is remarkable that the results of the NN decoder are very close to the linear decoder: it is an indication of the generalizing ability of the learned code space. Our model outperforms the ECOC baseline and in the best setting is very close to the robust MLP baseline. The proposed regularization improves the performances of our model in most cases especially for large code size; in the case of the MLP, the regularization seems to have no effect. For the maximal inference speed-up (constant time prediction), using very short codes, the results are degraded but our model outperforms clearly the ECOC approach. When considering larger codes size, the regularized DSNC-NN outperforms in most settings all the other approach with a lower complexity. The proposed model successes to get a good trade-off between accuracy - higher than ECOC methods - and time complexity - better than the tested models.

The table 3 summarizes the distance intra-class and inter-class for the proposed model, with and without regularization for the codes of the training and the test sets. The results show that the regularization has a real impact on the learned latent space: 1) the regularization decreases the distance intra-class and increases the distance inter-class: this is an important feature to improve the nearest neighbor decoding as it allows better separation of codes of different classes; 2) the number of codes decreases with the introduction of the regularization, which indicates that the latent space is less fragmented. Moreover, less codes allows to speed-up the nearest neighbor decoding. To conclude, the experiments show that the regularization favors the learning of fewer and more compact codes improving the performances of the model.

5 Conclusion and perspectives

The presented model is a stochastic neural network architecture for multi-class classification, which learns jointly a function to map stochastically an input to a binary code and a decoder function associating codes to classes. The stochastic mapping between the input space and the latent binary space allows to explore efficiently the code space but introduces a non-differentiable layer. A Straigh-Through estimator is used to approximate the gradient and to learn the parameters. In addition, a regularization is proposed to achieve a better structure of the latent space, with fewer and more compact codes. Thanks to the finite discrete property of the latent space, the proposed model is able to retrieve the class associated to each code with a constant negligible time for small code size and in the generic case with a sublinear time w.r.t. to the number of classes. Experiments show the benefits of our model in terms of accuracy and time complexity. The presented work is thus a first step toward learning binary latent space in large multi-class classification context. Further investigations concerns mainly the adaptation of the model to multi-class multi-label context - in which an example can be tagged by multiple label - and the exploitation/analysis of the learned latent space for other classification tasks as automatic discovery of new classes and zero-shot learning.

Acknowledgments.

This publication is based upon work supported by the King Abdullah University of Science and Technology (KAUST) Office of Sponsored Research (OSR) under Award No. OSR-2015-CRG4-2639.