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

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()

iints/analysis/hardware_benchmark.py

@@ -0,0 +1,221 @@
+import time
+import subprocess
+import threading
+import psutil
+import json
+from typing import Dict, List, Optional
+from dataclasses import dataclass, asdict
+
+@dataclass
+class PerformanceMetrics:
+    timestamp: float
+    cpu_usage: float
+    memory_usage: float
+    gpu_usage: Optional[float] = None
+    gpu_memory: Optional[float] = None
+    temperature: Optional[float] = None
+    power_consumption: Optional[float] = None
+
+class HardwareBenchmark:
+    """Hardware performance monitoring for Jetson and other platforms."""
+    
+    def __init__(self, sample_interval=1.0):
+        self.sample_interval = sample_interval
+        self.metrics_history = []
+        self.monitoring = False
+        self.monitor_thread = None
+        self.is_jetson = self._detect_jetson()
+        
+    def _detect_jetson(self) -> bool:
+        """Detect if running on Jetson platform."""
+        try:
+            with open('/proc/device-tree/model', 'r') as f:
+                model = f.read().strip()
+                return 'jetson' in model.lower()
+        except:
+            return False
+    
+    def _get_tegrastats_metrics(self) -> Optional[Dict]:
+        """Parse tegrastats output for Jetson-specific metrics."""
+        if not self.is_jetson:
+            return None
+            
+        try:
+            result = subprocess.run(['tegrastats', '--interval', '100'], 
+                                  capture_output=True, text=True, timeout=2)
+            if result.returncode == 0:
+                # Parse tegrastats output (simplified)
+                lines = result.stdout.strip().split('\n')
+                if lines:
+                    # Example parsing - adapt based on actual tegrastats format
+                    line = lines[-1]  # Get last line
+                    # This is a simplified parser - real implementation would be more robust
+                    return {"raw_tegrastats": line}
+        except:
+            pass
+        return None
+    
+    def _collect_metrics(self) -> PerformanceMetrics:
+        """Collect current performance metrics."""
+        timestamp = time.time()
+        
+        # CPU and Memory (cross-platform)
+        cpu_usage = psutil.cpu_percent(interval=0.1)
+        memory = psutil.virtual_memory()
+        memory_usage = memory.percent
+        
+        # GPU metrics (Jetson-specific)
+        gpu_usage = None
+        gpu_memory = None
+        temperature = None
+        power_consumption = None
+        
+        if self.is_jetson:
+            tegra_metrics = self._get_tegrastats_metrics()
+            if tegra_metrics:
+                # Parse tegrastats data here
+                # This is platform-specific and would need proper parsing
+                pass
+            
+            # Try to get temperature
+            try:
+                with open('/sys/class/thermal/thermal_zone0/temp', 'r') as f:
+                    temp_millicelsius = int(f.read().strip())
+                    temperature = temp_millicelsius / 1000.0
+            except:
+                pass
+        
+        return PerformanceMetrics(
+            timestamp=timestamp,
+            cpu_usage=cpu_usage,
+            memory_usage=memory_usage,
+            gpu_usage=gpu_usage,
+            gpu_memory=gpu_memory,
+            temperature=temperature,
+            power_consumption=power_consumption
+        )
+    
+    def _monitor_loop(self):
+        """Background monitoring loop."""
+        while self.monitoring:
+            metrics = self._collect_metrics()
+            self.metrics_history.append(metrics)
+            
+            # Keep only last 1000 samples to prevent memory issues
+            if len(self.metrics_history) > 1000:
+                self.metrics_history.pop(0)
+            
+            time.sleep(self.sample_interval)
+    
+    def start_monitoring(self):
+        """Start background performance monitoring."""
+        if not self.monitoring:
+            self.monitoring = True
+            self.monitor_thread = threading.Thread(target=self._monitor_loop, daemon=True)
+            self.monitor_thread.start()
+    
+    def stop_monitoring(self):
+        """Stop background performance monitoring."""
+        self.monitoring = False
+        if self.monitor_thread:
+            self.monitor_thread.join(timeout=2)
+    
+    def benchmark_algorithm(self, algorithm, test_data, iterations=100):
+        """Benchmark algorithm performance."""
+        self.start_monitoring()
+        
+        start_time = time.time()
+        start_metrics = self._collect_metrics()
+        
+        # Run algorithm iterations
+        for i in range(iterations):
+            # Simulate algorithm execution
+            if hasattr(algorithm, 'calculate_insulin'):
+                algorithm.calculate_insulin(
+                    current_glucose=test_data.get('glucose', 120),
+                    time_step=test_data.get('time_step', 5),
+                    carb_intake=test_data.get('carbs', 0)
+                )
+        
+        end_time = time.time()
+        end_metrics = self._collect_metrics()
+        
+        self.stop_monitoring()
+        
+        # Calculate performance statistics
+        total_time = end_time - start_time
+        avg_time_per_iteration = total_time / iterations
+        
+        # Get metrics during benchmark
+        benchmark_metrics = [m for m in self.metrics_history 
+                           if start_time <= m.timestamp <= end_time]
+        
+        if benchmark_metrics:
+            avg_cpu = sum(m.cpu_usage for m in benchmark_metrics) / len(benchmark_metrics)
+            avg_memory = sum(m.memory_usage for m in benchmark_metrics) / len(benchmark_metrics)
+            max_cpu = max(m.cpu_usage for m in benchmark_metrics)
+            max_memory = max(m.memory_usage for m in benchmark_metrics)
+        else:
+            avg_cpu = avg_memory = max_cpu = max_memory = 0
+        
+        return {
+            "algorithm_name": algorithm.__class__.__name__,
+            "iterations": iterations,
+            "total_time_seconds": total_time,
+            "avg_time_per_iteration_ms": avg_time_per_iteration * 1000,
+            "iterations_per_second": iterations / total_time,
+            "cpu_usage": {
+                "average": avg_cpu,
+                "maximum": max_cpu
+            },
+            "memory_usage": {
+                "average": avg_memory,
+                "maximum": max_memory
+            },
+            "platform": "Jetson" if self.is_jetson else "Generic",
+            "sample_count": len(benchmark_metrics)
+        }
+    
+    def get_current_metrics(self) -> Dict:
+        """Get current system metrics."""
+        metrics = self._collect_metrics()
+        return asdict(metrics)
+    
+    def get_metrics_summary(self) -> Dict:
+        """Get summary of collected metrics."""
+        if not self.metrics_history:
+            return {"error": "No metrics collected"}
+        
+        cpu_values = [m.cpu_usage for m in self.metrics_history]
+        memory_values = [m.memory_usage for m in self.metrics_history]
+        
+        return {
+            "sample_count": len(self.metrics_history),
+            "duration_seconds": self.metrics_history[-1].timestamp - self.metrics_history[0].timestamp,
+            "cpu_usage": {
+                "average": sum(cpu_values) / len(cpu_values),
+                "minimum": min(cpu_values),
+                "maximum": max(cpu_values)
+            },
+            "memory_usage": {
+                "average": sum(memory_values) / len(memory_values),
+                "minimum": min(memory_values),
+                "maximum": max(memory_values)
+            },
+            "platform": "Jetson" if self.is_jetson else "Generic"
+        }
+    
+    def export_metrics(self, filename: str):
+        """Export metrics to JSON file."""
+        data = {
+            "platform": "Jetson" if self.is_jetson else "Generic",
+            "sample_interval": self.sample_interval,
+            "metrics": [asdict(m) for m in self.metrics_history]
+        }
+        
+        with open(filename, 'w') as f:
+            json.dump(data, f, indent=2)
+    
+    def clear_metrics(self):
+        """Clear collected metrics."""
+        self.metrics_history.clear()

iints/analysis/metrics.py

@@ -0,0 +1,117 @@
+import pandas as pd
+from typing import Dict, Any, Tuple
+
+def calculate_tir(df: pd.DataFrame, lower_bound: float = 70.0, upper_bound: float = 180.0) -> float:
+    """
+    Calculates Time In Range (TIR) for glucose values.
+
+    Args:
+        df (pd.DataFrame): DataFrame containing simulation results, must have a 'glucose_actual_mgdl' column.
+        lower_bound (float): Lower bound for Time In Range (mg/dL).
+        upper_bound (float): Upper bound for Time In Range (mg/dL).
+
+    Returns:
+        float: Percentage of time in range (0-100).
+    """
+    if 'glucose_actual_mgdl' not in df.columns:
+        return float('nan') # Or raise error, returning nan for robustness in benchmark
+        # raise ValueError("DataFrame must contain 'glucose_actual_mgdl' column for TIR calculation.")
+
+    in_range = (df['glucose_actual_mgdl'] >= lower_bound) & (df['glucose_actual_mgdl'] <= upper_bound)
+    tir_percentage = in_range.mean() * 100
+    return tir_percentage
+
+def calculate_hypoglycemia(df: pd.DataFrame, threshold: float = 70.0) -> float:
+    """
+    Calculates percentage of time in hypoglycemia.
+
+    Args:
+        df (pd.DataFrame): DataFrame containing simulation results, must have a 'glucose_actual_mgdl' column.
+        threshold (float): Glucose threshold for hypoglycemia (mg/dL).
+
+    Returns:
+        float: Percentage of time in hypoglycemia (0-100).
+    """
+    if 'glucose_actual_mgdl' not in df.columns:
+        return float('nan')
+        # raise ValueError("DataFrame must contain 'glucose_actual_mgdl' column for hypoglycemia calculation.")
+    
+    hypo = (df['glucose_actual_mgdl'] < threshold)
+    hypo_percentage = hypo.mean() * 100
+    return hypo_percentage
+
+def calculate_hyperglycemia(df: pd.DataFrame, threshold: float = 180.0) -> float:
+    """
+    Calculates percentage of time in hyperglycemia.
+
+    Args:
+        df (pd.DataFrame): DataFrame containing simulation results, must have a 'glucose_actual_mgdl' column.
+        threshold (float): Glucose threshold for hyperglycemia (mg/dL).
+
+    Returns:
+        float: Percentage of time in hyperglycemia (0-100).
+    """
+    if 'glucose_actual_mgdl' not in df.columns:
+        return float('nan')
+        # raise ValueError("DataFrame must contain 'glucose_actual_mgdl' column for hyperglycemia calculation.")
+    
+    hyper = (df['glucose_actual_mgdl'] > threshold)
+    hyper_percentage = hyper.mean() * 100
+    return hyper_percentage
+
+def calculate_average_glucose(df: pd.DataFrame) -> float:
+    """
+    Calculates the average glucose value.
+
+    Args:
+        df (pd.DataFrame): DataFrame containing simulation results, must have a 'glucose_actual_mgdl' column.
+
+    Returns:
+        float: Average glucose value (mg/dL).
+    """
+    if 'glucose_actual_mgdl' not in df.columns:
+        return float('nan')
+        # raise ValueError("DataFrame must contain 'glucose_actual_mgdl' column for average glucose calculation.")
+    
+    return df['glucose_actual_mgdl'].mean()
+
+def generate_benchmark_metrics(df: pd.DataFrame) -> Dict[str, float]:
+    """
+    Generates a dictionary of key benchmark metrics from simulation results.
+
+    Args:
+        df (pd.DataFrame): DataFrame containing simulation results.
+
+    Returns:
+        Dict[str, float]: A dictionary of calculated metrics.
+    """
+    metrics = {
+        "TIR (%)": calculate_tir(df),
+        "Hypoglycemia (<70 mg/dL) (%)": calculate_hypoglycemia(df),
+        "Hyperglycemia (>180 mg/dL) (%)": calculate_hyperglycemia(df),
+        "Avg Glucose (mg/dL)": calculate_average_glucose(df),
+    }
+    return metrics
+
+if __name__ == "__main__":
+    # Example usage:
+    print("Running example for metrics.py")
+    # Create a dummy DataFrame for testing
+    data = {
+        'time_minutes': range(0, 60, 5),
+        'glucose_actual_mgdl': [100, 110, 150, 200, 170, 80, 60, 50, 90, 120, 140, 160]
+    }
+    dummy_df = pd.DataFrame(data)
+
+    print("\nDummy DataFrame:")
+    print(dummy_df)
+
+    metrics_results = generate_benchmark_metrics(dummy_df)
+    print("\nCalculated Metrics:")
+    for key, value in metrics_results.items():
+        print(f"- {key}: {value:.2f}")
+
+    # Test with custom ranges
+    print("\nCalculated Metrics (Custom TIR 80-140):")
+    custom_tir = calculate_tir(dummy_df, lower_bound=80, upper_bound=140)
+    print(f"- TIR (80-140 mg/dL): {custom_tir:.2f}%")