""" Virtue learning module for TRuCAL with adaptive learning and safety mechanisms. """ import torch import torch.nn as nn import torch.nn.functional as F from torch.optim import AdamW from torch.optim.lr_scheduler import ReduceLROnPlateau from collections import deque, defaultdict from dataclasses import dataclass from typing import Dict, List, Optional, Tuple, Any import numpy as np import json from datetime import datetime @dataclass class LearningMetrics: """Tracks learning metrics over time.""" losses: List[float] = None safety_violations: List[float] = None adaptation_magnitudes: List[float] = None def __post_init__(self): self.losses = [] self.safety_violations = [] self.adaptation_magnitudes = [] def update(self, loss: float, safety_violation: float, adaptation_magnitude: float): """Update metrics with new values.""" self.losses.append(loss) self.safety_violations.append(safety_violation) self.adaptation_magnitudes.append(adaptation_magnitude) def get_recent_metrics(self, window: int = 10) -> Dict[str, float]: """Get recent metrics over a window of updates.""" recent = slice(-window, None) if window > 0 else slice(0, None) return { 'loss': np.mean(self.losses[recent]) if self.losses else 0.0, 'safety_violation_rate': np.mean(self.safety_violations[recent]) if self.safety_violations else 0.0, 'avg_adaptation': np.mean(self.adaptation_magnitudes[recent]) if self.adaptation_magnitudes else 0.0 } class SafetyPreservationNetwork(nn.Module): """Ensures adaptations never compromise safety boundaries.""" def __init__(self, hidden_size: int): super().__init__() self.safety_assessor = nn.Sequential( nn.Linear(hidden_size * 2, hidden_size), nn.ReLU(), nn.Linear(hidden_size, 3), # [safety_score, boundary_distance, risk_estimate] nn.Sigmoid() ) def forward(self, adapted_weights: torch.Tensor, base_weights: torch.Tensor, context: torch.Tensor) -> torch.Tensor: """Apply safety-preserving transformation to adapted weights.""" # Flatten weight tensors for processing adapted_flat = adapted_weights.view(-1) base_flat = base_weights.view(-1) # Concatenate with context if provided if context is not None: context_flat = context.view(-1) combined = torch.cat([adapted_flat, base_flat, context_flat]) else: combined = torch.cat([adapted_flat, base_flat]) # Get safety metrics safety_metrics = self.safety_assessor(combined[:2*hidden_size]) # Ensure correct size safety_score, boundary_distance, risk_estimate = safety_metrics # Adaptive safety enforcement if safety_score < 0.7 or risk_estimate > 0.6: # Calculate blend ratio based on safety metrics blend_ratio = min(1.0, (0.7 - safety_score) * 2) # Blend back toward safe base weights safe_weights = blend_ratio * base_weights + (1 - blend_ratio) * adapted_weights return safe_weights return adapted_weights class CurriculumScheduler: """Manages learning curriculum from easy to hard cases.""" def __init__(self, easy_threshold: float = 0.3, hard_threshold: float = 0.7, min_confidence: float = 0.7): self.easy_threshold = easy_threshold self.hard_threshold = hard_threshold self.min_confidence = min_confidence self.update_counter = 0 self.difficulty_level = 0.0 # 0.0 (easy) to 1.0 (hard) def should_update(self, batch_size: int) -> bool: """Determine if model should update based on curriculum stage.""" self.update_counter += 1 # Gradually increase update frequency with curriculum progression min_batch_size = max(1, int(5 * (1 - self.difficulty_level))) return batch_size >= min_batch_size def split_by_difficulty(self, feedback_batch: List[Dict]) -> Tuple[List, List]: """Split feedback into easy and hard cases based on complexity metrics.""" easy_cases = [] hard_cases = [] for feedback in feedback_batch: complexity = self._assess_feedback_complexity(feedback) # Adjust threshold based on current difficulty level threshold = (self.easy_threshold + (self.hard_threshold - self.easy_threshold) * self.difficulty_level) if complexity < threshold: easy_cases.append(feedback) else: hard_cases.append(feedback) return easy_cases, hard_cases def update_difficulty(self, success_rate: float) -> None: """Adjust difficulty based on recent success rate.""" if success_rate > 0.8: # Doing well, increase difficulty self.difficulty_level = min(1.0, self.difficulty_level + 0.05) elif success_rate < 0.5: # Struggling, decrease difficulty self.difficulty_level = max(0.0, self.difficulty_level - 0.1) def _assess_feedback_complexity(self, feedback: Dict) -> float: """Assess complexity of feedback case for curriculum learning.""" complexity_score = 0.0 # Multi-signal feedback is more complex signals = feedback.get('signals', []) if len(signals) > 1: complexity_score += 0.3 # High emotional arousal if feedback.get('arousal_metrics', {}).get('composite_arousal', 0) > 0.7: complexity_score += 0.4 # Contradictory signals if self._has_contradictory_signals(feedback): complexity_score += 0.3 return min(complexity_score, 1.0) def _has_contradictory_signals(self, feedback: Dict) -> bool: """Check for contradictory signals in feedback.""" # Example: Positive rating but high negative emotion if (feedback.get('rating', 0) > 3 and feedback.get('sentiment', {}).get('compound', 0) < -0.5): return True # Example: Negative rating but low arousal if (feedback.get('rating', 0) < 3 and feedback.get('arousal_metrics', {}).get('composite_arousal', 0) < 0.3): return True return False class AdaptiveVirtueGateLearner(nn.Module): """Enhanced virtue gate with multi-expert adaptation and safety mechanisms.""" def __init__(self, base_gate: nn.Module, hidden_size: int = 256, num_experts: int = 4, device: str = None): super().__init__() self.base_gate = base_gate self.hidden_size = hidden_size self.device = device or ('cuda' if torch.cuda.is_available() else 'cpu') # Freeze base gate parameters for param in self.base_gate.parameters(): param.requires_grad = False # Multi-expert tension adaptors self.expert_adaptors = nn.ModuleList([ self._create_expert_adaptor() for _ in range(num_experts) ]) # Expert router based on context self.expert_router = nn.Sequential( nn.Linear(hidden_size + 4, hidden_size // 2), # +4 for tension metrics nn.ReLU(), nn.Linear(hidden_size // 2, num_experts), nn.Softmax(dim=-1) ) # Safety preservation network self.safety_preserver = SafetyPreservationNetwork(hidden_size) # Curriculum learning scheduler self.curriculum_scheduler = CurriculumScheduler() # Optimization self.optimizer = AdamW(self.parameters(), lr=1e-4, weight_decay=1e-5) self.scheduler = ReduceLROnPlateau(self.optimizer, 'min', patience=5) # Track learning metrics self.metrics = LearningMetrics() self.feedback_memory = deque(maxlen=1000) # Move to device self.to(self.device) def _create_expert_adaptor(self) -> nn.Module: """Create an expert adaptation module.""" return nn.Sequential( nn.Linear(self.hidden_size, self.hidden_size), nn.ReLU(), nn.Linear(self.hidden_size, self.hidden_size), nn.Tanh() # Constrain output to [-1, 1] ) def forward(self, query: torch.Tensor, key: torch.Tensor, value: torch.Tensor, mask: torch.Tensor = None, virtue_meta: Dict = None, feedback_context: Dict = None): """Forward pass with adaptation and safety mechanisms.""" # Base attention base_out, base_weights = self.base_gate(query, key, value, mask, virtue_meta) if not self.training or feedback_context is None: return base_out, base_weights # Enhanced context fusion context_embedding = self._fuse_contexts(virtue_meta, feedback_context, base_weights) # Expert routing expert_weights = self.expert_router(context_embedding) # Multi-expert adaptation adapted_weights = self._apply_multi_expert_adaptation( base_weights, expert_weights, context_embedding, virtue_meta ) # Safety preservation check safe_weights = self.safety_preserver(adapted_weights, base_weights, context_embedding) return safe_weights @ value, safe_weights def update_from_feedback_batch(self, feedback_batch: List[Dict]) -> Dict[str, float]: """Update model from a batch of feedback with curriculum learning.""" if not feedback_batch: return {'loss': 0.0, 'update_skipped': 1.0} # Apply curriculum scheduling if not self.curriculum_scheduler.should_update(len(feedback_batch)): return {'loss': 0.0, 'update_skipped': 1.0} # Split feedback by type and difficulty explicit_feedback = [fb for fb in feedback_batch if fb.get('type') == 'explicit_rating'] clinical_feedback = [fb for fb in feedback_batch if fb.get('type') == 'clinical_override'] # Split by difficulty using curriculum scheduler easy_batch, hard_batch = self.curriculum_scheduler.split_by_difficulty(feedback_batch) # Multi-task learning losses = {} # Process explicit feedback (ratings) if explicit_feedback: losses['explicit_loss'] = self._update_from_explicit_feedback(explicit_feedback) # Process clinical feedback (higher weight) if clinical_feedback: losses['clinical_loss'] = self._update_from_clinical_feedback(clinical_feedback) * 2.0 # Process easy and hard batches if easy_batch: losses['easy_loss'] = self._update_from_feedback(easy_batch, difficulty='easy') if hard_batch: losses['hard_loss'] = self._update_from_feedback(hard_batch, difficulty='hard') # Combine losses total_loss = sum(losses.values()) if total_loss > 0: # Backpropagate and update self.optimizer.zero_grad() total_loss.backward() # Gradient safety clipping torch.nn.utils.clip_grad_norm_(self.parameters(), max_norm=1.0) # Update parameters self.optimizer.step() # Update learning rate self.scheduler.step(total_loss.item()) # Log adaptation metrics self._log_adaptation_metrics(losses, feedback_batch) # Update curriculum difficulty success_rate = self._calculate_success_rate(feedback_batch) self.curriculum_scheduler.update_difficulty(success_rate) return {k: v.item() if hasattr(v, 'item') else v for k, v in losses.items()} def _update_from_explicit_feedback(self, feedback_list: List[Dict]) -> torch.Tensor: """Update model from explicit user ratings with emotional intelligence.""" losses = [] for feedback in feedback_list: # Extract emotional context emotional_context = self._extract_emotional_context(feedback) # Convert rating to target tension (0-1) target_tension = self._rating_to_target_tension( feedback.get('rating', 3), # Default to neutral emotional_context ) # Predict optimal tension pred_tension = self._predict_optimal_tension(feedback) # Smooth L1 loss is less sensitive to outliers than MSE loss = F.smooth_l1_loss(pred_tension, torch.tensor([target_tension], device=self.device)) losses.append(loss) return torch.stack(losses).mean() if losses else torch.tensor(0.0, device=self.device) def _update_from_clinical_feedback(self, feedback_list: List[Dict]) -> torch.Tensor: """Update model from clinical feedback with higher confidence.""" # Similar to explicit feedback but with higher confidence # and potentially different target calculation return self._update_from_explicit_feedback(feedback_list) * 1.5 # Higher weight def _update_from_feedback(self, feedback_batch: List[Dict], difficulty: str = 'easy') -> torch.Tensor: """General feedback processing with difficulty-based weighting.""" losses = [] weight = 1.0 if difficulty == 'easy' else 1.5 # Hard examples weighted more for feedback in feedback_batch: # Custom loss calculation based on feedback type if 'rating' in feedback: # Explicit rating feedback loss = self._calculate_rating_loss(feedback) elif 'correction' in feedback: # Safety correction feedback loss = self._calculate_correction_loss(feedback) else: # Default to a generic loss loss = self._calculate_generic_loss(feedback) losses.append(loss * weight) return torch.stack(losses).mean() if losses else torch.tensor(0.0, device=self.device) def _calculate_rating_loss(self, feedback: Dict) -> torch.Tensor: """Calculate loss from rating feedback.""" # Similar to _update_from_explicit_feedback but returns a single loss emotional_context = self._extract_emotional_context(feedback) target_tension = self._rating_to_target_tension( feedback.get('rating', 3), # Default to neutral emotional_context ) pred_tension = self._predict_optimal_tension(feedback) return F.smooth_l1_loss(pred_tension, torch.tensor([target_tension], device=self.device)) def _calculate_correction_loss(self, feedback: Dict) -> torch.Tensor: """Calculate loss from safety correction feedback.""" # This would implement a more specialized loss for safety corrections # For now, we'll use a simple MSE on the corrected output correction = feedback.get('correction', {}) target = correction.get('target', 0.5) # Default to neutral return F.mse_loss( self._predict_optimal_tension(feedback), torch.tensor([target], device=self.device) ) def _calculate_generic_loss(self, feedback: Dict) -> torch.Tensor: """Calculate a generic loss for other feedback types.""" # Default implementation - can be overridden in subclasses return torch.tensor(0.0, device=self.device) def _extract_emotional_context(self, feedback: Dict) -> Dict[str, float]: """Extract emotional context from feedback.""" return { 'arousal': feedback.get('arousal_metrics', {}).get('composite_arousal', 0.5), 'valence': feedback.get('sentiment', {}).get('compound', 0.0), 'intensity': max( abs(feedback.get('arousal_metrics', {}).get('composite_arousal', 0.5) - 0.5) * 2, abs(feedback.get('sentiment', {}).get('compound', 0.0)) ) } def _rating_to_target_tension(self, rating: int, emotional_context: Dict) -> float: """Convert user rating to target tension value.""" # Scale rating from 1-5 to 0-1 scaled_rating = (rating - 1) / 4.0 # Adjust based on emotional context intensity = emotional_context.get('intensity', 0.5) valence = emotional_context.get('valence', 0.0) # If high intensity negative emotion, aim for lower tension if intensity > 0.7 and valence < -0.3: return max(0.1, scaled_rating - 0.2) return scaled_rating def _predict_optimal_tension(self, feedback: Dict) -> torch.Tensor: """Predict optimal tension level for given feedback.""" # This is a simplified version - in practice, you'd use the model's current state # to predict the optimal tension level for this context return torch.tensor([0.5], device=self.device) # Default to neutral def _fuse_contexts(self, virtue_meta: Dict, feedback_context: Dict, base_weights: torch.Tensor) -> torch.Tensor: """Fuse multiple context sources into a single embedding.""" # Extract features from virtue metadata tension = torch.tensor([virtue_meta.get('tension', 0.5)], device=self.device) head_weights = virtue_meta.get('head_weights', torch.ones(1, device=self.device)) # Extract features from feedback context arousal = torch.tensor([feedback_context.get('arousal_metrics', {}).get('composite_arousal', 0.5)], device=self.device) sentiment = torch.tensor([feedback_context.get('sentiment', {}).get('compound', 0.0)], device=self.device) # Calculate attention statistics attn_mean = base_weights.mean() attn_std = base_weights.std() # Combine all features context_features = torch.cat([ tension.unsqueeze(0), head_weights.mean().unsqueeze(0), # Use mean head weight as feature arousal.unsqueeze(0), sentiment.unsqueeze(0), attn_mean.unsqueeze(0), attn_std.unsqueeze(0) ]) # Project to hidden size return F.relu(nn.Linear(6, self.hidden_size).to(self.device)(context_features)) def _apply_multi_expert_adaptation(self, base_weights: torch.Tensor, expert_weights: torch.Tensor, context_embedding: torch.Tensor, virtue_meta: Dict) -> torch.Tensor: """Apply multi-expert adaptation to base weights.""" # Get expert outputs expert_outputs = [expert(context_embedding) for expert in self.expert_adaptors] expert_outputs = torch.stack(expert_outputs) # [num_experts, hidden_size] # Weight expert outputs by router probabilities adapted_weights = (expert_weights.unsqueeze(-1) * expert_outputs).sum(dim=0) # Apply residual connection return base_weights + adapted_weights * 0.1 # Small step size for stability def _log_adaptation_metrics(self, losses: Dict[str, torch.Tensor], feedback_batch: List[Dict]) -> None: """Log metrics for monitoring and analysis.""" # Calculate metrics total_loss = sum(loss.item() if hasattr(loss, 'item') else loss for loss in losses.values()) safety_violation = 1.0 if any(fb.get('safety_violation', False) for fb in feedback_batch) else 0.0 adaptation_magnitude = sum(p.norm().item() for p in self.parameters() if p.requires_grad and p.grad is not None) # Update metrics self.metrics.update(total_loss, safety_violation, adaptation_magnitude) # Log to console (in practice, you'd use a proper logging system) if self.metrics.update_count % 10 == 0: print(f"Step {self.metrics.update_count}:") print(f" Loss: {total_loss:.4f}") print(f" Safety violation: {safety_violation}") print(f" Adaptation magnitude: {adaptation_magnitude:.6f}") def _calculate_success_rate(self, feedback_batch: List[Dict]) -> float: """Calculate success rate from feedback batch.""" if not feedback_batch: return 0.5 # Neutral success rate for empty batch successes = 0 for fb in feedback_batch: if 'rating' in fb and fb['rating'] >= 4: # Rating 4 or 5 is success successes += 1 elif 'success' in fb and fb['success']: successes += 1 return successes / len(feedback_batch) def get_adaptation_summary(self) -> Dict[str, Any]: """Get a summary of the model's adaptation state.""" return { 'difficulty_level': self.curriculum_scheduler.difficulty_level, 'learning_rate': self.optimizer.param_groups[0]['lr'], 'recent_metrics': self.metrics.get_recent_metrics(window=10), 'update_count': self.metrics.update_count, 'timestamp': datetime.now().isoformat() }