分布式訓(xùn)練框架Horovod初步學(xué)習(xí)
簡介
Horovod 是 TensorFlow、Keras、PyTorch 和 Apache MXNet 的分布式深度學(xué)習(xí)訓(xùn)練框架。Horovod 的目標(biāo)是使分布式深度學(xué)習(xí)快速且易于使用。
簡單來說就是為這些框架提供分布式支持，比如有一個需求，由于數(shù)據(jù)量過大（千萬級），想要在128個GPU上運(yùn)行，以便于快速得到結(jié)果，這時候就可以用horovod，只需要簡單改不多的代碼，就可以將原來在單GPU上跑的模型，并行跑在128個GPU上。
安裝
安裝CMake：https://cmake.org/install/
如果您安裝了 PyPI 中的 TensorFlow，請確保Tensorflow已安裝 或安裝了
g++-4.8.5``g++-4.9如果您從PyPI：https://pypi.org/project/torch 安裝了 PyTorch，請確保已安裝了
g++-4.9如果已安裝來自Conda 的任一包，請確保已安裝 Conda 中的
gxx_linux-64包安裝 pip
horovod在 CPU 上運(yùn)行：
$?pip?install?horovod
要使用 NCCL 在 GPU 上運(yùn)行：
$?HOROVOD_GPU_OPERATIONS=NCCL?pip?install?horovod
有關(guān)使用 GPU 支持安裝 Horovod 的更多詳細(xì)信息，請閱讀GPU 上的 Horovod。
名詞解釋
rank：
表示進(jìn)程序號，用于進(jìn)程間通訊，表征進(jìn)程優(yōu)先級。rank = 0 的主機(jī)為 master 節(jié)點(diǎn)。
local_rank：
進(jìn)程內(nèi)，GPU 編號，非顯式參數(shù)，由 torch.distributed.launch 內(nèi)部指定。比方說， rank = 3，local_rank = 0 表示第 3 個進(jìn)程內(nèi)的第 1 塊 GPU。
allreduce：
累加所有數(shù)據(jù)，并同步到所有節(jié)點(diǎn)的操作
allgather:
收集所有數(shù)據(jù)，并同步到所有節(jié)點(diǎn)的操作，完成后每個節(jié)點(diǎn)都包含所有節(jié)點(diǎn)的數(shù)據(jù)，并且這些數(shù)據(jù)單獨(dú)存在
broadcast:
將數(shù)據(jù)（需要由根節(jié)點(diǎn)確認(rèn)）從一個節(jié)點(diǎn)傳播到其他所有節(jié)點(diǎn)的操作
使用指南
添加以下步驟：
hvd.init()用于初始化horovod將每個GPU固定給單個進(jìn)程處理，以避免資源競爭。
每個進(jìn)程設(shè)置為一個GPU，通過設(shè)置local rank參數(shù)，服務(wù)器上的第一個進(jìn)程將分配第一個 GPU，第二個進(jìn)程將分配第二個 GPU，等等
???if?torch.cuda.is_available():
???????torch.cuda.set_device(hvd.local_rank())
根據(jù)線程個數(shù)縮放學(xué)習(xí)率
將優(yōu)化器包裝在
hvd.DistributedOptimizer中。分布式優(yōu)化器將梯度計(jì)算委托給原始優(yōu)化器，使用allduce或allgather來平均梯度，然后應(yīng)用這些平均梯度。
將初始變量的狀態(tài)從rank 0廣播至其他進(jìn)程。需要保證初始化的一致性。
修改權(quán)重保存部分源碼，只通過worker 0保存權(quán)重，防止由于多線程操作導(dǎo)致的沖突。
Tensorflow + Horovod
這里Tensorflow是1.x版本，更加穩(wěn)定一些，以下是一個修改示例。
import?tensorflow?as?tf
import?horovod.tensorflow?as?hvd
#?Initialize?Horovod
hvd.init()
#?Pin?GPU?to?be?used?to?process?local?rank?(one?GPU?per?process)
config?=?tf.ConfigProto()
config.gpu_options.visible_device_list?=?str(hvd.local_rank())
#?Build?model...
loss?=?...
opt?=?tf.train.AdagradOptimizer(0.01?*?hvd.size())
#?Add?Horovod?Distributed?Optimizer
opt?=?hvd.DistributedOptimizer(opt)
#?Add?hook?to?broadcast?variables?from?rank?0?to?all?other?processes?during
#?initialization.
hooks?=?[hvd.BroadcastGlobalVariablesHook(0)]
#?Make?training?operation
train_op?=?opt.minimize(loss)
#?Save?checkpoints?only?on?worker?0?to?prevent?other?workers?from?corrupting?them.
checkpoint_dir?=?'/tmp/train_logs'?if?hvd.rank()?==?0?else?None
#?The?MonitoredTrainingSession?takes?care?of?session?initialization,
#?restoring?from?a?checkpoint,?saving?to?a?checkpoint,?and?closing?when?done
#?or?an?error?occurs.
with?tf.train.MonitoredTrainingSession(checkpoint_dir=checkpoint_dir,
???????????????????????????????????????config=config,
???????????????????????????????????????hooks=hooks)?as?mon_sess:
??while?not?mon_sess.should_stop():
????#?Perform?synchronous?training.
????mon_sess.run(train_op)
完整代碼如下：
import?os
import?errno
import?tensorflow?as?tf
import?horovod.tensorflow?as?hvd
import?numpy?as?np
import?argparse
from?tensorflow?import?keras
layers?=?tf.layers
tf.logging.set_verbosity(tf.logging.INFO)
#?Training?settings
parser?=?argparse.ArgumentParser(description='Tensorflow?MNIST?Example')
parser.add_argument('--use-adasum',?action='store_true',?default=False,
????????????????????help='use?adasum?algorithm?to?do?reduction')
parser.add_argument('--gradient-predivide-factor',?type=float,?default=1.0,
????????????????????help='apply?gradient?predivide?factor?in?optimizer?(default:?1.0)')
args?=?parser.parse_args()
def?conv_model(feature,?target,?mode):
????"""2-layer?convolution?model."""
????#?Convert?the?target?to?a?one-hot?tensor?of?shape?(batch_size,?10)?and
????#?with?a?on-value?of?1?for?each?one-hot?vector?of?length?10.
????target?=?tf.one_hot(tf.cast(target,?tf.int32),?10,?1,?0)
????#?Reshape?feature?to?4d?tensor?with?2nd?and?3rd?dimensions?being
????#?image?width?and?height?final?dimension?being?the?number?of?color?channels.
????feature?=?tf.reshape(feature,?[-1,?28,?28,?1])
????#?First?conv?layer?will?compute?32?features?for?each?5x5?patch
????with?tf.variable_scope('conv_layer1'):
????????h_conv1?=?layers.conv2d(feature,?32,?kernel_size=[5,?5],
????????????????????????????????activation=tf.nn.relu,?padding="SAME")
????????h_pool1?=?tf.nn.max_pool(
????????????h_conv1,?ksize=[1,?2,?2,?1],?strides=[1,?2,?2,?1],?padding='SAME')
????#?Second?conv?layer?will?compute?64?features?for?each?5x5?patch.
????with?tf.variable_scope('conv_layer2'):
????????h_conv2?=?layers.conv2d(h_pool1,?64,?kernel_size=[5,?5],
????????????????????????????????activation=tf.nn.relu,?padding="SAME")
????????h_pool2?=?tf.nn.max_pool(
????????????h_conv2,?ksize=[1,?2,?2,?1],?strides=[1,?2,?2,?1],?padding='SAME')
????????#?reshape?tensor?into?a?batch?of?vectors
????????h_pool2_flat?=?tf.reshape(h_pool2,?[-1,?7?*?7?*?64])
????#?Densely?connected?layer?with?1024?neurons.
????h_fc1?=?layers.dropout(
????????layers.dense(h_pool2_flat,?1024,?activation=tf.nn.relu),
????????rate=0.5,?training=mode?==?tf.estimator.ModeKeys.TRAIN)
????#?Compute?logits?(1?per?class)?and?compute?loss.
????logits?=?layers.dense(h_fc1,?10,?activation=None)
????loss?=?tf.losses.softmax_cross_entropy(target,?logits)
????return?tf.argmax(logits,?1),?loss
def?train_input_generator(x_train,?y_train,?batch_size=64):
????assert?len(x_train)?==?len(y_train)
????while?True:
????????p?=?np.random.permutation(len(x_train))
????????x_train,?y_train?=?x_train[p],?y_train[p]
????????index?=?0
????????while?index?<=?len(x_train)?-?batch_size:
????????????yield?x_train[index:index?+?batch_size],?\
??????????????????y_train[index:index?+?batch_size],
????????????index?+=?batch_size
def?main(_):
????#?Horovod:?initialize?Horovod.
????hvd.init()
????#?Keras?automatically?creates?a?cache?directory?in?~/.keras/datasets?for
????#?storing?the?downloaded?MNIST?data.?This?creates?a?race
????#?condition?among?the?workers?that?share?the?same?filesystem.?If?the
????#?directory?already?exists?by?the?time?this?worker?gets?around?to?creating
????#?it,?ignore?the?resulting?exception?and?continue.
????cache_dir?=?os.path.join(os.path.expanduser('~'),?'.keras',?'datasets')
????if?not?os.path.exists(cache_dir):
????????try:
????????????os.mkdir(cache_dir)
????????except?OSError?as?e:
????????????if?e.errno?==?errno.EEXIST?and?os.path.isdir(cache_dir):
????????????????pass
????????????else:
????????????????raise
????#?Download?and?load?MNIST?dataset.
????(x_train,?y_train),?(x_test,?y_test)?=?\
????????keras.datasets.mnist.load_data('MNIST-data-%d'?%?hvd.rank())
????#?The?shape?of?downloaded?data?is?(-1,?28,?28),?hence?we?need?to?reshape?it
????#?into?(-1,?784)?to?feed?into?our?network.?Also,?need?to?normalize?the
????#?features?between?0?and?1.
????x_train?=?np.reshape(x_train,?(-1,?784))?/?255.0
????x_test?=?np.reshape(x_test,?(-1,?784))?/?255.0
????#?Build?model...
????with?tf.name_scope('input'):
????????image?=?tf.placeholder(tf.float32,?[None,?784],?name='image')
????????label?=?tf.placeholder(tf.float32,?[None],?name='label')
????predict,?loss?=?conv_model(image,?label,?tf.estimator.ModeKeys.TRAIN)
????lr_scaler?=?hvd.size()
????#?By?default,?Adasum?doesn't?need?scaling?when?increasing?batch?size.?If?used?with?NCCL,
????#?scale?lr?by?local_size
????if?args.use_adasum:
????????lr_scaler?=?hvd.local_size()?if?hvd.nccl_built()?else?1
????#?Horovod:?adjust?learning?rate?based?on?lr_scaler.
????opt?=?tf.train.AdamOptimizer(0.001?*?lr_scaler)
????#?Horovod:?add?Horovod?Distributed?Optimizer.
????opt?=?hvd.DistributedOptimizer(opt,?op=hvd.Adasum?if?args.use_adasum?else?hvd.Average,
???????????????????????????????????gradient_predivide_factor=args.gradient_predivide_factor)
????global_step?=?tf.train.get_or_create_global_step()
????train_op?=?opt.minimize(loss,?global_step=global_step)
????hooks?=?[
????????#?Horovod:?BroadcastGlobalVariablesHook?broadcasts?initial?variable?states
????????#?from?rank?0?to?all?other?processes.?This?is?necessary?to?ensure?consistent
????????#?initialization?of?all?workers?when?training?is?started?with?random?weights
????????#?or?restored?from?a?checkpoint.
????????hvd.BroadcastGlobalVariablesHook(0),
????????#?Horovod:?adjust?number?of?steps?based?on?number?of?GPUs.
????????tf.train.StopAtStepHook(last_step=20000?//?hvd.size()),
????????tf.train.LoggingTensorHook(tensors={'step':?global_step,?'loss':?loss},
???????????????????????????????????every_n_iter=10),
????]
????#?Horovod:?pin?GPU?to?be?used?to?process?local?rank?(one?GPU?per?process)
????config?=?tf.ConfigProto()
????config.gpu_options.allow_growth?=?True
????config.gpu_options.visible_device_list?=?str(hvd.local_rank())
????#?Horovod:?save?checkpoints?only?on?worker?0?to?prevent?other?workers?from
????#?corrupting?them.
????checkpoint_dir?=?'./checkpoints'?if?hvd.rank()?==?0?else?None
????training_batch_generator?=?train_input_generator(x_train,
?????????????????????????????????????????????????????y_train,?batch_size=100)
????#?The?MonitoredTrainingSession?takes?care?of?session?initialization,
????#?restoring?from?a?checkpoint,?saving?to?a?checkpoint,?and?closing?when?done
????#?or?an?error?occurs.
????with?tf.train.MonitoredTrainingSession(checkpoint_dir=checkpoint_dir,
???????????????????????????????????????????hooks=hooks,
???????????????????????????????????????????config=config)?as?mon_sess:
????????while?not?mon_sess.should_stop():
????????????#?Run?a?training?step?synchronously.
????????????image_,?label_?=?next(training_batch_generator)
????????????mon_sess.run(train_op,?feed_dict={image:?image_,?label:?label_})
if?__name__?==?"__main__":
????tf.app.run()
PyTorch + Horovod
運(yùn)行
hvd.init()將每個 GPU 固定到單個進(jìn)程。
每個進(jìn)程的典型設(shè)置為一個 GPU，請將此設(shè)置為本地排名。服務(wù)器上的第一個進(jìn)程將分配第一個 GPU，第二個進(jìn)程將分配第二個 GPU，等等。
if?torch.cuda.is_available():
????torch.cuda.set_device(hvd.local_rank())按線程數(shù)縮放學(xué)習(xí)率。
同步分布式培訓(xùn)中的有效批次大小按工作人員數(shù)量進(jìn)行縮放。學(xué)習(xí)率的提高彌補(bǔ)了批次大小的增加。
將優(yōu)化器包裝在
hvd.DistributedOptimizer分布式優(yōu)化器將梯度計(jì)算委托給原始優(yōu)化器，使用allduce或all 聚集來平均梯度，然后應(yīng)用這些平均梯度。將初始變量狀態(tài)從排名 0 廣播到所有其他進(jìn)程：
hvd.broadcast_parameters(model.state_dict(),?root_rank=0)
hvd.broadcast_optimizer_state(optimizer,?root_rank=0)
在使用隨機(jī)權(quán)重開始訓(xùn)練或從檢查點(diǎn)恢復(fù)訓(xùn)練時，這對于確保所有工作人員的一致初始化是必要的。
修改代碼以僅保存工作線程 0 上的檢查點(diǎn)，以防止其他工作人員損壞它們。
通過使用 保護(hù)模型檢查點(diǎn)代碼，實(shí)現(xiàn)此目的。hvd.rank() != 0
import?torch
import?horovod.torch?as?hvd
#?Initialize?Horovod
hvd.init()
#?Pin?GPU?to?be?used?to?process?local?rank?(one?GPU?per?process)
torch.cuda.set_device(hvd.local_rank())
#?Define?dataset...
train_dataset?=?...
#?Partition?dataset?among?workers?using?DistributedSampler
train_sampler?=?torch.utils.data.distributed.DistributedSampler(
????train_dataset,?num_replicas=hvd.size(),?rank=hvd.rank())
train_loader?=?torch.utils.data.DataLoader(train_dataset,?batch_size=...,?sampler=train_sampler)
#?Build?model...
model?=?...
model.cuda()
optimizer?=?optim.SGD(model.parameters())
#?Add?Horovod?Distributed?Optimizer
optimizer?=?hvd.DistributedOptimizer(optimizer,?named_parameters=model.named_parameters())
#?Broadcast?parameters?from?rank?0?to?all?other?processes.
hvd.broadcast_parameters(model.state_dict(),?root_rank=0)
for?epoch?in?range(100):
???for?batch_idx,?(data,?target)?in?enumerate(train_loader):
???????optimizer.zero_grad()
???????output?=?model(data)
???????loss?=?F.nll_loss(output,?target)
???????loss.backward()
???????optimizer.step()
???????if?batch_idx?%?args.log_interval?==?0:
???????????print('Train?Epoch:?{}?[{}/{}]\tLoss:?{}'.format(
???????????????epoch,?batch_idx?*?len(data),?len(train_sampler),?loss.item()))
完整代碼：
import?argparse
import?torch.multiprocessing?as?mp
import?torch.nn?as?nn
import?torch.nn.functional?as?F
import?torch.optim?as?optim
from?torchvision?import?datasets,?transforms
import?torch.utils.data.distributed
import?horovod.torch?as?hvd
#?Training?settings
parser?=?argparse.ArgumentParser(description='PyTorch?MNIST?Example')
parser.add_argument('--batch-size',?type=int,?default=64,?metavar='N',
????????????????????help='input?batch?size?for?training?(default:?64)')
parser.add_argument('--test-batch-size',?type=int,?default=1000,?metavar='N',
????????????????????help='input?batch?size?for?testing?(default:?1000)')
parser.add_argument('--epochs',?type=int,?default=10,?metavar='N',
????????????????????help='number?of?epochs?to?train?(default:?10)')
parser.add_argument('--lr',?type=float,?default=0.01,?metavar='LR',
????????????????????help='learning?rate?(default:?0.01)')
parser.add_argument('--momentum',?type=float,?default=0.5,?metavar='M',
????????????????????help='SGD?momentum?(default:?0.5)')
parser.add_argument('--no-cuda',?action='store_true',?default=False,
????????????????????help='disables?CUDA?training')
parser.add_argument('--seed',?type=int,?default=42,?metavar='S',
????????????????????help='random?seed?(default:?42)')
parser.add_argument('--log-interval',?type=int,?default=10,?metavar='N',
????????????????????help='how?many?batches?to?wait?before?logging?training?status')
parser.add_argument('--fp16-allreduce',?action='store_true',?default=False,
????????????????????help='use?fp16?compression?during?allreduce')
parser.add_argument('--use-adasum',?action='store_true',?default=False,
????????????????????help='use?adasum?algorithm?to?do?reduction')
parser.add_argument('--gradient-predivide-factor',?type=float,?default=1.0,
????????????????????help='apply?gradient?predivide?factor?in?optimizer?(default:?1.0)')
class?Net(nn.Module):
????def?__init__(self):
????????super(Net,?self).__init__()
????????self.conv1?=?nn.Conv2d(1,?10,?kernel_size=5)
????????self.conv2?=?nn.Conv2d(10,?20,?kernel_size=5)
????????self.conv2_drop?=?nn.Dropout2d()
????????self.fc1?=?nn.Linear(320,?50)
????????self.fc2?=?nn.Linear(50,?10)
????def?forward(self,?x):
????????x?=?F.relu(F.max_pool2d(self.conv1(x),?2))
????????x?=?F.relu(F.max_pool2d(self.conv2_drop(self.conv2(x)),?2))
????????x?=?x.view(-1,?320)
????????x?=?F.relu(self.fc1(x))
????????x?=?F.dropout(x,?training=self.training)
????????x?=?self.fc2(x)
????????return?F.log_softmax(x)
def?train(epoch):
????model.train()
????#?Horovod:?set?epoch?to?sampler?for?shuffling.
????train_sampler.set_epoch(epoch)
????for?batch_idx,?(data,?target)?in?enumerate(train_loader):
????????if?args.cuda:
????????????data,?target?=?data.cuda(),?target.cuda()
????????optimizer.zero_grad()
????????output?=?model(data)
????????loss?=?F.nll_loss(output,?target)
????????loss.backward()
????????optimizer.step()
????????if?batch_idx?%?args.log_interval?==?0:
????????????#?Horovod:?use?train_sampler?to?determine?the?number?of?examples?in
????????????#?this?worker's?partition.
????????????print('Train?Epoch:?{}?[{}/{}?({:.0f}%)]\tLoss:?{:.6f}'.format(
????????????????epoch,?batch_idx?*?len(data),?len(train_sampler),
????????????????100.?*?batch_idx?/?len(train_loader),?loss.item()))
def?metric_average(val,?name):
????tensor?=?torch.tensor(val)
????avg_tensor?=?hvd.allreduce(tensor,?name=name)
????return?avg_tensor.item()
def?test():
????model.eval()
????test_loss?=?0.
????test_accuracy?=?0.
????for?data,?target?in?test_loader:
????????if?args.cuda:
????????????data,?target?=?data.cuda(),?target.cuda()
????????output?=?model(data)
????????#?sum?up?batch?loss
????????test_loss?+=?F.nll_loss(output,?target,?size_average=False).item()
????????#?get?the?index?of?the?max?log-probability
????????pred?=?output.data.max(1,?keepdim=True)[1]
????????test_accuracy?+=?pred.eq(target.data.view_as(pred)).cpu().float().sum()
????#?Horovod:?use?test_sampler?to?determine?the?number?of?examples?in
????#?this?worker's?partition.
????test_loss?/=?len(test_sampler)
????test_accuracy?/=?len(test_sampler)
????#?Horovod:?average?metric?values?across?workers.
????test_loss?=?metric_average(test_loss,?'avg_loss')
????test_accuracy?=?metric_average(test_accuracy,?'avg_accuracy')
????#?Horovod:?print?output?only?on?first?rank.
????if?hvd.rank()?==?0:
????????print('\nTest?set:?Average?loss:?{:.4f},?Accuracy:?{:.2f}%\n'.format(
????????????test_loss,?100.?*?test_accuracy))
if?__name__?==?'__main__':
????args?=?parser.parse_args()
????args.cuda?=?not?args.no_cuda?and?torch.cuda.is_available()
????#?Horovod:?initialize?library.
????hvd.init()
????torch.manual_seed(args.seed)
????if?args.cuda:
????????#?Horovod:?pin?GPU?to?local?rank.
????????torch.cuda.set_device(hvd.local_rank())
????????torch.cuda.manual_seed(args.seed)
????#?Horovod:?limit?#?of?CPU?threads?to?be?used?per?worker.
????torch.set_num_threads(1)
????kwargs?=?{'num_workers':?1,?'pin_memory':?True}?if?args.cuda?else?{}
????#?When?supported,?use?'forkserver'?to?spawn?dataloader?workers?instead?of?'fork'?to?prevent
????#?issues?with?Infiniband?implementations?that?are?not?fork-safe
????if?(kwargs.get('num_workers',?0)?>?0?and?hasattr(mp,?'_supports_context')?and
????????????mp._supports_context?and?'forkserver'?in?mp.get_all_start_methods()):
????????kwargs['multiprocessing_context']?=?'forkserver'
????train_dataset?=?\
????????datasets.MNIST('data-%d'?%?hvd.rank(),?train=True,?download=True,
???????????????????????transform=transforms.Compose([
???????????????????????????transforms.ToTensor(),
???????????????????????????transforms.Normalize((0.1307,),?(0.3081,))
???????????????????????]))
????#?Horovod:?use?DistributedSampler?to?partition?the?training?data.
????train_sampler?=?torch.utils.data.distributed.DistributedSampler(
????????train_dataset,?num_replicas=hvd.size(),?rank=hvd.rank())
????train_loader?=?torch.utils.data.DataLoader(
????????train_dataset,?batch_size=args.batch_size,?sampler=train_sampler,?**kwargs)
????test_dataset?=?\
????????datasets.MNIST('data-%d'?%?hvd.rank(),?train=False,?transform=transforms.Compose([
????????????transforms.ToTensor(),
????????????transforms.Normalize((0.1307,),?(0.3081,))
????????]))
????#?Horovod:?use?DistributedSampler?to?partition?the?test?data.
????test_sampler?=?torch.utils.data.distributed.DistributedSampler(
????????test_dataset,?num_replicas=hvd.size(),?rank=hvd.rank())
????test_loader?=?torch.utils.data.DataLoader(test_dataset,?batch_size=args.test_batch_size,
??????????????????????????????????????????????sampler=test_sampler,?**kwargs)
????model?=?Net()
????#?By?default,?Adasum?doesn't?need?scaling?up?learning?rate.
????lr_scaler?=?hvd.size()?if?not?args.use_adasum?else?1
????if?args.cuda:
????????#?Move?model?to?GPU.
????????model.cuda()
????????#?If?using?GPU?Adasum?allreduce,?scale?learning?rate?by?local_size.
????????if?args.use_adasum?and?hvd.nccl_built():
????????????lr_scaler?=?hvd.local_size()
????#?Horovod:?scale?learning?rate?by?lr_scaler.
????optimizer?=?optim.SGD(model.parameters(),?lr=args.lr?*?lr_scaler,
??????????????????????????momentum=args.momentum)
????#?Horovod:?broadcast?parameters?&?optimizer?state.
????hvd.broadcast_parameters(model.state_dict(),?root_rank=0)
????hvd.broadcast_optimizer_state(optimizer,?root_rank=0)
????#?Horovod:?(optional)?compression?algorithm.
????compression?=?hvd.Compression.fp16?if?args.fp16_allreduce?else?hvd.Compression.none
????#?Horovod:?wrap?optimizer?with?DistributedOptimizer.
????optimizer?=?hvd.DistributedOptimizer(optimizer,
?????????????????????????????????????????named_parameters=model.named_parameters(),
?????????????????????????????????????????compression=compression,
?????????????????????????????????????????op=hvd.Adasum?if?args.use_adasum?else?hvd.Average,
?????????????????????????????????????????gradient_predivide_factor=args.gradient_predivide_factor)
????for?epoch?in?range(1,?args.epochs?+?1):
????????train(epoch)
????????test()
訓(xùn)練命令
開始訓(xùn)練，指定worker個數(shù)：
#?run?training?with?4?GPUs?on?a?single?machine
$?horovodrun?-np?4?python?train.py
#?run?training?with?8?GPUs?on?two?machines?(4?GPUs?each)
$?horovodrun?-np?8?-H?hostname1:4,hostname2:4?python?train.py
參考
https://github.com/horovod/horovod
歡迎添加筆者微信加群討論
評論
圖片
表情