比较 Graql 和 SQL —第 1/2 部分
探索共同的概念和差异
自 20 世纪 70 年代以来，SQL 一直是处理数据库的事实语言。作为一种声明式语言，编写查询和构建强大的应用程序非常简单。然而，关系数据库在处理互连的复杂数据时会遇到困难。在 SQL 中处理这类数据时，尤其是在数据的建模和查询方面会出现挑战。
Graql 是在 Grakn 中使用的查询语言。就像 SQL 是关系数据库中的标准查询语言一样，Graql 是 Grakn 的查询语言。SQL 和 Graql 都是声明式查询语言，抽象出了低级操作。两者都是:
- 尝试可读性和可理解性的语言
- 试图在更高层次上提问的语言
- 系统计算出如何进行底层操作的语言
实际上，这意味着那些原本无法接触到这些语言的人群可以接触到这些语言。在本文中，当我们查看特定的通用概念时，我们将重点比较和探索这两种语言之间的差异。
SQL 和关系模型的起源
1970 年，一位牛津毕业的数学家名叫 Edgar Codd ，也就是所谓的“ted ”,发表了一篇论文,在论文中，他引入了两种语言——一种关系代数和一种关系微积分来表达极其复杂的查询。当它们问世时，被认为是一种奇怪的数学符号。为了将这些想法构建到数据库管理系统中，Ted 创建了一个名为 System R 的研究小组，该小组基于圣何塞的 IBM 研究机构。
那时，数据库主要基于导航、网络和层级模型，在我们能够编写描述我们的查询的导航计划之前，我们需要知道物理数据层。然而，Ted 看到了其中固有的复杂性，并希望使编写数据库查询变得更容易。
然而，由于 Ted 的想法是基于数学符号和数学象征的，它们很难理解，大多数人也不太容易理解，所以两位 System R 成员通过创建一种简单的查询语言来解决这个问题 based。由于这种新语言完全基于英语单词，这成为一个突破，使人们更容易理解 Ted 的简单思想。
到 20 世纪 70 年代末，关系数据库越来越受欢迎，世界开始接受 SQL 和关系模型比它的前辈优越。此后的故事众所周知——随着世界进入数字革命，关系数据库已经成为构建软件的标准。
SQL 和 Graql 的本质
在理解 Graql 时，看看创建 SQL 的基本思想是很有用的，因为它们在概念上是密切相关的。Graql 和 SQL 的本质可以总结如下:
- 一种可以直观阅读和理解的语言。当一种语言看起来简单、可维护并且与自然文本有一定程度的相似性时，我们说它满足这些标准。
- **一种能够提出更高层次问题的语言。**这里我们指的是一种允许用户在新的和更高的语义层次上描述操作的语言。
- 一种语言，在这种语言中，系统计算出如何进行低级操作。当用户描述更高层次的操作时，系统会处理这些操作，而无需用户去想它们。
从这个意义上说，SQL 和 Graql 都是抽象低级操作的语言。实际上，这意味着那些原本无法接触到这些语言的人群可以接触到这些语言。这意味着它们能够创造价值，而那些已经可以使用它们的人现在可以更快地做事。Python 也有类似的情况，例如，它是一种高级编程语言，使数百万程序员能够构建软件，而不必担心被抽象掉的低级操作。
建模和定义模式
首先，让我们看看 SQL 和 Graql 之间的数据建模有何不同。我们使用实体关系图 (ER 图)，因为它是最常用的建模工具。基本模型由实体类型和它们之间可能存在的关系组成。下面是一个 ER 图示例。我们称之为概念模型。
ER 图示例。正方形是实体，菱形是关系，圆形是属性。
SQL 建模
如果我们在关系数据库中实现这个模型，我们首先要经历一个规范化过程。我们从第一范式 (1NF)开始，通过寻找诸如函数依赖和传递依赖之类的东西，我们最终得到我们想要的第三范式 (3NF)。
从 1NF 归一化到 3NF。
在这个规范化过程之后，我们在 3NF 中得到我们的逻辑模型，并在关系数据库中实现它。我们已经从概念模型(ER 图)发展到逻辑模型(3NF)，甚至不需要深入到数据库的物理层。这正是关系模型带给我们的突破——抽象出物理层次。我们称之为数据的物理独立性。
SQL 给了我们数据的物理独立性。
Graql 建模
现在让我们来看看它与 Graql 有何不同。我们可以将任何 ER 图直接映射到我们如何在 Graql 中实现它，这意味着我们不需要经过规范化过程。下面我们可以看到早期 er 图的特定部分是如何建模的。我们避免了进行任何标准化的需要，因为 Graql 使我们能够创建一个带有实体、关系、属性和角色的 ER 图的直接映射，以便我们稍后在代码中实现它。这与 SQL 不同，在 SQL 中，我们需要在模型上强加一个表格结构作为逻辑层(如上所述)。
ER 图(左)到 Graql 模型(右)。
这意味着我们完全跳过了 SQL 中所需的规范化过程，我们继续在概念模型上工作。换句话说，Graql 抽象出了逻辑和物理模型。从这个意义上说，SQL 给了我们数据的物理独立性，而 Graql 给了我们数据的逻辑独立性。
通过在概念层面建模，Graql 为我们提供了逻辑模型的抽象。
在 SQL 和 Graql 中定义模式
现在我们来看一些真实的数据。任何学习过 SQL 的人可能都熟悉 Northwind 数据集。它包含虚构的专业食品进出口公司 Northwind Traders 的销售数据。
北风模式。
我们如何在 Graql 和 SQL 中定义上面显示的products表？下面我们看到 Graql 语法定义了product实体，以及相应的relation。这也显示了创建新表的SQL语句和相应的属性。
Graql
结构化查询语言
几个要点:
- 这里我们可以看到 SQL 表有三个属性，每个属性都有自己的数据类型，我们也可以在 Graql 中定义。其中一个属性是
primary key，我们在 Graql 中使用key关键字定义了它。 - 在 SQL 语句中，还有一个
foreign key，根据我们的模型，我们将其建模为 Graql 中的相关relation。我们通过使用角色product-assignment将product实体连接到assignment关系来做到这一点。 - 在 Graql 中，没有
null值的概念。如果一个概念没有属性，它就真的没有属性。这是因为在图上下文中，空属性被简单地从图中省略了。 - 最后，重要的一点是，在 Graql 模型中，属性是一等公民，不像在 SQL 中。
总结一下:
- 将 ER 图建模为 SQL 包含一个从 1NF 到 3NF 的规范化过程
- ER 图自然地映射到 Graql，不需要执行任何类型的规范化
在第 2 部分中( 链接此处 )，我们看看如何读/写数据，以及我们应该如何在 Graql 中利用超图和自动推理进行更高级别的建模。
比较现代可扩展超参数调整方法
随机搜索、使用超点的贝叶斯搜索、结合异步超带的贝叶斯搜索和基于群体的训练的比较
来源—https://pix abay . com/photos/挖掘机-铲斗-车轮-挖掘机-1050501/
在本帖中，我们将比较以下超参数优化方法。
- 随机搜索
- 使用超点的贝叶斯搜索
- 结合异步超带的贝叶斯搜索
- 基于人口的培训
实验
我们将在 MNIST 数据集上训练一个简单的 DCGAN，并优化模型以最大化初始得分。
我们将使用 Ray Tune 来执行这些实验，并在 W&B 仪表板上跟踪结果。
我还在我的频道上做了一个视频，深入解释了这个实验-
搜索空间
为了使比较公平，我们将对所有实验使用相同的搜索空间。
随机搜索
让我们在搜索空间中执行随机搜索，看看它的优化效果如何。这也将作为我们比较的基准指标。我们的实验设置有 2 个 GPU 和 4 个 CPU。我们将在多个 GPU 上并行化操作。如果您指定了resources_per_trail，光线调节会自动为您执行此操作。
让我们看看结果
作者图片
推理
正如所料，我们得到了不同的结果。
- 一些型号确实优化了，因为调谐器运气好，选择了正确的超参数集
- 但是一些模型的初始得分图仍然是平坦的，因为它们由于不好的超参数值而没有优化。
- 因此，当使用随机搜索时，您可能最终会达到最优值，但是您最终肯定会在不增加任何价值的运行中浪费大量资源。
超点贝叶斯搜索
贝叶斯超参数调整背后的基本思想是在选择超参数时不是完全随机的，而是使用来自先前运行的信息来选择下一次运行的超参数。Tune 支持实现贝叶斯搜索算法的 HyperOpt。这是你怎么做的。
结果看起来是这样的
作者图片
推理
- 与之前的运行相比有显著的改进，因为只有一条平曲线。
- 这意味着搜索算法基于先前运行的结果选择超参数值。
- 平均而言，运行比随机搜索表现更好
- 可以通过更早地终止不良运行来避免资源浪费。
异步超带贝叶斯搜索
异步超带的想法是消除或终止表现不佳的运行。将这种方法与贝叶斯搜索结合起来是有意义的，看看我们是否可以在没有优化的运行中进一步减少资源的浪费。我们只需要在代码中做一点小小的改动来适应 Hyperband。
现在让我们看看这是如何执行的
作者图片
推理
- 20 次运行中只有 2 次在规定的时期内执行，而其他运行则提前终止。
- 所达到的最高精度仍然略高于没有 Hyperband 调度程序的运行。
- 因此，通过在训练过程的早期终止不良运行，我们不仅加快了调优工作，还节省了计算资源。
基于人口的培训
我们将讨论的最后一个调优算法是由 Deepmind research 引入的基于群体的训练(PBT)。通俗地说，算法背后的基本思想是:
- 对于给定的时间步长(或迭代次数)t，对一些样本运行优化过程
- 在每 T 次迭代之后，比较运行，并将良好运行的权重复制到不良运行，并改变它们的超参数值以接近良好运行的值。
- 终止表现最差的运行。尽管算法背后的想法似乎很简单，但从头开始构建它需要大量复杂的优化数学。 Tune 提供了 SOTA PBT 算法的可扩展且易于使用的实现
现在让我们看看结果。
作者图片
推理
结果看起来相当令人惊讶。这些结果有许多独特的因素。
- 几乎所有的运行都达到了最佳点
- 最高分(6.29)是由一次跑步获得的
- 随着实验的进行，开始时表现不佳或异常的运行也收敛了。
- 没有运行具有平坦的初始得分图
- 一些表现不佳的运行在过程中被停止
- 因此，没有资源被浪费在不良运行上
PBT 是如何优化从错误的超参数值开始的运行的？
答案是由 PBT 调度程序完成的超参数突变。在每一个T时间步之后，该算法还变异超参数的值，以最大化期望的度量。下面是 PBT 调度程序在这个实验中是如何改变参数的。
超参数突变
现在让我们看看超参数是如何被 PBT 算法调整来最大化初始得分的
作者图片
作者图片
推理
- 超参数值在整个实验过程中不断调整。
- 以坏的超参数值开始的运行很快被更新。
- PBT 根据探索和利用方法运行，探索良好参数值的空间，并通过更新不良运行来利用。
减少运行次数
我们现在将运行次数减少到 5 次，以便给 PBT 制造困难。让我们看看它在这种受限的情况下表现如何。
作者图片
推理
- 即使将运行次数减少到 5 次，PBT optimizer 仍然优于随机搜索和贝叶斯优化。
- 正如预期的那样，表现不佳的运行在训练过程的早期就被终止了
比较各次运行的平均初始得分
以下是平均盗梦分数的最终比较结果。我们对 5 次运行集进行了平均:
- 随机搜索— 10 次运行(作业类型—随机)
- 贝叶斯搜索— 10 次运行(工作类型—mnist-hyperpt)
- 使用 Hyperband 的贝叶斯搜索-20 次运行(工作类型-mnist-SHA2-hyperpt)
- PBT 调度程序— 10 次运行(作业类型— mnist-pbt2)
- PBT 调度程序— 5 次运行(作业类型— mnist-pbt3)
作者图片
结尾注释
如果你喜欢读这篇文章，你可以在推特上关注我，获取更多更新。我还在我的 youtube 频道上制作深度学习视频。
比较熊猫的数据结构
伊洛娜·弗罗利希在 Unsplash 上的照片
我将演示几种方法，并解释每种方法的优缺点
数据框架是数据科学的主力。虽然它们不是该领域最迷人的方面，但如果你让我挑选一个数据科学家掌握的最重要的东西，那就是熟练构建和操作数据框架的能力。
在过去的一篇文章中，我将数据帧描述为部分 Excel 电子表格和部分 SQL 表，但是具有 Python 的所有通用性和分析能力。老实说，我还不是一个专业的熊猫用户，但我的目标是成为一个。这就是为什么每当我学到一些新的有用的东西，我都会试着把它记录在这里。
今天的主题是比较平等(或不平等)的数据框架。通常，当处理存储在数据帧中的数据时，我们需要知道它们是否相同。如果不是，则突出显示差异。使用案例包括:
- 根据主拷贝快速检查您的数据帧。
- 如果您下载了现有数据集的更新版本，您可能希望标识任何新行或更新的单元格。
方法 1:使用。eq 方法
熊猫数据框自带便利**。eq** 法。它可以让您快速比较两个数据帧，并突出显示任何不同的单元格。例如，假设我们有一些 NBA 球员的数据和他们赢得的冠军数(戒指)。
现在我们假设一个朋友正在做一个关于篮球的研究项目，并要求我们检查他的数据(他比我们更少是一个 NBA 球迷)。我们的数据在 array_1 和 df_1，朋友让我们查的数据在 array_2 和 df_2:
*# Our data*
array_1 = np.array([['LeBron',3],
['Kobe',5],
['Michael',6,],
['Larry',3],
['Magic',5],
['Tim',4]])
df_1 = pd.DataFrame(array_1,
columns=['Player','Rings'])*# Data from friend*
array_2 = np.array([['LeBron',3],
['Kobe',3],
['Michael',6,],
['Larry',5],
['Magic',5],
['Tim',4]])
df_2 = pd.DataFrame(array_2,
columns=['Player','Rings'])
我们可以使用。快速比较数据帧的 eq 方法。的产量。eq 列出了每个单元格位置，并告诉我们该单元格位置的值在两个数据帧之间是否相等(注意第 1 行和第 3 行包含错误)。
**In:**
df_1.eq(df_2)**Out:
** Player Rings
0 True True
1 True False
2 True True
3 True False
4 True True
5 True True
我们可以使用布尔索引和**。all** 方法打印出有错误的行。布尔索引使用一组条件来决定打印哪些行(布尔索引等于 True 的行被打印)。
**In:** *# .all returns True for a row if all values are True*df_1.eq(df_2).all(axis=1)**Out:** 0 True
1 False
2 True
3 False
4 True
5 True*# Above the rows marked True are the ones where all values equal.
# We actually want the rows marked False***In:** *# Note that we specify the axis to let Pandas know that we care* # *about equality across all the columns in a row*df_2[df_1.eq(df_2).all(axis=1)==False]**Out:
** Player Rings
1 Kobe 3
3 Larry 5
我们发现我们朋友关于科比和拉里的数据都是错的(科比其实就是 5 环的那个)。因为我们正在寻找值不相等的单元格，所以我们实际上可以使用更简洁地完成这项工作。ne 方法(。ne 代表不相等)和**。任何**:
**In:** # *.any returns true for row if any of the row's values are True*df_2[df_1.ne(df_2).any(axis=1)]**Out:
** Player Rings
1 Kobe 3
3 Larry 5
突出的一点是。情商和。当我们比较相同维数的数据帧时，效果更好。但是如果他们不是呢？比如说我们朋友的 dataframe 行数比我们多(加了 KG 和 Charles)。
*# Data from friend*
array_3 = np.array([['LeBron',3],
['Kobe',3],
['Michael',6,],
['Larry',5],
['Magic',5],
['Tim',4],
['KG',1],
['Charles',0]])
df_3 = pd.DataFrame(array_3,
columns=['Player','Rings'])
现在，让我们使用。需要找出不同之处。的。ne 方法已确定第 1、3、6 和 7 行中的差异。
**In:**
df_1.ne(df_3)**Out:**
Player Rings
0 False False
1 False True
2 False False
3 False True
4 False False
5 False False
6 True True
7 True True
如果我们试图在 df_1 上使用布尔索引来打印差异，Python 会给我们一个警告(因为我们的布尔索引比 df_1 长)，并且只打印 Kobe 和 Larry 的行(我们最初识别的差异)。它没有打印出 KG 和 Karl，因为它们不在 df_1 中。为了打印所有的文件，我们需要在 df_3 上使用布尔索引:
**In:**
df_3[df_1.ne(df_3).any(axis=1)]**Out:**
Player Rings
1 Kobe 3
3 Larry 5
6 KG 1
7 Charles 0
如果指数不同呢？
所以当数据帧长度不同时，它也能工作。但是如果指数不同呢？索引是数据帧的关键部分，它基本上是一行的名称，以及我们需要获取数据时如何引用该行。**当两个数据帧之间的索引不同时(即使单元格中的实际内容相同)，则。eq 方法将它们视为不同的实体。**让我们用字母索引代替数字索引来创建一个新的数据框架:
**In:**
# Array with alphabetical index
df_4 = pd.DataFrame(array_3,
index=['a','b','c','d','e','f','g','h'],
columns=['Player','Rings'])
print(df_4)**Out:
** Player Rings
a LeBron 3
b Kobe 3
c Michael 6
d Larry 5
e Magic 5
f Tim 4
g KG 1
h Charles 0
现在让我们试试。eq。输出是一个长而无用的数据帧。它的行数与我们的两个数据帧 df_1 (6 行)和 df_2 (8 行)的总和一样多。这样做是因为即使单元格内容相同，索引也不相同。等式假设两个数据帧之间没有什么是相同的。
**In:**
df_1.eq(df_4)**Out:**
Player Rings
0 False False
1 False False
2 False False
3 False False
4 False False
5 False False
a False False
b False False
c False False
d False False
e False False
f False False
g False False
h False False
让我们看看如何解决这个问题。
比较具有不同索引的数据帧
最简单的方法就是重置索引。在这种情况下，我们只需要重置 df_3 的索引(它将从字母回到从 0 开始的数字)。不要忘记删除索引，这样在重置后就不会出现额外的列。
正如你所看到的，由于重置了索引，输出回到了错误的条目(科比和拉里)以及新的条目(KG 和查尔斯)。
**In:**
*# Reset index first and drop the original index*
df_3_reset = df_3.reset_index(drop=True)*# Use boolean indexing and .ne method on reset index*
df_3_reset[df_1.ne(df_3_reset).any(axis=1)]**Out:**
Player Rings
1 Kobe 3
3 Larry 5
6 KG 1
7 Charles 0
不算太糟吧？这种方法的一个问题是，它要求第二个数据帧的索引(post reset)与第一个数据帧的对齐。换句话说，df_1 和 df_3 中重叠的球员一定是相同的(而且顺序相同)，他们是——勒布朗、科比、迈克尔、拉里、魔术师、蒂姆。
但如果他们不是呢？相反，假设我们下载了一些新数据，我们希望将它们合并到我们的数据集中。不幸的是，新的数据与我们现有的数据有一些冗余，即勒布朗，迈克尔和魔术师。
*# New data to add to our dataset*
array_new = np.array([['LeBron',3],
['Michael',6,],
['Magic',5],
['KG',1],
['Charles',0],
['Stephen',3],
['Patrick',0]])
df_new = pd.DataFrame(array_new,
columns=['Player','Rings'])
新数据如下所示。注意迈克尔的指数在 df_1 里是 2 但是在这里是 1，魔术师的指数在 df_1 里是 4 但是在这里是 2。
Player Rings
0 LeBron 3
1 Michael 6
2 Magic 5
3 KG 1
4 Charles 0
5 Stephen 3
6 Patrick 0
让我们使用之前的方法来比较数据帧。eq 和. ne .首先让我们用。eq(和。all)来查看新数据和现有数据之间的相同之处:
**In:**
df_new[df_1.eq(df_new).all(axis=1)]**Out:
** Player Rings
0 LeBron 3
它说只有勒布朗的条目是相同的，即使迈克尔和魔术师的数据也是一样的。正如我们已经知道的，问题在于不同的指数。如果我们使用。ne(和。any)来标识新的或不同的行，我们会得到一个很长的列表，其中包括我们不想放在那里的行—我们不想错误地将多余的 Michael 和 Magic 条目插入到我们的数据中。
**In:**
df_new[df_1.ne(df_new).any(axis=1)]**Out:
** Player Rings
1 Michael 6
2 Magic 5
3 KG 1
4 Charles 0
5 Stephen 3
6 Patrick 0
使用合并
在这种情况下，最好的方法(据我所知)是使用**。合并方法(我在这里写了一篇关于合并的文章，所以如果你需要背景知识，可以看看这篇文章。合并。这有点绕弯，但是通过使用 merge，我们可以只比较每个条目的值，而不考虑索引。**
使用 Player 和 Rings 列进行合并允许我们匹配现有数据帧和新数据帧中具有相同值的行(同时忽略数据帧索引中的差异)。我们需要重命名新数据帧中的 Rings 列，使它作为两个独立的列输出(旧的 Rings 和新的 Rings_new)。一旦我们检查了输出，您就会明白为什么。
# Need to rename Rings since we are merging on it but we want
# it to show as different columns post-merge
temp = df_new.rename({'Rings': 'Rings_new'}, axis=1)merged = temp.merge(df_1, how='left',
left_on=['Player','Rings_new'],
right_on=['Player','Rings'])
我已经打印了名为“合并”的数据框的内容。NaN 就是我们要找的东西(这也是为什么我们需要两栏都显示)。因为我们进行了左连接，所以输出包括 df_new 中的每一行——我们在 df_1 中已经有数据的球员在 Rings 列中有数值。新玩家在“环”列中用 NaN 值表示，这是我们唯一想添加到数据集的玩家。
Player Rings_new Rings
0 LeBron 3 3
1 Michael 6 6
2 Magic 5 5
3 KG 1 NaN
4 Charles 0 NaN
5 Stephen 3 NaN
6 Patrick 0 NaN
我们可以通过对数据帧进行切片来分离出新的条目，只对环中具有 NaN 值的行进行切片:
**In:**
df_new[merged['Rings'].isna()]**Out:**
Player Rings
3 KG 1
4 Charles 0
5 Stephen 3
6 Patrick 0
并像这样连接到我们的数据帧:
final_df = pd.concat([df_1,
df_new[merged['Rings'].isna()]],
axis=0)
最后，我们得到了我们想要的。final_df 的内容如下所示:
Player Rings
0 LeBron 3
1 Kobe 5
2 Michael 6
3 Larry 3
4 Magic 5
5 Tim 4
3 KG 1
4 Charles 0
5 Stephen 3
6 Patrick 0
请注意，如果在新数据中有一个现有球员(如[LeBron，0])的错误条目，它也会被插入，因为我们合并了球员和戒指(因此，为了匹配条目，姓名和戒指数需要相同)。如果我们不想要这种行为，那么我们可以只在玩家列合并。这也可能引起问题，因为可能会有另一个同名但戒指数不同的球员(比如迈克尔·库帕有 5 枚戒指，而迈克尔·乔丹只有 6 枚)。当然，对于一个真实的数据集，我们将包括足够多的字段，以便我们可以唯一地识别每个球员(例如，名字，姓氏，出生日期)。
希望这是有见地的，祝你的数据框架好运！干杯！
如果你总体上喜欢这篇文章和我的写作，请考虑通过我的推荐链接注册 Medium 来支持我的写作。谢谢！
比较 Q 级咖啡:地区、年份和加工
咖啡数据科学
使用 Q 等级特征检查匹配分数
之前，我观察了 Q-grade 的每个子指标与总分的关联程度，一些有趣的记录出现在某些年份和地区。现在，我的目的是看看如何将子指标用作特征描述符，并相互比较。这是否揭示了咖啡在地区、年份或加工方法上的相似之处？
类似
为了计算相似性得分，使用均方根将 10 个子指标的每个向量与所有其他向量进行比较:
这些分数是针对所有咖啡和所有咖啡计算的，如下图所示，按分数着色并按国家排序:
本文中的所有图片均由作者提供。
然而，在下面的细目分类中，我将每个图表调整到 0%到 100%之间。100%不代表完全匹配，0%也不代表不匹配。它相对于每个图表中的数据，其中 100%是最大相似度(最相似)，0%是最小相似度(最不相似)。
按地区
我们可以从查看每个地理区域开始。非洲咖啡豆比其他任何地方的咖啡豆都更像南美咖啡豆。中美洲的豆子似乎非常独特，与其他地区的豆子不同，但是南美洲的豆子与其他地区的豆子有最多的共同点。
这可以按国家进一步细分，这有助于我们更好地了解这些地区。这并不是说非洲的咖啡豆和它们自己的相比不好，而是南美的咖啡豆和非洲的相比要好得多。一些中美洲的豆类比非洲的一些国家好。
结果很有趣，有多少品种和多少咖啡是彼此相似的。主要的区别在于巴布亚新几内亚和美国，它们不能与多种咖啡相提并论。
我希望这张表能有所帮助，作为参考，甚至在人们做杯子的时候进行比较。我很好奇哪些咖啡是杯装在一起的，因为这可能会影响体验。
按年份
在我之前使用相关性进行的分析中，2015 年脱颖而出。在这种情况下，2010 年和 2017 年似乎是疯狂的一年，因为相对而言，它们与其他年份并不相似。2018 年比什么都好，因为在这个数据集中只有 8 种 2018 年的咖啡。
我们也可以按年查看地区，看看是否有任何有趣的趋势，因为一年中的天气对考虑作物结果很重要。这是一个非常高的水平，只有颜色编码，但如果有人好奇，我会很高兴地分享这些表进行更深入的检查。
南美似乎是多年来最相似的地方，我怀疑这是因为更多的咖啡被清洗，而不是自然或干燥加工。中美洲似乎是 2010 年和 2017 年是怪异年份这一概念的关键角色。
通过加工
看看加工过程，我们看到了在品尝豆子时所看到的，清洗豆子在某些方面使味道变得均匀。洗豆比其他工艺更类似于其他豆类。天然加工的豆子最不像自己。
我们可以将这一过程按地区进行细分，以帮助了解它们是如何相似的。正如你所看到的，湿加工的咖啡豆在地域上比干加工的咖啡豆更相似。干加工的非洲咖啡豆似乎与其他地区/加工过程最不相似。
在计算干与干、干与湿、湿与湿的平均相似性时，可以看到下表的简化。
在某些情况下，干加工的分数比湿加工的好，而不是其他干加工的。这有点令人惊讶，但一个未知的变量是其他豆子在同一时间被分级。如果一个人同时给多个豆子评分，分数可能会受到类似的影响。
所以我们来看看分级协会！
分级员
每个分级员都属于一个分级协会，人们可以假设在一个协会内，分级员对咖啡的分级会更加相似。一些评分者有非常相似的分数，理想情况下，每个人都会给豆子打相同的分。问题总是不同的咖啡产区用不同的分级体。
我们可以通过移除 10 级或以下咖啡的分级员来压缩这张桌子。看看这个，我们可以看到一些评级机构与其他机构非常不同，但这也可能是他们对咖啡进行评级的类型。
大多数协会对自己的评分和对彼此的评分相似。有一些异常值，他们的评分和其他人不一样。
这是在使用现代数据科学和模式识别技术来帮助理解咖啡如何相互分级以及通过等级来确定咖啡有多相似的方向上迈出的又一步。q-分级是主观的，但目的是有一个共同的语言，以比较/对比的方式谈论咖啡。希望随着数据在咖啡供应链中变得更加完整，看到这种类型的比较不仅会变得更加普遍，而且它们将成为影响我们制作咖啡的工具。
如果你愿意，可以在 Twitter 和 YouTube 上关注我，我会在那里发布不同机器上的浓缩咖啡视频和浓缩咖啡相关的东西。你也可以在 LinkedIn 上找到我。
我的进一步阅读:
比较最佳免费金融市场数据 API
作为一名数据科学家、交易员或投资者，如果你想分析金融市场数据——股票市场或加密数据，从这里开始吧。
克里斯·利维拉尼在 Unsplash 上的照片
在我们的世界里，很少有东西像金融市场和数据这样紧密相连。金融市场的整个功能是基于其参与者对可用信息和从所述信息中综合的知识采取行动；目标是以他们认为有利的价格购买或出售资产。
这种机制设定了市场价格，进而赋予市场另一个关键属性——数据来源。不管有效市场假说的有效性，以及价格的客观正确性，很少有东西能像市场数据那样捕捉到集体情绪。
此外，可用数据的粒度随着时间的推移而增加，现在可以捕捉个人情绪以及集体情绪。其结果是，如此丰富、如此广泛、拥有如此多市场历史的任何数据源都很少有相似之处。
照片由 Aditya Vyas 在 Unsplash 拍摄
例如，纽约证券交易所自 1792 年就已经成立了。)而如今，据说仅美国的纽约证券交易所这样的主要交易所平均每天就产生大约 300 亿个市场事件。
鉴于这些市场涉及大量资金，以及不断寻求优势的猫鼠游戏，寻求更多更好的数据并不奇怪。
虽然这些天来市场通过销售其数据产品获得了可观的收入，但市场数据分析领域仍然有许多优秀的、免费的切入点。这些 API 中的一些还提供关于加密资产以及来自股票市场的信息。
因此，在本文中，我比较了几个顶级金融市场数据 API 的自由层。我希望它们对你有用。
API 比较—概述
IEX 云
IEX 是一家初创股票交易所，其联合创始人布拉德·山因迈克尔·刘易斯的书《闪光男孩》而出名
IEX 的价值主张是，它的目标是成为一个交易所“，消除行业中一些最糟糕的做法“ ( 文章濒临破产)。 IEX 云(网站)是 IEX 的数据 API 分支，提供如下免费层:
IEX 云免费层(截至 2020 年 3 月 9 日)
廷戈
它们从 2014 年就已经存在了(见这篇关于 2015 年 HackerNews 的讨论)，如果没有别的，存活这么久可能是其可靠性和可行性的一个好迹象。
他们的自由层功能概述如下:
Tiingo 自由层(截至 2020 年 3 月 9 日)
Quandl
Quandl 自 2013 年以来一直存在，现在是纳斯达克的一部分。
他们的使命不仅仅是收集股票市场数据，因此他们从大量广泛的来源提供各种不同领域的数据集。虽然不是所有的数据产品都是免费的，但是他们的财务数据 API 是免费的，有以下限制:
Quandl 自由层(截至 2020 年 3 月 9 日)
有趣的是，Quandl 似乎还提供了为 R、Python 和 Excel 编写的原生工具，旨在使下载数据更容易。
阿尔法优势
除了这种相对宽泛的简介，Alpha Vantage 网站上关于他们成立的时间、他们是谁以及该组织代表什么的信息相对较少。
关于 Alpha Vantage ( 链接)
尽管如此，他们确实提供了一个如下的免费层，并且看起来使用相对广泛。
Alpha Vantage 自由层(截至 2020 年 3 月 9 日)
WorldTradingData
他们的网站(链接)同样包含很少的关于他们是谁的信息，但与其他网站类似，他们提供一个免费层，并因此相对知名。
详细的自由层比较
每个网站上的信息布局使得产品比较非常困难，所以下面是我的尝试:
有用数据
幸运的是，所有这些 API 似乎都提供了历史和当日美国股票价格，以及外汇数据。因此，就数据可用性而言，任何这些服务都可能满足您的大部分需求。
对于加密货币数据，IEX、Quandl 和 Tiingo 提供这些数据，而 Alpha Vantage 和 WorldTradingData 则没有。
如果你在 API 访问额外(非价格)信息后，IEX 也提供 API 访问基本面和新闻数据。Quandl 的部分数据源也是免费的。
自由层数据限制
因为它有点复杂，让我们把 IEX 留到最后，看看其他的:
- Tiingo :每月 500 个唯一符号，500 个请求/小时，20000 个请求/天，5gb/月(来源)。
- Quandl : 300 个请求/10 秒，2000 个请求/10 分钟，50000 个请求/天，如果经过认证(来源)。(每 10 分钟 20 个电话，如果匿名，每天 50 个电话)
- Alpha Vantage : 5 个请求/分钟，500 个请求/天(来源)。
- WorldTradingData : 250 个请求/天(25 个当天请求/天)(来源)。
现在，让我们来看看 IEX。他们有每月 50，000 条核心“消息”的自由层限制。每种类型的请求将使用不同数量的消息，因此数据越多，使用的消息就越多。
50，000 条消息并不是一个很大的数目。平均来说，不太可能有 Tiingo 和 Quandl 那么多数据(虽然这取决于使用情况)，所以我会建议明智地使用它们。
该计算器将为您提供使用特定数据端点的每个月将使用多少“消息”的估计。
IEX 云是构建金融科技应用最简单、最容易实现的方式。
iexcloud.io](https://iexcloud.io/calculator/)
令人高兴的是，IEX 是唯一一个提供沙盒测试模式的公司，这种模式将返回“虚拟”或随机数据。沙盒模式可以用来测试和优化你的代码，看看你在真实的、实时的模式下会使用多少消息，对个人来说这是一个很大的好处。
证明文件
总的来说，我发现 IEX 云文档是我看过的所有文档中最全面的。
以下是他们文档的链接:
IEX 云是构建金融应用程序最简单的方式。
iexcloud.io](https://iexcloud.io/docs/api/)
例如，IEX 文档清楚地显示了历史价格请求的响应属性:
IEX 文档—响应属性(链接)
IEX 文档包括请求示例、参数列表、响应示例和属性，以及版本、错误代码和安全说明等其他方面。
据我所知，IEX 是名单中最大的组织，这在这里的全面性上得到了体现。
这并不是说其他人的文件是缺乏的，更多的是 IEX 的文件是非常全面的。
Tiingo 的文档在这里:
[## 股票市场工具| Tiingo
一个金融研究平台，致力于为所有人创造创新的金融工具，同时采用座右铭…
api.tiingo.com](https://api.tiingo.com/documentation/general/overview) 
Tiingo 文档—响应属性(链接
Quandl 在这里:
[## Quandl 文档
获取您的免费 API 密钥，开始使用我们的数据。开始使用我们强大的数据 API 分析所需的一切…
docs.quandl.com](https://docs.quandl.com) 
Quandl 文档—响应属性(链接)
这两个都非常详细，有示例请求和参数，以及响应示例和参数。虽然可能不如 IEX 文档那样令人印象深刻，但这些仍然相当可靠。
最后，我将把 Alpha Vantage 和 WorldTradingData 文档放在最后一层。
Alpha Vantage 的 API 文档。Alpha Vantage 为实时和历史股票和权益提供免费的 JSON APIs
www.alphavantage.co](https://www.alphavantage.co/documentation/) [## API 文档|世界贸易数据
我们的 API 通过我们的 API 提供对 JSON 或 CSV 格式的实时和历史股票数据的有效访问…
www.worldtradingdata.com](https://www.worldtradingdata.com/documentation)
虽然它本身没有遗漏任何信息，但它们显然不像其他的那样完整或有解释力。
根据你对编程和 API 的经验水平，你可能会从 IEX / Tiingo 和 Quandl 的更全面的文档中获益更多。
结论
我试图在这里给出顶级免费金融市场数据 API 的简要概述。
上面列出的五个 API 都是非常惊人的数据服务，尤其是考虑到它们的运行是免费的。如上所述，历史数据或当天数据等常见数据类型可从所有提供商处获得，选择哪种服务在很大程度上取决于个人选择。
说到这个，作为金融界的爱好者，我个人更喜欢 IEX。对于像我这样的临时用户，我希望学习曲线越浅越好，他们的大量文档会非常有帮助，就像他们的沙盒模式一样。不过，如果我需要更多的数据，Quandl 或 Tiingo 似乎也是不错的选择。
不过，总的来说，我(非专家)的观点是，所有这些似乎都是进入金融市场数据分析世界的非常可靠的切入点，您可能希望选择一个最适合自己的。
我希望你觉得这是有用的，如果你有任何意见，或者我犯了什么错误，请告诉我！
在接下来的几周里，我将使用来自一个或多个 API 的数据进行分析。
(如果你想知道为什么我没有包括雅虎！，这是因为它已被官方弃用——尽管许多人似乎仍在使用它)
- 注意:这篇文章包含一个亚马逊联盟链接，这意味着在你没有额外费用的情况下，如果你购买，我会得到一小笔佣金。
如果你喜欢这个，比如说👋/关注推特，或点击此处获取更新。如果你错过了，看看这篇关于可视化时间序列数据的文章。
使用 Python 和 Plotly 构建清晰易读的时序数据可视化，以支持您的叙述。
towardsdatascience.com](/effectively-visualize-data-across-time-to-tell-better-stories-2a2c276e031e)
这是关于用 Plotly Dash 建立一个网络数据仪表板。
[## 使用 Python 在几分钟内构建一个 web 数据仪表板
通过将您的数据可视化转换为基于 web 的仪表板，以指数方式提高功能和可访问性…
towardsdatascience.com](/build-a-web-data-dashboard-in-just-minutes-with-python-d722076aee2b)
比较预报模式的性能:霍尔特-温特斯与 ARIMA
如何评估模型性能以及如何选择合适的模型
菲尔·德福斯在 Unsplash 拍摄的照片
这是我写的关于时间序列预测模型的系列文章中的第三篇。第一篇文章是时间序列预测在现实世界中的应用，我用美国住房市场数据做的，目的是展示预测是如何实施和解释的。在第二篇文章中，我概述了建立预测模型的 5 个简单步骤，目标是从未做过预测的初学者。在今天的文章中，我将展示如何将两种不同的技术应用于同一数据集，以及如何评估和比较它们的性能。
在众多不同的预测技术中，我选择了两个模型来评估:ARIMA 和霍尔特-温特斯指数平滑法。在继续之前，我将简要描述它们是什么以及它们在概念上有什么不同。
ARIMA(自回归综合移动平均) : ARIMA 可以说是预测中最流行、最广泛使用的统计技术。顾名思义，ARIMA 有 3 个部分:a)一个自回归部分模拟序列和它的滞后值之间的关系；b)移动平均组件预测作为滞后预测误差的函数的未来值；c)集成组件使系列静止。
ARIMA 模型——表示为 ARIMA(p，q，d)——采用以下参数:
- 定义滞后数量的 p；
- d 指定使用的差异数；和
- q 定义移动平均窗口的大小
霍尔特-温特斯:这是另一套同样使用历史值的技术。然而，一个关键的区别特征是所谓的“指数平滑”。
如果分解，时间序列将分解成 3 个部分:趋势、季节性和白噪声(即随机数据点)。出于预测目的，我们可以预测可预测的组成部分(即趋势和季节性)，但不能预测以随机方式出现的不可预测的项目。指数平滑可以通过消除白噪声来处理序列中的这种可变性。移动平均值可以平滑训练数据，但它是通过对过去的值取平均值并对它们进行平均加权来实现的。另一方面，在指数平滑中，过去的观察值以指数递减的顺序加权。也就是说，最近的观测值比远处的值具有更高的权重。
现在让我们开始实施、比较和评估这两种预测技术。
数据准备
我做这个练习的方式是，你不必寻找外部数据集。我已经在你下面包括了美国住宅数据的一个子集——一个真实世界和最近的数据集，所以你可以在你的程序中复制它们。你应该能够跟上并从这里到结尾很好地复制一切。
我在 R 编程环境中用 Rob J. Hyndman 开发的fpp2预测包实现了这个功能。
# required package
library(fpp2)# data
values = c(92.1, 92.6, 89.5, 80.9, 95.6, 72.5, 71.2, 78.8, 73.8, 83.5, 97.9, 93.4, 98.0, 90.2, 96.7, 100.0, 103.6, 74.6, 78.9, 92.0, 83.4, 98.1, 109.9, 102.2, 102.1, 96.2, 106.9, 95.1, 113.4, 84.0, 88.6, 94.9, 94.7, 105.7, 108.6, 101.9, 113.9, 100.9, 100.2, 91.9, 99.6, 87.2, 92.1, 104.9, 103.4, 103.3, 103.9, 108.5)# time series
time_series = ts(values, start = 2015, frequency =12)
时间序列分解
时间序列分解意味着将序列解构并可视化为这些组成部分—趋势、季节性和随机成分。
趋势和季节性在时间序列中是可预测的，并且易于预测。我对随机部分最感兴趣，因为这个部分实际上决定了预测的不确定性。随机性越小，预测性能越好。
# decomposition
autoplot(decompose(time_series)) + ggtitle("Decomposition of the series") + theme(plot.title = element_text(size=8))
时间序列分解
造型:ARIMA 和 HW
你可以用许多不同的方式参数化 ARIMA 和霍尔特-温特，但我保持简单。fpp2包有auto.arima()功能，可以优化参数本身，当然你也可以随意调整参数。在霍尔特-温特斯技术中，我需要说明季节性是增加的还是增加的。在这两种情况下，我都是在预测未来 60 步(h = 60)，也就是未来 5 年。
# ARIMA
forecast_arima = auto.arima(predictor_series, seasonal=TRUE, stepwise = FALSE, approximation = FALSE)
forecast_arima = forecast(forecast_arima, h=60)# Holt-Winters
forecast_hw = hw(predictor_series, seasonal="multiplicative", h=60)
预测
运行模型后，您就可以检查预测结果了。你可以用数据图表来检查结果，或者用图形来显示。
fpp2模型具有内置的可视化功能authoplot()，可以创建时间序列数据和预测值的ggplot样式图形。它们使您可以直观地检查和确定模型的性能。
# ARIMA
autoplot(predictor_series, series=" Historical data") +
autolayer(forecast_arima, series=" ARIMA Forecast") +
ggtitle(" ARIMA forecasting") +
theme(plot.title = element_text(size=8))# HW
autoplot(predictor_series, series=" Historical data") +
autolayer(forecast_hw, series="Holt-Winter forecast") +
ggtitle("HW Exponential Smoothing") +
theme(plot.title = element_text(size=8))
用模型预测:ARIMA
用模型预测:Holt-Winters
模型评估
模型评估时间到了。对上述预测数字的直观检查并没有显示出预测结果的很大差异，这可能是因为可预测的季节性和趋势成分。然而，Holt-Winters 确实显示出(至少在视觉上)预测值的不确定性较高。
但是我们可以超越视觉检查，使用量化指标来评估性能。如果您查看模型描述并调用accuracy()函数，就会弹出一堆信息。在下表中，我总结了一些您可能用来评估模型的关键指标。
# ARIMA
forecast_arima['model']
accuracy(forecast_arima)# HW
forecast_hw['model']
accuracy(forecast_hw)
需要仔细解读这些指标。在本案例研究中，在训练数据的 RMSE 测量中存在一些差异，但是在 MAE 中的差异并不显著。就 AIC 而言，ARIMA 似乎是一个更好的模式。注意:虽然 AIC 非常擅长比较同级别车型(如 ARIMA 车型)，但它不应用于比较两个非常不同的车型级别(如 ARIMA 与硬件)。我在这里展示它们只是为了告诉大家它在实际实现中是什么样子。
尽管如此，最终确定一个合适的模型需要根据定量的模型选择标准以及使用领域知识来仔细判断和选择。
结论
本文的目的是展示使用相同数据集的不同预测模型实现，并演示如何评估模型性能以及选择适合问题空间的模型。在这里，我比较了两个模型——ARIMA 和霍尔特-温特斯——但是还有一整套其他的预测技术——T2——可以应用于给定的数据集。我鼓励你去找一个不同的数据集，尝试不同的预测模型，看看它们在不同的实现中表现如何。
TensorFlow 中全连接、简单 CNN 和 ResNet50 用于二值图像分类的性能比较
使用 TensorFlow/Keras 比较 3 个二值图像分类器模型的精确度、ROC 曲线和 AUC。你认为哪个表现最好？
梅丽莎·迪·罗科在 Unsplash 上的照片
在机器学习的世界中，有三种模型可以用来执行二进制图像分类:全连接网络、卷积神经网络，或预训练网络，如应用了迁移学习的 MobileNet】。在我以前的故事中，我展示了如何实现这些模型来构建一个图像分类器，该分类器可以对蒲公英和草进行分类，并通过计算它们的准确性、ROC 曲线和 AUC 分数来评估它们的性能。在这个故事中，我将并排比较这些模型，并比较它们的性能。如果您想跟踪这些模型的整个培训、评估和比较，请跟踪本笔记本。您可以通过转到文件- >保存副本来保存您自己的副本，从而运行代码。
你认为哪种型号性能最好？
模型架构概述
首先，让我们看一下这三种模型架构，看看它们有什么不同:
FULLY-CONNECTED MODELLayer (type) Output Shape Param # ================================================================= flatten (Flatten) (None, 120000) 0 _________________________________________________________________ dense (Dense) (None, 128) 15360128 _________________________________________________________________ dense_1 (Dense) (None, 1) 129 ================================================================= Total params: 15,360,257 Trainable params: 15,360,257 Non-trainable params: 0CONVOLUTIONAL NEURAL NETWORK MODELLayer (type) Output Shape Param # ================================================================= conv2d (Conv2D) (None, 198, 198, 16) 448 _________________________________________________________________ max_pooling2d (MaxPooling2D) (None, 99, 99, 16) 0 _________________________________________________________________ conv2d_1 (Conv2D) (None, 97, 97, 32) 4640 _________________________________________________________________ max_pooling2d_1 (MaxPooling2 (None, 48, 48, 32) 0 _________________________________________________________________ conv2d_2 (Conv2D) (None, 46, 46, 64) 18496 _________________________________________________________________ max_pooling2d_2 (MaxPooling2 (None, 23, 23, 64) 0 _________________________________________________________________ conv2d_3 (Conv2D) (None, 21, 21, 64) 36928 _________________________________________________________________ max_pooling2d_3 (MaxPooling2 (None, 10, 10, 64) 0 _________________________________________________________________ conv2d_4 (Conv2D) (None, 8, 8, 64) 36928 _________________________________________________________________ max_pooling2d_4 (MaxPooling2 (None, 4, 4, 64) 0 _________________________________________________________________ flatten (Flatten) (None, 1024) 0 _________________________________________________________________ dense (Dense) (None, 512) 524800 _________________________________________________________________ dense_1 (Dense) (None, 1) 513 ================================================================= Total params: 622,753 Trainable params: 622,753 Non-trainable params: 0MOBILENET w/ TRANSFER LEARNINGLayer (type) Output Shape Param # ================================================================= mobilenetv2_1.00_224 (Model) (None, 7, 7, 1280) 2257984 _________________________________________________________________ global_average_pooling2d (Gl (None, 1280) 0 _________________________________________________________________ dense (Dense) (None, 1) 1281 ================================================================= Total params: 2,259,265 Trainable params: 1,281 Non-trainable params: 2,257,984
请注意，全连接模型的可训练参数数量最多，其次是 CNN 模型，最后是 MobileNet 模型。在 FC 模型中，展平层中的每个连接都连接到密集层中的每个连接，从而产生更多的参数。在 CNN 中，需要的参数更少，因为每个卷积层通过卷积运算降低了输入的维数。与这两个模型相比，MobileNet 模型使用所谓的迁移学习:它不在预训练层上训练，只训练最终的密集层。它利用预训练层的特征提取能力来训练最后一层，因此只需要很少的参数来训练模型。
比较精确度
对于每个模型，我使用相同的数据集，并用 15 个时期训练模型。让我们将结果汇总在一起，并排进行比较，从精度开始:
FC accuracy: 0.5987
CNN accuracy: 0.7197
MobileNet accuracy: 0.8917
MobileNet 模型的准确性最高，其次是 CNN 模型，再其次是全连接模型。
比较 ROC 曲线和 AUC
ROC 曲线的组合图
准确性不是比较模型性能的最佳方式。分类任务的更好的度量包括 ROC 曲线和 AUC，它们测量我们的模型能够在多大程度上区分我们的两个类别，蒲公英和草。AUC 越高，我们的模型在分类上就越好。在上图中，MobileNet 在 AUC 中得分最高，其次是 CNN，然后是 FC。
以下是这些比较的要点:
- 就准确性和 ROC 曲线/AUC 而言，MobileNet 模型是一个优越的模型，尽管它没有最多的参数。这显示了迁移学习在强大的训练模型上的力量。
- CNN 模式排在第二位。卷积神经网络在二值图像分类上比全连接网络表现得更好，具有更少的参数，因为它们的共享权重结构和平移不变性特征。
- 在二值图像分类中，全连接模型比机会模型表现得更好，但它不是这样做的最佳模型。
贷款申请预测的 ML 模型比较与优化
深入研究常见的机器学习模型，以进行模型选择、验证和优化
来自 Pixabay 的 Img 通过链接
在本文中，我们将使用在线贷款申请数据详细阐述 ML 模型的选择、验证和优化。你将学习如何创建、评估和优化 ML 模型。具体来说，我们将重点介绍逻辑回归、支持向量机和随机森林。它分为 7 个部分。
- 商业挑战
- 数据审查
- 电子设计自动化(Electronic Design Automation)
- 数据处理
- 模型结构
- 模型验证
- 参数调谐
- 外卖食品
现在，让我们开始旅程🏃♀️🏃♂️.
1。商业挑战
我们被一家贷款公司委派预测优质申请人的任务。这项工作是开发一个模型，通过分析申请过程中输入的申请人数据来预测申请人的兴趣。如果申请人感兴趣，他或她将对产品进行电子签名，否则不会。
2。数据回顾
快速查看视频中显示的数据，您会发现有 21 列 17，908 行。有了这么多特性，让我们为每个变量的解释创建一个摘要，如图 1 所示，以增强我们的理解。
视频原始数据的简要视图
图 1 变量定义汇总
3。EDA
EDA 是任何数据处理之前必须要做的一步。通常，它包括数据清理、数据可视化和相关性分析。这里我就不细说 EDA 了。如果你想熟悉 EDA 的步骤，请随意阅读这篇文章。
4。数据处理
1)数据工程
在 EDA 数据可视化过程中，您可能会发现，对于变量’ months_employed '，大多数申请人的就业时间为 0 个月。这似乎不正确，所以我们将删除这个不可靠的列。
第二，可以将两列’个人账户 m’ 和’*个人账户 y '，*组合成一个新的变量来表示申请人账户的总月数。具体来说，
dataset = dataset.drop(columns = [‘months_employed’])dataset[‘personal_account_months’] = (dataset.personal_account_m + (dataset.personal_account_y * 12))dataset = dataset.drop(columns = [‘personal_account_m’, ‘personal_account_y’])
2)一键编码
我们需要将分类变量转换成数字变量。只有一个分类变量’ pay_schedule’ 。具体来说，
dataset = pd.get_dummies(dataset)
以上将*‘付薪时间表’转换为 4 列，付薪时间表 _ 双周’，‘付薪时间表 _ 月’，*付薪时间表 _ 半月’，付薪时间表 _ 周’。因为每一列都是互斥的，所以我们必须删除一列，使它们线性独立。具体来说，
dataset = dataset.drop(columns = [‘pay_schedule_semi-monthly’])
3)数据分割
为了给模型准备好数据，我们将自变量和响应变量分成测试集和训练集。
response = dataset[“e_signed”]
users = dataset[‘entry_id’]
dataset = dataset.drop(columns = [“e_signed”, “entry_id”])from sklearn.model_selection import train_test_splitX_train, X_test, y_train, y_test = train_test_split(dataset, response,test_size = 0.2, random_state = 0)
4)特征缩放
最后，我们需要缩放自变量。
from sklearn.preprocessing import StandardScalersc_X = StandardScaler()
X_train2 = pd.DataFrame(sc_X.fit_transform(X_train))
X_test2 = pd.DataFrame(sc_X.transform(X_test))
X_train2.columns = X_train.columns.values
X_test2.columns = X_test.columns.values
X_train2.index = X_train.index.values
X_test2.index = X_test.index.values
X_train = X_train2
X_test = X_test2
**注意，从 scaler 得到的数据是一个 Numpy 数组，我们将它转换为 Dataframe 以保留索引和列名。**同样，我们用 X_train 训练定标器，用训练好的定标器直接转换测试数据。
5。模型构建
首先，让我们试验不同的模型，找出最好的一个。
1)逻辑回归
让我们先创建一个线性模型。具体来说，
from sklearn.linear_model import LogisticRegression
classifier = LogisticRegression(random_state = 0, penalty = ‘l1’)
classifier.fit(X_train, y_train)
y_pred = classifier.predict(X_test)
上面的代码块将对逻辑回归模型进行定型和测试。注意我们使用了 L1 套索正则化来惩罚模型的系数。如果你想了解更多的细节，请查看这篇关于正规化的文章。
最终我们得到了 56%的准确率，57%的准确率，70%的召回率。这意味着在所有积极的预测中，只有 57%是正确的，而这些正确的预测占实际预测的 70%😆。
2) SVM(线性核)
让我们建立一个基于支持向量机的分类器。
SVM 的一个关键概念是内核。**使用核进行数据转换，使得当前数据空间中不可分的数据可以在更高维空间中分离。**它接收数据作为输入，并根据选择的内核将其转换成所需的形式。显然，选择正确的内核至关重要，因为错误的转换会使模型表现不佳。如果你想深入了解 SVM 的细节，请随意阅读这篇文章和这篇文章。
首先，让我们训练一个线性核 SVM。通常，当数据集是线性可分的，即使用单线可分时，使用线性核。它比其他任何内核都快。具体来说，
from sklearn.svm import SVC
classifier = SVC(random_state = 0, kernel = ‘linear’)
classifier.fit(X_train, y_train)
y_pred = classifier.predict(X_test)
最终我们得到了 57%的准确率，58%的准确率，73%的召回率。与逻辑回归模型相比，这是一个稍好的性能🤪。
3) SVM 银行
径向基函数是 SVM 中使用的非线性核。与线性核相比，RBF 不是一个参数模型，其复杂性随着数据的大小而增加。因此，训练模型以及进行预测的成本更高。此外，超参数越多，复杂模型越容易过度拟合。
具体来说，要实现 RBF，
classifier = SVC(random_state = 0, kernel = ‘rbf’)
classifier.fit(X_train, y_train)
y_pred = classifier.predict(X_test)
同样，经过训练和测试，我们获得了 59%准确率、60%的精确度和 69%的召回率。与线性核相比没有太大的改进😒。
4)随机森林
**随机森林通过构建大量个体决策树并输出分类问题的模式类或回归问题的均值预测来运行。**运行许多决策树的潜在逻辑是，最优决策来自群体的智慧，简单而强大。
为了实现 RF，具体地说，
from sklearn.ensemble import RandomForestClassifier
classifier = RandomForestClassifier(random_state = 0, n_estimators = 100, criterion = ‘entropy’)
classifier.fit(X_train, y_train)
y_pred = classifier.predict(X_test)
如上所述，我们创建了 100 棵决策树。最终我们得到了 62%的准确率，64%的准确率，67%的召回率。总结图 2 中的所有模型性能，我们发现 RF 的性能最佳😁。
图 2 模型性能总结
6。模型验证
在优化随机森林模型之前，我们先验证一下它的性能。这里，我们使用训练数据应用 K 重交叉验证。具体来说，
from sklearn.model_selection import cross_val_score
accuracies = cross_val_score(estimator = classifier, X= X_train, y = y_train, cv = 10)
最后，我们得到了 63%的准确率和 3%的标准偏差。这表明随机森林模型对于训练集一直表现良好😎。
7。参数调谐
因为我们知道随机森林与其他模型相比性能最佳，所以让我们通过使用参数调整来优化随机森林模型。
随机森林分类器有几个参数，包括:
- *e _ estimators】:*树的数量
- 判据 ”:衡量分割质量的判据
- " max_depth ":每棵树的最大层数
- “min _ samples _ split”:拆分一个节点所需的最小样本数
- " max_features ":寻找最佳分割时要考虑的最大特征数
- " min_samples_leaf ":一个叶节点需要的最小样本数
- " bootstrap ":数据点采样的一种方法(有替换或无替换)
在这里，我们选择下面的参数，并为每个参数设置搜索范围。
parameters = {“**max_depth**”: [3, None],“**max_features**”: [1, 5, 10],‘**min_samples_split**’: [2, 5, 10],‘**min_samples_leaf**’: [1, 5, 10],“**bootstrap**”: [True, False],“**criterion**”: [“entropy”]}
我们使用网格搜索来遍历所有不同的参数组合以及每个组合的交叉验证。我们也可以使用随机搜索。具体来说，
from sklearn.model_selection import GridSearchCVgrid_search = GridSearchCV(estimator = classifier, param_grid = parameters, scoring = “accuracy”, cv = 10, n_jobs = -1)grid_search = grid_search.fit(X_train, y_train)
请注意，我们使用 10 重交叉验证。最后，网格搜索发现最佳参数如下图 3 所示，准确率为 63%😃。
图 3 使用“熵”的网格搜索第一轮结果
这样，我们可以使用这些参数在测试数据集上测试模型，或者执行第二轮网格搜索来微调参数。如果你想要第二轮，试试下面的参数。
parameters = {“max_depth”: [None], “max_features”: [3, 5, 7], ‘min_samples_split’: [8, 10, 12],‘min_samples_leaf’: [1, 2, 3], “bootstrap”: [True], “criterion”: [“entropy”]}
最终，在相同的参数下，我们得到了同样的 63%的准确率。这意味着我们从第一轮得到的结果已经是最佳的了👌。
图 4 使用“熵”的网格搜索第二轮结果
最后，让我们在测试数据上使用优化的模型。最后，我们得到了图 5 中的结果。巨大的成果。
图 5 基于熵优化射频的模型性能总结
注意上面我们使用熵作为分裂标准。你也可以用’基尼’。**熵和基尼系数是衡量一个节点不纯程度的指标。有多个类的节点是不纯的，而只有一个类的节点是纯的。一般来说，决策树是通过递归分割变量或响应变量的特征来工作的。它旨在通过最大化每个节点的纯度来优化每个拆分。**熵旨在最大化每次分裂所获得的信息内容，并且期望从分裂节点获得的信息越多，分裂就越好。另一方面，基尼系数衡量的是贴错标签的可能性。根据使用的标准，决策树结果可能会有所不同。如果你需要更多关于这个话题的细节，请随意阅读这篇文章。
现在让我们使用“G ini 作为标准执行相同的网格搜索，保持其余参数不变。第一轮之后，我们获得了 64%的准确率。
图 6 使用“基尼”的网格搜索第一轮结果
如果我们执行第二轮来微调上述参数，我们使用下面的最佳参数再次获得了 64%的准确度。
图 7 使用“基尼”的网格搜索第二轮结果
有了微调的参数，我们来测试模型。如图 8 所示，基于熵和基尼的模型之间存在微小的性能差异。
图 8 基于基尼系数优化射频的模型性能总结
8。外卖
我们使用相同的数据测试了 4 个不同的模型，逻辑回归、SVM(线性)、SVM (RBF)和随机森林。随机森林被证明具有 63%的准确率。使用网格搜索，我们将模型性能提高了 1–3%。
从商业角度来说，利用该模型的一种方法是针对那些预测不会签署定制入职流程贷款的人。这将有助于公司赢得更多客户，改善业务。
太好了！如果你觉得这篇文章有帮助，请随意点击👏s！如果您需要源代码，请随时访问我的Github页面🤞🤞🤞。
CPU 和 GPU 的集群性能比较
一个基准:Scikit-Learn 和 TensorFlow-GPU 的 K 均值算法
(来源)
当你想对一个现象有更深的理解时，一种方法是将他们分组，这样更容易理解。例如，您可能想按标题观看电影，而另一个人可能想按类型观看。你决定如何对它们进行分组会引导你对它们有更多的了解。
在机器学习中，将数据点分成一定数量的组称为聚类。这些数据点没有初始标签。因此，聚类是将未标记的数据点分组，以更有意义的方式找出它们。
要深入了解聚类技术，请访问 麻省理工学院-edu 笔记。
在这篇文章中，目的是通过的执行时间来比较 Scikit-Learn (random，k-means++) 和 TensorFlow-GPU (k-means++，Tunnel k-means) 算法的集群性能，并通过提供相应的系统规格将它们打印在比较矩阵中。由于数据的内容不是本次基准研究的重点，因此所需的数据集将随机生成。
当你想对一个现象有更深的理解时，一种方法是把他们分成小组来做…
www.commencis.com](https://www.commencis.com/thoughts/comparison-of-clustering-performance-for-both-cpu-and-gpu/)
k 均值聚类
k 均值聚类 的目的是以不重叠的方式将一些数量的观察值 n 划分成 k 数量的质心。数据点的数量在集群内部应该尽可能的一致，在集群外部应该尽可能的不同。更多理论解释，请访问本网页。
在这篇文章中，将测试三个不同的环境 (2 个不同的 CPU 驱动系统，1 个 GPU 驱动系统)。系统规格添加如下。
第一个 CPU 供电的系统规格:
**处理器:**英特尔®酷睿™i7–8850h
处理器速度: 2.60 GHz
物理核心: 6
逻辑处理器: 12
物理内存(RAM): 64 GB第二 CPU 供电系统规格:
**处理器:**英特尔®酷睿™i9–10900
处理器速度: 3.70 GHz
物理核心: 10
逻辑处理器: 20
物理内存(RAM): 256 GB (8 个 32GB DDR4 3000 MHz)GPU 驱动的系统规格:
**处理器:**英特尔®酷睿™i9–10900
处理器速度: 3.70 GHz
**图形处理器(GPU)😗*NVIDIA GeForce RTX 2080 ti 352 位 11GB GDDR6 内存(2)
1.基于 CPU 的 K-均值聚类
中央处理器(CPU)是计算机的关键部件，大部分处理和计算都在其中进行。
对于进一步的编码部分，我们将使用 Python 编程语言*(*3.7 版 ) 。 PyCharm 和 Jupyter 笔记本 都可以用来运行 Python 脚本。为了便于使用，可以安装 Anaconda ，因为它本身包含了所有必需的 IDE 和重要包。
作为第一步，我们将安装 CPU 实施所需的软件包。
pip install psutil
pip install numpy
pip install matplotlib
pip install scikit-learn
安装完psutilnumpymatplotlibsk learn我们将导入**
***import platform
import time
import psutil as ps
import platform
from datetime import datetime
import numpy as np
import matplotlib.pyplot as plt
from sklearn.cluster import KMeans***
在开始集群之前，可以使用下面的代码片段检查 CPU 信息及其当前的 CPU 使用百分比。
***print("Physical cores:", ps.cpu_count(logical=False))
print("Logical cores:", ps.cpu_count(logical=True),"\n")
print("CPU Usage Percentages:", "\n")
for i, percentage in enumerate(ps.cpu_percent(percpu=True)):
print(f"CPU {i}: {percentage}%")
print("\n")
print(f"Current CPU Usage in Total: {ps.cpu_percent()}%")***
第一个 CPU 系统信息(图片作者提供)
第二 CPU 系统信息(图片由作者提供)
在带有参数 “init= random” 或 “init=kmeans++” 的函数中存在两种类型的 k-means 算法。下面首先测试“init = random”，代表随机选择 k 个观测值。**
***“n _ clusters”*参数代表算法将分割成的聚类数。当我们将“n _ clusters”分配到“100”中时，向算法发出信号，将所有数据点分配到最合适的 100 个质心中。为了能够控制每次运行的随机性，应将“ random_state ”参数设置为整数；否则，每次运行都会选择不同的随机组，这将很难与之前的输出进行比较。
**kmeansRnd = KMeans(n_clusters=100, init='random',random_state=12345)**
设置集群参数后，生成 5 列 500 K 行的随机数。
**CPU_Test_1 = np.random.normal(size=(500000,5))**
现在，我们有 5 列和 500 K 行随机生成的数据。使用“ fit_predict ”函数，将通过输入名为“ CPU_Test_1 ”的数据来计算每个数据点的聚类中心和聚类指数。
**kmeansRnd.fit_predict(CPU_Test_1)**
使用 python 的“ plotly ”包添加样本的可视化和聚类数。在描述数据点和聚类的同时，该绘图脚本的结果被添加到帖子的后续部分中基于系统的结果的末尾。
**plt.scatter(CPU_Test_1[:,0], CPU_Test_1[:,1], s=1)plt.scatter(kmeans.cluster_centers_[:,0], kmeans.cluster_centers_[:,1], s=5, c="r")plt.title("K-means (Random) with Scikit Learn", "\n")plt.show()**
通过在我们的算法之外添加以下代码行，可以跟踪算法的执行时间。
**start_time = time.time()# ... *clustering* *code block* end_time = time.time()
print(end_time - start_time)**
1.1.使用 Scikit-Learn 的 k 均值(随机)聚类
sci kit Learn K-means—random算法以随机方式选择第一个中心聚类，与 k-means++算法相比，这可能会导致更高的聚类内方差。
第一个 CPU 驱动的系统结果:
**算法执行时间: 2505.26 秒
**聚类可视化:蓝点(数据点)，红点(聚类)
Scikit Learn，K-means(随机)聚类 100 个聚类(图片由作者提供)
第二次 CPU 供电系统结果:
**算法执行时间: 1395.10 秒
**聚类可视化:蓝点(数据点)，红点(聚类)
Scikit Learn，K-means(随机)聚类 100 个聚类(图片由作者提供)
1.2.使用 Scikit-Learn 的 K-means (kmeans++)聚类
**sci kit Learn K-means—K means++算法以更符合逻辑的方式选择第一个中心聚类，这可以导致之后更快的聚类性能。
第一次 CPU 供电系统结果:
**算法执行时间: 2603.74 秒
**聚类可视化:蓝点(数据点)，红点(聚类)
Scikit Learn，K-means (kmeans++)聚类 100 个聚类(图片由作者提供)
第二次 CPU 供电系统结果:
**算法执行时间: 1384.73 秒
**聚类可视化:蓝点(数据点)，红点(聚类)
Scikit Learn，K-means (kmeans++)聚类 100 个聚类(图片由作者提供)
2。基于 GPU 的集群
tensor flow库是为海量数值计算而开发的。根据您环境中安装的版本，它支持 CPU 和 GPU。如果您希望启用您的 GPU，需要安装的版本是tensor flow-GPU。
**pip install tensorflow-gpu**
为了能够通过使用 TensorFlow 库来测试 GPU 信息的可用性，可以使用下面的代码片段。
**import tensorflow as tfconfig = tf.compat.v1.ConfigProto()
tf.config.list_physical_devices('GPU')**
(图片由作者提供)
使用以下脚本查看 GPU 信息后，可以打印更详细的设备信息，包括 CPU。
**from tensorflow.python.client import device_lib as dev_libprint (dev_lib.list_local_devices())**
(图片由作者提供)
2.1.使用 TensorFlow-GPU 进行 KMeansTF (kmeans++)聚类
tensor flow k-means算法通过迭代优化类内方差，路由随机产生的初始质心的负面影响。
通过安装以下 kmeanstf 包，可以使用支持 GPU 的 Tensorflow k-means 算法。
**pip install kmeanstf**
在安装了所需的包之后，下面的算法将在基于 GPU 的环境中运行。结果添加在系统规格之后。
**from kmeanstf import KMeansTFstart_time = time.time()kmeanstf = KMeansTF(n_clusters=100, random_state=12345)
GPU_Test = np.random.normal(size=(500000,5))
kmeanstf.fit(GPU_Test)end_time = time.time()
print('Kmeans++ execution time in seconds: {}'.format(end_time - start_time))**
GPU 驱动的系统规格:
**算法执行时间: 219.18 秒
**聚类可视化:蓝点(数据点)，红点(聚类)
KMeansTF(kmeans++)100 个聚类的聚类(图片由作者提供)
2.2。 TunnelKMeansTF 使用 TensorFlow-GPU 进行聚类
隧道k-means算法具有在聚类之间实现非局部移位的能力，以为每个数据点找到最佳质心。
***start_time = time.time()kmeansTunnel = TunnelKMeansTF(n_clusters=100, random_state=12345)
GPU_Test = np.random.normal(size=(500000,5))
kmeansTunnel.fit(GPU_Test)end_time = time.time()
print('Tunnel Kmeans execution time in seconds: {}'.format(end_time - start_time))***
GPU 驱动的系统规格:
算法执行时间: 107.38 秒聚类可视化:蓝点(数据点)，红点(聚类)
100 个聚类的 TunnelKMeansTF 聚类(图片由作者提供)
3。最终比较矩阵
为了更清楚地理解算法的输出，生成了一个矩阵表。
系统特性与算法运行时间(图片由作者提供)
正如我们在比较矩阵中所观察到的，GPU 驱动的系统在执行时间方面具有独特的性能优势。
完整的实现代码和 Jupyter 笔记本在我的 GitHub 上都有。
非常感谢您的提问和评论！*
参考文献:
来自不同地点的新冠肺炎数据的比较:正常化-展示-编程
数据科学—新冠肺炎—可视化—编程
照片由 Thuy Chung Vuong 拍摄
有多少感染者还在我们附近的环境中，在我们国家，以及更远的邻国？
编者按: 走向数据科学 是一份以数据科学和机器学习研究为主的中型刊物。我们不是健康专家或流行病学家，本文的观点不应被解释为专业建议。想了解更多关于疫情冠状病毒的信息，可以点击 这里 。
新冠肺炎疫情看起来像一场世界大战，波及全球 213 个国家和地区[worldometer.info]，给世界带来死亡、疾病、恐惧、悲伤、灾难、混乱。每天都有大量的新冠肺炎数据流作为信息从与我们看不见的敌人——新型冠状病毒病毒斗争的前线流向我们。从这些数据中，我问了自己一个问题:
“有多少感染者还在我们附近的环境中，在我们的国家，以及更远的邻国？”
目前受感染患者的数量很重要；它有助于我们的生活、规划、工作和预防。出于这个动机，我将我的研究兴趣从数据的可视化，以及对未发现感染病例的估计，扩展到不同地点的活跃感染病例的比较。
在这篇文章中，我想和你分享我的方法“累积活跃案例的规范化”来分析来自多国的数据。
因为我的数据资源提供来自许多国家的数据，我可以在“高水平”上工作:比较来自世界各国的数据。然而，您也可以使用我的方法和我用 Python 编写的开源软件包来分析来自其他地理位置的数据。
我在这里展示了一些例子来展示我的开发方法。它们不是专业报告(如在、世卫组织、 CDC 、 RKI 中发现的)，但它可能有助于我们理解新冠肺炎·疫情在海量数据之外正在发生的事情。
比较哪些新冠肺炎数据很重要？
在我们进行数据的比较之前，我想先介绍一下不同类型的新冠肺炎数据。它们是:
- 每日确诊感染病例数，即“新病例数”。
- 目前被感染的病人数量，即“活跃病例”(这里是“T7”)
- 估计的活动案例数，包括未发现的案例，可以通过我的 Vuong 算法或其他算法进行估计。
- 康复/出院患者人数。
- 死亡案例。
- 等等。
这些数据将显示为以下图表:
每日数据
累积数字
日数 y(t)是离散值，所以函数 y(t)是一个“时间序列”。我在这里使用 y[x]而不是 y (t)，因此 x 是日期时间(参见 Python 文档:" DateTime 模块")。这使得以后的编程和绘图更加容易。
{y[x] / x =x0，x1，…，xn，…xN；xn 是日期时间}
**累计数 s[k]，**是 y{x]的 k 个数之和。
表 1 以 y[x]为例，每日新增病例数及其累计数
表 1:y[x]，s[k]的示例
累计活跃人数是当前感染患者的人数，重要信息，用于我们的计划、工作和预防感染。
这些数字很难找到，因为它们取决于许多参数:感染人数，由于无症状患者的问题，很难准确地检测到感染人数，康复病例和死亡病例，也很难准确地找到。但是我们可以通过多种方式获得累积的活动案例数:
- 这些数字直接来自专业机构的报告，如测试中心、医疗保健中心、疾病预防控制中心
- 可以使用 SIR 模型(例如，Brian Collins，新冠肺炎的动态建模)从感染病例中间接估计这些数字，或者使用我的模拟器和 Vuong 算法从每日确诊的新病例和死亡人数中估计感染病例。
如何比较不同国家的数据？
让我们来看看图 1 中的图表！
图 1:不同国家的活动累积案例图表。数据来源:【https://ourworldindata.org/coronavirus-source-data
它显示了来自不同国家的活动累积案例的图表。如果要把它们放在一起比较，有以下几个问题:
- 这看起来就像你在比较一头大象(世界数据)和一只熊(美国数据)或者一只兔子(德国数据)。这是比较的主要问题。
- 信号的振幅是未知的。2020 年 2 月 4 日，累计感染病例数增至 100 万，2020 年 4 月 15 日增至 200 万，2020 年 9 月 5 日增至 400 万，2020 年 6 月 15 日增至 800 万！
- 传染病例的产生是一个非线性系统。
- 每个县的 COVID 感染传播情况都不一样。
因此，我提出了一种对相关数据进行分析的方法:对累积的活动案例数据进行规范化。
对累积的活动案例数据进行规范化
该概念有以下步骤:
第一步:
每个国家的数据系列必须在同一时期，例如从 2020 年 1 月到 2020 年 6 月 30 日。
第二步:
对于每个国家，我们都会:
-我们存储累积数据字段 s[]。
我们搜索 s[k]的局部最大值 A
A = max (s[k]，k =0，…N)， N=域 s[k]的元素个数，range (s[])
-然后我们计算原始的标准化数据
sn[k] = s[k] /A
-我们可以使用原始计算 sn[k]，但我建议使用百分比计算 sp{n]，这样更容易理解。
sp[n] = 100 s[k] /A*
表 2 是一个示例，显示了对来自两个国家的 s[k]进行归一化的计算，因此来自 A 国的 S[k]的最大值为 10，来自 B 国的 S[k]的最大值为 500。
表 2:两个国家数据的计算
使用 covid 19-vuongsulator 进行数据分析
为了便于交流，我想打电话
“归一化活动案例数据图”到“归一化活动案例”，
“使用 Vuong 算法估计的活动案例的归一化数据的图表”到“归一化的 V-活动案例”,
为了解释标准化数据的图形，我使用多国模式(s .vuongsulator 命令)用 vuongsulator 生成了两个展示。
- 展示 1:来自一个国家的标准化活跃案例
- 展示 2:来自多国的标准化活跃案例:德国、意大利、瑞典、美国和世界。
展示 1:来自一个国家的标准化 V-active 案例
您可以从展示区 1“一个国家的标准化 V-活性病例”中了解以下信息(见图 2):
- 在 2004 年 4 月 1 日，活动案例相对于其最大值的百分比。
- 一个国家感染的爆发日期是图表达到最大值 100%的日期时间(见图 2)
- 在最近的日期和时间，你可以读到目前感染的病人的百分比，仍然存在于该国，14%。
图 2:展示案例 1:新冠肺炎数据分析【德】，数据来源:https://ourworldindata.org/coronavirus-source-data
**VuongSimulator comand for showcase 1:****./data/vmodel_testlist.csv
Germany** **$ python ./covid19-VuongSimulator.py -c ‘World’ -o test.png -n ./data/new_cases.csv -d ./data/new_deaths.csv -g 0.98 -r 14 -t 7 -s 76**
展示 2:来自多国(德国、意大利、瑞典、美国和世界)的标准化虚拟活动案例
您可以从展示区 2(图 3)获得以下信息:
- 不同国家的现行案例现已正常化。每个图在 100%时具有相同的最大值。
- 每个国家/地区的活动案例与其所在国家/地区的百分比最高为 100%。
- 我们可以在任何时间比较每个国家与其他国家的“地位”，当然只能用百分比来表示。
- 我们可以探索每个国家的突破日期，在那里图形达到最大值 100%。
- 我们可以发现减少的趋势，德国减少了 14%，意大利减少了 34%。百分比数字更容易理解为绝对值。
- 我们可以发现趋势待机，处于平台期，74%是美国。
- 我们可以发现瑞典突破的开始，因为图形在最近的日期时间达到了 100%的最大值。
- 我们看到世界图表在四月中旬有一个局部最大值，图表向上增加，在图表的最后一天达到 100%。我们可以期待下一个最大值，未来的第二波。
使用Vuong-Simulator，您可以根据您想要的国家列表比较不同国家的数据；有 212 个国家被感染来比较！(本文中的“安装和启动”)。
图 3:展示案例 2:新冠肺炎数据分析【多国】，数据来源:https://ourworldindata.org/coronavirus-source-data
**VuongSimulator comand for showcase 2:****./data/vmodel_testlist.csv
World,Germany,Italy,Sweden,United States****$ python ./covid19-VuongSimulator.py -c 'World' -o test.png -n ./data/new_cases.csv -d ./data/new_deaths.csv -g 0.98 -r 14 -t 7 -s 76**
多国标准化模式的 covid 19-vuongsulator
我已经在covid 19-vuongssimulator . py中实现了来自多国的归一化累积活动案例。模拟器只有命令行来减少对话框。项目的 wiki 中描述了命令参数。
VuongSimulator 需要一个国家列表来生成多图输出图表。这个列表是 CSV 文件。/data/vmodel_testlist.csv
默认设置:
**./data/vmodel_testlist.csv
World,Germany,France,Belgium,Sweden,United Kingdom,Russia,Brazil,United States**
要对其他国家的数据进行分析，您必须用普通的文本编辑器编辑国家列表
安装并启动
VuongSimulator 在我的帖子[ 1 、 2 ]和项目tavuong/covid 19-datakit的 wiki 中有详细的描述，所以我想在这里写一个简单的安装和快速的开始来制作我所做的 showcase，这可能会给你带来动力。
**$ github clone** [**https://github.com/tavuong/covid19-datakit.git**](https://github.com/tavuong/covid19-datakit.git)**$ pip install numpy****$ pip install Matplotlib****$ cd ~/covid19-datakit/****$ python ./covid19-VuongSimulator.py [by PC]****$ python3 ./covid19-VuongSimulator.py [by Raspberry PI]**
快速启动
为了在安装后快速启动，您可以使用下面的命令。它将显示一个橱窗，展示来自多国的标准化累积活动案例(图 4)。要制作另一个 showcase，您需要编辑 country-list 并重新启动命令。CSV 文件(。\data\new_cases 和。\data\new_deaths.csv)在文件夹里。\data ，从开源下载( 此处 )。
**VuongSimulator comand for Quick Start:****./data/vmodel_testlist.csv
World,Germany,France,Belgium,Sweden,United Kingdom,Russia,Brazil,United States****$ python ./covid19-VuongSimulator.py -c 'World' -o test.png -n ./data/new_cases.csv -d ./data/new_deaths.csv -g 0.98 -r 14 -t 7 -s 76**
图 4:快速入门:新冠肺炎数据分析【多国】，数据来源:https://ourworldindata.org/coronavirus-source-data
摘要
根据用于分析的 Vuong 算法的开发，以及对新冠肺炎数据的估计，我编写了具有多国新闻功能的软件包，从而开发了一种用于将累积的活跃感染病例的数据标准化的方法，人们可以比较来自不同地点的数据，并估计病毒的地理传播。如果我提出的方法能引起不同专业甚至专业机构用户的兴趣，那就太好了。
请不要犹豫，联系我咨询当前的开发，也许可以通过 Github 将您的模块贡献给我的开源和麻省理工学院许可的项目TAV uong/covid 19-datakit。
玩得开心！
综述鸣谢:简范博士教授
感谢支持和咖啡蛋糕的动力:我的妻子 Thi Chung Vuong
逻辑回归、决策树和随机森林模型预测中国红葡萄酒质量的比较
有监督机器学习模型预测红酒质量的比较
在接下来的项目中，我应用了三种不同的机器学习算法来预测葡萄酒的质量。我在项目中使用的数据集叫做 葡萄酒质量数据集 (具体来说就是“winequality-red.csv”文件)，取自 UCI 机器学习库。
该数据集包含 1，599 个观察值和 12 个与葡萄牙“Vinho Verde”葡萄酒的红色变体相关的属性。每行描述了一瓶葡萄酒的物理化学性质。前 11 个自变量显示了关于这些特征的数字信息，最后一个因变量根据感官数据以 0(质量差的葡萄酒)到 10(质量好的葡萄酒)的范围揭示了葡萄酒的质量。
由于结果变量是有序的，我选择了逻辑回归、决策树和随机森林分类算法来回答以下问题:
- 哪种机器学习算法能够根据葡萄酒的理化性质最准确地预测葡萄酒的质量？
- 红酒的哪些理化性质对其品质影响最大？
对于下面的项目，我使用 R 编程语言来探索、准备和建模数据。
导入数据集
一旦工作目录设置好，数据集下载到我们的计算机，我就导入数据。
#Importing the dataset
data <- read.csv('winequality-red.csv', sep = ';')
str(data)
srt()函数的结果
使用 str() 函数，我们可以看到所有的变量类型都是数字，这是正确的格式，除了结果变量。我继续将因变量转换成二元分类响应。
#Format outcome variable
data$quality <- ifelse(data$quality >= 7, 1, 0)
data$quality <- factor(data$quality, levels = c(0, 1))
我选择的修改结果变量水平的任意标准如下:
- 大于或等于 7 的值将被更改为 1，表示优质葡萄酒。
- 另一方面，小于 7 的数量将被转换为 0，表示质量差或一般。
此外，我将变量“quality”的类型修改为 *factor，*表示变量是分类的。
探索性数据分析
现在，我着手开发一个基于数据的 EDA，以找到基本的见解，并确定变量之间的特定关系。
首先，我开发了一个描述性分析，其中我通过使用 summary() 函数收集了数据的五个数摘要统计信息。
#Descriptive statistics
summary(data)
数据中每个变量的五位数汇总值
该图显示了数据中每个变量的五位数汇总值。换句话说，使用该函数，我获得了数值变量的最小值和最大值、第一个和第三个四分位数、平均值和中值。此外，摘要显示了因变量级别的频率。
接下来，我开发了一个单变量分析，包括分别检查每个变量。首先，我分析了因变量。
为了分析结果变量，我开发了一个柱状图来可视化分类水平的频率计数。此外，我生成了一个频率表，以了解每个类别中不同级别的确切数量和价值百分比。
#Univariate analysis
#Dependent variable
#Frequency plot
par(mfrow=c(1,1))
barplot(table(data[[12]]),
main = sprintf('Frequency plot of the variable: %s',
colnames(data[12])),
xlab = colnames(data[12]),
ylab = 'Frequency')#Check class BIAS
table(data$quality)
round(prop.table((table(data$quality))),2)
分析因变量的频率图
在分析该图时，我声明数据集有大量的 0 值，这表明数据中有更多的行表示葡萄酒质量差。换句话说，数据是有偏差的。
此外，通过分析这些表，我声明数据中有 1，382 行被认为是劣质酒，217 行被认为是优质酒。同样，数据集包含大约 86%的 0 结果值和 14%的 1 结果值。
从这个意义上说，有必要考虑数据集是有偏差的。这就是为什么在将数据分成训练集和测试集时，必须遵循分层抽样方法的原因。
现在，我开始分析独立变量。为了进行分析，我选择为每个变量创建箱线图和直方图。这些可视化将帮助我们识别五个数字汇总值的位置、它拥有的异常值以及变量遵循的分布。
#Independent variable
#Boxplots
par(mfrow=c(3,4))
for (i in 1:(length(data)-1)){
boxplot(x = data[i],
horizontal = TRUE,
main = sprintf('Boxplot of the variable: %s',
colnames(data[i])),
xlab = colnames(data[i]))
}#Histograms
par(mfrow=c(3,4))
for (i in 1:(length(data)-1)){
hist(x = data[[i]],
main = sprintf('Histogram of the variable: %s',
colnames(data[i])),
xlab = colnames(data[i]))
}
用于分析数字自变量的箱线图
正如我们所见，箱线图显示了每个变量的均值、中值和四分位数测量值的位置，以及每个变量的取值范围。
通过分析箱线图，我得出结论，所有的变量都有异常值。此外，变量“残余糖”和“氯化物”是具有最大量异常值的变量。正如我们所看到的，在平均值和中间值附近有一个集中值，这反映在一个非常小的四分位范围(IQR)。
当我继续评估异常值时，这些信息将在数据准备阶段派上用场。
直方图用于分析数字自变量
可视化直方图，我确定了每个变量的模式。正如我们所看到的，在大多数分布中有一个右偏度。然而，变量“密度”和“pH”显示它们遵循正态分布。此外，我可以提一下，变量“残余糖”和“氯化物”的值范围很广，大多数观察结果都集中在图表的左侧。这种现象表明变量有大量的异常值。
最后，我开发了一个双变量分析来理解变量之间的关系。
#Bivariate analysis
#Correlation matrix
library(ggcorrplot)
ggcorrplot(round(cor(data[-12]), 2),
type = "lower",
lab = TRUE,
title =
'Correlation matrix of the red wine quality dataset')
相关矩阵来分析数值变量之间的关系
在图像中，我们可以看到自变量之间的正负关系。如矩阵所示，在“固定酸度”变量和变量“柠檬酸”和“密度”之间存在 0.67 的正相关。换句话说，随着“固定酸度”变量的增加，“柠檬酸”也会增加。同样，同样的概念也适用于“游离二氧化硫”和“总二氧化硫”变量之间的关系。
此外，我可以声明变量“固定酸度”和“pH”具有负线性相关性-0.68。这种关系表明，当葡萄酒的固定酸度增加时，葡萄酒的 pH 值降低。这个假设是正确的，因为我们知道这样一个事实，当一种成分的 pH 值降低时，意味着该元素变酸了。
数据准备
一旦我完成了 EDA，我就开始准备数据来开发预测模型。在项目的这一步，我集中精力寻找丢失的数据并评估异常值。
#Missing values
sum(is.na(data))
数据中缺失值数量的结果
既然我已经确定数据集不包含任何缺失值，我将继续处理异常值。
首先，我确定了每个变量的异常值数量。为了完成这一步，我创建并应用了一个识别异常值的特定函数。然后，我生成了一个数据帧来存储信息。此外，我使用 for 循环来收集和存储信息。
#Outliers
#Identifing outliers
is_outlier <- function(x) {
return(x < quantile(x, 0.25) - 1.5 * IQR(x) |
x > quantile(x, 0.75) + 1.5 * IQR(x))
}outlier <- data.frame(variable = character(),
sum_outliers = integer(),
stringsAsFactors=FALSE)for (j in 1:(length(data)-1)){
variable <- colnames(data[j])
for (i in data[j]){
sum_outliers <- sum(is_outlier(i))
}
row <- data.frame(variable,sum_outliers)
outlier <- rbind(outlier, row)
}
离群数据框架
正如我们所看到的，数据中的所有变量都有异常值。为了评估这些值，我遵循了一个标准，该标准规定我将接受在数据集的所有观察中异常值少于 5%的变量。
有必要提及的是，我并没有放弃离群值，因为它们代表并携带了关于数据集的必要信息。删除异常值会使我们的模型结果产生重大偏差。
#Identifying the percentage of outliers
for (i in 1:nrow(outlier)){
if (outlier[i,2]/nrow(data) * 100 >= 5){
print(paste(outlier[i,1],
'=',
round(outlier[i,2]/nrow(data) * 100, digits = 2),
'%'))
}
}
异常值百分比等于或大于 5%的变量
通过上面显示的代码，我能够识别出变量“残余糖”和“氯化物”分别有大约 10%和 7%的异常值。
此外，我继续输入这些变量的异常值。我选择用变量的平均值来改变异常值，因为正如我们在直方图中看到的，两个变量在平均值以下都有很大的集中值。因此，通过输入平均值，不会对数据的本质产生重大影响。
#Inputting outlier values
for (i in 4:5){
for (j in 1:nrow(data)){
if (data[[j, i]] > as.numeric(quantile(data[[i]], 0.75) +
1.5 * IQR(data[[i]]))){
if (i == 4){
data[[j, i]] <- round(mean(data[[i]]), digits = 2)
} else{
data[[j, i]] <- round(mean(data[[i]]), digits = 3)
}
}
}
}
建模
现在，我正确地排列了数据集，我开始开发预测红酒质量的机器学习模型。第一步是将数据分为训练和测试。由于数据是不平衡的，我着手开发一个分层抽样。我使用了 80%的代表优质葡萄酒的观察值(“质量”变量的一个结果)来平衡训练集。换句话说，在训练集中，因变量将具有相同数量的观察值 0 和 1。
#Splitting the dataset into the Training set and Test set
#Stratified sample
data_ones <- data[which(data$quality == 1), ]
data_zeros <- data[which(data$quality == 0), ]#Train data
set.seed(123)
train_ones_rows <- sample(1:nrow(data_ones), 0.8*nrow(data_ones))
train_zeros_rows <- sample(1:nrow(data_zeros), 0.8*nrow(data_ones))
train_ones <- data_ones[train_ones_rows, ]
train_zeros <- data_zeros[train_zeros_rows, ]
train_set <- rbind(train_ones, train_zeros)table(train_set$quality)#Test Data
test_ones <- data_ones[-train_ones_rows, ]
test_zeros <- data_zeros[-train_zeros_rows, ]
test_set <- rbind(test_ones, test_zeros)table(test_set$quality)
训练和测试集的因变量表
正如我们在图中看到的，训练集包含的观察值比测试集少。然而，训练集将被平衡以有效地训练模型。
现在我已经完成了这一步，我继续开发模型，并确定哪个模型可以准确预测红酒的质量。
逻辑回归
#Logistic Regression
lr = glm(formula = quality ~.,
data = training_set,
family = binomial)#Predictions
prob_pred = predict(lr,
type = 'response',
newdata = test_set[-12])library(InformationValue)
optCutOff <- optimalCutoff(test_set$quality, prob_pred)[1]y_pred = ifelse(prob_pred > optCutOff, 1, 0)
一旦使用训练集创建了模型，我就开始使用测试集数据预测值。
由于逻辑回归将提供概率值，我继续计算最佳分界点，这将把结果值分类为 1 或 0。
然后，利用获得的预测值，我继续开发一个混淆矩阵，我们可以用逻辑回归模型的预测值来可视化测试集值。
#Making the confusion matrix
cm_lr = table(test_set[, 12], y_pred)
cm_lr#Accuracy
accuracy_lr = (cm_lr[1,1] + cm_lr[1,1])/
(cm_lr[1,1] + cm_lr[1,1] + cm_lr[2,1] + cm_lr[1,2])
accuracy_lr
逻辑回归的混淆矩阵
可视化该表时，我声明该模型准确预测了 1，208 个值，这意味着该模型对 45 个观察值进行了错误分类。此外，我得出结论，该模型的准确率为 96.41%。
#ROC curve
library(ROSE)
par(mfrow = c(1, 1))
roc.curve(test_set$quality, y_pred)
逻辑回归的 ROC 曲线
此外，我继续开发一个 ROC 曲线，以了解该模型区分结果类别的能力。最后我发现曲线下面积(AUC)是 51.1%。
决策图表
现在我按照和以前一样的步骤。一旦使用训练集创建了模型，我就开始使用测试集数据预测值。
#Decision Tree
library(rpart)
dt = rpart(formula = quality ~ .,
data = training_set,
method = 'class')#Predictions
y_pred = predict(dt,
type = 'class',
newdata = test_set[-12])
此外，我继续生成混淆矩阵，在这里我们可以看到测试集值和决策树模型的预测值。
#Making the confusion matrix
cm_dt = table(test_set[, 12], y_pred)
cm_dt#Accuracy
accuracy_dt = (cm_dt[1,1] + cm_dt[1,1])/
(cm_dt[1,1] + cm_dt[1,1] + cm_dt[2,1] + cm_dt[1,2])
accuracy_dt
决策树的混淆矩阵
可视化该表后，我声明该模型准确预测了 873 个观察值，表明该模型错误分类了 380 个值。此外，我发现该模型的准确率为 69.67%。
#ROC curve
library(ROSE)
roc.curve(test_set$quality, y_pred)
决策树的 ROC 曲线
然后，根据 ROC 曲线，我得到了曲线下面积(AUC ),其值为 81%。
随机森林
最后，我继续使用训练集创建随机森林模型，并使用测试集数据预测值。
#Random forest
library(randomForest)
rf = randomForest(x = training_set[-12],
y = training_set$quality,
ntree = 10)#Predictions
y_pred = predict(rf,
type = 'class',
newdata = test_set[-12])
现在，我通过创建一个混淆矩阵，用随机森林模型的预测值来可视化测试集值。
#Making the confusion matrix
cm_rf = table(test_set[, 12], y_pred)
cm_rf#Accuracy
accuracy_rf = (cm_rf[1,1] + cm_rf[1,1])/
(cm_rf[1,1] + cm_rf[1,1] + cm_rf[2,1] + cm_rf[1,2])
accuracy_rf
随机森林的混淆矩阵
通过评估该表，我证明了该模型准确预测了 991 个值，这意味着该模型错误分类了 262 个观察值。此外，还得出了该模型的准确率为 79.09%。
#ROC curve
library(ROSE)
roc.curve(test_set$quality, y_pred)
随机森林的 ROC 曲线
最后，通过 ROC 曲线，我获得了 83.7%的 AUC 值。
可变重要性
此外，我通过计算具有最高精确度的模型的变量重要性来回答项目的第二个问题。换句话说，我计算了逻辑回归模型的变量重要性。
#Variable importance
library(caret)
varImp(lr)
逻辑回归的可变重要性
通过分析结果，我宣布这个模型最重要的变量是“酒精”，其次是变量“硫酸盐”和“固定酸度”。
此外，我进行了一项调查，以了解这些成分对红酒质量的影响。我发现硫酸盐是葡萄酒中的一种成分，这种成分决定了饮料的新鲜度。从这个意义上来说，不含硫酸盐或含少量硫酸盐的葡萄酒通常保质期较短。换句话说，硫酸盐对葡萄酒的寿命有更多的控制，因为它有助于确保葡萄酒在打开时保持新鲜和干净。另一方面，酒精成分对葡萄酒的质量也起着重要的作用。酒精将有助于平衡葡萄酒的坚硬和酸的味道，使葡萄酒的坚硬和柔软的特性相互联系。
正如我们所分析的，逻辑回归模型解释了实际的理论事实。关于优质葡萄酒的基本成分的调查包括了模型中必要的变量。出于这个原因，变量“酒精”和“硫酸盐”对模型非常重要，因为这些元素将是指示葡萄酒质量好坏的重要组成部分。
结论
在获得不同机器学习算法的结果后，我声明逻辑回归模型在预测红酒质量方面显示出更高的准确性。该模型的准确率为 96.41%，能够正确预测 1209 个值，这意味着该模型的误分类误差为 3.59%。
另一方面，通过分析 ROC 曲线，我声明模型表现不如预期。通过评估曲线下面积(AUC = 51.1%)，我将 ROC 曲线标记为失败曲线。换句话说，该模型不能识别不同的类别，这表明该模型具有低性能。出于这个原因，我得出结论，即使该模型在预测测试集值方面有很好的准确性，但它在快速识别真正的正值方面的速度很慢。
此外，通过分析其他 ROC 曲线，我发现随机森林确实具有最佳性能，获得了 83.7%的曲线下面积。这意味着尽管随机森林模型在三个模型中没有显示出最高的准确性，但它通过比逻辑回归更好地检测因变量的不同类别而具有最佳性能。
此外，通过逻辑回归模型，我进一步确定了哪些理化性质对红酒的质量影响最大。我发现“酒精”、“硫酸盐”和“固定酸度”是模型中影响最大的变量。就此而言，如果这些变量之一发生变化，模型的结果将受到强烈影响。
使用 Python 进行数据采集和分析
使用数据收集的竞争性定价
数据 抓取是一种从互联网上检索大量数据的技术。这个技巧在竞争 定价中非常有用。为了确定我们产品的最佳价格，我们可以比较市场上的类似产品。这些价格变化很大。因此，在这篇博客中，我将展示我们如何丢弃关于特定产品的数据。
最常见的数据抓取技术是使用 BeautifulSoup 。它提取页面的 html 并将其存储为非结构化数据。我们必须把它转换成结构化的格式。
让我们导入我们将需要的所有必要的库:
import requests
from fake_useragent import UserAgent
import pandas as pd
import bs4
我们提取的数据是非结构化数据。所以我们将创建空列表，以结构化的形式存储它们，
products=[] #List to store name of the product
prices=[] #List to store price of the product
ratings=[] #List to store rating of the product
specifications = [] #List to store specifications of the product
df=pd.DataFrame()
创建用户代理。参考此链接https://pypi.org/project/fake-useragent/
user_agent = UserAgent()
将产品名称作为输入。提取的数据将与该产品相关。
product_name = input("Product Name- ")
为了从产品列表的多个页面中提取数据，我们将使用一个 for 循环。该范围将指定要提取的页数。
for i in range(1,11):
url = "[https://www.flipkart.com/search?q={0}&page={1](https://www.flipkart.com/search?q={0}&page={1)}" url = url.format(product_name,i) ## getting the reponse from the page using get method of requests module
page = requests.get(url, headers={"user-agent": user_agent.chrome}) ## storing the content of the page in a variable
html = page.content ## creating BeautifulSoup object
page_soup = bs4.BeautifulSoup(html, "html.parser") for containers in page_soup.findAll('div',{'class':'_3liAhj'}):
name=containers.find('a', attrs={'class':'_2cLu-l'})
price=containers.find('div', attrs={'class':'_1vC4OE'})
rating=containers.find('div', attrs={'class':'hGSR34'})
specification = containers.find('div', attrs {'class':'_1rcHFq'})
products.append(name.text)
prices.append(price.text)
specifications.append(specification.text) if type(specification) == bs4.element.Tag else specifications.append('NaN')
ratings.append(rating.text) if type(rating) == bs4.element.Tag else ratings.append('NaN')
df = pd.DataFrame({'Product Name':products,'Price':prices, 'specification':specifications, 'Rating':ratings})
为了从 soup 中提取数据，您需要指定要从中检索数据的 html 标签。你可以在网页上使用 inspect 元素。
上述代码将以结构化格式存储数据。当您打印 df 时，您将获得:
df.head()
清理数据
因为所有的产品都是一样的，我们可以把它们写成“瓶子”。
df['Product Name'] = 'bottle'
df.head()
同样，我们可以找到不同产品的数据。
现在，我们将从 Price 中删除符号，并清理 specification 列。
df[‘Price’] = df[‘Price’].str.lstrip(‘₹’)
df[‘Price’] = df[‘Price’].replace({‘,’:’’}, regex=True)
df.head()
df[‘Pack’], df[‘color’] = df[‘specification’].str.split(‘,’, 1).str
del df[‘specification’]
df.head()
我们得到的数据的一些基本分析
绘制箱线图
import numpy as np
import seaborn as sns
df[‘Price’] = df[‘Price’].astype(np.float)
sns.boxplot(x=df[‘Price’])
正如我们所看到的，在价格范围非常高的地方有一些异常值。
绘制条形图
sns.barplot(x=df[‘Price’], y=df[‘color’])
我们可以观察到某种颜色的价格是如何变化的。多种颜色的行是成包的，如 4 个一包或 6 个一包等。
df[‘Rating’] = df[‘Rating’].astype(np.float)
sns.barplot(x=df[‘Rating’], y=df[‘color’])
我们还可以观察到，颜色对产品的评级几乎没有影响。
sns.barplot(x=df[‘Rating’], y=df[‘Price’])
sns.lineplot(x=df[‘Rating’], y=df[‘Price’])
从这里我们可以得出结论，价格较低的产品在某种程度上有较高的收视率。
谢谢大家，我希望你们对我们如何使用数据收集来获得有竞争力的价格有所了解。除了博客中提到的，你还可以尝试不同的 EDA 技术。
所有高效网络模型的完整架构细节
让我们深入探究所有不同高效网络模型的架构细节，并找出它们之间的不同之处。
乔尔·菲利普在 Unsplash 上的照片
我在一次 Kaggle 竞赛中翻阅笔记本，发现几乎每个人都在使用 EfficientNet 作为他们的主干网，这是我之前从未听说过的。它是由谷歌人工智能在这篇论文中介绍的，他们试图提出一种如其名称所示更有效的方法，同时改善艺术效果的状态。一般来说，模型做得太宽、太深，或者分辨率太高。增加这些特征最初有助于模型，但是它很快饱和，并且所制作的模型只是具有更多的参数，因此效率不高。在 EfficientNet 中，它们以更有原则的方式进行扩展，即逐渐增加所有内容。
模型缩放。(a)是一个基线网络示例；(b)-(d)是仅增加网络宽度、深度或分辨率的一个维度的传统缩放。(e)是我们提出的复合缩放方法，它以固定的比例统一缩放所有三个维度。
不明白发生了什么？别担心，一旦你看到这个建筑，你就会明白的。但首先，让我们看看他们用这个得到的结果。
由于参数数量少得多，模型系列是有效的，并且还提供了更好的结果。现在我们已经看到了为什么这些可能成为标准的预训练模型，但是缺少了一些东西。我记得莱米·卡里姆的一篇文章，他展示了预训练模型的架构，这对我理解它们和创建类似的架构帮助很大。
普通卷积神经网络的编译可视化
towardsdatascience.com](/illustrated-10-cnn-architectures-95d78ace614d)
由于我在网上找不到这样的一个，我决定理解它并为你们所有人创建一个。
共有的事物
首先，任何网络都是它的主干，然后开始所有的架构实验，这在所有八个模型和最终层中都很常见。
此后，它们中的每一个都包含 7 个块。这些模块还包含不同数量的子模块，随着我们从效率 0 提高到效率 7，子模块的数量也会增加。要查看 Colab 中模型的层，请编写以下代码:
!pip install tf-nightly-gpuimport tensorflow as tfIMG_SHAPE = (224, 224, 3)
model0 = tf.keras.applications.EfficientNetB0(input_shape=IMG_SHAPE, include_top=False, weights="imagenet")tf.keras.utils.plot_model(model0) # to draw and visualize
model0.summary() # to see the list of layers and parameters
如果你计算一下 EfficientNet-B0 中的总层数，总数是 237，而在 EfficientNet-B7 中，总数是 813！！但是不要担心，所有这些层都可以由下面显示的 5 个模块和上面的茎制成。
我们将使用 5 个模块来构建架构。
- 模块 1 —用作子模块的起点。
- 模块 2 —该模块用作除第一个模块之外的所有 7 个主模块的第一个子模块的起点。
- 模块 3 —该模块作为跳接连接至所有子模块。
- 模块 4 —用于组合第一个子块中的跳跃连接。
- 模块 5 —每个子模块以跳接方式连接到其前一个子模块，并使用该模块进行组合。
这些模块被进一步组合以形成子块，这些子块将以某种方式在块中使用。
- 子块 1 —仅用作第一个块中的第一个子块。
- 子块 2 —它被用作所有其它块中的第一个子块。
- 子块 3 —用于所有块中除第一个以外的任何子块。
到目前为止，我们已经指定了将被组合以创建高效网络模型的所有内容，所以让我们开始吧。
EfficientNet-B0
高效网络架构-B0。(x2 表示括号内的模块重复两次)
效率网络-B1
高效网络架构-B1
B2 效率网
其架构与上述模型相同，它们之间的唯一区别是特征图(通道)的数量不同，这增加了参数的数量。
B3 效率网
高效网络架构-B3
高效网络-B4
高效网络架构-B4
高效网络-B5
高效网络 B5 的架构
B6 效率网
B6 高效网络的架构
B7 效率网
B7 高效网络的架构
很容易看出所有模型之间的差异，他们逐渐增加了子块的数量。如果你理解这些架构，我会鼓励你选择任何一个模型，打印出它的概要，并浏览一遍以更彻底地了解它。下表显示了卷积运算的内核大小以及 EfficientNet-B0 中的分辨率、通道和层。
此表包含在原始文件中。这个决议对整个家庭来说是一样的。我不知道内核大小是变化还是保持不变，所以如果有人知道，请回复。层数已经在上面的图中示出。频道数量各不相同，它是根据从每个型号的摘要中看到的信息计算出来的，如下所示()如果您使用的是移动设备，则需要在横向模式下查看。)
╔═══════╦══════╦══════╦══════╦══════╦══════╦══════╦══════╗
║ Stage ║ B1 ║ B2 ║ B3 ║ B4 ║ B5 ║ B6 ║ B7 ║
╠═══════╬══════╬══════╬══════╬══════╬══════╬══════╬══════╣
║ 1 ║ 32 ║ 32 ║ 40 ║ 48 ║ 48 ║ 56 ║ 64 ║
║ 2 ║ 16 ║ 16 ║ 24 ║ 24 ║ 24 ║ 32 ║ 32 ║
║ 3 ║ 24 ║ 24 ║ 32 ║ 32 ║ 40 ║ 40 ║ 48 ║
║ 4 ║ 40 ║ 48 ║ 48 ║ 56 ║ 64 ║ 72 ║ 80 ║
║ 5 ║ 80 ║ 88 ║ 96 ║ 112 ║ 128 ║ 144 ║ 160 ║
║ 6 ║ 112 ║ 120 ║ 136 ║ 160 ║ 176 ║ 200 ║ 224 ║
║ 7 ║ 192 ║ 208 ║ 232 ║ 272 ║ 304 ║ 344 ║ 384 ║
║ 8 ║ 320 ║ 352 ║ 384 ║ 448 ║ 512 ║ 576 ║ 640 ║
║ 9 ║ 1280 ║ 1408 ║ 1536 ║ 1792 ║ 2048 ║ 2304 ║ 2560 ║
╚═══════╩══════╩══════╩══════╩══════╩══════╩══════╩══════╝
Medium 没有任何制作表格的格式，所以如果你想创建如上的表格，你可以从这个站点创建 ASCII 表格。
在结束之前，我再次附上了其研究论文中的另一张图片，该图片显示了其相对于其他先进技术的性能，并且还减少了所需的参数数量和触发器数量。
如果您想创建像这样的高级 CNN 架构，或者在理解所使用的任何层或术语方面有问题，请不要担心，我已经写了一篇文章来解决这些问题。
使用复杂的架构生成更深层次的模型，并了解不同的层，从而使模型更好。
towardsdatascience.com](/beyond-the-standard-cnn-in-tensorflow-2-a7562d25ca2d)
你想看看 EfficientNet 如何在 Kaggle 挑战赛上与模特们一较高下吗，你可以看看这篇文章。
[## EfficientNet 应该是 goto 预训练模型或…
比较不同预训练模型的时间和准确性，并最终创建一个集成来提高结果。
towardsdatascience.com](/efficientnet-should-be-the-goto-pre-trained-model-or-38f719cbfe60)
扫一扫
724
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
