目 錄

1 前期準備作業

2 Pytorch 的安裝與環境配置

2.1 查看并創建新的 conda 環境

2.2 部署新的 conda 環境到 Pycharm

2.3 安裝 cuda

2.4 下載安裝 cuDNN

2.5 下載安裝 pytorch

2.5.1 方法一：利用官網找到的命令列陳述句 （速度較慢）

2.5.2 方法二：下載 pytorch 的 whl 檔案到本地安裝（速度較快）

2.6 安裝 torchvision

3 測驗

3.1 測驗示例代碼

3.2 測驗結果

1 前期準備作業

前期應該了解電腦的系統型別、python 版本資訊以及擁有一款好用的 IDE（如：Pycharm 等）

下面展示的我電腦上的相關資訊：

• 系統型別：64位作業系統（×64）
• （Anaconda）python版本：3.7
• Pycharm 版本：PyCharm Community Edition 2020.2.3 x64

Anaconda 下載地址：https://www.anaconda.com/download/

Pycharm 下載地址：https://www.jetbrains.com/pycharm/

2 Pytorch 的安裝與環境配置

2.1 查看并創建新的 conda 環境

第一步：打開 Anaconda Prompt（Anaconda）

第二步：查看已有的 conda 環境

第三步：創建新的 conda 環境 taidi

回車運行，創建好新的 conda 環境后的示例圖如下

2.2 部署新的 conda 環境到 Pycharm

在 Pycharm 的Settings 中添加新的 Conda 環境

這時我們發現在測驗代碼中一些包庫下面有紅色波浪線，說明這些庫還沒有匯入，那么下一步就匯入這些庫，

2.3 安裝 cuda

對應我電腦的 python 環境，我選擇安裝 cuda 10.1 版本，當然讀者可根據自己需要對應安裝不同版本的 cuda，

cuda下載路徑：https://developer.nvidia.com/cuda-10.1-download-archive-base

解壓

2.4 下載安裝 cuDNN

在官網選擇與 cuda 版本對應的 cuDNN，

cudnn 下載路徑：https://developer.nvidia.com/rdp/cudnn-archive

將下載好的 cuDNN 應用程式放到桌面，雙擊圖示運行

等待初始化安裝完成

接下來的操作就依次按照下圖所示進行就好：

安裝好后進入本地路徑 C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v10.1 即可看到 CUDA 檔案資訊

接下來將前面解壓出的檔案全部復制粘貼到 C 盤目錄下的 CUDA 檔案夾中

2.5 下載安裝 pytorch

進入pytorch官網：https://pytorch.org/get-started/previous-versions/

2.5.1 方法一：利用官網找到的命令列陳述句 （速度較慢）

可以選用 conda 安裝也可以選用 pip 安裝（注意 CUDA 版本要對應）

接下來要將上圖所示對應代碼復制粘貼到 pycharm Terminal 中

值得注意的是，若命令列前的小括號內不是 taidi，需要首先執行下面陳述句切換到 taidi 環境中

conda activate taidi

正確的情況如下圖所示

將命令列陳述句粘貼過來回車運行，等待安裝完成即可，

2.5.2 方法二：下載 pytorch 的 whl 檔案到本地安裝（速度較快）

注：① 檔案路徑盡量選用絕對路徑，可有效避免報錯

② 為加快安裝速度，避免報“超時”錯誤，亦可輸入下面命令陳述句（原理：換源）

python -m pip install -i http://pypi.tuna.tsinghua.edu.cn/simple --trusted-host pypi.tuna.tsinghua.edu.cn  空格后緊跟下載本地路徑

若出現如下圖所示的內容，pytorch 大概率是安裝成功啦

2.6 安裝 torchvision

直接執行下面陳述句到 pycharm taidi 環境下的命令列即可

python -m pip install -i http://pypi.tuna.tsinghua.edu.cn/simple --trusted-host pypi.tuna.tsinghua.edu.cn torchvision

3 測驗

3.1 測驗示例代碼

from __future__ import print_function
import argparse
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torchvision import datasets, transforms
from torch.autograd import Variable

# Training settings
parser = argparse.ArgumentParser(description='PyTorch MNIST Example')
parser.add_argument('--batch-size', type=int, default=64, metavar='N',
                    help='input batch size for training (default: 64)')
parser.add_argument('--test-batch-size', type=int, default=1000, metavar='N',
                    help='input batch size for testing (default: 1000)')
parser.add_argument('--epochs', type=int, default=10, metavar='N',
                    help='number of epochs to train (default: 10)')
parser.add_argument('--lr', type=float, default=0.01, metavar='LR',
                    help='learning rate (default: 0.01)')
parser.add_argument('--momentum', type=float, default=0.5, metavar='M',
                    help='SGD momentum (default: 0.5)')
parser.add_argument('--no-cuda', action='store_true', default=False,
                    help='disables CUDA training')
parser.add_argument('--seed', type=int, default=1, metavar='S',
                    help='random seed (default: 1)')
parser.add_argument('--log-interval', type=int, default=10, metavar='N',
                    help='how many batches to wait before logging training status')
args = parser.parse_args()
args.cuda = not args.no_cuda and torch.cuda.is_available()

torch.manual_seed(args.seed)  # 為CPU設定種子用于生成亂數，以使得結果是確定的
if args.cuda:
    torch.cuda.manual_seed(args.seed)  # 為當前GPU設定隨機種子；如果使用多個GPU，應該使用torch.cuda.manual_seed_all()為所有的GPU設定種子，

kwargs = {'num_workers': 1, 'pin_memory': True} if args.cuda else {}
"""加載資料，組合資料集和采樣器，提供資料上的單或多行程迭代器
引數：
dataset：Dataset型別，從其中加載資料
batch_size：int，可選，每個batch加載多少樣本
shuffle：bool，可選，為True時表示每個epoch都對資料進行洗牌
sampler：Sampler，可選，從資料集中采樣樣本的方法，
num_workers：int，可選，加載資料時使用多少子行程，默認值為0，表示在主行程中加載資料，
collate_fn：callable，可選，
pin_memory：bool，可選
drop_last：bool，可選，True表示如果最后剩下不完全的batch,丟棄，False表示不丟棄，
"""
train_loader = torch.utils.data.DataLoader(
    datasets.MNIST('../data', train=True, download=True,
                   transform=transforms.Compose([
                       transforms.ToTensor(),
                       transforms.Normalize((0.1307,), (0.3081,))
                   ])),
    batch_size=args.batch_size, shuffle=True, **kwargs)
test_loader = torch.utils.data.DataLoader(
    datasets.MNIST('../data', train=False, transform=transforms.Compose([
        transforms.ToTensor(),
        transforms.Normalize((0.1307,), (0.3081,))
    ])),
    batch_size=args.batch_size, shuffle=True, **kwargs)


class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(1, 10, kernel_size=5)  # 輸入和輸出通道數分別為1和10
        self.conv2 = nn.Conv2d(10, 20, kernel_size=5)  # 輸入和輸出通道數分別為10和20
        self.conv2_drop = nn.Dropout2d()  # 隨機選擇輸入的信道，將其設為0
        self.fc1 = nn.Linear(320, 50)  # 輸入的向量大小和輸出的大小分別為320和50
        self.fc2 = nn.Linear(50, 10)

    def forward(self, x):
        x = F.relu(F.max_pool2d(self.conv1(x), 2))  # conv->max_pool->relu
        x = F.relu(F.max_pool2d(self.conv2_drop(self.conv2(x)), 2))  # conv->dropout->max_pool->relu
        x = x.view(-1, 320)
        x = F.relu(self.fc1(x))  # fc->relu
        x = F.dropout(x, training=self.training)  # dropout
        x = self.fc2(x)
        return F.log_softmax(x)


model = Net()
if args.cuda:
    model.cuda()  # 將所有的模型引數移動到GPU上

optimizer = optim.SGD(model.parameters(), lr=args.lr, momentum=args.momentum)


def train(epoch):
    model.train()  # 把module設成training模式，對Dropout和BatchNorm有影響
    for batch_idx, (data, target) in enumerate(train_loader):
        if args.cuda:
            data, target = data.cuda(), target.cuda()
        data, target = Variable(data), Variable(
            target)  # Variable類對Tensor物件進行封裝，會保存該張量對應的梯度，以及對生成該張量的函式grad_fn的一個參考，如果該張量是用戶創建的，grad_fn是None，稱這樣的Variable為葉子Variable，
        optimizer.zero_grad()
        output = model(data)
        loss = F.nll_loss(output, target)  # 負log似然損失
        loss.backward()
        optimizer.step()
        if batch_idx % args.log_interval == 0:
            print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
                epoch, batch_idx * len(data), len(train_loader.dataset),
                       100. * batch_idx / len(train_loader), loss.item()))


def test(epoch):
    model.eval()  # 把module設定為評估模式，只對Dropout和BatchNorm模塊有影響
    test_loss = 0
    correct = 0
    for data, target in test_loader:
        if args.cuda:
            data, target = data.cuda(), target.cuda()
        data, target = Variable(data, volatile=True), Variable(target)
        output = model(data)
        test_loss += F.nll_loss(output, target).item()  # Variable.data
        pred = output.data.max(1)[1]  # get the index of the max log-probability
        correct += pred.eq(target.data).cpu().sum()

    test_loss = test_loss
    test_loss /= len(test_loader)  # loss function already averages over batch size
    print('\nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format(
        test_loss, correct, len(test_loader.dataset),
        100. * correct / len(test_loader.dataset)))


if __name__ == '__main__':
    for epoch in range(1, args.epochs + 1):
        train(epoch)
        test(epoch)

3.2 測驗結果

不報錯說明安裝成功，如下圖所示，是在訓練模型的程序截圖，

大家在施行程序中若發現什么問題可隨時聯系，也可在下方評論區留下你的問題
若發現新的更簡便方法我也會隨時更新的

歡迎大家交流評論，一起學習

希望本文能幫助您解決您在這方面遇到的問題

感謝閱讀
END

著作權宣告：本文為CSDN博主「榮仔！最靚的仔！」的原創文章，遵循 CC 4.0 BY-SA 著作權協議，
         轉載請在醒目位置附上原文出處鏈接及本宣告，