Stochastic_Depth
Code for "Deep Networks with Stochastic Depth"
view repo
Very deep convolutional networks with hundreds of layers have led to significant reductions in error on competitive benchmarks. Although the unmatched expressiveness of the many layers can be highly desirable at test time, training very deep networks comes with its own set of challenges. The gradients can vanish, the forward flow often diminishes, and the training time can be painfully slow. To address these problems, we propose stochastic depth, a training procedure that enables the seemingly contradictory setup to train short networks and use deep networks at test time. We start with very deep networks but during training, for each minibatch, randomly drop a subset of layers and bypass them with the identity function. This simple approach complements the recent success of residual networks. It reduces training time substantially and improves the test error significantly on almost all data sets that we used for evaluation. With stochastic depth we can increase the depth of residual networks even beyond 1200 layers and still yield meaningful improvements in test error (4.91
READ FULL TEXT VIEW PDF
Theoretical and empirical evidence indicates that the depth of neural
ne...
read it
Despite their success, convolutional neural networks are computationally...
read it
The increasing complexity of deep learning architectures is resulting in...
read it
In this work we propose a novel interpretation of residual networks show...
read it
Training a deep convolutional neural net typically starts with a random
...
read it
A major contributing factor to the recent advances in deep neural networ...
read it
Recently, many iterative algorithms proposed for various applications su...
read it
Code for "Deep Networks with Stochastic Depth"
Rewriting code for "Deep Networks with Stochastic Depth" http://arxiv.org/abs/1603.09382 in keras
Implementation of Stochastic Depth Networks in Keras
Implementation of Deep Networks with Stochastic Depth by chainer (Deep Networks with Stochastic Depth: https://arxiv.org/abs/1603.09382)
None
Convolutional Neural Networks (CNNs) were arguably popularized within the vision community in 2009 through AlexNet [1]
and its celebrated victory at the ImageNet competition
[2]. Since then there has been a notable shift towards CNNs in many areas of computer vision
[3, 4, 5, 6, 7, 8]. As this shift unfolds, a second trend emerges; deeper and deeper CNN architectures are being developed and trained. Whereas AlexNet had 5 convolutional layers [1], the VGG network and GoogLeNet in 2014 had 19 and 22 layers respectively [5, 7], and most recently the ResNet architecture featured 152 layers [8].Network depth is a major determinant of model expressiveness, both in theory [9, 10] and in practice [8, 5, 7]. However, very deep models also introduce new challenges: vanishing gradients in backward propagation, diminishing feature reuse in forward propagation, and long training time.
Vanishing Gradients is a well known nuisance in neural networks with many layers [11]. As the gradient information is backpropagated, repeated multiplication or convolution with small weights renders the gradient information ineffectively small in earlier layers. Several approaches exist to reduce this effect in practice, for example through careful initialization [12], hidden layer supervision [13]
, or, recently, Batch Normalization
[14].Diminishing feature reuse during forward propagation (also known as loss in information flow [15]) refers to the analogous problem to vanishing gradients in the forward direction. The features of the input instance, or those computed by earlier layers, are “washed out” through repeated multiplication or convolution with (randomly initialized) weight matrices, making it hard for later layers to identify and learn “meaningful” gradient directions. Recently, several new architectures attempt to circumvent this problem through direct identity mappings between layers, which allow the network to pass on features unimpededly from earlier layers to later layers [8, 15].
Long training time is a serious concern as networks become very deep. The forward and backward passes scale linearly with the depth of the network. Even on modern computers with multiple stateoftheart GPUs, architectures like the 152layer ResNet require several weeks to converge on the ImageNet dataset [8].
The researcher is faced with an inherent dilemma: shorter networks have the advantage that information flows efficiently forward and backward, and can therefore be trained effectively and within a reasonable amount of time. However, they are not expressive enough to represent the complex concepts that are commonplace in computer vision applications. Very deep networks have much greather model complexity, but are very difficult to train in practice and require a lot of time and patience.
In this paper, we propose deep networks with stochastic depth, a novel training algorithm that is based on the seemingly contradictory insight that ideally we would like to have a deep network during testing but a short network during training. We resolve this conflict by creating deep Residual Network [8] architectures (with hundreds or even thousands of layers) with sufficient modeling capacity; however, during training we shorten the network significantly by randomly removing a substantial fraction of layers independently for each sample or minibatch. The effect is a network with a small expected depth during training, but a large depth during testing. Although seemingly simple, this approach is surprisingly effective in practice.
In extensive experiments we observe that training with stochastic depth substantially reduces training time and test error (resulting in multiple new records to the best of our knowledge at the time of initial submission to ECCV). The reduction in training time can be attributed to the shorter forward and backward propagation, so the training time no longer scales with the full depth, but the shorter expected depth of the network. We attribute the reduction in test error to two factors: 1) shortening the (expected) depth during training reduces the chain of forward propagation steps and gradient computations, which strengthens the gradients especially in earlier layers during backward propagation; 2) networks trained with stochastic depth can be interpreted as an implicit ensemble of networks of different depths, mimicking the record breaking ensemble of depth varying ResNets trained by He et al. [8].
Many attempts have been made to improve the training of very deep networks. Earlier works adopted greedy layerwise training or better initialization schemes to alleviate the vanishing gradients and diminishing feature reuse problems [17, 18, 12]. A notable recent contribution towards training of very deep networks is Batch Normalization [14]
, which standardizes the mean and variance of hidden layers with respect to each minibatch. This approach reduces the vanishing gradients problem and yields a strong regularizing effect.
Recently, several authors introduced extra skip connections to improve the information flow during forward and backward propagation. Highway Networks [15] allow earlier representations to flow unimpededly to later layers through parameterized skip connections known as “information highways”, which can cross several layers at once. The skip connection parameters, learned during training, control the amount of information allowed on these “highways”.
simplify Highway Networks by shortcutting (mostly) with identity functions. This simplification greatly improves training efficiency, and enables more direct feature reuse. ResNets are motivated by the observation that neural networks tend to obtain higher training error as the depth increases to very large values. This is counterintuitive, as the network gains more parameters and therefore better function approximation capabilities. The authors conjecture that the networks become worse at function approximation because the gradients and training signals vanish when they are propagated through many layers. As a fix, they propose to add skip connections to the network. Formally, if denotes the output of the layer (or sequence of layers) and represents a typical convolutional transformation from layer to , we obtain
(1) 
where denotes the identity transformation and we assume a transition function [19]. Fig. 1 illustrates an example of a function , which consists of multiple convolutional and Batch Normalization layers. When the output dimensions of do not match those of , the authors redefine as a linear projection to reduce the dimensions of to match those of . The propagation rule in (1) allows the network to pass gradients and features (from the input or those learned in earlier layers) back and forth between the layers via the identity transformation .
Stochastically dropping hidden nodes or connections has been a popular regularization method for neural networks. The most notable example is Dropout [16]
, which multiplies each hidden activation by an independent Bernoulli random variable. Intuitively, Dropout reduces the effect known as “coadaptation” of hidden nodes collaborating in groups instead of independently producing useful features; it also makes an analogy with training an ensemble of exponentially many small networks. Many follow up works have been empirically successful, such as DropConnect
[20], Maxout [21] and DropIn [22].Similar to Dropout, stochastic depth can be interpreted as training an ensemble of networks, but with different depths, possibly achieving higher diversity among ensemble members than ensembling those with the same depth. Different from Dropout, we make the network shorter instead of thinner, and are motivated by a different problem. Anecdotally, Dropout loses effectiveness when used in combination with Batch Normalization [14, 23]. Our own experiments with various Dropout rates (on CIFAR10) show that Dropout gives practically no improvement when used on 110layer ResNets with Batch Normalization.
We view all of these previous approaches to be extremely valuable and consider our proposed training with stochastic depth complimentary to these efforts. In fact, in our experiments we show that training with stochastic depth is indeed very effective on ResNets with Batch Normalization.
Learning with stochastic depth is based on a simple intuition. To reduce the effective length of a neural network during training, we randomly skip layers entirely. We achieve this by introducing skip connections in the same fashion as ResNets, however the connection pattern is randomly altered for each minibatch. For each minibatch we randomly select sets of layers and remove their corresponding transformation functions, only keeping the identity skip connection. Throughout, we use the architecture described by He et al. [8]. Because the architecture already contains skip connections, it is straightforward to modify, and isolates the benefits of stochastic depth from that of the ResNet identity connections. Next we describe this network architecture and then explain the stochastic depth training procedure in detail.
Following He et al. [8], we construct our network as the functional composition of residual blocks (ResBlocks), each encoding the update rule (1). Fig. 1 shows a schematic illustration of the ResBlock. In this example, consists of a sequence of layers:
ConvBNReLUConvBN
, where Conv and BN stand for Convolution and Batch Normalization respectively. This construction scheme is adopted in all our experiments except ImageNet, for which we use the bottleneck block detailed in He et al. [8]. Typically, there are 64, 32, or 16 filters in the convolutional layers (see Section 4 for experimental details).aims to shrink the depth of a network during training, while keeping it unchanged during testing. We can achieve this goal by randomly dropping entire ResBlocks during training and bypassing their transformations through skip connections. Let denote a Bernoulli random variable, which indicates whether the ResBlock is active () or inactive (
). Further, let us denote the “survival” probability of ResBlock
as .With this definition we can bypass the ResBlock by multiplying its function with and we extend the update rule from (1) to
(2) 
If , eq. (2) reduces to the original ResNet update (1) and this ResBlock remains unchanged. If , the ResBlock reduces to the identity function,
(3) 
This reduction follows from the fact that the input is always nonnegative, at least for the architectures we use. For , it is the output of the previous ResBlock, which is nonnegative because of the final transition function (see Fig. 1). For , its input is the output of a ConvBNReLU sequence that begins the architecture before the first ResBlock. For nonnegative inputs the transition function acts as an identity.
are new hyperparameters of our training procedure. Intuitively, they should take on similar values for neighboring ResBlocks. One option is to set uniformly for all to obtain a single hyperparameter . Another possibility is to set them according to a smooth function of . We propose a simple linear decay rule from for the input, to for the last ResBlock:
(4) 
See Fig. 2 for a schematic illustration. The linearly decaying survival probability originates from our intuition that the earlier layers extract lowlevel features that will be used by later layers and should therefore be more reliably present. In Section 4 we perform a more detailed empirical comparison between the uniform and decaying assignments for . We conclude that the linear decay rule (4) is preferred and, as training with stochastic depth is surprisingly stable with respect to , we set throughout (see Fig. 8).
During the forwardbackward pass the transformation is bypassed with probability , leading to a network with reduced depth. With stochastic depth, the number of effective ResBlocks during training, denoted as , becomes a random variable. Its expectation is given by:
Under the linear decay rule with , the expected number of ResBlocks during training reduces to , or when is large. For the 110layer network with commonly used in our experiments, we have . In other words, with stochastic depth, we train ResNets with an average number of 40 ResBlocks, but recover a ResNet with 54 blocks at test time. This reduction in depth significantly alleviates the vanishing gradients and the information loss problem in deep ResNets. Note that because the connectivity is random, there will be updates with significantly shorter networks and more direct paths to individual layers. We provide an empirical demonstration of this effect in Section 5.
When a ResBlock is bypassed for a specific iteration, there is no need to perform forwardbackward computation or gradient updates. As the forwardbackward computation dominates the training time, stochastic depth significantly speeds up the training process. Following the calculations above, approximately of training time could be saved under the linear decay rule with . The timings in practice using our implementation are consistent with this analysis (see the last paragraph of Section 4). More computational savings can be obtained by switching to a uniform probability for or lowering accordingly. In fact, Fig. 8 shows that with , the ResNet with stochastic depth obtains the same test error as its constant depth counterpart on CIFAR10 but gives a 40% speedup.
In addition to the predicted speedups, we also observe significantly lower testing errors in our experiments, in comparison with ResNets of constant depth. One explanation for our performance improvements is that training with stochastic depth can be viewed as training an ensemble of ResNets implicitly. Each of the layers is either active or inactive, resulting in possible network combinations. For each training minibatch one of the networks (with shared weights) is sampled and updated. During testing all networks are averaged using the approach in the next paragraph.
requires small modifications to the network. We keep all functions active throughout testing in order to utilize the fulllength network with all its model capacity. However, during training, functions are only active for a fraction of all updates, and the corresponding weights of the next layer are calibrated for this survival probability. We therefore need to recalibrate the outputs of any given function by the expected number of times it participates in training, . The forward propagation update rule becomes:
(5) 
From the model ensemble perspective, the update rule (5) can be interpreted as combining all possible networks into a single test architecture, in which each layer is weighted by its survival probability.

CIFAR10+  CIFAR100+  SVHN  ImageNet 

Maxout [21]  9.38    2.47   
DropConnect [20]  9.32    1.94   
Net in Net [24]  8.81    2.35   
Deeply Supervised [13]  7.97    1.92  33.70 
Frac. Pool [25]    27.62     
AllCNN [6]  7.25      41.20 
Learning Activation [26]  7.51  30.83     
RCNN [27]  7.09    1.77   
Scalable BO [28]  6.37  27.40  1.77   
Highway Network [29]  7.60  32.24     
Gen. Pool [30]  6.05    1.69  28.02 
ResNet with constant depth  6.41  27.76  1.80  21.78 
ResNet with stochastic depth  5.25  24.98  1.75  21.98 
We empirically demonstrate the effectiveness of stochastic depth on a series of benchmark data sets: CIFAR10, CIFAR100 [1], SVHN [31], and ImageNet [2].
For all data sets we compare the results of ResNets with our proposed stochastic depth and the original constant depth, and other most competitive benchmarks. We set with the linear decay rule of and
throughout. In all experiments we report the test error from the epoch with the lowest validation error. For best comparisons we use the same construction scheme (for constant and stochastic depth) as described by He et al.
[8]. In the case of CIFAR100 we use the same 110layer ResNet used by He et al. [8] for CIFAR10, except that the network has a 100way softmax output. Each model contains three groups of residual blocks that differ in number of filters and feature map size, and each group is a stack of 18 residual blocks. The numbers of filters in the three groups are 16, 32 and 64, respectively. For the transitional residual blocks, i.e. the first residual block in the second and third group, the output dimension is larger than the input dimension. Following He et al. [8], we replace the identity connections in these blocks by an average pooling layer followed by zero paddings to match the dimensions. Our implementations are in Torch 7
[32]. The code to reproduce the results is publicly available on GitHub at https://github.com/yueatsprograms/Stochastic_Depth.CIFAR10 [1] is a dataset of 32by32 color images, representing 10 classes of natural scene objects. The training set and test set contain 50,000 and 10,000 images, respectively. We hold out 5,000 images as validation set, and use the remaining 45,000 as training samples. Horizontal flipping and translation by 4 pixels are the two standard data augmentation techniques adopted in our experiments, following the common practice [21, 20, 24, 13, 6, 26, 30].
The baseline ResNet is trained with SGD for 500 epochs, with a minibatch size 128. The initial learning rate is 0.1, and is divided by a factor of 10 after epochs 250 and 375. We use a weight decay of 1e4, momentum of 0.9, and Nesterov momentum
[33] with 0 dampening, as suggested by [34]. For stochastic depth, the network structure and all optimization settings are exactly the same as the baseline. All settings were chosen to match the setup of He et al. [8].The results are shown in Table 1. ResNets with constant depth result in a competitive 6.41% error on the test set. ResNets trained with stochastic depth yield a further relative improvement of and result in 5.25% test error. To our knowledge this is significantly lower than the best existing single model performance () [30] on CIFAR10 prior to our submission, without resorting to massive data augmentation [25, 6].^{1}^{1}1The only model that performs even better is the 1202layer ResNet with stochastic depth, discussed later in this section. Fig. 3 (left) shows the test error as a function of epochs. The point selected by the lowest validation error is circled for both approaches. We observe that ResNets with stochastic depth yield lower test error but also slightly higher fluctuations (presumably due to the random depth during training).
Similar to CIFAR10, CIFAR100 [1] contains 32by32 color images with the same traintest split, but from 100 classes. For both the baseline and our method, the experimental settings are exactly the same as those of CIFAR10. The constant depth ResNet yields a test error of 27.22%, which is already the stateoftheart in CIFAR100 with standard data augmentation. Adding stochastic depth drastically reduces the error to 24.98%, and is again the best published single model performance to our knowledge (see Table 1 and Fig. 3 right).
We also experiment with CIFAR10 and CIFAR100 without data augmentation. ResNets with constant depth obtain 13.63% and 44.74% on CIFAR10 and CIFAR100 respectively. Adding stochastic depth yields consistent improvements of about 15% on both datasets, resulting in test errors of 11.66% and 37.8% respectively.
The format of the Street View House Number (SVHN) [31]
dataset that we use contains 32by32 colored images of cropped out house numbers from Google Street View. The task is to classify the digit at the center. There are 73,257 digits in the training set, 26,032 in the test set and 531,131 easier samples for additional training. Following the common practice, we use all the training samples but do not perform data augmentation. For each of the ten classes, we randomly select 400 samples from the training set and 200 from the additional set, forming a validation set with 6,000 samples in total. We preprocess the data by subtracting the mean and dividing the standard deviation. Batch size is set to 128, and validation error is calculated every 200 iterations.
Our baseline network has 152 layers. It is trained for 50 epochs with a beginning learning rate of 0.1, divided by 10 after epochs 30 and 35. The depth and learning rate schedule are selected by optimizing for the validation error of the baseline through many trials. This baseline obtains a competitive result of 1.80%. However, as seen in Fig. 4, it starts to overfit at the beginning of the second phase with learning rate 0.01, and continues to overfit until the end of training. With stochastic depth, the error improves to 1.75%, the secondbest published result on SVHN to our knowledge after [30].
CIFAR10+  CIFAR100+  SVHN  

Constant Depth  20h 42m  20h 51m  33h 43m 
Stochastic Depth  15h 7m  15h 20m  25h 33m 
We compare the training efficiency of the constant depth and stochastic depth ResNets used to produce the previous results. Table 2 shows the training (clock) time under both settings with the linear decay rule . Stochastic depth consistently gives a 25% speedup, which confirms our analysis in Section 3. See Fig. 8 and the corresponding section on hyperparameter sensitivity for more empirical analysis.
He et al. [8] tried to learn CIFAR10 using an aggressively deep ResNet with 1202 layers. As expected, this extremely deep network overfitted to the training set: it ended up with a test error of 7.93%, worse than their 110layer network. We repeat their experiment on the same 1202layer network, with constant and stochastic depth. We train for 300 epochs, and set the learning rate to 0.01 for the first 10 epochs to “warmup” the network and facilitate initial convergence, then restore it to 0.1, and divide it by 10 at epochs 150 and 225.
The results are summarized in Fig. 4 (right) and Fig. 5. Similar to He et al. [8], the ResNets with constant depth of 1202 layers yields a test error of 6.67%, which is worse than the 110layer constant depth ResNet. In contrast, if trained with stochastic depth, this extremely deep ResNet performs remarkably well. We want to highlight two trends: 1) Comparing the two 1202layer nets shows that training with stochastic depth leads to a 27% relative improvement; 2) Comparing the two networks trained with stochastic depth shows that increasing the architecture from 110 layers to 1202 yields a further improvement on the previous recordlow 5.25%, to a 4.91% test error without sign of overfitting, as shown in Fig. 4 (right) ^{2}^{2}2We do not include this result in Table 1 since this architecture was only trained on one of the datasets..
To the best of our knowledge, this is the lowest known test error on CIFAR10 with moderate image augmentation and the first time that a network with more than 1000 layers has been shown to further reduce the test error ^{3}^{3}3This is, until early March, 2016, when this paper was submitted to ECCV. Many new developments have further decreased the error on CIFAR10 since then (and some are based on this work).. We consider these findings highly encouraging and hope that training with stochastic depth will enable researchers to leverage extremely deep architectures in the future.
The ILSVRC 2012 classification dataset consists of 1000 classes of images, in total 1.2 million for training, 50,000 for validation, and 100,000 for testing. Following the common practice, we only report the validation errors. We follow He et al. [8] to build a 152layer ResNet with 50 bottleneck residual blocks. When input and output dimensions do not match, the skip connection uses a learned linear projection for the mismatching dimensions, and an identity transformation for the other dimensions. Our implementation is based on the github repository fb.resnet.torch^{4}^{4}4https://github.com/facebook/fb.resnet.torch [34], and the optimization settings are the same as theirs, except that we use a batch size of 128 instead of 256 because we can only spread a batch among 4 GPUs (instead of 8 as they did).
We train the constant depth baseline for 90 epochs (following He et al. and the default setting in the repository) and obtain a final error of 23.06%. With stochastic depth, we obtain an error of 23.38% at epoch 90, which is slightly higher. We observe from Fig.6 that the downward trend of the validation error with stochastic depth is still strong, and from our previous experience, could benefit from further training. Due to the 25% computational saving, we can add 30 epochs (giving 120 in total, after decreasing the learning rate to 1e4 at epoch 90), and still finish in almost the same total time as 90 epochs of the baseline. This reaches a final error of 21.98%. We have also kept the baseline running for 30 more epochs. This reaches a final error of 21.78%.
Because ImageNet is a very complicated and large dataset, the model complexity required could potentially be much more than that of the 152layer ResNet [35]. In the words of an anonymous reviewer, the current generation of models for ImageNet are still in a different regime from those of CIFAR. Although there seems to be no immediate benefit from applying stochastic depth on this particular architecture, it is possible that stochastic depth will lead to improvements on ImageNet with larger models, which the community might soon be able to train as GPU capacities increase.
In this section, we provide more insights into stochastic depth by presenting a series of analytical results. We perform experiments to support the hypothesis that stochastic depth effectively addresses the problem of vanishing gradients in backward propagation. Moreover, we demonstrate the robustness of stochastic depth with respect to its hyperparameter.
Stochastically dropping layers during training reduces the effective depth on which gradient backpropagation is performed, while keeping the testtime model depth unmodified. As a result we expect training with stochastic depth to reduce the vanishing gradient problem in the backward step. To empirically support this, we compare the magnitude of gradients to the first convolutional layer of the first ResBlock () with and without stochastic depth on the CIFAR10 data set.
Fig. 7 shows the mean absolute values of the gradients. The two large drops indicated by vertical dotted lines are due to scheduled learning rate division. It can be observed that the magnitude of gradients in the network trained with stochastic depth is always larger, especially after the learning rate drops. This seems to support out claim that stochastic depth indeed significantly reduces the vanishing gradient problem, and enables the network to be trained more effectively. Another indication of the effect is in the left panel of Fig. 3, where one can observe that the test error of the ResNets with constant depth approximately plateaus after the first drop of learning rate, while stochastic depth still improves the performance even after the learning rate drops for the second time. This further supports that stochastic depth combines the benefits of shortened network during training with those of deep models at test time.
The survival probability is the only hyperparameter of our method. Although we used throughout all our experiments, it is still worth investigating the sensitivity of stochastic depth with respect to its hyperparameter. To this end, we compare the test error of the 110layer ResNet under varying values of () for both linear decay and uniform assignment rules on the CIFAR10 data set in Fig. 8 (left). We make the following observations: 1) both assignment rules yield better results than the baseline when is set properly; 2) the linear decay rule outperforms the uniform rule consistently; 3) the linear decay rule is relatively robust to fluctuations in and obtains competitive results when ranges from 0.4 to 0.8; 4) even with a rather small survival probability e.g. , stochastic depth with linear decay still performs well, while giving a 40% reduction in training time. This shows that stochastic depth can save training time substantially without compromising accuracy.
The heatmap on the right shows the test error varied over both and network depth. Not surprisingly, deeper networks (at least in the range of our experiments) do better with a . The ”valley” of the heatmap is along the diagonal. A deep enough model is necessary for stochastic depth to significantly outperform the baseline (an observation we also make with the ImageNet data set), although shorter networks can still benefit from less aggressive skipping.
In this paper we introduced deep networks with stochastic depth, a procedure to train very deep neural networks effectively and efficiently. Stochastic depth reduces the network depth during training in expectation
while maintaining the full depth at testing time. Training with stochastic depth allows one to increase the depth of a network well beyond 1000 layers, and still obtain a reduction in test error. Because of its simplicity and practicality we hope that training with stochastic depth may become a new tool in the deep learning “toolbox”, and will help researchers scale their models to previously unattainable depths and capabilities.
We thank the anonymous reviewers for their kind suggestions. Kilian Weinberger is supported by NFS grants IIS1550179, IIS1525919 and EFRI1137211. Gao Huang is supported by the International Postdoctoral Exchange Fellowship Program of China Postdoctoral Council (No.20150015). Yu Sun is supported by the Cornell University Office of Undergraduate Research. We also thank our lab mates, Matthew Kusner and Shuang Li for useful and interesting discussions.
In: Computer Vision and Pattern Recognition, 2009. CVPR 2009. IEEE Conference on, IEEE (2009) 248–255
In: International conference on artificial intelligence and statistics. (2010) 249–256
The Journal of Machine Learning Research
15(1) (2014) 1929–1958
Comments
There are no comments yet.