Initial commit

README.md

@@ -1,14 +1,71 @@
 ---
-title: Detection Repoter
-emoji: 💻
-colorFrom: green
-colorTo: pink
+title: Radar Image Analysis System
+emoji: 📡
+colorFrom: blue
+colorTo: red
 sdk: gradio
-sdk_version: 5.0.1
+sdk_version: 3.50.0
 app_file: app.py
 pinned: false
 license: mit
-short_description: 'Reporter generation  of radar deatection '
 ---
 
+# Radar Image Analysis System
+
+This Hugging Face Space provides an interactive interface for analyzing radar images using deep learning and signal processing techniques. The system can detect defects, analyze signal characteristics, and generate detailed reports.
+
+## Features
+
+- **Defect Detection**: Uses PaliGemma model to detect and localize defects in radar images
+- **Signal Analysis**: Analyzes key signal characteristics:
+  - Amplitude analysis
+  - Distribution range measurement
+  - Attenuation rate calculation
+  - Reflection count analysis
+- **Report Generation**: Creates detailed reports with visualizations
+- **History Tracking**: Maintains a history of analyzed images and findings
+
+## How to Use
+
+1. Upload a radar image using the interface
+2. Click "Analyze" to process the image
+3. View the detection results and analysis report
+4. Access previous analyses through the history feature
+
+## Technical Details
+
+- **Model**: PaliGemma-3b fine-tuned for radar defect detection
+- **Framework**: PyTorch + Transformers
+- **Interface**: Gradio
+- **Signal Processing**: Custom algorithms for radar signal analysis
+
+## Environment Variables
+
+The following environment variables need to be set in your Space:
+
+- `HF_TOKEN`: Your Hugging Face token for accessing the model
+- `DATABASE_URL` (optional): URL for the database connection
+
+## Requirements
+
+See `requirements.txt` for the complete list of dependencies.
+
+## License
+
+MIT License
+
+## Citation
+
+If you use this system in your work, please cite:
+
+```bibtex
+@software{radar_analysis_system,
+  title = {Radar Image Analysis System},
+  author = {Chen, Xingqiang},
+  year = {2024},
+  publisher = {Hugging Face Spaces},
+  url = {https://huggingface.co/spaces/[your-username]/radar-analysis}
+}
+```
+
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -1,91 +1,154 @@
 import gradio as gr
 import torch
 from PIL import Image
-import io
-import pandas as pd
+import numpy as np
+import os
+from pathlib import Path
 
 from model import RadarDetectionModel
 from feature_extraction import (calculate_amplitude, classify_amplitude,
-                                calculate_distribution_range, classify_distribution_range,
-                                calculate_attenuation_rate, classify_attenuation_rate,
-                                count_reflections, classify_reflections)
-from report_generation import generate_report
+                              calculate_distribution_range, classify_distribution_range,
+                              calculate_attenuation_rate, classify_attenuation_rate,
+                              count_reflections, classify_reflections)
+from report_generation import generate_report, render_report
 from utils import plot_detection
 from database import save_report, get_report_history
-from report_generation import render_report
-model = RadarDetectionModel()
 
+# Initialize model with HF token from environment
+model = None
+try:
+    model = RadarDetectionModel(use_auth_token=os.getenv("HF_TOKEN"))
+except Exception as e:
+    print(f"Warning: Model initialization failed: {str(e)}")
+    print("The app will initialize the model on first request.")
+
+def initialize_model():
+    global model
+    if model is None:
+        try:
+            model = RadarDetectionModel(use_auth_token=os.getenv("HF_TOKEN"))
+        except Exception as e:
+            return None, f"Error initializing model: {str(e)}"
+    return model, None
 
 def process_image(image):
-    detection_result = model.detect(image)
-
-    np_image = np.array(image)
-    amplitude = calculate_amplitude(np_image)
-    amplitude_class = classify_amplitude(amplitude)
-
-    box = detection_result['boxes'][0].tolist()
-    distribution_range = calculate_distribution_range(box)
-    distribution_class = classify_distribution_range(distribution_range)
-
-    attenuation_rate = calculate_attenuation_rate(np_image)
-    attenuation_class = classify_attenuation_rate(attenuation_rate)
-
-    reflection_count = count_reflections(np_image)
-    reflection_class = classify_reflections(reflection_count)
-
-    features = {
-        "振幅": amplitude_class,
-        "分布范围": distribution_class,
-        "衰减速度": attenuation_class,
-        "反射次数": reflection_class
-    }
-
-    report = generate_report(detection_result, image, features)
-
-    detection_image = plot_detection(image, detection_result)
-
-    save_report(report)
-
-    return detection_image, report
-
-
-def analyze_radar_image(image):
-    detection_image, report = process_image(image)
-    report_html = render_report(report)
-    return detection_image, report_html
-
+    if image is None:
+        return None, "Please upload an image."
+    
+    # Initialize model if needed
+    global model
+    model, error = initialize_model()
+    if error:
+        return None, error
+    
+    try:
+        # Convert to PIL Image if needed
+        if isinstance(image, np.ndarray):
+            image = Image.fromarray(image)
+        
+        # Run detection
+        detection_result = model.detect(image)
+        
+        # Extract features
+        np_image = np.array(image)
+        amplitude = calculate_amplitude(np_image)
+        amplitude_class = classify_amplitude(amplitude)
+        
+        if len(detection_result['boxes']) > 0:
+            box = detection_result['boxes'][0].tolist()
+            distribution_range = calculate_distribution_range(box)
+            distribution_class = classify_distribution_range(distribution_range)
+        else:
+            distribution_class = "No defects detected"
+        
+        attenuation_rate = calculate_attenuation_rate(np_image)
+        attenuation_class = classify_attenuation_rate(attenuation_rate)
+        
+        reflection_count = count_reflections(np_image)
+        reflection_class = classify_reflections(reflection_count)
+        
+        features = {
+            "Amplitude": amplitude_class,
+            "Distribution Range": distribution_class,
+            "Attenuation Rate": attenuation_class,
+            "Reflection Count": reflection_class
+        }
+        
+        # Generate report and visualizations
+        report = generate_report(detection_result, image, features)
+        detection_image = plot_detection(image, detection_result)
+        
+        # Save report if database is configured
+        try:
+            save_report(report)
+        except Exception as e:
+            print(f"Warning: Could not save report: {str(e)}")
+        
+        return detection_image, render_report(report)
+        
+    except Exception as e:
+        error_msg = f"Error processing image: {str(e)}"
+        print(error_msg)
+        return None, error_msg
 
 def display_history():
-    reports = get_report_history()
-    history_html = "<div class='history-container'><h3>历史记录</h3>"
-    for report in reports:
-        history_html += f"""
-        <div class='history-item'>
-            <p><strong>报告ID:</strong> {report.report_id}</p>
-            <p><strong>缺陷类型:</strong> {report.defect_type}</p>
-            <p><strong>描述:</strong> {report.description}</p>
-            <p><strong>创建时间:</strong> {report.created_at}</p>
-        </div>
-        """
-    history_html += "</div>"
-    return history_html
-
-
-with gr.Blocks(css="static/style.css") as iface:
-    gr.Markdown("# 雷达图谱分析系统")
+    try:
+        reports = get_report_history()
+        history_html = "<div class='history-container'><h3>Analysis History</h3>"
+        for report in reports:
+            history_html += f"""
+            <div class='history-item'>
+                <p><strong>Report ID:</strong> {report.report_id}</p>
+                <p><strong>Defect Type:</strong> {report.defect_type}</p>
+                <p><strong>Description:</strong> {report.description}</p>
+                <p><strong>Created:</strong> {report.created_at}</p>
+            </div>
+            """
+        history_html += "</div>"
+        return history_html
+    except Exception as e:
+        return f"Error retrieving history: {str(e)}"
+
+# Create Gradio interface
+css = """
+.gradio-container {max-width: 1200px !important}
+.history-container {margin-top: 20px; padding: 10px;}
+.history-item {
+    border: 1px solid #ddd;
+    padding: 10px;
+    margin: 10px 0;
+    border-radius: 5px;
+}
+"""
+
+with gr.Blocks(css=css) as iface:
+    gr.Markdown("# Radar Image Analysis System")
+    
     with gr.Row():
         with gr.Column(scale=1):
-            input_image = gr.Image(type="pil", label="上传雷达图谱")
-            analyze_button = gr.Button("分析")
+            input_image = gr.Image(type="pil", label="Upload Radar Image")
+            analyze_button = gr.Button("Analyze", variant="primary")
+        
         with gr.Column(scale=2):
-            output_image = gr.Image(type="pil", label="检测结果")
-            output_report = gr.HTML(label="分析报告")
-
-    history_button = gr.Button("查看历史记录")
-    history_output = gr.HTML()
-
-    analyze_button.click(analyze_radar_image, inputs=[
-                         input_image], outputs=[output_image, output_report])
-    history_button.click(display_history, inputs=[], outputs=[history_output])
-
+            output_image = gr.Image(type="pil", label="Detection Result")
+            output_report = gr.HTML(label="Analysis Report")
+    
+    with gr.Row():
+        history_button = gr.Button("View History")
+        history_output = gr.HTML()
+    
+    # Set up event handlers
+    analyze_button.click(
+        fn=process_image,
+        inputs=[input_image],
+        outputs=[output_image, output_report]
+    )
+    
+    history_button.click(
+        fn=display_history,
+        inputs=[],
+        outputs=[history_output]
+    )
+
+# Launch the interface
 iface.launch()

model.py

@@ -1,23 +1,83 @@
+import os
 from transformers import AutoFeatureExtractor, AutoModelForObjectDetection
 import torch
-from config import MODEL_NAME
+from huggingface_hub import login
+import logging
 
+logger = logging.getLogger(__name__)
 
 class RadarDetectionModel:
-    def __init__(self):
-        self.feature_extractor = AutoFeatureExtractor.from_pretrained(
-            "google/paligemma-3b-ft-coco35l-224")
-        self.model = AutoModelForObjectDetection.from_pretrained(
-            "google/paligemma-3b-ft-coco35l-224")
-        self.model.eval()
+    def __init__(self, model_name="google/paligemma-3b-ft-coco35l-224", use_auth_token=None):
+        """
+        Initialize the radar detection model.
+        
+        Args:
+            model_name (str): Name of the model to load from HuggingFace
+            use_auth_token (str, optional): HuggingFace token for accessing gated models.
+                                          If None, will try to use HF_TOKEN environment variable.
+        """
+        self.model_name = model_name
+        
+        # Get token from environment if not provided
+        if use_auth_token is None:
+            use_auth_token = os.getenv("HF_TOKEN")
+        
+        try:
+            # Try to load the model with authentication
+            if use_auth_token:
+                logger.info("Attempting to load model with authentication token...")
+                login(use_auth_token)
+                
+            self.feature_extractor = AutoFeatureExtractor.from_pretrained(
+                self.model_name,
+                use_auth_token=use_auth_token
+            )
+            self.model = AutoModelForObjectDetection.from_pretrained(
+                self.model_name,
+                use_auth_token=use_auth_token
+            )
+            self.model.eval()
+            
+        except Exception as e:
+            logger.error(f"Error loading model: {str(e)}")
+            logger.error("""
+                Failed to load the model. This could be due to:
+                1. Missing authentication token for gated model
+                2. Invalid token
+                3. No internet connection
+                
+                Please ensure you have:
+                1. Set the HF_TOKEN environment variable with your HuggingFace token
+                   OR passed the token directly to the constructor
+                2. Have a valid token with access to the model
+                3. Are connected to the internet
+                
+                You can get your token from: https://huggingface.co/settings/tokens
+            """)
+            raise
 
     @torch.no_grad()
     def detect(self, image):
-        inputs = self.feature_extractor(images=image, return_tensors="pt")
-        outputs = self.model(**inputs)
+        """
+        Perform object detection on the input image.
+        
+        Args:
+            image: PIL Image object
+            
+        Returns:
+            dict: Detection results including boxes, scores, and labels
+        """
+        try:
+            inputs = self.feature_extractor(images=image, return_tensors="pt")
+            outputs = self.model(**inputs)
 
-        target_sizes = torch.tensor([image.size[::-1]])
-        results = self.feature_extractor.post_process_object_detection(
-            outputs, threshold=0.5, target_sizes=target_sizes)[0]
+            # Process the outputs
+            target_sizes = torch.tensor([image.size[::-1]])
+            results = self.feature_extractor.post_process_object_detection(
+                outputs, threshold=0.5, target_sizes=target_sizes)[0]
 
-        return results
+            return results
+            
+        except Exception as e:
+            logger.error(f"Error during detection: {str(e)}")
+            raise

requirements.txt

@@ -1,11 +1,13 @@
-gradio==3.37.0
-torch==2.0.1
-transformers==4.31.0
-Pillow==9.5.0
-numpy==1.23.5
-matplotlib==3.7.1
-pandas==1.5.3
-sqlalchemy==2.0.19
-plotly==5.15.0
-scikit-learn==1.3.0
-jinja2==3.1.2
+gradio>=3.50.0
+torch>=2.0.1
+transformers>=4.31.0
+Pillow>=9.5.0
+numpy>=1.23.5
+matplotlib>=3.7.1
+pandas>=1.5.3
+sqlalchemy>=2.0.19
+plotly>=5.15.0
+scikit-learn>=1.3.0
+jinja2>=3.1.2
+huggingface-hub>=0.19.0
+python-dotenv>=1.0.0