精华内容
下载资源
问答
  • gpu并行训练: torch.nn.DataParallel(module, device_ids=None, output_device=None, dim=0) 该函数实现了在module级别上的数据并行使用,注意batch size要大于GPU的数量。 参数 : module:需要GPU训练的...
  • 神经网络 深度学习 GPU并行训练 tensorflow demo MNIST
  • pytorch gpu并行训练

    万次阅读 2020-06-10 09:32:12
    单机多卡并行训练 torch.nn.DataParallel 我一般在使用GPU的时候, 会喜欢使用os.environ['CUDA_VISIBLE_DEVICES']来限制使用的GPU个数, 例如我要使用第0和第3编号的GPU, 那么只需要在程序中设置: os.environ...

    单机多卡并行训练

    torch.nn.DataParallel

    我一般在使用多GPU的时候, 会喜欢使用os.environ['CUDA_VISIBLE_DEVICES']来限制使用的GPU个数, 例如我要使用第0和第3编号的GPU, 那么只需要在程序中设置:

    os.environ['CUDA_VISIBLE_DEVICES'] = '0,3'

    这个参数最好在主体代码开始的时候写上,因为它要写在model调用cuda函数前使用。

    例如我们需要训练的文件为train.py,也是用‘0,3’号gpu,可以在代码外部的命令行中输入命令:

    CUDA_VISIBLE_DEVICES='0,3' python train.py

    这样的方式有两点好处,1.不用再关心代码是否在调用cuda前已经设置好参数;2.写在外面方便调用空闲gpu,不用每次使用的时候再去代码中修改。

    如果是模型, 那么需要执行下面的这几句代码:

    model = nn.DataParallel(model)
    model = model.cuda()

    如果是数据, 那么直接执行下面这几句代码就可以了:

    inputs = inputs.cuda()
    labels = labels.cuda()

     

     Reference:

    https://zhuanlan.zhihu.com/p/86441879

    展开全文
  • pytorch 指定gpu训练与gpu并行训练

    千次阅读 2019-05-16 19:33:41
    一.指定一个gpu训练的两种方法: 1.代码中指定 import torch torch.cuda.set_device(id) 2.终端中指定 CUDA_VISIBLE_DEVICES=1 python 你的程序 其中id就是你的gpu编号 二.gpu并行训练:...

    转自原文:https://blog.csdn.net/qq_29023939/article/details/88405459

    一.指定一个gpu训练的两种方法:

    1.代码中指定

    import torch
    torch.cuda.set_device(id)
    

    2.终端中指定

    CUDA_VISIBLE_DEVICES=1 python  你的程序
    

    其中id就是你的gpu编号

    二.多gpu并行训练:

    torch.nn.DataParallel(module, device_ids=None, output_device=None, dim=0)
    

    该函数实现了在module级别上的数据并行使用,注意batch size要大于GPU的数量。

    参数 :

    module:需要多GPU训练的网络模型

    device_ids: GPU的编号(默认全部GPU,或[0,1] ,[0,1,2])

    output_device:(默认是device_ids[0])

    dim:tensors被分散的维度,默认是0

    在保存模型时要注意要加上"module",例如:

    network.module.state_dict()
    
    展开全文
  • 文章目录实验配置1 单2080s 86.4 / 94.42 单2080 86.0 / 94.53 利用torch的parallel两张并行 85.0 /93.7 实验配置 一张2080s, 一张2080 1 单2080s 86.4 / 94.4 re-ranking 2 单2080 86.0 / 94.5 3 利用torch的...

    实验配置

    一张2080s, 一张2080

    1 单2080s 86.4 / 94.4 reranking 93.9 / 95.7

    在这里插入图片描述
    在这里插入图片描述

    re-ranking
    在这里插入图片描述

    展开全文
  • 使用Tensorflow实现GPU并行训练

    千次阅读 2017-11-14 16:07:01
    本文由 azraelkuan 创作,采用 知识共享署名4.0 国际许可协议进行许可 本站文章除注明转载/出处外,均为本站原创或翻译,转载前请务必署名 ...深度学习框架一般都支持GPU并行计算,主要分为数据并行

    转载自https://www.azraelkuan.me/archives/multiply-gpu-parallel-training-using-tensorflow

    本文由 azraelkuan 创作,采用 知识共享署名4.0 国际许可协议进行许可
    本站文章除注明转载/出处外,均为本站原创或翻译,转载前请务必署名

    基本简介

    深度学习框架一般都支持多GPU并行计算,主要分为数据并行和模型并行.TensorFlow支持的是数据并行.
    数据并行的原理:

    • CPU负责梯度平均和参数更新
    • 在GPU上训练模型的副本

    由图中可以看出多GPU并行计算的过程:

    1. 模型副本定义在GPU上
    2. 对于每一个GPU, 都是从CPU获得数据,前向传播进行计算,得到loss,并计算出梯度
    3. CPU接到GPU的梯度,取平均值,然后进行梯度更新

    同时在使用GPU的时候,有几个注意点:

    • 使用tf.get_variable定义变量,这样可以读取已经定义过的变量实现参数共享
    • 分别使用tf.name_scopetf.variable_scope来定义区间

    范例说明

    下面结合官网上的例子进行说明: GITHUB
    分为四个部分:

    • 输入数据处理: cifar10_input.py
    • 模型定义,loss计算等: cifar.py
    • 多gpu训练脚本: cifar10_multi_gpu_train.py
    • 评估脚本: cifar10_eval.py

    这里针对多gpu训练脚本做一个详细的说明:

    from datetime import datetime
    import os.path
    import re
    import time
    
    import numpy as np
    from six.moves import xrange
    import tensorflow as tf
    import cifar10
    
    
    FLAGS = tf.app.flags.FLAGS
    
    tf.app.flags.DEFINE_string('train_dir', './cifar10_train',
                               """Directory where to write event logs """
                               """and checkpoint.""")
    tf.app.flags.DEFINE_integer('max_steps', 1000000,
                                """Number of batches to run.""")
    tf.app.flags.DEFINE_integer('num_gpus', 1,
                                """How many GPUs to use.""")
    tf.app.flags.DEFINE_boolean('log_device_placement', False,
                                """Whether to log device placement.""")
    
    
    def tower_loss(scope, images, labels):
        """
        计算当前tower的损失
        这里的损失包括最后的损失和weight的L2正则损失 具体可以
        :param scope: 当前空间名
        :param images: 输入的图像
        :param labels: 图像的label
        :return: 总的loss
        """
        logits = cifar10.inference(images)
        _ = cifar10.loss(logits, labels)
        # 获得losses集合中的所有损失
        losses = tf.get_collection('losses', scope)
        # 将所有损失加和
        total_loss = tf.add_n(losses, name='total_loss')
        # 将loss记录到summary中
        for l in losses + [total_loss]:
            loss_name = re.sub('%s_[0-9]*/' % cifar10.TOWER_NAME, '', l.op.name)
            tf.summary.scalar(loss_name, l)
        return total_loss
    
    
    def average_gradients(tower_grads):
        """
        梯度平均
        :param tower_grads: 所有tower的梯度
        :return: 每一个变量的平均梯度
        """
        average_grads = []
        # 枚举所有的变量 计算变量在所有GPU下梯度的平均值
        for grad_and_vars in zip(*tower_grads):
            grads = []
            for g, _ in grad_and_vars:
                expanded_g = tf.expand_dims(g, 0)
                grads.append(expanded_g)
    
            grad = tf.concat(axis=0, values=grads)
            grad = tf.reduce_mean(grad, 0)
            v = grad_and_vars[0][2]
            grad_and_var = (grad, v)
            average_grads.append(grad_and_var)
        return average_grads
    
    
    def train():
        # 基本运算都定义在CPU上
        with tf.Graph().as_default(), tf.device('/cpu:0'):
            # 当前step
            global_step = tf.get_variable(
                'global_step', [],
                initializer=tf.constant_initializer(0), trainable=False)
            # 得到训练的batch
            num_batches_per_epoch = (cifar10.NUM_EXAMPLES_PER_EPOCH_FOR_TRAIN /
                                     FLAGS.batch_size)
            # 定义学习率衰减的步数
            decay_steps = int(num_batches_per_epoch * cifar10.NUM_EPOCHS_PER_DECAY)
            # 定义学习率 指数衰减
            lr = tf.train.exponential_decay(cifar10.INITIAL_LEARNING_RATE,
                                            global_step,
                                            decay_steps,
                                            cifar10.LEARNING_RATE_DECAY_FACTOR,
                                            staircase=True)
            # 优化器
            opt = tf.train.GradientDescentOptimizer(lr)
            # 建立数据队列
            images, labels = cifar10.distorted_inputs()
            batch_queue = tf.contrib.slim.prefetch_queue.prefetch_queue(
                [images, labels], capacity=2 * FLAGS.num_gpus)
    
            tower_grads = []
            with tf.variable_scope(tf.get_variable_scope()):
                for i in xrange(FLAGS.num_gpus):
                    with tf.device('/gpu:%d' % i):
                        with tf.name_scope('%s_%d' % (cifar10.TOWER_NAME, i)) as scope:
                            image_batch, label_batch = batch_queue.dequeue()
                            loss = tower_loss(scope, image_batch, label_batch)
                            # 在第一次声明变量之后,将控制变量重用的参数设置为True。这样可以
                            # 让不同的GPU更新同一组参数。注意tf.name_scope函数并不会影响
                            # tf.get_ variable的命名空间。
                            tf.get_variable_scope().reuse_variables()
                            summaries = tf.get_collection(tf.GraphKeys.SUMMARIES, scope)
                            # 计算梯度
                            grads = opt.compute_gradients(loss)
                            tower_grads.append(grads)
            # 计算平均梯度
            grads = average_gradients(tower_grads)
            summaries.append(tf.summary.scalar('learning_rate', lr))
    
            for grad, var in grads:
                if grad is not None:
                    summaries.append(tf.summary.histogram(var.op.name + '/gradients', grad))
            # 更新梯度
            # 注意这里的梯度是多个batch的平均 因此下面在计算时间,速度均要考虑gpu个数
            apply_gradient_op = opt.apply_gradients(grads, global_step=global_step)
    
            for var in tf.trainable_variables():
                summaries.append(tf.summary.histogram(var.op.name, var))
    
            # 计算变量的滑动平均值
            variable_averages = tf.train.ExponentialMovingAverage(
                cifar10.MOVING_AVERAGE_DECAY, global_step)
            variables_averages_op = variable_averages.apply(tf.trainable_variables())
    
            # 每一轮迭代需要更新变量的取值并更新变量的滑动平均值
            train_op = tf.group(apply_gradient_op, variables_averages_op)
    
            saver = tf.train.Saver(tf.global_variables())
            summary_op = tf.summary.merge(summaries)
    
            init = tf.global_variables_initializer()
    
            sess = tf.Session(config=tf.ConfigProto(
                allow_soft_placement=True,
                gpu_options=tf.GPUOptions(allow_growth=True),
                log_device_placement=FLAGS.log_device_placement))
            sess.run(init)
    
            tf.train.start_queue_runners(sess=sess)
    
            summary_writer = tf.summary.FileWriter(FLAGS.train_dir, sess.graph)
    
            for step in xrange(FLAGS.max_steps):
                start_time = time.time()
                _, loss_value = sess.run([train_op, loss])
                duration = time.time() - start_time
    
                assert not np.isnan(loss_value), 'Model diverged with loss = NaN'
    
                if step % 10 == 0:
    
                    # 这里统计计算速度 都要考虑到gpu的个数
                    # batch 应该是基本*gpu_num
                    num_examples_per_step = FLAGS.batch_size * FLAGS.num_gpus
                    # 每一个epoch的耗时也应该除以gpu个数
                    examples_per_sec = num_examples_per_step / duration
                    # 单个epoch的时间应该是总时间除gpu个数
                    sec_per_batch = duration / FLAGS.num_gpus
    
                    format_str = ('%s: step %d, loss = %.2f (%.1f examples/sec; %.3f '
                                  'sec/batch)')
                    print(format_str % (datetime.now(), step, loss_value,
                                        examples_per_sec, sec_per_batch))
    
                if step % 100 == 0:
                    summary_str = sess.run(summary_op)
                    summary_writer.add_summary(summary_str, step)
    
                if step % 1000 == 0 or (step + 1) == FLAGS.max_steps:
                    checkpoint_path = os.path.join(FLAGS.train_dir, 'model.ckpt')
                    saver.save(sess, checkpoint_path, global_step=step)
    
    
    def main(argv=None):
        cifar10.maybe_download_and_extract()
        if tf.gfile.Exists(FLAGS.train_dir):
            tf.gfile.DeleteRecursively(FLAGS.train_dir)
        tf.gfile.MakeDirs(FLAGS.train_dir)
        train()
    
    if __name__ == '__main__':
        tf.app.run()
    

    运行程序,多gpu速度

    Screenshot_2017-07-31_22-24-22.png

    展开全文
  • 模型训练时,通信量(特别是多卡,或者多机多卡)大幅减少,大幅减少等待时间,加快数据的流通。 计算更快: 目前的不少GPU都有针对 fp16 的计算进行优化。论文指出:在近期的GPU中,半精度的计算吞吐量可以是单...
  • Pytorch单机多卡分布式训练 数据并行

    千次阅读 2019-12-30 16:51:20
    目录Pytorch单机多卡训练(数据并行训练)0.判断GPU是否可用1.把模型送入GPU2.将训练数据送入GPU Pytorch单机多卡训练(数据并行训练) Pytorch的数据并行训练,已经被封装的十分完善。全程只需两步: 1.将模型...
  • Keras并行训练

    2019-07-29 20:31:24
    Keras如果以Tensorflow作为后端,是自动支持GPU的。...如果要用GPU训练,只需要用multi_gpu_model函数再包裹 一下。具体如下 ## 代码来自keras官方文档 网址 https://keras.io/getting-started/faq/#how-can-i-...
  • pytorch学习笔记:pytorchgpu并行训练

    千次阅读 2019-05-27 10:45:34
    在一个或个 GPU 上训练大批量模型: 梯度累积 充分利用 GPU 机器:torch.nn.DataParallel GPU 机器上的均衡负载 : PyTorch-Encoding 的 PyTorch 包,包括两个模块:DataParallelModel 和...
  • PyTorchGPU并行训练方法及问题整理

    千次阅读 2020-09-06 00:12:00
    单机多卡并行训练 1.1.torch.nn.DataParallel 我一般在使用GPU的时候, 会喜欢使用os.environ['CUDA_VISIBLE_DEVICES']来限制使用的GPU个数, 例如我要使用第0和第3编号的GPU, 那么只需要在程序中设置: os.environ['...
  • DataParallel 使用单进程控制将模型和数据加载到个 GPU 中,控制数据在 GPU 之间的流动,协同不同 GPU 上的模型进行并行训练。 但是DataParallel的缺点十分明显,各卡之间的负载不均衡,主卡的负载过大。运行时间...
  • DataParallel 可以帮助我们(使用单进程控)将模型和数据加载到个 GPU 中,控制数据在 GPU 之间的流动,协同不同 GPU 上的模型进行并行训练(细粒度的方法有 scatter,gather 等等)。 DataParallel 使用起来非常...
  • 数据并行 由于训练数据集太大,而无法一次将其全部载入内存。因此将数据集分为N份,分别装载到N个GPU节点中去进行梯度求导,然后将所有节点的求导结果进行加权平均,再sync update给所有节点(对于每个节点来说,...
  • 2.3 tensorflow单机GPU并行

    万次阅读 热门讨论 2019-06-30 14:30:40
    现在很服务器配置都是单机上配有个GPU卡。tensorflow默认占用全部的gpu的显存,但是只在第一块GPU上进行计算,这样对于显卡的利用率不高。 1. 指定运行GPU,不占用其他gpu的显存。 import os os.environ[...
  • 本篇博文主要讲如何使用PyTorch来进行模型训练和GPU操作。 PyTorch 预训练模型 Pytorch 提供了许多 Pre-Trained Model on ImageNet,仅需调用 torchvision.models 即可,具体细节可查看官方文档。 往往我们需要对 ...
  • 一.... 写一个TFRecord文件大概有3个流程: 1. 把数据转换成TFRecord规定的可接受的三种类型之一,分别是tf.train.BytesList(对应... train.py 数据并行多GPU训练一个image2image模型(dncnn降噪) 3. test.py 推理测试
  • if torch.cuda.device_count() > 1: # 并行 pretrained_model = nn.DataParallel(pretrained_model) 第一句是判断可用的gpu个数
  • 在使用 callbacks.ModelCheckpoint() 并进行 gpu 并行计算时,callbacks 函数会报错: TypeError: can't pickle ...(different text at different situation) objects 这个错误形式其实跟使用 gpu 训练时...
  • 2.Spark MLlib如何并行训练? 3.Spark MLlib并行训练的局限性有哪些? 这里是 王喆的机器学习笔记 的第二十五篇文章。接下来的几篇文章希望与大家一同讨论一下机器学习模型的分布式训练的问题。这个问题在推荐、...
  • 行业分类-物理装置-并行训练业务模型的方法及装置.zip
  • PyTorch 的多卡并行训练

    千次阅读 2019-03-24 15:21:32
    DataParallel 会将module复制到个卡上,也会将每个batch均分到每张卡上,每张卡独立forward自己那份data,而在backward时,每个卡上的梯度会汇总到原始的module上,以此来实现并行。 但是,这样的方式会造成原始...
  • 在LibSVM的源码中添加openmp的支持,实现训练和预测的并行计算。计算时会占用(MAX_CORE-1)个CPU核,MAX_CORE为最大核心数 使用方法: 将svm-train.exe和svm-predict.exe替换原有libsvm压缩包中windows目录下的可...
  • 实现 TensorFlow 多机并行线性加速

    千次阅读 2019-01-17 11:20:23
    摘要: 深度学习训练需要海量的数据,这就需要超大规模参数的网络模型拟合。如果训练数据不足,会造成欠拟合;如果网络模型参数太少,只会得到低精度的模型。目前常见网络模型参数已经上亿,参数大小达到数GB。中给出...
  • 使用 torch.distributed 加速并行训练 在 pytorch 1.0 之后,官方终于对分布式的常用方法进行了封装,支持 all-reduce,broadcast,send 和 receive 等等。通过 MPI 实现 CPU 通信,通过 NCCL 实现 GPU 通信。官方...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 66,329
精华内容 26,531
关键字:

多机并行训练