Group2Vec 用于高级分类编码
创建高基数类别的有价值的表示
对分类变量进行编码是每个机器学习项目中必需的预处理步骤。选择正确的编码技术是一项严肃而重要的任务。有许多选择:从经典的一键或整数映射到巧妙的目标编码或散列函数，最后得到更复杂的向量表示。
固定的收据是不存在的，采用一种技术而不是另一种技术是基于我们可以处理的数据类型和我们的分析范围。例如，one-hot 保持了类别的对称性，但是它很消耗内存。整数映射更简单，但是在类之间创建了无意义的关系。目标编码与目标直接相关，但如果应用不当，往往会过度拟合。嵌入表示是一种新趋势，包括分配一个神经网络来产生类别的感知向量表示。
在这篇文章中，我处理了一个点击欺诈识别的问题。我们的分析领域是移动设备，只有分类变量可供我们使用。我们的范围是从这个数据结构中提取值，引入一些用于分类编码的高级矢量化技术。共有三种不同的方法:前两种通过组计数和其他变换，应用手动创建矢量特征来管理数据；最新的是一个纯粹的神经网络结构，用于创建类别的深度表示，以某种方式，它倾向于从’组 ’ (因此得名 Group2Vec)中提取值。
数据
通话数据和跟踪欺诈检测是卡格尔为通话数据*主办的挑战，该平台是中国最大的独立大数据服务平台，覆盖全国 70%以上的移动设备。他们每天处理 30 亿次点击，其中 90%是潜在的欺诈。他们目前为应用程序开发人员防止点击欺诈的方法是，测量用户在他们的文件夹中点击的行程，并标记产生大量点击但从未安装应用程序的 IP 地址。利用这些信息，他们建立了一个 IP 黑名单和设备黑名单。*他们需要构建一个算法，来预测用户点击移动应用广告后是否会下载应用。为此，他们提供了一个丰富的数据集，在 4 天内覆盖了大约 2 亿次点击！
可用信息以点击记录的形式存在，具有以下结构: ip、app、device、os、channel、点击时间、归属时间，是归属(我们的目标)。阅读和使用所有怪物数量的数据是出于我们的目的。我们提取了 3 个时间样本:第一个(200.000 次点击)用于 train，另两个(每次 50.000 次点击)用于验证和测试；我们还提供了验证和测试之间的时间下降，以提高结果的可靠性。
列车集中时间函数的标签分布
我们掌握的有价值的变量是 ip、应用、设备、操作系统、渠道；均为分类式。每个特性的大量类是我们想要评估的一个积极方面。从这个意义上说，经典的编码方法并没有发挥出最好的效果，我们需要更多，因此，我们建立了一些特殊而有趣的方法。分组和计数是开发我们先进编码技术的两个神奇元素，它们是从我们手工特征工程过程的第一步开始引入的。最后，我们尝试在不需要人工工程的情况下，创建一个足够聪明的神经网络结构，以产生有价值且可比的结果，但让我们按顺序进行！
组计数+截断的 SVD
我们介绍的第一种技术利用了截断奇异值分解(LSA)，LDA 或类似的方法也是很好的选择。如前所述，我们的范围是对我们的分类列进行编码，生成其中每个类的向量表示。这里是模式化的过程:
- 分组依据各分类变量训练(分组依据);
- 对于每一个剩余的分类变量( passive_key )，我们按组计算可用类的连接，就像它们是字符串一样。每对 group_key — passive_key 是一串来自 passive_key 域的类；
- 用 CountVectorizer 将字符串检索为数字编码；
- 然后用截断的 SVD 来减少所得到的稀疏矩阵。
这样，我们获得了每个分类变量的每个类别的向量表示，作为截断 SVD 向量的串联。向量的长度取决于归约分量的数量和串联的数量，由所有可能的组合(n_compn_cat(n_cat-1))导出。在我们的例子中，3 是简化组件的数量，每个变量中的每个类是一个长度为 60(3 * 5 * 5(5–1))的向量。为了澄清，没有出现在 trainset 或 NaN 中的类别类在早期被编码为 0。
所创建的特征对于每一种进一步的任务都是有用的。我们用它们来构建欺诈性点击预测的模型。使用一个简单的 RandomForest，在验证上进行调整，我们在看不见的测试数据上达到 0.908 AUC。
数据特性方面的 TNSE(左起:app、ip、渠道)
组计数+熵
如上所述，第二种技术采用人工分组的方式将原始范畴转换成数字。这里是图解程序:
- groupby 按每个分类变量训练(group _ key)；
- 依次对每个剩余的分类变量( passive_key )，计算未堆叠计数矩阵。其中在第一维上我们有 group_key 类，而在第二维上我们有 passive_key 类。交集是分组计数频率；
- 对行应用熵来总结计数事件。
通过这种方式，我们获得了作为熵值串联的每个分类变量的每个类别的向量表示。因为熵是单个标量值，所以向量表示的长度取决于由所有可能的适用组合(n_cat*(n_cat-1))导出的串联的数量。在我们的例子中是 20(5 * 5(5–1))。
如下所示，我们使用生成的特征集来输入机器学习模型，该模型预测哪些点击是欺诈性的。使用一个简单的 RandomForest，在验证上进行调整，我们在看不见的测试数据上达到了 0.896 的 AUC。
验证数据方面的 TNSE(左起:应用、ip、渠道)
Group2Vec
在本节中，我们将介绍一种自动技术，它试图为我们制作所有以前的手工特征工程。由于神经网络和深度学习的力量，这种神奇是可能的。这个任务的架构被称为 Group2Vec(在示意图可视化下方)。
Group2Vec 架构
它接收表格分类特征作为输入，并试图以监督的方式学习它们的有价值的嵌入表示。这个问题对于神经网络来说并不新鲜:最简单的模型学习分类数据的嵌入表示，训练嵌入层，最后，在输出之前连接所有的分类数据。我们的策略既简单又有效:
- 为每个分类输入初始化嵌入层；
- 对于每个类别，在其他嵌入表示中计算点积。这些是我们在分类层次上的’组；
- 汇总各’*‘组’*采用平均汇集；
- 串接’*‘组’*平均值；
- 应用正规化技术，如批处理正规化或退出；
- 输出概率。
在我们的特定任务上训练的组 2Vec 在测试数据上实现了 0.937 的 AUC。
验证数据方面的 TNSE(左起:应用、ip、渠道)
摘要
在这篇文章中，我介绍了一些分类编码的高级技术。它们不同于随处可得的标准方法，如果在分类任务中采用，同时显示出巨大的预测能力。在具有大量类别的分类特征的情况下，它们的有用性是明显的，同时避免了维度和代表性问题。
保持联系: Linkedin
如何使用 SQL 对数据进行分组和聚合
在保持社交距离的同时学习数据科学
使用 Spice Girls 示例说明如何使用 SQL 关键字 GROUP BY、MIN、MAX、COUNT、AVG 和 SUM 对数据进行分组和聚合
由 Kiana Bosman 在 Unsplash 上拍摄的照片
介绍
我非常喜欢和我的朋友一起分享我对数据科学的热爱。我们正在努力学习 SQL，已经学了三课了。如果你想从头开始，这里有一个第一课的链接。所有的课程也可以在这里找到。否则，请继续学习关于使用 SQL 对数据进行分组和聚合的课程。
前一课
上周，我们讨论了使用 SQL 过滤数据。使用我最喜欢的一个节目，比如数据，我们在查询中使用 WHERE 子句。此外，我们还探讨了关键字 In、AND、OR、LIKE、BETWEEN 和 NOT 的用法。
这一课
现在我们知道了如何过滤数据，我们将转向聚合。我们将学习如何使用关键字 MIN 和 MAX 来分别查找数据的最小值和最大值。我们还将以类似的方式练习使用计数、AVG 和求和关键字。
这也将是我们遇到空值的第一课。所以我们将学习如何在我们的数据集中处理它们。
碰巧的是，我教数据科学的所有朋友都是女性。因此，在这节课中，还有什么比辣妹组合更好的例子来庆祝一点女孩的力量呢？我们将使用辣妹第一张专辑《辣妹》的数据。这是我成长过程中在我家经常看到的。
主要学习内容:
- 使用关键字 MIN 查找列中的最小值
- 使用关键字 MAX 查找列中的最大值
- 使用关键字 COUNT 计算列或表格中的行数
- 使用关键字 AVG 查找数字列的平均值
- 当所有值相加在一起时，使用关键字 SUM 来查找数字列的总计
- 使用关键字 GROUP BY 按表中的列进行分组
- 了解如何在上述方法中处理空值
- 了解别名的工作原理以及如何使用 AS 关键字来创建它们
问题是
我认为辣妹的第一张专辑是最好的一张。以防别人不信，我想找点数据来佐证。用澳大利亚的排行榜数据来分析辣妹每张专辑的单曲，我想我可以证明第一条规则！
数据
该数据集包含辣妹组合发行的每张专辑中所有曲目的信息。这个表格包含了每首歌的长度，每首单曲发行的时间，这首歌在澳大利亚排行榜上的最高位置，以及这首歌在澳大利亚排行榜上的第几周。我没有包括最受欢迎的专辑，因为我认为这会混淆视听。
我从辣妹组合唱片维基百科页面、辣妹(专辑)维基百科页面、辣妹世界(专辑)维基百科页面、永远(辣妹专辑)和一个澳大利亚排行榜网站上获得了这张表的数据。
聚合数据的语法
在这一课中，我将教你如何在 SELECT 语句中使用聚合关键字 MIN、MAX、COUNT、SUM 和 AVG。这些聚合器也可以用在查询中的其他地方。例如，它们可以用在 HAVING 子句中，但这超出了本课的范围。我写了另一个故事来比较 SQL 中的 WHERE 和 HAVING，以防你想了解更多。
MAX 关键字可用于查找列中的最大值。它可以用于许多不同的数据类型，包括整数、浮点数、字符串和日期。
正如您在下面看到的，使用 MAX 的语法包括将 MAX 关键字放在 select 语句中。MAX 关键字后面有一组方括号，您可以在其中放置要查找其最大值的列名。
SELECT
MAX(name_column_one) AS 'largest_col_one'
FROM
name_of_table
;
可以与聚合器结合使用的另一个有用的关键字是 AS。AS 用于为聚合器在返回的表中创建的列创建别名或临时名称。因为聚合器已经用在列 1 上，所以给结果起一个新的名字是很有用的，这样它在结果表中很容易识别。关键字 AS 也可以用来给一个表起一个别名，但是我们将在关于连接表的课程中讨论这个问题。
MIN 关键字的用法与 MAX 关键字非常相似。如您所料，它用于返回所选列的最小值。
SELECT
MIN(name_column_two) AS 'smallest_col_two'
FROM
name_of_table
;
COUNT 是一个关键字，用于计算所选列中的行数。所以在下面的例子中，它会计算表中的总行数。
SELECT
COUNT(name_column_three) AS 'col_three_counts'
FROM
name_of_table
;
但是，当对表应用了一些过滤器或分组时，COUNT 更有用。在这种情况下，您将计算表中满足筛选或分组条件的行数。
SELECT
COUNT(name_column_three) AS 'col_three_counts'
FROM
name_of_table
WHERE
name_column_one = value
;
与 MIN、MAX 和 COUNT 不同，关键字 SUM 和 AVG 只能用于包含数字数据类型(如整数或浮点数)的列。AVG 用于返回列的平均值。
SELECT
AVG(name_column_four) AS 'mean_col_four'
FROM
name_of_table
;
SUM 将数字列中的值相加。使用 SUM 的语法与其他聚合器相同。
SELECT
SUM(name_column_five) AS 'summed_col_five'
FROM
name_of_table
;
对数据分组的语法
分组对于汇总具有重复值的数据非常有用。它通常与聚合器 MIN、MAX、COUNT、SUM 和 AVG 一起使用。GROUP BY 将应用它的列中的相同值收集在一起。然后可以基于这些分组在另一列上使用聚合器。GROUP BY 子句通常用于包含类别值的列。
例如，如果将 AVG 聚合器与 GROUP BY 一起使用，则可以找到一列中每组值在另一列中的平均值。这个例子的语法如下所示。在这种情况下，返回的表将包含第一列中第二列中每个值的平均值。
SELECT
AVG(name_column_one) AS mean_col_one, name_column_two
FROM
name_of_table
GROUP BY
name_column_two
;
空值会发生什么？
当字段中没有输入值时，就会出现空值。所以它就像一个占位符，让你知道表中有一个空的位置。它不同于 0 值或空字符串“”，因为它们仍然是值。NULL 有自己的关键字。
可以使用 IS NULL 关键字检查列中的空值。这是在 WHERE 语句中完成的，将只返回在 WHERE 语句中指定的列中包含 NULL 值的记录。
SELECT
*
FROM
name_of_table
WHERE
name_column_one IS NULL
;
但是，更常见的情况是您希望排除所有包含空值的记录。在这种情况下，您可以在查询中添加 NOT 关键字。在下面的示例中，只有第二列中没有空值的记录才会包含在返回的表中。
SELECT
*
FROM
name_of_table
WHERE
name_column_two IS NOT NULL
;
聚合关键字 MIN、MAX、AVG、SUM 和 COUNT 会忽略空值。对于最小值和最大值，这是相当简单的，您将在忽略所有空值的列中获得最小值或最大值。类似地，对于 SUM，列中所有不为空的值将被加在一起。对于 AVG，当所有空值都被删除时，您将获得列的平均值。
COUNT 只是稍微复杂一点，除了包含空值的行之外，所选列中的所有行将被计数。该规则的唯一例外如下所示。在这种情况下，无论是否有空值，都将计算表中的所有行。
SELECT
COUNT(*)
FROM
name_of_table
;
与聚合器不同，GROUP BY 不忽略空值。相反，它们被组合在一起作为单个分组类别。
现在让我们试着解决我们的问题
- 去http://sqlfiddle.com/(或者你可以用https://www.db-fiddle.com/，因为我发现 SQL fiddle 最近停机了一段时间)
- 在左边的框中放入创建表并插入到下面的查询中
CREATE TABLE spice_girls(
album varchar(255),
title varchar(255),
length TIME(0),
track_number int,
single_released date,
peak_chart_position_au int,
chart_weeks_au int);INSERT INTO spice_girls(
album,
title,
length,
track_number,
single_released,
peak_chart_position_au,
chart_weeks_au
)
VALUES
("Spice", "Wannabe", '000:02:53', 1, '1996-07-08', 1, 29),
("Spice", "Say You'll Be There", '000:03:55', 2, '1996-10-10', 12, 22),
("Spice", "2 Become 1", '000:04:01', 3, '1996-12-16', 2, 18),
("Spice", "Love Thing", '000:03:38', 4, NULL, NULL, NULL),
("Spice", "Last Time Lover", '000:04:11', 5, NULL, NULL, NULL),
("Spice", "Mama", '000:05:04', 6, '1997-02-27', 13, 14),
("Spice", "Who Do You Think You Are", '000:04:00', 7, '1997-02-27', 13, 14),
("Spice", "Something Kinda Funny", '000:04:05', 8, NULL, NULL, NULL),
("Spice", "Naked", '000:04:25', 9, NULL, NULL, NULL),
("Spice", "If U Can't Dance", '000:03:48', 10, NULL, NULL, NULL),
("Spice World", "Spice Up Your Life", '000:02:53', 1, '1997-10-06', 8, 20),
("Spice World", "Stop", '000:03:24', 2, '1997-01-01', 5, 21),
("Spice World", "Too Much", '000:04:31', 3, '1997-12-08', 9, 15),
("Spice World", "Saturday Night Divas", '000:04:25', 4, NULL, NULL, NULL),
("Spice World", "Never Give Up on the Good Times", '000:04:30', 5, NULL, NULL, NULL),
("Spice World", "Move Over", '000:02:46', 6, NULL, NULL, NULL),
("Spice World", "Do It", '000:04:04', 7, NULL, NULL, NULL),
("Spice World", "Denying", '000:03:46', 8, NULL, NULL, NULL),
("Spice World", "Viva Forever", '000:05:09', 9, '1998-07-20', 2, 21),
("Spice World", "The Lady Is a Vamp", '000:03:09', 10, NULL, NULL, NULL),
("Forever", "Holler", '000:04:15', 1, '2000-10-23', 2, 15),
("Forever", "Tell Me Why", '000:04:13', 2, NULL, NULL, NULL),
("Forever", "Let Love Lead the Way", '000:04:57', 3, '2000-10-23', 2, NULL),
("Forever", "Right Back at Ya", '000:04:09', 4, NULL, NULL, NULL),
("Forever", "Get Down with Me", '000:03:45', 5, NULL, NULL, NULL),
("Forever", "Wasting My Time", '000:04:13', 6, NULL, NULL, NULL),
("Forever", "Weekend Love", '000:04:04', 7, NULL, NULL, NULL),
("Forever", "Time Goes By", '000:04:51', 8, NULL, NULL, NULL),
("Forever", "If You Wanna Have Some Fun", '000:05:25', 9, NULL, NULL, NULL),
("Forever", "Oxygen", '000:04:55', 10, NULL, NULL, NULL),
("Forever", "Goodbye", '000:04:35', 11, '1998-12-07', 3, 16)
;
**关于特殊字符的注意事项:**在创建这个表格的过程中，我们遇到了一个新的语法上的细微差别，这是我们在前面的课程中没有看到的。一些歌曲名称包含撇号。因此，如果我们像往常一样用单引号’'将歌曲名称字符串括起来，就会出现错误。这是因为撇号会被程序误认为是结束引用。因此，要在我们的表中包含一个包含撇号的字符串，我们需要在字符串周围使用双引号。
如果需要一个包含双引号的字符串，也可以反过来。如果你想了解更多关于引号这样的特殊字符，这是一个很好的资源。
**关于时间数据类型的注意事项:**这个表中还有一个数据类型，我们在前面的任何课程中都没有见过。它是时间数据类型。时间的格式为“小时:分钟:秒”。
3.单击“构建模式”按钮
4.在右边的框中输入您的问题
5.运行下面的查询，看看它是否会返回您所期望的结果:
SELECT
SUM(length) AS 'total_length'
FROM
spice_girls
;
6.运行下面的查询，看看它是否会返回您所期望的结果:
SELECT
SUM(length) AS 'album_length',
album
FROM
spice_girls
GROUP BY
album
;
7.运行下面的查询，看看它是否会返回您所期望的结果:
SELECT
album,
SUM(length) AS 'album_length',
AVG(length) AS 'average_song_length',
COUNT(length) AS 'number_of_songs',
MIN(length) AS 'shortest_song_length',
MAX(length) AS 'longest_song_length'
FROM
spice_girls
GROUP BY
album
ORDER BY
album
;
练习 1: 写一个查询，显示哪张专辑是最好的，如果我们把最好的专辑定义为其中一张单曲的最高峰值排行榜位置。
练习 2: 如果我们将最佳专辑定义为专辑中所有单曲的平均峰值排行榜位置最高的专辑，编写一个查询来显示哪张专辑是最佳专辑。
练习 3: 写一个查询，显示哪张专辑是最好的，如果我们把最好的专辑定义为在澳洲排行榜上至少 5 周单曲数最高的那张专辑。
学习回顾
学完本课后，你应该知道:
- 如何使用关键字 MIN 查找列中的最小值
- 如何使用关键字 MAX 查找列中的最大值
- 如何使用关键字 COUNT 计算列或表格中的行数
- 如何使用关键字 AVG 来寻找一个数字列的平均值
- 当所有值相加时，如何使用关键字 SUM 来计算数字列的总和
- 如何使用关键字 GROUP BY 按表中的列进行分组
- 了解如何处理空值
- 能够使用上述一种或多种方法编写自己的查询
- 能够使用 AS 关键字为聚合列创建别名
下一课
下周将是我们最后一堂 SQL 课。我们将学习如何将表连接在一起。我们可以使用 UNION、UNION ALL 和 JOIN 关键字以几种不同的方式组合数据集。如果你渴望在下周之前开始研究连接，我之前写过一篇关于 SQL 中内部和外部连接的区别的文章。
除了数据，我的另一个爱好是绘画。你可以在 www.katemarielewis.com 的找到我的野生动物艺术
社交距离学习数据科学的所有课程(LDSWSD)
阅读《走向数据科学》中关于 Ldswsd 的文章。共享概念、想法和代码的媒体出版物。
towardsdatascience.com](https://towardsdatascience.com/tagged/ldswsd)
国际足联 20 |第 1 部分:K-均值聚类
机器学习中的聚类分析
机器学习中的聚类算法教程的第 1 部分
视频版本
介绍
足球(欧洲足球)是我从小就喜欢的运动之一。我过去无论去哪里都带着一个球，这样我就可以最大限度地利用踢足球的机会。
我也喜欢踢足球——国际足联。我觉得用机器学习来分析国际足联的球员会很酷。
在本教程中，我将使用 K-Means 聚类算法对 FIFA 20 中具有相似技能的足球运动员进行分组。
了解聚类
聚类是一种无监督学习技术(PCA 是另一种)。
我们可以将观测值聚类(或分组)到相同的子组中，使得子组中的观测值彼此非常相似，而不同子组中的观测值彼此非常不同。
聚类示例
上面的散点图向我们展示了数据集中有三个不同的组。
了解 K-均值聚类
K-Means 聚类是聚类算法的一种。
基本算法是这样的:
- 指定 K 簇并初始化随机质心
- 迭代直到集群分配停止变化。该方法将每个观察精确地分配给 K 个聚类中的一个
- 对于每个 K 分类，计算分类平均值
- 继续查看观察值列表，并将一个观察值分配给平均值最接近的群集。
目标是以这样一种方式形成聚类，即同一聚类内的观察尽可能相似。
K-Means 聚类使用平方欧几里得距离计算相似性。
数据集
我们准备用 Kaggle 的 FIFA 20 数据集 。
特征工程
我们将只选择数字值和每个玩家的名字。
df = df[['short_name','age', 'height_cm', 'weight_kg', 'overall', 'potential','value_eur', 'wage_eur', 'international_reputation', 'weak_foot','skill_moves', 'release_clause_eur', 'team_jersey_number','contract_valid_until', 'nation_jersey_number', 'pace', 'shooting','passing', 'dribbling', 'defending', 'physic', 'gk_diving','gk_handling', 'gk_kicking', 'gk_reflexes', 'gk_speed','gk_positioning', 'attacking_crossing', 'attacking_finishing','attacking_heading_accuracy', 'attacking_short_passing','attacking_volleys', 'skill_dribbling', 'skill_curve','skill_fk_accuracy', 'skill_long_passing', 'skill_ball_control','movement_acceleration', 'movement_sprint_speed', 'movement_agility','movement_reactions', 'movement_balance', 'power_shot_power','power_jumping', 'power_stamina', 'power_strength', 'power_long_shots','mentality_aggression', 'mentality_interceptions','mentality_positioning', 'mentality_vision', 'mentality_penalties','mentality_composure', 'defending_marking', 'defending_standing_tackle','defending_sliding_tackle', 'goalkeeping_diving','goalkeeping_handling', 'goalkeeping_kicking','goalkeeping_positioning', 'goalkeeping_reflexes']]
我正在抽取工装裤在 86 以上的玩家，因为我们不想用 18000 以上的玩家来分组。
df = df[df.overall > 86] # extracting players with overall above 86
用平均值替换空值。
df = df.fillna(df.mean())
使数据正常化(标准化/重新标度)。
- 我们希望将数据标准化，因为变量是在不同的尺度上测量的。
from sklearn import preprocessingx = df.values # numpy arrayscaler = preprocessing.MinMaxScaler()x_scaled = scaler.fit_transform(x)X_norm = pd.DataFrame(x_scaled)
使用主成分分析将该图的 60 维减少到 2 维。
from sklearn.decomposition import PCApca = PCA(n_components = 2) # 2D PCA for the plotreduced = pd.DataFrame(pca.fit_transform(X_norm))
执行 K 均值聚类
我们将指定有 5 个集群。
from sklearn.cluster import KMeans # specify the number of clusterskmeans = KMeans(n_clusters=5)# fit the input datakmeans = kmeans.fit(reduced)# get the cluster labelslabels = kmeans.predict(reduced)# centroid valuescentroid = kmeans.cluster_centers_# cluster valuesclusters = kmeans.labels_.tolist()
通过添加玩家的名字和他们的集群创建一个新的数据框。
reduced['cluster'] = clustersreduced['name'] = namesreduced.columns = ['x', 'y', 'cluster', 'name']reduced.head()
可视化 K 均值聚类图
import matplotlib.pyplot as pltimport seaborn as sns%matplotlib inlinesns.set(style="white")ax = sns.lmplot(x="x", y="y", hue='cluster', data = reduced, legend=False,fit_reg=False, size = 15, scatter_kws={"s": 250})texts = []for x, y, s in zip(reduced.x, reduced.y, reduced.name):texts.append(plt.text(x, y, s))ax.set(ylim=(-2, 2))plt.tick_params(labelsize=15)plt.xlabel("PC 1", fontsize = 20)plt.ylabel("PC 2", fontsize = 20)plt.show()
k 均值聚类
看看基于玩家位置的集群是如何形成的，这很酷！
我希望你觉得这个教程有用，并期待下一个！
FIFA 20 中具有相似技能的足球运动员分组|第 2 部分:层次聚类
机器学习中的聚类分析
机器学习中的聚类算法教程的第 2 部分
视频版本
查看我的聚类算法系列 这里 。
在本教程中，我们将使用层次聚类对 FIFA 20 名球员进行分组！
了解分层聚类
- 与 K-means 不同，不需要指定聚类数。
- 结果汇总在一个树状图中，这是一个树形图，可以轻松解释数据并选择任意数量的聚类
基本思想
- 焦点:自下而上(又名。凝聚聚类)
- 从个人观察开始(又名。叶子成簇
- 通过将叶子合并成分支向上移动
- 将树枝与其他树叶或树枝合并
- 最终，当所有的东西都合并成一个集群时，到达顶端
树状图示例
解读树状图
- 在适当的高度切割，以获得所需的簇数
- 纵轴:相异度(或距离)——两个聚类合并的高度
- 高度代表聚类的相似性
- 身高更低- >更相似
- 横轴不表示相似性
- 交换左右分支不会影响树状图的含义
它如何度量集群之间的不相似性？
- 基于公制的(曼哈顿距离或欧几里德距离——最常见)
- 完全连锁(最远邻法)
- 单一连锁(最近邻法)
- 平均连锁
- 质心连杆机构
2.基于相关性的距离
- 找出观察值之间的相关性
分层聚类的缺点
- 计算成本高—不适合大数据集
- O(N log N)，而 O(N)用于 K-means
2.对噪音和异常值敏感
使用层次聚类对 FIFA 20 球员进行分组
数据清理/预处理(第 1 部分的代码)
import pandas as pdimport numpy as npdf = pd.read_csv("/content/players_20.csv")df = df[['short_name','age', 'height_cm', 'weight_kg', 'overall', 'potential','value_eur', 'wage_eur', 'international_reputation', 'weak_foot','skill_moves', 'release_clause_eur', 'team_jersey_number','contract_valid_until', 'nation_jersey_number', 'pace', 'shooting','passing', 'dribbling', 'defending', 'physic', 'gk_diving','gk_handling', 'gk_kicking', 'gk_reflexes', 'gk_speed','gk_positioning', 'attacking_crossing', 'attacking_finishing','attacking_heading_accuracy', 'attacking_short_passing','attacking_volleys', 'skill_dribbling', 'skill_curve','skill_fk_accuracy', 'skill_long_passing', 'skill_ball_control','movement_acceleration', 'movement_sprint_speed', 'movement_agility','movement_reactions', 'movement_balance', 'power_shot_power','power_jumping', 'power_stamina', 'power_strength', 'power_long_shots','mentality_aggression', 'mentality_interceptions','mentality_positioning', 'mentality_vision', 'mentality_penalties','mentality_composure', 'defending_marking', 'defending_standing_tackle','defending_sliding_tackle','goalkeeping_diving','goalkeeping_handling', 'goalkeeping_kicking','goalkeeping_positioning', 'goalkeeping_reflexes']]df = df[df.overall > 86] # extracting players with overall above 86df = df.fillna(df.mean())names = df.short_name.tolist() # saving names for laterdf = df.drop(['short_name'], axis = 1) # drop the short_name columndf.head()
标准化数据
from sklearn import preprocessingx = df.values # numpy arrayscaler = preprocessing.MinMaxScaler()x_scaled = scaler.fit_transform(x)X_norm = pd.DataFrame(x_scaled)
平均链接的层次聚类
import matplotlib.pyplot as pltimport scipy.cluster.hierarchy as sch# plot dendrogram using average linkageplt.figure(figsize=(10,14))plt.title('Hierarchical Clustering Dendrogram with Average Linkage')dendrogram = sch.dendrogram(sch.linkage(X_norm, method="average"), labels= names, leaf_font_size = 13, orientation='right')
- 分成两个位置——守门员和其他人
单键
# plot dendrogram using single linkageplt.figure(figsize=(10,14))plt.title('Hierarchical Clustering Dendrogram with Single Linkage')dendrogram = sch.dendrogram(sch.linkage(X_norm, method="single"), labels= names, leaf_font_size = 13, orientation='right')
- 分成守门员和其他人
质心连杆机构
# plot dendrogram using centroid linkageplt.figure(figsize=(10,14))plt.title('Hierarchical Clustering Dendrogram with Centroid Linkage')dendrogram = sch.dendrogram(sch.linkage(X_norm, method="centroid"), labels= names, leaf_font_size = 13, orientation='right')
- 再一次，分成守门员和其他人
完全连锁
# plot dendrogram using complete linkageplt.figure(figsize=(10,14))plt.title('Hierarchical Clustering Dendrogram with Complete Linkage')dendrogram = sch.dendrogram(sch.linkage(X_norm, method="complete"), labels= names, leaf_font_size = 13, orientation='right')
结论
完全联动似乎对玩家分组最准确！
感谢你阅读这篇文章，希望你觉得有用！
GitHub 回购:https://github.com/importdata/Clustering-FIFA-20-Players
FIFA 20 中具有相似技能的足球运动员分组|第 3 部分:DBSCAN
机器学习中的聚类分析
机器学习中的聚类算法教程的第 3 部分
视频版本
查看我的聚类算法系列 这里 。
在本教程中，我们将使用 DBSCAN 算法对 FIFA 20 名球员进行分组！
了解 DBSCAN
- 基于密度的含噪声应用空间聚类
- 基于密度的聚类定位被低密度区域彼此分开的高密度区域
- 密度:指定半径内的点数。Eps 或ε)
点
- 核心点:如果一个点在 Eps 内有超过规定的点数(分点数)
- 边界点:它在 Eps 内的分点少于，但在核心点的附近
- **噪声(离群点)😗*不是核心点或边界点的任何点
核心、边界、异常值示例
集群是如何形成的？
- 选择一个点 p
- 检索从 p . w . r . t . EPS 和 MinPts 可达到的所有点密度。
- 如果 p 是一个核心点，就形成了一个集群。
- 如果 p 是一个边界点，没有点是从 p 密度可达的，DBSCAN 访问数据库的下一个点。
3.继续该过程，直到处理完所有点。
4.结果与处理点的顺序无关
ε-邻域概念
- 距离一个物体ε半径内的物体
- 核心对象:一个对象的ε-邻域至少包含个对象的 MinPts
p 是一个核心对象
能达到性
- 直接密度可达:如果 q 在 p 的ε-邻域内，且 p 是核心点，则点 q 是从 p 直接密度可达的。
q 是从 p 直接密度可达的
- 密度可达:如果点“p”距离点“q”在ε距离内，并且“q”在它的相邻点中有足够多的点在ε距离内，则称点“p”是从点“q”密度可达的。
q 是从 p 密度可达的吗
连通性
- 密度-连通性:如果有一个点 r 使得 p 和 q 是从 r w.r.t 和 MinPts 密度可达的，则点 p 是密度-连通到点 q w.r.t 和 MinPts 的
q 通过 r 与 p 密度相关
优点、缺点和应用
使用 DBSCAN 对 FIFA 20 名球员进行分组
数据清理/预处理(第 1 部分和第 2 部分的代码)
import pandas as pdimport numpy as npdf = pd.read_csv("/content/players_20.csv")df = df[['short_name','age', 'height_cm', 'weight_kg', 'overall', 'potential','value_eur', 'wage_eur', 'international_reputation', 'weak_foot','skill_moves', 'release_clause_eur', 'team_jersey_number','contract_valid_until', 'nation_jersey_number', 'pace', 'shooting','passing', 'dribbling', 'defending', 'physic', 'gk_diving','gk_handling', 'gk_kicking', 'gk_reflexes', 'gk_speed','gk_positioning', 'attacking_crossing','attacking_finishing','attacking_heading_accuracy', 'attacking_short_passing','attacking_volleys', 'skill_dribbling', 'skill_curve','skill_fk_accuracy', 'skill_long_passing','skill_ball_control','movement_acceleration', 'movement_sprint_speed', 'movement_agility','movement_reactions', 'movement_balance', 'power_shot_power','power_jumping', 'power_stamina', 'power_strength', 'power_long_shots','mentality_aggression', 'mentality_interceptions','mentality_positioning', 'mentality_vision', 'mentality_penalties','mentality_composure', 'defending_marking', 'defending_standing_tackle','defending_sliding_tackle', 'goalkeeping_diving','goalkeeping_handling', 'goalkeeping_kicking','goalkeeping_positioning', 'goalkeeping_reflexes']]df = df[df.overall > 86] # extracting players with overall above 86df = df.fillna(df.mean())names = df.short_name.tolist() # saving names for laterdf = df.drop(['short_name'], axis = 1) # drop the short_name columndf.head()
标准化数据
from sklearn import preprocessingx = df.values # numpy arrayscaler = preprocessing.MinMaxScaler()x_scaled = scaler.fit_transform(x)X_norm = pd.DataFrame(x_scaled)
使用主成分分析将 60 列减少为 2 列
from sklearn.decomposition import PCApca = PCA(n_components = 2) # 2D PCA for the plotreduced = pd.DataFrame(pca.fit_transform(X_norm))
应用数据库扫描
from sklearn.cluster import DBSCAN# train the model using DBSCANdb = DBSCAN(eps=1, min_samples=5)# the prediction for dbscan clustersdb_clusters = db.fit_predict(reduced)
通过添加玩家的名字和他们的集群创建一个新的数据框
reduced['cluster'] = db_clustersreduced['name'] = namesreduced.columns = ['x', 'y', 'cluster', 'name']reduced.head()
绘制 DBSCAN
import matplotlib.pyplot as pltimport seaborn as sns%matplotlib inlinesns.set(style="white")ax = sns.lmplot(x="x", y="y", hue='cluster', data = reduced, legend=False,fit_reg=False, size = 10, scatter_kws={"s": 250})texts = []for x, y, s in zip(reduced.x, reduced.y, reduced.name): texts.append(plt.text(x, y, s)) ax.set(ylim=(-2, 2))plt.tick_params(labelsize=15)plt.xlabel("PC 1", fontsize = 20)plt.ylabel("PC 2", fontsize = 20)plt.show()
Eps = 1 且 MinPts = 5 时的 DBSCAN
- 集群被组成守门员对抗其他的
- 不太准确
找到一个最佳的ε
- 通过计算每个点到最近的 n 个点的距离，排序并绘制结果，找到一个最佳ε。
from sklearn.neighbors import NearestNeighbors# calculate the distance from each point to its closest neighbornn = NearestNeighbors(n_neighbors = 2)# fit the nearest neighbornbrs = nn.fit(reduced)# returns two arrays - distance to the closest n_neighbors points and index for each pointdistances, indices = nbrs.kneighbors(reduced)# sort the distance and plot itdistances = np.sort(distances, axis=0)distances = distances[:,1]plt.plot(distances)
寻找最佳 Eps
- 看起来曲率在 eps = 0.3 左右开始加快
使用新的 Eps 再次应用 DBSCAN
from sklearn.cluster import DBSCAN# train the model using DBSCANdb= DBSCAN(eps=0.3, min_samples=4)# prediction for dbscan clustersdb_clusters = db.fit_predict(reduced)reduced['cluster'] = db_clustersreduced['name'] = namesreduced.columns = ['x', 'y', 'cluster', 'name']reduced.head()
用新的 Eps = 0.3 和 MinPts = 4 再次绘图
import matplotlib.pyplot as pltimport seaborn as sns%matplotlib inlinesns.set(style="white")ax = sns.lmplot(x="x", y="y", hue='cluster', data = reduced, legend=False,fit_reg=False, size = 9, scatter_kws={"s": 250})texts = []for x, y, s in zip(reduced.x, reduced.y, reduced.name): texts.append(plt.text(x, y, s)) ax.set(ylim=(-2, 2))plt.tick_params(labelsize=10)plt.xlabel("PC 1", fontsize = 20)plt.ylabel("PC 2", fontsize = 20)plt.show()
Eps = 0.3、MinPts = 4 时的 DBSCAN 图
结论
Epsilon = 0.3 和 MinPts = 4 的 DBSCAN 在分组和检测异常值方面做得更好！
感谢你阅读这篇文章，希望你觉得有用！
GitHub 回购:https://github.com/importdata/Clustering-FIFA-20-Players
印度各邦新冠肺炎病例的增长率
自 2020 年 4 月 22 日以来，印度各邦新冠肺炎病例增长率的简单、易于解释的可视化图。这将让我们了解哪些州在控制方面做得很好，哪些州在未来几天处于危险地带。
编者按: 走向数据科学 是一份以数据科学和机器学习研究为主的中型刊物。我们不是健康专家或流行病学家，本文的观点不应被解释为专业建议。想了解更多关于疫情冠状病毒的信息，可以点击 这里 。
这个想法
由于新冠肺炎造成的全球疫情现在已经延伸到 2020 年上半年之后，几个国家仍然每天报告数千例病例。世界各地的数据科学爱好者已经提出了一些预测、仪表盘和可视化方法，其中许多方法在这个前所未有的时代非常有用。
在这里，我尝试对阳性病例的比率进行州级比较，即 ，以尝试检测哪些州正在从相对安全的区域发展到危险的区域(潜在的热点)，反之亦然。
我们如何比较？
重要的第一步是选择准确的比较标准。简单地说，每个州的病例数没有意义:
- 每个州进行的检测数量很可能影响报告的阳性病例数量。更多的检测几乎肯定会导致更多的病例报告。因此，阳性百分比(即阳性病例数/100 次检测)是一个合适的指标。
- 各州的人口也不能被视为无用的因素。你只会认为马哈拉施特拉邦或更远的地方会发生比果阿更严重的事故。阳性病例数/100K 人口是我们的第二个选项(选择 100K 也确保了结果缩小到与前面变量类似的范围)
然而，我们不应忽视这样一种可能性，即一个人口较多的国家正在进行与一个小得多的国家类似数量的检测，因此很可能也有类似数量的病例。在这种情况下，每 100，000 人口的病例数将不是一个非常合适的代表真实情况的指标，特别是***，因为不同州的检测存在显著差异的情况在我国非常相关。***
最终选择的指标
我上面所讨论的仅仅是我的直觉，仅仅基于此来选择或放弃影响变量是不公平的。为此进行了回归分析:
“每日测试次数”和“人群”是两个回归变量，而每日报告的病例数是预测变量。在单独和共同考虑变量后，比较 R 平方值显示“日常测试次数”占变异的大约 63%，而“总体”占变异的大约11%。这清楚地证明了**“每日测试次数”是更有影响力的变量**(我的直觉:D 也是如此)。然而，最好不要完全抛弃另一个因素。相反， 给两者适当的权重是最好的办法:分别为 0.84 和 0.16(基于 R 平方比较)，从而将它们组合成一个新的变量。**
此外，我将执行 3 个不同的可视化(每个基于独立的可视化)和最后一个使用加权变量。
数据
我们的数据来源于下面的 GitHub 存储库，它致力于定期更新有关印度新冠肺炎的记录:https://github.com/imdevskp/covid-19-india-data
然而，并非所有的州都有足够的关于检测和报告的信息。因此，我只选择了 16 个州，这些州有严格的信息和足够的案例来进行研究。即使在过滤后的数据中，一些值也是不准确或荒谬的(例如，负数的情况；尽管测试为 0，但仍有阳性病例，等等)。它们已经被插值技术所取代。
包括可视化在内的整个过程的代码(将在下面显示)已记录在此:https://github . com/viper ville 007/Growth-rate-of-Indian-cases-in-States
可视化和解释:
日期的选择:4 月 22 日被选为起点。从此，我们可以通过 获得 有关检测和确诊病例的具体信息。此外，封锁已经实施了一个月，到那时，几乎所有被选中的州都有足够的设施进行测试，从而确保了同质性。
***平滑:**提供了近 90 个时间戳，绘制所有时间戳会使事情看起来 不必要的笨拙和难以解释 *。同样，如果我们关注每一天，一些 异常值是很有可能的 。我添加了 均值平滑到一个 7 天窗口的数据 来照顾这些问题。7 似乎是一个合理的选择，因为你会期望季节性每周都存在，如果它真的存在的话。
***注:*点击图片，您可以选择以更高的清晰度观看。
*
来源:自创*
这是我们所做的 3 个可视化中的第一个(第一个仅基于与进行的测试相关的阳性案例的百分比)。
基于配色方案的随附图例很好地总结了这一点:通俗地说，越接近黑色，该状态在该时间点的条件越安全(参考图下方的轴),黄色表示高危险。
*
来源:自创*
所以，这是单纯根据每个州 的病例数/10 万人口得出的。**
正如你可能已经猜到的，这个情节本身并不是一个非常恰当的事情指标(它仅仅解释了我们之前看到的关系的 11%)。
在不强调这一点的情况下，让我们快速进入最后的情节(基于我创建的修改变量)。
*
来源:自创*
这是基于修改变量的最终可视化图(带有前两个变量的适当权重)。**
现在，让我们试着从中得出一些结论:
- 理想的情况是，截止到最新时间戳的颜色方案接近黑色(非常低的增长率)
- 从黄色到紫色的趋势表明，该州的传播曾经非常高，但正在逐渐放缓。
- 相反的趋势(从紫色到黄色)表明存在风险——在接下来的几天里，情况只会变得更糟。基本上，麻烦。
- 综上所述，德里正显示出放缓的迹象(从曾经非常糟糕的状态)。古吉拉特邦和哈里亚纳邦在某种程度上显示出类似的模式。
- 这是西孟加拉邦、安得拉邦、比哈尔邦和卡纳塔克邦关注的问题。这种趋势非常令人担忧。
- 泰米尔纳德邦和马哈拉施特拉邦没有任何值得注意的巨大差异——但是%仍然是最高的。
- 其他州(大部分在黑色地带)已经能够应付事情，或者没有像上面讨论的那样严重地成为病毒的牺牲品。它们也没有显示出很快会突然爆炸的迹象。
编辑 1:
我现在已经为选定的州制作了一个条形图比赛，以视频的形式显示进度。你可以在这里查看:https://app.flourish.studio/story/489625/edit
这里有一个相同的快照:
来源:自创
我们只能希望越来越多的地区开始出现与上述第二点类似的趋势。
非常感谢你，如果你有足够的耐心通读整篇文章。请随时留下您的真实反馈，指出这篇文章中存在的技术或印刷错误，或者在评论部分澄清您的疑问和疑问。干杯:)
GSoC 2020 与 CERN-HSF |暗物质和深度学习
这个博客是我在 HSF 欧洲核子研究中心的谷歌代码之夏(GSoC) 2020 项目的一个非常简短的总结。今年是谷歌代码之夏 16 周年，共有 6，626 名学生提交了 8，902 份提案，其中 1，198 名学生获得了与 199 个组织合作的机会。
图片来源:谷歌代码之夏
DeepLense 项目
项目描述
DeepLense 是一个深度学习管道，用于利用强引力透镜进行粒子暗物质搜索，是伞式组织 CERN-HSF 的一部分。具体来说，我的项目是题为“深度学习暗物质亚结构的形态学”的论文中发表的工作的扩展，在该论文中，我的导师探索了使用最先进的监督深度学习模型，如 ResNet，对强透镜图像进行多类分类。
自 1936 年爱因斯坦的计算中讨论引力透镜并于 1979 年发现以来，引力透镜一直是许多宇宙学实验和研究的基石，一个特别感兴趣的领域是通过强透镜图像中的亚结构研究暗物质。虽然统计和监督机器学习算法已经实现了这项任务，但无监督深度学习算法的潜力仍有待探索，并可能被证明在 LSST 数据的分析中至关重要。这个 GSoC 2020 项目的主要目标是设计一个基于 python 的框架，用于实现无监督的深度学习架构，以研究强透镜图像。
更多细节参见论文“无监督解码暗物质子结构”。
仓库
我已经将我的工作编译成了两个开源库。第一个名为 PyLensing ，这是一个基于 PyAutoLens 模拟生成透镜图像的工具，第二个名为 Unsupervised Lensing ，这是一个基于 PyTorch 的工具，用于强透镜宇宙学中的无监督深度学习应用。
关于我
我是 K·普拉纳斯·雷迪，荣誉理学硕士。物理学和理学士(荣誉)。)印度 Pilani Birla 理工学院(BITS)海德拉巴校区电气和电子工程专业。
为什么是 DeepLense？
作为一名物理系学生，我熟悉 CERN 的运作，并对该组织的许多相关项目有着基本的了解，我在宇宙学领域的深度学习应用方面做了大量工作。这一经历激励我为 DeepLense 项目做贡献。
数据
不同子结构的模拟样品透镜图像。无(左)、漩涡(中)和球形(右)。|作者图片
我们的数据集由三类组成，没有子结构的强透镜图像、涡旋子结构和球形子结构。考虑到具有子结构的样本是异常值，我们将在一组没有子结构的强透镜图像上训练我们的无监督模型，以解决异常检测的任务。
我们已经生成了两组透镜图像，模型 A 和模型 b。我们已经使用 python 包 PyAutoLens 进行模拟。这两个模型之间的区别在于，模型 A 的所有模拟图像都保持在固定的红移，而模型 B 允许透镜星系和透镜星系的红移在一个数值范围内浮动。两种模型的另一个区别是信噪比。模型 A 的图像 SNR ≈ 20，而模型 B 的构造使得模拟产生的图像 SNR 在 10 到 30 之间变化。关于模拟的更多细节可以在的论文中找到。
无监督模型
我在异常检测的背景下研究并实现了各种无监督模型。在本节中，我将讨论四个模型，即深度卷积自动编码器(DCAE)、卷积变分自动编码器(VAE)、对抗自动编码器(AAE)和受限玻尔兹曼机器(RBM)，以及使用我的 PyTorch 工具无监督透镜实现这些模型的代码。
深度卷积自动编码器(DCAE)
自动编码器是一种学习自身表示的神经网络，由编码器网络和解码器网络组成。编码器学习将输入样本映射到其维度低于输入样本维度的潜在向量，解码器网络学习从潜在维度重构输入。因此，自动编码器可以定性地理解为寻找给定类的最佳压缩表示的算法。
我们首先考虑深度卷积自动编码器，它主要用于图像的特征提取和重建。在训练期间，我们利用均方误差(MSE)，
MSE 损失|作者图片
作为我们的重建损失，其中θ和θ’是真实的和重建的样本。
使用 PyTorch 工具实现:
**from** **unsupervised_lensing.models** **import** Convolutional_AE
**from** **unsupervised_lensing.models.DCAE_Nets** **import** *
**from** **unsupervised_lensing.utils** **import** loss_plotter **as** plt
**from** **unsupervised_lensing.utils.EMD_Lensing** **import** EMD*# Model Training*
out = Convolutional_AE.train(data_path='./Data/no_sub_train.npy',
epochs=100,
learning_rate=2e-3,
optimizer='Adam',
checkpoint_path='./Weights',
pretrain=**True**,
pretrain_mode='transfer',
pretrain_model='A')
*# Plot the training loss*
plt.plot_loss(out)*# Model Validation*
recon_loss = Convolutional_AE.evaluate(data_path='./Data/no_sub_test.npy',
checkpoint_path='./Weights',
out_path='./Results')
*# Plot the reconstruction loss*
plt.plot_dist(recon_loss)
*# Calculate Wasserstein distance*
print(EMD(data_path='./Data/no_sub_test.npy', recon_path='./Results/Recon_samples.npy'))
卷积变分自动编码器(VAE)
我们还考虑了一个变分自动编码器，它以 Kullback-Liebler (KL)散度的形式对潜在维度的表示引入了一个附加约束，
Kullback-Liebler (KL)散度|作者图片
其中 P(x)是目标分布，Q(x)是算法学习的分布。r.h.s .上的第一项是 P 和 Q 之间的交叉熵，第二项是 P 的熵。因此，KL 散度对分布 Q 离 P 有多远的信息进行编码。在变分自动编码器的情况下，KL 散度用作正则化，以在潜在空间上施加先验。出于我们的目的，P 被选择为在潜在空间 z 上采用高斯先验的形式，而 Q 对应于由编码器表示的近似后验 q(z|x)。模型的总损失是重建(MSE)损失和 KL 散度之和。
使用 PyTorch 工具实现:
from unsupervised_lensing.models import Variational_AE
from unsupervised_lensing.models.VAE_Nets import *
from unsupervised_lensing.utils import loss_plotter as plt
from unsupervised_lensing.utils.EMD_Lensing import EMD# Model Training
out = Variational_AE.train(data_path='./Data/no_sub_train.npy',
epochs=100,
learning_rate=2e-3,
optimizer='Adam',
checkpoint_path='./Weights',
pretrain=True,
pretrain_mode='transfer',
pretrain_model='A')# Plot the training loss
plt.plot_loss(out)# Model Validation
recon_loss = Variational_AE.evaluate(data_path='./Data/no_sub_test.npy',
checkpoint_path='./Weights',
out_path='./Results')# Plot the reconstruction loss
plt.plot_dist(recon_loss)# Calculate Wasserstein distance
print(EMD(data_path='./Data/no_sub_test.npy', recon_path='./Results/Recon_samples.npy'))
对抗性自动编码器(AAE)
最后，我们考虑一个对抗的自动编码器，它用对抗学习代替变分自动编码器的 KL 散度。我们训练鉴别器网络 D，以在由自动编码器 G 生成的样本和从对应于我们的训练数据的先验分布 P(z)获取的样本之间进行分类。该模型的总损耗是重建(MSE)损耗和鉴别器网络损耗之和，
鉴别器丢失|作者图片
我们另外向自动编码器添加以下形式的正则化项，
作者图片
随着自动编码器在重建输入方面变得熟练，鉴别器的能力下降。然后，鉴别器网络通过提高其区分真实数据和生成数据的性能来进行迭代。
使用 PyTorch 工具实现:
from unsupervised_lensing.models import Adversarial_AE
from unsupervised_lensing.models.AAE_Nets import *
from unsupervised_lensing.utils import loss_plotter as plt
from unsupervised_lensing.utils.EMD_Lensing import EMD# Model Training
out = Adversarial_AE.train(data_path='./Data/no_sub_train.npy',
epochs=100,
learning_rate=2e-3,
optimizer='Adam',
checkpoint_path='./Weights',
pretrain=True,
pretrain_mode='transfer',
pretrain_model='A')# Plot the training loss
plt.plot_loss(out)# Model Validation
recon_loss = Adversarial_AE.evaluate(data_path='./Data/no_sub_test.npy',
checkpoint_path='./Weights',
out_path='./Results')# Plot the reconstruction loss
plt.plot_dist(recon_loss)# Calculate Wasserstein distance
print(EMD(data_path='./Data/no_sub_test.npy', recon_path='./Results/Recon_samples.npy'))
受限玻尔兹曼机(RBM)
为了与我们的三个自动编码器模型进行比较，我们还训练了一个受限的波尔兹曼机器(RBM)，这是一个生成式人工神经网络算法，实现为一个二分图，学习输入的概率分布。RBMs 由两层组成，一个隐藏层和一个可见层，其中训练是在一个称为对比发散的过程中完成的。
所有模型的详细架构可在论文的附录 B 中找到。
使用 PyTorch 工具实现:
from unsupervised_lensing.models import RBM_Model
from unsupervised_lensing.models.RBM_Nets import *
from unsupervised_lensing.utils import loss_plotter as plt
from unsupervised_lensing.utils.EMD_Lensing import EMD# Model Training
out = RBM_Model.train(data_path='./Data/no_sub_train.npy',
epochs=100,
learning_rate=2e-3,
optimizer='Adam',
checkpoint_path='./Weights',
pretrain=True,
pretrain_mode='transfer',
pretrain_model='A')# Plot the training loss
plt.plot_loss(out)# Model Validation
recon_loss = RBM_Model.evaluate(data_path='./Data/no_sub_test.npy',
checkpoint_path='./Weights',
out_path='./Results')# Plot the reconstruction loss
plt.plot_dist(recon_loss)# Calculate Wasserstein distance
print(EMD(data_path='./Data/no_sub_test.npy', recon_path='./Results/Recon_samples.npy'))
结果
我使用了 25，000 个没有子结构的样本和每类 2，500 个验证样本来训练和评估无监督模型。这些模型是使用 PyTorch 包实现的，并在单个 NVIDIA Tesla K80 GPU 上运行 500 个时代。我们利用 ROC 曲线下的面积(AUC)作为我们所有模型的分类器性能的度量。对于无监督模型，ROC 值是针对重建损失的设定阈值计算的。此外，我们还使用 Wasserstein 距离值来比较重建的保真度。一组更详细的结果可以在的论文中找到。
无监督算法的 ROC-AUC 曲线。左边的图对应于模型 A，右边的图对应于模型 b。|图片由作者提供
本分析中使用的体系结构的性能。ResNet 的 AUC 值是针对有和没有亚结构的图像分类计算的，因此它不是宏观平均 AUC。W₁是没有子结构的图像的平均第一瓦瑟斯坦距离。|作者图片
未来的工作和最后的想法
尽管我们的无监督模型得到了一些非常有希望的结果，但是与 ResNet 模型的监督结果相比，它们的性能仍有进一步改进的空间。我目前正在探索基于图的模型的应用，因为它们在与稀疏数据集相关的任务中取得了成功，如稀疏 3D 点云和稀疏探测器数据。另一个未来的任务是使用迁移学习，通过从我们已经在模拟上训练过的模型开始，在真实数据上训练我们的架构。
我要感谢我的导师迈克尔·图米、谢尔盖·格莱泽、斯蒂芬·亚力山大和伊曼纽·乌赛，以及整个欧洲粒子物理研究所-HSF 社区对我的支持。我在 GSoC 项目上度过了一个美好的夏天。我还要感谢阿里·哈里里、汉娜·帕鲁尔和赖克·冯·克拉尔进行了有益的讨论。
给以后想参加 GSoC 的同学们，不要把 GSoC 看成一个需要“破解”的竞赛或者考试。GSoC 是关于开源开发和成为优秀开发者社区的一部分。找到你热爱的项目，了解组织的需求。最重要的是，在社区论坛上保持活跃，定期与你的项目导师互动。
感谢谷歌给我这么一个神奇的机会。
**更新:**deep lens 项目现在是 ML4SCI 保护伞组织的一部分。
重要链接
[## 无监督解码暗物质亚结构
暗物质的身份仍然是当今物理学中最紧迫的问题之一。虽然许多有前途的黑暗…
arxiv.org](https://arxiv.org/abs/2008.12731) [## 用强引力透镜模拟暗物质
强引力透镜是对暗物质亚结构的一个有希望的探索，以更好地理解它的结构。
hepsoftwarefoundation.org](https://hepsoftwarefoundation.org/gsoc/2020/proposal_DEEPLENSE.html) [## 深透镜-无监督/无监督-透镜
基于 PyTorch 的工具，用于强透镜宇宙学中的无监督深度学习应用
github.com](https://github.com/DeepLense-Unsupervised/unsupervised-lensing) [## DeepLense 无人监督/PyLensing
一个基于 PyAutoLens 模拟生成透镜图像的工具
github.com](https://github.com/DeepLense-Unsupervised/PyLensing) [## 印度特伦甘纳邦皮兰尼-海德拉巴普拉纳特·雷迪-比拉科技学院
查看 Pranath Reddy 在全球最大的职业社区 LinkedIn 上的个人资料。Pranath 有 2 份工作列在…
www.linkedin.com](https://www.linkedin.com/in/pranath-reddy/) [## 普拉纳斯-雷迪-概述
此时您不能执行该操作。您已使用另一个标签页或窗口登录。您已在另一个选项卡中注销，或者…
github.com](https://github.com/pranath-reddy)
如果可以的话，猜猜这些胡言乱语
一个简单的算法来创建你的胡言乱语的挑战
图片来源:自创
社交媒体是 21 世纪的强大平台。它已经成为数字营销的主要来源，表达观点，交友，娱乐方式等等。社交媒体应用不断创新和变化，通过显示正确的内容来了解用户的行为，从而保持用户的参与。经常可以看到新的挑战趋势，很多名人会发布相关的帖子。当前流行的一个挑战是“猜胡言乱语挑战”。
我相信你一定接受过或者至少见过有人接受这个挑战。在这个挑战中，屏幕上出现一些看似无意义但听起来有意义的乱码。让我们看一些例子。
图片来源:自创
图片来源:自创
我接受了胡言乱语的挑战
我亲自尝试过，我可以保证它有时会上瘾。作为一个算法爱好者，我想到的第一件事是我如何自己创造一个这样的挑战。我做了一些研究，创造了一个简单的游戏版本。这个简单的版本可以通过一些调整变得复杂，我将在最后作为开放式问题进行讨论。可以有许多不同的方法来创建它。在这篇博文中，我将讨论一种可能的方法。这篇博文中使用的所有代码都可以在这里找到。那么，我们开始吧。
你也可以找到我关于这个话题的 Youtube 视频。
我在 Youtube 上关于这个话题的视频
语音算法
根据维基百科，语音学是研究人类声音的科学。这个领域的主题专家被称为语音学家。基于语言学的语音学研究被称为音系学。
一个语音算法是一个算法，用于通过发音为单词的标引。这些算法提供了识别发音相似的单词的能力。
读者能想到的第一个问题是，我们为什么要讨论语音学和语音算法。答案是，在我们试图解决的问题“猜测胡言乱语挑战”中，胡言乱语听起来类似于某种要被解码的有意义的东西，这也是最终的动机。直觉上，它想到一些语音算法可以帮助这一点。有许多好的语音算法，其中一个流行且简单的算法是 Soundex 算法。
Soundex 算法
Soundex 是一个语音算法，用于通过声音索引姓名。目标是让同音字被编码成相同的表示，这样即使拼写有微小差异，它们也能被匹配。
Soundex 算法将英语单词编码成一个代码，其中第一位由一个字母和后面的“k-1”个数字组成，假设我们想要“k”位编码。
该算法在维基百科中有非常好的解释。从它身上取下一些部分，稍微简化一下，看起来是这样的:
[## 桑迪克斯
Soundex 是一种语音算法，用于按声音索引名称，如英语中的发音。我们的目标是让同音词…
en.wikipedia.org](https://en.wikipedia.org/wiki/Soundex#American_Soundex)
第一步:保留单词的第一个字母，去掉所有其他出现的 a，e，I，o，u，y，h，w。
**第二步:**用数字替换辅音如下(第一个字母后):
★ b，f，p，v → 1
★ c，g，j，k，q，s，x，z → 2
★ d，t → 3
★ l → 4
★ m，n → 5
★ r → 6
图片来源~ 维基百科
步骤 2 背后的逻辑:
**第三步:**如果原词中有两个或两个以上同号字母相邻，只保留首字母；同样，由“h”或“w”分隔的具有相同数字的两个字母被编码为单个数字，而由元音分隔的这种字母被编码两次。这条规则也适用于第一个字母。
步骤 4: 如果最终编码少于 k 位，用 0 填充剩余的位。如果多于 k 位，只保留第一个 k 位。
使用此算法,“Robert”和“Rupert”返回相同的字符串“R163 ”,而“Rubin”返回“R150”。“阿什克拉夫特”和“阿什克罗夫特”都产生“A261”。“Tymczak”产生“T522”而不是“T520”(名称中的字符“z”和“k”被编码为 2 两次，因为它们之间有一个元音)。‘pfister’产生‘P236’而不是‘P123’(前两个字母的数字相同，编码一次为‘P’)，‘Honeyman’产生‘H555’。
在 python 中，模糊包提供了 Soundex 和其他语音算法的良好实现。
对 Soundex 的轻微修改
我们将使用 Soundex 算法生成编码，与步骤 1 略有不同。
我们不是删除 a、e、I、o、u、y、h、w 的所有出现，而是进一步对它们进行聚类/编号。
★ e，I，y → 7
★ o，u → 8
★ a，h，w →忽略它们
推理:e，I 和 y 看起来相似，例如’ pic ‘，’ pec ‘，’ pyc '听起来相似。
我不能使用模糊包，因为我希望在原始的 Soundex 算法中执行这些建议的修改。我发现卡洛斯·德尔加多的这个伟大的实现。这并不完全正确，但对我们的用例来说已经足够好了。
查看我们用不同的和已知的编程语言编写的 Soundex 函数的复制。
ourcodeworld.com](https://ourcodeworld.com/articles/read/249/implementation-of-the-soundex-algorithm-function-in-different-programming-languages)
改进的 Soundex 算法；
def get_soundex_modified(name):
# Get the soundex code for the string
name = name.upper()soundex = ""
soundex += name[0]# numbering of letters based on phonetic similarity
dictionary = {"BFPV": "1", "CGJKQSXZ":"2", "DT":"3", "L":"4", "MN":"5", "R":"6","EIY":"7","OU":"8","AHW":"."}for char in name[1:]:
for key in dictionary.keys():
if char in key:
code = dictionary[key]
if code != soundex[-1]:
soundex += codesoundex = soundex.replace(".", "")
# We prefer a 8-bit output
soundex = soundex[:8].ljust(8, "0")return soundex
猜猜胡言乱语挑战算法
对 Soundex 算法稍加修改，我们就可以完成“猜测胡言乱语挑战”算法。这些步骤将是
步骤 1: 给定句子，一次取一个单词，使用上述修改的 sounded 算法生成 8 位编码。例如，单词“under”的编码为“U5376000”。
步骤 2: 从步骤 1 中取出编码，一次取出编码中的一个字母，并执行以下操作:
- 如果字母是字符，就保持原样。
- 如果字母是一个数字，从该组中随机选择一个字符。例如，如果字母是 2，我们可以随机选择 c、g、j、k、q、s、x 和 z 中的任意一个。群集是:
★ b，f，p，v → 1
★ c，g，j，k，q，s，x，z → 2
★ d，t → 3
★ l → 4
★ m，n → 5
★ r → 6
★ e，I，y → 7
★ o，u → 8
- 如果字母是 0 或者编码中没有剩余的字母，我们就完成了这个单词
**第三步:**对句子中的所有单词重复同样的过程。
猜谜挑战算法的实现
让我们可视化一些谚语的乱码输出。
最终输出:生成的乱码
输出是胡言乱语，虽然听起来类似于实际的谚语。这就是我们简单的“猜谜挑战”解决方案。
可能的增强
在目前的方法中，我们正在为每个可能被改变的单词创建一个乱码。同样，第一个字符在原始输入和乱码输出中都保持不变。我们可以有一些解决办法。我将提供两种可能的方法来增强我们的“猜测胡言乱语”算法，并把它作为一个开放式问题留给观众来展示创造力。
- 一些智能的启发式算法，智能地拆分和组合单词，然后使用修改的 Soundex 算法进行编码。例如，英国的一个可能有趣的胡言乱语是“母羊之夜特德国王哑巴”。
- 原始输入和乱码输出中的第一个字符不必相同。例如，对字母“U”进行编码的一种可能方式可以是“Ewe”。
结论
通过这篇博文，我们开发了一个有趣且非常简单的算法来创建我们自己的“猜测胡言乱语挑战”。在这个过程中，我们还学习了语音学、音韵学和语音算法。我们还研究了如何让它变得更具挑战性。希望你喜欢。这篇博文中使用的所有代码都可以在这里找到。
如果你有任何疑问，请联系我。我很想知道你是否想到了更多可能的改进。
我的 Youtube 频道获取更多内容:
嗨，伙计们，欢迎来到频道。该频道旨在涵盖各种主题，从机器学习，数据科学…
www.youtube.com](https://www.youtube.com/channel/UCg0PxC9ThQrbD9nM_FU1vWA)
关于作者-:
Abhishek Mungoli 是一位经验丰富的数据科学家，拥有 ML 领域的经验和计算机科学背景，跨越多个领域并具有解决问题的思维方式。擅长各种机器学习和零售业特有的优化问题。热衷于大规模实现机器学习模型，并通过博客、讲座、聚会和论文等方式分享知识。
我的动机总是把最困难的事情简化成最简单的版本。我喜欢解决问题、数据科学、产品开发和扩展解决方案。我喜欢在闲暇时间探索新的地方和健身。关注我的 中 、Linkedin或insta gram并查看我的往期帖子。我欢迎反馈和建设性的批评。我的一些博客:****
- 一个无监督的数学评分模型
- 降维:PCA 与自动编码器
- 体验遗传算法的威力
- 每个数据科学家都应该避免的 5 个错误
- 以简单&直观的方式分解时间序列
- GPU 计算如何在工作中拯救了我？
- 信息论& KL 分歧第一部分和第二部分
- 使用 Apache Spark 处理维基百科，创建热点数据集
- 一种基于半监督嵌入的模糊聚类
- 比较哪个机器学习模型表现更好
- 分析 Fitbit 数据，揭开疫情封锁期间身体模式变化的神秘面纱
- 神话与现实围绕关联
- 成为面向业务的数据科学家指南
关于如何从零开始学习数据科学的指南，完全在线，没有 STEM 背景
照片通过像素
数据科学仍然是吸引人们思想的神秘领域，但许多人仍然认为从头学习非常困难，甚至不可能。“要精通数据科学，你必须有工程学本科学历，或者有数学/统计学背景”，—我听过很多次了。尽管拥有一些这样的背景无疑是有益的，但我真的相信这绝不是必要的。
两周之后，我将在弗吉尼亚大学完成我的 MBA/MSDS 双学位。在我在校的两年时间里，我利用空闲时间完成了本指南中列出的每一门课程。我在本文中推荐的课程是我能找到的最好的数据科学资源。我学习有点慢，不得不尝试很多不同的在线课程。我下面列出的这些学校都有顶尖的教授，他们是解释这些概念的专家。
在美国，一个典型的数据科学硕士学位的费用从 1 万美元(在线 MSDS)到 10 万美元不等。本文中的指南不能取代校内的 MSDS 学位，因为你在招聘方面得到了学校的大力支持，你发展了自己的关系网，并结交了很多密友。然而，我认为，与参加全日制 MSDS 学位相比，数据科学是少数几个你可以通过在线学习获得同样多甚至更多知识的领域之一。另外，根据你的愿望，你最终将支付 0-1000 美元。最后，并不是所有人都需要学习硕士级别的数据科学。在数字时代，大多数工作专业人士最终将开始在日常生活中使用机器学习技术，就像 90 年代第一次使用 Excel 的人一样。因此，虽然 MSDS 可能有些矫枉过正，但学习一些技能并对数据科学有一个大致的了解是至关重要的。
我将把这个指南分成两个部分:一个面向那些希望对数据科学的技术和语言有一个总体了解的人，他们想亲自动手，能够进行数据辩论，并自己运行一些机器学习和深度学习模型；另一个目标是那些想要获得 MSDS 水平的知识，甚至可能转行成为全职数据科学家的人。同样，你可以在没有任何先验知识的情况下开始做这两个轨道。在本文中，我将主要推荐 Python 资源，但是我认为学习 R 也是很有价值的。我会让你决定的。
在开始阅读指南之前，我想提供一些通用的提示和技巧，帮助我保持正确的方向，保持动力，尽可能高效地学习和利用时间。
- 每周至少学习五天。理想情况下，每天 30 分钟。我建议建立一个 30 分钟-1 小时的 9 点日历，并在周末保留 2-3 个小时。所有的课程都被设计成小块进行，所以学习起来会很自然。小块的学习会帮助你更好的内化信息。
- 循序渐进，不要同时上课。指南从最简单的课程到更难的课程。而且如果你没有一些概念的先验知识，再高级的课程对你来说也是无法理解的。
- 支付课程费用(当然只要你能负担得起)。本指南中的每门课程都有大量练习，这对你的学习体验至关重要。与你通过练习得到的结果相比，这些量是微不足道的。
- 不用担心卡住！数据科学的酷之处在于，很多知识仅仅来自谷歌搜索。我在 MSDS 的顶点项目是自然语言处理(文本分析)，我对此一无所知。我没有选修过 NLP，但是通过选修下面列出的几门课程和谷歌搜索，我仍然能够成功地完成这个项目。Stackoverflow 是一个平台，可以解答你在这个过程中可能遇到的所有问题。
现在让我们来看看指南。
第一轨。我只是想对数据科学有一个大致的了解，并能够了解我团队中的数据科学家在做什么
- 对于这两种途径，我建议从基本的 Python 基础开始。我的假设是，你没有编程经验，因此建立一些基础和对自己能力的信心是至关重要的。从 Coursera 上密执安大学的这个 Python 专门化开始。如果你想做练习题并获得证书，你需要花费 50 美元。你也可以免费旁听课程。
- 在 DataCamp 上用 Python 完成赛道数据科学家。这个 100 小时的专业课程将为您提供开始数据科学之路所需的一切，并能够与贵公司的数据科学家和工程师交流。费用是 30 美元/月，但是 DataCamp 上时不时会有很多优惠。我见过 75%的年费折扣。在完成这 23 门课程的专业学习后，你将获得 Python 技术的扎实知识，并将了解最常用的机器学习模型，还将稍微进入深度学习和人工智能领域。
- 最后，我强烈推荐熟悉 Tableau。商务人士能够获得的最重要的技能之一是与数据沟通。Tableau 是实现这一目的的最佳工具之一。在 Tableau 电子教学网站上完成 Tableau 分析师课程。您必须注册才能访问该资源。有试用期和折扣。截至 2020 年 4 月，Tableau 提供 90 天免费。
总工作量:~ 100–200 小时
总费用: $30 — $300 取决于你的速度。所有订阅都是按月进行的，所以完成得越快，支付的费用就越少。
作为额外的学习，我建议参加 DataCamp 的营销分析技能课程。对于进入 B2C 领域的商务人士来说，这将是非常有用的。
第二轨。我想成为一名全职数据科学家，或者用低预算获得 MSDS 水平的知识
这条赛道的主要区别在于，除了实用知识，还会为你提供扎实的理论基础。我强烈建议为大部分资源付费，以充分利用实际问题以及可能有助于职业转型的证书。我还有一个假设，你有一般的高中数学知识。你不必是一个伟大的数学家，但是如果你不知道函数是如何工作的，例如(斜率、截距等等)，我会建议你从 Khanacademy.com 开始，在他们的网站上复习代数 I 部分。不需要微积分、线性代数或概率论知识。现在让我们去赛道。
- 正如我之前提到的，对于这两种途径，我建议从基本的 Python 基础开始。我的假设是，你没有编程经验，因此建立一些基础和对自己能力的信心是至关重要的。从密歇根大学 Coursera 上的这个 Python 专门化开始。如果你想做练习题并获得证书，你需要花费 50 美元。你也可以免费旁听课程。
- 那么你将需要转向一些数学。当我在攻读 MSDS 学位时，我在数学方面完全没有准备，必须从头开始学习所有的概念。我学了很多课程，如果你和我一样，没有扎实的数学基础，大部分课程都很难理解。我发现机器学习的数学绝对令人着迷。教授们用直白的语言解释相当复杂的概念。同样，我建议付费来练习这些概念，但是如果对你来说效果更好的话，也可以随意旁听课程。
- 我们的下一站是统计。此外，作为数据科学家，这也是我们需要的重要基础。我建议要么选择 Python 专门化的统计，要么选择 R 专门化的统计。我选择了第二个，并建议你也这样做。然而，它是用 R 编程语言教授的。同样，非常有用，但在这一点上不是非常必要。如果时间不够，就用 Python 吧。如果你口袋里还有时间，就拿 R 吧。那里的教授是杜克大学著名的数据科学贡献者玛雅·切廷卡亚-伦德尔。
- 当你完成了理论基础，我们需要跳上一辆实用的火车，用 Python 进行大量的机器学习建模。对于这一点，我不知道有什么资源比 DataCamp 上具有 Python 专长的数据科学家更好。这很长，有 23 门课程，大约需要 100 个小时，但作为一名有抱负的数据科学家，你将获得非常坚实的实践基础。
- 接下来，我们需要更深入，我们将在 DataCamp 上切换到使用 Python 的机器学习科学家。这是一个高级的多课程专业化，深入研究最常用的机器学习技术，如果你想在这个行业取得成功，你必须熟悉这些技术。
- 我们的最后两步将专注于 AI 和深度学习算法。你能找到的最好的资源是吴恩达在 Coursera 上的深度学习专业。这是相同的，甚至可能比一个合法的硕士 3 级学分的深度学习课程更好。对每个数据科学家来说都是绝对必要的知识。
- 最后，用一些实际的实现来巩固前面步骤中的知识是至关重要的。tensor flow in Practice specialization建立在深度学习的基础上，提供大量的实践。
**总时间:**至少 300 小时，很可能 500 小时左右
总成本: $60 — $1000(？).这里的成本将高度依赖于学习的速度和为练习付费的意愿。你不能旁听 DataCamp 的课程，每月至少要花 30 美元。其余的你可以免费审核。但是，我强烈建议付费。与完成所有练习题后你将得到的结果相比，这个成本可以忽略不计。
我故意没有把 Tableau 放在这首歌里。您将从 Python 专门化中获得基础的可视化知识，并且在这一点上，作为一名专业人员，您将能够确定 Tableau 是否是您日常需要的东西。如果是的话，学起来会相当快和容易。
最后的想法
我非常有信心，没有 STEM 背景的任何人都可以成为数据科学家。和其他技能一样，这当然需要时间、努力和奉献。然而，结果是惊人的，尤其是现在几乎是无与伦比的。所以我祝你一路走好，也希望你能像我一样，一路玩得开心。
课程链接汇总:
轨道 1。
- https://www.coursera.org/specializations/python?
- https://learn . data camp . com/career-tracks/data-scientist-with-python
- https://www.tableau.com/learn/training/elearning
- https://www . data camp . com/tracks/marketing-analytics-with-python
第二轨。
- https://www.coursera.org/specializations/python?
- https://www . coursera . org/specializations/mathematics-machine-learning？
- https://www.coursera.org/specializations/statistics 和T4
- https://www.datacamp.com/tracks/data-scientist-with-python
- https://www . data camp . com/tracks/machine-learning-scientist-with-python
- https://www.coursera.org/specializations/deep-learning?
- https://www . coursera . org/specializations/tensor flow-in-practice？
亚马逊人工智能工作指南
了解亚马逊的不同人工智能角色，在人工智能的热门领域启动你的职业生涯。
- 注意，我指的是 AI 的定义，即机器对人类智能过程的模拟。因此，在这个上下文中，AI 是一个包含 ML、CV、NLP 等的总括术语…*
随着人工智能的出现，人工智能相关工作的数量急剧增加，对这些职位的需求也在增加。这个简短的指南是对亚马逊不同角色的介绍，这些角色可以引领你进入人工智能领域。我希望你喜欢！
克里斯蒂安·威迪格在 Unsplash 上拍摄的照片
软件开发工程师——我们将从这里最明显的角色开始。亚马逊名下有许多团队，尤其是亚马逊网络服务(AWS)服务团队。成为亚马逊的软件开发工程师并不是做 AI 工作的保证，但如果你已经是该行业的开发人员，这是最简单的方法。亚马逊有许多团队正在推进人工智能的边界。仅仅在 AWS 网站上快速搜索一下，就有 19 个服务团队列在“机器学习”之下。软件工程师负责构建和部署支持 AWS 的最先进平台。职责可能包括开发服务于数十亿日常请求的平台，或者深入系统以优化性能和可维护性。
以亚马逊公开发布的软件开发工作中的这个片段为例
“作为亚马逊人工智能团队的一名机器学习软件开发工程师，你将设计和开发快速、高效、高度可扩展的深度学习算法，应用于挑战日常用例问题。你将与亚马逊人工智能领域的高级科学家和工程师合作，开发健壮可靠的高质量软件。”
与大多数软件开发工程角色一样，这些职位的需求可能会有所不同。需要本科学历才能闯入 FAANG 的日子已经一去不复返了，只要你有扎实的同等经验和一个缺德的好程序员就能进去。拥有硕士或博士学位可以帮助你在更高的水平上起步，前提是你符合要求。
研究科学家与应用科学家- 这些角色是亚马逊的职位令人困惑的地方。亚马逊的 T2 研究科学家 T3 与谷歌或脸书的研究科学家 T5 不同。在亚马逊，相应的职位是应用科学家。亚马逊的研究科学家或应用科学家通常由拥有计算机科学、数学、统计学或相关领域硕士或博士学位的人担任。虽然研究人员和应用科学家之间的学位要求非常相似，但当涉及到对编码的预期熟练程度时，他们的地位是不同的。
亚马逊的一名研究科学家有望在模拟中设计和开发系统原型。这些原型通常会交给应用科学家来实现。应用科学家需要通过入门级软件开发工程师的编码栏，而研究科学家则不需要。这并不意味着研究科学家不会有任何技术问题，只是不期望研究科学家具有与应用科学家相同的编码能力。应用科学家被期望与研究科学家一起开发新的模型和算法，但是然后采用研究科学家开发的原型并大规模实现它们。亚马逊是关于规模的，这种大规模部署的能力是应用科学家和研究科学家之间的关键区别。作为亚马逊招聘流程的一部分，如果你面试的是一个应用科学家的职位，并且符合除了入门级编码栏以外的所有要求，你仍然可以被聘为研究科学家。所以不要害怕！如果你渴望成为一名应用科学家，但仍在提高你的编程技能，那么在进入应用科学家角色之前，研究科学家职位是发展这些技能的一个很好的方式*。
*请注意，虽然这些是亚马逊研究和应用科学家角色的一般准则，但它们绝不是这些角色的员工的指示。许多研究科学家都是出色的程序员，他们的职责和应用科学家一样。
人工智能相关服务团队
如上所述，目前 AWS 有超过 19 个平台与人工智能相关。这里有几个让你开始:
亚马逊 SageMaker 一个大规模构建、训练、部署机器学习模型的平台。
Amazon Lex 构建和部署聊天机器人。
亚马逊 Rekognition 分析图像和视频(比如面部识别)。
亚马逊翻译 自然准确的机器翻译。
***我希望这篇指南能给亚马逊人工智能领域的各种角色一些启发。请随时留下任何反馈。
大数据连接指南— Python、SQL、Pandas、Spark、Dask
如何以最佳方式连接大数据集—多种方法指南
大数据——Patrick linden Berg 在 Unsplash 上拍摄的照片
有许多方法可以旋转磁盘、切鱼片或处理大数据，这里有一个快速指南。
样本数据集
Kaggle 电影数据库[8]—45，000 部电影的 2，600 万个评级，数据分布在 5 个文件中:
Foostack。人工智能
要找到电影的最高平均评分，您需要加入链接到元数据到评分:
SELECT m.title，avg(r . rating)FROM links l INNER JOIN to metas m ON m . imdbid = l . imdbid INNER JOIN to ratings ON r . movie id = l . movie id GROUP BY m . title count(r . rating)> 2 且 avg(r.rating) > 4.5
老式 SQL RDBMS
经典的方法是加载一个数据库，索引并运行前面提到的 SQL(或使用下面的经典 SQL):
从链接 l，metas m，ratings r 中选择 m.title，avg(r.rating)其中 m.imdbId=l.imdbId 和 r . movie id = l . movie id GROUP BY m . title 具有 count(r.rating) > 2 和 avg(r.rating) > 4.5
对于某些平台变体，RDBMS 中的连接有三种主要方式:
- 嵌套循环— 对于表 A 中的每一行，查找表 B 中的匹配键。B 上的索引使得查找为 O(Alog B)，否则连接为慢速— O(AB)。
- Hash-Join — 通过查找键构建表 B 的散列/映射，使得连接查找非常快速— O(A*1)
- 合并-排序 —对两个表进行排序，并在一次通过中合并，除非预先排序，否则速度不会很快—O(A+B+A log A+B log B)→O(A log A+B log B)
使用 Sqlite3 [1]—创建数据库、表和加载非常简单:
SQLite3 表加载/设置
用加载和查询 26m 行数据需要大约 10 分钟(也许我们可以合并- 调整前两步…
- 从 CSV/磁盘加载— 35 秒
- 插入数据库— 8 分钟
- 添加索引— 30 秒
- 按查询分组— 20 秒
您还可以使用 sqlite3 命令行来测试和查看查询执行计划，如下所示。在联接列上添加一些额外的索引后，我们的目标查询大约需要 21 秒来执行。
SQLite 查询执行(来自 cmdline 工具)
使用 SQL 数据库是可扩展的，但是很老派。接下来我们将尝试潮人技巧。
python——终极黑客
我们可以省去数据库开销，直接用 Python 编写数据加载和连接&这很麻烦:
自定义 python 合并(NL 连接)
“merge()”是一个没有索引的嵌套循环连接。该循环必须扫描 metas 和链接表以获得每个评级(26m * 50k *2)。10 万条评论只需要 5 分钟，所以 2600 万条评论将永远不会结束…
“merge_wmap()”是一个散列连接— 我们为元和链接构建一个映射，从而获得 O(n*1)的性能。连接 26m 排只需 3 秒！
使用 hashmap 查找的自定义 python NL 连接
我没有实现分组过滤——这相对较快(需要对 26m 的行结果进行排序-扫描-合并)—我估计加载和处理的总时间为0:53
- 将原始 CSV 加载到阵列— 35 秒
- 手动合并索引— 3 秒
- 手动分组和过滤— 15 秒(TBD～估计值)
生蟒速度快但是丑。全速你的本地电脑和完全控制你所有的错误。
熊猫数据帧拯救行动
Pandas[2]是 Python 上用于数据准备的事实上的包。速度极快且易于使用，我们可以用最少的代码进行加载、连接和分组:
熊猫加入例子
熊猫很聪明。您不需要预定义散列或索引，它似乎可以动态生成优化连接所需的内容。最大的限制是它存在于单个机器上。**处理 26m 行的时间约为 0:17，**代码更少，无需外部系统(数据库、集群等)。
- 将 3 个 csv 加载到数据帧— 5 秒
- 连接 3 个数据帧— 8 秒
- 加入、分组和过滤— +4 秒
熊猫文件加载比我的自定义 py 快得多，35 秒对 5 秒！这表明不要做黑客，使用库。理论上，Pandas 是单线程/进程(在我的 TaskManager 上看起来不像),因此数据集的大小受到你的电脑内存的限制。
尽管如此——Pandas 是处理中小型数据的终极方式——但是我们想要 大数据 ！
火花簇 FTW(为了胜利)
SQL 很棒，但并行性和破解能力有限。Python 和 Pandas 超级灵活，但是缺乏可伸缩性。Apache Spark [5]实际上是在大数据上并行化内存操作的方式。
Spark 有一个名为 DataFrame *的对象(是的另一个！)*这就像一个熊猫的数据框架，甚至可以加载/窃取数据(尽管你可能应该通过 HDFS 或云加载数据，以避免大数据传输问题):
最小火花码(本地独立设置)
我写了两个 Spark join 方法。两者并行运行。默认模式(第 15 行)将对您的数据进行分区，并在集群节点间移动(传播)。后面的“广播”模式(第 18 行)复制一次较小的表，只对大表内容进行分区和发送。使用较小的连接表，广播模式会快得多。
Spark 在 workers 节点(JVM——设置为 8，以匹配我的 CPU 内核数)之间划分工作，分而治之，回到聚合中。火花代码和结果输出如下:
df.groupBy('title').agg(func.mean('rating').
alias('avg_rating'),func.count('rating').
alias('r_count')).filter('r_count >2').
filter('avg_rating > 4.5').show()
Spark 对 26m 行的连接和分组操作的输出
绩效总结
(来自我笔记本电脑的非实验室认证结果)
首先记下将 3 个数据集连接在一起的运行时间:
连接的性能
令人惊讶的是，原始 Python 解决方案是最快的？黑黑！
顶级电影团体(包括 Spark)的最终结果:
连接和分组+过滤的性能
外卖:
- 熊猫是非凡的快速和高效，在这一点上，你有核心记忆。在某个时候，Python/Pandas 会耗尽内存并崩溃。
- Spark 是一个很好的扩展解决方案，尽管集群管理可能比较棘手。内存分布式处理、分区作业和数据+分区存储策略(HDFS 或其他)是正确的方向。
- RDBMS 是可靠的，但是在移动数据和处理方面有伸缩限制
在接下来的章节中会有更多关于 Spark 的内容…糟糕，我忘了 Dask (原生 Python 集群)——也许下次吧。
SQLite3 资源配置文件
只有 2 个真正活跃的内核，额外的 I/O(尽管大部分都被缓存)
熊猫资源概况
对于我所认为的单线程/任务进程，CPU 利用率出奇的高？
Spark 资源配置文件(8 个工人，10 个分区)
所有内核都利用了 8 个工作线程—良好的 CPU 和内存分配
以上数据来自我的 MSFT Surface 笔记本电脑 3-i7/16gb/256 GB 固态硬盘
参考和启示
[0]测试代码的完整源代码(不仅仅是 gist)——Doug foo 的 GitHub
[1] SQLite Python 指南— 官方 Python 文档
[2]熊猫指南— 10 分钟教程
[3]有点老的分析 SQLite vs Pandas — 韦斯·麦金利博客
[4] Spark Joins DB Deck— 数据块演示
[5]关于 Spark 的精彩详细介绍—a . Ialenti 撰写的 TDS 文章
[6] PYArrow 用于 Spark 中的快速数据帧加载— Bryan Cutler IBM
[7]在 10 分钟内安装 PySpark Win—TDS 文章作者 Uma G
[8]电影评论文件— Kaggle 数据集
YOLO 汽车检测指南
YOLO 算法的深入概念——包围盒、非最大值抑制和 IOU。
使用 YOLOv3 的实时对象检测
1.问题陈述
你正在研究一辆自动驾驶汽车。作为这个项目的一个关键组成部分，你想首先建立一个汽车检测系统。为了收集数据，你在汽车引擎盖上安装了一个摄像头，当你开车时，它每隔几秒钟就拍摄一次前方道路的照片。
在硅谷开车时用车载相机拍摄的照片。
感谢 drive.ai 提供本数据集。
你已经将所有这些图像收集到一个文件夹中，并通过在你找到的每辆车周围绘制边框来标记它们。下面是一个边界框的示例:
图 1:边界框的定义
如果您想要对象检测器识别 80 个类别，您可以将类别标签 c 表示为 1 到 80 之间的整数，或者表示为 80 维向量(80 个数字)，其中一个分量为 1，其余为 0。在本文中，我将使用这两种表示法，这取决于哪种表示法对特定步骤更方便。
2.YOLO
“你只看一次”(YOLO) 是一种流行的算法，因为它实现了高精度，同时还能够实时运行。这种算法“只看一次”图像，因为它只需要一次通过网络的前向传播来进行预测。在 非最大抑制 之后，输出识别的对象和边界框。
2.1 模型细节
输入和输出
- 输入是一批图像，每幅图像的形状为( m，608，608，3 )。
- 输出是一个包含已识别类的边界框列表。每个边界框由 6 个数字表示——如上所述的 pc 、 bx 、 by 、 bh 、 bw 、 c — 。如果你将 c 展开成一个 80 维的向量，那么每个边界框由 85 个数字表示。
锚箱
- 通过探索训练数据来选择代表不同类别的合理的高/宽比，从而选择锚定框。
- 锚盒尺寸为编码中倒数第二个尺寸: m ， nH ， nW ，锚，类。
- YOLO 架构为:图像( m，608，608，3 ) - >深度 CNN - >编码( m，19，19，5，85 )。
编码
让我们更详细地看看这种编码代表了什么。
图 2:YOLO 的编码架构
如果对象的中心/中点落入网格单元，则该网格单元负责检测该对象。
由于我们使用 5 个锚盒，因此每个19×19单元编码了关于 5 个盒的信息。锚定框仅由其宽度和高度定义。
为简单起见，我们将展平形状的最后两个维度( 19，19，5，85 )编码。所以深度 CNN 的输出是( 19，19，425 )。
图 3:展平最后两个尺寸
班级成绩
现在，对于(每个单元格的)每个盒子，我们将计算下面的元素乘积，并提取盒子包含某个类的概率。
类得分是score _ cᵢ=p _ c * cᵢ——存在一个对象的概率 p_c 乘以该对象是某类的概率 cᵢ.
图 4:找出每个方框检测到的类别
在图 4 中，假设对于盒子 1(单元格 1)，物体存在的概率为 p₁ = 0.60。因此，有 60%的可能性，一个对象存在于框 1(单元格 1)。
物体是类别 3(汽车)的概率是 c₃ = 0.73。
方框 1 和类别 3 的分数为score _ c₁,₃= 0.60 * 0.73 = 0.44。
假设我们计算了方框 1 中所有 80 个类别的分数，发现汽车类别(类别 3)的分数最大。因此，我们将把分数 0.44 和类别 3 分配给这个框 1。
可视化类
这里有一种方法可以形象化 YOLO 在图像上预测的东西:
- 对于每一个 19 x 19 网格单元，找到概率得分的最大值，即在 80 个类中取一个最大值，5 个锚框中的每一个都取一个最大值)。
- 根据网格单元认为最有可能是什么对象来给网格单元着色。
这样做的结果是这幅图:
图 19 x 19 网格单元中的每一个都根据在该单元中哪个类具有最大的预测概率而被着色。
注意，这种可视化并不是进行预测的 YOLO 算法本身的核心部分；这只是可视化算法中间结果的一种很好的方式。
可视化边界框
另一种可视化 YOLO 输出的方式是绘制它输出的边界框。这样做的结果是这样的可视化:
图 6 :每个单元格给你 5 个盒子。总的来说，该模型仅通过查看图像一次(通过网络向前传递一次)就预测了 19×19×5 = 1805 个盒子！不同的颜色代表不同的类别。
非最大抑制
在上图中，我们只绘制了模型分配了高概率的盒子，但这仍然是太多的盒子。我们希望将算法的输出减少到更少数量的检测对象。
为此，我们将使用非最大抑制。具体来说，我们将执行以下步骤:
- 去掉分数低的盒子。意思是，盒子对检测一个类不是很有信心；要么是由于任何物体的低概率，要么是这个特殊类的低概率。
- 当几个框相互重叠并检测同一对象时，仅选择一个框。
2.2 利用类别分数的阈值进行过滤
我们将首先通过设定阈值来应用过滤器。我们想摆脱任何盒子的类“分数”小于一个选择的阈值。
该模型总共为我们提供了 19 x 19 x 5 x 85 个数字，每个盒子由 85 个数字描述。将( 19，19，5，85 )或( 19，19，425 )维张量重新排列成以下变量是很方便的:
box_confidence:形状张量( 19×19，5，1 )( 19×19，5，1 )，包含 p_c — 在 19x19 单元格中预测的 5 个框中的每一个中，存在某个对象的置信概率。boxes:形状张量( 19×19，5，4 ，包含每个单元格中 5 个盒子的中点和尺寸( bx ， by ， bh ， bw )。box_class_probs:形状张量( 19×19，5，80 )，包含每个单元格 5 个盒子的 80 个类别中的每个类别的“类别概率”( c ₁ ，c ₂ ，…，c ₈₀)。
实现
***yolo_filter_boxes()***
- 按照图 4 中的所述，通过进行元素乘积( p * c) 来计算 box 分数。
- 对于每个盒子，找到具有最大盒子分数的类的索引，以及相应的盒子分数。
- 使用阈值创建遮罩。作为提醒:
([0.9, 0.3, 0.4, 0.5, 0.1] < 0.4)回报:[False, True, False, False, True]。对于您想要保留的盒子，掩码应为True。 - 使用 TensorFlow 对
box_class_scores、boxes和box_classes应用蒙版，过滤掉我们不想要的盒子。你应该只留下你想保留的盒子的子集。
有用的参考资料
2.3 非最大抑制
即使在通过对类分数进行阈值化过滤之后，我们可能仍然会得到许多重叠的盒子。用于选择正确框的第二个过滤器被称为非最大抑制(NMS) 。
图 7 :在本例中，模型预测了 3 辆汽车，但实际上是同一辆汽车的 3 次预测。运行非最大抑制(NMS)将只选择 3 个框中最准确(概率最高)的一个。
非最大值抑制使用一个非常重要的函数，叫做 交集超过并集 ，或者 IoU 。
图 8:Union 上交点的定义。
实现
在这段代码中，我将使用这样的约定，即( 0，0 )是图像的左上角；( 1，0 )是右上角；( 1，1 )是右下角。换句话说，( 0，0 )原点从图像的左上角开始。随着 x 增加，我们向右移动。随着 y 的增加，我们向下移动。
我将使用它的两个角来定义一个盒子:左上角( x₁，y₁ )和右下角( x₂，y₂ )，而不是使用中点、高度和宽度。这使得计算交集变得更加容易。
要计算一个矩形的面积，用它的高度(y₂-y₁)乘以它的宽度(x₂-x₁)。既然( x₁ 、 y₁ )是左上方( x₂、y₂ )是右下方，这些差异应该是非负的。
请随意在纸上画一些例子来从概念上阐明这一点。要找到两个盒子的交集(xi₁，yi₁，xi₂，yi₂ ):
- 交点的左上角( xi₁，yi₁ )通过比较两个盒子的左上角( x₁ ， y₁ )，然后找到具有更靠近右边的x-坐标和更靠近底部的y-坐标的顶点来找到。
- 交点的右下角( xi₂，yi₂ )是通过比较两个盒子的右下角( x₂，y₂ )找到的，然后找到一个顶点的x-坐标更靠近左边，而y-坐标更靠近上面。
- 两个框可能没有交集。如果我们计算的交点坐标最终是一个交点框的右上角和/或左下角，我们可以检测到这一点。另一种思考方式是，如果您计算了高度(y₂—y₁)或宽度(x₂—x₁)并且发现这些长度中至少有一个是负的，那么就没有相交(相交面积为零)。
- 两个框可能在边或顶点相交，在这种情况下，相交面积仍然为零。当计算的交叉点的高度或宽度(或两者)为零时，会出现这种情况。
YOLO 非最大抑制
我们现在准备实施非最大抑制。关键步骤是:
- 选择得分最高的方框。
- 计算此框与所有其他框的重叠，并移除明显重叠的框(
iou> =iou_threshold)。 - 回到步骤 1，重复直到没有比当前选择的盒子分数更低的盒子。
这将删除与所选框有大量重叠的所有框。只有“最好的”盒子保留下来。
实施
**yolo_non_max_suppression()**
参考文件
2.4 完成过滤
是时候实现一个函数了，它接受深度 CNN 的输出(T42 19 x 19 x 5 x 85 维度编码)并使用我们刚刚实现的函数过滤所有的盒子。
实现
该函数获取 YOLO 编码的输出，并使用分数阈值和 NMS 过滤盒子。
有一个实现细节你需要知道。有几种表示盒子的方法，比如通过它们的角或者通过它们的中点和高度/宽度。 YOLO 使用以下函数在不同时间在几种格式之间转换:
boxes = yolo_boxes_to_corners(box_xy, box_wh)
它将 YOLO 框坐标( x，y，w，h )转换为框角坐标( x ₁ ，y ₁ ，x ₂ ，y ₂)以适应yolo_filter_boxes的输入。
boxes = scale_boxes(boxes, image_shape)
YOLO 的网络被训练运行在 608 x 608 的图像上。如果您在不同尺寸的图像上测试该数据，例如，具有 720 x 1280 图像的汽车检测数据集，该步骤将重新缩放这些方框，以便它们可以绘制在原始 720 x 1280 图像的顶部。
2.5 概述
- 输入图像( 608，608，3 )
- 输入图像通过 CNN，产生( 19，19，5，85 )维输出。
- 展平最后两个维度后，输出的是一个体积形状( 19，19，425 )。输入图像上的19×19网格中的每个单元给出 425 个数字:425 = 5×85，因为每个单元包含 5 个框的预测，对应于 5 个锚框；85 = 5 + 80 其中 5 是因为( pc，bx，by，bh，bw )有 5 个数，80 是我们想要检测的类的个数。
- 然后，我们基于分数阈值化— 丢弃已经检测到分数小于阈值的类的盒子，以及非最大值抑制— 计算联合**【IOU】上的交集并避免选择重叠的盒子，来仅选择几个盒子。**
- 这给了你 YOLO 的最终输出。
3.在图像上测试 YOLO 预训练模型
在这一部分中，我们将使用一个预训练的模型，并在汽车检测数据集上进行测试。我们需要一个会话来执行计算图并评估张量:
sess = K.get_session()
3.1 定义类别、锚点和图像形状
回想一下，我们试图检测 80 个类，并且使用了 5 个锚盒。我们将读取存储在两个文件中的 80 个类和 5 个盒子的名称和锚点— coco_classes.txt 和yolo_anchors.txt(更多信息请参见 Github repo)。汽车检测数据集有 720 x 1280 图像，这些图像被预处理成 608 x 608 图像。
3.2 加载预训练模型
训练一个 YOLO 模型需要很长的时间，并且对于大范围的目标类需要一个相当大的标签包围盒数据集。因此，我们将加载一个现有的预先训练好的 Keras YOLO 模型。(更多信息见 Github repo)。这些重量来自 YOLO 官方网站，并由艾伦·泽勒纳编写的函数转换而来。参考文献在本文末尾。从技术上来说，这些是来自 YOLOv2 模型的参数，但在本文中我们将简称它为 YOLO 。
yolo_model = load_model(“model_data/yolo.h5”)
这将加载一个经过训练的 YOLO 模型的权重。你可以在 Github repo 里的笔记本里看看模型包含的图层汇总。
提醒:该模型将预处理后的一批输入图像(shape: ( m，608，608，3 )转换成形状张量( m，19，19，5，85 )，如图图 2 所示。
3.3 将模型的输出转换为可用的边界框张量
yolo_model的输出是一个( m，19，19，5，85 )张量，需要经过非平凡的处理和转换。下面的代码为我们完成了这项工作:
yolo_outputs = yolo_head(yolo_model.output, anchors, len(class_names))
如果你很好奇yolo_head是如何实现的，可以在 Github repo 的文件 ‘keras_yolo.py’ 中找到函数定义。
将yolo_outputs加入我们的图表后。这组 4 个张量已准备好用作yolo_eval功能的输入。
3.4 过滤箱
yolo_outputs以正确的格式给了我们所有yolo_model的预测框。我们现在准备通过调用之前实现的yolo_eval来过滤和选择最好的盒子。
scores, boxes, classes = yolo_eval(yolo_outputs, image_shape)
3.5 在图像上运行图形
让欢乐开始吧。我们创建了一个图表，可以总结如下:
- yolo_model.input 给
yolo_model。该模型用于计算输出 yolo_model.output 。 - yolo_model.output 由
yolo_head处理。它给你 yolo_outputs 。 - yolo_outputs 经过过滤功能
yolo_eval。它输出你的预测:scores, boxes, classes.
实施
**predict()**
**predict()**运行图形以测试图像上的 YOLO 。你需要运行一个 TensorFlow 会话，让它计算scores, boxes, classes。
下面的代码也使用了下面的函数:
image, image_data = preprocess_image("images/" **+** image_file, model_image_size = (608, 608))
哪些输出:
- 图像:用于绘制框的图像的 python (PIL)表示。你不需要使用它。
- image_data:表示图像的 numpy 数组。这将是 CNN 的输入。
在测试图像上测试功能:
out_scores, out_boxes, out_classes = predict(sess, “test.jpg”)
test.jpg 上的输出示例
我们刚刚运行的模型实际上能够检测到coco_classes.txt中列出的 80 个不同的类。通过下载 Github repo 中的文件，您可以随意尝试使用您自己的图像。
如果我们在所有图像上运行 for 循环会话。下面是我们将得到的结果:
4.结论
- YOLO 是一个快速准确的最先进的物体检测模型。
- 它通过 CNN 运行输入图像，CNN 输出一个 19 x 19 x 5 x 85 尺寸的体积。
- 编码可以被视为一个网格，其中每个 19 x 19 单元格包含关于 5 个盒子的信息。
- 使用非最大抑制过滤所有框。具体来说，使用分数阈值检测类的概率以仅保留准确(高概率)的框，以及交集超过并集(IoU) 阈值以消除重叠的框。
- 因为从随机初始化的权重中训练 YOLO 模型是非常重要的，并且需要大的数据集以及大量的计算，所以我们在这个练习中使用了先前训练的模型参数。如果您愿意，也可以尝试用自己的数据集微调 YOLO 模型，尽管这将是一项相当重要的工作。
引用和参考文献
特别感谢deep learning . ai。
所有图由 deeplearning.ai 提供。
本文提出的观点主要来自于 YOLO 的两篇论文。这里的实现也从 Allan Zelener 的 GitHub 库中获得了很多灵感并使用了很多组件。本次训练中使用的预训练重量来自 YOLO 官方网站。
- 约瑟夫·雷德蒙、桑托什·迪夫瓦拉、罗斯·吉斯克、阿里·法尔哈迪— 你只看一次:统一的实时物体检测 (2015)
- 约瑟夫·雷德蒙，阿里·法尔哈迪— YOLO9000:更好、更快、更强 (2016)
- 艾伦·泽伦纳— 亚得 2K:又一个黑暗之网 2 Keras
- https://pjreddie.com/darknet/yolo/ YOLO 官方网站()
汽车检测数据集:Drive.ai 样本数据集(由 drive . ai 提供)在知识共享署名 4.0 国际许可下获得许可。
Github 回购:https://github.com/TheClub4/car-detection-yolov2
不平衡数据集分类指南
理解和纠正阶级不平衡的教程
不平衡中的平衡平衡什么是不平衡 —阿马杜·贾鲁呸
**免责声明:**这是一个关于处理不平衡数据集的综合教程。虽然这些方法对于多类分类仍然有效，但为了简单起见，本文的主要焦点将放在二分类上。
简介
任何经验丰富的数据科学家或统计学家都知道，数据集很少均匀分布在感兴趣的属性之间。假设我们的任务是发现欺诈性信用卡交易——很自然，这些交易中的绝大多数都是合法的，只有极小一部分是欺诈性的。类似地，如果我们测试个体的癌症或病毒(包括新冠肺炎病毒)的存在，阳性率将(希望)只是被测试者的一小部分。更多例子包括:
- 一家电子商务公司预测哪些用户将在其平台上购买商品
- 一家制造公司分析生产材料的缺陷
- 垃圾邮件过滤试图区分“火腿”和“垃圾邮件”
- 入侵检测系统检查网络流量中的恶意软件签名或非典型端口活动
- 预测客户流失率的公司
- 在银行或金融机构关闭特定账户的客户数量
- 电信设备故障预测
- 从卫星图像探测石油泄漏
- 保险风险建模
- 硬件故障检测
来自不利类别的数据点通常要少得多。这是不幸的，因为我们非常关心避免这个类的错误分类。
事实上，在分类任务中很少有完全平衡的数据。通常，我们感兴趣分析的项目本质上是“罕见”事件，因为它们非常罕见，因此难以预测。这给有抱负的数据科学家带来了一个奇怪的问题，因为许多数据科学计划没有正确解决如何处理不平衡的数据集，因为它们在行业中非常普遍。
数据集何时变得“不平衡”？
不平衡数据集的概念有点模糊。通常，两个变量之间具有 49–51 分割的二元分类数据集不会被视为不平衡。然而，如果我们有一个 90-10 分割的数据集，对我们来说这显然是一个不平衡的数据集。显然，不平衡数据的边界位于这两个极端之间。
从某种意义上说,“不平衡”一词是一个主观的词，由数据科学家来判断。一般来说，当标准分类算法(固有地偏向多数类(更多细节见上一篇文章)由于多数类的偏向而返回次优解决方案时，数据集被认为是不平衡的。数据科学家可能会查看 45–55 分割的数据集，并判断这已经足够接近，不需要采取措施来纠正不平衡。然而，数据集变得越不平衡，就越需要校正这种不平衡。
在一个概念学习问题中，如果数据集包含的一个类别的例子比另一个类别多得多，那么就说数据集呈现了类别不平衡。
因此，这些分类器倾向于忽略小类，而专注于准确分类大类。
假设你在网飞工作，负责确定哪些客户流失率(客户“流失”意味着他们将停止使用你的服务或产品)。
在一个理想的世界中(至少对于数据科学家来说)，我们的训练和测试数据集将接近完全平衡，大约 50%的数据集包含会流失的个人，而 50%不会。在这种情况下，90%的准确度将或多或少地表示正分类组和负分类组的 90%的准确度。我们的误差将在两组中平均分配。此外，我们在两个类中有大致相同的点数，这从大数定律告诉我们减少了类中的总体方差。这对我们来说很好，在这种情况下，准确性是一个信息指标，我们可以不受阻碍地继续我们的分析。
在二进制响应变量中对半分割的数据集。这个例子中没有多数类。
正如你可能已经怀疑的那样，大多数已经为网飞付费的人没有 50%的机会每月停止他们的订阅。事实上，会流失的人的比例相当小，接近 90-10 的比例。这种数据集不平衡的存在是如何使问题复杂化的？
假设 90-10 的比例，我们现在有一个非常不同的数据故事要讲。将这些数据交给算法而不做任何进一步的考虑可能会导致接近 90%的准确率。这看起来很不错，对吧？这和我们以前得到的差不多。如果你尝试将这种模型投入生产，你的老板可能会不高兴。
90–10 分割的不平衡数据集。假阳性会比假阴性大很多。由于数据点较少，少数集合中的方差会更大。多数类将支配算法预测，而不对不平衡进行任何校正。
给定多数类(90%类)的流行，我们的算法将可能回归到多数类的预测。该算法可以通过任意预测多数类每次出现来非常接近地最大化其准确性(我们选择的评分标准)。这是一个微不足道的结果，提供了接近零的预测能力。
(左)正负类项目数相同的平衡数据集；在这种情况下，假阳性和假阴性的数量大致相等，导致很少的分类偏差。(右图)一个不平衡的数据集，其中大约 5%的样本属于负类，95%的样本属于正类(这可能是为网飞付费并决定在下一个付费周期退出的人数)。
当数据不平衡和/或不同错误的成本差异显著时，预测准确性(一种评估分类器性能的常用选择)可能不合适。
从视觉上看，该数据集可能如下所示:
默认情况下，机器学习算法假设数据是平衡的。在分类中，这对应于每个类的相对数量的实例。分类器从平衡分布中学习得更好。纠正失衡取决于数据科学家，这可以通过多种方式完成。
不同类型的不平衡
我们已经清楚地表明，不平衡数据集对标准数据集有一些额外的挑战。更复杂的是，在一个数据集中可能会出现不同的类型的不平衡。
(1)课间
当每个类别中包含的数据点数量不平衡时，就会出现类别间不平衡。这方面的一个例子如下所示:
阶级间不平衡的例证。我们有大量红色类的数据点，但白色类的数据点相对较少。
这方面的一个例子是乳房 x 线照相数据集，它使用称为乳房 x 线照片的图像来预测乳腺癌。考虑与阳性和阴性癌症诊断相关的乳房 x 线照片的数量:
绝大多数样本(> 90%)为阴性，而相对较少(<10%) are positive.
Note that given enough data samples in both classes the accuracy will improve as the sampling distribution is more representative of the data distribution, but by virtue of the law of large numbers, the majority class will have inherently better representation than the minority class.
(2)类内
当数据集平衡了类间数据，但其中一个类在某些区域不具有代表性时，就会出现类内不平衡。这方面的一个例子如下所示:
阶级内部不平衡的例证。这两个类别都有大量的数据点，但左上角白色类别中的数据点数量非常稀少，这可能导致与这些区域中预测的类别间不平衡类似的复杂性。
(3)内在和外在
一个内在不平衡是由于数据集的性质，而外在不平衡与时间、存储和其他限制数据集或数据分析的因素有关。内在特征相对简单，是我们常见的，但外在不平衡可以单独存在，也可以增加数据集的不平衡。
例如，公司经常使用入侵检测系统来分析进出网络的数据包，以检测恶意活动的恶意软件。根据您是分析所有数据还是仅分析通过特定端口或特定设备发送的数据，这将显著影响数据集的不平衡(大多数网络流量可能是合法的)。类似地，如果与可疑恶意行为相关的日志文件或数据包通常被存储，而正常日志没有被存储(或者只存储选定的几种类型)，那么这也会影响数据集的不平衡。类似地，如果日志仅在正常工作日(比如晚上 9-5 点)存储，而不是 24 小时，这也会影响不平衡。
失衡的进一步复杂化
不平衡的数据集增加了更多的困难。首先，我们有类重叠。这并不总是一个问题，但经常会在不平衡的学习问题中出现，并引起头痛。下面的数据集中显示了类重叠。
类重叠的例子。一些正数据点(星形)与负数据点(圆形)混杂在一起，这将导致算法构建不完美的决策边界。
类别重叠发生在正常的分类问题中，那么这里的附加问题是什么呢？在重叠区域中更多表示的类倾向于通过基于全局学习(在完整数据集上)的方法更好地分类。这是因为该算法能够更好地了解多数类的数据分布。
相比之下，在这样的区域中较少被代表的类倾向于通过局部方法被更好地分类。如果以 k-NN 为例，随着 k 值的增大，它变得越来越全局化，越来越局部化。可以看出，k 值较低时，少数数据集的性能较好，而 k 值较高时，性能较低。多数类不会出现这种精度变化，因为它在所有点上都有很好的表现。
这表明地方方法可能更适合研究少数民族阶层。对此进行校正的一种方法是 CBO 方法。CBO 方法使用基于聚类的重采样来识别“罕见”病例，并对它们分别进行重采样，以避免在已有假设中产生小的析取项。这是一种过采样方法，我们将在下一节详细讨论。
CBO 方法。一旦每一类的训练样本被聚类，过采样就开始了。在多数类中，除了最大的一个聚类之外，所有聚类都被随机过采样，以便获得与最大聚类相同数量的训练样本。
校正数据集不平衡
有几种技术可以控制数据集的不平衡。处理不平衡数据集的技术主要有两种:采样方法和成本敏感方法。
其中最简单和最常用的是采样方法，称为过采样和欠采样，我们将对此进行更详细的讨论。
过采样/欠采样
简单地说，过采样涉及为少数类生成新的数据点，而欠采样涉及从多数类中移除数据点。这在一定程度上降低了数据集中的不平衡程度。
欠采样是什么样子的？我们不断地移除非常接近的相似样本，直到两个类别具有相同数量的数据点。
**欠采样。**假设您正在分析欺诈交易的数据集。大多数交易都不是欺诈性的，这造成了一个根本不平衡的数据集。在欠采样的情况下，我们将从多数类中获取较少的样本，以帮助减少这种不平衡的程度。
欠采样是个好主意吗？许多统计研究人员建议使用欠采样，但只有在欠采样类上有足够多的数据点时，欠采样才有用。此外，由于多数类最终将与少数类具有相同的点数，分布的统计特性在某种意义上将变得“更松散”。然而，我们没有通过添加人工数据点来人为地扭曲这种方法的数据分布。
欠采样插图。在试图增加数据分布的稀疏性时，移除非常接近的相似样本。
过采样是什么样子的？简言之，与欠采样相反。我们人为地向数据集中添加数据点，以平衡每个类中的实例数量。
**过采样。**在过采样的情况下，我们将从少数类中进行过采样，以帮助降低这种不平衡的程度。
我们如何生成这些样本？最常见的方法是生成在数据空间中接近现有样本或位于两个样本之间的点，如下图所示。
过采样示意图。
正如您可能已经怀疑的那样，添加虚假数据点有一些不利之处。首先，您有过度拟合的风险，尤其是如果您对有噪声的点这样做，您最终会通过添加增强的测量来加剧这种噪声。此外，随机添加这些值也会给我们的模型带来额外的噪声。
SMOTE(合成少数过采样技术)
幸运的是，我们不必为了过采样而编写随机生成数据点的算法。相反，我们可以使用 SMOTE 算法。
SMOTE 是如何工作的？SMOTE 根据现有数据点的局部密度及其与其他类的边界，在现有数据点之间生成新样本。它不仅执行过采样，而且可以随后使用清理技术(欠采样，稍后会详细介绍)来最终消除冗余。下面是研究类数据时 SMOTE 如何工作的图示。
SMOTE 功能的说明。左侧的实例是孤立的，因此被算法视为噪声。在其附近没有生成额外的数据点，或者，如果有的话，它们将非常接近奇点。中间和右侧的两个聚类有几个数据点，表明这些点不太可能对应于随机噪声。因此，更大的聚类(经验数据分布)可以由算法绘制，由此可以产生额外的样本。
SMOTE 的算法如下。对于每个少数民族样本:
–找到其 k 个最近的少数民族邻居
–随机选择 j 个邻居
–沿着连接少数样本及其 j 个选定相邻样本的线随机生成合成样本(j 取决于所需的过采样量)
知情与随机过采样
使用少数类的随机过采样(替换)具有使少数类的决策区域非常具体的效果。在决策树中，这将导致新的分裂，并经常导致过度拟合。SMOTE 的知情过采样概括了少数类的决策区域。结果，学习了较大的和不太具体的区域，因此，关注少数类样本而不会导致过度拟合。
SMOTE 的弊端
过度概括。SMOTE 的程序可能是危险的，因为它盲目地概括少数民族地区，而不考虑多数民族阶层。这种策略在高度偏斜的阶级分布的情况下特别成问题，因为在这种情况下，少数阶级相对于多数阶级来说非常稀疏，从而导致更大的阶级混合机会。
**不灵活。**SMOTE 生成的合成样本数量是预先固定的，因此不允许在重新平衡速率上有任何灵活性。
另一个潜在的问题是 SMOTE 可能会在多数类空间中引入过多的人为少数类示例。这个缺点可以通过混合来解决:结合 SMOTE 和欠采样算法。其中最著名的就是 Tomek 链接 。Tomek 链接是相对类的实例对，它们是自己最近的邻居。换句话说，它们是非常接近的对立实例对。
Tomek 的算法寻找这样的配对，并移除配对的多数实例。这个想法是为了澄清少数民族和多数民族阶级之间的界限，使少数民族地区更加分明。Scikit-learn 没有内置的模块来做到这一点，尽管有一些独立的包(例如 TomekLink 、不平衡学习)。
因此，Tomek 的算法是一种欠采样技术，充当 SMOTE 的数据清理方法，以调节冗余。正如您可能已经怀疑的那样，有许多额外的欠采样技术可以与 SMOTE 结合使用来执行相同的功能。这些功能的完整列表可以在不平衡学习文档的功能部分找到。
另一个示例是编辑最近邻(ENN)。ENN 删除其类标签不同于至少两个其邻居的类的任何例子。ENN 比托梅克链接删除了更多的例子，也可以从两个类中删除例子。
SMOTE 的其他更细致的版本包括 Borderline SMOTE、SVMSMOTE 和 KMeansSMOTE，与 SMOTE 配合使用的欠采样技术的更细致的版本是压缩最近邻(CNN)、重复编辑最近邻和实例硬度阈值。
成本敏感学习
我们已经讨论了抽样技术，现在准备讨论成本敏感的学习。在许多方面，这两种方法是相似的——主要区别在于，在成本敏感学习中，我们通过改变单个样本的相对权重来执行欠采样和过采样。
**上升流。**上加权类似于过采样，其工作原理是增加一个类的权重，同时保持另一个类的权重为 1。
**降体重。**向下加权类似于欠采样，其工作原理是降低一个类的权重，同时保持另一个类的权重为 1。
如何使用 sklearn 实现这一点的一个例子是通过sklearn.utils.class_weight函数并应用于任何 sklearn 分类器(以及 keras 内)。
from sklearn.utils import class_weight
class_weights = class_weight.compute_class_weight('balanced', np.unique(y_train), y_train)
model.fit(X_train, y_train, class_weight=class_weights)
在这种情况下，我们已经将实例设置为“平衡的”，这意味着我们将根据它们的相对点数来处理这些实例，使其具有平衡的权重——这是我的建议，除非您有自己设置值的充分理由。如果您有三个类，并且希望将其中一个类的权重增加 10 倍，将另一个类的权重增加 20 倍(因为数据集中的这些点比多数类少 10 倍和 20 倍)，那么我们可以将其重写为:
class_weight = {0: 0.1,
1: 1.,
2: 2.}
一些作者声称，成本敏感学习比随机或定向过采样或欠采样稍微更有效，尽管所有方法都是有帮助的，并且定向过采样在功效上接近成本敏感学习。就我个人而言，当我在处理机器学习问题时，我会使用成本敏感学习，因为它更容易实现并与个人沟通。然而，使用采样技术可能还有其他方面可以提供我所不知道的更好的结果。
评估指标
在这一节中，我概述了几个可用于分析分类器性能的指标，这些分类器被训练来解决二元分类问题。这些包括(1)混淆矩阵，(2)二进制分类度量，(3)接收器操作特性曲线，和(4)精度-召回曲线。
混淆矩阵
不管你从它的名字中获得了什么，混淆矩阵是绝对令人困惑的。混淆矩阵是评估二元分类器的最基本形式。给定我们的分类器的预测输出和真实的响应变量，混淆矩阵告诉我们每个类别有多少预测是正确的，有多少是不正确的。混淆矩阵提供了基于这些因素的分类器性能的简单可视化。
这是混淆矩阵的一个例子:
希望这显示的相对清晰。TN 单元格告诉我们真阳性的数量:我预测为阳性的阳性样本的数量。
TP 单元格告诉我们真正阴性的数量:我预测为阴性的阴性样本的数量。
FP 细胞告诉我们假阳性的数量:我预测为阳性的阴性样本的数量。
FN 细胞告诉我们假阴性的数量:我预测为阳性的阳性样本的数量。
这些数字非常重要，因为它们构成了接下来讨论的二元分类度量的基础。
二元分类度量
二元分类有过多的单值度量。因此，此处仅介绍一些最常用的方法及其不同的公式，更多详细信息可在 sklearn 文档中找到，以及它们与混淆矩阵和 ROC 曲线的关系(在下一节讨论)此处。
可以说，二元分类最重要的五个指标是:(1)精确度，(2)召回率，(3) F1 分数，(4)准确度，和(5)特异性。
**精度。*精确为我们提供了问题的答案“在我所有的积极预测中，有多少是正确的？”*。如果您有一个正确预测所有阳性类别的算法，但也有很大一部分误报，精度将会很低。为什么称之为精度是有道理的，因为它是我们预测有多“精确”的一个度量。
**回忆。*回忆为我们提供了另一个问题的答案“在所有阳性样本中，我正确预测的比例是多少？”*。我们现在对假阴性感兴趣，而不是假阳性。这些是我们的算法遗漏的项目，并且通常是最严重的错误(例如，未能诊断出实际上患有癌症的癌症，未能发现恶意软件，或未能发现有缺陷的项目)。在这种情况下,“召回”这个名称也是有意义的，因为我们可以看到算法能够提取多少样本。
应该清楚的是，这些问题虽然相关，但彼此有很大的不同。有可能具有非常高的精度，同时具有低的召回率，反之亦然。例如，如果您每次都预测多数类，那么您会对多数类有 100%的回忆，但是您会从少数类得到很多误报。
要指出的另一个要点是，可以为每个单独的类确定精度和召回率。也就是说，我们可以谈论 A 类的精度，或者 B 类的精度，它们会有不同的值——在这样做的时候，我们假设我们感兴趣的类是正类，而不考虑它的数值。
F1 分数是精确度和召回率的调和平均值，它们的相对权重可以使用参数β 来调整。
**F1 比分。**F1 分数是一个单值指标，通过使用调和平均值(一种奇特的平均类型)结合了精确度和召回率。 β 参数是一个严格的正值，用于描述召回率对精确度的相对重要性。较大的 β 值更强调查全率而不是查准率，而较小的值则不太强调查全率。如果该值为 1，则精确度和召回率的权重相等。
F1 高分意味着什么？这表明精度和召回率都有很高的值，这很好，也是在不平衡数据集上生成功能良好的分类模型时所希望看到的。较低的值表示精确度或召回率较低，可能需要引起关注。良好的 F1 分数通常低于良好的准确性(在许多情况下，0.5 的 F1 分数被认为是非常好的，例如从乳房 x 光片预测乳腺癌)。
**特异性。*简单来说，特异性就是对负值的回忆。它回答了问题“在我所有的负面预测中，有多少是正确的？”*。这在需要检查假阳性的相对比例的情况下可能很重要。
宏观、微观和加权分数
这就是事情变得有点复杂的地方。任何在 sklearn 上钻研过这些指标的人可能都注意到了，我们可以参考 recall-macro 或者 f1 加权分数。
宏观 F1 分数是每个班级 F1 分数的平均值。
如果我们有很多班级，并且我们对每个班级的平均 F1 分数感兴趣，这是非常有用的。如果你只关心一门课的 F1 分数，你可能不需要一个宏观的 F1 分数。
一个微 F1 分数从所有类中获取所有的真阳性、假阳性和假阴性，并计算 F1 分数。
微观 F1 分数在效用上与宏观 F1 分数非常相似，因为它给出了分类器在多个类别上的总体性能。也就是说，他们会给出不同的结果，并理解潜在的差异，结果可能是给定应用程序的信息。
加权 F1 分数与宏观 F1 分数相同，但是每个特定于类别的 F1 分数是由该类别的样本的相对数量来衡量的。
在这种情况下， N 是指数据集中属于单个类的样本的比例。对于 A 类，其中 A 类是多数类，这可能等于 0.8 (80%)。B 和 C 的值可能分别是 0.15 和 0.05。
对于一个高度不平衡的数据集，一个大的加权 F1 分数可能会有些误导，因为它受到多数类的过度影响。
其他指标
对于二元分类(在某种程度上也包括多类分类)来说，您可能会看到的其他一些指标有:
准确度。如果你正在读这篇文章，我想你已经对准确性很熟悉了，但对其他的可能就不那么熟悉了。根据混淆矩阵的度量，准确性可以描述为真实预测(阳性和阴性)与阳性和阴性样本总数之和的比率。
**G-均值。**G 均值是一个不太常见的指标，有点类似于 F1 得分。这通常用两种不同的公式表示，第一种是精确召回 g 均值，第二种是灵敏度特异性 g 均值。在分析算法性能方面，它们可以以类似于 F1 分数的方式使用。精确召回率 g 均值也可以称为 Fowlkes-Mallows 指数。
还有许多其他可以使用的度量标准，但是大多数都有专门的用例，除了这里描述的度量标准之外，几乎没有提供额外的效用。读者可能有兴趣查看的其他指标有平衡准确度、、马修斯相关系数、、标记性、和信息量、。
受试者工作特性(ROC)曲线
ROC 曲线是一个二维图形，用来描述收益(真阳性)和成本(假阳性)之间的权衡。它显示给定分类器(二元问题、参数化分类器或分数分类)的灵敏度和特异性之间的关系。
这是一个 ROC 曲线的例子。
这里有很多东西需要打开。首先，穿过中心的虚线对应于一个分类器，该分类器充当“抛硬币”的角色。也就是说，它大约有 50%的正确率，是最差的分类器(我们只是猜测)。这作为我们的基线，我们可以对照它比较所有其他分类器——这些分类器应该更靠近图的左上角，因为我们希望在所有情况下都有高的真阳性率。
应当注意，ROC 曲线不评估一组分类器。相反，它在一组分类阈值上检查单个分类器。
这是什么意思？这意味着，对于一个点，我将我的分类器和阈值设置为 0.3 (30%倾向)，然后评估真阳性和假阳性率。
真阳性率: 由特定分类器和分类阈值的组合产生的真阳性(对真阳性和假阴性之和)的百分比。
假阳性率: 特定分类器和分类阈值组合产生的假阳性(占假阳性和真阴性之和)的百分比。
这给了我两个数字，我可以把它们画在曲线上。然后我取另一个阈值，比如 0.4，重复这个过程。在对每个感兴趣的阈值(可能以 0.1、0.01 或 0.001 的增量)做了这些之后，我们为这个分类器构建了一个 ROC 曲线。
ROC 曲线示例显示了如何绘制单个点。与分类阈值一起选择分类器。接下来，计算这种分类和阈值组合的真阳性率和假阳性率，并随后绘图。
这样做有什么意义？根据您的应用，您可能非常反对假阳性，因为它们可能非常昂贵(例如发射核导弹)，因此希望分类器具有非常低的假阳性率。相反，只要您获得了高的真阳性率，您可能就不会那么关心高的假阳性率(阻止大多数欺诈事件可能是值得的，即使您必须检查更多被算法标记为有缺陷的事件)。对于这两个比率之间的最佳平衡(其中假阳性和假阴性的代价相等)，我们将采用导致离左上角最小对角线距离的分类阈值。
为什么左上角对应理想分类器？ROC 曲线上的理想点应该是(0，100) **，**也就是说，所有阳性样本都被正确分类，并且没有阴性样本被错误分类为阳性。在一个完美的分类器中，不会有错误分类！
虽然图表本身可能看起来不太有用，但它有助于比较分类器。一个特殊的指标，曲线下面积(AUC) 得分，允许我们通过比较 ROC 曲线上产生的线下总面积来比较分类器。对于理想的分类器，AUC 等于 1，因为我们将 100% (1.0)的真阳性率乘以 100% (1.0)的假阳性率。如果某个分类器的 ROC 为 0.6，而另一个分类器的 ROC 为 0.8，那么后者显然是更好的分类器。AUC 的优势在于它独立于决策标准——分类阈值——因此更容易比较这些分类器。
现在可能会想到一个问题——如果一些分类器在较低阈值时更好，一些在较高阈值时更好，会怎么样？这就是 ROC 凸包的用武之地。凸包为我们提供了一种识别潜在最佳分类器的方法——即使我们可能没有直接观察到它们，我们也可以推断它们的存在。请考虑下图:
来源: Quora
给定一族 ROC 曲线，ROC 凸包可以包括更靠近 ROC 空间左上角(完美分类器)的点。如果一条直线通过凸包上的一点，那么就没有其他斜率相同的直线通过另一个真正截距更大的点。因此，在该点的分类器在与该斜率串联的任何分布假设下都是最优的。检查图像后，这可能更容易理解。
欠采样/过采样如何影响 ROC 曲线？一篇名为“SMOTE:Synthetic Minority Over-sampling Technique”的关于 SMOTE(之前讨论过)的著名论文概述了通过对多数类进行欠采样，我们迫使 ROC 曲线向上和向右移动，从而有可能增加给定分类器的 AUC(这本质上只是验证 SMOTE 功能正确，如预期的那样)。类似地，对少数类进行过采样也会产生类似的影响。
通过欠采样扫描 ROC 曲线的图示。多数(负)类的欠采样增加会将性能从左下角移动到右上角。来源 : 研究之门
精确召回(PR)曲线
可以从 ROC 空间重铸类似于 ROC 曲线的图，并将其重新表达到 PR 空间。这些图表在许多方面类似于 ROC 曲线，但我们没有绘制召回率对辐射(真阳性率对假阳性率)，而是绘制精确度对召回率。这产生了 ROC 曲线的某种镜像(曲线本身看起来有些不同),因为 PR 曲线的右上角指定了理想的分类器。这通常比 ROC 曲线更容易理解，但提供了非常相似的信息。PR 曲线下的面积通常称为 mAP，类似于 ROC 空间中的 AUC。
最终点评
与不平衡数据集在许多工业机器学习应用中的流行性和重要性相反，不平衡数据集在许多数据科学项目中的代表性不足(没有双关语)。数据科学家的工作是能够识别数据集何时失衡，并遵循程序和利用指标来充分理解和控制这种失衡。
我希望在阅读这篇文章的过程中，您已经了解了一些关于处理不平衡数据集的知识，并且在将来面对这种不平衡问题时能够游刃有余。如果你是一个认真的数据科学家，这些应用程序之一的出现只是时间问题！
简讯
关于新博客文章和额外内容的更新，请注册我的时事通讯。
丰富您的学术之旅，加入一个由科学家，研究人员和行业专业人士组成的社区，以获得…
mailchi.mp](https://mailchi.mp/6304809e49e7/matthew-stewart)
Keras 中的自定义递归建模指南
探索由基本循环层组成的 12 种不同排列，实验性地回答 3 个关于模型构建的有趣问题！
弗兰基·查马基在 Unsplash 上拍摄的照片
介绍
递归神经操作的初始层次通常从 LSTM、GRU 和 RNN 开始。但是随着任务复杂性的增加，我们应该使用更复杂的模型。也就是说，在直接转向不同的、相对复杂的模型(如注意力或变形金刚)之前，我们应该先问一个简单的问题——我们还能快速处理基本的循环层吗？在这篇文章中，我将关注同样的哲学——我们应该先尝试简单的解决方案，然后再尝试更复杂的解决方案。在接下来的部分中，我们将探索相同的一组旧的循环层(尽管有一些有趣的安排)，以获得更好的数据推断。总共，我们将讨论 12 个这样的安排(包括原始设置)。最后，我们将在文本情感检测任务上测试我们的所有模型，以比较它们的性能。我们开始吧！
先决条件
在继续之前，让我们讨论几个我们应该知道的主题，以便完全理解这篇文章。还有一点，我交替使用排列和模型，因为所有讨论的模型不过是基本循环层的组合，它充当最小的构建块。
递归层输出类型
任何递归层都可以选择返回两种类型的输出— (1)最后状态输出(1 个输出)和(2)所有状态输出(N 个输出)。实际上，第二种类型更通用，因为它也包含最后的状态输出(即，第一种类型)，但通常，流行的深度学习库的实现提供了返回两种类型输出的选项。对于 Keras，默认为第一种类型，您可以设置参数return_sequence=True转换为第二种类型。请注意，这里的“状态”是指递归图层的隐藏状态，N 个输出通常是数据集中的时间步长数。为了了解更多关于循环层和隐藏状态的内部情况，我推荐这篇优秀文章。现在回到主题，有趣的是，虽然第二种类型包含更多的信息(这通常是一件好事)，但它也可能令人不知所措，因为我们不知道该如何处理它。由于大多数下游应用程序仍然需要一个输出，我们最终将所有状态的输出合并为一个最终输出(可能的技术—使用AveragePooling或MaxPooling)。在某种程度上，LSTM 或 GRU 也是如此，他们使用前一个州的输出(和当前输入)来创建下一个州的输出。那么有趣的问题是，“什么更好——信任 LSTM/GRU 来巩固国家产出还是应用我们自己的逻辑？”。我们将在后面的章节中尝试回答这个问题，现在，让我们继续。
循环层中的变化与输出数量有关。(作者)
堆叠循环层
递归层接受顺序输入并处理它们以返回一个或多个输出(状态向量)。现在，由于输出(如果我们返回所有状态的输出)也遵循顺序感，它们可以被认为是一些转换的原始输入，并可以被传递到 LSTM/GRU 的另一层进行进一步处理。这被称为堆叠，这里的主要直觉是，就像普通的深度神经网络，你可以添加更密集的层，或者 CNN，你可以一个接一个地添加多个卷积层，在循环分层中，你可以将多个层一个接一个地堆叠起来。理想情况下，层数越多，可调参数越多，学习能力越强。但是要小心添加太多的栈，因为这可能会导致过度拟合(对于太简单的学习需求来说，网络太复杂)。我们在这里可以问的主要问题是“增加堆叠层会带来更好的性能吗？”。
2 级堆叠循环模型，其中每一级都有不同的循环层(不同的权重)
双向循环层
一个有趣的安排是，当您有两个递归层(它们没有堆叠)时，在一个层中，数据从左到右传递用于训练，而在另一个层中，这个方向相反。这是双向递归层，直觉是，与仅具有前向训练和左上下文的正常层相比，在准备状态向量输出时具有左和右上下文可以导致更高的性能。通常，对于您期望完整数据(双向上下文)存在的任务，这是正确的，因此这对于情绪检测是有效的，因为我们有完整的句子字符串可用，但对于时间序列预测是不正确的，因为如果我们想要今天的值(比如温度)，我们没有未来日期的数据。由于双向系统使用 2 个循环层，我们将其与堆叠架构进行比较，并询问“哪一个更好——2 层堆叠循环层还是双向循环层？”。
具有两个不同循环层的双向层。
方法学
接下来，让我们尝试使用我们知道的模型(基本循环层)和上面学到的技术来定义和分组我们可以创建的不同排列。在更高的层次，我们把所有的安排分成两大类—
- 单栈(SS) :其中我们只使用一个循环层
- 多栈(MS) :其中我们使用了多个循环层。为了保持分析简单，我将只使用 2 层安排。
此外，由于 rnn 已经让位于“更好”的循环层，我们在分析中将只考虑 LSTM 和 GRU。现在，在 SS 的情况下，我们可以使用 LSTM 或 GRU，我们也可以通过只取 1 个输出或 N 个输出来增加味道。这给了我们可能想要考虑的不同安排。接下来，在 MS (本文只有 2 个)的情况下，让我们首先从 1 个和 N 个输出开始。对于每个这样的设置，我们可以使用两层堆叠或双向 LSTM 和 GRU。这给了我们2x2x2=8不同的安排。所有 12 种排列组合如下所示。注意，我说的“返回序列错误”是指 1 个输出，因为你只返回一个输出，而不是完整的序列。
循环层排列的分离。
密码
现在让我们看看如何在 Keras 中编码不同的安排。为了简洁起见，我将只展示 LSTM 递归层的代码。转移到 GRU 就像在代码中用 GRU 替换 LSTM 一样简单(不过别忘了导入 GRU)。我也将只涵盖 4 个不同的品种，因为休息可以很容易地建立后，小的修改。LSTM RSF 市入门，即单一堆叠-返回序列错误-LSTM 图层😉
SS_RSF_LSTM
# import
from tensorflow.keras import layers
from tensorflow import keras
# model
inputs = keras.Input(shape=(99, )) # input layer - shape should be defined by user.
embedding = layers.Embedding(num_words, 64)(inputs) # embedding layer
rl = layers.LSTM(128)(embedding) # our LSTM layer - default return sequence is False
dense = layers.Dense(64)(rl) # a dense layer on the output of LSTM
output = layers.Dense(1, activation='sigmoid')(dense) # final layer which gives classification result
self.model = keras.Model(inputs=inputs, outputs=output, name="SS_RSF_LSTM") # stitching everything together
需要注意的事情很少，
- 代码是根据情感分类任务创建的(下一节)。因此，最终的输出层的大小为 1，具有 sigmoid 激活以返回概率作为输出。
- 我们定义一个输入，其中我们说 shape=99，即我们在数据中预期的时间步长。这里指的是每个句子的字数。
- 我们使用嵌入层将单词转换成向量表示。我们可以使用现成的单词嵌入，如 Glove 或 Word2Vec，但是我们初始化了一个新的，专门为这个任务训练的单词嵌入。每个向量的大小是 64，
num_words是我们正在使用的数据集的词汇大小。 - 我们使用一个状态输出大小为 128 的 LSTM 层。注意，由于默认返回序列为假，所以我们只得到一个输出，即 LSTM 的最后一个状态。
- 我们将最后一个状态输出与大小=64 的密集层连接起来。这用于增强 LSTM 输出的复杂阈值处理。
SS_RST_LSTM
这里唯一的区别是，我们从 LSTM 返回所有州的输出。我们可以这样做:
inputs = keras.Input(shape=(99, ))
embedding = layers.Embedding(num_words, 64)(inputs)
rl = layers.LSTM(128, return_sequences=True)(embedding)
avg = tf.keras.layers.AveragePooling1D(pool_size=99)(rl)
dense = layers.Dense(64)(avg)
output = layers.Dense(1, activation='sigmoid')(dense)
self.model = keras.Model(inputs=inputs, outputs=output, name="SS_RST_LSTM")
注意事项:
- 第一个变化是在 LSTM 定义中增加了
return_sequence=True。 - 接下来，我们需要将 99x128 矩阵合并成 1x128 大小的向量。虽然有很多方法可以做到这一点，但我们将选择
AveragePooling1D，它简单地取每 99 个时间步长向量的平均值来返回 1 个向量输出。这里的pool_size是指我们取每 99 个时间步的平均值。
MS _ RSF _ 比尔斯特姆
要有一个双向层，我们需要做的就是在 LSTM 之上添加一个Bidirectional函数。
inputs = keras.Input(shape=(99, ))
embedding = layers.Embedding(num_words, 64)(inputs)
rl = layers.Bidirectional(layers.LSTM(128))(embedding)
dense = layers.Dense(64)(rl)
output = layers.Dense(1, activation='sigmoid')(dense)
self.model = keras.Model(inputs=inputs, outputs=output, name="MS_RSF_biLSTM")
注意要移动到MS _ RST _ 比尔斯特姆你需要做两件事——(1)在 LSTM 层内添加return_sequence=True，以及(2)在双向 LSTM 层后添加AveragePooling1D逻辑，如上所述。
RST LSTM 女士
inputs = keras.Input(shape=(99, ))
embedding = layers.Embedding(num_words, 64)(inputs)
rl = layers.LSTM(128, return_sequences=True)(embedding)
rl = layers.LSTM(128, return_sequences=True)(rl)
avg = tf.keras.layers.AveragePooling1D(pool_size=99)(rl)
dense = layers.Dense(64)(avg)
output = layers.Dense(1, activation='sigmoid')(dense)
self.model = keras.Model(inputs=inputs, outputs=output, name="MS_RST_LSTM")
注意事项:
- 要堆叠多个 LSTM，所有较低的 lstm 都必须有
return_sequence=True，因为它们将作为输入馈送到下一个 LSTM。 - 对于最顶端的 LSTM，它的用户的选择。正如我们看到的一个 RST 的例子，代码返回所有的状态序列，然后进行平均。
- 要以这种方式堆叠更多的层，我们需要做的就是一次又一次地复制粘贴
rl = layers.LSTM(128, return_sequences=True)(rl)行。这里我们有两条这样的线，我们有两层堆叠的 LSTM。
按照上面分享的提示，剩下的安排可以很容易地编码。我把它作为一个练习，并在这里分享完整的代码以供参考。
实验
资料组
为了测试我们的模型，我选择了 IMDB 情感分类数据集，其中包含 25，000 条高度极性的电影评论，其二元情感由标签 0 和 1 表示。为了在我的笔记本电脑上更方便，我进一步整理了数据，只考虑了频率最高的 5000 个单词，并截断了超过 100 个单词的句子。由于数据 API 是由 Keras 公开的，所有这些都可以由，
# import
import tensorflow as tf
# set parameters
num_words = 5000
maxlen = 100
# fetch data
(x_train, y_train), (x_test, y_test) = tf.keras.datasets.imdb.load_data(num_words=num_words,
maxlen=maxlen)
此外，Keras 已经将单词转换成整数表示形式，从而更容易输入到我们的模型中。剩下的就是确保所有的句子大小相同，因为可能有一些句子的大小小于maxlen。这可以通过用一个虚拟数字(比如 0)填充较小的句子来实现。你可以在短句的左边或右边添加填充，我选择了左边。这样做的代码是，
## perform padding
x_train = tf.keras.preprocessing.sequence.pad_sequences(x_train, padding="pre")
x_test = tf.keras.preprocessing.sequence.pad_sequences(x_test, padding="pre")
结果
为了比较所有模型的性能得分，我们将根据准备好的数据和报告准确性，对每个模型进行指定次数的训练。为了处理训练中的变化，我们将多次重复训练过程(运行),并报告每次运行中观察到的准确度分数的变化以及最高和最低分数。最后，为了确保随机权重初始化不会引入模型性能的变化，我们将为每次运行使用相同的初始权重。然后，引入的主要差异在于模型拟合及其内部训练验证数据分割。
每个实验(针对一个模型)运行 5 次，每次运行 5 个时期。总共，我们运行了 12 个这样的实验(对于我们所有的模型)。综合业绩报告卡如下所示，
看看 LSTM RST 的获胜者，这比 LSTM RSF 的简单 SS(香草 LSTM)要好得多。
现在，让我们试着回答我们之前提出的问题，
报告精确度差异的问题相关模型比较表(右侧模型减去左侧模型)。对于每个问题，更多的绿色表示是，更多的红色表示不是。
- Q1:不同的经常性产出类型有关系吗？ —简答:有！为了理解其中的原因，让我们将每一款 RSF 车型与其对应的 RST 车型进行比较。所有这些可能的比较和差异(右减去左)如上所示。很明显，4/6 的模型表现更好。事实上，我们最好的模型是 MS_RST_LSTM，它比它的 RSF 版本有超过 3%的改进。
- Q2:堆叠多层很重要吗？ —又来了！见第二个比较表，所有正差异。增加更多的层会产生额外的可调参数，从而获得更大的学习能力。但是，这并不意味着你可以堆叠 100 层，并期望它比以前工作得更好——在某一点上，它会收敛，即增加更多的层不会有帮助。但是堆叠几层确实有帮助，如图所示。
- Q3:双向分层在对抗正常堆叠时表现更好吗？——有趣的是没有！3/4 倍堆叠层性能更好。这可能是因为多个堆栈层具有更多训练参数，因此对数据的推断更好。
结论
让我从一个免责声明开始——虽然我(或者更确切地说是实验结果)说一种安排比另一种安排更好，但我并不是暗示你应该只训练“好”的模型，而忽略其他的。请记住，每个任务及其数据都是不同的，可能会导致与上述报告不同的结果。以双向为例，通常，我发现双向与堆叠层竞争，在某些情况下甚至表现更好。这与我们之前看到的形成了对比，这证明了每个数据都是不同的。也就是说，这篇文章的目的有两个——( 1)展示仅使用基本的递归层就可以实现的不同种类的分层排列，以及(2)基于实验来帮助排列优先级，而不是忽略它们。所以下次你有一个文本分类项目，你可以从 MS_RST_LSTM 模型开始，用时间(如果你有的话)在别人身上做实验。
干杯！
在 LinkedIn 上与我联系，或者在我的网站上阅读更多这样的文章。
扫一扫
721
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
