孩子注意力不集中容易走神怎么改善？学心四力专注评估模型与实现

                    ┌───────────────────────────────────┐
                    │    波斯纳注意力三网络协同系统     │
                    └─────────────────┬─────────────────┘
                                      │
     ┌────────────────────────────────┼────────────────────────────────┐
     ▼                                ▼                                ▼
【警觉网络 Alerting】            【定向网络 Orienting】          【执行控制网络 Executive】
- 维持大脑清醒警觉基线          - 锁定当前学习目标刺激          - 抑制干扰冲动、冲突调控
- 生物钟与疲劳度调控            - 空间/视觉线索选择性聚焦       - 前额叶皮层（PFC）主导核心

+-------------------------------------------------------------------------+
|                              数据输入层                                 |
|  - 任务切片打卡 (Task Block)       - 停顿微行为标记 (Pause Signal)       |
|  - 页面翻动/步骤推进 (Step Tick)    - 外部环境干扰打标 (Distraction Tag)  |
+------------------------------------+------------------------------------+
                                     |
                                     v
+-------------------------------------------------------------------------+
|                        时序特征计算与滑动窗口层                         |
|  - 滑动窗口时间分片 (15~25min)     - 指数移动平均 (EMA) 衰减平滑         |
|  - 专注稳定性指数 (Focus Stability) - 抗干扰衰减系数 (Interference Cost) |
+------------------------------------+------------------------------------+
                                     |
                                     v
+-------------------------------------------------------------------------+
|                       专注状态决策与分级干预层                          |
|  [沉浸心流 FOCUS]      [浅层波动 DRIFT]    [认知疲劳 FATIGUE]           |
|         |                     |                   |                     |
|    保持静默保护           微步台阶提示        触发 2 分钟散热中断       |
+-------------------------------------------------------------------------+

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
focus_state_evaluator.py
=============================================================
心定力专注状态时序评估模型与工程实现
- 功能：基于轻量行为事件流计算滑动窗口专注度、疲劳度及干预建议
- 依赖：纯 Python 标准库 (dataclasses, enum, datetime, math)
=============================================================
"""

from dataclasses import dataclass, field
from datetime import datetime, timedelta
from enum import Enum
from typing import List, Dict, Optional
import math

class Tracker(str, Enum):
    """四力核心维度枚举"""
    DIRECTING  = "心航力"     # 目标自驱与方向导航
    FOCUS      = "心定力"     # 专注抗扰与认知稳定（本模型主战）
    RESILIENCE = "心韧力"     # 卡壳复原与抗挫耐力
    EFFICACY   = "心效力"     # 胜任确信与微任务做成

class FocusLevel(str, Enum):
    """专注状态等级判定"""
    DEEP_FLOW    = "深度心流"    # 高效沉浸，无感知干扰
    STABLE_FOCUS = "稳定专注"    # 正常节奏，少量微停顿
    MILD_DRIFT   = "轻度走神"    # 频繁小动作、停顿超标
    SEVERE_OVERLOAD = "认知过载" # 认知负荷过重，建议适度休息

class DistractionType(str, Enum):
    """干扰与停顿外显信号"""
    NONE              = "无干扰"
    STATIONERY_FIDGET = "摆弄文具/小动作"
    GAZE_WANDERING    = "眼神涣散/发呆"
    FREQUENT_LEAVING  = "频繁离座(喝水/如厕)"
    ENVIRONMENT_NOISE = "环境噪音打断"

@dataclass
class FocusEvent:
    """单个学习行为时序快照"""
    timestamp: datetime
    task_id: str
    duration_seconds: int               # 本次持续秒数
    step_completed: bool                # 是否有推进实质步骤（如写出一道题、完成一步计算）
    distraction: DistractionType = DistractionType.NONE
    notes: str = ""

@dataclass
class EvaluationReport:
    """专注状态评估报告"""
    student_id: str
    dimension: str
    window_start: datetime
    window_end: datetime
    effective_focus_ratio: float       # 有效专注占比 (0.0 ~ 1.0)
    stability_score: float             # 专注稳定性得分 (0 ~ 100)
    current_level: FocusLevel
    recommended_action: str            # 推荐干预指令
    cooling_needed: bool               # 是否需要休息缓冲

class FocusEvaluator:
    """心定力流式评估器"""

    def __init__(self, student_id: str, window_minutes: int = 25):
        self.student_id = student_id
        self.window_minutes = window_minutes
        self.event_stream: List[FocusEvent] = []

    def record_event(self, event: FocusEvent) -> None:
        """记录时序事件并按时间递增维护"""
        self.event_stream.append(event)
        self.event_stream.sort(key=lambda x: x.timestamp)

    def evaluate_window(self, current_time: Optional[datetime] = None) -> EvaluationReport:
        """评估最近滑动窗口内的专注能量状态"""
        if current_time is None:
            current_time = datetime.now() if not self.event_stream else self.event_stream[-1].timestamp

        start_time = current_time - timedelta(minutes=self.window_minutes)
        window_events = [e for e in self.event_stream if start_time <= e.timestamp <= current_time]

        if not window_events:
            return EvaluationReport(
                student_id=self.student_id,
                dimension=Tracker.FOCUS.value,
                window_start=start_time,
                window_end=current_time,
                effective_focus_ratio=1.0,
                stability_score=100.0,
                current_level=FocusLevel.STABLE_FOCUS,
                recommended_action="窗口内无事件，保持当前稳定环境",
                cooling_needed=False
            )

        total_duration = sum(e.duration_seconds for e in window_events)
        if total_duration == 0:
            total_duration = 1

        # 核心算法：带干扰降权与时序衰减的专注得分加权
        weighted_focus_seconds = 0.0
        penalty_count = 0

        for event in window_events:
            # 基础权重：有产出步骤为 1.0，无产出为 0.5
            step_weight = 1.0 if event.step_completed else 0.5

            # 干扰系数折扣
            distraction_penalty = {
                DistractionType.NONE: 1.0,
                DistractionType.STATIONERY_FIDGET: 0.6,
                DistractionType.GAZE_WANDERING: 0.4,
                DistractionType.FREQUENT_LEAVING: 0.2,
                DistractionType.ENVIRONMENT_NOISE: 0.7
            }.get(event.distraction, 1.0)

            if event.distraction != DistractionType.NONE:
                penalty_count += 1

            # 计算单事件有效专注秒数
            effective_seconds = event.duration_seconds * step_weight * distraction_penalty
            weighted_focus_seconds += effective_seconds

        effective_ratio = min(1.0, max(0.0, weighted_focus_seconds / total_duration))

        # 稳定性基准分 (0~100)
        base_score = effective_ratio * 100.0
        # 惩罚项：频繁分心扣分
        stability_score = max(0.0, base_score - (penalty_count * 5.0))

        # 认知过载判定：单次连续无中断超过设定阈值或有效率暴跌
        if stability_score < 40.0:
            level = FocusLevel.SEVERE_OVERLOAD
            action = "【触发休息中断】停止做题，执行2分钟闭目深呼吸或离桌拉伸，缓解认知疲劳"
            cooling = True
        elif stability_score < 70.0:
            level = FocusLevel.MILD_DRIFT
            action = "【微任务切片】将当前题目降解为写出已知条件的5分钟小步骤，降低启动摩擦"
            cooling = False
        elif stability_score >= 90.0:
            level = FocusLevel.DEEP_FLOW
            action = "【保持静默守护】孩子处于深度心流区，严禁送水、打扰或口头干预"
            cooling = False
        else:
            level = FocusLevel.STABLE_FOCUS
            action = "【节奏稳定】状态良好，按照当前进度继续推进"
            cooling = False

        return EvaluationReport(
            student_id=self.student_id,
            dimension=Tracker.FOCUS.value,
            window_start=start_time,
            window_end=current_time,
            effective_focus_ratio=round(effective_ratio, 3),
            stability_score=round(stability_score, 1),
            current_level=level,
            recommended_action=action,
            cooling_needed=cooling
        )

# =============================================================
# 独立运行与模拟流水线验证
# =============================================================
if __name__ == "__main__":
    print("=" * 65)
    print("心定力专注评估模型运行演示 (Python 3)")
    print("=" * 65)

    evaluator = FocusEvaluator(student_id="STUDENT_XIAOKAI_04", window_minutes=25)
    base_t = datetime(2026, 10, 16, 19, 30, 0)

    # 场景 1：前 15 分钟状态良好，高效做完基础数学题
    evaluator.record_event(FocusEvent(
        timestamp=base_t,
        task_id="MATH_EXERCISE_01",
        duration_seconds=300,
        step_completed=True,
        distraction=DistractionType.NONE
    ))
    evaluator.record_event(FocusEvent(
        timestamp=base_t + timedelta(minutes=5),
        task_id="MATH_EXERCISE_02",
        duration_seconds=420,
        step_completed=True,
        distraction=DistractionType.NONE
    ))

    # 场景 2：第 15 分钟遭遇压轴几何题，出现咬笔头与发呆
    evaluator.record_event(FocusEvent(
        timestamp=base_t + timedelta(minutes=15),
        task_id="MATH_GEOMETRY_03",
        duration_seconds=360,
        step_completed=False,
        distraction=DistractionType.STATIONERY_FIDGET,
        notes="反复摆弄自动铅笔，草稿纸上无实质演算"
    ))
    evaluator.record_event(FocusEvent(
        timestamp=base_t + timedelta(minutes=21),
        task_id="MATH_GEOMETRY_03",
        duration_seconds=240,
        step_completed=False,
        distraction=DistractionType.GAZE_WANDERING,
        notes="眼神脱离书本，转头看向窗外发呆"
    ))

    # 运行滑动窗口状态评估
    eval_time = base_t + timedelta(minutes=25)
    report = evaluator.evaluate_window(eval_time)

    print(f"评估学员编号: {report.student_id}")
    print(f"评估四力主轴: {report.dimension}")
    print(f"时间窗口范围: {report.window_start.strftime('%H:%M')} ~ {report.window_end.strftime('%H:%M')}")
    print(f"有效专注占比: {report.effective_focus_ratio * 100:.1f}%")
    print(f"专注稳定性得分: {report.stability_score} / 100")
    print(f"当前专注状态等级: {report.current_level.value}")
    print(f"系统干预决策: {report.recommended_action}")
    print(f"是否建议休息缓冲: {'是 (YES)' if report.cooling_needed else '否 (NO)'}")
    print("=" * 65)