Lightweight framework for learning with side information (aka privileged information), based on Theano and Lasagne. For more info on learning with side information see http://arxiv.org/abs/1511.06429
Understanding how images of objects and scenes behave in response to specific ego-motions is a crucial aspect of proper visual development, yet existing visual learning methods are conspicuously disconnected from the physical source of their images. We propose to exploit proprioceptive motor signals to provide unsupervised regularization in convolutional neural networks to learn visual representations from egocentric video. Specifically, we enforce that our learned features exhibit equivariance i.e. they respond predictably to transformations associated with distinct ego-motions. With three datasets, we show that our unsupervised feature learning approach significantly outperforms previous approaches on visual recognition and next-best-view prediction tasks. In the most challenging test, we show that features learned from video captured on an autonomous driving platform improve large-scale scene recognition in static images from a disjoint domain.READ FULL TEXT VIEW PDF
This paper presents a novel yet intuitive approach to unsupervised featu...
Visual Recognition is one of the fundamental challenges in AI, where the...
Spiking neural networks (SNNs) equipped with latency coding and spike-ti...
Semantic scene segmentation has primarily been addressed by forming
This paper entertains the hypothesis that the primary purpose of the cel...
Humans can effortlessly imagine the occluded side of objects in a photog...
A panoramic image mosaic is an attractive visualization for viewing many...
Lightweight framework for learning with side information (aka privileged information), based on Theano and Lasagne. For more info on learning with side information see http://arxiv.org/abs/1511.06429
How is visual learning shaped by ego-motion? In their famous “kitten carousel” experiment, psychologists Held and Hein examined this question in 1963 . To analyze the role of self-produced movement in perceptual development, they designed a carousel-like apparatus in which two kittens could be harnessed. For eight weeks after birth, the kittens were kept in a dark environment, except for one hour a day on the carousel. One kitten, the “active” kitten, could move freely of its own volition while attached. The other kitten, the “passive” kitten, was carried along in a basket and could not control his own movement; rather, he was forced to move in exactly the same way as the active kitten. Thus, both kittens received the same visual experience. However, while the active kitten simultaneously experienced signals about his own motor actions, the passive kitten did not. The outcome of the experiment is remarkable. While the active kitten’s visual perception was indistinguishable from kittens raised normally, the passive kitten suffered fundamental problems. The implication is clear: proper perceptual development requires leveraging self-generated movement in concert with visual feedback.
We contend that today’s visual recognition algorithms are crippled much like the passive kitten. The culprit: learning from “bags of images”. Ever since statistical learning methods emerged as the dominant paradigm in the recognition literature, the norm has been to treat images as i.i.d. draws from an underlying distribution. Whether learning object categories, scene classes, body poses, or features themselves, the idea is to discover patterns within a collection of snapshots, blind to their physical source. So is the answer to learn from video? Only partially. Without leveraging the accompanying motor signals initiated by the videographer, learning from video data does not escape the passive kitten’s predicament.
Inspired by this concept, we propose to treat visual learning as an embodied process, where the visual experience is inextricably linked to the motor activity behind it.111Depending on the context, the motor activity could correspond to either the 6-DOF ego-motion of the observer moving in the scene or the second-hand motion of an object being actively manipulated, e.g., by a person or robot’s end effectors. In particular, our goal is to learn representations that exploit the parallel signals of ego-motion and pixels. We hypothesize that downstream processing will benefit from a feature space that preserves the connection between “how I move” and “how my visual surroundings change”.
To this end, we cast the problem in terms of unsupervised equivariant feature learning. During training, the input image sequences are accompanied by a synchronized stream of ego-motor sensor readings; however, they need not possess any semantic labels. The ego-motor signal could correspond, for example, to the inertial sensor measurements received alongside video on a wearable or car-mounted camera. The objective is to learn a feature mapping from pixels in a video frame to a space that is equivariant to various motion classes. In other words, the learned features should change in predictable and systematic ways as a function of the transformation applied to the original input. See Fig 1. We develop a convolutional neural network (CNN) approach that optimizes a feature map for the desired egomotion-based equivariance. To exploit the features for recognition, we augment the network with a classification loss when class-labeled images are available. In this way, ego-motion serves as side information to regularize the features learned, which we show facilitates category learning when labeled examples are scarce.
In sharp contrast to our idea, previous work on visual features—whether hand-designed or learned—primarily targets feature invariance. Invariance is a special case of equivariance, where transformations of the input have no effect. Typically, one seeks invariance to small transformations, e.g., the orientation binning and pooling operations in SIFT/HOG and modern CNNs both target invariance to local translations and rotations. While a powerful concept, invariant representations require a delicate balance: “too much” invariance leads to a loss of useful information or discriminability. In contrast, more general equivariant representations are intriguing for their capacity to impose structure on the output space without forcing a loss of information. Equivariance is “active” in that it exploits observer motor signals, like Hein and Held’s active kitten.
Our main contribution is a novel feature learning approach that couples ego-motor signals and video. To our knowledge, ours is the first attempt to ground feature learning in physical activity. The limited prior work on unsupervised feature learning with video [22, 24, 21, 9] learns only passively from observed scene dynamics, uninformed by explicit motor sensory cues. Furthermore, while equivariance is explored in some recent work, unlike our idea, it typically focuses on 2D image transformations as opposed to 3D ego-motion [14, 26] and considers existing features [30, 17]. Finally, whereas existing methods that learn from image transformations focus on view synthesis applications [12, 15, 21], we explore recognition applications of learning jointly equivariant and discriminative feature maps.
We apply our approach to three public datasets. On pure equivariance as well as recognition tasks, our method consistently outperforms the most related techniques in feature learning. In the most challenging test of our method, we show that features learned from video captured on a vehicle can improve image recognition accuracy on a disjoint domain. In particular, we use unlabeled KITTI [6, 7] car data to regularize feature learning for the 397-class scene recognition task for the SUN dataset . Our results show the promise of departing from the “bag of images” mindset, in favor of an embodied approach to feature learning.
Invariance is a special case of equivariance, wherein a transformed output remains identical to its input. Invariance is known to be valuable for visual representations. Descriptors like SIFT, HOG, and aspects of CNNs like pooling and convolution, are hand-designed for invariance to small shifts and rotations. Feature learning work aims to learn invariances from data [27, 28, 31, 29, 5]. Strategies include augmenting training data by perturbing image instances with label-preserving transformations [28, 31, 5]
, and inserting linear transformation operators into the feature learning algorithm.
Most relevant to our work are feature learning methods based on temporal coherence and “slow feature analysis” [32, 10, 22]. The idea is to require that learned features vary slowly over continuous video, since visual stimuli can only gradually change between adjacent frames. Temporal coherence has been explored for unsupervised feature learning with CNNs [22, 37, 9, 3, 19], with applications to dimensionality reduction , object recognition [22, 37], and metric learning . Temporal coherence of inferred body poses in unlabeled video is exploited for invariant recognition in . These methods exploit video as a source of free supervision to achieve invariance, analogous to the image perturbations idea above. In contrast, our method exploits video coupled with ego-motor signals to achieve the more general property of equivariance.
Equivariant features can also be hand-designed or learned. For example, equivariant or “co-variant” operators are designed to detect repeatable interest points . Recent work explores ways to learn descriptors with in-plane translation/rotation equivariance [14, 26]. While the latter does perform feature learning, its equivariance properties are crafted for specific 2D image transformations. In contrast, we target more complex equivariances arising from natural observer motions (3D ego-motion) that cannot easily be crafted, and our method learns them from data.
Methods to learn representations with disentangled latent factors [12, 15] aim to sort properties like pose, illumination into distinct portions of the feature space. For example, the transforming auto-encoder learns to explicitly represent instantiation parameters of object parts in equivariant hidden layer units . Such methods target equivariance in the limited sense of inferring pose parameters, which are appended to a conventional feature space designed to be invariant. In contrast, our formulation encourages equivariance over the complete feature space; we show the impact as an unsupervised regularizer when training a recognition model with limited training data.
The work of  quantifies the invariance/equivariance of various standard representations, including CNN features, in terms of their responses to specified in-plane 2D image transformations (affine warps, flips of the image). We adopt the definition of equivariance used in that work, but our goal is entirely different. Whereas  quantifies the equivariance of existing descriptors, our approach learns a feature space that is equivariant.
Other methods train with pairs of transformed images and infer an implicit representation for the transformation itself. In 
, bilinear models with multiplicative interactions are used to learn content-independent “motion features” that encode only the transformation between image pairs. One such model, the “gated autoencoder” is extended to perform sequence prediction for video in
. Recurrent neural networks combined with a grammar model of scene dynamics can also predict future frames in video. Whereas these methods learn a representation for image pairs (or tuples) related by some transformation, we learn a representation for individual images in which the behavior under transformations is predictable. Furthermore, whereas these prior methods abstract away the image content, our method preserves it, making our features relevant for recognition.
There is renewed interest in egocentric computer vision methods, though none perform feature learning using motor signals and pixels in concert as we propose. Recent methods use ego-motion cues to separate foreground and background[25, 35] or infer the first-person gaze [36, 18]. While most work relies solely on apparent image motion, the method of  exploits a robot’s motor signals to detect moving objects and 
uses reinforcement learning to form robot movement policies by exploiting correlations between motor commands and observed motion cues.
Our goal is to learn an image representation that is equivariant with respect to ego-motion transformations. Let be an image in the original pixel space, and let be its associated ego-pose representation. The ego-pose captures the available motor signals, and could take a variety of forms. For example, may encode the complete observer camera pose (its position in 3D space, pitch, yaw, roll), some subset of those parameters, or any reading from a motor sensor paired with the camera.
As input to our learning algorithm, we have a training set of image pairs and their associated ego-poses, . The image pairs originate from video sequences, though they need not be adjacent frames in time. The set may contain pairs from multiple videos and cameras. Note that this training data does not have any semantic labels (object categories, ); they are “labeled” only in terms of the ego-motor sensor readings.
In the following, we first explain how to translate ego-pose information into pairwise “motion pattern” annotations (Sec 3.1). Then, Sec 6.3 defines the precise nature of the equivariance we seek, and Sec 3.3 defines our learning objective. Sec 3.4 shows how our equivariant feature learning scheme may be used to enhance recognition with limited training data. Finally, in Sec 3.5, we show how a feedforward neural network architecture may be trained to produce the desired equivariant feature space.
First we want to organize training sample pairs into a discrete set of ego-motion patterns. For instance, one ego-motion pattern might correspond to “tilt downwards by approximately 20°”. While one could collect new data explicitly controlling for the patterns (e.g., with a turntable and camera rig), we prefer a data-driven approach that can leverage video and ego-pose data collected “in the wild”.
To this end, we discover clusters among pose difference vectorsfor pairs of temporally close frames from video (typically 1 second apart; see Sec 4.1 for details). For simplicity we apply -means to find clusters, though other methods are possible. Let denote the motion pattern ID, , the cluster to which belongs. We can now replace the ego-pose vectors in with motion pattern IDs: . 222For movement with degrees of freedom, setting should suffice (cf. Sec 6.3). We chose small for speed and did not vary it.
The left panel of Fig 1 illustrates a set of motion patterns discovered from videos in the KITTI  dataset, which are captured from a moving car. Here consists of the position and yaw angle of the camera. So, we are clustering a 2D space consisting of forward distance and change in yaw. As illustrated in the center panel, the largest clusters correspond to the car’s three primary ego-motions: turning left, turning right, and going forward.
Given , we wish to learn a feature mapping function parameterized by that maps a single image to a -dimensional vector space that is equivariant to ego-motion. To be equivariant, the function must respond systematically and predictably to ego-motion:
for some function . We consider equivariance for linear functions , following . In this case, is said to be equivariant with respect to some transformation if there exists a matrix333bias dimension assumed to be included in for notational simplicity such that:
Such an is called the “equivariance map” of on the feature space . It represents the affine transformation in the feature space that corresponds to transformation in the pixel space. For example, suppose a motion pattern corresponds to a yaw turn of 20°, and and are the images observed before and after the turn, respectively. Equivariance demands that there is some matrix that maps the pre-turn image to the post-turn image, once those images are expressed in the feature space . Hence, “organizes” the feature space in such a way that movement in a particular direction in the feature space (here, as computed by multiplication with ) has a predictable outcome. The linear case, as also studied in , ensures that the structure of the mapping has a simple form, and is convenient for learning since can be encoded as a fully connected layer in a neural network.
While prior work [14, 26] focuses on equivariance where is a 2D image warp, we explore the case where is an ego-motion pattern (cf. Sec 3.1) reflecting the observer’s 3D movement in the world. In theory, appearance changes of an image in response to an observer’s ego-motion are not determined by the ego-motion alone. They also depend on the depth map of the scene and the motion of dynamic objects in the scene. One could easily augment either the frames or the ego-pose with depth maps, when available. Non-observer motion appears more difficult, especially in the face of changing occlusions and newly appearing objects. However, our experiments indicate we can learn effective representations even with dynamic objects. In our implementation, we train with pairs relatively close in time, so as to avoid some of these pitfalls.
While during training we target equivariance for the discrete set of ego-motions, the learned feature space will not be limited to preserving equivariance for pairs originating from the same ego-motions. This is because the linear equivariance maps are composable. If we are operating in a space where every ego-motion can be composed as a sequence of “atomic” motions, equivariance to those atomic motions is sufficient to guarantee equivariance to all motions. To see this, suppose that the maps for “turn head right by 10°” (ego-motion pattern ) and “turn head up by 10°” (ego-motion pattern ) are respectively and , , and for all . Now for a novel diagonal motion that can be composed from these atomic motions as , we have
so that is the equivariance map for novel ego-motion , even though was not among . This property lets us restrict our attention to a relatively small number of discrete ego-motion patterns during training, and still learn features equivariant w.r.t. new ego-motions.
We now design a loss function that encourages the learned feature spaceto exhibit equivariance with respect to each ego-motion pattern. Specifically, we would like to learn the optimal feature space parameters jointly with its equivariance maps for the motion pattern clusters through (cf. Sec 3.1).
To achieve this, a naive translation of the definition of equivariance in Eq (2) into a minimization problem over feature space parameters and the equivariance map candidate matrices would be as follows:
where is a distance measure. This problem can be decomposed into independent optimization problems, one for each motion, corresponding only to the inner summation above, and dealing with disjoint data. The -th such problem requires only that training frame pairs annotated with motion pattern approximately satisfy Eq (2).
However, such a formulation admits problematic solutions that perfectly optimize it, for the trivial all-zero feature space with
set to the all-zeros matrix for all, the loss above evaluates to zero. To avoid such solutions, and to force the learned ’s to be different from one another (since we would like the learned representation to respond differently to different ego-motions), we simultaneously account for the “negatives” of each motion pattern. Our learning objective is:
where is a “contrastive loss”  specific to motion pattern :
where is the indicator function. This contrastive loss penalizes distance between and in “positive” mode (when ), and pushes apart pairs in “negative” mode (when ), up to a minimum margin distance specified by the constant . We use the norm for the distance .
In our objective in Eq (5), the contrastive loss operates in the latent feature space. For pairs belonging to cluster , the contrastive loss penalizes feature space distance between the first image and its transformed pair, similar to Eq (4) above. For pairs belonging to clusters other than , requires that the transformation defined by must not bring the image representations close together. In this way, our objective learns the ’s jointly. It ensures that distinct ego-motions, when applied to an input , map it to different locations in feature space.
We want to highlight the important distinctions between our objective and the “temporal coherence” objective of  for slow feature analysis. Written in our notation, the objective of  may be stated as:
where are the video time indices of , and
is a temporal neighborhood size hyperparameter. This loss encourages the representations of nearby frames to be similar to one another. However, crucially, it does not account for the nature of the ego-motion between the frames. Accordingly, while temporal coherence helps learn invariance to small image changes, it does not target a (more general) equivariant space. Like the passive kitten from Hein and Held’s experiment, the temporal coherence constraint watches video to passively learn a representation; like the active kitten, our method registers theobserver motion explicitly with the video to learn more effectively, as we will demonstrate in results.
While we have thus far described our formulation for generic equivariant image representation learning, it can optionally be used for visual recognition tasks. Suppose that in addition to the ego-pose annotated pairs we are also given a small set of class-labeled static images, , where . Let denote the unsupervised equivariance loss of Eq (5). We can integrate our unsupervised feature learning scheme with the recognition task, by optimizing a misclassification loss together with . Let be a
matrix of classifier weights. We solve jointly forand the maps :
where denotes the softmax loss over the learned features, , and
is the softmax probability of the correct class. The regularizer weightis a hyperparameter. Note that neither the supervised training data nor the testing data for recognition are required to have any associated sensor data. Thus, our features are applicable to standard image recognition tasks.
In this use case, the unsupervised ego-motion equivariance loss encodes a prior over the feature space that can improve performance on the supervised recognition task with limited training examples. We hypothesize that a feature space that embeds knowledge of how objects change under different viewpoints / manipulations allows a recognition system to, in some sense, hallucinate new views of an object to improve performance.
For the mapping , we use a convolutional neural network architecture, so that the parameter vector now represents the layer weights. The loss of Eq (5) is optimized by sharing the weight parameters among two identical stacks of layers in a “Siamese” network [2, 10, 22], as shown in the top two rows of Fig 3. Image pairs from
are fed into these two stacks. Both stacks are initialized with identical random weights, and identical gradients are passed through them in every training epoch, so that the weights remain tied throughout. Each stack encodes the feature map that we wish to train,.
To optimize Eq (5), an array of equivarance maps , each represented by a fully connected layer, is connected to the top of the second stack. Each such equivariance map then feeds into a motion-pattern-specific contrastive loss function , whose other inputs are the first stack output and the ego-motion pattern ID .
To optimize Eq (8), in addition to the Siamese net that minimizes as above, the supervised softmax loss is minimized through a third replica of the layer stack with weights tied to the two Siamese networks stacks. Labelled images from
are fed into this stack, and its output is fed into a softmax layer whose other input is the class label. The complete scheme is depicted in Fig313] (more details in Sec 4 and Supp).
|Tasks||Equivariance error||Recognition accuracy %||Next-best view|
|Methods||atomic||composite||[25 cls]||[4 cls]||[397 cls]||[397 cls, top-10]||1-view 2-view|
|temporal ||0.7587||0.8119||35.470.51||45.121.21||1.210.14||8.240.25||29.60 31.90|
|drlim ||0.6404||0.7263||36.600.41||47.040.50||1.020.12||6.780.32||14.89 17.95|
We validate our approach on 3 public datasets and compare to two existing methods, on equivariance (Sec 4.2), recognition performance (Sec 4.3) and next-best view selection (Sec 4.4). Throughout we compare the following methods:
clsnet: A neural network trained only from the supervised samples with a softmax loss.
equiv: Our ego-motion equivariant feature learning approach, combined with the classification loss as in Eq (8), unless otherwise noted below.
equiv+drlim: Our approach augmented with temporal coherence regularization ().
temporal and drlim are the most pertinent baselines because they, like us, use contrastive loss-based formulations, but represent the popular “slowness”-based family of techniques ([37, 3, 9, 19]) for unsupervised feature learning from video, which, unlike our approach, are passive.
Recall that in the fully unsupervised mode, our method trains with pairs of video frames annotated only by their ego-poses in . In the supervised mode, when applied to recognition, our method additionally has access to a set of class-labeled images in . Similarly, the baselines all receive a pool of unsupervised data and supervised data. We now detail the data composing these two sets.
We consider two unsupervised datasets, NORB and KITTI:
(1) NORB : This dataset has 24,300 9696-pixel images of 25 toys captured by systematically varying camera pose. We generate a random 67%-33% train-validation split and use 2D ego-pose vectors consisting of camera elevation and azimuth. Because this dataset has discrete ego-pose variations, we consider two ego-motion patterns, , (cf. Sec 3.1): one step along elevation and one step along azimuth. For equiv, we use all available positive pairs for each of the two motion patterns from the training images, yielding a -pair training set. For drlim and temporal, we create a 50,000-pair training set (positives to negatives ratio 1:3). Pairs within one step (elevation and/or azimuth) are treated as “temporal neighbors”, as in the turntable results of [10, 22].
(2) KITTI [6, 7]: This dataset contains videos with registered GPS/IMU sensor streams captured on a car driving around 4 types of areas (location classes): “campus”, “city”, “residential”, “road”. We generate a random 67%-33% train-validation split and use 2D ego-pose vectors consisting of “yaw” and “forward position” (integral over “forward velocity” sensor outputs) from the sensors. We discover ego-motion patterns (cf. Sec 3.1) on frame pairs 1 second apart. We compute clusters and automatically retain the with the largest motions, which upon inspection correspond to “forward motion/zoom”, “right turn”, and “left turn” (see Fig 1, left). For equiv, we create a -pair training set with 11,996 positives. For drlim and temporal, we create a 98,460-pair training set with 24,615 “temporal neighbor” positives sampled 2 seconds apart. We use grayscale “camera 0” frames (see ), downsampled to 3232 pixels, so that we can adopt CNN architecture choices known to be effective for tiny images .
In our recognition experiments, we consider 3 supervised datasets : (1) NORB: We select 6 images from each of the object training splits at random to create instance recognition training data. (2) KITTI: We select 4 images from each of the location class training splits at random to create location recognition training data.(3) SUN : We select 6 images for each of scene categories at random to create scene recognition training data. We preprocess them identically to the KITTI images above (grayscale, crop to KITTI aspect ratio, resize to ). We keep all the supervised datasets small, since unsupervised feature learning should be most beneficial when labeled data is scarce. Note that while the video frames of the unsupervised datasets are associated with ego-poses, the static images of have no such auxiliary data.
For KITTI, we closely follow the cuda-convnet 
recommended CIFAR-10 architecture: 32 conv(5x5)-max(3x3)-ReLU32 conv(5x5)-ReLU-avg(3x3) 64 conv(5x5)-ReLU-avg(3x3) 64 full feature units. For NORB, we use a fully connected architecture: 20 full-ReLU
100 full feature units. Parentheses indicate sizes of convolution or pooling kernels, and pooling layers have stride length 2.
We use Nesterov-accelerated stochastic gradient descent. The base learning rate and regularization s are selected with greedy cross-validation. The contrastive loss margin parameter in Eq (6) is set to 1.0. We report all results for all methods based on 5 repetitions. For more details on architectures and optimization, see Supp.
First, we test the learned features for equivariance. Equivariance is measured separately for each ego-motion through the normalized error :
where denotes the empirical mean, is the equivariance map, and would signify perfect equivariance. We closely follow the equivariance evaluation approach of  to solve for the equivariance maps of features produced by each compared method on held-out validation data, before computing (see Supp).
We test both (1) “atomic” ego-motions matching those provided in the training pairs (, “up” 5°and “down” 20°) and (2) composite ego-motions (“up+right”, “up+left”, “down+right”). The latter lets us verify that our method’s equivariance extends beyond those motion patterns used for training (cf. Sec 6.3). First, as a sanity check, we quantify equivariance for the unsupervised loss of Eq (5) in isolation, , learning with only . Our equiv method’s average error is 0.0304 and 0.0394 for atomic and composite ego-motions in NORB, respectively. In comparison, drlim—which promotes invariance, not equivariance—achieves 0.3751 and 0.4532. Thus, without class supervision, equiv tends to learn nearly completely equivariant features, even for novel composite transformations.
Next we evaluate equivariance for all methods using features optimized for the NORB recognition task. Table 2 (left) shows the results. As expected, we find that the features learned with equiv regularization are again easily the most equivariant. We also see that for all methods error is lower for atomic motions than composite motions, since they are more equivariant for smaller motions (see Supp).
Next we test the unsupervised-to-supervised transfer pipeline of Sec 3.4 on 3 recognition tasks: NORB-NORB, KITTI-KITTI, and KITTI-SUN. The first dataset in each pairing is unsupervised, and the second is supervised.
Table 1 (center) shows the results. On all 3 datasets, our method significantly improves classification accuracy, not just over the no-prior clsnet baseline, but also over the closest previous unsupervised feature learning methods.444To verify the clsnet baseline is legitimate, we also ran a Tiny Image nearest neighbor baseline on SUN as in . It obtains 0.61% accuracy (worse than clsnet, which obtains 0.70%).
All the unsupervised feature learning methods yield large gains over clsnet on all three tasks. However, drlim and temporal are significantly weaker than the proposed method. Those methods are based on the “slow feature analysis” principle —nearby frames must be close to one another in the learned feature space. We observe in practice (see Supp) that temporally close frames are mapped close to each other after only a few training epochs. This points to a possible weakness in these methods—even with parameters (temporal neighborhood size, regularization ) cross-validated for recognition, the slowness prior is too weak to regularize feature learning effectively, since strengthening it causes loss of discriminative information.
In contrast, our method requires systematic feature space responses to ego-motions, and offers a stronger prior. equiv+drlim further improves over equiv, possibly because: (1) our equiv implementation only exploits frame pairs arising from specific motion patterns as positives, while drlim more broadly exploits all neighbor pairs, and (2) drlim and equiv losses are compatible— drlim requires that small perturbations affect features in small ways, and equiv requires that they affect them systematically.
The most exciting result is KITTI-SUN. The KITTI data itself is vastly more challenging than NORB due to its noisy ego-poses from inertial sensors, dynamic scenes with moving traffic, depth variations, occlusions, and objects that enter and exit the scene. Furthermore, the fact we can transfer equiv features learned without class labels on KITTI (street scenes from Karlsruhe, road-facing camera with fixed pitch and field of view) to be useful for a supervised task on the very different domain of SUN (“in the wild” web images from 397 categories mostly unrelated to streets) indicates the generality of our approach. Our best recognition accuracy of 1.58% on SUN is achieved with only 6 labeled examples per class. It is 30% better than the nearest competing baseline temporal and over 6 times better than chance. Top-10 accuracy trends are similar.
While we have thus far kept supervised training sets small to simulate categorization problems in the “long tail” where training samples are scarce and priors are most useful, new preliminary tests with larger labeled training sets on SUN show that our advantage is preserved. With =20 samples for each of 397 classes on KITTI-SUN, equiv scored 3.66+/-0.08% accuracy vs. 1.66+/-0.18 for clsnet.
Next, we show preliminary results of a direct application of equivariant features to “next-best view selection”. Given one view of a NORB object, the task is to tell a hypothetical robot how to move next to help recognize the object, , which neighboring view would best reduce object prediction uncertainty. We exploit the fact that equivariant features behave predictably under ego-motions to identify the optimal next view. Our method for this task, similar in spirit to , is described in detail in Supp. Table 1 (right) shows the results. On this task too, equiv features easily outperform the baselines.
To qualitatively evaluate the impact of equivariant feature learning, we pose a nearest neighbor task in the feature difference space to retrieve image pairs related by similar ego-motion to a query image pair (details in Supp). Fig 4 shows examples. For a variety of query pairs, we show the top neighbor pairs in the equiv space, as well as in pixel-difference space for comparison. Overall they visually confirm the desired equivariance property: neighbor-pairs in equiv’s difference space exhibit a similar transformation (turning, zooming, ), whereas those in the original image space often do not. Consider the first azimuthal rotation NORB query in row 2, where pixel distance, perhaps dominated by the lighting, identifies a wrong ego-motion match, whereas our approach finds a correct match, despite the changed object identity, starting azimuth, lighting . The red boxes show failure cases. For instance, in the KITTI failure case shown (row 1, column 3), large foreground motion of a truck in the query image causes our method to wrongly miss the rotational motion.
Over the last decade, visual recognition methods have focused almost exclusively on learning from “bags of images”. We argue that such “disembodied” image collections, though clearly valuable when collected at scale, deprive feature learning methods from the informative physical context of the original visual experience. We presented the first “embodied” approach to feature learning that generates features equivariant to ego-motion. Our results on multiple datasets and on multiple tasks show that our approach successfully learns equivariant features, which are beneficial for many downstream tasks and hold great promise for novel future applications.
Acknowledgements: This research is supported in part by ONR PECASE Award N00014-15-1-2291 and a gift from Intel.
Transformation equivariant boltzmann machines.ICANN, 2011.
Transformation Invariance in Pattern Recognition - Tangent distance and Tangent propagation.1998.
Extracting and composing robust features with denoising autoencoders.ICML, 2008.
Some sample images from KITTI and SUN are shown in Fig 5. As they show, these datasets have substantial domain differences. In KITTI, the camera faces the road and has a fixed field of view and camera pitch, and the content is entirely street scenes around Karlsruhe. In SUN, the images are downloaded from the internet, and belong to 397 diverse indoor and outdoor scene categories—most of which have nothing to do with roads.
(Elaborating on para titled “Network architectures and Optimization” 4.1) As mentioned in the paper, for KITTI, we closely follow the cuda-convnet  recommended CIFAR-10 architecture: 32 conv(5x5)-max(3x3)-ReLU 32 conv(5x5)-ReLU-avg(3x3) 64 conv(5x5)-ReLU-avg(3x3) 64 full feature units. A schematic representation for this architecture is shown in Fig 6.
We use Nesterov-accelerated stochastic gradient descent as implemented in Caffe , starting from weights randomly initialized according to . The base learning rate and regularization s are selected with greedy cross-validation. Specifically, for each task, the optimal base learning rate (from 0.1, 0.01, 0.001, 0.0001) was identified for clsnet. Next, with this base learning rate fixed, the optimal regularizer weight (for drlim, temporal and equiv) was selected from a logarithmic grid (steps of ). For equiv+drlim, the drlim loss regularizer weight fixed for drlim was retained, and only the equiv loss weight was cross-validated. The contrastive loss margin parameter in Eq (6) in drlim, temporal and equiv were set uniformly to 1.0. Since no other part of these objectives (including the softmax classification loss) depends on the scale of features,555Technically, the equiv objective in Eq (5) may benefit from setting different margins corresponding to the different ego-motion patterns, but we overlook this in favor of scalability and fewer hyperparameters. different choices of margins in these methods lead to objective functions with equivalent optima - the features are only scaled by a factor. For equiv+drlim, we set the drlim and equiv margins respectively to 1.0 and 0.1 to reflect the fact that the equivariance maps of Eq (5) applied to the representation of the transformed image must bring it closer to the original image representation than it was before .
In addition, to allow fast and thorough experimentation, we set the number of training epochs for each method on each dataset based on a number of initial runs to assess the scale of time usually taken before the classification softmax loss on validation data began to rise overfitting began. All future runs for that method on that data were run to roughly match (to the nearest 5000) the number of epochs identified above. For most cases, this number was of the order of . Batch sizes (for both the classification stack and the Siamese networks) were set to 16 (found to have no major difference from 4 or 64) for NORB-NORB and KITTI-KITTI, and to 128 (selected from 4, 16, 64, 128) for KITTI-SUN, where we found it necessary to increase batch size so that meaningful classification loss gradients were computed in each SGD iteration, and training loss began to fall, despite the large number (397) of classes.
On a single Tesla K-40 GPU machine, NORB-NORB training tasks took 15 minutes, KITTI-KITTI tasks took 30 minutes, and KITTI-SUN tasks took 2 hours.
In Sec 4.2 in the main paper, we proposed the following measure for equivariance. For each ego-motion , we measure equivariance separately through the normalized error :
where denotes the empirical mean, is the equivariance map, and would signify perfect equivariance. We closely follow the equivariance evaluation approach of  to solve for the equivariance maps of features produced by each compared method on held-out validation data (cf. Sec 4.1 from the paper), before computing . Such maps are produced explicitly by our method, but not the baselines. Thus, as in , we compute their maps666For uniformity, we do the same recovery of for our method; our results are similar either way. by solving a least squares minimization problem based on the definition of equivariance in Eq (2) in the paper:
’s computed as above are used to compute ’s as in Eq (10). and are computed on disjoint subsets of the validation data. Since the output features are relatively low in dimension ( 100), we find regularization for Eq (11) unnecessary.
While results in the main paper (Table 2) were reported as averages over atomic and composite motions, we present here the results for individual motions in Table 2. While relative trends among the methods remain the same as for the averages reported in the main paper, the new numbers help demonstrate that for composite motions is no bigger than for atomic motions, as we would expect from the argument presented in Sec 6.3 in the main paper.
To see this, observe that even among the atomic motions, for all methods is lower on the small “up” atomic ego-motion (5°) than it is for the larger “right” ego-motion (20°). Further, the errors for “right” are close to those for the composite motions (“up+right”, “up+left” and “down+right”), establishing that while equivariance is diminished for larger motions, it is not affected by whether the motions were used in training or not. In other words, if trained for equivariance to a suitable discrete set of atomic ego-motions (cf. Sec 6.3 in the paper), the feature space generalizes well to new ego-motions.
|Datasets||“up (u)”||“right (r)”||“u+r”||“u+l”||“d+r”|
We now present evidence supporting our claim in the paper that the principle of slowness, which penalizes feature variation within small temporal windows, provides a prior that is rather weak. In every stochastic gradient descent (SGD) training iteration for the drlim and temporal networks, we also computed a “slowness” measure that is independent of feature scaling (unlike the drlim and temporal losses of Eq 7 themselves), to better understand the shortcomings of these methods.
Given training pairs annotated as neighbors or non-neighbors by (cf. Eq (7) in the paper), we computed pairwise distances , where is the parameter vector at SGD training iteration , and is set to the distance for drlim and to the distance for temporal (cf. Sec 4).
We then measured how well these pairwise distances predict the temporal neighborhood annotation , by measuring the Area Under Receiver Operating Characteristic (AUROC) when varying a threshold on .
These “slowness AUROC”s are plotted as a function of training iteration number in Fig 7, for drlim and coherence networks trained on the KITTI-SUN task. Compared to the standard random AUROC value of 0.5, these slowness AUROCs tend to be near 0.9 already even before optimization begins, and reach peak AUROCs very close to 1.0 on both training and testing data within about 4000 iterations (batch size 128). This points to a possible weakness in these methods—even with parameters (temporal neighborhood size, regularization ) cross-validated for recognition, the slowness prior is too weak to regularize feature learning effectively, since strengthening it causes loss of discriminative information. In contrast, our method requires systematic feature space responses to ego-motions, and offers a stronger prior.
We now describe our method for next-best view selection for recognition on NORB. Given one view of a NORB object, the task is to tell a hypothetical robot how to move next to help recognize the object which neighboring view would best reduce object prediction uncertainty. We exploit the fact that equivariant features behave predictably under ego-motions to identify the optimal next view.
We limit the choice of next view to “up”, “down”, “up+right” and “up+left” for simplicity in this preliminary test. We build a -nearest neighbor (k-NN) image-pair classifier for each possible , using only training image pairs related by the ego-motion . This classifier takes as input a vector of length , formed by appending the features of the image pair (each image’s representation is of length ) and produces the output probability of each class. So, returns class likelihood probabilities for all 25 NORB classes. Output class probabilities for the k-NN classifier are computed from the histogram of class votes from the nearest neighbors. We set .
At test time, we first compute features on the given starting image . Next we predict the feature corresponding to each possible surrounding view , as , per the definition of equivariance (cf. Eq 2 in the paper).777Equivariance maps for all methods are computed as described in Sec 6.3 in this document (and Sec 4.2 in the main paper)
With these predicted transformed image features and the pair-wise nearest neighbor class probabilities , we may now pick the next-best view as:
where is the information-theoretical entropy function. This selects the view that would produce the least predicted image pair class prediction uncertainty.
To qualitatively evaluate the impact of equivariant feature learning, we pose a pair-wise nearest neighbor task in the feature difference space to retrieve image pairs related by similar ego-motion to a query image pair (details in Supp). Given a learned feature space and a query image pair , we form the pairwise feature difference . In an equivariant feature space, other image pairs with similar feature difference vectors would be likely to be related by similar ego-motion to the query pair.888Note that in our model of equivariance, this isn’t strictly true, since the pair-wise difference vector need not actually be fixed for a given transformation , . For small motions (and the right kinds of equivariant maps ), this still holds approximately, as we find in practice. This can also be viewed as an analogy completion task, , where the right answer should apply to to obtain . For the results in the paper, the closest pair to the query in the learned equivariant feature space is compared to that in the pixel space. Some more examples are shown in Fig 8.