2nd/10_Wiki/Topic_Programming/AI_and_ML/Emotionally Intelligent Tutoring Systems (EITS).md

id, title, category, status, canonical_id, aliases, duplicate_of, source_trust_level, confidence_score, verification_status, tags, raw_sources, last_reinforced, github_commit, tech_stack

id	title	category	status	canonical_id	aliases	duplicate_of	source_trust_level	confidence_score	verification_status	tags	raw_sources	last_reinforced	github_commit	tech_stack
wiki-2026-0508-emotionally-intelligent-tutoring	Emotionally Intelligent Tutoring Systems (EITS)	10_Wiki/Topics	verified	self	EITS affective tutor AutoTutor emotionally aware ITS	none	A	0.93	applied	edtech ai-tutor affective-computing eits emotion learning pedagogy		2026-05-10	pending	language framework Python Tutoring system / LLM

Emotionally Intelligent Tutoring Systems (EITS)

매 한 줄

"매 student 의 cognitive + emotional 의 동시 의 sense + respond 의 ITS". 매 frustration / boredom / confusion / engagement 의 detect → 매 strategy adjust. 매 famous: AutoTutor (Graesser), Affective AutoTutor. 매 modern: 매 LLM tutor + 매 facial / voice + 매 adaptive prompt.

매 핵심

매 emotion of learning (D'Mello)

• Engagement: 매 best.
• Confusion: 매 productive (zone of proximal).
• Frustration: 매 productive 의 X — 매 detect.
• Boredom: 매 challenge ↑.

매 affect detection

• Behavioral: 매 click, dwell, error.
• Facial: 매 brow furrow.
• Posture: 매 lean.
• Speech: 매 hesitation.
• Self-report: 매 emoji slider.

매 response strategy

• Frustration → 매 hint, scaffold.
• Boredom → 매 challenge ↑, novelty.
• Confusion → 매 dwell, allow.
• Engagement → 매 maintain.

매 응용

1. Math tutor: 매 step-by-step.
2. Language: 매 conversation practice.
3. Programming: 매 debug help.
4. Adaptive learning: 매 LMS.
5. Reading: 매 comprehension.

💻 패턴

Affect detection (multimodal)

class AffectDetector:
    def __init__(self):
        self.face = FacialAnalyzer()
        self.behavior = BehaviorTracker()
    
    def detect(self, frame, log):
        return {
            'engagement': 0.6 * self.face.attention(frame) + 0.4 * self.behavior.click_rate(log),
            'frustration': self.face.brow_furrow(frame) + self.behavior.delete_count(log),
            'confusion': self.behavior.idle_time(log),
            'boredom': self.face.yawn_count(frame) + self.behavior.skip_count(log),
        }

Strategy selector

def select_strategy(affect, mastery):
    if affect['frustration'] > 0.7:
        return 'hint_with_encouragement'
    if affect['boredom'] > 0.6 and mastery > 0.7:
        return 'increase_difficulty'
    if affect['confusion'] > 0.5 and mastery < 0.5:
        return 'review_prerequisite'
    if affect['engagement'] > 0.7:
        return 'maintain_flow'
    return 'check_in'

LLM tutor with affect prompt

def llm_tutor_response(student_msg, affect, history):
    affect_str = f"Frustration: {affect['frustration']:.1f}, Engagement: {affect['engagement']:.1f}"
    
    prompt = f"""You are a patient, emotionally-aware tutor.
Student affect: {affect_str}
{'IMPORTANT: Student frustrated — validate first, then small step.' if affect['frustration'] > 0.6 else ''}
{'IMPORTANT: Student bored — pivot to challenge.' if affect['boredom'] > 0.5 else ''}

History: {history[-3:]}
Student: {student_msg}

Response:"""
    return llm.generate(prompt)

Productive vs unproductive confusion (D'Mello)

def classify_confusion(affect_history, performance):
    duration = affect_history.confusion_duration()
    progress = performance.recent_correct_rate()
    if duration > 60 and progress < 0.3:
        return 'unproductive'  # 매 intervene
    return 'productive'  # 매 let dwell

Mastery-aware (Bayesian Knowledge Tracing)

class BKT:
    def __init__(self, p_init=0.1, p_learn=0.3, p_slip=0.1, p_guess=0.2):
        self.p_known = p_init
        self.p_learn, self.p_slip, self.p_guess = p_learn, p_slip, p_guess
    
    def update(self, correct):
        if correct:
            num = self.p_known * (1 - self.p_slip)
            denom = num + (1 - self.p_known) * self.p_guess
        else:
            num = self.p_known * self.p_slip
            denom = num + (1 - self.p_known) * (1 - self.p_guess)
        self.p_known = num / denom + (1 - num / denom) * self.p_learn

Engagement intervention (recovery)

def recover_engagement(disengaged_for_seconds):
    if disengaged_for_seconds < 30:
        return None
    if 30 <= disengaged_for_seconds < 120:
        return {'type': 'gentle_check_in', 'msg': 'Still with me?'}
    return {'type': 'pivot', 'msg': "Let's try something different."}

Self-report (emoji slider)

<div class="affect-checkin">
  How are you feeling?
  <button data-emotion="frustrated">😤</button>
  <button data-emotion="confused">🤔</button>
  <button data-emotion="bored">😴</button>
  <button data-emotion="engaged">🤩</button>
</div>

Empathy response template

EMPATHIC_OPENERS = {
    'frustrated': ["This one is tricky — that's a normal feeling.", "Let's slow down a bit."],
    'confused': ["I see what's confusing — let me explain differently.", "Good question."],
    'bored': ["Let me show you why this matters.", "Here's a more interesting twist."],
}

def open_response(detected_emotion):
    return random.choice(EMPATHIC_OPENERS.get(detected_emotion, ['']))

A/B test (affect-aware vs not)

def evaluate_eits(group_a_baseline, group_b_eits):
    return {
        'completion_a': mean(s.completed for s in group_a_baseline),
        'completion_b': mean(s.completed for s in group_b_eits),
        'satisfaction_a': mean(s.rating for s in group_a_baseline),
        'satisfaction_b': mean(s.rating for s in group_b_eits),
        'mastery_a': mean(s.mastery for s in group_a_baseline),
        'mastery_b': mean(s.mastery for s in group_b_eits),
    }

매 결정 기준

상황	Approach
Webcam OK	Multimodal facial + behavior
No camera	Behavioral + self-report
K-12	Strong empathy emphasis
Higher-ed	Productive confusion tolerated
Adult learning	Less interruption
Mental health risk	Clinician escalation path

기본값: 매 multimodal affect + 매 BKT mastery + 매 LLM empathic response + 매 self-report fallback + 매 productive confusion 의 respect.

🔗 Graph

• 부모: Education-Technology
• 변형: AutoTutor · Emotional-AI (Affective Computing)
• 응용: Adaptive-Learning
• Adjacent: Emotional-AI (Affective Computing) · Dynamic Difficulty Adjustment (DDA) · Corporate-LMS-Training

🤖 LLM 활용

언제: 매 tutoring product. 매 K-12. 매 language learning. 언제 X: 매 reference material. 매 assessment-only.

❌ 안티패턴

• Surveillance feel: 매 student 의 creep.
• All confusion = bad: 매 productive 의 ignore.
• Static empathy: 매 personalize X.
• Privacy violation: 매 video 의 cloud send.
• Validate-only: 매 challenge X.

🧪 검증 / 중복

• Verified (D'Mello & Graesser, AutoTutor, 2014+ EITS literature).
• 신뢰도 A.

🕓 Changelog

날짜	변경
2026-04-20	Auto-reinforced
2026-05-08	Phase 1
2026-05-10	Manual cleanup — affect-aware + 매 detect / strategy / BKT / LLM / A/B code