推荐系统系列第 7 部分:用于协同过滤的玻尔兹曼机器的 3 种变体
RecSys 系列
物理符合推荐
更新: 本文是我探索学术界和工业界推荐系统系列文章的一部分。查看完整系列: 第一部分 ， 第二部分 ， 第三部分 ，第四部分 ，第五部分 ， 第六部分
我去年读过的最好的人工智能相关书籍之一是特伦斯·塞伊诺夫斯基的《深度学习革命》这本书解释了深度学习是如何从一个模糊的学术领域变成信息时代一项有影响力的技术的。作者 Terry Sejnowski 是深度学习的先驱之一，他与 Geoffrey Hinton 一起创造了 Boltzmann machines :一个与大脑中的学习有着惊人相似之处的深度学习网络。
深度学习革命(【https://mitpress.mit.edu/books/deep-learning-revolution】)
我最近听了一个关于人工智能的播客，特伦斯讨论了机器做梦，玻尔兹曼机器的诞生，大脑的内部运作，以及在神经网络中重建它们的过程。特别是，他和 Geoff Hinton 用物理学启发的架构发明了玻尔兹曼机器:
- 每个单元有一个概率产生一个随输入量变化的输出。
- 他们给网络输入，然后跟踪网络内的活动模式。对于每个连接，他们跟踪输入和输出之间的相关性。然后，为了能够学习，他们摆脱输入，让网络自由运行，这被称为睡眠阶段。
- 学习算法很直观:他们从唤醒学习阶段减去睡眠阶段相关性，然后相应地调整权重。对于足够大的数据集，该算法可以有效地学习输入和输出之间的任意映射。
玻尔兹曼机器的类比被证明是一个很好的洞察睡眠期间人类大脑中发生了什么。在认知科学中，有一个概念叫做回放，海马体向皮层回放我们的记忆和经历，然后皮层将其整合到我们关于世界的语义知识库中。
这是一种啰嗦的方式来说，我对探索玻尔兹曼机器感兴趣有一段时间了。看到他们在推荐系统中的应用，我欣喜若狂！
在这篇文章和接下来的文章中，我将介绍推荐系统的创建和训练，因为我目前正在做这个主题的硕士论文。
- 第 1 部分提供了推荐系统的高层次概述，它们是如何构建的，以及它们如何被用来改善各行各业的业务。
- 第 2 部分对正在进行的关于这些模型的优势和应用场景的研究计划进行了有益的回顾。
- 第 3 部分提供了几个可能与推荐系统学者社区相关的研究方向。
- 第 4 部分提供了可以构建的矩阵分解的 7 种变体的本质数学细节:从使用巧妙的侧面特征到贝叶斯方法的应用。
- 第 5 部分提供了基于多层感知器的协同过滤模型的 5 个变体的架构设计，这些模型是能够以非线性方式解释特征的判别模型。
- 第 6 部分提供了基于协作过滤模型的自动编码器的六个变体的主类，这些模型是在学习底层特征表示方面更胜一筹的生成模型。
在第 7 部分中，我探索了使用波尔兹曼机器进行协同过滤。更具体地说，我将剖析三篇将玻尔兹曼机器纳入其推荐架构的原则性论文。但首先，让我们浏览一下玻尔兹曼机器及其变体的初级读本。
玻尔兹曼机及其变体入门
“玻尔兹曼机器是一个由对称连接的神经元样单元组成的网络，可以随机决定是开还是关。玻尔兹曼机器有一个简单的学习算法，允许它们在由二进制向量组成的数据集中发现有趣的特征。在具有许多层特征检测器的网络中，学习算法非常慢，但是通过一次学习一层特征检测器，可以使学习算法快得多。”
为了进一步揭示这一点，Hinton 指出，我们可以使用 Boltzmann 机器来解决两种不同的计算问题:
- **搜索问题:**玻尔兹曼机器在连接上具有固定的权重，其被用作优化过程的成本函数。
- **学习问题:**给定一组二进制数据向量，我们的目标是找到连接上的权重，以优化训练过程。玻尔兹曼机器通过解决搜索问题的多次迭代来更新权重值。
受限玻尔兹曼机 (RBM)是玻尔兹曼机的一种特殊类型，有两层单元。如下图所示，第一层由可见单元组成，第二层包括隐藏单元。在这种受限的体系结构中，层中的单元之间没有连接。
马尼什·纳亚克——RBM 直观介绍(https://medium . com/datadriveninvestor/An-Intuitive-Introduction-of-restricted-Boltzmann-machine-RBM-14f 4382 A0 dbb)
模型中可见的单元对应于观察到的组件，隐藏的单元代表这些观察到的组件之间的依赖关系。目标是对可见和隐藏单元的联合概率建模: p(v，h) 。因为隐藏单元之间没有连接，所以学习是有效的，因为给定可见单元，所有隐藏单元都是有条件独立的。
一个深度信念网络 (DBN) 是一个多层学习架构，它使用一堆 RBM 来提取训练数据的深度分层表示。在这样的设计中，每个子网络的隐藏层充当即将到来的子网络的可见层。
himan Shu Singh-Deep Belief Networks:An Introduction(https://medium . com/analytics-army/Deep-Belief-Networks-An-Introduction-1d 52 bb 867 a 25)
当通过 DBN 学习时，首先通过将原始数据输入到可视单元中来训练底层的 RBM。然后，固定参数，并将 RBM 的隐藏单元用作第二层 RBM 的输入。学习过程继续进行，直到到达堆叠子网络的顶部，最后，获得合适的模型以从输入中提取特征。由于学习过程是无监督的，因此通常会在 DBN 的末尾添加一个新的监督学习网络，以用于分类或回归(上图中的逻辑回归图层)等监督学习任务。
好了，是时候回顾一下不同的基于波尔兹曼机器的推荐框架了！
1-用于协同过滤的受限玻尔兹曼机器
回想一下在经典的协同过滤设置中，我们试图用维度 n x d 对评级(用户-项目交互)矩阵 X 进行建模，其中 n 是用户数量，d 是项目数量。条目 xᵢⱼ (第 I 行，第 j 列)对应于用户 I 对项目 j 的评级。在 MovieLens 数据集中(在我之前的所有帖子中都使用过)，xᵢⱼ ∈ 0，1，2，3，4，5(其中 0 代表缺失的评级)。
- 例如，xᵢⱼ = 2 意味着用户 I 给电影 j 的评分是 2 分(满分 5 分)。另一方面，xᵢⱼ = 0 意味着用户没有评价电影 j
- X 行编码每个用户对所有电影的偏好，X 列编码所有用户收到的每个项目的评级。
从形式上来说，我们将协同过滤上下文中的预测和推断定义如下:
- **预测:**给定观察评分 X，预测 x_{im}(用户 I 给新查询电影 m 的评分)。
- **推论:**计算概率 p(x_{im} = k | Xₒ)(其中 Xₒ表示 x 和 k ∈ 0，1，2，3，4，5 的非零项)。
RBM 架构中提出的 受限玻尔兹曼机用于协同过滤
Salakhutdinov、Mnih 和 Hinton 将计算 p(x_{im} = k | Xₒ)的任务框定为对具有训练参数的底层 RBM 的推断。数据集被细分为评级矩阵，其中用户的评级被一次性编码到矩阵 v 中，使得如果用户用评级 k 对电影 j 进行评级，则 vⱼᵏ = 1。上图说明了 RBM 图:
- v 是一个 5×d 矩阵，对应于用户的独热编码整数等级。
- h 是二进制隐变量的 F×1 向量，其中 F 是隐变量的个数。
- w 是一个 d x F x 5 张量，它对评级和隐藏特征之间的邻接关系进行编码。它的入口 Wⱼcᵏ对应于电影 j 的等级 k 和隐藏特征 c 之间的边缘电势
整个用户-项目交互矩阵是 V (s)的集合，其中每个 V 对应每个用户的评分。因为每个用户可能有不同的缺失值，所以每个用户都有一个唯一的 RBM 图。在每个 RBM 图中，边连接评级和隐藏功能，但不会出现在缺失评级的项目之间。这篇论文把 W 看作是连接在所有这样的 RBM 图上的一组边势。
在训练阶段，RBM 使用条件概率 p(vⱼᵏ = 1 | h) 和 p(hₐ = 1 | V) 来表征评级和隐藏特征之间的关系:
等式 1
等式 2
得到这些概率后，还有两个额外的步骤来计算 p(vₒᵏ = 1 | V) :
- 基于观察到的评级 v 和每个 a)的边缘势 W (p(hₐ = 1 | V)计算 h 中每个隐藏特征的分布。
- 基于边缘电势 w 和 p(hₐ的分布计算 p(vₒᵏ = 1 | V。
在优化阶段，通过 V — p(V) 的边际似然对 W 进行优化。使用对比散度计算梯度∇ Wᵢⱼᵏ，这是基于 Gibbs 抽样的梯度的近似值:
等式 3
期望值<.> _T 代表运行吉布斯采样器得到的样本分布，在数据处初始化，用于 T 个完整步骤。t 通常在学习开始时设置为 1，并随着学习的收敛而增加。当运行 Gibbs 采样器时，RBM 重构(如等式 1 所示)非缺失评级的分布。对比散度的近似梯度然后可以在所有 n 个用户上平均。
为了便于说明，下面给出了 RBM 模型类的 PyTorch 代码:
对于我的 PyTorch 实现，我设计了 RBM 架构，它有一个由非线性 sigmoid 函数激活的 100 个单元的隐藏层。其他超参数包括批次大小 512 和时期 50。
2 —用于协同过滤的可解释的受限玻尔兹曼机器
对建议的解释可以有多种好处，包括有效性(帮助用户做出正确的决定)、效率(帮助用户做出更快的决定)和透明度(揭示建议背后的推理)。在 RBM 的例子中，它将一组低维的特征分配给潜在空间中的项目，很难解释这些习得的特征。因此，一个巨大的挑战是为 RBM 选择一种预测精度适中的可解释技术。
Abdollahi 和 Nasraoui 为一个协同过滤推荐系统设计了一个 RBM 模型，该系统在保持准确性的同时建议可以解释的项目。该论文的范围仅限于在解释中不使用额外数据源的建议，以及仅由活动用户的邻居从对这些项目给出的评级中可以生成对推荐项目的解释。
推荐项目的基于用户的邻居风格解释的例子，如在 可解释的 RBM 用于 CF 中提出的
主要思想是，如果许多邻居已经对推荐的项目进行了评级，那么这可以使用邻居风格的解释机制来提供解释推荐的基础。对于基于用户的邻居风格的解释，如上图所示，用户 u 的项目 I 的可解释性得分被定义为:
等式 4
这里 N_k (u) 是用户 u 的 k 个邻居的集合， r_{x，i} 是 x 对项目 I 的评分， R_max 是 N_k (u)对 I 的最大评分值，余弦相似度定义邻域。在没有信息损失的情况下，对于缺失评分，r_{x，i}为 0，表明用户 x 对于用户 u 对项目 I 的基于用户的邻居式解释没有贡献，因此，可解释性得分在 0 和 1 之间。只有当项目 I 的可解释性得分大于 0 时，项目 I 对于用户 u 才是可解释的。当无法解释时，可解释率为 0。
为了便于说明，下面给出了 RBM 模型等级的张量流代码:
对于我的 TensorFlow 实现，我设计了 RBM 架构，它有一个由非线性 sigmoid 函数激活的 100 个单元的隐藏层。其他超参数包括批次大小 512 和时期 50。我还给一个假设用户展示了一个示例推荐列表，其中包括可解释性得分。
3 —用于协同过滤的神经自回归分布估计器
RBM 模型的一个问题是它遭受不准确和不切实际的长训练时间，因为:(1)训练是难以处理的，和(2)需要变分近似或马尔可夫链蒙特卡罗。 Uria，Cote，Gregor，Murray，Larochelle 提出了所谓的神经自回归分布估计量 (NADE)，这是一种对高维二元向量的易处理的分布估计量。估计器计算每个元素的条件概率，给定二进制向量中其左侧的其他元素，其中所有条件共享相同的参数。二元向量的概率可以通过这些条件的乘积得到。通过反向传播可以有效地优化 NADE，而不是像 RBM 那样需要昂贵的推理来处理潜在变量。
如下图 NADE 所示:
- 在输入图层中，值为 0 的单位显示为黑色，值为 1 的单位显示为白色。虚线边框表示层预激活。
- 输出 x^_0 给出了向量 x_0 的每个维度的预测概率，以某种顺序给出了前面的元素。
- 在输出和被预测的值之间，或者在排序中的 x_0 的后面的元素之间，没有连接的路径。
- 连接的箭头对应于具有共享参数的连接。
一个 NADE 模型的示意图，如图 神经自回归分布估计
郑、唐、丁、周提出 CF-NADE ，其灵感来源于-CF 和模型，对用户评分分布进行建模。假设我们有四部电影:m1(评分为 5)、m2(评分为 3)、m3(评分为 4)和 m4(评分为 2)。更具体地说，过程如下:
- 无条件下用户给 m1 五星的概率。
- 在给 m1 5 星的条件下，用户给 m2 3 星的概率。
- 用户给 m3 4 星的概率，条件是给 m1 5 星，给 m2 3 星。
- 用户给予 m4 2 星的概率，条件是给予 m1 5 星、m2 3 星和 m3 4 星。
从数学上讲，CF-NADE 通过链式法则将评级向量 r 的联合概率建模为:
等式 5
- d 是用户已经评级的项目的数量。
- o 是(1，2，…，D)排列中的 D 元组。
- mᵢ ∈ {1，2，…，M}是第 I 个评级项的指标。
- rᵘ = (rᵘ_{m_{o₁}}，rᵘ_{m_{o₂}}，…，rᵘ_{m_{oD}})表示用户 u 的训练案例
- rᵘ_{m_{oᵢ}} ∈ {1，2，…，K}表示用户对项目 m_{oᵢ}.的评价
- rᵘ_{m_{o
To expand on the process of getting the conditionals in equation 5, CF-NADE first computes the hidden representation of dimension H given rᵘ_{m_{o
Equation 6
- g is the activation function.
- Wᵏ is the connection matrix associated with rating k.
- Wᵏ_{:,j} is the j-th column of Wᵏ and Wᵏ_{i,j} is an interaction parameter between the i-th hidden unit and item j with rating k.
- c is the bias term.
Using this hidden representation from equation 6, CF-NADE then computes sᵏ_{m_{oᵢ}} (r_{m_{o_{
Equation 7
Vʲ and bʲ are the connection matrix and the bias term associated with rating k, respectively, where k is bigger than or equal to j. Using this score from equation 7, the conditionals in equation 5 could be modeled as:
Equation 8
CF-NADE is optimized via minimization of the negative log-likelihood of p® in equation 5:
Equation 9
Ideally, the order of movies (represented by notation o) should follow the timestamps of ratings. However, the paper shows that random drawing can yield good performance.
The Keras code of the CF-NADE model class is given below for illustration purpose:
For 我的 Keras 实现，我设计了一个包含 100 个单元的隐藏层，通过 Adam 优化，学习率为 0.001。其他超参数包括批次大小 512 和时期 50。
模型评估
您可以查看我在这个资源库中构建的所有三个基于波尔兹曼机器的推荐模型:https://github . com/khanhnamle 1994/transfer-rec/tree/master/Boltzmann-Machines-Experiments。
- 数据集是 MovieLens 1M ，类似于我之前用矩阵分解、多层感知器和自动编码器做的三个实验。目标是预测用户对一部电影的评价，其中评价在 1 到 5 之间。
- 在该设置中，评估度量是均方根误差(RMSE)* 。换句话说，我希望最小化预测评级和实际评级之间的差值。***
- 结果表在我回购的自述底部:可解释的 RBM 模型 RMSE 最低，训练时间最短，NADE 模型 RMSE 最高，训练时间最长。
结论
在这篇文章中，我讨论了玻尔兹曼机器的基本原理及其在协同过滤中的应用。我还浏览了 3 篇不同的论文，这些论文使用了受波尔兹曼机器启发的架构作为推荐框架:(1)受限波尔兹曼机器，(2)可解释的受限波尔兹曼机器，以及(3)神经自回归分布估计器。
还有几篇值得一提的论文，我还没来得及细说:
- 乔尔杰夫和纳科夫使用 RBMs 联合建模:(1)用户投票项目之间的相关性和(2)对特定项目投票的用户之间的相关性，以提高推荐系统的准确性。
- 胡等在基于群体的推荐系统中使用，通过联合建模集体特征和群体简档来建模群体偏好。
- Truyen 等人使用 Boltzmann 机器来提取两者:(1)评级项目与其评级之间的关系(由于隐藏层和 softmax 层之间的连接)以及(2)评级项目之间的相关性(由于 softmax 层单元之间的连接)。
- Gunawardana 和 Meek 不仅使用 Boltzmann 机器来建模用户和项目之间的相关性，还用于整合内容信息。更具体地说，模型参数与内容信息联系在一起。
请继续关注本系列的下一篇博文，它将探讨推荐系统环境中的各种评估指标。
参考
- 受限玻尔兹曼机协同过滤 。Ruslan Salakhutdinov，Andriy Mnih 和 Geoffrey Hinton。2007 年 6 月。
- **可解释受限玻尔兹曼机进行协同过滤 。贝努什·阿多拉希和奥尔法·纳斯拉维。2016 年 6 月。
- 一种神经自回归的协同过滤方法 。、唐、丁、周汉宁。2016 年 5 月。
如果你想关注我在推荐系统、深度学习和数据科学新闻方面的工作，你可以查看我的 中的 和GitHub，以及在【https://jameskle.com/】的其他项目。你也可以在 推特 ， 直接发邮件给我 ，或者 在 LinkedIn 上找我 。 注册我的简讯 就在你的收件箱里接收我关于研究和生产中的机器学习的最新想法吧！**
递归集成学习
冥想计划
用竞争神经网络提高文本生成质量
塞内卡图像来自 Jean-Pol GRANDMONT 制作的17 世纪匿名雕塑家制作的塞内卡半身像，由 3.0 授权于 CC。背景图片来自银河全景图由 ESO 提供，由 4.0 授权 CC。
我一直在设计几个斯多葛派哲学家——都是用 TensorFlow 构建的。他们中的一些人创造了辉煌的文本，但随后会陷入疯狂的状态***(不是一件非常坚忍的事情)并说出类似(!EPLYZzzFxZFKzPZjQYCVS(!C!HZwEL(]SzKz]FXXKHzzzPP[(的话。*
其他哲学家会写出可读的文本，但不是特别有趣。但是他们会更加稳定。
这两个问题的解决方案——让这些现在的角斗士哲学家进行生死决斗。场地？体育馆里欢呼的人群已经被没有灵魂的短语排名算法所取代。
因此，在开始之前，我们将介绍:
- 使用几个竞争的 RNN 模型(我们的哲学角斗士****
- 评定模型输出(体育馆和****
- 将这些放在一起产生一些神奇的东西(一个冠军角斗士的哲学名言——或者实际上，我们的几个角斗士)
莫拉莱斯书信
我们的角斗士将学习马可·奥勒留的冥想和鲁契留的书信。我们混合使用了requests和BeautifulSoup库来获取它们。
为了你的兴趣，我不会描述这个过程。但是你可以在这里找到code/data.py中的代码。
全体
使用一个名为gladiator_predict的简单函数来控制模型的集合。
模型名称列表被传递给这个函数——它加载模型，然后遍历每个模型——用generate生成文本，用rate对文本进行评级**。**
然后，我们根据分数对这些输出进行排序，并将获胜的序列传递回generate，就像这样:
完整代码见此处。
当我们生成更多文本时，能够选择最佳序列对我们的输出有巨大的影响。
在之前，模型会产生合理的文本，但经常会陷入无意义的胡言乱语**——然后回到雄辩的“斯多葛派的冥想。**
现在，一旦一个模特陷入这种胡言乱语的状态，她就输了👎
然后，我们的模型将继续丢失，直到它再次生成英文文本👍****
竞技场
决定哪个哲学家角斗士产生了最好的输出的关键是rate函数。
rate给出一个角斗士的冥想，并根据几个因素进行评分:
- 冥想是否以正确的标点符号结束？
✔ ️ "this whole world is my country."
❌ "Thy knows what **Z**"
- 冥想包含多少重复**？**
✔ ️ "About what am I now employing my own soul?"
❌ "But **I know** how many **I know** and **I know**."
- 这些词存在于词汇中吗？
✔ ️ "Do not act as if thou wert going to live ten thousand years."
❌ "**Turramoly**? When **hishich** is deity, from there is places the **smater**."
综上所述，我们可以根据这个分数生成输出:
谁赢了？
gladiator_predict中的vis参数允许我们可视化我们的角斗士表演:
我们可以看到这是一场戏剧性的战斗。但最终，角斗士哲学家 LSTM_e512_sl250_0414 产生了最好和最一致的哲学。
使用一组模型的优势在这张图片中是显而易见的。 e128 产生了一些得分最高的输出。但是在迭代 36 和 47 时也产生了一些可怕的输出。
****如果没有合奏来支持 e128 ，迭代 36 和 47 中所说的任何胡言乱语都将进入最终输出。
幸运的是，我们有几个更好的选择。
在这次演出中，我们的合奏制作了这篇短文。
Do you ask any man with a book: here you ask these fellows, who indeed make thy thing greater. That which you declared if you consider any man a friend whom you are to distinguish between investigation to every man accordingly.That even in the scholar's abyss in study, and the senses may need desired, but the world walls he should not *abroughly* handle soil, which turn to the fact where the good seeks a fame of living things, and likewise to disease to meet us to other also, that we can come *alood* of it again in all respects, but not boast of his own strength; but what kind out my lot has been broken, it *goan* us generations, and was reached when one fights away upon a period of labour! This is the words of Socrates.
感谢阅读！
如果你对这个项目感兴趣，你可以在这里找到回购协议。我还写了关于初始构建的内容，您可以在这里阅读:
再现历史上最有权势的人之一所写的斯多葛派哲学
towardsdatascience.com](/stoic-philosophy-built-by-algorithms-9cff7b91dcbd)**
递归神经网络
理解 RNN 背后的直觉！
按作者分列的数字
介绍
本文的目标是深入探讨递归神经网络，这是一种具有不同于前几篇文章(链接)中所见的架构的神经网络。
具体而言，文章分为以下几个部分:
- 什么是 rnn
- 长短期记忆(LSTM)网络
- 时间序列的 RNNs 实现
什么是 rnn？
正如我们在这里看到的，CNN 没有任何记忆，rnn 每次都可以超越“从头开始思考”的限制，因为它们有某种记忆。
让我们用一个非常直观的例子来看看它们是如何工作的:
例子
假设我们住在公寓里，有一个完美的室友，他会根据天气做不同的饭菜，晴天还是雨天。
按作者分列的数字
所以，如果我们用向量来编码这些食物:
按作者分列的数字
我们的神经网络会做以下事情:
按作者分列的数字
如果我们回想一下，神经网络学习一些可以用矩阵表示的权重，这些权重用于进行预测。我们的将如下:
如果是晴天:
按作者分列的数字
如果是雨天:
按作者分列的数字
如果我们看一下我们的权重矩阵，这次是一个图表:
按作者分列的数字
现在让我们看看在这个例子之后添加了什么 rnn:
递归神经网络
比方说，现在我们亲爱的室友不仅根据天气来决定做什么，而且现在只看他昨天做了什么。
负责根据室友今天做的菜来预测她明天会做什么菜的网络是一个递归神经网络(RNN)。
这个 RNN 可以表示为下面的矩阵:
按作者分列的数字
所以我们有一个:
按作者分列的数字
让我们把它变得稍微复杂一点
现在想象一下，你的室友根据她昨天做的菜和天气决定做什么菜。
- 如果天气晴朗，她会手里拿着一瓶上好的啤酒在阳台上呆一天，所以她不做饭，所以我们吃和昨天一样的东西。但是
- 如果下雨，她就呆在家里做饭。
大概是这样的:
按作者分列的数字
因此，我们最终有了一个模型，它根据我们昨天吃的东西告诉我们将要吃什么，而另一个模型告诉我们我们的室友是否会做饭。
按作者分列的数字
添加和合并操作如下:
按作者分列的数字
按作者分列的数字
这里你可以看到图表:
按作者分列的数字
这就是它的工作原理！
这个例子来自一个很棒的视频，我建议你根据需要多次查看，深入理解前面的解释。你可以在这里找到视频:https://www.youtube.com/watch?v=UNmqTiOnRfg
rnn 是用来做什么的？
有几种类型:
按作者分列的数字
他们非常擅长做出预测，尤其是当我们的数据是连续的时候:
股市预测
一只股票的价值很大程度上取决于它以前的价值
序列生成
只要数据是序列，数据在一个瞬间 t 取决于数据在瞬间 t-1。
文本生成
比如你手机提示单词的时候。它看着你写的最后一个单词，看着你正在写的字母，暗示下一个字母甚至单词。
语音识别
在这种情况下，我们可以识别出前一个单词，并在那一刻接收到音频。
长短期记忆网络
现在让我们研究一下最流行的 RNN 是如何工作的。它们是 LSTM 网络，其结构如下:
按作者分列的数字
但是首先:为什么他们是最受欢迎的？
原来常规的 rnn 都有内存问题。专门设计的记忆网络无法进行长期记忆。为什么这是一个问题？
好吧，回到我们室友的问题，对于这个例子，我们只需要知道我们昨天吃了什么，所以什么都不会发生。
按作者分列的数字
但是想象一下，如果不是三道菜的菜单，而是 60 道菜。
按作者分列的数字
传统的 rnn 无法记住很久以前发生的事情。然而，LSTM 会！
为什么呢？
让我们来看看 RNN 和 LSTM 的建筑:
RNN
按作者分列的数字
LSTM
按作者分列的数字
事实证明，rnn 只有一层，而 LSTMs 有多层的组合，它们以一种非常特殊的方式相互作用。
让我们试着理解这一点，但首先，让我解释一下术语:
按作者分列的数字
在上图中:
- 向量沿着每条线传播，从一个节点的输出到其他节点的输入。
- 粉色圆圈表示元素到元素的运算，例如向量和，而黄色方框是通过训练学习的神经层。
- 连接的线表示连接，分隔的线表示相同的行内容到达两个不同的目的地。
LSTMs 的核心思想
关键是单元的状态，它在图中表示为穿过顶部的线:
按作者分列的数字
细胞的状态就像一种传送带，它沿着网络的整个结构行进，很少交互作用(并且它们是线性的):这意味着信息只是简单地流动而没有被修改。
巧妙之处在于，LSTM 的各层可以(或不可以)向这条传送带提供信息，而这个决定是由“门”做出的:
按作者分列的数字
这些门只不过是一种小心调节到达传送带的信息的方式。它们由具有 sigmoid 型激活和元素乘法的神经网络组成。
因此，sigmoid 层输出一个介于 0 和 1 之间的数字，这意味着让信息传递到传送带有多重要。0 表示我不在乎，1 表示非常重要。
如图所示，一台 LSTM 有 3 个这样的门，用于保护和控制传送带。
关于这个操作的具体细节，在这里有很大的解释:http://colah.github.io/posts/2015-08-Understanding-LSTMs/
而且这个博客也很有意思:【http://karpathy.github.io/2015/05/21/rnn-effectiveness/】T2
考虑到这一点，让我们看看循环网络可以做什么！
LSTM 实施
LSTM 图像分类
我们将遵循一个可以在此找到的示例:
from keras.models import Sequential
from keras.layers import LSTM, Dense
from keras.datasets import mnist
from keras.utils import np_utils
from keras import initializers
**# Hyper parameters**
batch_size = 128
nb_epoch = 10**# Parameters for MNIST dataset**
img_rows, img_cols = 28, 28
nb_classes = 10**# Parameters for LSTM network**
nb_lstm_outputs = 30
nb_time_steps = img_rows
dim_input_vector = img_cols**# Load MNIST dataset**
(X_train, y_train), (X_test, y_test) = mnist.load_data()
print('X_train original shape:', X_train.shape)
input_shape = (nb_time_steps, dim_input_vector)X_train = X_train.astype('float32') / 255.
X_test = X_test.astype('float32') / 255.Y_train = np_utils.to_categorical(y_train, nb_classes)
Y_test = np_utils.to_categorical(y_test, nb_classes)print('X_train shape:', X_train.shape)
print(X_train.shape[0], 'train samples')
print(X_test.shape[0], 'test samples')
**# LSTM Building**
model = Sequential()
model.add(LSTM(nb_lstm_outputs, input_shape=input_shape))
model.add(Dense(nb_classes, activation='softmax'))
model.compile(optimizer='rmsprop', loss='categorical_crossentropy', metrics=['accuracy'])
model.summary()
**# Training the model**
history = model.fit(X_train,
Y_train,
nb_epoch=nb_epoch,
batch_size=batch_size,
shuffle=True,
validation_data=(X_test, Y_test),
verbose=1)
**# Evaluation**
evaluation = model.evaluate(X_test, Y_test, batch_size=batch_size, verbose=1)
print('Summary: Loss over the test dataset: %.2f, Accuracy: %.2f' % (evaluation[0], evaluation[1]))
用 LSTM 进行时间序列预测
# LSTM for international airline passengers problem with regression framing
# [https://machinelearningmastery.com/time-series-prediction-lstm-recurrent-neural-networks-python-keras/](https://machinelearningmastery.com/time-series-prediction-lstm-recurrent-neural-networks-python-keras/)
!wget [https://raw.githubusercontent.com/lazyprogrammer/machine_learning_examples/master/airline/international-airline-passengers.csv](https://raw.githubusercontent.com/lazyprogrammer/machine_learning_examples/master/airline/international-airline-passengers.csv)import numpy
import matplotlib.pyplot as plt
from pandas import read_csv
import math
from keras.models import Sequential
from keras.layers import Dense
from keras.layers import LSTM
from sklearn.preprocessing import MinMaxScaler
from sklearn.metrics import mean_squared_error**# convert an array of values into a dataset matrix**
def create_dataset(dataset, look_back=1):
dataX, dataY = [], []
for i in range(len(dataset)-look_back-1):
a = dataset[i:(i+look_back), 0]
dataX.append(a)
dataY.append(dataset[i + look_back, 0])
return numpy.array(dataX), numpy.array(dataY)**# fix random seed for reproducibility**
numpy.random.seed(7)**# load the dataset**
dataframe = read_csv('international-airline-passengers.csv', usecols=[1], engine='python', skipfooter=3)
dataset = dataframe.values
dataset = dataset.astype('float32')**# normalize the dataset**
scaler = MinMaxScaler(feature_range=(0, 1))
dataset = scaler.fit_transform(dataset)**# split into train and test sets**
train_size = int(len(dataset) * 0.67)
test_size = len(dataset) - train_size
train, test = dataset[0:train_size,:], dataset[train_size:len(dataset),:]**# reshape into X=t and Y=t+1**
look_back = 1
trainX, trainY = create_dataset(train, look_back)
testX, testY = create_dataset(test, look_back)**# reshape input to be [samples, time steps, features]**
trainX = numpy.reshape(trainX, (trainX.shape[0], 1, trainX.shape[1]))
testX = numpy.reshape(testX, (testX.shape[0], 1, testX.shape[1]))**# create and fit the LSTM network**
model = Sequential()
model.add(LSTM(4, input_shape=(1, look_back)))
model.add(Dense(1))
model.compile(loss='mean_squared_error', optimizer='adam')
model.fit(trainX, trainY, epochs=100, batch_size=1, verbose=2)**# make predictions**
trainPredict = model.predict(trainX)
testPredict = model.predict(testX)**# invert predictions**
trainPredict = scaler.inverse_transform(trainPredict)
trainY = scaler.inverse_transform([trainY])
testPredict = scaler.inverse_transform(testPredict)
testY = scaler.inverse_transform([testY])**# calculate root mean squared error**
trainScore = math.sqrt(mean_squared_error(trainY[0], trainPredict[:,0]))
print('Train Score: %.2f RMSE' % (trainScore))
testScore = math.sqrt(mean_squared_error(testY[0], testPredict[:,0]))
print('Test Score: %.2f RMSE' % (testScore))**# shift train predictions for plotting**
trainPredictPlot = numpy.empty_like(dataset)
trainPredictPlot[:, :] = numpy.nan
trainPredictPlot[look_back:len(trainPredict)+look_back, :] = trainPredict**# shift test predictions for plotting**
testPredictPlot = numpy.empty_like(dataset)
testPredictPlot[:, :] = numpy.nan
testPredictPlot[len(trainPredict)+(look_back*2)+1:len(dataset)-1, :] = testPredict**# plot baseline and predictions**
plt.plot(scaler.inverse_transform(dataset))
plt.plot(trainPredictPlot)
plt.plot(testPredictPlot)
plt.show()
最后的话
一如既往，我希望你喜欢这篇文章，并且对 rnn 以及如何实现它们有了一个直觉！
如果你喜欢这篇文章，那么你可以看看我关于数据科学和机器学习的其他文章 这里 。
如果你想了解更多关于机器学习、数据科学和人工智能的知识 请关注我的媒体 ，敬请关注我的下一篇帖子！
递归神经网络
由 Sonja Langford 在 Unsplash 上拍摄的照片
了解是什么使 RNNs 在处理序列数据时高效
递归神经网络是非常著名的深度学习网络，应用于序列数据:时间序列预测、语音识别、情感分类、机器翻译、命名实体识别等…
对序列数据使用前馈神经网络提出了两个主要问题:
- 在不同的例子中，输入和输出可以有不同的长度
- MLPs 不共享跨数据样本的不同位置学习的特征
在本文中，我们将发现 RNNs 成功背后的数学原理，以及一些特殊类型的细胞，如 LSTMs 和 GRUs。最后，我们将深入研究结合注意力机制的编码器-解码器架构。
注意:因为 Medium 不支持 LaTeX，所以数学表达式是作为图像插入的。因此，为了更好的阅读体验，我建议你关闭黑暗模式。
目录
- 符号
- RNN 车型
- 不同类型的无线网络
- 高级细胞类型
- 编码器&解码器架构
- 注意机制
1.注释
作为示例，我们将考虑命名实体识别的任务，该任务包括定位和识别命名实体，例如专有名称:
我们表示:
当处理非数字数据时，例如文本，将它编码成数字向量是非常重要的:这个操作称为embedding。最著名的文本编码方式之一是由谷歌开发的 Bert。
2.RNN 模型
RNNs 代表神经网络的一种特殊情况，其中模型的参数以及所执行的操作在整个体系结构中是相同的。网络为序列中的每个元素执行相同的任务，该序列的output depends on the input and the previous state of the memory。
下图显示了具有单层隐藏记忆的神经元的神经网络:
方程式
架构中的变量包括:
其中:
h(-1)被随机初始化， ϕ 和 ψ 是非线性函数， U 、 V 和 W 是各种线性回归的parameters，在非线性激活之前。
需要注意的是，它们在整个架构中是相同的。
应用程序
递归神经网络显著改进了序列模型，特别是:
- NLP 任务、建模和文本生成
- 翻译机
- 声音识别
我们在下表中总结了上述应用:
学习算法
如同在经典神经网络中一样，在递归网络的情况下，通过优化关于 U 、 V 和 W 的成本函数来进行学习。换句话说，我们的目标是从真实值 yi 的输入 xi 开始，找到给出最佳预测 y^ i 的最佳参数。
为此，我们定义了一个名为loss function的目标函数，记为J，它量化了整个训练集的真实值和预测值之间的距离。
我们通过以下两个主要步骤来最小化 J:
**Forward Propagation**:我们通过网络整体或分批传播数据，并计算这批数据的损失函数，该损失函数只不过是不同行的预测输出中的误差之和。**Backward Propagation Through Time**:包括计算成本函数相对于不同参数的梯度，然后应用下降算法对其进行更新。它被称为 BPTT，因为每个输出端的梯度既取决于同一时刻的元素，也取决于前一时刻的记忆状态。
我们多次重复相同的过程，称为epoch number。定义架构后，学习算法编写如下:
(∫)成本函数 L 计算单个点上实际值和预测值之间的距离。
正向传播
让我们考虑通过神经网络预测单个序列的输出。
在每个时刻 t ，我们计算:
直到到达序列的末尾。
同样，参数 U 、 W 和 V 在整个神经网络中保持相同。
当处理一个 m 行的数据集时，对每一行分别重复这些操作是非常昂贵的。因此，我们截断数据集，以便在相同的时间线中描述序列，即:
我们可以使用线性代数将其并行化，如下所示:
穿越时间的反向传播
反向传播是学习的第二步，包括在预测(正向)阶段将injecting the error提交到网络中，并将其参数更新为perform better on the next iteration。因此，函数 J 的优化通常通过下降法进行。
我们现在可以应用一个下降方法，在我之前的文章中有详细描述。
记忆问题
我们对基于历史预测时间序列的演变感兴趣的领域有几个:音乐、金融、情感…等等。上面描述的内在循环网络被称为“香草”,具有记忆力差的缺点，在预测未来时不能考虑过去的几个因素。
考虑到这一点，RNNs 的各种扩展被设计来修整内部记忆:双向神经网络、LSTM 细胞、注意力机制等等。记忆放大在某些领域是至关重要的，比如在金融领域，人们试图记住尽可能多的历史，以便预测一个金融序列。
RNN 的学习阶段也可能遭受gradient vanishing或gradient exploding问题，因为成本函数的梯度包括影响其记忆能力的 W 的幂。
3.不同类型的 rnn
经典或“普通”递归神经网络有多种扩展，这些扩展旨在增加网络的存储容量以及特征提取能力。
下图总结了不同的扩展:
还有其他类型的 rnn 有一个专门设计的隐藏层，我们将在下一章讨论。
4.高级类型的细胞
门控循环单元
GRU(门控循环单元)单元允许循环网络保存更多的历史信息，以便进行更好的预测。它引入了一个update gate，用于确定要从过去保留的信息量，以及一个reset gate，用于设置要忘记的信息量。下图示意了 GRU 细胞:
方程 我们将 GRU 单元中的方程定义如下:
ϕ 是非线性整数函数，参数 W 由模型学习。
长短期记忆
LSTMs(长短期记忆)也被引入来克服短记忆的问题，它们比普通的 RNNs 多 4 倍的记忆。这个模型使用了门的概念，有三个:
- 输入门 i :控制输入信息的流动。
- 遗忘门 f :控制前一存储状态的信息量。
- 输出门 o:控制输出信息流
下图显示了 LSTM 电池的操作:
当输入和输出门关闭时，存储单元中的激活被阻止。
方程式 我们将 LSTM 单元中的方程式定义如下:
优点&缺点 我们可以把 LSTM 细胞的优点和缺点总结为四个要点:
- 优点
+他们能够对长期序列依赖性进行建模。
+与“普通”rnn 相比，它们对短记忆问题更具鲁棒性，因为内部存储器的定义从:
- 缺点
+与 RNN 相比，它们增加了计算复杂性，引入了更多要学习的参数。
+由于存在多个内存单元，所需内存高于“普通”rnn。
5.编码器和解码器架构
它是由两个主要部分组成的顺序模型:
Encoder:模型的第一部分处理序列，然后在最后返回整个序列的编码向量，称为context vector，其概括了不同输入的信息。Decoder:上下文向量然后被作为解码器的输入，以便进行预测。
下图说明了该模型的架构:
编码器可以认为是一个降维工具，事实上，上下文向量 en 无非是对输入向量的编码( 0 中的*，* 1 中的*， inn )，这些向量的大小之和远大于 en 的大小，因此有降维的概念。*
6.注意机制
引入注意机制是为了解决记忆限制的问题，主要回答以下两个问题:
- 编码器的每个输出 ej 赋予什么权重(重要性) αj ？
- 我们如何克服编码器有限的内存，以便能够“记住”更多的编码过程？
该机制将其自身插入编码器和解码器之间，并帮助解码器显著选择对解码过程的每个步骤都很重要的编码输入 outi 如下:
数学形式主义
保持与之前相同的符号，我们将 αi ， j 设置为由输出 i 给予向量 ej 的注意力，表示为 outi 。
注意力通过神经网络来计算，该神经网络将向量( e 0、 e 1、…、 en )和先前的记忆状态 h(i- 1)作为输入，它由下式给出:
应用:翻译机
注意机制的使用使得visualize and interpret模型内部正在做什么成为可能，特别是在预测的时候。
例如，通过绘制翻译系统注意力矩阵的“热图”,我们可以看到第一种语言中的单词，该模型将每个单词翻译成第二种语言:
如上所述，当将单词翻译成英语时，系统特别关注相应的法语单词。
LSTM 叠加与注意机制
结合这两种方法来改善内部记忆是相关的，因为第一种方法允许考虑更多的过去的元素，而第二种方法选择在预测时仔细关注它们。
注意机制的输出 ct 是 LSTM 细胞的新输入，因此方程组变成如下:
ϕ 是非线性整数函数，参数 w 由模型学习。
结论
RNNs 是处理序列数据的一个非常强大的工具，它们提供了令人难以置信的记忆能力，并广泛应用于日常生活中。它们也有许多扩展，能够解决各种类型的数据驱动问题，尤其是讨论时间序列的问题。
不要犹豫，检查我以前的文章处理:
参考
- Z.Lipton，J.Berkowitz，C.Elkan，对用于序列学习的递归神经网络的评论，arXiv:156.00019 v4，2015。
- H.Salehinejad，S.Sankar，J.Barfett，E.Colak，S.Valaee，递归神经网络的最新进展，arXiv: 1801.01078v3，2018。
- Y.Baveye，C.Chamaret，E . del andréA，L.Chen，情感视频内容分析:多学科洞察，HAL Id: hal-01489729，2017。
- A.Azzouni，G.Pujolle，一种用于网络流量矩阵预测的长短期记忆递归神经网络框架，arXiv: 1705.05690v3，2017。
- Y.g .希纳尔，H .米里萨伊，P .戈斯瓦米，E .高斯希尔，A .艾特-巴奇尔，V .斯特里约夫，利用 RNNs 进行时间序列预测:一种扩展的注意机制对周期进行建模并处理缺失值，arXiv: 1703.10089v1，2017。
- K.徐，吴，王，冯，维特布洛克，谢宁，Graph2Seq: 基于注意的神经网络的图到序列学习，arXiv: 1804.00823v3，2018 .
- Rose Yu，，Cyrus Shahabi，Ugur Demiryurek，深度学习:极端条件下交通预测的通用方法，南加州大学，2017 年。
原载于 2020 年 4 月 15 日 https://www.ismailmebsout.com。
用于假人的递归神经网络
一个有趣的和有插图的指南来理解直觉。
这篇文章温和地介绍了循环单元，它们的内存是如何工作的，以及它们是如何被用来处理序列数据的，比如文本和时间序列。有没有把递归神经网络想象成时光机？
我们为什么关心序列数据？
我们想要一个机器学习模型来理解序列，而不是孤立的
样本。这对于时间序列数据尤其重要，因为数据与时间的概念有着内在的联系。
序列也存在于自然语言中，句子是单词的序列。自然语言处理模型需要上下文信息来理解下面句子中的主语( he )和直接宾语( it )。在提供顺序信息后，模型将理解句子中的主语(乔的兄弟)和直接宾语(毛衣)。
页（page 的缩写）Protopapas，CS109b，哈佛 FAS
为什么神经网络会在序列数据上失败？
在我们之前的文章为什么深度学习有效中，我们展示了几个人工神经网络来预测农民在给定年份可能生产的收获量。这些模型不仅着眼于一年(如 2019 年)，而且同时着眼于一系列年份(如 2017 年、2018 年、2019 年)，从而提高预测能力。
如下图所示，给定三个连续值，模型将预测第四个值。第一个垂直列显示值的完整序列。下一列显示了预测结果的示例(蓝色)。
页（page 的缩写）Protopapas，CS109b，哈佛 FAS
这被称为重叠加窗数据集，因为我们对观测值加窗以创建新的。我们可以设想建立一个具有三层和 ReLU 激活函数的全连接神经网络，用于在给定三个连续数字时预测下一个数字。
页（page 的缩写）Protopapas，CS109b，哈佛 FAS
这种方法有几个问题。如果我们重新排列输入序列，网络将预测同样的结果。完全连接的网络不会区分顺序，因此会丢失一些信息。
页（page 的缩写）Protopapas，CS109b，哈佛 FAS
此外，完全连接的网络需要固定的输入和输出大小。如果我们决定查看 5 个连续数字来进行预测，我们将不得不建立另一个模型。
全连接网络的另一个缺点是，它不能对多个地方的输入进行分类。例如，当网络被设计为预测 3 个值时，我们不能同时预测接下来的 4 个值。
输入的顺序很重要。对于大多数顺序数据来说都是如此。
记忆游戏
在上一节中，我们提出了使用上下文、历史和未来来进行更好预测的想法。怎样才能让一个神经网络记住？
我们可能都经历过在 Pexeso 游戏中被孩子打败的经历，这是一个关于注意力和记忆力的游戏。
玩 Pexeso 时，目标是用尽可能少的走法找到所有相同的牌对。不知何故，孩子们非常擅长记忆。为什么我们不把这种同样的超人能力赋予人工神经网络中的一个神经元呢？
基本上，我们需要将神经元更新为一个新的计算单元，能够记住它以前看到的东西。我们将这称为单元的状态或隐藏状态或内存。
页（page 的缩写）Protopapas，CS109b，哈佛 FAS
如何建立一个能记住过去的单位？内存或状态可以被写到一个文件中，但是更好的是，我们把它保存在单元内部，在一个数组中或者在一个向量中。当单元读取输入时，它也读取存储器的内容。利用这两种信息，它做出预测，更重要的是，它更新记忆。
我们也可以在 Pexeso 游戏中找到这个原则。一个孩子会打开一张卡片，试着回忆以前打开过的配对卡片的位置，然后决定下一张打开哪张卡片。打开那张卡片后，如果不匹配，孩子会通过记录他刚刚发现的那对卡片的位置来更新他的记忆。在下一轮游戏中，孩子将重复这个过程，如下图所示。
页（page 的缩写）Protopapas，CS109b，哈佛 FAS
循环单元
在数学中，当前值(事件或单词)对先前事件的依赖类型被称为递归，并使用递归方程来表示。
递归神经网络可以被认为是同一节点的多个副本，每个副本都向后继节点传递消息。表示上述递归关系的一种方法是使用下图。黑色的小方块表示所使用的状态是从以前的时间戳获得的，也就是以前的状态进入当前状态的循环。
页（page 的缩写）Protopapas，CS109b，哈佛 FAS
每个单元有三组权重:一组用于输入𝒙(𝑡，另一组用于前一时间步的输出𝒚(𝑡–1，另一组用于当前时间步的输出𝒚(𝑡).这些权重就像我们在正常的人工神经网络中处理的任何其他权重一样，最终它们将由训练过程来确定。
下面的示意图显示了将 3 个数字转换成 4 个数字的装置内部。输入是一个 3 个数字的向量。隐藏状态或记忆是一个 5 个数字的向量。该单元将使用 5 个神经元(A1-5)的内部网络将输入转化为 5 个数字的向量，将其与当前状态相结合，并通过激活函数传递结果。由此产生的 5 个数字的向量将通过另一个由 5 个神经元(B1–5)组成的内部网络来产生新的状态。它将同时通过另一个由 4 个神经元(C1-4)组成的网络，产生一个 4 个数字的输出向量。
页（page 的缩写）Protopapas，CS109b，哈佛 FAS
通过将当前输入与先前状态相结合，并通过激活函数来传递，网络将不仅仅记住先前的输入。国家永远是一个已经被网络看到的事物的更大画面。
在 Pexeso 游戏中，孩子们不是记录桌子上卡片的(x，y)坐标，而是模糊地记得哪些卡片彼此相邻，哪些靠近中心，哪些在棋盘的左边，哪些有更多的颜色，等等。
类似地，一个单元不会只记住一个句子的最后 2 或 3 个单词，而是会找到要记住多少个单词和哪些单词，尤其是这些单词的哪个表示，以便实现最佳预测。
这是一个非常简单的例子，说明了我们人类是如何选择记住一些事情(例如我们的妈妈纪念日)和忘记另一些事情(我们的老板纪念日)的。
穿越时间的反向传播
在我们之前的例子中，整个单元将在训练期间学习 5+5+4=14 个权重和 14 个偏差。我们如何找到这些重量？典型的梯度下降和反向传播在这里也适用吗？
现在来点难看的数学。首先，我们称 V 为应用于输入的权重， U 为应用于状态的权重， W 为应用于输出的权重。姑且称 h 为状态。我们有两个激活函数， g_h 作为隐藏状态的激活， 𝑔_y 作为输出的激活。
页（page 的缩写）Protopapas，CS109b，哈佛 FAS
递归单元由以下两个等式完美描述，其中 b 和*b’*分别表示输出神经元和状态神经元中的偏差。
为了通过应用随机梯度下降找到权重，正如我们在另一篇文章中所述，我们需要计算损失函数及其对权重的导数。
下面你可以看到这是如何为输出权重 W 完成的。整个网络的损耗是以循环单位表示的单个损耗的总和。
类似地，我们可以如下计算损失函数相对于状态权重 U 的导数。
还不算太糟。我们现在知道如何训练一个递归神经网络。但是有一个问题。
在上面突出显示的损失函数中，你可以看到一个巨大的数字乘积。已知产生的量变得非常大或非常小，导致爆炸或消失梯度。
梯度可能会超过最小值，并撤消许多已经完成的工作。因此，通常的做法是将梯度裁剪在可接受的区间内，并选择不允许梯度过小的激活函数。
实际上，由于这个问题，rnn 不能学习长依赖关系，正如我们将在我们的对真实世界客户评论分类的实际实验中所展示的。如果你想用 Python 从零开始实现你自己的 RNN，查看 Victor Zhou 的这篇优秀文章。
递归神经网络如何处理序列数据？
现在，我们知道了单个循环单元是如何工作的。通过一个接一个地链接几个单元，我们能够处理一系列的输入。
下面，我们将说明递归神经网络如何获取一系列观察结果并预测是否会下雨。
在时间 t 时，网络出现“狗叫声”信息，其存储器为空。因此，预测有 0.3 的可能性会下雨。该网络在其存储器中存储“狗叫声”的表示，用于下一步。
在时间 t+1 ，它接收到新的信息‘白衬衫’，这将下雨的可能性降低到 0.1。现在记忆中有了“狗叫声”和“白衬衫”的代表。
接下来，在时间 t+2 ，网络接收“苹果派”作为信息。这不会改变它的预测，但是通过推出“白衬衫”来更新记忆。
在时间 t+3 时，输入“膝盖疼”将预测值增加到 0.6，并覆盖存储器中的“苹果派”。序列的最终输入是‘get dark’，将最终预测推至 0.9。
页（page 的缩写）Protopapas，CS109b，哈佛 FAS
这个例子直观地说明了当从输入序列中学习时，网络是如何有意识地在记忆中保持和忘记某些信息的。这是一个典型的多对一场景。
在下面描述的不同风格中也发现了递归神经网络。多对多体系结构通常用于将文本从一种语言翻译成另一种语言。
结论
在本文中，我们展示了神经网络如何处理序列数据。如果您有兴趣了解如何实现递归神经网络，并对全连接神经网络或卷积神经网络进行基准测试，请通读我们下面的下一篇文章。包括实际操作的 Python 代码。
递归神经网络解释。使用 FCNNs、CNN、RNNs 和嵌入对客户评论进行分类。
towardsdatascience.com](/sentiment-analysis-a-benchmark-903279cab44a)
感谢阅读。
电价预测的递归神经网络
具有外生变量的时间序列分析
用于预测这些价格的最终模型可以找到( 此处 )
(ffull GitHub 库 )
什么是需求灵活性？
需求灵活性可以描述为电力终端用户(包括企业和家庭)根据市场信号(如随时间变化的电价)改变其电力消费模式的能力。
电价遵循每日、每周和季节性模式。上面我们可以看到日线模式。早上，每个人醒来，打开所有设备，价格上涨。随着人们去工作，需求和价格下降(太阳能发电开始上网)。下午 5 点左右，人们开始离开办公室，回家，打开电视，洗衣服等，价格再次上涨，直到就寝时间，价格下降。这个循环然后重复。
鉴于电价和碳排放的相关性(见我之前的博客)，如果我们能把人们从高峰时间转移到非高峰时间，我们就能节省成本和碳排放。
没有多少公司向他们的客户提供提前一天的价格，但是 章鱼能源公司的灵活关税 正是这样做的。
然而，首先，对价格的准确预测将是有用的。
外变量
通常当进行特征工程时，我们需要确保我们的输入确实有助于(而不是阻碍)模型。幸运的是，神经网络非常善于辨别什么是有益的，什么是无益的，所以我们可以非常慷慨。
电力生产的投入可能对决定价格很有帮助。以下是 2013 年至 2019 年的数据图。
随着时间的推移，每个输入似乎都与电价有某种关联。
最重要的是，考虑到季节变化，包括温度数据是有帮助的。由于空调需求，夏季可能会有更高的价格。
所有这些数据必须来自不同的来源。我用 Nordpools 的提前一天市场来获取价格数据，用 DarkSky API 来获取温度数据，用 Investing.com 来获取商品数据。(这个都可以在这里找到。)
时间序列分析的整形
现在，经过一些清理，我有了一个完整的数据帧(这里)。
因为我正在执行时间序列分析，而我试图预测的变量也在预测中使用，所以我需要将数据重塑为监督学习问题。
data = df.valuesn_steps = 168series_reshaped = np.array([data[i:i + (n_steps+24)].copy() **for** i **in** range(len(data) - (n_steps+24))])series_reshaped.shape(61134, 192, 6)
取数据帧的值(在对神经网络进行缩放之后),我定义它可以看到 168 个向后的时间步长(1 周),我希望它可以预测未来 24 小时。
它在数据框上创建了一个窗口，这样我就有了一个 192 行 X 6 列的矩阵。此窗口向下移动原始数据框“行我的行”,每小时创建一个新矩阵。如果 2013 年 1 月 1 日中午是第一个矩阵的第一行，那么下午 1 点将是第二个矩阵的第一行。
像这样增加维度将允许神经网络理解时间到来的顺序很重要。
既然数据是这种格式，我将它拆分，这样我们就有了 168 小时(1 周)的输入数据块，对于每 168 小时块，我们有 24 小时的价格输出，所以我们的模型可以“看到”接下来的 24 小时。这将数据转化为监督学习问题。
X_train = series_reshaped[:43800, :n_steps]
X_valid = series_reshaped[43800:52560, :n_steps]
X_test = series_reshaped[52560:, :n_steps]
Y = np.empty((61134, n_steps, 24))
**for** step_ahead **in** range(1, 24 + 1):
Y[..., step_ahead - 1] = series_reshaped[..., step_ahead:step_ahead + n_steps, 0]
Y_train = Y[:43800]
Y_valid = Y[43800:52560]
Y_test = Y[52560:]
现在 X 训练数据是所有商品过去的 168 小时，而 Y 训练数据是未来 24 小时的价格。
训练模型
将数据格式化后输入神经网络，只需要尝试不同的格式。
在尝试了 LSTM 的、GRU 的卷积层以及经典的机器学习(回归树和 ARIMA 预测)之后，一个递归神经网络提供了最好的结果。
np.random.seed(42)
tf.random.set_seed(42)
model6 = keras.models.Sequential([
keras.layers.SimpleRNN(20, return_sequences=**True**, input_shape=[**None**, 6]),
keras.layers.SimpleRNN(20, return_sequences=**True**),
keras.layers.TimeDistributed(keras.layers.Dense(24))
])
model6.compile(loss="mape", optimizer="adam")
history = model6.fit(X_train, Y_train, epochs=20,
validation_data=(X_valid, Y_valid))
这里有两个重要的事情需要了解，对于那些更喜欢技术方面的人来说，那就是 return_sequences=True，以及最终的时间分布层 24。第一个确保数据在网络中保持相同的多维(时间序列)格式，第二个是它以相同的结构每小时输出未来 24 小时的数据。
对于预测，我只关心最后的 24 小时，因为一个小时后，将有一个新的输入，这将产生下一个小时的预测。
在 2013 年至 2018 年对模型进行训练后，我用 2019 年来评估模型在看不见的数据上的工作情况。随机选择几天，这样你就能真正看到效果，这是相当准确的。
使用案例
鉴于该模型现在可以提前 24 小时预测电价，我们现在可以调整我们的用电量，使其远离那些高峰时段。这可能意味着设置我们的烘干机和电器在我们睡觉时运行，甚至投资智能插头来自动化我们的循环设备(如冰箱和空调)。
为了简单起见，我模拟了一个家用电池。它大致基于特斯拉 Powerwall 2，容量为 14KW，功率为 5 KW。为简单起见，这意味着它可以容纳近 3 个小时的电荷。它查看模型的 24 小时预测，并选择 3 个最便宜的充电时间和 3 个最贵的放电时间。
然而，你不太可能以这些日前价格将电力卖回给电网，我模拟的估值指标正是如此。在 2019 年的过程中，这种电池将花费 151.02 英镑用于充电，并从出售给电网中“赚取”280.23 英镑，从而获得 85.5%的投资回报率。考虑到这是一个相当初级的电池模型，这是一个不错的结果。
还不错，但是钱也不多。当我们开始考虑灵活需求的真正潜在规模时，真正有趣的场景出现了，事实是，有成千上万个巨大的 1MW +空调机组可以做到这一点，既减少了碳排放，又节省了大量成本。
递归神经网络—第一部分
FAU 讲座笔记关于深度学习
埃尔曼细胞
FAU 大学的深度学习。下图 CC BY 4.0 来自深度学习讲座
这些是 FAU 的 YouTube 讲座 深度学习 的讲义。这是与幻灯片匹配的讲座视频&的完整抄本。我们希望，你喜欢这个视频一样多。当然，这份抄本是用深度学习技术在很大程度上自动创建的，只进行了少量的手动修改。如果你发现了错误，请告诉我们！
航行
欢迎大家来到深度学习的新一期。今天我们想研究顺序学习，特别是递归神经网络。到目前为止，我们只有简单的前馈网络，其中我们基本上有固定大小的输入，然后将生成分类结果，如“猫”、“狗”或“仓鼠”。
背景知识在许多分类问题中是相关的。 CC 下的图片来自深度学习讲座的 4.0 。
如果我们有像音频、语音、语言或视频这样的具有时间背景的序列，那么我们目前看到的技术并不是很适合。所以，我们现在感兴趣的是寻找适用于很长输入序列的方法。递归神经网络(RNNs)正是实际做到这一点的一种方法。在对动机进行第一次回顾之后，我们将继续研究简单的递归神经网络。然后，我们将介绍著名的长短期记忆单位，然后是门控循环单位。之后，我们将比较这些不同的技术，并讨论一下优缺点。最后，我们将讨论我们的 rnn 的采样策略。当然，这对于一个视频来说太多了。所以，我们会在个别短视频中，针对不同的话题进行讨论。所以，我们来看动机。好吧，我们有一个针对单个图像的输入，但对于语音、音乐、视频或其他传感器数据等时序或时间相关信号来说，这就不太好了。你甚至可以谈论测量能量消耗的非常简单的传感器。因此，固定长度的快照通常信息不多。如果你只看一个单词，你可能很难得到正确的翻译，因为上下文很重要。时间上下文非常重要，需要适当地建模。
递归神经网络能够以不同于时间维度的方式对空间维度进行建模。 CC 下的图片来自深度学习讲座的 4.0 。
现在的问题是:“我们如何将这种背景融入网络？”简单的方法是将整个序列输入一个大网络。这可能是个坏主意，因为我们的内存使用效率很低。这很难训练，甚至不可能训练，我们永远也搞不清楚空间和时间维度之间的区别。我们会照样处理。实际上，也许这不是一个坏主意。对于相当简单的任务，正如你在[6]中看到的，因为他们实际上调查了这一点，并用 CNN 发现了相当令人惊讶的结果。当然，你的一个问题是它不是实时的，因为你需要整个序列来处理。因此，我们在本视频和接下来的几个视频中建议的方法是对架构内的顺序行为进行建模，从而产生递归神经网络。
经典埃尔曼单元草图。 CC 下的图片来自深度学习讲座的 4.0 。
所以让我们来看看简单的递归神经网络。主要的想法是，你引入一个隐藏状态 h 下标 t，它会持续一段时间。所以这是可以改变的，但它本质上是连接回原始细胞 A。所以，A 是我们的循环细胞，它有这种隐藏状态，以某种方式允许我们编码当前时间信息带给我们的东西。现在，我们有一些输入 x 下标 t，这将产生一些输出 y 下标 t，顺便说一下，第一个模型来自 20 世纪 70 年代和 80 年代初，像 Hopfield 网络。这里，我们将坚持使用简单的递归神经网络或 Elman 网络，如[5]中所介绍的。
递归网络和前馈网络的比较。 CC 下的图片来自深度学习讲座的 4.0 。
现在，前馈网络只前馈信息。相比之下，有了循环网络，我们现在可以模拟循环，我们可以模拟记忆和经验，我们可以学习顺序关系。因此，随着数据的到来，我们可以提供连续的预测。这使我们能够实时处理一切。
在 RNN 建筑中，隐藏状态随着时间而变化。来自深度学习讲座的 4.0CC 下的图片。
现在，这又是我们的基本递归神经网络，其中我们有一些输入 x 乘以一些权重。然后，我们有了额外的输入，来自先前配置的隐藏状态，我们本质上有了一个反馈回路，在那里你使用来自现在和最近过去的信息。
在输入序列上展开或展开网络是理解网络解码和训练的关键。 CC 下的图片来自深度学习讲座的 4.0 。
为了计算输出 y 下标 t，我们最终得到一个展开的结构。所以，如果你想评估循环单元，你要做的是从你的单元处理的一些 x ₀开始。这产生了新的结果 y₀和新的隐藏状态₀.现在， h ₀被前馈到下一个实例，在那里实质上是权重被耦合。所以在下一个时间状态，我们有相同单元的完全相同的副本，但是当然，h 是不同的。所以现在，我们馈入 x ₁过程产生 y₁并产生一个新的隐藏态 h ₁等等。我们可以这样做，直到我们在序列的末尾，这样每个单元将隐藏状态作为附加输入传递给后继单元。这意味着先前的输入可以对当前的输出产生影响，因为如果我们已经看到了 x ₀和 x ₁，它们可以对 y 下标(t-1)产生影响，只是因为我们已经对我们在隐藏状态中观察到的 x ₀和 x ₁的信息进行了编码。因此，隐藏状态允许我们存储信息，并通过整个网络将信息传递到某个时间段，然后我们想选择特定的行动。
我们如何更新状态，如何计算输出？ CC 下的图片来自深度学习讲座的 4.0 。
所以现在，基本问题是“我们如何更新隐藏状态？”第二个问题是“我们如何结合输入和隐藏状态来计算输出？”所以，我们打开牢房往里面看。你在这里看到的是，我们本质上把隐藏状态和新输入连接起来，然后把它输入非线性，这里是双曲正切。这产生了一个新的状态，从这个新的状态，我们用一个 sigmoid 函数产生新的输出。然后，我们将新的隐藏状态传递给同一个单元格的下一个实例。因此，我们有两个激活函数:用于组合先前状态和当前状态的双曲正切函数和用于产生输出的 sigmoid 非线性函数。
更新状态方程。 CC 下的图片来自深度学习讲座的 4.0 。
当然，为了做到这一点，我们需要权重矩阵，这些权重矩阵在这里用红色表示。如果我们想要更新隐藏状态，我们可以更详细地查看它们。这实质上是隐藏状态转移矩阵 W 下标 hh 乘以最后一个隐藏状态加上隐藏状态转换矩阵的输入 W 下标 xh 乘以 x 下标 t 加上偏差。这然后被馈送到非线性，然后产生新的隐藏状态。
产生输出的方程式。 CC 下的图片来自深度学习讲座的 4.0 。
好，那么我们如何计算输出呢？我们产生了一个新的隐藏状态，这意味着我们现在有了另一个转移矩阵，从隐藏状态产生一个初步输出。因此，我们有了这个新的 W 下标 hy，它接受 h 下标 t 和一些偏置，并将其提供给 sigmoid 函数以产生最终输出。
RNNs 有多种输入和输出选择。 CC 下的图片来自深度学习讲座的 4.0 。
如果我们坚持这种架构，我们就可以实现许多不同类型的架构。这是由架构的设置决定的。因此，我们可以进行一对一的映射，我们有一个输入单元和一个输出单元，但你也可以做一个太多，多对一，或者你甚至可以做许多。一对一的例子是图像分类。本质上是经典的前馈。一对多是图像字幕。多对一是情绪分析，你需要观察一个特定的序列，以便找出在这种情况下是什么情绪。多对多是视频分类。
深度 RNNs 可能吗？ CC 下的图片来自深度学习讲座的 4.0 。
当然，我们也可以思考深层 RNNS。到目前为止，我们只有一个隐藏层，我们可以只使用我们的循环模型，这就是为什么我们需要更深入。在这种情况下，它更像是“哟，老兄，我听说你喜欢 RNNs，所以我把 RNN 放在你的 RNN RNN 上。”
深度 RNN 的一个例子。来自深度学习讲座的 CC BY 4.0 下的图片。
由此产生了像这样的建筑。对于深度 rnn，我们简单地堆叠多个隐藏单元。所以，我们当然可以把 Elman 细胞堆叠在 Elman 细胞上。然后，我们将使用输入随时间进行解码，使用多个 RNN 单元进行解码，并随时间产生多个输出。所以，这给了我们接触深层元素的机会。
在这个深度学习讲座中，更多令人兴奋的事情即将到来。 CC 下的图片来自深度学习讲座的 4.0 。
好的。所以，这是对深度 RNNs 和递归神经网络的简单介绍。在下一个视频中，我们想更详细地了解一下训练是如何完成的，以及为了执行训练而实际更新的等式。所以，我希望你喜欢这个视频，并看到你在下一个！
如果你喜欢这篇文章，你可以在这里找到更多的文章，或者看看我们的讲座。如果你想在未来了解更多的文章、视频和研究，我也会很感激关注 YouTube 、 Twitter 、脸书或 LinkedIn 。本文以 Creative Commons 4.0 归属许可发布，如果引用，可以转载和修改。
RNN 民间音乐
FolkRNN.org
MachineFolkSession.com
玻璃球亨利评论 14128
链接
参考
[1] Dzmitry Bahdanau、Kyunghyun Cho 和 Yoshua Bengio。“通过联合学习对齐和翻译的神经机器翻译”。载于:CoRR abs/1409.0473 (2014 年)。arXiv: 1409.0473。Yoshua Bengio，Patrice Simard 和 Paolo Frasconi。“学习具有梯度下降的长期依赖性是困难的”。摘自:IEEE 神经网络汇刊 5.2 (1994)，第 157-166 页。
[3]钟俊英，卡格拉尔·古尔希雷，赵京云等，“门控递归神经网络序列建模的实证评估”。载于:arXiv 预印本 arXiv:1412.3555 (2014 年)。
[4]道格拉斯·埃克和于尔根·施密德胡伯。“学习蓝调音乐的长期结构”。《人工神经网络——ICANN 2002》。柏林，海德堡:施普林格柏林海德堡出版社，2002 年，第 284-289 页。
【5】杰弗里·L·埃尔曼。“及时发现结构”。摘自:认知科学 14.2 (1990)，第 179-211 页。
[6] Jonas Gehring，Michael Auli，David Grangier，等，“卷积序列到序列学习”。载于:CoRR abs/1705.03122 (2017 年)。arXiv: 1705.03122。亚历克斯·格雷夫斯、格雷格·韦恩和伊沃·达尼埃尔卡。《神经图灵机》。载于:CoRR abs/1410.5401 (2014 年)。arXiv: 1410.5401。
【8】凯罗尔·格雷戈尔，伊沃·达尼埃尔卡，阿历克斯·格雷夫斯等，“绘制:用于图像生成的递归神经网络”。载于:第 32 届机器学习国际会议论文集。第 37 卷。机器学习研究论文集。法国里尔:PMLR，2015 年 7 月，第 1462-1471 页。
[9]赵京贤、巴特·范·梅林波尔、卡格拉尔·古尔切雷等人，“使用 RNN 编码器-解码器学习统计机器翻译的短语表示”。载于:arXiv 预印本 arXiv:1406.1078 (2014 年)。
【10】J J 霍普菲尔德。“具有突发集体计算能力的神经网络和物理系统”。摘自:美国国家科学院院刊 79.8 (1982)，第 2554-2558 页。eprint:http://www.pnas.org/content/79/8/2554.full.pdf.T11【11】w . a . Little。“大脑中持久状态的存在”。摘自:数学生物科学 19.1 (1974)，第 101-120 页。
[12]赛普·霍克雷特和于尔根·施密德胡贝尔。“长短期记忆”。摘自:神经计算 9.8 (1997)，第 1735-1780 页。
[13] Volodymyr Mnih，Nicolas Heess，Alex Graves 等，“视觉注意的循环模型”。载于:CoRR abs/1406.6247 (2014 年)。arXiv: 1406.6247。
[14]鲍勃·斯特姆、若昂·费利佩·桑托斯和伊琳娜·科尔舒诺娃。“通过具有长短期记忆单元的递归神经网络进行民间音乐风格建模”。英语。In:第 16 届国际音乐信息检索学会会议，晚破，西班牙马拉加，2015，p. 2。
[15] Sainbayar Sukhbaatar，Arthur Szlam，Jason Weston 等著《端到端存储网络》。载于:CoRR abs/1503.08895 (2015 年)。arXiv: 1503.08895。
【16】彼得·m·托德。“算法合成的连接主义方法”。在:13(1989 年 12 月)。
【17】伊利亚·苏茨基弗。“训练递归神经网络”。安大略省多伦多市多伦多大学。，加拿大(2013)。
【18】安德烈·卡帕西。“递归神经网络的不合理的有效性”。载于:安德烈·卡帕西博客(2015)。
贾森·韦斯顿、苏米特·乔普拉和安托万·博尔德斯。“记忆网络”。载于:CoRR abs/1410.3916 (2014 年)。arXiv: 1410.3916。
递归神经网络—第二部分
FAU 讲座笔记关于深度学习
穿越时间的反向传播
FAU 大学的深度学习。下图 CC BY 4.0 来自深度学习讲座
这些是 FAU 的 YouTube 讲座 深度学习 的讲义。这是与幻灯片匹配的讲座视频&的完整抄本。我们希望，你喜欢这个视频一样多。当然，这份抄本是用深度学习技术在很大程度上自动创建的，只进行了少量的手动修改。如果你发现了错误，请告诉我们！
航行
同样，对于 RNNs，我们可以采用一次热编码。 CC 下的图片来自深度学习讲座的 4.0 。
欢迎回到深度学习！今天，我们想多谈一点关于递归神经网络，特别是研究训练程序。那么，我们的 RNN 培训是如何进行的呢？让我们看一个简单的例子，我们从字符级语言模型开始。所以，我们想从一个输入文本中学习一个字符概率分布，我们的词汇将会非常简单。这将是字母 h，e，l，和 o，我们将它们编码为一个热点向量，这样我们就可以得到 h 的向量(1 0 0 0)ᵀ.现在，我们可以继续在序列“hello”上训练我们的 RNN，我们应该知道给定“h”作为第一个输入，网络应该生成序列“hello”。现在，当出现 l 时，网络需要知道以前的输入，因为它需要知道它是需要产生 l 还是 o，它是相同的输入，但有两个不同的输出。所以，你得知道语境。
未经训练的 RNN 解码示例。 CC 下的图片来自深度学习讲座的 4.0 。
让我们看看这个例子，你已经可以看到解码是如何发生的。因此，我们基本上再次将输入层作为一个热码编码向量。然后，我们用之前看到的矩阵产生隐藏状态 h 下标 t，并产生输出，你可以看到。现在，我们输入不同的字母，然后产生一些输出，这些输出可以通过一键编码映射回字母。因此，这基本上为我们提供了遍历整个序列并产生所需输出的可能性。现在，对于训练来说，问题是我们如何确定所有这些权重？当然，我们希望最大化这些权重来预测正确的分量。
通过时间的反向传播展开了完整序列的递归解码。来自深度学习讲座的 4.0CC 下的图片。
这都可以通过时间反向传播算法来实现。我们的想法是在展开的网络上训练。这里有一个关于如何做到这一点的简短草图。我们的想法是展开网络。因此，我们计算整个序列的前向路径，然后应用损耗。所以，我们基本上是在整个序列上反向传播，这样即使是发生在最后一个状态的事情也会对最开始产生影响。因此，我们计算整个序列的后向传递，以获得梯度和权重更新。因此，对于一个随时间反向传播的更新，我必须展开这个由输入序列产生的完整网络。然后，我可以将创建的输出与期望的输出进行比较，并计算更新。
让我们重温一下正向路径的更新公式。 CC 下的图片来自深度学习讲座的 4.0 。
那么，让我们更详细地看一下这个问题。当然，正向传递只是计算隐藏状态和输出。因此，我们知道我们有一些输入序列是 x 下标 1 到 x 下标 T，其中 T 是序列长度。现在，我只是重复更新我们的 u 下标 t，它是各自激活函数之前的线性部分。然后，我们计算激活函数来得到新的隐藏状态，然后我们计算下标 t，它本质上是 sigmoid 函数之前的线性部分。然后，我们应用 sigmoid 来产生基本上是我们网络输出的 y 帽子。
rnn 就像五行代码一样简单。图片来源: imgflip 。
如果我们这样做，那么我们可以展开整个网络，并产生我们需要的所有相应信息，然后实际计算权重的更新。
为了得到梯度，我们从损失函数开始。来自深度学习讲座的 4.0CC 下的图片。
现在通过时间的反向传播基本上产生了一个损失函数。现在，损失函数实际上是对我们在之前的讲座中已经知道的损失进行求和，但我们对每个时间 t 的实际观测值进行求和，因此，例如，我们可以取交叉熵，然后我们将预测输出与地面真实值进行比较，并以我们已经知道的类似方式计算损失函数的梯度。我们希望获得参数向量 θ 的参数更新，参数向量由这三个矩阵、两个偏置向量和向量 h 组成。因此，也可以使用学习率来更新参数，方法与我们在整个课程中所做的非常相似。现在的问题是，当然，我们如何得到这些衍生物，现在的想法是通过整个网络回到过去。
在这张幻灯片上，我们推导了隐藏状态的梯度。来自深度学习讲座的 CC BY 4.0 下的图片。
那我们该怎么办？我们从时间 T = T 开始，然后迭代计算 T 的梯度，直到 1。所以只要记住我们的 y 帽子是由这两个矩阵组成的 o 下标 t 的 sigma 产生的。因此，如果我们想要计算相对于 o 下标 t 的偏导数，那么我们需要 o 下标 t 的 sigmoid 函数的导数乘以损失函数相对于 y 下标 t 的偏导数。现在，你可以看到，相对于 W 下标 hy 的梯度将被给出为 o 下标 t 乘以 h 下标 t 转置的梯度。相对于偏差的梯度将被简单地给定为 o 下标 t 的梯度。因此，梯度 h 下标 t 现在取决于两个元素:受 o 下标 t 影响的隐藏状态和下一个隐藏状态 h 下标 t+1。所以，我们可以得到 h 下标 t 的梯度，作为 h 下标 t+1 对 h 下标 t 的偏导数，转置乘以 h 下标 t+1 的梯度。然后，我们仍然需要添加 o 下标 t 相对于 h 下标 t 的偏导数乘以 o 下标 t 的梯度。这可以表示为权重矩阵 W 下标 hh 乘以 W 下标 hh 乘以 h 下标 t 加上 W 下标 xh 乘以**x 乘以 h 下标 t+1 的梯度加上 W 下标 hy 转置乘以 o 下标 t 的梯度，所以，你可以看到我们也可以针对矩阵实现这个梯度。 现在，您已经拥有了隐藏状态的所有更新。**
接下来，我们研究参数来更新状态。来自深度学习讲座的 4.0CC 下的图片。
现在，我们还想计算其他权重矩阵的更新。所以，让我们来看看这是怎么可能的。我们现在已经基本上建立了计算对我们的 h 下标 t 的导数的方法，所以，现在我们已经可以通过时间传播了。所以对于每个 t，我们基本上得到和中的一个元素，因为我们可以计算梯度 h 下标 t，我们现在可以得到剩余的梯度。为了计算 h 下标 t，我们需要 u 下标 t 的 tanh，它包含剩余的权重矩阵。所以我们基本上得到了关于两个缺失矩阵和偏差的导数。通过使用梯度 h 下标 t 乘以 u 下标 t 的 tangens 双曲线导数。然后，根据您想要更新的矩阵，它将是 h 下标 t-1 转置，或 x 下标 t 转置。对于偏差，你不需要乘以任何额外的东西。因此，这些基本上是计算剩余更新所需的要素。我们现在看到的是，我们可以计算梯度，但它们依赖于 t，现在的问题是，我们如何得到序列的梯度。我们看到的是，以展开状态出现的网络本质上是一个共享权重的网络。这意味着我们可以简单地通过所有时间步长的和来更新。这样，我们就可以计算出权重和时间 t 的所有更新，最终的梯度更新将是所有梯度步长的总和。好了，我们已经看到了如何计算所有这些步骤，是的:这可能是五行伪代码，对吗？
反向传播算法截断的天真想法。来自深度学习讲座的 4.0CC 下的图片。
正常的时间反向传播存在一些问题。你需要展开整个序列，对于长序列和复杂的网络，这意味着大量的内存消耗。单个参数更新非常昂贵。所以，你可以做一个分裂的方法，就像我们在这里建议的天真的方法，但是如果你只是将序列分成几批，然后重新开始初始化隐藏状态，那么你可能可以训练，但是你会在长时间内失去依赖性。在本例中，第一个输入永远不会连接到这里的最后一个输出。所以，我们需要一个更好的方法来处理和节省内存，当然，有一种方法可以做到这一点。这被称为通过时间的截断反向传播算法。
截断时间反向传播算法。 CC 下的图片来自深度学习讲座的 4.0 。
现在，通过时间的截断反向传播算法整体上保持对序列的处理，但是它适应更新的频率和深度。所以每个 k₁时间步，你运行一个 k₂时间步的反向传播，如果 k₂很小，参数更新会很便宜。隐藏状态仍然暴露在许多时间步骤中，正如您将在下面看到的。所以，这个想法是从 1 到 t 的时间 t 运行我们的 RNN 一步计算 h 下标 t 和 y 下标 t，然后如果我们在 k₁步骤，那么我们通过时间从 t 向下运行反向传播到 t 减去 k₂.
时间截断反向传播的一个例子。 CC 下的图片来自深度学习讲座的 4.0 。
这在下面的设置中出现:你可以看到，我们实际上跨越了 4 个时间步。如果我们在第四个时间步，那么我们可以通过时间回溯，直到序列的开始。一旦我们这样做了，我们继续前进，我们总是保持隐藏状态。我们不会丢弃它。所以，我们可以模拟这种相互作用。那么，这能解决我们所有的问题吗？不，因为如果我们有一个很长的时间背景，它将无法更新。比方说，第一个元素负责改变序列中最后一个元素的某些东西，然后你会发现它们永远不会被连接起来。所以，我们再也无法了解这种长时间的背景。这是长期依赖和基本 RNNs 的一个大问题。
可以很好地捕捉附近的上下文。 CC 下的图片来自深度学习讲座的 4.0 。
假设你有这种长期依赖。你想预测“云在天上”的下一个词。你可以看到云可能与此相关。这里，上下文信息就在附近。所以，我们可以很容易地把它编码成隐藏状态。现在，如果我们有很长的序列，那么会困难得多，因为我们必须反向传播这么多步骤。你也看到了，我们在深度网络中有这些问题，在那里我们有消失梯度问题。我们无法找到连接相距甚远的网络部分的更新。
长时间的上下文仍然会产生问题。来自深度学习讲座的 CC BY 4.0 下的图片。
你可以在这里看到，如果我们有这样的例子:一句“我在德国长大”然后说别的“我说得很流利”，那很可能是德语。我必须能够记住“我在德国长大”。因此，上下文信息离得很远，这很重要，因为我们必须通过许多层来传播。
rnn 中长期依赖的问题。 CC 下的图片来自深度学习讲座的 4.0 。
这意味着我们必须彼此相乘。正如 Hochreiter 和 Schmidhuber 在[12]中指出的那样，你可以看到这些梯度易于消失和爆炸。现在，你仍然有这个问题，你可能有一个爆炸梯度。嗯，你可以截断梯度，但消失梯度更难解决。还有一个内存覆盖的问题，因为隐藏状态在每个时间步都被覆盖。因此，如果隐藏状态向量中没有足够的空间，检测长期依赖关系将会更加困难。这也是你的递归神经网络可能出现的问题。那么，我们能做得比这更好吗？答案还是:是的。
在这个深度学习讲座中，更多令人兴奋的事情即将到来。 CC 下的图片来自深度学习讲座的 4.0 。
这是我们将在下一个视频中讨论的内容，届时我们将讨论长短期记忆单位以及 Hochreiter 和 Schmidhuber 所做的贡献。
接下来:更多来自 Schmidhuber 毕业论文的秘密。来源: imgflip 。
所以非常感谢你听这个视频，希望在下一个视频中见到你。谢谢你，再见！
如果你喜欢这篇文章，你可以在这里找到更多的文章，在这里找到更多关于机器学习的教育材料，或者看看我们的深度 学习 讲座。如果你想在未来了解更多的文章、视频和研究，我也会很感激关注 YouTube 、 Twitter 、脸书或 LinkedIn 。本文以 Creative Commons 4.0 归属许可发布，如果引用，可以转载和修改。
RNN 民间音乐
FolkRNN.org
MachineFolkSession.comT5玻璃球亨利评论 14128
链接
参考
[1] Dzmitry Bahdanau、Kyunghyun Cho 和 Yoshua Bengio。“通过联合学习对齐和翻译的神经机器翻译”。载于:CoRR abs/1409.0473 (2014 年)。arXiv: 1409.0473。Yoshua Bengio，Patrice Simard 和 Paolo Frasconi。“学习具有梯度下降的长期依赖性是困难的”。摘自:IEEE 神经网络汇刊 5.2 (1994)，第 157-166 页。
[3]钟俊英，卡格拉尔·古尔希雷，赵京云等，“门控递归神经网络序列建模的实证评估”。载于:arXiv 预印本 arXiv:1412.3555 (2014 年)。
[4]道格拉斯·埃克和于尔根·施密德胡伯。“学习蓝调音乐的长期结构”。《人工神经网络——ICANN 2002》。柏林，海德堡:施普林格柏林海德堡出版社，2002 年，第 284-289 页。
【5】杰弗里·L·埃尔曼。“及时发现结构”。摘自:认知科学 14.2 (1990)，第 179-211 页。
[6] Jonas Gehring，Michael Auli，David Grangier，等，“卷积序列到序列学习”。载于:CoRR abs/1705.03122 (2017 年)。arXiv: 1705.03122。亚历克斯·格雷夫斯、格雷格·韦恩和伊沃·达尼埃尔卡。《神经图灵机》。载于:CoRR abs/1410.5401 (2014 年)。arXiv: 1410.5401。
【8】凯罗尔·格雷戈尔，伊沃·达尼埃尔卡，阿历克斯·格雷夫斯等，“绘制:用于图像生成的递归神经网络”。载于:第 32 届机器学习国际会议论文集。第 37 卷。机器学习研究论文集。法国里尔:PMLR，2015 年 7 月，第 1462-1471 页。
[9]赵京贤、巴特·范·梅林波尔、卡格拉尔·古尔切雷等人，“使用 RNN 编码器-解码器学习统计机器翻译的短语表示”。载于:arXiv 预印本 arXiv:1406.1078 (2014 年)。
【10】J J 霍普菲尔德。“具有突发集体计算能力的神经网络和物理系统”。摘自:美国国家科学院院刊 79.8 (1982)，第 2554-2558 页。eprint:http://www.pnas.org/content/79/8/2554.full.pdf.T11【11】w . a . Little。“大脑中持久状态的存在”。摘自:数学生物科学 19.1 (1974)，第 101-120 页。
[12]赛普·霍克雷特和于尔根·施密德胡贝尔。“长短期记忆”。摘自:神经计算 9.8 (1997)，第 1735-1780 页。
[13] Volodymyr Mnih，Nicolas Heess，Alex Graves 等，“视觉注意的循环模型”。载于:CoRR abs/1406.6247 (2014 年)。arXiv: 1406.6247。
[14]鲍勃·斯特姆、若昂·费利佩·桑托斯和伊琳娜·科尔舒诺娃。“通过具有长短期记忆单元的递归神经网络进行民间音乐风格建模”。英语。In:第 16 届国际音乐信息检索学会会议，晚破，西班牙马拉加，2015，p. 2。
[15] Sainbayar Sukhbaatar，Arthur Szlam，Jason Weston 等著《端到端存储网络》。载于:CoRR abs/1503.08895 (2015 年)。arXiv: 1503.08895。
【16】彼得·m·托德。“算法合成的连接主义方法”。在:13(1989 年 12 月)。
【17】伊利亚·苏茨基弗。“训练递归神经网络”。安大略省多伦多市多伦多大学。，加拿大(2013)。
【18】安德烈·卡帕西。“递归神经网络的不合理的有效性”。载于:安德烈·卡帕西博客(2015)。
贾森·韦斯顿、苏米特·乔普拉和安托万·博尔德斯。“记忆网络”。载于:CoRR abs/1410.3916 (2014 年)。arXiv: 1410.3916。
递归神经网络——第三部分
FAU 讲座笔记关于深度学习
向 schmid Huber-LSTMs 致敬
FAU 大学的深度学习。下图 CC BY 4.0 来自深度学习讲座
这些是 FAU 的 YouTube 讲座 深度学习 的讲义。这是讲座视频&的完整文字记录，配有幻灯片。我们希望，你喜欢这个视频一样多。当然，这份抄本是用深度学习技术在很大程度上自动创建的，只进行了少量的手动修改。如果你发现了错误，请告诉我们！
航行
欢迎回到深度学习！今天，我想向大家展示一种替代方案，来解决递归神经网络中的消失梯度问题。
于尔根·斯密德胡伯的名言。来源: imgflip 。
你已经注意到长时间的上下文是一个问题。因此，我们将讨论长短期记忆单位(LSTMs)。它们是由 Schmidhuber 的一位 Hochreiter 介绍的，并于 1997 年出版。
机器学习领域的两位著名作者。 CC 下的图片来自深度学习讲座的 4.0 。
它们被设计用来解决长期依赖中的消失梯度问题。主要的想法是，你引入门来控制额外状态下的写和访问存储器。
LSTM 细胞概述。 CC 下的图片来自深度学习讲座的 4.0 。
那么，让我们来看看 LSTM 单元。你看这里，一个主要的特征是我们现在有两个可以被认为是隐藏状态的东西:我们有单元状态 C 和隐藏状态 h 。同样，我们有一些输入。然后我们有相当多的激活函数。然后我们将它们组合起来，最后，我们产生一些输出 y 。这个单元比你之前在简单的 RNNs 中看到的要复杂得多。
LSTM 细胞的工作流程。来自深度学习讲座的 4.0CC 下的图片。
好，那么 LSTM 的主要特征是什么:给定一些输入 x 它产生一个隐藏状态 h 。它还有一个单元状态 C ，我们将在接下来的几张幻灯片中更详细地研究它，以产生输出 y 。现在，我们有几个门，这些门本质上是用来控制信息流的。有一个遗忘门，用来遗忘细胞状态中的旧信息。然后，我们有输入门，这实质上是决定细胞状态的新输入。由此，我们然后计算更新的单元状态和更新的隐藏状态。
单元状态处理的路径。 CC 下的图片来自深度学习讲座的 4.0 。
让我们来看看工作流程。我们有每个时间点 t 之后的单元状态，并且单元状态仅经历线性变化。所以没有激活功能。你看到在细胞状态的路径上只有一个乘法和一个加法。所以，细胞状态可以流过这个单位。对于多个时间步长，单元状态可以是恒定的。现在，我们要对细胞状态进行操作。我们用几个门来做这个，第一个门是遗忘门。这里的关键思想是我们想忘记细胞状态的信息。在另一个步骤中，我们要考虑如何将新的信息放入细胞状态，用来记忆东西。
因此，遗忘门 f 控制有多少先前的单元状态被遗忘。你可以看到它是由 sigmoid 函数计算的。所以，它介于 0 和 1 之间。它本质上是通过隐藏状态和 x 的串联加上一些偏差的矩阵乘法来计算的。然后乘以单元状态。所以，我们决定忘记状态向量的哪些部分，保留哪些部分。
现在，我们还需要输入新的信息。对于新信息，我们必须以某种方式决定将什么信息输入到单元状态中。这里，我们需要两个激活函数:一个我们称之为 I ，它也是由一个 sigmoid 激活函数产生的。同样，隐藏状态的矩阵乘法与输入加上一些偏置和 sigmoid 函数连接，是非线性的。记住，这个值会在 0 和 1 之间，所以你可以说它是在选择什么。然后，我们有一些 C 波浪号，这是一种由双曲正切产生的更新状态。然后，将某个权重矩阵 W 下标 c 作为输入，该权重矩阵 W 下标 c 乘以隐藏向量和输入向量加上某个偏差的串联。所以本质上，我们有这个指数，然后乘以中间细胞阶段 C 代字号。我们可以说双曲正切正在产生一些新的细胞状态，然后我们通过 I 选择这些指数中的哪些应该添加到当前细胞状态。因此，我们用 I 乘以新产生的 C 波形符，并将其添加到单元格状态 C 。
单元状态更新。来自深度学习讲座的 4.0CC 下的图片。
现在，我们使用与前一状态的遗忘门的逐点乘法来更新我们刚刚看到的完整单元状态。然后，我们用逐点乘法将已经由 I 识别的更新单元状态的元素相加。因此，您可以看到，仅使用乘法和加法，单元状态的更新是完全线性的。
隐藏状态更新和输出。来自深度学习讲座的 4.0CC 下的图片。
现在，我们仍然需要产生隐藏状态和输出。正如我们在 Elman 单元中所看到的，我们网络的输出只取决于隐藏态。因此，我们首先用另一个非线性更新隐藏状态，然后乘以单元状态的变换。这给了我们新的隐藏状态，并且根据新的隐藏状态，我们产生具有另一个非线性的输出。
所以，你看这些是更新方程。我们产生一些 o ，这实质上是一个 sigmoid 函数对新隐藏态的提议。然后，我们将它与细胞状态产生的双曲线正切相乘，以选择实际产生的元素。这给了我们新的隐藏状态。新的隐藏状态可以通过另一个非线性来产生输出。顺便说一下，你可以在这里看到，对于隐藏状态的更新和新输出的产生，我们省略了当然需要的转换矩阵。你可以把网络中的每一个非线性本质上解释为一个通用函数逼近器。所以，我们仍然需要线性部分，当然，在这里减少消失梯度。
记住:rnn 就像五行代码一样简单。图片来源: imgflip 。
如果你想训练所有这些，你可以回去用一个非常相似的方法，就像我们已经看到的 Elman 细胞一样。所以，你用反向传播来更新所有不同的权重矩阵。
在这个深度学习讲座中，更多令人兴奋的事情即将到来。 CC 下的图片来自深度学习讲座的 4.0 。
好吧。这已经把我们带到了这个视频的结尾。你们已经看到了长短期记忆细胞，不同的部分，不同的门，当然，这是这节课非常重要的一部分。所以，如果你正在准备考试，那么我肯定会推荐你看一看如何画出这么长的短期记忆单元。你可以看到 LSTM 有很多优点。特别地，我们可以通过单元状态的线性变换来缓解消失梯度的问题。顺便说一句，值得指出的是，我们在长短期记忆细胞中包含了一些我们从计算机设计中了解到的想法。我们基本上学会了如何操纵记忆细胞。我们可以说，在隐藏状态下，我们现在有了一种程序，一种有限状态机，它对一些内存进行操作，学习存储哪些信息，删除哪些信息，加载哪些信息。因此，这些网络设计如何逐渐接近计算机体系结构是非常有趣的。当然，关于这个还有很多要说的。在下一个视频中，我们将研究门控循环神经网络，它是 LSTM 细胞的一种简化。您将会看到，采用稍薄的设计，我们仍然可以获得 LSTM 的许多优势，但参数要少得多。好了，我希望你喜欢这个视频，下次我们讨论门控循环神经网络时再见。拜拜。
如果你喜欢这篇文章，你可以在这里找到更多的文章，或者看看我们的讲座。如果你想在未来了解更多的文章、视频和研究，我也会很感激关注 YouTube 、 Twitter 、脸书或 LinkedIn 。本文以 Creative Commons 4.0 归属许可发布，如果引用，可以转载和修改。
RNN 民间音乐
FolkRNN.org
MachineFolkSession.com
玻璃球亨利评论 14128
链接
参考
[1] Dzmitry Bahdanau、Kyunghyun Cho 和 Yoshua Bengio。“通过联合学习对齐和翻译的神经机器翻译”。载于:CoRR abs/1409.0473 (2014 年)。arXiv: 1409.0473。Yoshua Bengio，Patrice Simard 和 Paolo Frasconi。“学习具有梯度下降的长期依赖性是困难的”。摘自:IEEE 神经网络汇刊 5.2 (1994)，第 157-166 页。
[3]钟俊英，卡格拉尔·古尔希雷，赵京云等，“门控递归神经网络序列建模的实证评估”。载于:arXiv 预印本 arXiv:1412.3555 (2014 年)。
[4]道格拉斯·埃克和于尔根·施密德胡伯。“学习蓝调音乐的长期结构”。《人工神经网络——ICANN 2002》。柏林，海德堡:施普林格柏林海德堡出版社，2002 年，第 284-289 页。
【5】杰弗里·L·埃尔曼。“及时发现结构”。摘自:认知科学 14.2 (1990)，第 179-211 页。
[6] Jonas Gehring，Michael Auli，David Grangier，等，“卷积序列到序列学习”。载于:CoRR abs/1705.03122 (2017 年)。arXiv: 1705.03122。亚历克斯·格雷夫斯、格雷格·韦恩和伊沃·达尼埃尔卡。《神经图灵机》。载于:CoRR abs/1410.5401 (2014 年)。arXiv: 1410.5401。
【8】凯罗尔·格雷戈尔，伊沃·达尼埃尔卡，阿历克斯·格雷夫斯等，“绘制:用于图像生成的递归神经网络”。载于:第 32 届机器学习国际会议论文集。第 37 卷。机器学习研究论文集。法国里尔:PMLR，2015 年 7 月，第 1462-1471 页。
[9]赵京贤、巴特·范·梅林波尔、卡格拉尔·古尔切雷等人，“使用 RNN 编码器-解码器学习统计机器翻译的短语表示”。载于:arXiv 预印本 arXiv:1406.1078 (2014 年)。
【10】J J 霍普菲尔德。“具有突发集体计算能力的神经网络和物理系统”。摘自:美国国家科学院院刊 79.8 (1982)，第 2554-2558 页。eprint:http://www.pnas.org/content/79/8/2554.full.pdf.T11【11】w . a . Little。“大脑中持久状态的存在”。摘自:数学生物科学 19.1 (1974)，第 101-120 页。
[12]赛普·霍克雷特和于尔根·施密德胡贝尔。“长短期记忆”。摘自:神经计算 9.8 (1997)，第 1735-1780 页。
[13] Volodymyr Mnih，Nicolas Heess，Alex Graves 等，“视觉注意的循环模型”。载于:CoRR abs/1406.6247 (2014 年)。arXiv: 1406.6247。
[14]鲍勃·斯特姆、若昂·费利佩·桑托斯和伊琳娜·科尔舒诺娃。“通过具有长短期记忆单元的递归神经网络进行民间音乐风格建模”。英语。In:第 16 届国际音乐信息检索学会会议，晚破，西班牙马拉加，2015，p. 2。
[15] Sainbayar Sukhbaatar，Arthur Szlam，Jason Weston 等著《端到端存储网络》。载于:CoRR abs/1503.08895 (2015 年)。arXiv: 1503.08895。
【16】彼得·m·托德。“算法合成的连接主义方法”。在:13(1989 年 12 月)。
【17】伊利亚·苏茨基弗。“训练递归神经网络”。安大略省多伦多市多伦多大学。，加拿大(2013)。
【18】安德烈·卡帕西。“递归神经网络的不合理的有效性”。载于:安德烈·卡帕西博客(2015)。
贾森·韦斯顿、苏米特·乔普拉和安托万·博尔德斯。“记忆网络”。载于:CoRR abs/1410.3916 (2014 年)。arXiv: 1410.3916。
递归神经网络——第四部分
FAU 讲座笔记关于深度学习
门控循环单位
FAU 大学的深度学习。下图 CC BY 4.0 来自深度学习讲座
这些是 FAU 的 YouTube 讲座 深度学习 的讲义。这是讲座视频&的完整文本，配有幻灯片。我们希望，你喜欢这个视频一样多。当然，这份抄本是用深度学习技术在很大程度上自动创建的，只进行了少量的手动修改。如果你发现了错误，请告诉我们！
航行
欢迎回到深度学习！今天我们想谈谈门控循环单位(GRUs)，它是 LSTM 细胞的一种简化。
GRUs 为长时间的上下文提供了一种更简单的方法。图片来源: imgflip 。
这又是一个神经网络:门控循环单元。这里的想法是，LSTM 当然很棒，但它有很多参数，很难训练。
gru 的性能与 LSTMs 相当，但参数更少。 CC 下的图片来自深度学习讲座的 4.0 。
因此，Cho 提出了门控循环单元，并在 2014 年将其引入统计机器翻译。你可以说这是一种 LSTM，但它更简单，参数更少。
GRU 细胞的结构。 CC 下的图片来自深度学习讲座的 4.0 。
这是大致的设置。你可以看到我们不像在 LSTM 那样有两个不同的记忆。我们只有一个隐藏状态。与 LSTM 的一个相似之处是隐藏状态只沿着一个线性过程流动。所以，你在这里只能看到乘法和加法。同样，在 LSTM 中，我们从隐藏状态产生输出。
GRU 工作流程的主要步骤。来自深度学习讲座的 CC BY 4.0 下的图片。
所以让我们来看看 Cho 为了提出这个酷细胞的想法。它从 LSTM 中提取概念，并通过门来控制内存。主要区别在于没有额外的单元状态。所以，记忆只直接作用于隐藏状态。状态的更新可以分为四个步骤:有一个重置门，它控制着先前隐藏状态的影响。然后是引入新计算的更新的更新门。因此，下一步提出一个更新的隐藏状态，然后用它来更新隐藏状态。
那么，这是如何工作的呢？首先我们确定前一个隐藏状态的影响。这是通过 sigmoid 激活函数来完成的。我们又有一个矩阵类型的更新。我们将输入和之前的隐藏状态用一个矩阵相乘，并添加一些偏差。然后，将其输入这个 sigmoid 激活函数，该函数产生一些复位值 r 下标 t。
更新门首先用来自深度学习讲座的 4.0 计算 CC 下的 z 下标 t. Image。
接下来，我们生产一些 z 。这实质上是对新隐藏状态的更新建议。因此，这又是由一个 sigmoid 函数产生的，其中我们连接了最后一个隐藏状态，输入向量乘以矩阵 W 下标 z 并添加一些偏差。
接下来，计算更新建议。 CC 下的图片来自深度学习讲座的 4.0 。
接下来，我们提议更新。所以我们把输入和复位状态结合起来。这是以如下方式完成的:因此，更新建议 h 波浪号由双曲正切产生，其中我们将复位门乘以最后的隐藏状态。因此，我们基本上从最后一个隐藏状态中删除了我们不想看到的条目，并将 x 下标 t 与某个矩阵 W 下标 h 相乘，并添加一些偏差 b 下标 h。然后，这被提供给 tanh 以产生更新建议。
最后，新状态被计算为旧状态和更新提议之间的混合。下图 CC BY 4.0 来自深度学习讲座。
现在，有了更新建议，我们就进入了更新阶段。更新门控制旧状态和建议状态的组合。因此，我们通过乘以 1 — z 下标 t 来计算新的状态。你记得这是我们之前用旧状态计算的中间变量。进一步，我们添加 z 下标 t 乘以 h 波浪号。这是提议的更新。因此，本质上，产生了一个 z 下标 t 的 sigmoid 函数现在用于选择是保留旧状态的旧信息还是用新状态的信息更新它。这给出了新的隐藏状态。有了新的隐藏状态，我们产生了新的输出，并再次注意到我们在这一步省略了转换矩阵。因此，我们把它写成下标 t 的 sigmoid，但实际上有转换矩阵和偏差。不，我们在这里什么也没发现。所以，这个东西给出了最终输出 y hat 下标 t。
关于 GRUs 的评论。来自深度学习讲座的 4.0CC 下的图片。
一些注释:加法对于保留反向传播中的误差是必要的。这些门允许捕获不同的时标和远程相关性。这些单元能够通过学习限制门来学习短期依赖性。因此，如果我们有一个接近于零的下标 t，它将忽略先前的隐藏状态。我们还可以通过设置限制性更新门来了解长期依赖性。所以，这里我们的 z 下标 t 接近于零，这意味着我们忽略了新的输入门。然后，根据信息的类型出现不同的节奏。现在，你会说“好吧。现在，我们有了 RNN 单位、LSTM 单位和 GRUs。那么，我们该走哪一条？”
重新盖好 RNN 电池。下图 CC BY 4.0 来自深度学习讲座。
所以，让我们简单回顾一下。在简单的 RNNs 中，我们有基于梯度的训练，这很难做到。我们有长期依赖的爆炸梯度和消失梯度问题。短期依赖性很好，但是由于指数小梯度，它们可能隐藏长期依赖性，并且隐藏状态在每个时间步中被覆盖。
来自深度学习讲座的 4.0 的 CC 下的 LSTM 和 GRU. Image 对比。
然后，我们有 LSTMs 和 GRUs。他们两人都引入了对记忆进行操作的门。在 LSTMs 中，我们将其分为单元状态和隐藏状态。在 GRU，我们只有一个隐藏的国家。它们都有完全线性的记忆，这有助于我们理解长期依赖性。
LSTM 和格鲁的相似之处。来自深度学习讲座的 CC BY 4.0 下的图像。
所以，这里的相似之处，当然，是信息由门控制，以及捕捉不同时间尺度的依赖性的能力。状态的加法计算保留了反向传播期间的误差。所以，我们可以做更有效率的训练。
LSTMs 和 GRUs 的区别。 CC 下的图片来自深度学习讲座的 4.0 。
当然，LSTMs 有不同的隐藏和单元状态。因此，它们通过一个输出门、一个输入门和一个遗忘门来控制内存内容的暴露。他们独立工作。所以，他们可能会做不同的事情。新内存内容独立于当前内存。在 GRU，我们将隐藏状态和细胞状态结合在一起。所以，我们完全暴露在没有控制的内存内容中。有一个公共的更新门，它用我们的变量 z 下标 t 产生新的隐藏状态。它本质上决定是使用旧的状态还是使用建议的更新。所以，新的内存内容取决于当前的内存。
经验证据表明，LSTM 和 GRU 都优于埃尔曼细胞。然而，GRU 和 LSTM 的表现不相上下。 CC 下的图片来自深度学习讲座的 4.0 。
您也可以比较应用程序，因为您可能会问应该使用什么。在[3]中，您看到了门控递归神经网络对序列建模的经验评估。他们比较了简单的 RNN、LSTMs 和 GRU 网络。任务是复调音乐建模和语音信号建模。结果表明门控循环单位明显优于常规循环单位。GRU 和 LSTM 之间的比较不是结论性的。他们有相似的表现。
Jürgen Schmidhuber 的至理名言。图片来源: imgflip 。
所以，你可以说它们都非常适合序列建模。一个有较少的参数，但是对于本文中提出的任务，它没有产生很大的差异，所以它们都是可行的选择。
在这个深度学习讲座中，更多令人兴奋的事情即将到来。来自深度学习讲座的 4.0CC 下的图片。
好吧，下一次在深度学习中，我们想谈谈生成序列。我们现在有了递归神经网络，当然，递归不仅可以用来处理长序列，当然，我们也可以生成序列。因此，我们将稍微研究一下序列生成。非常感谢你们的聆听。我希望你喜欢这个视频，并希望在下一个视频中看到你。拜拜。
如果你喜欢这篇文章，你可以在这里找到更多的文章，或者看看我们的讲座。如果你想在未来了解更多的文章、视频和研究，我也会很感激关注 YouTube 、 Twitter 、脸书或 LinkedIn 。本文以 Creative Commons 4.0 归属许可发布，如果引用，可以转载和修改。
RNN 民间音乐
FolkRNN.org
MachineFolkSession.com
玻璃球亨利评论 14128
链接
参考
[1] Dzmitry Bahdanau、Kyunghyun Cho 和 Yoshua Bengio。“通过联合学习对齐和翻译的神经机器翻译”。载于:CoRR abs/1409.0473 (2014 年)。arXiv: 1409.0473。Yoshua Bengio，Patrice Simard 和 Paolo Frasconi。“学习具有梯度下降的长期依赖性是困难的”。摘自:IEEE 神经网络汇刊 5.2 (1994)，第 157-166 页。
[3]钟俊英，卡格拉尔·古尔希雷，赵京云等，“门控递归神经网络序列建模的实证评估”。载于:arXiv 预印本 arXiv:1412.3555 (2014 年)。
[4]道格拉斯·埃克和于尔根·施密德胡伯。“学习蓝调音乐的长期结构”。《人工神经网络——ICANN 2002》。柏林，海德堡:施普林格柏林海德堡出版社，2002 年，第 284-289 页。
【5】杰弗里·L·埃尔曼。“及时发现结构”。摘自:认知科学 14.2 (1990)，第 179-211 页。
[6] Jonas Gehring，Michael Auli，David Grangier，等，“卷积序列到序列学习”。载于:CoRR abs/1705.03122 (2017 年)。arXiv: 1705.03122。亚历克斯·格雷夫斯、格雷格·韦恩和伊沃·达尼埃尔卡。《神经图灵机》。载于:CoRR abs/1410.5401 (2014 年)。arXiv: 1410.5401。
【8】凯罗尔·格雷戈尔，伊沃·达尼埃尔卡，阿历克斯·格雷夫斯等，“绘制:用于图像生成的递归神经网络”。载于:第 32 届机器学习国际会议论文集。第 37 卷。机器学习研究论文集。法国里尔:PMLR，2015 年 7 月，第 1462-1471 页。
[9]赵京贤、巴特·范·梅林波尔、卡格拉尔·古尔切雷等人，“使用 RNN 编码器-解码器学习统计机器翻译的短语表示”。载于:arXiv 预印本 arXiv:1406.1078 (2014 年)。
【10】J J 霍普菲尔德。“具有突发集体计算能力的神经网络和物理系统”。摘自:美国国家科学院院刊 79.8 (1982)，第 2554-2558 页。eprint:http://www.pnas.org/content/79/8/2554.full.pdf.T11【11】w . a . Little。“大脑中持久状态的存在”。摘自:数学生物科学 19.1 (1974)，第 101-120 页。
[12]赛普·霍克雷特和于尔根·施密德胡贝尔。“长短期记忆”。摘自:神经计算 9.8 (1997)，第 1735-1780 页。
[13] Volodymyr Mnih，Nicolas Heess，Alex Graves 等，“视觉注意的循环模型”。载于:CoRR abs/1406.6247 (2014 年)。arXiv: 1406.6247。
[14]鲍勃·斯特姆、若昂·费利佩·桑托斯和伊琳娜·科尔舒诺娃。“通过具有长短期记忆单元的递归神经网络进行民间音乐风格建模”。英语。In:第 16 届国际音乐信息检索学会会议，晚破，西班牙马拉加，2015，p. 2。
[15] Sainbayar Sukhbaatar，Arthur Szlam，Jason Weston 等著《端到端存储网络》。载于:CoRR abs/1503.08895 (2015 年)。arXiv: 1503.08895。
【16】彼得·m·托德。“算法合成的连接主义方法”。在:13(1989 年 12 月)。
【17】伊利亚·苏茨基弗。“训练递归神经网络”。安大略省多伦多市多伦多大学。，加拿大(2013)。
【18】安德烈·卡帕西。“递归神经网络的不合理的有效性”。载于:安德烈·卡帕西博客(2015)。
贾森·韦斯顿、苏米特·乔普拉和安托万·博尔德斯。“记忆网络”。载于:CoRR abs/1410.3916 (2014 年)。arXiv: 1410.3916。
递归神经网络——第五部分
FAU 讲座笔记关于深度学习
序列生成
FAU 大学的深度学习。下图 CC BY 4.0 来自深度学习讲座
这些是 FAU 的 YouTube 讲座 深度学习 的讲义。这是与幻灯片匹配的讲座视频&的完整抄本。我们希望，你喜欢这个视频一样多。当然，这份抄本是用深度学习技术在很大程度上自动创建的，只进行了少量的手动修改。 自己试试吧！如果您发现错误，请告诉我们！
航行
如何使用 RNNs 进行序列生成？ CC 下的图片来自深度学习讲座的 4.0 。
欢迎回到我们关于递归神经网络的视频系列的最后部分！今天，我们想谈谈递归神经网络的采样。当我说采样时，我的意思是我们想使用递归神经网络来实际生成符号序列。那么，我们怎样才能做到呢？
如果你用正确的方法训练你的神经网络。你可以用一种方式来创建它们，它们预测下一个元素的概率分布。所以，如果我训练它们来预测序列中的下一个符号，你也可以用它们来生成序列。这里的想法是，从空符号开始，然后使用 RNN 生成一些输出。然后，将这个输出放入下一个状态的输入中。如果你继续这样做，那么你可以看到你实际上可以从你训练过的循环神经网络中生成完整的序列。
因此，简单的策略是执行贪婪搜索。所以我们从空符号开始。然后，我们只需选择最可能的元素作为下一个状态中 RNN 的输入，并生成下一个、下一个和下一个，这样每次实验都会生成一个样本序列。所以，这将是一个贪婪的搜索，你可以看到，我们得到的是这里构造的一个句子。我们在这里构造的句子是“让我们穿越时间”。当然，缺点是不可能有前瞻性。所以，姑且说“走吧”后面最有可能的词是“走吧”。所以你可能会产生循环，比如"走吧，走吧"等等。所以，你无法察觉“让我们穿越时间”有更高的总概率。所以，它倾向于在讲话中重复一系列频繁出现的词“和”、“这个”、“一些”等等。
光束搜索。来自深度学习讲座的 CC BY 4.0 下的图片。
现在，我们对缓解这个问题感兴趣。这可以通过波束搜索来完成。现在，波束搜索的概念是选择 k 个最可能的元素。k 本质上是波束宽度或大小。所以，在这里你可以推出 k 个可能的序列。你有一个以这 k 个元素为前缀的，取 k 个最可能的。所以，在我们右边展示的例子中，我们从一个空单词开始。然后，我们选择两个最有可能的选项，即“让我们”和“通过”。接下来，如果我们取“through”，我们生成“let’s”作为输出。如果我们用“let’s ”,我们产生“go ”,我们可以继续这个过程，用我们的两个光束。我们可以在波束搜索中保留两个最可能的序列。所以现在，我们一次生成两个序列。一个是《穿越时空》，一个是《穿越时空》。所以，你可以看到我们可以用这个光束的想法来产生多个序列。最后，我们可以确定哪一个是我们最喜欢的，或者哪一个产生了最大的总概率。因此，我们可以一次生成多个序列，这通常也包含比贪婪搜索更好的序列。我认为这是从 RNN 身上取样的最常见的技术之一。
当然也有其他类似随机抽样的。这里的思路是，你根据输出概率分布选择下一个。你还记得吗，我们把单词编码成一个热编码向量。然后，我们可以将自动 RNN 的输出解释为概率分布，并从中进行采样。这就允许我们产生许多不同的序列。那么假设“let’s”的输出概率为 0.8，那么它作为下一个单词被抽样 10 次中的 8 次。这会产生非常多样的结果，看起来可能太随机了。所以，你可以看到我们得到了非常不同的结果，以及我们在这里生成的序列。你也可以在生成的序列中观察到相当多的随机性。为了减少随机性，您可以增加概率或减少可能或不太可能的单词的概率。这可以通过例如温度采样来完成。这里你可以看到，我们引入了这个温度𝜏，然后我们用它来控制概率采样。这是一种常见的技巧，你已经在本课程的各种实例中看到过。
角色级 RNNs 。来自深度学习讲座的 CC BY 4.0 下的图片。
让我们看一些例子，我发现非常有趣的一件事是用 RNNs 进行基于字符的语言建模。我们这里有一篇 Andrew Kaparthy 的博文。我也把它作为下面描述的链接。在那里，他训练了一个基于莎士比亚文本生成的 RNN。它是在角色层面上训练的。所以，你只有一个字符作为输入，然后你生成序列。它产生了非常有趣的序列。这里，你可以看到已经生成的典型例子。让我读给你听:
唉，我想他将会到来，到那一天，小斯瑞恩将不再被喂养，
他只是一条锁链，是他死亡的主题，
我不会睡去。除来自 卡帕蒂的博客
诸如此类。所以，你可以看到这是非常有趣的，这种语言的类型非常接近莎士比亚，但是如果你通读这些例子，你可以看到它们本质上完全是胡说八道。然而，有趣的是，这种语言的基调仍然存在，而且对莎士比亚来说非常典型。这真的很有趣。
创作民间音乐。 CC 下的图片来自深度学习讲座的 4.0 。
当然，你可以产生很多很多其他的东西。我今天想给你们看的一个很好的例子是创作民间音乐。所以，音乐创作通常是用 RNNS 来解决的，你可以在文学作品中找到不同的例子，也是尤尔根·施密德胡伯的作品。这里的想法是使用更大更深的网络来产生民间音乐。因此，他们采用的是一个字符级的 RNN 使用 ABC 格式，包括生成标题。我这里有一个例子，这是一小段音乐。是的，正如你所听到的，这真的是民间音乐。这是完全自动生成的。有趣不是吗？如果你仔细听，你会听到民间音乐可能特别适合这个，因为你可能会说这有点重复。尽管如此，整首歌完全是自动生成的，这还是很棒的。实际上，人们会在真实的乐器上演奏计算机生成的歌曲，就像这些人一样。非常有趣的观察。所以，如果你对此感兴趣，我也把链接放在这里供你参考。你可以在这个网站上听到更多的例子。
图像序列生成。来自深度学习讲座的 CC BY 4.0 下的图片。
所以也有针对非顺序任务的 rnn。RNNs 也可用于静态输入，如图像生成。然后，想法是模拟从草图到最终图像的过程。你可以看到一个例子，我们从从模糊到清晰地绘制数字开始。在这个例子中，他们使用一个额外的注意机制来告诉网络在哪里寻找。这就产生了类似于笔触的东西。它实际上使用了一种变分的自动编码器，我们将在讨论无监督深度学习的主题时讨论这种编码器。
RNNs 上的单元总结。 CC 下的图片来自深度学习讲座的 4.0 。
所以我们稍微总结一下。你已经看到递归神经网络能够直接模拟顺序算法。你通过截断的反向传播来训练。简单的单元受到爆炸和消失梯度的极大影响。我们已经看到，LSTMs 和 gru 是改进的 rnn，它们明确地模拟了这种遗忘和记忆操作。我们没有谈到的是，还有很多很多的发展，我们无法在这个简短的讲座中涵盖。所以，谈论记忆网络，神经图灵机也是很有趣的，我们目前只接触了注意力和循环神经网络。在接下来的一个视频中，我们将更多地讨论注意力。
在这个深度学习讲座中，更多令人兴奋的事情即将到来。来自深度学习讲座的 CC BY 4.0 下的图片。
所以，下一次在深度学习中，我们想谈谈可视化。特别是，我们想谈谈可视化架构，培训过程，当然还有网络的内部工作。我们想弄清楚网络内部到底发生了什么，有相当多的技术，老实说，我们已经在本课前面看到过其中一些。在这堂课中，我们真的想深入研究这些方法，了解它们实际上是如何工作的，以便弄清楚深层神经网络内部发生了什么。一个有趣的观察结果是，这也与神经网络艺术有关。另一件值得更多思考的事情是注意力机制，这也将在随后的一个视频中涉及。
综合题。来自深度学习讲座的 4.0CC 下的图片。
因此，我有一些综合性的问题:“与前馈网络相比，RNNs 的优势是什么？”然后当然是:“你怎么训练一只 RNN？”、“挑战是什么？”，“LSTMs 背后的主要思想是什么？”因此，你应该能够描述在培训期间展开 RNNs。你应该能够描述埃尔曼细胞，LSTM 和格鲁。所以，如果你必须在不久的将来参加一些测试，这些真的是非常重要的事情。所以，最好对这种问题有所准备。好了，下面我们有一些进一步的阅读。安德鲁·卡帕西有一篇非常好的博文。有一篇关于 CNN 的机器翻译的非常酷的博文，我非常推荐阅读，还有一篇关于音乐一代的很酷的博文，你也可以在下面找到。当然，我们也有大量的科学参考。所以，我希望你喜欢这个视频，并看到你在下一个。拜拜。
如果你喜欢这篇文章，你可以在这里找到更多的文章，或者看看我们的讲座。如果你想在未来了解更多的文章、视频和研究，我也会很感激关注 YouTube 、 Twitter 、脸书或 LinkedIn 。本文以 Creative Commons 4.0 归属许可发布，如果引用，可以转载和修改。如果你有兴趣从视频讲座中获得文字记录，试试自动博客。
RNN 民间音乐
FolkRNN.org
MachineFolkSession.com
玻璃亨利评论 14128
链接
参考
[1] Dzmitry Bahdanau、Kyunghyun Cho 和 Yoshua Bengio。“通过联合学习对齐和翻译的神经机器翻译”。载于:CoRR abs/1409.0473 (2014 年)。arXiv: 1409.0473。Yoshua Bengio，Patrice Simard 和 Paolo Frasconi。“学习具有梯度下降的长期依赖性是困难的”。摘自:IEEE 神经网络汇刊 5.2 (1994)，第 157-166 页。
[3]钟俊英，卡格拉尔·古尔希雷，赵京云等，“门控递归神经网络序列建模的实证评估”。载于:arXiv 预印本 arXiv:1412.3555 (2014 年)。
[4]道格拉斯·埃克和于尔根·施密德胡伯。“学习蓝调音乐的长期结构”。《人工神经网络——ICANN 2002》。柏林，海德堡:施普林格柏林海德堡出版社，2002 年，第 284-289 页。
【5】杰弗里·L·埃尔曼。“及时发现结构”。摘自:认知科学 14.2 (1990)，第 179-211 页。
[6] Jonas Gehring，Michael Auli，David Grangier，等，“卷积序列到序列学习”。载于:CoRR abs/1705.03122 (2017 年)。arXiv: 1705.03122。亚历克斯·格雷夫斯、格雷格·韦恩和伊沃·达尼埃尔卡。《神经图灵机》。载于:CoRR abs/1410.5401 (2014 年)。arXiv: 1410.5401。
【8】凯罗尔·格雷戈尔，伊沃·达尼埃尔卡，阿历克斯·格雷夫斯等，“绘制:用于图像生成的递归神经网络”。载于:第 32 届机器学习国际会议论文集。第 37 卷。机器学习研究论文集。法国里尔:PMLR，2015 年 7 月，第 1462-1471 页。
[9]赵京贤、巴特·范·梅林波尔、卡格拉尔·古尔切雷等人，“使用 RNN 编码器-解码器学习统计机器翻译的短语表示”。载于:arXiv 预印本 arXiv:1406.1078 (2014 年)。
【10】J J 霍普菲尔德。“具有突发集体计算能力的神经网络和物理系统”。摘自:美国国家科学院院刊 79.8 (1982)，第 2554-2558 页。eprint:http://www.pnas.org/content/79/8/2554.full.pdf.T11【11】w . a . Little。“大脑中持久状态的存在”。摘自:数学生物科学 19.1 (1974)，第 101-120 页。
[12]赛普·霍克雷特和于尔根·施密德胡贝尔。“长短期记忆”。摘自:神经计算 9.8 (1997)，第 1735-1780 页。
[13] Volodymyr Mnih，Nicolas Heess，Alex Graves 等，“视觉注意的循环模型”。载于:CoRR abs/1406.6247 (2014 年)。arXiv: 1406.6247。
[14]鲍勃·斯特姆、若昂·费利佩·桑托斯和伊琳娜·科尔舒诺娃。“通过具有长短期记忆单元的递归神经网络进行民间音乐风格建模”。英语。In:第 16 届国际音乐信息检索学会会议，晚破，西班牙马拉加，2015，p. 2。
[15] Sainbayar Sukhbaatar，Arthur Szlam，Jason Weston 等著《端到端存储网络》。载于:CoRR abs/1503.08895 (2015 年)。arXiv: 1503.08895。
【16】彼得·m·托德。“算法合成的连接主义方法”。在:13(1989 年 12 月)。
【17】伊利亚·苏茨基弗。“训练递归神经网络”。安大略省多伦多市多伦多大学。，加拿大(2013)。
【18】安德烈·卡帕西。“递归神经网络的不合理的有效性”。载于:安德烈·卡帕西博客(2015)。
贾森·韦斯顿、苏米特·乔普拉和安托万·博尔德斯。“记忆网络”。载于:CoRR abs/1410.3916 (2014 年)。arXiv: 1410.3916。
Python 中的递归，探索
递归是那些看起来遥不可及的想法之一，可能来自编程存在的更高层次。a .你不知道它为什么是一个东西，b .你不认为你会需要利用它。毕竟，在撰写本文时， TIOBE 指数的前 10 名中还没有函数式编程语言。再想想，再想想…
也许你是对的，递归只对编码面试有用，否则就算了。然而，我认为学习不同的编程范例，以及它们解析问题的方式，最终会让你成为一名更好的数据科学家/程序员。学习一个新的范例会让你接触到新的思维方式和不同的代码结构。“这是我们一贯的做法”不会成为你这种态度的口头表达的一部分。因此，您将学到更多知识，并能更好地解决遇到的数据挑战。另外，如果你像我一样喜欢数学，让我们面对它，如果你在做数据科学，不喜欢数学，那么现在就离开(抱歉的语气，我爱你)，然后你会发现这项练习本身就是令人愉快的。
什么是递归？
为了介绍递归，让我们做一个简单的、假设的例子来比较解决方案。您有一个数组或一个数字列表，在被程序的其余部分使用之前，需要对它们求平方。我们可以使用 python 中的循环或列表理解的来创建平方版本。
# Set array
my_array = [10,11,12,13,14,15]# Method 1
# Create a new squared array with for loop (can be considered an anti-pattern)
squared_array = []
for num in my_array:
squared_array.append(num*num)# Method 2
# Create a new squared array with list comprehension, a bit more beautiful and concise
my_squared_array = [x*x for x in my_array]
通常，当我们在 Python 这样的命令式语言中循环值时，我们使用 for 循环或 while 循环。这些是我们已经习惯的概念，我们经常使用它们，它们是我们的第二天性。但是如果 for 和 while 循环明天被 python 砍掉了呢？除了世界上大部分停止运作，我们还有更紧迫的问题…现在如何使用递归？？
递归简介:平方数组
我们不能使用列表理解，所以让我们使用新的 pal 递归来平方我们的数组。为此，我们需要编写一个新的函数。
# Set array
my_array = [10,11,12,13,14,15]# Define our recursive, squared function that returns a new array
def squares(an_array, n=None, ret_array=None):
if n == None:
n = len(an_array)
ret_array = []
pos = len(ret_array)
squared = an_array[pos] ** 2
ret_array.append(squared)
if n-1 == 0:
return ret_array
else:
return squares(an_array, n-1, ret_array)
好吧，当一个列表理解就足够了的时候，这有点丑陋和冗长，但是它表明我们可以使用递归来代替 for 循环。该函数首先初始化一个保存平方值的新数组，使用 n 作为计数器来确定我们在按位置遍历数组时的位置，然后它调用自己，直到我们遍历了整个数组，随后得到新的平方数组。
有用的提示
把递归函数想象成一段代码，它不仅仅驻留在内存中的一个地方。当然，函数是在一个地方定义的，但是当数据传入时可以多次调用。这被称为调用堆栈。不要把它想成一条蟒蛇在吃自己的尾巴，尽管许多 R 用户会欢呼。想象一下，一群克隆人传递一个小盒子，每个人放入一枚硬币，然后将盒子传递给下一个克隆人。好吧，也许现在你更困惑了。回顾以下三个案例将有助于你理解这一点，并消除你可能有的任何困惑。
递归案例 1:标准阶乘
让我们用递归来做每个接触过递归的人都做过的事情，计算一个阶乘。还有谁爱离散数学！？
def factorial(num):
if num == 1:
return 1
return num*factorial(num-1)
n 的阶乘(记为 n！)是所有小于 n 的正整数的乘积，是对定义为 n 的任意数的运算！= n (n-1)(n-2)……(1！)，其中 1！= 1.这就是我们代码中所说的停止条件。这个想法对递归非常重要，因为没有它，我们的代码可能会进入无限循环，导致“时间悖论，其结果可能会引起连锁反应，破坏时空连续体的结构并摧毁整个宇宙。”—布朗博士
S ay 什么？
这里有一个有用的方法来形象化 4 的阶乘函数。。
阶乘(4)= 4 阶乘(3)= 4 * 3 阶乘(2)= 4 * 3 * 2 阶乘(1) = 4321 = 24
factorial 函数的每个实例都与我们在 def factorial() 中定义的相同，但它是一个新的实例，接受前一个 factorial 函数实例的结果并传递一个新的结果，所有这些都从基本情况 1 开始，在这种情况下，所有这些都将累积到最终计算中。
递归情况 2:前 N 个整数的和
下面是如何使用递归对 0 和 n 之间的整数求和
def sum_n(n):
if n == 0:
return 0
return n + sum_n(n-1)sum_n(1000)Outputs:
500500
让我们用相同操作的封闭形式来检查我们的结果，以确保我们正确地定义了递归函数。抽查总是一个好主意，因为正如理查德·费曼所说:“首要原则是你不能欺骗自己——而你是最容易被欺骗的人。”在报价中插入我和我自己，使其个性化。
def check_sum(n):
return int(n*(n+1)/2)check_sum(1000)Outputs:
500500
递归案例 3:复利
你可能以前见过复利的公式。
因为我们有一个指数的数字(1+r ),那么我们可以使用递归来计算我们的未来值 FV。
def future_val(pv, rate, t):
if t == 0:
return pv
pv = pv*(1+rate)
return future_val(pv, rate, t-1)
前面的函数假设复利 n=1。这意味着我们每个周期 t 只复利一次，这里 t 通常是指一年的时间。让我们扩展我们的例子，以包括不同的复合利率，如每月。
def future_val_n(pv, rate, t, n):
if t == 0:
return pv
pv = future_val(pv, rate/n, n)
return future_val_n(pv, rate, t-1, n)
我们已经能够回收我们的 future_val 函数，并扩展它，使我们在每个时间段 t 内复利 n 次，我们的函数起作用吗？
future_val_n(1000, 0.07, 20, 12)Outputs:
4038.73# Now we check our value from future_val_nprint(1000*(1+0.07/12)**(20*12))Outputs:
4038.73
最后的话
记住一些事情
- 我们不一定要有一门纯函数式语言才能开始在我们的代码中使用函数式编程技术
- Python 不是一种纯粹的函数式语言(当然)，但借鉴了它们的许多特性，比如作为第一类对象的函数和命名一对夫妇的列表理解。
考虑到这两点，我们意识到 python 对函数的递归调用次数有限制。此限制定义如下:
sys.getrecursionlimit()Outputs:
3000
如果我们在 n>3000 的情况下运行 sum_n 函数，它将抛出一个 RecursionError ，即使该函数适用于小于限制的递归深度。这是在将这些类型的函数合并到 python 代码库时需要考虑的事情。
既然你已经知道了递归，你将开始用不同的方式看待事物，也许你的下一个项目会有一些创造性的解决方案。我希望这是对递归和函数式编程范例的有趣而有启发性的介绍！
Python 中的递归
理解 Python 中的递归
在计算机科学中，递归是一种使用同一问题的较小解来寻找问题的解决方案的方法。递归算法在列表排序、二叉树遍历、路径查找等等方面都有应用。在本帖中，我们将讨论一个用于寻找自然数阶乘的经典递归过程。
我们开始吧！
因为我们将编写一个算法来寻找阶乘，所以有必要回顾一下阶乘的定义。自然数的阶乘， n ，是所有小于或等于 n 的自然数的乘积:
例如，如果 n =6:
让我们递归地思考这个问题。如果我们有一个递归函数 f ，我们想用 f 来计算 6！以下面的方式:
6!= f (6)
f (6) = 6* f (5)
f (5) = 5* f (4)，所以f(6)= 6 * 5 *f(4)
f (4) = 4* f (3)，所以f(6)= 6 * 5 * 4 *f(3)
f (3) = 3* f (2)，所以f(6)= 6 * 5 * 4 * 3 *f(2)
f (2) = 2* f (1)，所以f(6)= 6 * 5 * 4 * 3 * 2 *f(1)
f (1) = 1，所以 f (6) = 65432*1。
为了在 python 中实现这一点，我们需要定义一个函数，我们将调用“recursive_factorial”，它接受输入 n ，并返回*n** recursive _ factorial(n-1)。此外，我们希望函数不断返回自身，直到输入等于 1。此时，我们返回 1，递归终止。为了实现这一点，我们执行以下操作:
def recursive_factorial(n):
if n == 1:
return 1
else:
return n*recursive_factorial(n-1)
另外，我们应该处理 n =0 的情况，给定 0！=1.让我们适当地改变 if 语句:
def recursive_factorial(n):
if n <= 1:
return 1
else:
return n*recursive_factorial(n-1)
另一件值得注意的事情是，我们的函数不处理负数。这个方法只对自然数和零有效。
我们来考虑一下这个函数对于 4 来说是做什么的！：
We have to calculate recursive_factorial(4).The function asks, is n = 1? No, n=4, so let's return 4*recursive_factorial(4 - 1), which is 4*recursive_factorial(3).Now we have to calculate recursive_factorial(3). Is n = 1? No, n=3, so let's return 4*3*recursive_factorial(3 - 1), which is 4*3*recursive_factorial(2).Now we have to calculate recursive_factorial(2).Is n = 1? No, n=2, so let's return 4*3*2recursive_factorial(2 - 1), which is 4*3*2recursive_factorial(1).Now we have to calculate recursive_factorial(1).Is n = 1? yes, n=1, so let's return 4*3*2*1.
其中 n > 1 的情况称为递归情况，当 n < = 1 时，我们有基本情况。
根据这一逻辑，recursive _ factorial(4)= 4 * 3 * 2 * 1 = 24。让我们验证一下:
def recursive_factorial(n):
if n <= 1:
return 1
else:
return n*recursive_factorial(n-1)
print("4! =", recursive_factorial(4))
让我们试试前面的例子，6！：
print("6! =", recursive_factorial(6))
我将在这里停下来，但是您可以随意摆弄代码。如果你有兴趣学习更多关于递归的知识，python-course.edu 是一个很好的资源。
总之，在这篇文章中，我们讨论了如何编写一个递归算法来寻找一个自然数的阶乘。递归算法的其他经典应用包括汉诺塔问题和第 N 个楼梯问题。我希望你觉得这篇文章有用/有趣。这篇文章的代码可以在 GitHub 上找到。感谢您的阅读！
Python 中的递归函数
数据科学
数据科学领域的例子
照片由Tine ivani在 Unsplash 上拍摄
目录
- 什么是递归？
- 程序设计中的递归
- 来自数据科学世界的例子
- 结论
什么是递归？
递归是一个在操作中引用自身的概念。这在所有艺术领域都可以找到:文学(mise en abyme)、绘画、摄影……
一个物理世界的例子是将两个平行的镜子面对面放置。它们之间的任何对象都将被递归反射。
我们每天在定义词的时候都会用到递归！事实上，我们用词来定义他人，而他人也被其他词所定义！
程序设计中的递归
在编程中，它是一个引用自身的函数。两个函数可以互相调用，这叫相互递归。让我们用一个数学界的例子:阶乘。自然数n的阶乘是小于等于n的严格正整数的乘积。记为n!，计算如下:n! = (n-1)!*n。
在你的头脑中运行这个算法，你会发现它永远不会停止，它会无休止地运行。的确，如果我们用n = 3执行函数，T5 会被n = 3调用，然后n = 2，然后n = 1，然后n = 0，然后n = -1，等等。
一个永不停歇的算法是个问题，可想而知！
因此，解决方案是指定一个停止条件，这将始终取决于我们的问题。在我们的例子中3! = 3*2*1。您会注意到不同的因子(3、2 和 1)从不为负，甚至不等于 0。正是这个条件为我们提供了一个停止条件:“因子决不能小于或等于 0”。所以，我们添加一个条件语句:
在函数内部调用函数被称为递归调用。
递归调用必须在条件语句中。
**注:**每一次递归都可以转化为迭代。
来自数据科学世界的例子
1.二叉树结构的表示:
二叉树是由称为节点的元素层次结构形成的数据结构。节点由两类信息表征:
- 节点特定信息
- 描述与其后代节点的链接的信息
二叉树总是由一个节点指定:它的初始节点叫做根节点。
每个节点最多有两个子节点:
- 如果该节点正好有两个子节点，它们被称为 t 左子节点和右子节点。
- 如果该节点只有一个子节点，这是左子节点或右子节点。**
- 如果节点没有子节点，它被称为叶节点。
树枝是从树根到树叶的路径。
因此，二叉树是一个递归结构，因为左子树和右子树本身就是节点(依次代表树)。
二叉树图。源作者
这个图表示一个二叉树，它的节点 A 是根，B 是它的左孩子，C 是它的右孩子。节点 C 只有一个子节点 F(右子节点)。d、E 和 F 是叶节点。
【A，B，D】，【A，B，E】，【A，C，F】是树的分支。
让我们创建类节点:
属性:
- 标签 :表示观察的字符串。
- 左 :表示左子的类的实例。
- right :代表右孩子的类的实例。
方法:
- init: 构造函数。
- str: 根据以下示例返回表示树的字符串
- 线性化: 递归方法返回一个树形分支列表。
NodeFigure = Nd = Node('A',Node('B', Node('D'), Node('E')), Node('C',None,Node('F')))**>>> print(NodeFigure)**
Node(A,Node(B,Node(D),Node(E)),Node(C,None,Node(F)))
2.决策模型的表示
数据集表的切片
决策规则可以用二叉树来表示，称为二叉决策树。例如，对于下表中的数据集，可以构建下图所示的二元决策树。
在这一部分中，我们将创建 DecisionNode 类，它从 Node 类继承并表示一个二叉决策树。
属性:
- 标签 :表示观察的字符串，继承自 Node 类。
- distr :代表每个决策概率的字典:
——每个键代表一个可能的决策 0 或 1。
-每个值都是一个代表决策概率的实数。 - threshold: 一个实数代表测试阈值，用来推导要跟随的分支。
- left :表示左侧子节点的类的实例，继承自 Node 类。
- right :代表右子的类的实例，继承自 Node 类。
方法:
- init: 构造函数(从节点继承)
- str: 根据以下示例返回表示树的字符串
#Create the instance
left = DecisionNode('Decision', {0:0,1:1}, 0.5)
right = DecisionNode('Age',{0:0.5, 1:0.5},62,
DecisionNode('Decision', {0:0.2, 1:0.8},0.5),
DecisionNode('Tachycardia',{0:0.4,1:0.6},0.5,
DecisionNode('Decision',{0:0.1, 1:0.9},0.5),
DecisionNode('Decision',{0:0.9, 1:0.1},0.5)) )
DecisionNd = DecisionNode('Blood Pressure', {0:0.3,1:0.7},91, left, right)**>>> print(DecisionNd)**IF Blood Pressure >= 91 THEN Decision = {0: 0, 1: 1}
IF Blood Pressure < 91 AND Age >= 62 THEN Decision = {0: 0.2, 1: 0.8}
IF Blood Pressure < 91 AND Age < 62 AND Tachycardia >= 0.5 THEN Decision = {0: 0.1, 1: 0.9}
IF Blood Pressure < 91 AND Age < 62 AND Tachycardia < 0.5 THEN Decision = {0: 0.9, 1: 0.1}
简而言之:如何编程一个递归函数？
- 将问题分解成一个或多个同类型的子问题。子问题通过递归调用解决。
- 子问题应该比原问题小。
- 最后，分解必须产生一个不分解成子问题的基本问题(这是停止条件)。
资源:
- http://www.ipeis.rnu.tn/concours_nationaux/concours.htm
- https://www.geeksforgeeks.org/recursive-functions/
感谢阅读！😄
查看我的其他文章，并在媒体上关注我
哈利菲·艾哈迈德·阿齐兹
使用 PostgreSQL 的递归 SQL 查询
公共表表达式是 SQL 的一个鲜为人知的特性，它使得编写递归查询成为可能。让我们用 PostgreSQL 来探索一下吧！
在使用数据库时，大多数时候，你需要的只是SELECT、UPDATE (CRUD 操作)、几个JOIN和WHERE子句，仅此而已。但是，有时您会遇到数据集和任务，这将需要您使用更高级的 SQL 功能。其中之一是 CTE 或公共表表达式，更具体地说是递归 CTE ，我们可以用它来进行递归 SQL 查询。让我们看看它是如何工作的，我们可以用它做什么！
为什么是递归查询？
首先，为什么这实际上是一件事？递归查询有什么好处？—通常，当处理自引用数据或类似图形/树的数据结构时，递归查询很方便。这些使用案例的几个例子是:
自参考数据:
- *经理- >下属(员工)*关系
- 类别- >子类别- >产品关系
- 图表—飞行(飞机旅行)地图
树木:
- 任何分类系统——书籍、动物、遗传学…
- 文章之间的链接——例如在维基百科上
- 评论部分—例如 Reddit 上的主题
对于这些示例中的任何一个，都需要您构建临时表或使用游标来从这样的数据集中获取有用的数据。现在，我希望让您相信递归查询非常有用，让我们看看它们是什么以及如何使用它们。
我们需要什么？
递归查询利用了一种叫做 CTE 的东西——公共表表达式，它是 SQL WITH子句，更常用于简化非常复杂的查询(子查询)。让我们来看一个例子:
这是一个非常简单的例子，但是您可以想象如何使用它来使包含多个子查询的非常复杂的查询更具可读性。
除了上面的语法，我们还需要一些可以用于递归查询的数据。为此，我们将使用经理-下属层级，使用一个自引用表，定义如下:
员工表
下面的 SQL 创建了这样一个表，其中包含一些要使用的数据:
所以，现在我们来构建一些递归查询吧！
重复是人类的，重现是神圣的——l·彼得·多伊奇
递归
让我们从递归 SQL 查询的正式结构开始:
它看起来很简单，但并没有告诉我们太多，所以让我们看一个人类可读的例子:
该查询的输出是:
在这个例子中，我们的非递归基本情况只是SELECT 1，递归部分是SELECT n+1 FROM nums WHERE n+1 <= 10。这部分通过引用 CTE ( nums)的名字并联合所有结果来创建递归。最后，我们有WHERE子句来终止递归，这样我们的查询就不会无限地运行。
真实世界的例子
前一节展示了一个非常基本的例子，解释了它是如何工作的，但并没有真正展示递归 CTE 如何帮助我们。因此，让我们使用上面的经理-下属层级数据来看一些例子:
为某些员工获取*【经理树】*:
这个查询可以用来生成某个经理的所有下属的列表，它实际上是从某个特定雇员开始的子树。作为这里的一个基本案例，我们通过 ID 选择一个员工(经理),我们还包括了level,以表明我们在树中向下走了多少层。在递归部分，我们使用经理 id 将雇员表从 T5 转到 CTE。同样，我们通过增加上一步递归的结果级别来包含level。这是输出:
为了更好地想象那里发生了什么，请看下面的树。突出显示的部分是查询返回的内容:
另一个使用相同数据的实际例子是计算两名员工的离职程度:
递归 CTE 与前一个例子非常相似。为了简单起见，我们只选择 ID 和degree(而不是等级)。接下来，我们需要一个查询来查找并告诉我们两个雇员的离职程度——为此，我们将employees表连接到我们之前构建的包含 id 的rec表，并在各自的表中使用 id 连接degrees。在最后的SELECT部分，我们做了一些格式化以获得更好的输出，在WHERE子句中，我们可选地指定另一个(第二个)员工，我们希望得到他们的离职程度。输出:
同样，用同样的数据，让我们来看看在假设的公司里工作进展可能是怎样的:
这次我们从下往上运行递归。与前面的例子相比，这是通过翻转ON子句来实现的。为了创建可读的输出，我们使用了STRING_AGG函数，它从SELECT上面获取行，并使用>作为分隔符将它们连接起来。这是查询给我们的结果:
图的递归
足够多的雇员数据集，让我们探索一下我们能用图做什么——图作为一种数据结构是使用递归进行遍历的理想选择。因此，让我们首先定义一个简单的表并插入一些数据，这样我们就有东西可玩了:
图表
作为一个例子，我们将做一件显而易见的事情——用图的形式寻找路径。为此，我们将需要一个特殊的数据类型PostgreSQL—ARRAY。数组不是常见的关系数据库特性，但在这里存储路径非常方便。如果您不熟悉这种数据类型，下面是理解 SQL 所需的一些东西:
- 创建阵列—
ARRAY[value_1, value_2] - 串联数组—
ARRAY[value_1, value_2] || ARRAY[value_3] ALL函数-"x" != ALL(ARRAY["a", "b", "c"])-将"x"与数组中的每个值进行比较，如果所有比较的结果为true，则结果为true
好了，现在是问题:
上面的查询首先选择非递归情况下的所有直接邻居。然后在递归部分，我们建立在基础情况上(并且在随后的迭代过程中在先前的递归情况上)，并且将可用的边附加到现有的路径上，并且用相同的边替换目的地。我们对现有路径的终点(dest)与所选边的起点相同且新目的地尚未在路径中的每一行都这样做(以防止循环)。这是全部输出:
除了上面有用的东西，你还可以对无限数据流使用递归 CTE :
递归表是通过每一步迭代构建的，每一步产生有限数量的行，因此可以使用LIMIT从无限查询中检索第一个n行！
额外收获:递归视图
作为一个小奖励，我还想展示一下(从 PostgreSQL 9.3 开始)甚至可以创建递归视图:
尽管这只是语法上的好处，但在处理一些递归查询和数据时，它会让您的生活变得更加轻松。
结论
递归是一个非常强大的工具，它能以一种非常优雅的方式解决一些问题。不过，在 SQL 中使用它并不常见，所以希望本文向您展示了如何利用它的一些方法，以防您遇到只能递归处理的数据。
然而，递归会降低代码的可读性，所以要谨慎使用，尤其是在 SQL 中，因为即使没有递归，解析和理解也不是那么容易。
红色标记！！一个简单的分数如何影响你的一生。
欺诈和数字支付的问题
Yaneev 由 Pixabay 提供
在过去的学生时代，当人们用现金支付工资时，在借记卡、信用卡或在线商务出现之前，装甲卡车在街上游荡，将现金送到工资发放办公室，在那里，钱会被及时清点并装入棕色的小信封，然后发给工人。
现金仍然与数字支付流分层，但政府打击黑市经济、避税和犯罪洗钱，以及打击恐怖主义融资，意味着一个越来越西方化的无现金社会。
当然，这样做的问题是，不是现金所有者的人可能会欺诈性地获得资金。由于商品供应和支付之间的数字距离,识别资金操作者是否实际上是所有者的核心问题，这个问题在现金中不存在，因为资金与支付令牌是分开的，现在变成了一个问题。
银行如何努力消除信用卡欺诈是我们得分的开始
因此，接下来发生的是，每个卡支付事件都应该经过两级验证:
- 支付事件本身及其与客户账户主记录以及地理位置、数量、终端 IP、时间、购买模式的关系；和
- 通过“弹出框”、手机应用程序或输入全名、出生日期和地址，对账户持有人的身份进行强有力的支付事件认证；例如，还匹配送货和帐单地址。
所以，如果我住在澳大利亚，但一组来自保加利亚的欺诈性信用卡交易被阻止了？公平的决定。但那会留在我的记录里。
由于澳大利亚一家典型的大型银行每月处理高达 1.3 亿笔支付，因此根据公开的 Kaggle 信用卡欺诈训练数据集可以粗略推断，只有 0.172%的交易被确认为欺诈。如果 1.3 亿笔支付中有一半涉及银行卡，那么一家银行每月仍有约 11.2 万笔潜在的欺诈性银行卡交易。
尽管信用卡和借记卡号码内置了使用 Luhn 支票进行验证的功能，CVV 号码也有所帮助，但通过黑客、ATM 盗用、在线盗用和社交工程非法获取的大量卡号在网上随处可见，这意味着这是电子商务领域最大的问题之一。
在大多数在线欺诈案例中，如果欺诈不是由客户实施的，那么如果信用卡存在(CP)，作为发卡机构的银行将承担损失。在使用 EFTPOS 商户终端而没有卡(CNP)的在线交易中，损失由商户承担。澳大利亚的商户每年花费大约 5 亿澳元来解决无卡欺诈。因此，这是一个很大的问题，它会侵蚀商家的利润空间，还会导致废弃的购物车，商家会理所当然地说“我不能确定你就是你”。也是发卡方在冻结后重新发卡的成本。
虽然 1 级和 2 级验证是绝对有保证的，以防止有动机和机会的预谋的匿名黑客，但这变得有些复杂的是“风险分数”的概念，它基于客户自己实施欺诈或实际上成为欺诈受害者的倾向。
分数(满分为 100 分)类似于信用评分。日常客户实施的典型欺诈是应用程序欺诈。比如在申请增加信贷时虚报收入。“分数”会根据你的生活事件而变化，尤其是失业、关系破裂或破产…
澳大利亚犯罪学研究所，趋势与问题№2019 年 4 月 577 日
…此外，账户持有人同事的行为——已知同事的网络和他们的“分数”——会影响账户持有人的倾向“分数”,反之亦然。也就是说，如果一个已知的合作伙伴被证实从事欺诈活动，它会影响到你。
他们怎么会认识你的同事？很容易，通过脸书或推特。通过你付钱给的人，或者他们付钱给你的人，你的联系人。通过他们自己的 CRM 系统主数据层次结构。
这些分数也适用于那些被发现以低评级或高回报为基础欺骗顾客的商家。
不仅仅是银行用这种方式跟踪我们。
Airbnb 显然不以执行自己的政策而闻名，在收购在线背景调查公司“Trooly”后，它正在应用类似的自动化方法对客户和主人的“特质”进行描述和评分，如精神变态或自恋:
该专利称，博客和新闻网站上的帖子也被考虑在内，以形成“人物图”
使用 NLP 技术的特质分析是一种语言分析形式，它要么使用单词的分类法及其上下文来对情绪进行分类，这种情绪被映射到性格模型，在基本级别上类似于 Myers-Briggs，甚至是自动编码。这是更进一步，使用 ML 技术来判断你的在线“个性”，并标记和过滤掉危险行为属性的申请人。还有一个事实是，现在很容易识别发布的不当图片，并将其计入信任“得分”。
因此，如果 Airbnb 可以这样做，从而终身禁止顾客，那么拼车平台也可能这样做，或者易贝或亚马逊等。
为什么这有问题？
以这种方式将 ML/AI 技术应用于风险/信任评分人员的问题在于:
- 出错的倾向；
- 人类个性的浅薄模型被用来对人进行自动分级和评判；
- 缺乏赎罪的机会；和
- 强化学习居然漏进社会培训美国。
在出现错误的情况下，银行有可能为你的情况辩护，事实上，你可以去找调查官并花费精力来纠正这种误解。信不信由你，在这些事情上，银行实际上是高度诚信的。对于像 Airbnb 这样的私人组织，投诉可能会被置若罔闻。
因为可能给我们打分的模型是基于数据的，并且在后台自动运行，所以对它们和它们的理论基础(如大脑的计算理论)进行争论将变得几乎不可能。
此外，一些用于做这件事的 DNN 技术由于它们的黑盒性质而无法解释。这意味着，一旦被标记，不管是对是错，那面旗帜就好像我们衬衫背后的一个污点，可能永远不会被发现；由于许多非政府组织不受信息自由或监察员的监督，国旗可能会禁止赎回的可能性。
当我们凭经验学习这些评分“游戏”的规则时，这些规则在获得资金、住宿或交通的可用性方面对我们产生了真正的影响，我们是否会自己受到训练和约束，以双向机器-人类模式的性质来缓和曾经被视为普通的自由言论？
现在自动获得的言论自由，以及在我们同意下被评分算法断章取义的*【1】限制了我们现在拥有的令人惊叹的社交工具的潜力。如果我们的同事被发现有所欠缺，他们自己的分数会影响我们的分数，这是因为像脸书这样的社交媒体所依赖的网络或图表的性质。*
使用这些评分技术的公司的权衡是，如果他们过于积极地训练模型，以最大限度地降低风险，假阳性率将增加到这样的程度，即受到不当惩罚的客户将流失并找到替代方案，从而降低品牌资产和股东价值。
这里的一个解决方案是进行人工调查审查，但这很昂贵，而且使用 Keras 和 CloudML [2]等技术的 DNN 技术自动编码分数，无论如何都不可能，而且数量非常大。
随着这些评分型方法渗透到日常生活的更多方面，试图消除风险并增加未知参与者之间的信任，我认为我们将开始看到评分模型本身的强化奖励和惩罚成为我们必须遵守的政治正确性的一个方面，因为社交媒体表达中的语言变得越来越狭隘，基于互联网的对话的新私人渠道越来越多地出现在主流的审查之外【3】。
脚注
[1]通过服务的隐私条款，您可以了解他们在法律上有权以“研究”为目的共享数据。例如:https://policies.google.com/privacy?hl=en#infosharing
[2]尽管可以使用修改的随机森林模型作为分类器。
【3】类似茧的私人微网。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
