用RTX 4090打造AI魔镜：本地大模型与多模态视觉实战

在本地放一面 AI 魔镜，听起来像玩具，但把它真正跑通需要把摄像头采集、人脸检测、本地大模型推理和网页交互串成一条稳定链路。RTX 4090 的 24GB 显存让这件事可以在完全本地完成：不需要把画面传到云端，不用申请在线 API Key，模型权重全部放在自己机器上。下面的实现会从零搭建一个可运行的 AI 魔镜项目，核心功能是检测摄像头画面中一米以内的多张人脸，调用本地多模态大模型为每一张脸打分并给出中文短评，最终在网页上公布“方圆一米内最帅的男人”。

这套项目适合三类读者：想学习本地大模型部署的开发者，需要把视觉模型接进业务系统的后端工程师，以及准备用 4090 做趣味 Demo 的 AI 爱好者。它会涉及 OpenCV 的人脸检测、Ollama 的本地推理接口、Flask 的视频流和 JSON API，以及多模态模型 prompt 设计。完成之后，你可以随时把“帅度评价”替换成表情识别、年龄估计、情绪分析等真实业务能力。

1. 本地部署“AI 魔镜”要解决的核心问题

AI 魔镜并不是一个需要复杂算法才能完成的项目，它的本质是一个多模态视觉任务：摄像头拍到人脸，检测模型定位人脸区域，视觉语言模型对图片内容做理解和评价，最终把结果呈现在前端。难点在于如何把这些模块按正确的顺序连接起来，并保证在本地 4090 上稳定运行。

1.1 一条从摄像头到本地大模型的完整链路

完整链路可以拆成四个阶段。

第一，采集阶段。摄像头读取画面，后台线程持续更新最新帧。这一步不能直接用单次cv2.imread方式处理，否则浏览器请求和分析请求会互相阻塞。

第二，检测阶段。使用 OpenCV 的人脸检测器，从当前帧中找到所有人脸框。检测器输出的(x, y, w, h)同时用于裁剪人脸区域和估算人脸距离。这里的“方圆一米”，可以基于人脸宽度像素做一个近似换算。

第三，理解阶段。把裁剪出来的人脸图片通过 Base64 编码传给 Ollama API，由本地多模态模型结合 prompt 输出评价。多模态模型能同时理解图像内容和文字指令，因此可以给出类似“这位选手面部轮廓清晰，眼神有神，气质偏清爽”的描述。

第四，展示阶段。Flask 负责推送 MJPEG 视频流，并提供 JSON 分析接口。网页端在显示画面的同时，定时请求分析接口，将多张人脸的评分按从高到低渲染成榜单，最高分作为“方圆一米内最帅的男人”。

这四个阶段必须共享同一份最新帧，否则视频流和分析结果会出现明显错位。

1.2 为什么选择 4090 作为本地推理底座

RTX 4090 拥有 24GB 显存，这是本地部署视觉大模型的重要分水岭。以常见的 7B 参数多模态模型为例，使用 4bit 或 8bit 量化后，模型权重占用大约在 5GB 到 11GB 之间，剩余显存还可以容纳 CUDA 上下文、图像特征和并发请求的临时张量。因此 4090 可以比较从容地运行 7B 到 13B 级别的视觉语言模型。

选择本地推理还带来两个现实收益。其一是隐私可控，摄像头画面不会离开本机，适合办公室、实验室、智能家居等对数据敏感的环境。其二是调用成本稳定，所有推理都走本地 GPU，不依赖公网带宽，也没有在线 API 的限流和按次计费问题。缺点是模型能力和在线超大模型仍有差距，并且推理速度和显卡功耗直接挂钩。

对于本项目的趣味场景，7B 到 13B 模型已经足够。如果后续要处理更复杂的视觉理解任务，可以在同一块 4090 上换用更大的量化模型，或者增加一个独立的推理服务节点。

1.3 与在线 AI 方案做一次选型对比

很多同类功能可以直接调用在线视觉 API，开发成本更低。但“本地 AI 魔镜”更看重延迟、隐私和离线可用性。下面从项目落地角度看两者差异。

这个表格并不是说本地方案一定优于在线方案。如果是快速验证产品原型，在线 API 只需要几行代码。如果是做隐私要求高的本地应用，本地 4090 方案更合适。后续的工程实现都基于本地方案展开。

2. 先把环境准备好：驱动、Python、Ollama 和视觉模型

“魔镜”能跑起来的前提是环境对齐。很多人失败并不是代码问题，而是驱动版本、CUDA 环境和模型 tag 没有对上。下面的顺序建议按步骤执行，每一步都有明确的检查点。

2.1 环境检查清单

项目用到的主要组件包括 NVIDIA 驱动、Python 运行时、Ollama、OpenCV 和 Flask。最稳妥的学习环境要求如下。

先强调一个容易踩坑的点：Ollama 自带 CUDA 推理依赖，不需要手动安装完整 CUDA Toolkit。关键驱动版本要足够新，否则 GPU 设备无法被检测到。用nvidia-smi查看 GPU 状态时，只要能看到4090和驱动版本即可。

2.2 安装 Ollama 并拉取支持视觉的模型

Ollama 是一个本地模型运行时，它把模型下载、推理服务、GPU 调度都封装成了简单命令。安装完成后，默认监听11434端口，可以通过 REST API 调用。

Linux 和 macOS 的安装命令是：

curl -fsSL https://ollama.com/install.sh | sh

Windows 用户直接到官网下载安装包。安装完成后启动服务，然后拉取一个支持视觉能力的模型。建议优先选择qwen2.5vl:7b，它在中文理解和视觉描述上表现平衡，模型体积也适合 24GB 显存。

ollama pull qwen2.5vl:7b

如果拉取时网络不稳定，可以换用以下模型名，但注意不同模型的输出格式和中文能力有差异：

ollama pull llava:13b ollama pull minicpm-v

模型是否需要下载成功，可以通过以下命令确认：

ollama list

输出中应该出现刚才拉取的模型名和大小。如果列表为空，说明模型拉取失败，需要检查磁盘空间和网络。

2.3 模型选型速查

在项目落地前，把模型选型固定下来很重要。不同的模型对显存占用、中文能力、图像理解细节都有影响。

如果原始材料没有明确模型版本，落地前一定要确认 Ollama 官方库中的 tag。模型名和 tag 写错时，请求会返回model not found，这种报错最容易排查。

2.4 验证模型在 4090 上能正常推理

拉取模型后，先用 API 做一次最小验证，确认 GPU 真正参与推理。

curl http://localhost:11434/api/tags

正常会返回一个包含models数组的 JSON。再用命令行跑一次生成：

ollama run qwen2.5vl:7b "用一句话介绍你自己"

执行时打开另一个终端运行nvidia-smi，观察 4090 的显存占用是否上升。如果显存没有变化，说明模型可能跑在 CPU 上，需要检查 Ollama 日志或驱动环境。

3. 搭建项目骨架：摄像头采集与人脸检测模块

环境就绪后，开始写代码。这一阶段先不接入模型，只做摄像头采集、人脸检测、距离过滤和视频流输出。确认“能看到画面、能画出人脸框”之后，再进入模型接入。

3.1 项目目录结构和依赖

项目结构保持简单，方便后续扩展：

ai-mirror/ ├── app.py ├── requirements.txt └── templates/ └── index.html

requirements.txt内容如下：

flask>=3.0.0 opencv-python>=4.8.0 numpy>=1.24.0 requests>=2.31.0

安装依赖：

pip install -r requirements.txt

注意：不要在同一个虚拟环境中重复安装多个 OpenCV 包，例如opencv-python和opencv-contrib-python不要同时装，容易造成动态库冲突。

3.2 实现摄像头后台采集线程

摄像头读取在 OpenCV 中非常简单，但如果主线程同时处理 HTTP 请求和摄像头读取，视频流会出现卡顿。因此用后台线程持续读取最新帧，并加锁保护共享数据。

import cv2 import threading import time class Camera: def __init__(self, source=0): self.cap = cv2.VideoCapture(source) self.cap.set(cv2.CAP_PROP_FRAME_WIDTH, 1280) self.cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 720) if not self.cap.isOpened(): raise RuntimeError("无法打开摄像头，请检查设备号和占用情况") self.lock = threading.Lock() self.frame = None self.running = True self.thread = threading.Thread(target=self._loop, daemon=True) self.thread.start() def _loop(self): while self.running: ok, frame = self.cap.read() if ok: with self.lock: self.frame = frame time.sleep(0.03) def read(self): with self.lock: if self.frame is None: return None return self.frame.copy() def release(self): self.running = False self.cap.release()

这里的time.sleep(0.03)表示大约每秒处理 33 帧。实际帧率取决于摄像头输出，对于人脸检测和趣味展示已经足够。read()返回的是帧的副本，避免多个模块同时修改同一份图像数据。

3.3 用 OpenCV 检测人脸并估算“方圆一米”

OpenCV 自带的 Haar Cascade 人脸检测器不需要额外下载模型文件，适合作为最小启动方案。虽然它的精度不如深度学习人脸检测器，但能满足“识别画面中有人脸并框选”的需求。

import cv2 cascade_path = cv2.data.haarcascades + "haarcascade_frontalface_default.xml" face_cascade = cv2.CascadeClassifier(cascade_path) # 人脸宽度近似按 15cm 计算，FOCAL_PIXEL 是摄像头焦距的像素近似值 KNOWN_FACE_WIDTH = 0.15 FOCAL_PIXEL = 800 MAX_DISTANCE = 1.0 def detect_faces(frame): gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) faces = face_cascade.detectMultiScale( gray, scaleFactor=1.1, minNeighbors=5, minSize=(80, 80) ) results = [] for (x, y, w, h) in faces: distance = KNOWN_FACE_WIDTH * FOCAL_PIXEL / w if distance <= MAX_DISTANCE: results.append({ "box": [int(x), int(y), int(w), int(h)], "distance": round(distance, 2) }) return results

“方圆一米”在这里不是精确的空间距离，而是根据人脸框宽度做的近似估算。人在一米内时，脸在画面中会更大；人走远后，w变小，估算距离变大，从而被过滤掉。不同摄像头的焦距不同，FOCAL_PIXEL需要在固定位置实测调整。更精确的标定可以拍摄一张已知距离的人脸照片，用距离 = 人脸实际宽度 * 焦距像素 / 人脸像素宽度反推焦距。

如果 OpenCV 检测不到人脸，可以调小minNeighbors，或者降低minSize。但minSize降低后，画面远处的细小误检也会变多。这个参数后面会专门讲。

3.4 加一个视频流输出到浏览器

Flask 可以通过 multipart 响应输出 MJPEG 视频流。浏览器用<img>标签直接加载该地址，就能看到实时画面。

from flask import Flask, Response, jsonify, render_template app = Flask(__name__) camera = Camera() def generate_frames(): while True: frame = camera.read() if frame is None: continue for face in detect_faces(frame): x, y, w, h = face["box"] cv2.rectangle( frame, (x, y), (x + w, y + h), (0, 255, 0), 2 ) cv2.putText( frame, f"{face['distance']:.2f}m", (x, y - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0, 255, 0), 2 ) ok, buffer = cv2.imencode(".jpg", frame) if not ok: continue frame_bytes = buffer.tobytes() yield ( b"--frame\r\n" b"Content-Type: image/jpeg\r\n\r\n" + frame_bytes + b"\r\n" ) @app.route("/video") def video(): return Response( generate_frames(), mimetype="multipart/x-mixed-replace; boundary=frame" )

这一步运行后，访问http://127.0.0.1:5000/video应该能看到带绿框的视频画面。如果画面是黑色，优先检查摄像头权限和占用情况。

4. 接入本地视觉大模型：让魔镜开口评价

视频流只是“魔镜”的眼睛，真正决定“谁最帅”的是本地视觉语言模型。这一部分会把检测到的人脸裁剪出来，交给 Ollama 的生成接口，并解析成结构化结果。

4.1 Ollama 生成接口的请求格式

Ollama 的/api/generate接口支持传图片。图片字段images是 Base64 编码后的字符串数组。一个最小请求如下：

curl http://localhost:11434/api/generate \ -H "Content-Type: application/json" \ -d '{ "model": "qwen2.5vl:7b", "prompt": "请描述这张图片", "images": ["<base64字符串>"], "stream": false }'

在 Python 中，使用requests库发送同样的请求。注意stream=false表示等待完整结果返回，不开启流式输出，便于解析最终文本。

4.2 人脸裁剪、Base64 编码和 prompt 设计

从 OpenCV 拿到人脸框后，先裁剪人脸区域，再编码为 JPEG 和 Base64。不要直接把整张 1280x720 画面传给模型，否则模型容易被背景干扰，也会增加 Token 消耗。

import cv2 import base64 import requests def face_to_base64(frame, box): x, y, w, h = box face_roi = frame[y:y + h, x:x + w] ok, buffer = cv2.imencode(".jpg", face_roi) if not ok: return None return base64.b64encode(buffer.tobytes()).decode("utf-8") def ask_mirror(image_base64, model="qwen2.5vl:7b"): prompt = """ 你是一面有审美判断力的魔镜。请评估这张人脸照片的“帅度”。 要求： 1. score 是 0 到 100 的整数； 2. comment 是一句 15 字以内的中文短评； 3. tag 是 3 个以内的中文风格标签。 只输出 JSON，不要输出多余说明，格式如下： {"score": 85, "comment": "轮廓清晰，眼神有气质", "tag": ["清爽", "阳光", "沉稳"]} """ payload = { "model": model, "prompt": prompt, "images": [image_base64], "stream": False, "options": { "temperature": 0.3 } } resp = requests.post( "http://localhost:11434/api/generate", json=payload, timeout=120 ) resp.raise_for_status() return resp.json().get("response", "")

prompt 设计的核心是“把格式要求说清楚”。多模态模型对开放问题的回答会比较发散，但给出明确 JSON 模板后，输出结构会稳定很多。temperature=0.3是为了减少随机性，让评分更稳定。如果希望魔镜更有娱乐性，可以把温度调到 0.8，但分数波动会变大。

4.3 解析模型输出，整理成结构化结果

模型输出不一定每次都是合法 JSON，可能需要清洗。一个常用的做法是提取输出中的花括号部分，再用json.loads解析。解析失败时返回一个兜底结果，避免前端拿不到数据。

import json import re def parse_mirror_result(text): match = re.search(r"\{.*\}", text, re.S) if not match: return { "score": 50, "comment": "我暂时看不出来", "tag": ["未知"] } try: data = json.loads(match.group()) return { "score": int(data.get("score", 50)), "comment": str(data.get("comment", ""))[:30], "tag": data.get("tag", [])[:3] } except Exception: return { "score": 50, "comment": "我暂时看不出来", "tag": ["未知"] }

这里要把comment截断，防止模型输出超长文本破坏页面排版。tag只保留前三个，控制结果的简洁性。

4.4 把 Face 结果关联到画面框选

一次分析可能检测到多张人脸。每一张人脸都需要单独裁剪、单独调用模型。由于推理较慢，这个循环通常会执行几秒到十几秒。为了避免阻塞视频流，分析接口应该在独立线程中执行，或者接受“上一次分析结果还没完成时，直接返回旧结果”的策略。

为简单起见，这一版采用同步循环，但前端轮询间隔需要大于单次批量推理时间：

def analyze_frame(frame, faces): results = [] for idx, face in enumerate(faces): box = face["box"] image_b64 = face_to_base64(frame, box) if image_b64 is None: continue text = ask_mirror(image_b64) parsed = parse_mirror_result(text) parsed["face_index"] = idx parsed["box"] = box parsed["distance"] = face["distance"] results.append(parsed) results.sort(key=lambda r: r["score"], reverse=True) return results

results排序后，数组第一项就是当前画面中评分最高的人脸。

5. 完整实现：Flask 服务端和网页端“魔镜”交互

模型接入后，把服务端和前端组合起来，形成完整可运行的应用。

5.1 服务端主程序整合

app.py需要整合三部分：摄像头后台线程、视频流生成、分析接口。下面是一个最小可运行的完整服务端。

import cv2 import threading import time import base64 import json import re import requests from flask import Flask, Response, jsonify, render_template app = Flask(__name__) # 摄像头 class Camera: def __init__(self, source=0): self.cap = cv2.VideoCapture(source) self.cap.set(cv2.CAP_PROP_FRAME_WIDTH, 1280) self.cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 720) if not self.cap.isOpened(): raise RuntimeError("无法打开摄像头") self.lock = threading.Lock() self.frame = None self.running = True self.thread = threading.Thread(target=self._loop, daemon=True) self.thread.start() def _loop(self): while self.running: ok, frame = self.cap.read() if ok: with self.lock: self.frame = frame time.sleep(0.03) def read(self): with self.lock: if self.frame is None: return None return self.frame.copy() def release(self): self.running = False self.cap.release() camera = Camera() # 人脸检测 cascade_path = cv2.data.haarcascades + "haarcascade_frontalface_default.xml" face_cascade = cv2.CascadeClassifier(cascade_path) KNOWN_FACE_WIDTH = 0.15 FOCAL_PIXEL = 800 MAX_DISTANCE = 1.0 def detect_faces(frame): gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) faces = face_cascade.detectMultiScale( gray, scaleFactor=1.1, minNeighbors=5, minSize=(80, 80) ) results = [] for (x, y, w, h) in faces: distance = KNOWN_FACE_WIDTH * FOCAL_PIXEL / w if distance <= MAX_DISTANCE: results.append({ "box": [int(x), int(y), int(w), int(h)], "distance": round(distance, 2) }) return results def face_to_base64(frame, box): x, y, w, h = box face_roi = frame[y:y + h, x:x + w] ok, buffer = cv2.imencode(".jpg", face_roi) if not ok: return None return base64.b64encode(buffer.tobytes()).decode("utf-8") def ask_mirror(image_base64, model="qwen2.5vl:7b"): prompt = """ 你是一面有审美判断力的魔镜。请评估这张人脸照片的“帅度”。 要求： 1. score 是 0 到 100 的整数； 2. comment 是一句 15 字以内的中文短评； 3. tag 是 3 个以内的中文风格标签。 只输出 JSON，不要输出多余说明，格式如下： {"score": 85, "comment": "轮廓清晰，眼神有气质", "tag": ["清爽", "阳光", "沉稳"]} """ payload = { "model": model, "prompt": prompt, "images": [image_base64], "stream": False, "options": {"temperature": 0.3} } resp = requests.post( "http://localhost:11434/api/generate", json=payload, timeout=120 ) resp.raise_for_status() return resp.json().get("response", "") def parse_mirror_result(text): match = re.search(r"\{.*\}", text, re.S) if not match: return {"score": 50, "comment": "我暂时看不出来", "tag": ["未知"]} try: data = json.loads(match.group()) return { "score": int(data.get("score", 50)), "comment": str(data.get("comment", ""))[:30], "tag": data.get("tag", [])[:3] } except Exception: return {"score": 50, "comment": "我暂时看不出来", "tag": ["未知"]} def analyze_frame(frame, faces): results = [] for idx, face in enumerate(faces): box = face["box"] image_b64 = face_to_base64(frame, box) if image_b64 is None: continue text = ask_mirror(image_b64) parsed = parse_mirror_result(text) parsed["face_index"] = idx parsed["box"] = box parsed["distance"] = face["distance"] results.append(parsed) results.sort(key=lambda r: r["score"], reverse=True) return results def generate_frames(): while True: frame = camera.read() if frame is None: continue faces = detect_faces(frame) for face in faces: x, y, w, h = face["box"] cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 2) cv2.putText( frame, f"{face['distance']:.2f}m", (x, y - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0, 255, 0), 2 ) ok, buffer = cv2.imencode(".jpg", frame) if not ok: continue frame_bytes = buffer.tobytes() yield ( b"--frame\r\n" b"Content-Type: image/jpeg\r\n\r\n" + frame_bytes + b"\r\n" ) @app.route("/") def index(): return render_template("index.html") @app.route("/video") def video(): return Response( generate_frames(), mimetype="multipart/x-mixed-replace; boundary=frame" ) @app.route("/assess") def assess(): frame = camera.read() if frame is None: return jsonify({"error": "no frame"}), 503 faces = detect_faces(frame) results = analyze_frame(frame, faces) if not results: return jsonify({"results": [], "winner": None}) return jsonify({ "results": results, "winner": results[0] }) if __name__ == "__main__": app.run(host="0.0.0.0", port=5000, debug=False)

需要注意，/assess接口是同步的，后面会把性能问题和优化方式单独说明。

5.2 前端页面：视频流 + 定时分析 + 榜单展示

前端页面不需要复杂构建工具，一个 HTML 文件加少量 JS 即可。视频流直接用<img>加载，分析结果通过setInterval轮询/assess。

<!DOCTYPE html> <html lang="zh-CN"> <head> <meta charset="UTF-8"> <title>AI 魔镜</title> <style> body { background: #111; color: #eee; font-family: sans-serif; text-align: center; } img#mirror { width: 80%; max-width: 960px; border-radius: 16px; border: 2px solid #333; } #ranking { display: inline-block; text-align: left; margin: 16px auto; padding: 16px; background: #222; border-radius: 12px; } .card { padding: 8px 16px; margin: 8px 0; background: #333; border-radius: 8px; } .winner { background: #5a4a00; border: 1px solid #c9a500; } </style> </head> <body> <h2>AI 魔镜</h2> <img id="mirror" src="/video"> <div id="ranking"> <h3>方圆一米内最帅的男人</h3> <div id="cards"></div> </div> <script> async function refreshRanking() { try { const response = await fetch('/assess'); const data = await response.json(); const container = document.getElementById('cards'); container.innerHTML = ''; if (!data.winner) { container.innerHTML = '<p>画面中暂时没有检测到一米内的人脸</p>'; return; } data.results.forEach((item, idx) => { const card = document.createElement('div'); card.className = 'card' + (idx === 0 ? ' winner' : ''); card.innerHTML = ` <strong>第${idx + 1}名</strong> <span>得分：${item.score}</span> <span>距离：${item.distance}m</span> <p>${item.comment}</p> <small>${(item.tag || []).join(' / ')}</small> `; container.appendChild(card); }); } catch (e) { console.error(e); } } setInterval(refreshRanking, 8000); refreshRanking(); </script> </body> </html>

这里把轮询间隔设置为 8 秒，是因为本地 7B 模型处理一张人脸通常需要 3 到 10 秒。如果间隔太短，前端请求会堆积，Ollama 也会因为并发请求而变慢。

5.3 运行步骤与预期效果

启动前先确认 Ollama 服务在运行，并且模型已拉取。然后执行：

python app.py

打开浏览器访问http://127.0.0.1:5000。预期效果如下：

1. 页面顶部显示实时视频流，画面中的近距离人脸会被绿色框圈出。
2. 每 8 秒页面请求一次/assess。
3. 分析完成后，榜单区域显示多人的评分、距离、短评和标签。
4. 第一名卡片高亮，标题区域显示“方圆一米内最帅的男人”。

如果画面中没有人脸，榜单会显示提示文字，不会抛出错误。

6. 验证结果并做性能调优

功能跑通后，需要从接口、显存、耗时和参数四个维度做验证与调优。

6.1 用 curl 直接验证 Ollama 接口

后端逻辑出问题时，先绕过 Flask，直接验证 Ollama 接口。这样可以快速定位是模型问题还是应用代码问题。

curl -s http://localhost:11434/api/tags | python -m json.tool

再生成一张测试人脸图片，比如使用一张带人脸的 JPG 图片，然后转换成 Base64 后调用接口。如果 Ollama 返回model not found，表示模型名写错。如果返回空字符串，可能是 prompt 太长或图片编码异常。

6.2 观察显存占用和单次推理耗时

运行推理时，用nvidia-smi观察显存和 GPU 利用率。

watch -n 1 nvidia-smi

重点看两列：Memory-Usage和GPU-Util。如果显存占用接近 24GB，说明模型过大或并发请求过多。如果GPU-Util一直很低，但响应很慢，可能是模型没有完全落到 GPU，或者图像预处理占用了太多 CPU。

在后端代码中增加耗时统计，方便评估是否满足实时性要求：

import time start = time.time() text = ask_mirror(image_b64) elapsed = time.time() - start print(f"face {idx} cost {elapsed:.2f}s")

6.3 关键参数调优：阈值、温度、帧率、并发

调优原则是“先调检测，再调模型”。如果人脸框都不稳定，评分再准也无法展示。FOCAL_PIXEL的校正对距离过滤影响最大，建议用固定距离拍摄一张照片，反推准确值后再固定下来。

7. 本地部署常见问题排查

这套项目在生产环境之外也会遇到很多环境类问题。下面按“现象 -> 原因 -> 检查方式 -> 处理建议”的方式整理。

7.1 摄像头无法打开或画面黑色

最重要的一点：单独启动两个 Python 进程同时打开同一个摄像头，后启动的进程通常会失败。调试时先关闭旧进程。

7.2 CUDA out of memory

有一种隐蔽情况是模型之前被加载到显存，调试代码时没有释放。可以重启 Ollama 服务释放所有模型缓存：

ollama stop

然后重新启动服务。

7.3 Ollama 请求超时或返回空

请求超时可以把timeout从 120 秒继续调大。本地 7B 模型处理复杂图片可能超过 60 秒，但在 4090 上通常不会。

7.4 Python 环境兼容性问题

Windows 上 OpenCV 在部分 Python 3.12 版本下可能缺少预编译包。如果pip install出错，建议创建 Python 3.11 的虚拟环境：

python3.11 -m venv venv source venv/bin/activate pip install -r requirements.txt

macOS 上摄像头权限和 Windows 不同，需要给终端或其他调用进程授权摄像头。如果只是为了学习，建议优先在 Ubuntu 22.04 上运行，摄像头和 CUDA 的权限问题最少。

8. 从趣味 Demo 到可维护小项目的实践建议

演示项目跑通后，如果想继续把它变成可控、可维护的本地应用，还需要补上一些工程化思考。

8.1 “方圆一米”判定背后的工程取舍

“方圆一米”在项目里并没有使用深度传感器，而是用单目摄像头的近似几何换算。它能满足趣味需求，但有两个明显限制。其一是不同摄像头的焦距不一样，FOCAL_PIXEL必须标定。其二是人脸宽度不能精确代表与人脸中心的距离，侧脸时宽度变小，距离会被高估。

如果后续要更准确的距离判断，可以考虑双目摄像头、激光测距模块或基于深度学习的人脸关键点标定。但在这个项目中，单位置摄像头加简单换算已经足够，因为在魔镜场景下，人要获得高分，本来就该正对着镜子。

8.2 生产化要考虑的 5 件事

从本地 Demo 变成可长期运行的服务，至少要关注以下五件事。

1. 配置外置化。把模型名、端口、摄像头编号、人脸宽度、FOCAL_PIXEL等写入环境变量或配置文件，避免改代码。
2. 日志和监控。记录每次分析的模型名、请求耗时、显存占用、失败原因，方便定位问题。
3. 请求串行化。Ollama 并不适合同时处理大量并发请求，服务端应该用队列或锁保证一次只分析一个画面，避免显存和延迟失控。
4. 异常处理。摄像头断开、Ollama 重启、模型切换都会发生，要在接口层返回明确错误码，而不是让前端一直转圈。
5. 资源回收。临时裁剪的人脸图片要写入临时目录并及时清理，避免长期运行后磁盘被占满。

8.3 扩展方向：Agent、Dify 工作流、语音播报和更多视觉任务

这套架构的扩展性很好。

如果不想自己写 Flask 前端，可以把 Ollama 接入 Dify 本地部署，通过工作流编排 prompt、评分逻辑和结果展示。Dify 可以把各种模型调用封装成可视化节点，后续换模型、换提示词都不需要改代码。

也可以给魔镜加入语音播报，使用本地 TTS 把评分结果读出来，进一步增强“魔镜”氛围。如果想让魔镜记住不同用户的偏好，可以结合 Agent 框架，把人脸特征或用户 ID 保存到向量数据库，形成“认识你”的能力。

视觉任务方面，从“帅度评分”换成表情识别、年龄段估计、口罩检测、安全帽检测，只需要替换 prompt 或检测模型，整体链路不需要大改。

8.4 发布前检查清单

在学习环境和生产环境之间切换时，可以参考以下清单：

这个清单可以帮助你把一个趣味 Demo 升级成可长期访问的小型本地服务。最值得记住的一条是：在接入大模型之前，先把视频流、人脸框和距离过滤跑稳。底层链路稳定之后，换模型、换 prompt、加 Agent 都只是替换一个模块的事。AI 魔镜最有价值的部分不是“谁最帅”的评价本身，而是这条从摄像头到本地大模型的完整技术链路可以复用到更多真实场景中。