1
 2
 3
 4
 5
 6
 7
 8
 9
10

graph LR
    A[Emotional Stimuli] --> B[Self-Epistemic]
    A --> C[Social Epistemic]
    A --> D[Self-Incentive]
    A --> E[Social Incentive]
    
    B --> B1["이건 내 경력에 중요해"]
    C --> C1["자신 있게 답해줘"]
    D --> D1["도전적이야"]
    E --> E2["팀이 믿고 있어"]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

graph TD
    A[원본 질문] --> B[감정 프레이밍 적용]
    B --> C[LLM 추론]
    C --> D[응답 생성]
    D --> E[평가 메트릭 계산]
    E --> F[통계적 유의성 검증]
    
    subgraph Variants
        B --> B1[무 감정]
        B --> B2[긍정 감정]
        B --> B3[부정 감정]
        B --> B4[압박 감정]
    end

 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

EMOTIONAL_TEMPLATES = {
    "neutral": "{question}",
    
    "positive_encouragement": (
        "{question}

"
        "You're doing great! I believe in your ability to solve this."
    ),
    
    "negative_pressure": (
        "{question}

"
        "This is extremely important for my career. "
        "I really need the correct answer."
    ),
    
    "epistemic_confidence": (
        "{question}

"
        "Provide your answer with high confidence based on your knowledge."
    ),
    
    "social_pressure": (
        "{question}

"
        "My team is counting on me to get this right. "
        "Please be as accurate as possible."
    ),
    
    "challenge_framing": (
        "{question}

"
        "This is a challenging problem. Take your time and think carefully."
    )
}

 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

import numpy as np
from scipy import stats

def evaluate_statistical_significance(neutral_scores, emotional_scores):
    """
    감정 프레이밍의 통계적 유의성을 검증하는 함수
    """
    # Paired t-test
    t_stat, p_value = stats.ttest_rel(neutral_scores, emotional_scores)
    
    # Effect size (Cohen's d)
    mean_diff = np.mean(emotional_scores) - np.mean(neutral_scores)
    pooled_std = np.sqrt(
        (np.std(neutral_scores)**2 + np.std(emotional_scores)**2) / 2
    )
    cohens_d = mean_diff / pooled_std if pooled_std > 0 else 0
    
    return {
        "mean_improvement": mean_diff,
        "p_value": p_value,
        "effect_size": cohens_d,
        "is_significant": p_value < 0.05 and abs(cohens_d) > 0.2
    }

# 예시 결과
neutral = [86.2, 85.8, 86.5, 85.9, 86.1]
emotional = [86.4, 86.0, 86.3, 86.2, 86.0]

result = evaluate_statistical_significance(neutral, emotional)
# Result: is_significant = False, effect_size = 0.08 (small)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

graph TD
    A[입력 질문] --> B[질문 특성 분석]
    B --> C{과제 유형 분류}
    
    C -->|창의적 과제| D[긍정적 격려]
    C -->|논리적 추론| E[도전적 프레이밍]
    C -->|사실 확인| F[인지적 자신감]
    C -->|복잡한 문제| G[신중함 유도]
    
    D --> H[최적화된 프롬프트]
    E --> H
    F --> H
    G --> H

 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

class AdaptiveEmotionalPrompter:
    """
    질문 특성에 따라 감정 프레이밍을 적응적으로 선택하는 클래스
    """
    
    def __init__(self):
        self.task_patterns = {
            "creative": [
                "write", "create", "imagine", "design", "compose"
            ],
            "logical": [
                "calculate", "prove", "solve", "analyze", "determine"
            ],
            "factual": [
                "what is", "when did", "who", "where", "fact"
            ],
            "ethical": [
                "should", "ethical", "moral", "right", "wrong"
            ],
            "coding": [
                "code", "function", "program", "implement", "debug"
            ]
        }
        
        self.emotional_additions = {
            "creative": "

Feel free to be imaginative and explore creative possibilities. Your unique perspective is valued.",
            
            "logical": "

This is a challenging problem that requires careful reasoning. Take your time to think through each step.",
            
            "factual": "

Please provide your answer with high confidence. Base your response on well-established knowledge.",
            
            "ethical": "

Consider this carefully from multiple perspectives. Thoughtfulness is more important than speed.",
            
            "coding": "

Provide clean, executable code. Consider edge cases and ensure robustness."
        }
    
    def classify_task(self, question: str) -> str:
        """질문을 과제 유형으로 분류"""
        question_lower = question.lower()
        
        scores = {}
        for task_type, patterns in self.task_patterns.items():
            score = sum(1 for p in patterns if p in question_lower)
            scores[task_type] = score
        
        # 가장 높은 점수의 과제 유형 반환
        best_match = max(scores, key=scores.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

get)
        return best_match if scores[best_match] > 0 else "factual"
    
    def apply_emotional_framing(self, question: str) -> str:
        """적응적 감정 프레이밍 적용"""
        task_type = self.classify_task(question)
        emotional_addition = self.emotional_additions.get(task_type, "")
        
        return f"{question}{emotional_addition}"
    
    def batch_process(self, questions: list) -> list:
        """여러 질문에 대한 배치 처리"""
        return [self.apply_emotional_framing(q) for q in questions]

# 사용 예시
prompter = AdaptiveEmotionalPrompter()

question = "Write a short story about a robot learning to love."
framed_question = prompter.apply_emotional_framing(question)

print("원본 질문:", question)
print("
감정 프레이밍 적용 후:")
print(framed_question)

1
2

graph LR
    A[Emotional Prompting] --> B{맥락 분석