Bilinear interpolation implemented by convolution I read the paper Deep Feature Flow for Video Recognition https://arxiv.org/abs/1611.07715.

In Sec.3, the author implements bilinear interpolation like this:

$$f_i^c(p)=\sum\limits_{q}G(q,p+\delta p)f_k^c(q) \tag{1}$$

Where $q$ is the point from the source image, and $p$ is the points on the target image. $\delta p$ is the distance the point moved each point $p$ (not $\delta \bullet p$). $G$ is defined as 

$$G(q,p+\delta p)=g(q_x,p_x+\delta p_x)g(q_y,p_y+\delta p_y)\tag{2}$$

And the bilinear interpolation is defined in wiki as:

$$f(x,y)\approx {\frac {y_{2}-y}{y_{2}-y_{1}}}f(x,y_{1})+{\frac {y-y_{1}}{y_{2}-y_{1}}}f(x,y_{2})\tag{3}$$

I think the operation $(1)$ and $(3)$ is equivalent. How can I derive the filter $(1)$ from $(3)$?
Honestly I haven't read that article you linked to, but as long as you want a convolution kernel for 2D bilinear interpolation, then the following should help.

Bilinear interpolation gives a crude result which can be sufficient in case the application does not require a perfect output otherwise. Then the following simple triangular 2D convolution kernel implements a bilinear interpolation of the ratio (after compression by $M$) given by $r = \frac{L}{M} &gt; 1$. 

L = 9;          % upsampling ratio
M = 5;          % downsampling ratio (M &lt; L assumed)

h   = (1/L)*conv(ones(1,L),ones(1,L));  % 1D linear interpolator.
hBL = h'*h;                             % 2D bi-linear interpolator.

I = im2double(imread('Cameraman.tif')); % Read some image into double
S = size(I);                            % size of image

Ie = zeros( L*S(1), L*S(2) ) ;          % expand the image by stuffing zeros
Ie( 1:L:end , 1:L:end ) = I;            % assign the original pixels

Iup = conv2(Ie,hBL);                    % linear upsample (interpolate) by L
Iint = Iup(1:M:end,1:M:end);            % downsample by M

figure,imshow(I);title('original image');
figure,imshow(Iint);title('upsampled by L/M times');