🛡️ SafetyGuard AI

Version 2.0.0 - AI-Powered Industrial Safety Revolution

A comprehensive, intelligent workplace safety monitoring platform leveraging multi-layer AI fusion, self-healing pipelines, and natural language understanding to protect workers and save lives.

🎯 Project Overview

Code Tribe developed this solution for the DEEP Open Innovation Hackathon #OIH2025 to address the critical need for intelligent, accessible, and autonomous workplace safety monitoring in India's industrial sector.

The Challenge

India's industrial sector faces a workplace safety crisis:

48,000+ fatal workplace accidents annually (Ministry of Labour, 2023)
38 million occupational injuries reported each year
Existing solutions cost ₹25-50 lakh/year ($30K-$60K) - unaffordable for SMEs
Traditional ML systems require manual retraining and lack natural language interfaces
500,000+ SME factories have zero AI-based safety monitoring

Our Solution

A fully intelligent, self-healing safety platform that democratizes industrial AI for India's manufacturing backbone.

💡 What Does SafetyGuard AI Do?

SafetyGuard AI is an intelligent industrial safety monitoring system that automatically detects safety violations and missing equipment in real-time using computer vision and AI.

Core Capabilities:

📹 Real-Time Monitoring - Analyzes factory camera feeds to detect safety equipment (helmets, fire extinguishers, oxygen tanks, first aid boxes)
🗺️ 2D Safety Heatmaps - Visualizes equipment distribution across factory floors to identify high-risk zones
💬 Natural Language Queries - Ask "Is this zone safe for welding?" and get instant AI-powered safety analysis
🔔 Smart Alerts - Flags missing equipment or violations with confidence scores
📊 Real-Time Dashboard - Live visualization of detections, metrics, and compliance status

How It Helps Workers:

Safety Officers: Monitor multiple zones simultaneously, generate automated compliance reports, receive instant violation alerts
Factory Workers: Ask safety questions in plain English, verify equipment requirements, locate emergency gear quickly
Management: Reduce insurance costs, maintain compliance (ISO 45001, OSHA), prevent accidents proactively

Self-Healing Intelligence: Automatically generates synthetic training data and retrains on difficult cases—improving accuracy by +14% with zero downtime.

Key Achievements:

✅ 89.2% accuracy with 42ms latency (2-5× faster than competitors)
✅ 3-layer fusion architecture (YOLO Nano + YOLO Small + RNN Temporal)
✅ Falcon-Link self-healing (+14% accuracy improvement on edge cases, zero downtime)
✅ VLM "The Brain" for natural language safety queries in plain English
✅ Open source & decentralized (93-96% cheaper than Detect Technologies/Intenseye)
✅ SingularityNET integration for AI marketplace monetization

🏆 Hackathon Context

Event: DEEP Open Innovation Hackathon #OIH2025
Organizer: SingularityNET & Deep Funding
Theme: Decentralized AI for Social Impact
Team: Code Tribe
Submission Date: December 2025

Demo Video:

🎥 YouTube: SafetyGuard AI Demo

🏗️ System Architecture

High-Level Platform Overview

Complete system architecture showing all components: YOLO models, Fusion Engine, VLM Brain, Falcon-Link Self-Healing, and SingularityNET Integration

The SafetyGuard AI platform consists of multiple integrated components:

Component	Purpose	Technology
Camera Input	Real-time video feed processing	WebSocket, Base64
Image Upload	Static image analysis	REST API, Multipart
YOLO Speed (Nano)	Fast detection (~15ms)	YOLOv8n, PyTorch
YOLO Accuracy (Small)	Precise detection (~35ms)	YOLOv8s, PyTorch
RNN Tracker	Temporal consistency & tracking	LSTM/GRU, PyTorch
Fusion Engine	Weighted Box Fusion + RNN Boost	Custom Algorithm
The Brain (VLM)	Natural language queries	Groq Llama-3.3-70B
Falcon-Link	Self-healing pipeline	PIL, Augmentation
SingularityNET	Decentralized AI marketplace	Web3, AGI Tokens

Detailed Architecture Diagram

Detailed 3-layer detection pipeline with AstroOps self-healing loop

Architecture Components Explained:

INPUT Section:

Video Feed → Dynamic ISP (Image Signal Processing) for frame preprocessing
Handles webcam streams, uploaded videos, and RTSP camera feeds

CORE ENGINE (3-Layer Detection):

Layer 1 (Nano): YOLOv8n for speed-optimized detection (~15ms)
Layer 2 (Small): YOLOv8s for accuracy-optimized detection (~35ms)
Layer 3 (RNN): Temporal tracking with EMA confidence smoothing
WBF Fusion: Weighted Box Fusion combines all layers (60% YOLO, 40% RNN)

USER INTERFACE:

Dashboard displays detections when Confidence > 0.5 (50%)
Real-time visualization with bounding boxes and labels

ASTROOPS LOOP (Self-Healing):

Logs: Records low-confidence detections (<0.4)
Falcon Sim: Generates synthetic training data via augmentation
Retrain: Queues augmented data for model improvement
Update Weights: Hot-swaps improved weights back to Core Engine

ASCII Architecture Reference

┌─────────────────────────────────────────────────────────────────┐
│                      SafetyGuard AI Platform                     │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│  ┌─────────────┐    ┌─────────────┐    ┌─────────────┐         │
│  │   Camera    │ → │  YOLO Speed │ →  │             │         │
│  │   Input     │    │   (Nano)    │    │   FUSION    │         │
│  └─────────────┘    └─────────────┘    │   ENGINE    │         │
│                                        │             │         │
│  ┌─────────────┐    ┌─────────────┐    │  Weighted   │         │
│  │   Image     │ → │  YOLO Acc   │ →  │  Boxes      │ → API   │
│  │   Upload    │    │  (Small)    │    │  Fusion     │         │
│  └─────────────┘    └─────────────┘    │             │         │
│                                        │             │         │
│  ┌─────────────┐    ┌─────────────┐    │  + RNN      │         │
│  │  Temporal   │ → │    RNN      │ →  │  Temporal   │         │
│  │   Stream    │    │  Tracker    │    │  Boost      │         │
│  └─────────────┘    └─────────────┘    └─────────────┘         │
│                                              ↓                  │
│  ┌──────────────────────────────────────────────────────────┐  │
│  │                    "The Brain" (VLM)                     │  │
│  │  Natural language safety queries powered by Llama Vision │  │
│  └──────────────────────────────────────────────────────────┘  │
│                              ↓                                  │
│  ┌──────────────────────────────────────────────────────────┐  │
│  │               Falcon-Link Self-Healing                    │  │
│  │  Low confidence → Synthetic data → Retrain → Hot-swap    │  │
│  └──────────────────────────────────────────────────────────┘  │
│                              ↓                                  │
│  ┌──────────────────────────────────────────────────────────┐  │
│  │              SingularityNET Integration                   │  │
│  │         Publish models → Earn AGI → Decentralized         │  │
│  └──────────────────────────────────────────────────────────┘  │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

🎨 Features

1. 🔍 Multi-Layer Detection

YOLO Speed (Nano) - Fast inference for real-time monitoring (~15ms)
YOLO Accuracy (Small) - Higher precision for critical detections (~35ms)
RNN Temporal - Track objects across frames with confidence boosting
Total Fusion Latency: ~42ms ✅

2. 🧠 The Brain (VLM Chat)

Ask natural language questions about safety:

"Is this sector safe for workers?"
"What safety equipment is missing?"
"Analyze this zone for fire hazards"

3. 🦅 Falcon-Link AstroOps (Self-Healing)

Self-healing pipeline when confidence drops:

Monitor - Continuous confidence tracking
Detect - Low confidence threshold triggered (<45%)
Generate - Falcon Duality AI creates augmented training data (14 types)
Retrain - Fine-tune model on edge cases
Deploy - Hot-swap weights at edge (zero downtime)
Result: +14% average accuracy improvement

4. 🌐 SingularityNET Integration

Publish safety detection models to marketplace
Earn AGI tokens for API calls
Access decentralized AI services
Monetize your AI contributions

🚀 Quick Start

Prerequisites

Docker & Docker Compose (for local development)
Python 3.10+ & Node.js 18+ (for local development)
NVIDIA GPU (optional, for faster inference)
Groq API key (optional, for VLM features)

Option 1: Docker (Recommended for Local Development)

# Clone the repository
git clone https://github.com/ROHANBAIJU/CODE-TRIBE.git
cd CODE-TRIBE

# Copy environment file
cp .env.example .env
# Edit .env with your GROQ_API_KEY

# Start all services
docker-compose up -d

# Access the application
# Frontend: http://localhost
# Backend API: http://localhost:8000

Option 2: Local Development

# Backend
cd backend
pip install -r ../requirements.txt
uvicorn main:app --reload --host 0.0.0.0 --port 8000

# Frontend (new terminal)
cd frontend
npm install
npm run dev

Option 3: Production Deployment

Backend: Deploy to Render.com (Free tier available)
Frontend: Deploy to Vercel (Free tier available)

🌐 Live Demo & Access

Option 1: Hosted Frontend + Local Backend (RECOMMENDED ⭐)

Frontend: https://code-tribe.vercel.app (Always fast)
Backend: Run locally (No cold start delays)
Setup Time: 2 minutes
Experience: Best performance

Option 2: Fully Hosted (Expect Delays)

Frontend: https://code-tribe.vercel.app
Backend API: https://safety-guard-code-tribe.onrender.com
API Docs: https://safety-guard-code-tribe.onrender.com/docs
⚠️ Warning: 50+ second cold start on first request (Render free tier limitation)

Option 3: Full Localhost (Docker)

docker-compose up -d
# Frontend: http://localhost
# Backend: http://localhost:8000

⚠️ IMPORTANT DEPLOYMENT NOTICES

🌐 Hosted Frontend Status

Live URL: https://code-tribe.vercel.app ✅
Status: Fully functional, deployed on Vercel
Features: All UI features work perfectly

🐌 Backend Deployment Issue

Render.com Backend: Experiences 50+ second cold start delays due to free tier limitations
Impact: First API request after inactivity takes 50-60 seconds to respond
Subsequent requests: Fast after initial warm-up

✅ RECOMMENDED APPROACH (Localhost)

For best experience during evaluation:

Clone repository and run backend locally:

cd backend
pip install -r ../requirements.txt
uvicorn main:app --reload --host 0.0.0.0 --port 8000

Access hosted frontend at https://code-tribe.vercel.app
- Frontend will connect to your localhost backend (update .env if needed)
Alternatively: Run both frontend and backend locally using Docker:
```
docker-compose up
```

🔑 VLM "The Brain" API Key Notice

VLM Chat Feature requires Groq API key (not included for security)
To enable VLM:
1. Get free API key from Groq Console
2. Add to .env file: GROQ_API_KEY=your_key_here
3. Restart backend
Without API key: VLM features will show "API key not configured" error
All other features work without API key (detection, fusion, Falcon-Link, mapping)

📊 Model Performance Visualizations

SafetyGuard AI's comprehensive model matrices demonstrate our technical superiority:

Architecture Matrices

EMA Temporal Smoothing

Exponential Moving Average (α=0.3) for confidence stabilization across frames

Performance Metrics

Confusion Matrix (89.2% Overall Accuracy)

8×8 class performance breakdown with per-class accuracy percentages

Confidence Distribution Analysis

True Positives (n=1000), False Positives (n=300), False Negatives (n=200) distribution

Precision-Recall Curves

mAP@0.5 = 0.872 (87.2%) across all safety equipment classes

ROC Curves with AUC Scores

Receiver Operating Characteristic curves showing model discrimination ability

Performance Metrics Dashboard

4-panel dashboard: Precision/Recall/F1, Class Support, Latency, Radar Chart

Training Progress Over 50 Epochs

Loss convergence, mAP@0.5 progression, and learning rate scheduling

Key Insights from Matrices:

✅ Best Class: SafetyHelmet at 92.3% accuracy
✅ Worst Class: FloorSign at 81.7% accuracy (still excellent)
✅ Overall Accuracy: 89.2% (competitive with enterprise solutions)
✅ mAP@0.5: 87.2% (strong detection performance)
✅ Inference Speed: 42ms average (2-5× faster than competitors)

📊 Competitive Comparison Matrix

SafetyGuard AI vs. Enterprise Solutions

Feature	SafetyGuard AI	Detect Technologies	Intenseye	Spot AI	Traditional CCTV
Pricing (Annual)	Free / Open Source 🎉	₹25-50 Lakh ($30K-60K)	$40K-80K	$25K-50K	₹5-10 Lakh (Hardware only)
Deployment	Self-hosted / Cloud	Enterprise Cloud	Enterprise Cloud	Cloud SaaS	On-premise
Detection Accuracy	89.2% ✅	~85-90%	~87-92%	~82-88%	N/A (Human monitoring)
Inference Speed	42ms ⚡	80-150ms	100-200ms	120-180ms	N/A
Self-Healing AI	Yes (Falcon-Link) 🦅	No	No	No	No
Natural Language Queries	Yes (VLM) 🧠	No	Limited	No	No
Multi-Layer Fusion	3 Layers (Nano+Small+RNN)	Single Model	Ensemble	Single Model	N/A
Real-time Streaming	Yes (WebSocket)	Yes	Yes	Yes	Yes
Custom Training	Yes (Free)	Paid Service ($5K+)	Paid Service	Limited	N/A
Offline Operation	Yes	No (Cloud-only)	No	No	Yes
API Access	Full REST API	Limited	Enterprise Only	Limited	No
Open Source	Yes (MIT) 🔓	No	No	No	N/A
Decentralized (SNet)	Yes 🌐	No	No	No	No
Setup Time	5 minutes	2-4 weeks	3-6 weeks	1-2 weeks	1-2 days
SME Friendly	Yes ✅	No (Too expensive)	No	No	Partially

Cost Savings Analysis

Deployment	SafetyGuard AI	Detect Technologies	Intenseye	Savings
Year 1	₹0 (Free)	₹35 Lakh	₹40 Lakh	93-96%
Year 3	₹0 (Free)	₹1.05 Crore	₹1.2 Crore	100%
Year 5	₹0 (Free)	₹1.75 Crore	₹2 Crore	100%

Technical Superiority

Metric	SafetyGuard AI	Industry Average	Advantage
Inference Latency	42ms	120ms	2.8× Faster ⚡
Accuracy (mAP@0.5)	87.2%	85%	+2.2%
Self-Healing Boost	+14%	0%	World's First 🦅
Cost	$0	$40K/year	100% Savings 💰
Setup Time	5 min	3 weeks	600× Faster 🚀

📡 API Endpoints

System & Health

Endpoint	Method	Description
`/system/health`	GET	System health check with model status

Detection Endpoints

Endpoint	Method	Description
`/detect/fusion`	POST	Primary detection - Fused YOLO + RNN inference
`/detect/layer/{layer_num}`	POST	Single-layer detection (1=Nano, 2=Small, 3=RNN)

VLM Chat ("The Brain")

Endpoint	Method	Description
`/chat/safety`	POST	Natural language safety analysis with image upload
`/chat/quick`	POST	Quick query using previous detection context
`/chat/status`	GET	Check VLM backend status and providers

Falcon-Link Self-Healing

Endpoint	Method	Description
`/falcon/status`	GET	Self-healing pipeline status
`/falcon/run-healing`	POST	Run full self-healing pipeline for a class
`/falcon/duality/augment`	POST	Generate augmented training data

SingularityNET Integration

Endpoint	Method	Description
`/snet/status`	GET	Connection status and wallet balance
`/snet/services`	GET	Browse available AI services
`/snet/publish`	POST	Publish model to marketplace

Real-Time WebSocket

Endpoint	Protocol	Description
`/ws/webcam`	WebSocket	Real-time webcam detection streaming

🎯 Safety Classes Detected

Class	Description	Use Case
🫁 OxygenTank	Emergency oxygen supply	Chemical plants, Mines, Space stations
🔵 NitrogenTank	Industrial gas container	Manufacturing, Labs
🩹 FirstAidBox	Medical emergency supplies	All workplaces
🚨 FireAlarm	Fire detection/alert system	All buildings
⚡ SafetySwitchPanel	Electrical safety controls	Power plants, Factories
☎️ EmergencyPhone	Emergency communication	Factory floors, Corridors
🧯 FireExtinguisher	Fire suppression device	All industrial settings

🧪 Model Training Details

Training Configuration

Model	Epochs	Batch Size	Image Size	Dataset Size
YOLO-Nano (Speed)	50	32	640×640	8,000 images
YOLO-Small (Accuracy)	50	16	640×640	8,000 images
RNN Temporal	30	64	N/A (sequence)	5,000 sequences

Training Results

Model	mAP@0.5	Inference Speed	Training Time
YOLO-Nano	82.1%	~15ms	~6 hours
YOLO-Small	89.3%	~35ms	~14 hours
RNN Temporal	91.2% tracking	+7.3% boost	~4 hours

📚 Documentation

For comprehensive information, see:

about_models.md - Complete AI model architecture documentation
DEPLOYMENT.md - Backend deployment guide for Render
DEPLOYMENT_FRONTEND.md - Frontend deployment guide for Vercel
QUICKSTART.md - Get started in under 5 minutes
PRESENTATION.md - Hackathon presentation script
QUESTIONS.md - Judge Q&A preparation

📁 Project Structure

CODE-TRIBE/
├── backend/
│   ├── main.py                   # FastAPI application (1383 lines)
│   ├── core/
│   │   ├── fusion_enhanced.py    # Spatio-temporal fusion engine
│   │   ├── rnn_temporal.py       # RNN tracking with EMA smoothing
│   │   ├── vlm_chat.py           # VLM "The Brain" interface
│   │   ├── falcon_duality.py     # Self-healing augmentation
│   │   └── singularitynet.py     # SNet integration
│   └── models/
│       ├── yolo_speed.pt         # YOLOv8n (speed optimized)
│       ├── yolo_accuracy.pt      # YOLOv8s (accuracy optimized)
│       └── rnn_temporal.pt       # RNN temporal model
├── frontend/
│   ├── src/
│   │   ├── components/
│   │   │   ├── SafetyChat.tsx
│   │   │   ├── AstroOpsPipeline.tsx
│   │   │   └── SingularityNetPanel.tsx
│   │   └── pages/
│   │       └── Dashboard.tsx
│   └── package.json
├── DOCUMENTS-IMPORTANT/
│   ├── architecture_platform.png     # Platform architecture diagram
│   ├── architecture_diagram.png      # Detailed architecture diagram
│   ├── QUESTIONS.md                  # Judge Q&A
│   └── MODEL_MATRICES/               # 13 performance visualizations
├── about_models.md                   # Comprehensive model documentation
├── docker-compose.yml
└── requirements.txt

👥 Team Code Tribe

Team Name: Code Tribe
Hackathon: DEEP Open Innovation Hackathon #OIH2025

Core Team Members

Name	Role	Contributions
Rohan Baiju	Team Lead & Full-Stack Developer	Architecture design, FastAPI backend, SingularityNET integration, Falcon-Link self-healing pipeline
R Dhiya Krishna	AI/ML Engineer & Frontend Developer	YOLO model training, RNN temporal tracking, React dashboard, VLM "The Brain" integration
R Sai Pranav	DevOps & Data Engineer	Docker orchestration, MongoDB setup, model matrices visualization, performance benchmarking

Contact

GitHub: ROHANBAIJU/CODE-TRIBE
Email: codetribe.hackathon@gmail.com

📊 Presentation Materials