CCVS: Context-aware Controllable Video Synthesis
Year: 2021

Abstract:
This presentation introduces a self-supervised learning approach to the synthesis of new video clips from old ones, with several new key elements for improved spatial resolution and realism: It conditions the synthesis process on contextual information for temporal continuity and ancillary information for fine control. The prediction model is doubly autoregressive, in the latent space of an autoencoder for forecasting, and in image space for updating contextual information, which is also used to enforce spatio-temporal consistency through a learnable optical flow module. Adversarial training of the autoencoder in the appearance and temporal domains is used to further improve the realism of its output. A quantizer inserted between the encoder and the transformer in charge of forecasting future frames in latent space (and its inverse inserted between the transformer and the decoder) adds even more flexibility by affording simple mechanisms for handling multimodal ancillary information for controlling the synthesis process (e.g., a few sample frames, an audio track, a trajectory in image space) and taking into account the intrinsically uncertain nature of the future by allowing multiple predictions. Experiments with an implementation of the proposed approach give very good qualitative and quantitative results on multiple tasks and standard benchmarks.

heading: 1 Introduction
text: Feeding machines with extensive video content, and teaching them to create new samples on their own, may deepen their understanding of both the physical and social worlds. Video synthesis has numerous applications from content creation (e.g., deblurring, slow motion) to human-robot interaction (e.g., motion prediction). Despite the photo-realistic results of modern image synthesis models [38], video synthesis is still lagging behind due to the increased complexity of the additional temporal dimension.
An emerging trend is to use autoregressive models, for example transformer architectures [68], for their simplicity, and their ability to model long-range dependencies and learn from large volumes of data [4, 16]. First introduced for natural language processing (NLP) and then succesfully applied to visual data [18], the strength of transformers is grounded in a self-attention mechanism which considers all pairwise interactions within the data. The price to pay is a computational complexity which grows quadratically with the data size, which itself depends linearly on the temporal dimension and quadratically on the spatial resolution in the image domain. Although there have been some efforts to reduce the complexity of self-attention [11, 39, 50], using such methods directly on visual data is still limited to low resolutions and impractical without considerable computational power [9, 79].
Some recent works [20, 53] address this problem by using an autoencoder to compress the visual data, and apply the autoregressive model in the latent space. This greatly reduces the memory footprint and computational cost, yet, the greater the compression, the harder it is to faithfully reconstruct frames. The corresponding trade-offs may undermine the practical usability of these approaches. GANs [26] mitigate this issue by “hallucinating” plausible local details in image synthesis [20]. But latent video
∗corresponding author: guillaume.le-moing@inria.fr
35th Conference on Neural Information Processing Systems (NeurIPS 2021).
transformers [53] decode frames independently, which prevents local details from being temporally coherent. Hence, using GANs in this setting may result in flickering effects in the synthesized videos.
We follow the problem decomposition from [20, 53], but introduce a more elaborate compression strategy with CCVS (for Context-aware Controllable Video Synthesis), an approach that takes advantage of “context” frames (i.e., both input images and previously synthesized ones) to faithfully reconstruct new ones despite lossy compression. As shown in Figure 1, CCVS relies on optical flow estimation between context and new frames, within temporal skip connections, to let information be shared across timesteps. New content, which cannot be retrieved from context, is synthesized directly from latent compressed features, and adversarial training [26] is used to make up realistic details. Indeed, information propagates in CCVS to new frames as previously synthesized ones become part of the context. Like other video synthesis architectures based on autoregressive models [53, 79], CCVS can be used in many tasks besides future video prediction. Any data which can be expressed in the form of a fixed-size sequence of elements from a finite set (aka, tokens) can be processed by a transformer. This applies to video frames (here, via compression and quantization) and to other types of data. Hence, one can easily fuse modalities without having to build complex or task-specific architectures. This idea has been used to control image synthesis [20, 54], and we extend it to a variety of video synthesis tasks by guiding the prediction with different annotations as illustrated in Figure 2. Code, pretrained models, and video samples synthesized by our approach are available at the url https://16lemoing.github.io/ccvs. Our main contributions are as follows:
1. an optical flow mechanism within an autoencoder to better reconstruct frames from context, 2. the use of ancillary information to control latent temporal dynamics when synthesizing videos, 3. a performance on par with or better than the state of the art, while being more memory-efficient.

heading: 2 Related Work
text: Video synthesis. In its simplest form, videos are produced without prior information about their content. GAN-based approaches map Gaussian noise into a visually plausible succession of frames. For example, VGAN [71] and ProgressiveVGAN [1], adapt the traditional GAN framework [26] from image to video synthesis by simply using 3D instead of 2D convolutions. These approaches, including recent attempts such as G3AN [76], are computationally expensive, and, by nature, restricted to synthesizing a fixed number of frames due to the constraints of their architecture. Other approaches predict latent motion vectors with a CNN [56], or a recurrent neural network (RNN) [12, 57, 65], and generate frames with individual 2D operations. To avoid the shortcomings of information loss in the sequential processing of RNNs, we use an attention-based autoregressive model instead. Since we forecast temporal dynamics in a compressed space, a large temporal window can be used when predicting new frames, without having to resort to expensive 3D computations. Previous works have attempted to scale video synthesis to higher resolution by using progressive training [1], subsampling [56, 57], reducing the dimension of the discriminator [36], or redefining the task as finding a trajectory in the latent space of a pre-trained image generator [63]. Compression, together with efficient context-aware reconstruction allows us to synthesize videos at high resolution.
Controllable video synthesis. Some of the aforementioned works [12, 56, 57, 76] handle synthesis conditioned on a class label. Another popular control is to use a few priming frames to set off the generation process. This task, known as future video prediction, has received a lot of attention recently. Methods based on variational autoencoders (VAE) [2, 15] have been proposed to account for the stochastic nature of future forecasting, i.e., the plurality of possible continuations, disregarded in deterministic predictive models [21, 47, 70]. Yet, their blurry predictions have motivated the incorporation of adversarial training [44], hierarchical architectures [7, 80], fully latent temporal models [22], or normalizing flows [42]. Another line of work infers spatial transformation parameters (e.g., optical flow), and predicts the future by warping past frames (i.e., grid sampling and interpolation as in [33]) in RGB space [21, 24, 28, 72, 81] or in feature space [45], typically using a refinement step to handle occlusions. Lately, autoregressive methods [53, 79] leveraging a self-attention mechanism [68] have also been applied to this task. Our method benefits from the context-efficiency of approaches based on spatial transformation modules and the modeling power of autoregressive networks. In the meantime, other forms of control with interesting applications have emerged. Point-to-point generation [75], a variant of future video prediction, specifies both start and end frames. State or action-conditioned synthesis [28, 48] guides the frame-by-frame evolution with high-level commands.
Additional works consider video synthesis based on one [51] or multiple layouts [46, 74], another video [8], or sound [10, 34, 73]. To account for the variety of potential controls, we leverage the flexibility of transformers, and propose an unifying approach to tackle all of these tasks.

heading: 3 Context-aware controllable video synthesis

heading: 3.1 Overview of the proposed approach
text: We consider video data, such that an individual frame x is natively an element of X = RH×W×3, which can be encoded as some feature z in Z = Rh×w×F with reduced spatial resolution and increased number of channels. We assume that we are given Xc in Xm corresponding to m successive frames, and our goal is to synthesize a plausible representation of the following n frames Xs which lies in Xn. Given Xc, we can compute the corresponding features Zc in Zm using some encoder E : X → Z on each frame individually, then use an autoregressive model (a transformer coupled with a quantization step in our case) to predict features Zs in Zn formed by the n features corresponding to time ticks m + 1 to m + n. (Note that the values of m and n can be arbitrary, using [by now] traditional masking and sliding window techniques.) These features can finally be converted one by one into the corresponding frames Xs using some decoder D : Z → X . The overall approach is illustrated by Figure 1. The use of a quantizer over a learned codebook in our implementation complicates the architecture a bit, but has several advantages, including the reuse of familiar NLP technology [68] and, perhaps more importantly, affording simple mechanisms for handling different types of inputs (from images to sound for example [9, 31]) and the intrinsically uncertain and multimodal nature of future prediction (by sampling different codebook elements according to their likelihood [30]). Concretely, this choice simply amounts to inserting in our architecture, right after the encoder E , a nearest-neighbor quantizer Q : RF → J1, qK parameterized by an F × q codebook which, given the embedding z of a frame, returns a h × w matrix of corresponding tokens, that is, the indices of the closest entry in the codebook for feature vector zi,j for all spatial locations (i, j) in J1, hK × J1, wK. We abuse notation, and identify Q with its parameterization by this codebook, so we can optimize over Q just as we optimize over E instead of naming explicitly its parameters in the rest of this presentation. An “un-quantizer” U : J1, qK → RF , also parameterized (implicitly) by the codebook and associating with each token the corresponding entry of the codebook, is also inserted right before the decoder D. In this setting, T : J1, qKm×h×w → J1, qKn×h×w takes as input a sequence of tokens, and outputs the tokens for subsequent frames, each one of them chosen among q possibilities as either the one with the highest score, or drawn randomly
from the top-k scores to account for the multimodal nature of future forecasting (here k ≤ q is some predefined constant, see [30] for related approaches).
The elements of the architecture described so far are by now (individually) rather classical, with learnable, parametric functions E , D, Q and T . Besides putting them all together, and as detailed in the rest of this section, we add several original elements: (a) The encoding/decoding scheme is improved by the use of two discriminators, ∆i and ∆t respectively, trained in an adversarial manner to ensure that the predicted frames are realistic and temporally consistent. (b) The context frames Xc are themselves updated each time a new frame is predicted in an autoregressive manner (iteratively fill the sequence up to some predefined capacity, then shift to the left, forgetting the first frame and adding the latest synthetic one on the right). (c) The encoder and decoder are linked through a learnable flow module F , allowing the context frames to guide the prediction of the synthetic ones. (d) Additional control variables, ranging from object trajectories to audio tracks, can be used in the form of sequence- or frame-level annotations to drive the synthesis by adding the corresponding tokens to the ones passed on to the autoregressive model T . We detail in this section the concrete components of the approach sketched above, including the autoencoder and quantizer architectures and their training procedure (Section 3.2), and the implementation of the autoregressive model by a transformer [68], illustrated in Figure 2, which we adapt to account for outside control signals (Section 3.3), once again with the corresponding procedure. Further architectural choices are also detailed in Appendix A.

heading: 3.2 First stage: training the context-aware autoencoder and the quantizer
text: Architecture. E and D respectively decreases and increases the spatial resolution by using convolutional residual blocks [29], with (rk)k∈J1;KK the K corresponding resolution levels (rk = hk × wk). It is common practice to augment, as in U-Net [55], the autoencoder with long skip connections between E and D to share information across the two models at these intermediate levels and escape the lossy compression bottleneck. Although we cannot apply this directly to our setting since information only flows through D for predicted timesteps, such skip connections can be established from the encoding stage of a context frame xc to the decoding stage of a new frame xs (resulting from features zs). Similar mechanisms [15, 19] have been proposed in the past for video synthesis but they are only copying static background features from a single context frame. We follow works on semantic segmentation [23] and face frontalization [78] and use a flow module F to warp features and produce temporally consistent outputs despite motion. We extend this to multi-frame contexts, with significant performance gains and no additional parameter to be learned.
Concretely, let ekc be features being encoded from xc, and d k s features being decoded from zs at a given intermediate resolution rk. We first compute all intermediate context features ekc by applying E to xc. We then progressively decode features dks for the new frame from low (k = 1) to high resolution (k = K) by iterating over the following steps: (a) apply one decoding sub-module to get dks from d k−1 s , (b) use F to refine the optical flow fkc (in R2×rk ) which estimates the displacement field from ekc to d k s (as a proxy to the one from xc to xs), and a fusion mask m k c (in R1×rk ) which indicates the expected similarity between aligned features e′kc = W(e k c , f k c ) and d k s (also as a proxy for the one in image domain) with W corresponding to a standard warping operation, (c) use e′kc and mkc to update d k s with context information (see update rule (1) below), (d) move to resolution level rk+1 by going back to (a). We note that F estimates fkc and mkc in a coarse-to-fine fashion by refining fk−1c and m k−1 c (see Appendix A for further details). Temporal skip connections at a given resolution level rk are defined as the following in-place modification of dks :
dks = σ(m k c )⊗ dks + (1− σ(mkc ))⊗ e′kc , (1)
where σ is the Sigmoid function, and ⊗ the element-wise product. We note that update rule (1) is quite standard for warping and fusing two streams of spatial information [23, 28, 74]. For concrete implementation of F , we build upon LiteFlowNet [32], an optical flow estimation model which also combines pyramidal extraction and progressive warping of features. For simple integration into our framework, we use features from E and D both in the mask and flow estimation, and in the update (1). This process readily generalizes to multi-frame contextual information (see Appendix D for details). Similar to spatial transformers [33], the warping operation W is differentiable. As a result, gradients from the training losses can backpropagate from D to E through F . This allows end-to-end training of the autoencoder even with information from different timesteps in E and D.
Training procedure. The global objective is the linear combination of four auxiliary ones: L = λqLq + λrLr + λaLa + λcLc, (2)
namely a quantization loss (Lq), a reconstruction loss (Lr), an adversarial loss (La), and a contextual loss (Lc), detailed in the next paragraphs. The codebook is trained by minimizing the reconstruction error between encoded features z = E(x) and quantized features zq = U(Q(z)) (with notations introduced in Section 3.1):
Lq(E ,Q) = ∥ sg(z)− zq∥22 + β∥ sg(zq)− z∥22, (3) where sg(.) is the stop gradient operation which constrains its operand to remain constant during backpropagation. The first part moves the codebook entries closer to the encoded features. The second part, known as the commitment loss [67], reverses the roles played by the two variables.
In regions with complex textures and high frequency details, local patterns shifted by a few pixels in x and its reconstruction x̂ = D(zq) may result in large pixel-to-pixel errors, while being visually satisfactory. We thus define the recovery objective as the L1 loss in both RGB space and between features from a VGG network [59] pretrained on ImageNet [14]:
Lr(E ,Q,F ,D) = ∥x− x̂∥1 + ∥VGG(x)−VGG(x̂)∥1. (4)
To tackle cases where information cannot be recovered from context due to occlusion, and the compressed features are insufficient to create plausible reconstructions due to lossy compression, we supplement our architecture with an image discriminator ∆i, made of downsampling residual blocks [29], to encourage realistic outputs. ∆i tries to distinguish real images from reconstructed ones (Ld), while E and D fools ∆i into assuming reconstructed images are as good as real ones (La):
Ld(∆i) = ln(1+e∆i(x))+ln(1+e−∆i(x̂)), (5) La(E ,Q,F ,D) = ln(1 + e∆i(x̂)). (6) We employ a similar strategy on sequences of consecutive frames to improve the temporal consistency using a 3D temporal discriminator ∆t, a direct extension of 2D image discriminator ∆i.
The success of our method relies on accurate motion estimation in F , a difficult task which benefits from self-supervision [35]. Therefore, we train the autoencoder with augmented views of the input frames as context. Custom augmentations functions A : X → X include: rotation, scaling, translation, elastic deformation, and combinations of these. Augmented views are obtained by warping x by the suitable flow ac: A(x) = W(x, ac), and the inverted flow fc from A(x) to x can be approximated.1 We resort to flow inversion because directly reconstructing distorted views may encourage similar defects during inference. Moreover, we balance between self-recovery and context-recovery objectives by additionally applying a blurring function B : X → X and an occlusion mask oc to the augmented frames xc = oc ⊗ B(A(x)). This augmentation strategy is illustrated in Appendix F. We define the contextual loss as:
Lc(E ,Q,F ,D) = ∥fc − f̂c∥22 + ∥o′c − σ(m̂c)∥22, (7)
where o′c = W(oc, fc), and f̂c and m̂c are the flow and mask estimated by F . In practice, this loss is applied at intermediate resolution levels rk for improved training.

heading: 3.3 Second stage: predicting temporal dynamics with transformers
text: Architecture. We follow [20] and adopt an architecture similar to Image-GPT [9] for T . Instead of modeling a single annotated frame as in [54], we design our model to account for sequences of N such frames to allow prediction of temporal dynamics controlled by ancillary information in the form of video- and frame-level annotations. We have shown, in Section 3.2, how to represent a frame as a sequence of h× w tokens (indices in J1, qK) through encoding and quantization. Similar strategies can be applied to cater to other types of data, with or without compression depending on their complexity, and, thereby, turn ancillary information into tokens as well. The capacity of the transformer (the maximum sequence length it can process) is L = lv +N ∗ (lf + h ∗ w), where lv and lf are the size of video- and frame-level annotations respectively. The final layer of the model predicts, for every i in J1, L− 1K, a vector ôi (of size q, the number of possible tokens) which scores the likelihood of the i+ 1th token given all preceding ones.
1Our implementation of flow inversion approximation is detailed in Appendix C.
Training procedure. To learn the parameters of T , we load a complete sequence (N frames corresponding to L tokens), and try to predict the L − 1 last tokens based on the L − 1 first ones. This is done by maximizing the log-likelihood of the data using the cross-entropy loss:
L(T ) = − L∑
i=2
log ( exp(⟨ ôi−1, eτ(i)⟩)∑
j exp(⟨ ôi−1, ej⟩)
) , (8)
where τ(i) is the ith ground-truth token, and ej a vector of 0’s with a 1 in its jth coordinate.
Inference. During inference we use T to complete autoregressively an input sequence of tokens. To avoid known pitfalls (e.g., repetitive synthesis) and allow diverse outcomes, we use top-k sampling whereby the next token is randomly chosen among the k most likely ones, weighted by their scores ô. Although T processes sequences of N annotated frames, we predict ones of arbitrary length by using a temporal sliding window. Tokens corresponding to video- and frame-level annotations are given as input to T (not predicted, even for future frames) to guide the synthesis. We show in the experiments how this control can translates into a variety of interesting tasks.

heading: 4 Experiments
text: We assess the merits of CCVS in the light of extensive experiments on various video synthesis tasks.
Datasets. BAIR Robot Pushing [19] consists of 43k training and 256 test videos of a robotic arm interacting with objects from a fixed viewpoint. A high-resolution version has recently been released. We manually annotate, in 500 frames, the (x, y) location of the arm in image space to train a position estimator, which we use for state-conditioned synthesis. To account for real world scenarios, we evaluate on Kinetics-600 [5], a large and diverse action-recognition dataset with approximately 500K videos. We also test our method on AudioSet-Drums [25] for sound-conditioned synthesis on music performance, containing 6k and 1k video clips in train and test splits respectively. Other datasets and tasks are covered in Appendix E.
Metrics. We use the Fréchet video distance (FVD) [66] which measures the distribution gap between real and synthetic videos in the feature space of an Inception3D network [6] pretrained on Kientics-400 [40]. It estimates the visual quality and temporal consistency of samples as well as the diversity in unconditioned scenarios. In conditioned ones, we use another metric for diversity (DIV) which is the mean pixel-wise distance among synthetic trajectories conditioned on the same input. For near-deterministic motions (e.g., in reconstructions, or constrained tasks), there is a one-to-one mapping between real video frames and synthetic ones, and we include pairwise image quality assessments: the structural similarity index measure (SSIM) [77] which evaluates a per-frame
Table 2: Ablation study of the transformer on BAIR. We adopt notations and evaluation setups from Table 1.
Architecture Top-k State-conditioned Pred. Unc. Layer Head Dec. Frame State FVD↓ PSNR↑ FVD↓ FVD↓
6 4 1 1 73±2 23.0 281±7 474±17 12 8 1 1 73±3 23.1 262±7 435±8 24 16 1 1 70±3 23.3 331±9 521±19 24 16 ✓ 1 1 69±2 23.2 321±9 479±34 24 16 ✓ 10 1 65±2 22.4 127±7 308±19 24 16 ✓ 100 1 67±1 22.3 121±2 314±12 24 16 ✓ 100 10 67±1 22.3 100±2 293±7
“Dec.”: spatio-temporal decomposition of positional embeddings.
Figure 3: Quality and speed of synthesis vs. compression on a Nvidia V100 GPU.
conformity (combination of luminance, contrast and structure), and the peak signal-to-noise ratio (PSNR) which is directly related to the root mean squared error. For each metric, we compute the mean and standard deviation (std) over 5 evaluation runs (2 for Kinetics due to its voluminous 50k video test set). For clarity, the std value is shown only when it is greater than the reported precision.
Training details. All our models are trained on 4 Nvidia V100 GPUs (32GB VRAM each), using ADAM [41] optimizer, for multiple 20 hour runs. We adapt the batch size to fill the memory available. We use a learning rate of 0.02 to train the autoencoder, and exponential moving average [83] to obtain its final parameters. We use weighting factors (1, 10, 1, 1) and 0.25 for (λq, λr, λa, λc) and β in Equations (2) and (3) respectively. We use a learning rate of 10−5 to train the transformer.

heading: 4.1 Ablation study
text: We conduct an ablation study of CCVS to show the individual contribution of the key components of the proposed autoencoder (Table 1), transformer (Table 2), and the effect of compression (Figure 3).
First, we fix the transformer and observe the incremental improvements in synthesis quality when adding self- and context-recovery modules to the autoencoder (Table 1). In particular, L1 loss in the feature space of a VGG net [59] produces sharper videos than using the same loss in the RGB space alone. Predicted frames using image and temporal discriminators (∆i and ∆t) display greater realism and temporal consistency. The flow module F significantly improves the performance on all metrics by allowing context frames to guide the reconstruction of synthetic ones. The self-supervision of F , the use of larger context windows, and longer training times, further improve the quality of the synthesis. ∆t seems to deteriorate the FVD at first, but when all modules are combined it improves FVD by almost a factor 2 as it encourages better temporal consistency in the presence of context.
We fix the autoencoder, and compare different architectures and sampling strategies for the transformer (Table 2). Increasing the model capacity by adding layers and increasing expressivity (number of attention heads) along with a spatio-temporal decomposition of positional embeddings (shown in Figure 2, detailed in supplementary material) yields small improvements. Top-k sampling is beneficial for stochastic tasks (video prediction and unconditional synthesis), whereas always selecting the most probable tokens results in little to no motion. Guiding temporal dynamics with state-conditioned synthesis reduces the advantage of sampling by narrowing down possible outcomes.
Finally, we explore the effect of compression (in terms of the number of tokens for each frame) on synthesis speed (FPS) and quality (FVD) of reconstructed and predicted videos (Figure 3). We use a compression of 64 tokens in our default setup since it gives the best FVD while retaining a reasonable speed. The critical drop of FPS for low compression ratios is due to the pairwise consideration of all input tokens in T . Note that using a smaller temporal window in T may allow additional speed-ups.
Table 4: Future video prediction on Kinetics (64×64) of 16-frame videos from 5 consecutive input frames.
Method FVD ↓ GPU/TPU Mem. LVT [53] 225 128GB, 48h Video Transformer [79] 170±5 2TB, 336h∗ DVD-GAN-FP [12] 69±1 2TB, 144h∗ CCVS (ours) 55±1 128GB, 300h TriVD-GAN-FP [45] 26±1 16TB, 160h∗
∗: value confirmed by authors.

heading: 4.2 Quantitative and qualitative studies
text: BAIR. For future video prediction on BAIR (Table 3), CCVS trained at 64×64 resolution (low res.) is on par with the best method (L-size version of [79]), but requires much less computing resources, and outperforms [79] under similar resources. We also propose high res. CCVS which is not strictly comparable to the prior arts as we use 256×256 image resolution for training and test, and resize the synthesized frames to 64×64 for computing FVD. However, using this variant demonstrates the performance gains that can arise by scaling CCVS. We additionally address point-to-point synthesis (with the end frame as a video-level annotation) and state-conditioned synthesis (with the estimated 2D position of the arm as a frame-level annotation). Point-to-point synthesis is more difficult than video prediction: Not only does it requires realistic video continuations, but also ones which explain the end position of all visible objects. Hence, FVD score is constant despite the additional input. Still, this yields better SSIM for mid-point and one-before-last frames. State-conditioned synthesis improves on FVD and mid-synthesis SSIM as motion becomes near-deterministic. Some synthetic frames for these tasks are shown in Figure 4. CCVS creates plausible high-quality videos in various settings, and true interactions with objects compared to previous attempts [48] at the same resolution.
Kinetics. CCVS ranks second on Kinetics video prediction benchmark. Kinetics contains more diversity than BAIR, and the reconstruction is thus more difficult. A solution [54] is to increase the codebook size (Table 5) but it stops translating into better prediction FVD at some point. We also try removing the quantization step (equivalent to an infinite codebook), and directly regressing latent features with T (instead of ranking the likelihood of possible tokens). It allows better reconstructions, yet the prediction FVD is high. Figure 5 shows examples of synthetic continuations conditioned on
DIV∗ ↑ Input Seed 1 Seed 2 Seed 3 Seed 4 Seed 5 Seed 6 t = 1 t = 15 t = 15 t = 15 t = 15 t = 15 t = 15
5-frame unseen test sequences. CCVS produces realistic and temporally coherent outputs which display various types of motion (e.g., body, hand, camera).
AudioSet-Drums. CCVS achieves top performance on sound-conditioned video synthesis on AudioSet Drums (Table 6). Figure 6 shows quantitative and qualitative insights on the diversity of the synthetic trajectories conditioned on the same input for the three datasets. The diversity metrics (DIV) computed on whole frames is lower on AudioSet Drums than on the other two datasets. This is explained by the fact that motion is quite repetitive and involves a limited portion of the frame. The same metric on moving parts only, and the end position of the drummer’s hand and upper left cymbal in qualitative samples, show the diversity of synthetic trajectories. An ablation of CCVS with/without audio guidance as well as more qualitative results on diversity can be found in Appendix E.

heading: 5 Discussion
text: CCVS is on par or better than the state-of-the-art on standard benchmarks, uses less computational resources, and scales to high resolution. Training neural networks is environmentally costly, due to the carbon footprint to power processing hardware [17, 61]. Methods sparing GPU-hours like ours are crucial to make AI less polluting [43, 61], and move from a “Red” to a “Green” AI [58]. Future work will include exploring new codebook strategies and synthesis guided by textual information.
Limitations. CCVS uses a complex architecture and a two-stage training strategy. Simplification of both is an interesting direction for improving the method. Moreover, CCVS lacks global regularization of motion (flow computed on pairs of timesteps), and its efficiency relies on recycling context information such that synthesizing content from scratch (i.e., no input frame given) remains difficult.
Broader impact. The increased accessibility and the many controls CCVS offers could accelerate the emergence of questionable applications, such as “deepfakes” (e.g., a video created from someone’s picture and an arbitrary audio) which could lead to harassment, defamation, or dissemination of fake news. On top of current efforts to automate their detection [49], it remains our responsibility to grow awareness of these possible misuses. Despite these worrying aspects, our contribution has plenty of positive applications which outweigh the potential ethical harms. Our efficient compression scheme is a step in the direction of real-time solutions: e.g., enhancing human-robot interactions, or improving the safety of self-driving cars by predicting the trajectories of people and vehicles nearby.

heading: Acknowledgements
text: This work was granted access to the HPC resources of IDRIS under the allocation 2020-AD011012227 made by GENCI. It was funded in part by the French government under management of Agence Nationale de la Recherche as part of the “Investissements d’avenir” program, reference ANR-19P3IA-0001 (PRAIRIE 3IA Institute). JP was supported in part by the Louis Vuitton/ENS chair in artificial intelligence and the Inria/NYU collaboration. We thank the reviewers for useful comments.

Review summaries:
This submission presents a conditional video synthesis model. This work is largely based on the recent progress of the Transformer-based autoregressive model [17] but with video extension. Differences over [17] are 1) learning-based flow module for temporal consistency, 2) conditioning for controllability, and 3) temporal embedding.  Overall, the submission contains a few technical novelties while being questionable whether significant, and the organization could be further improved. Other than those, the results seem reasonable, and the analyses are well conducted.   =============================================  <After the rebuttal and discussion phase>  The authors' responses have addressed most of this reviewer's concerns, which increases my rating.  The authors are strongly required to reflect all the rebuttal responses in the paper; especially missing reference, acknowledging the conventional works, the additional results, and the preliminary results with the SPADE version. More discussion about the flow module is recommended. 

This paper introduced a conditional video prediction algorithm based on VQ-VAE [57] and Vision Transformer (ViT). Similar to VQ-VAE, the frame-level discrete representation is learned by autoencoder with vector quantization, whose (conditional) prior on the latent representation is modeled by the variants of ViT. The authors also incorporated a useful inductive bias for video prediction by warping features based on optical flow estimation, as in [63]. The practical impacts of the proposed method are demonstrated in various short-term video prediction tasks, showing competitive performance to the previous SOTAs.

This paper proposes a method for video synthesis that combines an encoder / decoder architecture that computes discrete representation of images with a transformer network that predicts those discrete representations into the future. The encoder and decoder are connected through a novel optical flow module that warps encoder features into the decoder in order to predict how objects will move. In experiments, the authors perform thorough ablations of the proposed method, and show that they outperform most baselines.