在 Intel GPU 上開始使用¶

硬體先決條件¶

針對 Intel 資料中心 GPU

裝置	Red Hat* Enterprise Linux* 9.2	SUSE Linux Enterprise Server* 15 SP5	Ubuntu* Server 22.04（>= 5.15 LTS 核心）
英特爾® 資料中心 GPU Max 系列（代號：Ponte Vecchio）	是	是	是

針對 Intel 客戶端 GPU

支援的作業系統

已驗證硬體

Windows 10/11 與 Ubuntu 24.10

英特爾® Arc A 系列顯示卡（代號：Alchemist）
英特爾® Arc B 系列顯示卡（代號：Battlemage）
搭載英特爾® Arc™ 顯示卡的英特爾® 酷睿™ Ultra 處理器（代號：Meteor Lake）
搭載英特爾® Arc™ 顯示卡的英特爾® 酷睿™ Ultra 200V 系列處理器（代號：Lunar Lake）
搭載英特爾® Arc™ 顯示卡的英特爾® 酷睿™ Ultra 系列 2 處理器（代號：Arrow Lake）

Ubuntu 24.04 與 WSL2 (Ubuntu 24.04)

英特爾® Arc A 系列顯示卡（代號：Alchemist）
搭載英特爾® Arc™ 顯示卡的英特爾® 酷睿™ Ultra 處理器（代號：Meteor Lake）
搭載英特爾® Arc™ 顯示卡的英特爾® 酷睿™ Ultra 200V 系列處理器（代號：Lunar Lake）
搭載英特爾® Arc™ 顯示卡的英特爾® 酷睿™ Ultra 系列 2 處理器（代號：Arrow Lake）

從 PyTorch* 2.5 版本開始，Intel GPU 支援（原型）已面向 Linux 和 Windows 上的英特爾® 客戶端 GPU 和英特爾® 資料中心 GPU Max 系列提供，這將 Intel GPU 和 SYCL* 軟體棧整合到官方 PyTorch 棧中，提供一致的使用者體驗，以適應更多 AI 應用場景。

軟體先決條件¶

要在 Intel GPU 上使用 PyTorch，您首先需要安裝 Intel GPU 驅動程式。有關安裝指南，請訪問 Intel GPU 驅動程式安裝。

如果您從二進位制檔案安裝，請跳過 Intel® Deep Learning Essentials 安裝部分。要從原始碼構建，請參閱 Intel GPU 的 PyTorch 安裝先決條件，瞭解 Intel GPU 驅動程式和 Intel® Deep Learning Essentials 的安裝方法。

安裝¶

二進位制檔案¶

在安裝了 Intel GPU 驅動程式後，使用以下命令在 Linux 上安裝 pytorch、torchvision 和 torchaudio》。


針對釋出版 wheel
pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/xpu


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



從原始碼¶
在安裝了 Intel GPU 驅動程式和 Intel® Deep Learning Essentials 後。按照指南從原始碼構建 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 的支援和限制

支援訓練和推理工作流程。
支援 eager 模式和 torch.compile。從 PyTorch* 2.7 版本開始，Intel GPU 也支援在 Windows 上使用 torch.compile 功能，請參閱 如何在 Windows 上配合 CPU/XPU 使用 Inductor。
支援 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 不受英特爾® Arc™ A 系列顯示卡原生支援。如果您在英特爾® 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")

在 Intel GPU 上開始使用¶

硬體先決條件¶

軟體先決條件¶

安裝¶

二進位制檔案¶

從原始碼¶

檢查 Intel GPU 可用性¶

最低程式碼更改¶

示例¶

推理示例¶

使用 FP32 進行推理¶

使用 AMP 進行推理¶

使用 `torch.compile` 進行推理¶

訓練示例¶

使用 FP32 進行訓練¶

使用 AMP 進行訓練¶

使用 `torch.compile` 進行訓練¶

文件

教程

資源