AI-powered Traffic Prediction

Abstract

AI-powered Traffic Prediction is a Python project that uses AI to forecast traffic congestion. The application features data analysis, model training, and a CLI interface, demonstrating best practices in transportation analytics and machine learning.

Prerequisites

• Python 3.8 or above
• A code editor or IDE
• Basic understanding of transportation analytics and machine learning
• Required libraries: scikit-learn, numpy, pandas, matplotlib

Before you Start

Install Python and the required libraries:

Install dependencies

pip install scikit-learn numpy pandas matplotlib

Getting Started

Create a Project

1. Create a folder named ai-powered-traffic-prediction.
2. Open the folder in your code editor or IDE.
3. Create a file named ai_powered_traffic_prediction.py.
4. Copy the code below into your file.

Write the Code

AI-powered Traffic Prediction

pch.viewSource

AI-powered Traffic Prediction

"""
AI-powered Traffic Prediction

Features:
- Predicts traffic congestion using ML
- Data analysis
- Visualization
- Modular design
- CLI interface
- Error handling
"""
import sys
import numpy as np
try:
    from sklearn.ensemble import RandomForestRegressor
    import matplotlib.pyplot as plt
except ImportError:
    RandomForestRegressor = None
    plt = None

class TrafficPredictor:
    def __init__(self):
        self.model = RandomForestRegressor() if RandomForestRegressor else None
        self.trained = False
    def train(self, X, y):
        if self.model:
            self.model.fit(X, y)
            self.trained = True
    def predict(self, X):
        if self.trained:
            return self.model.predict(X)
        return [np.mean(X)] * len(X)
    def plot(self, X, y):
        if plt:
            plt.scatter(X, y)
            plt.xlabel('Time')
            plt.ylabel('Congestion')
            plt.title('Traffic Congestion')
            plt.savefig("ai_powered_traffic_prediction.png", dpi=120, bbox_inches="tight")
            print("saved ai_powered_traffic_prediction.png")
            plt.show()
        else:
            print("matplotlib not available.")

class CLI:
    @staticmethod
    def run():
        print("AI-powered Traffic Prediction")
        predictor = TrafficPredictor()
        while True:
            cmd = input('> ')
            if cmd.startswith('train'):
                parts = cmd.split()
                if len(parts) < 3:
                    print("Usage: train <data_file> <labels_file>")
                    continue
                X = np.loadtxt(parts[1], delimiter=',').reshape(-1, 1)
                y = np.loadtxt(parts[2], delimiter=',')
                predictor.train(X, y)
                print("Model trained.")
            elif cmd.startswith('predict'):
                parts = cmd.split()
                if len(parts) < 2:
                    print("Usage: predict <data_file>")
                    continue
                X = np.loadtxt(parts[1], delimiter=',').reshape(-1, 1)
                preds = predictor.predict(X)
                print(f"Predictions: {preds}")
            elif cmd.startswith('plot'):
                parts = cmd.split()
                if len(parts) < 3:
                    print("Usage: plot <data_file> <labels_file>")
                    continue
                X = np.loadtxt(parts[1], delimiter=',').reshape(-1, 1)
                y = np.loadtxt(parts[2], delimiter=',')
                predictor.plot(X, y)
            elif cmd == 'exit':
                break
            else:
                print("Unknown command")

if __name__ == "__main__":
    try:
        CLI.run()
    except Exception as e:
        print(f"Error: {e}")
        sys.exit(1)

Example Usage

Run traffic prediction

python ai_powered_traffic_prediction.py

How it fits together

Read from the top: this is what runs when you execute the file, and which function calls which. It is generated from the code, so it cannot drift from it.

diagram Diagram mermaid

  flowchart TD
  RUN(["python ai_powered_traffic_prediction.py"])
  TrafficPredictor["TrafficPredictor
class"]
  CLI["CLI
class"]
  RUN --> TrafficPredictor
  CLI --> TrafficPredictor

Explanation

Key Features

• Data Analysis: Processes and analyzes traffic data.
• Model Training: Uses machine learning for congestion prediction.
• Forecasting: Predicts future traffic conditions.
• Error Handling: Validates inputs and manages exceptions.
• CLI Interface: Interactive command-line usage.

Code Breakdown

1. What it imports (lines 12–13)

ai_powered_traffic_prediction.py

import sys
import numpy as np

2. TrafficPredictor — the class (lines 21–43)

ai_powered_traffic_prediction.py

class TrafficPredictor:
    def __init__(self):
        self.model = RandomForestRegressor() if RandomForestRegressor else None
        self.trained = False
    def train(self, X, y):
        if self.model:
            self.model.fit(X, y)
            self.trained = True
    def predict(self, X):
        if self.trained:
            return self.model.predict(X)
        return [np.mean(X)] * len(X)
    def plot(self, X, y):
        if plt:
            plt.scatter(X, y)
            plt.xlabel('Time')
            plt.ylabel('Congestion')
            plt.title('Traffic Congestion')
            plt.savefig("ai_powered_traffic_prediction.png", dpi=120, bbox_inches="tight")
            print("saved ai_powered_traffic_prediction.png")
            plt.show()
        else:
            print("matplotlib not available.")

3. CLI — the class (lines 45–80)

ai_powered_traffic_prediction.py

class CLI:
    @staticmethod
    def run():
        print("AI-powered Traffic Prediction")
        predictor = TrafficPredictor()
        while True:
            cmd = input('> ')
            if cmd.startswith('train'):
                parts = cmd.split()
                if len(parts) < 3:
                    print("Usage: train <data_file> <labels_file>")
                    continue
                X = np.loadtxt(parts[1], delimiter=',').reshape(-1, 1)
                y = np.loadtxt(parts[2], delimiter=',')
                predictor.train(X, y)
                print("Model trained.")
            elif cmd.startswith('predict'):
                parts = cmd.split()
                # ... 12 more lines in the file ...
                y = np.loadtxt(parts[2], delimiter=',')
                predictor.plot(X, y)
            elif cmd == 'exit':
                break
            else:
                print("Unknown command")

The file defines 2 top-level symbols in all; the whole thing is above under Write the Code.

Features

• AI-Based Traffic Prediction: High-accuracy forecasting
• Modular Design: Separate functions for preprocessing and prediction
• Error Handling: Manages invalid inputs and exceptions
• Production-Ready: Scalable and maintainable code

Next Steps

Enhance the project by:

• Integrating with real-world traffic datasets
• Supporting batch predictions
• Creating a GUI with Tkinter or a web app with Flask
• Adding evaluation metrics (MAE, RMSE)
• Unit testing for reliability

Educational Value

This project teaches:

• Transportation Analytics: Data analysis and prediction
• Software Design: Modular, maintainable code
• Error Handling: Writing robust Python code

Real-World Applications

• Traffic Management Systems
• Urban Planning
• Transportation Analytics
• Educational Tools

Conclusion

AI-powered Traffic Prediction demonstrates how to build a scalable and accurate traffic prediction tool using Python. With modular design and extensibility, this project can be adapted for real-world applications in transportation, analytics, and more. For more advanced projects, visit Python Central Hub.