Viola–Jones object detection framework


The Viola–Jones object detection framework is the first object detection framework to provide competitive object detection rates in real-time proposed in 2001 by Paul Viola and Michael Jones. Although it can be trained to detect a variety of object classes, it was motivated primarily by the problem of face detection.

Problem description

The problem to be solved is detection of faces in an image. A human can do this easily, but a computer needs precise instructions and constraints. To make the task more manageable, Viola–Jones requires full view frontal upright faces. Thus in order to be detected, the entire face must point towards the camera and should not be tilted to either side. While it seems these constraints could diminish the algorithm's utility somewhat, because the detection step is most often followed by a recognition step, in practice these limits on pose are quite acceptable.

Components of the framework

Feature types and evaluation

The characteristics of Viola–Jones algorithm which make it a good detection algorithm are:
The algorithm has four stages:
  1. Haar Feature Selection
  2. Creating an Integral Image
  3. Adaboost Training
  4. Cascading Classifiers
The features sought by the detection framework universally involve the sums of image pixels within rectangular areas. As such, they bear some resemblance to Haar basis functions, which have been used previously in the realm of image-based object detection. However, since the features used by Viola and Jones all rely on more than one rectangular area, they are generally more complex. The figure on the right illustrates the four different types of features used in the framework. The value of any given feature is the sum of the pixels within clear rectangles subtracted from the sum of the pixels within shaded rectangles. Rectangular features of this sort are primitive when compared to alternatives such as steerable filters. Although they are sensitive to vertical and horizontal features, their feedback is considerably coarser.

Haar Features

All human faces share some similar properties. These regularities may be matched using Haar Features.
A few properties common to human faces:
Composition of properties forming matchable facial features:
The four features matched by this algorithm are then sought in the image of a face.
Rectangle features:
An image representation called the integral image evaluates rectangular features in constant time, which gives them a considerable speed advantage over more sophisticated alternative features. Because each feature's rectangular area is always adjacent to at least one other rectangle, it follows that any two-rectangle feature can be computed in six array references, any three-rectangle feature in eight, and any four-rectangle feature in nine.

Learning algorithm

The speed with which features may be evaluated does not adequately compensate for their number, however. For example, in a standard 24x24 pixel sub-window, there are a total of possible features, and it would be prohibitively expensive to evaluate them all when testing an image. Thus, the object detection framework employs a variant of the learning algorithm AdaBoost to both select the best features and to train classifiers that use them. This algorithm constructs a “strong” classifier as a linear combination of weighted simple “weak” classifiers.
Each weak classifier is a threshold function based on the feature.
The threshold value and the polarity are determined in the training, as well as the coefficients.
Here a simplified version of the learning algorithm is reported:
Input: Set of positive and negative training images with their labels. If image is a face, if not.
  1. Initialization: assign a weight to each image.
  2. For each feature with
  3. # Renormalize the weights such that they sum to one.
  4. # Apply the feature to each image in the training set, then find the optimal threshold and polarity that minimizes the weighted classification error. That is where
  5. # Assign a weight to that is inversely proportional to the error rate. In this way best classifiers are considered more.
  6. # The weights for the next iteration, i.e., are reduced for the images that were correctly classified.
  7. Set the final classifier to

    Cascade architecture

In cascading, each stage consists of a strong classifier. So all the features are grouped into several stages where each stage has certain number of features.
The job of each stage is to determine whether a given sub-window is definitely not a face or may be a face. A given sub-window is immediately discarded as not a face if it fails in any of the stages.
A simple framework for cascade training is given below:
F = 1.0; D = 1.0; i = 0
while F > Ftarget
increase i
n = 0; F= F
while F > f × F
increase n
use P and N to train a classifier with n features using AdaBoost
Evaluate current cascaded classifier on validation set to determine F and D
decrease threshold for the ith classifier
until the current cascaded classifier has a detection rate of at least d × D
N = ∅
if F > Ftarget then
evaluate the current cascaded detector on the set of non-face images
and put any false detections into the set N.
The cascade architecture has interesting implications for the performance of the individual classifiers. Because the activation of each classifier depends entirely on the behavior of its predecessor, the false positive rate for an entire cascade is:
Similarly, the detection rate is:
Thus, to match the false positive rates typically achieved by other detectors, each classifier can get away with having surprisingly poor performance. For example, for a 32-stage cascade to achieve a false positive rate of, each classifier need only achieve a false positive rate of about 65%. At the same time, however, each classifier needs to be exceptionally capable if it is to achieve adequate detection rates. For example, to achieve a detection rate of about 90%, each classifier in the aforementioned cascade needs to achieve a detection rate of approximately 99.7%.

Using Viola–Jones for object tracking

In videos of moving objects, one need not apply object detection to each frame. Instead, one can use tracking algorithms like the KLT algorithm to detect salient features within the detection bounding boxes and track their movement between frames. Not only does this improve tracking speed by removing the need to re-detect objects in each frame, but it improves the robustness as well, as the salient features are more resilient than the Viola-Jones detection framework to rotation and photometric changes.

Implementations