An industrial oriented major project report

on

Deep learning for edge computing in indian smart cities : real time
analytics on low power devices
Submitted by

B Teja Karthik :21W91A6704

B Prabhakar :21W91A6703
E Vikas :21W91A6711
K Akhil Kumar :22W95A6705

Under the Esteemed Guidance of

Mr. T. SATHISH
Asst.Professor, CSE

TO

Jawaharlal Nehru Technological University, Hyderabad

In partial fulfillment of the requirements for award of degree of

BACHELOR OF TECHNOLOGY
IN
COMPUTER SCIENCE AND ENGINEERING(DATA SCIENCE)

DEPARTMENT OF COMPUTER SCIENCE AND ENGINEERING(DATA SCIENCE)

MALLA REDDY INSTITUTE OF ENGINEERING AND TECHNOLOGY
(UGC AUTONOMOUS)
(Sponsored by Malla Reddy Educational society)
(Affiliated to JNTU, Hyderabad)
Maisammaguda, Dhulapally post, Secunderabad-500014
2024-2025
 CERTIFICATE

This is to certify that this is the Bonafide record of the project titled “Deep learning for edge
computing in Indian smart cities : real time analytics on low power devices” submitted by
B.Teja Karthik(21W91A6704), B.Prabhakar(21W91A6703), E.Vikas(21W91A6711),
K.Akhil Kumar(22W95A6705) Student of B Tech Ⅳ Year – II Semester in the partial
fulfillment of the requirements for the degree of Bachelor of Technology in Computer Science
and Engineering (Data Science), Dept. of CSE (DS) during the year 2024-2025. The results
embodied in this project report have not been submitted to any other university or institute for
the award of any degree or diploma.

Project Guide Head of the Department

Mr. T. SATHISH Dr. MOHD ASHFAQUL HASSAN

EXTERNAL EXAMINER

Date of Viva-Voce Examination held on:

 DECLARATION

I hereby declare that the project entitled “Deep learning for edge computing in indian smart
cities : real time analytics on low power devices” submitted to Malla Reddy Institute of
Engineering and Technology, Autonomous Institution, affiliated to Jawaharlal Nehru
Technological University Hyderabad (JNTUH) as part of Ⅳ Year B. Tech – II Semester and for
the partial fulfilment of the requirement for the award of Bachelor of Technology in Computer
Science and Engineering ( Data Science ) is a result of original research work done by me.

It is further declared that the project report or any part thereof has not been previously submitted
to any University or Institute for the award of degree or diploma.

B Teja Karthik :21W91A6704

B Prabhakar :21W91A6703
E Vikas :21W91A6711
K Akhil Kumar :22W95A6705
 ACKNOWLEDGEMENT

First and foremost, I am grateful to the Principal Dr. P. SRINIVAS, for providing me with all the
resources in the college to make my project a success. I thank him for his valuable suggestions at the time
of seminars which encouraged me to give my best in the project.

I would like to express my gratitude to Dr. MOHD ASHFAQUL HASAN, Head of the Department,
Department of Computer Science and Engineering for his support and valuable suggestions during the
dissertation work.

I offer my sincere gratitude to my project - coordinator Mr. S. SELVAMANI and internal guide
Mr. T. SATHISH, Assistant Professor of Computer Science and Engineering (DS) department who
have supported me throughout this project with their patience and valuable suggestions.

I would also like to thank all the supporting staff of the Dept. of CSE (DS) and all other departments who
have been helpful directly or indirectly in making the project a success.

I am extremely grateful to my parents for their blessings and prayers for my completion of project that
gave me strength to do my project.

B.Teja Karthik – 21W91A6704

B.Prabhakar - 21W91A6703

E.Vikas - 21W91A6711

K.Akhil Kumar – 22W95A6705

 ABSTRACT
Smart cities in India are rapidly evolving with a focus on using technology to improve urban
living conditions, optimize infrastructure, and ensure sustainable development. As part of this
transformation, the need for real-time analytics, powered by artificial intelligence (AI) and
machine learning, is crucial for decision-making, especially in areas like traffic management,
waste management, healthcare, and energy efficiency. However, traditional cloud-based
computing is not always feasible due to the large volume of data generated, network latency, and
privacy concerns. This project aims to leverage edge computing for real-time deep learning
analytics on low-power devices in Indian smart cities. By processing data locally, at the "edge"
of the network, instead of sending it to centralized cloud servers, the system can reduce latency,
improve privacy, and operate in real-time. The project will focus on deploying deep learning
models on low-power edge devices, such as Raspberry Pi, Nvidia Jetson, and Intel Movidius, to
process and analyze data efficiently.

i
 TABLE OF CONTENT

Chapter No. Contents PageNo

Abstract i

List of figures iv

List of output screens ⅴ

1 INTRODUCTION 1-5
1.1 Motivation 1-2
1.2 Problem definition 2-3
1.3 Objective of the Project 3
1.4 Limitations of project 4
1.5 Organization of Documentation 5

2 LITERATURE SURVEY 6-9

2.1 Introduction 6
2.2 Existing System 7
2.3 Proposed System 8
2.4 Conclusion 9

3 ANALYSIS 10-17
3.1 Introduction 10-11
3.2 Software Requirements Specifications 12
3.2.1 User Requirements 12
3.2.2 Software Requirements 12-13
3.2.3 Hardware Requirements 14
3.3 Architecture Diagram of project 15
3.4 Algorithms and Flowcharts 15-17
3.5 Conclusion 17
4 Design 18-23
4.1 Introduction 18-19
4.2 UML Diagrams 19
4.2.1 Use Case Diagram 20
4.2.2 Class Diagram 21
4.2.3 Sequence Diagram 22
4.2.4 Activity Diagram 23
4.3 Module Design & Organization 24-25
4.4 Conclusion 26

5 IMPLEMENTATION & RESULTS 27-53

5.1 Introduction 27-36
5.2 Explanation of Key features 36
5.3 Method of Implementation 37
5.3.1 Source Code 37-46
5.3.2 Output Screens 47-51
5.3.3 Result Analysis 52
5.4 Conclusion 53

6 TESTING & VALIDATION 54-57

6.1 Introduction 54
6.2 Valisation 54-56
6.3 Conclusion 57

CONCLUSION 58
FUTURE ENHANCEMENT 59
REFERENCE 60

LIST OF FIGURES
Fig.no Figure Title Page No

3.3(a) Architecture Diagram 15

4.2.1 Use Case Diagram 20

4.2.2 Class Diagram 21

4.2.3 Sequence Diagram 22

4.2.4 Activity Diagram 23

6.2.1 Black Box Testing 56

6.2.2 Black Box Testing for Machine Learning Algoritm 56

iv

LIST OF SCREENSHOTS
Fig.no Output Screen Shots Page No

5.3.2.1 Cloud Server Terminal 47

5.3.2.2 Home Page 48
5.3.2.3 Training Completion 48
5.3.2.4 Selecting & Upload Video 49
5.3.2.5 Detecting Traffic Content 49
5.3.2.6 Run Edge to Report Processed data 50
5.3.2.7 Send Processed Data 50
5.3.2.8 Cloud Server Received Edge 51
5.3.2.9 Delay of Latency Graph 51

ⅴ
 Deep learning for edge computing in indian smart cities : real time analytics on low power devices

CHAPTER 1

INTRODUCTION

1.1 MOTIVATION

The integration of deep learning with edge computing holds immense potential for transforming
Indian smart cities. By processing data locally on low-power devices, we can unlock real-time
insights from sensor data, enabling faster decision-making and more efficient resource
utilization. This project aims to develop and implement practical solutions for various smart city
applications, such as traffic management, environmental monitoring, and public safety. By
pioneering this technology, we can address the challenges posed by data latency and bandwidth
constraints, while also contributing to the development of sustainable and resilient urban
environments.

Key Motivations:

1. Real-time Decision Making: Edge computing enables real-time analysis of data at the
source, allowing for swift decision-making and immediate responses to dynamic urban
conditions.
2. Reduced Latency: By processing data locally, edge computing eliminates the need for
data transmission to remote servers, significantly reducing latency and improving system
responsiveness.
3. Enhanced Privacy: Processing sensitive data at the edge minimizes the risk of data
breaches and privacy violations, as less data needs to be transmitted to centralized
servers.
4. Reduced Network Congestion: Offloading data processing to edge devices can alleviate
network congestion, especially during peak usage hours.
5. Improved Scalability: Edge computing can scale more efficiently by distributing
processing tasks across multiple edge devices, making it suitable for large-scale urban
deployments.

1
 Deep learning for edge computing in indian smart cities : real time analytics on low power devices

6. Energy Efficiency: By optimizing models and hardware, edge computing can reduce
energy consumption, making it more sustainable.

1.2 PROBLEM DEFINITION

Indian smart cities are rapidly deploying an extensive network of Internet of Things (IoT)
sensors and devices to monitor and manage various urban services, including traffic flow,
environmental conditions, public safety, and energy consumption. This proliferation of
interconnected devices generates a massive and continuous stream of data, offering
unprecedented opportunities for data-driven decision-making and optimization. However, the
sheer volume and velocity of this data, coupled with the inherent limitations of traditional cloud-
based processing paradigms, present significant challenges.

1. Resource Constraints of Edge Devices: Edge devices, often based on microcontrollers

or embedded systems, possess limited processing capabilities, making the execution of
complex deep learning models challenging. The memory available on edge devices is
often constrained, restricting the size and complexity of deep learning models that can be
deployed. Many edge devices are battery-powered or operate in remote locations,
necessitating energy-efficient algorithms and model designs to prolong operational
lifespan. The diverse range of edge devices deployed in smart cities leads to varying
hardware specifications and software environments, demanding adaptable and scalable
solutions.
2. Data Volume and Velocity: Data from multiple sensors (e.g., cameras, LiDAR,
environmental sensors) is often high-dimensional and heterogeneous, requiring
sophisticated feature extraction and dimensionality reduction techniques. The need for
real-time analysis necessitates low-latency processing pipelines capable of handling
continuous data streams. Raw sensor data may contain redundancies and noise, requiring
robust preprocessing and filtering algorithms. The data generated is often distributed
across many edge devices, making data aggregation for training and inference complex.
3. Network Latency and Bandwidth Limitations: Relying on cloud-based processing
introduces significant latency due to network transmission delays, particularly in areas

2
 Deep learning for edge computing in indian smart cities : real time analytics on low power devices

with poor connectivity. Transmitting large volumes of data to the cloud consumes
substantial network bandwidth, potentially leading to congestion and delays. Some edge
devices may operate in areas with intermittent or unreliable network connectivity,
necessitating offline processing capabilities. Many smart city applications such as traffic
accident detection, or public safety applications require extremely low latency responses.
4. Privacy and Security: Transmitting sensitive data (e.g., facial recognition, location data)
to the cloud raises concerns about unauthorized access and data breaches. Adhering to
data privacy regulations and ensuring compliance with relevant standards is crucial. Edge
devices and deep learning models are vulnerable to adversarial attacks, such as data
poisoning and model manipulation. Ensuring the secure deployment and update of deep
learning models on edge devices is essential. It is important to explore privacy preserving
techniques such as federated learning, and differential privacy.
5. Model Optimization for Edge Deployment: Techniques such as quantization, pruning,
and knowledge distillation are needed to reduce the size and complexity of deep learning
models for edge deployment. Leveraging specialized hardware accelerators (e.g., GPUs,
TPUs, NPUs) on edge devices can improve inference speed and energy efficiency.
Selecting appropriate deep learning algorithms that balance accuracy and computational
efficiency is crucial. The environment of a smart city is constantly changing, so continual
learning techniques are needed to update the models on the edge devices.

1.3 OBJECTIVE OF THE PROJECT

This project aims to address these challenges by developing and deploying edge-based deep
learning solutions that enable:

● Real-time analytics and decision-making on edge devices.

● Reduced network latency and bandwidth consumption.
● Enhanced data privacy and security.
● Efficient resource utilization on constrained edge devices.
● Scalable and adaptable solutions for diverse smart city applications.
● Robustness to network intermittency.

3
 Deep learning for edge computing in indian smart cities : real time analytics on low power devices

By achieving these objectives, this project seeks to improve the efficiency, responsiveness, and
sustainability of smart city services in India.

1.4 LIMITATION OF THE PROJECT

● Hardware Heterogeneity and Compatibility: The wide variety of edge devices with
diverse hardware specifications may pose challenges in ensuring compatibility and
consistent performance of deep learning models.
● Data Quality and Availability: The accuracy and reliability of deep learning models
depend heavily on the quality and quantity of training data.
● Model Optimization and Deployment: Optimizing deep learning models for resource-
constrained edge devices may lead to a trade-off between accuracy and efficiency.
● Network Connectivity and Reliability: Intermittent or unreliable network connectivity
may hinder real-time data processing and model updates.
● Security and Privacy Concerns: Protecting sensitive data processed on edge devices from
unauthorized access and cyberattacks is crucial.
● Scalability and Maintainability: Scaling the edge-based deep learning system to
accommodate the growing number of edge devices and data streams can be challenging.
● Computational Complexity of Advanced Algorithms: Some complex deep learning
algorithms may still be computationally demanding for edge devices.

4
 Deep learning for edge computing in indian smart cities : real time analytics on low power devices

1.5 ORGANIZATION OF DOCUMENTATION

1. Abstract: Provides a summary of the project, including the problem, aim, and focus.
2. Introduction: Explains the context of smart cities in India, the role of real-time data
analytics, and the limitations of traditional cloud computing. It also introduces edge
computing as a solution.
3. Existing System: Describes the current reliance on cloud computing for data analytics in
smart cities and its disadvantages, such as latency, bandwidth constraints, and privacy
concerns.
4. Proposed System: Details the edge computing system with deep learning models for real-
time analytics on low-power edge devices. It also lists the advantages of the proposed
system, including reduced latency, lower bandwidth usage, and improved privacy.
5. Literature Review: Presents a review of relevant research papers and surveys on edge
computing and deep learning in smart cities.
6. Hardware Requirements: Lists the hardware components required for the system, such as
the processor, hard disk, monitor, and input devices.
7. Software Requirements: Specifies the software components required, including the
operating system, coding language, tool, and database.
8. System Design: Provides an overview of the Unified Modeling Language (UML) and its
purpose in software engineering.
9. UML Diagrams: Explains various UML diagrams used in the system design, including
use case diagrams, class diagrams, sequence diagrams, and activity diagrams.

5
 Deep learning for edge computing in indian smart cities : real time analytics on low power devices

CHAPTER - 2
LITERATURE SURVEY

2.1 INTRODUCTION:

Dr. S. Kumar, Prof. R. Patel [1] This survey paper provides an in-depth overview of edge
computing's role in smart cities, particularly in the context of real-time analytics. The authors
discuss various use cases, such as traffic management, healthcare monitoring, and environmental
sensing, where edge computing can be used to overcome the challenges of latency, bandwidth,
and data privacy. The paper also highlights the challenges of implementing edge computing in
smart cities, including the limited processing capabilities of edge devices, the need for seamless
integration with cloud platforms, and security concerns.

Dr. M. Patel, Dr. K. Sharma [2] This research paper explores the integration of deep learning
models on low-power edge devices in smart city applications. It highlights the potential of edge
AI to process sensor data in real-time, enabling applications such as traffic prediction, anomaly
detection, and environmental monitoring. The paper presents case studies of successful
implementations of edge AI in smart cities and evaluates the performance of different edge
devices like Raspberry Pi and Nvidia Jetson for running deep learning models.

Dr. A. Singh, Prof. R. Kapoor [3] This paper examines the use of deep learning techniques for
optimizing smart city operations, particularly in areas such as energy management, waste
collection, and public safety. The authors discuss how real-time data analytics, powered by deep
learning, can improve operational efficiency and decision-making. The paper also explores the
technical challenges of deploying deep learning models on resource-constrained devices and the
trade-offs between model accuracy and computational requirements.

6
 Deep learning for edge computing in indian smart cities : real time analytics on low power devices

2.2 EXISTING SYSTEM

In the current landscape of smart cities, most data analytics solutions rely heavily on cloud
computing. Data from sensors deployed in cities — including cameras, IoT devices,
environmental sensors, and traffic counters — is sent to cloud servers for processing. While
cloud computing offers powerful computing capabilities, it is often limited by issues like high
latency, bandwidth constraints, data privacy concerns, and the need for continuous connectivity.
For instance, traffic management systems in Indian cities typically use cloud servers to process
camera footage and sensor data, but delays in transmission and analysis can hinder real-time
decision-making, especially in traffic control and emergency services.
Moreover, in low-latency applications, such as real-time traffic monitoring or air quality
tracking, the reliance on cloud infrastructure introduces significant bottlenecks, especially when
large volumes of data need to be processed instantaneously. This issue becomes even more
critical in densely populated urban environments, where the volume of data generated is vast,
and network infrastructure is often unreliable or congested.

Disadvantages:

1. High Latency: Sending data to centralized cloud servers results in high latency, which is
problematic for time-sensitive applications like traffic management or emergency response.
2. Bandwidth Constraints: The large volume of data generated by sensors and devices in
smart cities requires high-bandwidth networks, which may not be available in all regions,
especially in developing areas.
3. Data Privacy and Security Concerns: Transmitting sensitive data to centralized servers
raises concerns about data privacy and security, particularly in public safety, healthcare, and
personal data applications.

7
 Deep learning for edge computing in indian smart cities : real time analytics on low power devices

2.3 PROPOSED SYSTEM:

The proposed system integrates edge computing with deep learning models for real-time
analytics on low-power edge devices. These edge devices, including single-board computers
like Raspberry Pi or AI-focused platforms like Nvidia Jetson or Intel Movidius, will run deep
learning models locally to process data in real-time. The system will be capable of handling
applications such as:

● Traffic Management: Real-time traffic monitoring, congestion detection, and intelligent

traffic signal control.
● Environmental Monitoring: Air quality monitoring, noise pollution detection, and water
quality assessment.
● Public Safety: Surveillance and security, crowd analysis, and emergency response.
● Smart Grid: Energy consumption monitoring, anomaly detection, and predictive
maintenance.
● Smart Buildings: Occupancy detection, energy efficiency optimization, and facility
maintenance.

By processing data locally, the system can reduce latency, improve response times, and enhance
privacy by minimizing data transmission to the cloud. Additionally, the system will be designed
to be energy-efficient, leveraging low-power hardware and optimized algorithms to minimize
power consumption.

Advantages:

1. Reduced Latency: Real-time data processing at the edge reduces the time required for
decision-making, making the system suitable for time-sensitive applications.
2. Lower Bandwidth Usage: Since data is processed locally, only relevant information is sent
to the cloud, optimizing bandwidth usage.
3. Improved Privacy: Sensitive data is processed locally, reducing the risks associated with
sending personal or private information to centralized cloud servers.

8
 Deep learning for edge computing in indian smart cities : real time analytics on low power devices

2.4 CONCLUSION:

For the "Deep Learning for Edge Computing in Indian Smart Cities" project, the existing
system relies heavily on cloud computing for smart city data analytics, where data from sensors
is transmitted to cloud servers for processing; this approach, while leveraging the cloud's
powerful computing capabilities, introduces limitations such as high latency, bandwidth
constraints, data privacy vulnerabilities, and a requirement for continuous connectivity,
hindering real-time responsiveness, particularly in critical applications like traffic management
and emergency services. In contrast, the proposed system seeks to overcome these shortcomings
by integrating edge computing with deep learning models to enable real-time analytics on low-
power edge devices, processing data locally to reduce latency, optimize bandwidth usage, and
enhance privacy, thereby facilitating timely decision-making across various smart city functions,
including traffic monitoring, air quality assessment, and waste management.

Regarding the "Automated Emerging Cyber Threat Identification and Profiling Based on
Natural Language Processing" project, while the provided document doesn't detail a traditional
"existing system," it's understood that conventional cyber threat detection involves methods like
signature-based detection, statistical anomaly detection, and manual log analysis, which can be
slow, ineffective against new threats, and prone to errors. The proposed system aims to advance
cyber threat identification and profiling by employing Natural Language Processing (NLP) to
automate the analysis of text-based cyber threat data, striving for quicker and more precise
identification of emerging threats, and lessening the dependence on manual analysis.

9
 Deep learning for edge computing in indian smart cities : real time analytics on low power devices

CHAPTER - 3

ANALYSIS
3.1 INTRODUCTION

With the rapid urbanization in India, the concept of "smart cities" has become central to solving
the challenges of infrastructure, traffic management, waste management, energy consumption,
and environmental monitoring. Real-time data analytics is a key enabler for smart cities, as it
allows authorities to make timely decisions that optimize city operations and enhance the quality
of life for residents. However, traditional cloud computing models, where data is sent to a central
server for processing, face limitations, including network congestion, latency, and bandwidth
requirements.

Edge computing addresses these challenges by bringing computation and data storage closer to
the data source. In a smart city context, this involves deploying low-power devices that can
collect, process, and analyze data locally before transmitting only the necessary information to a
central server or cloud. Integrating deep learning algorithms on these edge devices allows for
real-time analytics, which is crucial for applications like traffic monitoring, waste management,
and environmental monitoring.

This project explores the implementation of deep learning on low-power edge devices to process
real-time data locally in Indian smart cities. The study will evaluate the advantages, challenges,
and potential of using edge AI for urban analytics, focusing on performance, energy
consumption, and scalability.

10
 Deep learning for edge computing in indian smart cities : real time analytics on low power devices

REQUIREMENT ANALYSIS

Requirement analysis is the process of defining the expectations of the stakeholders and users
from the software product. It involves gathering, documenting, and validating the requirements
to ensure that they are clear, complete, and consistent. This is a crucial step in the software
development lifecycle as it forms the basis for the design, implementation, and testing phases.

Functional Requirements:

1. Data Collection: The system should be able to collect data from various sensors and
devices deployed in smart cities (e.g., cameras, IoT devices, environmental sensors).
2. Data Processing: The system should be able to process the collected data in real-time on
edge devices using deep learning models.
3. Model Deployment: The system should support the deployment and execution of deep
learning models on low-power edge devices.
4. Output/Actions: The system should be able to provide outputs or trigger actions based on
the analysis of the data (e.g., traffic management decisions, air quality alerts, waste
management optimization).

Non-Functional Requirements:

1. Performance: The system should process data with low latency to enable real-time
decision-making.
2. Scalability: The system should be scalable to handle increasing volumes of data and the
addition of more edge devices.
3. Reliability: The system should operate reliably and consistently in potentially challenging
environmental conditions.
4. Security: The system should ensure the security and privacy of the data processed on
edge devices.
5. Energy Efficiency: The system should be energy-efficient to prolong the operational life
of edge devices.

11
 Deep learning for edge computing in indian smart cities : real time analytics on low power devices

3.2 SOFTWARE REQUIREMENTS SPECIFICATIONS:

3.2.1 USER REQUIREMENT:

1. Real-time Monitoring and Analysis: Users need to access real-time data and analysis of
various urban parameters, such as traffic flow, air quality, and waste levels.
2. Efficient Decision-Making: Users require the system to provide actionable insights and
support timely decision-making to optimize city operations and improve the quality of
life for residents.
3. Alerts and Notifications: Users need to receive timely alerts and notifications about
critical events or anomalies, such as traffic congestion, pollution spikes, or unusual
patterns in waste generation.
4. Data Visualization: Users need intuitive and user-friendly interfaces to visualize the
analyzed data and system performance.
5. System Integration: The system should be able to integrate with existing smart city
infrastructure and platforms.
6. Accessibility: Users should be able to access the system and its information from various
devices and locations.

3.2.2 SOFTWARE REQUIREMENTS:

The application should support commonly used operating systems, such as Windows,
macOS, and Linux. It is essential to ensure that the application runs seamlessly on various
versions of these operating systems, considering that backward compatibility may not always
be guaranteed.

Operating System:

The application should support commonly used operating systems, such as Windows,
macOS, and Linux. It is essential to ensure that the application runs seamlessly on various
versions of these operating systems, considering that backward compatibility may not always
be guaranteed.

12
Deep learning for edge computing in indian smart cities : real time analytics on low power devices

1. API and Libraries:The application may require specific APIs or libraries to process
textual data, integrate with data sources, and implement machine learning models. The
availability of these dependencies is vital for the application's core functionalities.
2. Web Browser Integration:If the application includes web-based components, it should
be compatible with popular web browsers like Google Chrome, Mozilla Firefox, and
Microsoft Edge. This ensures a user-friendly experience across different platforms.
3. Software Requirements:For the development and deployment of the cyber threat
identification application, the following software components are necessary:
4. Integrated Development Environment (IDE):Visual Studio Code or PyCharm
Community Edition
5. Programming Language:Python (version 3.7 or higher)
6. NLP and Data Analysis Libraries:Libraries such as NumPy, Pandas, NLTK, SpaCy,
Scikit-learn, TensorFlow, or PyTorch
7. Web Framework:Flask or Django for web-based user interfaces
8. Deployment Tools:Docker or Kubernetes for containerized deployment Git for version
control and team collaboration.
9. Monitoring and Logging Tools:ElasticSearch, Logstash, and Kibana (ELK stack) for
system performance monitoring and log analysis, the compatibility and specific versions
of these software components should be carefully documented to ensure seamless
development, deployment, and operational process for the application.

13
 Deep learning for edge computing in indian smart cities : real time analytics on low power devices

3.2.3 HARDWARE REQUIREMENTS:

Architecture:

The cyber threat identification and profiling application should be compatible with the x86
architecture, which is the most widely used architecture for desktop and server systems.
Additionally, the application may need to support other architectures, such as ARM, to ensure
compatibility with mobile devices or embedded systems, if required.

Processing Power:

The minimum recommended processor for running the application is an Intel Core i5 or
equivalent. The CPU should have a clock speed of 2.5 GHz or higher to efficiently process large
volumes of threat data and execute complex machine learning tasks.

Memory (RAM):

The application requires a minimum of 4 GB of RAM for basic operation. For optimal
performance, especially when handling extensive datasets or training sophisticated machine
learning models, 8 GB of RAM or more is recommended.

Secondary Storage (Hard Disk):

The application requires at least 50 GB of available storage space on the hard disk. This storage
is necessary for the application software, threat data, logs, and temporary files generated during
data analysis and detection processes.

Display Adapter:

While the application does not have high-end graphics requirements, a dedicated graphics
processing unit (GPU) or a modern integrated graphics chipset is recommended. This will
provide hardware acceleration for certain computational tasks, such as running deep learning
models, enhancing the overall system performance.

Peripherals:

Depending on the operational requirements, the application may need to support various
peripherals, including:

Network Adapter: For accessing external threat intelligence sources and online databases.

14
 Deep learning for edge computing in indian smart cities : real time analytics on low power devices

3.3 ARCHITECTURE DIAGRAM OF PROJECT:

Fig 3.3(a) : Architecture diagram

3.4 ALGORITHMS AND FLOWCHARTS:

● Algorithms:
○ Deep Learning Algorithms:
1. Convolutional Neural Networks (CNNs): If the project involves image or
video processing (e.g., traffic monitoring, object detection), CNNs are
highly likely. CNNs excel at extracting spatial hierarchies of features from
images. For example, in traffic monitoring, a CNN could be trained to
identify vehicles, pedestrians, and traffic signals.
2. Recurrent Neural Networks (RNNs) or LSTMs: If the project deals with
time-series data (e.g., air quality monitoring, predicting pollution levels),
RNNs or Long Short-Term Memory (LSTM) networks might be used.
These are designed to handle sequential data and capture temporal
dependencies.

15
Deep learning for edge computing in indian smart cities : real time analytics on low power devices

3. Other Deep Learning Models: Depending on the specific application, other

models like autoencoders (for anomaly detection) or graph neural
networks (for traffic flow optimization) could also be employed.

○ Model Optimization Algorithms:

1. Quantization: This technique reduces the precision of the model's weights
(e.g., from 32-bit floating point to 8-bit integers). This significantly
reduces model size and speeds up inference on edge devices but may
slightly impact accuracy.
2. Pruning: This involves removing less important connections (weights)
from the neural network. Sparse models are smaller and faster.
3. Knowledge Distillation: A large, accurate model (better suited for a
server) trains a smaller, less complex model that is suitable for the edge
device.
● Flowchart:
○ Here's a more detailed flowchart:
1. Data Acquisition:
■ Sensors (cameras, LiDAR, environmental sensors, IoT devices)
collect raw data from the smart city environment.
2. Edge Processing:
■ Data Preprocessing:
■ Cleaning: Removing noise, handling missing values.
■ Filtering: Smoothing data, removing outliers.
■ Formatting: Converting data into a suitable format for the
deep learning model.
■ Feature Extraction:
■ For images/video: CNN layers automatically extract
features.
■ For time-series: Statistical features or learned features are
extracted.

16
 Deep learning for edge computing in indian smart cities : real time analytics on low power devices

■ Deep Learning Inference:

■ The preprocessed data is fed into the optimized deep
learning model.
■ The model generates predictions or analysis results (e.g.,
traffic density, pollution level, anomaly score).
3. Decision/Action:
■ Local Action:Edge device directly controls actuators or triggers
local responses (e.g., adjusting traffic lights, activating ventilation
systems).
■ Alert/Notification:The system generates alerts or notifications
based on the analysis (e.g., warning of high pollution levels).
4. Data Transmission (if needed):
■ Selective Transmission: Only essential information (e.g., alerts,
aggregated statistics) is transmitted to a central server or cloud.

3.5 CONCLUSION:

This project leverages deep learning algorithms, primarily Convolutional Neural Networks
(CNNs) for image/video processing in applications like traffic monitoring, and Recurrent Neural
Networks (RNNs) or LSTMs for time-series data analysis, such as air quality monitoring.

Given the resource constraints of edge devices, model optimization algorithms such as
quantization, pruning, and knowledge distillation are essential to reduce model size and
complexity while maintaining acceptable performance. The general flow involves data
acquisition from sensors, edge processing that includes preprocessing, feature extraction, and
deep learning inference, a decision/action stage where the system takes local action or sends
alerts, and optional data transmission of summarized information to a central server. In essence,
the project uses deep learning on edge devices for real-time smart city data analysis, emphasizing
local processing for reduced latency, bandwidth efficiency, and enhanced privacy, with model
optimization as a key component for efficient edge device operation.

17
 Deep learning for edge computing in indian smart cities : real time analytics on low power devices

CHAPTER – 4

DESIGN

4.1 INTRODUCTION

The design sits at the technical kernel of the software engineering process and is applied
regardless of the development paradigm and area of application. Design is the first step in the
development phase for any engineered product or system. The designer’s goal is to produce a
model or representation of an entity that will later be built. Once system requirements have
been specified and analyzed, system design is the first of the three technical activities -design,
code and test that are required to build and verify software.
The importance can be stated with a single word “Quality.” Design is the place where quality
is fostered in software development. The design provides us with representations of software
that can assess quality. Design is the only way that we can accurately translate a customer’s
view into a finished software product or system. Software design serves as a foundation for all
the software engineering steps that follow. Without a strong design we risk building an
unstable system – one that will be difficult to test, one whose quality cannot be assessed until
the last stage. The purpose of the design phase is to plan a solution to the problem specified by
the requirement document.

This phase is the first step in moving from the problem domain to the solution domain. In
other words, starting with what is needed, design takes us toward how to satisfy the needs. The
design of a system is perhaps the most critical factor affecting the quality of the software; it has
a major impact on the later phase, particularly testing, and maintenance. The output of this
phase is the design document. This document is similar to a blueprint for the solution and is
used later during implementation, testing and maintenance. The design activity is often divided
into two separate phases System Design and Detailed Design.

System Design, also called top-level design, aims to identify the modules that should be in
the system, the specifications of these modules, and how they interact with each other to

18
 Deep learning for edge computing in indian smart cities : real time analytics on low power devices

produce the desired results. At the end of the system design, all the major data structures, file
formats, output formats, and the major modules in the system and their specifications are
decided. During Detailed Design, the internal logic of each of the modules specified in the
system design is decided. During this phase, the details of the data of a module are usually
specified in a high-level design description

4.2 UML DIAGRAMS:

UML stands for Unified Modeling Language. UML is a standardized general-purpose modeling
language in the field of object-oriented software engineering. The standard is managed, and was
created by, the Object Management Group.

The goal is for UML to become a common language for creating models of object oriented
computer software. In its current form UML is comprised of two major components: a Meta-
model and a notation. In the future, some form of method or process may also be added to; or
associated with, UML.

The Unified Modeling Language is a standard language for specifying, Visualization,

Constructing and documenting the artifacts of software system, as well as for business modeling
and other non-software systems. The UML represents a collection of best engineering practices
that have proven successful in the modeling of large and complex systems.The UML is a very
important part of developing objects oriented software and the software development process.
The UML uses mostly graphical notations to express the design of software projects.

GOALS:
The Primary goals in the design of the UML are as follows:

1. Provide users a ready-to-use, expressive visual modeling Language so that they can
develop and exchange meaningful models.
2. Provide extendibility and specialization mechanisms to extend the core concepts
3. Be independent of particular programming languages and development process.

19
 Deep learning for edge computing in indian smart cities : real time analytics on low power devices

4. Provide a formal basis for understanding the modeling language.

5. Encourage the growth of OO tools market.
6. Integrate best practices.

4.2.1 USE CASE DIAGRAM:

A use case diagram in the Unified Modeling Language (UML) is a type of behavioral diagram
defined by and created from a Use-case analysis. Its purpose is to present a graphical overview
of the functionality provided by a system in terms of actors, their goals (represented as use
cases), and any dependencies between those use cases. The main purpose of a use case diagram
is to show what system functions are performed for which actor. Roles of the actors in the system
can be depicted.

Fig:4.2.1 Use case diagram for Deep learning for edge computing in indian smart cities : real time analytics on low power
devices

20
 Deep learning for edge computing in indian smart cities : real time analytics on low power devices

4.2.2 CLASS DIAGRAM:

In software engineering, a class diagram in the Unified Modeling Language (UML) is a type of
static structure diagram that describes the structure of a system by showing the system's classes,
their attributes, operations (or methods), and the relationships among the classes. It explains
which class contains information.

Fig:4.2.2 Class Diagram of Deep learning for edge computing in indian smart cities : real time analytics on low power
devices

21
 Deep learning for edge computing in indian smart cities : real time analytics on low power devices

4.2.3 SEQUENCE DIAGRAM:

A sequence diagram in Unified Modeling Language (UML) is a kind of interaction diagram that
shows how processes operate with one another and in what order. It is the construction of a
Message Sequence Chart. Sequence diagrams are sometimes called event diagrams, event
scenarios, and timing diagrams.

Fig:4.2.3 Sequence diagram for Deep learning for edge computing in indian smart cities : real time analytics on low power
devices

22
 Deep learning for edge computing in indian smart cities : real time analytics on low power devices

4.2.4 ACTIVITY DIAGRAM:

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.

23
 Deep learning for edge computing in indian smart cities : real time analytics on low power devices

Fig:4.2.4 Activity Diagram for Deep learning for edge computing in indian smart cities : real time analytics on low power
devices

4.3 MODULE DESIGN AND ORGANISATION:

To implement this project, we have designed the following modules:

1. Start Cloud Server:

● Function: This module initiates the cloud server application, which acts as the central hub
for receiving and processing data from edge devices.

24
 Deep learning for edge computing in indian smart cities : real time analytics on low power devices

● Importance: It establishes the communication endpoint for the entire system, allowing for
data aggregation, storage, and potentially further analysis or visualization.

2. Start Edge Server:

● Function: This module starts the edge server, which runs on the edge devices and is
responsible for local data processing and analysis.
● Importance: It enables real-time processing of data closer to the source, reducing latency
and bandwidth consumption.

3. Train & Load Deep Learning Algorithm:

● Function: This module trains and loads the deep learning algorithm (YOLO CNN in this
case) onto the edge device.
● Importance: It equips the edge device with the intelligence to perform object detection
and analysis locally, allowing for real-time traffic detection and counting.

4. Run Traffic Detection & Counting:

● Function: This module processes a video input to detect and count traffic elements (e.g.,
vehicles, pedestrians) using the loaded deep learning algorithm.
● Importance: It demonstrates the core functionality of the system in a real-world
application, providing valuable data for traffic management and analysis.

5. Upload Video:

● Function: This module allows the user to select and upload a video file for traffic
detection and counting.
● Importance: It provides a user-friendly way to input data into the system for processing.

6. Run Cloud to Report Image Data:

● Function: This module uploads the entire video frame/image data to the cloud server and
calculates the latency involved.
● Importance: It serves as a baseline for comparison to demonstrate the latency reduction
achieved by edge processing.

7. Run Edge to Report Processed Data:

● Function: This module sends only the processed output (e.g., traffic counts) from the
edge device to the cloud server and calculates the latency.
● Importance: It highlights the efficiency of edge computing by showing the reduced
amount of data transmitted and the resulting lower latency.

25
 Deep learning for edge computing in indian smart cities : real time analytics on low power devices

8. View Cloud Server Logs:

● Function: This module allows the user to view the logs on the cloud server, showing the
data received from the edge server.
● Importance: It provides a way to monitor the communication and data transfer between
the edge and the cloud.

9. Delay Comparison Graph:

● Function: This module visualizes the latency comparison between sending full image
data and processed data to the cloud.
● Importance: It provides a clear and intuitive representation of the performance benefits of
edge computing in terms of reduced latency.

4.4 CONCLUSION:

The design phase is a critical component of software engineering, serving as the bridge between
problem definition and solution implementation. It emphasizes quality by providing
representations of software that can be assessed and ensuring that customer needs are accurately
translated into a final product. UML, a standardized modeling language, plays a vital role in this
process, offering a visual and expressive way to design object-oriented software. The design
process is often divided into system design and detailed design, with system design focusing on
identifying modules and their interactions, and detailed design addressing the internal logic of

26
 Deep learning for edge computing in indian smart cities : real time analytics on low power devices

those modules. Ultimately, a well-executed design phase, utilizing tools like UML and a modular
approach, is crucial for developing high-quality, stable, and maintainable software systems.

Software design is a foundational activity within software engineering, crucial for translating
customer requirements into a working system. It's where quality is built in, providing the
blueprints for development, testing, and maintenance. The design process, often structured into
system and detailed design phases, defines the system's architecture, modules, and internal logic.
Unified Modeling Language (UML) serves as a key tool in this endeavor, offering a standardized
visual language for modeling object-oriented systems. UML facilitates communication,
documentation, and the overall understanding of complex software, supporting the creation of
robust and maintainable applications through various diagrams like use case, class, sequence,
and activity diagrams. The project's modular design, encompassing components like cloud and
edge servers, deep learning algorithm integration, and data processing functionalities, further
exemplifies the importance of a well-defined design in achieving the system's objectives.

CHAPTER - 5
IMPLEMENTATION AND RESULTS

5.1 INTRODUCTION :
The implementation phase represents the transition from theoretical design to a tangible,
operational system. For the "Deep Learning for Edge Computing in Indian Smart Cities" project,
this involves the practical deployment of deep learning models onto resource-constrained edge

27
 Deep learning for edge computing in indian smart cities : real time analytics on low power devices

devices to facilitate real-time data analysis within smart city environments. Similarly, the
"Automated Emerging Cyber Threat Identification and Profiling Based on Natural Language
Processing" project translates its analytical framework into a working application capable of
identifying and profiling cyber threats. This section will detail the development process,
including the specific technologies and methodologies employed to bring these systems to life,
and present the outcomes of this implementation.

This section focuses on the realization of the proposed solutions, detailing the implementation
strategies and the resulting outcomes. In the context of the "Deep Learning for Edge Computing"
project, this includes the development and integration of modules such as the Cloud Server, Edge
Server, and the deep learning algorithm for traffic detection and counting. For the cyber threat
identification project, "Automated Emerging Cyber Threat Identification and Profiling Based on
Natural Language Processing", this involves the application of a range of machine learning
algorithms, including CNN, SVM, and others, to process and interpret textual data for threat
identification. This section will provide a comprehensive overview of the implementation
processes and analyze the results achieved by each project.

What is Python:
Below are some facts about Python.

● Python is currently the most widely used multi-purpose, high-level programming

language.
● Python allows programming in Object-Oriented and Procedural paradigms. Python
programs generally are smaller than other programming languages like Java.
● Programmers have to type relatively less, and the indentation requirement of the language
makes them readable all the time.

28
Deep learning for edge computing in indian smart cities : real time analytics on low power devices

● Python language is being used by almost all tech-giant companies like – Google,
Amazon, Facebook, Instagram, Dropbox, Uber… etc.
● The biggest strength of Python is the huge collection of standard libraries which can be
used for the following
● Machine Learning
● GUI Applications (like Kivy, Tkinter, PyQt etc. )
● Web frameworks like Django (used by YouTube, Instagram, Dropbox)
● Image processing (like Opencv, Pillow)
● Web scraping (like Scrapy, BeautifulSoup, Selenium)
● Test frameworks
● Multimedia

Python is an interpreted high-level programming language for general-purpose programming.

Created by Guido van Rossum and first released in 1991, Python has a design philosophy that
emphasizes code readability, notably using significant whitespace.

Python features a dynamic type of system and automatic memory management. It supports
multiple programming paradigms, including object-oriented, imperative, functional and
procedural, and has a large and comprehensive standard library.

● Python is Interpreted − Python is processed at runtime by the interpreter. You do not need
to compile your program before executing it. This is like 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 also acknowledges that speed of development is important. Readable and terse code is
part of this, and so is access to powerful constructions that avoid tedious repetition of code.
Maintainability also ties into this may be an all but useless metric, but it does say something
about how much code you have to scan, read and/or understand to troubleshoot problems or
tweak behaviors. This speed of development, the ease with which a programmer of other
languages can pick up basic Python skills and the huge standard library is key to another area
where Python excels. All its tools have been quick to implement, saved a lot of time, and

29
 Deep learning for edge computing in indian smart cities : real time analytics on low power devices

several of them have later been patched and updated by people with no Python background -
without breaking.

History of Python:

What do the alphabet, and the programming language Python have in common? Right, both
start with ABC. If we are talking about ABC in the Python context, it's clear that the
programming language ABC is meant. ABC is a general-purpose programming language and
programming environment, which had been developed in the Netherlands, Amsterdam, at the
CWI (Centrum Wiskunde &Informatica). The greatest achievement of ABC was to influence
the design of Python. Python was conceptualized in the late 1980s. Guido van Rossum worked
at that time in a project at the CWI, called Amoeba, a distributed operating system. In an
interview with Bill Venners1, Guido van Rossum said: "In the early 1980s, I worked as an
implementer on a team building a language called ABC at Centrum voor Wiskunde en
Informatica (CWI). I don't know how well people know ABC's influence on Python. I try to
mention ABC's influence because I'm indebted to everything I learned during that project and
to the people who worked on it. "Later on in the same Interview, Guido van Rossum continued:
"I remembered all my experience and some of my frustration with ABC. I decided to try to
design a simple scripting language that possessed some of ABC's better properties, but without
its problems. So, I started typing. I created a simple virtual machine, a simple parser, and a
simple runtime. I made my own version of the various ABC parts that I liked. I created a basic
syntax, used indentation for statement grouping instead of curly braces or begin-end blocks,
and developed a small number of powerful data types: a hash table (or dictionary, as we call it),
a list, strings, and numbers."

Advantages of Python:
Let’s see how Python dominates over other languages.

a. Extensive Libraries:Python downloads with an extensive library and it contains code for
various purposes like regular expressions, documentation-generation, unit-testing, web browsers,

30
 Deep learning for edge computing in indian smart cities : real time analytics on low power devices

threading, databases, CGI,email, image manipulation, and more. So, we don’t have to write the
complete code for that manually.

b. Extensible:As we have seen earlier, Python can be extended to other languages. You can
write some of your code in languages like C++ or C. This comes in handy, especially in projects.

c. Embeddable:Complimentary to extensibility, Python is embeddable as well. You can put

your Python code in your source code of a different language, like C++. This lets us add
scripting capabilities to our code in the other language.

d. Readable:Because it is not such a verbose language, reading Python is much like reading
English. This is the reason why it is so easy to learn, understand, and code. It also does not need
curly braces to define blocks, and indentation is mandatory. These further aids the readability of
the code.

e. Object-Oriented:This language supports both the procedural and object-oriented

programming paradigms. While functions help us with code reusability, classes and objects let us
model the real world. A class allows the encapsulation of data and functions into one.

f. Free and Open-Source:Like we said earlier, Python is freely available. But not only can you
download Python for free, but you can also download its source code, make changes to it, and
even distribute it. It downloads with an extensive collection of libraries to help you with your
tasks.

g. Portable:When you code your project in a language like C++, you may need to make some
changes to it if you want to run it on another platform. But it isn’t the same with Python. Here,
you need to code only once, and you can run it anywhere. This is called Write Once Run
Anywhere (WORA). However, you need to be careful enough not to include any system-
dependent features.

h. Interpreted:Since statements are executed one by one, debugging is easier than in compiled
languages. Lastly, we will say that it is an interpreted language.

31
 Deep learning for edge computing in indian smart cities : real time analytics on low power devices

i. Improved Productivity:The language’s simplicity and extensive libraries render programmers

more productive than languages like Java and C++ do. Also, the fact that you need to write less
and get more things done.

j. IOT Opportunities:Since Python forms the basis of new platforms like Raspberry Pi, it finds
the future bright for the Internet of Things. This is a way to connect the language with the real
world.

Advantages of Python Over Other Languages:

A. Less Coding: Almost all the tasks done in Python require less coding when the same task is
done in other languages. Python also has awesome standard library support, so you don’t
have to search for any third-party libraries to get your job done. This is the reason that many
people suggest learning Python to beginners.
B. Affordable:Python is free therefore individuals, small companies or big organizations can
leverage the free available resources to build applications. Python is popular and widely used
so it gives you better community support.
C. Python is for Everyone:Python code can run on any machine whether it is Linux, Mac or
Windows. Programmers need to learn different languages for different jobs but with Python,
you can professionally build web apps, perform data analysis and machine learning, automate
things, do web scraping and also build games and powerful visualizations. It is an all-rounder
programming language.

Disadvantages of Python:

32
 Deep learning for edge computing in indian smart cities : real time analytics on low power devices

So far, we’ve seen why Python is a great choice for your project. But if you choose it, you
should be aware of its consequences as well. Let’s now see the downsides of choosing Python
over another language.

1. Weak in Mobile Computing and Browsers: While it serves as an excellent server-side

language, Python is very rarely seen on the client-side. Besides that, it is rarely ever used
to implement smartphone-based applications. One such application is called
Carbonnelle.The reason it is not so famous despite the existence of Brython is that it isn’t
that secure.
2. Design Restrictions: As you know, Python is dynamically typed. This means that you
don’t need to declare the type of variable while writing the code. It uses duck-typing. But
wait, what’s that? Well, it just means that if it looks like a duck, it must be a duck. While
this is easy on the programmers during coding, it can raise run-time errors.
3. Underdeveloped Database Access Layers: Compared to more widely used technologies
like JDBC (Java Database Connectivity) and ODBC (Open Database Connectivity),
Python’s database access layers are a bit underdeveloped. Consequently, it is less often
applied in huge enterprises.
4. Simple: No, we’re not kidding. Python’s simplicity can indeed be a problem. Take my
example. I don’t do Java; I’m more of a Python person. To me, its syntax is so simple
that the verbosity of Java code seems unnecessary.
5. Speed Limitations: We have seen that Python code is executed line by line. But since
Python is interpreted, it often results in slow execution. This, however, isn’t a problem
unless speed is a focal point for the project. In other words, unless high speed is a
requirement, the benefits offered by Python are enough to distract us from its speed
limitations.

What is Deep Learning

33
 Deep learning for edge computing in indian smart cities : real time analytics on low power devices

Deep learning is a subset of artificial intelligence and machine learning that utilizes artificial
neural networks with multiple layers (deep neural networks) to analyze and extract features from
data. Unlike traditional machine learning techniques that often require manual feature
engineering, deep learning models can automatically learn hierarchical representations of data,
enabling them to excel in complex tasks such as image and speech recognition, natural language
processing, and pattern recognition. This capability makes deep learning particularly well-suited
for applications involving large volumes of unstructured data, as seen in the "Deep Learning for
Edge Computing in Indian Smart Cities" project, where deep learning models analyze data from
various sensors for real-time decision-making, and in the "Automated Emerging Cyber Threat
Identification and Profiling Based on Natural Language Processing" project, where deep learning
aids in processing and understanding textual data for cyber threat detection.

The power of deep learning lies in its ability to learn intricate patterns and relationships within
data through these multi-layered neural networks. Each layer in a deep learning model
transforms the data representation into a higher, more abstract level, allowing the model to
progressively learn complex features. For instance, in image analysis, the initial layers might
detect edges and corners, while deeper layers identify objects and complex structures. This
automated feature learning is crucial for tasks where manual feature extraction is difficult or
impossible. In the context of the provided documents, deep learning facilitates real-time analytics
on edge devices in smart cities and enables the automated identification and profiling of
emerging cyber threats, demonstrating its versatility and effectiveness in tackling complex, data-
rich challenges.

Challenges in Deep Learning

1. Data Requirements: Deep learning models, especially complex ones, often require vast
amounts of labeled data to train effectively. In the context of smart cities, this means
collecting and annotating large datasets of sensor data, images, and videos, which can be
a significant undertaking. For cyber threat detection, it involves gathering and labeling
diverse datasets of network traffic, system logs, and threat reports.
2. Computational Resources: Training deep learning models is computationally intensive,
requiring powerful hardware like GPUs or TPUs. Even after training, deploying and

34
Deep learning for edge computing in indian smart cities : real time analytics on low power devices

running these models, especially in real-time, can be demanding, particularly on

resource-constrained edge devices in smart city applications. This necessitates model
optimization techniques.
3. Model Complexity and Interpretability: Deep learning models, especially deep neural
networks, can be complex "black boxes," making it difficult to understand how they
arrive at their decisions. This lack of interpretability can be a challenge in critical
applications where trust and explainability are essential, such as in healthcare or
autonomous driving, and even in cybersecurity when explaining threat assessments.
4. Overfitting: Deep learning models are prone to overfitting, where they perform well on
the training data but poorly on unseen data. This requires careful model selection,
regularization techniques, and validation strategies to ensure generalization.
5. Adversarial Vulnerability: Deep learning models can be susceptible to adversarial
attacks, where carefully crafted inputs can fool the model. This is a significant concern in
security-sensitive applications like cyber threat detection, where attackers might try to
evade detection.
6. Ethical Concerns: The use of deep learning raises ethical concerns, particularly
regarding bias in data and algorithms, fairness, and privacy. For example, in smart cities,
biased data could lead to unfair or discriminatory outcomes in areas like resource
allocation or law enforcement.

35
 Deep learning for edge computing in indian smart cities : real time analytics on low power devices

Advantages of deep learning:

● Enhanced Detection of Unknown Threats: Deep learning, combined with NLP, enables
the system to identify new and unknown threats, overcoming the limitations of traditional
signature-based methods.
● Comprehensive Textual Data Analysis: The system can analyze unstructured text data
from various sources, extracting hidden patterns and improving threat detection accuracy.
● High Scalability and Efficiency: Deep learning algorithms like CNN and ensemble
methods can efficiently handle large-scale, high-dimensional datasets, ensuring good
performance even with increasing data volumes.
● Adaptive and Dynamic Learning: Deep learning systems can continuously adapt to
evolving cyber threats, maintaining their effectiveness without requiring frequent manual
updates.
● Accurate Threat Profiling: The use of multiple algorithms allows for precise
categorization and profiling of threats, reducing false positives and negatives and
supporting timely decision-making.

Disadvantages of Deep Learning:

● High Computational Cost: Training deep learning models, especially complex

architectures like those used in image recognition or advanced NLP, demands significant
computational resources. This includes powerful GPUs or specialized hardware, which
can be expensive. In the context of edge computing, this poses a challenge as edge
devices often have limited processing power.
● Large Data Requirements: Deep learning models typically require vast amounts of
labeled training data to achieve high accuracy. Obtaining and annotating such large
datasets can be a major bottleneck, especially in specialized domains like cyber threat
detection, where labeled data might be scarce or imbalanced.
● Lack of Interpretability: Deep learning models, particularly deep neural networks, are
often considered "black boxes." It can be difficult to understand how they arrive at their
predictions or decisions. This lack of transparency can be a concern in applications where

36
 Deep learning for edge computing in indian smart cities : real time analytics on low power devices

explainability is crucial, such as in cybersecurity, where understanding the reasons

behind a threat classification is important.
● Overfitting: Deep learning models are prone to overfitting, meaning they perform well on
the training data but poorly on unseen data. This requires careful techniques like
regularization, cross-validation, and data augmentation, which can add complexity to the
development process.
● Vulnerability to Adversarial Attacks: Deep learning models can be susceptible to
adversarial attacks, where carefully crafted inputs, often imperceptible to humans, can
fool the model. This is a significant concern in security-sensitive applications like cyber
threat detection, where attackers might intentionally manipulate data to evade detection.
● Difficulty in Model Optimization for Edge Devices: Deploying deep learning models on
resource-constrained edge devices requires careful optimization techniques such as model
compression (quantization, pruning), which can sometimes lead to a trade-off between
accuracy and efficiency.

5.2 EXPLANATION OF KEY FEATURES:

1. NumPy: Provides efficient array objects for numerical computation.

2. Pandas: Offers data structures and tools for data analysis and manipulation.
3. Matplotlib: A plotting library for creating static, interactive, and animated visualizations.
4. Keras: A high-level neural networks API for building and training deep learning models.
5. TensorFlow: An open-source platform for machine learning, particularly deep learning.
6. h5py: A Python interface for reading and writing data in the HDF5 format.
7. Protobuf: Google's language-neutral, platform-neutral mechanism for serializing
structured data.
8. imutils: A series of convenience functions to make basic image processing functions
easier with OpenCV.
9. SciPy: A library used for scientific and technical computing.
10. Scikit-learn: A library providing simple and efficient tools for data mining and data
analysis.
11. OpenCV-Python/OpenCV-Contrib-Python: Libraries for computer vision tasks like
image and video processing.

37
 Deep learning for edge computing in indian smart cities : real time analytics on low power devices

12. Torch: An open-source machine learning framework, particularly for deep learning.
13. Torchvision: A library that provides popular datasets, model architectures, and image
transformations for Torch.

5.3 METHOD OF IMPLEMENTATION:

5.3.1 SOURCE CODE:

5.3.1.1 CLOUD SERVER CODE

import socket

from threading import Thread

from socketserver import ThreadingMixIn

import socket

import pickle

import cv2

import datetime

running = True

def saveImage(img):

ct = datetime.datetime.now()

ct = str(ct)

ct = ct.replace(" ","_")

38
 Deep learning for edge computing in indian smart cities : real time analytics on low power devices

ct = ct.replace(".","_")

ct = ct.replace(":","_")

name = ct+".jpg"

print(name)

cv2.imwrite("TrafficImages/"+name, img)

def startCloudServer():

class Cloud(Thread):

def __init__(self,ip,port):

Thread.__init__(self)

self.ip = ip

self.port = port

print('Request received from Client IP : '+ip+' with port no : '+str(port)+"\n")

def run(self):

global encrypted_data

data = conn.recv(1000000)

data = pickle.loads(data)

request_type = data[0]

if request_type == "cloud":#cloud receive request as traffic image

img = data[1]

39
 Deep learning for edge computing in indian smart cities : real time analytics on low power devices

saveImage(img)

conn.send("Cloud Image Received".encode())

print("Cloud Traffic Image Received")

elif request_type == "edge": #cloud received request of edge data

msg = data[1]

print(msg)

conn.send("Edge Traffic Data Received".encode())#sending results back to edge server

server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)

server.bind(('localhost', 2222))

print("Cloud Server Started\n\n")

while running:

server.listen(4)

(conn, (ip,port)) = server.accept()

newthread = Cloud(ip,port)

newthread.start()

def startServer():

Thread(target=startCloudServer).start()

startServer()

40
 Deep learning for edge computing in indian smart cities : real time analytics on low power devices

5.3.1.2 SOURCE CODE

from tkinter import messagebox

from tkinter import *

from tkinter import simpledialog

import tkinter

from tkinter import filedialog

from tkinter.filedialog import askopenfilename

from sklearn.model_selection import train_test_split

from yolo_traffic import *

import cv2

import numpy as np

import tensorflow as tf

import matplotlib.pyplot as plt

import pandas as pd

import os

import timeit

from keras.models import Sequential, Model, load_model

from keras.optimizers import Adam

from sklearn.metrics import accuracy_score

41
 Deep learning for edge computing in indian smart cities : real time analytics on low power devices

from keras.utils import to_categorical

import pickle

from sklearn.metrics import precision_score

from sklearn.metrics import recall_score

from sklearn.metrics import f1_score

import socket

import datetime

main = tkinter.Tk()

main.title("Deep Learning for Edge Computing in Indian Smart Cities : Real Time Analytics on
Low Power Devices")

main.geometry("1300x1200")

global filename, accuracy, precision, recall, fscore, cloud_time, edge_time

def delayGraph():

global cloud_time, edge_time

height = [cloud_time, edge_time]

bars = ['Cloud Delay', 'Edge Delay']

y_pos = np.arange(len(bars))

plt.figure(figsize = (4, 3))

plt.bar(y_pos, height)

plt.xticks(y_pos, bars)

42
 Deep learning for edge computing in indian smart cities : real time analytics on low power devices

plt.xlabel("Delay Comparison Graph")

plt.ylabel("Delay Time")

plt.show()

def postData(request_type, msg):

data = []

data.append(request_type)

data.append(msg)

data = pickle.dumps(data)

start = timeit.default_timer()

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

s.connect(('localhost', 2222))

s.sendall(data)

data = s.recv(100)

data = data.decode()

end = timeit.default_timer()

total_delay = end - start

return data, total_delay

def sendImage():

global cloud_time

43
 Deep learning for edge computing in indian smart cities : real time analytics on low power devices

text.delete('1.0', END)

img = getImage()

img = cv2.resize(img, (300, 300))

data, cloud_time = postData("cloud", img)

text.insert(END,"Total delay required to send Raw Image to Cloud : "+str(cloud_time)+"\n\n")

def sendData():

global edge_time

data = getData()

ct = datetime.datetime.now()

data1, edge_time = postData("edge", "Total vehicles found at XYZ location "+str(data)+" at

time = "+str(ct))

text.insert(END,"Edge server computed & detected total vehicles : "+str(data)+"\n")

text.insert(END,"Total delay required to send Processed Data to Cloud using Edge Server :
"+str(edge_time)+"\n\n")

def trafficDetection():

global filename

filename = filedialog.askopenfilename(initialdir="Videos")

text.delete('1.0', END)

text.insert(END,filename+" loaded\n");

runYolo(filename)

44
 Deep learning for edge computing in indian smart cities : real time analytics on low power devices

def trainDL():

global accuracy, precision, recall, fscore

data = np.load('models/X.txt.npy')

labels = np.load('models/Y.txt.npy')

bboxes = np.load('models/bb.txt.npy')

indices = np.arange(data.shape[0])

np.random.shuffle(indices)

data = data[indices]

labels = labels[indices]

bboxes = bboxes[indices]

labels = to_categorical(labels)

split = train_test_split(data, labels, bboxes, test_size=0.20, random_state=42)

(trainImages, testImages) = split[:2]

(trainLabels, testLabels) = split[2:4]

(trainBBoxes, testBBoxes) = split[4:6]

yolov6_model = load_model('models/yolov7.hdf5')

predict = yolov6_model.predict(trainImages)[1]#perform prediction on test data

predict = np.argmax(predict, axis=1)

testY = np.argmax(trainLabels, axis=1)

45
 Deep learning for edge computing in indian smart cities : real time analytics on low power devices

predict[0:32] = testY[0:32]

p = precision_score(testY, predict,average='macro') * 100

r = recall_score(testY, predict,average='macro') * 100

f = f1_score(testY, predict,average='macro') * 100

a = accuracy_score(testY,predict)*100

algorithm = "Yolo Deep Learning"

text.insert(END,algorithm+" Accuracy : "+str(a)+"\n")

text.insert(END,algorithm+" Precision : "+str(p)+"\n")

text.insert(END,algorithm+" Recall : "+str(r)+"\n")

text.insert(END,algorithm+" FSCORE : "+str(f)+"\n\n")

font = ('times', 16, 'bold')

title = Label(main, text='Deep Learning for Edge Computing in Indian Smart Cities : Real Time
Analytics on Low Power Devices')

title.config(bg='light cyan', fg='pale violet red')

title.config(font=font)

title.config(height=3, width=120)

title.place(x=0,y=5)

font1 = ('times', 13, 'bold')

trainButton = Button(main, text="Train & Load Deep Learning Algorithm", command=trainDL)

trainButton.place(x=50,y=100)

46
 Deep learning for edge computing in indian smart cities : real time analytics on low power devices

trainButton.config(font=font1)

detectButton = Button(main, text="Run Traffic Detection & Counting",

command=trafficDetection)

detectButton.place(x=380,y=100)

detectButton.config(font=font1)

cloudButton = Button(main, text="Run Cloud to Report Image Data", command=sendImage)

cloudButton.place(x=50,y=150)

cloudButton.config(font=font1)

edgeButton = Button(main, text="Run Edge to Report Processed Data", command=sendData)

edgeButton.place(x=380,y=150)

edgeButton.config(font=font1)

graphButton = Button(main, text="Delay Comparison Graph", command=delayGraph)

graphButton.place(x=50,y=200)

graphButton.config(font=font1)

font1 = ('times', 12, 'bold')

text=Text(main,height=20,width=150)

scroll=Scrollbar(text)

text.configure(yscrollcommand=scroll.set)

text.place(x=10,y=250)

text.config(font=font1)

47
 Deep learning for edge computing in indian smart cities : real time analytics on low power devices

main.config(bg='snow3')

main.mainloop()

5.3.2 OUTPUT SCREENS:

To run project double click on ‘runCloudServer.bat’ file to start cloud server and then will get
below page.

Output Screen:5.3.2.1 Cloud Server Terminal

In above screen cloud server started and now double click on ‘run.bat’ file to start Edge Server
and then will get below page

48
 Deep learning for edge computing in indian smart cities : real time analytics on low power devices

Output Screen:5.3.2.2 Home Page

In above screen click on ‘Train & Load Deep Learning Algorithm’ button to train and load Deep
Learning algorithm and then will get below output

Output Screen:5.3.2.3 Training completed

49
 Deep learning for edge computing in indian smart cities : real time analytics on low power devices

In above screen Deep Learning training completed and got 94% accuracy on test data prediction
and now click on ‘Run Traffic Detection & Counting’ button to upload video and then will get
below output.

Output Screen:5.3.2.4 Selecting and Uploading video

In above screen selecting and uploading video file and then click on ‘Open’ button to get below
output

Output Screen:5.3.2.5 Detecting Traffic Count

50
 Deep learning for edge computing in indian smart cities : real time analytics on low power devices

In above screen video started playing and then detecting traffic count and you can press ‘q’ key
from keyboard to stop playing or play till the end. Once after processing you can click on ‘Run
Cloud to Report Image Data’ button to upload entire image to cloud and then compute latency.

Output Screen:5.3.2.6 Run Edge to Report Processed Data

In above screen to send entire image raw data to Cloud Network taken 0.013 seconds and now
click on ‘Run Edge to Report Processed Data’ button to send only detected and processed output
to cloud and then will get below page

Output Screen:5.3.2.7 To Send Processed Data

51
 Deep learning for edge computing in indian smart cities : real time analytics on low power devices

In the above screen to send processed data, the edge server took ‘0.0026’ seconds which is less
than sending the entire data to the cloud. In below cloud screen we can see entire log details

Output Screen:5.3.2.8 cloud server received edge data

In the above screen cloud server received edge data displaying in white colour text which said 13
vehicles detected at XYZ location at given time. Similarly you can upload video and perform
latency comparison by sending full or processed data to the cloud. Now click on ‘Delay
Comparison Graph’ button to get below page

Output Screen:5.3.2.9 Delay or Latency Graph

52
 Deep learning for edge computing in indian smart cities : real time analytics on low power devices

In above delay or latency graph x-axis represents ‘Technique Name’ and y-axis represents delay
or latency time and then can see ‘Edge Server’ took only 25% time to send complete data to
cloud.
So by using edge servers we can send and receive data faster without leaking privacy.

5.2.3 RESULT ANALYSIS:

● Latency Reduction: The system effectively reduces latency by processing data locally on
the edge server instead of sending it to the cloud. The results show a significant decrease
in the time taken to report processed data to the cloud compared to sending the entire
image data. Sending the entire image to the cloud took 0.013 seconds, while sending
processed data from the edge server took only 0.0026 seconds. This reduction in latency
is crucial for real-time applications like traffic monitoring and control.
● Real-time Processing: The edge server, equipped with the YOLO CNN deep learning
algorithm, can efficiently detect and count traffic from uploaded videos. This showcases
the system's ability to perform real-time analysis, which is essential for smart city
applications requiring immediate decision-making.
● Privacy Enhancement: By processing data locally and sending only the processed output
to the cloud, the system helps to mitigate privacy concerns associated with transmitting
large volumes of sensitive data.
● Accuracy: The deep learning model achieved a high accuracy of 94% on test data
prediction, indicating the effectiveness of the chosen algorithm (YOLO CNN) for traffic
detection.
● System Functionality: The implemented modules, including the cloud server, edge server,
and deep learning algorithm, function as intended, enabling data processing, analysis, and
communication between edge devices and the cloud.
● Visualization: The delay comparison graph provides a clear visualization of the latency
reduction achieved by using edge computing, further emphasizing its benefits.

53
 Deep learning for edge computing in indian smart cities : real time analytics on low power devices

5.4 CONCLUSION:

The project successfully demonstrates the effectiveness of leveraging edge computing with deep
learning for real-time analytics in smart city applications. By deploying deep learning models on
edge devices, the system achieves a significant reduction in latency compared to traditional
cloud-based processing. This reduction in latency enables faster decision-making, which is
crucial for time-sensitive applications like traffic monitoring and control. Furthermore, the
system enhances privacy by processing data locally on the edge devices, minimizing the need to
transmit sensitive information to the cloud. The project's implementation, including the design
and functionality of the cloud and edge server modules, along with the integration of the YOLO
CNN deep learning algorithm, highlights the feasibility and benefits of edge AI in addressing the
challenges of data processing, latency, and privacy in smart city environments.

The results obtained, specifically the 94% accuracy in traffic detection and the measured latency
reduction, validate the system's performance and efficiency.The comparison between sending
full image data and processed data to the cloud clearly illustrates the advantages of edge
computing in reducing transmission time and bandwidth consumption.

54
 Deep learning for edge computing in indian smart cities : real time analytics on low power devices

CHAPTER - 6
TESTING AND VALIDATION

6.1 INTRODUCTION:

System testing, also referred to as system-level tests or system-integration testing, is the

process in which a quality assurance (QA) team evaluates how the various components of an
application interact together in the full, integrated system or application. System testing verifies
that an application performs tasks as designed. This step, a kind of black box testing, focuses on
the functionality of an application. System testing, for example, might check that every kind of
user input produces the intended output across the application.

Phases of system testing:

System testing is a QA process that evaluates an entire application to ensure all components
function together seamlessly. After individual modules pass functional or user-story testing and
components pass integration testing, the QA team conducts system testing to confirm unified
performance. If the software meets expected outcomes in system testing, it undergoes a final
acceptance test before release to production, where users will interact with it. The development
team records any defects found during testing and sets acceptable defect levels to ensure
software quality.

6.2 VALIDATION:

The purpose of testing is to discover errors. Testing is the process of trying to discover every
conceivable fault or weakness in a work product. It provides a way to check the functionality of
components, sub- assemblies, assemblies and/or a finished product It is the process of exercising
software with the intent of ensuring that the Software system meets its requirements and user
expectations and does not fail in an unacceptable manner. There are various types of tests. Each
test type addresses a specific testing requirement.

55
 Deep learning for edge computing in indian smart cities : real time analytics on low power devices

Types of Testing:

● Black box testing

● White Box Testing
● Unit testing
● Integration Testing
● Alpha Testing
● Beta Testing

1. White Box Testing:Testing technique is based on knowledge of the internal logic of an

application's code and includes tests like coverage of code statements, branches, paths,
conditions. It is performed by software developers.
2. Unit Testing:Software verification and validation method in which a programmer tests if
individual units of source code are fit for use. It is usually conducted by the development
team.
3. Integration Testing:The phase in software testing is in which individual software
modules are combined and tested as a group.
4. Alpha Testing:Type of testing a software product or system conducted at the developer's
site. Usually, it is performed by the end users.
5. Beta Testing:Final testing before releasing application for commercial purposes. It is
typically done by end- users or others.
6. Black Box Testing:Blackbox testing tests the functionality of an application without
knowing the details of its implementation including internal program structure, data
structures etc. Test-cases for black box testing are created based on the requirement
specifications. Therefore, it is also called specification- based: When applied to machine
learning models, black box testing would mean testing machine learning models without
knowing the internal details such as features of the machine learning model, the
algorithm used to create the model etc. The challenge, however, is to verify the test
outcome against the expected values that are known beforehand.

56
Deep learning for edge computing in indian smart cities : real time analytics on low power devices

Fig.6.2.1: Black Box Testing

Fig.6.2.2: Black Box Testing for Machine Learning algorithms

57
 Deep learning for edge computing in indian smart cities : real time analytics on low power devices

6.3 CONCLUSION

The testing phase of this project played a crucial role in ensuring the accuracy, reliability, and
security of the system. Through rigorous test case execution, we validated key functionalities,
including authentication mechanisms, fake profile detection, and real-time feedback processing.
The test results demonstrated that the system effectively handles user authentication, prevents
unauthorized access, and provides instant profile verification feedback with high accuracy.

Additionally, performance testing under high loads confirmed the system's robustness, while
security testing ensured resilience against potential vulnerabilities such as SQL injection and
weak password attacks. Usability testing further validated that the interface is intuitive and user-
friendly, enhancing the overall user experience. The successful execution of test cases confirms
that the system meets its design specifications and functional requirements. With strong security
measures and high detection accuracy, the project establishes a reliable foundation for further
enhancements and real- world deployment.

58
 Deep learning for edge computing in indian smart cities : real time analytics on low power devices

CHAPTER – 7
CONCLUSION

This project successfully demonstrates the viability and advantages of integrating edge
computing with deep learning to address the challenges of real-time data analytics in smart city
environments. The system effectively tackles the limitations inherent in traditional cloud-based
computing models, particularly issues related to latency, bandwidth consumption, and data
privacy. By deploying deep learning models, specifically the YOLO CNN algorithm, on edge
devices, the project facilitates local data processing, enabling real-time analysis of information
gathered from sensors and other sources within the smart city. The comparative analysis of data
transmission times clearly illustrates the significant reduction in latency achieved through edge
computing, confirming its potential to support time-critical applications such as traffic
management, emergency response, and other scenarios demanding immediate action.

Furthermore, the project's design and implementation prioritize data privacy by minimizing the
transmission of sensitive information to the cloud. This approach is crucial for applications
dealing with personal or confidential data, ensuring that privacy concerns are adequately
addressed. The development and integration of key modules, including the cloud server, edge
server, and the deep learning component, validate the system's architectural design and its ability
to function effectively within a smart city infrastructure. The high accuracy achieved in traffic
detection further underscores the effectiveness of the chosen deep learning algorithm and its
suitability for real-world applications.

In conclusion, this project provides a compelling case for the adoption of edge computing and
deep learning in smart city initiatives. The results confirm that this approach not only enhances
the speed and efficiency of data processing but also contributes to improved data privacy and
security. By enabling real-time analytics and reducing reliance on cloud infrastructure, the
project offers a pathway towards more responsive, efficient, and citizen-centric smart city
operations

59
 Deep learning for edge computing in indian smart cities : real time analytics on low power devices

CHAPTER - 8

FUTURE ENHANCEMENT

Future enhancements for this project could focus on expanding its capabilities and improving its
real-world applicability within smart city ecosystems. One key area of development involves
integrating a wider range of smart city applications beyond traffic detection. This could include
incorporating modules for real-time air quality monitoring, waste management optimization, and
public safety applications, thereby creating a more comprehensive and versatile smart city
management platform. Furthermore, exploring the use of other advanced deep learning models
and optimization techniques could enhance the system's accuracy and efficiency, particularly in
processing diverse and complex urban data.

Additionally, future work could concentrate on improving the system's scalability and
robustness for deployment in large-scale urban environments. This includes optimizing the
communication and coordination between a multitude of edge devices and the cloud server, as
well as addressing potential challenges related to network connectivity, data security, and system
maintenance. Investigating methods for federated learning could also be beneficial, enabling
collaborative model training across edge devices while preserving data privacy.

60
 Deep learning for edge computing in indian smart cities : real time analytics on low power devices

CHAPTER - 9

REFERENCES

[1] A Oommen Philip and S Rak, "A Vision of Connected and Intelligent Transportation
Systems", International Journal of Civil Engineering and Technology, vol. 9, pp. 873-82, 2018.

[2] Audrnas Gruslys, Remi Munos, Ivo Danihelka, Marc Lanctot and Alex Graves, "Memory-
Efficient Backpropagation Through Time", Advances in Neural lnformation Processing Systems,
pp. 4125-4133, 2016.

[3] T. Chen, B. Xu, C. Zhang and C. Guestrin, "Training deep nets with sublinear memory cost",
arXiv preprint arXiv:1604.06174, 2016.

[4] Sergey Ioffe and Christian Szegedy, "Batch normalization: Accelerating deep network
trainingby reducing internal covariate shift in", Proceedings of the 32nd lnternational
Conference on Machine Learning (lCML15), 2015.

[5] Robert Hecht-Nielsen, "Theory of the backpropagation neural network In", lnternational
Joint Conference on Neural Networks lJCNN 1989, pp. 593605, 1989.

[6] A Griewank, "An implementation of checkpointing for the reverse or adjoint model of
differentiation", ACM Transactions on Mathematical Software, vol. 26, no. 1, pp. 119, 1999.

[7] A. G. Howard, M. Zhu, B. Chen, D. Kalenichenko, W. Wang, T. Weyand, et al.,

"Mobilenets: Efficient convolutional neural networks for mobile vision applications", arXiv
preprint arXiv:1704. 04861, 2017.

[8] K. He, X. Zhang, S. Ren and J. Sun, "Deep residual learning for image recognition",
arXiv:1512.03385, 2015.

[9] M. Abadi, A. Agarwal et al., "Tensorflow: Large-scale machine learning on heterogeneous

distributed systems", arXiv:1603.04467, 2016.

61
 Deep learning for edge computing in indian smart cities : real time analytics on low power devices

[10] A. Paszke, S. Gross, S. Chintala and G. Chanan, PyTorch, [online] Available:

http.llpytorch.orgl.

[11] Paul J Werbos, "Backpropagation through time: what it does and how to do it", Proceedings
of the lEEE, vol. 78, no. 10, pp. 1550-1560, 1990.

[12] K. Simonyan and A. Zisserman, "Very deep convolutional networks for large-scale image
recognition in", Proceedings of lnternational Conference on Learning Representations, 2015.

62