精华内容
下载资源
问答
  • 在深度学习模型训练过程中,在服务器端或者本地pc端,输入nvidia-smi来观察显卡的GPU内存占用率(Memory-Usage),显卡的GPU利用率(GPU-util),然后采用top来查看CPU的线程数(PID数)和利用率(%CPU)。...

            在深度学习模型训练过程中,在服务器端或者本地pc端,输入nvidia-smi来观察显卡的GPU内存占用率Memory-Usage),显卡的GPU利用率GPU-util),然后采用top来查看CPU的线程数(PID数)和利用率(%CPU)。往往会发现很多问题,比如,GPU内存占用率低,显卡利用率低,CPU百分比低等等。接下来仔细分析这些问题和处理办法。

    (ps:对于如何在Intel CPU,ARM架构CPU,以及Jetson TensorRT上部署深度学习模型,以及部署遇到的速度问题,该如何解决。请查看我的另外一篇文章。如何定制化编译Pytorch,TensorFlow,使得CNN模型在CPU,GPU,ARM架构和X86架构,都能快速运行,需要对每一个平台,有针对性的调整。如何做到最大化加速深度学习在不同平台部署性能。请看我的这篇文章。)

    深度学习模型部署性能分析,Intel和ARM CPU上CNN计算速度差距分析。

    1. GPU内存占用率问题

            这往往是由于模型的大小以及batch size的大小,来影响这个指标。当你发下你的GPU占用率很小的时候,比如40%,70%,等等。此时,如果你的网络结构已经固定,此时只需要改变batch size的大小,就可以尽量利用完整个GPU的内存。GPU的内存占用率主要是模型的大小,包括网络的宽度,深度,参数量,中间每一层的缓存,都会在内存中开辟空间来进行保存,所以模型本身会占用很大一部分内存。其次是batch size的大小,也会占用影响内存占用率。batch size设置为128,与设置为256相比,内存占用率是接近于2倍关系。当你batch  size设置为128,占用率为40%的话,设置为256时,此时模型的占用率约等于80%,偏差不大。所以在模型结构固定的情况下,尽量将batch size设置大,充分利用GPU的内存。(GPU会很快的算完你给进去的数据,主要瓶颈在CPU的数据吞吐量上面。)

    2. GPU利用率问题

            这个是Volatile GPU-Util表示,当没有设置好CPU的线程数时,这个参数是在反复的跳动的,0%,20%,70%,95%,0%。这样停息1-2 秒然后又重复起来。其实是GPU在等待数据从CPU传输过来,当从总线传输到GPU之后,GPU逐渐起计算来,利用率会突然升高,但是GPU的算力很强大,0.5秒就基本能处理完数据,所以利用率接下来又会降下去,等待下一个batch的传入。因此,这个GPU利用率瓶颈在内存带宽和内存介质上以及CPU的性能上面。最好当然就是换更好的四代或者更强大的内存条,配合更好的CPU。

            另外的一个方法是,在PyTorch这个框架里面,数据加载Dataloader上做更改和优化,包括num_workers(线程数),pin_memory,会提升速度。解决好数据传输的带宽瓶颈和GPU的运算效率低的问题。在TensorFlow下面,也有这个加载数据的设置。

    torch.utils.data.DataLoader(image_datasets[x],
                                batch_size=batch_size, 
                                shuffle=True,
                                num_workers=8,
                                pin_memory=True)

            为了提高利用率,首先要将num_workers(线程数)设置得体,4,8,16是几个常选的几个参数。本人测试过,将num_workers设置的非常大,例如,24,32,等,其效率反而降低,因为模型需要将数据平均分配到几个子线程去进行预处理,分发等数据操作,设高了反而影响效率。当然,线程数设置为1,是单个CPU来进行数据的预处理和传输给GPU,效率也会低。其次,当你的服务器或者电脑的内存较大,性能较好的时候,建议打开pin_memory打开,就省掉了将数据从CPU传入到缓存RAM里面,再给传输到GPU上;为True时是直接映射到GPU的相关内存块上,省掉了一点数据传输时间。

    3. CPU的利用率问题

            很多人在模型训练过程中,不只是关注GPU的各种性能参数,往往还需要查看CPU处理的怎么样,利用的好不好。这一点至关重要。但是对于CPU,不能一味追求超高的占用率。如图所示,对于14339这个程序来说,其CPU占用率为2349%(我的服务器是32核的,所以最高为3200%)。这表明用了24核CPU来加载数据和做预处理和后处理等。其实主要的CPU花在加载传输数据上。此时,来测量数据加载的时间发现,即使CPU利用率如此之高,其实际数据加载时间是设置恰当的DataLoader的20倍以上,也就是说这种方法来加载数据慢20倍。当DataLoader的num_workers=0时,或者不设置这个参数,会出现这个情况。

    CPU利用率查看结果
    CPU利用率查看结果

            下图中可以看出,加载数据的实际是12.8s,模型GPU运算时间是0.16s,loss反传和更新时间是0.48s。此时,即使CPU为2349%,但模型的训练速度还是非常慢,而且,GPU大部分是时间是空闲等待状态。

    num_workers=0,模型每个阶段运行时间统计

            当我将num_workers=1时,出现的时间统计如下,load data time为6.3,数据加载效率提升1倍。且此时的CPU利用率为170%,用的CPU并不多,性能提升1倍。

    num_workers=1时,模型每个阶段运行时间统计

            此时,查看GPU的性能状态(我的模型是放在1,2,3号卡上训练),发现,虽然GPU(1,2,3)的内存利用率很高,基本上为98%,但是利用率为0%左右。表面此时网络在等待从CPU传输数据到GPU,此时CPU疯狂加载数据,而GPU处于空闲状态

    1,2,3号GPU的内存占用率和计算效率截图

            由此可见,CPU的利用率不一定最大才最好。

            对于这个问题,解决办法是,增加DataLoader这个num_wokers的个数,主要是增加子线程的个数,来分担主线程的数据处理压力,多线程协同处理数据和传输数据,不用放在一个线程里负责所有的预处理和传输任务。

            我将num_workers=8,16都能取得不错的效果。此时用top查看CPU和线程数,如果我设置为num_workers=8,线程数有了8个连续开辟的线程PID,且大家的占用率都在100%左右,这表明模型的CPU端,是较好的分配了任务,提升数据吞吐效率。效果如下图所示,CPU利用率很平均和高效,每个线程是发挥了最大的性能。

    num_workers=8时,CPU利用率和8个连续PID任务

            此时,在用nvidia-smi查看GPU的利用率,几块GPU都在满负荷,满GPU内存,满GPU利用率的处理模型,速度得到巨大提升。

    优化数据加载num_workers=8,和设置batch size的结果

            上图中可以看见,GPU的内存利用率最大化,此时是将batch size设置的较大,占满了GPU的内存,然后将num_workers=8,分配多个子线程,且设置pin_memory=True,直接映射数据到GPU的专用内存,减少数据传输时间。GPU和CPU的数据瓶颈得到解决。整体性能得到权衡。

            此时的运行时间在表中做了统计:

    处理时间统计
    处理阶段时间
    数据加载0.25s
    模型在GPU计算0.21s
    loss反传,参数更新0.43s

    4. 总结

            对上面的分析总结一下,第一是增加batch size,增加GPU的内存占用率,尽量用完内存,而不要剩一半,空的内存给另外的程序用,两个任务的效率都会非常低。第二,在数据加载时候,将num_workers线程数设置稍微大一点,推荐是8,16等,且开启pin_memory=True不要将整个任务放在主进程里面做,这样消耗CPU,且速度和性能极为低下。

                                                                                                                                                                         

                                                                                                                                                                         

                                                                                                                                                                         

            Supplementary:看到大家在评论回复的问题比较多,所以再加一些叙述!

            开这么多线程。第一个,查看你的数据的batch_size,batchsize小了,主CPU直接就加载,处理,而且没有分配到多GPU里面(如果你使用的是多GPU);如果是单GPU,那么就是CPU使劲读数据,加载数据,然后GPU一下就处理完了,你的模型应该是很小,或者模型的FLOPs很小。检查一下模型问题。还有就是,现在这个情况下,开8个线程和1个线程,没什么影响,你开一个num_workers都一样的。如果速度快,没必要分配到多个num_workers去。当数据量大的时候,num_workers设置大,会非常降低数据加载阶段的耗时。这个主要还是应该配合过程。

            在调试过程,命令:top     实时查看你的CPU的进程利用率,这个参数对应你的num_workers的设置;

            命令:   watch -n 0.5 nvidia-smi    每0.5秒刷新并显示显卡设置。

    实时查看你的GPU的使用情况,这是GPU的设置相关。这两个配合好。包括batch_size的设置。

                                                                                                                                                                    时间:2019年9月20日

    5. 再次补充内容

            有很多网友都在讨论一些问题,有时候,我们除了排查代码,每个模块的处理信息之外,其实还可以查一下,你的内存卡,是插到哪一块插槽的。这个插槽的位置,也非常影响代码在GPU上运行的效率。

            大家除了看我上面的一些小的建议之外,评论里面也有很多有用的信息。遇到各自问题的网友们,把他们的不同情况,都描述和讨论了一下,经过交流,大家给出了各自在训练中,CPU,GPU效率问题的一些新的发现和解决问题的方法。

            针对下面的问题,给出一点补充说明:

            问题1: CPU忙碌,GPU清闲。

     数据的预处理,和加载到GPU的内存里面,花费时间。平衡一下batch size, num_workers。

            问题2:CPU利用率低,GPU跑起来,利用率浮动,先增加,然后降低,然后等待,CPU也是浮动。

    • 2.1 下面是具体的步骤和对策:

    在pytorch训练模型时出现以下情况, 情况描述: 首先环境:2080Ti + I7-10700K, torch1.6, cuda10.2, 驱动440 参数设置:shuffle=True, num_workers=8, pin_memory=True; 现象1:该代码在另外一台电脑上,可以将GPU利用率稳定在96%左右 现象2:在个人电脑上,CPU利用率比较低,导致数据加载慢,GPU利用率浮动,训练慢约4倍;有意思的是,偶然开始训练时,CPU利用率高,可以让GPU跑起来,但仅仅几分钟,CPU利用率降下来就上不去了,又回到蜗牛速度。

    •  可以采用的方法:

    两边的配置都一样吗。另一台电脑和你的电脑。你看整体,好像设置配置有点不同。包括硬件,CPU的核,内存大小。你对比一下两台设备。这是第一个。第二个,还是代码里面的配置,代码的高效性。你一来,CPU利用率低,你看一下每一步,卡到哪里,哪里是瓶颈,什么步骤最耗时。都记录一下每一个大的步骤的耗时,然后在分析。测试了每一个大的过程的时间,可以看见,耗时在哪里。主要包括,加载数据,前向传播,反向更新,然后下一步。

    • 2.2 经过测试之后,第二次问题分析:

    经过测试,发现本机卡的地方在加载图像的地方,有时加载10kb左右的图像需要1s以上,导致整个batch数据加载慢!代码应该没有问题,因为在其他电脑能全速跑起来;硬件上,本机的GPU,CPU都强悍,环境上也看不出差距,唯一差在内存16G,其他测试电脑为32G,请问这种现象和内存直接关系大吗?

    • 情况分析

    最多可能就在这边。你可以直接测试batch size为1情况下的整个计算。或者将batch size 开到不同的设置下。看加载数据,计算之间的差值。最有可能就是在这个load data,读取数据这块。 电脑的运行内存16g 32g。其实都已经够了,然后加载到GPU上,GPU内存能放下,影响不大。所以估计是你的内存相对小了,导致的问题。试一下。

    • 2.3 问题定位,解决方法:
    • 这台电脑的内存条插的位置不对,4个插槽的主板,1根内存的时候应该插在第2个插槽(以cpu端参考起),而组装电脑的商家不专业,放在了第4个插槽上,影响性能,更换位置后,速度飞起来了!关于插槽详情,有遇到的朋友去网上收,一大堆!

            在自己电脑,或者自己配的主机上,跑GPU的时候,记得注意查看你自己的内存卡是插到哪一个槽上的。

            补充时间:2021年1月15日

    5.1 再次新补充一些内容

            有网友补充了一些在执行上面的问题中遇到的实际问题,附上他的解决方法。

            使用win 10修改num_workers后可能会报错Broken pipe。

    解决方法:1. 把代码放到if __name__ == "__main__":下运行;或者2.num_workers默认为0即可;或者3. 在Linux进行代码运行

            有一些内容需要说明:在Windows下面,设置num_threads,除了在做数据加载的时候,设置num_workers,还可以用torch.set_num_threads(4)多线程,单线程,都会用多个CPU核,跑多个CPU core的的。只是CPU利用率不高。你设置8线程,12线程,CPU会在每个核上,都进行分配,只是单核的占用率,不一样。即使设置2线程,在6核12线程的CPU,也会在每个核心上,分配计算资源的。只是单核分配的很少。

    5.2 关于加速CPU端训练的方法(无GPU)

            在单独的CPU上,做训练,或者做推理,intel CPU提供了OpenMP 和MKL-DNN的加速库。一般torch或者TensorFlow都做了这一块的优化。可以查看你的pytorch版本,是否支持。

    print(torch.get_num_threads())
    print(torch.__config__.parallel_info())
    
    print(*torch.__config__.show().split("\n"), sep="\n")
    
    
    os.environ["OMP_NUM_THREADS"]="8"  #设置OpenMP计算库的线程数
    os.environ["MKL_NUM_THREADS"]="8"  # 设置MKL-DNN CPU加速库的线程数。
    torch.set_num_threads(8)

    print(torch.get_num_threads())
    print(torch.__config__.parallel_info())

    print(*torch.__config__.show().split("\n"), sep="\n")


    os.environ["OMP_NUM_THREADS"]="8"  #设置OpenMP计算库的线程数
    os.environ["MKL_NUM_THREADS"]="8"  # 设置MKL-DNN CPU加速库的线程数。
    torch.set_num_threads(8)

            分析:

            上面这几个,都可以试一下。看你的pytorch版本,是否在编译之后,支持MKL-DNN加速。为了能控制你使用的线程数,set_num_threads(8) 这个线程数的多少,可以自己按照需求来设定。当你全力跑网络模型,当然设置大点。如果需要留一部分CPU性能来做其他的业务,4线程,6线程?都可以。自己试一试。配合着任务管理器或者htop top 在linux下实时查看CPU使用状态和设置多线程数量的关系。来定性的分配。

            print(torch.__config__.parallel_info()) , 这个函数,查看你的pytorch支持的intel加速库的信息。

            print(*torch.__config__.show().split("\n"), sep="\n") , 这个函数,查看你编译过程中的信息。

            实测结果:

            有没有OpenMP支持,速度影响不是太大。在1-2s内的影响。所采用的pytorch版本是否支持mkl-dnn不影响。在mac arm m1芯片下,开启mkl-dnn,速度比没有开启快4s。44s 与 48s的差别。我们的平台,都是支持mkl-dnn。没有mkl-dnn,速度比有mkl-dnn编译的模型,慢1.5倍左右。

            结论:

            mkl-dnn有无,对性能影响不是很大,1-2x的影响。如果你需要这点性能,那么就要重点检测,你的pytorch版本,是否在编译过程中,设置了use_mkl=on,use_mkldnn=on。大多数情况下,咱们安装的pytorch官方版本,都在build过程中,设置了开启mkl加速选项。这是intel Math Kernel  Library for Deep Neural Networks (Intel® MKL-DNN) 专门针对intel CPU做的CPU端深度学习加速库。

            arm平台下,有无OpenMP和mkl-dnn不确定,要查看这个pytorch是否对arm 这个架构有支持。nvidia的arm平台,jetson这一类的,nvidia自己做了重新编译的,都适配了arm的CPU。

    再提醒一下:以上设置,如果不进行设计,默认为0,会按照最大的性能,来运行。

            补充时间:2021年6月25日。ps:有任何性能加速上遇到的问题,欢迎提出,我经常会查看大家的问题,能回答的都会回答。

    对于如何在Intel CPU,ARM架构CPU,以及Jetson TensorRT上部署,以及部署遇到的速度问题,该如何解决。请查看我的另外一篇文章。

    深度学习模型部署性能分析,Intel和ARM CPU上CNN计算速度差距分析。

    展开全文
  • 训练模型中,最耗时的因素是图像大小size,一般227*227用CPU来训练的话,训练1万次可能要超过1周的时间。 不同的网络结构,可能会有不同图片尺寸的需求,所以训练之前需要了解一下,在生成LMDB环节就直接符合上模型...

    本文部分内容来源于CDA深度学习实战课堂,由唐宇迪老师授课

    • 如果你企图用CPU来训练模型,那么你就疯了…
    • 训练模型中,最耗时的因素是图像大小size,一般227*227用CPU来训练的话,训练1万次可能要超过1周的时间。
    • 不同的网络结构,可能会有不同图片尺寸的需求,所以训练之前需要了解一下,在生成LMDB环节就直接符合上模型的数据要求。
    • 如果你自己DIY了框架,那么不知道如何检验框架与通用框架比较,是否优质,可以去benchmarks网站,跟别人的PK一下:http://human-pose.mpi-inf.mpg.de/
    • Caffe官网: Examples:主要集中在训练模型 Notebook Examples:集中在fun-tuning模型

    一、训练文件配置详情

    1、参数文件solver.prototxt

    以caffeNet为例,参数解读:

    net: "/caffe/examples/lmdb_test/train/bvlc_reference_caffenet/train_val.prototxt"
        # 训练的prototxt在哪,路径
    test_iter: 1000
        # 测试要迭代多少个Batch  test_iter * batchsize(测试集的)= 测试集的大小
    test_interval: 500
        # 每500次迭代,就在用测试集进行测试
    base_lr: 0.01
        # 设置初始化的学习率为0.01
    lr_policy: "step"
        # 权重衰减策略。
    gamma: 0.1
    stepsize: 100000
        # 初始的学习率为0.01,并且每100000次迭代中进行学习率下降
    display: 20
        # 每20次epoch就显示出一些数据信息
    max_iter: 50000
        # 迭代次数
    momentum: 0.9
        # 一直都是0.9,固定不变;迭代的数据更快,步伐更快
    
    weight_decay: 0.0005
        # 权重衰减因子为0.0005
    snapshot: 10000
        # 每10000次迭代中,就生成当前状态的快照
    snapshot_prefix: "/caffe/examples/lmdb_test/train/bvlc_reference_caffenet"
        # 模型快照保存
    
    solver_mode: CPU
        # 可以设定GPU还是cpu

    快照的大用途:如果出了什么意外中断了训练,那真是天都要塌了,所以快照存储了训练的中间结果,这个设计真是人性化,当再次训练时,就可以从快照中恢复数据了。直接在最后的执行文件,调用已经训练的快照就行,用-snapshot

    2、框架文件,train_val.prototxt

    框架文件每一层参数具体含义是什么?可参考caffe官方链接:http://caffe.berkeleyvision.org/tutorial/layers.html

    训练文件:配置训练阶段的图片数据集、配置训练阶段的标签数据集、配置测试阶段的图片数据集 、配置测试阶段的标签数据集 、 多标签损失函数(博客:Caffe中LMDB接口实现多标签数据准备及训练)

    网络的配置文件——定义网络

    Name:””  #随便写
    Layer
    {
    Name:””  #名称
    Type:””  #很严格
    Top:”label” # 接最后的内容,最后全连接层会出现"bottom:"label""
    }
    
    Transform.param
    # 1/256,归一化,多少大小一般都需要进行归一化处理
    
    Batch_size:64  
    #一次迭代多少个样本
    
    Layer
    {data}
    # 两个数据层,一个训练层,一个验证层
    
    Layer 
    {
    Conv1
    }

    需要注意的是:

    1. 最后全连接输出,时候你是几分类,就要填几:

    多分类数量就看训练时候的分类个数。

    inner_product_param {
        num_output: 2
        weight_filler {
          type: "gaussian"
          std: 0.01

    2. 自己定义层的时候
    需要自己写不同的层,c++自己写,挺麻烦的

    3. 图片尺寸
    图片尺寸是根据网络来定义的,大型网络都是227*227(224*224),VGG,ALEX都是这样,譬如lenet小网络就可以用28*28

    4. batch的作用
    Batch越大越好,一般64.小的话,可以更好地显示,小步迭代

    3、模型执行文件train.sh

    执行文件就是训练好之后,你要在linux下运行的文件。

    ./build/tools/caffe train \
      # caffe这个工具在哪,一般就在tool之下
    -gpu 0 \
      # 不必须,是否用GPU,譬如你有很多块GPU,每块都有编号,那么就可以直接选择某一块GPU。其中如果你有四块GPU,那么就可以-gpu all
    -model path/to/trainval.prototxt \
      # 不必须,因为后面有solver参数文件,而参数文件里面有trainval.prototxt文件,一般都不用写
    -solver path/to/solver.prototxt \
      # 必须,prototxt文件内容在哪
    -weights path/to/pretrained_weights.caffemodel
      # 不必须,-weight用来做fine-tuning,参数拿来学习。这个在fine-tuning时候用得上
    --snapshot=examples/imagenet/myself/model/caffenet_train_1000.solverstate
      # 如果断了,这时候就可以用快照继续训练啦~  只要在执行文件中加入snapshot的路径

    其中snapshot可是大杀器,笔者觉得有两个用途:

    • 1、临时停机了…机器训练中断了…
      训练的时候是遵循snapshot每10000次生成一次快照,如果停机就可以继续延续上次的内容继续训练,再写一遍这个文件即可。
    • 2、要fine-tuning别人的模型,则需要先down他们的模型快照,然后继续训练,继续训练的时候可以让学习率降低到很小,把全连接层可以稍微分一下。

    4、验证集文件:deploy.prototxt

    这个文件是预测的时候需要用到的,跟参数trian_val.prototxt训练文件很相似。

    train_val.prototxt文件=数据输入+卷积层+全连接层+loss/accuracy
    Deploy.prototxt文件=简化版数据输入+卷积层+全连接层+prob预测层

    其他真的不用改动。train_val的ImageData输入层,需要修改为input层。

    就拿AlexNet来说,不同之处在数据输入部分+最后链接层

    • Deploy.prototxt的数据输入部分:
    layer {
      name: "data"
      type: "Input"
      top: "data"
      input_param { shape: { dim: 10 dim: 3 dim: 227 dim: 227 } }
    }

    其中input_param中的参数意义为:
    **第一个:**dim,对待识别样本图片进行数据增广的数量,一个图片会变成10个,之后输入到网络进行识别。如果不进行数据增广,可以设置成1。
    第二个:图片的通道数,一般灰度图片为单通道,则值为1,如果为非灰度图3通道图片则为3。
    第三个:图片的高度,单位像素。
    第四个:图片的宽度,单位像素。
    内容来源于:caffe生成lenet-5的deploy.prototxt文件

    • Deploy.prototxt的全连接prob部分:
    layer {
      name: "prob"
      type: "Softmax"
      bottom: "fc8"
      top: "prob"
    }

    输出的是概率值,参数trian_val.prototxt集合中全连接层之后链接的是loss/accuracy。可以看出训练集要求的主要内容是输出loss/accuracy,衡量训练精度;而验证集文件,主要就是将图片分类输出出来。


    二、训练完之后如何测试新数据

    官方案例案例链接ipynb格式:打开链接

    1、如何将mean.binaryproto转mean.npy

    由于验证的时候需要在python下,验证新图片的时候,是先读入然后减去均值,这时候均值就需要一个python可以理解的版本。
    网络上有博客总结两种方法(博客:Caffe均值文件mean.binaryproto转mean.npy):mean.binaryproto转mean.npy、已知均值情况下用均值创建

    (1)mean.binaryproto 转化
    使用Caffe的C++接口进行操作时,需要的图像均值文件是pb格式,例如常见的均值文件名为mean.binaryproto;但在使用Python接口进行操作时,需要的图像均值文件是numpy格式,例如mean.npy。所以在跨语言进行操作时,需要将mean.binaryproto转换成mean.npy,转换代码如下:

    import caffe
    import numpy as np
    
    MEAN_PROTO_PATH = 'mean.binaryproto'               # 待转换的pb格式图像均值文件路径
    MEAN_NPY_PATH = 'mean.npy'                         # 转换后的numpy格式图像均值文件路径
    
    blob = caffe.proto.caffe_pb2.BlobProto()           # 创建protobuf blob
    data = open(MEAN_PROTO_PATH, 'rb' ).read()         # 读入mean.binaryproto文件内容
    blob.ParseFromString(data)                         # 解析文件内容到blob
    
    array = np.array(caffe.io.blobproto_to_array(blob))# 将blob中的均值转换成numpy格式,array的shape (mean_number,channel, hight, width)
    mean_npy = array[0]                                # 一个array中可以有多组均值存在,故需要通过下标选择其中一组均值
    np.save(MEAN_NPY_PATH ,mean_npy)

    (2)已知图像均值,构造mean.npy

    如果已知图像中每个通道的均值,例如3通道图像每个通道的均值分别为104,117,123,我们也可以通过其构造mean.npy。代码如下:

    import numpy as np
    
    MEAN_NPY_PATH = 'mean.npy'
    
    mean = np.ones([3,256, 256], dtype=np.float)
    mean[0,:,:] = 104
    mean[1,:,:] = 117
    mean[2,:,:] = 123
    
    np.save(MEAN_NPY, mean)

    (3)如何加载mean.npy文件
    上面我们用两种方式构造了均值文件mean.npy,在使用时载入mean.npy的代码如下:

    import numpy as np
    
    mean_npy = np.load(MEAN_NPY_PATH)
    mean = mean_npy.mean(1).mean(1)

    2、利用python做预测

    (1)模块加载与设置环境

    #加载模块与图像参数设置
    import numpy as np
    import matplotlib.pyplot as plt
    plt.rcParams['figure.figsize'] = (10, 10)        # large images
    plt.rcParams['image.interpolation'] = 'nearest'  # don't interpolate: show square pixels
    plt.rcParams['image.cmap'] = 'gray' 
    
    #模型路径deploy
    import caffe
    import os
    
    caffe.set_mode_cpu()
    
    model_def = caffe_root + 'examples/faceDetech/deploy.prototxt'
    model_weights = caffe_root + 'examples/faceDetech/alexnet_iter_50000_full_conv.caffemodel'
    
    
    #模型加载
    net = caffe.Net(model_def,      # defines the structure of the model
                    model_weights,  # contains the trained weights
                    caffe.TEST)

    其中如何你没有训练好的模型那么caffe官方有一套,利用imagenet图片和caffenet模型训练好了一个caffemodel, 供大家下载。要进行图片的分类,这个caffemodel是最好不过的了。下载地址为:http://dl.caffe.berkeleyvision.org/bvlc_reference_caffenet.caffemodel
    或者命令行下载:

    # sudo ./scripts/download_model_binary.py models/bvlc_reference_caffenet

    (2)模型预处理阶段-不处理均值的情况

    transformer = caffe.io.Transformer({'data': net.blobs['data'].data.shape})
      # 那么reshape操作,就是自动将验证图片进行放缩
    transformer.set_transpose('data', (2,0,1))  # move image channels to outermost dimension
      # transpose将RGB变为BGR,都要做transpose
      # BGR谁放在前面,譬如3*300*100,这里设定3在前面
    transformer.set_raw_scale('data', 255)      # rescale from [0, 1] to [0, 255]
      # 像素点rescale操作,将数据的像素点集中在[0,255]区间内
    transformer.set_channel_swap('data', (2,1,0))  
    
      # CPU classification              
     net.blobs['data'].reshape(50,        # batch size
                              3,         # 3-channel (BGR) images
                              227, 227) 

    (3)单张新图片处理与识别

    image = caffe.io.load_image("/caffe/data/trainlmdb/val/test_female/image_00010.jpg") 
    # 导入图片         
    transformed_image = transformer.preprocess('data', image)        
    # 预处理图片
    output = net.forward()            
    # 前向传播一次,找出参数
    net.blobs['data'].data[...] = transformed_image         
    output_prob = output['prob'][0]                
    # 输出概率
    print 'predicted class is:', output_prob.argmax() 
    # 输出最大可能性

    笔者训练的一个二分类结果是:

    array([ 0.34624347,  0.65375656], dtype=float32)

    转载:三、多张训练循环读取

    本节主要参考博客:Caffe学习系列(20):用训练好的caffemodel来进行分类

    在caffe根目录下的 examples/cpp-classification/
    文件夹下面,有个classification.cpp文件,就是用来分类的。当然编译后,放在/build/examples/cpp_classification/
    下面

    数据准备好了,我们就可以开始分类了,我们给大家提供两个版本的分类方法:

    一、c++方法

    在caffe根目录下的 examples/cpp-classification/ 文件夹下面,有个classification.cpp文件,就是用来分类的。当然编译后,放在/build/examples/cpp_classification/ 下面

    我们就直接运行命令:

    # sudo ./build/examples/cpp_classification/classification.bin \
      models/bvlc_reference_caffenet/deploy.prototxt \
      models/bvlc_reference_caffenet/bvlc_reference_caffenet.caffemodel \
      data/ilsvrc12/imagenet_mean.binaryproto \
      data/ilsvrc12/synset_words.txt \
      examples/images/cat.jpg

    命令很长,用了很多的\符号来换行。可以看出,从第二行开始就是参数,每行一个,共需要4个参数

    运行成功后,输出top-5结果:

    ---------- Prediction for examples/images/cat.jpg ----------
    0.3134 - "n02123045 tabby, tabby cat"
    0.2380 - "n02123159 tiger cat"
    0.1235 - "n02124075 Egyptian cat"
    0.1003 - "n02119022 red fox, Vulpes vulpes"
    0.0715 - "n02127052 lynx, catamount"

    即有0.3134的概率为tabby cat, 有0.2380的概率为tiger cat ……

    二、python方法

    python接口可以使用jupyter notebook来进行可视化操作,因此推荐使用这种方法。

    在这里我就不用可视化了,编写一个py文件,命名为py-classify.py

    #coding=utf-8
    #加载必要的库
    import numpy as np
    
    import sys,os
    
    #设置当前目录
    caffe_root = '/home/xxx/caffe/' 
    sys.path.insert(0, caffe_root + 'python')
    import caffe
    os.chdir(caffe_root)
    
    net_file=caffe_root + 'models/bvlc_reference_caffenet/deploy.prototxt'
    caffe_model=caffe_root + 'models/bvlc_reference_caffenet/bvlc_reference_caffenet.caffemodel'
    mean_file=caffe_root + 'python/caffe/imagenet/ilsvrc_2012_mean.npy'
    
    net = caffe.Net(net_file,caffe_model,caffe.TEST)
    transformer = caffe.io.Transformer({'data': net.blobs['data'].data.shape})
    transformer.set_transpose('data', (2,0,1))
    transformer.set_mean('data', np.load(mean_file).mean(1).mean(1))
    transformer.set_raw_scale('data', 255) 
    transformer.set_channel_swap('data', (2,1,0))
    
    im=caffe.io.load_image(caffe_root+'examples/images/cat.jpg')
    net.blobs['data'].data[...] = transformer.preprocess('data',im)
    out = net.forward()
    
    
    imagenet_labels_filename = caffe_root + 'data/ilsvrc12/synset_words.txt'
    labels = np.loadtxt(imagenet_labels_filename, str, delimiter='\t')
    
    top_k = net.blobs['prob'].data[0].flatten().argsort()[-1:-6:-1]
    for i in np.arange(top_k.size):
        print top_k[i], labels[top_k[i]]

    执行这个文件,输出:

    281 n02123045 tabby, tabby cat
    282 n02123159 tiger cat
    285 n02124075 Egyptian cat
    277 n02119022 red fox, Vulpes vulpes
    287 n02127052 lynx, catamount

    caffe开发团队实际上也编写了一个python版本的分类文件,路径为 python/classify.py

    运行这个文件必需两个参数,一个输入图片文件,一个输出结果文件。而且运行必须在python目录下。假设当前目录是caffe根目录,则运行:

    # cd python
    # sudo python classify.py ../examples/images/cat.jpg result.npy

    分类的结果保存为当前目录下的result.npy文件里面,是看不见的。而且这个文件有错误,运行的时候,会提示

    Mean shape incompatible with input shape

    的错误。因此,要使用这个文件,我们还得进行修改:

    1、修改均值计算:

    定位到

    mean = np.load(args.mean_file)

    这一行,在下面加上一行:

    mean=mean.mean(1).mean(1)

    则可以解决报错的问题。

    2、修改文件,使得结果显示在命令行下:

    定位到

    
    # Classify.
        start = time.time()
        predictions = classifier.predict(inputs, not args.center_only)
        print("Done in %.2f s." % (time.time() - start))
    

    这个地方,在后面加上几行,如下所示:

      # Classify.
        start = time.time()
        predictions = classifier.predict(inputs, not args.center_only)
        print("Done in %.2f s." % (time.time() - start))
        imagenet_labels_filename = '../data/ilsvrc12/synset_words.txt'
        labels = np.loadtxt(imagenet_labels_filename, str, delimiter='\t')
        top_k = predictions.flatten().argsort()[-1:-6:-1]
        for i in np.arange(top_k.size):
            print top_k[i], labels[top_k[i]]

    就样就可以了。运行不会报错,而且结果会显示在命令行下面。
    .


    延伸一:caffe中网络结构可视化

    还有一个是python下面的接口,draw_net.py可以根据.prototxt文件将模式用图示的方法表示出来,博文开始的模型图即用该接口所绘

    ./python/draw_net.py ./examples/siamese/mnist_siamese.prototxt   ./examples/siamese/mnist_siamese.png
    #使用该接口进行网络的绘制示例化

    第一个参数为模型文件,第二个参数为所绘模型图的保存地址。参考博客:Caffe使用step by step:caffe框架下的基本操作和分析

    展开全文
  • 模型训练时间的估算

    千次阅读 2020-08-26 10:34:47
    昨天群里一个朋友训练一个BERT句子对模型,使用的是CPU来进行训练,由于代码是BERT官方代码,并没有显示训练需要的总时间,所以训练的时候只能等待。他截图发了基本的信息,想知道训练完整个模型需要多久。 最开始跑...

    模型训练时间的估算

    昨天群里一个朋友训练一个BERT句子对模型,使用的是CPU来进行训练,由于代码是BERT官方代码,并没有显示训练需要的总时间,所以训练的时候只能等待。他截图发了基本的信息,想知道训练完整个模型需要多久。

    最开始跑BERT模型的时候,我也碰到这个问题,当时没有深入研究,
    不过后来换成keras,bert4keras等框架,可以直接输出时间,比较直观,也就忽略了这个问题。这次回过头来重新理一理,也算温故知新。

    话不多说,截图如下:
    在这里插入图片描述
    在这里插入图片描述

    基础量

    先整理一下截图中已知的量:

    global_step/sec = 0.204125
    表示每秒训练多少个batch批次;

    examples/sec = 3.26599
    表示每秒可以训练的样本数量 ;

    Num examples = 40127
    表示样本的总数量

    Batch size = 16
    表示一批次有多少个样本;

    Num steps = 25079
    表示总共有多少步(批次)

    Epoch = 10
    迭代次数,即所有样本训练的次数

    迭代次数Epoch没有在截图里,但是可以这样推算:

    Epoch = Num steps * Batch size / Num examples
          = 25079 * 16 / 40127
    	  = 10 次
    

    推理公式

    以下是推理出来的其它公式:

    Num steps = Num examples * Epoch / Batch size 
    25079 = 40127 * 10 / 16
    
    一个迭代训练用时 = Num examples / (examples/sec)
                     = 40127 / 3.26599 
    				 = 12286秒
    				 = 3小时 24分 46秒
    
    训练总用时(秒) = Num examples * Epoch / (examples/sec) (秒)
                   = 40127 * 10 / 3.26599
    		       = 122863 秒
    		       = 34小时 7分 43秒
    
    或者:
    训练总用时(秒) = Num steps  / (global_step/sec) (秒)
                   = 25079 / 0.204125
    			   = 122861 秒
    		       = 34小时 7分 41秒
    
    

    ** 附带一个时间长度的转换方法,可用于把秒数变成时间长度 **:

    '''
    # 经过的秒数 转成 时间长度
    测试样例:
    >>> getSpanTimes(122891234,unit='')
    '3Y 10M 22D 08:27:14;'
    >>> getSpanTimes(122891234,unit='en')
    '3 Years 10 Months 22 Days 08 Hour 27 Minute 14 Second'
    >>> getSpanTimes(122891234,unit='zh')
    '3年 10个月 22天 08小时 27分 14秒'
    '''
    def getSpanTimes (lngTimeSpan, unit=''):
        import time
        unit_sim = 'Y |M |D |:|:|;'
        unit_en = ' Years | Months | Days | Hour | Minute | Second'
        unit_zh = '年 |个月 |天 |小时 |分 |秒'
        if unit=='en':
            unit_list = unit_en.split('|')
        elif unit=='zh':
            unit_list = unit_zh.split('|')
        else:
            unit_list = unit_sim.split('|')
        t = time.gmtime(float(round(lngTimeSpan,3)))
        #print(t)
        total_time = ''
        total_time += ('%d%s'  % (t.tm_year-1970, unit_list[0])) if t.tm_year>1970 else '' 
        total_time += ('%d%s' % (t.tm_mon-1, unit_list[1])) if t.tm_mon>1 else '' 
        total_time += ('%d%s'   % (t.tm_mday-1, unit_list[2])) if t.tm_mday>1 else '' 
        tm = "%%H%s%%M%s%%S%s" % tuple(unit_list[3:])
        total_time += time.strftime(tm, t)
        return total_time
    

    最终结论

    最终得到的结果:总训练时间可以这样计算:

    ** 训练总用时(秒) = Num examples * Epoch / (examples/sec) (秒) **

    ** 训练总用时(秒) = Num steps / (global_step/sec) (秒) **

    ps: 看来使用CPU训练模型确实是非常慢,跑一个迭代要接受三个半小时。

    展开全文
  • 训练模型

    千次阅读 2019-06-20 17:10:57
    1 预训练模型由来 预训练模型是深度学习架构,已经过训练以执行大量数据上的特定任务(例如,识别图片中的分类问题)。这种训练不容易执行,并且通常需要大量资源,超出许多可用于深度学习模型的人可用的资源,我就...

    1 预训练模型由来

    预训练模型是深度学习架构,已经过训练以执行大量数据上的特定任务(例如,识别图片中的分类问题)。这种训练不容易执行,并且通常需要大量资源,超出许多可用于深度学习模型的人可用的资源,我就没有大批次GPU。在谈论预训练模型时,通常指的是在Imagenet上训练的CNN(用于视觉相关任务的架构)。ImageNet数据集包含超过1400万个图像,其中120万个图像分为1000个类别(大约100万个图像含边界框和注释)。

    2 预训练模型定义

    那么什么是预训练模型?这是在训练结束时结果比较好的一组权重值,研究人员分享出来供其他人使用。我们可以在github上找到许多具有权重的库,但是获取预训练模型的最简单方法可能是直接来自您选择的深度学习库。

    现在,上面是预训练模型的规范定义。您还可以找到预训练的模型来执行其他任务,例如物体检测姿势估计

    此外,最近研究人员已开始突破预训练模型的界限。在自然语言处理(使用文本的模型)的上下文中,我们已经有一段时间使用嵌入层。Word嵌入是一组数字的表示,其中的想法是类似的单词将以某种有用的方式表达。例如,我们可能希望'鹰派','鹰','蓝杰伊'的表现形式有一些相似之处,并且在其他方​​面也有所不同。用矢量表示单词的开创性论文是word2vec,这篇嵌入层的论文是我最喜欢的论文之一,最早源于80年代,Geoffrey Hinton 的论文

    尽管通过对大型数据集进行训练获得的单词的表示非常有用(并且以与预训练模型类似的方式共享),但是将单词嵌入作为预训练模型会有点拉伸。然而,通过杰里米霍华德塞巴斯蒂安鲁德的工作,真正的预训练模型已经到达NLP世界。它们往往非常强大,围绕着首先训练语言模型(在某种意义上理解某种语言中的文本而不仅仅是单词之间的相似性)的概念,并将其作为更高级任务的基础。有一种非常好的方法可以在大量数据上训练语言模型,而不需要对数据集进行人工注释。这意味着我们可以在尽可能多的数据上训练语言模型,比如整个维基百科!然后我们可以为特定任务(例如,情感分析)构建分类器并对模型进行微调,其中获取数据的成本更高。要了解有关这项非常有趣的工作的更多信息,请参阅论文虽然我建议先看看随附的网站,了解全局。

    3 预训练模型最好结果

    2018年NLP领域取得最重大突破!谷歌AI团队新发布的BERT模型,在机器阅读理解顶级水平测试SQuAD1.1中表现出惊人的成绩:全部两个衡量指标上全面超越人类,并且还在11种不同NLP测试中创出最佳成绩。毋庸置疑,BERT模型开启了NLP的新时代!而谷歌提出的BERT就是在OpenAI的GPT的基础上对预训练的目标进行了修改,并用更大的模型以及更多的数据去进行预训练,从而得到了目前为止最好的效果。

    旁注:如何从头开始训练架构以获得预训练的重量?这根本不容易回答,而且相关信息相当稀少。从纸张到纸张需要大量的跳跃才能将训练的所有方面(增强,训练 - 测试分裂,重量衰减,时间表等)拼凑在一起。我试着破解其中一些我过去做过的实验,你可以在这里这里看看这些尝试。更有趣的是DAWNBench比赛网站。在这里,各个团队已经尝试将他们的神经网络训练到某种程度的准确性,同时提高资源使用效率和优化速度。这通常不是架构最初如何训练,而是一个非常有用的信息源(因为代码也可用)。

    4 预训练模型

    4.1 官方版本综合版本

    4.1.1 pytorch

    NetworkTop-1 errorTop-5 error
    AlexNet43.4520.91
    VGG-1130.9811.37
    VGG-1330.0710.75
    VGG-1628.419.62
    VGG-1927.629.12
    VGG-11 with batch normalization29.6210.19
    VGG-13 with batch normalization28.459.63
    VGG-16 with batch normalization26.638.50
    VGG-19 with batch normalization25.768.15
    ResNet-1830.2410.92
    ResNet-3426.708.58
    ResNet-5023.857.13
    ResNet-10122.636.44
    ResNet-15221.695.94
    SqueezeNet 1.041.9019.58
    SqueezeNet 1.141.8119.38
    Densenet-12125.357.83
    Densenet-16924.007.00
    Densenet-20122.806.43
    Densenet-16122.356.20
    Inception v322.556.44

    4.1.2 fastai

    4.1.3 tensorflow

    4.1.4 keras

    ModelSizeTop-1 AccuracyTop-5 AccuracyParametersDepth
    Xception88 MB0.7900.94522,910,480126
    VGG16528 MB0.7130.901138,357,54423
    VGG19549 MB0.7130.900143,667,24026
    ResNet5099 MB0.7490.92125,636,712168
    InceptionV392 MB0.7790.93723,851,784159
    InceptionResNetV2215 MB0.8030.95355,873,736572
    MobileNet16 MB0.7040.8954,253,86488
    MobileNetV214 MB0.7130.9013,538,98488
    DenseNet12133 MB0.7500.9238,062,504121
    DenseNet16957 MB0.7620.93214,307,880169
    DenseNet20180 MB0.7730.93620,242,984201
    NASNetMobile23 MB0.7440.9195,326,716-
    NASNetLarge343 MB0.8250.96088,949,818-

    4.1.5 ONNX

    4.2 图片分类

    Model ClassReferenceDescription
    MobileNetSandler et al.顾名思义,MobileNet是为移动设备设计的架构。而搭建它的正是移动设备行业龙头谷歌。而我们之前附上链接的模型,带有对流行的 ImageNet(包含两万个类的数百万张图片的巨型数据库) 数据集的预训练权重。正如上文所提,MobileNet不止可以用于目标检测,同样它也适用于类似面部识别、地标识别、细致纹理分类等多种计算机视觉任务。.
    Top-5 error from paper - ~10%
    ResNetHe et al., He et al.Very deep CNN model (up to 152 layers), won the ImageNet Challenge in 2015.
    Top-5 error from paper - ~6%
    SqueezeNetIandola et al.A light-weight CNN providing Alexnet level accuracy with 50X fewer parameters.
    Top-5 error from paper - ~20%
    VGGSimonyan et al.Deep CNN model (upto 19 layers) which won the ImageNet Challenge in 2014.
    Top-5 error from paper - ~8%
    Bvlc_AlexNetKrizhevsky et al.Deep CNN model for Image Classification
    Bvlc_GoogleNetSzegedy et al.Deep CNN model for Image Classification
    Bvlc_reference_CaffeNetKrizhevsky et al.Deep CNN model for Image Classification
    Bvlc_reference_RCNN_ILSVRC13Girshick et al.Deep CNN model for Image Classification
    DenseNet121Huang et al.Deep CNN model for Image Classification
    Inception_v1Szegedy et al.Deep CNN model for Image Classification
    Inception_v2Szegedy et al.Deep CNN model for Image Classification
    ShuffleNetZhang et al.Deep CNN model for Image Classification
    ZFNet512Zeiler et al.Deep CNN model for Image Classification

    4.3 语义分割

    Model ClassReferenceDescription
    DUCWang et al.Deep CNN based model with >80% mIOU (mean Intersection Over Union) trained on urban street images
    FCNLong et al.contribute

    4.3.1 对象检测和分段

    Model ClassReferenceDescription
    Tiny_YOLOv2Redmon et al.Deep CNN model for Object Detection
    SSDLiu et al.contribute
    Faster-RCNNRen et al. 
    Mask-RCNNHe et al.Mask R-CNN 是为目标实例分割而开发的灵活框架。这个预训练模型是使用 Python 和 Keras 对 Mask R-CNN 技术的实现。它为给定图像中的目标的每个实例生成边界框和分割掩模,这个 GitHub 存储库提供了大量的资源来帮助新手入门。它包括 Mask R-CNN 的源代码,用于MS COCO 数据集的训练代码和预训练权重,Jupyter notebook 用于可视化检测流程的每个步骤。
    YOLO v2Redmon et al.说到 YOLO,这是一个广泛运用于深度学习的目标检测框架,这个库包含Keras 中的YOLOv2 实现。尽管开发者已经在各种目标图像上测试了这一框架,比如袋鼠检测、自动驾驶汽车,红细胞检测等等,他们依然发布了浣熊检测的预训练模型。这里你可以下载浣熊的数据集,并且开始训练这个预训练模型。这一数据集包含200个图片(160个训练集,40个测试集)。同样,你可以下载整个模型的预训练权重。而根据模型开发者所说,这些权重可以用于一类物体的目标检测。
    YOLO v3Redmon et al.contribute
    VGG-Face人脸识别模型从头开始创建一个人脸识别模型其实是一个令人害怕的任务。为了最终构建出令人满意的模型,你需要去寻找搜集并且标注大量的图像。因此,在这个领域使用预训练模型是非常有道理的。VGG-Face是一个有超过2百万张人脸图像,包含2622个独立身份的数据集。预训练模型已经通过以下方法构建完成 vgg-face-keras: 将vgg-face模型直接转化成keras模型,vgg-face-keras-fc:首先将vgg-face Caffe模型转化成mxnet模型,再将其转化成keras模型
    Deeplabv3+语义图像分割义图像分割是指将语义标签分配给图像的每个像素的任务。这些语义标签可以是‘天空’,‘汽车’,‘道路’,‘长颈鹿’等等。这项技术所要做的就是找到对象的边界因而需要对精度要求做出约束(这也就是与图像层面的分类任务的区别所在,分类任务对精度的要求更加宽松)。Deeplabv3 是Google最新的语义图像分割模型。 它最初是使用TensorFlow实现并且现在也已经通过keras实现了。这个GitHub仓库包含如何获取标签,如何使用自定义类别数的预训练模型的代码,当然也包含如何去追踪自己模型的代码。

    4.3.2 汽车识别

    Model ClassReferenceDescription
    ArcFace汽车识别众所周知,对一辆车分门别类有很多方法:譬如车体设计风格、车门数量、是否敞篷、车座数量等等。对于这一问题,我们需要将车辆图片分门别类,比如考虑品牌、设计模式、年限等等的分类。2012年,Tesla Model S 使用了斯坦福大学的车辆数据集(其中包含196类汽车的16185张图片)正是为了开发这一模型。Tesla Model S使用预训练过的VGG16、VGG19、InceptionV3模型进行训练。由于仅仅使用 3*3的卷积层增加深度,VGG这一简单特点为人所知,这里16和19分别代表两种VGG网络的层数。由于数据量较少,最简单的模型——VGG16是最精确的。这一神经网络的训练,使得在交叉验证集上达到了66.11%的准确度。而由于偏差方差的问题,反而使得比较复杂的模型譬如InceptionV3得到的准确率较低。

    4.3.3 面部检测和识别

    Model ClassReferenceDescription
    ArcFaceDeng et al.ArcFace is a CNN based model for face recognition which learns discriminative features of faces and produces embeddings for input face images.
    CNN CascadeLi et al.contribute

    4.3.4 表情识别

    Model ClassReferenceDescription
    Emotion FerPlusBarsoum et al.Deep CNN model for Emotion recognition

     


     

    4.3.5 性别区别

    Model ClassReferenceDescription
    Age and Gender Classification using Convolutional Neural NetworksLevi et al.contribute

     


     

    4.3.6 手写数字识别

    Model ClassReferenceDescription
    MNIST- Hand Written Digit RecognitionConvolutional Neural Network with MNISTDeep CNN model for hand written digit identification

     


     

    4.3.7 超分辨率

    Model ClassReferenceDescription
    Image Super resolution using deep convolutional networksDong et al.contribute

     


     

    4.3.8 风格迁移

    Model ClassReferenceDescription
    Unpaired Image to Image Translation using Cycle consistent Adversarial NetworkZhu et al.contribute

     


     

    4.3.9 生熟番茄分类

    Model ClassReferenceDescription
    生熟番茄分类 假定我们有几百个数据集的番茄图片,现在考虑如何如何区分它们,比方说按是否瑕疵,或者按成熟与否区分。这里我们考虑使用深度学习模型,而解决这个问题的关键技术就是图像处理。应对于这一分类问题,我们可以利用在Keras上预训练好的 VGG16模型来区分给定图片的番茄是生是熟。通过在ImageNet数据集上抓取的390张或生或熟的番茄图像进行训练,并在18张不同的验证集上进行测试。这些验证集图像上的总体结果如下所示:

    4.4 机器翻译

    Model ClassReferenceDescription
    Neural Machine Translation by jointly learning to align and translateBahdanau et al.contribute
    Google's Neural Machine Translation SystemWu et al.contribute

     


     

    4.4.1 语音处理

    Model ClassReferenceDescription
    Speech recognition with deep recurrent neural networksGraves et al.contribute
    Deep voice: Real time neural text to speechArik et al.contribute

    4.4.2 语言模型

    Model ClassReferenceDescription
    Deep Neural Network Language ModelsArisoy et al.contribute

    4.4.3 视觉问答

    Model ClassReferenceDescription
    VQA: Visual Question AnsweringAgrawal et al.contribute
    Yin and Yang: Balancing and Answering Binary Visual QuestionsZhang et al.contribute
    Making the V in VQA MatterGoyal et al.contribute
    Visual DialogDas et al.contribute

    4.4.4 其他有意思的模型

    4.5 Model Visualization

    You can see visualizations of each model's network architecture by using Netron.

    4.6 CV

    名称环境精度错误率
    物体检测c cuda  
    姿势估计keras  
    斯坦福CIFAR10pytorch tensorflow95.29% 
    斯坦福ImageNetpytorch tensorflow MXNet caffe93.94% 

    4.7 NLP

    4.7.1 多用途模型

    多用途模型是自然语言处理领域的热门话题。这些模型为机器翻译、问答系统、聊天机器人、情绪分析等我们感兴趣的自然语言处理应用提供了动力。这些多用途自然语言处理模型的核心组件是语言建模的概念。

    4.7.1.1 ULMFiT

    https://github.com/fastai/fastai/tree/master/courses/dl2/imdb_scripts
    ULMFiT 由 fast.ai 的 Jeremy Howard 和 DeepMind 的 Sebastian Ruder 提出并设计。你可以说 ULMFiT 是去年启动迁移学习派对的发行版。
    正如我们在本文中所述,ULMFiT 使用新的自然语言生成技术实现了最先进的结果。该方法包括在 Wikitext 103 数据集上训练的预处理语言模型进行微调,使其不会忘记以前所学的内容,从而将其微调为一个新的数据集。

    4.7.1.2 Transformer

    GitHub 项目地址:https://github.com/tensorflow/models/tree/master/official/transformer

    Transformer 架构是自然语言处理领域最近几乎所有主要发展的核心,2017 年由 Google 推出。当时,RNN 递归神经网络被用于语言任务,如机器翻译和问答系统。

    这种 Transformer 架构的性能优于 RNN 和 CNN(卷积神经网络)。而且训练模型所需的计算资源也大为减少。对自然语言处理的每个人来讲,这种结果是双赢的局面。
    根据 Google 的说法,Transformer“应用了一种自注意力(self-attention)机制,可以直接模拟句子中所有单词之间的关系,无论这些单词的位置如何”。它使用固定大小的上下文(也就是前面的单词)来实现这一点。是不是觉得太复杂了?让我们举个例子来简化这个。
    “She found the shells on the bank of the river.”模型需要理解这里的“bank”是指河岸,而不是金融机构。Transformer 只需一步就能理解这一点。我建议你阅读下面给出链接的完整论文,以了解 Transformer 的工作原理。它会让你大吃一惊。
    Google 去年发布了一款 Universal Transformer 的改进版。还有一个更新、更直观的版本,叫做 Transformer-XL,我们将稍后予以介绍。

    有关 Transformer 的更多信息,请参阅以下资源:

    4.7.1.3 BERT

    GitHub 项目地址:https://github.com/google-research/bert

    自 Google 公布他们的结果以来,BERT 就一直在掀起波澜,然后 Google 开源了它背后的代码。我们可以讨论这是否标志着“自然语言处理领域的新时代”,但毫无疑问的是,BERT 是一个非常有用的框架,可以很好地推广到各种自然语言处理任务。
    BERT,是 Bidirectional Encoder Representations(双向编码器表示)的缩写,它从单词的两边(左边和右边)来考虑上下文。以前所有的努力方向,都是一次只考虑单词的一边,要么是左边,要么是右边。这种双向性有助于模型更好地理解使用单词的上下文。此外,BERT 的设计目标是能够进行多任务学习,也就是说,它可以同时执行不同的自然语言处理任务。

    BERT 是第一个无监督、深度双向的自然语言处理模型预训练系统。它只使用纯文本语料库进行训练。

    在发布的时候,BERT 在 11 个自然语言处理任务上取得了最先进的结果。这真是相当了不起的成就!你可以在短短几个小时内(在单个 GPU 上)使用 BERT 训练自己的自然语言处理模型(例如问答系统)。

    4.7.1.4 Google Transformer-XL

    GitHub 项目地址:https://github.com/kimiyoung/transformer-xl

    从长远来看,Google 的这一发行版对自然语言处理领域来说可能是一个非常重要的版本。如果你是一名菜鸟,这个概念可能会变得有点棘手,所以我建议你多读几遍来掌握它。我还会在这一节中提供一些资源,帮助你开始入门 Transformer-XL。

    想象一下,你正在读一本书,读到一半的时候,书中突然出现了某个单词或句子,而这些在这本书的开头都提到过。这时候,你我都能回忆起那些单词或句子指的是什么意思。但机器很难建立模拟长期依赖(long-term dependency)的模型,这是可以理解的。

    如上所述,实现这一点的一种方法是使用 Transformer。但它们是在固定长度的上下文实现的。换句话说,如果使用这种方法,就没有多少灵活性而言。

    而 Transformer-XL 很好地弥补了这一缺陷。它由 Google AI 团队开发,是一种新型的自然语言处理架构,可以帮助机器理解超出固定长度限制的上下文。Transformer-XL 比普通的 Transformer 要快上 1800 倍。
    如你现在所预测的,Transformer-XL 在各种语言建模基准 / 数据集上实现了最新的、最先进的结果。下面是他们网页上的一张表,展示了这一点:

    image

    上面的链接和下面提到的 Transformer-XL GitHub 存储库包含 PyTorch 和 TensorFlow 中的代码。

    有关 Transformer-XL 的更多信息,请参阅以下资源:

    4.7.1.5 OpenAI GPT-2

    GitHub 项目地址:https://github.com/openai/gpt-2

    目前这是一个颇有争议的条目。一些人可能会认为 GPT-2 的发布就是 OpenAI 的营销噱头。我当然理解他们的想法。然而,我还是认为,至少尝试一下 OpenAI 发布的代码还是很重要的。
    首先,我得为那些不知道我在说什么的人们提供一些背景信息。OpenAI 在 2 月份的时候发表了一篇博文,声称他们已经设计了一个自然语言处理模型,表现非常出色,以至于他们担心被恶意使用,而没有选择发布完整版本。这当然引起了社区的关注。

    GPT-2 经过训练后,可以预测 40GB 互联网文本数据的下一个出现的单词。这个框架也是基于 Transformer 的模型,该模型在 800 万个 Web 页面的数据集进行训练。他们在网站公布的结果令人震撼。这个模型能够根据我们输入的寥寥可数的句子就编织出一个完全清晰的故事,请看看下面的这个例子:

    4.7.2 词嵌入

    我们使用的大多数机器学习和深度学习算法都无法直接处理字符串和纯文本。这些技术要求我们必须先将文本数据转换为数字,然后才能执行任何任务(如回归和分类)。
    因此,简单来说,词嵌入就是为了将文本块转换为用于执行自然语言处理任务的数字。词嵌入格式通常尝试使用字典将单词映射到向量。
    你可以在下面的文章中,更深入地理解词嵌入、它的不同类型以及如何在数据集中使用它们。如果你不熟悉这个概念的话,我认为这份指南对你来说是必读的:

    《An Intuitive Understanding of Word Embeddings: From Count Vectors to Word2Vec》(《直观理解词嵌入:从计数向量到 Word2Vec》:https://www.analyticsvidhya.com/blog/2017/06/word-embeddings-count-word2veec/?utm_source=blog&utm_medium=top-pretrained-models-nlp-article

    在这一节中,我们将介绍自然语言处理领域中两个最先进的词嵌入。我还提供了教程的链接,这样你就可以对每个主题有实际的理解。

    4.7.2.1 ELMo

    GitHub 项目地址:https://github.com/allenai/allennlp/blob/master/tutorials/how_to/elmo.md
    不,这个 ELMo 可不是《Sesame Street》(《芝麻街》,美国芝麻街工作制坐坐的一档著名的儿童教育电视节目)的角色。但这个 ELMo(是 Embedding from Language Models 的缩写)在构建自然语言处理模的上下文非常有用。
    ELMo 词向量表示(word representations)考虑用于计算词嵌入的完整输入语句。因此“read”这个词在不同的上下文中有不同的 ELMo 向量。这点与旧词嵌入截然不同,对旧词嵌入而言,无论单词在什么上下文中使用,这个单词都会分配到相同的向量。
    有关 ELMo 更多的信息,请参阅以下资源:

    4.7.2.2 Flair

    Flair 并不完全是词嵌入,而是词嵌入的组合。我们可以称 Flair 更多的是一个自然语言处理程序库,它结合了 GloVe、BERT、EMLo 等嵌入。Zalando Research 的优秀人员开发并开源了 Flair。
    该团队已经为以下自然语言处理任务发布了几个预训练模型:

    • Name-Entity Recognition (NER,名称 - 实体识别)
    • Parts-of-Speech Tagging (PoS,词性标注)
    • 文本分类
    • 训练自定义模型

      <p>image.png</p>
      <br>
      “Flair Embedding”是封装在 Flair 库中的签名嵌入。它由上下文字符串嵌入提供支持。你应该自诩阅读这篇文章《Introduction to Flair for NLP: A Simple yet Powerful State-of-the-Art NLP Library》(《Flair 简介:简单而强大的,最先进的自然语言处理库》)来了解支持 Flair 的核心组件:<a href="https://links.jianshu.com/go?to=https%3A%2F%2Fwww.analyticsvidhya.com%2Fblog%2F2019%2F02%2Fflair-nlp-library-python%2F%3Futm_source%3Dblog%26utm_medium%3Dtop-pretrained-models-nlp-article" rel="nofollow" target="_blank">https://www.analyticsvidhya.com/blog/2019/02/flair-nlp-library-python/?utm_source=blog&amp;utm_medium=top-pretrained-models-nlp-article</a><br>
      我特别喜欢 Flair 的地方就是它能够支持多种语言。如此多的自然语言处理版本都只做英语方面的任务。如果自然语言处理想在全球范围内获得吸引力的话,我们就必须超越这一点!<br>
      有关 Flair 更多的信息,请参阅以下资源:</li>
      <li>《Introduction to Flair for NLP: A Simple yet Powerful State-of-the-Art NLP Library》(《Flair 简介:简单而强大的,最先进的自然语言处理库》):<a href="https://links.jianshu.com/go?to=https%3A%2F%2Fwww.analyticsvidhya.com%2Fblog%2F2019%2F02%2Fflair-nlp-library-python%2F%3Futm_source%3Dblog%26utm_medium%3Dtop-pretrained-models-nlp-article" rel="nofollow" target="_blank">https://www.analyticsvidhya.com/blog/2019/02/flair-nlp-library-python/?utm_source=blog&amp;utm_medium=top-pretrained-models-nlp-article</a><br>
      Flair 的预训练模型:<a href="https://links.jianshu.com/go?to=https%3A%2F%2Fgithub.com%2Fzalandoresearch%2Fflair" rel="nofollow" target="_blank">https://github.com/zalandoresearch/flair</a><br>
      还不确定?那么,看下面这张比较表就会让你明白:</li>
      <li>GitHub 项目地址:<a href="https://links.jianshu.com/go?to=https%3A%2F%2Fgithub.com%2Fzalandoresearch%2Fflair" rel="nofollow" target="_blank">https://github.com/zalandoresearch/flair</a></li>
      

    4.7.3 FairSeq Seq2Seq模型

    4.7.4

    4.7.5

    名称环境精度错误率
    Thomas Wolf   
    Junseong Kim   

    4.7.5



    作者:readilen
    链接:https://www.jianshu.com/p/7e13a498bd63
    来源:简书
    简书著作权归作者所有,任何形式的转载都请联系作者获得授权并注明出处。

    展开全文
  • 在服务器上使用两块显卡训练模型训练代码中有这句 model = torch.nn.DataParallel(model).cuda() 在自己的电脑上加载模型的时候,因为电脑只有CPU,所以需要在加载时指明cpu checkpoint = torch.load(args.model...
  • 在前面几篇文章中详细介绍了MXNet的一些特点以及入门基础知识,本篇文章主要介绍如何使用MXNet来训练模型、加载模型进行预测、预训练模型以及MXNet中GPU使用的相关知识。 在介绍训练模型之前,先介绍MXNet如何使用...
  • v4目标检测算法详解及预训练模型使用与自己训练模型一、YOLO简介二、YOLO v3三、YOLO v4四、预训练模型使用(基于Darknet的GPU版本)五、自己训练模型(使用GPU) 一、YOLO简介 YOLO是目前比较流行的目标检测算法,...
  • 由于抢不到实验室的gpu资源,决定把毕设需要的训练部署在远程cpu服务器上(gpu服务器太贵搞不起),为了测试模型在gpu和cpu之间来回转换时是否会影响模型的性能,特别做了以下实验。 - 首先明确测试的四种情况: ...
  • 速度提升了,时间自然节约了不少,正在欢喜之间猛然发现训练出来的权重文件在本地的cpu机器加载的时候报错无法用做预测。报错信息如下: 2018-07-19 18:07:21.957595: I tensorflow/core/platform/cpu_feature_...
  • 使用GPU训练模型

    千次阅读 2020-07-17 23:07:35
    公众号后台回复关键字:Pytorch,获取项目github地址。Pytorch没有官方的高阶API。一般通过nn.Module来构建模型并编写自定义训练循环。为了更加方便地训练模型,作者...
  • 我的电脑配置: ...今天我测试了一下使用keras框架训练一个简单的卷积神经网络,在分别测试cpu和gpu所消耗的时间之前,我其实心里是明白的,节约的时间肯定会比42%要多,因为卷积神经网络的数据特性使然,...
  • pytorch(4)Pytorch模型训练时从CPU与GPU之间的转换

    千次阅读 热门讨论 2020-11-09 00:05:51
    使用Pytorch写的模型: 对模型和相应的数据使用.cuda()处理。通过这种方式,我们就可以将内存中的数据复制到GPU的显存中去。从而可以通过GPU来进行运算了。 另外一种方式,使用.to(device)的方式,将cpu的数据切换...
  • Tensorflow训练模型越来越慢

    千次阅读 2019-05-15 13:27:16
    1 解决方案 【方案一】 载入模型结构放在全局,即tensorflow会话外层。 '''载入模型结构:最关键的一步''' saver = tf.train.Saver() ... '''开始训练''' _, loss_1, acc, summary = sess.run(...
  • BERT 中文预训练模型使用

    万次阅读 2019-04-27 16:44:15
    只要是从事文本处理相关工作的人应该都知道 Google 最新发布的 BERT 模型,该模型属于是词向量的预训练模型,一经提出便横扫各大 NLP 任务,最近 Google 公司如约推出了中文词向量的预训练模型,不得不说这是一件...
  • NLP预训练模型综述

    千次阅读 2020-10-30 22:16:41
    文章目录文章介绍背景2.1语言表示学习非上下文词嵌2.2 神经上下文编码器2.2.1 序列模型s2.2.2 非序列模型2.2.3 分析2.3 为什么预训练?2.4 NLP的PTMs的历史2.4.1 第一代PTM:预先训练的词嵌入将单词表示为密集的矢量...
  • BERT模型训练到部署

    万次阅读 多人点赞 2019-04-15 23:38:03
    这段时间使用BERT模型完成了从数据准备到生产部署的全流程,在这里整理出来,方便大家参考。 在下面我将以一个“手机评论的情感分类”为例子,简要说明从训练到部署的全部流程。最终完成后可以使用一个网页进行交互...
  • 训练模型时,对梯度进行截断 import torch as t _ = nn.utils.clip_grad_norm_(model.parameters(), clip) 2.load预训练好的模型 cpu-&amp;gt;cpu或者gpu-&amp;gt;gpu,直接 model.load_state_dict(t.load...
  • 随着深度学习模型复杂度和数据集规模的增大,计算效率成为了不可忽视的问题。GPU凭借强大的并行计算能力,成为深度学习加速的标配。然而,由于服务器的显存非常有限,随着训练样本越来越大,显存连...
  • 文章目录一 项目展示二 依赖环境与导读2.1依赖环境2.2 本文导读三 模型训练3.1 新手也能做对的教学3.2 高手也爱的黑科技:无损的半精度模型模型优化4.1 Openvino 介绍 可以参见这篇博客4.2 Openvino安装4.3 Open...
  • 在所有的数据都处理完了之后,接下来就可以进行模型训练了。 在Github上FaceNet项目的介绍中有softmax和论文中提到的三元损失训练triplet两种方式,这边简单的介绍下softmax的训练方法。 FaceNet已经将所有的...
  • 训练模型,无疑是机器学习中最耗费时间和成本最高的部分。在GPU上训练模型可以将训练速度提升接近40倍,将2天的训练时间减少到几个小时。但是——提升速度通常意味着你要花钱。还好小编有幸遇到了一个95后小盆友...
  • PyTorch的TorchVision模块中包含多个用于图像分类的预训练模型,TorchVision包由流行的数据集、模型结构和用于计算机视觉的通用图像转换函数组成。一般来讲,如果你进入计算机视觉和使用PyTorch,TorchVision可以...
  • 本文记录利用resnet18预训练模型进行迁移学习,在自己的训练数据集上进行重新训练。相关代码重点部分分别介绍如下: model=torchvision.models.resnet18(pretrained=True) num_features=model.fc.in_features ...
  • FaceBook的Demucs音乐分轨预训练模型

    千次阅读 2020-01-10 17:54:42
    音乐分轨预训练模型 常规的音乐文件是由若干个波形叠加而成的,每个波形分别对应不同的音轨,例如人声,鼓,贝斯,键盘…等等。在音乐信息检索(MIR)领域,音乐的分轨一直是一个热门话题,当前已有的分轨模型主要有...
  • 日萌社 人工智能AI:Keras PyTorch MXNet TensorFlow PaddlePaddle 深度学习实战(不定时更新) 第二章:迁移学习 2.1 迁移学习理论 学习目标: ...预训练模型(Pretrained model): 一般情况下...
  • 记录一下之前安装TensorFlow-GPU版本的流程,防止之后时间久了忘记。
  • 说明:Tensorflow官方的models项目(https://github.com/tensorflow/models)中已经支持了各种模型训练和验证,并且有详细的教程,但是在models/research/Object_detection的教程中并没有提及如何进行分布式训练,...
  • 显著性检测网络模型是基于PyTorch深度学习框架进行搭建并参与训练的,在实际应用和生产中,由于要满足低延迟和严格部署要求,通常选用C++来进行推理过程。这里的显著图推理模型C++转换过程主要由以下几个步骤组成:...
  • 【MaixPy教程】用maixHub训练模型进行开源硬件识别

    千次阅读 多人点赞 2020-04-23 21:00:47
    【MaixPy教程】用maixHub训练模型进行开源硬件识别 前言 年前参加了dfrobot的活动:DF冬季AI挑战赛有幸进入第二轮,大方的木子给了200的优惠券。在逛了DF商城时候无意间发现了一个宝贝:Maix Dock AI开发板!又有...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 33,135
精华内容 13,254
关键字:

cpu训练模型时间