端侧轻量化情绪识别方案：双模型融合情绪推理，面向青少年心理沟通的AI监测应用26.8

import cv2
import numpy as np
from fastapi import FastAPI, UploadFile, File
from fastapi.middleware.cors import CORSMiddleware
from fastapi.staticfiles import StaticFiles
from insightface.app import FaceAnalysis
import onnxruntime as ort

app = FastAPI(title="青少年情绪监测后端服务")
# 全局跨域放行
app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)
# 托管前端静态页面
app.mount("/static", StaticFiles(directory="static"), name="static")

# 模型全局懒加载变量
face_analyzer = None
emotion_main_model = None
emotion_backup_model = None

# 人脸裁剪函数
def crop_face_square(img, bbox, expand_ratio=1.4):
    x1, y1, x2, y2 = bbox
    cx, cy = (x1+x2)/2, (y1+y2)/2
    w, h = x2-x1, y2-y1
    side = max(w, h) * expand_ratio
    half = side / 2
    # 正方形边界
    nx1, ny1 = int(cx - half), int(cy - half)
    nx2, ny2 = int(cx + half), int(cy + half)
    # 填充灰色
    h_img, w_img = img.shape[:2]
    pad_x1, pad_y1 = max(0, -nx1), max(0, -ny1)
    pad_x2, pad_y2 = max(0, nx2-w_img), max(0, ny2-h_img)
    img_pad = cv2.copyMakeBorder(img, pad_y1, pad_y2, pad_x1, pad_x2, cv2.BORDER_CONSTANT, value=(114,114,114))
    crop = img_pad[ny1+pad_y1:ny2+pad_y1, nx1+pad_x1:nx2+pad_x1]
    return crop

# 概率锐化算法
def sharpen_probs(probs, sharp=3.0):
    probs = np.clip(probs, 1e-8, 1.0)
    p_pow = np.power(probs, sharp)
    return p_pow / np.sum(p_pow)

@app.get("/")
async def index():
    from fastapi.responses import FileResponse
    return FileResponse("static/index.html")

@app.post("/api/emotion/recognize")
async def recognize_emotion(file: UploadFile = File(...)):
    global face_analyzer
    # 人脸检测懒加载
    if face_analyzer is None:
        face_analyzer = FaceAnalysis(name="buffalo_l", providers=['CPUExecutionProvider'])
        face_analyzer.prepare(ctx_id=0, det_size=(640,640))
    # 读取图片
    content = await file.read()
    arr = np.frombuffer(content, np.uint8)
    img = cv2.imdecode(arr, cv2.IMREAD_COLOR)
    faces = face_analyzer.get(img)
    if len(faces) == 0:
        return {"code":-1, "msg":"未检测到人脸"}
    # 选取画面最大人脸
    max_face = max(faces, key=lambda f:(f['bbox'][2]-f['bbox'][0])*(f['bbox'][3]-f['bbox'][1]))
    bbox = max_face["bbox"]
    w_face = bbox[2] - bbox[0]
    if w_face < 16:
        return {"code":-1, "msg":"人脸区域过小，无法识别"}
    face_crop = crop_face_square(img, bbox)
    # 此处调用双模型情绪推理
    # ...（推理逻辑）
    return {
        "code":0,
        "msg":"识别成功",
        "face_count": len(faces),
        "emotion_result": {
            "emotion_name": "calm",
            "confidence": 0.82,
            "probs": [0.82,0.05,0.03,0.04,0.02,0.02,0.01,0.01]
        }
    }

if __name__ == "__main__":
    import uvicorn
    uvicorn.run("main:app", host="0.0.0.0", port=8000)

// 向后端上传图片请求识别
async function uploadImageToBackend(imgBlob){
    const formData = new FormData();
    formData.append("file", imgBlob);
    const resp = await fetch("/api/emotion/recognize",{
        method:"POST",
        body:formData
    })
    const resJson = await resp.json();
    return resJson;
}

// 多帧投票算法，提升实时监测稳定性
function voteResult(frameEmotionList){
    const emotionCount = {};
    let totalProb = Array(8).fill(0);
    frameEmotionList.forEach(item=>{
        const emo = item.emotion_name;
        emotionCount[emo] = (emotionCount[emo]||0)+1;
        totalProb = totalProb.map((v,i)=>v+item.probs[i]);
    })
    // 统计最高频次情绪
    let maxCnt = 0;
    let finalEmo = "";
    Object.keys(emotionCount).forEach(k=>{
        if(emotionCount[k]>maxCnt){
            maxCnt = emotionCount[k];
            finalEmo = k;
        }
    })
    const avgProbs = totalProb.map(v=>v / frameEmotionList.length);
    const consistentRate = maxCnt / frameEmotionList.length;
    return {
        finalEmotion: finalEmo,
        avgProbs: avgProbs,
        frameConsistency: consistentRate
    }
}

// 摄像头轮询采集识别
let timer = null;
function startCameraDetect(){
    timer = setInterval(async ()=>{
        const canvas = document.getElementById("cameraCanvas");
        const blob = await new Promise(res=>canvas.toBlob(res,"image/jpeg"));
        const ret = await uploadImageToBackend(blob);
        if(ret.code===0){
            pushFrameData(ret.emotion_result);
            renderChart();
        }
    },2000);
}
function stopCameraDetect(){
    clearInterval(timer);
}

def emotion_probs_unified(face_crop):
    global emotion_main_model, emotion_backup_model
    try:
        # 优先使用EmotiEffLib主模型推理
        if emotion_main_model is None:
            from emotiefflib.facial_analysis import EmotiEffLibRecognizer
            emotion_main_model = EmotiEffLibRecognizer(engine="onnx", model_name="enet_b2_8")
        probs, _ = emotion_main_model.predict_emotions(face_crop)
        # 索引映射，对齐FERPlus输出顺序
        map_index = [0,1,2,3,4,5,6,7]
        aligned_probs = [probs[i] for i in map_index]
    except Exception as e:
        print(f"主模型异常，切换兜底模型:{e}")
        # 加载FERPlus ONNX兜底模型
        if emotion_backup_model is None:
            emotion_backup_model = ort.InferenceSession("ferplus8.onnx", providers=["CPUExecutionProvider"])
        gray = cv2.cvtColor(face_crop, cv2.COLOR_BGR2GRAY)
        gray = cv2.resize(gray,(64,64))
        inp = gray[np.newaxis,np.newaxis,:,:].astype(np.float32)
        out = emotion_backup_model.run(None, {"input":inp})
        aligned_probs = out[0][0].tolist()
    # 概率锐化
    aligned_probs = sharpen_probs(np.array(aligned_probs), sharp=3.0)
    return aligned_probs.tolist()

def emotion_preprocess(face_bgr_img):
    # BGR转灰度
    gray_img = cv2.cvtColor(face_bgr_img, cv2.COLOR_BGR2GRAY)
    # 缩放到64*64
    resized = cv2.resize(gray_img, (64,64))
    # 构建模型输入shape (1,1,64,64)
    input_tensor = np.expand_dims(np.expand_dims(resized, axis=0), axis=0).astype(np.float32)
    # 保留0~255像素值域，不额外归一化
    return input_tensor

def crop_face_square(img, bbox, scale=1.4):
    """以人脸 bbox 中心为基准外扩 scale 倍裁剪正方形区域，越界部分用灰色 (114) 填充"""
    h, w = img.shape[:2]
    bx1, by1, bx2, by2 = [float(v) for v in bbox]
    cx = (bx1 + bx2) / 2
    cy = (by1 + by2) / 2
    side = max(int(max(bx2 - bx1, by2 - by1) * scale), 16)
    half = side // 2
    x1 = int(cx - half)
    y1 = int(cy - half)
    x2 = x1 + side
    y2 = y1 + side
    # 原图越界量（copyMakeBorder 时用灰色补上）
    left = -min(x1, 0)
    top = -min(y1, 0)
    right = max(x2 - w, 0)
    bottom = max(y2 - h, 0)
    # 先夹取到图内
    x1 = max(x1, 0)
    y1 = max(y1, 0)
    x2 = min(x2, w)
    y2 = min(y2, h)
    crop = img[y1:y2, x1:x2]
    if left or top or right or bottom:
        crop = cv2.copyMakeBorder(crop, top, bottom, left, right,
                                  cv2.BORDER_CONSTANT, value=(114, 114, 114))
    return crop

def emotion_preprocess(crop_bgr):
    """人脸区域 → 模型输入 (1,1,64,64) float32。

    注意：ONNX Model Zoo emotion-ferplus-8 官方 README 明确——输入为灰度图，
    直接 resize 到 64x64 即可，像素保持 0~255，无需任何归一化。
    （此前误用 (x-128)/3.5 压到 [-36.6,36.3]，输入分布严重偏离训练域，
      导致模型几乎恒输出 neutral）
    """
    gray = cv2.cvtColor(crop_bgr, cv2.COLOR_BGR2GRAY)
    gray = cv2.resize(gray, (64, 64), interpolation=cv2.INTER_LINEAR)
    x = gray.astype(np.float32)
    return x.reshape(1, 1, 64, 64)

def sharpen_probs(p):
    """p: (8,) 概率数组 -> 锐化后仍归一化的概率数组"""
    p = np.maximum(np.asarray(p, dtype=float), 0.0)
    if p.sum() <= 0:
        return np.full(len(p), 1.0 / len(p))
    s = np.power(p + 1e-9, SHARP)
    return s / s.sum()

def emotion_probs_unified(crop_bgr):
    """人脸区域 → 统一 8 类顺序概率数组。主引擎 AffectNet，异常自动回退 FERPlus"""
    rec = get_affect_recognizer()
    if rec is not None:
        try:
            rgb = cv2.cvtColor(crop_bgr, cv2.COLOR_BGR2RGB)
            _labels, scores = rec.predict_emotions(rgb, logits=False)
            src = np.asarray(scores[0], dtype=float)
            p = np.empty(len(_AFFECT_SRC), dtype=float)
            for i, j in enumerate(_AFFECT_SRC):
                p[i] = src[j]
            return sharpen_probs(p)
        except Exception:
            pass
    x = emotion_preprocess(crop_bgr)
    sess = get_emotion_session()
    out = sess.run(None, {sess.get_inputs()[0].name: x})[0][0]
    e = np.exp(out - np.max(out))
    return sharpen_probs(e / e.sum())