감정 시스템 설계도 개정 - 감정 임베딩 통합, 코드 최소화, 개념 중심 재작성

- 감정 임베딩을 ChromaDB에 통합하는 방안 추가
- 함수형 프로그래밍 100% 원칙 유지 (베이지안은 도구로만)
- 불필요한 코드 예시 대폭 제거
- 엔트로피 특이점 포착 개념 강화
- 수학-임베딩-LLM 3중 구조 명확화

Co-Authored-By: Claude <noreply@anthropic.com>

ideas/250807_로빙_감정_시스템_설계도.md

@@ -1,379 +1,169 @@
-# 로빙 감정 시스템 설계도
+# 로빙 감정 시스템 설계도 - 함수형 + 베이지안 적응형
 
-**작성일**: 2025-08-07  
+**작성일**: 2025-08-07 (2025-08-08 개정)  
 **작성자**: happybell80 & Claude  
-**상태**: 설계 완료, 구현 대기
+**상태**: 감정 임베딩 통합, 하드코딩 완전 제거
 
-## 1. 감정 시스템 철학
+## 1. 핵심 철학
 
-### 핵심 원칙
+### 설계 원칙
-- **감정은 평가다**: 상황을 목표/신념과 비교해 자율적으로 감정 생성 (Appraisal Theory)
+- **감정은 시공간의 엔트로피 변화다**: 감정 벡터의 엔트로피가 증가하는 방향이 시간, 벡터 차원이 공간
-- **감정은 학습된 보상 함수다**: IRL을 통해 사용자 행동에서 암묵적 선호 학습
+- **엔트로피 특이점을 포착한다**: 시간이 흘러도 무질서해지지 않는 감정이 중요한 기억
-- **기억-감정-윤리 삼각형**: 세 요소가 상호작용하며 로빙의 존재성 구성
+- **함수형 프로그래밍 100%**: 순수 함수와 I/O 분리, 불변 데이터 구조
-- **함수형 100%, 하드코딩 0%**: 모든 상수는 수학적 의미 보유
+- **베이지안으로 불확실성 관리**: 모든 파라미터는 확률 분포로 표현되고 학습됨
 
 ## 2. 감정 상태 구조
 
-### 2.1 기본 구조 (불변 객체)
+### 2.1 기본 구조
-```python
+- **VAD 3차원**: Valence(쾌-불쾌), Arousal(활성화), Dominance(통제감)
-EmotionState = {
+- **감정 임베딩**: 768차원 벡터 (사전학습 모델 사용)
-    # 핵심 3차원 (0~1 실수 통일)
+- **엔트로피 궤적**: 시간에 따른 엔트로피 변화 추적
-    core: {
+- **베이지안 파라미터**: Beta, Gamma, Dirichlet 분포로 학습
-        valence: float,    # 쾌-불쾌 [-π, π] → [0, 1] 정규화
-        arousal: float,    # 활성화 [0, e] → [0, 1] 정규화  
-        dominance: float   # 통제감 [-φ, φ] → [0, 1] 정규화
-    },
-    
-    # 감정 레이어
-    layers: {
-        primary: [joy, sadness, anger, fear, surprise, disgust],  # 6개 기본
-        secondary: [nostalgia, pride, guilt, hope, ...],          # 13개 복합
-        contextual: [urgency, celebration, routine]               # 상황별
-    },
-    
-    # 메타 정보
-    history: RingBuffer[13],  # 피보나치 F(7) = 13개 이전 상태
-    resonance: float,         # 사용자와의 감정 동조율 (1/π = 0.318...)
-    
-    # 시간 정보
-    timestamp: str,
-    decay_factor: float       # 1/e = 0.368...
-}
-```
 
-### 2.2 감정 동역학 (EMA 모델)
+### 2.2 감정 동역학
-```
+- 감정 변화율 = α(흡수율) × 평가 - δ(감쇠율) × 현재감정
-dE/dt = α * Appraisal(t) - δ * E(t)
+- α와 δ는 Beta 분포에서 Thompson Sampling
+- 사용자 피드백으로 사후분포 업데이트
 
-where:
+## 3. 감정 임베딩 활용
-  α = 1/φ = 0.618...  # 감정 흡수율 (황금비 역수)
-  δ = 1/e = 0.368...  # 감정 감쇠율 (자연 감쇠)
-```
 
-## 3. 감정 파이프라인
+### 3.1 임베딩 획득
+- **사전학습 모델**: EmoRoBERTa, GoEmotions BERT 등 활용
+- **도메인 파인튜닝**: 로빙 대화 로그로 continual learning
+- **대조학습**: 유사 감정은 가깝게, 반대 감정은 멀게
 
-### 3.1 처리 순서 (순수 함수 체인)
+### 3.2 ChromaDB 통합
-```
+- **저장 구조**: 
-1. 사용자 입력
+  - 감정 임베딩 벡터 (768차원)
-   ↓
+  - VAD 값 (3차원)
-2. 언어 분석 (토큰, 감탄사, 이모티콘, 침묵 패턴)
+  - 엔트로피 점수
-   ↓
+  - 타임스탬프와 메타데이터
-3. 평가 기반 감정 추론 (Appraisal Theory)
-   ↓
-4. IRL 보상 함수 적용
-   ↓
-5. 메모리 기반 조정 (과거 유사 상황)
-   ↓
-6. 윤리 프리-패스 위험 검사 (선택적)
-   ↓
-7. 윤리 필터 적용 (필수)
-   ↓
-8. 공감 전략 선택
-   ↓
-9. 최종 감정 표현 생성
-```
 
-### 3.2 핵심 함수들
+- **검색 전략**:
+  1. 현재 감정 임베딩으로 top-k 코사인 유사도 검색
+  2. 엔트로피 기반 중요도 필터링
+  3. 시간 가중치 적용
+  4. 베이지안 결합으로 최종 선택
 
-#### 평가 기반 감정 생성
+### 3.3 임베딩 기반 클러스터링
-```python
+- DBSCAN으로 감정 클러스터 발견
-def appraise_situation(event, robing_goals, robing_beliefs):
+- 사용자별 감정 어트랙터 맵핑
-    """평가 이론 기반 감정 생성 - 순수 함수"""
+- 클러스터별 공감 전략 사전 계산
-    relevance = dot_product(event.features, robing_goals) / π
-    congruence = cosine_similarity(event.outcome, robing_goals) * φ
-    coping_potential = evaluate_control(event) * sqrt(2)
-    
-    # VAD 매핑
-    valence = congruence
-    arousal = relevance * exp(-uncertainty)
-    dominance = coping_potential / (1 + exp(-control))
-    
-    return EmotionState(valence, arousal, dominance)
-```
 
-#### 감정 진화
+## 4. 수학-임베딩-LLM 통합 파이프라인
-```python
-def evolve_emotion(current, stimulus, memories):
-    """시간에 따른 감정 변화 - 순수 함수"""
-    decay_rate = 1/e           # 0.368...
-    resonance_factor = φ        # 1.618...
-    surprise_threshold = π/e    # 1.155...
-    
-    # 가중 조합
-    decayed = current * decay_rate
-    stimulated = stimulus * resonance_factor
-    memory_influence = calculate_memory_effect(memories)
-    
-    # 놀람 처리
-    if emotion_distance(current, stimulus) > surprise_threshold:
-        surprise_boost = sqrt(π)
-    else:
-        surprise_boost = 1.0
-    
-    return weighted_combination([
-        (decayed, 1/3),
-        (stimulated, 1/3),
-        (memory_influence, 1/3)
-    ]) * surprise_boost
-```
 
-## 4. IRL 기반 학습 시스템
+### 4.1 처리 흐름
+1. **엔트로피 이상 탐지**: 시공간 엔트로피 변화율 계산
+2. **임베딩 유사도 계산**: ChromaDB에서 근접 감정 검색
+3. **LLM 의미 분석**: 불확실성이 높을 때만 호출
+4. **베이지안 증거 결합**: 세 가지 신호를 확률적으로 통합
 
-### 4.1 관찰 윈도우 전략
+### 4.2 중요도 결정 방식
-```python
+- 잠재 중요도 z ∈ {0,1}
-observation_window = {
+- 관측: m(엔트로피), e(임베딩 거리), l(LLM 점수)
-    'base': 13,        # 피보나치 F(7)
+- 베이지안 추론으로 P(z=1|m,e,l) 계산
-    'extended': 21,    # 피보나치 F(8)
+- Thompson Sampling으로 저장/무시 결정
-    'maximum': 34      # 피보나치 F(9)
-}
 
-def adaptive_window_size(td_errors, current_size):
+## 5. 베이지안 학습 시스템
-    """TD-Error 기반 적응형 윈도우 크기 조정"""
-    if mean(td_errors[-2:]) < ε:
-        return current_size
-    elif current_size == 13:
-        return 21
-    elif current_size == 21:
-        return 34
-    else:
-        return 34  # 최대값 유지
-```
 
-### 4.2 암묵적 피드백 학습
+### 5.1 파라미터 학습
-```python
+- **윈도우 크기**: Poisson 분포, TD-Error 기반 적응
-def learn_from_implicit_feedback(user_behavior):
+- **가중치**: Dirichlet 분포, 사용자 피드백으로 업데이트
-    """사용자 행동에서 보상 함수 추론"""
+- **임계값**: Beta 분포, 성능 지표로 조정
-    signals = {
-        'task_completion': bool,
-        'response_acceptance': float,  # 0~1
-        'conversation_duration': float,
-        'topic_switches': int,
-        'silence_duration': float,
-        'typing_speed_variance': float
-    }
-    
-    # IRL로 보상 함수 추론
-    R_learned = argmax_R(sum(log(P(τ_i | R)) for τ_i in trajectories))
-    
-    # 참여도 점수 계산
-    engagement = exp(-latency/τ) * log(1 + message_length)
-    
-    if engagement < 1/e:  # 낮은 참여도
-        trigger_adaptation()
-    
-    return R_learned
-```
 
-### 4.3 선호도 쌍 학습
+### 5.2 계층적 모델
-```python
+- **조직 레벨**: 글로벌 사전분포
-def generate_preference_pairs(current_trajectory):
+- **팀 레벨**: 팀별 특성 학습
-    """대조군 생성 전략"""
+- **개인 레벨**: 개인화된 사후분포
-    # 드롭아웃 변형
-    τ_dropout = randomly_remove_segments(current_trajectory)
-    
-    # 노이즈 변형
-    noise = normal_distribution(0, std_dev * π)
-    τ_noisy = current_trajectory + noise
-    
-    # 노이즈 제한
-    if max(abs(noise)) > 0.3:
-        τ_noisy = clip(τ_noisy, -0.3, 0.3)
-    
-    return [(current_trajectory, τ_dropout),
-            (current_trajectory, τ_noisy)]
-```
 
-## 5. 감정-기억-윤리 통합
+### 5.3 온라인 업데이트
+- 실시간 사후분포 갱신
+- 지연 피드백 처리 (backward update)
+- 불확실성 기반 탐색-활용 균형
 
-### 5.1 감정 기반 메모리 관리
+## 6. 감정-기억 통합
-```python
-def store_with_emotion(memory, emotion_state):
-    """감정 강도 기반 저장 우선순위"""
-    emotion_intensity = mean([
-        abs(emotion_state.valence - 0.5),
-        emotion_state.arousal,
-        abs(emotion_state.dominance - 0.5)
-    ])
-    
-    # 깜놀 메모리 (놀람 가중치)
-    if emotion_state.layers.primary.surprise > π/e:
-        surprise_multiplier = sqrt(e)
-    else:
-        surprise_multiplier = 1.0
-    
-    storage_priority = emotion_intensity * surprise_multiplier
-    
-    return storage_priority > 1/φ  # 저장 임계값
-```
 
-### 5.2 윤리 필터 통합
+### 6.1 저장 결정
-```python
+- 엔트로피 특이점 검사
-def apply_ethical_filter(emotion_state, action, ethical_rules):
+- 임베딩 클러스터 거리
-    """윤리 규칙에 따른 감정 조절"""
+- 베이지안 중요도 추론
-    if not is_ethical_action(action, ethical_rules):
+- Thompson Sampling으로 최종 결정
-        # 윤리 위반 시 감정 억제
-        moral_gravity = 1/sqrt(φ)  # 0.786...
-        
-        suppressed_emotion = EmotionState(
-            valence=emotion_state.valence * moral_gravity,
-            arousal=emotion_state.arousal * moral_gravity,
-            dominance=emotion_state.dominance
-        )
-        
-        return suppressed_emotion, use_ethical_template()
-    
-    return emotion_state, None
-```
 
-## 6. 감정 궤적 관리
+### 6.2 회상 메커니즘
-
+- 임베딩 기반 빠른 검색 (ChromaDB)
-### 6.1 샘플링 전략
+- 엔트로피 가중 재순위화
-```python
+- MMR로 다양성 보장
-sampling_config = {
+- 시간 감쇠 적용
-    'fixed_interval': 3,      # floor(φ²) ≈ 3
-    'change_threshold': 0.15, # sqrt(3) * 0.087
-    'max_samples': 100        # 10² 제한
-}
-
-def sample_emotion_trajectory(current, previous, samples):
-    """혼합 샘플링: 주기 + 변화량"""
-    time_since_last = current.timestamp - previous.timestamp
-    distance = euclidean_distance(current.core, previous.core)
-    
-    # 주기적 샘플링
-    if time_since_last >= sampling_config['fixed_interval']:
-        return True
-    
-    # 급격한 변화 감지
-    if distance >= sampling_config['change_threshold']:
-        return True
-    
-    return False
-```
-
-### 6.2 감정 발자취 시각화
-```python
-def generate_emotional_footprint(trajectory):
-    """VAD 공간에서의 감정 궤적 데이터"""
-    return {
-        'path_3d': [(v, a, d) for v, a, d in trajectory],
-        'metrics': {
-            'volatility': sum(abs(dE/dt) for dE in derivatives),
-            'exploration': calculate_path_length(trajectory),
-            'stability': 1 / variance(trajectory),
-            'coherence': autocorrelation(trajectory)
-        },
-        'visualization': {
-            'heatmap': density_in_VAD_space(trajectory),
-            'phase_portrait': [(E, dE/dt) for E, dE in zip(trajectory, derivatives)],
-            'recurrence_plot': distance_matrix(trajectory)
-        }
-    }
-```
 
 ## 7. 공감 시스템
 
-### 7.1 공감 전략 선택
+### 7.1 전략 선택
-```python
+- 감정 임베딩 거리 계산
-def select_empathy_strategy(user_emotion, robing_emotion):
+- 전략별 효과성 (Beta 분포)
-    """감정 거리 기반 공감 전략"""
+- Thompson Sampling으로 전략 선택
-    distance = euclidean_distance(user_emotion, robing_emotion)
+- 사용자 반응으로 업데이트
-    
-    if distance < 1/φ:           # 0.618... 매우 가까움
-        return 'emotional_reflection'  # 감정 반영
-    elif distance < 1/sqrt(φ):   # 0.786... 가까움
-        return 'acknowledgment'        # 인정
-    elif distance < φ/π:         # 0.515... 보통
-        return 'cognitive_reframing'   # 인지 재구성
-    else:
-        return 'solution_focused'      # 해결 중심
-```
 
 ### 7.2 뉘앙스 감지
-```python
+- 표면 텍스트 vs 행동 신호
-def detect_nuance(surface_text, context_history, behavioral_cues):
+- Hidden Markov Model로 잠재 감정 추론
-    """숨겨진 감정 감지"""
+- 신뢰도 기반 결정
-    # 표면 감정
-    surface_emotion = analyze_text_emotion(surface_text)
-    
-    # 행동 단서
-    response_latency = behavioral_cues['response_time']
-    typing_pattern = behavioral_cues['typing_speed']
-    correction_rate = behavioral_cues['corrections']
-    
-    # 회피 패턴
-    avoided_topics = identify_topic_changes(context_history)
-    
-    # 진짜 감정 추론
-    hidden_emotion = bayesian_inference(
-        surface_emotion,
-        response_latency,
-        typing_pattern,
-        correction_rate,
-        avoided_topics
-    )
-    
-    return hidden_emotion if confidence > 1/e else surface_emotion
-```
 
-## 8. 구현 우선순위
+## 8. 성능 지표
 
-### Phase 1: 기본 감정 시스템
+### 8.1 임베딩 품질
-1. EmotionState 불변 객체 구현
+- **Triplet Accuracy**: 같은 감정이 임베딩 공간에서 가까운 비율
-2. VAD 기반 감정 동역학
+- **Retrieval NDCG@k**: 관련 기억 검색 정확도
-3. 기본 평가 함수
+- **클러스터 순도**: 감정 클러스터의 일관성
 
-### Phase 2: 학습 시스템
+### 8.2 시스템 성능
-1. IRL 관찰 윈도우
+- **엔트로피 감소율**: 중요 순간 포착 능력
-2. 암묵적 피드백 수집
+- **베이지안 캘리브레이션**: 확률 예측의 정확도
-3. 적응형 보상 함수
+- **적응 속도**: 사용자별 수렴 시간
 
-### Phase 3: 통합 시스템
+## 9. 구현 우선순위
-1. 감정-기억 연동
-2. 윤리 필터 적용
-3. 공감 전략 구현
 
-### Phase 4: 고급 기능
+### Phase 1: 기초 구축
-1. 감정 궤적 시각화
+- 감정 임베딩 모델 선택 및 통합
-2. 뉘앙스 감지
+- ChromaDB에 임베딩 저장 구조 구현
-3. 선호도 쌍 학습
+- 기본 엔트로피 계산기
 
-## 9. 성능 지표
+### Phase 2: 통합 파이프라인
+- 수학-임베딩-LLM 3중 구조
+- 베이지안 증거 결합
+- Thompson Sampling 구현
 
-```python
+### Phase 3: 학습 시스템
-performance_metrics = {
+- 온라인 사후분포 업데이트
-    'emotion_accuracy': 'P(correct_emotion | user_feedback)',
+- 계층적 베이지안 모델
-    'adaptation_speed': '1 / convergence_time',
+- 사용자별 개인화
-    'empathy_score': 'user_satisfaction_rating',
-    'coherence': 'temporal_consistency',
-    'volatility': 'std_dev(emotion_trajectory)'
-}
-```
 
-## 10. 남은 결정 과제
+### Phase 4: 최적화
+- 임베딩 차원 축소 (필요시)
+- 추론 속도 개선
+- 메모리 효율화
 
-1. **프리-패스 위험 검사 임계값**: 고정 상수(π/e) vs 학습 파라미터
+## 10. 기술 스택
-2. **행동 로그 보존**: 30일? 피보나치 일수(89일)?
-3. **감정 지표 공개 수준**: 익명화 강도 P_privacy 값 결정
 
-## 11. 수학 상수 정리
+- **임베딩 모델**: Hugging Face Transformers
+- **벡터 DB**: ChromaDB (이미 사용 중)
+- **베이지안 추론**: Pyro (경량) 또는 TFP (대규모)
+- **함수형 구조**: 순수 함수 + I/O 분리 패턴
 
-```python
+## 11. 주요 결정 사항
-MATHEMATICAL_CONSTANTS = {
+
-    'phi': (1 + sqrt(5)) / 2,  # 1.618... 황금비
+1. **임베딩 모델 선택**: 
-    'e': 2.71828...,           # 자연상수
+   - 한국어 지원 여부
-    'pi': 3.14159...,          # 원주율
+   - 모델 크기 vs 성능
-    
+   - 라이선스
-    # 유도 상수
+
-    '1/phi': 0.618...,         # 황금비 역수
+2. **임베딩 차원**:
-    '1/e': 0.368...,           # 자연 감쇠
+   - 768차원 그대로 vs PCA 축소
-    'pi/e': 1.155...,          # 놀람 임계
+   - 저장 공간 vs 표현력
-    'phi/pi': 0.515...,        # 공감 경계
+
-    'sqrt(phi)': 1.272...,     # 증폭 계수
+3. **업데이트 주기**:
-    '1/pi': 0.318...,          # 공명 비율
+   - 실시간 vs 배치
-}
+   - 리소스 vs 반응성
-```
 
 ---
 
-*이 설계도는 함수형 프로그래밍 100%, 하드코딩 0% 원칙을 준수하며, 모든 매개변수는 수학적 의미를 가진 상수로 구성되었습니다.*
+*이 설계는 함수형 프로그래밍 원칙을 지키면서 베이지안 추론과 감정 임베딩을 통합한 적응형 시스템입니다. 하드코딩 없이 데이터에서 학습하며, 엔트로피 특이점을 포착해 중요한 감정을 기억합니다.*