first commit

README.MD

@@ -0,0 +1,31 @@
+---
+title: Smart Bin AI
+emoji: 🗑️
+colorFrom: green
+colorTo: red
+sdk: gradio
+sdk_version: 4.44.0
+app_file: app.py
+pinned: false
+license: mit
+---
+
+# Smart Bin AI — Waste Management Intelligence
+
+Two ML models for smart city waste management:
+
+**Model 1 — Fill Level Predictor**
+- Input: live ultrasonic + weight sensor readings
+- Output: exact fill %, GREEN/YELLOW/RED status, confidence score
+- Algorithm: Random Forest (300 trees)
+- Accuracy: 99%+ classification, MAE < 1%
+
+**Model 2 — Garbage Flow Forecaster**
+- Input: current sensor readings + fill trend
+- Output: predicted fill % at +6h and +12h
+- Algorithm: Gradient Boosting
+- Accuracy: R2 = 0.77 (6h), 0.70 (12h)
+
+**Dataset:** 72,000 rows (100 bins × 720 hours) with realistic IoT sensor simulation including rush hour patterns, weekend effects, zone differences, sensor drift, and collection events.
+
+**Validation:** GroupKFold cross-validation (zero bin leakage between train and test)

Requirements.txt

@@ -0,0 +1,5 @@
+gradio==4.44.0
+scikit-learn==1.5.2
+pandas==2.2.3
+numpy==1.26.4
+joblib==1.4.2

app.py

@@ -0,0 +1,367 @@
+# app.py
+# This is the file Hugging Face looks for automatically.
+# It runs your Gradio interface and exposes the API.
+
+import gradio as gr
+import numpy as np
+import pandas as pd
+import joblib
+import os
+
+# ── Load all models (Hugging Face runs this once on startup) ──────────────────
+print("Loading models...")
+
+reg_model  = joblib.load("model1_regression.pkl")
+cls_model  = joblib.load("model1_classifier.pkl")
+m1_features = joblib.load("model1_features.pkl")
+
+forecast_6h  = joblib.load("model2_forecast_6h.pkl")
+forecast_12h = joblib.load("model2_forecast_12h.pkl")
+m2_features  = joblib.load("model2_features.pkl")
+
+print("All models loaded.")
+
+STATUS_NAMES  = {0: "🟢 GREEN — Empty",  1: "🟡 YELLOW — Filling",  2: "🔴 RED — Full"}
+STATUS_ACTION = {
+    0: "No action needed",
+    1: "Monitor — schedule collection soon",
+    2: "DISPATCH TRUCK IMMEDIATELY"
+}
+
+# ── Shared feature builder ────────────────────────────────────────────────────
+def build_row(ultrasonic, weight, fill_now, hour_of_day, day_of_week,
+              bin_type, location, zone,
+              fill_rate_1h=0, fill_rate_3h=0, fill_rate_6h=0,
+              rolling_fill_3h=None, rolling_fill_6h=None,
+              rolling_fill_12h=None, rolling_fill_24h=None,
+              hours_since_collection=24, week_number=0):
+
+    rolling_fill_3h  = rolling_fill_3h  or fill_now
+    rolling_fill_6h  = rolling_fill_6h  or fill_now
+    rolling_fill_12h = rolling_fill_12h or fill_now
+    rolling_fill_24h = rolling_fill_24h or fill_now
+
+    hours_to_full = max(0, min(72,
+        (80 - fill_now) / fill_rate_1h if fill_rate_1h > 0.01 else 72
+    ))
+    fill_acceleration = fill_rate_1h - (fill_rate_3h / 3 if fill_rate_3h else 0)
+
+    return {
+        "ultrasonic":          ultrasonic,
+        "weight":              weight,
+        "sensor_ratio":        weight / (ultrasonic + 1e-5),
+        "fill_percent":        fill_now,
+        "fill_rate_1h":        fill_rate_1h,
+        "fill_rate_3h":        fill_rate_3h,
+        "fill_rate_6h":        fill_rate_6h,
+        "fill_rate_12h":       0,
+        "fill_acceleration":   fill_acceleration,
+        "rolling_fill_3h":     rolling_fill_3h,
+        "rolling_fill_6h":     rolling_fill_6h,
+        "rolling_fill_12h":    rolling_fill_12h,
+        "rolling_fill_24h":    rolling_fill_24h,
+        "rolling_weight_3h":   weight,
+        "hour_of_day":         hour_of_day,
+        "day_of_week":         day_of_week,
+        "week_number":         week_number,
+        "is_weekend":          int(day_of_week >= 5),
+        "is_rush_hour":        int(hour_of_day in [7,8,9,12,13,17,18,19,20]),
+        "is_night":            int(hour_of_day in [0,1,2,3,4,5]),
+        "sin_hour":            np.sin(2 * np.pi * hour_of_day / 24),
+        "cos_hour":            np.cos(2 * np.pi * hour_of_day / 24),
+        "sin_day":             np.sin(2 * np.pi * day_of_week / 7),
+        "cos_day":             np.cos(2 * np.pi * day_of_week / 7),
+        "hours_since_collection": hours_since_collection,
+        "hours_to_full":       hours_to_full,
+        "bin_type_residential":int(bin_type == "residential"),
+        "bin_type_commercial": int(bin_type == "commercial"),
+        "location_urban":      int(location == "urban"),
+        "location_suburban":   int(location == "suburban"),
+        "location_mall":       int(location == "mall"),
+        "zone_north":          int(zone == "north"),
+        "zone_south":          int(zone == "south"),
+        "zone_east":           int(zone == "east"),
+        "zone_west":           int(zone == "west"),
+        "zone_central":        int(zone == "central"),
+    }
+
+
+def safe_predict(model, features, row_dict):
+    df = pd.DataFrame([row_dict])
+    for col in features:
+        if col not in df.columns:
+            df[col] = 0
+    return model.predict(df[features])
+
+
+# ── PREDICTION FUNCTION 1: Current fill status ────────────────────────────────
+def predict_current_status(
+    ultrasonic, weight, fill_now,
+    hour_of_day, day_of_week,
+    bin_type, location, zone,
+    fill_rate_1h, hours_since_collection
+):
+    try:
+        row = build_row(
+            ultrasonic=ultrasonic, weight=weight, fill_now=fill_now,
+            hour_of_day=int(hour_of_day), day_of_week=int(day_of_week),
+            bin_type=bin_type, location=location, zone=zone,
+            fill_rate_1h=fill_rate_1h,
+            hours_since_collection=int(hours_since_collection)
+        )
+
+        fill_pred  = float(np.clip(safe_predict(reg_model, m1_features, row)[0], 0, 100))
+        status_idx = int(safe_predict(cls_model, m1_features, row)[0])
+        proba      = cls_model.predict_proba(
+            pd.DataFrame([row])[[f for f in m1_features if f in row or True]]
+        )[0]
+
+        # Fix proba dataframe
+        df_row = pd.DataFrame([row])
+        for col in m1_features:
+            if col not in df_row.columns:
+                df_row[col] = 0
+        proba = cls_model.predict_proba(df_row[m1_features])[0]
+        confidence = float(proba.max()) * 100
+
+        result = f"""
+## 📊 Current Bin Status
+
+| Metric | Value |
+|--------|-------|
+| **Predicted Fill** | {fill_pred:.1f}% |
+| **Status** | {STATUS_NAMES[status_idx]} |
+| **Action** | {STATUS_ACTION[status_idx]} |
+| **Confidence** | {confidence:.1f}% |
+
+### Probability Breakdown
+- 🟢 GREEN (Empty):   {proba[0]*100:.1f}%
+- 🟡 YELLOW (Filling): {proba[1]*100:.1f}%
+- 🔴 RED (Full):      {proba[2]*100:.1f}%
+
+{"⚠️ **DISPATCH TRUCK NOW**" if status_idx == 2 else "✅ No immediate action required"}
+"""
+        return result
+
+    except Exception as e:
+        return f"❌ Error: {str(e)}"
+
+
+# ── PREDICTION FUNCTION 2: Flow forecast ─────────────────────────────────────
+def predict_forecast(
+    ultrasonic, weight, fill_now,
+    hour_of_day, day_of_week,
+    bin_type, location, zone,
+    fill_rate_1h, fill_rate_3h
+):
+    try:
+        row = build_row(
+            ultrasonic=ultrasonic, weight=weight, fill_now=fill_now,
+            hour_of_day=int(hour_of_day), day_of_week=int(day_of_week),
+            bin_type=bin_type, location=location, zone=zone,
+            fill_rate_1h=fill_rate_1h, fill_rate_3h=fill_rate_3h
+        )
+
+        df_row = pd.DataFrame([row])
+        for col in m2_features:
+            if col not in df_row.columns:
+                df_row[col] = 0
+        df_row = df_row[m2_features]
+
+        p6h  = float(np.clip(forecast_6h.predict(df_row)[0],  0, 100))
+        p12h = float(np.clip(forecast_12h.predict(df_row)[0], 0, 100))
+
+        # Urgency
+        if p6h >= 80:
+            urgency = "🔴 HIGH — Collect within 6 hours"
+        elif p12h >= 80:
+            urgency = "🟡 MEDIUM — Collect within 12 hours"
+        else:
+            urgency = "🟢 LOW — No collection needed soon"
+
+        bar_now  = "█" * int(fill_now  / 5) + "░" * (20 - int(fill_now  / 5))
+        bar_6h   = "█" * int(p6h  / 5) + "░" * (20 - int(p6h  / 5))
+        bar_12h  = "█" * int(p12h / 5) + "░" * (20 - int(p12h / 5))
+
+        result = f"""
+## 📈 Fill Level Forecast
+
+| Time | Predicted Fill | Bar |
+|------|---------------|-----|
+| **Now** | {fill_now:.1f}% | `{bar_now}` |
+| **+6 hours** | {p6h:.1f}% | `{bar_6h}` |
+| **+12 hours** | {p12h:.1f}% | `{bar_12h}` |
+
+### 🚛 Collection Urgency
+**{urgency}**
+
+### For Route Optimization
+```
+bin_fill_now:    {fill_now:.1f}%
+bin_fill_6h:     {p6h:.1f}%
+bin_fill_12h:    {p12h:.1f}%
+dispatch_urgent: {str(p6h >= 80).lower()}
+```
+"""
+        return result
+
+    except Exception as e:
+        return f"❌ Error: {str(e)}"
+
+
+# ── BUILD GRADIO UI ────────────────────────────────────────────────────────────
+with gr.Blocks(
+    title="Smart Bin AI",
+    theme=gr.themes.Soft()
+) as demo:
+
+    gr.Markdown("""
+    # 🗑️ Smart Bin AI — Waste Management Intelligence
+    **Model 1:** Predict current fill level (GREEN / YELLOW / RED)
+    **Model 2:** Forecast fill level 6h and 12h into the future
+
+    > Built with Random Forest + Gradient Boosting on 72,000 sensor readings
+    """)
+
+    # ── TAB 1: Current Status ─────────────────────────────────────────────────
+    with gr.Tab("📡 Current Fill Status (Model 1)"):
+        gr.Markdown("### Enter live sensor readings to get current bin status")
+
+        with gr.Row():
+            with gr.Column():
+                ultra1   = gr.Slider(4,  65,  value=30,  label="Ultrasonic Distance (cm) — lower = more full")
+                weight1  = gr.Slider(0,  36,  value=15,  label="Weight (kg)")
+                fill1    = gr.Slider(0,  100, value=50,  label="Current Fill % (from previous reading)")
+                rate1    = gr.Slider(0,  10,  value=1.0, label="Fill Rate per hour (%/hr)", step=0.1)
+                hours_sc = gr.Slider(0,  72,  value=24,  label="Hours Since Last Collection")
+
+            with gr.Column():
+                hour1    = gr.Slider(0,  23,  value=12,  label="Hour of Day (0–23)", step=1)
+                day1     = gr.Slider(0,  6,   value=1,   label="Day of Week (0=Mon, 6=Sun)", step=1)
+                btype1   = gr.Dropdown(["residential", "commercial"], value="commercial", label="Bin Type")
+                loc1     = gr.Dropdown(["urban", "suburban", "mall"], value="urban",     label="Location")
+                zone1    = gr.Dropdown(["north","south","east","west","central"], value="central", label="Zone")
+
+        btn1    = gr.Button("🔍 Predict Current Status", variant="primary", size="lg")
+        output1 = gr.Markdown()
+
+        btn1.click(
+            fn=predict_current_status,
+            inputs=[ultra1, weight1, fill1, hour1, day1, btype1, loc1, zone1, rate1, hours_sc],
+            outputs=output1
+        )
+
+        gr.Examples(
+            examples=[
+                [55, 2.5,  8,  9, 1, "residential", "suburban", "north", 0.3, 48],
+                [32, 15,  50, 13, 2, "commercial",  "urban",    "central", 2.0, 24],
+                [8,  30,  90, 18, 4, "commercial",  "urban",    "central", 4.0, 6],
+            ],
+            inputs=[ultra1, weight1, fill1, hour1, day1, btype1, loc1, zone1, rate1, hours_sc],
+            label="Try these examples"
+        )
+
+    # ── TAB 2: Flow Forecast ──────────────────────────────────────────────────
+    with gr.Tab("📈 Fill Forecast (Model 2)"):
+        gr.Markdown("### Predict how full this bin will be in 6 and 12 hours")
+
+        with gr.Row():
+            with gr.Column():
+                ultra2  = gr.Slider(4,  65,  value=30,  label="Ultrasonic Distance (cm)")
+                weight2 = gr.Slider(0,  36,  value=15,  label="Weight (kg)")
+                fill2   = gr.Slider(0,  100, value=50,  label="Current Fill %")
+                rate1h  = gr.Slider(0,  10,  value=1.5, label="Fill Rate last 1h (%/hr)",  step=0.1)
+                rate3h  = gr.Slider(0,  30,  value=4.0, label="Fill Rate last 3h (total)", step=0.1)
+
+            with gr.Column():
+                hour2   = gr.Slider(0,  23,  value=12, label="Hour of Day",     step=1)
+                day2    = gr.Slider(0,  6,   value=1,  label="Day of Week",     step=1)
+                btype2  = gr.Dropdown(["residential","commercial"], value="commercial", label="Bin Type")
+                loc2    = gr.Dropdown(["urban","suburban","mall"],  value="urban",      label="Location")
+                zone2   = gr.Dropdown(["north","south","east","west","central"], value="central", label="Zone")
+
+        btn2    = gr.Button("📈 Forecast Fill Level", variant="primary", size="lg")
+        output2 = gr.Markdown()
+
+        btn2.click(
+            fn=predict_forecast,
+            inputs=[ultra2, weight2, fill2, hour2, day2, btype2, loc2, zone2, rate1h, rate3h],
+            outputs=output2
+        )
+
+        gr.Examples(
+            examples=[
+                [52, 4,   15, 7,  1, "residential", "suburban", "north",   0.3, 0.8],
+                [30, 16,  55, 11, 2, "commercial",  "urban",    "central", 2.8, 7.5],
+                [12, 27,  78, 17, 4, "commercial",  "urban",    "central", 3.5, 9.0],
+            ],
+            inputs=[ultra2, weight2, fill2, hour2, day2, btype2, loc2, zone2, rate1h, rate3h],
+            label="Try these examples"
+        )
+
+    # ── TAB 3: API Docs for Node.js ───────────────────────────────────────────
+    with gr.Tab("🔌 Node.js API Docs"):
+        gr.Markdown("""
+        ## Using This As a Node.js API
+
+        Hugging Face Spaces exposes your Gradio app as a REST API automatically.
+        Install the client: `npm install @gradio/client`
+
+        ### Call Model 1 (Current Status)
+        ```javascript
+        const { Client } = require("@gradio/client");
+
+        async function getBinStatus(sensorData) {
+          const client = await Client.connect("YOUR_HF_USERNAME/smart-bin-ai");
+
+          const result = await client.predict("/predict_current_status", {
+            ultrasonic:            sensorData.ultrasonic,
+            weight:                sensorData.weight,
+            fill_now:              sensorData.fill_percent,
+            hour_of_day:           new Date().getHours(),
+            day_of_week:           new Date().getDay(),
+            bin_type:              sensorData.bin_type || "commercial",
+            location:              sensorData.location || "urban",
+            zone:                  sensorData.zone || "central",
+            fill_rate_1h:          sensorData.fill_rate || 0,
+            hours_since_collection: sensorData.hours_since_collection || 24,
+          });
+
+          return result.data;
+        }
+        ```
+
+        ### Call Model 2 (Forecast)
+        ```javascript
+        async function getForecast(sensorData) {
+          const client = await Client.connect("YOUR_HF_USERNAME/smart-bin-ai");
+
+          const result = await client.predict("/predict_forecast", {
+            ultrasonic:   sensorData.ultrasonic,
+            weight:       sensorData.weight,
+            fill_now:     sensorData.fill_percent,
+            hour_of_day:  new Date().getHours(),
+            day_of_week:  new Date().getDay(),
+            bin_type:     sensorData.bin_type || "commercial",
+            location:     sensorData.location || "urban",
+            zone:         sensorData.zone || "central",
+            fill_rate_1h: sensorData.fill_rate_1h || 0,
+            fill_rate_3h: sensorData.fill_rate_3h || 0,
+          });
+
+          return result.data;
+        }
+        ```
+
+        ### Replace `YOUR_HF_USERNAME` with your actual Hugging Face username.
+        ### Replace `smart-bin-ai` with your Space name if you chose a different one.
+        """)
+
+    gr.Markdown("""
+    ---
+    Built for Smart Waste Management | Random Forest (Model 1) + Gradient Boosting (Model 2)
+    | 72,000 training rows | GroupKFold validated
+    """)
+
+# Launch
+demo.launch()

model1_classifier.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f768e9d7660bdd89725904e73b234f94ede8498fbe137cde87da5d2069fd4420
+size 39330522

model1_features.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e116ef8f7f85dc8d8c66dbcf664f99c1db9fcbf44a0877829becc5a84d8baf6b
+size 503

model1_regression.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8706c1634f883a1c129348e16bd8a8ce14bf93c0503f4de71ce52a87cb854ad9
+size 638000922

model2_features.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e23f401b06f7921a4488457c3022f9dd7b82c53b34b27d578202347dc26bcc70
+size 570

model2_forecast_12h.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dd63458ecfff528b3569e58db81f1db1a9e9f0484c461c3b755582aeb26903ac
+size 1283875

model2_forecast_24h.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2d4b8b03f151f27ee6294300a23fffd32762a6cee5a91bc000bec83c976f629d
+size 1301747

model2_forecast_6h.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:48dc70f6ff9e2df79ababa5fd064e154639ae8b47630d8ac966871c9d368f4a5
+size 1281571

model2_metadata.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9ab3c31a2aed3cadebcc7579099cc9ea395f493ea60b6b72bcd5575524fb04a8
+size 312