iints-sdk-python35 0.1.7__py3-none-any.whl

iints/analysis/diabetes_metrics.py

@@ -0,0 +1,43 @@
+import numpy as np
+import pandas as pd
+
+class DiabetesMetrics:
+    """Professional diabetes metrics for algorithm evaluation."""
+    
+    @staticmethod
+    def time_in_range(glucose_values, lower=70, upper=180):
+        """Calculate Time In Range (TIR) percentage."""
+        in_range = (glucose_values >= lower) & (glucose_values <= upper)
+        return (in_range.sum() / len(glucose_values)) * 100
+    
+    @staticmethod
+    def coefficient_of_variation(glucose_values):
+        """Calculate CV - variability metric."""
+        return (np.std(glucose_values) / np.mean(glucose_values)) * 100
+    
+    @staticmethod
+    def blood_glucose_risk_index(glucose_values, risk_type='high'):
+        """Calculate LBGI or HBGI."""
+        def risk_function(bg):
+            if risk_type == 'low':
+                return 10 * (1.509 * (np.log(bg)**1.084 - 5.381))**2 if bg < 112.5 else 0
+            else:  # high
+                return 10 * (1.509 * (np.log(bg)**1.084 - 5.381))**2 if bg > 112.5 else 0
+        
+        risks = [risk_function(bg) for bg in glucose_values]
+        return np.mean(risks)
+    
+    @staticmethod
+    def calculate_all_metrics(df, baseline=120):
+        """Calculate comprehensive metrics suite."""
+        glucose = df['glucose_actual_mgdl']
+        
+        return {
+            "peak_glucose_mgdl": glucose.max(),
+            "tir_percentage": DiabetesMetrics.time_in_range(glucose),
+            "cv_percentage": DiabetesMetrics.coefficient_of_variation(glucose),
+            "lbgi": DiabetesMetrics.blood_glucose_risk_index(glucose, 'low'),
+            "hbgi": DiabetesMetrics.blood_glucose_risk_index(glucose, 'high'),
+            "mean_glucose": glucose.mean(),
+            "glucose_std": glucose.std()
+        }

iints/analysis/edge_performance_monitor.py

@@ -0,0 +1,315 @@
+#!/usr/bin/env python3
+"""
+Edge AI Performance Monitor - IINTS-AF
+Jetson Nano performance validation for medical device standards
+"""
+
+import time
+import psutil
+import json
+from pathlib import Path
+from datetime import datetime
+import numpy as np
+
+class EdgeAIPerformanceMonitor:
+    """Monitor Jetson Nano performance for medical device validation"""
+    
+    def __init__(self):
+        self.performance_log = []
+        self.baseline_metrics = None
+        self.monitoring_active = False
+        
+    def start_monitoring(self):
+        """Start performance monitoring session"""
+        self.monitoring_active = True
+        self.baseline_metrics = self._capture_baseline()
+        
+        print("Edge AI Performance Monitoring Started")
+        print(f"Baseline CPU: {self.baseline_metrics['cpu_percent']:.1f}%")
+        print(f"Baseline Memory: {self.baseline_metrics['memory_mb']:.1f} MB")
+        print(f"Available Memory: {self.baseline_metrics['available_memory_mb']:.1f} MB")
+        
+    def measure_inference_latency(self, inference_function, input_data, iterations=100):
+        """Measure AI inference latency with statistical analysis"""
+        
+        if not self.monitoring_active:
+            self.start_monitoring()
+        
+        latencies = []
+        cpu_usage = []
+        memory_usage = []
+        
+        print(f"Measuring inference latency over {iterations} iterations...")
+        
+        for i in range(iterations):
+            # Pre-inference metrics
+            cpu_before = psutil.cpu_percent()
+            memory_before = psutil.virtual_memory().used / (1024 * 1024)  # MB
+            
+            # Measure inference time
+            start_time = time.perf_counter()
+            
+            try:
+                result = inference_function(input_data)
+            except Exception as e:
+                print(f"Inference error at iteration {i}: {e}")
+                continue
+            
+            end_time = time.perf_counter()
+            
+            # Post-inference metrics
+            cpu_after = psutil.cpu_percent()
+            memory_after = psutil.virtual_memory().used / (1024 * 1024)  # MB
+            
+            # Calculate metrics
+            latency_ms = (end_time - start_time) * 1000
+            cpu_delta = cpu_after - cpu_before
+            memory_delta = memory_after - memory_before
+            
+            latencies.append(latency_ms)
+            cpu_usage.append(cpu_delta)
+            memory_usage.append(memory_delta)
+            
+            # Log detailed metrics every 10 iterations
+            if (i + 1) % 10 == 0:
+                avg_latency = np.mean(latencies[-10:])
+                print(f"Iteration {i+1:3d}: Avg latency {avg_latency:.2f}ms")
+        
+        # Statistical analysis
+        performance_stats = self._analyze_performance_stats(latencies, cpu_usage, memory_usage)
+        
+        # Log performance session
+        self.performance_log.append({
+            'timestamp': datetime.now().isoformat(),
+            'test_type': 'inference_latency',
+            'iterations': len(latencies),
+            'statistics': performance_stats,
+            'raw_latencies_ms': latencies,
+            'cpu_usage_delta': cpu_usage,
+            'memory_usage_delta_mb': memory_usage
+        })
+        
+        return performance_stats
+    
+    def _analyze_performance_stats(self, latencies, cpu_usage, memory_usage):
+        """Analyze performance statistics for medical device validation"""
+        
+        if not latencies:
+            return {'error': 'No valid measurements'}
+        
+        latency_stats = {
+            'mean_ms': round(np.mean(latencies), 3),
+            'median_ms': round(np.median(latencies), 3),
+            'std_ms': round(np.std(latencies), 3),
+            'min_ms': round(np.min(latencies), 3),
+            'max_ms': round(np.max(latencies), 3),
+            'p95_ms': round(np.percentile(latencies, 95), 3),
+            'p99_ms': round(np.percentile(latencies, 99), 3)
+        }
+        
+        # Embedded system performance classification
+        mean_latency = latency_stats['mean_ms']
+        if mean_latency < 10:
+            performance_class = "SUB_10MS_LATENCY - Real-time capable"
+        elif mean_latency < 50:
+            performance_class = "SUB_50MS_LATENCY - Near real-time suitable"
+        elif mean_latency < 100:
+            performance_class = "SUB_100MS_LATENCY - Batch processing suitable"
+        else:
+            performance_class = "OPTIMIZATION_REQUIRED - Exceeds embedded constraints"
+        
+        # Consistency analysis (coefficient of variation)
+        cv_percent = (latency_stats['std_ms'] / latency_stats['mean_ms']) * 100
+        
+        if cv_percent < 5:
+            consistency_rating = "HIGHLY CONSISTENT"
+        elif cv_percent < 15:
+            consistency_rating = "CONSISTENT"
+        elif cv_percent < 30:
+            consistency_rating = "MODERATELY VARIABLE"
+        else:
+            consistency_rating = "HIGHLY VARIABLE - Investigate"
+        
+        return {
+            'latency_statistics': latency_stats,
+            'performance_classification': performance_class,
+            'consistency_rating': consistency_rating,
+            'coefficient_of_variation_percent': round(cv_percent, 2),
+            'cpu_impact': {
+                'mean_delta_percent': round(np.mean(cpu_usage), 2),
+                'max_delta_percent': round(np.max(cpu_usage), 2)
+            },
+            'memory_impact': {
+                'mean_delta_mb': round(np.mean(memory_usage), 2),
+                'max_delta_mb': round(np.max(memory_usage), 2)
+            },
+            'medical_device_assessment': self._assess_embedded_suitability(mean_latency, cv_percent)
+        }
+    
+    def _assess_embedded_suitability(self, mean_latency, cv_percent):
+        """Assess suitability for embedded system deployment"""
+        
+        # Embedded system criteria
+        criteria = {
+            'real_time_response': mean_latency < 100,  # < 100ms for real-time
+            'consistent_performance': cv_percent < 20,  # < 20% variation
+            'low_latency': mean_latency < 50,  # < 50ms preferred
+            'high_reliability': cv_percent < 10  # < 10% for high reliability
+        }
+        
+        passed_criteria = sum(criteria.values())
+        total_criteria = len(criteria)
+        
+        if passed_criteria == total_criteria:
+            suitability = "EMBEDDED_OPTIMAL - Compatible with real-time constraints"
+        elif passed_criteria >= 3:
+            suitability = "EMBEDDED_SUITABLE - Compatible with near real-time applications"
+        elif passed_criteria >= 2:
+            suitability = "RESEARCH_GRADE - Suitable for research and development"
+        else:
+            suitability = "OPTIMIZATION_REQUIRED - Requires performance tuning"
+        
+        return {
+            'suitability_rating': suitability,
+            'criteria_passed': f"{passed_criteria}/{total_criteria}",
+            'detailed_criteria': criteria,
+            'recommendations': self._generate_optimization_recommendations(criteria)
+        }
+    
+    def _generate_optimization_recommendations(self, criteria):
+        """Generate optimization recommendations based on failed criteria"""
+        
+        recommendations = []
+        
+        if not criteria['real_time_response']:
+            recommendations.append("Optimize model architecture for faster inference")
+        
+        if not criteria['consistent_performance']:
+            recommendations.append("Investigate system load variations and thermal throttling")
+        
+        if not criteria['low_latency']:
+            recommendations.append("Consider model quantization or pruning techniques")
+        
+        if not criteria['high_reliability']:
+            recommendations.append("Implement performance monitoring and adaptive scheduling")
+        
+        if not recommendations:
+            recommendations.append("Performance meets embedded system constraints")
+        
+        return recommendations
+    
+    def _capture_baseline(self):
+        """Capture baseline system metrics"""
+        
+        memory = psutil.virtual_memory()
+        
+        return {
+            'timestamp': datetime.now().isoformat(),
+            'cpu_percent': psutil.cpu_percent(interval=1),
+            'memory_mb': memory.used / (1024 * 1024),
+            'available_memory_mb': memory.available / (1024 * 1024),
+            'memory_percent': memory.percent,
+            'cpu_count': psutil.cpu_count(),
+            'cpu_freq_mhz': psutil.cpu_freq().current if psutil.cpu_freq() else 'Unknown'
+        }
+    
+    def generate_performance_report(self):
+        """Generate comprehensive performance report"""
+        
+        if not self.performance_log:
+            return "No performance data available"
+        
+        latest_session = self.performance_log[-1]
+        stats = latest_session['statistics']
+        
+        report = f"""
+EDGE AI PERFORMANCE VALIDATION REPORT
+=====================================
+
+Test Configuration:
+- Device: Jetson Nano (Edge AI Platform)
+- Test Date: {latest_session['timestamp'][:19]}
+- Iterations: {latest_session['iterations']}
+- Test Type: {latest_session['test_type']}
+
+INFERENCE PERFORMANCE:
+- Mean Latency: {stats['latency_statistics']['mean_ms']:.3f} ms
+- Median Latency: {stats['latency_statistics']['median_ms']:.3f} ms
+- 95th Percentile: {stats['latency_statistics']['p95_ms']:.3f} ms
+- 99th Percentile: {stats['latency_statistics']['p99_ms']:.3f} ms
+- Standard Deviation: {stats['latency_statistics']['std_ms']:.3f} ms
+
+PERFORMANCE CLASSIFICATION:
+- Overall Rating: {stats['performance_classification']}
+- Consistency: {stats['consistency_rating']}
+- Coefficient of Variation: {stats['coefficient_of_variation_percent']:.2f}%
+
+EMBEDDED SYSTEM ASSESSMENT:
+- Suitability: {stats['medical_device_assessment']['suitability_rating']}
+- Criteria Passed: {stats['medical_device_assessment']['criteria_passed']}
+
+SYSTEM IMPACT:
+- CPU Usage Delta: {stats['cpu_impact']['mean_delta_percent']:.2f}% (avg), {stats['cpu_impact']['max_delta_percent']:.2f}% (max)
+- Memory Usage Delta: {stats['memory_impact']['mean_delta_mb']:.2f} MB (avg), {stats['memory_impact']['max_delta_mb']:.2f} MB (max)
+
+RECOMMENDATIONS:
+"""
+        
+        for rec in stats['medical_device_assessment']['recommendations']:
+            report += f"- {rec}\n"
+        
+        return report
+    
+    def export_performance_data(self, filepath):
+        """Export performance data for analysis"""
+        
+        export_data = {
+            'export_timestamp': datetime.now().isoformat(),
+            'baseline_metrics': self.baseline_metrics,
+            'performance_sessions': self.performance_log,
+            'summary_report': self.generate_performance_report()
+        }
+        
+        with open(filepath, 'w') as f:
+            json.dump(export_data, f, indent=2, default=str)
+        
+        return filepath
+
+# Mock inference function for testing
+def mock_ai_inference(input_data):
+    """Mock AI inference function for testing"""
+    # Simulate neural network computation
+    time.sleep(0.008)  # 8ms base latency
+    
+    # Add some variability
+    time.sleep(np.random.exponential(0.002))  # Variable component
+    
+    return {"prediction": np.random.random(), "confidence": np.random.random()}
+
+def main():
+    """Test edge AI performance monitoring"""
+    monitor = EdgeAIPerformanceMonitor()
+    
+    print("IINTS-AF Edge AI Performance Validation")
+    print("=" * 45)
+    
+    # Test inference performance
+    test_input = {"glucose": 150, "trend": [145, 148, 150]}
+    
+    performance_stats = monitor.measure_inference_latency(
+        mock_ai_inference, test_input, iterations=50
+    )
+    
+    # Generate and display report
+    report = monitor.generate_performance_report()
+    print(report)
+    
+    # Export data
+    export_file = Path("results") / "edge_ai_performance.json"
+    export_file.parent.mkdir(exist_ok=True)
+    monitor.export_performance_data(export_file)
+    
+    print(f"\nPerformance data exported to: {export_file}")
+
+if __name__ == "__main__":
+    main()

iints/analysis/explainability.py

@@ -0,0 +1,94 @@
+import pandas as pd
+import numpy as np
+from typing import List, Dict, Any, Callable, Optional, Union, cast
+
+class ExplainabilityAnalyzer:
+    """
+    Provides tools for analyzing and explaining the behavior of insulin algorithms.
+    This module implements 'AI as explainability tool' by performing sensitivity analysis.
+    """
+    def __init__(self, simulation_results: pd.DataFrame):
+        self.results = simulation_results
+
+    def calculate_glucose_variability(self) -> Dict[str, float]:
+        """
+        Calculates basic metrics for glucose variability.
+        """
+        glucose_actual = self.results['glucose_actual_mgdl']
+        return {
+            "mean_glucose": glucose_actual.mean(),
+            "std_dev_glucose": glucose_actual.std(),
+            "min_glucose": glucose_actual.min(),
+            "max_glucose": glucose_actual.max(),
+            "time_in_range_70_180": (
+                ((glucose_actual >= 70) & (glucose_actual <= 180)).sum() / len(glucose_actual)
+            ) * 100
+        }
+
+    def analyze_insulin_response(self, algorithm_type: str = "") -> Dict[str, Any]:
+        """
+        Analyzes insulin delivery patterns.
+        """
+        total_insulin = self.results['delivered_insulin_units'].sum()
+        basal_insulin = self.results['basal_insulin_units'].sum()
+        bolus_insulin = self.results['bolus_insulin_units'].sum()
+        correction_bolus = self.results['correction_bolus_units'].sum() # May not exist for all algorithms
+
+        return {
+            "total_insulin_delivered": total_insulin,
+            "total_basal_insulin": basal_insulin,
+            "total_bolus_insulin": bolus_insulin,
+            "total_correction_bolus": correction_bolus,
+            "algorithm_type": algorithm_type # For context
+        }
+
+    def perform_sensitivity_analysis(self,
+                                     algorithm_instance: Any,
+                                     parameter_name: str,
+                                     original_value: float,
+                                     perturbations: List[float],
+                                     simulation_run_func: Callable[[Any, List[Any], int], pd.DataFrame],
+                                     fixed_events: Optional[List[Any]] = None,
+                                     duration_minutes: int = 1440 # 24 hours
+                                    ) -> Dict[float, Dict[str, Union[float, str]]]:
+        """
+        Performs a basic sensitivity analysis by perturbing one algorithm parameter
+        and observing the change in glucose metrics.
+
+        Args:
+            algorithm_instance (Any): An instance of the algorithm to test.
+            parameter_name (str): The name of the parameter to perturb (e.g., 'carb_ratio').
+            original_value (float): The original value of the parameter.
+            perturbations (List[float]): A list of values to test for the parameter.
+            simulation_run_func (Callable): A function that takes an algorithm instance,
+                                            a list of fixed events, and duration_minutes,
+                                            then returns simulation results (pd.DataFrame).
+            fixed_events (List[Any]): Optional list of events to apply in each simulation run.
+            duration_minutes (int): Duration for each simulation run.
+
+        Returns:
+            Dict[float, Dict[str, float]]: A dictionary where keys are the perturbed parameter values
+                                            and values are dictionaries of glucose metrics.
+        """
+        original_settings = algorithm_instance.settings.copy()
+        analysis_results = {}
+
+        for p_value in perturbations:
+            # Temporarily modify the parameter
+            algorithm_instance.settings[parameter_name] = p_value
+            algorithm_instance.reset() # Ensure algorithm state is reset
+
+            try:
+                # Call the provided simulation run function
+                perturbed_results_df = simulation_run_func(algorithm_instance, fixed_events or [], duration_minutes)
+                temp_analyzer = ExplainabilityAnalyzer(perturbed_results_df)
+                analysis_results[p_value] = temp_analyzer.calculate_glucose_variability()
+            except Exception as e:
+                print(f"Error during sensitivity analysis for {parameter_name}={p_value}: {e}")
+                analysis_results[p_value] = {"error": cast(Any, str(e))}
+
+        # Restore original settings
+        algorithm_instance.settings = original_settings
+        algorithm_instance.reset()
+
+        return analysis_results # type: ignore

iints/analysis/explainable_ai.py

@@ -0,0 +1,232 @@
+#!/usr/bin/env python3
+"""
+Explainable AI Audit Trail - IINTS-AF
+Clinical decision transparency system for medical AI validation
+"""
+
+import json
+from datetime import datetime, timedelta
+from pathlib import Path
+import numpy as np
+
+class ClinicalAuditTrail:
+    """Explainable AI system for clinical decision transparency"""
+    
+    def __init__(self):
+        self.audit_log = []
+        self.decision_context = {}
+        
+    def log_decision(self, timestamp, glucose_current, glucose_trend, insulin_decision, 
+                    algorithm_confidence, safety_override=False, context=None):
+        """Log AI decision with clinical reasoning"""
+        
+        # Calculate glucose velocity (mg/dL per minute)
+        glucose_velocity = self._calculate_velocity(glucose_trend)
+        
+        # Generate clinical reasoning
+        reasoning = self._generate_clinical_reasoning(
+            glucose_current, glucose_velocity, insulin_decision, 
+            algorithm_confidence, safety_override, context
+        )
+        
+        # Create audit entry
+        audit_entry = {
+            'timestamp': timestamp,
+            'glucose_mg_dL': glucose_current,
+            'glucose_velocity_per_min': glucose_velocity,
+            'insulin_decision_U': insulin_decision,
+            'algorithm_confidence': algorithm_confidence,
+            'safety_override': safety_override,
+            'clinical_reasoning': reasoning,
+            'risk_assessment': self._assess_immediate_risk(glucose_current, glucose_velocity),
+            'decision_category': self._categorize_decision(insulin_decision, glucose_current)
+        }
+        
+        self.audit_log.append(audit_entry)
+        return audit_entry
+    
+    def _calculate_velocity(self, glucose_trend):
+        """Calculate glucose rate of change"""
+        if not glucose_trend or len(glucose_trend) < 2:
+            return 0.0
+        
+        # Use last 3 readings for velocity calculation (15 minutes)
+        recent_readings = glucose_trend[-3:]
+        if len(recent_readings) < 2:
+            return 0.0
+        
+        # Calculate slope (mg/dL per 5-minute interval)
+        time_intervals = len(recent_readings) - 1
+        glucose_change = recent_readings[-1] - recent_readings[0]
+        velocity_per_5min = glucose_change / time_intervals
+        
+        # Convert to per-minute
+        return velocity_per_5min / 5.0
+    
+    def _generate_clinical_reasoning(self, glucose, velocity, insulin, confidence, override, context):
+        """Generate human-readable clinical reasoning"""
+        
+        reasoning_parts = []
+        
+        # Glucose status assessment
+        if glucose < 70:
+            reasoning_parts.append(f"Hypoglycemia detected ({glucose:.1f} mg/dL)")
+        elif glucose > 180:
+            reasoning_parts.append(f"Hyperglycemia detected ({glucose:.1f} mg/dL)")
+        else:
+            reasoning_parts.append(f"Glucose in target range ({glucose:.1f} mg/dL)")
+        
+        # Trend analysis
+        if abs(velocity) > 2.0:
+            direction = "rising" if velocity > 0 else "falling"
+            reasoning_parts.append(f"Rapid glucose {direction} at {abs(velocity):.1f} mg/dL/min")
+        elif abs(velocity) > 1.0:
+            direction = "increasing" if velocity > 0 else "decreasing"
+            reasoning_parts.append(f"Moderate glucose {direction} trend")
+        else:
+            reasoning_parts.append("Stable glucose trend")
+        
+        # Insulin decision reasoning
+        if insulin > 0:
+            if glucose > 150 and velocity > 1.0:
+                reasoning_parts.append(f"Corrective bolus {insulin:.2f}U for hyperglycemia with rising trend")
+            elif glucose > 180:
+                reasoning_parts.append(f"Correction bolus {insulin:.2f}U for hyperglycemia")
+            else:
+                reasoning_parts.append(f"Preventive insulin {insulin:.2f}U based on predictive model")
+        elif insulin < 0:
+            reasoning_parts.append(f"Basal reduction {abs(insulin):.2f}U to prevent hypoglycemia")
+        else:
+            reasoning_parts.append("No insulin adjustment - maintaining current therapy")
+        
+        # Confidence assessment
+        if confidence < 0.7:
+            reasoning_parts.append(f"Low AI confidence ({confidence:.2f}) - conservative approach")
+        elif confidence > 0.9:
+            reasoning_parts.append(f"High AI confidence ({confidence:.2f}) - optimal conditions")
+        
+        # Safety override explanation
+        if override:
+            reasoning_parts.append("SAFETY OVERRIDE: Decision modified by clinical safety supervisor")
+        
+        # Context-specific reasoning
+        if context:
+            if context.get('meal_detected'):
+                reasoning_parts.append("Meal bolus component included")
+            if context.get('exercise_detected'):
+                reasoning_parts.append("Exercise adjustment applied")
+            if context.get('sensor_noise'):
+                reasoning_parts.append("Sensor reliability considered")
+        
+        return ". ".join(reasoning_parts) + "."
+    
+    def _assess_immediate_risk(self, glucose, velocity):
+        """Assess immediate clinical risk"""
+        
+        # Predict glucose in 30 minutes
+        predicted_glucose = glucose + (velocity * 30)
+        
+        if glucose < 54 or predicted_glucose < 54:
+            return "CRITICAL - Severe hypoglycemia risk"
+        elif glucose < 70 or predicted_glucose < 70:
+            return "HIGH - Hypoglycemia risk"
+        elif glucose > 300 or predicted_glucose > 300:
+            return "HIGH - Severe hyperglycemia risk"
+        elif glucose > 250 or predicted_glucose > 250:
+            return "MODERATE - Hyperglycemia risk"
+        elif 70 <= predicted_glucose <= 180:
+            return "LOW - Target range maintained"
+        else:
+            return "MODERATE - Glucose excursion predicted"
+    
+    def _categorize_decision(self, insulin, glucose):
+        """Categorize the type of clinical decision"""
+        
+        if insulin > 1.0:
+            return "CORRECTIVE_BOLUS"
+        elif insulin > 0.1:
+            return "MICRO_BOLUS"
+        elif insulin < -0.1:
+            return "BASAL_REDUCTION"
+        elif glucose < 70:
+            return "HYPOGLYCEMIA_MANAGEMENT"
+        elif glucose > 180:
+            return "HYPERGLYCEMIA_MANAGEMENT"
+        else:
+            return "MAINTENANCE_THERAPY"
+    
+    def generate_clinical_summary(self, hours=24):
+        """Generate clinical summary for specified time period"""
+        
+        if not self.audit_log:
+            return "No clinical decisions recorded"
+        
+        recent_entries = self.audit_log[-int(hours * 12):]  # 12 entries per hour (5-min intervals)
+        
+        # Count decision types
+        decision_counts = {}
+        risk_levels = {}
+        total_insulin = 0
+        
+        for entry in recent_entries:
+            decision_type = entry['decision_category']
+            risk_level = entry['risk_assessment'].split(' - ')[0]
+            
+            decision_counts[decision_type] = decision_counts.get(decision_type, 0) + 1
+            risk_levels[risk_level] = risk_levels.get(risk_level, 0) + 1
+            total_insulin += entry['insulin_decision_U']
+        
+        # Generate summary
+        summary = f"Clinical Decision Summary ({hours}h period):\n"
+        summary += f"Total insulin delivered: {total_insulin:.2f}U\n"
+        summary += f"Decision types: {dict(decision_counts)}\n"
+        summary += f"Risk distribution: {dict(risk_levels)}\n"
+        
+        return summary
+    
+    def export_audit_trail(self, filepath):
+        """Export audit trail for clinical review"""
+        
+        audit_data = {
+            'export_timestamp': datetime.now().isoformat(),
+            'total_decisions': len(self.audit_log),
+            'audit_entries': self.audit_log,
+            'clinical_summary': self.generate_clinical_summary()
+        }
+        
+        with open(filepath, 'w') as f:
+            json.dump(audit_data, f, indent=2, default=str)
+        
+        return filepath
+
+def main():
+    """Test explainable AI audit trail"""
+    audit = ClinicalAuditTrail()
+    
+    # Simulate some clinical decisions
+    test_scenarios = [
+        (120, [115, 118, 120], 0.2, 0.85, False, None),  # Stable
+        (185, [170, 178, 185], 1.5, 0.92, False, {'meal_detected': True}),  # Rising
+        (65, [75, 70, 65], -0.8, 0.78, True, None),  # Falling with override
+    ]
+    
+    print("Explainable AI Clinical Audit Trail")
+    print("=" * 50)
+    
+    for i, (glucose, trend, insulin, confidence, override, context) in enumerate(test_scenarios):
+        timestamp = datetime.now() + timedelta(minutes=i*5)
+        
+        entry = audit.log_decision(
+            timestamp, glucose, trend, insulin, confidence, override, context
+        )
+        
+        print(f"\nDecision {i+1}:")
+        print(f"Time: {timestamp.strftime('%H:%M')}")
+        print(f"Clinical Reasoning: {entry['clinical_reasoning']}")
+        print(f"Risk Assessment: {entry['risk_assessment']}")
+        print(f"Decision Category: {entry['decision_category']}")
+    
+    print(f"\n{audit.generate_clinical_summary(1)}")
+
+if __name__ == "__main__":
+    main()