pytorch中的Optimizer的灵活运用

 pytorch可以自动求导梯度,不过要对需要求梯度的tensor设置为“requires grad = TRUE"。同时,pytorch可以对神经网络进行灵活训练,主要同通过Optimazer的设计来实现的。

以下针对不同的应用场景需要对optimizer的使用进行总结。

1. 多个神经网络联合训练

应用场景

(1)Autoencoder网络分为encoder与decoder两部分组成,中间加入了AWGN噪声。首先两部分进行联合训练,得到压缩编码,然后再单独将接收端进行训练,观看性能是否有所提升。

(2)GAN网络的discriminator需要单独进行training,generator需要经过discriminator后,再进行参数更新,同时,discriminator锁死,不进行参数更新,只进行梯度反传。

具体实现

(1)Autoencoder只进行接收端的训练时,网络结构如下,定义一个encoder的网络参数,再定义一个decoder的网络参数

        super(AutoEncoder, self).__init__() 
        self.encoder = nn.Sequential(
            nn.Linear(InputNum, 128),
            nn.LeakyReLU(),
            nn.Linear(128,OutputBit),
        )
 
        self.decoder = nn.Sequential(
            nn.Linear(OutputBit,128),
            nn.LeakyReLU(),
            nn.Linear(128, InputNum),
          
        )

Optimizer定义为:

net = AutoEncoder()
net.apply(weight_init)
optimizer = optim.Adam(net.parameters(), lr = LR)
decoder_optimizer = optim.Adam(net.decoder.parameters(), lr=LR)  
criterion = nn.CrossEntropyLoss()

第一个optimaizer为整个net的parameters,第二个decoder_optimizer的参数只传入了net.decoder.parameters(),所以

decoder_optimizer.step()

只更新decoder的参数。

(2)GAN在训练网络时如下图:

pytorch中的Optimizer的灵活运用_第1张图片

pytorch网络结构实现为:

class discriminator(nn.Module):
    def __init__(self):
        super(discriminator,self).__init__()
        self.dis=nn.Sequential(
            nn.Linear(784,256),#输入特征数为784,输出为256
            nn.LeakyReLU(0.2),#进行非线性映射
            nn.Linear(256,256),#进行一个线性映射
            nn.LeakyReLU(0.2),
            nn.Linear(256,1),
            nn.Sigmoid()#也是一个激活函数,二分类问题中,
            # sigmoid可以班实数映射到【0,1】,作为概率值,
            # 多分类用softmax函数
        )
    def forward(self, x):
        x=self.dis(x)
        return x
class generator(nn.Module):
    def __init__(self):
        super(generator,self).__init__()
        self.gen=nn.Sequential(
            nn.Linear(100,256),#用线性变换将输入映射到256维
            nn.ReLU(True),#relu激活
            nn.Linear(256,256),#线性变换
            nn.ReLU(True),#relu激活
            nn.Linear(256,784),#线性变换
            nn.Tanh()#Tanh激活使得生成数据分布在【-1,1】之间
        )
 
    def forward(self, x):
        x=self.gen(x)
        return x

discriminator的优化器设置如下: 

#创建对象
D=discriminator()
G=generator()

criterion = nn.BCELoss() #是单目标二分类交叉熵函数
d_optimizer=torch.optim.Adam(D.parameters(),lr=0.0003)
g_optimizer=torch.optim.Adam(G.parameters(),lr=0.0003)

 # 损失函数和优化
d_loss = d_loss_real + d_loss_fake #损失包括判真损失和判假损失
d_optimizer.zero_grad()  # 在反向传播之前,先将梯度归0
d_loss.backward()  # 将误差反向传播
d_optimizer.step()  # 更新参数


generator优化器为:

# 计算假的图片的损失
 
z = Variable(torch.randn(num_img, z_dimension)).cuda()  # 得到随机噪声
fake_img = G(z) #随机噪声输入到生成器中,得到一副假的图片
output = D(fake_img)  # 经过判别器得到的结果
g_loss = criterion(output, real_label)  # 得到的假的图片与真实的图片的label的loss

g_optimizer.zero_grad()  # 梯度归0
g_loss.backward()  # 进行反向传播
g_optimizer.step()  # .step()一般用在反向传播后面,用于更新生成网络的参数

由于两个网络是分开设置的,所以两个网络的参数也是分开更新的。在更新G的参数时,使用D网络进行传输,所以D网络的梯度进行计算,但是在step时,D的参数并不更新。

2.对网络中固定部分参数进行训练

方法一:首先将网络层中不进行更新的参数的requires_grad属性设置为False,然后再optimizer中加入过滤器即可。

具体参考:https://blog.csdn.net/guotong1988/article/details/79739775

https://blog.csdn.net/weixin_34261739/article/details/87555871?tdsourcetag=s_pcqq_aiomsg

optimizer.SGD(filter(lambda p: p.requires_grad, model.parameters()), lr=1e-3)

对于网络层中的设置方法比较多,如:features是构建NN中的一个模组。 

for i, para in enumerate(self._net.module.features.parameters()):
            if i < 16:
                para.requires_grad = False
            else:
                para.requires_grad = True

 在加载预训练模型之后,在原来的基础上添加一部分的网络,我们可以固定原来的参数,然后只训练我们添加的这部分网络,完了之后再全部训练.

class RESNET_attention(nn.Module):
    def __init__(self, model, pretrained):
        super(RESNET_attetnion, self).__init__()
        self.resnet = model(pretrained)
        for p in self.parameters():
            p.requires_grad = False
        self.f = nn.Conv2d(2048, 512, 1)
        self.g = nn.Conv2d(2048, 512, 1)
        self.h = nn.Conv2d(2048, 2048, 1)
        self.softmax = nn.Softmax(-1)
        self.gamma = nn.Parameter(torch.FloatTensor([0.0]))
        self.avgpool = nn.AvgPool2d(7, stride=1)
        self.resnet.fc = nn.Linear(2048, 10)
optimizer = optim.Adam(filter(lambda p: p.requires_grad, model.parameters()), lr=0.0001, betas=(0.9, 0.999), eps=1e-08, weight_decay=1e-5)

如果是Variable,则可以初始化时指定

j = Variable(torch.randn(5,5), requires_grad=True)

但是如果是

m = nn.Linear(10,10)

是没有requires_grad传入的 
m.requires_grad也没有 
需要用for循环

for i in m.parameters():
    i.requires_grad=False

另外一个小技巧就是在nn.Module里,可以在中间插入这个

for p in self.parameters():
    p.requires_grad=False

这样前面的参数就是False,而后面的不变

class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(1, 6, 5)
        self.conv2 = nn.Conv2d(6, 16, 5)

        for p in self.parameters():
            p.requires_grad=False

        self.fc1 = nn.Linear(16 * 5 * 5, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)

 在fine tuning一个预训练的网络时,要增加一个参数组,还可以用下面方法:

add_param_group(param_group)

加载optimizer的状态

load_state_dict(state_dict)

获取一个optimizer的状态(一个dict)。

state_dict()
model=resnet()#自己构建的模型,以resnet为例
model_dict = model.state_dict()
pretrained_dict = torch.load('xxx.pkl')
pretrained_dict = {k: v for k, v in pretrained_dict.items() if k in model_dict}
model_dict.update(pretrained_dict)
model.load_state_dict(model_dict)

for k,v in model.named_parameters():

    if k!='xxx.weight' and k!='xxx.bias' :

        v.requires_grad=False#固定参数

optimizer2=torch.optim.Adam(params=[model.xxx.weight,model.xxx.bias],lr=learning_rate,betas=(0.9,0.999),weight_decay=1e-5)

3.Optimizer不同的参数设置不同的学习速率

参考:https://www.cnblogs.com/hellcat/p/8496727.html

为不同的子网络参数不同的学习率,finetune常用,使分类器学习率参数更高,学习速度更快(理论上).

网络结构:

import torch as t
 
 
class LeNet(t.nn.Module):
    def __init__(self):
        super(LeNet, self).__init__()
        self.features = t.nn.Sequential(
            t.nn.Conv2d(3, 6, 5),
            t.nn.ReLU(),
            t.nn.MaxPool2d(2, 2),
            t.nn.Conv2d(6, 16, 5),
            t.nn.ReLU(),
            t.nn.MaxPool2d(2, 2)
        )
        # 由于调整shape并不是一个class层,
        # 所以在涉及这种操作(非nn.Module操作)需要拆分为多个模型
        self.classifiter = t.nn.Sequential(
            t.nn.Linear(16*5*5, 120),
            t.nn.ReLU(),
            t.nn.Linear(120, 84),
            t.nn.ReLU(),
            t.nn.Linear(84, 10)
        )
 
    def forward(self, x):
        x = self.features(x)
        x = x.view(-1, 16*5*5)
        x = self.classifiter(x)
        return x
 
net = LeNet()

(1)经由构建网络时划分好的模组进行学习率设定:(粗粒度设定)

optimizer = optim.SGD([{'params': net.features.parameters()}, # 默认lr是1e-5
                       {'params': net.classifiter.parameters(), 'lr': 1e-2}], lr=1e-5)

(2)以网络层对象为单位进行分组,并设定学习率:(细粒度)着重学习nn.ModuleList是如何工作的。

# # 以层为单位,为不同层指定不同的学习率
# ## 提取指定层对象
special_layers = t.nn.ModuleList([net.classifiter[0], net.classifiter[3]]) #第一层与第四层
# ## 获取指定层参数id
special_layers_params = list(map(id, special_layers.parameters()))
print(special_layers_params)
# ## 获取非指定层的参数id
base_params = filter(lambda p: id(p) not in special_layers_params, net.parameters())
optimizer = t.optim.SGD([{'params': base_params},
                         {'params': special_layers.parameters(), 'lr': 0.01}], lr=0.001)

(3)在训练中动态的调整学习率

'''调整学习率'''
# 新建optimizer或者修改optimizer.params_groups对应的学习率
# # 新建optimizer更简单也更推荐,optimizer十分轻量级,所以开销很小
# # 但是新的优化器会初始化动量等状态信息,这对于使用动量的优化器(momentum参数的sgd)可能会造成收敛中的震荡
# ## optimizer.param_groups:长度2的list,optimizer.param_groups[0]:长度6的字典
print(optimizer.param_groups[0]['lr'])
old_lr = 0.1
optimizer = optim.SGD([{'params': net.features.parameters()},
                       {'params': net.classifiter.parameters(), 'lr': old_lr*0.1}], lr=1e-5)

可以看到optimizer.param_groups结构,[{'params','lr', 'momentum', 'dampening', 'weight_decay', 'nesterov'},{……}],集合了优化器的各项参数。

辅助理解:

法1(比较推荐):新建一个optimizer。对于使用动量的优化器(如Adam),会丢失动量等状态信息,可能会造成损失函数的收敛出现震荡等情况

old_lr = 0.1
optimizer1 =optim.SGD([
                {'params': net.features.parameters()},
                {'params': net.classifier.parameters(), 'lr': old_lr*0.1}
            ], lr=1e-5)
optimizer1

法2:一种是修改optimizer.param_groups中对应的学习率

# 方法2: 调整学习率, 手动decay, 保存动量
for param_group in optimizer.param_groups:
    param_group['lr'] *= 0.1 # 学习率为之前的0.1倍
optimizer

你可能感兴趣的:(机器学习,神经网络,pytorch,optimizer)