|
|
|
|
|
\documentclass{article} |
|
|
|
\usepackage{times} |
|
\usepackage{graphicx} |
|
\usepackage{multirow} |
|
\usepackage{natbib} |
|
|
|
\usepackage{algorithm} |
|
\usepackage{caption} |
|
\usepackage{subcaption} |
|
\usepackage{algorithmic} |
|
\usepackage{amsmath} |
|
\usepackage{mathtools} |
|
\usepackage{amsfonts} |
|
\usepackage{booktabs} |
|
\usepackage{graphicx} |
|
\usepackage{amssymb} |
|
\usepackage{soul} |
|
\usepackage{color} |
|
|
|
\font\dsrom=dsrom10 scaled 1200 |
|
\newcommand{\indicator}[1]{\textrm{\dsrom{1}}_{#1}} |
|
\DeclareMathOperator*{\argmax}{arg\,max} |
|
\DeclareMathOperator*{\argmin}{arg\,min} |
|
|
|
\def \ie {\emph{i.e.}} |
|
|
|
\usepackage{hyperref} |
|
|
|
\newcommand{\theHalgorithm}{\arabic{algorithm}} |
|
|
|
|
|
|
|
\usepackage[accepted]{icml2017} |
|
|
|
|
|
|
|
\icmltitlerunning{Unsupervised Learning by Predicting Noise} |
|
|
|
\begin{document} |
|
|
|
\twocolumn[ |
|
\icmltitle{Unsupervised Learning by Predicting Noise} |
|
|
|
|
|
|
|
|
|
\begin{icmlauthorlist} |
|
\icmlauthor{Piotr Bojanowski}{fair} |
|
\icmlauthor{Armand Joulin}{fair} |
|
\end{icmlauthorlist} |
|
\icmlaffiliation{fair}{Facebook AI Research} |
|
|
|
\icmlcorrespondingauthor{Piotr Bojanowski}{bojanowski@fb.com} |
|
|
|
\icmlkeywords{Unsupervised Learning, Convolutional Neural Networks, Discriminative Clustering} |
|
|
|
\vskip 0.3in |
|
] |
|
|
|
\printAffiliationsAndNotice{} |
|
|
|
\begin{abstract} |
|
Convolutional neural networks provide visual features that perform remarkably well in many computer vision applications. |
|
However, training these networks requires significant amounts of supervision. |
|
This paper introduces a generic framework to train deep networks, end-to-end, with no supervision. |
|
We propose to fix a set of target representations, called \emph{Noise As Targets} (NAT), and to constrain the deep features to align to them. |
|
This domain agnostic approach avoids the standard unsupervised learning issues of trivial solutions and collapsing of features. |
|
Thanks to a stochastic batch reassignment strategy and a separable square loss function, it scales to millions of images. |
|
The proposed approach produces representations that perform on par with state-of-the-art unsupervised methods on ImageNet and \textsc{Pascal} VOC. |
|
\end{abstract} |
|
|
|
\section{Introduction} |
|
|
|
In recent years, convolutional neural networks, or \emph{convnets}~\citep{fukushima1982neocognitron,LBDHHHJ89} have |
|
pushed the limits of computer vision~\citep{KSH12, he16}, leading to important progress |
|
in a variety of tasks, like object detection~\citep{girshick2015fast} or image |
|
segmentation~\citep{pinheiro2015learning}. |
|
Key to this success is their ability to produce features that easily transfer |
|
to new domains when trained on massive databases of labeled |
|
images~\citep{razavian14,oquab2014learning} or weakly-supervised data~\cite{joulin16}. |
|
However, human annotations may introduce unforeseen |
|
bias that could limit the potential of learned features to capture subtle information |
|
hidden in a vast collection of images. |
|
|
|
Several strategies exist to learn deep convolutional |
|
features with no annotation~\citep{DKD16}. They either try to |
|
capture a signal from the source as a form of \emph{self-supervision}~\citep{DGE15,WG15} |
|
or learn the underlying distribution of |
|
images~\citep{vincent2010stacked,goodfellow2014generative}. |
|
While some of these approaches obtain promising performance in |
|
transfer learning~\citep{DKD16,WG15}, they do not explicitly aim to learn |
|
discriminative features. |
|
Some attempts were made with retrieval based approaches~\citep{DSRB14} and clustering~\citep{YPB16,LSZU16}, |
|
but they are hard to scale and have only been tested on small datasets. |
|
Unfortunately, as in the supervised case, a lot of data is required to learn good representations. |
|
|
|
In this work, we propose a novel discriminative framework designed to learn deep architectures on massive amounts of data. |
|
Our approach is general, but we focus on convnets since they require millions of images to produce good features. |
|
Similar to self-organizing maps~\cite{kohonen1982self, martinetz1991neural}, |
|
we map deep features to a set of predefined representations in a low dimensional space. |
|
As opposed to these approaches, we aim to learn the features in a end-to-end fashion, |
|
which traditionally suffers from a feature collapsing problem. Our approach |
|
deals with this issue by fixing the target representations and aligning them to our features. |
|
These representations are sampled from a uninformative distribution and we use this \emph{Noise As Targets} (NAT). |
|
Our approach also shares some similarities with standard clustering approches like $k$-means~\citep{lloyd1982least} |
|
or discriminative clustering~\cite{Bach07}. |
|
|
|
In addition, we propose an online algorithm able to scale to massive image databases like ImageNet~\citep{deng2009imagenet}. |
|
Importantly, our approach is barely less efficient to train than |
|
standard supervised approaches and can re-use any |
|
optimization procedure designed for them. |
|
This is achieved by using a quadratic loss as in~\cite{CSTTW17} and a fast approximation of the Hungarian algorithm. |
|
We show the potential of our approach by training end-to-end on ImageNet a standard architecture, namely AlexNet~\citep{KSH12} with no supervision. |
|
|
|
We test the quality of our features on |
|
several image classification problems, following the setting of~\citet{DKD16}. |
|
We are on par with state-of-the-art unsupervised and self-supervised learning approaches while being much simpler to train |
|
and to scale. |
|
|
|
The paper is organized as follows: after a brief review of |
|
the related work in Section~\ref{sec:related}, we present |
|
our approach in Section~\ref{sec:method}. We then |
|
validate our solution with several experiments and |
|
comparisons with standard unsupervised and self-supervised approaches in Section~\ref{sec:exp}. |
|
|
|
|
|
|
|
\section{Related work} |
|
\label{sec:related} |
|
|
|
|
|
Several approaches have been recently proposed to tackle the problem of deep unsupervised learning~\cite{CN12, MKHS14, DSRB14}. |
|
Some of them are based on a clustering loss~\cite{XGF16,YPB16,LSZU16}, but they are not tested at a scale comparable to that of supervised convnet training. |
|
\citet{CN12} uses $k$-means to pre-train convnets, by learning each layer sequentially in a bottom-up fashion. |
|
In our work, we train the convnet end-to-end with a loss that shares similarities with $k$-means. |
|
Closer to our work, \citet{DSRB14} proposes to train convnets by solving a retrieval problem. |
|
They assign a class per image and its transformation. |
|
In contrast to our work, this approach can hardly scale to more than a few hundred of thousands of images, and requires a custom-tailored architecture while we use a standard AlexNet. |
|
|
|
Another traditional approach for learning visual representations in an unsupervised manner is to define a parametrized mapping between a predefined random variable and a set of images. |
|
Traditional examples of this approach are variational autoencoders~\cite{kingma2013auto}, generative adversarial networks~\citep{goodfellow2014generative}, and to a lesser extent, noisy autoencoders~\citep{vincent2010stacked}. |
|
In our work, we are doing the opposite; that is, we map images to a predefined random variable. |
|
This allows us to re-use standard convolutional networks and greatly simplifies the training. |
|
|
|
\paragraph{Generative adversarial networks.} Among those approaches, generative adversarial |
|
networks (GANs)~\cite{goodfellow2014generative,denton2015deep,DKD16} share another |
|
similarity with our approach, namely |
|
they are explicitly minimizing a discriminative loss |
|
to learn their features. |
|
While these models cannot learn an inverse mapping, \citet{DKD16} recently |
|
proposed to add an encoder to extract visual features |
|
from GANs. |
|
Like ours, their encoder can be any standard convolutional network. |
|
However, their loss aims at differentiating real and generated images, while |
|
we are aiming directly at differentiating between images. This makes our |
|
approach much simpler and faster to train, since we do not need to learn |
|
the generator nor the discriminator. |
|
|
|
\paragraph{Self-supervision.} |
|
Recently, a lot of work has explored \emph{self-supervison}: |
|
leveraging supervision contained in the input signal~\cite{DGE15,NF16, pathak2016context}. |
|
In the same vein as word2vec~\cite{mikolov2013efficient}, ~\citet{DGE15} show |
|
that spatial context is a strong signal to learn visual features. \citet{NF16} |
|
have further extended this work. Others have shown that temporal coherence in videos also provides a |
|
signal that can be used to learn powerful visual |
|
features~\cite{ACM15,JG15,WG15}. In particular,~\citet{WG15} show that such |
|
features provide promising performance on ImageNet. |
|
In contrast to our work, these approaches are domain dependent since they |
|
require explicit derivation of weak supervision directly from the input. |
|
|
|
\paragraph{Autoencoders.} |
|
Many have also used autoencoders with a reconstruction |
|
loss~\citep{bengio2007greedy,huang2007unsupervised,masci2011stacked}. The idea |
|
is to encode and decode an image, while minimizing the loss between the decoded |
|
and original images. Once trained, the encoder produces image features and |
|
the decoder can be used to generate images from codes. The decoder is often a |
|
fully connected network~\cite{huang2007unsupervised} or a deconvolutional |
|
network~\citep{masci2011stacked, whatwhere} but can be more sophisticated, like |
|
a PixelCNN network~\citep{van2016conditional}. |
|
|
|
\paragraph{Self-organizing map.} This family of unsupervised methods aims at |
|
learning a low dimensional representation of the data that preserves certain topological properties~\citep{kohonen1982self, vesanto2000clustering}. In |
|
particular, Neural Gas~\citep{martinetz1991neural} aligns feature vectors to |
|
the input data. Each input datum is then assigned to one of these vectors in a |
|
winner-takes-all manner. These feature vectors are in spirit similar to our |
|
target representations and we use a similar assignment strategy. In contrast to our work, |
|
the target vectors are not fixed and aligned to the input vectors. Since |
|
we primarly aim at learning the input features, we do the opposite. |
|
|
|
\paragraph{Discriminative clustering.} |
|
Many methods have been proposed to use discriminative losses for |
|
clustering~\cite{xu2004maximum,Bach07,krause2010discriminative,JouBacICML12}. |
|
In particular, |
|
\citet{Bach07} shows that the ridge regression loss could be use to |
|
learn discriminative clusters. It has been successfully |
|
applied to several computer vision applications, like |
|
object discovery~\citep{Joulin10,TJLF14} or |
|
video/text alignment~\cite{Bojanowski_ICCV13,bojanowski2014weakly,ramanathan2014linking}. |
|
In this work, we show that a similar framework can be |
|
designed for neural networks. As opposed to \citet{xu2004maximum}, |
|
we address the empty assignment problems by restricting the |
|
set of possible reassignments to permutations rather than |
|
using global linear constrains the assignments. |
|
Our assignments can be updated online, allowing our approach to scale to very large datasets. |
|
|
|
|
|
|
|
\section{Method} |
|
\label{sec:method} |
|
|
|
\begin{figure}[t] |
|
\centering |
|
\includegraphics[width=\linewidth]{pullfig_5.pdf} |
|
\caption{ |
|
Our approach takes a set of images, computes their deep features with a convolutional network and matches them to |
|
a set of predefined targets from a low dimensional space. The parameters of the network are learned |
|
by aligning the features to the targets. |
|
} |
|
\label{fig:pullfig} |
|
\end{figure} |
|
|
|
In this section, we present our model and discuss its relations with several clustering approaches including $k$-means. |
|
Figure~\ref{fig:pullfig} shows an overview of our approach. |
|
We also show that it can be trained on massive datasets using an online procedure. |
|
Finally, we provide all the implementation details. |
|
|
|
\subsection{Unsupervised learning} |
|
\label{sec:unsup} |
|
We are interested in learning visual features with no supervision. |
|
These features are produced by applying a parametrized mapping $f_\theta$ to the images. |
|
In the presence of supervision, the parameters $\theta$ are learned by minimizing a loss function between the |
|
features produced by this mapping and some given targets, e.g., labels. |
|
In absence of supervision, there is no clear target representations and we thus need to learn them as well. |
|
More precisely, given a set of $n$ images $x_i$, we jointly learn the parameters $\theta$ of the mapping $f_\theta$, |
|
and some target vectors $y_i$: |
|
\begin{equation} |
|
\label{eq:pb} |
|
\min_{\theta} \ \frac{1}{n} \sum_{i=1}^n \ \min_{y_i \in \mathbb{R}^d} \ \ell(f_\theta(x_i), y_i), |
|
\end{equation} |
|
where $d$ is the dimension of target vectors. |
|
In the rest of the paper, we use matrix notations, \ie, we denote by $Y$ |
|
the matrix whose rows are the target representations $y_i$, |
|
and by $X$ the matrix whose rows are the images $x_i$. |
|
With a slight abuse of notation, we denote by $f_\theta(X)$ the $n \times d$ matrix of features whose rows are obtained by applying the function $f_\theta$ to each image independently. |
|
|
|
\paragraph{Choosing the loss function.} |
|
In the supervised setting, a popular choice for the loss $\ell$ is the softmax function. |
|
However, computing this loss is linear in the number of targets, making it impractical |
|
for large output spaces~\citep{goodman2001classes}. |
|
While there are workarounds to scale these losses to large output spaces, |
|
\citet{CSTTW17} has recently shown that using a squared $\ell_2$ distance works well in many supervised settings, as long as the final activations are unit normalized. |
|
This loss only requires access to a single target per sample, making its computation independent of the number of targets. |
|
This leads to the following problem: |
|
\begin{equation}\label{eq:mat} |
|
\min_{\theta} \ \min_{Y\in\mathbb{R}^{n\times d}} \ \frac{1}{2n} \|f_\theta(X) - Y\|_F^2, |
|
\end{equation} |
|
where we still denote by $f_\theta(X)$ the unit normalized features. |
|
|
|
\paragraph{Using fixed target representations.} |
|
Directly solving the problem defined in Eq.~(\ref{eq:mat}) would lead to a |
|
representation collapsing problem: all the images would be assigned to the same representation~\citep{xu2004maximum}. |
|
We avoid this issue by fixing a set of $k$ predefined target representations and matching them |
|
to the visual features. |
|
More precisely, the matrix $Y$ is defined as the product of a matrix $C$ containing these $k$ representations and an assignment matrix $P$ in $\{0,1\}^{n \times k}$, \ie, |
|
\begin{equation} |
|
Y = P C. |
|
\end{equation} |
|
Note that we can assume that $k$ is greater than $n$ with no loss of generality (by duplicating representations otherwise). |
|
Each image is assigned to a different target and each target can only be assigned once. |
|
This leads to a set $\mathcal{P}$ of constraints for the assignment matrices: |
|
\begin{equation}\label{eq:p} |
|
\mathcal{P} = \{ P \in \{0,1\}^{n\times k} ~ | ~ P1_k \le 1_n, ~ P^\top 1_n = 1_k\}. |
|
\end{equation} |
|
This formulation forces the visual features to be diversified, avoiding the collapsing issue at the cost of fixing the target representations. |
|
Predefining these targets is an issue if their number $k$ is small, which is why we are interested in the case |
|
where $k$ is at least as large as the number $n$ of images. |
|
|
|
\paragraph{Choosing the target representations.} |
|
Until now, we have not discussed the set of target representations stored in $C$. |
|
A simple choice for the targets would be to take $k$ elements of the canonical basis of $\mathbb{R}^d$. |
|
If $d$ is larger than $n$, this formulation would be similar to the framework of~\citet{DSRB14}, and is |
|
impractical for large $n$. |
|
On the other hand, if $d$ is smaller than $n$, this formulation is equivalent to the discriminative |
|
clustering approach of~\citet{Bach07}. |
|
Choosing such targets makes very strong assumptions on the nature of the underlying problem. |
|
Indeed, it assumes that each image belongs to a unique class and that all classes are orthogonal. |
|
While this assumption might be true for some classification datasets, it does not generalize to huge image collections |
|
nor capture subtle similarities between images belonging to different classes. |
|
|
|
Since our features are unit normalized, |
|
another natural choice is to uniformly sample target vectors on the $\ell_2$ unit sphere. |
|
Note that the dimension $d$ will then directly influence the level of correlation |
|
between representations, \ie, the correlation is inversely proportional to the square root of $d$. |
|
Using this \emph{Noise As Targets} (NAT), Eq.~(\ref{eq:mat}) is now equivalent to: |
|
\begin{equation}\label{eq:lin} |
|
\max_\theta \max_{P\in\mathcal{P}} \text{Tr} \left ( P C f_\theta(X)^\top \right ). |
|
\end{equation} |
|
This problem can be interpreted as mapping deep features to a uniform distribution over a manifold, |
|
namely the $d$-dimension $\ell_2$ sphere. |
|
Using $k$ predefined representations is a discrete approximation of this manifold that justifies |
|
the restriction of the mapping matrices to the set $\mathcal{P}$ of $1$-to-$1$ assignment matrices. |
|
In some sense, we are optimizing a crude approximation of the earth mover's distance between the distribution |
|
of deep features and a given target distribution~\cite{rubner1998metric}. |
|
|
|
\paragraph{Relation to clustering approaches.} |
|
Using the same notations as in Eq.~(\ref{eq:lin}), |
|
several clustering approaches share similarities with our method. |
|
In the linear case, spherical $k$-means minimizes the same loss |
|
function w.r.t. $P$ and $C$, \ie, |
|
\begin{equation*} |
|
\max_C\max_{P\in\mathcal{Q}} \text{tr}\left(PCX^T\right). |
|
\end{equation*} |
|
A key difference is the set $\mathcal{Q}$ of assignment matrices: |
|
\begin{equation*} |
|
\mathcal{Q} = \{P\in\{0,1\}^{n\times k}~|~P 1_k = 1_n\}. |
|
\end{equation*} |
|
This set only guarantees that each data point is assigned to a single target representation. |
|
Once we jointly learn the features and the assignment, this set does not prevent |
|
the collapsing of the data points to a single target representation. |
|
|
|
Another similar clustering approach is Diffrac~\citep{Bach07}. Their loss is equivalent to ours |
|
in the case of unit normalized features. |
|
Their set $\mathcal{R}$ of assignment matrices, however, is different: |
|
\begin{equation*} |
|
\mathcal{R} = \{P\in\{0,1\}^{n\times k}~|~P^\top 1_n \ge c 1_k\}, |
|
\end{equation*} |
|
where $c>0$ is some fixed parameter. |
|
While restricting the assignment matrices to this set prevents the collapsing issue, |
|
it introduces global constraints that are not suited for online optimization. |
|
This makes their approach hard to scale to large datasets. |
|
|
|
|
|
|
|
\begin{algorithm}[t] |
|
\caption{ |
|
Stochastic optimization of Eq.~(\ref{eq:lin}). |
|
} |
|
\label{alg1} |
|
\begin{algorithmic} |
|
\REQUIRE $T$ batches of images, $\lambda_0>0$ |
|
\FOR{$t = \{1,\dots, T\}$} |
|
\item |
|
Obtain batch $b$ and representations $r$ |
|
\item |
|
Compute $f_\theta(X_b)$ |
|
\item |
|
Compute $P^*$ by minimizing Eq. (\ref{eq:mat}) w.r.t. $P$ |
|
\item |
|
Compute $\nabla_\theta L(\theta)$ from Eq.~(\ref{eq:mat}) with $P^*$ |
|
\item |
|
Update $\theta\leftarrow \theta - \lambda_t \nabla_\theta L(\theta)$ |
|
\ENDFOR |
|
\end{algorithmic} |
|
\end{algorithm} |
|
|
|
\subsection{Optimization} |
|
\label{sec:opt} |
|
In this section, we describe how to efficiently optimize the cost function described in Eq.~(\ref{eq:lin}). |
|
In particular, we explore approximated updates of the assignment matrix that are compatible |
|
with online optimization schemes, like stochastic gradient descent (SGD). |
|
|
|
\paragraph{Updating the assignment matrix $P$.} |
|
Directly solving for the optimal assignment requires to evaluate the distances between all the $n$ features and the $k$ representations. |
|
In order to efficiently solve this problem, we first reduce the number $k$ of representations to $n$. |
|
This limits the set $\mathcal{P}$ to the set of permutation matrices, \ie, |
|
\begin{equation}\label{eq:newp} |
|
\mathcal{P} = \{ P \in \{0,1\}^{n\times n} ~ | ~ P1_n = 1_n, ~ P^\top 1_n = 1_n\}. |
|
\end{equation} |
|
Restricting the problem defined in Eq.~(\ref{eq:lin}) to this set, the linear assignment problem in $P$ can be solved exactly |
|
with the Hungarian algorithm~\citep{kuhn1955hungarian}, but at the prohibitive cost of $O(n^3)$. |
|
|
|
Instead, we perform stochastic updates of the matrix. |
|
Given a batch of samples, we optimize the assignment matrix $P$ on its restriction to this batch. |
|
Given a subset $\mathcal{B}$ of $b$ distinct images, |
|
we only update the $b\times b$ square sub matrix $P_\mathcal{B}$ obtained by restricting $P$ |
|
to these $b$ images and their corresponding targets. |
|
In other words, each image can only be re-assigned to a target that was previously assigned to another image in the batch. |
|
This procedure has a complexity of $O(b^3)$ per batch, leading to an overall complexity of $O(n b^2)$, |
|
which is linear in the number of data points. |
|
We perform this update before updating the parameters $\theta$ of our features, in an on-line manner. |
|
Note that this simple procedure would not have been possible if $k > n$; |
|
we would have had to also consider the $k-n$ unassigned representations. |
|
|
|
\paragraph{Stochastic gradient descent.} |
|
Apart from the update of the assignment matrix $P$, |
|
we use the same optimization scheme as standard supervised approaches, \ie, |
|
SGD with batch normalization~\citep{ioffe2015}. |
|
As noted by~\citet{CSTTW17}, batch normalization plays a crucial role |
|
when optimizing the $\l_2$ loss, as it avoids exploding gradients. |
|
For each batch $b$ of images, we first perform a forward pass to compute the distance between the images and the corresponding subset of target representations $r$. |
|
The Hungarian algorithm is then used on these distances to obtain the optimal reassignments within the batch. |
|
Once the assignments are updated, we use the chain rule in order to compute the gradients of all our parameters. |
|
Our optimization algorithm is summarized in Algorithm~\ref{alg1}. |
|
|
|
|
|
|
|
\subsection{Implementation details} |
|
Our experiments solely focus on learning visual features with convnets. |
|
All the details required to train these architectures with our approach are described below. |
|
Most of them are standard tricks used in the usual supervised setting. |
|
|
|
\paragraph{Deep features.} |
|
To ensure a fair empirical comparison with previous work, we follow~\citet{WG15} and use an AlexNet architecture. |
|
We train it end to end using our unsupervised loss function. |
|
We subsequently test the quality of the learned visual feature by re-training a classifier on top. |
|
During transfer learning, we consider the output of the last convolutional layer as our features as in~\citet{razavian14}. |
|
We use the same multi-layer perceptron (MLP) as in~\citet{KSH12} for the classifier. |
|
|
|
\paragraph{Pre-processing.} |
|
We observe in practice that pre-processing the images greatly helps the quality of our learned features. |
|
As in~\citet{huang2007unsupervised}, we use image gradients instead of the images to avoid trivial solutions like clustering according to colors. |
|
Using this preprocessing is not surprising since most hand-made features like SIFT or HoG are based on image gradients~\citep{L99,dalal2005histograms}. |
|
In addition to this pre-processing, we also perform all the standard image transformations that are commonly applied in the supervised setting~\cite{KSH12}, |
|
such as random cropping and flipping of images. |
|
|
|
\begin{table}[t] |
|
\centering |
|
\begin{tabular}{@{}cccc@{}} |
|
\toprule |
|
&& Softmax & Square loss \\ |
|
\midrule |
|
ImageNet && 59.2 & 58.4 \\ |
|
\bottomrule |
|
\end{tabular} |
|
\caption{ |
|
Comparison between the softmax and the square loss for supervised object classification on ImageNet. |
|
The architecture is an AlexNet. The features are unit normalized for the square loss~\cite{CSTTW17}. We report the accuracy on the validation set. |
|
} |
|
\label{tab:l2loss} |
|
\end{table} |
|
|
|
\paragraph{Optimization details.} |
|
We project the output of the network on the $\ell_2$ sphere as in~\citet{CSTTW17}. |
|
The network is trained with SGD with a batch size of $256$. |
|
During the first $t_0$ batches, we use a constant step size. |
|
After $t_0$ batches, we use a linear decay of the step size, \ie, $l_t = \frac{l_0}{1 + \gamma [t - t_0]_+}$. |
|
Unless mentioned otherwise, we permute the assignments within batches every $3$ epochs. |
|
For the transfer learning experiments, we follow the guideline described in~\citet{DKD16}. |
|
|
|
|
|
\section{Experiments} |
|
\label{sec:exp} |
|
We perform several experiments to validate different design choices in NAT. |
|
We then evaluate the quality of our features by comparing them to state-of-the-art unsupervised approaches on several auxiliary supervised tasks, namely object classification on ImageNet and object classification and detection of \textsc{Pascal} VOC 2007~\citep{EVWWZ10}. |
|
|
|
\paragraph{Transfering the features.} |
|
In order to measure the quality of our features, we measure their performance on transfer learning. |
|
We freeze the parameters of all the convolutional layers and overwrite the parameters of the MLP classifier with random Gaussian weights. |
|
We precisely follow the training and testing procedure that is specific to each of the datasets following~\citet{DKD16}. |
|
|
|
\paragraph{Datasets and baselines.} |
|
We use the training set of ImageNet to learn our convolutional network~\citep{deng2009imagenet}. |
|
This dataset is composed of $1,281,167$ images that belong to $1,000$ object categories. |
|
For the transfer learning experiments, we also consider \textsc{Pascal} VOC 2007. |
|
In addition to fully supervised approaches~\citep{KSH12}, |
|
we compare our method to several unsupervised approaches, \ie, autoencoder, GAN and BiGAN as reported in~\citet{DKD16}. |
|
We also compare to self-supervised approaches, \ie, \citet{ACM15,DGE15,pathak2016context,WG15} and \citet{zhang2016colorful}. |
|
Finally we compare to state-of-the-art hand-made features, \ie, SIFT with Fisher Vectors (SIFT+FV)~\citep{akata2014good}. They reduce the Fisher Vectors to a $4,096$ dimensional vector with PCA, and apply an $8,192$ unit $3$-layer MLP on top. |
|
|
|
|
|
|
|
|
|
\subsection{Detailed analysis} |
|
In this section, we validate some of our design choices, like the loss function, representations and the influences of some parameters on the quality of our features. |
|
All the experiments are run on ImageNet. |
|
|
|
\paragraph{Softmax \emph{versus} square loss.} |
|
Table~\ref{tab:l2loss} compares the performance of an AlexNet trained with a softmax and a square loss. |
|
We report the accuracy on the validation set. |
|
The square loss requires the features to be unit normalized to avoid exploding gradients. |
|
As previously observed by~\citet{CSTTW17}, the performances are similar, hence validating our choice of loss function. |
|
|
|
\paragraph{Effect of image preprocessing.} |
|
In supervised classification, image pre-processing is not frequently used, and transformations that remove information are usually avoided. |
|
In the unsupervised case, however, we observe that is it is preferable to work with simpler inputs as it avoids learning trivial features. |
|
In particular, we observe that using grayscale image gradients greatly helps our method, as mentioned in Sec.~\ref{sec:method}. |
|
In order to verify that this preprocessing does not destroy crucial information, we propose to evaluate its effect on supervised classification. |
|
We also compare with high-pass filtering. |
|
Table~\ref{tab:degradation} shows the impact of this preprocessing methods on the accuracy of an AlexNet on the validation set of ImageNet. |
|
None of these pre-processings degrade the perform significantly, meaning that the information related to gradients are sufficient for |
|
object classification. This experiment confirms that such pre-processing does not lead to a significant drop in the |
|
upper bound performance for our model. |
|
|
|
\begin{table}[t] |
|
\centering |
|
\begin{tabular}{@{}rrrrr@{}} |
|
\toprule |
|
& clean & high-pass & sobel \\ |
|
\midrule |
|
acc@1 & 59.7 & 58.5 & 57.4 \\ |
|
\bottomrule |
|
\end{tabular} |
|
\caption{ |
|
Performance of supervised models with various image pre-processings applied. |
|
We train an AlexNet on ImageNet, and report classification accuracy. |
|
} |
|
\label{tab:degradation} |
|
\end{table} |
|
|
|
\paragraph{Continuous \emph{versus} discrete representations.} |
|
We compare our choice for the target vectors to those commonly used for clustering, \ie, elements of the canonical basis of a $k$ dimensional space. |
|
Such discrete representation make a strong assumption on the underlying structure of the problem, that it can be linearly separated in $k$ different classes. |
|
This assumption holds for ImageNet giving a fair advantage to this discrete representation. We test this representation with k in $\{10^3, 10^4, 10^5\}$, which |
|
is a range well-suited for the $1,000$ classes of ImageNet. |
|
The matrix $C$ contains $n/k$ replications of $k$ elements of the canonical basis. This assumes that the clusters are balanced, which is verified on ImageNet. |
|
|
|
We compare these cluster-like representations to our continuous target vectors on the transfer task on ImageNet. |
|
Using discrete targets achieves an accuracy of $19\%$, which is significantly worse that our best performance, \ie, $33.5\%$. |
|
A possible explanation is that binary vectors induce sharp discontinuous distances between representations. |
|
Such distances are hard to optimize over and may result in early convergence to poorer local minima. |
|
|
|
\begin{figure}[t] |
|
\centering |
|
\includegraphics[height=10em]{epochs.pdf} |
|
\includegraphics[height=10em]{periods.pdf} |
|
\caption{ |
|
On the left, we measure the accuracy on ImageNet after training the features with different permutation rates |
|
There is a clear trade-off with an optimum at permutations performed every $3$ epochs. |
|
On the right, we measure the accuracy on ImageNet after training the features with our unsupervised approach as a function of the number of epochs. |
|
The performance improves with longer unsupervised training. |
|
} |
|
\label{fig:epochs} |
|
\end{figure} |
|
|
|
\paragraph{Evolution of the features.} |
|
In this experiment, we are interested in understanding how the quality of our features evolves with the optimization of our cost function. |
|
During the unsupervised training, we freeze the network every 20 epochs and learn a MLP classifier on top. We report the accuracy on the validation set |
|
of ImageNet. |
|
Figure~\ref{fig:epochs} shows the evolution of the performance on this transfer task as we optimize for our unsupervised approach. |
|
The training performance improves monotonically with the epochs of the unsupervised training. |
|
This suggests that optimizing our objective function correlates with learning transferable features, \ie, our features do not destroy useful |
|
class-level information. |
|
On the other hand, the test accuracy seems to saturate after a hundred epochs. This suggests that the MLP is overfitting rapidly on pre-trained features. |
|
|
|
\paragraph{Effect of permutations.} |
|
Assigning images to their target representations is a crucial feature of our approach. |
|
In this experiment, we are interested in understanding how frequently we should update this assignment. |
|
Indeed, updating the assignment, even partially, is relatively costly and may not be required to achieve |
|
good performance. |
|
Figure~\ref{fig:epochs} shows the transfer accuracies on ImageNet as a function of the frequency of these updates. |
|
The model is quite robust to choice of frequency, with a test accuracy always above $30\%$. |
|
Interestingly, the accuracy actually degrades slightly with high frequency. |
|
A possible explanation is that the network overfits rapidly to its own output, leading to relatively worse features. |
|
In practice, we observe that updating the assignment matrix every $3$ epochs offers a good trade-off between |
|
performance and accuracy. |
|
|
|
\begin{figure*}[t!] |
|
\centering |
|
\begin{tabular}{ccccccc} |
|
\includegraphics[width=.11\linewidth]{13_1.jpg} & |
|
\includegraphics[width=.11\linewidth]{7_1.jpg} & |
|
\includegraphics[width=.11\linewidth]{510300_1.jpg} & |
|
\includegraphics[width=.11\linewidth]{133334_1.jpg} & |
|
\includegraphics[width=.11\linewidth]{110_1.jpg} & |
|
\includegraphics[width=.11\linewidth]{34_1.jpg} & |
|
\includegraphics[width=.11\linewidth]{4_1.jpg} \\ |
|
\includegraphics[width=.11\linewidth]{13_2.jpg}& |
|
\includegraphics[width=.11\linewidth]{7_2.jpg} & |
|
\includegraphics[width=.11\linewidth]{510300_2.jpg} & |
|
\includegraphics[width=.11\linewidth]{133334_2.jpg} & |
|
\includegraphics[width=.11\linewidth]{110_2.jpg} & |
|
\includegraphics[width=.11\linewidth]{34_2.jpg} & |
|
\includegraphics[width=.11\linewidth]{4_2.jpg} \\ |
|
\includegraphics[width=.11\linewidth]{13_3.jpg} & |
|
\includegraphics[width=.11\linewidth]{7_3.jpg} & |
|
\includegraphics[width=.11\linewidth]{510300_3.jpg} & |
|
\includegraphics[width=.11\linewidth]{133334_3.jpg} & |
|
\includegraphics[width=.11\linewidth]{110_3.jpg} & |
|
\includegraphics[width=.11\linewidth]{34_3.jpg} & |
|
\includegraphics[width=.11\linewidth]{4_3.jpg}\\ |
|
\includegraphics[width=.11\linewidth]{13_4.jpg}& |
|
\includegraphics[width=.11\linewidth]{7_4.jpg} & |
|
\includegraphics[width=.11\linewidth]{510300_4.jpg} & |
|
\includegraphics[width=.11\linewidth]{133334_4.jpg} & |
|
\includegraphics[width=.11\linewidth]{110_4.jpg} & |
|
\includegraphics[width=.11\linewidth]{34_4.jpg} & |
|
\includegraphics[width=.11\linewidth]{4_4.jpg} |
|
\end{tabular} |
|
\caption{ |
|
Images and their $3$ nearest neighbors in ImageNet according to our model using an $\ell_2$ distance. |
|
The query images are shown on the top row, and the nearest neighbors are sorted from the closer to |
|
the further. |
|
Our features seem to capture global distinctive structures. |
|
} |
|
\label{fig:nn} |
|
\end{figure*} |
|
|
|
\begin{figure}[t] |
|
\centering |
|
\includegraphics[width=.49\linewidth]{bnw-filters-sup-new.jpg} |
|
\includegraphics[width=.49\linewidth]{bnw-filters-new.jpg} |
|
\caption{ |
|
Filters form the first layer of an AlexNet trained on ImageNet with supervision (left) or with NAT (right). |
|
The filters are in grayscale, since we use grayscale gradient images as input. |
|
This visualization shows the composition of the gradients with the first layer. |
|
} |
|
\label{fig:filters} |
|
\end{figure} |
|
|
|
\paragraph{Visualizing the filters.} |
|
Figure~\ref{fig:filters} shows a comparison between the first convolutional layer of an AlexNet trained with and without supervision. |
|
Both take grayscale gradient images as input. |
|
The visualization are obtained by composing the Sobel filtering with the filters of the first layer of the AlexNet. |
|
Unsupervised filters are slightly less sharp than their supervised counterpart, but still maintain edge and orientation information. |
|
|
|
\paragraph{Nearest neighbor queries.} |
|
Our loss optimizes a distance between features and fixed vectors. This means that looking at the distance between |
|
features should provide some information about the type of structure that our model captures. |
|
Given a query image $x$, we compute its feature $f_\theta(x)$ and search for its nearest neighbors according to the $\ell_2$ distance. |
|
Figure~\ref{fig:nn} shows images and their nearest neighbors. |
|
|
|
The features capture relatively complex structures in images. |
|
Objects with distinctive structures, like trunks or fruits, are well captured by our approach. |
|
However, this information is not always related to true labels. |
|
For example, the image of bird over the sea is matched to images capturing information about the sea or the sky rather than the bird. |
|
|
|
|
|
|
|
\subsection{Comparison with the state of the art} |
|
We report results on the transfer task both on ImageNet and \textsc{Pascal} VOC 2007. |
|
In both cases, the model is trained on ImageNet. |
|
|
|
|
|
|
|
\paragraph{ImageNet classification.} |
|
In this experiment, we evaluate the quality of our features for the object classification task of ImageNet. |
|
Note that in this setup, we build the unsupervised features on images that correspond to predefined image categories. |
|
Even though we do not have access to category labels, the data itself is biased towards these classes. |
|
In order to evaluate the features, we freeze the layers up to the last convolutional layer and train the classifier with supervision. |
|
This experimental setting follows~\citet{NF16}. |
|
|
|
We compare our model with several self-supervised approaches~\cite{WG15, DGE15, zhang2016colorful} and an unsupervised |
|
approach, \ie,~\citet{DKD16}. |
|
Note that self-supervised approaches use losses specifically designed for visual features. |
|
Like BiGANs~\citep{DKD16}, NAT does not make any assumption about the domain but of the structure of its features. |
|
Table~\ref{tab:in2in} compares NAT with these approaches. |
|
|
|
\begin{table}[t] |
|
\centering |
|
\begin{tabular}{@{}lr@{}} |
|
\toprule |
|
Method& Acc@1 \\ |
|
\midrule |
|
Random~\citep{NF16} & 12.0 \\ |
|
\midrule |
|
SIFT+FV~\cite{akata2014good} & 55.6 \\ |
|
\midrule |
|
\citet{WG15} & 29.8 \\ |
|
\citet{DGE15} & 30.4 \\ |
|
\citet{zhang2016colorful} & 35.2 \\ |
|
$^1$\citet{NF16} & 38.1 \\ |
|
\midrule |
|
BiGAN~\citep{DKD16} & 32.2 \\ |
|
\midrule |
|
NAT & 36.0 \\ |
|
\bottomrule |
|
\end{tabular} |
|
\caption{ |
|
Comparison of the proposed approach to state-of-the-art unsupervised feature learning on ImageNet. |
|
A full multi-layer perceptron is retrained on top of the features. |
|
We compare to several self-supervised approaches and an unsupervised approach, \ie, BiGAN~\cite{DKD16}. |
|
$^1$\citet{NF16} uses a significantly larger amount of features than the original AlexNet. |
|
We report classification accuracy. |
|
} |
|
\label{tab:in2in} |
|
\end{table} |
|
|
|
Among unsupervised approaches, NAT compares favorably to BiGAN~\citep{DKD16}. |
|
Interestingly, the performance of NAT are slightly better than \emph{self-supervised} methods, even though we do not |
|
explicitly use domain-specific clues in images or videos to guide the learning. |
|
While all the models provide performance in the $30-36\%$ range, |
|
it is not clear if they all learn the same features. |
|
Finally, all the unsupervised deep features are outperformed by hand-made features, |
|
in particular Fisher Vectors with SIFT descriptors. |
|
This baseline uses a slightly bigger MLP for the classifier and its performance can be improved by $2.2\%$ |
|
by bagging $8$ of these models. |
|
This difference of $20\%$ in accuracy shows that unsupervised deep features are still quite far from |
|
the state-of-the-arts among \emph{all} unsupervised features. |
|
|
|
|
|
|
|
\paragraph{Transferring to \textsc{Pascal} VOC 2007.} |
|
We carry out a second transfer experiment on the \textsc{Pascal} VOC dataset, on the classification and detection tasks. |
|
The model is trained on ImageNet. |
|
Depending on the task, we \emph{finetune} all layers in the network, or solely the classifier, following~\citet{DKD16}. |
|
In all experiments, the parameters of the convolutional layers are initialized with the ones obtained with our unsupervised approach. |
|
The parameters of the classification layers are initialized with gaussian weights. |
|
We get rid of batch normalization layers and use a data-dependent rescaling of the parameters~\cite{krahenbuhl2015data}. |
|
Table~\ref{tab:voc} shows the comparison between our model and other unsupervised approaches. |
|
The results for other methods are taken from~\citet{DKD16} except for~\citet{zhang2016colorful}. |
|
|
|
\begin{table}[t] |
|
\centering |
|
\begin{tabular}{@{}lccc@{}} |
|
\toprule |
|
& \multicolumn{2}{c}{Classification} & Detection \\ |
|
\midrule |
|
Trained layers & fc6-8 & all & all \\ |
|
\midrule |
|
ImageNet labels & 78.9 & 79.9 & 56.8 \\ |
|
\midrule |
|
\citet{ACM15} & 31.0 & 54.2 & 43.9 \\ |
|
\citet{pathak2016context} & 34.6 & 56.5 & 44.5\\ |
|
\citet{WG15} & 55.6 & 63.1 & 47.4 \\ |
|
\citet{DGE15} & 55.1 & 65.3 & 51.1 \\ |
|
\citet{zhang2016colorful} & 61.5 & 65.6 & 46.9 \\ |
|
\midrule |
|
Autoencoder & 16.0 & 53.8 & 41.9 \\ |
|
GAN & 40.5 & 56.4 & - \\ |
|
BiGAN~\citep{DKD16} & 52.3 & 60.1 & 46.9 \\ |
|
\midrule |
|
NAT & 56.7 & 65.3 & 49.4 \\ |
|
\bottomrule |
|
\end{tabular} |
|
\caption{ |
|
Comparison of the proposed approach to state-of-the-art unsupervised feature learning on VOC 2007 Classification and detection. |
|
We either fix the features after conv5 or we fine-tune the whole model. |
|
We compare to several self-supervised and an unsupervised approaches. |
|
The GAN and autoencoder baselines are from~\citet{DKD16}. |
|
We report mean average prevision as customary on \textsc{Pascal} VOC. |
|
} |
|
\label{tab:voc} |
|
\end{table} |
|
|
|
As with the ImageNet classification task, our performance is on par with self-supervised approaches, for both detection and classification. |
|
Among purely unsupervised approaches, we outperform standard approaches like autoencoders or GANs by a large margin. |
|
Our model also performs slightly better than the best performing BiGAN model~\citep{DKD16}. |
|
These experiments confirm our findings from the ImageNet experiments. |
|
Despite its simplicity, NAT learns feature that are as good as those obtained with more sophisticated and data-specific models. |
|
|
|
|
|
\section{Conclusion} |
|
|
|
This paper presents a simple unsupervised framework to learn discriminative features. |
|
By aligning the output of a neural network to low-dimensional noise, we obtain |
|
features on par with state-of-the-art unsupervised learning approaches. |
|
Our approach explicitly aims at learning discriminative features, while most unsupervised approaches |
|
target surrogate problems, like image denoising or image generation. |
|
As opposed to self-supervised approaches, we make very few assumptions about the input space. |
|
This makes our appproach very simple and fast to train. |
|
Interestingly, it also shares some similarities with traditional clustering approaches as well as retrieval methods. |
|
While we show the potential of our approach on visual data, it will be interesting to try other domains. |
|
Finally, this work only considers simple noise distributions and alignment methods. A possible direction of research is to |
|
explore target distributions and alignments that are more informative. This also would strengthen the relation |
|
between NAT and methods based on distribution matching like the earth mover distance. |
|
|
|
\paragraph{Acknowledgement.} |
|
We greatly thank Herv\'e J\'egou for his help throughout the development of this project. |
|
We also thank Allan Jabri, Edouard Grave, Iasonas Kokkinos, L\'eon Bottou, Matthijs Douze and the rest of FAIR |
|
for their support and helpful discussion. |
|
Finally, we thank Richard Zhang, Jeff Donahue and Florent Perronnin for their help. |
|
|
|
\bibliographystyle{icml2016} |
|
\bibliography{egbib} |
|
|
|
\end{document} |
|
|