精华内容
下载资源
问答
  • 自己写深度学习框架
    千次阅读
    2019-06-30 20:54:52

    概述


    简介

    人工智能诞生于1950年代,深度学习是机器学习的一个特定子领域:从数据中学习表示的一种新方法,强调学习越来越有意义的表示的连续层(layers)。

    深度学习将数据中高层次化的模式建模成复杂的多层网络,需要进行大量的计算来构建一个有用的模型。

    在深度学习中,这些分层的表示(几乎总是)是通过称为神经网(neural networks)的模型来学习的,这些模型的结构是逐层堆叠在一起的文字层。

    就目的而言,深度学习是一个从数据中学习表征的数学框架。

    机器学习是关于将输入(如图像)映射到目标(如标签“cat”),这是通过观察许多输入和目标的样例来完成的。

    总的来说,有三种技术力量推动着机器学习的进步:

    • 硬件
    • 数据和基准测试
    • 算法的进步
    解决的问题

    虽然深度学习是机器学习的一个相当古老的分支领域,但它直到2010年代初才开始崭露头角。

    数据科学家使用深度学习来解决企业各个方面非常实际的问题,如:

    • 语深度学习能够处理音频和文本数据,可应用于语言翻译(GMNT谷歌翻译)、语音识别、语音合成、情感分析以及自然语言生成等领域
    • 高精地图和图像识别应用,深度学习可以应用于图像分类(ResNet50),目标检测(Mask R-CNN),图像分割(UNET),图像恢复等领域
    • 支付系统提供商使用深度学习实时识别可疑交易
    • 具有大型数据中心和计算机网络的机构使用深度学习从日志中挖掘信息检测威胁
    • 汽车制造商和汽车运营商使用深度学习挖掘传感器数据预测部分车辆故障
    • 具有大型复杂供应链的公司使用深度学习预测延迟和生产瓶颈
    • 预测人幼年或老年时的外貌,可以帮助警方寻找失踪人口
    优势

    深度学习的优势:

    • 它能从特征中检测复杂的相互作用
    • 它能从几乎没有处理的原始数据中学习低层次的特征
    • 它能处理高基数类成员
    • 它能处理未标记的数据
    缺点

    深度学习的劣势:

    • 生成的模型难以解释,这些模型可能有许多层和上千个节点;单独解释每一个是不可能的
    • 对训练数据过度学习,算法“记住了”训练数据的特征,在模型将要使用的生产环境中,这些被记住的特征可能会也可能不会被用到
    • 需要大量的计算性能来构建,虽然计算成本已经大幅下降,但是计算仍旧不是免费的。对于小数据集的简单问题,在计算开销和时间相同的情况下,深度学习可能不会比更简单方法产生足够的额外效果
    • 复杂性,在测试数据上表现良好但无法落实的预测模型是没有实际用途的

    基础算法


    近年来,随着海量数据的积累和计算机硬件计算能力的提升,深度学习越来越广泛应用在各个方面。

    深度学习没有足够的数据支持深度学习,有时用不同的算法可以更好地解决这个问题。

    学习和掌握基本的算法,不能立刻解决所有的问题,但可以在面对问题的时候有更多更优的选择,也可以基于这些算法构建出新的适应问题的算法。

    经典的深度学习方法包括下述方面:

    1. 概率模型
    • 概率建模是统计学原理在数据分析中的应用,这类算法中最著名的算法之一是朴素贝叶斯算法
    • 朴素贝叶斯是一种基于贝叶斯定理的机器学习分类器,它假设输入数据中的特征都是独立的
    • 一个密切相关的模型是逻辑回归(简称logreg),是一个分类算法而不是回归算法
    1. 早期神经网络
    • 神经网络第一次成功的实际应用是在1989年贝尔公司,当Yann LeCun将早期的卷积神经网络和反向传播的思想结合起来,并将它们应用到手写数字的分类问题上时
    • 在20世纪90年代,美国邮政服务公司(United States Postal Service)使用该网络来自动读取邮件信封上的邮编
    • 反向传播算法是一种利用梯度下降优化训练参数操作链的方法
    1. 内核模型
    • 核方法是一类分类算法,其中最著名的是支持向量机(SVM)
    • SVMs旨在通过在属于两个不同类别的两组点之间找到好的决策边界来解决分类问题
    1. 决策树,随机森林,以及梯度增强机
    • 决策树是类似流程图的结构,对输入数据点进行分类或预测给定输入的输出值
    • 随机森林算法引入了一种健壮的、实用的决策树学习方法,它涉及到构建大量的专门决策树,然后集成它们的输出
    • 梯度提升机很像随机森林,是一种基于综合弱预测模型(通常是决策树)的机器学习技术
    1. 神经网络
    • 2011年,来自IDSIA的Dan Ciresan开始通过gpu训练的深度神经网络赢得学术图像分类竞赛,这是现代深度学习的第一次实际成功
    • 自2012年以来,深度卷积神经网络(convnets)成为所有计算机视觉任务的首选算法

    主流框架介绍


    深度学习框架已经实现了核心算法,在学习和实际工程应用中就不必重新实现复杂的模型,如卷积神经网络(CNN)或循环神经网络(RNN)。

    使用深度学习框架的好处:

    • 不需要手写CUDA 代码能跑GPU
    • 容易构建大的计算图(computational graphs)
    • 自动实现计算图中的梯度计算

    这里仅对比较常用的四种深度学习框架作一简要介绍,后期深入学习。

    1. TensorFlow

    2015年11月谷歌(Google)出品,基于Python和C++编写,TensorFlow一经推出就获得了极大的关注,并迅速成为如今用户最多的深度学习框架。2019年3月已发布最新的TensorFlow2.0 版本。

    优点:

    • 自带tensorboard可视化工具,能够让用户实时监控观察训练过程
    • 拥有大量的开发者,有详细的说明文档、可查询资料多
    • 支持多GPU、分布式训练,跨平台运行能力强
    • 具备不局限于深度学习的多种用途,还有支持强化学习和其他算法的工具

    缺点:

    • 频繁变动的接口。TensorFlow的接口一直处于快速迭代之中,并且没有很好地考虑向后兼容性,这导致现在许多开源代码已经无法在新版的TensorFlow上运行,同时也间接导致了许多基于TensorFlow的第三方框架出现BUG
    • 接口设计过于晦涩难懂,在设计TensorFlow时,创造了图、会话、命名空间、PlaceHolder等诸多抽象概念,对初学者来说较难上手。(不过,据称新的2.0版本对接口设计有了重大改进,笔者也很期待)
    • 运行明显比其他框架速度慢
    1. Keras

    Keras 于2015年3月首次发布,拥有“为人类而不是机器设计的API”,得到Google的支持。

    用于快速构建深度学习原型的高层神经网络库,由纯Python编写而成,以TensorFlow,CNTK,Theano和MXNet为底层引擎,提供简单易用的API接口,能够极大地减少一般应用下用户的工作量。

    优点:

    • 更简洁,更简单的API
    • 丰富的教程和可重复使用的代码
    • 更多的部署选项(直接并且通过TensorFlow后端),更简单的模型导出
    • 支持多GPU训练

    缺点:

    • 过度封装导致丧失灵活性,导致用户在新增操作或是获取底层的数据信息时过于困难
    • 许多BUG都隐藏于封装之中,无法调试细节
    • 初学者容易依赖于 Keras 的易使用性而忽略底层原理
    1. PyTorch
      PyTorch于2016年10月发布,是一款专注于直接处理数组表达式的低级API。 前身是 Torch(一个基于 Lua 语言的深度学习库)。

    Facebook 人工智能研究院对PyTorch提供了强力支持。

    PyTorch 支持动态计算图,为更具数学倾向的用户提供了更低层次的方法和更多的灵活性,目前许多新发表的论文都采用PyTorch作为论文实现的工具,成为学术研究的首选解决方案。

    优点:

    • 简洁易用:更少的抽象,更直观的设计,建模过程简单透明,所思即所得,代码易于理解
    • 可以为使用者提供更多关于深度学习实现的细节,如反向传播和其他训练过程
    • 活跃的社区:提供完整的文档和指南,作者亲自维护的论坛供用户交流和求教问题。当然与Tensorflow相比,社区还是更小
    • 代码很Pythonic(简洁、优雅),更好的调试功能,默认的运行模式更像传统的编程,您可以使用常见的调试工具如pdb,ipdb或PyCharm调试器

    缺点:

    • 无可视化接口和工具
    • 导出模型不可移植,工业部署不成熟
    • 代码冗余量较大
    1. Caffe/Caffe2.0
      Caffe的全称是Convolutional Architecture for Fast Feature Embedding,它是一个清晰、高效的深度学习框架,于2013年底由加州大学伯克利分校开发,核心语言是C++。

    它支持命令行、Python和MATLAB接口。Caffe的一个重要特色是可以在不编写代码的情况下训练和部署模型。

    优点:

    • 核心程序用C++编写,因此更高效,适合工业界开发
    • 网络结构都是以配置文件形式定义,不需要用代码设计网络
    • 拥有大量的训练好的经典模型(AlexNet、VGG、Inception)在其 Model Zoo里

    缺点:

    • 缺少灵活性和扩展性:Caffe是基于层的网络结构,如果要实现一个新的层,用户必须要利用C++实现它的前向和后向传播代码。如果需要新层运行在GPU上,则同时还需要用户自己实现CUDA代码。这种限制使得不熟悉C++和CUDA的用户扩展Caffe十分困难
    • 依赖众多环境,难以配置,GitHub上基于Caffe的新的项目越来越少,已经很少用于学术界
    • 缺乏对递归网络RNN和语言建模的支持,不适用于文本、声音或时间序列数据等其他类型的深度学习应用

    总结


    • 如果你最终想找一份深度学习的工作,最好学习下TensorFlow
    • 如果你是深度学习的初学者,想要快速入门,建议从Keras开始
    • 如果你是一名科研工作者,倾向于理解你的模型真正在做什么,那么就考虑选择PyTorch
    • 如果您是C++熟练使用者,并对CUDA计算游刃有余,你可以考虑选择Caffe

    综上,深度学习框架众多,并无最好与最坏之分。

    最重要的还是要深刻理解神经网络的基本概念,根据自己想要实现网络的类型,基于自己擅长的编程语言,考虑项目本身的特点和目标,选择最适合您的框架。


    参考资料:
    深度学习:实际问题解决指南
    Python深度学习(一)深度学习基础
    深度学习框架对比与选择

    更多相关内容
  • 本文首先从深度学习的流程开始分析,对神经网络中的关键组件抽象,确定基本框架;然后再对框架里各个组件进行代码...加入极市CV技术交流群,走在计算机视觉的最前沿当前深度学习框架越来越成熟,对于使用者而言封装程

    本文首先从深度学习的流程开始分析,对神经网络中的关键组件抽象,确定基本框架;然后再对框架里各个组件进行代码实现;最后基于这个框架实现了一个 MNIST 分类的示例,并与 Tensorflow 做了简单的对比验证。喜欢本文,就请点赞、收藏、关注。

    当前深度学习框架越来越成熟,对于使用者而言封装程度越来越高,好处就是现在可以非常快速地将这些框架作为工具使用,用非常少的代码就可以构建模型进行实验,坏处就是可能背后地实现都被隐藏起来了。在这篇文章里笔者将设计和实现一个、轻量级的(约 200 行)、易于扩展的深度学习框架 tinynn(基于 Python 和 Numpy 实现),希望对大家了解深度学习的基本组件、框架的设计和实现有一定的帮助。

    本文首先会从深度学习的流程开始分析,对神经网络中的关键组件抽象,确定基本框架;然后再对框架里各个组件进行代码实现;最后基于这个框架实现了一个 MNIST 分类的示例,并与 Tensorflow 做了简单的对比验证。

    目录

    1. 组件抽象

    2. 组件实现

    3. 整体结构

    4. MNIST 例子

    5. 总结

    6. 附录

    7. 参考

    组件抽象

    首先考虑神经网络运算的流程,神经网络运算主要包含训练 training 和预测 predict (或 inference) 两个阶段,训练的基本流程是:输入数据 -> 网络层前向传播 -> 计算损失 -> 网络层反向传播梯度 -> 更新参数,预测的基本流程是 输入数据 -> 网络层前向传播 -> 输出结果。从运算的角度看,主要可以分为三种类型的计算:

    1. 数据在网络层之间的流动:前向传播和反向传播可以看做是张量 Tensor(多维数组)在网络层之间的流动(前向传播流动的是输入输出,反向传播流动的是梯度),每个网络层会进行一定的运算,然后将结果输入给下一层

    2. 计算损失:衔接前向和反向传播的中间过程,定义了模型的输出与真实值之间的差异,用来后续提供反向传播所需的信息

    3. 参数更新:使用计算得到的梯度对网络参数进行更新的一类计算

    基于这个三种类型,我们可以对网络的基本组件做一个抽象

    • tensor 张量,这个是神经网络中数据的基本单位

    • layer 网络层,负责接收上一层的输入,进行该层的运算,将结果输出给下一层,由于 tensor 的流动有前向和反向两个方向,因此对于每种类型网络层我们都需要同时实现 forward 和 backward 两种运算

    • loss 损失,在给定模型预测值与真实值之后,该组件输出损失值以及关于最后一层的梯度(用于梯度回传)

    • optimizer 优化器,负责使用梯度更新模型的参数

    然后我们还需要一些组件把上面这个 4 种基本组件整合到一起,形成一个 pipeline

    • net 组件负责管理 tensor 在 layers 之间的前向和反向传播,同时能提供获取参数、设置参数、获取梯度的接口

    • model 组件负责整合所有组件,形成整个 pipeline。即 net 组件进行前向传播 -> losses 组件计算损失和梯度 -> net 组件将梯度反向传播 -> optimizer 组件将梯度更新到参数。

    基本的框架图如下图

    图片

    组件实现

    按照上面的抽象,我们可以写出整个流程代码如下。

    # define model
    net = Net([layer1, layer2, ...])
    model = Model(net, loss_fn, optimizer)
    
    # training
    pred = model.forward(train_X)
    loss, grads = model.backward(pred, train_Y)
    model.apply_grad(grads)
    
    # inference
    test_pred = model.forward(test_X)
    

    首先定义 net,net 的输入是多个网络层,然后将 net、loss、optimizer 一起传给 model。model 实现了 forward、backward 和 apply_grad 三个接口分别对应前向传播、反向传播和参数更新三个功能。接下来我们看这里边各个部分分别如何实现。

    tensor

    tensor 张量是神经网络中基本的数据单位,我们这里直接使用 numpy.ndarray 类作为 tensor 类的实现

    numpy.ndarray :https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html

    layer

    上面流程代码中 model 进行 forward 和 backward,其实底层都是网络层在进行实际运算,因此网络层需要有提供 forward 和 backward 接口进行对应的运算。同时还应该将该层的参数和梯度记录下来。先实现一个基类如下

    # layer.py
    class Layer(object):
        def __init__(self, name):
            self.name = name
            self.params, self.grads = None, None
    
        def forward(self, inputs):
            raise NotImplementedError
    
        def backward(self, grad):
            raise NotImplementedError
    

    最基础的一种网络层是全连接网络层,实现如下。forward 方法接收上层的输入 inputs,实现 的运算;backward 的方法接收来自上层的梯度,计算关于参数 和输入的梯度,然后返回关于输入的梯度。这三个梯度的推导可以见附录,这里直接给出实现。w_init 和 b_init 分别是参数 和 的初始化器,这个我们在另外的一个实现初始化器中文件 initializer.py 去实现,这部分不是核心部件,所以在这里不展开介绍。

    # layer.py
    class Dense(Layer):
        def __init__(self, num_in, num_out,
                     w_init=XavierUniformInit(),
                     b_init=ZerosInit()):
            super().__init__("Linear")
    
            self.params = {
                "w": w_init([num_in, num_out]),
                "b": b_init([1, num_out])}
    
            self.inputs = None
    
        def forward(self, inputs):
            self.inputs = inputs
            return inputs @ self.params["w"] + self.params["b"]
    
        def backward(self, grad):
            self.grads["w"] = self.inputs.T @ grad
            self.grads["b"] = np.sum(grad, axis=0)
            return grad @ self.params["w"].T
    

    同时神经网络中的另一个重要的部分是激活函数。激活函数可以看做是一种网络层,同样需要实现 forward 和 backward 方法。我们通过继承 Layer 类实现激活函数类,这里实现了最常用的 ReLU 激活函数。func 和 derivation_func 方法分别实现对应激活函数的正向计算和梯度计算。

    # layer.py
    class Activation(Layer):
        """Base activation layer"""
        def __init__(self, name):
            super().__init__(name)
            self.inputs = None
    
        def forward(self, inputs):
            self.inputs = inputs
            return self.func(inputs)
    
        def backward(self, grad):
            return self.derivative_func(self.inputs) * grad
    
        def func(self, x):
            raise NotImplementedError
    
        def derivative_func(self, x):
            raise NotImplementedError
    
    
    class ReLU(Activation):
        """ReLU activation function"""
        def __init__(self):
            super().__init__("ReLU")
    
        def func(self, x):
            return np.maximum(x, 0.0)
    
        def derivative_func(self, x):
            return x > 0.0
    

    net

    上文提到 net 类负责管理 tensor 在 layers 之间的前向和反向传播。forward 方法很简单,按顺序遍历所有层,每层计算的输出作为下一层的输入;backward 则逆序遍历所有层,将每层的梯度作为下一层的输入。这里我们还将每个网络层参数的梯度保存下来返回,后面参数更新需要用到。另外 net 类还实现了获取参数、设置参数、获取梯度的接口,也是后面参数更新时需要用到

    # net.py
    class Net(object):
        def __init__(self, layers):
            self.layers = layers
    
        def forward(self, inputs):
            for layer in self.layers:
                inputs = layer.forward(inputs)
            return inputs
    
        def backward(self, grad):
            all_grads = []
            for layer in reversed(self.layers):
                grad = layer.backward(grad)
                all_grads.append(layer.grads)
            return all_grads[::-1]
    
        def get_params_and_grads(self):
            for layer in self.layers:
                yield layer.params, layer.grads
    
        def get_parameters(self):
            return [layer.params for layer in self.layers]
    
        def set_parameters(self, params):
            for i, layer in enumerate(self.layers):
                for key in layer.params.keys():
                    layer.params[key] = params[i][key]
    

    losses

    上文我们提到 losses 组件需要做两件事情,给定了预测值和真实值,需要计算损失值和关于预测值的梯度。我们分别实现为 loss 和 grad 两个方法,这里我们实现多分类回归常用的 SoftmaxCrossEntropyLoss 损失。这个的损失 loss 和梯度 grad 的计算公式推导进文末附录,这里直接给出结果:多分类 softmax 交叉熵的损失为

    梯度稍微复杂一点,目标类别和非目标类别的计算公式不同。对于目标类别维度,其梯度为对应维度模型输出概率减一,对于非目标类别维度,其梯度为对应维度输出概率本身。

    代码实现如下

    # loss.py
    class BaseLoss(object):
        def loss(self, predicted, actual):
            raise NotImplementedError
    
        def grad(self, predicted, actual):
            raise NotImplementedError
    
    
    class CrossEntropyLoss(BaseLoss):
        def loss(self, predicted, actual):
            m = predicted.shape[0]
            exps = np.exp(predicted - np.max(predicted, axis=1, keepdims=True))
            p = exps / np.sum(exps, axis=1, keepdims=True)
            nll = -np.log(np.sum(p * actual, axis=1))
            return np.sum(nll) / m
    
        def grad(self, predicted, actual):
            m = predicted.shape[0]
            grad = np.copy(predicted)
            grad -= actual
            return grad / m
    

    optimizer

    optimizer 主要实现一个接口 compute_step,这个方法根据当前的梯度,计算返回实际优化时每个参数改变的步长。我们在这里实现常用的 Adam 优化器。

    # optimizer.py
    class BaseOptimizer(object):
        def __init__(self, lr, weight_decay):
            self.lr = lr
            self.weight_decay = weight_decay
    
        def compute_step(self, grads, params):
            step = list()
            # flatten all gradients
            flatten_grads = np.concatenate(
                [np.ravel(v) for grad in grads for v in grad.values()])
            # compute step
            flatten_step = self._compute_step(flatten_grads)
            # reshape gradients
            p = 0
            for param in params:
                layer = dict()
                for k, v in param.items():
                    block = np.prod(v.shape)
                    _step = flatten_step[p:p+block].reshape(v.shape)
                    _step -= self.weight_decay * v
                    layer[k] = _step
                    p += block
                step.append(layer)
            return step
    
        def _compute_step(self, grad):
            raise NotImplementedError
    
    class Adam(BaseOptimizer):
        def __init__(self, lr=0.001, beta1=0.9, beta2=0.999,
                     eps=1e-8, weight_decay=0.0):
            super().__init__(lr, weight_decay)
            self._b1, self._b2 = beta1, beta2
            self._eps = eps
    
            self._t = 0
            self._m, self._v = 0, 0
    
        def _compute_step(self, grad):
            self._t += 1
            self._m = self._b1 * self._m + (1 - self._b1) * grad
            self._v = self._b2 * self._v + (1 - self._b2) * (grad ** 2)
            # bias correction
            _m = self._m / (1 - self._b1 ** self._t)
            _v = self._v / (1 - self._b2 ** self._t)
            return -self.lr * _m / (_v ** 0.5 + self._eps)
    

    model

    最后 model 类实现了我们一开始设计的三个接口 forward、backward 和 apply_grad ,forward 直接调用 net 的 forward ,backward 中把 net 、loss、optimizer 串起来,先计算损失 loss,然后反向传播得到梯度,然后 optimizer 计算步长,最后由 apply_grad 对参数进行更新

    # model.py
    class Model(object):
        def __init__(self, net, loss, optimizer):
            self.net = net
            self.loss = loss
            self.optimizer = optimizer
    
        def forward(self, inputs):
            return self.net.forward(inputs)
    
        def backward(self, preds, targets):
            loss = self.loss.loss(preds, targets)
            grad = self.loss.grad(preds, targets)
            grads = self.net.backward(grad)
            params = self.net.get_parameters()
            step = self.optimizer.compute_step(grads, params)
            return loss, step
    
        def apply_grad(self, grads):
            for grad, (param, _) in zip(grads, self.net.get_params_and_grads()):
                for k, v in param.items():
                    param[k] += grad[k]
    

    整体结构

    最后我们实现出来核心代码部分文件结构如下

    tinynn
    ├── core
    │   ├── initializer.py
    │   ├── layer.py
    │   ├── loss.py
    │   ├── model.py
    │   ├── net.py
    │   └── optimizer.py
    

    其中 initializer.py 这个模块上面没有展开讲,主要实现了常见的参数初始化方法(零初始化、Xavier 初始化、He 初始化等),用于给网络层初始化参数。

    MNIST 例子

    框架基本搭起来后,我们找一个例子来用 tinynn 这个框架 run 起来。这个例子的基本一些配置如下

    • 数据集:MNIST(http://yann.lecun.com/exdb/mnist/)

    • 任务类型:多分类

    • 网络结构:三层全连接 INPUT(784) -> FC(400) -> FC(100) -> OUTPUT(10),这个网络接收 的输入,其中 是每次输入的样本数,784 是每张 的图像展平后的向量,输出维度为 ,其中 是样本数,10 是对应图片在 10 个类别上的概率

    • 激活函数:ReLU

    • 损失函数:SoftmaxCrossEntropy

    • optimizer:Adam(lr=1e-3)

    • batch_size:128

    • Num_epochs:20

    这里我们忽略数据载入、预处理等一些准备代码,只把核心的网络结构定义和训练的代码贴出来如下

    # example/mnist/run.py
    net = Net([
      Dense(784, 400),
      ReLU(),
      Dense(400, 100),
      ReLU(),
      Dense(100, 10)
    ])
    model = Model(net=net, loss=SoftmaxCrossEntropyLoss(), optimizer=Adam(lr=args.lr))
    
    iterator = BatchIterator(batch_size=args.batch_size)
    evaluator = AccEvaluator()
    for epoch in range(num_ep):
        for batch in iterator(train_x, train_y):
           # training
            pred = model.forward(batch.inputs)
            loss, grads = model.backward(pred, batch.targets)
            model.apply_grad(grads)
        # evaluate every epoch
        test_pred = model.forward(test_x)
        test_pred_idx = np.argmax(test_pred, axis=1)
        test_y_idx = np.asarray(test_y)
        res = evaluator.evaluate(test_pred_idx, test_y_idx)
        print(res)
    

    运行结果如下

    # tinynn
    Epoch 0 	 {'total_num': 10000, 'hit_num': 9658, 'accuracy': 0.9658}
    Epoch 1 	 {'total_num': 10000, 'hit_num': 9740, 'accuracy': 0.974}
    Epoch 2 	 {'total_num': 10000, 'hit_num': 9783, 'accuracy': 0.9783}
    Epoch 3 	 {'total_num': 10000, 'hit_num': 9799, 'accuracy': 0.9799}
    Epoch 4 	 {'total_num': 10000, 'hit_num': 9805, 'accuracy': 0.9805}
    Epoch 5 	 {'total_num': 10000, 'hit_num': 9826, 'accuracy': 0.9826}
    Epoch 6 	 {'total_num': 10000, 'hit_num': 9823, 'accuracy': 0.9823}
    Epoch 7 	 {'total_num': 10000, 'hit_num': 9819, 'accuracy': 0.9819}
    Epoch 8 	 {'total_num': 10000, 'hit_num': 9820, 'accuracy': 0.982}
    Epoch 9 	 {'total_num': 10000, 'hit_num': 9838, 'accuracy': 0.9838}
    Epoch 10 	 {'total_num': 10000, 'hit_num': 9825, 'accuracy': 0.9825}
    Epoch 11 	 {'total_num': 10000, 'hit_num': 9810, 'accuracy': 0.981}
    Epoch 12 	 {'total_num': 10000, 'hit_num': 9845, 'accuracy': 0.9845}
    Epoch 13 	 {'total_num': 10000, 'hit_num': 9845, 'accuracy': 0.9845}
    Epoch 14 	 {'total_num': 10000, 'hit_num': 9835, 'accuracy': 0.9835}
    Epoch 15 	 {'total_num': 10000, 'hit_num': 9817, 'accuracy': 0.9817}
    Epoch 16 	 {'total_num': 10000, 'hit_num': 9815, 'accuracy': 0.9815}
    Epoch 17 	 {'total_num': 10000, 'hit_num': 9835, 'accuracy': 0.9835}
    Epoch 18 	 {'total_num': 10000, 'hit_num': 9826, 'accuracy': 0.9826}
    Epoch 19 	 {'total_num': 10000, 'hit_num': 9819, 'accuracy': 0.9819}
    

    可以看到测试集 accuracy 随着训练进行在慢慢提升,这说明数据在框架中确实按照正确的方式进行流动和计算,参数得到正确的更新。为了对比下效果,我用 Tensorflow 1.13 实现了相同的网络结构、采用相同的采数初始化方法、优化器配置等等,得到的结果如下

    # Tensorflow 1.13.1
    Epoch 0 	 {'total_num': 10000, 'hit_num': 9591, 'accuracy': 0.9591}
    Epoch 1 	 {'total_num': 10000, 'hit_num': 9734, 'accuracy': 0.9734}
    Epoch 2 	 {'total_num': 10000, 'hit_num': 9706, 'accuracy': 0.9706}
    Epoch 3 	 {'total_num': 10000, 'hit_num': 9756, 'accuracy': 0.9756}
    Epoch 4 	 {'total_num': 10000, 'hit_num': 9722, 'accuracy': 0.9722}
    Epoch 5 	 {'total_num': 10000, 'hit_num': 9772, 'accuracy': 0.9772}
    Epoch 6 	 {'total_num': 10000, 'hit_num': 9774, 'accuracy': 0.9774}
    Epoch 7 	 {'total_num': 10000, 'hit_num': 9789, 'accuracy': 0.9789}
    Epoch 8 	 {'total_num': 10000, 'hit_num': 9766, 'accuracy': 0.9766}
    Epoch 9 	 {'total_num': 10000, 'hit_num': 9763, 'accuracy': 0.9763}
    Epoch 10 	 {'total_num': 10000, 'hit_num': 9791, 'accuracy': 0.9791}
    Epoch 11 	 {'total_num': 10000, 'hit_num': 9773, 'accuracy': 0.9773}
    Epoch 12 	 {'total_num': 10000, 'hit_num': 9804, 'accuracy': 0.9804}
    Epoch 13 	 {'total_num': 10000, 'hit_num': 9782, 'accuracy': 0.9782}
    Epoch 14 	 {'total_num': 10000, 'hit_num': 9800, 'accuracy': 0.98}
    Epoch 15 	 {'total_num': 10000, 'hit_num': 9837, 'accuracy': 0.9837}
    Epoch 16 	 {'total_num': 10000, 'hit_num': 9811, 'accuracy': 0.9811}
    Epoch 17 	 {'total_num': 10000, 'hit_num': 9793, 'accuracy': 0.9793}
    Epoch 18 	 {'total_num': 10000, 'hit_num': 9818, 'accuracy': 0.9818}
    Epoch 19 	 {'total_num': 10000, 'hit_num': 9811, 'accuracy': 0.9811}
    

    图片
    可以看到两者效果上大差不差,测试集准确率都收敛到 0.982 左右,就单次的实验看比 Tensorflow 稍微好一点点。

    总结

    tinynn 相关的源代码在这个 repo(https://github.com/borgwang/tinynn) 里。目前支持:

    • layer :全连接层、2D 卷积层、 2D反卷积层、MaxPooling 层、Dropout 层、BatchNormalization 层、RNN 层以及 ReLU、Sigmoid、Tanh、LeakyReLU、SoftPlus 等激活函数

    • loss:SigmoidCrossEntropy、SoftmaxCrossEntroy、MSE、MAE、Huber

    • optimizer:RAam、Adam、SGD、RMSProp、Momentum 等优化器,并且增加了动态调节学习率 LRScheduler

    • 实现了 mnist(分类)、nn_paint(回归)、DQN(强化学习)、AutoEncoder 和 DCGAN (无监督)等常见模型。见 tinynn/examples:https://github.com/borgwang/tinynn/tree/master/examples

    tinynn 还有很多可以继续完善的地方受限于时间还没有完成,笔者在空闲时间会进行维护和更新。

    当然 tinynn 只是一个「玩具」版本的深度学习框架,一个成熟的深度学习框架至少还需要:支持自动求导、高运算效率(静态语言加速、支持 GPU 加速)、提供丰富的算法实现、提供易用的接口和详细的文档等等。这个小项目的出发点更多地是学习,在设计和实现 tinynn 的过程中笔者个人学习确实到了很多东西,包括如何抽象、如何设计组件接口、如何更效率的实现、算法的具体细节等等。对笔者而言写这个小框架除了了解深度学习框架的设计与实现之外还有一个好处:后续可以在这个框架上快速地实现一些新的算法,新的参数初始化方法,新的优化算法,新的网络结构设计,都可以快速地在这个小框架上进行实验。如果你对自己设计实现一个深度学习框架也感兴趣,希望看完这篇文章会对你有所帮助,也欢迎大家提 PR 一起贡献代码~

    附录: Softmax 交叉熵损失和梯度推导

    多分类下交叉熵损失如下式:

    其中 分别是真实值和模型预测值, 是样本数, 是类别个数。由于真实值一般为一个 one-hot 向量(除了真实类别维度为 1 其他均为 0),因此上式可以化简为

    其中 是代表真实类别, 代表第 个样本 类的预测概率。即我们需要计算的是每个样本在真实类别上的预测概率的对数的和,然后再取负就是交叉熵损失。接下来推导如何求解该损失关于模型输出的梯度,用 表示模型输出,在多分类中通常最后会使用 Softmax 将网络的输出归一化为一个概率分布,则 Softmax 后的输出为

    代入上面的损失函数

    求解 关于输出向量 的梯度,可以将 分为目标类别所在维度 和非目标类别维度 。首先看目标类别所在维度
    再看非目标类别所在维度

    可以看到对于目标类别维度,其梯度为对应维度模型输出概率减一,对于非目标类别维度,其梯度为对应维度输出概率真身。

    参考

    • Deep Learning, Goodfellow, et al. (2016)

    • Joel Grus - Livecoding Madness - Let’s Build a Deep Learning Library

    • TensorFlow Documentation

    • PyTorch Documentation

    如果觉得有用,就请点赞、收藏、关注吧!

    展开全文
  • 亲自动手一个深度学习框架

    千人学习 2018-10-30 15:24:47
    本课程带领大家亲自动手一个更方便大家使用的深度学习框架,帮助大家理解常用技术的底层实现。具体安排如下: 1.板书完成数学推导,同时画图讲解; 2.基础:Python实现多层感知器; 3.进阶:C++实现深度学习框架...
  • 本着“凡我不能创造的,我就不能理解”的思想,此系列文章会基于纯Python以及NumPy从零创建自己深度学习框架,该框架类似PyTorch能实现自动求导。

    引言

    本着“凡我不能创造的,我就不能理解”的思想,本系列文章会基于纯Python以及NumPy从零创建自己的深度学习框架,该框架类似PyTorch能实现自动求导。

    要深入理解深度学习,从零开始创建的经验非常重要,从自己可以理解的角度出发,尽量不适用外部完备的框架前提下,实现我们想要的模型。本系列文章的宗旨就是通过这样的过程,让大家切实掌握深度学习底层实现,而不是仅做一个调包侠。
    本系列文章首发于微信公众号:JavaNLP

    从零开始实现深度学习框架,可能会花费不少时间,我们需要编写不少的代码。但是一旦完成了这一项工作,看着通过我们自己的框架实现的RNN、seq2seq、BERT等技术时,一种自豪感油然而生。同时在这个过程中,我们会对其他的技术细节有深入的理解。对于我们使用、调试现有的自动求导库,如PyTorch都非常有帮助。

    完整代码地址

    点击 👉 metagrad

    线路图

    下面是从零实现深度学习框架的线路图(可点击跳转)。

    点击进入线路图

    目录

    1. 自动求导神器计算图
    2. 常见运算的计算图
    3. 计算图运算补充
    4. 实现自己的Tensor对象
    5. 实现Tensor的反向传播
    6. 理解广播和常见的乘法
    7. 优化反向传播相关代码
    8. 实现常见运算的计算图(上)
    9. 实现常见运算的计算图(下)
    10. 线性回归简介
    11. 动手实现线性回归
    12. 逻辑回归简介
    13. 动手实现逻辑回归
    14. Softmax回归简介
    15. 动手实现Softmax回归
    16. 实现Debug功能与no_grad
    17. 逻辑回归中的数值稳定
    18. Softmax回归中的数值稳定
    19. 深入浅出交叉熵
    20. 优化索引操作&交叉熵损失
    21. 神经元与常见激活函数
    22. 神经网络入门
    23. 手写前馈网络实现电影评论分类
    24. 过拟合与欠拟合
    25. 处理数据的加载
    26. 理解正则化(一)
    27. 理解正则化(二)
    28. 几种常用的权重初始化方法
    29. N-Gram语言模型(一)
    30. N-Gram语言模型(二)
    31. 利用GPU加速
    32. 从共现矩阵到点互信息
    33. 深入浅出Word2vec(上)
    34. 深入浅出Word2vec(下)
    35. 前馈网络语言模型
    36. 重构计算图的实现
    37. RNN从理论到实战【理论】
    38. RNN从理论到实战【实战】
    39. LSTM从理论到实战【理论】
    展开全文
  • 深度学习框架概览TensorFlowCaffePytorchPaddlePaddle TensorFlow Caffe Pytorch PaddlePaddle


    工欲善其事,必先利其器。深度学习诞生10年有余,已经有了不少成熟的开发框架,这篇文章就来了解一下当前主流的框架。

    参考文章:详解 6 大主流深度学习框架
    参考书籍:【深度学习与计算机视觉】 叶韵编著

    Caffe

    在这里插入图片描述

    Caffe,全称为Convolutional Architecture for Fast Feature Embedding,由伯克利加州大学的博士生贾扬清开发,后来一直由伯克利视觉及学习中心(Berkeley Vision and Learning Center, BVLC)进行维护。Caffe基于C++和英伟达公司的GPU(Graphic Processing Unit)通用计算架构CUDA(Compute Unified Device Architecture)开发,特点是高效、可配置化的输入、GPU和CPU的无缝切换。当然还有非常重要的一点,Caffe拥有庞大的社区,无论是科研领域还是业界都有大量的用户。每当一些最前沿的深度学习方法发表后,没多久就会有官方的预训练模型或是第三方基于Caffe的实现,所以Caffe是一个对初学者和有经验的人都非常适合的工具。

    2013年,贾扬清得到了一块NVIDIA免费提供的K20加速卡。在这个契机下贾扬清一边做毕业论文一边开始写一个用于深度学习的框架。经过了近半年的独立开发,Caffe初具形态并且在伯克利的研究组内获得了良好的试用反响。后来在物体检测领域成为经典的R-CNN(Regions with Convolutional Neural Network features)方法就是在这段时间内基于Caffe实现的。

    2013年底,贾扬清将Caffe开源,成为了当时业内第一个较为完整的深度学习开源框架,于是立刻获得了学术界和业界的好评及支持。后来在BLVC和NVIDIA为主的合力推广下,Caffe很快成为了深度学习领域,尤其是基于深度学习的计算机视觉领域最流行的框架。

    初学使用Caffe还需要注意下面两个问题。

    Caffe的安装过程需要大量的依赖库,因此涉及很多安装版本问题,初学者须多加注意。

    当用户要实现一个新的层,就需要用C++实现它的前向传播和反向传播代码,而如果想要新层运行在GPU上,则需要同时使用CUDA实现这一层的前向传播和反向传播。

    Theano

    在这里插入图片描述

    这个由希腊神话中伊卡里亚岛国王妻子名字命名的框架,是由本吉奥领导的蒙特利尔大学机器学习研究小组(MILA)开发的。作为一个诞生比Caffe早的框架,在早期Theano是深度学习领域最流行的软件包。严格来说,Theano不是专门面向深度学习的,而是一个基于多维数组用于计算和优化数学表达式的数值软件包,因为神经网络的本质其实就是数学表达式,所以用Theano可以非常灵活地从无到有地实现神经网络的各种功能。Theano基于Python,最大的优点是灵活,性能非常出色,确实是基于函数式的编程方式,还有拗口的API,异常困难的调试等,造就了陡峭的学习曲线。另外,其异常慢的编译速度也常常遭人诟病。

    直接在Theano中开发虽然灵活度最高,但开发工作量和难度也不小,所以在Theano基础上有很多封装过后的框架,比如MILA官方的Pylearn2,还有第三方开发的Lasagne和Keras等。Pylearn2由于把Theano的缺点又进一步发挥到了极致,在火了一小阵后就被渐渐冷落,如今已经停止了实际意义上的开发。后两个框架正在蓬勃发展中,尤其是Keras,渐渐开始成为一个脱离底层实现的大框架,目前除了Theano也支持了Google的Tensorflow。

    TensorFlow

    在这里插入图片描述

    Google开源的深度学习框架,一开始主要面向的是分布式系统。从官方介绍上来看,具有非常好的延展性,在多GPU/多机上拥有最好的灵活性。另外Google的强有力支持也算是一大优点。初期版本在单机和一些小任务上性能差强人意,在一些基准测试上甚至常常被其他框架甩下一个量级。不过随着TensorFlow的持续改进,以及Google光环的照耀,现在TensorFlow正在变得越来越流行。截至2016年5月,在github上关于TensorFlow的相关讨论的数量已经超过Caffe跃居第一位。

    TensorFlow在很大程度上可以看作Theano的后继者,这不仅因为它们有很大一批共同的开发者,还因为它们拥有相近的设计理念,都基于计算图实现自动微分系统。TensorFlow 使用数据流图进行数值计算,图中的节点代表数学运算,图中的边代表在这些节点之间传递的多维数组。

    TensorFlow编程接口支持Python和C++,TensorFlow 1.0版本开始支持Java、Go、R和Haskell API的Alpha版本。此外,TensorFlow还可以在Google Cloud和AWS中运行。TensorFlow支持Windows 7、Windows 10和Windows Server 2016系统。

    因为TensorFlow使用C++ Eigen库,所以可以在ARM架构上编译和优化。这也就意味着用户可以在各种服务器和移动设备上部署自己的训练模型,无须执行单独的模型解码器或者加载Python解释器。

    作为当前最流行的深度学习框架,TensorFlow获得了极大的成功,但在学习过程中读者也需要注意下面一些问题。

    • 因为TensorFlow的接口在不断地快速迭代,并且版本之间不兼容,所以在开发和调试过程中可能会出现问题,例如开源代码无法在新版的TensorFlow上运行。

    • 想学习TensorFlow底层运行机制的读者需要做好心理准备,TensorFlow在GitHub代码仓库的总代码量超过100万行,系统设计比较复杂,这将是一个漫长的学习过程。

    • 在代码层面,对于同一个功能,TensorFlow提供了多种实现,这些实现良莠不齐,使用中还有细微的区别,请读者注意选择。另外,TensorFlow创造了图、会话、命名空间、PlaceHolder等诸多抽象概念,对普通用户来说较难理解。

    Torch

    由卷积神经网络之父杨乐昆领导开发的框架,是Facebook的深度学习开发工具,于2014年开源后,迅速传播开来。Torch的性能非常优秀,其他方面作为一个框架该有的功能都有。另外,作为集合了杨乐昆学术能力和Facebook业界经验的框架,Torch天然对多GPU的支持也胜过了被经常拿来一起比较的Caffe。Torch是基于Lua的,虽然Lua是一个简单又灵活的语言,但是毕竟是小众语言,这在一定程度上限制了Torch的流行程度。

    Pytorch

    在这里插入图片描述

    PyTorch的前身便是Torch,其底层和Torch框架一样,但是使用Python重新写了很多内容,不仅更加灵活,支持动态图,而且提供了Python接口。它是由Torch7团队开发,是一个以Python优先的深度学习框架,不仅能够实现强大的GPU加速,同时还支持动态神经网络,这是很多主流深度学习框架比如Tensorflow等都不支持的。

    PyTorch既可以看作加入了GPU支持的numpy,同时也可以看成一个拥有自动求导功能的强大的深度神经网络。除了Facebook外,它已经被Twitter、CMU和Salesforce等机构采用。

    相对于TensorFlow,PyTorch的一大优点是它的图是动态的,而TensorFlow框架是静态图,不利于扩展。同时,PyTorch非常简洁,方便使用。

    如果说TensorFlow的设计是“Make it complicated”,Keras的设计是“Make it complicated and hide it”,那么PyTorch的设计则真正做到了“Keep it simple,stupid”。

    MXNet

    在这里插入图片描述

    由分布式机器学习社区(Distributed/Deep Machine Learning Community, DMLC)开发,是第一个由中国人主导开发的流行框架。MXNet的特点是轻量级、高性能,以及对从分布式到嵌入式等多种场景的优异支持。MXNet前身是DMLC的CXXNet和Minerva,这两个项目一个通过配置和定义来训练网络,而另一个则提供了类似numpy一样的多维数组的用法。MXNet无缝地衔接了这两种用法,获得了非常好的灵活性,这是另一个特点。MXNet支持语言非常多,尤其是对R的支持,赢得了一批统计领域的用户,并且扩展性也不错,可以说是一个非常有潜力的框架。此外,MXNet还有一个很大的特点是文档非常“烂”。2016年末,Amazon宣布MXNet为其官方深度学习平台,并会提供进一步支持,这个问题似乎有望被解决。

    cuda-convnet2

    由2012年让深度学习在视觉领域声名大噪的AlexNet作者,辛顿的学生艾利克斯·克里则夫斯基(Alex Krizhevsky)开发。作为一名学术工程双馨的天才,其开发的cuda-convnet2的性能曾经非常强悍,不过不知什么原因,最近也停止更新了。

    Neon

    由一家结合了深度学习人才和硬件人才的创业公司Nervana Systems于2015年开源发布。这是一个比较独特的框架,因为其公司软硬结合的血统,在硬件优化上的造诣让这个框架在发布时在不少基准测试上达到了世界最佳的成绩。2016年中,Nervana System被Intel收购。

    Deeplearning4j

    支持Java的机器学习库,由Skymind发布于2014年发布,商业标准的开源框架,在一些欧美咨询公司中受到欢迎。

    CNTK

    全称为Computational Network Toolkit,是微软出品的深度学习框架,于2016年初开源,所以目前使用者寥寥。该框架同时支持CPU和GPU,据说性能极其强悍,在微软官方博客上的测试中,超过了其他所有常见框架。

    PaddlePaddle

    飞桨(PaddlePaddle)以百度多年的深度学习技术研究和业务应用为基础,是中国首个自主研发、功能完备、开源开放的产业级深度学习平台,集深度学习核心训练和推理框架、基础模型库、端到端开发套件和丰富的工具组件于一体。目前,飞桨已凝聚超过265万开发者,服务企业10万家,基于飞桨开源深度学习平台产生了34万个模型 。飞桨助力开发者快速实现AI想法,快速上线AI业务。帮助越来越多的行业完成AI赋能,实现产业智能化升级。

    飞桨在业内率先实现了动静统一的框架设计,兼顾灵活性与高性能,并提供一体化设计的高层API和基础API,确保用户可以同时享受开发的便捷性和灵活性。

    在大规模分布式训练技术上,飞桨率先支持了千亿稀疏特征、万亿参数、数百节点并行训练的能力,并推出业内首个通用异构参数服务器架构,达到国际领先水平。

    飞桨拥有强大的多端部署能力,支持云端服务器、移动端以及边缘端等不同平台设备的高速推理;飞桨推理引擎支持广泛的AI芯片,已经适配和正在适配的芯片或IP达到29款,处于业界领先地位。

    飞桨围绕企业实际研发流程量身定制打造了大规模的官方模型库,算法总数达到270多个,服务企业遍布能源、金融、工业、农业等多个领域。

    Keras

    在这里插入图片描述
    Keras是一个高层神经网络API,使用Python编写,并将TensorFlow、Theano及CNTK作为后端。Keras为支持快速实验而生,能够快速实现开发者的想法。Keras目前是最容易上手的深度学习框架,它提供了一致且简洁的API,能够极大减少一般应用下用户的工作量。

    相比于深度学习框架,Keras更像是一个深度学习接口,它构建于第三方框架之上。Keras的缺点很明显:过度封装导致丧失了灵活性。Keras最初作为Theano的高级API,后来增加了TensorFlow和CNTK作为后端。

    为了屏蔽后端的差异性,Keras提供了一致的用户接口并做了层层封装,导致用户在新增操作或是获取底层的数据信息时过于困难。同时,过度封装也使得Keras的程序运行十分缓慢,许多Bug都隐藏于封装之中。在绝大多数场景下,Keras是本文介绍的所有框架中运行最慢的。

    学习Keras十分容易,但是很快就会遇到瓶颈,因为它不够灵活。另外,在使用Keras的大多数时间里,用户主要是在调用接口,很难真正学习到深度学习的内容。

    Keras的过度封装使其并不适合新手学习(无法理解深度学习的真正内涵),故不推荐。

    展开全文
  • 用Python实现深度学习框架

    千次阅读 2021-01-07 19:59:00
    ↑↑↑关注后"星标"Datawhale每日干货&每月组队学习,不错过开课吧教育作者:高民权,前IBM中国数据科学家深度学习作为人工智能的核心技术,近年来无...
  • 通过matlab的卷积网络框架,然后复杂的操作比如卷积池化等通过.cu文件的, 调用GPU加速,外面的层为粗粒度的,运行的速度和TensorFlow差一个数量级,也用到 GPU加速了,怎么会慢这么多,会不会因为由于每一层...
  • 干货 | 5个常用的深度学习框架

    千次阅读 2021-11-23 02:01:26
    点击上方“小白学视觉”,选择加"星标"或“置顶”重磅干货,第一时间送达对于学习数据科学的同学来说,从头开始实现神经网络,会让你理解很多有趣的东西。但是,我并不认为在真实数据集上构建深度学...
  • 导读:近几年,随着深度学习爆炸式发展,在人工智能领域除了理论方面的突破外,还有基础架构的突破,它们奠定了深度学习繁荣发展的基础。这其中涌现了几个著名的深度学习平台,本文将对这些平台进行逐一...
  • 常见的深度学习框架有 TensorFlow 、Caffe、Theano、Keras、PyTorch、MXNet等,如下图所示。这些深度学习框架被应用于计算机视觉、语音识别、自然语言处理与生物信息学等领域,并获取了极好的效果。几乎所有的框架都...
  • 一、深度学习框架概述与深度学习技术的四大阵营 人工智能从学术理论研究到生产应用的产品化开发过程中通常会涉及到多个不同的步骤和工具,这使得人工智能开发依赖的环境安装、部署、测试以及不断迭代改进准确性和...
  • 常见深度学习框架比较

    万次阅读 多人点赞 2018-09-10 11:35:59
    常见的深度学习框架有 TensorFlow 、Caffe、Theano、Keras、PyTorch、MXNet等,如下图所示。这些深度学习框架被应用于计算机视觉、语音识别、自然语言处理与生物信息学等领域,并获取了极好的效果。下面将主要介绍...
  • 轻量级深度学习推理框架. 轻量级深度学习推理框架. 轻量级深度学习推理框架.
  • amd深度学习框架搭建

    千次阅读 2021-03-24 21:11:41
    一、实验一:深度学习框架搭建 二、实验目标 1、深度学习环境搭建; 2、图像识别开发环境搭建; 三、实验内容 1、实验方法及步骤: 方法:由于电脑是AMD显卡故下载tensorflow-cpu版本,python,Anaconda,pycharm,...
  • 对比深度学习十大框架

    千次阅读 2019-05-20 18:19:04
    2016 年已经过去,BEEVA Labs 数据分析师 Ricardo Guerrero Gomez-Ol 近日在 Medium 上发表了一篇文章,盘点了目前最流行的深度学习框架。为什么要做这一个盘点呢?他写道:「我常听到人们谈论深度学习——我该从...
  • 5个热门的深度学习框架

    千次阅读 2020-10-10 22:27:40
    介绍我是一名程序员,喜欢从头开始编写代码,这有助于我清楚地理解算法的技术细节。当我们最初学习数据科学时,这种方法是特别有用的。从头开始实现一个神经网络,你会学到很多有意义的知识,但是在现...
  • 现在深度学习框架不但内卷严重,而且头部效应明显。一提起深度学习框架,首先想到的肯定是Google家的TensorFlow,和Facebook家的PyTorch。究竟排名谁先谁后,还要看你...
  • 主流深度学习框架对比

    万次阅读 多人点赞 2017-02-20 20:20:35
    深度学习研究的热潮持续高涨,各种开源深度学习框架也层出不穷,其中包括TensorFlow、Caffe、Keras、CNTK、Torch7、MXNet、Leaf、Theano、DeepLearning4、Lasagne、Neon,等等。然而TensorFlow却杀出重围,在关注度...
  • 各种深度学习框架实现猫狗大战

    千次阅读 2019-12-21 15:43:24
    不同深度学习框架下的实现教程/github地址 1.Pytorch 2.TensorFlow 3.Keras 4.MXNet 不同深度学习框架下的实现教程/github地址(好用的话记得star噢) 1.Pytorch 一个教程和项目地址,代码需要自己建立项目,...
  • 文章目录前言一、背景介绍二、...目前常见的深度学习框架不尽相同,主要有TensorFlow、Caffe、Theano、Keras等,常见的深度学习框架如借图如下所示。这些深度学习框架被应用于计算机视觉、语音识别、自然语言处...
  • 一、深度学习框架究竟是什么?

    千次阅读 2018-09-15 21:27:24
    1 引言 一直在说深度学习框架,最近也在使用tensorflow进行了简单的实验,但是对其中关系的理解还是...
  • 深度学习框架究竟是什么?

    万次阅读 多人点赞 2017-12-08 20:02:27
    1 引言一直在说深度学习框架,最近也在使用tensorflow进行了简单的实验,但是对其中关系的理解还是不够到位,他们里面究竟是怎样的一个运行机制呢?2 说明深度学习框架也就像Caffe、tensorflow这些是深度学习的工具...
  • Python+Anaconda+Pycharm+Pytorch的深度学习框架安装

    千次阅读 多人点赞 2021-07-15 16:16:26
    首先,先理清这个基于Pytorch的深度学习框架,下面是冷漠根据自己的理解画的一个关系图,如下: 我举个例子,方便大家容易理解,Anaconda软件相当于一栋没有住户大楼,这栋楼已经打好了地基,pyhton编译器相当...
  • 如此多的深度学习框架,为什么我选择PyTorch?

    万次阅读 多人点赞 2018-01-24 10:01:56
    小编说:目前研究人员正在使用的深度学习框架不尽相同,本文介绍了6种常见的深度学习框架,PyTorch与他们相比又有哪些优势呢?本文选自《深度学习框架PyTorch:入门与实践》1 PyTorch的诞生2017年1月,Facebook人工...
  • 5天搞定深度学习框架-Caffe入门系列

    万人学习 2017-07-27 16:23:05
    本课程是在windows环境下的caffe课程,主要使用的是python的接口。 首先带着大家完成一个MNIST手写数字识别的项目,让大家了解caffe训练模型的大致流程。然后会讲到caffe中的一些重要文件和配置,使用python绘图。...
  • [深度学习]深度学习框架总结

    万次阅读 2017-04-16 11:53:11
    深度学习库比较 库名 主语言 从语言 速度 灵活性 文档 适合模型 平台 上手难易 开发者 模式 Tensorflo C++ cuda/python/Matlab/Ruby/R 中等 好 中等 CNN/RNN Linux,OSX 难 Google 分布式/声明...
  • TensorFlow与主流深度学习框架对比

    千次阅读 2018-07-30 15:52:07
    TensorFlow是相对高阶的机器学习库,用户可以方便地用它设计神经网络结构,而不必为了追求高效率的实现亲自C++或CUDA代码。它和Theano一样都支持自动求导,用户不需要再通过反向传播求解梯度。其核心代码和Caffe...
  • 世间有一种软件,名叫“深度学习框架”。 在人工智能的江湖,常听人言:得框架者,得天下。 多年以前,一面画着大G的大旗在高处飘扬,美国谷歌公司的深度学习框架占据大半江山。万万没有想到,一场大风暴来了。 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 85,959
精华内容 34,383
热门标签
关键字:

自己写深度学习框架