十年自学数据科学——彼得·诺维格(谷歌机器学习主管)的三堂课
数据科学、机器学习和分析被认为是最热门的职业道路。行业、学术界和政府对熟练数据科学从业者的需求正在快速增长。因此，持续的“数据热潮”吸引了如此多具有不同背景的专业人士，如物理、数学、统计、经济和工程。数据科学家的就业前景非常乐观。IBM 预测，到 2020 年，对数据科学家的需求将飙升 28%:https://www . Forbes . com/sites/louiscolombus/2017/05/13/IBM-predicts-demand-for-data-scientists-will-soar-28-by-2020/# 7916 f 3057 e3b。
数据科学是一个如此广阔的领域，包括几个细分领域，如数据准备和探索；数据表示和转换；数据可视化和显示；预测分析；机器学习等。对学习数据科学基础感兴趣的初学者可能会有这样的问题:
- 学习数据科学的基础知识需要多长时间？
- 有哪些学习数据科学的资源？
选择上述标题的动机是基于 Peter Norvig 关于成为编程专家所需时间的想法。如果你还没有读过这篇文章:《10 年自学编程》作者 Peter Norvig(谷歌机器学习总监)，我鼓励你这样做。下面是文章链接:http://norvig.com/21-days.html。
这里的重点是，你不需要 10 年来学习数据科学的基础知识，但匆忙学习数据科学肯定没有帮助。成为一名数据科学家需要时间、努力、精力、耐心和承诺。
Peter Norvig 的建议是，学习需要时间、耐心和承诺。当心那些告诉你可以在 4 周内或 1 个月内学习数据科学的文章、书籍或网站。如果您有兴趣学习数据科学的基础知识，请准备好投入适量的时间和精力，这样您不仅可以掌握表面的概念，还可以掌握数据科学的深层概念。
我花了 2 年的时间深入学习(通过自学)来掌握数据科学的基础知识，这是因为我拥有物理学博士学位，并且我在数学和编程方面有坚实的背景。掌握数据科学的基础知识需要多长时间取决于你的背景。一般来说，在数学、统计学、计算机科学、工程学或经济学等分析学科有扎实的背景是有利的。
Peter Norvig 的 3 个教训**“十年自学编程”**
1)掌握数据科学的基础知识需要时间、努力、精力、耐心和承诺
数据科学是一个多学科领域，需要扎实的高等数学、统计学、编程背景，以及数据分析、数据可视化、模型构建、机器学习等方面的其他相关技能。我花了两年的时间专门学习，才掌握了数据科学的基础，这是因为我在数学、物理和编程方面有坚实的背景。以下是一些帮助我掌握数据科学基础的资源。
(一)【https://www.edx.org/professional…】数据科学专业证书(HarvardX，通过 edX):
包括以下课程，全部使用 R 教授(您可以免费旁听课程或购买认证证书):
- 数据科学:R 基础；
- 数据科学:可视化；
- 数据科学:概率；
- 数据科学:推理和建模；
- 数据科学:生产力工具；
- 数据科学:扯皮；
- 数据科学:线性回归；
- 数据科学:机器学习；
- 数据科学:顶点
(二)分析:基本工具和方法(Georgia TechX，通过 edX):https://www.edx.org/micromasters…
包括以下课程，全部使用 R、Python 和 SQL 讲授(您可以免费审计或购买经过验证的证书):
- 分析建模导论；
- 数据分析计算导论:
- 商业数据分析。
(三)应用数据科学与 Python 专业化(密歇根大学，通过 Coursera):https://www.coursera.org/special…
包括以下课程，全部使用 python 教授(您可以免费旁听大多数课程，有些课程需要购买认证证书):
- Python 中的数据科学导论；
- 应用 Python 绘图、制图和数据表示；
- Python 中的应用机器学习；
- Python 中文本挖掘的应用:
- Python 中的应用社会网络分析。
(四)数据科学教科书
从教科书中学习提供了比你从在线课程中获得的更精炼和更深入的知识。这本书对数据科学和机器学习提供了很好的介绍，代码包括:“Python 机器学习”，作者塞巴斯蒂安·拉什卡。作者以一种非常容易理解的方式解释了机器学习的基本概念。此外，代码也包括在内，因此您实际上可以使用提供的代码来练习和构建您自己的模型。我个人认为这本书在我作为数据科学家的旅程中非常有用。我会向任何数据科学爱好者推荐这本书。你所需要的是基本的线性代数和编程技能，以便能够理解这本书。也有很多其他优秀的数据科学教科书，如韦斯·麦金尼的《 Python for Data Analysis 》，库恩·约翰逊的《应用预测建模》，伊恩·h·威滕的《数据挖掘:实用机器学习工具和技术》，Eibe Frank & Mark A. Hall 等等。
(v)与其他数据科学有志者建立网络
从我的个人经历来看，通过与其他数据科学有志者合作，我从每周关于数据科学和机器学习各种主题的小组对话中学到了很多。与其他数据科学有志者建立联系，在 GitHub 上分享您的代码，在 LinkedIn 上展示您的技能，这将真正帮助您在短时间内学习许多新概念和工具。你还会接触到新的做事方式，以及新的算法和技术。
2。理解数据科学的理论基础与数据科学实践技能同样重要
数据科学是一门数学密集型学科，需要以下方面的知识:
(一)统计和概率
㈡多变量微积分
㈢线性代数
㈣优化和运筹学
从这里了解更多你需要重点关注的数学话题: 机器学习必备数学技能 。
即使 Python 的 sci-kit learn 和 R 的 Caret 包等包包含了几个用于进行数据科学和构建机器学习模型的工具，理解每种方法的理论基础也是极其重要的。
3。避免使用机器学习模型作为黑盒工具
扎实的数据科学背景将使数据科学家能够构建可靠的预测模型。例如，在构建模型之前，您可能会问自己:
㈠什么是预测变量？
㈡目标变量是什么？我的目标变量是离散的还是连续的？
(三)我应该使用分类还是回归分析？
(iv)如何处理数据集中缺失的值？
㈤在将变量纳入同一尺度时，我应该使用规范化还是标准化？
(vi)我是否应该使用主成分分析？
(vii)如何调整模型中的超参数？
(viii)如何评估我的模型以检测数据集中的偏差？
(ix)我是否应该使用集成方法，即使用不同的模型进行训练，然后进行集成平均，例如使用 SVM、KNN、逻辑回归等分类器，然后在 3 个模型上进行平均？
(x)我如何选择最终型号？
好的和坏的机器学习模型之间的区别取决于一个人理解模型的所有细节的能力，包括关于不同超参数的知识以及如何调整这些参数以获得具有最佳性能的模型。在没有完全理解模型的错综复杂的情况下，将任何机器学习模型作为黑箱，都会导致模型被证伪。
总之，数据科学是当今最热门的领域之一。数字革命创造了成吨成吨的数据。公司、行业、组织和政府每天都在产生大量的数据。对高技能数据科学家的需求只会继续增长。这是投入时间掌握数据科学基础知识的最佳时机。在这样做的时候，要小心那些告诉你可以在 4 周或 1 个月内学会数据科学的文章、书籍或网站。不要匆忙。慢慢掌握数据科学的基础知识。
自学 SQL —第一部分
Courtesy of comic.browserling.com
作为一名数据分析师，我在 SQL 方面做了很多工作，我想我应该分享一下如何使用它来解决业务问题。我自学成才，并在一家专门从事数据科学和 UX 设计教育的教育科技初创公司从市场营销工作成为一名数据分析师。
我想用我的学习来回报它，并分享一些我发现对培养分析技能有帮助的事情。事不宜迟，我将直接切入正题:一个可以用 SQL 解决的一些业务/产品分析师风格问题的端到端示例。
这篇文章是为那些希望发展自己的 SQL/分析思维技能的人，以及那些试图进入并开始他们作为业务分析师、数据分析师、产品分析师或数据科学家的职业生涯的人准备的。无论您选择哪种方式，我向您保证 SQL 是您工具箱中的一项关键技能！
因此，我这篇文章的目标是让您:
- 建立自己的免费 Mode 实例，这是一个常用的商业智能平台。许多数据分析师和数据科学家的职位描述都在寻找知道这个工具的候选人，所以如果你想进入这个领域，熟悉这个工具是很好的。
- 根据 Mode 提供的测试数据源编写基本的 SQL 语句。
在本系列文章的后续部分中，我将更深入地研究更高级的 SQL，并使用它来解决业务问题。
目标 1:设置
首先，你需要前往mode.com注册一个免费账户。这是一个超级快速和基本的注册过程。验证您的帐户后，您可以登录。
一旦进入平台，转到SQL Training2019并点击Write a Query。作为一个有产品和业务分析经验的人，我将带你浏览一下yammer_experiments表中的 SQL 查询，它对应于产品实验及其结果。
这样，我们就实现了目标 1！看我们走！
目标 2:基本 SQL
让我们运行第一个查询来计算我们要处理多少行:
SELECT
COUNT(1)
FROM
tutorials.yammer_experiments
;
上面的查询告诉您表中的行数— 2595。
现在我们知道了这个表的大小，让我们了解一下这个表的值。为此，请使用 LIMIT 子句编写以下内容:
SELECT
*
FROM
tutorials.yammer_experiments
LIMIT 100
;
星号获取所有列，LIMIT 子句减少返回的行数，否则您将等待一段时间，尤其是在大型表上。
The first few rows returned from the previous query gives us a sense of what the data are
看起来yammer_experiments表是某种网络分析数据。看到occurred_at字段让我觉得这就是所谓的事件表。事件表的不同之处在于，每一行对应于用户采取的一个动作。典型地，在数据库中设置有触发器，其中执行以下逻辑:如果用户采取动作 A，记录在事件表 A 中捕获该用户-动作对的记录。动作的发生激活触发器并将记录推送到该表。
我不知道这张表，所以这是我的假设。在分析师的工作中，开发和测试假设是很重要的。为了测试我的假设，即每一行都是一个用户-动作对，因此任何用户都可以执行多个动作，让我们计算每个 user_id 出现的次数，看看是否有多个条目对应于任何用户 id。下一个查询引入了两个新子句:GROUP BY 和 ORDER BY。
SELECT
user_id,
COUNT(1)
FROM
tutorial.yammer_experiments
GROUP BY
user_id
ORDER BY
COUNT(1) DESC
;
在上面的查询中，我从表中选择了用户 id，并使用了上面介绍的相同的 COUNT(1)逻辑。分组依据按用户 id 对计数进行分组。最后，我使用 ORDER BY 和关键字 DESC(代表降序)首先获得用户 id 的最大数量的实例。这产生了以下结果:
First few rows of user ids and the number of occurrences of each
这否定了我的假设，即这是一个事件表，但让我们继续前进！
让我们更好地理解下一个专栏:occurred_at。所以我们知道一个用户只出现一次，可能是某种动作不能执行两次。
无论如何，假设你的利益相关者没有告诉你这个信息，或者当这个实验进行时，你没有在会议中问他们，这将会很有趣。很容易做到这一点，使用聚合函数* : MIN 和 MAX。查看并运行下面的查询:*
SELECT
MIN(occurred_at),
MAX(occurred_at)
FROM
tutorial.yammer_experiments
;
这将向我们显示最早的操作是在 2014 年 6 月 1 日刚过午夜时执行的，最晚的操作是在 2014 年 6 月 30 日晚上 10:45。让我们假设这是 2014 年 6 月的一次实验！
现在需要一个关于可读性和易于理解的注释。在这些列的 SELECT 子句中使用 AS 关键字对我们自己的理解和将来可能运行该查询的任何人来说都更好一些。
SELECT
MIN(occurred_at) AS `Earliest Occurrence`,
MAX(occurred_at) AS `Latest Occurrence`
FROM
tutorial.yammer_experiments
;
这称为别名，它有助于 SQL 的可读性和理解。然而，当与其他分析师单独工作时，我实际上建议保持表名和字段名不变——因为别名是您自己的命名约定。其他分析师只会理解数据库模式的实际名称，而不是您决定对其进行重命名的名称！因此，如果你在寻求反馈或合作，尽量不要使用别名，即使你会打更多的字。做一个好的分析师同事——不要化名。
*注意:*反斜杠(`)并不是在 SQL 的每个版本中都适用于别名，一些 SQL 变体很难处理空格。尝试使用下划线而不是空格、单引号或双引号，直到没有出现错误为止。
在研究这些数据的其他方法之前，重要的是要看看控制组和测试组的大小是否相等。如果我们正在做一个 A/B 测试，看看设计流程的两个变量，按钮点击行为，登陆页面，等等。，我们希望数据平均分布在多个变量上。让我们再用 COUNT(1)的把戏检查一下。
SELECT
experiment_group,
COUNT(1) AS number_of_participants
FROM
tutorial.yammer_experiments
GROUP BY
experiment_group
;
这表明test_group有 849 个参与者，而control_group有 1746 个参与者！虽然这种划分并不理想，但双方都有统计意义上的显著数量的观察结果，所以让我们注意到 A/B 划分的警告并继续前进——这是需要向利益相关者注意的事情，并作为未来的建议添加——请平均划分您的小组！
您可能已经注意到 Mode 中有多个 Yammer 表。你想知道它们之间有什么联系吗？一个名副其实的数据组织应该有一个 ER(实体关系)图，它显示了表的主键和外键。主键通常是表中的第一列，外键是从该表指向外的键，映射到您试图连接的任何其他表的主键。这让我想到了连接的概念。
让我们试试下面的方法:将用户表连接到实验表。在我们开始之前，由于我们不知道模式，让我们通过对表运行查询来从经验上了解模式**！为了提高可读性和处理表名太长的奇怪换行符，我将打破自己的规则，为下一节的表和字段起别名。**
让我们看看实验表中是否使用了所有用户:
SELECT
COUNT(1)
FROM
tutorial.yammer_users AS users
INNER JOIN
tutorial.yammer_experiments AS experiments
ON experiments.user_id = users.user_id
;
上面的查询再次计算了行数，但是在 users 表中的所有用户 id 被内部连接到 experiments 表之后返回的行数。结果呢？2595.为什么？内部连接是文氏图的内部部分，这意味着只有当表 A 中的记录与表 B(实验表)中 on 子句中使用的字段匹配时，才会返回这些记录。简单地说:返回 2595 行，因为在所有用户(users 表)中，只有这 2595 个用户 id 用在了 experiments 表中。
因为 experiments 表是 users 表的子集(当然，因为您不想对所有用户进行实验！)，这是使用另一种联接的好机会:左联接。
让我们尝试与上面相同的查询，但是使用左连接而不是内连接:
SELECT
COUNT(1)
FROM
tutorial.yammer_users AS users
LEFT JOIN
tutorial.yammer_experiments AS experiments
ON experiments.user_id = users.user_id
;
嗯？成功了吗？它应该返回用户表中的行数！这是因为它获取用户表中的所有用户 id，并且只获取用户 id 对应的实验表中的行。对上述查询生成的表进行解聚，自己去看看吧！
SELECT
*
FROM
tutorial.yammer_users AS users
LEFT JOIN
tutorial.yammer_experiments AS experiments
ON experiments.user_id = users.user_id
;
发生了什么事？我返回了两个表中的所有列，如果一个用户 ID 同时存在于 users 表和 experiments 表中，则 experiments 表中的列将填充该用户对应的实验数据，否则值为 NULL，因为没有匹配！
下面是上述查询生成的表格(我突出显示了用户 id 匹配的地方):
The resultant table from the LEFT JOIN query above
结论
在 SQL Academy 系列的第一部分中，您学习了 SQL 的基础知识:SELECT、FROM、LIMIT、COUNT、GROUP BY、MIN、MAX 和 ORDER BY。
在下一部分中，我写了子查询和 case 语句。点击这里查看！
如果你觉得这篇文章有用或者学到了新的东西，可以考虑捐赠任何数量来支付给下一个学习者！
感谢阅读和快乐编码！
奢侈的生活
自学 SQL —第二部分
Bucketed data
几周前，我决定写更多我作为数据分析师所学到的关于 SQL 和分析思维的东西。我在一家名为的教育科技初创公司工作，该公司致力于让学生在数据科学和 UX 设计等热门领域找到工作。
本文是这个系列的第二篇文章(见第一部分此处)。第一部分的目标是让您了解模式分析，并熟悉示例数据库中的基本 SQL。
在本文中，我将介绍以下内容:
- 使用子查询更深入地研究 SQL。
- 将事情联系到业务示例案例，以及如何从战略上对查询结果采取行动。
- 展示一些例子，说明如何有效地用可视化表达这些查询的结果。
目标 1:总结和更多 SQL
回顾一下第一部分中的内容，我们在查询编辑器中设置了模式，并对 Yammer 实验表运行了一些基本的查询，使用了 SQL 的以下功能:SELECT、FROM、LIMIT、COUNT、GROUP BY、ORDER BY 以及 MIN 和 MAX。
这些对于获取汇总统计数据和理解您的数据非常有用。接下来让我们试着从数据中找出一个更复杂的商业问题！但是在我开始之前，我想分享一个提高效率的小技巧:
在大多数 SQL 编辑器和客户端(MySQL Workbench，我们一直使用的 GUI 模式分析平台，以及其他软件)中，查询的结尾用分号(；).在下一节中，我将写出几个查询，用注释(一个最佳实践)向您展示您可以在一个页面中有多个查询，并运行您想要的任何一个查询(在突出显示它或光标位于 SELECT 和分号之间的任何位置时运行CTRL + Enter,将只运行那个查询)。
这里有一个例子来说明我的意思:
-- This subquery produces the event type counts
SELECT
events.event_type AS event_type,
COUNT(1) AS number_of_occurrences
FROM
tutorial.yammer_events AS events
GROUP BY
events.event_type
;-- This subquery produces the count of actions by location
SELECT
events.location,
COUNT(1) AS number_of_occurrences
FROM
tutorial.yammer_events AS events
GROUP BY
events.location
ORDER BY
COUNT(1) DESC
;-- This grabs the count of actions by device
SELECT
events.device,
COUNT(1) AS number_of_occurrences
FROM
tutorial.yammer_events AS events
GROUP BY
events.device
ORDER BY
COUNT(1) DESC
;
两个破折号是单行注释。若要注释掉多行，请以“/”开始，以“/”结束。运行上述查询并检查输出，我们看到大多数操作都是约定。在这些数据中，美国、日本和德国是行动的前三名。最常见的设备是 Macbook Pro，其次是联想 Thinkpad，最后是 Macbook Air。
目标 2:将它与业务示例案例联系起来
将这个问题与一个商业案例联系起来:如果有一个 bug 同时影响了 OS X 和 Windows 的用户，那么技术团队最好先修复 OS X 的 bug，然后在修复 Windows 的时候再推出，因为这是可能受到影响的最大的两个用户群。
一个更详细的表也可能存储操作系统版本，这可以帮助开发人员确切地知道要修补什么版本。如果那些数据是可用的，当优先考虑首先解决哪个 OS 版本时，可以应用与上述类似的逻辑。
如果我们想弄清楚打开电子邮件的用户是否会表现出其他行为呢？我们需要探索更多，然后才能尝试找出要寻找的模式。
让我们看看用户采取的平均行动次数是多少。这将让我们对预期的参与量有所了解:
SELECT
user_id,
COUNT(1)
FROM
tutorial.yammer_events AS events
GROUP BY
user_id,
event_name
;
请记住，事件表是一个实际的事件表。因此，我们需要做的就是统计用户 id 并按用户 id 分组。等等，我们不是想要普通的吗？
让我们引入子查询的概念来获得该值！
子查询是查询中的一个查询。我花了一段时间才明白如何使用它们，直到我的同事解释了一个启发法，帮助我建立了正确的思维模式。之后就一拍即合了。
当您说 SELECT something FROM table 时，您正在查询该表并选择 SELECT 子句中指定的列。子查询返回所谓的派生表、、，这只是一种说法，即查询的输出是一个只在查询期间持续的表。就像查询任何表一样，您可以从该表进行查询，该表本身就是一个查询。我将从一个例子开始，这个例子在实践中没有意义，但是以一种简单的方式说明了这个概念。
SELECT
user_id
FROM
(
SELECT
user_id
FROM
tutorial.yammer_events AS events
) AS example_derived_table;
这应该是清楚的，并说明了为什么我学会了制表(即缩进)的方式。左括号和右括号在一条线上，所以你可以很容易地知道子查询从哪里开始和结束(相信我，有 10 或 20 个子查询，这是至关重要的！).
这个查询没有任何意义，但是它说明了这一点:我在 events 表中派生出一个用户 ID 表，并从中提取用户 ID。
您能猜到我们如何使用它来获得用户使用我们之前的 COUNT 查询所采取的平均操作数吗？
获取用户的动作计数，然后从中取这些计数的平均值！
SELECT
AVG(action_count)
FROM
(
SELECT
user_id,
COUNT(1) AS action_count
FROM
tutorial.yammer_events AS events
GROUP BY
user_id
) AS example_derived_table;
这个返回 34.9！第一个用户只有几个，所以我怀疑有一个巨大的行动传播，实际上通常有高度参与和勉强参与的用户。所以让我们来数一数吧！
SELECT
action_count,
COUNT(1)
FROM
(
SELECT
user_id,
COUNT(1) AS action_count
FROM
tutorial.yammer_events AS events
GROUP BY
user_id
) AS example_derived_table
GROUP BY
action_count
ORDER BY
action_count
;
这将返回给我们动作的数量。最常见的是单个行动，这很有意义，因为少行动比多行动更容易。
在上面的子查询示例中，我在 FROM 子句中进行了子查询。但是可以在任何子句中进行子查询。我通常会在 JOIN 子句中编写一个子查询，因为我想将一些被操作的数据连接回某个基表。
目标 3:有效的可视化
通常，制作简单、易读的图表向企业的利益相关者传达信息是最有效的。假设你在一个产品分析团队工作，你的任务是展示用户参与度的分布。总共有多少用户执行 x 个操作？
我们已经有了产生这个结果的查询。然后，您可以在模式下，或者在将数据提取为 CSV 格式并导入 Python、Excel 或您喜欢的任何其他工具之后，用结果数据制作一个条形图！
在模式下，您只需使用您编写的查询，然后单击图表按钮并选择一个条形图。将从查询中导出的列拖动到 X 轴和 Y 轴上，这就是您的图表！
The count of users who performed X number of actions
这向我们展示了执行一个动作的用户数量巨大，而执行更多动作的用户数量却少得多。不过 X 轴并不理想，所以让我们重新查看一下查询，使用 CASE 语句和谓词逻辑为 X 轴创建更好的数据存储。这将允许我们为了可读性和简洁性而截断数据。
下面是在 X 轴上存储数据的 SQL 查询:
SELECT
CASE
WHEN action_count BETWEEN 0 AND 10 THEN '[0-10]'
WHEN action_count BETWEEN 10 AND 20 THEN '[10-20]'
WHEN action_count BETWEEN 20 AND 30 THEN '[20-30]'
WHEN action_count BETWEEN 30 AND 40 THEN '[30-40]'
WHEN action_count BETWEEN 40 AND 50 THEN '[40-50]'
WHEN action_count BETWEEN 50 AND 60 THEN '[50-60]'
WHEN action_count BETWEEN 60 AND 70 THEN '[60-70]'
WHEN action_count BETWEEN 70 AND 80 THEN '[70-80]'
WHEN action_count BETWEEN 80 AND 90 THEN '[80-90]'
WHEN action_count BETWEEN 90 AND 100 THEN '[90-100]'
END AS action_count_bucketed,
SUM(number_of_users)
FROM
(
SELECT
action_count,
COUNT(1) AS number_of_users
FROM
(
SELECT
user_id,
COUNT(1) AS action_count
FROM
tutorial.yammer_events AS events
GROUP BY
user_id
) AS example_derived_table
GROUP BY
action_count
ORDER BY
action_count
) AS case_table
GROUP BY
action_count_bucketed
LIMIT 10
;
Bucketed data
好多了！使用 case 语句并捕获值的范围，我能够简化这个图表。没有必要知道大约 20 个用户执行了 98 个动作。说 120 执行了 90 到 100 个动作就“够好”了！永远记住 80/20 法则，多少是足够的信息。
这张图表背后的故事是，你可以看到大多数用户并不十分投入，只有少数核心群体处于 10-20 到 30-40 个行动区间。下一步是使用日期时间列occured_at来讲述一个关于这些行为何时发生的更有趣的故事，并查看重要的产品参与度指标，如日活跃用户(DAU)、周活跃用户(WAU)等。
在本系列的下一部分中，我将更深入地研究如何使用日期时间值，敬请关注！
如果你觉得这篇文章有用或者学到了新的东西，考虑捐赠任何数量来支付给下一个学习者！
感谢阅读和快乐编码！
奢侈的生活
教电脑登陆月球
去年我花了相当多的时间来了解机器学习领域的进展。现在可用的工具真的令人印象深刻——现在，利用可用的库，只需几行代码就可以实现复杂的神经网络。
我一直对机器学习复杂任务的想法很感兴趣，比如通过一遍又一遍地做它们来学习飞行，并看看什么有效，所以我选择了 OpenAI Gym 月球着陆器环境进行第一次实验。进行学习和控制的程序被称为代理。
代理学习解决问题的正确方法，而没有被提供许多解决的例子，这是无监督学习。这样做的一个方法是建立一个培训环境，奖励做得好的代理人，这样代理人就可以强化这种行为。这叫做强化学习。
OpenAI 健身房提供了一个模拟不同问题的一致的训练环境——游戏、物理模拟等。它处理给出所需的奖励，以便代理可以学习。
有一个很好的库可以做到这一点，叫做 Keras-RL，它和 OpenAI Gym 配合得非常好。
下面显示了训练过程的视频，每隔一段时间采样一次。它从火箭坠毁时的有效随机发射发展到犹豫盘旋，再到平稳着陆。学习代理的代码如下。
The training process
该计划是第一次训练，这可能需要几天时间，如果你没有使用 GPU 加速。然后保存训练模型的参数，并由测试程序加载，该测试程序演示学习的着陆技术。在云系统或 GPU 加速桌面上进行培训将大大加快这一过程。
这些程序由 Keras-RL 演示代码修改而来。
import numpy as np import gym from keras.models
import Sequential from keras.layers
import Dense, Activation, Flatten from keras.optimizers
import Adam from keras.callbacks
import EarlyStopping from rl.agents.dqn
import DQNAgent from rl.policy
import BoltzmannQPolicy from rl.policy
import EpsGreedyQPolicy from rl.memory
import SequentialMemory ENV_NAME = 'LunarLander-v2' env = gym.make(ENV_NAME)
env = gym.wrappers.Monitor(env, 'recordings12')
np.random.seed() env.seed()
nb_actions = env.action_space.n # Next, we build a very simple model.
model = Sequential() model.add(Flatten(input_shape=(1,) + env.observation_space.shape)) model.add(Dense(128)) model.add(Activation('relu')) model.add(Dense(64)) model.add(Activation('relu')) model.add(Dense(32)) model.add(Activation('relu')) model.add(Dense(nb_actions)) model.add(Activation('linear')) print(model.summary())# configure and compile our agent. memory = SequentialMemory(limit=1000000, window_length=1)
policy = EpsGreedyQPolicy()
earlystop = EarlyStopping(monitor = 'episode_reward', min_delta=.1, patience=5, verbose=1, mode='auto')
callbacks = [earlystop]
nb_steps_warmup = 1000
target_model_update = .2
gamma = .99
lr = .0001
training_steps = 4000000
epochs = training_steps/1000 decay = float(lr/epochs)
dqn = DQNAgent(model=model, nb_actions=nb_actions, memory=memory, nb_steps_warmup=nb_steps_warmup, target_model_update = target_model_update, policy=policy, gamma = gamma)dqn.compile(Adam(lr=lr), metrics=['mae']) # Train model
dqn.fit(env, nb_steps=training_steps, visualize=False, verbose=1) # After training is done, we save the final weights. dqn.save_weights('dqn_{}_weights.h5f'.format(ENV_NAME), overwrite=True)
测试程序
import numpy as np
import gym from keras.models
import Sequential from keras.layers
import Dense, Activation, Flatten from keras.optimizers
import Adam from rl.agents.dqn
import DQNAgent from rl.policy
import EpsGreedyQPolicy from rl.memory
import SequentialMemory ENV_NAME = 'LunarLander-v2'
env = gym.make(ENV_NAME)
env = gym.wrappers.Monitor(env, 'recordings2')
np.random.seed()
env.seed()
nb_actions = env.action_space.n
model = Sequential() model.add(Flatten(input_shape=(1,) + env.observation_space.shape)) model.add(Dense(128))
model.add(Activation('relu'))
model.add(Dense(64))
model.add(Activation('relu'))
model.add(Dense(32))
model.add(Activation('relu'))
model.add(Dense(nb_actions))
model.add(Activation('linear'))
print(model.summary())
memory = SequentialMemory(limit=75000, window_length=1)
policy = EpsGreedyQPolicy()
dqn = DQNAgent(model=model, nb_actions=nb_actions, memory=memory, nb_steps_warmup=10000, target_model_update=.2, policy=policy) dqn.compile(Adam(lr=.0001), metrics=['mae']) dqn.load_weights('dqn_{}_weights.h5f'.format(ENV_NAME)) dqn.test(env, nb_episodes=10, visualize=True)
最初发表于T5【http://shortcircuitsandinfiniteloops.blogspot.com】。
教神经网络玩 21 点
我们训练一个神经网络，看看应用深度学习是否可以改善我们的 21 点策略
上次我们开发了模拟 21 点的代码。通过这些模拟，我们发现了赌场优势的关键驱动因素。以下是我们之前发现的快速回顾:
- 赌场通过强迫玩家在庄家之前行动(并根据不完全信息行动)来获得对 21 点玩家的优势。这首先让他们面临破产的风险(所以他们可能在庄家有机会行动之前就破产了)。
- **当玩家的牌总数在 12 到 16 之间(他们的下一张牌有被击败的风险)并且庄家亮出大牌时，他们尤其危险。**在这些情况下，假设庄家最终会有一手好牌，因此玩家必须命中或灭亡。我们可以直观地看到这一点，玩家获胜或平手的概率在 12 和 16 之间(绝望之谷)。
Probability of Win or Tie vs. Player’s Hand Value (21 not shown because the probability is 100%)
- 最后，我们观察到，一个天真的策略，即只有在失败的机会为零时才出手，极大地提高了我们击败赌场的几率，因为它将失败的风险完全转移到了赌场
如果你不熟悉 21 点这个游戏，我之前的帖子也描述了这个游戏的玩法和规则。
但是深度学习能做得更好吗？
今天帖子的目标是，我们是否可以使用深度学习来获得比幼稚策略更好的策略。我们将:
- 使用我们上次编写的 21 点模拟器生成数据(做了一些修改，使其更适合训练算法)。
- 编码并训练神经网络玩 21 点(希望是最佳的)。
如果你不熟悉神经网络， 我在这篇文章中写了大量关于它们的内容(这是我最努力的一篇文章，所以请查看)。
A Visual Depiction of a Simple Neural Net (From Understanding Neural Networks)
在我们进入训练过程之前，让我们后退一步，快速讨论一下在这种情况下使用神经网络的利弊。神经网络是高度灵活的算法，就像软粘土一样，神经网络可以自我调整以适应数据的轮廓，即使很少或没有转换。神经网络很容易处理会给线性回归等更严格的东西带来麻烦的数据。此外，网络中的层和神经元将学习数据中可能存在的任何深度嵌入的非线性关系。
然而，这种多功能性是有代价的——神经网络是一个黑盒模型。与我们可以通过查看回归系数来了解模型如何做出决策的回归不同，神经网络没有这种透明性。**此外，神经网络有可能过于拟合我们的数据，而不能很好地概括样本数据。**在我看来，这些缺点值得牢记并设计安全措施，但它们不是回避使用神经网络的理由。
生成我们的训练数据
在我们可以训练我们的神经网络之前，我们首先需要弄清楚如何组织我们的训练数据，以便我们用它建立的模型将是有用的。
我们想预测什么？在我看来，我们的目标变量有两个候选者:
- 输掉比赛的概率。在这种情况下，我们可能希望模型告诉我们损失的概率是多少。话说回来，这只有在我们可以增加或减少赌注的情况下才有用，而在 21 点中我们不能这样做。
- 相反，我们希望我们的神经网络能够识别正确的动作，击中或停留。因此，我们的目标变量应该是“正确的行动是打击还是停留”。
事实上，我花了一段时间才想出设置它的最佳方式。但这是我想到的。
我们需要一种方法让神经网络知道给定的移动是否正确。不需要做到万无一失，只要大体正确即可。因此，我判断一个给定的走法是否正确的方法是模拟一场 21 点游戏:将牌发给玩家和发牌者，检查是否有人有 21 点，只走一步(要么击中，要么留下)，模拟游戏结束并记录结果。由于模拟玩家只做出一个决定，我们可以通过他在游戏中是赢是输来评估该决定的质量:
- 如果玩家击中并获胜，那么击中(Y=1)是正确的决定。
- 如果玩家击中并输了，那么留下(Y=0)是正确的决定。
- 如果玩家留下并获胜，那么留下(Y=0)是正确的决定。
- 如果玩家留下并输了，那么 hit (Y=1)是正确的决定。
这允许我们训练我们的模型，以便它的输出是一个是否击中或停留的预测。代码与上次的类似，所以这里就不做详细概述了(你也可以在我的 GitHub 上找到这里)。但是主要特征是:
- 庄家面朝上的牌(另一张看不见)。
- 玩家的总牌价。
- 不管玩家有没有 a。
- 玩家的动作(击或停留)。
目标变量是由上述逻辑定义的正确决策。
训练神经网络
我们将把 Keras 库用于我们的神经网络。让我们先把我们的进口商品放在一边:
from keras.models import Sequential
from keras.layers import Dense, LSTM, Flatten, Dropout
现在，让我们设置用于训练神经网络的输入变量。变量 feature_list 是我在上面列出的特性(X 变量)的列名列表。dataframe model_df 是我存储我运行的 21 点模拟的所有数据的地方。
# Set up variables for neural net
feature_list = [i for i in model_df.columns if i not in
['dealer_card','Y','lose','correct_action']
]
train_X = np.array(model_df[feature_list])
train_Y = np.array(model_df['correct_action']).reshape(-1,1)
实际实例化和训练我们的神经网络的代码行非常简单。第一行(第 1 行)创建顺序型神经网络，它是神经网络层的线性序列。第 1 行之后的行一个接一个地给我们的模型添加层(密集是最简单的层类型，只是一堆神经元)——像 16、128 等数字。指定每层中神经元的数量。
**最后对于最后一层，我们需要选择一个激活函数。这将神经网络的原始输出转换成我们可以理解的东西。**关于最后一层要注意两点。首先，它只包括一个神经元，因为我们在两个可能的结果之间进行预测(两类问题)。其次，我们使用 sigmoid 激活，因为我们希望我们的神经网络像逻辑回归一样运作，并预测正确的举动是击中(Y=1)还是停留(Y = 0)——换句话说，我们希望知道击中是正确举动的概率。
最后两行告诉我们的神经网络模型使用什么损失函数(二元交叉熵是输出概率的分类模型使用的损失函数)，并使模型适合我们的数据。我没有花太多时间调整层或神经元的数量，但是如果有人要摆弄我的代码，我会建议将它们作为潜在的改进途径。
# Set up a neural net with 5 layers
model = Sequential() # line 1
model.add(Dense(16))
model.add(Dense(128))
model.add(Dense(32))
model.add(Dense(8))
model.add(Dense(1, activation='sigmoid')) # final layermodel.compile(loss='binary_crossentropy', optimizer='sgd')
model.fit(train_X, train_Y, epochs=20, batch_size=256, verbose=1)
检验我们模型的性能
判断我们的模型是否增加了任何价值的一个快速方法是使用 ROC 曲线(如果你想深入研究 ROC 曲线，请查看你的真实博客链接)。ROC 曲线告诉我们，我们的模型在收益(真阳性率)和成本(假阳性率)之间的权衡有多好——曲线下的面积越大，模型越好。
下图显示了我们玩神经网络的 21 点的 ROC 曲线——神经网络似乎比随机猜测增加了相当多的价值(红色虚线)。其曲线下面积或 AUC 为 0.73，显著高于随机猜测的 AUC(0.50)。
ROC Curve for Our Blackjack Playing Neural Net
我用我的训练数据画了 ROC 曲线。通常我们会希望使用我们的验证或测试数据来绘制它，但在这种情况下，我们知道只要我们的样本足够大，那么它就是总体的代表(假设我们继续用相同的规则玩 21 点)。我们希望我们的模型能够很好地推广(任何新数据都将与我们的训练数据具有相同的基本统计特征)。
该玩了！
在我们的神经网络可以正式开始赌博之前，我们需要给它一个决策规则。**记住，sigmoid 激活(来自我们最终的神经网络层)使我们的神经网络输出正确移动命中的概率。**我们需要一个决策规则，根据给定的概率，我们决定是打还是留。
我编写了以下函数来实现这一点 model _ decision 函数获取神经网络所需的特征，使用这些特征进行预测，并将该预测与预定义的阈值进行比较，以决定是成功还是失败。我用 0.52，因为我们从上次已经知道，对一个 21 点玩家来说，破产是最大的风险。因此，使用 0.52 作为命中的截止值使得我们的模型不太可能命中，因此不太可能失败。
def model_decision(model, player_sum, has_ace, dealer_card_num):
input_array = np.array([player_sum, 0, has_ace,
dealer_card_num]).reshape(1,-1)
predict_correct = model.predict(input_array)
if predict_correct >= 0.52:
return 1
else:
return 0
现在我们只需要将上述函数添加到我们的代码中，在这里我们决定是否点击(如果你想知道我是如何编写这部分代码的，请参考我的 GitHub )。因此，当决定要做什么时，神经网络将根据庄家正在展示的牌、自己手中牌的总价值以及它是否持有 a 来做出决定。
我们的模型相当不错！
最后，让我们比较一下我们的神经网络在简单策略和随机策略下的性能。提醒大家:
- 我对每种策略类型(神经网络、朴素策略和随机策略)进行了大约 300，000 次 21 点模拟。
- 天真的策略是只有在没有机会击败的时候才出手(出手总数低于 12 的时候出手，出手总数超过 12 的时候继续出手)。
- 随机策略是抛硬币——如果正面朝上，否则留下。如果你击中了，但没有失败，那么再掷一次硬币，重新开始整个过程。
让我们看看我们的神经网络是否能够找到更好的策略。下表显示了每种策略类型的结果分布。有两件事引起了我的注意。**首先，我们的神经网络只输了略少于一半(49%)的游戏。**虽然我不认为这是赢了，但对于一场赔率对你不利的比赛来说，这已经相当不错了。第二，它实际上并没有比天真的策略更常获胜，而是能够迫使更多的平局。
Outcome Breakdown by Strategy
我们还可以看看这些策略在我们的关键特征(庄家牌和玩家手牌总数)中的表现。首先，让我们看看庄家的牌对我们三种策略的胜算或平手概率的影响。在下面的图中，如果庄家正在展示一张低牌，我们的神经网络的表现和天真策略差不多。但当庄家亮出更高的牌(7 或更多)时，我们的神经网络表现明显更好。
Probability of Tie or Win vs. Dealer’s Shown Card (Taller Bars are Better!)
我们可以看看赢或平的概率是如何随着玩家的初始手牌总数而变化的。这看起来很有希望——我们的神经网络在各方面的表现一样好，甚至更好。而且不像在绝望谷(玩家手牌值在 12 到 16 之间)表现甚至比随机猜测更差的天真策略，我们的神经网络表现更好。
Probability of Tie or Win vs. Player’s Initial Hand Value (Taller Bars are Better!)
最近的情节暗示了神经网络如何能够超越天真的策略。天真的策略(因为我们是如何编码的)是不愿意在任何时候冒险，哪怕有一丁点失败的风险。另一方面，神经网络会定期点击 12、13、14 或 15。更细致的决策和承担可计算风险的能力似乎使其有别于天真的策略。
Tendency to Hit of Neural Net and Naive Strategy vs. Player’s Initial Hand Value
我们可以看看当玩家的手牌总数在 12 和 16 之间时，神经网络会做什么，以尝试改进我们的天真策略(并且不会给赌场输掉那么多钱)。
看起来，当庄家亮出大牌(8、9 或 10)时，玩家更倾向于出手。但是，即使当庄家展示像 3 这样的低牌时，神经网络仍然有 60%的时间选择击中——这是因为神经网络在做决定时考虑了它拥有的所有特征。所以看起来我们不能轻易地将其决策提炼为几条简单的经验法则。
Neural Net’s Frequency of Hitting vs. Dealer’s Shown Card
结论
希望这篇文章给了你一个关于机器学习如何在现实生活中帮助决策的体面介绍。当您训练自己的模型(无论是决策树、回归还是神经网络)时，请记住以下几点:
- **我的目标变量是否以这样一种方式构建，如果我能预测它，那么我就能解决我的问题？**在你开始收集数据和建立模型之前，确保你预测的是正确的事情是至关重要的。
- 新数据与我训练过的数据有什么不同？如果差异很大，那么统计模型甚至可能不是你问题的正确答案。至少你必须认识到这一点，并建立安全措施，如规范化和严格的(以及诚实的)验证，以及你的模型的测试集基准。
- 如果不能理解模型是如何做出决策的，那么除了使用模型训练过程中获得的测试数据进行严格测试之外，您就无法理解和检查模型的决策。
关于 21 点最后说一句。我大概有一段时间不会再写赌博了(我想探讨的其他话题太多了)。但是如果有人对使用或不使用我的代码感兴趣，这里有几个这个项目的潜在有趣的扩展:
- 尝试通过更优化的神经网络结构来改进模型，或者添加用于拆分 ace 的代码(我没有将此构建到我最初的模拟器中)，或者选择比我使用的基本功能更好的功能。
- 给模型算牌的能力，看看这对一副牌和六副牌的情况(这是维加斯的标准)的性能有何影响。
希望你和我一样对此感兴趣。干杯！
我最近的一些帖子，希望你看看:
教神经网络看道路
用卫星图像和卷积神经网络预测交通事故的位置
Source: https://www.tbftraffic.com/traffic-management-london/
问题是
全世界每年约有 125 万人死于道路交通事故，另外还有 2000 万至 5000 万人受伤或致残。如果交通事故的位置可以预测，这可能会产生巨大的有益影响，有助于减少每年的事故数量。例如，路由软件可以避开最危险的区域——特别是在无人驾驶汽车即将到来的背景下。它在保险领域也很有用，可用于预测风险，也可用于政府和地方公路局，以创建更高效的道路维护和改善系统。
解决方案
带着这个想法，我最近与陈山眉完成了一个项目，试图解决这个问题，使用各种形式的深度学习来预测交通事故可能发生的地方。我们对回答这个问题特别感兴趣:
使用卫星图像能提高模型预测交通事故的能力吗？
我们总共建立了三种类型的模型来预测交通事故的各个方面:
- 使用交通事故、人口密度和交通的结构化数据来尝试和预测事故的严重程度
- 使用卫星图像来尝试和预测一个地区是“安全”(无交通事故)还是“危险”(交通事故)
- 一种奇特的混合数据模型，将在结构化数据上训练的多层感知器和在卫星图像上训练的卷积神经网络的输出组合成最终的神经网络层头
这篇文章是关于模型 2，以及我们如何建立一个卷积神经网络(CNN)来预测一个给定区域在交通事故方面有多危险(但不用担心，花哨的模型 3 将是未来博客帖子的主题——它相当糟糕)。
数据
我们选择伦敦作为我们的试验场——部分是因为英国国家统计局有一些关于交通事故、人口和交通的非常全面的高质量数据；部分原因是伦敦是一个大城市，由市中心区、郊区和大小道路组成，这为训练提供了各种各样的图像；部分原因是因为我住在这里，不被车撞是我的既得利益。
该项目的完整代码可以在我的 GitHub repo 中找到。数据来源包括英国运输部(DfT)的道路安全数据、 DfT 的道路交通统计(是的，我们确实雇佣了一些人站在街角数汽车)、来自英国 2011 年人口普查的数据，以及由谷歌地图静态 API 提供的卫星图像。
该方法
我们选择的区域是我在 M25 号高速公路外侧画的一个正方形，M25 号高速公路是环绕伦敦的大型高速公路(对我的美国观众来说是高速公路)，目的是为了包括各种各样的道路类型:
为了得到一组不重叠的“危险”和“安全”区域，通过将伦敦分成 0.0005 纬度 x 0.0005 经度的正方形来创建和使用网格系统。这导致了 56 米高(纬度)和 35 米宽(经度)的网格正方形(技术上是矩形)，类似于通常用于交通事故分析的 30 米×30 米。
下图显示了叠加在伦敦市中心交通事故地点地图上的方格系统，以提供比例感(事故地点相当有效地追踪了道路系统):
Bonus points if you can spot the Strand and the Thames
一旦我们有了全部方格的列表，我们就使用事故数据集来计算出哪些方格在过去五年中发生过或没有发生交通事故。这些成为我们的“危险”和“安全”类。然后，我们使用谷歌地图静态 API 下载 5000 个“危险”区域和 5000 个“安全”区域的随机样本中每个方块的图像。
下面的图片显示了从每个班级的随机样本中下载的前五张图片。它们表明，危险区域包括郊区的道路、较大的道路和交叉路口(例如，在英国非常常见的环形路)，但并非所有图像都一定只是道路，例如，第四幅图像也包含事故发生道路旁边的绿色区域。
安全区域包括没有道路的绿色区域(不足为奇)，但也包括有道路的郊区区域，这些区域与发生事故的区域有相似之处。这些图像对 CNN 来说可能更难分类，但对它来说也很重要，因为它们意味着 CNN 不仅了解道路和田野之间的差异，还了解不同类型道路之间的差异。
模型
我们尝试了三次 CNN 迭代，试图产生最精确的模型。我们尝试的第一个版本是一个相当简单的 CNN 模型架构，使用 Keras，在最终的 sigmoid 激活层之前有三对 Conv2D 和 MaxPooling2D 层以及一个密集层。它做得相当好，测试准确率(平均 F1 分数)为 72%，没有过度拟合。
这是我们基线模型的代码:
对于我们模型的第二次迭代，我们在 VGG19 预训练模型的基础上构建了 ImageNet 权重，并通过在输出的基础上训练新的分类器之前首先运行我们的图像来提取特征。我们达到了 74%的测试准确率，但是有明显的过度拟合(即训练集达到了更高的准确率)。
对于我们的最后一次迭代，我们使用 L1 正则化来尝试和克服过度拟合。为了尝试和提高准确性，我们增加了图像输入的大小，并添加了一个额外的密集层到分类器头只是为了更好的测量。
结果呢
最后一次迭代是我们最好的模型，达到了 77%的准确率和最小的过度拟合。构建模型的代码有点复杂(没有双关语的意思)，但是在我的 GitHub repo 的 notebook 6 中可以找到。结果如下:
Classification reports (top is the training set, bottom is the test set) and confusion matrix for the final model
我想改进的主要方面是提高召回率，降低误报率——预测 1 =安全，而实际上该区域为 0 =危险。在这种情况下，与预测实际上安全的危险区域的模型相比，这些类型的错误可以被视为成本更高。
今后
为了尝试和提高模型的准确性并完全消除过度拟合，可以在进一步的模型迭代中尝试以下一些方法:
- 下载更多图片用于培训
- 使用不同的预训练模型，如 ResNet50，该模型已在其他 CNN 中用于卫星图像(如此处和此处)
- 冻结预训练模型的特定层，并微调其他层
- 在预训练模型的顶部改变密集连接的分类器的架构(例如，添加更多层或节点)
然而，仅从卫星图像就能正确预测一个地区是否可能发生交通事故的概率为 77%,这仍然令人印象深刻。
感谢阅读——我希望你发现这是一个有趣的话题！将来，我会写我们如何将这个模型与结构化数据结合起来，创建一个非常酷的混合数据神经网络。如果你有兴趣阅读更多，你可以订阅我在 Medium 上的博客，当下一篇文章发表时，你会得到通知。
教一个排外的人工智能健康检查员，和机器学习的伦理
基于德克萨斯州奥斯丁的健康检查分数，并受到这篇关于纽约州水塔检查的媒体文章的启发。
前言:我并不反对我在这篇文章中作为例子的任何一家餐馆，我积极地在所有这些餐馆吃饭。
请继续阅读这些预测的来源！
介绍
我是一名奥斯汀人，一名 UT Austin 的学生，一名脸书的实习生，一名有抱负的数据科学家。
关于数据科学项目，我已经意识到的一件事是底层数据的重要性。
Score average by ZIP Code + Individual Scores
使用对你来说重要的数据既能给你领域的专业知识来发现有洞察力的结果，又能增加你在项目上工作的动力。
这个数据集与我密切相关，因为我在许多这样的餐馆吃过饭，有些得分较高，有些得分较低。
假设
我认为训练一个机器学习模型来预测仅仅基于餐馆名称的健康检查分数会很有趣。我有一种感觉，由此产生的模式最终将是一个排外的模式，比如认为中国餐馆很脏。
Spicy Fish Fillet at Asia Cafe, Average Score: 76.75
在奥斯汀我最喜欢的餐馆中，我敢肯定一些低端餐馆的卫生检查分数会低于理想水平。我相信我的“直觉”(字面和隐喻)，无论如何都会去那里吃。
数据探索
为了确定我想如何对问题建模，我从探索和理解数据集开始。
df.head()
其特点是:
'Restaurant Name',
'Zip Code',
'Inspection Date',
'Score',
'Address',
'Facility ID',
'Process Description'
设施 ID 、地址和餐厅名称对于每个餐厅应该是唯一的。
我对差评餐厅的餐厅名称感兴趣，我将“差评”设为 85 分及以下，并生成了一些单词云。
根据我的经验，这听起来不错。在这一点上，我开始意识到教授一个模型的伦理含义，即名称中带有“taqueria”的餐馆比名称中带有“pizza”的餐馆的健康检查分数更差。我后来在建模部分捕捉到了这个想法，并对其进行了讨论。
每个餐厅可能都有过几次检查。随着时间的推移，我对变化不感兴趣，所以我取消了检查日期，用平均分数代替了分数。
groupby = df.groupby("Facility ID")['Score']means = groupby.mean()df_mean = df_mean.join(means, on="Facility ID", how="right")df_mean.drop(columns=["Scorel"], inplace=True)df_mean.rename({"ScoreR": "Average Score"},)df_mean.drop(['Inspection Date'])
地址有 3 行
6500 S US 183 HWY
AUSTIN, TX 78744
(30.164092387667438, -97.69352171343812)
第一行是街道地址，
第二行是德克萨斯州奥斯汀的邮政编码，
第三行是字符串格式的**(纬度，经度)**。
我想把坐标提取到浮点数中，用于我的可视化。如果我真的关心我们的模型的性能，我也可以提取街道名称作为一个特征，因为街道名称可以给我们提供关于邻居的上下文。
def extract_lat(x):
lst = x.**split**('\n')
string = lst[2]
#substring cuts off the leading and tailing brackets
string = **string[1:-1]**
#split to the lat and long
pair = string.**split(',')**
return **float(pair[0])**
def extract_long(x):
... similar
return **float(pair[1])**lat = df3['Address'].**apply(extract_lat**)long = df3['Address'].**apply(extract_long**)df3['lat'] = lat
df3['long'] = long
邮政编码是一个有趣的分类变量，我稍后也可以在可视化中使用它。
['78744' '78758' '78727' '78617' '78701' '78745' '78751' '78757' '78750' '78756' '78753' '78748' '78705' '78746' '78704' '78721' '78613' '78738' '78741' '78702' '78739' '78724' '78759' '78734' '78723' '78703' '78735' '78729' '78728' '78731' '78752' '78749' '78754' '78669' '78722' '78660' '78732' '78725' '78653' '78730' '78641' '78747' '78726' '78719' '78652' '78733' '78717' '78736' '78620' '78737' '78654' '78742' '78610' '78621' '78615']
然后我开始观察这些特征的分布:
我看了检查分数直方图，很多 100 分(耶)，左尾(恶)。
Histogram of scores
另一件有趣的事情是查看每个邮政编码的分布情况，是否有些邮政编码比其他的更脏？I 根据邮政编码聚合，并为每个邮政编码绘制一个图表
for _, row in df_agg.iterrows():
if row['total_facilities'] > 10:
zipcode = row['Zip Code'] df_zip = df_mean[df_mean['Zip Code'] == zipcode]
sns.distplot(df_zip['Average Score'])
大多数分布看起来像是 78704 分布， 78719 看起来更像是双峰分布，这是令人不安和有趣的。
地图
好了，玩够了 seaborn 和 matplotlib 。这些信息本质上是地理上的，所以构建一些地图是非常有意义的，我使用叶子和 plotly-Express 来实现这些可视化。完整的笔记本将被链接，所以我跳过一些细节。
首先，让我们看看地图上所有的分数。我用 plotly-express 来做这个。
px.**scatter_mapbox**(df3, lat="lat", lon="long",
**color="Score**",hover_data=['Score'], zoom=14)
接下来，看看每个邮编的平均得分结合个人得分不是很有趣吗？我为此使用了叶子，因为 Plotly-express 不支持 geoJSON (邮政编码形状)。
我使用了一个 groupby 和 agg 来计算每个邮政编码的平均得分。
我找到了一个德克萨斯州的邮政编码 geoJSON ，我用它和叶子根据平均分数给每个邮政编码着色。
我想在地图上标出每家餐馆。与 plotly-express 不同，follow 不会渲染超过 1000 个标记，所以我不得不使用 MarkerClusters。
这就是结果。
FFFFFolium’s nauseating cluster animation, sorry!
Score average by ZIP Code + Individual Scores
Mopac，Lamar 和 I 35 走廊似乎很脏。
第六街和市中心也是如此。
建模
现在我对数据有了更多的了解，我应该有更多的背景来开始建模。
My Xenophobic model at work! I wouldn’t want to eat a at a “Mexican Chinese Meat Butcher Seafood Buffet” either
我想尝试做的是建立一个模型，让只根据餐馆名称预测检查分数**。我有一种感觉，即“民族”餐馆与较差的健康检查分数相关，我想说服一个模特了解这一点。**
How do I get a model to know this is a mexican restaurant?
自然语言处理
NLP 意味着以人类能够理解的方式来表达语言的含义。
餐馆名称包含关于它们是什么类型的餐馆的信息,“taqueria”是与“四川”餐馆不同类型的餐馆，等等。
我可以使用 TF-IDF 将这些信息传递到模型中。
TF-IDF 考虑了我们的数据集中所有单词的词汇，并且根据该单词在整个数据集中的频率来衡量该单词在每行数据中的存在。
如果“cafe”这个词很常见，而“carniceria”这个词不常见，TF-IDF 会认为“carniceria”比“cafe”有更多的含义
应用到我们的问题，我敢打赌，一些餐馆听起来像他们有更差的食品检查分数比其他人。
凭直觉， TF-IDF 会找到一家名为 【墨西哥中式肉店海鲜自助餐】 的餐厅，比 【咖啡厅】 包含更多的信息。
One of the dingiest looking restaurants I have ever been in, but the food is great. Score: 89
预处理:
餐馆名称对于文本字符串来说非常短。我必须小心地预处理我们的数据，明智地选择我们的技术来充分利用数据。
n-gram 是由 n 个单词组成的短语，“taco”是 1-gram，“taco joint”是 2-gram。
考虑到作为文本形式的数据的餐馆名称很短，我将 TF-IDF 限制为 n-grams==1，就像只使用像“taco”和“joint”这样的单词一样。
我可以做的另一种形式的预处理是从我们的餐厅名称中删除数字和符号，“棒约翰的#928”变成了“棒约翰”。
Food from Asters
建模:
我使用了 XGBoost，一个非常通用的模型。
我还得决定如何表达这个问题。
回归: 如果我将问题表述为回归，我可以将目标变量设置为分数。**“给定一个餐厅名称，预测它的卫生检查分数”**
或者，我可以通过为一个令人讨厌的分数设置一个阈值，比如低于 85 分，来把这个问题表述为分类。“给定一家餐馆的名字，预测它在卫生检查中得到“坏分数”的几率”****
我选择了 85 分而不是 70 分(不及格)，因为不及格的分数很少，我不想要极度不平衡的班级。
# Get the tfidf vectorstfidf_vec = **TfidfVectorizer**(stop_words='english', norm='l2', ngram_range=(1,1))tfidf_vec.**fit_transform**(X['restaurant_name'].values.tolist())train_tfidf = tfidf_vec.**transform**(X['restaurant_name'].values.tolist())regressor = xgb.XGBRegressor()
regressor.**fit**(train_tfidf, df4['score'])classifier = xgb.XGBClassifier()
classifier.**fit**(train_tfidf, df4['score'] < 85)eli5.**show_weights**(classifier, vec=tfidf_vec)
来自分类器的权重，这些是与低于 85 的“坏分数”相关的单词
TF-IDF 和 XGboost 的好处是，该模型非常容易理解，您可以很容易地看到与低于 85 的“糟糕分数”直接相关的单词，结果与预期的一样，并且与早期的单词云相似。
我使用全部数据进行训练，所以让我们用一些任意数据来测试模型。
回归器根据输入字符串预测得分。以下是我发现的一些有趣的预测结果。
$4 for 3 Breakfast Tacos, La Tapatia, Score: 87.5, I have been coming here for years
显然，奥斯汀的一些餐馆往往比其他餐馆更脏，我一直通过查看数据和我们的模型来怀疑这一点。
伦理学
这整个数据集有很多有趣的伦理考量。
准确性与社会危害:
好吧，也许一些餐厅往往不如其他餐厅干净，这是否意味着我可以允许人类或人工智能健康检查员针对这些类型的餐厅？
准确性和不公平地针对某些人群之间的权衡。
有人可能会说防止顾客生病很重要。
另一个人可能会争辩说，针对特定类型的餐馆是荒谬的，因为“数据就是这么说的”
最佳解决方案取决于它是什么类型的问题。
在招聘时，模特不可能被允许使用“种族”或“性别”，因为这些是 EEOC 明确保护的。
在广告定位中，使用那些相同的特征可能更容易被接受，因为不同的人口统计仅仅具有不同的消费模式
数据中的人为偏差 训练数据由人类健康检查员生成。如果那些人类健康检查员讨厌中国餐馆，这个模型也会学会同样的憎恨。
根据我的经验，我有相对较好的信心认为这些数据接近事实，但这种探索仍然表明了盲目训练模型的危险，因为“数据说什么，数据就说什么！”。
一个模型会学习它被训练的数据中的任何东西。
数据科学家的人类偏见:
我试图通过让一个模型认为中国餐馆很恶心来证明这一点。在我找到一个能证明我观点的模型后，我停了下来。这样，我在文章中展示的模型也代表了我的偏见。
我在寻找一种利用数据来证明我的观点的方法，当我找到这样做的方法时，我就停止了。试图提出另一个观点的人可能也会让数据支持他们的观点。
模型复杂度成本:
在我们的例子中，我应用的 TF-IDF 技术相对简单易懂，我们可以看到哪些词与目标变量相关。
但是如果我使用更先进的技术呢？
如果我用 word2vec + LSTM RNNs 举例呢。更复杂的模型，如具有单词嵌入的 RNN，能够理解数百个单词之外的文本内容中单词之间的关系，并且具有类似于人类记忆的长期和短期记忆。
对于如此复杂的模型，要“诊断”为什么模型会预测某些预测结果要困难得多。
像谷歌这样的公司肯定也有成千上万的功能和模型，它们不仅理解功能，还理解这些功能之间复杂的交互和关系，什么人可能理解这样一个模型的工作方式？
如果我们不明白为什么模型是准确的，我们还能相信准确的模型吗？
结论
该数据集中有 22，000 个检查，5，000 个被检查的独特企业，以及大约 50 个邮政编码。
我的模型只使用 TF-IDF 和餐馆名称进行预测。
如果有人希望构建一个更关注模型准确性的模型，数据集中还包含一些其他重要的功能。
其他一些很棒的特性是邮政编码作为一个分类特性。
以(北、南、东、西)作为分类或文本特征的街道名称，包含位置的邻域级别上下文。
过程描述有“常规”、“跟进至低分”和“第二次跟进至低分”，必须有某种方法来教导一个模型，该模型在较差的检查之后分数通常会上升。我在这次探索中没有使用时间序列，但肯定有办法。
日期，也许卫生检查员周一更暴躁？
这就是我对一个数据集的分析，这个数据集既与我个人密切相关，也与我毫不相关(外出就餐时，我“相信自己的直觉”)。
教人工智能如何做量子力学
Pictured top left: Schrodinger, Einstein and Pople. Pictured bottom middle: Hinton and Bengio
使用传统的先进方法，精确计算化合物的量子力学性质，如原子化能，可能需要几个小时到几周的时间。这篇文章探索了使用深度神经网络在几秒钟内计算上述属性，准确率达到 99.8%。
Training a DNN to predict atomization energy based on a Coulomb matrix input. The average error is 3 kcal/mol, equating to a mind-boggling 99.8% accuracy
答在 20 世纪 20 年代发现量子力学之后，科学家们很快意识到从该理论中产生的基本方程只能在最简单的系统中求解(比如氢原子……)。用诺贝尔奖获得者保罗·狄拉克自己的话说:
“潜在的物理定律必要的数学理论的大部分物理和整个化学因此完全知道，困难只是这些定律的精确应用导致方程太复杂而无法解决。因此，发展应用量子力学的近似实用方法变得很有必要，这可以导致对复杂原子系统的主要特征的解释，而不需要太多的计算”——保罗·狄拉克，1929
接下来的快速发展是寻找新的近似方法来处理这个复杂的问题。由此产生了两种最先进的方法: 哈特里-福克理论(HF)密度泛函理论 (DFT)。
特别是，在 20 世纪 90 年代，DFT 取得了突破性进展，至今仍保持着领先水平。
今天，DFT 是计算化学和材料科学的基石。例如，它可用于精确模拟大分子的电子密度表面，如巴克敏斯特富勒烯:
Electron density map of Buckminsterfullerene (C60)
DFT 和 HF 的问题是，要得到准确的结果，还是需要很长的时间:小时，天甚至几周。
我们将使用深度神经网络的预测能力将这个时间缩短到几秒钟。
这篇文章附带了一个 Google Colab 笔记本,可以用来阅读和深入研究这里提到的一些过程。
最后，对最初出版这部作品的 G .蒙塔冯等人给予应有的感谢。确实是一个伟大的发现，他们正在继续做一些有趣的事情。
1.什么是库仑矩阵，为什么它很重要？
库仑矩阵是一种装置，本质上存储不同原子相互作用的所有信息。
准确地说，它储存了分子中所有原子对的成对静电势能。
分子的每个原子都有一个与之相关的 电荷 。此外，每个原子都有一组表示其在空间中的位置的 3D 坐标。因此，对于每一对原子，我们记下两个原子的距离。那么库仑矩阵就是:
Definition of the Coulomb Matrix
我们希望使用库仑矩阵作为我们的数据输入，因为它具有预测能力。
事实上，给定库仑矩阵，我们可以进行 DFT 或 HF 计算，以精确计算复杂的量子力学性质(库仑矩阵直接进入薛定谔方程——参考前面的图像)。
我们本质上是使用库仑矩阵来隐含地教导机器学习模型关于量子力学的规则。
2.库仑矩阵有什么问题？
事实上有三个问题。幸运的是，这些都可以解决，仍然可以产生一个非常有用的模型。
2.1 不同大小的分子有不同大小的库仑矩阵。这与机器学习不兼容。
这个问题的解决方案是填充较小分子的库仑矩阵的边缘，就像这样:
幸运的是，我们使用的数据中已经生成了填充库仑矩阵。我们暂时不需要担心这个问题。
2.2 存在几个(N！准确地说)标记你的分子的方法——每种标记方案都会产生不同的库仑矩阵。
Different atom labeling leads to different Coulomb matrices of the same molecule
解决这个问题的方法是简单地按照最大原子的顺序对矩阵进行排序。
但是有一个问题——在排序时，我们实际上给矩阵添加了一点噪声，所以每次排序都略有不同。这使神经网络暴露于同一库仑矩阵的几个微小变化，使其更加鲁棒，并防止过拟合。
2.3 订单中包含大量与标签相关的信息
这个问题可以通过将库仑矩阵通过激活函数转换成二进制输入(0 和 1)来解决。这方面的细节并不重要，要了解更多细节，以及这篇文章中提到的许多其他细节，请阅读以下内容:学习原子化能量预测的分子不变表示
Converting the Coulomb Matrix into a Binary input
对于以上两个问题，这些输入输出类会整理一下。你可以通过代码工作，或者你不能这样做，只是信任它；)
Stochastic augmentation and input processing functions
3.我们的数据是什么？
我们使用了大约 7000 个分子的数据，这些分子具有几个不同的官能团。
对于每个分子，库仑矩阵已经计算出来(这在代码中很容易做到；每个分子的原子坐标都使用 MM94 力场进行了优化——都相当标准。
对于每个分子，我们还使用 DFT 实现计算其原子化能量，这是一种量子力学属性。这是我们试图预测的数据，我们将使用计算值来训练我们的神经网络。
The flow of data from molecule to quantum energy prediction
4.我们的深度神经网络是什么架构？
我们使用一个非常简单的架构:2 个完全连接的隐藏层，每层分别有 400 和 100 个神经元。
使用 Xavier 初始化对重量进行初始化。
更复杂的架构有很大的发展空间(请随意尝试，如果发现更好的，请告诉我)，但这个简单的结构适用于这个问题。
We used something somewhere in between these two…
我们使用 Adam 优化器来最小化我们的 MSE(均方误差)损失函数。
神经网络在 Google 的 Tensorflow 库中实现，代码在 Colab 笔记本中。
5.结果
如果你想深入了解更多细节，请点击这里查看 Google Colab 笔记本。
您应该能够毫无问题地运行它，并且神经网络应该训练得非常快(大喊免费 GPU 的 Google Colab)。
回归的结果如下所示。很好，如你所见…
The straight line represents a perfect prediction while the scattered points represent predictions made by the DNN
6.后续步骤
要深入探究这篇博客文章中的更多概念，请继续阅读发表这项研究的原始论文。
这个研究小组发布了更多关于这个想法的论文，所以一定要去看看。
如果你喜欢这个，给这个帖子鼓掌，在 LinkedIn 上和我联系，告诉我你喜欢什么。下次见！
教人工智能起草魔法:聚会
或者，如何训练你的机器人来训练你的龙
概观
在《魔术:收集草稿》中，玩家反复地从一副牌中选择卡片，尽可能地制作出最好的一副牌。使用人类进行的草稿中的数据，我训练了一个神经网络来预测人类将从每副牌中取出什么牌。在这项任务中，它达到了 60%的准确率。在 40%的情况下，当人和模型不同时，模型的预测选择往往比人的选择更好。可以在这里找到一个笔记本，上面有模型训练代码和样本结果。
词汇表
- 魔术:聚会[MTG]:有史以来最好的纸牌游戏。“有点像扑克和象棋的结合，但是有龙”，这是我在去比赛的路上对拼车司机描述的。作为一名玩家，你召唤并指挥各种各样的神话生物，然后当你们两个施展魔法将它们推向更高的高度时，它们与对手的生物一决雌雄。
- 构造:MTG 最常见的玩法。比赛开始前，每个玩家制作一副 60 张的牌，并把它带到战场上。优点:自我表达(你可以选择你的牌组中放什么牌)。缺点:必须提前获得所有该死的卡($$$)。
- 草稿:在作者看来，扮演 MTG 最好玩的方式。你和其他 7 名玩家围坐在一张桌子旁。你们每人打开一包 15 张的卡片。你从你的包里抽出一张牌，然后把剩下的 14 张递给你的左边。你从这 14 张牌中抽出一张，然后把 13 张递给你的左边。重复，直到所有的牌都没了；现在你面前有 15 张牌。然后循环又开始了:你和其他 7 个人每人打开第二包。重复第三次，你有 45 张牌。然后用你起草的卡片做最好的一副牌。选秀的美妙之处在于，每个人都是在一个公平的竞争环境中开始的，而且每次都是不同的，因为你永远不会两次选择同一副牌。
要掌握草稿，你必须平衡每张牌的原始能量水平，牌与牌之间的协同作用，以及你在任何给定时间从剩余牌中接收到的信号。
培训用数据
魔法工厂的老板好心地给我发了一个. json 文件，里面有第二部最新的 MTG 系列《拉夫尼卡行会》的 2130 份草稿。
我还搜集了 draft sim 的档案，在这个网站上，人们可以按照预先设定的挑选顺序练习与机器人对抗。根据这一数据训练的模型与根据 Flooey 数据训练的模型达到了类似的准确性水平，但我注意到模型做出了更差的选择，因为 Draftsim 用户比 Flooey 用户做出了更差的选择，可能是因为他们没有参与赌注。尽管 Draftsim 比 draft sim 多几个数量级。
数据表示法
为了表示一副牌中可供选择的牌的集合，我们可以使用一个长度为 N 的向量，其中 N 是 Ravnica (250)的公会中不同牌的数量。每张卡都有一个索引。您看到的第一副牌中有 15 张牌，因此它的向量将有 15 个 1(该副牌中牌的索引)和 235 个 0。第二个包将有 14 个 1 和 236 个 0，等等。
为了表示我们已经选择的卡片，我们可以使用另一个长度为 N 的向量，其中每个索引处的值是我们已经起草的卡片的编号。每次选秀的第一个选秀权都是零。对于第二次选择，将有 1 个 1 和 249 个 0。对于第三次选择，它可能是 2 个 1 和 248 个 0…除非我们从前两包中取出同一张牌，在这种情况下，它将是 2 和 249 个 0。
总之，我们模型的输入是一个长度为 2N 的向量。
输出是一个长度为 N 的独热编码向量，在人拿的牌的索引处被设置为 1，在其他地方被设置为 0。
这种表示忽略了草稿的一个重要特征:记忆你在之前的一副牌中看到的和没有拿到的牌。职业玩家使用这些信息来猜测他们在未来的牌包中可能会看到什么牌。我们可以通过给每个输入增加额外的 45 个长度为 N 的向量来表示。这些向量中的第一个将代表我们第一次选择时看到的牌，除非这个*是我们的第一次选择，在这种情况下，它都是零。一般来说，这些向量的第 K 个代表我们在第 K 次选择时看到的牌，如果我们确实已经进行了 K 次选择，否则都是零。
在模型中包含这些信息会将输入表示的大小乘以 24，这对于只有 2000x45 个数据点的情况来说并不理想。随着更多的数据，我认为这可能是一个有价值的功能添加。
建模
我试验了一个线性 SGD 分类器，它达到了 50%的准确率。然后，我尝试了一个神经网络，它有两个 512 个神经元的密集层，中间有一个 N 长度的 softmax 层，准确率达到了 59%。
定性评价
我浏览了测试集中的一些草稿，让模型在每个阶段说出它会选择哪张牌，给定已经选择的牌，以及人类选择的牌。你可以在这篇文章附带的笔记本中看到它们。
模特绝对理解色彩的概念。在 MTG 有 5 种颜色，任何给定的草稿牌都可能只使用其中 2 或 3 种颜色的牌。因此，如果你已经拿了一张蓝卡，你应该更有可能在未来的选择中拿蓝卡。我们没有告诉这个模型，我们也没有告诉它哪些牌是什么颜色。但不管怎样，它还是学会了，通过观察哪些卡片经常是相互组合的。
由于 MTG 问题还没有像国际象棋和围棋那样得到解决，所以不可能确切地说模型的选择有多好。我是一名正派玩家，当我看牌时，我看不出有什么明显的问题。事实上，当它和人类绘图员意见不一致时，我发现我倾向于更喜欢模型的选择。但我有偏见，所以请你自己看看这些精选，然后告诉我你的想法，或者让你最了解 MTG 的朋友去看看，然后反馈回来。
毫无根据的猜测
让一千个人猜一大罐软糖里有多少颗软糖。平均每个猜测的绝对误差。然后平均猜测值，取that的绝对误差。后者会少错一些。
http://wisdomofcrowds . blogspot . com/2009/12/chapter-one-part-I . html
我认为类似的事情正在这里发生。每个人都高估一些牌，低估另一些牌。将所有这些误差平均在一起，你会得到一个更好的结果。
未来的工作
如果我们对训练集中的每副牌都有匹配结果(即，每副牌最终赢了多少局)，我们可以让模型不仅针对与人类选择的相似性进行优化，还针对进行给定选择后预期牌的质量进行优化。对于一副牌中的每一张牌，模型会从这一点出发，设想出成千上万种可能的走法，并评估最终的牌组。然后它拿走给它最好的梦的卡片。也就是说，我们可以全力以赴阿尔法零。
另一个令人兴奋的可能性是将来自 MTGJSON 的数据添加到模型中。现在，每张卡只是 1 到 250 之间的随机整数。有了来自 MTG JSON 的信息，我们将添加关于哪些卡片是相似的明确信息。这将允许模型起草一个新的集合，而不用看到人类先起草它。
直到下一次，愿你无法区分足够先进的魔法和技术。
教人工智能写流行音乐
因为谁还有时间自己写呢？
我从来都不擅长写歌词。在我高中的 ska 乐队中，我创作了圆号部分和一些其他乐器，在我大学的一个无伴奏合唱团中，我总是整理已经写好的歌曲的封面。很少有一场斗争让我觉得我可以写一首关于它的歌，但当我写的时候，它们总是俗气和蹩脚的。经过多年的放弃，我终于发现了我需要的工具来解决写歌词的问题，同时将自己从过去的跛脚感或劣质感中分离出来。利用递归神经网络和一个与我心心相印的数据集，我将最终解决几十年来一直存在的问题——写歌词。
The CD that started it all
当我 7 岁的时候，我得到了一张汉堡王的 CD，作为儿童餐的一部分:一张 7 首歌的后街男孩 CD，名为“给粉丝”。这张专辑点燃了我对乐队的爱，这个乐队很快就发行了他们的热门歌曲“我想要那样”。那首歌几乎毫无意义。《我想要那样》是瑞典音乐创作巨星马克斯·马丁在他的英语还不流利的时候写的，这就是为什么这首歌在任何时候表达的意思都不一致。由于其商业上的成功和它的意义，在人工智能生成的歌曲中，“我想要它这样”是一个伟大的一致性基准。
使用生成神经网络模型，我可以从他人的作品中获得灵感，并通过与写歌相关的作家障碍，直接进入编辑阶段。因为我对男孩乐队深深的(和真正的)热爱，我将记录我使用递归神经网络(RNN)编写男孩乐队歌词的人工智能艺术的尝试。这个项目使用的所有代码都在我的 GitHub 上，特别感谢 T2 的丹尼·门多萨的帮助。以下乐队的完整作品用于训练我的模型:
- 后街男孩
- 超级男孩
- Boyz II Men
- 一个方向
- 我们为什么不呢
- 新来的孩子
- 乔纳斯兄弟
- 通缉犯
LSTM and GRU nodes are great for recognizing sequences in data Source
生殖模型绝不是新的，但与人类的艺术相比，通常不会受到重视——明显的例外是售价超过 40 万美元的人工智能生成的艺术作品。有不同的技术用于生成不同类型的艺术——生成对抗网络(GAN)生成图片，而 rnn 由于其识别和创建连贯序列的能力而生成音乐和文字。为了这个项目，我在我的神经网络中使用了门控循环单位(GRU)层，但该领域的同事也成功地使用了长短期记忆(LSTM)网络。
为了收集数据，我结合使用了 web 抓取和 python 包调用。最初，我计划抓取我想要的歌曲的所有歌词，但被狡猾的网络开发者阻止我从他们的网站抓取 700 首歌曲。由于我只能获得艺术家和歌曲名称的列表，所以我使用 PyLyrics 包制作了一个去掉了任何格式和标点符号的歌词列表。我将从我的输出中提取一系列单词来制作一首歌曲，而不使用歌曲本身的任何格式。一旦我有了歌曲的所有歌词，我将所有的单词添加到一个列表中，作为生成 7 个单词长的单词序列的标记。在删除重复序列后，我训练我的 RNN 模型来预测每个序列的最后一个字，给定前 6 个字。下面的函数显示了模型如何获取一个种子词，并生成我们可以选择长度的歌词。
使用我的 RNN 和这个 gen_sequence 函数，我编译了模型的输出来写一首男孩乐队的歌。模型的原始输出在左边，模型被训练的时间在右边。尽情享受吧！
教 RNN 人写代码
请放心，您可以阅读本文的其余部分，知道您的开发职业不会有任何风险。
上学的时候对计算机科学和开发了解不多，偶然发现了这个很酷的网站。当键盘上的任意键被点击时，它会输出视觉上有意义的代码。它让任何人看起来都像一个专业黑客，整个矩阵都是黑底绿字，发现这个工具意味着巨大的责任，因为它有可能给人留下深刻印象——但这是另一个故事了。
Source code of the matrix (Cloned from Keanu’s GitHub)
几年后，在发现了 RNN 氏症之后，在抽出一些空闲时间从事这个迷你项目之后，我终于有机会目睹了“代码创建”，结果令人捧腹。
数据集
对于本文，我决定用两个数据集来训练网络:
- 我从 https://github.com/gcc-mirror/gcc 的拿的几个 C 文件。(完全公开——因为我的 C 语言知识是中级的，所以我随机选择了两个看起来足够长的 C 文件)
- HTML 页面——没有任何内联或外部 CSS 或 Javascript。
框架和平台 我很喜欢学习 TensorFlow (v2.0)和 Keras ，但我会将本教程主要放在 TensorFlow 上，并在我认为比 TensorFlow 更容易实现或理解的地方提供 Keras 实现的示例。
我使用过Google Colab——这是一个由 Google 提供的很酷的云服务，允许你完全在云上运行你的 Jupyter 笔记本 env(无论是 CPU 还是 GPU 运行时)
想法
在文本生成领域，递归神经网络——特别是长短期记忆(LSTM) 网络擅长记住给定输入的输出历史，然后相应地预测新的结果。
这听起来可能比实际情况复杂一点，所以让我试着分解一下—
考虑一下正文
这只狗被命名为猫。
现在，当我们将此作为训练数据提供给 RNN 时，我们将文本中的每个标记等同于其输出的直接邻居。
Input to Output correlation [ training data ]
每个[i+1]元素被训练为每个第 I 个元素的输出。
步伐
1。导入库和数据集
使用 Google Colab 允许我们通过使用 google.colab 连接到 Google Drive 上的数据集。验证您的帐户后，您可以装载驱动器并指向您的数据集。
2。准备查找表和数据集
查找表负责将字符转换为整数，并将整数转换为字符。字符的查找表是建立在我们的文本词汇上的。
现在，我们可以将数据集分成输入(dataX)和输出(dataY)。为了创建数据集，我们通过每个字符的步长来累积输入和输出。这里，每个训练模式是一个字符(输入)的 100 次步进，后跟一个字符输出。我们从文本的开头开始，直到结尾，如果有任何剩余部分，就把它们去掉。
sequences = char_dataset.batch(seq_length+1, drop_remainder=True)
char_dataset = tf.data.Dataset.from_tensor_slices(text2int)def split_input_target(chunk):
dataX = chunk[:-1]
dataY = chunk[1:]
return dataX, dataYdataset = sequences.map(split_input_target)
3。构建和编译模型
def build_model(vocab_size, embedding_dim, rnn_units, batch_size):
model = tf.keras.Sequential([
tf.keras.layers.Embedding(vocab_size, embedding_dim,
batch_input_shape=[batch_size, None]),
tf.keras.layers.GRU(rnn_units,
return_sequences=True,
stateful=True,
recurrent_initializer='glorot_uniform'),
tf.keras.layers.Dense(vocab_size)
])
return model
并且训练模型！这个模型在 Colab 上被训练了 30 个时期
model.compile(optimizer='adam',loss=tf.keras.losses.sparse_categorical_crossentropy(target_example_batch, example_batch_predictions, from_logits=True)**)**model.fit(dataset, epochs=EPOCHS, callbacks=[checkpoint_callback])
4。生成结果
有两组共享的结果
- HTML 数据集——使用的数据集来自维基百科(随机页面),因为它有很多 HTML 属性。我尽可能地删除了内联 CSS，这是训练数据的样子-
(INPUT) looks structured even without most of the CSS elements
下面是模型生成的代码(HTML 预览)
(OUTPUT) Lower temperature predicted output, 5000 predicted characters
(OUTPUT) Higher temperature predicted output, 10k predicted characters
温度越低，文本越容易预测。更高的温度导致更令人惊讶的文本。
OUTPUT: Lower temperature, 10k predicted characters
2.生成 C 代码
胡言乱语，但努力。
感谢您的阅读！
教 GPT 2 号变形金刚幽默感
如何在 PyTorch 中单个 GPU 上微调大型变压器模型
Photo by Ben White on Unsplash
在这篇文章中，我演示了如何使用预训练的 GPT-2 来生成文本，然后使用单个 GPU 在特定的语言建模任务中对其进行微调。在这种情况下，我试图通过在笑话数据集上对模型进行微调，让它变得有趣。
GPT 2 号
最近 OpenAI 团队发表了一篇文章更好的语言模型，以及一篇技术论文语言模型是无监督的多任务学习者关于训练更大更好的语言模型。他们研究语言模型的能力，以生成连贯的文本，并在零射击设置中解决 NLP 任务，这意味着使用模型解决没有明确训练过的任务。
Image Credit: OpenAI
他们创建了一个基于 transformer 的语言模型，他们称之为 GPT-2，并在一个巨大的 40GB 互联网文本数据集上训练它。他们在语言建模任务中训练该模型，该任务是预测单词序列中下一个单词的概率。为语言建模训练 NLP 模型，然后为特定任务进行微调是训练 NLP 模型最常见的途径之一。为语言建模预先训练模型是方便的，因为它不需要带标签的数据来学习语言的结构——它只需要纯文本，这是大量公开可用的。大多数公开可用的预训练 NLP 模型是为语言建模而训练的。
他们在训练后生成文本的结果令人印象深刻。这些片段感觉非常人性化和连贯，几乎令人毛骨悚然。此外，该模型在各种语言建模任务(包括摘要、阅读理解和翻译)的零射击设置中获得了最先进的分数。
微调实验计划
所以我决定用 GPT 2 号做一点实验。我觉得教模特讲笑话会很有趣。为此，我需要一个笑话数据集和一个预训练的 GPT-2 模型进行微调。
Photo by Helloquence on Unsplash
由于人工智能社区和一些特定团队的慷慨，他们发布了预先训练的神经网络模型，解决像这样的挑战性任务的相对廉价的解决方案是可能的。从头开始训练这样的大型神经网络模型将花费数万美元，在某些情况下，甚至数十万美元。在单个 GPU 上，针对新任务对预训练模型进行微调可能需要几个小时。我会做到的。
Huggingface 已经在 PyTorch 中提供了许多预先训练好的变形金刚模型以方便使用。我将使用他们预先训练的 GPT-2，并在 Kaggle 上发布的这个短笑话数据集上进行微调。
GPT-2 有 4 种不同的尺寸——小、中、大和 XL ，分别有 124 米、355 米、774 米和 1.5 米的参数。我发现，一个中等大小的 GPT-2 模型是我可以在单个 GPU 上用合理的输入序列长度进行微调的最大模型。
Image Credit: Image by Jay Alammar from post The Illustrated GPT-2
通过生成文本来测试预训练模型
在对笑话的模型进行微调之前，我将在生成文本时对其进行测试。
在下面的要点中，我演示了如何通过使用来自 huggingface 的预先训练好的中等大小的 GPT-2 来生成文本。首先，我将向模型提供以下文本片段，并让它生成其余部分:
‘母体’无处不在。它就在我们周围。即使现在，就在这个房间里。当你向窗外看或者打开电视时，你可以看到它。当你去工作的时候，当你去教堂的时候，当你交税的时候，你能感觉到。是这个世界蒙住了你的眼睛，让你看不到真相……’
‘人工通用智能是……’
教父:“我要给他一个他无法拒绝的提议。”… ’
从生成的关于技术的阴谋论，关于 AI 行业的威胁性预测，以及教父与自己的对话来看，我会说文本生成在起作用。
在单个 GPU 上微调模型
大型变压器模型通常在多 GPU(或 TPU)设置中训练，因为在大型模型上训练合理的批量大小和序列长度需要大量张量/图形处理单元内存。我的机器配的是单颗 GeForce 1080 Ti，内存 11 GB。通过对中型 GPT-2 模型的经验测试，我发现我的 GPU 在一个批处理中处理的最大总序列元素数大约是 550，这不是很多，可能不足以成功进行微调。
但是我们可以考虑一些事情来改善这种情况。
首先要注意的是，基于 transformer 的模型的前后传递中的批量大小不起作用，因为使用了层归一化而不是批量归一化。在图层归一化中，每个特征在特征尺寸上归一化，不涉及批量尺寸。
第二，我们可以在多次向前-向后过程中累积梯度，然后才进行模型权重更新。这样，我们不必将整个批次的计算图存储在存储器中，但我们可以一个序列接一个序列地处理，并获得相同的结果，就好像整个批次在单次向前-向后传递中被处理一样。
考虑到这一切，我将一次处理一个最大长度为 550 的序列，并对每个 BATCH_SIZE 处理的序列进行模型权重更新。
笑话的长度在数据集中变化很大——有许多短序列。为了使一个优化步骤中的总序列元素数更加一致，我将尝试在每个 550 个元素的序列中加入尽可能多的笑话。
结果和结论
Photo by Marcela Rogante on Unsplash
教人工智能生成对人类来说很有趣的文本是一个困难的问题，我认为这比生成一个连贯的文本要困难得多。即使对一个人来说，这也不容易做到——这需要一种特殊的创造力，对环境的理解，甚至对人类心理的理解。向语言模型输入许多笑话可能不足以让模型真正了解什么让事情变得有趣。训练人类水平的开玩笑模型可能需要更复杂的技术和更多的数据。
尽管如此，看到这种语言模型的尝试还是很有趣的。偶尔，这个模型会设法产生一个有趣的人类水平的笑话。
*当我开始实验时，我没有注意到数据集中有很大一部分笑话是种族主义和粗鲁的，这意味着你可以在模型生成的笑话列表中预期相同的内容。我为此道歉并做好准备。
这里是 完整生成的笑话列表 。
如果你在生成的笑话列表中看到一些好的和有趣的东西，请在评论中发布。:)我自己也没有全部通读。
这是转贴自我的原创博客。
教他们扮演上帝
对初学者友好的角色生成介绍
Photo by Aaron Burden on Unsplash
冒着成为另一个“用 RNN 生成文本”教程的风险，想到 Shakespeare 和 Lewis Carrol 在坟墓里为这些普通模型通常生成的文本畏缩不前，我选择了一条不同的路线，但同时决定对此进行挖掘。
《圣经》是人类历史上销量最大、最有影响力的书籍。人类思想、阐述和创造的巨大宝库都围绕着这本书。
这就引出了一个问题——递归神经网络能被很好地训练以产生布道吗？
在这个玩具示例中，我们将通过相对简单的代码行来尝试这一点。我们的期望不高，因为我们将使用一个非常简单的架构。这篇文章的目标是学习如何在 tensorflow 中使用 RNNs 进行文本生成。我以前在 tensorflow 中训练神经网络时确实假设了一些背景，只是我不会解释例如损失函数或 softmax 是如何实现的。
版本:Python 3.6 和 Tensorflow 1.15.0。
我们开始吧！
数据
既然深度学习没有数据就无法进行，那我们就来获取一些数据。古腾堡计划有一些精彩的书籍供公众免费使用[多么讽刺啊，因为古腾堡圣经是第一个用活字印刷的文本]。我们将在这里得到国王詹姆士版本。
预处理
圣经的结构相对来说比其他书简单。即使这样，我们可能会遇到一些我们不希望被馈入我们的模型的怪异角色。让我们来看看数据:
我们不希望我们的模型学习像’ \ ‘、’ { ‘、’ \n '这样的字符。事实上，让我们看看文中独特的人物:
print(sorted(list(set(data)))
数字很重要，因为它们表示诗句，其他标点符号也可以，但我们可以没有以下内容:
那更好。这段文字中有 48 个独特的字符。
在我们继续这个模型之前，我们需要做两件小事。这些角色不能以他们本来的样子存在。我们需要对它们进行整数编码，以便能够将它们作为输入数组。类似地，当我们预测字符时，我们需要一种方法将获得的整数再次解码为字符。所以我们可以创建两个字典，一个保存一个字符到一个整数的一对一映射，反之亦然。让我们这样做:
char_to_int = dict((i, char) for char, i in enumerate(unique_chars)) int_to_char = dict((char, i) for char, i in enumerate(unique_chars))
在此之前没有什么需要解释的，请检查您是否有以下映射:
Char to int
int to char
批量生成
许多深度学习训练碰巧涉及到对数据的大小、形状、结构等做出决定。文本太大，无法一次输入，现实世界中的大多数问题都涉及到比我们目前正在处理的文本更大的尺寸。分批训练不是一件好事。这是必要的。
特别地，RNNs 使用通过时间的*反向传播【BPTT】*进行训练，这基本上是在每个时间步长上展开的传统反向传播。一个很好的引子就是这个。
因为我们不能在整个文本上应用 BPTT，所以我们在生成的批处理上应用它。我们如何生成这些批次？这主要是一个设计问题，但是我已经实现了下面的过程:[如果您只对代码感兴趣，可以跳过这一部分]。
(1)将全文分成 16 块。
(2)每个块包含字符序列。我们选择 256 作为我们的序列大小。
(3)我们创建的每个批次 i 包含来自每个块的第 i 个序列。这个。意味着每批包含 16 个序列，每个序列的大小为 256。这意味着批次 1 具有来自*块 1、块 2、…的第一个 256 字符序列。，第 16 块。同批次 2、批次 3、…、*等。我们有多少批？总共有n个字符，这是标准的中学数学
n = batch_size * sequence_size * no_of_batches
当然，这不会总是被整除，这取决于所选择的四个整数值。例如，在我们的例子中，n = 4233042, batch_size = 16, sequence_size = 256, no_of_batches = 1034但是如果你仔细观察，最后一批的序列大小不可能是 256，而是一个更小的值【拿出笔和纸，试着算出这个值会是多少】，因为当我们到达最后一批时，我们已经用完了所有的字符。
我们可以放弃这最后一批，以避免以后出现形状不匹配的问题。我们现在有了no_of_batches = 1033，所有的阵列都在(16, 256)成形。
好了，总之，1033批，每批包含 16 个序列，每个序列256字符长。
顺便说一下，我描述的整个过程有一个名字——*截断的时间反向传播。*很多细节这里。
下面是完成我刚才提到的所有事情的代码:
Batch generation
下一个问题是，我们如何创建输入值和目标值？这很简单。考虑下面的例子:
X -> the dog。
这方面的目标是:
Y -> he dog。
目标向量中的每个字符 i 都是输入向量中的第( i + 1】个字符。注意Y是如何比X小一个单位尺寸的。这是因为当你到达X的最后一个角色时，就没什么可预测的了。因此，我们可以简单地删除X中的最后一个字符。这个小小的观察很重要，我们最终得到的X和Y都是(16, 255):
Creating the Dataset
搞定了。我们现在准备构建我们的模型。
架构和培训
我们将选择一个简单的架构——两个隐藏层，一个多单元，每个 LSTM 单元包含 256 个隐藏单元，一个 softmax 输出层包含 k 个单元，其中 k 是我们数据中唯一字符的数量【有道理，对吗？].
就是这样！
Model Architecture
这应该是不言自明的，除了我为输入和标签添加了一个热编码的部分。注意，在我们的例子中，这将形状(16, 256)转换为(16, 256, k), k = 48。我选择了少量的时期来检查训练损失是否表现得像它们应该表现的那样——逐渐减少。稍后，您可以随时使用这些超参数。
让我们训练我们的模型:
Train for 5 epochs
请注意，您需要将每个时间步 t 的最终状态作为( t + 1) 的初始状态。这是至关重要的。
我们得到以下损失曲线:
Train Loss per epoch
漂亮的肘状动作。损失有:[1.54, 1.16, 1.10, 1.07, 1.05]
生成神的话语
真正有趣的时候到了。让我们用这个简单的模型来生成一些文本:
我们将提供一个开始序列，并要求模型预测开始后的 256 个字符。因为我们的 softmax 返回选择每个字符的概率，所以我们可以灵活地决定选择哪个字符。总是选择最大概率字符会使模型自我重复，表现得像一个无限循环，一遍又一遍地打印相同的值。相反，我们对概率进行排序，取五个最大值，重新归一化，然后从这五个值中随机选择。这引入了产生更好结果的随机性:
Words of God
让我们来看看我们的 LSTMs 发出了什么样的布道:
神和耶和华所喜悦的地，我要向耶和华所喜悦的，就是向旷野所喜悦的，和一切耶和华所喜悦的
爆笑！这里还有一些:
神也看顾服事他们。那离弃他们如会众之子的，耶和华已经成就了，且喝吧。因为耶和华你的神已经成就了。我却为我应允你。你借着你的光所说的耶和华心之神的分裂
神与光。我对他说，这要在我身上发生的事，我们为什么没有信你，又在仇敌中间呢。夫子，我要把这些都预备好了，送给你，放在会众面前
几乎所有这些在语义上都是无意义的，但请注意，这个模型没有任何关于单词、字母或数字是什么，标点符号是什么，结构是什么，语言是什么的信息。经过 5 个时期的训练，我们可以看到一些有趣的结果。例如，它知道很多文本都是以数字开头的。它确实在新的讲道之前增加了正确的数字和冒号的结构。它还学会了在各处添加标点符号，就词汇而言，大部分单词都是正确的。
让我们试试不同的开始顺序，只是为了好玩。这是我们的模型为“耶路撒冷”想出的:
耶路撒冷:惟有利未人，他的城要被火烧死，要被咒诅。我设了一个比喻，说，你们就是这地，也是属他们的。没有人奉他的名。他们好像圣灵，他们列祖的话是指着他们说的
耶路撒冷，宝座，三匹马，和祭司的仆人陀拉，都归与这俗语。因为众水必流在耶和华殿的坟墓上
耶路撒冷，和他们的父。有能力攻击耶和华的，只有这一位，就是耶和华的话是什么，并偶像的挂物。又说，我必服自己的劳苦
有趣的是，它学到了很多，耶路撒冷是一个独特的实体，不与其他字符连接。
自己尝试不同的开始顺序！
改进和总结意见
改进可以在许多方面实现。调整超参数，特别是尝试增加历元，稍微降低学习率，增加隐藏单元的数量，以及所有这些的组合。可以引入的一个有趣的超参数是温度，它决定了在选择下一个字符时模型选择的保守性/多样性。这里解释的很好。
我以一个问题作为结束——如果有足够的时间、足够的数据和一个聪明的模型，我们可以生成与人类书写的布道没有区别的布道(就像我们对画作所做的那样),我们能给上帝编程吗？但是如果我们可以，我们不是遇到了一个悖论吗？我很想就此展开讨论。
快乐深度学习！
代号:https://github.com/rwiddhic96/LSTMS_God
参考资料:
- https://r2rt . com/recurrent-neural-networks-in-tensor flow-ii . html
- https://www.tensorflow.org/tutorials/text/text_generation
R 队还是 Python 队？
“一个公认的事实是，一个在计算机科学和统计学方面有良好基础的数据科学家，肯定需要一种编程语言。”
嗯，我敢肯定，如果数据科学早在 1813 年的《傲慢与偏见》第一次出版的时候，简·奥斯汀就会这样表达。
随着点击统计和机器学习工具的存在，如 Weka、SPSS 和谷歌的 AutoML，人们很容易陷入这样一个陷阱，即认为在数据科学领域建立职业生涯时，能够编程不再重要。
虽然我不否认技术的发展变化，而且理解数据科学的理论比用代码实现它更重要。事实是，如果你想在数据科学领域有所成就，你需要会编程。
事实上，在我最近对 LinkedIn 上列出的 100 个数据科学职位广告进行的分析中，我发现 97%的广告都将编程技能作为选择标准。
能够编程给了你能够提取和争论你自己的数据的自由；让您更好地控制模型参数调整；这意味着当涉及到您能够使用的算法和技术范围时，您不再受软件开发人员的摆布。
但是有这么多编程语言可供选择(维基百科列出了几百种)，你应该从哪里开始呢？
在为数据科学选择编程语言时，需要考虑以下六点:
#1:雇主想要什么编程语言？
如前所述，我最近检查了 2019 年 4 月 22 日至 2019 年 5 月 5 日期间在 LinkedIn 上发现的四个英语国家(澳大利亚、加拿大、英国和美国)的 100 份数据科学招聘广告。
这些招聘广告被选择来代表雇主类型、规模、行业和工作级别的广泛代表性，而纯粹的管理角色没有被考虑。
基于这一分析，我发现雇主在数据科学家中寻求的前三种编程语言是 Python(在 90.4%的招聘广告中被提及)、R(在 73.4%的招聘广告中被提及)和 SQL(在 58.5%的招聘广告中被提及)。
这表明，如果您打算为数据科学选择一种编程语言，那么 Python、R 或 SQL 中的一种是最佳选择。
然而，虽然 R 和 Python 都是通用编程语言，具有允许用户执行数据科学的大多数技术要求的附加包，包括统计分析和机器学习，但 SQL 是一种专门为查询和操作关系数据库中的数据而设计的数据库语言。
雇主通常要求 SQL 技能，因为他们将数据保存在关系数据库中，并希望他们的数据科学家能够访问这些数据。他们实际上并不期望他们的数据科学家使用 SQL 执行他们工作的其他方面，比如模型开发。
虽然我之前已经在这里写了关于学习使用数据库的基础知识的重要性，但是作为一名数据科学家，你不需要学习太多的 SQL。只需学习足够的 SQL，以便能够合并和过滤一组表，然后将注意力集中在 Python 或 r 中的一个上。
顺便说一下，有多个为 Python 和 R 编写的包，允许用户从这些语言中运行 SQL 查询(例如，Python 中的 sqlite3 和 R 中的 RSQLite)，因此，为了最大限度地提高效率，您可以在学习 R 和 Python 之一的同时学习 SQL 。
#2:其他人都在用什么编程语言？
如果你已经与其他数据科学家或数据专业人员在一个环境中工作，那么最好的学习语言往往是你周围每个人都在使用的语言(即使你已经知道一些不同的东西)。
这样做的原因是因为它将您置于这样一个位置，您可以向您周围更有经验的程序员学习，并得到他们的指导(同时也不会因为您选择的编程语言而受到嘲笑——对一些人来说，整个 R vs Python 的辩论可能变得非常政治化)。
你可以让其他程序员检查你的代码；使用他们的代码作为好的编程技术的模板；从你周围的对话中获取编程的一般技巧。
我的一个朋友曾经告诉我一个她的前同事的故事，他坚持用一种他周围没有人熟悉的语言编程。他在一家跨国保险公司找到了一份工作，在那里他继续保持这种立场，并最终犯下了一个巨大的错误，这让他丢掉了工作，因为没有人能够审查他的工作。
如果你刚刚起步，或者不与任何其他程序员一起工作，那么你可以在更大的层面上应用这种考虑。数据科学社区中的其他数据科学家通常使用什么语言？
在我对 2018 年度 StackOverflow 开发者调查(可在此处找到)进行的分析中，我发现，在自称为数据科学家的受访者中，Python 是最受欢迎的语言，76.8%的人在过去 12 个月中使用过 Python。
相比之下，去年只有 34.0%的人使用过 R，排在 SQL、HTML、JavaScript、CSS、Bash/Shell、Java 和 C++之后。
同样，对 Kaggle 2018 ML & DS 调查回复的分析显示，在认为“可能”或“肯定”是数据科学家的受访者中，60.5%最常使用 Python(使其成为最受欢迎的语言)，R 以 16.0%的比例位居第二。
#3:你打算用这种语言做什么？
r 最初是 S/S-Plus 的开源实现，S/S-Plus 是一种专门为统计人员设计的编程语言，通常在大学水平的统计课程中讲授。
尽管 S/S-Plus 的编写使得大部分主要功能都在核心程序中，但 R 被设计成可通过包进行扩展，并且随着时间的推移，已经编写了额外的包来扩展 R 的功能，使之超越统计技术。然而，由于它的起源，R 的优点仍然是它的统计功能。
相比之下，Python 最初是一种通用编程语言，受 C/C++和 Java 的影响，供软件开发人员使用。与 R 一样，Python 也可以通过包进行扩展，但是由于这种语言的通用性质，它的优势在于这些包所提供的功能的广度。
Python 是许多大学计算机科学课程(尤其是与机器学习或人工智能相关的课程)的首选语言，实现非统计功能的包往往首先用 Python 编写，R 包随后创建(要么原生于 R 中，要么作为 Python 包的 R 接口，如谷歌的深度学习包 Tensorflow 的情况)。
一般来说，如果你学习编程语言的目的是专门用于统计分析和建模，那么 R 可能比 Python 更能满足你的需求。
但是，如果您计划扩展到统计之外，特别是数据科学的计算机科学方面(包括机器学习、深度学习、自然语言处理和计算机视觉)，那么请考虑使用 Python。
#4:未来呢？
引用搏击俱乐部的话，“在一个足够长的时间线上，每个人的存活率下降到零”，这也适用于编程语言。不管一种编程语言今天有多流行，最终会有另一种语言取代它。
从积极的一面来看，尽管编程语言时好时坏，但支撑大多数编程语言的原则往往保持不变。
一旦您掌握了函数、for 和 while 循环、if/else 语句和变量类型背后的概念，您就可以相对较快地掌握任何编程语言的基础知识。
尽管如此，如果你打算花时间学习一门编程语言，你希望能够尽可能获得最大的投资回报，这意味着选择一门越来越受欢迎的编程语言，而不是越来越不受欢迎。
数据科学网站 KDnuggets 对其用户的软件选择进行了年度调查(例如，见这里)。最近三年，Python 在这项民意调查中一直名列前茅，在 2015 年至 2019 年的五年中，其使用量从 30.3%的受访者增长到 65.8%的受访者。
相比之下，在同一时期，R 的使用率从 2015 年的 46.9%增加到 2017 年的 52.1%，然后再次下降，到 2019 年降至 46.6%。
在截至 2019 年 8 月的五年中，谷歌趋势对搜索词“Python”和“R”进行了比较，结果显示，尽管“Python”一直是更受欢迎的搜索词，但“R”的受欢迎程度保持相对平稳，而“Python”的受欢迎程度则大幅上升。
因此，如果未来的可用性是你最关心的，那么 Python 就是你要走的路。
#5:你最喜欢哪种编程语言？
开源语言的美妙之处在于，任何人都可以免费下载它们，并在自己的电脑上使用它们。你不会在没有试驾的情况下购买一辆新车，那么为什么不在选择编程语言时应用同样的原则呢？在接下来的几年里，你可能会花很多时间来使用编程语言。
r、Python 以及其他许多在数据科学家中流行的语言都是开源的。你可以下载你感兴趣的每一种语言，然后，对于每一种语言，花一周左右的时间学习一些你可以在网上找到的入门教程。
一旦你掌握了语法，给自己设定一些基本的任务来进行语言的比较。例如，给定一个你从某个来源下载的数据集，比如 Kaggle 或者 UCI 机器学习库，你可以尝试下面的方法:
- 加载数据集，计算基本汇总统计数据(如各变量的均值和方差)；
- 单独或成对绘制每个数据变量；
- 进行基本的数据清理，将数据整理成适合模型拟合的形式；和
- 将几种不同的机器学习模型(例如，线性回归模型、决策树、支持向量机和神经网络)与数据进行拟合，并选择最佳模型。
在这个过程的最后，选择最适合你的语言。
#6:专有语言呢？
到目前为止，本文主要关注的是开源语言，但是它们的专有表亲(即与商业软件相关联的语言)，比如 SAS，情况又如何呢？
虽然曾经有一段时间，甚至就在五年前，雇主倾向于选择商业软件而不是开源软件，但随着开源工具的日益流行，人们的态度已经发生了变化。
据我所知，一些组织(包括跨国咨询公司和企业)正在从商业分析软件转向开源软件，以削减成本。
的这篇文章反映了这一观察结果，文章讨论了行业从 SAS 到开源工具的转变，并声称“新毕业生进入职场普遍更喜欢 Python 和 R，而不是 SAS。”
如果这还不足以阻止您学习专有编程语言，请记住，专有语言的功能往往比开源语言少，任何超出基本功能的附加功能通常都是以昂贵的附加模块的形式出现的。
此外，如果你学习了一种特定的语言，然后找到了一份工作，而你的新雇主没有你使用这种语言所需的软件，那么说服你的雇主为你提供免费的开源工具要比购买一种商业产品的许可证容易得多，后者每年可能要花费五六位数的费用。
为数据科学选择一种编程语言可能是一个困难的决定。我个人更喜欢 Python，因为它的功能广泛，在数据科学社区很受欢迎，并且有增长的轨迹。然而，至少在中短期内，我预计 Python 和 R 将继续作为两种顶级数据科学语言共存。
所以，只要你学会了其中一个，你就不会错得太多(事实上，如果你对数据科学很认真，那么最终你应该两个都学)。
然而，无论你选择哪种编程语言，一定要学好它。因为，归根结底，重要的不是你用于数据科学的语言，而是你用它做了什么。
Genevieve Hayes 博士是数据科学家、教育家和人工智能及分析专家，拥有Genevieve Hayes Consulting。你可以在LinkedIn或者Twitter上关注她。她还是 价值驱动数据科学 的主持人，这是一个每月两次的播客，面向希望最大化其数据和数据团队价值的企业。
想要发掘企业数据的价值，但不知道从哪里开始？**下载免费的数据科学项目发现指南。
2020 年你应该读的科技书籍
我们生活在未来。是时候了解一下了。
我们的世界是一个地球村。如果你正在阅读这些文字，你可能有一部可以上网的智能手机。过去的 20 年是科技和我们如何使用科技的疯狂时期。在我们的历史上，我们从未在如此短的时间内看到如此多的突破。这篇文章集中在从不同角度讨论这些变化的书籍上。
Technology Books you should read in 2020
改变世界的创新者
我们都喜欢英雄的故事，他们做出牺牲，失败，一次又一次的失败后回来改变世界。以下书籍关注的是人:
沃尔特·伊萨克森的《创新者》是一本关于有创造力的头脑的书，他们突破界限，与他们的时代背道而驰，并重新发明做事的方式。说到创新，这绝对是经典。
数百万人对埃隆·马斯克又爱又恨。他将电动汽车推向大众和去火星的迷人探索成为头条新闻。他的传记介绍了他从南非童年到现在的经历。一个惊人的故事仍然揭开。
万物商店讲述了亚马逊如何从一个小型在线图书销售商成长为一个全球巨擘的故事，这个巨擘横跨多个行业，并且还在不断成长。读一读就明白为什么总是‘第一天’。
如果你的目标是“不惜一切代价建立一个十亿美元的公司”而不是创新，那么你会犯多大的错误。它展示了硅谷是如何运作的，以及在没有工作原型的情况下你能走多远。
火箭亿万富翁展示了火箭工业有多艰难，以及为什么“火箭科学”仍然意味着“艰难，几乎不可能”。它介绍了第一次登月的历史，分析了卫星业务，并解释了为什么私营部门完全改变了火箭工业。任何对太空感兴趣的人都必须阅读。
人工智能来了
技术可以有许多面孔，但最近主要的一个是人工智能。不管我们想不想，我们都在使用它。下面的书解释了我们是如何来到这个时代的，以及未来等待我们的可能是什么。
哈拉里的《T2 智人》以令人信服和连贯的方式展现了我们的历史。从我们古老的祖先到现在，从简单的工具到互联网和智能手机，这个故事是一个很好的读物，可以让我们了解为什么我们是人类。
超智能是人工智能和人工通用智能的经典参考。尼克·博斯特罗姆列出了其他作者经常使用的所有理论。对于任何想知道人工智能将如何改变世界的人来说，这是一本好书。
数学毁灭的武器是一本关于数学的书。凯茜·奥尼尔展示了我们的世界是如何被算法统治的，以及我们如何让算法为我们做出决定。既迷人又可怕。
《人工智能的超能力》是解释人工智能如何在商业中使用以及中国如何利用人工智能造福人类的一个很好的参考。作者解释了硅谷和中国初创企业生态系统之间的差异。
人工智能商业是针对商业人士和以商业为导向的数据科学家的人工智能简明指南。注重实际，关注最新趋势。
如果你想找更多的书籍推荐，可以看看我的其他书单:
敬请关注更多关于人工智能和技术的文本。](https://creative-producer-9423.ck.page/c3b56f080d) 
Data Science Job
最后，如果你想了解成为一名数据科学家意味着什么，那么看看我的书数据科学工作:如何成为一名数据科学家，它将指导你完成这个过程。
技术和创造力的起源
人工智能和新兴技术给人类带来了强大的新工具，但我们准备好向它们过渡了吗？
德克·克内梅尔和乔纳森·福利特
The Smartware Evolution [Photo: Girl With VR Goggles, by Samuel Zeller on Unsplash]
智能软件的发展
我们正处于计算技术的下一次重大变革的风口浪尖，这将为我们的工作和生活带来重大变化。虽然人工智能(AI)受到了媒体的极大关注，但它正在与一系列其他新兴和补充技术同步成熟，我们认为这些技术是智能软件——从物联网(IoT)到虚拟和增强现实，再到添加制造/ 3D 打印——决定了自动化系统可以并将如何与我们互动、协助我们并向我们营销。不仅将这些技术本身视为变革性的，而且将其视为从第一台计算机开始的进程的延续，这是很有用的。每一次进步，从个人电脑到互联网再到手机，我们的技术优势都在增加。在过去的 40 年里，随着我们采用和利用这些工具，我们的社会已经从工业经济过渡到信息经济。
这种演变将会破坏稳定，以一种最终看起来类似于我们从农业经济向工业经济演变的规模改变世界。人们的生活将会受到影响，几十年后，世界将会变得面目全非。我们已经可以看到无人驾驶汽车等技术的痕迹。尽管由于优步和特斯拉等商业模式各异的公司发生了引人注目的致命事故，它们的发展和采用速度有所放缓，但它们在一些社区仍然引人注目。此外，一些人做出了激烈的反应，这让人想起了 19 世纪 10 年代英国的勒德分子。亚利桑那州钱德勒市的人们用石头、刀子袭击了谷歌分拆公司 Waymo 的无人驾驶汽车，甚至用武器威胁这些汽车。尽管在过去两年里，这类攻击只有 21 起，但对人工智能和其他相关新兴技术进步的不安是显而易见的。无人驾驶汽车可能还需要数年或十年的时间，才能将典型的人类司机转变为无人驾驶交通工具的乘客，但它已经预示了它将对社会产生的深远影响。
人工智能和自动化带来的越来越多的技术杠杆提供了创造和摧毁工业、工作和生活方式的能力。为了以积极的方式改变和改善我们的生活，我们需要适应性策略来准备与智能机器的合作。
前车之鉴
我们的人类生态——我们与自然和人造环境以及彼此之间的关系——将会发生变化。但是，如果这能让你感到安慰的话，作为一个物种，我们已经经历过多次这种类型的转变。历史上，我们和我们的技术一起发展。为了更好地理解人类与技术和创造力之间关系的人类学基础，我们采访了东北大学的人类学家和社会学家 Carie Little Hersh 博士。她教了我们很多东西。首先，你知道科技实际上早于人类吗？所以，某种意义上，它甚至不是“我们的”。最早的技术比人类智人早几百万年:石器至少可以追溯到南方古猿。不管怎样，技术现在是我们独有的东西，而且只会加速发展。赫什博士带我们回到大约 10，000 年前，以说明技术和人类生态之间的相互作用是如何齐头并进的。
Figure 01 — New Tools for Food Production
[Image: “Man with a Hoe”, c. 1882, Georges Seurat, (Open Access Image from the National Gallery of Art)]
赫什博士说:“从狩猎和采集过渡到农业，特别是复杂的农业，不仅需要新的采集食物的工具，还需要新的建筑工具。”“因为突然间，你不再四处走动，不停地跟踪你的猎物。你需要有长期的技术，比如粘土、制砖、木结构，这些东西会持续很长时间，因为你必须储存你的谷物。你不得不在一个地方生活很长一段时间，可以说是经受了各种天气的考验。但是，它也产生了巨大的社会影响。”
这种情况在从农业到工业的转变中再次发生:“所以，随着工业革命，你确实有了这种技术的爆发，也许，其中一些与这些更大的政治有关，包围土地和创造城市的政治。赫什博士说:“几百年前有一次伟大的城市化。“土地的使用方式发生了变化，人们开始相互交往的方式也发生了变化。因此，所有这些不同的东西都发生了变化，以提供这种环境，这为新技术的发展和新生活方式的体现奠定了基础。”
Figure 02 — The Transition to Industrial Revolution
[Illustration: From the book “Medieval and modern times; an introduction to the history of western Europe form the dissolution of the Roman empire to the present time” (1919) (Library of Congress)]
我们已经看到计算技术创造了全新的产业，尽管机器人自动化与新兴市场合谋摧毁了美国的其他产业。但这仅仅是开始。在未来的几年里，创造性工作者，像我们这样的人，也许还有你，将会看到我们的部分工作越来越自动化。全新一代的行业和工作岗位将会同时出现。这将带来不可预测的挑战和机遇。
全球影响和意外后果
社会学家斯蒂芬·平克(Stephen Pinker)通过他的书和 TED 演讲，依靠一系列统计数据来支持他的论点，即世界比以往任何时候都更好，从而赋予了技术进步人士力量。Hersh 博士带来了更加全球化的视角:
“你知道，我们每取得一点进展，就会产生一个新问题。当我们还是狩猎采集者和牧民时，全球变暖显然不是一个问题。所以，我们有很多环境和健康的后果来自我们的选择…我们社会发展的方式。不是所有的社会都有同样的问题，也不是所有的社会都有同样的收获。因此，环顾四周，看看这些问题从何而来，以及其他可能的解决方案，将会非常有用。作为这个神奇的技术世界的受益者，我们所有人都有责任保持警惕，帮助保护弱势群体，并更广泛地传播利益。”
我们花了将近 200 年才意识到工业革命对我们的环境有着潜在的破坏性影响。甚至在今天，当我们享受甚至庆祝我们的智能世界所提供的恩惠时，我们很容易忽视我们视野之外的人们生活质量的下降。你不得不怀疑，在技术可能威胁到他们的生计或侵犯他们的生活方式之前，Waymo 的风险管理团队是否预见到他们的车辆会受到害怕未来的人的物理攻击。它提醒我们，将会有意想不到的后果，我们新兴的智能世界将会产生我们无法预料和无法立即意识到的影响。它还提醒我们，作为与 70 多亿人共享这个世界的人，留意那些在我们社区和视野之外的人也很重要。
Creative Next 是一个播客，探索人工智能驱动的自动化对创意工作者，如作家、研究人员、艺术家、设计师、工程师和企业家的生活的影响。本文伴随 第一季第一集——技术和创造力的起源。
特拉维夫艺术家:为自己打造一款地图应用
TL；dr-I 从尝试地图库到构建可重用的地图应用。这是我如何做到的，你也可以如何重复使用它。
介绍
作为一名数据科学家，我的大部分工作都停留在幕后。在训练模型时，我接触的最多的是部署一个简单的 flask web-app 作为 REST APIs。
最近，部署工具变得更加友好、快捷和高效。你看，如果你想为用户开发一个应用程序，即使是为了演示的目的，一个最小化的 UI 可以是一个很好的起点。
最近偶然发现了 这个 的例子，用于机器学习模型部署和 UI。它有许多部署选项的教程，以及一个用于图像识别的基本 UI。您可以找到许多数据科学家正在使用这个例子，并将其用于他们的分类算法。
这一次，我决定走出我的舒适区，并进一步“扩展”这个例子。
这个概念
如果你在以色列的特拉维夫漫步，你可能会看到一些标志，比如这个:
这块纪念牌位于特拉维夫的伊本·格维罗尔街 30 号，上面写着大卫·佩尔洛夫(David Perlov)曾在这座房子里生活和工作，他是以色列艺术家和电影制作人的先驱。
以色列是一个非常年轻的国家，因此，它的许多历史艺术活动都发生在以色列的第一个城市特拉维夫的一个小地方。
如果你对艺术和漫游感兴趣，围绕这些景点做一次自助游可能会很有趣。
不幸的是，我找不到任何提供某种界面的在线页面来让你自己选择一条旅游路线。
所以，我决定去做。
你们中没有多少人知道，但我有一个老想法，至少利用一些网上可获得的海量地理数据，并创建某种虚拟导游，这将自动生成未知城市的步行路线，或已知城市的原始步行路线。这个任务有点雄心勃勃，所以我决定从小处着手:这些记忆牌将是我进入地图世界的机会。
步骤 1:高级设计
虽然弄脏你的手总是很诱人，但我首先需要思考这个项目的最终目标是什么:这当然不会是一个成熟的生产应用程序，而是一个原型玩具，允许用户进行某种程度的探索。
Schematic plot of the project
更准确地说，我希望用户能够:
- 将斑块视为地图上的标记。
- 获取一些关于他们的信息。
- 获得检查站之间的简单行进路线。
- 所有这些都在用户可访问的网络应用程序中(不是 python 笔记本)
所以我需要:
- 数据分析工具
- 映射工具
- Web 框架:客户端和服务器端。
- 部署服务。
很多事情要做！
当然，这些定义并不严格，但它们描述了我心目中的最小项目。
也是选择发展战略的好时机。这种高层次的选择将伴随我们整个工作。客观地说，我认为他们最好的选择是客户端语言——JavaScript。然而，作为一名数据科学家，我的强项是 python ，所以我选择尽可能多地使用它。这个选择将迫使我使用服务器，因为 python 不能在浏览器中有效使用。
幸运的是，有像样的 pythonic 式 web 框架，比如 Flask。
第二步:数据分析
为了达到上述目标，我必须解决一些任务:
- 获取数据
- 视觉化是
- 创建 UI 界面
在这一页http://cafe.themarker.com/post/3124888/，有一个相当混乱的所有艺术家及其地址的列表。
很容易将艺术家列表及其地址粘贴到文本文件中，并解析到更友好的表格中。
现在是更难的部分。
我做了以下工作:
- 将数据保存在 2 个文件中
- 项目用句号分隔，因此很容易将它们分开。
- 每个项目都包括名称、地址和简短描述。它们用逗号分开，但比之前的方式更混乱
- 总共有大约 180 位艺术家上榜
- 如前所述，大约有 20%的条目用逗号分隔不好。
- 一些缺少逗号
- 有些带有额外的逗号，主要是在描述中
解决方案:
- 因为地址应该有数字，所以它可以是一个指示器
- 将拆分并整理成地址和姓名(可能有一两个遗漏了，但我们必须接受)
- 将所有清理过的地址发送到地理定位器 API 以获取位置坐标。由于各种原因，并非所有(20)都将被正确返回，因此应该手动检索它们
拿到数据后，接下来的任务就是提取路点的坐标。显然，处理地理数据的正确方法是能够无缝地将用户友好的地址转换成计算机友好的地理位置。
这可以通过 GeoPy 实现——带有一些地理编码(place=> geocode=>place)功能的包，这可以节省一些 google APIs 积分。
Cleaned data with Geo-location
第三步:选择我们的武器
处理完大部分数据工作后，下一步就是映射 可视化和 UI 。由于我已经决定使用 python 作为我的后端，我需要一些 python 工具，希望可以翻译成 html。有相当多的软件包可以内联绘制地图并将其另存为(有时是交互式的)。html 文件。但是，它们具有不同的特性和功能。有些需要使用高级谷歌地图 API，这意味着一些限制，除非你付费。
因此，我们希望我们的包装中包含以下内容:
- 能够制作交互式 html 地图或类似。
- 绘图，工具提示，弹出功能。
- 简单易用(有很多事情要做，不想浪费我所有的时间在贴图上)。
- 最好无限制 API 要求。
- 奖励:额外功能，如搜索和路线
一个简单但健壮的包将使我的工作更快，用户体验更好。
因此，我继续进行了一个关于映射包的小研究。因为我的首选语言是 python，所以映射工具并不是最好的。这些是我体验过的工具，它们很 pythonic 很容易使用:
谷歌地图
谷歌地图值得拥有自己的版块，因为它是领先的地图工具。因此，能够通过 API 有效地使用它可以解决我们的大多数问题。然而，这是不可能的。谷歌提供的所有 API 都有一定的局限性:
- 谷歌地图服务 python
这个包更像是 google maps API 的包装器，允许在 google maps 中检索大量可用数据，但我没有找到绘图功能，因此这个库不太相关。
2.谷歌地图 url API
这个工具非常容易使用，有动态和静态两种版本:
- 对于这个项目来说，动态 google maps API 可能是最好的选择，然而，也许令人惊讶的是，它不支持太多选项，除了通过 google maps 用户界面提供的选项。因为我的需求之一是呈现一个有多个标记的地图，所以我在这里无法完全实现。
[https://www.google.com/maps/search/pizza+seattle+wa/@47.6257624,-122.331987,12z/data=!3m1!4b1](https://www.google.com/maps/search/pizza+seattle+wa/@47.6257624,-122.331987,12z/data=!3m1!4b1) - search pizza in seatle with google maps dynamic API
- 静态的谷歌地图 URL API——和上面的一样简单，有更多的选项，但是它是静态的，因此谷歌地图的一些动态功能被关闭了。然而，我发现这个工具对我来说是最有用的
如果你喜欢使用它，注意它需要一个 API 键，所以如果你不想被计费，你应该限制它(或者让用户插入他自己的)
3。我的地图谷歌应用
谷歌的一个很好且必要的产品是“我的地图”,它允许你创建带有位置、标记等的个性化地图。然而，自从“不可行以来，谷歌似乎没有为其提供 API
Python 包
回到我们最喜欢的独立开源 python 库:
- Gmplot
一个简单漂亮的 python 包，负责一些基本的绘图功能，并输出一个 HTML 文件。这是唯一一个允许开箱即用绘图(在谷歌地图风格的地图上)的包，但是它的选项是有限的。任何类型的弹出窗口都是不可能的，
主要是所见即所得:圆圈，线条，标记，热图，就是这样。没有文字或路线。
优点——非常简单
缺点——过于简单，需要 Google API
回购+快速启动:https://github.com/vgm64/gmplot
2。散景
令人惊讶的是，好的结果来自一个与谷歌地图没有直接关系的包。散景映射模块有我们需要的一切，除了外观和感觉不是很光滑。
然而，这里也不可能有用户界面。
3。叶子
在几乎放弃 python 并开始使用 JS 之后，我偶然发现了这个伟大的库，它在 GitHub 上拥有超过 3.5K 的星级。基于 fleet . js 地图，看起来很棒，有高级绘图选项，不需要 google API。
leav 包括一些额外好特性:
- Html 工具提示和弹出窗口
- 祖穆特的标记分组
- 许多不错的绘图选项
- 无缝导出到 html
那么叶子就是了！
Folium map
第四步:逻辑
所以我们有地图和标记。现在是时候做一些更聪明的事情了:路线规划。
我的任务是允许用户插入一个起始地址，并为他规划一条旅行路线。使用 google API，我们可以获得一条智能步行路线，但我将它留给了用户(换句话说，这超出了本项目的范围)，并且只显示指定位置之间的折线:
在接收地址时，有不同的算法可以找到最佳路径，但我选择使用简单的贪婪算法来找到最近的检查点。当达到限制(每小时 2 公里)时，脚本结束路线，并添加一条路径返回到起点，并在地图上以折线的形式显示所有内容。
简单不是吗？
你可以在 app.py 文件中找到所有的逻辑，在 repo 中的 calc_route 函数中。
步骤 5:实施/部署
因此，在我们将所有逻辑都准备好之后，就到了最具技术性的部分——部署。
这一部分对 web 开发人员来说很容易，但作为一名数据科学家，这是我尽量避免的部分。我最多是用 flask 应用程序包装我的模型，并把它放在一些云服务上。
在后端部分，我决定使用谷歌应用引擎。我主要使用谷歌云，所以对我来说更容易。尽管将 web-app 加载到这样一个托管服务上要比标准服务器慢得多，但它能处理许多我不愿接触的事情
至于前端，我把这个回购用于我的目的，做了如下改动:
- 用 flask 代替 uvicon/starlette，因为我更熟悉 flask。
- 一些明显的用户界面变化。
- 我决定添加的功能需要一些 javascript 代码。
Javascript 很复杂:作为编程语言，它非常简单。然而，使用它，尤其是使用 flask，可能会很棘手，因为有许多活动部件。
甚至调试过程也不同，因为它需要在浏览器中来回检查应用程序。
我的策略是从模板开始，在谷歌上搜索我想要做的每一项改变当然并不容易，因为我不熟悉:
- Iframes 的行为
- 在 html、python 和 javascript 之间来回传递数据，反之亦然
诸如此类。
- 添加数据-添加标记后，我们想给用户添加一些额外的价值，添加谷歌地图图像和维基百科页面的摘录
- 路径——目前它只是一个数据地图。我们将如何让它活起来？我认为添加一个简单的自流道路线计算算法会很好。一些我“以后可能会改进”的东西。逻辑将如下:您输入您的当前地址和您想要投入到您的旅行中的时间，系统将计算出满足所需条件的路线。这里的算法是贪婪的，不是最优的，并且路线目前是点之间的直线
6.构建您自己的地图
现在你可能会对自己说“我对‘特拉维夫’的艺术家没有任何兴趣。所以我给你准备了一个惊喜:你可以分叉我的回购，获得自己的地址，更改 data.json ，部署自己的映射工具！
你只需要有一个 gcloud 命令行工具，一个活跃的项目，如这里描述的，有了这个命令你就可以开始了:
gcloud app deploy
如果你做到了，请在评论里发帖。
如果你从笔记本开始，你可以使用位置和描述的列表，你有自己的智能旅行地图。
摘要
就是这样！我向您展示了，如果您知道自己在做什么，那么让脏数据集变得生动起来是一件简单而快速的事情。不幸的是，我花了很多时间才知道自己在做什么，或者换句话说，找到叶库。
如果你关注了这篇文章，你可能已经看到了为达到 MVP 所做的工作:许多可能的改进被遗漏了。但是，添加它们很容易:
- 更智能的路由算法
- 使用谷歌地图 API 生成实际路线，而不是折线
- 更好的弹出窗口设计等等。
我现在可以想到很多想法，但我不认为我会在未来几周内接触地图或 js ，但我鼓励你尝试:)
电信客户流失预测
为流失预测建立机器学习模型
Photo by Carlos Muza on Unsplash
客户流失，也称为客户流失，发生在客户停止与公司做生意或停止使用公司的服务时。通过了解和监控流失率，公司能够确定他们的客户保持成功率，并确定改进策略。我们将使用机器学习模型来理解准确的客户行为和属性，这些行为和属性标志着客户流失的风险和时机。
了解我们的数据集:
我们将使用 Kaggle 的电信客户流失数据集。原始数据集包含 7043 个条目。所有条目都有几个特征和一列说明客户是否搅拌过。
为了更好地理解数据，我们将首先把它加载到 pandas 中，并在一些非常基本的命令的帮助下探索它。
import numpy as np
import pandas as pd
from sklearn.preprocessing import MinMaxScaler
from sklearn.cluster import KMeans
import matplotlib.pyplot as plt
import seaborn as sns%matplotlib inline
from sklearn.model_selection import train_test_split#Loading the data
df = pd.read_csv(r’...Churn\telco_customer.csv’) df.info() <class ‘pandas.core.frame.DataFrame’>
RangeIndex: 7043 entries, 0 to 7042
Data columns (total 21 columns):
customerID 7043 non-null object
gender 7043 non-null object
SeniorCitizen 7043 non-null int64
Partner 7043 non-null object
Dependents 7043 non-null object
tenure 7043 non-null int64
PhoneService 7043 non-null object
MultipleLines 7043 non-null object
InternetService 7043 non-null object
OnlineSecurity 7043 non-null object
OnlineBackup 7043 non-null object
DeviceProtection 7043 non-null object
TechSupport 7043 non-null object
StreamingTV 7043 non-null object
StreamingMovies 7043 non-null object
Contract 7043 non-null object
PaperlessBilling 7043 non-null object
PaymentMethod 7043 non-null object
MonthlyCharges 7043 non-null float64
TotalCharges 7043 non-null object
Churn 7043 non-null object
dtypes: float64(1), int64(2), object(18) memory usage: 1.1+ MB
df.info()为我们提供了每一列的详细信息。我们可以看到我们的数据分为三种类型；
- 对象:对象格式意味着变量是分类的。我们数据集中的分类变量包括:客户 ID、性别、合作伙伴、家属、电话服务、多条线路、互联网服务、在线安全、在线备份、设备保护、技术支持、流媒体电视、流媒体电影、合同、无纸化账单、支付方式、总费用和客户流失。
- int64:代表整数变量。老年公民和终身职位都是这种格式。
- float64:表示包含一些小数值的变量。它们也是数字变量。在我们的数据集中，这种格式只有一个变量，即每月费用。
探索性数据分析
本节的目标是熟悉我们的数据。我们将进行双变量分析。这是分析数据的最简单的形式，我们检查每个变量与流失率的关系。对于分类特征，我们可以使用频率表或柱状图来计算特定变量中每个类别的数量。对于数字特征，概率密度图可用于查看变量的分布。
分类变量的所有可视化将在 tableau public 中完成。
从上面的柱状图可以得出以下推论:
男性和女性的流失率几乎相等。
老年人的流失率更高。
拥有电话服务的客户流失率更高。
与没有合作伙伴&家属的客户相比，有合作伙伴和家属的客户流失率较低。
与其他支付方式相比，使用电子支付方式的客户流失率更高。
没有互联网服务的客户流失率较低。
光纤互联网服务的流失率要高得多。没有 OnlineSecurity、OnlineBackup 和 TechSupport 等服务的客户在过去的一个月里离开了该平台。
现在让我们看看数字变量。
plt.figure(1), plt.subplot(121), sns.distplot(df['tenure']);
plt.figure(1), plt.subplot(121), sns.distplot(df['MonthlyCharges']);
plt.figure(1), plt.subplot(121), sns.distplot(df['TotalCharges']);
资料准备&特色工程:
这部分是机器学习的基础部分。如果这一部分做得不好，我们的模型就不会工作。在这一节中，我们将通过删除不相关的数据、处理丢失的值以及将变量转换为适当的数据类型来清理数据集。
处理无关数据和缺失值
在我们的数据集中，我们可以看到我们的模型不需要客户 ID，所以我们删除了变量。我们不需要处理缺失值，因为该数据集中没有缺失值。
df.drop([‘customerID’], axis=1, inplace=True)
将分类数据转换为数字数据
机器学习只处理数值。因此，我们需要将我们的分类值转换成数值。通过使用熊猫函数“get_dummies()”，我们可以用“gender_Female”和“gender_Male”替换性别列。我们将使用 df.info()向我们展示哪些是分类的，哪些是数字的。
df.info()<class ‘pandas.core.frame.DataFrame’>
RangeIndex: 7043 entries, 0 to 7042
Data columns (total 21 columns): customerID 7043 non-null object
gender 7043 non-null object
SeniorCitizen 7043 non-null int64
Partner 7043 non-null object
Dependents 7043 non-null object
tenure 7043 non-null int64
PhoneService 7043 non-null object
MultipleLines 7043 non-null object
InternetService 7043 non-null object
OnlineSecurity 7043 non-null object
OnlineBackup 7043 non-null object
DeviceProtection 7043 non-null object
TechSupport 7043 non-null object
StreamingTV 7043 non-null object
StreamingMovies 7043 non-null object
Contract 7043 non-null object
PaperlessBilling 7043 non-null object
PaymentMethod 7043 non-null object
MonthlyCharges 7043 non-null float64
TotalCharges 7043 non-null object
Churn 7043 non-null object
dtypes: float64(1), int64(2), object(18) memory usage: 1.1+ MB
从上面的结果中，我们可以看到数据类型为 object 的变量需要转换为 numerical。
df = pd.get_dummies(df, columns = [‘gender’, ‘Partner’, ‘Dependents’,’PhoneService’,’MultipleLines’,’InternetService’,
‘OnlineSecurity’,’OnlineBackup’,’DeviceProtection’,’TechSupport’,’StreamingTV’,‘StreamingMovies’,’Contract’,’PaperlessBilling’,’PaymentMethod’,’Churn’], drop_first = True)
使用 df.info()来检查我们所有的变量是否都被转换为适当的数据类型是明智的。在这一步之后，我注意到 total charges 仍然有一个 object 数据类型。因此，我将使用 pd.numeric()函数将其转换为浮点数。
df[‘TotalCharges’] = pd.to_numeric(df.TotalCharges, errors = ‘coerce’)
df.drop([‘TotalCharges’], axis = 1, inplace = True)
分割数据集。
首先我们的模型需要被训练，其次我们的模型需要被测试。因此，最好有两个不同的数据集。至于现在我们只有一个，相应拆分数据是很常见的。x 是自变量的数据，Y 是因变量的数据。测试大小变量决定了数据的分割比例。在 80 的训练/ 20 的测试比例中这样做是很常见的。
df[‘Churn_Yes’] = df[‘Churn_Yes’].astype(int)
Y = df[“Churn_Yes”].values
X = df.drop(labels = [“Churn_Yes”],axis = 1)
# Create Train & Test Data
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, Y, test_size=0.2, random_state=101)
逻辑回归和模型测试
让我们制作第一个模型来预测目标变量。我们将从用于预测二元结果的逻辑回归开始。
我们将使用 scikit-learn (sklearn)来制作不同的模型，这是 Python 的一个开源库。它是最有效的工具之一，包含许多可用于 Python 建模的内置函数。
from sklearn.linear_model import LogisticRegression
model = LogisticRegression()
result = model.fit(X_train, y_train)
数据集分为训练和验证两部分。让我们从 sklearn 导入 LogisticRegression 和 accuracy_score 并拟合逻辑回归模型。
from sklearn import metrics
prediction_test = model.predict(X_test)# Print the prediction accuracy
print (metrics.accuracy_score(y_test, prediction_test))
0.800567778566
因此，我们的预测几乎 81%准确，也就是说，我们已经正确识别了 80%的流失率。因此，为了减少流失并及时采取正确的预防措施，我们想知道哪些独立变量对我们的预测结果影响最大。因此，我们将模型中的系数设置为零，并查看每个变量的权重。
weights = pd.Series(model.coef_[0],
index=X.columns.values)
weights.sort_values(ascending = False)
结果如下:
InternetService_Fiber optic 0.800533
PaperlessBilling_Yes 0.417392
PaymentMethod_Electronic check 0.293135
StreamingTV_Yes 0.267554
MultipleLines_Yes 0.253773
SeniorCitizen 0.247112
StreamingMovies_Yes 0.197304
MultipleLines_No phone service 0.120019
PaymentMethod_Mailed check 0.019744
gender_Male 0.018991
MonthlyCharges 0.004611
Partner_Yes 0.000535
DeviceProtection_Yes -0.021993
tenure -0.035615
StreamingTV_No internet service -0.095143
TechSupport_No internet service -0.095143
DeviceProtection_No internet service -0.095143
StreamingMovies_No internet service -0.095143
OnlineBackup_No internet service -0.095143
OnlineSecurity_No internet service -0.095143
InternetService_No -0.095143
PaymentMethod_Credit card (automatic) -0.156123
Dependents_Yes -0.182597
OnlineBackup_Yes -0.190353
OnlineSecurity_Yes -0.335387
TechSupport_Yes -0.337772
PhoneService_Yes -0.551735
Contract_One year -0.591394
Contract_Two year -1.257341
dtype: float64
可以观察到，一些变量与我们预测的变量成正相关，而一些变量则成负相关。负值的客户表明他们不太可能流失，而正值的客户表明他们可能流失。这些
我写的大部分内容都让我忙于自己的创业公司 analyx。
期待听到你的经历:)
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
