T IME -A GNOSTIC P REDICTION : P REDICTING P REDICTABLE V IDEO F RAMES
Anonymous authors
Paper under double-blind review
A BSTRACT
Prediction is arguably one of the most basic functions of an intelligent system.
In general, the problem of predicting events in the future or between two waypoints is exceedingly difﬁcult.
However, most phenomena naturally pass through relatively predictable bottlenecks—while we cannot predict the precise trajectory of a robot arm between being at rest and holding an object up, we can be certain that it must have picked the object up.
To exploit this, we decouple visual prediction from a rigid notion of time.
While conventional approaches predict frames at regularly spaced temporal intervals, our time-agnostic predictors (TAP) are not tied to speciﬁc times so that they may instead discover predictable “bottleneck” frames no matter when they occur.
We evaluate our approach for future and intermediate frame prediction across three robotic manipulation tasks.
Our predictions are not only of higher visual quality, but also correspond to coherent semantic subgoals in temporally extended tasks.
I NTRODUCTION
Imagine taking a bottle of water and laying it on its side.
Consider what happens to the surface of the water as you do this: which times can you conﬁdently make predictions about?
The surface is initially ﬂat, then becomes turbulent, until it is ﬂat again, as shown in Fig 1.
Predicting the exact shape of the turbulent liquid is extremely hard, but its easy to say that it will eventually settle down.
Prediction is thought to be fundamental to intelligence (Bar, 2009; Clark, 2013; Hohwy, 2013).
If an agent can learn to predict the future, it can take anticipatory actions, plan through its predictions, and use prediction as a proxy for representation learning.
The key difﬁculty in prediction is uncertainty.
Visual prediction approaches attempt to mitigate uncertainty by predicting iteratively in heuristically chosen small timesteps, such as, say, 0 .
1 s .
In the bottle-tilting case, such approaches generate blurry images of the chaotic states at t = 0 .
1 s, 0 .
2 s, . .
, and this blurriness compounds to make predictions unusable within a few steps.
Sophisticated probabilistic approaches have been proposed to better handle this uncertainty (Babaeizadeh et al., 2018; Lee et al., 2018; Denton & Fergus, 2018; Xue et al., 2016).
What if we instead change the goal of our prediction models?
Fixed time intervals in prediction are in many ways an artifact of the fact that cameras and monitors record and display video at ﬁxed frequencies.
Rather than requiring predictions at regularly spaced future frames, we ask: if a frame prediction is treated as a bet on that frame occurring at some future point, what should we predict?
Such time-agnostic prediction (TAP) has two immediate effects: (i) the predictor may skip more uncertain states in favor of less uncertain ones, and (ii) while in the standard approach, a prediction is wrong if it occurs at t ± (cid:15) rather than at t , our formulation considers such predictions equally correct.
Recall the bottle-tilting uncertainty proﬁle.
Fig 1 depicts uncertainty proﬁles for several other prediction settings, including both forward/future prediction (given a start frame) and intermediate prediction (given start and end frames).
Our time-agnostic reframing of the prediction problem targets the minima of these proﬁles, where prediction is intuitively easiest.
We refer to these minima states as “bottlenecks.”
At this point, one might ask: are these “easy” bottlenecks actually useful to predict?
Intuitively, bottlenecks naturally correspond to reliable subgoals—an agent hoping to solve the maze in Fig 1 (e) would do well to target its bottlenecks as subgoals.
In our experiments, we evaluate the usefulness of our predictions as subgoals in simulated robotic manipulation tasks.
[Figure]
Our main contributions are: (i) we reframe the video prediction problem to be time-agnostic, (ii) we propose a novel technical approach to solve this problem, (iii) we show that our approach effectively identiﬁes “bottleneck states” across several tasks, and (iv) we show that these bottlenecks correspond to subgoals that aid in planning towards complex end goals.
R ELATED W ORK
Visual prediction approaches.
Prior visual prediction approaches regress directly to future video frames in the pixel space (Ranzato et al., 2014; Oh et al., 2015) or in a learned feature space (Hadsell et al., 2006; Mobahi et al., 2009; Jayaraman & Grauman, 2015; Wang et al., 2016; Vondrick et al., 2016b; Kitani et al., 2012).
The success of generative adversarial networks (GANs) (Goodfellow et al., 2014; Mirza & Osindero, 2014; Radford et al., 2015; Isola et al., 2017) has inspired many video prediction approaches (Mathieu et al., 2015; Vondrick et al., 2016a; Finn & Levine, 2017;
Xue et al., 2016;
Oh et al., 2015; Ebert et al., 2017; Finn et al., 2016; Larsen et al., 2016; Lee et al., 2018).
While adversarial losses aid in producing photorealistic image patches, prediction has to contend with a more fundamental problem: uncertainty.
Several approaches (Walker et al., 2016; Xue et al., 2016; Denton & Fergus, 2018; Lee et al., 2018; Larsen et al., 2016; Babaeizadeh et al., 2018) exploit conditional variational autoencoders (VAE) (Kingma & Welling, 2013) to train latent variable models for video prediction.
Pixel-autoregression (Oord et al., 2016; van den Oord et al., 2016; Kalchbrenner et al., 2016) explicitly factorizes the joint distribution over all pixels to model uncertainty, at a high computational cost.
Like these prior approaches, we too address the uncertainty problem in video prediction.
We propose a general time-agnostic prediction (TAP) framework for prediction tasks.
While all prior work predicts at ﬁxed time intervals, we aim to identify inherently low-uncertainty bottleneck frames with no associated timestamp.
We show how TAP may be combined with conditional GANs as well as
VAEs, to handle the residual uncertainty in its predictions.
Bottlenecks.
In hierarchical reinforcement learning, bottlenecks are proposed for discovery of options (Sutton et al., 1999) in low-dimensional state spaces in (McGovern & Barto, 2001; S¸ims¸ek & Barto, 2009; Bacon, 2013; Metzen, 2013).
Most approaches (S¸ims¸ek & Barto, 2009; Bacon, 2013; Metzen, 2013) construct full transition graphs and apply notions of graph centrality to locate bottlenecks.
A multi-instance learning approach is applied in (McGovern & Barto, 2001) to mine states that occur in successful trajectories but not in others.
We consider the use of our bottleneck predictions as subgoals for a hierarchical planner, which is loosely related to options in that both aim to break down temporally extended trajectories into more manageable chunks.
Unlike these prior works, we use predictability to identify bottlenecks, and apply this to unlabeled high-dimensional visual state trajectories.
T IME -A GNOSTIC P REDICTION OF B OTTLENECK F RAMES
In visual prediction, the goal is to predict a set of unobserved target video frames given some observed context frames.
In forward prediction, the context is the ﬁrst frame, and the target is all future frames.
In the bidirectionally conditioned prediction case, the context is the ﬁrst and the last frame, and the frames in between are the target.
In Fig 1, we may wish to predict future images of the tilting bottle, or intermediate images of an agent who traverses the maze successfully.
[Figure]
In standard ﬁxed-time video prediction models (Ranzato et al., 2014; Oh et al., 2015; Mathieu et al., 2015; Vondrick et al., 2016a; Walker et al., 2016; Finn & Levine, 2017; Xue et al., 2016;
Oh et al., 2015; Ebert et al., 2017;
Finn et al., 2016; Lee et al., 2018; Denton & Fergus, 2018), a frame x τ (video frame at time τ ) is selected in advance to be the training target for some given input frames c .
For instance, in a typical forward prediction setup, the input may be c = x 0 , and the target frame may be set to x τ = x 1 .
A predictor G takes context frames c as input and produces a single frame G ( c ) .
G is trained as:
[Equation]
where E is a measure of prediction error, such as (cid:107) G ( c ) − x τ (cid:107) 1 .
This predictor may be applied recursively at test time to generate more predictions as G ( G ( c )) , G ( G ( G ( c ))) , and so on.
We propose to depart from this ﬁxed-time paradigm by decoupling prediction from a rigid notion of time.
Instead of predicting the video frame at a speciﬁed time τ , we propose to predict predictable bottleneck video frames through a time-agnostic predictor (TAP), as motivated in Sec 1.
To train this predictor, we minimize the following “minimum-over-time” loss:
[Equation]
where the key difference from Eq 1 is that the loss is now a minimum over target times of a timeindexed error E t
= E ( · , x t ) .
The target times are deﬁned by a set of time indices T .
For forward prediction starting from input c = x 0 , we may set targets to T = { 1 , 2 , ... } .
Fig 2 depicts this idea schematically.
Intuitively, the penalty for a prediction is determined based on the closest matching ground truth target frame.
This loss incentivizes the model to latch on to “bottleneck” states in the video, i.e. , those with low uncertainty.
In the bottle-tilting example, this would mean producing an image of the bottle after the water has come to rest.
One immediate concern with this minimum-over-time TAP loss might be that it could produce degenerate predictions very close to the input conditioning frames c .
However, as in the tilting bottle and other cases in Fig 1, uncertainty is not always lowest closest to the observed frames.
Moreover, target frame indices T are always disjoint from the input context frames, so the model’s prediction must be different from input frames by at least one step, which is no worse than the one-step-forward prediction of Eq 1.
In our experiments, we show cases where the minimum-over-time loss above captures natural bottlenecks successfully.
Further, Sec 3.2 shows how it is also possible to explicitly penalize predictions near input frames c .
This minimum loss may be viewed as adaptively learning the time offset τ , but in fact, the predictor’s task is even simpler since it is not required to provide a timestamp accompanying its prediction.
For example, in Fig 1(e), it need only specify which points in the maze the agent will go through; it need not specify when .
Lifting the requirement of a timestamped prediction relieves TAP approaches of a signiﬁcant implicit burden.
Recursive TAP.
TAP models may also be trained for recursive prediction, by minimizing the following loss:
[Equation]
where c ( r ) and T( r ) are the input and target set at recursion level r , both dynamically adapted based on the previous prediction.
The input c ( r ) may be set to the previous prediction G ( c ( r − 1)) , so that the sequence of predictions is ( G ( c (0)) , G ( G ( c (0))) , . . . ) .
T( r ) is set to target all times after the last prediction.
In other words, if the prediction at r = 0 was closest to frame x 5 , the targets for r =are set to T(1) = { 6 , 7 , ... } .
While we also test recursive TAP in Sec 4, in the rest of this section, we discuss the non-recursive formulation, building on Eq 2, for simplicity.
Bidirectional TAP.
Finally, while the above description of TAP has focused on forward prediction, the TAP loss of Eq 2 easily generalizes to bidirectional prediction.
Given input frames c = ( x 0 , x last ) , ﬁxed-time bidirectional predictors might target, say, the middle frame x τ = x last / 2 .
Instead, bidirectional TAP models target all intermediate frames, i.e., T = { 1 , 2 , ..., last − 1 } in Eq 2.
As in forward prediction, the model has incentive to predict predictable frames.
In the maze example from Fig 1, this would mean producing an image of the agent at one of the asterisks.
3. F ROM M INIMUM TO G ENERALIZED M INIMUM TAP L OSS
Within the time-agnostic prediction paradigm, we may still want to specify preferences for some times over others, or for some visual properties of the predictions.
Consider the minimum-over-time loss L in Eq 2.
Taking the minimum inside, this may be rewritten as:
[Equation]
where we use the time-indexed error E t as shorthand for E ( ., x t ) .
We may now extend this to the following “generalized minimum” loss, where the outer and inner errors are decoupled:
[Equation]
Now, E (cid:48) t , over which the minimum is computed, could be designed to express preferences about which frames to predict.
In the simplest case, E (cid:48) t = E t , and the loss reduces to Eq 2.
Instead, suppose that predictions at some times are preferred over others.
Let w ( t ) express the preference value for all target times t ∈ T , so that higher w ( t ) indicates higher preference.
Then we may set E (cid:48) t
=
E t /w ( t ) so that times t with higher w ( t ) are preferred in the arg min .
In our experiments, we set w ( t ) to linearly increase with time during forward prediction and to a truncated discrete Gaussian centered at the midpoint in bidirectional prediction.
At this point, one might ask: could we not directly incorporate preferences into the outer error?
For instance, why not simply optimize min t E t /w ( t ) ?
Unfortunately, that would have the sideeffect of downweighting the errors computed against frames with higher preferences w ( t ) , which is counterproductive.
Decoupling the outer and inner errors instead, as in Eq 5, allows applying preferences w ( t ) only to select the target frame to compute the outer loss against; the outer loss itself penalizes prediction errors equally regardless of which frame was selected.
The generalized minimum formulation may be used to express other kinds of preferences too.
For instance, when using predictions as subgoals in a planner, perhaps some states are more expensive to reach than others.
We also use the generalized minimum to select frames using different criteria than the prediction penalty itself, as we will discuss in Sec 3.5.
3. T IME -A GNOSTIC C ONDITIONAL GAN S
TAP is not limited to simple losses such as (cid:96) 1 or (cid:96) 2 errors; it can be extended to handle expressive
GAN losses to improve perceptual quality.
A standard conditional GAN (CGAN) in ﬁxed-time video prediction targeting time τ works as follows: given a “discriminator” D that outputs 0 for input-prediction tuples and 1 for input-ground truth tuples, the generator G is trained to fool the discriminator.
The discriminator in turn is trained adversarially using a binary cross-entropy loss.
The CGAN objective is written as:
[Equation]
To make this compatible with TAP, we train | T | discriminators { D t } , one per timestep.
Then, analogous to Eq 2, we may deﬁne a time-agnostic CGAN loss:
[Equation]
Like Eq 6, Eq 7 deﬁnes a cross-entropy loss.
The ﬁrst two terms are analogous to Eq 6 — for the t -th discriminator, the t -th frame provides a positive, and the generated frame provides a negative instance.
The third term treats ground truth video frames occurring at other times x t (cid:48) (cid:54) =
t as negatives.
In practice, we train a single discriminator network with | T | outputs that serve as { D t } .
Further, for computational efﬁciency, we approximate the summation over t (cid:48) (cid:54) =
t by sampling a single frame at random for each training video at each iteration.
Appendix A provides additional details.
3. T IME -A GNOSTIC C ONDITIONAL VAE S
While TAP targets low-uncertainty bottleneck states, it may be integrated with a conditional variational autoencoder (CVAE) to handle residual uncertainty at these bottlenecks.
In typical ﬁxed-time CVAE predictors targeting time τ , variations in a latent code z input to a generator G ( c, z ) must capture stochasticity in x τ .
At training time, z is sampled from a posterior distribution q φ ( z | x τ ) with parameters φ , represented by a neural network.
At test time, z is sampled from a prior p ( z ) .
The training loss combines a log-likelihood term with a KL-divergence from the prior:
[Equation]
(8) where we might set p G to a Laplacian distribution such that the second term reduces to a l 1reconstruction loss − ln p G ( x τ | c, z )
= (cid:107) G ( c, z ) − x τ (cid:107) 1 .
In a time-agnostic CVAE, rather than capturing stochasticity at a ﬁxed time τ , z must now capture stochasticity at bottlenecks: e.g., when the agent crosses one of the asterisks in the maze of Fig 1, which pose is it in?
The bottleneck’s time index varies and is not known in advance.
For computational reasons (see Appendix B), we pass the entire video X into the inference network q φ , similar to Babaeizadeh et al.
The negative log-likelihood term is adapted to be a minimum-over-time:
[Equation]
3. C OMBINED L OSS , N ETWORK A RCHITECTURE , AND T RAINING
We train time-agnostic CVAE-GANs with the following combination of a generalized minimum loss (Sec 3.2) and the CVAE KL divergence loss (Sec 3.4):
[Equation]
[Equation]
The outer error E t absorbs the CGAN discriminator errors (Sec 3.3), while the inner error E (cid:48) t is a simple (cid:96) 1 error, weighted by user-speciﬁed time preferences w ( t ) (Sec 3.2).
Omitting GAN error terms in E (cid:48) t helps stabilize training, since learned errors may not always be meaningful especially early on in training.
As in VAE-GANs (Larsen et al., 2016; Lee et al., 2018), the training objective includes a new term L t cvae-gan , analogous to L t cgan (Eq 7).
We set up L t cgan to use samples z from the prior p ( z ) , while L t cvae-gan instead samples z from the posterior q φ ( z | X ) , and employs separate discriminators { D (cid:48) t } .
The (cid:96) 1 loss also samples z from the posterior.
We omit expectations over the
VAE latent z to keep notation simple.
Frame generation in the predictor involves ﬁrst generating appearance ﬂow-transformed input frames (Zhou et al., 2016) and a frame with new uncopied pixels.
These frames are masked and averaged to produce the output.
Full architecture and training details are in Appendix C.
E XPERIMENTS
We have proposed a time-agnostic prediction (TAP) paradigm that is different from the ﬁxed-time paradigm followed in prior prediction work.
In our experiments, we focus on comparing TAP against a representative ﬁxed-time prediction model, keeping network architectures ﬁxed.
We use three simulated robot manipulation settings: object grasping (50k episodes), pick-and-place (75k episodes), and multi-object pushing (55k episodes).
Example episodes from each task are shown in Fig 3 (videos in Supp).
5% of the data is set aside for testing.
We use 64 × 64 images.
For grasping (15 frames per episode), the arm moves to a single object on a table, selects a grasp, and lifts it vertically.
For pick-and-place (20 frames), the arm additionally places the lifted object at a new position before performing a random walk.
For pushing (40 frames), two objects are initialized at random locations and pushed to random ﬁnal positions.
Object shapes and colors in all three settings are randomly generated.
Fig 3 shows example episodes.
[Figure]
[Figure] [Figure]
[Table] [Table]
[Table]
Forward prediction.
First, we evaluate our approach for forward prediction on grasping.
The ﬁrst frame (“start”) is provided as input.
We train ﬁxed-time baselines (architecture same as ours, using (cid:96) 1 and GAN losses same as MIN and GENMIN ) that target predictions at exactly 0 .
75 , 1 .fraction of the episode length ( FIX 0.25 ,..., FIX 1.00 ).
MIN and GENMIN are TAP with/without the generalized minimum of Sec 3.2.
For GENMIN , we evaluate different choices of the time
preference vector w ( t ) (Sec 3.2).
We set w ( t ) =
β + t/ 15 , so that our preference increases linearly from β to β + 1 .
Since w ( t ) applies multiplicatively, low β corresponds to high disparity in preferences ( β = ∞ reduces to MIN , i.e., no time preference).
GENMIN 2 is our approach with β = 2 and so on.
Fig 5 shows example predictions from all methods for the grasping task.
In terms of visual quality of predictions and ﬁnding a semantically coherent bottleneck, GENMIN 2 , GENMIN 4 , and GENMINperform best—they reliably produce a grasp on the object while it is still on the table.
With little or no time preferences, MIN and GENMIN 10 produce images very close to the start, while GENMIN 0.
places too high a value on predictions farther away, and produces blurry images of the object after lifting.
Quantitatively, for each method, we report the min and arg min index of the (cid:96) 1 distance to all frames in the video, as “min (cid:96) 1 err” and “match-step” (“which future ground truth frame is the prediction closest to?”).
Fig 4 shows a scatter plot, where each dot or square is one model.
TAP (various models with varying β ) produces an even larger variation in stepsizes than ﬁxed-time methods explicitly targeting the entire video ( FIX 0.75 and FIX 1.0 fall short of producing predictions at 0.75 and 1.
fraction of the episode length).
TAP also produces higher quality predictions (lower error) over that entire range.
From these quantitative and qualitative results, we see that TAP not only successfully encourages semantically coherent bottleneck predictions, it also produces higher quality predictions than ﬁxed-time prediction over a range of time offsets.
Intermediate frame prediction.
Next, we evaluate our approaches for bidirectionally conditioned prediction in all three settings.
Initial and ﬁnal frames are provided as input, and the method is trained to generate an intermediate frame.
The FIX baseline now targets the middle frame.
As before, MIN and GENMIN are our TAP models.
The GENMIN time preference w ( t ) is bell-shaped and varies from 2/3 at the ends to 1 at the middle frame (see Appendix E).
Figs 6 and 9 show examples from the three settings.
TAP approaches successfully discover interesting bottlenecks in each setting.
For grasping (Fig 6 (left)), both MIN and GENMIN consistently produce clear images of the arm at the point at which it picks up the object.
Pick-and-place (Fig 6, right) is harder because it is more temporally extended, and the goal image does not specify how to grasp the object.
FIX struggles to produce any coherent predictions, but GENMIN once again identiﬁes
[Figure]
bottlenecks reliably—in examples #3 and #1, it predicts the “pick” and the “place” respectively.
For the pushing setting (Fig 9 (left)), GENMIN frequently produces images with one object moved and the other object ﬁxed in place, which again is a semantically coherent bottleneck for this task.
In row #1, it moves the correct object ﬁrst to generate the subgoal, so that objects do not collide.
Table 1 shows quantitative results over the full test set.
As in forward prediction, we report min (cid:96)error and the best-matching frame index (“match-step”) for all methods.
MIN and GENMIN consistently yield higher quality predictions (lower error) than FIX at similar times on average.
As an example,
GENMIN reduces FIX errors by 21%, 26.5%, and 53.2% on the three tasks—these are consistent and large gains that increase with increasing task complexity/duration.
Additionally, while all foregoing results were reported without the CVAE approach of Sec 3.4, Table 1 shows results for GENMIN + VAE , and Fig 9 shows example predictions for pick-and-place.
In our models, individual stochastic predictions from GENMIN + VAE produce higher (cid:96) 1 errors than GENMIN .
However, the CVAE helps capture meaningful sources of stochasticity at the bottlenecks—in Fig 9 (right), it produces different grasp conﬁgurations to pick up the object in each case.
To measure this, we evaluate the best ofstochastic predictions from GENMIN + VAE in Table 1 ( GENMIN + VAE BEST - OF -100 ).
On pick-and-place and pushing, the best VAE results are signiﬁcantly better than any of the deterministic methods.
Table 1 also shows results for our method without the GAN ( GENMIN W / O GAN )—while its (cid:96) 1 errors are comparable, we observed a drop in visual quality.
r= r= r= r= r= r=
As indicated in Sec 3.1 and Eq 3, TAP may also be applied recursively.
Fig 7 compares consecutive subgoals for the pick-and-place task produced by recursive TAP versus a recursive ﬁxed-time model.
Recursion level r = 1 refers to the ﬁrst subgoal, and r = 2 refers to the subgoal generated when the ﬁrst subgoal is provided as the goal input (start input is unchanged).
In example #1, FIX struggles while “ours” identiﬁes the “place” bottleneck at r = 1 , and subsequently the “pick” botleneck at r = 2 .
Finally, we test on “BAIR pushing” (Ebert et al., 2017), a real-world dataset that is commonly used in visual prediction tasks.
The data consists of 30-frame clips of random motions of a Sawyer arm tabletop.
While this dataset does not have natural bottlenecks like in grasping, TAP (min (cid:96) 1 error 0.
at match-step 15.42) still performs better than FIX (0.059 at 15.29).
Qualitatively, as Fig 8 shows, even though BAIR pushing contains incoherent random arm motions, TAP consistently produces predictions that plausibly lie on the path from start to goal image.
In example #1, given a start and goal image with one object displaced, “ours” correctly moves the arm to the object before displacement, whereas FIX struggles.
[Figure]
Bottleneck discovery frequency.
We have thus far relied on qualitative results to assess how often our approach ﬁnds coherent bottlenecks.
For pushing, we test bottleneck discovery frequency more quantitatively.
We make the reasonable assumption that bottlenecks in 2-object pushing correspond to states where one object is pushed and the other is in place.
Our metric exploits knowledge of true object positions at start and goal states.
First, for this evaluation, we restrict both GENMIN and FIX to synthesize predictions purely by warping and masking inputs.
Thus, we can track where the pixels at ground truth object locations in start and goal images end up in the prediction, i.e., where did each object move?
We then compute a score that may be thresholded to detect when only one object moves (details in Appendix F).
As an intuitive example, suppose that the two objects are displaced by 10 cm and 15 cm respectively between start and goal frames.
Suppose further that our predictor predicts the start frame as its output.
Then its distance score would be computed to becm.
For all values of threshold below 10 cm, this would be counted as a bottleneck discovery failure.
As Fig 10 shows, GENMIN predicts bottlenecks much more frequently ( ∼ 60% of the time) than FIX .
As hypothesized, our time-agnostic approach does indeed identify and latch on to low-uncertainty states to improve its predictions.
[Table]
Hierarchical planning evaluation.
Finally, we discuss experiments directly evaluating our intermediate predictions as visual subgoals for hierarchical planning for pushing tasks.
A forward
Visual MPC planner (Ebert et al., 2017) accepts the subgoal object positions (computed as above for evaluating bottlenecks).
Start and goal object positions are also known.
Internally, Visual MPC makes action-conditioned ﬁxed-time forward predictions of future object positions to ﬁnd an action sequence that reaches the subgoal object positions, with a planning horizon of 15.
Additional implementation details are in Appendix G.
Given start and goal images, our model produces a subgoal.
Visual MPC plans towards this subgoal for half the episode length, then switches to the ﬁnal goal.
We compare this scheme against (i) “direct”: planning directly towards the ﬁnal goal for the entire episode length, and (ii) FIX :
subgoals from a center-frame predictor.
The error measure is the mean of object distances to goal states (lower is better).
As an upper bound, single-object pushing with the planner yields ∼ 5cm error.
Results for two-object and three-object pushing are shown in Table 2.
GENMIN does best on both, but especially on the more complex three-object task.
Since Visual MPC has thus far been demonstrated to work only on pushing tasks, our hierarchical planning evaluation is also limited to this task.
Going forward, we plan to adapt Visual MPC to allow testing TAP on more complex temporally extended tasks like block-stacking, where direct planning breaks down and subgoals offer greater value.
C ONCLUSIONS
The standard paradigm for prediction tasks demands that a predictor not only make good predictions, but that it make them on a set schedule.
We have argued for redeﬁning the prediction task so that the predictor need only care that its prediction occur at some time, rather than that it occur at a speciﬁc scheduled time.
We deﬁne this time-agnostic prediction task and propose novel technical approaches to solve it, that require relatively small changes to standard prediction methods.
Our results show that reframing prediction objectives in this way yields higher quality predictions that are also semantically coherent—unattached to a rigid schedule of regularly speciﬁed timestamps, model predictions instead naturally attach to speciﬁc semantic “bottleneck” events, like a grasp.
In our preliminary experiments with a hierarchical visual planner, our results suggest that such predictions could serve as useful subgoals for complex tasks.
In future work, we would like to address some limitations of our TAP formulation, of which we will mention two here. First, TAP currently beneﬁts not only from selecting which times to predict, but also from not having to provide timestamps attached to its predictions. We would like to study: could we retain the beneﬁts of time-agnostic prediction while also providing timestamps for when each predicted state will occur? Second, our current TAP formulation may not generalize to prediction problems in all settings of interest.
As an example, for videos of juggling or waving, which involving repeated frames, TAP might collapse to predicting the input state repeatedly.
We would like to investigate more general TAP formulations: for example, rather than choosing E (cid:48) t in Eq 5 to encourage predicting farther away times, we could conceivably penalize predictions that look too similar to the input context frames.
More broadly, we believe that our results thus far hold great promise for many applications of prediction including hierarchical planning and model-based reinforcement learning, and we hope to build further on these results
ta-pred A L ABEL S MOOTHING FOR T IME -A GNOSTIC C ONDITIONAL GAN S
In Eq 7, we deﬁned a time-agnostic CGAN loss that trained T discriminators, one corresponding to each target time t ∈ T .
In Eq 7, the only positives for the t -th discriminator D t were ground truth frames that occured precisely at time t relative to the input c , i.e., discriminators are trained so
that
D t ( c, x t ) would be 1, and D t ( c, x t (cid:48) (cid:54) =
t ) and D t ( c, G ( c )) would both be 0.
However, in practice, we use the following slightly different loss:
[Equation]
(11) where we set l t,t (cid:48)
= max(0 , 1 − α | t − t (cid:48) | ) with α = 0 .
The ﬁrst two terms are the same as Eq— for the t -th discriminator, the t -th frame provides a positive, and the generated frame provides a negative instance.
The third term deﬁnes the loss for frames x t (cid:48) (cid:54) =
t : frames close to time t are partial positives ( 0 < l t,t (cid:48) < 1 ), and others are negatives ( l t,t (cid:48)
= 0 ).
This label smoothing stabilizes training and ensures enough positives for each discriminator D t .
B T IME -A GNOSTIC C ONDITIONAL VAE S
Here, we discuss one alternative to the TAP CVAE formulation of Eq 9 in Sec 3.4.
Rather than restricting the minimum-over-time to be over the log-likelihood term alone, why not take the minimumover-time over the whole loss?
In other words, the inference network would still have to only see one frame as input, and this version of the TAP CVAE loss would be:
[Equation] [Equation]
Unfortunately, this would be computationally very expensive to train.
Both the inference network q φ and the generator G would have to process | T | frames.
In comparison, the formulation of Eqallows q φ and G to process just one frame, and only error computation must be done T times, once with each target frame x t for t ∈ T .
C A RCHITECTURE AND TRAINING DETAILS
Predictor architecture.
As indicated in Fig 11, the predictor G has an encoder-decoder architecture.
When our approach is used together with the conditional VAE (Sec 3.4), the conditional latent z
[Figure]
is appended at the bottleneck between the encoder and the decoder.
The encoder produces a 128dimensional code, and the VAE latent code z is 32-dimensional, so the overall size of the input to the decoder is 160 when the VAE is used.
The encoder inside the predictor uses a series of 4x4convolution-batchnorm-LeakyReLU(0.2) blocks to reduce the 64x64 input image as 3x64x64 → 32x32x32 → 64x16x16 → 128x8x8 → 256x4x4.
For bidirectional prediction, this is repeated for both images and concatenated to produce a 512x4x feature map.
Finally, a small convolution-ReLU-convolution head reduces this to a 128-dimensional vector.
Except for this last head subnetwork, this architecture is identical to the DCGAN discriminator (Radford et al., 2015).
The decoder inside the predictor uses a DCGAN-based architecture (Radford et al., 2015).
The input vector is reshaped by a transposed convolution into 256 4 × 4 maps.
This is subsequently processed a series of bilinear upsampling-5x5convolution-batchnorm-ReLU blocks as 256x4x4 → 128x8x8 → 64x32x32 → 3x64x64.
For the last block, a Tanh activation is used in place of ReLU to keep outputs in [-1,1].
Compared to (Radford et al., 2015), the main difference is that transposed convolutions are replaced by upsampling-5x5 convolution blocks, which aids in faster learning with fewer image artifacts (Odena et al., 2016).
As shown in Fig 12, our predictor produces three sets of outputs: (a) one frame of new pixels, (b) “appearance ﬂow” (Zhou et al., 2016) maps that warp the | C | input image(s), and (c) | C | + 1 masks (summing to 1 at each pixel) that combine the warped input images and the new pixels frame to produce the ﬁnal output.
To produce these three outputs, we use three decoders that all have the same architecture as above, except that the ﬁnal output is shaped appropriately—the appearance ﬂow decoder produces | C | x64x64 ﬂowﬁelds, and the masks decoder produces ( | C | + 1) x64x64 masks.
Discriminator and Recognition Network The VAE recognition network and the discriminator both use similar architectures to the predictor encoder above.
Only the input layer and the output layer are changed as follows: (a) The discriminator accepts | C | + 1 images as input and the recognition network accepts | C | + | T | images (the full video) as input.
The discriminator head produces | T | logits (one to each target time and the recognition network produces a 32 -dimensional
conditional
Training.
We found it beneﬁcial to initialize the decoder by training it ﬁrst as an unconditional frame generator on frames from the training videos.
For this pretraining, we use learning rate 0.
for 10 epochs with batch size 64 and Adam optimizer.
Thereafter, for training, we use learning rate 0.0001 for 200 epochs with batch size 64 and Adam optimizer.
D D ATA G ENERATION
To generate the data, we use a cross-entropy method (CEM)-based planner (Kroese et al., 2013;
Ebert et al., 2017) in the MuJoCo (Todorov et al., 2012) environment with access to the physics engine, which produces non-deterministic trajectories.
The planner plans towards randomly provided goals, but we use both successful and failed trajectories.
Sample videos of episodes are shown at: https://sites.google
E G ENERALIZED M INIMUM W EIGHTS F OR I NTERMEDIATE P REDICTION
In Sec 4, we brieﬂy mentioned that the time preference w ( t ) for the generalized minimum loss during intermediate frame prediction was set to 2/3 at the ends to 1 at the middle frame.
In our experiments, we set these weights heuristically as follows: w ( t ) rises linearly from κ = 0 . 66 at t = 1 to 1.0 at the t = 5 , then stay at 1.0 for T − 10 frames.
Then, starting from the ( T − 5) -th frame, it would drop linearly to κ once more at t = T .
The only hyperparameter we tuned was κ (search over 2/3 and 1/3).
F B OTTLENECK D ISCOVERY F REQUENCY S CORE
In Sec 4, we mentioned a bottleneck discovery frequency measure in the paragraph titled “Bottleneck discovery frequency metric.”
We now provide further details.
Our proposed metric for two-object pushing quantiﬁes how reliably the network is able to generate a bottleneck state with one object being moved and the other being at its original position.
The reason that this state is of interest is that in two-object pushing, this may be reasonably assumed to be the natural bottleneck, so we call this metric the bottleneck frequency.
Even without this assumption though, the metric quantiﬁes the ability of our approach to generate predictions attached to this consistent semantically coherent bidirectional state.
To measure bottleneck frequency, we use a technique similar to the approach proposed in (Ebert et al., 2017) for planning with a visual predictor.
First, we train versions of “genmin” and “ﬁx” that synthesize predictions purely by appearance-ﬂow-warping and masking inputs (as shown in the scheme of Fig 12, but without pixel generation).
Next, recall that we have access to the starting and goal positions of objects since our dataset is synthetically generated.
Thus, we can exploit this and track where the pixels at ground truth object locations in start and goal images end up in the prediction, i.e., where did each object move?
This works as follows: we take the appearance ﬂow transformations and masks generated by the model internally (for application to input images to generate prediction) and apply them instead to one-hot object location maps—these maps have value one at the ground truth origin of the the objects and zero elsewhere.
The output of this operation is a probability map for each object indicating where it is located in the predictor’s bidirectional prediction output.
To compute the score, we then calculate the expected distance in pixels between the predicted positions of each object and the bottleneck state.
There are actually two possible candidates for this bottleneck state: object 1 is moved ﬁrst, or object 2 is moved ﬁrst.
We compute the expected distances to both these bottleneck candidates and take the lower distance to be the score.
This score does not evaluate whether the semantically correct bottleneck was predicted (in cases where one object must always be moved ﬁrst to avoid collision, such as Fig 9 (left) example #1).
The lower this distance score, the higher the likelihood that the predicted output is actually a bottleneck (“bottleneck frequency”).
Fig 10 shows what happens when the threshold over the score is varied, for our approach and the ﬁxed-time baseline.
Higher bottleneck frequency at lower threshold is desirable.
As the ﬁgure shows, at a low threshold distance score ( ≈ 2 pixels), our approach gets to about 58% bottleneck frequency while the ﬁxed-time predictor gets about 0% frequency at this threshold.
This veriﬁes that our approach produces predictions attached to semantically coherent low-uncertainty bottleneck events.
G H IERARCHICAL P LANNING E VALUTION M ETHOD
In Sec 4, we described a hierarchical planning approach using our predictions in the paragraph titled “Hierarchical planning evaluation.
We describe this method in more detail here.
We test the usefulness of the generated predictions as subgoals for planning multi-object pushing.
Given a start and goal image, we produce an bidirectional prediction using our time-agnostic predictor and feed it to a low-level planner that plans towards this prediction as its subgoal.
For the low-level planner we use the visual model-predictive control algorithm (“Visual MPC”)
(Ebert et al., 2017) which internally uses a ﬁxed-time forward prediction model and sampling-based planning to solve short-term and medium duration tasks.
A more detailed description of this process follows.
Visual MPC requires start and goal locations of objects to plan.
When used in conjunction with our method, we ﬁrst compute the locations of objects at the bidirectional predictions and feed this in place of the ﬁnal goal object locations, so that Visual MPC may plan to ﬁrst reach the bidirectional prediction as a subgoal/stepping stone towards the ﬁnal goal.
Once the subgoal is reached, Visual
MPC is fed the ﬁnal goal.
To compute subgoal object locations, we use the same technique as in
Appendix F above—one-hot maps of object locations are transformed by the appearance ﬂow maps and masks computed internally by our predictor.
This produces a probability map p g over object locations at the prediction, which is passed to Visual MPC.
Internally, the Visual MPC planner makes ﬁxed-time forward predictions for the object locations starting from the initial distribution p s given a randomly sampled action sequence of length h =(the “planning horizon”).
Out of all the action sequences, it selects the sequence that brings the distribution closest to p g within h = 15 steps ( h is the “planning horizon”).
In practice, we userandom action sequences and perform three iterations of CEM search (Kroese et al., 2013) to ﬁnd the the best sequence.
Once an action sequence is selected, the ﬁrst action in the sequence is executed, and the initial object distribution is updated.
New candidate action sequences are now generated starting from this updated object distribution and the process repeats.
In our experiments, we use a time budget B of 40 steps for 2-object pushing, and 75 steps for 3-object pushing.
In both cases, we feed Visual MPC the subgoal (bidirectional prediction object locations) for the ﬁrst B/ 2 timesteps, and then feed the ﬁnal goal location for the last B/ 2 steps.
The “direct” planning baseline instead receives the ﬁnal goal location for all B steps.
As shown by the results in the paper, our subgoal predictions aid in performing these multi-stage pushing tasks better than with the direct planning baseline.
H S UPPLEMENTARY P REDICTION E XAMPLES
We now show more prediction results from various settings in Figs 13, 14,
[Figure] [Figure]
[Figure]
Bidirectional prediction results with GENMIN + VAE (Grasping)
[Figure] [Figure]