\documentclass[runningheads]{llncs}
\usepackage{graphicx}

\usepackage{tikz}
\usepackage{comment}
\usepackage{amsmath,amssymb} %
\usepackage{color}

\usepackage{booktabs}
\usepackage{multirow}
\usepackage{tabularx}
\usepackage{threeparttable}
\usepackage{ragged2e}
\usepackage{wrapfig}

\makeatletter
\@namedef{ver@everyshi.sty}{}
\makeatother
\usepackage{pgfplots}
\usepackage{pgfplots}\pgfplotsset{compat=1.9}

\usepackage[accsupp]{axessibility}  %
\newcommand{\ie}{\emph{i.e.}}
\newcommand{\eg}{\emph{e.g.}}

\begin{document}
\pagestyle{headings}
\mainmatter
\def\ECCVSubNumber{4010}  %

\title{Beyond a Video Frame Interpolator: A Space Decoupled Learning Approach to Continuous Image Transition} %
\titlerunning{Beyond a Video Frame Interpolator}
\author{Tao Yang\inst{1} \and
Peiran Ren\inst{1} \and
Xuansong Xie\inst{1} \and
Xiansheng Hua\inst{1} \and 
Lei Zhang\inst{2}} %
\authorrunning{T. Yang et al.}
\institute{DAMO Academy, Alibaba Group \\
\email{\{yangtao9009@gmail.com, peiran\_r@sohu.com, xingtong.xxs@taobao.com, xiansheng.hxs@alibaba-inc.com\}} \\
 \and
Department of Computing, The Hong Kong Polytechnic University \\
\email{\{cslzhang@comp.polyu.edu.hk\}}}
\maketitle

\vspace*{-0.5cm}

\begin{abstract}
   Video frame interpolation (VFI) aims to improve the temporal resolution of a video sequence. Most of the existing deep learning based VFI methods adopt off-the-shelf optical flow algorithms to estimate the bidirectional flows and interpolate the missing frames accordingly. Though having achieved a great success, these methods require much human experience to tune the bidirectional flows and often generate unpleasant results when the estimated flows are not accurate. In this work, we rethink the VFI problem and formulate it as a continuous image transition (CIT) task, whose key issue is to transition an image from one space to another space continuously. More specifically, we learn to implicitly decouple the images into a translatable flow space and a non-translatable feature space. The former depicts the translatable states between the given images, while the later aims to reconstruct the intermediate features that cannot be directly translated. In this way, we can easily perform image interpolation in the flow space and intermediate image synthesis in the feature space, obtaining a CIT model. The proposed space decoupled learning (SDL) approach is simple to implement, while it provides an effective framework to a variety of CIT problems beyond VFI, such as style transfer and image morphing. Our extensive experiments on a variety of CIT tasks demonstrate the superiority of SDL to existing methods. The source code and models can be found at \url{https://github.com/yangxy/SDL}. %
\keywords{Video Frame Interpolation, Continuous Image Transition, Image Synthesis, Space Decoupled Learning}
\end{abstract}

\section{Introduction}
\label{sec:intro}
Video frame interpolation (VFI) targets at synthesizing intermediate frames between the given consecutive frames of a video to overcome the temporal limitations of camera sensors. VFI can be used in a variety of practical applications, including slow movie generation \cite{Jiang2018Superslomo}, motion deblurring \cite{Shen2020BIN} and visual quality enhancement \cite{Xue2019TOFlow}. The conventional VFI approaches \cite{Baker2007ADA} usually calculate optical flows between the source and target images and gradually synthesize the intermediate images. With the great success of deep neural networks (DNNs) in computer vision tasks \cite{Dong2015SRCNN,He2016ResNet,Redmon2016YOLO}, recently researchers have been focusing on developing DNNs to address the challenging issues of VFI.

Most DNN based VFI algorithms can be categorized into flow-based \cite{Jiang2018Superslomo,Bao2019DAIN,Xu2019QVI,Niklaus2020Splatting}, kernel-based \cite{Niklaus2017Adaptive,Lee2020Adacof,Shen2020BIN}, and phase-based ones \cite{Meyer2015Phase,Meyer2018PhaseNet}. With the advancement of optical flow methods \cite{Sun2018PWC-Net,Bar-Haim2020ScopeFlow}, flow-based VFI algorithms have gained increasing popularity and shown good quantitative results on benchmarks \cite{Bao2019DAIN,Niklaus2020Splatting}. However, these methods require much human experience to tune the bidirectional flows, \eg, by using the forward \cite{Jiang2018Superslomo,Bao2019DAIN} and backward \cite{Niklaus2018Context,Niklaus2020Splatting} warping algorithms. In order to improve the synthesis performance, some VFI methods have been developed by resorting to the depth information \cite{Bao2019DAIN}, the acceleration information \cite{Xu2019QVI} and the softmax splatting \cite{Niklaus2020Splatting}. These methods, however, adopt the off-the-shelf optical flow algorithms, and hence they often generate unpleasant results when the estimated flows are not accurate.

To address the above issues, we rethink the VFI problem and aim to find a solution that is free of flows. Different from previous approaches, we formulate VFI as a continuous image transition (CIT) problem. It is anticipated that we could construct a smooth transition process from the source image to the target image so that the VFI can be easily done. Actually, there are many CIT tasks in computer vision applications, such as image-to-image translation \cite{Isola2017Pix2Pix,Zhu2017CycleGAN}, image morphing \cite{Liu2019Few,Park2020Crossbreed} and style transfer \cite{Gatys2016Style,Huang2017Adain}. Different DNN models have been developed for different CIT tasks. Based on the advancement of deep generative adversarial network (GAN) techniques \cite{Brock2019BigGAN,Karras2019StyleGAN,Karras2020StyleGAN2}, deep image morphing methods have been proposed to generate images with smooth semantic changes by walking in a latent space \cite{Radford2016Unsupervised,Jahanian2020GANsteerability}. Similarly, various image-to-image translation methods have been developed by exploring intermediate domains \cite{Gong2019DLOW,Wu2019RelGANMI,Choi2020StarGANV2}, interpolating attribute \cite{Mao2020ContinuousI2I} or feature \cite{Upchurch2017DFI} or kernel \cite{Wang2019DNI} vectors, using physically inspired models for guidance \cite{Pizzati2021CoMoGAN}, and navigating latent spaces with discovered paths \cite{Chen2019Homomorphic,Jahanian2020GANsteerability}. Though significant progresses have been achieved for CIT, existing methods usually rely on much human knowledge of the specific domain, and employ rather different models for different applications. %

In this work, we propose to learn a translatable flow space to control the continuous and smooth translation between two images, while synthesize the image features which cannot be translated. Specifically, we present a novel space decoupled learning (SDL) approach for VFI. Our SDL implicitly decouples the image spaces into a translatable flow space and a non-translatable feature space. With the decoupled image spaces, we can easily perform smooth image translation in the flow space, and synthesize intermediate image features in the non-translatable feature space. Interestingly, the proposed SDL approach can not only provide a flexible solution for VFI, but also provide a general and effective solution to other CIT tasks.

To the best of our knowledge, the proposed SDL is the first flow-free algorithm which is however able to synthesize consecutive interpolations, achieving leading performance in VFI. SDL is easy-to-implement, and it can be readily integrated into off-the-shelf DNNs for different CIT tasks beyond VFI, serving as a general-purpose solution to the CIT problem. We conduct extensive experiments on various CIT tasks, including, VFI, image-to-image translation and image morphing, to demonstrate its effectiveness. Though using the same framework, SDL shows highly competitive performance with those state-of-the-art methods that are specifically designed for different CIT problems.

\vspace{-2mm}
\section{Related Work}
\label{sec:work}
\subsection{Video Frame Interpolation (VFI)}
With the advancement of DNNs, recently significant progresses have been made on VFI. Long \emph{et al}. \cite{Long2016VFI} first attempted to generate the intermediate frames by taking a pair of frames as input to DNNs. This method yields blurry results since the motion information of videos is not well exploited. The latter works are mostly focused on how to effectively model motion and handle occlusions. Meyer \emph{et al}. \cite{Meyer2015Phase,Meyer2018PhaseNet} proposed phase-based models which represent motion as per-pixel phase shift. Niklaus \emph{et al}. \cite{Niklaus2017Adaptive,Niklaus2017Sepconv} came up with the kernel-based approaches that estimate an adaptive convolutional kernel for each pixel. Lee \emph{et al}. \cite{Lee2020Adacof} introduced a novel warping module named Adaptive Collaboration of Flows (AdaCoF). An end-to-end trainable network with channel attention was proposed by Choi \emph{et al}. \cite{Choi2020CAIN}, where frame interpolation is achieved without explicit estimation of motion. The kernel-based methods have achieved impressive results. However, they are not able to generate missing frames with arbitrary interpolation factors and usually fail to handle large motions due to the limitation of kernel size.

Unlike phase-based or kernel-based methods, flow-based models explicitly exploit motion information of videos \cite{Jiang2018Superslomo,Bao2019DAIN,Xu2019QVI,Niklaus2020Splatting}. With the advancement of optical flow methods \cite{Sun2018PWC-Net,Bar-Haim2020ScopeFlow}, flow-based VFI algorithms have become popular due to their good performance. Niklaus and Liu \cite{Niklaus2018Context} adopted forward warping to synthesize intermediate frames. This algorithm suffers from holes and overlapped pixels, and it was later improved by the softmax splatting method \cite{Niklaus2020Splatting}, which can seamlessly map multiple source pixels to the same target location. Since forward warping is not very intuitive to use, most flow-based works adopt backward warping. Jiang \emph{et al}. \cite{Jiang2018Superslomo} jointly trained two U-Nets \cite{Ronneberger2015Unet}, which respectively estimate the optical flows and perform bilateral motion approximation to generate intermediate results. Reda \emph{et al}. \cite{Reda2019UVI} and Choi \emph{et al}. \cite{Choi2020Meta} further improved this work by introducing cycle consistency loss and meta-learning, respectively. Bao \emph{et al}. \cite{Bao2019DAIN} explicitly detected the occlusion by exploring the depth information, but the VFI performance is sensitive to depth estimation accuracy. To exploit the acceleration information, Xu \emph{et al}. \cite{Xu2019QVI} proposed a quadratic VFI method. Recently, Park \emph{et al}. \cite{Park2020BMBC} proposed a bilateral motion network to estimate intermediate motions directly.

\subsection{Continuous Image Transition (CIT)}
In many image transition tasks, the key problem can be formulated as how to transform an image from one state to another state. DNN based approaches have achieved impressive results in many image transition tasks, such as image-to-image translation \cite{Isola2017Pix2Pix,Zhu2017CycleGAN,Wang2018Pix2PixHD}, style transfer \cite{Gatys2016Style,Johnson2016Perceptual}, image morphing \cite{Chen2019Homomorphic} and VFI \cite{Lee2020Adacof,Niklaus2017Sepconv}. However, these methods are difficult to achieve continuous and smooth transition between images. A continuous image transition (CIT) approach is desired to generate the intermediate results for a smooth transition process.

Many researches on image-to-image translation and image morphing resort to finding a latent feature space and blending image features therein \cite{Upchurch2017DFI,Mao2020ContinuousI2I,Pizzati2021CoMoGAN}. However, these methods need to explicitly define the feature space based on human knowledge of the domain. Furthermore, encoding an image to a latent code often results in the loss of image details. Alternatively, methods on image morphing and VFI first establish correspondences between the input images, for example, by using a warping function or bidirectional optical flows, to perform shape deformation of image objects, and then gradually blend images for smooth appearance transition \cite{Wolberg1998Morph,Liao2014Morph,Bao2019DAIN,Niklaus2020Splatting}. Unfortunately, it is not easy to accurately specify the correspondences, leading to superimposed appearance of the intermediate results. In addition to generating a continuous transition between two input images (source and target), there are also methods to synthesize intermediate results between two different outputs \cite{Huang2017Adain,Hong2021Domain}.

\textbf{Image-to-image Translation:}
Isola \emph{et al}. \cite{Isola2017Pix2Pix} showed that the conditional adversarial networks (cGAN) can be a good solution to image-to-image (I2I) translation problems. Many following works, such as unsupervised learning \cite{Zhu2017CycleGAN}, disentangled learning \cite{Lee2018DRIT}, few-shot learning \cite{Liu2019Few}, high resolution image synthesis \cite{Wang2018Pix2PixHD}, multi-domain translation \cite{Choi2018Stargan}, multi-modal translation \cite{Zhu2017Multimodal}, have been proposed to extend cGAN to different scenarios. Continuous I2I has also attracted much attention. A common practice to this problem is to find intermediate domains by weighting discriminator \cite{Gong2019DLOW} or adjusting losses \cite{Wu2019RelGANMI}. Some methods have been proposed to enable controllable I2I by interpolating attribute \cite{Mao2020ContinuousI2I} or feature \cite{Upchurch2017DFI} or kernel \cite{Wang2019DNI} vectors. Pizzati \emph{et al}. \cite{Pizzati2021CoMoGAN} proposed a model-guided framework that allows non-linear interpolations. 

\textbf{Image Morphing:}
Conventional image morphing methods mostly focus on reducing user-intervention in establishing correspondences between the two images \cite{Wolberg1998Morph}. Smythe \cite{Smythe1990Morph} used pairs of mesh nodes for correspondences. Beier and Neely \cite{Beier1992Morph} developed field morphing utilizing simpler line segments other than meshes. Liao \emph{et al}. \cite{Liao2014Morph} performed optimization of warping fields in a specific domain. Recently, methods \cite{Park2020Crossbreed,Abdal2019Img2StyleGAN,Jahanian2020GANsteerability} have been proposed to achieve efficient image morphing by manipulating the latent space of GANs \cite{Brock2019BigGAN,Karras2020StyleGAN2}. However, these methods often result in the loss of image details and require time-consuming iterative optimization during inference. Mao \emph{et al.} \cite{Mao2020ContinuousI2I} and Pizzati \emph{et al}. \cite{Pizzati2021CoMoGAN} decoupled content and style spaces using disentangled representations. They achieved continuous style interpolations by blending the style vectors. However, these methods preserve the content of source image and they are not suitable to image morphing. Park \emph{et al.} \cite{Park2020Crossbreed} overcame this limitation by performing interpolation in both the content and style spaces. 

 As can be seen from the above discussions, existing works basically design rather different models for different CIT tasks. In this work, we aim to develop a state decoupled learning approach to perform different CIT tasks, including VFI, image-to-image translation and image morphing, by using the same framework. 

\section{Proposed Method}
\label{sec:proposed}
\subsection{Problem Formulation}
\label{sec:problem}
Given a source image $I_0$ and a target image $I_1$, the goal of VFI is to synthesize an intermediate result $I_t$ from them: 
\begin{equation}
I_t=\mathcal{G}(I_0, I_1, t),
\label{eqn:general}
\end{equation}
where $t\in(0,1)$ is a control parameter and $\mathcal{G}$ is a transition mapping function. 

To better preserve image details, researchers \cite{Bao2019DAIN,Xu2019QVI,Niklaus2020Splatting} have resorted to using bidirectional optical flows \cite{Sun2018PWC-Net,Teed2020RAFT} of $I_0$ and $I_1$, denoted by $F_{0\rightarrow1}$ and $F_{1\rightarrow0}$, to establish the motion correspondence between two consecutive frames. With the help of optical flows, $I_t$ can be obtained as follows:
\begin{equation}
I_t=\mathcal{G}(I_0, I_1, \mathcal{B}(F_{0\rightarrow1}, F_{1\rightarrow0}, t)),
\label{eqn:vfi}
\end{equation}
where $\mathcal{B}$ is a blending function. Forward \cite{Niklaus2018Context,Niklaus2020Splatting} and backward \cite{Bao2019DAIN,Xu2019QVI} warping algorithms have been proposed to perform the blending $\mathcal{B}$ in Eq.~(\ref{eqn:vfi}). 

The above idea for VFI coincides with some image morphing works \cite{Wolberg1998Morph,Liao2014Morph,Fish2020MorphGAN}, where the warping function, instead of optical flow, is used to mark the object shape changes in the images. However, it is not easy to specify accurately the correspondences using warping, resulting in superimposed morphing appearance. This inspires us to model VFI as a CIT problem and seek for a more effective and common solution.

One popular solution to CIT is to embed the images into a latent space, and then blend the image feature codes therein:
\begin{equation}
I_t=\mathcal{G}(\mathcal{B}(L_0, L_1, t)),
\label{eqn:latent}
\end{equation}
where $L_0, L_1$ represent respectively the latent codes of $I_0, I_1$ in the latent space. For example, StyleGAN \cite{Karras2019StyleGAN} performs \emph{style mixing} by blending the latent codes at various scales. To gain flexible user control, disentangled learning methods \cite{Mao2020ContinuousI2I,Liu2019Few,Pizzati2021CoMoGAN} were later proposed to decompose the latent space into the content and style representations. The smooth style mixing can be achieved by interpolating the style vectors as follows:
\begin{equation}
I_t=\mathcal{G}(L_0^c, \mathcal{B}(L_0^s, L_1^s, t)),
\label{eqn:disentangle}
\end{equation}
where $L_0^s, L_1^s$ are the style representation vectors of $L_0, L_1$, respectively, and $L_0^c$ is the content vector of $L_0$. In this case, $I_1$ serves as the ``style'' input and the content of $I_0$ is preserved. However, the above formulation is hard to use in tasks such as image morphing.

Though impressive advancements have been made, the above CIT methods require much human knowledge to explicitly define the feature space, while embedding an image into a latent code needs time-consuming iterative optimization and sacrifices image details. 

\begin{figure*}[t!]
\centering
\includegraphics[width=0.9\textwidth]{imgs/SDL_arch.pdf}
\caption{The architecture of our space decoupled learning (SDL) method.}
\label{fig:arch}
\end{figure*}

\subsection{Space Decoupled Learning}
\label{sec:sdl}
As discussed in Section \ref{sec:problem}, previous works employ rather different models for different CIT applications. One interesting question is: can we find a common yet more effective framework to different CIT tasks? We make an in-depth investigation of this issue and present such a framework in this section.

The latent space aims to depict the essential image features and patterns of original data. It is expected that in the latent space, the correspondences of input images $I_0$ and $I_1$ can be well built. In other words, the latent codes $L_0, L_1$ in Eq.~(\ref{eqn:latent}) play the role of optical flows $F_{0\rightarrow1}, F_{1\rightarrow0}$ in Eq.~(\ref{eqn:vfi}). Both of Eq.~(\ref{eqn:latent}) and Eq.~(\ref{eqn:vfi}) blend the correspondence of two images to obtain the desired output. The difference lies in that the latent code representation of an image in Eq.~(\ref{eqn:latent}) may lose certain image details, while in Eq.~(\ref{eqn:vfi}) the original inputs $I_0, I_1$ are involved into the reconstruction, partially addressing this problem. 

From the above discussion, we can conclude that the key to CIT tasks is how to smoothly blend the image features whose correspondences can be well built, while reconstruct the image features whose correspondences are hard to obtain. We thus propose to decouple the image space into two sub-spaces accordingly: a \textit{translatable flow space}, denoted by $P$, where the features can be smoothly and easily blended with $t$, and a \textit{non-translatable feature space}, denoted by $Q$, where the features cannot be blended but should be synthesized. With $P$ and $Q$, we propose a unified formulation of CIT problems as follows:
\begin{equation}
I_t=\mathcal{G}(Q_{0\rightarrow1}, \mathcal{B}(P_{0\rightarrow1}, t)).
\label{eqn:sdl}
\end{equation}
The subscript ``$0\rightarrow1$'' means the transition is from $I_0$ to $I_1$. With Eq.~(\ref{eqn:sdl}), we continuously transition those translatable image components in $P$, and reconstruct the intermediate features that cannot be directly transitioned in $Q$. 

Now the question turns to how to define the spaces of $P$ and $Q$. Unlike many previous CIT methods \cite{Mao2020ContinuousI2I,Pizzati2021CoMoGAN} which explicitly define the feature spaces using much human knowledge, we propose to learn $P$ and $Q$ implicitly from training data. We learn a decoupling operator, denoted by $\mathcal{D}$, to decompose the image space of $I_0$ and $I_1$ to the translatable flow space $P$ and the non-translatable feature space $Q$: 
\begin{equation}
(P_{0\rightarrow1}, Q_{0\rightarrow1}) \leftarrow \mathcal{D}(I_0, I_1).
\label{eqn:decouple}
\end{equation}
Specifically, we use several convolutional layers to implement the space decoupling operator $\mathcal{D}$. To gain performance, $\mathcal{D}$ is learned on multiple scales. The proposed method, namely space decoupled learning (SDL), requires no human knowledge of the domain, and it can serve as an effective and unified solution to different CIT tasks. 

The architecture of SDL is a U-shaped DNN, as illustrated in Fig.~\ref{fig:arch}. Unlike standard U-Net \cite{Ronneberger2015Unet}, a novel \emph{SDL unit} is introduced in the decoder part of our network. The detailed structure of the SDL unit is depicted in the right-bottom corner of Fig.~\ref{fig:arch}. The inputs of the SDL unit are the feature maps decomposed in previous convolution layers. Let $C$ be the number of input feature maps and $s\in(0,1)$ be the ratio of translatable flow features to the total features. $s$ is a hyper-parameter controlled by users (we will discuss how to set it in Section~\ref{sec:expriment}). We then split the channel number of input feature maps in $P$ and $Q$ as $s*C$ and $C-s*C$, and perform the blending $\mathcal{B}$ on $P$ while keeping $Q$ unchanged. There are multiple ways to perform the blending. For example, $\mathcal{B}$ can be achieved by scaling the features with factor $t$:
$\mathcal{B}(P_{0\rightarrow1}, t)=t*P_{0\rightarrow1}$, which results in linear interpolation in $P$ and is used in our experiments. Afterwards, the blended $P$ and $Q$ are concatenated as the output of the SDL unit. A merging operator $\mathcal{M}$ (also learned as several convolutional layers like $\mathcal{D}$) is followed to rebind the decoupled spaces on multiple scales. 

A synthesis network is also adopted to improve the final transition results. We employ a GridNet architecture \cite{Fourure2017Gridnet} for it with three rows and six columns. Following the work of Niklaus \emph{et al}. \cite{Niklaus2020Splatting}, some modifications are utilized to address the checkerboard artifacts. The detailed architecture of the synthesis network can be found in the \textbf{supplementary materials}. In addition, it is worth mentioning that $t$ works with the loss function during training if necessary. Details can be found in the section of experiments.
\subsection{Training Strategy}
To train SDL model for VFI, we adopt two loss functions: the Charbonnier loss \cite{Charbonnier1994Loss} $\mathcal{L}_C$ and the perceptual loss \cite{Johnson2016Perceptual} $\mathcal{L}_P$. The final loss $\mathcal{L}$ is as follows:
\begin{equation}
\mathcal{L}=\alpha\mathcal{L}_C+\beta\mathcal{L}_P,
\end{equation}
where $\alpha$ and $\beta$ are balancing parameters. The content loss $\mathcal{L}_C$ enforces the fine features and preserves the original color information. The perceptual loss $\mathcal{L}_P$ can be better balanced to recover more high-quality details. We use the $conv5\_4$ feature maps before activation in the pre-trained VGG19 network \cite{Simonyan2014VGG} as the perceptual loss. In our experiments, we empirically set $\alpha=1$ and $\beta=0.1$.

For other CIT applications including image-to-image translation and image morphing, GAN plays a key role to generate high-quality results in order to alleviate superimposed appearances. In our implementation, we use PatchGAN developed by Isola \emph{et al.} \cite{Isola2017Pix2Pix} for adversarial training. The final loss is the sum of the $\mathcal{L}_1$ loss and PatchGAN loss with equal weights.

\begin{table*}[t]
\centering
\caption{Quantitative comparison (PSNR, SSIM, runtime) of different methods on the Middleburry, UCF101, Vimeo90K and Adobe240fps datasets. The runtime is reported as the average time to process a pair of $640\times 480$ images. The numbers in \textbf{bold} represent the best performance. The upper part of the table presents the results of kernel-based methods, and the lower part presents the methods that can perform smooth frame interpolations. ``-'' means that the result is not available.}
\vspace*{-3mm}
    \resizebox{0.9\textwidth}{!}{\begin{threeparttable}\begin{tabular}{l|c|c|c c|c c|c c|c c}
      \multirow{2}{*}{\textbf{Method}} & 
      \multirow{2}{*}{\textbf{Training Dataset}} & 
      \multicolumn{1}{c}{\textbf{Runtime}} &
      \multicolumn{2}{c}{\textbf{Middleburry}} & 
      \multicolumn{2}{c}{\textbf{UCF101}} & 
      \multicolumn{2}{c}{\textbf{Vimeo90K}} & 
      \multicolumn{2}{c}{\textbf{Adobe240fps}} \\
      & & (ms) & PSNR$\uparrow$ & SSIM$\uparrow$ & PSNR$\uparrow$ & SSIM$\uparrow$ & PSNR$\uparrow$ & SSIM$\uparrow$ & PSNR$\uparrow$ & SSIM$\uparrow$ \\
      \hline
      SepConv \protect{\cite{Niklaus2017Sepconv}} & proprietary & 57 & 35.73 & 0.959 & 34.70 & 0.947 & 33.79 & 0.955 & - & -  \\
      CAIN \protect{\cite{Choi2020CAIN}} & proprietary & 56 & 35.07 & 0.950 & 34.97 & 0.950 & 34.64 & 0.958 & - & - \\
      AdaCof \protect{\cite{Lee2020Adacof}} & Vimeo90K & 77 & 35.71 & 0.958 & 35.16 & 0.950 & 34.35 & 0.956 & - & - \\
      CDFI \protect{\cite{Ding2021CDFI}} & Vimeo90K & 248 & 37.14 & 0.966 & 35.21 & 0.950 & 35.17 & 0.964 & - & - \\
      \hline
      \hline
      SuperSloMo \protect{\cite{Jiang2018Superslomo}} & Adobe240fps+Youtube240fps & 67 & 33.64 & 0.932 & 33.14 & 0.938 & 32.68 & 0.938 & 30.76 & 0.902 \\
      DAIN \protect{\cite{Bao2019DAIN}} & Vimeo90K & 831 & 36.70 & 0.964 & 35.00 & 0.949 & 34.70 & 0.963 & 29.22 & 0.877 \\
      BMBC \protect{\cite{Park2020BMBC}} & Vimeo90K & 3008 & 36.78 & 0.965 & 35.15 & 0.950 & 35.01 & \textbf{0.965} & 29.56 & 0.881 \\
      EDSC \protect{\cite{Cheng2021EDSC}} & Vimeo90K-Septuplet & 60 & 36.81 & \textbf{0.967} & 35.06 & 0.946 & 34.57 & 0.956 & 30.28 & 0.900 \\
      SDL & Vimeo90K+Adobe240fps & \textbf{42} & \textbf{37.38} & \textbf{0.967} & \textbf{35.33} & \textbf{0.951} & \textbf{35.47} & \textbf{0.965} & \textbf{31.38} & \textbf{0.914} \\
   \end{tabular}
\end{threeparttable}}
\label{tab:vficomp}
\vspace*{-2mm}
\end{table*}

\begin{figure*}[t!]
\centering
\includegraphics[width=0.9\textwidth]{imgs/vfi.pdf}
\vspace*{-5mm}
\caption{Visual comparison of competing methods on the Vimeo90K test set. (a) SepConv \protect\cite{Niklaus2017Sepconv}; (b) SuperSloMo \protect\cite{Jiang2018Superslomo}; (c) CAIN \protect\cite{Choi2020CAIN}; (d) EDSC \protect\cite{Cheng2021EDSC}; (e) DAIN \protect\cite{Bao2019DAIN}; (f) BMBC \protect\cite{Park2020BMBC}; (g) SDL; (h) Ground truth.}
\label{fig:vimeo}
\end{figure*}

\vspace*{-2mm}
\section{Experiments and Applications}
\vspace*{-1mm}
\label{sec:expriment}
In this section, we first conduct extensive experiments on VFI to validate the effectiveness of our SDL method, and then apply SDL to other CIT tasks beyond VFI, such as face aging, face toonification and image morphing, to validate the generality of SDL. 

\vspace*{-2mm}
\subsection{Datasets and Training Settings for VFI} 
\vspace*{-1mm}
There are several datasets publicly available for training and evaluating VFI models, including Middlebury \cite{Baker2007Middlebury}, UCF101 \cite{Soomro2012UCF101AD}, Vimeo90K \cite{Xue2019TOFlow} and Adobe240-fps \cite{Su2017Adobe240fps}. The Middlebury dataset contains two subsets, \ie, \emph{Other} and \emph{Evaluation}. The former provides ground-truth middle frames, while the later hides the ground-truth, and the users are asked to upload their results to the benchmark website for evaluation. The UCF101 dataset \cite{Soomro2012UCF101AD} contains $379$ triplets of human action videos, which can be used for testing VFI algorithms. The frame resolution of the above two datasets is $256\times256$. 

We combine the training subsets in Adobe240-fps and Vimeo90K to train our SDL model. The Vimeo90K dataset \cite{Xue2019TOFlow} has $51,312$ ($3,782$) triplets for training (testing), where each triplet contains $3$ consecutive video frames of resolution $256\times448$. This implicitly sets the value of $t$ to $0.5$, and hence it is insufficient to train our SDL model for finer time intervals. We further resort to the Adobe240-fps dataset \cite{Su2017Adobe240fps}, which is composed of high frame-rate videos, for model training. We first extract the frames of all video clips, and then group the extracted frames with $12$ frames per group. There is no overlap between any two groups. During training, we randomly select $3$ frames $I_a, I_b, I_c$ from a group as a triplet, where $\{a,b,c\}\in\{0,1,...,11\}$ and $a<b<c$. The corresponding value of $t$ can be calculated as $(b-a)/(c-a)$. We also randomly reverse the direction of the sequence for data augmentation ($t$ is accordingly changed to $1-t$). Each video frame is resized to have a shorter spatial dimension of $360$ and a random crop of $256\times256$. Horizontal flip is performed for data augmentation. Following SuperSloMo \cite{Jiang2018Superslomo}, we use $112$ video clips for training and the rest $6$ for validation. 

During model updating, we adopt the Adam \cite{Kingma2015AdamAM} optimizer with a batch size of $48$. The initial learning rate is set as $2\times 10^{-4}$, and it decays by a factor of $0.8$ for every 100K iterations. The model is updated for 600K iterations. 
\subsection{Comparisons with State-of-the-arts} 
We evaluate the performance of the proposed SDL method in comparison with two categories of state-of-the-art VFI algorithms, whose source codes or pretrained models are publicly available. The first category of methods allow frame interpolation at arbitrary time, including SuperSloMo \cite{Jiang2018Superslomo}, DAIN \cite{Bao2019DAIN}, BMBC \cite{Park2020BMBC} and EDSC \cite{Cheng2021EDSC}. The second category is kernel-based algorithms, including SepConv \cite{Niklaus2017Sepconv}, CAIN \cite{Choi2020CAIN}, AdaCof \cite{Lee2020Adacof} and CDFI \cite{Ding2021CDFI}, which can only perform frame interpolation iteratively at the power of $2$. The PSNR and SSIM \cite{Wang2004SSIM} indices are used for quantitative comparisons.

Table~\ref{tab:vficomp} provides the PSNR/SSIM and runtime results on the Middlebury \emph{Other} \cite{Baker2007Middlebury}, UCF101 \cite{Soomro2012UCF101AD}, Vimeo90K \cite{Xue2019TOFlow} and Adobe240-fps \cite{Su2017Adobe240fps} testing sets. In all experiments, the first and last frames of each group are taken as inputs. On the first three datsets, we set $t=0.5$ to interpolate the middle frame. While on the high frame rate Adobe240-fps dataset, we vary $t\in\{\frac{1}{11},\frac{2}{11},...,\frac{10}{11}\}$ to produce the intermediate $10$ frames, which is beyond the capability of kernel-based methods \cite{Niklaus2017Sepconv,Choi2020CAIN,Lee2020Adacof,Ding2021CDFI}. All the methods are tested on a NVIDIA V100 GPU, and we calculate the average processing time for $10$ runs. From Table~\ref{tab:vficomp}, one can see that the proposed SDL approach achieves best PSNR/SSIM indices on all the datasets, while it has the fastest running speed. The kernel-based method CDFI \cite{Ding2021CDFI} also achieves very good PSNR/SSIM results. However, it often fails to handle large motions due to the limitation of kernel size. The flow-based methods such as DAIN \cite{Bao2019DAIN} address this issue by referring to bidirectional flows, while inevitably suffer from inaccurate estimations. The proposed SDL implicitly decouples the images into a translatable flow space and a non-translatable feature space, avoiding the side effect of inaccurate flows.

Fig.~\ref{fig:vimeo} presents some visual comparisons of the VFI results of competing methods. It can be seen that our SDL method preserves better the image fine details and edge structures especially in scenarios with complex motions, where inaccurate flow estimations are commonly observed. SDL manages to address this difficulty by implicitly decoupling the images into a translatable flow space and a non-translatable feature space, and hence resulting in better visual quality with fewer interpolation artifacts. More visual comparison results can be found in the \textbf{supplementary material}.  
In the task of VFI, optical flow is widely used to explicitly align the adjacent frames. However, this may lead to visual artifacts on pixels where the flow estimation is not accurate. In our SDL, we decouple the image space into a translatable flow space and a non-translatable feature space, and only perform interpolation in the former one, avoiding the possible VFI artifacts caused by inaccurate flow estimation. In Fig.~\ref{fig:vis}, we visualize the the translatable flow space and compare it with the optical flow obtained by SpyNet \cite{Ranjan2017SpyNet}. As can be seen, the translatable flow space matches the optical flow on the whole, while it focuses more on the fine details and edge structures that are import to synthesize high-quality results.

\begin{figure}[t!]
\begin{minipage}[t]{0.5\linewidth}
   \centering
    \includegraphics[width=1\textwidth]{imgs/vis.jpg}
    \caption{Visualization of the translatable flow space and the optical flow in VFI. \textbf{Left:} the translatable flow space; \textbf{Right:} the optical flow.}
    \label{fig:vis}
\end{minipage}
\hspace{0.05cm}
\begin{minipage}[t]{0.5\linewidth} 
    \centering
    \begin{tikzpicture}
      \begin{axis}[
          xlabel={$s$},
          ylabel={PSNR (dB)},
          xmin=0, xmax=1,
          ymin=26, ymax=36,
          xtick={0,0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9,1},
          ytick={26,28,30,32,34,36},
          legend pos=north west,
          ymajorgrids=true,
          grid style=dashed,
          width=5.2cm, height=3.2cm,
          ticklabel style={font=\tiny},
          xlabel style={at={(1,0)}, right, yshift=0pt}
      ]
      \addplot[
          color=blue,
          mark=square,
          ]
          coordinates {
          (0,26.5)(0.1,35.47)(0.2,35.31)(0.3,35.3)(0.4,35.57)(0.5,35.98)(0.6,35.82)(0.7,35.61)(0.8,35.4)(0.9,35.11)(1,30.95)
          };
      \end{axis}
    \end{tikzpicture}
    \caption{PSNR vs. $s$ on the Adobe240-fps testing set. When $s=0.5$, the PSNR reaches the peak, while the performance is very stable by varying $s$ from $0.1$ to $0.9$.}
    \label{fig:ratio}
\end{minipage}
\vspace*{-1mm}
\end{figure}

\begin{table}[t!]
\centering
\caption{Quantitative comparison (PSNR, SSIM) between SDL and its variants on the Middleburry, UCF101, Vimeo90K and Adobe240fps datasets. The numbers in \textbf{bold} represent the best results.}
\vspace*{-3mm}
    \resizebox{0.95\textwidth}{!}{
    \begin{tabular}{l|c|c c|c c|c c|c c}
      \multirow{2}{*}{\textbf{Method}} & 
      \multirow{2}{*}{\textbf{Training Dataset}} & 
      \multicolumn{2}{c}{\textbf{Middleburry}} & 
      \multicolumn{2}{c}{\textbf{UCF101}} & 
      \multicolumn{2}{c}{\textbf{Vimeo90K}} & 
      \multicolumn{2}{c}{\textbf{Adobe240fps}} \\
      & & PSNR$\uparrow$ & SSIM$\uparrow$ & PSNR$\uparrow$ & SSIM$\uparrow$ & PSNR$\uparrow$ & SSIM$\uparrow$ & PSNR$\uparrow$ & SSIM$\uparrow$ \\
      \hline
      SDL-vimeo90k & Vimeo90K & \textbf{37.49} & \textbf{0.967} & 35.27 & \textbf{0.951} & \textbf{35.56} & \textbf{0.965} & 26.52 & 0.811 \\
      SDL-w/o-sdl & Vimeo90K+Adobe240fps & 36.96 & 0.964 & 35.24 & 0.950 & 35.38 & 0.964 & 26.51 & 0.817 \\
      SDL-w/o-syn & Vimeo90K+Adobe240fps & 37.19 & 0.965 & 35.27 & \textbf{0.951} & 35.37 & 0.964 & 31.21 & 0.911 \\
      SDL & Vimeo90K+Adobe240fps & 37.38 & \textbf{0.967} & \textbf{35.33} & \textbf{0.951} & 35.47 & \textbf{0.965} & \textbf{31.38} & \textbf{0.914} \\
   \end{tabular}}
\label{tab:vfi_ablation}
\vspace*{-5mm}
\end{table}
\vspace*{-2mm}
\subsection{Ablation Experiments}
\label{sec:ablation}
In this section, we conduct experiments to investigate the ratio of translatable flow features, and compare SDL with several of its variants.

\textbf{Translatable Flow Features.}
In order to find out the effect of $s$ (\ie, the ratio of translatable flow features to total features) of SDL, we set $s\in\{0,0.1,...,1\}$) and perform experiments on the Adobe240-fps testing set. The curve of PSNR versus $s$ is plotted in Fig.~\ref{fig:ratio}. We can see that the performance decreases significantly if all feature maps are assigned to non-translatable feature space (\ie, $s=0$) or translatable flow space (\ie, $s=1$). When $s=0.5$, the PSNR reaches the peak, while the performance is very stable by varying $s$ from $0.1$ to $0.9$. This is because SDL can learn to adjust its use of translatable and non-translatable features during training. %

\textbf{The variants of SDL.}
We compare SDL with several of its variants to validate the design and training of SDL. The first variant is denoted as SDL-vimeo90k, \ie, the model is trained using only the Vimeo90K dataset. The second variant is denoted as SDL-w/o-sdl, \ie, SDL without space decoupling learning by setting $s=0$. The third variant is denoted as SDL-w/o-syn, \ie, the synthesis network is replaced with several convolution layers.

We evaluate SDL and its three variants on the Middlebury \emph{Other} \cite{Baker2007Middlebury}, UCF101 \cite{Soomro2012UCF101AD}, Vimeo90K \cite{Xue2019TOFlow} and Adobe240-fps \cite{Su2017Adobe240fps} testing sets, and the PSNR and SSIM results are listed in Table~\ref{tab:vfi_ablation}. One can see that SDL-vimeo90k achieves the best SSIM indices on all the triplet datasets, and the best PSNR indices on Middlebury \emph{Other} and Vimeo90K by using a smaller training dataset than SDL, which uses both Vimeo90K and Adobe240-fps in training. This is because these is a domain gap between Adobe240-fps and Vimeo90k, and hence the SDL-vimeo90k can overfit the three triplet dataset. Furthermore, SDL-vimeo90k performs poorly on the Adobe240-fps dataset. This implies that training SDL using merely triplets fails to synthesize continuous frames.

Without decoupling the space, SDL-w/o-sdl performs much worse than the full SDL model, especially on the Adobe240-fps testing set. This validates that the space decoupling learning strategy boosts the VFI performance and plays a key role in continuous image transition. Without the GridNet \cite{Fourure2017Gridnet}, which is widely used as the synthesis network to improve VFI performance \cite{Niklaus2018Context,Niklaus2020Splatting}, SDL-w/o-syn maintains good VFI performance on all the datasets with only slight PSNR/SSIM decrease compared to original SDL.

\begin{figure}[t!]
\centering
\includegraphics[width=0.8\textwidth]{imgs/aging_comp.pdf}
\vspace{-3mm}
\caption{Comparison of SDL with StyleGAN2 backpropagation on face aging. From left to right: input image, StyleGAN2 backpropagation \protect{\cite{Viazovetskyi2020Distillation}} and SDL. Note that artifacts can be generated by StyleGAN2 backpropagation, while SDL can synthesize the image more robustly.}
\label{fig:bad}
\vspace{-5mm}
\end{figure}

\begin{figure*}[t!]
\centering
\includegraphics[width=0.86\textwidth]{imgs/i2i_aging.pdf}
\vspace*{-5mm}
\caption{Comparison of SDL with competing methods on continuous face aging. From top to bottom: SDL, StyleGAN2 backpropagation \protect{\cite{Viazovetskyi2020Distillation}}, SAVI2I \protect{\cite{Mao2020ContinuousI2I}}, Lifespan \protect{\cite{Orel2020Lifespan}} and DNI \protect{\cite{Wang2019DNI}}.}
\label{fig:i2i}
\vspace*{-6mm}
\end{figure*}

\vspace*{-2mm}
\subsection{Applications beyond VFI}
\vspace*{-1mm}
The proposed SDL achieves leading performance in VFI without using optical flows. It can also be used to address other CIT applications beyond VFI, such as image-to-image translation and image morphing. In this section, we take face aging and toonification and dog-to-dog image morphing as examples to demonstrate the generality of our SDL approach.

\textbf{Face Aging.}
\label{sec:I2I}
Unlike VFI, there is no public dataset available for training and assessing continuous I2I models. To solve this issue, we use StyleGAN \cite{Karras2019StyleGAN,Karras2020StyleGAN2}, which is a cutting-edge network for creating realistic images, to generate training data. Following \cite{Viazovetskyi2020Distillation}, we use StyleGAN2 distillation to synthesize datasets for face manipulation tasks such as aging. We first locate the direction vector associated with the attribute in the latent space, then randomly sample the latent codes to generate source images. For each source image, we walk along the direction vector with equal pace to synthesize a number of target images. 
As shown in the middle image of Fig.\ref{fig:bad}, StyleGAN2 distillation may not always generate faithful images. We thus manually check all the samples to remove unsatisfactory ones. Finally, $50,000$ samples are generated, and each sample contains $11$ images of $1024\times 1024$. The dataset will be made publicly available.

The source image $I_0$ and a randomly selected target image $I _a$ ($a\in1,2,...,10$) are used as the inputs to train the SDL model. The corresponding value of $t$ is $a/10$. We also randomly replace the source image $I_0$ with the target image $I_{10}$ during training, and the corresponding value of $t$ can be set as $a/10-1$. In this way, the range of $t\in[0,1]$ can be extended to $[-1,1]$ so that our model can produce both younger (by setting $a\in[-1,0)$) and older faces (by setting $a\in(0, 1]$). Note that SDL only needs the source image as input in inference.

Though trained on synthetic datasets, SDL can be readily used to handle real-world images. Since only a couple of works have been proposed for continuous I2I translation problem, and we choose those methods \cite{Wang2019DNI,Mao2020ContinuousI2I,Orel2020Lifespan} whose training codes are publicly available to compare, and re-train their models using our datasets. In particular, we employ the same supervised $L_1$ loss as ours to re-train those unsupervised methods for fair comparison. Fig.~\ref{fig:i2i} shows the results of competing methods on continuous face aging. One can see that SDL outperforms clearly the competitors in generating realistic images. By synthesizing the non-translatable features in reconstruction, SDL also works much better on retaining image background, for example, the mouth in the right-top corner. StyleGAN2 backpropagation \cite{Viazovetskyi2020Distillation} generates qualified aging faces; however, it fails to translate the face identity and loses the image background. SDL also produces more stable results than StyleGAN2 backpropagation, as shown in Fig.\ref{fig:bad}.

It is worth mentioning that SDL is $10^3$ times faster than StyleGAN2 backpropagation which requires time-consuming iterative optimization. SAVI2I \cite{Mao2020ContinuousI2I} fails to generate qualified intermediaries with photo-realistic details. Lifespan \cite{Orel2020Lifespan} adopts an off-the-shelf face segmentation algorithm to keep the background unchanged. However, the generated face images have low quality. To test DNI \cite{Wang2019DNI}, we train two Pix2PixHD \cite{Wang2018Pix2PixHD} models to generate younger and older faces, respectively, and blend their weights continuously. As can be seen, DNI \cite{Wang2019DNI} fails to produce reasonable transition results. Moreover, SDL can generate continuous image-to-image translations with arbitrary resolutions, while all the competing methods cannot do it. More visual comparison results can be found in the \textbf{supplementary materials}.

\begin{figure*}[t!]
\centering
\includegraphics[width=0.86\textwidth]{imgs/I2I_toonify.pdf}
\vspace*{-5mm}
\caption{Comparison of SDL with competing methods on continuous face toonification. From top to bottom: SDL, Pinkney \emph{et al.} \cite{Pinkney2020ResolutionDG}, and SAVI2I \protect{\cite{Mao2020ContinuousI2I}}.}
\label{fig:toonification}
\vspace*{-5mm}
\end{figure*}

\textbf{Face Toonification.} 
We first build a face toonification dataset by using the method of \emph{layer swapping} \cite{Pinkney2020ResolutionDG}. Specifically, we finetune a pretrained StyleGAN on a cartoon face dataset to obtain a new GAN, then swap different scales of layers of the two GANs (\ie, the pretrained and the finetuned ones) to create a series of blended GANs, which can generate various levels of face toonification effects. Similar to face aging, we generate $50,000$ training samples, each containing $6$ images of resolution $1024\times 1024$. During training, we take the source images (\ie, $I_0$) as input and randomly choose a target image $I_a$, $a\in\{1,2,...,5\}$, as the ground-truth output. The corresponding value of $t$ is $a/5$.

We compare SDL with Pinkney \emph{et al.} \cite{Pinkney2020ResolutionDG} and SAVI2I \cite{Mao2020ContinuousI2I}, whose source codes are available. As shown in Fig.~\ref{fig:toonification}, SDL outperforms the competitors in producing visually more favourable results. Pinkney \emph{et al.} \cite{Pinkney2020ResolutionDG} generates qualified toonification effects but it fails to retain the face identity and the image background. The generated face images of SAVI2I \cite{Mao2020ContinuousI2I} have low quality. Furthermore, SAVI2I \cite{Mao2020ContinuousI2I} merely synthesizes images with a resolution of $256\times 256$, while SDL can yield results at any resolution. More visual comparison results can be found in the \textbf{supplementary materials}.

\begin{figure*}[t!]
\centering
\includegraphics[width=0.86\textwidth,,height=0.49\textwidth]{imgs/morphing.pdf}
\vspace*{-5mm}
\caption{Comparison of SDL with competing methods on dog-to-dog morphing. From top to bottom: SDL, StyleGAN2 backpropagation \protect{\cite{Viazovetskyi2020Distillation}}, CrossBreed \protect{\cite{Park2020Crossbreed}}, SAVI2I \protect{\cite{Mao2020ContinuousI2I}}, and FUNIT \protect{\cite{Liu2019Few}}.}
\label{fig:morphing}
\vspace*{-5mm}
\end{figure*}

\textbf{Dog-to-Dog Morphing.}
Similar to I2I translation, we synthesize training data for dog-to-dog morphing using StyleGAN2 \cite{Karras2020StyleGAN2} and BigGAN \cite{Brock2019BigGAN}. We randomly sample two latent codes as the source and target images. The intermediate images are obtained by interpolating the two codes in the latent space. We generate $50,000$ training samples, each containing $11$ images of resolution $512\times 512$. During training, we take the source and target images (\ie, $I_0, I_{10}$) as inputs and randomly choose an image $I_a$, $a\in\{1,2,...,9\}$, as the ground-truth output.  

Since few methods have been proposed for continuous image morphing, we compare SDL with I2I translation models, including CrossBreed \cite{Park2020Crossbreed}, SAVI2I \cite{Mao2020ContinuousI2I} and FUNIT \cite{Liu2019Few}. (We re-train their models using our datasets and the same supervised $L_1$ loss for fair comparison.) As shown in Fig.~\ref{fig:morphing}, SDL achieves smooth morphing from one dog to another with vivid details. StyleGAN2 backpropagation \cite{Viazovetskyi2020Distillation} yields comparable results but it loses the background details. CrossBreed \cite{Park2020Crossbreed} and SAVI2I \cite{Mao2020ContinuousI2I} fail to generate qualified intermediate results. FUNIT \cite{Liu2019Few} produces smooth morphing; however, the generated dog images have low quality and it fails to retain the image content when $t=0,1$. Please refer to the \textbf{supplementary materials} for more visual comparisons.

\vspace*{-3mm}
\section{Conclusion}
\vspace*{-2mm}
We proposed a simple yet effective approach, namely space decoupled learning (SDL), for VFI problem. We implicitly decoupled the images into a translatable flow space and a non-translatable feature space, and performed image interpolation in the flow space and intermediate image synthesis in the feature space. The proposed SDL can serve as a general-purpose solution to a variety of continuous image transition (CIT) problems. As demonstrated by our extensive experiments, SDL showed highly competitive performance with the state-of-the-arts, which were however specifically designed for their given tasks. Particularly, in the application of video frame interpolation, SDL was the first flow-free algorithm that can synthesize consecutive interpolations with leading performance. In other CIT tasks such as face aging, face toonification and dog-to-dog morphing, SDL exhibited much better visual quality and efficiency with more foreground and background details.  
\clearpage
\bibliographystyle{splncs04}
\bibliography{egbib}
\end{document}


Peer review:
.
1) Summary:

The paper reformulates Video Frame Interpolation (VFI) as a Continuous Image Transition task. The approach is based on Space Decoupled Learning (SDL) and it shows competitive results for VFI and for other CIT tasks.

2) Strengths:
- SDL simplifies VIF to a CIT problem without affecting performance and without requiring any human knowledge of the domain. Additionally, SDL works well for several CIT tasks.
- Paper very well written.
- Hypothesis supported by experiments.
- In line with workshop.

3) Weaknesses.
- Figure 1 is usually an important figure in the paper. It seems a bit difficult to follow and to read.
Rating: 8: Top 50% of accepted papers, clear accept
Confidence: 4: The reviewer is confident but not absolutely certain that the evaluation is correct