Pytorch入门

1. 什么是Pytorch,为什么选择Pytorch?

PyTorch 是一个基于 Python 的科学计算包，主要定位两类人群：
NumPy 的替代品，可以利用 GPU 的性能进行计算。
深度学习研究平台拥有足够的灵活性和速度

2. 配置Python环境

1. 进入Anaconda官网https://www.anaconda.com/download/，选择Python3.7的安装包进行下载，下载完成后直接安装。安装完成之后会有一个Anaconda Prompt，类似于windows的终端操作，可以输入命令行啦！
   
2. 安装PyCharm与Pytorch环境配置
   1）直接输入网址：http://www.jetbrains.com/pycharm/download/#section=windows，下载PyCharm安装包，根据自己电脑的操作系统进行选择
   2）File->Settings->Project-Interpreter->add local,然后选择Anaconda3->envs->python->python.exe即可
   

2. 准备Python管理器

安装Anaconda后，打开Anaconda Prompt，然后输入如下指令：
1.建立环境

  conda create --name pytorch python=3.7

2. 创建完环境后，利用下列语句进入环境

 conda activate pytorch

3. 然后在该环境下配置相应的环境
4. 使用下列语句退出环境

conda deactivate pytorch

5. 通过命令行安装Pytorch

进入https://pytorch.org/，选择自己的环境，就会出现相应的安装指令，本人选择条件后，通过下列指令进行安装

conda install pytorch torchvision cudatoolkit=10.0 -c pytorch

6. Pytorch基本概念

PyTorch 是一个基于 Python 的库，旨在为深度学习提供一个灵活的开发平台。PyTorch 的工作流程非常接近于 Python 的科学计算库 NumPy。那么为什么我们需要使用 PyTorch 构建深度学习模型？以下作者根据实际经验提供了三个理由：
1. 便于使用的 API：它的使用如同 Python 那样简单。
2. 支持 Python：正如上文所述，PyTorch 可以平滑地与 Python 数据科学栈相结合。它与 NumPy 一样简单，甚至我们都感觉不出它们的区别。
3. 动态计算图：PyTorch不再采用特定的函数预定义计算图，而是提供构建动态计算图的框架，甚至我们可以在运行时修正它们。这种动态框架在我们不知道所构建的神经网络需要多少内存时非常有用。

7. 通过代码实现流程（实现MNIST手写分类）

1 建立mnist_pytorch.py,首先定义一个三层FC

from torch import nn
class simpleNet(nn.Module):
   def __init__(self, in_dim, n_hidden_1, n_hidden_2, out_dim):
       super(simpleNet, self).__init__()
       self.layer1 = nn.Linear(in_dim, n_hidden_1)
       self.layer2 = nn.Linear(n_hidden_1, n_hidden_2)
       self.layer3 = nn.Linear(n_hidden_2, out_dim)
  
   def forward(self, x):
       x = self.layer1(x)
       x = self.layer2(x)
       x = self.layer3(x)
       return x

2. 在每层的输出加入**函数

   class Activation_Net(nn.Module):
       def __init__(self, in_dim, n_hidden_1, n_hidden_2, out_dim):
       	super(Activation_Net, self).__init__()
        	self.layer1 = nn.Sequential(nn.Linear(in_dim, n_hidden_1), nn.ReLU(True))
        	self.layer2 = nn.Sequential(nn.Linear(n_hidden_1, n_hidden_2), nn.ReLU(True))
        	self.layer3 = nn.Sequential(nn.Linear(n_hidden_2, out_dim))
        	
       def forward(self, x):
        	x = self.layer1(x)
        	x = self.layer2(x)
        	x = self.layer3(x)
        	return x
   

3. 在上面的Activation_Net的基础上，增加了一个加快收敛速度的方法——批标准化

   class Batch_Net(nn.Module):
      def __init__(self, in_dim, n_hidden_1, n_hidden_2, out_dim):
    	super(Batch_Net, self).__init__()
   		self.layer1 = nn.Sequential(nn.Linear(in_dim, n_hidden_1), nn.BatchNorm1d(n_hidden_1), nn.ReLU(True))
    	self.layer2 = nn.Sequential(nn.Linear(n_hidden_1, n_hidden_2), nn.BatchNorm1d(n_hidden_2), nn.ReLU(True))
    	self.layer3 = nn.Sequential(nn.Linear(n_hidden_2, out_dim))
   
      def forward(self, x):
    	 x = self.layer1(x)
    	 x = self.layer2(x)
    	 x = self.layer3(x)
    	 return x
   

4 建立work.py,首先导入相应的包

import torch
from torch import nn, optim
from torch.autograd import Variable
from torch.utils.data import DataLoader
from torchvision import datasets, transforms

import mnist_pytorch as net

5.超参数定义

batch_size = 64
learning_rate = 0.02
num_epoches = 20

6.数据预处理与数据集下载

data_tf = transforms.Compose([transforms.ToTensor(),transforms.Normalize([0.5], [0.5])])
train_dataset = datasets.MNIST(root='./data', train=True, transform=data_tf, download=True)
test_dataset = datasets.MNIST(root='./data', train=False, transform=data_tf)
train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)

7.选择模型

model = net.simpleNet(28 * 28, 300, 100, 10)
model = net.Activation_Net(28 * 28, 300, 100, 10)
model = net.Batch_Net(28 * 28, 300, 100, 10)

8.选择训练（在GPU上训练）

if torch.cuda.is_available():
model = model.cuda()

criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=learning_rate)

epoch = 0

for data in train_loader:
    img, label = data
    img = img.view(img.size(0), -1)
    if torch.cuda.is_available():
        img = img.cuda()
        label = label.cuda()
    else:
        img = Variable(img)
        label = Variable(label)
    out = model(img)
    loss = criterion(out, label)
    print_loss = loss.data.item()

    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
    epoch+=1
    if epoch%50 == 0:
        print('epoch: {}, loss: {:.4}'.format(epoch, loss.data.item()))

9.评估模型

model.eval()
eval_loss = 0
eval_acc = 0
for data in test_loader:
    img, label = data
    img = img.view(img.size(0), -1)
    if torch.cuda.is_available():
        img = img.cuda()
        label = label.cuda()

    out = model(img)
    loss = criterion(out, label)
    eval_loss += loss.data.item()*label.size(0)
    _, pred = torch.max(out, 1)
    num_correct = (pred == label).sum()
    eval_acc += num_correct.item()
print('Test Loss: {:.6f}, Acc: {:.6f}'.format(
    eval_loss / (len(test_dataset)),
    eval_acc / (len(test_dataset))
))

10.训练结果

D:\anaconda3\envs\pytorch\python.exe C:/Users/gaoke/PycharmProjects/untitled1/work.py
epoch: 50, loss: 1.486
epoch: 100, loss: 1.164
epoch: 150, loss: 0.8667
epoch: 200, loss: 0.662
epoch: 250, loss: 0.5385
epoch: 300, loss: 0.3639
epoch: 350, loss: 0.5292
epoch: 400, loss: 0.4852
epoch: 450, loss: 0.3118
epoch: 500, loss: 0.2925
epoch: 550, loss: 0.2276
epoch: 600, loss: 0.3478
epoch: 650, loss: 0.2258
epoch: 700, loss: 0.2774
epoch: 750, loss: 0.2162
epoch: 800, loss: 0.1947
epoch: 850, loss: 0.1697
epoch: 900, loss: 0.1567
Test Loss: 0.167605, Acc: 0.955200