Enhanced technical report generation with comprehensive analysis features

app.py

@@ -6,6 +6,8 @@ import os
 from pathlib import Path
 from datetime import datetime
 import tempfile
+import time
+import psutil
 
 from model import RadarDetectionModel
 from feature_extraction import (calculate_amplitude, classify_amplitude,
@@ -19,34 +21,119 @@ from database import save_report, get_report_history
 
 class TechnicalReportGenerator:
     def __init__(self):
-        self.timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        self.timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
     
-    def _generate_technical_section(self, detection_result, features):
-        """Generate technical analysis section of the report."""
-        tech_doc = "## Technical Analysis\n\n"
-        
-        # Detection Results
-        tech_doc += "### Detection Results\n\n```python\n"
-        tech_doc += f"Confidence Scores: {detection_result['scores'].tolist()}\n"
-        tech_doc += f"Bounding Boxes: {detection_result['boxes'].tolist()}\n"
-        tech_doc += f"Labels: {detection_result['labels'].tolist()}\n"
-        tech_doc += "```\n\n"
-        
-        # Feature Analysis
-        tech_doc += "### Feature Analysis\n\n"
-        for feature_name, value in features.items():
-            tech_doc += f"- **{feature_name}**: {value}\n"
-        
-        # Signal Processing Details
-        tech_doc += "\n### Signal Processing Metrics\n\n"
-        tech_doc += "| Metric | Value | Classification |\n"
-        tech_doc += "|--------|--------|----------------|\n"
-        tech_doc += f"|Amplitude|{features['Amplitude']}|{classify_amplitude(features['Amplitude'])}|\n"
-        tech_doc += f"|Distribution Range|{features['Distribution Range']}|{features['Distribution Range']}|\n"
-        tech_doc += f"|Attenuation Rate|{features['Attenuation Rate']}|{features['Attenuation Rate']}|\n"
-        tech_doc += f"|Reflection Count|{features['Reflection Count']}|{features['Reflection Count']}|\n"
-        
-        return tech_doc
+    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"
+        detection_section += "|--------|-------|\n"
+        detection_section += "| Detection Count | {} |\n".format(len(detection_results.get('boxes', [])))
+        detection_section += "| Average Confidence | {:.2f}% |\n".format(
+            np.mean(detection_results.get('scores', [0])) * 100
+        )
+        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(
+            mm_results.get('alignment_score', 0) * 100
+        )
+        mm_section += "- Cross-Modal Coherence: {:.2f}%\n".format(
+            mm_results.get('coherence_score', 0) * 100
+        )
+        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"
+        perf_section += "|-------|------------|-------------|\n"
+        pipeline_stages = perf_data.get('pipeline_stats', {})
+        for stage, stats in pipeline_stages.items():
+            perf_section += "| {} | {:.2f} | {:.2f} |\n".format(
+                stage,
+                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
@@ -108,28 +195,66 @@ def process_image(image, generate_tech_report=False):
             "Reflection Count": reflection_class
         }
         
-        # Generate report and visualizations
-        report = generate_report(detection_result, image, features)
-        detection_image = plot_detection(image, detection_result)
+        # Start performance tracking
+        start_time = time.time()
+        performance_data = {
+            'pipeline_stats': {},
+            'peak_memory': 0,
+            'gpu_util': 0
+        }
+        
+        # Process image and get results
+        stage_start = time.time()
+        detection_results = run_detection(image)
+        performance_data['pipeline_stats']['detection'] = {
+            'time': (time.time() - stage_start) * 1000,
+            'memory': get_memory_usage()
+        }
+        
+        # Extract features and analyze
+        stage_start = time.time()
+        model_outputs = extract_features(image)
+        performance_data['pipeline_stats']['feature_extraction'] = {
+            'time': (time.time() - stage_start) * 1000,
+            'memory': get_memory_usage()
+        }
+        
+        # Perform multimodal analysis
+        stage_start = time.time()
+        multimodal_results = analyze_multimodal(model_outputs)
+        performance_data['pipeline_stats']['multimodal_analysis'] = {
+            'time': (time.time() - stage_start) * 1000,
+            '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 reports
+        analysis_report = generate_analysis_report(detection_results)
         
-        # Generate technical report if requested
-        tech_report = None
         if generate_tech_report:
-            report_gen = TechnicalReportGenerator()
-            tech_report = report_gen._generate_technical_section(detection_result, features)
+            # Prepare results for technical report
+            tech_report_data = {
+                'model_outputs': model_outputs,
+                'detection_results': detection_results,
+                'multimodal_results': multimodal_results,
+                'performance_data': performance_data
+            }
             
-            # Save technical report to a temporary file
-            with tempfile.NamedTemporaryFile(mode='w', delete=False, suffix='.md') as f:
+            # 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)
-                tech_report = f.name
-        
-        # 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), tech_report
+                
+            return detection_results['image'], analysis_report, report_path
+            
+        return detection_results['image'], analysis_report, None
         
     except Exception as e:
         error_msg = f"Error processing image: {str(e)}"
@@ -154,6 +279,25 @@ def display_history():
     except Exception as e:
         return f"Error retrieving history: {str(e)}"
 
+def get_memory_usage():
+    """Get current memory usage in MB"""
+    process = psutil.Process()
+    return process.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
+
+def get_gpu_utilization():
+    """Get GPU utilization percentage"""
+    try:
+        if torch.cuda.is_available():
+            return torch.cuda.utilization() if hasattr(torch.cuda, 'utilization') else 0
+    except:
+        pass
+    return 0
+
 # Create Gradio interface
 css = """
 .gradio-container {max-width: 1200px !important}

requirements.txt

@@ -11,4 +11,5 @@ scikit-learn>=1.3.0
 jinja2>=3.1.2
 huggingface-hub>=0.19.0
 python-dotenv>=1.0.0
-markdown>=3.4.0
+markdown>=3.4.0
+psutil>=5.9.0