Master Tensorflow Распределенная тренировка: MirroredStrategy, Tpustrategy и многое другое
1 августа 2025 г.Обзор контента
- Обзор
- Установите TensorFlow
- Типы стратегий
- MirroredStrategy
- Tpustrategy
- MultiporwermirRoredStrategy
- ParameterSerVrategy
- Центральная стоимость
- Другие стратегии
- Используйте tf.distribute.strategy с keras model.fit
- Что сейчас поддерживается?
- Примеры и учебные пособия
Обзор
tf.distribute.Strategyэто API TensorFlow для распространения тренировок по нескольким графическим процессорам, нескольким машинах или TPU. Используя этот API, вы можете распространять свои существующие модели и код обучения с минимальными изменениями кода.
tf.distribute.Strategyбыл разработан с учетом этих ключевых целей:
- Простые в использовании и поддержка нескольких сегментов пользователей, включая исследователей, инженеров машинного обучения и т. Д.
- Обеспечить хорошую производительность из коробки.
- Легкое переключение между стратегиями.
Вы можете распространять обучение, используяtf.distribute.Strategyс API высокого уровня, как керасModel.fit, а такжеПользовательские тренировочные петли(и, в целом, любое вычисление с использованием Tensorflow).
В TensorFlow 2.x вы можете с нетерпением выполнять свои программы или на графике, используяtf.functionПолемtf.distribute.Strategyнамеревается поддержать оба этих режима исполнения, но лучше всего работает сtf.functionПолем Жесткий режим рекомендуется только для целей отладки и не поддерживается дляtf.distribute.TPUStrategyПолем Хотя обучение находится в центре внимания этого руководства, этот API также можно использовать для распределения оценки и прогнозирования на разных платформах.
Вы можете использоватьtf.distribute.StrategyС очень небольшим количеством изменений в вашем коде, потому что основные компоненты Tensorflow были изменены, чтобы стать стратегией. Это включает переменные, слои, модели, оптимизаторы, метрики, сводки и контрольные точки.
В этом руководстве вы узнаете о различных типах стратегий и о том, как вы можете использовать их в разных ситуациях. Чтобы узнать, как отладить проблемы с эффективностью, ознакомьтесь сОптимизировать производительность графического процессора TensorFlowгид.
Примечание:Для более глубокого понимания понятий, следите за глубоким презентацией-tf.distribute.StrategyПолем Это особенно рекомендуется, если вы планируете написать свой собственный учебный цикл.
Установите TensorFlow
import tensorflow as tf
2024-10-25 03:10:09.809713: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:477] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered
WARNING: All log messages before absl::InitializeLog() is called are written to STDERR
E0000 00:00:1729825809.832772 192915 cuda_dnn.cc:8310] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered
E0000 00:00:1729825809.839425 192915 cuda_blas.cc:1418] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered
Типы стратегий
tf.distribute.Strategyнамеревается охватить ряд вариантов использования вдоль разных осей. Некоторые из этих комбинаций в настоящее время поддерживаются, а другие будут добавлены в будущем. Некоторые из этих оси:
- Синхронно и асинхронное обучение:Это два распространенных способа распространения обучения с параллелизмом данных. В условиях синхронизации все работники обучают различные кусочки входных данных синхронизированы и агрегируют градиенты на каждом этапе. При асинхронном обучении все работники независимо обучаются входных данных и асинхронно обновляют переменные. Обычно синхронизированное обучение поддерживается с помощью All-Reduce и Async с помощью архитектуры сервера параметров.
- Аппаратная платформа:Возможно, вы захотите масштабировать обучение на несколько графических процессоров на одной машине или несколько машин в сети (с 0 или более графическими процессорами каждый) или на облачных TPU.
Чтобы поддержать эти варианты использования, TensorflowMirroredStrategyВTPUStrategyВMultiWorkerMirroredStrategyВParameterServerStrategyВCentralStorageStrategy, а также другие доступные стратегии. В следующем разделе объясняется, кто из них поддерживается, в каких сценариях в Tensorflow. Вот краткий обзор:
Обучение API |
|
|
|
|
|
|---|---|---|---|---|---|
Керас | Поддерживается | Поддерживается | Поддерживается | Экспериментальная поддержка | Экспериментальная поддержка |
Пользовательская учебная петля | Поддерживается | Поддерживается | Поддерживается | Экспериментальная поддержка | Экспериментальная поддержка |
Оценка API | Ограниченная поддержка | Не поддерживается | Ограниченная поддержка | Ограниченная поддержка | Ограниченная поддержка |
Примечание:
Предупреждение:Поддержка оценки ограничена. Основное обучение и оценка являются экспериментальными, а усовершенствованные функции - такие как каркас - не реализованы. Вы должны использовать кера или пользовательские тренировочные петли, если вариант использования не покрывается. Оценки не рекомендуются для нового кода. Оценки работаютv1.Session-Зывание кода, которое труднее писать правильно, и может вести себя неожиданно, особенно в сочетании с кодом TF 2. Оценки подпадают под наши
MirroredStrategy
tf.distribute.MirroredStrategyПоддерживает синхронное распределенное обучение на нескольких графических процессорах на одной машине. Он создает одну копию на устройство GPU. Каждая переменная в модели отражается во всех репликах. Вместе эти переменные образуют одну концептуальную переменную, называемуюMirroredVariableПолем Эти переменные хранятся синхронизированы друг с другом, применяя идентичные обновления.
Эффективные алгоритмы все-восстановительного использования используются для передачи переменных обновлений на устройствах. Все уменьшаются тензоры агрегатов по всем устройствам, добавляя их, и делает их доступными на каждом устройстве. Это слитый алгоритм, который очень эффективен и может значительно снизить накладные расходы синхронизации. Существует множество доступных алгоритмов и реализаций все-восстановительного, в зависимости от типа связи, доступной между устройствами. По умолчанию он использует библиотеку коллективной коммуникации NVIDIA (Nccl) как все-восстановительная реализация. Вы можете выбрать из нескольких других вариантов или написать свои собственные.
Вот самый простой способ созданияMirroredStrategy:
mirrored_strategy = tf.distribute.MirroredStrategy()
INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:CPU:0',)
W0000 00:00:1729825812.490898 192915 gpu_device.cc:2344] Cannot dlopen some GPU libraries. Please make sure the missing libraries mentioned above are installed properly if you would like to use GPU. Follow the guide at https://www.tensorflow.org/install/gpu for how to download and setup the required libraries for your platform.
Skipping registering GPU devices...
Это создастMirroredStrategyэкземпляр, который будет использовать все графические процессоры, которые видны для Tensorflow, и NCCL-в качестве перекрестной связи.
Если вы хотите использовать только некоторые графические процессоры на своей машине, вы можете сделать это так:
mirrored_strategy = tf.distribute.MirroredStrategy(devices=["/gpu:0", "/gpu:1"])
INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:GPU:0', '/job:localhost/replica:0/task:0/device:GPU:1')
Если вы хотите переопределить связь с поперечным устройством, вы можете сделать это, используяcross_device_opsаргумент, предоставляя экземплярtf.distribute.CrossDeviceOpsПолем В настоящее время,tf.distribute.HierarchicalCopyAllReduceиtf.distribute.ReductionToOneDeviceдва варианта, кроме какtf.distribute.NcclAllReduce, который по умолчанию.
mirrored_strategy = tf.distribute.MirroredStrategy(
cross_device_ops=tf.distribute.HierarchicalCopyAllReduce())
INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:CPU:0',)
Tpustrategy
tf.distribute.TPUStrategyПозволяет вам пропустить тренировку по тензодару на TensorflowТензорные обработки единицы (TPU)Полем TPU - это специализированные ASIC Google, предназначенные для значительного ускорения рабочих нагрузок машинного обучения. Они доступны наGoogle Colab,TPU Research Cloud, иОблачный TPUПолем
С точки зрения распределенной учебной архитектуры,TPUStrategyто же самоеMirroredStrategy- Он реализует синхронное распределенное обучение. TPU предоставляют свою собственную реализацию эффективных все-восстановительных и других коллективных операций по нескольким ядрам TPU, которые используются вTPUStrategyПолем
Вот как бы вы создали экземплярTPUStrategy:
Примечание:Чтобы запустить любой код TPU в Colab, вы должны выбрать TPU в качестве времени выполнения Colab. См
cluster_resolver = tf.distribute.cluster_resolver.TPUClusterResolver(
tpu=tpu_address)
tf.config.experimental_connect_to_cluster(cluster_resolver)
tf.tpu.experimental.initialize_tpu_system(cluster_resolver)
tpu_strategy = tf.distribute.TPUStrategy(cluster_resolver)
АTPUClusterResolverэкземпляр помогает найти TPU. В Колабах вам не нужно указывать какие -либо аргументы в него.
Если вы хотите использовать это для Cloud TPU:
- Вы должны указать имя вашего ресурса TPU в
tpuаргумент - Вы должны инициализировать систему TPU явно вначинатьпрограммы. Это требуется до того, как TPU можно использовать для вычисления. Инициализация системы TPU также уничтожает память TPU, поэтому важно сначала выполнить этот шаг, чтобы избежать потери состояния.
MultiporwermirRoredStrategy
tf.distribute.MultiWorkerMirroredStrategyочень похож наMirroredStrategyПолем Он реализует синхронную распределенную подготовку среди нескольких работников, каждый с потенциально несколькими графическими процессорами. Похоже наtf.distribute.MirroredStrategy, он создает копии всех переменных в модели на каждом устройстве для всех работников.
Вот самый простой способ созданияMultiWorkerMirroredStrategy:
strategy = tf.distribute.MultiWorkerMirroredStrategy()
WARNING:tensorflow:Collective ops is not configured at program startup. Some performance features may not be enabled.
INFO:tensorflow:Using MirroredStrategy with devices ('/device:CPU:0',)
INFO:tensorflow:Single-worker MultiWorkerMirroredStrategy with local_devices = ('/device:CPU:0',), communication = CommunicationImplementation.AUTO
MultiWorkerMirroredStrategyимеет две реализации для перекрестных коммуникаций.CommunicationImplementation.RINGявляетсяRPC-На основе и поддерживает как процессоры, так и графические процессоры.CommunicationImplementation.NCCLИспользует NCCL и обеспечивает современную производительность на графических процессорах, но не поддерживает процессоры.CollectiveCommunication.AUTOОпределяет выбор в Tensorflow. Вы можете указать их следующим образом:
communication_options = tf.distribute.experimental.CommunicationOptions(
implementation=tf.distribute.experimental.CommunicationImplementation.NCCL)
strategy = tf.distribute.MultiWorkerMirroredStrategy(
communication_options=communication_options)
WARNING:tensorflow:Collective ops is not configured at program startup. Some performance features may not be enabled.
INFO:tensorflow:Using MirroredStrategy with devices ('/device:CPU:0',)
WARNING:tensorflow:Enabled NCCL communication but no GPUs detected/specified.
INFO:tensorflow:Single-worker MultiWorkerMirroredStrategy with local_devices = ('/device:CPU:0',), communication = CommunicationImplementation.NCCL
Одним из ключевых различий в том, чтобы пройти обучение с несколькими работниками по сравнению с обучением с несколькими GPU, является установка нескольких работников. А'TF_CONFIG'Переменная среда является стандартным способом в TensorFlow, чтобы указать конфигурацию кластера каждому работнику, который является частью кластера. Узнайте больше вНастройка раздела TF_CONFIGэтого документа.
Для получения более подробной информации оMultiWorkerMirroredStrategy, рассмотрим следующие учебники:
- Обучение с несколькими работниками с Keras Model.fit
- Обучение с несколькими работниками с помощью индивидуальной тренировочной петли
ParameterSerVrategy
Обучение сервера параметров-это общий метод, параллельный данных для масштабирования обучения модели на нескольких машинах. Учебный кластер сервера параметров состоит из работников и параметров. Переменные создаются на серверах параметров, и они читаются и обновляются работниками на каждом шаге. ПроверьтеПараметр Сервер обучениеУчебное пособие для деталей.
В TensorFlow 2 обучение сервера параметров использует центральную архитектуру на основе координаторов черезtf.distribute.experimental.coordinator.ClusterCoordinatorсорт.
In this implementation, the workerиparameter serverЗадачи выполняютсяtf.distribute.ServerS, которые слушают задачи от координатора. Координатор создает ресурсы, отправляет учебные задачи, пишет контрольно -пропускные пункты и занимается сбоями задач.
В программировании, работающем на координаторе, вы будете использоватьParameterServerStrategyобъект для определения этапа обучения и использоватьClusterCoordinatorОтправлять этапы обучения на отдаленных работников. Вот самый простой способ их создать:
strategy = tf.distribute.experimental.ParameterServerStrategy(
tf.distribute.cluster_resolver.TFConfigClusterResolver(),
variable_partitioner=variable_partitioner)
coordinator = tf.distribute.experimental.coordinator.ClusterCoordinator(
strategy)
Чтобы узнать больше оParameterServerStrategy, проверьтеОбучение сервера параметров с Keras Model.fit и пользовательским петлей обученияУчебник.
Примечание:Вам нужно будет настроить'TF_CONFIG'переменная среды, если вы используетеTFConfigClusterResolverПолем Это похоже на'TF_CONFIG'вMultiWorkerMirroredStrategyно имеет дополнительные предостережения.
В TensorFlow 1,ParameterServerStrategyдоступен только с оценкой черезtf.compat.v1.distribute.experimental.ParameterServerStrategyсимвол.
Примечание:Эта стратегия естьexperimentalтак как в настоящее время находится в активном развитии.
Центральная стоимость
tf.distribute.experimental.CentralStorageStrategyТакже делает синхронное обучение. Переменные не отражаются, вместо этого они размещаются на процессоре, а операции реплицируются во всех локальных графических процессорах. Если есть только один графический процессор, все переменные и операции будут размещены на этом графическом процессоре.
Создать экземплярCentralStorageStrategyк:
central_storage_strategy = tf.distribute.experimental.CentralStorageStrategy()
INFO:tensorflow:ParameterServerStrategy (CentralStorageStrategy if you are using a single machine) with compute_devices = ['/job:localhost/replica:0/task:0/device:CPU:0'], variable_device = '/job:localhost/replica:0/task:0/device:CPU:0'
Это создастCentralStorageStrategyэкземпляр, который будет использовать все видимые графические процессоры и процессор. Обновление до переменных на репликах будет агрегировано, прежде чем будет применено к переменным.
Примечание:Эта стратегия естьexperimental, поскольку в настоящее время это работа.
Другие стратегии
В дополнение к вышеуказанным стратегиям, есть две другие стратегии, которые могут быть полезны для прототипирования и отладки при использованииtf.distributeАпис
Стратегия по умолчанию
Стратегия по умолчанию - это стратегия распределения, которая присутствует, когда нет явной стратегии распределения. Он реализуетtf.distribute.Strategyинтерфейс, но проходит через проходной и не обеспечивает фактического распределения. Например,Strategy.run(fn)просто позвонитfnПолем Код, написанный с использованием этой стратегии, должен вести себя точно так же, как код, написанный без какой -либо стратегии. Вы можете думать об этом как о стратегии «нетоопереда».
Стратегия по умолчанию - это синглтон - и нельзя создать больше случаев. Его можно получить с помощьюtf.distribute.get_strategyЗа пределами любой явной стратегии (тот же API, который можно использовать для получения текущей стратегии внутри явной стратегии).
default_strategy = tf.distribute.get_strategy()
Эта стратегия служит двум основным целям:
- Это позволяет безоговорочно код библиотеки с учетом распределения. Например, в
tf.keras.optimizersВы можете использоватьtf.distribute.get_strategyи использовать эту стратегию для снижения градиентов - он всегда будет возвращать объект стратегии, на котором вы можете вызватьStrategy.reduceAPI.
# In optimizer or other library code
# Get currently active strategy
strategy = tf.distribute.get_strategy()
strategy.reduce("SUM", 1., axis=None) # reduce some values
1.0
- Подобно коду библиотеки, его можно использовать для написания программ конечных пользователей для работы с стратегией распределения и без него, не требуя условной логики. Вот образец фрагмента кода, иллюстрирующий это:
if tf.config.list_physical_devices('GPU'):
strategy = tf.distribute.MirroredStrategy()
else: # Use the Default Strategy
strategy = tf.distribute.get_strategy()
with strategy.scope():
# Do something interesting
print(tf.Variable(1.))
<tf.Variable 'Variable:0' shape=() dtype=float32, numpy=1.0>
OnedeviceStrategy
tf.distribute.OneDeviceStrategyявляется стратегией для размещения всех переменных и вычислений на одном указанном устройстве.
strategy = tf.distribute.OneDeviceStrategy(device="/gpu:0")
Эта стратегия отличается от стратегии по умолчанию несколькими способами. В стратегии по умолчанию логика размещения переменных остается неизменной по сравнению с запуском TensorFlow без какой -либо стратегии распределения. Но при использованииOneDeviceStrategy, все переменные, созданные в его области, явно размещаются на указанном устройстве. Более того, любые функции, вызванные черезOneDeviceStrategy.runтакже будет размещен на указанном устройстве.
Ввод, распространяемый через эту стратегию, будет предварительно выбран на указанное устройство. В стратегии по умолчанию нет входного распределения.
Подобно стратегии по умолчанию, эта стратегия также может быть использована для тестирования вашего кода перед переходом на другие стратегии, которые фактически распространяются на несколько устройств/машин. Это будет использовать стратегию распределения несколько больше, чем стратегия по умолчанию, но не в полной мере использования, например,, например,MirroredStrategyилиTPUStrategyПолем Если вам нужен код, который ведет себя так, как будто нет стратегии, используйте стратегию по умолчанию.
До сих пор вы узнали о разных стратегиях и о том, как вы можете их создавать. В следующих нескольких разделах показаны различные способы использования их для распространения обучения.
Используйте tf.distribute.strategy с keras model.fit
tf.distribute.Strategyинтегрируется вtf.keras, который является реализацией TensorFlowСпецификация API KerasПолемtf.kerasэто API высокого уровня для создания и обучения моделей. Интегрируясь вtf.kerasБэкэнд, для вас легко распространять свою тренировку, написанную в рамках тренировок КерасаИспользование model.fitПолем
Вот что вам нужно изменить в своем коде:
- Создать экземпляр соответствующего
tf.distribute.StrategyПолем - Переместите создание модели, оптимизатора и метрик керас
strategy.scopeПолем Таким образом, код в моделиcall()Вtrain_step(), иtest_step()Все методы будут распределены и выполнены на акселераторе.
Стратегии распределения TensorFlow поддерживают все типы моделей кераса -ПоследовательныйВФункциональный, иподкласс
Вот фрагмент кода, чтобы сделать это для очень простой модели кераса с однимDenseслой:
mirrored_strategy = tf.distribute.MirroredStrategy()
with mirrored_strategy.scope():
model = tf.keras.Sequential([
tf.keras.layers.Dense(1, input_shape=(1,),
kernel_regularizer=tf.keras.regularizers.L2(1e-4))])
model.compile(loss='mse', optimizer='sgd')
INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:CPU:0',)
/tmpfs/src/tf_docs_env/lib/python3.9/site-packages/keras/src/layers/core/dense.py:87: UserWarning: Do not pass an `input_shape`/`input_dim` argument to a layer. When using Sequential models, prefer using an `Input(shape)` object as the first layer in the model instead.
super().__init__(activity_regularizer=activity_regularizer, **kwargs)
Этот пример используетMirroredStrategyТак вы можете запустить это на машине с несколькими графическими процессорами.strategy.scope()указывает на кера, какую стратегию использовать для распространения обучения. Создание моделей/оптимизаторов/метрик внутри этой области позволяет создавать распределенные переменные вместо обычных переменных. После того, как это будет настроено, вы можете установить свою модель, как обычно.MirroredStrategyПозаботится о копировании обучения модели по доступным графическим процессорам, агрегирующим градиентам и многому другому.
dataset = tf.data.Dataset.from_tensors(([1.], [1.])).repeat(100).batch(10)
model.fit(dataset, epochs=2)
model.evaluate(dataset)
2024-10-25 03:10:12.686928: W tensorflow/core/framework/dataset.cc:993] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.
Epoch 1/2
1/10 ━━━━━━━━━━━━━━━━━━━━ 2s 287ms/step - loss: 0.649210/10 ━━━━━━━━━━━━━━━━━━━━ 0s 2ms/step - loss: 0.5412
Epoch 2/2
1/10 ━━━━━━━━━━━━━━━━━━━━ 0s 61ms/step - loss: 0.286910/10 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 0.2392
1/10 ━━━━━━━━━━━━━━━━━━━━ 1s 168ms/step - loss: 0.126810/10 ━━━━━━━━━━━━━━━━━━━━ 0s 2ms/step - loss: 0.1268
0.1268472820520401
Здесь аtf.data.DatasetОбеспечивает обучение и входные данные. Вы также можете использовать массивы Numpy:
import numpy as np
inputs, targets = np.ones((100, 1)), np.ones((100, 1))
model.fit(inputs, targets, epochs=2, batch_size=10)
Epoch 1/2
2/10 ━━━━━━━━━━━━━━━━━━━━ 0s 2ms/step - loss: 0.124410/10 ━━━━━━━━━━━━━━━━━━━━ 0s 2ms/step - loss: 0.1058
Epoch 2/2
3/10 ━━━━━━━━━━━━━━━━━━━━ 0s 2ms/step - loss: 0.0539 10/10 ━━━━━━━━━━━━━━━━━━━━ 0s 2ms/step - loss: 0.0468
<keras.src.callbacks.history.History at 0x7fab904bcfa0>
В обоих случаях - сDatasetили Numpy - какая партия данного входа в равной степени делится между несколькими репликами. Например, если вы используетеMirroredStrategyС 2 графическими процессорами каждая партия размера 10 будет разделена между 2 графическими процессорами, причем каждый получает 5 входных примеров на каждом этапе. Каждая эпоха будет тогда тренироваться быстрее, когда вы добавляете больше графических процессоров. Как правило, вы хотели бы увеличить размер партии, добавляя больше ускорителей, чтобы эффективно использовать дополнительную вычислительную мощность. Вам также нужно будет повторно настраивать свой уровень обучения, в зависимости от модели. Вы можете использоватьstrategy.num_replicas_in_syncЧтобы получить количество копий.
mirrored_strategy.num_replicas_in_sync
1
# Compute a global batch size using a number of replicas.
BATCH_SIZE_PER_REPLICA = 5
global_batch_size = (BATCH_SIZE_PER_REPLICA *
mirrored_strategy.num_replicas_in_sync)
dataset = tf.data.Dataset.from_tensors(([1.], [1.])).repeat(100)
dataset = dataset.batch(global_batch_size)
LEARNING_RATES_BY_BATCH_SIZE = {5: 0.1, 10: 0.15, 20:0.175}
learning_rate = LEARNING_RATES_BY_BATCH_SIZE[global_batch_size]
Что сейчас поддерживается?
Обучение API |
|
|
|
|
|
|---|---|---|---|---|---|
Керас | Поддерживается | Поддерживается | Поддерживается | Экспериментальная поддержка | Экспериментальная поддержка |
Примеры и учебные пособия
Вот список учебных пособий и примеров, которые иллюстрируют вышеуказанную интеграцию с керамиModel.fit:
- Учебник: Обучение с
Model.fitиMirroredStrategyПолем - Учебник: Обучение с
Model.fitиMultiWorkerMirroredStrategyПолем - Гид: Содержит пример использования
Model.fitиTPUStrategyПолем - Учебник: Обучение сервера параметров с
Model.fitиParameterServerStrategyПолем - Учебник: Тонкая настройка Берта для многих задач из теста клея с
Model.fitиTPUStrategyПолем - Tensorflow Model Gardenрепозиторийсодержащий коллекции современных моделей, реализованных с использованием различных стратегий.
Первоначально опубликовано на
Оригинал