【PyTorch 深度学习】6.PyTorch理解更多神经网络优化方法

1.了解不同的优化器

关于各种优化器的理解和选择问题，可以看我之前写的这篇博客：
https://blog.csdn.net/qq_40314507/article/details/79933289

2.书写优化器代码

我们分别用SGD,Momentum，RMSprop，Adam作为优化器，训练前面几篇博客的数据，看看效果如何。

2.1定义网络

代码如下：

class module_net(nn.Module):
    def __init__(self, num_input, num_hidden, num_output):
        super(module_net, self).__init__()
        self.layer1 = nn.Linear(num_input, num_hidden)
        
        self.layer2 = nn.ReLU()
        
        self.layer3 = nn.Linear(num_hidden, num_hidden)
        
        self.dropout3 = nn.Dropout(p=0.5)

        self.layer4 = nn.ReLU()

        self.layer5 = nn.Linear(num_hidden, num_hidden)

        self.dropout5 = nn.Dropout(p=0.5)

        self.layer6 = nn.ReLU()
        
        self.layer7 = nn.Linear(num_hidden, num_output)
        
        
    def forward(self, x):
        x = self.layer1(x)
        x = self.layer2(x)
        x = self.layer3(x)
        x = self.dropout3(x)
        x = self.layer4(x)
        x = self.layer5(x)
        x = self.dropout5(x)
        x = self.layer6(x)
        x = self.layer7(x)
        
        return x

2.2为每个优化器创建一个网络类

为了对比每一种优化器, 我们给他们各自创建一个神经网络, 但这个神经网络都来自同一个 Net 形式.

net_SGD         = module_net(8,10,1)
net_Momentum    = module_net(8,10,1)
net_RMSprop     = module_net(8,10,1)
net_Adam        = module_net(8,10,1)
nets = [net_SGD, net_Momentum, net_RMSprop, net_Adam]

2.3创建不同的优化器

接下来在创建不同的优化器, 用来训练不同的网络. 并创建一个 loss_func 用来计算误差. 我们用几种常见的优化器, SGD , Momentum , RMSprop , Adam .

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))

loss_func = torch.nn.MSELoss()
losses_his = [[], [], [], []]   # 记录 training 时不同神经网络的 loss
Accuracy_list = [[],[],[],[]]   # 记录 training 时不同神经网络的 准确率
optimizers = [opt_SGD, opt_Momentum, opt_RMSprop, opt_Adam]
criterion = nn.BCEWithLogitsLoss().to(device) # CrossEntropyLoss=softmax+cross entropy

2.4初始化正则项

weight_decay=0.01 # 正则化参数
for net  in nets:
    if weight_decay>0:
        reg_loss=Regularization(net, weight_decay, p=2).to(device)
    else:
        print("no regularization")

2.5训练

for e in range(100):
    for net, opt, l_his ,acc_his in zip(nets, optimizers, losses_his,Accuracy_list):
        out = net.forward(Variable(x))   #这里省略了 mo_net.forward()
        loss = criterion(out, Variable(y))
        #--------------------用于求准确率-------------------------#
        out_class=(out[:]>0).float()  #将out矩阵中大于0的转化为1，小于0的转化为0，存入a中
        right_num=torch.sum(y==out_class).float()  #分类对的数值
        precision=right_num/out.shape[0]  #准确率
        #--------------------求准确率结束-------------------------#
        opt.zero_grad()    
        loss.backward()
        opt.step()
        if (e + 1) % 1 == 0:
            l_his.append(loss.data[0])
            acc_his.append(precision)
            
        if (e + 1) % 50 == 0:
            print('epoch: {}, loss: {}，precision{},right_num{}'.format(e+1, loss.data[0],precision,right_num))

2.6画图

我这里只训练了100次，我们来看看loss曲线和acc曲线，代码如下：

x1=list(range(100))
labels_loss=["SGD_loss","Momentum_loss","RMSprop_loss","Adam_loss"]
labels_acc=["SGD_acc","Momentum_acc","RMSprop_acc","Adam_acc"]
plt.figure()
for i in range(4):
    plt.plot(x1, losses_his[i])
    plt.legend(labels =labels_loss,loc = 'upper right')
plt.close(0)
plt.figure()
for i in range(4):
    plt.plot(x1, Accuracy_list[i])
    plt.legend(labels =labels_acc,loc = 'lowver right')

结果：

我们可以看到最快的RMSprop，最慢的SGD。

2.7测试集测试

代码：

x_test_tensor=x_test_tensor.float()
y_test_tensor=y_test_tensor.float()
opt_name=['SGD','Momentum','RMSprop','Adam']
for net ,name in zip(nets,opt_name):
    out_test=net.forward(Variable(x_test_tensor)) 
    loss_test = criterion(out_test, Variable(y_test_tensor))
    out_test_class=(out_test[:]>0).float()  #将out矩阵中大于0的转化为1，小于0的转化为0，存入a中
    right_num_test=torch.sum(y_test_tensor==out_test_class).float()  #分类对的数值
    precision_test=right_num_test/out_test.shape[0]  #准确率
    loss_test=loss_test.data[0]
    print('opt:{}, loss_test:{}, precision_test:{}, right_num_test:{}'.format(name,loss_test,precision_test,right_num_test))

结果如下：

Adam效果最好。

3.测试优化器

3.1增加迭代次数

我们上面只迭代了100次，几种优化器效果都还可以，如果我们增加迭代次数呢，首先我增加到1000次，loss和acc曲线如下：

这时候RMSprop的loss值甚至到了0.3左右，但这时候测试集表现如何呢？我们来看看：

说明后面两个过拟合严重。
我们现在迭代一万次再来看看，首先是loss曲线和acc曲线:

最低也达到了0.3以下，我们来看看测试集表现：

可以看见，过拟合更加严重了。

3.2减小网络层数

我们数据量不多，但是用了好几层网络，现在我们减小网络层数后再来看看效果。
修改后的网络：

class module_net(nn.Module):
    def __init__(self, num_input, num_hidden, num_output):
        super(module_net, self).__init__()
        self.layer1 = nn.Linear(num_input, num_hidden)
        
        self.dropout1 = nn.Dropout(p=0.5)
       
        self.layer2 = nn.ReLU()
        
        self.layer3 = nn.Linear(num_hidden, num_output)
        
    def forward(self, x):
        x = self.layer1(x)
        x = self.dropout1(x)
        x = self.layer2(x)
        x = self.layer3(x)

直接迭代一万次：

可以看到SGD虽然最慢，但最终在此数据集上，它与其他三个模型都会相遇到同一水平上。
在测试集上：

loss值相差不大。