dlib C++ Library - cca_abstract.h

    // Copyright (C) 2013  Davis E. King (davis@dlib.net)
    // License: Boost Software License   See LICENSE.txt for the full license.
    #undef DLIB_CCA_AbSTRACT_Hh_
    #ifdef DLIB_CCA_AbSTRACT_Hh_

    #include "../matrix/matrix_la_abstract.h"
    #include "random_subset_selector_abstract.h"

    namespace dlib
    {

    // ----------------------------------------------------------------------------------------

        template <
            typename T
            >
        matrix<typename T::type,0,1> compute_correlations (
            const matrix_exp<T>& L,
            const matrix_exp<T>& R
        );
        /*!
            requires
                - L.size() > 0
                - R.size() > 0
                - L.nr() == R.nr()
            ensures
                - This function treats L and R as sequences of paired row vectors.  It
                  then computes the correlation values between the elements of these
                  row vectors.  In particular, we return a vector COR such that:
                    - COR.size() == L.nc()
                    - for all valid i:
                        - COR(i) == the correlation coefficient between the following sequence
                          of paired numbers: (L(k,i), R(k,i)) for k: 0 <= k < L.nr().
                          Therefore, COR(i) is a value between -1 and 1 inclusive where 1
                          indicates perfect correlation and -1 perfect anti-correlation.  Note
                          that this function assumes the input data vectors have been centered
                          (i.e. made to have zero mean).  If this is not the case then it will
                          report inaccurate results.
        !*/

    // ----------------------------------------------------------------------------------------

        template <
            typename T
            >
        matrix<T,0,1> cca (
            const matrix<T>& L,
            const matrix<T>& R,
            matrix<T>& Ltrans,
            matrix<T>& Rtrans,
            unsigned long num_correlations,
            unsigned long extra_rank = 5,
            unsigned long q = 2,
            double regularization = 0
        );
        /*!
            requires
                - num_correlations > 0
                - L.size() > 0
                - R.size() > 0
                - L.nr() == R.nr()
                - regularization >= 0
            ensures
                - This function performs a canonical correlation analysis between the row
                  vectors in L and R.  That is, it finds two transformation matrices, Ltrans
                  and Rtrans, such that row vectors in the transformed matrices L*Ltrans and
                  R*Rtrans are as correlated as possible.  That is, we try to find two transforms
                  such that the correlation values returned by compute_correlations(L*Ltrans, R*Rtrans)
                  would be maximized.
                - Let N == min(num_correlations, min(R.nr(),min(L.nc(),R.nc())))
                  (This is the actual number of elements in the transformed vectors.
                  Therefore, note that you can't get more outputs than there are rows or
                  columns in the input matrices.)
                - #Ltrans.nr() == L.nc()
                - #Ltrans.nc() == N
                - #Rtrans.nr() == R.nc()
                - #Rtrans.nc() == N
                - This function assumes the data vectors in L and R have already been centered
                  (i.e. we assume the vectors have zero means).  However, in many cases it is
                  fine to use uncentered data with cca().  But if it is important for your
                  problem then you should center your data before passing it to cca().
                - This function works with reduced rank approximations of the L and R matrices.
                  This makes it fast when working with large matrices.  In particular, we use
                  the svd_fast() routine to find reduced rank representations of the input
                  matrices by calling it as follows: svd_fast(L, U,D,V, num_correlations+extra_rank, q)
                  and similarly for R.  This means that you can use the extra_rank and q
                  arguments to cca() to influence the accuracy of the reduced rank
                  approximation.  However, the default values should work fine for most
                  problems.
                - returns an estimate of compute_correlations(L*#Ltrans, R*#Rtrans).  The
                  returned vector should exactly match the output of compute_correlations()
                  when the reduced rank approximation to L and R is accurate and regularization
                  is set to 0.  However, if this is not the case then the return value of this
                  function will deviate from compute_correlations(L*#Ltrans, R*#Rtrans).  This
                  deviation can be used to check if the reduced rank approximation is working
                  or you need to increase extra_rank.
                - The dimensions of the output vectors produced by L*#Ltrans or R*#Rtrans are
                  ordered such that the dimensions with the highest correlations come first.
                  That is, after applying the transforms produced by cca() to a set of vectors
                  you will find that dimension 0 has the highest correlation, then dimension 1
                  has the next highest, and so on.  This also means that the list of numbers
                  returned from cca() will always be listed in decreasing order.
                - This function performs the ridge regression version of Canonical Correlation
                  Analysis when regularization is set to a value > 0.  In particular, larger
                  values indicate the solution should be more heavily regularized.  This can be
                  useful when the dimensionality of the data is larger than the number of
                  samples.
                - A good discussion of CCA can be found in the paper "Canonical Correlation
                  Analysis" by David Weenink.  In particular, this function is implemented
                  using equations 29 and 30 from his paper.  We also use the idea of doing CCA
                  on a reduced rank approximation of L and R as suggested by Paramveer S.
                  Dhillon in his paper "Two Step CCA: A new spectral method for estimating
                  vector models of words".
        !*/

    // ----------------------------------------------------------------------------------------

        template <
            typename sparse_vector_type,
            typename T
            >
        matrix<T,0,1> cca (
            const std::vector<sparse_vector_type>& L,
            const std::vector<sparse_vector_type>& R,
            matrix<T>& Ltrans,
            matrix<T>& Rtrans,
            unsigned long num_correlations,
            unsigned long extra_rank = 5,
            unsigned long q = 2,
            double regularization = 0
        );
        /*!
            requires
                - num_correlations > 0
                - L.size() == R.size()
                - max_index_plus_one(L) > 0 && max_index_plus_one(R) > 0
                  (i.e. L and R can't represent empty matrices)
                - L and R must contain sparse vectors (see the top of dlib/svm/sparse_vector_abstract.h
                  for a definition of sparse vector)
                - regularization >= 0
            ensures
                - This is just an overload of the cca() function defined above.  Except in this
                  case we take a sparse representation of the input L and R matrices rather than
                  dense matrices.  Therefore, in this case, we interpret L and R as matrices
                  with L.size() rows, where each row is defined by a sparse vector.  So this
                  function does exactly the same thing as the above cca().
                - Note that you can apply the output transforms to a sparse vector with the
                  following code:
                    sparse_matrix_vector_multiply(trans(Ltrans), your_sparse_vector)
        !*/

    // ----------------------------------------------------------------------------------------

        template <
            typename sparse_vector_type,
            typename Rand_type,
            typename T
            >
        matrix<T,0,1> cca (
            const random_subset_selector<sparse_vector_type,Rand_type>& L,
            const random_subset_selector<sparse_vector_type,Rand_type>& R,
            matrix<T>& Ltrans,
            matrix<T>& Rtrans,
            unsigned long num_correlations,
            unsigned long extra_rank = 5,
            unsigned long q = 2,
            double regularization = 0
        );
        /*!
            requires
                - num_correlations > 0
                - L.size() == R.size()
                - max_index_plus_one(L) > 0 && max_index_plus_one(R) > 0
                  (i.e. L and R can't represent empty matrices)
                - L and R must contain sparse vectors (see the top of dlib/svm/sparse_vector_abstract.h
                  for a definition of sparse vector)
                - regularization >= 0
            ensures
                - returns cca(L.to_std_vector(), R.to_std_vector(), Ltrans, Rtrans, num_correlations, extra_rank, q)
                  (i.e. this is just a convenience function for calling the cca() routine when
                  your sparse vectors are contained inside a random_subset_selector rather than
                  a std::vector)
        !*/

    // ----------------------------------------------------------------------------------------

    }

    #endif // DLIB_CCA_AbSTRACT_Hh_