Interview Prep
Career
GenAI
Prompt Engg
ChatGPT
LLM
Langchain
RAG
AI Agents
Machine Learning
Deep Learning
GenAI Tools
LLMOps
Python
NLP
SQL
AIML Projects

Reading list

Machine Learning Basics for a Newbie
6 Steps of Machine learning Lifecycle Introduction to Predictive Modeling
Introduction to Exploratory Data Analysis & Data Insights Descriptive Statistics Inferential Statistics How to Understand Population Distributions?
Reading Data Files into Python Different Variable Datatypes
Probability for Data Science Basic Concepts of Probability Axioms of Probability Conditional Probability
Central Tendencies for Continuous Variables Spread of Data KDE plots for Continuous Variable Overview of Distribution for Continuous variables Normal Distribution Skewed Distribution Skeweness and Kurtosis Distribution for Continuous Variable
Central Tendencies for Categorical Variables Understanding Discrete Distributions Performing EDA on Categorical Variables
Dealing with Missing Values Understanding Outliers Identifying Outliers in Data Outlier Detection in Python Outliers Detection Using IQR, Z-score, LOF and DBSCAN
Sample and Population Central Limit Theorem Confidence Interval and Margin of Error
Bivariate Analysis Introduction
Covariance Pearson Correlation Spearman's Correlation & Kendall's Tau Correlation versus Causation Tabular and Graphical methods for Bivariate Analysis Performing Bivariate Analysis on Continuous-Continuous Variables
Tabular and Graphical methods for Continuous-Categorical Variables Introduction to Hypothesis Testing P-value Two sample Z-test T-test T-test vs Z-test Performing Bivariate Analysis on Continuous-Catagorical variables
Chi-Squares Test Bivariate Analysis on Categorical Categorical Variables
Multivariate Analysis A Comprehensive Guide to Data Exploration The Data Science behind IPL
Supervised Learning vs Unsupervised Learning Reinforcement Learning Generative and Descriminative Models Parametric and Non Parametric model
Machine Learning Pipeline Preparing Dataset Build a Benchmark Model: Regression Build a Benchmark Model: Classification
Evaluation Metrics for Machine Learning Everyone should know Confusion Matrix Accuracy Precision and Recall AUC-ROC Log Loss R2 and Adjusted R2
Dealing with Missing Values Replacing Missing Values Imputing Missing Values in Data Working with Categorical Variables Working with Outliers Preprocessing Data for Model Building
Understanding Cost Function Understanding Gradient Descent Math Behind Gradient Descent Assumptions of Linear Regression Implement Linear Regression from Scratch Train Linear Regression in Python Implementing Linear Regression in R Diagnosing Residual Plots in Linear Regression Models Generalized Linear Models Introduction to Logistic Regression Odds Ratio Implementing Logistic Regression from Scratch Introduction to Scikit-learn in Python Train Logistic Regression in python Multiclass using Logistic Regression How to use Multinomial and Ordinal Logistic Regression in R ? Challenges with Linear Regression Introduction to Regularisation Implementing Regularisation Ridge Regression Lasso Regression
Introduction to K Nearest Neighbours Determining the Right Value of K in KNN Implement KNN from Scratch Implement KNN in Python
Bias Variance Tradeoff Introduction to Overfitting and Underfitting Visualizing Overfitting and Underfitting Selecting the Right Model What is Validation? Hold-Out Validation Understanding K Fold Cross Validation
Introduction to Feature Selection Feature Selection Algorithms Missing Value Ratio Low Variance Filter High Correlation Filter Backward Feature Elimination Forward Feature Selection Implement Feature Selection in Python Implement Feature Selection in R
Introduction to Decision Tree Purity in Decision Tree Terminologies Related to Decision Tree How to Select Best Split Point in Decision Tree? Chi-Squares Information Gain Reduction in Variance Optimizing Performance of Decision Tree Train Decision Tree using Scikit Learn Pruning of Decision Trees
Introduction to Feature Engineering Feature Transformation Feature Scaling Feature Engineering Frequency Encoding Automated Feature Engineering: Feature Tools
Introduction to Naive Bayes Conditional Probability and Bayes Theorem Introduction to Bayesian Adjustment Rating: The Incredible Concept Behind Online Ratings! Working of Naive Bayes Math behind Naive Bayes Types of Naive Bayes Implementation of Naive Bayes
Understanding how to solve Multiclass and Multilabled Classification Problem Evaluation Metrics: Multi Class Classification
Introduction to Ensemble Techniques Basic Ensemble Techniques Implementing Basic Ensemble Techniques Finding Optimal Weights of Ensemble Learner using Neural Network Why Ensemble Models Work well?
Introduction to Stacking Implementing Stacking Variants of Stacking Implementing Variants of Stacking Introduction to Blending Bootstrap Sampling Introduction to Random Sampling Hyper-parameters of Random Forest Implementing Random Forest Out-of-Bag (OOB) Score in the Random Forest IPL Team Win Prediction Project Using Machine Learning Introduction to Boosting Gradient Boosting Algorithm Math behind GBM Implementing GBM in python Regularized Greedy Forests Extreme Gradient Boosting Implementing XGBM in python Tuning Hyperparameters of XGBoost in Python Implement XGBM in R/H2O Adaptive Boosting Implementing Adaptive Boosing LightGBM Implementing LightGBM in Python Catboost Implementing Catboost in Python
Different Hyperparameter Tuning methods Implementing Different Hyperparameter Tuning methods GridsearchCV RandomizedsearchCV Bayesian Optimization for Hyperparameter Tuning Hyperopt
Understanding SVM Algorithm SVM Kernels In-depth Intuition and Practical Implementation SVM Kernel Tricks Kernels and Hyperparameters in SVM Implementing SVM from Scratch in Python and R
Introduction to Principal Component Analysis Steps to Perform Principal Compound Analysis Computation of Covariance Matrix Finding Eigenvectors and Eigenvalues Implementing PCA in python Visualizing PCA A Brief Introduction to Linear Discriminant Analysis Introduction to Factor Analysis
Introduction to Clustering Applications of Clustering Evaluation Metrics for Clustering Understanding K-Means Implementation of K-Means in Python Implementation of K-Means in R Choosing Right Value for K Profiling Market Segments using K-Means Clustering Hierarchical Clustering Implementation of Hierarchial Clustering DBSCAN Defining Similarity between clusters Build Better and Accurate Clusters with Gaussian Mixture Models
Understand Basics of Recommendation Engine with Case Study
8 Ways to Improve Accuracy of Machine Learning Models
Introduction to Dask Working with CuML
Introduction to Machine Learning Interpretability Framework and Interpretable Models model Agnostic Methods for Interpretability Implementing Interpretable Model Understanding SHAP Out-of-Core ML Introduction to Interpretable Machine Learning Models Model Agnostic Methods for Interpretability Game Theory & Shapley Values
Introduction to Machine Learning Interpretability Framework and Interpretable Models model Agnostic Methods for Interpretability Implementing Interpretable Model Understanding SHAP Out-of-Core ML Introduction to Interpretable Machine Learning Models Model Agnostic Methods for Interpretability Game Theory & Shapley Values
Introduction to AutoML Implementation of MLBox Introduction to PyCaret TPOT Auto-Sklearn EvalML
Pickle and Joblib Introduction to Model Deployment
Deploying Machine Learning Model using Streamlit Deploying ML Models in Docker Deploy Using Streamlit Deploy on Heroku Deploy Using Netlify Introduction to Amazon Sagemaker Setting up Amazon SageMaker Using SageMaker Endpoint to Generate Inference Deploy on Microsoft Azure Cloud Introduction to Flask for Model Deploying ML model using Flask
Model Deployment in Android Model Deployment in Iphone

Face Detection using Haar-Cascade using Python

Abhishek Jaiswal
Abhishek Jaiswal Last Updated : 12 Oct, 2024
6 min read
Face Detection

Introduction

Hey Folks !!

In this article, we will discuss implementing a face detector using Haar Cascade in OpenCV python. In the last article, we talked about real-time object classification; if you haven’t checked it yet, the link is here.

Identifying a given object in an image is known as object detection. This task can be achieved using several techniques, but in this article, we will use haar cascade with pre-trained XML files. It’s the simplest method to perform object detection.

Haar cascades have been used for object detection on low-edge devices, and it was one of the most popular object detection algorithms in OpenCV.

Haar Cascade is not much computation-heavy; hence it is popular for small devices with small computation power.you will get to know about the face detection using haar cascade.

This article was published as a part of the Data Science Blogathon.

Table of contents

Haar Cascade

What is Haar Cascade, and how it works?

Haar Cascade is a feature-based object detection algorithm to detect objects from images. A cascade function is trained on lots of positive and negative images for detection.

The algorithm does not require extensive computation and can run in real-time. We can train our own cascade function for custom objects like animals, cars, bikes, etc.

Haar Cascade can’t be used for face recognition since it only identifies the matching shape and size.

Haar cascade uses the cascade function and cascading window. It tries to calculate features for every window and classify positive and negative. If the window could be a part of an object, then positive, else, negative. For more in-depth knowledge of its working, refer to this link.

haar cascade

Haar cascade can be understood as a binary classifier. It assigns positive to those cascade windows that can be a part of our object . and negative to those windows that can’t be a part of our object.

  • Haar cascades can work in real-time. It blazing fast.
  • Haar cascade is not much accurate compared to modern object detection algorithms.
  • It detects many false positives. This can be tuned to some extent but can’t be completely removed.
  • It is very simple to implement.
  • The biggest downside of Haar Cascade is its false negative detection.

Pre-trained Haar Cascades

There are lots of pre-trained haar cascade files that make implementation super easy. We can also train our own haar cascade, but that needs big data to train on.

The OpenCV library manages a repository on GitHub for all popular haar cascades pre-trained files that can be used for various object detection tasks, for example:

  • Human face detection
  • Eye detection
  • Vehicle detection
  • Nose / Mouth detection
  • body detection
  • license plate detection

Haar cascade stores its features in an XML file; these files can be directly loaded in OpenCV for object detection using Haar cascade.

Implementing Haar-cascades in OpenCV

If you are working with any of the pre-trained object detection available in the repository provided by OpenCV, you only need to download the pre-trained XML file.

Installing OpenCV in Python

OpenCV can be installed using the pip package manager in python.

!pip install opencv-python
#---OR ---
!pip install opencv-contrib-python

Loading Haar-cascade in OpenCV

We can load haar-cascade XML files using cv2.CascadeClassifier function.

face_detector=cv2.CascadeClassifier(‘haarcascade_frontalface_default.xml’)
eye_dectector = cv2.CascadeClassifier(‘haarcascade_eye.xml’)

We can call the detector function once the XML file is loaded.

results = face_detector.detectMultiScale(gray_img, scaleFactor=1.15,minNeighbors=5,minSize=(34, 35), flags=cv2.CASCADE_SCALE_IMAGE)

results It is the list of bounding box coordinates (x,y,w,h) around the detected object.

Parameters in detectMultiScale

  • scaleFactor – This tells how much the object’s size is reduced to the original image.
  • minNeighbors – This parameter tells how many neighbors should contribute in a single bounding box.
  • minSize — This signifies the minimum possible size of the object in our image. if our object is smaller than the minSize it will be ignored.

Note : For Object detection, we must use a gray_image , minNeighbors,scaleFactorther parameters are not necessary.

Face Detection of the Humans

Let’s take the first example of object detection using a pre-trained haar cascade, where we will detect human faces from a picture using Python.

Download the cascade file for face detection using this link.

import numpy as np
import cv2
#---loading the Haar Cascade detector using CascadeClassifier---face_detector=cv2.CascadeClassifier('haarcascade_frontalface_default.xml')
#---Loading the image from local -----
img = cv2.imread('team_india.jpg')
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
results = face_detector.detectMultiScale(gray, 1.3, 5)
for (x,y,w,h) in results:
    cv2.rectangle(img,(x,y),(x+w,y+h),(0,255,0),2)
  
cv2.imshow('img',img)
cv2.waitKey(0)
cv2.destroyAllWindows()
  • results It contains the coordinate of the Bounding boxes in the picture.
  • detectMultiScale This method only works on grayscale pictures.
  • cv2.rectangle This OpenCV method allows us to draw rectangles after passing the coordinates.
  • scaleFactor = 1.3 FineTuning parameter from 1 to 2.
face detection

Hierarchical detection

Haarcascade supports Hierarchical detection, which means the Haar cascade can be able to detect multiple objects within a single frame in a hierarchical manner.

Suppose we have to detect the faces and eyes of humans. To proceed with the task, we need to follow these steps.

  • Detect Faces
  • For every face, crop faces and forward them for eye detection
  • After finding the coordinates of the eyes (ex,ey,ew,eh) draw a bounding box around the eyes in the original picture.
  • draw a bounding box around faces using coordinates(x,y,w,h) on the original picture.
import numpy as np
import cv2
face_detector1=cv2.CascadeClassifier('haarcascade_frontalface_default.xml')
eye_detector1 = cv2.CascadeClassifier('haarcascade_eye.xml')
img = cv2.imread('uman.jpg')
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
faces_result = face_detector.detectMultiScale(gray, 1.3, 5)
for (x,y,w,h) in faces_result:
img = cv2.rectangle(img,(x,y),(x+w,y+h),(255,0,0),2)
roi_gray = gray[y:y+h, x:x+w]
roi_color = img[y:y+h, x:x+w]
eyes = eye_detector.detectMultiScale(roi_gray)
for (ex,ey,ew,eh) in eyes:
cv2.rectangle(roi_color,(ex,ey),(ex+ew,ey+eh),(0,255,0),2)

cv2.imshow('img',img)
cv2.waitKey(0)
cv2.destroyAllWindows()
face detection

Implementing Face Detection in Real Time

Object detection using Haar Cascade can be used in OpenCV video stream, we only need to read a video or camera feed in OpenCV, and the rest of the thing will be the same.

A Video feed is a sequence of frames so that the code will be the same as the single frame. Due to its light computation requirements, Haar Cascade runs at a good time per second.

We will read OpenCV video cam feed input to take images in real-time.

import cv2
face_detector1 = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')
eye_dectector1 = cv2.CascadeClassifier('haarcascade_eye.xml')
# reading the input image now
cap = cv2.VideoCapture(0)
while cap.isOpened():
    _, frame = cap.read()
    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
    faces = face_detector1.detectMultiScale(gray,1.1, 4 )
    for (x,y, w, h) in faces:
    cv2.rectangle(frame, pt1 = (x,y),pt2 = (x+w, y+h), color = (255,0,0),thickness =  3)
    roi_gray = gray[y:y+h,x:x+w]
    roi_color = frame[y:y+h, x:x+w]
    eyes = eye_dectector1.detectMultiScale(roi_gray)
    for (ex,ey, ew, eh) in eyes:
        cv2.rectangle(roi_color, (ex,ey), (ex+ew, ey+eh), (0,255,0), 5)
    cv2.imshow("window", frame)
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break
frame.release()

The bounding boxes for the eyes and faces will be real-time and change for every frame.

Limitation of Haar Cascade Face Detection

Haar Cascade is still very popular for some objects like faces, cars, etc., where the object is easily distinguishable.

Haar Cascade can’t work for deep object detection like types of grain, etc.

There are a few Limitations of the Haar Cascade Algorithm-

  • Lower Accuracy compared to modern object detectors.
  • High False-positive detection.
  • Manual tuning of parameters is required.
  • Training haar cascade for the custom objects is not easy at all.

Conclusion

In this article, we have talked about the working of the haar cascade and how to implement the haar cascade for object detection using OpenCV in python. We used a pre-trained haar cascade file for face detection and eyes detection, and then we performed the same operation in real time.

We also talked about the limitation of the haar cascade algorithm, why it is still widely used, and why it is so fast.

  • The false positive rate can be fixed using manual parameter tuning.
  • YOLO, SSD, and other deep learning object detection algorithms promise better accuracy.
  • Training customer haar cascade is time-consuming and inefficient.

Thanks for reading, If you still have any queries feel free to write me on LinkedIn.

FAQs

Q1.What is the P value in hypothesis testing?

The p-value in hypothesis testing gauges how likely observed results are under the assumption of a true null hypothesis. A small p-value (< 0.05) indicates evidence against the null hypothesis, leading to rejection. A significant p-value (> 0.05) suggests insufficient evidence for rejection, assessing the strength of evidence.

Q2. What are the six steps of hypothesis testing?

1. Guess Something:
Make a statement that there’s no effect (null) and another saying there is (alternative).
2. Pick a Rule:
Decide how sure you want to be that you’re right (usually 95%).
3. Get Information:
Collect and study the information you need.
4. Do the Math:
Use a formula to calculate a number from your information.
5. Make a Choice:
Decide if your number is so weird that you should change your guess.
6. Tell What You Think:
Share your conclusion based on the math.

The media shown in this article is not owned by Analytics Vidhya and is used at the Author’s discretion.

Abhishek Jaiswal
Abhishek Jaiswal

A data enthusiast exploring the leading technologies related to the data

Free Courses

Generative AI 4.7

Generative AI - A Way of Life

Explore Generative AI for beginners: create text and images, use top AI tools, learn practical skills, and ethics.
Large Language Models 4.5

Getting Started with Large Language Models

Master Large Language Models (LLMs) with this course, offering clear guidance in NLP and model training made simple.
Prompt Engineering 4.6

Building LLM Applications using Prompt Engineering

This free course guides you on building LLM apps, mastering prompt engineering, and developing chatbots with enterprise data.
LlamaIndex 4.8

Improving Real World RAG Systems: Key Challenges & Practical Solutions

Explore practical solutions, advanced retrieval strategies, and agentic RAG systems to improve context, relevance, and accuracy in AI-driven applications.
RAG systems using LlamaIndex 4.7

Microsoft Excel: Formulas & Functions

Master MS Excel for data analysis with key formulas, functions, and LookUp tools in this comprehensive course.

Recommended Articles

Responses From Readers

Clear

Jijo
Jijo

Isn't it "cap.release()" instead of "frame.release()"?

123

Write for us

Write, captivate, and earn accolades and rewards for your work
  • Reach a Global Audience
  • Get Expert Feedback
  • Build Your Brand & Audience
  • Cash In on Your Knowledge
  • Join a Thriving Community
  • Level Up Your Data Science Game
imag

We use cookies essential for this site to function well. Please click to help us improve its usefulness with additional cookies. Learn about our use of cookies in our Privacy Policy & Cookies Policy.

Show details