A

REPORT
on
\

“FACE BASED ATTENDANCE MANAGEMENT SYSTEM

USING AIML”

SUBMITTED TO

FACULTY OF ENGINEERING AND TECHNOLOGY

(CO-EDUCATION)

DEPARTMENT OF COMPUTER SCIENCE AND ENGINEERING

IN PARTIAL FULFILLMENT OF THE SEMESTER PROJECT

SUBMITTED BY

AISHWARYA KOTHALIKAR SG20CSE300

SHESHADRI KULKARNI SG20CSE135
SHASHANK BIRADAR SG20CSE134
SHIVANG S PATIL SG20CSE136

UNDER THE GUIDENCE OF

Dr. SHIVAKUMAR KAGI SIR
 CERTIFICATE
This is to certify that the project work entitled “FACE BASED ATTENDANCE
MANAGEMENT SYSTEM USING AIML” is bonafide work carried out by: AISHWARYA
KOTHALIKAR (SG20CSE300), SHESHADRI KULKARNI (SG20CSE135), SHASHANK
BIRADAR (SG20CSE134), SHIVANG S PATIL (SG20CSE136) in partial fulfillment of
B.Tech 8th Semester in COMPUTER SCIENCE ENGINEERING of the FACULTY OF
ENGINEERING AND TECHNOLOGY (Co-Ed), SHARNBASVA UNIVERSITY,
KALABURAGI during the year 2023-2024. It is certified that, she/he has completed the
project satisfactory.

Marks Details

SL NO NAME OF THE STUDENT USN MAX. MARKS MARKS OBTAINED

1 AISHWARYA KOTHALIKAR SG20CSE300

2 SHESHADRI KULKARNI SG20CSE135

3 SHASHANK BIRADAR SG20CSE134

4 SHIVANG S PATIL SG20CSE136

GUIDE CHAIRMAN DEAN

Name of the Examiners Signature with Date

1.

2.
 ACKNOWLEDGEMENT

We express our deep sense of gratitude to our esteemed

“SHARNBASVA UNIVERSITY” KALABURAGI which has
provided us an opportunity to fulfill the most cherished desire to
reach our goal.

We also extend our sincere thanks Dr.

SANNABASSANANGOUDA DOLLEGOUDAR, Registrar,
Sharnbasva University, for his constant encouragement.

We would like to express our sense of gratitude to our beloved

Dr. SHIVAKUMAR JAWALIGI, Dean-FET for providing the right
academic climate at this university that has made this entire task
appreciable.

We are thankful to Dr. SYEDA ASRA Chairman, department

of Computer Science & Engineering, for giving permission to carry
out this project in the university.

We wish to place our grateful thanks to our project guide Dr.

SHIVAKUMAR KAGI without his help and guidance, it would not
have been possible to complete this project work.

Finally, we express our heartily thanks to all of our staff

members of our department, who helped us a lot in the completion
of project directly and indirectly within the schedule period.

AISHWARYA KOTHALIKAR (SG20CSE300)

SHESHADRI KULKARNI (SG20CSE135)
SHASHANK BIRADAR (SG20CSE134)
SHIVANG S PATIL (SG20CSE136)
 ABSTRACT

Automatic smart attendance face recognition technologies have seen dramatic

improvements in performance over the past years, and such systems are now
widely used for security and commercial applications. An automated system for
human face recognition in a real time background which can be useful for a
college to mark the attendance of their students. So, using Real Time Face
Recognition is a real-world solution which comes with day-to-day activities of
handling various activities. The task is very difficult as the real time background
subtraction in an image is still a challenge. To detect real time human face are
used and a simple fast LBPH has used to recognize the faces detected with a high
accuracy rate. The matched face is used to detect accurate user. Our system
maintains the collection of user facial features as datasets and use them for
verification.
 CONTENTS

SL.NO PARTICULARS PAGE.NO

1. Introduction 1

2. Objectives 2

3. Methodology 3

4. System Analysis 4

5. Advantages & Disadvantages 5

6. Results

Conclusion

References
 CHAPTER-1
INTRODUCTION

Ensuring attendance accuracy is crucial for institutes to assess employee

performance. Various methods are employed, ranging from manual paper-based
systems to automated biometric techniques. However, long queues and
authentication delays are common drawbacks. Biometric systems typically
involve enrollment, identification, and verification processes, utilizing features
like fingerprints, iris scans, and facial recognition. Our system streamlines
attendance using facial recognition, bypassing queues and employee
intervention. Leveraging LBPH for face detection, it enhances efficiency. Face
recognition techniques are categorized into appearance-based, focusing on
texture features, and feature-based, utilizing geometric features like eyes and
mouth. Statistical tools such as LDA and PCA, along with illumination-
invariant algorithms, further optimize recognition accuracy.
 CHAPTER-2
OBJECTIVES

 Adaptive Learning Algorithm Integration: The system continually learns and

adapts from attendance data, improving recognition accuracy over time. This
ensures reliable identification even in varying conditions, enhancing overall system
performance and user satisfaction.

 Data Security and Privacy Measures: Robust encryption techniques secure

biometric data storage and transmission, ensuring compliance with data protection
regulations. Strict access controls and authentication mechanisms prevent
unauthorized access, safeguarding sensitive personal information.

 Multimodal Biometric Authentication: In addition to facial recognition, the system

supports multimodal biometric authentication, allowing users to verify their
identity through alternate biometric modalities such as fingerprint or iris scans.
This enhances security and reliability by offering redundancy in identification
methods and accommodating users with facial features that may be challenging to
recognize.

 User-Friendly Interface and Accessibility: With an intuitive user interface, the

system ensures ease of use for both administrators and employees. Features such as
mobile compatibility and multi-platform support enhance accessibility, enabling
users to conveniently access attendance records and perform necessary tasks from
anywhere, fostering greater efficiency and user adoption.
 CHAPTER-3
METHOLODOGY

 Face detection: An image is captured from which a human face is detected from
the cluttered surroundings.

 Image normalization: In which the image need be standardized consistent with its
scale, orientation, pose, size, illumination etc. relative to the images stored within
database. This is a pivotal step in the process of recognition since the recognition
of the face will not be a successful process unless the attributes of the probe image
are more or less identical to the attributes of the faces stored in the database.

 Feature extraction: In which distinctive attributes of the face are extracted for
recognition.

 Face recognition or authentication: Where in recognition, the input face to the

system is unknown and the system is responsible to find a match to that face (i.e.
To identify who that person is) from database of already known stored faces in the
system. While in authentication, the input face is claimed to be that of a specific
person and the system is responsible to either verify or reject the claimed identity
of that input face.
 CHAPTER-4
SYSTEM ANALYSIS

Existing system
In Existing system eigenfaces are widely employed in face-based attendance
systems due to their effectiveness in recognizing and verifying individuals. One
drawback is their sensitivity to lighting conditions, as variations in lighting can
negatively impact the accuracy of face recognition, leading to false results.
Additionally, eigenfaces may struggle to accurately identify faces with significant
pose variations, reducing their effectiveness in such scenarios. Another concern is
their vulnerability to spoofing attacks, where an individual can deceive the system
using photographs or facial imitations.

Proposed System
Face-based attendance systems using Local Binary Patterns Histograms (LBPH) are
widely utilized due to the effectiveness of the LBPH algorithm in face recognition
and attendance tracking. LBPH captures facial texture information by analyzing the
local patterns in an image. This method is robust to lighting variations and can
handle moderate pose variations, making it suitable for real-world scenarios. By
comparing the local binary patterns of an input face with the pre-registered patterns
in the system, LBPH enables accurate identification and verification. However,
challenges such as occlusion and extreme pose variations can still affect the system's
performance. Continuous research and improvement are necessary to address these
limitations and enhance the overall accuracy and reliability of face-based attendance
systems using LBPH.
 PROBLEM STATEMENT

The problem statement of face-based attendance system using machine learning

arises from the need for a more accurate, efficient, and reliable method of
attendance tracking. Traditional attendance systems, such as manual or card-based
methods, can be prone to errors, buddy punching, and time-consuming
administrative tasks. By leveraging machine learning algorithms for face
recognition, the aim is to develop a system that can automatically and accurately
identify individuals based on their facial features, streamline the attendance process,
and reduce the potential for fraudulent activities.

SELECTED SOFTWARE

IMPLEMENTATION ON (PYTHON):

 What Is a Script?
Up to this point, I have concentrated on the interactive programming capability
of Python. This is a very useful capability that allows you to type in a program
and to have it executed immediately in an interactive mode.

 Scripts are reusable:

Basically, a script is a text file containing the statements that comprise a Python
program. Once you have created the script, you can execute it over and over
without having to retype it each time.

 Scripts are editable:

Perhaps, more importantly, you can make different versions of the script by
modifying the statements from one file to the next using a text editor. Then you
can execute each of the individual versions. In this way, it is easy to create
different programs with a minimum amount of typing.
 You will need a text editor:
Just about any text editor will suffice for creating Python script files. You can
use Microsoft Notepad, Microsoft WordPad, Microsoft Word, or just about any
word processor.

 Difference between a script and a program

Script:
Scripts are distinct from the core code of the application, which is usually
written in a different language, and are often created or at least modified by the
end-user. Scripts are often interpreted from source code or byte code, whereas
the applications they control are traditionally compiled to native machine code.

Program:
The program has an executable form that the computer can use directly to
execute the instructions. The same program in its human-readable source code
form, from which executable programs are derived (e.g., compiled)

Python

What is Python? Chances you are asking yourself this. You may have found this
book because you want to learn to program but don’t know anything about
programming languages. Or you may have heard of programming languages like C,
C++, C#, or Java and want to know what Python is and how it compares to “big
name” languages. Hopefully I can explain it for you.

Python concepts

If you not interested in the how and whys of Python, feel free to skip to the next
chapter. In this chapter I will try to explain to the reader why I think Python is one
of the best languages available and why it’s a great one to start programming with.
  Open-source general-purpose language.
 Object Oriented, Procedural, Functional
 Easy to interface with C/ObjC/Java/Fortran
 Easy-Ish to interface with C++ (via SWIG)
 Great interactive environment

Python is a high-level, interpreted, interactive and object-oriented scripting

language. Python is designed to be highly readable. It uses English keywords
frequently where as other languages use punctuation, and it has fewer syntactical
constructions than other languages.

 Python is Interpreted − Python is processed at runtime by the interpreter. You

do not need to compile your program before executing it. This is similar to PERL
and PHP.

 Python is Interactive − You can actually sit at a Python prompt and interact with
the interpreter directly to write your programs.

 Python is Object-Oriented − Python supports Object-Oriented style or

technique of programming that encapsulates code within objects.

 Python is a Beginner's Language − Python is a great language for the beginner-

level programmers and supports the development of a wide range of applications
from simple text processing to WWW browsers to games.

 History of Python
Python was developed by Guido van Rossum in the late eighties and early
nineties at the National Research Institute for Mathematics and Computer
Science in the Netherlands.

 Python is derived from many other languages, including ABC, Modula-3, C,

C++, Algol-68, SmallTalk, and Unix shell and other scripting languages.

 Python is copyrighted. Like Perl, Python source code is now available under
the GNU General Public License (GPL).
  Python is now maintained by a core development team at the institute,
although Guido van Rossum still holds a vital role in directing its progress

o Python Features
Python's features include −

 Easy-to-learn − Python has few keywords, simple structure, and a clearly

defined syntax. This allows the student to pick up the language quickly.

 Easy-to-read − Python code is more clearly defined and visible to the eyes.

 Easy-to-maintain − Python's source code is fairly easy-to-maintain.

 A broad standard library − Python's bulk of the library is very portable and
cross-platform compatible on UNIX, Windows, and Macintosh.

 Interactive Mode − Python has support for an interactive mode which allows
interactive testing and debugging of snippets of code.

 Portable − Python can run on a wide variety of hardware platforms and has the
same interface on all platforms.

 Extendable − You can add low-level modules to the Python interpreter. These
modules enable programmers to add to or customize their tools to be more
efficient.

 Databases − Python provides interfaces to all major commercial databases.

 GUI Programming − Python supports GUI applications that can be created and
ported to many system calls, libraries and windows systems, such as Windows
MFC, Macintosh, and the X Window system of Unix.

 Scalable − Python provides a better structure and support for large programs
than shell scripting.
Apart from the above-mentioned features, Python has a big list of good features, few
are listed below –

 It supports functional and structured programming methods as well as OOP.

 It can be used as a scripting language or can be compiled to byte-code for

building large applications.

 It provides very high-level dynamic data types and supports dynamic type
checking.

 IT supports automatic garbage collection.

 It can be easily integrated with C, C++, COM, ActiveX, CORBA, and Java.
 System Design

Figure 1: Architecture of the face detection-based attendance system.

o There are technically 3 algorithms we can use, but we have used the LBPH (Local
Binary Pattern Histogram) which gives very efficient result. The other two are
Eigenface and Fisherface algorithms. LBPH is implemented using OpenCV
libraries.

o The input image is read by the camera of the system(webcam). After the image is
read it is converted into gray scale. The faces in the image are detected using the
Haar Cascade frontal face module. Using the LBPH algorithm, the faces in the
image are predicted. After the images are predicted, the recognized faces are
shown in a green box along with their names finally the attendance has been
marked and saved it into csv file.
 UML Diagrams

USE CASE DIAGRAM

Figure 2: Use case diagram of face detection-based attendance system.

A use case diagram at its simplest is a representation of a user’s interaction with

the system and depicting the specifications of a use case. A use case diagram can
portray the different types of users of a system and the various ways that they
interact with the system. This type of diagram is typically used in conjunction
with the textual use case and will often be accompanied by other types of
diagrams as well.
CLASS DIAGRAM

Figure 3 : Class diagram of face detection based attendance system.

The class diagram is the main building block of object oriented modeling. It is used
both for general conceptual modeling of the systematic of the application, and for
detailed modeling translating the models into programming code. Class diagrams
can also be used for data modeling. The classes in a class diagram represent both the
main objects, interactions in the application and the classes to be programmed. A
class with three sections, in the diagram, classes is represented with boxes which
contain three parts:

 The upper part holds the name of the class.

 The middle part contains the attributes of the class.

 The bottom part gives the methods or operations the class can take or
undertake.
SEQUENCE DIAGRAM

Figure 4: Sequence diagram of face detection-based attendance system.

A sequence diagram is a kind of interaction diagram that shows how processes

operate with one another and in what order. It is a construct of a Message Sequence
Chart. A sequence diagram shows object interactions arranged in time sequence. It
depicts the objects and classes involved in the scenario and the sequence of
messages exchanged between the objects needed to carry out the functionality of the
scenario. Sequence diagrams are typically associated with use case realizations in
the Logical View of the system under development. Sequence diagrams are
sometimes called event diagrams, event scenarios, and timing diagrams.
ACTIVITY DIAGRAM

Figure 5: Activity diagram of face detection-based attendance system

Activity diagrams are graphical representations of workflows of stepwise

activities and actions with support for choice, iteration and concurrency. In the
Unified Modeling Language, activity diagrams can be used to describe the
business and operational step-by-step workflows of components in a system. An
activity diagram shows the overall flow of control.
COMPONENT DIAGRAM

Figure 6: Component diagram of face detection-based attendance system.

A component diagram depicts how components are wired together to form

larger components of the software system. These are used to illustrate the structure
of arbitrary complexes. System administrators can use component diagram to plan
ahead, using the view of the logical software components and their relationship on
the system
FLOWCHART

Figure 7: Flowchart of the face detection-based attendance system.

A flowchart is a type of diagram that represents a workflow or process. A flowchart

also be defined as a diagrammatic representation of an algorithm. The flowchart
shows the steps as boxes of various kinds, and their order by connecting the boxes
with the arrows.
 CHAPTER-5
ADVANTAGES AND DISADVANTAGES

Advantages
 Robustness to lighting variations
 Efficient and fast computation
 Texture-based recognition
 Low storage requirements
 Well-established and widely used.

Disadvantages
 Sensitivity to lighting conditions
 Limited accuracy with pose variations
 Vulnerability to spoofing attacks
 Computational complexity
 CHAPTER-6
SYSTEM SPECIFICATIONS

Software Specifications:
Operating system: Microsoft Windows 11 Home
Programming Language: Python Language
IDE: PYCHARM
Code Complier: Pycharm

Hardware Specifications:
CPU: Intel Core i5-11300H @3.60 to 4.80 GHz
GPU: Nvidia GeForce RTX 3060
RAM: 16GB LPDDR4x @4266 MHz
ROM: 512GB m.2 NVMe SSD
System type: 64-bit Processor Architecture Operating System
 CHAPTER-7
IMPLEMENTATION
(SOURCE CODE)
import os.path
import datetime
import pickle

import tkinter as tk
import cv2
from PIL import Image, ImageTk
import face_recognition

import util
from test import test

class App:
def __init__(self):
self.main_window = tk.Tk()
self.main_window.geometry("1200x520+350+100")

self.login_button_main_window = util.get_button(self.main_window, 'login', 'green', self.login)

self.login_button_main_window.place(x=750, y=200)

self.logout_button_main_window = util.get_button(self.main_window, 'logout', 'red',

self.logout)
self.logout_button_main_window.place(x=750, y=300)

self.register_new_user_button_main_window = util.get_button(self.main_window, 'register new

user', 'gray',
self.register_new_user, fg='black')
self.register_new_user_button_main_window.place(x=750, y=400)

self.webcam_label = util.get_img_label(self.main_window)
self.webcam_label.place(x=10, y=0, width=700, height=500)

self.add_webcam(self.webcam_label)

self.db_dir = './db'
if not os.path.exists(self.db_dir):
os.mkdir(self.db_dir)

self.log_path = './log.txt'

def add_webcam(self, label):

if 'cap' not in self.__dict__:
self.cap = cv2.VideoCapture(2)
 self._label = label
self.process_webcam()

def process_webcam(self):
ret, frame = self.cap.read()

self.most_recent_capture_arr = frame
img_ = cv2.cvtColor(self.most_recent_capture_arr, cv2.COLOR_BGR2RGB)
self.most_recent_capture_pil = Image.fromarray(img_)
imgtk = ImageTk.PhotoImage(image=self.most_recent_capture_pil)
self._label.imgtk = imgtk
self._label.configure(image=imgtk)

self._label.after(20, self.process_webcam)

def login(self):

label = test(
image=self.most_recent_capture_arr,

model_dir='/home/phillip/Desktop/todays_tutorial/27_face_recognition_spoofing/code/face-
attendance-system/Silent-Face-Anti-Spoofing/resources/anti_spoof_models',
device_id=0
)

if label == 1:

name = util.recognize(self.most_recent_capture_arr, self.db_dir)

if name in ['unknown_person', 'no_persons_found']:

util.msg_box('Ups...', 'Unknown user. Please register new user or try again.')
else:
util.msg_box('Welcome back !', 'Welcome, {}.'.format(name))
with open(self.log_path, 'a') as f:
f.write('{},{},in\n'.format(name, datetime.datetime.now()))
f.close()

else:
util.msg_box('Hey, you are a spoofer!', 'You are fake !')

def logout(self):

label = test(
image=self.most_recent_capture_arr,

model_dir='/home/phillip/Desktop/todays_tutorial/27_face_recognition_spoofing/code/face-
attendance-system/Silent-Face-Anti-Spoofing/resources/anti_spoof_models',
device_id=0
)

if label == 1:

name = util.recognize(self.most_recent_capture_arr, self.db_dir)

 if name in ['unknown_person', 'no_persons_found']:
util.msg_box('Ups...', 'Unknown user. Please register new user or try again.')
else:
util.msg_box('Hasta la vista !', 'Goodbye, {}.'.format(name))
with open(self.log_path, 'a') as f:
f.write('{},{},out\n'.format(name, datetime.datetime.now()))
f.close()

else:
util.msg_box('Hey, you are a spoofer!', 'You are fake !')

def register_new_user(self):
self.register_new_user_window = tk.Toplevel(self.main_window)
self.register_new_user_window.geometry("1200x520+370+120")

self.accept_button_register_new_user_window =
util.get_button(self.register_new_user_window, 'Accept', 'green', self.accept_register_new_user)
self.accept_button_register_new_user_window.place(x=750, y=300)

self.try_again_button_register_new_user_window =
util.get_button(self.register_new_user_window, 'Try again', 'red', self.try_again_register_new_user)
self.try_again_button_register_new_user_window.place(x=750, y=400)

self.capture_label = util.get_img_label(self.register_new_user_window)
self.capture_label.place(x=10, y=0, width=700, height=500)

self.add_img_to_label(self.capture_label)

self.entry_text_register_new_user = util.get_entry_text(self.register_new_user_window)
self.entry_text_register_new_user.place(x=750, y=150)

self.text_label_register_new_user = util.get_text_label(self.register_new_user_window, 'Please,

\ninput username:')
self.text_label_register_new_user.place(x=750, y=70)

def try_again_register_new_user(self):
self.register_new_user_window.destroy()

def add_img_to_label(self, label):

imgtk = ImageTk.PhotoImage(image=self.most_recent_capture_pil)
label.imgtk = imgtk
label.configure(image=imgtk)

self.register_new_user_capture = self.most_recent_capture_arr.copy()

def start(self):
self.main_window.mainloop()

def accept_register_new_user(self):
name = self.entry_text_register_new_user.get(1.0, "end-1c")
 embeddings = face_recognition.face_encodings(self.register_new_user_capture)[0]

file = open(os.path.join(self.db_dir, '{}.pickle'.format(name)), 'wb')

pickle.dump(embeddings, file)

util.msg_box('Success!', 'User was registered successfully !')

self.register_new_user_window.destroy()

if __name__ == "__main__":
app = App()
app.start()

import os
import pickle

import tkinter as tk
from tkinter import messagebox
import face_recognition

def get_button(window, text, color, command, fg='white'):

button = tk.Button(
window,
text=text,
activebackground="black",
activeforeground="white",
fg=fg,
bg=color,
command=command,
height=2,
width=20,
font=('Helvetica bold', 20)
)

return button

def get_img_label(window):
label = tk.Label(window)
label.grid(row=0, column=0)
return label

def get_text_label(window, text):

label = tk.Label(window, text=text)
label.config(font=("sans-serif", 21), justify="left")
return label
def get_entry_text(window):
inputtxt = tk.Text(window,
height=2,
width=15, font=("Arial", 32))
return inputtxt

def msg_box(title, description):

messagebox.showinfo(title, description)

def recognize(img, db_path):

# it is assumed there will be at most 1 match in the db

embeddings_unknown = face_recognition.face_encodings(img)
if len(embeddings_unknown) == 0:
return 'no_persons_found'
else:
embeddings_unknown = embeddings_unknown[0]

db_dir = sorted(os.listdir(db_path))

match = False
j=0
while not match and j < len(db_dir):
path_ = os.path.join(db_path, db_dir[j])

file = open(path_, 'rb')

embeddings = pickle.load(file)

match = face_recognition.compare_faces([embeddings], embeddings_unknown)[0]

j += 1

if match:
return db_dir[j - 1][:-7]
else:
return 'unknown_person'
CHAPTER-8
OUTPUT
 CONCLUSION

The project successfully implemented a face-based attendance system using the

Local Binary Patterns Histograms (LBPH) algorithm. The LBPH algorithm
demonstrated its effectiveness in recognizing and verifying individuals, particularly
in handling lighting variations and moderate pose variations. By leveraging LBPH,
the attendance system achieved robust and efficient attendance tracking, offering
advantages such as texture-based recognition, compatibility with different image
resolutions, and low storage requirements. The project addressed the limitations of
traditional attendance systems, providing a more accurate and automated approach
while reducing the potential for fraudulent activities. The successful implementation
of the LBPH-based face attendance system highlights the potential of machine
learning algorithms in revolutionizing attendance tracking and improving overall
efficiency in various domains.
 REFERENCES

[1] B.K.P. Horn and M. Brooks, Seeing Shape from Shading. Cambridge, Mass.:
MIT Press, 1989
[2] Kanan C, Cottrell GW (2012) Color-to-Grayscale: Does the Method Matter in
Image Recognition? https://doi.org/10.1371/journal.pone.0029740
[3] Grundland M, Dodgson N (2007) Decolorize: Fast, contrast enhancing, color to
grayscale conversion. Pattern Recognition 40: 2891- 2896.
[4] F. Ibikunle, Agbetuvi F. and Ukpere G. “Face Recognition Using Line Edge
Mapping Approach.” American Journal of Electrical and Electronic Engineering
1.3(2013): 52-59
[5] T. Kanade, Computer Recognition of Human Faces. Basel and Stuttgart:
Birkhauser Verlag 1997.
[6] K. Wong, H. Law, and P. Tsang, “A System for Recognizing Human Faces,”
Proc. ICASSP, pp. 1,6381,642, 1989.
[7] V. Govindaraju, D.B. Sher, R. Srihari, and S.N. Srihari, “Locating Human Faces
in Newspaper Photographs,” Proc. CVPR 89, pp. 549-554; 1989
[8] N. Dalal, B. Triggs “Histograms of oriented gradients for Human Detection”,
IEEE Computer Society Conference on Computer Vision and Pattern Recognition,
Vol. 1, 2005, pp. 886 – 893.
[9] Modern Face Recognition with Deep learning. Website Reference:
https://medium.com/@ageitgey/machine-learning-is-fun-part-4- modern-face-
recognitionwith-deep- learning.
[10] S.Edelman, D.Reisfeld, and Y. Yeshurun, “A System for Face Recognition that
Learns from Examples,” Proc. European Conf. Computer Vision, S. Sandini, ed., pp.
787-791. Springer- Verlag,1992.