---1

app.py

@@ -18,132 +18,89 @@ st.set_page_config(
     layout="wide"
 )
 
-class BehaviorDetector(nn.Module):
-    def __init__(self, num_classes):
-        super(BehaviorDetector, self).__init__()
-        # Use EfficientNet as base model (better performance than ResNet)
-        self.base_model = models.efficientnet_b0(pretrained=True)
-        # Replace classifier
-        num_features = self.base_model.classifier[1].in_features
-        self.base_model.classifier = nn.Sequential(
-            nn.Dropout(p=0.2),
-            nn.Linear(num_features, num_classes)
-        )
-        
-    def forward(self, x):
-        return torch.sigmoid(self.base_model(x))
-
 class DogBehaviorAnalyzer:
-    def __init__(self, model_path=None):
-        self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
-        
-        # Initialize YOLO model for dog detection (optional)
-        try:
-            self.yolo_model = YOLO(model_path) if model_path else None
-        except Exception as e:
-            st.warning("YOLO model not found. Running without dog detection.")
-            self.yolo_model = None
-        
-        # Initialize behavior classifier
-        self.num_behaviors = 5
-        try:
-            self.behavior_model = BehaviorDetector(self.num_behaviors).to(self.device)
-        except Exception as e:
-            st.warning("Error loading behavior model. Using default classifier.")
-            self.behavior_model = models.resnet18(pretrained=True)
-            num_features = self.behavior_model.fc.in_features
-            self.behavior_model.fc = nn.Linear(num_features, self.num_behaviors)
-            self.behavior_model = self.behavior_model.to(self.device)
-        
-        self.behavior_model.eval()
-        
-        # Define sophisticated transforms
-        self.transform = transforms.Compose([
-            transforms.Resize((224, 224)),
-            transforms.ToTensor(),
-            transforms.Normalize(mean=[0.485, 0.456, 0.406],
-                              std=[0.229, 0.224, 0.225]),
-            transforms.RandomHorizontalFlip(p=0.3),
-            transforms.ColorJitter(brightness=0.2, contrast=0.2)
-        ])
-        
-        # Behavior definitions with confidence thresholds
+    def __init__(self):
         self.behaviors = {
-            'tail_wagging': {'threshold': 0.75, 'description': 'Your dog is displaying happiness and excitement!'},
-            'barking': {'threshold': 0.8, 'description': 'Your dog is trying to communicate or alert you.'},
-            'ears_perked': {'threshold': 0.7, 'description': 'Your dog is alert and interested in something.'},
-            'lying_down': {'threshold': 0.85, 'description': 'Your dog is relaxed and comfortable.'},
-            'jumping': {'threshold': 0.8, 'description': 'Your dog is energetic and playful!'}
+            'tail_wagging': {'threshold': 0.6, 'description': 'Your dog is displaying happiness and excitement!'},
+            'movement': {'threshold': 0.5, 'description': 'Your dog is active and moving around.'},
+            'stationary': {'threshold': 0.7, 'description': 'Your dog is calm and still.'},
+            'high_activity': {'threshold': 0.65, 'description': 'Your dog is very energetic!'}
         }
         
-        # Temporal smoothing using sliding window
-        self.behavior_history = {behavior: deque(maxlen=5) for behavior in self.behaviors.keys()}
-        
-    def preprocess_frame(self, frame):
-        """Advanced frame preprocessing"""
-        # Convert BGR to RGB
-        rgb_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+        # Motion detection parameters
+        self.history = []
+        self.max_history = 10
+        self.prev_frame = None
         
-        # Apply adaptive histogram equalization
-        lab = cv2.cvtColor(rgb_frame, cv2.COLOR_RGB2LAB)
-        l, a, b = cv2.split(lab)
-        clahe = cv2.createCLAHE(clipLimit=3.0, tileGridSize=(8,8))
-        cl = clahe.apply(l)
-        enhanced = cv2.merge((cl,a,b))
-        enhanced = cv2.cvtColor(enhanced, cv2.COLOR_LAB2RGB)
+    def detect_motion(self, frame):
+        """Detect motion in frame"""
+        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+        gray = cv2.GaussianBlur(gray, (21, 21), 0)
         
-        return Image.fromarray(enhanced)
-
-    def detect_dog(self, frame):
-        """Detect dog in frame using YOLO"""
-        if self.yolo_model is None:
-            return True  # Skip detection if no model
+        if self.prev_frame is None:
+            self.prev_frame = gray
+            return 0.0
+            
+        frame_delta = cv2.absdiff(self.prev_frame, gray)
+        thresh = cv2.threshold(frame_delta, 25, 255, cv2.THRESH_BINARY)[1]
+        thresh = cv2.dilate(thresh, None, iterations=2)
+        
+        motion_score = np.sum(thresh > 0) / thresh.size
+        self.prev_frame = gray
+        
+        return motion_score
+        
+    def detect_color_changes(self, frame):
+        """Detect significant color changes that might indicate tail wagging"""
+        hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
+        lower = np.array([0, 0, 0])
+        upper = np.array([180, 255, 255])
+        mask = cv2.inRange(hsv, lower, upper)
+        
+        if len(self.history) > 0:
+            prev_mask = self.history[-1]
+            diff = cv2.absdiff(mask, prev_mask)
+            change_score = np.sum(diff > 0) / diff.size
+        else:
+            change_score = 0.0
             
-        results = self.yolo_model(frame)
-        return len(results) > 0 and any(result.boxes for result in results)
+        self.history.append(mask)
+        if len(self.history) > self.max_history:
+            self.history.pop(0)
+            
+        return change_score
 
     def analyze_frame(self, frame):
-        """Analyze frame with temporal smoothing and confidence thresholds"""
-        # First detect if dog is present
-        if not self.detect_dog(frame):
-            return []
-            
-        # Preprocess frame
-        processed_frame = self.preprocess_frame(frame)
-        input_tensor = self.transform(processed_frame).unsqueeze(0).to(self.device)
-        
-        with torch.no_grad():
-            predictions = self.behavior_model(input_tensor).squeeze().cpu().numpy()
+        """Analyze frame using motion and color change detection"""
+        motion_score = self.detect_motion(frame)
+        color_change_score = self.detect_color_changes(frame)
         
-        # Update behavior history
-        for behavior, pred in zip(self.behaviors.keys(), predictions):
-            self.behavior_history[behavior].append(pred)
-        
-        # Apply temporal smoothing and thresholds
         detected_behaviors = []
-        for behavior, history in self.behavior_history.items():
-            if len(history) > 0:
-                avg_conf = sum(history) / len(history)
-                if avg_conf > self.behaviors[behavior]['threshold']:
-                    detected_behaviors.append((behavior, avg_conf))
         
+        # Detect tail wagging based on localized color changes
+        if color_change_score > self.behaviors['tail_wagging']['threshold']:
+            detected_behaviors.append(('tail_wagging', color_change_score))
+            
+        # Detect movement
+        if motion_score > self.behaviors['movement']['threshold']:
+            detected_behaviors.append(('movement', motion_score))
+            
+        # Detect stationary behavior
+        if motion_score < self.behaviors['stationary']['threshold']:
+            detected_behaviors.append(('stationary', 1.0 - motion_score))
+            
+        # Detect high activity
+        if motion_score > self.behaviors['high_activity']['threshold']:
+            detected_behaviors.append(('high_activity', motion_score))
+            
         return detected_behaviors
 
 def main():
-    st.title("🐕 Advanced Dog Language Understanding")
-    st.write("Upload a video of your dog for detailed behavior analysis!")
+    st.title("🐕 Dog Behavior Analyzer")
+    st.write("Upload a video of your dog for behavior analysis!")
 
     analyzer = DogBehaviorAnalyzer()
     
-    # Add model confidence control
-    confidence_threshold = st.sidebar.slider(
-        "Detection Confidence Threshold",
-        min_value=0.5,
-        max_value=0.95,
-        value=0.7,
-        step=0.05
-    )
-
     video_file = st.file_uploader("Upload Video", type=['mp4', 'avi', 'mov'])
 
     if video_file is not None:
@@ -179,38 +136,36 @@ def main():
             progress = frame_count / total_frames
             progress_bar.progress(progress)
             
-            # Update video preview with annotations
-            annotated_frame = frame.copy()
+            # Analyze frame
             detected_behaviors = analyzer.analyze_frame(frame)
             
             # Draw behavior labels on frame
             y_pos = 30
             for behavior, conf in detected_behaviors:
-                if conf > confidence_threshold:
-                    behavior_counts[behavior] += 1
-                    confidence_history[behavior].append(conf)
-                    cv2.putText(annotated_frame, 
-                              f"{behavior.replace('_', ' ').title()}: {conf:.2f}",
-                              (10, y_pos), 
-                              cv2.FONT_HERSHEY_SIMPLEX, 
-                              0.7, 
-                              (0, 255, 0), 
-                              2)
-                    y_pos += 30
+                behavior_counts[behavior] += 1
+                confidence_history[behavior].append(conf)
+                cv2.putText(frame, 
+                          f"{behavior.replace('_', ' ').title()}: {conf:.2f}",
+                          (10, y_pos), 
+                          cv2.FONT_HERSHEY_SIMPLEX, 
+                          0.7, 
+                          (0, 255, 0), 
+                          2)
+                y_pos += 30
             
             video_placeholder.image(
-                cv2.cvtColor(annotated_frame, cv2.COLOR_BGR2RGB),
+                cv2.cvtColor(frame, cv2.COLOR_BGR2RGB),
                 channels="RGB",
                 use_container_width=True
             )
             
-            # Update analysis display with confidence scores
+            # Update analysis display
             analysis_text = "Detected Behaviors:\n\n"
             for behavior, count in behavior_counts.items():
                 if count > 0:
                     avg_conf = sum(confidence_history[behavior]) / len(confidence_history[behavior])
                     analysis_text += f"• {behavior.replace('_', ' ').title()}:\n"
-                    analysis_text += f"  Count: {count} | Avg Confidence: {avg_conf:.2f}\n"
+                    analysis_text += f"  Count: {count} | Confidence: {avg_conf:.2f}\n"
                     analysis_text += f"  {analyzer.behaviors[behavior]['description']}\n\n"
             
             analysis_placeholder.text_area(
@@ -227,11 +182,11 @@ def main():
         # Final analysis
         st.subheader("Comprehensive Analysis")
         
-        # Create detailed metrics
+        # Create metrics
         col1, col2, col3 = st.columns(3)
         
         with col1:
-            most_common = max(behavior_counts.items(), key=lambda x: x[1])[0]
+            most_common = max(behavior_counts.items(), key=lambda x: x[1])[0] if any(behavior_counts.values()) else "None"
             st.metric("Primary Behavior", most_common.replace('_', ' ').title())
             
         with col2:
@@ -239,32 +194,31 @@ def main():
             st.metric("Total Behaviors", total_behaviors)
             
         with col3:
-            avg_confidence = np.mean([np.mean(conf) for conf in confidence_history.values() if conf])
+            valid_confidences = [conf for confs in confidence_history.values() if confs for conf in confs]
+            avg_confidence = np.mean(valid_confidences) if valid_confidences else 0
             st.metric("Average Confidence", f"{avg_confidence:.2%}")
         
         # Behavior distribution chart
-        st.subheader("Behavior Distribution")
-        behavior_data = {k.replace('_', ' ').title(): v for k, v in behavior_counts.items() if v > 0}
-        st.bar_chart(behavior_data)
-        
-        # Recommendations based on analysis
-        st.subheader("Personalized Recommendations")
-        if total_behaviors > 0:
-            st.write("Based on the detailed analysis, here are tailored recommendations:")
+        if any(behavior_counts.values()):
+            st.subheader("Behavior Distribution")
+            behavior_data = {k.replace('_', ' ').title(): v for k, v in behavior_counts.items() if v > 0}
+            st.bar_chart(behavior_data)
             
-            # Generate specific recommendations based on detected behaviors
+            # Recommendations
+            st.subheader("Behavior Insights")
             recommendations = []
+            
             if behavior_counts['tail_wagging'] > total_behaviors * 0.3:
-                recommendations.append("• Your dog shows frequent happiness - great time for training!")
-            if behavior_counts['barking'] > total_behaviors * 0.2:
-                recommendations.append("• Consider quiet command training to manage barking")
-            if behavior_counts['jumping'] > total_behaviors * 0.25:
-                recommendations.append("• Focus on calm behavior reinforcement")
+                recommendations.append("• Your dog shows frequent happiness - great time for positive reinforcement!")
+            if behavior_counts['high_activity'] > total_behaviors * 0.4:
+                recommendations.append("• High energy levels detected - consider more physical exercise")
+            if behavior_counts['stationary'] > total_behaviors * 0.5:
+                recommendations.append("• Your dog appears calm - good for training sessions")
                 
             for rec in recommendations:
                 st.write(rec)
         else:
-            st.write("No clear behaviors detected. Try recording with better lighting and closer camera angle.")
+            st.write("Upload a video to see behavior analysis!")
 
 if __name__ == "__main__":
     main()