详解win10下pytorch-gpu安装以及CUDA详细安装过程

在Windows 10下安装PyTorch GPU版本需要安装CUDA和cuDNN,本文将详细讲解如何安装PyTorch GPU版本以及CUDA和cuDNN,并提供两个示例说明。

1. 安装PyTorch GPU版本

在安装PyTorch GPU版本之前,需要先安装CUDA和cuDNN。安装完成后,可以通过以下步骤安装PyTorch GPU版本:

  1. 打开Anaconda Prompt或者命令行窗口,创建一个新的虚拟环境:

conda create --name pytorch_gpu python=3.8

  1. 激活虚拟环境:

conda activate pytorch_gpu

  1. 安装PyTorch GPU版本:

conda install pytorch torchvision torchaudio cudatoolkit=11.1 -c pytorch -c nvidia

其中,cudatoolkit=11.1表示安装CUDA 11.1版本,可以根据自己的需求选择不同的版本。

  1. 安装完成后,可以通过以下代码测试PyTorch是否安装成功:

python
import torch
print(torch.cuda.is_available())

如果输出True,则表示PyTorch GPU版本安装成功。

2. 安装CUDA和cuDNN

在安装PyTorch GPU版本之前,需要先安装CUDA和cuDNN。以下是安装CUDA和cuDNN的详细步骤:

  1. 下载CUDA安装包

在NVIDIA官网上下载CUDA安装包,选择与自己的显卡和操作系统版本相对应的安装包。

  1. 安装CUDA

双击下载的CUDA安装包,按照提示进行安装。在安装过程中,需要选择自定义安装,并选择安装CUDA Toolkit和CUDA Tools。

  1. 下载cuDNN

在NVIDIA官网上下载cuDNN,选择与自己的CUDA版本相对应的cuDNN版本。

  1. 安装cuDNN

解压下载的cuDNN压缩包,将其中的bin、include和lib文件夹复制到CUDA安装目录下的对应文件夹中。

  1. 配置环境变量

在系统环境变量中添加以下变量:

CUDA_HOME:CUDA安装目录
Path:添加CUDA安装目录下的bin文件夹路径

  1. 测试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技术站

(0)
上一篇 2023年5月15日
下一篇 2023年5月15日

相关文章

  • Pytorch固定某些层的操作

    1. model = models.resnet18(pretrained=False,num_classes=CIFAR10_num_classes) def my_forward(model, x): mo = nn.Sequential(*list(model.children())[:-1]) feature = mo(x) feature = fe…

    PyTorch 2023年4月8日
    00
  • pytorch实现模型剪枝的操作方法

    PyTorch 实现模型剪枝的操作方法 模型剪枝是一种常见的模型压缩技术,它可以通过去除模型中不必要的参数和结构来减小模型的大小和计算量,从而提高模型的效率和速度。在 PyTorch 中,我们可以使用一些库和工具来实现模型剪枝。本文将详细讲解 PyTorch 实现模型剪枝的操作方法,并提供两个示例说明。 1. PyTorch 实现模型剪枝的基本步骤 在 Py…

    PyTorch 2023年5月16日
    00
  • pytorch 5 classification 分类

    import torch from torch.autograd import Variable import torch.nn.functional as F import matplotlib.pyplot as plt n_data = torch.ones(100, 2) # 100个具有2个属性的数据 shape=(100,2) x0 = torc…

    2023年4月8日
    00
  • PyTorch LSTM,batch_first=True对初始化h0和c0的影响

    batch_first=True会对LSTM的输入输出的维度顺序有影响,但是对初始化h0和c0的维度顺序没有影响,也就是说,不管batch_first=True还是False,h0和c0的维度顺序都是:     关于LSTM的输入输出,可参考这篇博客。  

    2023年4月7日
    00
  • PyTorch的自适应池化Adaptive Pooling实例

    PyTorch的自适应池化Adaptive Pooling实例 在 PyTorch 中,自适应池化(Adaptive Pooling)是一种常见的池化操作,它可以根据输入的大小自动调整池化的大小。本文将详细讲解 PyTorch 中自适应池化的实现方法,并提供两个示例说明。 1. 二维自适应池化 在 PyTorch 中,我们可以使用 nn.AdaptiveAv…

    PyTorch 2023年5月16日
    00
  • weight_decay in Pytorch

    在训练人脸属性网络时,发现在优化器里增加weight_decay=1e-4反而使准确率下降 pytorch论坛里说是因为pytorch对BN层的系数也进行了weight_decay,导致BN层的系数趋近于0,使得BN的结果毫无意义甚至错误 当然也有办法不对BN层进行weight_decay, 详见pytorch forums讨论1pytorch forums…

    PyTorch 2023年4月8日
    00
  • pytorch实现vgg19 训练自定义分类图片

    1、vgg19模型——pytorch 版本= 1.1.0  实现  # coding:utf-8 import torch.nn as nn import torch class vgg19_Net(nn.Module): def __init__(self,in_img_rgb=3,in_img_size=64,out_class=1000,in_fc_s…

    2023年4月8日
    00
  • pytorch两种模型保存方式

      只保存模型参数   # 保存 torch.save(model.state_dict(), ‘\parameter.pkl’) # 加载 model = TheModelClass(…) model.load_state_dict(torch.load(‘\parameter.pkl’))      保存完整模型   # 保存 torch.save(…

    PyTorch 2023年4月8日
    00
合作推广
合作推广
分享本页
返回顶部