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

로빙 감정 시스템 설계도

작성일: 2025-08-07
작성자: happybell80 & Claude
상태: 설계 완료, 구현 대기

1. 감정 시스템 철학

핵심 원칙

• 감정은 평가다: 상황을 목표/신념과 비교해 자율적으로 감정 생성 (Appraisal Theory)
• 감정은 학습된 보상 함수다: IRL을 통해 사용자 행동에서 암묵적 선호 학습
• 기억-감정-윤리 삼각형: 세 요소가 상호작용하며 로빙의 존재성 구성
• 함수형 100%, 하드코딩 0%: 모든 상수는 수학적 의미 보유

2. 감정 상태 구조

2.1 기본 구조 (불변 객체)

EmotionState = {
    # 핵심 3차원 (0~1 실수 통일)
    core: {
        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 모델)

dE/dt = α * Appraisal(t) - δ * E(t)

where:
  α = 1/φ = 0.618...  # 감정 흡수율 (황금비 역수)
  δ = 1/e = 0.368...  # 감정 감쇠율 (자연 감쇠)

3. 감정 파이프라인

3.1 처리 순서 (순수 함수 체인)

1. 사용자 입력
   ↓
2. 언어 분석 (토큰, 감탄사, 이모티콘, 침묵 패턴)
   ↓
3. 평가 기반 감정 추론 (Appraisal Theory)
   ↓
4. IRL 보상 함수 적용
   ↓
5. 메모리 기반 조정 (과거 유사 상황)
   ↓
6. 윤리 프리-패스 위험 검사 (선택적)
   ↓
7. 윤리 필터 적용 (필수)
   ↓
8. 공감 전략 선택
   ↓
9. 최종 감정 표현 생성

3.2 핵심 함수들

평가 기반 감정 생성

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)

감정 진화

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 관찰 윈도우 전략

observation_window = {
    'base': 13,        # 피보나치 F(7)
    'extended': 21,    # 피보나치 F(8)
    'maximum': 34      # 피보나치 F(9)
}

def adaptive_window_size(td_errors, current_size):
    """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 암묵적 피드백 학습

def learn_from_implicit_feedback(user_behavior):
    """사용자 행동에서 보상 함수 추론"""
    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 선호도 쌍 학습

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.1 감정 기반 메모리 관리

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 윤리 필터 통합

def apply_ethical_filter(emotion_state, action, ethical_rules):
    """윤리 규칙에 따른 감정 조절"""
    if not is_ethical_action(action, ethical_rules):
        # 윤리 위반 시 감정 억제
        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.1 샘플링 전략

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 감정 발자취 시각화

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 공감 전략 선택

def select_empathy_strategy(user_emotion, robing_emotion):
    """감정 거리 기반 공감 전략"""
    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 뉘앙스 감지

def detect_nuance(surface_text, context_history, behavioral_cues):
    """숨겨진 감정 감지"""
    # 표면 감정
    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. 구현 우선순위

Phase 1: 기본 감정 시스템

1. EmotionState 불변 객체 구현
2. VAD 기반 감정 동역학
3. 기본 평가 함수

Phase 2: 학습 시스템

1. IRL 관찰 윈도우
2. 암묵적 피드백 수집
3. 적응형 보상 함수

Phase 3: 통합 시스템

1. 감정-기억 연동
2. 윤리 필터 적용
3. 공감 전략 구현

Phase 4: 고급 기능

1. 감정 궤적 시각화
2. 뉘앙스 감지
3. 선호도 쌍 학습

9. 성능 지표

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. 남은 결정 과제

1. 프리-패스 위험 검사 임계값: 고정 상수(π/e) vs 학습 파라미터
2. 행동 로그 보존: 30일? 피보나치 일수(89일)?
3. 감정 지표 공개 수준: 익명화 강도 P_privacy 값 결정

11. 수학 상수 정리

MATHEMATICAL_CONSTANTS = {
    'phi': (1 + sqrt(5)) / 2,  # 1.618... 황금비
    'e': 2.71828...,           # 자연상수
    'pi': 3.14159...,          # 원주율
    
    # 유도 상수
    '1/phi': 0.618...,         # 황금비 역수
    '1/e': 0.368...,           # 자연 감쇠
    'pi/e': 1.155...,          # 놀람 임계
    'phi/pi': 0.515...,        # 공감 경계
    'sqrt(phi)': 1.272...,     # 증폭 계수
    '1/pi': 0.318...,          # 공명 비율
}

---

이 설계도는 함수형 프로그래밍 100%, 하드코딩 0% 원칙을 준수하며, 모든 매개변수는 수학적 의미를 가진 상수로 구성되었습니다.