我手撸了一个乞丐版深度学习框架，已开源！

61eec4a1772a4b3acc8654b6a51e5862.png

文 | 王桂波@知乎
源 | 极市平台

当前深度学习框架越来越成熟，对于使用者而言封装程度越来越高，好处就是现在可以非常快速地将这些框架作为工具使用，用非常少的代码就可以构建模型进行实验，坏处就是可能背后地实现都被隐藏起来了。在这篇文章里笔者将设计和实现一个、轻量级的（约 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 组件将梯度更新到参数。

基本的框架图如下图

bbf4f01e020a8e38ebf46a757f5fbc0b.png

组件实现

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

# 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 = nameself.params, self.grads = None, Nonedef forward(self, inputs):raise NotImplementedErrordef 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 = Nonedef forward(self, inputs):self.inputs = inputsreturn inputs @ self.params["w"] + self.params["b"]def backward(self, grad):self.grads["w"] = self.inputs.T @ gradself.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 = Nonedef forward(self, inputs):self.inputs = inputsreturn self.func(inputs)def backward(self, grad):return self.derivative_func(self.inputs) * graddef func(self, x):raise NotImplementedErrordef derivative_func(self, x):raise NotImplementedErrorclass 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 = layersdef forward(self, inputs):for layer in self.layers:inputs = layer.forward(inputs)return inputsdef 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.gradsdef 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 交叉熵的损失为

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

402 Payment Required

代码实现如下

# loss.py
class BaseLoss(object):def loss(self, predicted, actual):raise NotImplementedErrordef grad(self, predicted, actual):raise NotImplementedErrorclass 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) / mdef grad(self, predicted, actual):m = predicted.shape[0]grad = np.copy(predicted)grad -= actualreturn grad / m

optimizer

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

# optimizer.py
class BaseOptimizer(object):def __init__(self, lr, weight_decay):self.lr = lrself.weight_decay = weight_decaydef compute_step(self, grads, params):step = list()# flatten all gradientsflatten_grads = np.concatenate([np.ravel(v) for grad in grads for v in grad.values()])# compute stepflatten_step = self._compute_step(flatten_grads)# reshape gradientsp = 0for 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 * vlayer[k] = _stepp += blockstep.append(layer)return stepdef _compute_step(self, grad):raise NotImplementedErrorclass 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, beta2self._eps = epsself._t = 0self._m, self._v = 0, 0def _compute_step(self, grad):self._t += 1self._m = self._b1 * self._m + (1 - self._b1) * gradself._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 = netself.loss = lossself.optimizer = optimizerdef 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, stepdef 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):# trainingpred = model.forward(batch.inputs)loss, grads = model.backward(pred, batch.targets)model.apply_grad(grads)# evaluate every epochtest_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}
4eb8091e4db3156b4b08d63c942ee0e6.png

可以看到两者效果上大差不差，测试集准确率都收敛到 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），因此上式可以化简为

402 Payment Required

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

代入上面的损失函数

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

402 Payment Required

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

参考

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

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

  • TensorFlow Documentation

  • PyTorch Documentation

ec6f3098e113b90504f4fd541e3b7852.png后台回复关键词【入群】

加入卖萌屋NLP、CV与搜推广与求职讨论群

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/477272.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

使用Intellij中的Spring Initializr来快速构建Spring Boot/Cloud工程

使用Intellij中的Spring Initializr来快速构建Spring Boot/Cloud工程

在之前的所有Spring Boot和Spring Cloud相关博文中，都会涉及Spring Boot工程的创建。而创建的方式多种多样，我们可以通过Maven来手工构建或是通过脚手架等方式快速搭建，也可以通过《Spring Boot快速入门》一文中提到的SPRING INITIALIZR页面工…
阅读更多...
剑指Offer - 面试题61. 扑克牌中的顺子

剑指Offer - 面试题61. 扑克牌中的顺子

1. 题目 从扑克牌中随机抽5张牌，判断是不是一个顺子，即这5张牌是不是连续的。2～10为数字本身，A为1，J为11，Q为12，K为13，而大、小王为 0 ，可以看成任意数字。A 不能视为 1…
阅读更多...
超越CLIP！谷歌发布首个大规模MoE架构的视觉语言模型

超越CLIP！谷歌发布首个大规模MoE架构的视觉语言模型

文 | 明敏（发自凹非寺）源 | 量子位多模态模型常见，但是基于稀疏化的还是头一个。谷歌带来最新成果LIMoE，首次将稀疏化方法用在了图像文本混合模型上。要知道，随着大模型参数呈指数级增加，训练成本也是一路飙…
阅读更多...
新年彩蛋：Spring Boot自定义Banner

新年彩蛋：Spring Boot自定义Banner

在2016年的最后一天，借用Spring Boot的Banner向各位程序猿同仁们问候一声：Happy New Year。 接下来我们就来介绍一下这个轻松愉快的自定义banner功能。实现的方式非常简单，我们只需要在Spring Boot工程的/src/main/resources目录下创建一个ba…
阅读更多...
剑指Offer - 面试题58 - II. 左旋转字符串

剑指Offer - 面试题58 - II. 左旋转字符串

1. 题目 字符串的左旋转操作是把字符串前面的若干个字符转移到字符串的尾部。请定义一个函数实现字符串左旋转操作的功能。比如，输入字符串"abcdefg"和数字2，该函数将返回左旋转两位得到的结果"cdefgab"。 示例 1： 输入…
阅读更多...
硬刚Meta！字节把元宇宙跳动到了美国

硬刚Meta！字节把元宇宙跳动到了美国

文 | 好困 拉燕源 | 新智元字节跳动招兵买马，组队「杀向」西海岸。如今元宇宙火得一塌糊涂，跟互联网挂钩的公司都想来掺一脚。最近，就连字节跳动也要进军元宇宙了！你给我等等，这是什么陈年旧闻？别急&#x…
阅读更多...
Spring Boot应用的后台运行配置

Spring Boot应用的后台运行配置

酱油一篇，整理一下关于Spring Boot后台运行的一些配置方式。在介绍后台运行配置之前，我们先回顾一下Spring Boot应用的几种运行方式： 运行Spring Boot的应用主类使用Maven的Spring Boot插件mvn spring-boot:run来运行打成jar包后&#xff0c…
阅读更多...
Spring Boot Actuator监控端点小结

Spring Boot Actuator监控端点小结

在Spring Boot的众多Starter POMs中有一个特殊的模块，它不同于其他模块那样大多用于开发业务功能或是连接一些其他外部资源。它完全是一个用于暴露自身信息的模块，所以很明显，它的主要作用是用于监控与管理，它就是：spr…
阅读更多...
剑指Offer - 面试题60. n个骰子的点数（动态规划）

剑指Offer - 面试题60. n个骰子的点数（动态规划）

1. 题目 把n个骰子扔在地上，所有骰子朝上一面的点数之和为s。输入n，打印出s的所有可能的值出现的概率。 你需要用一个浮点数数组返回答案，其中第 i 个元素代表这 n 个骰子所能掷出的点数集合中第 i 小的那个的概率。 示例 1: 输入: 1 输出…
阅读更多...
经典著作《动手学深度学习》中文版2.0beta版发布！开源下载！

经典著作《动手学深度学习》中文版2.0beta版发布！开源下载！

2020年疫情刚开始的时候，《动手学深度学习》的英文版相较中文版已经多出不少内容了。我们书第一版的不少老读者表示，疫情在家虽然想学习，但第一版早就刷完，于是只好刷阿信和小抖。沐神和我的第一反应是：这样对眼睛不好…
阅读更多...
使用Spring StateMachine框架实现状态机

使用Spring StateMachine框架实现状态机

Spring StateMachine框架可能对于大部分使用Spring的开发者来说还比较生僻，该框架目前差不多也才刚满一岁多。它的主要功能是帮助开发者简化状态机的开发过程，让状态机结构更加层次化。前几天刚刚发布了它的第三个Release版本1.2.0，其中增加了…
阅读更多...
滴滴退市了

滴滴退市了

文 | 彭小伟, 编 | 刘芳源 | 网约车焦点美东时间6月10日，滴滴正式在纽交所退市。根据官方通告，滴滴在完成退市后，其股份会转移到OTC（Over-the-Counter，场外交易市场）进行交易，交易代码为“DIDIY…
阅读更多...
剑指Offer - 面试题62. 圆圈中最后剩下的数字（约瑟夫环 递推公式）

剑指Offer - 面试题62. 圆圈中最后剩下的数字（约瑟夫环 递推公式）

1. 题目 0,1,…,n-1这n个数字排成一个圆圈，从数字0开始，每次从这个圆圈里删除第m个数字。求出这个圆圈里剩下的最后一个数字。 例如，0、1、2、3、4这5个数字组成一个圆圈，从数字0开始每次删除第3个数字，则删除的前4个…
阅读更多...
Spring Boot中使用MyBatis注解配置详解

Spring Boot中使用MyBatis注解配置详解

之前在Spring Boot中整合MyBatis时，采用了注解的配置方式，相信很多人还是比较喜欢这种优雅的方式的，也收到不少读者朋友的反馈和问题，主要集中于针对各种场景下注解如何使用，下面就对几种常见的情况举例说明用法。 在…
阅读更多...
何恺明团队的“视频版本MAE”，高效视频预训练！Mask Ratio高达90%时效果也很好！...

何恺明团队的“视频版本MAE”，高效视频预训练！Mask Ratio高达90%时效果也很好！...

文 | 小马源 | 我爱计算机视觉本篇文章分享论文『Masked Autoencoders As Spatiotemporal Learners』，由何恺明团队提出视频版本的 MAE，进行高效视频预训练！Mask Ratio 高达 90% 时效果很好！详细信息如下：论文链接&…
阅读更多...
剑指Offer - 面试题45. 把数组排成最小的数（字符串排序）

剑指Offer - 面试题45. 把数组排成最小的数（字符串排序）

1. 题目 输入一个正整数数组&#xff0c;把数组里所有数字拼接起来排成一个数&#xff0c;打印能拼接出的所有数字中最小的一个。 示例 1: 输入: [10,2] 输出: "102"示例 2: 输入: [3,30,34,5,9] 输出: "3033459"提示: 0 < nums.length < 100 说明…
阅读更多...
Spring Boot整合MyBatis

Spring Boot整合MyBatis

最近项目原因可能会继续开始使用MyBatis&#xff0c;已经习惯于spring-data的风格&#xff0c;再回头看xml的映射配置总觉得不是特别舒服&#xff0c;接口定义与映射离散在不同文件中&#xff0c;使得阅读起来并不是特别方便。 Spring中整合MyBatis就不多说了&#xff0c;最近…
阅读更多...
谷歌放弃Tensorflow，全面拥抱JAX

谷歌放弃Tensorflow，全面拥抱JAX

文 | Matthew Lynley源 | 机器之心编辑部TensorFlow 大概已经成为了谷歌的一枚「弃子」。2015 年&#xff0c;谷歌大脑开放了一个名为「TensorFlow」的研究项目&#xff0c;这款产品迅速流行起来&#xff0c;成为人工智能业界的主流深度学习框架&#xff0c;塑造了现代机器学习…
阅读更多...
LeetCode 第 20 场双周赛（294 / 1541，前19.07%，第1次全部通过）

LeetCode 第 20 场双周赛（294 / 1541，前19.07%，第1次全部通过）

文章目录1. 比赛结果2. 题目LeetCode 5323. 根据数字二进制下 1 的数目排序 easyLeetCode 5324. 每隔 n 个顾客打折 mediumLeetCode 5325. 包含所有三种字符的子字符串数目 mediumLeetCode 5326. 有效的快递序列数目 hard1. 比赛结果 第一次全部做出来了&#xff0c;提前6分钟…
阅读更多...
Spring Boot中的缓存支持（二）使用Redis做集中式缓存

Spring Boot中的缓存支持（二）使用Redis做集中式缓存

上一篇介绍了在Spring Boot中如何引入缓存、缓存注解的使用、以及EhCache的整合。 虽然EhCache已经能够适用很多应用场景&#xff0c;但是由于EhCache是进程内的缓存框架&#xff0c;在集群模式下时&#xff0c;各应用服务器之间的缓存都是独立的&#xff0c;因此在不同服务器…
阅读更多...
最新文章

Copyright @ 2022~2023