编码疗法
现实世界中的 DS
对于我们目前的冠状病毒培养
是的，很严重。
是的，我们都应该认真对待它。
是的，当你无法走出去逃避它时，你很难从它身上分心，每个新闻节目都征用每个电台来谈论它。
谢谢你，冠状病毒，谢谢你让我们在别人的大型、恐怖、疫情主题的恐怖电影中成为临时演员，谢谢你让我们所有人都蹲在家里，不管什么房间现在都成了我们自己的私人密室。
这可能会令人沮丧…然而，也不一定如此。
如果你仔细想想，这也是一个巨大的机会。
你赢得了一些时间。
没有通勤。不要为了避开同事而在办公室里快速走动。没有没完没了的会议。不要重复去街角的咖啡店买咖啡(你知道你无论如何都需要减少咖啡因的摄入)。
在那里的某个地方，你可能每天花至少半个小时，如果你幸运的话，一个小时。
不管你是对编码感兴趣，还是对数据科学或 UX/UI 感兴趣，为什么不花时间投资自己，学习那些你一直向自己承诺要掌握的优秀编码技能呢？
我们现在被告知，我们可能会“生活在封锁中”至少一个月，所以也许是时候充分利用你的情况，学习一些真正有价值的编程语言，你可以在疫情爆发的另一边利用它们。
塔玛斯·考托瑙在 Unsplash 上拍摄的照片
所以，如果你一直在思考这个问题，这是博斯科博士为我们常见的冠状病毒文化开出的药方——每天在网上吃一片，早上给我打电话(如果你感觉很好，吃两片):
PYTHON
Python 不仅会一直流行下去，而且流行速度如此之快，很可能会成为未来几年的主流编程语言。
语言本身是逻辑的，代码是可读的，编程语法是简单的。它可以应用于非常广泛的情况，例如数据科学、数据可视化、游戏等等。
它可能是你今天需要了解的最重要的编程语言，并且有望成为未来编程语言的主导力量。
SQL
结构化查询语言(SQL)是一种编程语言，用于与数据库进行交互，并通过查询来分析和理解数据。
现在对它的需求非常大，因为许多公司都用它来运行查询，并对他们利用的数据进行分析。很可能你现在工作的公司正在使用它，你希望有一天为之工作的公司也在利用它。
无论是像谷歌和亚马逊这样的大公司，还是中等规模的公司，SQL 无处不在，帮助你快速了解它的课程也是如此。
JAVASCRIPT
JavaScript 是世界上最流行的编程语言之一，它是一种面向对象的编程语言，旨在简化 web 开发。
它允许你通过使网页上的元素具有交互性来赋予它们生命。你可以用它来创建菜单、动画、地图和视频播放器。
JavaScript 用于开发网页、移动应用程序、基于浏览器的游戏等。有太多的东西等着用 JavaScript 来创造，许多公司愿意付钱给你来完成它。
你只需在谷歌上搜索一下，就能看到数百个令人生畏的课程链接，这些链接声称能够指导你学习代码，所以请允许我帮你缩小范围。
我一直很偏爱曾经和 总会Udemy、 和data camp**的经历。**请注意，这里没有有偿代言，只有我的个人经历。
我建议你开始回顾它们，并根据你想要学习的内容、事情如何与你自己的学习风格和工作日程同步，以及一旦冠状病毒文化最终消退，你可能希望用你新发现的编码知识实现什么，做出自己的决定。
我们都需要保持乐观。
我们会变得更好，现在我们可以利用这段时间来学习如何编码，这样我们都可以在我们所做的事情上做得更好。
然后我们都可以利用我们的新技能让世界变得更好。
梅和 RMSE 的普通人指南
用简单的话来理解——它们在现实世界中意味着什么，什么时候选择哪个？
图片由皮克斯拜的 Gerd Altmann 提供
一位商人，我的潜在客户，昨天当我向他展示我的预测模型时，他问我，“你认为这些预测模型会有多准确？”。我准备好回答这个问题了。“非常”，我颇有些自信地说道。“它具有极低的 MAE”。
对我天真的回答，他藏起笑容，看着我，就像一个老人看着一个还不了解人情世故的青少年一样，他又问了一遍。“我不太擅长理解高级金融和数学术语，你能以简单的方式给我解释一下吗？这样我就能明白，相信你的预测，我在这里冒了多大的风险？”。
常识不是那么普通，简单也不是那么容易获得。
于是我礼貌地要求再给一天时间，跟他告辞了。
错误造就人
我们在生活中非常清楚地知道，同样大的错误在不同的情况下会有不同的分量。当你和朋友参加一个非正式的聚餐时，迟到 10 分钟可能不是坏事，但当你妻子的父母请客时，这将是一个改变一生的灾难性事件。
大多数情况下，你只要说自己很守时，就可能逃脱惩罚。你基本上是在要求考虑你的平均表现。
对你来说，这就是平均误差或平均误差。
我们应该从我委托人的角度考虑这个问题。几个月前，他开了一家不太大的家庭餐馆。他的任务是预测每天的顾客流量，以便他能够计划从批发市场购买正确数量的原材料。作为一家新企业，他同样害怕由于一天结束时浪费了过多的食物而招致损失，以及因为他没有更多的食物来烹饪一天而不得不请顾客回去。
让我们以周为单位来想象一下。假设这些是每天的实际客户数量:
每日顾客流量
我创建模型，并预测类似这样的事情:
每日预测
然后，我计算模型犯下的一个或多个错误:
预测误差
总误差= 0。很容易看出这种逻辑的谬误。我在积极方向上的错误被那些在消极方向上的错误抵消了。
我说，错误就是错误。从数学上来说，这意味着取错误的绝对值。
平均绝对误差
我们刚刚理解了什么是 MAE(平均绝对误差)。
它说，平均来说，我会错误预测一天的客户数 6.285。我是否会预测更多或更少，通过了解 MAE 并不明显。我的客户可能每天浪费 6.285 人的食物，或者平均每天拒绝 6.285 名顾客。
为了便于理解，让我们假设我的模型只在正向出错，也就是说，我可能会错误地说，“今天会有 25 个客户”，而实际上可能只有 20 个。但绝不会出现我低估这个数字只有 15 的情况。这基本上意味着食物可能会被浪费掉，但所有的顾客都会得到款待。
一个是小偷，另一个是强盗
那么这是否意味着具有相同 MAE 的两种方法(模型)同样好(或坏)？
想象一下，我的一个竞争对手，我称之为 BloodyC Pvt. Ltd .，也试图向这位拥有餐馆的先生推销它的方法。我们的预测大概是这样的:
两个预测，相同的 MAE
我每天都犯小错误，而 BloodyC 在大多数日子里都很准确，但在某些日子里会犯更大的错误。哪个更好？
光看数字是无法得出答案的。这是关于商业，它的愿景，它的道德和它背后的人。所以我会让你们想象一个离现实不远的情况，在这个情况下，我的模型会更好。
(资料)科学从来都不是数字和逻辑。永远都是关于情感和生活的。
在许多国家、商店和家庭，当有多余的食物时，我们会尽量给那些比其他人更需要的人，或者喂宠物&流浪动物，如果这对它们无害的话。当然，每个人都有极限。因此，如果只剩下 2-3 个人的食物，很容易立即找到需要的人，但如果数量更多，大部分食物通常会被扔进垃圾箱。不是每个店主都和无家可归者收容所或类似的服务机构有联系。
我的潜在客户，餐馆老板，也有类似的行为。对许多人来说，看到如此多的食物被浪费也是一种情感上的痛苦。虽然对他来说在经济上是一样的，但他更喜欢我的型号，它每天浪费很少，相比之下，BloodyC 的几天就浪费很多。
发现情况太抽象或假设？这里有一个非常真实的例子:
$克鲁奇·麦克达克
职业交易员通常更喜欢通过衍生品——期货期权——在股票市场进行投资/交易。在许多策略中，人们押注的是一只股票或衍生品在未来 n 天的价格区间。
我的模型现在感觉比 BloodyC 的更安全吗？即使我出错了，我也会出错一点点。交易者仍然会在这个有限的范围内赚钱，即使他的赌注不准确。如果价格大幅偏离交易者所相信的预测，这意味着在的一次错误投资中损失了巨额资金——相信 BloodyC 会让他付出高昂的代价。
如果这让您觉得我的模型更适合您的业务案例，那么在比较这两个模型时，您使用哪个指标来表达这一点？梅当然不能惩罚一个比另一个多。
进来吧，RMSE
R MSE 是 M的平方 R oot 可以是 S的平方Eerror。因此，如果你计算预测中每个错误的平方，并把它们加起来，然后除以 7(预测的总数)，你就得到 MSE。如果你想要 RMSE，只需要做一个额外的平方根。(唷，那不是一口！)
让我们看看 RMSE 如何看待我们的预测:
均方根误差
哟呼呼！
更大的错误，更大的惩罚——这是 RMSE 的特点之一。我的预测得到了比 BloodyC 的( 3.505 )更低的 RMSE ( 2.138 )值，这意味着当用这个目标评估时它更好。
向 RMSE 祈祷吧！
这是否意味着我们应该一直使用 RMSE 来检验模型的准确性？绝对不行！
如果我的潜在客户出售的不是米饭、鸡肉和印度咖喱，而是可以轻松存放数年的泡菜，允许一天的剩余很容易在第二天出售，那么他更有可能从关注 MAE 或任何其他类似指标中受益。
RMSE、梅、MAPE(平均绝对百分比误差)还有其他几个细微差别，人们当然应该考虑阅读这些，并深入研究其背后的数学。我觉得有趣的几篇文章是这个和这个(跳转到第 11 节:时间序列预测的准确性度量)，供那些希望进一步探索的人参考。
离别的思绪
我希望我的潜在客户现在能够明白，通过相信我的预测，他将承担多大的风险，以及承担何种类型的风险。他的问题让我再次思考什么更适合他的用例。
至于那个不太守时的丈夫，他只能希望当他在不久的将来犯了大错时，不要被 RMSE 评头论足！
对分享想法、提问或简单讨论想法感兴趣？在 LinkedIn 、 YouTube 、 GitHub 上或通过我的网站与我联系:我只是一个学生。
回头见&学习愉快！
为什么不应该将 LabelEncoder 用于分类特征
如何处理分类特征和避免一个常见的陷阱
在处理分类特征时，选择一种合适的方式对它们进行编码可能并不那么简单。这是一个需要考虑的非常重要的方面，它将决定一个特性将为模型增加的价值。
这同样适用于顺序特征，这是一种非常常见的分类数据类型，其中不同的类别呈现出一种自然顺序。一个例子可以是是温度特征，取类别冷、温和和热。
一个相当常见的错误是，只给特性的每个类别分配一个唯一的数值，而不考虑它可能具有的任何顺序。并且类似地具有标称特征；不同之处在于它们并不自然地呈现任何顺序。
这篇文章的想法是探索和理解为什么这不是一个好主意，用一个带有顺序特征的例子来更好地说明这一点，以及我们应该用什么方法来代替。
找到所有的代码连同解释 也作为一个 jupyter 笔记本 。
将特征的固有顺序映射到错误的比例会对模型的性能产生非常负面的影响(即与特征的相关性成比例)。
如前所述，序数特征有一个*自然排序，*或者换句话说，它们有一个带有等级的序数尺度。因此，如果我们想在编码后保留特性的值，我们想确保它类似于它们的排名。
用决策树可视化
一种直观的思考方式是决策树设置阈值的方式。在训练过程中，决策树将学习在每个节点设置的最佳特征，以及确定未知样本通过每个节点的路径的最佳阈值。
如果我们用一个简单的LabelEncoder对一个序数特征进行编码，这可能会导致这样一个特征，比如说1代表热，2可能会翻译成热，而0代表沸腾。在这种情况下，结果将是一个具有不必要的大量分裂的树，因此对于本应更简单的建模来说，复杂性要高得多。
虽然实际上看到为什么这是一个坏主意会比仅仅是文字更直观。让我们用一个简单的例子来说明上面的内容，这个例子由两个序数特征组成，这两个特征包含一个学生准备考试所花费的小时数和所有以前作业的平均分数的范围，以及一个指示考试是否通过的目标变量。我已经将数据框的列定义为[pd.Categorical](https://pandas.pydata.org/pandas-docs/stable/user_guide/categorical.html):
将分类列定义为熊猫分类的好处是，我们可以在它的分类中建立一个顺序。这使得基于既定顺序的排序比基于词汇排序快得多。它也可以作为一种简单的方法，根据不同类别的顺序得到不同类别的代码。
也就是说，对于使用fit / transform方法的更一般的方法，我们应该看看其他工具，我将在下一节中介绍。
因此，我们将使用的数据帧如下所示:
Hours_of_dedication Assignments_avg_grade Result
0 20-25 B Pass
1 20-25 C Pass
2 5-10 F Fail
3 5-10 C Fail
4 40-45 B Pass
5 0-5 D Fail
6 15-20 C Fail
7 20-25 A Pass
8 30-35 B Pass
9 5-10 B Fail
10 10-15 D Fail
...
如上所述，我们可以使用[pd.Series.cat.codes](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.Series.cat.codes.html)方法，根据categories参数中的顺序，获得分配给每个类别的代码:
X = df.apply(lambda x: x.cat.codes)
print(X) Hours_of_dedication Assignments_avg_grade Result
0 4 3 1
1 4 2 1
2 1 0 0
3 1 2 0
4 7 3 1
5 0 1 0
6 3 2 0
7 4 4 1
8 6 3 1
9 1 3 0
10 2 1 0
...
现在让我们安装一个[DecisionTreeClassifier](https://scikit-learn.org/stable/modules/generated/sklearn.tree.DecisionTreeClassifier.html)，看看树是如何定义分割的:
from sklearn import tree
dt = tree.DecisionTreeClassifier()
y = X.pop('Result')
dt.fit(X, y)
[sklearn.tree](https://scikit-learn.org/stable/modules/generated/sklearn.tree.plot_tree.html#sklearn.tree.plot_tree)模块提供了绘制拟合决策树的功能。让我们用它来看看决策树是什么样子的:
g = tree.plot_tree(dt,
feature_names = X.columns,
class_names=['Failed', 'Pass'],
filled = True,
label='all',
rounded=True)
就这些吗？？嗯… 是的！我实际上以这样一种方式设置了特征，即在Hours of dedication特征和考试是否通过之间存在这种简单而明显的关系，这表明问题应该非常容易建模。
现在让我们试着做同样的事情，用一个我们可以通过LabelEncoder获得的编码方案直接编码所有的特征，所以不考虑特征的实际普通性，只是随机分配一个值:
from sklearn.preprocessing import LabelEncoderX_wrong = df.apply(LabelEncoder().fit_transform)
dt_wrong = tree.DecisionTreeClassifier()
dt_wrong.fit(X_wrong, y)g = tree.plot_tree(dt_wrong,
feature_names = X_wrong.columns,
class_names=['Fail', 'Pass'],
filled = True,
label='all',
rounded=True)
正如所料，对于我们试图建模的简单问题来说，树结构比必要的要复杂得多。为了让树正确地预测所有的训练样本，它已经扩展到深度为4，这时单个节点就足够了。
这意味着分类器可能会过拟合，因为我们大大增加了复杂性。通过修剪树和调整必要的参数来防止过度拟合，我们也没有解决问题，因为我们通过错误地编码特征添加了太多的噪声。
序数特征应该如何编码？
在上面的例子中，我们已经看到了一种使用pd.Categorical对序数特征进行编码的简单方法。但是大多数时候，我们感兴趣的不仅仅是转换一组给定的特性，还包括在看不见的数据上复制应用的转换。
为此，我们有来自类别编码器的[OrdinalEncoder](https://contrib.scikit-learn.org/categorical-encoding/)。本课程使我们能够:
- 定义将类别映射到代码的字典
- 用映射字典安装编码器，用转换看不见的数据
让我们通过一个例子来看看如何使用它，这个例子包含几个特性:
OrdinalEncoder接收一个映射参数，期望一个字典列表，每个字典包含键col和mapping:
然后，我们可以使用以下内容创建编码器的新实例:
import category_encoders as ce
encoder = ce.OrdinalEncoder(mapping = ordinal_cols_mapping,
return_df = True)
因此，通过在与上述相同的数据框架上进行转换，我们得到:
df_train = encoder.fit_transform(df)
print(df_train) Outlook Temperature Humidity Windy PlayTennis
0 2 2 1 0 0
1 2 2 1 1 0
2 1 2 1 0 1
3 0 1 1 0 1
4 0 0 0 0 1
5 0 0 0 1 0
6 1 0 0 1 1
7 2 1 1 0 0
8 2 0 0 0 1
9 0 1 0 0 1
10 2 1 0 1 1
11 1 1 1 1 1
12 1 2 0 0 1
13 0 1 1 1 0
因此，总而言之，一旦对特征进行编码，保持它们的平凡性是至关重要的，否则正如这个例子所表明的那样，我们将失去它们所有的可预测能力，而只是将噪声添加到我们的模型中。
找到所有的代码和解释，也可以作为一个笔记本。希望你喜欢并发现这很有帮助！
Cloudera、Amazon Web Services 和 Microsoft Azure 的比较研究
理解大数据
摘要 —本文旨在比较 Cloudera、亚马逊 Web 服务和微软 Azure 提供的云计算服务。大数据是指大量数据，包含结构化、半结构化和非结构化数据。传统技术无法存储和处理大数据。Hadoop 框架支持存储和处理如此复杂的数据。Cloudera、Amazon Web Services 和 Microsoft Azure 部署了 Hadoop 框架，并在云上实现数据存储和处理。这三个发行版都提供了云计算、云存储、数据库和机器学习。他们在不同方面都有自己的长处和短处。用户必须选择最符合他们需求的发行版。
关键词—大数据、云计算、Hadoop、AWS、Azure
一.导言(简要背景)
B ig 数据是一个术语，指庞大的规模(容量)、高增长率(速度)和各种数据集(多样性)。传统的技术和工具，例如关系数据库管理系统(RDBMS)，既不充分也不适合管理、捕获、处理或分析大数据并从大数据中创造有意义的洞察力[1][4]。
RDBMS 只适用于以表格形式存储的结构化数据，而对于大数据，数据种类繁多，不仅仅是表格。大数据包括非结构化数据，如移动生成的信息、图像、视频和 RFID。在 RDMBS 中，数据是基于关系进行分析的，这导致了它的另一个局限性，因为维护非结构化数据关系是不可想象的(至今)。除此之外，RDBMS 不能保证快速的处理速度，这是分析大数据的主要问题之一。因此，大数据分析更适合采用分布式文件系统方法的 NoSQL。最后但同样重要的是，在存储和处理大数据时，传统技术和工具将是一种昂贵的方法。[4]
图一。大数据的五大特征。(图片由作者提供)
从上面的陈述中，大数据被描述为具有巨大的量、高的多样性以及高的速度。从[2]和[7]来看，大数据还有另外两个定义，就是准确性和价值。
**卷:**卷是指数据的大小。随着每秒钟产生大量数据，数据量已经从兆字节和千兆字节增长到千兆字节。据预测，到 2020 年，将会产生 40zb 的数据，这是 2005 年的 300 倍[1] [2]。
图二。数据量的增长。(图片由作者提供)
**多样性:**多样性是指不同类型的数据和不同来源的数据。大数据不仅仅是行和列形式的结构化数据，事实上，大数据中只有一小部分是结构化数据，大部分生成的数据是非结构化数据或半结构化数据，例如，音乐、视频、图像、电子邮件或社交媒体数据。Twitter 上有 2 亿活跃用户，每天发送 4 亿条推文。所有这些都有助于各种大数据的增长[1] [2]。
图 3。数据类型。(图片由作者提供)
**速度:**速度是指产生数据的速度和处理数据的速度。有不变的静态数据，也有变化非常频繁的数据。对于频繁变化的数据或高速生成的数据，例如社交媒体帖子，处理速度必须足够快，因为数据有时可能在[1] [2]之后不再有用。
**准确性:**准确性是指数据的准确性或不可靠性。收集数据的不一致性和不完整性导致数据的不确定性[2]。
价值:价值是指可以从数据中获得的利益。从[7]，大数据生态系统表明，数据购买者和数据使用者可以从数据价值链中其他人收集和组合的信息中提取价值。
I .发行版/服务的历史和演变
随着传统技术和工具不再适合大数据存储和处理，各种分发和服务被发布。大多数发行版都支持 Hadoop 框架，能够处理复杂的大数据。
Hadoop(高度归档分布式面向对象编程)是一个开源的 Apache 框架，用 Java 编写，旨在使用简单的编程模型支持跨计算机集群的大规模数据集的分布式并行处理。Hadoop 得名于创造者儿子的玩具大象。2005 年，两名雅虎员工创建了 Hadoop，最初是为了支持开源网络爬虫 Nutch。2003 年，Google 发布了 Google 文件系统和 Google Map Reduce，随后 Google 在 2004 年的白皮书中分享了 Google 文件系统和 Map Reduce 的解释。谷歌激发了 Hadoop 的产生。2005 年，Hadoop 开始在雅虎服务。2008 年，Apache 接管了 Hadoop，这就是 Hadoop 现在被称为 Apache Hadoop 的原因。同时，Hadoop 已经成为分布式应用最强大的数据存储和处理框架之一[3] [4]。
Hadoop 有助于以分布式方式以最低的成本存储、访问和获取大数据中的大量资源，具有高扩展性和高可用性，因为它本身可以在应用层确定故障，这使得它非常具有容错性。Hadoop 不仅可以处理大量数据，还可以处理各种各样的数据，如图像、视频、音乐音频、文件、文件夹、软件和电子邮件。简而言之，Hadoop 可以处理任何类型的结构化、半结构化和非结构化数据。Cloudera、Hortonworks 和 MapR 是 Hadoop 的商业支持发行版[4]。
图 4。Hadoop 组件。(图片由作者提供)
Hadoop 提供多种服务，其中包括文档、位置感知、源代码和工作调度。Hadoop 包包含两个主要部分和其他各种组件。两个主要部分是 Hadoop 分布式文件系统(HDFS)和 MapReduce。HDFS 主要用于数据存储，MapReduce 用于数据处理和数据分析。HDFS 和 MapReduce 都实行主从架构。其他组件包括 Zookeeper、Sqoop、Pig、Oozie、Hive、HBase、Flume 和 Avro [3] [4]。
HDFS 是 Java 可移植文件系统，它在 Hadoop 框架环境中更具可伸缩性和可信任度。HDFS 包含一个名称节点和一个数据节点群集。数据节点存储文件数据，而名称节点存储元数据，如每个数据块地址的名称、文件属性、副本和位置。如果数据节点的数据块在复制副本中丢失或出现故障，名称节点将创建数据块的复制副本。数据节点中的块数由名称节点监控。因此，名称节点是非常重要的，因为只有它知道所有文件存储在哪里，这也是与数据节点通信的唯一方式[3]。
Map Reduce 是一款用于处理大型数据集的软件。它的名字代表了它的两个主要功能，Map 和 Reduce。映射函数将数据分离成一对键和值，减少推断最终输出，并生成中间值[4]。如上所述，MapReduce 采用与 HDFS 相同的主/从架构。在 MapReduce 中，主节点是作业跟踪器，从节点是任务跟踪器。在收到用户的订单后，MapReduce 向 HDFS 请求数据集。在此过程中，用户与 MapReduce 主节点(作业跟踪器)通信，然后作业跟踪器从 HDFS 的 Name 节点获取要处理的数据的位置。之后，作业跟踪器将作业传递给任务跟踪器进行处理。对于 HDFS 和 MapReduce，从节点和将定期向主节点发送心跳信号，以确保主节点仍然活着[5]。
Hadoop 是不可替代的，因为它的框架使大数据的存储和处理成为可能。虽然 Hadoop 架构是基于 Google 文件系统和 Google Map Reduce 的，但是提供的服务是免费的，因此许多发行版都部署了 Hadoop 的实现。
A.Cloudera
如前所述，Cloudera 是 Hadoop 的商业支持发行版之一。2008 年，Cloudera 由包括甲骨文、脸书、谷歌和雅虎在内的硅谷领先公司的最聪明的头脑创建。。Hortonworks 成立于 2011 年，由 24 名雅虎！工程师，来自最初的 Hadoop 团队。Hortonworks 和 Cloudera 都认为开放标准、开源和开放市场对公司来说是最好的。2019 年，Cloudera 已经与 Hortonworks 合并[8]。
Cloudera 的创始人坚持认为，有了 Hadoop，整个商业市场都可以获得优势。例如，石油和天然气公司可以用一种新方法分析他们的油藏数据，这种方法可能提供不同的见解。该声明得到了 Accel Partners 的足够重视，Accel Partners 愿意投资资金启动 Cloudera 项目。然而，VMware 的联合创始人戴安娜·格林(Diana Greene)和 MySQL 的前首席执行官马丁·米科斯(Marten Mickos)以及脸书的首席财务官吉迪恩·于(Gideon Yu)也向该公司投入了资金。Cloudera 计划出售他们的咨询和支持服务，尽管 Hadoop 仍然是免费的[9]。
B.亚马逊网络服务
亚马逊作为全球在线销售的领导者，拥有自己的云计算，即亚马逊网络服务(AWS)。2006 年，AWS 成立并开始向个人和组织提供云计算[6]。AWS 是作为 Amazon.com 的副业引入的[10]。AWS 业务的领导者 Andy Jassy 提到，AWS 不是任何一个人的想法，它的成立是因为该公司在推出新项目和支持客户的能力方面遇到了挫折。没有人知道 AWS 会成长为今天这样一个万亿美元的技术市场[11]。
根据 Jassy 的说法，在 AWS 的构建阶段，他们很快面临第一个关键决策，是应该从存储解决方案、计算解决方案和数据库解决方案中构建一个服务，还是构建一个包含所有三种服务的平台。由于他们认为所有应用程序都需要计算解决方案，大多数需要数据库，几乎所有应用程序都需要存储，因此他们得出结论，大多数开发人员需要这三种服务的组合。然后。AWS 于 2006 年 3 月推出[11]。
C.微软 Azure
微软 Azure 于 2010 年首次发布。微软 Azure 使用户能够在云上运行服务，或者将云计算服务与任何基础设施、数据中心或应用程序相结合[6]。微软 Azure 原名 Windows Azure，2014 年 4 月 3 日更名为微软 Azure。同一天，微软声明他们将 Azure 作为客户的公共云平台。微软 Azure 支持来自任何公共云的各种操作系统、语言和服务，例如 Hadoop [12]。微软 Azure 是在 2008 年微软专业开发者大会上首次推出的，同时推出的还有微软 SQL 服务。NET Services、Live Services 以及 Microsoft SharePoint Services 和 Microsoft Dynamics CRM Services SaaS。随着这一系列新产品的推出，微软提供了五大关键类别的云服务，而不仅仅局限于云计算。Windows Azure 提供计算、存储和网络服务，而微软 SQL Services 提供数据库服务[14]。
微软一直是 IT 市场的领导者。虽然微软 Windows 软件过去和现在都在人们的生活中很受欢迎，但微软决定将他们的重点从个人电脑转移到移动和云计算。这一决定被证明是明智的决定，因为销售额翻了一番，股票上涨了 6.2%。
二。分发/服务及其组件的亮点
表 1。三种分布的比较概要。(图片由作者提供)
A.Cloudera
Cloudera Enterprise 非常适合希望建立自己的企业大数据中心并在其上执行数据分析的组织。Cloudera Enterprise 利用 Hadoop (CDH)的开源 Cloudera 发行版，这是目前使用的 Hadoop 部署最多的实现之一[17]。
CDH 提供启动和运行大数据环境所需的所有工具。通过与 Apache Kudu 项目和 Apache Impala 项目的集成，Cloudera 现在能够支持实时分析和 SQL 分析查询。Cloudera 提供的四个主要功能是开源数据平台、分析、数据管理和预测建模。Cloudera 数据平台(CDP)拥有 Hortonworks 和 Cloudera 的最佳技术，可作为首个企业数据云。CDP 不仅包括数据中心服务，还包括数据仓库和机器学习。它提供了一个集成的控制平面来管理数据、基础架构和分析，CDP 还支持混合云或多云环境。CDP 是完全开源的发行版，可以避免供应商锁定。对于价格，Cloudera 提供了各种选项，包括 4，000 美元起的年费和每小时 0.08 美元的服务使用费[17]。
B.亚马逊网络服务
Amazon Web Services 在存储和使用的服务方面提供高度可定制的服务。此外，成本是根据选择的服务数量计算的。这对小型和大型组织都非常有益。AWS 还提供 12 个月的免费试用。然而，AWS 目前有一些客户支持问题[6]。
AWS 提供的云计算服务可以分为 19 个类别，分别是计算、存储、数据库、迁移、网络和内容交付、开发者工具、管理工具、人工智能、分析、安全、身份和合规、移动服务、应用服务、消息传递、业务生产力、桌面和应用流、软件、物联网、联络中心和游戏开发[16]。
在所有服务中，AWS 最受欢迎的服务之一是用于云计算的弹性计算云(EC2)。它提供免费层、按使用付费和快速部署。付款从每小时 0.0059 美元开始。接下来是简单存储服务(S3)，也是免费层，适用于主存储和备份，因为他们声称该服务具有几乎 100%的耐用性。Glacier 是 AWS 提供的另一种存储服务，适用于档案存储，与 S3 集成。另一个流行的服务是关系数据库服务(RDS ),它提供六种数据库引擎供选择，价格从每小时 0.017 美元开始。亚马逊在人工智能方面有强大的投资，他们提供了亚马逊机器学习，能够进行实时预测，并包含可视化工具和向导。该费用按使用次数计算，其中数据分析和模型构建每小时花费 0.42 美元，批量预测每 1000 次交易花费 0.10 美元，实时预测每次预测花费 0.0001 美元[16]。
AWS 提供的最大好处是按使用付费，这使它不仅适用于大型组织，也适用于中小型企业，甚至个人。
C.微软 Azure
微软 Azure 为不同类型的行业提供了各种各样的服务。他们考虑了各种业务需求，并推出了各种足以满足各种行业需求的软件包。它兼容 Windows 和 Linux，并提供 12 个月的免费试用。然而，它比 AWS 更贵，因为服务是打包提供的，这意味着即使你可能不需要某项服务，你仍然必须购买它[6]。
微软 Azure 提供的云服务可以分为 14 类，分别是计算、网络、存储、Web +移动、容器、数据库、数据+分析、AI +认知服务、物联网、企业集成、安全+身份、开发者工具、监控+管理、微软 Azure 栈[14]。
根据[14]，从 Azure 提供的各种各样的服务来看，最受欢迎的服务是用于计算的虚拟机、Blob 存储、SQL 数据库、用于安全+身份的 Azure Active Directory 以及用于开发人员工具的 Visual Studio Team Services。微软 Azure 的虚拟机提供按使用付费，每小时只需 0.018 美元。此外，虚拟机支持各种服务器软件，包括 Window Server、Linux、SOI Server、IBM、SAP 和 Oracle。对于 Blob 存储，价格取决于访问，以及它对大规模可扩展对象存储的支持。虚拟机和 Blob 存储都提供免费层，用户可以免费试用服务。其次是 SQL 数据库，它也提供按使用付费，价格从 0.10 美元到 3.23 美元每小时使用。Azure Active Directory 为云和云上应用程序提供单点登录服务，并与 Office 365 等微软云服务集成。提供免费等级，高级 P2 服务的费用为每个用户每月 9 美元，基本服务的费用为每个用户每月 1 美元。Visual Studio Team Services 对订阅其他微软服务的开发人员是免费的。对于不是微软服务订阅者的用户，前五个用户的服务是免费的，第六到第十个用户每月 6 美元，第 11-100 个用户 8 美元，第 101-1000 个用户 6 美元，其他用户 4 美元。
简而言之，微软 Azure 对那些已经在使用微软软件(例如 Windows 和 Office)的个人或组织有利。通过使用微软 Azure，微软服务用户可以很快采用它，并且微软 Azure 提供的一些服务对微软服务用户是免费的[14]。
三。分销商/服务及其组成部分之间的比较(分析/结果)
所有三个发行版，Cloudera，Amazon Web Services 和 Microsoft Azure 都支持数据存储，数据库，网络安全，云计算和机器学习。每种发行版都有自己的优缺点。本节将比较这三个发行版各自提供的服务。
基于产品功能和客户对 Cloudera、AWS 和 Microsoft Azure 的评级和评论可在[15]上获得。根据过去 12 个月的评级和评论[15]，Microsoft Azure 的总体同行评级最高，其次是 Cloudera，然后是 AWS。产品能力方面，Cloudera 和微软的平均评分高于 4.0，AWS 的平均评分在 3.5 左右。评级显示，AWS 在持续加载数据和查询多种数据类型/数据源方面的性能较低，而 Cloudera 在行政和管理方面较弱。除了管理大量数据、对许多数据类型/来源的查询、系统可用性和用户技能水平支持之外，Microsoft Azure 在大多数方面都获得了最高评级。AWS 在系统可用性方面排名最高，而 Cloudera 在许多数据类型/数据源的查询方面排名最高。就客户体验而言，所有三个发行版的平均评分都在 4.0 以上。Microsoft Azure 在所有标准方面都获得了最高评级，包括定价灵活性、易于部署、供应商响应的及时性和技术支持的质量。
根据评级，微软在大多数方面都是最好的，包括价格和部署的便利性。然而，基于[6]，微软 Azure 被评为昂贵。两个来源之间的差异，这是因为微软 Azure 非常适合已经是 Windows 服务订户的组织。他们可以获得一些免费的 Azure 服务，界面也更加熟悉，这使得他们更容易部署 Microsoft Azure。
根据评级[15]和评论[6]，AWS 在系统可用性方面有很高的评级，并推荐其低价和按使用付费的支付方式。但是，与其他两个发行版相比。AWS 在加载数据和执行查询方面较弱，而 Cloudera 在这方面有很强的性能。再者，AWS 不支持 Cloudera 和微软 Azure 这样的混合云环境，在某些方面限制了它的应用。
四。讨论和推荐(应用领域)
由于不同的分布有不同的优缺点，它们在现实生活中的大数据上的应用也是不同的。微软 Azure 对 Windows 服务有很强的支持，非常适合教育等广泛使用 Windows 服务的行业。从学生到教师或讲师，甚至是管理人员，都使用像 Microsoft Office 这样的 Windows 服务。大多数大学订阅了微软 Office 365 服务用于教育用途。Microsoft Office 365 的应用程序包括学生的作业、学生的讲课记录，以及学生和大学所有员工的详细记录。
Cloudera 是 Hadoop 部署最多的实现之一，具有最强的数据加载和查询能力，适合处理非结构化的复杂数据。比如医疗数据。不同病人身上疾病的特点和症状是不同的。Cloudera 还支持科学数据可视化。因此，Cloudera 适合在医疗保健领域应用。
亚马逊网络服务(AWS)适用于公共部门，因为支付是按使用量收费的。公共部门包括政府组织和非政府组织，他们可以使用 AWS 提供的服务来存储他们从调查中收集的数据，并在 AWS 平台上立即执行数据分析。AWS 允许按使用付费，这在成本方面可能对组织有利。AWS 也提供了机器学习服务，组织可以使用机器学习进行预测，例如预测住宅区的用电量。
从我的角度来看，所有这三个发行版都将增长，并在提供的服务方面变得越来越成熟，在产品质量、安全性、易于部署和客户服务方面。分布的应用范围只会越来越大。有可能在未来的某个时候，随着发行版之间的竞争，越来越多的服务变得免费。也有可能在未来的某个时候，云服务已经被创新，直到我们可以用智能设备而不是个人电脑或笔记本电脑来控制一切。大数据存储、处理、数据分析和机器学习都可以通过手指触摸来完成。
如果这已经成为我们的现实，网络安全对于发行版将是非常重要的。当我们生活中的一切都在云上时，如果云中断了，那将是一场灾难。那时，当人们选择服务时，发行版的安全性和持久性将是首先考虑的问题。
动词 （verb 的缩写）结论
总之，每个发行版都有其独特的功能、优点和缺点。因此，建议用户根据自己的情况选择最适合自己的发行版。 Cloudera 部署了 Hadoop 最多，因此在处理复杂数据方面有非常强的性能。亚马逊网络服务以其价格灵活性而闻名，它适合每一个用户。微软 Azure 最适合 Windows 服务用户。
保持联系
订阅 YouTube
参考
[1] H. S. Bhosale 和 P. D. P. Gadekar，“关于大数据和 Hadoop 的综述论文”，*《国际科学与研究出版物杂志》，*第 4 卷第 10 期，2014 年 10 月。
[2] R. Beakta，《大数据与 Hadoop:综述论文》，*国际计算机科学与信息技术杂志，*2015 年第 2 卷第 2 期。
[3] B. Saraladevi，N. Pazhaniraja，P. V. Paul，M. S. Basha 和 P. Dhavachelvan，“大数据和 Hadoop-安全视角的研究”，载于第二届大数据和云计算国际研讨会，钦奈，2015 年。
[4] P. Vijay 和 B. Keshwani，“使用 Hadoop 的大数据的出现:综述”，*《IOSR 工程学报》，*第 6 卷，第 3 期，2016 年 3 月。
[5] M. R. Ghazi 和 D. Gangodkar，“Hadoop、MapReduce 和 HDFS:一个开发者的视角”，载于印度智能计算、通信&融合国际会议，2015 年。
[6] N. Drake，“2019 年最佳云计算服务:面向数字化转型”， TechRadar ，2019 年 11 月 4 日。【在线】。可用:https://www . techradar . com/best/best-cloud-computing-services。[访问时间:2019 年 10 月 13 日]。
[7] S. Gnanasundaram 和 A. Shrivastava,《信息存储和管理:以传统方式存储、管理和保护数字信息》,第二版。，交叉点大道:约翰威利父子公司，2012 年。【电子书】。
[8]《关于| Cloudera》， Cloudera ，2019。【在线】。可用城市:https://www.cloudera.com/about.html.[访问时间:2019 年 10 月 18 日]。
[9] A .万斯，“将谷歌和脸书背后的魔力装瓶”， *Bits，*2009 年 3 月 16 日。【在线】。可查:https://bits . blogs . nytimes . com/2009/03/16/bottling-the-magic-behind-Google-and-Facebook/。[访问时间:2019 年 10 月 18 日]。
[10] R. Miller，《AWS 是如何诞生的》， TechCrunch ，2016 年 7 月 2 日。【在线】。可用:https://TechCrunch . com/2016/07/02/Andy-jass ys-brief-history-of-genesis-of-AWS/。[访问时间:2019 年 10 月 29 日]。
[11] J. Furrier，“独家:AWS 和 Andy Jassy 的万亿美元宝贝的故事”， Medium ，2015 年 1 月 30 日。【在线】。可用:https://medium . com/@ furrier/original-content-the-story-of-AWS-and-Andy-jass ys-万亿美元-baby-4e8a35fd7ed。[访问时间:2019 年 10 月 29 日]。
[12] S. Martin，“Window Azure 即将更名”，T20 微软 Azure，2014 年 3 月 24 日。【在线】。可用:https://azure . Microsoft . com/en-us/blog/upcoming-name-change-for-windows-azure/。[访问时间:2019 年 10 月 29 日]。
[13] A. G. Tharakan 和 J. Dastin，“由于云业务超过预期，微软股价创下新高”，路透社，2016 年 10 月 21 日。【在线】。可用:https://uk . Reuters . com/article/uk-Microsoft-results-idukkcn 12k 2 JC。[访问时间:2019 年 10 月 29 日]。
[14] C .哈维，《微软 Azure》，数据化，2017 年 5 月 23 日。【在线】。可用:https://www . data mation . com/cloud-computing/Microsoft-azure . html[访问时间:2019 年 11 月 2 日]。
[15]《比较 Cloudera、微软、亚马逊网络服务(AWS)》， Gartner 。【在线】。可用:https://www . Gartner . com/reviews/market/data-warehouse-solutions/compare/cloud era-vs-Amazon-we B- services-vs-Microsoft。[访问时间:2019 年 11 月 2 日]。
[16] C. Harvey，“亚马逊网络服务(AWS)”，数据化，2017 年 5 月 11 日。【在线】。可用:https://www . data mation . com/cloud-computing/Amazon-we b-services . html[访问时间:2019 年 11 月 3 日]。
[17] S. M. Kerner，“Cloudera 企业:服务概述与洞察”，数据化，2019 年 4 月 25 日。【在线】。可用:https://www . data mation . com/big-data/cloud era-enterprise-data-analytics-tools . html[访问时间:2019 年 11 月 5 日]。
Bandit 算法的比较
婴儿机器人强化学习指南
多武装匪徒:第 6 部分
概观
在本系列的课程中，我们已经了解了用于定义多臂匪徒的框架和术语。然后，我们将注意力转向一些可以用来解决这个问题的算法，从简单的贪婪算法，到复杂的汤普森抽样贝叶斯方法。现在只剩下一个问题需要回答了。这些方法中哪一种最能解决土匪问题？
对于那些还不熟悉多臂土匪问题，或希望刷新他们的知识的任何特定领域，在这一系列的其他部分如下:
- 第 1 部分:数学框架和术语——入门所需的全部基础信息
- 第二部分:Bandit 框架
- 代码和测试框架的描述 - 第三部分:强盗算法
-贪婪算法 -乐观-贪婪算法 -ε-贪婪算法【ε-贪婪】 - - 第四部分:置信上限(UCB) Bandit 算法
- 第五部分:汤普森采样-伯努利汤普森采样
-高斯汤普森采样 - 第 5b 部分:使用共轭先验的 Thompson 采样
bandit 算法和测试框架的所有代码都可以在 github 上找到: Multi_Armed_Bandits
概述
机器人宝宝在商场走失。利用强化学习，我们想帮助他找到回到妈妈身边的路。然而，在他开始寻找她之前，他需要从一组电源插座充电，每个插座的电量略有不同。
使用多臂强盗问题中的策略，我们需要在最短的时间内找到最好的插座，让机器人宝宝充电上路。
机器人宝宝进入了一个充电室，里面有 5 个不同的电源插座。每个插座返回的电荷数量略有不同。我们希望在最短的时间内给机器人宝宝充电，所以我们需要找到最好的插座，然后使用它，直到充电完成。
这与多臂强盗的问题是一样的，除了我们不是在找一个能给出最好回报的老虎机，而是在找一个能给出最多电量的电源插座。
Bandit 算法的比较
为了回答哪个是最好的 bandit 算法的问题(就我们已经研究过的算法而言)，我们可以根据我们自己的问题来重新构建问题:哪个算法会让婴儿机器人在最短的时间内充满电？
为了进行这个实验，我们首先需要准确定义充满电的含义。对于这一点，我们将任意定义婴儿机器人在有足够的电量运行一小时(3600 秒)时充满电。
有了这个定义，我们现在可以运行每一个 bandit 算法，最多运行 500 个时间步，结果如下:
(注:用于生成这些结果的完整测试系统可在 github 笔记本中获得。)
图 6.1:在 5 插座电源问题上 bandit 算法的比较。
从上图我们可以看出:
- 乐观贪婪，UCB 和汤普森采样都在大约相同的时间步数内达到所需的最大电荷(这就是为什么乐观贪婪和汤普森采样的线被 UCB 的线遮住)。
- 在每种情况下， 后悔 对于这些算法来说几乎为零。当任何插座的最大可用电量为 12 秒时，每个插座仅用了 300 个时间步来达到 3600 秒的最大所需电量。所以最佳插座被快速定位，然后被充分利用。
- Epsilon Greedy 另一方面，达到最大充电量需要稍长的时间。因为它在整个运行过程中继续探索套接字集，所以它未能完全利用最佳套接字。
- 而且，最糟糕的是贪心算法。它实际上无法在可用时间内达到最大电量。
所以，从给婴儿机器人充电的角度来看，任何一种乐观贪婪*、 UCB 或汤姆森采样算法都可以完成这项工作。但是需要注意的是乐观贪婪和 UCB 都需要设置一个参数(这些参数是乐观贪婪的初始值和 UCB 的置信度值)。对这些参数做出错误的选择会导致算法性能下降。*
由于汤普森采样不需要设置参数，所以这不是问题，因此这可能是选择使用哪种算法的决定性因素。
增加了问题难度
我们到目前为止所使用的套接字问题被故意做得非常简单，以允许对每个算法的探索和利用机制进行说明。然而，在寻找最佳算法方面，它有几个主要缺点。
- 首先，它只有五个插座。因此，即使使用贪婪算法的随机搜索，也有 20%的机会找到最佳插座。对于更高级的搜索机制，它们可以快速定位并锁定最佳插座，因为要测试的插座很少。
- 其次，每个插座都有非常明显的奖励。由于我们设置的实验中插座的充电间隔为 2 秒钟，其奖励有一个单位变化，因此插座和下一个最佳插座返回的电量几乎没有重叠。一旦尝试了最好的插座，任何其他插座返回的电荷都不太可能大于该值。这使得识别哪个插座是最佳的变得非常容易。
为了克服我们原始实验中的这些不足，让我们将插座的数量增加一倍，并减少插座可以返回的电荷数量的差异，将充电时间从 2 秒减少到 0.2 秒。有了这些值，套接字的输出现在看起来如下:
图 6.2:10 个插座的奖励分布。插座顺序定义了插座的相对品质，从最低到最高输出，10 是最好的(插座 4)，1 是最差的(插座 3)。
图 6.3:插座输出的密度图。插座 4 的平均输出最高，插座 3 的平均输出最低。
现在我们有 10 个插座，一个插座的平均回报和下一个最好的插座之间有 0.2 秒的充电差异。这意味着回报有更大的重叠。
插座顺序[7，5，1，10，2，3，6，8，9，4]以递增的顺序定义了插座的好坏，因此插座号 1 是第七好的插座，并且将具有(70.2 +2) = 3.4 秒的充电的平均回报(+2 只是防止插座具有负值的偏移值)。因此，最好的插座是插座 4，平均回报为(100.2 +2) = 4，最差的插座是插座 3，平均回报为(10.2 +2) = 2.2。*
需要注意的其他几点是:
- 因为我们已经减少了插座平均值的分布，最好的插座现在的输出比我们只测试 5 个插座时的输出低。因此，达到我们定义的最大总奖励(充电 3600 秒)所需的时间步数将会增加。
- 我们在 5 插槽实验中为 UCB 和乐观贪婪算法保留了相同的参数，因此调整这些值可能会得到更好的结果。
使用此新设置运行会产生以下结果:
**
图 6.4:bandit 算法在 10 插座电源问题上的比较，电荷分布为 0.2 秒。
现在我们可以看到算法性能的一些分离:
- 和以前一样，贪婪算法的表现比其他算法差得多。 Epsilon Greedy ，虽然比简单的 Greedy 算法好很多，但还是比其他 3 个算法差。
- 虽然数量不多，但汤普森取样比其他的要好。
如下所示，对于 100 个套接字，随着套接字数量的增加和平均奖励值的分布的减小，算法中的这种差异变得更加明显，分布为 0.1(注意，现在最大套接字输出再次为 12 (=0.1100 +2)😗
**
图 6.5:bandit 算法在 100 插座电源问题上的比较，电荷分布为 0.1 秒。
对于 100 个插槽，有趣的是注意到 UCB 和乐观贪婪算法的性能比ε贪婪算法差。事实上，当汤普森取样达到最大电荷时，这些其他算法都没有超过ε贪婪的总平均回报。
可以看出，这是由 UCB 和乐观贪婪算法的启动回合引起的，在此期间，每个插座被精确地测试一次(注意直到第 100 个时间步长的较低梯度)。因此，对于第一个 100 时间步， UCB 和乐观贪婪正在努力完成 100 个套接字中的每一个，而ε贪婪和汤姆森采样已经开始利用他们发现的最好套接字。
如果我们让实验运行更多的时间步，那么 UCB 和乐观贪婪可能会超过ε贪婪的平均总回报，并在此之前达到满负荷。然而，如果机器人宝宝用汤普森取样算法选择了插座，他就已经充满电了。
语境强盗
我们看到的基本 bandit 算法的一个主要缺点是它们没有考虑任何可用的上下文信息。
例如，想象一下电源插座是用颜色编码的，这种颜色表示将返回的电量。如果在完成我们的试验后，我们发现蓝色插座充电很多，而黄色插座充电很少，那么下次我们进入充电站时，优先选择蓝色插座而不是黄色插座是有道理的。
基本的强盗算法只是采取一个行动，收集奖励，并不关注他们的当前状态。因此，可能有助于选择最佳行动的当前状态的潜在有用信息被简单地忽略。
情境强盗(也称为“关联强盗”)通过使用来自当前状态的信息来帮助指导他们选择行动，从而解决了这一限制。因此，它们既可以被认为是复杂的强盗算法，也可以被认为是强化学习的简化版本。
在完全强化学习问题中，所采取的行动可以导致状态的改变，并因此导致新的上下文信息。因此，所选择的行动会对未来可能获得的回报产生影响。例如，在一盘棋中，一个看起来很好并能立即给予很大回报的走法(比如拿下对方的皇后)实际上可能会导致你输掉比赛。因此，这实际上被认为是一个糟糕的举动。真正的奖励会延迟，直到游戏结束才会收到。
在上下文盗匪中，这些条件都不存在；行动不会改变状态，回报是即时的，而不是延迟的。
Bandit 算法的使用
那么，除了给婴儿机器人充电或者下次你在拉斯维加斯时在吃角子老虎机上赢得你的财富，多臂强盗算法还能用来做什么呢？
免责声明: 众所周知，拉斯维加斯的赌场老板对在赌场中使用算法的人非常敏感。因此，在使用这些算法的过程中，我不承担任何物理或经济损失的责任！
多武装匪徒可能有两个主要的使用领域:
首先是我们如何使用它们，作为全面强化学习的垫脚石。多臂土匪的很多概念，比如动作和奖励，直接适用于完全强化学习(RL)问题。实际上，在完全强化学习中，一个多臂强盗可以被认为代表一个单一的状态。此外，贪婪的动作选择虽然可能不是解决 bandit 问题的最佳方法，但通常用于在 RL 中的不同动作之间进行选择。
bandit 算法的第二个主要应用领域是在真实世界测试中。这可以发生在任何领域，但在在线商务、医疗保健和金融领域尤为普遍。
例如，当评估网页的变化如何影响其性能时，这可以通过多种方式来衡量，如页面产生的销售额或点击率，标准方法是使用 A/B 测试。这需要两个或更多不同的页面变体，然后通常将每个变体同等地呈现给站点用户，以观察他们的表现。在预定的时间段之后，比较来自每个页面的统计数据，然后将表现最好的页面作为获胜页面。
很明显，这种形式的测试有一个主要缺点:在测试期间，相同数量的客户被发送到一个性能不佳的网页。如果这个页面的性能特别差，它可能会对你的网站的整体性能产生很大的负面影响。通过有一段时间专门用于勘探，A/B 测试继续调查表现不佳的选项。
相比之下，在多臂 Bandit 方法中，页面根据用户测量的相对性能呈现给用户。表现好的页面将越来越多地显示，表现差的页面将较少显示。以这种方式，可以测试对网站的改变。提高性能的好特性会立即得到提升，产生积极的影响，而在 A/B 测试中会持续产生负面影响的坏特性会很快被丢弃。
多臂匪在临床试验中的使用方式类似。显然，在药物试验期间，继续给患者服用会导致患者出现负面副作用的药物是个坏主意。因此，多臂 Bandit 算法已经被用于决定给患者的药物和剂量，以最大化积极的结果。
为了更全面地了解 Bandit 算法的实际应用，我推荐阅读以下文章:
" 多武装背景土匪 实际应用调查"，Djallel Bouneffouf，Irina Rish (2019)
结论
我们已经看到，当面临必须在各种不同选项之间进行选择的问题时，选择这些选项中任何一个的回报最初都是未知的，诸如汤姆森抽样或置信上限(UCB)* 之类的算法比简单地从选项中随机选择要好得多。有了这些算法，我们可以最大限度地减少尝试错误行动的次数，最大限度地增加采取最佳行动的次数。*
通过在插座选择问题中使用这些算法，我们能够快速定位和利用最佳插座，并让机器人宝宝充电上路。
在后续文章中，我们将会看到更高级的强化学习(RL)* 技术，其中一些利用了这些 bandit 算法。利用这些，我们将帮助机器人宝宝找到回到妈妈身边的路！*
***注意:*虽然我们已经研究了很多解决多臂强盗问题的方法，但是我们实际上只是触及了所有可用算法的皮毛。如果你想看得更多的话，可以看一看强盗的书。
参考资料:
[1] " 强化学习:导论 "，萨顿&巴尔托(2018)
[2]“汤普逊取样教程 ”，鲁索等，(2017)
[3]“一场语境化的土匪烘培赛 ”，比提等人，(2020)
[4] " 关于多武装和背景土匪的实际应用的调查 "，Djallel Bouneffouf，Irina Rish (2019)
bandit 算法和测试框架的所有代码都可以在 github 上找到:
婴儿机器人强化学习指南。通过创建一个……
github.com](https://github.com/WhatIThinkAbout/BabyRobot)*
下一个系列…
*强化学习导论:第 1 部分
陈述价值和政策评估*
强化学习简介:第 1 部分
towardsdatascience.com](/state-values-and-policy-evaluation-ceefdd8c2369)* 
使用 TF/Keras 比较 DNN、CNN 和 LSTM
视频教程
快速浏览不同的神经网络架构及其优缺点。
视频教程
实验机器学习变得如此有趣！在我对用深度神经网络取代一些信号处理算法进行研究之后，我开始尝试另外两种著名的神经网络架构:LSTM 和 CNN，感兴趣的读者可以参考文章“机器学习和信号处理”。
介绍 CNN 和 LSTM
在我们进入我的比较的细节之前，这里有一个介绍，或者说，我对其他神经网络架构的理解。我们都理解深度神经网络，它只是每层的一组神经元依次与下一层的另一组神经元互连，以此类推。每个神经元实现等式*y = f(Wx+b)*用于输入 x 和输出 y ，其中 f 是非线性激活函数， W 是权重矩阵，而【t3t】这是一张来自 https://playground.tensorflow.org/的图片
美国有线新闻网；卷积神经网络
一个卷积神经网络，CNN，正在增加额外的“过滤”层，除了每个神经元的权重和偏差之外，还可以学习过滤器权重(或者卷积核，如果你喜欢更华丽的词:)。仍然是反向传播在为我们做这项工作，但是我们不能让它对可靠的工作载体反向传播变得太容易！
这是我用 PowerPoint 制作的一张图片，用来解释 CNN。网上有更好的图片，图形很酷，但我不想抄袭别人的作品。当我创作我的内容时，我也必须创作我自己的插图！这就是为什么内容创作是一项艰巨的工作。尽管如此，今天的互联网是由那些创造了令人敬畏的内容的人建立的，因为他们乐在其中！
正如你在上面的图片中看到的，CNN 有几个平行的过滤器，可以被调整以提取不同的感兴趣的特征。当然，我们不会像信号处理中那样设计滤波器，但我们会让反向传播计算滤波器权重。
熟悉信号处理的读者可以连接滤波器组来分离高频和低频。这种思想在图像压缩中有重要作用，可以用滤波器组来分离低频和高频，只需要保留低频。然而，让我们不要跑题。
输入向量被这些“卷积”层中的每一层过滤。它们将输入向量与内核(滤波器脉冲响应)进行“卷积”。卷积是线性系统中的基本运算之一，就像乘法对于数字一样重要。实际上，卷积运算与多项式乘法完全相同。如果您将两个多项式相乘，并用 x=10 来计算结果，您将得到数字的常规长乘法。我又跑题了。
然后，每个卷积层生成自己的输出向量，因此，如果我们有 K 个卷积层，则维度增加 K 。为了减少维度，我们使用“池化”层—计算最大/最小或一定数量样本的平均值。连接所有池层的输出，并通过密集层来生成输出。
RNN 和 LSTM
LSTM(长短期记忆)是一种递归神经网络(RNN)，其中通过“时间”上的输入序列来训练相同的网络。我用引号将“时间”括起来，因为这只是将输入向量分割成时间序列的一种方式，然后通过序列循环来训练网络。
由于在每个时间实例中训练的是同一个网络，或者更确切地说是同一套神经元，我们需要有一种跨时间传递“状态信息”的方法。在一个时间实例中神经元进化到的状态被用作下一个时间实例中神经元的附加输入。希望下图能说明这一点。
如果我们用“LSTM 层”代替 RNN 的单一致密层，我们就会得到一个 LSTM 网络。网上有很好的解释 RNN 和 LSTM 的文章——这里有一篇来自 Colah 的博客:“了解 LSTM ”。
RNN 或 LSTM 捕捉输入向量中跨时间序列的相关性。使用 DNN 可以实现相同的效果，但这需要收集跨时间的输入向量，然后将其馈送到一个较大的图层，与 RNN 相比，这需要训练更大的参数集。
比较时间序列预测
有了对 CNN 和 RNN 的介绍，让我们进入本文的主题——比较 DNN、CNN 和 RNN/LSTM。我们将选择时间序列预测作为我们想要解决的问题，但有一个转折！一旦训练好网络，我们不仅会根据输入样本评估它们的预测，还会附加预测样本作为输入，以查看网络生成时间序列的效果如何。基于旧预测的新预测——这是一个很好的挑战！除了是一个有趣的实验，这也有实际应用。
例如，WLAN 中的信道估计发生在前同步码期间，但是需要用于解调，直到整个分组结束。如果它是一个很长的包，信道将随着时间慢慢变化，并且接近包的末尾，如果我们不跟踪信道的变化，我们将得到一个很差的信道估计。由于在有效载荷期间我们没有得到额外的训练符号来估计信道，所以我们需要“预测”信道变化来更新信道。基于预测更新信道估计，然后再次用于下一次预测。如果其中一个预测是错误的，这将导致该错误传播到未来的预测。
作为 ML 从业者的标准，我使用 Jupyter 笔记本来写这篇文章和相关的代码。让我们继续导入常用的。
让我们使用正弦曲线的总和作为输入时间序列。我挺喜欢这个数据的。即使只有三个正弦波叠加，时间序列看起来也足够随机！
DNN 预测性能
我们将从 DNN 开始。我们将向 DNN 提供时间序列的 64 个样本，而 DNN 需要预测第 65 个样本。取 4000 个样本长的时间序列数据，我们将其分成 64 个样本的重叠序列，以生成大约 4000 个批次(换句话说，4000 个输入向量，每个 64 个样本长)。请随意将代码复制到您的 Python 或 Colab 环境中运行，并感受一下我们正在做的事情。
DNN 模型是一个 3 层顺序网络，第一层有 32 个神经元，第二层 8 和第三层 1。
现在让我们开始训练模型，很简单:)
Model: "sequential_7"
_________________________________________________________________
Layer (type) Output Shape Param #
=================================================================
dense_14 (Dense) (None, 32) 2080
_________________________________________________________________
dense_15 (Dense) (None, 8) 264
_________________________________________________________________
dense_16 (Dense) (None, 1) 9
=================================================================
Total params: 2,353
Trainable params: 2,353
Non-trainable params: 0
_________________________________________________________________
DNN training done. Time elapsed: 11.484532 s
我们现在生成测试数据的方式与生成训练数据的方式完全相同，并使用它来评估网络。正如您所看到的，预测与预期输出在合理的准确度上相匹配。
但是基于输入样本的预测很容易。我们有 64 个输入样本来预测第 65 个。让我们评估一下，如果 DNN 必须根据它过去的 64 次预测来预测第 65 个样本，它的表现会有多好！我们在这里所做的就是运行模型来获得每个预测，将预测附加到输入中，并在循环中重复这个过程。
下面的输出显示了相当好的性能。我们可以直观地看到，基于自己过去的预测生成的输出与输入模式相匹配。这意味着我们可以在任何时候关闭网络的输入，让网络依靠自己的输出来产生后续输出，就像信号发生器一样。到目前为止一切顺利！
使用 CNN 预测
现在让我们构建一个 CNN，但是每次只使用 16 个输入来预测下一个样本。“卷积”应该已经能够提取样本之间的时间相关性，并且我们使用 3 个不同的滤波器，每个滤波器具有 4 个抽头的核大小。如果下面的代码被很好地注释了，那么让我们快速地通过训练和验证，进入有趣的部分。
Model: "sequential_2"
_________________________________________________________________
Layer (type) Output Shape Param #
=================================================================
conv1d_2 (Conv1D) (None, 13, 3) 15
_________________________________________________________________
average_pooling1d_2 (Average (None, 3, 3) 0
_________________________________________________________________
flatten_2 (Flatten) (None, 9) 0
_________________________________________________________________
dense_6 (Dense) (None, 16) 160
_________________________________________________________________
dense_7 (Dense) (None, 1) 17
=================================================================
Total params: 192
Trainable params: 192
Non-trainable params: 0
_________________________________________________________________
CNN training done. Time elapsed: 14.113128 s
同样，基于输入样本的预测非常好。但是，亲爱的读者，你有没有注意到 CNN 只需要 192 个参数，而 DNN 需要 2353 个参数？那就小了一个数量级！但是训练有点慢，DNN 是 16 秒，而不是 11 秒。
让我们来看看 CNN 的“信号生成”能力如何。运行下面的代码，我们看到 CNN 的输出在根据过去的预测生成时正在慢慢“衰减”。我知道，用引号说“腐朽”不是一个很科学的分析，但这只是一个有趣的实验！
虽然 CNN 只用 192 个参数就做了很好的预测，但与 DNN 相比，它在永久信号生成方面做得不好。也许增加 CNN 的规模会让它变得更好？很容易得到答案——试一试就知道了！然后去 LSTM。
LSTM 预测
为 LSTM 准备好数据取决于我们希望“回顾”到什么程度。换句话说，在产生输出之前，将训练输入 LSTM 序列的数量。对于我们的例子，我们将使用 4 个序列的回看，并且每个序列是 8 个样本长。请注意，Keras LSTM 层要求输入张量的形状为 (batch_size，lookback=4，input_size=8) ，因此我们只对第一批采样 0 至 31，对第二批采样 1 至 32，依此类推。，连接成一个向量，然后我们将它调整到合适的尺寸。
Model: "sequential_14"
_________________________________________________________________
Layer (type) Output Shape Param #
=================================================================
lstm_8 (LSTM) (None, 16) 1600
_________________________________________________________________
dense_23 (Dense) (None, 1) 17
=================================================================
Total params: 1,617
Trainable params: 1,617
Non-trainable params: 0
_________________________________________________________________
LSTM training done. Time elapsed: 27.157384 s
我们看到，基于输入样本的预测性能非常准确，但训练速度要慢得多，即使参数数量是 DNN 的一半。
如果我们在信号产生模式下运行 LSTM，它似乎表现不错，但仍会遗漏 DNN 设法捕捉到的低频调制。这又是一个假象，DNN 看了 64 个样本，而 LSTM 只看了 32 个。继续尝试将回看增加到 8，让 LSTM 每次输出 64 个样本，你会发现它做得和 DNN 一样好。
顺便说一句，如果你尝试了上述改变回看的实验，你会注意到关于 LSTM 的另一个很酷的事实。当您改变回望时，我们必须训练的参数数量保持不变。这意味着你可以在不增加网络规模的情况下观察很长的输入序列——这就是它的威力所在！
LSTMs 已经非常成功地用于语音识别和 NLP 中的各种各样的问题，在这些问题中，我们必须着眼于长期历史。想象一下和 DNN 这样做，你会有一个庞大的网络在手。
%tensorboard --logdir logs
结束语
总结一下，我们看到，对于我们选择进行实验的简单时间序列预测问题，所有三个网络都表现相似。如果我们评估它们根据以前的预测生成新预测的能力，我们会再次看到，只要每个网络都在相同数量的输入样本上进行训练，性能还是相似的。
#plt.plot(dnn_predictions[1000:1200])
#plt.plot(lstm_predictions[1000+8:1200],'r')
#plt.show()
mse_dnn = np.mean(pow(keras_dnn_err,2))
mse_cnn = np.mean(pow(keras_cnn_err,2))
mse_lstm = np.mean(pow(keras_lstm_err,2))
print("MSE for DNN, CNN and LSTM: ", mse_dnn, mse_cnn, mse_lstm)MSE for DNN, CNN and LSTM: 0.015292015168751526 0.10264436557722294 0.021495189602411965# Summary of training run time
print("DNN training time: ", dnn_train_time, "s")
print("CNN training time: ", cnn_train_time, "s")
print("LSTM training time: ", lstm_train_time, "s")DNN training time: 11.484532 s
CNN training time: 14.113128 s
LSTM training time: 26.689297 s
CNN 可以用来减少我们需要训练的参数数量，而不牺牲性能——结合信号处理和深度学习的力量！但是训练比 DNN 慢了一点点。
LSTM 比 CNN 需要更多的参数，但只有 DNN 的一半。虽然训练速度最慢，但它们的优势在于能够在不增加网络规模的情况下观察长序列的输入。
亲爱的读者，这篇文章到此结束。我感谢你的时间，并希望你得到一点点的洞察力作为回报。
https://www.linkedin.com/in/prasannasethuraman/
XGBoost & PyTorch 之战
XGBoost 和 PyTorch 的非技术性比较
TL；DR —这篇文章比较了 XGBoost 和 py torch——两个最流行的 ML 库——并讨论了哪一个更好。你可以在现场调查中了解社区的想法。
免责声明 *:所有观点都是我的，不代表我雇主的。*我交替使用“算法”、“模型”和“库”。
一个选择
在一次虚拟咖啡会上 COVID 期间保持联系的新方式——我最小的表弟正在完成他的数据科学硕士学位，Shawn 问道:“在 XGBoost 和 PyTorch 之间，我应该学哪个？”
事实上，我经常遇到同样的问题，甚至当我与有多年行业经验的客户一起工作时。
一方面，XGBoost 帮助赢得了大部分 Kaggle 比赛。另一方面，PyTorch 已经被领先的技术和研究公司公认为最佳图书馆。这两个库在构建质量和活跃的社区支持方面不相上下。
如果你有世界上所有的时间、资源和精力，答案显然是“两者都学”。我们大多数人都没有这样的奢侈。在大多数情况下，我建议:从 XGBoost 开始，然后是 PyTorch。
让我们从三个简单的角度来看:供给、需求、以及你的情况和愿望。
1.供给:图书馆擅长什么？
通过设计，XGboost 和 PyTorch 可以有效地解决不同类型的 ML 用例。
XGBoost 对于使用结构化数据的**“传统的”ML 用例非常有效(例如，使用良好的旧表格数据进行分类或回归)。PyTorch 专为需要神经网络模型架构的非结构化数据(例如，使用图像的生成模型或使用文本的自然语言处理)的“创新”用例**而构建。每个图书馆的教程页面都反映了这种差异和他们想要的“定位”。
XGBoost 教程关于牛逼的 XGBoost ，2020 年 5 月 22 日抓拍
官方 PyTorch 教程页，拍摄于 2020 年 5 月 24 日
鉴于 XGBoost 和 PyTorch 的不同优势，我们必须根据实际的 ML 用例进行挑选。
在学习的背景下，我相信一项新技能应该为我们提供最大限度的即时适用性(我能即时并频繁地使用它吗？)，这通常会带来更多的职业选择。
2.需求:工作中通常需要什么样的 ML 解决方案？
“无聊”和简单的东西。根据最新的 Kaggle 调查(以及我自己与该行业团队合作的经验)，大多数数据科学家将大部分时间花在使用“基本”ML 解决方案解决问题上，如线性回归、决策树或梯度推进。 XGBoost 擅长这些任务。
作者基于 2019 年 Kaggle 调查的分析
换句话说，如果你学习并使用 XGBoost，你可以更好更快地解决大部分枯燥的问题。然后，用节省下来的时间，你可以用 PyTorch 做创新的事情(或者只是喝杯咖啡，和家人在一起，或者做其他你喜欢的事情)🙂
3.你:你今天在哪里，你的志向是什么？
根据我的调查和一般观察，我们大多数人都在大公司工作，作为默默无闻的英雄——专注于非研究、运营业务问题的数据科学家。
作者的数据和分析
在大公司中，增加价值和获得认可的最直接、最可行的方法是进行渐进式创新。大公司中许多现有的 ML 应用程序是“无聊”的，但却是业务的核心用例；它们由过时和简单的算法驱动，例如使用 Sklearn ( Kaggle 调查和作者的行业经验)的逻辑回归识别客户倾向，或者根据监管和领域经验使用基于规则的定制引擎标记欺诈活动。
用 XGBoost 改进这些应用程序可能会在最短的时间内提供最大的预期投资回报,相比之下，比如说，说服你的老板使用花哨的 PyTorch 模型将客户情绪与面部识别结合起来。
总之，如果你喜欢操作问题，并希望在当前的职位上留下来并取得进步，学习 XGBoost(以及类似的算法，如 Light GBM)可以让你立即取得成果，并使你成为一个著名的英雄。
如果你像调查中的许多人一样，希望成为超级极客，专注于研究型项目，仍然学习 XGBoost 以最大化职业选择性，但现在投资 PyTorch。
现场调查
这是一个现场社区调查，以捕捉更多人的想法，并消除我的观点和经验的偏见。
喜欢读什么？ 与我连线上 中 ，LinkedIn，或者Twitter。还有，作为一名数据科学家，要不要学习商业思维和沟通技巧？查看我的《 用机器学习影响 》指南。
您可能也会喜欢这些文章:
每个懒惰的全栈数据科学家都应该使用的 5 套工具
towardsdatascience.com](/the-most-useful-ml-tools-2020-e41b54061c58) [## 我们应该留在数据科学领域吗？
数据科学家的 4 个现实职业选择
towardsdatascience.com](/the-most-realistic-data-science-career-guide-d12c4af87cc8) [## 下一个最佳数据科学工作
数据科学家最受欢迎的过渡路线
towardsdatascience.com](/the-best-data-science-transition-routes-e809254934d0) [## 被遗忘的算法
用 Streamlit 探索蒙特卡罗模拟
towardsdatascience.com](/how-to-design-monte-carlo-simulation-138e9214910a) [## ML 和敏捷注定的联姻
如何不对 ML 项目应用敏捷
towardsdatascience.com](/a-doomed-marriage-of-ml-and-agile-b91b95b37e35) [## 优步的机器学习让我失望
实时对抗优步黑客&给优步的建议
towardsdatascience.com](/how-to-improve-uber-machine-learning-c83051d6e57f)
免费数据科学资源汇编
自定进度学习
对于那些对学习数据科学感兴趣的人
想自学数据科学？不知道从哪里开始？或者，也许你想加深对某些话题的理解？继续读。
我已经按照媒体类型对免费资源的汇编进行了分类，其中一些可能包含统计、数据分析、python、机器学习和/或深度学习等主题的混合。我将说明(只要适用)何时资源仅用于一个特定的数据科学主题。也有很多网站可以帮助你学习/练习 R、Python、SQL 等语言的编码技巧。(HackerRank 是一个有趣的工具)，但本文将更侧重于帮助您学习数据科学概念以及如何在数据分析/机器学习应用程序中使用编码语言的工具。
快乐学习！
网站
数据科学 101
这个网站有非常棒的资源档案(这个部分的标题直接链接到免费的资源)。从的教科书到常春藤联盟的课程笔记到博客文章，你可以从数据科学 101 中学到很多东西。
开源代码库
GitHub 奇妙的协作精神导致了数据科学博客的这个巨型列表。这里有大量的博客，所以我会确保你选择阅读/关注的博客是可信的。
宾州州立大学在线统计
在您开始学习数据科学之前，这份在线课程材料对于学习基础统计学非常有用。我收藏了好几页宾夕法尼亚州立大学的书作为参考。
Udemy 上的免费机器学习课程
哇！本页有很多关于机器学习的免费课程。我建议看看评价最高的，也看看评论，找到一个适合你的需求。
开源教科书
用于数据分析的 Python
老实说，我不相信这本书是免费的。在 Python 中，使用 Pandas 和 NumPy 库进行数据分析非常深入。还有一个 GitHub 库,里面有 Jupyter 笔记本，每一章都有练习的答案！****
深入学习
开源，找到贡献者这里。
我本人没有读过这本书，但它是我的数据科学导师推荐给我的。它的格式非常好,带有讨论板和 GitHub 上补充代码的链接。主题包括多种类型的神经网络、优化算法&计算性能、自然语言处理、推荐系统等等。当我有时间的时候，我很高兴能读完这本书。
播客
数据怀疑论者
这是我听过的唯一一个数据科学播客，但它太有趣了！对于主持人来说，现在的一大焦点是机器学习的可解释性，但他也在他的最新章节中涵盖了其他相关主题(如对抗性神经网络和伦理算法设计)。有些插曲对我来说有点太深入了，但总体来说，它加深了我对该领域热门话题的理解，并有助于增加我对数据科学的热情。(数据怀疑论者)
其他的
数据科学会议
上meetup.com网站，搜索你所在地区的数据科学会议(这主要适用于那些生活在大城市或大城市附近的人)*。我住在丹佛附近，我参加了一个为数据科学领域的女性举办的名为“代码和咖啡”的聚会这是一个与其他女性讨论数据科学的美好时光，这些女性要么已经在这个领域工作，要么希望进入这个领域。这个团队的领导者非常棒——他们真心希望帮助其他女性实现职业目标或她们的副业项目。
- 由于冠状病毒疫情，目前没有安排见面会。但是，您仍然可以在他们的页面上搜索组。
就我在本文中包含的链接数量而言，有些链接肯定会在某个时候过期或更改。如果您发现某个链接不再有效，请在下面发表评论。此外，请随意评论您自己喜欢的免费资源，这些资源不在此列表中！
所有没有注明出处的图片都是我自己在 canva.com 制作的。
文档相似性算法初学者完全指南
了解欧几里得距离、余弦相似度和皮尔逊相关度背后的代码和数学，为推荐引擎提供动力
我已经在产品中部署了一些推荐系统。毫不奇怪，最简单的被证明是最有效的。
大多数推荐系统的核心是协同过滤。协同过滤的核心是文档相似性。
我们将介绍计算文档相似性的 3 种算法。
1)欧几里德距离
2)余弦相似度
3)皮尔逊相关系数
即使是对它们如何工作的一般直觉也会帮助你选择合适的工具来工作，并建立一个更智能的引擎。
这些算法的共同点
在我们讨论算法时，请记住这些警告。
- 计算在对象的矢量表示上进行。每个对象必须首先转换成一个数字向量。
- 一次计算一对向量之间的相似性/距离。
- 无论算法如何，特征选择都会对结果产生巨大影响。
欧几里得距离
简单地
欧几里德距离是多维空间中两点之间的距离。
更近的点彼此更相似。进一步的点彼此更不同。所以以上，马里奥和卡洛斯比卡洛斯和珍妮更相似。
我有意选择了二维(又名。特点:【财富，朋友】)因为容易剧情。我们仍然可以计算超过 2 维的距离，但是需要一个公式。
直观上，这种方法作为距离测量是有意义的。您将文档绘制成点，并且可以用尺子测量它们之间的距离。
用欧几里德距离比较城市
让我们比较三个城市:纽约、多伦多和巴黎。
多伦多= [3,7]
纽约= [7,8]
巴黎= [2,10]
特征向量包含两个特征:[population, temperature]。人口以百万计。温度单位是摄氏度。
现在，因为我们再次将问题框定为二维，我们可以用尺子测量点之间的距离，但我们将使用这里的公式。
无论是 2 维还是 1000 维，该公式都适用。
在 Python 中实现欧几里德距离
没有人比我更讨厌数学符号，但下面是欧几里得距离的公式。
原谅我的徒手画
让我们写一个函数来实现它并计算两点之间的距离。
from math import sqrtdef euclidean_dist(doc1, doc2):
'''
For every (x,y) pair, square the difference
Then take the square root of the sum
'''
pre_square_sum = 0
for idx,_ in enumerate(doc1):
pre_square_sum += (doc1[idx] - doc2[idx]) ** 2
return sqrt(pre_square_sum) toronto = [3,7]
new_york = [7,8] euclidean_dist(toronto, new_york)
#=> 4.123105625617661
好吧。多伦多和纽约之间的距离是4.12。
使用 Sklearn 的欧几里德距离
我们上面写的函数效率有点低。Sklearn 使用 Numpy 实现了一个更快的版本。在生产中，我们只用这个。
toronto = [3,7]
new_york = [7,8]import numpy as np
from sklearn.metrics.pairwise import euclidean_distancest = np.array(toronto).reshape(1,-1)
n = np.array(new_york).reshape(1,-1)euclidean_distances(t, n)[0][0]
#=> 4.123105625617661
注意，它需要数组而不是列表作为输入，但是我们得到了相同的结果。布雅！
余弦相似性
简单地
余弦相似度是多维空间中两点之间夹角的余弦。角度越小的点越相似。角度越大的点差别越大。
虽然难以理解，余弦相似性解决了欧几里德距离的一些问题。即大小。
一篇文章中提到“烹饪”和“餐馆”的次数
在上图中，我们根据三个文档包含单词“cooking”和“restaurant”的次数来比较它们。
欧几里德距离告诉我们博客和杂志比博客和报纸更相似。但我认为这是误导。
博客和报纸可以有相似的内容，但在欧几里得意义上是遥远的，因为报纸更长，包含更多的单词。
在现实中，他们都更多地提到“餐馆”而不是“烹饪”,可能彼此更相似。余弦相似度不属于这个陷阱。
用余弦相似度比较书籍和文章
让我们完成上面的例子。我们将基于特定单词的计数来比较文档
magazine_article = [7,1]
blog_post = [2,10]
newspaper_article = [2,20]
我们现在从原点开始，取它们之间角度的余弦，而不是取它们之间的距离。现在，即使只是目测，博客和报纸看起来更相似。
在 Python 中实现余弦相似性
注意余弦相似度不是角度本身，而是角度的余弦。因此，较小的角度(小于 90 度)返回较大的相似性。
https://en.wikipedia.org/wiki/Cosine_similarity
让我们自己实现一个函数来计算这个。
import numpy as np
from math import sqrtdef my_cosine_similarity(A, B):
numerator = np.dot(A,B)
denominator = sqrt(A.dot(A)) * sqrt(B.dot(B))
return numerator / denominator
magazine_article = [7,1]
blog_post = [2,10]
newspaper_article = [2,20]m = np.array(magazine_article)
b = np.array(blog_post)
n = np.array(newspaper_article)
print( my_cosine_similarity(m,b) ) #=> 0.3328201177351375
print( my_cosine_similarity(b,n) ) #=> 0.9952285251199801
print( my_cosine_similarity(n,m) ) #=> 0.2392231652082992
现在我们看到，博客和报纸确实更加相似。
与 Sklearn 的余弦相似性
在生产中，我们最好导入 Sklearn 更高效的实现。
from sklearn.metrics.pairwise import cosine_similaritym = np.array(magazine_article).reshape(1,-1)
b = np.array(blog_post).reshape(1,-1)
n = np.array(newspaper_article).reshape(1,-1)print( cosine_similarity(m,b)[0,0] ) #=> 0.3328201177351375
print( cosine_similarity(b,n)[0,0] ) #=> 0.9952285251199801
print( cosine_similarity(n,m)[0,0] ) #=> 0.2392231652082992
相同的价值观。太好了！
皮尔逊相关
这通常量化了两个变量之间的关系。比如教育和收入。
完全虚构的数据
但是我们也可以用它来度量两个文档之间的相似性，我们将第一个文档的向量视为x，将第二个文档的向量视为y。
因为皮尔逊相关系数r返回 1 和-1 之间的值，所以皮尔逊距离可以计算为1 — r以返回 0 和 2 之间的值。
用 Python 实现皮尔逊相关系数
让我们自己实现这个公式来理解它是如何工作的。
https://en . Wikipedia . org/wiki/皮尔逊相关系数
我们将生成一些代表少数人的假数据。我们将基于三特征向量来比较它们有多相似。
emily = [1,2,5]
kartik = [1,3,5]
todd = [5,3,5]
我们的实现。
import numpy as npdef pearsons_correlation_coef(x, y):
x = np.array(x)
y = np.array(y)
x_mean = x.mean()
y_mean = y.mean() x_less_mean = x - x_mean
y_less_mean = y - y_mean
numerator = np.sum(xm * ym)
denominator = np.sqrt(
np.sum(xm**2) * np.sum(ym**2)
)
return r_num / r_denpearsons_correlation_coef(emily,kartik)
#=> 0.9607689228305226
酷毙了。艾米莉和卡蒂克看起来很相似。我们一会儿将把这三个和 Scipy 进行比较。
皮尔逊相关系数与 Scipy
Scipy 实现了一种更高效、更健壮的计算。
emily = [1,2,5]
kartik = [1,3,5]
todd = [5,3,5]pearsonr2(emily,kartik)print( pearsonr2(emily, kartik) )
#=> (0.9607689228305226, 0.1789123750220673)
print( pearsonr2(kartik, todd) )
#=> (0.0, 1.0)
print( pearsonr2(todd, emily) )
#=> (0.27735009811261446, 0.8210876249779328)
虽然我选择了随机数作为数据点，但我们可以看到艾米丽和卡蒂克比艾米丽和托德更相似。
结论
虽然我们已经解决了这个难题的一部分，但是通往完全成熟的推荐器的道路还没有完成。
在电子商务引擎的上下文中，我们接下来将构建每对用户之间的相似性得分矩阵。然后我们可以用它来推荐相似用户购买的产品。
也就是说，一个好的推荐系统可能还包含基于领域的规则和用户偏好。
Python Numpy 数据科学矩阵乘法初学者完全指南
通过 Python 示例学习机器学习的矩阵乘法
线性代数是从逻辑回归到深度神经网络的机器学习的基础。
如果你从事数据科学已经有一段时间了，但是不理解它背后的数学，矩阵乘法是最好的起点。它平易近人，实用，让你熟悉机器学习的数学对象:标量，向量和矩阵。
哦，是的，Numpy 在公园里散步。
到本文结束时，您将对矩阵乘法有一个实际的理解。
什么是矩阵
这里我们将对比矩阵和标量。
一个矩阵是一个 2D 数组，其中数组中的每个元素有 2 个索引。比如[[1, 2], [3, 4]]是一个矩阵，1的索引是(0，0)。
我们可以用 Python 和 Numpy 来证明这一点。
import numpy as npA = [[1, 2],
[3, 4]]np.array(A)**[0,0]**
=> 1
当谈到矩阵的形状时，我们说“行 x 列”。我们会说下面的第一个矩阵的形状是 2x2，第二个矩阵的形状是 3x2。
[[1, 2],
[3, 4]][[10, 20],
[11, 21],
[12, 22]]
相比之下，标量只是一个数字，就像数字5一样。
标量乘法
矩阵乘法的简单形式叫做标量乘法，将一个标量乘以一个矩阵。
标量乘法一般很容易。输入矩阵中的每个值都乘以标量，输出与输入矩阵的形状相同。
让我们用 Python 的 Numpy 来做上面的例子。
a = 7
B = [[1,2],
[3,4]]np.dot(a,B)=> array([[ 7, 14],
=> [21, 28]])
再举一个标量乘法的例子。这次是一个标量乘以一个 3×1 矩阵。
在 Numpy。
a = 4
B = [[1],[2],[3]]np.dot(a,B)=> array([[ 4],
=> [ 8],
=> [12]])
标量乘法的顺序无关紧要。“标量 x 矩阵”和“矩阵 x 标量”给出了相同的结果。但当两个矩阵相乘时就不一样了。
矩阵乘法
现在到了有趣的部分。将 2D 矩阵乘以 2D 矩阵。
有几件事需要记住。
- 现在秩序很重要。
AB != BA - 如果第一个矩阵的列数等于第二个矩阵的行数，则矩阵可以相乘
- 乘法是行和列的点积。第一个矩阵的行和第二个矩阵的列
示例 1
在上图中，输出矩阵的(0，0)索引中的19是第一个矩阵的第一行和第二个矩阵的第一列的点积。
让我们用 Python 复制这个结果。
A = [[1,2],
[3,4]]B = [[5,6],
[7,8]]np.dot(A,B)=> array([[19, 22],
=> [43, 50]])
让我们反复强调秩序这一点。试试np.dot(A,B)再试试np.dot(B,A)。
np.dot(A,B)
=> array([[19, 22],
=> [43, 50]])np.dot(B,A)
=> array([[23, 34],
=> [31, 46]])
现在请注意输出是如何不同的！你会发现在纸上计算它会得到同样的结果(如果你不熟悉矩阵的话，这是很不直观的)。
示例 2
现在我们将一个 2×3 的矩阵乘以一个 3×2 的矩阵。
而在 Python 中用 Numpy。
A = [[1,2,3],
[4,5,6]]B = [[10,11],
[20,21],
[30,31]]np.dot(A,B)=> array([[140, 146],
=> [320, 335]])
示例 3
最后一个例子。将 1×5 乘以 5×1 矩阵。
请注意，我们在这里做的所有计算都只是返回输出矩阵中的一个单元格。
同样，在 Python 中。
A = [[1,2,3,4,5]]B = [[10],
[20],
[30],
[40],
[50]]np.dot(A,B)=> array([[550]])
这涵盖了矩阵乘法的 3 种独特情况，应该能让你对它的工作原理有一个大致的了解。我在图表的每一步都展示了所有的计算，所以你很容易理解。
结论
矩阵乘法(和线性代数)是深度学习和机器学习的基础。
虽然你不需要它来即插即用 Sklearn，但对它的工作原理有一个清晰的印象将有助于你理解它的模型。有了这种理解，就可以更高效地调整这些模型，以获得更好的性能。
使用分类的机器学习完全入门
如果你对数据科学、人工智能或机器学习领域感兴趣，但不知道该去哪里或做什么，那就别再找了。如果你想在大考或面试前温习你的 ML 技能，你来对地方了。这个关于机器学习的介绍，会涉及到行业内数据科学家每天使用的一些最流行的机器学习算法。到本文结束时，您应该会对机器学习的概念更加熟悉，并觉得有能力大胆尝试一些自己的模型。
机器学习基础
我们实施算法不是因为它们存在，我们实施算法是因为它们适合我们正在处理的数据。
-苏马纳·拉维克里希南
- 机器学习历史
- 信不信由你，人工智能和机器学习的想法首次出现在 20 世纪 50 年代，当时艾伦·图灵引入了图灵测试的概念。投入人工智能的时间和金钱一直在波动，但人们对这个主题的兴趣空前高涨。
2.机器学习的类型
- 监督学习:您的模型正在从您试图预测的结果中获得的示例数据中学习(想想 x 值和 y 值)。这意味着您已经对目标以及它如何处理输入数据有了概念。
- 无监督学习:你的模型是从只有输入数据(基本上是没有 y 值的 x 值)的例子数据中学习的。因此，模型必须依靠自己的算法来检测观察值之间的模式。
- 半监督学习:您的模型正在从带有“半监督”数据和“半非监督”数据(一些 x 值有 y 值，一些没有)的示例数据中学习。
- 强化学习:你的模型正在从你试图预测的结果中获得的样本数据中学习——但是，该模型也从它在预测过程中收到的正面/负面反馈中学习。这种类型的学习与尝试和错误的想法有关。
3.监督学习的类型
- 有两种主要类型的监督学习，分类和回归。尊重上面 Sumana 给出的建议并选择适合您正在处理的数据的算法是很重要的。这将决定你使用哪一种。
- 分类:目标反应，或 y，是绝对的。例如，这可能是一个需要预测测试结果(通过/失败)、天气类型(晴天/下雨/刮风)或大学年份(大一/大二等)的模型。
- 回归:目标响应，或 y，是连续的或数字的。在这种情况下，这可能是一个可以预测美元年薪或千克体重的模型。
4.假设检验
- 假设检验由两个假设组成:零假设和替代假设。
- 当我们进行假设检验时，我们从检验中得到的驱动我们最终决策的可量化结果被称为 p 值。
- 显著性水平，或者我们希望在测试准确性上给自己留的回旋余地，被称为 alpha。
- 这种检验的目的是探索零假设是否成立，或者正在讨论的数据是否提供了足够的信息，使我们能够拒绝零假设并接受替代假设。
数据本身并不有趣。我们真正感兴趣的是对数据的解释。
——苏马纳·拉维克里希南
朴素贝叶斯分类
- 分类
- 分类是监督学习的一种形式，旨在预测分类变量(职业、团队名称、颜色等)。)
2.条件概率
- 条件概率用于计算两个或更多相关事件发生的概率。
- 相关事件是其结果相互之间有某种影响的事件
- 例如，一个人从一副牌中抽出一张 k 和一张 8 的概率
- 这个事件是相关的，因为取出一张牌会使牌堆变小，并且在第二次尝试时更容易得到你想要的那张牌。
3.贝叶斯定理
- 在许多情况下，科学家需要知道一个事件发生的可能性。此外，他们通常有以前事件的数据来帮助他们的计算。贝叶斯定理来了，计算某个事件的概率，事件 B，给定一个已经发生的事件，事件 a。
- 通过使 P (B|A)和 P (A|B)相等，并做一些重新排列，贝叶斯定理的公式变成:
照片由 WWCode 数据科学公司提供
4.朴素贝叶斯
- 使用朴素贝叶斯时，您正在处理的数据集应分成两部分:
- 要素(x)-数据集中会以某种方式影响结果变量的列。把这些想象成一堆潜在的“事件作为”。
- 类变量(y)-数据集中我们试图预测或分类的列。将这些视为潜在的“事件 Bs”。
- 你可能在想——为什么贝叶斯如此天真？这是因为该定理的这个特定版本假设数据集的每个要素都是独立的(意味着一个要素对另一个要素没有影响)。
- 要使用朴素贝叶斯公式，您需要做的就是将表格数据转换为一个或多个列联表，这只是一个包含每个类别计数的表。这些计数将在适当的时候代入公式。
照片由 WWCode 数据科学公司提供
5.朴素贝叶斯变异
- 朴素贝叶斯算法有许多变体，对于某些数据集来说非常方便。
高斯朴素贝叶斯
- 当您有连续的数字特征时，您可以利用高斯朴素贝叶斯算法来预测分类结果。
多项式朴素贝叶斯
- 当您有一堆文本数据要用来预测分类结果时，此算法非常有用。
- 多项式朴素贝叶斯在计算中使用词频来进行预测。
贝叶斯网络
- 当您想要更复杂地调查特征子集之间的条件概率时，贝叶斯网络很有帮助。
决策树和随机森林分类
1.决策树
- 决策树是一种分类算法，它从数据集中学习一组规则，并使用它们进行预测。
- 决策树就像一个流程图。
照片由 WWCode 数据科学公司提供
- 一个根节点(正方形)和一个内部节点(圆形)都代表将要被询问的某种问题。天气晴朗吗？湿度是高、中还是低？
- 分支(线)表示在根或叶节点处对问题的回答。答案决定了您从一个节点沿着哪个分支前进。是的，是晴天还是不是，不是晴天。
- 叶节点(三角形)表示对正在讨论的数据点的最终预测。因为天气晴朗，湿度低，我们预测高尔夫球比赛将会举行。
- 通过观察熵和信息增益这两个度量来构建决策树，这将在下面解释。
2.熵
- 熵基本上是数据样本中不确定性的度量。
- 可以这样想，如果你的数据集中所有 100 场高尔夫比赛都进行了，并且没有一场被取消，那么熵值很低…因为你对这场比赛是否会进行的怀疑很低。
- 如果你的数据集中有 100 场高尔夫比赛，其中 50 场进行了，50 场取消了，这就是高熵。你对下一场比赛有很高的怀疑，因为数据是“命中或错过”。
- 这个过程需要两个熵公式——目标响应的熵(上图)和给定某个特征 X 的目标响应的熵(下图)。
照片由 WWCode 数据科学公司提供
3.信息增益
- 信息增益描述了我们通过向决策树添加节点来了解数据集的知识量。
- 这里有一个真实的例子——假设下周有一场高尔夫球比赛。如果我们知道会下雨，那么我们的预测就会有很大的不同，因为下雨对高尔夫比赛取消有很大的影响。知道是否在下雨会产生很高的信息增益。
- 信息增益的公式使用上面的公式。(这是有道理的，因为随着我们降低不确定性，我们获得了信息。)
照片由 WWCode 数据科学公司提供
4.建造圣诞树
- 基本上，构建决策树的过程是这样的:计算数据样本中每个特征的潜在信息增益。选择具有最高信息增益的一个作为当前节点中的“决策”特征。对其余特征重复计算。
- 一旦您的所有分支都指向一个叶节点(这意味着最终决策)，您就可以停止。
5.优点和缺点
- 决策树易于理解和解释，这使它们成为进行预测的直观方式。
- 此外，它们是朴素贝叶斯的升级，因为特性并不被认为是同等重要的。决策树的整个思想是把最重要的特征放在第一位。
- 然而，当类别标签开始增长时，决策树具有昂贵且复杂的计算。此外，他们无法估计缺失的数据。
- 最后，决策树容易过度拟合，因为它们总是偏向于具有更多样本的类值。例如，如果您的数据样本中有 100 场高尔夫比赛，其中 87 场比赛的湿度较低，那么低湿度可能会导致比赛无法进行。
6.克服决策树的缺点
- 减少决策树缺点的两种方法是剪枝和集成学习。
- 修剪一棵树就是删除那些几乎没有预测能力的节点和分支。我们可以将这些分支视为“边缘情况”或“随机噪声”，因此切断它们可以减少过度拟合。
- 集成学习是将多个“弱”机器学习模型放在一起以形成一个大型、性能更好的学习单元的过程。
7.随机森林
- 随机森林是一种用于决策树的特定类型的集成学习。
- 模型建立在数据的随机子集上，每个模型只关注特征的随机子集。
- 每个单独的树(或“弱学习者”)将做出预测。森林中投票最多的结果将成为真正的预测。
照片由 WWCode 数据科学公司提供
我希望你喜欢这本初学者分类指南。如果你有兴趣将这些知识付诸实践，你可以看看为数据科学 Github 编写代码的女性，在那里她们有我们上面提到的每种机器学习算法的 Python 笔记本。
这篇文章是由从事数据科学编程的女性在为期六周的机器学习入门课程中发表的博文汇编而成。该系列的第一篇帖子最初发表于 2020 年 5 月 17 日https://data dreamer . io。
完整的数据科学组合项目
我最新的端到端数据科学项目概述
马库斯·温克勒在 Unsplash 上的照片
在这篇文章中，我想展示我的有史以来最简单的数据科学项目。
过去，我花了数小时训练一个复杂得多的模型，并努力寻找正确的参数来创建机器学习管道。
尽管很简单，但如果我只能在简历上展示一个项目，那就是这个项目。
我来解释一下原因。
包装决定礼物的价值吗？
小时候，我总是对假期感到兴奋，因为我可以得到礼物。就迁就我一下吧，我保证我确实有道理。我阿姨送给我这件漂亮的衣服，也许比我那天收到的任何礼物都漂亮。
但问题是——我甚至不想打开它。她用报纸破旧地包了起来，在我看到里面的东西之前，礼物似乎已经失去了一半的价值。
回答上面的问题，没有。包装绝不决定礼物的价值。
然而，它可以极大地影响你对里面东西的期望，并改变你对它的看法。
你花数周时间训练的机器学习模型很棒。证明一下。不要让它们死在你的笔记本里。
招聘人员有数百份简历要看。他们几乎不可能通读你在 GitHub 上的所有代码，理解你所有的项目。
要想脱颖而出，你需要做一些稍微不同的事情。创造一个他们可以互动的界面。也许他们可以玩一个实时仪表盘。
即使它不是最好的仪表板或界面，它也会引起人们的兴趣，因为你创造了他们实际上可以使用的东西。
我正是想这样做，这就是为什么我想出了这个投资组合项目。在接下来的几节中，我将详细解释我做了什么，而不会过多涉及技术细节。
目标
我的目标是展示以下领域的技能:
- 数据收集
- 数据争论
- 数据可视化
- 机器学习
- Web 开发
为此，我在项目中创建了以下组件:
- 前端接口
- 电影仪表板
- 电影推荐系统
我将详细解释和演示每个组件。
注意:如果你不想通读整篇文章，只想看一看最终产品，只需向下滚动，看一看“ 链接 ”部分。
前端接口
过去，我会创建项目，让代码放在我的 GitHub 存储库中。我偶尔写一篇文章来解释 Medium 上的项目。
在这里，我采取了不同的方法。
我创建了一个网页，并解释了我的项目的不同组成部分。我简要地写了用户如何与我创建的系统交互，并放上了我的代码和媒体文章的链接。
整个项目可以通过一个页面来理解和访问，这使得人们更容易参与其中。
你可以在这里 — 查看笔记本电脑或个人电脑上的网站，以获得更好的用户界面体验。
电影仪表板
接下来，我用 Tableau 创建了一个电影仪表盘。
涉及的步骤:
数据收集
我不得不从各种不同的地方收集数据。我还想可视化这些电影的 Bechdel 分数(衡量好莱坞女性代表性的指标)，所以我使用了一个 API 来获取这些数据。
数据争论
我清理了数据并将数据集合并在一起。一旦我完成了，我终于可以想象它了！
数据可视化
令人惊讶的是，与这个项目的其他部分相比，这占据了我很大一部分时间。
我花了两天时间试图创建一个视觉上吸引人的仪表板。
我用 Python Dash 应用程序创建了一个。我对布局不太满意，尝试用 R 语言创建一个闪亮的 web 应用程序。
它比我的 Dash 应用程序要好，我喜欢它的功能。然而，我根本不觉得这个设计有吸引力。
最后决定用 Tableau。这只花了我大约一个小时来创作。如果想入门 Tableau，可以看看我创作的这个教程。
您可以在这里查看我的仪表板—在笔记本电脑或 PC 上查看以获得更好的 UI 体验。
推荐系统
最后，机器学习！
我使用与仪表板相同的数据创建了一个简单的推荐系统，并将其部署到 Dash 应用程序中。
只需输入电影名称，它就会使用后端推荐系统为您生成电影建议。
其实这个推荐系统是我刚开始学机器学习的时候创建的。
我在我的 Jupyter 笔记本中找到了代码，并决定对其进行一些清理，以创建这个简单的应用程序。
你可以看看这里的推荐系统—在笔记本电脑或 PC 上查看，以获得更好的 UI 体验。
就是这样！
链接
我希望你喜欢这篇文章，并发现上面的提示很有帮助。Jupyter 笔记本很棒，但是不要让你的项目就这么放在那里。
用你的创造力创造一些其他人可以与之互动的东西。
我在 GitHub 上看到过一些只有一颗星的不可思议的项目。另一方面，我也看到一些非常简单的项目仅仅因为它的呈现方式就获得了很多关注。
然而最重要的是，创建你喜欢做的项目，做你觉得有趣的事情！
关于使用 AWS Glue、Athena 和 QuickSight 的无服务器数据湖的完整指南
无服务器数据湖
无服务器数据湖中 ETL 数据处理、查询和可视化的分步演练
在上一篇 文章 中，我们为流数据创建了一个无服务器的数据湖。我们处理流数据，使用 Kinesis Data Analytics 执行窗口功能，将其存储在 S3 上，使用 AWS Glue 创建目录，使用 AWS Athena 执行查询，最后在 QuickSight 上可视化。
现在让我们通过引入批量摄取来完成我们的 lambda 架构
关于 Lambda 架构的一些背景知识
Lambda 架构 是一种数据处理设计模式，用于处理海量数据，并将批处理和实时处理集成在一个框架内。Lambda 架构是一种混合批处理和流(实时)数据处理的方法，并通过服务层使组合数据可用于下游分析或查看。
待办事项
在本教程中，我将通过自动化批处理摄取工作流来完成我们的 Lambda 架构。
本文将涵盖以下内容:
- 编写 Python Shell 作业以从本地文件服务器获取数据
- 编写一个 Pyspark 作业来处理 upserts、到 parquet 的转换并创建分区
- 运行爬网程序并更新数据目录
- 通过粘合工作流程自动化粘合作业和爬虫
- 在 AWS Athena 中编写分析查询
- 使用 Lambda 函数更新 Quicksight 的数据源
- 在 Quicksight 中创建视觉效果
解决方案概述
这篇帖子是我上一篇帖子的后续: 无服务器数据湖:使用 AWS **存储和分析流数据。**我将使用相同的数据集芝加哥犯罪。该数据集包含 6M 条记录，重 2 GB。我们将把文件放在本地文件服务器上。Python Shell Glue 作业将被安排为每天运行，它将执行批处理摄取。它还将处理 CDC(变更数据捕获)。文件的初始加载完成后，我们将运行 ETL 作业来进行转换和分区数据存储。一旦我们的粘合工作完成，我们将运行我们的爬行器，以注册新创建的分区和模式更改。目录更新后，Athena 将使用 Glue Catalog 对 S3 数据进行查询。我们将使用 lambda 函数来更新 Quicksight 数据源。然后我们的图表会在 Quicksight 上更新。
这里是高层架构:
体系结构
步骤 1-创建您的数据接收作业
首先，我们需要一个数据转储自动化作业，从本地文件服务器的文件夹中取出文件，并将其转储到 S3 存储桶中。这一过程可以通过 Python-Shell Glue job 实现自动化，因为不需要对数据进行转换，而且它是简单的 I/O。我们将使用 python-shell job，该 job 在第一次运行时将执行满负荷，在后续运行时将仅转储新创建或更新的文件。
下面是 Glue Python-Shell 代码:
让我们深入代码，看看那里发生了什么。首先，我们正在导入 boto3 SDK。我们将使用 SSM 参数存储来存储文件服务器的凭证、存储桶路径、文件夹路径和上次 ETL 执行时间。要在参数存储中创建参数，只需登录 AWS 控制台，转到系统管理器，创建一个标准参数并保存其值。我已经分别创建了所有的参数，你可以做同样的事情或者用逗号分隔的值存储一个参数，然后在你的代码中分割它们。
以下是创建参数的方法:
参数存储 Gif
这里我只是加载所有的参数。
接下来，我们使用给定的凭证创建一个与 FTP 服务器的安全 ssh 连接，然后继续打开 SFTP 连接。
这里，我们正在设置 TransferConfig 参数。当上传、下载或复制文件或 S3 对象时，您可以将配置设置存储在boto 3 . S3 . transfer . transfer config对象中。对象被传递给一个传输方法(上传文件、下载文件等)。)在 **Config=参数中。**通常默认设置非常适合一般情况，但是您可以更改此配置来处理您的特殊情况。我正在设置以下参数:
- multipart_threshold: 当文件大小超过 multipart_threshold 属性值时，会发生多部分传输。我已经设置为 100MB 。
- multipart_chunksize: 多部分传输的每个部分的分区大小。我将它设置为 20MB，因为我的文件是 200MB(最大值),默认情况下 max_concurrency 是 10，我的线程得到了适当的利用。你可以根据你的上网带宽定制，增加并发。
config = TransferConfig(multipart_threshold=100 * MB, multipart_chunksize=10 * MB)
接下来，我将遍历文件服务器中的文件，并将它们的最后修改日期与我的 **last_etl_execution_time 进行比较。**每次我的作业成功完成时，它都会将 last_etl_execution_time 存储在参数存储中，以便下次我只加载 last_etl_execution_time 之后更新/创建的文件。
重要的一点
这里需要注意的重要一点是，我使用≥来比较时间，而不是更长，这有一个重要的原因:当我们在 SSM 注册我们的 last_etl_execution_time 时，完全有可能一些新文件上传到我们的文件服务器中，并与我们的 last_etl_execution_time 进行了相同的修改，因此我们需要使用≥来上传我们的 S3 桶中的那些文件，以便任何新文件也得到上传，同时，任何重复的文件都将被自动覆盖(默认的 S3 行为)。
所以总结一下，
- 我们仅在 S3 上使用 last_etl_execution_time 上传新建或更新的文件。
- 使用≥以便与我们的 last_etl_execution_time 具有相同修改日期的任何文件都不会丢失。
最后，我们正在更新我们在 SSM 的last _ ETL _ execution _ time。请记住，第一次执行这个作业时，它将执行满负荷，因此您需要将这个 last_etl_execution_time 设置为一个更早的日期。在我的场景中，我将其设置为 2000–01–01 00:00:00
ssm.put_parameter(Name='Last_ETL_Execution_Time', Value=str(datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')),
Type='String', Overwrite=True)
嗯，就是这样。到目前为止，我们已经完成了 Python-Shell 的工作，并将文件转储到了 S3 bucket 上。现在让我们转到数据的转换和分区。
步骤 2-创建 Pyspark ETL 作业
现在我们将创建一个 Pyspark 作业，该作业将获取更新的或新的文件，根据某个列对它们进行重新分区，并保存为**bucket/year =/month =/**格式和 parquet 格式。我们需要一种方法来跟踪着陆桶中已处理的数据。
AWS Glue 通过保存作业运行的状态信息来跟踪在 ETL 作业的上一次运行中已经处理过的数据。该持久状态信息被称为作业书签。我们将为 Glue Pyspark 作业启用书签。
让我们去 AWS 控制台
步骤 1: 在 AWS Glue 控制台中创建一个新的 Pyspark 作业。
步骤 2: 附加一个具有所需权限的 IAM 角色。在我的例子中，我附加了 AmazonS3FullAccess 、 AWSGlueServiceRole 、CloudWatchLogsFullAccess、amazonsmsmfullaccess策略
第三步:选择一个由你创作的新剧本。
**第四步:**在类型中选择 Spark ，在 ETL 语言中选择 Python 。
步骤 5: 在高级属性中，启用作业书签。
步骤 6: 其余配置可以保留默认配置，在运行和测试胶合作业时，您可以以较低的成本将最大容量更改为 2 个 dpu。
这里是我的配置的一瞥
粘附配置
现在让我们深入研究 ETL 脚本
这里是 Github 上传的代码。请关注或给一颗星:)
让我们一部分一部分地分解它:
- 首先，我导入 Glue 库并创建 Glue 上下文。
- 从目录表创建动态框架。如果您还没有创建表，您需要转到表>添加新表>手动添加列并定义文件的模式。
- 将动态帧转换为数据帧以利用 spark SQL。
- 然后，我创建分区键(月、日)并追加到现有的数据框中(不需要创建年份，因为它已经存在于数据集中)。
- 在我们的bucket/year =/month =/data文件夹中，我们将存储按天分区的数据文件(每天单独的文件)。
- 如果在源文件(本地文件服务器)中更新了文件，那么各个 S3 分区文件夹中的数据将被最新的数据覆盖**(处理的更新)**。
- 重新划分的数据帧被转换回动态帧并存储在 S3 桶中，其中提到了分区键和拼花格式。
这是我们的 Glue Pyspark 作业的输出
S3 桶数据
查看 S3 桶中的输出文件。数据以拼花格式按年和月进行分区。每个月文件夹中的每个文件都包含按天划分的犯罪数据。
创建你的爬虫
一旦您的工作完成，您需要在 S3 桶中注册新创建的分区。我们将使用这项工作的爬虫。如果您的模式从不改变，您可以使用batch_create_partition() glue api 来注册新的分区。更多信息，请参考我的博客这里。在这里，因为我们需要检测任何模式更改，所以我们将为这项工作运行一个 crawler。以下是爬虫的配置。
爬虫配置
运行此 crawler 来注册分区。接下来，我们将在工作流程中使用这个爬虫。
步骤 3:让我们用粘合工作流来编排粘合作业和触发器
工作流通过在粘合实体(触发器、爬行器和作业)之间建立依赖关系来实现 ETL 工作负载的编排。您可以在控制台上直观地跟踪工作流中不同节点的状态，从而更容易监控进度和解决问题。此外，您可以在工作流程中的实体之间共享参数。
通过使用工作流，您不必手动设置不同触发器、爬行器和粘合作业之间的流程
所以是时候了！我们应该创建一个工作流程。但是首先，我们需要决定执行流程。
ETL 执行流程
以上是我们的 ETL 执行流程。我们可以创建一个工作流，轻松监控进度并排除错误，而不是配置 Cloudwatch 事件并自行管理。
现在让我们创建第一个工作流程！！！
- 转到 AWS Glue 控制台，选择工作流程。
- 给它起个名字和描述。点击添加。
- 选择您的工作流程并移至图表选项卡。
- 选择添加触发器。
- 选择**添加新的，**给它一个名称和描述。
- 选择触发类型为计划。
- 选择运行触发器的时间，然后单击添加。
- 现在您可以添加一个将被触发的节点。添加您的 Python-Shell 作业。
- 选择 Python-Shell 作业后，在它之后添加另一个触发器节点，并继续执行流程。最后，您的工作流将如下所示:
胶水工作流程
完成粘合工作流程后，您就可以运行您的工作流程了。
**重要提示:**完成教程后，不要忘记删除您的工作流，否则它将被安排在您设定的时间运行。
用亚马逊雅典娜分析数据
Amazon Athena 是一种交互式查询服务，它使得使用标准 SQL 分析亚马逊 S3 中的数据变得很容易。Athena 能够查询 CSV 数据。然而，Parquet 文件格式大大减少了查询数据的时间和成本。
现在来查询一些数据吧！！！
打开 Athena 的 AWS 管理控制台，连接你的数据库和表。
让我们看看芝加哥每年的犯罪率是多少。
每年的犯罪率
我们将在 Athena 中创建视图，稍后将由 **Quicksight 导入。**您只需在查询请求中添加以下行。
CREATE OR REPLACE VIEW chicago_crimes_usecase1 AS
让我们来看看每月的犯罪率
CREATE OR REPLACE VIEW chicago_crimes_usecase3 AS
SELECT
"date_format"("incident_date", '%M') "month"
, "primary" "primary_type"
, "count"(*) "count"
FROM
chicago_crimes_batch_bucket
WHERE ("primary" IS NOT NULL)
GROUP BY "primary", "date_format"("incident_date", '%M')
ORDER BY "month" ASC
下面是查询结果:
每月犯罪率
让我们来看看芝加哥排名前五的犯罪趋势。
CREATE OR REPLACE VIEW chicago_crimes_usecase6 AS
SELECT
"primary"
, "incident_year"
, "count"
FROM
(
SELECT
"primary"
, "incident_year"
, "count"("primary") "count"
, "row_number"() OVER (PARTITION BY "incident_year" ORDER BY "count"("primary") DESC) "rn"
FROM
chicago_crimes_batch_bucket
WHERE ("incident_year" BETWEEN '2001' AND '2070')
GROUP BY "primary", "incident_year"
) tmp
WHERE ("rn" <= 5)
GROUP BY "primary", "incident_year", "count"
ORDER BY "incident_year" ASC
热门犯罪
我们也有位置数据，所以我们可以显示前 5000 个位置点，并确定哪些地方是热点犯罪区域。
QuickSight 在一张地理图上最多只能显示 5000 个位置点
CREATE OR REPLACE VIEW chicago_crimes_usecase8 AS
SELECT
TRY(CAST("col20" AS double)) "latitude"
, TRY(CAST("col21" AS double)) "logitude"
FROM
chicago_crimes_batch_bucket
WHERE (("col20" <> 'null') AND ("col21" <> 'null'))
LIMIT 5000
位置数据
您可以创建更多类似的查询并分析您的数据。将它们存储在视图中，接下来我们将在 QuickSight 中导入它们。
是时候使用 QuickSight 进行一些数据可视化了
**第一步:**打开亚马逊 QuickSight 控制台如【1】所述。
**第二步:**第二步:设置亚马逊 QuickSight 账号设置到访问雅典娜和你的 S3 桶。您可以查看[1]了解更多信息。
第三步:选择管理数据。
第四步:选择新数据集然后选择雅典娜。
步骤 5: 输入您的数据源名称并选择您的视图。
第七步:这里你可以选择香料(缓存)。
**第 8 步:**你可以添加一个新的可视化，字段和指标。
这里有一些我用 Athena 的视图创建的样本图表。
快速浏览图表
您还可以创建报表可视化，就像这里的这个。它将为您提供雅典娜风格的查询输出外观。
Quicksight 报告可视化
QuickSight 仪表板中的计划数据刷新
您可以使用时间表自动刷新 SPICE 数据集。标准版或企业版可以选择每日、每周或每月。
- 每日:每天重复
- 每周:每周的同一天重复
- 每月:每月的同一天重复。要在每月的 29 日、30 日或 31 日刷新数据，从列表中选择每月的最后一天。
仅限企业版，可以选择小时。此设置从您选择的时间开始，每小时刷新您的数据集。
但是，如果您想要维护数据集刷新的自定义计划，可以使用 AWS SDK Boto3 来实现。在 lambda 函数中运行下面的代码，并调度您的 lambda。
从上面的代码中得到的关键信息:
- 过滤掉带有前缀“chicago_crimes”的数据集
- 在第一个循环中为每个数据集启动数据集刷新过程
- 检查第二个循环中每个数据集的状态
就是这样！
很棒吧？
在这个逐步演练中，我们使用 AWS Glue、AWS Athena 和 AWS QuickSight 开发了一个无服务器数据湖。我们执行了从摄取和治疗到可视化的每个步骤。
对于即将到来的故事，你应该关注我的简介。
当你点击并按住拍手按钮时，你想看到一些魔法吗？
- 每当我发表一篇文章，就会收到一封 [电子邮件](http://Get an email whenever I publish an article) ，如果你喜欢这个故事，可以考虑成为 会员 。
- 在 insta gram上与 45，000+ 其他关注者一起关注我，了解技术更新、谷歌的工作文化以及更多信息。
- 48，000+ 人们在 Linkedin 上关注职业建议、技术建议和日常激励。
参考资料:
深度学习推理的人工智能加速器完全指南——GPU、AWS 推理和亚马逊弹性推理
了解 CPU、GPU、AWS 推理和 Amazon 弹性推理，以及如何为推理部署选择正确的 AI 加速器
如何选择—推理用 GPU、AWS 推理和亚马逊弹性推理(作者图解)
让我们从回答“什么是 AI 加速器”这个问题开始。
人工智能加速器是一种专用处理器，旨在加速机器学习计算。机器学习，特别是它的子集，深度学习主要由大量的线性代数计算组成，(即矩阵-矩阵，矩阵-向量运算)，这些运算可以很容易地并行化。人工智能加速器是一种专门的硬件，旨在加速这些基本的机器学习计算，提高性能，减少延迟，并降低部署基于机器学习的应用程序的成本。
机器学习(ML)推理需要 AI 加速器吗？
假设你有一个 ML 模型作为你软件应用的一部分。预测步骤(或推断)通常是应用程序中最耗时的部分，会直接影响用户体验。一个需要数百毫秒来生成文本翻译或对图像应用过滤器或生成产品推荐的模型，可以让用户远离你的“迟缓”、“缓慢”、“令人沮丧”的应用。
通过加速推理，您可以减少应用程序的整体延迟，并提供可以用“流畅”、“爽快”和“令人愉快”来描述的应用程序体验。你可以通过将 ML 模型预测计算卸载到 AI 加速器来加速推断。
随着巨大的市场需求而来的是大量的替代产品，因此自然有多种方式来加速您在云中的 ML 模型。
在这篇博文中，我将探索三种流行的选择:
(作者插图)
- GPU:特别是高性能的英伟达 T4 和英伟达 V100 GPUs
- AWS 推理:AWS 定制设计的机器学习推理芯片
- Amazon Elastic Inference(EI):一个加速器，通过为不需要专用 GPU 的模型提供可变大小的 GPU 加速来节省成本
为您的工作负载选择正确的硬件加速类型可能是一个很难做出的选择。在这篇文章的其余部分，我将带您了解各种考虑因素，如目标吞吐量、延迟、成本预算、模型类型和大小、框架选择以及其他因素，以帮助您做出决策。我还将展示大量代码示例，并讨论开发人员友好性和选项的易用性。
免责声明:本文中的观点和建议是我自己的，不代表我现在或过去的雇主的观点。
一点硬件加速器的历史
(作者插图)
在计算的早期(70 年代和 80 年代)，为了加快计算机上的数学计算，你将 CPU(中央处理器)与 FPU(浮点单元)配对，也就是数学协处理器。想法很简单——允许 CPU 将复杂的浮点数学运算卸载到专门设计的芯片上，这样 CPU 就可以专注于执行应用程序的其余部分，运行操作系统等。由于系统有不同类型的处理器(CPU 和数学协处理器)，这种设置有时被称为异构计算。
快进到 90 年代，CPU 变得更快、更好、更高效，并开始配备集成浮点硬件。更简单的系统占了上风，而协处理器和异构计算对于普通用户来说已经过时了。
大约在同一时间，特定类型的工作负载开始变得更加复杂。设计师需要更好的图形，工程师和科学家需要更快的计算机进行数据处理、建模和模拟。这意味着对高性能处理器有一些需求(和市场),这种处理器可以比 CPU 更快地加速“特殊程序”,从而释放 CPU 来做其他事情。计算机图形是工作负载被卸载到特殊处理器的早期例子。你可能知道这种特殊的处理器的通用名，古老的 GPU。
2010 年代初，又出现了另一类工作负载——深度学习，或具有深度神经网络的机器学习——需要硬件加速才能实现，就像计算机图形一样。GPU 已经出现在市场上，经过多年的发展，已经变得高度可编程，不像早期的 GPU 是固定功能的处理器。自然地，ML 从业者开始使用 GPU 来加速深度学习训练和推理。
CPU 可以将复杂的机器学习操作卸载到人工智能加速器上(作者的插图)
如今的深度学习推理加速格局有趣多了。CPU 获得了对高级向量扩展(AVX-512)的支持，以加速深度学习中常见的矩阵数学计算。GPU 获得了新的功能，例如支持简化精度算法(FP16 和 INT8)，进一步加快了推理速度。
除了 CPU 和 GPU，今天你还可以使用专门的硬件，定制设计的芯片只是为了深度学习推理而构建的。如果处理器支持您的工作负载，这些专用处理器，也称为专用集成电路或 ASICs，与通用处理器相比，性能更高，成本更低。这种专用处理器的一个很好的例子是 AWS Inferentia，这是 AWS 为加速深度学习推理而定制设计的 ASIC。
一开始，为您的应用选择正确的硬件加速可能并不明显。在下一节中，我们将讨论每种方法的优势和考虑事项，如吞吐量、延迟、成本和其他会影响您选择的因素。
人工智能加速器和如何选择正确的选项
很难回答“GPU 比 CPU 好吗？”或者“CPU 比 GPU 便宜吗”或者“ASIC 总是比 GPU 快吗”。实际上，没有一种硬件解决方案能适用于所有使用情形，答案取决于您的工作负载和几个考虑因素:
- **模型类型和可编程性:**模型大小、定制操作符、支持的框架
- **目标吞吐量、延迟和成本:**在预算范围内提供良好的客户体验
- **编译器和运行时工具链的易用性:**应该有快速的学习曲线，不需要硬件知识
虽然模型支持和目标延迟等考虑是客观的，但易用性可能是非常主观的。因此，我反对不考虑上述所有具体应用的一般性建议。这种高水平的建议往往是有偏见的。
让我们回顾一下这些关键考虑事项。
1。型号类型和可编程性
(作者插图)
对人工智能加速器进行分类的一种方式是基于它们的可编程程度。在“完全可编程”的一端，有 CPU。作为通用处理器，你可以用定制的层、架构和操作为你的机器学习模型编写定制的代码。
另一个极端是 ASICs，如 AWS Inferentia，它通过 AWS Neuron SDK 编译器公开了一组固定的受支持操作。介于两者之间，但更接近 ASIC 的是 GPU，它比 ASIC 更具可编程性，但远不如 CPU 通用。在通用和提供性能之间总会有一些折衷。
定制代码可能会退回到 CPU 执行，从而降低整体吞吐量(作者的插图)
如果您正在通过自定义神经网络操作来拓展深度学习研究的边界，您可能需要为自定义操作编写自定义代码。你通常用像 Python 这样的高级语言来做这件事。
大多数人工智能加速器不能自动加速用高级语言编写的定制代码，因此这段代码将退回给 CPU 执行，降低了整体推理性能。
NVIDIA GPUs 的优势在于，如果你想提高自定义代码的性能，你可以使用 CUDA 编程语言重新实现它们，并在 GPU 上运行它们。但是如果你的 ASIC 的编译器不支持你需要的操作，那么 CPU 回退可能会导致较低的性能。
2。目标吞吐量、延迟和成本
一般来说，与通用处理器相比，专用处理器(如 AWS Inferentia)往往提供更低的性价比，并改善延迟。但在人工智能加速的世界里，所有的解决方案都可能是有竞争力的，这取决于工作负载的类型。
GPU 是吞吐量处理器，可以在指定的延迟时间内提供高吞吐量。如果延迟不重要(批处理、离线推理)，那么 GPU 利用率可以保持在较高水平，使其成为云中最具成本效益的选项。CPU 不是并行吞吐量设备，但是对于较小模型的实时推理，CPU 可能是最具成本效益的，只要推理延迟低于您的目标延迟预算。如果您的模型完全受 AWS Neuron SDK compiler 支持，AWS Inferentia 的性能和较低的成本可能使其成为相对于 CPU 和 GPU 最具成本效益和性能的选择。
这确实是一个微妙的话题，并且非常依赖于工作负载。在接下来的章节中，我们将进一步了解每个加速器的性能、延迟和成本。如果某个特定的选择不适合你，没关系，在云中切换选项很容易，直到你找到适合你的选项。
3。编译器和运行时工具链以及易用性
为了在人工智能加速器上加速您的模型，您通常必须经历一个编译步骤，该步骤分析计算图形并针对目标硬件进行优化，以获得最佳性能。当部署在 CPU 上时，深度学习框架拥有您需要的一切，因此通常不需要额外的 SDK 和编译器。
如果你正在部署一个 GPU，你可以依靠深度学习框架来加速你的模型进行推理，但你将把性能留在桌面上。为了充分利用你的 GPU，你必须使用一个专用的推理编译器，比如 NVIDIA TensorRT。
(作者截图)
在某些情况下，与使用深度学习框架相比，您可以获得 10 倍以上的额外性能(见图)。我们将在后面的代码示例部分看到如何重现这些结果。
NVIDIA TensorRT 是两件事——推理编译器和运行时引擎。通过使用 TensorRT 编译您的模型，您可以获得更好的性能和更低的延迟，因为它执行了许多优化，如图形优化和量化。同样，当以 AWS 推理为目标时，AWS Neuron SDK 编译器将执行类似的优化，以充分利用您的 AWS 推理处理器。
让我们更深入地挖掘一下这些人工智能加速器选项
加速器选项 1:用于推理的 GPU 加速
(作者插画)
您在 GPU 上训练您的模型，因此很自然会考虑将 GPU 用于推理部署。毕竟，GPU 大大加快了深度学习训练，而推理只是你已经在 GPU 上加速的神经网络的向前传递。这是真的，GPU 确实是推理的优秀硬件加速器。
首先，我们来谈谈 GPU 到底是什么。
GPU 首先是吞吐量处理器，正如 NVIDIA 的这篇博客文章所解释的。它们旨在利用算法中固有的并行性，并通过并行计算来加速算法。GPU 最初是作为计算机图形的专用处理器出现的，但今天的 GPU 已经发展成为可编程处理器，也称为通用 GPU (GPGPU)。它们仍然是专门的并行处理器，但也是高度可编程的，用于可以通过并行化来加速的狭窄范围的应用。
事实证明，早在深度学习之前，高性能计算(HPC)社区就已经在使用 GPU 来加速线性代数计算了。深度神经网络计算主要由类似的线性代数计算组成，因此用于深度学习的 GPU 是寻找问题的解决方案。毫不奇怪，Alex Krizhevsky 的 AlexNet 深度神经网络赢得了 ImageNet 2012 竞赛，并(重新)向世界介绍了深度学习，它是在 NVIDIA 现成的可编程消费 GPU 上训练的。
自那以后，GPU 的速度变得更快了我会让你去 NVIDIA 的网站了解他们最新的流行机型的训练和推理基准。虽然这些基准很好地表明了 GPU 的能力，但您的决定可能取决于下面讨论的其他因素。
1。GPU 推理吞吐量、延迟和成本
由于 GPU 是吞吐量设备，如果您的目标是最大限度地提高吞吐量，它们可以根据所需的延迟提供同类最佳的吞吐量，具体取决于部署的 GPU 类型和型号。GPU 大放异彩的一个用例是离线或批量推理。GPU 还将为小批量预测提供一些最低的延迟，但如果您无法始终将 GPU 利用率保持在最高水平，例如由于零星的推理请求(波动的客户需求)，您的成本/推理请求会上升(因为您为相同的 GPU 实例成本提供的请求较少)。对于这些情况，您最好使用 Amazon Elastic Inference，它可以让您以较低的成本获得足够的 GPU 加速。
在示例部分，我们将看到不同精度(FP32、FP16、INT8)的 GPU 性能比较。
2。GPU 推理支持的模型大小和选项
在 AWS 上，您可以使用不同的 NVIDIA GPUs、vCPUs 数量、系统内存和网络带宽启动 18 个不同的 Amazon EC2 GPU 实例。两种最受欢迎的深度学习推理 GPU 是 G4 EC2 instance type 提供的英伟达 T4 GPU 和 P3 EC2 instance type 提供的英伟达 V100 GPUs。
博文:为 AWS 上的深度学习选择合适的 GPU(作者截图)
关于 AWS 所有 GPU 实例类型的完整总结，请阅读我之前的博客文章:为 AWS 上的深度学习选择正确的 GPU
G4 实例类型应该是深度学习推理部署的首选 GPU 实例。
基于英伟达图灵架构，英伟达 T4 GPU 具有 FP64、FP32、FP16、张量内核(混合精度)和 INT8 精度类型。它们还拥有 16 GB 的 GPU 内存，对于大多数型号来说已经足够了，并结合了降低的精度支持。
如果您需要更大的吞吐量或每个 GPU 需要更多的内存，那么 P3 实例类型提供了更强大的 NVIDIA V100 GPU，通过p3dn.24xlarge实例大小，您可以访问 NVIDIA V100，它具有高达 32 GB 的 GPU 内存，可用于大型模型或大型图像或其他数据集。
3.GPU 推理模型类型、可编程性和易用性
与固定功能处理器的 AWS Inferentia 等 ASICs 不同，开发人员可以使用 NVIDIA 的 CUDA 编程模型来编写自定义层，这些层可以在 NVIDIA GPU 上加速。这正是 Alex Krizhevsky 在 2012 年对 AlexNet 所做的。他手工编写定制的 CUDA 内核，在 GPU 上训练他的神经网络。他称他的框架为 cuda-convnet，你可以说 cuda-convnet 是第一个深度学习框架。如果你正在推动深度学习的边界，并且不想将性能留在桌面上，GPU 是你的最佳选择。
可编程性与性能是 GPU 最大的优势之一
使用 NVIDIA 的 CUDA 编程模型来编写可以在 NVIDIA GPU 上加速的自定义层。(作者插图)
当然，你不需要写低级别的 GPU 代码来做深度学习。NVIDIA 已经通过 cuDNN 和 cuBLAS 等库提供了神经网络原语，TensorFlow、PyTorch 和 MXNet 等深度学习框架在幕后使用这些库，因此您只需使用这些框架就可以免费获得 GPU 加速。这就是 GPU 在易用性和可编程性方面获得高分的原因。
4.NVIDIA TensorRT 的 GPU 性能
如果你真的想让你的 GPU 发挥最佳性能，NVIDIA 提供了 TensorRT，一个用于推理部署的模型编译器。对经过训练的模型进行额外的优化，完整的列表可在 NVIDIA 的 TensorRT 网站上找到。需要注意的关键优化是:
- 量化:将模型精度从 FP32(单精度)降低到 FP16(半精度)或 INT8 (8 位整数精度)，从而减少计算量，加快推理速度
- 图形融合:在 GPU 上将多个层/操作融合成一个对 CUDA 内核的函数调用。这减少了每个层/操作的多个函数调用的开销
使用 NVIDIA TensorRT 部署 FP16 非常简单。TensorRT 编译器将在编译步骤中自动量化您的模型。
要使用 INT8 precision 进行部署，需要量化模型的权重和激活，以便可以使用适当的范围将浮点值转换为整数。你有两个选择。
- 选项 1 :执行量化感知训练。在量化感知训练中，从量化权重和张量到 INT8 的误差在训练期间被建模，允许模型适应和减轻该误差。这需要在培训期间进行额外的设置。
- **选项二:**进行训练后量化。在量化后培训中，不需要任何部署前准备。您将提供全精度(FP32)的训练模型，还需要提供训练数据集中的数据集样本，TensorRT 编译器可以使用该样本来运行校准步骤以生成量化范围。在下面的示例 2 中，我们将看看选项 2 的实现。
GPU 加速推理示例
使用以下 AWS 深度学习 AMI 在亚马逊 EC2 g4dn.xlarge上测试了以下示例:深度学习 AMI (Ubuntu 18.04)版本 35.0。为了运行 TensorRT，我使用了以下 NVIDIA TensorFlow Docker 映像:nvcr.io/nvidia/tensorflow:20.08-tf2-py3
数据集:50000 张测试图片的 ImageNet 验证数据集，转换为 TFRecord
模型:resnet 50 的 TensorFlow 实现
您可以在 Jupyter 笔记本上找到以下示例的完整实现:
示例 1:部署 ResNet50 TensorFlow 模型(1)框架的原生 GPU 支持和(2)NVIDIA tensort
TensorFlow 的原生 GPU 加速支持开箱即用，无需额外设置。您不会获得 NVIDIA TensorRT 所能提供的额外性能，但当一切正常工作时，生活会变得多么轻松，这一点毋庸置疑。
使用框架的本地 GPU 支持运行推理需要 3 行代码:
model = tf.keras.models.load_model(saved_model_dir)for i, (validation_ds, batch_labels, _) in enumerate(dataset):
pred_prob_keras = model(validation_ds)
但是你真的把性能留在桌面上了(有时是性能的 10 倍)。为了提高 GPU 的性能和利用率，您必须使用推理编译器和运行时，如 NVIDIA TensorRT。
下面的代码展示了如何用 TensorRT 编译您的模型。你可以在 GitHub 上找到的完整实现
TensorRT 编译有以下步骤:
- 向 TensorRT 的
TrtGraphConverterV2(用于 TensorFlow2)提供您未编译的 TensorFlow 保存模型 - 指定 TensorRT 编译参数。最重要的参数是精度(FP32、FP16、INT8)。如果您正在使用 INT8 支持进行编译，TensorRT 希望您从训练集中提供一个代表性样本来校准比例因子。当您调用
converter.convert()时，您将通过为参数calibration_input_fn提供一个 python 生成器来实现这一点。您不需要为 FP32 和 FP16 优化提供额外的数据。 - TensorRT 编译您的模型并将其保存为 TensorFlow 保存的模型，该模型包括特殊的 TensorRT 运算符，可加速 GPU 上的推理并更有效地运行它们。
以下是 TensorFlow ResNet50 推理的准确性和性能对比:
- TensorFlow 原生 GPU 加速
- tensor flow+tensort FP32 精度
- tensor flow+tensort FP16 精度
- tensor flow+tensort int 8 精度
(作者截图)
我测量的不仅仅是性能，还有精度，因为降低精度意味着信息的损失。在 ImageNet 测试数据集上，我们看到所有精度的精度损失可以忽略不计，而吞吐量略有增加。您的里程可能因型号而异。
示例 2:使用 Amazon SageMaker 托管 ResNet50 TensorFlow 模型
在示例 1 中，我们离线测试了性能，但是在大多数情况下，您将在云中托管您的模型，作为客户端应用程序可以向其提交推理请求的端点。最简单的方法之一是使用 Amazon SageMaker 托管功能。
这个例子是在亚马逊 SageMaker Studio 笔记本上测试的。使用以下亚马逊 SageMaker Studio conda 环境运行该笔记本:TensorFlow 2 CPU 优化。完整的实现可从以下网址获得:
使用 SageMaker 托管模型端点包括以下简单步骤:
- 使用您的 TensorFlow 保存的模型创建 tar.gz 存档文件，并将其上传到亚马逊 S3
- 使用 Amazon SageMaker SDK API 创建一个 TensorFlowModel 对象
- 使用英伟达 T4 GPU 将 TensorFlowModel 对象部署到 G4 EC2 实例
使用 TensorFlow 保存的模型创建 model.tar.gz:
$ tar cvfz model.tar.gz -C resnet50_saved_model .
将模型上传到 S3 并部署:
您可以通过调用端点来测试模型，如下所示:
输出:
加速器选项 2: AWS 推理
(作者插画)
AWS 推理是亚马逊设计的定制芯片，用于经济高效、高吞吐量、低延迟的推理。
詹姆斯·汉密尔顿(AWS 副总裁兼杰出工程师)在他的博客文章 AWS 推理机器学习处理器中深入探讨了 ASICs、通用处理器、AWS 推理以及围绕它们的经济学，如果你对人工智能硬件感兴趣，我鼓励你阅读这篇文章。
针对特定工作负载使用特定处理器的想法并不新鲜。降噪耳机中的芯片和 DVD 播放器中的视频解码器是专用芯片的例子，有时也称为专用集成电路(ASIC)。
ASICs 有一项工作(或有限的责任)，并被优化来做好它。与通用处理器(CPU)或可编程加速器(GPU)不同，大部分芯片并不专用于运行任意代码。
AWS 推理是专门为在云中以最低的成本提供高推理性能而构建的。AWS 推理芯片可以通过 Amazon EC2 Inf1 实例访问，这些实例有不同的大小，每个实例有 1 个 AWS 推理芯片，每个实例最多有 16 个 AWS 推理芯片。每个 AWS 推理芯片有 4 个神经元，支持 FP16、BF16 和 INT8 数据类型。NeuronCore 是一个高性能的脉动阵列矩阵乘法引擎，每个都有一个两级内存层次，一个非常大的片上缓存。
在大多数情况下，如果您的模型:
- 曾在 MXNet、TensorFlow、PyTorch 接受培训或已转换为 ONNX
- 拥有由 AWS Neuron SDK 支持的操作符
如果您有 AWS Neuron SDK 不支持的操作符，您仍然可以在 Inf1 实例上成功地部署它，但是这些操作将在主机 CPU 上运行，并且不会在 AWS Inferentia 上加速。正如我前面所说的，每个用例都是不同的，所以用 AWS Neuron SDK 编译您的模型，并测量性能，以确保它满足您的性能、延迟和吞吐量需求。
1.AWS 推理吞吐量、延迟和成本
AWS 比较了流行模型的 AWS 推理与 GPU 实例的性能，并报告了流行模型的较低成本: YOLOv4 模型、 OpenPose ，并提供了 TensorFlow、MXNet 和 PyTorch 的 BERT 和 SSD 的示例。对于实时应用程序，AWS Inf1 实例是 AWS 上可用的所有加速选项中最便宜的，与 GPU 和 CPU 相比，AWS Inferentia 可以在目标延迟下以更低的成本提供更高的吞吐量。最终，您的选择可能取决于下面讨论的其他因素。
2。AWS 推理支持的模型、运算符和精度
AWS 推理芯片支持通过 AWS Neuron SDK 公开的一组固定的神经网络操作符。当您使用 AWS Neuron SDK 编译一个面向 AWS 推理的模型时，编译器将检查您的模型中是否有您的框架支持的操作符。如果不支持某个操作符，或者如果编译器确定某个特定操作符在 CPU 上执行效率更高，它将对图形进行分区，以包括 CPU 分区和 AWS 推理分区。亚马逊弹性推理也是如此，我们将在下一节讨论。如果您将 TensorFlow 与 AWS 推理一起使用，这里列出了所有在 AWS 推理上加速的 TensorFlow 操作。
定制操作将是 CPU 分区的一部分，并将在主机实例的 CPU 上运行(作者的插图)
如果您在 FP32(单精度)中训练您的模型，AWS Neuron SDK 编译器会自动将您的 FP32 模型转换为 BF16 以提高推理性能。如果您更喜欢在 FP16 中提供模型，无论是通过在 FP16 中训练还是通过执行训练后量化，AWS Neuron SDK 将直接使用您的 FP16 权重。虽然 INT8 受 AWS 推理芯片支持，但 AWS Neuron SDK 编译器目前不提供支持 INT8 的部署方式。
3。AWS 推理灵活性和对如何使用推理神经元的控制
在大多数情况下，AWS Neuron SDK 使 AWS 推理真正易于使用。使用 AWS 推理和 GPU 的用户体验的一个关键区别是，AWS 推理让您可以更好地控制每个内核的使用方式。
AWS Neuron SDK 支持两种利用所有 NeuronCores 提高性能的方式: (1)批处理和 (2)流水线。因为 AWS Neuron SDK 编译器是一个超前编译器，所以您必须在编译阶段显式启用这些选项。
让我们看看这些是什么以及它们是如何工作的。
a .使用批处理来最大化较大批量的生产量
当您使用 AWS Neuron SDK 编译器编译一个大于 1 的模型时，批处理将被启用。在推理过程中，您的模型权重存储在外部存储器中，当开始向前传递时，由神经元运行时确定的层权重子集被复制到片上缓存中。使用缓存中该图层的权重，对整个批次计算向前传递。
(作者插图)
之后，将下一组图层权重加载到缓存中，并对整个批次计算向前传递。这个过程继续进行，直到所有的权重都用于推理计算。当层仍在缓存中时，通过对大批量进行推理，批处理允许更好地分摊从外部存储器读取权重的成本。
所有这些都发生在后台，作为用户，您只需在编译期间使用示例输入设置所需的批处理大小。
即使批处理大小是在编译阶段设置的，在启用动态批处理的情况下，模型也可以接受可变大小的批处理。在内部，neuron runtime 将把用户批量分解为编译后的批量，并运行推理。
b .使用流水线技术，通过跨多个神经元缓存模型来改善延迟
在批处理期间，模型权重从外部存储器逐层加载到片内缓存。借助流水线技术，您可以将整个模型权重加载到多核的片上缓存中。这可以减少延迟，因为神经元运行时不必从外部存储器加载权重。同样，所有这些都发生在幕后，作为用户，您只需在编译阶段使用—-num-neuroncores设置所需的内核数量。
(作者插图)
批处理和流水线可以一起使用。但是，您必须尝试不同的流水线内核和编译批处理大小的组合，以确定最适合您的模型的组合。
在编译步骤中，批次大小和神经元核心数量的所有组合(对于流水线)可能都不适用。您必须通过扫描不同的值并监控编译器错误来确定批处理大小和神经元核心数量的工作组合。
在你的 Inf1 实例上使用所有神经核心
根据您编译模型的方式，您可以:
- 编译您的模型，以便在具有特定批处理大小的单个 NeuronCore 上运行
- 通过管道将模型编译到具有特定批处理大小的多个神经元
成本最低的 Amazon EC2 Inf1 实例类型，inf1.xlarge有 1 个 AWS 推理芯片和 4 个神经元。如果您将模型编译为在单个 NeuronCore 上运行，tensorflow-neuron将自动在所有 4 个 neuron core 上并行执行数据。这相当于将您的模型复制 4 次，并将其加载到每个 NeuronCore 中，然后运行 4 个 Python 线程将数据输入到每个核心中。自动数据并行执行在 1 AWS 推理芯片之外不起作用。例如，如果您想将您的模型复制到一个inf1.6xlarge上的所有 16 个神经元，您必须生成多个线程来向所有 AWS 推理芯片提供数据。在 python 中你可以使用concurrent . futures . threadpoolexecutor。
(作者截图)
当你为多个神经核心编译一个模型时，运行时将为每个神经核心分配不同的子图(作者截图)
当你用流水线编译一个模型时，运行时会给每个 NeuronCore 分配不同的子图(作者截图)
4。在 Inf1 实例上部署多个模型
AWS Neuron SDK 允许您将神经元分组到逻辑组中。每组可以有一个或多个神经元，可以运行不同的模型。例如，如果您在 inf1.6xlarge EC2 Inf1 实例上进行部署，您可以访问 4 个推理芯片，每个芯片有 4 个神经内核，即总共有 16 个神经内核。你可以把 16 个神经元分成 3 组。第 1 组有 8 个神经元核心，将运行一个使用流水线来使用所有 8 个核心的模型。第 2 组使用 4 个神经元核心，运行用 1 个神经元核心编译的模型的 4 个副本。第 3 组使用 4 个神经元核，并运行用 2 个神经元核通过流水线编译的模型的 2 个副本。您可以使用 neuron core _ GROUP _ size 环境变量来指定此配置，并将其设置为 NEURONCORE _ GROUP _ SIZES =，1，1，1，1，2，2
之后，您只需在单个 python 进程中按指定顺序加载模型，即首先加载编译为使用 8 个内核的模型，然后加载编译为使用 1 个内核的模型四次，然后使用加载编译为使用 2 个内核的模型两次。适当的核心将被分配给模型。
Amazon EC2 Inf1 实例上的 AWS 推理加速推理示例
AWS Neuron SDK 预装在 AWS 深度学习 AMI 上，你也可以安装 SDK 和神经元加速的框架和库 TensorFlow、TensorFlow Serving、TensorBoard(带神经元支持)、MXNet 和 PyTorch。
下面的例子是在亚马逊 EC2 Inf1.xlarge和深度学习 AMI(Ubuntu 18.04)35.0 版本上测试的。
您可以在 Jupyter 笔记本上找到以下示例的完整实现:
示例 1:在 AWS 推理系统上部署带有 AWS Neuron SDK 的 ResNet50 TensorFlow 模型
在这个例子中，我比较了 3 个不同的选项
- 无批处理，无流水线:编译 ResNet50 模型，批量= 1，核数= 1
- 有批处理，无流水线:编译 ResNet50 模型，批处理大小= 5，内核数= 1
- 无批处理，带流水线:编译 ResNet50 模型，批量= 1，核数= 4
你可以在这个 Jupyter 笔记本中找到完整的实现。我就在这里回顾一下结果。
下面的比较表明，在 Inf1.xlarge 实例上，使用选项 2(批处理大小= 1，无流水线)可以获得最佳吞吐量。您可以在大型 Inf1 实例上用其他组合重复这个实验。
(作者截图)
加速器选项 3:亚马逊弹性推理(EI)推理加速
亚马逊弹性推理(作者插图)
亚马逊弹性推理(EI) 允许您向纯 CPU 实例添加经济高效的可变大小 GPU 加速，而无需配置专用的 GPU 实例。要使用 Amazon EI，您只需提供一个纯 CPU 实例，如 Amazon EC2 C5 实例类型，并在发布时从 6 个不同的 EI 加速器选项中进行选择。
EI 加速器不是构成您的 CPU 实例的硬件的一部分，相反，EI 加速器通过使用 AWS PrivateLink 端点服务的网络连接，该服务将流量从您的实例路由到使用您的实例配置的弹性推理加速器。当您使用支持 EI 的服务框架(如 TensorFlow serving)时，所有这些都在幕后无缝发生。
弹性推理允许您访问可变大小的 GPU 加速(作者插图)
Amazon EI 使用 GPU 来提供 GPU 加速，但与专用 GPU 实例不同，您可以选择添加 6 种不同加速器大小的 GPU 加速，您可以通过每秒万亿次浮点运算(TFLOPS)或 GPU 内存来选择。
为什么选择 Amazon EI 而不是专用 GPU 实例？
正如我前面所讨论的，GPU 主要是吞吐量设备，当处理实时应用程序常见的较小批量时，当您部署不需要 GPU 的全部处理能力或全部内存的模型时，GPU 往往得不到充分利用。此外，如果您没有足够的需求或多个模型来服务和共享 GPU，那么单个 GPU 可能不具成本效益，因为成本/推理会上升。
您可以从 6 种不同的 EI 加速器中进行选择，这些加速器提供 1–4 TFLOPS 和 1–8 GB 的 GPU 内存。假设您有一个计算要求较低的模型，内存占用较小，您可以将最小的 EI 加速器(如eia1.medium)连接到一个 CPU 实例，该加速器提供 1 TFLOPS 的 FP32 性能和 1 GB 的 GPU 内存。如果您有一个要求更高的模型，您可以将一个具有 4 TFLOPS 性能和 8 GB GPU 内存的eia2.xlarge EI 加速器附加到一个 CPU 实例上。
CPU 实例+ EI 加速器的成本仍然比专用 GPU 实例便宜，并且可以降低推理成本。您不必担心 GPU 利用率的最大化，因为您添加的容量刚好满足需求，不会过度配置。
什么时候选择亚马逊 EI 而不是 GPU，选择什么样的 EI 加速器尺寸？
让我们考虑下面的假设场景。比方说，如果您的总延迟(应用+网络+模型预测)低于 200 毫秒，您的应用可以提供良好的客户体验。比方说，使用 G4 实例类型，您可以将总延迟降至 40 毫秒，这完全在您的目标延迟范围内。您还尝试了使用纯 CPU C5 实例类型进行部署，您只能获得 400 毫秒的总延迟，这不符合您的 SLA 要求，导致客户体验不佳。
通过弹性推理，您可以将足够的 GPU 加速通过网络连接到一个 CPU 实例。在探索了不同的 EI 加速器尺寸(比如eia2.medium、eia2.large、eia2.xlarge)之后，您可以使用eia2.large EI 加速器将总延迟降至 180 毫秒，低于预期的 200 毫秒。由于 EI 比配置专用 GPU 实例便宜得多，因此您可以节省总部署成本。
1。亚马逊弹性推理性能
由于 GPU 加速是通过网络添加的，因此与专用 GPU 实例相比，EI 会增加一些延迟，但仍比纯 CPU 实例更快，并且比专用 GPU 实例更具成本效益。与 EI 相比，专用 GPU 实例仍将提供更好的推理性能，但如果额外的性能没有改善您的客户体验，使用 EI 您将保持在目标延迟 SLA 之下，提供良好的客户体验，并节省总体部署成本。AWS 有许多博客帖子，谈论与使用流行的深度学习框架的 CPU 和 GPU 相比的性能和成本节省。
2。支持的型号类型、可编程性和易用性
亚马逊 EI 支持在 TensorFlow、Apache MXNet、Pytorch 和 ONNX 模型上训练的模型。在您启动一个连接了 Amazon EI 的 Amazon EC2 实例后，要访问加速器，您需要一个支持 EI 的框架，比如 TensorFlow、PyTorch 或 Apache MXNet。
支持 EI 的框架预装在 AWS 深度学习 AMI 上，但如果你更喜欢手动安装，Python wheel 文件也已可用。
大多数流行的模型，如 Inception，ResNet，SSD，RCNN，GNMT，都经过测试，在与 Amazon EI 一起部署时，可以节省成本。如果您正在部署带有自定义操作符的自定义模型，则支持 EI 的框架会对图形进行分区，以便在主机 CPU 上运行不支持的操作符，并在通过网络连接的 EI 加速器上运行所有支持的操作。这使得使用 EI 非常简单。
示例:使用 Amazon EI 部署 ResNet50 TensorFlow 模型
这个例子是在亚马逊 EC2 c5.2xlarge 下面的 AWS 深度学习 AMI 上测试的:深度学习 AMI (Ubuntu 18.04)版本 35.0
您可以在此处找到 Jupyter 笔记本的完整实现:
Amazon EI enabled TensorFlow 提供的 API 允许您使用 EI 加速器加速模型，其行为就像 TensorFlow API 一样。作为一名开发人员，您应该尽可能少地修改代码。
要加载模型，只需运行以下代码:
from ei_for_tf.python.predictor.ei_predictor import EIPredictoreia_model = EIPredictor(saved_model_dir,accelerator_id=0)
如果有多个 EI 加速器连接到您的实例，您可以使用 accelerator_id 参数来指定它们。只需用 eia_model 替换 TensorFlow 模型对象，脚本的其余部分保持不变，您的模型现在在 Amazon EI 上加速了。
下图比较了在同一个 CPU 实例上的纯 CPU 推理和 EI 加速推理。在本例中，您可以看到使用 EI 加速器后速度提高了 6 倍以上。
(作者截图)
摘要
如果我想让你从这篇博文中学到什么，那就是:部署需求是独一无二的，没有放之四海而皆准的方法。回顾您的部署目标，将它们与本文中的讨论进行比较，并测试所有选项。云让你在提交之前尝试变得简单。
在选择时，请牢记以下注意事项:
- 模型类型和可编程性(模型大小、自定义操作符、支持的框架)
- 目标吞吐量、延迟和成本(在预算范围内提供良好的客户体验)
- 编译器和运行时工具链的易用性(快速学习曲线，不需要硬件知识)
如果可编程性非常重要，并且您的性能目标较低，那么 CPU 可能正好适合您。
如果可编程性和性能很重要，那么您可以为在 GPU 上加速的定制操作开发定制 CUDA 内核。
如果您想要最低成本的选项，并且您的模型在 AWS 推理上受支持，那么您可以节省总体部署成本。
易用性是主观的，但没有什么能打败原生框架体验。但是，稍加努力，AWS Neuron SDK for AWS Inferentia 和 NVIDIA TensorRT for NVIDIA GPUs 都可以提供更高的性能，从而降低成本/推理。
感谢您的阅读。在本文中，我只能给你一瞥我们在本文中讨论的所有样本代码。如果您想重现结果，请访问以下 GitHub repo:
https://github . com/shashankprasanna/ai-accelerators-examples
如果你觉得这篇文章有趣，请看看我在媒体上的其他博文。
想让我写一个特定的机器学习主题吗？我很想收到你的来信！在 twitter ( @shshnkp )， LinkedIn 关注我或者在下面留言评论。
扫一扫
3318
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
