Only Numpy Medical:使用交互式代码的神经网络对肺部 CT 扫描进行去噪—第 2 部分，卷积神经网络(使用卷积神经网络的低剂量 CT 去噪)
image from pixel bay
所以今天我就继续上图像去噪系列，幸运的是我找到了这篇论文“卷积神经网络低剂量 CT 去噪。在生物医学 Imagi*【n】*由陈虎。因此，让我们深入了解一下它们的实现，看看我们会得到什么结果。最后，为了好玩，让我们使用不同类型的反向传播来比较什么给我们最好的结果。我们将要使用的不同类型的反向传播是…
a.谷歌大脑的梯度噪声
b. 扩张型反向传播
c. 扩张型反向传播+谷歌大脑的梯度噪声
如果你不知道它们之间的区别，请阅读我链接的博文。
注:所有的 DICOM 图像均来自 癌症影像存档网 ，如果您打算使用这些数据，请查阅他们的数据使用年龄政策。具体来说，我将使用来自 仿真 FDA 数据集的 DICOM 图像。
网络架构(数学方程形式)
The first two layers of our convolutional NN
The final Layer of Convolutional NN
这篇论文写得有点奇怪，当提到符号时，有时他们用 X 代表 Y，反之亦然。因此，在我最大的能力范围内，我认为我们正在建立一个三层卷积神经网络。两层的激活函数都是 ReLU()激活函数，最后一层没有任何激活函数。
网络架构(OOP 形式)
网络的 OOP 形式非常简单，除了一部分。我们有 4 种情况，记住，我们将使用不同类型的反向传播，看看哪种能给出最好的结果，它们在这里。
这里需要注意的一个非常重要的事实是，每个网络并不是以相同的权重开始的！这可能不是最公平的比较。然而，我决定这样做，看看每个反向传播方法在长期效果中的表现。也就是说，如果它们确实优于另一个，那么无论初始权重如何初始化，网络都会表现得更好。
训练/测试数据
Original Paper link here
如上文中所见，作者(陈虎)将一幅图像分割成独立的图像块。现在，我们不打算使用与本文中完全相同数量的补丁，而是将我们的训练和测试映像分成几个补丁。下面可以看到一个训练图像。
第一行图像 →原始图像和分割补丁
第二行图像 →添加噪声图像和分割补丁
因此，原始图像的尺寸为(512512 ),我们将把图像分成 4 个小块。更具体地说，每个图像块将具有(256256)维。记住这一点，下面是其他训练和测试数据的例子。(此外，我忘了拍摄分割后的原始图像，所以这就是为什么你看不到它们的原因。)
成本函数/反向传播
现在让我们来看看我们将要使用的成本函数。既然这个方程的设定值对我们来说优化它是非常重要的。
现在，请记住这篇论文的符号是混淆的。但我可以有把握地说，我们将使用的成本函数是 L2 范数除以批量数量，而不是 0.5。这可以通过下面的代码来实现。
由于我们的批量大小为 4，(我们将图像分成 4 个不同的空间)我们将使用 0.25。此外，我想在这里指出一件非常重要的事情。
如果我们遵循反向传播的严格规则，我们实际上应该在红框区域乘以 0.5，但是为了稳定，我决定只使第一个梯度更小。(这个决定是在多次不同的尝试和错误之后做出的。)
案例 1:培训和结果
案例 1 是正常的随机梯度下降，如上图所示，可以看到 CT 扫描的整体形状。然而很难看出。右图是用于比较的原始图像之一。
案例二:培训及结果
对于梯度噪声，你可以。看到中间有东西。然而，没有办法告诉这是一个肺部 CT 扫描图像。右图是用于比较的原始图像之一。
案例 3:培训和结果
现在，使用扩张的反向传播，我们可以看到得到的去噪图像看起来非常类似于情况 1 的结果。然而，再次很难准确地说出 CT 扫描中哪个是肺的部分。右图是用于比较的原始图像之一。
案例 4:培训及结果
现在我们可以清楚地看到我们在看什么。然而，它缺乏细节，我的意思是很多细节。如果你把 GIF 和正确的图像进行比较，你几乎分辨不出细节。右图是用于比较的原始图像之一。
互动码
我转到 Google Colab 获取交互代码！所以你需要一个谷歌帐户来查看代码，你也不能在谷歌实验室运行只读脚本，所以在你的操场上做一个副本。最后，我永远不会请求允许访问你在 Google Drive 上的文件，仅供参考。编码快乐！
现在运行这段代码有点复杂，因为我使用了自己的数据集。不过，不要担心，我已经将我使用的所有 DICOMs 上传到我的公共 Github (Gitlab 遇到了问题)，要访问它请点击这个链接。要访问存储库的主页，请单击此处。现在请按照一步一步的教程。
- 从上面的链接下载“lung_data_small_jpg.zip”文件。
2.将 Google Colab 中的代码复制到您自己的游戏中。运行代码时，会弹出一个小按钮，如上所示。(绿色方框)。单击选择文件并选择最近下载的“lung_data_small.zip”文件。
3.该计划将完成上传数据到谷歌 Colab，它将继续运行。
所以记住上面的简短教程，请点击这里访问交互代码。最后，请注意，培训过程非常不稳定，因此每次结果都可能不同。
最后的话
所以我们尝试了两种不同的方法，自动编码器和现在的卷积神经网络。然而，他们都没有给我们一个医学专业人士可以在现实生活中使用的结果。所以传奇仍在继续……
如果发现任何错误，请发电子邮件到 jae.duk.seo@gmail.com 给我，如果你想看我所有写作的列表，请点击这里查看我的网站。
同时，在我的推特这里关注我，访问我的网站，或者我的 Youtube 频道了解更多内容。如果你感兴趣，我还在这里做了解耦神经网络的比较。
参考
- 患者 CD/DVD DICOM 浏览器。(未注明)。检索于 2018 年 2 月 16 日，来自https://www.radiantviewer.com/
- Scipy.ndimage.imread。(未注明)。检索于 2018 年 2 月 16 日，来自https://docs . scipy . org/doc/scipy/reference/generated/scipy . ndimage . im read . html
- 陈，洪，张，杨，张，魏，廖，李，周，王，(2017 年 4 月)。基于卷积神经网络的低剂量 CT 去噪。在生物医学成像(ISBI 2017)，2017 IEEE 第 14 届国际研讨会上(第 143–146 页)。IEEE。
- 如何在 Python 中读取压缩文件夹中的文本文件？(未注明)。检索于 2018 年 2 月 16 日，来自https://stack overflow . com/questions/22646623/how-to-read-text-files-in-a-zipped-folder-in-python
- Seo，J. D. (2018 年 1 月 18 日)。only Numpy:Implementing " ADDING GRADIENT NOISE IMPROVES-LEARNING FOR-VERY-DEEP-NETWORKS-with-ADF 23067 F9 f12018 年 2 月 17 日检索自https://becoming human . ai/only-Numpy-Implementing-ADDING-GRADIENT-NOISE-IMPROVES-LEARNING-FOR-VERY-DEEP-NETWORKS-with-ADF 23067 F9 f1】
- Seo，j . d .(2018 . 2 . 15)。只有 Numpy:扩张的反向传播和谷歌大脑的梯度噪声与交互代码。检索于 2018 年 2 月 17 日，来自https://hacker noon . com/only-numpy-expanded-back-propagation-and-Google-brains-gradient-noise-with-interactive-code-3a 527 fc 8003 c
- Seo，J. D. (2018 年 2 月 13 日)。Only Numpy Medical:使用具有交互代码的神经网络对肺部 CT 扫描进行去噪—第 1 部分…2018 年 2 月 17 日检索自https://towards data science . com/only-Numpy-Medical-de nosing-Lung-CT-Scans-using-auto-encoders-with-Interactive-Code-Part-1-a6c3f 9400246
- 越来越多的癌症医学图像档案。(未注明)。检索于 2018 年 2 月 12 日，发自 http://www.cancerimagingarchive.net/
- Gavrielides，Marios A，Kinnard，Lisa M，Myers，Kyle J，Peregoy，，Pritchard，William F，曾，荣平，… Petrick，Nicholas。(2015).数据来自 Phantom_FDA。癌症影像档案。http://doi.org/10.7937/K9/TCIA.2015.ORBJKMUX
Only Numpy: NIPS 2017 -用交互式代码实现扩张型递归神经网络。
Image from Pixel Bay
所以我在浏览 2017 年的 NIPS，出版页面时发现了这篇论文， IBM 沃森研究中心的扩张的递归神经网络。所以试图实现它，并用它来对 MNIST 数字进行分类。
网络架构(数学方程式形式/图形形式 2D)
Image from Original Paper
现在这个方程在数学方程的形式上有点复杂，难以理解。所以论文的作者给我们提供了一些图表。
如上所述，这是典型的 RNN，但有多个层以及跳过连接。
网络架构(图形形式 3D / OOP 形式)
Side view
Front View
红圈 →网络的最终输出，预测数的一个热编码的(1*10)向量
棕色圆圈 →第 2 层隐藏状态 0
石灰圆圈 →第 2 层隐藏状态
粉色圆圈→1 层隐藏状态 0
黑色圆圈→1 层隐藏状态
蓝色数字 1、2、3、4、5 →每个时间戳的输入(请记下这一点，因为我将使用这些知识来解释训练/测试数据)
以上是我们要建立的网络，第一层是标准的 RNN，没什么特别的，然而第二层有点不同，它有间隔为 2 的跳跃连接。
以上是面向对象的网络形式，正如我们所看到的，我们只有一个简单的前馈函数和一个标准的反向传播函数。
训练数据/测试数据
粉色框 →时间戳 1 处输入(矢量化 1414 像素图像)
黄色框 →时间戳 2 处输入(矢量化 1414 像素图像)
蓝色框 →时间戳 3 处输入(矢量化 1414 像素图像)
紫色框 →时间戳 4 处输入(矢量化 1414 像素图像)
绿色框
这就是我所做的，我取原始图像(2828)，用(22)矩阵进行均值合并，得到(1414)的图像。我们将用它作为时间戳 1 的输入。对于其他时间戳的输入，我们将把原始(2828)图像切割成 4 个部分，并将其提供给网络。下面是实现这一点的代码。
记住这一点，让我们看看其他的训练数据。最后，我这样做的原因，简单来说，我想 LOL。
Image of 3 6 4 in the respective order
训练和结果
看一下成本随时间变化的图表，我们可以看到，网络从 4.0 区域开始，并且能够将成本降低到 1.7。
然而，准确预测的数量只有 68/100，给了我们 68%的准确率。我认为把图片分成 4 部分是个坏主意，哈哈。
互动码
我搬到了谷歌 Colab 寻找交互代码！所以你需要一个谷歌帐户来查看代码，你也不能在谷歌实验室运行只读脚本，所以在你的操场上做一个副本。最后，我永远不会请求允许访问你在 Google Drive 上的文件，仅供参考。编码快乐！
请点击此处访问互动代码。
遗言
我实际上有更多的计划在不同的实验中使用这个网络架构，所以如果你想得到:D 的通知，请确保在推特上关注我
如果发现任何错误，请发电子邮件到 jae.duk.seo@gmail.com 给我，如果你想看我所有写作的列表，请在这里查看我的网站。
与此同时，请在我的 twitter 这里关注我，并访问我的网站，或我的 Youtube 频道了解更多内容。如果你感兴趣，我也在这里做了解耦神经网络的比较。
参考文献
- 常，张，杨，韩，魏，余，米，郭，陈，谭，黄，黄铁生(2017)。扩张的循环神经网络。神经信息处理系统的进展。
- [1]2018.【在线】。可用:https://www . quora . com/What-the-benefit-of-use-average-pooling-而非-max-pooling。【访问时间:2018 年 2 月 7 日】。
- [3]S. Chang，Y. Zhang，W. Han，M. Yu，X. Guo，W. Tan，X. Cui，M. Witbrock，M. Hasegawa-Johnson 和 T. Huang，“扩张型递归神经网络”， Papers.nips.cc ，2018 .【在线】。可用:https://papers . nips . cc/paper/6613-expanded-recurrent-neural-networks。【访问时间:2018 年 2 月 14 日】。
- IBM 托马斯·J·沃森研究中心。(未注明)。检索于 2018 年 2 月 14 日，来自http://www.research.ibm.com/labs/watson/index.shtml
只有 Numpy:理解反向传播的转置卷积多层 CNN 的例子和互动代码。
Gif from this website
所以在过去的两天里，我很难理解转置卷积运算。但我终于明白了，今天，我们将训练一个简单的 CNN，它有两个卷积层，如下所示。
Very Simple CNN Arch.
我从哪里得到答案的有趣故事。
昨天，我被邀请参加一个聚会的晚宴。原因是一个非常博学的硕士生成功地完成了她的答辩，所以我们在庆祝。然而，在过去的两天里，我无法完全理解 CNN 的整个反向传播过程。
当我试图在卷积层的最外层执行反向传播时，我碰了壁。
但在那次晚宴上，我终于明白了。
看着我盘子里的鸡眼，我意识到，一直以来，我都在试图将 CNN 中的反向传播过程理解为反卷积。这是我最初的想法。
设红框为 22 输出图像
设绿框为 33 内核
设蓝框为 4*4 输入图像
由于我们在对 4×4 图像执行卷积之后获得 2×2 输出图像，因此，在执行反向传播时，我们需要对 2×2 输出图像执行一些操作，以获得具有 4×4 维度的一些图像。”
但是鸡眼(LOL)让我意识到我们的目标不是恢复原来的形象。相反，我们试图得到网络中每个权重的错误率。在多层 CNN 的情况下，我们需要反向传播该误差。所以哈哈，这就是我的解决方案，让我用一个具体的例子和代码来解释我的意思。
网络架构
如上所见，网络拱非常简单，只是两层卷积和一层全连通层。请注意，在执行卷积时，我们需要将内核转置(旋转)180 度，所以请注意上面照片中的绿色方框。
还有，请注意，为了简单起见，我没有画激活层。但是在交互代码中，我用的不是 tanh()就是 archtan() 。
image from techieme
如果你不确定矩阵旋转，请阅读本文。
正向进给操作操作
更新我在列上犯了一个错误，绿色箭头所指的两列必须对调。谢谢亚伯拉罕·坎指出。
所以如上所见，卷积运算可以写成一行。出于我稍后将解释的原因，请仔细记下红框变量，它们基本上是下一层的输入。但是在执行反向传播时，这些信息变得至关重要。
相对于绿色权重的反向传播
黄色方框表示学习率，同样，整个反向传播是一个标准过程。我也写下了梯度更新方程。最后，请注意红色方框中的符号“k ”,我会反复使用这个符号来表示(Out — Y)。
相对于红色权重的反向传播
红框→ (Out — Y)
黄框→学习率
黑框→卷积运算前旋转核 180 度(或转置)——还记得在卷积运算中我们旋转核吗？
一切都非常简单明了，除了紫色的盒子，那是什么？
紫色框→旋转矩阵以拟合计算每个权重的导数。
现在的问题是，为什么？我们为什么要这样做？
记得我告诉过你们要注意每一层的输入吗？让我们再来一次。
请仔细看看这些彩色的盒子。
橙色框 →正在乘以红色 W(2，2)的输入
浅绿色框 →正在乘以红色 W(2，1)的输入
蓝色框 →正在乘以红色 W(1，2)的输入
粉色框 →正在乘以红色 W(1，1)的输入
很好，这很简单，但是这和转置内核有什么关系呢？好吧，让我们这样做，因为(请看黑框等式)Out 可以写成一行，让我们对红色权重求导，如下所示。
*更新 * 4 月 8 日—感谢大宇和亚伯拉罕·康指出错误，坐标上有个小错误。
深绿色方框数字→对不起，我没有绿色的笔，但它们代表绿色的砝码**。**
如图所示，当对每个红色权重进行求导时，我们可以看到 XX 坐标因输入而异。我们需要根据每个权重来匹配这些坐标，这就是我们将矩阵旋转(转置)180 度的原因。
关于蓝色重量部分 1 的反向传播
蓝框 →计算(K *绿色权重)和(填充的红色权重)之间的卷积
橙色框 →再次旋转矩阵以获得每个权重的导数。
黑盒 →同样的故事，卷积运算前旋转内核。
现在，问题来了，为什么要填充(紫色方框)？为什么我们需要垫红色的砝码？
好问题，我一会儿会解释，但是现在请继续读下去。
关于蓝色重量部分 2 的反向传播
蓝框 →第 1 部分的计算矩阵。
黑盒 →卷积运算前转置内核。
橙色、浅绿色、蓝色、粉色方框 →计算每个蓝色权重的每个导数。
Close look of the Rotated Kernel
上图是在执行卷积运算时，对旋转后的内核的近距离观察。但是现在让我们再看一下输入。
再说一次，因为 Out 可以写成一行，让我们对蓝色权重求导，如下所示。
绿色框号 →再次抱歉没有绿色笔
橙色框 →相对于蓝色权重(2，2)计算的渐变
粉色框 →相对于蓝色权重(1，1)计算的渐变
因此，我们再次旋转(或转置)矩阵，以匹配每个权重的梯度。
另外，现在我们填充红色重量的原因很清楚了，这是为了得到每个重量的梯度，我将再次向你们展示我所说的填充红色重量的意思。(请看紫色的星星)
交互式代码激活功能
绿框 →激活函数的导数，因为它们具有相同的维数，我们可以只执行元素乘法
红框 →旋转内核匹配渐变
蓝色方框 →用零填充红色砝码(名为 W2)
交互代码
最后的话
在 CNN 中理解反向传播是非常令人满意的，我两天来一直在努力理解这个概念。如果没有被邀请参加毕业晚宴，我是不可能做到这一点的，谢谢你，莎拉！
如果发现任何错误，请发电子邮件到 jae.duk.seo@gmail.com 找我。
同时，在我的 twitter 这里关注我，并访问我的网站，或我的 Youtube 频道了解更多内容。如果你感兴趣，我还在这里做了解耦神经网络的比较。
参考
- D.(2015 年 10 月 25 日)。矩阵旋转和矩阵转置。检索于 2018 年 1 月 28 日，发自http://techieme.in/matrix-rotation/
- 什么是反进化层？(未注明)。检索于 2018 年 1 月 28 日，来自https://data science . stack exchange . com/questions/6107/what-is-de convolution-layers
- http://courses . cs . tau . AC . il/Caffe _ workshop/boot camp/pdf _ lectures/lectures % 203% 20 CNN % 20-% 20 back propagation . pdf
- Dumoulin 和 f . Visin(2016 年)。深度学习卷积算法指南。 arXiv 预印本 arXiv:1603.07285 。
- https://www . cc . gatech . edu/classes/ay 2018/cs 7643 _ fall/slides/L7 _ CNNs _ annotated . pdf
这篇文章发表在 The Startup 上，这是 Medium 最大的创业刊物，拥有 295，232+人关注。
在此订阅接收我们的头条新闻。
Only Numpy:通过时间实践推导反向传播的普通递归神经网络—第 1/2 部分
这是我在 Medium 发表的第一篇正式的教育文章，我不得不说 Medium 是一个非常棒的博客平台。不管怎样，我们开始吧。问题很简单，我们将使用 RNN 来计算给定数据中有多少个 1。如果你只是想要视频教程和代码，请点击下面的链接。
Github 链接:https://github . com/JaeDukSeo/Only _ Numpy _ Basic/blob/master/rnn/a _ rnn _ simple . py
如上文(a)所示，训练数据是 X，测试数据是 Y(地面实况)。(b)我们将只有两个权重，Wx(其中我们将乘以输入 x)和 Wrec(其中我们将乘以先前的状态)
理解©非常重要，因为我们的网络架构是我们网络架构的展开版本。然而，它清楚地显示了状态 0(表示为 S0)与状态 1(表示为 S1)具有某种关系。那关系如下图！
在(E)下，我们可以看到一个等式，它阐明了状态之间的关系。
当前状态 K =先前状态 K * Wrec +当前输入 X * Wx
这条数学线是状态 0 和状态 1 之间的关系。但是每个州下面的数字呢？很简单，这些是每个状态的输入，所以在状态 1，输入 x 是一个向量[0，0，1]。
Same Color Box indicate inputs at each state
你可能会问，状态 0 呢？大问题他们全是零！
所以让我们用数学来弄脏——前馈。
就是这样！我们完成了前馈传播。另外，还有一点需要注意的是，我们将使用 MSE 作为成本函数，从现在开始，我们将只使用星号旁边的符号来表示成本函数。(抱歉我不是数学专业的，我不知道那个符号叫什么。)
现在让我们通过时间执行反向传播。我们必须对每个状态的 Wx 和 Wrec 求导。而这正是我们下面所做的！
原来如此！训练 RNN 背后的简单数学。但是，尽量自己填状态 1。但是有一个有趣的事实需要注意，当得到 Wx 和 Wrec 的导数时，有很多数学符号会随着时间的推移而重复出现，请看下图。
在矩阵中得到那些重复的值，并在以后通过乘以适当的 X 或 State 来使用它们，这在计算上会更有效。这正是我在视频教程中所做的！
Calculate the repeating terms
另一个需要注意的重要事情是，当我们得到导数时，我们要乘以 Wrec 的倍数，换句话说，变量起着关键作用！(我不打算进一步解释，但这个话题很重要！)
最后，让我们通过随机梯度下降来执行权重更新。
在右上角，我们相应地将各项相加，并执行 SGD。
更新！下面是第二部分: [链接](http://Only Numpy: Vanilla Recurrent Neural Network Deriving Back propagation Through Time Practice — part 1/2)
最后提醒一下，我用了很多彼得的素材！请点击下面的链接查看这个令人惊奇的教程！这是我的第一篇帖子，我仍在学习如何制作优秀的教程，任何反馈都将是有益的！
【请客气:’(]谢谢！
关于人工智能、机器学习、神经网络的笔记和代码样本
peterroelants.github.io](http://peterroelants.github.io/posts/rnn_implementation_part01/#Updating-the-parameters)
更多教程请查看我的网站和我的 Youtube 频道！
YouTube 频道:https://www.youtube.com/c/JaeDukSeo
[## 宰德徐- DJ 徐
嗨，我叫 Jae，我爱机器学习，请进来看看吧！数据科学家 Jae 的个人网站…
jaedukseo.me](https://jaedukseo.me/) [## 宰德徐
你好！我叫 Jae，这是我的 youtube 频道。我喜欢狗和人工智能，医疗保健和区块链…
www.youtube.com](https://www.youtube.com/channel/UCf5jue1EwgWrYw9bjTynV4g/featured?view_as=subscriber)
本体论和数据科学
对现有数据的研究如何帮助我们成为更好的数据科学家。
Photo by Valentin Antonucci from Pexels
如果你是本体这个词的新手，不要担心，我将给出它是什么的初级读本，以及它对数据世界的重要性。我将明确哲学本体论和与计算机科学中的信息和数据相关的本体论之间的区别。
本体论(哲学部分)
简而言之，人们可以说本体论是对现有事物的研究。但是这个定义的另一部分将在下面的章节中帮助我们，那就是本体通常也被认为包含了关于存在的实体的最一般的特征和关系的问题。
存在论为存在者打开了新的大门。我给你举个例子。
量子力学开启了对现实和自然界“存在”什么的新观点。对于 1900 年代的一些物理学家来说，量子形式主义中根本不存在现实。在另一个极端，有许多量子物理学家持截然相反的观点:单一演化的量子态完全描述了真实的现实，这意味着几乎所有的量子选择都必须继续共存(叠加)。从而让整个世界对自然界中“存在”的“事物”有了新的认识和理解。
但是让我们回到定义中的实体关系部分。有时当我们谈论实体及其关系时，本体论被称为形式本体论。这些理论试图给出某些实体的属性和关系的精确数学公式。这种理论通常提出关于这些问题实体的公理，用基于某种形式逻辑系统的某种形式语言来阐明。
这将允许我们做一个量子跳跃到文章的下一部分。
本体(信息和计算部分)
如果我们从上面带回形式本体论的定义，然后我们想到数据和信息，就有可能建立一个框架来研究数据及其与其他数据的关系。在这个框架中，我们以一种特别有用的方式来表示信息。以特定的形式本体表示的信息可以更容易地被自动化信息处理所访问，如何最好地做到这一点是像数据科学这样的计算机科学中的一个活跃的研究领域。这里使用的形式本体是具象。它是一个表示信息的框架，因此，无论实际上使用的形式理论是否真正描述了实体的领域，它在表示上都是成功的。
现在是一个很好的机会来看看本体如何在数据科学世界中帮助我们。
如果你还记得我上一篇关于语义技术的文章:
深度学习现在无处不在，在你的手表里，在你的电视里，在你的电话里，在某种程度上，在你的平台上…
towardsdatascience.com](/deep-learning-for-the-masses-and-the-semantic-layer-f1db5e3ab94b)
我谈到了关联数据的概念。链接数据的目标是以一种易于使用和与其他链接数据组合的方式发布结构化数据。我还讨论了知识图的概念，它包含数据和信息的集成集合，还包含不同数据之间的大量链接。
所有这些定义中缺失的概念是本体论。因为这是我们连接实体和理解它们之间关系的方式。有了本体，我们可以实现这样的描述，但首先我们需要正式地指定组件，如个体(对象的实例)、类、属性和关系，以及限制、规则和公理。
下面是解释上述段落的一种象形方法:
https://www.ontotext.com/knowledgehub/fundamentals/what-are-ontologies/
数据库建模和本体
目前，大多数采用数据建模语言(如 SQL)的技术都是按照严格的“构建模型，然后使用模型”的思维方式设计的。
例如，假设您想要更改关系数据库中的属性。你以前认为财产是单值的，但现在它需要多值。对于几乎所有的现代关系数据库，这种改变需要您删除该属性的整个列，然后创建一个全新的表来保存所有这些属性值和一个外键引用。
这不仅工作量很大，而且还会使任何处理原始表的索引失效。它还会使用户编写的任何相关查询无效。简而言之，做出这样的改变是非常困难和复杂的。通常情况下，这样的改变是如此的麻烦，以至于根本就没有进行过。
相比之下，本体语言中的所有数据建模语句(以及其他所有东西)本质上都是增量的。事后增强或修改数据模型可以很容易地通过修改概念来实现。
从 RDBS 到知识图谱
到目前为止，我发现将您的数据湖转换为智能数据湖的最简单的框架是 Anzo。这样，您就可以向完全连接的企业数据结构迈出第一步。
数据结构是支持公司所有数据的平台。它是如何被管理、描述、组合和普遍访问的。该平台由企业知识图构成，以创建统一的数据环境。
这种数据结构的形成首先需要在你所拥有的数据之间创建本体。这种转变也可以认为是从传统数据库到图形数据库+语义的转变。
根据剑桥语义公司的这个展示,图形数据库有用有三个原因:
- 图形数据库产品在功能和多样性方面越来越成熟
- 图形的应用已经超越了经典的图形问题
- 复杂数据的数字转换需要图形
因此，如果您将这种优势与建立在本体上的语义层联系起来，您可以从拥有这样的数据开始:
https://www.slideshare.net/camsemantics/the-year-of-the-graph
对此
https://www.slideshare.net/camsemantics/the-year-of-the-graph
其中有一种人类可读的数据表示，可以用常见的业务术语唯一地标识和连接数据。这一层帮助最终用户自主、安全、自信地访问数据。
然后，您可以创建复杂的模型来发现不同数据库中的模式。
https://www.slideshare.net/camsemantics/the-year-of-the-graph
在其中，你有代表实体间关系的本体。也许这样一个本体论的例子在这里会很好。这是从
本体和语义技术再次流行起来。它们是 21 世纪初的热门话题，但是…
enterprise-knowledge.com](https://enterprise-knowledge.com/what-is-an-ontology/)
让我们创建一个关于您的员工和顾问的本体:
在本例中，Kat Thomas 是一名顾问，他正在与 Bob Jones 合作一个销售流程重新设计项目。凯特在咨询公司工作，鲍勃向爱丽丝·雷迪汇报工作。我们可以通过这个本体推断出很多信息。由于销售流程重新设计是关于销售的，我们可以推断 Kat Thomas 和 Bob Jones 在销售方面有专长。咨询公司也必须提供这方面的专业知识。我们还知道 Alice Reddy 可能负责 Widgets，Inc .的某个方面的销售，因为她的直接下属正在从事销售流程重新设计项目。
当然，您可以在带有主键的关系数据库中使用它，然后创建几个连接来获得相同的关系，但这更直观，也更容易理解。
令人惊奇的是，Anzo 将连接到您的数据湖(意味着 HDFS 或甲骨文或其他公司内部的大量数据),并自动为您创建这个图表！然后你可以自己去添加或者改变本体。
数据科学的未来(只有明年 lol)
在本文中:
[## 人工智能，数据科学，分析 2018 年的主要发展和 2019 年的主要趋势
和过去一样，我们为您带来专家的预测和分析综述。我们问了主要的是什么…
www.kdnuggets.com](https://www.kdnuggets.com/2018/12/predictions-data-science-analytics-2019.html)
我谈到了未来几年数据科学(可能)会发生什么。
对我来说，2019 年的主要趋势是:
- AutoX:我们将看到更多的公司开发并在其栈技术和库中包含自动机器和深度学习。这里的 X 表示这个自动化工具将扩展到数据摄取、数据集成、数据清理、探索和部署。自动化将会继续存在。
- 语义技术:今年对我来说最有趣的发现是 DS 和语义之间的联系。这在数据世界中并不是一个新的领域，但是我看到越来越多的人对语义、本体、知识图及其与 DS 和 ML 的联系感兴趣。
- 编程更少:这很难说，但是随着 DS 过程中几乎每一步的自动化，我们每天的编程会越来越少。我们将拥有创建代码的工具，这些工具将理解我们想要 NLP 做什么，然后将其转化为查询、句子和完整的程序。我觉得[编程]还是一个很重要的东西要学，但是很快就会更容易了。
这是我写这篇文章的原因之一，试图跟踪整个行业正在发生的事情，你应该意识到这一点。在不久的将来，我们将减少编程，更多地使用语义技术。更接近我们的思考方式。我的意思是你认为在关系数据库？我并不是说我们用图表来思考，但是在我们的头脑和知识图表之间传递信息要比创建怪异的数据库模型容易得多。
对这个有趣的话题，我期待更多。如果您有任何建议，请告诉我:)
如果您有任何问题，请在 Twitter 上关注我:
Favio Vázquez 的最新推文(@FavioVaz)。数据科学家。物理学家和计算工程师。我有一个…
twitter.com](https://twitter.com/faviovaz)
和 LinkedIn:
[## favio vázquez——science ia y Datos | LinkedIn 创始人
查看 Favio Vázquez 在世界上最大的职业社区 LinkedIn 上的个人资料。Favio 有 16 个工作列在他们的…
www.linkedin.com](https://www.linkedin.com/in/faviovazquez/)
那里见:)
用于 SD-WAN 链接选择的开放 AI 健身房
Credit: NVIDIA blog (https://blogs.nvidia.com/blog/2018/04/30/nvail-deep-learning-iclr/
强化学习已经成功地应用于机器人和玩电脑游戏。它在网络领域中的应用令人鼓舞，用于解决无线接入网络中的资源分配(Comsa 等人)，用于优化 WAN 和资源(Xiu 等人)，用于 SDN 中的路由优化(Stampa 等人)，并且该列表还在不断增长。在这篇文章中，我试图探索用强化学习来解决 SD-WAN 网络中一个非常相关的问题，即链路选择的想法。链路选择是 SD-WAN 解决方案的关键组成部分，是其解决方案的核心。在应用强化学习之前，需要模拟 SD-WAN 环境，以便 RL 算法通过反复试验来学习最佳行为。传统上，这些模拟被称为健身房，这是 openAI (gym.openai.com)创造的一个术语。在这篇文章中，我提出了如何编写一个 gym 来解决 SD-WAN 链路选择实验的想法。在这个体育馆上应用不同 RL 算法的结果将在后续文章中给出。
什么是 SD-WAN
软件定义的广域网(SD-WAN)提供了一种基于软件的覆盖架构，该架构基于传统广域网硬件上的软件定义的网络(SDN)技术。这简化了网络管理，将控制层移至云端，实现了网络虚拟化。(参考: sdxcentral )
SD-WAN 在分支机构站点和企业数据中心之间提供两条或多条备用路径，如下所示。动态成本优化来自于将流量从私有 MPLS 云切换到更便宜的公共互联网服务。对于 SD-WAN 网络而言，如何决定何时进行链路切换以及切换频率至关重要。进行关于 QOS 参数的连续测量来得出这个决定。(参考: JuniperNetworks )
Credit: https://www.sdxcentral.com/sd-wan/definitions/essentials-sd-wan-architecture/
什么是强化学习及其在 SD-WAN 中的应用
强化学习是一种机器学习，其中代理正在学习如何通过试验环境提供的各种选项来最好地利用周围环境。通过尝试不同的行动，代理人学会优化他从环境中获得的回报。(reinforcementlearning.ai-depot.com)
下图描述了典型的强化学习设置。代理正在与环境交互并尝试不同的动作。环境保持其状态，并由于与代理的交互而经历不同的状态变化，并提供回报。每一个强化学习系统都有一个目标，代理人通过试错来学习实现目标。代理的目标是通过学习一组最优动作来最大化这种回报。
Credit: Sutton and Barto
这种强化学习与 SD-WAN 的相关性可以通过一个实验来思考，在该实验中，代理正在切换 WAN 链路并试图最大化带宽利用率。这是通过在有足够带宽可用时切换到互联网云，然后在 QOS 数量开始下降时切换回 MPLS 来实现的。如何实现这种链路交换，从而以最小的 MPLS 链路利用率获得最佳带宽是目标。
开放式人工智能健身房
Gym 是一个工具包，它为代理提供了一个平台，让他们在定制的环境中尝试和学习最佳行为。有像“翻筋斗”、“钟摆”和“山地车”等游乐场。
与健身房的典型互动如下所示
import gym env = gym.make('CartPole-v0')
env.reset()
for _ in range(1000):
env.render()
env.step(env.action_space.sample()) *# take a random action*
上面的每一步都返回四个值。这些是
1)“观察”——这实质上是捕捉环境的状态。
2)“奖励”——通过“行动”获得的衡量奖励。
3)“完成”——剧集是否完成
4)‘信息’—杂项信息
(更多见 https://gym.openai.com/docs/
SD-WAN 的环境
任何健身房都是一个模拟环境，代理人可以尝试不同的动作并获得奖励。对于 SD-WAN，我们需要模拟所谓的“分支机构”和“总部”之间的 WAN 网络。在这个简化的网络中，存在两条备用路径，一条经由专用 MPLS 电路，另一条经由公共互联网。对于网络模拟，存在不同的技术，如 NS3、mininet 等。我选择 mininet 是因为它的简单性和对 SDN 应用的适用性。(更多信息见 mininet.org)。
在下面的设计中，我们有两个路由器 R1 和 R2，分别代表分支边缘路由器和总部边缘。
核心路由器 C1 代表 MPLS 路径，C2 代表公共互联网。目标是将流量从分支机构的主机 H1 发送到总部的主机 H2。我们还从主机 N1 向 N2 发送额外的流量，这模拟了互联网专用路径中的其它流量。
对环境的观察(或状态)
我选择了以下任一时间点的实验状态(‘打勾’)。请注意，这些是在实验开始时以及代理采取任何“行动”时的任何“步骤”中测量的。
1)当前带宽——通过任何路径(如 MPLS 或公共互联网)获得的带宽量
2)可用带宽—这是互联网云中可用的带宽。假设 MPLS 路径有足够的带宽来满足任何需求。
3)链路 Id——在任何时刻传输流量的链路。
尽管像“延迟”和“抖动”这样的 QOS 参数在 SLA 管理中起着很大的作用，但我并没有从这里开始考虑它们。这些将在以后添加，以增强模型的实际用途。
行动
该代理的动作将是在 MPLS 和因特网之间进行选择。有两个独立的操作—链路 0(互联网)和链路 1 (MPLS)。任何动作及其状态转换都没有随机性。一条链路到另一条链路的切换是确定性的。
奖励设计
奖励是设计的关键部分，强化学习算法的性能在很大程度上依赖于奖励的设计方式。在设计奖励时，我必须牢记系统的目标。这里，SD-WAN 的目标是最大化互联网路径的带宽利用率，这是一个更便宜的选择。以下是设计奖励时要牢记的一些原则——
1)必须不惜任何代价维持 SLA，因此当前达到的带宽应该总是超过 SLA 规定的限制。当带宽低于 SLA 限制时，奖励应该被设计成严厉惩罚这样的失误。
- MPLS 电路不是成本有效的，因此奖励应该阻止它的使用
3)上述的另一面是，互联网电路应该更经常地被使用。
4)无论做出何种选择，目标都是维持交通流量。所以每次‘滴答’都应该带来最小的正回报。
插曲
强化学习的实验有一个插曲的概念，意思是当实验或游戏被获胜的一方结束时。在 SD_WAN 的这个实验中，没有赢的这回事。数据传输可以无限期地进行，但是为了实验的目的，已经设计了最大滴答的人为限制。当“滴答”的次数超过这个限制时，就认为该事件结束了。
这一集还有另一种结束方式，那就是错误。每当连续两个时间“滴答”未满足 SLA 带宽时，就判定该事件已经结束，代理必须重新开始。
履行
SD_WAN 健身房已经使用 OpenAI 提供的指南实现(这里是关于如何实现定制健身房的信息—https://github . com/open ai/gym/tree/master/gym/envs # how-to-create-new-environments-for-gym)
SD-WAN 健身房代码已在 github(【https://github.com/amitnilams/sdwan-gym】T2)签到
一些简单的实验已经在健身房进行，以设定一些基线。像“深度 Q 学习”或“演员评论”这样的高级算法应该应用于这些基线。这个健身房的一个局限是它仍然是单代理环境。它不能用于多代理算法 A3C 算法。
确定性实验
对于确定性情况，只要当前带宽低于 SLA 限制，我们就需要选择 MPLS 电路。SLA 限制是环境的一部分，不会通过“观察”或状态来揭示。换句话说，这个实验知道这个模型的一切，以及奖励是如何设计的，等等。在选择行动的算法中没有随机性。这是一集的一些输出(最大滴答数= 30)
2018-12-06 11:28:40,296 - root - INFO - SdwanEnv - Version 0.1.0
('Initial State:', (0, '11.0', 0.0))
2018-12-06 11:29:11,627 - root - INFO - current bw:10.0, sla bw:6.0
('Ticks:', 1, 'Action:', 1, 'Ob:', (1, 10.0, 5.09), 'R:', -1, 'Total Reward:', -1)
2018-12-06 11:29:26,655 - root - INFO - current bw:10.0, sla bw:6.0
('Ticks:', 2, 'Action:', 1, 'Ob:', (1, 10.0, 3.3899999999999997), 'R:', -1, 'Total Reward:', -2)
2018-12-06 11:29:41,680 - root - INFO - current bw:10.0, sla bw:6.0
('Ticks:', 3, 'Action:', 1, 'Ob:', (1, 10.0, 6.34), 'R:', -1, 'Total Reward:', -3)
2018-12-06 11:29:56,719 - root - INFO - current bw:4.94, sla bw:6.0
2018-12-06 11:29:56,719 - root - INFO - BW is less than SLA
('Ticks:', 4, 'Action:', 0, 'Ob:', (0, '4.94', 4.19), 'R:', -4, 'Total Reward:', -7)
2018-12-06 11:30:11,768 - root - INFO - current bw:10.0, sla bw:6.0
('Ticks:', 5, 'Action:', 1, 'Ob:', (1, 10.0, 4.73), 'R:', -1, 'Total Reward:', -8)
2018-12-06 11:30:26,794 - root - INFO - current bw:10.0, sla bw:6.0
('Ticks:', 6, 'Action:', 1, 'Ob:', (1, 10.0, 5.34), 'R:', -1, 'Total Reward:', -9)
2018-12-06 11:30:41,820 - root - INFO - current bw:10.0, sla bw:6.0
('Ticks:', 7, 'Action:', 1, 'Ob:', (1, 10.0, 8.05), 'R:', -1, 'Total Reward:', -10)
2018-12-06 11:30:56,889 - root - INFO - current bw:7.76, sla bw:6.0
('Ticks:', 8, 'Action:', 0, 'Ob:', (0, '7.76', 6.2), 'R:', 2, 'Total Reward:', -8)
2018-12-06 11:31:11,915 - root - INFO - current bw:6.36, sla bw:6.0
('Ticks:', 9, 'Action:', 0, 'Ob:', (0, '6.36', 5.27), 'R:', 2, 'Total Reward:', -6)
2018-12-06 11:31:26,963 - root - INFO - current bw:10.0, sla bw:6.0
('Ticks:', 10, 'Action:', 1, 'Ob:', (1, 10.0, 6.77), 'R:', -1, 'Total Reward:', -7)
2018-12-06 11:31:42,018 - root - INFO - current bw:5.92, sla bw:6.0
2018-12-06 11:31:42,018 - root - INFO - BW is less than SLA
('Ticks:', 11, 'Action:', 0, 'Ob:', (0, '5.92', 4.89), 'R:', -4, 'Total Reward:', -11)
2018-12-06 11:31:57,045 - root - INFO - current bw:10.0, sla bw:6.0
('Ticks:', 12, 'Action:', 1, 'Ob:', (1, 10.0, 7.029999999999999), 'R:', -1, 'Total Reward:', -12)
2018-12-06 11:32:12,113 - root - INFO - current bw:4.80, sla bw:6.0
2018-12-06 11:32:12,114 - root - INFO - BW is less than SLA
('Ticks:', 13, 'Action:', 0, 'Ob:', (0, '4.80', 4.15), 'R:', -4, 'Total Reward:', -16)
2018-12-06 11:32:27,196 - root - INFO - current bw:10.0, sla bw:6.0
('Ticks:', 14, 'Action:', 1, 'Ob:', (1, 10.0, 4.4), 'R:', -1, 'Total Reward:', -17)
2018-12-06 11:32:42,219 - root - INFO - current bw:10.0, sla bw:6.0
('Ticks:', 15, 'Action:', 1, 'Ob:', (1, 10.0, 6.029999999999999), 'R:', -1, 'Total Reward:', -18)
2018-12-06 11:32:57,263 - root - INFO - current bw:7.21, sla bw:6.0
('Ticks:', 16, 'Action:', 0, 'Ob:', (0, '7.21', 6.91), 'R:', 2, 'Total Reward:', -16)
2018-12-06 11:33:12,279 - root - INFO - current bw:4.68, sla bw:6.0
2018-12-06 11:33:12,280 - root - INFO - BW is less than SLA
('Ticks:', 17, 'Action:', 0, 'Ob:', (0, '4.68', 3.7800000000000002), 'R:', -4, 'Total Reward:', -20)
2018-12-06 11:33:27,321 - root - INFO - current bw:10.0, sla bw:6.0
('Ticks:', 18, 'Action:', 1, 'Ob:', (1, 10.0, 6.720000000000001), 'R:', -1, 'Total Reward:', -21)
2018-12-06 11:33:42,360 - root - INFO - current bw:9.54, sla bw:6.0
('Ticks:', 19, 'Action:', 0, 'Ob:', (0, '9.54', 8.15), 'R:', 2, 'Total Reward:', -19)
2018-12-06 11:33:57,388 - root - INFO - current bw:4.12, sla bw:6.0
2018-12-06 11:33:57,388 - root - INFO - BW is less than SLA
('Ticks:', 20, 'Action:', 0, 'Ob:', (0, '4.12', 3.51), 'R:', -4, 'Total Reward:', -23)
2018-12-06 11:34:12,416 - root - INFO - current bw:10.0, sla bw:6.0
('Ticks:', 21, 'Action:', 1, 'Ob:', (1, 10.0, 2.5700000000000003), 'R:', -1, 'Total Reward:', -24)
2018-12-06 11:34:27,441 - root - INFO - current bw:10.0, sla bw:6.0
('Ticks:', 22, 'Action:', 1, 'Ob:', (1, 10.0, 6.33), 'R:', -1, 'Total Reward:', -25)
2018-12-06 11:34:42,478 - root - INFO - current bw:8.97, sla bw:6.0
('Ticks:', 23, 'Action:', 0, 'Ob:', (0, '8.97', 7.57), 'R:', 2, 'Total Reward:', -23)
2018-12-06 11:34:57,505 - root - INFO - current bw:6.57, sla bw:6.0
('Ticks:', 24, 'Action:', 0, 'Ob:', (0, '6.57', 5.42), 'R:', 2, 'Total Reward:', -21)
2018-12-06 11:35:12,538 - root - INFO - current bw:10.0, sla bw:6.0
('Ticks:', 25, 'Action:', 1, 'Ob:', (1, 10.0, 3.84), 'R:', -1, 'Total Reward:', -22)
2018-12-06 11:35:27,564 - root - INFO - current bw:10.0, sla bw:6.0
('Ticks:', 26, 'Action:', 1, 'Ob:', (1, 10.0, 4.27), 'R:', -1, 'Total Reward:', -23)
2018-12-06 11:35:42,582 - root - INFO - current bw:10.0, sla bw:6.0
('Ticks:', 27, 'Action:', 1, 'Ob:', (1, 10.0, 2.95), 'R:', -1, 'Total Reward:', -24)
2018-12-06 11:35:57,606 - root - INFO - current bw:10.0, sla bw:6.0
('Ticks:', 28, 'Action:', 1, 'Ob:', (1, 10.0, 6.49), 'R:', -1, 'Total Reward:', -25)
2018-12-06 11:36:12,646 - root - INFO - current bw:6.90, sla bw:6.0
('Ticks:', 29, 'Action:', 0, 'Ob:', (0, '6.90', 5.69), 'R:', 2, 'Total Reward:', -23)
2018-12-06 11:36:27,681 - root - INFO - current bw:10.0, sla bw:6.0
('Ticks:', 30, 'Action:', 1, 'Ob:', (1, 10.0, 5.34), 'R:', -1, 'Total Reward:', -24)
Episode finished after 30 timesteps
随机实验
这个实验的逻辑很简单。它对奖励是如何设计的一无所知，随机尝试一个动作，并希望得到最好的结果。以下是典型剧集的一些输出(最大滴答数= 30)
2018-12-06 11:38:11,893 - root - INFO - SdwanEnv - Version 0.1.0
('Initial State:', (0, '10.3', 0.0))
2018-12-06 11:38:43,886 - root - INFO - current bw:5.96, sla bw:6.0
2018-12-06 11:38:43,887 - root - INFO - BW is less than SLA
('Ticks:', 1, 'Action:', 0, 'Ob:', (0, '5.96', 5.09), 'R:', -4, 'Total Reward:', -4)
2018-12-06 11:38:58,917 - root - INFO - current bw:10.0, sla bw:6.0
('Ticks:', 2, 'Action:', 1, 'Ob:', (1, 10.0, 3.3899999999999997), 'R:', -1, 'Total Reward:', -5)
2018-12-06 11:39:13,947 - root - INFO - current bw:10.0, sla bw:6.0
('Ticks:', 3, 'Action:', 1, 'Ob:', (1, 10.0, 6.34), 'R:', -1, 'Total Reward:', -6)
2018-12-06 11:39:28,986 - root - INFO - current bw:5.08, sla bw:6.0
2018-12-06 11:39:28,987 - root - INFO - BW is less than SLA
('Ticks:', 4, 'Action:', 0, 'Ob:', (0, '5.08', 3.9299999999999997), 'R:', -4, 'Total Reward:', -10)
2018-12-06 11:39:44,027 - root - INFO - current bw:10.0, sla bw:6.0
('Ticks:', 5, 'Action:', 1, 'Ob:', (1, 10.0, 4.73), 'R:', -1, 'Total Reward:', -11)
2018-12-06 11:39:59,049 - root - INFO - current bw:10.0, sla bw:6.0
('Ticks:', 6, 'Action:', 1, 'Ob:', (1, 10.0, 5.34), 'R:', -1, 'Total Reward:', -12)
2018-12-06 11:40:14,080 - root - INFO - current bw:10.0, sla bw:6.0
('Ticks:', 7, 'Action:', 1, 'Ob:', (1, 10.0, 8.05), 'R:', -1, 'Total Reward:', -13)
2018-12-06 11:40:29,105 - root - INFO - current bw:10.0, sla bw:6.0
('Ticks:', 8, 'Action:', 1, 'Ob:', (1, 10.0, 6.2), 'R:', -1, 'Total Reward:', -14)
2018-12-06 11:40:44,134 - root - INFO - current bw:10.0, sla bw:6.0
('Ticks:', 9, 'Action:', 1, 'Ob:', (1, 10.0, 5.27), 'R:', -1, 'Total Reward:', -15)
2018-12-06 11:40:59,159 - root - INFO - current bw:10.0, sla bw:6.0
('Ticks:', 10, 'Action:', 1, 'Ob:', (1, 10.0, 6.77), 'R:', -1, 'Total Reward:', -16)
2018-12-06 11:41:14,184 - root - INFO - current bw:10.0, sla bw:6.0
('Ticks:', 11, 'Action:', 1, 'Ob:', (1, 10.0, 4.89), 'R:', -1, 'Total Reward:', -17)
2018-12-06 11:41:29,221 - root - INFO - current bw:7.94, sla bw:6.0
('Ticks:', 12, 'Action:', 0, 'Ob:', (0, '7.94', 7.029999999999999), 'R:', 2, 'Total Reward:', -15)
2018-12-06 11:41:44,247 - root - INFO - current bw:5.32, sla bw:6.0
2018-12-06 11:41:44,248 - root - INFO - BW is less than SLA
('Ticks:', 13, 'Action:', 0, 'Ob:', (0, '5.32', 4.11), 'R:', -4, 'Total Reward:', -19)
2018-12-06 11:41:59,285 - root - INFO - current bw:10.0, sla bw:6.0
('Ticks:', 14, 'Action:', 1, 'Ob:', (1, 10.0, 4.4), 'R:', -1, 'Total Reward:', -20)
2018-12-06 11:42:14,315 - root - INFO - current bw:7.70, sla bw:6.0
('Ticks:', 15, 'Action:', 0, 'Ob:', (0, '7.70', 6.02), 'R:', 2, 'Total Reward:', -18)
2018-12-06 11:42:29,341 - root - INFO - current bw:8.24, sla bw:6.0
('Ticks:', 16, 'Action:', 0, 'Ob:', (0, '8.24', 6.92), 'R:', 2, 'Total Reward:', -16)
2018-12-06 11:42:44,366 - root - INFO - current bw:5.00, sla bw:6.0
2018-12-06 11:42:44,367 - root - INFO - BW is less than SLA
('Ticks:', 17, 'Action:', 0, 'Ob:', (0, '5.00', 4.11), 'R:', -4, 'Total Reward:', -20)
2018-12-06 11:42:59,396 - root - INFO - current bw:8.18, sla bw:6.0
('Ticks:', 18, 'Action:', 0, 'Ob:', (0, '8.18', 6.720000000000001), 'R:', 2, 'Total Reward:', -18)
2018-12-06 11:43:14,427 - root - INFO - current bw:8.55, sla bw:6.0
('Ticks:', 19, 'Action:', 0, 'Ob:', (0, '8.55', 8.15), 'R:', 2, 'Total Reward:', -16)
2018-12-06 11:43:29,463 - root - INFO - current bw:10.0, sla bw:6.0
('Ticks:', 20, 'Action:', 1, 'Ob:', (1, 10.0, 2.41), 'R:', -1, 'Total Reward:', -17)
2018-12-06 11:43:44,517 - root - INFO - current bw:3.87, sla bw:6.0
2018-12-06 11:43:44,518 - root - INFO - BW is less than SLA
('Ticks:', 21, 'Action:', 0, 'Ob:', (0, '3.87', 3.83), 'R:', -4, 'Total Reward:', -21)
2018-12-06 11:43:59,554 - root - INFO - current bw:10.0, sla bw:6.0
('Ticks:', 22, 'Action:', 1, 'Ob:', (1, 10.0, 6.33), 'R:', -1, 'Total Reward:', -22)
2018-12-06 11:44:14,580 - root - INFO - current bw:10.0, sla bw:6.0
('Ticks:', 23, 'Action:', 1, 'Ob:', (1, 10.0, 7.57), 'R:', -1, 'Total Reward:', -23)
2018-12-06 11:44:29,622 - root - INFO - current bw:6.88, sla bw:6.0
('Ticks:', 24, 'Action:', 0, 'Ob:', (0, '6.88', 5.42), 'R:', 2, 'Total Reward:', -21)
2018-12-06 11:44:44,658 - root - INFO - current bw:4.89, sla bw:6.0
2018-12-06 11:44:44,659 - root - INFO - BW is less than SLA
('Ticks:', 25, 'Action:', 0, 'Ob:', (0, '4.89', 4.53), 'R:', -4, 'Total Reward:', -25)
2018-12-06 11:44:59,730 - root - INFO - current bw:10.0, sla bw:6.0
('Ticks:', 26, 'Action:', 1, 'Ob:', (1, 10.0, 4.27), 'R:', -1, 'Total Reward:', -26)
2018-12-06 11:45:14,755 - root - INFO - current bw:10.0, sla bw:6.0
('Ticks:', 27, 'Action:', 1, 'Ob:', (1, 10.0, 2.95), 'R:', -1, 'Total Reward:', -27)
2018-12-06 11:45:29,781 - root - INFO - current bw:10.0, sla bw:6.0
('Ticks:', 28, 'Action:', 1, 'Ob:', (1, 10.0, 6.49), 'R:', -1, 'Total Reward:', -28)
2018-12-06 11:45:44,806 - root - INFO - current bw:10.0, sla bw:6.0
('Ticks:', 29, 'Action:', 1, 'Ob:', (1, 10.0, 5.69), 'R:', -1, 'Total Reward:', -29)
2018-12-06 11:45:59,844 - root - INFO - current bw:6.76, sla bw:6.0
('Ticks:', 30, 'Action:', 0, 'Ob:', (0, '6.76', 5.34), 'R:', 2, 'Total Reward:', -27)
Episode Finished after 30 timesteps
图表比较
确定性试验是每当因特网链路上的可用带宽超过 SLA 规定的值时进行链路切换。否则就是坚持 MPLS 链路的安全选项。从上面确定性试验的图表可以明显看出，每当链路切换到 MPLS 时，带宽上升到最大值，但回报变得平缓。
对于随机试验，没有这样的逻辑来跟踪互联网链路上的可用带宽。切换链接的选择是绝对随机的。从图中可以明显看出，即使互联网链路中有可用的带宽，由于其随机决策，它仍然坚持使用 MPLS 选项。然而，在这两种情况下，总报酬都没有上升趋势。相反，如下图所示，在两种情况下，它都迅速下降。
值得用其他更先进的算法，如“深度 Q 学习”或“A3C”来重新审视这些图表，并看看它们如何与这些基线保持平衡。这将在后续文章中讨论。
结论
软件定义网络有很大的潜力受益于各种机器学习算法的应用，而强化学习最有希望解决其一些核心问题。在这里，我们刚刚开始解决 SD-WAN 中的一个非常相关的问题，该问题有可能通过机器学习算法，特别是强化学习来解决。为了应用 RL 的原则，我们需要一个健身房来玩，我们创造了 SD-WAN 健身房。下一个挑战将是应用高级算法，如“深度 Q 学习”或“A3C ”,实际解决 SD-WAN 中链路选择的相关问题。
参考
Comsa，I. S .(未标明)。5G 无线接入网络中 QoS 驱动的调度— IEEE Xplore 。从 https://ieeexplore.ieee.org/document/8254926/取回
JuniperNetworks。(未注明)。 SLA 配置文件和 SD-WAN 策略概述。检索自https://www . juniper . net/documentation/en _ US/CSO 3.2/topics/concept/AP-config-app-SLA-profile-overview . html
reinforcementlearning.ai-depot.com(未标明)。从 http://reinforcementlearning.ai-depot.com/取回
sdxcentral。(未注明)。SD-WAN 架构的要点:优势和选择。检索自www . sdx central . com:https://www . sdx central . com/SD-wan/definitions/essentials-SD-wan-architecture/
斯坦福大学。一种用于软件定义网络路由优化的深度强化学习方法。从 https://arxiv.org/pdf/1709.07080.pdf取回
萨顿河(未标明)。从 http://incompleteideas.net/book/bookdraft2017nov5.pdf取回
休河(未标明)。工作负载工程:通过基于 RL 的工作负载放置优化广域网和 DC 资源。从 https://arxiv.org/pdf/1703.06967 取回
下一篇文章:
开放 API 塑造支付格局，创造大规模互联 API 经济
Source : Pixabay
应用编程接口或 API 指的是软件应用的各种组件之间或不同软件应用本身之间的一组通信方法。它们在转变组织内各种系统之间、金融行业参与者之间以及金融机构和其他行业(如电信、旅游等)之间的交互方面发挥着重要作用。
传统上，支付行业不仅对产品和服务的端到端交付，而且对用户体验都实施了严格的控制。互联网、智能手机和平板电脑的激增，加上向第三方支付提供商和金融科技公司开放市场以参与支付领域的监管压力，威胁到了传统的银行方法，迫使银行灵活地参与到动态的金融科技生态系统中。这种参与的关键促成因素是“开放 API”。
Image 1 — Banks can leverage multiple human touch-points
开放 API 战略是这种转变的核心，它使银行能够在数字革命中扮演更积极的角色，而不是一个边缘实体。
下图描述了一些用例，这些用例通过采用与传统银行相关的开放 API，帮助下一代支付公司颠覆了支付世界。
Image 2 — Open API Use Cases for Banks and Payment Providers
银行面临的挑战&支付提供商
大多数银行都处于 API 之旅的某个阶段。银行的 API 之旅放缓主要是因为主要业务利益相关者之间缺乏清晰的理解以及一些技术挑战。
银行正在努力确定可以利用开放 API 的正确业务功能和用例。大多数银行业专业人士对安全性都很偏执，而“开放”这个词立刻让银行家们担心 API 不安全，容易被黑客攻击，尽管他们的大多数担心都是毫无根据的。他们对与合作伙伴共享信息和数据以提供更好的客户体验持怀疑态度。消费者-生产者 API 经济中的这种文化不匹配导致缺乏来自各种利益相关者的承诺和支持
大多数核心银行系统都建立在几十年前的遗留基础设施上，这些基础设施在过去运行得非常好，但是它们与下一代技术的集成需要大量的资源带宽。任何实现传统现代化的努力都伴随着战略和技术挑战，这些挑战可能会给银行的运营和品牌声誉带来严重风险。
与部署在云上的 API 相关的安全性和故障转移机制仍然处于发展阶段，尽管它们在过去几年中已经走过了漫长的道路。2017 年 2 月 AWS S3 停机提醒银行，在 API 和云上有太多事情可能会出错，从而严重影响客户体验。
数据驱动方法&开放 API 采用框架
我们的观点是，银行和支付服务提供商应该对开放 API 采取“平衡”的采用方式。也不应该是盲目试验各种不相关用例的下意识反应，也不应该是“等待和观察”的选项。我们建议一个系统的数据驱动框架来评估和部署用例，该框架有三个基本支柱——部署框架、API 治理和价值实现&部署后监控。
Image 2 — Deployment Fraemwork
部署框架
收集数据*——*开始识别所有可能成为开放 API 候选者的业务用例。
评估维度 — 可以在两个维度上进行评估—业务价值和技术挑战
有序数据点可以被分配给三个领域的业务价值
客户体验
收入潜力
费用
同样，有序数据点也可以被分配用于跨领域的技术挑战
整合挑战
部署挑战
技能可用性
规格化&绘图 — 所有维度的数据都需要规格化，以便于绘制分析。然后可以将标准化数据绘制成二维图。
分割&部署 — 一旦我们有了绘制的数据，我们就可以开始将该区域分割成 4 个逻辑分区，这将有效地成为开放 API 的不同部署阶段。
Image 4 — Group Use Cases based on defined metrics and framework
API 治理
规划一个 API 治理流程，该流程定义了合作伙伴的入门要求、费率，并定义了确定是构建还是集成的标准。
创建一个利益相关者参与的持续反馈循环
创造一种协作文化，让人们讨论和解决集成问题。
价值实现和监控
企业必须持续监控已部署的 API 所产生的价值。因为维护这样的 API 的成本和风险超过了它的好处，所以淘汰不创造价值的 API 是合适的。
感谢阅读——如果你觉得这篇文章有趣并想保持联系，你可以在 Twitter 上找到我 这里 或Linkedin
2017 年西雅图开放数据日
3 月 4 日星期六是 2017 年的开放数据日。在西雅图，它悄悄靠近我们，没有人注意到，包括我自己。幸运的是，该市的公民技术倡导者坎迪斯·费伯(Candace Faber)参加了西雅图的一次公开集会，并引起了我们的注意。不想错过一个对一些公开数据感到厌烦的机会，我开始组织一个最后时刻的活动。
在民主数据成员扎克·穆勒的帮助下，一项计划形成了。我们选择了数据可视化作为这一天的主题，这感觉很有趣，适合一个简短的活动，也包括不同技术背景的人。后来，一些疯狂的电子邮件发送到潜在的场地，而国会山工具图书馆友好地让我们下午使用他们的工作室。现在，距离公开数据日还有四天倒计时，感觉完全可以控制。
我们没有时间计划一个完全结构化的活动，所以我们宣传下午是非结构化的黑客会议，以玩和策划开放数据。为了使活动尽可能公开，我们收集了一些材料和在线资源。这包括一页有用的链接，用于查找开放数据和开始可视化，以及挑选一些数据集。作为一个额外的奖励，我在旧货店搜寻物品来建立物理观想。
这一天吸引了形形色色的人群，他们愉快地闲聊了一下午。在西雅图也有一些关于开放数据的有趣讨论，许多参与者对来自该市的开放数据的质量发表了强烈的意见，这很棒。我们还谈到了许多人对要求公布更多数据的矛盾感受。城市确实提供了请求新数据集的途径，但是尽管我们都希望看到更多可用的数据集，但实际上很难确定我们想要访问什么。你可以考虑用大量的信息来描述一个城市的运作，甚至更多不太明显的信息。有时，我们想要构建或发现一些特定的东西，但作为一个公民，也很难想象哪些数据是可能获得的或有用的。与此同时，这座城市很难知道市民想要什么，或者将被授权创造什么。
Feedback on data.seattle.gov and its datasets from Open Data Day Seattle 2017 participants.
我下午的重点是拿出我带来的扑克筹码，用它们来可视化一些我们打印出来的小数据集。我们创建了关于城市规划许可申请的物理 3D 条形图，更重要的是关于猫和狗按邮政编码的分布。最棒的一点是有一些有趣的、切实的东西来集中讨论。没过多久，一群人就聚集在我们的宠物地图周围，讨论物理和社会指标，即养猫养狗的水平可能代表什么。
Some “physical data visualisations” using poker chips. Left: Numbers of cats (white) and dogs (red) by zip code in Seattle. Right: Building permit applications by type between 2006 and 2016 in Seattle. Something doesn’t seem quite right about those numbers…
最后，我从这次活动中学到了一些实用的东西:
- 向参加活动的人解释发生了什么事，以及他们如何参与进来，这很重要。对于组织者来说显而易见的事情，对于刚刚出现的人来说并不总是显而易见的。
- 如果可能，给人们一个机会向他人介绍自己，并与组织者分享他们的技能或当天的期望。
- 计划好各种活动。不是每个人都想坐下来黑 5 个小时。将一些结构化的研讨会时间与非结构化的工作时间混合在一起，似乎是这类活动的最佳选择。
- 人们安静并不意味着他们过得不好。几个人心满意足地在他们的笔记本电脑前坐了大半个下午，我觉得有点紧张。我内心的英国人说，任何这样做的人一定过得不好，但只是出于礼貌，什么也没说。事实上，情况正好相反，一些安静的参与者在结束时走过来告诉我，他们玩得很开心，想再做一次类似的事情。
我很乐意举办更多的开放数据和可视化研讨会，也许下次会有更多的计划和结构。与成年人或年轻人一起举办一个物理可视化研讨会，以一种平易近人的方式探索和理解现代世界中的数据，可能会非常有趣。
2018 开放数据日再见！
开放式学习依赖于非物质现象
Information is not a physical phenomenon but relies upon a system of interpretation.
在自发表’以来的短暂时间里，机器学习是开放式的吗？我一直在思考机器学习技术很可能能够进行开放式学习的想法。我提出，让节点明确成为自然选择对象的方法可能是一个合适的前进方向，但我越来越确定这不会起作用。我回溯的原因是，我不相信简单地使一个节点成为自私的适应度最大化代理就足以使它成为一个进化对象。就像我如何论证迷因对象被编码在大脑网络结构的配置中一样，我认为同样的问题也适用于我自己的建议。因此，我现在非常确信，自然选择和其他优化算法将会因为同样的原因产生(或失败)同样的效果。
像基因或迷因这样的物体的问题在于它们不是物理的东西。如果我将产生相同效果的所有 DNA 片段集合起来，我会发现 DNA 的每个功能单位都包含不同的 DNA 序列。基因不是被定义为任何特定的 DNA 序列，而是被定义为功能单位。用哲学术语来说，进化理论的相关基因不是物质“标记”，而是信息“类型”。或者，换句话说，基因(或模因)是语义内容的单位，而不是纯粹的语法对象。令人沮丧的是，这样做的后果是，基因将永远是编码的非物质或非物质的产物，不能像我之前暂时设想的那样直接放入网络。
然而，我认为我对当前网络架构固定性的批评仍然有效。我强烈主张在培训前对网络设置采取一种无政府主义的方法，尽可能少地给出指导性的限制，以便为创造性的解决方案留出空间。神经网络的这种子结构方法的理想是用具有少量隐藏节点的网络开始训练，并使隐藏节点能够按照某种选择增长、分裂或消亡。如果成功，这种子结构主义将消除对神经网络设计艺术的需要，使网络结构本身没有固定的总体形式限制，如层排列、宽度和深度，这些限制了节点如何连接。通过做更少的假设，子结构主义也许能够容纳更多不同的对象。
我仍然认为网络编码和对象之间的关系是一个重要的设计问题:我们希望网络具有独立自然选择(或优化)的进化对象，但它们不能直接编码到学习架构中。概念上的问题是，我们不应该把进化对象看作是“存在于”环境中的东西，相反，进化对象是从一个主体和它们的环境之间的关系中出现的。进化对象，作为语义内容的单位，是由一串语法(在环境中“存在”)和一个主体对语法的主观解释(在内部)之间的相互作用产生的。因此，从智能体的角度来看，一个物理事物只有在值得解释为一个对象(通过将语法解码为意义)的情况下，才会成为一个经历选择的进化对象。
从进化的角度来看，人们可以很好地想象，在一群智能体通过一组共享的语法-语义相互关系进行通信之前，智能体在本质上发明了一种特殊的语法来存储关于个人经验和学习的信息。这种特殊的语法会让代理人的行为反应成为未成熟的迷因——我的意思是指无法通过交流复制并在代理人之间传播的迷因。如果代理人可以发明(或内置)某种系统来评估他们在任务表现上的成功，这种迷因可以在代理人的头脑中经历自然选择。但我不清楚，一个外部观察者如何能够区分一个具有大量指导性本能或这种早期模因学习的主体的行为或神经模式。这是心理学中一个古老的问题，它导致动物行为学(动物行为的研究)采取激进的行为主义，保守地忽略了动物具有早期迷因所能提供的精神状态的可能性。但是，正如我在之前多次说过的，很少有动物的行为复杂到足以通过模因论进行分析。
当考虑机器时，原则上唯一的区别特征应该是表明机器正在利用心理语法来产生早期模因，即它们的行为应该非常灵活和有能力。在对当前形式的渐进式神经网络的数学进行进一步研究后，他们确实觉得在约束神经网络以保持整个网络中与先前训练相对应的部分方面相当“粗暴”。我仍然坚持认为，它们不同于灵活能力的模因形式。相反，正如我在本文前面所讨论的，子结构方法可能会产生必要的创造性，而不需要“硬编码”想要的结果。
但是，即使采取了亚结构的方法，我也不确定这是否足以产生不完整的迷因。我相信环境的复杂性扮演着极其重要的角色。如果环境非常简单，就没有理由为想法开发个人语法。语法首先是记忆的工具。语法不是有任何数量的模拟状态，而是创建一个明确的代码，可以用来存储学习的结果。
当你考虑儿童发展时，行为复杂性与语言发展的相关性并不是巧合(也见于相关病理学)。正如我在这里广泛使用的术语，语法主要指音素的动词语法，因为正是这种语法使思想能够被编码(不一定是字母，尽管这是编码的后期和重叠发展)。能够真正地自言自语，可以增强推理、自我意识等能力，这是学习的基础。毕竟，通过这样的心理功能来处理编码的想法，使得一个想法可以在内部选择过程中作为不成熟的迷因与另一个想法进行比较。与模因评估的本能系统相比，这种模因学习是特殊的，因为它将模因从基因中分离出来，并使模因能够相互评估。虽然基因可以播种到评估系统，迷因成为推理的最终仲裁者。
但是，在过于纠结于人类的例子之前，很明显，有许多人类知识是隐性的——这意味着它不能被推理或在人与人之间传播。这样的知识显然不是模因，尽管它可能属于模因的这种‘本能评价’范畴。我认为非模因论的解释更好，因为一旦隐性知识被遗忘，就没有“标签”或等同物使一个单位的隐性知识被重新获得。被遗忘的隐性知识不能通过记忆重新获得，而必须通过经验重建。因此，这样的知识在头脑中并没有真正的位置，因为它实际上是一种潜意识或运动可塑性。
根据行为控制的模因和塑料部分之间的这种区别，我们不应指望大脑是一个单一用途的思维机器，因为它涉及到如此多的其他身体控制，这些控制最好留给它们自己的设备，从呼吸到平衡。同样，我们不应该指望人工神经网络代表一个统一的模因推理系统，因为还有其他功能最好留给非模因过程，如可塑性。本质上，我们面临的问题是如何为机器学习代理设计环境，以促进具有模因品质的“心智模块”。最明显的变化是增加了学习环境和感觉运动系统的复杂性，使代理能够与学习环境进行交互。人工智能研究人员已经开始这样做了，特别是 DeepMind，他们不断增加他们的 DQN 代理在中玩的游戏的复杂性。但要知道这是否会像人们希望的那样有所回报还为时过早。
对于人工智能来说，这是一个非常有趣的时代，事情发展得如此之快。(事实上，我写帖子的当天就给自己回复了！)在我的困惑和回溯之后，我认为现有的技术很可能能够进行(开放式的)模因式学习，并将有力地支持两个关键领域的发展:1)像以前一样，给予机器更多的权力来设计它们自己的网络架构，以及 2)以新的重点，增加机器代理的环境和感觉运动者对这些环境的访问的复杂性。最后，我还要强烈重申“从本能到智能”的信息:你可以设计一台看起来通过复杂的“硬编码”本能网络的任务能力具有智能行为的机器，许多动物可能都有，但类似人类的智能行为有一些根本的不同，因为我们在变得智能之前就变得有知觉。机器学习的含义是，现有的技术将继续收集更多的奖杯，但人工智能确实需要一种仿生方法来改变正在生产的智能机器的联盟。制造一台具有模因能力的机器很可能是制造 AGI 的实际目标，但要知道如何设计 1)潜在模因智能体的适当子结构，以及 2)适当的环境，以实现智能体的模因潜力，仍然很棘手。
我对这个结论比我今天早些时候发布的更有信心，但是我很想听听你的想法和评论。感谢阅读！
从零开始开放健身房
从环境开发到训练有素的网络。
有很多工作和教程解释了如何使用 OpenAI Gym toolkit，以及如何使用 Keras 和 TensorFlow 来训练使用一些现有 OpenAI Gym 结构的现有环境。然而在本教程中，我将解释如何从头开始创建一个 OpenAI 环境，并在其上训练一个代理。
我还将解释如何创建一个模拟器来开发环境。该教程分为 4 个部分:问题陈述，模拟器，健身房环境和培训。
1 —问题陈述
这里提出的问题是基于我最后的毕业设计。目标是创造一个人工智能代理来控制船只在整个航道的航行。
如今，在受限水域(如航道和港口)中的航行基本上是基于飞行员对环境条件(如给定位置的风和水流)的了解。
Figure1: Ship accident
让我们说，人类仍然在犯错误，有时会花费数十亿美元，人工智能是一种可能的选择，可以应用于导航，以减少事故的数量。
2 —模拟器
为了创造一个人工智能代理来控制一艘船，我们需要一个人工智能代理可以执行导航体验的环境，并通过自己的错误来学习如何正确地在整个航道中导航。此外，因为我们不能使用真实的船只来训练 AI 智能体，所以最好的替代方法是使用模拟器来模拟真实世界船只的动力学行为。为此，我们可以使用现有的商业软件(付费选项)，，但在本教程中，我们将创建我们自己的船舶模拟器。
为了做到这一点，一些假设被采用，如:船舶是一个刚体，唯一的外力驱动船舶是水阻力(没有风，没有水流)，此外，推进和舵控制力被用来控制方向和速度的船舶。控制船舶动力学的完整方程很复杂，可以在参考文献[1]中找到。这里我们将使用一个非常简单的 3DOF 模型，如下所示:
在该图中， u 是船相对于固定在船 CG 上的框架的纵向速度， v 是吃水速度， dψ/dt 是相对于固定参照物的角速度， ψ 是相对于固定框架 OXY 测量的船的攻角。速度 U，V (固定框架)通过 2x2 旋转矩阵链接 T10U，v 。φ是相对于如图所示的移动框架测得的舵角。
阻力和推进力的公式超出了本教程的范围，但是，总而言之，阻力与船的运动方向相反，与船的速度成正比。方向舵和推进力与[1，1]中的参数 Al 和 [0，1]中的参数 Ap 成比例。这些参数与舵角和推进力(Tp)成正比。注意，Al 和 Ap 是可控参数，因此:
现在我们有了模型微分方程，我们可以使用一个积分器来建立我们的模拟器。让我们写下我们的模拟器。
- 第一步:模拟器方程式。写出上面的等式，分离出加速度项，我们得到:
def simulate_scipy(self, t, global_states):
local_states = self._global_to_local(global_states)
return self._local_ds_global_ds(global_states[2], self.simulate(local_states))
def simulate(self, local_states):
*"""
:param local_states: Space state
:return df_local_states
"""* x1 = local_states[0] # u
x2 = local_states[1] # v
x3 = local_states[2] # theta (not used)
x4 = local_states[3] # du
x5 = local_states[4] # dv
x6 = local_states[5] # dtheta
Frx, Fry, Frz = self.compute_rest_forces(local_states)
# Propulsion model
Fpx, Fpy, Fpz = self.compute_prop_forces(local_states)
# Derivative function
fx1 = x4
fx2 = x5
fx3 = x6
# main model simple
fx4 = (Frx + Fpx) / (self.M)
fx5 = (Fry + Fpy) / (self.M)
fx6 = (Frz + Fpz) / (self.Iz)
fx = np.array([fx1, fx2, fx3, fx4, fx5, fx6])
return fx
在前 6 行中，我们只定义了变量名从 x1 到 x6 ， beta 和 alpha 是用于控制方向舵和推进控制的控制常数，在我们计算阻力并最终分离出导数项 fx1，fx2 …，fx6 后，我们得出:
- **第二步:积分器。**作为模拟的积分器，我们使用 scipy 库的 5 阶龙格-库塔积分器。
from scipy.integrate import RK45
我们定义一个函数，它使用 scipy RK45 来整合一个函数 fun 使用一个起点 y0 。从 t0 到 t_bound 进行积分，相对公差 rtol 和绝对公差 atol 。
def scipy_runge_kutta(self, fun, y0, t0=0, t_bound=10):
return RK45(fun, t0, y0, t_bound, rtol=self.time_span/self.number_iterations, atol=1e-4)
因为我们使用全局参考(OXY)来定位船只，使用局部参考来积分方程(oxyz)，所以我们定义了一个“掩码”函数用于积分器。该功能主要将函数模拟中输出的差分向量转换为全局参考。
def simulate_scipy(self, t, global_states):
local_states = self._global_to_local(global_states)
return self._local_ds_global_ds(global_states[2], self.simulate(local_states))
- Step3:步进功能
每走一步，我们都要经过一个方向舵( angle_level) 和一个旋转杠杆( rot_level )来控制推进装置传递的推力。
def step(self, angle_level, rot_level):
self.current_action = np.array([angle_level, rot_level])
while not (self.integrator.status == 'finished'):
self.integrator.step()
self.last_global_state = self.integrator.y
self.last_local_state = self._global_to_local(self.last_global_state)
self.integrator = self.scipy_runge_kutta(self.simulate_scipy, self.get_state(), t0=self.integrator.t, t_bound=self.integrator.t+self.time_span)
return self.last_global_state
在第一行中，我们存储当前动作向量，在第二行中，我们使用 RK45*self . integrator . step()*进行积分，直到它达到最终时间跨度。最后，我们通过 self.integrator 更新 self.last_global_state、self.last_local_state 和积分间隔。最后，我们返回全局状态。
- **第四步:复位功能。**重置功能用于在每次新的迭代中设置模拟的初始条件，如初始位置和速度。它使用一个全局变量并更新 self.last_global_state，self.last_local_state。
**def reset_start_pos(self, global_vector)**:
x0, y0, theta0, vx0, vy0, theta_dot0 = global_vector[0], global_vector[1], global_vector[2], global_vector[3], global_vector[4], global_vector[5]
self.last_global_state = np.array([x0, y0, theta0, vx0, vy0, theta_dot0])
self.last_local_state = self._global_to_local(self.last_global_state)
self.current_action = np.zeros(2)
self.integrator = self.scipy_runge_kutta(self.simulate_scipy, self.get_state(), t_bound=self.time_span)
最后的代码可以在这里查看。
3 —健身房环境
有了模拟器后，我们现在可以创建一个健身房环境来训练代理。
3.1 国家
状态是代理可以“看到”世界的环境变量。代理使用这些变量来确定自己在环境中的位置，并决定采取什么行动来完成提议的任务。在我们的问题中，任务被表述为:
使用方向舵控制，在给定的恒定推进动作下，沿航道执行规定的线性导航路径。
为在任务中应用 RL 而选择的状态如下:
式中 d 为船舶质心到基准线的距离； θ 是船舶纵轴与基准线之间的角度； vx 是船在其质心的水平速度(在引导线方向； vy 是船在其质心的垂直速度(垂直于引导线)； dθ/dt 是船的角速度。
3.2 奖励
奖励函数负责惩罚没有遵循指导方针的代理，如果他没有太大的动摇就奖励他。定义的奖励函数是:
其中:
3.3 行动
这些动作是控制船舶操纵运动的输入参数。使船可控的力是方向舵和推进力。这些动作具有矢量形式Av =【Al，Ap】，其中 Al 为无量纲方向舵指令， Ap 为无量纲推进指令，因此 Al 在[-1，1] 中， Ap 在[0，1] 中。
3.4 代码
现在我们已经定义了环境的主要方面，我们可以写下代码了。
首先，我们定义我们的船的界限和我们的可观察空间状态(特征)的“盒子”的种类，我们也定义初始条件盒子。
**self.observation_space** = spaces.Box(low=np.array([0, -np.pi / 2, 0, -4, -0.2]), high=np.array([150, np.pi / 2, 4.0, 4.0, 0.2]))**self.init_space** = spaces.Box(low=np.array([0, -np.pi / 15, 1.0, 0.2, -0.01]), high=np.array([30, np.pi / 15, 1.5, 0.3, 0.01]))
self.ship_data = None
之后，我们定义一个函数将模拟器空间状态转换为环境空间状态。注意，我们镜像了 vy 速度 θ 角度和距离 d 以使 AI 更容易学习(减少空间状态维度)。
**def convert_state(self, state):**
*"""
This method generated the features used to build the reward function* ***:param*** *state: Global state of the ship
"""* ship_point = Point((state[0], state[1]))
side = np.sign(state[1] - self.point_a[1])
d = ship_point.distance(self.guideline) # meters
theta = side*state[2] # radians
vx = state[3] # m/s
vy = side*state[4] # m/s
thetadot = side * state[5] # graus/min
obs = np.array([d, theta, vx, vy, thetadot])
return obs
然后我们定义一个函数来计算之前定义的奖励
d, theta, vx, vy, thetadot = obs[0], obs[1]*180/np.pi, obs[2], obs[3], obs[4]*180/np.pi
if not self.observation_space.contains(obs):
return -1000
else:
return 1-8*np.abs(theta/90)-np.abs(thetadot/20)-5*np.abs(d)/150- np.abs(vy/4)-np.abs(vx-2)/2
我们还必须定义阶跃函数。该功能由代理在导航时使用，在每一步，代理选择一个动作并在 10 秒内运行模拟(在我们的积分器中),并一次又一次地这样做，直到它到达通道的末端或到达通道边缘。
def step(self, action):
side = np.sign(self.last_pos[1])
angle_action = action[0]*side
rot_action = 0.2
state_prime = self.simulator.step(angle_level=angle_action, rot_level=rot_action)
# convert simulator states into obervable states
obs = self.convert_state(state_prime)
# print('Observed state: ', obs)
dn = self.end(state_prime=state_prime, obs=obs)
rew = self.calculate_reward(obs=obs)
self.last_pos = [state_prime[0], state_prime[1], state_prime[2]]
self.last_action = np.array([angle_action, rot_action])
info = dict()
return obs, rew, dn, info
因为我们镜像状态，所以我们也必须镜像方向舵的动作，将它乘以**侧。**在本教程中，我们将创建一个网络，仅控制方向舵的动作，并保持旋转角度不变( rot_action = 0.2 )。
我们还使用库 turtle 创建了一个查看器，你可以在这里查看代码。它用于显示学习过程或培训后的表现。查看器在函数 render 中被调用。
def render(self, mode='human'):
if self.viewer is None:
self.viewer = Viewer()
self.viewer.plot_boundary(self.borders)
self.viewer.plot_guidance_line(self.point_a, self.point_b) img_x_pos = self.last_pos[0] - self.point_b[0] * (self.last_pos[0] // self.point_b[0])
if self.last_pos[0]//self.point_b[0] > self.number_loop:
self.viewer.end_episode()
self.viewer.plot_position(img_x_pos, self.last_pos[1], self.last_pos[2], 20 * self.last_action[0])
self.viewer.restart_plot()
self.number_loop += 1
else:
self.viewer.plot_position(img_x_pos, self.last_pos[1], self.last_pos[2], 20 * self.last_action[0])
最后，我们定义了设置初始空间状态和重置的函数，它们在每次新的迭代开始时使用。
**def set_init_space(self, low, high):**
self.init_space = spaces.Box(low=np.array(low), high=np.array(high))**def reset(self):**
init = list(map(float, self.init_space.sample()))
init_states = np.array([self.start_pos[0], init[0], init[1], init[2] * np.cos(init[1]), init[2] * np.sin(init[1]), 0])
self.simulator.reset_start_pos(init_states)
self.last_pos = np.array([self.start_pos[0], init[0], init[1]])
print('Reseting position')
state = self.simulator.get_state()
if self.viewer is not None:
self.viewer.end_episode()
return self.convert_state(state)
完整的代码可以在这里找到。
4 —培训
为了培训我们的代理人，我们使用了来自 Keras-rl 项目的 DDPG 代理人。关于 DDPG 方法的细节可以在这里找到。
然后我们导入所有使用过的方法来建立我们的神经网络。
from keras.models import Sequential, Model
from keras.layers import Dense, Activation, Flatten, Input, Concatenate
from keras.optimizers import Adamfrom rl.agents import DDPGAgent
from rl.memory import SequentialMemory
from rl.random import OrnsteinUhlenbeckProcess
from ship_env import ShipEnv
所使用的神经网络具有以下结构(演员-评论家结构):
实现该结构的代码如下:
# Next, we build a very simple model.
actor = Sequential()
actor.add(Flatten(input_shape=(1,) + env.observation_space.shape))
actor.add(Dense(400))
actor.add(Activation('relu'))
actor.add(Dense(300))
actor.add(Activation('relu'))
actor.add(Dense(nb_actions))
actor.add(Activation('softsign'))
print(actor.summary()) action_input = Input(shape=(nb_actions,), name='action_input')
observation_input = Input(shape=(1,) + env.observation_space.shape, name='observation_input')
flattened_observation = Flatten()(observation_input)
x = Concatenate()([action_input, flattened_observation])
x = Dense(400)(x)
x = Activation('relu')(x)
x = Dense(300)(x)
x = Activation('relu')(x)
x = Dense(1)(x)
x = Activation('linear')(x)
critic = Model(inputs=[action_input, observation_input], outputs=x)
print(critic.summary()) # Finally, we configure and compile our agent. You can use every built-in Keras optimizer and
# even the metrics!
memory = SequentialMemory(limit=2000, window_length=1)
random_process = OrnsteinUhlenbeckProcess(size=nb_actions, theta=0.6, mu=0, sigma=0.3)
agent = DDPGAgent(nb_actions=nb_actions, actor=actor, critic=critic, critic_action_input=action_input,
memory=memory, nb_steps_warmup_critic=2000, nb_steps_warmup_actor=10000,
random_process=random_process, gamma=.99, target_model_update=1e-3)
agent.compile(Adam(lr=0.001, clipnorm=1.), metrics=['mae'])
最后，我们使用 300.000 次迭代来训练我们的代理，并且在训练之后，我们保存网络权重和训练历史:
hist = agent.fit(env, nb_steps=300000, visualize=False, verbose=2, nb_max_episode_steps=1000) # train our agent and store training in histfilename = '300kit_rn4_maior2_mem20k_target01_theta3_batch32_adam2'# we save the history of learning, it can further be used to plot reward evolutionwith open('_experiments/history_ddpg__redetorcs'+filename+'.pickle', 'wb') as handle:
pickle.dump(hist.history, handle, protocol=pickle.HIGHEST_PROTOCOL)
#
After training is done, we save the final weights.
agent.save_weights('h5f_files/ddpg_{}_weights.h5f'.format('600kit_rn4_maior2_mem20k_target01_theta3_batch32_adam2_action_lim_1'), overwrite=True)
最后经过训练我们有了以下结果:
代理人已经学会如何控制船舵以及如何停留在航道中线。
如果你已经读到这里，谢谢！如有任何问题，请在下方留言
关于这个项目的更多信息:
在我最后一年的项目中，我使用了一个更详细的船模型，还包括由人工智能代理控制的推进动作。项目存储库可以在这里找到。
参考文献:
【1】FOSSEN，Thor I .船舶流体力学与运动控制手册。约翰·威利父子有限公司，2011 年。
OpenHouse。人工智能:通过透明扰乱房地产
技术如何改变一个受到严格监管、拥有强大制衡、信息受到严格保护的行业？房地产行业主要由独立的房地产经纪人组成，由经纪公司和全国房地产协会统一管理。在这种寡头垄断的范围内，有一些规则保护其参与者，并确保市场维持对几十年来定义的结构的依赖。
与此同时，市场已经发展成为由信息驱动的按需经济。如今，购房者越来越容易获得信息，这使得他们在某些方面可以绕过中介。对即时满足和以最低成本找到最佳价值的知识的需求正在慢慢演变这个行业。房地产如何在未来十年取得成功将完全取决于购房者习惯的改变，他们默许慢慢拆除这一市场结构，以改善买家对信息的获取，同时创造新的价值来源。
一家总部位于卡尔加里和多伦多的初创企业正在为这种颠覆铺平道路，并向参与者发起挑战:房地产经纪人和购房者对这些交易有不同的看法。OpenHouse。AI 是一个基于云的数据和功能丰富的住宅房地产网络平台，使买家和卖家能够通过清晰和透明做出更好更快的房地产决策。
这些由和 Yanky Li 创立的年轻企业家们正在真正地解开一个非常传统的模式，并创造一个平台，在这个平台上，免费信息极大地改变了游戏规则。
条条大路通 OpenHouse。人工智能
张智峰在 R&D 工作了 12 年多。他毕业于法国，获得软件工程硕士学位，曾在多个行业的技术领域工作，包括公用事业、金融、电信和会计。当他从 NYU 商学院毕业时，他经历了一次“觉醒”，改变了他开始思考的方式。
我想在生活中做一些更有意义的事情，更直接地帮助人们创造积极的社会影响，而不仅仅是薪水和提前退休。我总是觉得我必须改变才能保持原样，做真实的自己。成为企业家对我来说再好不过了。
杨基李本质上一直是一个企业家，年轻时总是向家人、朋友和同学卖东西。他记得在小学时，他饲养并出售仓鼠，通过在学校进行的交易和装在塑料豆腐容器中的存货赚了一些钱。这些年来，他在商业和技术领域度过了他的职业生涯。通过咨询和项目管理的角色，他不断地寻找解决方案，并被期望能够快速思考。为他人工作并实现他们的梦想并不那么令人满意。杨基想要实现自己的梦想。
OpenHouse 的愿景。人工智能是连接人，而公司则提供洞察力。对 Will 来说，这个平台的想法源于他的经历。在他的职业生涯中，他幸运地见证了信息的释放，这将比任何一个人产生更广泛的影响。在开源运动下创建的应用程序，特别是在机器学习社区，已经取得了长足的进步。维基百科创立的理念是“每个人都可以自由获取所有人类知识的总和”，它利用社区和信任的力量来维持自身。一天，威尔和一个同样从事高级分析研究的朋友在一起，他们都意识到可以运用自己的技能帮助普通购房者做出人生中最重要的决定之一。
我女儿出生后，我和妻子在看一个开放的房子。我见到了店主。他开始带我们参观他的家，并谈论他对房子进行的翻新和升级(这些信息大多不在房地产清单上)。这对我们来说是一次很棒的购买体验。我希望我有更多这样的东西。就在那时，我构思了一个产品，将房主和房地产经纪人联系起来，在购买过程中创造更好的体验。我和我的老朋友 Yanky 分享了这个想法:我们建立一个允许人们贡献信息的产品。然后，我们部署技术来聚合和分析信息，并将数据开放给任何想要使用它的公司或第三方。
对杨基来说，这是一个影响世界的机会:
我已经获得了很多经验，我想把它带到一个新的水平，并影响人们的生活。我挨家挨户地去听人们的故事(我们了解他们的痛点)。我们正处于一个技术普及、成本降低的时代，初创公司正试图通过利用技术来帮助人们。我们没有房地产背景，所以我们进入这个问题:这应该如何工作？
你如何改变心态？
你如何告诉房地产经纪人，他们一直是真相的行业守护者，释放这些信息不会把他们的工作置于危险之中？创始人的使命是为每个人创造积极的影响。当技术以正确的方式创造并正确部署时，它可以增强人们的能力。
对于房地产经纪人来说，技术可以提供有价值的洞察力。人际关系也很重要。在房地产行业，关系至关重要。这些经历推动了更多的业务。OpenHouse。AI 将为房地产经纪人提供更有意义的见解，让他/她更好地了解社区，以加强这些关系。随着大数据的出现，来自世界各地的信息使技术能够积累更多的洞察力，从而为用户提供更多的价值。虽然代理人有信息，随时可以获得实时的，相关的信息仍然难以捉摸。如果房地产经纪人有更好的信息，他们可以为客户提供更好的服务。按照遗嘱:
我们正在创建一个不偏不倚的信任平台，将使信息随时可用。
杨基同意。在最近一次对一家经纪公司的采访中，他们花了过多的时间编写报告和做研究。如果他们有能力即时访问数据，他们就可以专注于他们最擅长的事情:发展良好的关系，并向人们展示合适的房屋。
对于购买者来说，目标是使他们能够做出更明智的决定，并确保这些决定是有效的。对于销售者来说，他/她可能会评价不同的销售方式。他们上演吗？他们翻新吗？他们卖多少钱？OpenHouse。人工智能将通过数据将卖家与市场联系起来，这样他们就可以优化他们的销售决策。
向所有人开放这些信息会创造一种透明度，这反过来会在利益相关者之间培养一种急需的信任。
在数据保护中释放信息的二分法
随着人工智能开始流行，人们对用户数据的收集、安全和处理感到担忧和谨慎。于 5 月 25 日生效的《欧洲通用数据保护条例》( GDPR)也指出，需要仔细审查数据是如何汇编的，以生成关于个人及其倾向的背景。
威尔介绍了他们的赋权价值观:
- 让人们能够使用人工智能做决定
- 通过让人们控制平台可以访问哪些信息以及哪些信息将与他人共享，来增强人们的能力。
他们是“人民数据”的坚定信仰者。人们对分享他们的信息有不同的舒适度。让他们选择分享他们愿意分享的数据，例如个人信息。在许多情况下，他们可能会分享他们的购买偏好，如房屋特征、邻里要求，即允许平台为他人创造洞察力的信息类型。按照美国佬的说法，
当个人需要时，来自整体的贡献使他们受益。
威尔补充说，人工智能将影响成本节约，并将成为一个重要的利润驱动因素，并影响就业。然而，他不相信它会淘汰或取代人类。这将解放人们以不同的方式思考，随着时间的推移，他的公司准备启用和验证这一点。
让人们能够控制他们的数据意味着确保隐私功能嵌入到平台的所有层中。当卖家想要列出房屋时，他们可以选择隐藏任何他们不想在网站上透露的信息。他们也可以选择不使用用于分析的信息。作为一个数据聚合器，OpenHouse。AI 的设计理念是向用户传达他们在旅程的每一步将会获得什么。
隐私权是一种权利。用户需要具备这一点，才能对您的系统产生信任。
这种将人们联系起来、做出更好的决定、赚钱和默许人们的隐私的哲学——都共存于一个系统中吗？杨基强调这是可能的。关键是不断从市场中学习，迭代并提供一个优化社区体验的平台，并提供保持其运行的价值和信任。Yanky 指出，他们参加了真正的北方会议，在那里他们积极参与了对《T2 永久技术宣言》的完善。他们当然也自己签了名。组织者阐述了这一宣言的前提:
如今，随着新技术的不断进步，我们有机会退一步，讨论如何深思熟虑地使用技术。随着加拿大在全球科技舞台上声名鹊起，我们相信我们已经做好了举行这些重要对话的准备。 ~ Steve Currie，Communitech 首席创新官。
加拿大商业领袖和他们的组织处于理想的位置，以确保他们开发和使用的技术合乎道德、包容和公平地为所有人追求“好”的结果。 ~ Peter Barr，德勤滑铁卢和西安大略地区管理合伙人。
这是重要的一步，不仅仅是在沟通 OpenHouse 方面。人工智能的价值，还在于确保它在整个平台上得到功能性的转化。
颠覆的时代和对未来十年的展望
威尔关注 AI 的大规模部署，并设想它将如何扰乱人们的日常生活。但是，通过技术创造解决迫在眉睫的粮食危机、疾病发病率和迫在眉睫的能源危机的方法来改善人们生活的机会显示了巨大的希望。与此同时，技术可以大幅降低基本生活成本，改善每个人的福祉。
对于 Yanky 来说，他设想随着创新的增加，技术社区在政策上有更多的发言权。目前，在努力跟上技术发展的过程中，政策和监管存在滞后，减轻这种风险的最佳方式是让技术在与企业和政府监管机构的谈判中占有一席之地。这将迫使政府与市场变化和消费者偏好保持同步。
通过允许商业和技术公司更道德地使用数据，技术有能力最小化社会的财富差距。随着社交媒体的出现，Joe Public 获得了一个扩音器，AI 有能力释放每个人手中的信息。这种不可避免性将要求所有层面的问责制:用户、企业、系统和政府。
OpenHouse。艾:这些门什么时候会开？按照遗嘱，
计划首先在 AB 的卡尔加里进行测试，以确保产品适合市场。不着急。我们希望确保买家、卖家和房地产专业人士之间的价值。我们知道这需要时间。我们知道这会带来怎样的影响，所以我们真的需要正确地构建它。一旦发布，我们将不断改进，一次推出一个城市。
忠于他们的价值观，以使平台有用为目标是最重要的。优先考虑创造经济和社会影响的目标，而不是货币化，将保持开放门户。人工智能在通往可持续发展的道路上走得更少。对威尔来说，他将继续倾听市场，学习和更新平台，用他自己的话来说，“不断变化，以保持真实的自我”。
约 约开房。艾
在过去的十年里，张智峰一直致力于运筹学、产品商业化、技术咨询和 R&D 组织设计方面的先进技术。他拥有商业分析和软件工程硕士学位，曾在欧洲和北美的公用事业、金融、能源和会计领域带头发起技术倡议。
Yanky Li 的职业生涯几乎都在致力于平衡业务和技术。作为特许专业会计师和项目管理专家，Yanky 在世界各地领导了许多成功的项目，在这些项目中，他利用技术为业务问题设计解决方案。他本质上一直是一个企业家，他的动力是为人们创造影响，倡导包容性的社会变革。
这篇文章最初发表在福布斯上
打开神经网络黑盒——感知器
用 R 从头开始实现感知器
在大学开始研究机器学习之后，我一直在和人们谈论它，我逐渐意识到，即使有更多的技术背景，人们仍然认为机器学习算法是一个黑盒。因此，我想写这篇文章，展示如何使用 R 编程语言从零开始实现第一个提出的称为感知器的神经网络模型。我将带你们看一下整个过程，看看这个黑匣子里面是什么。
感知器神经网络
神经网络是一个受大脑启发的概念，更具体地说，是学习如何执行任务的能力。实际上，这是一种尝试，用代数的形式来模拟学习机制，以利于创建能够学习如何执行简单任务的算法。学习机制是一个很难的课题，多年来一直在研究，但没有完全理解，然而一些概念被假设来解释学习如何在大脑中发生，其中主要的一个是可塑性:改变神经元之间突触连接的强度，并创建新的连接。1949 年，唐纳德·赫布首次假设了这些突触的强度是如何适应的，他说突触连接强度的变化与两个连接神经元放电的相关性成正比。听起来很难做对吗？让我在这里澄清一下。他只是说，如果两个神经元一致地同时放电，那么它们之间的任何连接都会在强度上发生变化，变得更强。例如，你还记得你第一次吃来自一个新地方的比萨饼并且你喜欢它的味道吗？太棒了，对吧？嗯，在那一刻，你大脑中的一组神经元受到了积极的刺激，因为你品尝到了来自新地方的比萨饼的味道，因为这些神经元同时放电，它可能连接在一起或创建了一个新的连接。最终，当你从朋友那里听说那个地方或者看到一则广告时，它将足以让你再次想起比萨饼的美味。
为了模拟这种机制，麦卡洛克和皮茨提出了一个数学模型，该模型只能捕捉和再现其本质和基本属性，该模型被命名为感知器，如下图所示:
Basic Perceptron Model proposed by McCulloch and Pits.
感知器的主要特点是只有一个神经元。基本上，该模型由一组输入(x1，x2，…，xm)，权重(w1，w2，…wm)和激活功能。输入代表刺激，权重复制神经元之间的连接强度，激活函数模拟神经元放电的性质。所有这些元件一起模拟一个感知器模型，该模型只不过是一个数学运算器，该运算器对所有乘以输入的权重求和，并且结果是激活函数的输入，只要求和的结果大于阈值，该激活函数就提供一种类型的输出，否则就提供其他类型的输出。
看，这个模型并不复杂。我希望到目前为止你做得很好，你可以意识到神经网络只不过是乘法和求和，其结果应用于一个函数。这就是真实的情况。
现在，我们需要将这些刺激映射到输入中。回想一下在一个新地方吃美味披萨的例子。刺激是比萨饼的味道，标签是比萨饼真的很好，所以你了解到那个新地方的比萨饼味道很好。味道并不是使比萨饼真正好吃的唯一特征，一般来说，比萨饼有更多可观察的特征，如:大小、格式、气味、颜色、重量、稠度、温度等，这些特征组成了“好比萨饼”的概念，这正是我们如何从现实世界中学习的。再想一个例子:你是怎么知道汽车是轿车而不是卡车的？很可能当你还是个孩子的时候，你的父母指着一辆汽车告诉你那是一辆汽车，而在其他情况下，他们指着一辆卡车告诉你那个大物体是一辆卡车。事实上，你所做的是观察到一些使这两个物体彼此不同的特征，并将这些观察结果与你父母告诉你的联系起来，例如，卡车比汽车大，可能有许多轮子，汽车没有巨大的后备箱，可以容纳五个人，等等。这正是机器学习试图做的事情:教导算法如何对对象进行分类，为数据集提供可观察特征的示例，其中每个观察都有一个标签或类别。
简单数据集
好了，现在你知道了感知器算法的模型和数据集应该是怎样的，是时候编码了。在我们动手之前，让我们先来定义我们要使用的数据集和激活函数。我们关注的是算法本身，所以为了使其他变量尽可能简单，我们将采用一个源于众所周知的 OR 逻辑函数的简单数据集。
从代码开始，让我们以 R 数据帧格式存储数据，如下所示:
data = data.frame( x1 = c( 0, 0, 1, 1 ),
x2 = c( 0, 1, 0, 1 ),
y = c( 0, 1, 1, 1 ) )print( data )## x1 x2 y
## 1 0 0 0
## 2 0 1 1
## 3 1 0 1
## 4 1 1 1
数据集只有四个观察值，其中两个属于类 0，其他属于类 1。
plot( data$x1, data$x2, type = 'n', main = 'Dataset OR', xlab = "x1", ylab = "x2" )
text( data$x1, data$x2, labels = data$y )
grid( nx = length( data$x1 ) + 1, ny = length( data$x1 ), col = 'black' )
这里的任务是训练一个感知器来执行分类。
让我们做些训练吧
首先，什么是培训？训练只有一个目标:找到当算法执行分类任务时产生最小误差的权重的最佳值。因此，分类就是简单地说明一个确定的输入属于 0 类还是 1 类。为了做到这一点，该算法找到一个超平面，该超平面将这些观察结果分成两边，一边应该只有来自类 0 的观察结果，而另一边只有来自类 1 的例子。事情会在下图中变得清晰:
Figure 02. OR classification
定义超平面的参数由权重值给出。然而，它有无限的组合，每一个都定义了超平面的不同位置，某些位置会引起错误分类。当已知类别的输入被算法分类为属于不同类别时，会出现此错误。因此，我们需要选择最佳位置，以避免错误分类。回到代码，让我们在一个短的值范围内随机初始化权重值，如下所示:
weights = rnorm( mean = 0, sd = 0.1, n = ncol( data ) )print( weights )## [1] 0.07189541 -0.08588955 -0.12175474
我从均值等于零、标准差等于 0.1 的正态分布中随机抽取数字。等等，到目前为止，我们已经看到了两个权重，每个输入一个，但是上面的代码显示了三个权重。第三个权重用于偏置输入。Bias 是一个固定输入，通常为-1 或 1，即使电流输入都为零，它也负责激活神经元。缺少的最后一个定义是激活函数。这将是如下所示的 Heaviside 阶跃函数:
Figure 03: Heaviside step function
Heaviside 阶跃函数的特性是当输入低于某个阈值时输出等于 0，否则输出为 1。您可能已经感觉到，激活函数的输出将是算法对输入属于哪一类的猜测。在这种情况下，Heaviside 阶跃函数是有意义的，因为它允许我们计算误差，以便评估分类器的性能。考虑到阈值等于 0.5，激活函数可以写成如下:
activation_function = function( net ){
if( net > 0.5 )
return( 1 )
return( 0 )
}
现在，我们终于可以写下感知器的代码了。让我们进行第一次观察，添加偏差值并乘以初始权重，结果将放入激活函数。在此之后，计算误差值并更新权重以提高自信度。为了计算误差和更新权重，我们将使用下面的表达式，其中参数 eta 是学习率，该值定义了遍历误差函数的步骤。
data = as.matrix( data )
net = c( data[1, 1:2 ], 1 ) %*% weightsy_hat = activation_function( net )error = y_hat - data[1,3]eta = 0.1weights = weights - eta * ( error ) * c( data[ 1, 1:2 ], 1 )print( weights )## x1 x2
## 0.07189541 -0.08588955 -0.12175474
这是只有第一次观察的学习过程，现在我们需要对数据集上所有可用的例子重复这个过程。然而，这个循环需要有一个停止标准，它将定义学习过程何时应该停止。为了测量算法在分类任务中的性能，我们观察误差的值，因此使用它作为停止标准听起来是合理的，更准确地说，我们将使用均方误差(mse)值。当算法达到一个较低的 mse 值时，我们会对它的性能感到满意。执行整个工作流培训的代码如下所示:
perceptron = function( dataset, eta = 0.1, threshold = 1e-5 ){
data = as.matrix( dataset )
num.features = ncol( data ) - 1
target = ncol( data ) # Initial random weights
weights = rnorm( mean = 0, sd = 0.1, n = ncol( data ) ) mse = threshold * 2
while( mse > threshold ){
mse = 0
for( i in 1:nrow( data ) ){
# Add bias and compute multiplications
net = c( data[ i, 1:num.features ], 1 ) %*% weights # Activation function
y_hat = activation_function( net ) # Compute mse
error = ( y_hat - data[ i, target ] )
mse = mse + error^2
cat( paste( "Mean square error = ", mse, "\n" ) ) # Update weights
weights = weights - eta * error * c( data[i, 1:num.features ], 1 )
}
}
return( weights )
}
这个函数找到感知器模型的最佳权重。
看那个超平面！！
好了，伙计们，我们到了这篇文章的最后部分。在我们找到感知器模型的最优权重之后，让我们来看看超平面。下面的函数绘制了输入空间上的超平面。
shattering.plane = function( weights ){
X = seq( 0, 1, length = 100 )
data = outer( X, X, function( X, Y ){ cbind( X, Y, 1 ) %*% weights } )
id = which( data > 0.5 )
data[ id ] = 1
data[ -id ]= 0
filled.contour( data )
}
…运行功能…
weights = perceptron( data, eta=0.1, threshold=1e-5 )## Mean square error = 0
## Mean square error = 1
## Mean square error = 2
## Mean square error = 3
## Mean square error = 0
## Mean square error = 1
## Mean square error = 2
## Mean square error = 2
## Mean square error = 0
## Mean square error = 0
## Mean square error = 0
## Mean square error = 0shattering.plane( weights )
如您所见，超平面将输入空间分为两个区域(蓝色和粉色)，每个区域代表输入被分类为属于类 0 和类 1 的空间。同样，你可以观察到，每次你运行代码，你会得到一个不同的权重值，从而改变超平面的位置。对于那些还不熟悉 R 语言的人，完整的感知器代码存储在我的 github 库中，只需在 R 控制台中复制并粘贴即可。
机器学习的好结论和未来
感知器是第一个提出的神经网络模型，它在线性可分的数据集上工作良好，对于其他类型的数据集，感知器存在许多限制，使得它不可能以良好的结果(低误差值)执行分类任务。例如，感知器不会对源自逻辑函数 XOR 的数据集执行分类任务。如果你是一个好奇的人，你可以在一个 XOR 数据集上运行这个代码，看到感知器不能区分类 0 和类 1，它永远不会达到低于给定阈值的均方误差。此外，尝试使用超平面对 XOR 数据集进行可视化分类。你能画出一个超平面来分隔类 0 和类 1 的输入吗？很可能不会，你会失败得很惨。我知道在所有这些研究之后，发现一个非常有限的分类器是令人沮丧的。不要悲伤或绝望，这不是机器学习的结束，恰恰相反，这只是开始。科学家们找到了一种超越这些限制的方法，将感知器算法进化成了一种叫做多层感知器(MLP)的算法。与感知器不同，MLP 能够解决复杂的问题，从简单的逻辑功能，如异或，直到人脸识别。在接下来的帖子中，我将打开 MLP 黑盒，从头开始实现它，并在一个真实的数据集上运行它来展示它的威力。感谢您的时间，您可以在 github 资源库中查看完整的代码。随时欢迎反馈。一会儿见。
实际管理数据科学团队
运营一个数据科学团队不是光看 Coursera 和 Udemy 上的讲座和视频就能学会的。不要误解我们，他们是学习数据科学和机器学习理论与实践问题的好地方。
然而，他们没有教授良好的业务实践，以及如何在业务环境中运营数据团队。知道算法，以及如何使用 Hadoop 还不足以拥有一个有效的数据团队。
给数据科学团队的建议
团队要和其他部门合作，要维护软件，要向高管汇报，当然还要回报商业价值！数据科学，如分析和商业智能，只是帮助企业更有效地赚钱的工具。
大多数数据科学课程都不会讨论这些内容。这就是为什么我们的重点之一不仅仅是定制数据科学算法和模型，还有数据科学团队发展。
我们想提供一些伟大的提示，帮助您的数据科学团队更加成功。这与算法和模型无关，而是与数据专家在业务中需要如何运营有关:
ROI 与算法和技术
程序员、数据科学家和工程师。我们大多数人通常更喜欢关注我们正在开发的数据项目或软件的技术方面。我们开发产品的原因不仅仅是为了钱，而是为了证明我们可以做一些事情。这是一个挑战！我们是问题解决者。
也许我们想证明我们可以开发一种算法，可以预测一个产品是不是热狗。只是为了好玩！
然而，归根结底，美国的数据科学家、数据顾问和软件工程师是被企业雇佣的。最终，这些企业希望看到财务结果。无论您使用的是神经网络还是基于支持向量机的算法，哪个结果可以节省最多的资金，或者带来最多的收入，都没有关系。
记住这一点很重要，因为数据科学家或大数据分析师越早发现这一点。他们的作用就越有效。作为一名数据科学家，有一点点企业家精神是必要的。
数据专家寻找机会为公司省钱，或者发现新的价值流。我们也经常是对的，因为我们不仅了解业务，而且我们有数据来支持我们的见解。
这是拥有一个与您的业务非常协调的数据团队的价值之一。他们有数据来驱动他们的决策。
数据工程
一个可以偶尔赶工的领域是数据工程。它可能看起来不重要，可能看起来很容易改变。然而，如果数据不是以一种易于操作和开发的方法设计的。数据科学家将有一段地狱般的时间试图设计他们的算法和下游工作流程。
在 indeed.com的职位中，数据工程师的比例仍然高于数据科学家，这是有原因的。
数据的结构在分析中起着很大的作用。我们的团队有几个成员原本是数据工程师，这就是他们如此有价值的原因。他们不仅能创建漂亮的算法，还能创建从 A 点到 b 点、从数据仓库到算法的自然流动的数据管道。
设计良好的数据易于修改，易于允许新的模块和报告指标等。这可能看起来很奇怪，但是有了好的数据工程，这一切都是可能的！
系统设计也适用于数据科学家
当设计算法时，很容易忘记结果需要实际应用到生产中。
数据科学家不只是设计一个算法，然后就此结束。相反，通常需要某种形式的数据仓库或数据存储中心作为一个系统，从开发的模型中获取并记录数据。该算法不是一个孤岛，它自己创造美元。
通常还会有某种形式的用户可以与之交互的界面。
例如，这可能是一个网站或一个仪表板。目的是让最终用户直接获得可操作和可理解的见解。而不是他们必须翻译随机数字和模型输出。
当在课堂上简单地做一个卡格尔问题或创建一个项目时，这可能会被忽略。这就是为什么像“激励”这样的项目让他们的学生与实际的企业合作，因为将算法投入生产需要的不仅仅是开发它。
有旧系统要处理，API 文档要筛选，有 bug，有变通办法，当然还有公司政治。
公司政治，是的，你会参与其中
商业总是有政治。没有办法绕过去。数据科学高管和项目负责人需要能够与其他团队合作，并像其他部门一样获得资金。
这需要了解其他高管想要什么和需要什么，并确保他们支持你的项目。如果他们不支持你的项目，如果他们等着在背后捅你一刀(这种情况确实会发生)，你的项目就会失败。
不要操纵，而是引导其他团队领导接受你的观点，或者交换，或者妥协。只要确保你不会开始踩着每个人的脚趾…至少，直到你的数据团队已经证明了自己几次。即使这样，也不要变得难以共事。
否则，没有人会给你的业务团队提供资源。
文档是数据团队的朋友
好吧，85%的程序员需要承认一些事情。他们讨厌文档。没关系，这并不是最有趣的事情。然而，不断地记录是很重要的！
数据科学算法、数据结构和软件需要不断地被记录。
没人要求你的数据团队写出下一个汤姆·斯威尔。只要保持清晰易懂的笔记，任何其他程序员都可以拿起。
你永远不知道团队成员什么时候会离开，因此，留下一堆没有文档的半成品项目。
因此，为了便于维护，让您的数据团队记录他们的项目。这将为您的团队节省数百小时的技术债务，并确保您的产品继续运行。
数据科学项目需要软件 QA 和生命周期
数据科学是软件开发的一个分支。这意味着它需要一个过程来确保开发的代码是健壮的和可维护的。
你怎么问？
通过对代码和数据都有一个很好的质量保证过程，并确保代码从开发到生产有一个标准化的过程。
不，你不应该在产品上测试代码！
事情就是这样出问题的！！！
不要误解我们，您需要推出代码，但不能以您的代码会破坏构建为代价。
同行评审、QA 和单元测试可以为您的数据团队省去很多麻烦。确保没有持续的障碍，就像一个工程师永远都要对别人的代码进行同行评审。
同时，确保你没有直接开发产品！！
数据科学不仅仅是关于算法
数据科学和分析的真相是，它不是一颗神奇的子弹。它实际上只是企业用来增加利润和降低成本的另一个工具。如果操作得当，它会创造巨大的竞争优势。当数据设计得很好，团队与业务的其他部分运作良好时。
我们的数据顾问专门确保您的团队满负荷运转。当然，我们喜欢解决数据科学和机器学习问题。
然而，我们也提供令人敬畏的指导和研讨会，以帮助发展您的团队成员！我们拥有数据科学和业务专业人员，他们知道如何确保您的团队与业务保持一致。通过这种方式，您可以充分利用数据来推动价值流！无论是大数据，小数据，让我们知道今天我们如何为您服务！
阅读下面关于数据科学的更多信息！
生物学和医学中深度学习的机遇和障碍
**目标受众:**一般。
27 名科学家合作审查生物学和医学领域深度学习的机遇和障碍。也许比他们的结论更重要的是导致这些结论的写作过程——在 Github 上，在开放的环境中，以类似于开源软件开发的方式。
概要:
- 生物学和医学正变得数据丰富，但数据复杂且往往难以理解，这使得这些领域可能非常适合深度学习。
- 最近的几份出版物综述了深度学习在生物学和医学中的应用。
- 这篇综述与众不同，因为 27 位科学家在 Github 上公开合作撰写了这篇综述:它代表了不同专家的共识，导致最新版本的综述的讨论对公众开放。
- 回顾的主题包括深度学习在疾病和患者分类、基础生物学研究和患者治疗中的应用。
- 对模型评估和解释的批判性讨论强调了常见的陷阱和最佳实践的指导原则。
- 尽管在大多数审查的应用中，深度学习优于竞争机器学习方法，但深度学习尚未实现其潜力或最终解决这些问题。
- 数据、代码和模型共享的文化将加速这一领域的进步；像 DragoNN 这样的教学资源会扩展它。
- 总之，我们对深度学习在生物学和医学领域的未来持乐观态度。
在 Github 上公开写评论可以减少偏见，利用大众的智慧。右边是我和其中一位作者交流的快照，我们决定不对我们之前考虑过的某些问题发表评论。我们不会在评论中讨论这些问题，但是这种交流澄清了我们对这些问题的看法，这就是开放式写作过程的附加价值。
该综述可在 bioRxiv 上获得预印本，最新版本可在 Github 上获得。接下来，它将接受同行评审，以便在《皇家学会杂志》上发表。我们的结论，如果经得起时间的考验，将会把这个领域向前推进一步；我们采用的开放式写作过程，如果经得起时间的考验，将会改变它。
Johnny Israeli 是斯坦福大学的生物物理学博士生和 SIGF Bio-X 研究员。他开发了基因组学的深度学习，专注于蛋白质-DNA 相互作用。Johnny 创造了DragoNN toolkit用深度学习来教授基因组数据的建模和解释。DragoNN workshops 已经在各大研究机构推出，现在可以作为 Nvidia 深度学习学院的在线课程*。通过与 Anshul Kundaje 教授合作，Johnny 将基因组学的深度学习从想法转变为可用的框架，指导了几十名学生，并通过研讨会和课程扩展了该领域。你可以* 在 LinkedIn 上关注他，获取深度学习和基因组学的月度文章。
机器学习和人工智能的最佳工具
注意:这篇文章基于我最近在脸书开发者圈和柏林数据本地人上的演讲。你可以在这里得到幻灯片。
我将第一个承认工具可能是目前数据科学中最不令人兴奋的话题。人们似乎更有兴趣谈论最新的聊天机器人技术或深度学习框架。
这完全说不通。为什么你不花足够的时间来仔细挑选你的工具？还有一个额外的问题，这对于我的职业来说很典型——当你只有一把锤子时，一切都变成了钉子(这就是为什么你实际上可以用 R 建立网站；-)).我们来谈谈这个。
先说要领。
我应该使用哪种语言？
好吧，这个有争议。在这个问题上有一些非常广泛的观点，从一个极端到另一个极端。我有一个可能是最不常见的——越多越好。R 和 Python 都要用。
More is better
那么，为什么呢？r 可以说在数据可视化方面做得更好，并且有大量的统计软件包。另一方面，Python 将帮助您将模型投入生产，并且更受团队中其他开发人员的赞赏(想象一下，给他们一个 R 模型来部署)。
在这里，我想对茱莉亚大声疾呼。这是该领域的新来者，但潜力巨大。留意一下这个。
基本软件包
我们不希望在工作中不断重复发明轮子，我们应该利用围绕这些语言的令人敬畏的开源社区。首先，快速回顾一下典型数据科学工作流中的主要任务。
A typical machine learning workflow
最重要的步骤是:摄取，清洗，可视化，建模和交流——我们需要所有这些的库。
对于 R 中的数据清理，有一个很棒的包叫做 dplyr 。诚然，它有一个奇怪的合成轴，但这就是它的力量所在。注意 % > % —它的工作方式与nix 中的管道( | )操作符完全相同，上一个操作的输出成为下一个操作的输入。这样，只需几行代码，您就可以构造非常复杂但可读的数据清理或转租操作。*
python 的替代品是熊猫。这个库大量借鉴了 R，尤其是 dataframe 的概念(其中行是观察值，列是特性)。它有一些学习曲线，但是一旦你习惯了它，你可以在数据操作中做几乎任何事情(你甚至可以直接写数据库)。
对于数据可视化，我们有 ggplot2 和 plotly 用于 r。gg plot 2 非常强大，但相当低级。同样，它有一点奇怪的语法，你应该阅读一下 Graphics 的语法来理解为什么。Plotly 是一个较新的库，它可以让你的 ggplots 拥有超能力，只需要一行代码就可以让它们交互。Python 中 dataviz 的基础包是 matplotlib。它有一些非常神秘的特性，比如奇怪的语法和可怕的默认颜色，这就是为什么我强烈建议你使用更新的 seaborn 包。python 缺乏的一个领域是模型性能的可视化。这个缺口由优秀的黄砖项目填补。您可以使用它来创建漂亮的图来评估您的分类器，查看特征重要性，甚至绘制一些文本模型。
Using Seaborn for scatter pair plotting of the iris dataset
R 中的机器学习遭遇一致性问题。几乎所有的模型都有不同的 API，如果你只是想在你的数据上测试不同的算法(这是你应该做的)，你要么把所有的东西都背下来，要么打开几个文档标签。这一缺陷由两个主要的软件包解决，即 caret 和 mlr ，后者较新。我会选择 mlr，因为它看起来更有结构性，而且维护得更积极。您需要的一切都在那里，从分割数据、训练、预测和性能评估的功能开始。Python 中相应的库可能是我最喜欢的，也难怪一些主要的科技公司支持它——sci kit-learn。它有一个非常一致的 API，超过 150+的可用算法(包括神经网络)，精彩的文档，主动维护和教程。
ROC/AUC plot in Python, using yellowbrick
集成开发环境
为 R 选择一个 IDE 是显而易见的。RStudio 绝对是一个神奇的工具，它没有竞争对手。理想情况下，我们希望 python 像这样。我已经看过一打了(Spyder、PyCharm、Rodeo、spacemacs、Visual Studio、Canopy 等。等等。)，而且只有两个竞争者:木星实验室和原子 + 氢。
朱庇特实验室仍在(积极)建设中，看起来相当不错。尽管如此，它仍然继承了 Jupyter 笔记本的一些缺点，如电池状态、安全性以及最糟糕的 VCS 集成。基于这个原因，我推荐原子+氢。使用这个设置，你可以做各种各样的数据科学的事情，比如检查你的数据帧和变量，在中绘制东西和所有内嵌的东西。py 脚本。
Atom + Hydrogen
EDA 工具
我们为什么需要它们？在数据科学过程中，我们经常(尤其是在开始时)需要快速探索数据。在我们致力于可视化之前，我们需要探索，并以最少的技术投资来完成。这就是为什么编写大量的 seaborn 或 ggplot 代码是次优的，你应该使用 GUI 界面。另外，它也可以被商业人士使用，因为不涉及任何代码。有两个非常酷的跨平台免费工具可用: Past 和 Orange 。前者更侧重于统计分析，后者侧重于建模。两者都可以进行出色的数据可视化，因此它们完全符合我们的目的。
Stuff you can do with Orange
结论
作为临别赠言，我希望你保持高效，尽可能优化你的工具(不要把这作为不工作的借口；)).
损失函数(第二部分):逻辑回归
本系列旨在解释一些广泛使用的监督学习模型的损失函数，以及优化算法的一些选项。在第一部分中，我用梯度下降法，用最小二乘误差作为损失函数，详细地走了一遍线性回归的优化过程。在这一部分，我将转向逻辑回归。
假设
记住线性回归的假设是:
称这种线性回归的假设为原始模型输出。逻辑回归只是有一个基于它的变换。对于逻辑回归，这里着重于二元分类，我们有 0 类和 1 类。为了与目标值进行比较，我们希望将预测值限制在 0 到 1 之间。这就是为什么 Sigmoid 函数应用于原始模型输出并提供概率预测的能力。
假设函数返回的是 y = 1 的概率，给定 x，用θ参数化，写成:h(x)= P(y = 1 | x；θ).决策边界可以描述为:预测 1，如果θᵀx≥0→h(x)≥0.5；预测 0，如果θᵀx < 0 → h(x) < 0.5.
Cost Function
Linear regression uses最小平方误差作为损失函数，给出一个凸图，然后我们可以通过找到它的顶点作为全局最小值来完成优化。然而，它不再是逻辑回归的一个选项。由于假设发生了变化，通过对原始模型输出应用 sigmoid 函数进行计算，最小二乘误差将产生具有局部最小值的非凸图形。
source: https://medium.freecodecamp.org/understanding-gradient-descent-the-most-popular-ml-algorithm-a66c0d97307f; https://www.cs.ubc.ca/labs/lci/mlrg/slides/non_convex_optimization.pdf
直观地说，我们希望在预测 1 而实际为 0 和预测 0 而实际为 1 时分配更多的惩罚。逻辑回归的损失函数正是这样做的，它被称为逻辑损失。见下图。如果 y = 1，看下面左边的图，当预测= 1 时，成本= 0，当预测= 0 时，学习算法受到非常大的成本的惩罚。类似地，如果 y = 0，右边的图显示，预测 0 没有惩罚，但是预测 1 有很大的成本值。
这个损失函数的另一个优点是，尽管我们分别从 y = 1 和 y = 0 的角度来看它，但它可以写成一个公式，便于计算:
因此，模型的成本函数是所有训练数据样本的总和:
正规化
在用这个代价函数对训练数据进行参数拟合之前，先简单说一下正则化。常用的正则化类型有两种，【套索】****【脊】。不是直接优化上述成本函数，而是通过正则化，我们添加对系数可以达到多大的约束，以防止过拟合。L1 和 L2 采用不同的方式设置系数的上限，这决定了 L1 有能力通过将不太重要的特征的系数设为 0 来进行特征选择，并缓解多重共线性问题，而 L2 也惩罚非常大的系数，但不将任何系数设为 0。还有一个参数控制约束的权重λ，以便系数不会受到太大的惩罚而导致欠拟合。
关于为什么 L1 和 L2 由于“平方”和“绝对”值而具有不同的能力，以及λ如何影响正则项和原始拟合项的权重，这是一个非常有趣的话题。这里我们不会真的深究，但绝对值得你去学习和研究。下面显示了如何将原始成本函数更新为正则化成本函数。
最佳化
使用正确的学习算法，我们可以通过最小化 J(θ)作为θ的函数来开始拟合，以找到最佳参数。我们仍然可以应用梯度下降作为优化算法。它采用 J 相对于θ的偏导数(J 的斜率)，并通过每次迭代以选定的学习速率α更新θ，直到梯度下降收敛。请参阅下面的 python 查询来优化 L2 正则化逻辑回归。这里有一篇很好的文章非常详细地解释了优化过程的矢量化实现。
## Vectorized Implementation of Optimization Using Gradient Descent# Define Cost functiondef cost(t, h, l=l, X=X, y=y, m=m):
cost = np.transpose(-y)[@np](http://twitter.com/np).log(h) - np.transpose(1-y)[@np](http://twitter.com/np).log(1-h) + (l/2)*np.transpose(t[1:])[@t](http://twitter.com/t)[1:]
cost = (1/m)*cost
return cost # Define first derivative of cost functiondef cost_dev(j, t, X=X, y=y, m=m):
dev = X[:, j]@(1/(1 + np.exp(-X@theta)) - y)
dev = (1/m)*dev
return dev# Define iterationscost_list = []theta_temp = np.zeros(theta.shape)theta_list = []for i in range(1000000):
for j in range(len(theta)):
if j == 0:
theta_temp[j] = theta[j] - a*cost_dev(j, theta)
else:
theta_temp[j] = theta[j]*(1 - (a*lmbd)/m) - a*cost_dev(j, theta)
theta = theta_temp
hypo = 1/(1 + np.exp(-X@theta))
theta_list.append(list(theta))
cost_val = cost(theta, hypo)
cost_list.append(cost_val)
我想谈一谈另一种流行的优化算法，牛顿法，它采用不同的方法来达到成本函数的全局最小值。类似于梯度下降，我们首先取 J(θ)的偏导数即 J(θ)的斜率，记为 f(θ)。牛顿方法不是通过某个选定的学习速率α乘以 f(θ)来减小θ，而是在先前θ和 x 轴处 f(θ)的切线的交点处获得更新的θ。经过一定的迭代次数后，牛顿法将收敛于 f(θ) = 0。
参见上面的简化图，从右边开始，黄色虚线是 f(θ)在θ0 处的切线。它决定了θ1 的位置，从θ0 到θ1 的距离是δ。重复该过程，直到找到服从 f(θ) = 0 的最优θ，即该图中的θ3。参见下面更新θ的公式。
显然，牛顿的方法不需要选择固定的学习速率，并且每次迭代的步长较大并且也是变化的，因此，在适当的特征和样本大小下，它通常收敛得更快并且相当有效。
未完待续…
损失函数(第三部分):支持向量机
继续这个旅程，我已经在第一部分讨论了线性回归的损失函数和优化过程，在第二部分讨论了逻辑回归，这一次，我们将前往支持向量机。
线性 SVM
让我们从线性 SVM 开始，它被称为无核 SVM。通过两个特征 X1 来看散点图，X2 如下。我们实际上用很多不同的方法来区分两个类别，粉线和绿线就是其中的两个。SVM 最终选择了绿线作为决策边界，因为 SVM 如何对样本进行分类是为了找到与最接近决策边界的样本距离最大的决策边界。这就是为什么线性 SVM 也被称为大幅度分类器的原因。
谁是支持向量？支持向量是被错误分类的样本或接近边界的样本。看下面的剧情。带红圈的样本就是决策边界。在 SVM，只有支持向量对模型训练有有效的影响，也就是说去除非支持向量对模型没有任何影响。为什么？我们会从它的成本函数中算出。
SVM 的损失函数非常类似于逻辑回归的损失函数。在下图中分别用 y = 1 和 y = 0 来看，黑线是逻辑回归的成本函数，红线是 SVM 的成本函数。请注意，这里的 x 轴是原始模型输出，θᵀx.记得把原始模型输出放入 Sigmoid 函数给了我们逻辑回归的假设。SVM 的假设是什么？简单明了。当θᵀx ≥ 0 时，预测 1，否则，预测 0。
然后回到损失函数图。铰链损耗，当实际为 1 时(左图如下)，如果θᵀx ≥ 1，则完全没有成本，如果θᵀx < 1，则成本随着θᵀx 值的降低而增加。等等！当θᵀx ≥ 0 时，我们已经预测了 1，这是正确的预测。为什么成本从 1 而不是 0 开始增加？是的，SVM 对不正确的预测和那些接近决策边界(0 < θᵀx < 1)的预测都给予了一些惩罚，这就是我们如何称它们为支持向量。当数据点刚好在页边空白上时，θᵀx = 1，当数据点在判定边界和页边空白之间时，0 < θᵀx < 1。稍后我会解释为什么一些数据点出现在页边空白内。至于为什么去除非支持向量不会影响模型性能，我们现在可以回答了。记住模型拟合过程是最小化成本函数。由于非支持向量根本没有代价，所以代价函数的总值不会因为添加或删除它们而改变。
让我们写出 SVM 成本函数的公式:
我们也可以将 SVM 正规化。例如，将 L2 正则化项添加到 SVM，成本函数变为:
与 Logistic 回归在正则项前使用 λ 作为参数来控制正则化的权重不同，相应地，SVM 在拟合项前使用 C 。直观上，拟合项强调通过寻找最佳系数来很好地拟合模型，而正则化项通过约束大的系数值来控制模型的复杂性。在训练数据集上很好地拟合模型与可能导致过度拟合的模型复杂性之间存在权衡，这可以通过调整λ或 C 的值来调整。λ和 C 都优先考虑我们对优化拟合项和正则化项的关注程度。放在成本函数的不同地方，C 实际上起到了类似于 1/λ的作用。
在 C 值非常大的情况下(类似于没有正则化)，这个大间隔分类器将对异常值非常敏感。例如，在下图左侧的图中，理想的决策边界应该像绿线一样，通过添加橙色的橙色三角形(异常值)，加上一个非常大的 C，决策边界将移动到橙色线，以满足大幅度规则。另一方面，C 还起到调整边距宽度的作用，这使得边距违例成为可能。见下图右侧。当 C 较小时，边距较宽，显示为绿线。粉红色的数据点违反了边界。这在处理不可分离的数据集时特别有用。因此，这就是正则化如何影响决策边界的选择，使算法适用于非线性可分离数据集，允许数据点被错误分类或有边界违规。
非线性 SVM
当决策边界不是线性时，假设和成本函数的结构保持不变。首先，让我们来看看。
你可能已经注意到，非线性 SVM 的假设和成本函数与线性 SVM 几乎相同，只是这里的“x”被“f”代替了。f 是 x 的函数，我接下来会讨论如何求 f。让我们从头开始。假设我们有一个样本(见下图)具有两个特征 x1、x2。我在 x 周围随机放了几个点(l⁽ ⁾，l⁽ ⁾，l⁽ ⁾)，称它们为地标。我想看看 x 分别离这些地标有多近，记为 f1 =相似度(x，l⁽ ⁾)或 k(x，l⁽ ⁾)，f2 =相似度(x，l⁽ ⁾)或 k(x，l⁽ ⁾)，f3 =相似度(x，l⁽ ⁾)或 k(x，l⁽ ⁾).
所以这叫做核函数，它就是你从上面的公式中看到的精确的‘f’。内核函数内部是什么？换句话说，我们应该如何描述 x 与地标的接近程度？有不同的类型。高斯核是最流行的一种。它是用两个向量的欧几里德距离和描述函数平滑度的参数σ计算的。高斯核提供了一个很好的直觉。如果 x ≈ l⁽ ⁾，f1 ≈ 1，如果 x 远离 l⁽ ⁾，f1 ≈ 0。在 Scikit-learn SVM 包中，高斯核被映射到’ rbf ‘，径向基函数核，唯一不同的是’ rbf '用γ来表示高斯的 1/2σ。
我们可以说样本 x 的位置已经被这三个核重新定义了。也就是说，非线性 SVM 根据与地标的接近度来计算新的特征 f1、f2、f3，而不再使用 x1、x2 作为特征，这是由所选择的地标决定的。这就是θᵀf 原始模型输出的来源。让我们试一个简单的例子。θᵀf = θ0 + θ1f1 + θ2f2 + θ3f3。指定θ0 = -0.5，θ1 = θ2 = 1，θ3 = 0，因此θᵀf 为-0.5 + f1 + f2。查看第一个样本(S1 ),它非常接近 l⁽ ⁾，而远离 l⁽⁾l⁽⁾，具有高斯核，我们得到 f1 = 1，f2 = 0，f3 = 0，θᵀf = 0.5。根据前面提到的假设，预测 1。样本 2(S2)远离所有地标，我们得到 f1 = f2 = f3 =0，θᵀf = -0.5 < 0，预测 0。基于当前的θs，很容易注意到靠近 l⁽ ⁾或 l⁽ ⁾的任何点将被预测为 1，否则为 0。绿线展示了一个大致的决策边界，如下所示。
我们刚刚用我手动选择的某些特征和系数完成了预测部分。那么，这些地标来自哪里呢？我们需要多少地标？好吧，你可能会惊讶，给定 m 个训练样本，界标的位置就是你的 m 个训练样本的位置。
也就是说，非线性 SVM 通过将您的每个训练样本与所有其他训练样本进行比较来重建特征。因此，由标志创建的用于预测的特征的数量是训练样本的大小。对于给定的样本，我们更新了如下功能:
关于重新创建特征，这个概念就像当创建多项式回归以达到非线性效果时，我们可以通过对现有特征进行一些变换(例如平方它)来添加一些新的特征。例如，您有两个特征 x1 和 x2。为了创建多项式回归，您创建了θ0 + θ1x1 + θ2x2 + θ3x1 + θ4x1 x2，因此您的要素变为 f1 = x1，f2 = x2，f3 = x1，f4 = x1 x2
让我们重写假设，成本函数，和正则化的成本函数。
为了获得良好的模型性能并防止过拟合，除了选择适当的正则项 C 值，我们还可以从高斯核中调整σ，以找到偏差和方差之间的平衡。以某个样本 x 和某个地标 l 为例，当σ很大时，核函数 f 的输出接近 1，随着σ变小，f 向 0 移动。换句话说，对于 x 和 l 之间的固定距离，大σ认为它“更近”，具有较高的偏差和较低的方差(欠拟合)，而小σ认为它“更远”，具有较低的偏差和较高的方差(过拟合)。
像逻辑回归一样，SVM 的成本函数也是凸的。SVM 最流行的优化算法是序列最小优化，可以用 python 中的‘libsvm’包实现。 SMO 通过将大型二次规划(QP)问题分解为一系列可解析求解的小型 QP 问题来解决该问题，从而在一定程度上避免了耗时的过程。在详细的计算方面，它非常复杂，包含许多数值计算技巧，使得处理非常大的训练数据集的计算更加有效。
总之，如果您有大量的要素，线性 SVM 或逻辑回归可能是一个选择。如果您的特征数量较少(1000 以下)并且训练样本的大小不太大，则高斯核 SVM 可能很适合您的数据。
最优化:引擎盖下的损失函数(上)
在建立机器学习模型时，我通常会想到类似这样的问题:模型是如何优化的？为什么模型 A 的表现优于模型 B？
要回答这些问题，我认为一个切入点可以是了解不同模型的损失函数，此外，能够根据项目的目标和误差类型的容限选择合适的损失函数或自定义损失函数。我将发表一系列博客，讨论几种常见的监督学习模型的损失函数和优化算法。我会尽量用对没有很强数学背景的观众友好的方式来解释。让我们从第一部分开始，线性回归。
对于监督学习，通过找到最小化成本函数的最佳系数来优化模型。成本函数是用损失函数计算的每个数据点损失的总和。我们选择使用的模型是我们的假设。这是线性回归模型的假设。
线性回归最常用的损失函数是最小二乘误差，其代价函数也被称为均方误差(MSE) 。
从公式中可以看出，成本函数是一条抛物线。为了最小化它，我们需要找到它的顶点。它可以通过分析或使用编程算法来解决。在这篇博客中，我将重点介绍最流行的编程解决方案之一，梯度下降，来完成优化过程。梯度下降广泛应用于不同的模型中，其基于学习速率α采取步骤，向抛物线的顶点移动以找到线性回归的全局最小值，该点也称为斜率等于 0 的点。为了得到斜率，我们对每个系数θ的成本函数求导。
From: https://hackernoon.com/gradient-descent-aynk-7cbe95a778da
接下来，通过大量迭代不断更新每个θ，同时观察成本函数的降低，直到它达到一条水平线。实际上，由于所选择的步长，斜率不可能达到 0 的精确值，但根据超参数，它可以尽可能接近 0。
现在记住这些概念，让我们使用真实世界的数据(来自 UCI 机器学习库的 Boston Housing 数据)。由于我在这篇博客中只演示了优化部分，所以我将跳过所有的过程，如探索性数据分析、特征工程等。，并直接转到数据标准化，为预测做好准备。我们来看看前几行数据。
为了解释简单，我选择了两个特征(RM:每套住宅的平均房间数，年龄:1940 年之前建造的自有住房的比例)来进行预测，目标变量是 MEDV(以 1000 美元为单位的自有住房的中值)。为了计算效率，我把所有的计算转换成矩阵格式。下面是用于假设、成本函数、成本函数导数的矩阵，以及用于矩阵计算的 python 查询。
# Instantiate a hypothesis
hypothesis = X@theta - y# Calculate cost function
def cost(theta, X=X, y=y, m=m):
cost = np.transpose((X@theta - y))@(X@theta - y)
cost = (1/(2*m))*cost
return cost# Calculate derivative of cost function
def cost_dev(j, theta, X=X, y=y, m=m):
dev = X[:, j]@(X@theta - y)
dev = (1/m)*dev
return dev
所有系数在开始时都设置为 1。下面的查询返回 100，000 次迭代来同时更新系数。当趋势开始变平时，这意味着梯度下降已经收敛，并且已经达到成本函数的最小值。
# Assign a learning rate
a = 0.001cost_list = []
theta_temp = np.zeros(theta.shape)
theta_list = []for i in range(100000):
for j in range(len(theta)):
theta_temp[j] = theta[j] - a*cost_dev(j, theta)
theta = theta_temp
theta_list.append(list(theta))
cost_val = cost(theta)
cost_list.append(cost_val)
我们能让这种趋势变得更好，更自信地说确实达到了最低水平吗？如果我们将学习率调整为 0.0005，迭代 1，000，000 次，会发生什么？
这种趋势看起来很疯狂。这并不是一个很好的成本函数演示，但我们可以对优化的结果非常有信心，假设最小均方误差达到当前设置。我们来对比一下刚刚手动从梯度下降算法得到的系数和从 Scikit-learn LinearRegression()得到的系数，数据集相同。
哒哒！他们几乎是一样的。这个博客的目标是揭示机器学习模型的基本优化秘密。梯度下降有许多高级变体，Scikit-learn 软件包中也应用了其他算法。当然，在大多数情况下，没有必要被那些数学问题所困扰。然而，能够理解引擎盖下的损失函数有助于我们作为机器学习工程师前进到下一个级别！
未完待续……
优化问题
最近，通过微软的一项计划，我有机会在乌干达坎帕拉作为一名部署数据科学家呆了两周。整个经历帮助我形成了对志愿者工作的一些看法，我想从我在非洲的时光中获得一些想法和经验。
在过去的一个月里，我收拾行李前往非洲，通过微软的一项名为 MySkills4Afrika 的计划前往坎帕拉，该计划旨在招募非洲缺乏技能的技术人员。我与四个合作伙伴——乌干达政府、乌干达发展金融公司、世纪银行和 MTN——合作，试图帮助他们重塑数据仓库、科学和分析能力。
Four organizations I worked with
起初，我有一个清晰的计划来做这件事。首先，获取他们的数据集，清理，参数化。第二，建立一个清晰的模型，提供一些商业洞察力。最后，共享该模型，以便组织可以复制和定制它。三步走，简单吧？没有那么多——在我来到这个国家的头几天，我很快意识到，我必须大幅改变我的方法。否则，我将成为非洲大陆上无数善意的志愿者中的一员，他们做着工作，但不一定是他们需要的工作。
那么，我要改变什么呢？事实证明，对于我工作过的组织来说，我必须采取一种更加量身定制的方法。每个人都有不同的数据基础架构、数据科学专业知识水平和与我相处的时间。
对于乌干达发展金融公司(DFCU)和世纪银行来说，他们都非常渴望与我会面，但缺乏数据专业知识，也不准备对他们的数据实施机器学习(ML)。因此，关于使用哪种语言、模型或方法的对话并没有特别大的帮助。相反，我花时间与 DFCU 和世纪银行讨论了他们可以采取的未来数据分析能力投资——自动化仪表板，这样员工就不会把所有时间都花在那里，并投资学习 SQL 和 Python，以便他们可以更轻松地挖掘数据。我提供了具体的例子，并向他们指出了他们可以利用的资源。
Isaac Niwamanya (business intelligence specialist at DFCU, left), Kenneth Kyobe (data analyst at Centenary Bank, right) and me
他们的数据科学负责人 MTN 在构建 ML 管道和模型方面经验丰富，因此我提供了实验设置反馈，并对他的代码进行了同行评审。在许多方面，与 MTN 的数据科学领导一起工作非常类似于我在微软与同事之间的互动。最后，对于乌干达税务局来说，他们对数据科学能力感兴趣，但希望获得一个具体的例子，说明如何利用这些能力来具体帮助他们的税收工作。为了给他们提供一些切实的东西，我访问了他们的数据子集，并建立了一个分类器，用于预测哪些地区将无法达到他们在本季度的预计税收目标。
Headquarters of Uganda Revenue Authority and MTN in Kampala
据我所知，每个组织都有这样一套独特的需求。在任何规划文件或旅行前电话中不明显的需求。不同的文化基础和动机。资金和变革意愿的梯度。关于数据对决策的重要性的各种立场。
在我的旅行之前，我已经陷入了许多其他非洲志愿者已经陷入的陷阱，我把乌干达归类为一个单层的国家，我认为一个适合所有人的志愿服务优化方法会有所帮助。甚至在我返回美国时，我发现自己反复被问及我在乌干达的经历，好像我在那里的时间是对整个非洲大陆的精确测量。作为第一代越南裔美国人，我非常清楚被一概而论地强加于你的挫败感。这种情况在世界其他地方已经屡见不鲜，我们不能在非洲继续犯同样的错误。自从我回到西雅图，开始与朋友和同事分享我的经历，我就试图突出乌干达惊人的多样性以及它在非洲大陆上的独特性。非洲的广大组织和人民不会从普遍的帮助中受益；相反，在志愿工作方面，他们应该得到量身定制的独特方法。
使用 Python 并发期货优化数据准备代码
最初发表于【www.easy-analysis.com】
只需几行代码，就能让您的 Python 代码为数据准备提供更快的执行速度。利用内置的 并发期货
这篇文章将讨论并展示在执行 Python 代码进行数据准备时，如何通过添加几行额外的代码来利用所有的 CPU 内核。
常见的数据准备任务
数据科学中一个非常常见的任务是数据准备。一个常见的任务可能是为模型训练准备图像。下面的代码片段演示了遍历文件夹中的图像、操作每个图像并最终保存每个更改的常见任务。
创建文件 compress.py
该文件应该包含以下代码。
函数 compress_image()检查图像的尺寸，并根据设置的 max_dim 调整尺寸。缩放图像尺寸时，纵横比保持不变。调整大小时，图像保存在内存中，而不是在光盘上，并检查大小。如果不满足 set image_size，则使用变量 max_dim 的较低值递归调用该函数，否则，用新尺寸覆盖图像。如果你想了解更多关于库 PIL 和木卫一的信息。BytesIO 请访问各自的文档。
下一个任务是使用这个函数来测量对任意数量的图像执行操作需要多长时间。出于测试的目的，我们将再创建一个 Python 文件。
创建文件 test_compress.py
该文件应该包含以下代码。
上面的代码创建了一个特定文件夹中所有图像文件的列表，在我的例子中是“…/data/test_compres/。png”，此外，我只希望将 PNG 文件添加到列表中。最后，对于列表中的每个图像路径，调用函数 compress_image(file_name)。库时间用于测量执行文件所用的时间。*
运行 test_compress.py 文件打印时间 6.6042399406433105 秒。这有点慢，因此，让我们通过使用 Pythons 的一个核心库 Concurrent futures 来提高速度。
使用 Python 并发期货
python 中的并发未来允许我们利用执行代码的机器上所有可用的内核。我们运行的第一个示例只使用了我的 Mac 上四个可用内核中的一个。让我们看看，如果我们使用全部四种方法，我们可以提高多少时间。
为了进行这种改进，我们需要导入一个新的库，并稍微更改文件 test_compress.py 中的代码。修改后的 test_compress.py 文件现在应该包含以下内容。
这个版本的文件 test_compress.py 与以前的版本略有不同。导入了一个新的库 concurrent.futures。现在以不同的方式调用了进一步的函数 compress_image()。并发期货用于创建可用资源池，我们使用 map 为 list_files 中的每个项目调用函数 compress_image()。就这样，现在让我们再次运行文件。
运行 test_compress.py 文件现在打印出时间 3.422382116317749 秒。这是大约 90%的改进。
结论
您可能已经注意到，如果一个内核可以在大约 6 秒内完成任务，那么四个内核可以在 1.5 秒内完成。然而，这通常取决于你的代码在做什么，对于其他任务来说，它甚至可以扩展得很好。然而，仅仅通过增加两行代码就实现了 90% 的改进，这实在是太棒了。
为了提高 Python 代码的性能，可能还有许多其他的优化方法。一个有趣的方法是使用 Cython 将你的 Python 代码编译成 C 代码。Cython 做得很好，你不需要知道任何 C 编程。使用 Cython 的话题不在本文的讨论范围之内，但是，这是一个值得探讨的有趣话题。
如果你有兴趣了解我更多。请访问我在 LinkedIn 上的个人简介https://www.linkedin.com/in/vedranmarkulj/
感谢阅读。如果你对我写的关于机器学习和类似主题的未来帖子感兴趣，请在 Medium 和 LinkedIn 上关注我。更多文章即将发表。
利用自动化机器学习优化您的电子邮件营销策略
个性化自动化
对全球企业来说，优化销售营销支出是一个价值 10 亿美元的问题，因为自 2017 年以来，每年有超过 1 万亿美元用于这项任务。然而，理解营销预算、行动和相关销售之间的关系是具有挑战性的，因为有许多同时发生且相互竞争的内部和外部因素会影响销售(心理、天气、情绪、位置、价格、广告……)。
由于机器学习技术能够在大型数据集上绘制复杂的关系，因此在该领域显示出了有希望的结果，但对于缺乏技术技能和背景的营销人员来说，它们的实施往往是一个障碍。入职顾问数据科学家的成本也很高，效率也很低，因为他们缺乏对市场营销和被营销行业的了解，无法提供有意义和可操作的见解。
在 [Mind Foundry](http://mind foundry.ai) ，我们相信问题所有者应该获得简单而可靠的工具来构建他们自己的数据科学解决方案，这就是为什么我们在 box 中建立了 AuDaS ，一个自动化数据科学团队。在这篇文章中，我们将看到营销人员如何使用 AuDaS 来设计他们的电子邮件营销活动，以提高他们的客户转化率和保留率。我们将使用 Corefactors.in 在 Kaggle 上托管的数据集。根据客户的各种属性和电子邮件的内容，我们试图预测的 3 种电子邮件状态是“忽略”、“已读”和“已确认”。
阶段 1:数据探索
将数据集上传到 AuDaS 后，我们会看到数据的快照，以及机器学习生成的关于如何清理和准备数据的建议。
AuDaS Data Preparation
例如，AuDaS 已经检测到 Email_ID 列没有预测能力，可以删除。它还检测到几列中缺少的值，并询问用户是希望填充它们还是删除它们。通过查看列名，我们知道可以按如下方式填充它们:
- 总共有 0 个链接、图片和过去的交流
- 客户位置的 NA
下图显示了我们如何通过几次点击来实现建议。
AuDaS 会自动为用户执行建议，同时在屏幕底部为应用于数据的每个操作创建审计跟踪。然后，用户可以返回到数据集的先前版本，并在必要时撤消步骤。
AuDaS 还自动生成直方图和特征相关性，为用户提供数据结构的高级概览。
阶段 2:建模
对于这个电子邮件营销数据集，我们希望根据其他属性来预测电子邮件的状态(忽略、阅读、确认)，这意味着我们正在尝试解决一个 分类 问题。
在指定了我们要预测的列( Email_Status )之后，AuDaS 提供了一个健壮的框架来构建分类管道，该管道可以推广到其他数据集，而不会失去过多的预测能力，这通常是由过拟合引起的。这包括:
- 出于最终模型验证的目的，自动保留数据集的 10%平衡保留
- 执行 10 重交叉验证
- 优化 F1 分数
高级用户可以将这些默认值更改为他们的首选设置(N 倍、分割、可优化指标等)。
然后，AuDaS 将使用 Mind Foundry 的专有贝叶斯优化器( OPTaaS )在数百万个可能的解决方案中高效导航，以在不到 100 次迭代中确定最佳分类管道(特征工程、模型和最佳参数)。
在执行这种搜索时，AuDaS 向用户提供了关于测试管道、模型和参数值及其相关性能统计和特征相关性的完全透明性。
对于指定的分类模型，字数、过去的总通信量和主题热度是预测电子邮件状态的最相关的特征。用户还可以访问 AuDaS 尝试过的所有单一模型的完整审计跟踪。
阶段 3:模型验证和部署
当用户对模型性能满意或已经完成 100 次迭代时，AuDaS 将在 10%平衡支持下验证模型，并提供模型健康建议。在我们的案例中，对保留数据的测试与优化过程中的交叉验证测试一致，模型健康状况良好。这意味着用户可以对模型提供的见解充满信心，并将其部署到生产中。
然后，用户可以上传测试集来预测电子邮件状态结果，对模型进行评分，或者通过可以集成到您的产品中的 RESTful API 自动部署它。
API documentation for the classification model
AuDaS 还提供了对预测的时间解释，让你了解每个特征对预测结果的贡献。一个简单的 web 应用程序展示了你如何与训练好的模型进行交互:
阶段 4:提高性能
在我们的第一次运行中，我们对所有 3 个类的分类准确率为 51%,这比随机分类要好，但并不理想。我们知道电子邮件状态值 0、1、2 代表忽略、已打开和已转换，为了提高模型的性能，我们可以尝试重新组合 0 和 1，因为它们的结果对于营销人员来说是相同的。通过在数据准备阶段重新分组类别并重新训练模型，我们能够在 10%的保留率上实现 73.7%的更好的分类准确度。
更完整的教程可以在下面查看:
如果您喜欢这篇文章，并且很想知道您还可以用 AuDaS 解决什么问题？检查我的其他职位如下:
[## 利用 AuDaS 在几分钟内解决 Kaggle Telco 客户流失挑战
AuDaS 是由 Mind Foundry 开发的自动化数据科学家，旨在允许任何人，无论是否有…
towardsdatascience.com](/solving-the-kaggle-telco-customer-churn-challenge-in-minutes-with-audas-2273fed19961)
如果你有兴趣尝试奥达斯，请不要犹豫，联系 out ！
【更新:我开了一家科技公司。你可以在这里找到更多的
团队和资源
Mind Foundry 是牛津大学的一个分支机构，由斯蒂芬·罗伯茨(Stephen Roberts)和迈克尔·奥斯本(Michael Osborne)教授创建，他们在数据分析领域已经工作了 35 年。Mind Foundry 团队由 30 多名世界级的机器学习研究人员和精英软件工程师组成，其中许多人曾是牛津大学的博士后。此外，Mind Foundry 通过其分拆地位，拥有超过 30 名牛津大学机器学习博士的特权。Mind Foundry 是牛津大学的投资组合公司，其投资者包括牛津科学创新、牛津技术与创新基金、、牛津大学创新基金和 Parkwalk Advisors 。
Python 中优化的 I/O 操作
使用 Python 的数据科学堆栈加速分析的输入/输出技巧
在处理数据密集型应用程序时，我经常面临输入/输出(I/O)挑战，这是每个性能关键型应用程序的瓶颈。随着存储数据量的增加，有必要将数据存储在磁盘中，以通过将数据从磁盘加载到 RAM 来弥补 RAM 的不足，反之亦然。因此，在处理金融数据或任何科学数据时，I/O 操作本质上是非常重要的任务。
通过这篇文章，我试图揭示一些图书馆和他们的商业技巧。Python 有内置的功能，可以用来将对象存储在磁盘上，并从磁盘读取到 RAM 中。此外，Python 在处理文本文件和 SQL 数据库时非常健壮。Pandas 库提供了大量的类和方法来读写各种格式的文件。
我们将在这里研究以下领域的数据存储和检索方法:
- 使用 Pickle 模块的序列化存储
- 对文本数据的 I/O 操作
- SQL 数据库
- 具有 PyTables 的 I/O
在 Python 语言中优化 I/O 操作时要考虑的两个主要因素是效率(性能)和灵活性。让我们直入主题:
使用 Pickle 模块的序列化存储
Python 语言中有许多模块，可以在大规模部署环境中轻松使用。
使用 pickle 模块读写文件
您需要将数据存储在您的磁盘上，以便以后共享、记录或使用。我们有 pickle 模块，它序列化 python 对象以快速进行读写操作。
# On running the above code snippet, you'll see:CPU times: user 40.9 ms, sys: 14 ms, total: 54.9 ms
Wall time: 54.5 ms
随机浮点构建一个 9MB 的文件，该文件被序列化为字节流并在 54.9 毫秒内写入磁盘。您将使用 pickle 模块的 dump 和 load 函数分别写入和读取文件。要断言序列化和反序列化的数据，可以使用 Numpy 的 allclose 方法。你可以这样做:
np.allclose(np.array(a1), np.array(a2))# here a2 is the deserialized object after reading the same file
# using the load function.
因此，pickle 模块存储了 python 列表、dict 等。在将它们转换成磁盘上的字符流之后。这里的关键是这个字节流包含了在另一个 python 脚本中重建对象所必需的信息。
对文本数据的 I/O 操作
Python 一直是最受欢迎的语言，尤其是在处理文本文件时，因为它具有处理文本数据的健壮性和易用性。有几个选项来操作字符串对象和一般的文本文件。
要编写 CSV(逗号分隔值)，我们可以使用 write 和 readline 方法:
csv_file.write(header)# time is time array and data is the dummy numpy array
**for** time, (a, b, c, d, e) **in** zip(time, data):
s = '%s,%f,%f,%f,%f,%f**\n**' % (time, a, b, c, d, e) csv_file.write(s)csv_file.close()# to read the file, we can use readlines function
content = csv_file.readlines()
虽然 python 提供了处理文本文件的方法，但是我们有 pandas 库，它可以读写各种数据格式，并且更好更容易获得。
无论是 CSV(逗号分隔值)、SQL(结构化查询语言)、XLS/XLSX(Microsoft Excel 文件)、JSON(Javascript 对象表示法)还是 HTML(超文本标记语言)。
熊猫让整个 CSV 文件的读写过程变得更加方便、简洁、快捷。
%time data.to_csv(filename + '.csv')# CPU times: user 5.59 s, sys: 137 ms, total: 5.69 s# And to read the files back from the diskpd.read_csv(<path to the CSV file>)
SQL 数据库
Python 附带了对 SQL 数据库 SQLite3 的支持。使用 python，我们可以处理几乎任何类型的数据库(SQL 或 NoSQL)。
SQL 查询被写成字符串对象，其中语法和数据类型取决于所使用的数据库。说明了在 SQLite 数据库中通过 python 创建 Todo 表:
import sqlite3 as sq# query string to create the tablequery = 'CREATE TABLE TODO_NUMBER (Num1 real, Num2 real, Num3 real)'
con = sq.connect(path + 'todo.db')
con.execute(query)
con.commit()
让我们尝试在创建的数据库中插入一些数据，
data = np.random.standard_normal((1000000, 3))
%%time
con.executemany('INSERT INTO TODO_NUMBER VALUES (?, ?, ?, ?, ?)', data)
con.commit()# Time taken: CPU times: user 10.3 s, sys: 316 ms, total: 10.6 s
Wall time: 11 s
将 100 万行写入数据库是一项有点繁重且耗时的任务。读取数据库要快得多:
con.execute('SELECT * FROM TODO_NUMBER').fetchall()
如果在数据库中处理大量的数字和数组，可以利用 Numpy 数组将数据直接读入 numpy ndarray。
np_query = 'SELECT * FROM TODO_NUMBER WHERE Num1 > 0 AND Num2 < 0'
res = np.array(con.execute(np_query).fetchall()).round(3)
这是一个非常好的技巧，可以毫不费力地读取和绘制查询结果。为了使读取更加高效和优化，我们应该使用 pandas 读取整个表和查询结果。当整个表被加载到内存中时，分析和处理变得更快。这是通过使用子库 pandas.io.sql 实现的
import pandas.io.sql as pds
data_df = pds.read_sql('SELECT * FROM TODO_NUMBERS', con)
该表现在被加载到内存中，这使得处理速度更快。使用 SQLite3 需要几秒钟的 SQL 查询在内存中使用 pandas 时在几毫秒内完成:
%time data_df[(data_df['Num1'] > 0) & (data_df['Num2'] < 0)].head()# CPU times: user 50 ms, sys: 0 ns, total: 50 ms# Wall time: 49.9 ms
我们可以用 pandas 掌握更多复杂的查询，它会比 SQL 更快地产生结果，但它不能取代 SQL。鉴于 pandas 能够复制 SQL 查询，我们可以使用 pandas 的内存处理显著加快分析速度。
这里需要注意的一点是，pandas 并不是用来取代 SQL 数据库的，目前它也不能取代 SQL 数据库。Pandas 不支持关系数据结构。
具有 PyTables 的 I/O
PyTables 是针对 HDF5 数据库/文件标准的 Python 绑定。它是专门为增强 I/O 操作的性能和充分利用可用硬件而设计和开发的。它在加速分析和更快生成输出方面做得非常好。PyTables 数据库可以容纳许多表，它支持压缩和索引，还支持对表的重要查询。
PyTables 具有基于文件的数据库格式。让我们看一下表格的工作原理，
这将为我们创建一个带有指定数据类型的必需字段的表。现在让我们填充数据库，我们必须创建一些随机值，并将它们逐行写入表中，如下所示:
但是同样，我们有一种更优化和 Pythonic 化的方法来达到相同的结果，即利用 NumPy 结构化数组:
dty = np.dtype([('Num1', 'i4'), ('Num2', '<i4')])sarray = np.zeros(len(ran_int), dtype=dty)
现在我们已经在表中设置了完整的数据，这一切都归结为表的创建，如下所示:
%%time
h5.create_table('/', 'ints_from_array', sarray,title='Integers', expectedrows=rows, filters=filters)
这种方法速度更快，而且我们用更少的代码行完成了同样的结果。我们可以使用以下命令删除重复的表:
h5.remove_node(‘/’, ‘ints_from_array’)
pandas 和 PyTables 都能够处理复杂的类似 SQL 的查询、索引和选择。就 I/O 操作而言，它们都经过了速度设计和优化。
使用 PyTables 的一个主要优点是它的压缩操作方式。它使用压缩不仅可以节省磁盘空间，还可以提高 I/O 操作的性能。
结论
一般来说，金融或科学中的许多企业级应用领域只需基于阵列的数据建模就能取得成功。在大多数情况下，结合使用 NumPy 和 PyTables I/O 功能可以显著提高性能。事实证明，基于 HDF5 的商店是所有方法的独特补充。
如果你有复杂的数据结构，表现出单个对象/表之间的许多关系，关系数据库有它的优点。这在某些情况下可能证明是合理的，在这些情况下，与纯基于 NumPy ndarray 或基于 pandas DataFrame 的方法相比，存在性能劣势。
Harshit 的数据科学
通过这个渠道，我计划推出几个涵盖整个数据科学领域的系列。以下是你应该订阅频道的原因:
- 该系列将涵盖每个主题和副主题的所有必需/要求的高质量教程。
- 解释了为什么我们在 ML 和深度学习中做这些事情的数学和推导。
- 与谷歌、微软、亚马逊等公司的数据科学家和工程师以及大数据驱动型公司的首席执行官的播客。
- 项目和说明，以实现迄今为止所学的主题。
你可以在 LinkedIn 、 Twitter 或 Instagram 上与我联系(在那里我谈论健康和福祉。)
注意:在这些黑暗的时期，自我隔离为自我提升腾出了一些空间，我们可以利用这些空间来发展新的技能、爱好，并帮助未来的自己。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
