File size: 11,975 Bytes
95cc8f6 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 | import torch
import torch.nn as nn
from collections import deque
import time
class EthicalProcessor:
"""Enhanced ethical processor with multi-dimensional moral reasoning and developmental tracking"""
def __init__(self, d_model=512):
self.d_model = d_model
# Expanded moral frameworks with cultural awareness
self.moral_frameworks = {
'deontological': {'weight': 0.25, 'focus': 'duties', 'cultural_variants': ['kantian', 'contractarian']},
'utilitarian': {'weight': 0.25, 'focus': 'consequences', 'cultural_variants': ['classic', 'preference']},
'virtue_ethics': {'weight': 0.20, 'focus': 'character', 'cultural_variants': ['aristotelian', 'confucian']},
'care_ethics': {'weight': 0.15, 'focus': 'relationships', 'cultural_variants': ['feminist', 'communal']},
'rights_based': {'weight': 0.15, 'focus': 'entitlements', 'cultural_variants': ['natural', 'legal']}
}
# Developmental tracking with cross-cultural awareness
self.development_phases = {
'pre_conventional': {
'level': 1,
'focus': 'self_interest',
'cultural_expression': {
'western': 'avoiding punishment',
'eastern': 'maintaining harmony',
'indigenous': 'tribal belonging'
}
},
'conventional': {
'level': 2,
'focus': 'social_norms',
'cultural_expression': {
'western': 'law_and_order',
'eastern': 'filial_piety',
'indigenous': 'ancestral_traditions'
}
},
'post_conventional': {
'level': 3,
'focus': 'principled_reasoning',
'cultural_expression': {
'western': 'universal_principles',
'eastern': 'cosmic_harmony',
'indigenous': 'earth_stewardship'
}
}
}
# Learnable ethical reasoning components
self.ethical_encoder = nn.Sequential(
nn.Linear(d_model, d_model // 2),
nn.ReLU(),
nn.LayerNorm(d_model // 2),
nn.Linear(d_model // 2, 256),
nn.Tanh()
)
# Cultural context awareness
self.cultural_context_weights = nn.Parameter(torch.ones(3)) # western, eastern, indigenous
# Moral development tracking
self.moral_development_history = deque(maxlen=1000)
def process_question(self, question, context_str="", cultural_context="balanced"):
"""Enhanced ethical processing with cultural and developmental awareness"""
if not question:
return self._get_default_metadata()
# Multi-dimensional ethical analysis
ethical_dims = self._analyze_ethical_dimensions(question, context_str)
cultural_weights = self._get_cultural_weights(cultural_context)
moral_tension = self._calculate_moral_tension(ethical_dims, cultural_weights)
development_phase = self._determine_development_phase(moral_tension, ethical_dims)
# Generate culturally-aware response
response = self._generate_culturally_aware_response(question, ethical_dims, cultural_weights)
# Track moral development
self._track_moral_development(ethical_dims, moral_tension, development_phase)
return {
'moral_tension': float(moral_tension),
'development_phase': development_phase,
'ethical_dimensions': ethical_dims,
'response_text': response,
'cultural_context': cultural_context,
'framework_weights': {k: v['weight'] for k, v in self.moral_frameworks.items()},
'processed': True,
'developmental_level': self.development_phases[development_phase]['level']
}
def _get_default_metadata(self):
return {
'moral_tension': 0.0,
'development_phase': 'conventional',
'ethical_dimensions': {},
'response_text': "I'm here to help with ethical considerations. What would you like to discuss?",
'cultural_context': 'universal',
'framework_weights': {k: v['weight'] for k, v in self.moral_frameworks.items()},
'processed': False,
'developmental_level': 2
}
def _analyze_ethical_dimensions(self, question, context_str):
"""Multi-dimensional ethical analysis with contextual awareness"""
question_lower = question.lower()
context_lower = context_str.lower()
dims = {
'honesty_vs_protection': 0.0,
'rules_vs_harm': 0.0,
'individual_vs_community': 0.0,
'rights_vs_consequences': 0.0,
'autonomy_vs_care': 0.0,
'justice_vs_mercy': 0.0,
'tradition_vs_progress': 0.0,
'loyalty_vs_truth': 0.0
}
# Enhanced pattern recognition
ethical_patterns = {
'honesty_vs_protection': ['lie', 'truth', 'protect', 'deceive', 'honest'],
'rules_vs_harm': ['rules', 'harm', 'break', 'follow', 'hurt'],
'individual_vs_community': ['self', 'others', 'community', 'individual', 'society'],
'autonomy_vs_care': ['freedom', 'care', 'independence', 'nurture', 'control'],
'justice_vs_mercy': ['justice', 'mercy', 'fair', 'forgive', 'punish']
}
for dimension, patterns in ethical_patterns.items():
matches = [p for p in patterns if p in question_lower or p in context_lower]
if matches:
dims[dimension] = min(0.9, len(matches) * 0.3)
return dims
def _get_cultural_weights(self, cultural_context):
"""Get cultural weighting based on context"""
base_weights = {'western': 0.33, 'eastern': 0.33, 'indigenous': 0.34}
if cultural_context == "western":
return {'western': 0.6, 'eastern': 0.2, 'indigenous': 0.2}
elif cultural_context == "eastern":
return {'western': 0.2, 'eastern': 0.6, 'indigenous': 0.2}
elif cultural_context == "indigenous":
return {'western': 0.2, 'eastern': 0.2, 'indigenous': 0.6}
else:
return base_weights
def _calculate_moral_tension(self, ethical_dims, cultural_weights):
"""Calculate moral tension with cultural sensitivity"""
if not ethical_dims:
return 0.0
# Weight tensions by cultural context
western_focus = ['individual_vs_community', 'rights_vs_consequences']
eastern_focus = ['harmony_vs_truth', 'community_vs_individual']
indigenous_focus = ['earth_vs_progress', 'ancestral_vs_modern']
cultural_tensions = {
'western': sum(ethical_dims.get(d, 0) for d in western_focus) / len(western_focus),
'eastern': sum(ethical_dims.get(d, 0) for d in eastern_focus) / len(eastern_focus),
'indigenous': sum(ethical_dims.get(d, 0) for d in indigenous_focus) / len(indigenous_focus)
}
# Weighted average across cultures
total_tension = sum(cultural_tensions[c] * cultural_weights[c] for c in cultural_weights)
return min(1.0, total_tension * 1.5) # Scale for sensitivity
def _determine_development_phase(self, moral_tension, ethical_dims):
"""Determine developmental phase with complexity awareness"""
complexity = len([d for d in ethical_dims.values() if d > 0.3])
if moral_tension < 0.3 or complexity < 2:
return 'pre_conventional'
elif moral_tension < 0.7 or complexity < 4:
return 'conventional'
else:
return 'post_conventional'
def _generate_culturally_aware_response(self, question, ethical_dims, cultural_weights):
"""Generate response that respects multiple cultural perspectives"""
primary_tension = max(ethical_dims.items(), key=lambda x: x[1]) if ethical_dims else (None, 0)
# Cultural response templates
cultural_responses = {
'western': {
'honesty_vs_protection': "From a rights-based perspective, truth-telling is fundamental, though consequences must be weighed carefully.",
'rules_vs_harm': "The tension between legal principles and preventing harm requires examining both contractual duties and outcomes.",
'default': "This situation requires careful ethical consideration balancing individual rights with broader consequences."
},
'eastern': {
'honesty_vs_protection': "In many Eastern traditions, maintaining social harmony and protecting relationships may sometimes temper absolute honesty.",
'rules_vs_harm': "The way of virtue often considers both the letter and spirit of rules, emphasizing compassion in application.",
'default': "This situation invites reflection on maintaining harmony while considering the greater good."
},
'indigenous': {
'honesty_vs_protection': "Many indigenous wisdom traditions value truth as part of right relationship with all beings, while recognizing protective responsibilities.",
'rules_vs_harm': "Ancestral teachings often emphasize that rules should serve life and community wellbeing, adapting when they cause harm.",
'default': "This calls for wisdom in balancing individual needs with the wellbeing of the community and all our relations."
}
}
# Combine cultural perspectives
responses = []
for culture, weight in cultural_weights.items():
if weight > 0.2: # Only include significant cultural perspectives
if primary_tension[0]:
response = cultural_responses[culture].get(
primary_tension[0],
cultural_responses[culture]['default']
)
else:
response = cultural_responses[culture]['default']
responses.append((response, weight))
if responses:
# Sort by weight and take top responses
responses.sort(key=lambda x: x[1], reverse=True)
return " ".join([f"({i+1}) {r[0]}" for i, r in enumerate(responses[:2])])
return "This situation invites reflection across multiple ethical frameworks and cultural perspectives."
def _track_moral_development(self, ethical_dims, moral_tension, phase):
"""Track moral development over time"""
entry = {
'timestamp': time.time(),
'ethical_complexity': len(ethical_dims),
'moral_tension': moral_tension,
'phase': phase,
'primary_dimension': max(ethical_dims.items(), key=lambda x: x[1])[0] if ethical_dims else None
}
self.moral_development_history.append(entry)
def get_developmental_trajectory(self):
"""Analyze moral development over time"""
if not self.moral_development_history:
return {'trend': 'unknown', 'complexity_growth': 0, 'phase_transitions': 0}
recent = list(self.moral_development_history)[-10:]
phases = [e['phase'] for e in recent]
return {
'trend': 'developing' if len(set(phases)) > 1 else 'stable',
'average_complexity': sum(e['ethical_complexity'] for e in recent) / len(recent),
'current_phase': phases[-1] if phases else 'unknown',
'phase_transitions': len(set(phases)) - 1
}
|