Horovod es un framework de entrenamiento de aprendizaje profundo distribuido de código abierto desarrollado por Uber. Su objetivo es hacer que el entrenamiento de aprendizaje profundo distribuido sea más simple, rápido y fácil de usar. Horovod es compatible con frameworks de aprendizaje profundo populares como TensorFlow, Keras, PyTorch y Apache MXNet.
Horovod es compatible principalmente con los siguientes frameworks de aprendizaje profundo:
Horovod admite los siguientes mecanismos de comunicación:
El proceso de instalación de Horovod depende del framework de aprendizaje profundo y el mecanismo de comunicación que esté utilizando. Por lo general, primero debe instalar MPI o NCCL y luego instalar Horovod usando pip.
Por ejemplo, para instalar Horovod usando pip y admitir TensorFlow y NCCL, puede ejecutar el siguiente comando:
pip install horovod[tensorflow,gpu]
Consulte la documentación oficial de Horovod para obtener instrucciones de instalación más detalladas: https://github.com/horovod/horovod
El uso de Horovod para el entrenamiento distribuido generalmente implica los siguientes pasos:
horovod.init() para inicializar Horovod.DistributedOptimizer: Utilice el DistributedOptimizer proporcionado por Horovod para envolver el optimizador original.El siguiente es un ejemplo simple de cómo usar Horovod para el entrenamiento distribuido de TensorFlow:
import tensorflow as tf
import horovod.tensorflow as hvd
# 1. Inicializar Horovod
hvd.init()
# 2. Fijar la GPU
gpus = tf.config.experimental.list_physical_devices('GPU')
for gpu in gpus:
tf.config.experimental.set_memory_growth(gpu, True)
if gpus:
tf.config.experimental.set_visible_devices(gpus[hvd.local_rank()], 'GPU')
# 3. Cargar el conjunto de datos
(mnist_images, mnist_labels), _ = tf.keras.datasets.mnist.load_data()
dataset = tf.data.Dataset.from_tensor_slices(
(tf.cast(mnist_images[..., None] / 255.0, tf.float32),
tf.cast(mnist_labels, tf.int64)))
dataset = dataset.repeat().shuffle(10000).batch(128)
# 4. Construir el modelo
model = tf.keras.models.Sequential([
tf.keras.layers.Conv2D(32, [3, 3], activation='relu'),
tf.keras.layers.Conv2D(64, [3, 3], activation='relu'),
tf.keras.layers.MaxPooling2D(pool_size=(2, 2)),
tf.keras.layers.Dropout(0.25),
tf.keras.layers.Flatten(),
tf.keras.layers.Dense(128, activation='relu'),
tf.keras.layers.Dropout(0.5),
tf.keras.layers.Dense(10, activation='softmax')
])
# 5. Definir el optimizador
opt = tf.keras.optimizers.Adam(0.001 * hvd.size()) # Escalar la tasa de aprendizaje
# 6. Usar DistributedOptimizer
opt = hvd.DistributedOptimizer(opt)
# 7. Definir la función de pérdida y las métricas
loss_fn = tf.keras.losses.SparseCategoricalCrossentropy()
metric = tf.keras.metrics.SparseCategoricalAccuracy()
# 8. Definir el paso de entrenamiento
@tf.function
def train_step(images, labels):
with tf.GradientTape() as tape:
probs = model(images, training=True)
loss = loss_fn(labels, probs)
tape = hvd.DistributedGradientTape(tape)
gradients = tape.gradient(loss, model.trainable_variables)
opt.apply_gradients(zip(gradients, model.trainable_variables))
metric.update_state(labels, probs)
return loss
# 9. Difundir las variables iniciales
@tf.function
def initialize_vars():
if hvd.rank() == 0:
model(tf.zeros((1, 28, 28, 1)))
hvd.broadcast_variables(model.variables, root_rank=0)
hvd.broadcast_variables(opt.variables(), root_rank=0)
initialize_vars()
# 10. Bucle de entrenamiento
for batch, (images, labels) in enumerate(dataset.take(10000 // hvd.size())):
loss = train_step(images, labels)
if batch % 10 == 0 and hvd.rank() == 0:
print('batch: %d, loss: %.4f, accuracy: %.2f' % (batch, loss, metric.result()))
Horovod es un potente framework de aprendizaje profundo distribuido que puede ayudarle a entrenar modelos de aprendizaje profundo a gran escala de forma más fácil y rápida. Al aprovechar múltiples nodos GPU o CPU, Horovod puede reducir significativamente el tiempo de entrenamiento y mejorar la precisión del modelo.