Upload 4 files

README.md

@@ -1,12 +1,23 @@
 ---
-title: Deliveryoptimizationapp
-emoji: 📚
-colorFrom: red
-colorTo: green
+title: Delivery Delay Risk Intelligence Dashboard
+emoji: 🚚
+colorFrom: blue
+colorTo: indigo
 sdk: gradio
-sdk_version: 6.13.0
+sdk_version: 5.0.0
 app_file: app.py
 pinned: false
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Delivery Delay Risk Intelligence Dashboard
+
+This Hugging Face Space supports a university group project on delivery delay risk.
+
+It combines:
+- real-world/found delivery logistics data uploaded as CSV,
+- synthetic delivery-time generation logic,
+- quantitative dashboard analysis,
+- qualitative business recommendations,
+- automation through an AI-enhanced interface.
+
+Users can upload a delivery dataset or use the included sample dataset, filter operational conditions, identify high-risk delay factors, simulate a new delivery, and download an executive summary.

app.py

@@ -0,0 +1,390 @@
+import gradio as gr
+import pandas as pd
+import numpy as np
+import plotly.express as px
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.preprocessing import OneHotEncoder
+from sklearn.compose import ColumnTransformer
+from sklearn.pipeline import Pipeline
+from pathlib import Path
+import tempfile
+
+DATA_PATH = Path("synthetic_delivery_data.csv")
+
+NUMERIC_COLS = [
+    "distance_km", "package_weight_kg", "delivery_time_hours",
+    "expected_time_hours", "delivery_rating", "delivery_cost"
+]
+CAT_COLS = [
+    "delivery_partner", "package_type", "vehicle_type", "delivery_mode",
+    "region", "weather_condition", "delayed", "delivery_status"
+]
+
+CUSTOM_CSS = """
+.gradio-container {max-width: 1280px !important; margin: auto;}
+.metric-card {background: linear-gradient(135deg, #ffffff, #f7f8fb); border: 1px solid #e8e8ef; border-radius: 18px; padding: 18px; box-shadow: 0 8px 24px rgba(0,0,0,.05);} 
+.metric-label {font-size: 13px; color: #5f6470; margin-bottom: 6px;}
+.metric-value {font-size: 30px; font-weight: 800; color: #111827;}
+.insight-box {background: #111827; color: white; border-radius: 18px; padding: 20px; line-height: 1.55;}
+.small-muted {color: #6b7280; font-size: 13px;}
+"""
+
+
+def _clean_time_column(series):
+    """Convert either normal numbers or timestamp-looking duration strings into numeric hours."""
+    if pd.api.types.is_numeric_dtype(series):
+        return pd.to_numeric(series, errors="coerce")
+    s = series.astype(str)
+    # Handles values like 1970-01-01 00:00:00.000000008 by extracting last part.
+    extracted = s.str.split(".").str[-1]
+    return pd.to_numeric(extracted, errors="coerce")
+
+
+def load_and_prepare(file_obj=None):
+    if file_obj is None:
+        df = pd.read_csv(DATA_PATH)
+    else:
+        df = pd.read_csv(file_obj.name)
+
+    df = df.copy()
+    df.columns = df.columns.str.strip().str.lower()
+    df = df.drop_duplicates()
+
+    required_minimum = ["distance_km", "vehicle_type", "weather_condition", "delivery_mode", "region"]
+    missing_required = [c for c in required_minimum if c not in df.columns]
+    if missing_required:
+        raise gr.Error(f"Your file is missing these required columns: {missing_required}")
+
+    for col in ["delivery_time_hours", "expected_time_hours"]:
+        if col in df.columns:
+            df[col] = _clean_time_column(df[col])
+
+    for col in NUMERIC_COLS:
+        if col in df.columns:
+            df[col] = pd.to_numeric(df[col], errors="coerce")
+            df[col] = df[col].fillna(df[col].median())
+
+    for col in CAT_COLS:
+        if col in df.columns:
+            df[col] = df[col].astype(str).str.strip().str.lower()
+            if df[col].isna().any():
+                df[col] = df[col].fillna(df[col].mode()[0])
+
+    # If expected/delivery time are not reliable or missing, rebuild them with business logic.
+    df = create_synthetic_time_logic(df)
+    df["delay_hours"] = (df["delivery_time_hours"] - df["expected_time_hours"]).round(2)
+    df["calculated_delay"] = np.where(df["delay_hours"] > 0, "yes", "no")
+    df["delay_score"] = df["delay_hours"].apply(delay_score)
+    df["performance_label"] = df["delay_score"].apply(performance_label)
+    df["distance_category"] = pd.cut(
+        df["distance_km"],
+        bins=[0, 50, 150, 300, float("inf")],
+        labels=["short", "medium", "long", "very long"],
+        include_lowest=True,
+    ).astype(str)
+    return df
+
+
+def create_synthetic_time_logic(df):
+    df = df.copy()
+    for col in ["vehicle_type", "weather_condition", "delivery_mode", "region"]:
+        df[col] = df[col].astype(str).str.strip().str.lower()
+
+    vehicle_adjustment = {"bike": 1.2, "van": 0.5, "truck": 0.8, "ev van": 0.4}
+    weather_adjustment = {"clear": 0.0, "cloudy": 0.2, "foggy": 0.6, "rainy": 0.8, "stormy": 1.2, "cold": 0.2, "hot": 0.2, "windy": 0.3}
+    mode_adjustment = {"same day": 0.3, "express": 0.2, "two day": 0.7, "standard": 0.5}
+    region_adjustment = {"central": 0.6, "north": 0.3, "south": 0.3, "east": 0.4, "west": 0.4}
+
+    expected = (
+        df["distance_km"] / 45
+        + df["vehicle_type"].map(vehicle_adjustment).fillna(0.5)
+        + df["weather_condition"].map(weather_adjustment).fillna(0.3)
+        + df["delivery_mode"].map(mode_adjustment).fillna(0.4)
+        + df["region"].map(region_adjustment).fillna(0.3)
+    ).clip(lower=0.5)
+
+    vehicle_mult = {"bike": 1.05, "van": 0.95, "truck": 1.02, "ev van": 0.97}
+    weather_mult = {"clear": 0.95, "cloudy": 1.00, "foggy": 1.05, "rainy": 1.10, "stormy": 1.20, "cold": 1.02, "hot": 1.02, "windy": 1.03}
+    mode_mult = {"same day": 1.05, "express": 1.02, "two day": 0.97, "standard": 1.00}
+    region_mult = {"central": 1.08, "north": 1.00, "south": 1.01, "east": 1.02, "west": 1.03}
+
+    actual = (
+        expected
+        * df["vehicle_type"].map(vehicle_mult).fillna(1)
+        * df["weather_condition"].map(weather_mult).fillna(1)
+        * df["delivery_mode"].map(mode_mult).fillna(1)
+        * df["region"].map(region_mult).fillna(1)
+    ).clip(lower=0.5)
+
+    ratio = actual / expected
+    balanced_actual = np.where(
+        ratio < 0.98, expected * 0.95,
+        np.where(ratio < 1.05, expected * 1.00,
+                 np.where(ratio < 1.15, expected * 1.10, expected * 1.25))
+    )
+    df["expected_time_hours"] = expected.round(2)
+    df["delivery_time_hours"] = pd.Series(balanced_actual).round(2)
+    return df
+
+
+def delay_score(delay):
+    if delay <= 0: return 5
+    if delay <= 2: return 4
+    if delay <= 5: return 3
+    if delay <= 8: return 2
+    return 1
+
+
+def performance_label(score):
+    return {5: "excellent", 4: "good", 3: "average", 2: "poor", 1: "critical"}.get(int(score), "unknown")
+
+
+def filter_df(df, vehicle, weather, mode, region):
+    out = df.copy()
+    filters = {"vehicle_type": vehicle, "weather_condition": weather, "delivery_mode": mode, "region": region}
+    for col, selected in filters.items():
+        if selected and "all" not in selected:
+            out = out[out[col].isin(selected)]
+    return out
+
+
+def kpi_html(df):
+    total = len(df)
+    delay_rate = (df["calculated_delay"].eq("yes").mean() * 100) if total else 0
+    avg_delay = df["delay_hours"].mean() if total else 0
+    avg_score = df["delay_score"].mean() if total else 0
+    cost = df["delivery_cost"].mean() if "delivery_cost" in df.columns and total else 0
+    return f"""
+    <div style='display:grid;grid-template-columns:repeat(4,minmax(0,1fr));gap:14px;'>
+      <div class='metric-card'><div class='metric-label'>Deliveries analyzed</div><div class='metric-value'>{total:,.0f}</div></div>
+      <div class='metric-card'><div class='metric-label'>Delay rate</div><div class='metric-value'>{delay_rate:.1f}%</div></div>
+      <div class='metric-card'><div class='metric-label'>Average delay hours</div><div class='metric-value'>{avg_delay:.2f}</div></div>
+      <div class='metric-card'><div class='metric-label'>Avg. delay score</div><div class='metric-value'>{avg_score:.2f}/5</div></div>
+    </div>
+    <p class='small-muted'>Average delivery cost in filtered data: {cost:,.2f}</p>
+    """
+
+
+def group_summary(df, col):
+    return (
+        df.groupby(col, observed=False)
+        .agg(
+            deliveries=(col, "size"),
+            delay_rate=("calculated_delay", lambda x: round((x.eq("yes").mean() * 100), 2)),
+            avg_delay_hours=("delay_hours", "mean"),
+            avg_delay_score=("delay_score", "mean"),
+            avg_distance_km=("distance_km", "mean"),
+        )
+        .round(2)
+        .sort_values(["delay_rate", "avg_delay_hours"], ascending=False)
+        .reset_index()
+    )
+
+
+def make_charts(df):
+    by_vehicle = group_summary(df, "vehicle_type")
+    by_weather = group_summary(df, "weather_condition")
+    by_region = group_summary(df, "region")
+    by_mode = group_summary(df, "delivery_mode")
+
+    fig_vehicle = px.bar(by_vehicle, x="vehicle_type", y="delay_rate", text="delay_rate", title="Delay Risk by Vehicle Type")
+    fig_weather = px.bar(by_weather, x="weather_condition", y="avg_delay_hours", text="avg_delay_hours", title="Average Delay Hours by Weather")
+    fig_region = px.bar(by_region, x="region", y="delay_rate", text="delay_rate", title="Delay Rate by Region")
+    fig_mode = px.bar(by_mode, x="delivery_mode", y="avg_delay_score", text="avg_delay_score", title="Performance Score by Delivery Mode")
+    fig_scatter = px.scatter(df.sample(min(len(df), 2000), random_state=42), x="distance_km", y="delay_hours", color="weather_condition", hover_data=["vehicle_type", "delivery_mode", "region"], title="Distance vs Delay Hours")
+
+    for fig in [fig_vehicle, fig_weather, fig_region, fig_mode, fig_scatter]:
+        fig.update_layout(template="plotly_white", height=430, margin=dict(l=40, r=20, t=60, b=40))
+    return fig_vehicle, fig_weather, fig_region, fig_mode, fig_scatter
+
+
+def train_feature_importance(df):
+    model_cols = ["vehicle_type", "weather_condition", "delivery_mode", "region", "distance_category", "distance_km", "package_weight_kg"]
+    model_cols = [c for c in model_cols if c in df.columns]
+    X = df[model_cols]
+    y = df["calculated_delay"].eq("yes").astype(int)
+    cat = [c for c in model_cols if X[c].dtype == "object" or str(X[c].dtype) == "category"]
+    num = [c for c in model_cols if c not in cat]
+    pre = ColumnTransformer([("cat", OneHotEncoder(handle_unknown="ignore"), cat), ("num", "passthrough", num)])
+    clf = RandomForestClassifier(n_estimators=80, random_state=42, max_depth=7)
+    pipe = Pipeline([("pre", pre), ("clf", clf)])
+    pipe.fit(X, y)
+    names = list(pipe.named_steps["pre"].get_feature_names_out())
+    importances = pipe.named_steps["clf"].feature_importances_
+    imp = pd.DataFrame({"factor": names, "importance": importances}).sort_values("importance", ascending=False).head(12)
+    imp["factor"] = imp["factor"].str.replace("cat__", "", regex=False).str.replace("num__", "", regex=False)
+    fig = px.bar(imp.sort_values("importance"), x="importance", y="factor", orientation="h", title="AI Model: Most Important Delay-Risk Drivers")
+    fig.update_layout(template="plotly_white", height=470, margin=dict(l=120, r=20, t=60, b=40))
+    return fig, imp
+
+
+def auto_insights(df):
+    if len(df) == 0:
+        return "<div class='insight-box'>No data available for the selected filters.</div>"
+    summaries = {c: group_summary(df, c) for c in ["vehicle_type", "weather_condition", "delivery_mode", "region", "distance_category"] if c in df.columns}
+    worst = {k: v.iloc[0] for k, v in summaries.items() if len(v) > 0}
+    best = {k: v.sort_values(["delay_rate", "avg_delay_hours"], ascending=True).iloc[0] for k, v in summaries.items() if len(v) > 0}
+    top_risk_text = "<br>".join([f"• <b>{k.replace('_',' ').title()}</b>: highest risk = <b>{row[k]}</b> ({row['delay_rate']:.1f}% delay rate, {row['avg_delay_hours']:.2f} avg delay hours)" for k, row in worst.items()])
+    best_text = "<br>".join([f"• <b>{k.replace('_',' ').title()}</b>: best performer = <b>{row[k]}</b> ({row['delay_rate']:.1f}% delay rate)" for k, row in best.items()])
+    delay_rate = df["calculated_delay"].eq("yes").mean() * 100
+    recommendation = "Prioritize operational buffers for the highest-risk combinations, especially where bad weather, central routes, same-day delivery, or slower vehicle types overlap."
+    if delay_rate > 35:
+        recommendation += " The current filtered scenario has a high delay rate, so management should add contingency capacity and proactively communicate expected delays to customers."
+    else:
+        recommendation += " The current filtered scenario is relatively manageable, so management can focus on monitoring and selective process improvements."
+    return f"""
+    <div class='insight-box'>
+    <h3>AI-enhanced executive interpretation</h3>
+    <p><b>Business challenge:</b> Which operational factors create the highest delivery-delay risk, and what should management do?</p>
+    <p><b>Highest-risk factors found in the filtered data:</b><br>{top_risk_text}</p>
+    <p><b>Best-performing conditions:</b><br>{best_text}</p>
+    <p><b>Management action:</b> {recommendation}</p>
+    <p><b>Qualitative interpretation:</b> Delay risk is not only a numeric issue. It affects customer trust, service reliability, driver planning, and cost control. The dashboard therefore combines quantitative KPIs with qualitative business recommendations.</p>
+    </div>
+    """
+
+
+def update_dashboard(file_obj, vehicle, weather, mode, region):
+    df = load_and_prepare(file_obj)
+    fdf = filter_df(df, vehicle, weather, mode, region)
+    if len(fdf) == 0:
+        raise gr.Error("Your filters produced no rows. Select fewer filters.")
+    figs = make_charts(fdf)
+    model_fig, imp = train_feature_importance(fdf)
+    sample = fdf.head(15)
+    tables = [group_summary(fdf, c) for c in ["vehicle_type", "weather_condition", "region", "delivery_mode", "distance_category"]]
+    return (kpi_html(fdf), auto_insights(fdf), *figs, model_fig, *tables, sample)
+
+
+def choices_from_data(file_obj=None):
+    df = load_and_prepare(file_obj)
+    return [
+        gr.update(choices=sorted(df["vehicle_type"].dropna().unique().tolist()), value=[]),
+        gr.update(choices=sorted(df["weather_condition"].dropna().unique().tolist()), value=[]),
+        gr.update(choices=sorted(df["delivery_mode"].dropna().unique().tolist()), value=[]),
+        gr.update(choices=sorted(df["region"].dropna().unique().tolist()), value=[]),
+    ]
+
+
+def simulate_delivery(distance, weight, vehicle, weather, mode, region):
+    row = pd.DataFrame({
+        "distance_km": [distance], "package_weight_kg": [weight], "vehicle_type": [vehicle],
+        "weather_condition": [weather], "delivery_mode": [mode], "region": [region]
+    })
+    row = create_synthetic_time_logic(row)
+    row["delay_hours"] = (row["delivery_time_hours"] - row["expected_time_hours"]).round(2)
+    row["delay_score"] = row["delay_hours"].apply(delay_score)
+    row["performance_label"] = row["delay_score"].apply(performance_label)
+    risk = "HIGH RISK" if row.loc[0, "delay_hours"] > 0 else "LOW RISK"
+    return f"""
+    ### Simulation Result
+    - Expected delivery time: **{row.loc[0, 'expected_time_hours']:.2f} hours**
+    - Predicted actual delivery time: **{row.loc[0, 'delivery_time_hours']:.2f} hours**
+    - Predicted delay: **{row.loc[0, 'delay_hours']:.2f} hours**
+    - Delay score: **{row.loc[0, 'delay_score']}/5**
+    - Performance label: **{row.loc[0, 'performance_label'].title()}**
+    - Risk classification: **{risk}**
+    """
+
+
+def download_summary(file_obj, vehicle, weather, mode, region):
+    df = load_and_prepare(file_obj)
+    fdf = filter_df(df, vehicle, weather, mode, region)
+    summary = {
+        "rows_analyzed": len(fdf),
+        "delay_rate_percent": round(fdf["calculated_delay"].eq("yes").mean() * 100, 2),
+        "average_delay_hours": round(fdf["delay_hours"].mean(), 2),
+        "average_delay_score": round(fdf["delay_score"].mean(), 2),
+    }
+    lines = ["Delivery Delay Risk Executive Summary", "", "KPIs:"]
+    for k, v in summary.items():
+        lines.append(f"- {k.replace('_', ' ').title()}: {v}")
+    lines += ["", "Highest-risk groups:"]
+    for c in ["vehicle_type", "weather_condition", "delivery_mode", "region", "distance_category"]:
+        tab = group_summary(fdf, c)
+        row = tab.iloc[0]
+        lines.append(f"- {c}: {row[c]} | delay rate {row['delay_rate']}% | avg delay {row['avg_delay_hours']}h")
+    lines += ["", "Recommended actions:", "- Add operational buffers for high-risk weather and region combinations.", "- Match faster vehicle types to same-day and express deliveries.", "- Use the simulator before accepting risky delivery promises.", "- Monitor delay score weekly as an operational KPI."]
+    tmp = tempfile.NamedTemporaryFile(delete=False, suffix=".txt", mode="w", encoding="utf-8")
+    tmp.write("\n".join(lines))
+    tmp.close()
+    return tmp.name
+
+
+base_df = load_and_prepare(None)
+vehicle_choices = sorted(base_df["vehicle_type"].dropna().unique().tolist())
+weather_choices = sorted(base_df["weather_condition"].dropna().unique().tolist())
+mode_choices = sorted(base_df["delivery_mode"].dropna().unique().tolist())
+region_choices = sorted(base_df["region"].dropna().unique().tolist())
+
+with gr.Blocks(theme=gr.themes.Soft(primary_hue="indigo", neutral_hue="slate"), css=CUSTOM_CSS, title="Delivery Delay Risk Dashboard") as demo:
+    gr.Markdown("""
+    # 🚚 Delivery Delay Risk Intelligence Dashboard
+    **AI-enhanced operations dashboard for identifying delivery delay risk factors and management actions.**
+
+    Upload your CSV or use the included dataset. The app cleans the data, generates realistic delivery-time logic, calculates delay risk, visualizes operational drivers, simulates new deliveries, and creates an executive summary.
+    """)
+
+    with gr.Row():
+        file_input = gr.File(label="Optional: upload your real-world/found delivery CSV", file_types=[".csv"])
+        refresh_btn = gr.Button("Load / refresh data", variant="primary")
+
+    with gr.Accordion("Filters", open=True):
+        with gr.Row():
+            vehicle_filter = gr.Dropdown(vehicle_choices, label="Vehicle type", multiselect=True)
+            weather_filter = gr.Dropdown(weather_choices, label="Weather condition", multiselect=True)
+            mode_filter = gr.Dropdown(mode_choices, label="Delivery mode", multiselect=True)
+            region_filter = gr.Dropdown(region_choices, label="Region", multiselect=True)
+
+    kpis = gr.HTML()
+    insights = gr.HTML()
+
+    with gr.Tab("Interactive dashboard"):
+        with gr.Row():
+            fig_vehicle = gr.Plot()
+            fig_weather = gr.Plot()
+        with gr.Row():
+            fig_region = gr.Plot()
+            fig_mode = gr.Plot()
+        fig_scatter = gr.Plot()
+
+    with gr.Tab("AI risk-driver model"):
+        model_fig = gr.Plot()
+        gr.Markdown("This section trains a simple Random Forest model inside the app to estimate which factors are most important for predicting delays.")
+
+    with gr.Tab("Summary tables"):
+        with gr.Row():
+            vehicle_table = gr.Dataframe(label="Vehicle performance")
+            weather_table = gr.Dataframe(label="Weather performance")
+        with gr.Row():
+            region_table = gr.Dataframe(label="Region performance")
+            mode_table = gr.Dataframe(label="Delivery mode performance")
+        distance_table = gr.Dataframe(label="Distance category performance")
+        sample_table = gr.Dataframe(label="Cleaned sample data")
+
+    with gr.Tab("Delivery risk simulator"):
+        with gr.Row():
+            sim_distance = gr.Slider(1, 500, value=120, label="Distance km")
+            sim_weight = gr.Slider(0.1, 60, value=10, label="Package weight kg")
+        with gr.Row():
+            sim_vehicle = gr.Dropdown(vehicle_choices, value=vehicle_choices[0], label="Vehicle")
+            sim_weather = gr.Dropdown(weather_choices, value=weather_choices[0], label="Weather")
+            sim_mode = gr.Dropdown(mode_choices, value=mode_choices[0], label="Mode")
+            sim_region = gr.Dropdown(region_choices, value=region_choices[0], label="Region")
+        sim_btn = gr.Button("Simulate delivery risk", variant="primary")
+        sim_output = gr.Markdown()
+
+    with gr.Tab("Download executive summary"):
+        gr.Markdown("Generate a short text summary for your presentation/report.")
+        download_btn = gr.Button("Create executive summary file")
+        download_file = gr.File(label="Download summary")
+
+    outputs = [kpis, insights, fig_vehicle, fig_weather, fig_region, fig_mode, fig_scatter, model_fig, vehicle_table, weather_table, region_table, mode_table, distance_table, sample_table]
+    refresh_btn.click(update_dashboard, inputs=[file_input, vehicle_filter, weather_filter, mode_filter, region_filter], outputs=outputs)
+    file_input.change(choices_from_data, inputs=[file_input], outputs=[vehicle_filter, weather_filter, mode_filter, region_filter])
+    sim_btn.click(simulate_delivery, inputs=[sim_distance, sim_weight, sim_vehicle, sim_weather, sim_mode, sim_region], outputs=sim_output)
+    download_btn.click(download_summary, inputs=[file_input, vehicle_filter, weather_filter, mode_filter, region_filter], outputs=download_file)
+    demo.load(update_dashboard, inputs=[file_input, vehicle_filter, weather_filter, mode_filter, region_filter], outputs=outputs)
+
+if __name__ == "__main__":
+    demo.launch()

requirements.txt

@@ -0,0 +1,5 @@
+gradio
+pandas
+numpy
+plotly
+scikit-learn