Difference between revisions of "stat841f14"

From statwiki
Jump to: navigation, search
(Introduciton =)
Line 1,429: Line 1,429:
==== Introduciton ====
==== Introduciton ====
==== Motivation =====
==== Motivation ====
==== Some ways to minimize objective function ====
==== Some ways to minimize objective function ====
==== Some versions of constraint ====
==== Some versions of constraint ====

Revision as of 19:27, 22 October 2014


Editor Sign Up

Principal components analysis (Lecture 1: Sept. 10, 2014)


Principal Component Analysis (PCA), first invented by Karl Pearson in 1901, is a statistical technique for data analysis. Its main purpose is to reduce the dimensionality of the data.

Suppose there is a set of data points in a d-dimensional space. The goal of PCA is to find a linear subspace with lower dimensionality p (p [math]\leq[/math] d), such that maximum variance is retained in this lower-dimensional space. The linear subspace can be specified by d orthogonal vectors, such as [math] u_1 , u_2 , ... , u_d[/math] which form a new coordinate system, called 'principle components'. In other words, PCA aims to reduce the dimensionality of the data, while preserving its information (or minimizing the loss of information). Information comes from variation. In other words, the more variation captured in the lower dimension, the more information preserved. For example, if all data points have the same value along one dimension, then that dimension does not carry any information. So, to preserve information, the subspace need to contain components (or dimensions) along which, data has most of its variability. However, finding a linear subspace with lower dimensionality which include all data points is not possible in practical problems and loss of information is inevitable. Through PCA, we try to reduce this loss and capture most of the features of data.

Figure below, demonstrates an example of PCA. Data is transformed from original 3D space to 2D coordinate system where each coordinate is a principal component.

Now, consider the ability of two of the above examples' components (PC1 and PC2) to retain information from the original data. The data in the original space is projected onto each of these two components separately in the below figure. Notice that PC1 is better able to capture the variation in the original data than PC2 alone. If reducing the original d=3 dimensional data to p=1 dimension, PC1 is therefore preferable to PC2.

Comparison of two different components used for dimensionality reduction

PCA Plot example

For example<ref> https://onlinecourses.science.psu.edu/stat857/sites/onlinecourses.science.psu.edu.stat857/files/lesson05/PCA_plot.gif </ref>, in the top left corner of the image below, the point [math] x_1 [/math] showed in two-dimensional and it's coordinates are [math](x_i, 1)[/math] and [math](x_i, 2) [/math]

All the red points in the plot represented by their projected values on the two original coordinators (Feature 1, Feature 2).

In PCA technique, it uses new coordinators (showed in green). As coordinate system changed, the points also are shown by their new pair of coordinate values for example [math](z_i, 1)[/math] and [math](z_i, 2)[/math]. These values are determined by original vector, and the relation between the rotated coordinates and the original ones.

PCA Plot.gif

In the original coordinates the two vectors [math]x_1[/math] and [math]x_2[/math] are not linearly uncorrelated. In other words, after applying PCA, if there are two principal component, and use those as the new coordinates, then it is guaranteed that the data along the two coordinates have correlation = 0

By rotating the coordinates we performed an orthonormal transform on the data. After the transform, the correlation is removed - which is the whole point of PCA.

As an example of an extreme case where all of the points lie on a straight line, which in the original coordinates system it is needed two coordinates to describe these points.

In short, after rotating the coordinates, we need only one coordinate and clearly the value on the other one is always zero. This example shows PCA's dimension reduction in an extreme case while in real world points may not fit exactly on a line, but only approximately.

PCA applications

As mentioned, PCA is a method to reduce data dimension if possible to principal components such that those PCs cover as much data variation as possible. This technique is useful in different type of applications which involve data with a huge dimension like data pre-processing, neuroscience, computer graphics, meteorology, oceanography, gene expression, economics, and finance among of all other applications.

Data usually is represented by lots of variables. In data preprocessing, PCA is a technique to select a subset of variables in order to figure our best model for data. In neuroscience, PCA used to identify the specific properties of a stimulus that increase a neuron’s probability of generating an action potential.

Figures below show some example of PCA in real world applications. Click to enlarge.

Mathematical details

PCA is a transformation from original space to a linear subspace with a new coordinate system. Each coordinate of this subspace is called a Principle Component. First principal component is the coordinate of this system along which the data points has the maximum variation. That is, if we project the data points along this coordinate, maximum variance of data is obtained (compared to any other vector in original space). Second principal component is the coordinate in the direction of the second greatest variance of the data, and so on.

Lets denote the basis of original space by [math] \mathbf{v_1}[/math], [math]\mathbf{v_2}[/math], ... , [math]\mathbf{v_d}[/math]. Our goal is to find the principal components (coordinate of the linear subspace), denoted by [math]\mathbf{u_1}[/math], [math]\mathbf{u_2}[/math], ... , [math]\mathbf{u_p}[/math] in the hope that [math] p \leq d [/math]. First, we would like to obtain the first principal component [math]\mathbf{u_1}[/math] or the components in the direction of maximum variance. This component can be treated as a vector in the original space and so is written as a linear combination of the basis in original space.

[math]\mathbf{u_1}=w_1\mathbf{v_1}+w_2\mathbf{v_2}+...+w_d\mathbf{v_d} [/math]

Vector [math] \mathbf{w} [/math] contains the weight of each basis in this combination.

[math]\mathbf{w}=\begin{bmatrix} w_1\\w_2\\w_3\\...\\w_d \end{bmatrix}[/math]

Suppose we have n data points in the original space. We represent each data points by [math] \mathbf{x_1}[/math], [math] \mathbf{x_2} [/math], ..., [math] \mathbf{x_n} [/math]. Projection of each point [math] \mathbf{x_i} [/math] on the [math] \mathbf{u_1} [/math] is [math] \mathbf{w}^T\mathbf{x_i} [/math].

Let [math] \mathbf{S} [/math] be the sample covariance matrix of data points in original space. The variance of the projected data points, denoted by [math] \Phi [/math] is

[math] \Phi = Var(\mathbf{w}^T \mathbf{x_i}) = \mathbf{w}^T \mathbf{S} \mathbf{w} [/math]

we would like to maximize [math] \Phi [/math] over set of all vectors [math] \mathbf{w} [/math] in original space. But, this problem is not yet well-defined, because for any choice of [math] \mathbf{w} [/math], we can increase [math] \Phi [/math] by simply multiplying [math] \mathbf{w} [/math] in a positive scalar greater than one. So, we add the following constraint to the problem to bound the length of vector [math] \mathbf{w} [/math]:

[math] max \Phi = \mathbf{w}^T \mathbf{S} \mathbf{w} [/math]

subject to : [math]\mathbf{w}^T \mathbf{w} =1 [/math]

Using Lagrange Multiplier technique we have:

[math] L(\mathbf{w} , \lambda ) = \mathbf{w}^T \mathbf{S} \mathbf{w} - \lambda (\mathbf{w}^T \mathbf{w} - 1 ) [/math]

By taking derivative of [math] L [/math] w.r.t. primary variable [math] \mathbf{w} [/math] we have:

[math]\frac{\partial L}{\partial \mathbf{w}}=( \mathbf{S}^T + \mathbf{S})\mathbf{w} -2\lambda\mathbf{w}= 2\mathbf{S}\mathbf{w} -2\lambda\mathbf{w}= 0 [/math]

Note that [math] \mathbf{S}[/math] is symmetric so [math] \mathbf{S}^T = \mathbf{S} [/math].

From the above equation we have:

[math] \mathbf{S} \mathbf{w} = \lambda\mathbf{w} [/math].

So [math] \mathbf{w} [/math] is the eigenvector and [math] \lambda [/math] is the eigenvalue of the matrix [math] \mathbf{S} [/math] .(Taking derivative of [math] L [/math] w.r.t. [math] \lambda [/math] just regenerate the constraint of the optimization problem.)

By multiplying both sides of the above equation to [math]\mathbf{w}^T[/math] and considering the constraint, we obtain:

[math] \Phi = \mathbf{w}^T \mathbf{S} \mathbf{w} = \mathbf{w}^T \lambda \mathbf{w} = \lambda \mathbf{w}^T \mathbf{w} = \lambda [/math]

The interesting result is that objective function is equal to eigenvalue of the covariance matrix. So, to obtain the first principle component, which maximizes the objective function, we just need the eigenvector corresponding to the largest eigenvalue of [math] \mathbf{S} [/math]. Subsequently, the second principal component is the eigenvector corresponding to the second largest eigenvalue, and so on.

Principal component extraction using singular value decomposition

Singular Value Decomposition (SVD), is a well-known way to decompose any kind of matrix [math] \mathbf{A} [/math] (m by n) into three useful matrices.

[math] \mathbf{A} = \mathbf{U}\mathbf{\Sigma}\mathbf{V}^T [/math].

where [math] \mathbf{U}[/math] is m by m unitary matrix, [math] \mathbf{UU^T} = I_m [/math], each column of [math] \mathbf{U}[/math] is an eigenvector of [math] \mathbf{AA^T} [/math]

[math] \mathbf{\Sigma}[/math] is m by n diagonal matrix, non-zero elements of this matrix are square roots of eigenvalues of [math] \mathbf{AA^T} [/math].

[math] \mathbf{V}[/math] is n by n unitary matrix, [math] \mathbf{VV^T} = I_n [/math], each column of [math]\mathbf{V}[/math] is an eigenvector of [math] \mathbf{A^TA} [/math]

Now, comparing the concepts of PCA and SVD, one may find out that we can perform PCA using SVD.

Let's construct a matrix p by n with our n data points such that each column of this matrix represent one data point in p-dimensional space:

[math] \mathbf{X} = [\mathbf{x_1} \mathbf{x_2} .... \mathbf{x_n} ] [/math]

and make another matrix [math] \mathbf{X}^* [/math] simply by subtracting the mean of data points from [math] \mathbf{X} [/math].

[math] \mathbf{X}^* = \mathbf{X} - \mu_X [/math]

Then we will get a zero-mean version of our data points for which [math] \mathbf{X^*} \mathbf{X^{*^T}} [/math] is the covariance matrix.

So, [math] \mathbf{\Sigma}[/math] and [math] \mathbf{U}[/math] give us the eigenvalues and corresponding eigenvectors of covariance matrix, respectively. We can then easily extract the desired principal components.

MATLAB example

In this example we use different pictures of a man's face with different facial expressions. But, these pictures are noisy. So the face is not easily recognizable. The data set consists of 1965 pictures each 20 by 28. So dimensionality is 20*28= 560.

Our goal is to remove noise using PCA and of course by means of SVD function in matlab. We know that noise is not the main feature that makes these pictures look different, so noise is among least variance components. We first extract the principal components and then remove those which correspond to the least values of eigenvalues of covariance matrix. Here, eigenvalues are sorted in a descending order from column to column of matrix S. For example, the first column of matrix U, which corresponds to the first element in S, is the first principal component.

We then reconstruct the picture using first d principal components. If d is too large, we can not completely remove the noise. If it is too small, we will lose some information from the original data. For example we may lose the facial expression (smile, sadness and etc.). We can change d until we achieve a reasonable balance between noise reduction and information loss.

Noise reduced version of a picture in MATLAB example
 >> % loading the noisy data, file "noisy" stores our variable X which contains the pictures 
 >> load noisy;
 >> % show a sample image in column 1 of matrix X
 >> imagesc(reshape(X(:,1),20,28)')
 >> % set the color of image to grayscale
 >> colormap gray
 >> % perform SVD, if X matrix if full rank, will obtain 560 PCs
 >> [U S V] = svd(X);
 >> d= 10;
 >> % reconstruct X using only the first d principal components and removing noise
 >> XX = U(:, 1:d)* S(1:d,1:d)*V(:,1:d)' ;
 >> % show image in column 1 of XX which is a noise reduced version
 >> imagesc(reshape(XX(:,1),20,28)')

PCA continued, Lagrange multipliers, singular value decomposition (SVD) (Lecture 2: Sept. 15, 2014)

Principal component analysis (continued)

PCA is a method to reduce dimensions in data or to extract features from data.

Given a data point in vector form x the goal of PCA is to map x to y where x [math]\isin[/math] [math]\real[/math]d and y [math]\isin[/math] [math]\real[/math]p such that p is much less than d. For example we could map a two-dimensional data point onto any one-dimensional vector in the original 2D space or we could map a three-dimensional data point onto any 2D plane in the original 3D space.

The transformation from [math]d[/math]-dimensional space to [math]p[/math] dimensional space is chosen in such a way that maximum variance is retained in the lower dimensional subspace. This is useful because variance represents the main differences between the data points, which is exactly what we are trying to capture when we perform data visualization. For example, when taking 64-dimensional images of hand-written digits, projecting them onto 2-dimensional space using PCA captures a significant amount of the structure we care about.

In terms of data visualization, it is fairly clear why PCA is important. High dimensional data is sometimes impossible to visualize. Even a 3D space can be fairly difficult to visualize, while a 2D space, which can be printed on a piece of paper, is much easier to visualize. If a higher dimensional dataset can be reduced to only 2 dimensions, it can be easily represented by plots and graphs.

In the case of many data points xi in d-dimensional space:

Xdxn = [x1 x2 ... xn]

There is an infinite amount of vectors in [math]\real[/math]p to which the points in X can be mapped. When mapping these data points to lower dimensions information will be lost. To preserve as much information as possible the points are mapped to a vector in [math]\real[/math]p which will preserve as much variation in the data as possible. In other words, the data is mapped to the vector in [math]\real[/math]p that will have maximum variance. In the images below, the data points mapped onto u in Mapping 1 have greater variance than in Mapping 2, and thus preserves more information in the data.

The projection of a single data point x on u is uTx (a scalar).

To project n data points onto u compute Y = uTX.

The variance of Y = uTX can be calculated easily as Y is a 1 by n vector.

In higher dimensional space [math]\real[/math]q where q > 1 the concept is Covariance.

The variance of projected points in the direction of vector u is given by:

Var(uTX) = uTSu where S is the sample covariance matrix of X.

In finding the first principal component the objective is to find the direction u which will have the greatest variance of the points projected onto it. This can be expressed as the following optimization problem:

maxu uTSu
s.t. uTu = 1

The restriction uTu = 1 is to bound the problem. If the length of u were not restricted, uTSu would go to infinity as the magnitude of u goes to infinity. The selection of 1 as the bound is arbitrary.

Lagrange multipliers

The Lagrange multiplier is a method for solving optimization problems. After constraining the principal component analysis output vector to an arbitrary size the task of maximizing variance in lower dimensional spaces becomes an optimization problem.

Lagrange multipler theorem

The method of Lagrange multipliers states that given the optimization problem:

   [math]max\ f(x,y)[/math] 
      [math]s.t.\ g(x,y) = c [/math]

The Lagrangian is defined by:

[math]\ L(x,y,\lambda)= f(x,y) - \lambda(g(x,y)-c)[/math]

Which implies, where [math] \bigtriangledown\ [/math] is the gradient, that:

[math] \bigtriangledown\ f(x,y) = \lambda \bigtriangledown g(x,y) [/math]

[math] \bigtriangledown\ f(x,y) - \lambda \bigtriangledown g(x,y) = 0 [/math]

In practice,

[math] \bigtriangledown\ L [/math] is calculated by computing the three partial derivatives of [math]\ L[/math] with respect to [math] \ x, y, \lambda [/math], setting them to 0, and solving the resulting system of equations.

That is to say, the solution is given by taking the solution of:

[math] \ \bigtriangledown L = \begin{bmatrix} \frac{\partial L}{\partial x}\\\frac{\partial L}{\partial y}\\\frac{\partial L}{\partial \lambda}\end{bmatrix}= 0 [/math]

which maximize the objective function f(x,y).

Intuitive explanation

The Lagrange multiplier utilizes gradients to find maximum values subject to constraints. A gradient [math] \bigtriangledown [/math] is a vector which collects all of the partial derivatives of a function. Intuitively, this can be thought of as a vector which contains the slopes of all of a graph's tangent lines, or the direction which each point on the graph points.

Finding a point where the gradient of f(x,y) and g(x,y) differ by a factor lambda: [math]\bigtriangledown f(x,y) = \lambda \bigtriangledown g(x,y)[/math] defines a point where our restraint and objective functions are both pointing in the same direction. This is important because if our objective function is pointing in a higher direction than g, increasing our objective function will increase our output, meaning we are not at a maximum. If the restraint is pointing in a higher direction than f, then reducing our input value will yield a higher output. The factor lambda is important because it is adjusted to ensure that the constraint is satisfied and maximized at our current location.

Lagrange multiplier example

Consider the function [math]f(x,y) = x - y[/math] such that [math]g(x,y) = x^2 + y^2 = 1[/math]. We would like to maximize this objective function.

Calculating the Lagrangian gives

[math]\text{L}(x,y,\lambda) = x - y - \lambda g(x,y) = x - y - \lambda (x^2 + y^2 - 1)[/math]

This gives three partial derivatives:

[math]\frac{\partial L}{\partial x} = 1 - 2\lambda x = 0, \frac{\partial L}{\partial y} = -1 - 2\lambda y = 0, \frac{\partial L}{\partial \lambda} = x^2 + y - 1 = 0[/math]

This gives two solutions:

  1. [math] x = \frac{\sqrt{2}}{2}, y = \frac{-\sqrt{2}}{2}, \lambda = \frac{1}{\sqrt{2}}[/math]
  2. [math] x = \frac{-\sqrt{2}}{2}, y = \frac{\sqrt{2}}{2}, \lambda = \frac{1}{\sqrt{2}}[/math]

Both solutions give extreme values of our objective function. Because this is an optimization problem we are interested in the solution which gives the maximum output, which is solution 1.

Singular value decomposition revisited

Any matrix X can be decomposed to the three matrices: [math] \ U \Sigma V^T[/math] where:

[math] \ U [/math] is an m x m matrix of the eigenvector XXT

[math] \ \Sigma [/math] is an m x n matrix containing singular values along the diagonal and zeroes elsewhere

[math] \ V^T [/math] is an orthogonal transpose of a n x n matrix of the eigenvector XTX

Connection of Singular Value Decomposition to PCA

If X is centered (has a mean of 0) then XXT is the covariance matrix.

Using the SVD of X we get:

[math] \ XX^T = (U \Sigma V^T)(U \Sigma V^T)^T[/math]

[math] \ XX^T = (U \Sigma V^T)(V \Sigma U^T)[/math]

[math] \ XX^T = U \Sigma V^T V \Sigma U^T[/math]

[math] \ XX^T = U \Sigma I \Sigma U^T[/math] (By the definition of V)

[math] \ XX^T = U \Sigma^2 U^T[/math]

It is important to remember that U and V are unitary matricies, i.e.: [math] U^TU=UU^T=I[/math] and [math]V^TV=VV^T=I[/math], each equality using the appropriate dimensional identity matrix.. It is also interesting that the nonsquare matrix formed by taking a subset of the eigenvectors contained in [math]U[/math] or [math]V[/math] has the property that [math]V^TV=I[/math] (the appropriate lower dimensional identity matrix)

Matlab example of dimensionality reduction using PCA

The following example shows how principal component analysis can be used to identify between a handwritten 2 and a handwritten 3. In the example the original images are each 64 pixels and thus 64 dimensional. By reducing the dimensionality to 2D the 2's and 3's are visualized on a 2D plot and can it could be estimated as to which digit one was.

 >> % load file containing 200 handwritten 2's and 200 handwritten 3's
 >> load 2_3;
 >> who?
 >> % displays that X is 64x400 matrix containing the handwritten digits
 >> imagesc(reshape(X(:,1),8,8)')
 >> colormap gray
 >> % displays first image, a handwritten 2
 >> M = mean(X,2)*ones(1,400);
 >> Xb = X-M
 >> % M is the matrix of the mean of column vectors repeated 400 times
 >> % Xb is data centred about mean
 >> % Now use SVD to find eigenvectors, eigenvalues of Xb
 >> [U S V] = svd(Xb);
 >> % 2D projection on points
 >> Y = U(:,1:2)'*X;
 >> % 2D projections of 2's
 >> plot(Y(1,1:200),Y(2,1:200),'.')
 >> % 2D projections of 3's
 >> plot(Y(1,201:400),Y(2,201:400),'.') 

PCA Algorithm, Dual PCA, and Kernel PCA (Lecture 3: Sept. 17, 2014)

PCA Algorithm (Algorithm 1)

Recover basis

To find the basis for PCA we first center the data by removing the mean of the sample, then calculate the covariance:

[math]XX^T = \sum_{i=1}^n x_i x_i^T [/math]

Let [math]U[/math] be the eigenvectors of [math]XX^T[/math] corresponding to the top [math]\,d[/math] eigenvalues.

Encode training data

To encode our data using PCA we let

[math]\,Y = U^TX[/math]

where [math]Y[/math] is an encoded matrix of the original data

Reconstruct training data

To project our data back to the higher dimension

[math]\hat{X} = UY = UU^T X [/math]

Encode test example

[math]\,y = U^T x[/math]

where [math]\,y[/math] is an encoding of [math]\,x[/math]

Reconstruct test example

[math]\hat{x} = Uy = UU^T x[/math]

Dual principal component analysis


In some cases the dimension of our data can be much larger than the number of data points [math]( d \gt \gt n )[/math]. For example, suppose we are interested in weekly closing rates of the Dow Jones Industrial Average, S&P 500 Index, and the NASDAQ Composite Index over the past forty years. In this example we only have three data points [math]( n = 3 )[/math], but our dimension is over two thousand! [math]( d \approx 2080 )[/math] Consequently, the matrix [math] XX^T[/math] used to find the basis [math]U[/math] is [math]2080\times2080[/math], which is computationally heavy to calculate. As another example is studying genes for patients since the number of genes studied is likely much larger than the number of patients. When the data's dimensionality is high, a less compute-intensive way of recovering the basis is desirable.

Recall from Lecture 2 how we used singular value decomposition for PCA:

[math]\,X = U \Sigma V^T [/math]

Multiply both sides by V to get:

[math]\,X V = U \Sigma V^T V [/math]

Since [math] V^T V = I [/math] (the identity matrix) the SVD can be rearranged as

[math]\,X V = U \Sigma [/math]

Then, multiply both sides by [math] \Sigma [/math]-1 to get:

[math]\,U = X V \Sigma[/math]-1

And so [math]U[/math] can be calculated in terms of [math]V[/math] and [math]\Sigma[/math]. [math]V[/math] is the eigenvectors of [math]X^T X_{n \times n}[/math], so it is much easier to find than [math]U[/math] because [math]n\lt \lt d[/math].


We can replace all instances of [math]\,U[/math] in Algorithm 1 with the dual form, [math]\,U = X V \Sigma^{-1} [/math], to obtain the algorithm for Dual PCA.

Recover Basis:
For the basis of Dual PCA, we calculate


then let [math]V[/math] be the eigenvectors of [math]XX^T[/math] with respect to the top [math]d[/math] eigenvalues. Finally we let [math]\Sigma[/math] be the diagonal matrix of square roots of the top [math]d[/math] eigenvalues.

Encode Training Data:
Using Dual PCA to encode the data, let

[math]\,Y = U^TX = \Sigma V^T[/math]

where [math]Y[/math] is an encoded matrix of the original data

Reconstruct Training Data:
Project the data back to the higher dimension by

[math]\hat{X} = UY = U \Sigma V^T = X V \Sigma^{-1} \Sigma V^T = X V V^T[/math]

Encode Test Example:

[math]\,y = U^T x = \Sigma^{-1} V^T X^T x = \Sigma^{-1} V^T X^T x[/math]

where [math]\,y[/math] is an encoding of [math]\,x[/math]

Reconstruct Test Example:

[math]\hat{x} = Uy = UU^T x = X V \Sigma^{-2} V^T X^T x = X V \Sigma^{-2} V^T X^T x[/math]

Note that the steps of Reconstructing training data and Reconstructioning test example still depend on [math]d[/math], and therefore still will be impractical in the case that the original dimensionality of the data ([math]d[/math]) is very large

Kernel principle component analysis

Kernel methods

Kernel methods are a class of algorithms used for analyzing patterns and measuring similarity. They are used for finding relations within a data set. Kernel methods map data into a higher-dimensional space to make it easier to find these relations. While PCA is designed for linear variabilities, a lot of higher-dimensional data are nonlinear. This is where Kernel PCA can be useful to help model the data variability when it comes to a nonlinear manifold. Generally speaking, Kernels is a measure of "similarity" between data points without explicitly performing the dot product between data points pairs. This can be done using different methods. For example, the dot product looks at whether vectors are orthogonal. The Gaussian kernel looks at whether two objects are similar on a scale of 0 to 1. Kernels also measure similarity between trees. We will not go in too much detail at the moment.

Some common examples of kernels include:

  1. Linear kernel:
    [math]\, k_{ij} = \lt x_{i},x_{j}\gt [/math]
  2. Polynomial kernel:
    [math]\, k_{ij} = (1+\lt x_{i},x_{j}\gt )^P[/math]
  3. Gaussian kernel:
    [math]\, k_{ij} = exp(||x_{i}-x_{j}||^2/2\sigma^2)[/math]

Other kernel examples can be found here:

Kernel PCA

With the Kernel PCA, we take the original or observed space and map it to the feature space and then map the feature space to the embedded space of a lower dimension.

[math] X_{observed space} \rightarrow \Eta_{feature space} \rightarrow Y_{embedded space} [/math]

In the Kernel PCA algorithm, we can use the same argument as PCA and again use the Singular Value Decomposition (SVD) where:

[math]\, \Phi(X) = U \Sigma V^T [/math]

where [math] U [/math] contains the eigenvectors of [math] \Phi(X)\Phi(X)^T [/math]

The algorithm is similar to the Dual PCA algorithm except that the training and the test data cannot be reconstructed since [math]\Phi(X)[/math] is unknown.


Recover Basis:
For the basis of Kernel PCA, we calculate

[math]\, K = \Phi(X)^T \Phi(X)[/math]

using the kernel [math]K[/math] and let [math]V[/math] be the eigenvectors of [math]\Phi(X)^T \Phi(X)[/math] with respect to the top [math]p[/math] eigenvalues. Finally we let [math]\Sigma[/math] be the diagonal matrix of square roots of the top [math]p[/math] eigenvalues.

Encode Training Data:
Using Kernel PCA to encode the data, let

[math]\,Y = U^T \Phi(X) = \Sigma V^T [/math]

Recall [math] U = \Phi(X) V \Sigma^{-1} [/math]:

[math]\,Y = U^T \Phi(X) = \Sigma^{-1} V^T \Phi(X)^T \Phi(X) = \Sigma^{-1} V^T K(X,X) [/math]

where [math]Y[/math] is an encoded matrix of the image of the original data in the function [math]\Phi[/math]. [math]Y[/math] is computable without knowledge of [math]\Phi(X)[/math] via the kernel function.

Reconstruct Training Data:

[math]\hat{\Phi(X)} = UY = UU^T\Phi(X)=\Phi(X)V\Sigma^{-1}\Sigma V^T=\Phi(X) V V^T[/math]
[math]\hat{X} = \Phi^{-1}(\hat{\Phi(X)})[/math]

However, [math]\Phi(X)[/math] is unknown so we cannot reconstruct the data.

Encode Test Example:

[math]\,y = U^T \Phi(x) = \Sigma^{-1} V^T \Phi(X)^T \Phi(x) = \Sigma^{-1} V^T K(X,x)[/math]

This is possible because we know that [math]\Phi(X)^T \Phi(X) = K(X,x)[/math].
[math] U = \Phi(X) V \Sigma^{-1} [/math]:
[math]\Phi(X)[/math] is the transformation of the training data [math]X_{d \times n}[/math] while [math]\Phi(x)[/math] is the transformation of the test example [math]x_{d \times 1}[/math]

Reconstruct Test Example:

[math]\hat{\Phi(x)} = Uy = UU^T \Phi(x) = \Phi(X) V \Sigma^{-2} V^T \Phi(X)^T \Phi(x) = \Phi(X) V \Sigma^{-2} V^T K(X,x)[/math]

Once again, since [math]\Phi(X)[/math] is unknown, we cannot reconstruct the data.

Centering for kernel PCA and multidimensional scaling (Lecture 4: Sept. 22, 2014)

Centering for kernel PCA

In the derivation of kernel PCA we assumed that [math]\sum_{i=1}^n\Phi(x_i)=0[/math] which is improbable for a random data set and an arbitrary mapping [math]\Phi[/math]. We must be able to ensure this condition though we don't know [math]\Phi[/math].

Let [math]\mu=\frac{1}{n}\sum_{j=1}^n\Phi(x_j)[/math]

Define the centered transformation (not computable)


and the centered kernel (computable)

[math]\tilde{K}:(x,y)\mapsto \tilde{\Phi}(x)^T \tilde{\Phi}(y)[/math]


[math]\tilde{K}(x,y) = (\Phi(x)-\mu)^T (\Phi(y)-\mu)=\Phi(x)^T\Phi(y)-\mu^T\Phi(x)-\mu^T\Phi(y)+\mu^T\mu[/math]

[math]=K(x,y)-\frac{1}{n}\sum_{j=1}^n K(x_j,x)-\frac{1}{n}\sum_{j=1}^n K(x_j,y)+\frac{1}{n^2}\sum_{j=1}^n\sum_{i=1}^n K(x_j,x_i)[/math]
where [math]\bold{1}=([1,1,...,1]_{1\times n})^T[/math]

Here [math]X_{d\times n}[/math] and [math]\{x_j\}_{j=1}^n[/math] denote the data set matrix and elements respectively and [math]x,y[/math] represent test elements at which the centered kernel is evaluated.

In practice, with [math]\, X = [x_1 | x_2 | ... | x_n] [/math] as the data matrix, the Kernel Matrix, denoted by [math]K[/math], will have elements [math]\, [K]_{ij} = K(x_i,x_j)[/math].

We evaluate [math]\tilde{K} = K - \frac{1}{n}\bold{1}^TK-\frac{1}{n}K\bold{1}+\frac{1}{n^2}\bold{1}^TK\bold{1} [/math], and find the eigenvectors/eigenvalues of this matrix for Kernel PCA.

Multidimensional scaling

Multidimensional Scaling (MDS) is a dimension reduction method that attempts to preserve the pair-wise distance, [math]d_{ij}[/math], between data points. For example, suppose we want to map a set of points X, [math]x \in \mathbb{R}^d[/math], to a set of points Y, [math]y \in \mathbb{R}^p[/math]. We want to preserve the pair-wise distances such that [math]d(x_i, x_j)[/math] is approximately the same as [math]d(y_i, y_j)[/math].

MDS example

We can map points in 2 dimensions to points in 1 dimension by projecting the points onto a straight line:

Multidimensional scaling from 2D to 1D

Note that the pair-wise distances are relatively preserved. However, the triangle inequality is not preserved:

[math]\, d(x_1,x_2)+d(x_2,x_3) \gt d(x_1, x_3)[/math], but [math]\, d(y_1,y_2)+d(y_2,y_3) = d(y_1, y_3)[/math]

Another example of when it's crucial to preserve the distances between data points in lower dimension space (MDS) is when dealing with "distances between cities", as shown in here

Distance matrix

Given a [math]d x n[/math] matrix, [math]X[/math], the distance matrix is defined by:

[math]D^X_{n \times n} = \begin{bmatrix} d^{(X)}_{11} & d^{(X)}_{12} & ... & d^{(X)}_{1n}\\d^{(X)}_{21} & d^{(X)}_{22} & ... & d^{(X)}_{2n}\\...\\d^{(X)}_{n1} & d^{(X)}_{n2} & ... & d^{(X)}_{nn} \end{bmatrix}[/math]

Where [math]d^{(X)}_{ij}[/math] is defined as the euclidean distance between points [math]x_i[/math] and [math]x_j[/math] in [math]\mathbb{R}^d[/math]

Important properties:

  • The matrix is symmetric
    • ie [math]d^{(X)}_{ij} = d^{(X)}_{ji} \; \forall \; 1 \leq i,j \leq n [/math]
  • The matrix is always non-negative
    • ie [math]d^{(X)}_{ij} \ge 0 \; \forall \; 1 \leq i,j \leq n [/math]
  • The diagonal of the matrix is always 0
    • ie [math]d^{(X)}_{ii}= 0 \; \forall \; 1 \leq i \leq n [/math]
  • If [math]x_i[/math]'s don't overlap, then all elements that are not on the diagonal are positive

Triangle inequality: [math]d_{ab} + d_{bc} \gt = d_{ac}[/math] whenever [math]a, b, c[/math] are three different indices

For any mapping to matrix [math]Y_{p \times n}[/math], we can calculate the corresponding distance matrix

[math]D^Y_{n \times n} = \begin{bmatrix} d^{(Y)}_{11} & d^{(Y)}_{12} & ... & d^{(Y)}_{1n}\\d^{(Y)}_{21} & d^{(Y)}_{22} & ... & d^{(Y)}_{2n}\\...\\d^{(Y)}_{n1} & d^{(Y)}_{n2} & ... & d^{(Y)}_{nn} \end{bmatrix}[/math]

Where [math]d^{(Y)}_{ij}[/math] is defined as the euclidean distance between points [math]y_i[/math] and [math]y_j[/math] in [math]\mathbb{R}^p[/math]

Note that a kernel matrix is a positive semidefinite matrix.

Finding the optimal Y

MDS minimizes the metric

[math]\text{min}_Y \sum_{i=1}^n{\sum_{j=1}^n{(d_{ij}^{(X)}-d_{ij}^{(Y)})^2}}[/math]

Where [math]d_{ij}^{(X)} = ||x_i - x_j||[/math], and [math]d_{ij}^{(Y)} = ||y_i - y_j||[/math]

The distance matrix [math]D^{(X)}[/math] can be converted to a kernel matrix:

[math]K = -\frac{1}{2}HD^{(X)}H[/math]

Where [math]H = I - \frac{1}{n}ee^T[/math] and [math]e=\begin{bmatrix} 1 \\ 1 \\ ... \\ 1 \end{bmatrix}[/math]

Here, K is a kernel matrix implies that K is positive semi-definite, so [math]x^TKx \geq 0[/math] [math] \forall x[/math]

In fact, there is a one-to-one correspondence between symmetric matrices and kernel matrices


If [math]D^{(X)}[/math] is a distance matrix and if [math]K=-\frac{1}{2}HD^{(X)}H[/math], then [math]D^{(X)}[/math] is Euclidean iff [math]K[/math] is Positive Semi-Definite,
where [math]H=I-\frac{1}{n}\bold{1}^T\bold{1} [/math] and [math]\bold{1}=([1,1,...,1]_{1\times n})^T[/math]

Relation between MDS and PCA

As has already been shown, the goal of MDS is to obtain [math] Y [/math] by minimizing [math]\text{min}_Y \sum_{i=1}^n{\sum_{j=1}^n{(d_{ij}^{(X)}-d_{ij}^{(Y)})^2}}[/math]
K is positive semi-definite so it can be written [math]K = X^TX[/math]. So

[math]\text{min}_Y \sum_{i=1}^n{\sum_{j=1}^n{(d_{ij}^{(X)}-d_{ij}^{(Y)})^2}} =\text{min}_Y(\sum_{i=1}^n\sum_{j=1}^n(x_i^Tx_j-y_i^Ty_j)^2) [/math]



From SVD we may make the decompositions [math]\, X^TX=V\Lambda V^T[/math] and [math]Y^TY=Q\hat{\Lambda}Q^T[/math]

[math]\text{min}_Y(\text{Tr}((X^TX-Y^TY)^2))=\text{min}_Y(\text{Tr}((V\Lambda V^T-Q\hat{\Lambda}Q^T)^2))=\text{min}_Y(\text{Tr}((\Lambda-V^TQ\hat{\Lambda}Q^TV)^2))[/math]

Let [math]G=Q^TV[/math]

[math]\text{min}_{G,\hat{\Lambda}}(\text{Tr}((X^TX-Y^TY)^2))=\text{min}_{G,\hat{\Lambda}}(\text{Tr}((\Lambda-G^T\hat{\Lambda}G)^2))=\text{min}_{G,\hat{\Lambda}}(\text{Tr}(\Lambda^2+G^T\hat{\Lambda}GG^T\hat{\Lambda}G-2\Lambda G^T\hat{\Lambda}G))[/math]

[math]=\text{min}_{G,\hat{\Lambda}}(\text{Tr}(\Lambda^2+G^T\hat{\Lambda}^2G-2\Lambda G^T\hat{\Lambda}G))[/math]
It can be shown that for fixed [math]\hat{\Lambda}[/math] that the minimum over [math]G[/math] occurs at [math]G=I[/math], which implies that


Since [math]\, \Lambda[/math] and [math]\hat{\Lambda}[/math] are diagonal matrices containing the eigenvalues of [math]X^TX,\text{ and } Y^TY[/math] respectively, and all said eigenvalues are positive, then the min is clearly obtained when the [math]p[/math] nonzero diagonal elements in [math]Y^TY[/math] are the [math]p[/math] largest eigenvalues in [math]X^TX[/math]

Finishing comments on MDS and Introduction to ISOMAP and LLE (Lecture 5: Sept. 29, 2014)


Isomap is a nonlinear dimensionality reduction method. In Multidimensional scaling we seek to find a low dimensional embedding [math]Y[/math] for some high dimensional data [math]X[/math], minimizing [math]\|D^X - D^Y\|^2[/math] where [math]\, D^Y[/math] is a matrix of euclidean distances of points on [math] Y[/math] (same with [math] D^X[/math]). In Isomap we assume the high dimensional data in [math] X[/math] lie on a low dimensional manifold, and we'd like to replace the euclidean distances in [math] D^X[/math] with the distance on this manifold. Obviously we don't have information about this manifold, so we approximate it by forming the k-nearest-neighbour graph between points in the dataset. The distance on the manifold can then be approximated by the shortest path between points. This is called the geodesic distance which is a generalization of the notion of straight line to curved spaces ans denoted by [math] D^G[/math]. This is useful because it allows for nonlinear patterns to be accounted for in the lower dimensional space. From this point the rest of the algorithm is the same as MDS.

It worth noting that as [math]D^{G}[/math] is not an Euclidean distance so the matrix [math]K = -\frac{1}{2}HD^{(G)}H[/math] is not guaranteed to be positive semi-definite matrix. This is handled in the implementation [3] by considering only the positive value of the real part only, which can be considered as projecting the matrix onto the cone of nearest positive semi-definite matrix.

It is important to note that k determines "locality". Isomap captures local structure and "unfolds" the manifold.

The swiss roll manifold is a commonly discussed example of this. Note that the Euclidean distance between points A and B drastically differs from the Geodesic distance.

ISOMAP Results

A Global Geometric Framework for Nonlinear Dimensionality Reduction paper proposed ISOMAP, the below figures show some images for ISOMAP results. The first image show the faces different orientation images dataset, as shown in the figure the x axis captures the horizontal orientation, while the y axis captures the vertical orientation and the bar captures the lightning direction. The second image shows the 2 handwritten digit and ISOMAP results in this dataset.

Locally Linear Embedding (LLE)

Locally Linear Embedding (LLE) is another technique for nonlinear dimensionality reduction that tries to find a mapping from high dimensional space to low dimensional space such that local distances between points are preserved. LLE has some advantages over Isomap, including faster optimization and better result in many problems. LLE reconstructs each point based on its k-nearest neighbour.

E.g. [math]x_i \approx w_1x_{1}+w_2x_{2}+...+w_kx_{k} , \sum_i w_i = 1[/math]

The method optimizes the equation [math]\mathbf{x_i-w_1x_{i1}+w_2x_{i2}+...+w_kx_{ik}}[/math] for each [math]x_i \in X[/math] with corresponding k-th nearest neighbour set [math]\mathbf{\, {x_{i1},x_{i2},...,x_{ik}}}[/math]. LLE is therefore an optimization problem for:

[math]\mathbf{ \text{min}_W \sum_{i=1}^n{(x_i-\sum_{j=1}^n{w_{ij}x_j)^2}}} [/math] such that [math] \mathbf{\sum_{j=1}^n w_{ij} = 1} [/math] and also [math] \mathbf{w_{ij} = 0} [/math] if [math]\mathbf{x_i} [/math] and[math]\mathbf{x_j} [/math]are not neighbors


  • Find the k-nearest neighbour for each data point
  • Compute [math] \mathbf{W_{nxn}} [/math] through [math] \mathbf{\text{min}_W \sum_{i=1}^n{(x_i-\sum_{j=1}^n{W_{ij}x_j)^2}}} [/math] such that [math]\mathbf{\sum w_{ij} = 1}[/math] (which means that it's convex optimization of the points) where [math] \mathbf{x_j} [/math] are the k-nearest neighbours of [math] \mathbf{x_i} [/math]
  • Let [math] \mathbf{V_i = [x_j | x_j} [/math] is a neighbour of [math]\mathbf{ x_i ]_{dxk}} [/math] Let [math] \mathbf{w(i)} [/math] be all k weights of point [math] \mathbf{x_i} [/math] (ie row i of W with all zeroes removed) Then:
[math] \mathbf{V_i*w(i) = \sum_{j=1}^n{w_{ij}x_j}} [/math]
and hence we need to optimize
[math]\mathbf{\, \text{min}_{w(i)} |x_i-V_i*w(i)|^2}[/math] under the constraint [math]\mathbf{\sum_{j=1}^n{w_{ij}}=1} [/math]
This is a separable optimization problem which can be solved for each point independently, which can be simplified to
[math] \mathbf{min|x_ie_k^Tw(i)-V_iw(i)|^2 }[/math], where [math]e=\begin{bmatrix} 1 \ 1 \ ... \ 1 \end{bmatrix}^T[/math].
Now we have
[math]\mathbf{\, |x_ie_k^Tw(i)-V_iw(i)|^2 =(x_ie^Tw(i)-V_iw(i))^T(x_ie^Tw(i)-V_iw(i))= w(i)^T(x_ie^T-V_i)^T(x_ie^T-V_i)w(i) }[/math]

Let [math]\mathbf{\, G =(x_ie^T-V_i)^T(x_ie^T-V_i) }[/math]. Therefore we can instead simplify
[math]\mathbf{ min \;w(i)^TGw(i)} [/math] under the constraint [math]\mathbf{\, w(i)^Te=1} [/math]

  • Use Lagrange Multipliers to optimize the above equation:
[math]\mathbf{\, L(w(i),\lambda)=w(i)^TGw(i)-\lambda(w(i)^Te-1) }[/math]

[math]\mathbf{\frac{\partial L}{\partial {w(i)}}=2Gw(i)-\lambda e=0 }[/math] which implies [math]\mathbf{ Gw(i)=\frac{\lambda}{2}e} [/math] and hence [math]\mathbf{ w(i)=\frac{\lambda}{2}G^{-1}e }[/math]
Note that we do not need to compute [math] \mathbf{\lambda} [/math], but can just compute [math]\mathbf{\, G^{-1}e} [/math], then re-scale so [math]\mathbf{\, w(i)^Te=1} [/math]
  • Finally, solve [math]\mathbf{\text{min}_Y \sum_{i=1}^n{(y_i-\sum_{j=1}^t{w_{ij}y_j)^2}}} [/math] where w is known and y is unknown


[math]G_{d*d}[/math] is invertible under some conditions depending on [math]k[/math], as it must have rank [math]d[/math] so [math]k[/math] must be greater than or equal [math]d[/math]

LLE doesn't work for out of sample case there are extensions for it to handle this as in this [4]

If we want to reduce the dimensionality to p, we need to choose the p+1 smallest eigenvectors.

LLE continued, introduction to maximum variance unfolding (MVU) (Lecture 6: Oct. 1, 2014)


Recall the steps of LLE can be summarized as follows:

  1. For each data point, find its [math]k[/math] nearest neighbours for some fixed [math]k[/math].
  2. Find reconstruction weights [math]W[/math], minimizing
    [math]\sum_{i=1}^n ||x_i - \sum_{j=1}^n w_{ij}x_j||^2, where \sum_j w_{ij} = 1[/math]
  3. Reconstruct the low dimensional embedding with respect to these weights.
    That is, find low dimensional [math]Y[/math] minimizing
    [math]\sum_{i=1}^n||y_i - \sum_{j=1}^nw_{ij}y_j||^2[/math].

The previous lecture covered how to find the weights [math]W[/math]. Here we will discuss how to find the low-dimensional embedding [math]Y[/math] using these weights.

First, we want to write the previous equation in a matrix form.
Consider that [math]Y[/math] is a [math]p*n[/math] matrix and [math]I_{:i}[/math] is the [math]i^{th}[/math] column ([math]n*1[/math]) in the identity matrix (like Matlab notation)

Then the sample, [math]i[/math], can be represented as follows: [math]y_i = Y * I_{:i} = \begin{bmatrix} y_1, y_2 ,... y_i,..., y_n \end{bmatrix} \begin{bmatrix} 0 \\0 \\... \\ 1 \\ ... \\0 \end{bmatrix}[/math]

Note that: [math]I_{i:} Y^T = y_i^T[/math] where [math]I_{i:}[/math] is the [math]i^{th}[/math] row from the identity matrix

Similarly, [math]\sum w_{ij} y_i = w_{i:} Y^T[/math]

So the objective is equivalent to minimizing [math]\sum_{i=1}^n||I_{i:} Y^T - W_{i:}Y^T||^2 = ||IY^T - WY^T||^2[/math]

But first, to prevent the trivial solution of the 0-matrix, we add the constraint that [math]\frac{1}{n}Y^TY = I[/math]. Now, the objective can be rewritten as minimizing:

[math]||Y^T - WY^T||^2_F[/math]

where the above norm is the Frobenius norm, which takes the square root of the sum of squares of all the entries in the matrix. Recall this norm can be written in terms of the trace operator:

[math]||Y^T - WY^T||^2_F = ||Y^T (I - W)||^2_F = Tr((Y^T (I - W)) (Y^T (I - W))^T)= Tr(Y^T(I-W)(I-W)^TY)[/math]

By letting [math]\, M=(I-W)(I-W)^T[/math], the objective function will become

[math]\min_Y Tr(Y^T M Y)[/math]

This minimization has a well-known solution: We can set the rows of [math]Y[/math] to be the [math]d[/math] lowest eigenvectors of [math]M[/math], where [math]d[/math] is the dimension of the reduced space.

To solve this minimization using the Lagrange multiplier, the Lagrangian is:

[math]L(Y, \Lambda) = Tr(Y^TMY) - Tr(\Lambda (\frac{1}{n} Y^T Y - I)))[/math]

[math]\frac{d}{dy} L(Y, \Lambda) = 2MY- \Lambda \frac{2}{n} Y[/math]

Setting this equal to zero and solving gives

[math]MY = \frac{1}{n} \Lambda Y[/math]
[math]MY = \Lambda^* Y[/math]

where [math]\Lambda = \begin{bmatrix} \lambda_1 & \ldots & 0 \\ 0 & \lambda_2 & \ldots\\ \vdots & \ddots & \vdots\\ 0 &\ldots & \lambda_p \end{bmatrix} [/math]

If we want to reduce the dimensions to p, we need to choose p + 1 smallest eigenvectors. This is because the matrix has the first eigenvalue equal to 1 since it is a Laplacian (the number of [math]0[/math] eigenvalues of a Laplacian is the number of connected components).

Comparison between Dimensionality Reduction Approaches

Approach Solution\Eigenvectors of
PCA [math] \mathbf{ X^T * X }[/math] OR [math] \mathbf{ \Sigma V^T } [/math]
MDS [math] \mathbf{ - \frac{1}{2} (I - \frac{1}{n} e e^T) D (I - \frac{1}{n} e e^T) }[/math] aka [math] \mathbf{H D H}[/math] where [math] H=(I - \frac{1}{n} e e^T)[/math]
ISOMAP [math]\mathbf{ - \frac{1}{2} (I - \frac{1}{n} e e^T) D^G (I - \frac{1}{n} e e^T) }[/math]
LLE [math]\mathbf{ (I - W)(I - W)^T }[/math] [math]\mathbf{ \lambda I - (I - W)(I - W)^T }[/math]
KPCA [math] \mathbf {K} [/math]

From the above table we can interpret all of these algorithms as kernel PCA more details are presented here [5].

Note that PCA, MDS, ISOMAP and KPCA choose the largest eigenvalue/eigenvector pairs for embedding while LLE chooses the smallest pair. However, in LLE, if we let [math]\lambda_{max}[/math] be the largest eigenvalue of [math]\mathbf{L = (I-W)^T(I-W)}[/math] and replace the matrix [math]\mathbf{ (I - W)(I - W)^T }[/math] with [math]\mathbf{ \lambda_{max}I - (I - W)(I - W)^T }[/math], the largest eigenvalue/eigenvector pairs will be chosen instead.

Maximum variance unfolding

In maximum variance unfolding (MVU), as in isomap and LLE, we try to reduce the dimensionality of a nonlinear data. We may assume that the data is sampled from a low-dimensional manifold that is embedded within a higher-dimensional Euclidean space. The aim is to "unfold" this manifold in a lower-dimensional Euclidean space such that the local structure of each point is preserved. We would like to preserve the distance from any point to each of its [math]k[/math] nearest neighbours, while maximizing the pairwise variance for all points which are not its neighbours. The MVU algorithm uses semidefinite programming to find such a kernel.

Optimization constraints

For a kernel [math]\Phi[/math] such that [math]x \mapsto \phi(x)[/math], we have the following 3 constraints:

  1. [math]\Phi[/math] must be centred, i.e. [math]\sum\limits_{i,j} k_{ij} = 0[/math].
  2. [math] k [/math] should be positive semi-definite, i.e. [math]k \succeq 0 [/math].
  3. The local distance should be maintained between data and its embedding.
    This means that for [math]i, j[/math] such that [math]x_i, x_j[/math] are neighbours, we require that [math]\Phi[/math] satisfies
     :[math]\, | x_i - x_j |^2 = |\phi(x_i) - \phi(x_j)|^2[/math]
[math]\, = [\phi(x_i) - \phi(x_j)]^T [\phi(x_i) - \phi(x_j)] [/math]
 :[math]\, =\phi(x_i)^T \phi(x_i) - \phi(x_i)^T \phi(x_j) - \phi(x_j)^T \phi(x_i) + \phi(x_j)^T \phi(x_j)[/math]
 :[math]\, =k_{ii} - k_{ij} - k_{ji} + k_{jj}[/math]
 :[math]\, =k_{ii} -2k_{ij} + k_{jj}[/math]
where [math]\, K=\phi^T \phi[/math] is the [math]n \times n[/math] kernel matrix.
We can summarize this third constraint as:
 :[math]\, n_{ij} ||x_i - x_j||^2 = n_{ij} || \phi(x_i) - \phi(x_J) ||^2[/math]
where [math] n_{ij}[/math] is the neighbourhood indicator, that is, [math] n_{ij} = 1[/math] if [math]x_i, x_j[/math] are neighbours and [math]0[/math] otherwise.

Optimization problem

One option for finding the correct K would be to minimize the rank of K. The intuition behind this is that even though the data might be high-dimensional, it lies on a manifold of low dimension. Since [math]rank[/math] is not a convex function, the objective function is ill-defined and is replaced with [math]Tr(K),[/math] since when K is semidefinite the trace is just equal to the sum of the singular values. However, in practice minimizing the trace does not result in a faithful low-dimensional representation. An explanation for this phenomenon is still an open problem. To find a useful K, the objective of [math]Tr(K)[/math] can still be used, but the problem has to be changed from a minimization to a maximization. The intuition here is that you are maximizing the total variance explained by the kernel. Thus the problem is

[math]\text{max } Tr(K)[/math]
[math]\text{subject to above constraints}[/math]

which is a semidefinite program.

MVU (Maximum Variance Unfoilding) Method

  1. Construct the neighbourhood graph using k-nearest neighbours
  2. Find the kernel K by solving the SDP problem: max [math]Tr(K)[/math] such that
    [math]K_{ii}+K_{jj}-2K_{ij} = D_{ij}, \sum_{ij} K_{ij} = 0, K \succeq 0[/math]
  3. Apply Kernel PCA on the learned kernel K

Action Respecting Embedding and Spectral Clustering (Lecture 7: Oct. 6, 2014)

SDE Paper Notes

Unsupervised Learning of Image Manifolds by Semidefinite Programming introduced the maximum variance unfolding technique. The results of the paper compare the proposed technique against existing dimensionality reduction techniques. The first figure compares SDE against PCA in the "faces" dataset. To maintain the entire dataset variation we need 5 dimensions using SDE, while we need 10 dimensions using PCA. The second figure compares SDE against ISOMAP in a non-convex dataset. To maintain the whole dataset variation we need only 2 dimensions using SDE, while we need more than 5 dimensions using ISOMAP. The two figures show that SDE can represent data variation using a much smaller number of eigenvectors than PCA or ISOMAP.

Action Respecting Embedding

When we are dealing with temporal data, in which the order of data is important, we could consider a technique called Action Respecting Embedding. Examples include stock prices, which are time series, or a robot that moves around and takes pictures at different positions. Usually there are various actions that transform one data point into the next data point. For example, consider a robot taking pictures at different positions. Actions include stepping forward, stepping backward, stepping right, turning, etc. After each action, the robot takes a picture at its current position then undertakes another action. This sequence is continued until a set of data points is collected. Consider a financial time series. Actions include stock splits, interest rate reduction, etc. Consider a patient under a treatment. Actions include taking a specific step in the treatment or taking a specific drug, which affects blood sugar level, cholesterol, etc.

Some information cannot be captured in the form of similarities.

Action Respecting Embedding takes a set of data points [math]\, x_{1},...,x_{n}[/math] along with associated discrete actions [math]\, a_{1},...,a_{n-1}[/math]. The data points are assumed to be in temporal order, where [math]\, a_{i}[/math] was taken between [math]\ x_{i}[/math] and [math]\ x_{i+1}[/math].

Constain all actions to be distance preserving transformations in the feature space.

Now we realize that intuitively, if two points have the same action, then the distance between them should not change after the action. There are only three types of transformations that do not change the distance between points. They are rotation, reflection, and translation. Since rotation and reflection have the same properties, we will call both of these rotation for our purposes. Any other transformation does not preserve distances. Note that we are able to model any action in low dimensional space by rotation, translation or any linear combination of them.

Optimization Problem

Recall that kernel function satisfies the property: [math]\, |\phi(x_i) - \phi(x_j)|^2 = | x_i - x_j |^2 [/math]. We can formulate the idea of distance preserving mathematically as [math]\, |\phi(x_i) - \phi(x_j)|^2 = |\phi(x_i+1) - \phi(x_j+1)|^2 [/math], if [math]\, x_i, x_j[/math] are points that perform the same type of transformations.

The maximum variance unfolding problem is

[math]\, \text{max tr}(K)[/math]
such that [math]\, |\phi(x_i) - \phi(x_j)|^2 = k_{ii} -2k_{ij} + k_{jj}[/math]
[math]\sum\limits_{i,j} k_{ij} = 0[/math]
[math]k \succeq 0 [/math]

The Action Respecting Embedding problem is similar to the maximum variance unfolding problem, with another constraint:

For all i, j, [math]a_{i} = a_{j}[/math],

[math]\,k_{(i+1)(i+1)} - 2k_{(i+1)(j+1)} + k_{(j+1)(j+1)} = k_{ii} - 2k_{ij} + k_{jj}[/math]

A Simple Example

Consider the two examples presented in the ARE paper [6] of a robot moving around taking pictures with some action between them. The input is a series of pictures with actions between them. Note that there are no semantics for the actions, only labels

The first example is a robot that takes 40 steps forward then takes a 20 steps backward. The following figure (which is taken from ARE paper [7] shows the action taking by the robot and the results of ARE and SDE. We can see that ARE captures the trajectory of the robot. Although ARE doesn't have semantics for each action it captured an essential property of these actions that they are opposite in direction and equal in magnitude. We could look at the position on manifold vs. time for a robot that took 40 steps forward and 20 steps backward. We could also look at the same analysis for a robot that took 40 steps forward and 20 steps backward that are twice as big.

Another complicated action and the result of ARE and SDE are shown in the next figure (taken from ARE paper [8]), where we can see that ARE captured the trajectory of the robot.

Sometimes it's very hard for humans to recognize what happened by merely looking at the data, but this algorithm will make it easier for you to see exactly what happened.

Types of Applications

A common type of application is planning. This is when we need to find a sequence of decisions which achieve a desired goal, for example, coming up with an optimal sequence of actions to get from one point to another.

For example, what type of treatment should I give a patient in order to get from a particular state to a desired state?

For each action [math]a[/math], we have a collection of data points [math]\, (y_{t},y_{t+1})[/math] such that [math]\, y_{t} \to y_{t+1}[/math].

Through the algorithm, we learn [math]\, f_{a}[/math]: [math]\, f_{a}(y_{t}) = A_{a}y_{t} + b_{a} = y_{t+1}[/math] where [math]A_{a}[/math] is that rotation matrix for action [math] a [/math], and [math]b_{a}[/math] is the translation vector vector for action [math] a [/math]. We can estimate [math]A_{a}[/math] and [math]b_{a}[/math]. These can be solved in closed form so that we will know what happens to any input [math] (y_t) [/math] if action [math] a [/math] is taken.

Spectral Clustering

Clustering is the task of grouping data so that elements in the same group are more similar (or dissimilar) to each other than to the elements in other groups. In spectral clustering, we represent first the data as a graph and then perform clustering.

For the time being, we will only consider the case where there are two clusters.

Given [math]\{x_i\}^{n}_{i=1}[/math] and notation of similarity or dissimilarity, we can represent the data as a weight undirected graph [math]\,G=(V,E)[/math] where V represents the vertices (the data) and E represents the edges (similarity or dissimilarity between two data - for now we will assume simliarity).

Using intuition, we can see that the goal is to minimize the sum of the weights of the edges that we cut (i.e. edges we remove from G until we have a disconnected graph)
[math]cut(A,B)=\sum_{i\in A, j\in B} w_{ij}[/math]

where A and B are the partitions of the vertices in G made by a cut, and [math]\,w_{ij}[/math] is the weight between points i and j.

Consider the following graphs of data:

Although "cut" may minimize the edge weights that we use to partition, note that using cut(A,B) may cause many edges to be cut, but which have smaller weights. For example, if there is one datum that is very dissimilar to the rest of the data, we may end up partitioning this one point to itself despite it resulting in many edges being cut. This is the case in Example 3 above. This occurrence may cause an imbalance in partition sizes. To avoid this problem, we minimize the ratio-cut.

We define ratio-cut as: [math]ratiocut = \frac{cut(A, \bar{A})}{|A|} + \frac{cut(\bar{A}, A)}{|\bar{A}|}[/math] where [math]\, |A|[/math] is the number of points in set [math]\, A[/math] and [math]\, \bar{A}[/math] is the complement of [math]\, A[/math].

This equation will be minimized if there is a balance between set [math]\, A[/math] and [math] \bar{A}[/math]. This, however, is an NP Hard problem; we must relax the constraints to arrive at a computationally feasible solution.

Let [math]f \in \mathbb{R}^n[/math] such that

[math] f_{i} = \left\{ \begin{array}{lr} \sqrt{\frac{|\bar{A}|}{|A|}} & i \in A\\ -\sqrt{\frac{|A|}{|\bar{A}|}} & i \in \bar{A} \end{array} \right. [/math]

We will show in the next lecture that minimizing [math]\, \sum_{ij}w_{ij}(f_{i}-f_{j})^2[/math] is equivalent to minimizing the ratio-cut.

Spectral Clustering (Lecture 8: Oct. 8, 2014)

Problem Formulation and Notations

Once we are given a set of points [math]\, x_{1},...,x_{n}[/math] and a sense of what it is to be similar or dissimilar, we can represent these data points as a weighted undirected graph. Let [math]\, G=( V, E)[/math] be a graph, where V is the set of vertices and E is the set of edges.

In graph theory, partitioning the set of vertices of a graph into two disjoint sets is called a cut. Consequently the set of edges which has one end point in each subset (partition) is called a cut-set, which crosses the cut. In a connected graph each cut-set determines a unique cut. So, in some cases cuts are identified with their cut-sets rather than with their vertex partitions.

A cut [math]\, C = ( A, B ) [/math] is a partition of [math] V [/math] of a graph [math]\, G = (V, E)[/math] into two subsets [math] A [/math] and [math] B [/math]. The cut-set of a cut [math]\, C = ( A, B ) [/math] is the set [math] \{ ( i,j ) \in E | i \in A, j \in B \} [/math] of edges that have one endpoint in [math] A [/math] and the other endpoint in [math] B [/math]. If [math] i [/math] and [math] j [/math] are specified vertices of the graph [math] G [/math], an [math] i [/math] [math] - [/math] [math] j [/math] cut is a cut in which [math] i [/math] belongs to the set [math] A [/math] , and [math] j [/math] belongs to the set [math] B [/math].

The weight of a cut is different for different types of graphs:

  • In an Unweighted Undirected graph, the size or weight of a cut is the number of edges crossing the cut, or 1 for each edges crossing the cut.
  • In a Weighted graph, the value or weight is defined by the sum of the weights of the edges crossing the cut.

Cut can be minimized or maximized, as defined below:

  • A cut is minimum if the size or weight of the cut is not larger than the size of any other cut. In other words, partitioning vertices of a graph into two disjoint subsets that are joined by at least one edge is minimum cut, which is 2 here in the following example.
  • A cut is maximum if the size of the cut is not smaller than the size of any other cut, which is 5 here in the following example.

The total weight of the cut is

[math] cut ( A, B) = \sum_{i \in A, j \in B} w_{ij} [/math]

Minimizing this is a combinatorial problem:

[math]ratiocut (A, \bar{A}) = \frac{cut( A, \bar{A})} {|A|} + \frac{cut( \bar{A}, A)} {| \bar{A}|} [/math]

which result in a more balanced subgraph in terms of the size of each subgraph.

[math] f \in {R}^n [/math] [math] f_i = \left\{ \begin{array}{lr} \sqrt{\frac{| \bar{A}|}{| A|}} & i \in A\\ -\sqrt{\frac{| A|}{| \bar{A}|}} & i \in \bar{A} \end{array} \right. [/math]

The previous function gives a positive value to any point i that belongs to [math] A [/math], and a negative value to any point j that belongs to [math] \bar{A}[/math].

Ex. If [math]| A| = | \bar{A}|[/math] then the values for i will be +1 and values for j will be -1.


Problem: Prove that minimizing [math]\, \sum_{i,j} w_{ij} * ( f_i - f_j)^2 [/math] is equivalent to minimizing ratiocut [math] ( A, \bar{A})[/math]


We have 4 cases: 1) [math] i \in A \; and\; j \in A [/math] , 2) [math] i \in A \; and\; j \in \bar{A} [/math] , 3) [math] i \in \bar{A} \; and\; j \in A [/math] , and 4) [math] i \in \bar{A} \; and\; j \in \bar{A} [/math]

[math] \sum_{i,j} w_{ij} * ( f_i - f_j)^2 = \sum_{ i \in A, j \in \bar{A}} w_{ij} * (\sqrt{\frac{| \bar{A}|}{| A|}} + \sqrt{\frac{| A|}{| \bar{A}|}}) ^ 2 + \sum_{ i \in \bar{A}, j \in A} w_{ij} * (- \sqrt{\frac{| A|}{| \bar{A}|}} - \sqrt{\frac{| \bar{A}|}{| A|}}) ^ 2 [/math]

since both [math] \sum_{ i \in A, j \in A} w_{ij} * ( f_i - f_j)^2 =0 \; and \; \sum_{ i \in \bar{A}, j \in \bar{A}} w_{ij} * ( f_i - f_j)^2 = 0 [/math]

[math] = \sum_{ i \in A, j \in \bar{A}} w_{ij} * (\frac{| \bar{A}|}{| A|} + \frac{| A|}{| \bar{A}|} + 2 * \sqrt {\frac{| \bar{A}|} {| A|} * \frac{| A|} {| \bar{A}|}}) + \sum_{ i \in \bar{A}, j \in A} w_{ij} * ( \frac{| A|}{| \bar{A}|} + \frac{| \bar{A}|}{| A|} + 2 * \sqrt {\frac{| A|} {| \bar{A}|} * \frac{| \bar{A}|} { | A|}}) [/math]

Note that [math] \frac{| \bar{A}|} {| A|} * \frac{| A|} {| \bar{A}|} = I [/math] and [math] 2 = 1 + 1 = \frac{| A|} {| A|} + \frac {| \bar{A}|} {| \bar{A}|} [/math]

[math] = \sum_{ i \in A, j \in \bar{A}} w_{ij} * (\frac{| \bar{A}|+| A|}{| A|} + \frac{| A| + | \bar{A}|}{| \bar{A}|}) + \sum_{ i \in \bar{A}, j \in A} w_{ij} * ( \frac{| A|+| \bar{A}|}{| \bar{A}|} + \frac{| \bar{A}| + | A|}{| A|} ) [/math]

[math] = (\frac{| \bar{A}|+| A|}{| A|} + \frac{| A| + | \bar{A}|}{| \bar{A}|}) * \sum_{ i \in A, j \in \bar{A}} w_{ij} + (\frac{| \bar{A}|+| A|}{| A|} + \frac{| A| + | \bar{A}|}{| \bar{A}|}) * \sum_{ i \in \bar{A}, j \in A} w_{ij} [/math]

Note that [math] \sum_{ i \in A, j \in \bar{A}} w_{ij} = cut ( A, \bar{A}) [/math] and [math] \sum_{ i \in \bar{A}, j \in A} w_{ij} = cut ( \bar{A}, A) [/math] .

Therefore, our main equation becomes:

[math] (\frac{| \bar{A}|+| A|}{| A|} + \frac{| A| + | \bar{A}|}{| \bar{A}|}) * cut ( A, \bar{A}) + (\frac{| \bar{A}|+| A|}{| A|} + \frac{| A| + | \bar{A}|}{| \bar{A}|}) * cut ( \bar{A}, A) [/math]

Since [math] cut( A, \bar{A}) = cut( \bar{A}, A) [/math], then:

[math] (\frac{| \bar{A}|+| A|}{| A|} + \frac{| A| + | \bar{A}|}{| \bar{A}|}) * 2 * cut ( A, \bar{A}) [/math]

Let [math] n = | \bar{A}| + | A| [/math], then:

[math] (\frac{ n}{| A|} + \frac{ n}{| \bar{A}|}) * 2 * cut ( A, \bar{A}) [/math]

[math] = 2 * n * (\frac{cut( A, \bar{A})}{| A|} + \frac{cut( \bar{A}, A)}{| \bar{A}|}) [/math]

[math] = 2 * n * ratiocut( A, \bar{A}) [/math]

Since n is always non-negative, minimizing ratiocut is equivalent to minimizing [math] 2 * n * ratiocut( A, \bar{A}) [/math]. Therefore, minimizing [math]\, \sum_{i,j} w_{ij} * ( f_i - f_j)^2 [/math] is equivalent to minimizing [math] ratiocut( A, \bar{A})[/math]. This completes the proof.

Problem: find an appropriate relaxation of the optimization problem.

Define [math]\, {W = [w_{ij}]_{n \times n}} [/math] to be the matrix of all weights.

[math] {W = \begin{bmatrix} w_{1,1} & w_{1,2} & \cdots & w_{1,n} \\ w_{2,1} & w_{2,2} & \cdots & w_{2,n} \\ \vdots & \vdots & \ddots & \vdots \\ w_{n,1} & w_{n,2} & \cdots & w_{n,n} \end{bmatrix}} [/math]

Define [math] D [/math] to be a diagonal nxn matrix such that:

[math]\, {d_i = \sum_j w_{ij}} [/math]

[math] {D = \begin{bmatrix} d_{1} & 0 & \cdots & 0 \\ 0 & d_{2} & \cdots & 0 \\ \vdots & \vdots & \ddots & \vdots \\ 0 & 0 & \cdots & d_{n} \end{bmatrix}} [/math]

Define [math] L [/math] is a [math] {n \times n} [/math] matrix such that [math] L = D - W [/math], [math] L [/math] is called the Laplacian of the graph.

Show: [math]\, {2 f^TLf = \sum_{ij} w_{ij} (f_i - f_j)^2} [/math]


[math]\, {L}[/math] and [math]\, {w_{ij}}[/math] are known.

[math]\, {L.H.S = 2 f^T L f = 2 f^T (D-W) f = 2 f^T D f - 2 f^T W f} [/math]

Note that [math]\, {f^T D f} [/math] can be written as [math] {\sum_i d_i f_i^2}[/math] and [math]\, {f^T W f} [/math] can be written as [math]\, {\sum_{i,j} w_{ij} f_i f_j} [/math]

Recall that we want to reach to the quadratic form in the right hand side [math]{(f_i- f_j)^2 = f_i^2 - 2f_i f_j + f_j^2}[/math]

[math] {L.H.S = 2 \sum_i d_i f_i^2 - 2 \sum_{i,j} w_{ij} f_i f_j = \sum_i d_i f_i^2 + \sum_{i} d_i f_i^2 - 2 \sum_{i,j} w_{ij} f_i f_j} [/math]

By changing the [math]i[/math] in the second term into [math]j[/math]

[math] {L.H.S = \sum_i d_i f_i^2 + \sum_{j} d_j f_j^2 - 2 \sum_{i,j} w_{ij} f_i f_j = \sum_i d_i f_i^2 - 2 \sum_{i,j} w_{ij} f_i f_j + \sum_{j} d_j f_j^2} [/math]

By substituting the value of [math]d_i[/math]

[math] {L.H.S = \sum_{i,j} w_{ij} f_i^2 - 2 \sum_{i, j} w_{ij} f_i f_j + \sum_{i,j}w_{ij}f_j^2 =\sum_{i,j} w_{ij} (f_i - f_j)^2 = R.H.S} [/math]

Which means minimizing the R.H.S minimizes the L.H.S

Relaxation of constraint

Observe that [math]f^T f = \sum_{i=1} f_i^2 = \sum_{i \in A} \frac{|\bar{A}|}{|A|} + \sum_{i \in \bar{A}} \frac{|A|}{|\bar{A}|} = |A|*\frac{|\bar{A}|}{|A|} + |\bar{A}| * \frac{|A|} {|\bar{A}|} = n[/math]

Therefore our goal is to solve the following optimization problem

[math]\, \text{min}_f( {f^T L f})[/math]

[math]\, s.t. {f^T f = n}[/math]

instead of solving the more difficult ratiocut optimization problem

Our new problem can be solved by using Lagrange multiplier:

[math]\, {L(f, \lambda) = f^T L f - \lambda (f^Tf -n)} [/math]

[math] {\frac{\delta L}{\delta f} = 2 Lf - 2 \lambda f} [/math]

Set [math]\frac{\delta L}{\delta f} = 0[/math], we get: [math]\, { Lf = \lambda f} [/math]
The equation above is clearly satisfied if and only if [math]f[/math] is an eigenvector of L, and [math]\lambda[/math] is the corresponding smallest eigenvalue.

[9] Since a graph with one connected component has only one constant eigenvector [math]{u = 1_n}[/math] that is associated with [math] {0}[/math] eigenvalue. And as we can see from the previous equation that [math]{f}[/math] is the eigenvector of [math]{L}[/math]. So [math]{f}[/math] is the eigenvector corresponding to the second smallest eigenvalue, with positive elements corresponds to one class and negative elements correspond to the other one.

Spectral Clustering Results

The following figures show [10]the results of the spectral clustering against other clustering algorithms. As clustering is considered as an ill-defined problem it's hard to say that one algorithm groups the points better than other algorithms. However, in the figures below, spectral clustering groups the points as a person may.

The most notable issue with spectral clustering is its dependency on the definition of "similar" and/or "dissimilar". For example, suppose a class of students were to be cut into two groups. If weights were given to pairs of students according to the similarity of their gender, then the two groups would presumably be separated into males and females. However, this weighting doesn't account for other similarities the class might have such as colour of clothing worn that day, or less visible similarities such as number of hours slept the previous night. The definition of "similar" is therefore what drove the cut, and not the actual similarities between the students. Spectral clustering is a problem that only has subjective solutions due to the subjective nature of the problem.

Multiclass Spectral Clustering

Spectral clustering can be used in multiclass case by choosing the smallest [math] k-1 [/math] eigenvectors after ignoring the smallest one (associated with [math] 0 [/math] eigenvalue, this will result in a matrix of size [math] n * (k-1)[/math] which can be used as a covariate of other clustering algorithm.

Laplacian Eigenmap

Laplacian eigenmap [11] solves the problem of dimensionality reduction by obtaining the eigenvectors that correspond to the lowest [math] {d+1} [/math] eigenvalues and project the data to these eigenvectors. This is very similar to the spectral clustering.

We can interpret the multiclass spectral clustering as a dimensionality reduction step before applying a clustering technique.

Also spectral clustering can be interpreted from Random walk point of view as explained here [12]: "Random walk is a stochastic process on a graph which moves randomly from node to node. So spectral clustering tries to find a graph partition such that random walk stays long within a cluster and with seldom moves from one cluster to another."

A side note: The frobenius norm of the covariance matrix can measure the linear correlation between two variables, the larger the norm the larger the correlation. And this is true only for linear correlation as for the nonlinear correlation data should be mapped to Hilbert space first before applying the covariance operator and obtain the Schmidt norm.

The following is a matlab sample code that shows the norm of a covariance matrix for uncorrelated, linearly correlated, non-linearly correlated random variables.

>> X1 = randn(1, 10000);
>> X2 = randn(1, 10000);  % x1 and x2 are independent
>> X = [X1;X2];  
>> cov(X')        % 2 by 2 matrix 
>> norm(cov(X'))  % small as X1 and X2 are independent
>> X2 = 2 * X1;
>> X = [X1;X2];
>> cov(X')
>> norm(cov(X')) % large as X1 and X2 are linearly dependent
>> X2 = sin(X1);
>> X = [X1;X2];
>> cov(X')
>> norm(cov(X')) % not large as the dependency between X1 and X2 is not linear. 

Supervised Principal Component Analysis (Lecture 9: Oct. 15, 2014)

Assignment 1 Solutions

Overall the first assignment was done quite well. The average mark for undergrads was approximately 70%. The average grade for graduates was approximately 75%. This lecture will focus on the details of the first assignment and going over the solutions. The solutions will not be posted online.

Question 1 was done quite well. Some marks were deducted for unusual scaling of eigenvalues (division by (n-1)). In general it is a good idea to scale the eigenvalues, however, it will usually not affect whether the PCA function works or not. Marks were given simply for having a picture for most of the questions. Note that the explanations for the questions should have some detail, one-word answers are not sufficient.

Question 2 part(a) had some issues. Some students plotted too many eigenvectors. Also in general, the fewer PCs we keep, the better. When determining how many eigenvectors to keep, look for an "elbow" in the plot for when the variance represented by a given eigenvector drops off.

Question 3 was very well done, as long as you had some pictures, you would have gotten most of the marks.

Question 4 had some issues. These are very well-known properties, so you should prove it using the definitions and show more detailed steps.

Question 5 was marked based on how far a student correctly followed the solution. Take the partial derivatives according to [math] \mu [/math], and according to [math] y_i [/math], set equal to 0 and simplify. Substituting one into the other and further simplifying gives the answer.

Question 6 part(a) as well as part(c) were done well. Part(b) required showing that all eigenvectors of [math] \tilde S [/math] are also eigenvectors of [math] S [/math]

Supervised Principal Component Analysis Introduction

Principal component analysis (PCA) may not be the ideal for processing multiple sets of data at once or data with different classes of characteristics, since the principal component which maximizes variation may not preserve these characteristics/classes. As such, maximizing the variance sometimes is not the best way to reduce the dimensionality of the data as shown in the below figure (taken from here [13]) we can see that projecting the data on the direction of maximum variation will not make the two classes discriminated in the lower dimensions compared to FDA.

Sometimes we could do clustering as a pre-algorithm. Or, we can incorporate side data and use labels in PCA in order to create a better dimensionality reduction. In these cases, we are more interested in finding subspaces which respect to the labels of the original data, instead of those that maximizes the variance.

In dimensionality reduction, we might have some "side information" or labels. In low dimension data, we want points with the same label to be close to each other. For example, a data set containing pictures of different faces can be divided into glasses/no glasses classes, or beards/no beards classes. KPCA may be able to distinguish some pre-specified features in the picture, while PCA could only give components that have max variance. In dimension reduction, we might have some "side information" or labels.

Problem Statement

Given a set of data [math](X,Y),\; X \in \mathbb{R}^p [/math] are p-dimensional explanatory variates and [math]Y\in \mathbb{R}^l[/math] l-dimensional response variables, the goal is to estimate a low-dimension subspace S such that S contains as much predictive information about the response variable Y as the original explanatory variable X.

Alternatively, given an i.i.d (independent and identically distributed) sample [math]\{(x_1,y_1), (x_2,y_2) \dots (x_N,y_N)\} [/math], we are looking for an orthogonal projection of X onto [math]S=U^T X[/math] such that Y depends mainly on [math]U^T X[/math].

Related Work

There are many families of algorithms to solve this problem, some of which are briefly described below.

Classical Fisher's discriminant analysis (FDA)

This algorithm is very famous, however it will not be covered in this class. This[14] is a brief introduction to FDA.

Metric Learning (ML)

Metric learning computes the Mahalanobis distance instead of Euclidean distance over the input space. The Mahalanobis distance is defined as

[math]d_A(x_i,x_j) = \|x_i,x_j\|_A = \sqrt{(x_i - x_j)^T A (x_i-x_j)}[/math]

where [math]A[/math] is a symmetric positive semi-definite matrix.

The matrix [math]A[/math] changes the definition of distance/similarity. The problem is then reduced to finding [math]A[/math].

The algorithm learns a linear transformation of the original inputs followed by Euclidean distance in the projected space. To see this, we know that [math]A[/math] is symmetric and positive semi-definite, and we can write it as [math]A=UU^T[/math] using Cholesky decomposition. Then

[math]d_A(x_i,x_j) = \sqrt{(x_i - x_j)^T A (x_i-x_j)} = \sqrt{(x_i - x_j)^T UU^T (x_i-x_j)} = \sqrt{(U^T x_i - U^T x_j)^T (U^T x_i- U^T x_j)}[/math]

which represents the Euclidean distance of [math]U^T x_i[/math] and [math]U^T x_j[/math].

Sufficient Dimension Reduction (SDR)

In sufficient dimension reduction, we attempt to find a linear subspace [math]S \subset X [/math] such that [math]P_{Y\mid X}(y\mid X) [/math] is preserved.

i.e [math]P_{Y\mid X}(y\mid X) = P_{Y\mid U^TX}(y\mid U^TX)\; \forall x,y[/math]

Supervised Principal Components (SPCA)

  • This version of Supervised Principal Components is different from the the Supervised Principal Component Analysis that we are going to talk about in this lecture. It is proposed by Bair er. al., and the original paper can be found here[15].
  • This method is commonly used in biostatistics, but it's different from the one we are covering this course.

1. Recall that in linear regression the coefficient for feature j is computed as:

[math]s_j = \dfrac{X_j^T Y}{\sqrt{X^T_jX_j}} [/math]

Note that [math]X[/math] doesn't have to be centered. This is essentially a measure of similarity between feature j (row j) and output Y.

2. Replace the data matrix so that it only consists of features for whom the absolute value of the calculated coefficients exceeds some determined threshold [math]\theta [/math].

3. Compute the first (few) principal components of the reduced data matrix.

4. Use the principal component(s) calculated in step 3 in a regression model or classification algorithm to predict the outcome.

Hilbert-Schmidt Independence Criterion (HSIC)

Two random variables [math]X\in \mathbb{R}^p[/math] and [math]Y\in \mathbb{R}^q[/math] are independent if and only if any bounded continuous function of them is uncorrelated.

If we map these random variables to reproduce kernel Hilbert spaces (RFHS), we can test for correlation. Problem: Given [math]{(x_1, y_1), . . . ,(x_m, y_m)}\∼ . Pr(x, y)[/math] determines whether [math]Pr(x, y) = Pr(x)Pr(y)[/math].

To do so, we define a RKHS [math]F:X\to \mathbb{R}[/math] containing all continuous bounded real-valued functions of x,

and a RKHS [math]G:Y\to \mathbb{R}[/math] containing all continuous bounded real-valued functions of y.

Let [math]Z:= \{(x_1,y_1),\dots, (x_n,y_n) \} \subseteq X\times Y [/math] be n independent observations from [math]\rho_{X,Y} [/math].

An estimator of HSIC is:

[math]HSIC:= \dfrac{1}{(n-1)^2}Tr(KHBH)[/math]

where [math] H,K,B \in \mathbb{R}^{n\times n}[/math], [math]K_{ij} = K(x_i,x_j) [/math] is a kernel of X, [math]B_{ij} = b(y_i,y_j) [/math] is a kernel of Y,and [math]H = I - \frac{1}{n}ee^T [/math] is the centering matrix. Note that k and b are positive semidefinite.

The HSIC is 0 if and only if X and Y are independent. Thus the estimator described above can be used to test for independence. For more details, see [16].

How far are two distributions from each other? A measure of similarity of P and Q is [math] X \sim P, Y \sim Q [/math] where P and Q are probability distributions. We can calculate the distance between distributions P and Q as follows:

[math]\mid P-Q \mid^2 = \mid \frac{1}{n}\sum \phi(x_i)-\frac{1}{m}\sum\phi (y_i) \mid^2[/math]
[math] = (\frac{1}{n}\sum \phi(x_i)-\frac{1}{m}\sum\phi (y_i))^T (\frac{1}{n}\sum \phi(x_i)-\frac{1}{m}\sum\phi (y_i))[/math]
[math] = \frac{1}{n^2} \sum K(x_i,x_j)+\frac{1}{m^2}\sum K(y_i,y_j) -\frac{2}{mn} \sum K(x_i,y_j)[/math]

So does the mean capture all the characteristics of the distribution in the higher dimensional space. The idea of this measure of distance is counter-intuitive at first glance, since it states that after mapping into high dimension space using [math]\phi(x) [/math], we can measure the distance of distribution by using the mean of the sample data points. It's difficult to find an explicit [math]\phi(x) [/math], but we can use kernel trick to solve the problem.

Note that, the mean in the original dimensions is not enough to capture the characteristics of the distribution. For example, the following figure shows a two different distributions with exact same mean but with different variance. So, say we have a point in 2 dimensions, the first dimension of the point is the mean and the second dimension of the point is the variance. So, this point captures these two characteristic of the distribution. So, in infinity dimension, a point can capture all momentum of the distribution and therefore, only mean in higher space can capture the characteristic of the distribution.

Now that we have a way to measure the distance between two distributions, we have a way to test for independence since:

[math]X, Y[/math] independent [math]\Rightarrow P_{X,Y}(x,y) = P_X(x)P_Y(y) \Rightarrow \mid P_{X,Y}(x,y)-P_X(x)P_Y(y) \mid = 0[/math]

Hilbert Schmidt Independence Criterion (Lecture 10: Oct. 20, 2014)

Introduction to the Hilbert Schmidt Independence Criterion (HSIC)

Last lecture we reviewed the background and set-up for SPCA. Given data, X, and a label, Y, if we want to maximize the dependence between X and Y, then we will need the Hilberts Schmidt Independence Criterion. When data are mapped through a file (eg a kernel), we hope that the data are linear with respect to the space, as well we hope the dependence is linear. However, some cases won't necessarily conform to these assumptions. This was explained last lecture with the example of two distributions with the same mean, but different variances.

Intuition: Two random variable x and y in [math]R^n[/math] are independent if and only if any bounded continuous function of them is uncorrelated

[math] |p-q|^2 [/math] measures distance between dimensions p and q. It also allows us to check independence since [math] p(x,y)=p(x)p(y) [/math] implies independence. We can re-write the distance equation to [math] |p(x,y)-p(x)p(y)|^2 [/math] where expanding [math] p(x,y)-p(x)p(y) [/math] gives the Hilbert Schmidt Independence Criterion (HSIC). This term is based on the norm of the covariance matrix in Hilbert space.

Derivation of HSIC

Goal: Given an [math]i.i.d[/math]. sample, [math]X[/math], and label, [math]Y[/math], we want an orthogonal projection of the data onto [math] U^TX [/math] such that [math]Y[/math] depends on [math]X[/math].

An estimator of [math]HSIC[/math] is given by:

[math]HSIC = \frac{1}{(n-1)^2} Tr(KHBH) [/math]
  • [math]K[/math] is a kernel over [math]X[/math], positive semidefinite
  • [math]B[/math] is a kernel over [math]Y[/math], positive semidefinite
  • [math]H[/math] is the centering matrix given by [math] H=I-\frac{1}{n} ee^T [/math]

We then want to maximize [math] U^TX [/math] such that it has the maximum dependency on [math]Y[/math]

This is done by:

  1. Compute the linear kernel of [math] U^TX [/math]
    [math] K_{n \times n}=X^TUU^TX [/math] is a [math]n \times n[/math] matrix
    notice the similarity to Kernel PCA, which finds [math] X^TX [/math], the linear kernel of [math] X [/math]
  2. Compute a kernel of labels [math] Y [/math]
    [math] B_{n \times n}=Y^TY [/math] is a [math]n \times n[/math] matrix
  3. According to HSIC, the dependence between [math] U^TX [/math] and [math] Y [/math] can be computed as
[math] \underset{U}{max} \; \frac{1}{(n-1)^2}Tr(X^TUU^THBH) [/math]
where [math] K_{n \times n}=X^TUU^TX [/math]
  • Since [math] \frac{1}{(n-1)^2} [/math] doesn't depend on [math]U[/math], we only need to maximize the trace, where the only unknown is [math]U[/math]
  • Hence
[math] \underset{U}{max} \; \frac{1}{(n-1)^2}Tr(X^TUU^THBH) [/math]

Since the trace of a matrix is invariant under cyclic permutations, this can be rewritten as:

[math] = \underset{U}{max} \; \frac{1}{(n-1)^2}Tr(HX^TUU^THB) [/math]
[math] = ... = \underset{U}{max}\; \frac{1}{(n-1)^2}Tr(U^TXHBHX^TU) [/math]
Letting [math]Q = XHBHX^T[/math], the problem becomes [math]\underset{U}{max} \; U^TQU[/math].
  • There is no upper bound on this optimization problem, so we need restrictions on [math]U[/math]
We can use [math] U^TU = I [/math] (a.k.a. [math]U[/math] is an orthogonal matrix) as our restriction, just like with [math]PCA[/math]
  • To optimise this problem, use the Lagrange Multiplier:
[math] L(U, \Lambda) = Tr(U_{}^TXHBHX^TU^T)-Tr(\Lambda(U^TU-I)) [/math]
[math] = Tr(U^TQU)-Tr(\Lambda(U^TU-I)) [/math]
Taking the derivative of this with respect to U and setting the derivative to zero yields
[math]2QU - 2\Lambda U = 0 [/math]
[math]QU = \Lambda U[/math]
[math](XHBHX^T)U = \Lambda U[/math]
Hence adding this restriction implies we need to find the [math]p[/math] largest eigenvectors of [math] XHLHX^T [/math] which is the optimal solution for U
  • [math] U^TX [/math] is the projection of X on a lower dimension space, but in this context we are ensuring it has maximum dependence on [math]Y[/math], rather than trying to maximize variance as with [math]PCA[/math]

Note that if [math]B=I[/math], then [math] X_{}HBHX^T = XHHX^T [/math]. Since this is now the sample covariance matrix of [math]X[/math], the solution to [math]SPCA[/math] will be identical to the solution to [math]PCA[/math]. Therefore [math]PCA[/math] is just [math]SPCA[/math] with the condition that [math]B=I[/math].

If [math]B=I[/math], then, because [math]B[/math] is the kernel over all the labels and so represents the similarity over labels, we are working only under the knowledge that each datum is similar to itself - we do not know how similar any datum is to another datum. This is how [math]PCA[/math] is conducted.
[math]SPCA[/math] is therefore [math]PCA[/math] with additional knowledge regarding similarity between data.

Algorithm for HSIC

  1. Recover basis
    Calculate [math]\; Q=XHBHX^T [/math]
    Define [math]U[/math] based on the top [math]p[/math] eigenvectors of [math]Q[/math] corresponding to the top p eigenvalues
  2. Encode training data
    Let [math]\; Y=U^TXH [/math] where [math]Y_{d \times n}[/math] is a [math]d \times n[/math] matrix
  3. Reconstruct training data
    [math] \hat{X} = UY = UU^TX [/math]
  4. Encode test example
    [math]\; y = U^T*(x-\mu) [/math] where [math] y [/math] is a [math]p[/math]-dimensional encoding of [math]x[/math]
  5. Reconstruct test example
    [math] x=Uy = UU^T(x-\mu) \;[/math]

Dual Supervised Principal Component Analysis

Recall how Dual PCA led to Kernel PCA. Dual PCA was based on cases where dimensionality is large, and hence the eigenvectors of [math] XX^T [/math] are hard to find. Instead, single value decomposition was used to decompose the data into [math] X = U \Sigma V^T [/math] where

U is the eigenvectors of [math] XX^T [/math]
V is the eigenvectors of [math] X^TX [/math]

re-arranging shows [math] U = XV \Sigma^{-1} [/math]

Similarly, we can decompose [math] Q = XHBHX^T [/math] instead of just decomposing [math] X [/math]. First we define

  • [math] Q = \Psi \Psi^T [/math]
  • [math] B = \Delta^T \Delta [/math]
  • [math] \Psi =XH \Delta^T [/math]

The solution for U can be decomposed from [math] \Psi =U \Sigma V^T [/math]

Kernel Supervised Principal Component Analysis (Kernel SPCA)

In Kernel SPCA, we maximize [math] Tr(U^TXHBHX^TU) [/math] subject to [math] U^TU=I [/math]. There is a trick to doing this: U can be written as a linear combination of all data.

[math] U = \underset{i}{\sum} \alpha_{i} \; x_i [/math]

which allows us to re-write our problem using dot product In matrix form, we assume that, for each column of U, there are n coefficients such that [math] U=X \beta [/math] where [math] U [/math] is d x p, [math] X [/math] is d x n, [math] \beta [/math] is n x p

  • Our objective function can be re-written in terms of [math] \beta [/math] as
[math] \underset{\beta}{max} \; Tr(U^{T}XHBHX^{T}U) [/math]
[math] = \underset{\beta}{max} \; Tr(\beta^TX^TXHBHX^TX\beta) [/math]
[math] = \underset{\beta}{max} \; Tr(\beta^TKHBHK\beta) [/math]
notice that [math] X^TX [/math] and [math] XX^T [/math] are our linear kernel: [math] \psi (x^T) \psi (x) = \psi (x) \psi (x^T) [/math]
  • Our constraint term can be re-written in terms of [math] \beta [/math] as:
[math] U^TU=I [/math] which implies [math] \beta^TX^TX \beta = I [/math] which implies [math] \beta^T K \beta = I [/math]

Therefore the new optimization problem is [math] \underset{\beta}{max} \; Tr( \beta^TKHBHK \beta) [/math] subject to [math] \beta^T K \beta = I [/math]

Here we don't have [math]X[/math], but rather we have [math]KK[/math]. If we were to write the Lagrange multiplier, we can see that the solution to this problem is the generalized eigenvectors of [math] HBHK [/math]:
[math] \; L(\beta) = Tr( \beta^T KHBHK \beta ) - \lambda Tr( \beta^TK \beta - I) [/math]
[math] \frac{\partial L}{\partial \beta} = 2KHBHK \beta - 2 \lambda K \beta = 0[/math]
[math] let \; Q=KHBHK [/math]
this implies that [math] Q \beta = \lambda K \beta [/math]
Notice that if this was just [math] Q \beta = \lambda \beta [/math], then Q would be the eigenvectors, and [math] \lambda [/math] the eigenvalues of [math] \beta [/math]. However, since we instead have [math] \lambda K [/math], we are solving for the generalized eigenvectors of [math] Q=HBHK [/math]
Therefore the solution will be the top p eigenvectors of the generalized eigenproblem [math] eigen(Q,K) [/math]

In high dimensional space, X isn't explicitly available. So, if we denote [math] X \mapsto\Phi(X) [/math], then [math] U= \Phi(X) \Beta [/math], but we don't have X. Therefore we need to project [math] \Phi(X) [/math] to a lower dimension space and compute
[math] Y=U^T \Phi(X) = \beta^T \Phi^T(X) \Phi(X) = \beta^T K [/math] where [math] Y [/math] is p x n, [math] \beta^T [/math] is p x n, and [math] K [/math] is n x n.

To project an out-of-sample point, x, we have:

[math] y=U^T \Phi(x) = \beta^T \Phi(X) \Phi(x) = \beta^T K_{test} [/math] where
  • [math] X [/math] is the training data
  • [math] x [/math] is the test data
  • [math] K_{test} [/math] is the kernel between the training and test data. (ie. it codes how similar the training and test data are)

Note: There is an alternative way to derive the Kernel SPCA, which will be shown on Assignment 2

Algorithm for Kernel SPCA


  • [math] \mathbf{K} [/math] the kernel matrix of the training data
  • [math] \mathbf{K_{test}} [/math] the kernel matrix of the test data
  • [math] \mathbf{B} [/math] kernel matrix of target variable

Note: in lecture note professor use [math] \mathbf{L} [/math] to represent the kernel of target variable. For consistency reason I keep using [math] \mathbf{B} [/math] instead.

  • [math] \mathbf{x} [/math] testing example
  • [math] \mathbf{n} [/math] training data size


  • [math] \mathbf{X} [/math] dimension reduced training data
  • [math] \mathbf{z} [/math] dimension reduced test data

  1. Define: [math] H = I - \frac{1}{n}ee^T [/math] and [math] Q = KHBHK [/math]
  2. Compute basis: [math] \beta_{n \times p} [/math], the top [math]p[/math] generalized eigenvectors of [math]Q[/math] and [math]K[/math]
  3. Encode the training data: [math] Z = \beta^T \Phi^T(X) \Phi(X) = \beta^TK [/math]
  4. Encode the test example: [math] z = \beta^T \Phi^T(X) \Phi(x) = \beta^TK_{test} [/math]

Experimental Results Visualization

The following images are the 2-dimensional projections to the Iris flower data set produced by (in order from left to right): i. Supervised PCA with [math]L = I[/math]; ii. Bair's SPC; iii. Kernel Dimension Reduction; iv. Kernel Supervised PCA

Comparing the different 2-dimensional projections of the Iris flower data set, image taken from here

The following are two more examples to show the effects of the 4 projections on different data sets. We are going to use the Binary XOR dataset and the Concentric Ring dataset to demonstrate.

The Binary XOR dataset
Original form of the Binary XOR dataset
The original form of Binary XOR data set, image taken from here

An 1-dimensional Gaussian noise is added to the dataset before projected to 2-dimensional space.
2-dimensional projections of the Binary XOR dataset produced by (in order from left to right): i. Supervised PCA with [math]L = I[/math]; ii. Bair's SPC; iii. Kernel Dimension Reduction; iv. Kernel Supervised PCA
File:binaryxor all.png
Comparing the different 2-dimensional projections of the Binary XOR data set, image taken from here

The Concentric Ring dataset
Original form of the Concentric Ring data set
The original form of Binary XOR data set, image taken from here

2-dimensional projections of the Concentric Ring dataset produced by (in order from left to right): i. Supervised PCA with [math]L = I[/math]; ii. Bair's SPC; iii. Kernel Dimension Reduction; iv. Kernel Supervised PCA
Comparing the different 2-dimensional projections of the Concentric Ring data set, image taken from here

SPCA continued and Metric Learning(Lecture 12: Oct. 22, 2014)

SPCA continued

How to solve sparse matrix problem.

Metric Learning



Some ways to minimize objective function

Some versions of constraint