在Windows 10下安装PyTorch GPU版本需要安装CUDA和cuDNN，本文将详细讲解如何安装PyTorch GPU版本以及CUDA和cuDNN，并提供两个示例说明。
1. 安装PyTorch GPU版本
在安装PyTorch GPU版本之前，需要先安装CUDA和cuDNN。安装完成后，可以通过以下步骤安装PyTorch GPU版本：
- 打开Anaconda Prompt或者命令行窗口，创建一个新的虚拟环境：
conda create --name pytorch_gpu python=3.8
- 激活虚拟环境：
conda activate pytorch_gpu
- 安装PyTorch GPU版本：
conda install pytorch torchvision torchaudio cudatoolkit=11.1 -c pytorch -c nvidia
其中，cudatoolkit=11.1表示安装CUDA 11.1版本，可以根据自己的需求选择不同的版本。
- 安装完成后，可以通过以下代码测试PyTorch是否安装成功：
python
import torch
print(torch.cuda.is_available())
如果输出True，则表示PyTorch GPU版本安装成功。
2. 安装CUDA和cuDNN
在安装PyTorch GPU版本之前，需要先安装CUDA和cuDNN。以下是安装CUDA和cuDNN的详细步骤：
- 下载CUDA安装包
在NVIDIA官网上下载CUDA安装包，选择与自己的显卡和操作系统版本相对应的安装包。
- 安装CUDA
双击下载的CUDA安装包，按照提示进行安装。在安装过程中，需要选择自定义安装，并选择安装CUDA Toolkit和CUDA Tools。
- 下载cuDNN
在NVIDIA官网上下载cuDNN，选择与自己的CUDA版本相对应的cuDNN版本。
- 安装cuDNN
解压下载的cuDNN压缩包，将其中的bin、include和lib文件夹复制到CUDA安装目录下的对应文件夹中。
- 配置环境变量
在系统环境变量中添加以下变量：
CUDA_HOME：CUDA安装目录
Path：添加CUDA安装目录下的bin文件夹路径
- 测试CUDA和cuDNN是否安装成功
打开命令行窗口，输入以下命令：
nvcc -V
如果输出CUDA版本信息，则表示CUDA安装成功。
然后，打开Python解释器，输入以下代码：
python
import torch
print(torch.cuda.is_available())
如果输出True，则表示cuDNN安装成功。
3. 示例3：使用PyTorch GPU版本进行图像分类
以下是使用PyTorch GPU版本进行图像分类的示例代码：
import torch
import torch.nn as nn
import torch.optim as optim
import torchvision
import torchvision.transforms as transforms
# 定义模型
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(3, 6, 5)
self.pool = nn.MaxPool2d(2, 2)
self.conv2 = nn.Conv2d(6, 16, 5)
self.fc1 = nn.Linear(16 * 5 * 5, 120)
self.fc2 = nn.Linear(120, 84)
self.fc3 = nn.Linear(84, 10)
def forward(self, x):
x = self.pool(torch.relu(self.conv1(x)))
x = self.pool(torch.relu(self.conv2(x)))
x = x.view(-1, 16 * 5 * 5)
x = torch.relu(self.fc1(x))
x = torch.relu(self.fc2(x))
x = self.fc3(x)
return x
# 加载数据集
transform = transforms.Compose(
[transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
trainset = torchvision.datasets.CIFAR10(root='./data', train=True,
download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=4,
shuffle=True, num_workers=2)
testset = torchvision.datasets.CIFAR10(root='./data', train=False,
download=True, transform=transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=4,
shuffle=False, num_workers=2)
# 实例化模型
net = Net()
# 将模型和数据移动到GPU上
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
net.to(device)
# 定义损失函数和优化器
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
# 训练模型
for epoch in range(2):
running_loss = 0.0
for i, data in enumerate(trainloader, 0):
inputs, labels = data[0].to(device), data[1].to(device)
optimizer.zero_grad()
outputs = net(inputs)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
running_loss += loss.item()
if i % 2000 == 1999:
print('[%d, %5d] loss: %.3f' %
(epoch + 1, i + 1, running_loss / 2000))
running_loss = 0.0
print('Finished Training')
# 测试模型
correct = 0
total = 0
with torch.no_grad():
for data in testloader:
images, labels = data[0].to(device), data[1].to(device)
outputs = net(images)
_, predicted = torch.max(outputs.data, 1)
total += labels.size(0)
correct += (predicted == labels).sum().item()
print('Accuracy of the network on the 10000 test images: %d %%' % (
100 * correct / total))
在上面的代码中，我们首先定义了一个包含两个卷积层和三个全连接层的模型Net。然后，我们使用torchvision.datasets.CIFAR10()方法加载CIFAR10数据集，并使用torch.utils.data.DataLoader()方法将数据集分成小批量进行训练。接下来，我们实例化了该模型，并使用torch.device()方法将模型和数据移动到GPU上。然后，我们定义了损失函数和优化器，并使用它们训练模型。最后，我们使用torch.no_grad()方法关闭梯度计算，进行模型测试，并计算模型的准确率。
4. 示例4：使用PyTorch GPU版本进行文本分类
以下是使用PyTorch GPU版本进行文本分类的示例代码：
import torch
import torch.nn as nn
import torch.optim as optim
from torchtext.datasets import IMDB
from torchtext.data import Field, LabelField, BucketIterator
# 定义Field
TEXT = Field(tokenize='spacy', lower=True)
LABEL = LabelField(dtype=torch.float)
# 加载数据集
train_data, test_data = IMDB.splits(TEXT, LABEL)
train_data, valid_data = train_data.split(random_state=random.seed(1234))
# 构建词汇表
TEXT.build_vocab(train_data, max_size=25000, vectors="glove.6B.100d")
LABEL.build_vocab(train_data)
# 加载数据迭代器
BATCH_SIZE = 64
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
train_iterator, valid_iterator, test_iterator = BucketIterator.splits(
(train_data, valid_data, test_data), batch_size=BATCH_SIZE, device=device)
# 定义模型
class Net(nn.Module):
def __init__(self, vocab_size, embedding_dim, hidden_dim, output_dim, n_layers, bidirectional, dropout):
super().__init__()
self.embedding = nn.Embedding(vocab_size, embedding_dim)
self.rnn = nn.LSTM(embedding_dim, hidden_dim, num_layers=n_layers, bidirectional=bidirectional, dropout=dropout)
self.fc = nn.Linear(hidden_dim * 2 if bidirectional else hidden_dim, output_dim)
self.dropout = nn.Dropout(dropout)
def forward(self, text):
embedded = self.dropout(self.embedding(text))
output, (hidden, cell) = self.rnn(embedded)
if self.rnn.bidirectional:
hidden = self.dropout(torch.cat((hidden[-2, :, :], hidden[-1, :, :]), dim=1))
else:
hidden = self.dropout(hidden[-1, :, :])
return self.fc(hidden)
# 实例化模型
VOCAB_SIZE = len(TEXT.vocab)
EMBEDDING_DIM = 100
HIDDEN_DIM = 256
OUTPUT_DIM = 1
N_LAYERS = 2
BIDIRECTIONAL = True
DROPOUT = 0.5
net = Net(VOCAB_SIZE, EMBEDDING_DIM, HIDDEN_DIM, OUTPUT_DIM, N_LAYERS, BIDIRECTIONAL, DROPOUT)
# 将模型和数据移动到GPU上
net = net.to(device)
# 定义损失函数和优化器
criterion = nn.BCEWithLogitsLoss()
optimizer = optim.Adam(net.parameters())
# 训练模型
for epoch in range(5):
running_loss = 0.0
for i, batch in enumerate(train_iterator):
text, label = batch.text, batch.label
optimizer.zero_grad()
output = net(text).squeeze(1)
loss = criterion(output, label)
loss.backward()
optimizer.step()
running_loss += loss.item()
if i % 1000 == 999:
print('[%d, %5d] loss: %.3f' %
(epoch + 1, i + 1, running_loss / 1000))
running_loss = 0.0
print('Finished Training')
# 测试模型
correct = 0
total = 0
with torch.no_grad():
for batch in test_iterator:
text, label = batch.text, batch.label
output = net(text).squeeze(1)
predicted = torch.round(torch.sigmoid(output))
total += label.size(0)
correct += (predicted == label).sum().item()
print('Accuracy of the network on the test data: %d %%' % (
100 * correct / total))
在上面的代码中，我们首先定义了一个包含一个LSTM层和一个全连接层的模型Net。然后，我们使用torchtext.datasets.IMDB()方法加载IMDB数据集，并使用torchtext.data.Field()方法定义文本和标签的处理方式。接下来，我们构建了词汇表，并使用torchtext.data.BucketIterator()方法将数据集分成小批量进行训练。然后，我们实例化了该模型，并使用torch.device()方法将模型和数据移动到GPU上。接下来，我们定义了损失函数和优化器，并使用它们训练模型。最后，我们使用torch.no_grad()方法关闭梯度计算，进行模型测试，并计算模型的准确率。
以上就是在Windows 10下安装PyTorch GPU版本以及CUDA和cuDNN的详细步骤，以及两个使用PyTorch GPU版本进行图像分类和文本分类的示例代码。
本站文章如无特殊说明，均为本站原创，如若转载，请注明出处：详解win10下pytorch-gpu安装以及CUDA详细安装过程 - Python技术站
微信扫一扫 
支付宝扫一扫 