# Understanding the Difference Between HOG and CNN Models for Face Detection

> Discover the HOG vs CNN face detection difference. Learn how HOG offers fast CPU detection and CNN delivers superior GPU-accelerated accuracy for your projects.

- Repository: [Adam Geitgey/face_recognition](https://github.com/ageitgey/face_recognition)
- Tags: deep-dive
- Published: 2026-03-06

---

**The `face_recognition` library provides HOG for fast, CPU-only detection using classic computer vision algorithms, while CNN offers higher-accuracy deep learning detection that requires GPU acceleration for optimal performance.**

The `ageitgey/face_recognition` library abstracts two fundamentally different approaches to face detection behind a single API. Understanding the difference between HOG and CNN models for face detection allows you to balance speed against accuracy based on your hardware constraints and application requirements. Both implementations wrap dlib's detectors and are selectable via the `model` parameter in the core API.

## Algorithmic Foundations

### HOG (Histogram of Oriented Gradients)

**HOG** is a classic computer-vision feature descriptor that computes gradient orientation histograms across a sliding window. This traditional method relies on manually engineered features to identify face-like patterns in images. It processes images through simple mathematical operations without requiring learned parameters, making it lightweight and deterministic.

### CNN (Convolutional Neural Network)

**CNN** refers to a deep-learning model trained on large face datasets, where the network learns hierarchical features automatically through convolutional layers. Unlike HOG's fixed algorithmic approach, the CNN model adapts to complex patterns, enabling it to detect faces under challenging conditions such as heavy occlusion, extreme angles, or poor lighting.

## Performance and Hardware Requirements

The primary distinction between these models lies in their hardware utilization and speed characteristics:

- **HOG** operates purely on CPU using simple gradient calculations, making it extremely fast on standard processors and ideal for environments without GPU access, such as Raspberry Pi devices.
- **CNN** is designed for CUDA-capable GPUs and runs significantly slower on CPU-only machines. The model requires the dlib CNN face-detector file (`mmod_human_face_detector.dat`) and benefits from batch processing capabilities when GPU memory is available.

## Accuracy and Detection Capabilities

Accuracy trade-offs vary significantly between the two approaches:

- **HOG** performs well on frontal and moderately angled faces in high-resolution images, but tends to miss small faces or those partially hidden by objects.
- **CNN** achieves higher detection rates for small, rotated, or partially occluded faces due to its learned feature representations, making it suitable for production-grade pipelines where missing a face is costly.

## Implementation in the Source Code

The library's model selection logic is implemented in [`face_recognition/api.py`](https://github.com/ageitgey/face_recognition/blob/main/face_recognition/api.py) within the `_raw_face_locations` function (lines 92-99):

```python
def _raw_face_locations(img, number_of_times_to_upsample=1, model="hog"):
    """
    :param model: Which face detection model to use. "hog" is less accurate but faster on CPUs.
                 "cnn" is a more accurate deep-learning model which is GPU/CUDA accelerated (if available).
    """
    if model == "cnn":
        return cnn_face_detector(img, number_of_times_to_upsample)
    else:
        return face_detector(img, number_of_times_to_upsample)

```

This wrapper function routes calls to either `face_detector` (HOG) or `cnn_face_detector` based on the string parameter. CNN support was officially added in version 0.20 of the library, as documented in `HISTORY.rst`.

## How to Select the Right Model

You can specify the detection backend through both the Python API and command-line interface.

### Using the Python API

```python
import face_recognition

# Load an image as a numpy array

image = face_recognition.load_image_file("group_photo.jpg")

# Fast CPU detection (default behavior)

hog_locations = face_recognition.face_locations(image, model="hog")
print(f"HOG detected {len(hog_locations)} faces")

# Higher-accuracy detection (GPU accelerated if available)

cnn_locations = face_recognition.face_locations(image, model="cnn")
print(f"CNN detected {len(cnn_locations)} faces")

```

### Command Line Interface

The CLI exposes the same selection through the `--model` flag defined in [`face_recognition/face_detection_cli.py`](https://github.com/ageitgey/face_recognition/blob/main/face_recognition/face_detection_cli.py) (lines 53-55):

```bash

# Fast HOG detection on CPU

python -m face_recognition.face_detection_cli image.jpg --model hog

# CNN detection (requires dlib CNN model file, GPU optional)

python -m face_recognition.face_detection_cli image.jpg --model cnn

```

### Batch Processing with CNN

When using the CNN model with GPU support, process multiple images simultaneously to maximize throughput:

```python
import face_recognition

images = [
    face_recognition.load_image_file("img1.jpg"),
    face_recognition.load_image_file("img2.jpg"),
    face_recognition.load_image_file("img3.jpg")
]

# Batch processing significantly faster on GPU

batch_locations = face_recognition.batch_face_locations(images, model="cnn")
for i, locs in enumerate(batch_locations):
    print(f"Image {i}: {len(locs)} faces detected")

```

## Summary

- **HOG** provides fast, CPU-only detection using gradient-based feature descriptors, making it ideal for prototyping, low-resource environments, and real-time applications on standard hardware.
- **CNN** delivers superior accuracy through deep learning, effectively detecting small, rotated, or occluded faces, but requires GPU acceleration to achieve acceptable performance speeds.
- Both models are selectable via the `model` parameter in `face_locations()` or the `--model` CLI argument in [`face_detection_cli.py`](https://github.com/ageitgey/face_recognition/blob/main/face_detection_cli.py).
- CNN functionality requires the `mmod_human_face_detector.dat` model file and was introduced in version 0.20 of the library.

## Frequently Asked Questions

### Is HOG or CNN better for real-time face detection on a CPU?

**HOG is significantly faster on CPU-only machines.** The HOG model performs simple gradient calculations that execute quickly on standard processors, while the CNN model involves deep neural network inference that creates noticeable latency without GPU acceleration. For real-time video processing on standard hardware, HOG is the practical choice.

### What hardware do I need to run the CNN model efficiently?

**A CUDA-capable NVIDIA GPU is strongly recommended.** According to the implementation in [`face_recognition/api.py`](https://github.com/ageitgey/face_recognition/blob/main/face_recognition/api.py), the CNN face detector is designed to utilize GPU acceleration via dlib's CUDA bindings. While the model falls back to CPU execution if no GPU is available, detection speed decreases substantially, making it unsuitable for time-sensitive applications.

### Why does the CNN model detect faces that HOG misses?

**The CNN's deep learning architecture learns hierarchical features automatically** from training data, enabling it to recognize complex patterns and variations in face appearance. HOG relies on fixed gradient-based rules that struggle with small faces, extreme angles, or partial occlusion, whereas the CNN's learned representations generalize better to challenging viewing conditions.

### How do I switch between HOG and CNN in my code?

**Pass the `model` parameter to detection functions.** In the Python API, use `face_recognition.face_locations(image, model="hog")` for classic detection or `model="cnn"` for deep learning detection. From the command line, specify `--model hog` or `--model cnn` when using [`face_detection_cli.py`](https://github.com/ageitgey/face_recognition/blob/main/face_detection_cli.py), as defined in the CLI argument parser.