大模型应用：基于《症状自评量表SCL-90》与混元大模型的心理评估系统全解析.113

// **************************
// 核心数据定义
// **************************

// SCL-90题目数据（完整版90题）
// 结构：content(题目内容), factor(所属心理因子)
const SCL90_QUESTIONS = [
    { content: '头痛', factor: '躯体化' },
    { content: '神经过敏，心中不踏实', factor: '焦虑' },
    { content: '头脑中有不必要的想法或字句盘旋', factor: '强迫症状' },
    // ... (此处省略中间题目，实际代码包含90条)
    { content: '感到自己的脑子有毛病', factor: '精神病性' }
];

// 因子配置（各因子对应的题目索引）
// 关键逻辑：SCL-90的每个因子由特定的题目组成，这里通过数组索引精确映射
const FACTOR_CONFIG = {
    '躯体化': [0, 3, 8, 11, 38, 40, 45, 47, 50, 52, 53, 71],
    '强迫症状': [2, 9, 37, 44, 46, 60],
    '人际关系敏感': [5, 20, 34, 36, 37, 41, 65, 79],
    '抑郁': [4, 13, 14, 19, 25, 29, 30, 31, 32, 42, 54, 59, 66, 68, 77],
    '焦虑': [1, 16, 22, 33, 55, 57, 72, 74, 78],
    '敌对': [7, 10, 23, 58, 61, 63, 75],
    '恐怖': [12, 24, 33, 47, 51, 64, 70, 76],
    '偏执': [6, 18, 21, 43, 62, 73, 80],
    '精神病性': [15, 35, 49, 56, 67, 81, 83],
    '睡眠饮食': [44, 59, 60, 61]
};

// 中国成人常模数据
// 用途：在图表中作为“标准线”与用户得分进行对比，判断是否异常
const NORM_DATA = {
    '躯体化': 1.37,
    '强迫症状': 1.62,
    '人际关系敏感': 1.65,
    '抑郁': 1.50,
    '焦虑': 1.39,
    '敌对': 1.46,
    '恐怖': 1.23,
    '偏执': 1.43,
    '精神病性': 1.29
};

// 全局状态变量
let userScores = new Array(90).fill(null); // 存储用户每题的得分 (1-5)
let assessmentResult = null;                // 存储计算后的最终结果

// 初始化题目展示
function initQuestions() {
    const container = document.getElementById('questions-container');
    
    SCL90_QUESTIONS.forEach((question, index) => {
        const questionDiv = document.createElement('div');
        questionDiv.className = 'question-container';
        // 动态生成每一题的HTML结构：题目文本 + 5个评分按钮
        questionDiv.innerHTML = `
            <div class="question-title">${index + 1}. ${question.content}</div>
            <div class="score-options">
                <button class="score-btn" data-score="1" data-index="${index}">1分 - 无</button>
                <button class="score-btn" data-score="2" data-index="${index}">2分 - 轻度</button>
                <button class="score-btn" data-score="3" data-index="${index}">3分 - 中度</button>
                <button class="score-btn" data-score="4" data-index="${index}">4分 - 偏重</button>
                <button class="score-btn" data-score="5" data-index="${index}">5分 - 严重</button>
            </div>
        `;
        container.appendChild(questionDiv);
        
        // 【关键点】如果本地有保存的分数，恢复选中状态
        if (userScores[index] !== null) {
            const scoreBtn = questionDiv.querySelector(`.score-btn[data-score="${userScores[index]}"]`);
            if (scoreBtn) scoreBtn.classList.add('selected');
        }
    });
}

// 保存评分到本地存储 (实现断点续测)
function saveScores() {
    localStorage.setItem('scl90_user_scores', JSON.stringify(userScores));
}

// 加载本地存储的评分
function loadSavedScores() {
    const saved = localStorage.getItem('scl90_user_scores');
    if (saved) {
        userScores = JSON.parse(saved);
        updateProgress(); // 加载后更新进度条
    }
}

// 更新进度显示与提交按钮状态
function updateProgress() {
    const completed = userScores.filter(score => score !== null).length;
    const progressText = document.getElementById('progress-text');
    const submitBtn = document.getElementById('submit-btn');
    
    progressText.textContent = `进度：${completed}/90`;
    
    // 只有当90题全部做完，才激活“完成评估”按钮
    if (completed === 90) {
        submitBtn.classList.remove('btn-disabled');
        submitBtn.classList.add('btn-primary');
        submitBtn.disabled = false;
    } else {
        submitBtn.classList.add('btn-disabled');
        submitBtn.classList.remove('btn-primary');
        submitBtn.disabled = true;
    }
}

// 计算评估结果
function calculateResults() {
    // 1. 计算各因子得分
    const factorScores = {};
    Object.keys(FACTOR_CONFIG).forEach(factor => {
        const indices = FACTOR_CONFIG[factor];
        // 过滤掉“睡眠饮食”等非标准核心因子（根据具体需求可选）
        if (['睡眠饮食'].includes(factor)) return;
        
        // 核心算法：(该因子下所有题目得分之和) / 题目数量
        const sum = indices.reduce((total, index) => {
            return total + (userScores[index] || 0);
        }, 0);
        
        factorScores[factor] = (sum / indices.length).toFixed(2); // 保留两位小数
    });

    // 2. 计算总症状指数 (Global Severity Index)
    // 公式：所有90题得分总和 / 90
    const totalSum = userScores.reduce((sum, score) => sum + score, 0);
    const totalIndex = (totalSum / 90).toFixed(2);

    // 3. 计算阳性项目数和均分
    // 阳性项目：得分 >= 2 的题目（表示有症状）
    const positiveScores = userScores.filter(score => score >= 2);
    const positiveCount = positiveScores.length;
    
    // 阳性症状均分：阳性项目的平均分
    const positiveMean = positiveCount > 0 
        ? (positiveScores.reduce((sum, score) => sum + score, 0) / positiveCount).toFixed(2)
        : '0.00';

    // 组装结果对象
    assessmentResult = {
        factorScores,
        totalIndex,
        positiveCount,
        positiveMean,
        rawScores: userScores
    };

    // 将结果也存入本地，方便后续查看
    localStorage.setItem('scl90_assessment_result', JSON.stringify(assessmentResult));

    // 触发结果展示
    showResults();
}

// 初始化可视化图表
function initCharts() {
    // 1. 雷达图 (Radar Chart) - 多维度能力/状态分析
    const radarChart = echarts.init(document.getElementById('radar-chart'));
    const factorNames = Object.keys(assessmentResult.factorScores);
    
    // 提取用户得分和常模得分，转为数字数组
    const userFactorScores = factorNames.map(factor => parseFloat(assessmentResult.factorScores[factor]));
    const normFactorScores = factorNames.map(factor => NORM_DATA[factor] || 0);

    radarChart.setOption({
        title: { text: 'SCL-90各因子得分分布', left: 'center' },
        tooltip: { trigger: 'item' },
        legend: { orient: 'vertical', right: 10, top: 20 },
        radar: {
            // 动态生成雷达图的顶点（每个因子一个顶点）
            indicator: factorNames.map(name => ({ name, max: 5 })),
            shape: 'polygon',
            splitNumber: 4
        },
        series: [{
            name: '得分对比',
            type: 'radar',
            data: [
                { value: userFactorScores, name: '您的得分', itemStyle: { color: '#409eff' } },
                { value: normFactorScores, name: '常模均值', itemStyle: { color: '#67c23a' } }
            ]
        }]
    });

    // 2. 柱状图 (Bar Chart) - 直观对比高低
    const barChart = echarts.init(document.getElementById('bar-chart'));
    barChart.setOption({
        title: { text: '各因子得分与常模对比', left: 'center' },
        tooltip: { trigger: 'axis' },
        legend: { data: ['您的得分', '常模均值'], bottom: 0 },
        xAxis: {
            type: 'category',
            data: factorNames,
            axisLabel: { rotate: 45 } // 标签倾斜防止重叠
        },
        yAxis: { type: 'value', min: 0, max: 5 },
        series: [
            {
                name: '您的得分',
                type: 'bar',
                data: userFactorScores,
                itemStyle: { color: '#409eff' }
            },
            {
                name: '常模均值',
                type: 'bar',
                data: normFactorScores,
                itemStyle: { color: '#67c23a' }
            }
        ]
    });

    // 响应式处理：窗口大小改变时重绘图表
    window.addEventListener('resize', function() {
        radarChart.resize();
        barChart.resize();
    });
}

// 获取AI分析结果，调用后端 API
function getAIAnalysis() {
    const loading = document.querySelector('.loading');
    const analysisSection = document.getElementById('analysis-section');
    
    loading.style.display = 'block'; // 显示加载中
    
    // 构造发送给后端的数据包
    const requestData = {
        data: assessmentResult, // 包含所有计算好的分数
        userInfo: {
            age: 30,  
            gender: '未知',
            occupation: '未知'
        }
    };

    // 发送 POST 请求
    fetch('http://localhost:8000/api/analyze', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify(requestData)
    })
    .then(response => {
        if (!response.ok) throw new Error('请求失败');
        return response.json();
    })
    .then(data => {
        loading.style.display = 'none';
        analysisSection.style.display = 'block';

        // 【关键点】使用 marked 库将后端返回的 Markdown 文本解析为 HTML
        const analysisContent = document.getElementById('analysis-content');
        analysisContent.innerHTML = marked.parse(data.analysis);
    })
    .catch(error => {
        loading.style.display = 'none';
        showToast('获取分析结果失败：' + error.message, 'error');
        console.error('Error:', error);
    });
}

// 下载评估报告
function downloadReport() {
    const analysisContent = document.getElementById('analysis-content').textContent;
    
    // 拼接报告文本
    let reportContent = `
症状自评量表(SCL-90)评估报告
==============================
生成时间：${new Date().toLocaleString()}

一、基础评估数据
总症状指数：${assessmentResult.totalIndex}
阳性项目数：${assessmentResult.positiveCount} (共90项)
阳性症状均分：${assessmentResult.positiveMean}

二、各因子得分
${Object.entries(assessmentResult.factorScores).map(([factor, score]) => `${factor}：${score}`).join('\n')}

三、专业分析与建议
${analysisContent}

------------------------------
重要提示：本报告仅为参考，不能替代专业医师的诊断。
    `;

    // 创建 Blob 对象并触发下载
    const blob = new Blob([reportContent], { type: 'text/plain;charset=utf-8' });
    const url = URL.createObjectURL(blob);
    const a = document.createElement('a');
    a.href = url;
    a.download = `SCL-90评估报告_${new Date().toLocaleDateString()}.txt`;
    a.click();
    
    URL.revokeObjectURL(url); // 释放内存
}

from fastapi import FastAPI, HTTPException
from fastapi.middleware.cors import CORSMiddleware
from pydantic import BaseModel, Field
from openai import OpenAI
import os
from typing import Dict, List, Optional, Any

# ========================
# 初始化配置
# ========================
app = FastAPI(title="SCL-90评估分析API", version="1.0")

# 配置跨域（解决前端跨域问题，允许前端页面调用此 API）
app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],  # 生产环境应指定具体域名，如 ["http://localhost:8080"]
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

# 配置腾讯混元大模型客户端
# 注意：实际部署时 API Key 应通过环境变量注入，不要硬编码
api_key = os.getenv("TENCENT_API_KEY", "sk-bWlJPKjB——e")
client = OpenAI(
    api_key=api_key,
    base_url="https://api.hunyuan.cloud.tencent.com/v1", # 腾讯混元兼容 OpenAI 协议
)

# ========================
# 数据模型定义 (Pydantic)
# ========================
class UserInfo(BaseModel):
    """用户基本信息模型"""
    age: int = Field(..., description="用户年龄")
    gender: str = Field(..., description="用户性别")
    occupation: Optional[str] = Field(None, description="用户职业")

class FactorScores(BaseModel):
    """SCL-90 各因子得分模型，强制要求包含所有核心因子"""
    躯体化: float = Field(..., description="躯体化因子得分")
    强迫症状: float = Field(..., description="强迫症状因子得分")
    人际关系敏感: float = Field(..., description="人际关系敏感因子得分")
    抑郁: float = Field(..., description="抑郁因子得分")
    焦虑: float = Field(..., description="焦虑因子得分")
    敌对: float = Field(..., description="敌对因子得分")
    恐怖: float = Field(..., description="恐怖因子得分")
    偏执: float = Field(..., description="偏执因子得分")
    精神病性: float = Field(..., description="精神病性因子得分")

class SCL90Data(BaseModel):
    """完整的 SCL-90 评估数据模型"""
    factorScores: FactorScores = Field(..., description="各因子得分")
    totalIndex: float = Field(..., description="总症状指数")
    positiveCount: int = Field(..., description="阳性项目数")
    positiveMean: float = Field(..., description="阳性症状均分")
    rawScores: List[int] = Field(..., description="原始90题得分")

class AnalysisRequest(BaseModel):
    """API 请求体模型"""
    data: SCL90Data = Field(..., description="SCL-90评估数据")
    userInfo: UserInfo = Field(..., description="用户基本信息")

# ========================
# 核心常量 (心理学常模)
# ========================
NORM_DATA = {
    "躯体化": 1.37, "强迫症状": 1.62, "人际关系敏感": 1.65,
    "抑郁": 1.50, "焦虑": 1.39, "敌对": 1.46,
    "恐怖": 1.23, "偏执": 1.43, "精神病性": 1.29
}

STD_DATA = {
    "躯体化": 0.48, "强迫症状": 0.58, "人际关系敏感": 0.61,
    "抑郁": 0.59, "焦虑": 0.43, "敌对": 0.55,
    "恐怖": 0.41, "偏执": 0.57, "精神病性": 0.42
}

SEVERITY_LEVELS = {
    "normal": "正常范围（得分≤常模均值）",
    "mild": "轻度异常（常模均值<得分≤常模均值+1SD）",
    "moderate": "中度异常（常模均值+1SD<得分≤常模均值+2SD）",
    "severe": "重度异常（得分>常模均值+2SD）"
}

def get_severity_level(score: float, factor: str) -> str:
    """
    【核心算法】根据常模和标准差判断严重程度
    逻辑：得分 > 均值 + 2倍标准差 -> 重度; > 均值 + 1倍 -> 中度; 以此类推
    """
    norm = NORM_DATA[factor]
    std = STD_DATA[factor]
    
    if score <= norm:
        return SEVERITY_LEVELS["normal"]
    elif score <= norm + std:
        return SEVERITY_LEVELS["mild"]
    elif score <= norm + 2*std:
        return SEVERITY_LEVELS["moderate"]
    else:
        return SEVERITY_LEVELS["severe"]

def build_prompt(request: AnalysisRequest) -> str:
    """
    【提示词构建】将数据转化为大模型能理解的专业指令
    """
    factor_scores = request.data.factorScores.dict()
    total_index = request.data.totalIndex
    positive_count = request.data.positiveCount
    user_info = request.userInfo
    
    # 预计算异常因子列表，减少 AI 的幻觉风险
    abnormal_factors = []
    for factor, score in factor_scores.items():
        severity = get_severity_level(score, factor)
        if "异常" in severity:
            abnormal_factors.append({
                "name": factor, "score": score,
                "norm": NORM_DATA[factor], "severity": severity
            })
    
    # 构建结构化 Prompt
    prompt = f"""
你是一位资深的临床心理学家，拥有丰富的SCL-90量表解读经验。请根据以下用户的SCL-90评估数据，提供专业、客观、易懂的分析报告。

# 用户基本信息
- 年龄：{user_info.age}岁
- 性别：{user_info.gender}
- 职业：{user_info.occupation or '未填写'}

# 评估核心数据
1. 总症状指数：{total_index}（正常值参考范围：1.00-2.00）
2. 阳性项目数：{positive_count}项（共90项）
3. 阳性症状均分：{request.data.positiveMean}

# 各因子得分详情 (已结合中国成人常模计算)
{chr(10).join([f"- {factor}：{score}（常模均值：{NORM_DATA[factor]}，{get_severity_level(score, factor)}）" 
               for factor, score in factor_scores.items()])}

# 异常因子识别 (重点关注)
{chr(10).join([f"- {item['name']}：得分{item['score']}，{item['severity']}" for item in abnormal_factors]) if len(abnormal_factors) > 0
    else "未发现明显异常因子"}

# 分析要求
1. 语言风格：通俗易懂，避免过度术语，保持建设性态度。
2. 分析维度：总体状态、因子解读（重点分析异常）、症状关联模式、个性化建议。
3. 安全限制：**不做确诊性判断**，不提供药物建议，必须标注“仅供参考”。

# 输出格式 (Markdown)
## 一、总体评估
## 二、各因子详细解读
## 三、症状模式分析
## 四、个性化建议
## 五、重要提示
"""
    return prompt

def call_llm(prompt: str) -> str:
    """
    【LLM 调用】调用腾讯混元大模型，含异常降级处理
    """
    try:
        response = client.chat.completions.create(
            model="hunyuan-lite",       # 选择具体的模型版本
            messages=[
                {"role": "system", "content": "你是专业的临床心理学家，擅长SCL-90量表解读"},
                {"role": "user", "content": prompt}
            ],
            temperature=0.7,  # 平衡创造性与稳定性
            max_tokens=2000,   # 限制输出长度，防止过长
            timeout=30         # 30秒超时，防止长时间阻塞
        )
        return response.choices[0].message.content.strip()
        
    except Exception as e:
        # 【降级策略】当 AI 不可用时，返回基于规则的基礎分析
        error_msg = f"大模型调用失败：{str(e)}"
        print(error_msg)
        
        # 注意：这里需要访问外部变量，实际生产中建议将数据作为参数传入
        # 为演示逻辑，此处假设能访问到 request 中的数据 (实际代码需调整作用域或传参)
        # 下面是一个简化的降级模板逻辑示意：
        basic_analysis = f"""
## 一、总体评估
您的SCL-90总症状指数为 {request.data.totalIndex if 'request' in locals() else '未知'}。
由于智能分析服务暂时不可用，以下为基础数据解读：

## 二、各因子简要解读
系统检测到以下因子得分情况（基于常模对比）：
(此处略去详细循环，实际会列出所有因子及之前计算的严重程度)

## 三、通用建议
1. 保持规律作息，避免熬夜。
2. 适度运动，如慢跑、瑜伽。
3. 若情绪困扰持续超过两周，请务必前往医院心理科就诊。

## 四、重要提示
当前为系统自动生成的基础报告，缺乏深度上下文分析。请以专业医师诊断为准。
        """
        return basic_analysis

# ========================
# API接口定义
# ========================
@app.post("/api/analyze", summary="分析SCL-90评估数据")
async def analyze_scl90(request: AnalysisRequest):
    """
    主接口：接收数据 -> 校验 -> 构建Prompt -> 调用AI -> 返回结果
    """
    try:
        # 1. 业务逻辑校验 (Pydantic 已完成类型校验，此处做数值范围校验)
        if not (1 <= request.data.totalIndex <= 5):
            raise HTTPException(status_code=400, detail="总症状指数超出有效范围（1-5）")
        
        if len(request.data.rawScores) != 90:
            raise HTTPException(status_code=400, detail="原始得分数量必须为90项")
        
        # 2. 构建提示词
        prompt = build_prompt(request)
        
        # 3. 调用大模型 (含降级逻辑)
        analysis_result = call_llm(prompt)
        
        # 4. 返回标准化响应
        return {
            "code": 200,
            "message": "分析成功",
            "analysis": analysis_result  # Markdown 格式的文本
        }
        
    except HTTPException as e:
        raise e  # 透传业务错误
    except Exception as e:
        # 捕获未知错误，返回 500
        raise HTTPException(status_code=500, detail=f"服务器内部错误：{str(e)}")

@app.get("/health", summary="健康检查")
async def health_check():
    """用于负载均衡器或监控系统检查服务状态"""
    return {"status": "healthy", "service": "SCL-90 Analysis API", "version": "1.0"}

# ========================
# 主函数 (启动入口)
# ========================
if __name__ == "__main__":
    import uvicorn
    # 启动 Uvicorn 服务器
    # host="0.0.0.0" 允许外部访问，port=8000 指定端口
    uvicorn.run(
        app="main:app",  # 假设文件名为 main.py
        host="0.0.0.0",
        port=8000,
        reload=True,     # 开发模式下，代码修改自动重启
        log_level="info"
    )

{
  "data": {
    "factorScores": {
      "躯体化": 1.37,
      "强迫症状": 1.62,
      // ... 其他因子
    },
    "totalIndex": 1.45,
    "positiveCount": 20,
    "positiveMean": 2.10,
    "rawScores": [1,2,1,2,...] // 90个评分
  },
  "userInfo": {
    "age": 30,
    "gender": "男",
    "occupation": "程序员"
  }
}

{
  "code": 200,
  "message": "分析成功",
  "analysis": "## 一、总体评估...（详细分析内容）"
}