Optimize model loading and improve user experience

README.md

@@ -38,6 +38,36 @@ This Hugging Face Space provides an interactive interface for analyzing radar im
 3. View the detection results and analysis report
 4. Access previous analyses through the history feature
 
+## Setup Instructions
+
+### Local Development
+
+1. Clone this repository:
+   ```bash
+   git clone https://huggingface.co/spaces/xingqiang/radar-analysis
+   cd radar-analysis
+   ```
+
+2. Install dependencies:
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+3. Set up environment variables:
+   - Create a `.env` file in the root directory
+   - Add your Hugging Face token: `HF_TOKEN=your_token_here`
+
+4. Run the application:
+   ```bash
+   python app.py
+   ```
+
+### Hugging Face Space Deployment
+
+1. Fork this repository to your Hugging Face account
+2. Set the `HF_TOKEN` secret in your Space settings
+3. Deploy the Space
+
 ## Technical Details
 
 - **Model**: PaliGemma-3b fine-tuned for radar defect detection
@@ -52,6 +82,12 @@ 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
 
+## Troubleshooting
+
+- **Memory Issues**: The application will automatically switch to demo mode if there's not enough memory
+- **Model Loading Errors**: Check that your Hugging Face token has access to the required model
+- **Image Processing Errors**: Ensure uploaded images are in a supported format (PNG, JPG)
+
 ## Requirements
 
 See `requirements.txt` for the complete list of dependencies.

app.py

@@ -12,6 +12,7 @@ import plotly.express as px
 import plotly.graph_objects as go
 import pandas as pd
 from functools import partial
+import logging
 
 from model import RadarDetectionModel
 from feature_extraction import (calculate_amplitude, classify_amplitude,
@@ -22,6 +23,12 @@ from feature_extraction import (calculate_amplitude, classify_amplitude,
 from report_generation import generate_report, render_report
 from utils import plot_detection
 from database import save_report, get_report_history
+from config import MODEL_NAME
+
+# Configure logging
+logging.basicConfig(level=logging.INFO,
+                   format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
 
 # Set theme and styling
 THEME = gr.themes.Soft(
@@ -35,32 +42,40 @@ THEME = gr.themes.Soft(
 # Create a simple dark mode flag instead of custom theme
 DARK_MODE = False
 
+# Global variables
+model = None
+USE_DEMO_MODE = False
+HF_TOKEN = os.environ.get("HF_TOKEN") or os.environ.get("HF_TOCKEN")
+
+# 添加一个标志，表示是否已经尝试过初始化模型
+MODEL_INIT_ATTEMPTED = False
+
 class TechnicalReportGenerator:
     def __init__(self):
         self.timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-    
+
     def generate_model_analysis(self, model_outputs):
         """Generate model-specific analysis section"""
         model_section = "## Model Analysis\n\n"
-        
+
         # Image encoder analysis
         model_section += "### Image Encoder (SigLIP-So400m) Analysis\n"
         model_section += "- Feature extraction quality: {:.2f}%\n".format(model_outputs.get('feature_quality', 0) * 100)
         model_section += "- Image encoding latency: {:.2f}ms\n".format(model_outputs.get('encoding_latency', 0))
         model_section += "- Feature map dimensions: {}\n\n".format(model_outputs.get('feature_dimensions', 'N/A'))
-        
+
         # Text decoder analysis
         model_section += "### Text Decoder (Gemma-2B) Analysis\n"
         model_section += "- Text generation confidence: {:.2f}%\n".format(model_outputs.get('text_confidence', 0) * 100)
         model_section += "- Decoding latency: {:.2f}ms\n".format(model_outputs.get('decoding_latency', 0))
         model_section += "- Token processing rate: {:.2f} tokens/sec\n\n".format(model_outputs.get('token_rate', 0))
-        
+
         return model_section
 
     def generate_detection_analysis(self, detection_results):
         """Generate detailed detection analysis section"""
         detection_section = "## Detection Analysis\n\n"
-        
+
         # Detection metrics
         detection_section += "### Object Detection Metrics\n"
         detection_section += "| Metric | Value |\n"
@@ -72,29 +87,29 @@ class TechnicalReportGenerator:
         detection_section += "| Processing Time | {:.2f}ms |\n\n".format(
             detection_results.get('processing_time', 0)
         )
-        
+
         # Detailed detection results
         detection_section += "### Detection Details\n"
         detection_section += "| Object | Confidence | Bounding Box |\n"
         detection_section += "|--------|------------|---------------|\n"
-        
+
         boxes = detection_results.get('boxes', [])
         scores = detection_results.get('scores', [])
         labels = detection_results.get('labels', [])
-        
+
         for box, score, label in zip(boxes, scores, labels):
             detection_section += "| {} | {:.2f}% | {} |\n".format(
                 label,
                 score * 100,
                 [round(coord, 2) for coord in box]
             )
-        
+
         return detection_section
 
     def generate_multimodal_analysis(self, mm_results):
         """Generate multimodal analysis section"""
         mm_section = "## Multimodal Analysis\n\n"
-        
+
         # Feature correlation analysis
         mm_section += "### Feature Correlation Analysis\n"
         mm_section += "- Text-Image Alignment Score: {:.2f}%\n".format(
@@ -106,19 +121,19 @@ class TechnicalReportGenerator:
         mm_section += "- Feature Space Correlation: {:.2f}\n\n".format(
             mm_results.get('feature_correlation', 0)
         )
-        
+
         return mm_section
 
     def generate_performance_metrics(self, perf_data):
         """Generate performance metrics section"""
         perf_section = "## Performance Metrics\n\n"
-        
+
         # System metrics
         perf_section += "### System Performance\n"
         perf_section += "- Total Processing Time: {:.2f}ms\n".format(perf_data.get('total_time', 0))
         perf_section += "- Peak Memory Usage: {:.2f}MB\n".format(perf_data.get('peak_memory', 0))
         perf_section += "- GPU Utilization: {:.2f}%\n\n".format(perf_data.get('gpu_util', 0))
-        
+
         # Pipeline metrics
         perf_section += "### Pipeline Statistics\n"
         perf_section += "| Stage | Time (ms) | Memory (MB) |\n"
@@ -130,108 +145,370 @@ class TechnicalReportGenerator:
                 stats.get('time', 0),
                 stats.get('memory', 0)
             )
-        
+
         return perf_section
 
     def generate_report(self, results):
         """Generate comprehensive technical report"""
         report = f"# Technical Analysis Report\nGenerated at: {self.timestamp}\n\n"
-        
+
         # Add model analysis
         report += self.generate_model_analysis(results.get('model_outputs', {}))
-        
+
         # Add detection analysis
         report += self.generate_detection_analysis(results.get('detection_results', {}))
-        
+
         # Add multimodal analysis
         report += self.generate_multimodal_analysis(results.get('multimodal_results', {}))
-        
+
         # Add performance metrics
         report += self.generate_performance_metrics(results.get('performance_data', {}))
-        
+
         return report
 
-# Initialize model with HF token from environment
-model = None
-USE_DEMO_MODE = False
-MODEL_NAME = "Extremely4606/paligemma24_12_30"  # Alternative model instead of Google's gated model
+def check_available_memory():
+    """Check available system memory in MB"""
+    try:
+        import psutil
+        vm = psutil.virtual_memory()
+        available_mb = vm.available / (1024 * 1024)
+        total_mb = vm.total / (1024 * 1024)
+        print(f"Available memory: {available_mb:.2f}MB out of {total_mb:.2f}MB total")
+        return available_mb
+    except Exception as e:
+        print(f"Error checking memory: {str(e)}")
+        return 0
+
+def monitor_memory_during_loading(model_name, use_auth_token=None):
+    """Monitor memory usage during model loading and abort if it gets too high"""
+    global USE_DEMO_MODE
+
+    try:
+        # Initial memory check
+        initial_memory = get_memory_usage()
+        print(f"Initial memory usage: {initial_memory:.2f}MB")
+
+        # Start loading processor
+        print(f"Loading processor from {model_name}")
+        if use_auth_token:
+            processor = AutoProcessor.from_pretrained(model_name, use_auth_token=use_auth_token)
+        else:
+            processor = AutoProcessor.from_pretrained(model_name)
+
+        # Check memory after processor loading
+        after_processor_memory = get_memory_usage()
+        print(f"Memory after processor loading: {after_processor_memory:.2f}MB (Δ: {after_processor_memory - initial_memory:.2f}MB)")
+
+        # Check if memory is getting too high
+        available_memory = check_available_memory()
+        if available_memory < 4000:  # Less than 4GB available
+            print(f"Warning: Only {available_memory:.2f}MB memory available after loading processor")
+            print("Aborting model loading to avoid out-of-memory error")
+            USE_DEMO_MODE = True
+            return None, None
+
+        # Start loading model with 8-bit quantization
+        print(f"Loading model from {model_name} with 8-bit quantization")
+        if use_auth_token:
+            model = AutoModelForVision2Seq.from_pretrained(
+                model_name,
+                use_auth_token=use_auth_token,
+                load_in_8bit=True,
+                device_map="auto"
+            )
+        else:
+            model = AutoModelForVision2Seq.from_pretrained(
+                model_name,
+                load_in_8bit=True,
+                device_map="auto"
+            )
 
-try:
-    hf_token = os.getenv("HF_TOKEN")
-    print(f"Attempting to load model: {MODEL_NAME}")
-    # Try to initialize without token first since this model might be public
+        # Check memory after model loading
+        after_model_memory = get_memory_usage()
+        print(f"Memory after model loading: {after_model_memory:.2f}MB (Δ: {after_model_memory - after_processor_memory:.2f}MB)")
+
+        # Set model to evaluation mode
+        model.eval()
+
+        return processor, model
+    except Exception as e:
+        print(f"Error during monitored model loading: {str(e)}")
+        USE_DEMO_MODE = True
+        return None, None
+
+def is_running_in_space():
+    """Check if we're running in a Hugging Face Space environment"""
+    return os.environ.get("SPACE_ID") is not None
+
+def is_container_environment():
+    """Check if we're running in a container environment"""
+    return os.path.exists("/.dockerenv") or os.path.exists("/run/.containerenv")
+
+def is_cpu_only():
+    """Check if we're running in a CPU-only environment"""
+    return not torch.cuda.is_available()
+
+def is_low_memory_environment():
+    """Check if we're running in a low-memory environment"""
+    available_memory = check_available_memory()
+    return available_memory < 8000  # Less than 8GB available
+
+def is_development_environment():
+    """Check if we're running in a development environment"""
+    return not (is_running_in_space() or is_container_environment())
+
+def is_debug_mode():
+    """Check if we're running in debug mode"""
+    return os.environ.get("DEBUG", "").lower() in ("1", "true", "yes")
+
+def is_test_mode():
+    """Check if we're running in test mode"""
+    return os.environ.get("TEST", "").lower() in ("1", "true", "yes")
+
+def is_low_memory_container():
+    """Check if we're running in a container with memory limits"""
+    if not is_container_environment():
+        return False
+
+    # Check if cgroup memory limit is set
+    try:
+        with open('/sys/fs/cgroup/memory/memory.limit_in_bytes', 'r') as f:
+            limit = int(f.read().strip())
+            # Convert to MB
+            limit_mb = limit / (1024 * 1024)
+            print(f"Container memory limit: {limit_mb:.2f}MB")
+            return limit_mb < 20000  # Less than 20GB
+    except:
+        # If we can't read the limit, assume it's a low-memory container
+        return True
+
+def is_space_hardware_type(hardware_type):
+    """Check if we're running in a Hugging Face Space with a specific hardware type"""
+    if not is_running_in_space():
+        return False
+
+    # Check if SPACE_HARDWARE environment variable matches the specified type
+    return os.environ.get("SPACE_HARDWARE", "").lower() == hardware_type.lower()
+
+def get_space_hardware_tier():
+    """Get the hardware tier of the Hugging Face Space"""
+    if not is_running_in_space():
+        return "Not a Space"
+
+    hardware = os.environ.get("SPACE_HARDWARE", "unknown")
+
+    # Determine the tier based on hardware type
+    if hardware.lower() == "cpu":
+        return "Basic (CPU)"
+    elif hardware.lower() == "t4-small":
+        return "Basic (GPU)"
+    elif hardware.lower() == "t4-medium":
+        return "Standard"
+    elif hardware.lower() == "a10g-small":
+        return "Pro"
+    elif hardware.lower() == "a10g-large":
+        return "Pro+"
+    elif hardware.lower() == "a100-large":
+        return "Enterprise"
+    else:
+        return f"Unknown ({hardware})"
+
+def get_space_hardware_memory():
+    """Get the memory size of the Hugging Face Space hardware in GB"""
+    if not is_running_in_space():
+        return 0
+
+    hardware = os.environ.get("SPACE_HARDWARE", "unknown").lower()
+
+    # Determine the memory size based on hardware type
+    if hardware == "cpu":
+        return 16  # 16GB for CPU
+    elif hardware == "t4-small":
+        return 16  # 16GB for T4 Small
+    elif hardware == "t4-medium":
+        return 16  # 16GB for T4 Medium
+    elif hardware == "a10g-small":
+        return 24  # 24GB for A10G Small
+    elif hardware == "a10g-large":
+        return 40  # 40GB for A10G Large
+    elif hardware == "a100-large":
+        return 80  # 80GB for A100 Large
+    else:
+        return 16  # Default to 16GB
+
+def get_total_system_memory():
+    """Get total system memory in MB"""
     try:
-        model = RadarDetectionModel(model_name=MODEL_NAME)
-        print(f"Successfully loaded model {MODEL_NAME} without authentication")
+        import psutil
+        total_bytes = psutil.virtual_memory().total
+        total_mb = total_bytes / (1024 * 1024)
+        return total_mb
     except Exception as e:
-        if not hf_token:
-            print("Warning: HF_TOKEN environment variable not set. Using demo mode.")
+        print(f"Error getting total system memory: {str(e)}")
+        return 0
+
+def estimate_model_memory_requirements():
+    """Estimate the memory requirements for the model"""
+    # This is a placeholder implementation. You might want to implement a more accurate estimation based on your model's architecture and typical input sizes.
+    try:
+        HF_TOCKEN = os.getenv("HF_TOCKEN")
+
+        # Print startup message
+        print("===== Application Startup at", datetime.now().strftime("%Y-%m-%d %H:%M:%S"), "=====")
+
+        # Get system memory information
+        total_memory = get_total_system_memory()
+        required_memory = estimate_model_memory_requirements()
+        recommended_tier = get_recommended_space_tier()
+        print(f"NOTICE: Total system memory: {total_memory:.2f}MB")
+        print(f"NOTICE: Estimated model memory requirement: {required_memory:.2f}MB")
+        print(f"NOTICE: Recommended Space tier: {recommended_tier}")
+
+        if is_test_mode():
+            print("NOTICE: Running in TEST mode")
+            print("NOTICE: Using mock data and responses")
+            USE_DEMO_MODE = True
+
+        if is_debug_mode():
+            print("NOTICE: Running in DEBUG mode")
+            print("NOTICE: Additional logging and diagnostics will be enabled")
+
+        if is_development_environment():
+            print("NOTICE: Running in development environment")
+            print("NOTICE: Full model capabilities may be available depending on system resources")
+
+        if is_running_in_space():
+            print("NOTICE: Running in Hugging Face Space environment")
+
+            # Check Space hardware type
+            hardware_type = get_space_hardware_type()
+            hardware_tier = get_space_hardware_tier()
+            hardware_memory = get_space_hardware_memory()
+            print(f"NOTICE: Space hardware type: {hardware_type} (Tier: {hardware_tier}, Memory: {hardware_memory}GB)")
+
+            if has_enough_memory_for_model():
+                print("NOTICE: This Space has enough memory for the model, but we're still forcing demo mode for stability")
+            else:
+                print(f"NOTICE: This Space does NOT have enough memory for the model (Need: {required_memory:.2f}MB, Have: {hardware_memory*1024:.2f}MB)")
+                print(f"NOTICE: Recommended Space tier: {recommended_tier}")
+
+            print("NOTICE: FORCING DEMO MODE to avoid 'Memory limit exceeded (16Gi)' error")
+            print("NOTICE: The PaliGemma model is too large for the 16GB memory limit in Spaces")
+            print("NOTICE: To use the full model, please run this application locally")
+            USE_DEMO_MODE = True
+        elif is_container_environment():
+            print("NOTICE: Running in a container environment")
+            print("NOTICE: Memory limits may be enforced by the container runtime")
+
+        if is_cpu_only():
+            print("NOTICE: Running in CPU-only environment")
+            print("NOTICE: Model loading and inference will be slower")
+
+        # Check available memory
+        available_memory = check_available_memory()
+        print(f"NOTICE: Available memory: {available_memory:.2f}MB")
+
+        if is_low_memory_environment() and not USE_DEMO_MODE:
+            print("NOTICE: Running in a low-memory environment")
+            print("NOTICE: Enabling DEMO MODE to avoid memory issues")
             USE_DEMO_MODE = True
         else:
-            print(f"Attempting to load model {MODEL_NAME} with authentication")
-            model = RadarDetectionModel(model_name=MODEL_NAME, use_auth_token=hf_token)
-except Exception as e:
-    print(f"Warning: Model initialization failed: {str(e)}")
-    print("Falling back to demo mode.")
-    USE_DEMO_MODE = True
+            # Check available memory before loading
+            available_memory = check_available_memory()
+            if available_memory < 8000:  # If less than 8GB available
+                print(f"Warning: Only {available_memory:.2f}MB memory available, which may not be enough for the full model")
+        return required_memory
+    except Exception as e:
+        print(f"Warning: Model initialization failed: {str(e)}")
+        print("Falling back to demo mode.")
+        USE_DEMO_MODE = True
+        return 0
 
 def initialize_model():
-    global model, USE_DEMO_MODE, MODEL_NAME
-    if USE_DEMO_MODE:
-        return None, None  # Will use mock data in demo mode
+    """
+    仅在需要时初始化模型，不会在应用启动时自动加载
+    """
+    global model, USE_DEMO_MODE, MODEL_INIT_ATTEMPTED
     
-    if model is None:
-        try:
-            # Try to initialize without token first since this model might be public
-            try:
-                model = RadarDetectionModel(model_name=MODEL_NAME)
-            except Exception as e:
-                hf_token = os.getenv("HF_TOKEN")
-                if not hf_token:
-                    USE_DEMO_MODE = True
-                    return None, None
-                
-                model = RadarDetectionModel(model_name=MODEL_NAME, use_auth_token=hf_token)
-        except Exception as e:
+    # 如果已经初始化过模型，直接返回
+    if model is not None:
+        return model
+        
+    # 如果已经尝试过初始化并失败，使用演示模式
+    if MODEL_INIT_ATTEMPTED and model is None:
+        logger.info("已尝试过初始化模型但失败，使用演示模式")
+        USE_DEMO_MODE = True
+        return None
+    
+    # 标记为已尝试初始化
+    MODEL_INIT_ATTEMPTED = True
+    
+    # 检查是否在Hugging Face Space环境中运行
+    if is_running_in_space():
+        logger.info("在Hugging Face Space环境中运行")
+        
+        # 检查可用内存
+        available_memory = check_available_memory()
+        logger.info(f"可用内存: {available_memory:.2f}MB")
+        
+        if available_memory < 8000:  # 如果可用内存少于8GB
+            logger.warning(f"只有{available_memory:.2f}MB可用内存，可能不足以加载模型")
+            logger.info("使用演示模式以避免内存问题")
             USE_DEMO_MODE = True
-            return None, None
+            return None
     
-    return model, None
+    if USE_DEMO_MODE:
+        logger.info("使用演示模式 - 不会加载模型")
+        return None  # 在演示模式下使用模拟数据
+    
+    try:
+        # 从环境变量获取token
+        hf_token = os.environ.get("HF_TOKEN") or os.environ.get("HF_TOCKEN")
+        
+        logger.info(f"尝试加载模型 {MODEL_NAME}")
+        model = RadarDetectionModel(model_name=MODEL_NAME, use_auth_token=hf_token)
+        logger.info(f"成功加载模型 {MODEL_NAME}")
+        return model
+    except Exception as e:
+        logger.error(f"模型初始化错误: {str(e)}")
+        logger.info("由于模型加载错误，切换到演示模式")
+        USE_DEMO_MODE = True
+        return None
 
 def create_confidence_chart(scores, labels):
     """Create a bar chart for confidence scores"""
     if not scores or not labels:
         return None
-    
+
     df = pd.DataFrame({
         'Label': labels,
         'Confidence': [score * 100 for score in scores]
     })
-    
+
     fig = px.bar(
-        df, 
-        x='Label', 
+        df,
+        x='Label',
         y='Confidence',
         title='Detection Confidence Scores',
         labels={'Confidence': 'Confidence (%)'},
         color='Confidence',
         color_continuous_scale='viridis'
     )
-    
+
     fig.update_layout(
         xaxis_title='Detected Object',
         yaxis_title='Confidence (%)',
         yaxis_range=[0, 100],
         template='plotly_white'
     )
-    
+
     return fig
 
 def create_feature_radar_chart(features):
     """Create a radar chart for feature analysis"""
     categories = list(features.keys())
     values = []
-    
+
     # Convert text classifications to numeric values (1-5 scale)
     for feature in features.values():
         if "High" in feature:
@@ -246,16 +523,16 @@ def create_feature_radar_chart(features):
             values.append(1)
         else:
             values.append(0)
-    
+
     fig = go.Figure()
-    
+
     fig.add_trace(go.Scatterpolar(
         r=values,
         theta=categories,
         fill='toself',
         name='Feature Analysis'
     ))
-    
+
     fig.update_layout(
         polar=dict(
             radialaxis=dict(
@@ -266,108 +543,109 @@ def create_feature_radar_chart(features):
         title='Feature Analysis Radar Chart',
         template='plotly_white'
     )
-    
+
     return fig
 
 def create_heatmap(image_array):
     """Create a heatmap visualization of the image intensity"""
     if image_array is None:
         return None
-    
+
     # Convert to grayscale if needed
     if len(image_array.shape) == 3 and image_array.shape[2] == 3:
         gray_img = np.mean(image_array, axis=2)
     else:
         gray_img = image_array
-    
+
     fig = px.imshow(
         gray_img,
         color_continuous_scale='inferno',
         title='Signal Intensity Heatmap'
     )
-    
+
     fig.update_layout(
         xaxis_title='X Position',
         yaxis_title='Y Position',
         template='plotly_white'
     )
-    
+
     return fig
 
+def cleanup_memory():
+    """Attempt to clean up memory by forcing garbage collection"""
+    try:
+        import gc
+        gc.collect()
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+        print("Memory cleanup performed")
+    except Exception as e:
+        print(f"Error during memory cleanup: {str(e)}")
+
 def process_image_streaming(image, generate_tech_report=False, progress=gr.Progress()):
-    """Process image with streaming progress updates"""
+    """处理图像并提供流式进度更新"""
     if image is None:
-        raise gr.Error("Please upload an image.")
+        raise gr.Error("请上传一张图像。")
     
-    # Initialize model if needed
-    progress(0.1, desc="Initializing model...")
+    # 仅在需要时初始化模型
+    progress(0.1, desc="初始化模型...")
+    log_memory_usage("在process_image中初始化模型之前")
     global model, USE_DEMO_MODE
     
     if not USE_DEMO_MODE:
-        model, error = initialize_model()
-        if error:
-            progress(0.15, desc="Switching to demo mode...")
+        model = initialize_model()
+        if model is None:
+            progress(0.15, desc="切换到演示模式...")
             USE_DEMO_MODE = True
     
     try:
-        # Convert to PIL Image if needed
+        # 如果需要，将图像转换为PIL Image
         if isinstance(image, np.ndarray):
             image = Image.fromarray(image)
         
-        # Run detection
-        progress(0.2, desc="Running detection...")
+        # 运行检测
+        progress(0.2, desc="运行检测...")
+        log_memory_usage("检测之前")
         
         if USE_DEMO_MODE:
-            # Use mock detection results in demo mode
+            # 在演示模式下使用模拟检测结果
             detection_result = {
                 'boxes': [[100, 100, 200, 200], [300, 300, 400, 400]],
                 'scores': [0.92, 0.85],
-                'labels': ['Crack', 'Corrosion'],
+                'labels': ['裂缝', '腐蚀'],
                 'image': image
             }
         else:
-            detection_result = model.detect(image)
-        
-        # Extract features
-        progress(0.3, desc="Extracting 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]
-            if not isinstance(box, list):
-                box = box.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)
+            try:
+                detection_result = model.detect(image)
+                log_memory_usage("检测之后")
+            except Exception as e:
+                logger.error(f"检测过程中出错: {str(e)}")
+                # 如果检测失败，切换到演示模式
+                USE_DEMO_MODE = True
+                detection_result = {
+                    'boxes': [[100, 100, 200, 200], [300, 300, 400, 400]],
+                    'scores': [0.92, 0.85],
+                    'labels': ['错误', '备用'],
+                    'image': image
+                }
         
-        features = {
-            "Amplitude": amplitude_class,
-            "Distribution Range": distribution_class,
-            "Attenuation Rate": attenuation_class,
-            "Reflection Count": reflection_class
-        }
+        # 提取特征
+        progress(0.3, desc="提取特征...")
+        features = extract_features(image, detection_result)
         
-        # Create visualization charts
-        progress(0.5, desc="Creating visualizations...")
+        # 创建可视化图表
+        progress(0.5, desc="创建可视化...")
         confidence_chart = create_confidence_chart(
-            detection_result.get('scores', []), 
+            detection_result.get('scores', []),
             detection_result.get('labels', [])
         )
         
         feature_chart = create_feature_radar_chart(features)
-        heatmap = create_heatmap(np_image)
+        heatmap = create_heatmap(np.array(image))
         
-        # Start performance tracking
-        progress(0.6, desc="Analyzing performance...")
+        # 开始性能跟踪
+        progress(0.6, desc="分析性能...")
         start_time = time.time()
         performance_data = {
             'pipeline_stats': {},
@@ -375,7 +653,7 @@ def process_image_streaming(image, generate_tech_report=False, progress=gr.Progr
             'gpu_util': 0
         }
         
-        # Process image and get results
+        # 处理图像并获取结果
         stage_start = time.time()
         detection_results = detection_result
         detection_results['processing_time'] = (time.time() - stage_start) * 1000
@@ -384,7 +662,7 @@ def process_image_streaming(image, generate_tech_report=False, progress=gr.Progr
             'memory': get_memory_usage()
         }
         
-        # Extract features and analyze
+        # 提取特征并分析
         stage_start = time.time()
         model_outputs = {
             'feature_quality': 0.85,
@@ -399,7 +677,7 @@ def process_image_streaming(image, generate_tech_report=False, progress=gr.Progr
             'memory': get_memory_usage()
         }
         
-        # Perform multimodal analysis
+        # 执行多模态分析
         stage_start = time.time()
         multimodal_results = {
             'alignment_score': 0.78,
@@ -411,20 +689,20 @@ def process_image_streaming(image, generate_tech_report=False, progress=gr.Progr
             'memory': get_memory_usage()
         }
         
-        # Update performance data
+        # 更新性能数据
         performance_data['total_time'] = (time.time() - start_time) * 1000
         performance_data['peak_memory'] = get_peak_memory_usage()
         performance_data['gpu_util'] = get_gpu_utilization()
         
-        # Generate analysis report
-        progress(0.8, desc="Generating reports...")
+        # 生成分析报告
+        progress(0.8, desc="生成报告...")
         analysis_report = generate_report(detection_result, features)
         
-        # Prepare output
+        # 准备输出
         output_image = plot_detection(image, detection_result)
         
         if generate_tech_report:
-            # Prepare results for technical report
+            # 准备技术报告的数据
             tech_report_data = {
                 'model_outputs': model_outputs,
                 'detection_results': detection_results,
@@ -432,23 +710,29 @@ def process_image_streaming(image, generate_tech_report=False, progress=gr.Progr
                 'performance_data': performance_data
             }
             
-            # Generate technical report
+            # 生成技术报告
             tech_report = TechnicalReportGenerator().generate_report(tech_report_data)
             
-            # Save technical report to temporary file
+            # 将技术报告保存到临时文件
             report_path = "temp_tech_report.md"
             with open(report_path, "w") as f:
                 f.write(tech_report)
             
-            progress(1.0, desc="Analysis complete!")    
+            progress(1.0, desc="分析完成!")
+            # 处理完成后清理内存
+            cleanup_memory()
             return output_image, analysis_report, report_path, confidence_chart, feature_chart, heatmap
         
-        progress(1.0, desc="Analysis complete!")
+        progress(1.0, desc="分析完成!")
+        # 处理完成后清理内存
+        cleanup_memory()
         return output_image, analysis_report, None, confidence_chart, feature_chart, heatmap
         
     except Exception as e:
-        error_msg = f"Error processing image: {str(e)}"
+        error_msg = f"处理图像时出错: {str(e)}"
         print(error_msg)
+        # 出错后清理内存
+        cleanup_memory()
         raise gr.Error(error_msg)
 
 def display_history():
@@ -472,12 +756,25 @@ def display_history():
 def get_memory_usage():
     """Get current memory usage in MB"""
     process = psutil.Process()
-    return process.memory_info().rss / 1024 / 1024
+    memory_info = process.memory_info()
+    return memory_info.rss / 1024 / 1024
 
 def get_peak_memory_usage():
     """Get peak memory usage in MB"""
-    process = psutil.Process()
-    return process.memory_info().peak_wset / 1024 / 1024 if hasattr(process.memory_info(), 'peak_wset') else 0
+    try:
+        process = psutil.Process()
+        memory_info = process.memory_info()
+        if hasattr(memory_info, 'peak_wset'):
+            return memory_info.peak_wset / 1024 / 1024
+        else:
+            # On Linux, we can use /proc/self/status to get peak memory
+            with open('/proc/self/status') as f:
+                for line in f:
+                    if line.startswith('VmHWM:'):
+                        return float(line.split()[1]) / 1024  # Convert KB to MB
+    except:
+        pass
+    return 0
 
 def get_gpu_utilization():
     """Get GPU utilization percentage"""
@@ -488,128 +785,274 @@ def get_gpu_utilization():
         pass
     return 0
 
+def log_memory_usage(stage=""):
+    """Log current memory usage"""
+    mem_usage = get_memory_usage()
+    peak_mem = get_peak_memory_usage()
+    gpu_util = get_gpu_utilization()
+    print(f"Memory usage at {stage}: {mem_usage:.2f}MB (Peak: {peak_mem:.2f}MB, GPU: {gpu_util:.2f}%)")
+
 def toggle_dark_mode():
     """Toggle between light and dark themes"""
     global DARK_MODE
     DARK_MODE = not DARK_MODE
     return gr.Theme.darkmode() if DARK_MODE else THEME
 
+def get_space_upgrade_url():
+    """Get the URL for upgrading the Space"""
+    if not is_running_in_space():
+        return "#"
+
+    space_id = os.environ.get("SPACE_ID", "")
+    if not space_id:
+        return "https://huggingface.co/pricing"
+
+    # Extract username and space name
+    parts = space_id.split("/")
+    if len(parts) != 2:
+        return "https://huggingface.co/pricing"
+
+    username, space_name = parts
+    return f"https://huggingface.co/spaces/{username}/{space_name}/settings"
+
+def get_local_installation_instructions():
+    """Get instructions for running the app locally"""
+    required_memory = estimate_model_memory_requirements()
+    repo_url = get_repository_url()
+
+    return f"""
+    ## Running Locally
+
+    To run this application locally with the full model:
+
+    1. Clone the repository:
+       ```bash
+       git clone {repo_url}
+       cd radar-analysis
+       ```
+
+    2. Install dependencies:
+       ```bash
+       pip install -r requirements.txt
+       ```
+
+    3. Set your Hugging Face token as an environment variable:
+       ```bash
+       export HF_TOCKEN=your_huggingface_token
+       ```
+
+    4. Run the application:
+       ```bash
+       python app.py
+       ```
+
+    Make sure your system has at least {required_memory/1024:.1f}GB of RAM for optimal performance.
+    """
+
+def get_model_card_url():
+    """Get the URL for the model card"""
+    return f"https://huggingface.co/{MODEL_NAME}"
+
+def has_enough_memory_for_model():
+    """Check if we have enough memory for the model"""
+    if is_running_in_space():
+        # In Spaces, we need to be more cautious
+        hardware_memory = get_space_hardware_memory() * 1024  # Convert GB to MB
+        required_memory = estimate_model_memory_requirements()
+        print(f"Space hardware memory: {hardware_memory}MB, Required: {required_memory:.2f}MB")
+        return hardware_memory >= required_memory
+    else:
+        # For local development, check available memory
+        available_memory = check_available_memory()
+        required_memory = estimate_model_memory_requirements()
+        print(f"Available memory: {available_memory:.2f}MB, Required: {required_memory:.2f}MB")
+        return available_memory >= required_memory
+
+def get_repository_url():
+    """Get the URL for the repository"""
+    if is_running_in_space():
+        space_id = os.environ.get("SPACE_ID", "")
+        if space_id:
+            # Space ID is in the format "username/spacename"
+            return f"https://huggingface.co/spaces/{space_id}"
+        else:
+            return "https://huggingface.co/spaces/xingqiang/radar-analysis"
+    else:
+        return "https://huggingface.co/spaces/xingqiang/radar-analysis"
+
+def get_directory_name_from_repo_url(repo_url):
+    """Get the directory name from the repository URL"""
+    # Extract the last part of the URL
+    parts = repo_url.rstrip('/').split('/')
+    return parts[-1]
+
+# Launch the interface
+def launch():
+    """启动Gradio界面"""
+    if is_running_in_space():
+        # 在Spaces中，使用最小资源配置以避免内存问题
+        logger.info("使用最小资源配置启动Spaces")
+        iface.launch(
+            share=False,
+            server_name="0.0.0.0",
+            server_port=7860,
+            max_threads=4,  # 从10减少到4
+            show_error=True,
+            quiet=False
+        )
+    else:
+        # 对于本地开发，使用默认设置
+        iface.launch()
+
 # Create Gradio interface
 with gr.Blocks(theme=THEME) as iface:
     theme_state = gr.State(THEME)
-    
+
     with gr.Row():
-        gr.Markdown("# Radar Image Analysis System")
-        dark_mode_btn = gr.Button("🌓 Toggle Dark Mode", scale=0)
-    
+        gr.Markdown("# 雷达图像分析系统")
+        dark_mode_btn = gr.Button("🌓 切换暗黑模式", scale=0)
+
+    # 添加模型加载提示
+    gr.Markdown("""
+    ### ℹ️ 模型加载说明
+    - 模型仅在您点击"分析"按钮时才会下载和初始化
+    - 首次分析可能需要较长时间，因为需要下载模型
+    - 如果内存不足，系统会自动切换到演示模式
+    """, elem_id="model-loading-notice")
+
     if USE_DEMO_MODE:
-        gr.Markdown("""
-        ### ⚠️ Running in Demo Mode
-        The app is currently running in demo mode because access to the PaliGemma model is restricted.
-        
-        To use the full model capabilities:
-        1. Get access to the PaliGemma model at [Hugging Face](https://huggingface.co/google/paligemma-3b-ft-coco35l-224)
-        2. Add your Hugging Face token as an environment variable named `HF_TOKEN` in the Space settings
-        
-        Demo mode will show simulated results for demonstration purposes.
+        hardware_type = get_space_hardware_type() if is_running_in_space() else "N/A"
+        hardware_tier = get_space_hardware_tier() if is_running_in_space() else "N/A"
+        hardware_memory = get_space_hardware_memory() if is_running_in_space() else 0
+        total_memory = get_total_system_memory()
+        required_memory = estimate_model_memory_requirements()
+        recommended_tier = get_recommended_space_tier()
+        upgrade_url = get_space_upgrade_url()
+        model_card_url = get_model_card_url()
+
+        memory_info = f"Space硬件: {hardware_type} (等级: {hardware_tier}, 内存: {hardware_memory}GB)"
+        model_req = f"[PaliGemma模型]({model_card_url})在使用8位量化加载时需要约{required_memory/1024:.1f}GB内存"
+
+        gr.Markdown(f"""
+        ### ⚠️ 运行在演示模式
+        由于内存限制，应用程序当前在演示模式下运行:
+
+        1. **内存错误**: Space遇到"内存限制超过(16Gi)"错误
+           - {memory_info}
+           - 系统总内存: {total_memory:.2f}MB
+           - {model_req}
+
+        2. **解决方案**:
+           - 演示模式提供模拟结果用于演示目的
+           - 要使用完整模型，请在本地运行此应用程序，需要{required_memory/1024:.1f}GB+内存
+           - 或[升级到{recommended_tier} Space等级]({upgrade_url})或更高
+
+        演示模式仍提供所有UI功能和可视化特性。
         """, elem_id="demo-mode-warning")
-    
-    gr.Markdown("Upload a radar image to analyze defects and generate technical reports")
-    
+
+    gr.Markdown("上传雷达图像以分析缺陷并生成技术报告")
+
     with gr.Tabs() as tabs:
-        with gr.TabItem("Analysis", id="analysis"):
+        with gr.TabItem("分析", id="analysis"):
             with gr.Row():
                 with gr.Column(scale=1):
-                    with gr.Accordion("Input", open=True):
+                    with gr.Accordion("输入", open=True):
                         input_image = gr.Image(
-                            type="pil", 
-                            label="Upload Radar Image",
+                            type="pil",
+                            label="上传雷达图像",
                             elem_id="input-image",
                             sources=["upload", "webcam", "clipboard"],
                             tool="editor"
                         )
                         tech_report_checkbox = gr.Checkbox(
-                            label="Generate Technical Report", 
+                            label="生成技术报告",
                             value=False,
-                            info="Creates a detailed technical analysis report"
+                            info="创建详细的技术分析报告"
                         )
                         analyze_button = gr.Button(
-                            "Analyze", 
+                            "分析",
                             variant="primary",
                             elem_id="analyze-btn"
                         )
-                
+
                 with gr.Column(scale=2):
-                    with gr.Accordion("Detection Results", open=True):
+                    with gr.Accordion("检测结果", open=True):
                         output_image = gr.Image(
-                            type="pil", 
-                            label="Detection Result",
+                            type="pil",
+                            label="检测结果",
                             elem_id="output-image"
                         )
-                    
-                    with gr.Accordion("Analysis Report", open=True):
+
+                    with gr.Accordion("分析报告", open=True):
                         output_report = gr.HTML(
-                            label="Analysis Report",
+                            label="分析报告",
                             elem_id="analysis-report"
                         )
                         tech_report_output = gr.File(
-                            label="Technical Report",
+                            label="技术报告",
                             elem_id="tech-report"
                         )
-            
+
             with gr.Row():
                 with gr.Column():
                     confidence_plot = gr.Plot(
-                        label="Confidence Scores",
+                        label="置信度分数",
                         elem_id="confidence-plot"
                     )
-                
+
                 with gr.Column():
                     feature_plot = gr.Plot(
-                        label="Feature Analysis",
+                        label="特征分析",
                         elem_id="feature-plot"
                     )
-            
+
             with gr.Row():
                 heatmap_plot = gr.Plot(
-                    label="Signal Intensity Heatmap",
+                    label="信号强度热图",
                     elem_id="heatmap-plot"
                 )
-        
-        with gr.TabItem("History", id="history"):
+
+        with gr.TabItem("历史", id="history"):
             with gr.Row():
-                history_button = gr.Button("Refresh History")
+                history_button = gr.Button("刷新历史")
                 history_output = gr.HTML(elem_id="history-output")
-        
-        with gr.TabItem("Help", id="help"):
+
+        with gr.TabItem("帮助", id="help"):
             gr.Markdown("""
-            ## How to Use This Tool
-            
-            1. **Upload an Image**: Click the upload button to select a radar image for analysis
-            2. **Generate Technical Report** (Optional): Check this box if you want a detailed technical report
-            3. **Analyze**: Click the Analyze button to process the image
-            4. **View Results**: 
-               - The detection visualization shows identified defects
-               - The analysis report provides a summary of findings
-               - The technical report (if requested) offers detailed metrics
-               - Charts provide visual representation of confidence scores and feature analysis
-            
-            ## About the Model
-            
-            This system uses PaliGemma, a vision-language model that combines SigLIP-So400m (image encoder) and Gemma-2B (text decoder) for joint object detection and multimodal analysis.
-            
-            ## Keyboard Shortcuts
-            
-            - **Ctrl+A**: Trigger analysis
-            - **Ctrl+D**: Toggle dark mode
-            
-            ## Troubleshooting
-            
-            - If the analysis fails, try uploading a different image format
-            - Ensure the image is a valid radar scan
-            - For technical issues, check the console logs
+            ## 如何使用此工具
+
+            1. **上传图像**: 点击上传按钮选择要分析的雷达图像
+            2. **生成技术报告** (可选): 如果需要详细的技术报告，请勾选此框
+            3. **分析**: 点击分析按钮处理图像
+            4. **查看结果**:
+               - 检测可视化显示已识别的缺陷
+               - 分析报告提供发现的摘要
+               - 技术报告(如果请求)提供详细指标
+               - 图表提供置信度分数和特征分析的可视化表示
+
+            ## 关于模型
+
+            该系统使用[PaliGemma]({get_model_card_url()})，这是一个视觉-语言模型，结合了SigLIP-So400m(图像编码器)和Gemma-2B(文本解码器)进行联合目标检测和多模态分析。
+
+            该模型针对雷达图像分析进行了微调，可以检测结构检查图像中的各种类型的缺陷和异常。
             """)
-    
+
+            if USE_DEMO_MODE and is_running_in_space():
+                gr.Markdown(get_local_installation_instructions())
+
+            gr.Markdown("""
+            ## 键盘快捷键
+
+            - **Ctrl+A**: 触发分析
+            - **Ctrl+D**: 切换暗黑模式
+
+            ## 故障排除
+
+            - 如果分析失败，请尝试上传不同的图像格式
+            - 确保图像是有效的雷达扫描
+            - 对于技术问题，请查看控制台日志
+            """)
+
     # Set up event handlers
     dark_mode_btn.click(
         fn=toggle_dark_mode,
@@ -617,21 +1060,21 @@ with gr.Blocks(theme=THEME) as iface:
         outputs=[iface],
         api_name="toggle_theme"
     )
-    
+
     analyze_button.click(
         fn=process_image_streaming,
         inputs=[input_image, tech_report_checkbox],
         outputs=[output_image, output_report, tech_report_output, confidence_plot, feature_plot, heatmap_plot],
         api_name="analyze"
     )
-    
+
     history_button.click(
         fn=display_history,
         inputs=[],
         outputs=[history_output],
         api_name="history"
     )
-    
+
     # Add keyboard shortcuts
     iface.load(lambda: None, None, None, _js="""
         () => {
@@ -640,11 +1083,11 @@ with gr.Blocks(theme=THEME) as iface:
                     document.getElementById('analyze-btn').click();
                 }
                 if (e.key === 'd' && e.ctrlKey) {
-                    document.querySelector('button:contains("Toggle Dark Mode")').click();
+                    document.querySelector('button:contains("切换暗黑模式")').click();
                 }
             });
         }
     """)
 
 # Launch the interface
-iface.launch()
+launch()

config.py

@@ -2,7 +2,7 @@ import os
 
 BASE_DIR = os.path.dirname(os.path.abspath(__file__))
 
-MODEL_NAME = "Extremely4606/paligemma_9_19"
+MODEL_NAME = "Extremely4606/paligemma24_12_30"
 DATABASE_URL = f"sqlite:///{os.path.join(BASE_DIR, 'radar_reports.db')}"
 
 AMPLITUDE_THRESHOLD = 128

create_space.py

@@ -4,13 +4,23 @@ import sys
 
 def create_and_push_space():
     try:
+        # Get Hugging Face token from environment
+        hf_token = os.environ.get("HF_TOKEN")
+        if not hf_token:
+            print("Error: HF_TOKEN environment variable not set")
+            print("Please set your Hugging Face token as an environment variable:")
+            print("export HF_TOKEN=your_token_here")
+            sys.exit(1)
+            
         print("Creating Space...")
         # Create the space
+        api = HfApi(token=hf_token)
         repo_url = create_repo(
             repo_id="xingqiang/radar-analysis",
             repo_type="space",
             space_sdk="gradio",
-            private=False
+            private=False,
+            token=hf_token
         )
         print(f"Space created successfully at: {repo_url}")
         

feature_extraction.py

@@ -40,13 +40,30 @@ def classify_reflections(count):
 
 
 def extract_features(image, detection_result):
+    """
+    Extract features from the image and detection result.
+    
+    Args:
+        image: PIL Image
+        detection_result: Dictionary containing detection results
+        
+    Returns:
+        Dictionary of features
+    """
     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)
+    # Handle box calculation
+    if detection_result and 'boxes' in detection_result and len(detection_result['boxes']) > 0:
+        box = detection_result['boxes'][0]
+        if not isinstance(box, list):
+            box = box.tolist()
+        distribution_range = calculate_distribution_range(box)
+        distribution_class = classify_distribution_range(distribution_range)
+    else:
+        distribution_range = 0
+        distribution_class = "小"
 
     attenuation_rate = calculate_attenuation_rate(np_image)
     attenuation_class = classify_attenuation_rate(attenuation_rate)
@@ -59,8 +76,8 @@ def extract_features(image, detection_result):
         "分布范围": distribution_class,
         "衰减速度": attenuation_class,
         "反射次数": reflection_class,
-        "振幅值": amplitude,
-        "分布范围值": distribution_range,
-        "衰减速度值": attenuation_rate,
-        "反射次数值": reflection_count
+        "振幅值": float(amplitude),
+        "分布范围值": float(distribution_range),
+        "衰减速度值": float(attenuation_rate),
+        "反射次数值": int(reflection_count)
     }

model.py

@@ -6,101 +6,205 @@ import logging
 from transformers import AutoProcessor, AutoModelForVision2Seq
 from PIL import Image
 import numpy as np
+from config import MODEL_NAME
 
+# 配置日志记录
+logging.basicConfig(level=logging.INFO, 
+                   format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
 
 class RadarDetectionModel:
-    def __init__(self, model_name="Extremely4606/paligemma24_12_30", use_auth_token=None):
+    def __init__(self, model_name=None, use_auth_token=None):
         """
-        Initialize the radar detection model.
+        初始化雷达检测模型。
         
         Args:
-            model_name (str): The name or path of the model to load
-            use_auth_token (str, optional): Hugging Face token for accessing gated models
+            model_name (str): 要加载的模型名称或路径
+            use_auth_token (str, optional): 用于访问受限模型的Hugging Face令牌
         """
         self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        logger.info(f"使用设备: {self.device}")
         
-        # Load model and processor
-        if use_auth_token:
-            self.processor = AutoProcessor.from_pretrained(model_name, use_auth_token=use_auth_token)
-            self.model = AutoModelForVision2Seq.from_pretrained(model_name, use_auth_token=use_auth_token)
+        self.model_name = model_name if model_name else MODEL_NAME
+        logger.info(f"模型名称: {self.model_name}")
+        
+        self.use_auth_token = use_auth_token or os.environ.get("HF_TOKEN")
+        if self.use_auth_token:
+            logger.info("已提供Hugging Face令牌")
         else:
-            self.processor = AutoProcessor.from_pretrained(model_name)
-            self.model = AutoModelForVision2Seq.from_pretrained(model_name)
+            logger.warning("未提供Hugging Face令牌，可能无法访问受限模型")
+            
+        self.processor = None
+        self.model = None
+        
+        # 加载模型和处理器
+        logger.info("开始加载模型和处理器...")
+        self._load_model()
+        
+    def _load_model(self):
+        """加载模型和处理器，并监控内存使用情况"""
+        try:
+            logger.info(f"正在从{self.model_name}加载处理器")
+            start_time = torch.cuda.Event(enable_timing=True) if torch.cuda.is_available() else None
+            end_time = torch.cuda.Event(enable_timing=True) if torch.cuda.is_available() else None
+            
+            if start_time:
+                start_time.record()
+                
+            if self.use_auth_token:
+                # 如果提供了令牌，登录到Hugging Face Hub
+                logger.info("使用令牌登录到Hugging Face Hub")
+                login(token=self.use_auth_token)
+                self.processor = AutoProcessor.from_pretrained(self.model_name, use_auth_token=self.use_auth_token)
+            else:
+                self.processor = AutoProcessor.from_pretrained(self.model_name)
+            
+            if end_time:
+                end_time.record()
+                torch.cuda.synchronize()
+                logger.info(f"处理器加载时间: {start_time.elapsed_time(end_time):.2f}毫秒")
+            
+            logger.info(f"正在从{self.model_name}加载模型，使用8位量化以减少内存使用")
             
-        self.model.to(self.device)
-        self.model.eval()
+            if start_time:
+                start_time.record()
+                
+            # 使用8位量化以减少内存使用
+            if self.use_auth_token:
+                self.model = AutoModelForVision2Seq.from_pretrained(
+                    self.model_name, 
+                    use_auth_token=self.use_auth_token,
+                    load_in_8bit=True,  # 使用8位量化
+                    device_map="auto"   # 自动管理设备放置
+                )
+            else:
+                self.model = AutoModelForVision2Seq.from_pretrained(
+                    self.model_name,
+                    load_in_8bit=True,  # 使用8位量化
+                    device_map="auto"   # 自动管理设备放置
+                )
+            
+            if end_time:
+                end_time.record()
+                torch.cuda.synchronize()
+                logger.info(f"模型加载时间: {start_time.elapsed_time(end_time):.2f}毫秒")
+                
+            logger.info(f"模型加载成功")
+            # 使用device_map="auto"时无需手动移动到设备
+            self.model.eval()
+            
+            # 记录模型信息
+            param_count = sum(p.numel() for p in self.model.parameters())
+            logger.info(f"模型参数数量: {param_count:,}")
+            
+            if torch.cuda.is_available():
+                memory_allocated = torch.cuda.memory_allocated() / (1024 * 1024)
+                memory_reserved = torch.cuda.memory_reserved() / (1024 * 1024)
+                logger.info(f"GPU内存分配: {memory_allocated:.2f}MB")
+                logger.info(f"GPU内存保留: {memory_reserved:.2f}MB")
+                
+        except Exception as e:
+            logger.error(f"加载模型时出错: {str(e)}")
+            raise
         
     def detect(self, image):
         """
-        Detect objects in the radar image.
+        检测雷达图像中的对象。
         
         Args:
-            image (PIL.Image): The radar image to analyze
+            image (PIL.Image): 要分析的雷达图像
             
         Returns:
-            dict: Detection results including boxes, scores, and labels
+            dict: 检测结果，包括边界框、分数和标签
         """
-        # Preprocess image
-        inputs = self.processor(images=image, return_tensors="pt").to(self.device)
-        
-        # Run inference
-        with torch.no_grad():
-            outputs = self.model.generate(
-                **inputs,
-                max_length=50,
-                num_beams=4,
-                early_stopping=True
-            )
-        
-        # Process outputs
-        generated_text = self.processor.batch_decode(outputs, skip_special_tokens=True)[0]
-        
-        # Parse detection results from generated text
-        # This is a simplified example - actual parsing would depend on model output format
-        boxes, scores, labels = self._parse_detection_results(generated_text, image.size)
-        
-        return {
-            'boxes': boxes,
-            'scores': scores,
-            'labels': labels,
-            'image': image
-        }
+        try:
+            if self.model is None or self.processor is None:
+                raise ValueError("模型或处理器未正确初始化")
+                
+            # 预处理图像
+            logger.info("预处理图像")
+            inputs = self.processor(images=image, return_tensors="pt").to(self.device)
+            
+            # 运行推理
+            logger.info("运行模型推理")
+            start_time = torch.cuda.Event(enable_timing=True) if torch.cuda.is_available() else None
+            end_time = torch.cuda.Event(enable_timing=True) if torch.cuda.is_available() else None
+            
+            if start_time:
+                start_time.record()
+                
+            with torch.no_grad():
+                outputs = self.model.generate(
+                    **inputs,
+                    max_length=50,
+                    num_beams=4,
+                    early_stopping=True
+                )
+            
+            if end_time:
+                end_time.record()
+                torch.cuda.synchronize()
+                inference_time = start_time.elapsed_time(end_time)
+                logger.info(f"推理时间: {inference_time:.2f}毫秒")
+            
+            # 处理输出
+            generated_text = self.processor.batch_decode(outputs, skip_special_tokens=True)[0]
+            logger.info(f"生成的文本: {generated_text}")
+            
+            # 从生成的文本中解析检测结果
+            boxes, scores, labels = self._parse_detection_results(generated_text, image.size)
+            logger.info(f"检测到{len(boxes)}个对象")
+            
+            return {
+                'boxes': boxes,
+                'scores': scores,
+                'labels': labels,
+                'image': image
+            }
+        except Exception as e:
+            logger.error(f"检测过程中出错: {str(e)}")
+            # 返回备用检测结果
+            return {
+                'boxes': [[100, 100, 200, 200]],
+                'scores': [0.75],
+                'labels': ['错误: ' + str(e)[:50]],
+                'image': image
+            }
     
     def _parse_detection_results(self, text, image_size):
         """
-        Parse detection results from generated text.
+        从生成的文本中解析检测结果。
         
         Args:
-            text (str): Generated text from the model
-            image_size (tuple): Size of the input image (width, height)
+            text (str): 模型生成的文本
+            image_size (tuple): 输入图像的大小(宽度, 高度)
             
         Returns:
             tuple: (boxes, scores, labels)
         """
-        # This is a simplified example - actual parsing would depend on model output format
-        # For demonstration, we'll extract some mock detections
+        # 这是一个简化的示例 - 实际解析将取决于模型输出格式
+        # 为了演示，我们将提取一些模拟检测结果
         
-        # Check for common defect keywords in the text
+        # 检查文本中常见的缺陷关键词
         defects = []
         
-        if "crack" in text.lower():
-            defects.append(("Crack", 0.92, [0.2, 0.3, 0.4, 0.5]))
+        if "crack" in text.lower() or "裂缝" in text.lower():
+            defects.append(("裂缝", 0.92, [0.2, 0.3, 0.4, 0.5]))
         
-        if "corrosion" in text.lower():
-            defects.append(("Corrosion", 0.85, [0.6, 0.2, 0.8, 0.4]))
+        if "corrosion" in text.lower() or "腐蚀" in text.lower():
+            defects.append(("腐蚀", 0.85, [0.6, 0.2, 0.8, 0.4]))
             
-        if "damage" in text.lower():
-            defects.append(("Damage", 0.78, [0.1, 0.7, 0.3, 0.9]))
+        if "damage" in text.lower() or "损坏" in text.lower():
+            defects.append(("损坏", 0.78, [0.1, 0.7, 0.3, 0.9]))
             
-        if "defect" in text.lower():
-            defects.append(("Defect", 0.88, [0.5, 0.5, 0.7, 0.7]))
+        if "defect" in text.lower() or "缺陷" in text.lower():
+            defects.append(("缺陷", 0.88, [0.5, 0.5, 0.7, 0.7]))
         
-        # If no defects found, add a generic one
+        # 如果没有找到缺陷，添加一个通用的
         if not defects:
-            defects.append(("Anomaly", 0.75, [0.4, 0.4, 0.6, 0.6]))
+            defects.append(("异常", 0.75, [0.4, 0.4, 0.6, 0.6]))
         
-        # Convert normalized coordinates to pixel coordinates
+        # 将归一化坐标转换为像素坐标
         width, height = image_size
         boxes = []
         scores = []

requirements.txt

@@ -1,22 +1,24 @@
-gradio>=5.18.0
-torch>=2.1.2
-transformers>=4.37.2
-Pillow>=10.2.0
-numpy>=1.26.3
+gradio==4.19.2
+torch==2.1.2
+transformers==4.37.2
+pillow==10.1.0
+numpy==1.26.2
 matplotlib>=3.8.2
-pandas>=2.1.4
+pandas==2.1.3
 sqlalchemy>=2.0.25
-plotly>=5.18.0
+plotly==5.18.0
 scikit-learn>=1.3.2
 jinja2>=3.1.3
-huggingface-hub>=0.20.2
+huggingface-hub==0.20.2
 python-dotenv>=1.0.0
 markdown>=3.5.1
-psutil>=5.9.6
+psutil==5.9.6
 tqdm>=4.66.1
-accelerate>=0.25.0
+accelerate==0.25.0
 safetensors>=0.4.1
 peft>=0.7.1
 optimum>=1.14.0
 colorama>=0.4.6
-rich>=13.7.0
+rich>=13.7.0
+bitsandbytes==0.41.1
+scipy>=1.11.3

run.py

@@ -0,0 +1,38 @@
+import os
+import sys
+import logging
+from dotenv import load_dotenv
+
+# Load environment variables from .env file if it exists
+load_dotenv()
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, 
+                   format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+def main():
+    """Run the Radar Analysis System application"""
+    try:
+        # Check for HF_TOKEN environment variable
+        hf_token = os.environ.get("HF_TOKEN")
+        if not hf_token:
+            logger.warning("HF_TOKEN environment variable not set. The application will run in demo mode.")
+        else:
+            logger.info("HF_TOKEN environment variable found.")
+        
+        # Import app module
+        import app
+        
+        # Launch the application
+        logger.info("Starting Radar Analysis System...")
+        app.launch()
+        
+        return True
+    except Exception as e:
+        logger.error(f"Error running application: {str(e)}")
+        return False
+
+if __name__ == "__main__":
+    success = main()
+    sys.exit(0 if success else 1) 

test_app.py

@@ -0,0 +1,129 @@
+import os
+import sys
+import logging
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, 
+                   format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+def test_imports():
+    """测试所有必需的模块都可以导入"""
+    try:
+        import torch
+        logger.info(f"PyTorch版本: {torch.__version__}")
+        
+        import transformers
+        logger.info(f"Transformers版本: {transformers.__version__}")
+        
+        import numpy as np
+        logger.info(f"NumPy版本: {np.__version__}")
+        
+        import PIL
+        logger.info(f"PIL版本: {PIL.__version__}")
+        
+        import scipy
+        logger.info(f"SciPy版本: {scipy.__version__}")
+        
+        logger.info("所有导入成功")
+        return True
+    except ImportError as e:
+        logger.error(f"导入错误: {str(e)}")
+        return False
+
+def test_model_loading():
+    """测试模型可以加载"""
+    try:
+        from model import RadarDetectionModel
+        
+        # 检查是否设置了HF_TOKEN环境变量
+        hf_token = os.environ.get("HF_TOKEN")
+        if not hf_token:
+            logger.warning("未设置HF_TOKEN环境变量，使用公共模型进行测试")
+        
+        # 尝试初始化模型，使用较小的公共模型
+        logger.info("尝试初始化模型(使用较小的公共模型)")
+        model = RadarDetectionModel(model_name="google/siglip-base-patch16-224")
+        logger.info("模型初始化成功")
+        return True
+    except Exception as e:
+        logger.error(f"模型加载错误: {str(e)}")
+        return False
+
+def test_feature_extraction():
+    """测试特征提取功能"""
+    try:
+        import numpy as np
+        from PIL import Image
+        from feature_extraction import extract_features
+        
+        # 创建一个虚拟图像和检测结果
+        logger.info("创建虚拟测试数据")
+        dummy_image = Image.fromarray(np.random.randint(0, 255, (224, 224, 3), dtype=np.uint8))
+        dummy_detection = {
+            'boxes': [[50, 50, 100, 100]],
+            'scores': [0.9],
+            'labels': ['测试']
+        }
+        
+        # 提取特征
+        logger.info("提取特征")
+        features = extract_features(dummy_image, dummy_detection)
+        logger.info(f"提取的特征: {features}")
+        return True
+    except Exception as e:
+        logger.error(f"特征提取错误: {str(e)}")
+        return False
+
+def test_app_initialization():
+    """测试应用程序初始化但不加载模型"""
+    try:
+        logger.info("测试应用程序初始化")
+        import app
+        
+        # 检查应用程序是否已初始化但没有加载模型
+        logger.info("检查应用程序全局变量")
+        assert app.model is None, "模型不应该在导入时加载"
+        assert app.MODEL_INIT_ATTEMPTED is False, "模型初始化尝试标志应为False"
+        
+        logger.info("应用程序初始化测试通过")
+        return True
+    except Exception as e:
+        logger.error(f"应用程序初始化错误: {str(e)}")
+        return False
+
+def run_tests():
+    """运行所有测试"""
+    tests = [
+        ("导入测试", test_imports),
+        ("应用程序初始化测试", test_app_initialization),
+        ("模型加载测试", test_model_loading),
+        ("特征提取测试", test_feature_extraction)
+    ]
+    
+    results = []
+    for name, test_func in tests:
+        logger.info(f"运行{name}...")
+        try:
+            result = test_func()
+            results.append((name, result))
+            logger.info(f"{name}: {'通过' if result else '失败'}")
+        except Exception as e:
+            logger.error(f"{name}失败，错误: {str(e)}")
+            results.append((name, False))
+    
+    # 打印摘要
+    logger.info("\n--- 测试摘要 ---")
+    passed = sum(1 for _, result in results if result)
+    total = len(results)
+    logger.info(f"通过: {passed}/{total} 测试")
+    
+    for name, result in results:
+        status = "通过" if result else "失败"
+        logger.info(f"{name}: {status}")
+    
+    return passed == total
+
+if __name__ == "__main__":
+    success = run_tests()
+    sys.exit(0 if success else 1) 

utils.py

@@ -9,10 +9,12 @@ def plot_detection(image, detection_result):
     ax = plt.gca()
 
     for score, label, box in zip(detection_result["scores"], detection_result["labels"], detection_result["boxes"]):
-        x, y, w, h = box
-        rect = plt.Rectangle((x, y), w-x, h-y, fill=False, color='red')
+        x1, y1, x2, y2 = box
+        width = x2 - x1
+        height = y2 - y1
+        rect = plt.Rectangle((x1, y1), width, height, fill=False, color='red', linewidth=2)
         ax.add_patch(rect)
-        ax.text(x, y, f'{label}: {score:.2f}',
+        ax.text(x1, y1, f'{label}: {score:.2f}',
                 bbox=dict(facecolor='white', alpha=0.8))
 
     plt.axis('off')