INTRODUCTION

The " Gender And Age Detector " is a Python-based

image processing application designed to explore
facial recognition and age-gender prediction using
computer vision techniques. The program integrates
popular libraries such as OpenCV for image
processing, matplotlib for visualization, and pygame
for background music. The application allows users to
interactively select images through a Tkinter-based
file dialog.

The core functionality of the program lies in its ability

to detect faces, predict gender, and estimate age from
the selected images. These tasks are achieved through
the utilization of pre-trained neural networks,
specifically a face detection model and separate
models for gender and age prediction. The neural
networks are loaded into the program using OpenCV's
deep neural network (dnn) module.

Upon selecting an image, the program resizes it for

consistent processing and passes it through the face
detection model. Detected faces are then processed
individually to predict gender and estimate age. The

1
predicted information is overlaid on the original
image, providing a visual representation of the
program's analysis. The annotated image is displayed
to the user using matplotlib.

To enhance the user experience, the program

incorporates background music using the pygame
library, playing a lofi track during image analysis.
This feature adds a unique and enjoyable element to
the application, creating a more immersive and
engaging interaction for users.

The Gender And Age Detector offers a user-friendly

and visually appealing interface for exploring facial
recognition technology. The combination of image
annotation, age-gender prediction, and background
music contributes to a dynamic and informative user
experience. The program can be utilized for
educational purposes, providing insights into
computer vision applications, or simply for
entertainment.

2
 OBJECTIVE

The primary objective of the code is to implement a

comprehensive image processing application that
leverages computer vision techniques for facial
recognition, gender prediction, and age estimation.
The code is designed to accomplish the following key
goals:

1.Face Detection: Implement a robust face detection

mechanism using OpenCV's deep neural network
(dnn) module to accurately locate faces within user-
selected images.

2.Gender Prediction: Utilize a pre-trained neural

network to predict the gender of each detected face,
providing insights into the program's gender
classification capabilities.

3.Age Estimation: Incorporate an age estimation

model to predict the age range for each detected face,
enhancing the user's understanding of age prediction
in the context of facial recognition.

4.User Interaction: Create a user-friendly interface

that allows interactive image selection through a

3
Tkinter-based file dialog, ensuring ease of use for
individuals exploring the application.

5.Visual Representation: Display the results of the

analyses in a visually appealing manner using
matplotlib, overlaying the predicted gender and age
information on the original image for user
comprehension.

6.Background Music: Enhance the user experience by

incorporating background music using the pygame
library, providing an enjoyable and immersive
element during image analysis.

7.Educational and Entertainment Value: Serve as both

an educational tool for individuals interested in
computer vision applications and an entertaining
experience, allowing users to interact with and explore
the capabilities of facial recognition and age-gender
prediction.

By achieving these objectives, the code aims to

provide a versatile and insightful platform for users to
engage with computer vision technologies, fostering
both learning and enjoyment in the process.

4
 EXISTING SYSTEM

The existing “Gender And Image Detector" system,

while capable and engaging, has some limitations that
are important to acknowledge:

Accuracy Constraints: The accuracy of facial

recognition, gender prediction, and age estimation is
contingent on the quality of pre-trained models and
the data they were trained on. In real-world scenarios,
variations in lighting conditions, facial expressions,
and diverse demographics may impact the system's
accuracy.

Single Image Processing: The system currently

operates on a single image at a time. There's a
limitation in handling multiple images or real-time
video streams, which could be a valuable extension
for broader use cases.

Dependency on Pre-trained Models: The system

relies on pre-trained models for face detection, gender
prediction, and age estimation. These models may not
be optimal for all demographic groups or may not
generalize well to diverse datasets, leading to potential
biases.
5
Limited User Interaction: While the system allows
users to select images, there's limited interactivity
beyond that. Integrating features such as image re-
selection, real-time feedback, or a more dynamic user
interface could enhance the user experience.

Resource Utilization: The system may consume

significant computational resources, especially with
large image sizes or high-resolution inputs.
Optimizing the code for efficiency could improve
overall performance.

Static Music Playback: The background music

feature is a static, continuous loop. Implementing
controls for users to pause, play, or choose different
music tracks could add a more dynamic and
personalized touch.

Security Concerns: The system may not have robust

security measures in place, especially if it evolves to
handle user-uploaded images. Ensuring data privacy
and protecting against potential security threats should
be a consideration for future developments.

Limited Documentation: The code lacks extensive

comments or documentation, making it less accessible
for users who want to understand the implementation
details or potentially modify the code for their needs.
6
 IMPORTANCE

The “Gender And Age Detector" code holds

significance in several aspects:

1.Educational Tool: It serves as an educational tool

for individuals interested in computer vision and
machine learning. The code demonstrates practical
applications of facial recognition, gender prediction,
and age estimation, offering insights into the
capabilities and challenges of these technologies.

2.Hands-On Learning: Users can interact with the

code, select images, and observe the real-time results
of facial analysis. This hands-on experience fosters a
better understanding of how computer vision
algorithms work and how they can be implemented in
Python.

3.Entertainment Value: Beyond education, the code

introduces an entertaining element by incorporating
background music. This adds a layer of enjoyment to
the user experience, making the exploration of facial
recognition more engaging.

7
4.Demonstration of Integration: The code
showcases the integration of multiple technologies,
including OpenCV for image processing, deep neural
networks for face detection and age-gender prediction,
and multimedia libraries like matplotlib and pygame.
It serves as an example of how diverse tools can be
seamlessly integrated.

5.Practical Application Exploration: Users can

apply the code to their own images, exploring the
practical application of facial recognition in a
controlled environment. This allows individuals to see
the technology in action and understand its potential
applications in various fields.

6.Inspiration for Further Development: The code

provides a foundation that can be expanded upon.
Users, particularly those learning Python and
computer vision, may find inspiration to enhance the
code, add new features, or adapt it for specific
applications.

7.Cross-Disciplinary Appeal: The code's

combination of computer vision, multimedia, and user
interaction elements makes it appealing to individuals
with diverse interests, including computer science,
8
data science, multimedia, and human-computer
interaction.

INPUT DATA

The input data for the "Gender And Age Detector"

code is an image file in a common format such as
JPEG or PNG. The code allows users to select an
image file through a graphical user interface (GUI)
using the Tkinter library. Here's a breakdown of the
input data:

Image File:

Format: JPEG, PNG, or other common image formats.

Content: The image should contain one or more faces

for the facial recognition, gender prediction, and age
estimation algorithms to analyze

Selection: The user is prompted to select an image file

using the file dialog provided by the Tkinter library.

9
 TYPES OF OUTPUT

The "Gender And Age Detector" code provides

several types of output to the user, offering insights
into the facial analysis results. The main types of
output include:

1.Visual Output:

Display Window: The code generates a graphical user

interface (GUI) using the matplotlib library to display
the original image with annotated information.

Bounding Boxes: Detected faces are outlined with

green bounding boxes to visually indicate the regions
where facial analysis has been performed.

2.Text Output:

10
Console Messages: The code prints messages to the
console to communicate information such as whether
a face is detected or if there are any errors.

Age and Gender Information: Predicted age and

gender for each detected face are displayed on the
image near the corresponding bounding box.

3. Interactive Input:

User Choice: After analyzing an image, the code

prompts the user with a choice to select another image
or exit the program. This interactive input allows users
to control the flow of the application.

4.Audio Output:

Background Music: The code incorporates

background music using the pygame library, creating
a more engaging and entertaining user experience.
The music plays continuously until the user decides to
exit the program.

The code provides a combination of visual, text, and

interactive outputs to enhance the user experience.
Users can see the annotated image, receive
information about detected faces, and make decisions
11
on whether to continue using the program. The
inclusion of background music adds an additional
layer of engagement.

IMPLEMENTATION

The code is implemented using the Python

programming language and several libraries for image
processing, deep learning, and graphical user interface
(GUI) interaction. Below is an overview of the key
implementation details:

Libraries Used:

1.OpenCV (cv2): Used for image processing,

including reading, resizing, and detecting faces.

2.Matplotlib (plt): Utilized for displaying images

with annotated information in a graphical user
interface.
12
3.Tkinter: Used for creating a simple GUI that allows
users to select an image file.

4. Pygame: Integrated to provide background music

for an engaging user experience.

Main Functions:

1.load_models():Loads pre-trained deep learning

models for face detection, age estimation, and gender
prediction using OpenCV's dnn module.

2.detect_faces(image,face_net):Uses the face

detection model to identify faces in the input image
and returns the coordinates of the bounding boxes
around detected faces.

3.predict_gender_age(face,age_net,
gender_net):Takes a face region and utilizes the age
and gender prediction models to estimate the age
category and gender of the person in the face.

13
4.select_image():Utilizes Tkinter to open a file
dialog, allowing the user to select an image file.

5.main():

The main function orchestrates the entire workflow:

Selects an image using Tkinter.

Reads and resizes the image.

Calls the face detection, age estimation, and gender

prediction functions.

Displays the annotated image using Matplotlib.

Prompts the user to choose another image or exit the

program.

Plays background music using Pygame.

Overall Structure:

The code follows a modular structure, separating the

functionalities into distinct functions. This design
enhances readability, maintainability, and ease of
modification. The implementation also incorporates
user interaction, visual feedback, and audio elements
to create an engaging and interactive application.

14
The face detection model is based on OpenCV's deep
neural network module (`cv2.dnn`).

Age and gender prediction models use pre-trained

Caffe models.

The code allows users to select multiple images

consecutively until they decide to exit.

Usage:

Users run the program and are prompted to choose an

image file.

The code processes the selected image, annotates it

with age and gender information, and displays the
result.

Users can decide to select another image or exit the

program.

Dependencies: - Python

- OpenCV

- Matplotlib

- Tkinter

- Pygame (for background music)

15
 SYSTEM ANALYSIS

Understand the problem before the system to create

analysis model there is a tendency to rush to a
solution, even before the problem is understood.
Develop prototypes that enables user to understand
how human/machine interaction will occur. Since the
perception of the quality of software is often based on
the perception of the “friendliness” of the interface
prototyping is highly recommended.

16
Record the origin of and the reason for every
requirement. This is the first step-in establishing
traceability back to the customer.
Use multiple views of requirements building data,
functional and behavioral models provide the software
engineer with three different views. This reduces the
likelihood that something will be missed and increases
the likelihood that inconsistency will be recognized.
Rank requirements. Tight deadlines may preclude the
implementation of every software requirements to be
delivered in the first increment must be identified.

SYSTEM PLANNING

Analysis principles are applied and a model of the

software to be build called a planning (prototype) is
constructed for customer and developer assessment.
The close-ended approach is often called throwaway
prototyping using this approach a prototype serves
solely as a rough demonstration of requirements it is
then discarded and the software is engineered using a
different paradigm.

17
An open-ended approach, called evolutionary
prototyping uses the prototype as the first part of an
analysis activity that will be continued into design and
construction the prototype of the software is the first
evolution of the finished system.

FEASIBLITY STUDY

Technology:
This system is technically feasible, because the system
activated by computers and recent technology. We
use client / server technology which is powerful and
very user friendly.
Finance:

18
It is financially feasible. There is no need of spending
over money. Mainly this system constructed by
existing devices only. Since we use visual studio dot
net as a front-end it was most power-full, small and
portable across platforms and operating systems both
at the source and at the binary level. This project
reduces the number of workers wage also.
Time:
This system really time-to-market beat the
competition. Because the system developed with in a
time span and worked based on time event. The time
taken to access the account is very less and avoids
unnecessary waiting that was in the traditional
system. Although it uses less time but its performance
is very well.
Resources:
This system will use the well known resources.
Where there is no need of any special kind of
resource. It uses only the required databases, tables
only.

19
 SOFTWARE REQUIREMENTS

 Platform Used: Python

 Type of Application: Desktop-based application
 Programming Language: Python
 IDE Tool: Python Editor
 Database: NULL

20
 SOURCE CODE

import cv2

import matplotlib.pyplot as plt

from tkinter import Tk, filedialog

import pygame

21
def load_models():

face_net = cv2.dnn.readNet("opencv_face_detector_uint8.pb",
"opencv_face_detector.pbtxt")

age_net = cv2.dnn.readNet("age_net.caffemodel",
"age_deploy.prototxt")

gender_net =
cv2.dnn.readNetFromCaffe("gender_deploy.prototxt",
"gender_net.caffemodel")

return face_net, age_net, gender_net

def detect_faces(image, face_net):

h, w = image.shape[:2]

blob = cv2.dnn.blobFromImage(image, 1.0, (300, 300), [104,

117, 123], True, False)

face_net.setInput(blob)

detections = face_net.forward()

face_boxes = []

for i in range(detections.shape[2]):

confidence = detections[0, 0, i, 2]

if confidence > 0.7:

x1 = int(detections[0, 0, i, 3] * w)

22
 y1 = int(detections[0, 0, i, 4] * h)

x2 = int(detections[0, 0, i, 5] * w)

y2 = int(detections[0, 0, i, 6] * h)

face_boxes.append((x1, y1, x2, y2))

return face_boxes

def predict_gender_age(face, age_net, gender_net):

blob = cv2.dnn.blobFromImage(face, 1.0, (227, 227),

(78.4263377603, 87.7689143744, 114.895847746), swapRB=False)

gender_net.setInput(blob)

gender_preds = gender_net.forward()

gender = "Female" if gender_preds[0, 0] < 0.5 else "Male"

age_net.setInput(blob)

age_preds = age_net.forward()

age_category = ['(0-2)', '(4-6)', '(8-12)', '(15-20)', '(25-32)', '(38-

43)', '(48-53)', '(60-100)']

predicted_age = age_category[age_preds[0].argmax()]

23
 return gender, predicted_age

def select_image():

Tk().withdraw()

file_path = filedialog.askopenfilename(title="Select an Image")

return file_path

def main():

pygame.mixer.init()

pygame.mixer.music.load('zoro.mp3')

pygame.mixer.music.play(-1)

while True:

image_path = select_image()

if not image_path:

print("No image selected. Exiting.")

break

image = cv2.imread(image_path)

24
 if image is None:

print(f"Error: Unable to load the image from

{image_path}")

continue

image = cv2.resize(image, (720, 640))

face_net, age_net, gender_net = load_models()

face_boxes = detect_faces(image, face_net)

if not face_boxes:

print("No face detected")

continue

for face_box in face_boxes:

face_roi = image[max(0, face_box[1]-

15):min(face_box[3]+15, image.shape[0]-1),

max(0, face_box[0]-15):min(face_box[2]+15,
image.shape[1]-1)]

25
 gender, predicted_age = predict_gender_age(face_roi,
age_net, gender_net)

cv2.rectangle(image, (face_box[0], face_box[1]),

(face_box[2], face_box[3]), (0, 255, 0), 2)

cv2.putText(image, f'{gender}, {predicted_age}',

(face_box[0], face_box[1] - 10),

cv2.FONT_HERSHEY_SIMPLEX, 0.8, (255, 0, 0),

2, cv2.LINE_AA)

plt.figure(figsize=(7, 7))

plt.imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))

plt.show()

choice = input("Do you want to choose another image?

(yes/no): ").lower()

if choice != 'yes':

pygame.mixer.music.stop()

break

if __name__ == "__main__":

main()

26
OUTPUT

27
28
29
 CONCLUSION

In conclusion, the "Gender And Age Detector" is a

user-friendly Python program that combines advanced
image processing and deep learning models to analyze
facial features. With capabilities for face detection,
gender recognition, and age prediction, the application
offers a seamless and engaging user experience.
Whether for educational exploration or entertainment,
this program provides valuable insights into the
potential of facial analysis. Its intuitive interface,
coupled with background music, enhances the overall
user experience, making it a versatile tool for various
applications.

30
 BIBILIOGRAPHY

 Class 12 NCERT book

 www.coderspacket.com
 www.itsourcecode.com
 www.cbsepython.in

31