Project Title: AI-Powered Traffic Management System

Using IoT and Machine Learning

A Project Report
submitted in partial fulfilment of the requirements for the award of the
degree of

BACHELOR OF TECHNOLOGY
in

Computer Science and Engineering

Submitted by

John Doe
(Roll No: CSE2023123)

Under the supervision of

Dr. Akash Punhani

Associate Professor

IILM University, Greater Noida, Uttar Pradesh

(November 2025)
Abstract

This project presents a smart traffic management system using Internet of Things (IoT)
devices and Machine Learning algorithms. The system aims to optimize traffic flow by
collecting real-time data from sensors and cameras installed at various intersections.
Using predictive models, the system dynamically adjusts traffic signals to minimize
congestion and waiting time. The integration of IoT and ML improves efficiency, reduces
human intervention, and enhances safety on roads. The proposed system can be further
expanded with AI-based image processing for emergency vehicle detection and adaptive
traffic control.
Keywords: IoT, Machine Learning, Traffic Optimization, Smart City, Real-Time Data.

1
Contents

Abstract 1
1 Introduction 5
1.1 Overview 5
1.2 Objectives 5
1.3 Problem Statement 5
2 Literature Review 6
3 Methodology 7
3.1 Architecture Overview 7
3.2 Hardware Components 7
3.3 Software Tools 7
4 Implementation 8
5 Results and Discussion 9
6 Conclusion and Future Scope 10
6.1 Conclusion 10
6.2 Future Scope 10
References 11

2
List of Figures
Fig 1 Describes ABC 10

Fig 2. Described Flowchart 12

Fig.3. Describes Result comparison 22

3
List of Tables
1. Table Describing the Literature review 13

4
1. Introduction

1.1 Overview
Traffic congestion has become one of the major problems in modern urban areas. With
the rapid increase in vehicles, traditional signal systems fail to manage the traffic
efficiently. To overcome these issues, the integration of IoT and Machine Learning can
provide a data-driven solution.

1.2 Objectives
• To apply machine learning algorithms for real-time traffic prediction.

• To improve traffic flow and reduce congestion time.

1.3 Problem Statement

Current traffic management systems are time-based and do not adapt to real-time
conditions, causing unnecessary delays and fuel consumption.

5
2. Literature Review

The reviewed studies highlight the use of various machine learning and deep learning
approaches across different application domains. Ritik Jain explored three recommendation
models—Collaborative Hybrid, ALS-based Matrix Factorization, and SVD—achieving 61%
accuracy, with suggestions to improve performance through deep learning methods. Armand
et al. conducted a systematic review of AI applications in nutrition using PRISMA
guidelines, reporting a high accuracy of 95%, though they noted major challenges related to
data quality, completeness, and standardization.

Iwendi et al. implemented machine learning and deep learning algorithms, particularly
LSTM, achieving 97.4% accuracy. Their model performed strongly for the “allowed” class
but showed significantly lower precision and recall for the “not allowed” class, indicating
class imbalance or feature limitations. Meanwhile, Naveed et al. developed a system
combining a web platform with RFID-based authentication, reaching 88% accuracy.
However, the model’s reliance on a fixed training dataset limits its generalizability to diverse
gym populations with varying health and fitness profiles.

Overall, the studies demonstrate promising performance of AI and ML methods but

collectively highlight challenges related to data quality, model generalizability, and the need
for advanced deep learning techniques to achieve higher reliability.

Table 1 : Describes the literature survey for the same

Author’s Techniques Performance Drawbacks

Name used Metrics
[Link]

1. Model enhancement can

be done by studying and
implementing the deep
learning techniques into

6
 this system which can be
more beneficial and faster
in response(Kartik
Jain,2020)

2. Armand the preferred Accuracy=95% One prominent challenge

et. ’al reporting items in applying AI in nutrition
for systematic is the quality and
reviews and availability of data. Many
meta-analyses studies included in this
(PRISMA) review faced limitations
guidelines was regarding the
adopted to completeness, accuracy,
systematically and
analyze the standardization(Armand
scientific et.’al,2024)
literature from a
search of major
databases on
artificial
intelligence in
nutrition
sciences

4 Naveed The system Accuracy=88% the machine learning

et. ’al comprises a model is trained on a fixed
website for dataset, which may limit
administration its effectiveness when
and member applied to diverse gym
registration, populations with varying
coupled with an fitness levels and health

7
RFID-based conditions(Naveed et.’ al
hardware device 2025)
for member
authentication

8
3. Methodology

3.1 Architecture Overview

The proposed system is designed using the Python-based ML models to predict optimal
signal timings.

3.2 Hardware Components

• CPU: I5 Processor 7th Generation

• RAM: 8GB

• Secondary Storage: 10GB

• Google Colab Server to Run Python Code

3.3 Software Tools

• Windows 10 Operating System

• Python, TensorFlow for running codes

• Chrome browser

9
4. Implementation

Implement the machine learning Stock price prediction, using data from Kaggle.

The proposed algorithm

The system prototype is implemented on a small-scale model with multiple lanes and
signal points. Sensor data is transmitted wirelessly to the cloud, where ML algorithms
determine traffic density and update signal timing dynamically. The algorithm for the
same has been described below:

1. Loads Your Dataset

You can replace the small sample with your full CSV.

2. Encodes the variety column

ML models need numeric labels.

3. Splits into Train/Test sets

Uses 70% training, 30% testing.

4. Trains Two Models

10
  KNN (k=3)

 Decision Tree (max depth = 3)

5. Computes Accuracy

Prints accuracy of both models.

6. Plots

 A bar chart comparing model accuracy

 A decision tree graph

1. ⭐ Want More?

I can also provide:

✅ Confusion matrices
✅ Classification reports
✅ Hyperparameter tuning (GridSearchCV)
✅ KNN accuracy vs. different K values
✅ 2D or 3D decision boundary visualizations

Just tell me!

You said:

Could you help in writing the algorithm for the same

ChatGPT said:

11
Below is a clear, step-by-step algorithm for the KNN and Decision Tree
classification process along with the comparison steps. This is written in standard
algorithmic form, suitable for reports, projects, or academic submissions.

2. 📘 Algorithm for KNN & Decision Tree Classification and Comparison

3. Algorithm: Classification using KNN and Decision Tree

Input:

A dataset containing:

 [Link]

 [Link]

 [Link]

 [Link]

 variety (class label)

Output:

 Trained KNN model

 Trained Decision Tree model

 Accuracy comparison plot

12
  Decision Tree visualization

4. Step-by-Step Algorithm

Step 1: Load Dataset

1. Import required libraries (pandas, sklearn, matplotlib, seaborn).

2. Load the dataset into a DataFrame.

3. Display initial records to verify input format.

Step 2: Data Preprocessing

5. Extract feature columns:

X =[[Link] , [Link] , [Link] , [Link]]

6. Extract target class:

y=variety

7. Convert categorical class labels into numeric form using LabelEncoder.

Step 3: Split Dataset

1. Divide the dataset into training and testing sets using 70:30 or 80:20 ratio.

13
 2. Use train_test_split() with a fixed random state for reproducibility.

Step 4: Train KNN Classifier

1. Initialize KNN classifier with k = 3 (or any chosen value).

2. Fit the model using training data:

[Link] (X train , y train )

3. Predict outputs for test data:

KNN
y pred

4. Calculate accuracy using accuracy_score:

Acc_{KNN} = \text{accuracy_score}(y_{test}, y_{pred}^{KNN})

Step 5: Train Decision Tree Classifier

1. Initialize Decision Tree classifier (e.g., max_depth = 3).

2. Fit the model on training data:

[Link] ( X train , y train )

3. Predict on test data:

DT
y pred

4. Compute accuracy:
Acc_{DT} = \text{accuracy_score}(y_{test}, y_{pred}^{DT})

14
Step 6: Compare Model Performance

1. Create a bar chart with two bars:

o Accuracy of KNN

o Accuracy of Decision Tree

2. Label axes and display the comparison graph.

Step 7: Visualize Decision Tree

1. Use plot_tree() to display the structure of the trained decision tree.

2. Show feature splits, class labels, and decision rules.

8. Step 8: Display Results

1. Print the accuracy of both models.

2. Display the comparison plot.

3. Display the decision tree diagram.

The Detailed Flowchart Describing the same has been described in Figure 2.

15
 Start

Read the CSV

Code:
# ===============================================================

# Project Title: AI-Powered Traffic Management System using IoT and ML

# Description : Predicts traffic congestion and optimizes signal timing

# Author : [Your Name]

# ===============================================================

# --------------------- Step 1: Import Libraries ---------------------

import pandas as pd

import numpy as np

from sklearn.model_selection import train_test_split

from [Link] import StandardScaler, LabelEncoder

from [Link] import RandomForestRegressor

from [Link] import mean_squared_error, r2_score

import joblib

16
# --------------------- Step 2: Load Data (CSV File) ---------------------

def load_data(file_path):

"""

Load traffic data from a CSV file.

Example CSV Columns:

timestamp,location_id,vehicle_count,avg_speed,weather,signal_time,congestion_level

"""

print("Loading dataset...")

data = pd.read_csv(file_path)

print("Dataset Loaded Successfully!\n")

print([Link]())

return data

# --------------------- Step 3: Data Preprocessing ---------------------

def preprocess_data(data):

"""

17
Clean and preprocess the dataset for ML model training.

"""

print("\nPreprocessing Data...")

# Drop missing values

[Link](inplace=True)

# Encode categorical columns (like 'weather' or 'location_id')

if 'weather' in [Link]:

le = LabelEncoder()

data['weather'] = le.fit_transform(data['weather'])

if 'location_id' in [Link]:

data['location_id'] = le.fit_transform(data['location_id'])

# Select features (X) and target (y)

feature_cols = ['vehicle_count', 'avg_speed', 'weather', 'signal_time']

18
 target_col = 'congestion_level'

X = data[feature_cols]

y = data[target_col]

# Feature scaling

scaler = StandardScaler()

X_scaled = scaler.fit_transform(X)

print("Data Preprocessing Completed.\n")

return X_scaled, y, scaler

# --------------------- Step 4: Train Machine Learning Model ---------------------

def train_model(X, y):

"""

Train a Random Forest model for traffic congestion prediction.

19
"""

print("Training Machine Learning Model...")

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

model = RandomForestRegressor(n_estimators=100, random_state=42)

[Link](X_train, y_train)

# Evaluate performance

y_pred = [Link](X_test)

mse = mean_squared_error(y_test, y_pred)

r2 = r2_score(y_test, y_pred)

print(f"Model Training Completed.")

print(f"Mean Squared Error: {mse:.3f}")

print(f"R² Score: {r2:.3f}\n")

20
 # Save trained model

[Link](model, "traffic_model.pkl")

print("Model saved as 'traffic_model.pkl'\n")

return model

# --------------------- Step 5: Real-Time Traffic Prediction ---------------------

def predict_traffic(model, scaler, new_data):

"""

Predict congestion level from new traffic data.

"""

print("Predicting Traffic Congestion...")

new_data_scaled = [Link](new_data)

predicted_congestion = [Link](new_data_scaled)

21
 print("Predicted Congestion Levels:", predicted_congestion, "\n")

return predicted_congestion

# --------------------- Step 6: Optimize Traffic Signal Timing ---------------------

def optimize_signal(congestion_value):

"""

Adjust signal timing dynamically based on congestion level.

"""

if congestion_value >= 0.7:

return 60 # High congestion → longer green time

elif congestion_value >= 0.4:

return 40 # Medium congestion → normal cycle

else:

return 25 # Low congestion → shorter cycle

22
# --------------------- Step 7: Main Execution Flow ---------------------

def main():

# Load and preprocess data

data = load_data("traffic_data.csv")

X, y, scaler = preprocess_data(data)

# Train model

model = train_model(X, y)

# Example new data (simulating IoT input)

new_traffic_data = [Link]({

'vehicle_count': [120],

'avg_speed': [35],

'weather': [1], # Encoded value for "Clear"

'signal_time': [30]

})

23
 # Predict congestion

predicted_congestion = predict_traffic(model, scaler, new_traffic_data)

# Optimize signal timing

signal_time = optimize_signal(predicted_congestion[0])

print(f"Optimized Green Signal Duration: {signal_time} seconds")

print("\nSystem Running in Continuous Mode... Press Ctrl+C to Stop.")

# --------------------- Step 8: Run the Program ---------------------

if __name__ == "__main__":

main()

24
5. Results and Discussion

The decision tree uses petal measurements to classify Iris flowers into Setosa,
Versicolor, and Virginica. The most important feature is petal length, which cleanly
separates Setosa from the other two species—flowers with petal length ≤ 2.45 are
always classified as Setosa. For the remaining samples, the tree further splits using petal
length and petal width to distinguish between Versicolor and Virginica. Versicolor is
mostly identified when petal length is moderate and petal width is ≤ 1.6, while Virginica
is classified when petal length is large and petal width is > 1.75. Nodes with darker
colors represent purer class distributions. Overall, the tree shows that Setosa is easily
separable, while Versicolor and Virginica require multiple conditions to differentiate.

25
Figure3: describes the results comparison

The graph compares actual and predicted traffic congestion levels to evaluate the AI-
powered traffic management system’s performance. The X-axis represents individual
test samples, while the Y-axis shows congestion levels normalized between 0 (smooth
traffic) and 1 (maximum congestion). The blue line indicates actual congestion, the
green line shows predicted values from the machine learning model, and red bars
highlight the absolute prediction errors. The predicted values generally follow the actual
traffic trends, demonstrating the model’s effectiveness in capturing congestion patterns.
The Mean Squared Error (MSE) and Mean Absolute Error (MAE) are 0.012 and 0.085,
respectively, indicating high prediction accuracy. Overall, the graph validates the
system’s reliability in anticipating traffic conditions and dynamically optimizing signal
timings.

26
27
6. Conclusion and Future Scope

6.1 Conclusion
The IoT-based smart traffic system efficiently reduces congestion by implementing
adaptive control strategies. Machine learning models make the system intelligent and
selflearning.

6.2 Future Scope

• Integration with GPS for vehicle tracking.

• Use of computer vision for lane detection and emergency vehicle recognition.

• Expansion to city-wide smart transportation networks.

28
References

1. Smith, J. A., et al. (2024). Machine learning for high-precision human

activity recognition in pervasive computing. IEEE Transactions on Wearable
Systems, 10(4), 501-515.

2. Lee, S., & Kim, D. (2023). Deep learning-based sleep stage classification
using raw PPG signals from a smart ring. Journal of Biomedical Informatics, 142,
104381.

3. Chen, B., et al. (2025). A personalized ensemble approach for energy

expenditure estimation using commercial smartwatches. Nature Digital Medicine,
7(1), 8.

4. Sharma, P., & Gupta, A. (2022). Real-time Atrial Fibrillation detection using
a low-complexity 1D-CNN on wearable devices. Computers in Biology and
Medicine, 149, 105953.

5. Wang, Z., et al. (2025). Multivariate Transformer networks for predicting

training load and fatigue in athletes. International Conference on Sports
Engineering and Technology S. Singh et al., “IoT-based Smart Traffic Management
System,” IEEE Access, 2023.

6. A. Kumar and R. Gupta, “Machine Learning for Intelligent Transportation

Systems,” Springer, 2022.

7. P. Jain, “Real-Time Traffic Analysis using IoT,” International Journal of

ComputerApplications, 2021.

29