Upload folder using huggingface_hub

README.md

@@ -1,13 +1,43 @@
 ---
-title: Soho Comet Detector
-emoji: 👀
-colorFrom: yellow
-colorTo: pink
+title: SOHO Comet Detector
+emoji: 🌟
+colorFrom: blue
+colorTo: purple
 sdk: gradio
-sdk_version: 5.49.0
+sdk_version: 4.44.0
 app_file: app.py
 pinned: false
-license: mit
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 🌟 AI-Powered SOHO Comet Detector
+
+Automatically detect comets in NASA's SOHO/LASCO coronagraph images using deep learning.
+
+## 🚀 Features
+- **99% Accuracy** on validation data
+- **Difference Imaging** to highlight moving objects
+- **EfficientNet-B0** classifier
+- Real-time detection on uploaded image sequences
+
+## 📊 Model Details
+- **Architecture:** EfficientNet-B0
+- **Training Data:** 1,590 patches (590 comet, 1,000 background)
+- **Method:** Difference imaging + binary classification
+- **Performance:** 99% precision, 99% recall
+
+## 🎯 Usage
+1. Upload a ZIP containing SOHO LASCO C3 FITS images
+2. Adjust confidence threshold (0.90 recommended)
+3. Click "Detect Comets"
+4. View results with detection confidence scores
+
+## 📚 Dataset
+Trained on SOHO/LASCO C3 coronagraph data from the Sungrazer Project.
+
+## 👥 Team
+Sambhavi
+Emily
+Mohammed
+
+---
+*Built with Gradio • Powered by Hugging Face*

app.py

@@ -0,0 +1,186 @@
+import gradio as gr
+import torch
+import numpy as np
+from astropy.io import fits
+import timm
+from torchvision import transforms
+from PIL import Image
+import matplotlib.pyplot as plt
+from scipy.ndimage import zoom
+from skimage.feature import peak_local_max
+import zipfile
+import tempfile
+from pathlib import Path
+
+class CometDetectorApp:
+    def __init__(self, model_path='best_model.pth'):
+        self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+        
+        self.model = timm.create_model('efficientnet_b0', pretrained=False, num_classes=2)
+        self.model.load_state_dict(torch.load(model_path, map_location=self.device))
+        self.model.to(self.device)
+        self.model.eval()
+        
+        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])
+        ])
+    
+    def load_fits_from_zip(self, zip_file):
+        images = []
+        filenames = []
+        
+        with tempfile.TemporaryDirectory() as tmpdir:
+            with zipfile.ZipFile(zip_file, 'r') as zip_ref:
+                zip_ref.extractall(tmpdir)
+            
+            fits_files = sorted(Path(tmpdir).rglob('*.fts')) + sorted(Path(tmpdir).rglob('*.fits'))
+            
+            for fpath in fits_files:
+                try:
+                    with fits.open(fpath) as hdul:
+                        img = hdul[0].data.astype(np.float32)
+                        if img.shape != (1024, 1024):
+                            factor = 1024 / img.shape[0]
+                            img = zoom(img, factor, order=1)
+                        images.append(img)
+                        filenames.append(fpath.name)
+                except:
+                    continue
+        
+        return np.array(images), filenames
+    
+    def create_difference_images(self, images):
+        diff_images = []
+        for i in range(len(images) - 1):
+            diff = images[i+1] - images[i]
+            diff_images.append(diff)
+        max_proj = np.max(np.abs(np.array(diff_images)), axis=0)
+        return diff_images, max_proj
+    
+    def detect_candidates(self, max_proj, threshold_percentile=95):
+        threshold = np.percentile(max_proj, threshold_percentile)
+        candidates = peak_local_max(max_proj, min_distance=20, threshold_abs=threshold)
+        return candidates
+    
+    def extract_patch(self, image, center, patch_size=64):
+        y, x = center
+        half = patch_size // 2
+        
+        y_start = max(0, y - half)
+        y_end = min(image.shape[0], y + half)
+        x_start = max(0, x - half)
+        x_end = min(image.shape[1], x + half)
+        
+        patch = image[y_start:y_end, x_start:x_end]
+        
+        if patch.shape != (patch_size, patch_size):
+            padded = np.zeros((patch_size, patch_size))
+            padded[:patch.shape[0], :patch.shape[1]] = patch
+            patch = padded
+        
+        return patch
+    
+    def classify_patch(self, patch):
+        patch_norm = (patch - patch.min()) / (patch.max() - patch.min() + 1e-8)
+        patch_rgb = np.stack([patch_norm]*3, axis=-1)
+        patch_rgb = (patch_rgb * 255).astype(np.uint8)
+        
+        patch_pil = Image.fromarray(patch_rgb)
+        patch_tensor = self.transform(patch_pil).unsqueeze(0).to(self.device)
+        
+        with torch.no_grad():
+            output = self.model(patch_tensor)
+            probs = torch.softmax(output, dim=1)
+            pred_class = torch.argmax(probs, dim=1).item()
+            confidence = probs[0][pred_class].item()
+        
+        return pred_class, confidence
+    
+    def process_and_visualize(self, zip_file, confidence_threshold):
+        try:
+            images, filenames = self.load_fits_from_zip(zip_file.name)
+            
+            if len(images) < 2:
+                return None, "❌ Need at least 2 FITS images in the zip file"
+            
+            diff_images, max_proj = self.create_difference_images(images)
+            candidates = self.detect_candidates(max_proj)
+            
+            detections = []
+            for y, x in candidates:
+                patch = self.extract_patch(max_proj, (y, x))
+                pred_class, confidence = self.classify_patch(patch)
+                
+                if pred_class == 0 and confidence >= confidence_threshold:
+                    detections.append({'position': (y, x), 'confidence': confidence})
+            
+            fig, axes = plt.subplots(1, 2, figsize=(14, 6))
+            
+            axes[0].imshow(images[0], cmap='gray')
+            axes[0].set_title('First Image in Sequence')
+            axes[0].axis('off')
+            
+            axes[1].imshow(max_proj, cmap='hot')
+            axes[1].set_title(f'Comet Detection Results')
+            
+            for det in detections:
+                y, x = det['position']
+                axes[1].plot(x, y, 'g*', markersize=20, markeredgecolor='lime', markeredgewidth=2)
+                axes[1].text(x+15, y-15, f"{det['confidence']:.2f}", 
+                           color='lime', fontsize=12, weight='bold',
+                           bbox=dict(boxstyle='round', facecolor='black', alpha=0.7))
+            
+            axes[1].axis('off')
+            plt.tight_layout()
+            
+            if len(detections) > 0:
+                summary = f"✅ **{len(detections)} COMET(S) DETECTED!**\n\n"
+                for i, det in enumerate(detections, 1):
+                    y, x = det['position']
+                    summary += f"**Comet #{i}:**\n- Position: ({y}, {x})\n- Confidence: {det['confidence']:.1%}\n\n"
+            else:
+                summary = "❌ No comets detected in this sequence.\n\n"
+            
+            summary += f"**Processing Info:**\n- Images analyzed: {len(images)}\n- Candidates examined: {len(candidates)}\n- Confidence threshold: {confidence_threshold:.1%}"
+            
+            return fig, summary
+            
+        except Exception as e:
+            return None, f"❌ Error processing images: {str(e)}"
+
+detector = CometDetectorApp('best_model.pth')
+
+with gr.Blocks(theme=gr.themes.Soft(), title="SOHO Comet Detector") as demo:
+    gr.Markdown("""
+    # 🌟 AI-Powered SOHO Comet Detector
+    
+    Upload a **ZIP file** containing SOHO/LASCO C3 FITS images from a time sequence.
+    The AI will automatically detect comets using difference imaging and deep learning.
+    
+    ### 📁 How to prepare your data:
+    1. Download SOHO LASCO C3 images (6-hour sequence)
+    2. Put all .fts or .fits files in a folder
+    3. Zip the folder and upload here
+    
+    ### 🔬 Model: EfficientNet-B0 | Accuracy: 99%
+    """)
+    
+    with gr.Row():
+        with gr.Column():
+            zip_input = gr.File(label="Upload ZIP of FITS Images", file_types=[".zip"], type="filepath")
+            confidence_slider = gr.Slider(minimum=0.5, maximum=0.99, value=0.90, step=0.05,
+                                         label="Confidence Threshold", info="Higher = fewer false positives")
+            detect_button = gr.Button("🔍 Detect Comets", variant="primary", size="lg")
+        
+        with gr.Column():
+            output_plot = gr.Plot(label="Detection Results")
+            output_text = gr.Markdown(label="Summary")
+    
+    detect_button.click(fn=detector.process_and_visualize, inputs=[zip_input, confidence_slider],
+                       outputs=[output_plot, output_text])
+
+if __name__ == "__main__":
+    demo.launch()

best_model.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e21c528b5ba532d474414c4f3773d0359cf15a3dd17577b9cad2e937d05e8a93
+size 16336121

requirements.txt

@@ -0,0 +1,9 @@
+gradio>=4.0.0
+torch>=2.0.0
+timm>=0.9.0
+astropy>=5.0.0
+scikit-image>=0.21.0
+numpy>=1.24.0
+matplotlib>=3.7.0
+scipy>=1.11.0
+Pillow>=10.0.0