目录
  • 文档 >
  • 在英特尔 GPU 上入门
快捷键

在英特尔 GPU 上入门 ¶

硬件要求 ¶

针对英特尔数据中心 GPU

设备

红帽企业 Linux 9.2

SUSE 企业 Linux 服务器 15 SP5

Ubuntu 服务器 22.04（>= 5.15 LTS 内核）

英特尔数据中心 GPU 至强系列（代号：庞特韦奇奥）

是的

是的

是的

英特尔客户端 GPU

支持的操作系统

已验证硬件
Windows 10/11 & Ubuntu 24.10
英特尔® Arc A 系列显卡（代号：炼金术士）
英特尔® Arc B 系列显卡（代号：斗士法师）
英特尔® Core™ Ultra 处理器系列搭载英特尔® Arc™ 显卡（代号：流星湖）
英特尔® Core™ Ultra 200V 系列搭载英特尔® Arc™ 显卡（代号：月湖）
英特尔® Core™ Ultra 系列 2 处理器，配备英特尔® Arc™ 图形（代号：箭湖）
Ubuntu 24.04 & WSL2（Ubuntu 24.04）
英特尔® Arc A 系列图形（代号：炼金术士）
英特尔® Core™ Ultra 处理器，配备英特尔® Arc™ 图形（代号：流星湖）
英特尔® Core™ Ultra 200V 系列搭载英特尔® Arc™显卡（代号：Lunar Lake）
英特尔® Core™ Ultra 系列 2 处理器搭载英特尔® Arc™显卡（代号：Arrow Lake）

英特尔 GPU 支持（原型）已从 PyTorch* 2.5 开始支持英特尔®客户端 GPU 和英特尔®数据中心 GPU Max 系列，在 Linux 和 Windows 上均可用，将英特尔 GPU 和 SYCL*软件栈纳入官方 PyTorch 堆栈，提供一致的用户体验，以拥抱更多 AI 应用场景。

软件先决条件 ¶

要在 Intel GPU 上使用 PyTorch，您需要首先安装 Intel GPU 驱动程序。有关安装指南，请访问 Intel GPU 驱动程序安装页面。

如果您从二进制文件安装，请跳过 Intel®深度学习基础安装部分。如果您从源代码构建，请参阅 PyTorch 安装先决条件，包括 Intel GPU 驱动程序和 Intel®深度学习基础安装。

安装¶

二进制文件

现在我们已经安装了 Intel GPU 驱动程序，请使用以下命令在 Linux 上安装 pytorch ， torchvision ， torchaudio 。

用于发布轮子

pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/xpu

用于夜间轮子

pip3 install --pre torch torchvision torchaudio --index-url https://download.pytorch.org/whl/nightly/xpu

从源代码 ¶

现在我们已经安装了英特尔 GPU 驱动程序和英特尔®深度学习工具包。按照指南从源代码构建 pytorch ， torchvision ， torchaudio 。

从源代码构建，参考 torch PyTorch 安装从源代码构建。

从源代码构建，参考 torchvision Torchvision 安装从源代码构建。

从源代码构建，参考 torchaudio Torchaudio 安装从源代码构建。

检查 Intel GPU 的可用性 ¶

检查您的 Intel GPU 是否可用，您通常会使用以下代码：

import torch
torch.xpu.is_available()  # torch.xpu is the API for Intel GPU support

如果输出为 False ，请再次检查 Intel GPU 的驱动程序安装。

最小代码更改

如果您正在从 cuda 迁移代码，您将更改引用从 cuda 到 xpu 。例如：

# CUDA CODE
tensor = torch.tensor([1.0, 2.0]).to("cuda")

# CODE for Intel GPU
tensor = torch.tensor([1.0, 2.0]).to("xpu")

以下列出了 PyTorch 与 Intel GPU 的兼容性和限制：

  1. 支持训练和推理工作流程。

  2. 支持急切模式和 torch.compile 。从 PyTorch* 2.7 开始，在 Windows 上还支持 torch.compile 功能，请参阅如何在 Windows 上使用 CPU/XPU 的 Inductor。

  3. 支持 FP32、BF16、FP16 和自动混合精度（AMP）等数据类型。

示例 ¶

本节包含推理和训练工作流程的用法示例。

推理示例 ¶

这里有一些推理工作流程的示例。

使用 FP32 进行推理 ¶

import torch
import torchvision.models as models

model = models.resnet50(weights="ResNet50_Weights.DEFAULT")
model.eval()
data = torch.rand(1, 3, 224, 224)

model = model.to("xpu")
data = data.to("xpu")

with torch.no_grad():
    model(data)

print("Execution finished")

使用 AMP 进行推理

import torch
import torchvision.models as models

model = models.resnet50(weights="ResNet50_Weights.DEFAULT")
model.eval()
data = torch.rand(1, 3, 224, 224)

model = model.to("xpu")
data = data.to("xpu")

with torch.no_grad():
    d = torch.rand(1, 3, 224, 224)
    d = d.to("xpu")
    # set dtype=torch.bfloat16 for BF16
    with torch.autocast(device_type="xpu", dtype=torch.float16, enabled=True):
        model(data)

print("Execution finished")

使用 torch.compile 进行推理

import torch
import torchvision.models as models
import time

model = models.resnet50(weights="ResNet50_Weights.DEFAULT")
model.eval()
data = torch.rand(1, 3, 224, 224)
ITERS = 10

model = model.to("xpu")
data = data.to("xpu")

for i in range(ITERS):
    start = time.time()
    with torch.no_grad():
        model(data)
        torch.xpu.synchronize()
    end = time.time()
    print(f"Inference time before torch.compile for iteration {i}: {(end-start)*1000} ms")

model = torch.compile(model)
for i in range(ITERS):
    start = time.time()
    with torch.no_grad():
        model(data)
        torch.xpu.synchronize()
    end = time.time()
    print(f"Inference time after torch.compile for iteration {i}: {(end-start)*1000} ms")

print("Execution finished")

训练示例

这里有一些训练工作流程的示例。

使用 FP32 训练 ¶

import torch
import torchvision

LR = 0.001
DOWNLOAD = True
DATA = "datasets/cifar10/"

transform = torchvision.transforms.Compose(
    [
        torchvision.transforms.Resize((224, 224)),
        torchvision.transforms.ToTensor(),
        torchvision.transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),
    ]
)
train_dataset = torchvision.datasets.CIFAR10(
    root=DATA,
    train=True,
    transform=transform,
    download=DOWNLOAD,
)
train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=128)
train_len = len(train_loader)

model = torchvision.models.resnet50()
criterion = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(model.parameters(), lr=LR, momentum=0.9)
model.train()
model = model.to("xpu")
criterion = criterion.to("xpu")

print(f"Initiating training")
for batch_idx, (data, target) in enumerate(train_loader):
    data = data.to("xpu")
    target = target.to("xpu")
    optimizer.zero_grad()
    output = model(data)
    loss = criterion(output, target)
    loss.backward()
    optimizer.step()
    if (batch_idx + 1) % 10 == 0:
         iteration_loss = loss.item()
         print(f"Iteration [{batch_idx+1}/{train_len}], Loss: {iteration_loss:.4f}")
torch.save(
    {
        "model_state_dict": model.state_dict(),
        "optimizer_state_dict": optimizer.state_dict(),
    },
    "checkpoint.pth",
)

print("Execution finished")

使用 AMP 训练 ¶

注意：使用 GradScaler 需要 FP64 的硬件支持。 FP64 不是 Intel® Arc™ A 系列显卡的原生支持。如果您在 Intel® Arc™ A 系列显卡上运行工作负载，请禁用 GradScaler 。

import torch
import torchvision

LR = 0.001
DOWNLOAD = True
DATA = "datasets/cifar10/"

use_amp=True

transform = torchvision.transforms.Compose(
    [
        torchvision.transforms.Resize((224, 224)),
        torchvision.transforms.ToTensor(),
        torchvision.transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),
    ]
)
train_dataset = torchvision.datasets.CIFAR10(
    root=DATA,
    train=True,
    transform=transform,
    download=DOWNLOAD,
)
train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=128)
train_len = len(train_loader)

model = torchvision.models.resnet50()
criterion = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(model.parameters(), lr=LR, momentum=0.9)
scaler = torch.amp.GradScaler(device="xpu", enabled=use_amp)

model.train()
model = model.to("xpu")
criterion = criterion.to("xpu")

print(f"Initiating training")
for batch_idx, (data, target) in enumerate(train_loader):
    data = data.to("xpu")
    target = target.to("xpu")
    # set dtype=torch.bfloat16 for BF16
    with torch.autocast(device_type="xpu", dtype=torch.float16, enabled=use_amp):
        output = model(data)
        loss = criterion(output, target)
    scaler.scale(loss).backward()
    scaler.step(optimizer)
    scaler.update()
    optimizer.zero_grad()
    if (batch_idx + 1) % 10 == 0:
         iteration_loss = loss.item()
         print(f"Iteration [{batch_idx+1}/{train_len}], Loss: {iteration_loss:.4f}")

torch.save(
    {
        "model_state_dict": model.state_dict(),
        "optimizer_state_dict": optimizer.state_dict(),
    },
    "checkpoint.pth",
)

print("Execution finished")

使用 torch.compile 训练 ¶

import torch
import torchvision

LR = 0.001
DOWNLOAD = True
DATA = "datasets/cifar10/"

transform = torchvision.transforms.Compose(
    [
        torchvision.transforms.Resize((224, 224)),
        torchvision.transforms.ToTensor(),
        torchvision.transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),
    ]
)
train_dataset = torchvision.datasets.CIFAR10(
    root=DATA,
    train=True,
    transform=transform,
    download=DOWNLOAD,
)
train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=128)
train_len = len(train_loader)

model = torchvision.models.resnet50()
criterion = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(model.parameters(), lr=LR, momentum=0.9)
model.train()
model = model.to("xpu")
criterion = criterion.to("xpu")
model = torch.compile(model)

print(f"Initiating training with torch compile")
for batch_idx, (data, target) in enumerate(train_loader):
    data = data.to("xpu")
    target = target.to("xpu")
    optimizer.zero_grad()
    output = model(data)
    loss = criterion(output, target)
    loss.backward()
    optimizer.step()
    if (batch_idx + 1) % 10 == 0:
         iteration_loss = loss.item()
         print(f"Iteration [{batch_idx+1}/{train_len}], Loss: {iteration_loss:.4f}")
torch.save(
    {
        "model_state_dict": model.state_dict(),
        "optimizer_state_dict": optimizer.state_dict(),
    },
    "checkpoint.pth",
)

print("Execution finished")

© 版权所有 PyTorch 贡献者。

使用 Sphinx 构建，并使用 Read the Docs 提供的主题。

文档

PyTorch 的全面开发者文档

查看文档

教程

深入了解初学者和高级开发者的教程

查看教程

资源

查找开发资源并获得您的疑问解答

查看资源

为了分析流量并优化您的体验，我们在本网站上使用 cookies。通过点击或导航，您同意允许我们使用 cookies。作为本网站的当前维护者，适用 Facebook 的 Cookies 政策。了解更多信息，包括关于可用控制的信息：Cookies 政策。