/** @file fisher.c ** @brief Fisher - Declaration ** @author David Novotny **/ /* Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson. All rights reserved. This file is part of the VLFeat library and is made available under the terms of the BSD license (see the COPYING file). */ /** @page fisher Fisher Vector encoding (FV) @author David Novotny @author Andrea Vedaldi @ref fisher.h implements the Fisher Vectors (FV) image representation @cite{perronnin06fisher} @cite{perronnin10improving}. A FV is a statistics capturing the distribution of a set of vectors, usually a set of local image descriptors. @ref fisher-starting demonstrates how to use the C API to compute the FV representation of an image. For further details refer to: - @subpage fisher-fundamentals - Fisher Vector definition. - @subpage fisher-derivation - Deriving the Fisher Vectors as a Fisher Kernel. - @subpage fisher-kernel - The Fisher Kernel in general. @section fisher-starting Getting started The Fisher Vector encoding of a set of features is obtained by using the function ::vl_fisher_encode. Note that the function requires a @ref gmm "Gaussian Mixture Model" (GMM) of the encoded feature distribution. In the following code, the result of the coding process is stored in the @c enc array and the improved fisher vector normalization is used. @code float * means ; float * covariances ; float * priors ; float * posteriors ; float * enc; // create a GMM object and cluster input data to get means, covariances // and priors of the estimated mixture gmm = vl_gmm_new (VL_TYPE_FLOAT) ; vl_gmm_cluster (gmm, data, dimension, numData, numClusters); // allocate space for the encoding enc = vl_malloc(sizeof(float) * 2 * dimension * numClusters); // run fisher encoding vl_fisher_encode (enc, VL_F_TYPE, vl_gmm_get_means(gmm), dimension, numClusters, vl_gmm_get_covariances(gmm), vl_gmm_get_priors(gmm), dataToEncode, numDataToEncode, VL_FISHER_FLAG_IMPROVED ) ; @endcode The performance of the standard Fisher Vector can be significantly improved @cite{perronnin10improving} by using appropriate @ref fisher-normalization normalizations. These are controlled by the @c flag parameter of ::vl_fisher_encode. @page fisher-fundamentals Fisher vector fundamentals @tableofcontents This page describes the *Fisher Vector* (FV) of @cite{perronnin06fisher} @cite{perronnin10improving}. See @ref fisher for an overview of the C API and @ref fisher-kernel for its relation to the more general notion of Fisher kernel. The FV is an image representation obtained by pooling local image features. It is frequently used as a global image descriptor in visual classification. While the FV can be @ref fisher-kernel "derived" as a special, approximate, and improved case of the general Fisher Kernel framework, it is easy to describe directly. Let $I = (\bx_1,\dots,\bx_N)$ be a set of $D$ dimensional feature vectors (e.g. SIFT descriptors) extracted from an image. Let $\Theta=(\mu_k,\Sigma_k,\pi_k:k=1,\dots,K)$ be the parameters of a @ref gmm "Gaussian Mixture Model" fitting the distribution of descriptors. The GMM associates each vector $\bx_i$ to a mode $k$ in the mixture with a strength given by the posterior probability: \[ q_{ik} = \frac {(\bx_i - \mu_k)^T \Sigma_k^{-1} (\bx_i - \mu_k)} {\sum_{t=1}^K (\bx_i - \mu_t)^T \Sigma_t^{-1} (\bx_i - \mu_t)}. \] For each mode $k$, consider the mean and covariance deviation vectors @f{align*} u_{jk} &= {1 \over {N \sqrt{\pi_k}}} \sum_{i=1}^{N} q_{ik} \frac{x_{ji} - \mu_{ik}}{\sigma_i}, \\ v_{jk} &= {1 \over {N \sqrt{2 \pi_k}}} \sum_{i=1}^{N} q_{ik} \left[ \left(\frac{x_{ji} - \mu_{ik}}{\sigma_j}\right)^2 - 1 \right]. @f} where $j=1,2,\dots,D$ spans the vector dimensions. The FV of image $I$ is the stacking of the vectors $\bu_k$ and then of the vectors $\bv_k$ for each of the $K$ modes in the Gaussian mixtures: \[ \Phi(I) = \begin{bmatrix} \vdots \\ \bu_k \\ \vdots \\ \bv_k \\ \vdots \end{bmatrix}. \] @section fisher-normalization Normalization and improved Fisher vectors The *improved* Fisher Vector @cite{perronnin10improving} (IFV) improves the classification performance of the representation by using to ideas: 1. *Non-linear additive kernel.* The Hellinger's kernel (or Bhattacharya coefficient) can be used instead of the linear one at no cost by signed squared rooting. This is obtained by applying the function $|z| \sign z$ to each dimension of the vector $\Phi(I)$. Other @ref homkermap "additive kernels" can also be used at an increased space or time cost. 2. *Normalization.* Before using the representation in a linear model (e.g. a @ref svm "support vector machine"), the vector $\Phi(I)$ is further normalized by the $l^2$ norm (note that the standard Fisher vector is normalized by the number of encoded feature vectors). After square-rooting and normalization, the IFV is often used in a linear classifier such as an @ref svm "SVM". @page fisher-derivation Fisher vector derivation The FV of @cite{perronnin06fisher} is a special case of the @ref fisher-kernel "Fisher kernel" construction. It is designed to encode local image features in a format that is suitable for learning and comparison with simple metrics such as the Euclidean. In this construction, an image is modeled as a collection of $D$-dimensional feature vectors $I=(\bx_1,\dots,\bx_n)$ generated by a GMM with $K$ components $\Theta=(\mu_k,\Sigma_k,\pi_k:k=1,\dots,K)$. The covariance matrices are assumed to be diagonal, i.e. $\Sigma_k = \diag \bsigma_k^2$, $\bsigma_k \in \real^D_+$. The generative model of *one* feature vector $\bx$ is given by the GMM density function: \[ p(\bx|\Theta) = \sum_{k=1}^K \pi_k p(\bx|\Theta_k), \quad p(\bx|\Theta_k) = \frac{1}{(2\pi)^\frac{D}{2} (\det \Sigma_k)^{\frac{1}{2}}} \exp \left[ -\frac{1}{2} (\bx - \mu_k)^\top \Sigma_k^{-1} (\bx - \mu_k) \right] \] where $\Theta_k = (\mu_k,\Sigma_k)$. The Fisher Vector requires computing the derivative of the log-likelihood function with respect to the various model parameters. Consider in particular the parameters $\Theta_k$ of a mode. Due to the exponent in the Gaussian density function, the derivative can be written as \[ \nabla_{\Theta_k} p(\bx|\Theta_k) = p(\bx|\Theta_k) g(\bx|\Theta_k) \] for a simple vector function $g$. The derivative of the log-likelihood function is then \[ \nabla_{\Theta_k} \log p(\bx|\Theta) = \frac{\pi_k p(\bx|\Theta_k)}{\sum_{t=1}^K \pi_k p(\bx|\Theta_k)} g(\bx|\Theta_k) = q_k(\bx) g(\bx|\Theta_k) \] where $q_k(\bx)$ is the soft-assignment of the point $\bx$ to the mode $k$. We make the approximation that $q_k(\bx)\approx 1$ if $\bx$ is sampled from mode $k$ and $\approx 0$ otherwise @cite{perronnin06fisher}. Hence one gets: \[ E_{\bx \sim p(\bx|\Theta)} [ \nabla_{\Theta_k} \log p(\bx|\Theta) \nabla_{\Theta_t} \log p(\bx|\Theta)^\top ] \approx \begin{cases} \pi_k E_{\bx \sim p(\bx|\Theta_k)} [ g(\bx|\Theta_k) g(\bx|\Theta_k)^\top], & t = k, \\ 0, & t\not=k. \end{cases} \] Thus under this approximation there is no correlation between the parameters of the various Gaussian modes. The function $g$ can be further broken down as the stacking of the derivative w.r.t. the mean and the diagonal covariance. \[ g(\bx|\Theta_k) = \begin{bmatrix} g(\bx|\mu_k) \\ g(\bx|\bsigma_k) \end{bmatrix}, \quad [g(\bx|\mu_k)]_j = \frac{x_j - \mu_{jk}}{\sigma_{jk}^2}, \quad [g(\bx|\bsigma_k^2)]_j = \frac{1}{2\sigma_{jk}^2} \left( \left(\frac{x_j - \mu_{jk}}{\sigma_{jk}}\right)^2 - 1 \right) \] Thus the covariance of the model (Fisher information) is diagonal and the diagonal entries are given by \[ H_{\mu_{jk}} = \pi_k E[g(\bx|\mu_{jk})g(\bx|\mu_{jk})] = \frac{\pi_k}{\sigma_{jk}^2}, \quad H_{\sigma_{jk}^2} = \frac{\pi_k}{2 \sigma_{jk}^4}. \] where in the calculation it was used the fact that the fourth moment of the standard Gaussian distribution is 3. Multiplying the inverse square root of the matrix $H$ by the derivative of the log-likelihood function results in the Fisher vector encoding of one image feature $\bx$: \[ \Phi_{\mu_{jk}}(\bx) = H_{\mu_{jk}}^{-\frac{1}{2}} q_k(\bx) g(\bx|\mu_{jk}) = q_k(\bx) \frac{x_j - \mu_{jk}}{\sqrt{\pi_k}\sigma_{jk}}, \qquad \Phi_{\sigma^2_{jk}}(\bx) = \frac{q_k(\bx)}{\sqrt{2 \pi_k}} \left( \left(\frac{x_j - \mu_{jk}}{\sigma_{jk}}\right)^2 - 1 \right) \] Assuming that features are sampled i.i.d. from the GMM results in the formulas given in @ref fisher-fundamentals (note the normalization factor). Note that: * The Fisher components relative to the prior probabilities $\pi_k$ have been ignored. This is because they have little effect on the representation @cite{perronnin10improving}. * Technically, the derivation of the Fisher Vector for multiple image features requires the number of features to be the same in both images. Ultimately, however, the representation can be computed by using any number of features. @page fisher-kernel Fisher kernel This page discusses the Fisher Kernels (FK) of @cite{jaakkola98exploiting} and shows how the FV of @cite{perronnin06fisher} can be derived from it as a special case. The FK induces a similarity measures between data points $\bx$ and $\bx'$ from a parametric generative model $p(\bx|\Theta)$ of the data. The parameter $\Theta$ of the model is selected to fit the a-priori distribution of the data, and is usually the Maximum Likelihood (MLE) estimate obtained from a set of training examples. Once the generative model is learned, each particular datum $\bx$ is represented by looking at how it affects the MLE parameter estimate. This effect is measured by computing the gradient of the log-likelihood term corresponding to $\bx$: \[ \hat\Phi(\bx) = \nabla_\Theta \log p(\bx|\Theta) \] The vectors $\hat\Phi(\bx)$ should be appropriately scaled before they can be meaningfully compared. This is obtained by *whitening* the data by multiplying the vectors by the inverse of the square root of their *covariance matrix*. The covariance matrix can be obtained from the generative model $p(\bx|\Theta)$ itself. Since $\Theta$ is the ML parameter and $\hat\Phi(\bx)$ is the gradient of the log-likelihood function, its expected value $E[\hat\Phi(\bx)]$ is zero. Thus, since the vectors are already centered, their covariance matrix is simply: \[ H = E_{\bx \sim p(\bx|\Theta)} [\hat\Phi(\bx) \hat\Phi(\bx)^\top] \] Note that $H$ is also the *Fisher information matrix* of the model. The final FV encoding $\Phi(\bx)$ is given by the whitened gradient of the log-likelihood function, i.e.: \[ \Phi(\bx) = H^{-\frac{1}{2}} \nabla_\Theta \log p(\bx|\Theta). \] Taking the inner product of two such vectors yields the *Fisher kernel*: \[ K(\bx,\bx') = \langle \Phi(\bx),\Phi(\bx') \rangle = \nabla_\Theta \log p(\bx|\Theta)^\top H^{-1} \nabla_\Theta \log p(\bx'|\Theta). \] **/ #include "fisher.h" #include "gmm.h" #include "mathop.h" #include #include #include #ifndef VL_FISHER_INSTANTIATING #endif #ifdef VL_FISHER_INSTANTIATING static void VL_XCAT(_vl_fisher_encode_, SFX) (TYPE * enc, TYPE const * means, vl_size dimension, vl_size numClusters, TYPE const * covariances, TYPE const * priors, TYPE const * data, vl_size numData, int flags) { vl_size dim; vl_index i_cl, i_d; TYPE * posteriors ; TYPE * sqrtInvSigma; posteriors = vl_malloc(sizeof(TYPE) * numClusters * numData); sqrtInvSigma = vl_malloc(sizeof(TYPE) * dimension * numClusters); memset(enc, 0, sizeof(TYPE) * 2 * dimension * numClusters) ; for (i_cl = 0 ; i_cl < (signed)numClusters ; ++i_cl) { for(dim = 0; dim < dimension; dim++) { sqrtInvSigma[i_cl*dimension + dim] = sqrt(1.0 / covariances[i_cl*dimension + dim]); } } VL_XCAT(vl_get_gmm_data_posteriors_, SFX)(posteriors, numClusters, numData, priors, means, dimension, covariances, data) ; #if defined(_OPENMP) #pragma omp parallel for default(shared) private(i_cl, i_d, dim) num_threads(vl_get_max_threads()) #endif for(i_cl = 0; i_cl < (signed)numClusters; ++ i_cl) { TYPE uprefix; TYPE vprefix; TYPE * uk = enc + i_cl*dimension ; TYPE * vk = enc + i_cl*dimension + numClusters * dimension ; if (priors[i_cl] < 1e-6) { continue ; } for(i_d = 0; i_d < (signed)numData; i_d++) { TYPE p = posteriors[i_cl + i_d * numClusters] ; if (p == 0) continue ; for(dim = 0; dim < dimension; dim++) { TYPE diff = data[i_d*dimension + dim] - means[i_cl*dimension + dim] ; diff *= sqrtInvSigma[i_cl*dimension + dim] ; *(uk + dim) += p * diff ; *(vk + dim) += p * (diff * diff - 1); } } uprefix = 1/(numData*sqrt(priors[i_cl])); vprefix = 1/(numData*sqrt(2*priors[i_cl])); for(dim = 0; dim < dimension; dim++) { *(uk + dim) = *(uk + dim) * uprefix; *(vk + dim) = *(vk + dim) * vprefix; } } vl_free(posteriors); vl_free(sqrtInvSigma) ; if (flags & VL_FISHER_FLAG_SQUARE_ROOT) { for(dim = 0; dim < 2 * dimension * numClusters ; dim++) { TYPE z = enc [dim] ; if (z >= 0) { enc[dim] = VL_XCAT(vl_sqrt_, SFX)(z) ; } else { enc[dim] = - VL_XCAT(vl_sqrt_, SFX)(- z) ; } } } if (flags & VL_FISHER_FLAG_NORMALIZED) { TYPE n = 0 ; for(dim = 0 ; dim < 2 * dimension * numClusters ; dim++) { TYPE z = enc [dim] ; n += z * z ; } n = VL_XCAT(vl_sqrt_, SFX)(n) ; n = VL_MAX(n, 1e-12) ; for(dim = 0 ; dim < 2 * dimension * numClusters ; dim++) { enc[dim] /= n ; } } } /* VL_FISHER_INSTANTIATING */ #else #ifndef __DOXYGEN__ #define FLT VL_TYPE_FLOAT #define TYPE float #define SFX f #define VL_FISHER_INSTANTIATING #include "fisher.c" #define FLT VL_TYPE_DOUBLE #define TYPE double #define SFX d #define VL_FISHER_INSTANTIATING #include "fisher.c" #endif #endif /* ================================================================ */ #ifndef VL_FISHER_INSTANTIATING /** @brief Fisher vector encoding of a set of vectors. ** @param dataType the type of the input data (::VL_TYPE_DOUBLE or ::VL_TYPE_FLOAT). ** @param enc Fisher vector (output). ** @param means Gaussian mixture means. ** @param dimension dimension of the data. ** @param numClusters number of Gaussians mixture components. ** @param covariances Gaussian mixture diagonal covariances. ** @param priors Gaussian mixture prior probabilities. ** @param data vectors to encode. ** @param numData number of vectors to encode. ** @param flags options. ** ** @a means and @a covariances have @a dimension rows and @a numCluster columns. ** @a priors is a vector of size @a numCluster. @a data has @a dimension ** rows and @a numData columns. @a enc is a vecotr of size equal ** to twice the product of @a dimension and @a numClusters. ** All these vectors and matrices have the same class, as specified ** by @a dataType. ** ** @a flag can be used to control several options: ** ::VL_FISHER_FLAG_SQUARE_ROOT, ::VL_FISHER_FLAG_NORMALIZED, ** ::VL_FISHER_FLAG_IMPROVED. ** ** @sa @ref fisher **/ VL_EXPORT void vl_fisher_encode (void * enc, vl_type dataType, void const * means, vl_size dimension, vl_size numClusters, void const * covariances, void const * priors, void const * data, vl_size numData, int flags ) { switch(dataType) { case VL_TYPE_FLOAT: _vl_fisher_encode_f ((float *) enc, (float const *) means, dimension, numClusters, (float const *) covariances, (float const *) priors, (float const *) data, numData, flags); break; case VL_TYPE_DOUBLE: _vl_fisher_encode_d ((double *) enc, (double const *) means, dimension, numClusters, (double const *) covariances, (double const *) priors, (double const *) data, numData, flags); break; default: abort(); } } #endif #undef SFX #undef TYPE #undef FLT #undef VL_FISHER_INSTANTIATING