Comparing 3 Face Recognition Approaches in Python: Eigenfaces (PCA), LBPH, and DeepFace

A developer implemented and compared three Python face recognition approaches — Eigenfaces (PCA), LBPH, and DeepFace — on a small sample dataset, testing each against a simulated 50% brightness reduction to gauge robustness to illumination changes. The writeup includes runnable code, notes that standard opencv-python lacks the cv2.face module required for Eigenfaces and LBPH (fixed by installing opencv-contrib-python), and offers a Google Colab variant that pulls real faces from Scikit-Learn's LFW dataset.

Face recognition has evolved significantly—from classical statistical methods like Eigenfaces PCA and texture-based descriptors like LBPH Local Binary Pattern Histograms to modern deep learning frameworks like DeepFace . In this post, we will implement and compare all three approaches on a small dataset in Python, test how they hold up against illumination changes e.g., low lighting , and look at how to run the code effortlessly without running into environment issues. Eigenfaces PCA-based Representation LBPH Local Binary Pattern Histograms DeepFace Deep Learning-based Recognition ModuleNotFoundError: No module named 'cv2' A common mistake when running this code is executing it inside lightweight online compilers like Programiz or OnlineGDB , which results in: Traceback most recent call last : File "/box/main.py", line 1, in <module import cv2 ModuleNotFoundError: No module named 'cv2' opencv-contrib-python opencv-python . Standard OpenCV does cv2.face module needed for Eigenfaces and LBPH Run this in your terminal: pip uninstall opencv-python -y pip install opencv-contrib-python deepface scikit-learn tf-keras If you have 4 sample face images in your project directory p1 1.jpg , p1 2.jpg for Person 0, and p2 1.jpg , p2 2.jpg for Person 1 , here is the cleanest implementation: python import cv2 import numpy as np from deepface import DeepFace 1. Load and preprocess the small dataset Resize to 100x100 & Grayscale def load img path : img = cv2.imread path, cv2.IMREAD GRAYSCALE return cv2.resize img, 100, 100 Training data: 2 images of Person 0, 1 image of Person 1 train imgs = load img 'p1 1.jpg' , load img 'p1 2.jpg' , load img 'p2 1.jpg' labels = np.array 0, 0, 1 Test data: Another image of Person 1 test img = load img 'p2 2.jpg' Simulate illumination change reduce brightness by 50% dark test img = np.clip test img 0.5, 0, 255 .astype np.uint8 cv2.imwrite 'dark test.jpg', dark test img Save for DeepFace --------------------------------------------------------- APPROACH 1: Eigenfaces PCA-based --------------------------------------------------------- eigen model = cv2.face.EigenFaceRecognizer create eigen model.train train imgs, labels pred eigen norm, = eigen model.predict test img pred eigen dark, = eigen model.predict dark test img --------------------------------------------------------- APPROACH 2: LBPH Local Binary Pattern Histograms --------------------------------------------------------- lbph model = cv2.face.LBPHFaceRecognizer create lbph model.train train imgs, labels pred lbph norm, = lbph model.predict test img pred lbph dark, = lbph model.predict dark test img --------------------------------------------------------- APPROACH 3: DeepFace Deep Learning-based --------------------------------------------------------- DeepFace compares images directly without explicit training df norm = DeepFace.verify 'p2 1.jpg', 'p2 2.jpg', enforce detection=False df dark = DeepFace.verify 'p2 1.jpg', 'dark test.jpg', enforce detection=False --------------------------------------------------------- OUTPUT & COMPARISON Expected Label = 1 / True --------------------------------------------------------- print "--- COMPARISON RESULTS Target: Person 1 ---" print f"1. Eigenfaces | Normal: {pred eigen norm == 1} | Dark: {pred eigen dark == 1}" print f"2. LBPH | Normal: {pred lbph norm == 1} | Dark: {pred lbph dark == 1}" print f"3. DeepFace | Normal: {df norm 'verified' } | Dark: {df dark 'verified' }" Don't have sample photos handy? Paste this directly into a Google Colab cell. It automatically installs the dependencies and fetches real faces from Scikit-Learn's built-in LFW Labeled Faces in the Wild dataset: Step 1: Install required libraries in Colab pip install -q opencv-contrib-python deepface scikit-learn import cv2 import numpy as np from deepface import DeepFace from sklearn.datasets import fetch lfw people Step 2: Load a small built-in face dataset No manual image upload needed lfw = fetch lfw people min faces per person=10, resize=1.0 img p1 1 = lfw.images 0 255 .astype np.uint8 Person 0, Image 1 img p1 2 = lfw.images 1 255 .astype np.uint8 Person 0, Image 2 img p2 1 = lfw.images 2 255 .astype np.uint8 Person 1, Image 1 Train test img = lfw.images 3 255 .astype np.uint8 Person 1, Image 2 Test Resize all to 100x100 train imgs = cv2.resize x, 100, 100 for x in img p1 1, img p1 2, img p2 1 test img = cv2.resize test img, 100, 100 labels = np.array 0, 0, 1 Simulate illumination change 50% darker dark test img = test img 0.5 .astype np.uint8 Save images temporarily for DeepFace requires RGB/file paths cv2.imwrite 'train p2.jpg', cv2.cvtColor train imgs 2 , cv2.COLOR GRAY2BGR cv2.imwrite 'test norm.jpg', cv2.cvtColor test img, cv2.COLOR GRAY2BGR cv2.imwrite 'test dark.jpg', cv2.cvtColor dark test img, cv2.COLOR GRAY2BGR 1. Eigenfaces PCA eigen = cv2.face.EigenFaceRecognizer create eigen.train train imgs, labels print "Eigenfaces Normal, Dark :", eigen.predict test img 0 , eigen.predict dark test img 0 2. LBPH lbph = cv2.face.LBPHFaceRecognizer create lbph.train train imgs, labels print "LBPH Normal, Dark :", lbph.predict test img 0 , lbph.predict dark test img 0 3. DeepFace df norm = DeepFace.verify 'train p2.jpg', 'test norm.jpg', enforce detection=False df dark = DeepFace.verify 'train p2.jpg', 'test dark.jpg', enforce detection=False print "DeepFace Normal, Dark :", df norm 'verified' , df dark 'verified' Here is how the three approaches stack up across key metrics: | Evaluation Metric | 1. Eigenfaces PCA | 2. LBPH | 3. DeepFace | |---|---|---|---| | Accuracy | Low to Moderate struggles with pose and lighting variations . | Moderate to High on small, controlled datasets. | Very High Backed by state-of-the-art CNNs . | | Robustness Under Illumination Changes | Poor — Global pixel intensity changes drastically shift PCA eigenvectors. | Good — Local pixel thresholding preserves texture patterns even when darkened. | Excellent — Pre-trained on millions of faces across diverse lighting conditions. | | Ease of Implementation | Medium — Requires strictly identical image dimensions and grayscale conversion. | Easy — Handles varied sizes and uses the straightforward cv2.face API. | Easiest — Just 1 line of code DeepFace.verify with no training loop needed. | Happy coding Feel free to drop any questions in the comments below. 👇