Traffic Prediction Model Development

Here’s a structured approach for your Traffic Prediction Model using pandas, seaborn, and scikit-learn:

1. Data Inspection & Cleaning

import pandas as pd

# Load dataset
df = pd.read_csv("traffic_data.csv")

# Inspect dataset
print(df.info()) # Check data types
print(df.describe()) # Summary statistics
print(df.isnull().sum()) # Check for missing values

# Handle missing values (example: filling with median values)
df.fillna(df.median(), inplace=True)

# Check for duplicate rows
df.drop_duplicates(inplace=True)
2. Data Visualization

import seaborn as sns
import matplotlib.pyplot as plt

# Traffic distribution over time
df["timestamp"] = pd.to_datetime(df["timestamp"]) # Ensure datetime format
df.set_index("timestamp", inplace=True)
df["traffic"].plot(figsize=(12,6), title="Traffic Flow Over Time")
plt.show()

# Correlation heatmap
sns.heatmap(df.corr(), annot=True, cmap="coolwarm")
plt.show()
3. Train-Test Split & Scaling

from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

# Select features and target variable
X = df.drop("traffic", axis=1) # Assuming 'traffic' is the target variable
y = df["traffic"]

# Scale numerical features (important for models like SVM, Neural Networks)
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# Split data
X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, test_size=0.2, random_state=42)
4. Model Training (Random Forest for Regression)

from sklearn.ensemble import RandomForestRegressor
from sklearn.metrics import mean_absolute_error, mean_squared_error

# Initialize and train model
rf = RandomForestRegressor(n_estimators=100, random_state=42)
rf.fit(X_train, y_train)

# Predictions
y_pred = rf.predict(X_test)

# Model Evaluation
mae = mean_absolute_error(y_test, y_pred)
mse = mean_squared_error(y_test, y_pred)
print(f"MAE: {mae:.2f}, MSE: {mse:.2f}")
5. Confusion Matrix (For Classification-Based Traffic Levels)
If predicting traffic levels (e.g., Low, Medium, High), use a classification model:


from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import confusion_matrix

# Convert traffic volume to categories
df["traffic_level"] = pd.cut(df["traffic"], bins=[0, 50, 100, 200], labels=["Low", "Medium", "High"])

# Encode categorical labels
from sklearn.preprocessing import LabelEncoder
le = LabelEncoder()
df["traffic_level"] = le.fit_transform(df["traffic_level"])

# Train model again with traffic levels
X = df.drop(["traffic", "traffic_level"], axis=1)
y = df["traffic_level"]

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

rf_classifier = RandomForestClassifier(n_estimators=100, random_state=42)
rf_classifier.fit(X_train, y_train)

y_pred_class = rf_classifier.predict(X_test)

# Confusion Matrix
cm = confusion_matrix(y_test, y_pred_class)
sns.heatmap(cm, annot=True, fmt="d", cmap="Blues")
plt.xlabel("Predicted")
plt.ylabel("Actual")
plt.show()
6. Accuracy Improvement
Feature Engineering: Use weather data, time of day, day of the week, special events, etc.

Hyperparameter Tuning: Use GridSearchCV or RandomizedSearchCV for optimization.

Time Series Models: Try LSTMs or ARIMA for better performance on time-based predictions.

Increase Data: More historical data can improve generalization.

Would you like a time series approach (LSTM, ARIMA) or a classification-based traffic prediction?