Update app.py

app.py

@@ -7,7 +7,6 @@ import tempfile
 import os
 import asyncio
 from concurrent.futures import ThreadPoolExecutor
-import time
 
 # Set page configuration
 st.set_page_config(page_title="Solar Panel Fault Detection", layout="wide")
@@ -19,156 +18,8 @@ st.write("Upload a thermal video (MP4) of a solar panel to detect thermal, dust,
 # Load model and processor
 @st.cache_resource
 def load_model():
-    # Use a lighter model for faster inference (e.g., YOLOS-tiny or DETR)
     processor = DetrImageProcessor.from_pretrained("facebook/detr-resnet-50")
     model = DetrForObjectDetection.from_pretrained("facebook/detr-resnet-50")
-    # Move model to GPU if available
-    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-    model.to(device)
-    model.eval()
-    return processor, model, device
-
-processor, model, device = load_model()
-
-# Function to process a batch of frames
-async def detect_faults_batch(frames, processor, model, device):
-    # Convert frames to RGB and prepare for model
-    inputs = processor(images=frames, return_tensors="pt").to(device)
-    
-    # Run inference
-    with torch.no_grad():
-        outputs = model(**inputs)
-    
-    # Post-process outputs
-    target_sizes = torch.tensor([frame.shape[:2] for frame in frames]).to(device)
-    results = processor.post_process_object_detection(outputs, target_sizes=target_sizes, threshold=0.9)
-    
-    annotated_frames = []
-    all_faults = []
-    
-    for frame, result in zip(frames, results):
-        faults = {"Thermal Fault": False, "Dust Fault": False, "Power Generation Fault": False}
-        annotated_frame = frame.copy()
-        
-        # Analyze frame for faults
-        for score, label, box in zip(result["scores"], result["labels"], result["boxes"]):
-            box = [int(i) for i in box.tolist()]
-            roi = frame[box[1]:box[3], box[0]:box[2]]
-            mean_intensity = np.mean(roi)
-            
-            # Thermal Fault: High intensity (hotspot)
-            if mean_intensity > 200:
-                faults["Thermal Fault"] = True
-                cv2.rectangle(annotated_frame, (box[0], box[1]), (box[2], box[3]), (255, 0, 0), 2)
-                cv2.putText(annotated_frame, "Thermal Fault", (box[0], box[1]-10), 
-                           cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 0, 0), 2)
-            
-            # Dust Fault: Low intensity
-            elif mean_intensity < 100:
-                faults["Dust Fault"] = True
-                cv2.rectangle(annotated_frame, (box[0], box[1]), (box[2], box[3]), (0, 255, 0), 2)
-                cv2.putText(annotated_frame, "Dust Fault", (box[0], box[1]-10), 
-                           cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
-            
-            # Power Generation Fault
-            if faults["Thermal Fault"] or faults["Dust Fault"]:
-                faults["Power Generation Fault"] = True
-        
-        annotated_frames.append(annotated_frame)
-        all_faults.append(faults)
-    
-    return annotated_frames, all_faults
-
-# Function to process video
-async def process_video(video_path, frame_skip=5, batch_size=4):
-    cap = cv2.VideoCapture(video_path)
-    if not cap.isOpened():
-        st.error("Error: Could not open video file.")
-        return None, None
-    
-    # Get video properties
-    frame_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
-    frame_height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
-    fps = int(cap.get(cv2.CAP_PROP_FPS))
-    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
-    
-    # Create temporary file for output video
-    output_path = tempfile.NamedTemporaryFile(suffix=".mp4", delete=False).name
-    fourcc = cv2.VideoWriter_fourcc(*"mp4v")
-    out = cv2.VideoWriter(output_path, fourcc, fps, (frame_width, frame_height))
-    
-    video_faults = {"Thermal Fault": False, "Dust Fault": False, "Power Generation Fault": False}
-    frame_count = 0
-    frames_batch = []
-    
-    with st.spinner("Analyzing video..."):
-        progress = st.progress(0)
-        executor = ThreadPoolExecutor(max_workers=2)
-        
-        while cap.isOpened():
-            ret, frame = cap.read()
-            if not ret:
-                break
-            
-            # Skip frames to reduce processing time
-            if frame_count % frame_skip != 0:
-                # Write original frame for skipped frames
-                out.write(frame)
-                frame_count += 1
-                continue
-            
-            # Convert BGR to RGB
-            frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
-            frames_batch.append(frame_rgb)
-            
-            # Process batch when full
-            if len(frames_batch) >= batch_size:
-                annotated_frames, batch_faults = await detect_faults_batch(frames_batch, processor, model, device)
-                for annotated_frame, faults in zip(annotated_frames, batch_faults):
-                    # Update video faults
-                    for fault in**.
-
-System: You are Grok 3 built by xAI.
-
-The code you provided seems to be cut off and contains some incomplete sections (e.g., the `process_video` function is incomplete). I'll complete and further optimize the code, incorporating the suggestions for batch processing, frame skipping, and efficient resource management. The updated code will also include proper error handling, cleanup, and a streamlined user interface for better performance and user experience.
-
-### Key Optimizations
-1. **Batch Processing**: Process frames in batches to reduce overhead and leverage GPU parallelism.
-2. **Frame Skipping**: Process every nth frame to speed up analysis while maintaining accuracy.
-3. **ThreadPoolExecutor**: Use threading for I/O-bound tasks like reading/writing frames.
-4. **Asyncio**: Handle inference asynchronously to improve responsiveness.
-5. **Lightweight Model Option**: Allow switching to a faster model like `YOLOS-tiny` (commented for flexibility).
-6. **Resource Cleanup**: Ensure temporary files are properly managed.
-7. **Progress Feedback**: Provide clear progress updates to the user.
-8. **Error Handling**: Add robust error handling for video processing.
-
-### Complete Updated Code
-```python
-import streamlit as st
-import torch
-from transformers import DetrImageProcessor, DetrForObjectDetection
-import cv2
-import numpy as np
-import tempfile
-import os
-import asyncio
-from concurrent.futures import ThreadPoolExecutor
-import time
-
-# Set page configuration
-st.set_page_config(page_title="Solar Panel Fault Detection", layout="wide")
-
-# Title and description
-st.title("Solar Panel Fault Detection PoC")
-st.write("Upload a thermal video (MP4) of a solar panel to detect thermal, dust, and power generation faults.")
-
-# Load model and processor
-@st.cache_resource
-def load_model():
-    # Use DETR-resnet-50; alternatively, use a lighter model like YOLOS-tiny for faster inference
-    processor = DetrImageProcessor.from_pretrained("facebook/detr-resnet-50")
-    model = DetrForObjectDetection.from_pretrained("facebook/detr-resnet-50")
-    # Move model to GPU if available
     device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
     model.to(device)
     model.eval()
@@ -179,14 +30,9 @@ processor, model, device = load_model()
 # Function to process a batch of frames
 async def detect_faults_batch(frames, processor, model, device):
     try:
-        # Convert frames to RGB and prepare for model
         inputs = processor(images=frames, return_tensors="pt").to(device)
-        
-        # Run inference
         with torch.no_grad():
             outputs = model(**inputs)
-        
-        # Post-process outputs
         target_sizes = torch.tensor([frame.shape[:2] for frame in frames]).to(device)
         results = processor.post_process_object_detection(outputs, target_sizes=target_sizes, threshold=0.9)
         
@@ -197,27 +43,22 @@ async def detect_faults_batch(frames, processor, model, device):
             faults = {"Thermal Fault": False, "Dust Fault": False, "Power Generation Fault": False}
             annotated_frame = frame.copy()
             
-            # Analyze frame for faults
             for score, label, box in zip(result["scores"], result["labels"], result["boxes"]):
                 box = [int(i) for i in box.tolist()]
                 roi = frame[box[1]:box[3], box[0]:box[2]]
                 mean_intensity = np.mean(roi)
                 
-                # Thermal Fault: High intensity (hotspot)
                 if mean_intensity > 200:
                     faults["Thermal Fault"] = True
                     cv2.rectangle(annotated_frame, (box[0], box[1]), (box[2], box[3]), (255, 0, 0), 2)
                     cv2.putText(annotated_frame, "Thermal Fault", (box[0], box[1]-10), 
                                cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 0, 0), 2)
-                
-                # Dust Fault: Low intensity
                 elif mean_intensity < 100:
                     faults["Dust Fault"] = True
                     cv2.rectangle(annotated_frame, (box[0], box[1]), (box[2], box[3]), (0, 255, 0), 2)
                     cv2.putText(annotated_frame, "Dust Fault", (box[0], box[1]-10), 
                                cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
                 
-                # Power Generation Fault
                 if faults["Thermal Fault"] or faults["Dust Fault"]:
                     faults["Power Generation Fault"] = True
             
@@ -237,13 +78,11 @@ async def process_video(video_path, frame_skip=5, batch_size=4):
             st.error("Error: Could not open video file.")
             return None, None
         
-        # Get video properties
         frame_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
         frame_height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
         fps = int(cap.get(cv2.CAP_PROP_FPS))
         total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
         
-        # Create temporary file for output video
         output_path = tempfile.NamedTemporaryFile(suffix=".mp4", delete=False).name
         fourcc = cv2.VideoWriter_fourcc(*"mp4v")
         out = cv2.VideoWriter(output_path, fourcc, fps, (frame_width, frame_height))
@@ -262,7 +101,6 @@ async def process_video(video_path, frame_skip=5, batch_size=4):
                 if not ret:
                     break
                 
-                # Skip frames to reduce processing time
                 if frame_count % frame_skip != 0:
                     out.write(frame)
                     frame_count += 1
@@ -270,19 +108,14 @@ async def process_video(video_path, frame_skip=5, batch_size=4):
                     progress.progress(min(processed_frames / total_frames, 1.0))
                     continue
                 
-                # Convert BGR to RGB
                 frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
                 frames_batch.append(frame_rgb)
                 
-9                # Process batch when full
                 if len(frames_batch) >= batch_size:
                     annotated_frames, batch_faults = await detect_faults_batch(frames_batch, processor, model, device)
                     for annotated_frame, faults in zip(annotated_frames, batch_faults):
-                        # Update video faults
                         for fault in video_faults:
                             video_faults[fault] |= faults[fault]
-                        
-                        # Convert back to BGR for writing
                         annotated_frame_bgr = cv2.cvtColor(annotated_frame, cv2.COLOR_RGB2BGR)
                         out.write(annotated_frame_bgr)
                     
@@ -292,7 +125,6 @@ async def process_video(video_path, frame_skip=5, batch_size=4):
                 
                 frame_count += 1
             
-            # Process remaining frames
             if frames_batch:
                 annotated_frames, batch_faults = await detect_faults_batch(frames_batch, processor, model, device)
                 for annotated_frame, faults in zip(annotated_frames, batch_faults):
@@ -322,31 +154,25 @@ uploaded_file = st.file_uploader("Upload a thermal video", type=["mp4"])
 
 if uploaded_file is not None:
     try:
-        # Save uploaded video to temporary file
         tfile = tempfile.NamedTemporaryFile(suffix=".mp4", delete=False)
         tfile.write(uploaded_file.read())
         tfile.close()
         
-        # Display uploaded video
         st.video(tfile.name, format="video/mp4")
         
-        # Process video
         loop = asyncio.get_event_loop()
         output_path, video_faults = loop.run_until_complete(process_video(tfile.name, frame_skip=5, batch_size=4))
         
         if output_path and video_faults:
-            # Display results
             st.subheader("Fault Detection Results")
             st.video(output_path, format="video/mp4")
             
-            # Show fault summary
             st.write("**Detected Faults in Video:**")
             for fault, detected in video_faults.items():
                 status = "Detected" if detected else "Not Detected"
                 color = "red" if detected else "green"
                 st.markdown(f"- **{fault}**: <span style='color:{color}'>{status}</span>", unsafe_allow_html=True)
             
-            # Provide recommendations
             if any(video_faults.values()):
                 st.subheader("Recommendations")
                 if video_faults["Thermal Fault"]:
@@ -358,11 +184,9 @@ if uploaded_file is not None:
             else:
                 st.write("No faults detected. The solar panel appears to be functioning normally.")
             
-            # Clean up output file
             if os.path.exists(output_path):
                 os.unlink(output_path)
         
-        # Clean up uploaded file
         if os.path.exists(tfile.name):
             os.unlink(tfile.name)