*This post assumes familiarity with the terminology and notation of linear algebra, particularly inner product spaces. Fortunately, we have both a beginner’s primer on linear algebra and a follow-up primer on inner products.*

## The Quest

We are on a quest to write a program which recognizes images of faces. The general algorithm should be as follows.

- Get a bunch of sample images of people we want to recognize.
- Train our recognition algorithm on those samples.
- Classify new images of people from the sample images.

We will eventually end up with a mathematical object called an *eigenface*. In short, an eigenface measures variability within a set of images, and we will use them to classify new faces in terms of the ones we’ve already seen. But before we get there, let us investigate the different mathematical representations of images.

## God has given you one face, and you make yourself a vector

Most naturally, we think of an image as a matrix of pixel values. For simplicity, we restrict our attention to grayscale images. Recall that a pixel value in the standard grayscale model is simply an unsigned byte representing pixel intensity. In other words, each pixel is an integer ranging from 0 to 255, where 0 is black and 255 is white. So every image corresponds bijectively to a matrix with integer entries between 0 and 255.

Representing an image as a matrix reminds us of the ubiquitous applicability of linear algebra. Indeed, we may learn a great deal about our image by representing it with different bases or querying pixel neighbors. We can find frequencies, detect edges, and do a whole host of other fascinating things. However, we aren’t only concerned with the properties of one picture. In fact, individual pictures are useless to us! We only care about the relationships between a set of pictures, and we want to be able to compute “how similar” two faces are to each other.

In other words, we want a face space.

So instead of representing our images as a matrix, let’s represent them as points. Given an matrix with entries , we simply “collapse” the rows of a matrix into a single row like so:

Now we have our face space: . Note that even for small images, this space is huge. For example, with images of size , this space has ten-thousand dimensions! Certainly, reasoning about such objects would be impossible without a computer, but even then, we will run into trouble.

In order to translate back and forth between the standard matrix representation and the vector representation, we present the following Mathematica code. As always, the full notebook including all the code we provide here is available on this blog’s Github page.

imageToVector[img_] := Flatten[ImageData[img]]; vectorToImage[vec_, {n_, m_}] := Image[Partition[vec, m]];

Now all we need is a set of example faces. We found such an example from a facial recognition research group, and we posted the images on our Google code page. It contains a large number of images of size pixels. Here are a few samples:

This bounty of data is excellent. Now we may begin to play.

## Mean Faces

In order to classify faces we would like to investigate the distribution of faces in face space. We start by computing the “mean face,” which represents the center of gravity of our sample of faces. We can do this simply by averaging the values of each pixel across all our face images.

We start by selecting a sample of male faces, at most one for each person in our database, and transforming them to grayscale:

(* This directory is particular to my file system. Change it appropriately. *) files = Import["~/downloads/faces94/male"][[1 ;; -1 ;; 30]]; faces = Map[Import["~/downloads/faces94/male/" <> #] &, files]; grayFaces = Map[ColorConvert[#, "Grayscale"] &, faces];

Then, we construct a vector with the average pixel intensity values for each pixel:

meanImage = Image[ Apply[Plus, Map[ImageData, grayFaces]] / Length[grayFaces] ]

ImageData accepts an image object (as represented in Mathematica) and returns the matrix of pixel values. Note that for this particular operation, which is just adding and dividing, it is unnecessary to translate faces from matrices to vectors.

The result is the following image:

Honestly, for a mean face I expected something more sinister. Just for kicks, let’s watch the averaging process incrementally:

This is a nice (seemingly fast) convergence. We casually wonder how much this particular image is subject to change with data coming from different cultures, as most of our data are twenty- or thirty-something white males.

Now that we have a mean, we may calculate the deviations of each image from our mean. Again, this is a simple subtraction of pixel values, which does not require special representation.

differenceFaces = Map[ImageSubtract[#, meanImage]&, grayFaces];

And get some pictures that look like these:

Don’t they look much nicer now that we’ve subtracted off the mean face? In all seriousness, we call these *difference faces*.

As one can see, some of these difference faces are darker than others. For whatever reason (perhaps some faces are in slightly more agreeable positions), the lighter faces are more “unique” in this sample of faces. We will see this notion come up again when we compute the actual eigenfaces: some will resemble the more variable faces.

While this is fine and dandy, we don’t yet have a way to recognize anybody. For this, we turn to statistics.

**Covariance**

We may interpret our face vectors in face space as a distribution of random variables which are precisely the people in the training sample. Specifically, when we try to classify a new face, we want to calculate the distance of that face from each of our training faces, and infer how likely it is to be a specific person.

In reality, however, since our faces are points in a space of dimensions, we have random variables: one for each coordinate axis. While we recognize that this is far too many variables for us to do any computations with, we play along for now.

Taking our cue from statistics, we want to investigate the variability of the set of face vectors. To do this we use a special matrix called the *covariance matrix* of our distribution.

**Definition**: The *covariance* of two variables, denoted , is the expected value of the product of their deviations from their means: .

Colloquially, the covariance measures the relationship between how two variables change. A high positive covariance means that a positive change in one variable correlates to a positive change in the other. A highly negative covariance implies a positive change in one variable correlates to a negative change in the other. If the two variables are independent, then their covariance is zero, though the reverse implication is not true in general.

As an example, consider the following distribution of points in the plane:

This distribution clearly has a nontrivial covariance in the and variables. It looks like an ellipse on a tilted axis signified by the two black arrows. In fact, we will soon be able to calculate those arrows; they have very special significance for us.

So just finding the variance of and (as in the coordinate axes) is not enough to fully describe this distribution. We need three numbers: the variance of , the variance of , and the covariance of . As a side note, the *variance* of a variable is equivalently the covariance of that variable with itself.

We represent these three pieces of data in a *covariance matrix*, which for the two variables above has the form:

Since the “Cov” as a function is symmetric in its arguments, we see that every covariance matrix is symmetric. This will have important implications for us, as symmetric matrices have a rich theory for us to exploit.

Once we compute the covariance matrix of our two variables, we want to describe the variance in terms of the “axes” as above. In other words, if we could just tilt, stretch, and move the data the right way, we could put it back on top of the normal unit coordinate axes and . The process we just described is precisely a linear map that performs a change of basis. In particular, those two black arrows constitute the best basis to describe the data. So if we could just compute the right basis, we’d know everything about our distribution!

Now it’s no coincidence that the particular basis above is so nice. Specifically, if we consider our random variables as unit measurements along those axes (remember, one axis is stretched, so a unit measurement is longer there), then the two variables have *zero* covariance. In particular, the covariance matrix of the random variables in that basis is diagonal! Recalling that if a matrix has a diagonal representation, then the basis for that representation is a basis of eigenvectors. Hence, we see that computing any basis of eigenvectors will give us our optimal basis, should one exist.

And now, the coup de grâce, we recall that every symmetric real-valued matrix, and hence every covariance matrix, has an orthonormal basis of eigenvectors! This is a special case of the spectral theorem, which we discuss in our primer on inner product spaces.

So now we have proven that for any distribution of data in random variables, we may describe them with a basis of eigenvectors, such that the variables are pairwise uncorrelated. Let’s apply this to our face space.

## Methinks no eigenface so gracious is as mine

In one mindset, we may compute the covariance matrix of our difference faces quite easily:

differenceVectors = Map[imageToVector, differenceFaces]; covarianceMatrix = Transpose[differenceVectors].differenceVectors;

For the Java coders, note that the dot notation is for vector products; Mathematica is not object oriented, but rather it is functional with built in hash maps for mutation. Furthermore, in it’s raw form the “differenceVectors” variable is a 76-element list of face vectors.

These dot products, however, are precisely the computations of covariance, since each dot product computed is between two difference face vectors, each component of which is one of our random variables. Perform a few of the computations by hand (on a smaller matrix, obviously!) to convince yourself that it is so. The entry of our resulting covariance matrix is just .

Here we are multiplying a matrix (76 face vectors of length 36,000) by a matrix, resulting an a matrix. While we could theoretically compute the eigenvalues and eigenvectors of this matrix directly, in reality even the matrix multiplication to construct the matrix uses up all available memory and crashes the Mathematica kernel (how wimpy my netbook is that it can’t handle a billion-entry matrix!). In any case, we need another way to get our eigenvectors.

Again going back to linear algebra, we have a few useful propositions:

**Proposition**: If is a real matrix, then and are symmetric square matrices.

*Proof*. The squareness of these products is trivial. We prove symmetry of the first, and note the argument is identical for the second.

Here symmetry is equivalent to . We can see this immediately by using properties of transposition. Alternatively, we can note that the entry of the left side is the dot product of the th row of with the th row of . On the other hand, the entry is the dot product of the th column of and the th column of . Since the two factors are transposes of each other, the th row of is equal to the th column of , and similarly for the s. In other words, the dot products described for the and entries are dot products of the same two vectors, and are hence equal.

In particular, we will use the symmetry about the smaller to get information about the eigenvectors of the larger . We just need the following proposition:

**Proposition**: Let a real matrix have dimension , where (here a transposition of maintains generality). Then the number of eigenvectors with nonzero eigenvalue of is no greater than the number of eigenvectors with nonzero eigenvalue of

In particular, the eigenvectors with zero eigenvalues are removable; they correspond to zero variability of a face in that particular direction. So for our purposes, it suffices to find the eigenvalues with nonzero eigenvalue. As we are about to see, this is generally much smaller than the total number of eigenvectors. In fact, the result above follows from a stronger statement:

**Proposition**: If is an eigenvector with nonzero eigenvalue of , then is an eigenvector with the same eigenvalue of .

*Proof*. Letting be such an eigenvector, with corresponding eigenvalue , we have , and hence

This completes the proof.

By the same reasoning, if is an eigenvector with nonzero eigenvalue of , then is an eigenvector of .

Now we have just given a bijection between the eigenvectors with nonzero eigenvalue of and the much smaller ! This is great, because if we compute in our face problem, the former is a mere matrix! Computing the eigenvectors is then a one-line affair, utilizing Mathematica’s fast library for it:

eigenfaceSystem = Eigensystem[covarianceMatrix];

This returns the eigenvalues in decreasing order, with their corresponding eigenvectors attached. Note that we still need to multiply them by the transpose of our “differenceVector” matrix.

The astute reader will notice that we named these eigenvectors *eigenfaces*. Though they are indeed just plain old eigenvectors, they have a special interpretation as images. Reforming them as grayscale pictures, and scaling the values to , we reveal truly haunting faces:

As creepy as they look, one must recall their astonishing interpretation: each ghostly face represents a random variable and the largest change of that random variable along its axis. Specifically, by finding these eigenfaces, we translated our notion of dimension from having one for each pixel to having one for each *person* in our training set, and these eigenfaces represent shared variability among the faces of those people. In other words, these faces represent the largest similarities between some faces, and the most drastic differences between others. This is one of the most stunning visualizations of dimension this mathematician has ever seen.

## This Face is Your Face, This Face is My Face

Though we only display a few above, we computed a basis of 76 different eigenfaces. Call the subspace spanned by these basis vectors (which is certainly a small subspace of ) the *eigenface subspace*. For the purpose of learning new faces, we may reduce face space to the eigenface subspace, and hence represent any face as a linear combination of the eigenfaces.

To do this, we recall once again that the spectral theorem not only provided us a basis of eigenvectors, but it guaranteed that this basis is orthonormal. Recalling our primer, the projections of a vector onto elements of an orthonormal basis give us the needed coefficients for that vector’s expansion. If we label our eigenfaces , then any face can be decomposed as

Here since we are working within , we may simply use the standard dot product as our inner product. Hence, in Mathematica the coefficients are easy to compute:

projectImageToFaceSpace[image_, meanImage_, eigenfaces_]:= Module[{imageVec, diffVec, meanVec}, imageVec = imageToVector[image]; meanVec = imageToVector[meanImage]; diffVec = imageVec - meanVec; Map[(diffVec.#)&, eigenfaces] ];

For the following face, we present its coefficients when projected onto each of the 76 eigenfaces, in order by decreasing eigenvalues.

coefficients = {-6.85693, 23.7498, -11.4515, -3.43352, 5.24749, -7.1615, 8.09015, -9.7205, -0.660834, -2.4148, -10.3942, 3.33424, 2.94988, -2.75981, 3.02687, -2.4499, -2.09885, -5.98832, -4.22564, -0.65014, 2.20144, -5.43782, -9.61821, -3.25227, 7.49413, -0.145002, 7.61483, -0.696994, -3.7731, 3.23569, -1.78853, 0.0400116, -3.86804, -2.02456, 2.20949, -1.86902, 1.23445, 0.140996, 0.698304, -0.420466, 2.30691, 3.70434, 1.02417, 0.382809, 0.413049, -0.994902, 0.754145, 0.363418, -0.383865, 1.46379, 1.96381, -2.90388, -2.33381, -0.438939, -0.30523, -0.105925, 0.665962, -0.729409, -1.28977, 0.150497, 0.645343, 0.30724, -1.04942, 1.0462, -0.60808, 0.333288, 1.09659, -1.38876, 0.33875, 0.278604, 1.0632, -0.0446148, 0.24526, -0.283482, -0.236843, 0.312122};

And with the following piece of code, we can reconstruct the image exactly from the eigenfaces:

vectorToImage[ imageToVector[meanImage] + Apply[Plus, coefficients*eigenfaces], {200, 180}]

While this is fine and dandy, we can do better computationally. As the magnitude of an eigenface’s corresponding eigenvalue decreases, we see, both visually and mathematically, that the eigenface contributes less to the overall variability of the distribution of faces. In other words, we can shed some of the shorter coordinate axes and still retain most of our description of face space!

Here is an animation of the face reconstruction where we choose the first eigenfaces (i.e., with the largest corresponding eigenvalues), and increase :

We notice some “pauses” in the animation, which correspond to either very small coefficients or eigenfaces which only have small regions of variability.

Unfortunately, and this is in the author’s opinion an inherent wishy-washiness of applied mathematics, how many eigenfaces to use is an empirically determined variable. Exercising our best judgement, we find that the image reconstruction is easily recognizable after 30 eigenfaces are used (about seven seconds into the animation above), so we use those for our reduced eigenface subspace.

## Recognition Procedure

Now, to polish off our discussion, we have the quite simple recognition procedure. Once we have projected every sample image into the eigenface subspace, we have a bunch of points in .

When given a new image, all we need do is project it into face space, and find the smallest distance between the new point and each of the projections of the sample images. We do so in the Mathematica notebook (available from this blog’s Github page), and also run the recognition procedure on some pictures of the training subjects not used in training.

The reader is invited to look at the results, and see what sorts of changes in appearance mess up recognition the most. As a sneak preview, it seems that head-tilting, eye-closing, and smiling account for a lot of variability. If the reader is a fugitive on the run (and somehow find’s time to read this blog; I’m so honored!), and wishes to have his photograph not recognized, he should smile, tilt his head, and blink vigorously while the photograph is being taken. Additionally, to avoid detection, he should split some of his heist money with the author.

We notice one additional problem: in our haphazard way of selecting individuals for training and evaluation, we mistakenly attempted to classify some individuals that were never in a training photo. What’s worse, is that some of these men look strikingly similar to different people who *were* used in the training photos, with obvious differences like ears which stick out or thicker noses.

To handle subjects who were not in training, we need a category for those individuals who could not be classified. This is straightforward enough; we just have a minimum threshold. If an image is not within, say 25 units of any of our training faces, then it cannot be classified. This threshold can only be chosen empirically, which is again an unfortunate consequence of moving from pure mathematics to the real world.

With this modification, we see that our final evaluation sample of thirty faces, three of which were not in the original training set, results in only two false positive matches, and one false negative. This method appear to be relatively robust, considering its simplicity.

For more precise results, the reader is encouraged to play with the data and run larger tests. The faces used are organized by gender and name in a downloadable zip file on this blog’s Github page. The archive contains about twenty photos for each individual, and about eighty individuals. Have a blast!

## An Alternative Metric

While Euclidean distance is fine and dandy, there are a whole host of other methods for classifying points in Euclidean space. One could potentially train a neural network to perform classification, or dig deeper down the linear algebra rabbit hole and run the points through a support vector machine. Of course, with the rich ocean of literature on classification problems, there are likely many other applicable methods that the reader could explore. [Note: we intend to cover both neural networks and support vector machines on this blog in due time.]

However, there is one less drastic change we can make in our recognition procedure: ditch Euclidean distance. We may want to do so because our axes (the eigenfaces, which recall are eigenvectors of random variables), are at different scales. Euclidean distance hence treats one unit along a short axis as importantly as it treats a fraction of a longer axis. But the distances along shorter axes are more variable, and hence a small change there should mean more than it does elsewhere. This simply cannot do.

Our remedy is the Mahalanobis metric. It is specifically designed to utilize the covariance matrix to measure weighted distances.

**Definition**: Given a covariance matrix , the Mahalanobis metric is defined as

However, since our covariance matrix is diagonal (using our basis of eigenvectors, the entries are just the corresponding eigenvalues), is easy to compute: we just invert each diagonal entry. We encourage the reader to compare the two distance metrics’ performance in eigenface recognition. Augmenting our Mathematica notebook to do so should not require more than a few lines of code.

Finally, a few extensions and modifications of the eigenface method have popped up since their conception in the late 1980′s. In particular, they seek to compensate for the eigenface approach’s weakness to changes in lighting, orientation, and scaling. One such method is called “fisherfaces,” another “eigenfeatures,” and yet another the “active appearance model.” The latter two appear to map out “landmarks” on the image being processed, combining traditional facial metrics or anomalies with the eigenface decomposition technique. This author may return to an investigation of other facial recognition systems in the future, but for now we have too many other ideas.

## Additional Uses

The eigenface method for facial recognition hints at a far more general technique in mathematics: breaking an object down into components which yield information about the whole. This is everywhere in mathematics: group theory, Fourier analysis, and of course linear algebra, to name a few. For linear algebra, the method is called *principal component analysis*, and this method has wide application in both statistics and machine learning methods in general (which are nowadays largely statistical procedures anyway).

Aside from using eigenfaces to classify faces or other objects, they could be used simply for facial detection. The projection of a facial image into face space, whether the image is used for training or not, will almost always be relatively close to some training image. While the distance might not be small enough to determine a person’s identity, it is usually close enough to determine whether the image is of a face. We encourage the reader to use our code to write a function for facial detection. We anticipate it require less than twenty lines of code, and it should be very similar to our function for classification.

Another simplified application is to classify gender. We casually wonder if it would be more robust, and point the reader to this paper on it. The researcher here has a shockingly high-quality data set, and he also tries his hand on some general, low-quality data sets. It’s a good, quick read for one who has absorbed the content here.

Finally, eigenfaces can also be used as a method for image compression. Since we reduce an image to the 76 coefficients used to rebuild it from the eigenfaces, we see that an image is compressed from being 36,000 bytes to 76 floats. With a large collection of thousands of images and an agreeable tolerance for image approximation, eigenfaces could save quite a lot of space.

So we see that even though our original task was to classify faces, we have stumbled upon a whole host of other solutions to problems in computer science. Indeed, a method for image compression is quite far from the pure mathematics of orthonormal eigenvector bases. We attribute the connections to the beauty of mathematics and computer science, and look forward to the next time we may witness such a connection.

Until then!

Very interesting! I am looking forward to the article about neural networks!

This is one of the most interesting real life-applications of mathematics I’ve read about. Great work!

This must be one of the most interesting math blogs I’ve stumbled upon. Hope to see more posts soon.

Pingback: Eigenfaces Talk – Wednesday at 4p | Math ∩ Programming

Pingback: Row Reduction Over A Field | Math ∩ Programming

Pingback: Numerical Integration | Math ∩ Programming

I am going to have to do a lot of reading and learning before I can get to the bottom of this page!

This was my run in with facemath: http://neuraloutlet.wordpress.com/2011/11/25/morph-maths/

So basic in comparison! haha

Well the proof stuff just fills in the details as to

whyit works, and the rest of it is how to make the problem computationally tractable. If you want a primer on the linear algebra, I have two that start from scratch and provide all the relevant background mathematics. Feel free to drop a comment if you give it a read and something is unclear.Pingback: Principal Component Analysis | Math ∩ Programming

Excellent explanation and visualizations, great work!

The .zip file of faces seems to be corrupt: neither Archive Utility nor StuffIt Expander can unpack it on my mac.

I used the unix utility zip(1) to archive them, so you could use unzip to decompress it (I believe OS X has that in its terminal). Alternatively, I just posted a .tar.gz archive of the same contents.

Pingback: Hackaday Links: October 6, 2012 - Hack a Day

Pingback: Hackaday Links

Pingback: Hackaday Links: October 6, 2012 | Orange Claymore Red Slime

Pingback: Matemáticas y programación | CyberHades

The paper you linked on classifying gender is quite interesting. The data set it was based on had fallen off the web, but I corresponded with Dr. Hundler, the original researcher, and he’s put it back up online here: http://people.whitman.edu/~hundledr/data.html He’s skeptical about the results from that paper. He thinks the fact that his data set was useful for gender classification was a fluke based on the accidental separation of these particular faces in face space.

Interesting. In my opinion gender is closer to a continuum than a separable notion, and in particular sex is not uniquely determined by one’s facial appearance (even in the typical case where one does not try explicitly to modify their perceived gender). But I stumbled across the paper and thought it seemed interesting that there was any progress on that problem. Even if a solution might only give 60% correct classification, that’s still statistically significant. Of course it would be a shame if those results relied on the data set used.

Pingback: Probability Theory — A Primer | Math ∩ Programming

Amazing text! I think this exact method could be applied in fingerprints matching and many other biometric comparisons. But i think other biometric recognitions would be harder, since it’s quite easy to imagine a “mean face”, but not a “mean fingerprint” and similar ‘almost unique’ subjects.

In these cases maybe a more direct comparison between pixel matrices works better. Ironic how this method works fine on hard spaces, but may fail on easy cases, as recognizing a letter from alphabet.

So the idea is easily generalizable to work with any data, and it’s official name is Principal Component Analysis. Indeed, this technique has been applied to fingerprinting, see for example this paper.

On the other hand, it’s very unusually the case that direct pixel comparisons give a good answer, especially on things like fingerprints which have a lot of fine detail.

“To do this, we recall once again that the spectral theorem not only provided us a basis of eigenvectors, but it guaranteed that this basis is orthonormal.”

Yes, but the eigenvectors were obtained from $(differenceVector)^Tv$. How do you know that this particular eigenvector basis is ortonormal? Not all eigenvector basis are ortonormal. In this case, they can be just otrogonal.

Yes, you’ve identified a gap. This is a detail of the way Mathematica computes eigensystems of symmetric matrices. It uses a method with the awfully undescriptive name ‘dsyevr‘. However, even if Mathematica didn’t guarantee an orthogonal basis as output, we could use the Gram-Schmidt process to transform any basis into an orthonormal one.

“… corresponding eigenvectors attached. Note that we still need to multiply them (normal eigenvectors) by the transpose of our “differenceVector” matrix.”

But even if Mathematica gives us normal eigenvectors, when you multiply them by transpose they are no longer normal eigenvectors, right?

The whole point of the few preceding propositions is that multiplication by A^T provides a bijection between the sets of eigenvectors.

If they were ortonormal, i think Euclidean distance metric should be fine, wouldnt it?

This is excellent! Thanks much! I used your scary eigenfaces pic in a conference talk on sparse and low-rank problems in machine learning, super awesome.

Pingback: Eigenfaces and Forms – wellecks

Pingback: How to Conquer Tensorphobia | Math ∩ Programming

I wrote a web page that allows you to tweak the coordinates of a 60-dimensional face projection and thereby navigate face space. You can start with the mean face. You can even start with your own face if you download our iPhone app (free). Have fun!

Web page: http://facefield.org/SynthFace.aspx

iphone app: https://itunes.apple.com/us/app/anti-face/id690376775

Very cool!

Pingback: Correlation matrix for eigenfaces – Java | StackAnswer.com