|
|
import streamlit as st |
|
|
import pandas as pd |
|
|
import plotly.express as px |
|
|
import plotly.graph_objects as go |
|
|
from datetime import datetime |
|
|
import os |
|
|
|
|
|
st.set_page_config( |
|
|
page_title="Urban Traffic Flow Dashboard", |
|
|
page_icon="🚗", |
|
|
layout="wide", |
|
|
initial_sidebar_state="expanded", |
|
|
) |
|
|
|
|
|
|
|
|
@st.cache_data |
|
|
def load_data(): |
|
|
script_dir = os.path.dirname(os.path.abspath(__file__)) |
|
|
csv_path = os.path.join(script_dir, "urban_traffic_flow_with_target.csv") |
|
|
df = pd.read_csv(csv_path) |
|
|
df["Timestamp"] = pd.to_datetime(df["Timestamp"]) |
|
|
df["Hour"] = df["Timestamp"].dt.hour |
|
|
df["DayOfWeek"] = df["Timestamp"].dt.day_name() |
|
|
df["Date"] = df["Timestamp"].dt.date |
|
|
df["IsWeekend"] = df["DayOfWeek"].isin(["Saturday", "Sunday"]) |
|
|
return df |
|
|
|
|
|
|
|
|
def main(): |
|
|
st.title("🚗 Urban Traffic Flow Dashboard") |
|
|
st.markdown( |
|
|
"Explore urban traffic patterns, congestion levels, and temporal trends" |
|
|
) |
|
|
|
|
|
df = load_data() |
|
|
|
|
|
with st.sidebar: |
|
|
st.header("🔍 Filters") |
|
|
|
|
|
min_date = df["Timestamp"].min().date() |
|
|
max_date = df["Timestamp"].max().date() |
|
|
|
|
|
date_range = st.date_input( |
|
|
"Date Range", |
|
|
value=(min_date, max_date), |
|
|
min_value=min_date, |
|
|
max_value=max_date, |
|
|
) |
|
|
|
|
|
selected_locations = st.multiselect( |
|
|
"Select Locations", |
|
|
options=sorted(df["Location"].unique()), |
|
|
default=sorted(df["Location"].unique()), |
|
|
) |
|
|
|
|
|
peak_filter = st.multiselect( |
|
|
"Peak/Off-Peak", |
|
|
options=sorted(df["Peak_Off_Peak"].unique()), |
|
|
default=sorted(df["Peak_Off_Peak"].unique()), |
|
|
) |
|
|
|
|
|
day_filter = st.multiselect( |
|
|
"Day of Week", |
|
|
options=sorted(df["DayOfWeek"].unique()), |
|
|
default=sorted(df["DayOfWeek"].unique()), |
|
|
) |
|
|
|
|
|
congestion_filter = st.slider( |
|
|
"Min Congestion Level", min_value=0, max_value=5, value=0, step=1 |
|
|
) |
|
|
|
|
|
filtered_df = df.copy() |
|
|
|
|
|
if len(date_range) == 2: |
|
|
start_date, end_date = date_range |
|
|
filtered_df = filtered_df[ |
|
|
(filtered_df["Timestamp"].dt.date >= start_date) |
|
|
& (filtered_df["Timestamp"].dt.date <= end_date) |
|
|
] |
|
|
|
|
|
if selected_locations: |
|
|
filtered_df = filtered_df[filtered_df["Location"].isin(selected_locations)] |
|
|
|
|
|
if peak_filter: |
|
|
filtered_df = filtered_df[filtered_df["Peak_Off_Peak"].isin(peak_filter)] |
|
|
|
|
|
if day_filter: |
|
|
filtered_df = filtered_df[filtered_df["DayOfWeek"].isin(day_filter)] |
|
|
|
|
|
filtered_df = filtered_df[filtered_df["Congestion_Level"] >= congestion_filter] |
|
|
|
|
|
st.subheader("📊 Key Performance Indicators") |
|
|
|
|
|
kpi_col1, kpi_col2, kpi_col3, kpi_col4 = st.columns(4) |
|
|
|
|
|
with kpi_col1: |
|
|
st.metric( |
|
|
"Total Vehicle Count", |
|
|
f"{filtered_df['Vehicle_Count'].sum():,.0f}", |
|
|
help="Total number of vehicles recorded", |
|
|
) |
|
|
|
|
|
with kpi_col2: |
|
|
st.metric( |
|
|
"Avg Vehicle Speed", |
|
|
f"{filtered_df['Vehicle_Speed'].mean():.1f} km/h", |
|
|
help="Average speed across all locations", |
|
|
) |
|
|
|
|
|
with kpi_col3: |
|
|
st.metric( |
|
|
"Avg Congestion Level", |
|
|
f"{filtered_df['Congestion_Level'].mean():.1f}", |
|
|
help="Average congestion level (0-5 scale)", |
|
|
) |
|
|
|
|
|
with kpi_col4: |
|
|
st.metric( |
|
|
"Peak Hours Ratio", |
|
|
f"{(filtered_df['Peak_Off_Peak'] == 'Peak').sum() / len(filtered_df) * 100:.1f}%", |
|
|
help="Percentage of peak hour observations", |
|
|
) |
|
|
|
|
|
st.markdown("---") |
|
|
|
|
|
tab1, tab2, tab3, tab4 = st.tabs( |
|
|
[ |
|
|
"📈 Temporal Trends", |
|
|
"📍 Location Analysis", |
|
|
"📊 Distribution", |
|
|
"🏆 Top Zones", |
|
|
] |
|
|
) |
|
|
|
|
|
with tab1: |
|
|
st.subheader("Hourly Traffic Patterns") |
|
|
|
|
|
hourly_avg = ( |
|
|
filtered_df.groupby("Hour") |
|
|
.agg( |
|
|
{ |
|
|
"Vehicle_Count": "mean", |
|
|
"Vehicle_Speed": "mean", |
|
|
"Congestion_Level": "mean", |
|
|
} |
|
|
) |
|
|
.reset_index() |
|
|
) |
|
|
|
|
|
fig_hourly = go.Figure() |
|
|
|
|
|
fig_hourly.add_trace( |
|
|
go.Scatter( |
|
|
x=hourly_avg["Hour"], |
|
|
y=hourly_avg["Vehicle_Count"], |
|
|
mode="lines+markers", |
|
|
name="Avg Vehicle Count", |
|
|
line=dict(color="#1f77b4", width=3), |
|
|
yaxis="y", |
|
|
) |
|
|
) |
|
|
|
|
|
fig_hourly.add_trace( |
|
|
go.Scatter( |
|
|
x=hourly_avg["Hour"], |
|
|
y=hourly_avg["Vehicle_Speed"], |
|
|
mode="lines+markers", |
|
|
name="Avg Speed (km/h)", |
|
|
line=dict(color="#2ca02c", width=3), |
|
|
yaxis="y2", |
|
|
) |
|
|
) |
|
|
|
|
|
fig_hourly.update_layout( |
|
|
title="Average Traffic by Hour of Day", |
|
|
xaxis_title="Hour", |
|
|
yaxis_title="Vehicle Count", |
|
|
yaxis2=dict(title="Speed (km/h)", overlaying="y", side="right"), |
|
|
hovermode="x unified", |
|
|
template="plotly_white", |
|
|
height=500, |
|
|
) |
|
|
|
|
|
st.plotly_chart(fig_hourly, use_container_width=True) |
|
|
|
|
|
st.subheader("Traffic Evolution Over Time") |
|
|
|
|
|
time_series = ( |
|
|
filtered_df.groupby(["Timestamp", "Location"]) |
|
|
.agg({"Vehicle_Count": "sum", "Congestion_Level": "mean"}) |
|
|
.reset_index() |
|
|
) |
|
|
|
|
|
fig_ts = px.line( |
|
|
time_series, |
|
|
x="Timestamp", |
|
|
y="Vehicle_Count", |
|
|
color="Location", |
|
|
title="Traffic Volume Over Time by Location", |
|
|
labels={"Vehicle_Count": "Vehicle Count", "Timestamp": "Time"}, |
|
|
) |
|
|
|
|
|
fig_ts.update_layout(hovermode="x unified", template="plotly_white", height=500) |
|
|
|
|
|
st.plotly_chart(fig_ts, use_container_width=True) |
|
|
|
|
|
with tab2: |
|
|
col1, col2 = st.columns(2) |
|
|
|
|
|
with col1: |
|
|
st.subheader("Traffic by Location") |
|
|
|
|
|
location_stats = ( |
|
|
filtered_df.groupby("Location") |
|
|
.agg( |
|
|
{ |
|
|
"Vehicle_Count": "sum", |
|
|
"Vehicle_Speed": "mean", |
|
|
"Congestion_Level": "mean", |
|
|
} |
|
|
) |
|
|
.reset_index() |
|
|
) |
|
|
|
|
|
fig_loc = px.bar( |
|
|
location_stats, |
|
|
x="Location", |
|
|
y="Vehicle_Count", |
|
|
title="Total Vehicle Count by Location", |
|
|
color="Vehicle_Count", |
|
|
color_continuous_scale="Blues", |
|
|
labels={"Vehicle_Count": "Total Count"}, |
|
|
) |
|
|
|
|
|
fig_loc.update_layout(template="plotly_white", height=400) |
|
|
|
|
|
st.plotly_chart(fig_loc, use_container_width=True) |
|
|
|
|
|
with col2: |
|
|
st.subheader("Avg Speed by Location") |
|
|
|
|
|
fig_speed = px.bar( |
|
|
location_stats, |
|
|
x="Location", |
|
|
y="Vehicle_Speed", |
|
|
title="Average Speed by Location", |
|
|
color="Vehicle_Speed", |
|
|
color_continuous_scale="RdYlGn", |
|
|
labels={"Vehicle_Speed": "Speed (km/h)"}, |
|
|
) |
|
|
|
|
|
fig_speed.update_layout(template="plotly_white", height=400) |
|
|
|
|
|
st.plotly_chart(fig_speed, use_container_width=True) |
|
|
|
|
|
st.subheader("Congestion Heatmap: Hour vs Location") |
|
|
|
|
|
heatmap_data = filtered_df.pivot_table( |
|
|
values="Congestion_Level", index="Hour", columns="Location", aggfunc="mean" |
|
|
) |
|
|
|
|
|
fig_heatmap = px.imshow( |
|
|
heatmap_data, |
|
|
labels=dict(x="Location", y="Hour", color="Avg Congestion Level"), |
|
|
title="Average Congestion Level by Hour and Location", |
|
|
color_continuous_scale="RdYlGn_r", |
|
|
aspect="auto", |
|
|
) |
|
|
|
|
|
fig_heatmap.update_layout(template="plotly_white", height=500) |
|
|
|
|
|
st.plotly_chart(fig_heatmap, use_container_width=True) |
|
|
|
|
|
with tab3: |
|
|
col1, col2 = st.columns(2) |
|
|
|
|
|
with col1: |
|
|
st.subheader("Vehicle Count Distribution") |
|
|
|
|
|
fig_count_box = px.box( |
|
|
filtered_df, |
|
|
x="Location", |
|
|
y="Vehicle_Count", |
|
|
title="Vehicle Count Distribution by Location", |
|
|
color="Location", |
|
|
) |
|
|
|
|
|
fig_count_box.update_layout( |
|
|
template="plotly_white", height=400, showlegend=False |
|
|
) |
|
|
|
|
|
st.plotly_chart(fig_count_box, use_container_width=True) |
|
|
|
|
|
with col2: |
|
|
st.subheader("Speed Distribution") |
|
|
|
|
|
fig_speed_box = px.box( |
|
|
filtered_df, |
|
|
x="Location", |
|
|
y="Vehicle_Speed", |
|
|
title="Speed Distribution by Location", |
|
|
color="Location", |
|
|
) |
|
|
|
|
|
fig_speed_box.update_layout( |
|
|
template="plotly_white", height=400, showlegend=False |
|
|
) |
|
|
|
|
|
st.plotly_chart(fig_speed_box, use_container_width=True) |
|
|
|
|
|
st.subheader("Congestion Level Distribution") |
|
|
|
|
|
congestion_dist = ( |
|
|
filtered_df["Congestion_Level"].value_counts().sort_index().reset_index() |
|
|
) |
|
|
congestion_dist.columns = ["Congestion_Level", "Count"] |
|
|
|
|
|
fig_congestion = px.bar( |
|
|
congestion_dist, |
|
|
x="Congestion_Level", |
|
|
y="Count", |
|
|
title="Distribution of Congestion Levels", |
|
|
color="Congestion_Level", |
|
|
color_continuous_scale="Reds", |
|
|
labels={ |
|
|
"Count": "Number of Records", |
|
|
"Congestion_Level": "Congestion Level", |
|
|
}, |
|
|
) |
|
|
|
|
|
fig_congestion.update_layout(template="plotly_white", height=400) |
|
|
|
|
|
st.plotly_chart(fig_congestion, use_container_width=True) |
|
|
|
|
|
st.subheader("Congestion by Peak/Off-Peak") |
|
|
|
|
|
fig_peak = px.box( |
|
|
filtered_df, |
|
|
x="Peak_Off_Peak", |
|
|
y="Congestion_Level", |
|
|
title="Congestion Level: Peak vs Off-Peak", |
|
|
color="Peak_Off_Peak", |
|
|
) |
|
|
|
|
|
fig_peak.update_layout(template="plotly_white", height=400, showlegend=False) |
|
|
|
|
|
st.plotly_chart(fig_peak, use_container_width=True) |
|
|
|
|
|
with tab4: |
|
|
st.subheader("Most Congested Locations") |
|
|
|
|
|
location_congestion = ( |
|
|
filtered_df.groupby("Location") |
|
|
.agg( |
|
|
{ |
|
|
"Congestion_Level": "mean", |
|
|
"Vehicle_Count": "mean", |
|
|
"Vehicle_Speed": "mean", |
|
|
} |
|
|
) |
|
|
.round(2) |
|
|
.reset_index() |
|
|
) |
|
|
|
|
|
location_congestion = location_congestion.sort_values( |
|
|
"Congestion_Level", ascending=True |
|
|
) |
|
|
|
|
|
st.dataframe(location_congestion, use_container_width=True, hide_index=True) |
|
|
|
|
|
st.subheader("Top 5 Busiest Locations") |
|
|
|
|
|
top_locations = ( |
|
|
filtered_df.groupby("Location")["Vehicle_Count"] |
|
|
.sum() |
|
|
.sort_values(ascending=False) |
|
|
.head(5) |
|
|
.reset_index() |
|
|
) |
|
|
|
|
|
fig_top = px.bar( |
|
|
top_locations, |
|
|
x="Vehicle_Count", |
|
|
y="Location", |
|
|
orientation="h", |
|
|
title="Top 5 Locations by Total Traffic Volume", |
|
|
color="Vehicle_Count", |
|
|
color_continuous_scale="Blues", |
|
|
) |
|
|
|
|
|
fig_top.update_layout( |
|
|
template="plotly_white", |
|
|
height=400, |
|
|
yaxis={"categoryorder": "total ascending"}, |
|
|
) |
|
|
|
|
|
st.plotly_chart(fig_top, use_container_width=True) |
|
|
|
|
|
st.subheader("Slowest Locations (Lowest Avg Speed)") |
|
|
|
|
|
slowest_locations = ( |
|
|
filtered_df.groupby("Location")["Vehicle_Speed"] |
|
|
.mean() |
|
|
.sort_values() |
|
|
.head(5) |
|
|
.reset_index() |
|
|
) |
|
|
|
|
|
fig_slow = px.bar( |
|
|
slowest_locations, |
|
|
x="Vehicle_Speed", |
|
|
y="Location", |
|
|
orientation="h", |
|
|
title="Top 5 Slowest Locations", |
|
|
color="Vehicle_Speed", |
|
|
color_continuous_scale="Reds_r", |
|
|
) |
|
|
|
|
|
fig_slow.update_layout( |
|
|
template="plotly_white", |
|
|
height=400, |
|
|
yaxis={"categoryorder": "total ascending"}, |
|
|
) |
|
|
|
|
|
st.plotly_chart(fig_slow, use_container_width=True) |
|
|
|
|
|
st.markdown("---") |
|
|
st.subheader("💡 Automatic Insights") |
|
|
|
|
|
insights = [] |
|
|
|
|
|
if len(filtered_df) > 0: |
|
|
peak_hour = filtered_df.groupby("Hour")["Vehicle_Count"].mean().idxmax() |
|
|
insights.append( |
|
|
f"🕐 **Peak traffic hour**: {peak_hour}:00 - {peak_hour + 1}:00 with avg {filtered_df.groupby('Hour')['Vehicle_Count'].mean().max():.0f} vehicles" |
|
|
) |
|
|
|
|
|
busiest_loc = filtered_df.groupby("Location")["Vehicle_Count"].sum().idxmax() |
|
|
busiest_count = filtered_df.groupby("Location")["Vehicle_Count"].sum().max() |
|
|
insights.append( |
|
|
f"📍 **Busiest location**: {busiest_loc} with {busiest_count:,.0f} total vehicles" |
|
|
) |
|
|
|
|
|
avg_congestion = filtered_df["Congestion_Level"].mean() |
|
|
if avg_congestion < 2: |
|
|
congestion_status = "Low" |
|
|
elif avg_congestion < 4: |
|
|
congestion_status = "Moderate" |
|
|
else: |
|
|
congestion_status = "High" |
|
|
insights.append( |
|
|
f"🚦 **Overall congestion**: {congestion_status} (avg level: {avg_congestion:.1f}/5)" |
|
|
) |
|
|
|
|
|
weekday_avg = filtered_df[~filtered_df["IsWeekend"]]["Vehicle_Count"].mean() |
|
|
weekend_avg = filtered_df[filtered_df["IsWeekend"]]["Vehicle_Count"].mean() |
|
|
diff_pct = ( |
|
|
((weekday_avg - weekend_avg) / weekend_avg * 100) if weekend_avg > 0 else 0 |
|
|
) |
|
|
insights.append( |
|
|
f"📅 **Weekday vs Weekend**: Weekdays have {abs(diff_pct):.1f}% {'more' if diff_pct > 0 else 'less'} traffic on average" |
|
|
) |
|
|
|
|
|
peak_vs_offpeak_peak = filtered_df[filtered_df["Peak_Off_Peak"] == "Peak"][ |
|
|
"Congestion_Level" |
|
|
].mean() |
|
|
peak_vs_offpeak_off = filtered_df[filtered_df["Peak_Off_Peak"] == "Off-Peak"][ |
|
|
"Congestion_Level" |
|
|
].mean() |
|
|
insights.append( |
|
|
f"⏰ **Peak hours**: Congestion is {(peak_vs_offpeak_peak - peak_vs_offpeak_off):.1f} levels higher during peak hours" |
|
|
) |
|
|
|
|
|
for insight in insights: |
|
|
st.markdown(f"- {insight}") |
|
|
|
|
|
|
|
|
if __name__ == "__main__": |
|
|
main() |
|
|
|
