情绪和影响者
网络分析与情感分析相结合
几年前，我们开始了一场关于最大声的顾客是否真的像每个人——包括他们自己——认为的那样重要的辩论！客户服务部通常对最大声的抱怨者反应更快。这样方便吗？如何识别那些值得投入时间的抱怨者？
通过论坛帖子上的情绪分析,可以很容易地识别开心和不开心的用户。每个用户的影响程度也可以通过影响得分来衡量。有许多可用的影响分数。一个被广泛采用的是中心性指数。这个用例的想法是将情绪测量与影响分数相结合，并以这种方式识别那些具有高度影响的不满的客户/用户。然后，支持时间和资源应该重新分配给最有影响力和最不满意的客户或用户。
数据集
最初的用例指的是新产品的发布，旨在收集 beta 用户的意见。由于公司的隐私政策，不可能共享原始数据集，我们用一个公开的类似数据集来代替它:Slashdot 新闻论坛。
斜线圆点(有时缩写为“/”)是一个社会新闻网站，创办于 1997 年，面向科技。用户可以发布不同主题的新闻和故事，并接收其他用户的在线评论。
Slashdot 数据集收集了许多子论坛的帖子和评论，如科幻、Linux、天文学等。大多数用户使用他们的用户名发帖或评论，而一些用户匿名参与。最大的分论坛围绕政治展开，包含来自总共约 24，000 名用户的约 140，000 条评论和 496 篇文章。出于本使用案例的目的，我们重点关注“政治”分论坛。
Slashdot 数据集中的用户不完全是客户。然而，当谈论政治时，我们可以将政治话题视为产品，并像对待产品一样衡量用户的反应。
每个新帖子都被分配了一个唯一的线程 ID。标题、子域、用户、日期、主题和正文都引用这个线程 ID。为每个带有评论标题、用户、日期和正文的评论创建一个新的数据行，并附加来自种子帖子的主题 ID、帖子标题、帖子用户、帖子日期和帖子正文。在图 1 中，您可以在左边看到种子帖子数据，在右边看到相应评论的数据。请注意，多个评论可能会引用同一个种子帖子。
Figure 1. SlashDot Dataset. Data from seed post on the left; data from related comments on the right.
工作流程
在分析中，我们考虑了所有的非匿名用户。因此，第一步是删除用户名为“匿名”、为空、过长或没有文章 ID 的所有数据行。这发生在“预处理”元节点中。
Figure 2. The upper part of the final workflow, referred to as “Network creation and analysis,” calculates influence scores. The lower part, labeled “Text processing and sentiment analysis”, measures the sentiment of each forum user. This workflow is available on KNIME EXAMPLES Server under: 08_Other_Analytics_Types/04_Social_Media/02_NetworkAnalytics_meets_TextProcessing.
影响分数
我们希望通过调查用户之间的联系，找出谁是最有影响力的用户。因此，我们的目标是构建一个网络对象来表示用户交互。
第一步是准备边表作为网络的基础。边缘表有一个源列(文章的作者)和一个目标列(参考文章的作者)。边缘表是由图 2 所示的最终工作流的上部分支中的“Create edge table”元节点构建的。在这里，一个左外部连接将所有文章作者(源)和所有参考作者(目标)放在一起，如果有的话。GroupBy 节点统计从源到目标的每个连接的出现次数。过滤掉所有自动连接，即用户自己回答。
边缘表现在准备好被转换成一个网络对象。对象插入器节点将源用户和目标用户转换为节点，并通过一条边将它们连接起来，连接出现的次数作为值。
之后，名为“提取最大组件”的元节点将网络拆分为所有相连的组件。子网络然后基于它们的边和节点的总数被分类，并且只有最大的子网络被保留用于进一步的分析。最后，第二网络分析器节点计算中心和权威得分。
网络分析器节点为社交媒体活动提供了一个很好的摘要。它在节点和边缘级别计算网络图上不同统计数据的数量。这种统计测量试图通过每个节点和边的连接数、它们的权重、它们的邻居、到它们邻居的距离以及类似的其他参数来建立每个节点和边的重要性。其中两个重要指标是中心和权威得分。
如https://NLP . Stanford . edu/IR-book/html/html edition/hubs-and-authorities-1 . html中所述，hubs 和 authority 的概念植根于网页。有两种主要的网页作为广泛主题搜索的结果:
- 关于这个话题的权威信息来源(当局)
- 手工编制的链接列表，链接到关于该主题的权威网页。
中心本身并不是特定主题信息的权威来源，而是将您导向更权威的页面。中心/权威得分计算依赖于中心页面来发现权威页面。
为了计算中心和权限分数，网络分析器节点在 JUNG (Java 通用网络/图)框架中实现 HITS 算法。
情感分析
现在我们想测量情绪，即根据积极和消极而不是权威来量化每个论坛用户。
图 2 中工作流的下部分支从每个论坛用户写的帖子或评论中提取文档列表。同时根据 MPQA 主观性词典从英语词典中导入两个词表:负面词和正面词。所有文档中的单词都被两个字典标记器节点标记为阳性或阴性，这取决于它们是否匹配这两个列表中的任何单词。未加标签的单词被认为是中性的。
每个正单词被赋予+1 值，每个负单词被赋予-1 值，每个中性单词被赋予 0 值。通过对每个用户写的所有文档的所有单词值求和，我们计算出用户情感得分。
请注意，这里使用绝对词频计算用户情感得分，而不考虑使用的字数。对于具有较长文档的语料库，即具有更大的字数差异的语料库，相对频率可能更合适。
最后，情绪得分在(平均值+标准差)以上的论坛用户被认为是积极的；情绪得分低于(平均值—标准差)的论坛用户被认为是负面的；介于两者之间的所有其他用户都被认为是中立的。积极用户用绿色表示，消极用户用红色表示，中性用户用灰色表示。
把所有的放在一起
将所有这些放在一起，一个 Joiner 节点将 authority 和 hub 分数与作者的情感分数连接起来。
一个散点图(Javascript)节点位于包装的元节点“散点图上的分数和情绪”内，它通过 y 轴上的中心分数、x 轴上的权威分数以及作为颜色的情绪分数来绘制论坛用户。
请注意，用红色表示的最大声的抱怨者实际上没有什么权威，因此不能被认为是有影响力的人。因此，这个情节似乎违背了你应该倾听和纵容最具攻击性的抱怨者的普遍信念。还要注意，最权威的用户实际上是中立的。这种中立性很可能是其他用户信任他们的原因之一。
散点图(Javascript)节点生成的散点图视图是交互式的。通过单击视图顶部的“选择模式”按钮，可以通过单击选择散点图上的单个点，或者通过在点周围画一个矩形来选择一组点。
Figure 3. Authors as points on a scatter plot with authority score on the x-axis and hub score on the y-axis. Authors with a positive sentiment score, i.e. sentiment score > (average + std dev), are color coded green. Authors with a negative sentiment score, i.e. sentiment score < (average — std dev), are color coded red. Authors with sentiment score in between are labelled as neutral and depicted in gray. In the upper right corner, there are the buttons for zooming and selection. The circled button enables point/author selection. The bigger point in the plot is the point that has been selected by single-click.
最终的工作流如图 2 所示，位于 KNIME EXAMPLES 服务器上的:08 _ Other _ Analytics _ Types/04 _ Social _ Media/02 _ network Analytics _ meets _ text processing
那么，我们做得怎么样？
论坛中的帖子和联系可以通过将它们简化为数字来进行分析，比如情感指标或影响力得分。在这篇博文中，它们一方面通过文本处理被简化为情感分数，另一方面通过网络图分析被简化为权威/中心分数。
这两种表示都产生有价值的信息。然而，当试图隔离最积极和最权威的用户以获得奖励以及最消极和最权威的批评者以获得损害控制时，这两者的结合被证明是无价的帮助。
承认
这篇博客文章是与菲尔·温特斯、基利安·泰尔和托拜厄斯·科特合作的一个项目的总结。更多详细信息，请参见 KNIME 白皮书“从社交媒体数据中创建可用的客户情报:网络分析与文本挖掘的结合”。
可分离卷积——用很小的精度换取巨大的计算增益
通常在卷积中，我们使用 2D 或 3D 内核滤波器，我们希望每个滤波器通过分别在所有 2 维或 3 维中卷积来提取某种特征。特别是在 2D 的情况下，我们试图在初始层提取简单的特征，在后面的层提取更复杂的特征。然而，如果我们愿意，我们可以将一个 2D 核分解成两个 1D 核，如下所示。
Separability Example
现在，我们可以把这两个 1D 核一个接一个地应用在一个图像上，而不是应用原始的 2D 核。通过这样做，我们实际上减少了用于卷积的参数数量，现在可以训练的参数更少了。此外，我们使用这些可分离的内核过滤器的顺序通常并不重要。客观地说，一个 5x5 内核过滤器有 25 个参数，而两个内核，一个 1x5 内核和一个 5x1 内核只有 10 个参数。
当然，参数的减少意味着我们可能不得不在我们学习的特征的复杂性上妥协。但是，如果你看下面的图片，你可以看到两个 1D 内核可以很容易地学习简单的功能，一个 2D 内核试图学习。并且，如果你试着想象这两个 1D 内核(如下所示)，你可以看到它们应该能够以相当的准确度学习任何接近复杂的特征。在该图中，我们在左侧可视化了 1D 核“horz[c]”和“vert[r]”的权重，而右侧的图像显示了一个接一个地应用两个 1D 核所获得的最终权重的 3d 图。
Visualizing Separable Filters
这些可分离的卷积层通常可以非常有效和毫不费力地学习图像中简单到接近复杂的特征。因此，从直觉上来说，与尝试捕获复杂得多的要素的最终图层相比，在尝试捕获简单要素的初始图层中更多地使用这些可分离图层是有意义的。
我们也可以把这看作是调整我们网络的一种方式，其中我们试图只保留网络中真正独立的参数。通过这种方式，我们可以利用在每一层学习到的强大特征集来提高模型的计算效率。此外，通过尝试卷积和学习每个维度中的特征，可分离卷积尝试学习每个维度中的更多抽象特征。在某种程度上，它更侧重于在独立的个体维度中找到好的特征，然后最终将它们组合在一起，以最少的参数提取复杂的特征。
深度方向卷积是可分卷积的特例。在深度方向卷积中，我们首先使用 2D 滤波器(具有第三维的大小= 1)在 X 和 Y 维度上进行空间卷积，然后使用 1×1 滤波器在 Z 维度上进行信道方向卷积。下图显示了深度方向卷积在异常网络中的应用。
Xception Network
你可以在标题为“可分卷积基础介绍”的文章中读到更多关于可分卷积的内容。如果你想要更多关于可分卷积的形式证明，你也可以参考这里的更多关于 2D 可分卷积的数学证明，并有例子支持。
将医学艺术与人工智能分开
人工智能需要数据。理想情况下，数据应该是干净、可信的，最重要的是准确的。不幸的是，医学数据远非如此。事实上，医学数据有时远非干净，而是非常肮脏。
考虑一下简单的胸部 x 光片，这是一种很好的老式的胸部前后 x 光片。医学诊断军械库中历史最悠久的放射技术之一，在世界范围内被数十亿人使用。事实上，数量如此之多，以至于放射科医生很难跟上庞大的数量，有时忘记阅读其中的 23，000 份。哎呀。
当然，如此受欢迎、屡试不爽的医学测试应该为训练放射学人工智能提供大量数据吧？显然有足够多的数据来进行一次像样的尝试，而且这项技术是如此的标准化和健壮，以至于肯定它只是在呼唤自动化？
A random anonymised chest X-ray taken from the NIH dataset. Take a look, and make a note of what you think you can see… there’s a test later.
不幸的是，有一个小而不方便的问题——人类。
人类放射科医生在解读胸部 x 光片和/或同意他们可以看到的发现方面非常糟糕，以至于数字图像附带的“报告”通常要么完全错误，要么部分错误，要么遗漏了信息。这不是人类的错…他们已经尽力了！当您的工作是在大约 30 秒内将数千个黑白像素处理成几个词的自然语言文本时，信息丢失和出现错误是可以理解的。撰写放射学报告是数据压缩的一种极端形式—您将大约 2 兆字节的数据转换为几个字节，实际上是以巨大的压缩比执行有损压缩。这就像试图通过一个 16K 的调制解调器播放一部电影，让某人用莫尔斯电码拍出正在发生的事情。更不用说这一切的主观性了。
不信我说放射科医生不好？让我们看看文献…
Swingler 等人表明，放射科医生在临床怀疑患有结核病的儿童 x 线片上发现淋巴结病变的总体敏感性为 67%，特异性为 59%。(这意味着他们只有大约 2/3 的时间发现某些东西，即使他们知道有问题，但只有一半以上的时间正确地找到了淋巴结。)
Taghizadieh 等人表明，放射科医生发现胸腔积液的灵敏度为 67%，特异性为 78%(肺部周围的液体——在 x 光片上呈白色固体，你会认为很难错过……)。
奎克尔等人发现有五分之一的病例漏掉了肺癌，尽管回想起来病变是完全可见的！在将近一半的病例中，癌症在随后的 x 光检查中至少两次被遗漏*。*
令人欣慰的是，研究确实表明医学训练使人比一般学生或外行人略胜一筹…
萨提亚等人显示，35%的非放射科初级医生无法区分心力衰竭和肺炎，18%无法诊断正常的 CXR，17%无法发现 3 厘米的右心尖肿块，55%无法识别慢性肺气肿的特征。高级临床医生在所有类别中表现更好。
起初，这可能看起来相当惊人！你可能会期望现代医学比在最多 2/3 的时间里把事情做对要好一点。嗯，实际上比那更糟…
放射科医生不仅不擅长写准确的 x 光胸透报告，而且在同样的 x 光胸透下，他们会写完全不同的报告。观察者之间的一致程度如此之低，真是可笑——一项研究显示, kappa 值为 0.2 (0 是糟糕的，1 是完美的)。另一项研究只是放弃了，并得出结论说“在肺炎患者中，对胸部 x 光的解释，尤其是最小的细节，完全取决于读者。”我想，主观性就是主观性。
前几天，我上了 Twitter 进行了一个简单的(完全不科学的)实验来证明这一点。
我让放射科医生看一张胸部 x 光片(取自匿名的 NIH 数据集)，并在推特上发布他们的报告作为回应。我提供了一个简短的捏造的病史，不针对任何特定的疾病(54 岁，不吸烟，两周气短，门诊病人)，以免他们对任何发现产生偏见。
大家表现如何？以下是一些回复示例:
就个人而言，人们的表现符合预期。他们做了一些正确的和一些可能不正确的观察，一些建议进一步用 ct 成像。但是人们同意吗？没有两个建议是完全相同的。有些很接近，但没有两份报告提到完全相同的发现或得出完全相同的结论。报告的发现范围从感染、腺病、高血压、肺气肿、癌症到肺结核。
然而，出现了一个总体趋势。如果你浏览所有的回复，就会发现某些发现比其他发现更容易被发现，包括左心尖结节、过度膨胀的肺和难以分辨的左心边界。我不知道这个胸部 x 光片的正确“读数”是什么(我甚至自己也做了一次，并给其他人写了一份不同的报告)，但我倾向于同意这三个主要发现。来自 NIH 数据集的标签是从原始报告中挖掘的“结节”和“肺炎”。可悲的是，没有后续的 CT 或进一步的临床信息，所以我们永远不会知道真相。
(顺便说一句，这个帖子有了不同的转变，来自其他行业的医生也加入进来，提供了他们自己相当幽默的观点。如果你想笑，我推荐你读一读！是的，放射科医生作为一个团队做得更好。唷！)
我发现令人着迷的是，通过简单地改变一些周围的元数据，报告是如何发生变化的。例如，如果我有一天抽 40 支烟的历史，那么这些报告会更关注肺气肿和肺癌，而不是可能的肺炎吗？如果我说病人是 24 岁而不是 54 岁呢？如果我说他们有α-1 抗胰蛋白酶缺乏症呢？如果这张胸透照片来自撒哈拉以南的非洲会怎样？那么肺结核会是最常见的报告发现吗？
对图像的解释受到各种外部因素的影响，包括患者的人口统计、历史和地理。对于更复杂的成像模式(如 MRI)或操作者依赖的模式(如超声),问题甚至更严重，其中观察者误差甚至更高。
为什么所有这些都很重要？如果胸透报告不太准确怎么办？图像还在，所以没有数据真正丢失，是吗？
当你开始使用书面报告来训练放射学人工智能学习如何解释图像时，问题很快变得明显。斯坦福大学的机器学习团队已经完全做到了这一点，使用了 108948 张从 NIH 免费获得的带标签的胸部 x 光片。他们自豪地宣布他们的结果为在发现肺炎方面胜过放射科医生。现在，我完全支持前沿研究，我认为正是因为这个原因，像这样的数据集被公布于众是很好的…但我们必须非常小心我们如何解释基于这些数据的任何算法的结果，因为，正如我已经表明的那样，这些数据是不干净的。(我不是唯一的一个——请阅读卢克·奥克登-雷纳博士的博客详细检查数据集。)
如果你给人工智能的数据质量和人类的一样低，怎么可能训练出比人类更好的人工智能呢？我觉得不是…
它归结为一个简单的事实——胸部 x 光报告从未打算用于开发放射学人工智能。它们只被认为是一种观点，一种解释，一种创造性的有教养的猜测。阅读胸透与其说是一门科学，不如说是一门艺术。胸透既不是最终的诊断测试，也不是第一次，它只是达到临床终点的一系列诊断步骤中的一部分。胸部 x 光片本身并不能代替地面真相。事实上，它唯一的真正目的是充当一种“分流”的形式——普遍的临床问题是“这里有什么我需要担心的吗？”。这就是 x 光胸透的价值所在——回答“我应该担心吗？”，而不是“诊断是什么？”。也许斯坦福大学的研究人员一直试图回答一个错误的问题…
如果我们要开发一种能够真正“阅读”胸部 x 光片的人工智能，那么未来的研究应该集中在三个方面:
- 周围的元数据和找到一个地面真相，而不是依赖于一个人衍生的报告，没有产生数据挖掘的想法。理想的数据集应该包括所有患者的详细信息、流行病学、病史、血液测试、后续 CT 结果、活检结果、遗传学等。可悲的是，这种级别的验证匿名数据并不存在，至少不是机器阅读所需的格式。因此，基础设施应该投入到整理和验证这些元数据中，最少，最好是大规模的。
- 数据集的细致标记。我的意思是，为了提供机器学习就绪的数据，使用经过专门培训的领域专家，煞费苦心地彻底注释图像。专家的一致意见，以及准确的元数据，将明显优于使用随机的单一读者报告。谢天谢地，这是一些更有声誉的放射学人工智能公司正在做的事情。是的，它既昂贵又费时，但如果要达到最终目标，这是必要的。这就是我称之为的数据提炼过程，具体来说就是从 B 级到 A 级的阶段。跳过这一步，你将永远无法击败人类的表现。
- 标准化放射学语言。我的简单 Twitter 实验得到的许多回复使用不同的语言来描述大致相似的事情。例如,“实变”在很大程度上可以和“肺炎”互换。或者是？我们如何定义这些术语，什么时候应该用一个来代替另一个？人类语言存在巨大的不确定性，这延伸到了放射性语言。(放射科医生在医学界以其实践不确定性的技能而闻名，被称为“对冲”)。除非这种不确定性被消除，并且每一个可能的用例的术语都被认可，否则很难看到我们如何能走向数字天堂。正在努力引入一种标准化的语言( RadLex )，然而执业放射科医生的接受速度很慢，而且相当零散。我不知道这个问题的答案是什么，但我知道问题是语言！
在我们完成所有这些之前，人工智能在胸部放射摄影中唯一真正有用的价值充其量是提供分类支持——告诉我们什么是正常的，什么是不正常的，并强调哪里可能不正常。只是不要试图声称人工智能可以明确地告诉我们异常是什么，因为它不能比我们做得更准确，因为数据是脏的，因为我们这样做了。
现在，让我们把模糊的思维和创造性的解释留给我们人类，把医学的“艺术”从“人工智能”中分离出来，并开始专注于产生大量干净的数据。
如果你和我一样对人工智能在放射学和医学成像领域的未来感到兴奋，并想讨论这些想法，请联系我们。我在推特@drhughharvey
如果你喜欢这篇文章，点击推荐并分享它会很有帮助。
关于作者:
哈维博士是一名委员会认证的放射科医生和临床学者，在英国国民医疗服务体系和欧洲领先的癌症研究机构 ICR 接受过培训，在那里他两次获得年度科学作家奖。他曾在 Babylon Health 工作，领导监管事务团队，在人工智能支持的分诊服务中获得了世界第一的 CE 标记，现在是顾问放射科医生，皇家放射学家学会信息学委员会成员，以及人工智能初创公司的顾问，包括 Kheiron Medical。
区分牛排和咝咝声——在人工智能/人工智能领域，什么是“真实”的，什么是炒作
人工智能(AI)和机器学习(ML)的世界近年来蓬勃发展，为寻求改善消费者体验的公司拓展了商业解决方案。随着深度神经网络和情感识别的进步，行业正在改善我们交流、创建内容和分析数据的方式。WorkFusion 已经在行业中取得了长足的进步，提高了人工智能在商业世界中的极限。
然而，人工智能和人工智能的其他领域最近受到了大量的炒作，尽管它们仍处于早期阶段。虽然使用生成性对抗网络(GAN)改善网络安全的前景已经显示出一些希望，但该技术仍需数年才能开花结果。
这里有两个人工智能领域被夸大了，还有两个领域是真正的问题。
1)甘在信息安全
信息安全专家一直在探索 GAN 如何提高我们的在线安全，并取得了一些令人鼓舞的成果。新泽西斯蒂文斯理工学院和纽约理工学院的研究人员已经开发出使用 GANs 猜测密码的方法。
该小组开发了一个实验，通过其名为“PassGan”的密码猜测技术来查看泄露密码的数据，并发现该软件能够从这些帐户中猜出 47%的密码，这一比例高于 HashCat 和 John the Ripper 等竞争算法。这一发现是 GANs 的核心，GANs 本质上是一种神经网络，可以模拟任何数据分布，并提供与数据对应的输出。
来自纽约理工学院的 Paolo Gasti 将这项技术比作素描艺术家和试图揭开嫌疑人身份的目击者。从本质上来说，GANs 可以通过目击者的反馈不断完善嫌疑人的形象，理论上输出一个几乎相同的嫌疑人形象。
然而，康奈尔大学的一项研究发现，这些“机器人艺术家”仍然需要大量的微调，才能在图像、音乐、语音和散文的开发和分析中得到更广泛的应用。该小组发现，在开发这些算法的过程中缺乏系统和客观的评估指标，需要做更多的工作，以便以可承受的价格提供一致的数据输出。
2。更好地理解自然语言的细微差别
当谈到自动语音系统和其他接受语音命令的计算机程序时，这些软件的设计仍然存在一个缺陷，使得这些算法很难准确理解这个人在说什么。尽管如此，开发人员已经在这一领域取得了一些进展，深度学习神经网络可以更准确地区分不同的语音和口音。
在未来的一年里，更多的企业将扩展他们的客户服务聊天机器人和其他理解自然语言命令的商业应用程序。这些机器人在理解人类语言方面也变得更加细致入微，并以更加连贯和全面的方式回应他们的查询，减少了消费者与这些机器人互动的时间和精力。
这一举措进一步代表了机器人流程自动化(RPA)在人工智能中的越来越多的使用及其推动行业前进的能力，正如 WorkFusion 必须提供的服务的情况一样。
3。药物发现中的人工智能
阿斯利康的研究人员写了一篇论文，讨论了通过使用递归神经网络和强化学习，使用人工智能来生成新分子。虽然该论文通过使用直方图、小提琴图和 t-SNE 图包含了数量惊人的可视化数据，但在其报告中有一个明显的遗漏。
该公司的所有测量都是通过比较人工智能生成的分子和自然分子来进行的，但他们未能测量人工智能生成的分子之间的距离。哈佛大学的一项研究也存在同样的缺乏辨别能力的问题，因为人工智能生成的分子并不相互比较。
这一遗漏意味着 AI 在生成新颖分子方面的作用还有很长的路要走。
4。解决精神健康问题的聊天机器人
虽然这个想法看起来有些牵强，但你可能很快就会有一个机器人顾问。人工智能在开发聊天机器人方面取得了一些进展，这些机器人可以识别一个人何时变得激动、沮丧或愤怒，并做出相应的调整。这项技术可以帮助提高客户服务能力和其他商业解决方案。
它还可能对改变精神健康治疗有很大帮助，因为这些顾问机器人不会有情绪偏见，同时还能回忆起你与他们互动的每个细节。一个名为 Karim 的心理治疗聊天机器人已经开始发挥作用，治疗患有 PTSD 和其他疾病的患者。这项技术也降低了精神健康治疗的成本。
底线…
人工智能和人工智能技术在过去几年里取得了长足的进步，将传统的商业实践转变为能够简化工作流程、提高公司投资回报率和节省管理费用的先进解决方案。尽管像信息安全(infosec)的甘(GAN)这样的技术已经显示出作为机器人艺术家的前景，但它们仍有很长的路要走。
在药物发现中使用人工智能是同一条船上的，产生了一些令人鼓舞的结果，但距离在医疗保健行业广泛采用还有几年时间。与此同时，聊天机器人和语音助手在区分语音命令的声音细微差别方面变得越来越有能力，同时还可以为客户和精神健康患者提供虚拟援助。
这是一个激动人心的时刻，因为这个行业正在不断重新定义我们的工作方式、沟通方式以及为各种规模的公司开发智能商业解决方案。
丝芙兰和数据科学—第二部分
继续我之前关于 Sephora.com 产品和客户可视化的博文，在这篇博文中，我将分享我的项目中的一些实验和结果。如果你喜欢在早期的博客上阅读更多内容，它突出了我为这个项目所做的可视化，其中包括各种客户概况的箱线图，以及产品的价格和评级分布。
对于我在熨斗学校的顶点项目，我决定把我对美丽世界的迷恋和…
medium.com](https://medium.com/datadriveninvestor/data-visualization-of-sephora-b2cc91b19b35)
对于我的项目的机器学习部分，我想知道如果给定一些关于产品的特征，如客户资料或产品信息，是否会有可以从电子零售商的数千个数据点中辨别出的模式。我的第一个目标是预测评论者对某个产品的推荐百分比的回归，我的第二个目标是找出某个产品是高于还是低于平均评级的分类。
起初，我想看看价格本身是否会成为决定一个产品将获得多少推荐的重要因素。直觉来自一个简单的相关矩阵，它表明价格对产品的推荐数量有轻微的负面影响。
feature correlation matrix
然而，价格本身并不构成一个强大的功能。一个简单的价格回归产生的预测比随机猜测更糟糕。加入了额外的特征，如用户资料信息和价格，该模型成为预测推荐计数的更有效的模型。使用梯度推进回归器，该模型能够对推荐产品的用户百分比做出相对准确的预测。这些模型的特征是客户概要信息，而这个模型最强的特征是价格。
决定推荐百分比回归的最强特征是价格，然而，用户简档特征，如黑发头发评论者的数量，也对回归预测有很大影响。与随机猜测相比，训练和测试分数的均方误差也表现得非常有效。随机猜测预测正确的基线为 2.6%，然而，模型预测作为测试分数校正了 55.35%。
梯度推进是另一种集成方法。该算法利用弱预测器的集成，也称为简单决策树，以类似于其他 boosting 集成方法的分阶段方式，并通过允许优化任意可微分损失函数来概括它们。简单来说，它以迭代的方式将一群弱学习者或树组合成一个强学习者。迭代阶段的目标是最小化均方误差。因此，在学习的每个阶段，模型都会从早期阶段的错误中学习，并变得越来越适合所提供的样本。像许多集成方法一样，该算法也可能过拟合，但是，因为它依靠弱学习器来优化预测，所以它能够最小化对所提供的特定样本的过拟合。
你可以在我的 Github 上阅读更多关于我的项目和代码的信息。我的下一篇博客将会更深入地介绍我的项目的分类部分，在这个部分中，我使用了产品描述和成分的文本来预测一个产品的评级性能是高于平均水平，还是低于平均水平。
伯克利 RISECamp:大规模部署深度分布式人工智能
2017 年 9 月 7 日和 8 日标志着加州大学伯克利分校有史以来第一次 RISECamp。RISECamp 是一个为期两天的训练营，重点是分享来自 RISELab 的工作。缩写 RISE 在实验室的网站上有解释 :
安全执行的实时智能
RISELab 和著名的 amp lab(Apache Spark 的诞生地)之间的一个巨大差异是，重点从批处理转移到大规模实时决策。这种转变标志着学术界和工业界如何接近最先进的机器学习系统的趋势。虽然批处理适用于各种各样的问题，但实时决策系统能够在新的观察结果流入系统时进行即时学习。这些类型的系统也向真正的人工智能系统迈进了一步，而不是应用根据新观察结果离线训练的模型。
除了专注于构建能够做出实时决策的系统(利用强化学习)，该营地还解决了许多试图大规模集成高级人工智能系统的组织所面临的其他挑战。这些挑战包括跨机器集群轻松分发代码、管理数据沿袭和治理、提供大规模预测，以及在构建依赖于敏感数据的高级系统时所需的固有安全性。
营地分为五个主要部分，分别应对这些挑战。在这篇文章中，我将总结这些章节的内容，并解释在夏令营期间在 RISELab 中构建的工具。
涵盖的主题
1.强化学习
2。预测发球:按比例计分
3。易开发性:让 ML 对非 CS 来说变得容易
4。在上下文中使用数据
5。安全:物联网授权——安全
RISECamp 堆栈
如果你做过任何类型的机器学习工作，那么这些话题应该会引起你的共鸣。来自学术界和工业界的一些最大的开源项目正在解决这些问题。虽然许多现有技术试图解决这些问题，但 RISELab 开发了一系列技术，可以一起使用来创建部署人工智能系统的端到端解决方案。
RISECamp 堆栈:
- Ray :用现有代码扩展 RL 和 ML 算法进行分发
- 削波器:预测发球；支持多种框架。水平可伸缩。实时决策的在线评分。
- PyWren :无服务器架构；python api 无需管理集群
- 地面:数据上下文服务
- 浪潮:使用区块链的去中心化授权，聚焦物联网设备
强化学习
在更详细地讨论这些组件之前，我将提供一个关于强化学习的简短背景，以及它与更多监督和非监督学习方法的比较。
监督学习
这可以说是最流行的机器学习形式，因此它提供了一个很好的比较基础。监督学习用于解决现有数据中已知一些基本事实的问题。用于这类问题的数据将具有某种可被识别为“目标”的属性。对于一个老生常谈的经典例子，为了让监督学习系统预测贷款申请人是否应该获得贷款，历史数据需要一个字段来指示借款人是否偿还了贷款或违约。我们可以将此转化为一个二元分类问题，根据历史数据和“目标”标签，我们预测新的申请人是否会偿还贷款或违约。监督学习通常分为两大类——“分类”和“回归”。分类是当预测的目标是离散值(如偿还贷款或违约)时使用的术语。另一方面，回归问题试图预测一个连续值的目标(例如，预测房屋的价格)。
无监督学习
与监督学习相比，非监督学习没有基础事实。这意味着对于所有的历史数据，没有与手头问题相关的可用标签。无监督学习的一个主要例子是一种叫做聚类的技术。聚类的工作原理是获取数据并将数据分组/聚类/分段成组，这些组通过适合数据集的聚类算法计算为相似的组。这方面的一个具体例子是获取企业客户的所有历史数据，并根据他们行为的某些方面将他们分组。
强化学习
虽然强化学习(RL)是机器学习中一种独特的第三种方法，但它更接近于有监督的学习，而不是无监督的学习。尽管可能相似，但 RL 侧重于顺序决策，不像传统的监督学习那样针对单个时间点做出决策。一个常见的 RL 应用是机器人，其中代理与其环境进行交互，并需要实时做出决策。许多用于重复任务(例如在制造过程中)的机器人不需要强化学习，因为它们可以被显式编程来处理它们的任务，因为它们工作的环境极其有限。当机器人(在 RL 术语中:agent)具有变化的环境或需要在没有明确编程的情况下对任务做出决策时，强化学习在机器人学中大放异彩。为了将这种类型的用例更正式地构建为强化学习问题，我们需要定义一些核心概念。
- 代理人:要么是一个模拟的演员，比如电子游戏中的对手，要么是一个物理设备，比如机器人或自动驾驶汽车
- 状态:对代理在任意时间点所处环境的描述。这种描述取决于系统中提供给代理的输入。
- 动作:在评估状态后，动作就是代理决定要做的事情。基于代理能够控制的内容来定义操作的范围。在自动驾驶汽车的例子中，这可以是加速度的量和车轮应该转动的程度
- 奖励:RL 问题的这个组成部分是它与监督学习更紧密联系的部分。然后，根据代理采取的行动将奖励输入系统。回到自动驾驶汽车，奖励可以基于安全、平稳驾驶，或者在合理的时间内到达目的地(我们希望三者都达到)。
- 环境:这是代理运行的世界。对于视频游戏中的模拟代理，这由游戏中强加的约束组成，这些约束规定哪些动作是可能的。在自动驾驶汽车的例子中，这是真实的世界，其中环境是汽车将要行驶的街道。
RL in action
有人可能会说，既然奖励是已知的，我们就有了基础事实，强化学习问题可以用监督学习技术来处理。虽然监督学习可以取得一些成功，但它在用新的训练数据实时更新模型方面存在不足。
持续学习是机器学习的另一个子集，它在观察值被错误分类时更新模型；它会随着时间的推移更新模型以提高性能。持续学习在决策方面也有不足之处，因为有时在做出许多其他决策之前，一个分数不能被理解为成功或失败。这方面的一个例子是一个代理人在玩国际象棋(或围棋)游戏，在知道最终标签(比赛的输赢)之前必须做出许多决定。解决符合这一模型的问题的最佳方法是强化学习，因为它调整所有决策的概率，而不是单个决策的概率。
光线
Ray 使得在一个机器集群上分发 Python 函数变得非常容易。这是通过使用 Ray Python 包来修饰函数或类，允许它们使用非常简单的语法并行执行来实现的。
来自 Ray 教程的一个例子展示了如何将一个现有的 Python 函数转换成一个在集群上并行运行的函数:
# A regular Python function.def regular_function():
return 1# A Ray remote function.
[@ray](http://twitter.com/ray).remote
def remote_function():
return 1
“remote_function()”前的“ @ray .remote”装饰符使其能够以允许并行处理的特殊方式被调用。调用此函数以并行方式运行使用以下语法:
for _ in range(4):
remote_function.remote()
就是这样！通过在函数名后调用`. remote()'，函数将由范围(或列表)中的每一项并行执行，而不是顺序执行。这是一个没有参数的非常简单的函数，但是如果需要任何参数，它们会在“remote()”中传递，就像在不使用 Ray 的情况下调用“remote_function()”一样。
这涵盖了如何在集群中的核心或节点之间分配函数，使用 Ray 也可以很容易地从这个函数中获得返回值。以下代码片段也来自 Ray 教程，显示了传统函数返回和 Ray 远程函数返回的比较:
>>> regular_function()
1>>> remote_function.remote()
ObjectID(1c80d6937802cd7786ad25e50caf2f023c95e350)>>> ray.get(remote_function.remote())
1
这个简单的例子展示了一个远程函数返回一个对象(Python 的未来)。为了将其转换为实际值，对返回的对象使用简单的“ray.get()”调用来获得实际值。
这只是触及了 Ray 提供的东西的表面；但是它应该会引发一些关于这个库可以处理的潜在用例的想法。在 RISECamp 的上下文中，Ray 被用作工具，以并行方式处理任意数量的代理上的模拟强化学习策略，以加速模拟。许多其他用例，如超参数优化，也可以很容易地从使用像 Ray 这样的分布式处理系统中受益。
快速帆船
所以你用 Ray 模拟了一个给定 RL 问题的很多策略，找到了最优策略；现在怎么办？这是机器学习的一个古老问题，其中模型是由数据科学家建立的，需要找到一种进入生产环境的方法，以便为系统/应用程序/组织带来真正的价值。这是一个即使是先进的数据科学团队也会因为许多原因而陷入困境的领域。Clipper 提供了一个部署模型的框架，该框架由任何流行的开源机器学习库创建，可以以低延迟提供预测。查看 Clipper 的资源库，获取快速入门指南。
Clipper 的发展有点早，但是它有一个非常强大的方法来应对模型服务的挑战。IBM 开发了一款名为沃森机器学习的产品来应对这一挑战。Watson Machine Learning 提供了一个统一的界面，可以通过代码或 UI 驱动该界面来部署来自多个框架(SPSS、SparkML、Scikit-Learn 等)的模型。).通过使用单一工具来部署任何类型的模型，数据科学家可以灵活地使用他们想要的任何机器学习库，应用程序开发人员可以轻松地选择这些模型，以便轻松地嵌入到系统和应用程序中，进行实时决策。
鹩哥
就像我们在 Ray 中看到的那样，有许多用例，数据科学家需要将他们的过程分布在许多机器上。PyWren 是来自 RISELab 的另一个 Python 包，它专注于这个问题，考虑了不同的方法和目标。与 Ray 不同的是，PyWren 选择了无服务器架构，将 Python 函数推送到 AWS Lambda 上执行。PyWren 提供了一个用于 Lambda 的通用容器，它拥有最流行的数据科学 Python 库，无需额外定制。与 Ray 类似，PyWren 以一种非常简洁的方式实现了这一点，可以很容易地集成到现有的 Python 代码库中。
要查看它的运行情况，请看来自 PyWren 教程的代码片段:
import pywrendef square(param):
return param * paramparam_list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]pwex = pywren.default_executor()
futures = pwex.map(square, param_list)
results_with_pywren_map = [f.result() for f in futures]
如果您在 Python 中使用过’ map()'，那么这个语法应该非常熟悉。传统“映射”和鹪鹩“映射”的区别在于，鹪鹩将函数映射到任意数量的 Lambdas 上。这为可以并行运行的分布式操作提供了一个经济高效且可水平扩展的解决方案。
因为这个代码示例很简单，所以我将更详细地介绍一个具体的用例。如今，许多数据团队利用云对象存储或亚马逊 S3 等块存储来存储数据集。团队可以将这些对象存储服务用于不同的目的，但是一个常见的模式是将容器/桶视为一个接收器，新的数据集作为一些数据管道的一部分写入其中。随着这些文件数量的增加，对每个文件应用一个函数可能是一个缓慢的过程。特别是如果使用类似循环的东西来迭代所有文件，从而线性地应用该函数。PyWren 通过利用 AWS Lambda 将函数清晰地映射到给定容器/桶中的所有文件，在这个用例中大放异彩。PyWren 使用非常简单的语法触发 Lambda 为每个文件应用普通的 python 函数。
地面
到目前为止，我已经介绍了机器学习的许多方面，但是还没有描述如何处理最核心的部分:数据。这就是地在 RISELab 中发挥作用的地方。背景的介绍性解释提供了数据背景的基础知识:
地面数据上下文基础知识
-[A]应用上下文:描述如何解释原始位以供使用。
-【B】行为背景:关于真实的人或系统如何创建和使用数据的信息。
-【C】change Over Time:另外两种形式的数据上下文的版本历史。
通过考虑对数据管理很重要的不同上下文，Ground 提供了管理大型数据目录所需的完整视图。
波浪
最后但同样重要的是，RISELab 堆栈的组件解决了处理物联网设备的安全性和授权的挑战:Wave。
Wave 是最超出我专业范围的组件，但也是我认为最令人印象深刻的组件。我假设有相关性:-)。Wave 提供了一种新的方法，为基于名称空间、公钥和区块链的设备控制提供授权。如果你没有从这个博客中获得任何其他东西，请接受这个时髦的总结:我们正在使用云来训练区块链授权的深度强化学习人工智能系统。从 RISECamp 这里看一下波练习。
总之，RISECamp 是一次令人惊叹的经历，与会者很幸运地看到了来自加州大学伯克利分校的下一代开源项目。RISELab 能够以模块化和互补的方式针对机器学习工程师面临的一些最常见的挑战，这给我留下了非常深刻的印象。我非常期待跟踪这里描述的每个项目，我鼓励你也这样做。
九月版:图像识别
8 篇必读文章
Google tensor flow 物体检测 API 是实现图像识别最简单的方法吗？
由 Priya Dwivedi — 4 分钟阅读。
有许多不同的方法来进行图像识别。谷歌最近发布了一个新的 Tensorflow 对象检测 API，以推动计算机视觉无处不在。
如何用 TensorFlow 的物体检测器 API 训练自己的物体检测器
通过 Dat Tran — 8 分钟读取。
这是关于“用 Tensorflow 和 OpenCV 构建实时物体识别应用”的后续帖子，在这里我重点训练自己的类。具体来说，我在自己收集和标记的数据集上训练了自己的浣熊检测器。完整数据集可在 my Github repo 上获得。
使用 Keras 和直方图均衡化进行深度学习的图像增强
由 Ryan Allred — 12 分钟读取。
在这篇文章中，我们将回顾:图像增强:它是什么？为什么重要？Keras:如何使用它进行基本的图像增强。直方图均衡化:它是什么？怎么有用？实现直方图均衡化技术:修改 keras .预处理 image.py 文件的一种方法。
基于初始网的多标签图像分类
由 Radek Bartyzal — 6 分钟阅读。
Inception v3 是一个深度卷积神经网络，在 ImageNet 数据集上训练用于单标签图像分类。TensorFlow 团队已经准备了一个关于重新训练它的教程，根据我们自己的例子来区分一些类。
我从 Udacity 自动驾驶汽车纳米学位项目的第一学期中学到了什么。
Hadi N. Abu-Snineh — 12 分钟阅读。
我叫哈迪·阿布·斯内赫，来自约旦安曼。我曾在德国约旦大学学习机电一体化工程。我决定接受挑战，参加 Udacity 自动驾驶汽车项目。
智慧城市和图像识别
由乔·汉森 — 6 分钟阅读。
图像识别和机器视觉对地方政府具有现实意义，可以帮助官员有效地整合和管理资产
电报机器人、我的早餐、水果和互动对话上的张量流对象检测
Nicolas Bortolotti——3 分钟阅读。
在本文中，我们将探索一个案例，其中我们使用张量流(对象检测 API)将图像中的对象检测与通过 bot 架构(电报平台)的交互相结合。
深度学习中不同类型卷积的介绍
由保罗-路易·普罗夫 — 6 分钟阅读。
让我给你一个快速概述不同类型的卷积和他们的好处。为了简单起见，我只关注 2D 卷积。
走向数据科学是一份独立的出版物。为了保持我们的开放和编辑自由，我们要求我们的支持者承诺一小笔捐款来帮助我们竞选。非常感谢！
我们也感谢最近加入我们的所有伟大的新作家南希·汉斯莱、普拉萨德·阿金克亚、卡森·福特、达里亚·瓦亚达、苏普里亚·尼甘、古平雄、钟弘成、科林·麦克格鲁、沙恩·巴克、 马克斯·弗罗洛夫、费德里卡·佩泽尔、玉峰、艾哈迈德·沙姆苏尔·阿雷芬、达塔特、马特·拉实验室、帕拉德普·雷迪·拉马纳、贾纳丹·谢蒂、尼克·怀特、阿伊奎斯特·罗德里格斯
九月版:机器学习案例研究
人工智能、机器学习和深度学习的整个格局在过去五年里发生了快速变化。机器学习不再局限于实验室实验或研究论文，而是在不同领域的主流行业采用方面迅速加快了步伐。我们也开始在日常生活中看到甚至使用智能系统。其中包括 Google Now、Alexa、Siri 和 Cortana 等智能助手、自动驾驶汽车、专业游戏代理、聊天机器人、edge analytics 等等。我们人类也逐渐开始在日常生活中接受这样的智能系统和技术，不管围绕人工智能与人类的所有宣传。
人工智能是为了帮助我们自动化和解决复杂且经常重复的任务，帮助我们提高生产力和利润。因此，随着我们步入学习机器、数字化和自动化的新时代，不仅要理解统计建模和机器学习的理论概念，还要理解如何有效地应用这些工具来解决现实世界的问题，这一点非常重要。
“人工智能是新的电力……我们有足够的纸。停止出版，开始用科技改变人们的生活”——吴恩达
因此，现在是时候启动 【应用】 机器学习来解决不同行业领域复杂和简单的现实世界问题，包括金融、零售、科技、医疗保健、物流、运输甚至政府。了解如何应用和使用机器学习的最佳方式是查看业内机器学习案例研究的成熟策略和最佳实践。这个版本为您带来了一些应用机器学习解决各种有趣问题的最佳案例研究。我们希望你能从他们身上学到东西，走出去，做一些令人惊讶的事情！
Dipanjan (DJ) Sarkar ，数据科学家，作者& TDS 编辑
机器学习方法——构建酒店推荐引擎
由苏珊李 — 5 分钟读完
所有在线旅行社都在争先恐后地满足亚马逊和网飞设定的人工智能驱动的个性化标准。此外，在线旅游世界已经成为一个竞争激烈的空间，品牌试图通过推荐、比较、匹配和分享来吸引我们的注意力(和钱包)。
Spotify 的“这是”播放列表:50 位主流艺术家的终极歌曲分析
由詹姆斯·勒 — 15 分钟读完
每个艺术家都有自己独特的音乐风格。从献身于木吉他的艾德·希兰，到精通说唱艺术的德雷克。从能在流行歌曲中唱一些疯狂高音的阿黛尔，到在 DJ 台上创造 EDM 魔术的 Kygo。
通过无监督学习检验国际美食
通过本斯特姆 — 8 分钟读取
像很多人一样，我也是一个美食迷。我非常幸运，在一个吃饭都是从零开始的家庭长大。我妈妈做饭，因为她从德国移民到美国，我接触了很多美味的德国菜肴。
如何使用序列对序列模型创建神奇的数据产品
通过哈默尔侯赛因 — 17 分钟阅读
我从未想过我会用“神奇”这个词来描述机器学习技术的输出。当我被引入深度学习时，这种情况发生了变化，在深度学习中，你可以完成像识别图片中的物体或分类两吨重的乐高玩具这样的事情。
销售员的进化:Python 的完整遗传算法教程
由艾瑞克·斯托罗兹 — 8 分钟读出
从自然选择中汲取灵感，遗传算法(GA)是一种解决搜索和优化问题的迷人方法。虽然已经有很多关于遗传算法的文章(见这里的和这里的)，但很少有人展示用 Python 一步一步实现更复杂问题的遗传算法。
使用 Python 进行时间序列分析和预测的端到端项目
由苏珊李 — 9 分钟读完
时间序列分析包括分析时间序列数据的方法，以便提取有意义的统计数据和数据的其他特征。时间序列预测是使用模型根据以前观察到的值来预测未来值。
利用机器学习模拟世界杯比赛
通过罗德里戈·纳德 — 11 分钟阅读
世界杯正在进入一个新的阶段，很少有人能够预测小组赛的结果。现在是时候进入一个更加激动人心的阶段了，世界上最伟大的人将会面对面。本文的目标是，通过 Python 使用数据科学的力量，尝试揭示这些游戏将呈现的一些统计数据。
客户细分的聚类算法
在当今竞争激烈的世界中，了解客户行为并根据其人口统计和购买行为对客户进行分类至关重要。这是客户细分的一个重要方面，它允许营销人员在促销、营销和产品开发策略方面更好地针对各种受众群调整营销工作。
张量流中的 Seq2Seq 模型
Photo by Marcus dePaula on Unsplash
在这个项目中，我将在 TensorFlow 中建立一个名为**seq2seq model or encoder-decoder model**的语言翻译模型。该模型的目标是将英语句子翻译成法语句子。我将展示详细的步骤，他们将回答像how to define encoder model、how to define decoder model、how to build the entire seq2seq model、how to calculate the loss and clip gradients这样的问题。
请访问 Github repo 了解 Jupyter 笔记本中更详细的信息和实际代码。它将涵盖更多的主题，如how to preprocess the dataset、how to define inputs和how to train and get prediction。
这是 Udacity 深度学习纳米学位的一部分。一些代码/功能(保存、加载、测量精度等)由 Udacity 提供。然而，大部分是我自己实现的，每一节都有更丰富的解释和参考。此外，基础数字(关于模型)借用自 Luong (2016) 。
构建 Seq2Seq 模型的步骤
您可以将整个模型分成两个小的子模型。第一个子模型称为**【E】编码器 ，第二个子模型称为【D】解码器 。就像任何其他 RNN 架构一样，接受原始输入文本数据。最后，【E】输出一个神经表示。这是一个非常典型的工作，但是你需要注意这个输出到底是什么。【E】的输出将成为【D】**的输入数据。
这就是为什么我们称**【E】为编码器，称【D】为解码器。【E】做出一个以神经表征形式编码的输出，我们不知道它到底是什么。它被加密了。【D】具有查看【E】**输出内部的能力，它将创建一个完全不同的输出数据(在本例中翻译成法语)。
为了建立这样一个模型，总共有 6 个步骤。我注意到要实现的功能与每个步骤相关。
(1)定义编码器模型的输入参数
enc_dec_model_inputs
(2)建立编码器模型
encoding_layer
(3)定义解码器模型的输入参数
enc_dec_model_inputs、process_decoder_input、decoding_layer
(4)为训练建立解码器模型
decoding_layer_train
(5)建立用于推理的解码器模型
decoding_layer_infer
(6)将(4)和(5)放在一起
decoding_layer
(7)连接编码器和解码器型号
seq2seq_model
(8)定义损失函数、优化器，并应用梯度剪切
Fig 1. Neural Machine Translation / Training Phase
编码器输入(1)、(3)
enc_dec_model_inputs函数创建并返回与建筑模型相关的参数(TF 占位符)。
输入占位符将输入英文句子数据，其形状为[None, None]。第一个None表示批量大小，批量大小未知，因为用户可以设置。第二个None表示句子的长度。setence 的最大长度因批次而异，因此无法用确切的数字进行设置。
- 一种选择是将每批中所有句子的长度设置为最大长度。无论您选择哪种方法，您都需要在空位置添加特殊字符
<PAD>。然而，对于后一种选择，可能会有不必要的更多<PAD>字符。
targets 占位符类似于 inputs 占位符，只是它将输入法语句子数据。
target_sequence_length 占位符表示每个句子的长度，所以形状是None，一个列张量，与批量大小相同。这个特定的值需要作为 TrainerHelper 的参数，以建立用于训练的解码器模型。我们将在(4)中看到。
max_target_len 获取所有目标句子(序列)长度的最大值。如你所知，我们在 target_sequence_length 参数中有所有句子的长度。从中获取最大值的方法是使用 tf.reduce_max 。
过程解码器输入(3)
在解码器端，我们需要两种不同的输入，分别用于训练和推理。在训练阶段，输入作为目标标签被提供，但是它们仍然需要被嵌入。然而，在推理阶段，每个时间步的输出将是下一个时间步的输入。它们也需要被嵌入，并且嵌入向量应该在两个不同的相位之间共享。
Fig 2. **<GO>** insertion
在本节中，我将为训练阶段预处理目标标签数据。这不是什么特别的任务。你所需要做的就是在所有目标数据前面加上<GO>特殊标记。<GO> token 是一种引导性的 token，比如说“这是翻译的开始”。对于这个过程，你需要知道 TensorFlow 的三个库。
- 提取张量的步长切片(广义 python 数组索引)。
- 可以认为是分裂成多个张量与跨度窗口大小从开始到结束
- 参数:TF 张量，开始，结束，步幅
- 创建一个用标量值填充的张量。
- 参数:TF 张量(必须是 int32/int64)，要填充的值
- 沿一维连接张量。
- 参数:一个 TF 张量列表(本例中为 tf.fill 和 after_slice)，axis=1
对目标标签数据进行预处理后，我们会在后面实现 decoding_layer 函数时嵌入。
编码(2)
Fig 3. Encoding model highlighted — Embedding/RNN layers
如图 3 所示，编码模型由两个不同的部分组成。第一部分是嵌入层。一个句子中的每个单词将由指定为encoding_embedding_size的特征数量来表示。这一层赋予了单词有用解释更丰富的代表力。第二部分是 RNN 层。你可以利用任何种类的 RNN 相关技术或算法。例如，在这个项目中，多个 LSTM 单元在漏失技术应用后堆叠在一起。你可以使用不同种类的 RNN 细胞，如 GRU
嵌入层
RNN 层层
- TF contrib . rnn . lstmcell
:简单指定它有多少个内部单元 - TF contrib . rnn . drop out wrapper
:用 keep 概率值包装单元格 - TF contrib . rnn . multirnncell
:堆叠多个 rnn(类型)单元格
: 这个 API 是如何使用的？
编码模式
- TF nn.dynamic_rnn
:将嵌入图层和 rnn 图层放在一起
解码—训练过程(4)
解码模型可以被认为是两个独立的过程，训练和推理。这不是因为它们具有不同的架构，而是因为它们共享相同的架构及其参数。这是因为他们有不同的策略来支持共享模型。对于这个(训练)和下一个(推断)部分，图 4 清楚地显示了它们是什么。
Fig 4. Decoder shifted inputs
当编码器使用TF contrib . layers . embed _ sequence时，它不适用于解码器，即使它可能要求其输入嵌入。这是因为相同的嵌入向量应该通过训练和推断阶段共享。TF contrib . layers . embed _ sequence运行前只能嵌入准备好的数据集。推理过程需要的是动态嵌入能力。在运行模型之前，不可能嵌入推理过程的输出，因为当前时间步的输出将是下一个时间步的输入。
我们如何嵌入？我们很快就会看到。然而，现在，你需要记住的是训练和推理过程共享相同的嵌入参数。对于训练部分，应该交付嵌入的输入。在推理部分，应该只传送训练部分中使用的嵌入参数。
先看训练部分。
[**tf.contrib.seq2seq.TrainingHelper**](https://www.tensorflow.org/api_docs/python/tf/contrib/seq2seq/TrainingHelper):training helper 是我们传递嵌入输入的地方。顾名思义，这只是一个助手实例。这个实例应该交付给 BasicDecoder，这是构建解码器模型的实际过程。[**tf.contrib.seq2seq.BasicDecoder**](https://www.tensorflow.org/api_docs/python/tf/contrib/seq2seq/BasicDecoder):basic decoder 构建解码器模型。这意味着它连接解码器端的 RNN 层和由 TrainingHelper 准备的输入。[**tf.contrib.seq2seq.dynamic_decode**](https://www.tensorflow.org/api_docs/python/tf/contrib/seq2seq/dynamic_decode):dynamic _ decode 展开解码器模型，以便 BasicDecoder 可以检索每个时间步长的实际预测。
解码——推理过程(5)
[**tf.contrib.seq2seq.GreedyEmbeddingHelper**](https://www.tensorflow.org/api_docs/python/tf/contrib/seq2seq/GreedyEmbeddingHelper):greedyembedinghelper 动态获取当前步骤的输出，并将其交给下一个时间步骤的输入。为了动态地嵌入每个输入结果，应该提供嵌入参数(只是一串权重值)。与此同时，GreedyEmbeddingHelper 要求提供与批量和end_of_sequence_id相同数量的start_of_sequence_id。[**tf.contrib.seq2seq.BasicDecoder**](https://www.tensorflow.org/api_docs/python/tf/contrib/seq2seq/BasicDecoder):同培训流程一节所述[**tf.contrib.seq2seq.dynamic_decode**](https://www.tensorflow.org/api_docs/python/tf/contrib/seq2seq/dynamic_decode): 同培训流程一节所述
构建解码层(3)、(6)
嵌入目标序列
- TF contrib . layers . embed _ sequence创建了嵌入参数的内部表示，因此我们无法查看或检索它。相反，你需要通过 TF 变量手动创建一个嵌入参数。
- 手动创建的嵌入参数用于训练阶段，以在训练运行前通过 TF nn.embedding_lookup 转换提供的目标数据(句子序列)。手动创建嵌入参数的 TF nn.embedding_lookup 返回与TF contrib . layers . embed _ sequence类似的结果。对于推理过程，每当解码器计算当前时间步的输出时，它将被共享的嵌入参数嵌入，并成为下一个时间步的输入。你只需要提供嵌入参数给 GreedyEmbeddingHelper，那么它会帮助这个过程。
- embedding _ lookup 如何工作？
:简而言之，选择指定的行 - 注意:请小心设置变量范围。如前所述，参数/变量在训练和推理过程之间共享。共享可以通过 tf.variable_scope 指定。
构建解码器 RNN 层
- 如图 3 和图 4 所示，解码器模型中的 RNN 层数必须等于编码器模型中的 RNN 层数。
创建一个输出层，将解码器的输出映射到我们的词汇表中的元素
- 这只是一个完全连接的层，以获得每个单词在最后出现的概率。
构建 Seq2Seq 模型(7)
在本节中，将之前定义的函数、encoding_layer、process_decoder_input和decoding_layer放在一起，构建一个完整的序列到序列模型。
构建图形+定义损失，优化器，带梯度剪裁
seq2seq_model功能创建模型。它定义了前馈和反向传播应该如何流动。该模型可训练的最后一步是决定和应用使用什么优化算法。在本节中，TF contrib . seq 2 seq . sequence _ loss用于计算损失，然后 TF train。AdamOptimizer 用于计算损耗的梯度下降。让我们在下面的代码单元中检查每个步骤。
从检查点加载数据
- (source_int_text，target_int_text)是输入数据，而(source_vocab_to_int，target_vocab_to_int)是用于查找每个单词的索引号的词典。
- max_target_sentence_length 是源输入数据中最长句子的长度。在解码器模式下构建推理过程时，这将用于 GreedyEmbeddingHelper。
创建输入
- enc_dec_model_inputs 函数的输入(输入数据、目标、目标序列长度、最大目标序列长度)
- 超参数输入函数的输入(lr，keep_prob)
构建 seq2seq 模型
- 通过 seq2seq_model 函数建立模型。它将返回 train _ logits(计算损失的 logit)和 inference _ logits(来自预测的 logit)。
成本函数
- 使用 TF contrib . seq 2 seq . sequence _ loss。这个损失函数只是一个加权的 softmax 交叉熵损失函数，但它是特别设计用于时间序列模型(RNN)。权重应该作为一个参数明确提供，它可以由 TF sequence_mask 创建。在这个项目中， TF sequence_mask 创建[batch_size，max_target_sequence_length]大小的变量，然后马克斯只将第一个 target_sequence_length 元素的个数设为 1。这意味着零件的重量会比其他零件轻。
优化器
- TF 列车。使用 AdamOptimizer ，这是应该指定学习率的地方。你也可以选择其他算法，这只是一个选择。
渐变裁剪
Fig 5. Gradient Clipping
- 由于递归神经网络是臭名昭著的消失/爆炸梯度，梯度裁剪技术被认为是改善这一问题。
- 这个概念真的很简单。您决定阈值以保持梯度在某个边界内。在这个项目中，阈值的范围在-1 和 1 之间。
- 现在，您需要将这些概念性知识应用到张量流代码中。幸运的是，有这个 TF 渐变裁剪的官方指南 How？。在 breif 中，您通过调用 compute_gradients 从优化器手动获取梯度值，然后使用 clip_by_value 操作梯度值。最后，您需要通过调用 apply_gradients 将修改后的梯度放回到优化器中
关于我自己
我的深度学习背景是uda city { Deep Learning ND&AI-ndwith contentrations(CV， NLP ，VUI)}，Coursera Deep Learning . AI Specialization(AI-ND 被拆分成 4 个不同的部分，我是和之前版本的 ND 一起完成的)。还有，我目前正在服用 Udacity 数据分析师 ND ，目前已经完成 80%。
序列对序列学习
在序列到序列学习中，RNN 被训练将输入序列映射到不一定长度相同的输出序列。
应用是语音识别、机器翻译、图像字幕和问答。
架构
Encoder — Decoder Architecture
编码器 RNN 读取输入序列并生成固定大小的上下文向量，该向量代表输入序列的语义摘要。
固定大小的上下文向量作为解码器 RNN 的输入。
固定大小上下文可以作为解码器 RNN 的初始状态提供，或者可以在每个时间步长连接到隐藏单元。这两种方式也可以结合使用。
编码器和解码器中的时间步长数不需要相等。
限制
这种体系结构的一个限制是很难用一个小维度的上下文向量来概括一个长序列。
如何解决？
可以使用可变长度的上下文向量代替固定大小的向量。
注意机制可用于从输入序列的每个时间步长从编码器 RNN 产生矢量序列。解码器学习有选择地关注矢量**，以在每个时间步长产生输出。**
序列对序列模型:简介和概念
如果我们从高层次来看，seq2seq 模型的主要组件包括编码器、解码器和中间步骤:
我们使用嵌入，所以我们必须首先编译一个“词汇表”列表，包含我们希望我们的模型能够使用或读取的所有单词。模型输入必须是包含序列中单词 id 的张量。
然而，有四个符号需要我们的词汇来包含。Seq2seq 词汇表通常为这些元素保留前四个位置:
- < PAD > :在训练过程中，我们需要将我们的例子批量地反馈给网络。这些批次中的输入都需要具有相同的宽度，以便网络进行计算。然而，我们的例子长度不同。这就是为什么我们需要填充较短的输入，使它们与批处理的宽度相同
- < EOS > :这也是批处理的另一个必要性，但更多是在解码器端。它允许我们告诉解码器一个句子在哪里结束，也允许解码器在输出中指出同样的事情。
- <>:如果你在真实数据上训练你的模型，你会发现你可以通过忽略那些在你的词汇表中出现频率不够高、不值得考虑的单词来极大地提高你的模型的资源效率。我们用< UNK >代替那些。
- < GO > :这是解码器第一个时间步长的输入，让解码器知道什么时候开始产生输出。
注意:可以使用其他标签来表示这些功能。例如，我见过用和代替和。因此，通过预处理和模型训练/推理，确保您使用的任何东西都是一致的。
为训练图准备输入稍微复杂一些，原因有两个:
1.如果我们向解码器提供我们的目标序列，而不管它的时间步长在训练运行中实际输出什么，这些模型会工作得更好。因此，与图中不同的是，我们不会在下一个时间步中将解码器的输出反馈给自身。
2.定量
最初的序列对序列论文之一 Sutskever 等人 2014 报告称，如果输入相反，模型性能会更好。所以你也可以选择颠倒单词在输入序列中的顺序。
在预处理过程中，我们执行以下操作:
- 我们建立自己的独特词汇库(并计算出现的次数)
- 我们用替换频率低的词
- 创建一个对话的副本，用 id 替换单词
- 我们可以选择现在将和单词 id 添加到目标数据集，或者在训练时进行添加
学分:来自课堂讲稿:https://classroom.udacity.com/nanodegrees/nd101/syllabus
资源:
https://github.com/ematvey/tensorflow-seq2seq-tutorials
序列到序列教程
这是深度学习中最强大的概念之一，它始于翻译，但后来转移到了问答系统(Siri、Cortana 等)。)、音频转录等。顾名思义，它对从一个序列转换到另一个序列很有用。
背后的主要思想是，它包含一个编码器 RNN (LSTM)和一个解码器 RNN。一个用来“理解”输入序列，解码器用来“解码”“思想向量”并构建输出序列。
Seq2Seq LSTMs
思想载体真正强大的地方在于，你可以插入输出解码器，将其转换成任何语言。也就是说，你不需要在英语到法语的数据集上训练来从英语转换到西班牙语。你可以简单地插入一个解码器，这个解码器是从一个不同的设备(比如葡萄牙语到西班牙语)预先训练好的。至少这是背后的理论。可能取决于你训练它的时间，你的数据量等等。
我发现 tensorflow 中缺少 seq2seq 模型背后的文档，所以我编写了自己的模型，如下所示。我在 Tensorflow 文档中找到的最接近的是embedding_rnn_seq2seq,然而，它在实现这个函数方面并不明显。因此，我写了自己的seq2seq模型如下:
*# Tensor where we will feed the data into graph*
inputs = tf.placeholder(tf.int32, (**None**, x_seq_length), 'inputs')
outputs = tf.placeholder(tf.int32, (**None**, **None**), 'output')
targets = tf.placeholder(tf.int32, (**None**, **None**), 'targets')
*# Embedding layers*
input_embedding = tf.Variable(tf.random_uniform((len(char2numX), embed_size), -1.0, 1.0), name='enc_embedding')
output_embedding = tf.Variable(tf.random_uniform((len(char2numY), embed_size), -1.0, 1.0), name='dec_embedding')
date_input_embed = tf.nn.embedding_lookup(input_embedding, inputs)
date_output_embed = tf.nn.embedding_lookup(output_embedding, outputs)
**with** tf.variable_scope("encoding") **as** encoding_scope:
lstm_enc = tf.contrib.rnn.BasicLSTMCell(nodes)
_, last_state = tf.nn.dynamic_rnn(lstm_enc, inputs=date_input_embed, dtype=tf.float32)
**with** tf.variable_scope("decoding") **as** decoding_scope:
lstm_dec = tf.contrib.rnn.BasicLSTMCell(nodes)
dec_outputs, _ = tf.nn.dynamic_rnn(lstm_dec, inputs=date_output_embed, initial_state=last_state)
*#connect outputs to*
logits = tf.contrib.layers.fully_connected(dec_outputs, num_outputs=len(char2numY), activation_fn=**None**)
**with** tf.name_scope("optimization"):
*# Loss function*
loss = tf.contrib.seq2seq.sequence_loss(logits, targets, tf.ones([batch_size, y_seq_length]))
*# Optimizer*
optimizer = tf.train.RMSPropOptimizer(1e-3).minimize(loss)
完整的教程可以在这个视频(和代码(第 19 课)如果你想跳过视频):
看这里是我的关于机器学习和深度学习的课程(使用代码 DEEPSCHOOL-MARCH 到 85 折)。
深度学习中序列对序列模型的熟悉
序列到序列模型是接受序列输入并输出序列的模型。
建筑
Sequence to Sequence
编码器 r 是一个 RNN，接收输入并将其编码成一个向量。
编码器的最后隐藏状态给出编码向量。
编码向量重复 n 次，其中n =输出的时间步长数。
解码器，也是 RNN，将编码矢量和先前 状态作为输入，并给出输出。
编码器和解码器中的时间步长数不需要相等。
为什么是 Seq2seq？
当你想在看到整个输入句子后生成输出时，可以使用 seq2seq 模型。
例如，在机器翻译中，翻译句子中的第一个单词可能取决于输入句子中的最后一个单词。
图像字幕
在图像字幕中，生成图像的文本描述。
训练数据由带有相应标题的图像组成。
编码器现在被卷积神经网络所取代。来自最后一个隐藏状态的输出被提供给解码器 RNN。
使用 Dask、Amazon ECS 和 Python 的分布式数据预处理(上)
Source: unsplash.com
机器学习模型的质量和准确性取决于许多因素。最关键的因素之一是在将数据集输入到从数据中学习的机器学习算法之前对数据集进行预处理。因此，为他们提供您想要解决的问题的正确数据是至关重要的。例如，一些算法不支持空值，应该在训练之前进行转换和处理。您还应该了解为什么会有缺失值，这些值是否有特定的模式，以及它们的影响是什么。
数据工程师和数据科学家经常使用来自 python 生态系统的工具，如 Numpy 和 Pandas 来分析、转换和可视化他们的数据，这些数据被设计为高性能、直观和高效的库。以快速和可伸缩的方式在小数据集上执行这样的操作并不困难，只要数据集能够适合单台机器的内存。然而，如果数据集太大，无法放入单台机器，数据工程师可能会被迫将他们的代码重写为更具可扩展性的工具，如 Spark 和 SparkML，这些工具可以由大型 EMR 集群提供计算支持。
为了克服这个问题，我使用了 Dask 。Dask 利用了人们对像 Pandas 这样的著名库的熟悉，你可以用它来开发代码，以可伸缩、并行和分布式的方式处理数据。
在本文中，我将讨论如何创建一个无服务器集群，以分布式和并行的方式预处理数据。我还使用了 Dask 分布式 集群，为分析和数据处理提供了高级并行性。为了实现大规模性能，同时优化成本并保持解决方案的灵活性，我将使用 AWS Fargate 构建一个无服务器集群，它不提供集群管理开销，只提供一个 API 调用来扩展和缩小集群，然后将集群与 Amazon SageMaker Jupyter 笔记本集成。(或任何其他首选 IDE)
Dask 分布式是什么？
dask . distributed*:*是一个轻量级的开源库，用于 Python 中的分布式计算。它还是一个集中管理的、分布式的、动态的任务调度器。Dask 有三个主要组成部分:
dask-scheduler 进程: 协调几个工人的动作。调度器是异步的和事件驱动的，同时响应来自多个客户端的计算请求并跟踪多个工作进程。
dask-worker 进程: 跨多台机器和多个客户端的并发请求。
dask-客户端进程: 它是 dask.distributed 用户的主要入口点
解决方案图表:
Solution Diagram and Architecture
我需要在 Juypter 笔记本和 Fargate 集群之间保持低延迟通信和简单的网络配置。因此，我在同一个虚拟私有云(VPC)中创建了笔记本和 Dask 分布式集群。
预部署步骤:
首先，作为先决条件，我需要创建一个弹性容器注册(ECR)存储库。为此，我转到 AWS 控制台- >弹性容器服务(ECS) - >选择存储库，然后“创建存储库”。
(您也可以跳过这一步，创建一个 github 资源库)
我们需要给它起一个名字——“dask，然后点击“下一步”:
然后，我们转到“入门”页面，在这里我们可以找到创建和推送容器映像的初始命令。
既然存储库已经准备好了，我将切换到一个 shell“终端”来下载、构建和标记容器映像，然后将其推送到 ECR。为此，我运行以下 shell 命令:
bash# git clone [https://github.com/wmlba/ECS-Dask.git](https://github.com/wmlba/ECS-Dask.git)bash# cd ECS-Dask; tar -xzf base-image.tar.gz; cd base-imagebash# `aws ecr get-login --no-include-email --region us-east-1`bash# docker build -t dask .bash# docker tag dask:latest <AWS Account ID>.dkr.ecr.us-east-1.amazonaws.com/dask:latestbash# docker push <AWS Account ID>.dkr.ecr.us-east-1.amazonaws.com/dask:latest
注意:为了运行上述命令，您需要在运行命令的机器上本地安装 Docker，并配置 AWS 凭证。
我使用的 docker 图片是从 dask 库上发布的图片稍微修改的
构建映像需要几分钟时间，然后将其推送到在前面的步骤中创建的 ECR 存储库。您可以通过在 ECS 控制台中单击存储库名称来验证这一点。
部署解决方案
现在我已经准备好了映像，我需要按照以下步骤使用 CloudFormation 模板部署解决方案:
- 在你的账户中启动这个云信息模板。完成云形成堆栈大约需要 3-5 分钟
CloudFormation 堆栈将为 Dask worker 和 Scheduler 创建资源，例如:Fargate 集群、任务定义、服务和任务。它还将创建一个 IAM 执行角色和策略，以允许访问 Elastic Container Registry (ECR)存储库和 CloudWatch 日志组的日志。默认情况下，所有资源都将在 us-east-1 区域创建。
2.在“指定详细信息”页面上，我为集群指定了一个带有 NAT 网关的专用子网。Dask 调度程序和工作程序将通过专用网络进行通信，ECS 服务只需要 NAT 网关就可以从存储库中提取 ECR 映像。然后，选择下一步:
3.在选项页面上，选择下一步。
4.在查看页面上，查看并确认设置。确保选中该框，确认模板将创建具有自定义名称的 AWS 身份和访问管理(IAM)资源。要部署堆栈，选择创建。几分钟后，堆栈创建应该完成。
创建堆栈后，您还可以确认 ECS Dask 集群已部署并正在运行。您可以通过切换到 ECS 控制台->单击群集 - >单击 Fargate-Dask-Cluster 来验证这一点，在 tasks 选项卡上，应该有两个正在运行的任务:
现在 Dask 集群已经准备好了，我将创建 SageMaker Notebook，这样我就可以开始使用集群了。为此，我切换到 SageMaker 控制台->笔记本实例->创建笔记本实例**。**
然后，我将选择之前在 CloudFormation 模板中选择的相同 VPC 和子网:
注意:您可以选择任何其他子网和安全组，只要您启用 SageMaker 笔记本和 Dask 集群之间的访问。
然后，我通过点击新建->-conda _ python3 创建一个新的 python 3 笔记本。Dask 软件包默认安装在 SageMaker 笔记本上，但确保软件包更新到最新版本很重要。为了验证这一点，我将在笔记本上运行 conda update 命令:
注意:如果客户端版本低于调度器和工作器版本，您在启动客户端时会遇到错误。
下一步是创建客户端，并通过运行以下代码连接到 dask 集群:
请注意，我使用了使用 ECS 服务发现功能自动分配的调度程序的 DNS 名称，该功能使用 Route 53 自动命名 API 操作来管理 Route 53 DNS 条目
现在，让我们使用集群对数据执行一些操作，但在此之前，我会将集群中的工作线程数量增加到 7 个。为此，我在笔记本中运行如下命令:
几秒钟后，Fargate 控制台中的工作任务状态将为“正在运行”。我将重新启动 Dask 客户端，以确保我们利用了集群的并行性。
现在，我们有一个由 14 个 CPU 内核和 12 GB 内存组成的集群(7 个工作线程各有 2 个 CPU 内核和 2 GB 内存)。让我们做一些计算和内存密集型操作，并产生一些见解。我正在用数据加载 dask dataframe，计算行程距离，并根据乘客数量进行分组。
在 7 个不同的工作人员之间并行化任务并并行加载超过 10 GB 的数据后，大约 2.5 分钟后，结果开始显现。
可视化:
来自 Bokeh 服务器的调度器任务的屏幕截图，显示了在工人之间线程化的操作。可以在浏览器中从调度程序 IP 地址和端口 8787 访问仪表板:
以下屏幕截图显示了每个工作人员的资源(CPU 和内存)利用率:
现在你应该准备好做一些预处理魔术！
在第 2 部分，我将展示一些使用我们创建的 Dask 集群运行分析和预处理/特征工程和机器学习的代码。
感谢您阅读帖子。反馈和建设性的批评总是受欢迎的。我会阅读你所有的评论。
威尔
使用 TensorFlow-Serving 的 RESTful API 服务基于图像的深度学习模型
如何在网络中提供端到端的 Tensorflow 模型？
TensorFlow-Serving 是一个有用的工具，由于它的新近性和相当小众的用例，它没有太多的在线教程。在这里，我将展示一个解决方案，演示 TensorFlow 的端到端实现——在基于图像的模型上提供服务，涵盖从将图像转换为 Base64 到将 TensorFlow 模型服务器与深度神经网络集成的所有内容。
在本教程中，提供了一个最小的工作示例——这个实现可以很容易地扩展到包括 Docker 容器、Bazel 构建、批量推理和模型解耦。这里的主要焦点是理解使用 TensorFlow-Serving 的一般要求，独立于任何可选的附加功能。使用 TensorFlow-Serving 的 RESTful 版本，与 gRPC 版本相反，我们实现了 predict 函数，但是也可以使用 classify 和 regression。
如果你想在 Jupyter 笔记本上查看这个教程，请点击这里。
概观
在最基本的层面上，TensorFlow-Serving 允许开发人员将客户端请求和数据与独立于客户端系统的深度学习模型相集成。这样做的好处包括客户端能够对数据进行推断，而不必实际安装 TensorFlow，甚至不必与实际模型有任何联系，并且能够用一个模型实例为多个客户端提供服务。
我们的管道将是这样的:
特别要注意的是，图像必须作为一个 Base64 编码的字符串从客户端传递到服务器。这是因为 JSON 没有其他方法来表示图像(除了张量的数组表示，这很快就会失控)。图像也必须作为张量从原型传递到生成器。这是可以修改的，但是最好保持任何预处理和后处理与模型本身分离。
计算机网络服务器
导出用于服务的 TensorFlow 模型可能是该过程中最令人困惑的部分，因为这涉及到几个步骤。
- 将图形导出为 ProtoBuf 格式。这将保存 GraphDef 和变量，并表示训练好的模型。为了导出基于图像的模型，我们必须在图形的开头和结尾注入位串转换层，因为我们要求我们的推理函数只处理张量。
- 将 ProtoBuf 包装在 SavedModel 中。这一步是必要的，因为 TensorFlow-Serving 的 RESTful API 是通过 SavedModelBuilder 实现的。我们将导入我们的 GraphDef，然后提取输入和输出的 TensorInfo 来定义我们的预测签名定义。
我们将使用 CycleGAN 作为使用示例。首先，导入一些有用的库:
import tensorflow as tf
import argparse
import sys
sys.path.insert(0, “../CycleGAN-TensorFlow”)
import model
在这里，我们实例化一个 CycleGAN 并注入我们的第一层。
graph = tf.Graph()
**with** graph.as_default():
*# Instantiate a CycleGAN*
cycle_gan = model.CycleGAN(ngf=64, norm="instance", image_size=64)
*# Create placeholder for image bitstring*
*# This is the injection of the input bitstring layer*
input_bytes = tf.placeholder(tf.string, shape=[], name="input_bytes")
接下来，我们将位串预处理为一个浮点张量批，以便它可以在模型中使用。
**with** graph.as_default():
input_bytes = tf.reshape(input_bytes, [])
*# Transform bitstring to uint8 tensor*
input_tensor = tf.image.decode_png(input_bytes, channels=3)
*# Convert to float32 tensor*
input_tensor = tf.image.convert_image_dtype(input_tensor, dtype=tf.float32)
*# Ensure tensor has correct shape*
input_tensor = tf.reshape(input_tensor, [64, 64, 3])
*# CycleGAN's inference function accepts a batch of images*
*# So expand the single tensor into a batch of 1*
input_tensor = tf.expand_dims(input_tensor, 0)
然后，我们将张量输入模型并保存其输出。
**with** graph.as_default():
*# Get style transferred tensor*
output_tensor = cycle_gan.G.sample(input_tensor)
后推理，我们将浮点张量转换回一个位串。这是输出层的注入:
**with** graph.as_default():
*# Convert to uint8 tensor*
output_tensor = tf.image.convert_image_dtype(output_tensor, tf.uint8)
*# Remove the batch dimension*
output_tensor = tf.squeeze(output_tensor, [0])
*# Transform uint8 tensor to bitstring*
output_bytes = tf.image.encode_png(output_tensor)
output_bytes = tf.identity(output_bytes, name="output_bytes")
*# Instantiate a Saver*
saver = tf.train.Saver()
既然我们已经将位串层注入到我们的模型中，我们将加载我们的火车检查点并将图保存为 ProtoBuf。在对该服务器进行编码之前，我对 CycleGAN 进行了 10，000 步的训练，并将检查点文件保存在我的本地机器上，我将在该会话中访问该文件。
*# Start a TensorFlow session*
**with** tf.Session(graph=graph) **as** sess:
sess.run(tf.global_variables_initializer())
*# Access variables and weights from last checkpoint*
latest_ckpt = tf.train.latest_checkpoint("../CycleGAN-TensorFlow/checkpoints/20180628-1208")
saver.restore(sess, latest_ckpt)
*# Export graph to ProtoBuf*
output_graph_def = tf.graph_util.convert_variables_to_constants(sess, graph.as_graph_def(), [output_bytes.op.name])
tf.train.write_graph(output_graph_def, "../CycleGAN-TensorFlow/protobufs", "model_v1", as_text=**False**)
至此，我们完成了第一步！在第二步中，我们将把 ProtoBuf 包装在一个 SavedModel 中，以使用 RESTful API。
*# Instantiate a SavedModelBuilder*
*# Note that the serve directory is REQUIRED to have a model version subdirectory*
builder = tf.saved_model.builder.SavedModelBuilder("serve/1")
*# Read in ProtoBuf file*
**with** tf.gfile.GFile("../CycleGAN-TensorFlow/protobufs/model_v1", "rb") **as** protobuf_file:
graph_def = tf.GraphDef()
graph_def.ParseFromString(protobuf_file.read())
*# Get input and output tensors from GraphDef*
*# These are our injected bitstring layers*
[inp, out] = tf.import_graph_def(graph_def, name="", return_elements=["input_bytes:0", "output_bytes:0"])
接下来，我们定义我们的签名定义，它期望模型的输入和输出的张量信息。当我们保存模型时，我们会得到一个“No assets”消息，但是这没关系，因为我们的图和变量已经保存在 ProtoBuf 中了。
*# Start a TensorFlow session with our saved graph*
**with** tf.Session(graph=out.graph) **as** sess:
*# Signature_definition expects a batch*
*# So we'll turn the output bitstring into a batch of 1 element*
out = tf.expand_dims(out, 0)
*# Build prototypes of input and output bitstrings*
input_bytes = tf.saved_model.utils.build_tensor_info(inp)
output_bytes = tf.saved_model.utils.build_tensor_info(out)
*# Create signature for prediction*
signature_definition = tf.saved_model.signature_def_utils.build_signature_def(
inputs={"input_bytes": input_bytes},
outputs={"output_bytes": output_bytes},
method_name=tf.saved_model.signature_constants.PREDICT_METHOD_NAME)
*# Add meta-information*
builder.add_meta_graph_and_variables(
sess, [tf.saved_model.tag_constants.SERVING],
signature_def_map={
tf.saved_model.signature_constants.
DEFAULT_SERVING_SIGNATURE_DEF_KEY: signature_definition
})
*# Create the SavedModel*
builder.save()
就是这样！命令行返回的是 SavedModel 的路径，它用于构建 TensorFlow 模型服务器。serve/1 中的“variables”文件夹将是空的，但这没关系，因为我们的变量已经保存在 ProtoBuf 中了。
截至 2018 年 7 月，Python 3 不支持 TensorFlow 服务，但有人提出了解决方案。安装 Python 3 TensorFlow 服务 API，包括:
pip install tensorflow-serving-api-python3
现在，我们可以用下面的命令从 bash 运行这个 TensorFlow 模型服务器:
tensorflow_model_server --rest_api_port=8501 --model_name=saved_model --model_base_path=$(path)
其中$(path)是服务器目录的路径。我的例子是/mnt/c/Users/Tyler/Desktop/tendies/minimum _ working _ example/serve。
客户
客户端的工作是接受图像作为输入，将其转换为 Base64，使用 JSON 将其传递给服务器，并解码响应。首先，导入一些有用的库:
**import** **base64**
**import** **requests**
**import** **json**
**import** **argparse**
我们将执行从高斯噪声图像到正弦噪声图像的风格转换。这是高斯图像:
首先，我们将打开图像并将其转换为 Base64。
*# Open and read image as bitstring*
input_image = open("images/gaussian.png", "rb").read()
print("Raw bitstring: " + str(input_image[:10]) + " ... " + str(input_image[-10:]))
*# Encode image in b64*
encoded_input_string = base64.b64encode(input_image)
input_string = encoded_input_string.decode("utf-8")
print("Base64 encoded string: " + input_string[:10] + " ... " + input_string[-10:])
发送到 TensorFlow 模型服务器的 JSON 数据必须以一种非常特殊的方式构建。这种方法将略有不同用于分类和回归。对于图像预测调用，我们的 JSON 主体必须如下所示:
{
"instances": [
{"b64": "iVBORw"},
{"b64": "pT4rmN"},
{"b64": "w0KGg2"}
]
}
因为我们只向服务器发送一张图片，所以这很简单。我们可以像这样创建 JSON 数据:
*# Wrap bitstring in JSON*
instance = [{"b64": input_string}]
data = json.dumps({"instances": instance})
print(data[:30] + " ... " + data[-10:])
这就是我们向 TensorFlow 模型服务器发送 POST 请求所需的全部内容。这是一个同步调用，所以客户端将暂停，直到它收到来自服务器的响应(当您想知道为什么您的代码在发布一个非常大的图像后停止时，这很有用)。
json_response = requests.post("http://localhost:8501/v1/models/saved_model:predict", data=data)
为了解释响应，我们以相反的顺序执行上述步骤。为了从 JSON 响应中获取 base64 编码的图像，我们必须访问:
- 对应于响应字典中“预测”的值。
- 结果数组中的第一个条目。
- 结果字典中对应于“b64”的值。
然后，我们将把这个值解码成一个原始的位串。
*# Extract text from JSON*
response = json.loads(json_response.text)
*# Interpret bitstring output*
response_string = response["predictions"][0]["b64"]
print("Base64 encoded string: " + response_string[:10] + " ... " + response_string[-10:])
*# Decode bitstring*
encoded_response_string = response_string.encode("utf-8")
response_image = base64.b64decode(encoded_response_string)
print("Raw bitstring: " + str(response_image[:10]) + " ... " + str(response_image[-10:]))
*# Save inferred image*
**with** open("images/sinusoidal.png", "wb") **as** output_file:
output_file.write(response_image)
成功！这是合成图像，它在我们的原始图像上添加了正弦噪声模式。
结论
感谢跟随本教程；希望对你有帮助！这款笔记本基于我的 TensorFlow 分布式图像服务库的最小工作示例，您可以在这里下载。如果您有兴趣将这个库与 TensorFlow 对象检测 API 甚至您自己的模型集成在一起，请查看本文的续集。更多关于我的博文和信息，请访问我的网站。
Scala 中的服务张量流模型
Taken from here
Taken from here
问题
训练机器学习模型的过程只是将其投入生产的第一步。在一天结束时，数据科学团队签署模型，数据工程团队必须找出如何在生产环境中部署、使用、更新和维护模型。关于如何做到这一点，有两种可能的方法:
- 通过 RPC/REST API 公开一个模型。在这种情况下，优势在于用于构建模型的语言/基础设施也可以用于服务 RPC/REST API。缺点是对模型的每个请求都是单独的 RPC 或 HTTP 调用，有自己的延迟。延迟对查询模型所用的平均时间设置了上限。
- 在生产环境中已经可用的数据工程管道中直接使用该模型。在这种情况下，不存在额外延迟的问题，但是，最好的数据处理引擎/框架似乎不支持用于模型训练的同一组语言。例如，典型的场景是当数据科学团队使用 Python/TensorFlow 构建模型时，数据工程团队必须将其集成到 Spark/Scala/Java 堆栈中。
我将关注第二个选项，并描述如何在 Scala 中使用预先训练好的 TensorFlow 模型构建一个库。TensorFlow 已经提供了 Java API ，可以在 Scala 中直接引用和使用，但是非常低级和繁琐。
在tfmodelserving 4s GitHub repo中可以找到包含这里描述的示例的结果库。
API 代数
无标签的最终方法是用来建立图书馆。更多细节可以在这里和这里找到。这个想法是创建一个代数，它抽象了一个具体实现/解释器中使用的效果和类型。这个特征定义了 API 公开的一组操作:
F[_]是高级类型，表示具体实现使用的效果。这可能是未来的 Scalaz 任务，甚至是简单的尝试。trait 还定义了两种类型 TModel 和 TTensor。前者是一个模型类型，表示一个加载到内存中的模型，后者是一个张量类型。两种类型都必须由解释器来定义。此外，trait 定义了使用模型的几个基本操作:
-
load 用于从某个源(例如，从文件系统)加载模型。模型源是定义模型源的联产品类型:
-
元数据从加载的模型中查询模型元数据。它返回 ModelMetadata，依次枚举此图可用的签名列表。签名的概念是从 TensorFlow 借用的，它定义了一个由模型公开的函数。例如，预测模型可能会公开由其输入和输出张量定义的签名。当给定一个输入张量时，该函数产生一个输出张量，该输出张量根据输入属于特定类别的概率。如果一个图支持多个任务，它可能会公开多个签名。以下是 ModelMetadata、SignatureMetadata 和 TensorMetadata 事例类的定义:
-
张量函数从兼容的数据结构(如数组或列表)创建一个张量对象。如果为数据结构定义了隐式 TensorEncoder 类型类，则该数据结构是兼容的:
以下是 TensorEncoder 将二维数组转换为 TensorFlow API 张量对象的示例:
- eval 是实际执行图形计算的函数。它需要一个模型对象、一个输出元数据和一个映射，输入张量元数据作为键，输入张量本身作为值。它返回包装成效果 F[_]的结果张量对象。该函数还需要 TensorDecoder 和 Tensor type 的 Closeable 类型类。TensorDecoder 将一个张量对象转换成数组、列表等数据结构形式的表示。：
需要可关闭的类型类来释放非托管对象。例如，TensorFlow API 对非托管对象 tensors 进行操作，当不再需要它们时，必须显式关闭它们，否则，它们将留在内存中，这可能会导致应用程序中的内存泄漏:
就是这样。API 已定义。下一步是为 TensorFlow 实现一个“解释器”。
张量流解释程序
TensorFlow 的解释器必须实现模型服务特性。我选择了 scala.util.Try 作为一个效果，这样所有的 API 函数都将返回打包到 Try 中的结果，并且为了便于理解，可以使用 scala 来编写 API 操作。下面是解释器的实现。它完成了与 TensorFlow Java API 交互的所有脏活:
此外，我们必须定义 TensorEncoder、TensorDecoder 和 Closeable 类型类:
只有一个字符串、一维和二维数组才有编码器和解码器。这是我执行几个示例并查看它是否有效所需的基本最小值。这可以扩展到任何其他兼容的数据类型。
使用示例#1
是时候用一个简单的例子来试试这个库了。首先，必须准备一个 TensorFlow 保存模型。对于这个例子，我使用了一个计算图，它简单地将一个矩阵乘以单位矩阵。根据单位矩阵的性质，输出矩阵应该等于输入矩阵。以下是构建图表并将其保存为 TensorFlow SavedModel 格式的 Python 代码:
它用单输入(’ x ‘)和单输出(’ y ')定义签名。生成的模型目录包含序列化图形以及变量快照:
Scala 代码将输入矩阵输入到模型中并获得结果矩阵:
下面是上面的应用程序产生的输出:
使用示例#2
第二个使用示例基于我在这里描述的如何构建的狗品种分类模型。它拍摄了一张狗的图像，并产生了前 5 个品种的概率:
为样本狗图像生成的输出:
结论
构建了一个合理的 Scala 库来处理 TensorFlow 模型。它可以用于在任何 Scala/Java 应用程序(例如 Apache Spark)中使用预训练的张量流模型来执行分类、预测等。
服务 TensorFlow 模型。无服务器
之前我写过，如何用 TensorFlow 服务模型或用 Flask 包装它以提供 REST API。也可以用 Flask 直接托管模型，这在许多用例中也是非常可行的。所有这些技术都有一个共性——你需要将应用程序放在一个容器中，由你的云提供商运行它，维护一个服务器，并负责扩展。我们有 Docker 和 Kubernetes 这样的工具让我们的生活变得更轻松，但最终，你会有一个耗费金钱和时间的基础设施。
几年前，AWS 引入了无服务器应用程序的新概念，你不需要服务器来托管你的应用程序，你只需要编写一个代码，它会被调用来响应一些事件——T4。目前，它支持 Node.js、Java、Python 和 C#作为编程语言。我们也有替代方案，比如微软功能和谷歌云功能，但微软只做 Python 的实验性支持，谷歌功能仍处于测试阶段。
无服务器，是什么？
我强烈推荐马丁·福勒的这篇关于无服务器架构的文章。我不能解释得更好了。简而言之，您完全依赖提供者服务来管理服务器逻辑和状态。当然，您编写一个后端代码，但是，与传统方法不同，您在无状态容器中运行它，并将它们的管理外包出去。
拥有无服务器应用程序的想法听起来很棒——您只需创建一个后端逻辑，AWS Lambda 将调用它来响应事件。例如，一个事件可以是 REST API 调用或在 S3 桶中写一些东西。然后使用提供的 Web UI 或 AWS CLI 将代码部署到 AWS Lambda，就这样。不用担心容器、扩展和其他基础设施相关的东西；亚马逊负责所有这些。
不幸的是，它并不适用于所有用例。它非常适合微服务架构和无状态 API。这意味着，如果您需要在 REST 请求之间保存任何东西，或者拥有某些东西的全局实例(例如，已初始化并准备好进行预测的机器学习模型)，那么无服务器架构可能不是最佳选择。
服务 TensorFlow 模型无服务器？
无服务器方法对 TensorFlow 模型的服务有意义并带来优势吗？在我看来，如果你开发机器学习产品或服务，而不想在 Docker、Kubernetes 和所有这些东西上浪费时间，这是有意义的。
另一个要考虑的方面是成本。与 AWS EC2 实例不同，您是根据请求的数量和代码执行的时间来收费的。此外，如果您的代码利用其他 AWS 服务或传输数据(例如，从 S3 桶)，您也将为此付费。详细信息可以在这里找到。我想在很多情况下，AWS Lambda 会是一个更便宜的选择。
考虑
如果您决定尝试 TensorFlow 模型的无服务器服务，请考虑以下因素。
加载模型
通常，您训练模型，保存它，并在 web 应用程序启动时加载。在无服务器的情况下，您只提供一个处理请求的函数，因此，理论上，您需要在每次函数调用时加载模型。幸运的是，根据的最佳实践，你可以解决这个问题，在 lambda 函数被调用之前全局加载模型。
功能生命周期
此外，如果您在第一次函数调用之前加载您的模型，则不能保证同一个函数实例保持活动状态并处理后续调用。这意味着 AWS 可以实例化您的函数，并在每次事件发生时加载模型。然而，我的测试表明，如果后续调用之间的时间差很小(几秒钟)，实例会被重用，模型会保留在内存中。如果您预计工作量很大，那么重新加载模型将不是问题。否则，每个请求可能需要几秒钟才能得到响应。
限制
AWS Lambda 在大小和超时方面有一定的限制。请仔细检查。特别是在 TensorFlow 的情况下，您必须应用一些技巧来部署函数、加载模型和传输数据。我在下面提供细节。
履行
我创建了一个项目,演示如何使用 AWS Lambda 为 TensorFlow 模型提供服务。请随意复制、修改和用于商业和非商业目的，但我不提供任何担保和支持。在这里，我给出了一个简短的概述，并描述了模型部署的步骤和工具。
你需要什么
我假设一个知识，什么是 AWS 和如何使用它的管理控制台。开始之前，请确保您已经:
- AWS 帐户
- EC2 实例，自由层，Ubuntu 16.04
- S3 桶容纳模型和数据。
我测试了以下配置和库:
- Python 2.7
- 用于机器学习模型的 TensorFlow 1.4.0
- Boto3 1.4.7，用于从自动气象站 S3 桶传输数据
- 邮递员进行测试
- Node.js 框架和 npm
- 用于在 AWS Lambda 中部署的无服务器工具包。
准备
为了方便起见，我使用了 Anaconda ，在这里我为项目创建了 Python 2.7 环境。
- 安装 Python 库——我为 PIP 安装提供了需求文件
- 下载并安装 Node.js. npm 是安装包的一部分，不需要单独安装
- 安装无服务器工具包，以便在 AWS Lambda 中更容易地部署代码
- 或者，安装 Postman 来发布 REST 请求。
项目结构
在项目存储库中，您可以找到以下文件:
- gan_model.py :表示 gan 模型。它恢复保存到 Protobuf 模型，创建一个会话并初始化计算图。它提供了一种预测的方法
- utils.py :包含帮助函数。最重要的是用于从自动气象站 S3 存储桶传输数据的那些
- handler.py :实现一个被 AWS Lambda 调用的函数。此外，我们在这里导入预编译的依赖项(见下文)并创建模型实例
- serverless.yml :无服务器工具包部署配置
- settings.py :包含在项目范围内使用的常量
- 我只在本地测试中使用它来检查数据传输和模型功能
- requirements . txt:PIP 安装需求文件
- env_var.sh :为本地测试导出环境变量的助手脚本
- 卖主:在这里你可以找到一份自述文件。在本地，我们将额外的项目依赖项放入这个目录中进行部署。
准备项目相关性
AWS Lambda 为代码执行提供了 Python 环境。这个环境没有提供你可能需要的所有库。在我们的例子中，我们必须提供 TensorFlow、Numpy 等。并将它们与我们的代码一起部署。
问题是 AWSλ限制 —部署包大小不能超过 50 MB。但是 TensorFlow 的重量，也就是 ZIP 的重量，实在太重了。它包含了许多我们不需要的东西(TensorBoard、预编译的 Python 脚本等等)。所以我们必须运用一些技巧来克服这个障碍。我建议采取以下步骤:
- 创建并启动 AWS EC2 实例，自由层，Ubuntu 16.04 64 位
- 从终端连接到实例:
ssh <your instance name>.compute.amazonaws.com
- 将 ZIP、虚拟环境和 TensorFlow 安装到其中:
sudo apt-get update
sudo apt-get install -y zip python-dev python-pip
export LC_ALL=C
pip install --upgrade pip
sudo pip install virtualenv
virtualenv tf_env
source tf_env/bin/activate
pip install tensorflow
- 摆脱无用的东西和压缩依赖，我们需要:
touch ~/tf_env/lib/python2.7/site-packages/google/__init__.pycd ~/tf_env/lib/python2.7/site-packageszip -r ~/tf_env.zip . --exclude \*.pyc *.DS_Store /external/* /tensorflow/contrib/* /tensorflow/include/unsupported/* /tensorflow/examples/* /tensorboard/* /tensorflow_tensorboard-0.4.0rc3.dist-info/* /pip/* /pip-9.0.1.dist-info/*
- 将依赖项复制到本地计算机:
scp ubuntu@<your instance name>.compute.amazonaws.com:~/tf_env.zip <somewhere at your local machine>/tf_env.zip
- 终止 AWS EC2 实例。
现在我们有了 tf_env.zip 和部署到 AWS Lambda 的依赖项。
张量流模型准备
我们成功地开发并训练了一个模型，最终将其导出到 Protobuf 中，现在我们希望使用它进行预测。问题是——我们是将其作为部署包的一部分，还是从外部来源加载？
将模型和源代码一起部署的好处是——您将所有的东西都放在一个地方。但是有两个缺点——模型可能太大，无法通过 AWS Lambda 限制，当您更改模型时，您必须重新部署所有内容。
我强烈建议在外部保存您的模型，并从那个地方加载它。我在这个项目中做了什么:
- 当我在 Udacity 学习的时候，我用我的样本模型进行了面部生成，我用生成式对抗网络进行了训练
- 我将模型训练并导出到 Protobuf 中(我在这里描述了流程)并将模型压缩到 protobuf 文件和变量目录中
- 我创建了 AWS S3 桶，并上传了我的模型 ZIP 文件。重要说明—我的 S3 桶和 Lambda 函数在同一个 AWS 区域。这允许更快的传输和更容易的权限设置。
然后，我可以将我的模型从 S3 桶加载到我的 Lambda 函数中。
准备测试图像
Lambda 函数对街景门牌号进行预测。我决定把我的测试图像也上传到 S3 桶中，并从那里下载一个特定的图像进行预测。这意味着该函数获取桶名和图像名，下载图像并对其运行预测。
AWS Lambda 函数解释
主要的挑战是提供被 AWS Lambda 调用的函数和初始化步骤。让我们来看看 handler.py :
- 首先，我们导入标准库:
import os
import sys
import json
- 接下来，我们让 Python 环境知道，在哪里可以找到额外的项目依赖关系:
current_location = os.path.dirname(os.path.realpath(__file__))
sys.path.append(os.path.join(current_location, 'vendored'))
- 只有现在我们才能导入加载我们的模型。我们从 S3 桶加载保存的模型——详情请查看 utils.py ,非常简单。
from gan_model import GANModel
import utilsmodel_dir = utils.create_model_dir()
utils.download_model_from_bucket(model_dir)
gan_model = GANModel(model_dir)
- 我们提供一个带有特殊签名的 Lambda 函数。事件包含 AWS Lambda 提供的数据，我们希望 Python dict 在我们的例子中。上下文提供运行时信息，但是我们不在函数中使用它。
def predict(event, context):
- 下面是一个对我们函数的 REST 请求的例子。 {LambdaURL} 为无服务器安装返回的 URL， {stage} 在部署设置文件 serverless.yml 中设置。
{LambdaURL}/{stage}/predict?bucket=<your bucket>&key=<image file in bucket>
- 该函数从 S3 桶下载图像并对其进行预测:
......image = utils.download_image_from_bucket(bucket_name, key)
results = gan_model.predict(image)......
- 最后一件事是响应准备——我们提供 3 个最可能的数字，它们的概率为 JSON:
......def lambda_gateway_response(code, body):
return {"statusCode": code,
"headers": {"Content-Type": "application/json"},
"body": json.dumps(body)}......results_json = [{'digit': str(res[0]), 'probability': str(res[1])} for res in results]......return lambda_gateway_response(
200,
{'prediction_result': results_json})
就是这样。函数本身的创建要简单得多，因为所有的准备步骤都是:-)
部署
我们可以在 AWS Lambda 中使用提供的 Web UI 手动部署我们的功能，但是我强烈建议使用无服务器框架。它独立于云提供商，我鼓励您查看官方文档以了解详细信息。
首先，安装无服务器工具包:
sudo npm install serverless -g
serverless --version
您应该会看到工具包的安装版本。配置 AWS 凭证—我使用了 AWS 访问密钥。请查看官方 AWS 文档中关于管理凭证和访问密钥的内容。生成 AWS 访问密钥后，保存它们并导出到 shell 环境中:
export AWS_ACCESS_KEY_ID=<your-key-here>
export AWS_SECRET_ACCESS_KEY=<your-secret-key-here>
接下来，我们在 serverless.yml. 中定义部署配置。
- AWS 作为提供者，Python 2.7 作为执行环境:
provider:
name: aws
runtime: python2.7
- 环境变量:
environment:
TF_AWS_MODEL_ZIP_FILE_NAME: gan_model.zip
TF_AWS_MODEL_PROTOBUF_FILE_NAME: saved_model.pb
TF_AWS_S3_MODEL_BUCKET_NAME: <bucket name that holds the model>
- Lambda 函数执行角色的 AWS IAM(身份和访问管理)策略。它必须被添加以允许函数访问 S3 桶，在那里我们保存我们的模型和测试图像。以下是我的设置:
iamRoleStatements:
- Effect: “Allow”
Action:
- "s3:GetObject"
Resource:
- "arn:aws:s3:::vb-tf-aws-lambda-model"
- "arn:aws:s3:::vb-tf-aws-lambda-model/*"
- "arn:aws:s3:::vb-tf-aws-lambda-images"
- "arn:aws:s3:::vb-tf-aws-lambda-images/*"
- 要响应的处理函数和事件—在我们的例子中是 HTTP GET 请求。当 AWS Lambda 收到请求时，它调用我们的函数来获得响应:
functions:
predict:
handler: handler.predict
events:
- http:
path: /predict
method: get
现在只需从终端执行部署命令…
cd <project root>
serverless deploy
…然后等到一切都部署完毕。在终端中，您会看到一个部署日志和关于已部署服务的信息。具体来说，您可以看到端点和函数:
endpoints:
GET — [https://<address>.amazonaws.com/dev/predict](https://9cspjk5fg6.execute-api.us-west-1.amazonaws.com/dev/predict)
functions:
predict: tensorflow-lambda-gan-dev-predict
如果要从 AWS 中删除该功能，请执行以下操作:
serverless remove
试验
对于测试，我使用 Postman，但是如果你愿意，你也可以使用你的浏览器。
现在我们得到了与这里的和这里的相同的结果，但是没有创建 Docker 容器，使用 Kubernetes 进行缩放，最终使用 Flask 进行服务。
结论
一开始，我相当怀疑预测服务的无服务器部署是否可行和有意义。我首先关心的是 Lambda 函数实例的重用——我们不希望每次收到请求时都重新加载模型。第二个问题是——我们如何克服 Lambda 限制，并使用 TensorFlow 这样复杂而庞大的库。
在做了一些研究并阅读了一篇非常有帮助的文章之后，我能够解决第二个问题。我的测试表明，在恒定负载下，函数被重用，模型很少被重载。
我的印象是——AWS Lambda 加快了开发周期，因为我们不关心容器化、缩放和应用服务器。一切都由云提供商管理。你可以快速上传一个新版本的模型，如果你使用 S3 桶来存储它。我没有展示这一点，但是对 S3 桶中模型的更新做出反应是可能的——这是一个可以由 Lambda 函数处理的额外事件。
另一方面，当 AWS 删除一个函数实例时，这是不可预测的。如果您的服务没有被广泛使用，那么每个请求需要几秒钟而不是几毫秒，这是事实。如果你能忍受，那很好，否则，你应该建立一个预热机制来模拟负载。
另一个方面——目前，将 TensorFlow 依赖项引入 AWS Lambda 确实很棘手。我个人不喜欢这样的黑客。
由于 TensorFlow 对于无服务器架构的不可预测性和未就绪性，我仍然倾向于在生产环境中使用全服务器方法。
更新 2018 年 10 月 26 日
最初，我使用 TensorFlow 1.4.0 作为我的预测函数的依赖项。从那时起，谷歌团队对 TensorFlow 框架进行了重大更新，我们必须稍微改变项目依赖性，为绕过 AWS Lambda 限制做准备。在 virtualenv 中安装 TensorFlow 后，我们执行以下命令
touch ~/tf_env/lib/python2.7/site-packages/google/__init__.pycd ~/tf_env/lib/python2.7/site-packagesfind . -name "*.so" | xargs stripzip -r ~/tf_env_l.zip . --exclude \*.pyc *.DS_Store /external/* /tensorflow/contrib/* /tensorflow/include/unsupported/* /tensorflow/examples/* /tensorboard*/* /pip*/* /setuptools*/* /wheel*/* easy_install*
创建具有所需依赖项的 ZIP 文件。最值得注意的动作是对所有目标文件执行剥离。这允许显著减小它们的尺寸。此外，我稍微清理了一下 zip 命令的参数。我用 TensorFlow 1.11.0 测试了一下，效果和预期一样。
Source: Google
从数据中设定面包店的促销策略
知道如何处理数据并提出正确的问题非常重要。在商业中，知道如何处理这些结果是至关重要的。第二步包括将图表、表格或统计数据从描述性的(“告诉我发生了什么”)转换为说明性的(“告诉我该怎么做”)。
出于这个原因，我们将经历一个基于数据发现来制定策略的项目。我们拥有的关于数据的唯一上下文是，它是来自面包店的交易数据。上面有号码、日期、时间戳和购买的物品。下面是一个快照:
我们的目标是增加已经在我们面包店销售给顾客的商品总量。
我们关注的是产品数量和收入，因为面包店通常有较高的固定成本和稳定的营业时间，这意味着增加对现有客户的高利润产品(如咖啡、面包、茶)的销售会带来更高的盈利能力，因为这些成本中的更多成本都可以在不增加劳动力、工时或空间的情况下得到弥补。如果我们有收入和盈利能力数据，我们可以在分析的基础上再增加一层，以模拟我们的战略对盈利能力的影响。
正如我将在下面的调查结果中详述的那样，我们实现该面包店目标的策略应该是:
- 在工作日上午 12 点之前，我们应该为顾客选择的**热饮(茶、咖啡或热巧克力)和早餐(吐司、蛋糕、松饼)**提供捆绑折扣。
- 在工作日的下午，我们应该提供:买一个三明治，喝茶可以打五折。
- 周末，购买任意两件商品，第三件商品打 7.3 折。
完整项目代码， 请点击此处 。
探索性数据分析
让我们从更好地理解数据开始。具体来说，我们想知道按商品购买的频率，以及这一频率在一天中的不同时间会如何变化。我们可以将所有这些信息简洁地嵌入到交互式条形图中:
Note: For conciseness, I’ve limited to the top selling items for each time period.
接下来，我们可以通过点击下图右上角的“播放”按钮来查看销售趋势。
显而易见，我们可以看到销售呈现出上升和下降的循环模式。让我们看看星期几能否解释这种差异:
事实上，看上面的两张图表，我们可以看到周末似乎可以解释大部分的价格上涨。
最后，我们将了解销售商品的数量如何随着一天中的时间、一周中的每一天以及一天中的每个小时而变化。
上述内容有助于我们进行剩余的分析，让我们了解最受欢迎的商品，以及这些商品在一天中的不同时间是如何变化的，并告诉我们应该制定一个策略，将一周中的不同日子和/或一天中的不同时间的销售差异考虑在内。
设定策略
现在我们对数据及其分布有了更好的理解，我们可以进入使用数据为决策提供信息的阶段。
在我们的战略发展中，有几个指导原则需要考虑:
- 我们希望增加出售的商品数量，以此来激励那些不会购买的商品。
- 我们应该考虑那些我们知道会改变客户与我们互动方式的变量(例如，一天中的时间和一周中的日期)。
- 最终输出应该提供如何行动的明确指示，为什么这一行动过程是可取的，它不应该对客户太混乱，也不应该对操作员太复杂。
通过交易数据，我们希望更好地理解下面的问题:购买哪些商品会导致购买哪些其他商品？
为了使这一点更加明确，我们想知道，例如，与任何顾客购买松饼的可能性相比，购买咖啡是否意味着顾客更有可能也购买松饼。
对于这类问题，有一种经过充分研究的方法，它被称为 Apriori 算法，它有三个主要组成部分:支持、信心和提升。
Apriori 帮助我们理解，对于一对物品，物品 2 被购买的频率(支持)，如果物品 1 被购买，物品 2 被购买的可能性(置信度)，以及在物品 1 被购买的情况下物品 2 被购买的比率的增加(提升)。
(更多阅读， 这是一篇优秀的文章 )。
考虑到这些，我们对如何解决这个问题有一些考虑:
- 我们可以寻找这样的项目对，其中项目 1 具有高支持度(即频繁购买)，项目 2 具有低支持度，但是这两者具有高的组合寿命(购买项目 1 时，更频繁地购买项目 2)。
- 我们可以寻找支持度较低但提升力较高的商品(例如，我们希望鼓励购买商品 1，这种商品不经常购买，但会引发其他购买)。
- 我们可以寻找两种或两种以上经常单独购买，但不经常一起购买的产品，并将它们捆绑在一起，为客户提供更具吸引力的产品。
例如，我们将使用上述内容来考虑如何设置折扣(“以 50%的折扣购买项目 1 并获得项目 2”)或捆绑产品选项(“以低于项目 1 +项目 2 的价格获得项目 1 和项目 2”)。
同样，在日历层面，我们有几个问题需要考虑:
- 我们是否应该尝试在历史上销售额较低的日子(即周中)提高销售额？
- 我们是否应该在交易量已经较高的日子里尝试销售更多产品，因为我们的初始客户群较高(如周末)？
- 知道我们的交易量每小时都不一样，我们是否应该以一天中的时间为目标？
让我们绕一小段路，看看这些概念是如何实现的。下面我分享了我的 Dunkin Donuts 应用程序的 DDPerks 屏幕截图。让我们看看他们在宣传什么，为什么:
首先，我们看到打折的卡布奇诺或拿铁，但只有当我在下午 2 点到下午 6 点之间去的时候，他们才试图鼓励在特定的时间窗口访问，否则(可能)会有较低的销售额。
第二，有两个早餐三明治的价格降低到了 5 美元> DD’s 正在采用产品捆绑来增加总订单价值。
最后，如果我在周三使用他们的移动订购功能，可以获得 2 倍的积分。该公司鼓励某种类型的行为来展示产品功能，并可能更好地管理商店内的订单流。
此外，这些可能会根据位置和我与应用程序的交互进行个性化——我购买了什么以及购买的频率。如果你有这个应用程序，你的报价会有所不同吗？
战略
当评估 Apriori 算法的结果时，结合领域知识，我们可以采用以下策略:
- 在工作日上午 12 点前，以低于两者加起来的价格获得您选择的任何热饮(茶、咖啡或热巧克力)和早餐(烤面包、蛋糕、松饼)。
- 在工作日的下午，买一个三明治，喝茶可以打五折。
- 周末，买任意两件，第三件 33 折。
为什么？
关于第一点，我们知道，在工作日早晨，几乎所有推动最高提升(销售比率增加)的购买都是热饮和早餐的组合(见下表)。因为我们的结果因饮料和食物类型而异，这个选项足够宽泛，不会限制选择，也不会缩小这个选项的市场。此外，我们知道至少 70%的早上交易都是购买热饮**，这给了我们强大的初始购买基础。**
Apriori results for weekday mornings
对于工作日的下午，我们希望刺激原本不会发生的购买行为。为此，我们将查看具有最高综合升力的项目。结果依次是茶、咖啡和三明治。下午，三明治和茶卖得很好，但它们不常一起买。茶占交易的 17%,三明治占 12%,但它们合起来仅占交易的 2.5%。因此，考虑到茶也很受欢迎，但不是在购买三明治时，我们想要创建购买三明治(更高价值的项目)。我们希望创造这种多产品购买，这在历史上一直是一个单一的购买。
最后，对于周末，我们发现，相对于平日，有更多的多购买交易，推动购买第三个项目。
周末前 10 大购物驱动因素中有 50%是两件商品的前因，相比之下，工作日早上的这一比例为 20%
当有人已经买了两件东西，我们希望他们再买第三件，这在周末似乎更有可能。因此，我们可以想出一个朗朗上口、简单易懂的促销方式，比如“买两件，第三件打 33 折。”
Apriori results for weekends; note the 5 multi-item antecedents in the top 10.
测量结果
为了总结这些发现，我们希望实施这些策略，并在一段时间内测量结果。我们特别想看看上午平均门票大小的变化，下午组合茶和三明治的销售，以及周末每笔交易的商品数量。我们将寻找在每个细分市场中销售的商品数量是否有统计上的显著差异。
如果我们做到了，太好了！我们的策略奏效了，我们可以每隔几个月重新审视购买习惯和产品供应，以确定如何调整折扣和促销。
如果没有，没什么大不了的，我们可以重新设置为无折扣的基本情况，然后重新研究数据并与客户交谈。毕竟，测试和学习是在找到有效方法之前进行迭代和调整的重要方式。
即使它最初显示出积极的结果，战略和执行是持续的。我们不能因为它有效就假设它会永远有效。我们也不能因为它不起作用就认为它不是正确的行动方向。
结论
从分析转移到策略是具有挑战性的，因为你从确定的领域(“我看到这种情况发生”)转移到不确定的领域(“根据我看到的，我认为这种情况会发生”)。也就是说，在一个日益信息化的世界里，对批判性思维和数据解释的需求正在快速增长。
数据与领域专业知识和客户互动相结合，是一种经过检验的方法，可以为战略提供信念，并最终为从面包店到财富 500 强公司的每个人带来更好的业务成果。
如果您有任何想法或反馈，我希望在 jordan@jordanbean.com 或通过 LinkedIn 收到您的来信。
在 AWS 上设置和使用 Jupyter (IPython)笔记本电脑
If you are having trouble following this tutorial or want to use JupyterHub on AWS, I made an updated tutorial (YouTube, blog).
前阵子写了一个帖子，“在 AWS 上启动一个 Jupyter (IPython)笔记本服务器”。虽然这种方法允许多人只需一个密码就能访问服务器，但设置起来很复杂。大多数人只是想使用 Jupyter 笔记本使用他们的 AWS 资源，没有麻烦。有了这个，你就可以这么做了。
在 AWS 上启动 Jupyter 笔记本
- SSH 到您的 EC2 实例。如果你不知道如何做，或者想要参考，请参见本教程。
SSH Command used in the Video
2.确保您已经安装了 Anaconda。如果你还没有安装，你可以使用这个教程来安装。
3.在终端中键入以下命令:
jupyter notebook --no-browser --port=8888
Expected Output of running the previous command
我们添加“—无浏览器”的原因是因为如果我们不这样做，您可能会得到类似“Jupyter Notebook 需要 JavaScript”的错误。说了这么多，如果你得到那个错误，你可以通过按Q忽略错误，然后按Y确认。
SSH 到你的 Jupyter 笔记本
4.打开一个新的终端，SSH 到你的 Jupyter 笔记本。您的命令应该类似于下面的命令。如果不知道怎么做，请看教程。
ssh -i thisIsmyKey.pem -L 8000:localhost:8888 ubuntu@ec2–34–227–222–100.compute-1.amazonaws.com
-i指定用于公钥认证的备用标识文件。基本上对于本教程，我有我的关键在当前目录。
-L指定本地(客户端)主机上的给定端口将被转发到远程端(AWS)上的给定主机和端口。这意味着无论在 AWS 的第二个端口号(即8888)上运行什么，都会出现在本地计算机的第一个端口号(即8000)上。你应该把8888换成 Jupyter 笔记本运行的端口。99.9%的时间 Jupyter 将在端口 8888 上运行。可选地将端口8000更改为您选择的一个端口(例如，如果8000被另一个进程使用)。
5.打开浏览器，转到 localhost:8000
You should get something similar to this
6.(可选)如果你想使用不同的 conda 环境(包括在 Jupyter 笔记本中同时访问 Python 2 和 Python 3 环境的能力，请参见本教程)。
如果你有任何问题，请在这里，在 youtube 视频页面，或者通过 Twitter 告诉我！
在 AWS 中建立深度学习工作站
这是在 AWS 中设置机器的一步一步的指南，该机器可以执行复杂的深度学习任务，如图像分类或面部识别。
为什么不是我自己的机器
我也有同样的问题，直到我看到运行一个基本图像分类的算法有多慢。像张量流或 Theano 这样的深度学习框架在 CPU 上工作，但它更适合 GPU 计算。与 CPU 相比，算法在 GPU 中运行更快。
关于 CPU 与 GPU 的更多信息:
在本教程中，我们将在 TensorFlow 中进行简单的矩阵乘法，并将 GPU 的速度与
medium.com](https://medium.com/@erikhallstrm/hello-world-tensorflow-649b15aed18c)
有鉴于此，亚马逊提供了一个每小时 0.90 美元的 GPU 系统，它可以用来运行算法和机器来与所有的预配置。这里是一步一步的信息。
登录 Aws 后，从侧面菜单中选择 Ec2
选择启动实例。亚马逊提供所有必要的软件并维护它。我们可以从 Aws MarketPlace 中选择机器映像
镜像名称:深度学习 AMI 亚马逊 Linux 版
这将为您提供以下屏幕
选择图像，然后单击下一步选择 GPU 计算。
这一步将花费你 0.90 美元。但是有一些有趣的方法可以通过改变训练和测试之间的实例来降低成本。稍后会详细介绍。
您可以单击“下一步”,直到配置安全组，然后添加新安全组。
就是这样！！点击查看并启动。可以配置运行深度学习的机器。
有可能你可能会得到错误说，请求限制超过。您可以向 AWS 提出请求来解决这个问题。
要启动实例，请单击“连接”按钮，并按照说明进行操作。
通过最后一步，你就拥有了一台包含深度学习所需所有东西的机器。要使开发人员工具易于使用，还需要几个步骤。我的意思是，你必须配置 Jupyter 笔记本电脑，以便在外面可以方便地访问。
在命令中连接后，执行以下步骤
代码块的最后一行会生成这样的 SHA 键
sha1:806d 23 d9 C1 c8:2 da 90 b 513 b 6 AE 2 a 941 a 4 bdcf 6843 a3 A0 ea 5a 7
复制并保存在记事本中
然后回到终端类型
vi ~/。jupyter/jupyter _ notebook _ config . py
如果你不是 Vi 人，记住你需要按 I 开始插入内容，当你完成时，你可以点击然后最后退出 Vi esc :wq enter，同时保存你的更改(代表 write-quit)。
将密码更改为您在之前的步骤中复制的生成的 SHA1 密钥。
更新 Keras
Keras 会在 1。x 版本，但是很容易用一个简单的命令升级
sudo pip 安装 keras —升级—无 deps
现在您已经升级了，您可以通过以下方式启动 Jupyter 笔记本
Jupyter 笔记本
这将运行 jupyter 笔记本，可通过公共 IP 在互联网上访问。你可以在下面找到公共 IP
一旦完成，你可以创建一个空的笔记本和类型。
现在这一步已经完成了。你可以创造一个更好的世界。
在 Google Colab 中设置 Kaggle
一个简单的新手教程
我要所有的数据，现在就要！
Photo by Logan Fisher on Unsplash
你知道所有这些数据集在哪里，你也知道你想让它们去哪里，但你如何轻松地将你的数据集从 Kaggle 移动到 Google Colab，而没有很多复杂的疯狂？
让我给你看看！
发现快乐是 Google Colab 绝对是我开始深度学习、机器学习和人工智能以来所做的最聪明的事情之一。Google Colab 提供免费 GPU(真的！)卖给几乎所有想要的人。如果你刚刚开始，你需要上 Colab！我写了另一篇文章介绍第一次在 Colab 中设置，但是在 Colab 中设置和运行 Kaggle 真的应该有自己的文章。
Photo by Oscar Söderlund on Unsplash
尽管 Colab 非常用户友好，但在设置时，您可能需要一些细节方面的帮助。
事实证明，Kaggle 就是这些细节之一。
卡格尔需要一点技巧。一点爱。然而，如果你在寻找那些可爱的数据集，你会想要得到它！其实真的很简单；你只需要采取几个简单的步骤。如果您只想查看 GitHub 上的代码，然后继续您的一天(这里的事情可能会变得有点…冗长……),欢迎您这样做！
下面是我发现的第一次访问 Kaggle 数据的最简单方法:
入门
(一个小提示:为了能够访问 Kaggle 数据，你需要注册 Kaggle(免费！)并同意您想要参加的竞赛的条款和条件。)
首先，从卡格尔那里拿到你的令牌。
转到您的帐户页面(屏幕右上角的下拉菜单会带您到那里)。
然后向下滚动到 API 并点击“创建新的 API 令牌”
那就要下载一个名为 kaggle.json 的文件。确保您知道该文件在哪里！也许把它放在你能找到的地方…
只是一个建议。
打开该文件，您会看到类似如下的内容:
{“username”:”YOUR-USER-NAME”,”key”:”SOME-VERY-LONG-STRING”}
为将来的复制和粘贴准备好那个东西！
接下来，去 Colab 开始一个新的笔记本。我非常喜欢立即在 GPU 上运行，为此，请进入“运行时”下拉菜单，选择“更改运行时类型”，然后在“硬件加速器”下拉菜单中选择 GPU。然后点击保存。
接下来，您需要安装 Kaggle。这几乎就像把它安装在你的 Jupyter 笔记本上一样，但是 Colab 希望在你的代码开头有一个感叹号。只需运行:
!pip install kaggle
你可以使用!ls来检查你是否已经有一个名为 Kaggle 的文件夹，或者直接运行
!mkdir .kaggle
去创造一个。
接下来，您需要运行下面的单元格，但是请注意几件事情:
- 这个没有感叹号
- 你肯定想把用户名和密码改成你从下载的 Kaggle 文件中复制粘贴的那个！
import jsontoken = {“username”:”YOUR-USER-NAME”,”key”:”SOME-VERY-LONG-STRING”}with open('/content/.kaggle/kaggle.json', 'w') as file:
json.dump(token, file)
我在运行这段代码时进行了复制粘贴，实际上遇到了一点麻烦。我不知道为什么，但我不得不删除并重新键入上面代码中的单引号，以使该单元格正常运行。如果您莫名其妙地弹出一个错误代码，那就试试吧！
接下来，运行
!cp /content/.kaggle/kaggle.json ~/.kaggle/kaggle.json
然后
!kaggle config set -n path -v{/content}
您将会得到一个类似如下的警告:
您可以通过运行以下命令轻松解决这个问题:
!chmod 600 /root/.kaggle/kaggle.json
在那之后，你应该能跑了
!kaggle datasets list
访问 Kaggle 数据集列表。
如果您正在寻找一个特定的数据集，您可以运行类似
!kaggle datasets list -s sentiment
以便列出例如标题中包含“情感”的数据集。
现在是时候开始享受真正的乐趣了！
下载数据
去 Kaggle，找到你想要的数据集，在那个页面上，点击 API 按钮(它会自动复制代码)。
您将把代码粘贴到下一个单元格中，但是要确保在单元格的开头添加感叹号，并添加-p /content来阐明您的路径。
!kaggle datasets download -d kazanova/sentiment140 -p /content
要解压缩文件，运行
!unzip \*.zip
欢迎来到数据镇！！！想看看吗？尝试跑步:
import pandas as pdd = pd.read_csv('training.1600000.processed.noemoticon.csv')d.head()
(当然，用数据集中的文件名替换上面的文件名。)
现在走出去，创造一些惊人的东西！
Photo by Fidel Fernando on Unsplash
如果有人用他们新得到的数据做了一些非常棒的事情，我想听听他们的想法！请在下面的回复中让每个人都知道你创造了什么，或者随时在 LinkedIn @annebonnerdata 上联系！
你可能也想看看我的其他一些文章！
Git 和 GitHub 基础知识，供好奇和完全困惑的人使用(加上最简单的方法来为您的第一次公开…
towardsdatascience.com](/getting-started-with-git-and-github-6fcd0f2d4ac6) [## 如何用 GitHub 毫不费力地免费创建一个网站
GitHub Pages 入门:创建和发布免费作品集的快速简便指南…
towardsdatascience.com](/how-to-create-a-free-github-pages-website-53743d7524e1) [## Google Colab 入门
沮丧和困惑的基本教程
towardsdatascience.com](/getting-started-with-google-colab-f2fff97f594c) [## 深度学习简介
新手、新手和新手的神经网络。
towardsdatascience.com](/intro-to-deep-learning-c025efd92535) [## 如何构建准确率高于 97%的图像分类器
清晰完整的成功蓝图
medium.freecodecamp.org](https://medium.freecodecamp.org/how-to-build-the-best-image-classifier-3c72010b3d55) [## 数据清理和预处理完全初学者指南
如何在几分钟内为机器学习模型成功准备数据
towardsdatascience.com](/the-complete-beginners-guide-to-data-cleaning-and-preprocessing-2070b7d4c6d) [## 出色的模型部署初学者指南
一个清晰简单的路线图，让你的机器学习模型在互联网上，做一些很酷的事情
heartbeat.fritz.ai](https://heartbeat.fritz.ai/brilliant-beginners-guide-to-model-deployment-133e158f6717)
为数据分析设置我的第一个 Amazon Web Services (AWS)虚拟服务器
今天终于加入了 AWS 的列车。作为我正在为一个客户进行的大数据分析项目的一部分，我需要托管一个云服务器来从 Twitter 和 Google 上挖掘数据，每天将它们保存在一个 CSV 文件中。通常，我会使用我的笔记本电脑作为这项任务的服务器，但由于这是一个商业项目，我可以将成本转嫁给客户，我必须使用一个可靠的负担得起的虚拟服务器。然后我去谷歌上搜索。我不想用微软 Azure，因为我的支付系统有问题，而且我听说 Azure 对于一个非常小的企业来说不是最好的口袋友好型选择。我偶然发现了阿里云服务，但不久我就接受了亚马逊网络服务。
设置真的很容易；比我想象的要容易，因为网上普遍认为 AWS 不像 Azure 那样简单易用。现在经历了这两者，我不同意。
我使用了 EC2 服务并创建了一个 t2-micro Windows Server 2012 R2 实例。
在通过远程桌面连接连接到服务器时，我为我的数据分析工作设置了它。我安装了微软 R Open 和 RStudio 用于我基于 R 的数据分析工作。我为我基于 Python 的分析工作安装了 Anaconda 和 PyCharm 。下面是我的服务器设置的样子。
我甚至把我常用的工具钉在了任务栏上——Powershell、任务调度器、RStudio 和 PyCharm。
剩下的问题是如何估算我每月的花费，以及我是否需要自动启动/关闭服务器以节省计算时间/成本。启动/关闭决定的某些方面将取决于 Twitter 是否批准我不受限制地访问他们的 Tweet 数据库的请求，并且不收取我一些疯狂的费用。我已经提出了请求，他们要求我向他们提供一些信息，他们将使用这些信息来决定是否批准我的请求。我目前绕过每 15 分钟可以抓取多少条推文的限制的方法是每三个小时运行一次报废脚本，但我仍然认为我没有获得足够多的代表性推文，一些推文不断重复显示。
总的来说，我喜欢深入数据分析的新冒险。我会一直让你们知道我的进步，分享我的学习成果。
最初发表于【www.olafusimichael.com】。
在 r 中为文本挖掘设置 Twitter。
Photo Credit : Pixabay
介绍
多年来，社交媒体已经成为数据挖掘的热点。每天都有话题趋势、活动进行和人们讨论不同的全球、大陆或国家问题。这是利用数据的一个主要目标。
在这篇文章中，我们把 Twitter 作为全球观点和情感的中心。我们开始从每天发布的数百万条推文中挖掘文本，以便能够理解正在发生的事情，甚至超越我们自己的时间线。
Twitter API 设置
要使用 twitter API，我们需要有一个 twitter 帐户。
通过https://twitter.com注册，前往https://apps.twitter.com/访问 twitter 开发者选项。
Click create New App
创建新的应用程序
**应用程序名称:**给你的应用程序一个唯一的名称。如果被占用，将通知您进行更改。
**应用程序站点:**如果你的应用程序还没有站点，这可以是一个到你的 Github 存储库的链接，应用程序代码就在那里。(像我一样)
回调 URL: 这是一个链接，成功或失败的消息从一个程序中继到另一个程序。它告诉程序在这两种情况下下一步去哪里。您可以将您的应用程序定向到任何可用的端口，我的端口是 1410。
应用凭据
这些对于帮助用户登录应用程序非常重要。
此设置中使用了四种主要凭证。
**消费者密钥:**该密钥向应用程序标识客户端。
**消费者密码:**这是用于服务器验证的客户端密码。
**访问令牌:**这是用来定义用户权限的用户标识。
**访问密码:**这是用访问令牌作为密码发送的。</李>
他们就是这样获得的。
App credentials
Generating Tokens
App Tokens
注意:这些证书应该是保密的，这就是为什么我在我的证书上画了阴影。瞧吧！我们设置了一个 API
r 工作室成立
R 使用了 twitteR 库，这是一个基于 R 的 twitteR 客户端，处理与 Twitter API 的通信。让我们花点时间感谢杰夫·金特里把这个图书馆建起来。
现在继续使用下面的代码安装这个库。
#from CRAN
install.packages(“twitteR”)#alternatively from the Github
library(devtools)
install_github(“geoffjentry/twitteR”)
上述两种方法的区别在于，第一种方法从 CRAN 站点下载包，并接受包名参数，而第二种方法从 GitHub 库安装包，并接受库名参数。点击阅读更多关于软件包和安装的信息。
证明
Twitter 使用开放认证(OAuth)来授权访问信息。开放式身份验证是一种基于令牌的身份验证方法。我们来参考一下我们的四个凭据。
第一步
#load library
library(twitteR)#load credentials
consumer_key <- “****************”
consumer_secret<- “*******************”
access_token <- “*******************”
access_secret <- “************************”
第二步
我们使用 setup_twitter_oauth 函数来设置我们的认证。 setup_twitter_oauth() 函数接收我们从上面设置的 API 生成的四个 twitter 凭证。
#set up to authenticate
setup_twitter_oauth(consumer_key ,consumer_secret,access_token ,access_secret)
请按键盘上的 Y 键授权直接认证。
查询 Twitter
质疑就是简单地问一个问题。为了能够访问我们需要的数据，我们必须向 twitter 发送有意义的查询。有了 Twitter，我们可以获得从趋势、活动到账户的大量信息。我们有一系列的问题要问。
让我们在这个标签#rstats 上运行查询
#fetch tweets associated with that hashtag , 12 tweets-n in
#(en)glish-lang since the indicated date yy/mm/ddtweets <- twitteR::searchTwitter(“#rstats”,n =12,lang =”en”,since = ‘2018–01–01’)#strip retweets
strip_retweets(tweets)
这段代码以列表的形式返回推文。 strip_retweets() 函数删除返回的 tweets 中的任何 retweets。
为了进一步分析这些推文，我们将考虑将返回的推文转换为数据帧，并在本地存储它们。
#convert to data frame using the twListtoDF function
df <- twListToDF(tweets)\#extract the data frame save it locally
saveRDS(df, file=”tweets.rds”)
df1 <- readRDS(“mytweets.rds”)
清理推文
通过查询，我们已经设法将结果存储到计算机上的数据框中。现在让我们检查这些数据，找出谁的转发量最高，并直接从我们的脚本中给他们一个大喊。
我们将使用 dplyr 库遍历该数据帧。
library(dplyr)#clean up any duplicate tweets from the data frame using #dplyr::distinctdplyr::distinct(df1)
让我们利用 dplyr 动词来选择转发次数最多的 tweet 的 tweet、昵称、id 和转发次数，并将结果存储在一个名为 winner 的数据帧中。
winner <-df1 %>% select(text,retweetCount,screenName,id )%>% filter(retweetCount == max(retweetCount))
View(winner)
通过此备忘单查看更多关于 dplyr 的信息。
发送直接信息
为了通知我们的转发竞赛获胜者，我们将通过从获胜者数据帧中选取他们的句柄，从该脚本中向他们发送一条直接消息。
**DM send()**函数接收保存为屏幕名称的消息和用户名。
us <- userFactory$new(screenName= winner$screenName)
dmSend(“Thank you for participating in #rstats,Your tweet had the highest retweets” , us$screenName)
结论
我们刚刚从 twitter 中创建了第一个挖掘数据集，并使用它来找出我们的转发比赛获胜者。嗯，这只是我们能做的一个小例子，然而，有一个专栏包含来自挖掘的推文的文本，可以使用这个博客上以前文章的技术来分析这些文本。
这种挖掘的数据有更多的可能性，如情感分析和词频可视化。
我建议你通过这个 GitHub 库查看一个 twitter 文本挖掘的实例。
关于本文的任何进一步的问题和评论，请通过 twitter 问我 @lornamariak 。
微博挖掘快乐！
在 5 分钟内设置您的数据科学和人工智能开发环境
Kaggle、TensorFlow、PyTorch、MxNet 等等，只需几步！
Using datmo to get a new TensorFlow project setup in under a minute
无论您是第一次设置 TensorFlow 的数据科学爱好者新手，还是处理万亿数据的经验丰富的人工智能工程师，安装您的库、包和框架总是一场斗争。
虽然像 Docker 这样的容器化工具真正革新了软件的可复制性，但它们还没有在数据科学和人工智能社区中流行起来，这是有充分理由的！随着机器学习框架和算法的不断发展，很难找到时间来学习另一种开发工具，尤其是与模型构建过程没有直接联系的工具。
在这篇博文中，我将向您展示如何使用一个名为datmo的简单 python 包来为任何流行的数据科学和人工智能框架设置环境，只需几个简单的步骤。Datmo 利用 Docker 并简化流程，帮助您快速轻松地运行。
0.先决条件
- 安装并启动和 Docker 和
- (如果使用 GPU)安装 CUDA 9.0 (此处提供替代指南)
- (如果使用 GPU)安装NVIDIA-docker(步骤 3)
1.安装 datmo
就像任何 python 包一样，我们可以使用以下命令从您的终端安装 datmo:
$ pip install datmo
2.初始化 datmo 项目
在你的终端中，cd到你想要开始建立模型的文件夹中。然后，输入以下命令:
$ datmo init
然后你会被要求为你的项目取一个名字和描述——你可以随意命名它！
3.开始环境设置
在名称和描述之后，datmo 将询问您是否想要设置您的环境——键入y并按下enter。
4.选择系统驱动程序(CPU 或 GPU)
然后，CLI 将询问您的环境需要哪些系统驱动程序。如果你不打算使用 GPU，选择cpu。
Select system drivers
5.选择一个环境
接下来，您将从众多预打包环境中选择一个。只需在提示中给出您想要使用的环境的编号或 ID。
Select an environment
6.选择语言版本(如果适用)
根据您计划使用的语言和版本，上面的许多环境都有不同的版本。
例如，在选择了keras-tensorflow环境后，我会看到下面的提示，询问我是想使用Python 2.7还是Python 3.5。
Select a language version
7.启动您的工作区
您已经正确选择了您的环境，现在是时候启动您的工作区了。选择您想要使用的工作区，并在您的终端中输入相应的命令。
Jupyter 笔记本— $ datmo notebook
木星实验室— $ datmo jupyterlab
RStudio — $ datmo rstudio(在 R-base 环境中可用)
终端— $ datmo terminal
Opening a Jupyter Notebook and importing TensorFlow
你已经准备好了！第一次为新环境初始化工作空间时，需要花费一些时间来获取所有的资源，但是在连续运行时会明显加快。
一旦您的工作空间启动，您就可以开始导入包含在您选择的环境中的包和框架了！例如，如果用户选择了keras-tensorflow环境，那么import tensorflow将在您的 Jupyter 笔记本中开箱即用！
如果你正在使用 TensorFlow，你可以试试 datmo 文档中的这个例子来运行你的第一个 TensorFlow 图。
感谢您的阅读，我们希望您的软件环境设置变得更加简单！
我们的使命是最大限度地利用数据科学家从事数据科学的时间。
如果你想帮忙投稿、报告问题或请求功能，你可以在 GitHub 这里找到我们！
为 AI 设置 Visual Studio 代码工具
微软刚刚在去年 9 月的微软 Ignite 2017 上推出了一套与人工智能相关的新工具，其中一个工具就是Visual Studio Code Tools for AI。
Visual Studio Code Tools for AI是一个构建、测试和部署深度学习/人工智能解决方案的扩展。它与 Azure Machine Learning 无缝集成，提供强大的实验功能，包括但不限于向不同的计算目标透明地提交数据准备和模型训练作业。
对于需要开发人工智能解决方案的开发人员来说，这实际上是一个有用的工具，同时仍然使用他们选择的代码编辑器，在我的例子中是 Visual Studio 代码。
入门指南
在我们真正开始用 VS 代码安装和设置扩展之前，我们首先需要创建一个 Azure 机器学习实验帐户和 Azure 机器学习模型管理帐户，这将允许我们稍后在 VS 代码中使用 sample explorer 创建一个项目。
登录到 Azure 门户网站
第一步是在 portal.azure.com 的登录你的 Azure 账户。如果你没有 Azure 账户，你可以点击这里获得免费试用。
创建一个 Azure 机器学习实验和模型管理帐户
进入 Azure 门户后，请执行以下操作:
- 点击“+新建”按钮
- 搜索“机器学习实验”
3.点击“创建”
4.填写机器学习实验信息
5.单击“Create ”,您应该能够看到服务已成功创建
要记住的事情:
- 如果您还没有“创建模型管理帐户”,请确保选中该帐户。
- “座位数”基本上是你可以添加到你的实验账户的 Azure 用户总数。
- 一个套餐只能有一个“DevTest”定价层的计划。
- 目前支持的位置是澳大利亚东部、美国东部 2 和美国中西部。
安装 Azure 机器学习工作台
一旦我们有了 Azure 机器学习实验和模型管理帐户设置，接下来我们要做的就是安装 Azure 机器学习工作台。
Azure Machine Learning work bench是一个桌面应用程序加上命令行工具，在 Windows 和 macOS 上都受支持。它允许您在整个数据科学生命周期中管理机器学习解决方案。
目前，Azure 机器学习工作台桌面应用程序只能安装在以下操作系统上:
- Windows 10
- Windows Server 2016
- macOS Sierra(尚不支持 macOS High Sierra)
注意:Azure Machine Learning Workbench 还将下载并安装其他相关组件，如 Python、Miniconda、Azure CLI 等。
要安装 AML 工作台，您可以单击最近创建的机器学习实验服务，您应该能够看到以下内容:
然后，您只需点击您正在使用的特定操作系统，将安装程序下载到您的机器上。
注意:对于 macOS，在安装 AmlWorkbench 安装文件之前，首先需要使用自制软件安装openssl库。
$ brew install openssl
$ mkdir -p /usr/local/lib
$ ln -s /usr/local/opt/openssl/lib/libcrypto.1.0.0.dylib /usr/local/lib/
$ ln -s /usr/local/opt/openssl/lib/libssl.1.0.0.dylib /usr/local/lib/
在 Visual Studio 代码工具中安装和浏览项目示例
现在我们已经有了 Azure 机器学习帐户和 Azure 机器学习工作台设置，我们现在准备好为 AI 使用 Visual Studio 代码工具了
- 在这里下载 AI 扩展的 Visual Studio 代码，或者你可以在 VS 代码中的扩展上搜索它。
- 安装完成后，重启 VS 代码
- 打开命令调板(Windows 中的 CTRL + SHIFT + P 或 macOS 中的 COMMAND-P)
- 键入" > AI:Azure ML-log in "，这将在终端中显示一条消息，让您打开浏览器并输入提供的代码
5.一旦你成功登录你的账户，再次打开命令面板，输入" > AI:打开 Azure ML 样本浏览器"
注意:有时当您输入“AI: Open Azure ML Sample Explorer”命令时，VS 代码中没有发生任何事情，当您再次尝试输入该命令时，该命令将不会显示在命令调板中。要修复这个问题，只需重新启动 VS 代码，您应该能够再次看到该命令。
在 Azure 机器学习示例资源管理器中创建新项目
现在，我们将尝试使用 sample explorer 创建一个简单的项目，并在本地机器上测试它。
- 点击"安装"到简单线性回归项目
- 输入项目名称
- 进入项目安装文件夹
- 输入我们刚才使用 Azure 创建的帐户和工作区
- 成功创建项目后，您将能够看到以下文件:
6.您也可以检查readme.md文件，以了解正确运行项目所需安装的包。在这种情况下，我们必须安装matplotlib。
# For macOS
$ pip3 install matplotlib# For Windows
$ conda install matplotlib
提交作业并在本地训练模型
一旦我们安装了matplotlib包，我们现在将提交一个任务在本地训练模型。
- 你可以右击
linear_reg.py文件，点击“AI:提交作业”
2.或者，你可以再次打开linear_reg.py，打开命令面板，输入“AI:提交作业”
3.确保选择“本地”作为您的配置
4.提交作业，您应该能够在终端中看到输出
那么你怎么看待 Visual Studio 的 AI 代码工具呢？就个人而言，当提交作业或准备将用于训练模型的数据时，我更喜欢使用 Azure Machine Learning Workbench，因为它对作业发生的事情有更好的可视化。以下是您在 AML Workbench 中运行任务时的情况:
如果你想了解更多关于 Visual Studio Code Tool for AI 的信息，你可以查看他们的 GitHub 库这里，如果你也对 AML Workbench 感兴趣，你也可以查看他们的文档这里。
扫一扫
721
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
