了解你的敌人
为什么对立的例子比你意识到的更重要
Photo by naomi tamar on Unsplash
对抗性的例子是对 ML 模型的输入，这些模型是特制的，以使模型出错——计算机的视错觉。如下所示，典型的对立例子是通过在自然图像中加入少量精心计算的噪声而产生的。事实上，这种攻击可以欺骗最先进的图像识别模型，同时通常人类察觉不到，这表明了人类和深度卷积网络处理视觉信息的方式存在根本差异。这不仅提出了有趣的理论问题，而且也对神经网络在安全关键应用中的就绪性提出了质疑。
Adversarial example from Goodfellow et al. In this an imperceptibly small amount of noise is added to the first image to trick GoogLeNet — the state of the art ImageNet model in 2014.
对立的例子是一种特别有趣的机器学习现象，因为围绕它们有太多开放的问题。为什么他们愚弄深度网络而不是人类？有可能完全保护神经网络免受这些攻击吗？到目前为止，还没有人能够制造出一个对对立例子完全鲁棒的 MNIST 数字分类模型，尽管 MNIST 被大多数机器学习实践者视为一个玩具问题。
本帖将涵盖以下内容:
- 如何创造一个对立的例子
- 定义和分类敌对的例子和攻击方法
- 对立的例子转移到物理世界
- 对立范例在模型间的转移
- 对立的例子转移到人类身上(kinda)
如何创造一个对抗性的例子
创建对立样本非常简单，并且与神经网络的训练方式(即梯度下降)密切相关。梯度下降的原理很简单。要找到一个未知函数的最小值，首先从一个随机点开始，然后向该函数的梯度方向迈出一小步。对于足够小的步长和非病理函数，这将总是收敛(至少收敛到局部最小值)。
Gradient descent finding the minimum of f(x) = x²
为了将此应用于网络训练，我们首先定义训练数据和网络参数的损失函数(如均方误差，如下所示),该损失函数表示模型输出对于特定样本的错误程度。因此，找到这个损失函数的最小值相当于找到一组好的网络参数。
Mean squared error loss for a single sample, x, and label y. Theta represents the weights of a neural network.
其次，我们将这种损失相对于参数θ进行微分，并更新参数，使得该样本上的损失将减少。在实践中，有更多的细节，如学习率，批量大小，势头等。但原理只是梯度下降。
创造一个对立的例子是通过颠倒这个过程来完成的。如果我们保持模型的参数不变，并对输入数据, x 的损失进行微分，那么我们可以更新 x ,使得模型的预期损失在该样本上增加。
Gradient ascent on the sample, x, to increase the loss L
快速梯度符号法
在这一节中，我将讨论图像像素的扰动，只是为了说明不仅仅是图像分类模型容易受到恶意攻击。
这就把我们带到了快速梯度符号法(FGSM)，这是创造一个对立例子的最简单的方法。这与梯度上升的单个步骤完全相同，除了我们将每个像素上的扰动固定为固定大小ε，因此保证在相反的例子中没有像素比原始图像大ε。这个方法产生了这篇文章顶部的例子。
在实践中，这种简单的非常简单的方法导致现有技术的 ImageNet 模型的准确性下降到几乎为零，而图像对于人类来说是察觉不到的。这对神经网络具有超人的图像识别性能(经常在 ImageNet 上声称)的形象来说是一个相当不幸的打击，并暴露了深度神经网络学习的分类函数中的一些根本盲点。你会将自动驾驶汽车中的视觉处理交给一个可能被几个移动像素愚弄的网络吗？
Alternative meme: “One-weird trick to fool any neural network — ML ENGINEERS HATE HIM”
为什么神经网络容易受到这些攻击？
尽管这可能是围绕对立例子的最有趣的问题，但我不能给你一个满意的答案——这是一个完全开放的问题！已经提出了许多建议，包括
定义对立的例子
在我继续展示一些从对立的例子中得出的有趣结果之前，我将把它们正式化，并对可以执行的攻击类型进行分类。
对抗示例通常被定义为满足以下条件的ε有界示例x’
即，具有参数θ的分类器的决定不是真正的标签 y 。有界对抗性例子也满足
即，在特定的范数(也称为测量距离的方式)下，对立示例和原始示例之间的距离小于某个小ε。
规范 p 的选择决定了对对立例子的限制。所有这些规范都旨在量化一个对抗性的例子对人类来说是多么难以察觉。
- l⁰·诺姆。ε限定了相对于 x 可以修改的**x’**中的像素总数(尽管它们可以被修改任意数量)
- L norm。ε限定了**x’**中像素值和 x 中相应像素值之间的总平方距离。
- L∞又名最大范数。ε限定了**x’**中任何像素与 x 中相应像素之间的最大差值。
然而，最近的一些工作采取了不同的方法，采用了不同的方法，并使用了一个无限的定义。对抗性扰动是对图像的任何修改，它保留了原始图像的语义，但欺骗了机器学习模型，即使攻击可能被人类察觉。这是一类定义不太明确的扰动，但正如下面的例子所证明的那样，这是一类有用的扰动。
Unrestricted adversarial attacks on MNIST. These images are adversarial in the sense that the semantic meaning is preserved for humans but led to incorrect classifications from a machine learning model.
对敌对攻击进行分类
可以在机器学习模型上执行的算法类型(也称为攻击)也可以分类。
- 白盒攻击。攻击者可以访问完整的模型架构，包括它的梯度
- 黑箱攻击。攻击者不能访问模型梯度，而只能访问概率得分或者更严格地说，只能访问最终模型决策。
你可能会提出一个问题，尽管像上述 FGSM 方法这样的白盒攻击非常有效，但攻击者有多大可能获得为自动驾驶汽车的视觉组件供电的网络的全部权重？事实证明，黑盒攻击和白盒攻击一样有效。这一事实以及我将在接下来的几段中与您分享的一些结果，使得对抗性攻击的安全含义更加真实。
对立例子的迷人特性
对立的例子转移到物理世界
读到这里，你可能会认为对立的例子只是学术上的好奇，或者至少局限于数字环境，比如躲避垃圾邮件过滤器。人们很容易相信，到目前为止你所看到的难以察觉的失真在现实世界中永远不会有效，因为它们会被相机质量、视点、照明等的变化所破坏……嗯 库拉金等人 想和你谈谈。
Figure 1 from https://arxiv.org/pdf/1607.02533.pdf demonstrating that print-out photos of adversarial images can fool classifiers in real life. In this case an Inception network is fooled into classifying a picture of a washing machine is a safe.
在他们出色的论文中，Kurakin 等人演示了对 TensorFlow 相机演示应用的黑盒攻击，该应用使用了强大的 Inception 分类器。他们能够证明，用 FGSM 方法创建的对立范例的打印输出正确分类的比率是常规范例打印输出的一半。这是一个远不如数字领域成功的攻击，但仍然是对神经网络的一个打击。
Athalye 等人更进了一步，通过发明期望超过转换(EOT)攻击来生成真正健壮的真实世界对抗实例。EOT 攻击的前提如下:我们预计一些对抗性的扰动将由于自然发生的图像变换(照明、视点等)而变得无效，因此我们应该优化我们的对抗性示例来说明这一点。他们通过使用交替梯度上升步骤和随机变换的迭代攻击过程来实现这一点。
Adversarial turtle from Athalye et al. Athalye et al were able to use their EOT method generate a 3D printed turtle that was reliably classified as a rifle from most viewpoints.
用类似的方法布朗等人能够使用 EOT 攻击生成一个敌对标签，可以打印出来并应用到任何图像上。这些对立的例子被设计成在大范围的位置、比例、旋转和背景图像上是鲁棒的，因此可以应用于任何东西。这些攻击扩展了对抗性示例的定义，因为它们对人类来说是清晰可见的，但是它们也产生了一些伪装的版本。一个占图像 10%的敌对补丁能够在 90%的时间里欺骗网络。相比之下，一个相同大小的烤面包机的标签在 10%的情况下导致了烤面包机的分类！
Left: adversarial patch successfully fooling a VGG16 network into classifiying a banana as a toaster. Right: a variety of disguised and undisguised adversarial patches, plus a real toaster for reference. See this YouTube video for a demonstration.
也许这只是我的看法，但我发现敌对贴纸在艺术上令人愉悦，事实上它甚至包含了一些类似烤面包机的视觉特征！一般来说，对抗性例子越强，就越符合人类的感知。这一有趣的现象是一个经验主义的暗示，表明人类感知和卷积神经网络之间存在某种联系——这是我将在后面的章节中更多讨论的内容。
对立范例在量词间的转移
当我第一次发现对立的例子时，我认为一个显而易见的防弹攻击是使用一组模型。一个对立的例子显然可以通过利用特定梯度的特性来欺骗一个模型，但它永远不会同时欺骗多个模型，对吗？事实证明我错了。
Table 1 from Liu et al.
刘等全面考察了对立范例在多种分类器上的可迁移性。上表中的每个单元格显示了为攻击行模型而生成的对立示例上的列模型的准确性，例如，第一行中左起第四个单元格表明对 ResNet-152 的攻击导致 VGG016 的准确性下降到 20%(从 70%)。因此，我们可以看到，一群顶级模特仍然有可能被针对单个模特的攻击所愚弄！
作者更进一步，通过对 Clarifai.com和 T3发动黑盒攻击，使用精心制作的对立例子来欺骗分类器群，充分证明了对立例子的可转移性。他们推断，既然我们不知道 Clarifai 模型的数据集、架构或训练程序，那么他们可以通过欺骗合奏来提高他们的机会。令人印象深刻的是，使用这种方法，他们能够让 Clarifai.com 模型在 76%的情况下生成不相关的标签！
Clarifai.com tags before and after adversarial perturbation.
仍然有理由相信只有神经网络容易受到这种攻击，但 Papernot 等人表明，对立的例子在各种模型类型之间转移，包括经典的机器学习算法，如支持向量机和决策树。
我相信本节中讨论的结果提供了证据，证明对立的例子不是任何特定模型的缺陷，而是在高维空间中执行分类时可能固有的问题。一些最近的结果支持这个观点，但是很明显人类能够避免这种情况。
对立的例子愚弄了有时间限制的人类
在前面的章节中，我已经向你展示了强大的对抗性例子更符合人类的感知，并且对抗性例子可以在分类器之间转移。在这篇精彩的论文中，Elsayed 等人展示了对立的例子可以转移到所有分类器中表现最好的——人类视觉系统。
这项精心设计的研究中，人类参与者重复执行以下试验的变体:
- 参与者被要求将目光投向屏幕中央的十字
- 参与者被短暂地呈现了一个大约 65 毫秒的图像
- 参与者都带着高对比度的随机面具(我不确定为什么需要这一步)
- 将图像分为两类，例如猫和狗
Visual summary of the experimental setup.
你可能已经注意到，参与者只能在很短的时间间隔内看到图像。事实上，这项研究旨在通过以下选择，最大限度地增加将对立的例子传递给人类的机会
- 人类是有时间限制的。这限制了大脑可以使用自上而下和循环处理的数量，并且被认为使视觉处理更类似于人工前馈神经网络
- 对立的例子是从 10 个高性能 ImageNet 模型的集合中创建的，并使用比典型情况大得多的扰动
- 重要的是，这些扰动对人类来说是可见的，但不会改变一个没有时间限制的人的决定——它们保留了原始图像的类别
尽管如此，对抗性攻击降低了人类在这些试验中的准确性，降低了大约 10%,并且参与者的池足够大，使得这一结果具有统计学意义！
Part of figure 3 from Elsayed et al. This is an example of an adversarial image that was able to fool time-limited humans. Original class: spider, adversarial class: snake. Note that although the adversarial perturbation is visible (and contains some snake-like features, especially around the strand of silk) it is still clearly a picture of a spider.
在我看来，这篇论文展示了深层卷积网络和人类视觉的初始快速视觉反应之间的明确联系。然而，人类的视觉比第一个反应要复杂得多，涉及到不同感兴趣区域之间许多被称为扫视的眼球运动。有可能人类视觉系统的这个或一些其他特征是“秘密调味汁”，使人类视觉不受对立例子的影响，尽管甚至人类视觉也会遭受视错觉的影响(尽管这些与对立例子非常不同)。或者，也许有一天我们会发现一种方法，为无限时间的人类产生对立的例子——一个真正令人不安的想法！
我不能说这篇文章是对对立例子的全面回顾，因为我只触及了这个领域中正在做的杰出工作的一小部分，但是我希望在读完这篇文章后，你会同意我的观点，对立例子是一种迷人的现象。我相信有一天研究界会发现图像识别技术不会受到攻击，并且在这个过程中我们会学到很多关于人类视觉系统的知识。
请继续关注后续文章，在这篇文章中，我将用代码指导您完成一次具体的对抗性攻击。我还将从最近的文献中提供一种对抗性训练方法，并说明它提供了一些意想不到的好处！
更新: 这里是 。
知识架构——做出更好决策的途径
Photo by Patrick Tomasso on Unsplash
在许多行业和领域，很少有组织不是数据的消费者和生产者，却能在现代成功运营。这实际上并不是一个新现象——在 20 世纪的大部分时间里，整个工业时代，组织和企业都会采用某种形式的数据，对其进行处理和理解，并使用这些知识来提高他们完成使命的能力。
从根本上改变的是廉价的、可扩展的平台的到来，这些平台可以生成非常大的数据集，以及从这些数据集提取意义的新工具和技术的诞生。这些技术为希望正确管理其数据的组织提供了很多希望，但它们通常以特定的方式部署，用于解决特定部门的特定问题，而不允许更大的群体受益。
知识架构是在上下文感知框架中对数据资源的战略管理，提供了一个组织数据的关联和可解释视图，以支持更好的决策。
不投资知识架构的成本是什么？
1。收集大数据会导致更大的问题
大数据一词流行于 21 世纪初，指的是最近收集和存储数据集的能力激增，这些数据集通常太大，无法通过传统方法进行解释。在这种情况下,“大”一词是相对的——它同样适用于从几十个参与者那里接收数据的小型社区团体，或者试图协调多个国家和时区的运营的国际组织。这是因为虽然收集的规模可能会改变，但如何解释和理解数据的复杂性是不变的。
值得深入思考一下为什么会出现这种情况。一个组织所采用的几乎任何新技术都会立即产生数据——在线财务系统会产生支出和收入记录。库存系统记录资源的数量、位置和状态。工作流管理系统产生关于谁做了什么、工作的性质、克服的问题和实现的结果的历史数据。这些数据流中的每一个都在帮助人们理解组织如何运作方面发挥着重要作用，但它们通常是支离破碎的，并通过不同的存储和解释方法保持不可访问。财务数据可能存在于图表中，库存数据可能存在于电子表格中，工作流数据可能存在于非结构化的人工编写的文本中，这些数据似乎与更结构化的数据类型无关。
如果没有一个有凝聚力的框架来连接这些不同类型的数据，组织就无法做出明智的决策。如果他们幸运的话，他们的员工愿意花时间从一个来源移动到另一个来源，构建一个基于他们的决策的心理图像，但是这本质上是缓慢和困难的。如果不是，他们的人只是根据不完整的信息做出决定。这两种方法都不会有好结果。
2。随着复杂性的增加，很容易忘记你的任务
在大多数组织的早期阶段，使命是明确的，复杂性是最小的。大多数组织的存在都是为了解决现实世界中的问题，并且是由那些相信自己能够解决问题的人发起的。但是，如果它存在的时间足够长，任何团队的工作都会开始变得复杂，要么是因为工作的性质发生了变化，要么是因为他们处理工作的方式发生了变化。
对于在以人为中心的领域中开展的努力来说，尤其如此。人群聚集在一起，相互作用，又以有时违背人道主义和理性的基本逻辑的方式分裂。然而，正是这些群体是许多组织为了完成使命最需要了解的。如果没有一个连贯的框架来理解这些团体产生的数据，简单地管理解释意义的任务很容易使你的任务失去它所需要的重点。
3。跨多个数据集的误解更有可能
它不必像臭名昭著的洛克希德·马丁/美国宇航局，帝国/公制失败摧毁了 1999 年的火星气候轨道器——任何数据集的收集都可能包括如何适当格式化和呈现不同类型数据的假设。即使不是关键任务，这些假设在没有事先了解它们之间的差异的情况下试图将它们连接起来时，也会导致糟糕的结果。
一个设计良好的知识框架将这些约定问题作为一个起点，并抽象出技术差异以创建一个无缝的数据结构作为决策的基础。可能在不同术语下报告相同事物的数据也可以得到适当的处理，使决策过程更加清晰。
投资知识架构有什么好处？
1。它允许一代工人通知下一代，而不需要做额外的工作
大多数组织都经历过失去一个长期服务的员工所带来的负面影响，这个人非常了解如何把事情做好。这些人变得如此有价值和难以替代，因为他们通过经验学习如何驾驭工作环境，并找到成功的方法，尽管存在任何技术限制。他们对一个组织有本能的了解，然后有一天他们离开了，这种了解也就消失了。
好的知识架构能够随着人们的学习而发展，以捕捉他们的经验和见解，而不是传统的方法，希望在时间允许的情况下编写文档。如果有人带来了新的数据流，因为它有助于他们的角色，这些数据应该很容易被吸收到框架中，从而使每个人受益。构建以协作为核心的基础设施是实现这一目标的关键。
2。它打开了数据的更多维度，允许发现意想不到的趋势
了解你的组织的状态和你的数据告诉你什么是一回事。了解上周、上个月和去年的情况，以及未来的走向，完全是另一种体验。也许您的操作正在正常运行，或者也许它们在响应一个不寻常的事件时出现了异常。或者，也许他们正悄悄地、稳步地朝着一个尚未完全意识到的方向前进。无论实际情况如何，如果您只有单一时间点的数据视图，您将无法轻松地将这些趋势纳入您的决策流程，也无法对影响您执行任务能力的变化做出响应。
构建知识架构时考虑了您的组织如何随着时间的推移而运作，可以捕捉数据中与时间相关的适当方面，并以能够为您提供更多见解的方式将它们联系起来。牢记趋势分析来重新评估您的情况永远不会太晚，因为即使是相对较短的数据变化历史也可以帮助开始了解您的组织的发展方向。
3。重要的创新经常发生在部门之间，而不仅仅是部门内部
围绕数据的对话经常使用术语孤岛。这指的是特定类型的数据通常是自己存储的，因为这是相关部门处理数据的方式，也是我们的大脑组织事物的方式。你不会把刀、勺子和叉子都放在厨房抽屉的同一个隔间里。你把它们分开，因为这是你使用它们的方式。对商人和他们的工具箱来说是一样的，对图书管理员和他们的书来说也是一样的。
组织数据的区别在于，它比器皿、工具或书籍承载了更多的细微差别和联系，当整合到一个统一的视图中时，有相当大的潜力释放新的机会和视角。这不仅仅是一个部门更好地了解另一个部门在做什么，而是利用现代技术来揭示以前看不到的关系和原因。'快乐的意外’经常以这种方式发生，知识架构使这成为可能。
我如何开始？
如果你已经决定认真审视你的组织的知识架构，确保你以正确的方式进行以获得最大的投资回报是值得的。取决于你从哪里开始，这个过程可能看起来不同，但以下步骤通常是一个好的起点。
1。与你的人交谈，了解他们的问题和知识差距
规划你的知识架构应该总是从理解它试图解决的问题开始。很多时候，新兴技术被作为一种通用的解决方案提供，但是任何项目，如果不能明显地让组织的员工在履行他们的职责时受益，就不可能持久。
最了解什么问题影响着一个组织的人是在这个组织中工作的人。不应该期望他们定义解决方案，但是在了解当前情况时，应该仔细倾听他们的意见。这些对话并不总是容易进行的——讨论问题有时会被认为与责任和指责的想法交织在一起。一个外部团体帮助你完成这个过程可能是一个好主意。
2。确定并了解您现有的数据来源
选择正确的技术路线需要了解您正在处理的不同类型的数据，因此组织一个完整的清单是一个明智的起点。
这也是开始查看数据集的不同特征的好时机，尤其是当它们相互关联时。每种类型的数据告诉了你什么，或者没有告诉你什么？两者有何相似之处，或有何不同？花些时间思考这些问题有助于确定连接数据的正确方法。
3。为工作选择合适的工具
只有当您清楚地了解了您试图解决的问题，并充分理解了您组织的数据环境后，您才应该选择和实施技术堆栈。这与许多技术过程发生的方式相反，但正如前面提到的，它有助于防止新的、过度宣传的产品被视为解决可能不存在的问题的简单方法。
正确的技术选择将取决于您组织的独特情况，但有一些反复出现的主题，将您的数据视为事件或变化的流，而不是简单的最后已知状态，可以帮助识别趋势。同样，提升数据中实体之间关系价值的技术可以帮助连接看似不相关的来源，提供组织各方面状态的一致画面。
最后的想法
知识架构并不是一个新概念，但在现代数据驱动的环境中实现它的方式已经发生了变化。大多数组织并不缺少数据——事实上，他们现在经常不得不满足于试图管理太多的数据。与此同时，决策需要基于分散的、静态的资源，这些资源不能以应有的有意义的方式相互关联。
着手解决组织的知识管理有时会遇到阻力，因为它经常与机器学习和人工智能一起讨论，这些技术已被用于自动化某些类型的人类工作。真正的知识架构并不是用技术取代人，而是让他们能够做出更好的决策。有无数的领域(特别是那些以人为中心的领域，如前所述)，只有有经验、有觉悟和有同情心的人才能决定如何前进，以尊重他人背景和文化并维护其尊严的方式与其他人合作。将这些决策建立在能够充分描述环境的关联、准确数据的基础上，是向更好的结果迈进的一步。
知识架构消耗数据，并着手让数据发挥作用。数据本身很有趣。数据转化为信息是引人注目的。转化为知识的信息是可操作的。
本文首次出现在 insightabletimes.org 的https://insightabletimes . org/why-your-organization-should-invest-in-knowledge-architecture
知识数据科学与语义技术。
数据科学(可能的)未来简介。
Illustration by Héizel Vázquez
欢迎来到关于数据科学的新系列。在这里，我将开始介绍一些指导我们学习的概念和定义。要理解这篇文章，我建议你阅读我过去写的其他文章:
我将尝试为我们的领域定义一个新的开始，我称之为:
知识数据科学
我是从知识工程领域取的这个想法，但是仅仅是名字，定义会有点不同。还有另一种类似的方法，你可以在这里阅读。让我首先回顾一下我对数据科学的定义:
数据科学是通过数学、编程和科学方法来解决业务/组织问题，其中涉及通过分析数据和生成预测模型来创建假设、实验和测试。它负责将这些问题转化为也能以创造性方式回应初始假设的适定问题。还必须包括对所获结果的有效沟通，以及解决方案如何为企业/组织增加价值。
这里是我们需要谈论的知识数据科学:
知识数据科学是通过数学、编程、科学方法和语义技术解决业务/组织问题的方法，涉及通过分析数据和在知识表示系统内生成预测模型来创建假设、实验和测试。它负责将这些问题转化为适定的问题，这些问题也可以以一种创造性的方式对最初的假设做出回应。它还必须包括对所获结果的有效沟通，以及解决方案如何为企业/组织增加价值。
所以这里的主要区别是增加了语义技术和知识表示系统的概念。在本文中，我将描述这些。
你们中的一些人在读到这里时可能会想:我刚刚开始进入这个新领域，现在又出现了一个？或者:为什么我们需要更多关于数据科学的定义？为什么不专注于解决业务问题，就这样？
我听到了。但是让我告诉你一些事情。数据科学领域的一些人需要谈论我们领域的理论部分；这是我们能够将它的研究系统化并使其他人容易进入它的唯一方法。为什么我要给它添加一个新的部分(语义)？因为是时候了，我们开始理解它能给我们的领域和我们的工作方式带来的奇迹。这在开始时可能看起来不明显，但希望在本系列结束后，您会看到这一点。
语义技术
Illustration by Héizel Vázquez
语义这个词本身就意味着意义或理解。因此，我们在这里将要讨论的语义技术是关于数据的含义，而不是数据的结构。
当我们理解的时候，我们正在解码组成一个复杂事物的部分，并把我们一开始得到的原始数据转化成有用的和直观的东西。我们通过建模来做到这一点。你可以想象，我们需要这样的模型来理解数据的意义。
我们通常通过创建一个叫做知识图的东西来做到这一点，它依赖于我们链接数据。这里的关键是，在这个新模型下，我们不是在寻找可能的答案，而是在寻找答案。我们想要事实——这些事实从何而来并不重要。
这里的数据可以代表概念、物体、事物、人，实际上是你脑海中的任何东西。图表填充了概念之间的关系和联系。
因此我们可以说，语义技术是那些使用语义、本体、链接数据和知识图的概念来帮助我们理解我们所拥有的数据的含义的技术。这种技术有很多很好的例子，比如:
还有更多。其中一些是问题的完整解决方案，但其他的则侧重于事务性(OLTP)图数据库。而类似剑桥语义公司的 AnzoGraph 是一个分析(OLAP)图形数据库。不久前，我在一篇文章中谈到了这种差异:
继续分析语义和数据科学，是时候讨论图形数据库以及它们必须…
towardsdatascience.com](/graph-databases-whats-the-big-deal-ec310b1bc0ed)
为什么所有这些对你来说都很重要？因为人们不会在表格中思考(像在传统的 RDBMS 中)，但他们会立即理解图形。当你在白板上画出一个知识图表的结构时，它对大多数人的意义是显而易见的。
同样重复我以前写的，我厌倦了编写极长的 SQL 查询，甚至是从数据库中获取简单数据的 NoSQL 查询。这可能是解决这一问题的方法，甚至更多。
知识表示系统
Illustration by Héizel Vázquez
我们在数学世界中表示事物的方式是最基本的。人工智能的大多数理论进步，特别是机器和深度学习，都来自于更好地表示系统和数据，并找到新的有用的技术来分析它。几乎所有我们用来完成这类任务的算法都依赖于代数、微积分和统计。
但是最近几年，以图表的方式表达信息的转变变得越来越重要。你可以在我开头列出的其他文章和文章的其余部分找到原因。但这里重要的部分是，我们需要一种数据表示，不仅包括数据本身，还包括其中的交互是一等公民。
这就是知识表示系统给我们的。一种毫不费力地表示数据及其关系的方法。正如我之前提到的:
关系数据库将高度结构化的数据存储在具有预先确定的列和行的表中，而图形数据库可以映射多种类型的关系数据和复杂数据。因此，图形数据库的组织和结构不像关系数据库那样严格。所有关系都存储在边的顶点中，这意味着顶点和边都可以有与之关联的属性。这种结构允许数据库能够描述不相关的数据集之间的复杂关系。
美国数据科学家可以通过这种方式找到很多帮助来组织我们组织中的数据。我们需要专注于解决问题，而不是处理数据。正如你以前可能听到的，处理和清理数据几乎是我们所做的一切，这种情况必须结束。我们需要开始考虑建立一个数据平台，让我们能够解决问题，并且能够以更好的方式处理数据。
知识表示系统的一个很好的例子是数据结构，我之前定义为:
[…]支持公司所有数据的平台。它是如何被管理、描述、组合和普遍访问的。该平台由企业知识图构成，创建统一的数据环境。
使用像剑桥语义的 Anzo 这样的工具，你可以自动生成查询(是的，这是一个东西)，使用它们来处理复杂的图形使提取特征变得容易，并最终完全自动化。以下是 Anzo 的一个示例:
https://www.cambridgesemantics.com/product/
这个新领域的开始要求我们了解更多关于语义学、本体论、语义网、知识图等等。我以前写过这方面的文章，在下一部分，我将深入探讨这些内容以及它们与数据科学的联系。
对这个激动人心的话题，我期待更多。如果您有任何建议，请告诉我:)
如果您有任何问题，请在 Twitter 上关注我:
Favio Vázquez 的最新推文(@FavioVaz)。数据科学家。物理学家和计算工程师。我有一个…
twitter.com](https://twitter.com/faviovaz)
和 LinkedIn:
[## 法维奥·瓦兹奎——首席执行官——克洛斯特| LinkedIn
‼️‼️重要提示:由于 LinkedIn 的技术限制，我现在只能接受来自我…
www.linkedin.com](https://www.linkedin.com/in/faviovazquez/)
那里见:)
知识蒸馏——一种为压缩和加速神经网络而开发的技术
Photo by Kai Dahms on Unsplash
最近的增长见证了深度学习行业的显著增长。随着 AlexNet 在 2012 年 ImageNet 比赛中的突破，更先进的深度神经网络 *(ResNet-50，VGGNet，以及许多其他)*被开发出来，不断改写记录。然而，这些网络需要大量的计算来产生良好的结果。例如，AlexNet 有 6230 万个参数，使用两个 Nvidia Geforce GTX 580 GPU 训练 90 多个 epochs 需要大约 6 天时间。
因此，这些网络的潜力只能通过繁重的计算来完全利用。相比之下，我们日常生活中使用的大多数移动设备通常对存储和计算资源有严格的限制，这使得它们无法充分利用深度神经网络。因此，为了保持类似的准确性，同时牢记这些限制，开发了一种压缩和加速神经网络的新技术，称为知识提取。
在这篇文章中，我们将关注知识的提炼以及如何用它来解决这个问题。
知识蒸馏
直觉
The red plot is of the large model(Teacher), the blue plot is of the student network trained without distillation, and the purple plot is of the student network trained using distillation.
我们的主要目标是训练一个能够在测试数据集上产生良好结果的模型。为了做到这一点，我们训练了一个笨重模型，它可以是许多不同训练过的模型的集合，或者仅仅是一个用正则化子训练的非常大的模型，例如退出。一旦笨重的模型*(教师)准备就绪，我们就使用一种称为提炼的技术，将笨重模型学到的复杂知识转移到更适合部署在具有内存和繁重计算约束的设备中的小模型(学生)*。
通过复杂的知识，我的意思是，繁琐的模型可以区分大量的类。在这样做的时候，它给所有不正确的类分配概率。然而，这些概率是非常小的，它们告诉我们很多关于这个繁琐的模型是如何概括的。一张狗的图片很少会被误认为是猫，但这种错误仍然比误认为是鸽子多很多倍。
繁琐的模型需要很好地概括，所以当我们将知识提取到较小的模型时，它应该能够以与大模型相同的方式概括。例如，如果一个大模型是许多不同模型的集合，那么与在用于训练集合的相同训练集上以正常方式训练的小模型相比，使用提取知识学习的小模型将能够在测试数据集上更好地概括。
将繁琐模型的泛化能力转移到小模型的一种明显的方式是使用由繁琐模型产生的类别概率*(通过称为蒸馏的技术产生)作为用于训练小模型的“软目标”。对于转移阶段，我们可以使用相同的训练集或单独的集(完全由未标记的数据组成)*。
Scatters dots are the data points in the dataset. The blue plot is the cumbersome model(teacher) trained on a complex dataset and the red plot is the small model(student) generalizing on the soft targets generated from the teacher model.
对于软目标，我们可以取所有单个预测分布的几何平均值。当软目标具有高熵时(你可以在这里阅读更多关于熵的信息)，它们为每个训练案例提供的信息比硬目标多得多，训练案例之间的梯度差异也小得多，因此小模型通常可以在比原始笨重模型少得多的数据上进行训练，并使用高得多的学习率。
蒸馏
蒸馏是产生软目标概率分布的一般解决方案。在这种情况下，我们使用 softmax 激活函数产生类别概率，该函数将为每个类别计算的 logits z_i 转换成概率 q_i:
Equation-1
这里 T 是温度，通常设置为 1。使用更高的概率分布导致更柔和的概率分布。
z_i 是为数据集中每个数据点的每个类计算的逻辑值。
在蒸馏的最简单变型中，通过在转移集上训练笨重的模型，并对转移集中的每种情况使用软目标分布，将知识转移到小模型，该软目标分布由 softmax 函数中的高温产生。在训练小型或蒸馏模型时使用相同的高温，但是在训练之后，温度被设置为 1。
如果我们有转移集的正确标签，这项技术可以得到显著的改进。一种方法是取两个目标函数的加权平均值。第一个目标函数是软目标的交叉熵，并且使用提取模型的 softmax 中与用于从繁琐模型生成软目标相同的高温来计算该交叉熵。第二个目标函数是正确标签的交叉熵。这是使用提取模型的 softmax 中完全相同的 logits 进行计算的，但温度为 1。保持第二目标函数的权重相当小产生了最好的结果。
因为由软目标产生的梯度的幅度缩放为 1/T，所以当使用硬目标和软目标时，将它们乘以 T 是重要的。这确保了当用元参数进行实验时，如果用于蒸馏的温度改变，则硬目标和软目标的相对贡献大致保持不变。
运行一个示例
Process of deploying deep learning models in embedded devices.
在这个例子中，我们将考虑我们正在处理一个非常复杂的数据集 (X) ，并且使用一个浅层网络*(可以部署在移动设备中)*在这个数据集上获得良好的准确性，使用传统的模型构建技术几乎是不可能的。因此，为了获得良好的准确性，我们将使用知识提炼技术:
- 首先，我们将在数据中心使用大型模型*(老师)*训练数据集 X，该模型能够分解数据集 X 的复杂性，以产生良好的准确性。
- 现在，我们将使用原始数据集 X 或转移集*(数据集 X 的较小版本)*从大模型中生成软目标，然后使用它们通过蒸馏技术获得数据集中每种情况的概率分布。
- 下一步是基于移动设备的内存和计算限制来构建一个浅层网络*(学生)*。
- 这个浅层网络将根据第二步中产生的概率分布进行训练，并在此基础上进行推广。
- 一旦该模型被训练，它就准备好被部署在移动设备中。
为了估计提取模型的结果有多好，我们将查看神经网络 中的论文 知识蒸馏的作者使用知识提取在 MNIST 数据集上能够实现的数字。
结果
为了了解蒸馏是如何工作的，MNIST 数据集使用一个非常大的神经网络*(教师)进行训练，该网络由两个隐藏层组成，每个隐藏层都有 1200 个经过校正的线性隐藏单元。以下模型已经训练了超过 60，000 个训练案例。该网络实现了 67 个测试错误，而较小的网络(学生)*具有两个隐藏单元，每个具有 800 个校正的隐藏单元 146 个测试错误。
但是，如果仅仅通过增加匹配大网在 20℃下产生的软目标的额外任务来调整较小的网，它会产生 74 个测试误差。这表明软目标可以将大量知识转移到提取的模型，包括从翻译的训练数据中学习的关于如何概括的知识，即使转移集不包含任何翻译。
如果你想比较其他数据集的结果，你可以查看原始的论文以获得更多信息。
结论
- 简单模型的能力没有被硬标签训练充分利用:通过知识提炼来提高。
- 随着知识的丰富和流畅，软标签更容易匹配。
- 知识提炼框架主要关注准确性和压缩率，但忽略了对实际应用至关重要的已学习学生网络的健壮性。
- 学生模型可以用在嵌入式设备中，产生可比较的结果，在某些情况下，它甚至可以复制复杂网络的结果。
为了更深入地了解知识的提炼，我建议你去阅读原文， 在神经网络中提炼知识 。
如果你喜欢这篇文章并想保持联系，你可以在 LinkedIn 这里找到我。
知识蒸馏:简体
窥探师生网络的世界
什么是知识蒸馏？
近年来，神经模型在几乎每个领域都取得了成功，包括极其复杂的问题陈述。然而，这些模型体积庞大，具有数百万(和数十亿)个参数，因此不能部署在边缘设备上。
知识提炼指的是模型压缩的思想，通过一步一步地教会一个较小的网络，使用一个更大的已经训练好的网络来做什么。“软标签”指的是在每个卷积层之后由更大的网络输出的特征图。然后，较小的网络被训练来学习较大网络的确切行为，尝试在每个级别复制其输出(不仅仅是最终损失)。
我们为什么需要这个？
深度学习已经在包括计算机视觉、语音识别、自然语言处理等众多领域取得了令人难以置信的性能。然而，这些模型中的大多数在计算上过于昂贵，以至于不能在诸如移动电话或嵌入式设备上运行。要了解更多关于模型压缩的需求和相关的常用技术，请访问下面的博客。
看看最先进的机器学习模型的压缩、修剪和量化领域
towardsdatascience.com](/machine-learning-models-compression-and-quantization-simplified-a302ddf326f2)
这和从零开始训练一个模型有什么不同？
显然，对于更复杂的模型，理论上的搜索空间要比较小的网络大。但是，如果我们假设使用更小的网络可以实现相同(甚至相似)的收敛，那么教师网络的收敛空间应该与学生网络的解空间重叠。
不幸的是，仅凭这一点并不能保证学生网络在同一位置收敛。学生网络可能有一个与教师网络非常不同的汇聚点。但如果引导学生网复制教师网的行为(教师网已经搜索过更大的解空间)，则有望使其收敛空间与原教师网收敛空间重叠。
师生网络——它们到底是如何工作的？
- *训练教师网络:*高度复杂的教师网络首先使用完整数据集单独训练。这一步需要很高的计算性能，因此只能离线完成(在高性能 GPU 上)。
An example of a highly complex and Deep Network which can be used as a teacher network : GoogleNet
*2。建立对应关系:*在设计学生网络时，需要在学生网络和教师网络的中间输出之间建立对应关系。这种对应可以包括将教师网络中某一层的输出直接传递到学生网络，或者在将其传递到学生网络之前执行一些数据扩充。
An example of establishing correspondence
*3。通过教师网络向前传递:*通过教师网络传递数据以获得所有中间输出，然后对其应用数据扩充(如果有)。
*4。通过学生网络反向传播:*现在使用来自教师网络的输出和对应关系在学生网络中反向传播误差，这样学生网络可以学习复制教师网络的行为。
下一步是什么？
对上述传统的学生教师提出了许多新的修改建议，如引入多名教师(即，将一个合奏转变为一个单一的网络)，引入一名助教(教师先教助教，助教再教学生)等。然而，这个领域仍然非常年轻，在许多方面还没有被探索。
这个博客是努力创建机器学习领域简化介绍的一部分。点击此处查看完整系列
在你一头扎进去之前就知道了
towardsdatascience.com](/machine-learning-simplified-1fe22fec0fac)
或者只是阅读系列的下一篇博客
一窥单个 RNN 细胞的“深层”世界
towardsdatascience.com](/growing-your-own-rnn-cell-simplified-b68ba2c0f082)
参考
[1]王，，等.“DeepVID:基于的图像分类器深度视觉解释与诊断”IEEE 可视化与计算机图形学汇刊 25.6(2019):2168–2180。
[2] Mirzadeh，Seyed-Iman 等，“通过教师助理改进知识升华:弥合学生和教师之间的差距。”arXiv 预印本 arXiv:1902.03393 (2019)。
[3]辛顿、杰弗里、奥里奥尔·维尼亚尔斯、杰夫·迪恩。"从神经网络中提取知识."arXiv 预印本 arXiv:1503.02531 (2015)。
[4]刘，晓东，等.【用改进多任务深度神经网络用于自然语言理解】arXiv 预印本 arXiv:1904.09482 (2019)。
知识图:机器学习的完美补充
Photo by Alina Grubnyak on Unsplash
如今，网络上的信息数量惊人，而且还在不断增加。例如，有超过 19.4 亿个网站与万维网和搜索引擎(例如，Google、Bing 等)链接。)可以通过这些链接，以极高的精度和速度提供有用的信息。在大多数成功的搜索引擎中，最重要的特征是使用知识图表。不仅是搜索引擎，社交网站(如脸书等。)、电子商务网站(如亚马逊等。)也在使用知识图来存储和检索有用的信息。
简史
1960 年、、、语义网络、、被发明出来，以解决对知识表示框架的日益增长的需求，该框架可以捕捉广泛的实体——真实世界的物体、事件、情形或抽象概念和关系，并最终可以应用于扩展的英语对话任务。语义网络背后的主要思想是捕捉广泛的问题，包括计划、行动、时间、个人信念和意图的表示，并且足够通用以适应每个问题。
根据维基百科，在 1980 年末，两所荷兰大学开始了一个名为 知识图 的项目，这是一种语义网络，但增加了一些限制，以方便图上的代数运算。
2001 年，蒂姆·伯纳斯·李创造了术语 语义网 是语义网与 Web 结合的一种应用。
蒂姆·伯纳斯·李说“语义网是当前网络的延伸，在其中信息被赋予明确的含义，更好地使计算机和人合作工作。”
2012 年，谷歌将其知识图谱命名为 知识图谱 。
未定义的定义
每个公司/团体/个人都创建他们自己版本的知识图，以限制复杂性并将信息组织成数据和知识。比如谷歌的知识图、知识库、微软的 Satori、脸书的实体图等。
因此，知识图没有正式的定义。从更广的角度来看，知识图是语义网络的变体，带有附加的约束，其范围、结构、特征甚至用途都没有完全实现，并且处于发展过程中。
知识图示例
Source: Maximilian Nickel et al. A Review of Relational Machine Learning for Knowledge Graphs: From Multi-Relational Link Prediction to Automated Knowledge Graph Construction
你为什么要兴奋？
随着时间的推移，机器学习和基于知识图的知识表示学习正在迅速发展，无论是在规模上还是在深度上，但方向不同。一方面，机器学习技术在执行各种任务(如分类、生成等)方面越来越好。)在各种数据集上，具有很高的精确度和召回率。另一方面，知识表示带来了以高可靠性、可解释性和可重用性来表示实体和关系的能力。知识表示学习的最新进展包括从图中挖掘逻辑规则。
Source: Bishan Yang et al. Embedding Entities and Relations for Learning and Inference in Knowledge Bases.
然而，将知识图和机器学习结合起来将系统地提高系统的准确性，并扩展机器学习能力的范围。例如，从机器学习模型中推断出的结果将具有更好的可解释性和可信度。
以下是将知识图引入机器学习中可以利用的一些机会:
数据不足
拥有足够数量的数据来训练机器学习模型是非常重要的。在数据稀疏的情况下，知识图可以用来扩充训练数据，例如，用相似类型的实体名称替换原始训练数据中的实体名称。这样，使用知识图可以创建大量的正面和负面例子。
零射学习
如今，机器学习模型面临的主要挑战是，如果没有经过适当训练的数据，就无法区分两个数据点。在机器学习中，这被认为是零射学习问题。这就是知识图表可以发挥很大作用的地方。来自机器学习模型的归纳可以用来自知识图的推断来补充，例如，用训练数据中没有出现情况类型的图片。
可解释性
机器学习行业的主要问题之一是解释机器学习系统所做的预测。一个问题是导致来自机器学习模型的预测的隐式表示。知识图可以通过将解释映射到图中适当的节点并总结决策过程来缓解这个问题。
注意:上述机会在研讨会报告知识图:语义网上知识表示的新方向(Dagstuhl 研讨会 18371) 中有更详细的解释
一些使用案例
- 问答是知识图最常用的应用之一。知识图包含丰富的信息，问答是帮助终端用户更有效地从知识图中检索信息的好方法。
- 存储研究信息是另一个有用的应用知识图。最近，许多公司正在使用知识图来存储从研究的各个阶段产生的信息，这些信息可用于建立可访问的模型、风险管理、过程监控等。
- 网飞使用知识图表为其推荐系统存储大量不同的信息，这有助于发现电影、电视节目、人物等之间的关系。稍后，这些关系可用于预测客户接下来可能喜欢看什么。
- 供应链管理也受益于知识图的使用。公司可以轻松跟踪不同组件的库存、涉及的人员、时间等，这使他们能够更快速、更经济地移动物品。
还有更多……
公开挑战
- 一套连贯的最佳实践，可以在知识图的创建过程中应用，将有助于工程师、开发人员和研究人员理解和重用知识图。
- 给定一组非结构化数据和知识图，知识整合的问题是识别数据中提到的实体是否与知识图中呈现的现实世界实体相匹配。虽然这个问题可以使用机器学习算法来解决，但是这些算法的结果直接取决于训练数据的质量。给定各种各样数据集，知识集成变得相当困难。
- 知识不是一成不变的，而是不断进化的。例如，如果一个知识图表跟踪病人的健康状况，那么在某个特定时刻存储的数据可能在稍后的某个时刻是错误的。那么，我们如何捕捉这种知识进化的本质呢？
- 如何评价一个知识图谱？哪些质量改进(例如，完整性、正确性、链接等。)更重要？
感谢
- 知识图表:语义网上知识表示的新方向(Dagstuhl 研讨会 18371) Dagstuhl 报道8(2018):29–111。
- 保罗海姆，黑科。"知识图精化:方法和评估方法综述."语义网8(2016):489–508。
- 《知识图的关系机器学习回顾》IEEE 会议录104(2015):11–33。
- 艾伦和弗里希(1982)。“语义网络中有什么”。在:第 20 届会议录。ACL 年度会议，多伦多，第 19-27 页。
- 奈杰尔等人《语义网再访》 IEEE 智能系统21(2006):96–101。
2019 年知识图谱大会
Credit: Columbia University
我对 KGC2019 @哥伦比亚大学的看法
上周，我得以参加哥伦比亚大学的 2019 年知识图谱大会。这是一个为期两天的活动，来自世界各地的优秀演讲者在这一领域的专业知识。这是我对它的简短看法。
如果你是知识图表和“数据结构”的新手，我强烈推荐你阅读法维奥瓦斯奎兹的系列文章。他很好地解释了不太直观的概念，并且很容易理解。
在能够开发数据结构之前，我们需要构建一个知识图。在这篇文章中，我将建立一个基础…
towardsdatascience.com](/the-data-fabric-for-machine-learning-part-2-building-a-knowledge-graph-2fdd1370bb0a)
用例
来自金融行业的代表表现良好，大多数用例涉及法规遵从性、风险和其他后台办公室用例。汤森路透(Thompson Reuters)和其他公司旗下的路孚特公司有一个演示特别引起了我的注意(路孚特向其他金融机构出售市场数据)。一个真正的用例是通过 KG 增强新闻/事件的消费。例如，如果我是一名投资组合经理，并对钢铁价格有所敞口，而一条影响我头寸的突发新闻刚刚发生，知识图将直观地捕捉到这种联系。即使你知道你的头寸和(插入随机全局事件)之间的相关性，使用这样的工具也会加快决策过程(无论你持有还是做空你的头寸)。这只是一个用例，但我很好奇如何利用知识图以其他方式生成 alpha。
科技公司也在使用这项技术。鉴于许多功能/基础设施都是内部构建的，我对工程方面的印象尤为深刻。从零开始！
下面是一篇关于 AirBnb 如何使用他们的知识图表的文章。但简而言之，推荐得到了增强，因为不同实体之间的关系在 KG 中被捕获。
介绍我们如何在 Airbnb 构建知识图，该知识图帮助我们对库存进行分类并提供上下文…
medium.com](https://medium.com/airbnb-engineering/contextualizing-airbnb-by-building-knowledge-graph-b7077e268d5a)
障碍
大多数机构面临的主要障碍是人为的，而不是技术上的。知识图/语义技术的采用增长迅速，但是仍然很难解释、证明和在全公司范围内采用这种工具。“传播”可能很困难，尤其是当本体学家、IT 和业务之间存在信息鸿沟时。就采用策略而言，与其将组织中的每个数据集都映射或放在“蓝海”中，不如一点一点地慢慢进行被认为是更好的方式。
下一步是什么？
就个人而言，我想学习更多关于图论(遍历、推理、联邦查询、推理等)的知识，并探索在构建 KG/Semantic Web 时使用前沿 NLP 技术增强映射自动化的可能性。
这是一次很棒的教育活动，我要感谢弗朗索瓦·沙夫，组织者，学生志愿者，以及所有使这次活动成功的人。虽然我的博客文章很短，但这些演讲者提供了关于会议的更全面的报告:
来自维基数据/谷歌的 Denny Vrandeč
[## 2019 年知识图谱大会，第一天- Simia
我提出了维基数据和抽象维基百科的概念，认为它超出了知识图表可以轻易表达的范围。我…
simia.net](http://simia.net/wiki/Knowledge_Graph_Conference_2019,_Day_1)
来自 Capsenta 的 Juan Sequeda
刚从哥大专业研究学院组织的 2019 知识图谱大会回来…
www.juansequeda.com](http://www.juansequeda.com/blog/2019/05/11/2019-knowledge-graph-conference-trip-report/)
使用 Stardog 的知识图查询
Stardog:一个允许你探索和查询知识图表的平台。
Image by Stardog. Knowledge graph visualization in Studio
Stardog 不仅仅是一个查询引擎，它是一个前沿平台，允许你探索和查询知识图表。
Stardog 可用于在知识图上运行 SPARQL 查询。如果你不熟悉知识图或者 SPARQL 查询，我建议你看我的博客:使用 Apache Jena (SPARQL 引擎)提取和查询知识图。对于本教程，您可以下载任何知识图表，如 AGROVOC ，或者您可以创建自己的图表，如下所示:
目前，图表如下所示:
明星日志
知识图的功能取决于它所能访问的数据，因此我们构建了数据库连接器来简化数据的统一。Stardog 拥有所有主要 SQL 系统和最流行的 NoSQL 数据库的连接器。此外，我们构建了 BITES 管道来处理您的非结构化数据，如研究论文、简历和监管文档。BITES 使用 NLP 实体识别来识别和提取概念，将这些数据关系添加到知识图中。一旦你的数据在 Stardog 中统一，你就可以在每个数据点上看到 360 度的视图。
Image from Stardog
下载并安装 Stardog
有不同的下载选项，您可以轻松运行下面的curl命令:
curl [https://downloads.stardog.com/stardog/stardog-latest.zip](https://downloads.stardog.com/stardog/stardog-latest.zip) –output stardog-latest.zip
然后使用以下命令将其解压缩:
unzip stardog-latest.zip
现在你应该可以运行命令./stardog-admin.了，我建议你添加路径到你的.bsahrc或者你可以直接使用export PATH=/home/.../stardog:$PATH.之后，你需要使用下面的命令启动 Stardog 引擎:
stardog-admin server start
您应该得到以下内容:
建立一个数据库
然后打开另一个终端，运行下面的命令，从给定的知识图构建一个数据库。
stardog-admin db create -n MoDB data.nt
如果运行成功，您应该会得到类似的输出:
注意:MoDB是数据库名，data.nt是你的知识图名。
运行 SPARQL 查询
最简单的查询之一是返回所有的三元组。这是查询:
stardog query MoDB "select * where { ?s ?p ?o }"
这是输出结果:
或者你可以通过提问来搜索所有感兴趣的东西Mohamed？(该查询将返回所有的三元组，其中interestedIn是关系)
stardog query MoDB "select * where { ?s <[http://example.com#interestedIn](http://example.com#interestedIn)> ?o }"
输出:
到目前为止，我们一直直接从终端运行查询。相反，您可以将查询写到一个文件中，我们称之为que.sparql.要从文件中执行前面的查询，请在que.sparql中粘贴以下内容:
select * where {
?s <[http://example.com#interestedIn](http://example.com#interestedIn)> ?o
}
要执行查询文件，请运行以下命令:
stardog query MoDB que.sparql
返回最短路径
以下查询将返回两个实体之间的最短路径，在我们的示例中为Mohamed和Jim:
stardog query MoDB "PATHS START ?x = <[http://example.com/Mohamed](http://example.com/Mohamed)> END ?y = <[http://example.com/Jim](http://example.com/Jim)> VIA ?p"
返回所有可能的路径
默认情况下，Stardog 将返回最短路径。要返回所有路径，只需在PATHS后添加关键字ALL:
stardog query MoDB "PATHS ALL START ?x = <[http://example.com/Mohamed](http://example.com/Mohamed)> END ?y = <[http://example.com/Jim](http://example.com/Jim)> VIA ?p"
输出是:
请注意，如果您从Mohamed查询到Mike，您将只获得一条路径，因为从pasta到Mike没有关系。
这些查询可以应用于任何知识图。
知识图和机器学习
半自动洞察生成的强大组合
知识图是一组由描述一个领域(例如一个企业、一个组织或一个研究领域)的关系所链接的数据点。这是一种强大的数据表示方式，因为知识图可以自动构建，然后可以探索以揭示关于该领域的新见解。
知识图谱是二级或衍生数据集:通过对原始数据的分析和过滤获得。更具体地说，数据点之间的关系是预先计算的，并成为数据集的重要部分。这意味着不仅每个数据点都可以快速、大规模地分析，而且每个关系都可以分析。
选择如何描述这种关系以及快速大规模分析的能力是获得新见解的关键。从数据到信息，从信息到知识，从知识到洞察，从洞察到智慧。
例如，地理地图包含城市的名称和坐标，而简单的知识图也包含城市之间的距离。因此，不用在查询时计算所有的距离，我可以直接问:A 点和 R 点之间的最短路径是什么？预先计算距离是一个简单的步骤，但使地理分析更快，也允许轻松测试不同的场景。例如，知道 B 点突然不可到达，A 和 R 之间的最短路线是什么？
图形作为分析工具已经存在了几个世纪，但是直到最近才出现了“知识图”的概念。它的形式定义由 Paulheim ( 2016 )给出，其中一个知识图:
- 描述现实世界的实体及其相互关系；
- 定义架构中实体的可能类和关系；
- 允许任意实体之间潜在的相互关系；
- 涵盖各种主题。
除了定义之外，知识图还有巨大的市场吸引力:它意味着一个技术人工制品，它封装了一个公司或另一个领域的所有关系，从而导致更好的理解。这正变得越来越真实，这也要归功于机器学习。
使用机器学习描述新关系
机器学习革命的主力是通过深度学习进行数据分类。通过对数据进行分类，我们可以创建属于同一类的相关数据点子集。这种关系在分类之前并不存在，现在可以用来创建知识图。
深度学习的强大之处在于能够对复杂的数据进行分类，而不需要提供明确的描述，只需要简单的例子。图像、语音、文档、电子表格、演示文稿、视频……深度学习可以对许多不同种类的数据进行分类，这为从多个角度描述一个领域提供了前所未有的机会。手动描述数百万个数据点基本上是不可行的。想象一下，必须阅读和分类数百万份精确但枯燥的法律文件。不是对人类时间的最佳利用。
充分利用一个人的时间也是一个公司的 ML 生成的知识图的简单例子:通过分析文档，有可能知道 A-team 和team∈分别在同一主题上工作，这提供了改进协作的机会。
图形和 ML 的强大组合有许多可能的用例。开发需要在两个具有挑战性的方面下功夫:访问数据和找到将导致期望结果的类。第一个问题主要是组织、法律和伦理问题，而第二个问题需要领域知识。在 ML 革命之前，这通常只能由主题专家提供，而现在 ML 系统可以支持这项工作，降低了准入门槛。
ML 也支持关系类的定义
机器学习可以支持使用分类以及类的定义来创建关系。例如，文档的自然语言处理可以对主题建模并识别命名实体。有了它们的统计表示，人们就可以根据数据来决定哪些元素应该构成新的关系类型。这些然后成为分类的标签。
这意味着，为了创建知识图，任何可能包含相关信息的数据库都会被爬行和扫描。文件、目录、活动日志……任何东西都可以进行统计分析，以创建分类和本体，这些术语用于定义数据点之间的类、属性和关系，以及如何创建新的数据点。它们是对所有考虑的数据点进行分类和描述的蓝图和说明。这就是为什么知识图有时也被称为语义网络的核心。语义强调了这样一个事实，即表示的与相应的数据一起编码。这是通过分类法和本体论完成的(它们的通用术语有一些重叠，部分是由于它们的起源。分类学源于生物学，而本体论源于哲学——源于希腊语 Ontologia，“对存在的研究”。存在更正式的定义，如计算机科学中使用的定义，但它们在此上下文中并不完全相关)。
在定义分类法和本体论时，人的判断是很重要的，因为数据可以用无数种方式来描述。机器仍然无法考虑更广泛的背景来做出适当的决定。分类法和本体论就像是提供了一个观察和操作数据的视角。如果没有考虑感兴趣的元素，那么知识图不会提供任何洞察力。选择正确的视角是创造价值的方式。典型地，这个任务是反复执行的，也从失败中学习。
一旦您定义了规则，您就可以将它们应用到新数据，创建元数据，从而创建知识图。在适当的数据库系统中，可以很容易地查询和分析它。例如，一个特定的实体有多少关系？从 A 到 Z 的最短路线是什么？子图有多相似？
知识图的强大之处之一是能够将不同类型的数据和来源联系起来。这对于通过组合来自不同来源的信息来提取价值非常有用，例如跨公司筒仓。
创建知识图是一项重要的工作，因为它需要访问数据、重要的领域和机器学习专业知识，以及适当的技术基础设施。然而，一旦为一个知识图建立了这些需求，就可以为更多的领域和用例建立更多的需求。鉴于可以发现新的见解，知识图是一种从现有非结构化数据中提取价值的变革性方式。明智使用。
[All photos and images by author]
如果你读到这里，你可能会喜欢以光速飞行的——元宇宙的苍蝇如何帮助解决了一个长期存在的工程之谜。
连接点:使用人工智能和知识图表来识别投资机会
最近，Gartner 的 2018 年人工智能和新兴技术炒作周期宣布知识图表呈上升趋势。它们与 4D 印刷和区块链一样，处于宣传周期的早期，是创新触发阶段的一部分，仅可能在截至 2018 年 8 月的五到十年内达到平台期。
Gartner Hype Cycle for Emerging Technologies, 2018. Source: Gartner (August 2018).
“知识图表是新的黑色！(……)从可用的聊天机器人、引导式流程到自动化顾问，我们将看到在许多行业和领域的使用越来越多，包括医疗保健、金融服务和供应链”
—埃森哲应用智能公司董事总经理兼首席技术官 Jean-Luc chate Lin
知识图谱在金融领域的影响才刚刚开始。然而，随着数据的迅猛增长和市场参与者面临的信息过载，基于知识图的技术将很快从竞争优势转变为必备条件。
知识图谱在投资中的主要用例有哪些？
K 知识图用例包括问答(QA)系统、语义搜索、动态风险分析、基于内容的推荐引擎、知识套利、主题投资和知识管理系统。我们强调四种主要使用情形:
- 企业数据治理
- 研究和知识发现
- 风险暴露
- 主题投资
企业数据治理
主要机构通常面临着成千上万个孤立的“数据孤岛”，因此面临着信息过载的挑战。知识图可以通过处理不同的来源和从不同的数据集中提取知识的原子单元，作为集成知识和推理的集中来源。
知识图能够持续“读取”不同的来源，将信息投射到多维概念空间中，其中不同维度的相似性度量可用于将相关概念分组在一起。这允许集成的企业解决方案，该解决方案不仅识别实体、人、事件和想法的含义，将它们聚集到整个机构的统一知识层中，而且将概念关联和分组，以允许推理生成和洞察。
研究和知识发现
知识图可以用作语义搜索引擎，在研究和知识发现应用中激发新的想法和发现意想不到的联系。
知识图表利用来自不同领域的数百万篇学术文章、书籍和数据库的数亿个语义连接和概念链接。
知识图表使用户能够直观地浏览概念、关系和领域，从可能被忽略的资源中学习。这不仅增进了理解，创造了更有影响力的作品，而且节省了时间，同时确保了全面和可信的报道。
风险暴露
复杂传染是指一个人需要多种接触来源才能改变行为的现象。投资就是识别关系，揭露风险就是复杂的传染。
影响特定公司、行业、市场或经济的潜在联系(包括直接和间接的)呈指数增长。在正确的数学意义上，知识图是实际的图，允许应用基于推理图的技术。从这个意义上说，知识图表的一些最重要的用例与推理和“推断关系”有关——本质上是在有时完全不同的事件或信息之间画出联系，否则这些事件或信息不会被联系起来。这允许在复杂传染框架内量化风险暴露。
Yewno|Edge quantifies portfolio exposure to complex concepts such as Data Privacy, Tariffs, and Brexit. Source: www.yewno.com/edge.
Yewno|Edge 就是一个应用例子，它是 Yewno 的新人工智能金融平台，可以量化投资组合对复杂概念的敞口，无论是苹果公司未能实现的收益，对贸易战的担忧，还是中国经济放缓，你都可以看到几乎任何因素都在影响你的投资组合。使用 Yewno|Edge，您可以通过跟踪公司关系和对想法的接触，而不仅仅是关键字，轻松找到哪些公司、主题和事件正在影响您的投资组合。
主题投资
知识图可以通过从投影的语义空间消除术语的歧义来编码含义。知识图与高级计算语言学相结合，可用于量化公司对人工智能、机器人和 ESG 等目标主题的暴露程度，方法是处理官方文件、政府奖励和专利等文档，这些文档提供了公司业务、产品、服务和知识产权的整体视图。
随着被动投资在过去 10 年的出现，人们对主题 ETF 策略越来越感兴趣，这些策略捕捉未来可能扰乱经济的技术和大趋势。利用知识图表和基于语义的主题投资的金融产品示例包括:
- Yewno 旗下 STOXX AI 全球 AI 指数；
- 纳斯达克 Yewno 北美大麻经济指数；
- 纳斯达克 Yewno 未来流动性指数；
- 纳斯达克 Yewno AI &大数据指数；
- 纳斯达克 Yewno 颠覆性基准指数；
- iSTOXX Yewno 发达市场区块链指数；
- 纳斯达克 Yewno 全球创新科技指数；
- AMUNDI STOXX 全球人工智能 ETF (GOAI)，与 Yewno 合作；
- Coincapital STOXX 区块链专利创新指数基金(LDGR)，与 Yewno 合作；
- DWS 的人工智能和大数据 ETF (XAIX:GR)，与 Yewno 合作。
早在 2018 年初，彭博写了一篇关于耶诺斯托克人工智能指数的文章，提出了一个挑衅性的问题“你会让机器人选择你的投资组合吗？”。快进到今天，欧洲最大的资产管理公司(Amundi)用一只 ETF 给出了答案，这只 ETF 在 AUM 复制了 Yewno 的 AI 指数，价值超过 1 . 4 亿美元。
Bloomberg article about Yewno’s AI Index.
每个人都已经可以访问核心财务数据。知识图表如何补充现有的数据集，如基本面，估计，所有权等？
作为替代数据引擎的知识图
企业现在拥有的一个机会是替代数据，即传统金融领域之外的内容，但可以用来提供对金融投资的见解，如航运物流数据、法庭文件、专利、临床试验和社交媒体互动。
根据德勤引用 Opimas 的一份报告，2020 年，这类数据的支出可能超过 70 亿美元，每年增长 21%。来源 : Adena Friedman，纳斯达克总裁兼首席执行官。
虽然替代数据的增加是一个值得关注的重要趋势，但像这样的数据集很难处理、整合并从中产生见解。如今，大多数替代数据来自不同的来源，并且通常是非结构化的格式。简单地吸收更多的数据并不一定会带来更多的洞察力— 信息并不等同于知识。
当被问及什么数据集在不久的将来最有价值时，50 家对冲基金和机构资产管理公司表示，不仅包括基本面和定价数据等传统内容，还包括有关人员、企业行动主义和治理以及事件和转录的信息。总的来说，这些数据集遵循不同的频率(每日、每月、每季度)、符号系统标准、数据格式(结构化和非结构化)，有时甚至遵循不同的语言。知识图是从这种异构和动态的内容源中生成洞察力的正确解决方案，这些内容源的数量和复杂性只会随着时间的推移而增长。
Core Content Ranked by (Future) Value according to a survey performed by Factset and Coleman Parkes with 50 hedge funds and institutional asset management firms across the U.S., EMEA, and APAC.
Yewno 的知识图能够从不同的数据点进行推断，并提取不同信息领域的见解。通过这种方式，Yewno 的知识图充当了一个替代数据引擎，它从不同种类的替代数据源中提取、处理、链接和表示知识的原子单位——T2 概念。
A Sample of Yewno’s Alternative Data Feeds.
Yewno 目前提供一系列的替代数据源，授权给主要的对冲基金和机构资产管理公司，由包括 Factset 和纳斯达克在内的值得信赖的合作伙伴分发。
如今基于人工智能的投资面临哪些关键挑战，知识图表如何帮助解决这些挑战？
公平、问责和透明(FAT)问题越来越多，但大多仍未被注意到，尤其是在人工智能金融应用中。人们越来越担心，人工智能在投资中应用的复杂性，可能会降低“责怪机器”的相应决策的合理性。在这个领域有一个灰色区域，由于这种方法的复杂性，确定谁应该对基于人工智能的模型所做的决定负责并不总是容易的。
FAT ML is an annual Conference that brings together a growing community of researchers and practitioners concerned with fairness, accountability, and transparency in machine learning. Source: http://www.fatml.org/.
在知识图中，数据的含义可以与图中的数据一起编码，作为知识库本身的一部分。因此，知识图可以是自描述的，即它的知识库可以维护和解释它所包含的知识。这样，知识图表可以作为解决方案的一部分提供透明度和可解释性，从而促进问责制和公平性。
结论
投资就是识别关系，发现隐藏的风险和机会。金融行业对知识图表的采用势不可挡，其使用将很快从竞争优势转变为必备。
Yewno 的知识图可以作为一个可扩展的推理和替代数据引擎，同时通过将透明度作为解决方案的一部分来解决主要的人工智能挑战。
机器学习的知识象限
当今世界上部署的大多数机器学习系统都是从人类反馈中学习的。例如，自动驾驶汽车可以理解停车标志，因为人类已经在从汽车上拍摄的视频中人工标记了 1000 个停车标志的例子。这些标记的例子教授了汽车中部署的自动识别停车标志的算法。
然而，大多数机器学习课程几乎只关注算法，而不是系统的人机交互部分。这可能会给从事现实世界机器学习的数据科学家留下很大的知识缺口，他们将在数据管理上花费更多时间，而不是构建算法。没有人在回路中的机器学习背景，数据科学家经常试图将算法设计和训练数据创建作为完全独立的活动。如果你能结合你的数据和算法策略，算法会更快更准确，所以这是一个错过的机会。
人在回路中的机器学习是解决当今技术中最重要的问题之一的机会:人类和机器应该如何合作解决问题？
这是我为机器学习创建的一个知识象限，用来框定问题和方法:
我们可以将这些象限分为:
- 已知的知识:你的机器学习模型今天可以自信而准确地做什么。
- 已知的未知:你的机器学习模型今天不能自信地做什么。
- 未知的知识:预先训练好的模型中的知识，可以适应你的任务。
- 未知的未知:你的机器学习模型中的差距，今天它是盲目的。
我们如何解决每个机器学习知识象限中的问题？
除了单个象限(下面将详细介绍)之外，机器学习知识象限中的行和列对于我们如何解决问题也有重要的共享属性:
最上面一行可以在您当前的模型中解决:模型今天在哪里有信心或没有信心？
最下面的一行意味着在你的模型之外寻找:对于不同的未标记的项目，你应该使用什么样的其他预先训练好的模型和采样方法？
左栏可以通过正确的算法设计来解决:我们如何构建可解释的精确模型并利用预先训练的模型？
右栏可以通过人工交互来解决:我们如何通过主动学习对最优的未标记数据点进行采样，并获得准确的人工标注？
我们如何构建系统来解决每个象限中的问题？
对于迁移学习，机器学习社区仍然处于运动的开始。预训练模型仅在大约 5 年前起飞(甚至更近一些，在机器学习的一些领域，如自然语言处理)，因此我们仍在学习利用预训练模型和嵌入的最佳方法，特别是在主动学习和注释的上下文中。
对于我们未知的未知事物，人们今天使用的各种方法甚至没有一个通用的名称，这些方法包括:基于聚类的采样、异常值、异常检测、代表性采样、现实世界多样性采样等。这些方法是从机器学习世界的不同部分被吸收到主动学习中的，因此没有通用的名称，所以我将它们归类到“多样性采样”下:这个象限中的所有方法都试图在更广泛、更多样化的数据点集合上使模型更加准确。
有许多算法可以解决其中一个象限中的问题。例如，不确定性采样有一些常见的算法，如最小置信度、置信界限和基于熵的置信度，其中任何一种算法都可能是对数据中的最佳“已知未知”进行采样的最佳选择。
对于你的机器学习架构，你需要让它能够被主动学习所解释。例如，如果您使用 softmax 方程来生成预测的概率分布，您可能无法相信预测的“置信度”的绝对值。把置信度当作一个排名就足够了，你可以忽略实际值。或者，您可能决定公开您的模型下游处理系统的层，这些层可以更准确地确定置信度。或者作为一种更高级的策略，您甚至可以开发一个并行架构，在您的模型中有两个最终层(或者如果使用基于 transformer 的模型，则有两个注意力头):一个预测标签，第二个确定该预测的置信度。
一个结合了所有四个象限中的解决方案的战略的医疗保健示例
有一些聪明的策略可以将这些象限中的两个或多个问题的解决方案结合起来。
例如，假设您想从医疗保健文档的文本中获取额外的信息。也许你想知道哪些疾病被提到的频率更高，这样你就可以监控潜在的流行病——这是我以前工作过的一个用例。
您可以从使用迁移学习开始，通过调整一个 XLNet 预训练模型来构建一个新模型，以提取您的医疗保健文档中与医疗相关的信息。
然而，XLNet 是在公共网站和其他公开文本上预先训练的，这看起来与你的私人医疗保健文档有很大不同。所以，你需要获取更多的训练实例。
您决定从您的医疗保健文档中抽取未标记的项目，这些项目看起来与 XLNet 接受训练的开放数据最不同。为了进一步细化您采样的未标记项目，您今天仅从您的分类器中采样具有< 50%置信度的项目，因为它们最有可能包含错误。
虽然在我们的医疗保健相关示例中，所有工作流都像常识一样，但我们需要正确处理许多实施细节，因为它结合了迁移学习、不确定性采样和多样性采样。您必须决定哪种迁移学习、不确定性采样和多样性采样算法最适合您的数据和用例。
人在回路中的机器学习资源
20 年来，我一直在构建结合人类和算法方法进行机器学习的系统。看到变化如此之大很有趣:
在过去的 25 年中，培训数据发生了怎样的变化？
towardsdatascience.com](/a-brief-history-of-training-data-9c513fc95b3e)
体验最新进展也很有趣:
对前 65，000 个 Unicode 字符应用 StyleGAN 以生成新字符
towardsdatascience.com](/creating-new-scripts-with-stylegan-c16473a50fd0)
为了继续分享我学到的更多东西，我将在未来几个月发表一系列文章和开源代码。本文是第一篇，下一篇将深入探讨不确定性采样。大多数算法是在十多年前发明的，但根据机器学习的新神经方法重新检查是令人兴奋的。
这些例子和开源代码也可以在我最近发布的教科书《人在回路中的机器学习:
我学到了很多以前从未想过的关于机器学习的新东西。
www.manning.com](https://www.manning.com/books/human-in-the-loop-machine-learning)
文章和开源代码是独立的，但是如果你想更深入地了解这些主题，请查阅这本书！教科书也将在接下来的几个月里逐章发布。如果你知道一些相关和有趣的研究或我应该强调的人在回路中的机器学习的实际例子，请让我知道！
对于任何象限的解决方案，有一些算法是容易实现的低挂果实，也有一些解决方案将在计算上或实现上非常难以实现。与大多数事情一样，您应该从简单开始，只在需要时才开始构建更复杂的解决方案。关于这一点，下面是第一个开源代码示例:
[## rmunro/pytorch_active_learning
PyTorch 主动学习入门。为 rmunro/pytorch_active_learning 的发展做出贡献，创建一个…
github.com](https://github.com/rmunro/pytorch_active_learning)
它用不到 500 行代码解决了四个象限中的三个象限(除了迁移学习之外的一切)，使用了一个类似于上面医疗保健例子的灾难响应场景。
从技术角度来说，我已经用 PyTorch 编写了大部分代码(并将在最终发布之前将整本书转换成 py torch——其中一章目前在 Numpy 中)。因此，对于用 PyTorch 构建人在回路中的机器学习系统的人来说，这些代码会特别有趣。然而，无论您选择何种框架或语言进行编码，这些示例都足够通用，足以让您理解！
罗伯特·芒罗【2019 年 7 月
面部表情识别中的偏见
Image: A dancer depicting the navarasa (nine emotions), source: shakti-e.monsite.com.
我如何使用南亚艺术美学来建立一个卷积神经网络。
我从小到大最喜欢的电视节目之一是探索频道的 docu 系列节目“它是如何制作的”这是一场揭示日常用品——从铝箔到实验室玻璃器皿——是如何制作的展览。当你观看自动化机器时，解说员平静的声音解释了这个过程，有时在工厂工人的帮助下，毫不费力地快速建造物体。考虑你周围的物理对象；你可能会有根据地猜测它们是如何制成的或者是由什么制成的。但是，如果我让你告诉我，当你看着手机解锁时，你让 Siri 或 Alexa 为你做一些事情，或者在你打字之前，单词和整个句子是如何自动完成的，会发生什么呢？换句话说，你知道你的人工智能(AI)是怎么做出来的吗？
A machine testing highlighters after they’ve been made. Source: huffpost.com
AI 无缝地融入了我们的生活，并为我们做出了无数甚至我们可能都没有意识到的决定。但是人工智能的存在不仅仅是帮助我们完成日常任务。人工智能为我们做出的决定有可能会有偏差。使用“犯罪风险评估算法的警察部门正瞄准低收入和少数族裔人口，因为他们更有可能犯罪，无人驾驶的汽车无法检测深色皮肤的行人，许多大型科技公司很难识别女性和有色人种的面孔——这样的例子不胜枚举。现在比以往任何时候都更重要的是#了解你的未来。
在我对事物如何运作的好奇心的驱使下，我决定建立自己的人工智能系统，它不会使对代表性不足的社区的偏见永久化。我开发了一个面部识别系统，该系统基于一个解决人工智能偏见的框架，从人们的脸上检测情绪。在这篇文章中，我将向你介绍我开发这个项目的主要步骤，但是如果你想更深入地了解我的代码和分析，请查看我的 GitHub 库。
I developed a facial recognition system that detects emotions from people’s faces.
步骤 1:理解人工智能中的偏见是如何存在的
当 AI 有偏见时，正在收集的数据不是包容性的，或者是有选择地选择来促进某种(有偏见的)叙事。此外， 为人工智能系统做决策的人会影响项目的结果。最后，用来分析数据的框架当它们实际上是基于特定的社会信仰时，就被理解为科学真理。
Addressing bias in AI by understanding the data (how and what data is collected), the people (who are responsible for collecting and/or analyzing that data), and the frameworks (how the data is analyzed). Credit: Jasmine Vasandani.
以下是我如何确保我没有在我的项目中延续偏见:
- 数据:我的数据集包括有色人种、性别不合群的人、年轻人和老年人，以及带面部饰品的人的图像。
- 人物:我是一个色彩数据科学家的酷儿女，深受 AI 偏见的影响并深感忧虑。
- 框架:为了对情绪进行分类，我脱离了“快乐”、“悲伤”、“愤怒”等一般分类，转而引用了 navarasa (或九种情绪)所定义的情绪。
第二步:使用“纳瓦拉沙”对情绪进行分类
The navarasa. Image credit: Leesa Mohanty.
为了从图像中检测面部表情，我建立了一个卷积神经网络(CNN，或 convnet)，它由一系列层组成，这些层处理一幅图像，并告诉你它在图像中“看到”了什么情绪。由我来告诉 convnet 检测哪种类型的情绪。对我来说，重要的是不要用一个通用的框架来理解情绪，因为每种文化都有自己对情绪分类的方式。例如，这里的一个眼色(无论“这里”对你来说是什么意思)可能与其他地方的一个眼色不是一回事。相反，我实现了 navarasa 作为一个框架来对情绪进行分类。纳瓦拉萨在梵文文本 Natya Shastra (公元前 200-200 年或公元前 500-500 年)中被定义，由南亚艺术家和哲学家 Bharata Muni 所写。Natya Shastra 被认为是今天南亚古典艺术的基础文本。这段文字创造了梵语术语 rasa ，字面上可以翻译为“汁液”或“果汁”，但也可以表示“精华”、“味道”、“风味”或“情感”。在文本中，巴拉塔陈述道纳瓦拉萨是“所有人类情感的基础” 组成纳瓦拉萨的九种情绪是:
- adbhuta (惊愕)
- bibhatsa (厌恶)
- bhayanaka (恐惧)
- 哈斯亚(欢乐)
- 卡鲁纳(悲伤)
- 鲁德拉(愤怒)
- 圣诞老人(和平)
- srngara (爱情)
- veera (信心)
navarasa 可以有不同的翻译，但我还是坚持上面的翻译。对我来说，使用 navarasa 作为情绪分类的框架只是第一步。在这个项目未来的迭代中，我希望实现其他文化情感框架，以更好地通过人工智能来表现人类表达的复杂性。既然我已经确定了我的框架，是时候构建一个图像数据集了，我将用它来输入到 convnet 中。
Classical South Asian dancers depicting the navarasa.
步骤 3:构建包容性影像数据集
我用来构建面部表情检测器的 convnet 的一切都是可定制的。例如，我可以使用 convnet 构建一个系统来告诉我房间图像中显示的是什么家具，根据面部图像判断一个人的年龄，图像中显示的是什么颜色，等等。对于我的 convnet，我已经定制了输出，即纳瓦拉萨。但是现在我需要告诉模型在什么样的图像中检测导航系统。为了建立我的图像数据集，我手工挑选了 1035 张图像，其中大部分人脸代表了有色人种、性别不合群的人、年轻人和老年人，或者戴着面部饰品的人。
我使用的图片来自以下来源:
建立一个大型数据集，同时确保图像不仅具有包容性，而且能够代表纳瓦拉萨的九种情绪，这是一项艰巨的任务。我为每种情绪收集了几乎等量的图像，但如果有更少的情绪来组织图像，我可以建立一个更大的数据集。我的数据集的质量可以改进，我希望继续建立一个表达各种情绪的包容性面部图像数据库。下面是根据导航系统分类后的图片预览。
My images dataset categorized into the navarasa. Image source for srngara face.
步骤 4:准备图片来训练我的模型
我现在有了我的 convnet 的输入(图像数据集)和输出( navarasa )。现在，我需要准备构建并激活我的 convnet，以便它可以开始从图像中预测面部表情。该过程的下一步是确保所有的图像都是相同的尺寸和相同的配色方案。所以我检查了我的整个图像数据集，将每张图像设置为相同的矩形尺寸，并将其全部灰度化。使用 python，我从图像中检测人脸，将它们裁剪成特定的大小，并将其转换成灰度。我可以选择一个不同的维度来设置所有图像，并将它们保存为彩色图像，但是这些参数特别适合我的数据集。
Image processing: detect face, crop, and convert to grayscale.
除了上述规范之外，我的所有图像都需要采用数值形式，以便由我的 convnet 处理。所以我把这些图像转换成一个由像素值组成的矩阵。在下图中，最左边的图显示了一个像素化的图像，中间显示了对应于像素颜色的值，左边显示了如果仅用像素值来描绘图像的效果。
Far left: pixelated, middle: pixelated with values, far right: pixel values. Image source: http://ai.stanford.edu/~syyeung/cvweb/tutorial1.html.
将图像转换成像素值的矩阵相对容易，下面是如何用 python 实现的基础知识。
**import** **numpy** **as** **np
from** **PIL** **import** Image#Create a variable to store the path to your image directory
image_dir = #image_directory_path#Open the image
img = Image.open(image_dir)#Convert the image to a numpy array
np.array(img)
步骤 5:实现卷积神经网络(convnet)
简单来说，convnet 通过一系列层来处理图像的像素值，其中每一层都定位图像中的视觉趋势。例如，如果某人微笑的图像通过 convnet 的层，则 convnet 会将上翘的嘴、微笑的眼睛和抬高的脸颊识别为属于笑脸的独特特征。因此，当另一个人微笑的图像通过 convnet 时，它会告诉你图像中的人在微笑。下面是一个 convnet 层的可视化。一幅图像(最左边的输入)通过一个 convnet 的各层，输出是九个纳瓦拉萨之一。如果你想更深入地了解 convnets，请查看这个视频教程。
An example of what the layers of a convnet look like. In this example, if the input image were to be passed through the model, its output would be “santa” (peace).
Convnets 最适合大型数据集，但我的数据集相对较小，只有 1000 多张图片。幸运的是，有一个叫做[ImageDataGenerator](https://keras.io/preprocessing/image/)的工具可以解决我的小数据集问题。通过实现ImageDataGenerator，我的数据集中的每张图片都得到了细微的调整，比如翻转、放大、倾斜等等。这个过程欺骗了 convnet，让它认为我正在处理一个更大的独特图像数据集。如果你想知道我构建的 convnets 的精度和损耗值，请查看我的 GitHub 库。
An example of how an image gets altered to trick the convnet into thinking there are new images being introduced to it. Image source.
第六步:从图像中预测“纳瓦拉沙”
最后，我现在可以根据 convnet 认为图像表达的情绪来生成预测。convnet 只会预测它认为哪个纳瓦拉萨在图像中被表达，它还会告诉你它在图像中检测到了其他纳瓦拉萨中的哪个。
PREDICTION #1.
在“预测 1”可视化中，有一个正在表达 veera (信心)的人的图像。convnet 做出了准确的预测，并有 55%的把握在图像中检测到了 veera 。convnet 还在图像中看到了 roudra(愤怒)、karuna(悲伤)和其他情绪的痕迹。由于 veera 收到的概率最高，因此 convnet 选择这种情绪作为最终预测。
PREDICTION #2. Image Source.
在“预测 2”可视化中，有一个人正在表达 adbhuta(惊讶)的图像，但 convnet 的最强预测只有 15%，而且是针对 bhayanaka(恐惧)的不正确情绪。不准确的预测可能是由许多原因造成的，其中一些原因是该图像可能在其特定的 rasa(情感)上与其他图像不相似，照片的质量差，等等。
PREDICTION #3.
在“预测 3”可视化中，有一个人正在表达 hasya (喜悦)的图像。convnet 几乎 100%确定这是某人表达喜悦的图像。
结论和后续步骤
Artistic depiction of the navarasa. Source.
完全使用开源资源并在有限的时间框架内工作，我能够建立一个人工智能系统，它不会使对服务不足的社区的偏见永久化。首先，我确定了人工智能中的偏见是如何延续的:通过收集什么数据，谁解释数据，以及如何分析数据。在我的项目中，我使用这个框架来直接解决和减轻偏见。对我来说，确定我的下一步很容易，那就是建立一个包容性的图像数据集，并开发一个基于文化特定情感的预测人工智能。如果有更多的时间和资源，我会扩大我的数据集，以包括更多关于纳瓦拉沙的图像和艺术描述，与合作者一起工作，并测试更多的人工智能方法。总的来说，我对这个项目的结果很满意，因为它帮助我开发了一个基于项目的框架来解决人工智能中的偏见。
作为这篇文章的读者，无论你是否是人工智能专家，我希望我已经激发了你对#KnowYourAI 的好奇心。
要查看这个项目中使用的代码，请查看我的 GitHub 资源库 。
A classical dancer depicting the navarasa.
感谢在我完成这个项目时支持和指导我的以下人员:Anuva Kalawar、ADI wid(Boom)Devahastin Na Ayudhya、Matthew Brems、Riley Dallas、Tim Book。再次特别感谢 Anuva Kalawar，没有他，这个项目就不会存在。
Jasmine Vasandani 是一名数据科学家。你可以在这里了解她的更多:www.jasminev.co/
Kohonen 自组织地图
一种特殊类型的人工神经网络
EMNIST Dataset clustered by class and arranged by topology
背景
自组织地图是由芬兰教授和研究员 Teuvo Kohonen 博士于 1982 年提出的，它是一种无监督的学习模型，旨在应用于维护输入和输出空间之间的拓扑很重要的情况。该算法的显著特点是高维空间中相近的输入向量也被映射到 2D 空间中的邻近节点。它本质上是一种降维方法，因为它将高维输入映射到低维(通常是二维)离散表示，并保留其输入空间的底层结构。
一个有价值的细节是，整个学习是在没有监督的情况下进行的，即节点是自组织的。它们也被称为特征图，因为它们本质上是重新训练输入数据的特征，并且简单地根据彼此之间的相似性将它们自己分组。这对于将复杂或大量的高维数据可视化，并将它们之间的关系表示到低维(通常是二维)域中，以查看给定的未标记数据是否具有任何结构，具有实用价值。
结构
Kohonen Architecture
自组织映射(SOM)在结构和算法特性上都不同于典型的人工神经网络。首先，它的结构由单层线性 2D 神经元网格组成，而不是一系列层。该网格上的所有节点都直接连接到输入向量*，但彼此不连接*，这意味着节点不知道其邻居的值，并且仅更新其连接的权重作为给定输入的函数。网格本身就是地图，它在每次迭代中根据输入数据的输入来组织自己。这样，在聚类之后，每个节点具有其自己的 (i，j) 坐标，这允许人们通过勾股定理来计算 2 个节点之间的欧几里德距离。
Kohonen network’s nodes can be in a rectangular (left) or hexagonal (right) topology.
属性
此外，自组织映射使用与纠错学习相反的竞争学习来调整其权重。这意味着在每次迭代中只有一个节点被激活，其中输入向量的实例的特征被呈现给神经网络，因为所有节点竞争对输入做出响应的权利。
所选结点(最佳匹配单元(BMU))是根据当前输入值和格网中所有结点之间的相似性选择的。
选择在输入向量和所有节点之间具有最小欧几里德差的节点以及其在某个半径内的相邻节点，以稍微调整它们的位置来匹配输入向量。
通过遍历格网上的所有结点，整个格网最终会与完整的输入数据集相匹配，相似的结点会被组合到一个区域，而不相似的结点会被分开。
A Kohonen model with the BMU in yellow, the layers inside the neighbourhood radius in pink and purple, and the nodes outside in blue.
变量
- t 是当前迭代
- n 是迭代极限，即网络可以经历的总迭代次数
- λ是时间常数，用于衰减半径和学习速率
- i 是节点网格的行坐标
- j 是节点网格的列坐标
- d 是节点和 BMU 之间的距离
- w 是权重向量
- w_ij(t) 是网格中节点 i，j 与输入向量在迭代 t 处的实例之间连接的权重
- x 是输入向量
- x(t) 是输入向量在迭代 t 时的实例
- α(t) 为学习率，在区间[0，1]内随时间递减，保证网络收敛。
- β_ij(t) 是邻域函数，单调递减，表示节点 i，j 到 BMU 的距离，以及它对步骤 t 的学习的影响。
- *∑(t)*是邻域函数的半径，其确定在更新向量时在 2D 网格中检查多远的邻居节点。随着时间的推移逐渐减少。
算法
- 将每个节点的权重 w_ij 初始化为随机值
- 选择一个随机输入向量 x_k
- 重复第 4 点。和 5。对于图中的所有节点:
- 计算输入向量 x(t) 和与第一节点相关联的权重向量 w_ij 之间的欧几里德距离，其中 t，I，j = 0。
- 追踪产生最小距离 t 的节点。
- 找到整体最佳匹配单元(BMU)，即与所有计算出的单元距离最小的节点。
- 确定 Kohonen 图中 BMU 的拓扑邻域 βij(t) 其半径 σ(t)
- 对 BMU 邻域中的所有节点重复:通过添加输入向量 x(t) 和神经元的权重 w(t) 之间的差的一部分来更新 BMU 邻域中的第一个节点的权重向量 w_ij 。
- 重复整个迭代过程，直到达到选定的迭代极限 t=n
步骤 1 是初始化阶段，而步骤 2–9 代表训练阶段。
公式
根据以下公式对变量进行更新和更改:
邻域内的权重被更新为:
第一个等式告诉我们，节点 i，j 的新的更新权重 w_ij (t + 1) 等于旧的权重 w_ij(t) 和旧的权重与输入向量 x(t) 之差的一部分的总和。换句话说，权重向量向输入向量“移动”得更近。要注意的另一个重要因素是，更新的权重将与邻域半径中的节点和 BMU 之间的 2D 距离成比例。
此外，相同的等式 3.1 没有考虑到学习与节点距 BMU 的距离成比例的影响。更新的权重应该考虑这样的因素，即学习的效果在邻域的末端接近于零，因为学习的量应该随着距离而减少。因此，第二个方程增加了额外的邻域函数因子 βij(t) ，是更精确的深度方程。
半径和学习率都类似地随时间呈指数衰减。
邻域函数的影响 β_i(t) 计算如下:
每个节点的权重向量和当前输入实例之间的欧几里德距离是通过勾股公式计算的。
从所有节点的计算距离中选择 BMU 作为最小距离。
进一步阅读
- 更深入地阅读算法的各个方面:https://eklavyafcb.github.io/som.html
- 在https://github.com/EklavyaFCB/EMNIST-Kohonen-SOM可以找到该算法的一个很好的实现
kt rain:Keras 的一个轻量级包装器，用于帮助训练神经网络
ktrain 是一个在深度学习软件框架 Keras 中帮助构建、训练、调试和部署神经网络的库。(从v0.7开始，ktrain 在 TensorFlow 中使用tf.keras而不是独立的 Keras。)受 fastai 库的启发， ktrain 只需几行代码，就能让您轻松:
- 在给定数据的情况下，使用学习率查找器估计模型的最佳学习率
- 采用学习率计划，如三角学习率政策、1 周期政策和 SGDR 来更有效地训练您的模型
- 为文本分类(例如，NBSVM、fastText、带有预训练单词嵌入的 GRU)和图像分类(例如，ResNet、Wide Residual Networks、Inception)采用快速且易于使用的预设模型
- 加载和预处理各种格式的文本和图像数据
- 检查错误分类的数据点，以帮助改进模型
- 利用简单的预测 API 保存和部署模型和数据预处理步骤，对新的原始数据进行预测
ktrain 是开源的，可以在 GitHub 这里获得。它需要 Python 3，可以用 pip 安装如下:pip3 install ktrain
我们将通过例子展示几个关于 ktrain 的用例。
将模型和数据包装在学习者对象中
ktrain 设计用于与 Keras 无缝协作。在这里，我们加载数据并定义模型，就像您在 Keras 中通常所做的那样。以下代码直接复制自 Keras fastText 文本分类示例。它加载 IMDb 电影评论数据集，并定义一个简单的文本分类模型来推断电影评论的情感。
*# load and prepare data as you normally would in Keras*
**from** **tensorflow**.**keras.preprocessing** **import** sequence
**from** **tensorflow.keras.datasets** **import** imdb
NUM_WORDS = 20000
MAXLEN = 400
**def** load_data():
(x_train, y_train), (x_test, y_test) = imdb.load_data(num_words=NUM_WORDS)
x_train = sequence.pad_sequences(x_train, maxlen=MAXLEN)
x_test = sequence.pad_sequences(x_test, maxlen=MAXLEN)
**return** (x_train, y_train), (x_test, y_test)
(x_train, y_train), (x_test, y_test) = load_data()*# build a fastText-like model as you normally would in Keras*
**from** **tensorflow.keras.models** **import** Sequential
**from** **tensorflow.keras.layers** **import** Dense, Embedding, GlobalAveragePooling1D
**def** get_model():
model = Sequential()
model.add(Embedding(NUM_WORDS, 50, input_length=MAXLEN))
model.add(GlobalAveragePooling1D())
model.add(Dense(1, activation='sigmoid'))
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
**return** model
model = get_model()
要使用 ktrain ，我们只需使用get_learner函数将模型和数据包装在一个ktrain.Learner对象中:
import **ktrain**
learner = **ktrain.get_learner**(model,
train_data=(x_train, y_train),
val_data = (x_test, y_test))
默认的批处理大小是 32，但是可以通过向get_learner提供一个batch_size参数来改变。学习者对象有助于以各种方式训练您的神经网络。例如，调用学习者对象的fit方法允许你以不同的学习速度进行交互式训练:
# train for three epochs at 0.005
**learner.fit**(5e-3, 3)# train for additional three epochs at 0.0005
**learner.fit**(5e-4, 3)
由学习者对象包装的底层 Keras 模型总是可直接访问的，如下:learner.model
接下来，我们展示了学习者对象也可以用于找到一个好的初始学习率，并且容易地使用各种不同的学习率计划，这些计划在训练期间自动改变学习率。
调整学习率
学习率是在神经网络中设置的最重要的超参数之一。各种优化器(如 Adam 和 SGD)的默认学习速率可能并不总是适合给定的问题。神经网络中的训练包括最小化损失函数。如果学习率太低，训练将会很慢或者停滞不前。如果学习率太高，损失将无法最小化。这两种情况都会对模型的性能产生负面影响。要为您的模型找到一个最佳的学习率，可以通过以低学习率开始并逐渐增加学习率来模拟训练。 Leslie Smith 展示了当绘制学习率与损失的关系图时，与持续下降的损失相关的最大学习率是一个很好的培训选择。他将此称为 LR 范围测试(也称为 LR Finder)。遵循与 fastai 库类似的语法，这可以在 ktrain 中完成，如下所示:
**learner.lr_find()
learner.lr_plot()**
上面的代码将为上面加载的模型和数据显示以下图形:
We must select the maximal learning rate where the loss is still falling prior to divergence.
根据该图，0.005 的学习率似乎是一个合理的选择，因为损失在更高的学习率下开始发散。
学习费率表
许多研究表明，在训练过程中以各种方式改变学习率可以提高神经模型的性能，使损失最小化，并提高验证的准确性。例如，除了最初的1 周期论文之外，Sylvain Gugger 的本实验中还演示了具有循环动量的1 周期学习率计划的好处。 ktrain 允许您轻松采用几种不同的学习率策略。这里，我们展示一些例子:
在 ktrain 中训练模特的不同方法:
# employs a static learning rate of 0.005 for 3 epochs
**learner.fit**(0.005, 3)# employs an SGDR schedule with a cycle length of one epoch.
# learning rate is varied between 0.005 and near-zero value.
**learner.fit**(0.005, 3, cycle_len=1)# employs an SGDR schedule with a cycle length
# that increases by a factor of 2 each cycle
**learner.fit**(0.005, 3, cycle_len=1, cycle_mult=2)# employs the 1cycle learning rate policy
**learner.fit_onecycle**(0.005, 3)# employs a triangular learning rate policy with automatic stopping
**learner.autofit**(0.005)# employs a triangular learning rate policy with both maximum
# and base learning rates reduced when validation loss stalls
**learner.autofit**(0.005, 20, reduce_on_plateau=3)
我们将在下面详细介绍每一种方法，并从 SGDR 学习率政策开始。
SGDR 学习率政策
带重启的随机梯度下降(或 SGDR) 在用前述学习率探测器识别的初始学习率和接近零的学习率之间循环学习率。使用余弦退火来衰减学习速率。fit方法允许你以类似于 fastai 库的语法轻松使用 SGDR 学习率策略。当提供 cycle_len 参数时，余弦退火用于衰减周期持续时间内的学习速率。这里，我们显示了两个周期，每个周期具有一个时期的长度:
SGDR: learner.fit(0.005, 2, cycle_len=1)
cycle_mult 参数以指定的因子增加循环的长度。这里，周期长度随着每个周期而加倍( cycle_mult=2 ):
SGDR: learner.fit(0.005, 3, cycle_len=1, cycle_mult=2)
1 周期和三角学习率政策
除了fit，还有autofit方法(采用三角学习率策略)和fit_onecycle方法(采用1 周期策略)。两者都是由 NRL 海军研究实验室的 Leslie Smith 提出的。fit_onecycle方法在前半段训练中将学习速率从基本速率提高到最大速率，在后半段训练中将学习速率衰减到接近零值。最大学习率是使用上述学习率查找器设置的。
1cycle policy: learner.fit_onecycle(0.005, 3)
此外，如果将 Adam、Nadam 或 Adamax 优化器与fit_onecycle一起使用，动量在 0.95 和 0.85 之间循环，使得动量在低学习率时高，动量在高学习率时低。以这种方式改变动量在本文中被提出，并被证明可以加速收敛。
cyclical momentum in the 1cycle policy
autofit方法简单地在每个时期执行一个周期策略(可以认为是三角策略的变体):
Triangular Policy: learner.autofit(0.005, 2)
像这样每个时期执行一个周期，更适合与明显有效的内置 Keras 训练回调一起使用。这样的 Keras 回调可以很容易地通过autofit的方法参数来启用，例如early _ stopping(early stopping 回调)、reduce _ on _ plateau(ReduceLROnPlataeu)和check point _ folder(model check point)。例如，当 reduce_on_plateau 启用时，如果验证损失没有改善，峰值和基本学习率都会定期降低(或退火),这有助于提高性能:
Triangular Policy with ReduceLROnPlateau: learner.autofit(0.005, 8, reduce_on_plateau=2)
如果未向autofit提供时期数，则自动启用提前停止回调，训练将继续，直到验证损失不再增加。也有更多的理由让autofit进一步微调训练过程。在 Jupyter 笔记本中键入help(learner.autofit)了解更多详情。最后，虽然这里没有显示，但是autofit方法(像 1 周期策略)在 0.95 和 0.85 之间循环动量。
在前面的章节中，我们手动定义了一个模型，并在 ktrain 之外加载了数据。 ktrain 公开了许多方便的函数，可以轻松地从各种来源加载数据，并毫不费力地使用一些非常强大的基线模型。我们将展示一个图像分类和文本分类的例子——每一个都只需要几行代码。
图像分类:给狗和猫分类
图像分类和深度学习介绍中使用的一个标准数据集是狗对猫数据集。我们将在 ktrain 中使用该数据集作为图像分类的示例。在下面的代码块中，images_from_folder函数用于加载训练和验证图像作为 Keras 目录迭代器对象，并为训练图像增加数据。然后使用image_classifier函数在 ImageNet 上建立一个 ResNet50 模型。我们在目测了lr_plot生成的剧情后，选择 7e-5 作为学习率。由于我们在本例中调用autofit时没有指定历元数，当验证损失没有改善时，训练将自动停止。默认情况下，提前停止耐心值为 5，而减少延迟耐心值仅为 2。这些可以使用autofit的 early_stopping 和 reduce_on_plateau 参数来更改。该代码块的精度通常在 99.35% 和 99.55% 之间，如本笔记本所示。
# import ktrain modules
import **ktrain**
from **ktrain import vision as vis**# get default data augmentation with
# horizontal_flipping as only modification
data_aug = **vis.get_data_aug**(horizontal_flip=True)# load the data as Keras DirectoryIterator generators
(trn, val, preproc) = **vis.images_from_folder**(
datadir='data/dogscats',
data_aug=data_aug,
train_test_names=['train', 'valid'],
target_size=(224,224), color_mode='rgb')# build a pre-trained ResNet50 model and freeze first 15 layers
model = **vis.image_classifier**('pretrained_resnet50',
trn, val, freeze_layers=15)# wrap model and data in a Learner object
learner = **ktrain.get_learner**(model=model,
train_data=trn, val_data=val,
workers=8, use_multiprocessing=False,
batch_size=64)
**learner.lr_find()** # simulate training to find good learning rate
**learner.lr_plot()** # visually identify best learning rate# train with triangular learning rate policy
# ReduceLROnPlateau and EarlyStopping automatically enabled.
# ModelCheckpoint callback explicitly enabled.
**learner.autofit**(7e-5, checkpoint_folder='/tmp')
通过在训练后调用learner.view_top_losses(preproc, n=3)，我们可以查看验证集中分类错误最严重的前 n 个例子。这可以揭示如何改进您的模型或数据处理管道，以及是否要删除“垃圾”数据的数据集。例如，在狗和猫的数据集中，下图是验证集中分类错误最多的示例之一:
A misclassified example in the validation set
正如你所看到的，这张图片被贴上了“猫”的标签，尽管图片上同时出现了一只狗和一只猫，但狗的特征更加突出。这可能会有问题，因为该数据集将类视为互斥的。类别不互斥的数据集称为多标签分类问题，将在本文稍后讨论。
对新数据的预测
有了训练好的模型，我们可以将我们的模型和由images_from_folder返回的预预测对象包装在一个预测器对象中，从而轻松地对新的原始图像进行分类:
The Predictor object automatically preprocesses raw data before making predictions.
preproc 对象自动预处理并适当转换原始数据，以便准确地做出预测。预测器对象可以保存到磁盘，并在以后作为已部署应用程序的一部分重新加载:
有关详细的解释和结果，请参见我们的图像分类教程笔记本。
文本分类:识别有毒在线评论
Kaggle 上的有毒评论分类挑战涉及将维基百科评论分类为一个或多个所谓的有毒评论的类别。有毒在线行为的类别包括有毒、重度 _ 有毒、淫秽、威胁、侮辱、身份 _ 仇恨。与前面的例子不同，这是一个多标签分类问题，因为类别不是互斥的。例如，一条评论可能属于多个类别的有害在线行为。 ktrain 从数据中自动检测多标签分类问题，并适当配置内置模型。
数据集可以从比赛现场以 CSV 文件的形式下载(即下载文件 train.csv )。我们将使用texts_from_csv方法加载数据，该方法假设 label_columns 字段已经在电子表格中进行了一次热编码(Kaggle 的 train.csv 文件就是这种情况)。然后，我们将使用text_classifier方法加载一个类似 fastText 的模型。最后，我们使用autofit方法来训练我们的模型。在第二个示例中，我们明确地将历元数指定为 8。使用三角形学习率策略，因此执行 8 个三角形循环。
import **ktrain
from ktrain import text as txt**DATA_PATH = 'data/toxic-comments/train.csv'
NUM_WORDS = 50000
MAXLEN = 150
label_columns = ["toxic", "severe_toxic", "obscene",
"threat", "insult", "identity_hate"](x_train, y_train), (x_test, y_test), preproc =
**txt.texts_from_csv**(DATA_PATH,
'comment_text',
label_columns=label_columns,
val_filepath=None,
max_features=NUM_WORDS,
maxlen=MAXLEN,
ngram_range=1)# define model a fastText-like architecture using ktrain
model = **txt.text_classifier**('fasttext', (x_train, y_train),
preproc=preproc)# wrap model and data in Learner object
learner = **ktrain.get_learner**(model, train_data=(x_train, y_train),
val_data=(x_test, y_test))# find a good learning rate
**learner.lr_find()**
**learner.lr_plot()**# train using triangular learning rate policy
**learner.autofit**(0.0007, 8)
上面的代码块在 Titan V GPU 上仅用 6 分钟的训练就实现了大约为 0.98 的 ROC-AUC。如我们 GitHub 项目中的示例笔记本所示，使用带有预训练单词向量的双向 GRU(在 ktrain 中称为“bigru ”)可以获得更好的结果。
和前面的例子一样，我们可以实例化一个预测器对象来轻松地对新的原始数据进行预测:
更多信息
有关 ktrain 的更多信息和细节，请参见 GitHub 上的教程笔记本:
- 教程笔记本 1: 简介k train
- 教程笔记本 2: 调整学习率
- 教程笔记本 3: 图像分类
- 教程笔记本 4: 文字分类
- 教程笔记本 5: 从无标签文本数据中学习
- 教程笔记本 6: 文本序列标注
- 教程笔记本 7: 图形神经网络
- 教程笔记本 A1: 关于其他主题的附加技巧，例如为模型设置全局权重衰减、调试 Keras 模型、预览数据扩充方案，以及在 ktrain 中使用内置回调
- 教程笔记本 A2: 讲解文字和图像分类
- 教程笔记本 A3: 文字分类与抱脸变形金刚
- 附加示例
**2019–08–16:**在 Google Colab 上使用 ktrain ？请参见 BERT 的演示。
Kubeflow 组件和管道
Kubeflow 是一个大的生态系统，一堆不同的开源工具 ML tools。
我想让事情变得简单，因此我们涵盖了组件、管道和实验。通过管道和组件，您可以获得构建 ML 工作流所需的基础知识。Kubeflow 中集成了更多的工具，我将在接下来的文章中介绍它们。
Kubeflow 起源于谷歌。
使在 Kubernetes 上部署机器学习(ML)工作流变得简单、可移植和可扩展。
来源:Kubeflow 网站
Photo by Ryan Quintal on Unsplash
目标
- 演示如何建造管道。
- 演示如何创建组件。
- 演示如何使用组件。
- 演示如何在笔记本电脑中运行管道和实验。
- 易于理解和使用的示例。
管道
成分
在管道中执行一步的代码。换句话说，一个 ML 任务的容器化实现。
组件类似于函数，它有名称、参数、返回值和主体。流水线中的每个组件独立执行和必须打包成 docker 映像。
The components.
图表
组件之间的表示。它显示了管道正在执行的步骤。
The graph.
管道
流水线描述了机器学习的工作流程，它包括组件和图。
The pipeline.
奔跑
一次运行是一条流水线的单次执行**，为了比较，所有运行都被保留。**
A run is a single execution of a Pipeline.
重复运行
循环运行可用于重复管道运行，如果我们想要以预定的方式在新数据上训练更新的模型版本，这很有用。
实验
类似于工作空间，它包含不同的运行。跑分可以比较。
An overview of all runs in this specific experiment.
组件类型
Kubeflow 包含两种类型的组件，一种用于快速开发，另一种用于重用。
轻量级组件
用于笔记本环境中的快速开发。快速简单，因为不需要构建容器映像。
可重复使用的集装箱组件
可以通过将装载到 Kubeflow 管道中来重复使用。这是一个内含 T42 的组件。
要求多实施时间。
可重用成分
在本节中，您将获得可重用组件的基础知识。
组件结构
组件本身很简单，只由几个部分组成:
- 组件逻辑
- 一个组件规格为 yaml。
- 构建容器需要一个 Dockerfile 。
- 一个自述文件解释组件及其输入和输出。
- 助手脚本到构建组件，然后将组件推送到 Docker 仓库。
Parts of a reusable Kubeflow component.
部件规格
本规范描述了用于 Kubeflow 管道的容器组件数据模型。
以 YAML 格式编写(component.yaml)。
- 元数据描述组件本身，如名称和描述
- 接口定义组件的输入和输出。
- 实现指定组件应该如何执行。
处理输入
一个组件通常需要某种输入，比如训练数据的路径或者模型的名称。它可以消耗多个输入。
- 在 component.yaml 中定义输入
- 将输入定义为容器的参数。
- 解析组件逻辑中的 参数。
The training component might require training data as input and produces a model as output.
处理输出
需要输出来在组件之间传递数据。重要的是要知道流水线中的每个组件都独立执行。
- 组件在不同的进程中运行，不能共享数据。
- 传递小数据的过程不同于传递大数据的过程。
对于小数据
- 值可以作为输出直接传递。
对于大数据
- 大型数据必须序列化为文件，以便在组件之间传递。
- 上传数据到我们的存储系统。
- 并且将此文件的一个引用传递给下一个组件。
- 管道中的下一个组件将获取该引用，并且下载序列化数据。
Dockerize 组件
每个组件都是一个容器映像，需要一个 order 文件来构建映像。
映像构建完成后，我们将组件容器映像推送到 Google 容器注册表。
构建组件容器映像并将其上传到 Google 容器注册表只是几行代码:
# build_image.sh
image_name=gcr.io/ml-training/kubeflow/training/train
image_tag=latestfull_image_name=${image_name}:${image_tag}docker build --build-arg -t "${full_image_name}"
docker push "$full_image_name"
在第一次 docker 推送时，您可能会得到以下错误消息:
您没有执行此操作所需的权限，并且您可能有无效的凭据。要验证您的请求，请遵循以下步骤:https://cloud . Google . com/container-registry/docs/advanced-authentic ation
在这种情况下，只需运行以下 gcloud 命令并再次推送:
$ gcloud auth configure-docker
使用管道
加载组件
有权访问 Docker 存储库和 component.yaml 的每个人都可以在管道中使用组件。
Load a component from a component.yaml URL.
然后可以基于 component.yaml 将组件加载到。
operation = kfp.components.load_component_from_url(
'[https://location-to-your-yaml/component.yaml'](https://storage.googleapis.com/spielwiese-sascha-heyer/test9/component.yaml'))help(operation)
创建管道
dsl 装饰器通过管道 SDK 提供，用于定义管道并与之交互。dsl.pipeline为返回管道的 Python 函数定义一个装饰器。
[@dsl](http://twitter.com/dsl).pipeline(
name='The name of the pipeline',
description='The description of the pipeline'
)
def sample_pipeline(parameter):
concat = operation(parameter=first)
编译管道
为了编译管道，我们使用了compiler.Compile()函数，它也是管道 SDK 的一部分。编译器生成一个 yaml 定义，Kubernetes 使用它来创建执行资源。
pipeline_func = sample_pipeline
pipeline_filename = pipeline_func.__name__ + '.pipeline.zip'compiler.Compiler().compile(sample_pipeline,
pipeline_filename)
创造一个实验
管道总是实验的一部分，可以用 Kubeflow 管道客户端kfp.client()创建。目前无法删除实验。
client = kfp.Client()try:
experiment = client.get_experiment(experiment_name=EXPERIMENT_NAME)
except:
experiment = client.create_experiment(EXPERIMENT_NAME)
print(experiment)
运行管道
为了运行管道，我们使用实验 id 和在前面步骤中创建的编译管道。client.run_pipeline运行管道，并提供与库巴流实验的直接链接。
run_name = pipeline_func.__name__ + ' run'
run_result = client.run_pipeline(experiment.id,
run_name,
pipeline_filename)
GitHub 上的例子
我创建了一个基本的管道来演示本文中的所有内容。为了简单起见，管道不包含任何特定于 ML 的实现。
Usage
感谢阅读。
更多如 Kubeflow 整流罩、Katib 等话题敬请关注。
这篇文章的代码可以在GitHub上找到。
您的反馈和问题非常感谢，您可以在 Twitter 上找到我@ HeyerSascha。
关于作者
Sascha HeyerIo Annotator 的创始人一个用于文本和图像的 AI 注释平台
，它提供了几种图像和文本注释工具。
诗人的库伯流
机器学习生产流水线的容器化指南
本系列文章提供了一种在 Kubernetes 上使用 Kubeflow 生产机器学习管道的系统方法。构建机器学习模型只是一个更广泛的任务和过程系统的一部分，这些任务和过程共同交付一个机器学习产品。Kubeflow 使得利用容器化的微服务范例来分离在 Kubernetes 上编排的应用程序的模块化组件成为可能。虽然 Kubernetes 是平台不可知的，但本系列将重点关注在 Google 云平台上部署一个机器学习产品，利用 Google Cloud BigQuery、Google Cloud Dataflow 和在 Google Kubernetes 引擎上编排的 Google Cloud 机器学习引擎。
内容
内容安排如下:
源代码和贡献:
完整的源代码可以在 Github 上获得。贡献和更正是受欢迎的拉请求。
介绍
机器学习通常被正确地视为使用数学算法来教会计算机学习任务，这些任务在计算上不可编程为一组指定的指令。然而，从工程的角度来看，这些算法的使用只占整个学习过程的一小部分。构建高性能和动态的学习模型包括许多其他重要的组成部分。这些组件实际上主导了交付端到端机器学习产品的关注空间。
典型的机器学习生产管道如下图所示。
从上图中，可以观察到管道中的流程流是迭代的。这种重复模式是机器学习实验、设计和部署的核心。
效率挑战
很容易认识到，在构建学习模型时，流水线需要大量的开发操作来实现从一个组件到另一个组件的无缝转换。这种零件的互操作性产生了机器学习操作，也称为 MLOps。这个术语是机器学习和 DevOps 的混合体。
进行机器学习的传统方式是在 Jupyter 笔记本电脑上执行所有的实验和开发工作，模型被导出并发送给软件开发团队进行部署和端点生成，以集成到下游软件产品中，而 DevOps 团队处理机器的基础设施和配置以进行模型开发。这种单一的工作方式导致机器学习过程不可重用，难以扩展和维护，更难以审计和执行模型改进，并且容易充满错误和不必要的复杂性。
然而，通过将微服务设计模式整合到机器学习开发中，我们可以解决这些问题，并真正简化生产过程。
谷歌云平台上的一句话(GCP)
该教程将重点关注在谷歌云平台的基础设施上开发和部署生产模型。云的优势是易于根据资源需求分发和扩展单个工作流组件。然而，当使用微服务时，容器化管道是机器无关的，可以快速部署在任何其他本地基础设施或公共云服务提供商，如 AWS 或 Azure 上。
谷歌云平台拥有一系列强大的人工智能无服务器服务，我们将整合这些服务来处理生产管道的一些组件。这些服务包括 Google BigQuery，用于暂存我们的转换数据集以进行轻松分析，Google Dataflow 用于大规模数据转换，Google Cloud Machine Learning Engine 用于大规模模型训练和模型部署。
微服务架构
微服务架构是一种开发和部署企业云原生软件应用的方法，它涉及将应用的核心业务功能分离成分离的组件。每个业务功能都代表应用程序作为服务提供给最终用户的一些功能。微服务的概念与整体架构形成对比，后者将应用程序构建为其“单独”功能的组合。
微服务使用表述性状态转移(REST)通信进行交互，以实现无状态互操作性。所谓无状态，我们指的是“服务器不存储关于客户端会话的状态”。这些协议可以是 HTTP 请求/响应 API 或异步消息队列。这种灵活性允许微服务轻松扩展并响应请求，即使另一个微服务出现故障。
微服务的优势
- 松散耦合的组件使应用程序具有容错能力。
- 能够横向扩展，使每个组件高度可用。
- 组件的模块化使得扩展现有功能变得更加容易。
微服务的挑战
- 软件架构的复杂性增加了。
- 微服务管理和编排的开销。然而，我们将在接下来的会议中看到 Docker 和 Kubernetes 如何努力缓解这一挑战。
码头工人
Docker 是一个虚拟化应用程序，它将应用程序抽象到被称为容器的隔离环境中。容器背后的想法是提供一个统一的平台，其中包括用于开发和部署应用程序的软件工具和依赖项。
开发应用程序的传统方式是在单个服务器上设计和托管应用程序。这种设置导致了许多问题，包括著名的“它在我的机器上工作，但在你的机器上不工作”。此外，在这种体系结构中，应用程序难以扩展和迁移，从而导致巨大的成本和缓慢的部署。
虚拟机与容器
Left: Virtual machines. Right: Containers
虚拟机(VMs)模拟物理机的功能，使得通过使用虚拟机管理程序来安装和运行操作系统成为可能。虚拟机管理程序是物理机(主机)上的一个软件，它使虚拟化成为可能，在虚拟化中，多个客户机由主机管理。
另一方面，容器通过自己的库和软件依赖关系隔离了应用程序的宿主环境，然而，与 VM 相反，机器上的容器都共享相同的操作系统内核。Docker 是容器的一个例子。
使用 Docker
首先在本地机器上安装 Docker 软件，使其能够运行 Docker 容器。参观 https://www.docker.com/get-started开始吧。
需要注意的关键概念是:
- docker file:docker file 是一个指定如何创建图像的文本文件。
- **Docker 图像:**通过构建 Docker 文件来创建图像。
- Docker 容器: Docker 容器是图像的运行实例。
下图突出显示了构建映像和运行 Docker 容器的过程。
介绍 DockerHub
DockerHub 是一个托管 Docker 图像的库。
编写 docker 文件时的关键例程
以下是创建 docker 文件时的关键例程。
+------------+-----------------------------------------------------+
| **Command** | **Description** |
+------------+-----------------------------------------------------+
| **FROM** | The base Docker image for the Dockerfile. |
| **LABEL** | Key-value pair for specifying image metadata. |
| **RUN** | It execute commands on top of the current image as | | new layers. |
| **COPY** | Copies files from the local machine to the |
| container filesystem. |
| **EXPOSE** | Exposes runtime ports for the Docker container. |
| **CMD** | Specifies the command to execute when running the | | container. This command is overridden if another | | command is specified at runtime. |
| **ENTRYPOINT** | Specifies the command to execute when running the | | container. Entrypoint commands are not overridden |
| by a command specified at runtime. |
| **WORKDIR** | Set working directory of the container. |
| **VOLUME** | Mount a volume from the local machine filesystem to | | the Docker container. |
| **ARG** | Set Environment variable as a key-value pair when | | building the image. |
| **ENV** | Set Environment variable as a key-value pair that | | will be available in the container after building. |
+------------+-----------------------------------------------------+
构建并运行一个简单的 Docker 容器
在这个简单的例子中，我们有一个名为date-script.sh的 bash 脚本。该脚本将当前日期赋给一个变量，然后将日期打印到控制台。Dockerfile 会将脚本从本地机器复制到 docker 容器文件系统，并在运行容器时执行 shell 脚本。构建容器的 Dockerfile 文件存储在docker-intro/hello-world中。
***# navigate to folder with images***
cd docker-intro/hello-world
让我们来看看 bash 脚本。
cat date-script.sh*#! /bin/sh*
DATE**=**"**$(**date**)**"
echo "Todays date is $DATE"
让我们来看看文档。
***# view the Dockerfile***
cat Dockerfile*# base image for building container*
FROM docker.io/alpine
*# add maintainer label*
LABEL maintainer**=**"dvdbisong@gmail.com"
*# copy script from local machine to container filesystem*
COPY date-script.sh /date-script.sh
*# execute script*
CMD sh date-script.sh
- Docker 映像将基于 Alpine Linux 包构建。参见https://hub.docker.com/_/alpine
- 当容器运行时,
CMD例程执行脚本。
建立形象
***# build the image***
docker build -t ekababisong.org/first_image .
生成输出:
Sending build context to Docker daemon 2.048kB
Step 1/4 : FROM docker.io/alpine
latest: Pulling from library/alpine
6c40cc604d8e: Pull complete
Digest: sha256:b3dbf31b77fd99d9c08f780ce6f5282aba076d70a513a8be859d8d3a4d0c92b8
Status: Downloaded newer image for alpine:latest
---> caf27325b298
Step 2/4 : LABEL maintainer="dvdbisong@gmail.com"
---> Running in 306600656ab4
Removing intermediate container 306600656ab4
---> 33beb1ebcb3c
Step 3/4 : COPY date-script.sh /date-script.sh
---> Running in 688dc55c502a
Removing intermediate container 688dc55c502a
---> dfd6517a0635
Step 4/4 : CMD sh date-script.sh
---> Running in eb80136161fe
Removing intermediate container eb80136161fe
---> e97c75dcc5ba
Successfully built e97c75dcc5ba
Successfully tagged ekababisong.org/first_image:latest
运行容器
***# show the images on the image***
docker imagesREPOSITORY TAG IMAGE ID CREATED SIZE
ekababisong.org/first_image latest e97c75dcc5ba 32 minutes ago 5.52MB
alpine latest caf27325b298 3 weeks ago 5.52MB***# run the docker container from the image***
docker run ekababisong.org/first_imageTodays date is Sun Feb 24 04:45:08 UTC 2019
用于管理图像的命令
+---------------------------------+--------------------------------+
| **Command** | **Description** |
+---------------------------------+--------------------------------+
| **docker images** | List all images on the | | machine. |
| **docker rmi [IMAGE_NAME]** | Remove the image with name | | IMAGE_NAME on the machine. |
| **docker rmi $(docker images -q)** | Remove all images from the | | machine. |
+------------+-----------------------------------------------------+
用于管理容器的命令
+-------------------------------+----------------------------------+
| **Command** | **Description** |
+-------------------------------+----------------------------------+
| **docker ps** | List all containers. Append -a |
| to also list containers not | | running. |
| **docker stop [CONTAINER_ID]** | Gracefully stop the container | | with [CONTAINER_ID] on the | | machine. |
| **docker kill CONTAINER_ID]** | Forcefully stop the container |
| with [CONTAINER_ID] on the | | machine. |
| **docker rm [CONTAINER_ID]** | Remove the container with | | [CONTAINER_ID] from the machine. |
| **docker rm $(docker ps -a -q)** | Remove all containers from the | | machine. |
+------------+-----------------------------------------------------+
运行 Docker 容器
让我们分解下面运行 Docker 容器的命令。
docker run -d -it --rm --name [CONTAINER_NAME] -p 8081:80 [IMAGE_NAME]
在哪里，
-d:以分离模式运行容器。该模式在后台运行容器。-it:以交互模式运行，附带终端会话。--rm:退出时取出容器。--name:指定容器的名称。-p:从主机到容器的端口转发(即主机:容器)。
使用 Docker 在nginx网络服务器上提供网页
文档文件
# base image for building container
FROM docker.io/nginx
# add maintainer label
LABEL maintainer="dvdbisong@gmail.com"
# copy html file from local machine to container filesystem
COPY html/index.html /usr/share/nginx/html
# port to expose to the container
EXPOSE 80
建立形象
**# navigate to directory**
cd docker-intro/nginx-server/**# build the image**
docker build -t ekababisong.org/nginx_server .Sending build context to Docker daemon 2.048kB
Step 1/4 : FROM docker.io/nginx
latest: Pulling from library/nginx
6ae821421a7d: Pull complete
da4474e5966c: Pull complete
eb2aec2b9c9f: Pull complete
Digest: sha256:dd2d0ac3fff2f007d99e033b64854be0941e19a2ad51f174d9240dda20d9f534
Status: Downloaded newer image for nginx:latest
---> f09fe80eb0e7
Step 2/4 : LABEL maintainer="dvdbisong@gmail.com"
---> Running in 084c2484893a
Removing intermediate container 084c2484893a
---> 2ced9e52fb67
Step 3/4 : COPY html/index.html /usr/share/nginx/html
---> 1d9684901bd3
Step 4/4 : EXPOSE 80
---> Running in 3f5738a94220
Removing intermediate container 3f5738a94220
---> 7f8e2fe2db73
Successfully built 7f8e2fe2db73
Successfully tagged ekababisong.org/nginx_server:latest**# list images on machine**
docker imagesREPOSITORY TAG IMAGE ID CREATED SIZE
ekababisong.org/nginx_server latest 0928acf9fcbf 18 hours ago 109MB
ekababisong.org/first_image latest 773973d28958 20 hours ago 5.53MB
运行容器
**# run the container**
docker run -d -it --name ebisong-nginx -p 8081:80 ekababisong.org/nginx_server**# list containers**
docker psCONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
b3380cc02551 ekababisong.org/nginx_server "nginx -g 'daemon of…" 7 seconds ago Up 4 seconds 0.0.0.0:8081->80/tcp ebisong-nginx
在运行的服务器上查看网页
打开 web 浏览器并转到:0.0.0.0:8081
清除
**# shutdown the container**
docker stop b3380cc02551**# remove the container**
docker rm ebisong-nginx
将图像推送到 Dockerhub
登录 Docker 并提供您的userid和password。
**# login to docker**
docker login**# tag the image**
docker tag 096e538abc1e ekababisong/ebisong-nginx-server:latest**# push to Dockerhub**
docker push ekababisong/ebisong-nginx-serverThe push refers to repository [docker.io/ekababisong/ebisong-nginx-server]
db4c3e547e3f: Pushed
6b5e2ed60418: Mounted from library/nginx
92c15149e23b: Mounted from library/nginx
0a07e81f5da3: Mounted from library/nginx
latest: digest: sha256:733009c33c6cf2775fedea36a3e1032006f1fe3d5155f49d4ddc742ea1dce1f1 size: 1155
卷
本地目录可以作为卷安装到正在运行的容器中，而不是容器文件系统本身。对于卷，数据可以与容器共享，同时保存在本地机器上。卷在docker run命令中贴有-v标签。
将卷挂载到容器化的nginx Web 服务器
docker run -d -it --name ebisong-nginx -p 8081:80 -v /Users/ekababisong/Documents/Talks/kubeflow-for-poets/docker-intro/nginx-server/html:/usr/share/nginx/html ekababisong.org/nginx_server
现在，无论对文件index.html做了什么更改，都可以从 Docker 容器中的nginx服务器的 web 浏览器上立即看到。
从 Dockerhub 运行 Tensorflow Jupyter 图像
注意:这张图片很大，从 Dockerhub 中提取需要一段时间。
**# pull the image from dockerhub**
docker pull jupyter/tensorflow-notebookUsing default tag: latest
latest: Pulling from jupyter/tensorflow-notebook
a48c500ed24e: Pull complete
...
edbe68d32a46: Pull complete
Digest: sha256:75f1ffa1582a67eace0f96aec95ded82ce6bf491e915af80ddc039befea926aa
Status: Downloaded newer image for jupyter/tensorflow-notebook:latest
运行 Tensorflow Jupyter 容器
这个命令启动一个运行 Jupyter 笔记本服务器的短暂容器，并在主机端口 8888 上公开服务器。服务器日志出现在终端中。访问 http:// <主机名> :8888/？浏览器中的 token= < token >加载 Jupyter 笔记本仪表板页面。它是短暂的，因为 Docker 在笔记本服务器退出后销毁了容器。这是因为docker run命令中的--rm标签。
**# run the image**
docker run --rm -p 8888:8888 jupyter/tensorflow-notebook
下图显示了一个从 Docker 容器运行的笔记本。
按下control + c收回本地终端。
库伯内特斯
当微服务应用程序被部署到生产环境中时，它通常会有许多正在运行的容器，需要为这些容器分配适量的资源来响应用户的需求。此外，还需要确保容器在线、正在运行并相互通信。高效管理和协调集装箱化应用集群的需求催生了 Kubernetes。
Kubernetes 是一个软件系统，它解决了部署、扩展和监控容器的问题。因此，它被称为容器编排器。其他类似的例子有 Docker Swarm、Mesos Marathon 和 Hashicorp Nomad。
Kubernetes 是由谷歌作为开源软件构建和发布的，现在由云本地计算基金会(CNCF) 管理。谷歌云平台提供了一个名为 的托管 Kubernetes 服务，谷歌 Kubernetes 引擎(GKE) 。针对 Kubernetes (EKS)的亚马逊弹性容器服务也提供托管的 Kubernetes 服务。
库伯内特的特点
- **水平自动缩放:**根据资源需求动态缩放容器。
- **自我修复:**重新配置失败的节点以响应健康检查。
- **负载平衡:**有效地在 pod 中的容器之间分配请求。
- **回滚和更新:**轻松更新或恢复到以前的容器部署，而不会导致应用程序停机。
- **DNS 服务发现:**使用域名系统(DNS)作为 Kubernetes 服务来管理容器组。
库伯内特斯的成分
Kubernetes 发动机的主要部件有:
- 主节点:管理 Kubernetes 集群。出于容错目的，它们可以是处于高可用性模式的多个主节点。在这种情况下，只有一个是主，其他的都是从。
- 工作节点:运行被调度为 pod 的容器化应用程序的机器。
下图提供了 Kubernetes 架构的概述。稍后，我们将简要介绍各个子组件。
主节点
- **etcd(分布式密钥存储)😗*管理 Kubernetes 集群状态。这个分布式密钥库可以是主节点的一部分，也可以在主节点之外。然而，所有主节点都连接到它。
- **api 服务器:**管理所有管理任务。
api server接收来自用户的命令(kubectlcli、REST 或 GUI)，执行这些命令，并将新的集群状态存储在分布式密钥库中。 - **调度器:**通过分配 pod 将工作调度到工作节点。它负责资源分配。
- **控制器:**确保 Kubernetes 集群保持所需的状态。理想状态是 JSON 或 YAML 部署文件中包含的状态。
工作节点
- kube let:
kubelet代理运行在每个工人节点上。它将工作节点连接到主节点上的api server,并从它那里接收指令。确保节点上的单元运行正常。 - kube-proxy: 它是运行在每个工作节点上的 Kubernetes 网络代理。它会监听
api server，并将请求转发给适当的 pod。这对负载平衡很重要。 - **pod:**由一个或多个共享网络和存储资源以及容器运行时指令的容器组成。豆荚是库伯内特最小的可部署单位。
编写 Kubernetes 部署文件
Kubernetes 部署文件定义了各种 Kubernetes 对象所需的状态。Kubernetes 对象的示例有:
- 一个或多个容器的集合。
- **副本集:**主节点中
controller的一部分。指定在任何给定时间应该运行的 pod 的副本数量。它确保在集群中维护指定数量的 pod。 - **部署:**自动创建
ReplicaSets。它也是主节点中controller的一部分。确保集群的当前状态与所需状态相匹配。 - **名称空间:**将集群划分成子集群，以便将用户组织成组。
- **服务:**一组逻辑单元，具有访问它们的策略。
- *服务类型:*指定服务的类型，如
ClusterIP、NodePort、LoadBalancer、ExternalName。例如，LoadBalancer使用云提供商的负载均衡器对外公开服务。
编写 Kubernetes 部署文件的其他重要标记。
- **规格:**描述集群的期望状态。
- **元数据:**包含对象的信息。
- **标签:**用于将对象的属性指定为键值对。
- **选择器:**用于根据标签值选择对象的子集。
部署文件被指定为一个yaml文件。
下一节中的示例将在前面的章节中推送到 Dockerhub 的 nginx 服务器映像部署到 Kubernetes 集群。该图像可在https://hub.docker.com/r/ekababisong/ebisong-nginx-server获得。
服务对象的示例
这个Service对象的代码片段保存在kubernetes-intro/deployment.yaml中。
kind: Service
apiVersion: v1
metadata:
name: nginx-server-service
spec:
*# service applies to the application with name `nginx-server`*
selector:
app: nginx-server
ports:
- protocol: "TCP"
*# port inside cluster*
port: 8080
*# forward to port inside the pod*
targetPort: 80
*# accessible outside cluster*
nodePort: 30001
*# load balance between 5 instances of the container application*
type: LoadBalancer
部署对象的示例
这个Deployment对象的代码片段保存在kubernetes-intro/deployment.yaml中。
apiVersion: extensions/v1beta1
kind: Deployment
metadata:
name: nginx-server-deployment
spec:
replicas: 5
template:
metadata:
labels:
app: nginx-server
spec:
containers:
- name: nginx-server
image: ekababisong/ebisong-nginx-server
ports:
- containerPort: 80
使用 Minikube 在本地机器上运行 Kubernetes
Minikube 使得在本地机器上安装和运行单节点 Kubernetes 集群变得很容易。前往https://kubernetes.io/docs/tasks/tools/install-minikube/获取安装 Minikube 的说明。
- 安装一个管理程序，例如 VirtualBox 。
- 安装 Kubernetes 命令行界面
kubectl。对于 mac:
brew install kubernetes-cli
检查安装的版本:
kubectl version
3.安装 Minikube。对于 mac:
brew cask install minikube
Minikube 命令概述
+---------------------+--------------------------------------------+
| **Command** | **Description** |
+---------------------+--------------------------------------------+
| **minikube status** | Check if Minikube is running. |
| **minikube start** | Create local kubernetes cluster. |
| **minikube stop** | Stop a running local kubernetes cluster. |
| **minikube dashboard** | Open Minikube GUI for interacting with the | | Kubernetes cluster. Append & to open in | | background mode minikube dashboard &. |
| **minikube ip** | get ip address of Kubernetes cluster. |
+------------+-----------------------------------------------------+
kubectl命令概述
+-------------------------------------------+----------------------+
| **Command** | **Description** |
+-------------------------------------------+----------------------+
| **kubectl get all** | list all resources. |
| **kubectl get pods** | list pods. |
| **kubectl get service** | list services. |
| **kubectl get deployments --all-namespaces** | list deployments for | | all namespaces. | | **kubectl create -f [DEPLOYMENT_FILE.yaml]** | create a new resource| | based on the desired | | state in the yaml | | file. | | **kubectl apply -f [DEPLOYMENT_FILE.yaml]** | if the resource | | already exists, | | refresh the resource | | based on the yaml. | | file. |
| **kubectl delete -f [DEPLOYMENT_FILE.yaml]** | remove all resources | | from the yaml file. |
| **kubectl get nodes** | get the nodes of the | | Kubernetes cluster. | | **kubectl delete deployment [DEPLOYMENT_NAME]** | delete the | | deployment with | | [DEPLOYMENT_NAME]. |
| **kubectl delete svc [SERVICE_NAME]** | delete the service | | with [SERVICE_NAME]. |
| **kubectl delete pod [POD_NAME]** | delete the pod with | | [POD_NAME]. |
+------------+-----------------------------------------------------+
使用kubectl在带有 Minikube 的本地机器上部署 Kubernetes
***# create local kubernetes cluster***
minikube startStarting local Kubernetes v1.13.2 cluster...
Starting VM...Getting VM IP address...
Moving files into cluster...
Setting up certs...
Connecting to cluster...
Setting up kubeconfig...
Stopping extra container runtimes...
Machine exists, restarting cluster components...
Verifying kubelet health ...
Verifying apiserver health ....
Kubectl is now configured to use the cluster.
Loading cached images from config file.Everything looks great. Please enjoy minikube!***# navigate to the directory with deployment file***
cd kubernetes-intro/***# create a new resource from yaml file***
kubectl create -f deployment.yamlservice "nginx-server-service" created
deployment.extensions "nginx-server-deployment" created***# launch minikube dashboard***
minikube dashboardVerifying dashboard health ...
Launching proxy ...
Verifying proxy health ...
Opening http://127.0.0.1:54356/api/v1/namespaces/kube-system/services/http:kubernetes-dashboard:/proxy/ in your default browser...
***# list pods***
kubectl get podsNAME READY STATUS RESTARTS AGE
nginx-server-deployment-f878d8679-5ptlc 1/1 Running 0 10m
nginx-server-deployment-f878d8679-6gk26 1/1 Running 0 10m
nginx-server-deployment-f878d8679-9hdhh 1/1 Running 0 10m
nginx-server-deployment-f878d8679-pfm27 1/1 Running 0 10m
nginx-server-deployment-f878d8679-rnmhw 1/1 Running 0 10m***# get ip address of kubernetes cluster***
$ minikube ip192.168.99.102
在由 Kubernetes 编排的 pod 上运行网页
让我们通过运行 192.168.99.102:30001 来访问 Kubernetes 集群中的应用程序。我们使用端口30001,因为我们从集群外部访问应用程序。
删除部署并停止 Minikube
***# delete the deployment***
kubectl delete -f deployment.yamlservice "nginx-server-service" deleted
deployment.extensions "nginx-server-deployment" deleted***# stop minikube***
minikube stopStopping local Kubernetes cluster...
Machine stopped.
在 Google Kubernetes 引擎上部署 Kubernetes
为了从本地 shell 在 GCP 上创建和部署资源，必须安装和配置 Google 命令行 SDK gcloud。如果您的机器不是这种情况，请遵循https://cloud.google.com/sdk/gcloud/中的说明。否则，更简单的选择是使用已经安装了gcloud和kubectl(Kubernetes 命令行界面)的 Google Cloud Shell。
创建 GKE 集群
*# create a GKE cluster*
gcloud container clusters create ekaba-gke-cluster
Kubernetes 集群在 GCP 上创建，有 3 个节点(默认)。
Creating cluster ekaba-gke-cluster in us-central1-a... Cluster is being deployed...done.
Created [https://container.googleapis.com/v1/projects/oceanic-sky-230504/zones/us-central1-a/clusters/ekaba-gke-cluster].
To inspect the contents of your cluster, go to: https://console.cloud.google.com/kubernetes/workload_/gcloud/us-central1-a/ekaba-gke-cluster?project=oceanic-sky-230504
kubeconfig entry generated for ekaba-gke-cluster.
NAME LOCATION MASTER_VERSION MASTER_IP MACHINE_TYPE NODE_VERSION NUM_NODES STATUS
ekaba-gke-cluster us-central1-a 1.11.7-gke.4 35.226.72.40 n1-standard-1 1.11.7-gke.4 3 RUNNING
要了解有关使用 Google Kubernetes 引擎创建集群的更多信息，请访问https://cloud . Google . com/Kubernetes-Engine/docs/how-to/creating-a-cluster。
***# get the nodes of the kubernetes cluster on GKE***
kubectl get nodesNAME STATUS ROLES AGE VERSION
gke-ekaba-gke-cluster-default-pool-e28c64e0-8fk1 Ready <none> 45m v1.11.7-gke.4
gke-ekaba-gke-cluster-default-pool-e28c64e0-fmck Ready <none> 45m v1.11.7-gke.4
gke-ekaba-gke-cluster-default-pool-e28c64e0-zzz1 Ready <none> 45m v1.11.7-gke.4
在 GKE 上部署 Nginx Web 服务器
***# navigate to directory with deployment file***
cd kubernetes-intro/***# create new resource from yaml file***
kubectl create -f deployment.yamlservice "nginx-server-service" created
deployment.extensions "nginx-server-deployment" created
部署详情可在 GCP Kubernetes 发动机控制台上查看:
Kubernetes 引擎控制台上的工作负载
GKE 控制台上的部署详情
列表框
***# list pods***
kubectl get podsNAME READY STATUS RESTARTS AGE
nginx-server-deployment-6d4cf7bb78-4swcb 1/1 Running 0 41m
nginx-server-deployment-6d4cf7bb78-5cdqc 1/1 Running 0 41m
nginx-server-deployment-6d4cf7bb78-bkjrp 1/1 Running 0 41m
nginx-server-deployment-6d4cf7bb78-d8b2l 1/1 Running 0 41m
nginx-server-deployment-6d4cf7bb78-mhpss 1/1 Running 0 41m
获取 GKE 上吊舱部署的外部 IP
***# get kubernetes service***
kubectl get serviceNAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
kubernetes ClusterIP 10.23.240.1 <none> 443/TCP 1h
nginx-server-service LoadBalancer 10.23.248.194 35.188.151.138 8080:30001/TCP 57m
在 GKE 上运行的应用程序
通过运行35.188.151.138:8080来访问部署在 GKE 上的应用程序。
删除在 GKE 的部署
***# delete the deployment***
kubectl delete -f deployment.yamlservice "nginx-server-service" deleted
deployment.extensions "nginx-server-deployment" deleted
删除 GKE 上的 Kubernetes 集群
***# delete the kubernetes cluster***
gcloud container clusters delete ekaba-gke-clusterThe following clusters will be deleted.
- [ekaba-gke-cluster] in [us-central1-a]Do you want to continue (Y/n)? YDeleting cluster ekaba-gke-cluster...done.
Deleted [https://container.googleapis.com/v1/projects/oceanic-sky-230504/zones/us-central1-a/clusters/ekaba-gke-cluster].
库贝弗洛
Kubeflow 是一个平台，旨在增强和简化在 Kubernetes 上部署机器学习工作流的过程。使用 Kubeflow，通过将组件(如培训、服务、监控和记录组件)放入 Kubernetes 集群上的容器中，管理分布式机器学习部署变得更加容易。
Kubeflow 的目标是抽象出管理 Kubernetes 集群的技术细节，以便机器学习从业者可以快速利用 Kubernetes 的能力和在微服务框架内部署产品的好处。在 2017 年底开源之前，Kubeflow 一直是谷歌在 Kubernetes 上实现机器学习管道的内部框架。
使用 Kubeflow
以下是 Kubeflow 上运行的一些组件:
在 GKE 建立一个 Kubernetes 集群
***# create a GKE cluster***
gcloud container clusters create ekaba-gke-clusterCreating cluster ekaba-gke-cluster in us-central1-a... Cluster is being health-checked (master is healthy)...done.
Created [https://container.googleapis.com/v1/projects/oceanic-sky-230504/zones/us-central1-a/clusters/ekaba-gke-cluster].
To inspect the contents of your cluster, go to: https://console.cloud.google.com/kubernetes/workload_/gcloud/us-central1-a/ekaba-gke-cluster?project=oceanic-sky-230504
kubeconfig entry generated for ekaba-gke-cluster.
NAME LOCATION MASTER_VERSION MASTER_IP MACHINE_TYPE NODE_VERSION NUM_NODES STATUS
ekaba-gke-cluster us-central1-a 1.11.7-gke.4 35.193.101.24 n1-standard-1 1.11.7-gke.4 3 RUNNING***# view the nodes of the kubernetes cluster on GKE***
kubectl get nodesNAME STATUS ROLES AGE VERSION
gke-ekaba-gke-cluster-default-pool-0f55a72b-0707 Ready <none> 4m v1.11.7-gke.4
gke-ekaba-gke-cluster-default-pool-0f55a72b-b0xv Ready <none> 4m v1.11.7-gke.4
gke-ekaba-gke-cluster-default-pool-0f55a72b-g4w8 Ready <none> 4m v1.11.7-gke.4
创建 OAuth 客户端 ID 来标识云 IAP
Kubeflow 使用云身份感知代理(Cloud IAP)安全地连接到 Jupyter 和其他正在运行的 web 应用。Kubeflow 使用电子邮件地址进行身份验证。在本节中，我们将创建一个 OAuth 客户端 ID，用于在请求访问用户的电子邮件帐户时识别 Cloud IAP。
- 转到 GCP 控制台中的API&服务- >凭证页面。
- 转到 OAuth 同意屏幕:
- 分配一个应用程序名称，例如 My-Kubeflow-App
- 对于授权域，请使用[您的产品 ID].cloud.goog
- 转到凭据选项卡:
- 单击创建凭据，然后单击 OAuth 客户端 ID。
- 在应用程序类型下，选择 Web 应用程序。
- 选择一个名称来标识 OAuth 客户端 ID。
- 在“授权重定向 URIs”框中，输入以下内容:
https://<deployment_name>.endpoints.<project>.cloud.goog/_gcp_gatekeeper/authenticate
- <deployment_name>必须是库巴流部署的名称。</deployment_name>
- 是 GCP 项目 ID。
- 在这种情况下，它将是:
[https://ekaba-kubeflow-app.endpoints.oceanic-sky-230504.cloud.goog/_gcp_gatekeeper/authenticate](https://ekaba-kubeflow-app.endpoints.oceanic-sky-230504.cloud.goog/_gcp_gatekeeper/authenticate)
- 记下 OAuth 客户端窗口中出现的客户端 ID 和客户端密码。这是启用云 IAP 所必需的。
***# Create environment variables from the OAuth client ID and secret earlier obtained.*** export CLIENT_ID**=**506126439013-drbrj036hihvdolgki6lflovm4bjb6c1.apps.googleusercontent.com
export CLIENT_SECRET**=**bACWJuojIVm7PIMphzTOYz9D
export PROJECT**=**oceanic-sky-230504
下载 kfctl.sh
***# create a folder on the local machine***
mkdir kubeflow***# move to created folder***
cd kubeflow***# save folder path as a variable***
export KUBEFLOW_SRC**=$(**pwd**)*****# download kubeflow `kfctl.sh`***
export KUBEFLOW_TAG**=**v0.4.1curl https://raw.githubusercontent.com/kubeflow/kubeflow/**${**KUBEFLOW_TAG**}**/scripts/download.sh | bash% Total % Received % Xferd Average Speed Time Time Time Current
Dload Upload Total Spent Left Speed
100 800 100 800 0 0 1716 0 --:--:-- --:--:-- --:--:-- 1716
+ '[' '!' -z 0.4.1 ']'
+ KUBEFLOW_TAG=v0.4.1
+ KUBEFLOW_TAG=v0.4.1
++ mktemp -d /tmp/tmp.kubeflow-repo-XXXX
+ TMPDIR=/tmp/tmp.kubeflow-repo-MJcy
+ curl -L -o /tmp/tmp.kubeflow-repo-MJcy/kubeflow.tar.gz https://github.com/kubeflow/kubeflow/archive/v0.4.1.tar.gz
% Total % Received % Xferd Average Speed Time Time Time Current
Dload Upload Total Spent Left Speed
100 125 0 125 0 0 64 0 --:--:-- 0:00:01 --:--:-- 64
100 8099k 0 8099k 0 0 1309k 0 --:--:-- 0:00:06 --:--:-- 2277k
+ tar -xzvf /tmp/tmp.kubeflow-repo-MJcy/kubeflow.tar.gz -C /tmp/tmp.kubeflow-repo-MJcy
...
x kubeflow-0.4.1/tf-controller-examples/tf-cnn/README.md
x kubeflow-0.4.1/tf-controller-examples/tf-cnn/create_job_specs.py
x kubeflow-0.4.1/tf-controller-examples/tf-cnn/launcher.py
++ find /tmp/tmp.kubeflow-repo-MJcy -maxdepth 1 -type d -name 'kubeflow*'
+ KUBEFLOW_SOURCE=/tmp/tmp.kubeflow-repo-MJcy/kubeflow-0.4.1
+ cp -r /tmp/tmp.kubeflow-repo-MJcy/kubeflow-0.4.1/kubeflow ./
+ cp -r /tmp/tmp.kubeflow-repo-MJcy/kubeflow-0.4.1/scripts ./
+ cp -r /tmp/tmp.kubeflow-repo-MJcy/kubeflow-0.4.1/deployment ./***# list directory elements***
ls -ladrwxr-xr-x 6 ekababisong staff 204 17 Mar 04:15 .
drwxr-xr-x 25 ekababisong staff 850 17 Mar 04:09 ..
drwxr-xr-x 4 ekababisong staff 136 17 Mar 04:18 deployment
drwxr-xr-x 36 ekababisong staff 1224 17 Mar 04:14 kubeflow
drwxr-xr-x 16 ekababisong staff 544 17 Mar 04:14 scripts
部署 Kubeflow
***# assign the name for the Kubeflow deployment*
*# The ksonnet app is created in the directory ${KFAPP}/ks_app***
export KFAPP**=**ekaba-kubeflow-app***# run setup script***
**${**KUBEFLOW_SRC**}**/scripts/kfctl.sh init **${**KFAPP**}** --platform gcp --project **${**PROJECT**}*****# navigate to the deployment directory***
cd **${**KFAPP**}***# creates config files defining the various resources for gcp*
**${**KUBEFLOW_SRC**}**/scripts/kfctl.sh generate platform
*# creates or updates gcp resources*
**${**KUBEFLOW_SRC**}**/scripts/kfctl.sh apply platform
*# creates config files defining the various resources for gke*
**${**KUBEFLOW_SRC**}**/scripts/kfctl.sh generate k8s
*# creates or updates gke resources*
**${**KUBEFLOW_SRC**}**/scripts/kfctl.sh apply k8s***# view resources deployed in namespace kubeflow***
kubectl -n kubeflow get all
Kubeflow 可从以下网址获得:https://e kaba-kube flow-app . endpoints . oceanic-sky-230504 . cloud . goog/
**注意:**URI 可能需要 10-15 分钟才能可用。Kubeflow 需要提供一个签名的 SSL 证书并注册一个 DNS 名称。
kube flow 主屏幕
库伯弗洛管道公司
Kubeflow Pipelines 是一个简单的平台，用于在 Kubernetes 上构建和部署容器化的机器学习工作流。Kubeflow 管道使得实现生产级机器学习管道变得容易，而不需要考虑管理 Kubernetes 集群的底层细节。
Kubeflow 管道是 Kubeflow 的核心组件，也是在部署 Kubeflow 时部署的。
Kubeflow 管道的组件
管道描述了机器学习工作流，其中管道的每个组件都是一组自包含的代码，这些代码被打包为 Docker 图像。每个管道都可以单独上传，并在 Kubeflow 管道用户界面(UI)上共享。管道接收运行管道所需的输入(参数)以及每个组件的输入和输出。
Kubeflow 管道平台包括:
- 用于管理和跟踪实验、作业和运行的用户界面(UI)。
- 用于安排多步骤 ML 工作流的引擎。
- 用于定义和操作管道和组件的 SDK。
- 使用 SDK 与系统交互的笔记本电脑。(摘自:库贝弗管道概述)
执行示例管道
- 点击名称**【样本】基本—条件**。
2.点击开始实验。
3.给实验起个名字。
4.给出运行名称。
5.点击运行名称开始运行。
在 Kubeflow 管道上部署端到端机器学习解决方案
Kubeflow 管道组件是管道任务的实现。组件是工作流中的一个步骤。每个任务将一个或多个工件作为输入，并可能产生一个或多个工件作为输出。
每个组件通常包括两个部分:
- 客户端代码:与端点对话以提交作业的代码。比如连接谷歌云机器学习引擎的代码。
- 运行时代码:执行实际工作的代码，通常在集群中运行。例如，为云 MLE 上的训练准备模型的代码。
组件由接口(输入/输出)、实现(Docker 容器映像和命令行参数)和元数据(名称、描述)组成。
简单的端到端解决方案管道概述
在这个简单的例子中，我们将实现一个深度神经回归器网络来预测比特币加密货币的收盘价。机器学习代码本身非常基础，因为它不是本文的重点。这里的目标是在具有 Kubeflow 管道的 Kubernetes 上使用微服务架构来编排机器学习工程解决方案。
管道由以下组件组成:
- 将 Github 上托管的原始数据移动到存储桶中。
- 使用谷歌数据流转换数据集。
- 在云机器学习引擎上进行超参数训练。
- 用优化的超参数训练模型。
- 部署在云 MLE 上服务的模型。
为每个组件创建一个容器图像
首先，我们将把客户机和运行时代码打包成一个 Docker 映像。该映像还包含安全服务帐户密钥，用于针对 GCP 进行身份验证。例如，使用数据流转换数据集的组件在其映像中内置了以下文件:
| _ _ data flow transform
| _ _ _ _ _ _ _ _ Docker file:Docker file 来构建 Docker 映像。
|_____ build.sh:启动容器构建并上传到 Google 容器注册表的脚本。
|_____ dataflow_transform.py:在云数据流上运行 beam 管道的代码。
|_____ service_account.json:在 GCP 上验证容器的安全密钥。
|_____ local_test.sh:本地运行图像管道组件的脚本。
在上传到 Kubeflow 管道之前构建容器
在将管道上传到 Kubeflow 管道之前，请确保构建组件容器，以便将最新版本的代码打包并作为映像上传到容器注册中心。代码提供了一个方便的bash脚本来构建所有容器。
使用 Kubeflow 管道 DSL 语言编译管道
管道代码包含组件如何相互作用的规范。每个组件都有一个输出，作为管道中下一个组件的输入。Kubeflow Pipelines SDK 中的 Kubeflow 管道 DSL 语言dsl-compile用于编译 Python 中的管道代码，以便上传到 Kubeflow 管道。
通过运行以下命令，确保 Kubeflow Pipelines SDK 安装在本地计算机上:
***# install kubeflow pipeline sdk***
pip install https://storage.googleapis.com/ml-pipeline/release/0.1.12/kfp.tar.gz --upgrade*# verify the install*
which dsl-compile
通过运行以下命令编译管道:
***# compile the pipeline***
python3 **[**path/to/python/file.py] **[**path/to/output/tar.gz]
对于示例代码，我们使用了:
python3 crypto_pipeline.py crypto_pipeline.tar.gz
将管道上传并执行到 Kubeflow 管道
- 将管道上传到 Kubeflow 管道。
2.单击管道以查看流量的静态图。
3.创建一个Experiment和Run来执行流水线。
4.完成管道运行。
完整的数据流管道
云 MLE 上部署的模型
删除 Kubeflow
***# navigate to kubeflow app***
cd **${**KFAPP**}*****# run script to delete the deployment***
**${**KUBEFLOW_SRC**}**/scripts/kfctl.sh delete all
删除 Kubernetes 集群
***# delete the kubernetes cluster***
gcloud container clusters delete ekaba-gke-cluster
参考
以下资源有助于创建和部署 Kubeflow 管道。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
