File size: 3,561 Bytes
52a9452 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 |
from bisect import bisect_right
import numpy as np
import torch.optim.lr_scheduler as lr_scheduler
from concern.config import Configurable, State
from concern.signal_monitor import SignalMonitor
class ConstantLearningRate(Configurable):
lr = State(default=0.0001)
def __init__(self, **kwargs):
self.load_all(**kwargs)
def get_learning_rate(self, epoch, step):
return self.lr
class FileMonitorLearningRate(Configurable):
file_path = State()
def __init__(self, **kwargs):
self.load_all(**kwargs)
self.monitor = SignalMonitor(self.file_path)
def get_learning_rate(self, epoch, step):
signal = self.monitor.get_signal()
if signal is not None:
return float(signal)
return None
class PriorityLearningRate(Configurable):
learning_rates = State()
def __init__(self, **kwargs):
self.load_all(**kwargs)
def get_learning_rate(self, epoch, step):
for learning_rate in self.learning_rates:
lr = learning_rate.get_learning_rate(epoch, step)
if lr is not None:
return lr
return None
class MultiStepLR(Configurable):
lr = State()
milestones = State(default=[]) # milestones must be sorted
gamma = State(default=0.1)
def __init__(self, cmd={}, **kwargs):
self.load_all(**kwargs)
self.lr = cmd.get('lr', self.lr)
def get_learning_rate(self, epoch, step):
return self.lr * self.gamma ** bisect_right(self.milestones, epoch)
class WarmupLR(Configurable):
steps = State(default=4000)
warmup_lr = State(default=1e-5)
origin_lr = State()
def __init__(self, cmd={}, **kwargs):
self.load_all(**kwargs)
def get_learning_rate(self, epoch, step):
if epoch == 0 and step < self.steps:
return self.warmup_lr
return self.origin_lr.get_learning_rate(epoch, step)
class PiecewiseConstantLearningRate(Configurable):
boundaries = State(default=[10000, 20000])
values = State(default=[0.001, 0.0001, 0.00001])
def __init__(self, **kwargs):
self.load_all(**kwargs)
def get_learning_rate(self, epoch, step):
for boundary, value in zip(self.boundaries, self.values[:-1]):
if step < boundary:
return value
return self.values[-1]
class DecayLearningRate(Configurable):
lr = State(default=0.007)
epochs = State(default=1200)
factor = State(default=0.9)
def __init__(self, **kwargs):
self.load_all(**kwargs)
def get_learning_rate(self, epoch, step=None):
rate = np.power(1.0 - epoch / float(self.epochs + 1), self.factor)
return rate * self.lr
class BuitlinLearningRate(Configurable):
lr = State(default=0.001)
klass = State(default='StepLR')
args = State(default=[])
kwargs = State(default={})
def __init__(self, cmd={}, **kwargs):
self.load_all(**kwargs)
self.lr = cmd.get('lr', None) or self.lr
self.scheduler = None
def prepare(self, optimizer):
self.scheduler = getattr(lr_scheduler, self.klass)(
optimizer, *self.args, **self.kwargs)
def get_learning_rate(self, epoch, step=None):
if self.scheduler is None:
raise 'learning rate not ready(prepared with optimizer) '
self.scheduler.last_epoch = epoch
# return value of gt_lr is a list,
# where each element is the corresponding learning rate for a
# paramater group.
return self.scheduler.get_lr()[0]
|