pytorch中的学习率调整函数_随笔

pytorch中的学习率调整函数

参考：https://pytorch.org/docs/master/optim.html#how-to-adjust-learning-rate

torch.optim.lr_scheduler提供了几种方法来根据迭代的数量来调整学习率

自己手动定义一个学习率衰减函数：

def adjust_learning_rate(optimizer, epoch, lr):

    """Sets the learning rate to the initial LR decayed by 10 every 2 epochs"""

    lr *= (0.1 ** (epoch // 2))

    for param_group in optimizer.param_groups:

        param_group['lr'] = lr

optimizer通过param_group来管理参数组。

param_group中保存了参数组及其对应的学习率,动量等等

使用：

model = AlexNet(num_classes=)

optimizer = optim.SGD(params = model.parameters(), lr=)

plt.figure()

x = list(range())

y = []

lr_init = optimizer.param_groups[]['lr']

for epoch in range():

    adjust_learning_rate(optimizer, epoch, lr_init)

    lr = optimizer.param_groups[]['lr']

    print(epoch, lr)

    y.append(lr)

plt.plot(x,y)

 10.0

 10.0

 1.0

 1.0

 0.10000000000000002

 0.10000000000000002

 0.010000000000000002

 0.010000000000000002

 0.0010000000000000002

 0.0010000000000000002

如图：

举例先导入所需的库：

import torch

import torch.optim as optim

from torch.optim import lr_scheduler

from torchvision.models import AlexNet

import matplotlib.pyplot as plt

1.LambdaLR

CLASS torch.optim.lr_scheduler.LambdaLR(optimizer, lr_lambda, last_epoch=-)

将每个参数组的学习率设置为初始lr乘以给定函数。

当last_epoch=-1时，将初始lr设置为lr。

参数：

optimizer (Optimizer) – 封装好的优化器
lr_lambda (function or list) –当是一个函数时,需要给其一个整数参数,使其计算出一个乘数因子,用于调整学习率,通常该输入参数是epoch数目；或此类函数的列表，根据在optimator.param_groups中的每组的长度决定lr_lambda的函数个数，如下报错。
last_epoch (int) – 最后一个迭代epoch的索引. Default: -1.

如：

optimizer = optim.SGD(params = model.parameters(), lr=0.05)

lambda1 = lambda epoch:epoch // 10 #根据epoch计算出与lr相乘的乘数因子为epoch//10的值

lambda2 = lambda epoch:0.95 ** epoch #根据epoch计算出与lr相乘的乘数因子为0.95 ** epoch的值

scheduler = lr_scheduler.LambdaLR(optimizer, lr_lambda=[lambda1, lambda2])

报错：

---------------------------------------------------------------------------

ValueError                                Traceback (most recent call last)

<ipython-input--c02d2d9ffc0d> in <module>

       lambda1 = lambda epoch:epoch //

       lambda2 = lambda epoch:0.95 ** epoch

---->  scheduler = lr_scheduler.LambdaLR(optimizer, lr_lambda=[lambda1, lambda2])

       plt.figure()

       x = list(range())

/anaconda3/envs/deeplearning/lib/python3./site-packages/torch/optim/lr_scheduler.py in __init__(self, optimizer, lr_lambda, last_epoch)

                  if len(lr_lambda) != len(optimizer.param_groups):

                      raise ValueError("Expected {} lr_lambdas, but got {}".format(

--->                      len(optimizer.param_groups), len(lr_lambda)))

                  self.lr_lambdas = list(lr_lambda)

              self.last_epoch = last_epoch

ValueError: Expected  lr_lambdas, but got

说明这里只需要一个lambda函数

举例：

1)使用的是lambda2

model = AlexNet(num_classes=)

optimizer = optim.SGD(params = model.parameters(), lr=0.05)

#下面是两种lambda函数

#epoch=0到9时，epoch//10=0，所以这时的lr = 0.05*0=0

#epoch=10到19时，epoch//10=1，所以这时的lr = 0.05*1=0.05

lambda1 = lambda epoch:epoch //

#当epoch=0时，lr = lr * (0.2**)=0.05;当epoch=1时，lr = lr * (0.2**)=0.01

lambda2 = lambda epoch:0.2 ** epoch

scheduler = lr_scheduler.LambdaLR(optimizer, lr_lambda=lambda2)

plt.figure()

x = list(range())

y = []

for epoch in range():

    scheduler.step()

    lr = scheduler.get_lr()

    print(epoch, scheduler.get_lr()[])

    y.append(scheduler.get_lr()[])

plt.plot(x,y)

 0.05

 0.010000000000000002

 0.0020000000000000005

 0.00040000000000000013

 8.000000000000002e-05

 1.6000000000000006e-05

 3.2000000000000015e-06

 6.400000000000002e-07

 1.2800000000000006e-07

 2.5600000000000014e-08

 5.120000000000003e-09

 1.0240000000000006e-09

 2.0480000000000014e-10

 4.096000000000003e-11

 8.192000000000007e-12

 1.6384000000000016e-12

 3.276800000000003e-13

 6.553600000000007e-14

 1.3107200000000014e-14

 2.621440000000003e-15

 5.242880000000006e-16

 1.0485760000000013e-16

 2.0971520000000027e-17

 4.194304000000006e-18

 8.388608000000012e-19

 1.6777216000000025e-19

 3.355443200000005e-20

 6.71088640000001e-21

 1.3421772800000022e-21

 2.6843545600000045e-22

 5.368709120000009e-23

 1.0737418240000018e-23

 2.147483648000004e-24

 4.294967296000008e-25

 8.589934592000016e-26

 1.7179869184000033e-26

 3.435973836800007e-27

 6.871947673600015e-28

 1.3743895347200028e-28

 2.748779069440006e-29

如图：

也可以写成下面的格式：

def lambda_rule(epoch):

    lr_l = 0.2 ** epoch

    return lr_l

scheduler = lr_scheduler.LambdaLR(optimizer, lr_lambda=lambda_rule)

2)使用的是lambda1函数：

 0.0

 0.0

 0.0

 0.0

 0.0

 0.0

 0.0

 0.0

 0.0

 0.0

 0.05

 0.05

 0.05

 0.05

 0.05

 0.05

 0.05

 0.05

 0.05

 0.05

 0.1

 0.1

 0.1

 0.1

 0.1

 0.1

 0.1

 0.1

 0.1

 0.1

 0.15000000000000002

 0.15000000000000002

 0.15000000000000002

 0.15000000000000002

 0.15000000000000002

 0.15000000000000002

 0.15000000000000002

 0.15000000000000002

 0.15000000000000002

 0.15000000000000002

如图：

其他函数：

load_state_dict(state_dict)

下载调试器状态

参数：

state_dict (dict) – 调试器状态。

应为state_dict()调用返回的对象.

state_dict()

以字典格式返回调试器的状态

它为self.__dict__中的每个变量都包含一个条目，这不是优化器。

只有当学习率的lambda函数是可调用对象时才会保存它们，而当它们是函数或lambdas时则不会保存它们。

2.StepLR

CLASS torch.optim.lr_scheduler.StepLR(optimizer, step_size, gamma=0.1, last_epoch=-)

每个step_size时间步长后使每个参数组的学习率降低。

注意，这种衰减可以与此调度程序外部对学习率的其他更改同时发生。

当last_epoch=-1时，将初始lr设置为lr。

参数：

optimizer (Optimizer) – 封装的优化器
step_size (int) – 学习率衰减的周期
gamma (float) – 学习率衰减的乘数因子。

Default: 0.1.
last_epoch (int) – 最后一个迭代epoch的索引. Default: -1.

举例：

model = AlexNet(num_classes=)

optimizer = optim.SGD(params = model.parameters(), lr=0.05)

#即每10次迭代，lr = lr * gamma

scheduler = lr_scheduler.StepLR(optimizer, step_size=, gamma=0.1)

plt.figure()

x = list(range())

y = []

for epoch in range():

    scheduler.step()

    lr = scheduler.get_lr()

    print(epoch, scheduler.get_lr()[])

    y.append(scheduler.get_lr()[])

plt.plot(x,y)

 0.05

 0.05

 0.05

 0.05

 0.05

 0.05

 0.05

 0.05

 0.05

 0.05

 0.005000000000000001

 0.005000000000000001

 0.005000000000000001

 0.005000000000000001

 0.005000000000000001

 0.005000000000000001

 0.005000000000000001

 0.005000000000000001

 0.005000000000000001

 0.005000000000000001

 0.0005000000000000001

 0.0005000000000000001

 0.0005000000000000001

 0.0005000000000000001

 0.0005000000000000001

 0.0005000000000000001

 0.0005000000000000001

 0.0005000000000000001

 0.0005000000000000001

 0.0005000000000000001

 5.0000000000000016e-05

 5.0000000000000016e-05

 5.0000000000000016e-05

 5.0000000000000016e-05

 5.0000000000000016e-05

 5.0000000000000016e-05

 5.0000000000000016e-05

 5.0000000000000016e-05

 5.0000000000000016e-05

 5.0000000000000016e-05

如图：

3.MultiStepLR

CLASS torch.optim.lr_scheduler.MultiStepLR(optimizer, milestones, gamma=0.1, last_epoch=-)

当迭代数epoch达到某个里程碑时，每个参数组的学习率将被gamma衰减。

注意，这种衰减可以与此调度程序外部对学习率的其他更改同时发生。

当last_epoch=-1时，将初始lr设置为lr。

参数：

optimizer (Optimizer) – 封装的优化器
milestones (list) –迭代epochs指数列表. 列表中的值必须是增长的.
gamma (float) – 学习率衰减的乘数因子。

Default: 0.1.
last_epoch (int) – 最后一个迭代epoch的索引. Default: -1.

举例：

model = AlexNet(num_classes=)

optimizer = optim.SGD(params = model.parameters(), lr=0.05)

#在指定的epoch值，如[,，，]处对学习率进行衰减，lr = lr * gamma

scheduler = lr_scheduler.MultiStepLR(optimizer, milestones=[,,,], gamma=0.1)

plt.figure()

x = list(range())

y = []

for epoch in range():

    scheduler.step()

    lr = scheduler.get_lr()

    print(epoch, scheduler.get_lr()[])

    y.append(scheduler.get_lr()[])

plt.plot(x,y)

 0.05

 0.05

 0.05

 0.05

 0.05

 0.05

 0.05

 0.05

 0.05

 0.05

 0.005000000000000001

 0.005000000000000001

 0.005000000000000001

 0.005000000000000001

 0.005000000000000001

 0.0005000000000000001

 0.0005000000000000001

 0.0005000000000000001

 0.0005000000000000001

 0.0005000000000000001

 0.0005000000000000001

 0.0005000000000000001

 0.0005000000000000001

 0.0005000000000000001

 0.0005000000000000001

 5.0000000000000016e-05

 5.0000000000000016e-05

 5.0000000000000016e-05

 5.0000000000000016e-05

 5.0000000000000016e-05

 5.000000000000001e-06

 5.000000000000001e-06

 5.000000000000001e-06

 5.000000000000001e-06

 5.000000000000001e-06

 5.000000000000001e-06

 5.000000000000001e-06

 5.000000000000001e-06

 5.000000000000001e-06

 5.000000000000001e-06

如图：

4.ExponentialLR

CLASS torch.optim.lr_scheduler.ExponentialLR(optimizer, gamma, last_epoch=-)

每个epoch都对每个参数组的学习率进行衰减。

当last_epoch=-1时，将初始lr设置为lr。

参数：

optimizer (Optimizer) – 封装的优化器
gamma (float) – 学习率衰减的乘数因子
last_epoch (int) – 最后一个迭代epoch的索引. Default: -1.

举例：

model = AlexNet(num_classes=)

optimizer = optim.SGD(params = model.parameters(), lr=0.2)

#即每个epoch都衰减lr = lr * gamma,即进行指数衰减

scheduler = lr_scheduler.ExponentialLR(optimizer, gamma=0.2)

plt.figure()

x = list(range())

y = []

for epoch in range():

    scheduler.step()

    lr = scheduler.get_lr()

    print(epoch, scheduler.get_lr()[])

    y.append(scheduler.get_lr()[])

plt.plot(x,y)

 0.2

 0.04000000000000001

 0.008000000000000002

 0.0016000000000000005

 0.0003200000000000001

 6.400000000000002e-05

 1.2800000000000006e-05

 2.560000000000001e-06

 5.120000000000002e-07

 1.0240000000000006e-07

如图：

5.CosineAnnealingLR

CLASS torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max, eta_min=, last_epoch=-)

使用余弦退火调度设置各参数组的学习率，其中ηmax设为初始lr, Tcur为SGDR上次重启后的时间间隔个数:

当last_epoch=-1时，将初始lr设置为lr。

注意，由于调度是递归定义的，所以其他 *** 作符可以在此调度程序之外同时修改学习率。

如果学习速率仅由该调度程序设置。

利用cos曲线降低学习率,该方法来源SGDR,学习率变换如下公式:

该方法已在SGDR中提出SGDR: Stochastic Gradient Descent with Warm Restarts。

注意，这只实现了SGDR的余弦退火部分，而没有重新启动。

参数：

optimizer (Optimizer) – 封装的优化器
T_max (int) – 迭代的最大数量
eta_min (float) – 最小学习率 Default: 0.
last_epoch (int) – 最后一个迭代epoch的索引. Default: -1.

举例：

model = AlexNet(num_classes=)

optimizer = optim.SGD(params = model.parameters(), lr=)

#根据式子进行计算

scheduler = lr_scheduler.CosineAnnealingLR(optimizer, T_max=)

plt.figure()

x = list(range())

y = []

for epoch in range():

    scheduler.step()

    lr = scheduler.get_lr()

    print(epoch, scheduler.get_lr()[])

    y.append(scheduler.get_lr()[])

plt.plot(x,y)

 10.0

 5.0

 0.0

 4.999999999999999

 10.0

 5.000000000000001

 0.0

 4.999999999999998

 10.0

 5.000000000000002

如图：

该例子前三个学习率结果的计算方式：

6.ReduceLROnPlateau(动态衰减lr)

CLASS torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode='min', factor=0.1, patience=, verbose=False, threshold=0.0001, threshold_mode='rel', cooldown=, min_lr=, eps=1e-)

torch.optim.lr_scheduler.ReduceLROnPlateau允许基于一些验证测量对学习率进行动态的下降

当评价指标停止改进时，降低学习率。

一旦学习停滞不前，模型通常会从将学习率降低2-10倍中获益。

这个调度器读取一个度量量，如果在“patience”时间内没有看到改进，那么学习率就会降低。

参数：

optimizer (Optimizer) – 封装的优化器
mode (str) – min, max两个模式中一个。

在min模式下，当监测的数量停止下降时，lr会减少;在max模式下，当监视的数量停止增加时，它将减少。

默认值:“分钟”。
factor (float) – 学习率衰减的乘数因子。

new_lr = lr * factor. Default: 0.1.
patience (int) – 没有改善的迭代epoch数量，这之后学习率会降低。

例如，如果patience = 2，那么我们将忽略前2个没有改善的epoch，如果loss仍然没有改善，那么我们只会在第3个epoch之后降低LR。

Default:10。
verbose (bool) – 如果为真，则为每次更新打印一条消息到stdout. Default: False.
threshold (float) – 阈值，为衡量新的最优值，只关注显著变化. Default: 1e-4.
threshold_mode (str) – rel, abs两个模式中一个. 在rel模式的“max”模式下的计算公式为dynamic_threshold = best * (1 + threshold)，或在“min”模式下的公式为best * (1 - threshold)。

在abs模式下的“max”模式下的计算公式为dynamic_threshold = best + threshold，在“min”模式下的公式为的best - threshold. Default: ‘rel’.
cooldown (int) – 减少lr后恢复正常 *** 作前等待的时间间隔. Default: 0.
min_lr (float or list) – 标量或标量列表。

所有参数组或每组的学习率的下界. Default: 0.
eps (float) – 作用于lr的最小衰减。

如果新旧lr之间的差异小于eps，则忽略更新. Default: 1e-8.

举例：

import torchvision.models as models

import torch.nn as nn

model = models.resnet34(pretrained=True)

fc_features = model.fc.in_features

model.fc = nn.Linear(fc_features, )

criterion = nn.CrossEntropyLoss()

optimizer = optim.SGD(params = model.parameters(), lr=)

scheduler = lr_scheduler.ReduceLROnPlateau(optimizer, 'min')

inputs = torch.randn(,,,)

labels = torch.LongTensor([,,,])

plt.figure()

x = list(range())

y = []

for epoch in range():

    optimizer.zero_grad()

    outputs = model(inputs)

    #print(outputs)

    loss = criterion(outputs, labels)

    print(loss)

    loss.backward()

    scheduler.step(loss)

    optimizer.step()

    lr = optimizer.param_groups[]['lr']

    print(epoch, lr)

    y.append(lr)

plt.plot(x,y)

监督loss，如果loss在patient=10的epoch中没有改进，那么lr就会衰减

tensor(0.7329, grad_fn=<NllLossBackward>)

tensor(690.2101, grad_fn=<NllLossBackward>)

tensor(2359.7373, grad_fn=<NllLossBackward>)

tensor(., grad_fn=<NllLossBackward>)

tensor(240161.7969, grad_fn=<NllLossBackward>)

tensor(3476952.2500, grad_fn=<NllLossBackward>)

tensor(5098666.5000, grad_fn=<NllLossBackward>)

tensor(719.7433, grad_fn=<NllLossBackward>)

tensor(6.7871, grad_fn=<NllLossBackward>)

tensor(5.5356, grad_fn=<NllLossBackward>)

tensor(4.2844, grad_fn=<NllLossBackward>)

tensor(3.0342, grad_fn=<NllLossBackward>)

 1.0

tensor(2.9092, grad_fn=<NllLossBackward>)

 1.0

tensor(2.7843, grad_fn=<NllLossBackward>)

 1.0

tensor(2.6593, grad_fn=<NllLossBackward>)

 1.0

tensor(2.5343, grad_fn=<NllLossBackward>)

 1.0

tensor(2.4093, grad_fn=<NllLossBackward>)

 1.0

tensor(2.2844, grad_fn=<NllLossBackward>)

 1.0

tensor(2.1595, grad_fn=<NllLossBackward>)

 1.0

tensor(2.0346, grad_fn=<NllLossBackward>)

 1.0

tensor(1.9099, grad_fn=<NllLossBackward>)

 1.0

tensor(1.7853, grad_fn=<NllLossBackward>)

 1.0

tensor(1.6610, grad_fn=<NllLossBackward>)

 0.1

tensor(1.6486, grad_fn=<NllLossBackward>)

 0.1

tensor(1.6362, grad_fn=<NllLossBackward>)

 0.1

tensor(1.6238, grad_fn=<NllLossBackward>)

 0.1

tensor(1.6114, grad_fn=<NllLossBackward>)

 0.1

tensor(1.5990, grad_fn=<NllLossBackward>)

 0.1

tensor(1.5866, grad_fn=<NllLossBackward>)

 0.1

tensor(1.5743, grad_fn=<NllLossBackward>)

 0.1

tensor(1.5619, grad_fn=<NllLossBackward>)

 0.1

tensor(1.5496, grad_fn=<NllLossBackward>)

 0.1

tensor(1.5372, grad_fn=<NllLossBackward>)

 0.1

tensor(1.5249, grad_fn=<NllLossBackward>)

 0.010000000000000002

tensor(1.5236, grad_fn=<NllLossBackward>)

 0.010000000000000002

tensor(1.5224, grad_fn=<NllLossBackward>)

 0.010000000000000002

tensor(1.5212, grad_fn=<NllLossBackward>)

 0.010000000000000002

tensor(1.5199, grad_fn=<NllLossBackward>)

 0.010000000000000002

tensor(1.5187, grad_fn=<NllLossBackward>)

 0.010000000000000002

tensor(1.5175, grad_fn=<NllLossBackward>)

 0.010000000000000002

tensor(1.5163, grad_fn=<NllLossBackward>)

 0.010000000000000002

tensor(1.5150, grad_fn=<NllLossBackward>)

 0.010000000000000002

tensor(1.5138, grad_fn=<NllLossBackward>)

 0.010000000000000002

tensor(1.5126, grad_fn=<NllLossBackward>)

 0.010000000000000002

tensor(1.5113, grad_fn=<NllLossBackward>)

 0.0010000000000000002

tensor(1.5112, grad_fn=<NllLossBackward>)

 0.0010000000000000002

tensor(1.5111, grad_fn=<NllLossBackward>)

 0.0010000000000000002

tensor(1.5110, grad_fn=<NllLossBackward>)

 0.0010000000000000002

tensor(1.5108, grad_fn=<NllLossBackward>)

 0.0010000000000000002

tensor(1.5107, grad_fn=<NllLossBackward>)

 0.0010000000000000002

tensor(1.5106, grad_fn=<NllLossBackward>)

 0.0010000000000000002

tensor(1.5105, grad_fn=<NllLossBackward>)

 0.0010000000000000002

tensor(1.5103, grad_fn=<NllLossBackward>)

 0.0010000000000000002

tensor(1.5102, grad_fn=<NllLossBackward>)

 0.0010000000000000002

tensor(1.5101, grad_fn=<NllLossBackward>)

 0.0010000000000000002

tensor(1.5100, grad_fn=<NllLossBackward>)

 0.00010000000000000003

tensor(1.5100, grad_fn=<NllLossBackward>)

 0.00010000000000000003

tensor(1.5099, grad_fn=<NllLossBackward>)

 0.00010000000000000003

tensor(1.5099, grad_fn=<NllLossBackward>)

 0.00010000000000000003

tensor(1.5099, grad_fn=<NllLossBackward>)

 0.00010000000000000003

第一个loss为0.7329，一直向后的patient=10的10个epoch中都没有loss小于它，所以根据mode='min'，lr = lr*factor=lr * 0.1,所以lr从10变为了1.0

如图：

⚠️该函数没有get_lr()，所以使用optimizer.param_groups[0]['lr']得到当前的学习率

7.CyclicLR

CLASS torch.optim.lr_scheduler.CyclicLR(optimizer, base_lr, max_lr, step_size_up=, step_size_down=None, mode='triangular', gamma=1.0, scale_fn=None, scale_mode='cycle', cycle_momentum=True, base_momentum=0.8, max_momentum=0.9, last_epoch=-)

根据循环学习速率策略(CLR)设置各参数组的学习速率。

该策略以恒定的频率循环两个边界之间的学习率，论文 Cyclical Learning Rates for Training Neural Networks中进行详细介绍。

两个边界之间的距离可以按每次迭代或每次循环进行缩放。

循环学习率策略会在每批batch数据之后改变学习率。

该类的step()函数应在使用批处理进行训练后调用。

该类有三个内置策略：

“triangular”:一个基本的三角形周期w，无振幅缩放

“triangular2”:一种基本的三角形周期，每个周期的初始振幅乘以一半。

“exp_range”:在每次循环迭代时，初始振幅按**(循环迭代)缩放的循环。



This implementation was adapted from the github repo: bckenstler/CLR


参数：

optimizer (Optimizer) – 封装的优化器
base_lr (float or list) –初始学习率，即各参数组在循环中的下界。
max_lr (float or list) – 各参数组在循环中的学习率上限。

在功能上，它定义了周期振幅(max_lr - base_lr)。

任意周期的lr是base_lr和振幅的某种比例的和;因此，根据缩放函数，实际上可能无法达到max_lr。
step_size_up (int) – 在周期的上升部分中，训练迭代的次数. Default: 2000
step_size_down (int) – 在一个周期的下降部分的训练迭代次数。

如果step_size_down为None，则将其设置为step_size_up. Default: None
mode (str) – {triangular, triangular2, exp_range}三个模式之一.值对应于上面详细说明的策略。

如果scale_fn不为None，则忽略该参数. Default: ‘triangular’
gamma (float) – 在' exp_range '缩放函数中的常量 :计算公式为gamma**(循环迭代)。

Default: 1.0
scale_fn (function) – 由一个参数lambda函数定义的自定义缩放策略，其中对于所有x >= 0, 0 <= scale_fn(x) <= 1。

如果指定，则忽略“mode”. Default: None
scale_mode (str) – {‘cycle’, ‘iterations’}.定义scale_fn是根据循环数计算还是根据循环迭代(从循环开始的训练迭代)计算. Default: ‘cycle’
cycle_momentum (bool) – 如果为True,momentum与“base_momentum”和“max_momentum”之间的学习率成反比。

. Default: True
base_momentum (float or list) – 初始momentum是各参数组在周期中的下界. Default: 0.8
max_momentum (float or list) – 各参数组在周期中的最大momentum边界。

在功能上，它定义了周期振幅(max_momentum - base_momentum)。

任意周期的momentum等于最大动量与振幅的比例之差;因此，根据缩放函数，实际上可能无法达到base_momentum. Default: 0.9
last_epoch (int) – 最后一批batch的索引。

此参数用于恢复训练工作。

因为step()应该在每个批处理之后调用，而不是在每个epoch之后调用，所以这个数字表示计算的批处理总数，而不是计算的epoch总数。

当last_epoch=-1时，调度将从头开始. Default: -1

举例：

出错：找不到CyclicLR,因为我1.0.1版本中没有这个类:

AttributeError: module 'torch.optim.lr_scheduler' has no attribute 'CyclicLR'

然后更新torch到最新版本1.1.0：

(deeplearning) userdeMBP:ageAndGender user$ pip install --upgrade torch torchvision

Collecting torch

...

Installing collected packages: torch

  Found existing installation: torch 1.0..post2

    Uninstalling torch-1.0..post2:

      Successfully uninstalled torch-1.0..post2

Successfully installed torch-1.1.

然后又报错：

(deeplearning) userdeMBP:ageAndGender user$ python

Python 3.6. |Anaconda, Inc.| (default, Dec  , ::)

[GCC 4.2. Compatible Clang 4.0. (tags/RELEASE_401/final)] on darwin

Type "help", "copyright", "credits" or "license" for more information.

>>> import torch

Traceback (most recent call last):

  File "<stdin>", line , in <module>

  File "/anaconda3/envs/deeplearning/lib/python3.6/site-packages/torch/__init__.py", line , in <module>

    from torch._C import *

ImportError: dlopen(/anaconda3/envs/deeplearning/lib/python3./site-packages/torch/_C.cpython-36m-darwin.so, ): Library not loaded: /usr/local/opt/libomp/lib/libomp.dylib

  Referenced from: /anaconda3/envs/deeplearning/lib/python3./site-packages/torch/lib/libshm.dylib

  Reason: image not found

>>>

没能解决这个问题，小伙伴有解决了的希望能告知

该类详情可见https://blog.csdn.net/u013166817/article/details/86503899

pix2pix代码相关部分为：

def get_scheduler(optimizer, opt):

    """返回学习率调试器

    Parameters:

        optimizer          -- 网络使用的优化器

        opt (option class) -- 存储的所有的实验标记，需要是BaseOptions的子类

                              opt.lr_policy是学习率策略的名字，如: linear | step | plateau | cosine

    对于'linear'，对前<opt.niter>个迭代（默认为100）中我们保持相同的学习率，并在下面的<opt.niter_decay>个迭代(m默认为100)中线性衰减学习率到0

    对于其他的调试器(step, plateau, and cosine)，使用默认的pytorch配置

    See https://pytorch.org/docs/stable/optim.html for more details.

    """

    if opt.lr_policy == 'linear':

        def lambda_rule(epoch): #epoch_count表示epoch开始的值，默认为1

            lr_l = 1.0 - max(, epoch + opt.epoch_count - opt.niter) / float(opt.niter_decay + )

            return lr_l

        scheduler = lr_scheduler.LambdaLR(optimizer, lr_lambda=lambda_rule)

    elif opt.lr_policy == 'step':

        scheduler = lr_scheduler.StepLR(optimizer, step_size=opt.lr_decay_iters, gamma=0.1)

    elif opt.lr_policy == 'plateau':

        scheduler = lr_scheduler.ReduceLROnPlateau(optimizer, mode='min', factor=0.2, threshold=0.01, patience=)

    elif opt.lr_policy == 'cosine':

        scheduler = lr_scheduler.CosineAnnealingLR(optimizer, T_max=opt.niter, eta_min=)

    else:

        return NotImplementedError('learning rate policy [%s] is not implemented', opt.lr_policy)

    return scheduler

欢迎分享，转载请注明来源：内存溢出

原文地址: https://outofmemory.cn/zaji/588184.html

pytorch中的学习率调整函数

发表评论

评论列表（0条）