Project Demo
During the project demonstration, the system begins with a login interface where
both patients and doctors can access their respective dashboards. Patients enter
their health vitals such as heart rate, blood pressure, oxygen level, and
temperature, which are first validated to ensure accuracy. Once submitted, the
values are analyzed by the Random Forest machine learning model to determine
whether the condition is normal or critical. If the readings are within safe
ranges, the system confirms it on the patient dashboard. However, if a critical
condition is detected, an emergency alert is instantly triggered and displayed on
the doctor’s dashboard along with the patient’s details and history. This ensures
that the doctor can review the data in real time and respond with timely advice or
medical intervention, thereby demonstrating how the system enables continuous
monitoring, proactive prediction, and rapid emergency response for elderly
healthcare.
1) Objectives (explained)
The system’s goals are threefold:
Timely emergency detection: Continuously watch key vitals (HR, BP, SpO₂,
temperature) and trigger instant alerts to caregivers/doctors when readings turn
risky, cutting response time in critical moments.
Affordable & accessible care: Run as a lightweight Flask web app that works with
simple inputs or low-cost sensors, so both urban and rural users can adopt it
without expensive hardware.
Predictive intelligence (not just thresholds): Use machine learning (Random Forest)
to spot patterns and trends, reducing false alarms and catching issues before they
escalate.
2) Software & Hardware Requirements (what and why)
Software
OS: Windows/Linux/macOS – good Python support and tooling.
Language/Framework: Python 3.9+ with Flask for a simple, flexible web backend and
REST endpoints.
DB: SQLite/MySQL – SQLite for quick local testing; MySQL for scalable deployments.
ML stack: scikit-learn, NumPy, Pandas for training and inference.
Frontend: HTML5/CSS/JS (Bootstrap) for a clean, responsive UI.
Server: Flask dev server (dev), Gunicorn (production).
IDE/Env: VS Code/PyCharm; venv/Conda to isolate dependencies.
Hardware
CPU: Core i5+ (multi-core helps with ML inference).
RAM: 8GB+ (datasets, model, and server together).
Storage: 256GB SSD (faster I/O for logs/data).
Network: Stable broadband (alerts, updates).
Optional: NVIDIA GPU (future DL), low-cost sensors for vitals.
3) Methodology — Diagrams & Algorithms (made simple)
a) Flow diagram (how a session runs)
Login (patient/doctor).
Patient dashboard: user enters vitals → validation (range/type checks).
AI analysis: model evaluates whether readings are normal vs. critical.
If normal: return status to patient; keep monitoring.
If critical: trigger alert to doctor.
Doctor dashboard: review live + historical data; respond with advice/actions.
b) Sequence diagram (who talks to whom)
Patient → Web UI → Flask backend → DB (login).
Patient → Web UI → Backend (send vitals) → validate → AI model (Random Forest) →
result → store in DB.
If critical, backend notifies doctor; doctor logs in, pulls patient history from
DB, reviews charts, and responds.
If safe, patient sees “All Normal” and continues routine updates.
c) Use-case diagram (roles & permissions)
Patient: Login/profile, enter vitals, view status/history.
System: Validate & store data, run AI, raise alerts.
Doctor: Login, analyze patient data, provide feedback/medical advice and emergency
guidance.
d) Algorithm explained — Random Forest (why it fits)
What it is: An ensemble of many decision trees; each tree votes, and the majority
vote becomes the prediction.
Why it’s used here:
Handles non-linear relations among vitals (e.g., HR × BP patterns).
Robust to noisy readings and outliers (common with manual/sensor data).
Offers good accuracy without heavy tuning; fast inference for real-time alerts.
How it works in your pipeline:
Input features: HR, systolic/diastolic BP, SpO₂, temperature (+ optional engineered
features like rate-of-change).
Preprocessing: Validation, scaling/cleaning if needed.
Model inference: Each tree classifies safe vs. critical; forest aggregates votes.
Decision: If critical, trigger alert; else log as normal.
Continuous learning (future): Retrain with new labeled data to reduce false
positives/negatives.
4) Results & Conclusion (what you can claim)
Results (from the report):
The system achieved >92% accuracy for anomaly detection using Random Forest,
balancing thresholds with ML predictions to cut false alarms.
Alert latency < 2.3 seconds, enabling near real-time notifications to
doctors/caregivers.
Conclusion (meaning & impact):
Moves from reactive to proactive healthcare by continuously analyzing vitals and
predicting risks before they become emergencies.
Lightweight Flask app makes it cost-effective, usable at home, clinics, or rural
centers—even without expensive IoT (sensors can be added later).
Role-based dashboards (patient/doctor) + instant alerts create a tight loop for
timely intervention, especially for elderly living alone.
Scalable & modular: Can integrate wearables, multilingual UI, voice assistants, and
cloud analytics in future iterations.
