Upload 3 files

README.md

@@ -1,12 +1,94 @@
----
-title: Farm Human Recognition
-emoji: 🌖
-colorFrom: red
-colorTo: green
-sdk: gradio
-sdk_version: 5.49.0
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+title: Farm Human Recognition API
+emoji: 👥
+colorFrom: purple
+colorTo: pink
+sdk: gradio
+sdk_version: 4.28.3
+app_file: app.py
+pinned: false
+license: apache-2.0
+short_description: Farm worker detection and safety analysis
+---
+
+# 👥 Farm Human Recognition API
+
+Advanced farm worker detection and analysis using YOLOS models for workplace safety and productivity assessment.
+
+## 🎯 Capabilities
+- **Worker Detection**: Precise identification of farm workers in images
+- **Safety Analysis**: Workplace safety scoring and risk assessment
+- **Activity Recognition**: Classification of farm work activities
+- **Productivity Metrics**: Performance analysis and recommendations
+
+## 🤖 Models
+- **YOLOS Tiny**: Fastest processing for real-time applications
+- **YOLOS Small**: Balanced accuracy and speed (recommended)
+- **YOLOS Base**: Highest accuracy for detailed analysis
+
+## 📡 API Usage
+
+### Python
+```python
+import requests
+import base64
+
+def detect_farm_workers(image_path, model="yolos_small"):
+    with open(image_path, "rb") as f:
+        image_b64 = base64.b64encode(f.read()).decode()
+    
+    response = requests.post(
+        "https://YOUR-USERNAME-farm-human-recognition.hf.space/api/predict",
+        json={"data": [image_b64, model]}
+    )
+    return response.json()
+
+result = detect_farm_workers("farm_workers.jpg")
+print(result)
+```
+
+## 📊 Response Format
+```json
+{
+  "humans_detected": 3,
+  "detections": [
+    {
+      "class": "person",
+      "confidence": 0.92,
+      "bbox": [120, 45, 180, 200],
+      "activity": "ground_work",
+      "area": 7200
+    }
+  ],
+  "safety_analysis": {
+    "status": "safe",
+    "score": 0.85,
+    "concerns": [],
+    "workers_detected": 3
+  },
+  "productivity_metrics": {
+    "active_workers": 3,
+    "productivity_score": 0.75,
+    "activity_breakdown": {
+      "ground_work": 2,
+      "operating_equipment": 1
+    },
+    "recommendations": [
+      "Consider team coordination for efficiency"
+    ]
+  },
+  "processing_time": 1.5
+}
+```
+
+## 🏭 Activity Classification
+- **ground_work**: Field operations, planting, harvesting
+- **close_work**: Inspection, detailed tasks, quality control
+- **operating_equipment**: Tractor/machinery operation
+- **general_activity**: Walking, standing, general movement
+
+## 🛡️ Safety Features
+- Automatic detection of high worker density
+- Equipment operation safety analysis
+- Workplace hazard identification
+- Safety score calculation (0-1)

app.py

@@ -0,0 +1,364 @@
+"""
+Farm Human Recognition API - Gradio Interface
+YOLO and pose estimation models for farm worker detection
+"""
+
+import gradio as gr
+import torch
+import cv2
+import numpy as np
+from PIL import Image
+import json
+import base64
+import io
+import time
+from typing import List, Dict, Any
+
+# Import models
+try:
+    from transformers import YolosImageProcessor, YolosForObjectDetection
+    from transformers import AutoImageProcessor, AutoModelForObjectDetection
+    MODELS_AVAILABLE = True
+except ImportError:
+    MODELS_AVAILABLE = False
+
+class HumanRecognitionAPI:
+    def __init__(self):
+        self.models = {}
+        self.processors = {}
+        self.model_configs = {
+            "yolos_tiny": "hustvl/yolos-tiny",
+            "yolos_small": "hustvl/yolos-small",
+            "yolos_base": "hustvl/yolos-base"
+        }
+        
+        # Human activity classes relevant to farming
+        self.farm_activities = {
+            "harvesting": ["picking", "collecting", "gathering", "harvesting"],
+            "planting": ["sowing", "planting", "seeding"],
+            "maintenance": ["pruning", "watering", "fertilizing", "weeding"],
+            "inspection": ["examining", "checking", "monitoring", "inspecting"],
+            "operation": ["driving", "operating", "machinery", "equipment"],
+            "general": ["working", "standing", "walking", "person"]
+        }
+        
+        if MODELS_AVAILABLE:
+            self.load_models()
+    
+    def load_models(self):
+        """Load human detection models"""
+        for model_key, model_name in self.model_configs.items():
+            try:
+                print(f"Loading {model_name}...")
+                processor = YolosImageProcessor.from_pretrained(model_name)
+                model = YolosForObjectDetection.from_pretrained(model_name)
+                
+                self.processors[model_key] = processor
+                self.models[model_key] = model
+                print(f"✅ {model_name} loaded successfully")
+            except Exception as e:
+                print(f"❌ Failed to load {model_name}: {e}")
+    
+    def detect_humans(self, image: Image.Image, model_key: str = "yolos_small") -> Dict[str, Any]:
+        """Detect humans and analyze farm activities"""
+        if not MODELS_AVAILABLE or model_key not in self.models:
+            return {"error": "Model not available"}
+        
+        start_time = time.time()
+        
+        try:
+            # Preprocess image
+            processor = self.processors[model_key]
+            model = self.models[model_key]
+            
+            inputs = processor(images=image, return_tensors="pt")
+            
+            # Run inference
+            with torch.no_grad():
+                outputs = model(**inputs)
+            
+            # Post-process results
+            target_sizes = torch.tensor([image.size[::-1]])
+            results = processor.post_process_object_detection(
+                outputs, threshold=0.5, target_sizes=target_sizes
+            )[0]
+            
+            # Filter for human detections
+            human_detections = []
+            for score, label, box in zip(results["scores"], results["labels"], results["boxes"]):
+                class_name = model.config.id2label[label.item()].lower()
+                if "person" in class_name and score > 0.5:
+                    human_detections.append({
+                        "class": "person",
+                        "confidence": float(score),
+                        "bbox": [float(x) for x in box],
+                        "area": float((box[2] - box[0]) * (box[3] - box[1])),
+                        "activity": self.infer_activity(box, image.size)
+                    })
+            
+            # Analyze safety and productivity
+            safety_analysis = self.analyze_safety(human_detections, image.size)
+            productivity_metrics = self.calculate_productivity_metrics(human_detections)
+            
+            processing_time = time.time() - start_time
+            
+            return {
+                "humans_detected": len(human_detections),
+                "detections": human_detections,
+                "safety_analysis": safety_analysis,
+                "productivity_metrics": productivity_metrics,
+                "processing_time": round(processing_time, 2),
+                "model_used": model_key
+            }
+            
+        except Exception as e:
+            return {"error": str(e)}
+    
+    def infer_activity(self, bbox: List[float], image_size: tuple) -> str:
+        """Infer farm activity from bounding box characteristics"""
+        x1, y1, x2, y2 = bbox
+        width = x2 - x1
+        height = y2 - y1
+        
+        # Simple activity inference based on pose characteristics
+        aspect_ratio = width / height
+        relative_size = (width * height) / (image_size[0] * image_size[1])
+        
+        if aspect_ratio > 1.2:  # Wide bounding box
+            return "operating_equipment"
+        elif relative_size > 0.1:  # Large person in frame
+            return "close_work"
+        elif y2 > image_size[1] * 0.8:  # Person near bottom
+            return "ground_work"
+        else:
+            return "general_activity"
+    
+    def analyze_safety(self, detections: List[Dict], image_size: tuple) -> Dict[str, Any]:
+        """Analyze workplace safety factors"""
+        if not detections:
+            return {"status": "no_workers", "score": 1.0}
+        
+        safety_score = 1.0
+        concerns = []
+        
+        # Check worker density
+        workers_per_area = len(detections) / (image_size[0] * image_size[1] / 1000000)  # per megapixel
+        if workers_per_area > 5:
+            safety_score -= 0.2
+            concerns.append("High worker density - ensure adequate spacing")
+        
+        # Check for workers near equipment (simplified check)
+        for detection in detections:
+            if detection["activity"] == "operating_equipment":
+                # Check if other workers are nearby
+                nearby_workers = sum(1 for d in detections 
+                                   if d != detection and self.calculate_distance(d["bbox"], detection["bbox"]) < 100)
+                if nearby_workers > 0:
+                    safety_score -= 0.3
+                    concerns.append("Workers detected near operating equipment")
+        
+        return {
+            "status": "safe" if safety_score > 0.7 else "caution" if safety_score > 0.4 else "unsafe",
+            "score": max(0.0, safety_score),
+            "concerns": concerns,
+            "workers_detected": len(detections)
+        }
+    
+    def calculate_distance(self, bbox1: List[float], bbox2: List[float]) -> float:
+        """Calculate distance between bounding box centers"""
+        center1 = [(bbox1[0] + bbox1[2]) / 2, (bbox1[1] + bbox1[3]) / 2]
+        center2 = [(bbox2[0] + bbox2[2]) / 2, (bbox2[1] + bbox2[3]) / 2]
+        return ((center1[0] - center2[0]) ** 2 + (center1[1] - center2[1]) ** 2) ** 0.5
+    
+    def calculate_productivity_metrics(self, detections: List[Dict]) -> Dict[str, Any]:
+        """Calculate farm productivity metrics"""
+        if not detections:
+            return {"active_workers": 0, "productivity_score": 0.0}
+        
+        activity_counts = {}
+        for detection in detections:
+            activity = detection["activity"]
+            activity_counts[activity] = activity_counts.get(activity, 0) + 1
+        
+        # Simple productivity scoring
+        productive_activities = ["close_work", "ground_work", "operating_equipment"]
+        productive_workers = sum(activity_counts.get(activity, 0) for activity in productive_activities)
+        productivity_score = productive_workers / len(detections) if detections else 0
+        
+        return {
+            "active_workers": len(detections),
+            "productivity_score": round(productivity_score, 2),
+            "activity_breakdown": activity_counts,
+            "recommendations": self.generate_productivity_recommendations(activity_counts)
+        }
+    
+    def generate_productivity_recommendations(self, activity_counts: Dict[str, int]) -> List[str]:
+        """Generate productivity improvement recommendations"""
+        recommendations = []
+        total_workers = sum(activity_counts.values())
+        
+        if activity_counts.get("general_activity", 0) > total_workers * 0.3:
+            recommendations.append("Consider assigning specific tasks to idle workers")
+        
+        if activity_counts.get("operating_equipment", 0) > 1:
+            recommendations.append("Multiple equipment operators detected - ensure coordination")
+        
+        if total_workers > 10:
+            recommendations.append("Large workforce detected - consider team organization")
+        
+        return recommendations[:3]  # Limit to 3 recommendations
+    
+    def draw_detections(self, image: Image.Image, detections: List[Dict]) -> Image.Image:
+        """Draw bounding boxes and labels on image"""
+        img_array = np.array(image)
+        
+        for detection in detections:
+            bbox = detection["bbox"]
+            x1, y1, x2, y2 = [int(coord) for coord in bbox]
+            
+            # Draw bounding box
+            cv2.rectangle(img_array, (x1, y1), (x2, y2), (0, 255, 0), 2)
+            
+            # Draw label
+            label = f"Worker {detection['confidence']:.2f}"
+            cv2.putText(img_array, label, (x1, y1-10), 
+                       cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
+        
+        return Image.fromarray(img_array)
+
+# Initialize API
+api = HumanRecognitionAPI()
+
+def predict_humans(image, model_choice):
+    """Gradio prediction function"""
+    if image is None:
+        return None, "Please upload an image"
+    
+    # Convert to PIL Image
+    if isinstance(image, np.ndarray):
+        image = Image.fromarray(image)
+    
+    # Run human detection
+    results = api.detect_humans(image, model_choice)
+    
+    if "error" in results:
+        return None, f"Error: {results['error']}"
+    
+    # Create visualization
+    annotated_image = api.draw_detections(image, results["detections"])
+    
+    # Format results text
+    safety = results["safety_analysis"]
+    productivity = results["productivity_metrics"]
+    
+    safety_emoji = "🟢" if safety["status"] == "safe" else "🟡" if safety["status"] == "caution" else "🔴"
+    
+    results_text = f"""
+👥 **Farm Worker Analysis**
+
+{safety_emoji} **Safety Status**: {safety['status'].title()} (Score: {safety['score']:.1%})
+👷 **Workers Detected**: {results['humans_detected']}
+📊 **Productivity Score**: {productivity['productivity_score']:.1%}
+
+**🛡️ Safety Analysis**:
+"""
+    
+    if safety["concerns"]:
+        for concern in safety["concerns"]:
+            results_text += f"\n⚠️ {concern}"
+    else:
+        results_text += "\n✅ No immediate safety concerns detected"
+    
+    results_text += f"\n\n**📈 Productivity Metrics**:"
+    if productivity["activity_breakdown"]:
+        for activity, count in productivity["activity_breakdown"].items():
+            results_text += f"\n• {activity.replace('_', ' ').title()}: {count} workers"
+    
+    if productivity["recommendations"]:
+        results_text += f"\n\n**💡 Recommendations**:"
+        for rec in productivity["recommendations"]:
+            results_text += f"\n• {rec}"
+    
+    return annotated_image, results_text
+
+# Gradio Interface
+with gr.Blocks(title="👥 Farm Human Recognition API") as app:
+    gr.Markdown("# 👥 Farm Human Recognition API")
+    gr.Markdown("AI-powered farm worker detection, safety analysis, and productivity assessment")
+    
+    with gr.Tab("👷 Worker Detection"):
+        with gr.Row():
+            with gr.Column():
+                image_input = gr.Image(type="pil", label="Upload Farm Image")
+                model_choice = gr.Dropdown(
+                    choices=["yolos_tiny", "yolos_small", "yolos_base"],
+                    value="yolos_small",
+                    label="Select Model"
+                )
+                detect_btn = gr.Button("🔍 Detect Workers", variant="primary")
+            
+            with gr.Column():
+                output_image = gr.Image(label="Worker Detection Results")
+                results_text = gr.Textbox(label="Analysis Results", lines=20)
+        
+        detect_btn.click(
+            predict_humans,
+            inputs=[image_input, model_choice],
+            outputs=[output_image, results_text]
+        )
+    
+    with gr.Tab("📡 API Documentation"):
+        gr.Markdown("""
+## 🚀 API Endpoint
+
+**POST** `/api/predict`
+
+### Request Format
+```json
+{
+  "data": ["<base64_image>", "<model_choice>"]
+}
+```
+
+### Model Options
+- **yolos_tiny**: Fastest processing, basic accuracy
+- **yolos_small**: Balanced performance (recommended)
+- **yolos_base**: Highest accuracy, slower processing
+
+### Response Format
+```json
+{
+  "humans_detected": 3,
+  "detections": [
+    {
+      "class": "person",
+      "confidence": 0.92,
+      "bbox": [120, 45, 180, 200],
+      "activity": "ground_work"
+    }
+  ],
+  "safety_analysis": {
+    "status": "safe",
+    "score": 0.85,
+    "concerns": []
+  },
+  "productivity_metrics": {
+    "active_workers": 3,
+    "productivity_score": 0.75,
+    "activity_breakdown": {
+      "ground_work": 2,
+      "operating_equipment": 1
+    }
+  }
+}
+```
+
+### Activity Types
+- **ground_work**: Workers performing field operations
+- **close_work**: Detailed inspection or harvesting
+- **operating_equipment**: Machinery operation
+- **general_activity**: General farm activities
+        """)
+
+if __name__ == "__main__":
+    app.launch()

requirements.txt

@@ -0,0 +1,8 @@
+torch>=2.0.0
+torchvision>=0.15.0
+transformers>=4.30.0
+gradio>=4.28.3
+Pillow>=9.0.0
+opencv-python>=4.8.0
+numpy>=1.21.0
+huggingface-hub>=0.15.0