目录
目录

Intel GPU 入门

硬件先决条件

经过验证的硬件

支持的操作系统

Intel® Data Center GPU Max 系列

Linux的

Intel 客户端 GPU

Windows/Linux 操作系统

英特尔 GPU 支持（测试版）已在 PyTorch* 2.5 中为英特尔®数据中心 GPU Max 系列和英特尔®客户端 GPU 在 Linux 和 Windows 上做好准备，它将英特尔 GPU 和 SYCL* 软件堆栈引入官方 PyTorch 堆栈，提供一致的用户体验，以拥抱更多的人工智能应用场景。

软件先决条件

有关以下方面的更多详细信息，请访问 Intel GPU 的 PyTorch 安装先决条件：

  1. Intel GPU 驱动程序安装

  2. Intel 支持软件包安装

  3. 环境设置

安装

二进制文件

平台 Linux

现在我们已经安装了所有必需的软件包并激活了环境。使用以下命令在 Linux 上安装 、 、 。pytorchtorchvisiontorchaudio

对于预览色盘

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

用于夜间车轮

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

平台窗口

现在我们已经安装了所有必需的软件包并激活了环境。使用以下命令在 Windows 上安装，从 和 的源代码构建。pytorchtorchvisiontorchaudio

对于预览色盘

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

用于夜间车轮

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

从源

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

从源构建 参考 Torchvision 安装 从源构建。torchvision

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

检查是否有空房 Intel GPU

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

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

如果输出为 ，请仔细检查以下步骤。False

  1. Intel GPU 驱动程序安装

  2. Intel 支持软件包安装

  3. 环境设置

最小代码更改

如果要将代码从 迁移，请将引用从 更改为 。例如：cudacudaxpu

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

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

以下几点概述了对带有 Intel GPU 的 PyTorch 的支持和限制：

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

  2. eager 模式和 均受支持。torch.compile

  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 进行训练

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(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 的全面开发人员文档

查看文档

教程

获取面向初学者和高级开发人员的深入教程

查看教程

资源

查找开发资源并解答您的问题

查看资源