Upload folder using huggingface_hub

README.md

@@ -0,0 +1,92 @@
+---
+license: cc-by-4.0
+source_datasets:
+- original
+task_categories:
+- tabular-classification
+- time-series-forecasting
+tags:
+- ev
+- data-engineering
+- medallion
+- teaching
+- sensor-data
+size_categories:
+- 10K<n<100K
+pretty_name: EV Fleet Telemetry Arrival Stream (Bronze) — Sample EV Data CSV
+---
+Attribution: original hourly telemetry derived from Kaggle dataset "EV Sensors:
+Driving Pattern Diagnostics (2020-24)" by Kunal Mehra (https://www.kaggle.com/datasets/kunalm95/ev-sensors-driving-pattern-diagnostics-2020-24),
+CC BY 4.0. Dimension enrichment and planted sensor faults are synthetic (deterministic, seed 7), also CC BY 4.0.
+
+# Bronze Layer — EV Sensor Arrival Stream (download this and work from here)
+
+You are holding what a fleet operator's data engineer receives: **raw sensor data,
+exactly as it arrives** — and real arrival data is never clean. Everything you need
+for a data-cleaning exercise is in this folder. You do not need anything else.
+
+## Contents
+
+| file | what it is |
+|---|---|
+| `ingest_stream_2024.csv` | **the demo/hands-on file**: 35,363 hourly sensor rows, one calendar year (2024), four EVs, delivered shuffled in arrival order — with realistic sensor faults planted |
+| `raw/daily_user.csv` … `raw/rare_user.csv` | the original Kaggle telemetry files (Kunal Mehra, CC BY 4.0), untouched — the "published clean" counterpart |
+| `fault_census.json` | **answer key**: exact counts and ranges of every fault planted |
+| `make_bronze_stream.py` | deterministic generator (seed 7) producing `ingest_stream_2024.csv` from the clean files — fully reproducible |
+| `README.md` | this file |
+
+## Schema of `ingest_stream_2024.csv` (17 columns)
+
+| column | meaning |
+|---|---|
+| `timestamp` | hourly, 2024 |
+| `vehicle_id` | EV-101 rare · EV-102 moderate · EV-103 daily · EV-104 heavy user |
+| `user_profile` | usage profile of that vehicle |
+| `district` | location that hour (Downtown · Harbor · University · Industrial), 82 % home district |
+| `SOC` | state of charge %, valid range 0–100 |
+| `SOH` | state of health %, valid range 0–100 |
+| `Charging_Cycles` | lifetime full-charge cycles |
+| `charging_now` | 1 when SOC rises vs previous hour (derived) |
+| `Battery_Temp`, `Motor_Temp` | °C |
+| `Motor_RPM`, `Motor_Torque` | rpm · Nm |
+| `Brake_Pad_Wear` | %, valid range 0–100 |
+| `Charging_Voltage` | V |
+| `Tire_Pressure` | **PSI** by contract (valid ≈ 25–45) |
+| `DTC` | 0 = no fault, else diagnostic trouble code string |
+| `grid_carbon_g_per_kwh` | district grid carbon intensity, gCO₂/kWh at that hour |
+
+## The faults planted (what your cleaning demo will find)
+
+| fault | how to detect | count planted |
+|---|---|---|
+| missing readings | empty cell in `SOC`, `Battery_Temp`, `Tire_Pressure` | 1,250 (434 + 398 + 418) |
+| `SOC` out of bound | value > 100 | 276 |
+| `SOH` out of bound | value > 100 | 174 |
+| `Battery_Temp` out of bound | value < −25 °C | 172 |
+| `Brake_Pad_Wear` out of bound | value > 100 | 209 |
+| `Tire_Pressure` zero (dead sensor) | value = 0 | 24 |
+| unit mix-up: pressure in kPa | value > 60 → divide by 6.895 | 517 |
+| duplicate rows (sensor retry/double-write) | identical full rows | 419 |
+
+After a correct cleaning pass you should have **34,944 rows** — that number is in
+`fault_census.json` too, so participants can self-check.
+
+No `SOC` outlier exceeds 145 and no `SOH` outlier exceeds 104.5 by design, so simple
+range rules are unambiguous. Cleaning policy questions to raise in class:
+*fix, flag, or drop?* for each fault type — a wrong indicator is worse than no indicator.
+
+## What the cleaned data enables (gold layer, built live)
+
+- battery `SOH` decline per vehicle/profile → fleet replacement decisions
+- `DTC` precursor patterns by usage profile → predictive maintenance
+- emissions per vehicle-day via `grid_carbon_g_per_kwh` × kWh charged → the
+  "same EV, very different footprint by district" insight (Industrial ≈ 577 vs
+  University ≈ 363 g/kWh on the full 2020–24 silver data)
+
+## Licensing / provenance
+
+Original hourly telemetry: Kaggle "EV Sensors: Driving Pattern Diagnostics (2020-24)"
+by Kunal Mehra, CC BY 4.0. The arrival stream, dimension enrichment and the planted
+faults are synthetic additions under the same license (CC BY 4.0, attribution required).
+Absolute row-level values are simulated — treat as realistic-pattern teaching data,
+not ground truth.

fault_census.json

@@ -0,0 +1,52 @@
+{
+  "rows": 34944,
+  "faults": {
+    "missing_values": 1250,
+    "missing_by_field": {
+      "SOC": 434,
+      "Battery_Temp": 398,
+      "Tire_Pressure": 418
+    },
+    "out_of_bound:SOC": {
+      "n": 276,
+      "planted_range": [
+        100.5,
+        145
+      ]
+    },
+    "out_of_bound:SOH": {
+      "n": 174,
+      "planted_range": [
+        100.0,
+        104.2
+      ]
+    },
+    "out_of_bound:Battery_Temp": {
+      "n": 172,
+      "planted_range": [
+        -42.0,
+        -25.0
+      ]
+    },
+    "out_of_bound:Brake_Pad_Wear": {
+      "n": 209,
+      "planted_range": [
+        100.5,
+        112.0
+      ]
+    },
+    "out_of_bound:Tire_Pressure_zero": {
+      "n": 24,
+      "planted_range": [
+        0,
+        0
+      ]
+    },
+    "unit_mix:Tire_Pressure_kPa": {
+      "n": 517,
+      "rule": "value > 60 implies kPa; /6.895 to PSI"
+    },
+    "duplicate_rows": 419,
+    "rows_after_fault_injection": 35363
+  }
+}

make_bronze_stream.py

@@ -0,0 +1,82 @@
+#!/usr/bin/env python3
+"""Simulate a realistic 'arrival stream' for the cleaning demo.
+
+Takes the (clean) 2024 silver facts for all four vehicles, then plants the
+faults a real sensor feed produces: missing readings, out-of-bound values,
+unit mix-ups, and duplicate retries. Deterministic (seed 7). Output plus an
+exact fault census go to silver-checkable CSV + JSON so the instructor has
+an answer key: after cleaning, row and fault counts must match.
+"""
+import csv, json, random, os
+BASE = os.path.expanduser("~/presentations/data/ev_enriched")
+random.seed(7)
+
+# ---- load 2024 rows from all profiles (the "clean truth" we corrupt) ----
+truth = []
+for prof in ["rare_user", "moderate_user", "daily_user", "heavy_user"]:
+    with open(f"{BASE}/silver/fact_telemetry_{prof}.csv") as f:
+        for r in csv.DictReader(f):
+            if r["timestamp"].startswith("2024"):
+                truth.append(r)
+print("clean truth rows (2024):", len(truth))
+
+def census():
+    return {"rows": len(truth), "faults": {}}
+
+c = census()
+rows = []
+# ---- 1. missing readings (~3.5% of rows, one field each) ----
+miss = {"SOC": 0, "Battery_Temp": 0, "Tire_Pressure": 0}
+for r in truth:
+    x = random.random()
+    if x < 0.012:   r["SOC"] = "";            miss["SOC"] += 1
+    elif x < 0.024: r["Battery_Temp"] = "";   miss["Battery_Temp"] += 1
+    elif x < 0.035: r["Tire_Pressure"] = "";  miss["Tire_Pressure"] += 1
+c["faults"]["missing_values"] = sum(miss.values()); c["faults"]["missing_by_field"] = miss
+rows.extend(truth)
+
+# ---- 2. out-of-bound values (plausible sensor glitches) ----
+def ob(col, lo, hi, frac):
+    picks = [r for r in rows if r[col] != ""]
+    chosen = random.sample(picks, int(len(picks) * frac))
+    for r in chosen:
+        v = float(r[col])
+        r[col] = round(lo + (hi - lo) * random.random(), 2)
+    c["faults"][f"out_of_bound:{col}"] = {"n": len(chosen), "planted_range": [lo, hi]}
+
+ob("SOC", 100.5, 145, 0.008)          # SOC can never exceed 100 %
+ob("SOH", 100.0, 104.2, 0.005)        # health % cannot exceed 100
+ob("Battery_Temp", -42.0, -25.0, 0.005)  # below thermistor floor
+ob("Brake_Pad_Wear", 100.5, 112.0, 0.006)
+c["faults"]["out_of_bound:Tire_Pressure_zero"] = {"n": 0}
+rowsz = [r for r in rows if r["Tire_Pressure"] != ""]
+for r in random.sample(rowsz, 24):
+    r["Tire_Pressure"] = "0.0"
+c["faults"]["out_of_bound:Tire_Pressure_zero"] = {"n": 24, "planted_range": [0, 0]}
+
+# ---- 3. unit mix-up: tire pressure reported in kPa (PSI × 6.895) by one gateway ----
+kpak = [r for r in rows if r["Tire_Pressure"] != "" and float(r["Tire_Pressure"]) > 0]
+chosen = random.sample(kpak, int(len(kpak) * 0.015))
+for r in chosen:
+    r["Tire_Pressure"] = round(float(r["Tire_Pressure"]) * 6.895, 1)   # 34 PSI -> ~234 kPa
+c["faults"]["unit_mix:Tire_Pressure_kPa"] = {"n": len(chosen), "rule": "value > 60 implies kPa; /6.895 to PSI"}
+
+# ---- 4. duplicate retries (~1.2%) ----
+dup_ct = int(len(rows) * 0.012)
+rows.extend([dict(r) for r in random.sample(rows, dup_ct)])
+c["faults"]["duplicate_rows"] = dup_ct
+
+# ---- 5. shuffle: arrival order is never sorted ----
+random.shuffle(rows)
+
+cols = ["timestamp","vehicle_id","user_profile","district","SOC","SOH","Charging_Cycles",
+        "charging_now","Battery_Temp","Motor_RPM","Motor_Torque","Motor_Temp",
+        "Brake_Pad_Wear","Charging_Voltage","Tire_Pressure","DTC","grid_carbon_g_per_kwh"]
+out = f"{BASE}/bronze/ingest_stream_2024.csv"
+with open(out, "w", newline="") as f:
+    w = csv.DictWriter(f, cols); w.writeheader(); w.writerows(rows)
+c["faults"]["rows_after_fault_injection"] = len(rows)
+with open(f"{BASE}/bronze/fault_census.json", "w") as f:
+    json.dump(c, f, indent=2)
+print(json.dumps(c, indent=2))
+print("wrote", out)