回归基础:朴素贝叶斯去神秘化
我们的目标是学习朴素贝叶斯，并将其应用于现实世界的问题，垃圾邮件检测。为什么是朴素贝叶斯？在这里找到答案！
Photo by Webaroo.com.au on Unsplash
我们的目标是学习朴素贝叶斯，并将其应用于现实世界的问题，垃圾邮件检测。为什么是朴素贝叶斯？考虑使用机器学习建立一个垃圾邮件过滤器。您希望根据邮件是未经请求的商业邮件(垃圾邮件)还是非垃圾邮件(火腿)对邮件进行分类。**分类垃圾邮件 vs. 火腿是一组更广泛的问题的一个例子，称为文本分类，一组问题，朴素贝叶斯可以以相对较高的性能解决。**朴素贝叶斯分类器是一种基于条件概率建模的强大分类算法。它对于具有多对多特征的分类问题特别有用，而且我们很快就会发现，可以忽略的条件依赖。名字“天真”暗示我们在这里做了一个错误的假设；事实上，我们是！但事实证明，我们天真的假设在实践中非常有效。
朴素贝叶斯
让我们假设我们对分类大量电子邮件感兴趣，并检测垃圾邮件与垃圾邮件。我们用 x 表示我们的输入向量。输入向量是每封邮件中单词的有序集合，比如 x = {I，am，happy} 。我们训练模型的目标是决定这个向量属于哪一类结果。我们把我们可能的结果集合表示为C；在这个例子中， C={spam，ham} 。
我们可以认为垃圾邮件检测是一个概率问题，我们想知道我们的电子邮件是垃圾邮件还是垃圾邮件的几率，并自然地选择几率更高的邮件。例如，我们可能会发现垃圾邮件的几率为 40%，因此垃圾邮件的几率为 60%(60% = 100%—40%)；然后，我们期望我们的模型将给定的电子邮件检测为 ham 。数学上我们用 P(spam|x)= 0.4 和 P(ham|x)= 0.6 或者如果我们真的想乱一点的话， P(spam| I，am，happy)= 0.4 和 P(ham| I，am，happy)= 0.6 。术语 P(spam|x) 读作电子邮件是垃圾邮件 ( 垃圾邮件发生)的概率，假设电子邮件是 x ( x 发生)。
到目前为止，一切顺利！但这里有一个问题。**怎么才能找到这些概率呢？**我们需要找到所有内容为 x 的电子邮件，并统计它们被垃圾邮件vs火腿的次数。比方说，我们收到 100 封内容为 x 的电子邮件，其中 60 封不是垃圾邮件，40 封是，那么:
不过这里有一个小问题！为了检测一封电子邮件并决定它是否是垃圾邮件，我们需要接收许多完全相同的电子邮件，并在能够对它们进行分类之前将它们记录在我们的记录中。**不实用！幸运的是，条件概率的贝叶斯定理可以帮助我们。请注意贝叶斯定理不同于朴素贝叶斯假设！**贝叶斯定理可以写成:
贝叶斯定理是概率论中的一个基本定理。好吧，就用它吧！
值得注意的是，我们真的想知道**𝑃(spam|x)/ 𝑃(ham|x)>1**是否存在；我们并不在乎它们的绝对值。所以我们真的想估计一下:
好消息是，与直接估算𝑃(spam|x】和 𝑃(ham|x) 相比，我们能更好地估算𝑃(spam|x】**𝑃(x|ham】**𝑃(ham】。据推测，我们有很多很多的电子邮件要么是垃圾邮件，要么是垃圾邮件，其中一些邮件的内容可能是垃圾邮件。这有助于我们处理不太频繁但存在于我们数据库中的电子邮件。但是，我们可能找不到以 x 为内容的电子邮件！我们该怎么办？这就是朴素贝叶斯帮助我们的地方！还有一个概率定理是基本定理。
Photo by JESHOOTS.COM on Unsplash
让我们将这个定理应用到我们的电子邮件示例中。
更好看！好，让我们再次应用同样的定理。
现在是朴素贝叶斯假设大放异彩的时候了！**朴素贝叶斯假设 x 的元素是条件独立的，给定 C 。**换句话说，在我们的例子中，我们将假设:
这个假设不仅听起来不对，简直荒谬！如果邮件中有“am ”,我们自然会期望有更高的几率出现“I”。然而，它工作得相当好！为什么？这需要对正在发生的事情有更深入的了解，但本质上每个单词的个体概率对于大多数常见的分类类型来说已经足够了。好了，让我们把所有的东西放在一个等式里:
剩下的就好办了！我们只需要查找包含各种单词的电子邮件，而不是所有单词都放在一起。那是一种更实际的锻炼方式！假设我们有1000 万封垃圾邮件和 1000 封邮件中有“快乐”字样。另外，假设我们有 1 亿非垃圾邮件，其中 100 万包含“happy ”,那么:
Photo by Hitesh Choudhary on Unsplash
使用 Python 进行垃圾邮件检测
我很确定没有人想自己做上面所有的计算；所以让我们来看一个 Python 库！我们将使用一堆 Python 库将电子邮件分类为垃圾邮件和火腿。计算机在理解文本方面并不擅长，所以我们需要做的第一件事是用另一种形式表示每封邮件的内容。表示要在机器学习上下文中使用的文本的一种方式是使用单词袋表示法(BOW)。在收集了所有可能的单词并将它们放入字典后，我们为字典中的每个单词分配一个向量。每个向量的长度等于字典中的单词数。例如，如果我们的字典中只有四个单词 {hello，I，am，happy} ，那么我们可以为它们分配以下向量:
在 BOW 表示中，文档被简单地表示为字数的向量；忽略单词顺序。一个简单的表示“我很开心很开心”的鞠躬是:
在这篇文章中，我们将使用这里可用的数据(感谢 Kaggle)。从技术上讲，这不是一个电子邮件数据集，但它是确定的。朴素贝叶斯也在这里工作！数据集在被您——饥饿的数据科学家——使用之前只需要少量的清理工作！下载 CSV 文件后，我们使用我们的朋友，’ 熊猫 '，来加载数据。
import pandas as pd
file_encoding = 'utf8'
input_fd = open('./spam.csv', encoding=file_encoding, errors = 'backslashreplace') #the file has some non utf8 parts
data = pd.read_csv(input_fd)
data = data.iloc[:,0:2] #removing the null columns
data.columns = ['label','content']
data.head()
我们需要将电子邮件放入 BOW 表示中。没问题！我们将使用模块’text’ from 'sk learn’来处理这个问题。首先，我们需要告诉 Python 为我们制作我们需要的字典。
from sklearn.feature_extraction import text
word_bagger = text.CountVectorizer()
注意:任何语言中都有一些单词对文本分类等没有那么大的价值；一个原因是它们在任何上下文中都很常见，例如，“the”、“am”和“this”无处不在。我们可以使用下面的选项来摆脱它们。
word_bagger = text.CountVectorizer(stop_words="english")
如果你有兴趣看看你的字典里有多少单词，甚至看一看它们，做我的猜测吧！您可以通过以下方式轻松查看:
words = word_bagger.get_feature_names()
len(all_words)
如你所见，我们的字典里有 8692 。如果你对 word 1001 到 1010 感到疑惑，那么你可以看看！
words[2000:2010]
我们得到下面的话:
现在我们有了字典，我们可以将任何句子转换成向量。只要照着这个做:
X = word_bagger.transform(data['content'])
让我们看看它通过转换’我很开心很开心【T1]'做了什么！
test = word_bagger.transform(['I am happy happy'])
如果你查看变量 test ，它被存储为*‘压缩稀疏行*’。这是因为’ sklearn '非常注意有效地使用内存，并希望最小化任何冗余存储。因此，它只跟踪非零元素。只需使用 print 命令查看测试的非零元素。
print(test)
训练模型:
信不信由你，我们已经完成了大部分工作！我们现在将使用另一个’ sklearn '模块来训练我们的朴素贝叶斯分类器。根据输入变量的特征，我们需要使用不同版本的朴素贝叶斯。它们是什么？让我们来看看。
- 高斯朴素贝叶斯:对于特征服从高斯分布的连续数据。
- 多项式朴素贝叶斯:针对特征为计数(即非负整数)的离散数据。
- 伯努利朴素贝叶斯:针对具有二进制值特征的离散数据。
在我们的例子中，我们需要使用多项式朴素贝叶斯；让我们导入它，然后在我们的数据集上训练模型。
from sklearn.naive_bayes import MultinomialNB
spam_nb = MultinomialNB()
spam_nb.fit(X, y)
我们可以使用’ sklearn '提供的原生评分函数轻松检查我们训练好的模型的样本内准确率。
spam_nb.score(X,y)
注意:这是一条通往高分的道路！我们在这里绝对是过度适应了。这可以使用通常的交叉验证或其他用于避免过度拟合的方法来避免。
我们完了！又短又甜，对吧？我们可以在一些样本案例上尝试我们的训练模型，看看结果是否符合我们的预期。
ham = "Let me know if it works for you? I will keep you posted!"
spam = "Buy real cheap eyeglasses here, eyeglasses.club!"
test_bagged = word_bagger.transform([ham, spam])
spam_nb.predict(bagged)
我们确实做得很好！总之，这是一个基本的机器学习算法，它是可靠的，因为很多很多的原因，比如易用性和快速计算时间。
快乐阅读&保持好奇！
原载于 2019 年 12 月 31 日http://hamidomid.com。
回归基础:第 1 部分
排列和组合
似乎不管我上了多少高级统计课，或者我重温了多少次这个话题，排列和组合仍然难住我。这篇文章是“回归基础”系列博客文章的第一篇，旨在建立数据科学的数学基础。这第一篇文章的目的是帮助彻底解决如何从瓶子里挑选那些讨厌的弹珠的问题！
排列和组合属于数学的一个分支，叫做组合学。具体来说，这是建立在广义计数基本原理的基础上的，即如果你进行 r 个实验，第一轮可能的结果是 n₁，第二轮是 n₂，……，rᵗʰ回合是 nᵣ，那么就有 n₁n₂……nᵣ可能的结果。
假设我们运行一个三轮实验，比如从一个装有红色和蓝色两个弹珠的罐子里选择弹珠。我们每轮选择两个弹珠。整个实验会有多少种可能的结果？
对于第一轮，有两种可能的结果。对于这两种结果中的每一种，第二轮都有两种可能的结果，所以 2 ^ 2 = 4 种可能的结果。在第三轮决赛中，四个变量中的每一个都有两个以上的可能结果，所以 4 ^ 2 = 2 ^ 2 = 2 = 8 个可能结果。
我们可以使用这个一般原则，用四个标准从给定的集合中找出排列项目的变化。这可以分为两种方式来思考一组物体的排列:排列和组合。对于排列，顺序很重要。在这种情况下，选择红色弹珠然后选择蓝色弹珠与选择蓝色弹珠然后选择红色弹珠是截然不同的结果。对于组合，顺序并不重要，即包含一个蓝色弹珠和一个红色弹珠的组是相同的组，无论哪个先被选择。无论哪一种，我们都可以替换掉瓶子里的弹珠，或者不替换。
- 排列(顺序事项)
a .带替换件
当顺序不重要时，我们有多少种方法可以从三个弹珠的罐子中选择两个弹珠，并进行替换？在第一个例子中，有三种方法来选择第一个弹球，对于这三种方法中的每一种，还有三种方法来选择下一个弹球。沿着箭头，有 9 种不同的可能结果，或者 3 种。
如果我们想替换弹珠，选择第三次，会有 3 3 3 = 3 种可能性；第四轮，我们会有 3 3 3 3 = 3⁴可能的结果，等等。一般来说，从一组 n 个对象中选择 r 个对象有 nʳ 种方式。
b .无需更换
如果我们不把三颗弹珠放回瓶子里，有多少有序排列的弹珠？对于第一种选择，也有三种选择。对于这三个选择中的任何一个，第二个弹球只剩下两个选择。最后的弹珠永远只剩下一颗，三轮过后我们将被迫停止选择。所以有 3 2 1 = 6 种可能的结果，或者说是 3！。
如果我们不打算选择所有的弹珠呢？假设瓶子里有 5 颗弹珠，我们将只选择其中的 2 颗。在这种情况下，有 5 种方法来选择第一个弹球，因为我们没有把它放回瓶子，第二个弹球有 4 种可能性。这是 5 4 = 20 种可能的组合。或者，这和上面的问题是一样的，但是“移除”了最后一轮，在这一轮中，我们继续选择瓶子中的所有弹珠。所以，我们可以把这些可能性分开，把 5 4 改写成:
一般来说，从 n 总个对象中选择 r 个对象而不替换的方法是:
2。组合(顺序无关紧要)
答:无需更换
让我们扩展上面的例子，并考虑我们可以从五个中选择两个弹珠而不用替换它们的方法。
我们知道，当我们从一组 5 个物体中选择 2 个时，共有 5 个！/(5–2)!可能的结果。这里的新内容是冗余问题。每个颜色对都有一个冗余副本(例如，红色+蓝色=蓝色+红色)，因此我们可以将可能性的数量除以 2 ^ 1 = 2！
所以，总可能性的数量是:
概括地说，从总共 n 个对象中产生 r 个对象的组而不替换(即，在一个组中没有重复项)的方法的数量等于:
这也是用符号写的:
b .带替换件
三个弹珠可以组成多少个不同的组,每组两个，可以替换？在这种情况下，包含一个红色和一个蓝色弹珠的组与选择红色然后选择蓝色或选择蓝色然后选择红色是一样的。和上一节一样，我们只关心最终的分组，而不是每个对象被选中的顺序。但是，因为我们有替换，所以每组中可以有重复的颜色。
在这种情况下，有六种可能的分组，我们可以展开得到:
类似地，当顺序不重要时，有 15 种方法从总共 5 个弹珠中选择 2 个弹珠，并进行替换。
和以前一样，我们可以将它展开得到:
所以，一般来说，从总共 n 个对象中产生多组 r 个对象的方法总数，加上替换，当顺序不重要时，是:
有用的公式
总之，对于从总共 n 个对象中选择 r 个对象的可能方式的数量，我们有以下规则:
我希望下次你从幸运弹珠罐中挑选或者只是准备数据科学面试时，这篇文章对你有用。欢迎和我联系，或者在评论中留下你的想法。
回归基础:第 2 部分
条件概率和独立性
这是一系列博客中的第二篇，旨在建立数据科学的数学和统计基础(第一篇讨论了排列和组合)。这篇文章的目标是回顾条件概率和统计独立性背后的概率定理。概率论使我们能够根据观察到的信息模式做出预测，这是数据科学中预测分析的基础。
条件概率是指在给定另一事件 B 也已发生的情况下，某一事件 A 将发生的概率。它被写成 P(A|B)。自然地，发生车祸的概率是以首先进入车内为条件的，所以当 P(发生车祸|不要进入车内)严格为零时，P(发生车祸|一定要进入车内)在零以上。显然，首先上路很重要。
另一方面，如果 B 发生的概率对 A 发生的概率没有影响，那么两个事件 A 和 B 被称为统计独立。例如，一个人是否会遭遇车祸完全与他或她上周一早餐吃了什么无关。
条件概率
有了条件概率，我们就可以根据先前事件的新信息来更新样本空间，从而更新我们的概率计算。所以，P(撞车|乘车)≠ P(撞车|坐火车)，因为这些“前科”(乘车和坐火车)给出了撞车可能性的重要信息。
让我们转到一个不那么病态、更经典的纸牌例子。在第一次抽牌时，从一副标准牌中抽出一张 a 的概率，记为 P(A1)，总是 4/52 或 1/13。然而，第二次抽 a 的概率 P(A2)取决于是否先抽了 a。如果在第一笔交易中确实抽到了 a，那么我们得到 P(A2|A1) = 3/51 或 1/17(注意样本空间已经从 52 更新到 51)。
进一步分解这个简单的例子可以让我们建立一些有用的方程。在前两次抽牌中抽到 a 的概率表示为 P(A1∩A2)，为(1/13)*(1/17)或 1/221。
到目前为止，我们已经:
这给了我们解决条件概率问题所需的第一个等式:
通过重新排列和乘法的交换性质，我们得到:
这个等式的内部两个表达式意味着:
这就是贝叶斯定理。我们来看一个例子！
贝叶斯在行动
假设你有一个同事，汤姆，他一周有 5 天(随机)有 3 天开车上班。不过，我们不会在可怜的汤姆身上使用车祸场景——汤姆的问题是，虽然他喜欢开车挨家挨户上下班的便利，但早上的交通可能会相当拥挤，这意味着他开车时会迟到 1/3 的时间。
汤姆也可以坐火车，虽然他不喜欢往返车站的额外麻烦，但他的火车通常是可靠的，当他乘火车通勤时，他只迟到 1/12 的时间。他每周(随机)5 天中有 2 天坐火车。
你的另一位同事 Larry 开始在办公室打赌 Tom 在迟到的日子里是开车还是坐火车。假设 Tom 没有及时通知向底池中放多少钱，您需要计算他开车去上班的确切概率。
到目前为止，我们有以下信息:
贝叶斯定理告诉我们:
而我们很容易就能算出 P(后期):
知道汤姆每 30 天迟到 7 天，我们就有:
同样地:
这些信息足以让你知道，如果你打赌汤姆在他迟到的日子里开车去上班，你会赢回你的钱，而且是 7 次中的 6 次。
独立性ˌ自立性
独立事件是指事件 B 的发生不会改变事件 A 发生的概率的事件。这样，当 A 和 B 是独立事件时，P(A|B) = P(A)。
根据这一点和贝叶斯定理，我们可以证明 P(B|A) = P(B ):
并且，由于 P(A∩B)=P(B|A)P(A)，那么 P(A∩B)=P(B)⋅P(A)=P(A)⋅P(B)当 a 和 b 统计独立时。
滚动骰子
统计独立性的思想可用于找出掷出至少 1 个公平骰子的三分之六的概率:
我希望这篇关于条件概率和统计独立性的基本原理的综述对你有所帮助，哪怕只是告诉你在同事的缺点或骰子游戏上该下多少赌注。欢迎在评论中联系我。
回到未来:人工智能与时间旅行的共同点
每一个对时间旅行的虚构描述都提出了两个问题——如何旅行到一个不同的时间，以及如何避免改变未来，在这个过程中潜在地消除时间旅行者。人工智能预测(或看到)可能的未来，但对其预测做出反应可能会改变未来，在这个过程中可能会破坏工具。
Photo by Greg Rakozy on Unsplash
回到过去的时间旅行是一个流行的虚构概念，有两个反复出现的问题。首先，如何到达那里(通常这暗示了许多次科学散文)。第二，一个共同的主题是，回到过去的最大风险是你改变了未来，这样做，创造了时间旅行者可能不存在的环境。这有时被称为祖父悖论基于时间旅行者杀死他们自己祖先的前提。
抛开日益复杂的 终结者 系列电影不谈，这跟 AI 有什么关系？
此外，涟漪效应可以在人工智能通常监控和吸收数据的复杂系统中产生二阶和三阶影响。
从时间的角度来看，改变现在来改变未来(通过更换燃料泵)与改变过去的事情来影响现在没有什么不同。因此，我们进入了循环因果循环和限制风险的世界。
具有讽刺意味的是，处理人工智能风险的方法之一本质上是管理数据的多种途径——因此，预测性维护发生在机器上，预测性维护没有发生在机器上。潜在的期货份额和扩大。
在第二部电影或第二本书中通常会发生同样的事情——我们进入了平行世界的世界，并最终进入了无限宇宙。一个任务，如果转移到 AI 身上，除了最敬业的 DevOps 从业者，其他人都做不到。
回归金属:开发大数据框架的三大编程语言
C++，Rust，用 Java 做数据密集型框架
Photo by Rob Lambert on Unsplash
在之前的一篇博客文章中: 统治数据密集型(大数据、快速数据)框架的编程语言 **，**我简要讨论了一些最流行的大数据框架，并展示了 Java 是数据密集型框架中事实上的编程语言。在 2004 年至 2014 年期间，当大多数主流大数据框架得到开发时，Java 相对于其他语言具有显著的优势(例如平台独立性、生产力、JVM)。
在过去的 10 年里，编程语言领域发生了很多变化。一些经典语言经历了重大改革和现代化。一些非常有前途的现代编程语言也以优雅的特性出现。计算机硬件已经经历了重大变化(多核处理器、GPU、TPU 的兴起)也是如此。集装箱化随着 Docker，Kubernetes 应运而生，并成为主流。
如果有人或某家公司想在 2019 年开发下一个颠覆性的大数据框架(例如下一个 Hadoop、Kafka、Spark)，什么编程语言会是最合适的？大数据领域的经典语言 Java 或任何其他语言？首先我将讨论 Java 的局限性，然后我将在数据密集型框架开发的背景下提出更好的替代方案。大部分的观点对于开发云原生、物联网和机器学习框架也是有效的。
Java 的局限性
每种编程语言都有其局限性。此外，Java 作为数据密集型领域最主要的编程语言，也有其自身的局限性。在这里，我将讨论 Java 在数据密集型框架开发环境中的主要局限性。
JVM: JVM 对 Java 被广泛采用并成为最流行的编程语言之一起到了巨大的作用。但是就像生活中的很多事情一样，有时候最大的优点也是最大的缺点。下面列出了 JVM 的主要限制:
- 运行期 : JVM 从开发者那里抽象出硬件。因此，Java 永远无法像接近金属的语言那样达到接近本机的速度/性能。
- 垃圾收集器 : JVM 提供了垃圾收集器，极大地帮助开发人员将注意力集中在业务问题上，而不用考虑内存管理。大多数时候，默认的垃圾收集器在默认设置下工作正常。但是，当垃圾收集器需要调优时，一切都完了。Java 的垃圾收集器由于其“ 停止世界 ”的性质，对于大量的长寿命对象有特殊的问题。不幸的是，数据密集型应用意味着大量的对象。Apache Flink 开发了自己的 堆外内存管理 解决方案来解决这个问题。Apache Spark 也有类似的使用 项目钨 的堆外内存管理解决方案。许多其他大数据框架(Cassandra、Solr)也面临同样的问题。使用 JVM 管理对象，开发堆外内存管理来绕过 JVM 的对象管理，说明 JVM 还没有高效地处理大量对象。
- 内存占用 : 由于 JVM 的内存占用很大，java 在缩小规模方面非常糟糕，也就是说，当一台机器上需要运行 100 个或更多的实例时。这就是为什么Linkerd已经从高性能、高吞吐量的 Scala+Finagle+Netty 栈中走出来生锈的原因。
****开发者生产力:Java 在 1995 年刚出现的时候，凭借其精简的规模和简单性，在当时是一门非常有生产力的语言。随着时间的推移，Java 增加了许多特性，增加了语言规范的规模/复杂性，不再被认为是最有生产力的语言。事实上，在过去的十年中，Java 经常因其需要大量样板代码的冗长本质而受到批评。
****并发:虽然 Java 是在多核时代之前发布的，但 Java 通过线程、锁、确定性内存模型和其他高级抽象提供了出色的基于共享内存的并发支持。基于共享内存的并发很难编程，并且容易出现数据竞争。Java 不提供任何基于语言级消息传递的并发性(更容易正确编程)或基于异步事件循环的并发性(I/O 繁重任务的更好选择)。 Akka 或其他高性能库可以在 Java 中提供消息传递或异步并发。但是如果没有 JVM 的内置支持，它们的性能将不如有本地支持的语言(例如 Go 、 Erlang 、 Node.js )。在当今多核处理器的世界里，这是 Java 的一个巨大缺点。
序列化 : Java 的默认序列化非常慢，有安全漏洞。因此，Java 序列化是数据密集型领域的另一个棘手问题，Oracle 将其称为 可怕的错误 ，并计划在未来的 Java 版本中放弃。
解决方案:回到金属
在 Java 的 heydeys 时代，这种接近金属的语言曾经被宣布过时并注定要消亡，但最近几年却获得了很多关注，这是有充分理由的。C 编程语言是由贝尔实验室的丹尼斯·里奇在一段时间(1969-1973)开发的，当时 CPU 的每个周期和内存的每个字节都非常昂贵。出于这个原因，C(以及后来的 C++)被设计成以语言的复杂性为代价，从硬件中获得最大的性能。
有一种误解认为，在大数据领域，人们不需要太在意 CPU/内存。如果有人需要更高的性能或需要处理更多的数据，就需要在大数据服务器中添加更多的机器。但是增加更多的机器/节点也会增加云提供商的费用。还有，随着机器学习/深度学习的兴起，未来几年硬件架构会发生快速变化。因此，在未来的日子里，完全控制硬件的编程语言只会越来越重要。
近金属语言在数据密集型框架中使用还有另一个缺点:平台依赖性。目前，Web 服务器操作系统由 Linux 以 97%左右的市场份额占据绝对优势 :
https://web.archive.org/web/20150806093859/http://www.w3cook.com/os/summary/
公共云也由 Linux 主导，占据超过 90%的市场份额:
https://thecloudmarket.com/stats#/totals
随着 Docker，Kubernetes 容器化的迅速发展，可以自由地在任何平台(例如 Windows)上开发任何其他平台(例如 Linux)。因此，平台依赖性不再是为数据密集型框架开发选择编程语言的关键因素。
不要误解我，Java 仍然是开发数据密集型框架的强大语言。有了 Java 新的 虚拟机 GraalVM和新的 垃圾收集器 ZGC ，Java 在几乎任何领域都将是更有吸引力的语言 。但是我确信，在未来几年，在开发数据密集型框架方面，接近金属的语言将会比 Java/Scala 更占优势。在这里，我将挑选三种接近金属的语言作为 2019 年在 Java/Scala 上开发数据密集型框架的潜在候选语言。
C++
像先驱的准金属语言 C 一样，C++也植根于贝尔实验室。在贝尔实验室期间， 比雅尼·斯特劳斯特鲁普 在 1985 年第一次发布商业版本时，已经初步实现了 C++作为“面向对象的 C”。C++是一种通用、静态类型、编译的编程语言，支持多种编程范式(函数式、命令式、面向对象)。像 C 一样，它也是一种近乎金属的语言，在没有内存安全或并发安全的情况下，对硬件进行完全控制。与 C 类似，C++也信奉以下 Moto:
也就是说，C++将为开发人员提供一种非常强大的语言，但开发人员有责任确保程序内存安全或数据无竞争。C++也有很多特性和功能(特性地狱)，可能是最难掌握的编程语言之一。自 2000 年以来，C++增加了许多特性(内存模型、基于共享内存的并发性、lambda ),使语言更简单、更安全、并发友好。但是这些变化是有代价的，C++语言规范变得更大甚至更复杂。
C++的另一个问题是构建时间长(我记得构建一个 CORBA 库需要 30 分钟)。然而，使用现代 C++(例如，【C++ 17)并使用类似于 资源获取是初始化(RAII) 的原则，与旧版本的 C++(例如，C++98)相比，在 c++中开发内存安全、数据竞争自由的编程相对更容易。C++仍然缺乏对消息传递并发(将在c++ 20中出现)和基于异步事件循环的并发的语言级支持。****
虽然有很多 C++库支持消息传递和基于异步事件循环的并发(传奇 Node.js 基于异步事件循环的并发是用 C++开发的)。学习 C++很难。掌握 C++更是难上加难。但是如果有一群有经验的 C++开发人员，他们可以构建无与伦比的框架(在任何领域，包括数据密集型领域)。有一个 4 节点 ScyllaDB(用 C++编写)的例子，它的性能优于 40 节点 Cassandra(用 Java 编写) 。****
优点:
- 最常用、最成熟的编程语言之一，在包括大数据或分布式系统在内的许多领域都有良好的记录。
- 惊人的快，接近金属语言与最大限度地控制硬件(CPU，GPU，TPU) ，旨在提取金属的最大性能。****
- 优秀的工具和庞大的库生态系统。语言越来越容易，并不断进化( 比雅尼·斯特劳斯特鲁普上 C++17 )。
缺点:
- 对消息传递或基于异步事件的并发性没有语言级别的支持(对于 I/O 繁重的任务)
- 非常陡峭的学习曲线和它的大规格，这是最难掌握的语言之一。不适合新手、刚毕业的学生或动态语言开发人员(PHP、Ruby 等)
- 没有对内存安全、数据竞争安全的语言级支持(虽然C++ 17相比老的 c++更安全)。很少有经验不足、粗心大意的开发人员会对整个项目造成严重破坏。
值得关注的大数据项目:
锈
https://thoughtram.io/rust-and-nickel/#/11
人们一直在寻找一种理想的编程语言，它将提供类似金属语言(C、C++)的性能/控制，以及运行时语言(Haskell/Python)的安全性。最后，Rust 看起来像是“承诺了的语言”，也就是说，它提供了类似 C/C++的性能/控制，以及Haskell/Python的安全性。受研究编程语言Cyclone(safer C)，Graydon Hoare首先开发了 Rust 作为个人项目，后来由 Mozilla 赞助，并得到了大卫·赫尔曼、 布伦丹·艾希的积极贡献 Rust 是一种静态类型的编译系统编程语言，支持函数式和命令式编程范式。****
它于 2010 年首次发布，第一个稳定版本于 2015 年发布。借助 所有权借用 的概念，它提供了RAII从语言层面的支持，使内存、线程安全编程具有 C++的速度，无需任何垃圾收集器或虚拟机。RUST 与其他近似金属语言(如 C/C++，Go)的真正区别在于它提供了编译时安全性，即如果代码编译，它将运行线程安全和内存安全，如“RUST中讨论的那样。它还为共享内存并发和 消息传递并发(通过通道) 提供了语言级并发支持，尽管它仍然缺乏基于异步事件循环的并发(正在开发中)。下面是 Mozilla 的 Alex Crichton 解释 Rust 并发性的精彩演讲:
Rust 也有像 ML 语言/Haskell 这样的表达类型和数字类型，并且在默认情况下有不可变的数据结构。因此，它像 ML 语言/Haskell 一样提供了出色的功能并发和数据并发。由于 Rust 和 Web Assembly(浏览器的下一件大事) 都是由 Mozilla 开发的，高性能快速的 Rust 代码可以直接转换成 Web Assembly 在浏览器上运行。另一个非常有趣的特性是 Rust 拥有 自托管编译器 即 Rust 的编译器是用 Rust 编写的(23 年后，Java 还没有自托管编译器)。Rust 在数据密集型领域也是一种很好的语言，因为它具有内存安全、无数据竞争、零成本抽象和并发的特性。服务网格平台 链接 从 Scala+Netty+Finagle 栈迁移到 Rust ，实现了更好的性能和资源利用率。用 Rust 编写的数据密集型运行时Weld对于数据密集型框架(如 Spark)可以放弃高达30 倍的性能增益。****
优点:
- 优雅的设计。Rust 是第一个成功结合了 C/C++的强大功能、Python 的安全性、ML 的表现力和 Haskell 的产品级语言。它有潜力像 C、C++、Java 一样成为改变游戏规则的语言。Rust 连续三年获得 StackOverflow 开发者调查中最受喜爱的编程语言:201620172018。
- 编译时保证内存安全(无悬空指针，无分段错误，无缓冲区溢出)，无数据竞争(无死锁)程序。
- 近乎金属的语言，拥有对硬件(CPU、GPU、TPU)的最大控制权和惊人的速度。如 基准游戏 所示，惯用 Rust 在性能上与惯用 C++不相上下。
- 利用现代多核处理器优势的并发友好编程。提供共享内存和消息传递并发。基于异步事件循环的并发(对于 I/O 繁重的任务)也在进行中(RFC 2394)。有了 Haskell 式的表达类型和不可变的数据结构，Rust 还提供了功能并发和数据并发。
缺点:
- 由于学习曲线较高，Rust 对于新手、刚毕业的学生或来自 PHP、Ruby、Python 等动态语言的开发人员来说并不是理想的语言。
- Rust 在行业中没有被广泛采用。因此，Rust 缺少库(箱)和工具，这反过来又阻碍了它的广泛应用。
- Rust 语言开发还不是一个成品。Rust 可能会引入重大的突破性变化或过于复杂的功能，并抑制其采用。
值得关注的大数据项目:
去
Go 是这个列表中的第二种语言，它源于贝尔实验室。语言的三位共同创造者中的两位: 罗布·派克 ( 计划 9 ，UTF-8)和 肯·汤普森(Unix 的创造者)在 Unix、C、C++起源于贝尔实验室的那段时间在那里工作。在 2000 年中期，Google 遇到了一个巨大的可伸缩性问题:开发人员可伸缩性(1000 名开发人员无法高效地在同一个代码库上工作)和应用程序可伸缩性(应用程序无法在 1000 台机器上以可伸缩的方式部署)。Google 也有过应届毕业生与现有数百万行复杂 C++代码库整合的问题，C++代码库编译时间长等一些问题详细讨论 这里 。****
发现现有的语言(C++，Java)不足以解决这些问题，谷歌聘请了软件行业的两个最优秀的人:Rob Pike 和 Ken Thompson 来创造一种新的语言。Go 于 2010 年首次发布，第一个正式版本于 2012 年发布。Go 设计者以 C 为基础，创造了一种简单、高效而强大的静态类型、编译、垃圾收集系统编程语言。Go 的另一个关键特性是它的编译时间非常快，它创建了一个单独的可执行二进制文件，该文件还包含 Go 运行时和垃圾收集器(几 MB)，并且不需要单独的 VM。Go 还提供了基于 CSP 的消息传递并发(通信顺序进程，源自东尼·霍尔 论文 )几乎和 Erlang 一样的方式。****
虽然 Go 没有使用 Actor 和 Channel(Erlang 使用的)，而是使用 goroutine(轻量级绿色线程)和 channel 进行消息传递。另一个区别是 Erlang 在参与者之间使用点对点通信，而 Go 在 goroutines 之间使用灵活的间接通信。因此，Go 提供了非常简单但极其可扩展的并发模型来利用现代多核处理器。下面是 Rob Pike 关于 Go 的并发模型的精彩演讲:
为了保持语言的简单和高效，Go 缺乏许多功能，如基于共享内存的并发性(尽管 Go 提供了与 Moto 通道之间的共享内存:“ ”不通过共享内存进行通信；相反，通过交流”和许多高级抽象(例如泛型)来共享内存。在 Google 的支持下，Go 已经被社区/行业很好地接受，并且拥有优秀的工具/库。一些最好的基础设施框架(Docker、Kubernetes)以及数据密集型框架都是使用 Go 开发的。
优点:
- 毫无疑问，这是最高效、最简单的系统编程语言。对于新手、刚毕业的学生或只有单线程、动态语言编程经验的开发人员来说，它是完美的接近金属的语言(PHP、Ruby、Python、JavaScript 等等)
- 通过使用 goroutines(轻量级线程)对消息传递并发性的语言级支持，它提供了高并发性和可伸缩性。它还有一个轻量级的嵌入式垃圾收集器来提供内存安全。
- 优秀的工具和库支持。已经是业内公认的成熟编程语言。
缺点:
- 由于运行时和垃圾收集器的存在，在 Go 中对硬件(如堆内存)的低级控制是不可能的。这样一来，Go 在速度和性能上都比不上 C，C++，Rust。此外，Go 的垃圾收集器缺乏 JVM 垃圾收集器的成熟度和性能。
- 由于其简单、极简的本质，Go 缺少许多通用编程语言的关键特性，例如共享内存并发、泛型。
- Go 没有为内存、数据竞争提供任何编译时安全性。
值得关注的大数据项目:
如果你觉得这很有帮助，请分享到你最喜欢的论坛上( Twitter，脸书，LinkedIn )。高度赞赏评论和建设性的批评。感谢阅读！
如果你对编程语言感兴趣，也可以看看我下面的文章:
****** [## 2020 年最受欢迎的 10 种编程语言
针对求职者和新开发人员的顶级编程语言的深入分析和排名
towardsdatascience.com](/top-10-in-demand-programming-languages-to-learn-in-2020-4462eb7d8d3e) [## 2021 年将使用的 10 大数据库
MySQL，Oracle，PostgreSQL，微软 SQL Server，MongoDB，Redis，Elasticsearch，Cassandra，MariaDB，IBM Db2
md-kamaruzzaman.medium.com](https://md-kamaruzzaman.medium.com/top-10-databases-to-use-in-2021-d7e6a85402ba) [## 控制数据密集型(大数据+快速数据)框架的编程语言。
大数据框架概述
towardsdatascience.com](/programming-language-that-rules-the-data-intensive-big-data-fast-data-frameworks-6cd7d5f754b0)******
处理 ML 模型中高度相关的列
解决一个常见问题的简单尝试
背景
作为数据科学训练营项目的一部分，我正在处理一个信用卡默认数据集。我们不得不运行各种 ML 算法来尝试和预测某人是否会违约，主要使用 F1 分数作为衡量标准。我们尝试在岭和套索逻辑回归、K 近邻和决策树上进行网格搜索，看看哪个模型效果最好。
问题！
正如上面的小标题所暗示的，我遇到了一些问题。以下是数据帧的列列表:
请注意，有一些看起来非常相似的列，pay _ 0–6、bill _ AMT 1–6 和 pay _ AMT 1–6。这些数字代表他们所在的月份。当我查看相关性时，我发现了这个:
如您所见，pay_ columns 和 bill_amt 列彼此之间有很强的相关性。pay_amt 这几个并不是那么的相互关联。高相关性表明许多列包含冗余信息，即来自一列的信息包含在其他列中。
量化问题
我的第一个问题是:我如何量化这种程度的冗余？公认的是，相关平方是另一个列描述一个列的良好程度的良好近似值。如果我把所有的相关矩阵平方并相加，会发生什么？
每个组有 6 列，因此如果所有列都是独立的(因此相关性为 0)，平方和将为 6，因为每列与自身的相关性为 1。如果它们都是相同的，那么所有的相关性都是 1，和是 36。第一种情况下每列的平均值为 1，第二种情况下为 6。在第一种情况下，有 6 列“有价值”的信息，而在第二种情况下，6/6=1 列“有价值”的信息，这对我来说很直观。
找到上面 3 个例子的总和，每次除以 6，我们得到:
为了得到每组中的非冗余列数，我们将该组中的总列数除以这个数。这表明 pay_ group 实际上有 6/3.21= 1.87 列“有价值”的信息，bill_amt 组有 6/4.94= 1.21 列有价值，pay_amt 组有 6/1.19=5.05 列有价值。这很直观，因为 bill_amt 列几乎完全相同，而 pay_amt 列则不同。
我还问自己，如果这些组相互关联，例如“账单金额”和“支付金额”，会发生什么，然后我得出了一个优雅的解决方案。
解决办法
我的解决方案是为每一列得出一个冗余分数，我称之为 C，它是该列与数据中所有其他列之间相关性的平方和。以下是按 C 度量的顶部和底部列:
Unsurprisingly, bill_amt and pay_ columns are at the top
注意，正如前面所讨论的，C 从来不会低于 1，对于 bill_amt 列，C 接近于 6(非常多余！).
应用解决方案:岭回归
如果你在做岭回归，有一个与列的平方系数成比例的惩罚。例如，如果你的模型试图预测 X，使用 A，你说 X=2A，惩罚将是(2 )λ，也就是 4λ。λ是进行岭回归前的超参数集。现在如果你创建一个列 B=A，你的模型将是 X= A+B，这将有一个(2*1 )λ，或 2λ的惩罚，是之前的一半。这意味着岭回归对冗余列的惩罚不足。
这个问题可以通过将列中的值除以 sqrt©来解决。在上面的例子中，A 和 B 之间的相关性是 1，所以每一列的 C 将是 2。如果我们将每一列除以√2，我们将得到等式 X= √2 A + √2 B，给我们一个(2*√2 )λ的惩罚，或如前所述的 4λ。这意味着我们的模型不会因为加入新列而有偏差。
声明:记得在使用定标器后进行划分，而不是之前！
应用解决方案:K-最近邻
K-最近邻(KNN)算法试图通过查看相似的数据点来猜测目标变量。相似数据点的数量看起来是“K ”,它通过最小化“距离”来确定相似性。
测量距离的一种常用方法是欧几里德距离——两点之间的直线距离。计算方法是将每列中的差值平方，将它们相加，然后对总和求平方根。例如，如果 A 列中的距离为 3，B 列中的距离为 4，则欧几里德距离为 sqrt(3 + 4 )= sqrt(25)= 5。
在上面的例子中，如果我们定义一个新的列 X=A，列 X 中的距离将是 3，新的欧几里德距离将是 sqrt(2*3 + 4 )= sqrt(34)。这造成了对冗余信息的不适当的偏见。
这也可以通过将两列除以 sqrt©来解决。在上面的例子中，A 和 X 之间的相关性是 1，所以如果 B 独立于 A，它们的 C 值将是 2。所以除以 sqrt(2)后，每列的距离都是 3/sqrt(2)。新的欧氏距离将是 sqrt(2 *(3/√2)+4)= sqrt(2 * 4.5+4)= sqrt(25)，和之前一样！
注意:如果你使用 p 阶的闵可夫斯基距离，你用(C )^(1/p).)除列在欧几里得的例子中，如果你在测量曼哈顿距离，p=1，那么你用 C 除列。
声明:记得在使用定标器后进行划分，而不是之前！
应用解决方案:随机森林
随机森林是随机生成的决策树的集合，这些决策树对机器学习问题的解决方案进行“投票”。通过引导选择随机数据，并在每个节点选择随机“特征”，即随机列。
如果列中有冗余信息，那么随机选择会使我们偏向冗余信息。这实际上可以很容易地解决，当选择它们时，给每个列一个 1/C 的权重。
从 A 和 B 中选一个的时候，几率是 50/50。如果我们加上 X=A，那么我们有 2/3 的机会从 A 获得信息。因为 A 和 X 的相关性为 1，所以它们的 C 值都为 2。除以 C，我们得到 A 的权重为 0.5，X 的权重为 0.5，B 的权重为 1。这意味着我们有 25%的机会选择 A，25%的机会选择 X，50%的机会选择 B，回到 50/50。
结论
我觉得我上面讨论的是对机器学习模型中相关列出现的一些问题的平滑解决方案。我试图在谷歌上寻找尝试类似事情的人，但我什么也找不到。如果有缺陷，或者你知道有人以前这样做过，请通知我，这样我可以做必要的更正。
反向传播人工智能的未来
反向传播(和梯度下降):用于训练神经网络的最流行的算法，通过识别哪些权重对输出中的误差贡献最大，并因此调整它们以给出更好的结果。
从任何意义上来说，人工智能首先是一个挑战。在技术上，伦理上，经济上，我们从未面临过人类历史上这样的破坏。探索这将把我们引向何方以及我们今天在哪里是有意义的，并尝试制定一个从这里走向何方的路线图。
在第一部分，我提出了一些关于人工智能未来的争论，它的哲学含义和牵强附会。
在第二部分，我一路回溯到今天，对人工智能研究在哪里、走向哪里以及关键问题是什么进行了更技术性的讨论。
第一部分
今天的机器并不像你想象的那样聪明。事实上，他们甚至没有接近。《终结者和我，机器人》的承诺(AI 陈词滥调#1)放错了地方。
计算机需要大量的数据来学习任何东西，即使这样，它们也不总是能很好地概括。想象一下，给一个 5 岁的聪明的孩子打电话——他必须看 10，000 张猫的图片才能理解猫的样子。我不会为他设立大学基金。我也不建议花时间给任何人看你的猫的一万张照片。
这不是人工智能未来的样子。在未来，人工智能将能够几乎毫不费力地用最少(或没有)的数据进行归纳。这被称为人工通用智能，它将理解或学习任何人类可以完成的智力任务，比我们好得多，现在你想起来了。
尼克·博斯特罗姆(Nick Bostrom)发人深省的书——《超级智能》(Super Intelligence)提出了人工超级智能(ASI)的概念，它将在很大程度上取代 AGI，甚至更多。
让我们把手弄脏(用机器人油我说的对吗)看看这一切意味着什么。
“大家都讨厌道德哲学教授！”
这些人工智能不仅可以在计算机上实现，还可以在我们提出的任何虚拟机上实现(一些研究人员还认为，我们的大脑也是一个虚拟机)。不用说，我们已经发现了人类历史上最普遍的技术。这不仅将是有史以来最先进的技术，而且将是一个全新的存在——马克斯·泰格马克在他的同名书中称之为生命 3.0 。
这些新生物有什么道德地位？
基质非歧视原则:
如果两个存有具有相同的功能性和相同的意识体验，
而只是在他们实现的基质上有所不同，那么他们就具有了
相同的道德地位。
如果我是碳，我的新人工智能朋友是硅，这都没关系，就像我的肤色没关系一样。博斯特罗姆等人认为，基质缺乏任何道德意义，因此这些代理人将与我们具有相同的道德地位。
关于人工智能的道德辩论有一个问题:除非道德哲学家能够为道德和伦理提供一个完美的框架，否则所有的辩论都是徒劳的。这项工作是天生的和递归的困难，并有深远的影响。人工智能的效用函数可以允许潜在的伤害、偏见和全球灾难，这只是因为常识和道德规范无法形式化为这些代理人可以理解的语言。
道德讨论很重要，因为很可能这些存在是如此强大，以至于他们与神的概念无法区分。一旦我们只用一台机器就实现了普遍智能，一场“智能爆炸”就可能发生。任何足够聪明的智能体都可以进入自我完善的循环，直到它脱离人类的控制。
让我们来谈谈当这些生物开始生活在我们之间时会发生什么。
他们抢走了我的工作
毫无疑问，反对人工智能的主要论点是，它们会抢走我们的工作。反对的观点是，即使他们这样做了，我们也可以自由地把时间花在有意义的事情上，避免所有的机械工作，并在某一天畏缩在这样一个事实上，即古代人类花了大半辈子的时间在不必要的、累人的、危险的事情上。
Weizenbaum 认为人工智能不应该被用来取代那些需要尊重和关怀的职位，例如:
- 治疗师
- 一名士兵
- 法官
- 警察局
- 客户服务
几乎所有这些职业都在大量使用人工智能。谷歌的助手预约预约的演示暗示了人工智能未来在所有涉及人类对话的工作中的主导地位(治疗、客户服务等)。Hannah Fry 的书 Hello World 展示了许多人工智能被实现为法官、医生的例子，并讨论了这方面的问题。人工智能还在艺术和音乐等领域证明了自己的勇气，这是 100 年前任何人都无法预测的事情。
工作和工资是根据一个人对社会的贡献提供的，并且(通常)与一个人解决问题的难度成正比。当一个毫不费力的智能生物出现时会发生什么？我们的工作不属于他们的理由很少，而且几乎没有一个是合理的。这完全不是一件坏事，经济学家和技术专家认为，随着这些工作流向人工智能代理，新的工作将为人类开放，其性质我们甚至无法预测。看来你终于可以给人看你的猫的一万张照片了。
很难预测会发生什么，根据过去的趋势进行推断也是不明智的，因为真正人工智能的崛起是一种前所未有的高度不确定的趋势。
智慧生物的目标
人工智能具有潜在的危险，不是因为它会占据阿诺德·施瓦辛格的身体来释放他们的愤怒，而仅仅是因为他们不想。他们没有动机或目标去煽动他们去做这样的事情。这给我们带来了实际的危险，当人工智能的目标与我们的目标不一致时会发生什么，以及我们如何确保这种情况不会发生。
作为一个有智慧的生物，我们学会了自己做决定，考虑到我们的生存和发展。今天没有一个人工智能系统有任何目标，尽管它们每秒都在做出决定。他们很好地适应了一个特定领域的任务，除了他们已经看过几百万遍的东西之外，他们完全忘记了其他任何东西。对于这些代理人来说，在没有任何目标的内在表现的情况下，决定一些事情是可能的，他们今天这样做了数十亿次。但是很难想象一个没有目标的普通智慧生物；即使是 2 岁的孩子也有目标。在 AGI 体系中，要求透明的目标是有道理的，如果没有别的原因的话，要求自动防故障是有道理的。但正如前面提到的，智能爆炸可能会很快失控，我们不知道也没有任何工具来解释这些硅大脑的目标。当务之急是在任何这样的先进机器制造出来之前解决这个问题。
创造力和情感
创造力也许是我们最大的优势和最有价值的资产，也许在反对人工智能的争论中也是如此。他们也许能每秒进行十亿次计算，但他们能画出这个吗
认识到创造力是一个困难的问题，更不用说提出创造性的想法了。随着计算机生成艺术和神经风格转移的出现，激起了深度学习社区，我们有了人工智能在传统领域的创造力的线索。在绘画、音乐和下棋等受限领域，人工智能已经领先一步，但在一般意义上匹配人类的创造力是我们只能做出假设的事情。
当我们提到人工智能时，另一个被视为异类的东西是情感。人工智能系统可以很好地伪造情绪(想想聊天机器人)。他们最近开始写漂亮的(开放 GPT-2)和像人类一样说话。我说是假的情绪，因为在这些算法中没有任何情绪的内在表现，然而它们却吐出了壮丽的文字、绘画和音乐。这里有一个问题:一些研究人员认为，像焦虑这样的感觉也需要被包括在内，并用于制定 AGI 系统，这是有意义的，因为我们的决策不仅源于我们的感觉，我们认为是情感的，还源于功能和现象意识以及过去的历史；这些事情使我们能够安排和优先考虑我们生活中的动机——一些我们想传递给我们聪明的主人的东西。
关于人工智能的未来会是什么样子，已经有了普遍的共识，尽管没有人同意它的细节。
重要的是要乐观、富有想象力，但也要对每一条信息持怀疑态度。试图预测未来在过去从来没有很好的结果，而过度推断则更糟。显而易见的事实及其不可避免的后果会使我们在未来误入歧途，因为今天的一切都是短暂的，很可能一开始就被证明是错误的。我还没有讨论很多主要问题(手推车问题、意识和品质问题、机器人权利等)，但这确实是一个起点，让你了解人工智能伦理、安全及其对我们所有人的影响(剧透:它对我们的影响远远不止推荐电影和产品)。
人工智能代理会记得我喜欢在冰淇淋上放什么配料，我最喜欢的电影是什么，我和谁聊得最多，以及我忘记了什么。他们不断地剥夺我们进行任何心算的需要，而我们喜欢这样。
我们不再是像我们的祖父母一样的人类，技术已经成为我们的延伸；我们已经是电子人了，人工智能是革命的下一章。
重要的是要批判性地思考这一切是否是一个实际的可能性，或者我们所有人都严重高估了 Alexa。在第二部分，我试图探索什么是真实的，我们将走向何方，猫的形象发生了什么。
第二部分
今天提到 AI 就是指机器学习或深度学习(或神经网络)，这两者都是人工智能的子集。这两类算法背后的基本原理很简单:要解决任何问题，你需要足够多的正在解决的问题的例子——带标签的数据，为我们提供问题的特征和答案(监督学习)，我们希望使用我们为问题提取的特征，我们可以从我们的系统中获得良好的预测。通过将我们的预测与正确的答案进行比较，当然，每当计算机给出错误的答案时，我们都会用棍子打它一顿，这样我们就可以调整参数，从而每次都能获得更好的输出。对数百万个参数(或更多)这样做一百万次，我们就产生了智能。
直觉上，这是有意义的，你看着猫的形象，你看到像眼睛、耳朵、胡须这样的特征，经过足够的训练，你就会明白猫是什么样子。这个过于简化的版本应该足以让你相信，只要有足够的数据和时间，这些算法就能创造奇迹。我们今天的算法也存在很大的问题。让我们看看其中的一些，看看未来是否真的像 5 岁的孩子一样聪明。
智能偏见
一个非常微妙的问题产生于我们目前对智慧的态度，这不是我们的错。我们所有人都有固有的偏见，不幸的是，我们的机器也赶上了这一点。
计算机并不聪明，但它们是非常好的模式发现者。在谷歌上搜索医生的图片，会发现超过 95%的结果是美国或英国人(主要是男性)。这种偏差在我们的算法中很普遍。如果我只用两个品种的猫来训练我的猫分类器，它会阻止所有其他的猫进入猫咖啡馆。我们非常小心谨慎地制作平衡且具有代表性的数据集，但这并不是唯一的问题。
问题从人类自身开始。人工智能进步背后的大多数人和政府代表都是白人男性，而像人工智能这样的问题需要由人类的代表来解决。许多人工智能发展中人的因素存在偏见的例子已经被观察到，这是危险的，因为人工智能是目前世界上最可武器化的技术之一。如果只有一小部分人控制它，上帝禁止他们的意图是错误的，人类的未来可能会受到非常不利的影响。值得称赞的是，人工智能研究人员非常迅速地发现了这个问题，并正在采取措施解决这些问题。
偏见不仅会因为不平衡的数据集而出现，还会在问题本身形成之前悄悄出现。编写这些算法的流行方式是使用大公司(如谷歌、脸书)提供的 API，不用说，如果在这一阶段出现偏差，它会迅速传播。
一切都很好，只要这仅限于猫咖啡馆和谷歌图像，但未来的人工智能系统将部署在高风险的情况下，如法院，工作面试和医院。如果这些偏见蔓延开来，许多人的生活将会受到影响。
想象一下，一名人工智能法官收到了一个白人和一个黑人的相同数据，但只判了黑人入狱，因为它从统计数据中了解到黑人更有可能有罪。在这里，不正确地构建问题和不平衡的数据集都可能在给出错误或有偏见的决定中发挥作用(以及许多其他因素)。
我们所有聪明的霸主就这么多了。
你怎么知道那是一只猫:人工智能算法中的透明性
出于多种原因，理解计算机如何做出决定是有意义的。许多人将人工智能算法视为黑盒，但最近的研究(如贝叶斯网络)正在开辟一个前沿，以找出为什么一种算法会做出特定的决定。
这也可以有效地对抗这些算法中的偏差。当务之急是以一种对检查透明的方式开发人工智能。
想象一下，在未来，当你的人工智能医生建议你服用某种特定的药物，而你信任它，因为你不想惹阿诺德·施瓦辛格。这里有一个问题:终结者不是真实的(将来也不会是)，你不信任你的人工智能医生。你想知道它为什么以及如何做出决定，你的生活就取决于此。
黑匣子不是长久之计，AGI 特工需要像我们人类一样解释他们做出决定的理由。这是我们需要克服的另一个问题，没有这个问题，AGI 系统就不会存在。
“什么炸弹？”:对抗性攻击
当我们聪明的霸主被愚弄时会发生什么？在上面的图片中，添加少量的随机噪声导致了一个相当有趣的错误分类，尽管一个 5 岁的孩子可以识别这张图片中的熊猫。事实证明，这是我们今天的算法中的另一个重要弱点，未来安全的 AGI 系统应该远离一百万英里。
由其他计算机、人类或仅仅是随机噪声的存在设计的对抗性攻击可能会破坏这项复杂的技术。想象一下，如果你可以在你的口袋/手提箱里放置一枚炸弹，这样它就可以轻易地骗过商场、机场或白宫的人工智能视觉安全系统。这些系统将被部署在任何地方，一个足够先进的 AGI 系统不应该因为人或计算机的操纵而被愚弄。在我们拥有真正的智能代理之前，对抗对抗性攻击的健壮性是一个需要考虑的重要因素。
艾丽莎。治好我的头痛
关于人工智能在医学和生物学方面的贡献，人们已经做出了很多乐观的承诺。许多人认为，只有人工智能代理才能解决癌症、蛋白质折叠、基因组测序和其他解决方案遥不可及的挑战。通常情况下，计算机视觉系统在检测肿瘤和其他异常方面比放射科医生表现得更好。
你的个人助理——未来的 AGI 系统将拥有你的全部病史，将拥有足够的关于你所在地区的医疗疾病的数据，并将推断出你可能容易患的几种疾病。这在今天并不困难，只要有足够的数据和良好的计算能力，现在就可以实现。
未来的 AGI 系统和智能体可能比我们聪明，也可能不比我们聪明，但在任何给定的时间里，他们都会比我们拥有更多的信息和更好的推断技巧。它可以预测流行病的爆发，调动资源，还可以成为你的私人医生。这并不意味着不需要人类医生，但像许多领域一样，医生的工作将变得更加容易。
民主化人工智能
人工智能超越了工程师和科学家。许多公司、初创企业和大学已经认识到了人工智能可能带来的危险，并采取了重大措施去分散人工智能。各国正在制定政策和战略来应对人工智能带来的危险，并在人工智能领域保持领先地位。
需要每个人的贡献。我们需要就我们想把人工智能带向哪个方向进行一次重要的对话。我们如何实现它？万一出了差错，我们如何制造自动防故障系统？我们希望我们的未来是什么样的？这将是一个无休止的推文和 instagram 帖子的循环，还是会提供一些更有前途的东西？
深层网络和浅层关系
在第 1 部分，我探讨了人工智能的未来将带来什么的哲学含义，在这一部分，我提出了一些感兴趣的领域/问题，以及我们需要如何负责任地解决它们，以确保更好、更有意义、更安全的未来，充分利用人工智能。
我以谦卑的自省结束我的发言，这必须是为我们的后代确定我们想要什么的第一步。尽管人工智能创造了所有的炒作——今天和未来，重要的是要意识到它已经在如何影响社会。个性化推荐、即时信息检索、高速数据传输，所有这些都以无人能想到的方式影响着我们。我认为，如果 AGI 系统没有得到负责任的处理，没有适当的道德和安全框架(或者至少是在机器中引入这些东西的方法)，将是灾难性的。但我们最需要担心的不是未来，而是我们对未来考虑的不够。
我们总是在娱乐(在这种气候下不能感到无聊——在我的下一个脸书独家报道中，看我与蚂蚁战斗)，大部分时间都在虚拟平台上生活(Instagram 在我触摸我的食物之前吃东西)，这是 50 年前没有人预测的那种未来。好故事偏见以微妙的方式支配着我们的思维，并对未来给出了乐观的衡量标准，但人工智能技术已经不知不觉地进入了生活的几乎所有领域。批判性地思考它的发展方向是至关重要的，我们是希望一代人生活在虚拟现实耳机和社交媒体中，还是我们已经有了其他的东西？
人工智能已经并将继续解决无数领域的重大问题。但是当我们的网络越来越深时，人际关系变得短暂。重要的是要保持警惕，克服宣传，看看到底发生了什么，清晰地思考，决定我们想要什么，并勇敢地做出潜移默化地影响我们未来的选择。
AI 正在改变我们所有人的世界，现在是我们作为一个物种进行这场对话的时候了，在事情失去控制之前，那个 5 岁的孩子因为你给他看你的猫的照片而感到沮丧，最终成为终结者。世纪剧情转折我说的对吗？
参考
[1]人工智能的伦理——尼克·博斯特伦和埃利泽·尤德科夫斯基
【2】计算机能力和人类理性——约瑟夫·韦岑鲍姆
【3】人工智能:它的本质和未来——玛格丽特·a·博登
批量标准化张量流 Keras 示例
https://www.pexels.com/photo/black-and-silver-laptop-computer-on-round-brown-wooden-table-1181243/
机器学习是一个非常活跃的研究领域，你会经常在图书馆的文档中看到白皮书。在前面的文章中，我们将讨论 Loffe 和 Szegedy 所描述的批处理规范化。如果你是那种喜欢直接从源头获取信息的人，请查看他们白皮书的链接。
[## 批量标准化:通过减少内部协变量转移加速深度网络训练
训练深度神经网络是复杂的，因为每层输入的分布在训练过程中会发生变化
arxiv.org](https://arxiv.org/abs/1502.03167)
批量标准化用于稳定甚至加速学习过程。它通过应用保持平均激活接近 0 和激活标准偏差接近 1 的变换来做到这一点。
反向传播
在高层次上，反向传播修改权重以降低成本函数值。然而，在我们能够理解批处理规范化背后的推理之前，我们必须掌握反向传播背后的实际数学原理。
为了使问题更简单，我们将假设我们有一个由两层组成的神经网络，每层有一个神经元。
我们可以使用以下公式来表示每个神经元的输出:
其中:
- L =神经网络中的层
- w =来自神经元的输出边缘所乘以的权重
- a =前一层神经元的输出(输入边缘的值)
- σ =激活函数
- b =偏置神经元的输出(输入边缘的值)
成本函数的典型例子是均方误差。对于单个样本，我们从预测值中减去实际值(即 y ),并对结果进行平方，以说明预测值大于或小于实际值的情况。
如前所述，我们修改权重以最小化成本函数。如果我们将成本与个体体重相关联，成本将在抛物线底部最低。
利用微积分中的链式法则，我们可以得到代价函数相对于权重的偏导数。
每一项的偏导数可以表示如下。
注意我们如何使用激活函数的导数。
如果我们使用 sigmoid 函数作为我们的激活函数，那么，如果 z (激活函数之前的神经元输出)非常大或非常小，导数将近似为 0。因此，当我们计算梯度并更新权重时，变化会非常小，以至于模型不会改进。后者被称为消失梯度 t 问题。
在神经元进入激活函数之前对其输出进行归一化，我们可以确保其保持接近于导数最高的 0。
正常化
自然界中的随机过程倾向于遵循一个钟形曲线，称为正态分布。
平均值是所有数据点的总和除以总点数。增大平均值会将钟形曲线的中心向右移动，减小平均值会将钟形曲线的中心向左移动。另一方面，标准差(方差的平方根)描述了样本与平均值的差异程度。增加标准差会使曲线变宽。
为了使数据标准化，我们减去平均值并除以标准差。
无论我们正在处理的数据是什么，归一化后，平均值将等于 0，标准差将等于 1。
注意:这等同于说它确保方差等于 1，因为标准差等于方差的平方根。
批量标准化
假设我们建立了一个神经网络，目标是对灰度图像进行分类。灰度图像中每个像素的亮度从 0 到 255 不等。在进入神经网络之前，每个图像都将被转换成一维数组。然后，每个像素从输入层进入一个神经元。如果将每个神经元的输出传递给一个 sigmoid 函数，那么除 0 之外的每个值(即 1 到 255)都将减少到接近 1 的数字。因此，通常在训练之前对每个图像的像素值进行归一化。另一方面，批处理规范化用于将规范化应用于隐藏层的输出。
密码
让我们看看如何在 Python 中实现批处理规范化。
import matplotlib.pyplot as plt
import matplotlib.image as mpimg
plt.style.use('dark_background')from keras.models import Sequential
from keras.preprocessing.image import ImageDataGenerator
from keras.layers import BatchNormalization
from keras.layers import Conv2D, MaxPooling2D, Dense, Flatten
from keras.datasets import cifar10
from keras.utils import normalize, to_categorical
cifar10 数据集由 60，000 张 32×32 像素的图像组成，分为 10 类。下面列出了这些类及其相关的标准整数值。
- 0:飞机
- 1:汽车
- 2:鸟
- 3:猫
- 4:鹿
- 5:狗
- 6:青蛙
- 7:马
- 8:船
- 9:卡车
在训练我们的模型之前，我们基于上面列出的相同原因对输入进行标准化，并对标签进行编码。
(X_train, y_train), (X_test, y_test) = cifar10.load_data()X_train = normalize(X_train, axis=1)
X_test = normalize(X_test, axis=1)
y_train = to_categorical(y_train)
y_test = to_categorical(y_test)
为了提高我们的模型的概括能力，我们将随机移动，翻转和放大/缩小图像。
train_datagen = ImageDataGenerator(
shear_range = 0.2,
zoom_range = 0.2,
horizontal_flip = True
)train_datagen.fit(X_train)train_generator = train_datagen.flow(
X_train,
y_train,
batch_size = 32
)
我们使用下面的等式来设置步数，但是我们也可以使用任意值。
steps = int(X_train.shape[0] / 64)
我们定义一个函数来建立模型，使用和不使用批量标准化以及我们选择的激活函数。
def build_model(batch_normalization, activation):
model = Sequential()
model.add(Conv2D(32, 3, activation = activation, padding = 'same', input_shape = (32, 32, 3)))
if batch_normalization: model.add(BatchNormalization())
model.add(Conv2D(32, 3, activation = activation, padding = 'same', kernel_initializer = 'he_uniform'))
if batch_normalization: model.add(BatchNormalization())
model.add(MaxPooling2D())
model.add(Conv2D(64, 3, activation = activation, padding = 'same', kernel_initializer = 'he_uniform'))
if batch_normalization: model.add(BatchNormalization())
model.add(Conv2D(64, 3, activation = activation, padding = 'same', kernel_initializer = 'he_uniform'))
if batch_normalization: model.add(BatchNormalization())
model.add(MaxPooling2D())
model.add(Flatten())
model.add(Dense(128, activation = activation, kernel_initializer = 'he_uniform'))
model.add(Dense(10, activation = 'softmax'))return model
为了突出使用批处理规范化的好处，我们将训练并比较使用批处理规范化的模型和不使用批处理规范化的模型的性能。
sig_model = build_model(batch_normalization = False, activation = 'sigmoid')
我们使用 rmsprop 作为优化器，使用分类交叉熵作为损失函数，因为我们试图预测类。
sig_model.compile(
optimizer = 'rmsprop',
loss = 'categorical_crossentropy',
metrics = ['accuracy']
)
接下来，我们训练我们的模型。
sig_history = sig_model.fit_generator(
train_generator,
steps_per_epoch = steps,
epochs = 10,
validation_data = (X_test, y_test)
)
我们可以通过使用由拟合函数返回的历史变量来绘制每个时期的训练和验证准确度和损失。
loss = sig_history.history['loss']
val_loss = sig_history.history['val_loss']
epochs = range(1, len(loss) + 1)
plt.plot(epochs, loss, 'y', label='Training loss')
plt.plot(epochs, val_loss, 'r', label='Validation loss')
plt.title('Training and validation loss')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.legend()
plt.show()
acc = sig_history.history['acc']
val_acc = sig_history.history['val_acc']
plt.plot(epochs, acc, 'y', label='Training acc')
plt.plot(epochs, val_acc, 'r', label='Validation acc')
plt.title('Training and validation accuracy')
plt.xlabel('Epochs')
plt.ylabel('Accuracy')
plt.legend()
plt.show()
接下来，我们采取与之前相同的步骤，只是这次我们应用了批处理规范化。
sig_norm_model = build_model(batch_normalization = True, activation = 'sigmoid')sig_norm_model.compile(
optimizer = 'rmsprop',
loss = 'categorical_crossentropy',
metrics = ['accuracy']
)sig_norm_history = sig_norm_model.fit_generator(
train_generator,
steps_per_epoch = steps,
epochs = 10,
validation_data = (X_test, y_test)
)
如您所见，训练损失和训练准确度图比没有批量标准化的模型平滑得多，并且获得了明显更好的结果。
loss = sig_norm_history.history['loss']
val_loss = sig_norm_history.history['val_loss']
epochs = range(1, len(loss) + 1)
plt.plot(epochs, loss, 'y', label='Training loss')
plt.plot(epochs, val_loss, 'r', label='Validation loss')
plt.title('Training and validation loss')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.legend()
plt.show()
acc = sig_norm_history.history['acc']
val_acc = sig_norm_history.history['val_acc']
plt.plot(epochs, acc, 'y', label='Training acc')
plt.plot(epochs, val_acc, 'r', label='Validation acc')
plt.title('Training and validation accuracy')
plt.xlabel('Epochs')
plt.ylabel('Accuracy')
plt.legend()
plt.show()
最后的想法
消失梯度问题指的是当我们向下传播到初始层时梯度如何指数下降。因此，初始层的权重和偏差将不能有效地更新。鉴于这些初始图层通常对识别输入数据的核心元素至关重要，因此可能会导致准确性较差。
最简单的解决方案是使用另一个激活函数，比如 ReLU。否则，我们可以使用批处理规范化来减轻问题，方法是规范化输入，使其保持在金发区。
对害怕数学的人进行反向传播
反向传播是机器学习中最重要的概念之一。有许多在线资源解释了这种算法背后的直觉(在我看来，其中最好的是斯坦福 cs231n 视频讲座中的反向传播讲座)。另一个非常好的来源，是这个，但是从直觉到实践，可能(委婉地说)很有挑战性。
我承认，花了更多的时间，试图让我的层和重量的所有尺寸都适合，不断忘记什么是什么，什么连接在哪里，我坐下来，画了一些图表来说明整个过程。就当是可视化伪代码吧。
挑战:从直觉到实践
所以，假设你对算法应该做什么有很好的直觉理解，但在让它工作时有困难，这篇文章是为你写的！
现在，要明确的是，这篇文章不会试图解释直觉部分。正如我之前所写的，有很多好的、可靠的资源可以做到这一点。这是一个简单的(算法允许的最简单的)…)帮助您让代码工作的实用指南。事实上，如果你没有任何直觉地遵循这些步骤，你的代码可能会工作。尽管如此，我还是强烈建议您阅读一些关于感知器的内容(注意，感知器使用不可微分的步进激活函数，因此您不能真正使用反向传播，但它的结构和权重更新方法确实为更复杂的神经网络奠定了基础)。这是最基本的神经网络，只有一层。在进入更复杂的网络之前，了解如何更新简单网络的权重确实很有帮助。
训练网络时，我们重复以下步骤(对于 n epoches):
- 执行向前传球。
- 通过反向传播计算 W(每个权重的增量)。
- 更新权重。
在这篇文章中，我将重点关注第二步。
准备好了吗？让我们跳进来吧！
-propagating…
破译方程式
下图是任意网络的示意图。因为反向传播的过程基本上每一步都是相同的(取决于您使用的激活功能)。我们只看最后几层(你可以把 L95 层当作输入层，如果这样让你觉得更安全的话。就计算而言没什么区别)。
如您所见，我们的任意网络在第 95 层有 5 个神经元，然后在第 96 层有 2 个神经元，然后在输出层(L100)有 4、3、3 和 1 个神经元。所有层都由权重连接，由线标记(传统上)。
注意每个节点被分成 Z 和 O 。对于每个节点， Z 值是通过将前一层的 O 值乘以连接它们与该节点的权重来计算的。 O 通过在 Z 上应用非线性激活函数获得。现在，下面你会发现可怕的梯度计算。不要害怕！我们将复习每个表达。
当试图更新和优化网络的权重时，我们试图找到-
损失对重量的导数(“重量的变化如何影响损失”)，并使用链式法则，将该任务分成三部分:
损失对下一层的导数。这是从输出层“向上游传递”的损失。或者换句话说，“下一层的变化如何影响损失”。
下一层相对于当前层的导数(可以解释为“当前层的变化如何影响下一层”)，它只是连接到下一层的权重乘以其激活函数的导数。和
-(“权重的变化如何影响当前层”)，它是前一层的 O 值乘以当前层的激活函数导数。
为了使事情更清楚，我写了实际的计算，用颜色编码到我们的网络中，用于我们网络的最后两层，L100 和 L99。
请注意，与每个计算相关的导数项出现在它的下方。与损耗相关的两个导数(以红色显示)非常重要，因为它们用于前面各层的计算。这在下图中可以清楚地看到:
注意∂Loss 是如何向下传播的。看着这个模式，你应该开始明白如何在代码中实现它。还要注意，我强调了最后两层，它们构成了前面提到的感知器。
注意，我没有提到在这个图中将整个表达式乘以学习率(α)，因为它看起来太拥挤了，并且遮蔽了带回家的消息，这是链规则的应用。您应该尝试不同的α值，以获得最佳性能。无论如何，α确实出现在下一张图中。
通过一批实例反向传播
需要注意的重要一点是，我们看到的示意图中的每一层实际上都是一个矢量，代表为一个单个实例所做的计算。通常我们会将一批实例输入到网络中。看了下一张图后，这一点会更清楚，图中显示了对一批 n 实例的计算。请注意，这是完全相同的网络(L95 层有 5 个神经元，L96 层有 2 个神经元，依此类推……)，只是我们现在看到的是 n 个实例，而不是一个。
对我来说，当实现反向传播时，最具挑战性的部分是获得不同层的大小、权重和梯度矩阵。这幅插图旨在整理事物。
在顶部，你会看到示意网络。 n 的实际大小没有影响(用于计算。显然，这在更大的范围内会有所不同…)，因为你会注意到，当我们在反向传播时执行矩阵乘法时，我们总是对 n 求和。也就是说，矩阵相乘时 n 的长度是“丢失”的。这正是我们想要的，对我们批次中所有实例的损失求和。
图表的其余部分分为两个部分:
- 向前传球。
- 反向传播。
向前传球对你们大多数人来说应该很明显。如果不是，我建议在继续学习之前先阅读一下矩阵乘法。我要指出的一件事是，每个权重矩阵取一个大小为 (n，k) 的层，输出一个大小为 (n，j) 的层。这种权重矩阵的大小为 (k，j) 。你可能会注意到这张图缺少了偏差单位。这是因为我想让它尽可能的清晰，并关注不同的矩阵大小如何适应反向传播过程。下面有一小段是关于添加偏置单元的。
反向传播部分是一个“位”更棘手… 😃
该部分图表分为三个子部分:
1。变量
这里我列出了计算的不同元素，最重要的是它们的形状。关于这一部分的几点说明:
- Z 指激活前层的值。
- O 指激活后的层值。
- σ 指激活功能。
- g’ 指激活函数的导数。
请注意，本节对构成的变量进行了分组
和
在顶部(以红色突出显示)，以及那些构成
在底部(用蓝色突出显示)。
2。计算
这是所有戏剧发生的地方。这里其实没有什么新东西。这些都是在前面的图表中看到的完全相同的计算，但是矩阵大小写得很清楚。此外，何时使用元素乘法，何时使用矩阵乘法都有明确的说明(矩阵乘法用@表示，因为这是 Numpy.dot 的简写。您将在下面的代码部分中看到它的作用)，以及何时需要转置矩阵。图表和下面的代码假设了一个平方损失函数。其导数定义为output - labels。
3.重量更新
剩下的就是通过向每个权重矩阵添加 w 来更新我们的权重。请注意，我们只在完成反向传播后才执行更新。
密码
关于此部分的一些注意事项:
- 出于可读性的目的，这里给出的代码是伪代码。
- 由于这篇文章旨在用作实践指南，我鼓励你仔细阅读图表，并在查看代码示例之前，尝试编写自己的T4 实现。这些图包含了你自己成功构建它所需要的所有信息。查看图表，了解渐变是如何从一层传递到下一层的。确保你明白什么是乘什么，什么轴是求和的。看看我们如何在每次迭代中获得适合我们层的权重的形状 W 矩阵。****
- 网上有很多解决方案。我强烈推荐这本书，因为它很容易理解。我自己的实现很大程度上基于它。
- 代码假设使用 sigmoid 激活函数。由于 sigmoid 函数(
σ(z) *(1-σ(z)))的导数只需要 O 的值(当然是σ(z)) ，所以我们不需要激活( Z )前神经元的值。对于使用不同激活功能的实施，在进行正向传递时，您需要保存 Z 值。
使用循环
使用递归
添加偏置单元
您可能已经注意到，之前的图表缺少偏置单位。我选择从这些图中去掉偏差，因为我想让它们尽可能简单和直观，但是你绝对应该考虑添加它！
您可以为每个层“手动”添加一个偏差，然后计算该偏差的损失导数:
我们已经知道如何计算
，以及
只是当前层的激活函数导数。
您还可以将偏差添加到权重矩阵中。这基本上意味着在每一层添加一个偏向神经元的向量(一个 1 的向量)，并相应地初始化权重矩阵形状(就像在简单的线性回归中一样)。不过要记住的一件事是，偏置单元本身永远不应该在正向传递中更新，因为它们连接到下一个层的神经元，而不是前一个层的神经元(见图)。
一种方法是避免更新这些神经元，但这可能会变得很棘手，尤其是在向后传递中(完全公开，这就是我所做的，我不建议这样做……)。一个更简单的解决方案是正常进行正向和反向传递，但在每次层更新后将偏置神经元重新初始化为 1。
一些有用的提示
- 反向传播时不要更新权重！！请记住，下一次迭代(前一层)将需要这些(未更新的)权重来计算损失。您可以保存 w，并在反向传播部分的末尾更新权重(就像我在代码示例中所做的那样)，或者不断更新前面两层的权重，在我看来，这是令人困惑的，而且过于复杂。
- 如果层不是由非线性函数激活的(例如输出层)，则梯度仅为 1。
- 你的程序没有崩溃，并不意味着它能工作。确保你的网络收敛，减少损失。
- 事实上，你的网络收敛，你的损失减少，并不意味着它的工作最佳。将您的结果与其他实现进行比较。研究学习速度和网络结构。
- 尝试不同的权重初始化方法。这会对性能产生巨大的影响。
摘要
反向传播可能是一个棘手的问题，但是如果你希望很好地理解神经网络是如何工作的，你应该避免在自己实现一个简单的网络之前跳入更高级的解决方案，如 TensorFlow 或 Pytorch 。这是所有深度学习的基础，也是成功处理更复杂网络的关键。也很好玩(起作用的时候)。
祝你好运！
卷积层中的反向传播
Backpropagation in a convolutional layer
介绍
动机
这篇文章的目的是详细说明梯度反向传播是如何在神经网络的卷积层中工作的。典型地，该层的输出将是所选激活功能的输入(例如relu)。我们假设给定了从该激活函数反向传播的梯度dy。因为我无法在网上找到一个完整的，详细的，和“简单”的解释它是如何工作的。我决定做数学，试图在归纳之前一步一步地理解简单的例子是如何工作的。在进一步阅读之前，你应该熟悉神经网络，尤其是计算图形中梯度的前向传递、后向传播和带有张量的基本线性代数。
Convolution layer — Forward pass & BP
记号
*在神经网络的情况下是指 2 个张量的卷积(一个输入x和一个滤波器w)。
- 当
x和w为矩阵时: - 如果
x和w共享相同的形状，x*w将是一个标量，等于数组之间的元素级乘法结果之和。 - 如果
w小于x，我们将获得一个激活图y，其中每个值是 x 的一个子区域与 w 的大小的预定义卷积运算。由滤波器激活的这个子区域在输入阵列x上滑动。 - 如果
x和w有 2 个以上的维度，我们考虑将后 3 个维度用于卷积，后 2 个维度用于高亮显示的滑动区域(我们只是给矩阵增加了一个深度)
符号和变量与斯坦福优秀课程中关于视觉识别的卷积神经网络中使用的符号和变量相同，尤其是作业 2 中的符号和变量。关于卷积层和前向传递的细节将在这个视频和前向传递帖子的一个简单实现的实例中找到。
Convolution layer notations
目标
我们的目标是找出梯度是如何在卷积层中向后传播的。向前传球是这样定义的:
输入由 N 个数据点组成，每个数据点有 C 个通道，高 H，宽 w，我们用 F 个不同的滤波器对每个输入进行卷积，其中每个滤波器跨越所有 C 个通道，高 HH，宽 WW。
输入:
- x:形状(N，C，H，W)的输入数据
- w:形状的过滤器权重(F，C，HH，WW)
- b:形状为(F，)的偏差
- conv _ 参数:带有以下键的字典:
- “步幅”:水平和垂直方向上相邻感受野之间的像素数。
- ’ pad ':将用于对输入进行零填充的像素数。
在填充过程中，“填充”零应沿着输入的高度和宽度轴对称放置(即两边相等)。
返回一个元组:
- out:形状为(N，F，H’，W’)的输出数据，其中 H’和 W’由下式给出
H’ = 1 + (H + 2 * pad — HH) /步幅
W’ = 1 + (W + 2 * pad — WW) /步幅
- 缓存:(x，w，b，conv 参数)
前进传球
一般情况(简化为 N=1，C=1，F=1)
N=1 个输入，C=1 个通道，F=1 个滤波器。
Convolution 2D
x:H×W
x′=带填充的 x
W:hh×WW
b 偏移:标量
y:H′×W′
步幅 s
具体情况:stride=1，pad=0，无偏差。
反向传播
我们知道:
我们要计算成本函数 l 的偏导数 dx 、 dw 和 db ，我们假设这个函数的梯度已经反向传播到 y。
平凡的例子:输入 x 是一个向量(一维)
我们正在寻找一种直觉，它是如何在一个简单的设置上工作的，稍后我们将尝试概括。
投入
输出
前向通过—与一个滤波器卷积，步长= 1，填充= 0
反向传播
我们知道成本函数 L 相对于 y 的梯度:
这可以用雅可比符号来表示:
dy 和 y 具有相同的形状:
我们正在寻找
使用链式法则和正向传递公式(1)，我们可以写出:
发展的宽度（Developed Width 的缩写）
我们可以注意到，dw 是输入 x 与滤波器 dy 的卷积。让我们看看它在增加了一个维度后是否仍然有效。
高级的（deluxe 的简写）
再一次，我们有一个卷积。这次有点复杂。我们应该考虑一个输入 dy，其大小为 1 的 0 填充与一个“反向”滤波器 w 卷积，如( w 2， w 1)
下一步将是看看它如何在小矩阵上工作。
输入 x 是一个矩阵(二维)
投入
输出
我们将再次选择最简单的情况:stride = 1 并且没有填充。y 的形状将是(3，3)
向前传球
我们将拥有:
用下标写的:
反向传播
我们知道:
使用爱因斯坦约定来简化公式(当一个指数变量在乘法中出现两次时，它意味着该指数的所有值的总和)
对 I 和 j 求和，我们得到:
发展的宽度（Developed Width 的缩写）
我们正在寻找
使用公式(4 ),我们得到:
所有术语
除了( k ， l )=( m ， n )为 1 的情况，double sum 中只出现一次。因此:
使用公式(3 ),我们现在有:
如果我们将该等式与给出卷积结果的公式(1)进行比较，我们可以区分类似的模式，其中 dy 是应用于输入 x 的滤波器。
高级的（deluxe 的简写）
使用我们对(5)所做的链式法则，我们有:
这一次，我们要寻找
使用等式(4):
我们现在有:
在我们的示例中，索引的范围集是:
当我们设置k=m-I+1 时，我们将超出定义的边界:(m-I+1)∈[1，4]
为了保持上述公式的可信度，一旦指数超出定义的范围，我们选择用 0 值扩展矩阵 w 的定义。
在二重和中，我们只有一次 x 的偏导数等于 1。所以:
其中 w 是我们的 0 扩展初始滤波器，因此:
让我们用几个选定的指数值来形象化它。
使用∫符号进行卷积，我们得到:
由于 dy 保持不变，我们将只查看 dx 22 的 w .的索引值，范围为 w:3-I，3-j
现在我们有了 dy 和 w’矩阵之间的卷积，定义如下:
另一个例子来看看发生了什么。 dx 43，w:4—I，3—j
最后一个 dx 44
我们确实看到弹出一个“反向过滤器”w’。这一次，我们在具有大小为 1 的 0 填充边界的输入 dy 和步长为 1 的滤波器 w’slidding 之间进行卷积。
反投影方程综述
考虑到深度
当我们试图考虑深度时，事情变得稍微复杂一些(C 通道用于输入 x，F 不同的过滤器用于输入 w)
输入:
- x:形状(C，H，W)
- w:过滤器的权重形状(F，C，HH，WW)
- 形状(F，)
产出:
- y:形状(F，H '，W ')
数学公式中出现了许多指数，使得它们更难阅读。我们示例中的正向传递公式是:
db 计算仍然很容易，因为每个 b_f 都与一个激活图 y_f 相关:
发展的宽度（Developed Width 的缩写）
使用向前传递公式，由于双和不使用 dy 索引，我们可以写为:
算法
既然我们对它是如何工作的有了直觉，我们选择不写整个方程组(这可能是相当乏味的)，但是我们将使用已经为正向传递编码的内容，并且通过玩维度来尝试为每个梯度编码反向投影。幸运的是，我们可以计算梯度的数值来检查我们的实现。这种实现只对步幅=1 有效，对于不同步幅，事情变得稍微复杂一些，需要另一种方法。也许是为了另一个职位！
梯度数值检验
Testing conv_backward_naive function
dx error: 7.489787768926947e-09
dw error: 1.381022780971562e-10
db error: 1.1299800330640326e-10
几乎每次都是 0，一切似乎都很好！😃
参考
欢迎评论改进本帖，随时联系我！
简单来说就是反向传播
随着我对神经网络(NN)的了解，我努力理解反向传播在做什么以及为什么它有意义。这篇文章是神经网络揭秘故事的后续。所以，如果你不知道什么是梯度下降，什么是正向传播，我建议你去查一下。
为什么我们关心反向传播？
我们关心反向传播，因为这是神经网络学习的方式！具体来说，这就是我们如何更新神经网络 w 和 b 的权重:
Rule for updating weights
α 是某个被称为学习率的正实数，它表示 w 和 b 的更新幅度，而 dw、db 分别是成本函数相对于 w 和 b 的斜率。
为什么有效？
为了建立我们的直觉，假设我们想要找到绝对值函数的最小值:
Absolute value function
对于那些微积分新手来说，为了找到一个函数在给定点的斜率，只要问自己:响应于 x 的变化， f(x) 变化了多少？注意，对于所有小于零的 x 值，斜率为 -1 ，对于所有大于零的 x 值，斜率为 +1 ，当 x 为零时，斜率未定义。思考一下更新 x 的值以最小化 f(x) = |x| 的规则。保持这种想法，现在让我们使用反向传播中使用的相同更新规则来更新 x :
根据反向传播更新规则，如果 x 为负(即 x + α )，我们希望将 x 向右移动；如果 x 为正(即 x — α )，我们希望将 x 向左移动。希望这也是你自己想出的最小化 f(x) 的策略！
我们到底是怎么计算 dw 和 db 的？
假设我们有一个用于分类的简单 NN，只有一个隐藏层，我们的模型成本函数是每个训练示例的平均损失，我们的损失函数是用于逻辑回归的损失函数:
Cost and Loss functions
其中 yʲ 是 jᵗʰ 例子的观测值， aʲ 是我们的 NN 为 jᵗʰ 例子产生的输出。此外，我们模型的输出是 sigmoid 函数的结果，sigmoid 函数使用输入要素与权重的线性组合:
Activation (sigmoid) and linear combination functions
最终，我们想要的是成本函数相对于权重的斜率，因为权重是我们唯一可以改变以最小化成本的东西。用数学术语来说，我们可以把它表达为:
Slope of the cost function with regards to the weights and the intercept
同时计算 dw 和 db 可能会令人望而生畏，因此我们将使用一种众所周知的技术，称为链式法则。
什么是链式法则，在 NNs 中是如何使用的？
一个例子可以清楚地说明这一点:假设我们有一些初始值、中间值和最终值，我们想通过只改变 w₁和 w₂来最小化 l
Example set-up
首先我们需要分别计算出 L 相对于 w₁ 和w₂的斜率，从而找到 dw₁ 和 dw₂ 。然后，我们可以将反向传播更新规则应用于 w₁ 和 w₂ 。只看这个例子，我们知道 w₁ 每改变一个单位， L 就会改变 2.5 个单位。同样， w₂ 每改变一个单位， L 将改变 1 个单位。如果你不相信我，试着自己做出改变。事实证明，同样的计算可以表示为中间偏导数的乘法:
Chain rule
所以现在，回到 NN 的，我们可以将 dw 和 db 表示为导致 w 和 b 的偏导数的乘积:
Chain rule in NN’s
最后，我们可以计算每一项，并用链式法则将它们相乘，得到 dw 和 db 。我知道每一项的实际解看起来很难看，但至少比试图做一次大规模求导要好(如果你有兴趣看每一项的求导，请向下滚动)。
希望这篇文章有助于驱散有时围绕反向传播的迷雾。请记住，我们所做的一切都是应用链式法则来计算我们应该如何更新我们的权重，这是神经网络学习过程的核心。
Derivation of each of the partial derivatives
反向传播超级简化！
Photo by Robina Weermeijer on Unsplash
我不会说反向传播是一个非常简单的算法。如果你不知道微积分，线性代数，矩阵乘法，这可能是非常令人生畏的。即使你知道一些或全部，要掌握它也需要一点脑力锻炼。
我这么说并不是要打击你的积极性，让你避免学习它(是的，你可以避免它，但仍然可以继续你的深度学习之旅)。它有点复杂，但我不会说它超级难，而是非常直观和容易掌握。你会惊奇地发现，与它所解决的问题相比，它是多么简单。它实际上是深层神经网络的主干。所需的概念非常容易学习，而可汗学院是实现这一目的的绝佳资源。我已经列出了所需数学概念的 URL，你可以在阅读帖子之前回顾一下。
1.链式法则
2.梯度下降
3.矩阵
关于反向传播算法的背景知识已经讲得够多了，我们现在开始吧。当我刚开始学习反向传播算法时，我发现节点的表示和权重非常令人困惑，而不是算法本身。所以，我会尽量让它变得简单。让我们从一个非常简单的神经网络开始。
简单神经网络
正向输送
在这个神经网络中，我们将计算每一层的值。
输入:
x = z = a
H1 图层:
z = w x + b = w a + b
a = f(z ) = f(w a + b )
H2 层:
z = w a + b
a = f(z ) = f(w a + b )
输出:
z⁴ = w a
o =f(z⁴)= f(w a)= f(w(f(w(f(w(w a+b)+b))))
这被称为前馈传播。我们必须一次又一次地这样做，通过改变我们的权重和偏好来接近我们想要的输出。
梯度下降和反向传播
但是，问题是如何改变权重。这就是这个算法的配方。为此，我们需要使用梯度下降，并向后传播(因此得名反向传播算法)，并根据需要改变权重。
回想一下，我们的期望输出是 y ，当前输出是 o. 为了评估我们预测中的差异，我们引入了成本函数，也称为 l oss 函数。它可以像 MSE (均方误差)一样简单，也可以像交叉熵函数一样简单。在这里，我们称之为 C，所以，我们的成本函数将是 C(o，y) 。
现在我们有了函数形式的差异。我们可以引入微积分来玩玩。我们需要一些函数来帮助我们减少预测值和实际产量之间的差异，我们已经以成本函数的形式量化了这种差异。这就是我们需要梯度下降算法的地方，梯度下降算法是通过不断向最陡下降的方向移动来最小化一个函数，最陡下降的方向等于梯度的负值。
让我们更深入地研究这种梯度下降。一个函数的梯度意味着，一个函数相对于一个特定量的变化而变化多少。它是通过对特定量取函数的偏导数来计算的。在这种情况下，我们希望看到我们的成本函数相对于我们的权重和偏差的变化有多少变化，从而给出如何改变权重以在我们的预测中获得最小可能误差的想法。
回到我们的例子:
由于， C 是 *o 中的函数，*又是 w_1 中的函数，我们可以利用链式法则得到上面的偏导数。
*记住，*o =f(z⁴)= f(w a)= f(w(f(w(w(w a+b)+b))))
(同理，我们可以计算出 C w.r.t 其他权重的梯度。)
这里，我们需要注意几件事:
术语 ∂C/∂w^n 也被称为局部梯度。
类似地，对于偏差:
好了，现在是时候收获我们辛勤工作的果实了。我们已经准备好必须改变权重的量，即 w_n。因此，要修改我们的权重和偏差，我们需要:
在这里，我们介绍了 ϵ 对渐变下降的影响。现在，该模型使用新的权重和偏差进行前向传播，然后一次又一次地反向传播。它继续下去，直到根据我们的约束最小化我们的成本函数到尽可能低的值。
小型复杂神经网络
此刻，你一定觉得很不完整，因为你可能会说这个模型非常简单，一旦层中有很多节点，事情就会变得非常复杂。
不完全是。事情依然如故，强硬程度依然如故。你现在要做的就是让自己熟悉编写复杂的指数和我们良好的 ole sigma(≘)符号。记住这一点，我们将再次检查表达式，但对于下面的神经网络，你会同意是相当复杂的。
在这里要小心，这不是直觉的东西，你必须习惯它。再次概括一下，我们有:
记住这一点，我们将尝试重新编写我们之前的表达式，但我将从第一层中选取一个特定的权重进行演示，然后我们将对其进行推广。
Value of z for node 3 in layer 2
对任意层中任意节点的 z 值进行概化，我们得到:
Generalized for of the value of z for any node in layer L
因此，相应的激活函数将是:
Generalized value of a for node j of layer L.
输出层:
在我们的例子中，oT7是输出:
现在，对我们的成本函数 C(o，y) 应用梯度下降，我们得到:
看看上面的表达式，这基本上是这个算法最复杂的部分。试着理解它是什么。我们将以类似的方式概括成本相对于所有其他权重的梯度。前面的表达式什么也没做，只是在向后传播时考虑了特定层的所有节点。我们如何做到这一点，非常简单，就是在我们试图改变的权重之前，将所有层的所有节点的所有计算相加。
概括起来，我们可以写:
然后，权重更新以与我们之前完全相同的方式完成:
拍拍自己，你做到了深度学习最重要的算法之一——反向传播算法的终点。如果你理解了这个算法，你现在可以更深入地挖掘，可以很容易地得到像消失渐变和更多的概念。
如果你对这篇文章有任何问题或编辑，请在评论区留下回复，我会回复的。
另外，请继续关注许多这样的深度学习算法和编码练习。
回溯测试交易策略:少施魔法，多统计数据
在这篇文章中，我将回顾为什么在定义交易策略时需要回溯测试，我将提供一个回溯测试设置的实际例子，包括工具和步骤，我稍后将描述哪些是关键的统计参数/数字，将引导我们得出有意义的结论。这些数字对盈利能力和风险管理的影响将被详细讨论。
正如将要展示的，简单的统计数据和指标可以以半自动的方式应用，以提供高质量的洞察力，即使是在传统上不太容易进行统计备份的全权委托交易中。
回溯测试不仅仅属于自动交易
一些分析师已经表示，资产的平均持有时间低至 22 秒。这一数字来自 2012 年的研究，可能已经被认为是过时的。
这一数字可能会产生误导，因为不同的参与者在不同的时间框架内运作，其中一些人持有资产的时间为几秒或几毫秒，而另一些人持有资产的时间为几年。
无论如何，可以合理地说，自动交易(高频、算法、量化或人工智能)的数量正在增长，而自主交易的数量正在减少或失去相关性。
这一趋势可以从大型投资机构的交易大厅和 pits⁴得到证实，它们现在要么完全解散，要么在边缘水平上运作。
这种趋势也可以在零售交易中发现。这种方法通常不同于专业交易公司使用的方法。最新的倾向于更多地依赖于统计、因子分解、回归模型、神经网络和基于覆盖率、对差价和网络中立性的策略，而零售商进行的大多数自动化交易是使用基本的基于指标的策略的简单定向交易，通常在不同的市场条件下表现不佳。
在这种背景下，似乎可自由支配的交易日屈指可数，零售注定要失败。虽然对大多数人来说这是事实(CFD 经纪公司的财务数据显示，他们每年需要吸纳大量新客户，因为他们的大多数现有客户在交易的第一个月内就失去了所有的钱)，但我发现有些人通过自主交易获得了极高的利润。他们的成果可能无法被大型资本复制，但他们足以提供一份富裕且利润丰厚的工作，甚至可以经营小型基金或投资俱乐部。
与任何其他职业一样，成功取决于一系列因素，包括态度、能力、培训、教育、指导、经验、学习、承诺、错误和时间。大多数零售商失败了，这是事实，但也是事实，他们中的大多数没有遵循必要的道路，成为一个成功的交易者。
回溯测试对于交易就像模拟/训练对于其他领域一样
在我快 30 岁的时候，当我试图成为一名空中交通管制员时，我有一个短暂的机会去了解航空业。从我生活的那个时期，我得到了一些关于世界上最安全的行业的信息，我今天仍然觉得很有用。
在航空业，没有什么是允许即兴创作的。培训——包括模拟——是所有角色工作中不可或缺的一部分。不管你是飞行员、空中交通管制员还是飞行助手。行业中的每个人都遵循程序并接受适当的培训，包括模拟正常和异常情况。
清单、交叉检查和程序是规范，航空事故和未能遵循这些程序和清单之间存在关联。这种方法可以推广到其他行业，在这些行业中没有对培训和模拟的强烈关注。
“没有数千小时的飞行经验和适当的飞行模拟时间，谁会想驾驶一架 747？”
模拟是训练中的一个关键因素。它允许暴露在不利和紧张的条件下而不受伤害，并培养了遵循程序和根据计划作出决定所需的能力。
在交易中获得准确的模拟实际上很容易，这是通过回溯测试实现的。
自主交易中回溯测试的好处
正如本文前面提到的，回溯测试需要成为任何策略不可或缺的一步。放弃这一点只会花钱，甚至会在几天内毁掉一个交易账户，如果你喜欢杠杆的话，也可以是几个小时。
虽然许多人将回溯测试与自动交易联系在一起(回溯测试很容易编程，因此是交易过程的一个自然部分)，但很少有人将回溯测试与技术分析或价格行为自主交易联系在一起。
回溯的好处是:
- 它能够充分理解方法/策略，发现仅仅描述策略无法涵盖的问题。
- 它给你带来了现实的期望，它将清楚地表明市场是如何完全被设计来消灭小玩家的帐户。
- 它允许您根据特定的资产/工具调整策略。
- 它有助于确定可能影响盈利能力的过滤条件。
- 它对我们正确执行该战略的技能和能力进行了现实的评估。
- 它提供真实世界的统计数据，这些数据将导致对盈利能力、支出、风险和所需资本的现实和详细的预期。
虽然这不是火箭科学，我也没有发现任何新的东西，但是回溯测试并不总是被认真对待。很多时候，它被放弃，代之以模拟账户交易，执行不力或没有适当的承诺。
做回溯测试需要什么工具和资源？
所需的基本工具有:
- 您想要交易的资产/工具的优质历史数据。
- 模拟软件包。
- 策略的完整定义(可以是一个迭代过程，因为第一轮模拟可能会导致策略的微调或定义进一步的条件)。
- 质量时间(几天)来完成回溯测试，直到至少数百(理想情况下大于 1000)的交易已经完成。
- 对回溯测试进行广泛的分析，重新访问已执行的交易，并尝试确定是否有任何相关因素或情景可以将交易损失降至最低。
所有项目都是不言自明的，尽管我们将在下面的段落中更详细地介绍前两个项目。
历史数据是个问题吗？
数据不再那么难找了。当然，如果你的策略在时间框架方面很激进，你希望根据一分钟蜡烛线的变化实时做出决策，或者你的策略使用分笔成交图，那么数据会很昂贵。但是，即使在这些情况下，这些策略中的一些也可以用 1 分钟蜡烛来近似，获得/购买要便宜得多。
数据的重要事实是，你需要明白你的时间框架和策略将决定你需要多少数据。
如果你在测试一个日内策略，几年后，可能 1 分钟蜡烛线(即使 5 分钟也是一个日内策略)将是最小值。无论选择何种数据长度，都应满足以下条件:
- 该策略必须在趋势和非趋势市场条件下进行测试。一种策略可能在持续的牛市中有效，但在横向或熊市中效果不佳。
- 该策略应针对不同的市场波动进行测试。
- 你应该计划测试 1000 次操作。也可以是数百个，但越大越好。
模拟软件:一种负担得起的有价值的辅助工具
对于手动回测，我使用外汇测试。这是一个便宜的工具，它有一个永久许可模式，而且使用起来非常简单。它支持分笔成交点和分钟数据。
这是我测试过的唯一一个手工回溯测试工具，但是我确信还有其他工具完全可以完成这项工作。重要的一点是，你需要用实际的市场历史数据来复制市场的东西。
Backtesting software Forex Tester with a classic intraday Triple Screen configuration. In this particular setup a 1 minute intraday strategy is being tested using daily, 15 minutes and 1 minute charts of the FDAX symbol. The multiple screen setup mimics a live market setup where you can monitor scenario for different timeframes.
应特别注意尺度(我个人尝试修正网格尺度，以便您可以对特定资产/工具的行为有更好的启发性理解)。
模板应该总是相同的，你可以使用任何有助于你的指标，虽然许多价格行动交易者忽视指标，但我个人认为它们是很好的确认工具，我倾向于使用标准的 14 周期 rs I 和古老的 Connors 2 周期 RSI，但这只是个人偏好。
如果数据来自受监管的流动性市场，交易量总是相关的，超过柜台交易量，如在 CFD 经纪人上发现的交易量可能会产生误导。
模拟软件将允许市场向前或向后移动，自动或只需按一个键。从一个时间框架转换到另一个时间框架很容易，当市场在一个与你的策略不相关的区域波动时，你可以快速前进。
“模拟/回溯测试软件的主要好处是，你可以在几天内测试数百或数千笔交易。同样数量的信息在常规交易或演示交易中需要几个月的时间。更不用说交易可以持续数周的摇摆或头寸策略了。”
应该避免分析过去的静态图表。我见过很多次，人们只是使用过去的图表，并根据图表验证策略。人类的大脑非常善于——也很有创造力——发现模式，所以仅仅在过去的图表中发现模式是不够的。需要在图表的右边空出一块地方来感受这个策略，并了解你在这些条件下的表现。
此外，一个常见的错误是避免分析模拟交易——避免分析一般的交易。你可以从盈利或亏损交易中学习，并识别可能导致生成提高盈利能力的过滤器的条件。尝试和事后分析 200 笔交易比测试 1000 笔交易要好。将市场条件与每笔交易相关联并加以注释也很重要，即，希望您用额外的市场条件情况来丰富该工具提供的损益表格数据。这将进一步丰富统计分析，进一步完善战略。
回溯测试的关键统计数据
尽管自主交易的名声更像巫术，而不是科学，但它绝对不是真的。虽然需要一定程度的艺术，但它可以被认为是一种比深奥更具启发性的体验。
全权委托交易的科学部分来自交易规则(即交易计划、设置、市场分析等。)以及我们方法论的统计分析。
必须为回溯测试、演示和实时交易阶段收集统计数据。与你可能认为的相反，不需要做复杂的分析，因为你可以从非常基本的统计数字中获得非常有趣的信息。
Backtesting Statistics
上图显示了该工具提供的统计数据。整个交易细节可以导出到 Excel 中，以进一步分析结果，但即使是这个基本集合也将提供足够的信息来验证或放弃策略。
在本例中，选择的策略涵盖了 2015 年全年，但在撰写本文时，交易仅在第一个月进行(如上所述，没有足够的采样数据来对策略进行有意义的分析)。无论如何，这些信息足以涵盖关键的统计数字以及如何解释这些数字。
总交易/盈利交易/亏损交易(与盈利能力相关)
这是对交易数量的明显统计，详细记录了盈亏情况。从这一基本计数中可以推断出以下信息:
- 你能从该策略中平均预期多少交易，根据应用的资本和风险管理，这将导致从该策略中可预期的净利润。如果我们的策略是每年给你 15 笔交易，而你每笔交易的风险是 100€，你知道你不会从这个策略中获利。此外，每年 15 笔交易的数字一定会让你马上得出结论，它需要进行多年的回溯测试。
- 盈利/亏损比率(也包含在统计报告中)。在这种情况下，我们赢了 69%的时间，输了 31%的时间。请注意，有些盈利策略的胜率低于 50%，这些数据与盈利交易的平均利润和亏损交易的平均亏损相结合，引入了每笔交易的平均盈利能力(APPT)⁵)的概念，这实际上是确定策略是否盈利的基石。
这是每笔交易的平均盈利率的公式，它基本上说明了每笔交易平均赚了多少钱。正数将反映盈利战略，负数将反映非盈利战略:
APPT =(盈利%平均盈利-(亏损%平均亏损)
连续盈利/亏损交易(涉及风险管理和交易心理学)
根据你采取的策略，你将面临或长或短的连续输赢。有些策略比其他策略更容易失败，导致小的损失，这些损失可以通过一些成功的交易来弥补。其他人得到更多的补偿，将呈现出类似数量的输赢条纹长度。
提前知道你能从一个策略中得到多少亏损交易，这对于决定你能得到什么是很重要的。你的账户应该有适当的大小，不仅能承受这个数量的亏损，还能承受更大的亏损。
虽然这只是一个指示性因素(模拟并不能确保未来的可靠性)，但它是一个很好的现实预期指标。在这个特定的测试中，我们最多有 3 笔亏损交易和 6 笔盈利交易。这可以作为一个参考，所以你应该准备至少两倍于这些数字。
预期的连续盈利/亏损交易也会对你的心理产生影响。承受长时间的亏损可能是一个艰难的经历，尤其是当你强调每笔交易的风险资本时。提前知道你可能会期望什么将有助于你应对动荡，它也将有助于发现什么时候事情真正偏离了原来的计划，这样你就可以在为时已晚之前暂停运营。
最大利润交易/最小利润交易(与风险管理相关)
每笔交易的最大利润和最小利润可能会产生误导。实际上，在准备策略的时候，为给定的交易规模做准备是个好建议。在这个特殊的例子中，已经安排了符号统计(杠杆和批量大小),因此损益数字以 FDAX 点给出。也就是说，我们选择了一个批量，所以每个点(赢或输)代表一个€。这使得以后的规模确定操作能够适应我们的风险。这意味着你以后可以根据你的交易账户和风险状况来升级或降级规模。
根据统计数据，我们注意到最大的亏损交易损失了 142.87 个 DAX 点。
这意味着，如果你接受每笔交易 1%的风险(你的交易账户为特定策略配置的风险)，这是交易中常见的风险假设，你可能会为 10.000€交易账户设定 1€/点的风险，因为最差的交易会让你损失 1.4%。
一些人表示，1%的数字必须更新并适应每个操作，这涉及到根据资产/工具当前报价、操作的止损值和您交易账户权益曲线的当前状态(提款或利润)为每个操作计算出一个适当的规模值。对于外汇对，您还需要将外汇对的当前汇率与您交易账户的基础货币进行比较。“路太麻烦了，你不觉得吗？”。
我个人的观点是，你不必对数字要求太严格；保持在一个可接受的亏损数字附近更容易操作，并且允许你操作固定的手数。缩小损失是风险管理的重要部分。您可以按季度或简单地根据权益曲线中期或长期演变来审查规模。这更容易。
请注意，在交易杠杆衍生工具(如期货或差价合约)时，你需要更多地考虑名义价值，而不是实际交易账户。你将被要求分配比你投资的名义价值少得多的钱，但是你仍然应该明白杠杆作用对损失和利润都是重要的。我个人倾向于总是从名义价值的角度来思考。我开始操作股票时，这是我评估操作规模的自然方式，但我遇到过许多只处理杠杆工具的人，他们往往不完全理解名义 value⁶.的概念
还应注意，每笔交易的最大百分比或风险实际上取决于每个人。有很多方法可以确定这个价值，它不仅与你的交易账户有关，还与你的可用资本和财富有关。有些人资本少但财富多，所以他们的资本相对来说没什么用；有些人资本多但财富少，所以保护他们的资本至关重要。你的风险状况也起着重要的作用。
根据你的具体情况，盲目使用 X %规则会导致不均衡的风险。
风险管理的重要一点是要有所准备，并清楚地了解这对你的风险状况、财富和个人状况意味着什么。应采用哪种特定的风险管理取决于每个人。
平均利润/平均损失(与盈利能力相关)
这些数字，加上交易的%盈利/亏损比率，构成了策略的盈利能力，就像之前用 APPT 公式讨论的那样。
请记住，尽管大多数培训课程和书籍都强调需要保持平均盈利/平均亏损的正比率，但这并不是真正需要的，因为相关的是 APPT 符号。尤其重要的是要明白，很多盈利的短线日内和刷单策略都是处理负盈亏比的。这可能与在这种较小的时间框架中发现的噪音有关，这使得处理短期动量和较高的交易%盈亏比比处理正的平均盈亏比更可取。
最大提款(与风险管理和心理学相关)
最大提款模拟您的交易账户在回溯测试期间经历的最大损失。虽然这个值不能保证什么，但它可以让您知道会发生什么。
你必须在不停止这个过程的情况下对经历这样的损失感到非常舒服，而且它必须符合你的风险管理政策。一些策略——比如操作中盘的均值回归策略，仅举一例——可能会经历极其严重的亏损，因此了解你的风险状况以感到舒适是很重要的。
利润因素(与盈利能力和优化相关)
利润因子定义了你冒多大的风险，得到多少。它基本上把总利润和总损失联系起来。1.5 的比率——如本例所示——意味着你冒着 1€的风险获得 0.50€的利润。比率越高越好。
利润因素通常用于进一步优化策略。接近 1 的利润因素会让你提高警惕。
回报率%(与盈利能力相关)
回报率%基本上就是投资获得了多少回报。这可能会有点误导，因为它是基于您的回溯测试交易账户计算的，可能过大(或过小)。
同样重要的是要明白，只有在不同的市场条件下对策略进行了长时间的测试，才能获得现实的回报率。在这个特殊的例子中，一个月的回溯测试不足以得出策略盈利的结论。
最大批量因子
如果你操作的是可变规模策略，最大批量因子会告诉你所用的最大规模。这很大程度上取决于您如何在回溯测试工具中配置工具的杠杆水平。
在本例中，手数和杠杆调整得很好，因此每个操作处理 1 个€/点，因此该值没有意义。如果您在交易中操作可变手数，并且您希望通过确定手数来控制风险，这会有所帮助(在差价合约中，您最终会感到自然手数对您的交易账户来说太多了)。
恢复系数和可靠性系数(与风险管理和优化相关)
恢复系数通过以下公式计算:
恢复系数=(总利润-总损失)/最大提取额
它基本上是一个品质因数，量化了毛利润与最大亏损之间的关系。恢复系数越高越好。
可靠性系数将平均月利润与最大提取相关联:
可靠性系数=每月利润/最大支出
我们可以尝试简化这两个数字的统计含义，说明它们试图量化股票曲线的波动程度。由于最大下降是估计性的，它们只是指标，可用于优化参数并获得更友好的权益曲线。
丰富和审查您的回溯测试操作
虽然我们不会讨论如何丰富表格数据，但文章中已经提到，用交易信息丰富数据总是一个好主意。
丰富数据的方法不受限制，需要经验和实验。如果你使用移动平均线或指标，你可能想包括交易发生时这些平均线或指标的状态。
Backtesting software will provide you basic information that can — and shall — be enriched separately in an spreadsheet analysis
基于交易长度、方向(买入/卖出)或一天中的时间段，可以获得进一步的详细分析。目标是找到某些参数和盈利/亏损交易之间的相关性。
我记得为我的外汇交易做的一组统计(在这种情况下，他们是实时交易的统计)，我知道我买比卖更有利可图。虽然这些发现必须谨慎对待(它可能与市场条件有关)，但它们也可能揭示您的操作中的偏差。正确分析后，可以应用过滤器或进一步的尺寸标准。
最后但并非最不重要的建议是分析交易。这不是经常做的事情(很无聊，需要很多时间)，但它可能会导致发现操作错误，并有助于进一步改善战略和执行。
摘要
文章回顾了如何对自主交易进行回溯测试，以及如何阅读一些基本的统计数据。
已经强调了回溯测试的相关性，并且已经表明了对关键统计数字和指标的基本理解如何能够有利于提高盈利能力。
强调了用于确定其对盈利能力和风险管理的影响的关键数字和公式，并提供了关于如何基于扩展数据实现进一步改进的最终意见。
[2]https://www . marottaomoney . com/what ’ s-the-average-holding-period for a-stock/
[3]https://ny post . com/2017/04/19/UBS-已经正式放弃其庞大的交易大厅/
[4]https://www . ft . com/content/4d 221 b 22-3d FB-11e 6-8716-a4 a71e 8140 b 0
[5]https://www . investopedia . com/articles/forex/07/profit _ loss . ASP
使用 zipline 中的自定义数据对交易策略进行回溯测试
Source: pixabay
了解如何将自定义数据导入zipline
在之前的文章中，我已经展示了如何使用zipline回测基本交易策略。为此，我使用了内置的quandl数据集，这对于许多用例来说已经足够了。然而，它也有一些缺点:
- 2018 年年中，它停产了，所以没有最近的价格
- 它只考虑美国股票
这就是为什么我还想展示如何获取定制数据集，即一小部分欧洲股票。我将通过使用已经由 Zipline 提供的csvdir包来这样做。还有其他的方法，我在本文最后会提到。
为了简洁起见，我将不再谈论zipline的设置。有关该主题的详细信息，请参考之前的文章。
获取数据
我们首先需要收集我们想要输入到zipline中的数据。为此，我使用了yahoofinancials库。为了加载到zipline中，数据必须是 CSV 文件和预定义的格式(示例如下)。为了这篇文章，我下载了两种证券的数据:ABN AMRO(一家荷兰银行)和 AEX(一种由在泛欧交易所交易的荷兰公司组成的股票市场指数)。我们使用后者作为基准。
我们从加载所需的库开始。
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
from yahoofinancials import YahooFinancials
然后，我们定义一个简短的函数，用于使用yahoofinancials下载数据，并准备数据帧供zipline接收。准备好数据后，该函数将数据作为 CSV 文件保存在一个名为daily的文件夹中(该文件夹以所考虑数据的频率命名)。
我们从下载 ABN·AMRO 的股票价格开始。
download_csv_data(ticker='ABN.AS',
start_date='2017-01-01',
end_date='2017-12-31',
freq='daily',
path='european/daily/abn.csv')
该函数返回下载价格的曲线图:
我们还展示了 zipline 接受的文本文件的结构。
!head ./european/daily/abn.csv
我们以类比的方式下载索引数据。
download_csv_data(ticker='^AEX',
start_date='2017-01-01',
end_date='2017-12-31',
freq='daily',
path='european/daily/aex.csv')
也可以将多个 tickers 以 Python 列表的形式传递给yahoofinancials并一次性下载。然而，我们选择这种方式是为了简化所需的操作。
摄取 CSV
让我们通过运行以下命令来检查当前加载的包。
!zipline bundles
我们现在将添加一个名为eu_stocks的定制包。为此，我们需要修改 zipline 目录中的extension.py文件。我们需要添加以下代码:
在调用register()时，我们必须指定一个交易日历，在本例中是XAMS，它对应于泛欧交易所。有关所有提供的日历列表，请参考此文档。也可以定义自己的交易日历，你可以在zipline的文档中找到更多信息。
请记住，我们需要传递之前下载的数据的确切日期范围。在本例中，我们从2017–01–02开始，因为这是我们获得价格数据的第一天。
为了最终接收数据，我们运行以下命令:
!zipline ingest --bundle eu_stocks
买入并持有策略示例
最后，我们展示了如何使用自定义数据来回溯测试交易策略。为此，我们采用基本的买入并持有策略。我们使用 ABN·AMRO 的股票，并选择 2017 年作为回溯测试的持续时间。默认情况下，zipline使用美元，但是，当所有资产都是同一种外币时，使用欧元报价的股票和指数没有问题。
关于这段代码中发生的事情的更详细的描述，我再次参考以前的文章。让我描述一些细微差别:
- 我们需要通过在
zipline魔术中包含—- bundle eu_stocks来指定我们想要使用的定制包 - 我们还需要通过在
zipline魔术中包含--trading-calendar XAMS来指定交易日历 - 我们需要在
initialize()函数中设置基准:set_benchmark(symbol(‘AEX’))。原因是默认基准是在纽约证券交易所交易的 SP500，这与我们的设置不兼容。
我们的买入并持有策略的结果如下图所示。
我们简单的策略在一年内成功创造了近 50 个€。
结论
在本文中，我展示了如何使用定制数据在zipline中运行回溯测试。正如我提到的，使用csvdir bundle 并不是我们获取定制数据的唯一方式。我们也可以写一个完整的定制包(更多细节请看这里)，例如，它使用 API 自动从加密交换中下载数据。然而，这可能是另一篇文章的主题:)
一如既往，我们欢迎任何建设性的反馈。你可以在推特或评论中联系我。您可以在我的 GitHub 上找到本文使用的代码。
以下是该系列的其他文章:
我最近出版了一本关于使用 Python 解决金融领域实际任务的书。如果你有兴趣，我贴了一篇文章介绍这本书的内容。你可以在亚马逊或者帕克特的网站 T21 买到这本书。
机器学习中特征选择的向后淘汰法
当我们建立机器学习模型时，我们只选择那些必要的特征或预测器是非常重要的。假设我们的数据集中有 100 个特征或预测值。这并不一定意味着我们需要在模型中包含所有 100 个特性。这是因为并不是所有的 100 个特征都会对模型产生显著的影响。但话说回来，这并不意味着它对所有情况都适用。这完全取决于我们手头的数据。这里有更多关于为什么我们需要特性选择的信息。
有多种方法可以找出哪些要素对模型影响很小，哪些要素可以从数据集中移除。我以前写过关于特性选择的文章，但是非常简短。在这篇文章中，我们将一步一步地看看逆向淘汰法，以及我们如何做到这一点。但是在我们开始讨论逆向淘汰之前，确保你熟悉 P 值。
第一步
反向消除的第一步非常简单，您只需选择一个显著性水平，或者选择 P 值。通常，在大多数情况下，选择 5%的显著性水平。这意味着 P 值将为 0.05。您可以根据项目更改该值。
第二步
第二步也很简单。你只需将你的机器学习模型与所有选择的特征相匹配。因此，如果有 100 个特征，您可以将它们全部包含在您的模型中，并使模型适合您的测试数据集。这里没有变化。
第三步
在步骤 3 中，识别具有最高 P 值的要素或预测值。又很简单了，对吧？
第四步
这是重要的一步。在这里，我们做决定。在上一步中，我们确定了具有最高 P 值的要素。如果该要素的 P 值大于我们在第一步中选择的显著性水平，我们将从数据集中移除该要素。如果该特征的 P 值(在集合中最高)小于显著性水平，我们将直接跳到步骤 6，这意味着我们完成了。请记住，最高 P 值大于显著性水平，请移除该要素。
第五步
一旦我们找到了需要从数据集中移除的要素，我们将在这一步中进行移除。因此，我们从数据集中移除该要素，并用新的数据集再次拟合模型。在为新数据集拟合模型之后，我们将跳回到步骤 3。
这一过程将一直持续到第 4 步，此时数据集中所有剩余要素的最高 P 值小于第 1 步中选择的显著性。在我们的示例中，这意味着我们从步骤 3 迭代到步骤 5，然后返回，直到数据集中的最高 P 值小于 0.05。这可能需要一段时间。在 100 个假设的特性中，我们可以这样筛选出 10 个特性(这只是我选择的一个随机数)。参考本文顶部的流程图，更好地理解这些步骤。
第六步
一旦我们到达第 6 步，我们就完成了特征选择过程。我们已经成功地使用反向消除来过滤掉对我们的模型不够重要的特征。
在这个过程中，我们还可以使用其他一些方法。我想我将来也会写一些关于他们的东西。
平衡谁处理数据不一致
在生产中，事情不可避免地变得不稳定，这是正常的
如果说这些年来你在处理数据时学到了什么，那就是数据质量“保证”本质上是善意的虚构。每当我接触到一个不熟悉的生产数据库时，我不可避免地会做一些简单的一致性检查，比如“这个惟一的 ID 实际上只出现过一次吗？”“有重复的事件吗？”“这些应该完全一对一地同时发生的事件真的是一对一的吗？”
每当我检查一个已经运行了一年或更长时间的系统时，通常很有可能至少有一些事实已经被有限地打破了。而在我看来，在一些合理的界限内， 这是可以的 。因为处理/预防问题的成本因团队而异。
Do the easy Eng stuff when you can, but eventually it gets too expensive
为什么？所有这些东西都应该由数据库系统来保证！这永远不会发生！
关于合同的事情(无论是在生活中还是在软件中)是，除非它们被强制执行，除非它们有真正的效力和后果，否则它们经常在对一方或双方都方便的时候被忽略。此外，强制执行的成本可能不值得付出。
在我曾经工作过的生产系统中，通常强制一致性约束的事物，比如外键和检查约束，出于性能原因在数据库中没有被明确使用或者不存在(就像那些黑暗的 NoSQL“酸？那是毒品对吗？”天)。这只是一个在应用层而不是数据库层“强制执行”的社会契约。所以事件日志表中没有重复行条目的唯一原因是因为应用程序知道不要写重复的行条目。
其他时候，有一些内置功能，如自动增加 id，这在单主机环境中是有意义的，但最终会增加复杂性，如分片，然后是多区域分片。随着复杂性的增加，这种逻辑开始转移到应用程序层，并且变得更加难以实施。
大多数时候，这一切都出乎意料地好，这要感谢设计系统并预见明显问题的工程师。预期的行为在测试和 QA 中得到验证，生活通常会继续。
当系统在生产中运行一段时间，并且系统开始积累不可预见的问题时，问题只会慢慢出现。不可避免地，一个系统会宕机，或者应用程序中的一个 bug 被引入。当你不得不处理一个分布式系统时，事情变得更加疯狂，这个系统更有可能有意想不到的和完全奇异的故障模式。这就是不可靠的数据如何绕过这些软“保证”并进入您的数据集。有时甚至“硬”保证也会被破坏，因为有一个意外的失败模式暴露了一个 bug。
什么？如果你关闭了一致性保证，你应该得到你所得到的！
I’m fairly sure this isn’t Stockholm Syndrome
确定吗？但问题是，如果数据中真的有重复的行(或丢失的行)，会发生什么呢？如果你是一家银行，这是你的交易日志，这是一件大事，即使每 10 万亿次交易中只发生一次。如果你只是跟踪有多少用户点击了一个按钮，你甚至可能不会注意到。
实用主义很重要。
同时，维护一致性合同的成本可能很高。数据库外键约束可能好，也可能不好，这取决于您的具体硬件、数据库工作负载和模式。您需要进行实际的测试和基准测试来计算 FKs 的成本。如果你需要保证整个地球上读/写事务的一致性，你要么等待光速，要么想出疯狂的新算法，比如用扳手。
如果检测到问题，您可以进行事后检查以发出警报，但随着应用程序的发展，您需要编写和维护一套全新的测试。此外，它要求您主动预测要检查的一致性问题。
对于大型 NoSQL 系统，您可能只有最终的一致性，如果不切换到一个完全不同的系统架构(以及其中涉及的所有成本)，您可能无能为力。
放松，可能没事
—什么？但是我的数据一团糟！我在一个表中有一个重复的 ID，该表中的字段应该是唯一的(真实的故事)。我的世界全是谎言。这怎么可能是“好”呢？你疯了。
所有发生在你发现了一个错误的证据，吸一口气，看看什么受到了影响。开始调试过程。你弄错了吗？它的主要作用是什么？有受影响的关键系统吗？这是一个持续的问题，还是已经停止了？有没有可以用来识别问题区域的签名？
一旦你意识到发生了什么(这不是一个错误)，以适当的严重程度提交一个 bug。如果它是一个关键的核心业务数据源，它可能需要 P0。
接下来，确定您是否可以解决事故造成的损失。对于那些有很强的人为因素的事情，比如临时的和探索性的工作，你能通过识别错误的行来解决这个问题吗？您能否在降级状态下使用不太细粒度的指标进行分析，比如使用唯一计数和不受影响的相关代理统计数据？
自动化数据管道的事情更加复杂，因为它们没有那么灵活。但是，根据您的模型和系统正在做什么，它可能在可接受的误差范围内。你必须测试才能发现。
核心问题:我们正在平衡防范数据问题的成本/收益
墨菲定律适用于所有事物，每个系统最终都会失败。完全干净的数据只存在于学校的玩具问题集中。问题是你愿意投入多少资源来防范越来越罕见的事件。
作为一个组织，您需要平衡在事情发生前通过工程预防/发现数据问题的能力，以及在事情发生后处理后果的时间和风险。
一致性检查和约束的工程设计可能是昂贵的，既包括原始计算资源，也包括构建和维护的工程时间。此外，这是另一个可能失败的系统！当然，有一些相对便宜的东西你可以从一开始就设计好，但是让我们承认，这些努力中有很多是典型的…后来加上去的。
另一方面，如果您没有预先做大量的一致性检查，当您发现坏数据时，作为数据科学家的您将被迫处理它。
那么，一个数据科学家能做些什么来处理这些乱七八糟的事情呢？
临时/探索过程
正如我之前提到的，这取决于所做的 ds 工作的类型。与生产系统或管道相比，分析和探索性研究是一件非常人性化和灵活的事情。由于这个过程中内置了大量的实验和探索，它天生更有能力处理奇异的数据错误，这些错误需要大量的工程工作来防止或检测。
在处理混乱的数据时，使用近似值的能力可能是我们拥有的最强有力的武器。考虑到我们所知道的一切是如何工作的，以及产生坏数据的错误的性质，至少可以推导出有用的近似值，至少可以提供部分信息的上限或下限。
正是由于这种使用降级数据集的能力，这就是为什么如果我被迫选择一方，我会投入更少的资源来确保非关键数据集上的预先数据一致性。在偶尔消费期间解决附带的 bug 会更有效率。
您仍然需要数据相当干净和可靠！但是你不应该试图为你能想象到的每一个黑天鹅事件提前计划。事情会出错，当它发生时你会处理它。
自动化流程
根据具体情况，数据问题可能会对模型产生巨大影响，或者根本没有影响。只有你这个模特设计师才能知道。但是即使有很大范围的可能性，我们还是可以谈论一些常见的情况。
如果数据问题已经存在很长时间了，您可能不需要立即采取任何措施，因为模型实际上是根据坏数据进行训练的，并且是在被判断为给出合理输出后启动的。具有讽刺意味的是，您需要测试您的模型是否能够处理接收干净的和错误修复的数据。这带来了各种关于模型原始有效性的认识论问题，但从纯黑盒输出的角度来看，它是可行的。
类似地，由于许多模型优先使用最近的数据，旧的和坏的数据有从系统中“老化”的趋势。如果修复花费的时间超过一个月或其他任何事情自我纠正的时间，那么修复历史数据可能就不值得了。
数据问题触发灾难性的重新分析和重写模型的情况也很少见(但并非闻所未闻),因为模型往往会将许多输入集中在一起。一个数据错误将需要影响一个真正广泛的区域来影响一组模型输入，因为几乎所有的模型都有一个试图最小化变量之间相关性的特征缩减步骤。
这种错误的一个例子是，如果重要的数据点以一种非常有偏差的方式被丢弃，就会在分布中引入一系列偏差。类似于一个系统，系统地不能识别来自大客户的购买，这些大客户只来自加利福尼亚州。希望这类错误足够大，能够很快被发现，因为它们会对业务中的其他事情产生重大影响。
所以我们应该接受数据质量退居二线的事实？
不要！我们不是擦鞋垫…
我要说的是，数据科学过程有更多自然的冲击吸收。数据质量的边际成本改善曲线与人在回路分析过程有很大的不同，在某一点上，说“好吧，我们的数据一致性保护措施是我们现在能够做到的最好的”是有道理的。
我们何时知道您必须改进数据一致性保护措施？
负责任的答案是，当你意识到一些流程和数据在你的业务中变得越来越重要，因此你应该加大投资。这意味着你需要做定期审查和积极主动。做好真的很难，我只在一些事情正在积极发展并且我正在积极思考这些问题的时候才会去做。
诚实的答案是，当你发现一个 bug，并意识到某件事有多重要时。随着系统的变化，这些事情很容易悄悄发生在我们当中最优秀的人身上。我们可能无法看到所有可能的变化，我们也无法 100%清楚地了解系统每个方面的副作用。
总是一种平衡的舞蹈。你永远不会对你所拥有的感到完全舒服，这种不舒服可能是一个好迹象，表明你接近一个可管理的点。
bamboo lib——无需编码即可学习和使用熊猫
Bamboolib In Action
熊猫的图形用户界面——适用于初学者和专家
你有没有因为用熊猫做数据探索和操纵而沮丧过？
有这么多方法做同样的事情，我被选择宠坏了，最终什么也没做。
对于初学者来说，问题正好相反，因为即使是简单的事情也没有适当的文档记录。对于门外汉来说，理解 Pandas 的语法可能是一件困难的事情。
那么应该怎么做呢？
bamboo lib的创作者有了一个解决这个问题的想法——为什么不给熊猫添加一个 GUI 呢？
想法是 “不用编码学习使用熊猫。”这个想法开始可能很简单，但是我发现 Bamboolib 在数据探索和数据清理方面要好得多。
这个帖子是关于为你的数据设置和使用 Bamboolib 的。
安装 Bamboolib
安装非常简单，包括:
*pip install bamboolib*
为了让 bamboolib 与 Jupyter 和 Jupyterlab 一起工作，我需要安装一些额外的扩展。因为我喜欢使用 Jupyter Notebook，所以我通过以下命令安装了 Jupyter Notebook extensions:
*jupyter nbextension enable --py qgrid --sys-prefix
jupyter nbextension enable --py widgetsnbextension --sys-prefix
jupyter nbextension install --py bamboolib --sys-prefix
jupyter nbextension enable --py bamboolib --sys-prefix*
如果你想为 Jupyterlab 安装进程，这里有进程。
验证 Bamboolib 安装
要检查是否一切正常，您可以打开一个 Jupyter 笔记本，并执行以下命令:
*import bamboolib as bam
import pandas as pd
data = pd.read_csv(bam.titanic_csv)
***bam.show(data)****
第一次运行此命令时，会要求您提供许可证密钥。如果您想对自己的数据使用 bamboolib，就需要这个键。因为我想在自己的项目中使用 bamboolib，所以我从 Bamboolib 的创始人 Tobias Krabel 那里得到了密钥，他非常慷慨地将它提供给我查看。然而，你可以从 https://bamboolib.8080labs.com/pricing/买你自己的。如果你想在购买钥匙之前看到库的运行，你可以尝试一下现场演示。
一旦 bamboolib 被激活，有趣的部分就开始了。可以看到 Bamboolib 的输出是这样的。你可以选择玩它提供的选项。
因此，让我们用令人兴奋的数据源来尝试 Bamboolib，我们都已经看到了大量的数据。
为此，我将使用来自 Kaggle 的移动价格分类数据。在这个问题中，我们必须创建一个分类器，根据手机的功能预测手机的价格范围。让我们从 Bamboolib 开始。
*train = pd.read_csv("../Downloads/mobile-price-classification/train.csv")
bam.show(train)*
我们需要简单地调用bam.show(train)来启动 Bamboolib。
轻松的数据探索
Bamboolib 对探索性数据分析有很大帮助。现在，数据探索是任何数据科学管道不可或缺的一部分。为数据探索和创建所有图表编写完整的代码是复杂的，需要大量的耐心和努力才能做好。我承认有时我会懈怠，没有足够的时间来做这件事。
Bamboolib 使整个数据探索练习变得轻而易举。
比如说。这里是您数据的 一瞥， 一旦您点击可视化数据框。
您可以看到每一列中缺少的值，以及唯一值的数量和一些实例。
但这还不是全部。我们还可以获得单变量的列级统计数据和信息。那么 让我们来了解一下我们的目标变量——价格范围。
在这里，我们深入研究目标列，可以看到单变量列统计数据以及目标列的最重要预测值。看起来 RAM 和电池电量是价格区间最重要的预测指标。很好。
我们来看看 RAM 是如何影响价格区间的。 我们可以为此使用二元图。
使用 seaborn 或 plotly 等标准 Python 库获得如此美丽的图形通常需要一些代码。虽然 plotly_express 通过为大多数图表提供简单的函数在这方面帮了很大的忙，Bamboolib 为我们自动创建了许多重要的图表。
以上，我们可以看到，随着 RAM 的增加，价格区间也在增加。我们还看到 RAM 变量的加权 F1 得分为 0.676。您可以对数据集中的每个变量都这样做，并尝试了解您的数据。
也可以导出这些图表的代码 用于某些演示/导出这些图表为 PNG。
为此，只需复制每个图表上方显示的代码片段。例如，您可以复制并运行代码来查看price_range与ram的对比，您将看到一个将这些图形下载为 PNG 的选项。在后端，它们都是 plotly 图形。
*bam.plot(train, 'price_range', 'ram')*
基于图形用户界面的数据管理
你有没有面临过忘记熊猫代码做某件事而去堆栈溢出，迷失在各种线程中的问题？如果是的话，这里有一份最小熊猫点心。或者您可以根据自己的喜好使用 Bamboolib。
Bamboolib 让事情变得如此简单，而不会迷失在代码中。您可以使用提供的简单 GUI删除列、过滤、排序、连接、分组、透视、融化(几乎是您想对数据集做的所有事情)。**
例如，这里我将删除目标列中缺少的值，如果有的话。您也可以添加多个条件。
最好的部分是它也给了我们代码。这里，删除缺失值的代码会自动填充到单元格中。
*train = train.loc[train['price_range'].notna()]
train.index = pd.RangeIndex(len(train))*
它的工作方式就像商业用户的 Microsoft Excel 一样，同时为高级用户提供所有的代码来分割数据。您可以尝试使用其他选项来熟悉一下。
下面是另一个如何使用 groupby 的例子。这实际上非常直观。
其代码被填充为:
*train = train.groupby(['price_range']).agg({'battery_power': ['mean'], 'clock_speed': ['std']})
train.columns = ['_'.join(multi_index) for multi_index in train.columns.ravel()]
train = train.reset_index()*
你可以看到它如何为我们照顾multi_index以及ravel，这有点难以理解和处理。
结论
Bamboolib 的 GUI 非常直观，我发现使用它绝对是一种享受。这个项目仍处于开始阶段，但这是一个多么好的开始啊。
我可以肯定地说，这个库对于想学习用 Pandas 编写代码的初学者来说是非常有用的，因为它为他们提供了访问所有必要功能的途径，而不会带来麻烦。
虽然我仍然会专注于了解熊猫的基础知识，并建议查看 Bamboolib 的输出来学习熊猫，但我想看看 Bamboolib 在未来会如何被采用。
请在评论中告诉我你的想法。
如果你想了解更多关于熊猫的知识，我想从密歇根大学调出一门关于 Python 数据科学入门的优秀课程，或者查看我以前关于如何与熊猫合作的帖子。
我以后也会写更多这样的帖子。让我知道你对他们的看法。在关注我或者订阅我的 博客 了解他们。一如既往，我欢迎反馈和建设性的批评，可以通过 Twitter @mlwhiz 联系
禁止面部识别，这是一个危险的举动
Wedjat Eye Amulet ca. 1070–664 B.C.
随着人们开始害怕面部识别，我们应该后退一步，重新评估这项技术和我们的选择。
为了透明起见，我认为我有责任声明我在计算机视觉行业工作。我不是用这篇文章来推动一家公司的议程或试图保住我的工作，而是为一个备受批评和误解的领域提供背景。
这是真的，谈论使用人工智能来调查城市会让人想起乔治·奥威尔警告过的反面乌托邦。知道某些政府如何利用这种技术并不能带来安慰。在过去的几个月里，人们一直在努力遏制计算机视觉的滥用。旧金山通过立法禁止市政当局使用面部识别技术。众议员奥卡西奥-科尔特斯在与算法正义联盟创始人的听证会上指出了一些担忧。最近， Buzzfeed 发布了一篇夸张的文章，要求彻底禁止所有面部识别技术。
面部识别技术是一个难以置信的新生领域。第一篇描述面部识别工作方法的论文发表于 1987 年，而 celeritous detection 发表于 2001 年。然而，这项技术在专利申请方面已经取得了长足的进步。Google 相册能够按照特定的人(和狗)对你的照片进行分类！)。脸书最近的照片崩溃事件显示了它识别照片中的人和情感的能力。
虽然这可能看起来令人印象深刻，甚至具有威胁性，但认识到面部识别的依赖性和局限性很重要。此外，像许多技术一样，我们应该承认总会有人滥用技术。这并不意味着这项技术没有善意的应用。
任何人工智能、机器学习或其他可怕的技术术语都是数学的应用。面部识别也没什么不同。该主题实现了线性代数和统计，以实现特定的目标。有多种方法用于实现面部检测，但一种基本方法涉及拍摄大量面部图像并将其提供给“训练者”。培训师确定图像和化妆之间哪些特征是相似的，我们认为什么是脸。这些不是我们想象中的特征，比如鼻子、嘴巴、两只眼睛等等。计算机不知道鼻子是什么。不，这些要素由一组离散的边、线、点和空间组成。从一个足够大和多样化的数据集中，这个训练器可以创建一个数学表达式。该表达式可以基于已经提取的特征在新图像上产生置信度得分。然后，外部用户可以声明他们认为能够证明成功结果的置信度分数。
这是一种简单的方法，更快、更精确的方法已经被开发出来。然而，它们的基本前提是相同的。这些算法依赖于大量的数据才能成功，它们产生的是置信度得分，而不是绝对答案。
这种方法有一个明显的问题。如果使用的数据集有明显的偏差，那么异常值将会引起问题。偏差会影响整个系统。其次，如果出现对置信度得分的误解，单个病例可能会被错误地处理。
这正是刑事调查案件中发生的情况。算法的设计者并没有天生地构建系统来选择某些少数群体、肤色或性别。一个更可能的解释是在训练阶段使用了同质数据集。如果数据集中使用的大多数人脸是年龄在 20 到 30 岁之间的白人男性，那么任何其他人脸都将被视为异常值，并报告有缺陷的置信度得分。在繁重的工程期限内，可能很难积累一个稳健的数据集，其中包含人口的现实代表。
报告的分数是误差的第二个来源。引入了第二层人为错误。如果向用户报告的结果没有置信度得分，那么解释器就没有其他信息可以采取行动。从工程角度来看，这是一个糟糕的设计。或者，如果产生了置信度得分，用户可能不理解置信度得分是如何得到的。这两个问题很可能是由于工程师、项目经理、销售人员和营销人员之间的沟通不畅而引起的。在这个分销链的某个地方，细节被忽略，最终用户对此一无所知。
已经提出了解决这些问题的规则。数据政策中的一些人提议公布数据。如果一个算法使用未知信息来得出结论，也许它的用户应该了解先验信息。科技公司会抱怨这破坏了竞争优势。
另一个解决方案是建立信心报告的标准。可以实施这样的法律，即算法本身不能基于某些置信度做出决定。他们可以向用户报告指标，但仍然给人以权威。这类法规将为科技公司创造更高的标准。这些法律可能适用于高风险场景，如刑事和国防，但不应普遍适用。某些令人兴奋的技术，如自动驾驶汽车，是建立在基于信心得分做出决策的基础上的。
规范智能
综上所述，讨论一下为什么完全禁止这种新生技术是危险的是很重要的。在过去，我们在技术的早期阶段就将其妖魔化并加以惩罚，这是我们今天要付出的代价。核能就是一个最好的例子。核技术因其在武器上的应用而声名狼藉，这是理所当然的。切尔诺贝利和福岛事故也无济于事。然而，在当今时代，核能实际上可能是我们减少化石燃料消耗和扭转气候变化影响的最佳机会。不幸的是，提出这样的技术已经成为政治自杀，现在被忽视。
联邦对大麻的驱逐是另一个例子。在极少进行研究的情况下，该药物在美国被宣布为非法。我们现在正在了解该药物的一些健康益处，但合法化和进展遭到了怀疑的反对。
如果我们在面部识别技术上鲁莽行事，我们不知道我们正在摧毁哪个科学和研究领域。也许有一些医学应用将有助于识别面部瑕疵和异常值，否则无法检测出来。一些公司正在车内实施面部识别系统，以提高驾驶员的注意力和安全性。这个领域仍未被充分开发。
禁止一项技术不仅从科学好奇心的角度来看是危险的，从立法的角度来看也是危险的。当规章到位时，可以测试、检查实践，并且可以进一步编辑规章。可以发现并封闭循环孔。压迫性的限制可以重新评估。当一项彻底的禁令实施后，任何废除的企图都几乎是不可能的。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
