IMAGE RECOGNITION SYSTEM

PROJECT REPORT

SUBMITTED IN PARTIAL FULFILLMENT OF THE REQUIREMENT FOR THE

AWARD OF THE DEGREE OF BACHELOR OF TECHNOLOGY.

BACHELOR OF TECHNOLOGY
COMPUTER SCIENCE ENGINEERING

SUBMITTED BY:
Nand Kumar
(2103491530004)
DECEMBER 2024

DR. APJ ABDUL Kalam Technical University, Uttar Pradesh

LUCKNOW, INDIA
 CERTIFICATE

This is to certify that the Project Report on the topic of "Image Recognition System" is
submitted by Nand Kumar CSE(AI &ML) 4th year [2103491530004] in fulfillment for the
award of degree of BACHELOR OF TECHNOLOGY in Computer Science and Engineering
has been found satisfactory and is approved for submission.

i. Embodies the work of the candidates themselves,

ii. Has duly been completed, and

iii. Is upto the desired standard both in respect of contents and language for being referred

to the examiners.

MR. Abhishek Singh Sengar Dr. Pankaj Kr. Yadav

Associate Professor (CSE) Department Head of Department CSE

MIPS MIPS
 ACKNOWLEDGEMENT

It gives us the great sense of pleasure to present the report of the B. Tech project undertaken

during B. Tech 4th year. I owe special debt of gratitude to Dr. Pankaj Kr. Yadav (Head of

Department in Computer Science and Engineering).

The satisfaction that accompanies the successful completion of any task would be incomplete

without mention of people whose ceaseless cooperation made in possible, whose constant

guidance and encouragement crown all effort with success.

We are grateful to our project guide Mr.Abhishek Singh Sengar Sir for the guidance,

inspiration and constructive suggestions that help us in the preparation in this project.

I am also thanks my college and colleagues who helped us in successful completion of the

project.

- Nand Kumar

- [2103491530004]
 INDEX
TITLE PAGE NO.

INTRODUCTION 1

OBJECTIVE 2

S/W & H/W REQUIREMENTS 3

FLOWCHARTS 4

PSEUDOCODE 5

LITERATURE REVIEW 6

FEASIBILITY STUDY 7

CONCLUSION 8

FUTURE SCOPE 9

REFERENCES 10

APPENDIX 11
INTRODUCTION :

The Image Recognition System is a software solution designed to identify and classify objects,
scenes, and patterns within digital images. With advancements in machine learning and computer
vision, this system leverages artificial intelligence (AI) to perform tasks such as object detection,
facial recognition, and scene understanding. This project aims to demonstrate the development,
implementation, and evaluation of a robust image recognition system.
OBJECTIVE :

The goal of this project is to develop an Image Recognition System that can accurately identify and
classify objects within images. This report outlines the methodology, tools, and techniques used in
building the system, focusing on deep learning approaches, particularly Convolutional Neural
Networks (CNNs).

Specific Goals

• To design and implement an efficient image recognition system.

• To achieve high accuracy in object detection and classification.

• To explore and apply machine learning algorithms and neural networks for image analysis.
• To provide a user-friendly interface for practical applications.
S/W & H/W REQUIREMENTS:

Hardware Required :-

Minimum recommended Maximum recommended

Hardware requirement requirement

RAM 4 GB 8GB or More

HARD DISK STORAGE 160 GB 512GB or More

PROCESSOR Intel i3 10th gen, AMD Intel i5 10th gen,i5 11th gen ,
Ryzen 3… i7, AMD Ryzen 5, Ryzen 7

Software Required:-

Minimum recommended Maximum recommended

Software requirement requirement
System Type Microsoft Windows 7(32 Microsoft Windows 10,
bits), Windows8(32bits), Windows 11
ubuntu, Linux
Storage FAT File System NTFS File System
Programming Language Idle, VS Code Idle, VS Code, Programiz and
Compiler other compiler
FLOWCHART :
PSEUDOCODE :
BEGIN Image Recognition System

// Step 1: Initialize system

LOAD pre-trained model
PRINT "System Initialized"

// Step 2: Input Image

PRINT "Please upload an image"
INPUT image

// Step 3: Preprocessing
image <- RESIZE(image, target_dimensions)
image <- NORMALIZE(image, range=0 to 1)
image <- AUGMENT(image) // Optional: For training or testing robustness

// Step 4: Feature Extraction

features <- EXTRACT_FEATURES(image, model=CNN)

// Step 5: Model Inference

result <- PREDICT(features, model)

// Step 6: Result Analysis

IF result IS classification THEN
PRINT "Classified as:", result.class
PRINT "Confidence:", result.confidence
ELSE IF result IS object_detection THEN
PRINT "Objects detected:"
FOR each object IN result.objects DO
PRINT "Object:", object.name, "Confidence:", object.confidence
END FOR
END IF

// Step 7: Display Results

DISPLAY result ON user interface

// Step 8: End
PRINT "Process Complete"
TERMINATE
LITERATURE REVIEW :

The field of image recognition has seen significant advancements due to the evolution of machine
learning and deep learning techniques.

• Early Methods: Initial approaches relied on manual feature extraction and traditional algorithms
like SIFT and HOG for image analysis. These methods, while effective for specific tasks, were
limited in handling complex and diverse datasets.

• Deep Learning Revolution: The introduction of Convolutional Neural Networks (CNNs) by LeCun
et al. marked a breakthrough. AlexNet (2012) demonstrated the power of deep learning on large-
scale datasets like ImageNet, achieving unprecedented accuracy.

• State-of-the-Art Models: Modern architectures like ResNet, Inception, and EfficientNet have
further improved performance by addressing issues like vanishing gradients and computational
efficiency. Techniques such as transfer learning and data augmentation have made it feasible to
train models with limited resources.

• Applications: Image recognition systems are now integral to various industries, from autonomous
vehicles using real-time object detection (e.g., YOLO, SSD) to medical imaging systems
diagnosing diseases with high precision.

• Challenges: Despite advancements, challenges like bias in training data, adversarial attacks, and the
need for large annotated datasets persist. Research continues to address these limitations, aiming for
more robust and generalizable models.
FEASIBILITY STUDY :

1. Technical Feasibility
• Hardware Requirements: The system requires GPU-enabled machines for training and
inference to ensure efficient processing of large datasets.
• Software Requirements: Frameworks like TensorFlow and PyTorch provide robust tools for
implementing deep learning models. OpenCV supports image preprocessing and manipulation.
• Skillset: Expertise in machine learning, Python programming, and data preprocessing is
essential.
2. Economic Feasibility
• Development Costs: Initial costs include hardware acquisition, software licenses, and dataset
procurement. Open-source tools reduce software costs.
• Operational Costs: Ongoing expenses involve cloud services for storage and computational
resources.
• Cost-Benefit Analysis: The potential benefits, such as automation, reduced error rates, and
scalability, outweigh the initial and operational costs, making the project economically viable.
3. Operational Feasibility
• Integration: The system can be integrated into existing workflows with minimal disruption.
• User-Friendly Interface: A simple and intuitive interface ensures ease of use for non-technical
users.
• Maintenance: Regular updates and monitoring are required to maintain system performance and
accuracy.
4. Legal and Ethical Feasibility
• Data Privacy: Compliance with data protection regulations (e.g., GDPR) is critical, especially
for systems involving facial recognition.
• Bias and Fairness: Efforts must be made to minimize bias in training data to ensure fair and
equitable outcomes.
• Intellectual Property: Ensuring the use of licensed datasets and models avoids potential legal
disputes
CONCLUSION :

The Image Recognition System demonstrates the potential of AI in automating image analysis tasks.
Despite existing challenges, the advancements in deep learning provide a solid foundation for further
innovation. This research contributes to the growing body of knowledge in computer vision,
emphasizing the importance of scalability, efficiency, and ethical considerations in developing image
recognition systems.
FUTURE SCOPE :

The future of image recognition systems is promising, with advancements in AI and computational
capabilities paving the way for new opportunities. Potential areas of exploration include:

• Video Recognition: Extending the system to analyze video streams in real-time, enabling
applications in surveillance, autonomous vehicles, and sports analytics.

• 3D Image Analysis: Incorporating 3D image recognition for applications in medical imaging,

augmented reality, and robotics.

• Edge Computing: Deploying image recognition systems on edge devices to reduce latency and
enhance real-time processing capabilities.

• Ethical AI: Developing frameworks to address biases and ensure fairness in image recognition
systems.

• Interdisciplinary Applications: Integrating image recognition with other domains such as natural
language processing (NLP) for multimodal systems and IoT for smart environments.
REFERENCES:
WEBSITES-
• Krizhevsky, A., Sutskever, I., & Hinton, G. E. (2012). ImageNet Classification with Deep Convolutional
Neural Networks.

• He, K., Zhang, X., Ren, S., & Sun, J. (2016). Deep Residual Learning for Image Recognition.

• OpenCV Documentation.

• TensorFlow and PyTorch official guides.

APPENDIX :

Code of the Solution –

import tensorflow as tf
from keras.preprocessing.image import ImageDataGenerator
from keras.preprocessing import image
import numpy as np

print(tf.__version__)

#--------------------- Data Preprocessing --------------------#

#feature training
train_datagen = ImageDataGenerator(
# reducing/normalizing the pixels
rescale=1./255,
shear_range=0.2,
zoom_range=0.2,
horizontal_flip=True)
#connecting the image augmentation tool to our dataset
train_set = train_datagen.flow_from_directory(
'training_set',
#final size of the images that will be fed into the ann
target_size=(64, 64),
# number of images that we want to have in each batch
batch_size=32,
# we have binary classification --> binary class mode
 class_mode='binary')

#only rescaling but no transformations

test_datagen = ImageDataGenerator(rescale=1./255)
#connecting to the test data
test_set = test_datagen.flow_from_directory(
'test_set',
target_size=(64, 64),
batch_size=32,
class_mode='binary')

print(test_set)

#--------------------- Building CNN --------------------#

# initializing CNN as sequential layers
cnn = tf.keras.models.Sequential()

# Step 1: Convolution to get the Feature Map

cnn.add(tf.keras.layers.Conv2D(filters = 32, kernel_size = 3, activation = 'relu',
input_shape=[64,64,3]))

# Step 2: Max Pooling

cnn.add(tf.keras.layers.MaxPool2D(pool_size=2 ,strides=2))
#adding a second convolutional layer
cnn.add(tf.keras.layers.Conv2D(filters = 32, kernel_size = 3, activation = 'relu'))
cnn.add(tf.keras.layers.MaxPool2D(pool_size=2 ,strides=2))
# Step 3: Flattening
cnn.add(tf.keras.layers.Flatten())

# Step 4: Full Connection

cnn.add(tf.keras.layers.Dense(units = 128, activation = 'relu'))

# Step 5: Output Layer

cnn.add(tf.keras.layers.Dense(units = 1, activation = 'sigmoid'))

#--------------------- Training the CNN --------------------#

#compiling the CNN
cnn.compile(optimizer = 'adam', loss = 'binary_crossentropy', metrics = ['accuracy'])
#training the CNN on the training set and evaluating it on the test set
cnn.fit(x = train_set, validation_data = test_set, epochs = 25)

#--------------------- Single prediction with CNN --------------------#

test_image = image.load_img('single_prediction/cat_or_dog_1.jpg', target_size = (64, 64))
# to convert image in pii format into a numpy array format
test_image = image.img_to_array(test_image)
# adding extra dimension to put this image into a batch by saying where we want to add this batch (as
the first dimension)
test_image = np.expand_dims(test_image, axis = 0)
# cnn prediction on the test image
result = cnn.predict(test_image)
# getting the results encoding: which indices correspond to which classes (1: dog, 0:cat)
print(train_set.class_indices)

#prediction for the single image/element from the batch

if result[0][0] == 1:
prediction = 'dog'
else:
prediction = 'cat'

print(prediction)

test_image2 = image.load_img('single_prediction/cat_or_dog_2.jpg', target_size = (64, 64))

# to convert image in pii format into a numpy array format
test_image2 = image.img_to_array(test_image2)
# adding extra dimension to put this image into a batch by saying where we want to add this batch (as
the first dimension)
test_image2 = np.expand_dims(test_image2, axis = 0)
# cnn prediction on the test image
result2 = cnn.predict(test_image2)

#prediction for the single image/element from the batch

if result2[0][0] == 1:
prediction2 = 'dog'
else:
prediction2 = 'cat'

print(prediction2)