tf.compat.v1.train.SyncReplicasOptimizer

Класс для синхронизации, агрегирования градиентов и передачи их оптимизатору.

Наследуется от: Optimizer

tf.compat.v1.train.SyncReplicasOptimizer(
    opt,
    replicas_to_aggregate,
    total_num_replicas=None,
    variable_averages=None,
    variables_to_average=None,
    use_locking=False,
    name='sync_replicas'
)

Этот класс устарел. Для синхронной обучения, пожалуйста, используйте Стратегии распределения.

В типичной асинхронной среде обучения часто встречаются устаревшие градиенты. Например, при асинхронном обучении с N репликами градиенты будут применяться к переменным N раз независимо. В зависимости от скорости обучения каждой реплики, некоторые градиенты могут быть рассчитаны на основе копий переменной из нескольких предыдущих шагов (в среднем N-1 шаг). Этот оптимизатор избегает устаревших градиентов, собирая градиенты со всех реплик, усредняя их, а затем применяя их к переменным за один раз, после чего реплики могут получить новые переменные и продолжить.

Создаются следующие аккумуляторы/очереди:

• N gradient accumulators, по одной на каждую обучаемую переменную. Градиенты помещаются в них, и главный рабочий будет ждать, пока не будет собрано достаточно градиентов, а затем усреднит их перед применением к переменным. Аккумулятор будет отбрасывать все устаревшие градиенты (подробнее в операции аккумулятора).
• 1 token очередь, в которую оптимизатор помещает новое значение global_step после обновления всех переменных.

Создается следующая локальная переменная:

• sync_rep_local_step, по одной на каждую реплику. Сравнивается с global_step в каждом аккумуляторе для проверки устарелости градиентов.

Оптимизатор добавляет узлы в граф, чтобы собирать градиенты и приостанавливать обучение до обновления переменных. Для узла сервера параметров:

1. Для каждой переменной создается аккумулятор, и каждая реплика помещает градиенты в аккумуляторы вместо прямого применения к переменным.
2. Каждый аккумулятор усредняет градиенты, когда их накопилось достаточно (replicas_to_aggregate).
3. Применяются усредненные градиенты к переменным.
4. Только после обновления всех переменных увеличивается global_step.
5. Только после шага 4, помещаются global_step в token_queue, по одному для каждой реплики рабочего. Рабочие теперь могут получить global_step, использовать его для обновления локального значения local_step и начать следующую партию. Обратите внимание, что некоторые рабочие могут обрабатывать несколько мини-парт, а некоторые — даже не одну. Это происходит потому, что каждый рабочий получает мини-партии, пока существует токен. Если рабочий по какой-то причине застрял и не использует токен, другой рабочий может его использовать.

Для реплик:

1. Начать шаг: получить переменные и вычислить градиенты.
2. После вычисления градиентов поместить их в аккумуляторы градиентов. Каждый аккумулятор проверит устарелость и отбросит устаревшие.
3. После помещения всех градиентов извлечь обновленное значение global_step из очереди токенов и записать этот шаг в локальное значение local_step. Обратите внимание, что это фактически является барьером.
4. Начать следующую партию.

Использование

# Create any optimizer to update the variables, say a simple SGD:
opt = GradientDescentOptimizer(learning_rate=0.1)

# Wrap the optimizer with sync_replicas_optimizer with 50 replicas: at each
# step the optimizer collects 50 gradients before applying to variables.
# Note that if you want to have 2 backup replicas, you can change
# total_num_replicas=52 and make sure this number matches how many physical
# replicas you started in your job.
opt = tf.compat.v1.train.SyncReplicasOptimizer(opt, replicas_to_aggregate=50,
                               total_num_replicas=50)

# Some models have startup_delays to help stabilize the model but when using
# sync_replicas training, set it to 0.

# Now you can call `minimize()` or `compute_gradients()` and
# `apply_gradients()` normally
training_op = opt.minimize(total_loss, global_step=self.global_step)


# You can create the hook which handles initialization and queues.
sync_replicas_hook = opt.make_session_run_hook(is_chief)

В программе обучения каждый рабочий будет выполнять train_op как будто он не синхронизирован.

with training.MonitoredTrainingSession(
    master=workers[worker_id].target, is_chief=is_chief,
    hooks=[sync_replicas_hook]) as mon_sess:
  while not mon_sess.should_stop():
    mon_sess.run(training_op)

Методы

apply_gradients

Просмотреть исходный код

apply_gradients(
    grads_and_vars, global_step=None, name=None
)

Применить градиенты к переменным.

Этот метод содержит большую часть реализации синхронизации и также оборачивает apply_gradients() из реального оптимизатора.

compute_gradients

Просмотреть исходный код

compute_gradients(
    *args, **kwargs
)

Вычислить градиенты "loss" для переменных в "var_list".

Просто оборачивает compute_gradients() от реального оптимизатора. Градиенты будут агрегированы в apply_gradients(), поэтому пользователь может изменить градиенты, например, выполнив обрезку с помощью глобальной нормы по репликам, если это необходимо. Глобальная норма с агрегированными градиентами может быть неблагоприятна, так как огромные градиенты одной реплики могут навредить градиентам других реплик.

get_chief_queue_runner

Просмотреть исходный код

get_chief_queue_runner()

Возвращает QueueRunner для выполнения главным узлом.

Включает операции синхронизации реплик: агрегация градиентов, применение к переменным, инкремент global_step, вставка токенов в очередь токенов.

Обратите внимание, что это можно вызвать только после вызова apply_gradients(), который фактически генерирует этот queuerunner.

get_init_tokens_op

Просмотреть исходный код

get_init_tokens_op(
    num_tokens=-1
)

Возвращает операцию для заполнения sync_token_queue токенами.

Предполагается, что это выполняется в начале процесса главного/синхронизированного потока, чтобы даже если total_num_replicas меньше replicas_to_aggregate, модель все еще могла продолжать работу, так как реплики могут вычислять несколько шагов на обновление переменной. Убедитесь в следующем: num_tokens >= replicas_to_aggregate - total_num_replicas.

get_name

Просмотреть исходный код

get_name()

get_slot

Просмотреть исходный код

get_slot(
    *args, **kwargs
)

Возвращает слот с именем "name", созданный для "var" оптимизатором.

Просто оборачивает get_slot() из фактического оптимизатора.

get_slot_names

Просмотреть исходный код

get_slot_names(
    *args, **kwargs
)

Возвращает список имён слотов, созданных Optimizer.

Просто оборачивает get_slot_names() из фактического оптимизатора.

make_session_run_hook

Просмотреть исходный код

make_session_run_hook(
    is_chief, num_tokens=-1
)

Создаёт обработчик для операций SyncReplicasHook, таких как инициализация.

minimize

Просмотреть исходный код

minimize(
    loss,
    global_step=None,
    var_list=None,
    gate_gradients=GATE_OP,
    aggregation_method=None,
    colocate_gradients_with_ops=False,
    name=None,
    grad_loss=None
)

Добавляет операции для минимизации loss путём обновления var_list.

Этот метод просто объединяет вызовы compute_gradients() и apply_gradients(). Если вы хотите обработать градиент перед применением, вызовите compute_gradients() и apply_gradients() явно вместо использования этой функции.

При включённом режиме Eager выполнения, loss должна быть функцией Python, которая не принимает аргументов и вычисляет значение, подлежащее минимизации. Минимизация (и вычисление градиента) выполняется относительно элементов var_list, если он не None, иначе относительно любых обучаемых переменных, созданных во время выполнения функции loss. gate_gradients, aggregation_method, colocate_gradients_with_ops и grad_loss игнорируются при включённом режиме Eager выполнения.

variables

Просмотреть исходный код

variables()

Извлекает список переменных оптимизатора в стандартной диаграмме.

Оборачивает variables() из фактического оптимизатора. Не включает локальный шаг SyncReplicasOptimizer.