pytorch学习（二）

---

前言

莫烦pytorch教材笔记~~~
课程链接

---

一、使用步骤

1.快速搭建神经层

下面是搭建的两种不同的模式，输出也略有不同。

#method 1
class Net(torch.nn.Module):#从torch那儿继承的模块，nn的功能都包含在这个模块当中
    def __init__(self, n_feature,n_hidden, n_output):
        super(Net, self).__init__()#继承一些Net的功能~~官方步骤
        self.hidden = torch.nn.Linear(n_feature, n_hidden)
        self.predict = torch.nn.Linear(n_hidden, n_output)

    def forward(self, x):#搭建神经网络
        x = F.relu(self.hidden(x))
        x = self.predict(x)
        return x

net1 = Net(2, 10, 2)#2--特征；一个是x的一个是y的

#method2
net2 = torch.nn.Sequential(
    torch.nn.Linear(2, 10),
    torch.nn.ReLU(),
    torch.nn.Linear(10, 2),
)

print(net1)
print(net2)

• 第一个不同点在于Class定义时将hidden和predict作为类定义在了初始化里，所以也会有相应的输出。

• 第二个不同点在于激活函数，method1里F.relu相当于一个函数调用，输出的时候不会有，method2里torch.nn.ReLU()相当于时定义了一个层结构，输出的时候会相应输出层的名字。

Net(
  (hidden): Linear(in_features=2, out_features=10, bias=True)
  (predict): Linear(in_features=10, out_features=2, bias=True)
)
Sequential(
  (0): Linear(in_features=2, out_features=10, bias=True)
  (1): ReLU()
  (2): Linear(in_features=10, out_features=2, bias=True)
)

2.保存提取

如果最后图线拟合的不是很好的化，就修改一下学习率，自己调试合适的学习率。

import  torch
import torch.nn.functional as F #引入各种函数实现非线性化功能
from torch.autograd import Variable#使用variable的形式来实现
import matplotlib.pyplot as plt

#fake data
x = torch.unsqueeze(torch.linspace(-1, 1,100), dim=1)# x data(tensor), shape=(100,1)#unsqueeze把一维的数据变成二维的数据
y = x.pow(2) + 0.2*torch.rand(x.size())#nosiy y data(tensor), shape=(100,1)

x, y = Variable(x, requires_grad=False), Variable(y, requires_grad=False)
#plt.scatter(x.data.numpy(), y.data.numpy())
#plt.show()


def save():
    #save net1
    net1 = torch.nn.Sequential(
        torch.nn.Linear(1, 10),
        torch.nn.ReLU(),
        torch.nn.Linear(10,1)
    )
    optimizer = torch.optim.SGD(net1.parameters(), lr=0.2)
    loss_func = torch.nn.MSELoss()

    for t in range(100):
        prediction = net1(x)
        loss = loss_func(prediction, y)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
    torch.save(net1, 'net.pkl')#保存整个神经网络
    torch.save(net1.state_dict(), 'net_params.pkl')#保存了整个网络中的parameters

    plt.subplot(131)
    plt.title('Net1')
    plt.scatter(x.data.numpy(), y.data.numpy())  # 原始数据
    plt.plot(x.data.numpy(), prediction.data.numpy(), 'r-', lw=5)  # 训练的拟合曲线





def restore_net():#提取神经网络
    net2 = torch.load('net.pkl')
    prediction = net2(x)
    plt.subplot(132)
    plt.title('Net2')
    plt.scatter(x.data.numpy(), y.data.numpy())  # 原始数据
    plt.plot(x.data.numpy(), prediction.data.numpy(), 'r-', lw=5)  # 训练的拟合曲线

def restore_params():#提取神经网络的参数，首先要建立一个和提取net相同的网络
    net3 = torch.nn.Sequential(
        torch.nn.Linear(1, 10),
        torch.nn.ReLU(),
        torch.nn.Linear(10,1)
    )
    net3.load_state_dict(torch.load('net_params.pkl'))
    prediction = net3(x)
    plt.subplot(133)
    plt.title('Net3')
    plt.scatter(x.data.numpy(), y.data.numpy())  # 原始数据
    plt.plot(x.data.numpy(), prediction.data.numpy(), 'r-', lw=5)  # 训练的拟合曲线


save()
restore_net()
restore_params()

plt.show()

3.批数据训练（mini batch training）

在莫烦的基础上改了一小点，主要是因为版本升级了，有些指令不能用了

import torch
import torch.utils.data as Data#进行小批训练的一个途径

BATCH_SIZE = 5

x =torch.linspace(1, 10, 10)#torch tensor
y =torch.linspace(10, 1, 10)#torch tensor

torch_dataset = Data.TensorDataset(x, y)#用torch定义一个数据库，把x，y放入数据库
loader = Data.DataLoader(
    dataset=torch_dataset,
    batch_size=BATCH_SIZE,
    shuffle=True,#是否打乱顺序
    #num_workers=2,#多线程
)#使训练变成mini-batch的函数

for epoch in range(3):
    #loader拆包得到的batch_x,batch_y
    #一个epoch里有2次迭代 =number of batchs=step
    #loader可以定义每个epoch要不要打乱顺序，不打乱每次epoch训练的数据都是一样的顺序
    for step, (batch_x, batch_y) in enumerate(loader):
        #training
        print('Epoch:', epoch,'| Step:', step, '| batch_x:', batch_x.numpy(), '|batch y:', batch_y.numpy())

Epoch: 0 | Step: 0 | batch_x: [4. 2. 5. 8. 9.] |batch y: [7. 9. 6. 3. 2.]
Epoch: 0 | Step: 1 | batch_x: [ 3.  1.  6.  7. 10.] |batch y: [ 8. 10.  5.  4.  1.]
Epoch: 1 | Step: 0 | batch_x: [ 7. 10.  1.  4.  8.] |batch y: [ 4.  1. 10.  7.  3.]
Epoch: 1 | Step: 1 | batch_x: [9. 2. 3. 6. 5.] |batch y: [2. 9. 8. 5. 6.]
Epoch: 2 | Step: 0 | batch_x: [5. 6. 8. 4. 9.] |batch y: [6. 5. 3. 7. 2.]
Epoch: 2 | Step: 1 | batch_x: [ 7.  2.  1.  3. 10.] |batch y: [ 4.  9. 10.  8.  1.]

4. Optimizer优化器

import torch
import torch.utils.data as Data
import torch.nn.functional as F
import matplotlib.pyplot as plt

# torch.manual_seed(1)    # reproducible

LR = 0.01
BATCH_SIZE = 32
EPOCH = 12

# fake dataset
x = torch.unsqueeze(torch.linspace(-1, 1, 1000), dim=1)
y = x.pow(2) + 0.1*torch.normal(torch.zeros(*x.size()))

# #plot dataset
#plt.scatter(x.numpy(), y.numpy())
#plt.show()

# put dateset into torch dataset
torch_dataset = Data.TensorDataset(x, y)
loader = Data.DataLoader(dataset=torch_dataset, batch_size=BATCH_SIZE, shuffle=True, num_workers=2,)


# default network
class Net(torch.nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.hidden = torch.nn.Linear(1, 20)   # hidden layer
        self.predict = torch.nn.Linear(20, 1)   # output layer

    def forward(self, x):
        x = F.relu(self.hidden(x))      # activation function for hidden layer
        x = self.predict(x)             # linear output
        return x

if __name__ == '__main__':
    # different nets
    net_SGD         = Net()
    net_Momentum    = Net()
    net_RMSprop     = Net()
    net_Adam        = Net()
    nets = [net_SGD, net_Momentum, net_RMSprop, net_Adam]

    # different optimizers
    opt_SGD         = torch.optim.SGD(net_SGD.parameters(), lr=LR)
    opt_Momentum    = torch.optim.SGD(net_Momentum.parameters(), lr=LR, momentum=0.8)
    opt_RMSprop     = torch.optim.RMSprop(net_RMSprop.parameters(), lr=LR, alpha=0.9)
    opt_Adam        = torch.optim.Adam(net_Adam.parameters(), lr=LR, betas=(0.9, 0.99))
    optimizers = [opt_SGD, opt_Momentum, opt_RMSprop, opt_Adam]

    loss_func = torch.nn.MSELoss()#回归误差计算公式
    losses_his = [[], [], [], []]   # record loss

    # training
    for epoch in range(EPOCH):
        print('Epoch: ', epoch)
        for step, (b_x, b_y) in enumerate(loader):          # for each training step
            #zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。
            for net, opt, l_his in zip(nets, optimizers, losses_his):#三个都是列表形式，将其提取出来
                output = net(b_x)              # get output for every net
                loss = loss_func(output, b_y)  # compute loss for every net
                opt.zero_grad()                # clear gradients for next train
                loss.backward()                # backpropagation, compute gradients
                opt.step()                     # apply gradients
                l_his.append(loss.data.numpy())     # loss recoder

    labels = ['SGD', 'Momentum', 'RMSprop', 'Adam']
    for i, l_his in enumerate(losses_his):
        plt.plot(l_his, label=labels[i])
    plt.legend(loc='best')
    plt.xlabel('Steps')
    plt.ylabel('Loss')
    plt.ylim((0, 0.2))
    plt.show()

---

总结

今天就学到这儿了~~~ 周末玩得太high了，木有看完视频，原本打算周末学完视频的。