基础概念
- FPS : Frames Per Second（每秒帧数）。在计算机视觉、视频分析和深度学习推理等领域，FPS是衡量图像或视频流处理速度的关键指标。
图1：图片检测任务的输入与输出示意图
- Prompt（提示词）：用于引导AI模型生成响应的输入文本。其主要作用是：提供上下文、给予指导、限制输出范围。
- 7B, 8B：指模型的参数量，B表示十亿（billion）。例如7B代表模型拥有约70亿个可训练参数（即神经网络的权重和偏置）。通常，参数量越大，模型的表达能力越复杂。
- 预训练 (Pre-Training)：
- 预训练是构建大型模型的基础，目标是利用海量数据训练出一个通用的基础模型。
- 此过程需要收集和准备大规模的语料数据。
- 通常消耗巨大的计算资源和时间，多在高性能计算集群上完成。
- 微调 (Fine-Tuning)：
- 指在预训练模型的基础上进行调整，使其适应新的、特定任务。
- 针对特定领域（如专业文本分类）时，预训练模型可能表现不佳，微调可以显著提升其在该领域的性能和准确性。
- 优势在于高效性和资源节约：相比从头训练，微调过程更快，且利用了预训练模型已学到的通用特征，降低了对计算资源的需求。
- Hugging Face：一个提供了大量预训练机器学习模型的开源平台，模型存储在模型仓库中，同时也托管了许多公开数据集。
- 魔塔社区 (ModelScope)：由达摩院推出的国内首个中文AI模型开源社区。
Datasets: 提供大量公开数据集。Models: 提供大量可供使用的预训练模型。Docs: 提供丰富的开发工具和SDK。
- 是否需要微调？
- 定制化需求：生成特定领域或高度个性化的内容（如营销文案）。
- 数据合规性：在严格监管环境下或处理敏感数据时，微调可确保模型输出符合隐私政策和行业法规。
- 领域特定知识：使模型深度理解并生成特定业务领域的准确响应。
- 上下文学习 (In Context Learning, ICL)：通过在输入中提供示例或参考信息，引导模型完成任务，而无需更新模型参数。
- 阈值 (Threshold)：在AI人脸识别等任务中，阈值决定了系统判断两张人脸是否为同一人的严格程度。算法会将人脸转换为特征向量，通过计算相似度（如欧氏距离、余弦相似度）进行比对，阈值则设定了接受或拒绝匹配的临界点。
- 微调（大模型场景）：指对已预训练好的大语言模型，使用特定领域的小规模数据，对其全部或部分参数进行调整，以获得在该领域更优的性能。
内置NPU
以 Intel® Core™ Ultra 5 Processor 235U 为例，其NPU规格可参考：产品规格页面
图2：Intel 235U处理器NPU规格表
OpenVINO
OpenVINO GenAI 是英特尔基于 OpenVINO 工具套件构建的生成式AI开发工具库，专注于在英特尔硬件（CPU、GPU、NPU）上高效优化和部署生成式模型，以实现高性能的深度学习推理，获得快速准确的结果。
- 可以从
Hugging Face 下载通用模型，然后通过 optimum-cli 转换为 IR 格式模型。
- 或者直接从
Hugging Face 下载已经转换好的 OpenVINO 格式模型。
图3：OpenVINO GenAI 工作流程图
量化是一种用于减少模型存储需求和计算复杂度的技术。通过用较低精度的数据类型（如 int8, int4）表示模型的权重和激活值，量化能显著降低内存占用并提升推理速度，同时对模型精度的影响尽可能小。
- int4：精度较低，在复杂任务或需要高精度细节时，准确性可能下降。
- int8：能在多数任务中保留接近原始模型的性能，是性能与精度之间较好的折衷方案。
FP16 与 BF16 都是深度学习中使用的16位浮点数表示格式。
- FP16：由1位符号位、5位指数位和10位尾数位组成。在表达小数时精度较高，但表达大数时范围有限。
- BF16：由1位符号位、8位指数位和7位尾数位组成。相比FP16，BF16扩大了数值表达范围，但略微降低了精度。
图4：OpenVINO 从模型到部署的全流程架构图
图5：基于CPU+GPU+NPU的硬件数字人解决方案示意图
模型转换
OpenVINO 支持将 PyTorch、TensorFlow、PaddlePaddle、ONNX 等多种格式的模型，转换为 OpenVINO IR 格式后再部署，也可直接使用原格式部署。与 OpenVINO IR 格式配合使用效果最佳，可以使用 optimum-cli 或 OVC 命令行工具进行转换。转换好的 IR 格式模型包含 .xml（描述模型拓扑结构）和 .bin（包含权重和二进制数据）两个文件。
import openvino as ov
ov_model = ov.convert_model('yolov10b.onnx')
ov.save_model(ov_model, 'yolov10b.xml')
或者使用 OVC 命令：
ovc yolov10b.onnx
图6：OpenVINO 模型转换与优化流程示意图
下载模型
# 环境依赖
sudo apt install curl
sudo snap install aria2c
wget https://hf-mirror.com/hfd/hfd.sh
chmod a+x hfd.sh
# 设置环境变量
export HF_ENDPOINT=https://hf-mirror.com
# 下载模型
./hfd.sh dreamlike-art/dreamlike-anime-1.0
图7：使用 hfd.sh 脚本下载模型的文件列表
转换模型
使用 optimum-cli 工具进行转换。需提前准备好Python环境及相关依赖。
# 创建并激活虚拟环境
conda create -n openvino python=3.11
conda activate openvino
# 设置国内镜像加速
pip3 config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple/
# 安装环境依赖
pip install --pre -U openvino-genai openvino openvino-tokenizers --extra-index-url https://storage.openvinotoolkit.org/simple/wheels/nightly
pip install nncf
pip install optimum-intel[openvino]
# 安装其他可能需要的依赖（如特定notebook的要求）
cd /path/to/openvino_notebooks-latest/supplementary_materials/qwen2
pip install -r requirements.txt
optimum-cli export openvino 常用参数解析
-m 或 –model：指定模型ID或本地路径。–task：指定模型任务类型（如 text-generation, question-answering），不指定则会尝试自动推断。–device：指定用于模型导出/量化的设备（如 cpu, npu）。–weight-format：指定权重量化格式，如 {fp32, fp16, int8, int4}。–quant-mode：应用全模型量化（包括激活函数），如 {int8, ...}。–group-size：权重量化时的分组大小（如 --group-size 128）。–dataset：用于基于数据的压缩或量化校准的数据集名称。
模型来源：
转换命令示例：
# 转换文本生成模型到指定目录
optimum-cli export openvino --model /path/to/DeepSeek-R1-Distill-Qwen-1.5B --task text-generation-with-past /path/to/output_dir
# 将模型转换为 int8 精度并指定在 NPU 上运行（如果支持）
optimum-cli export openvino --model Meta-Llama-3.1-8B-Instruct --task text-generation-with-past --weight-format int8 ./output_dir --device npu
# 使用 Python 转换脚本（例如针对特定模型如 Qwen）
python3 convert.py --model_id qwen/Qwen2-7B-Instruct --precision int4 --output ./output_dir --modelscope
图8：使用 optimum-cli 转换模型时的终端输出日志
图9：转换成功后的 OpenVINO IR 格式模型文件列表
参考资料:
主板GPU驱动安装
以 Ubuntu 24.04 为例，可从 Intel compute-runtime 的 GitHub Releases 页面安装最新驱动。
mkdir neo
cd neo
# 下载所有 *.deb 包 (此处为示例，版本号请以最新release为准)
wget https://github.com/intel/intel-graphics-compiler/releases/download/v2.22.2/intel-igc-core-2_2.22.2+20121_amd64.deb
wget https://github.com/intel/intel-graphics-compiler/releases/download/v2.22.2/intel-igc-opencl-2_2.22.2+20121_amd64.deb
wget https://github.com/intel/compute-runtime/releases/download/25.44.36015.5/intel-opencl-icd_25.44.36015.5-0_amd64.deb
# ... 下载其他必要的包
# 安装所有包
sudo dpkg -i *.deb
# 若安装出错，可能需要安装依赖，例如：
sudo apt install ocl-icd-libopencl1
# 重启后检查驱动
sudo dmesg | grep gpu
主板NPU驱动安装
驱动项目地址: https://github.com/intel/linux-npu-driver
# 移除旧版本驱动包（如有）
sudo dpkg --purge --force-remove-reinstreq intel-driver-compiler-npu intel-fw-npu intel-level-zero-npu intel-level-zero-npu-dbgsym
# 下载并解压驱动包 (以 Ubuntu 24.04 为例)
wget https://github.com/intel/linux-npu-driver/releases/download/v1.26.0/linux-npu-driver-v1.26.0.20251125-19665715237-ubuntu2404.tar.gz
tar -xf linux-npu-driver-v1.26.0.20251125-19665715237-ubuntu2404.tar.gz
cd <解压后的目录>
# 安装依赖
sudo apt update
sudo apt install libtbb12
# 安装所有驱动包
sudo dpkg -i *.deb
# 检查并安装 Level Zero 运行时（如未安装）
dpkg -l level-zero
# 如果未安装，则下载对应版本安装，例如 Ubuntu 24.04：
wget https://github.com/oneapi-src/level-zero/releases/download/v1.24.2/level-zero_1.24.2+u24.04_amd64.deb
sudo dpkg -i level-zero*.deb
图10：使用 dpkg 检查 level-zero 运行时的安装状态
重启系统后验证：
# 检查 NPU 设备文件
ls /dev/accel/accel0
# 查看内核日志中的 VPU/NPU 信息
sudo dmesg | grep vpu
图11：系统重启后，dmesg 中显示的 NPU 设备初始化信息
开发环境
通过 PIP 安装 OpenVINO，并验证可用设备中是否包含 NPU。
参考：OpenVINO 官方下载页面
图12：OpenVINO 官方下载页面选择界面
# 第 1 步：创建虚拟环境。
python3 -m venv openvino_env
# 第 2 步：激活虚拟环境
source openvino_env/bin/activate
# 第 3 步：升级 pip。
python -m pip install --upgrade pip
# 第 4 步：安装 OpenVINO 基础包。
pip install openvino==2025.4.0
# 查看可用设备
python -c "from openvino import Core; print(Core().available_devices)"
图13：运行代码验证 OpenVINO 可用的设备列表（显示 CPU 和 NPU）
若要使用对话生成模型（如 DeepSeek），需额外安装 openvino-genai。
# 在已激活的 openvino_env 环境中执行
pip install openvino-genai==2025.4.0
模型部署
基础推理流程示例：
-
导入库并创建核心对象
import openvino as ov
core = ov.Core()
-
加载并编译模型
model = core.read_model(model="model.xml") # 模型路径
# 第二个参数为 device_name，例如 "CPU", "GPU", "NPU" 或 "AUTO"
compiled_model = core.compile_model(model, "AUTO")
-
获取模型输入/输出信息
inputs = compiled_model.inputs
outputs = compiled_model.outputs
# 或通过索引获取
input_layer = compiled_model.input(0)
output_layer = compiled_model.output(0)
# 获取形状和数据类型
input_shape = input_layer.shape
data_type = input_layer.get_element_type()
图14：模型输入与输出格式说明图
- 创建推理请求并进行推理
infer_request = compiled_model.create_infer_request()
# 设置输入数据 (假设 input_data 是预处理后的 NCHW 格式数据)
input_tensor = ov.Tensor(array=input_data, shared_memory=True)
infer_request.set_input_tensor(input_tensor)
# 执行异步推理
infer_request.start_async()
infer_request.wait() # 等待推理完成
# 获取输出结果
output_tensor = infer_request.get_output_tensor()
output_data = output_tensor.data
# 对 output_data 进行后处理...
调用 DeepSeek 实时对话模型
以下是一个简化的示例，展示如何加载模型并进行对话生成，支持在 NPU 和 CPU 间自动回退。
#!/usr/bin/env python3
import time
import openvino as ov
import openvino_genai as ov_genai
from transformers import AutoTokenizer
from pathlib import Path
class SimpleNPUModelLoader:
"""简化的NPU/CPU模型加载与推理类"""
def __init__(self, model_path):
self.model_path = Path(model_path)
self.genai_pipe = None
self.tokenizer = None
self.use_npu = True
def check_npu_availability(self):
"""检查NPU可用性"""
print("🔍 检查NPU可用性...")
try:
core = ov.Core()
available_devices = core.available_devices
if "NPU" in available_devices:
device_name = core.get_property("NPU", "FULL_DEVICE_NAME")
print(f" ✅ NPU可用: {device_name}")
return True
else:
print(" ❌ NPU设备不可用")
return False
except Exception as e:
print(f" ❌ NPU检查失败: {e}")
return False
def load_model(self):
"""加载模型到可用设备（NPU优先，失败则回退CPU）"""
print("🚀 开始加载模型...")
npu_available = self.check_npu_availability()
if not npu_available:
print(" 🔄 NPU不可用，回退到CPU...")
device = "CPU"
self.use_npu = False
else:
device = "NPU"
self.use_npu = True
try:
scheduler_config = ov_genai.SchedulerConfig()
scheduler_config.cache_size = 2 # 缓存大小设为2GB
print(f" 📦 使用OpenVINO GenAI加载模型到{device}...")
self.genai_pipe = ov_genai.LLMPipeline(
str(self.model_path),
device,
scheduler_config=scheduler_config,
)
print(" 📝 加载tokenizer...")
self.tokenizer = AutoTokenizer.from_pretrained(
str(self.model_path),
trust_remote_code=True
)
print(f" ✅ 模型成功加载到{device}设备")
return True
except Exception as e:
print(f" ❌ 模型加载失败: {e}")
# NPU加载失败，尝试回退CPU
if device == "NPU":
print(" 🔄 NPU加载失败，尝试CPU...")
try:
self.genai_pipe = ov_genai.LLMPipeline(str(self.model_path), "CPU")
self.use_npu = False
print(" ✅ 模型成功加载到CPU设备")
return True
except Exception as cpu_e:
print(f" ❌ CPU加载也失败: {cpu_e}")
return False
def streamer(self, subword):
"""流式输出回调函数"""
print(subword, end='', flush=True)
return False
def generate_text(self, prompt):
"""生成文本"""
if self.genai_pipe is None:
raise RuntimeError("模型未加载")
try:
config = ov_genai.GenerationConfig()
config.max_new_tokens = 4096
config.stop_strings = set() # 设置停止词
response = self.genai_pipe.generate(prompt, config, streamer=self.streamer)
return response
except Exception as e:
print(f"❌ 文本生成失败: {e}")
return None
def main():
"""主函数"""
print("🎉 Intel NPU模型加载和推理测试")
print("=" * 50)
# 模型路径 - 请根据实际情况修改
model_path = "path/to/your/openvino_model_dir"
loader = SimpleNPUModelLoader(model_path)
if loader.load_model():
device_name = "NPU" if loader.use_npu else "CPU"
print(f"\n🧪 开始测试推理 (设备: {device_name})...")
test_prompt = "你好，请介绍一下自己。"
print(f"📝 提示: {test_prompt}")
print("🤖 AI: ", end="")
start_time = time.time()
response = loader.generate_text(test_prompt)
end_time = time.time()
print(f"\n⏱️ 推理时间: {(end_time - start_time):.2f}秒")
# 进入简单交互循环
print("\n💬 进入交互模式（输入'quit'退出）:")
while True:
user_input = input("\n👤 您: ").strip()
if user_input.lower() in ['quit', 'exit', '退出']:
break
if user_input:
print("🤖 AI: ", end="")
loader.generate_text(user_input)
print()
else:
print("❌ 模型加载失败，程序退出")
print("\n👋 程序结束")
if __name__ == "__main__":
main()
图15：LLM 文本生成流程示意图
安装报错处理
系统问题
在 Ubuntu 22.04 上安装 Intel GPU 驱动可能遇到问题，升级到 Ubuntu 24.04.3 或更新版本通常可以解决。
编译环境
错误信息：None of PyTorch, TensorFlow >= 2.0, or Flax have been found...
该错误表明当前 Python 环境中缺少 Hugging Face Transformers 库所需的深度学习后端框架。
解决方案：安装至少一个深度学习框架。
# 安装 PyTorch (推荐) 或 TensorFlow
pip install torch
# 或
pip install tensorflow
# 验证安装
python -c "import tensorflow as tf; print(tf.__version__)"
图16：终端中验证 TensorFlow 版本成功安装
实践示例
YOLO 模型转换与调用
将 Ultralytics YOLO 模型转换为 OpenVINO 格式，并在推理时自动判断。
import openvino as ov
from ultralytics import YOLO
from pathlib import Path
MODEL_NAME = "yolov11n"
PT_MODEL_PATH = f"path/to/{MODEL_NAME}.pt"
IR_MODEL_DIR = Path(f"path/to/{MODEL_NAME}_openvino_model")
IR_MODEL_PATH = IR_MODEL_DIR / f"{MODEL_NAME}.xml"
def load_or_export_openvino_model() -> ov.CompiledModel:
"""加载或导出 YOLO 模型的 OpenVINO IR 格式"""
model = YOLO(PT_MODEL_PATH)
if not IR_MODEL_PATH.exists():
print("转换后的openvino模型不存在，进行模型转换...")
model.export(format="openvino", dynamic=True, half=True)
core = ov.Core()
ir_model = core.read_model(IR_MODEL_PATH)
print("模型加载完毕")
# 指定推理设备，如 "CPU", "GPU", "NPU"
return core.compile_model(ir_model, device_name="NPU")
# 使用编译后的模型
compiled_model = load_or_export_openvino_model()
# 后续可使用 compiled_model 进行推理
文本生成（带草稿模型加速）
使用 Speculative Decoding（推测解码）技术，结合小型草稿模型加速大模型文本生成。
import openvino_genai
def streamer(subword):
"""流式输出回调"""
print(subword, end='', flush=True)
return openvino_genai.StreamingStatus.RUNNING
def infer_with_draft(main_model_dir: str, draft_model_dir: str, prompt: str):
main_device = 'CPU' # 或 'GPU', 'NPU'
draft_device = 'CPU'
# 配置缓存
scheduler_config = openvino_genai.SchedulerConfig()
scheduler_config.cache_size = 2 # GB
# 初始化草稿模型（FastDraft）
draft_model = openvino_genai.draft_model(draft_model_dir, draft_device)
# 创建带草稿模型的推理管道
pipe = openvino_genai.LLMPipeline(
main_model_dir,
main_device,
scheduler_config=scheduler_config,
draft_model=draft_model
)
# 配置生成参数，启用推测解码
config = openvino_genai.GenerationConfig()
config.max_new_tokens = 100
config.num_assistant_tokens = 5 # 草稿模型每次预测的token数
# 生成文本
pipe.generate(prompt, config, streamer)
# 使用示例
infer_with_draft(
"path/to/Meta-Llama-3.1-8B-Instruct-OV",
"path/to/Llama-3.1-8B-Instruct-FastDraft-150M-int8-OV",
"The Sun is yellow because"
)
视频目标检测推理
使用转换后的 YOLO OpenVINO 模型对摄像头或视频文件进行实时目标检测。
import cv2
import numpy as np
import time
import collections
from pathlib import Path
def run_video_inference(det_model, source=0, flip=True, width=None, save_video=False, output_dir="./results"):
"""
使用 OpenVINO YOLO 模型进行视频目标检测
det_model: 已加载的 YOLO 模型对象 (来自 ultralytics.YOLO)
source: 视频文件路径或摄像头索引
"""
cap = cv2.VideoCapture(source)
if not cap.isOpened():
print(f"无法打开视频源: {source}")
return
Path(output_dir).mkdir(parents=True, exist_ok=True)
out_writer = None
processing_times = collections.deque(maxlen=200) # 用于计算平均FPS
try:
while True:
ret, frame = cap.read()
if not ret:
break
if flip:
frame = cv2.flip(frame, 1)
if width:
scale = width / frame.shape[1]
frame = cv2.resize(frame, None, fx=scale, fy=scale)
# 推理
start_time = time.time()
results = det_model(frame, verbose=False)
stop_time = time.time()
# 绘制结果
annotated_frame = results[0].plot()
# 计算并显示FPS
processing_times.append(stop_time - start_time)
fps = len(processing_times) / sum(processing_times) if processing_times else 0
cv2.putText(annotated_frame, f"FPS: {fps:.1f}", (10, 30),
cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)
cv2.imshow('YOLO OpenVINO Detection', annotated_frame)
if cv2.waitKey(1) & 0xFF == 27: # ESC 退出
break
finally:
cap.release()
cv2.destroyAllWindows()
if out_writer:
out_writer.release()
# 假设 det_model 已通过之前的函数 build_ultralytics_model() 加载
run_video_inference(det_model, source=0, width=1280)
文本转图像 (Text-to-Image)
使用 Stable Diffusion 类模型（如 dreamlike-anime-1.0）生成图像。
步骤1：转换模型
optimum-cli export openvino --model dreamlike-art/dreamlike-anime-1.0 --device npu ./dreamlike_anime_ov
步骤2：Python 代码调用
import openvino_genai as ov_genai
from PIL import Image
import sys
from tqdm import tqdm
model_dir = "./dreamlike_anime_ov"
device = "NPU" # 或 "CPU", "GPU"
num_inference_steps = 20
prompt = "cyberpunk cityscape at dusk, cinematic lighting"
# 初始化生成器和流水线
random_generator = ov_genai.TorchGenerator(42) # 固定随机种子
if device != "NPU":
pipe = ov_genai.Text2ImagePipeline(model_dir, device)
else:
# NPU设备可能需要先 reshape 再 compile
pipe = ov_genai.Text2ImagePipeline(model_dir)
pipe.reshape(1, 512, 512, pipe.get_generation_config().guidance_scale)
pipe.compile(device)
# 带进度条的回调函数
pbar = tqdm(total=num_inference_steps, desc="Generating")
def callback(step, num_steps, latent):
pbar.update(1)
sys.stdout.flush()
return False
# 生成图像
image_tensor = pipe.generate(
prompt,
width=512,
height=512,
num_inference_steps=num_inference_steps,
generator=random_generator,
callback=callback
)
pbar.close()
# 转换为PIL图像并显示/保存
image = Image.fromarray(image_tensor.data[0])
image.show()
# image.save("output.png")
实用工具与资源
# 安装 Open Model Zoo 工具包，包含模型下载、优化等自动化脚本
pip install openvino-dev
参考资料
发表于 2025-12-30 04:14:08
|
查看: 27|
回复: 0
