1.Abstract

参加DatewhalePytorch课程

2.Background

以前接触过一点,一头雾水

3.Task

【Task1(2天)】PyTorch的基本概念 什么是Pytorch,为什么选择Pytroch? Pytroch的安装 配置Python环境 准备Python管理器 通过命令行安装PyTorch PyTorch基础概念 通用代码实现流程(实现一个深度学习的代码流程)

4.Work

1.查看系统内核

2. 屏蔽 nouveau 驱动

nouveau 是系统自带的一个显示驱动程序,需要先将其禁用,然后再进行下一步操作,否则在安装显卡驱动时,会提示:You appear to be running an X server …,然后安装失败。分别打开如下两个文件(如果没有就创建一个),并在其中输入如下两句,然后保存。 或者直接运行 NVIDIA 显卡驱动安装包(*.run),会出现提示:One or more modprobe configuration files to disable Nouveau have been written … 点击 OK 之后,会自动在指定位置创建好禁用 nouveau 驱动的文件,这样就不需要再手动添加。

3.重做 initramfs 镜像

# cp /boot/initramfs-$(uname -r).img /boot/initramfs-$(uname -r).img.bak
# dracut /boot/initramfs-$(uname -r).img $(uname -r)
# rm /boot/initramfs-$(uname -r).img.bak ; 这一步可不执行

4.Reboot

如果之前在图形界面操作,需要改为终端模式,runlevel 改为 3

# systemctl set-default multi-user.target
# init 3
# reboot

5.预安装组件

预安装一些必需的组件,需要联网

# yum install gcc kernel-devel kernel-headers

6.安装 NVIDIA 官方驱动

安装 NVIDIA 官方驱动 执行如下的安装步骤,必需指定 kernel source path,否则会报错;kernel 的版本和系统内核有关,可能会有差别

# cd /to/your/directory/ ; 跳转到驱动所在的目录
# ./NVIDIA-Linux-x86_64-384.81.run --kernel-source-path=/usr/src/kernels/3.10.0-693.5.2.el7.x86_64  -k $(uname -r)

执行后,开始解压驱动包,进入安装步骤,可能中间会出现一些警告,但是不影响

7.检查驱动安装情况

执行如下两条语句,如果出现显卡的型号信息,说明驱动已经安装成功。

8.安装 CUDA Toolkit

在 NVIDIA 官网下载对应的安装文件,建议选择 *.run 文件,用本地安装的方式 本文使用的是 cuda_9.0.176_384.81_linux.run,接下来进行安装

# ./cuda_9.0.176_384.81_linux.run
...
Install NVIDIA Accelerated Graphics Driver ... -no ; 不需要再安装显卡驱动
Install OpenGL ... -no                             ; 这个组件一定不要安装,如果出现选择,选 No
Install CUDA 9.0 Toolkit ... -yes
Toolkit location /usr/local/cuda-9.0 ... [Enter]   ; 默认安装位置即可
Install a symbolic link at ... -yes
Install CUDA 9.0 Samples ... -yes                  ; 安装一些例程
Enter CUDA Samples Location ... [Enter]            ; 默认安装位置
...
Finished 
Driver : Not Selected
Toolkit : Installed in /usr/local/cuda-9.0
Samples : Installed in /root, but missing recommended libraries

9.配置环境变量

不需要具体指定 cuda 版本号,系统已经建立了一个链接 cuda -> cuda-9.0

# vim /etc/profile
...
export PATH=/usr/local/cuda/bin:$PATH
export LD_LIBRARY_PATH=/usr/local/cuda/lib64:$LD_LIBRARY_PATH
# source /etc/profile ; 使环境变量立即生效

10.Cuda测试

11.cudnn安装

首先应该对应版本

tar -xzvf cudnn-8.0-linux-x64-v5.1.tgz
cp cuda/include/cudnn.h /usr/local/cuda/include
cp cuda/lib64/libcudnn* /usr/local/cuda/lib64
chmod a+r /usr/local/cuda/include/cudnn.h /usr/local/cuda/lib64/libcudnn*

12.Pytorch安装

在这里利用pip进行安装,首先找到pytorch的官网,然后根据自己cuda版本(windows内的cuda版本查看),python的版本号找到对应的代码进行安装就ok

pip install https://download.pytorch.org/whl/cu100/torch-1.1.0-cp37-cp37m-win_amd64.whl
pip install https://download.pytorch.org/whl/cu100/torchvision-0.3.0-cp37-cp37m-win_amd64.whl

13.手写数字

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
batch_size = 64

# MNIST Dataset
train_dataset = datasets.MNIST(root='./data/',
                               train=True,
                               transform=transforms.ToTensor(),
                               download=True)

test_dataset = datasets.MNIST(root='./data/',
                              train=False,
                              transform=transforms.ToTensor())

# Data Loader (Input Pipeline)
train_loader = torch.utils.data.DataLoader(dataset=train_dataset,
                                           batch_size=batch_size,
                                           shuffle=True)

test_loader = torch.utils.data.DataLoader(dataset=test_dataset,
                                          batch_size=batch_size,
                                          shuffle=False)


class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        # 输入1通道,输出10通道,kernel 5*5
        self.conv1 = nn.Conv2d(1, 10, kernel_size=5)
        self.conv2 = nn.Conv2d(10, 20, kernel_size=5)
        self.mp = nn.MaxPool2d(2)
        # fully connect
        self.fc = nn.Linear(320, 10)

    def forward(self, x):
        # in_size = 64
        in_size = x.size(0) # one batch
        # x: 64*10*12*12
        x = F.relu(self.mp(self.conv1(x)))
        # x: 64*20*4*4
        x = F.relu(self.mp(self.conv2(x)))
        # x: 64*320
        x = x.view(in_size, -1) # flatten the tensor
        # x: 64*10
        x = self.fc(x)
        return F.log_softmax(x)


model = Net()

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

def train(epoch):
    for batch_idx, (data, target) in enumerate(train_loader):
        data, target = Variable(data), Variable(target)
        optimizer.zero_grad()
        output = model(data)
        loss = F.nll_loss(output, target)
        loss.backward()
        optimizer.step()
        if batch_idx % 200 == 0:
            print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
                epoch, batch_idx * len(data), len(train_loader.dataset),
                100. * batch_idx / len(train_loader), loss.data))


def test():
    test_loss = 0
    correct = 0
    for data, target in test_loader:
        data, target = Variable(data, volatile=True), Variable(target)
        output = model(data)
        # sum up batch loss
        test_loss += F.nll_loss(output, target, size_average=False).data
        # get the index of the max log-probability
        pred = output.data.max(1, keepdim=True)[1]
        correct += pred.eq(target.data.view_as(pred)).cpu().sum()

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


for epoch in range(1, 10):
    train(epoch)
    test()