def increment_deep_cf(As, Bs, X, y, increment_cf=increment_mccf,
n_levels=3, l=0.01, boundary='constant'):
r"""
Increment Deep Correlation Filter (DCF) filter.
Parameters
----------
X : ``(n_images, n_channels, height, width)`` `ndarray`
Training images.
y : ``(1, height, width)`` `ndarray`
Desired response.
learn_cf : `callable`, optional
Callable used to learn a single shallow Correlation Filter (CF) (
`learn_mosse` for single channel images or `learn_mccf` for
multi-channel images).
n_levels : int, optional
The number of level.
l: `float`, optional
Regularization parameter.
boundary: str {`constant`, `symmetric`}, optional
Determines how the image is padded.
Returns
-------
deep_mosse: ``(1, height, width)`` `ndarray`
Deep Correlation Filter (DCF) filter associated to the training images.
"""
# learn mosse filter
f, A, B = increment_cf(As[0], Bs[0], X, y, l=l, boundary=boundary)
# initialize filters, numerators and denominators arrays
fs = np.empty((n_levels,) + f.shape)
As[0] = A
Bs[0] = B
# store filter
fs[0] = f
# for each level
for k in range(1, n_levels):
nX = []
# for each training image
for j, x in enumerate(X):
# convolve image and filter
x = np.sum(fast2dconv(x, f, mode='full', boundary=boundary),
axis=0)[None]
# replace image with response
nX.append(x)
X = np.asarray(nX)
# learn mosse filter from responses
f, A, B = increment_cf(As[k], Bs[k], X, y, l=l, boundary=boundary)
# store filter, numerator and denominator
fs[k] = f
As[k] = A
Bs[k] = B
# compute equivalent deep mosse filter
df = fs[0]
for f in fs[1:]:
df = fast2dconv(df, f, boundary=boundary)
return df, As, Bs
def learn_deep_kcf(x, y, n_levels=3, kernel_correlation=gaussian_correlation,
l=0.01, boundary='constant', **kwargs):
r"""
Deep Kernelized Correlation Filter (DKCF).
Parameters
----------
x : ``(channels, height, width)`` `ndarray`
Template image.
y : ``(1, height, width)`` `ndarray`
Desired response.
n_levels: `int`, optional
Number of levels.
kernel_correlation: `callable`, optional
Callable implementing a particular type of kernel correlation i.e.
gaussian, polynomial or linear.
l: `float`, optional
Regularization parameter.
boundary: str {`constant`, `symmetric`}, optional
Determines how the image is padded.
Returns
-------
deep_alpha: ``(channels, height, width)`` `ndarray`
Deep Kernelized Correlation Filter (DKFC), in the frequency domain,
associated to the template image.
"""
# learn alpha
alpha = learn_kcf(x, y, kernel_correlation=kernel_correlation, l=l,
boundary=boundary, **kwargs)
# initialize alphas
alphas = np.empty((n_levels,) + alpha.shape)
# for each level
for l in range(n_levels):
# store filter
alphas[l] = alpha
# compute kernel correlation between template and image
kxz = kernel_correlation(x, x, **kwargs)
# compute kernel correlation response
x = fast2dconv(kxz, alpha)
# learn mosse filter from responses
alpha = learn_kcf(x, y, kernel_correlation=kernel_correlation, l=l,
boundary=boundary, **kwargs)
# compute equivalent deep mosse filter
deep_alpha = alphas[0]
for a in alphas[1:]:
deep_alpha = fast2dconv(a, a, boundary=boundary)
return deep_alpha, alphas
def gaussian_correlation(x, z, sigma=0.2, boundary='constant'):
r"""
Gaussian kernel correlation.
Parameters
----------
x : ``(channels, height, width)`` `ndarray`
Template image.
z : ``(channels, height, width)`` `ndarray`
Input image.
sigma: `float`, optional
Kernel std.
Returns
-------
xz: ``(1, height, width)`` `ndarray`
Gaussian kernel correlation between the image and the template.
"""
# norms
x_norm = x.ravel().T.dot(x.ravel())
z_norm = z.ravel().T.dot(z.ravel())
# cross correlation
xz = np.sum(fast2dconv(z, x[:, ::-1, ::-1], boundary=boundary), axis=0)
# gaussian kernel
kxz = np.exp(-(1/sigma**2) * np.maximum(0, x_norm + z_norm - 2 * xz))
return kxz[None]
def polynomial_correlation(x, z, a=5, b=1, boundary='constant'):
r"""
Polynomial kernel correlation.
Parameters
----------
x : ``(channels, height, width)`` `ndarray`
Template image.
z : ``(channels, height, width)`` `ndarray`
Input image.
a: `float`, optional
Kernel exponent.
b: `float`, optional
Kernel constant.
Returns
-------
kxz: ``(1, height, width)`` `ndarray`
Polynomial kernel correlation between the image and the template.
"""
# cross correlation
xz = np.sum(fast2dconv(z, x[:, ::-1, ::-1], boundary=boundary), axis=0)
# polynomial kernel
kxz = (xz + b) ** a
return kxz[None]
def linear_correlation(x, z, boundary='constant'):
r"""
Linear kernel correlation (dot product).
Parameters
----------
x : ``(channels, height, width)`` `ndarray`
Template image.
z : ``(channels, height, width)`` `ndarray`
Input image.
Returns
-------
xz: ``(1, height, width)`` `ndarray`
Linear kernel correlation between the image and the template.
"""
# cross correlation
xz = np.sum(fast2dconv(z, x[:, ::-1, ::-1], boundary=boundary), axis=0)
return xz[None]
