Шаги vs num_epochs в учебнике для начинающих tenorflow

Ответ 1

Модуль contrib.learn.io не документирован очень хорошо, но кажется, что функция numpy_input_fn() принимает несколько массивов numpy и объединяет их вместе как вход для классификатора. Таким образом, количество эпох, вероятно, означает "сколько раз пройти через входные данные, которые у меня есть до остановки". В этом случае они подают два массива длины 4 в 4 элементарных пакетах, поэтому это будет означать, что функция ввода будет делать это не более 1000 раз, прежде чем поднимать исключение из "данных". Аргумент шагов в функции оценки fit() заключается в том, сколько раз следователь должен выполнить цикл обучения. Этот конкретный пример несколько извращен, поэтому позвольте мне составить еще один, чтобы сделать вещи более ясными (надеюсь).

Допустим, у вас есть два массива numpy (образцы и метки), которые вы хотите тренировать. Они по 100 элементов каждый. Вы хотите, чтобы ваше обучение принимало партии с 10 образцами за партию. Таким образом, после 10 партий вы пройдете все свои учебные данные. Это одна эпоха. Если вы установите генератор ввода на 10 эпох, он будет проходить ваш тренировочный набор 10 раз перед остановкой, то есть будет генерироваться не более 100 партий.

Опять же, модуль io не документирован, но, учитывая, как работают другие API-интерфейсы, связанные с вводом данных в тензорном потоке, должно быть возможно заставить его генерировать данные для неограниченного количества эпох, поэтому единственное, что контролирует продолжительность обучения, быть шагами. Это дает вам дополнительную гибкость в отношении того, как вы хотите, чтобы ваше обучение продвигалось вперед. Вы можете пройти несколько эпох за раз или несколько шагов за раз, или то и другое.

Edit: TL; DR Epoch - это когда ваша модель просматривает ваши данные о тренировках один раз. Шаг, когда ваша модель тренируется на одной партии (или один образец, если вы отправляете образцы по одному). Обучение в течение 5 эпох на 1000 пробных 10 образцов на партию займет 500 шагов.

Ответ 2

Эпоха: один проход через все данные.

Размер партии: нет примеров из одной партии.

Если есть 1000 примеров, а размер партии - 100, тогда будет 10 шагов за эпоху.

Эпохи и размер партии полностью определяют количество шагов.

steps_cal = (no из ex/batch_size) * no_of_epochs

estimator.fit(input_fn=input_fn)

Если вы просто напишите вышеприведенный код, то значение "шагов" указано в шаге "steps_cal" в приведенной выше формуле.

estimator.fit(input_fn=input_fn, steps  = steps_less)

Если вы даете значение (скажем, "step_less" ) меньше, чем "steps_cal", тогда будет выполняться только "step_less" никаких шагов. В этом случае обучение не будет охватывать целую эпоху, о которой упоминалось.

estimator.fit(input_fn=input_fn, steps  = steps_more)

Если вы дадите значение (скажем, step_more) больше шагов step_cal, то также будет выполнено "step_cal" no шагов.

Ответ 3

Начнем с противоположного порядка:

1) Шаги - количество циклов обучения в вашем алгоритме обучения будет выполняться для обновления параметров в модели. В каждой итерации цикла он обрабатывает кусок данных, который в основном представляет собой пакет. Обычно этот цикл основан на алгоритме Gradient Descent.

2) Размер партии - размер части данных, которые вы кормите в каждом цикле алгоритма обучения. Вы можете подать набор данных целый, и в этом случае размер партии равен размеру набора данных. Вы также можете подать один пример за раз. Или вы можете подать некоторое количество N примеров.

3) Эпоха - количество раз, когда вы запускаете набор данных для извлечения партий для подачи алгоритма обучения.

Скажем, у вас 1000 примеров. Установка размера партии = 100, epoch = 1 и шагов = 200 дает процесс с одним проходом (одна эпоха) по всему набору данных. В каждом проходе он будет подавать алгоритм партии со 100 примерами. Алгоритм будет выполнять 200 шагов в каждой партии. Всего видно 10 партий. Если вы измените эпоху на 25, тогда она будет делать это 25 раз, и вы получите 25x10 партий, которые можно увидеть вообще.

Зачем нам это нужно? Существует множество вариантов спуска градиента (пакетный, стохастический, мини-пакетный), а также другие алгоритмы оптимизации параметров обучения (например, L-BFGS). Некоторые из них должны видеть данные в партиях, в то время как другие видят одну датуту за раз. Кроме того, некоторые из них включают случайные факторы/этапы, поэтому для получения хорошей конвергенции вам может потребоваться несколько проходов.

Ответ 4

num_epochs: максимальное количество эпох (просмотр каждой точки данных).

: количество обновлений (параметров).

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

Ответ 5

Этот ответ основан на эксперименте, который я сделал с началом учебного кода.

Mad Wombat дал подробное объяснение терминов num_epochs, batch_size и шагов. Этот ответ является продолжением его ответа.

num_epochs - максимальное количество раз, когда программа может выполнять итерацию по всему набору данных за один train(). Используя этот аргумент, мы можем ограничить количество партий, которые могут быть обработаны во время выполнения одного метода train().

batch_size - количество примеров в одной партии, испускаемой параметром input_fn

- количество пакетов, которые метод LinearRegressor.train() может обрабатывать в одном выполнении

max_steps - еще один аргумент метода LinearRegressor.train(). Этот аргумент определяет максимальное количество шагов (партий), которые могут обрабатываться в течение жизни LinearRegressor().

Пусть это означает. Следующие эксперименты меняют две строки кода, предоставленные учебником. Остальная часть кода остается как есть.

Примечание. Для всех примеров предположим, что количество тренировок, то есть длина x_train равна 4.

Пример 1:

input_fn = tf.estimator.inputs.numpy_input_fn( {"x": x_train}, y_train, batch_size=4, num_epochs=2, shuffle=True)

estimator.train(input_fn=input_fn, steps=10)

В этом примере мы определили batch_size = 4 и num_epochs = 2. Таким образом, input_fn может испускать всего 2 партии входных данных для одного выполнения train(). Несмотря на то, что мы определили шаги = 10, метод train() останавливается через 2 шага.

Теперь снова запустите estimator.train(input_fn=input_fn, steps=10). Мы видим, что выполнено еще 2 шага. Мы можем продолжать выполнять метод train() снова и снова. Если мы выполним train() 50 раз, выполнено 100 шагов.

Пример 2:

input_fn = tf.estimator.inputs.numpy_input_fn( {"x": x_train}, y_train, batch_size=2, num_epochs=2, shuffle=True)

estimator.train(input_fn=input_fn, steps=10)

В этом примере значение batch_size изменяется на 2 (оно равно 4 в Ex 1). Теперь при каждом выполнении метода train() обрабатываются 4 шага. После 4-го шага нет партий для запуска. Если метод train() выполняется снова, обрабатываются еще 4 шага, что делает его в общей сложности 8 шагов.

Здесь значение шагов не имеет значения, потому что метод train() может получить максимум 4 партии. Если значение шагов меньше (num_epochs x training_size)/batch_size, см. Ex 3.

Пример 3:

input_fn = tf.estimator.inputs.numpy_input_fn( {"x": x_train}, y_train, batch_size=2, num_epochs=8, shuffle=True)

estimator.train(input_fn=input_fn, steps=10)

Теперь пусть batch_size = 2, num_epochs = 8 и шаги = 10. input_fn может испускать в общей сложности 16 партий за один проход метода train(). Тем не менее, шаги установлены на 10. Это означает, что eventhough input_fn может предоставить 16 пакетов для выполнения, train() должен остановиться после 10 шагов. Конечно, метод train() может быть повторно выполнен для дополнительных шагов в совокупности.

Из примеров 1, 2 и 3 мы можем четко видеть, как значения шагов, num_epoch и batch_size влияют на количество шагов, которые могут быть выполнены методом train() за один проход.

Аргумент max_steps метода train() ограничивает общее количество шагов, которые могут выполняться кумулятивно train()

Пример 4:

Если batch_size = 4, num_epochs = 2, input_fn может испускать 2 партии для выполнения одного train(). Но если для параметра max_steps установлено значение 20, независимо от того, сколько раз train() выполняется, в оптимизации будет выполняться всего 20 шагов. Это отличается от примера 1, когда оптимизатор может работать до 200 шагов, если метод train() вызывается 100 раз.

Надеемся, что это дает подробное понимание того, что означают эти аргументы.