手把手教你如何自己设计实现一个深度学习框架（附代码实现）

最新推荐文章于 2024-08-26 22:16:26 发布
最新推荐文章于 2024-08-26 22:16:26 发布
阅读量860 收藏 1
点赞数 2
文章标签： 深度学习 tensorflow 神经网络
原文链接：https://mp.weixin.qq.com/s/LKhxaX9_qRNzb6UMZyhmiA
版权

导读

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

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

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

目录

目录

导读

目录

组件抽象

组件实现

tensor

layer

net

losses

optimizer

model

整体结构

MNIST 例子

总结

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

参考

组件抽象

首先考虑神经网络运算的流程，神经网络运算主要包含训练 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 ：numpy.ndarray — NumPy v1.21 Manual
 

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，实现wx+b的运算；backward 的方法接收来自上层的梯度，计算关于参数w,b和输入的梯度，然后返回关于输入的梯度。这三个梯度的推导可以见附录，这里直接给出实现。w_init 和 b_init 分别是参数w和b的初始化器，这个我们在另外的一个实现初始化器中文件 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 交叉熵的损失为J_{CE}(y,\hat{y})=-\sum_{i=1}^N\log(\hat{y}_i^c)
 

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

 

 代码实现如下
 

# 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（MNIST handwritten digit database, Yann LeCun, Corinna Cortes and Chris Burges）
     
  •  
    任务类型：多分类
     
  •  
    网络结构：三层全连接 INPUT(784) -> FC(400) -> FC(100) -> OUTPUT(10)，这个网络接收(N,784)的输入，其中N是每次输入的样本数，784 是每张(28,28)的图像展平后的向量，输出维度为(N,10)，其中N是样本数，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 交叉熵损失和梯度推导
 

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

J_{CE}(y,\hat y)=-\sum _{i=1}^N \sum_{k=1}^K y_i^k \log (\hat y_i^k)
 

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

J_{CE}(y,\hat y)=-\sum _{i=1}^N \log (\hat y_i^c)
 

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

\hat y^c=\frac{\exp(o^c)}{\sum_{k=1}^K \exp(o^k)}
 

代入上面的损失函数
 

J_{CE}(y,\hat y)=-\sum _{i=1}^N (o_i^c - \log (\sum_{k=1}^K \exp(o_i^k)))
 

求解J_{CE}关于输出向量o的梯度，可以将o分为目标类别所在维度o^c和非目标类别维度。首先看目标类别所在维度o^c
 

\frac{\partial J_{ce}}{\partial o^c}=-\sum _{i=1}^N (1 - \frac{\exp(o^c)}{\sum_{k=1}^K \exp(o^k)})=\sum_{k=1}^K(\hat y^c-1)
 

再看非目标类别所在维度
 

 

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

参考
 

  •  
    Deep Learning, Goodfellow, et al. (2016)
     
  •  
    Joel Grus - Livecoding Madness - Let's Build a Deep Learning Library
     
  •  
    TensorFlow Documentation
     
  •  
    PyTorch Documentation
     

                

        

        

    

  


    

      

        

            

              
                
                  Small_Teenager
                
              
            

            

                关注
              
            

        

        

          
      

      









                



	

		

			

				
					
2024年 毕业设计 机器学习&深度学习实战案例,含有python代码和教程 (10月26日已更新856篇)

				
			

			

				

					sybh的博客
				

				

					10-05
					
					6698
					
				

			

		

		

			
				
10月促销价39.9,适合初学python机器学习深度学习的学生,从入门到精通,专栏内含有讲解,每篇文章都含有对应的代码,会持续更新,更新至千篇案例,已经更新六百多个项。

			
		

	



                

            
              



	

		

			

				
					
模型训练篇 | yolov10来了！手把手教你如何用yolov10训练自己的数据集（含网络结构 + 模型训练 + 模型推理等）

					
热门推荐

				
			

			

				

					突然好想你
				

				

					06-04
					
					2万+
					
				

			

		

		

			
				
YOLOv10推出的消息引发了AI界的关注，它被认为是计算机视觉领域的突破性框架，以实时的端到端目标检测能力而闻名，通过提供结合效率和准确性的强大解决方案，延续了YOLO系列的传统。新版本发布之后，很多人已经进行了部署测试，效果不错，本节课就带领大家如何基于YOLOv10训练模型并推理测试！~🌈

			
		

	



              


  
              

                


	

		

			

				
					
手把手教你用Python实践深度学习|深度学习教程

				
			

			

				

					09-21
				

			

		

		

			
				
课程共七章，采用最新版本进行教学，2018必学技术

第一章： 从人工智能到深度学习    
第二章：使用TensorFlow & Keras 建构人工神经网络(Artificial Neural Network)    
第三章：卷积神经网络 (Convolutional Neural Network)   
第四章：循环神经网络(Recurrent Neural Networks)
第五章：自编码网络 (AutoEncoder)    
第六章：生成对抗网络 GAN (Generative Adversarial Nets)    
第七章：深度增强学习

			
		

	





	

		

			

				
					
我用这个框架拿了Kaggle大赛冠军

				
			

			

				

					Paper weekly
				

				

					03-09
					
					406
					
				

			

		

		

			
				
2020年的AI算法岗竞争究竟多惨烈？这两年AI大火，还被顺势纳入了新基建的队伍，算法岗的平均薪资水平远超传统开发岗一大截，高薪+前景好，自然吸引越来越多技术人员转去AI工程师方向。再加上...

			
		

	



		

			
		



	

		

			

				
					
深度学习模板方法设计模式

					
最新发布

				
			

			

				

					G_whang的博客
				

				

					08-26
					
					556
					
				

			

		

		

			
				
模板方法设计模式是行为型设计模式，主要是定义算法框架，并将一些步骤的实现延迟到子类，重新定义算法的步骤。模板设计模式（Template Pattern）是一种行为型设计模式，它在超类中定义了一个算法的框架，将一些步骤延迟到子类中实现。模板方法使得子类可以在不改变算法结构的前提下，重新定义算法的某些特定步骤。AbstractClass（抽象类）：定义了模板方法和钩子方法，以及可能的抽象方法和具体方法。ConcreteClass（具体类）：继承自抽象类，实现抽象方法，并可能覆盖钩子方法和具体方法。

			
		

	





	

		

			

				
					
自己编写深度学习框架ANNbox【高仿tensorflow】__03文本情感分析

				
			

			

				

					drilistbox的博客
				

				

					06-26
					
					592
					
				

			

		

		

			
				
文章列表 
1.自己编写神经网络库__01基于MiniFlow实现全连接. 
2.自己编写神经网络库__02基于MiniFlow实现不同的优化方法. 
3.自己编写神经网络库__03文本情感分析. 
…



自己编写神经网络库__03文本情感分析
1  方法1：基于词汇计数的方法实现输入语句数据向量化
1.1   文本输入处理
1.2   标签处理
1.3   神经网络模型
1.4   程序实现...

			
		

	





	

		

			

				
					
深度学习-框架设计

				
			

			

				

					JIN JI 2013.12.24
				

				

					08-02
					
					722
					
				

			

		

		

			
				
虚拟框架杀入










从发现问题到解决问题




半年前的这时候，暑假，我在SIAT MMLAB实习。




看着同事一会儿跑Torch，一会儿跑MXNet，一会儿跑Theano。




SIAT的服务器一般是不给sudo权限的，我看着同事挣扎在编译这一坨框架的海洋中，开始思考：






是否可以写一个框架：


			
		

	





	

		

			

				
					
详解 6 大主流深度学习框架

				
			

			

				

					大数据
				

				

					02-25
					
					1万+
					
				

			

		

		

			
				
导读：近几年，随着深度学习的爆炸式发展，相关理论和基础架构得到了很大突破，它们奠定了深度学习繁荣发展的基础。这其中涌现了几个著名的深度学习平台，本文将对这些平台进行简要介绍。作者：涂铭 金...

			
		

	





	

		

			

				
					
手把手教 | 深度学习库PyTorch（附代码）

				
			

			

				

					数据派THU
				

				

					03-15
					
					3474
					
				

			

		

		

			
				
原文标题：An Introduction to PyTorch – A Simple yet Powerful Deep LearningLibrary作者：FAIZAN SHAIKH翻译：和中华本文约3600字，建议阅读15分钟。本文通过案例带你一步步上手PyTorch。  介绍每隔一段时间，就会有一个有潜力改变深度学习格局的python库诞生，PyTorch就是其中一员。 在过去的几周里，我一

			
		

	





	

		

			

				
					
YOLOv10 | 手把手教你利用yolov10训练自己数据集（含环境搭建、参数解析 、数据集查找、模型训练、推理、导出）

				
			

			

				

					Snu77的博客
				

				

					05-26
					
					2万+
					
				

			

		

		

			
				
本文内含YOLOv10网络结构图 + 各个创新模块手撕结构图 + 训练教程 + 推理教程 +  参数解析 + 环境搭建 + 数据集获取等一些有关YOLOv10的内容！目录一、前言二、整体网络结构图三、空间-通道分离下采样3.1 SCDown介绍3.2 C2fUIB介绍3.3 PSA介绍四、环境搭建五、数据集获取六、模型获取七、模型训练7.1 训练的三种方式7.1.1 方式一7.1.2 方式二（推荐）7.1.3 方式三八、模型验证/测试九、模型推理十、模型输出官方论文地址点击此处即可跳转。

			
		

	





	

		

			

				
					
抓住本源 触发心灵——读李松林教授《深度学习设计：模板与示例》有感(小学英语教师国培).docx

				
			

			

				

					10-25
				

			

		

		

			
				
抓住本源 触发心灵——读李松林教授《深度学习设计：模板与示例》有感(小学英语教师国培).docx

			
		

	





	

		

			

				
					
深度学习框架搭建

				
			

			

				

					qq_53640005的博客
				

				

					03-11
					
					589
					
				

			

		

		

			
				
深度学习框架搭建
框架一：torch
conda install pytorch-cpu -c pytorch 

pip install torchvision

框架二：tensorflow


（一）准备anaconda环境


（二）以管理员身份运行Anaconda Prompt


（三）创建tensorflow环境


conda create -n tensorflow python=3.6



（四）激活tensorflow环境


conda activate tensorflow




			
		

	





	

		

			

				
					
动手打造深度学习框架：基本数据结构与算法

				
			

			

				

					人邮异步社区
				

				

					06-16
					
					1014
					
				

			

		

		

			
				
我们要实现的元程序库要包含哪些内容呢？这个元程序库并不需要包含非常复杂的数据结构与算法，但应该具有足够的通用性，能够为我们的深度学习框架实现提供有力的支持。STL就是此类通用函数库中的一个典范：它包含的大部分数据结构与算法都比较简单，但被广泛地应用于各种C++程序的开发过程中。当然，C++标准模板库主要被应用于运行期，而我们要实现的元程序库则会在编译期大显身手。应用场景虽有所区别，但这并不妨碍我们借鉴STL的优秀设计。...

			
		

	





	

		

			

				
					
动手打造深度学习框架：元数据结构与算法

				
			

			

				

					人邮异步社区
				

				

					04-27
					
					699
					
				

			

		

		

			
				
元程序与运行期代码要解决的问题是有共通性的。这种共通性决定了很多运行期需要的数据结构与算法在元编程中也同样需要。将这些通用的数据结构与算法总结出来并加以实现，可以集中优化，便于后期使用。

事实上，这也正是很多元程序库所做的事情。本书并不打算使用某个元程序库，但讨论一下如何实现这些元程序库中的通用算法是非常有意义的。本质上，本章所讨论的可以视为一个微型元程序库的实现。通过实现这一元程序库，一方面，我们可以进一步熟悉元函数的编写方法；另一方面，我们也会看到一些元程序在编写过程中设计上的权衡，以及随之而来所衍生

			
		

	





	

		

			

				
					
李沐等：MXNet设计和实现简介

				
			

			

				

					klzhang的专栏
				

				

					12-03
					
					2430
					
				

			

		

		

			
				
我爱计算机
http://www.52cs.org/


@52cs 关注计算机领域进展

Skip
 to content



Home
About
友情
达人




李沐等：MXNet设计和实现简介


MXNet设计和实现简介

声明：本文经作者同意转载。

原始链接：https://github.com/dmlc/mxnet/issu

			
		

	





	

		

			

				
					
如何从0-1构建自己的”pytorch“(自己专属的深度学习框架)——part01

				
			

			

				

					flying_1314的博客
				

				

					07-21
					
					345
					
				

			

		

		

			
				
整体学习目标

建立属于你自己的深度学习框架
	Python创建线性回归模型，L1损失函数，L2损失函数
	参数初始化
	掌握梯度下降算法，创建优化器函数
	学会设置学习率以避免梯度爆炸
	掌握多个常用激活函数，Sigmoid， Relu，Tanh，Leaky_Relu，避免梯度消失
	掌握链式法则，计算图，拓扑，前馈/反向网络
创建线性回归模型

概念：首先该模型主要解决的情况是：你有一堆线性数据，你需要根据已知的样本数据，去拟合出一个模型或者说一条线，这样当你有新的数据点的时候，你就可以根据之前拟合出的

			
		

	





	

		

			

				
					
动手写深度学习框架（一）

				
			

			

				

					m0_63642362的博客
				

				

					03-22
					
					364
					
				

			

		

		

			
				
用python从零 手动实现深度学习框架（乞丐版）。从Tensor的实现，到 MLP 的构建，手写损失函数、随机梯度下降算法，能够实现基础 NN 网络的自动微分和反向传播，跑通MNIST

			
		

	





	

		

			

				
					
自制深度学习框架

				
			

			

				

					二毛的博客
				

				

					05-15
					
					2398
					
				

			

		

		

			
				
1.先写一些简单的函数，比如激活函数，把公式和求导的式子写出来，这个很简单，容易上手。 
2.写一个完整的前向传播和反向传播的过程。用代码实现。最后写一个简单的例子验证一下自己写的对不对。 
3.写一个基本的网络的计算模块。如CNn中的卷积，池化得前向反向传播等。 
4.写各类优化算法，基本的如sgd实现。...

			
		

	





	

		

			

				
					
手把手教你用Python实现简易深度学习框架

				
			

			

				

					
				

			

		

		

			
				
资源摘要信息:"基于Python实现一个简单的深度学习框架【***】"  在本次课程设计中，学生们需要完成一个大作业，即设计一个神经网络来拟合给定的函数表达式 $$y=\sin(x_1)-\cos(x_2), \qquad x_1, x_2\in[-5,5]$$。...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值