def __init__(self, args):
self._max_trigger = util.get_trigger((args.epochs, 'epoch'))
self._interval_trigger = util.get_trigger(
(args.save_interval_iters, 'iteration'))
self.start_time = args.start_time
self.time_limit = args.time_limit * 60
self.max_epochs = args.epochs
def __init__(self, check_trigger=(1, 'epoch'), monitor='main/loss',
patience=None, mode='auto', verbose=False,
max_trigger=(100, 'epoch'), **kwargs):
# `patients` as an alias of `patience`
patients, = argument.parse_kwargs(kwargs, ('patients', None))
if patients is None:
if patience is None:
patience = 3
else:
pass
else:
if patience is None:
patience = patients
else:
raise TypeError(
'Both \'patience\' and \'patients\' arguments are '
'specified. \'patients\' is an alias of the former. '
'Specify only \'patience\'.')
self.count = 0
self.patience = patience
self.monitor = monitor
self.verbose = verbose
self.already_warning = False
self._max_trigger = util.get_trigger(max_trigger)
self._interval_trigger = util.get_trigger(check_trigger)
self._init_summary()
if mode == 'max':
self._compare = operator.gt
elif mode == 'min':
self._compare = operator.lt
else:
if 'accuracy' in monitor:
self._compare = operator.gt
else:
self._compare = operator.lt
if self._compare == operator.gt:
if verbose:
print('early stopping: operator is greater')
self.best = float('-inf')
else:
if verbose:
print('early stopping: operator is less')
self.best = float('inf')
def __init__(self,
key,
patience,
compare,
trigger=(1, 'epoch'),
max_trigger=(1000, 'epoch')):
self._key = key
self._patience = patience
self._waited = 0
self._best_value = None
self._interval_trigger = util.get_trigger(trigger)
self._max_trigger = util.get_trigger(max_trigger)
self._init_summary()
self._compare = compare
def __init__(self, key, compare, trigger=(1, 'epoch'), print_triger=False):
self._key = key
self._best_value = None
self._interval_trigger = util.get_trigger(trigger)
self._init_summary()
self._compare = compare
self._print_triger = print_triger
def run_test_early_stopping_trigger_with_accuracy(self):
comm = self.communicator
key = 'main/accuracy'
trigger = MultiNodeEarlyStoppingTrigger(comm,
monitor=key,
patience=3,
check_trigger=(1, 'epoch'),
verbose=False)
trigger = util.get_trigger(trigger)
accuracies = [
0.5, 0.5, 0.5, 0.5, 0.6, 0.6, 0.7, 0.7, 0.6, 0.6, 0.4, 0.4, 0.3,
0.3, 0.2, 0.2
]
accuracies = [x * (1 - comm.rank / comm.size) for x in accuracies]
accuracies = [
chainer.Variable(self.xp.asarray(acc, dtype=np.float32))
for acc in accuracies
]
expected = [
False, False, False, False, False, False, False, False, False,
False, False, False, False, True, False, True
]
_test_trigger(self, trigger, key, accuracies, expected)
def __init__(self, max_epoch, key, stop_condition=None, eps=1e-3,
trigger=(1, 'epoch')):
self.max_epoch = max_epoch
self.eps = eps
self._key = key
self._current_value = None
self._interval_trigger = util.get_trigger(trigger)
self._init_summary()
self.stop_condition = stop_condition or self._stop_condition
def __init__(
self, numerator_key, denominator_key, result_key,
trigger=(1, 'epoch')):
self._trigger = util.get_trigger(trigger)
self._numerator_key = numerator_key
self._denominator_key = denominator_key
self._result_key = result_key
self._numerator = 0
self._denominator = 0
def setUp(self):
self.optimizer = mock.MagicMock()
self.extension = extensions.Multistep(
'x', self.base_lr, self.gamma, self.step_value, self.optimizer)
self.interval = 1
self.expect = [e for e in self.expect for _ in range(self.interval)]
self.trigger = util.get_trigger((self.interval, 'iteration'))
self.trainer = testing.get_trainer_with_mock_updater(self.trigger)
self.trainer.updater.get_optimizer.return_value = self.optimizer
def setUp(self):
self.optimizer = mock.MagicMock()
self.extension = extensions.ExponentialShift(
'x', self.rate, self.init, self.target, self.optimizer)
self.interval = 4
self.expect = [e for e in self.expect for _ in range(self.interval)]
self.trigger = util.get_trigger((self.interval, 'iteration'))
self.trainer = testing.get_trainer_with_mock_updater(self.trigger)
self.trainer.updater.get_optimizer.return_value = self.optimizer
def setUp(self):
self.optimizer = mock.MagicMock()
self.extension = extensions.MultistepShift(
'x', self.gamma, self.step_value, self.init, self.optimizer)
self.interval = 1
self.expect = [e for e in self.expect for _ in range(self.interval)]
self.trigger = util.get_trigger((self.interval, 'iteration'))
self.trainer = testing.get_trainer_with_mock_updater(self.trigger)
self.trainer.updater.get_optimizer.return_value = self.optimizer
def __init__(self,
numerator_key,
denominator_key,
result_key,
trigger=(1, 'epoch')):
self._trigger = util.get_trigger(trigger)
self._numerator_key = numerator_key
self._denominator_key = denominator_key
self._result_key = result_key
self._numerator = 0
self._denominator = 0
def __init__(self,
key,
compare,
trigger=(1, 'epoch'),
best_value=None,
verbose=True):
self._key = key
self._best_value = best_value
self._interval_trigger = util.get_trigger(trigger)
self._init_summary()
self._compare = compare
self.verbose = verbose
def __init__(self,
max_epoch,
key,
stop_condition=None,
eps=0.01,
trigger=(1, 'epoch')):
self.max_epoch = max_epoch
self.eps = eps
self._key = key
self._best_value = None
self._interval_trigger = util.get_trigger(trigger)
self._init_summary()
def __init__(self,
check_trigger=(1, 'epoch'),
monitor='main/loss',
patients=3,
mode='auto',
verbose=False,
max_trigger=(100, 'epoch')):
self.count = 0
self.patients = patients
self.monitor = monitor
self.verbose = verbose
self.already_warning = False
self._max_trigger = util.get_trigger(max_trigger)
self._interval_trigger = util.get_trigger(check_trigger)
self._init_summary()
if mode == 'max':
self._compare = operator.gt
elif mode == 'min':
self._compare = operator.lt
else:
if 'accuracy' in monitor:
self._compare = operator.gt
else:
self._compare = operator.lt
if self._compare == operator.gt:
if verbose:
print('early stopping: operator is greater')
self.best = float('-inf')
else:
if verbose:
print('early stopping: operator is less')
self.best = float('inf')
def test_early_stopping_trigger_with_loss(self):
key = 'main/loss'
trigger = triggers.EarlyStoppingTrigger(monitor=key, patients=3,
check_trigger=(1, 'epoch'))
trigger = util.get_trigger(trigger)
accuracies = [100, 80, 30, 10, 20, 24, 30, 35]
accuracies = numpy.asarray([
chainer.Variable(numpy.asarray(acc, dtype=numpy.float32))
for acc in accuracies])
expected = [False, False, False, False, False, False, True, True]
_test_trigger(self, trigger, key, accuracies, expected)
def test_early_stopping_trigger_with_loss(self):
key = 'main/loss'
trigger = triggers.EarlyStoppingTrigger(monitor=key, patience=3,
check_trigger=(1, 'epoch'))
trigger = util.get_trigger(trigger)
accuracies = [100, 80, 30, 10, 20, 24, 30, 35]
accuracies = numpy.asarray([
chainer.Variable(numpy.asarray(acc, dtype=numpy.float32))
for acc in accuracies])
expected = [False, False, False, False, False, False, True, True]
_test_trigger(self, trigger, key, accuracies, expected)
def __init__(self, comm, original_key, aggregated_key=None,
comm_trigger=(1, 'iteration'), aggregator=None):
self.comm = comm
self.original_key = original_key
if aggregated_key is None:
self.aggregated_key = original_key
else:
self.aggregated_key = aggregated_key
self.comm_trigger = util.get_trigger(comm_trigger)
self.observation_history = []
self.aggregator = aggregator or _average_2d
def __init__(self, triggers, max_trigger=(100, 'epoch')):
self._triggers = list(triggers)
self._max_trigger = util.get_trigger(max_trigger)
# find minimum training length
lengths = [
t.get_training_length() for t in triggers
if hasattr(t, 'get_training_length')
]
lengths = sorted(lengths,
key=lambda x: (1 if x[1] == 'epoch' else 0, x[0]),
reverse=True)
self._training_length = lengths[0] or max_trigger
logger.info('training length: {}'.format(self._training_length))
def test_early_stopping_trigger_with_accuracy(self):
key = 'main/accuracy'
trigger = triggers.EarlyStoppingTrigger(monitor=key, patients=3,
check_trigger=(1, 'epoch'),
verbose=False)
trigger = util.get_trigger(trigger)
accuracies = [0.5, 0.5, 0.6, 0.7, 0.6, 0.4, 0.3, 0.2]
accuracies = numpy.asarray([
chainer.Variable(numpy.asarray(acc, dtype=numpy.float32))
for acc in accuracies])
expected = [False, False, False, False, False, False, True, True]
_test_trigger(self, trigger, key, accuracies, expected)
def test_early_stopping_trigger_with_accuracy(self):
key = 'main/accuracy'
trigger = triggers.EarlyStoppingTrigger(monitor=key, patience=3,
check_trigger=(1, 'epoch'),
verbose=False)
trigger = util.get_trigger(trigger)
accuracies = [0.5, 0.5, 0.6, 0.7, 0.6, 0.4, 0.3, 0.2]
accuracies = numpy.asarray([
chainer.Variable(numpy.asarray(acc, dtype=numpy.float32))
for acc in accuracies])
expected = [False, False, False, False, False, False, True, True]
_test_trigger(self, trigger, key, accuracies, expected)
def __init__(self, check_trigger=(1, 'epoch'), monitor='main/loss',
patients=3, mode='auto', verbose=False,
max_trigger=(100, 'epoch')):
self.count = 0
self.patients = patients
self.monitor = monitor
self.verbose = verbose
self.already_warning = False
self._max_trigger = util.get_trigger(max_trigger)
self._interval_trigger = util.get_trigger(check_trigger)
self._init_summary()
if mode == 'max':
self._compare = operator.gt
elif mode == 'min':
self._compare = operator.lt
else:
if 'accuracy' in monitor:
self._compare = operator.gt
else:
self._compare = operator.lt
if self._compare == operator.gt:
if verbose:
print('early stopping: operator is greater')
self.best = float('-inf')
else:
if verbose:
print('early stopping: operator is less')
self.best = float('inf')
def __init__(self, key, compare, trigger=(1, 'epoch'),
n_times=5, max_trigger=None, print_triger=False):
self.period = max_trigger
self.unit = 'epoch'
self._key = key
self._best_value = None
self._interval_trigger = util.get_trigger(trigger)
self._init_summary()
self._compare = compare
self._print_triger = print_triger
self._n_times = n_times
self._n_fails = 0
self._max_trigger = max_trigger
self._n_triggers = 0
def __init__(self,
max_epoch,
key,
stop_condition=None,
eps=0.0001,
trigger=(1, 'epoch'),
early_stopping=5):
self.max_epoch = max_epoch
self.eps = eps
self.early_stopping = early_stopping
self._key = key
self._current_value = None
self._interval_trigger = util.get_trigger(trigger)
self._init_summary()
self.stop_condition = stop_condition or self._stop_condition
self.f1_scores_dev = []
def __init__(self,
trigger=(1, 'epoch'),
monitor='main/loss',
patients=3,
mode='auto',
verbose=False,
max_epoch=100,
debug=False):
self.count = 0
self.patients = patients
self.monitor = monitor
self.verbose = verbose
self.debug = debug
self.max_epoch = max_epoch
self.already_warning = False
self._interval_trigger = util.get_trigger(trigger)
self.listeners = []
self._init_summary()
if mode == 'max':
self._compare = greater
elif mode == 'min':
self._compare = less
else:
if 'accuracy' in monitor:
self._compare = greater
else:
self._compare = less
if self._compare == greater:
if verbose:
print('early stopping: operator is greater')
self.best = -1 * (1 << 50)
else:
if verbose:
print('early stopping: operator is less')
self.best = 1 << 50
def setUp(self):
self.trainer = _get_mocked_trainer()
self.interval = 4
self.expect = [e for e in self.expect for _ in range(self.interval)]
self.trigger = get_trigger((self.interval, 'iteration'))
def setUp(self):
self.trainer = _get_mocked_trainer()
self.interval = 4
self.expect = [e for e in self.expect for _ in range(self.interval)]
self.trigger = get_trigger((self.interval, 'iteration'))
def __init__(self, key, compare, trigger=(1, 'epoch')):
self._key = key
self._best_value = None
self._interval_trigger = util.get_trigger(trigger)
self._init_summary()
self._compare = compare
