个人学习小站 SIGNAL DESK 2026
LIVE --:--:--
资讯 人工智能 PyTorch 2.15 Intel GPU 文档、Intel PyTorch 前置条件页

不装 CUDA 也能跑:PyTorch XPU 从装环境到第一个张量

XPU wheel 把 SYCL 运行时打进了包里,所以官方路线不需要 source 任何 oneAPI 脚本。按驱动基线、wheel 安装、设备查询、第一个张量、CPU 脚本改造的顺序给一条能跑通的最短路径,附预期输出与症状对照表。

2026年11月18日 13 小时前 作者 站长 约 12 分钟 1 阅读

PyTorch 的 XPU 版把 SYCL 运行时打进了 wheel,所以「不装 CUDA 也能跑」真正省掉的是 CUDA Toolkit 和整套 oneAPI 环境脚本,省不掉显卡驱动。驱动不到位,torch.xpu.is_available() 只会还你一个 False,而且不告诉你为什么。

这篇按执行顺序走一条最短路径:确认驱动、装 XPU wheel、查设备、跑第一个张量、把现成的 CPU 脚本改过来。每一步给可复制的命令和预期输出。遇到 False 之后怎么逐层定位不在本篇范围内,那是另一个话题。

版本基线先钉死:PyTorch 2.15(官方文档 2026-09 更新)。Intel 客户端 GPU 的验证范围是 Windows 11、Ubuntu 24.04/26.04,以及 WSL2 里的这两个 Ubuntu 版本。更老的 20.04 不在列表里,省这个事最后会在别处还回来。

三条安装路径,先选一条

装之前先认清走哪条路,因为三条路的「前置」完全不是一回事。

路径适用平台与硬件需要装什么对应 PyTorch 2.15 的版本
pip wheelWindows、Linux、WSL2 全平台只装显卡驱动运行时由 wheel 依赖带入
Intel OMIXUbuntu + Arc Pro B50/B60/B65/B70一个整包OMIX 0.4.0
Deep Learning EssentialsWindows、WSL2、A/B 系列消费卡与核显驱动 + Essentials2026.1.3

wheel 这条路之所以能「装完就 import」,是因为官方 XPU wheel 里已经打包了 SYCL 运行时和 oneAPI 的一部分库,放在 torch/lib 下。这和 CUDA 平台的 cu12x wheel 打包 CUDA 运行时是同一个思路:运行时版本跟着 wheel 走,不跟着系统走。

这带来一个反直觉的结论——系统里装没装 oneAPI 不影响 pip 安装的 PyTorch。装了反而危险:setvars.sh 会把 LD_LIBRARY_PATH 指到 /opt/intel/oneapi,和 wheel 里的同名库版本不一致时,先被加载的那个赢。Intel 的前置条件文档在 Linux、WSL2、客户端三处都写了同一句警告——用 pip wheel 时不要 source。

反过来,如果你要从源码编译 PyTorch,或者运行自己编出来的 wheel,那就必须 source,而且必须按平台 source 对应的那几个脚本。这两条路的操作是互斥的,混着做必崩。

驱动这一关过不了,后面全是白工

Windows 的基线是 32.0.101.9033 WHQL 或更高。这条要求有个附加条件:安装包必须包含 LevelZeroSDK 组件。

缺这个组件时,is_available() 仍然是 True,torch.compile 会失败。属于「能跑但不能编译」的半通状态,很多人会误判成 PyTorch 装错了,然后重装一遍,再失败一次。

Get-CimInstance Win32_VideoController |
  Where-Object Name -like "*Intel*" |
  Select-Object Name, DriverVersion

Windows 上还有两个来源在打架:Intel 官网的通用驱动和 OEM 定制驱动。通用包更新快但会拒绝装在白名单外的机型上,OEM 包能装但常年落后。判断标准不是「哪个更新」,是 DriverVersion 有没有到基线。

Linux 上不看版本号字符串,看运行时能不能把设备列出来:

xpu-smi discovery
clinfo -l

xpu-smi discovery 要能看到 Device Name、Driver Version、Memory 三项才算过。只有 clinfo -l 有输出不算:OpenCL 和 Level Zero 是两条并列的栈,PyTorch 的 XPU 后端走后者,两者不能互相证明。

Linux 还有一条岔路。Arc Pro B50/B60/B65/B70 走 OMIX 整包,驱动和运行时一起到位;A 系列、B 系列消费卡和 Core Ultra 核显走「驱动 + Deep Learning Essentials」两件套。选错会得到一个中间态:设备在系统里,PyTorch 不认。

WSL2 的模型是反的——宿主机驱动持有 GPU,客机里只装用户态运行时,不要装 Linux 内核态 GPU 驱动,装了会和 /dev/dxg 打架。客机里能 ls -l /dev/dxg 看到节点,说明宿主机这一侧通了。

客机里还缺的是 Level Zero 用户态这一层,装齐之后 clinfo -l 才认得出 Intel 设备:

sudo apt update
sudo apt install -y libze1 libze-intel-gpu1 intel-opencl-icd clinfo libze-dev intel-ocloc

这一步不做,/dev/dxg 在、is_available() 还是 False。很多人卡在这里去重装 torch,方向错了。

装 wheel:一条命令,三层验证

python -m pip install --only-binary=:all: torch torchvision torchaudio \
  --index-url https://download.pytorch.org/whl/xpu

--only-binary=:all: 不是装饰。没有匹配当前 Python 版本的 wheel 时,它直接报错;不加这个参数,pip 会安静地回退去编译源码,最后给你一个没有 XPU 后端的 CPU 版,装完体积还特别大。

装完分三层验证,缺哪一层都会在别处以别的方式炸出来:

import torch
print("torch:", torch.__version__, "| xpu build:", torch.version.xpu)
print("available:", torch.xpu.is_available(), "| count:", torch.xpu.device_count())

p = torch.xpu.get_device_properties(0)
print("device:", p.name)
print("vram: %.1f GiB" % (p.total_memory / 1024**3))
print("driver:", p.driver_version, "| runtime:", p.version)
print("igpu:", p.is_integrated_gpu, "| fp16:", p.has_fp16)

预期输出(示例,数值随卡型变化):

torch: 2.15.0+xpu | xpu build: 2.15.0+xpu
available: True | count: 1
device: Intel(R) Arc(TM) B580 Graphics
vram: 11.9 GiB
driver: 32.0.101.9033 | runtime: 1.6.x
igpu: False | fp16: True

几个字段各有用途。torch.version.xpu 为 None,说明装的是 CUDA 版或 CPU 版,跟驱动无关,别再查驱动了。is_integrated_gpu 在核显上是 True,这决定了后面显存档位怎么算——核显没有独立显存,total_memory 报的是驱动划给它的预算,会随系统内存变化。

has_fp64 值得单独查一次,A 系列上是 False。这不影响推理,但影响训练:官方文档明确写了 A 系列上要关掉 GradScaler,因为硬件不原生支持 FP64,而 GradScaler 要用到。

环境隔离:别让 pip 装到隔壁

pip 和 python 可能不是一对。装了 Anaconda 或曾用 --user 装过包的机器上,pip 常指向用户目录,python 用的是环境里的解释器。结果是 pip show torch 显示 XPU 版,import torch 加载的却是另一份。

用 python -m pip 可以消掉这个歧义。装完确认一次实际加载路径:

python -c "import torch; print(torch.__file__, torch.version.xpu)"

路径应该落在你建的那个环境目录下。落在用户目录,说明装串了,卸载重装比修路径快。

用 uv 的话多一个坑:它默认读 pyproject.toml,index 要写在 [[tool.uv.index]] 里,和 pip 的 --index-url 不是同一套配置。漏了这段,uv 会从 PyPI 拿默认 torch,装完一样没有 XPU 后端,而且 uv pip list 看不出区别。

第一个张量:顺手把计时陷阱躲掉

import time, torch

a = torch.randn(4096, 4096, device="xpu", dtype=torch.bfloat16)
b = torch.randn(4096, 4096, device="xpu", dtype=torch.bfloat16)
for _ in range(5):          # 预热:第一次会触发内核加载
    a @ b
torch.xpu.synchronize()

t0 = time.perf_counter()
for _ in range(20):
    c = a @ b
torch.xpu.synchronize()
dt = (time.perf_counter() - t0) / 20 * 1000

print(f"{dt:.2f} ms/iter | device={c.device} | dtype={c.dtype}")
print("allocated %.0f MiB | reserved %.0f MiB" % (
    torch.xpu.memory_allocated() / 1024**2,
    torch.xpu.max_memory_reserved() / 1024**2))

两处容易错。第一是没有第二个 synchronize():你测到的是「把命令提交进队列」的时间,不是算完的时间。这个习惯从 CUDA 带过来,在 XPU 上一样成立,而且更隐蔽——XPU 的提交开销小,异步测出来的数字看着特别漂亮。

第二是没预热。第一次执行包含内核二进制加载和分配器首次扩张,这个时间摊进平均值会得到完全无意义的结论。至少丢掉前 3 到 5 次。

allocated 和 reserved 的差额是缓存分配器留着的空闲块。张量删掉后 allocated 会降,reserved 不会,得 torch.xpu.empty_cache() 才还回去。判断「显存被谁占了」,看这两个数比看任务管理器准。

torch.xpu.mem_get_info() 返回驱动视角的(空闲,总量),和上面两个数不是同一个来源。三个数一起看,才能分清是分配器囤着,还是别的进程在抢。

从张量到模型,多验证一件事

矩阵乘通过,只证明「XPU 能算」,不证明「你那个模型能在 XPU 上跑」。中间还隔着算子覆盖和 dtype 支持。

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

name = "Qwen/Qwen2.5-0.5B-Instruct"
tok = AutoTokenizer.from_pretrained(name)
model = AutoModelForCausalLM.from_pretrained(name, dtype=torch.bfloat16).to("xpu")

ids = tok("用一句话解释显存带宽", return_tensors="pt").to("xpu")
with torch.no_grad():
    out = model.generate(**ids, max_new_tokens=32, do_sample=False)
torch.xpu.synchronize()
print(tok.decode(out[0], skip_special_tokens=True))
print("peak %.0f MiB" % (torch.xpu.max_memory_allocated() / 1024**2))

用 0.5B 而不是 7B,是因为这一步要验证的是链路而不是性能。跑通之后再换大模型,出问题时至少能确定不是环境。max_memory_allocated() 给出的峰值可以和权重体积对一下:bf16 的 0.5B 约 1 GiB,加上 KV 和中间激活,峰值落在 1.5 到 2 GiB 之间算正常。

12GB 卡上的三笔账

显存不是一块,是三块,而且比例和直觉相反。

第一笔是权重。bf16 每参数 2 字节,7B 约 14 GiB,加上词表之类零碎会到 16 GiB 以上。int4 大约每参数 0.5 字节,7B 落到 4 GiB 附近。12GB 卡上 bf16 的现实上限是 3B 级;16GB 卡也装不下 7B 的 bf16,因为权重本身就越线了,它买到的是量化之后的余量。

第二笔是 KV 缓存,按 token 算。公式是 2 × KV 头数 × head_dim × 字节数 × 层数。Qwen2.5-7B 是 28 层、4 个 KV 头、head_dim 128,bf16 下每 token 56 KiB,8k 上下文就是 448 MiB。这部分随上下文线性涨,跟模型大小无关。

第三笔是激活和框架开销,1 到 2 GiB,跟 batch、序列长度、算子实现都有关系。它最容易在估算时被忘掉,也最容易在实测时让人怀疑人生。

三笔加起来,12GB 卡跑 7B int4 加 8k 上下文是可行的,但没余量做并发。想知道具体某个模型某个量化档位塞不塞得进,先按参数量、量化字节数、上下文长度算一遍,比装完再 OOM 便宜得多。

训练也支持,但边界更窄

按官方文档,XPU 后端同时支持训练和推理,eager 和 torch.compile 两条路都通,fp32、bf16、fp16 和自动混合精度也都在支持列表里。Windows 上的 torch.compile 从 PyTorch 2.7 起可用。

窄的地方在两个具体的点:Arc A 系列没有原生 FP64,GradScaler 要关;torch.compile 在 Windows 上依赖驱动里的 LevelZeroSDK 组件,缺了它编译期直接失败,而 eager 仍然正常。这两条都不影响推理,只影响训练和编译。

把 CPU 脚本改过来:五处

一张对照表比读文档快。

CPU / CUDA 写法XPU 写法说明
.to("cpu")、.to("cuda").to("xpu")纯字符串替换
torch.cuda.synchronize()torch.xpu.synchronize()计时前必须有
torch.cuda.manual_seed(0)torch.xpu.manual_seed(0)复现性
autocast(device_type="cuda")device_type="xpu"先查 bf16
DataLoader(..., pin_memory=True)去掉torch.xpu 没有 pin_memory()

最小改动版长这样:

import torch

dev = (torch.accelerator.current_accelerator().type
       if torch.accelerator.is_available() else "cpu")

model = model.to(dev).eval()
x = x.to(dev)
with torch.no_grad():
    y = model(x)
torch.accelerator.synchronize()

torch.accelerator 是统一入口,同一份脚本在 CUDA 机器和 Arc 上都能跑,不用写 if/else 分支。报错信息里的设备名仍然是 xpu,不会因为这层抽象变成别的字符串。

多卡机器上切换当前设备用上下文管理器,比手动 set 再改回来安全:

with torch.xpu.device(1):
    y = model(x)          # 这次分配落在 xpu:1
print(torch.xpu.device_of(y))   # 按张量反查设备

pin_memory 那一条值得单独说:torch.xpu 的 API 列表里没有 pin_memory(),照抄 CUDA 脚本时它不会报错,只会白占一块主机内存。数据加载想快,先把 batch 调大、把预处理挪到 GPU 上,比折腾固定页内存有效。

还有一个隐形差异:CUDA 代码里到处是 torch.cuda.is_available(),迁到 XPU 时如果只改字符串会得到一个永远 False 的分支,于是整个脚本默默跑在 CPU 上。这类「静默降级」比报错难查得多,改完先打印一次 dev。

不用改的部分

不用改的比想象中多。state_dict 的 key、optimizer 的实现、Dataset 的逻辑、torch.save 和 torch.load 的格式,全都和设备无关。真正绑设备只有三件事:张量在哪儿、随机数在哪儿生成、同步在哪儿发生。

所以迁移的工作量集中在入口和出口:模型和数据的 .to(),以及计时、日志里的 synchronize()。中间那一大坨前向反向代码,一行都不用动。这也解释了为什么很多脚本改完之后行为完全一致,只有速度变了。

如果你只想在 Arc 上跑 GGUF 而不写 Python,这条路可以直接跳过:llama.cpp 的预编译包和 KoboldCpp 的后端选择都不需要 PyTorch,装完就能用。

要继续在 PyTorch 这条路上走,下一步是把已有代码迁过来:设备字符串之外还有五处差异,其中三处不是改字符串能解决的。动手前先按这张按参数量分档的显存表确认卡装得下,比跑通 import 更有意义。

跑不通时,别从 Python 往下查

顺序反过来最省时间:先 xpu-smi discovery 有设备,再 is_available() 为 True,最后才怀疑脚本。三层里任意一层断了,上层看到的都是「正常」。

症状大概率指向先跑哪条命令
torch.version.xpu 是 Nonewheel 来源不对pip show torch 看版本后缀
版本对但 available 为 False驱动或运行时xpu-smi discovery
available True、count 是 0设备被环境变量过滤echo $ONEAPI_DEVICE_SELECTOR
容器里 False、宿主机 True设备没透传或组权限docker run --device=/dev/dri
能 import 不能算算子没覆盖按算子回退的排查逐个确认

ONEAPI_DEVICE_SELECTOR 的写法是 level_zero:0、level_zero:1 这种形式,按 Level Zero 的设备索引选。双显卡机器上可以拿它做隔离验证:只留独显跑一次,只留核显跑一次。两次都 True,说明两个设备都健康,问题在调度优先级;只有一次 True,坏的那张单独查驱动。

还有一条容易被忽略的时序问题:torch.xpu 的设备池在进程内只初始化一次。改完环境变量、装完运行时、加完用户组,在同一个解释器里重试不会变。所有验证都要新开进程,Jupyter 要重启内核。

装完之后容易失效的两件事

第一件是驱动被换掉。Windows Update 在部分机型上会把 Arc 驱动替换成更老的 WHQL 版本,DriverVersion 掉回基线以下,is_available() 直接变 False,表现是「上周还好的」。

第二件是 pip install -U。不带 --index-url 的升级会从 PyPI 拉默认 torch,把 XPU 版覆盖掉,不提示也不报错,下次 import 才发现。可行的做法是 requirements 里写死带 +xpu 的版本号,再加一份 constraints 锁住。

两件事都可以用一行定期自检:

python -c "import torch; print(torch.version.xpu, torch.xpu.is_available())"

第一个值是 None 就去查 wheel,是正常版本但第二个值是 False 就去查驱动和运行时。别倒过来查。

判断自己是否真的跑在卡上,别只看 is_available()。看三件事:c.device 是 xpu:0、memory_allocated() 随张量增长、把矩阵从 4096 加到 8192 时耗时按立方增长而不是按平方。三条都过,这条路径对你才算成立;没过的,把上面那张症状表从下往上再走一遍。

登录后可点赞、收藏与反馈。

继续阅读 NEXT

更多 →