Rajat Naik
Rajat Naik
Rajat Naik
RAJAT NAIK
4NM20IS414
the Degree of
from
MAY 2023
ACCREDITED WITH ‘A’ GRADE BY NAAC
CERTIFICATE
Certified that the project work entitled
The project report has been approved as it satisfies the academic requirements in respect
1. __________________________ __________________________
2. __________________________ __________________________
ACKNOWLEDGEMENT
It is with great satisfaction and delight that we are submitting the Project Report on
“Waste Detection and Management System Using Deep Learning”. We have
completed it as a part of the curriculum of Visvesvaraya Technological University,
Belagavi for the award of Bachelor of Engineering in Information Science and
Engineering.
We sincerely thank Dr. Niranjan N Chiplunkar, Principal, NMAM Institute of
Technology, Nitte and Dr. I Ramesh Mithanthaya, Vice Principal & Dean
(Academics), NMAM Institute of Technology, Nitte, who have always been a great
source of inspiration.
We are profoundly indebted to our guides, Ms. Preethi Salian K, (Assistant
Professor Gd.II)Department of Information Science and Engineering for
innumerable acts of timely advice, encouragement and we sincerely express our
gratitude.
We also thank Mr. Vasudeva Pai, Project Coordinator & Assistant Professor Gd
II,Department of Information Science & Engineering for their constant
encouragement and support extended throughout.
We express our sincere gratitude to Dr. Karthik Pai B.H, Head and Associate
Professor, Department of Information Science and Engineering for his invaluable
support and guidance.
Finally, yet importantly, we express our heartfelt thanks to our family and friends
for their wishes and encouragement throughout the work.
Title page i
Certificate ii
Acknowledgment iii
Abstract iv
List of Contents v
List of Figures vi
1.1 Overview 1
1.2 Objective 3
3.1 YOLO 12
3.2 Roboflow 13
3.3 WandB 14
3.4 Django 14
3.5 Flask Api 15
3.6 HTML 16
3.7 CSS 17
3.8 Javascript 19
3.9 MYSQL 20
1. Table Structure 25
CHAPTER 1
INTRODUCTION
1.1OVERVIEW
The presence of overflowing garbage also attracts animals such as cats, dogs,
rodents, and flies. These animals scavenge through the waste, spreading it even
further and contributing to unsanitary conditions. They can tear apart bags, causing
the contents to spill onto the streets, which worsens the situation. The presence of
animals near the garbage bins not only poses risks to public health but also creates
a nuisance for pedestrians and can lead to further contamination of the surrounding
area.In addition to the immediate physical issues caused by overflowing bins, there
are also health concerns associated with improper waste management. The
accumulation of garbage, coupled with the presence of animals, provides a
breeding ground for bacteria, viruses, and other pathogens. This creates an
environment conducive to the spread of diseases, posing risks to both human and
animal health. The potential for disease transmission is further amplified when
animals come into contact with the waste and then interact with humans or other
animals.
1.2 OBJECTIVES
3. Create a web app for the workforce and citizens to manage garbage bin
complaints, track the availability of smart bins, and provide routes for garbage
trucks.
CHAPTER 2
LITERATURE SURVEY
Deep learning based waste detection in bins is a new field that has received a lot
of attention from researchers in recent years. Advanced algorithms and methods
for detecting the status of waste bins using deep learning-based models have been
developed through a number of studies. In order to accurately process images and
determine the amount of waste in bins, these models make use of a variety of
computer vision and machine learning methods.
In this paper The authors propose a novel waste management system , aiming to
overcome the limitations of traditional waste auditing methods and scattered waste.
They acknowledge the hazardous and time-consuming nature of these methods,
as well as the challenges associated with locating waste. To address these issues,
the authors introduce a mobile-based application that utilizes deep neural networks
for precise waste detection, classification, and waste size quantification. This
application allows users to capture images of trash with their smartphones and
geotag them, streamlining the waste management process and improving overall
efficiency.
The authors present a sophisticated neural network architecture as the core of their
waste management method. The architecture consists of three key components:
the backbone layer, the neck layer, and the model head. The backbone layer
employs CSPNet (Cross Stage Partial Network) to extract relevant features from
the input images. The neck layer utilizes PANet (Pyramid Attention Network) to
create feature pyramids that accommodate objects of different sizes. The model
head utilizes anchor boxes to generate output vectors containing classification
scores, bounding boxes, and class probabilities. This comprehensive neural
network ensures accurate waste detection and classification.To facilitate the waste
The main focus of this paper is the detection and classification of different objects
in real time with the help of a 360°-camera. YOLO, a computer vision algorithm, is
to be used to perform both the localization and classification of the objects present
in the equirectangular panoramic images. The algorithm will be extended in such
a way that the angles and directions with respect to the camera are assigned to
the detected objects. The results of this work can contribute to enhanced road
safety at the locations where many traffic accidents take place due to suddenly
appearing road users.
In this paper, an experimental setup for real-time detection and localization for a
360°-camera using a YOLO algorithm will be presented. In the context of improved
road safety, the computer vision algorithm will be extended with the possibility to
estimate an angle of arrival of detected objects assigning them additionally relative
geographical directions with respect to the camera’s position.
The application for such a real-time detection system combining both optical and
radar sensors can be wide-ranging in the context of a smart and sustainable city.
One can start from a basic idea to collect mobility data in public urban surroundings
and make it available on a data platform for agile urban planning. From another
side, the system can be used more specifically for traffic counting of particular road
users irrespective it is urban surround-ings or forestry rural regions. Moreover, the
installation and control of adaptive lightning along the streets can also be supported
by the real-time detection system. Light duration can be adjusted automatically
depending whether a fast moving bicycle or a strolling pedestrian has been
detected passing by. Within the framework of the InnoSüd project the bicycle
counting system in the city Ulm is to be installed based on a real-time detection
system combining both optical and radar sensors.
computing power, making it efficient while still being capable of detecting small
objects.
The paper begins with a historical overview of panoramic images and their
evolution. It highlights the rise in popularity of panoramic images with the advent
of consumer-level VR devices. However, processing such images presents
challenges due to the lack of annotated datasets, high-resolution imagery, and
geometric distortions away from the central horizontal line. To address these
challenges, the authors employ state-of-the-art detectors, Faster R-CNN and
YOLO V3, trained using existing datasets like ImageNet and COCO. Their
experiments reveal that YOLO V3 outperforms Faster R-CNN in detecting objects
in 360-degree data.
To further enhance the YOLO V3 detector's efficiency, the authors propose a multi-
projection variant, m-p YOLO V3. This variant utilizes stereographic projection to
convert the equirectangular panorama into stereographic images, which are then
used as input for the YOLO V3 algorithm. Additionally, they incorporate soft-NMS
as a post-processing technique to suppress overlapping bounding boxes and
improve the detector's accuracy. The experimental results demonstrate the
effectiveness of their approach, with YOLO V3 achieving better performance
compared to previous models while consuming low computational power.
The paper delves into the methodology employed in the research for garbage
detection and collection. The approach includes two major sections. First, Machine
Learning techniques, specifically object detection and CNN models, are utilized for
garbage detection. The system uses a pre-trained MobileNet model to detect
garbage instances in images and videos, providing the coordinates of bounding
boxes around the detected objects. The second section focuses on estimating the
distance of the garbage from the base of the robotic arm and guiding the arm to
pick it up. This involves calculating the 2D position of the object in front of the
camera, utilizing the PID control principle to minimize the distance between the
object and the screen center, and determining the perpendicular distance of the
object from the camera using relevant information. The distance information is then
used to guide the robotic arm to collect the garbage. The methodology achieves a
detection speed of 3-4 frames per second on the Raspberry Pi and a garbage
detection confidence of 90% or higher in real-time.
The paper discusses the design of the robotic assembly used in the proposed
waste management system. The assembly consists of three main components: the
base, the robotic arm, and the drawer. The base is equipped with four Johnson
geared DC motors, each with a speed of 300 rpm, enabling omnidirectional
movement. The base is responsible for driving the robot towards the garbage. The
robotic arm, constructed using aluminum plates, slabs, nuts, bolts, servo motors,
and bearings, replicates the working of a human arm and is used for collecting the
garbage. The arm is controlled by five servo motors and an Arduino board, utilizing
inverse kinematics to move to specific positions. The drawer serves as a container
for depositing the collected garbage. The overall system offers an efficient and
automated solution for garbage detection and collection, with the ability to operate
in real-time and achieve a high detection accuracy.
In this paper the authors highlight the pressing issue of waste management faced
by municipalities worldwide and the need for effective garbage detection and
recognition systems. They emphasize the lack of a clear definition of garbage and
the wide range of scenes where it appears, which affects the accuracy of manual
scrutiny and photographic records. To tackle these challenges, the paper proposes
an improved garbage detection and recognition system using a YOLOv5-based
Deep Neural Network (DNN). The system utilizes a dataset of street and city
scenes with litter, trash cans, and containers to train the model and achieve an
accuracy rate of 87.69 percent. However, the system still faces challenges with
objects similar to waste or when they are in the distance, leading to incorrect
predictions.
The research paper discusses the architecture preparation for the garbage
detection model using Computer Vision and a YOLOv5-based Deep Neural
Network (DNN). The paper explains that the YOLOv5 model is written in Python
and built on the PyTorch framework, which offers ease of installation and
integration with IoT devices. The authors mention that the YOLOv5 architecture
can be configured and customized based on specific requirements by adding or
removing layers, integrating additional image processing methods, or changing
optimization techniques. To configure the model's architecture, a "data.yaml" file is
used, which contains information about the input image size, batch size, and
number of training epochs. The file also specifies the paths to training and
validation sets, the number of classes, and the object names. By appropriately
configuring these parameters, the authors aim to optimize the garbage detection
model's performance.
The research paper provides insights into the training process of the garbage
detection model using Computer Vision and deep learning techniques. The authors
explain the key parameters used in the training process, including epochs, data,
cfg, weights, name, and cache. The number of epochs determines the number of
times the model trains on all input images, and it is often chosen based on
experience and intuition. The "data" parameter refers to the path of the data.yaml
file, which contains the dataset summary. The "cfg" parameter specifies the model
configuration path, and the "weights" parameter mentions the path to pretrained
weights or initializes random weights if left blank. The "name" parameter is used to
name the result folder, and the "cache" parameter enables caching of images for
faster training. The authors also mention the use of TensorBoard, an add-in for
visualizing the training process and evaluating the model's performance. By
understanding and optimizing these training parameters, the authors aim to
develop an accurate and efficient garbage detection system.
The main Objective of this paper is to detect objects using the You Only Look Once
(YOLO) approach. This method has several advantages as compared to other
object detection algorithms. In other algorithms like Convolutional Neural Network,
Fast-Convolutional Neural Network the algorithm will not look at the image
completely but in YOLO the algorithm looks the image completely by predicting the
bounding boxes using convolutional network and the class probabilities for these
boxes and detects the image faster as compared to other algorithms.
The CNN model is built from scratch and trained to learn and classify the images
of wastages. To increase the accuracy of the image classification in MSW
management, the Inception ResNet V2 derived CNN model is built, trained, and
tested with the same set of data samples. The proposed CNN Inception ResNet
The aim of this research is to develop a smart waste management system using
TensorFlow based deep learning model. It performs real time object detection and
classification. The bin consists of several compartments to segregate the waste
including metal, plastic, paper. Object detection and waste classification is done in
the TensorFlow framework with a pre-trained object detection model. This program
classifies an input image as clean/unclean. This can later be used to automatically
send alerts to respective authorities when a street is found to be unclean. Once a
street is found to be unclean, it automatically sends an email alert to the respective
authorities who can then take action. It is impossible to manually identify streets
that require cleaning at a given time. With "CCTV Street Garbage Detection And
Alert System", authorities can get updates about the streets that are unclean.
CHAPTER 3
TECHNOLOGIES USED
The algorithm works based on the following four approaches: Residual blocks,
Bounding box regression, Intersection over union and Non-maximum suppression.
Most of the time, a single object in an image can have multiple grid box candidates
for prediction, even though not all of them are relevant. The goal of the IOU is to
discard such grid boxes to only keep those that are relevant.
Since the first release of YOLO in 2015, it has evolved a lot with different versions.
YOLOv2 was created in 2016 with the idea of making the YOLO model better,
faster and stronger. The improvement includes but is not limited to the use of
Darknet-19 as new architecture, batch normalization, higher resolution of inputs,
convolution layers with anchors, dimensionality clustering, and other features.
The YOLOv4 version has an optimal speed and accuracy of object detection
compared to all the previous versions and other state-of-the-art object detectors.
YOLOv4 is specifically designed for production systems and optimized for parallel
computations.
YOLOv7 is a new version making a significant move in the field of object detection,
and it surpassed all the previous models in terms of accuracy and speed.YOLO
object detection has different applications in our day-to-day life It is mainly used in
the following domains like healthcare, agriculture, security surveillance, and self-
driving cars.
3.2Roboflow
Roboflow is a comprehensive platform and toolset designed to simplify and
streamline the process of working with computer vision datasets. It provides a
range of powerful features that assist researchers, developers, and data scientists
in managing, annotating, and augmenting their image datasets for training machine
learning models.With Roboflow, users can upload their image datasets in various
formats, such as JPEG, PNG, or TIFF, and easily convert them into a standardized
format suitable for training computer vision models. The platform supports popular
annotation formats like Pascal VOC, COCO JSON, and YOLO TXT, enabling
efficient labeling of objects within the images.
Roboflow also offers integration with popular deep learning frameworks and
platforms, such as TensorFlow and PyTorch, allowing users to seamlessly
integrate their datasets into their training pipelines. The platform provides
convenient APIs and SDKs that facilitate the integration process and enable easy
data access and manipulation.
3.3WandB:
Wandb, short for Weights and Biases, is a versatile platform that facilitates
experiment tracking and visualization for machine learning projects. With Wandb,
researchers and developers can easily log and compare experiments, visualize
metrics, and track model performance over time. It provides an intuitive interface
to monitor training progress, view interactive graphs, and analyze results. Wandb
also offers integration with popular deep learning frameworks, making it effortless
to log and track experiments across different frameworks and environments.
Moreover, it supports collaborative features, allowing team members to share and
collaborate on projects seamlessly. Overall, Wandb is a powerful tool that
enhances productivity and reproducibility in machine learning workflows.
3.4Django:
Django is a high-level Python web framework based on the Model-View-Controller
(MVC) architecture. It was made with the intention of making web development
easier by providing a design that is simple and straightforward. Django is well-
known for its emphasis on scalability, reusability, and the speed with which
complex applications can be built. It gives many underlying highlights, for example,
an ORM, templating motor, structure dealing with, confirmation, and administrator
interface that make it simple to construct web applications.
Engineering of Django:
View: This component responds to user requests and handles user requests. It
interacts with the models to retrieve data and contains the application's business
logic. Views take in data as input, use that data to take actions, and then return a
response.
Template: The data will be displayed to the user by this component. It characterizes
the design and format of the result that is introduced to the client. HTML files that
contain placeholders for dynamic data are known as templates.
In Django's MVT design, the regulator part is certainly dealt with by the actual
structure, and it's known as the URL dispatcher. The URL dispatcher maps
approaching solicitations to the suitable perspectives and passes control to the
fitting perspective capability.
3.5Flask API
Flask API is a Python-based web framework for creating application programming
interfaces (APIs). It is a lightweight and adaptable framework that gives developers
the tools they need to quickly and easily create RESTful APIs. Since the Flask API
is based on the Flask microframework, it inherits many of its features, such as the
Jinja2 templating engine, support for HTTP methods, and easy-to-understand
routing system.
Flask API includes additional features to make building APIs easier. These
remember programmed serialization of reactions for JSON design, support for
input approval, and confirmation and approval instruments. Developers can also
use the Flask API to integrate with popular data storage solutions like MongoDB
and SQLAlchemy to create custom error responses.
Similar to the Flask API, Controllers are implemented using Python functions and
classes that interact with the Models and Views. Models are defined using data
models and ORM (Object-Relational Mapping) libraries like SQLAlchemy. Views
are defined using Flask's routing system and handle user input.
In general, Flask API is a Python framework for building RESTful APIs that is
adaptable and simple to use. It is the best option for developers who want to quickly
and easily create APIs that are lightweight and scalable due to its straightforward
architecture and built-in features.
3.6HTML
The standard markup language for creating web pages is HTML (Hypertext Markup
Language). It gives the content of a web page structure and format. Different
elements like headings, paragraphs, lists, images, links, forms, and more are
defined by HTML tags. These components are used to structure the page layout
and give the content meaning.
In order to meet the requirements of modern web development, new versions and
features of HTML have been added over time. HTML5, the most recent version,
includes numerous new attributes and elements that make it simpler to create
dynamic and interactive web pages.
Any web developer must have a solid understanding of HTML in order to create
user-friendly and effective web pages. HTML is a fundamental skill.
3.7CSS
CSS (Flowing Templates) is a template language utilized for portraying the
introduction of a report written in HTML or XML (counting XML vernaculars like
SVG, MathML or XHTML). CSS specifies how elements should appear on paper,
in speech, on a screen, or in any other form of media.
A declaration block and a selector make up CSS. The HTML element(s) that the
declaration block will be applied to are selected by the selector. One or more
declarations are separated by semicolons in the declaration block. Every statement
incorporates a property name and a relating esteem. The value of the property tells
you what you want to change about the element—for example, color or font size—
and the property tells you what you want to change about it.
1. Outside CSS: The link> tag is used to link the CSS code to the HTML document
after it is written in a separate file with the extension.css.
2. Inward CSS: The CSS code is composed inside the <style> label in the head
part of the HTML archive.
3. CSS inline: The CSS code is written within the HTML element's style attribute.
CSS has a lot of features that help developers make websites that are responsive
and look good. Among the most well-liked CSS features are:
1. Box Model: CSS regards each HTML component as a rectangular box and
applies different properties like cushioning, edge, and boundary to the container.
2. Flexbox: a flexible layout model that lets elements in a container align and share
space with each other.
3. Grid: a layout model in two dimensions with elements arranged in rows and
columns.
4. Media Concerns: a feature that enables web designers to specify distinct styles
for various screen sizes and devices.
5. Transitions and Animations: CSS lets web developers make animations and
transitions that make the user experience better and add more interactivity.
In general, responsive and visually appealing websites are made possible by CSS,
which is an essential component of web development.
3.8JAVASCRIPT
The high-level, interpreted programming language known as JavaScript is used to
create responsive and interactive web pages. It is supported by all current web
browsers and is one of the World Wide Web's core technologies. Web applications
that are both dynamic and interactive can be created using JavaScript, a powerful
scripting language.
Client-side scripting, in which the code is executed on the client's computer rather
than the server, is a common use for JavaScript. This permits web engineers to
make more unique and responsive site pages that can respond to client info and
update their substance without expecting to reload the whole page.
Using technologies like Node.js, JavaScript can also be used to create server-side
web applications and APIs.
- Offbeat: Web pages can continue to update and respond to user input while
waiting for other operations to finish because JavaScript can execute code
asynchronously.
3.9MYSQL
Open-source relational database management system (RDBMS) MySQL is
frequently utilized in web development. It powers dynamic websites and web
applications by storing and retrieving data efficiently, and it is frequently used as
the backend database for web applications.
MySQL is a versatile choice for web developers because it can be used with a
variety of web development frameworks, including Django, Ruby on Rails, and
Laravel. Its versatility and unwavering quality make it a famous decision for high-
traffic web applications and internet business sites.
In general, web developers who need to build robust and scalable web applications
that need to efficiently store and retrieve data will find that MySQL is an
indispensable tool. Many developers choose it because it is simple to integrate with
popular frameworks for web development.
CHAPTER 4
METHODOLOGY
4.1.Dataset Collection
The dataset for this project is collected from the kaggle named “Clean & Dirty
Containers in Montevideo”of version 6.1.It is a collection of data related to the
cleanliness status of containers in Montevideo,Uruguay.The dataset is created by
the user rodrigo laguna,provides valuable information for analyzing and
understanding the condition of containers in the city.
4.2.splitting dataset
fig4.2.1:train,validation,test split
Here we train the model in the kaggle including the official yolov7 folder.fine tuning
the dataset with the yolov7.pt model train it using the NVIDIA TESLA P100 GPU
with 55 epochs with the batch size of 16.It will integrated in wandb.ai to make
analysis.
CHAPTER 5
SYSTEM DESIGN
CHAPTER 6
IMPLEMENTATION
The YOLO (You Only Look Once) format represents object detection bounding
boxes using normalized coordinates and dimensions relative to the image size.
The format consists of four values: (x, y, width, height). Here's a breakdown of the
mathematics involved in the conversion from original xml format to yolo format.
size calculation:
dw = 1.0 / size[0]: Calculate the width reciprocal, which represents the ratio of the
width of the image.
dh = 1.0 / size[1]: Calculate the height reciprocal, which represents the ratio of the
height of the image.
(box[0] + box[1]) / 2.0: Calculate the x-coordinate of the center point of the
bounding box by taking the average of the minimum and maximum x-coordinates.
(box[2] + box[3]) / 2.0: Calculate the y-coordinate of the center point of the
bounding box by taking the average of the minimum and maximum y-coordinates.
box[1] - box[0]: Calculate the width of the bounding box by subtracting the minimum
x-coordinate from the maximum x-coordinate.
box[3] - box[2]: Calculate the height of the bounding box by subtracting the
minimum y-coordinate from the maximum y-coordinate.
Normalization:
x = x * dw: Normalize the x-coordinate of the center point by multiplying it with the
width reciprocal.
y = y * dh: Normalize the y-coordinate of the center point by multiplying it with the
height reciprocal.
The resulting values x, y, w, and h represent the bounding box coordinates in the
YOLO format, where x and y are the normalized center coordinates, and w and h
are the normalized width and height, respectively.
These calculations ensure that the bounding box coordinates are scaled relative to
the size of the image, allowing the YOLO model to generalize across different
image sizes during training and inference.
The detection function performs object detection using the YOLOv7 model on an
image specified by its path and name. It first constructs the full path to the image
file. Then, it executes a system command to run the detect.py script from the
YOLOv7 package, passing in the necessary arguments such as the weights file,
image resolution, confidence threshold, and source image file path. The script
performs object detection and saves the detected objects' labels in a text file.
Next, the function attempts to open the generated label file and reads its contents.
It iterates over each line of the file, incrementing a container variable for each non-
empty line. It extracts the object label from each line and sets the image_text
variable accordingly, either as "Dirty" or "Clean" based on the label value. If there
is an error opening the label file, it prints an error message.
After that, the function processes the image files generated by detect.py. It loops
through the files in the yolov7-master/runs/detect directory and checks if they have
a valid image file extension. For each valid image file, it resizes it to 350x350 pixels
and saves it in the static/detection-Out directory.At the end it removes the yolov7-
master/runs/detect directory and its contents. If objects were detected (i.e., the
container variable is greater than 0), it returns the image_text describing the image
as either "Dirty" or "Clean." Otherwise, it returns the string "No objects detected."
After running the detection script, we read the generated text files to determine the
presence of dirty containers. We opened the text file containing the object labels
and read its contents. We then iterated over each line in the file, extracted the
object label, and determined if it corresponded to a dirty container or a clean
container. Based on this information, we set the appropriate image description.
Moving on to the main part of the code, we set up the video capture using the
desired video source, such as a CCTV endpoint or a video file. We also set the
buffer size to improve playback smoothness and waited for the connection to be
established.Inside the main loop, we read the next frame from the video capture
using the cap.read() function and incremented the frame counter. We captured
frames at the desired interval by checking if the current frame number was a
multiple of the interval multiplied by the frames per second of the video. If it was,
we saved the frame to a temporary directory.We called the detection function to
perform object detection on the captured frame. If a dirty container was detected,
we moved the frame to the output directory. If not, we continued to the next frame.
The loop continued until the user interrupted it by pressing the 'q' key. At that
point, we released the video capture resources and closed any open windows
displaying the frames.
To visualize the collected geolocation data, we developed the allMaps() view and
the all_maps.html template. The view retrieves all Bin objects from the database
and prepares the geolocation data for display on a map. In the template, we
integrated the Google Maps API by signing up for an API key through the Google
Cloud Console. We replaced the placeholder API key in the template with the
actual key. Additionally, we ensured the inclusion of the jQuery library and verified
the correct setup of the Django views and templates.
By rendering the all_maps.html template, we loaded the Google Map with the
required settings and displayed markers for each geolocation point. This enabled
users to view the collected data in an interactive and visually appealing manner.
Overall, the integration of geolocation functionality into our Django project involved
collecting data through a form, saving it to the database, and displaying it on a map
using the Google Maps API.
Here we created a virtual environment for our Django project and installed the
necessary dependencies, including Flask, which allowed us to integrate the Flask
APIs into our Django application seamlessly. We also installed other required
packages such as requests for making API calls and the MySQL database
connector for Django.Next, we developed the Flask APIs in a separate Flask app
specifically designed for garbage bin overflow detection. These APIs accepted
image data, performed object detection using the YOLOv7 model, and returned the
detection results. We ensured that the Flask app was running smoothly and tested
the APIs to verify their functionality.
To integrate the Flask APIs into our Django project, we created a Django app
dedicated to garbage bin management. Within this app, we defined Django views
that called the corresponding Flask APIs using the requests library. These views
processed the responses from the Flask APIs and handled them appropriately
CHAPTER 7
SYSTEM TESTING
TESTCASE
3 Edit and Admin can edit If any changes edit Updated successfully
delete and delete the updated successfully or unsuccessfully
Garbage or delete successfully Delete successfully or
garbage unsuccessfully
details
3 Driver Login Admin will Driver login id will be Created successfully
“Created Successfully” or created
create login id
unsuccessfully
for drivers
4 View Work Admin will check Admin view garbage View all garbage
Report the garbage details details
work report
5 View Admin will check Admin will update Updated successfully
Complaint the Complaint Complaint Status or unsuccessfully
details
6 Driver login Driver will enter Login successfully or if Login successfully or
email and incorrect login details Login unsuccessfully
password “Login unsuccessfully”
7 daily work Driver will check Driver will update work Updated successfully
updates the garbage Status or unsuccessfully
details
8 Create Business All the details Create Created
Business created by all successfully successfully or
details like created
name,address unsuccessfully
, phone etc
9 View my Mechanic check Mechanic view business View all business
Business and view all details details
business details
10 Update Geo Mechanic Drag and drop the Updated successfully
Location update location location or unsuccessfully
of shop in
google map
CHAPTER 8
RESULT
The model training process reached epoch 54, and during this epoch, the model
demonstrated promising performance. The model achieved a total loss of 0.04375,
with individual losses for boxes, objects, and classes being 0.02705, 0.004817,
and 0.01188, respectively. The evaluation metrics on the test dataset showed
impressive results, with a precision of 0.882, indicating a high percentage of correct
positive predictions, and a recall of 0.863, reflecting a strong capture rate of actual
positive instances. The model's mean average precision (mAP) at an IoU threshold
of 0.5 was 0.92, indicating its effectiveness in accurately detecting objects.
Furthermore, the model achieved an mAP of 0.757 across IoU thresholds ranging
from 0.5 to 0.95, showcasing its consistent performance. Analyzing the results by
class, the model demonstrated excellent performance in detecting both "Clean"
and "Dirty" objects, with precision scores of 0.867 and 0.898, and recall scores of
0.892 and 0.835, respectively. The mAP scores at an IoU threshold of 0.5 were
0.925 for the "Clean" class and 0.914 for the "Dirty" class. On the basis of the
Confusion matrix we got the accuracy of 88.60%.Overall these results highlight the
model's effectiveness in accurately detecting objects, specifically in differentiating
between "Clean" and "Dirty" classes, as evidenced by its high precision, recall, and
mAP scores.
CHAPTER 9
CONCLUSION AND FUTURE WORK
Furthermore, the system can benefit from incorporating advanced analytics and
data visualization techniques. Analyzing historical data on garbage bin usage and
overflow patterns can help identify hotspots and optimize resource allocation.
Visualizing this data through interactive dashboards can provide insights for
decision-makers and aid in strategic planning for waste management.
Overall, this project lays a strong foundation for efficient garbage bin management
and waste management practices. By continually refining the object detection
model, incorporating advanced analytics, and leveraging emerging technologies,
such as Internet of Things (IoT) devices and machine learning algorithms, the
system can contribute to sustainable waste management and cleaner urban
environments in the future.
REFERENCES
1. Subbiah Geetha , Jayit Saha , Ishita Dasgupta , Rahul Bera , Isah A. Lawal
and Seifedine Kadry. “Design of Waste Management System Using Ensemble
Neural Networks” March-2022
4. Siddhant Bansal , Seema Patel ,Ishita Shah, Prof. Alpesh Patel, Prof. Jagruti
Makwana, Dr. Rajesh Thakker. “AGDC: Automatic Garbage Detection and
Collection” August-2019
9. Joseph Redmon,Santosh Divvala, Ross Girshick, Ali Farhadi. “You Only Look
Once: Unified, Real-Time Object Detection”
10. Peiyuan Jiang, Daji Ergu, Fangyao Liu, Ying Cai, Bo Ma. “A Review of Yolo
Algorithm Developments”
11. Tausif Diwan, G.Anirudh, and Jitendra V. Tembhurne. “Object detection using
YOLO: challenges, architectural successors, datasets and applications”