Towards a Neural Statistician

06/07/2016 ∙ by Harrison Edwards, et al. ∙ 0

An efficient learner is one who reuses what they already know to tackle a new problem. For a machine learner, this means understanding the similarities amongst datasets. In order to do this, one must take seriously the idea of working with datasets, rather than datapoints, as the key objects to model. Towards this goal, we demonstrate an extension of a variational autoencoder that can learn a method for computing representations, or statistics, of datasets in an unsupervised fashion. The network is trained to produce statistics that encapsulate a generative model for each dataset. Hence the network enables efficient learning from new datasets for both unsupervised and supervised tasks. We show that we are able to learn statistics that can be used for: clustering datasets, transferring generative models to new datasets, selecting representative samples of datasets and classifying previously unseen classes. We refer to our model as a neural statistician, and by this we mean a neural network that can learn to compute summary statistics of datasets without supervision.

READ FULL TEXT VIEW PDF

Authors

page 7

page 8

This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

1 Introduction

The machine learning community is well-practised at learning representations of

data-points and sequences. A middle-ground between these two is representing, or summarizing, datasets

- unordered collections of vectors, such as photos of a particular person, recordings of a given speaker or a document as a bag-of-words. Where these sets take the form of i.i.d samples from some distribution, such summaries are called

statistics. We explore the idea of using neural networks to learn statistics and we refer to our approach as a neural statistician.

The key result of our approach is a statistic network

that takes as input a set of vectors and outputs a vector of summary statistics specifying a generative model of that set - a mean and variance specifying a Gaussian distribution in a latent space we term the context. The advantages of our approach are that it is:

  • Unsupervised: It provides principled and unsupervised way to learn summary statistics as the output of a variational encoder of a generative model.

  • Data efficient: If one has a large number of small but related datasets, modelling the datasets jointly enables us to gain statistical strength.

  • Parameter Efficient: By using summary statistics instead of say categorical labellings of each dataset, we decouple the number of parameters of the model from the number of datasets.

  • Capable of few-shot learning: If the datasets correspond to examples from different classes, class embeddings (summary statistics associated with examples from a class), allow us to handle new classes at test time.

2 Problem Statement

We are given datasets for . Each dataset consists of a number of i.i.d samples from an associated distribution over . The task can be split into learning and inference components. The learning component is to produce a generative model for each dataset . We assume there is a common underlying generative process such that for drawn from . We refer to as the context. The inference component is to give an approximate posterior over the context for a given dataset produced by a statistic network.

3 Neural Statistician

In order to exploit the assumption of a hierarchical generative process over datasets we will use a ‘parameter-transfer approach’ (see Pan & Yang, 2010) to extend the variational autoencoder model of Kingma & Welling (2013).

figureLeft: basic hierarchical model, where the plate encodes the fact that the context variable is shared across each item in a given dataset. Center: full neural statistician model with three latent layers

. Each collection of incoming edges to a node is implemented as a neural network, the input of which is the concatenation of the edges’ sources, the output of which is a parameterization of a distribution over the random variable represented by that node.

Right: The statistic network, which combines the data via an exchangeable statistic layer.

3.1 Variational Autoencoder

The variational autoencoder is a latent variable model (often called the decoder) with parameters . For each observed , a corresponding latent variable is drawn from so that

(1)

The generative parameters are learned by introducing a recognition network (also called an encoder) with parameters . The recognition network gives an approximate posterior over the latent variables that can then be used to give the standard variational lower bound (Saul & Jordan, 1996) on the single-datum log-likelihood. I.e. , where

(2)

Likewise the full-data log likelihood is lower bounded by the sum of the terms over the whole dataset. We can then optimize this lower bound with respect to and using the reparameterization trick introduced by Kingma & Welling (2013) and Rezende et al. (2014)

to get a Monte-Carlo estimate of the gradient.

3.2 Basic Model

We extend the variational autoencoder to the model depicted on the left in Figure 3. This includes a latent variable , the context, that varies between different datasets but is constant, a priori, for items within the same dataset. Now, the likelihood of the parameters for one single particular dataset is given by

(3)

The prior is chosen to be a spherical Gaussian with zero mean and unit variance. The conditional is Gaussian with diagonal covariance, where all the mean and variance parameters depend on through a neural network. Similarly the observation model will be a simple likelihood function appropriate to the data modality with dependence on parameterized by a neural network. For example, with real valued data, a diagonal Gaussian likelihood could be used where the mean and log variance of are created from via a neural network.

We use approximate inference networks , , with parameters collected into , to once again enable the calculation and optimization of a variational lower bound on the log-likelihood. The single dataset log likelihood lower bound is given by

(4)

As with the generative distributions, the likelihood forms for and are diagonal Gaussian distributions, where all the mean and log variance parameters in each distribution are produced by a neural network taking the conditioning variables as inputs. Note that accepts as input a dataset and we refer to this as the statistic network. We describe this in Subsection 3.4.

The full-data variational bound is given by summing the variational bound for each dataset in our collection of datasets. It is by learning the difference of the within-dataset and between-dataset distributions that we are able to discover an appropriate statistic network.

3.3 Full Model

The basic model works well for modelling simple datasets, but struggles when the datasets have complex internal structure. To increase the sophistication of the model we use multiple stochastic layers and introduce skip-connections for both the inference and generative networks. The generative model is shown graphically in Figure 3

in the center. The probability of a dataset

is then given by

(5)

where the are again Gaussian distributions where the mean and log variance are given as the output of neural networks. The generative process for the full model is described in Algorithm 1.

The full approximate posterior factorizes analogously as

(6)

For convenience we give the variational lower bound as sum of a three parts, a reconstruction term , a context divergence and a latent divergence :

(7)
(8)
(9)
(10)

The skip-connections and allow the context to specify a more precise distribution for each latent variable by explaining-away more generic aspects of the dataset at each stochastic layer. This architecture was inspired by recent work on probabilistic ladder networks in Kaae Sønderby et al. (2016). Complementing these are the skip-connections from each latent variable to the observation , the intuition here is that each stochastic layer can focus on representing a certain level of abstraction, since its information does not need to be copied into the next layer, a similar approach was used in Maaløe et al. (2016).

Once again, note that we are maximizing the lower bound to the log likelihood over many datasets : we want to maximize the expectation of

over all datasets. We do this optimization using stochastic gradient descent. In contrast to a variational autoencoder where a minibatch would consist of a subsample of

datapoints from the dataset, we use minibatches consisting of a subsample of datasets

- tensors of shape

(batch size, sample size, number of features).

3.4 Statistic Network

In addition to the standard inference networks we require a statistic network to give an approximate posterior over the context given a dataset . This inference network must capture the exchangeability of the data in .

We use a feedforward neural network consisting of three main elements:

  • An instance encoder that takes each individual datapoint to a vector .

  • An exchangeable instance pooling layer that collapses the matrix to a single pre-statistic vector

    . Examples include elementwise means, sums, products, geometric means and maximum. We use the sample mean for all experiments.

  • A final post-pooling network that takes to a parameterization of a diagonal Gaussian.

The graphical model for this is given at the right of Figure 3.

We note that the humble sample mean already gives the statistic network a great deal of representational power due to the fact that the instance encoder can learn a representation where averaging makes sense. For example since the instance encoder can approximate a polynomial on a compact domain, and so can the post-pooling network, a statistic network can approximate any moment of a distribution.

4 Related Work

Due to the general nature of the problem considered, our work touches on many different topics which we now attempt to summarize.

Topic models and graphical models

The form of the graphical model in Figure 3 on the left is equivalent to that of a standard topic model. In contrast to traditional topic models we do not use discrete latent variables, or restrict to discrete data. Work such as that by Ranganath et al. (2014) has extended topic models in various directions, but importantly we use flexible conditional distributions and dependency structures parameterized by deep neural networks. Recent work has explored neural networks for document models (see e.g. Miao et al., 2015) but has been limited to modelling datapoints with little internal structure. Along related lines are ‘structured variational autoencoders’ (see Johnson et al., 2016), where they treat the general problem of integrating graphical models with variational autoencoders.

Transfer learning

There is a considerable literature on transfer learning, for a survey see

Pan & Yang (2010). There they discuss ‘parameter-transfer’ approaches whereby parameters or priors are shared across datasets, and our work fits into that paradigm. For examples see Lawrence & Platt (2004) where share they priors between Gaussian processes, and Evgeniou & Pontil (2004) where they take an SVM-like approach to share kernels.

One-shot Learning

Learning quickly from small amounts of data is a topic of great interest. Lake et al. (2015)

use Bayesian program induction for one-shot generation and classification, and

Koch (2015) train a Siamese (Chopra et al. (2005)) convolutional network for one-shot image classification. We note the relation to the recent work (Rezende et al., 2016) in which the authors use a conditional recurrent variational autoencoder capable of one-shot generalization by taking as extra input a conditioning data point. The important differences here are that we jointly model datasets and datapoints and consider datasets of any size. Recent approaches to one-shot classification are matching networks (Vinyals et al., 2016b) (which was concurrent with the initial preprint of this work), and related previous work (Santoro et al., 2016). The former can be considered a kind of differentiable nearest neighbour classifier, and the latter augments their network with memory to store information about the classification problem. Both are trained end-to-end for the classification problem, whereas the present work is a general approach to learning representations of datasets. Probably the closest previous work is by Salakhutdinov et al. (2012) where the authors learn a topic model over the activations of a DBM for one-shot learning. Compared with their work we use modern architectures and easier to train VAEs, in particular we have fast and amortized feedforward inference for test (and training) datasets, avoiding the need for MCMC.

Multiple-Instance Learning

There is previous work on classifying sets in multiple-instance learning, for a useful survey see Cheplygina et al. (2015). Typical approaches involve adapting kernel based methods such as support measure machines (Muandet et al., 2012), support distribution machines (Póczos et al., 2012) and multiple-instance-kernels (Gartner et al., 2002). We do not consider applications to multiple-instance learning type problems here, but it may be fruitful to do so in the future.

Set2Seq

In very related work, Vinyals et al. (2016a) explore architectures for mapping sets to sequences. There they use an LSTM to repeatedly compute weighted-averages of the datapoints and use this to tackle problems such as sorting a list of numbers. The main difference between their work and ours is that they primarily consider supervised problems, whereas we present a general unsupervised method for learning representations of sets of i.i.d instances. In future work we may also explore recurrently computing statistics.

Abc

There has also been work on learning summary statistics for Approximate Bayesian Computation by either learning to predict the parameters generating a sample as a supervised problem, or by using kernel embeddings as infinite dimensional summary statistics. See the work by Fukumizu et al. (2013) for an example of kernel-based approaches. More recently Jiang et al. (2015) used deep neural networks to predict the parameters generating the data. The crucial differences are that their problem is supervised, they do not leverage any exchangeability properties the data may have, nor can it deal with varying sample sizes.

5 Experimental Results

Given an input set we can use the statistic network to calculate an approximate posterior over contexts . Under the generative model, each context specifies a conditional model . To get samples from the model corresponding to the most likely posterior value of , we set to the mean of the approximate posterior and then sample directly from the conditional distributions. This is described in Algorithm 2. We use this process in our experiments to show samples. In all experiments, we use the Adam optimization algorithm (Kingma & Ba, 2014)

to optimize the parameters of the generative models and variational approximations. Batch normalization

(Ioffe & Szegedy, 2015) is implemented for convolutional layers and we always use a batch size of

. We primarily use the Theano

(Theano Development Team, 2016) framework with the Lasagne (Dieleman et al., 2015)

library, but the final experiments with face data were done using Tensorflow

(Abadi et al., 2015)

. In all cases experiments were terminated after a given number of epochs when training appeared to have sufficiently converged (

epochs for omniglot, youtube and spatial MNIST examples, and epochs for the synthetic experiment).

5.1 Simple 1-D Distributions

In our first experiment we wanted to know if the neural statistician will learn to cluster synthetic -D datasets by distribution family. We generated a collection of synthetic -D datasets each containing samples. Datasets consist of samples from either an Exponential, Gaussian, Uniform or Laplacian distribution with equal probability. Means and variances are sampled from and respectively. The training data contains sets.

The architecture for this experiment contains a single stochastic layer with units for and units for , . The model and variational approximation

are each a diagonal Gaussian distribution with all mean and log variance parameters given by a network composed of three dense layers with ReLU activations and

units. The statistic network determining the mean and log variance parameters of posterior over context variables is composed of three dense layers before and after pooling, each with

units with Rectified Linear Unit (ReLU) activations.

Figure 1 shows 3-D scatter plots of the summary statistics learned. Notice that the different families of distribution cluster. It is interesting to observe that the Exponential cluster is differently orientated to the others, perhaps reflecting the fact that it is the only non-symmetric distribution. We also see that between the Gaussian and Laplacian clusters there is an area of ambiguity which is as one might expect. We also see that within each cluster the mean and variance are mapped to orthogonal directions.

Figure 1: Three different views of the same data. Each point is the mean of the approximate posterior over the context where . Each point is a summary statistic for a single dataset with 200 samples. Top plot shows points colored by distribution family, left plot colored by the mean and right plot colored by the variance. The plots have been rotated to illustrative angles.

5.2 Spatial MNIST

Figure 2: An image from MNIST on the left, transformed to a set of coordinates, shown as a scatter plot on the right.

Building on the previous experiments we investigate 2-D datasets that have complex structure, but the datapoints contain little information by themselves, making it a good test of the statistic network. We created a dataset called spatial MNIST. In spatial MNIST each image from MNIST (LeCun et al., 1998) is turned into a dataset by interpreting the normalized pixel intensities as a probability density and sampling coordinate values. An example is shown in Figure 2. This creates two-dimensional spatial datasets. We used a sample size of . Note that since the pixel coordinates are discrete, it is necessary to dequantize them by adding uniform noise to the coordinates if one models them as real numbers, else you can get arbitrarily high densities (see Theis et al. (2016) for a discussion of this point).

The generative architecture for this experiment contains stochastic layers, each with units, and a single layer with units. The means and log variances of the Gaussian likelihood for , and each subnetwork for in both the encoder and decoder contained dense layers with ReLU units each. The statistic network also contained 3 dense layers pre-pooling and 3 dense layers post pooling with 256 ReLU units.

In addition to being able to sample from the model conditioned on a set of inputs, we can also summarize a dataset by choosing a subset to minimise the KL divergence of from . We do this greedily by iteratively discarding points from the full sample. Pseudocode for this process is given in Algorithm 3. The results are shown in Figure 3. We see that the model is capable of handling complex arrangements of datapoints. We also see that it can select sensible subsets of a dataset as a summary.

Figure 3: Conditioned samples from spatial MNIST data. Blue and red digits are the input sets, black digits above correspond to samples given the input. Red points correspond to a -sample summary of the dataset

5.3 Omniglot

Next we work with the OMNIGLOT data (Lake et al., 2015). This contains 1628 classes of handwritten characters but with just 20 examples per class. This makes it an excellent test-bed for transfer / few-shot learning. We constructed datasets by splitting each class into datasets of size 5. We train on datasets drawn from 1200 classes and reserve the remaining classes to test few-shot sampling and classification. We created new classes by rotating and reflecting characters. We resized the images to

. We sampled a binarization of each image for each epoch. We also randomly applied the dilation operator from computer vision as further data augmentation since we observed that the stroke widths are quite uniform in the OMNIGLOT data, whereas there is substantial variation in MNIST, this augmentation improved the visual quality of the few-shot MNIST samples considerably and increased the few-shot classification accuracy by about

percent. Finally we used ‘sample dropout’ whereby a random subset of each dataset was removed from the pooling in the statistic network, and then included the number of samples remaining as an extra feature. This was beneficial since it reduced overfitting and also allowed the statistic network to learn to adjust the approximate posterior over based on the number of samples.

We used a single stochastic layer with 16 units for , and units for . We used a shared convolutional encoder between the inference and statistic networks and a deconvolutional decoder network. Full details of the networks are given in Appendix B.1. The decoder used a Bernoulli likelihood.

In Figure 4 we show two examples of few-shot learning by conditioning on samples of unseen characters from OMNIGLOT, and conditioning on samples of digits from MNIST. The samples are mostly of a high-quality, and this shows that the neural statistician can generalize even to new datasets.

Figure 4: Few-shot learning Left: Few-shot learning from OMNIGLOT to MNIST. Left rows are input sets, right rows are samples given the inputs. Right: Few-shot learning from with OMNIGLOT data to unseen classes. Left rows are input sets, right rows are samples given the inputs. Black-white inversion is applied for ease of viewing.

As a further test we considered few-shot classification of both unseen OMNIGLOT characters and MNIST digits. Given a sets of labelled examples of each class (for MNIST say), we computed the approximate posteriors using the statistic network. Then for each test image we also computed the posterior and classified it according to the training dataset minimizing the KL divergence from the test context to the training context. This process is described in Algorithm 4. We tried this with either 1 or 5 labelled examples per class and either or classes. For each trial we randomly select classes, randomly select training examples for each class, and test on the remaining examples. This process is repeated 100 times and the results averaged. The results are shown in Table 1. We compare to a number of results reported in Vinyals et al. (2016b) including Santoro et al. (2016) and Koch (2015). Overall we see that the neural statistician model can be used as a strong classifier, particularly for the -way tasks, but performs worse than matching networks for the -way tasks. One important advantage that matching networks have is that, whilst each class is processed independently in our model, the representation in matching networks is conditioned on all of the classes in the few-shot problem. This means that it can exaggerate differences between similar classes, which are more likely to appear in a 20-way problem than a 5-way problem.

Task Method
Test Dataset K Shot K Way Siamese MANN Matching Ours
MNIST 1 10 70 - 72 78.6
MNIST 5 10 - - - 93.2
OMNIGLOT 1 5 97.3 82.8 98.1 98.1
OMNIGLOT 5 5 98.4 94.9 98.9 99.5
OMNIGLOT 1 20 88.1 - 93.8 93.2
OMNIGLOT 5 20 97.0 - 98.7 98.1
Table 1: The table shows the classification accuracies of various few-shot learning tasks. Models are trained on OMNIGLOT data and tested on either unseen OMNIGLOT classes or MNIST with varying numbers of samples per class (K-shot) with varying numbers of classes (K-way). Comparisons are to Vinyals et al. (2016b) (Matching), Santoro et al. (2016) (MANN) and Koch (2015) (Siamese). 5-shot MNIST results are included for completeness.

5.4 Youtube Faces

Figure 5: Few-shot learning for face data. Samples are from model trained on Youtube Faces Database. Left: Each row shows an input set of size 5. Center: Each row shows 5 samples from the model corresponding to the input set on the left. Right: Imagined new faces generated by sampling contexts from the prior. Each row consists of 5 samples from the model given a particular sampled context.

Finally, we provide a proof of concept for generating faces of a particular person. We use the Youtube Faces Database from Wolf et al. (2011). It contains videos of different people. We use the aligned and cropped to face version, resized to . The validation and test sets contain unique people each, and there is no overlap of persons between data splits. The sets were created by sampling frames randomly without replacement from each video, we use a set size of frames. We resample the sets for the training data each epoch.

Our architecture for this problem is based on one presented in Lamb et al. (2016). We used a single stochastic layer with dimensional latent and dimensional variable. The statistic network and the inference network share a common convolutional encoder, and the deocder uses deconvolutional layers. For full details see Appendix B.2. The likelihood function is a Gaussian, but where the variance parameters are shared across all datapoints, this was found to make training faster and more stable.

The results are shown in Figure 5. Whilst there is room for improvement, we see that it is possible to specify a complex distribution on-the-fly with a set of photos of a previously unseen person. The samples conditioned on an input set have a reasonable likeness of the input faces. We also show the ability of the model to generate new datasets and see that the samples have a consistent identity and varied poses.

6 Conclusion

We have demonstrated a highly flexible model on a variety of tasks. Going forward our approach will naturally benefit from advances in generative models as we can simply upgrade our base generative model, and so future work will pursue this. Compared with some other approaches in the literature for few-shot learning, our requirement for supervision is weaker: we only ask at training time that we are given datasets, but we do not need labels for the datasets, nor even information on whether two datasets represent the same or different classes. It would be interesting then to explore application areas where only this weaker form of supervision is available. There are two important limitations to this work, firstly that the method is dataset hungry: it will likely not learn useful representations of datasets given only a small number of them. Secondly at test time the few-shot fit of the generative model will not be greatly improved by using larger datasets unless the model was also trained on similarly large datasets. The latter limitation seems like a promising future research direction - bridging the gap between fast adaptation and slow training.

Acknowledgments

This work was supported in part by the EPSRC Centre for Doctoral Training in Data Science, funded by the UK Engineering and Physical Sciences Research Council (grant EP/L016427/1) and the University of Edinburgh.

References

Appendix A Appendix A: Pseudocode

  sample
  for  to  do
     sample
     for  to  do
        sample
     end for
     sample
  end for
Algorithm 1 Sampling a dataset of size
   {Calculate approximate posterior over using statistic network.}
   {Set to be the mean of the approximate posterior.}
  for  to  do
     sample
     for  to  do
        sample
     end for
     sample
  end for
Algorithm 2 Sampling a dataset of size conditioned on a dataset of size
  
  
  
   {Calculate approximate posterior over using statistic network.}
  for  to  do
     
     
  end for
Algorithm 3 Selecting a representative sample of size
  
  
   {approximate posterior over given query point}
  for  to  do
     
  end for
  
Algorithm 4 -way few-shot classification

Appendix B Appendix B: Further Experimental Details

b.1 Omniglot

Shared encoder
{ conv2d feature maps with kernels and ELU activations }
conv2d feature maps with

kernels, stride

and ELU activations
{conv2d feature maps with kernels and ELU activations }
conv2d feature maps with kernels, stride and ELU activations
{ conv2d feature maps with kernels and ELU activations }
conv2d feature maps with kernels, stride and ELU activations
Statistic network
fully-connected layer with units and ELU activations
sample-dropout and concatenation with number of samples
average pooling within each dataset
{fully-connected layer with units and ELU activations }
fully-connected linear layers to and
Inference network
concatenate and
{fully-connected layer with units and ELU activations }
fully-connected linear layers to and
Latent decoder network
{fully-connected layer with units and ELU activations }
fully-connected linear layers to and
Observation decoder network
concatenate and
fully-connected linear layers with units
{ conv2d feature maps with kernels and ELU activations }
deconv2d feature maps with kernels, stride 2, ELU activations
{ conv2d feature maps with kernels and ELU activations }
deconv2d feature maps with kernels, stride 2, ELU activations
{ conv2d feature maps with kernels and ELU activations }
deconv2d feature maps with kernels, stride 2, ELU activations
conv2d feature map with kernels, sigmoid activations

b.2 Youtube faces

Shared encoder
{ conv2d feature maps with kernels and ELU activations }
conv2d feature maps with kernels, stride and ELU activations
{conv2d feature maps with kernels and ELU activations }
conv2d feature maps with kernels, stride and ELU activations
{ conv2d feature maps with kernels and ELU activations }
conv2d feature maps with kernels, stride and ELU activations
{ conv2d feature maps with kernels and ELU activations }
conv2d feature maps with kernels, stride and ELU activations
Statistic network
fully-connected layer with units and ELU activations
average pooling within each dataset
fully-connected linear layers to and
Inference network
concatenate and
fully-connected layer with units and ELU activations
fully-connected linear layers to and
Latent decoder network
fully-connected layer with units and ELU activations
fully-connected linear layers to and
Observation decoder network
concatenate and
fully-connected layer with units and ELU activations
fully-connected linear layer with units
{ conv2d feature maps with kernels and ELU activations }
deconv2d feature maps with kernels, stride 2, ELU activations
{ conv2d feature maps with kernels and ELU activations }
deconv2d feature maps with kernels, stride 2, ELU activations
{ conv2d feature maps with kernels and ELU activations }
deconv2d feature maps with kernels, stride 2, ELU activations
{ conv2d feature maps with kernels and ELU activations }
deconv2d feature maps with kernels, stride 2, ELU activations
conv2d feature maps with kernels, sigmoid activations