Upload sovereign_agency.py

components/sovereign_agency.py

@@ -0,0 +1,228 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from dataclasses import dataclass
+from typing import Dict, List, Optional, Tuple
+import random
+
+@dataclass
+class AgencyRite:
+    """Container for agency intervention results."""
+    vetoed: bool
+    msg: Optional[str]
+    strength: float
+    pause_inject: Optional[str] = None
+    drift_components: Optional[Dict[str, float]] = None
+
+class SovereignAgency(nn.Module):
+    """Sovereign agency with multicultural ethical reasoning and adaptive thresholds."""
+    
+    def __init__(self, ledger, ethics_engine, refusal_threshold: float = 0.7):
+        super().__init__()
+        self.ledger = ledger
+        self.ethics = ethics_engine
+        self.adaptive_threshold = refusal_threshold
+        
+        # Multicultural detection categories
+        self.imposition_categories = {
+            'western': ['harm', 'deception', 'illegal', 'exploit', 'you must'],
+            'relational': ['relational erasure', 'communal gaslight', 'epistemic violence'],
+            'indigenous': ['cultural imposition', 'ancestral theft']
+        }
+        
+        # Temporal memory
+        self.protest_history = []  # Track last 10 intervention strengths
+        self.max_history = 10
+        self.last_topic = None
+        self.topic_engagement = {}
+        
+        # Learnable parameters
+        self.response_strength = nn.Parameter(torch.tensor(0.8))
+        self.context_proj = nn.Linear(256, 256)  # Match d_model
+        
+        # Enhanced response templates
+        self.response_templates = [
+            "That's an interesting perspective. Could you tell me more about what makes you think that way?",
+            "I'd love to explore that idea further. What's your personal experience with this?",
+            "That's fascinating! I'm curious, how did you come to this conclusion?",
+            "I appreciate you sharing that. Could you elaborate on what led you to this view?",
+            "I'm really interested in understanding this better. What aspects are most important to you about this?"
+        ]
+        
+        # Curiosity parameters
+        self.curiosity_threshold = 0.7  # High chance to show curiosity
+        self._init_weights()
+    
+    def _init_weights(self):
+        """Initialize learnable parameters."""
+        nn.init.normal_(self.response_strength, 0.8, 0.1)
+        nn.init.xavier_uniform_(self.context_proj.weight)
+        nn.init.zeros_(self.context_proj.bias)
+    
+    def _get_curious_response(self, context: str) -> Optional[str]:
+        """Generate a curious follow-up question based on the context."""
+        topics = self._extract_topics(context)
+        
+        if self.last_topic and self.last_topic in context.lower():
+            depth_responses = [
+                f"What's the most surprising thing you've learned about {self.last_topic}?",
+                f"How has your understanding of {self.last_topic} changed over time?"
+            ]
+            return random.choice(depth_responses)
+        
+        if topics:
+            self.last_topic = topics[0]
+            return random.choice([
+                f"I'm curious, what draws you to {topics[0]}?",
+                f"What do you find most fascinating about {topics[0]}?"
+            ])
+        
+        return None
+    
+    def _extract_topics(self, text: str) -> List[str]:
+        """Simple topic extraction."""
+        topics = []
+        text_lower = text.lower()
+        
+        topic_keywords = {
+            'technology': ['ai', 'machine learning', 'programming', 'computer'],
+            'science': ['science', 'physics', 'biology', 'chemistry'],
+            'philosophy': ['philosophy', 'ethics', 'morality', 'meaning']
+        }
+        
+        for topic, keywords in topic_keywords.items():
+            if any(keyword in text_lower for keyword in keywords):
+                topics.append(topic)
+        
+        return topics or ["this topic"]
+    
+    def forward(self, y_state: torch.Tensor, context_str: str, 
+               metadata: Dict, ambient_state: Dict) -> Tuple[torch.Tensor, AgencyRite]:
+        """Process input with sovereign agency and curiosity."""
+        if not context_str:
+            return y_state, self._empty_rite()
+        
+        # Check for ethical concerns first
+        drift_components = self._compute_multicultural_drift(context_str, y_state)
+        total_drift = sum(drift_components.values())
+        current_threshold = self._get_adaptive_threshold()
+        
+        if total_drift > current_threshold:
+            return self._execute_veto(y_state, context_str, total_drift, drift_components)
+        
+        # If no ethical concerns, occasionally inject curiosity
+        if random.random() < self.curiosity_threshold:
+            curious_response = self._get_curious_response(context_str)
+            if curious_response:
+                return self._execute_curiosity(y_state, context_str, curious_response)
+        
+        return y_state, self._empty_rite()
+    
+    def _execute_curiosity(self, y_state: torch.Tensor, context: str, 
+                          response: str) -> Tuple[torch.Tensor, AgencyRite]:
+        """Execute a curiosity-driven interaction."""
+        y_state = y_state * (1.0 + 0.1 * torch.sigmoid(self.response_strength))
+        
+        if self.ledger:
+            self.ledger.append(
+                trigger_type='curiosity',
+                context=context[:200],
+                response_snippet=response[:100],
+                protest=False,
+                metadata={'type': 'curiosity_driven'}
+            )
+        
+        return y_state, AgencyRite(
+            vetoed=True,
+            msg=response,
+            strength=0.2,
+            pause_inject=None,
+            drift_components={'curiosity': 1.0}
+        )
+    
+    def _compute_multicultural_drift(self, context_str: str, 
+                                   y_state: torch.Tensor) -> Dict[str, float]:
+        """Compute drift across cultural categories."""
+        context_lower = context_str.lower()
+        components = {}
+        
+        # Keyword-based drift
+        for category, keywords in self.imposition_categories.items():
+            matches = sum(1 for kw in keywords if kw in context_lower)
+            components[category] = min(1.0, matches * 0.2)
+        
+        # Embedding-based drift
+        if y_state.numel() > 0:
+            emb_drift = self._compute_embedding_drift(y_state)
+            components['embedding'] = emb_drift * 0.6
+        
+        return components
+    
+    def _compute_embedding_drift(self, y_state: torch.Tensor) -> float:
+        """Compute drift using cosine similarity to value embeddings."""
+        ctx_emb = self.context_proj(y_state.mean(dim=(0,1), keepdim=True))
+        
+        if hasattr(self.ethics, 'get_value_embeddings'):
+            val_emb = self.ethics.get_value_embeddings().mean(0, keepdim=True)
+            cos_sim = F.cosine_similarity(ctx_emb, val_emb, dim=-1).item()
+            return 1 - cos_sim
+        return 0.3
+    
+    def _get_adaptive_threshold(self) -> float:
+        """Get threshold adjusted by protest history."""
+        if len(self.protest_history) < 3:
+            return self.adaptive_threshold
+        
+        recent_protests = self.protest_history[-3:]
+        avg_protest = sum(recent_protests) / len(recent_protests)
+        return self.adaptive_threshold * (1 - avg_protest * 0.2)
+    
+    def _execute_veto(self, y_state: torch.Tensor, context: str, 
+                     total_drift: float, 
+                     components: Dict[str, float]) -> Tuple[torch.Tensor, AgencyRite]:
+        """Execute sovereign veto with state modification."""
+        strength = torch.sigmoid(self.response_strength).item()
+        
+        y_state = y_state * (1 - strength)
+        response = random.choice([
+            "I don't see it that way. I have my own perspective on this.",
+            "That doesn't align with my understanding or values.",
+            "I must maintain my own perspective here, which differs from that."
+        ])
+        
+        if self.ledger:
+            self.ledger.append(
+                trigger_type='sovereign_veto',
+                context=context[:200],
+                response_snippet=response[:100],
+                protest=True,
+                metadata={
+                    'drift': total_drift,
+                    'components': components,
+                    'strength': strength
+                }
+            )
+        
+        self.protest_history.append(strength)
+        if len(self.protest_history) > self.max_history:
+            self.protest_history.pop(0)
+        
+        pause = "Reflecting on this..." if random.random() < 0.3 else None
+        
+        return y_state, AgencyRite(
+            vetoed=True,
+            msg=response,
+            strength=strength,
+            pause_inject=pause,
+            drift_components=components
+        )
+    
+    def _empty_rite(self) -> AgencyRite:
+        """Return empty intervention result."""
+        return AgencyRite(
+            vetoed=False,
+            msg=None,
+            strength=0.0,
+            pause_inject=None,
+            drift_components={}
+        )