Horovod ist ein Open-Source-Framework für verteiltes Deep-Learning-Training, das von Uber entwickelt wurde. Sein Ziel ist es, das verteilte Deep-Learning-Training einfacher, schneller und benutzerfreundlicher zu gestalten. Horovod unterstützt beliebte Deep-Learning-Frameworks wie TensorFlow, Keras, PyTorch und Apache MXNet.
Horovod unterstützt hauptsächlich die folgenden Deep-Learning-Frameworks:
Horovod unterstützt die folgenden Kommunikationsmechanismen:
Der Installationsprozess von Horovod hängt von dem verwendeten Deep-Learning-Framework und dem Kommunikationsmechanismus ab. In der Regel müssen Sie zuerst MPI oder NCCL installieren und dann Horovod mit pip installieren.
Um beispielsweise Horovod mit pip zu installieren und TensorFlow und NCCL zu unterstützen, können Sie den folgenden Befehl ausführen:
pip install horovod[tensorflow,gpu]
Detailliertere Installationsanweisungen finden Sie in der offiziellen Horovod-Dokumentation: https://github.com/horovod/horovod
Die Verwendung von Horovod für verteiltes Training umfasst in der Regel die folgenden Schritte:
horovod.init() auf, um Horovod zu initialisieren.DistributedOptimizer verwenden: Verwenden Sie den von Horovod bereitgestellten DistributedOptimizer, um den ursprünglichen Optimierer zu umschließen.Im Folgenden finden Sie ein einfaches Beispiel für die Verwendung von Horovod für verteiltes TensorFlow-Training:
import tensorflow as tf
import horovod.tensorflow as hvd
# 1. Horovod initialisieren
hvd.init()
# 2. GPU fixieren
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. Datensatz laden
(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. Modell erstellen
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. Optimierer definieren
opt = tf.keras.optimizers.Adam(0.001 * hvd.size()) # Lernrate skalieren
# 6. DistributedOptimizer verwenden
opt = hvd.DistributedOptimizer(opt)
# 7. Verlustfunktion und Metriken definieren
loss_fn = tf.keras.losses.SparseCategoricalCrossentropy()
metric = tf.keras.metrics.SparseCategoricalAccuracy()
# 8. Trainingsschritt definieren
@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. Anfangsvariablen übertragen
@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. Trainingsschleife
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 ist ein leistungsstarkes Framework für verteiltes Deep Learning, mit dem Sie umfangreiche Deep-Learning-Modelle einfacher und schneller trainieren können. Durch die Nutzung mehrerer GPU- oder CPU-Knoten kann Horovod die Trainingszeit erheblich verkürzen und die Genauigkeit des Modells verbessern.