TowardsDataScience-博客中文翻译-2020-五十四-
TowardsDataScience 博客中文翻译 2020（五十四）
使用自动计算开始数据插补
使用 Autoimpute 实现数据插补技术，并了解它们对机器学习模型的影响。
马库斯·斯皮斯克在 Unsplash 上的照片
现实世界中的大多数数据集都包含缺失数据。这导致了一个问题，因为大多数 Python 机器学习模型只能处理干净的数据集。因此，在进行建模步骤之前，分析师需要弄清楚如何处理丢失的数据。不幸的是，大多数数据专家主要关注建模方面，他们不太注意丢失的值。他们通常要么删除有缺失值的行，要么依靠简单的数据插补(替换)技术，如均值/中值插补。这些技术会对模型性能产生负面影响。这就是 Autoimpute 库的用武之地——它为您提供了一个适当处理缺失数据的框架。
插补类型
- 单变量插补:仅使用目标变量本身对值进行插补，例如均值插补。
- 多元插补:基于其他变量的插补值，例如，使用线性回归来估计基于其他变量的缺失值。
- 单一插补:对数据集中的任何缺失值仅进行一次插补，以创建单一插补数据集。
- 多重插补:对数据集中相同的缺失值进行多次插补。这基本上包括多次运行单个插补，以获得多个插补数据集(下一节将详细举例说明)。
使用自动输入
现在让我们演示如何使用 Autoimpute 库来解决缺失问题。这个库提供了一个框架，用于处理从探索阶段到建模阶段的缺失数据。下图显示了使用多重插补的回归过程的基本流程图。
展示多重插补如何与线性回归一起工作的流程图。(图片由作者提供)
在上图中，原始数据集被估算三次以创建三个新数据集，每个数据集都有自己的新估算值。对每个新数据集运行单独的回归，并且从这些回归中获得的参数被汇集以形成单个模型。该过程可以推广到' n '(估算数据集的数量)的其他值和各种其他模型。
为了理解获得多个数据集的一个主要优点，我们必须记住缺失值实际上是未知的，我们并不寻求获得它们的精确点估计。相反，我们试图抓住这样一个事实，即我们不知道真正的价值，而且这个价值可能会变化。这种拥有多个包含不同值的估算数据集的技术有助于捕捉这种可变性。
导入库
我们将从导入所需的库开始。
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy.stats import norm, binom
import seaborn as snsfrom autoimpute.utils import md_pattern, proportions
from autoimpute.visuals import plot_md_locations, plot_md_percent
from autoimpute.visuals import plot_imp_dists, plot_imp_boxplots
from autoimpute.visuals import plot_imp_swarmfrom autoimpute.imputations import MultipleImputer
本文的完整代码可以从这个资源库下载:【https://github.com/haiderwaseem12/Autoimpute
创建虚拟数据集
出于演示目的，我们创建了一个包含 1000 个观察值的虚拟数据集。数据集包含两个变量；预测器' x' 和响应' y '。'y '中 40%的观察值被随机替换为缺失值，而' x' 被完全观察到。' x' 和' y' 的相关性约为0.8 。数据散点图如下所示。
显示虚拟数据集分布的散点图(图片由作者提供)
思念 EDA
作为起点，检查数据的缺失以从中提取模式是很重要的。这有助于我们理解缺失和选择合适的插补技术。下面演示了 Autoimpute 库为此任务提供的可视化技术。
函数plot_md_percent(df)的结果如下所示。这可用于显示数据集中每个要素的缺失百分比。在我们的例子中，我们可以看到' x '被完全填充，而 y 缺失了 40%。
柱状图，显示每列中缺失值的比例(图片由作者提供)
另一个函数plot_md_locations(df)通过将缺失的行显示为白色条来帮助我们可视化数据帧中缺失数据的位置。当试图寻找缺失的模式时，这个图会非常方便。
因为我们从' y '列中随机删除了值，所以我们的数据没有丢失的模式。我们可以看到' y' 列的值在' x' 的所有值中随机缺失。
显示缺失值位置的条形图(图片由作者提供)
然而，在某些情况下，这个情节可以帮助我们理解这种缺失。例如，如果我们在底部附近看到更多的白条，我们就会知道遗漏的概率随着 x 值的增加而增加。
一旦我们探索了缺失，我们就可以进入插补阶段。
多输入函数
函数MultipleImputer为我们的数据集提供了多重插补。这个函数可以以一种极其简单的方式使用，并且执行得相当好，即使使用它的默认参数。
imputer = MultipleImputer() #initialize the imputer
imputations = imputer.fit_transform(df) #obtain imputations
但是，该功能非常灵活，可以通过多种方式进行定制。下面讨论一些常用的论点:
- n: 插补数量(要创建的新插补数据集的数量)。
- 策略:可使用策略栏指定插补方法。该函数为我们提供了各种插补方法，从简单的单变量技术(如均值插补)到其他更高级的多变量技术(如预测均值匹配)。如果没有指定策略，则应用默认方法。默认方法取决于列数据类型。
- 预测值:该参数可用于设置哪些列用于特定列的插补。如果未指定预测值，则使用所有列，这是默认选项。
- imp_kwgs: 该参数可用于指定定制特定策略所需的任何其他参数。
下面给出了一个使用MultipleImputer及其参数的例子。假设我们有一个包含四列的数据集:性别、工资、教育和年龄。
MultipleImputer(
n=10,
strategy={'salary':'pmm', 'gender':'binary logistic'},
predictors={'salary':'all', 'gender':['salary','age']},
imp_kwgs={'pmm':{'fill_value':'random', 'neighbors':5}}
)
该函数将创建 10 个插补。薪资和性别将分别使用预测均值匹配和二元逻辑进行估算。为了估算工资，将使用所有列；而对于性别，将只使用工资和年龄变量。最后，PMM 策略将使用随机填充值，相邻点的数量将设置为 5。
注意: Autoimpute 遵循与 Scikit-learn 相同的 API，这使得代码为许多 Python 用户所熟悉。
平均插补
我们从最基本的插补类型开始:均值插补。由于均值插补非常常用，我们首先实现它，然后将其与 Autoimpute 库提供的另一种技术进行比较。
mi_mean = MultipleImputer(n=5, strategy="mean", seed=101)
imp_mean = mi_mean.fit_transform(df)
Autoimpute 还为我们提供了一些可视化技术来查看估算值如何影响我们的数据集。我们将使用这些图来比较不同技术的性能。
plot_imp_swarm(d=imp_mean,
mi=mi_mean,
imp_col=”y”,
title=”Imputed vs Observed Dists after Mean Imputation”
)
群体图，显示均值插补后的均值与插补分布(图片由作者提供)
从上面的蜂群图中，我们可以看到所有的估算值都是完全相同的。由于均值插补用列均值替换每个缺失值，并且每次插补一列时均值保持不变，因此无论我们插补一列多少次，这种技术都会给出完全相同的结果。因此，多次平均值估算不会给估算带来任何变化。这一观察结果得到了下面两幅图的进一步支持，因为我们可以清楚地看到所有五种插补的分布也完全相同。
此外，下图还显示了均值插补如何改变数据的分布。我们仍然有与原始数据相同的平均值，但是数据现在更紧密地围绕平均值，导致更低的方差。这可能导致模型在平均值附近做出预测时过于自信。
plot_imp_dists(d=imp_mean,
mi=mi_mean,
imp_col="y",
separate_observed=False,
hist_observed=True,
title="Distributions after Mean Imputation"
)plot_imp_boxplots(d=imp_mean,
mi=mi_mean,
imp_col="y",
title="Boxplots after Mean Imputation"
)
分布图(左)和箱线图(右)显示了均值插补后的均值分布与插补分布(图片由作者提供)
预测均值匹配插补
现在我们来看看一种更先进的技术:预测均值匹配(PMM)插补。这种方法使用贝叶斯回归模型来预测插补值。然后找到最接近预测值的观察值，随机替换其中一个值作为插补值。
注意:以下演示不需要详细了解 PMM 算法的工作原理。但是，如果你对算法不熟悉，希望理解它，请看看下面的链接:https://statisticalhorizons.com/predictive-mean-matching。
mi_pmm = MultipleImputer(n=5, strategy="pmm", seed=101) imp_pmm = mi_pmm.fit_transform(df)
为了展示 PMM 插补的性能，我们将使用与上述相同的可视化技术。
plot_imp_swarm(d=imp_pmm,
mi=mi_pmm,
imp_col=”y”,
title=”Imputed vs Observed Dists after Mean Imputation”
)
显示 PMM 插补后平均分布与插补分布的群体图(图片由作者提供)
当我们查看群集图时，我们注意到的第一件事是估算值分布在' y' 的实际值上。这有助于保持分布，我们可以从下图中清楚地看到，估算列的分布与实际列相似。尽管不同插补的分布略有不同，但平均值和方差都与实际列相似。
我们从上面的图中观察到的第二点是，估算值在不同的列中有所不同。下面的两个图进一步支持了这一观察结果，这两个图清楚地向我们展示了所有五个估算列的分布略有不同。这有助于我们捕捉缺失值的可变性。
plot_imp_dists(d=imp_pmm,
mi=mi_pmm,
imp_col="y",
separate_observed=False,
hist_observed=True,
title="Distributions after Mean Imputation"
)plot_imp_boxplots(d=imp_pmm,
mi=mi_pmm,
imp_col="y",
title="Boxplots after Mean Imputation"
)
分布图(左)和箱线图(右)显示平均插补后的平均分布与插补分布(作者提供的图片)
结论
在我们的论证中，PMM 插补的表现优于均值插补。大多数数据集都是如此。然而，PMM 插补并不总是最好的技术，因为它有自己的缺点，例如，它可能计算量很大。在缺失值数量很少的情况下，即使像均值插补这样的简单技术也能给出最佳结果。
正如机器学习中的一切一样，没有单一的最佳技术。最佳技术因情况而异，取决于给定数据集的特征。找到最佳技术依赖于领域知识和实验的结合。Autoimpute 库为我们提供了一种简单的方法来试验各种插补策略，并找出最有效的策略。
本文的完整代码可以从这个资源库下载:【https://github.com/haiderwaseem12/Autoimpute
数据科学入门
总结我在 WomenTech Network 2020 上的演讲“如何开始学习数据科学——分享一些技巧和资源，以及我从一名人文学科学生到获得数据分析硕士学位的旅程。
ihbRRmh _ transparent-wizard-beard-png-data-wizard-png-下载， Steemit
从解释什么是数据科学开始:
数据科学有许多定义，有些人可能会说它的计算机程序确实很酷。或者，数据奇才会把数据科学定义为用数据做神奇的事情！
或者有人喜欢将其定义为人机关系:他们可能会将数据科学视为“转换人类问题，将其放入计算机中，从而使其成为计算机问题，并期望计算机解决最初的人类问题。”在这里，我们本质上是在制造我们的问题，把它放在另一边，让它成为别人的问题来解决。
我的故事:从人文科学到数据科学:
照片由 Simran Yadav 在 Prezi 上拍摄
当我在 2015 年离开印度时，我是一名经济学和国际关系专业的学生。但是，在我大二的时候，作为课程的一部分，我不得不选了一门信息系统和统计学的课。通过这些课程，我积累了如何在现实世界中使用 MS access、MS excel 和回归等统计工具的知识。我对信息系统产生了真正的兴趣，并决定也主修这个专业。
学习三个非常不同的科目最初是一件麻烦事，但我很高兴我做到了。通过信息系统，我意识到我无疑喜欢通过数字，主要是通过趋势来理解世界。
在我的学士学位结束时，我知道我想进入数据和信息系统领域。但是，在那个时候，我对分析并不完全适应，并且肯定缺乏工作知识，需要在数据科学方面进行改进。所以我决定提高技能的最好方法是回到研究生院。(还有其他方法可以提高您的数据科学技能，其中一些将在本文结尾部分提到)。但是，我决定申请罗耀拉大学的商业数据分析项目(这是芝加哥地区最好的 MSBDA 项目，在全国排名第 33 位，所以我立刻觉得这是对的。).
这个项目基本上为我在 Excel 中处理统计数据做好了准备，让我知道如何在营销和供应链中使用数据(这个领域的知识确实有助于理解你正在做的所有数字运算)。除此之外，我非常欣赏这个项目的一点是，课程总体上强调实践经验，以学习不同的机器学习方法。因此，在过去的 8-9 个月里，我一直在积极参与 6 个不同的项目，其中一些是与实际的公司，涉及帮助他们解决他们面临的业务问题。而且，对于一些人来说，我可以灵活地在我感兴趣的领域工作，并且能够自己选择数据集并构建我认为对解决问题最有效的模型。
提示:在选择数据分析或数据科学的硕士项目时，
寻找一个理论和实践知识相结合的项目。这将极大地有助于获取知识，并有助于以后专业地展示这些技能。
最后，在我的硕士课程中，我学到了一些软技能，比如组织一个真正好的演示，以及如何创造引人注目的视觉效果来讲述一个故事。我认为数据科学中真正被忽视的一点是故事讲述方面。是的，编码很重要！是的，造型很重要！
但是，要真正将这些应用于实践，我们需要人们理解什么是信息，以及你的发现如何在商业意义上得到应用。这在很大程度上取决于你如何设计它，传递它，并激发你的观众理解它的兴趣。
那么我现在在做什么呢？我目前正在格林威治人力资源公司完成硕士学位。这是一家劳动力市场情报公司，收集实时、全面的招聘和薪酬数据。非常有趣，但具有挑战性，因为由于新冠肺炎，我们几乎每天都在处理数据的动态更新。
照片由 Simran Yadav 在 Prezi 上拍摄
一些小技巧:
1。一定要学习编码:如果你没有多少编码技能，没关系，根据一项对所有数据科学家的研究，他们中大约 22%的人有 1-2 年的编码经验，大约 19%的人有不到一年的编码经验。
Python 和 R 是行业标准。大约 70%的数据科学家更喜欢 Python。这对于非结构化数据尤其有用。我个人更喜欢 R，那只是因为我倾向于统计学。但是这两个都可以。
熟悉数据的存储、检索、访问、操作和充分利用，以便做出有成效的决策。
2。掌握一些数学知识:不要太广泛，比如高等微积分或导数(我必须做这些，但那是我的经济学专业。)但是，是的，熟悉代数、统计和概率。
3。领域知识:如果你想进入数据科学的特定领域，如体育分析、金融科技或供应链分析，会很有帮助。
你如何获得并提高上述技能？
1。在线学习:选择并完成课程，获得一些在线证书。Coursera 有一个非常好的机器学习入门课程，IBM 大数据大学有不同语言的学习路径，如 Python、R 甚至 Hadoop。
2。讲故事技巧 : Tableau 和 Power BI 利于数据可视化。Tableau 甚至有数据科学家、数据分析师等的学习路径。这里的问题是，他们现在免费提供这些课程。否则，他们通常从 200 美元到 300 美元不等。
3。实时项目: Apache projects、Kaggle 和 Pivigo 拥有大量资源和参与实时项目的良好资源。
4。开始:我认为这是最重要的，一旦你掌握了一些编码技巧，就可以开始使用你喜欢的数据集并建立初始模型。大多数人从 Titanic 或 HR 数据集开始，但对我来说，在我感兴趣的数据集上工作确实帮助我提高了技能，因为我在分析和可视化方面做得更好。最近，我开始处理来自 Kaggle 的钻石质量和卡地亚珠宝数据集。
成为一名彻底的专业数据科学家的过程是永无止境的，因此最关键的部分是识别问题，用数据驱动的方法解决问题，你将像交易一样学习模型和技术技能。
链接以上来源:
1 .在线课程:https://www.coursera.org/learn/machine-learning-duke
https://www . coursera . org/professional-certificates/IBM-data-science
2.讲故事:https://www.tableau.com/learn/get-started
https://www.udemy.com/course/powerbi-complete-introduction/
3.实时项目:https://www.kaggle.com
https://projects.apache.org/projects.html
Python 数据科学入门
在 YouTube 趋势数据集上执行简单的 OLS 线性回归
数据科学和 Python 携手并进。有很多地方和方法可以让你学习和使用 Python。一个很棒的地方是一个叫做 Kaggle 的网站。
Kaggle 是世界上最大的数据科学社区，拥有强大的工具和资源来帮助您实现您的数据…
www.kaggle.com](https://www.kaggle.com/)
如果你想免费访问课程、笔记本、数据集、大型社区和竞赛，那么 Kaggle 是不二之选。在这个练习中，我们将使用 Kaggle 笔记本来探索 YouTube 趋势数据集，并对其进行深入了解。
在这本笔记本中，我将执行一个构建和运行 OLS 线性回归模型的基本示例，以探索 YouTube 视频浏览量和特征数据(包括喜欢、不喜欢和评论数)之间的一些相关性。
来源
我将使用 Mitchell J .在 Kaggle 上通过 YouTube API 获得的趋势 YouTube 视频统计数据集:
[## 米切尔 J |卡格尔
Kaggle 是世界上最大的数据科学社区，拥有强大的工具和资源来帮助您实现您的数据…
www.kaggle.com](https://www.kaggle.com/datasnaek)
源代码可以在这里找到:
[## Mitchell jy/Trending-YouTube-Scraper
最初用于在 Kaggle 上建立这个数据集，其中有大约 6 个月的 YouTube 趋势视频。这个…
github.com](https://github.com/mitchelljy/Trending-YouTube-Scraper)
该数据集可在以下位置找到:
热门 YouTube 视频的每日统计数据
www.kaggle.com](https://www.kaggle.com/datasnaek/youtube-new)
数据集的许可可以在这里找到。
此页面有以下语言版本:CC0 1.0 通用版(CC0 1.0)公共领域专用公地…
creativecommons.org](https://creativecommons.org/publicdomain/zero/1.0/)
我的内容
我的 GitHub 库可以在这里找到:
此时您不能执行该操作。您已使用另一个标签页或窗口登录。您已在另一个选项卡中注销，或者…
github.com](https://github.com/third-eye-cyborg/LinearRegressionOLS-YouTubeTrends.git)
我的 Kaggle 笔记本可以在这里找到:
使用 Kaggle 笔记本探索和运行机器学习代码|使用趋势 YouTube 视频统计数据
www.kaggle.com](https://www.kaggle.com/thirdeyecyborg/ols-linear-regression-youtube-trends)
参考
如果您是 Python 新手，我还推荐一些我撰写的其他文章。
Python 编程语言是一种通用的编程语言，它已经在主流编程语言中占有一席之地
medium.com](https://medium.com/python-in-plain-english/a-brief-history-of-the-python-programming-language-4661fcd48a04) [## Python 基本概述
Python 有许多独特的特性，这些特性帮助它成为现在的样子。这些功能包括:
medium.com](https://medium.com/python-in-plain-english/python-basic-overview-76907771db60) [## Python 初学者完全参考指南
Python 是一种很好的初学者语言，但也适合高级用户。我将深入核心…
medium.com](https://medium.com/python-in-plain-english/python-beginners-reference-guide-3c5349b87b2) [## Python 的最佳 ide 和文本编辑器
我无法告诉你正确的 IDE(集成开发环境)对任何编程项目有多重要。只是…
medium.com](https://medium.com/analytics-vidhya/the-best-ides-and-text-editors-for-python-872ff1176c92) [## Anaconda 发行版概述
科学 Python 发行版将改变你研究数据科学的方式。
towardsdatascience.com](/an-overview-of-the-anaconda-distribution-9479ff1859e6) [## PEP 8 风格指南概述
让您的 Python 代码具有风格。
towardsdatascience.com](/an-overview-of-the-pep-8-style-guide-5672459c7682) [## 探索 Python 中的设计模式
如何在您的编程体验中实现可重用模型？
towardsdatascience.com](/exploring-design-patterns-in-python-be55fbcf8b34) [## 熊猫简介
使用 Pandas API 增强您的 Python 数据科学技能。
towardsdatascience.com](/introduction-to-pandas-cc3bc6355155)
目录
什么是 OLS 线性回归？
在统计学中，普通最小二乘法(OLS)是一种用于估计线性回归模型中未知参数的线性最小二乘法。OLS 通过最小二乘法原理选择一组解释变量的线性函数的参数:最小化给定数据集中观察到的因变量(被观察变量的值)与线性函数预测的因变量之间差异的平方和。
来源&确认:
在统计学中，普通最小二乘法(OLS)是一种估计未知变量的线性最小二乘法
en.wikipedia.org](https://en.wikipedia.org/wiki/Ordinary_least_squares)
维基百科贡献者。(2020 年 10 月 4 日)。普通最小二乘法。在维基百科，免费百科。2020 年 11 月 9 日 16:21 从https://en.wikipedia.org/w/index.php?检索 title =普通 _ 最小二乘& oldid=981750893
什么是 sklearn 模块？
python 的sklearn模块用于预测数据分析。你可以从他们的网站和文档中了解更多信息。
“我们使用 scikit-learn 来支持前沿基础研究[...]" "我认为这是我设计过的最棒的 ML 套装…
scikit-learn.org](https://scikit-learn.org/stable/index.html#)
您也可以在此查看pandas网站和文档:
pandas 是一个快速、强大、灵活且易于使用的开源数据分析和操作工具，构建于…
pandas.pydata.org](https://pandas.pydata.org/)
导入和加载数据集
第一步是进行必要的导入并加载数据集。
*# import modules*
import matplotlib.pyplot as plt
import pandas as pd
import os
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn import linear_model
from sklearn.metrics import mean_squared_error, r2_score
for dirname, _, filenames **in** os.walk('/kaggle/input'):
for filename **in** filenames:
print(os.path.join(dirname, filename))
*# load data*
data = pd.read_csv('../input/youtube-new/USvideos.csv')
作者输出的 Kaggle 笔记本
准备数据
然后对数据进行预处理，为 OLS 线性回归模型做准备。
*# break data down for analysis*
df = data[['title', 'views', 'likes', 'dislikes', 'comment_count']]
views = data[['title', 'views']]
likes = data['likes']
dislikes = data['dislikes']
comment_count = data['comment_count']
*# create feature list*
train_list = [likes, dislikes, comment_count]
*# print head to important data*
df.head()
作者输出的 Kaggle 笔记本
构建和运行 OLS 线性回归模型
接下来从sklearn模块创建并运行模型。确保检查均方误差和 r2 分数。
*# create scaler variable*
scaler = StandardScaler()
*# get feature titles ready*
labels = ['likes', 'dislikes', 'comment_count']
*# get y ready and preprocessed*
y = views['views']
y_scaled = y.values.reshape(-1, 1)
y_scaled = scaler.fit_transform(y_scaled)
*# get x ready and preprocessed*
for i, x **in** enumerate(train_list):
x_scaled = x.values.reshape(-1, 1)
x_scaled = scaler.fit_transform(x_scaled)
*#split data for fitting and predicting with the model*
X_train, X_test, y_train, y_test = train_test_split(x_scaled, y_scaled, test_size=0.33, random_state=42)
*# create model*
reg = linear_model.LinearRegression()
*# fit model*
reg.fit(X_train, y_train)
*# make prediction*
y_pred = reg.predict(X_test)
*# check the mean squared error*
mse = mean_squared_error(y_test, y_pred)
*# check the score function*
r2s = r2_score(y_test, y_pred) *#print feature labels*
print(labels[i])
*# print mse*
print(f'Mean squared error: **{**mse**}**')
*# 1 equals perfect prediction*
print(f'Coefficient of determination: **{**r2s**}**')
*# plot the visuals for a sanity check*
plt.plot(x, y, label=labels[i])
plt.title(f'**{**labels[i]**}** effect or YouTube views')
plt.xlabel = "views"
plt.ylabel = labels[i]
plt.legend()
plt.plot()
作者输出的 Kaggle 笔记本
视觉输出和模型输出都表明喜欢和视频观看之间的相关性比不喜欢和评论计数之间的相关性更高。
在文本编辑器或 IDE 中运行代码
如果你想在文本编辑器或者像 PyCharm 这样的 IDE 中运行它，你可以使用我的 GitHub 库中的代码。
作者 GitHub 要点
结论
虽然 OLS 线性回归可以很好地识别一些数据的更基本的相关性和洞察力，但它有时可能是有限的，不准确的，或对某些类型的问题有限制。确保为正确的任务选择正确的型号。这是一个探索 Python 中数据科学基础的简单示例。本文也是对 Kaggle 笔记本和数据集以及sklearn和 OLS 线性回归的简要介绍。我希望这能帮助任何开始学习 Python 数据科学的人。谢谢大家，编码快乐！
Python 数据结构入门
Deque 数据结构介绍
数据结构是一种数据管理格式，可以有效地访问和修改数据值集合。它由数据值、值之间的关系以及可以对它们使用的函数组成。在本帖中，我们将讨论如何在 python 中使用‘deque’数据结构。这篇文章中的例子是基于 Python 食谱 的“数据结构和算法”一章。
理解德克
“双端队列”是双端队列的首字母缩写。它是一个序列容器，可以从任意一端添加或删除元素。当您想保留在迭代或其他形式的处理过程中看到的最后几项的有限历史时,‘deques’非常有用。例如，假设您想要对以下文本中的一系列行执行简单的文本匹配，该文本包含对 Python Cookbook 的 Amazon 评论:
让我们从集合包中导入“deque ”:
from collections import deque
接下来，让我们定义一个最大长度为 5 的“deque”对象:
previous_lines = deque(maxlen=5)
为了促进“deque”数据结构的使用，让我们从遍历文本文件并打印每一行开始:
with open('amazon_review.txt') as f:
for line in f:
print(line)
接下来，让我们检查每一行中是否存在“Python ”,如果存在，则打印该行:
with open('amazon_review.txt') as f:
for line in f:
if 'Python' in line:
print(line)
现在我们定义一个生成器函数，它是一个行为类似迭代器的函数。当我们遍历文本文件时，每一行都被附加到“deque”，“previous_line”，然后再继续下一行:
def search_text(pattern):
previous_lines = deque(maxlen=5)
with open('amazon_review.txt') as f:
for line in f:
if pattern in line:
yield line, previous_lines
previous_lines.append(line)
然后，我们可以使用搜索模式“Python”迭代“search_text()”函数。我将截断输出，以包含一些附加的行:
for line, previous_lines in search_text('Python'):
print(line, previous_lines)
我们可以进一步迭代“deque”数据结构。这里我们将历史限制为最大长度= 5:
for line, previous_lines in search_text('Python'):
for pline in previous_lines:
print(pline, end='')
同样，使用“deque”数据结构的目的是将历史限制在迭代期间看到的最后几项。
我们可以定义一个函数来概括这个逻辑:
def search_text(lines, pattern, history=5):
previous_lines = deque(maxlen=history)
for line in lines:
if pattern in line:
yield line, previous_lines
previous_lines.append(line)
并用我们的输入值调用我们的函数:
if __name__ == '__main__':
with open('amazon_review.txt') as f:
for line, previous_lines in search_text(f, 'Python', 5):
for pline in previous_lines:
print(pline, end='')
print(line, end='')
print('-'*150)
接下来，我将介绍一些可用于“取消队列”对象的方法。让我们定义一个长度为 3 的固定大小的“deque”对象:
现在，让我们添加一些字符串值。让我们添加几个网址:
如果我们添加另一个元素:
如你所见，“https://pythonprogramming.net”被添加到“deque”中，“https://www.kaggle.com”和“https://www . kdnugges . com”被下移，“https://www.python.org”被删除。
我们可以使用“appendleft()”方法将一个元素添加到“deque”的底部。让我们添加熊猫图书馆文档的链接:
我们可以使用“pop()”方法删除“deque”顶部的元素:
我们还可以使用' popleft()'从' deque '的底部删除:
与具有 O(N)(线性时间复杂度)的列表不同，向/从队列的任一端添加(追加)或移除(弹出)项目具有恒定的时间 O(1)复杂度。
我就讲到这里，但是您可以随意将这段代码应用到其他文本文件中，并尝试搜索方法输入值。例如，您可以尝试更改最大长度(历史)并搜索替代文本模式。
结论
总之，在这篇文章中，我们讨论了使用 python 实现的“deque”数据结构的用例。当您需要保留有限的信息历史时，这些数据结构非常有用。尽管我们使用了一个文本匹配的例子，但是“deques”对于存储 web 浏览器历史也是有用的。类似于所示的最后一个例子，最近访问过的 URL 被添加到‘dequee’的前面，并且在‘dequee’后面的 URL 在一定数量的插入之后被移除。我希望这篇文章对你有帮助/有意思。如果你有任何问题，请留言。这篇文章的代码可以在 GitHub 上找到。
数据可视化入门
使用新冠肺炎新南威尔士州数据集理解 Pandas 和 Matplotlib 库如何工作。
数据可视化图片由https://unsplash.com/@emilep
编者注: 走向数据科学 是一份以研究数据科学和机器学习为主的中型刊物。我们不是健康专家或流行病学家，本文的观点不应被解释为专业建议。想了解更多关于疫情冠状病毒的信息，可以点击 这里 。
数据驱动着我们生活的世界，它经常帮助我们理解像现在这样的前所未有的时代正在发生什么。自今年年初以来，新冠肺炎改变了我们的生活和社交方式。了解病毒的传播和可视化感染率帮助我变得不那么焦虑，并理解社会距离如何有助于减少澳大利亚新南威尔士的感染人数。
要开始数据争论和可视化，必须从可靠的来源获取数据。我在 nsw.gov.au 找到了我需要的 CSV 文件形式的数据(对于那些刚刚开始使用 pandas 分析数据的人来说，逗号分隔值文件是首选)。CSV 文件包括通知日期和每个检测为阳性的患者从哪里获得病毒。
让我们编码
- 将必要的库导入到您的 Jupyter 笔记本中，开始使用。
**import** **numpy** **as** **np**
**import** **pandas** **as** **pd**
**from** **matplotlib** **import** pyplot **as** plt
%matplotlib inline
2.将 CSV 文件作为熊猫数据框读入 Jupyter 笔记本。
data = pd.read_csv('covid-19-cases-by-notification-date-and-likely-source-of-infection.csv')
3.尝试使用 Pandas 库中可用的 head()函数来理解数据框的内容。
data.head()
4.现在，让我们试着理解“可能感染源”一栏中的所有类别。要做到这一点，一个简单的方法是将整个列转换成一个列表，并获得唯一的值。
sources = list(data['likely_source_of_infection'])
set(sources)
5.日期条目的问题是，它通常可以是一个字符串或一个对象，当我们试图可视化“时间”时，它会变得棘手。为了防止任何此类问题，我们将包含日期的列转换为 DateTime，这样我们就可以毫无困难地访问日、月和年。
data['notification_date'] = pd.to_datetime(data['notification_date'],dayfirst=**True**)
6.查询功能允许用户从数据帧中检索他们需要的信息，很像 SQL 查询。获得每个类别的计数将有助于相应地可视化数据。
overseas = len(data.query('likely_source_of_infection == "Overseas or interstate"'))
local = len(data.query('likely_source_of_infection == "Locally acquired - contact not identified"')) + len(data.query('likely_source_of_infection == "Locally acquired - contact of a confirmed case and/or in a known cluster"'))
unidentified = len(data.query('likely_source_of_infection == "Under investigation"'))
print(f'The number of cases acquired from overseas in NSW : **{overseas}**.**\n**')
print(f'The number of cases acquired locally in NSW : **{local}**.**\n**')
print(f'The number of cases acquired from unidenitified sources in NSW : **{unidentified}**.**\n**')
7.人类是视觉动物，所以让我们把上面得到的数字放在一个饼图中，以便更好地理解比例。
labels = ['Overseas','Local','Unidentified']
no = [overseas,local,unidentified]
explode = (0, 0.1, 0)
fig1, ax1 = plt.subplots()
ax1.pie(no, labels=labels, explode = explode,autopct='**%1.1f%%**',shadow=**True**, startangle=90)
ax1.axis('equal') *# Equal aspect ratio ensures that pie is drawn as a circle.*
plt.show()
看，这比盯着无聊的数字要好得多。
8.那么，我们如何可视化 notification_date 列呢？一种方法是比较三月和四月的病例数。
data['notification_date'].groupby(data["notification_date"].dt.month).count().plot(kind="bar")
plt.suptitle('Monthly Infections in NSW', fontsize=10)
plt.xlabel('Months - March and April', fontsize=10)
plt.ylabel('No. of Infections', fontsize=10)
另一种方法是在我们可用的整个数据集期间，绘制每天的感染数。
data['notification_date'].groupby([data["notification_date"].dt.month, data["notification_date"].dt.day]).count().
plot(kind="bar")
plt.suptitle('Distibution of Number of Infections in NSW March - April', fontsize=10)
plt.xlabel('Date', fontsize=10)
plt.ylabel('No. of Infections', fontsize=10)
第二张图更深入地展示了案例数量的频率分布。很明显，曲线正在变平，每天的感染人数也在减少。
了解感染率趋势的另一种方法是绘制整个时间段的线形图。
data['notification_date'].groupby(data['notification_date']).count().plot(kind='line')
plt.suptitle('Distibution of Number of Infections in NSW', fontsize=10)
plt.xlabel('Date', fontsize=10)
plt.ylabel('No. of Infections per day', fontsize=10)
瞧啊。在不到十分钟的时间里，我们使用简单而强大的函数成功地洞察了数据集。这是让自己习惯熊猫和 matplotlib 的好方法。
整个笔记本和数据集可以在下面的 Github 链接中找到。
https://github.com/Vandhana-Visaka/NSW-COVID-ANALYSIS
Databricks 入门—分析新冠肺炎
马丁·桑切斯在 Unsplash 上的照片
深入了解 Databricks 平台
来自《走向数据科学》编辑的提示: 虽然我们允许独立作者根据我们的 规则和指导方针 发表文章，但我们并不认可每个作者的贡献。你不应该在没有寻求专业建议的情况下依赖一个作者的作品。详见我们的 读者术语 。
典型的数据科学工作流由以下步骤组成:
Identify Business Needs -> Data Ingestion -> Data preparation -> Data analysis -> Sharing data insights
这些步骤中的每一步都需要一组专业知识，这些专业知识可以分为:
数据工程师:开发、建造、测试和维护数据管道
数据科学家:使用多种方法提取洞察(机器学习模型)
数据分析师:获取数据工程师准备的数据，以图形、图表和仪表板的形式从中提取见解(商业智能)
平台管理员:负责管理和支持数据基础设施(DevOps)
Databricks 是一个统一的平台，为这些工作提供了必要的工具。在本文中，我们将通过创建数据管道和指定每个团队成员的职责来分析巴西的新冠肺炎数据。
准备
要完成接下来的步骤，您需要访问 Databricks 帐户。最简单的方法就是在 https://community.cloud.databricks.com创建一个 Databricks 社区账户
集群创建(平台管理员)
第一步是配置集群。Databricks 是一个基于 Spark 的平台，是最流行的大数据分析框架之一。Spark 本质上是一个分布式系统，这就是为什么集群创建过程包括为驱动程序和工作节点选择虚拟机。基本上，驱动程序是集群的指挥者，工作节点负责繁重的工作。
平台管理员负责根据用例、spark 版本、工作节点数量和自动扩展配置选择合适的虚拟机系列。例如，ETL 过程可能需要内存优化的设备，繁重的机器学习训练过程可能在 GPU 上运行。
集群创建过程
转到Clusters页面，使用 6.6 ML 运行时创建一个新集群。如果您使用 Azure Databricks 或 AWS，您将需要选择驱动程序和工作节点的 VM 系列。对于这个教程，你可以选择最便宜的。
数据接收(数据工程师)
数据摄取可能是一个具有挑战性的领域。通常，公司将数据存储在多个数据库中，现在使用数据流非常普遍。幸运的是，Databricks 与 Spark 和 Delta Lake 一起，可以帮助我们用一个简单的接口进行批处理或流式 ETL(提取、转换和加载)。
在本教程中，我们将从最简单的 ETL 开始，从 CSV 文件加载数据。
首先，我们需要下载数据集。请访问以下 URL:
https://github . com/relferreira/databricks-tutorial/tree/master/covid
并下载文件caso.csv.gz
解压文件，进入数据菜单，点击Add Data按钮。接下来，上传之前下载的 CSV 文件。
上传完成后，我们将使用数据集中显示的信息创建一个新表。单击Create Table UI，将表格重命名为covid，将第一行设置为标题，最后，单击 create 按钮。
表创建过程
数据分析(数据分析师)
创建好表后，我们可以开始分析数据集了。首先，我们需要创建一个新的 python 笔记本。去
Worspace > Users > YOUR EMAIL
点击箭头，创建一个新的笔记本
笔记本创建流程
虽然是一个 python 笔记本，但 Databricks 支持笔记本中的多种语言。在我们的例子中，我们将主要使用 SparkSQL 。如果你熟悉 SQL，SparkSQL 会给你家的感觉。
让我们先来看看我们的新表格:
%sql
SELECT * FROM covid
您应该会看到这样一个表格:
作为数据分析师，您应该能够从数据中提取有价值的信息。首先，我们需要理解表格中每一列的含义。一种方法是使用DESCRIBE功能:
%sql
DESCRIBE covid
分析这两个表，我们可以推断出，当列place_type等于state时，每一行代表该状态的总数。让我们试着画出人口最多的三个州的死亡人数的变化图:
%sql
SELECT date, state, deaths FROM covid WHERE state in (“MG”, “RJ”, “SP”) and place_type = “state”
点击Bar Chart按钮Plot Options，用以下配置配置一个Line chart:
现在我们有了疫情时期死亡人数演变的一个很好的代表。例如，我们可以将这个图表嵌入到仪表板中，以提醒这些州的人口。
数据科学(数据科学家)
接下来，我们将尝试预测之前绘制的时间序列的未来值。为此，我们将使用一个名为 Prophet 的脸书库
首先，我们需要安装一些依赖项。去…
Clusters > COVID > Libraries
并使用PyPI安装以下依赖项
- 熊猫
- pystan
- FB 先知
库安装过程
我们将尝试预测米纳斯吉拉斯州(MG)未来的死亡人数。所以第一步是收集我们的数据。
*也许您需要清除笔记本的状态
import pandas as pd
import logginglogger = spark._jvm.org.apache.log4j
logging.getLogger("py4j").setLevel(logging.ERROR)query = """
SELECT string(date) as ds, int(deaths) as y FROM covid WHERE state = "MG" and place_type = "state" order by date
"""df = spark.sql(query)
df = df.toPandas()
display(df)
接下来，我们将使用Prophet来拟合模型，并最终绘制“未来”
from fbprophet import Prophetm = Prophet()
m.fit(df)future = m.make_future_dataframe(periods=30)forecast = m.predict(future)fig1 = m.plot(forecast)
您应该会看到以下带有预测的图表:
米纳斯吉拉斯州的时间序列预测
结论
我们的目标是展示数据科学工作流程的所有步骤。这就是为什么我们没有描述时间序列模型是如何工作的。如果您遵循本教程，您应该对 Databricks 平台有了很好的了解。
完整的笔记本可以在这个公共存储库中获得
[## relferreira/data bricks-教程
此时您不能执行该操作。您已使用另一个标签页或窗口登录。您已在另一个选项卡中注销，或者…
github.com](https://github.com/relferreira/databricks-tutorial)
如果您有任何疑问，可以通过以下方式找到我:
https://twitter.com/relferreira
住宿之家#住宿安全
Keras 数据集入门
Keras 数据集简介
Keras 是一个用于神经网络的开源 python 库。它使得各种神经网络架构的实施和实验变得容易。除了为神经网络提供许多构建模块，Keras 还有许多内置数据集。
在本帖中，我们将看看 Keras 库中的一些基准数据。这些数据集通常用于展示新的机器学习算法相对于现有技术方法的改进性能。
我们开始吧！
CIFAR10 数据
我们要看的第一个数据集是 ' CIFAR10 '小型图像分类数据集。“CIFAR10”数据集包含飞机、汽车、鸟类、猫、鹿、狗、青蛙、马、船只和卡车的图像。
让我们导入“CIFAR10”数据:
from keras.datasets import cifar10
(x_train, y_train), (x_test, y_test) = cifar10.load_data()
接下来，让我们看看数据中的图像和标签列表。这可以在“CIFAR10”数据的文档中找到。
[来源](http://cifar dataset tensorflow)
如果我们打印训练输入数据的第一个值，我们得到:
print(X_train[0])
对应于该记录的标签是:
print("Label: ", y_train[0])
由于标签从 0 到 9，这对应于第 7 个标签，即一只青蛙。
让我们导入“matplotlib”并使用“imshow”方法来显示一些示例:
import matplotlib.pyplot as plt
plt.imshow(X_train[0])
plt.show()
我们可以为 inpsection 打印一些其他值:
import matplotlib.pyplot as plt
plt.imshow(X_train[1])
plt.show()
对应于该记录的标签是:
print("Label: ", y_train[0])
这对应于第 10 个标签，即卡车。
让我们再试一个:
import matplotlib.pyplot as plt
plt.imshow(X_train[2])
plt.show()
对应于该记录的标签是:
print("Label: ", y_train[0])
这也对应于卡车的图像。
IMDB 数据
“IMDB”数据集包含 25K 个电影评论。它通常用于构建基线自然语言处理模型或简单的文本分析。数据集包含每个评论的二进制分数(1 & 0 ),分别表示积极或消极的情绪。文本经过预处理，每个单词都用索引进行了编码。每个单词都根据在数据集中出现的总频率进行索引。
让我们加载“IMDB”数据:
from keras.datasets import imdb
(x_train, y_train), (x_test, y_test) = imdb.load_data(path="imdb.npz", num_words=None,skip_top=0, maxlen=None, seed=113, start_char=1, oov_char=2,index_from=3)
让我们打印第一份培训记录:
print(X_train[0])
相应的标签:
print("Label: ", y_train[0])
鉴于文本是编码的，这里没有太多可看的。如果你有兴趣分析原始数据，可以在这里找到。让我们继续下一组数据。
MNIST 数据
我们要看的下一个数据集是“MNIST”数据集。数据集包含 60K 28x28 灰度手写数字(0-9)。它还被用作验证新的图像分类方法的基准数据集。
让我们加载数据:
from keras.datasets import mnist(X_train, y_train), (X_test, y_test) = mnist.load_data()
让我们打印第一条记录:
print(X_train[0])
对应于该记录的标签是:
print("Label: ", y_train[0])
现在让我们使用“imshow”来显示图像:
plt.imshow(X_train[0], cmap='gray')plt.show()
让我们打印下一条记录:
plt.imshow(X_train[1], cmap='gray')plt.show()
让我们再试一个:
plt.imshow(X_train[2], cmap='gray')plt.show()
现在让我们看看“时尚 MNIST”的数据集。
时尚-MNIST 数据
“时尚-MNIST”数据集包含来自 Zalando 文章的 6 万张标记时尚类别的灰度图像。它还用于测试图像分类的机器学习算法。
标签代码如下:
让我们导入数据:
from keras.datasets import fashion_mnist(X_train, y_train), (X_test, y_test) = fashion_mnist.load_data()
让我们显示第一个图像及其标签:
plt.imshow(X_train[0], cmap='gray')
plt.show()
print("Label: ", y_train[0])
标签“9”对应于踝靴。
让我们试试另一个:
plt.imshow(X_train[1], cmap='gray')
plt.show()
print("Label: ", y_train[1])
最后，还有一个:
plt.imshow(X_train[2], cmap='gray')
plt.show()
print("Label: ", y_train[2])
结论
我将在这里停下来，但是您可以自由地进一步探索这些数据集。考虑到这些数据集是结构化的和有标签的，它们对于有志于加强建模技能的初露头角的数据科学家来说是一个很好的资源。
总之，在这篇文章中，我们讨论了如何从 Keras 库中提取数据。我们查看了“CIFAR”、“MNIST”和“时尚-MNIST”数据，所有这些数据都是图像分类的通用基准数据集。我们还查看了“IMDB”数据集，其中包含编码的评论，并附有与积极和消极情绪相对应的标签。这是另一个常用于情感分析的基准数据集。我希望你觉得这篇文章很有趣。这篇文章的代码将在 GitHub 上发布。感谢您的阅读！
Deno: Nodejs 替代方案入门
编程；编排
V8 和 Rust 上的安全类型脚本运行时
福斯托·加西亚在 Unsplash 上拍摄的照片
**Table of Contents**[**Introduction**](#91be)🦕 [Installation](#288e)
🦕 [Deno Built-in tools](#3da7)
🦕 [ES Modules and No Package Manager](#c6ce)
🦕 [Deno Standard library](#3397)
🦕 [Security with Deno sandbox](#c773)
🦕 [Web-API compatible](#caca)
🦕 [TypeScript](#7de5)
🦕 [Import maps](#a4f1)
🦕 [Test](#b83a)
🦕 [Third-party modules](#b4f7)
🦕 [HTTP request](#627c)
🦕 [Limitation](#44bb)[**Conclusion**](#945c)
介绍
2018 年 6 月，Node.js 的最初开发者 Ryan Dahl 在 JSConf EU 发表了演讲“关于 Node.js 我后悔的 10 件事”。下半年，他公布了自己的新项目 Deno。
他后悔在创建 Node.js 时做了 10 件本可以做得更好的事情。这促使他创建了 Nodejs 替代方案。
2020 年 5 月 13 日， Ryan Dahl，Bert Belder，Bartek iwan czuk发布 Deno 1.0。开发者可以期待定期的稳定发布。
Deno 是一个使用 JavaScript 和 TypeScript 编写应用程序的新平台。它基于 V8 JavaScript 引擎和 Rust。
Deno 与系统的最低级别绑定层与承诺(称为ops)绑定在一起。Deno 在默认情况下是安全的，提供了一流的类型脚本支持，内置了依赖检查器之类的工具，并支持第三方模块，如lodash。
在本文中，我将探讨 Deno 的一些特性。
听起来有趣吗？请继续阅读。
装置
Deno 可以在 macOS、Linux 和 Windows 上运行。Deno 是一个单一的二进制可执行文件，它没有外部依赖性。
查看所有安装。
对于自制软件用户:
$ brew install deno
...
Bash completion has been installed to:
/usr/local/etc/bash_completion.dzsh completions have been installed to:
/usr/local/share/zsh/site-functions
==> Summary
🍺 /usr/local/Cellar/deno/1.0.0: 9 files, 41.7MB
安装后，您可以检查版本和帮助。
$ deno --version
deno 1.0.0
v8 8.4.300
typescript 3.9.2
$ deno help
...
OPTIONS:
-h, --help Prints help information
-L, --log-level <log-level> Set log level [possible values: debug, info]
-q, --quiet Suppress diagnostic output
-V, --version Prints version information
SUBCOMMANDS:
bundle Bundle module and dependencies into single file
cache Cache the dependencies
completions Generate shell completions
doc Show documentation for a module
eval Eval script
fmt Format source files
help Prints this message or the help of the given subcommand(s)
info Show info about cache or info related to source file
install Install script as an executable
repl Read Eval Print Loop
run Run a program given a filename or url to the module
test Run tests
types Print runtime TypeScript declarations
upgrade Upgrade deno executable to given version
ENVIRONMENT VARIABLES:
DENO_DIR Set deno's base directory (defaults to $HOME/.deno)
DENO_INSTALL_ROOT Set deno install's output directory
(defaults to $HOME/.deno/bin)
NO_COLOR Set to disable color
HTTP_PROXY Proxy address for HTTP requests
(module downloads, fetch)
HTTPS_PROXY Same but for HTTPS
Deno 内置工具
Deno 提供了一套内置工具来改善开发人员的体验。
- 运行测试:
deno test - 格式化源文件:
deno fmt - 邦德勒:
deno bundle - 调试
deno --inspect <file> - 棉绒(即将推出)
deno lint
deno lint是提高代码质量的 TypeScript 类型检查。它还没有发布。
您可以使用deno fmt来格式化文件。(当我保存一个文件时，VS 代码为我做了这件事。)
ES 模块和无软件包管理器
使用 Deno 时，您注意到的第一件事是 Deno 使用 es 模块作为默认模块系统，而 Node.js 使用 CommonJS。并且使用 URL 加载外部依赖项，
在 Node.js 中:
在 Deno:
Deno 是网络兼容的，你可以从一个网址运行deno。
$ deno run https://deno.land/std/examples/welcome.ts
Download https://deno.land/std/examples/welcome.ts
Warning Implicitly using master branch https://deno.land/std/examples/welcome.ts
Compile https://deno.land/std/examples/welcome.ts
Welcome to Deno 🦕
你用deno run <URL/file>运行一个程序。你可以找到更多关于deno run --help的帮助。
或者你可以在 REPL 的deno经营。
$ deno
Deno 1.0.0
exit using ctrl+d or close()
> console.log("Welcome to Deno 🦕");
Welcome to Deno 🦕
因为您可以从 URL 导入库，所以您可以在互联网上的任何地方托管模块。不需要 package.json 文件和依赖列表。没有像 npm 那样的集中注册中心。
Deno 标准库
Deno 在 https://deno.land/std 提供了一个标准库。
下面使用来自标准库的datetime库。
在您的终端中:
$ deno run datetime.ts
Compile file:///Users/shinokada/Deno/demo/datetime.ts
2019-01-19T15:00:00.000Z
德诺标准图书馆
Deno 沙盒的安全性
Deno 在沙箱中执行代码，这意味着运行时无法访问网络、文件系统和环境。
Deno 提供权限白名单。对于文件系统，可以使用--allow-read和--allow-write。您可以使用--allow-net标志来访问主机/url。因为。env 文件，可以将--allow-env与 load.ts 一起使用。
创建 demo.js:
您需要--allow-net标志来运行 demo.js:
$ deno run --allow-net demo.js
http://localhost:8000/
Web-API 兼容
网络浏览器使用 Web-API 。Deno 为提供了一些 Web-API。例如，在 Nodejs 中需要fetch。
const fetch = require('node-fetch')
fetch('[https://jsonplaceholder.typicode.com/posts/](https://jsonplaceholder.typicode.com/posts/1)1')
.then(res => res.json())
.then(data => console.log(data) )
在 Deno 中，可以使用fetch:
# fetch.ts
const res = await fetch("[https://jsonplaceholder.typicode.com/posts/1](https://jsonplaceholder.typicode.com/posts/1)");
const json = res.json();
const data = await json;
console.log(data)
然后在您的终端中:
$ deno run --allow-net fetch.ts
{
userId: 1,
id: 1,
title: "sunt aut facere repellat provident occaecati excepturi optio reprehenderit",
body: "quia et suscipit\nsuscipit recusandae consequuntur expedita et cum\nreprehenderit molestiae ut ut quas..."
}
以打字打的文件
Deno 支持 TypeScript，不需要额外的工具。你可以通过deno types | less看到 Deno 的 TypeScript 声明或者看到https://deno.land/typedoc/index.html。
deno types输出包含三个库。
导入地图
尽管在撰写本文时它仍然是一个不稳定的特性，Deno 支持导入映射。Import maps控制 JavaScript 导入的行为。
例如，在 import_map.json 中:
在 hello_server.ts 中:
在您的终端中:
$ deno run --allow-net --importmap=import_map.json --unstable hello_server.ts
然后访问 http://localhost:8000/ 查看输出。
试验
您可以使用 Deno 的内置测试运行器来测试 Javascript 或 TypeScript。使用 Deno 的标准库测试/断言，可以使用equal、assert、assertEquals、assertNotEquals、assertStrictEq、assertStrContains、assertArrayContains、assertMatch等函数。
在 mytest.ts 中:
在终端中:
$ deno test mytest.ts
Compile file:///Users/shinokada/Deno/demo/.deno.test.ts
running 1 tests
test title ... ok (5ms)test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out (6ms)
第三方模块
你可以在 https://deno.land/x/找到在 Deno 上工作的第三方模块。
Deno 上有许多现成的模块，lodash就是其中之一:
您可以搜索不同的类别。还有受 Express、Koa、哈比神等启发的 Deno 中间件和 web 框架。
第三方模块中的中间件
第三方模块中的应用程序
。包封/包围（动词 envelop 的简写）
Deno 使用Deno.env.set/Deno.env.get设置/获取环境变量的值。
你需要使用--allow-env标志来运行这个。
$ deno run --allow-env denoenv.ts
8888
使用。env 是一种常见的做法。可以使用第三方模块[dotenv](https://deno.land/x/dotenv)。
在.env文件中:
在 app.ts 文件中:
你需要--allow-read标志来读取.env文件。
$ deno run --allow-read app.ts
Compile file:///Users/shinokada/Deno/demo/app.ts
8777
HTTP 请求
在 Deno 中，可以使用 Web API fetch 进行 HTTP 调用。在下面的代码中，您将第一个参数存储到const url，获取url，然后将响应解析为一个 ArrayBuffer ，等待响应，将其转换为一个 Uint8Array 并存储在变量体中。
在终端中:
deno run --allow-net=example.com https://deno.land/std/examples/curl.ts [https://example.com](https://example.com)
产出:
Download https://deno.land/std/examples/curl.ts
Warning Implicitly using master branch https://deno.land/std/examples/curl.ts
Compile https://deno.land/std/examples/curl.ts
<!doctype html>
<html>
<head>
<title>Example Domain</title><meta charset="utf-8" />
...
由于正在进行的进度限制
由于 Deno 仍处于早期阶段，因此存在一些局限性。一些标准库在运行时需要--unstable标志。
不稳定标志
节点模块是 NodeJS 标准库的一层。
在撰写本文时，您仍然需要使用--unstable标志来处理 node。
$ deno run --unstable path.ts
Compile file:///Users/shinokada/Deno/demo/path.ts
quux.html
结论
Deno 的目标不是取代 Node.js，而是提供一种替代方案。观察 Node.js 如何以不同的方式实现是很棒的。
Deno 的成功取决于许多因素，特性、稳定性、性能、社区、学习曲线、文档、工具等。
尽管 v1.0 刚刚发布，但第三方模块开发者社区正在迅速发展，这对 Deno 来说无疑是一个积极的信号。你觉得瑞安·达尔的最新作品怎么样？
通过 成为 会员，可以完全访问媒体上的每一个故事。
https://blog.codewithshin.com/subscribe
资源
🦕 Deno Github 回购
🦕德诺手动🦕 Deno 标准库
🦕节点标准库
🦕 Deno 第三方模块🦕Deno doc🦕 Visual Studio 代码 Deno 扩展
面向数据科学家的 Docker 入门
使用 Docker 的快速入门指南和最佳实践
图片由作者提供(使用 Canva 制作)
我们都经历过，
"它在我的机器上工作！！”。
谁不在声明的两端？
作为开发人员、数据科学家、软件工程师，我们在复杂的代码基础上工作，这些代码基础依赖于后台的许多项。当我们想与同事分享我们的代码或作为开源项目放在 Github 上时，我们需要确保代码能在所有不同的环境下工作。
有时候——比我们愿意承认的更多——我们试图运行朋友的代码或我们从互联网上得到的代码，这时计算机对我们大喊“ 导入错误。”那个错误意味着代码需要更多它在你的计算机上找不到的信息。
解决方法是使用 Docker 。Docker 是一个容器管理系统，旨在促进共享项目，并在不同的环境中运行它们。基本上，Docker 通过将代码及其所有依赖项封装在一个容器中，使得在其他具有不同操作系统的机器上编写和运行代码变得容易。
这个容器使代码独立于操作系统。
图片由作者提供(使用 Canva 制作)
我们为什么使用码头工人？
当我们为数据科学或机器学习应用程序编写代码时，我们经常会有许多顾虑，使得使用 Docker 成为我们应用程序的最佳选择。这些问题是:
- 确保应用程序能够以相同的方式在所有环境中工作。
- 为那些将要使用/运行你的应用程序的人省去处理依赖和安装问题的麻烦。
- 避免使用虚拟机。
- 专注于构建应用程序，而不是担心管理依赖关系。
码头基础知识
那么，Docker 是如何工作的呢？
为了理解这一点，我们首先需要了解一些 Docker 术语，让我们深入了解一下。
形象
图像与运行应用程序所需的所有数据一起存档。如果你熟悉编程语言，你可以想象一个图像，就像你想象一个类一样。班级是蓝图；它们包含生成密集的必要数据，而图像是包含创建容器所需数据的蓝图。
图像不会改变，这意味着您对特定图像所做的任何更改都不会被保存，除非您保存了该图像的副本。
容器
容器是运行应用程序的封闭环境。容器只能访问允许它访问的资源(存储、CPU、内存)，并不知道它所运行的机器的任何其他信息。容器只能访问包含运行应用程序所需信息的 Linux 发行版。
默认情况下，容器不会留下任何数据。只要您没有将容器保存为新图像，对容器所做的任何更改都会在移除后立即丢失。
码头文件
docker 文件是包含运行应用程序所需信息的文件。每个图像必须至少包含——最好是 Dockerfile。docker 文件可以分为三个主要部分:
- 基础镜像:应用的核心。例如，如果应用程序需要 Python3 才能正确运行，那么 Python 3 将是基础映像，而附加库将包含在指令集中。
- 指令集:指令集包括运行命令；每一个都代表需要安装或运行的额外的库或二进制文件。
- Entry 命令:这些是在安装了所有需要的库之后运行的命令。例如，一个输入命令可以是打开 Jupyter 笔记本，或者运行命令行等。
你可以把一个图像想象成一个洋葱，基础图像是洋葱的心脏，每条指令都是图像中的一个新层。这就是为什么你需要注意如何分层你的指令。
图片由作者提供(使用 Canva 制作)
卷
由于图像是固定的，容器的内存很短——类似于 ram——如果我们有运行应用程序所需的数据，会发生什么呢？
这就是体积解决问题的地方。当我们拥有应用程序所需的数据时，我们可以采用两种方法之一:本地访问数据或从卷中访问数据。本地访问数据—具有本地挂载点—需要您在本地机器上选择一个存储数据的特定目录。
当您对主机(应用程序将在那里运行)一无所知时，卷用于共享数据。
注册
注册表是 Docker 映像的存储库等价物。它允许你拉和推容器图像。你可以直接从你的 Docker 主机上分发你的图片，或者使用云代理，如 Kubernetes 、 Docker Swarm 或 DockerHub 。使用这样的服务可以让您获得有用的特性，比如自动化部署和扩展。
如何开始使用 Docker？
步骤 1:安装 Docker
要在您的设备上安装 Docker，请访问官方 Docker 网站并为您的机器安装正确的版本。要使您的安装正确进行，请尝试运行以下命令:
docker run
如果您得到如下内容，那么一切都已启动并运行，您已经准备好开始工作了！
作者的屏幕
步骤 2:了解基本命令
码头工人是一个相当宽泛的概念。但是，只要知道基本的 6 个命令，运行， ps ，重命名，停止，启动，以及日志，你就可以走得很远。
图片由作者提供(使用 Canva 制作)
步骤 3:准备需求文件
您可以直接将二进制文件和所需的库添加到 docker 文件中；最好把它们放在一个独立的文件里。这个文件通常被称为 requirements.txt。
图片由作者提供(使用 Canva 制作)
第四步:准备文档
写一个简单有效的 Dockerfile 文件。是时候把洋葱从里面组装出来了。我们需要设置一个基本图像和输入命令。
图片由作者提供(使用 Canva 制作)
步骤 5:创建一个 Docker 图像
通常我们的代码被托管在 GitHub 上，这使得创建代码的图像变得非常容易。如果本地有 GitHub，可以使用命令行并运行 repo2docker 命令从 repo 创建一个映像。
然而，如果你试图为其创建图像的代码在 GitHub 上，那么你可以使用 myBinder 来生成和托管你的回购图像。您将能够使用 myBinder 提供的链接访问该图像。如果您使用的是 myBinder，requirement.txt 将被称为 envrionment.yml，它将包含与需求相同的信息。
要使用 myBinder，您需要有回购主分行的链接。对于本文，我使用的是我为一个事件创建的回购。
作者的屏幕
如果您使用的是 Anaconda navigator，那么您可以使用 conda 命令行来生成特定环境的 envrionment.yml 文件，使用以下命令:
conda env export --name ENVNAME > envname.yml
步骤 6:运行容器
要运行容器，如果容器已经下载到您的机器上，您可以使用我们前面提到的 run 命令。但是，如果您使用 myBinder 并且图像托管在云上，您可以通过使用图像生成的链接来访问它。该链接将添加到您的 readme.md 文件中，并导致一个启动容器的徽章。
作者的屏幕
最佳实践的提示和技巧
- 始终确保您使用的是最有效的基础映像。例如，在 Python3 的情况下，选择苗条克星或伸展克星。他们有充分的支持，并与大多数 DS 和 ML 库配合良好。
- 使用标签提供重要信息，如使用技巧和关于应用程序和所需库以及如何使用它们的额外信息。
- 拆分运行命令，使它们更具可读性。将所有需要的库放在 requirments.txt 文件中以保持有序。
- 仅安装必要的包。这使得构建和运行映像更加高效。
- 显式忽略文件以避免安全风险(将它们添加到。忽略文件)。
- 避免添加数据，从数据库或云中提取数据(使用绑定挂载)，但不要在映像中硬编码。
- 如果您从 Docker 开始并想要一个标准项目模板，请使用 CookieCutter 数据科学或 CookieCutter docker 科学项目模板。
要掌握 Docker 可能会变得非常复杂和具有挑战性，但是最好的办法是坚持练习，并尝试利用 Docker 提供的强大功能。
即使您并不完全熟悉 Docker，它的主要用途是为您的应用程序提供极大的控制和能力。只需使用本文中介绍的基本命令，您就可以利用 Docker 的强大功能来共享、部署和开发您的应用程序。
开始使用端到端语音翻译
使用 Pytorch，您只需几个步骤就可以翻译英语演讲
更新 24–05–2021:本教程中使用的 github 库不再开发。如果有兴趣，你应该参考正在积极开发的这个叉子。
介绍
语音到文本的翻译是将源语言的语音翻译成不同目标语言的文本。这个任务的历史可以追溯到 1983 年的一个演示中。处理这项任务的经典方法是训练一系列系统，包括自动语音识别(ASR)和机器翻译(MT)。你可以在你的谷歌翻译应用中看到，你的演讲首先被转录，然后被翻译(尽管翻译看起来是实时的)
人工智能和机器翻译的任务已经被研究了很长时间，并且随着深度学习技术的采用，系统的质量已经经历了显著的飞跃。事实上，大数据的可用性(至少对某些语言而言)、强大的计算能力和清晰的评估，使这两项任务成为像谷歌这样在研究上投入大量资金的大公司的完美目标。参见关于变压器【1】和spec augment2】的论文作为参考。由于这篇博客文章不是关于级联系统的，我向感兴趣的读者推荐在上次 IWSLT 竞赛中获胜的系统[3]。
IWSLT 是致力于口语翻译的主要年度研讨会。每个版本都有一个“共享任务”，一种竞赛，目的是记录口语技术的进步。自 2018 年以来，共享任务开始对“端到端”系统进行单独评估，这些系统由单一模型组成，学习直接从音频翻译成目标语言的文本，没有中间步骤。我们小组从第一版开始就一直参与这个新的评估，我在之前的报道中报道了我们的第一次参与。
我们如何为 IWSLT 2018 评估活动构建我们的端到端语音到文本翻译系统。
与级联方法相比，端到端模型的质量仍在讨论中，但这是一个不断发展的研究课题，质量改进的报告非常频繁。本教程的目标是通过为读者提供一步一步的指南来训练端到端系统，从而降低这个领域的入门门槛。特别是，我们将关注一个可以将英语语音翻译成意大利语的系统，但它可以很容易地扩展到其他七种语言:荷兰语、法语、德语、西班牙语、葡萄牙语、罗马尼亚语或俄语。
你需要什么
最低要求是访问至少一个 GPU，可以通过安装 Colab 和 Pytorch 0.4 免费获得。
现在，您可以使用 Keras 在免费的 Tesla K80 GPU 上与 Google 合作开发深度学习应用程序
medium.com](https://medium.com/deep-learning-turkey/google-colab-free-gpu-tutorial-e113627b9f5d)
然而，K80 GPUs 非常慢，需要几天的训练。接入更好或者更多的 GPU 会有很大的帮助。
获取数据
我们将使用 MuST-C，这是可用于直接语音翻译任务的最大的多语言语料库。您可以在介绍它的论文[4]或下面的媒体故事中找到详细的描述:
…你一定要看看！
medium.com](https://medium.com/machine-translation-fbk/must-c-a-large-corpus-for-speech-translation-8e2350d01ea3)
要获取语料库，请前往https://mustc.fbk.eu/,点击“点击此处下载语料库”按钮，然后填写表格，您很快就可以下载了。
MuST-C 分为 8 个部分，每个部分对应一种目标语言，您可以随意下载其中的一种或全部，但是对于本教程，我们将使用意大利目标语言(it)作为示例。每一部分都包含用英语发表的 TED 演讲，并翻译成目标语言(翻译由 Ted 网站提供)。训练集的大小取决于给定语言的翻译的可用性，而验证集和测试集是从公共的谈话库中提取的。
MuST-C 的每个部分都分为列车、开发、tst-COMMON 和 tst-HE。Train、dev 和 tst-COMMON 表示我们分为训练、验证和测试集，而您可以安全地忽略 tst-HE。在这三个目录的每一个中，您都会发现三个子目录:wav/、txt/和 h5/。wav/包含了音频端的设置形式。wav 文件，每个对话一个。txt包含抄本和翻译，对于我们的意大利语示例，您将在train/txt目录下找到文件train.it, train.en, train.yaml。前两个分别是文本翻译和转录。train.yaml是一个包含音频分段的文件，其方式与文本文件一致。作为奖励。恩还有。it 文件是并行的，因此可以用来训练机器翻译系统。如果您不知道如何处理 yaml 文件提供的分段，请不要害怕！在h5/目录中有一个单独的. h5 文件，该文件包含已经被分割和转换以提取 40 个 Mel 滤波器组特征的音频。
注意:数据集将从 Google Drive 下载，如果你想从没有 GUI 的机器上下载，可以尝试使用工具 gdown 。然而，它并不总是正确地工作。如果您无法使用 gdown 下载，请在几个小时后重试。
获取软件
我们将使用FBK-公平序列-ST ，这是脸书为机器翻译开发的公平序列工具，适用于直接语音翻译任务。从 github 克隆存储库:
git clone [https://github.com/mattiadg/FBK-Fairseq-ST.git](https://github.com/mattiadg/FBK-Fairseq-ST.git)
然后，还要克隆 mosesdecoder，它包含了对文本预处理有用的脚本。
git clone [https://github.com/moses-smt/mosesdecoder.git](https://github.com/moses-smt/mosesdecoder.git)
数据预处理
数据的音频部分已经在. h5 文件中进行了预处理，所以我们只需要关心文本部分。
让我们首先创建一个存放令牌化数据的目录。
> mkdir mustc-tokenized
> cd mustc-tokenized
然后，我们可以继续对我们的意大利文本进行标记化(其他目标语言需要类似的过程):
> for file in $MUSTC/en-it/data/{train,dev,tst-COMMON}/txt/*.it; do
$mosesdecoder/scripts/tokenizer/tokenizer.perl -l it < $file |
$mosesdecoder/scripts/tokenizer/deescape-special-chars.perl > $file
done> mkdir tokenized> for file in *.it; do
cp $file tokenized/$file.char
sh word_level2char_level.sh tokenized/$file
done
第二个 for 循环将单词拆分成字符，就像我们在为所有 MuST-C 语言设置基线的论文中所做的那样[5]。
现在，我们必须将数据二进制化，以便为 fairseq 制作单一格式的音频和文本。首先，链接数据目录中的 h5 文件。
> cd tokenized
> for file in $MUSTC/en-it/data/{train,dev,tst-COMMON}/h5/*.h5; do
ln -s $file
done
然后，我们可以移动到实际的二值化
> python $FBK-Fairseq-ST/preprocess.py --trainpref train --validpref dev --testpref tst-COMMON -s h5 -t it --inputtype audio --format h5 --destdir bin
这将需要几分钟的时间，最终您应该会得到如下结果:
> ls bin/
dict.it.txt train.h5-it.it.bin valid.h5-it.it.idx
test.h5-it.it.bin train.h5-it.it.idx valid.h5-it.h5.bin
test.h5-it.it.idx train.h5-it.h5.bin valid.h5-it.h5.idx
test.h5-it.h5.bin train.h5-it.h5.idx
test.h5-it.h5.idx valid.h5-it.it.bin
我们有一个目标语言的字典(dict.it.txt)，对于数据的每个分割，源端有一个索引和一个内容文件(.h5.idx 和.h5.bin)，目标端也有相同的索引和内容文件(.it.idx 和.it.bin)。
至此，我们已经完成了数据预处理，可以继续训练了！
训练您的模型
注意:在培训之前，我强烈建议您使用相同架构的 ASR 系统对编码器进行预培训。训练脚本和这里一样，但是先按照这篇文章末尾的说明来做。没有编码器预训练，这些模型是不稳定的，并且可能不收敛。
对于培训，我们将复制[5]中报告的内容。您只需要运行以下命令:
> mkdir models
> CUDA_VISIBLE_DEVICES=$GPUS python $FBK-Fairseq-ST/train.py bin/ \
--clip-norm 20 \
--max-sentences 8 \
--max-tokens 12000 \
--save-dir models/ \
--max-epoch 50 \
--lr 5e-3 \
--dropout 0.1 \
--lr-schedule inverse_sqrt \
--warmup-updates 4000 --warmup-init-lr 3e-4 \
--optimizer adam \
--arch speechconvtransformer_big \
--distance-penalty log \
--task translation \
--audio-input \
--max-source-positions 1400 --max-target-positions 300 \
--update-freq 16 \
--skip-invalid-size-inputs-valid-test \
--sentence-avg \
--criterion label_smoothed_cross_entropy \
--label-smoothing 0.1
让我一步一步来解释。bin/是包含二进制数据的目录，如上所述，而models/是保存检查点的目录(每个时期结束时一个)。--clip-norm指的是渐变裁剪，和--[dropout](https://medium.com/@amarbudhiraja/https-medium-com-amarbudhiraja-learning-less-to-learn-better-dropout-in-deep-machine-learning-74334da4bfc5)熟悉深度学习的应该很清楚。--max-tokens是每次迭代在单个 GPU 中可以加载的音频帧的最大数量，--max-sentences是最大批量，也受 max-tokens 的限制。--update-freq还会影响批量大小，因为我们在这里说权重必须在 16 次迭代后更新。它基本上模拟了 16x GPUs 的训练。现在，优化策略:--optimizer adam 用于使用 Adam 优化器， --lr-schedule inverse_sqrt使用 Transformer 论文[1]中介绍的时间表:学习速率在--warmup-updates步(4000)中从--warmup-init-lr (0.0003)线性增长到--lr (0.005)，然后随着步数的平方根下降。要优化的损失是使用 0.1 的--label-smoothing与标签平滑 ( --criterion)的交叉熵。损失在句子中平均，而不是在具有--sentence-avg的记号中平均。--arch定义了要使用的架构和超参数，这些可以在运行训练时更改，但是speechconvtransformer_big使用了与我们论文中相同的超参数，除了我们命令中指定的距离惩罚。
深度学习架构是转换器对语音翻译任务的适应，它修改编码器以处理输入中的频谱图。我将在以后的博客中描述它。
在训练期间，将在每个时期结束时保存一个检查点，并相应地称为 checkpoint1.pt、checkpoint2.pt 等。此外，在每个时期结束时还会更新另外两个检查点:checkpoint_best.pt 和 checkpoint_last.pt。前者是验证损失最大的检查点的副本，后者是最后保存的检查点的副本。
生成和评估
当您准备好从音频(实际上是预处理的光谱图)运行翻译时，您可以运行以下命令:
python $FBK-Fairseq-ST/generate.py tokenized/bin/ --path models/checkpoint_best.pt --audio-input \
[--gen-subset valid] [--beam 5] [--batch 32] \
[--skip-invalid-size-inputs-valid-test] [--max-source-positions N] [--max-target-positions N] > test.raw.txt
这里绝对需要的是带有二进制数据的目录bin/，到检查点的路径--path models/checkpoint_best.pt，但它可以是任何保存的检查点，--audio-input，并通知软件它必须期待音频(而不是文本)输入。
根据设计，该命令将在给定的目录中查找数据集的“测试”部分。如果要翻译另一个，valid 或者 train，用--gen-subset {valid,train}就可以了。通过--beam和--batch可以分别修改光束大小和批量大小。--skip-invalid-size-inputs-valid-test让软件跳过比--max-source-positions和--max-target-positions设定的限制更长的段。
输出将是这样的:
带有翻译参数和数据信息的报头
段号 371、2088 和 713 的翻译
它首先列出用于翻译的参数，然后是一些数据信息:首先是字典，然后是数据集，最后是模型的路径。
在序言之后，我们有按照源代码长度排序的翻译列表。这个长度在翻译中并不明显，但在翻译长度中有部分体现。每个线段由其原始位置标识，每个线段有四行。源片段 S，这里总是音频，参考句子 T，翻译假设 H 和每个单词 p 的对数概率
最后一行打印的是 BLEU 分数，但这里是在角色级别计算的，对我们来说意义不大。
为了提取翻译，按照职位 id 对它们进行排序，并将翻译带到单词级别，您可以使用以下脚本
> python $FBK-Fairseq-ST/scripts/sort-sentences.py test.raw.txt 5 > test.lines.txt
> bash $FBK-Fairseq-ST/scripts/extract_words.sh test.lines.txt
这将创建单词级文件 test.lines.txt.word，您可以使用它来测量 BLEU 分数，例如使用 mosesdecoder 存储库中的脚本:
> $mosesdecoder/scripts/generic/multi-bleu.perl test.it < test.lines.txt.word
奖励:ASR 预培训
众所周知，在语音翻译文献中，用在 ASR 任务上训练的模型的权重来初始化我们的模型的编码器有利于最终的翻译质量和加速训练。这也很容易用我们的软件和数据复制。首先，使用相同的音频和文本的英语部分对数据进行预处理。音频片段和英文文本已经对齐，这意味着您可以对音频端使用完全相同的二进制数据，并处理文本以生成剩余的二进制数据。对于 ASR，您可能希望删除标点符号，只预测单词，以使任务更容易。标点符号可以用以下方式删除:
sed "s/[[:punct:]]//g" $file.tok > $file.depunct
按照上面列出的步骤在新目录models-asr中训练 ASR 系统。然后，一旦训练结束，跑步
$FBK-Fairseq-ST/strip_modules.py --model-path models-asr/checkpoint_best.pt --new-model-path models/pretrain_encoder.pt --strip-what decoder
该命令将创建一个新的检查点文件，其编码器与 models-asr/checkpoint_best.pt 相同，但没有解码器。最后，为了使用它来初始化新的解码器，只需像上面一样运行训练命令，但是用新的
cp models/pretrain_encoder.pt models/checkpoint_last.pt
默认情况下，训练脚本会检查检查点目录中是否存在名为 checkpoint_last.pt 的检查点，如果存在，它将用于初始化模型的权重。就这么简单！
结论
最近在直接语音到文本翻译方面的研究提供了软件和数据资源，可以很容易地用于启动您在这一领域的工作。希望这个教程对你“弄脏”手，熟悉工具有用。下一步就是研究如何改进现有的方法！
从几十次同行评审中获得的经验教训
towardsdatascience.com](/tips-for-reading-and-writing-an-ml-research-paper-a505863055cf)
参考
[1]瓦斯瓦尼等人，“你所需要的只是关注。”神经信息处理系统的进展。(2017)
【2】朴，DS。一种用于自动语音识别的简单数据扩充方法。继续。inter seech 2019(2019)
【3】Pham，NQ 等.IWS lt 2019 KIT 语音翻译系统。“芝诺多。(2019)
【4】迪甘吉，马。MuST-C:一个多语言语音翻译语料库。HLT-NAACL 2019(2019)
【5】迪甘吉，马。《让变压器适应端到端口语翻译》散客 2019 (2019)
特征选择入门
选择有用功能的初学者指南
你不会用你能做的俯卧撑的数量来决定巴士到达的时间吧？同样，在预测建模中，我们删除无用的特征，以降低最终模型的复杂性。简而言之，在开发预测模型时，特征选择减少了输入特征的数量。
在这篇文章中，我讨论了特性选择的三个主要类别；过滤方法、包装方法和嵌入方法。此外，我使用 Python 示例并利用一些框架，如用于机器学习的 scikit-learn(参见文档)、用于数据操作的 Pandas ( 文档)和用于交互式数据可视化的 Plotly ( 文档)。要访问本文中使用的代码，请访问下面共享的链接中的 my Github。
与中等博客文章相关的演示代码。-路径/到/文件；链接到文章有效的数据可视化…
github.com](https://github.com/kurtispykes/demo) 
图 1:Zui Hoang在 Unsplash 上拍摄的服装架照片
为什么要做特征选择？
第一段旨在传达的信息是，有时有些特征不能为预测最终结果提供足够有用的信息，因此通过将它包括在我们的模型中，我们正在使我们的模型变得不必要的复杂。丢弃无用的特征导致了简约的模型，这又导致了减少的评分时间。此外，特征选择也使得解释模型变得更加容易，这在所有的商业案例中都是非常普遍的。
“在大多数实际情况下，应用特征选择不太可能提供大的性能增益。但是，它仍然是功能工程师工具箱中的一个有价值的工具。”—(穆勒(Müller，(2016)，用 Python 介绍机器学习，奥瑞利传媒)
方法
有各种方法可用于执行特征选择，它们属于 3 个类别之一。每种方法都有自己的优缺点。Guyon 和 Elisseeff (2003 年)对这些类别描述如下:
- 过滤方法 -选择变量子集作为预处理步骤，独立于所选预测值。
- 包装器方法 -利用感兴趣的学习机作为黑盒，根据变量的预测能力对变量子集进行评分。
- 嵌入式方法——在训练过程中进行变量选择，通常针对给定的学习机。
过滤方法
图 2:由泰勒·尼克斯在 Unsplash 上过滤一张热饮照片
过滤方法使用单变量统计来评估每个输入要素与目标要素(目标变量/因变量)之间是否存在统计意义上的显著关系，这正是我们试图预测的。提供最高置信度的特征是我们为最终模型保留的特征，因此该方法独立于我们决定用于建模的选择模型。
“即使变量排序不是最佳的，它也可能比其他变量子集选择方法更可取，因为它的计算和统计可伸缩性。”——Guyon 和 Elisseeff (2003 年)
过滤方法的一个例子是皮尔逊相关系数——你可能在高中的统计课上遇到过。这是一种统计数据，用于测量输入 X 要素和输出 Y 要素之间的线性相关量。范围从+1 到-1，其中 1 表示完全正相关，而-1 表示完全负相关，因此 0 表示没有线性相关。
要计算皮尔逊相关系数，请将输入要素 X 和输出要素 y 的协方差除以两个要素标准差的乘积，公式如图 3 所示。
图 3:皮尔逊相关系数公式，其中 Cov 是协方差，σX 是 X 的标准差，σy 是 y 的标准差。
对于下面的代码示例，如前所述，我使用 Scikit-Learn 框架中可用的波士顿房价—参见文档 —以及用于数据操作的 Pandas 参见文档。
import pandas as pd
from sklearn.datasets import load_boston# load data
boston_bunch = load_boston()
df = pd.DataFrame(data= boston_bunch.data,
columns= boston_bunch.feature_names)# adding the target variable
df["target"] = boston_bunch.target
df.head()
图 4:上述代码单元的输出；显示波士顿房价数据集的预览。
python 中实现的要素选择的 pearson 相关系数示例。
# Pearson correlation coefficient
corr = df.corr()["target"].sort_values(ascending=False)[1:]# absolute for positive values
abs_corr = abs(corr)# random threshold for features to keep
relevant_features = abs_corr[abs_corr>0.4]
relevant_features>>> RM 0.695360
NOX 0.427321
TAX 0.468536
INDUS 0.483725
PTRATIO 0.507787
LSTAT 0.737663
Name: target, dtype: float64
然后简单地选择如下输入特征…
new_df = df[relevant_features.index]
优点
- 抗过拟合能力强(引入偏差)
- 比包装方法快得多
缺点
- 不考虑其他功能之间的相互作用
- 不考虑正在使用的模型
包装方法
图 4:包装一个盒子；照片由 Kira auf der Heide 在 Unsplash 上拍摄
维基百科将包装器方法描述为使用“预测模型对特征子集进行评分”。每一个新的子集都用来训练一个模型，该模型在一个保留集上进行测试。计算在坚持的集合上犯的错误的数量(模型的错误率)给出了该子集的分数。— 包装器方法维基百科。包装器方法所采用的算法被称为贪婪算法，因为它试图找到产生最佳性能模型的最佳特征组合。
“包装器特征选择方法创建具有输入特征的各种不同子集的许多模型，并根据一些性能度量来选择导致最佳性能模型的那些特征。”—杰森·布朗利
一种包装方法是递归特征消除(RFE ),正如该算法的名称所示，它的工作方式是递归地移除特征，然后使用剩余的特征建立一个模型，然后计算模型的精度。
from sklearn.feature_selection import RFE
from sklearn.linear_model import LinearRegression# input and output features
X = df.drop("target", axis= 1)
y = df["target"]# defining model to build
lin_reg = LinearRegression()# create the RFE model and select 6 attributes
rfe = RFE(lin_reg, 6)
rfe.fit(X, y)# summarize the selection of the attributes
print(f"Number of selected features: {rfe.n_features_}\n\
Mask: {rfe.support_}\n\
Selected Features:", [feature for feature, rank in zip(X.columns.values, rfe.ranking_) if rank==1],"\n\
Estimator : {rfe.estimator_}")
下面的打印语句返回…
Number of selected features: 6Mask: [False False False True True True False True False False True False True]Selected Features: ['CHAS', 'NOX', 'RM', 'DIS', 'PTRATIO', 'LSTAT'] Estimator : {rfe.estimator_}
优点
- 能够检测特征之间发生的相互作用
- 通常比过滤方法产生更好的预测准确性
- 查找最佳特征子集
缺点
- 计算成本高
- 倾向于过度拟合
嵌入方法
图 5:嵌入式组件；克里斯·里德在 Unsplash 上拍摄的照片
嵌入式方法类似于包装器方法，因为这种方法也优化预测模型的目标函数，但是将这两种方法分开的是，在嵌入式方法中，在学习建立模型期间使用了内在的度量。因此，嵌入式方法需要有监督的学习模型，该模型反过来将内在地确定每个特征对于预测目标特征的重要性。
注意:用于特征选择的模型不一定是用作最终模型的模型。
LASSO ( 最小绝对收缩和选择操作符)是嵌入方法的一个很好的例子。维基百科将 LASSO 描述为“一种回归分析方法，它执行变量选择和正则化，以提高其产生的统计模型的预测准确性和可解释性。”深入了解 Lasso 如何工作超出了本文的范围，但是可以在 Analytics Vidhya 博客上找到一篇关于该算法的好文章，作者是 Aarshay Jain ，标题是关于 Python 中脊和 LASSO 回归的完整教程。
# train model
lasso = Lasso()
lasso.fit(X, y)# perform feature selection
kept_cols = [feature for feature, weight in zip(X.columns.values, lasso.coef_) if weight != 0]kept_cols
这将返回 Lasso 回归模型认为相关的列…
['CRIM', 'ZN', 'RM', 'AGE', 'DIS', 'RAD', 'TAX', 'PTRATIO', 'B', 'LSTAT']
我们也可以使用瀑布图来显示系数…
figt = go.Figure(
go.Waterfall(name= "Lasso Coefficients",
orientation= "h",
y = X.columns.values,
x = lasso.coef_))fig.update_layout(title = "Coefficients of Lasso Regression Model")fig.show()
图 6:先前代码的输出；显示各功能系数的瀑布图；请注意，3 个特征被设置为 0，这意味着它们被模型忽略。
优点
- 计算速度比包装方法快得多
- 比过滤方法更准确
- 一次考虑所有功能
- 不容易过度合身
缺点缺点缺点
- 选择特定于模型的特征
- 不如包装方法强大
提示:没有最佳特征选择方法。适用于一个业务用例的方法可能不适用于另一个业务用例，因此您需要进行实验，看看什么方法最有效。
结论
在本文中，我介绍了执行特性选择的不同方法。当然，还有其他方法可以进行特征选择，如方差分析、反向特征消除和使用决策树。要获得一篇了解这些方法的好文章，我建议阅读 Madeline McCombe 的文章，标题为 介绍数据科学的特征选择方法 。
又及:非常感谢您抽出时间。对于那些想深入了解特性选择的人，下面有一些有用的资源！
与中等博客文章相关的演示代码。-路径/到/文件；链接到文章有效的数据可视化…
github.com](https://github.com/kurtispykes/demo)
其他资源
Jason Brownlee - 如何选择机器学习的特征选择方法
vikashraj luhaniwal-使用 Python 中的包装方法进行特征选择
Sebastian Raschka - 用于特征选择的过滤器、包装器和嵌入式方法之间有什么区别
使用 PyTorch 开始使用 GANs
机器学习
我们将看到 GAN 生成新图像的能力，乍一看，这使 GAN 看起来有点“神奇”。
介绍
生成对抗网络(GAN)是 Ian Goodfellow 和他的同事在 2014 年构想的一类机器学习框架。两个神经网络(生成器和鉴别器)像在游戏中一样相互竞争。这种技术学习在给定训练集的情况下，使用与训练集相同的统计信息来生成新数据。
生成的图像
在这篇博文中，我们将训练一个 GAN 来生成猫的面部图像。我们将使用由超过 15700 张猫图片组成的猫脸数据集。由于生成建模是一种无监督的学习方法，因此图像上没有标签。
来自数据集的真实图像
首先，获取所有需要的库，
由于我们在 Kaggle 上运行这个笔记本，我们可以使用边栏中的“+添加数据”选项，搜索猫脸数据集。这将把数据下载到../输入。
将数据集的路径保存在 DATA_DIR 中。
该数据集有一个名为 cats 的文件夹，其中包含超过 15，700 张 JPG 格式的图像。
现在使用 torchvision 中的 ImageFolder 类加载这个数据集。我们还将调整图像的大小并将其裁剪为 64x64 px，并使用 0.5 的平均值和标准偏差对像素值进行标准化。这将确保像素值在范围(-1，1)内，这对于鉴别器训练更方便。此外，我们将创建一个数据加载器，用于将数据加载到批处理中。
生成对抗网络
现在让我们建立鉴别器和生成器神经网络，生成器将生成图像，鉴别器将检测给定图像是真是假。他们都将相互竞争，并且都将在工作中做得更好。
照片由 machinelearningmastery 拍摄
发电机
生成器的输入是一个向量或随机数矩阵，用作图像生成的种子。该生成器可以将形状张量(128，1，1)转换成(3×28×28)形状张量图像。
鉴别器
鉴别器将图像作为其输入，并试图将其分类为“真实的”或“生成的”。这会将输入作为(3 x 64 x 64)张量，并将其转换为(1，1，1)张量。
下面是保存每个时期后生成的每个图像的功能。
培养
下一步是为鉴别器和生成器构建一个训练函数。该函数将用于训练两个神经网络。
这是鉴别器的训练功能。
这是发电机的训练功能。
现在我们将构建一个训练函数来训练鉴别器和生成器。
现在我们准备训练模型，我们取 lr = 0.0002，纪元数= 60。
结果
在训练模型 60 个时期后，我们可以看到生成的图像。
生成的图像
正如我们所见，从模型中生成的图像与真实图像相似。
你可以在我的 Jovian 个人资料中找到完整的代码:
https://jovian.ml/shubham7169007/cat-dcgan
Github 链接:
https://github . com/Shu bham 7169/Projects/blob/master/CAT-dcgan . ipynb
高斯过程回归建模入门
高斯过程回归理论和使用 scikit-learn GPR 软件包进行回归的快速指南
高斯处理(GP)是一种非常有用的技术，它支持非参数贝叶斯建模方法。它在回归、分类、优化等领域具有广泛的适用性。本文的目标是介绍 GP 的理论方面，并在回归问题中提供一个简单的例子。
多元高斯分布
我们首先需要复习多元高斯分布，它是 GP 的基础。多元高斯分布可以完全由其均值向量和协方差矩阵来定义
高斯分布有两个重要的性质，使得后来的 GP 计算成为可能:边缘化和条件化。
边缘化
对于联合高斯分布，这可以写成:
我们可以通过边缘化来检索多元分布的子集。例如，我们可以将随机变量 Y 边缘化，得到的 X 随机变量表示如下:
注意，边缘化分布也是高斯分布。
调理
另一个重要的操作是条件作用，它描述了一个随机变量在另一个随机变量存在的情况下的概率。这种操作使得贝叶斯推理成为可能，正如我们将在后面展示的，在给定观察数据的情况下推导出预测。
通过条件反射，你可以推导出，例如，
像边缘化一样，条件分布也是高斯分布。这允许结果以封闭的形式表达，并且易于处理。
高斯过程
我们可以在多元高斯分布和高斯过程之间画出平行线。高斯过程(GP)完全由其均值函数和协方差函数(aka 核)定义，
GP 可以认为是一个无限维的多元高斯。这实际上就是我们所说的 GP 是非参数化的——因为参数的数量是无限的。均值函数 m(x) 描述了任何给定数据点 x 的均值，而核函数 k(x，x’)描述了任何给定的两个数据点 x1 和 x2 之间的关系。
因此，GP 描述了在可能的函数上的分布。所以当你从一个 GP 采样时，你得到一个单一的函数。相比之下，当您从高斯分布中采样时，您会得到单个数据点。
高斯过程回归
我们可以把上述关于边缘化和条件作用以及 GP 的概念集合起来进行回归。在传统的回归模型中，我们推断出一个单一的函数，Y= f(X)。在高斯过程回归(GPR)中，我们在f(X)上放置一个高斯过程。当我们没有任何训练数据，只定义内核时，我们实际上是在定义一个先验分布的f(X)。下面我们就用符号 f 来表示f(X)。通常我们假设平均值为零，所以这意味着，
选择的内核 K (如周期、线性、径向基函数)描述了函数的一般形状。同样，当您选择一阶或二阶方程时，您会期望不同的函数形状，例如线性函数或抛物线函数。
当我们已经观察到数据(例如训练数据、 X )和我们想要估计的数据点(例如测试数据、 X* )时，我们再次将高斯先验放置在 f (对于f(X)和
这里的目的是我们想知道什么是 f 对于某组 x 值( X* )给定我们已经观测到的数据( X 及其对应的 f )。这是有效的条件作用，换句话说就是要求推导函数值的后验概率，p(f ****||f*， X ， X )。这也是我们如何进行预测——根据观察数据和测试数据点计算后验概率。
添加噪声
上述函数是无噪声的，这意味着我们对观察到的数据点有十足的信心。在现实世界中，情况并非如此，我们预计在我们的观察中会有一些噪声。在传统的回归模型中，这可以建模为:
其中ε~N(0， σ I )。 ε 是噪声项，服从高斯分布。在 GPR 中，我们将高斯先验放置到f(X)上，就像之前一样，所以f(X)~ GP(0，K)对于观察到的数据，联合概率与之前非常相似，除了现在在观察到的数据中添加了噪声项，
同样的，我们可以通过计算 f 、 X 、 X* 的后验条件来进行推断。*
GPR 使用 scikit-learn
有多个软件包可用于高斯过程建模(有些是更通用的贝叶斯建模软件包):GPy、GPflow、GPyTorch、PyStan、PyMC3、tensorflow probability 和 scikit-learn。为了简单起见，我们将在这里展示一个在样本数据集上使用 scikit-learn 包的例子。
我们将使用 scikit-learn 中的波士顿数据集示例。首先，我们将加载数据，并对数据进行简单的 80/20 分割，分成训练集和测试集。
我们将使用GaussianProcessRegressor包并定义一个内核。这里我们将尝试一个带噪声和偏移的径向基函数核。内核的超参数是建议值，这些参数将在拟合过程中进行优化。
可以用model.kernel_查看试衣模特。我们现在还可以绘制和查看我们的预测与实际，
请注意，您可以使用其他机器学习模型(如随机森林回归器等)获得类似的性能。然而，GPR 的主要好处是，对于每个给定的测试数据点，预测值自然会有置信区间。所以你不仅知道你的模型性能，而且你知道与每个预测相关的不确定性是什么。
这是 GP 和 GPR 的高级概述。我们不会在这里深入内核的细节。但是通过采用不同的内核，您可以将您之前对数据的假设整合到您的模型中。通过 scikit-learn 的简单示例，我们希望提供一些灵感，让您了解 GPR 是如何有用的，并且您可以快速开始将某种形式的贝叶斯建模作为您的机器学习工具箱的一部分！
关于 GP 的其他一些有用的资源/帖子
即使你花了一些时间阅读关于机器学习的书籍，你也很可能从未听说过高斯…
蒸馏. pub](https://distill.pub/2019/visual-exploration-gaussian-processes/) [## nbviewer 笔记本
看看这个 Jupyter 笔记本！
nbviewer.jupyter.org](https://nbviewer.jupyter.org/github/adamian/adamian.github.io/blob/master/talks/Brown2016.ipynb)*
R 中的生成艺术入门
数据不仅可以有用，还可以漂亮。这篇文章为那些想探索 r 中的生成艺术的人指出了一些起点。
国立博物馆。照片由维特·加布雷拍摄
介绍
生成艺术代表了一个独立于人类的系统(如算法)在创作过程中的参与。这种系统是创作过程中的一个关键要素，包括其产出。
不出所料，如果你想深入研究生成艺术，有许多“工具”可以使用。如果你想在 R 中拥有【实践】经验，有两个基本方向可以选择。
如果你是一个精通代码的人，你可以直接写你的代码。我敢说这是“个人”表达的方式，因为它允许更多的灵活性，嗯，自由。
然而，达到这一点需要时间。幸运的是，您可以通过使用一个现有的包来开始试验您的艺术作品。这不仅会让你受益匪浅，而且对于掌握“交易”的基础知识也非常有用。
在这篇文章中，我将向您展示一些用于制作生成艺术的“即用型”包。此外，我还将利用一些使用通用包或库来达到相同目标的例子。
生成艺术
我想展示的第一个包叫做generativeart。
它的一个关键特性是它构造输出文件的方式。为了获得输出文件，您必须指定它们的存储位置。此外，它还迭代所提供的不需要种子支持的公式。在这种情况下，每个结果文件都是唯一的。
此外，值得一提的是，generativeart包是很好的文档和易于使用。
**library**(generativeart) *# devtools::install_github("cutterkom/generativeart")*
**library**(ambient)
**library**(dplyr)*# set the paths*
IMG_DIR <- "img/"
IMG_SUBDIR <- "everything/"
IMG_SUBDIR2 <- "handpicked/"
IMG_PATH <- **paste0**(IMG_DIR,
IMG_SUBDIR)LOGFILE_DIR <- "logfile/"
LOGFILE <- "logfile.csv"
LOGFILE_PATH <- **paste0**(LOGFILE_DIR,
LOGFILE)*# create the directory structure*
generativeart::**setup_directories**(IMG_DIR,
IMG_SUBDIR,
IMG_SUBDIR2,
LOGFILE_DIR)
*# include a specific formula, for example:*
my_formula <- **list**(
x = **quote**(**runif**(1, -1, 10) * x_i^2 - **sin**(y_i^2)),
y = **quote**(**runif**(1, -1, 10) * y_i^3 - **cos**(x_i^2) * y_i^4)
)*# call the main function to create five images with a polar coordinate system*
generativeart::**generate_img**(formula = my_formula,
nr_of_img = 5, *# set the number of iterations*
polar = TRUE,
filetype = "png",
color = "#c1a06e",
background_color = "#1a3657")
茉莉
丹妮尔·纳瓦罗(Danielle Navarro)是《学习统计与 R 学习统计与 R 手册》的作者，是心理学学生中的知名人士。
除了她在阿德莱德大学的教学和研究活动，她还发布了 jasmines 包，这是一个允许在 r。
这个软件包给你一个机会来玩模拟参数(如grain或interaction)、形状(如entity_circle或scene_discs)及其修改(如style_ribbon)或颜色(palette或alpha)。和噪声，链接到环境库:
**library**(dplyr) *# or install.packages("dplyr") first*
**library**(jasmines) *# or devtools::install_github("djnavarro/jasmines")*p0 <- **use_seed**(100) %>% *# Set the seed of R‘s random number generator, which is useful for creating simulations or random objects that can be reproduced.*
**scene_discs**(
rings = 10,
points = 50000,
size = 50
) %>%
**mutate**(ind = 1:**n**()) %>%
**unfold_warp**(
iterations = 10,
scale = .5,
output = "layer"
) %>%
**unfold_tempest**(
iterations = 5,
scale = .01
) %>%
**style_ribbon**(
color = "#E0542E",
colour = "ind",
alpha = **c**(1,1),
background = "#4D7186"
)**ggsave**("p0.png", p0, width = 20, height = 20, units = "in")
作者图片
mathart + ggart
mathart包把很多常用的算法包装成函数。一个这样的例子是最近邻图，一个 k-d 树的可视化，一个多维空间的数据结构化程序:
**library**(mathart) *# devtools::install_github("marcusvolz/mathart")*
**library**(ggart) *# devtools::install_github("marcusvolz/ggart")*
**library**(ggforce)
**library**(Rcpp)
**library**(tidyverse)points <- mathart::pointsresult <- **kdtree**(points)
p1 <- **ggplot**() +
**geom_segment**(**aes**(x, y, xend = xend, yend = yend), result) +
**coord_equal**() +
**xlim**(0, 10000) + **ylim**(0, 10000) +
**theme_blankcanvas**(bg_col = "#fafafa", margin_cm = 0)*# save plot*
**ggsave**("kdtree.png", p1, width = 20, height = 20, units = "in")
作者图片
mathart是一个有据可查的包。这个事实扩大了实验的范围。也许更重要的是，通过查看【引擎盖下】，该软件包提高了对数据模拟的理解。
通用软件包
在许多情况下，前面提到的包建立在更常用的包上，如magritr(管道操作符甚至在艺术创作中也很方便)ggplot、dplyr或purr。
来自mathart包的 k-d 树没有什么不同。从马库斯·沃尔茨的例子中我们可以看到，最初的 k-d 树算法可以使用偶数基数 R 进行调整:
*# Metropolis: Generative city visualisations**# Packages*
**library**(ggart)
**library**(tidyverse)
**library**(tweenr)
**library**(viridis)*# Make reproducible*
**set.seed**(10001)*# Parameters*
n <- 10000 *# iterations*
r <- 75 *# neighbourhood*
width <- 10000 *# canvas width*
height <- 10000 *# canvas height*
delta <- 2 * pi / 180 *# angle direction noise*
p_branch <- 0.1 *# probability of branching*
initial_pts <- 3 *# number of initial points*
nframes <- 500 *# number of tweenr frames**# Initialise data frames*
points <- **data.frame**(x = **numeric**(n), y = **numeric**(n), dir = **numeric**(n), level = **integer**(n))
edges <- **data.frame**(x = **numeric**(n), y = **numeric**(n), xend = **numeric**(n), yend = **numeric**(n), level = **integer**(n))**if**(initial_pts > 1) {
i <- 2
**while**(i <= initial_pts) {
points[i, ] <- **c**(**runif**(1, 0, width), **runif**(1, 0, height), **runif**(1, -2*pi, 2*pi), 1)
i <- i + 1
}
}t0 <- **Sys.time**()*# Main loop ----*
i <- initial_pts + 1
**while** (i <= n) {
valid <- FALSE
**while** (!valid) {
random_point <- **sample_n**(points[**seq**(1:(i-1)), ], 1) *# Pick a point at random*
branch <- **ifelse**(**runif**(1, 0, 1) <= p_branch, TRUE, FALSE)
alpha <- random_point$dir[1] + **runif**(1, -(delta), delta) + (branch * (**ifelse**(**runif**(1, 0, 1) < 0.5, -1, 1) * pi/2))
v <- **c**(**cos**(alpha), **sin**(alpha)) * r * (1 + 1 / **ifelse**(branch, random_point$level[1]+1, random_point$level[1])) *# Create directional vector*
xj <- random_point$x[1] + v[1]
yj <- random_point$y[1] + v[2]
lvl <- random_point$level[1]
lvl_new <- **ifelse**(branch, lvl+1, lvl)
**if**(xj < 0 | xj > width | yj < 0 | yj > height) {
**next**
}
points_dist <- points %>% **mutate**(d = **sqrt**((xj - x)^2 + (yj - y)^2))
**if** (**min**(points_dist$d) >= 1 * r) {
points[i, ] <- **c**(xj, yj, alpha, lvl_new)
edges[i, ] <- **c**(xj, yj, random_point$x[1], random_point$y[1], lvl_new)
*# Add a building if possible*
buiding <- 1
valid <- TRUE
}
}
i <- i + 1
**print**(i)
}
edges <- edges %>% **filter**(level > 0)sand <- **data.frame**(alpha = **numeric**(0), x = **numeric**(0), y = **numeric**(0))
perp <- **data.frame**(x = **numeric**(0), y = **numeric**(0), xend = **numeric**(0), yend = **numeric**(0))*# Create plot*
p2 <- **ggplot**() +
**geom_segment**(**aes**(x, y, xend = xend, yend = yend, size = -level), edges, lineend = "round") +
*#geom_segment(aes(x, y, xend = xend, yend = yend), perp, lineend = "round", alpha = 0.15) +*
*#geom_point(aes(x, y), points) +*
*#geom_point(aes(x, y), sand, size = 0.05, alpha = 0.05, colour = "black") +*
**xlim**(0, 10000) +
**ylim**(0, 10000) +
**coord_equal**() +
**scale_size_continuous**(range = **c**(0.5, 0.5)) +
*#scale_color_viridis() +*
**theme_blankcanvas**(bg_col = "#fafafa", margin_cm = 0)*# print plot*
**ggsave**("plot007w.png", p2, width = 20, height = 20, units = "cm", dpi = 300)
作者图片
你不需要在这里停下来。花一些时间玩代码可以很容易地通过创建你独特的海报结束。
结束语
生成艺术证明代码可以是美丽的。如果你还是不被说服，那就去看看更多类似这些的精心制作的作品。
生成艺术不仅能产生惊人的东西，还能帮助你理解代码本身。有趣的是，获取生成艺术背后的代码可能不像其他开源领域那么容易。一些的“生成艺术家”得出结论，不分享创作过程中使用的代码:
“我不分享我用来创作作品的代码。这样做的主要原因是，我认为这对任何人都没有好处。对生成艺术感兴趣的人会开始关注我的想法，而不是发展他们自己的想法。知道答案是创造力的杀手。”
托马斯·林·彼得森，数据想象师
不管我们是否同意，生成艺术让我们面对在编码领域并不常见的想法。
那么，你对这件事有什么想法？你有最喜欢的生殖艺术家吗？或者你想分享你的艺术作品？欢迎在 推特 上讨论这个问题。
最初发表于https://www.data-must-flow.com。
入门:地理空间库
Python 中最有价值的库精选
照片由 Ylanite Koppen s 在 P exels 上拍摄
ython 是一种简单的编程语言，你不需要有大量的软件开发来编写你的第一行代码。另外，如果安装了所需的模块，您在一台机器上编写的 Python 脚本可以在任何其他机器上运行。有大量针对地理空间和地理处理的可用库和软件包，这允许用户花更多的时间开发真正的软件，这将有助于实现他们的目标。
什么是地理处理？
在于使用数学和计算处理来获得和分析空间数据。在地理处理中，数据需要进行地理配准，这意味着日期需要作为地址坐标进行实际定位。
当你意识到一个正式的处方集时，例如当你给出你的名字或电话号码时，对于地理处理来说，是不足以开始分析这种数据的。但是当你把你的地址给这个表单时，我们可以分析它，例如，当你想知道有多少用户住在这个州的北部。
用于地理空间开发的 Python 库
在本文中，我们将了解一些开源库，这些库提供地理处理和地理空间开发方面的支持和协作。确保你将正确的库用于正确的目的，以及它们中的哪一个适合你的项目。
形状美观的
笛卡尔平面中几何对象的操作和分析。
作者制作的图像
与 AutoCAD 一样，该库与 PostGIS 通信良好，其主要目的是操作几何图形。想象一下，你可以操纵你的数据来准确地告诉你如何从点“A”到点“B”，甚至发现你的家、城市或州的周长。
Shapely 使用计算几何非常简单地提供了这些和许多其他可能性。
菲奥纳
OGR 为 Python 程序员提供的简洁敏捷的 API。
作者制作的图像
Fiona 被做得很简单，它的主要功能是读/写文件，以及 Pyshp 库，除此之外你还可以操作几何属性，所有这些都以非常类似于 python 中使用字典、映射和迭代器的方式完成。
PyProj
PROJ 的 Python 接口(制图投影和坐标转换库)。
作者制作的图像
当我们在不同的投影中处理几何图形时，例如 UTM、WGS84 和许多其他投影。例如，PyProj 提供了一种将我们的投影从 UTM 转换到 WGS64 的方法，这样我们的信息将始终在我们指定的投影中，并且将始终正确地放置在地球上。
皮萨尔
一个空间分析库，侧重于用 Python 编写的地理空间矢量数据。
派萨尔(来源
PySAL 是一个用于空间分析的地理空间计算库。除此之外，它还集合了许多其他库，如 matplotlib、geopandas、rasterio，它变成了一个完整的资源。
Numpy
用 Python 实现科学计算的软件包。
Numpy ( 来源)
地理处理就是数学。Numpy 是一个非凡的库来处理这个问题，当处理地理空间数据时，你会做许多求和、除法之类的事情，这让你的生活变得更加轻松。在地理处理环境中，Numpy 的关键是支持大型矩阵和数学函数。
GDAL / OGR
光栅和矢量地理空间数据格式的翻译库。
GDAL ( 来源)
GDAL 为我们的几何对象带来了一种标准化的方法。反过来，GDAL 处理栅格数据，OGR 处理矢量数据。GDAL 除了其极高的处理速度(这是由它在 C 中的执行来保证的)之外，它还以处理大多数类型的空间数据格式而闻名。
熊猫/地质公园
对熊猫对象的地理数据支持。
熊猫(来源)
Pandas 是一个数据分析库，它以类似电子表格的方式组织你的数据，以供进一步计算。由于我们的地理空间数据来自广泛的来源和格式，如 CSV，pandas 可以帮助我们轻松处理这些数据。反过来， GeoPandas 不是将数据制成表格，而是添加了一个支持地理世界的组件。在幕后，Geopandas 使用 Shapely 和 Fiona。
Mapnik
支持地图可视化并为网络创建地图。
Mapnik ( 来源
Mapnik 的创建只有一个目的，那就是创造美丽的地图。除了这种令人难以置信的意识形态，它还为我们提供了几种可能性，以补充我们的地图标记，标签，颜色。
地质炼金术
SQLAlchemy 的空间扩展
GeoAlchmey ( 来源)
GeoAlchemy 是 SQLAlchemy 的扩展，是为 PostGIS 创建的，在 PostGIS 中需要在关系数据库中存储几何图形。除了支持几何图形，它还执行一些空间操作。
地质公园
轻松查找 lat/long 库。
地质公园(来源)
这个库提供了查找地址、城市的支持，所以你可以很容易地找到你所在城市的经度和纬度。
结论
地理空间开发在我们的生活中非常重要，因为在足球比赛结束时，由于地理空间数据和地理处理，我们可以知道球员在比赛中跑了多少英里。每天都有地理处理技术在发展，新的库在创建，新的 GIS 在创建，这是真实存在的。好在这些库可以极大的方便我们的开发，相比 10 年前。在未来，使用地理处理将会非常美妙，而创造这一未来的基础就是这些库。
giotto-tda 入门
用于拓扑机器学习的 Python 库
作者: 路易斯·汤斯顿 、科林·卡林、 弗朗切斯科·帕尔马 和 托马斯·博伊斯
简介
在 L2F ，我们围绕 giotto-tda 和拓扑机器学习最常见的问题之一是“我从哪里开始？”。
在本指南中，我们介绍了基本概念和工作流程的概述，以便您可以开始在您的机器学习管道中使用 giotto-tda。重现分析的代码可从 GitHub 获得。
什么是拓扑机器学习？
拓扑机器学习是指一套将代数拓扑中的元素与统计学习相结合的技术。通过关注形状和连接性等数据的全局属性，这些拓扑方法可以捕捉传统机器学习方法可能遗漏的模式。
例如，拓扑机器学习在药物设计和图形分类中产生了最先进的结果，并在蛋白质结合中产生了新颖的见解。
这些技术背后的主要成分被称为持久同源性。持续同源度量拓扑不变量的存在，如跨不同长度尺度的连通分量、洞和空隙。这些不变量的“出生”和“死亡”通过持久性图进行总结，这是生成新类型特征以提供给下游机器学习任务的最常见和最直观的方式。关于这些概念的精彩概述，请参见加里·科普利克的文章或马修·赖特的视频。
通过用半径递增的圆连接相邻点(左)来产生和消灭一个洞。还显示了相应的持久性图(右图)。信用:https://bit.ly/2raKb11
总而言之，拓扑机器学习的关键步骤是:
- 使用持久同源性从输入数据中提取拓扑特征。
- 使用监督或无监督的方法，将这些特征与机器学习方法相结合。
giotto-tda 库旨在简化这些步骤，并使拓扑机器学习可用于更广泛的数据科学社区。它基于 scikit-learn 的 fit-transform 范例，并提供了与流行框架的紧密集成。giotto-tda 入门就像跑步一样简单:
pip install giotto-tda
预测分子性质
为了展示 giotto-tda 的作用，我们将使用 Kaggle 上 预测分子性质 竞赛的 CHAMPS 数据集。这里的任务是预测一个分子中两个原子之间的磁相互作用或“标量耦合常数”。因为这些耦合采用连续值，所以学习任务是一个回归任务。
对于给定的分子，学习任务是预测每个原子对之间的耦合强度。
探索数据
训练数据由分子中的原子对组成，每对由标量耦合的类型和每个原子的 (x，y，z) 坐标表征。为了简化分析，我们将把注意力集中在 100 个最大的分子上，也就是那些原子数量最多的分子。如下图所示，这些分子有五种不同的耦合，其强度因耦合类型而异。
数据中 100 个最大分子的每种偶联类型的偶联强度。
从数据到持久性图
我们的拓扑机器学习管道的第一步是从训练数据构建持久性图。
在 giotto-tda 中，有两种主要方法可以实现这一点:
-
将数据表示为一个 点云 : 将每个观察值视为空间中的一个点，以及一个度量来计算成对观察值之间的距离。在我们的上下文中，单个分子的点云可以简单地是每个原子相对于所有原子的平均值 (x̅，y̅，z̅) 的 (x，y，z) 坐标。在下面的代码片段中，
homology_dimensions指定了要跟踪的拓扑不变量的类型(“0”表示连接的组件，“1”表示孔，“2”表示空隙)，而euclidean定义了我们希望在持久同源性计算中应用的度量。 -
将数据表示为一个 距离矩阵 : 计算每个观察值之间的成对距离，其中“距离”不一定必须是度量。如果我们把单个分子看作一个图形，两个原子之间的距离可以是连接它们的最短路径的边数。在下面的代码片段中，我们只需要指定我们的度量是
precomputed，并确保输入是一个距离矩阵。
对于每个输入点云或距离矩阵，我们得到一个单一的持久性图。在训练数据中，每个观察值是一个原子对，因此，当这些原子对被分组以形成 100 个分子时，我们获得 100 个点云，从而获得 100 个持久性图。
持久性图中离对角线死亡=出生线最远的点对应于最持久的拓扑特征。
**
单个分子的点云(左)及其相应的持久性图(右)。连接的组件(H0)显示为红色，孔(H1)显示为青色，空白(H2)显示为紫色。
从持久性图到机器学习功能
虽然持久性图是数据的有用描述符，但它们不能直接用于机器学习应用。这是因为不同的持久性图可能有不同数量的点，并且像图的加法和乘法这样的基本操作没有很好地定义。
为了克服这些限制，已经提出了各种建议，通过非常适合机器学习的嵌入或内核来“矢量化”持久性图。在 giotto-tda 中，我们通过gtda.diagrams模块提供对最常见矢量的访问。
例如，计算持久性图的“振幅”可以通过选择一个metric来实现，如下面的代码片段所示。
或者，您可以创建自己的自定义拓扑特征！因为 giotto-tda 中的持久性图是出生-死亡维度三元组的数组，所以用 NumPy 或 Pandas 操作它们是很简单的。例如，下面的代码片段显示了我们如何计算每个homology_dimension点的平均寿命。
在我们对 CHAMPS 数据集的全面分析中，我们提取了各种各样的拓扑特征——详见随附的代码。
训练模特
有了拓扑特征，下一步是训练回归变量。在 scikit-learn 约定中，这相当于将所有相关特性和目标变量组合成数组X和y。对于本指南，我们采用 this Kaggle 提交中采用的方法，并使用xgboostrgressor进行预测。为了评估特征对性能的影响，我们比较了用 5 重交叉验证训练的模型的结果，包括有和没有拓扑特征。这一步的代码片段是标准的，复制如下。
给预测打分
最后一步是对我们模型的预测进行评分。比赛的衡量标准是平均绝对误差的对数的平均值(是的，这有点复杂——就把它想象成多个分数，每个分数对应一种债券类型。对于每种类型，计算平均绝对误差，取这些结果的对数，最后计算所有焊接类型的平均值):
这里:
- T 是标量耦合类型的数量(在我们的例子中是五个)
- nⱼ是类型 j 的观测值的数量
- yᵢ是观测的标量耦合常数
- ŷᵢ是预测的标量耦合常数
由于对数，我们可以得到负值，因此分数为-0.5 比-0.3 好。
下图显示了每种耦合类型的得分，并将包含拓扑特征的模型与不包含拓扑特征的模型进行了比较。
我们可以清楚地看到，拓扑特征帮助分数提高了 5.5%，平均提高了 3.6%。在 Kaggle 比赛中，这些小的改进可以在最终的排行榜上产生很大的差异，并提供了拓扑如何为传统的特征提取方法提供补充信息的良好演示。
展望和下一步措施
本指南只是触及了 giotto-tda 的皮毛。除了像我们的回归示例这样的核心机器学习任务之外，该库目前还支持对图形和时间序列数据应用持久同源性。
例如，giotto-tda 已经被用来检测股票市场崩盘，研究甲虫种群的种群动态，或者预测一种分子是否抑制艾滋病毒的传播。
如果您对如何使用 giotto-tda 有任何疑问，请随时联系我们。
如果你想了解更多关于拓扑机器学习的知识，请参考下面的链接。
2020 年 1 月 23 日更新:Giotto-learn 库已更名为 giotto-tda！虽然新名称旨在更好地传达该库对拓扑机器学习的关注，但与 scikit-learn 无缝集成的承诺仍将是该项目的一个重要特征。
链接
giotto-time 入门
开始使用 giotto-time 进行预测的教程，Giotto-time 是用于时间序列分析中的机器学习建模的 Python 库
由弗朗切斯科·帕尔马、科林·卡林和路易斯·汤斯顿撰写
在许多商业和研究领域，生成准确的时间序列预测是必不可少的。在 L2F，我们发现用 Python 和 PyData 堆栈生成这些预测的工具有限。虽然像 statsmodels 和脸书的 Prophet 这样的流行库对于某些应用程序来说工作得很好，但它需要一个灵活的框架，允许组合数十个，甚至数百个模型并堆叠数千个功能。
为此，我们用 Python 库 giotto-time 开源了我们的时间序列工具。该库是为大规模机器学习应用程序设计的，在这些应用程序中，创建自定义模型非常重要。giotto-time 还提供了一个简单的 API 来自动化特性选择、执行因果关系测试和生成新特性。
在这篇博文中，我们展示了 Python 时间序列库 giotto-time 的一些功能。随附的笔记本可在这里找到。
数据和问题
电在当今社会至关重要。然而，它很难储存，而且价格昂贵。随着可再生能源在能源市场中的重要性日益增加，这一点尤其如此，这使得预测能源需求成为能源供应商的重要任务。
为了展示 giotto-time 中可用的功能，我们将重点关注提前 21 天预测瑞士能源需求的问题。
数据是从瑞士能源传输网运营商 Swissgrid 下载的，可以在这里找到。该图显示了 2016 年至 2019 年的日均能源需求。
时间序列库 giotto-time
giotto-time 入门就像跑步一样简单:
pip install giotto-time
在以下章节中，我们将介绍 giotto-time 的四个最重要的特性，这些特性也被用于能源需求建模:
- 去趋势和季节性
- 因果关系测试
- 特征创建
- 预测
该库旨在充分利用熊猫强大的时间序列和日期功能。特别是，giotto-time 中的中心对象是一个 pandas 数据帧，每个特性的时间戳和列都有一个DateTimeIndex。
该库的另一个重要方面是与 scikit-learn 的紧密集成。这使得能够一致地使用流行的机器学习框架的fit、predict和transform范例。
1)去趋势化和季节性
giotto-time 管道的第一步是对时间序列中的潜在趋势和季节性进行建模。giotto-time 中的Detrender可以通过选择多项式或指数模型来实现这一点。然后简单地在时间序列上调用fit_transform将会移除趋势，如下面的代码片段所示。
如何用 giotto-time 去除趋势
为了对季节性进行编码，例如夏季和冬季或每周的季节性，可以拟合一个具有适当相移的正弦波，如下例所示。
这可以通过以下方式完成:
如何添加周期性季节性特征
2)因果关系测试
评估因果关系是时间序列分析中最有争议的话题之一，通常需要特别的分析。由于要考虑的数据量和外部因素，这通常是不可能的。在 giotto-time 中，我们提供了一种方法来自动化这一过程，同时保持特别方法的统计严密性。
相关性并不意味着因果关系。但是，如果在统计上有意义，它可能是预测框架中一个有用的特征
ShiftedLinearCoefficient类找到目标时间序列与任何特征时间序列最相关的最佳滞后。一旦发现偏移，就进行统计测试以评估相关性的显著性。最后，通过变换方法，所有的特征时间序列自动向前移动，以使它们与目标时间序列在最佳滞后处对齐。这样，输出就可以用于预测了！
数据科学家首次使用 Giotto
可以使用线性拟合或皮尔逊相关系数。可以进行自举检验或排列检验来评估显著性。在下面的代码示例中，您可以看到这在实践中是如何实现的。最后，我们可以通过简单地使用transform方法来移动数据框中的列。
如何进行因果关系检验并转换时间序列
3)特征创建
可以说，该库最重要的功能之一是特征创建步骤。
以下功能可用:
- 移位特征:用于将时间序列移位给定的步数
- 移动平均:对于给定的窗口大小
- 常量特征:所有时间步长的常量值
- 多项式特征:对于给定的次数
- 外生特性:可以添加另一个时间序列
- 日历功能:给定国家的公共假日
- 周期性季节性特征:可用于创建具有给定起始日期和特定周期的正弦波
- 自定义功能:在这里使用您自己的功能
如何创建特征
一旦创建了特征，我们需要分割X和y数据框。特别是，我们必须定义一个时间范围，该时间范围对应于我们希望预测的时间步数。对于能源需求示例，这是 21 天，导致数据框有 21 列，y 测试值的右下三角形中有NaN值。这是因为那里没有已知值。标签创建是使用以下转换器完成的:
如何创建标签
下图显示了一个示例。第一列对应于向前看一个时间步，第二列对应于向前看两个时间步，以此类推。
4)预测
目前，giotto-time 支持两种类型的模型:
- 带/不带前馈的广义自回归模型(分别简称为
GARFF或GAR - 具有自定义损失函数的线性回归模型
GARFF模型可以选择任何 scikit-learn 兼容的回归器或分类器，并使用它对时间序列进行预测。在这种情况下，前馈意味着除了特征之外，模型还会进行一次预测，并将这些预测添加到数据框中，然后使用这个新的数据框进行下一个时间步长的预测，依此类推。
下面的代码片段显示了如何使用线性回归器作为基础模型来轻松创建这样的模型。
如何使用 GARFF 模型
另一种可能性是使用 giotto-time 自己的线性回归器，它允许优化自定义损失函数。在下面的例子中，使用了最大误差。
如何使用带有自定义损失函数的线性回归
它们都使用了 scikit-learn 中您可能熟悉的fit / predict方法。
结果
在这篇博文附带的笔记本中，我们使用这些函数来预测瑞士未来 21 天的日均能源需求。
在下图中，相对于平均绝对误差，最佳模型的结果与参考值一起绘制。我们可以清楚地看到，预测遵循全球趋势以及每周趋势。然而，也有一些异常值。一个例子是 8 月 1 日(蓝色曲线的大幅下降)。这是瑞士国庆日，从本文开头的时间序列图中可以看出，2016 年至 2018 年也出现了类似的下降。由于数据中可用的年份很少，我们在模型中包含的日历功能不能完全捕捉到这种影响。
对于 1、7、14 和 21 天的时间范围，与最佳模型的相对平均绝对误差分别为 4.4%、5.7%、6.7%和 6.8%。
下表概述了经过测试的不同模型以及针对各种指标获得的结果。对于我们在培训中找到的基线模型，设置回顾的理想天数，然后使用这一天的值作为预测。最好的结果用黄色标出。
第 1、7、14、21 天的结果表(从左到右和从上到下)
我们观察到，以线性回归作为基础模型的GARFF模型在除最大误差度量之外的所有方面都比其他模型表现得更好。特别是相对平均绝对误差从基线模型中的 9.0%提高到线性回归的GARFF模型中的 6.8%。对于其他情况，获得了类似的结果。最大误差高度依赖于异常值的存在。如上所述，8 月 1 日是一个例外，因为与其他日子相比，那里的能量需求非常低。
结论
我们介绍了 Python 时间序列库 giotto-time，并用它来预测瑞士的能源需求。介绍了 giotto-time 的不同功能，如去趋势、因果检验、特征创建，以及不同的模型，如具有前馈的广义自回归模型和具有定制损失函数的线性回归模型。
如果你想了解更多关于 giotto-time 和 giotto-tda 的信息，你可以在 Twitter 或 LinkedIn 上关注我们，或者在这里加入我们的 Slack 频道。
Google Data Studio 入门
最好的数据可视化和报告工具之一是完全免费使用的。Data Studio 基础入门。
当谈到可视化数据时，有大量的平台可用。但最好的大多是付费的，免费的都不达标。幸运的是，有一个平台可以让你克服这两个问题——Google Data Studio，它是完全免费的，所有人都可以使用。在本文中，我将帮助您开始使用 Data Studio，并探索不同的可用特性。
除了是一个免费使用的工具之外，使用 Data Studio 还有许多其他好处，不仅限于以下这些。
- 这是一个完全基于网络的工具，所以你不必在电脑上安装任何笨重的软件。同样，一切都存储在云上，你可以从任何地方访问它。
- 共享报告也非常简单，使用与从 google drive 共享文档相同的方法。
- 连接到来自 150 多个数据源的数据
- 您甚至可以使用嵌入代码在您的网站上显示报告。
在本文中，我使用示例 Google Analytics 数据创建了一个报告。
登录数据工作室
要登录，你需要一个谷歌帐户，一旦你登录，你的主页将有一个 Data Studio 仪表板，看起来像这样。
创建报告
选择“空白报告”选项。这是您为报告安排所有视觉和文本的地方。
连接数据源
从工具栏中选择“添加数据”选项，并连接到提供的示例 Google Analytics 数据。
添加一个可视化的
点按工具栏中的“添加图表”。将出现一个包含所有图表类型的下拉列表。选择所需的图表。
选择图表类型后，右侧窗格将会出现，您将会看到以下内容。您可以简单地从“可用字段”中拖放您想要的维度，您的可视化就准备好了！
定制您的视觉效果
通过选择“样式”选项，您可以根据自己的要求定制视觉效果。
添加文本
使用工具栏中的“文本框”选项可以很容易地添加文本和标题，同样，您可以根据需要自定义和格式化文本框。
下载和分享
一旦您的报告准备就绪，您可以使用显示的“共享”选项来共享它，或者您也可以从“文件”菜单下载 PDF 格式的报告。
在本文中，我非常简要地介绍了 Data Studio 的入门知识。还有许多其他很酷的特性，一旦你熟悉了基础知识，你就可以开始探索这些特性了。
Azure Cosmos DB 中的图形数据库入门
野外的数据是高度关联的。我们可以开始连接这些部分，在 Azure Cosmos DB 中构建图形数据库。
在 Azure Cosmos DB 中，我们可以使用 Gremlin API 产品构建图形数据库。像数据世界中的许多新兴趋势一样，您可能会听到人们谈论图形数据库，并转动眼睛想“我们开始吧”。
但是有很多情况我们可以用图形格式来建模。你可能遇到的最明显的例子是社交网络。我认识迈克，他认识珍玛，我们都喜欢徒步旅行。珍玛去了新西兰的拉格伦徒步旅行，我住在新西兰，等等。等等。(我们将一点点构建这个例子的基础！).
以传统的关系方式对这些关系建模可能很有挑战性，所以使用图形数据模型会很好，但是什么是图形数据库，我们能使用 Azure Cosmos DB 构建一个图形数据库吗？
本文的目的只是介绍什么是基本的图形数据库，然后向您展示如何使用 Azure Cosmos DB 中的 Gremlin API 构建图形数据库。
那么什么是图数据库？
图是由顶点和边组成的结构，这些顶点和边可以有许多属性。
顶点或节点代表物体。在我们的图数据库中，我们可以通过识别用例中的实体来确定图中的节点。记住这一点，我们的节点可以表示如下实体:
- 一个顾客
- 一名雇员
- 一种产品
- 订单
边是顶点或边之间的关系。例如，一个人可能认识另一个人，或者那个人可能去过一个地方。
属性描述关于顶点和边的信息。例如，顶点中的属性可能包括关于人的信息，如他们的姓名、年龄或头发颜色。在 edges 中，这可能包括关于这两个人如何认识彼此的信息。
这个数据模型也可以被称为属性图模型，这是 Azure Cosmos DB 所支持的
我们通常将图形数据库实现为 NoSQL 存储，因为我们需要无模式数据存储所提供的灵活性。这也可以为我们提供一个数据模型，我们可以快速地改变它，对使用它的应用程序产生最小的影响。
即使数据库中的数据在增长，图形数据库也能为我们提供高性能水平。即使我们的关系变得越来越复杂，我们仍然可以从数据库中获得高水平的性能。
在关系数据库中，一旦我们的关系变得更加复杂，我们的查询性能就会下降。
正如我前面提到的，我们可以向图形数据库添加更多的关系和数据，而不会对我们的功能产生巨大影响。
然而，如果我们的应用程序中需要处理大量的事务，那么我们的图形数据库就会受到影响。
好的，我可以用图形数据库做什么？
有几个我们可以部署图形数据库的用例。由于我目前在一家银行工作，我已经了解了如何部署图形数据库来进行欺诈分析。
构建推荐引擎和社交网络也是我们可以使用图形数据库的好时机。在这些情况下，我们可以使用图表来推断基于用户进行的或之前进行的交互和活动的关系。
我们可以使用图形数据库的另一个很酷的例子是用于主数据管理。我们可以使用图表来查看我们组织内的数据是如何连接的，什么类型的用户查询它，等等。
为什么要用 Cosmos DB 建立图形数据库？
我们可以在自己的电脑上运行图形数据库。没有理由不下载 Apache Tinkerpop，在 Gremlin 控制台上运行一些命令，就可以拥有自己的图形数据库。
但是，生产中的图形数据库是一个庞大的系统。生产中的大型图形数据库会有数十亿的顶点和边，所以我们在自己的计算机上运行这些是不切实际的。
这就是 Cosmos DB 可以帮助我们的地方。由于 Gremlin API 的提供，我们可以在 Azure Cosmos DB 中构建图形数据库。这为我们在云中提供了一个完全托管的图形数据库，它可以在存储和吞吐量方面弹性增长。
在 Cosmos DB 中创建图形数据库
让我们继续使用 Cosmos DB 构建一个图形数据库。转到 Azure 门户并单击创建新资源。在数据库下，单击 Azure Cosmos DB。
现在我们必须配置它。我们给它一个名字，把它放在一个资源组和一个离我们很近的位置。这里最重要的事情是确保选择 Gremlin (graph) 选项作为 API
等待几分钟，我们将准备好我们的带有 Gremlin API 的 Cosmos DB 帐户。让我们创建第一个图形数据库，并向其中添加一个图形，这样我们就可以在其中执行一些查询。
当您的帐户设置完成后，您将进入概述页面。单击“添加图形”来设置您的第一个图形数据库。
在本教程中，我将创建一个基本图表，我已经创建了一个名为 PeopleDB 的数据库，向其中添加了一个名为 PeopleGraph 的图表，并提供了一个分区键调用 hobby，其中包含了我们的爱好值。我将把最大 RU 值保持在 400，因为在本教程中我们不会做任何大的操作。单击“确定”进行设置。
在 Cosmos 中运行一些查询
现在我们已经建立了我们的图表，让我们建立我前面提到的人员场景。为此，我们将在图表中添加一些代表人物的顶点。他们都有自己的名字、姓氏、年龄、爱好、来自哪里和住在哪里的属性。
我们可以通过运行以下查询来添加这些顶点:
// Add Will
g.addV('person').property('firstName', 'Will').property('lastName', 'Velida').property('age', 28).property('userid', 1).property('hobby', 'kayaking').property('from', 'UK').property('lives', 'NZ')// Add Gemma
g.addV('person').property('firstName', 'Gemma').property('lastName', 'Wright').property('age', 30).property('userid', 2).property('hobby', 'hiking').property('from', 'NZ').property('lives', 'NZ')// Add Mike
g.addV('person').property('firstName', 'Mike').property('lastName', 'Smith').property('age', 30).property('userid', 3).property('hobby', 'kayaking').property('from', 'NZ').property('lives', 'NZ')// Add Sloan
g.addV('person').property('firstName', 'Sloan').property('lastName', 'Timms').property('age', 21).property('userid', 4).property('hobby', 'kayaking').property('from', 'UK').property('lives', 'NZ')
现在我们可以添加一些边来表示 People 应用程序中顶点之间的关系。
// Will Knows Gemma
g.V().hasLabel('person').has('firstName', 'Will').addE('knows').to(g.V().hasLabel('person').has('firstName', 'Gemma'))// Sloan Knows Will
g.V().hasLabel('person').has('firstName', 'Sloan').addE('knows').to(g.V().hasLabel('person').has('firstName', 'Will'))// Mike Knows Gemma
g.V().hasLabel('person').has('firstName', 'Will').addE('knows').to(g.V().hasLabel('person').has('firstName', 'Gemma'))
现在我们已经添加了所有内容，我们可以运行一些简单的查询。让我们运行一个查询，返回图形数据库中所有爱好皮划艇的人。
// Select everyone who kayaks as a hobby
g.V().hasLabel('person').has('hobby', 'kayaking')
我们看到返回的结果如下图所示。我们的查询返回了三个人，我们可以单击每个节点来查看他们的属性。
威尔结
迈克结节
斯隆氏结
总之
这是一个非常基本的例子，只是向您介绍图形数据库以及如何使用 Azure Cosmos DB 构建它们。在以后的博文中，我将更深入地探讨如何运行 Gremlin 查询，并将它们与 SQL 查询进行比较。
如有疑问，欢迎在下方随意评论！
HTML 入门
HTML 简介
在网上冲浪时，你看到的大多数网站都是渲染 HTML 和 CSS 代码的结果。HTML 代表超文本标记语言，用于描述网页的结构。在这篇文章中，我们将讨论如何开始使用 HTML 创建一个基本的网页。
我们开始吧！
在 HTML 中，使用标签(也称为元素)来指定结构和语义。结构化标记的元素包括标题、段落、粗体、斜体、换行、下标和上标元素。让我们从讨论 header 标签开始。
标题
在终端中，使用文本编辑器创建一个。“html”文件。我正在使用 VI 文本编辑器:
vi my_website.html
接下来，让我们在文件中创建一些标题。要创建一个标题，你需要使用一个开始标签
，后面跟着你想放在标题中的文本和一个结束标签
。让我们为我们的网站创建一个标题，这将是一个新的独立摇滚专辑发布的博客:
<html>
<h1>New Indie Rock Music</h1>
</html>
接下来保存并关闭文件。现在，在浏览器中，打开您刚刚保存的文件。您应该会看到带有指定标题的页面:
另一件要注意的事情是，通过在标记中指定头编号，可以包含许多头。这导致标题尺寸减小:
<html>
<h1>New Indie Rock Music</h1>
<h2>New Indie Rock Music</h2>
<h3>New Indie Rock Music</h3>
</html>
现在，让我们删除标题标签
和
并添加标题标签，它将显示在浏览器的选项卡中。让我们在主体中添加两个 header 标记:
<html>
<header>
<title>New Indie Rock Music</title>
</header>
<body>
<h1>New Indie Rock Music</h1>
<h2>The New Abnormal, The Strokes</p>
<body>
</html>
在第二个标题下面，我们可以添加段落标签
，给出我们对专辑的看法:
<html>
<header>
<title>New Indie Rock Music</title>
</header>
<body>
<h1>New Indie Rock Music</h1>
<h2>The New Abnormal, The Strokes</h2>
<p>This album is full of passion, commitment and creativity. It has great music.</p>
<body>
</html>
我们也可以使用粗体和斜体标签来强调部分文本。让我们使用 full 将段落中的单词“full”设为粗体，使用 great 将单词“great”设为斜体:
<html>
<header>
<title>New Indie Rock Music</title>
</header>
<body>
<h1>New Indie Rock Music</h1>
<h2>The New Abnormal, The Strokes</h2>
<p>This album is <b>full</b> of passion, commitment and creativity. It has <i>great</i> music.<</p>
<body>
</html>
我们也可以加上下标和上标。假设，我们想给我们的博客文章添加一个脚注。为了给我们的第一个脚注添加一个下标，我们使用^(【1】)。
<html>
<header>
<title>New Indie Rock Music</title>
</header>
<body>
<h1>New Indie Rock Music</h1>
<h2>The New Abnormal, The Strokes</h2>
<p>This album is <b>full</b> of passion, commitment and creativity. It has <i>great</i> music.<sub><a href="#section1">[1]</a></sub></p>
<body>
<p>[1] I don't use the word <i>great</i> lightly </p>
</html>
我们也可以用一个上标，，作为我们的注脚:
<html>
<header>
<title>New Indie Rock Music</title>
</header>
<body>
<h1>New Indie Rock Music</h1>
<h2>The New Abnormal, The Strokes</h2>
<p>This album is <b>full</b> of passion, commitment and creativity. It has <i>great</i> music.<sup><a href="#section1">[1]</a></sup></p>
<body>
<p>[1] I don't use the word <i>great</i> lightly </p>
</html>
此外，您可以使用换行符和水平线来分隔文本的各个部分。我们使用
来换行。让我们在段落中的两个句子之间添加一个换行符:
<html>
<header>
<title>New Indie Rock Music</title>
</header>
<body>
<h1>New Indie Rock Music</h1>
<h2>The New Abnormal, The Strokes</h2>
<p>This album is <b>full</b> of passion, commitment and creativity. <br /> It has <i>great</i> music.<sub><a href="#section1">[1]</a></sub></p>
<body>
<p>[1] I don't use the word <i>great</i> lightly </p>
</html>
接下来，让我们添加一条水平线，使用
来分隔段落和标题:
<html>
<header>
<title>New Indie Rock Music</title>
</header>
<body>
<h1>New Indie Rock Music</h1>
<h2>The New Abnormal, The Strokes</h2>
<hr />
<p>This album is <b>full</b> of passion, commitment and creativity. <br /> It has <i>great</i> music.<sub><a href="#section1">[1]</a></sub></p>
<body>
<p>[1] I don't use the word <i>great</i> lightly </p>
</html>
最后，让我们在我们的网站上添加另一个帖子。这将是驯服黑斑羚的慢冲:
<html>
<header>
<title>New Indie Rock Music</title>
</header>
<body>
<h1>New Indie Rock Music</h1>
<h2>The New Abnormal, The Strokes</h2>
<hr />
<p>This album is <b>full</b> of passion, commitment and creativity. <br /> It has <i>great</i> music.<sub><a href="#section1">[1]</a></sub></p>
<h2>The Slow Rush, Tame Impala</h2>
<hr />
<p>This album is <b>amazing</b>! <br />I love psychedelic pop. <sub><a href="#section2">[2]</a></sub></p>
<body>
<p>[1] I don't use the word <i>great</i> lightly </p>
<p>[2] Not referring to hallucinogenic soda</p>
</html>
我就说到这里，但是您可以自己尝试一下。我鼓励你研究其他标签，比如引用参考文献、添加列表和添加地址。
结论
总之，在这篇文章中，我们讨论了如何开始使用 HTML 构建一个基本的网站。我们讨论了如何指定结构和语义标记，包括页眉、标题、正文和段落标记。我们还讨论了如何斜体字体，字体加粗，添加脚注，添加换行符和添加水平规则。我希望你觉得这篇文章有用/有趣。这篇文章的代码可以在 GitHub 上找到。感谢您的阅读！
AWS 物联网分析入门
借助 AWS 物联网分析，近乎实时地分析来自物联网设备的环境传感器数据
帖子的音频版本
介绍
AWS 将 AWS IoT 定义为一组托管服务，使的互联网连接设备能够连接到 AWS 云，并让云中的应用程序与互联网连接设备进行交互 AWS 物联网服务涵盖三个类别:设备软件、连接和控制以及分析。在本帖中，我们将重点关注 AWS 物联网分析，这是四种服务之一，属于 AWS 物联网分析类别的一部分。据 AWS 介绍，AWS 物联网分析是一种完全托管的物联网分析服务，专为物联网设计，可收集、预处理、丰富、存储和分析大规模的物联网设备数据。
当然，AWS 物联网分析并不是在 AWS 上分析物联网(物联网)或工业物联网 (IIoT)数据的唯一方法。常见的是数据分析师团队使用更通用的 AWS 数据分析堆栈，由亚马逊 S3 、亚马逊 Kinesis 、 AWS Glue 和亚马逊雅典娜或亚马逊红移和红移光谱组成，用于分析物联网数据。那么，为什么选择 AWS 物联网分析而不是更传统的 AWS 数据分析堆栈呢？据 AWS 称，物联网分析旨在管理 Pb 级的物联网和物联网数据的复杂性。根据 AWS 的说法，物联网数据经常有明显的缺口、损坏的消息和错误的读数，必须在进行分析之前清除这些数据。此外，物联网数据必须经常得到丰富和转换才能有意义。物联网分析可以过滤、转换和丰富物联网数据，然后将其存储在时序数据存储中进行分析。
在接下来的帖子中，我们将探索如何使用 AWS 物联网分析来分析来自一系列物联网设备的近实时环境传感器数据。为了跟随帖子的演示，有一个选项可以使用样本数据来模拟物联网设备(参见本文的“模拟物联网设备消息”部分)。
物联网设备
在本帖中，我们将使用从一系列定制的环境传感器阵列中生成的物联网数据来探索物联网分析。每个基于试验板的传感器阵列都连接到一台 Raspberry Pi 单板计算机(SBC)，这是一台流行的、低成本的、信用卡大小的 Linux 计算机。物联网设备被特意放置在温度、湿度和其他环境条件不同的物理位置。
演示中使用的带传感器阵列的 Raspberry Pi 设备
每个设备包括以下传感器:
- MQ135 空气质量传感器有害气体检测传感器:CO、LPG、烟雾( 链接 )
(需要一个 MCP 3008–8 通道 10 位 ADC w/ SPI 接口( 链接 )) - DHT22/AM2302 数字式温湿度传感器( 链接 )
- Onyehn IR 热释电红外 PIR 运动传感器( 链接 )
- 光强检测光敏传感器(环节)
演示中使用的基于试验板的环境传感器阵列的详细视图
AWS 物联网设备 SDK
每个 Raspberry Pi 设备运行一个定制的 Python 脚本， sensor_collector_v2.py 。该脚本使用 AWS 物联网设备 SDK for Python v2 与 AWS 通信。该脚本定期从四个传感器收集总共七个不同的读数。传感器读数包括温度、湿度、一氧化碳(CO)、液化石油气(LPG)、烟雾、光线和运动。
该脚本使用 ISO 标准消息队列遥测传输 (MQTT)网络协议，将传感器读数以及设备 ID 和时间戳作为一条消息安全地发布给 AWS。下面是一个 MQTT 消息负载的例子，由收集器脚本发布。
如下图所示，在物联网设备上使用tcpdump，脚本生成的 MQTT 消息有效负载平均约为 275 字节。完整的 MQTT 消息平均大约 300 字节。
AWS 物联网核心
每个树莓 Pi 都注册了 AWS 物联网核心。物联网核心允许用户快速安全地将设备连接到 AWS。据 AWS 称，物联网核心可以可靠地扩展到数十亿台设备和数万亿条消息。注册的设备在 AWS 物联网核心中被称为的东西。一个事物是一个特定设备或逻辑实体的表示。关于一个事物的信息作为 JSON 数据存储在注册表中。
物联网核心提供了一个设备网关，管理所有活动设备连接。该网关目前支持 MQTT、WebSockets 和 HTTP 1.1 协议。在消息网关的背后是一个高吞吐量的 pub/sub 消息代理，它以低延迟安全地向所有物联网设备和应用传输消息。下面，我们看到一个典型的 AWS 物联网核心架构。
三个 Raspberry Pi 设备每天以五秒的消息频率向 AWS 物联网核心发布大约 50，000 条物联网消息。
AWS 物联网安全性
AWS 物联网核心提供相互认证和加密，确保 AWS 和设备之间交换的所有数据在默认情况下安全。在演示中，使用端口 443 上带有 X.509 数字证书的传输层安全性 (TLS) 1.2 安全地发送所有数据。设备访问 AWS 上任何资源的授权由单独的 AWS 物联网核心政策控制，类似于 AWS IAM 政策。下面，我们看到一个分配给注册设备的 X.509 证书的示例。
AWS 物联网核心规则
一旦从物联网设备(一个东西)接收到 MQTT 消息，我们使用 AWS 物联网规则将消息数据发送到 AWS 物联网分析通道。规则使您的设备能够与 AWS 服务进行交互。规则是用标准结构化查询语言(SQL)编写的。分析规则，并基于 MQTT 主题流执行动作。下面，除了 AWS 物联网事件和亚马逊 Kinesis 数据消防软管之外，我们还看到了一个将我们的消息转发给物联网分析的示例规则。
模拟物联网设备消息
构建和配置多个基于 Raspberry Pi 的传感器阵列，并向 AWS 物联网核心注册这些设备，仅仅是这篇文章就需要大量的工作。因此，我已经在 GitHub 上提供了模拟三个物联网设备所需的一切。使用以下命令 git 克隆项目的本地副本。
自动气象站云形成
使用 CloudFormation 模板 iot-analytics.yaml 创建包含(17)种资源的物联网分析堆栈，包括以下内容。
- (3) AWS 物联网
- (1) AWS 物联网核心话题规则
- (1) AWS 物联网分析渠道、管道、数据存储和数据集
- (1)AWSλ和λ许可
- ①亚马逊 S3 桶
- (1)亚马逊 SageMaker 笔记本实例
- (5) AWS IAM 角色
继续之前，请注意 CloudFormation 模板中使用的 AWS 资源所涉及的成本。要构建 AWS CloudFormation 堆栈，请运行以下 AWS CLI 命令。
下面，我们看到了物联网分析演示 CloudFormation 堆栈的成功部署。
发布示例消息
一旦成功创建了 CloudFormation 堆栈，使用包含的 Python 脚本， send_sample_messages.py ，将示例物联网数据从本地机器发送到 AWS 物联网主题。该脚本将使用您的 AWS 身份和凭据，而不是向物联网核心注册的实际物联网设备。物联网数据将被物联网主题规则拦截，并使用主题规则操作重定向到物联网分析通道。
首先，我们将通过发送一些测试消息来确保物联网堆栈在 AWS 上正确运行。转到 AWS 物联网核心测试选项卡。订阅iot-device-data话题。
然后，使用较小的数据文件 raw_data_small.json 运行以下命令。
如果成功，您应该会在 Test 选项卡中看到这五条消息，如上所示。该脚本的输出示例如下所示。
然后，使用更大的数据文件 raw_data_large.json 运行第二个命令，该文件包含 9995 条消息(相当于几个小时的数据)。该命令大约需要 12 分钟才能完成。
一旦第二个命令成功完成，您的物联网分析通道应该包含 10，000 条唯一消息。有一个可选的超大数据文件，包含大约 50，000 条物联网消息(24 小时的物联网消息)。
AWS 物联网分析
AWS 物联网分析由五个主要组件组成:通道、管道、数据存储、数据集和笔记本。这些组件使您能够收集、准备、存储、分析和可视化您的物联网数据。
下面，我们看到一个典型的 AWS 物联网分析架构。物联网消息来自 AWS 物联网核心，这是一个规则操作。亚马逊 QuickSight 提供商业智能、可视化。亚马逊 QuickSight ML Insights 增加了异常检测和预测功能。
典型的 AWS 物联网分析架构
物联网分析渠道
AWS 物联网分析通道将来自亚马逊 S3、亚马逊 Kinesis 或亚马逊物联网核心等其他 AWS 来源的消息或数据纳入物联网分析。渠道为物联网分析管道存储数据。渠道和数据存储都支持将数据存储在您自己的亚马逊 S3 存储桶或物联网分析服务管理的 S3 存储桶中。在演示中，我们使用服务管理的 S3 存储桶。
创建频道时，您还可以决定保留数据的时间。在演示中，我们将数据保留期设置为 14 天。通常，您只需在需要分析的时间段内将数据保留在通道中。对于物联网消息数据的长期存储，我建议使用 AWS 物联网核心规则向亚马逊 S3 发送原始物联网数据的副本，使用诸如亚马逊 Kinesis Data Firehose 之类的服务。
物联网分析渠道
AWS 物联网分析管道使用来自一个或多个渠道的消息。管道在将消息存储到物联网分析数据存储之前，对其进行转换、过滤和丰富。管道由一系列活动组成。从逻辑上讲，您必须指定一个[Channel](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iotanalytics-pipeline-activity.html#cfn-iotanalytics-pipeline-activity-datastore) ( 源)和一个[Datastore](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iotanalytics-pipeline-activity.html#cfn-iotanalytics-pipeline-activity-datastore) ( 目的地)活动。或者，您可以在pipelineActivities数组中选择多达 23 个附加活动。
在我们的演示管道iot_analytics_pipeline中，我们指定了五个额外的活动，包括[DeviceRegistryEnrich](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iotanalytics-pipeline-activity.html#cfn-iotanalytics-pipeline-activity-deviceregistryenrich)、[Filter](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iotanalytics-pipeline-activity.html#cfn-iotanalytics-pipeline-activity-filter)、[Math](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iotanalytics-pipeline-activity.html#cfn-iotanalytics-pipeline-activity-math)、[Lambda](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iotanalytics-pipeline-activity.html#cfn-iotanalytics-pipeline-activity-lambda)和[SelectAttributes](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iotanalytics-pipeline-activity.html#cfn-iotanalytics-pipeline-activity-selectattributes)。还有两个额外的活动类型我们没有选择，[RemoveAttributes](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iotanalytics-pipeline-activity.html#cfn-iotanalytics-pipeline-activity-removeattributes)和[AddAttributes](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iotanalytics-pipeline-activity.html#cfn-iotanalytics-pipeline-activity-addattributes)。
由 CloudFormation 创建的演示管道从来自演示通道iot_analytics_channel的消息开始，如下所示。
演示的管道通过一系列管道活动转换消息，然后将结果消息存储在演示的数据存储中iot_analytics_data_store。生成的消息如下所示。
在我们的演示中，对消息的转换包括删除device_id属性并将temp属性值转换为 Fahrenheit。此外，[Lambda](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iotanalytics-pipeline-activity.html#cfn-iotanalytics-pipeline-activity-lambda)活动将temp、humidity、co、lpg和smoke属性值向下舍入到精度的 2 到 4 位小数。
演示的管道还用metadata属性丰富了消息，包含来自物联网设备的 AWS 物联网核心注册表的元数据。元数据包括关于生成消息的设备的附加信息，包括我们输入的自定义属性，例如位置(经度和纬度)和设备的安装日期。
管道的一个重要特性是重新处理消息的能力。如果对管道进行更改(这通常发生在数据准备阶段),可以重新处理关联通道中的任何或所有消息，并覆盖数据集中的消息。
物联网分析数据存储
AWS 物联网分析数据存储将 AWS 物联网分析管道中准备好的数据存储在一个完全托管的数据库中。渠道和数据存储都支持将数据存储在您自己的亚马逊 S3 存储桶或物联网分析管理的 S3 存储桶中。在演示中，我们使用服务管理的 S3 存储桶在我们的数据存储中存储消息。
物联网分析数据集
AWS 物联网分析数据集通过使用标准 SQL 查询数据存储，自动为数据分析师提供定期的最新见解。定期更新是通过使用 cron 表达式提供的。在演示中，我们使用 15 分钟的间隔。
下面，我们在数据集的结果预览窗格中看到示例消息。这是我们发送来检查堆栈的五条测试消息。请注意用于获取消息的 SQL 查询，它查询数据存储。您会记得，数据存储包含来自管道的转换后的消息。
物联网分析数据集还支持将内容结果(物联网分析数据的物化视图)发送到亚马逊 S3 桶。
CloudFormation 堆栈包含一个加密的亚马逊 S3 桶。每当 cron 表达式运行计划更新时，此存储桶都会收到来自物联网分析数据集的消息副本。
物联网分析笔记本
AWS 物联网分析笔记本允许用户使用 Jupyter 笔记本对物联网分析数据集进行统计分析和机器学习。物联网分析笔记本服务包括一组笔记本模板，其中包含 AWS 创作的机器学习模型和可视化。笔记本实例可以链接到 GitHub 或其他源代码库。使用物联网分析笔记本创建的笔记本也可以通过亚马逊 SageMaker 直接访问。对于这个演示，笔记本实例与项目的 GitHub 存储库相关联。
该存储库包含一个基于conda_python3内核的示例 Jupyter 笔记本，IoT _ Analytics _ Demo _ Notebook . ipynb。这个预装环境包括默认的 Anaconda 安装和 Python 3。该笔记本使用 pandas、matplotlib 和 plotly 来操作和可视化我们之前发布并存储在数据集中的示例物联网消息。
笔记本可以修改，修改的内容推回到 GitHub。您可以轻松地复制我的 GitHub 存储库并修改 CloudFormation 模板，以包含您自己的 GitHub 存储库 URL。
亚马逊 QuickSight
亚马逊 QuickSight 提供商业智能(BI)和可视化。亚马逊 QuickSight ML Insights 增加了异常检测和预测功能。我们可以使用 Amazon QuickSight 来可视化存储在物联网分析数据集中的物联网消息数据。
亚马逊 QuickSight 有标准版和企业版。AWS 提供了每个版本详细的产品对比。在这篇文章中，我展示了企业版，它包括额外的功能，如 ML Insights，每小时刷新 SPICE (超快，并行，内存中，计算引擎)，以及主题定制。如果您选择跟随演示的这一部分，请注意 Amazon QuickSight 的成本。Amazon QuickSight 通过演示的 CloudFormation 模板启用或配置。
QuickSight 数据集
Amazon QuickSight 有各种各样的数据源选项来创建 Amazon QuickSight 数据集，包括下面显示的那些。不要混淆亚马逊 QuickSight 数据集和物联网分析数据集。这是两种不同但相似的结构。
为了进行演示，我们将创建一个 Amazon QuickSight 数据集，该数据集将使用我们的物联网分析数据集作为数据源。
Amazon QuickSight 让您能够修改 QuickSight 数据集。为了进行演示，我添加了两个额外的字段，将真和假的布尔值light和motion转换为二进制值 0 或 1。我还取消选择了 QuickSight 分析不需要的两个字段。
QuickSight 提供了多种功能，使我们能够对字段值执行动态计算。下面，我们看到一个新的计算字段，light_dec，包含原始光场的布尔值转换为二进制值。我使用一个if...else公式根据另一个字段中的值来改变字段的值。
快速视力分析
使用以物联网分析数据集为数据源构建的 QuickSight 数据集，我们创建了 QuickSight 分析。QuickSight 分析用户界面如下所示。分析主要是视觉效果(视觉类型)的集合。QuickSight 提供了许多视觉类型。每个图像都与一个数据集相关联。可以过滤 QuickSight 分析或每个单独视觉的数据。为了演示，我创建了一个 QuickSight 分析，包括几个典型的 QuickSight 视觉效果。
QuickSight 仪表板
要共享 QuickSight 分析，我们可以创建一个 QuickSight 仪表板。下面，我们将上面显示的 QuickSight 分析的几个视图作为仪表板。仪表板的查看者不能编辑视觉效果，尽管他们可以对视觉效果中的数据应用过滤和交互式下钻。
地理空间数据
亚马逊 QuickSight 理解地理空间数据。如果您还记得，在物联网分析管道中，我们丰富了来自设备注册表的元数据中的消息。元数据属性包含设备的经度和纬度。Quicksight 会将这些字段识别为地理字段。在我们的 QuickSight 分析中，我们可以使用地理空间图表(地图)视觉类型来可视化地理空间数据。
QuickSight 移动应用程序
亚马逊 QuickSight 提供免费的 iOS 和 Android 版本的亚马逊 QuickSight 移动应用。移动应用程序使注册的 QuickSight 最终用户能够使用他们的移动设备安全地连接到 QuickSight 仪表板。下面，我们看到同一个仪表盘的两个视图，显示在 iOS 版本的亚马逊 QuickSight 移动应用中。
Amazon QuickSight 移动应用程序的仪表板视图
亚马逊 QuickSight ML 洞察
据亚马逊称，ML Insights 利用 AWS 的机器学习(ML)和自然语言能力，从数据中获得更深入的见解。QuickSight 的 ML-powered 异常检测持续分析数据，以发现聚合内部的异常和变化，让您能够在业务发生变化时采取行动。QuickSight 的 ML-powered 预测可用于准确预测您的业务指标，并通过简单的点击操作执行交互式假设分析。QuickSight 的内置算法使任何人都可以轻松地使用从您的数据模式中学习的 ML，为您提供基于历史趋势的准确预测。
下面，我们在演示的 QuickSight 分析中看到了 ML Insights 选项卡。单独检测到的异常可以添加到 QuickSight 分析中，类似于可视化，并且配置来调整检测参数。
下面，我们看到一个所有设备湿度异常的例子，基于它们的异常分数，或高或低，最小差值为百分之五。
清理
SageMaker 笔记本实例按小时收费。完成演示后，不要忘记删除您的 CloudFormation 堆栈。注意亚马逊 S3 桶不会被删除；您必须手动执行此操作。
结论
在这篇文章中，我们展示了如何使用 AWS 物联网分析来近乎实时地分析和可视化来自多个物联网设备的流消息。结合其他 AWS 物联网分析服务，如 AWS 物联网 SiteWise 、 AWS 物联网事件和 AWS 物联网事物图，您可以创建一个强大的、功能齐全的物联网分析平台，能够处理数百万个工业、商业和住宅物联网设备，生成数 Pb 的数据。
本博客代表我自己的观点，不代表我的雇主亚马逊网络服务公司的观点。
在 Visual Studio 代码中开始使用 Jupyter 笔记本
VS 代码 Python 扩展
VS 代码现在通过它的 Python 插件提供了对 Jupyter 笔记本的本地支持。这里有一个简单的例子来概述它的主要功能。
尽管许多程序员选择使用 IDE(即集成开发环境)，并通过坚持使用它来真正了解它，但其他一些程序员，包括我自己，喜欢探索不同的 IDE 选项。这不仅仅是因为我有兴趣了解每种流行的 IDE 都提供了哪些很酷而且可能是独一无二的特性，而且我还与使用各种 IDE 的同事一起参与了多个项目，为了便于交流，当我们召开项目会议时，我想说他们的“语言”。
说到 Python 开发，我更喜欢 Jupyter 笔记本和 Visual Studio (VS)代码。
Jupyter 笔记本已经发展成为一种流行的 IDE 选择。随着除 IPython 之外的其他内核的出现，Jupyter Notebook 除了 Python 之外，还可以支持 Java、R、Julia 和其他流行的编程语言。笔记本是集成了降价文本和可执行源代码的画布，支持协作、可扩展和可复制的团队项目。
VS Code 是另一个开源 IDE，在使用各种编程语言(如 JavaScript、C#和 Python)的开发人员中很受欢迎，并且随着更多相关的 VS Code 插件的开发，支持的语言还在增加。但是，创建和编辑 Jupyter 笔记本的本地支持不可用。
事情变了！随着 2019 年 VS Code Python 插件的最新发布，VS Code 已经提供了 Jupyter 笔记本的原生支持，可以让我在不运行 Jupyter 笔记本的情况下在笔记本上工作。在本文中，我将向您展示在 VS 代码中使用 Jupyter 笔记本的基础知识。
环境设置
你需要在你的电脑上安装 Jupyter 软件包。您可以通过运行pip install notebook来使用 Python 包安装程序(即 pip ),或者通过运行conda install -c conda-forge notebook来使用 conda 包管理器。当然，您的计算机也应该已经安装了 Python 3 和 VS 代码。如果没有，Python 安装可以参考这里，VS 代码安装可以参考那里。
打开 VS 代码，转到扩展部分。如果您使用 Mac，可以使用⇧⌘X(即 Shift + Cmd + X)快捷键；如果您使用 Windows 切换到扩展部分，可以使用 Ctrl + Shift + X 快捷键。在文本框中搜索“Python”，应该可以看到相关扩展的列表。点击名为“Python”的一个——这是微软开发的一个扩展。如果需要，安装扩展并重新启动 VS 代码。
完成最后几个准备步骤后，您的 VS 代码就可以使用 Jupyter 笔记本了。
创建 Jupyter 笔记本
要创建一个新的笔记本，只需进入查看->命令调板(Mac 中的⇧⌘P)。一旦弹出调色板，搜索“Jupyter”并选择“Python:创建空白的新 Jupyter 笔记本”选项，这将为您创建一个新的笔记本。出于本教程的目的，我创建了一个名为 JupyterExample.ipynb 的笔记本，如下所示。
创建新的 Jupyter 笔记本
常见用法
插入和删除单元格
要插入单元格，请单击工具栏中的加符号或单元格左侧的符号。要删除单元格，点击单元格右侧的删除标志(即垃圾桶符号)。
插入和删除单元格
切换单元格内容类型和状态
要切换内容类型，请单击单元格中的代码/降价区域。要切换状态，点击文本输入框使其处于编辑模式。点击单元格左侧的竖条，切换到命令模式。通过点击另一个单元格，先前选择的单元格将变为未选中。单元格的状态由单元格左侧的竖线表示。
切换单元格内容类型和状态
命令状态下的快捷键
当单元格处于命令状态(如左侧的蓝色实线所示)时，可以使用以下快捷方式。
命令状态下的快捷键
运行代码单元格
要运行代码单元格，只需单击代码/降价区域中的三角形符号。要运行笔记本中的所有代码单元，只需点击顶部工具栏中的双箭头。
运行代码单元格
虽然上图中没有显示，但是工具栏中带有向上箭头的三角形是运行当前单元格上方的代码单元格，而带有向下箭头的三角形是运行当前单元格下方的代码单元格。
变量查看器
要查看已声明变量的列表，只需单击工具栏中的变量，这将带来一个显示所有已定义变量的表格。如果您声明了一个新的，它将自动包含在表中。
变量查看器
绘图查看器
对于生成的图，我们可以单击图输出角上的图图标，如下所示。
绘图查看器
在绘图查看器中，您会在顶部看到一个工具栏，它具有一些常用功能，如放大和缩小以及保存绘图。
外卖食品
本文回顾了在 VS 代码中使用 Jupyter 笔记本所需的基本操作。如果您使用 VS 代码来满足其他开发需求，尝试在 VS 代码中使用 Jupyter Notebook 会很方便，这样您就可以坚持使用一个 IDE。特别是对代码自动完成的支持，可以让你的开发更快。
2020 年云上的 Jupyter + Spark 入门
轻松组装由大数据集群支持的笔记本电脑
迪伦·诺尔特在 Unsplash 上的照片
2020 年是利用 Jupyter 和 Spark 集群深入研究大数据的大好时机。所有三大云提供商(Amazon Web Services、Microsoft Azure 和 Google Cloud)都配置了托管服务来运行集群，并预装了 Jupyter 和 Spark。随着大数据的爆炸式增长和低准入门槛(成本和工作量)，了解如何使用机器集群解决大数据问题正成为当今数据科学就业市场的一项必备技能。
在本文中，我将向您展示如何在 Google Cloud Dataproc 上使用 Jupyter 构建 Spark 集群。我们将回顾:
- 在 Dataproc 上配置 Spark 集群设置
- 为 Jupyter 和 Anaconda 配置集群
- 访问 Jupyter 笔记本
在 Dataproc 上配置 Spark 集群设置
Dataproc 是 Google Cloud 的托管服务，用于运行 Apache Spark 和 Apache Hadoop 集群。我们将使用 Dataproc 来创建和管理我们的 Spark 集群。在您的 Google 云平台用户控制台中，导航到 Dataproc 并点击“创建集群”。
您将进入“创建集群”页面，其中包含您的机器集群的设置。在本教程中，我们将对主节点和工作节点使用默认的机器类型 n1-standard-4。如果您想节省一些钱，我建议降级到 n1-standard-2，而不是 n1-standard-1，因为 1 vCPU 机器需要更长的时间来启动。
为 Jupyter 和 Anaconda 配置集群
这就是令人兴奋的地方。几年前，你必须编写一个自定义脚本来安装 Jupyter 和 Anaconda。今天，你可以通过点击几个按钮得到同样的结果。选中“组件网关”下的“启用对 web 界面的访问”并展开“高级选项”。
虽然是可选的，但是设置一个云存储分段存储桶。使用云存储桶可以将您的笔记本电脑保存在云中，并在您下次启动笔记本电脑时可用。
将机器的镜像设置为 1.5 (Debian 10、Hadoop 2.10、Spark 2.4)。根据我的经验，1.3 image 基于 Python 2，不能访问 Python 3 中开发的新工具。
这里最重要的部分是可选组件下的“选择组件”。下图显示了可用的选项。
最后，选中项目访问下的“允许 API 访问所有 Google 云服务”。这将允许您的集群访问其他 Google 云服务，如 BigQuery。
在可选组件中，我们看到了各种可用的组件。默认安装了 Spark(未列出)，我们将选中 Anaconda 和 Jupyter 笔记本，然后单击“Select”保存我们的选择。
回到“cluster settings”菜单，在启动集群之前，我们还有最后一个项目要设置。选中“计划删除”下的“按固定时间计划删除”。此选项确保您的群集在一段设定的时间后自行终止。Dataproc 根据集群保持运行的时间来计费。预设删除时间可以确保当我们忘记手动终止集群时，不会收到任何意外的账单。对于本教程，我们将删除时间设置为 2 小时。
访问 Jupyter 笔记本
就是这样！创建集群大约需要 3 到 10 分钟。一旦群集名称旁边的旋转图标变成绿点复选标记，请单击“web interfaces”选项卡和“Component gateway”下的“Jupyter”。如果 Jupyter 不可用，请确保您已按照上一节中的说明“启用对 web 界面的访问”并选择了可选组件。正如我们所看到的，我们在集群创建过程中选择的任何可选组件都将出现在 web interfaces 选项卡中。
迎接我们的是我们熟悉的 Jupyter 笔记本用户界面。点击“GCS”文件夹访问谷歌云存储桶。我们在该文件夹中上传或创建的任何文件都可以在我们之前在集群创建过程中设置的云桶中使用。
我们的笔记本电脑有 4 种不同的内核。他们都可以进入我们的星火星团。我喜欢使用“Python 3”笔记本，因为它可以访问与 Anaconda 和 PySpark 一起安装的所有数据科学包。
还有维奥拉。你现在有一个运行在 Spark 集群上的 Jupyter 笔记本了！我们可以用下面的代码检查笔记本，以确保所有内容都正确加载。
!scala -version import pandas as pd
import numpy as np
from pyspark.sql import SparkSessionspark = SparkSession.builder \
.appName('Jupyter BigQuery Storage')\
.config('spark.jars', 'gs://spark-lib/bigquery/spark-bigquery-latest_2.12.jar') \
.getOrCreate()table = "bigquery-public-data.wikipedia.pageviews_2020"
df = spark.read \
.format("bigquery") \
.option("table", table) \
.load()
df.printSchema()df_agg = df \
.select('wiki', 'views') \
.where("datehour = '2020-03-03'") \
.groupBy('wiki') \
.sum('views')
df_agg.show()
一旦你完成了你的分析，确保删除你的集群，以避免额外的费用！运行本教程中的集群 2 小时大约需要 1 美元。您可以使用Google Cloud Pricing Calculator并选择 Dataproc 服务来估算您的集群的成本。
结束语
随着大数据的兴起，对于数据科学家来说，学习如何在云上使用 Jupyter + Spark 非常重要。这样，我们可以水平扩展我们的计算资源，而不仅仅是垂直扩展。在本教程中，我们在 Google Cloud Dataproc 上构建了一个加载了 Jupyter 和 Anaconda 的 Spark 集群。现在，让我们开始处理大数据吧！
不知道去哪里找大数据练习？查看我以前的一篇文章，关于谷歌公共数据集上可用的万亿字节数据集:用谷歌公共数据集升级。
将 Jupyter 笔记本电脑连接到万亿字节的数据
towardsdatascience.com](/level-up-with-googles-public-datasets-5ffce0893ea0)
开始使用 Microsoft Excel
帮助您开始 Excel 之旅的 10 大命令
贾里德·布拉舍在 Unsplash 上拍摄的照片
对于门外汉来说，学习微软 Excel 的一些【高级基础】功能会对他们的生活产生巨大的影响。它可以帮助节省无数小时的手动工作，甚至可以自动化 It 的某些方面。根据行业和办公室的构成，它甚至可以帮助你成为办公室的电脑专家！
Excel 很强大，它做不到的事情很少。在投资银行工作，我每天都要使用 Excel，我很惊讶 Excel 的新毕业生对此知之甚少。我也不是在谈论 VBA；我说的是古老的内置公式。不过，不用担心，因为很快就能赶上。
在这篇博文中，我们将讨论我希望每个人都知道的关于 Excel 的 10 件事！
如何使用 Excel 公式
您需要知道的第一件事是，Excel 希望所有公式都以等号开头。单击任意空白单元格并键入“=”，您会注意到一些内置函数已经可以使用了。
当你读完这篇博客的时候，你会觉得把它们都尝试出来很舒服！
用“&”将单元格连接在一起
我们今天要学的第一件事是“&”符号。它用于将细胞连接在一起。你问我们为什么要这么做？我发现最常见的用法是创建唯一的数据键。如果一个数据集的主键中有多个字段，您可能希望用一个属性来表示它，以使数据集之间的连接和查找更容易。
让我们在实践中看看:
作者图片
使用 VLOOKUP 查找数据
迟早，当您需要根据一组数据中的一个值从另一组数据中检索信息时，这种需求肯定会出现。例如，假设您拥有所有相关信息，您希望能够根据姓名返回一个人的身高。
最简单的方法是使用 VLOOKUP。我们首先需要选择我们希望在查找中使用的值，然后是我们感兴趣的范围(记住查找将发生在第一列)，然后是我们希望返回数据的列，然后是我们希望精确匹配还是近似匹配。
这里有一个例子，你可以清楚地看到发生了什么:
作者图片
你可能已经注意到 VLOOKUP 只支持垂直查找。如果你想进行横向查找，你可以使用 HLOOKUP。
条件求和:SUMIF
另一个内置函数可能比您想象的更有用，它允许您有条件地对值求和。也就是说，根据某些标准，我们可以指定是否要将这些值包含在总数中。
这通过一个例子最容易理解:
作者图片
带小计的算术序列
SUBTOTAL 是一个漂亮的小函数，它使您能够对许多字段执行算术运算。Average、count、max、min、sum、stdev 等都是 SUBTOTAL 可以支持的函数。
这个函数的另一个秘密之处是它只考虑可见的值。换句话说，当您筛选结果集时(ctrl + shift + L，and filter)，分类汇总将只考虑在定义的范围内可见的值。
作者图片
删除重复项
虽然这不是一个内置的函数，但却是一个非常有用的功能。有时您只是想知道哪里有重复的数据，或者您只是想删除它们。这样做的过程不仅简单，而且非常实用。它的 UI 控件使您能够快速轻松地定义组合键。
您可以通过按 alt、A、m 快速调用此功能，或者如果您想使用鼠标，您可以通过典型的 Excel 控件调用此功能。
作者图片
文字分列
顾名思义，该功能使您能够将文本分成几列。当您使用逗号分隔文件(CSV)或其他分隔符时，这可能会很有用。
但是，根据您正在处理的数据类型，您可以使用该控件来发挥创造力。当我在 Excel 中复制粘贴一些内容，并且数字表示为文本时，我经常发现自己在使用这个控件(您可以直观地看出，因为单元格中的值是左对齐的)。这将产生任何查找等问题。因此，快速使用这个带有伪分隔符的控件会重新格式化所有内容(快捷键:alt，a，e)。
作者图片
数据透视表
如果有一件事你带走并记住了，那就是这件事。毫无疑问，数据透视表可能是您可以了解的关于 Excel 的最重要和最有用的东西。它使您能够以各种方式对数据进行切片和切块，以便您可以对您的数据进行总结并获得深刻的见解。
您可以选择如何根据列、行、要包含的数据以及要在聚合中执行的操作来显示数据。下面的例子肯定会帮助你更好地理解(快捷键:alt，n，v)数据透视表，但是我鼓励你深入研究并亲自尝试。没有比亲自尝试更好的学习方法了。
作者图片
学习在 Excel 中应用 If-Then-Else 语句
在分析数据时，有时你需要检查某些条件是否成立。为此，我们可以使用内置的“if”函数。该函数接受三个输入。条件，条件为真时的结果，条件为假时的结果。
根据语句的复杂程度，可以将多个 if 语句组合在一起。让我们进一步探讨这两种可能性。
简单的例子:
作者图片
或者具有更复杂的逻辑:
作者图片
用于数据分析的字符串操作，包括左、右、左
最后，我们要学习的最后一个 Excel 函数(实际上是最后三个)与尝试操作有关。Len 返回一个字符串的字符数，当它与 left 和 right 结合使用时最有用。
左和右接收两个输入。一个字符串和要返回的字符数，从左或右开始计数。然而，有时你只是想排除一个尾随或开始的字符集，这就是 len 出现的地方。
作者图片
结论
有了这些知识，您现在就具备了继续扩展和积累 Excel 知识所需的一切。我强烈推荐这是一项值得的自我投资。无论招聘广告是否要求，它都是大多数工作中必备的技能。
我希望这能对你有所帮助，并激励你继续学习！
MongoDB Atlas 入门:概述和教程
介绍
数据库即服务
近年来，数据库行业经历了许多变化，导致越来越多的人转向数据库即服务(DBaas)模式，而不是本地基础架构。数据库是大多数业务应用的核心，基于云的 DBaaS 服务为用户提供了一个灵活、可扩展的按需平台，无需设置昂贵的物理硬件、安装软件或配置性能。此外，公司正在分析的数据也在发生变化。用户和开发人员现在寻找适应性更强的数据库，以允许他们访问和处理非结构化数据。随之而来的是对按使用付费模式的内存和 NoSQL 数据库的更大需求。
MongoDB，开源数据库背后的公司，试图用 Atlas 来满足这一需求，这是它自己的 DBaaS 产品，为用户提供托管数据库服务。该服务提供按需付费的价格，并允许用户在他们选择的云服务提供商(AWS、Azure 和 GCP)上部署。Atlas 对 MongoDB 来说是成功的，截至 2019 年，它占其总收入的 35%，拥有超过 12，000 名客户。
在这篇文章中，我们将提供一个关于 MongoDB Atlas 的概述，给出一个关于开始使用该平台的教程，并从首次用户的角度分享我们的一般要点。
MongoDB 地图集
概观
MongoDB Atlas 是一个基于云的开源 NoSQL 数据库，它使用带有动态模式的 JSON 文档，作为表数据库的替代方案。Atlas 提供了 MongoDB 的所有功能，同时自动执行数据库管理任务，如数据库配置、基础设施供应、补丁、扩展事件、备份等，让开发人员能够专注于对他们最重要的事情。
MongoDB Atlas 还提供了灵活性和可伸缩性的双重好处。动态模式允许用户在不修改数据的情况下更改其模式，提供了灵活性。而其“自动分片”功能允许用户在一系列实例中进行纵向或横向扩展，应用程序不会停机。
定价
自由层
MongoDB 提供了一个免费层，用户可以用来学习、构建原型和早期部署。这个名为 M0 沙盒的免费版本被限制在 512MB 的存储空间，共享 vCPU 和 RAM，100 个最大连接数，以及一个 M0 集群的限制。
付费层级
Atlas 针对单区域集群的付费计划起价为 0.08 美元/小时，预计费用为 56.94 美元/月。
对于专用集群，MongoDB Atlas 根据您的使用量按小时计费。该速率取决于许多因素，最重要的是您使用的服务器的大小和数量。例如，根据 MongoDB，一个 m40 的 AWS 3 节点副本集使用附带的 80GB 标准块存储全天候运行一个月，成本约为 947 美元。
MongoDB Atlas 入门
MongoDB Atlas 使入门变得容易，注册免费层只需几秒钟。整个过程使用动态 web 界面，引导您完成各种部署选项。它简单、直观，不需要专业知识。下面，我们将详细介绍使用 MongoDB Atlas 开始运行的步骤。
创建 Atlas 帐户
首先，你需要在 MongoDB Atlas 登陆页面上注册一个账户。注册表只需要你提供基本信息，如姓名，电子邮件，公司和为您创建一个密码。不需要信用卡信息。注册后，Atlas 会自动创建一个默认的组织和项目，您可以在其中部署您的第一个集群。
MongoDB Atlas 登录页面(来源——mongodb.com)
部署自由层集群
登录后，系统会提示您选择云提供商和地区来构建您的第一个集群。Atlas 与三大主要云提供商 Amazon AWS、Google Cloud 和 Microsoft Azure 合作。根据您的选择，您可以选择首选数据中心的位置。免费层和区域被标记为免费沙盒版本，创建一个新的集群只需要几分钟。
选择 MongoDB Atlas 集群和云提供商(来源——mongodb.com)
将您的连接 IP 地址列入白名单
然后会提示您设置您的互联网协议(IP)并将您的 IP 地址列入白名单。这一点很重要，因为它确保只有您可以从您的 IP 地址访问云中的集群。您还可以选择允许从任何地方访问，尽管这意味着任何人都可以通过网络访问您的集群。如果您的密码和其他凭据泄露，这将是一个潜在的安全风险。
MongoDB Atlas 白名单 IP 地址提示(来源——mongodb.com)
为集群创建一个 MongoDB 用户
接下来，您需要创建一个 MongoDB 用户来访问您的集群。只需输入新的用户名和密码。然后，您可以选择用户权限，包括管理员权限、读/写权限或只读权限。
创建一个 MongoDB Atlas 用户提示(来源——mongodb.com)
连接到您的群集
现在，您已经创建了一个用户，是时候连接到您的集群了。系统会提示您选择一种连接方法，要么使用您自己的应用程序 MongoShell 连接，要么使用 MongoDB 的 GUI MongoDB Compass 连接。在本例中，我们将使用 MongoDB Compass 进行连接。
连接到 MongoDB Atlas 集群提示(来源-mongodb.com)
下载并打开 MongoDB Compass 后，系统会提示您从剪贴板粘贴一个连接字符串，然后连接到集群。
将连接字符串粘贴到 MongoDB Atlas 集群(来源—mongodb.com)
在集群中插入和查看数据
现在，您已经连接到集群，可以使用数据资源管理器在集群上插入示例数据并与之交互。
Data Explorer 允许您在集群中查看、创建和删除数据库、集合和索引。此外，您可以插入、编辑和删除文档，以及创建和运行聚合管道来处理数据。请注意，Data Explorer 是 Atlas 中的一个特性，它允许您访问和管理集群中的数据，这与 MongoDB Compass 不同，后者是一个用于与 MongoDB 数据库交互的独立 GUI。
首先，您需要将样本数据集加载到集群中。加载后，您可以通过单击 Collections 按钮(或使用 Mongo Shell)在数据浏览器中访问它。数据导入大约需要 5 分钟，操作完成后，您将在集群中看到五个数据库:
- 样本 _airbnb
- 样本 _ 地理空间
- sample_mflix
- 样本 _ 培训
- 样本 _ 天气数据
使用数据浏览器查看和修改您的 MongoDB Atlas 集群中的数据(来源—mongodb.com)
就这样，我们完成了注册 Atlas 帐户的整个过程，部署并连接到您的第一个 Atlas 集群，用样本数据填充您的集群，并使用 Atlas Data Explorer 与数据进行交互。如你所见，开始使用 Atlas 非常简单明了。
摘要
我们发现 MongoDB Atlas 易于使用和适应。注册帐户、部署第一个集群以及连接到集群的过程是无缝的，这在很大程度上要归功于其直观的界面。特别是，我们喜欢 Atlas 包含样本数据，我们可以将这些数据加载到集群中，然后利用 Data Explorer GUI 与数据进行交互。对于更高级的数据分析和可视化，您可以选择使用标准 BI 工具，如 Tableau 或本地解决方案，如 MongoDB Charts 和 Knowi 。
总的来说，它简单的用户界面，以及它的一系列功能，包括自动分片的可扩展性，用于操作任务的内置自动化机制，以及即使对于最苛刻的工作负载也能提供高吞吐量和低延迟的出色性能，难怪有经验的开发人员和新用户都喜欢 MongoDB Atlas。
外卖食品
- 基于云的 DBaaS 具有灵活性、可扩展性和按需性，无需昂贵的物理设置
- MongoDB Atlas 是 MongoDB 自己的基于云、开源、基于 NoSQL 的完全托管 DBaaS 产品
- Atlas 自动执行数据库管理任务，如配置、基础设施供应、补丁、扩展事件、备份等
- Atlas 提供了动态模式的灵活性，而自动分片特性使得跨实例扩展变得容易
- 一个直观的界面使开始使用 Atlas 变得容易。部署和连接第一个集群只需几分钟
- 数据资源管理器是一项非常有用的功能，它允许您以可视化方式与集群中的数据进行交互
- 其简单的用户界面、任务自动化、灵活性、内置复制和按需定价使 MongoDB Atlas 成为开发人员的最爱
印度语 NLP 入门
想超越英语，用自然语言处理(NLP)的真正力量为世界第二人口大国服务？每个人都知道印度是一个非常多元化的国家，是多种语言的家园，但是你知道印度说 780 种语言吗？说到 NLP，是时候超越英语了。这篇文章是写给那些对 NLP 有所了解，并想开始将它用于印度语言的人的。
语言模型
在进入主题之前，我们将浏览一下 NLP 中的一些基本概念和最近的成就。自然语言处理帮助计算机理解人类语言。文本分类、信息抽取、语义分析、问题回答、文本摘要、机器翻译和对话代理是 NLP 的一些应用。
为了让计算机理解人类语言，我们最初需要用数字形式表示单词。然后，机器学习模型可以利用数字表示的单词来完成任何 NLP 任务。传统上，像 One Hot Encoding ， TF-IDF 表示法这样的方法被用来将文本描述为数字。但是传统的方法由于不能捕捉词义而导致稀疏表示。
然后，神经单词嵌入通过解决传统方法中的问题来拯救。 Word2Vec 和 GloVe 是两种最常用的单词嵌入。这些方法提出了密集表示法，意思相似的单词会有相似的表示法。这种方法的一个显著缺点是单词被认为只有一个意思。但是我们知道，一个词可以有多种含义，这取决于它的使用环境。
语言模型——艾的布偶帝国[3]
NLP 通过现代语言模型家族(AI 的木偶帝国)实现了重大飞跃。单词嵌入不再独立于上下文。根据使用的上下文，同一个单词可以有多个数字表示。伯特、埃尔莫、乌尔姆菲特、 GPT-2 是目前比较流行的一些语言模型。最新一代这么好，也有人认为很危险[3]。这些语言模型撰写的新闻甚至被读者评为与《纽约时报》一样可信。
要了解更多关于语言模型的知识，我强烈推荐阅读[2]。
印度语的单词嵌入
现在，我们将通过获取印度语的单词嵌入来深入探讨这个主题。用数字表示单词在任何 NLP 任务中都有作用。我们将使用印度语自然语言工具包(iNLTK) 库。iNLTK 是一个构建在 PyTorch 之上的开源深度学习库，旨在为应用程序开发人员可能需要的印度语的各种 NLP 任务提供开箱即用的支持。ULMFiT 语言模型用于构建 iNLTK [6]。iNLTK 于 2019 年 5 月在 GitHub 上成为趋势，并在 PyPi 上获得了 23，000+的下载量[5]。
我们在这里使用 iNLTK 是因为它简单并且支持许多印度语言。iNLTK 目前支持以下 12 种印度语。请按照此链接安装 iNLTK。
iNLTK 支持的语言[5]
使用 iNLTK，我们可以快速获得用印度语编写的句子的嵌入向量。下面是一个例子，展示了我们如何获得用印地语写的句子的嵌入向量。给定的句子将被分解成记号，每个记号将用一个(400×1)向量来表示。令牌可以是一个单词，也可以是一个子单词。因为记号可以是子词，所以我们也可以为罕见的词得到一个有意义的向量表示。
# Example 1 - Get Embedding Vectorsfrom inltk.inltk import setup
from inltk.inltk import tokenize
from inltk.inltk import get_embedding_vectors'''
Note: You need to run setup('<code-of-language>') when you use a language for the FIRST TIME ONLY.
This will download all the necessary models required to do inference for that language.
'''
setup('hi')example_sent = "बहुत समय से मिले नहीं"# Tokenize the sentence
example_sent_tokens = tokenize(example_sent,'hi')# Get the embedding vector for each token
example_sent_vectors = get_embedding_vectors(example_sent, 'hi')print("Tokens:", example_sent_tokens)
print("Number of vectors:", len(example_sent_vectors))
print("Shape of each vector:", len(example_sent_vectors[0]))
输出:
代币:['▁बहुत'，'▁समय'，'▁से'，'▁मिले'，'▁नहीं ']
向量个数:5
每个向量的形状:400
既然我们有了单词 embeddings，许多人可能会想知道这些数字表示有多好？相似的令牌有相似的描述吗？我们可以使用为每种语言提供的可视化来获得所有这些问题的答案。例如，如下图所示，所有与'प्रेम'(爱情)相关的象征物都与爱情、亲情、婚礼等密切相关。
更接近'प्रेम'的标志(爱情)
印度语的多个 NLP 任务
正如我前面所说，用数字表示的自然语言可以被机器学习模型用来完成许多 NLP 任务。除此之外，我们可以立即使用 iNLTK 完成大量的 NLP 任务。例如，我们可以使用 iNLTK 来预测接下来的 n 个单词，获得相似的句子，获得句子编码，识别语言，等等。
在下面的例子中，我们将使用 iNLTK 来预测接下来的 n 个单词，并得到相似的句子。对于类似于泰米尔语的“自从我们相遇以来已经过了很长时间”的输入，我们得到对下一个‘n’个单词的预测为“并且，由于这个”。相似句子任务的结果也令人印象深刻。
# Example 2 - Predict Next 'n' Words, Get Similar Sentencesfrom inltk.inltk import setup
from inltk.inltk import predict_next_words
from inltk.inltk import get_similar_sentences'''
Note: You need to run setup('<code-of-language>') when you use a language for the FIRST TIME ONLY.
This will download all the necessary models required to do inference for that language.
'''
setup('ta')example_sent = "உங்களைப் பார்த்து நிறைய நாட்கள் ஆகிவிட்டது"# Predict next 'n' tokens
n = 5
pred_sent = predict_next_words(example_sent, n, 'ta')# Get 'n' similar sentence
n = 2
simi_sent = get_similar_sentences(example_sent, n, 'ta')print("Predicted Words:", pred_sent)
print("Similar Sentences:", simi_sent)
输出:
预测词:உங்களைப்பார்த்துநிறையநாட்கள்ஆகிவிட்டது.மேலும்，இதற்கு காரணமாக
类似句子:['உங்களைத்பார்த்துநாட்கள்ஆகிவிட்டது'，'உங்களைப்பார்த்துஏராளமானநாட்கள்ஆகிவிட்டது']
就像我说的，在开始的时候，是时候超越英语，用 NLP 的真正力量为大家服务了。最近的许多研究都集中在多语言自然语言处理上。iNLTK 就是这样一个专注于印度语的库。现在，您可以通过添加对新语言的支持、改进现有模型和添加新功能来为 iNLTK 做出贡献。除了 iNLTK，我还会推荐多语模型[7]，Indic NLP [8]。别忘了你刚刚遇到的一切都只是冰山一角。在结束这篇文章之前，我想补充几句话来表达 iNLTK 的创造者的愿景。
我一直希望有类似的东西存在，这将使 NLP 更容易理解，并使其对非英语母语者的好处民主化。iNLTK 是有机增长的，现在，由于它被广泛认可，我认为还有很多事情要做。我对 iNLTK 的愿景是，它应该成为任何使用低资源语言的人的首选库。— Gaurav Arora，iNLTK 的创造者。
参考文献
[1]http://blogs . Reuters . com/India/2013/09/07/India-speaks-780-languages-220-lost-in-last-50-earth-survey/
【2】https://towards data science . com/from-word-embeddings-to-pre-trained-language-models-a-new-age-in-NLP-part-1-7 ed 0 c 7 F3 DFC 5
【3
开始使用开源路线图
入门
关于如何开始为开源项目做贡献的 10 步指南。
开源可能是当今科技界的流行语之一。作为开发人员或数据科学家，您可能以前听说过它。即使你不在一个很深的技术领域，你也有可能听到有人提到开源的话题。
尽管许多人都熟悉开源这个术语，但人们并不总是真的知道这个术语的意思。
那么， 什么是开源呢？
开源是一种软件，其中该软件的源代码在特定的版权许可下发布，供其他人出于任何目的使用、研究、更改和分发该软件——只要它不与版权许可相抵触。
用外行人的话来说，这意味着，当一家公司或一个团队构建一项服务或产品时，他们让其他人能够使用源代码并修改其中的内容。
为开源项目做贡献有很多好处；它可以帮助你提高技能，结识新的志同道合的人，为未来的工作建立一个强大的投资组合。另一个好处是，如果你经常为开源做出贡献，你将在社区中变得众所周知，因此，在某种意义上，你将成为技术影响者。
谁能为开源做贡献？
好吧，任何人！无论你是一个代码新手，还是已经编码一段时间的人，你都可以开始为开源项目做贡献。
在这篇文章中，我将列出我的十步指南——我采取的步骤——来开始开源。你可能已经完成了一些步骤。在这种情况下，跳到你当前所在的步骤。
开启数据科学未来的 10 步路线图
towardsdatascience.com](/a-learning-path-to-becoming-a-data-scientist-56c5c2e8ae3f)
步骤 1:建立对编程的基本理解
这一步是为那些对开源好奇但没有任何技术背景的人准备的。不要担心。如果你愿意投入时间，开始构建软件是没有要求的。
在开始使用开源软件之前，您首先需要检查的是您的基本编程知识。这是您开始构建项目所需的基础。确保你了解你打算在文章中使用的编程语言。
如果你想为 Python 项目做贡献，那么了解 Python 将有助于你理解已经完成的工作，并且对你来说扩展它会更容易。
第二步:熟悉 git。
没有 Git 就拼不出开源。嗯，可以，但是你懂我的意思。Git 是让开源成为现实的工具。Git 是需要掌握的棘手话题之一。
我从事技术工作已经十多年了，但是我还没有遇到一个人能够完全处理 Git 而不需要返回文档。然而，你不需要完全理解 Git 的内部动态来开始使用开源。
哪个好！
你只需要几个命令——比如克隆、推、拉、提交，知道何时以及如何使用它们，然后瞧，你就可以开始了。
什么是版本控制，为什么它很重要？
towardsdatascience.com](/version-control-101-definition-and-benefits-6fd7ad49e5f1)
第三步:学习如何寻找你想要的东西
总的来说，对于技术领域来说，最困难的一个方面是关于任何主题的大量信息。如果你尝试谷歌“数据科学图书馆”，你会被成千上万的关于这个特定主题的文章轰炸。
对于开发人员或数据科学家来说，一项有价值的技能是知道如何有效地寻找他们所寻求的答案，无论他们是在谷歌上搜索，还是在文档或教科书中寻找。
如果你想得到你想要的答案，你需要学会问正确的问题。这项技能将有助于使你的工作更快更有效率。
第四步:阅读你最喜欢的项目的文档
数据科学中使用的大多数众所周知且常用的包都是开源包。像 Matplotlib、Numpy 和 Scipy 这样的包。
阅读这些项目的文档会让你了解这些大项目是如何产生的；它将向您展示开源的力量。它还会让你知道还需要做什么，以及为这些项目做贡献的机会。
此外，阅读他们的文档可以熟悉各种类型的许可证及其区别。这些知识将帮助您理解不同许可的规则和用法，从而知道在您未来的项目中使用什么。
第五步:从非代码贡献开始。
你的第一次投稿可能是最令人生畏的。帮助我克服这一点的是在我开始做编码之前做一些非编码的贡献。
有很多机会可以为非基于代码的开源做出贡献。如果你是一个编程新手，仍然对你的编程技能感到不舒服，或者你没有任何编程技能，但是你想为开源做贡献，我在这里告诉你，你可以！
一些非代码贡献包括:
- 改进文档或将其翻译成另一种语言。
- 在网站或图形界面上工作。
- 推销项目或传播信息。
- 主持会议并指导项目存储库的性能。
第七步:寻找一个初学者友好的项目
许多著名的大型项目都是初学者友好型的，不需要你以前的开源贡献。像 DuckDuckGo 或 Habitica 这样的项目非常欢迎新的贡献者。
你也可以联系你喜欢的包或服务的维护者，问问他们是否欢迎开源初学者的贡献。这些信息也可以在他们的网站和文档中找到。
寻找项目的其他来源有:
第八步:与社区交往。
开源是一个由来自世界各地的开发者组成的社区，他们决定共同努力，创造出令人惊叹的东西。当你为开源项目做贡献时，你基本上证明了你愿意加入这个社区。
与其他开源开发者的社交会让你觉得你是一个社区的一部分，一个会在你需要的时候支持你，给你提供很多机会的社区。
你可以通过不同的方式与社区建立联系；你可以为你正在处理的特定项目使用 slack 频道，比如用于 Django 、 Numpy 的 slack 组，或者一般的 Python 社区 slack。
步骤 9:提交你的第一个代码贡献
这一步是最需要你勇气的一步！但也是最有成就感的一步。一旦你熟悉了 Git 和你想使用的编程语言，你就已经用非编码的方式为项目做出了贡献。您已经为您的第一个代码贡献做好了准备。
从一个简单的特性或 bug 开始，也许是一些不紧急的东西。慢慢来，仔细检查你的代码，好好测试。然后，放手，创建一个拉请求。
你只需要一次成功的贡献就能给你继续贡献的信心。
第十步:建立你的投资组合
当你为项目做贡献时，不要忘记记录你对投资组合的贡献。你的贡献越大，你的投资组合就越稳固。
然而，有时候，这不是关于贡献的数量，而是关于它的质量。这就是为什么我总是建议你慢慢来，写出写得好的代码。说到软件贡献，质量在任何时候都胜过数量。
这里有一些你可以用来建立你的投资组合的网站:
您的应用程序需要什么样的测试？
towardsdatascience.com](/a-brief-introduction-to-software-testing-38499dd4189)
外卖食品
我知道一开始参与开源可能会令人生畏，但是，就像生活中的其他事情一样，克服这种威胁的最好方法就是直接投入进去。
不管你使用/知道什么编程语言，你的知识水平，或者专业领域，总有一个开源项目适合你。
所以，要对自己的能力有信心，寻找让你兴奋的事情，并开始做出贡献。一旦你这样做了，过程就变得容易了，暗示也就消失了。
没有比自己动手做东西更好的方法来提高你的技能了。开源是成为一名更好的开发人员和思想更开放的程序员的最好方法之一。
OpenCV 入门
使用 Python 实现计算机视觉的第一步
不久前，我为一个大学项目训练了一个物体检测模型，但老实说，除了需要许多红牛和漫漫长夜观看我的模型训练之外，我不太记得它了。
我最近对这些话题重新产生了一些兴趣，我决定重新开始，重新学习，但这次我做笔记，分享我的学习成果。
与reiinakano.com/arbitrary-image-stylization-tfjs一起建造
——我想知道是否有一天我们能够使用样式转移将样式从一个数据复制到另一个数据，而不损害其完整性。
OpenCV
OpenCV 是一个开源库，最初由英特尔开发，它充满了支持计算机视觉和机器学习的便捷方法和功能。
在本文中，我将尝试学习如何阅读图像，在 Jupyter 笔记本中显示图像，以及如何检查和更改它的一些属性。
import cv2
import numpy as np
import matplotlib.pyplot as plt
让我们从。imread 加载图片，然后我们可以使用。imshow 在新窗口中显示它。
image = cv2.imread('img.jpg')
cv2.imshow('Some title', image)cv2.waitKey(0)
cv2.destroyAllWindows()
方法。等等还有。销毁所有窗口对于运行代码而不崩溃是必不可少的。第一个命令将告诉 Jupyter 继续运行该程序块，直到某个键被按下，第二个命令将在最后关闭窗口。
我们也可以尝试用 Matplotlib 显示图像。imshow 这样，它将显示在内联，而不是在一个新的窗口中。
image = cv2.imread('img.jpg')
plt.imshow(image)
Matplotlib 显示 BGR 图像
呃，好吧。这看起来很奇怪。颜色全乱了。
OpenCV 以 Numpy 数组的形式加载图像，这些数组有三维的红色、绿色和蓝色。维度通常被称为通道，它们保存从 0 到 255 的值，代表每个像素的颜色强度。
>>> print(type(image))
>>> print(image.shape)<class 'numpy.ndarray'>
(776, 960, 3)
这意味着它是 RGB，对吗？不尽然。这是 BGR，这是同样的事情，但在不同的顺序。
Matplotlib 使用 RGB，这就是为什么我们的图片看起来很奇怪。这不是问题，因为 OpenCV 有一些非常方便的方法来转换颜色。
image = cv2.imread('img.jpg')
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)plt.imshow(image)
显示 RGB 图像的 Matplotlib。
太酷了，我们用 OpenCV 读取并显示了我们的图像，并且看了一眼如何用 Matplolib 将 GBR 颜色转换成 RGB 来显示它们。
OpenCV 可以处理其他颜色格式，比如 HSV、CMYK 等等。
颜色；色彩；色调
因为我们会重复很多次，所以让我们创建一个用 Matplotlib 绘图的方法。我们可以设置绘图的大小，并删除轴，使它更好。
def show(img):
fig, ax = plt.subplots(1, figsize=(12,8))
ax.axis('off')
plt.imshow(img, cmap='Greys')
注意，我还在。im 显示为“灰色”；当我们绘制 RGB 图像时，该参数将被忽略，但当我们稍后绘制数组的各个维度时，该参数将会很有帮助。现在，让我们试试我们的方法。
image = cv2.imread('img2.jpeg')
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)show(image)
好了，现在让我们试着把它转换成灰度，然后再转换成 RGB。
image = cv2.imread('img2.jpeg')gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
image = cv2.cvtColor(gray, cv2.COLOR_GRAY2RGB)show(image)
灰度等级
我们可以利用。分割得到单独的颜色数组，然后用. merge 将图片重新组合在一起。这对于修改、检查和过滤我们数组的一个维度是很实用的。
例如，我们可以将数组乘以零来移除它；
img = cv2.imread('img2.jpeg')B, G, R = cv2.split(img)
img = cv2.merge([B*0, G, R*0])img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
show(img)
只有绿色。
我们可以增加或减少颜色的强度，或者用相同的形状建立一个新的 Numpy 数组来替换它，或者你能想到的任何事情。
img = cv2.merge([np.ones_like(B)*255, G, R])img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
show(img)
忧郁增加。
分割和合并的相同概念可以应用于其他格式，例如 HSV 和 HSL。
img = cv2.imread('img2.jpeg')
img = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)H, S, V = cv2.split(img)
img = cv2.merge([np.ones_like(H)*30, S+10, V-20])img = cv2.cvtColor(img, cv2.COLOR_HSV2RGB)
show(img)
黄色色调，较高的饱和度，较低的值。
HSV :色相，饱和度，和值。
这种格式对于过滤颜色很方便，因为它与色调一起工作——这意味着，我们可以使用角度范围，而不是必须找出红色、绿色和蓝色之间的组合范围。
我们可以用 Numpy 定义 HSV 的上下边界。应用该方法。过滤这些值，并创建一个掩码。然后我们可以在饱和度下应用这个蒙版。bitwise_and，这将使边界之外的所有内容变为零。
换句话说:我们可以过滤掉一些颜色，把剩下的都变成灰度。
# read img and convert to HSV
img = cv2.imread('img2.jpeg')
img = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)# split dimensions
H, S, V = cv2.split(img)# upper and lower boundaries
lower = np.array([80, 0, 0])
upper = np.array([120, 255, 255])# build mask
mask = cv2.inRange(img, lower, upper)# apply mask to saturation
S = cv2.bitwise_and(S, S, mask=mask)# assemble image
img = cv2.merge([H, S, V])# convert to RGB and display
img = cv2.cvtColor(img, cv2.COLOR_HSV2RGB)
show(img)
布鲁斯。
分割图像还可以让我们更容易地检查其组成。
我们可以从 RGB 绘制颜色，从 HSV 绘制饱和度，或者我们想要的任何其他通道。
img = cv2.imread('img2.jpeg')
B, G, R = cv2.split(img)
show(B)img = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
H, S, V = cv2.split(img)
show(S)
使用“灰色”色图，数值从白色(低)到黑色(高)。
我们可以通过查看第一张地图来判断蓝色的强度在地面上比在建筑物中更高，我们可以通过饱和度图看到滑板周围的值比图像的其他部分更高。
今天我就讲到这里。我们研究了如何加载和显示图片，如何将数组转换为不同的颜色格式，以及如何访问、修改和过滤维度。
在下一篇文章中，我将尝试探索变换以及如何移动、调整大小、裁剪和旋转图像。
感谢阅读我的文章。我希望你喜欢它。
资源:
OpenCV 阅读图片；
OpenCV 颜色转换；
Matplotlib 显示图像；
OpenCV 对数组的操作；
OpenCV 基本操作；
使用 Python 开始光学字符识别
语言模型设计
对光学字符识别从无到有的直观理解和简要介绍
光学字符识别是通过使用电子或机械设备将二维文本数据转换成机器编码文本的一种形式。二维文本数据可以从各种来源获得，例如 PDF 文件之类的扫描文档、具有以下格式的文本数据的图像。png 或者。jpeg、路标(如交通标志)或任何其他带有任何形式文本数据的图像。光学字符识别有广泛的有趣应用。
我第一次接触到光学字符识别是在我上学的时候，我们的多项选择题(MCQ 的)答案脚本会被这些设备分析。可以从这些答案脚本中提取数据，并根据答案关键字标记答案。嗯，尽管大多数人过去总是抱怨他们得到的结果不是他们想要的。这可能是由于设备的故障/功能不全，或者学生可能有轻微的误导。然而，随着现代技术的发展，光学字符识别被用于各种应用中，并且这些应用更加先进。这些设备的精确度已经大大提高了。
在本文中，我们将介绍光学字符识别的基础知识。然后，我们将继续安装 pytesseract 模块，我们将使用它来执行光学字符识别。最初，在我刚入门的时候，安装对我来说是相当烦人和麻烦的。所以，我会尽量简化安装过程的步骤。然后我们将使用 python 理解 pytesseract 模块中的各种函数。最后，我们将以一段代码来结束本文，这段代码涵盖了光学字符识别以及 google 文本到语音转换模块的使用。
注意:最终代码将是使用文本到语音和字符识别的组合代码。这是语言模型设计系列的第二部分。如果你没有关于 gTTS 模块的线索，我强烈建议观众查看下面的链接。在本系列的下一部分，我们将尝试将语音翻译和光学字符识别与深度学习相结合。要按你的喜好顺序观看这个系列，你可以点击链接这里。
[## 如何使用 Python 开始使用 Google 文本到语音转换
从零开始的文本到语音转换简介
towardsdatascience.com](/how-to-get-started-with-google-text-to-speech-using-python-485e43d1d544) 
光学字符识别究竟是如何工作的？
图片由作者根据媒介创作
光学字符识别过程流程如上图所示。发送 API 请求以执行 OCR 操作。输入图像被相应地读取和预处理。文本被格式化并从图像中提取出来。使用经过训练的数据集，计算发送到 OCR 引擎的图像。OCR 引擎会尝试分析图像中的字符，并找到合适的解决方案。一旦引擎完成分析，它将发送数据进行另一步预处理和格式化，以排除任何不必要的项目。一旦这个过程完成，我们将最终获得所需的文本数据。在此之后，可以使用来自图像的转换后的文本数据向用户返回一个 API 响应。
安装:
安装可能有点棘手。但是，我会尽量简化安装步骤，以便您可以尽快开始。第一步很简单，只需使用 pip 命令安装 pytesseract 模块。在命令提示符终端/虚拟环境中键入以下命令—
我们已经成功安装了 pytesseractt 模块，但是当您试图立即运行代码时，您将收到一条错误消息，指出您的系统中没有安装 tesserac 模块。要完成此步骤，请访问此站点。这是 windows 宇宙魔方的官方网站。宇宙魔方 3.05、宇宙魔方 4 和开发版 5.00 Alpha 的 Windows 安装程序可从 UB Mannheim 的宇宙魔方获得。这些包括培训工具。32 位和 64 位安装程序都可用。
选择您喜欢的安装方式，并相应地进行安装。您可以将 pytesseract 模块添加到您的路径中，或者直接使用它。我希望这能解决安装过程中的大部分问题。如果您有任何其他疑问，请随时告诉我。
了解 pytesseract 模块:
Python-tesseract 是 Google 的 Tesseract-OCR 引擎的包装器。它作为 tesseract 的独立调用脚本也很有用，因为它可以读取 Pillow 和 Leptonica 图像库支持的所有图像类型，包括 jpeg、png、gif、bmp、tiff 等。此外，如果用作脚本，Python-tesseract 将打印识别的文本，而不是将其写入文件。
为了更直观地理解这一点，让我们看看下面的简单代码块—
我们导入 pytesseract 模块并指定路径。然后，我们使用 cv2 模块读取图像。最后，我们提取这些图像并返回文本数据。 image_to_string 返回对 image to string 运行的 Tesseract OCR 的结果。有关 tesseract OCR 及其 image_to_string 等功能的更多信息，请访问此处。
代码:
这一部分将包含结合文本到语音和光学字符识别的最终代码片段。我们将使用最近安装的 pytesseract 模块以及 gTTS 和 PIL 等模块。 PIL 代表 python 图像库，将用于加载我们的图像。open-cv 模块 cv2 也可用于读取图像。让我们分三部分来看看整个代码是如何工作的。
1。读取图像—
在这个代码块中，我们导入所需的库，并指定 Tesseract 位置的路径。然后，我们将继续用 cv2 模块读取图像。你也可以使用 PIL 图书馆。该命令将是“Image.open()”。在此步骤之后，我们将使用 OCR 库将图像转换为文本数据，并打印所需的输出。
2。格式化数据—
在下一个代码块中，我们将文本数据格式化为一行。我们基本上是在已经获得的文本数据上执行预处理，然后将其传递到 gTTS 模块用于语音翻译过程。
3。转换成语音—
最后，我们将导入 Google text-to-speech 模块，并将文本数据转换成音频消息的形式。这对于聆听 PDF 格式的文本数据以及图像的有声音频非常有用。如果您对 gTTS 模块有任何困惑，那么可以参考我以前的一篇文章来更好地理解这个概念。
[## 如何使用 Python 开始使用 Google 文本到语音转换
从零开始的文本到语音转换简介
towardsdatascience.com](/how-to-get-started-with-google-text-to-speech-using-python-485e43d1d544) 
照片由爱丽丝·多诺万·劳斯在 Unsplash 上拍摄
结论:
我们已经讲述了光学字符识别的一些概念，直观地了解了 OCR 处理流程是如何工作的。我希望开始使用 python 学习 OCR 技术的安装过程得到了简化，并且所有人都能达到预期的效果。我们理解了 pytesserac 模块的一些功能，并最终编写了一个代码，将 gTTS 和 pytesserac 模块结合起来。
在本主题语言模型设计的下一部分，我们将研究如何使用深度学习技术以及 OCR 和 TTS(文本到语音)来开发一个很酷的项目。
我强烈推荐你们所有人查阅下面的参考资料，以便更好地掌握和学习这些概念。如果您有任何疑问，请告诉我，祝您有美好的一天！
参考资料:
- 光学字符识别综合指南—https://moov.ai/en/blog/optical-character-recognition-ocr/
- 使用 Tesseract、OpenCV 和 Python 进行 OCR 的综合指南—https://nanonets.com/blog/ocr-with-tesseract/
- 使用 Google 的 Tesseract 和 OpenCV 构建您自己的光学字符识别(OCR)系统—https://www . analyticsvidhya . com/blog/2020/05/build-your-own-OCR-Google-tessera CT-OpenCV/
- 免费打造自己的 OCR(光学字符识别)——https://medium . com/@ Bala ajip/Optical-Character-Recognition-99 ABA 2 dad 314
- 光学字符识别—https://en.wikipedia.org/wiki/Optical_character_recognition
熊猫时序功能入门
提高数据分析速度的 3 种技巧
Pandas 具有分析时间序列数据的特殊功能，包括自动日期解析、高级过滤功能和几个特定于日期的绘图功能。
我发现自己几乎每天都在使用这些功能，但我花了很长时间才发现它们:Pandas datetime 的许多功能并不明显，而且我在开始时并没有使用这些功能。
但是使用这些功能很容易，而且无论何时处理时间序列数据，都有助于提高分析速度。
为了帮助你开始，这里有 3 个我最常用的时间序列特征。
1.自动解析时间序列数据
Pandas 可以自动将数据集中的列解析成时间序列数据，而不需要您指定任何正则表达式模式。
假设您正在分析一个数据集，其中前五行如下所示。
带有日期时间字段的示例表
您可以看到列date看起来像一个时间序列，我们将该列中的值转换为 Pandas datetime 类型是有意义的。
要指示 Pandas 转换这些值，在加载数据时使用parse_dates参数。
注意:
parse_dates参数在所有熊猫数据加载函数中都可用，包括read_csv。
>>> import pandas as pd
>>> df = pd.read_csv('[http://bit.ly/30iosS6](http://bit.ly/30iosS6)', parse_dates=['date'])
>>> df.info()
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 360 entries, 0 to 359
Data columns (total 2 columns):
# Column Non-Null Count Dtype
--- ------ -------------- -----
0 dau 360 non-null int64
1 date 360 non-null datetime64[ns]
dtypes: datetime64[ns](1), int64(1)
memory usage: 5.8 KB
注意列date的Dtype是如何变为datetime64[ns]的。您现在可以在date列上使用 Pandas 的所有特殊 datetime 方法。
>>> df.date.dt.day_name()
0 Tuesday
1 Wednesday
2 Thursday
3 Friday
4 Saturday
...
2.过滤时间戳索引
当数据帧的索引是一个datetime类型时，Pandas 提供了方便的过滤方法。
>>> df.set_index('date', inplace=True)
>>> df.index
DatetimeIndex(['2019-01-01', ... ,'2019-12-26'])
例如，您可以通过向 DataFrame 的loc访问器传递一个字符串来选择一个特定的日期。
>>> df.loc['2019-02-01']
dau 554
Name: 2019-02-01 00:00:00, dtype: int64
你也可以使用字符串来选择数据范围，即分割数据帧。
>>> df.loc['2019-02-01':'2019-03-01']
dau
date
2019-02-01 554
2019-02-02 798
...
2019-02-28 569
2019-03-01 599
注意，索引是最后一个值的和。我们使用2019-03-01作为我们选择的范围的结尾，所以标签为2019–03–01的行包含在结果数据帧中。
您甚至可以传入部分字符串来选择特定范围的数据。
>>> df.loc['2019-03']
dau
date
2019-03-01 599
2019-03-02 724
...
2019-03-30 724
2019-03-31 638
3.快速绘制时间序列数据
最后但同样重要的是，您可以使用 Pandas plot函数轻松绘制时间序列数据。
>>> df.plot()
自动生成的日期时间图
注意 Pandas 是如何使用 X 轴的数据帧索引的。
当然，这个图表不是很有帮助。让我们使用一个聚合视图来产生更具可读性的东西。
为此，我们可以使用 DataFrame 的resample方法按月聚合 timeseries 索引。然后，我们将计算每个月的mean,并创建结果的条形图。
>>> df.resample('M').mean().plot.bar()
时序索引的汇总视图
关于如何在 Pandas 中快速生成图表的更多细节，你可以阅读我的文章“用 Pandas 快速绘图”。
使用这些简单的内置函数快速可视化您的数据
towardsdatascience.com](/the-best-pandas-plotting-features-c9789e04a5a0)
感谢阅读！我经常在 Medium 上写关于数据科学和编程技巧的文章，所以请关注我以获得更多类似本文的文章。
R 并行编程入门
在多个 CPU 内核之间分配工作
图片来自 Pixabay
我为什么要看这篇文章？
尽管 R 中有许多关于并行计算的好资料，但很少有人以这样一种任何人都可以入门的基本方式解释这些概念。由于 R 的高级本质和强大的开源开发者社区，并行化基本和更复杂的任务非常简单。如果您熟悉apply系列函数(在数组或列表的索引上应用函数的函数)，只需增加三行代码就可以完成并行化！在本文中，我们将从“应用”功能的并行版本开始，扩展到更灵活的方法，最后通过一个来自财务优化的真实示例。
并行运行"apply" 功能
我们开始吧。假设我们有一个包含四个大向量的列表。对于四个大向量中的每一个，我们都要计算平均值。下面，使用传统的lapply方法计算平均值:
# Generate data
data <- 1:1e9
data_list <- list("1" = data,
"2" = data,
"3" = data,
"4" = data)# Single core
time_benchmark <- system.time(
lapply(data_list, mean)
)
这个计算用了 18.33 秒。用 18 秒来计算四个简单的平均值？我们没有时间了。事实证明，我们不需要这么做。上面执行的四个计算是完全独立的。即它们不相互依赖。第 1 项的含义绝不取决于第 2 项的含义。默认情况下，R 中的大多数功能都运行在一个处理核心上。随着当今大多数系统采用多核处理器，通过简单地将任务划分到多个内核上来减少运行时间的潜力是非常显著的。图书馆parallel帮助我们实现这一目标。下面，使用来自parallel库的lapply ( parLapply)的多核等价物来实现相同的计算:
library(parallel)# Detect the number of available cores and create cluster
cl <- parallel::makeCluster(detectCores())# Run parallel computation
time_parallel <- system.time(
parallel::parLapply(cl,
data_list,
mean)
)# Close cluster
parallel::stopCluster(cl)
这个计算用了 4.99 秒。通过添加三行代码，计算时间几乎减少了 75%！这就是现代多核 CPU 的好处。我使用四核 CPU，在四个核而不是一个核上运行四个计算，速度提高了四倍(嗯，由于计算机科学的原因，我没有足够的智慧来解释这一点)。这是您开始使用 r 中的并行计算所需要的全部内容。如果您只需要 apply 函数，那就自己动手吧。否则，请继续阅读，我们将用一种提供更多灵活性的方法进行更深入的研究。
并行运行循环迭代
比起一个apply 函数，你更喜欢并行一个传统的循环吗？那么foreach库就是你的解决方案。foreach函数的工作方式很像传统的循环，但是除了索引之外，它还需要关于如何构建输出以及在多核循环中应该可以访问哪些库的信息。因为我们的均值计算是使用基 R 函数执行的，所以不需要将任何包传递给foreach。同样，平均值的计算是这样实现的:
library(doParallel)
library(parallel)
library(foreach)# Detect the number of available cores and create cluster
cl <- parallel::makeCluster(detectCores())# Activate cluster for foreach library
doParallel::registerDoParallel(cl)time_foreach <- system.time({
r <- foreach::foreach(i = 1:length(data_list),
.combine = rbind) %dopar% {
mean(data_list[[i]])
}
})
time_foreach[3]# Stop cluster to free up resources
parallel::stopCluster(cl)
在 5.03 秒时，计算时间与parLapply实现的时间没有显著不同。这里重要的是使用了同名库中的foreach函数。它具有与 for 循环类似的功能，但同时在多个内核上执行迭代。这意味着迭代之间不存在依赖性。这里有两个输入被传递给函数；与常规循环一样的索引，以及如何组合输出。rbind将输出绑定为行。foreach提供了很大的灵活性，因为你可以完成几乎与传统循环相同的任务——假设每次迭代的结果之间不存在依赖关系。
并行运行投资组合优化
现在让我们尝试一个更现实的问题。可能很少有人有一个四个向量的列表，并想计算每个向量的平均值。在这一节中，我想说明你刚刚学到的东西在均值计算之外是有用的。具体来说，在我自己的计算金融领域。在计算金融中，经常需要通过运行 10、100 或 1000 次相当大的优化算法来模拟性能。通过适当的简化，这个问题很容易并行处理。
投资组合优化是在给定最大容许风险量的情况下，寻找具有最大预期回报的投资组合的艺术，反之亦然。预期回报通常以平均历史回报给出，风险以历史回报的标准差(或类似的度量)给出。这是一门有缺陷的艺术，因为它假设未来和过去一样。一位智者(苏伦·克尔凯郭尔)曾经说过，生活只能向后理解，但必须向前生活。不幸的是，在量化金融领域也是如此。
投资组合优化不能告诉你应该承担多大的风险。如果你还年轻，正在为退休储蓄，你可能应该承担相当大的风险，因为你不打算很快取出这笔钱，从长期来看，风险投资会获得更好的回报。如果你正在攒钱准备明年买房，那么降低风险是明智之举。高风险和低风险的投资组合都有一个共同点，那就是它们应该是最优的权衡。你希望在一定的风险下获得尽可能多的回报。所有这些最优投资组合都可以在一个名为“有效边界”的图表中可视化，这是我们将在第三部分也是最后一部分构建的。
首先，为了并行化和财务优化，有必要加载库:
# Load parallelisation libraries
library(doParallel)
library(foreach)
library(parallel)# Load finance and optimization libraries
library(PerformanceAnalytics)
library(PortfolioAnalytics)
require(ROI)
require(ROI.plugin.glpk)
require(ROI.plugin.quadprog)
require(quadprog)
您已经熟悉了前三个库。剩下的五个是金融数学和优化的专用库:
PerformanceAnalytics—用于计算绩效和风险指标的函数库PortfolioAnalytics—用于构建和分析金融投资组合的函数库ROI、ROI.plugin.glpk、ROI.plugin.quadprog、quadprog—用于优化的库
从PerformanceAnalytics库中，可以加载包含 13 种工具的财务回报的样本数据集:
# Load sample return data from the PerformanceAnalytics library
lookback <- 120 # lookback in months
returns <- tail(PerformanceAnalytics::edhec, lookback)
我们选择使用过去十年的回报数据来进行投资组合优化，从而假设不久的将来会像过去十年一样。对于投资组合，我们希望只进行长期投资(投资正金额)，完全投资(投资整个预算)投资组合，以最小化风险。最小化的风险度量是 ETL(预期尾部损失/风险条件价值/执行短缺)——一种具有理想财务属性的风险度量。如果你不熟悉这个指标，就假设它相当于收益的标准差。如果投资组合的价值波动很大，风险就大。以下代码创建要优化的投资组合对象:
# Create portfolio object
names_funds <- colnames(returns)
port.obj <- PortfolioAnalytics::portfolio.spec(assets = names_funds)
port.obj <- PortfolioAnalytics::add.constraint(portfolio = port.obj,
type = "full_weight")
port.obj <- PortfolioAnalytics::add.constraint(portfolio = port.obj,
type="long_only")
port.obj <- add.objective(portfolio=port.obj,
type='risk',
name='ETL',
arguments=list(p=0.95))
现在，为了计算有效边界，有必要知道从给定的工具领域构建的投资组合可以实现的最大预期回报和最小风险:
# Define maximum achievable return
ER_assets <- colMeans(returns)
ER_assets_max <- max(ER_assets)# Calculation of return of minimum risk portfolio
weights_ES_min <- PortfolioAnalytics::optimize.portfolio(
R = returns,
portfolio = port.obj,
optimize_method = "ROI",
trace = FALSE)$weights
ER_ES_min <- sum(weights_ES_min * ER_assets)# Vector of return targets
n_portfolios <- 500
return_targets <- seq(ER_ES_min,
ER_assets_max,
length.out = n_portfolios)
最大预期收益很容易找到，它就是回望期内平均收益最大的投资组合。由于分散效应，最小化风险的投资组合稍微复杂一些。我们通过求解优化问题找到投资组合，而无需指定回报目标，并计算该投资组合的预期回报。最后，定义最小值和最大值之间的 500 个等间距返回目标的向量。
对于这种多核优化，将再次使用foreach。然而，计算稍微复杂一些，因此将多核循环中的内容定义为函数是有益的。这使得指定输出等的格式变得简单。该函数定义如下:
# Write optimization function that returns exactly what we need.
optimise <- function(port.obj,
return_target) {
port.obj <- PortfolioAnalytics::add.constraint(
portfolio = port.obj,
type="return",
return_target = return_target)
out <- PortfolioAnalytics::optimize.portfolio(
R = returns,
portfolio = port.obj,
optimize_method = "ROI",
trace = FALSE)
return(c(out$weights, out$objective_measures$ETL))
}
优化功能将目标回报约束添加到我们的投资组合中，确定最佳投资组合，并以向量形式回报工具权重和风险。这是在foreach循环中实现的，与之前一样:
# Activate cluster for foreach library and pass libraries
cl <- parallel::makeCluster(detectCores())
doParallel::registerDoParallel(cl)time_foreach <- system.time({
data_frontier_par <- foreach::foreach(
i = 1:n_portfolios,
.combine = rbind,
.packages = c("PortfolioAnalytics")) %dopar% {
optimise(port.obj, return_targets[i])
}
})parallel::stopCluster(cl)
foreach函数将循环的索引作为输入，如何组合输出和循环中引用的库。定义这三个输入后，只需插入优化函数，500 次优化运行在 1.91 秒内完成。foreach的一个有用特性是，通过将%dopar%改为%do%，它可以被修改为在单核上运行。如果你有一个咄咄逼人的老板，需要一个借口去喝咖啡(或者如果你想对单核的计算时间进行基准测试)，这是一个很好的功能。在单核上，500 次优化运行在 5.05 秒内完成——这一次，并行化并没有使我们的运行时间减少 75%。这是因为将库加载到所有四个核心上需要时间。由此产生的有效边界看起来如下:
每单位风险的最佳回报可能是 3% ETL 左右，但选择哪个投资组合取决于你。沿着边界的所有投资组合都给出了其风险量的最优回报，因此可以被理性的投资者选择。
结论
我希望这篇文章能让你并行运行 R 脚本，从而帮助你加快速度！随着 CPU 性能向更多内核而不是更高频率发展，不利用并行化将是一种浪费。在 R 中，只需在正确的位置添加几行代码，您的计算速度就可以提高数倍。
评论
本文中的代码运行在 Windows 系统上。对于 Linux 或 Mac，考虑用mclapply替换parLapply。可能需要更多的修改。
参考
PyPy 入门
使用 PyPy 启动并运行，PyPy 是使用 JIT 编译的 CPython 的替代方案。
Python 编程语言是一种可以用多种方式实现的接口。一些例子包括使用 C 语言的 CPython，使用 Java 实现的 Jython 等等。
尽管是最流行的，CPython 并不是最快的。PyPy 是另一种 Python 实现，既兼容又快速。PyPy 依赖于实时(JIT)编译，这大大减少了长时间运行操作的执行时间。
在本教程中，将为初学者介绍 PyPy，以突出它与 CPython 的不同之处。我们还将讨论它的优点和局限性。然后我们将看看如何下载并使用 PyPy 来执行一个简单的 Python 脚本。PyPy 支持数百个 Python 库，包括 NumPy 。
具体来说，本教程涵盖以下内容:
- CPython 的快速概述
- PyPy 及其特性介绍
- PyPy 限制
- 在 Ubuntu 上运行 PyPy
- PyPy 与 CPython 的执行时间
让我们开始吧。
由 https://unsplash.com/photos/95YRwf6CNw8克莱门特 H : 改编自 Unsplash
CPython 的快速概述
在讨论 PyPy 之前，了解 CPython 的工作原理是很重要的。我上一篇名为用 Cython 提升 Python 脚本的教程详细介绍了 CPython 的工作原理，但是在这里快速回顾一下要点也无妨。下面你可以看到一个使用 CPython 实现的 Python 脚本的执行管道的可视化。
给定一个 Python .py脚本，首先使用 CPython 编译器将源代码编译成字节码。字节码被生成并保存在扩展名为.pyc的文件中。然后在虚拟环境中使用 CPython 解释器执行字节码。
使用编译器将源代码转换成字节码有很多好处。如果不使用编译器，那么解释器将通过逐行翻译成机器码来直接处理源代码。这样做的缺点是必须应用一些过程来将源代码的每一行翻译成机器代码，并且这些过程将对每一行重复。例如，语法分析将独立于其他行应用于每一行，因此解释器需要花费大量时间来翻译代码。编译器解决了这个问题，因为它能够一次处理所有代码，因此语法分析将只应用一次，而不是应用于每一行代码。因此，编译器生成的字节码很容易解释。注意，编译整个源代码在某些情况下可能没有帮助，我们将在讨论 PyPy 时看到一个明显的例子。
字节码生成后，由运行在虚拟机上的解释器执行。虚拟环境是有益的，因为它将 CPython 字节码与机器隔离开来，从而使 Python 跨平台。
不幸的是，仅仅使用编译器来生成字节码不足以加速 CPython 的执行。解释器的工作原理是每次执行代码时，将代码翻译成机器代码。因此，如果一个行L需要X秒来执行，那么执行它 10 次将会有X*10秒的开销。对于长时间运行的操作，这在执行时间上代价太高。
基于 CPython 的弊端，我们现在来看看 PyPy。
PyPy 及其特性介绍
PyPy 是一个类似于 CPython 的 Python 实现，既兼容又快速。“兼容”意味着 PyPy 与 CPython 兼容，因为您可以在 PyPy 中使用几乎所有的 CPython 语法。有一些兼容性的差异，如这里提到的。PyPy 最强大的优势就是速度。PyPy 比 CPython 快很多；稍后我们将看到 PyPy 执行速度快 7 倍的测试。在某些情况下，它甚至可能比 CPython 快几十倍或几百倍。那么 PyPy 是如何实现它的速度的呢？
速度
PyPy 使用实时(JIT)编译器，能够显著提高 Python 脚本的速度。CPython 中使用的编译类型是超前的(AOT)，这意味着所有的代码在执行之前都会被转换成字节码。JIT 只是在运行时翻译代码，只是在需要的时候。
源代码可能包含根本不执行的代码块，但这些代码块仍在使用 AOT 编译器进行翻译。这导致处理时间变慢。当源代码很大并且包含数千行时，使用 JIT 会有很大的不同。对 AOT 来说，整个源代码都需要翻译，因此需要很多时间。对于 JIT，只执行代码中需要的部分，这样速度会快很多。
PyPy 翻译了一部分代码后，就会被缓存。这意味着代码只被翻译一次，以后再使用。每次执行代码时，CPython 解释器都要重复翻译，这也是它运行缓慢的另一个原因。
容易的
PyPy 不是提升 Python 脚本性能的唯一方法，但却是最简单的方法。例如，Cython 可以用来提高向变量分配 C 类型的速度。问题是 Cython 要求开发人员手动检查源代码并进行优化。这很烦人，而且随着代码大小的增加，复杂性也在增加。当使用 PyPy 时，您只需更快地运行常规 Python 代码，无需任何努力。
无栈
标准 Python 使用 C 栈。这个堆栈存储相互调用的函数序列(递归)。因为堆栈的大小是有限的，所以函数调用的次数也是有限的。
PyPy 使用了无栈 Python ，这是一个不使用 C 栈的 Python 实现。相反，它将函数调用存储在对象旁边的堆中。堆的大小大于栈的大小，因此你可以做更多的函数调用。
无栈 Python 也支持微线程，比普通的 Python 线程要好。在单个无堆栈 Python 线程中，您可以运行数千个任务，称为“小任务”，所有这些任务都在同一个线程上运行。
使用微线程允许运行并发任务。并发意味着两个任务通过共享相同的资源同时工作。一个任务运行一段时间，然后停下来为第二个任务腾出空间。请注意，这与并行不同，并行涉及同时单独运行两个任务。
使用微线程减少了创建的线程数量，从而减少了操作系统管理所有这些线程的开销。因此，通过在两个线程之间交换来加速执行比在两个微线程之间交换更耗时。
使用无堆栈 Python 也为实现延续打开了大门。延续允许我们保存任务的状态，并在以后恢复它以继续它的工作。注意，无栈 Python 与标准 Python 没有什么不同；它只是增加了更多的功能。标准 Python 中可用的一切也将在无堆栈 Python 中可用。
在讨论了 PyPy 的好处之后，我们在下一节讨论它的局限性。
PyPy 限制
虽然您可以在任何机器和任何 CPU 架构上使用 CPython，但是 PyPy 的支持相对有限。
以下是 PyPy ( 来源)支持和维护的 CPU 架构:
- x86 (IA-32)和 x86_64
- ARM 平台(ARMv6 或 ARMv7，带 VFPv3)
- AArch64
- PowerPC 64 位，小端和大端
- 系统 Z (s390x)
PyPy 不能在所有的 Linux 发行版上工作，所以你必须小心使用一个受支持的版本。在不受支持的发行版上运行 PyPy Linux 二进制文件将会返回错误。PyPy 只支持 Python 2 和 Python 3 的一个版本，分别是 PyPy 2.7 和 PyPy 3.6。
如果在 PyPy 中执行的代码是纯 Python，那么 PyPy 提供的速度通常是显而易见的。但是如果代码包含 C 扩展，比如 NumPy，那么 PyPy 实际上可能会增加时间。PyPy 项目正在积极开发中，因此将来可能会为 C 扩展提供更好的支持。
许多流行的 Python 框架都不支持 PyPy，比如 Kivy。Kivy 允许 CPython 在所有平台上运行，包括 Android 和 iOS。这意味着 PyPy 不能在移动设备上运行。
现在我们已经看到了 PyPy 的优点和局限性，让我们来看看如何在 Ubuntu 上运行 PyPy。
在 Ubuntu 上运行 PyPy
您可以在 Mac、Linux 或 Windows 上运行 PyPy，但是我们将讨论在 Ubuntu 上运行它。再次提及 PyPy Linux 二进制文件仅在特定的 Linux 发行版上受支持是非常重要的。您可以在这个页面上查看可用的 PyPy 二进制文件及其支持的发行版。例如，PyPy(Python 2.7 或 Python 3.6)仅支持 Ubuntu 的三个版本:18.04、16.04 和 14.04。如果你有最新版本的 Ubuntu(19.10)，那么你不能在上面运行 PyPy。尝试在不受支持的发行版上运行 PyPy 将返回以下错误:
pypy: error while loading shared libraries ...
我只是简单的用一个虚拟机运行 Ubuntu 18.04。
PyPy 二进制文件以压缩文件的形式出现。你需要做的就是解压你下载的文件。在解压缩的目录中有一个名为bin的文件夹，在其中可以找到 PyPy 可执行文件。我使用的是 Python 3.6，因此这个文件被命名为pypy3。对于 Python 2.7，只是叫pypy。
对于 CPython，如果想从终端运行 Python 3，只需输入命令python3。要运行 PyPy，只需发出命令pypy3。
在终端中输入pypy3命令可能会返回Command 'pypy3' not found消息，如下图所示。原因是 PyPy 的路径没有添加到 path 环境变量中。实际运行的命令是./pypy3，考虑到终端的当前路径在 PyPy 的bin目录中。点.表示当前目录，添加/是为了访问当前目录中的内容。发出./pypy3命令成功运行 Python，如下所示。
现在，您可以像往常一样使用 Python，充分利用 PyPy 的优势。例如，我们可以创建一个简单的 Python 脚本，对 1，000 个数字求和，并使用 PyPy 执行它。代码如下。
nums = range(1000)
sum = 0
for k in nums:
sum = sum + k
print("Sum of 1,000 numbers is : ", sum)
如果这个脚本被命名为test.py，那么您可以简单地使用下面的命令运行它(假设 Python 文件位于 PyPy 的bin文件夹中，这与pypy3命令的位置相同)。
./pypy3 test.py
下图显示了执行前面代码的结果。
PyPy 与 CPython 的执行时间
为了比较 PyPy 和 CPython 对 1，000 个数字求和的运行时间，代码被更改为测量时间，如下所示。
import timet1 = time.time()
nums = range(1000)
sum = 0
for k in nums:
sum = sum + k
print("Sum of 1,000 numbers is : ", sum)
t2 = time.time()
t = t2 - t1
print("Elapsed time is : ", t, " seconds")
与 CPython 的0.0002秒相比，PyPy 的时间接近0.00045秒(我在我的 Core i7-6500U 机器上运行代码@ 2.5GHz)。在这种情况下，与 PyPy 相比，CPython 花费的时间更少，这是意料之中的，因为这个任务实际上不是一个长时间运行的任务。如果代码改为添加 100 万个数字，而不是 1000 个，那么 PyPy 将最终获胜。在这种情况下，Pypy 需要0.00035秒，CPython 需要0.1秒。PyPy 的好处现在很明显。这应该让您了解 CPython 在执行长时间运行的任务时会慢多少。
本文原载于 Paperspace 博客 。你可以在渐变 上免费运行我的教程 的代码。
结论
本教程介绍了 PyPy，这是最快的 Python 实现。PyPy 的主要优点是它的实时(JIT)编译，它提供了对编译后的机器码的缓存以避免再次执行。PyPy 的局限性也得到了强调，主要的一点是它对于纯 Python 代码来说工作得很好，但是对于 C 扩展来说效率不高。
我们还看到了如何在 Ubuntu 上运行 PyPy，并比较了 CPython 和 PyPy 的运行时间，突出了 PyPy 对于长时间运行任务的效率。与此同时，对于短期运行的任务，CPython 仍可能击败 PyPy。在以后的文章中，我们将探索 PyPy、CPython 和 Cython 之间的更多比较。
Python 类入门
Python 中的面向对象编程
在计算机编程中，类是组织数据和函数的一种方便的方式，这样它们以后就易于重用和扩展。在这篇文章中，我们将介绍如何用 python 构建一个基础类。具体来说，我们将讨论实现表示 instagram 用户的类的示例。
我们开始吧！
首先，让我们定义一个代表 Instagram 用户的简单类。最初我们不会包含任何数据(属性)或函数(方法):
class Instagram_User:
pass
在面向对象编程中需要理解的两个重要概念是类和类实例。Instagram 平台的用户可以被视为“Instagram_User”类的一个实例。这里的区别是‘Instagram _ User’类作为创建 insta gram 用户的蓝图，而‘insta gram _ User’类的一个实例可能指的是一个特定的用户。为此，我们可以定义两个 Instagram 用户实例，insta_user_1 和 insta_user_2:
insta_user_1 = Instagram_User()
insta_user_2 = Instagram_User()
这些用户中的每一个都将是他们自己的 Instagram_User 类的唯一实例。我们可以打印这两个对象:
print("User Object 1: ", insta_user_1)
print("User Object 2: ", insta_user_2)
这里我们可以看到每个对象都有一个唯一的内存地址。接下来，我们可以为每个实例创建变量。让我们定义保存每个用户的用户名的实例变量:
insta_user_1.user_name = 'nychef100'
insta_user_2.user_name = 'worldtraveler123'
我们还可以定义每个用户的名称:
insta_user_1.name = 'Jake Cohen'
insta_user_2.name = 'Maria Lopez'
电子邮件地址:
insta_user_1.email = 'jcohen100@gmail.com'
insta_user_2.email = 'mlopez123@gmail.com'
最后，让我们定义一个实例变量，告诉我们每个用户是否有私人帐户:
insta_user_1.private = True
insta_user_2.private = False
现在，每个实例都有对每个用户唯一的属性值。让我们打印用户名:
print(insta_user_1.user_name)
print(insta_user_2.user_name)
理想情况下，我们希望为每个用户自动设置所有这些信息，而不是手动设置这些值。为了获得类的全部好处，我们应该定义一个方法，允许我们用手动定义的值初始化每个用户实例。初始化方法基本上是一个构造函数，将被称为“init ”:
class Instagram_User:
def __init__(self, user_name, name, email, private):
self.user_name = user_name
self.name = name
self.email = email
self.private = private
这里,“self”参数是实例，它允许我们在实例中共享属性信息。例如，当我们写下:
insta_user_1 = Instagram_User('nychef100', 'Jake Cohen', 'jcohen100@gmail.com', True)
insta_user_2 = Instagram_User('worldtraveler123', 'Maria Lopez', 'mlopez123@gmail.com', False)
每种情况下的“self”参数分别是 insta_user_1 和 insta_user_2 对象。如果我们打印电子邮件，我们会看到:
print(insta_user_1.email)
print(insta_user_2.email)
这允许我们用比手工定义属性少得多的代码来定义属性。现在假设我们想要对每个用户的属性执行一些操作。例如，我们可以定义一个方法来告诉我们一个用户是否有一个私人帐户。在我们的方法中，如果' self.private '为真，我们打印“用户有一个私人帐户”，否则，我们打印“用户有一个公共帐户”:
def isPrivate(self):
if self.private:
print("{} has a Private Account".format(self.name))
else:
print("{} has a Public Account".format(self.name))
完整的脚本应该如下所示:
class Instagram_User:
def __init__(self, user_name, name, email, private):
self.user_name = user_name
self.name = name
self.email = email
self.private = private
def isPrivate(self):
if self.private:
print("{} has a Private Account".format(self.name))
else:
print("{} has a Public Account".format(self.name))
让我们使用 insta_user_1 实例调用该方法:
insta_user_1.isPrivate()
在 insta_user_2 上:
insta_user_2.isPrivate()
如您所见，由于“self”参数被传递给了“init”和“isPrivate”，因此在初始化时，“isPrivate”方法可以完全访问相应实例的属性。
我将在这里停下来，但是您可以随意摆弄代码。例如，您可以尝试定义 Instagram_User 类的几个额外的用户实例。在那里，您可以练习提取实例属性并使用类方法“isPrivate”。一旦你觉得舒服了，我鼓励你定义额外的类方法。一个有趣的方法是显示用户指标，比如关注者数量、用户关注的人数和帖子数量。
结论
总之，在这篇文章中，我们讨论了用 python 定义类的基础。我们展示了如何定义类的实例、初始化实例、访问实例属性以及用方法操作属性。这篇文章的代码可以在 GitHub 上找到。感谢您的阅读！
PyTorch 入门
关于如何使用 PyTorch 进行数据分析和推断的实践演练。
伊霍尔·马里茨基在 Unsplash 上拍摄的照片
介绍
PyTorch 是目前发展最快的深度学习 Python 框架之一。事实上，这个库最初主要由研究人员使用，以创建新的模型，但由于最近的进步，它也引起了许多公司的兴趣。对该框架感兴趣的一些原因是:
- GPU 优化的张量计算(类似矩阵的数据结构)使用非常类似 Numpy 的接口，以便于采用。
- 使用自动微分的神经网络训练(跟踪发生在张量上的所有操作并自动计算梯度)。
- 动态计算图(使用 PyTorch，不需要像在 Tensorflow 中那样为了运行模型而首先定义整个计算图)。
PyTorch 可以按照文档说明免费安装在任何操作系统上。组成该库的一些主要元素是:
- 自动签名 模块:用于记录在张量上执行的操作，并反向执行这些操作以计算梯度(该属性对于加速神经网络操作和允许 PyTorch 遵循命令式编程范例非常有用)。
- Optim 模块:用于方便地导入和应用各种神经网络训练的优化算法，如 Adam、随机梯度下降等..
- nn 模块:提供一组函数，可以帮助我们快速逐层设计任何类型的神经网络。
示范
在本文中，我将带您通过一个实际的例子来开始使用 PyTorch。本文中使用的所有代码(以及更多！)可以在我的 GitHub 和 Kaggle 账户上使用。对于这个例子，我们将使用澳大利亚Kaggle Rain数据集来预测明天是否会下雨。
导入库
首先，我们需要导入所有必需的库。
数据预处理
对于这个例子，我们将重点使用 RISK_MM 和 Location 指标作为我们的模型特征(图 1)。将数据划分为训练集和测试集后，我们可以将 Numpy 数组转换为 PyTorch 张量，并创建一个训练和测试数据加载器，以便将数据输入到我们的神经网络中。
图 1:简化的数据帧
系统模型化
此时，使用 PyTorch nn 模块，我们就可以设计我们的人工神经网络(ANN)了。在 PyTorch 中，神经网络可以定义为由两个主要函数构成的类: inti() 和 forward() 。
在 inti() 函数中，我们可以设置我们的网络层，而在【forward()函数中，我们决定如何将我们网络的不同元素堆叠在一起。这样，只需在【forward()函数中添加打印语句，就可以相对容易地进行调试和试验，以便在任何时间点检查网络的任何部分。
此外，PyTorch 还提供了一个顺序接口，可以使用该接口以类似于使用 Keras Tensorflow API 构建模型的方式来创建模型。
在这个简单的网络中，我们将 50 个特征作为输入，因为我们之前使用 Pandas get_dummies() 功能将输入分类变量转换为虚拟/指示变量。因此，我们的网络将由 50 个输入神经元、20 个神经元的隐藏层和单个神经元的输出层组成。隐藏层的大小当然可以变化，并且可以很容易地添加更多的隐藏层，但是考虑到可用的数据量有限，这可能会导致过度拟合我们的数据的风险。将连续图层堆叠在一起时，我们只需确保一个图层的输出要素数量等于连续图层的输入要素数量。
一旦实例化了我们的模型，我们就可以打印出网络架构。
ANN(
(fc1): Linear(in_features=50, out_features=20, bias=True)
(fc2): Linear(in_features=20, out_features=1, bias=True)
)
神经网络训练
我们现在终于准备好训练我们的模型了。在下面的代码片段中，我们首先将二元交叉熵定义为我们的损失函数，将 Adam 定义为模型参数的优化器。最后，我们创建一个 7 次迭代的训练循环，并存储一些关键的度量参数，如每次迭代的总损失和模型精度。
Epoch: 0, Loss: 294.88, Accuracy: 0.13%
Epoch: 1, Loss: 123.58, Accuracy: 6.31%
Epoch: 2, Loss: 62.27, Accuracy: 28.72%
Epoch: 3, Loss: 35.33, Accuracy: 49.40%
Epoch: 4, Loss: 22.99, Accuracy: 64.99%
Epoch: 5, Loss: 16.80, Accuracy: 71.59%
Epoch: 6, Loss: 13.16, Accuracy: 74.13%
正如图 2 所总结的，我们的模型成功地实现了良好的准确性，而没有过度拟合原始数据的风险(训练损失和准确性都即将达到平稳状态)。还可以通过实现训练/验证分割来训练我们的模型并调整其参数来进一步验证这一点(如本 GitHub 笔记本所示)。
图 2:培训报告
估价
最后，我们现在可以创建第二个循环来针对一些全新的数据测试我们的模型(为了确保我们的模型不再是训练模型，而是仅用于推理，请注意 model.eval() 语句)。
Test Accuracy: 74.66 %
从打印输出可以看出，我们的模型测试精度与我们的最终训练精度非常匹配(74.66 %对 74.13%)。
结论
如果您有兴趣了解 PyTorch 的更多潜力，PyTorch Lighting和 Livelossplot 是两个很棒的软件包，可以帮助您开发、调试和评估您的 py torch 模型。
希望您喜欢这篇文章，感谢您的阅读！
联系人
如果你想了解我最新的文章和项目，请通过媒体关注我，并订阅我的邮件列表。以下是我的一些联系人详细信息:
R 入门
https://www.r-project.org/logo/、知识共享署名-共享 4.0 国际许可 (CC-BY-SA 4.0)
我学过的第一门编码语言是 R，我很快就学会了，在学习 python 的同时，我的 R 知识绝对对我有帮助。我发现 R 和 python 在法语和意大利语方面很相似——虽然肯定有差异，但它们有很多共同点。为了庆祝 R 4 . 0 . 3 版本(标题惊人地叫“兔子-温尼斯怪胎”)在周六发布，我为 R 编译了一些我最喜欢的资源，以及一些额外的非语言特定但有用的资源。所有这些资源不仅精彩，而且免费！我希望你和我一样觉得它们很有帮助！
首先，我们有 R 本身，可以在 R:统计计算的 R 项目找到。如果你不知道的话，R 是免费的，而且是非常强大的统计和编码软件。要安装，进入 CRAN 页面，选择离你最近的位置。r 适用于所有三个主要系统；Mac、Windows 和 Linux。r 很棒，但是使用它最简单的方法是同时获得…
RStudio ！
RStudio 是一个集成开发环境，简称 IDE。和 R 一样，是免费的。基本上，如果 R 是打字机，RStudio 就是文字处理器。它使生活变得容易得多；使用 RStudio，您可以编辑代码、运行单个代码块、在语法不正确(最常见的错误来源之一)时获得警告、利用软件包(稍后将详细介绍)以及轻松访问帮助页面。可以在这里下载；只需选择“下载 RStudio 桌面”。RStudio 有在线版本，但这些都有相关费用。
Donny Jiang 在 Unsplash 上的照片
继续包装！R 有超过 10，000 个软件包，我可以写多篇文章。开始时，有几个特别有助于展示。
首先是 tidyverse 。即使你从未用过 R，你也可能听说过 tidyverse。这一组核心包是我日常使用的包。tidyr(用于数据清理)、dplyr(用于数据操作)、ggplot2(用于漂亮的可视化)、hms 和 lubridate(用于任何日期或时间数据)等等，将是你开始的基础。这应该是您在 R 和 RStudio 之后的第一次安装。100/10.
漩涡很优秀，因为它教你如何使用 R，在 R 。一旦你加载并打开了这个包，你可以从各种教程中选择，甚至从 GitHub 库下载额外的课程。这是让你熟悉 r 的一个很棒的方法。唯一的警告是，swirl 只在控制台上运行，并且不是非常 RStudio 笔记本友好。我仍然建议在 RStudio 的控制台中使用它，这只是需要注意的一点。如果你刚开始学 R，你需要这个包。
最后两个是相当基本的，但同样有用。 Stats 包含基本的统计功能，而 datasets 有数据集供您在入门时使用。
Hadley Wickham 和 Jennifer Bryan 的书 R Packages 也有助于找到适合你需求的特定软件包，Google 也是如此。说到这里，让我们继续看书吧！
R for Data Science :可视化、建模、转换、整理和导入数据，作者 Garrett Grolemund 和 Hadley Wickham
它有一步一步的问题，以一种非常自然和可理解的方式进行，并且在大多数部分的结尾还有额外的练习。这本书可以教授 r 的基础知识。如果你正在寻找一种传统的方法，这是一个很好的选择——我们在我的大学统计学课程中使用过这本书。
R for Data Science:Exercise Solutions，作者 Jeffrey B. Arnold &供稿
这本书是 R for Data Science 的非正式指南，包含了 R for Data Science 中练习的示例解决方案。这可能非常有帮助，但是，需要注意的是，一些解决方案可能过于复杂，或者使用尚未涉及的策略，如果您正在按顺序学习 R for Data Science 的话。不过，它是免费的，当你真的被难住的时候，它是一个有用的资源。
数据可视化的基础知识:制作信息丰富和引人注目的图表的初级读本，作者克劳斯·威尔基
数据可视化圣经。是优秀的。它很好地分解了数据可视化的基础，并专注于主要原则，同时也解释了可视化的利弊。我每周至少送一次这本书给某人。这是一个相当快速的阅读，并且这本书的在线版本很容易搜索，以找到你想要参考的确切图表或数字。100000/10.我想要一本实体的作为生日礼物。
最后，最后但同样重要的是今天！TidyTuesday 是每周一次的数据科学和可视化挑战赛，它提供了清理、管理和可视化大型数据集的良好实践。当你厌倦了 R datasets 包时，过去的数据集也是很好的资源，因为它是开源的，所以浏览别人的代码，看看他们清理和可视化的方法会很有帮助。
情感分析入门
自然语言处理笔记
自然语言处理专业课程 1 第 1 周笔记
在我的前两个帖子之后，我认为我们有必要开始一条新的道路。我们将一起浏览自然语言处理中的基本概念，作为新手的起步，并提醒长期从业者决定阅读的时间——从情感分析开始。
注:这个系列的帖子将由我从 Coursera 上的自然语言处理专业中摘掉的笔记创建，我添加了额外的东西，因为我认为它很有用。
前两个帖子:
最近，一个特别的话题在我和朋友的讨论中反复出现。品牌的重要性！我…
towardsdatascience.com](/the-importance-of-branding-in-data-science-467b2d2b1e7f) [## 从长远来看，专业化的“数据科学家”将会胜出
成为专家会比成为多面手让你走得更远
towardsdatascience.com](/the-specialized-data-scientist-will-win-in-the-long-run-22c47342aa00)
在我们笔记中给出的例子中，我们打算用逻辑回归模型来拟合我们的特征。我不会深入研究逻辑回归的内部工作原理，但是如果你非常感兴趣，你可以从头开始阅读“ 算法:逻辑回归 ”。
与普遍的看法相反，我在此声明，逻辑回归不是一个分类算法(就其本身而言)…
towardsdatascience.com](/algorithms-from-scratch-logistic-regression-7bacdfd9738e)
情感分析
情感分析的目标是使用自然语言处理和机器学习来解释和分类主观数据。
随着世界变得更加数字化，情绪分析在今天的商业中是一项非常重要的技能，自新冠肺炎以来更是如此。许多企业采用情感分析来检测社会数据，更好地了解他们的品牌声誉，了解他们在数字世界中的客户。
例如，一个企业(或任何人)可能会决定使用情感分析来自动确定关于他们公司(或任何东西)的推文的极性，以便更好地了解他们品牌的声誉；这个任务可以定义为一个监督学习问题，我们将输入特征输入到一个预测模型中，然后得到一个输出。
图 1 :情感分析问题
为了让我们执行情感分析，我们必须首先将我们的文本表示为特征(我们在图 1 中表示为 X)，因为计算机不理解文本，在我们可以使用它来分类文本之前。
那么，我们如何提取特征呢？很棒的问题。方法有很多。然而，在我们提取我们的特征并建立逻辑回归模型来分类我们数据的情感之前，我们必须讨论文本预处理。
文本预处理
互联网上的文本通常被定义为非结构化数据——非结构化数据是没有预定义的数据模型或者没有以预定义的方式组织的信息(来源:维基百科)。因此，文本预处理就是将我们的文本组织成预定义的方式或预定义的数据模型。
有各种各样的技术可以用来预处理我们的文本，但是在这篇文章中，我们将主要关注其中的几种；
小写
这可能是最简单的文本预处理形式，我们可以确保所有的文本都是小写的。这种技术适用于许多文本挖掘和自然语言处理任务，当数据集很小时，这种技术非常有用。
图 2 :小写示例
值得注意的是，尽管小写通常是一种标准做法，但在某些情况下，保持大写是很重要的。
词干
当我们“词干”一个词形变化——在语言形态学中，词形变化是一个构词的过程，在这个过程中，一个词被修饰以表达不同的语法范畴，如时态、格、语态、体、人称、数、性别、语气、动物性、确定性(来源: 维基百科 )。例如，who 变成了 who 的——我们把它简化为词根形式。
有许多不同的词干提取算法，但是最常见和最有效的英语词干提取算法是 Porters 算法。
图 3 :用 PorterStemmer 在 Python 中进行词干分析
词干通常对处理稀疏性和/或标准化词汇很有用。
词汇化
词汇化通常是指使用词汇和单词的形态学分析来正确地做事情，通常旨在仅删除屈折词尾，并返回单词的基本形式或字典形式，这被称为词汇(来源:Stanford NLP Group)。
简单地说，词汇化旨在消除词尾变化，并以适当的方式将单词映射到其词根。
图 4 :使用 WordNetLemmatizer 的词汇化示例
注意:不要犯交替使用词干化和词汇化的错误——词汇化会对单词进行词法分析。
停用词
停用词是语言中的常用词。这些词通常被认为是对文本没有任何意义的词(它们不重要)，因此我们要把它们去掉。
图 5:NLTK 中的停用词列表
删除停用词并不总是有效的策略。在某些情况下，移除停用词往往是有用的，例如主题提取，但在各种分类任务中，我们可以通过保留停用词来获得有用的见解。
正常化
在文本可能有很多噪音的环境中，例如 twitter 和文本消息，规范化文本往往是一个重要但被忽视的步骤——我所说的噪音环境是指非正式很常见的地方。当我们规格化文本时，我们将文本转换成标准形式(即 nvm 变成 nevermind)。
图 6: 文本的规范化(来源:Kavita Ganesan—关于 NLP 和机器学习的文本预处理你需要知道的一切
文本规范化与词干化和词条化一样，没有标准的方法。这完全取决于手头的任务，因为我们不会像标准化讲课笔记那样标准化我们的短信(考虑到我们以非标准的方式记笔记)。
噪声去除
噪音会严重干扰我们的文本分析。例如，tweets 通常包含各种各样的特殊字符，当我们做进一步的预处理步骤时，这些字符可能会损害我们的结果。
图 7 :去噪前的词干处理与去噪后的词干处理—原始图片来自卡维塔·加内桑 — 关于自然语言处理和机器学习的文本预处理，你需要知道的一切
有各种形式的噪音要从我们的文本中去除；
- 特殊字符
- 数字
- 超文本标记语言
- 特定领域关键词(例如，RT 表示 Twitter 上的转发)
- 其他(还有很多)
我们移除哪些是领域特定的，哪些被确定为我们手头任务的“噪声”。
注:关于文本预处理的更多内容，我强烈推荐你阅读 Kavita Ganesan 的《 关于自然语言处理和机器学习的文本预处理 》。
特征提取
在将文本传递给逻辑回归模型之前，我们必须首先将文本表示为一个向量。我们有许多方法将文本表示为向量，但是对于我们的任务(情感分析)，我们将看两个向量表示；
- 一个热编码
- 正负频率
一键编码
为了做到这一点，我们必须创造一个词汇。这可以通过从我们的数据中的每一条推文中创建一个独特的单词列表来实现。
图 8 :创建词汇表我们检查每条推文的每个单词，并向词汇表 V 添加单词，前提是该单词不在我们的词汇表中。
为了提取特征，我们提取一条推文，并将其标记为“1 ”,以表明我们词汇表中的单词出现在推文中，如果我们词汇表中的单词没有出现在推文中，则标记为“0 ”,参见图 9。
图 9 :获取一条推文，并显示该推文在被应用一热编码后的特征向量。
由于我们的 tweet 的向量长度为 V(我们数据集中所有唯一的单词)，并且对于我们选择显示的特定 tweet，它们只有 5 个值为 1 的特征(“我讨厌去上学”)，但有许多 0(长度为 V-5)，我们有所谓的稀疏向量表示，简单地说就是我们有大量的零，因此我们占用了不需要的空间来存储零。
如果我们在我们的稀疏表示上训练我们的逻辑回归模型，我们的模型将不得不学习 n + 1(对于偏差)个参数，其中 n 等于我们的词汇的大小 V。随着 V 变得越来越大，我们将面临两个主要问题；
- 训练模型需要很长时间
- 推理时间长
正&负频率
克服稀疏表示问题的一种技术是将向量转换为正负频率计数。更具体地说，给定一个单词，我们想要跟踪该单词在正面类中出现的次数，给定另一个单词，跟踪该单词在负面类中出现的次数。有了这些计数，我们可以提取特征，并将它们用作 Logisitc 回归模型的输入特征。
为了执行正负频率技术，我们必须首先创建一个频率字典——频率字典只是给定目标标签的单词计数的映射。例如，我们有自己的词汇，我们计算一个词在正面推文中出现的次数，我们对负面推文也这样做。
图 10 :单词词典
为了将这转化为一个特征，我们简单地对推文中的每个词取正频率之和，然后取负频率之和——见图 11 。
图 11 :对于每条推文，输入特征将是【偏差，正词频，负词频】。
因此，我们有一个直观的例子，我们将以 tweet“我很难过，我不高”为例(因此Xm=“我很难过，我不高”)。在图 5 中，我们可以看到单词在整个数据集中出现的频率，分为正类和负类，因此我们所要做的就是获取我们的 tweet，并计算每个单词出现的次数——参见图 12 。
图 12 :提取推文“我很难过，我不高”的特征
因此，我们的逻辑回归模型的输入特征将是[1(偏差)，4 (PostiveWordCount)，10 (NegativeWordCount)]。
包裹
通过这篇文章，你现在知道了各种预处理方法和两种提取特征的方法，我们可以将这些特征传递给一个逻辑回归模型。实践今天所学内容的一个好方法是在真实数据上尝试。
让我们继续 LinkedIn 上的对话:
[## Kurtis Pykes -人工智能作家-走向数据科学| LinkedIn
在世界上最大的职业社区 LinkedIn 上查看 Kurtis Pykes 的个人资料。Kurtis 有一个工作列在他们的…
www.linkedin.com](https://www.linkedin.com/in/kurtispykes/)
Python 中的捕捉工具箱入门
SentiNel 应用程序，通常称为 SNAP，是一个适应性很强的开源软件，用于对地球观测卫星数据进行科学探索。
美国地质勘探局在 Unsplash 上拍摄的照片
SNAP 由欧洲航天局(ESA)开发，是一个支持哨兵任务的通用软件平台。它由几个模块组成，可以修改并重新用于地球观测卫星数据的图像处理、建模和可视化。SNAP 不仅可用作哨兵任务(哨兵 1、哨兵 2 和哨兵 3)的研究支持工具，还可用作有效处理大量卫星数据的功能出口，包括来自 Landsat、MODIS 和 RapidEye 等其他任务的各种不同格式的数据。SNAP 的项目页面和各个工具箱可以在 http://step.esa.int找到。
在本文中，我想一步一步地介绍配置 python 安装以使用 SNAP-Python 或“ snappy ”接口的过程。这样做将允许您通过使用 python 脚本自动执行图像处理任务来高效地分析大量卫星数据。
本文将涵盖以下主题:
- 在 Windows 上下载并安装最新的 SNAP 版本(7.0 版)，
- 在快照安装过程期间和之后配置 snappy，
- 建立一个虚拟环境，
- 为 snappy 和配置最佳设置
- 使用 snappy 可视化卫星数据
下载快照工具箱
捕捉由几个工具箱组成。您可以单独安装每个工具箱，也可以安装一体化版本。在本教程中，我们将安装后者。
快照工具箱可以从下面的链接下载:https://step.esa.int/main/download/snap-download/
创建虚拟环境
在你应该在你的系统上安装 SNAP 软件之前，我建议你使用 pip 或者 conda 创建一个虚拟环境。对于本教程，我们将使用 conda。要运行这个命令，您需要在系统上安装 Anaconda 或 Miniconda。
通过在系统的 python 配置命令行工具上执行以下命令，使用 python 2.7 版创建一个名为“snap”的新虚拟环境。
conda create -n snap python=2.7
我们使用 python 2.7 版本的原因是因为 SNAP 软件仅支持 python 2.7、3.3 和 3.4 版本。
注意:如果你使用 pip 来创建一个新的环境，你必须安装 venv 包。点击了解更多关于如何使用 venv 创建虚拟环境的信息。
卡扣安装
接下来，我们可以使用下载的可执行文件开始安装快照软件。
您可以将 python 安装配置为在快照安装期间使用 snappy，方法是选中复选框并提供 python 目录的路径(如下所示)。然而，在本教程中，我们将而不是检查复选框并在 SNAP 安装完成后配置 snappy。
安装过程的其余部分非常简单。第一次启动 SNAP 时，它会进行一些更新。完成后，您就可以开始使用快照软件了。
配置爽快的
snap 安装完成后，我们希望获得虚拟环境“SNAP”所在的目录位置。从这里开始，我们需要以下两条路径:
- 虚拟环境的 Python 可执行路径
- 虚拟环境目录中名为“Lib”的文件夹
打开作为 SNAP 软件一部分安装的 SNAP 命令行工具，并运行以下命令:
snappy-conf {path_to_snap_env}\python.exe {path_to_snap_env}\Lib\
更改可用 RAM 的数量
在我们开始使用 snappy 创建 python 脚本之前，我们需要做一些改变，以确保 snappy 操作符以最高的最优性运行。如果您计划进行一些图像渲染和批处理操作，默认设置会非常慢。如果您想使用 snappy 来自动化繁重的处理任务并处理多个文件，这一点很重要。
转到{ virtual _ env " snap " directory } > Lib > snappy。
打开名为“ snappy.ini”的 snappy 配置文件。
编辑名为" j ava_max_mem" 的参数值，并将其设置为相当于系统 RAM 70–80%的值。
java_max_mem: 26G
在同一个目录中，有一个名为“ jpyconfig.py”的文件。C 更改参数" jvm_maxmem" 如下 :
jvm_maxmem = '26G'
改变磁贴缓存内存
接下来，导航到安装快照软件的位置。默认情况下，它设置为 C:\Program Files\snap。在其中，您会找到名为 etc 的文件夹，其中包含名为“SNAP . properties”的快照属性文件。编辑文件并更改名为snap . jai . tile cachesize .的参数，将其设置为等于 java_max_mem 值的 70–80%的值。您输入的数字应该以兆字节为单位。您可能需要启用管理员权限来保存对此文件的更改。
snap.jai.tileCacheSize = 21504
注:此处显示的值适用于 32GB 内存的系统。更改时必须考虑到系统的 RAM。
开始使用 Snappy
因此，对于最后一部分，我们想探索 snappy 是如何工作的，并可视化一些样本数据。在我们开始使用 snappy 之前，我们需要一些数据，在本教程中，我们将使用 snappy 安装预加载的测试数据。
# Import Librariesimport os
import numpy as np
import matplotlib.pyplot as plt
import snappy
from snappy import ProductIO# Set Path to Input Satellite Data# miniconda users
path = r'C:\Users\{User}\miniconda3\envs\snap\Lib\snappy\testdata'# anaconda users
path = r'C:\Users\{User}\anaconda3\envs\snap\Lib\snappy\testdata'filename = 'MER_FRS_L1B_SUBSET.dim'# Read File
df = ProductIO.readProduct(os.path.join(path, filename))# Get the list of Band Names
list(df.getBandNames())# Using "radiance_3" band as an example
band = df.getBand('radiance_3') # Assign Band to a variable
w = df.getSceneRasterWidth() # Get Band Width
h = df.getSceneRasterHeight() # Get Band Height# Create an empty array
band_data = np.zeros(w * h, np.float32)# Populate array with pixel value
band.readPixels(0, 0, w, h, band_data) # Reshape
band_data.shape = h, w# Plot the band
plt.figure(figsize=(18,10))
plt.imshow(band_data, cmap = plt.cm.binary)
plt.show()
“radiance_3”波段图
我还制作了一个视频，展示了我在这篇文章中列出的所有内容。因此，如果对如何在 Python 中安装和配置 SNAP Toolbox 有任何困惑，请务必查看。
附加资源
- Github 页面:【https://github.com/senbox-org
- 为 Python 配置 SNAP:https://senbox . atlassian . net/wiki/spaces/SNAP/pages/50855941/Configure+Python+to+use+the+SNAP-Python+snappy+interface
- 写这篇文章时有用的论坛讨论
下午好，我是一名新的欧空局学员，我想实施 S2-tbx/sen2cor 的一些过程到一个…
forum.step.esa.int](https://forum.step.esa.int/t/snappy-where-to-start/1463/7) [## 使用 python 脚本运行捕捉工具箱的进程
你好，我是 SNAP 工具箱的新用户。我已经在我的 windows 机器上安装了 SNAP 4.0。我目前正在使用快照桌面…
forum.step.esa.int](https://forum.step.esa.int/t/run-processes-of-snap-toolbox-using-python-script/3021/3)
TensorFlow 服务入门
将深度学习模型部署到生产中的简单高效的方法
TensorFlow 服务是 TensorFlow Extended(TFX)的一部分，它使将您的机器学习模型部署到服务器比以往任何时候都更加舒适。在 Google 发布 TensorFlow 服务之前，您的模型必须使用 Docker 部署到生产中。使用 Docker 来部署您的模型是乏味的、耗时的，并且容易出现许多错误。TensorFlow Serving 为我们提供了一个 API，可以使用 HTTP 请求调用该 API 在服务器上运行推理。在这篇博客中，我们将提供一个情感识别模型，并通过它了解 TensorFlow 服务的基础。
PS:我不会在这个博客中解释关于训练情绪识别模型的事情。我只会说为模特服务。你可以在这里找到训练情绪识别模型的要领。您可以在这里找到本地运行模型的存储库。
为什么要为模特服务？
一旦您训练了您的模型，它必须被部署到生产中以便可以使用。可以使用各种方法来部署模型，比如使用 TFlite 在手机上本地部署，使用 TFjs 在网站上部署，创建 docker 容器在云上部署模型，等等。TensorFlow 服务优于其他方法，原因如下。
- 使用 TensorFlow Serving 比使用 Docker 更容易部署您的模型，它可以节省您的时间并防止不必要的错误。
- 与 TFlite 或 TFjs 相比，更容易管理模型的不同版本。
- 当模型被更新时，所有的客户端将使用相同版本的模型，因此结果将是一致的。
- 由于模型将在服务器上运行，您可以使用强大的计算资源，如 GPU 或 TPUs 来更快地运行推理。
- 由于该模型由一个 API 提供服务，因此它可以由 TensorFlow 不支持的不同编程语言使用。
安装张量流服务
TensorFlow 服务可以使用 Docker、apt package installer for Linux 或 pip package manager 进行安装。在这篇博客中，我们将重点介绍如何使用 apt 和 pip 来安装 TensorFlow 服务。
在您的生产环境的终端中运行下面给出的代码，以安装 TensorFlow 服务。您可以使用 apt 软件包安装程序或 pip 软件包管理器。
安装 TensorFlow 服务
建立和服务您的模型。
一旦您训练、测试和验证了您的模型，就该为您的模型服务了。
步骤 1:指定模型的版本号，并使用 tf.keras.models.save_model()函数或 model.save()函数将模型保存到 tmp 目录中。
保存模型
步骤 2:模型将通过 bash 命令提供服务。为了让 bash 命令访问模型目录，需要将模型目录添加到环境中。
向环境中添加模型目录
第 3 步:既然模型已经保存，就可以开始服务了。运行下面给出的 bash 命令来服务模型。
为模型服务
第 4 步:既然已经为您的模型提供了服务，那么您可以使用 tail 命令来检查 server.log 文件。如果您在日志中发现“状态:成功:正常”行，则您的模型已被成功服务。
检查状态:成功:正常日志
使用 HTTP 请求在模型上运行推理
一旦您的模型被提供，就可以通过您定义的端口访问它。你的模型可以在任何地方使用；像 GCE、AWS lambda、AWS EC2、Google Colab、您本地计算机等云计算引擎。请注意，当您将模型部署到生产环境中时，在 Colab 或您的本地计算机上提供它没有多大意义。为了简单起见，我将在 Google Colab 上部署该模型。
您可以使用 HTTP 请求在服务模型上运行推理。发出 HTTP 请求后，服务器会将数据传递给模型，获取响应并将其发送回客户端。API 端点的输入是一个 JSON，其中嵌入了预处理过的图像。您可以使用请求库向 API 发出 HTTP 请求。
在调用 API 之前，必须对输入图像进行预处理。
图像预处理
图像经过预处理后，将图像嵌入到 JSON 中。这个 JSON 对象将是发送到 API 端点的数据。JSON 数据将有两项，“签名名”和“实例”“实例”项将包含列表形式的图像数据。
指定 API 请求的头，告诉端点 JSON 文件正在作为输入传递。使用 POST 方法从 API 端点请求，并将 URL、JSON 数据和头作为参数。API 将返回图像的预测。
来自服务模型的预测
这是模型的输出样本。
输出
结论
TensorFlow 服务使深度学习模型部署到生产中变得前所未有的简单。通过在模型中使用预处理图像的 lambda 层，可以避免对输入图像进行预处理。这使得调用 API 更加容易。
Python 文本分析入门
这是一个实用的循序渐进的教程，面向那些坚持使用 Excel 进行文本分析的数据分析师
因此，显然使用 MS Excel 处理文本数据是一件好事，因为你可以安装插件来创建字数统计和单词云，甚至可以进行情感分析。然而，我真的不知道为什么有人会这样做，如果存在免费的和不那么笨拙的工具——比如 Python。
我在之前的一篇文章中概述过，许多人不愿意学习编码，因为他们认为这很难，并且需要深入的数学知识。两者都不对。如果您可以在 Excel 中编写冗长而笨拙的函数，那么让我向您保证，Python 要简单得多，也更直观。此外，还有各种用于自然语言处理(NLP)的 Python 库，其中有大量的内置函数可以帮你完成繁重的工作。
在本文中，我想从 Python 中文本分析的基础开始。一些 Python 知识是必要的，所以我建议你看看我的前一篇文章，在这篇文章中，我给出了如何开始使用 Python 或 R 进行数据分析的技巧。这篇文章将是一个类似的格式。有大量关于如何开始使用 Python 学习 NLP 的教程和文章，其中一些我将在本文中链接到。但是，我想举一个实用的例子，说明如何处理您在日常工作中可能会遇到的真实文本数据。我想展示如何应用一些简单但强大的文本分析技术，以及如何解决您可能会遇到的问题。
我将从一个笔记本中给出一些代码示例，这个笔记本是我为一个想开始用 Python 进行文本分析的朋友创建的。整本笔记本在这里都有，如果你想翻一遍的话。这不是最令人兴奋的数据集，因为我试图找到一个公共数据集，类似于他在工作中必须分析的数据类型。该数据集包含 2019 年以来的美国铁路事故。
问正确的问题
与你在教程中分析的经过精心清理和格式化的数据集不同，真实世界的数据通常是杂乱和嘈杂的。例如，当导入美国铁路数据时，应该在一列中的事件文本不知何故出现在 15 列中。我不太清楚 MS Excel(已经很多年没用了)，但在 libre office Calc(Ubuntu 自带的开源版本)中，你必须逐行合并列。这对于 20 行已经很繁琐了，更不用说 2000 行了。当然，在 Python 中，你可以将其自动化，最好的数据操作库叫做 pandas (查看这篇中型文章中的介绍)。
在我看来，学习新东西的最好方法就是把手弄脏。当然，您应该花一些时间熟悉基础知识，但是没有人有时间去做所有有用的 Python 库的教程。如果你不知道如何执行某个操作(比如用熊猫合并栏目)——谷歌(或者百度，或者 Yandex……)是你的朋友。我可以向你保证，以前有人问过这个问题，并在 stackoverflow 上得到答案。
对于每个编程新手(或者实际上是任何东西)来说，最难的部分是当他们遇到困难时，为了找到他们正在寻找的答案，制定正确的问题。问正确的问题和谷歌搜索是一项技能，需要练习。因此，在开始的时候，你可能要花更长的时间才能在网上找到答案。但是不要担心——你很快就会掌握必要的词汇和经验。
问题:本应在一列中的数据被拆分成多列
最终目标:拥有一个包含所有列中数据的新列，并删除多余的列解决方案:合并列
谷歌查询:合并多列熊猫
谷歌搜索结果
谷歌推荐了几个 stackoverflow 帖子。主要的一个不是最理想的，因为我们有两个以上的列。但是还有一个问题是关于几个栏目的。
这是一个非常简洁的解决方案。为什么？因为它是通用的，并且考虑到了以后可能遇到的其他问题:比如 NaN 值(空单元格)和不同列中的不同数据类型(NaN 的类型是 float )。我在我的虚拟笔记本中一步一步地讲解这个功能。
非文本预处理
鉴于我想把重点放在文本数据上，我将不讨论如何处理丢失的数据。我正在给出一些如何在这个笔记本中估算缺失数值数据的例子(注意:是用 R，不是 Python)。对于铁路事故数据集，我只是检查重复的行并删除它们。我建议你用你的数据做一切必要的事情，让你的生活更轻松。如果您仅对某些列感兴趣，请仅选择这些列并将其存储在数据框中。如果您只对数据的某一部分感兴趣，请选择该部分(例如，只对发生在堪萨斯城的事件感兴趣)。
文本预处理
在这一节中，我想回顾一些重要的 NLP 概念，并展示如何将它们应用于文本数据的代码示例。
停用词移除
停用词是可能不携带任何有价值信息的词，如冠词(、)、连词(、)或命题(、)。你为什么要删除它们？因为发现 "the" 和 "a" 是数据集中最常见的词并不能告诉你太多关于数据的信息。然而，如果最常见的词包括【损害】和【脱轨】你已经可以对事故的类型做出某些推断(在美国铁路数据集中)。
NLP Python 库，如 NLTK 通常带有一个内置的停用词表，您可以很容易地导入它。
然而，NLTK 停用词列表只有大约 200 个停用词。我用于文本分析的停用词表包含将近 600 个单词。我把它保存在一个文件中，在那里我删除了撇号(不是 → 不是)，因为我在删除停用词之前删除了标点符号并对文本进行了标记。
请注意，在某些情况下，停用词很重要。例如，识别负面评论或建议。人们会在差评中使用【不】**【不是】这样的停用词:“我会 不是 再买这个商品。我看到了 没有 使用它的好处”。我在笔记本里寻址否定。
转换成 n-grams
正如您已经在上面的代码片段中看到的，我们需要将文本标记为单个单词，并将它们存储在一个列表中，以便遍历列表并删除停用的单词。单个词被称为一元词，两个词的二元词，三个词的三元词。
当处理一个新的数据集时，我发现提取最常用的词来了解数据是关于什么的很有帮助。您通常希望首先提取最常见的单字，但是提取具有较大 n 的 n 个单字来识别模式也是有用的。然而，你仍然应该至少阅读一些数据点，以便发现潜在的问题。例如，在铁路事故文本中，我注意到一些报告明确指出没有发生T21 损害或有害物质泄漏。然后，我使用二元语法和三元语法来识别否定，并区分损害和有害物质释放发生的事件和没有发生的事件。
NLTK 有内置的二元模型、三元模型和 n 元模型函数。
使用正则表达式删除标点符号
标点在预测文章的意思时并不总是有用的，所以它们经常和停用词一起被删除。去掉标点符号后，剩下的只有字母数字字符。我不会在这里讨论正则表达式——互联网上有很多关于它们的教程。下面是两个正则表达式—一个删除所有标点和数字，另一个在文本中保留数字。
注意，删除标点符号是否是个好主意，完全取决于你的数据。如果您想要提取特定的信息，例如，损害的美元金额，您想要保留美元符号，以便您可以提取随后的金额。另一个例子，保持标点符号是有益的是训练一个垃圾邮件-火腿分类器。垃圾邮件或文本通常包含更多的标点符号，因此可能是一个有用的功能。
引理满足和词干
词干化和词干化都是指将一个单词还原到其词根的过程。区别在于词干可能不是一个实际的单词，而一个词条是一个实际的单词。如果你想避免将同一个单词的不同形式视为不同的单词，例如出轨，出轨，出轨和出轨，这是一个方便的工具。
词干:考虑过，正在考虑，考虑→“考虑”
词干:考虑过，正在考虑，考虑→“考虑”
在训练分类器时，我个人从未注意到引理匹配和词干匹配之间的显著差异。不过，建议你自己试试。NLTK 带有许多不同的内置 lemmatisers 和 stemmers，所以只需即插即用。
把所有的放在一起
现在，您应该对 Python 中的文本分析有了足够的了解。让我们通过使用我用 5 个电影评论创建的虚拟数据集来把它们放在一起。笔记本可以在这里找到下载。
Jupyter 笔记本，演示文章中涉及的所有概念
笔记本中的预处理函数是我在博士刚开始时写的，并且在不同的项目中复制粘贴过。如果您在工作中总是处理相同类型的数据，那么很容易编写一些自动化预处理、探索和分析的函数，您可以在每次处理新数据集时复制粘贴这些函数。
我希望这篇文章对您有用，它将帮助您开始使用 Python pandas、NLTK 和任何其他库，这将使您的工作更容易。我将在下一篇文章中介绍一些更高级的 NLP 主题，所以如果您对我应该介绍的内容有任何建议，请告诉我！
[1] Lewis，David D .，et al .(2004)RC v1:文本分类研究的新基准集。机器学习研究杂志5:361–397。
文本矢量化入门
了解自然语言处理(NLP)-Python 中的文本矢量化
Feel free to follow me on Medium :)
最近，我在 DataCamp 上完成了“查尔斯·达尔文的书籍推荐”案例研究。在这个项目中，我们将学习如何实现文本预处理和文本矢量化，如何使用自然语言处理(NLP)构建图书推荐系统，以及检测查尔斯·达尔文的书籍彼此之间的相关程度。
文本矢量化
文本矢量化 是将文本转换成数值表示的过程。以下是一些实现文本矢量化的常用方法:
- 二进制术语频率
- 单词袋(BoW)术语频率
- (L1)标准化术语频率
- (L2)标准化的 TF-IDF
- Word2Vec
在这一节中，我们将使用下面的语料库来介绍文本矢量化中的 5 种流行方法。
corpus = ["This is a brown house. This house is big. The street number is 1.",
"This is a small house. This house has 1 bedroom. The street number is 12.",
"This dog is brown. This dog likes to play.",
"The dog is in the bedroom."]
二进制术语频率
二进制术语频率捕获文档中术语的存在(1)或不存在(0)。对于这一部分，在 TfidfVectorizer 下，我们将二进制参数设置为 true，以便它可以只显示存在(1)或不存在(0)以及范数参数等于 false。
单词袋(BoW)术语频率
单词袋(BoW)术语频率捕获文档中术语的频率。在 TfidfVectorizer 下，我们将二进制参数设置为 false，以便它可以显示项的实际频率，而范数参数等于 none。
(L1)标准化术语频率
(L1)规范化术语频率获取文档中规范化的 BoW 术语频率。在 TfidfVectorizer 下，我们将二进制参数设置为等于 false，这样它就可以显示项的实际频率，范数参数等于 l1 。
(L2)标准化的 TF-IDF
(L2)规范化 TFIDF(术语频率-文档频率倒数)捕获文档中的规范化 TFIDF。以下是计算 TFIDF 的公式。
TFIDF 的公式
在 TfidfVectorizer 下，我们将 binary 参数设置为等于 false，这样它就可以显示项的实际频率，norm 参数等于 l2 。
Word2Vec
Word2Vec 提供了单词的嵌入式表示。Word2Vec 从语料库中所有单词的一种表示开始，并在非常大的数据语料库上训练 NN(具有 1 个隐藏层)。以下是通常用于训练神经网络的两种方法:
- 连续单词包(CBOW) —基于上下文单词窗口预测中心/目标单词的矢量表示
- Skip-Gram (SG) —基于中心/目标词预测上下文词窗口的向量表示
一旦我们有了每个单词的嵌入向量并将其用于 NLP:
- 计算单词向量之间的余弦相似度，使用单词向量的加权平均值创建更高阶的表示，并提供给分类任务
Python 的 spacy 包提供了预先训练好的模型，我们可以用它来看看 w2v 是如何工作的。
import spacy
nlp = spacy.load("en_core_web_md", disable=['parser', 'ner'])# Get w2v representation of the word 'breakfast'
print (nlp('breakfast').vector.size)
nlp('breakfast').vector[:10]# Find cosine similarity between w2v representations of breakfast and universe
nlp('breakfast').similarity(nlp('universe')) # **0.044292555**doc1 = nlp("I like oranges that are sweet.")
doc2 = nlp("I like apples that are sour.")
doc1.similarity(doc2) # **0.962154245**
案例研究:查尔斯·达尔文的书籍推荐
数据
查尔斯·达尔文是世界上最著名的科学家。他还写了许多其他主题广泛的书籍，包括地质学、植物或他的个人生活。在这个项目中，我们将开发一个基于内容的图书推荐系统，它将根据所讨论主题的相似程度来确定哪些图书彼此接近。我们先来看看后面要用的书。
import glob # **glob** is a general term used to define techniques to match specified patterns according to rules related to Unix shell.folder = "datasets/"
files = glob.glob(folder + "*.txt")
files.sort()
文本预处理
作为第一步，我们需要加载每本书的内容，并检查正则表达式，通过删除所有非字母数字字符来简化这个过程。我们称这样的文本集合为语料库。
import re, ostxts = []
titles = []for n in files:
f = open(n, encoding='utf-8-sig')
data = re.sub('**[\W_]+**', ' ', f.read())
txts.append(data)
titles.append(os.path.basename(n).replace('.txt', ''))
[len(t) for t in txts]
然后，为了一致性，我们将参考达尔文最著名的关于物种起源的书来检查其他书的结果。
*for i in range(len(titles)):
if titles[i] == 'OriginofSpecies':
ori = i
print(ori) **# Index = 15***
下一步，我们通过做标记化将语料库转换成一种格式。
*stoplist = set('for a of the and to in to be which some is at that we i who whom show via may my our might as well'.split())txts_lower_case = [i.lower() for i in txts]
txts_split = [i.split() for i in txts]texts = [[word for word in txt if word not in stoplist] for txt in txts_split]
texts[15][0:20]*
对于文本预处理的下一部分，我们使用一个词干化过程，该过程将一个单词的变形形式组合在一起，这样它们就可以作为一个单独的项目进行分析:词干。为了使过程更快，我们将直接从 pickle 文件中加载最终结果，并回顾用于生成它的方法。
*import pickletexts_stem = pickle.load(open('datasets/texts_stem.p', 'rb'))
texts_stem[15][0:20]*
文本矢量化
词袋模型(BoW)
首先，我们需要创建一个包含查尔斯·达尔文著作语料库中所有单词的宇宙，我们称之为字典。然后，使用词干标记和字典，我们将创建词袋模型(BoW ),将我们的书表示为它们包含的与它们各自的出现次数相关联的所有唯一标记的列表。
*from gensim import corporadictionary = corpora.Dictionary(texts_stem)
bows = [dictionary.doc2bow(text) for text in texts_stem]
print(bows[15][:5])*
为了更好地理解这个模型，我们将把它转换成一个数据框架，并显示出“物种起源”这本书最常见的 10 个词干。
*df_bow_origin = pd.DataFrame()df_bow_origin['index'] = [i[0] for i in bows[15] if i]
df_bow_origin['occurrences'] = [i[1] for i in bows[15] if i]
df_bow_origin['token'] = [dictionary[index] for index in df_bow_origin['index']]
df_bow_origin.occurrences.sort_values(ascending=False).head(10)*
TF-IDF 型号
接下来，我们将使用一个 TF-IDF 模型根据每个单词在文本中的出现频率来定义它的重要性。因此，一个单词的高 TF-IDF 分数将指示该单词特定于该文本。
*from gensim.models import TfidfModelmodel = TfidfModel(bows)
model[bows[15]]*
同样，为了更好地理解这个模型，我们将把它转换成一个数据框架，并显示“物种起源”这本书的 10 个最具体的单词。
*df_tfidf = pd.DataFrame()df_tfidf['id'] = [i[0] for i in model[bows[15]]]
df_tfidf['score'] = [i[1] for i in model[bows[15]]]
df_tfidf['token'] = [dictionary[index] for index in df_tfidf['id']]
df_tfidf.score.sort_values(ascending=False).head(10)*
建议
现在我们有了一个 TF-IDF 模型来衡量它们与每本书的具体程度，我们可以衡量书籍之间的相关程度。因此，我们将使用余弦相似度，并将结果可视化为距离矩阵。
*from gensim import similaritiessims = similarities.MatrixSimilarity(model[bows])
sim_df = pd.DataFrame(list(sims))
sim_df.columns = titles
sim_df.index = titles
sim_df*
结论
我们现在有了一个矩阵，其中包含了查尔斯·达尔文的任何两本书之间的所有相似性度量！我们可以使用 barh()来显示一个横条图，其中的书籍与《物种起源》中的最为相似。**
*%matplotlib inline
import matplotlib.pyplot as pltv = sim_df['OriginofSpecies']
v_sorted = v.sort_values()
v_sorted.plot.barh()
plt.xlabel('Similarity')*
然而，我们想更好地了解大局，看看达尔文的书通常是如何相互关联的。为此，我们将把整个相似性矩阵表示为一个树状图，这是显示此类数据的标准工具。
*from scipy.cluster import hierarchyZ = hierarchy.linkage(sim_df, 'ward')
chart = hierarchy.dendrogram(Z, leaf_font_size=8, labels=sim_df.index, orientation="left")*
最后，基于我们之前创建的图表，我们可以得出结论:在物种起源上，“被驯化的动植物的变异与“最相关。”
创建这篇文章的源代码可以在我的 Github 中找到。
关于我
非常感谢您阅读我的文章！大家好，我是雪莉，目前在亚利桑那州立大学攻读商业分析硕士学位。如果您有任何问题，请随时联系我！
*Email me at ***kchen122@asu.edu***and feel free to connect me on [**LinkedIn**](https://www.linkedin.com/in/kuanyinchen-shirley/)!*
谷歌云人工智能平台 TFX 入门—第 1 部分
创建机器学习(ML)模型通常是世界各地许多数据科学家和工程师的核心关注点。然而，他们经常忘记计划一旦模型建成，他们将如何生产。这通常不是他们的错(大多数情况下)，因为大多数情况下，不同的部门负责不同的生产领域，例如，数据科学家团队负责创建模型，开发人员团队负责打包模型以供使用。这通常会导致:
- 模型没有定期更新，因为反馈循环通常是手动的，即收集的数据交给数据科学家团队来评估和更新模型。更新的模型然后被交给开发团队。我见过这样的过程，至少需要几个星期！
- 维护模型的运营成本增加，因为有多个团队负责模型的生命周期。
因此，Google/TensorFlow 的团队意识到，以上是围绕客户想要生产他们的模型的一个共同主题，所以他们创建了 TensorFlow Extended (TFX)。
TFX 是一个平台，它允许用户为他们的 TensorFlow 代码创建端到端的生产规模的 ML 管道。它包括建模、培训、验证、服务推理和管理在线部署。机器学习管道可以使用任何编排工具来构建，如 Apache Airflow、Apache Beam 或 Kubeflow。必须注意的是，本文中的流水线是对 ML 工作流的描述，它们以图表的形式组合，可用于编排和自动化机器学习系统。出于本文的目的，我们将通过 TFX 使用 Kubeflow 管道。
TFX 使用的主要库是:
- TF 数据验证 —用于异常检测
- TF 变换 —用于数据预处理和特征工程
- TF 估计器和 Keras —建立和训练机器学习模型
- TF 模型分析 —模型评估与分析
- TF 服务 —将模型作为 REST APIs 服务
下图显示了在端到端模型中使用的各种 TFX 库，我们将在下一系列文章中详细介绍它们。然而，在这篇文章中，我们将在谷歌云平台上建立一个基础，以了解 TFX 和库伯流的行动。
图片改编自[1]
1.在新的 Kubernetes 集群上建立 AI 平台管道。
我们将假设你们有一个项目与本教程启用计费。
放心吧！本教程保持在免费层的限制，但是，如果你耗尽了免费层的限制，你可能会被收费。如果您想遵循本教程，建议您创建一个新项目。
- 在导航窗格中，找到人工智能菜单下的“AI 平台”，点击管道，如下图所示。
2.点击“新实例，创建一个新集群，如下图所示。您将被引导至 Kubeflow Pipelines 概览页面。
3.在 Kubeflow Pipeline 概览页面上，点击“配置”。
注意:在启用 Kubernetes 引擎 API 时，您可能需要等待几分钟。
- 在“部署 Kubeflow 管道”页面上，选择离您最近的区域。离我最近的区域是“欧洲-西方 2-a”。
- 选中标记为“允许访问以下云 API”的框。
- 然后点击创建集群。这需要在进入下一步之前完成。
4.创建集群后，您可以选择名称空间和实例名称。我将保留我的默认设置。
您应该可以成功地看到您的 Kubernetes 集群中启动了 Kubeflow 管道，如下所示。
现在我们要设置一个云 AI 平台笔记本实例。
2.设置云人工智能笔记本实例。
- 回到主导航菜单，在人工智能菜单下找到“AI 平台”，点击笔记本，如下图所示。
2.继续点击“新实例，选择“ Tensorflow 2.2 - >不带 GPU”。
- 注意:您可以通过单击新笔记本实例表单底部的定制来更改机器。
现在我们可以做的是从我们的人工智能渠道推出一款笔记本电脑。
3.启动入门笔记本
- 我们现在可以点击“管道”按钮，它应该会把我们带到人工智能平台管道页面。然后，我们可以点击“Open Pipelines Dashboard”进入“入门页面”。
2.在“入门页面”上，单击“打开 TF 2.2 笔记本”链接，并选择您已创建的笔记本实例。
您现在可以访问与 Kubeflow 链接的 Jupyter 实验室笔记本，将会打开一个模板笔记本。
在我的下一个系列中，我将使用简单的数据，通过简单的步骤，使用 TFX 管道生产您的模型。对于那些等不及的人，你可以通过谷歌的“使用模板创建一个 TFX 管道”笔记本，它是默认打开的。
玩得开心！
AWS SAM CLI 入门
了解如何使用 AWS SAM CLI 在本地调试 lambda 函数
图片来自 Unsplash
在本文中，我们将学习 AWS SAM CLI 的概念。SAM，缩写为无服务器 应用 模型是亚马逊网络服务提供的一个框架，可以用来在本地机器上构建应用，并直接将这些应用部署到 AWS Lambdas。
初始背景
以前，在引入 AWS SAM CLI 之前，开发人员使用在线编辑器直接在 AWS Lambda 上编写、测试和部署代码。这是通过使用 AWS 管理控制台创建 Lambda 函数来完成的。当创建函数时，您可以使用 AWS Lambda 提供的在线代码编辑器在其中添加代码。
图 1 —在内嵌代码编辑器(AWS Lambda)中编写代码
虽然，这似乎是一种不用部署就可以编写和测试代码的非常方便的方式，如果您有非常简单的函数，其中不包含太多复杂的逻辑，或者您是单独处理它，这种方式也很好。然而，将你的代码放在在线代码编辑器中的想法对我来说听起来很吓人。在这个过程中，您不能完全控制您的代码。如果万一有人不小心删除了您的函数，那么您必须从头开始重新编写代码，这是我们作为开发人员应该避免的事情。
相反，在这个基础设施即代码的时代，大多数事情都可以通过编写代码来实现，我们应该考虑一个更健壮的想法，代码可以进行版本控制并易于管理。市场上有很多工具可以用来编写和开发您的功能，一旦准备好进行部署，您就可以使用 AWS Lambda 提供的本机流程将其部署到在线服务。
了解 AWS 中的无服务器功能和应用
AWS 中的无服务器函数或 Lambda 函数是一段代码，可以用任何支持的语言编写，如 C #、Python、NodeJS、Ruby 等。该代码可以部署在 AWS 上，并基于触发事件执行。AWS 中有许多受支持的事件，如 API Gateway，可用于触发 Lambda 函数。除此之外，还有其他事件，如 S3 事件、SNS 话题、SQS 排队等。所有这些事件都可以用来触发 Lambda 函数的执行。
另一方面，无服务器应用程序是为实现特定目标而工作的类似服务的组合。这样的应用程序可能包含一个或多个 Lambda 函数，并结合其他 AWS 服务，如 DynamoDB 表或 SNS 主题。
什么是 AWS SAM —无服务器应用程序模型
SAM 是由 Amazon 开发的开源框架，它帮助我们定义无服务器资源，如 Lambda 函数、API 网关以及其他一些资源。SAM 使用 CLI(称为 SAM CLI)提供对 API 的访问。在这个实用程序的帮助下，您可以轻松地定义您的资源，并将这些资源部署到 AWS 中的任何环境，而不需要做太多的手工工作。SAM 基于先前建立的云形成模板。如果您已经有了一些使用云形成堆栈部署无服务器资源的经验，那么使用 AWS SAM CLI 对您来说会非常容易。
现在我们对 AWS SAM 有了一些了解，让我们继续尝试查看底层工作流。
图 2-SAM 工作流程(来源: YouTube
如果你看到上图，你可以看到有两个主要部分——一个是“本地应用程序回购”,第二个是“AWS 云”。在本地 repo 中，有一个根目录“ my-sls-app-1 ，类似于一个无服务器的应用。在该应用程序中，有另一个目录“ lambda-1 ”，这是 lambda 函数的目录。在 lambda 函数目录下，有我的“ main.py ”文件，我可以在其中编写 lambda 函数的代码。这里需要注意的重要一点是，在根应用程序目录下，可以定义多个 lambda 函数和其他 AWS 资源。然而，为了简单起见，我想把它限制为一个 lambda 函数。
您可以看到的下一项是“ sam-template.yaml ”，这是 sam 框架将用来部署应用程序的模板。我将在本系列的后面解释它。这个模板有点类似于云的形成模板，其中有一些小的修改。如果你熟悉云的形成模板，那么你可以很容易地使用它。一旦开发了代码，就可以运行“ sam-package ”命令，该命令将使用该模板作为 sam 框架的输入，然后将其转换为云形成模板，并以“ sam-deploy.yaml ”的名称存储。除了生成部署模板之外，SAM 框架还创建 lambda 函数的 zip 文件，并将其上传到 S3 的预定义 bucket 中。此上传文件的 URL 将出现在部署模板中以供参考。
一旦部署模板准备好了，现在就可以将资源部署到 AWS 云中了。为此，您需要运行" sam-deploy "命令，该命令将 deploy 模板作为输入，并基于 AWS Lambda 函数、API 网关等资源创建云形成堆栈。在 SAM 模板文件中指定的。该部署不仅可以用于部署 Lambda 函数，还可以用于部署其他服务，如 API 网关、SNS 主题、SQS 队列、Dynamo DB 表等。这都是关于创建和部署您的无服务器应用程序。
使用 AWS SAM 的好处
AWS SAM 能够与其他 AWS 服务集成，因此为我们提供了许多可以利用的优势。
- 单一部署配置 —通过使用 AWS SAM，您可以在属于同一堆栈的单一位置轻松管理所有必要的资源
- AWS 云形成的扩展 —由于 SAM 是作为现有云形成的扩展而构建的，因此您可以获得相同部署能力的可靠性。有了这个，你还可以使用萨姆·YAML 模板中云形成的所有可用资源
- 本地调试和测试 —在 AWS SAM CLI 的帮助下，您现在可以在本地执行和测试您的无服务器应用程序。CLI 通过挂载 docker 映像并运行代码，在本地提供类似 Lambda 的执行环境。这有助于您轻松地单步调试代码，并找出在 lambda 环境中直接从控制台运行代码时可能检测不到的问题
安装 SAM CLI
到目前为止，我们已经合理地了解了 AWS SAM。现在让我们继续学习如何在我们的本地机器上安装相同的组件。假设您的机器上已经安装了 python，您可以通过运行以下命令来安装 CLI。
pip 安装 aws-sam-cli
图 3 —使用 PIP 安装 SAM
我已经在我的机器上安装了相同的程序，所以我得到消息“已经满足要求”。但是，如果您是第一次安装它，它将根据需要下载 SAM 包和所有必需的依赖项。
结论
在本文中，我们已经了解了 AWS 无服务器应用程序模型(SAM)是什么，以及如何使用它来开发无服务器应用程序。此外，我们还了解了它的工作流程以及如何打包和部署无服务器应用程序。在我即将发表的文章中，我将演示在本地调试和测试无服务器应用程序，以及如何使用 SAM CLI 打包和部署该应用程序。
原载于 2020 年 8 月 17 日【https://www.sqlshack.com】。
揭开机器学习的面纱
来自 Dribbble 的 Hurca 图片
当机器在学习的时候，人类被钩住了
机器学习是目前业界最热门的术语之一。全球科技巨头，如谷歌、亚马逊脸书等，都试图在他们的产品中利用机器学习的力量。尽管有抱负的数据科学家的机会呈指数增长，但仍有一大群人不清楚机器学习是什么。
这就是我来这里帮助你的原因。这篇文章将是名为机器学习秘诀的系列文章的第一篇，其中我们将研究机器学习的各个方面，首先是理论，然后是数学，最后是实践。
在这篇文章中，我将试图给你一个直觉，不仅关于什么是机器学习，而且它的不同类型，最近的发展，以及开始机器学习的最佳资源。
什么是机器学习？
机器学习是人工智能(AI)的一种应用，它为计算机或任何机器提供了从经验中学习和改进的能力，而无需显式编程。机器学习背后的目标是让机器在没有明确编程的情况下自己做事情。
图片由 Gerd Altmann 从 Pixabay 拍摄
让机器做事情背后的原因是它们在不疲惫的情况下提供高精度的结果。人类执行的任务的质量可能会有所不同，有时也会令人疲惫不堪，但机器可以高精度地完成高频率的重复任务，而不会感到疲劳或厌倦。
自从互联网出现以来，数据生成量一直在显著增加。每当我们在网站或应用程序上采取任何行动时，我们都在生成数据。随着云计算的发展，存储数据的成本也大大降低，为 ML 及相关领域的进一步发展铺平了道路。
人工智能 vs 机器学习 vs 深度学习
该领域的初学者面临的最大困惑之一是人工智能(AI)、机器学习(ML)和深度学习(DL)之间的区别。
人工智能是一种使机器能够模仿人类行为的技术。人工智能的最终目标是制造能够执行人类任务并做出自己聪明决定的智能机器。
机器学习是人工智能的一个子部分，它使用统计方法，使机器能够在没有明确编程的情况下根据经验进行改进。
图片由作者
深度学习是 ML 的一个子部分，它利用神经网络(类似于人类的神经元)来模拟类似人脑的行为。当数据集包含大量的观察值或数据点时，深度学习就会发挥作用。
另一个通常与机器学习混淆的重要术语是数据科学。数据科学是对我们为各种洞察生成的数据进行分析，这些洞察有可能服务于多种商业目的。
机器学习中使用的工具和编程语言
有几种工具和语言可用于执行机器学习。工具的具体选择可能会有所不同，所使用的工具取决于作业的需要和规模。
图片来自 Quantiphi
Python 和 R 是机器学习编程语言的首选。数据通常存储在 CSV 格式的文件中，尽管也可以使用 excel 表格。除此之外，统计学的基础知识对于理解机器学习算法是必要的。
分类 ML 算法
有各种机器学习算法可以用在各种不同的情况下。通常有三种不同类型的机器学习算法，即监督学习、非监督学习、和强化学习。
图片由作者
有监督的机器学习:有监督的机器学习问题是我们要基于一组例子进行预测的问题。
- 回归问题:结果为离散值的问题属于回归范畴。举个例子——房子的价格是一个回归问题。
- 分类问题:当我们要把结果分成不同的类别时。例如，癌症是恶性还是良性是一个分类问题。结果可以分为两类——恶性或良性。同样，客户是否会拖欠贷款也是一个分类问题，投资金融的公司对此非常感兴趣。
无监督机器学习:无监督机器学习问题是指我们的数据没有一组定义好的类别，而是我们在寻找机器学习算法来帮助我们组织数据的问题。
无监督机器学习问题的例子可以是基因组学。在基因组学中，我们提供了一种具有数千个不同基因的算法，然后该算法将这些基因聚类成相关基因的组。这可能是与寿命、头发颜色等相关的基因。结果通常通过聚类或分割获得。
无监督学习的各种算法包括 k 均值聚类、层次聚类、和神经网络。
最近另一种类型的机器学习研究正在获得火花，这就是强化学习。它通常被视为真正人工智能的希望。强化学习(RL)是机器学习的一个领域，涉及软件代理应该如何在环境中采取行动，以最大化累积回报的概念。
用于训练机器学习模型的数据
用于训练 ML 模型的数据量取决于我们试图解决的问题。有各种在线存储库，您可以在其中找到用于训练和构建机器学习模型的数据集。
为你的模型获取数据的一些最受欢迎的网站是 Kaggle 、 UCI 机器学习库、和谷歌数据集搜索。
图片来自 Intellipaat
如今有大量的数据可用。从网站和智能手机上的日志到健康设备，我们处于不断创建数据的过程中。
数据可以大致分为两种类型:
- 结构化数据:结构化数据通常是指以表格形式存储在组织中的数据库中的数据。
- 非结构化数据:非结构化数据包括所有获取的数据，但不是以表格的形式存储在企业中。
机器学习模型可以处理结构化和非结构化数据。然而，在实际构建机器学习模型之前，我们需要首先将非结构化数据转换为结构化数据。
构建机器学习模型的步骤
建立机器学习模型的第一步是数据收集。数据收集是指在既定系统中收集和测量目标变量信息的过程。
然后是为我们的模型清理和操作数据。数据探索和清理帮助我们去除异常值和缺失值，并将数据转换成所需的格式。
图片来自 Ceralytics
一旦我们的数据准备好了，我们在训练数据上训练模型，然后在测试数据上测试它。我们的最后一步是改进我们的模型，以获得更好的准确性。
这只是一个简短的介绍，让您直观地了解构建和部署机器学习模型所涉及的步骤。我们将在接下来的文章中详细讨论这些步骤。
机器学习的最佳资源
实践机器学习的一些最佳资源是:
- 由 Coursera 提供的吴恩达机器学习和
- ****机器学习纳米学位由 Udacity 提供
- 谷歌的机器学习速成班
- Coursera 提供的机器学习专业
正如多次提到的，机器学习是一个非常活跃的研究领域。从吴恩达到彼得·诺维格，顶级专家和研究人员的贡献怎么说都不为过。
你在正确的时间选择了正确的职业。快乐学习！
Python 的 Vim 和 Tmux 入门
如何从 Vim 中的 IDE 获得您想要的特性
尼奥诺韦在 Unsplash 拍摄的照片
如果你用多种语言编写代码，你可能会发现为每种语言维护一个 IDE 是一件令人厌倦的事情。经过一些试验后，我发现 Vim 和 Tmux 的组合是我的理想解决方案。主要好处是:
一个支持任何语言的环境
高效的纯键盘文件编辑
易于在任何新环境中安装
然而，作为一个文本编辑器而不是 IDE，这个解决方案缺少一些现成的重要特性。幸运的是，Vim 和 Tmux 都是高度可配置的。
本文展示了如何配置 Vim 和 Tmux 来支持 Python 开发的一系列关键特性。虽然 Tmux 起着重要的作用，但是大多数配置都与 Vim 有关。
先决条件:
这个工作流被设计成在像 Linux 或 MacOS 这样的 Unix 系统上运行。首先，创建一个。在 home/ 目录下的 vimrc 文件以及一个空文件夹。vim/。安装 Vim、Tmux 和(可选)IPython。通过对 Vim 及其配置有所了解。假设 vimrc 文件。如果你不知道如何安装 Vim 插件，看看这篇文章。
哪些功能是真正必要的？
下面是一个观点鲜明的特性列表，这些特性使得在 Vim 中开发 Python 更加明智:
1.一个多语言环境
2.容易到达终端
3.流畅的目录浏览
4.将代码行发送到 Python 控制台
5.在终端中运行 Python 文件
6.交互调试
1.一个多语言环境
可以为每种文件类型单独配置 Vim。例如，可以将 Vim 配置为在打开 Python 文件时使用四个空格，而在打开 R 文件时使用两个空格。要启用特定于文件的设置，将以下行放入。vimrc 文件:
filetype plugin indent on
indent部分支持文件特定的缩进。
创建目录。vim/after/ftplugin 。在 ftplugin 中的文件以语言命名(例如 python，json，r，sh ),并且有。vim 扩展。下面是 JSON、Python、R 和 Bash 的一个例子:
.vim/
└── after
└── ftplugin
├── json.vim
├── python.vim
├── r.vim
└── sh.vim
这个想法就是把任何。将只适用于特定语言的 vimrc 配置放入 ftplugin 中的相应文件中。从这个意义上来说， ftplugin 中的文件可以被视为“特定于语言的”。vimrc 文件。这些文件来源于之后。vimrc 并覆盖任何常规设置。
例如，Python 特定的缩进应该放在 python.vim 文件中:
setlocal tabstop=4
setlocal shiftwidth=4
setlocal softtabstop=4
setlocal expandtab
注意setlocal的使用，以便这些设置仅覆盖来自的一般设置。vimrc 文件仅用于当前缓冲区。
本文接下来的章节遵循惯例，将特定语言的设置放在 ftplugin 中，将通用 Vim 设置放在中。vimrc 。
参考资料:
2.容易到达终端
作者图片
只有当 Vim 在终端内部运行时，此功能才有效。在这种情况下，可以通过运行 Ex 命令来挂起 Vim:
:stop<CR>
这会将 Vim 移到后台，并将屏幕切换回调用 Vim 的终端。在终端中运行fg将 Vim 移回前台。
在 Vim 和全屏终端之间切换非常方便，值得在中创建一个映射。vimrc :
nnoremap <leader>t :stop<CR>
参考资料:
3.流畅的目录浏览
作者图片
ide 通常提供一个文件浏览器，作为项目的抽屉。这种方法不能很好地与 Vim 的窗口风格工作流相结合。毕竟，Vim 如何知道您希望在哪个窗口中打开您从项目抽屉中选择的文件？
Vim 已经自带了一个名为 netrw 的内置插件。为了理解这个插件，把 Vim 窗口想象成翻转的卡片:一边是你的文件，另一边是 netrw 文件浏览器。
在中为文件浏览映射两个键绑定很有用。vimrc 。第一个在当前文件的目录下打开 netrw。第二个键绑定在当前工作目录打开 netrw。
nmap <leader>f :Explore<CR>
nmap <leader><s-f> :edit.<CR>
尽管 Netrw 有一些恼人的默认设置。建议将这两个额外的 netrw 设置放在中。vimrc 。第一种设置允许以右分割方式打开文件。第二个设置禁止 netrw 保存。文件中的 netrwhist 文件。vim 文件夹。
let g:netrw_altv = 1
let g:netrw_dirhistmax = 0
最后，一个名为vim-醋的最小插件使 netrw 更加明智，并提供了几个有用的快捷方式:
- 在任一缓冲区中按下
-键，跳到目录列表，并找到您刚来的文件。 - 在一个文件上按下
.,在:命令行的末尾预先填充它。还有!，砰的一声启动生产线。 - 按
y.键，拖动光标下文件的绝对路径。
参考资料:
- 你不需要 NERDTREE 或者(可能)netrw
- 油和醋——分窗和项目抽屉
- 维姆醋
4.将代码行发送到 Python 控制台
作者图片
Tmux 允许将屏幕水平分割成两个终端窗口:上面一个用于 Vim(可能有多个垂直分割窗口),下面一个包含一个 IPython 控制台。如果您不喜欢 IPython，上面的过程在常规的 Python 控制台上也能很好地工作。
接下来，插件 vim-slime 用于将选定的代码从 vim 发送到 IPython 控制台。下面对中的配置进行说明。vimrc 文件支持这种行为:
let g:slime_target = "tmux"
let g:slime_default_config = {"socket_name": get(split($TMUX, ","), 0), "target_pane": ":.1"}
按下C-c, C-c(按住 Ctrl 并双击 C)将光标下的段落发送到 IPython 控制台。(第一次 vim-slime 会提示目标窗格。按两次 Enter 键。)
上面的过程与语言无关:同样的过程允许将 R 代码行发送到 R 控制台，或者将 Bash 脚本中的行发送到终端。
参考资料:
5.在终端中运行 Python 文件
作者图片
在终端中有运行当前脚本的快捷方式很方便。通常，这是通过调用解释器后跟文件名来实现的:
python filename.py
在 python.vim 中定义的以下映射运行两个连续的 Ex 命令:
nmap <buffer> <leader>r <Esc>:w<CR>:!clear;python %<CR>
它是这样做的:
- 第一个 Ex-command
:w<CR>保存文件。 - 第二个 Ex-command 以
:!开始，表示它是针对终端的，用:clear清除终端，最后调用当前文件的解释器python %<CR>，其路径由%给出。
注意，这种映射是特定于语言的。运行 bash 脚本的类似映射可以定义如下:
nnoremap <buffer> <leader>r <Esc>:w<CR>:!clear;sh %<CR>
参考资料:
6.交互调试
作者图片
调试是 ide 真正大放异彩的领域。尽管如此，通过安装 Python ipdb 可以在 Vim 中获得令人满意的调试体验。
模块 ipdb 类似于 pdb ，但是是为 IPython 设计的。它不必安装，因为它附带了 IPython。它允许用set_trace()定义一个断点，该断点将在该点暂停程序，并丢弃启动调试器，在调试器中可以使用 IPython 检查程序的状态。
python.vim 中的以下 Vim 映射在当前行下方放置了一个断点:
nmap <buffer> <leader>b oimport ipdb;ipdb.set_trace(context=5)<ESC>
上下文参数指定调试器显示的行数。
如果 IPython 是embed的话，这是一个很好的特性，它会在调试期间启动一个单独的 IPython 会话。在此会话中所做的更改不会影响原始调试会话中的对象。
ipdb> from IPython import embed
ipdb> embed()
对调试器命令的进一步讨论超出了本文的范围。它们在下面引用的文档中有很好的记录。
参考资料:
结论
本文中的配置将帮助您开始使用 Vim 和 Tmux 进行 Python 开发。其他有用的特性，如林挺、代码完成和跳转到定义，都没有涉及到。看看我的个人 Vim 配置中更完整的例子。
scikit 中的 XGBoost 入门-学习
入门
每一段旅程都从一次助推开始
图片来源:【https://www.pxfuel.com/en/free-photo-juges
这篇文章解释了 XGBoost 是什么，为什么 XGBoost 应该是你的首选机器学习算法，以及在 Colab 或 Jupyter 笔记本上启动和运行 XGBoost 所需的代码。假设您对机器学习和 Python 有基本的了解。
XGBoost 是什么
在机器学习中，集成模型比单个模型有更高的概率表现更好。集成模型将不同的机器学习模型组合成一个。随机森林是一个流行的集合，它通过装袋取许多决策树的平均值。Bagging 是“bootstrap aggregation”的缩写，意思是通过替换(bootstrapping)选择样本，并通过取其平均值进行组合(聚合)。
助推是装袋的一种强有力的替代方法。助推器不是聚集预测，而是通过关注单个模型(通常是决策树)哪里出错，将弱学习者变成强学习者。在梯度推进中，单个模型基于残差训练，残差是预测和实际结果之间的差异。梯度提升树不是聚集树，而是在每一轮提升过程中从错误中学习。
XGBoost 是“极端梯度推进”的缩写。“极致”是指并行计算和缓存感知等速度增强，使 XGBoost 比传统的梯度提升快大约 10 倍。此外，XGBoost 包括一个独特的分裂查找算法来优化树，以及内置的正则化来减少过度拟合。一般来说，XGBoost 是一个更快、更精确的渐变增强版本。
平均而言，boosting 比 bagging 表现得更好，梯度 Boosting 可以说是最好的 Boosting 系综。由于 XGBoost 是梯度增强的高级版本，其结果是无与伦比的，因此它可以说是我们拥有的最好的机器学习组合。
为什么 XGBoost 应该是您的首选机器学习算法
从 2014 年的希格斯玻色子 Kaggle 比赛开始，XGBoost 在机器学习领域掀起了风暴，经常在 Kaggle 比赛中获得一等奖。XGBoost 的受欢迎程度飙升，因为在竞争环境中，当从表格数据(行和列的表格)进行预测时，它一直优于可比的机器学习算法。
从表格数据进行预测时，XGBoost 可能是您的最佳起点，原因如下:
- XGBoost 很容易在 scikit-learn 中实现。
- XGBoost 是一个系综，所以比单个模型得分高。
- XGBoost 是正则化的，所以默认模型通常不会过度拟合。
- XGBoost 非常快(对于系综而言)。
- XGBoost 从错误中学习(梯度提升)。
- XGBoost 有大量用于微调的超参数。
- XGBoost 包括超参数来缩放不平衡的数据和填充空值。
现在，您对 XGBoost 是什么以及为什么 XGBoost 应该是处理表格数据时的首选机器学习算法有了更好的了解(与神经网络工作得更好的图像或文本等非结构化数据相比)，让我们建立一些模型。
安装 XGBoost
如果您运行的是 Colab 笔记本，XGBoost 是一个选项。如果你在 Jupyter 笔记本上运行 Anaconda，你可能需要先安装它。打开您的终端并运行以下命令来安装 XGBoost 和 Anaconda:
conda install -c conda-forge xgboost
如果您想要验证安装或您的 XGBoost 版本，请运行以下命令:
import xgboost; print(xgboost.__version__)
如需更多选项，请查看 XGBoost 安装指南。
接下来我们拿一些数据来做预测。
scikit-learn 中的 XGBRegressor
Scikit-learn 带有几个内置数据集，您可以访问这些数据集来快速对模型进行评分。以下代码加载 scikit-learn 糖尿病数据集，该数据集测量一年后疾病的传播程度。更多信息请参见sci kit-学习数据集加载页面。
from sklearn import datasets
X,y = datasets.load_diabetes(return_X_y=True)
衡量糖尿病传播程度的指标可能会采用连续值，因此我们需要一个机器学习回归器来进行预测。XGBoost 回归器称为 XGBRegressor ，可按如下方式导入:
from xgboost import XGBRegressor
我们可以使用交叉验证在多个折叠上构建模型并对其评分，这总是一个好主意。使用交叉验证的一个优点是它会为您拆分数据(默认情况下是 5 次)。首先导入 cross_val_score 。
from sklearn.model_selection import cross_val_score
要使用 XGBoost，只需将 XGBRegressor 放在 cross_val_score 中，以及 X、y 和您首选的回归得分指标。我更喜欢均方根误差，但这需要转换负的均方误差作为一个额外的步骤。
scores = cross_val_score(XGBRegressor(), X, y, scoring='neg_mean_squared_error')
如果您得到警告，那是因为 XGBoost 最近更改了他们默认回归目标的名称，他们希望您知道。要消除警告，请尝试以下方法，结果相同:
*# Alternative code to silence potential errors* scores = cross_val_score(**XGBRegressor(objective='reg:squarederror')**, X, y, scoring='neg_mean_squared_error')
求均方根误差，取 5 个分数的负平方根即可。
(-scores)**0.5
回想一下，在 Python 中，语法 x**0.5 表示 x 的 1/2 次方，也就是平方根。
我的 Colab 笔记本结果如下。
array([56.04057166, 56.14039793, 60.3213523 , 59.67532995, 60.7722925 ])
如果你喜欢一个分数，试试 scores.mean() 求平均值。
预期的希格斯玻色子衰变。欧洲核子研究中心制作的照片。通用创作许可证。链接到维基百科。
xgb 回归码
下面是使用 scikit-learn 中的 XGBoost 回归器预测糖尿病进展的所有代码。
from sklearn import datasets
X,y = datasets.load_diabetes(return_X_y=True)
from xgboost import XGBRegressor
from sklearn.model_selection import cross_val_score
scores = cross_val_score(**XGBRegressor(objective='reg:squarederror')**, X, y, scoring='neg_mean_squared_error')
(-scores)**0.5
正如你所看到的，由于 2019 年推出的新 scikit-learn 包装器，XGBoost 与其他 scikit-learn 机器学习算法的工作原理相同。
scikit-learn 中的 XGBClassifier
接下来，让我们使用类似的步骤构建一个 XGBoost 分类器并进行评分。
以下 url 包含可用于预测患者是否患有心脏病的心脏病数据集。
url = ‘https://media.githubusercontent.com/media/PacktPublishing/Hands-On-Gradient-Boosting-with-XGBoost-and-Scikit-learn/master/Chapter02/heart_disease.csv'
该数据集包含 13 个预测值列，如胆固醇水平和胸痛。最后一栏标有“目标”，确定患者是否患有心脏病。原始数据集的来源位于 UCI 机器学习库。
导入 pandas 来读取 csv 链接并将其存储为 DataFrame，df。
import pandas as pd
df = pd.read_csv(url)
由于目标列是最后一列，并且该数据集已经过预清理，因此可以使用索引位置将数据拆分为 X 和 y，如下所示:
X = df.iloc[:, :-1]
y = df.iloc[:, -1]
最后，导入 XGBClassifier 并使用 cross_val_score 对模型进行评分，将准确性作为默认的评分标准。
from xgboost import XGBClassifier
from sklearn.model_selection import cross_val_score
cross_val_score(XGBClassifier(), X, y)
以下是我从我的 Colab 笔记本中得到的结果。
array([0.85245902, 0.85245902, 0.7704918 , 0.78333333, 0.76666667])
xgb 分类器代码
以下是使用 scikit 中的 XGBClassifier 预测患者是否患有心脏病的所有代码——了解五个方面:
url = 'https://media.githubusercontent.com/media/PacktPublishing/Hands-On-Gradient-Boosting-with-XGBoost-and-Scikit-learn/master/Chapter02/heart_disease.csv'import pandas as pd
df = pd.read_csv(url)
X = df.iloc[:, :-1]
y = df.iloc[:, -1]from xgboost import XGBClassifier
from sklearn.model_selection import cross_val_score
cross_val_score(XGBClassifier(), X, y)
您知道如何在 scikit 中构建 XGBoost 分类器和回归器并对其评分——轻松学习。
XGBoost 后续步骤
从 XGBoost 中获得更多需要微调超参数。XGBoost 由许多决策树组成，因此除了集成超参数之外，还有决策树超参数可以进行微调。查看这篇 Analytics Vidhya 文章，以及官方 XGBoost 参数文档开始使用。
如果你正在寻找更多的深度，我的书 用 XGBoost 和 scikit 手动渐变增强-从 Packt Publishing 学习 是一个很好的选择。除了广泛的超参数微调，您将了解 XGBoost 在机器学习领域的历史背景，XGBoost 案例研究的详细信息，如 Higgs boson Kaggle 竞赛，以及高级主题，如调整备选基础学习器(gblinear，DART，XGBoost 随机森林)和为行业部署模型。
编码快乐！
科里·韦德(Corey Wade)是 伯克利编码学院 的创始人和主管，在这里他向来自世界各地的学生教授机器学习。此外，Corey 在伯克利高中的独立学习项目中教授数学和编程。著有两本书， 用 XGBoost 和 scikit-learn 和The Python Workshop。
本文中的代码可能是直接抄袭了 科里的 Colab 笔记本 。
亚历山大·辛恩摄影:https://unsplash.com/photos/KgLtFCgfC28
了解神经网络中的激活函数。
什么是神经网络中的激活函数，为什么你应该知道它们？
马里乌斯·马萨拉尔在 Unsplash 上的照片
如果你有实现神经网络的经验，你可能会遇到术语“激活函数”。这个名字有印象吗？没有吗？‘relu，softmax 或者 sigmoid 怎么样？好吧，这些是在今天的上下文中最广泛使用的激活函数中的一些。当我开始研究神经网络的时候，我不知道激活函数到底是干什么的。但是有一点，在没有激活函数的可靠知识的情况下，我不能继续实现我的神经网络。我做了一些调查，以下是我的发现…
什么是激活功能？
简单来说，激活函数就是决定神经网络输出的数学方程。它们基本上决定去激活或激活神经元以获得期望的输出，因此得名激活功能。现在，让我们进入数学…
图 1
在神经网络中，作为数值的输入数据点(x) 被馈入神经元。每一个神经元都有一个权重(w) ，该权重将与输入相乘，并输出一个特定值，该值将再次馈入下一层的神经元。如图 1 所示，激活函数作为这个过程之间的数学门发挥作用，并决定某个神经元的输出是开还是关。
激活功能可以分为三个主要类别；二元阶跃函数、线性激活函数和非线性激活函数。然而，非线性激活函数由几种类型的函数组成。让我们深入了解一下…
1。二元阶跃函数
二元阶跃函数是一种基于阈值的激活函数，即在某一阈值神经元被激活后，低于该阈值的神经元被去激活。在上图中，阈值为零。顾名思义，这个激活函数可以用在二进制分类中，但是它不能用在需要处理多个类的情况下。
2。线性激活功能
在这里，我们的函数(输出)与神经元的加权和成正比。线性激活函数可以处理多个类，不像二元阶跃函数。然而，它也有自己的缺点。利用线性激活函数，反向传播中的变化将是恒定的，这对学习是不利的。线性激活函数的另一个巨大缺点是，无论神经网络有多深(神经网络由多少层组成)，最后一层总是第一层的函数。这限制了神经网络处理复杂问题的能力。
3。非线性激活功能
深度学习实践者今天处理高维度的数据，例如图像、音频、视频等。由于上述缺点，在我们使用神经网络的复杂应用中使用线性激活函数是不实际的。因此，目前广泛使用的是非线性函数。我们将看看一些流行的非线性激活函数。
- 乙状结肠功能。
Sigmoid 函数(也称为逻辑函数)采用概率方法，输出范围在 0-1 之间。它使每个神经元的输出正常化。然而，Sigmoid 函数对非常高或非常低的输入的预测几乎没有变化，最终导致神经网络拒绝进一步学习，这个问题被称为消失梯度。
- 双曲正切函数
双曲正切函数(也称为双曲正切函数)几乎与 sigmoid 函数相似，但略胜一筹，因为它的输出范围在-1 和 1 之间，允许负输出。然而，tanh 也带来了与 sigmoid 函数一样的消失梯度问题。
- ReLU(整流线性单元)功能
在该函数中，正输入的输出范围可以从 0 到无穷大，但是当输入为零或负值时，该函数输出零，这阻碍了反向传播。这个问题被称为垂死的 ReLU 问题。
- 泄漏的 ReLU
泄漏的 ReLU 防止了死亡的 ReLU 问题，并允许反向传播。Leaky ReLU 的一个缺陷是斜率是预先确定的，而不是让神经网络来计算。
还有相当多的其他非线性激活函数，如 softmax、参数 ReLU 等。这在本文中没有讨论。现在百万美元的问题来了！哪个激活功能最好？嗯，我的答案是这取决于 …这取决于你应用神经网络解决的问题。例如，如果您将神经网络应用于分类问题，sigmoid 将会很好地工作，但对于其他一些问题，它可能不会很好地工作，这就是为什么了解激活函数的利弊很重要，以便您可以选择最适合您正在处理的项目的激活函数。
如何在代码中包含激活函数？
也许几年前实现所有这些函数背后的数学可能非常困难，但现在随着 TensorFlow 和 PyTorch 等开源库的进步，这变得更加容易了！让我们看一个代码片段，其中使用 TensorFlow 将激活函数包含在代码中。
张量流中的激活函数
看起来很简单，对吗？由于 TensorFlow 更容易，因此实际理解这些激活函数非常重要，因为您的神经网络的学习过程高度依赖于它。
感谢您的阅读，希望这篇文章对您有所帮助。
资源
通过急流在几秒钟内了解您的功能
在 GPU 上端到端运行数据预处理管道
泰勒·拉斯托维奇在 Unsplash 上的照片
这篇博文旨在展示我最近在正在进行的Kaggle 竞赛中发表的特征选择笔记本。
当面对数据科学问题时，探索性数据分析，尤其是了解特性的重要性，是至关重要的一步。然而，如果您的数据库很大，有许多相互联系，使得分析在计算时间上很昂贵，那么这一步可能经常会很难。
GPU 在提高计算时间方面非常棒…如果你能使用它们的话！事实上，由于强大的框架(Tensorflow 或 Pytorch 是最著名的)使数百万开发者能够释放出他们不可思议的能力，它们的用途通常是用于训练神经网络。
然而，如果你要用 pandas 或 scikit-learn 完成一些脏的预处理，如果你的数据很大，那会非常繁重，因为这些包没有任何参数来帮助你在 GPU 上运行它们。综上所述，在这个阶段，你无法充分利用你的 GPU。
RAPIDS 是 Nvidia AI 开发的一套软件包，旨在完全在 GPU 上执行端到端的数据科学和分析管道。
本笔记本的目标是对 MoA 竞赛中的每个特征的每个目标进行单变量回归，即 872 x 206 = 179632 逻辑模型分别进行估计。
好消息是什么？有了激流这在几分钟之内是可能的！
你可以注意到，我既不导入 pandas(被 cudf 取代)，也不导入 scikit-learn(被 cuml 取代)。
这本笔记本将是一个教程，旨在帮助你熟悉图书馆的使用。最后，你将能够在你的特征中选择那些看起来对预测你的目标最重要的特征。这将使您能够构建具有更好可解释性的健壮的中型模型。
如果想跳过处理直接跳到结果，可以直接看一下结果这里。
第一步:熟悉 cuDF
首先，我导入所有必需的包，并加载数据。
你可以注意到 cuDF 完全等同于 pandas，除了它在 GPU 上做所有的事情:使用 read_csv 将数据直接读取到 GPU，你也可以在数据帧上尝试任何常见的操作，功能和语法都是相似的，正如你可以从我使用的 merge 方法中看出的。
第二步:熟悉 cuML
该函数旨在返回特征重要性度量。
最初，我报告了对每个目标、每个特征执行的单变量逻辑回归的二元交叉熵损失(我总共有近 18 万个任务要做)。单变量分析是一种原始但相当可靠且广泛使用的方法，用于估计给定目标的特征重要性。它使你能够分离出给定模型的单独解释能力。
你可以注意到，cuML 类(这里是 LogisticRegression )、函数(这里是 log_loss )和方法(这里是 fit 或 predict_proba )也完全等同于你可能已经习惯了的 sklearn 类。
但是，我必须缩放输出(为了在或多或少难以预测的目标之间进行比较，利用特征的平均损失)和反转值，以获得更好的可解释性:实际上，您会期望特征重要性在估计该特征上的给定目标的损失时降低。对于这一步，我使用 cuML MinMaxScaler 预处理类，它的工作方式与 sklearn 一样。
第三步:解读
计算某个特性在所有目标上的平均重要性对于全面了解它对您的整体模型的重要性非常重要。
但是，我不确定在区分要保留的特性和要删除的特性时，您是否应该完全依赖这个指标:事实上，一个给定的特性可能对一个特定的目标具有非常高的解释能力，而对所有其他目标都不相关，因此即使它的平均重要性分数很低，保留它对该目标的最终模型质量也是决定性的。我们的目标是保留对所有目标都具有高平均解释能力的特征(平均重要性阈值)，或者对其中一些目标特别相关的特征(最大重要性阈值)。请随意使用阈值！
你可能已经注意到了我对我的数据应用的小方法:因为它存储在 GPU 上，只是为了绘图的目的，我需要把它转换成 cpu。例如，这相当于您在 cuda 计算过程结束时在 PyTorch 上执行的 to_cpu() 。
基于用所选阈值操作的特征选择的进一步数据分析得出以下结论:
- 平均而言，在所有目标上，满足和两个标准的特性比不满足任何一个标准的特性平均重要 0.15 倍。
- 平均而言，满足一个标准的特性在所有目标上的最大重要性比不满足任何标准的特性高 0.19。
根据我们的分析，这是一个相当令人放心的观察结果。
第四步:结论
为了获得全局概述，我们可以比较两个子集上按目标划分的缩放特征重要性的热图，这两个子集是满足两个标准的特征和不满足任何标准的特征。很快就可以看出，第一张图要淡得多，单独的重要性更高。
现在，您可以依赖于您选择的功能，并使用它们来构建一个更轻的模型，更容易运行，也更容易解释！
让您的分析团队走上正轨！
成功分析团队的五个必要角色
你的分析团队只会和你的分析团队一样好。因此，组建合适的团队是绝对必要的。这意味着你需要雇用最适合你的团队的人以及合适的技能。但是在您确定所需的技能之前，您应该为您的团队成功定义必要的角色。
缺乏角色定义是分析团队失败的最常见原因之一。很多时候，一家公司只是从 IT 部门抽调一名数据库管理员，让他们为营销提供一些分析。或者，他们不是从中抽身，而是走到市场部，请其中一名设计师就他们提议的营销策略的有效性汇总一些数字，就好像这位设计师是一名分析师一样。
这两种方法都行不通，因为这些例子中的公司要求人们做他们没有资格做的工作。那不是个人的错。这些被管理层如此愉快地扔进角斗场“你能做这个你从未申请过的工作吗”的人很有能力完成他们真正的工作。但扮演分析师的角色与他们通常朝九晚五的活动完全不同，这就产生了一个问题。
在我看来，分析团队要取得成功，需要扮演五个不同的角色。这些角色中的一些可以由一个人来完成，只要他们的技能组合涵盖他们并且工作量不是太大。在较大的组织中，不止一个人会担任相同的角色，因为工作量非常大。
此外，请记住，这些角色被描述为彼此明确划分。通常，一个在其中一个角色上表现出色的人会在另一个角色上表现得很好，但最好是让一个在这方面也很出色的人来担任第二个角色，而不是让一个人以平庸的方式同时担任这两个角色。但请不要被误导。没有一个人能够完美地扮演所有五个角色。即使您的团队今天只有一个人，并且其中一些角色执行得不完善，这些也是您唯一的分析师正在执行的角色及其各自的活动。当你发展你的分析团队时，你也应该记住这些角色，这是你不可避免要做的。
vectorkif / 土坯股票
连接器
你有没有过这样的工作，老板会告诉你该做什么，但从来没有解释过它如何适应业务？有一项任务要执行，但没有可供您参考的上下文。也许你被要求完成的任务并不需要任何背景。只是你的好奇心让你渴望从你的老板那里得到更多的情境信息——或者可能是当有人只是把工作丢给你而不解释任何事情时，你觉得完全不把你当人看。我知道。这让我觉得自己就像手机上的一个应用程序。只是一个随叫随到的单调过程。
尽管这令人沮丧，但在某些职业中，这种方法效果很好。但是在分析中“没有背景”的方法有一个问题。没用。 时期。
分析需要背景。否则，您将面临产生歪曲事实的分析结果的高风险。没有适当的上下文，数据可能会说谎。如果你曾经听到有人说“相关性并不意味着因果关系”，缺乏上下文可能会导致同样的基本错误。没有上下文，你就不能正确地解释数据。当我说你需要背景时，我指的是数据最初是如何收集的背景和提出手头问题的背景。(为了说明这一点，你可能会注意到，仅在这一段中，我就用了 7 次“上下文”这个词。)
你的分析团队如何解决这个问题？简单。
输入连接器的角色。
想象一个乌托邦世界，其中存在一个虚构的生物，即使他领导着一个由个人组成的高度技术化的团队，领导层也高兴地与他分享他们的业务计划和目标。我知道——我只是在做梦，对吗？不。实际上，那是连接器的作用。
联系人既是分析团队的领导者，也是其与整个企业的联络人。连接器理解分析，所以他是技术型的。但他也了解业务，是一个优秀的沟通者。虽然这位连接器可能不会每天处理数字，但他完全理解这些数字以及用于计算这些数字的数据科学方法。他会见了整个公司的业务领导，以了解他们如何认为分析可以帮助他们的部门，同时也建议他们可能不会想到自己的方式。
在公司看到演示文稿或新仪表板之前，或者在高管拿到副本之前，连接器是演示文稿或新仪表板的最后一双眼睛。他将理解来自业务单元的请求在其业务环境中的价值。他还可以了解分析团队在试图发现见解或满足业务需求时面临的瓶颈或问题。
连接器是公司内分析团队的拥护者。他是公关人员，也是团队的导师和顾问，因为这涉及到与大公司的互动。这个角色非常重要，即使它不被认为是一个领导职位，这个人也应该在领导者的桌子上占有一席之地。
tigatelu / 土坯股票
牧马人
当然，并不是每个人都能和高管打成一片。必须有人关注实际数据的细节。当团队收到新的请求时，知道完成请求所需的每个数据点的位置的可能性接近于零。仔细想想，可能是零。
即使您知道所有的源数据都存储在哪里，找到以一种形式存储的数据以供分析并提供其见解也是绝对不可能的。有人需要将数据转换成可用的形式。需要进行计算。需要填充和更正缺失或错误的数据。在所有这些工作完成之后，最终的一组干净的、格式良好的和经过计算的数据必须存储在某个地方以供分析。
没错，这就是牧马人的工作。
虽然这个名字可能会让人联想到牛仔的形象，但这个角色是典型的数据人。他用 SQL 编写代码，从适当的来源提取数据，在没有人确切知道去哪里找数据时搜索数据，清理数据，转换数据，并将数据加载到其他人可以容易地找到并使用它的位置。
牧马人通常被称为数据管家或数据工程师，是分析团队中五个关键角色之一。这个人经常被安排在数据团队的 IT 部门，而数据团队也需要这样的人。但是分析团队需要自己的鼓手！
在分析团队中直接安排一名牧马人将减少因试图利用数据团队或 IT 部门的数据工程师而导致的瓶颈。它还确保分析团队知道他们的管理者非常熟悉他们用于分析工作的数据。
牧马人熟悉分析团队的需求，这种需求不同于在普通数据团队中工作的其他同类团队。他经常在事务性数据结构和分析性数据结构中思考，比如星形或立方体。
就像连接器是业务和分析团队之间的纽带一样，牧马人是源数据和分析团队之间的纽带。没有牧马人不要离开家！
T4 土坯股票
神探
小时候，我喜欢看间谍和侦探电影。仔细想想，我还是喜欢看间谍和侦探电影。这些年来没什么变化。这种对解开谜团和揭示真相的热爱是我年轻时进入技术领域的主要动力之一。如果你像我一样，这是个好消息！在分析团队中，通过扮演侦探的角色，你仍然可以成为一名侦探和公司的英雄。
侦探使用牧马人准备的数据作为她的线索。有时这会导致发现没人想到要问的问题。其他时候，这意味着回答执行董事会多年来一直在问的问题。高管们多年来问同样的问题，但仍然没有可靠的答案，这并不罕见。
侦探更为人所知的身份是数据分析师或数据科学家。这两个头衔都属于这个角色，即使他们的技能重叠，他们也不是同义词。数据分析师通常会发现数据中的趋势，并创建图表或可视化来帮助企业领导者做出更具战略性的决策。数据科学家更关注利用数据进行预测或优化整个公司流程的数学模型和算法。
在您的团队中同时拥有数据分析师和数据科学家非常有益。虽然他们不同，但这两个人有一个共同点。他们试图通过搜索证据(也称为数据)来揭示真相。
尽管夏洛克·福尔摩斯可能会觉得他的案子“很简单”，但大多数交给数据科学家的案子都不简单。有时他们找到答案，有时他们找到更多的问题。但这是驱使人们扮演这一角色的原因。他们的动机是调查和揭示事情的全部真相。
毫无疑问，侦探通常被认为是分析团队的主要职能。当然，事实要宽泛得多。分析团队应该提供见解。这需要本文中讨论的所有五个角色完成的工作。但这位侦探无疑是团队成功的核心人物。
视觉一代/ 土坯股票
艺术家
平面设计师是最有创造力的人。他们把一个以前没人会用的应用程序变成了他们公司有史以来最好的工具。这款应用从根本上做了什么不同于以前的事情吗？不，不是的。用户理解应用程序、参与应用程序以及直观理解应用程序的能力是否与以前不同？是啊！这是一个应用被采用的关键。
分析也是如此。这位侦探可能已经发现了最有用和最聪明的见解。她的发现可能会彻底改变公司的未来，或者将它从灾难中拯救出来。但是没有人会知道这些见解是否能够清晰直观地传达给决策者。
这就是为什么你的分析团队需要一个艺术家。当然，这不是一般的艺术家。不是反对艺术家，我热爱艺术！但是分析，就像统计一样，很容易被曲解。有时，如果不完全清楚的话，一个图表可能意味着不止一件事。当然，注意到新销售额正在飙升的事实可能会导致首席执行官做出非常不同的决定，直到她意识到自然减员与新销售额持平。
因此，分析团队中的艺术家需要对分析和设计有扎实的理解。这个人认为图表稍微偏离了中心，棕色是黑色背景上的一个糟糕的颜色选择，还可以建议从销售仪表板中删除十个数据点，以确保传达关键信息。
最后，如果你能找到一个在 UI/UX 方面有天赋的艺术家角色，那将是额外的奖励！在一天结束时，一份报告、一张图表、一个仪表板或者分析团队用来交流其发现的任何东西都具有用户交互的元素。在创建最终演示文稿和雇佣艺术家时，请记住这一点。
自动机
因此，您的团队已经完成了所有必要的工作，以了解和发现与您的供应链相关的见解。这些发现将彻底改变供应链为你的公司交货的方式。事实上，它太棒了，他们希望能够以一种持续的方式监控它—永远监控！
这是分析团队向企业交付高价值时的典型结果。你应该习惯它。每个人都在庆祝，互相拍着对方的背。关节碰撞和击掌声充斥着你的走廊，直到有人意识到这到底意味着什么——可能是你团队中安静的那个人注意到了。
为了向供应链交付这一惊人的成果，您的团队在几天、几周甚至几个月内花费了大量的时间和精力，这些都需要一直重复！庆祝活动突然停止，一丝恐慌悄然而至。
等等！不要害怕！这就是你的团队雇佣自动机器人的原因！遁遁遁遁。(有点超级英雄的音乐，因为每个好英雄都需要一些。)
Automator 是一名软件开发人员，他也了解您团队的核心工作——分析和数据。不要被骗了。大多数软件开发人员认为数据是放在数据库中，以后再显示的东西。那不是你要找的这个角色的人。
自动机将你的团队完成的所有艰苦工作，通过代码进行复制。通过这种方式，供应链现在期望的日常洞察力可以帮助他们保持在他们创造的惊人的新流程的顶部，这要感谢你的原创工作，可以在你的团队没有一次又一次地执行工作的情况下继续提供。
必须对数据、使用的分析过程和各种编程语言有扎实的理解。您可能优先考虑的语言是 SQL、Python、Javascript、C#以及任何特定于您的环境的语言，如 SAS 或 r。
自动机的重要性不能被高估。将一个富有成效的团队变成一群毫无用处的好心人的最快方法是发布一个需要定期、持续手动维护的仪表板。它不仅会摧毁你的生产力，还会摧毁你的团队。
当心没有自动机的分析团队。
将所有这些整合在一起
既然我们已经讨论了成功的分析团队所必需的五个角色，那么让我们来谈谈拥有这样一个团队有多现实。
你的团队可能会从小规模开始。它可能只从一个人开始——你。这是真的，你将努力扮演所有这五个角色。而且就算你能把五个都演好，也不会把每个角色都演好。随着工作量的增加和团队的壮大，记住你可以雇佣那些你不擅长的角色，这仍然会减少你的工作量。它可能会通过将实际的数据辩论工作卸载给高度熟练的数据辩论者来减少您的工作量，但它也减轻了您的情绪负担，因为您不再需要在您不擅长的领域中挣扎。
关键是，一个全面发展的团队拥有这五个角色中每一个角色的人才是可能的。成长需要时间，但你会的。你也可以找到这些人。你所寻求的技能没有什么独特之处。但是将这五种技能都放在分析团队中是独一无二的。很不幸，但这是事实。随着时间的推移，试图用一个未经培训就被提升为数据科学家的兼职数据库管理员来运行分析的公司的坏习惯，将让位于培养和发展具有这五种角色的团队，该团队专注于公司可以承担的最有益的任务之一，即利用他们拥有的信息来运营他们的业务。
所以，是的。随着您的不断成长，您可以通过专注于这五项能力来建立一个分析梦之队！祝你好运！
罗德蓖麻 帮助公司获得正确的分析！他与国际组织和小型企业合作，开始或改进他们在数据分析、数据科学、技术战略和技术领导力方面的工作。除了咨询，Rod 还喜欢公开演讲、教学和写作。你可以在rodcastor.com和applied ai . us了解更多关于罗德和他的作品。
让你的机器学习模型进入现实世界
机器学习系统
从业者来之不易的教训
丹·史沫特莱在 Unsplash 上的照片
过去几年中一个令人兴奋的发展是机器学习在产品中的扩散。我们现在看到最先进的计算机视觉模型被部署在手机上。最先进的自然语言处理模型正被用于改进 搜索。
虽然有许多关于新的、令人兴奋的机器学习算法的文章，但关于产品化机器学习模型的文章却不多。人们对这些系统的工程设计越来越感兴趣，例如 ScaledML 会议，以及 MLOps 的诞生。然而，生产机器学习模型是一项仍然短缺的技能。
在我迄今为止的职业生涯中，我在生产机器学习模型方面得到了一些来之不易的教训。以下是其中的一些。
建还是买？
推特最近一直在热议 GPT-3。在正确的种子的引导下，事实证明 GPT-3 可以做很多令人惊讶的事情，比如在网页上生成按钮和反应代码。在这些令人兴奋的发展的刺激下，你的利益相关者有了一个想法:如果你建立一个 GPT-3 的等价物来帮助加速你工作的公司使用 GPT-3 的前端开发会怎么样？
GPT-3 从语句中生成布局代码(来源:此处为)
你应该训练你自己的 GPT-3 模型吗？
哦，不！GPT-3 是一个 1750 亿参数的模型，需要谷歌和微软之外的大多数公司难以开发的资源。由于 OpenAI 正在测试其 GPT-3 API，因此更谨慎的做法是尝试一下，看看该模型是否能解决您的用例，以及该 API 是否能扩展到您的用例。
那么，买(更像是租)还是建？看情况。
这看起来像是一个逃避的答案，但它是软件行业中一个古老的问题。这也是一个如此庞大和复杂的主题，它应该有一个自己的帖子。
然而，在这里我可以提供一些指导方针，帮助你与利益相关者讨论购买与建造的问题。第一个是
这个用例不是核心能力吗？对于现有/潜在的 AWS 产品，它是否足够通用？
这个问题的基本原则是问你自己你将要从事的工作是否是公司核心竞争力的一部分。如果您的利益相关者能够负担得起，购买现成的解决方案可能是值得的。
数据之外的资源是否可用？例如人才和基础设施？
在其核心，建立和部署一个可靠的机器学习系统是仍然主要是软件工程，增加了一个转折:数据管理 。如果团队没有将模型构建为服务 API 的经验，没有收集、清理、标记和存储数据的经验，那么所需的时间可能会非常长，比如 1 到 2 年(甚至更长)。相反，部署第三方解决方案可能需要 3 到 6 个月，因为这主要是关于将解决方案集成到产品中。企业主会发现这种时间和成本的节省极具吸引力。
另一方面，如果这与公司的核心竞争力有关，那么投资建立一个能够基于公司专有数据设计和部署模型的团队是更好的方式。它允许对过程进行更多的控制和理解，尽管它会带来很高的初始投资开销。
只要记住
对企业主来说，最重要的是:你的模型的输出在企业环境中如何有用？
广义地说，机器学习是自动化的下一步。所以以这种方式思考，你的模式有助于增加收入，或者通过降低成本来提高业务效率。
例如，集成一个更好的推荐系统应该会带来更高的用户满意度和参与度。更高的满意度导致更多的订阅和有机推广，从而带来更高的收入和更低的流失率。
作为一名数据科学家，你必须帮助企业主做出是构建还是购买的最佳决策，这意味着要在业务环境中评估这两种方法的具体利弊。
这篇文章中的观点在处理“构建与购买”问题时非常有用，它也适用于机器学习产品。正如这里的所说，如果这是一项核心业务能力，就有理由自己去打造。
这一切都从源头开始
考虑搜索小狗照片的用户的搜索结果。这里我们有一个来自 Unsplash 的例子，一个来自 Shutterstock，最后一个来自 EyeEm，这次是在移动设备上。
来源: Unsplash
来源: Shutterstock
来源:手机上的 EyeEm
我们可以看到，虽然每个用户界面(UI)显示的图像范围很广。假设我们想要使用图像上的点击来训练一个给出更好搜索结果的模型。
如果你是用户，你会首先被哪张图片吸引？
在 Shutterstock 示例中，您可能首先被窗口最右侧的 puppy 吸引，但在 EyeEm 示例中，它可能是中间的图像。
很明显，每个 UI 之间的差异导致了所收集的数据分布的差异。
信息检索文献表明，显示结果时存在位置偏差和呈现偏差。用户完全有可能点击排名第一的结果，即使它与他们的搜索查询无关，仅仅因为这是他们看到的第一个东西，他们可能对结果很好奇！
我们可以看到，用于训练搜索排名模型的点击数据会有这些偏差，这是由 UI 的设计方式决定的。所以，
了解模型最终将在产品中的何处以及如何使用
数据科学家和机器学习工程师不能孤立地构建模型，因为模型最终会被使用。这样做的结果是，数据科学家必须与产品中涉及的所有专业人员合作:产品经理、设计师、工程师(前端和后端)和质量保证工程师。
跨职能团队工作提供了好处，包括向所有团队成员简要介绍模型的局限性，以及它如何影响 UI 设计，反之亦然。另一个是找到简单、可靠的方法来解决问题，例如，不要使用机器学习来解决固有的 UI(和用户体验)问题。设计者还可以想出一些方法来使模型结果的呈现看起来令人惊叹，以及约束 UI 中的用户操作来限制进入模型的输入空间。
数据科学家必须建立关于产品的领域知识，包括为什么做出某些 UI 决策，以及如果产品发生变化，它们如何影响您的下游数据。后一点尤其重要，因为这可能意味着当产品变更推出时，您的模型很快就会过时。
此外，如何呈现模型的结果是很重要的，以便在未来的训练数据中最小化偏差，正如我们将在接下来看到的。
数据收集仍然具有挑战性
分析收集通常依赖于工程师在他们负责的服务中为产品的各个部分设置分析事件。有时，分析没有被收集，或者收集的数据中带有噪音和偏见。分析事件可能会被丢弃，从而导致数据丢失。点击一个按钮没有去抖，导致多个重复事件。
不幸的是，机器学习模型通常是这些分析数据的下游消费者，这意味着测量和数据收集的问题会对模型产生巨大影响。
如果关于数据有一件事需要记住，那就是
数据是测量的副产品
这意味着了解数据来自哪里，以及如何收集数据是很重要的。正确地进行测量也是至关重要的，定期对测量系统进行测试以确保良好的数据质量。与工程师和数据分析师一起工作以直接了解问题也是谨慎的，因为在收集的数据中通常有一个“陷阱”。
存储的数据需要进行编码，以适应业务领域。让我们以图像存储为例。在大多数领域，有损 JPEG 图像可能可以很好地编码您存储的图像，但在一些需要非常高分辨率的领域，例如使用机器学习来检测 MRI 扫描中的异常，就不适合。将这些问题提前传达给帮助您收集数据的工程师非常重要。
研究中的机器学习不同于产品中的机器学习，因为通常你最大的胜利来自更好的数据，而不是更好的算法。然而，也有例外，例如深度学习在许多领域提高了性能指标。即使这样，这些算法仍然对训练数据敏感，你需要更多的数据。
说服你的利益相关方继续投资改善数据收集基础设施 总是值得的。有时，即使是构建新功能的新数据源也能提升模型性能指标。它不仅有助于更好的模型，还有助于更好地跟踪公司的关键指标和整体产品特性。和你一起工作的数据分析师会为此而非常感激。
一位前 Dropbox 数据科学家最近告诉我
您最大的改进通常来自与工程师坐下来改进分析
检查你对数据的假设
这是我在战壕中亲身经历的一个故事。
在 Canva 整合从学习到排名模型以改善图像搜索的早期，我们计划使用一套来自 Mechanical Turk 的相关性判断。Canva 有一个图形设计编辑器工具，允许用户搜索超过 5000 万张图片，并将其纳入设计中。
基本上，我们收集了几组成对的判断:对于每个搜索词，给评分者一对图片，其中一张他们竖起大拇指。术语萤火虫的成对判断评级示例如下所示。虽然两者都是相关的，但是评价者更喜欢左边的图像而不是右边的图像。
对搜索词“萤火虫”的成对判断:评价者更喜欢左边的图像而不是右边的图像(来源:作者)
然后，我们使用这些成对的判断训练了一个模型，另一个模型只依赖于搜索日志的点击。后者有更多的数据，但由于位置偏差和错误的点击，质量较低。这两个模型在离线排名指标上看起来都很棒，并且对结果进行了视觉检查(即手动，用我们的眼睛)。
然而，在在线实验中，依赖于这些来源的相关性判断的模型与控制和其他模型相比，具有非常差的性能，降低了业务指标。
发生了什么事？
事实证明，我们的判断来源于而不是用户搜索符合其设计的图片的背景，而不仅仅是纯粹的搜索相关性。这种缺失的上下文导致数据集的分布不同于产品中的数据分布。
不用说，我们的假设是错误的。
数据分布不对称是一个非常现实的问题:即使是在谷歌的 Google Drive 中实现快速访问功能的团队也面临着 it⁴.在这种情况下，为开发环境收集的数据分布与最终部署环境的数据分布不匹配，因为培训数据不是从生产服务中收集的。
用于训练模型的数据应该与部署模型的最终环境相匹配
要检查的其他假设示例有
- 出现了概念漂移，数据分布发生了重大变化(最近的一个例子是新冠肺炎疫情扰乱了预测模型)，
- 特征 的预测能力进入模型，因为一些特征的预测能力随着时间而衰减，并且
- 产品弃用，导致功能消失。
通过设置监控系统来检查数据质量和模型性能指标，以及标记异常，这些问题可以得到部分解决。谷歌在这里提供了一份很好的清单，对你当前的生产机器学习系统进行评分，包括要注意的数据问题。
记住，如果谷歌的一个团队在部署机器学习系统方面的成熟度是世界上最好的团队之一，有数据假设问题，你当然应该仔细检查你对训练数据的假设。
把一切都包起来
机器学习系统是非常强大的系统。它们为公司提供了创建新产品功能、改进现有产品功能和提高自动化程度的新选择。
然而，这些系统仍然很脆弱，因为有更多关于它如何设计的考虑，以及如何收集数据并用于训练模型。
关于这个话题，我还有更多要说的，但现在这些就够了。
[1]替换为您最喜欢的云提供商。
[2] Thorsten Joachims，Laura Granka，Bing Pan，Helene Hembrooke 和 Geri Gay，准确地将点击链接数据解释为隐式反馈，在 Proc .第 28 届 ACM SIGIR 国际信息检索研究与发展年会(SIGIR)，第 154–161 页(2005)。
[3]宋轶·岳、拉詹·帕特尔和海因·罗里格，超越位置偏差:检验结果吸引力作为点击链接数据中呈现偏差的来源，在 Proc .万维网(WWW)第 19 届国际会议，第 1011–1018 页(2010)。
[4] Sandeep Tata，Alexandrin Popescul，Marc Najork，Mike Colagrosso，Julian Gibbons，Alan Green，Alexandre Mah，Michael Smith，Divanshu Garg，Cayden Meyer，Reuben Kan，快速访问:为 Google Drive 构建智能体验，KDD 2017:第 23 届 ACM SIGKDD 知识发现和数据挖掘国际会议论文集，第 1643–1651 页(2017)
在 Ubuntu 18.04 上准备好使用 Yolov3 对象检测器
这篇文章展示了如何使用 yolov3，更具体地说是 AlexeyAB 的 yolov3 Github repo，让您的机器为对象检测做好准备。
在安讯，我们的目标是站在计算机视觉开发的前沿。因此，我们喜欢与发生在更广阔的计算机视觉领域的最佳作品保持同步。其中包括跟踪部署的最佳系统，比如 darknet。
这篇文章展示了如何使用 yolov3，更具体地说是 AlexeyAB 的 yolov3 Github repo，让您的机器为对象检测做好准备。这是一篇关于启动虚拟机、安装必要的软件包和初步测试以确保您准备好开始对象检测所需的步骤的高级帖子。这篇文章使用了几个教程，我发现它们在安装这些依赖项的过程中很有用。主要步骤如下:
- 启动本地机器或虚拟机，确保你的 GPU 支持 Cuda。
- 克隆必要的 GitHub repos
- 安装 OpenCV 并用 OpenCV 测试 darknet
- 安装 Cuda、Cudnn 和其他必要的软件包，以加快 GPU 中的训练过程。
1.云计算资源
如果你有一台支持 GPU 的机器，你可以跳到第 2 步。否则，获得一个带有 GPU 的虚拟机对于对象检测任务来说将是非常重要的，这样可以大大加快速度。在这次演练中，我们将使用 Microsoft Azure 机器，但任何带有 GPU 或任何其他云计算服务的本地机器显然也可以工作。
- 一旦你在 Azure 中设置了你的帐户，你就可以导航到你的家，然后检查虚拟机服务。
- 单击“添加+”按钮，这将打开“创建虚拟机页面”。确保您已经设置了一个资源组，否则您必须在开始设置实例时创建它。
- 这里的关键部分是为您的虚拟机选择大小。在 Azure 中启动新虚拟机时，在配置的第一页上，您会发现“更改大小”选项。点击它，选择一个“系列”栏显示 GPU 的大小。
在 Azure 中更改虚拟机的大小
- 一旦创建了机器，您仍然可以在以后进行配置，因此，例如，如果您想要添加磁盘空间或更改到另一个机器系列，这是可能的。一旦你启动它，你可以 ssh 进入它，你可以确保你的机器有一个 CUDA 支持的 GPU 与
lspci | grep -i nvidia
虽然 GPU 的细节可能有所不同，但输出应该与下面的截图有些相似。
显示支持 CUDA 的 GPU 详细信息的输出
如果你是 Azure 新手，这本入门指南可能会非常有用:
2.克隆 Github repos
- 如果您的 github 帐户启用了 ssh，只需
git clone [git@github.com](mailto:git@github.com):AlexeyAB/darknet.git
- 如果这是一个新的虚拟机，您可能需要先安装 git:
sudo apt install git-all
完成后，确保它正常工作，您的工作目录看起来应该类似于以下内容:
克隆 AlexeyAB darknet repo 后的工作目录
- 您还需要几个其他的依赖项:
sudo apt install make
- 如果你还没有，你将需要 C 编译器
gcc和g++。你可以和which gcc和which g++核实一下。如果没有安装，您可以使用以下命令进行安装。
sudo apt install gcc
sudo apt install g++
- 现在我们已经准备好测试 darknet repo(没有 OpenCV，也没有使用 GPU 进行训练或预测。去暗网目录试试
$make。您应该会在控制台上看到大量警告消息和打印输出，如果没有错误，那么从技术上讲，您已经准备好开始对象检测了。尝试$ ./darknet命令，您应该会在控制台上看到以下输出:
usage: ./darknet <function
3。在 Ubuntu 18.04 上安装 OpenCV 3 . 4 . 4
按照这些步骤，您将安装 OpenCV3.4.4，但是对象检测 repo 应该也可以与版本 4+一起工作。
这个是我发现的最容易跟随的教程之一。Adrian Rosebrock 很好地解释了你复制和粘贴的步骤，这样你就能理解这些依赖项的作用了。他也有很好的替代方法来应对步骤可能会向您抛出错误的情况。
所以去看看吧，希望一切顺利。
您可以通过在命令行中打开 python 进程并输入以下命令来检查安装是否成功
import cv2
print(cv2.__version__)
现在检查一下 darknet 现在是否能与 opencv 一起工作:
更改/darknet/目录中的 Makefile 以显示OPENCV=1，然后重新make。正如官方文档中所述，您可以使用./darknet imtest data/eagle.jpg对此进行测试，尽管请记住，如果您在虚拟机上工作，您会遇到“无法打开显示”错误，但此时一切都应该正常工作，并且您应该可以在测试图像上看到检测概率。
4。在 Ubuntu 18.04 上安装 CUDA 和 cud nn
你可能想在 GPU 上运行 darknet，所以你需要安装 CUDA 和 CUDNN。" CPU 上的 Darknet 速度很快，但在 GPU 上要快 500 倍！"—约瑟夫·雷德蒙
这是由马赫迪-61 发布的的一个非常有用的帖子，其中的脚本执行了安装的大部分。继续完成这些步骤。
这篇文章还强调了如何删除以前的 CUDA 安装:
sudo apt-get purge nvidia*
sudo apt remove nvidia-*
sudo rm /etc/apt/sources.list.d/cuda*
sudo apt-get autoremove && sudo apt-get autoclean
sudo rm -rf /usr/local/cuda*
如果您想要不同的 Cuda 或 CUDNN 版本，只需在上面的脚本中将下载文件更改为所需的版本。
要确保安装成功，请尝试
nvidia-smi
成功安装 cuda 的预期产出
最后，尝试
nvcc -V
希望你能得到
显示 nvcc -V 结果的输出
最后，重要的是要确保所有这些都与 darknet 一起工作，然后我们可以开始测试对象检测器。
将 darknet 目录中的 Makefile 更改为:
Makefile 的头
如果make命令成功，那么你就可以开始测试了。
如果你想用真实的重量来测试
wget [https://pjreddie.com/media/files/yolov3.weights](https://pjreddie.com/media/files/yolov3.weights)./darknet detect cfg/yolov3.cfg yolov3.weights data/dog.jpg -dont_show
希望这份高水平的食谱能让你的机器为 AlexeyAB repo 的 yolov3 物体探测器做好准备。
ggplot:使用 Plotnine 的 Python 中的图形语法
数据可视化
强大的图形库，提供出色的可视化效果
你希望 Python 能模仿 R 语言中 ggplot 给你的出色可视化效果吗？嗯，可以的。
我们将探索 Plotnine 的功能，这是一个基于 ggplot2 的 Python 可视化库。
能够可视化您的数据使您能够更好地理解它。它让您有机会深入了解数据元素之间的关系，并发现相关性和依赖性。R 中的 ggplot 和 Python 中的 Plotnine 为您提供了以逻辑方式实现这一点的能力。
要做到这一点，你不需要成为 Python 专家，尽管接触一些 Python 编程会很有用，对 Pandas 中的数据帧有基本的了解也会很有用。
如果你也熟悉 Jupyter 笔记本，那将会很有帮助。
ggplot
ggplot2 是一个强大的 R 图形库，在 Hadley Wickham ( 附属链接)的书“ ggplot2:优雅的数据分析图形”中有所描述。韦翰，反过来，他的工作基于“图形的语法”，由利兰威尔金森的一本书。Wilkinson 的书给出了图形语法的理论基础，Wickham 的书展示了如何实现这种语法(在 ggplot2 中)。
ggplot2 实现了一种构建图形的分层方法，并允许使用标准例程来构建流行的图形和图表，或者构建自定义图形来满足您自己的目的。
Plotnine 基于 ggplot2，用 Python 实现。
根据您的 Python 安装，您可以使用 pip 来安装它:
pip install plotnine
或者康达:
conda install -c conda-forge plotnine
本文将重点介绍如何构建和定制标准图形——线条、条形图等——使用图层来修改这些图，并希望对您如何制作自己的定制图有所启发。
然后，在你的程序中，你的第一行应该是
from plotnine import *
层
ggplot 命令有三个基本要素:数据、美学和图层。数据的作用是明确的，我们应该以熊猫数据框架的形式提供它。美观是数据中的变量被映射到视觉属性上的地方，而层描述了如何呈现数据，例如，作为一个条形图。可以有几个层来定义不同的图表或图表的一部分，例如轴上的标签。
在 R 中，ggplot2 中的命令类似于:
ggplot(data, aesthetics)
+ layer1()
+ layer2()
Plotnine 使用了相同的模式，但这并不十分符合 Python 语法。你可以写:
ggplot(data,aesthetics) + layer1() + layer2()
但是你可能会排很长的队。不过，解决方法很简单。把整个事情用大括号括起来。所以我们最后得到了:
(ggplot(data,aesthetics)
+ layer1()
+ layer2()
)
因此，这是我将在本文中使用的风格。
获取数据
如果你已经了解了我对熊猫图和 T2 图的可视化介绍，你会对我使用的天气数据很熟悉。这是来自英国气象局的公开数据，并绘制了伦敦过去几十年的天气数据。
这些数据记录了每个月的最高和最低温度、日照时间和降雨量。有两个表，一个是 1957 年的完整数据，一个较短的表只记录了 2018 年的数据。
我们先拿 2018 年的数据。
import pandas as pd
weather=pd.read_csv(‘[https://raw.githubusercontent.com/alanjones2/dataviz/master/london2018.csv](https://raw.githubusercontent.com/alanjones2/dataviz/master/london2018.csv)')
weather
这是它看起来的样子:
Year 列是相当多余的，但是与更大的数据文件是一致的。其他列不言自明。月份从 1 到 12，温度以摄氏度为单位，降雨量以毫米为单位，日照以小时为单位。
所以，从 ggplot 开始，我们要画一个每个月最高温度的线图。然后，我们将添加一些层来增强图表。
线形图
对 ggplot 调用的剖析如上所述。第一个参数是我们将要绘制的数据，天气，下一个参数是对 aes 的调用。aes 将数据映射到不同的“美学”上——这里我们只有两个。默认情况下，前两个参数是 x 轴和 y 轴。所以这里的月在 x 轴上，Tmax 在 y 轴上。
这本身是对 ggplot 的合法调用，但它不会绘制任何东西。为此，我们需要添加一个层来告诉 ggplot 我们想要什么样的图形。图形类型称为 geoms ，我们这里使用的是 geom_line ，这当然是一个线图。
(ggplot(weather,aes('Month', 'Tmax'))
+ geom_line()
)
这是一个好的开始，但是我们可以做得更好。例如，您会注意到月份是数值而不是实际日期，所以折线图将它们解释为实数。这意味着我们最终的月份从 2.5 到 12.5 不等——这并不理想。
我们可以通过在 graph 函数中添加另一层来轻松解决这个问题。ggplot 允许我们指定每个轴的刻度，所以我们将添加一个层来完成这项工作。我们希望刻度是数字 1 到 12，这正是月份列中的数字。因此，我们将使用该数据来告诉 ggplot 分笔成交点应该是什么。
为了方便起见，我将使用一个变量月。像这样:
months = weather['Month']
这是完整的代码
months=weather['Month'](ggplot(weather,aes('Month','Tmax'))
+ geom_line()
+ scale_x_continuous(breaks=months)
)
这样更好，但是如果我们想用字符串标记月份，比如“一月”、“二月”等等，那该怎么办呢？当然，我们可以改变表格中的数据，但是这篇文章是关于 ggplot 的，所以我们将使用它。
另外，我不喜欢默认的配色方案。ggplot 附带了许多我们可以使用的主题，所以我将添加另一个层来指定我要使用光主题，并向几何线添加一个参数来告诉它绘制一条红线而不是默认的黑线。
month_labels=("Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec")(ggplot(weather,aes('Month','Tmax'))
+ geom_line(color='red')
+ scale_x_continuous(breaks=months,labels=month_labels)
+ theme_light()
)
我认为这是一个进步。
让我们用柱形图做同样的图。
柱状图
要画柱形图，我们只需交换几何图形。我们用 geom_col 代替 geom_line 。简单。唯一需要注意的是，如果我们想改变条形的颜色，我们需要指定一个“填充”。有一个参数“颜色”,但这只改变列的轮廓。
(ggplot(weather,aes('Month','Tmax'))
+ geom_col(fill='red')
+ scale_x_continuous(breaks=months, labels=month_labels)
+ theme_light()
)
这是同样的雨的情况——适当的雨的颜色变化。
(ggplot(weather,aes('Month','Rain'))
+ geom_col(fill='green')
+ scale_x_continuous(breaks=months, labels=month_labels)
+ theme_light()
)
多重图表
我想在同一个图上画出 Tmax 和Tmin——我该怎么做？
最好的方法是转换数据，使两个温度在同一列中，并在单独的列中标记为 Tmax 或 Tmin 。这很容易用熊猫融化功能完成。在这里，我创建了一个新的 dataframe temps 和所需的列。
temps = pd.melt(weather, id_vars=['Month'],
value_vars=['Tmax','Tmin'],
var_name='Temp', value_name='DegC' )
temps
现在我用柱形图绘制它们。这里有几件事需要注意。首先，我已经将填充从 geom 中取出，并将其放入对 aes 的调用中，并将其分配给 Temps (它将是 Tmax 或 Tmin )。
在 geom 中指定一种颜色会固定该 geom 中的颜色，而通过将其放入 aes，我可以告诉 geom 为每个 Temp 值的列指定不同的颜色。因此，geom 列现在将为两个单独的条着色，一个表示 Tmax，另一个表示 Tmin。默认情况下，这些条是堆叠的，但这里我们希望它们是并排的。
第二件事是，在 geom 列中，我将位置指定为“dodge ”,这为我们提供了并排配置。
(ggplot(temps,aes('Month','DegC',fill='Temp'))
+ geom_col(position='dodge')
+ scale_x_continuous(breaks=months)
+ theme_light()
)
这是同样的东西，但是有线条。注意，我为线条指定了颜色而不是填充，我不需要担心位置。
(ggplot(temps,aes(‘Month’,’DegC’,color=’Temp’))
+ geom_line()
+ scale_x_continuous(breaks=months)
+ theme_light()
)
更多图层-标签
正如你所看到的，为了给情节添加更多的东西，我们添加了更多的层。要修改图表上的标签，我们也可以这样做。在下一段代码中，我添加了图层来指定 x 轴和 y 轴上的标题，并给整个图表添加了一个标题。
(ggplot(temps,aes('Month','DegC',color='Temp'))
+ geom_line()
+ scale_x_continuous(breaks=months)
+ theme_light()
+ xlab('2018')
+ ylab('Temperature in degrees C')
+ ggtitle('Monthly Maximum and Minimum Temperatures')
)
更多层—刻面
让我们考虑画一张图来总结整个数据表。降雨量和日照两种温度的柱形图。
首先，我们再次熔化数据帧，但这次我们将所有数据放在一列中。每个值将被标记为 Tmax 、 Tmin 、 Rain 或 Sun 。
data = pd.melt(weather, id_vars=['Month'],
value_vars=['Tmax','Tmin','Rain','Sun'],
var_name='Measure', value_name='Value' )
为了创建刻面图，我们添加了一个 facet_wrap 层，并将测量值传递给它，这意味着我们将获得 Tmax、tmin、Rain 和 Sun 中每一个的刻面。默认情况下，这些面将使用相同的比例，这对于 Tmax 和 Tmin 来说是合适的。但是雨和太阳是不同的，温度也是不同的。所以我们需要告诉 facet_wrap 刻度是‘自由’的，也就是说，每个刻面都有自己的刻度。
问题是这样做意味着 y 轴的标签会与图表重叠，所以我们需要用另一个图层来调整布局。最后一层是主题的修改( theme_light )，在小平面之间增加额外的空间，并设置图形的整体大小。注意这必须在 theme_light 图层之后，否则 theme_light 会将布局重置为默认设置。
(ggplot(data, aes('Month','Value', fill='Measure'))
+ geom_col(show_legend=False)
+ scale_x_continuous(breaks=months,labels=month_labels)
+ facet_wrap('Measure', scales='free')
+ xlab('')
+ ylab('')
+ ggtitle('Weather Data for London, 2018')
+ theme_light()
+ theme(panel_spacing=0.5, figure_size=(10,5))
)
结论
这是 Plotnine 用 Python 实现的 ggplot 的一些方面和特性的随机演练。我希望你能看到这种方法的力量，并鼓励你去读读 Hadley Wickham 关于 ggplot2 的书，看看 Plotnine 文档。
如果您想了解未来的文章，请免费订阅我的 简讯 。
ggplotly() —扩展 tidyverse 中最棒的降压函数
使您的 ggplot 图与单个函数调用交互
我是 tidyverse 和 ggplot 的忠实粉丝。tidyverse 是一个用于探索性数据分析的优秀框架，ggplot 非常棒。这些工具提供的导入数据、重塑数据和可视化数据的能力非常强大。
除了核心 tidyverse，还有许多支持包。在所有的函数中，在所有这些包中，有一个函数为单个函数调用提供了大量的值。
ggplotly()
这是一个单一的函数调用，您可以围绕您的 ggplot()函数进行交互式可视化。
我发现它带来的主要价值是:
- 您可以缩放和平移绘图
- 您可以将鼠标悬停在点上来查看它们的值
运行起来很简单:
- 您只需要将现有代码包装在 ggplotly()中
- 安装就像 install.packages 一样简单
例子
例如，我使用 ggplot 创建了一个标准的散点图。这是我很多数据探索的通常起点。
iris %>%
ggplot(aes(x=Sepal.Length,y=Sepal.Width,color=Species)) +
geom_point()
从这里开始，我经常想放大并进一步研究数据。为此，我的标准模式是将数据帧通过过滤器传输到 ggplot:
iris %>%
filter(Sepal.Length < 7, Sepal.Length > 5) %>%
ggplot(aes(x=Sepal.Length,y=Sepal.Width,color=Species)) +
geom_point()
然后，我可以缩小这些过滤器的范围，隔离出我感兴趣的点，如果我想详细查看这些点，我可以将对 ggplot()的调用替换为对 View()的调用，如下所示。
iris %>%
filter(Sepal.Length < 7, Sepal.Length > 5,
Sepal.Width < 4, Sepal.Width > 3) %>%
View()
这些技术可行，但可能有点复杂。通常，我真正想要的是能够使用 ggplot()创建一个可视化，同时还能够与它进行交互以放大。这就是 ggplotly()的用武之地。
ggplotly(iris %>%
ggplot(aes(x=Sepal.Length,y=Sepal.Width,color=Species)) +
geom_point())
这里的关键价值是，我可以像往常一样使用 tidyverse 创建我的图，然后简单地将它包装在一个函数调用中，使它具有交互性。这对于探索性的数据分析非常有用。
我还发现 ggplotly()是闪亮仪表板的一个有价值的补充。我认为 ggplotly()提供的缩放和悬停信息功能在 Shiny 中更有价值。我认为这是因为仪表板经常被其他人使用，而不是构建图表的人，所以不太熟悉数据集。我还认为交互式 ggplotly()图比静态图和一个闪亮应用程序上的一组过滤器滑块更令人满意。
我已经上传了这个情节的现场版本到 RPubs，如果你想自己玩，可以通过下面的链接访问。当然，这很容易开始，你还不如自己动手。
[## RPubs
基本 ggplotly()示例
rpubs.com](http://rpubs.com/OwenFlanagan/565119)
使用 TensorFlow 进行 Ghost 写作
Aditya Chinchure 在 Unsplash 上拍摄的照片
人工抒情生成的 RNN 建筑比较
音乐一直被认为是最有影响力和最强大的艺术形式之一。因此，它被用来表达艺术家的原始情感，并将其传递给听众。
作为一名音乐爱好者，很自然地会想知道使用递归神经网络(RNNs)生成歌词会有多困难。我真的很喜欢说唱和嘻哈音乐，所以我选择了这些流派的艺术家。这也是一个很好的配合，因为有关于说唱歌词生成的现有研究。
递归神经网络可以用于许多语言建模任务，例如:聊天机器人、预测键盘和语言翻译。当涉及到文本生成时，递归神经网络工作良好，因为它们能够处理顺序数据。这是有益的，因为我们需要保留一个句子的上下文，或者在这种情况下，一首诗的上下文。
对 RNN 如何工作的一种解释是，它查看序列中以前的数据来预测序列中的下一个元素。比方说，我们有一个训练有素的 RNN 在你的手机键盘上进行文本预测(你知道，当你打字时弹出的单词预测)。根据我之前输入的信息，我可以输入类似“Wezley 是超级……”的内容，神经网络将接受这一序列，并给出一组预测词，如:“酷”、“聪明”和“有趣”。
架构概述
为了增加这个实验，我想训练不同的递归神经网络架构来执行 rap 歌词生成。我选择了简单神经网络、门控循环单元、长短期记忆和基于卷积神经网络+长短期记忆的架构。我选择这些是为了确保我们能够相互测试每个架构，以确定哪个架构在给定的任务中表现最好。除非我们尝试，否则我们不知道一个模型是否会优于另一个，对吗？
SimpleRNN 体系结构更适合作为基线，看看其他体系结构的性能如何。由于消失梯度问题，简单的 RNN 体系结构不太适合这个特定的任务。这意味着 SimpleRNN 在记忆整个小节/诗的上下文时不是很有用，因为它会丢失序列中的早期信息。这导致了不连贯的诗句，你会在文章的后面看到。如果你很好奇，想要一个 TL；博士的模型如何表现:我们得到的诗句，如“我是什么石头私人卧室现在”或“如何改变了低最后气吉他的事情。”这两个诗句都是从德雷克歌词的数据集生成的。这两个都没什么意义。然而，我认为他们仍然是火吧。
门控循环单元架构是我测试的下一个架构。门控循环单位不同于 SimpleRNN，它能够记住序列中稍靠下的部分。它通过利用两个门来实现这一点，一个复位门和一个更新门。这些门控制先前的序列信息是否继续通过网络，或者是否更新到最近的步骤。我将在本文中对此进行更深入的探讨。
这个项目测试的另一个架构是长短期记忆架构。LSTM 与简单神经网络的不同之处在于，它能够记住序列中更靠后的部分。LSTM 比 GRU 更有优势，因为它稍微复杂一些，能够记住更长的序列。LSTM 有三个门，而不是两个，控制它遗忘的信息，按顺序进行，并从最新的一步更新。同样，LSTM 将在本文的稍后部分进行更深入的讨论。
我测试的最终架构是一个卷积神经网络和长短期记忆 RNN 的混合体。我把这个作为一个思想实验，基于我读过的一篇使用 C-LSTM 架构进行文本分类的论文(参考 Colab 笔记本)。我想知道 CNN 是否会允许 LSTM 概括一个酒吧，更好地理解艺术家的风格要素。虽然在文本生成问题上看到 CNN 很有趣，但我并没有注意到这和 LSTM 模型之间有什么不同。
获取数据集
创建了一组定义好的架构后，我开始寻找我想用于解决这个问题的数据集。
数据集对我来说并不重要，只要它包含著名艺术家的歌词。我想根据我经常听的艺术家创作歌词。这是为了让我能够识别模型是否能够生成类似的歌词。不过不要担心！我不会仅仅根据我认为好听的东西来决定一个模特的表现。我还使用了一组在最近的相关文献中描述过的指标。
我在 Kaggle 上找到的数据集是由 Paul Mooney 提供的。
这个数据集很棒，因为它包含了我听的许多说唱/嘻哈艺术家的歌词。它也没有任何奇怪的字符，并照顾到一些明确的歌词审查。
准备数据
有了数据集，我开始加载和准备用于训练的数据。
我做的第一件事是载入数据并完成审查。我使用一个预先存在的 Python 库来执行审查，这样我就不必手动创建一个“不良词汇”列表。不幸的是，图书馆没有审查每一个词，所以如果你在这篇文章的出版笔记本中偶然发现一些明确的东西，我道歉。
歌词被读入并审查后，我继续将它们分成一系列小节。我没有对这些条进行任何其他处理，但是将来我可能会再次尝试，给每个条添加
完成数据分割后，我利用 markovify Python 库创建了一个 Markov 模型。马尔可夫模型将被用于生成每个条形的开始序列。这将有助于我们确保在将序列传递给训练好的模型之前，序列的开始是有点连贯的。然后，模型将获取序列，并完成为酒吧生成歌词。
下一步是将歌词符号化，以便它们是模型可以理解的格式。标记化实际上是一个非常酷的过程，因为它基本上是将单词拆分成一个单词字典，并与 id 相关联，然后将每个条形改变成一个相应单词 id 的数组。在发布的笔记本中有一个这样的例子，但这里有另一个这样的例子:
举个例子，假设我们要标记以下句子:
- 《威兹利很酷》
- 《你很酷》
- “tensor flow 很酷”
将产生以下序列:
- 【1，2，3】
- 【4，5，3】
- 【6，2，7，3】
其中单词字典是:
['Wezley' : 1，' is' : 2，' cool' : 3，' You' : 4，' are' : 5，' TensorFlow' : 6，' very' : 7]
照这样，这些序列不能被输入到模型中，因为它们的长度不同。为了解决这个问题，我们在数组的前面添加了填充。
使用填充，我们得到:
- 【0，1，2，3】
- 【0，4，5，3】
- 【6，2，7，3】
将条形标记化后，我终于能够创建用于训练的 X 和 y 数据了。train_X 数据由整个条形组成，减去最后一个字。train_y 数据是栏中的最后一个字。
展望未来，就像在条形上添加
定义模型
数据被导入并分成 train_X 和 train_y 集合。是时候定义模型架构并开始培训了。
首先是 SimpleRNN 架构！SimpleRNN 将提供与 GRU、LSTM 和 CNN+LSTM 架构的良好基线。
SimpleRNN 单位可以用算术方法表示为:
其中 h(t) 表示为给定时间点的隐藏状态 t 。正如您在等式中看到的，SimpleRNN 依赖于先前的隐藏状态 h(t-1) 和当前的输入 x(t) 来给出当前的隐藏状态。
SimpleRNN 很棒，因为它能够处理序列数据。不足之处在于它的简单性。SimpleRNN 不能记住序列中更靠后的数据，因此受到消失梯度问题的困扰。当我们开始进一步深入序列时，消失梯度问题就出现了。这是早期状态难以表达的时候。SimpleRNN 中没有机制来帮助跟踪以前的状态。
消失梯度可视化
在代码中，SimpleRNN 网络看起来像:
简单网络架构
送入网络的数据仅表示为一个 NT 向量，而 SimpleRNN 需要一个 NT*D 向量。我们通过添加一个嵌入层来修正这个问题，给向量一个 D 维。嵌入层允许将输入转换成密集向量，该向量可以被馈送到 SimpleRNN 单元。有关嵌入层的更多信息，请参见 TensorFlow 文档此处。
我正在使用 Adam 优化器，学习率为 0.001。我用分类交叉熵作为损失函数。使用分类交叉熵是因为我们试图根据前面的步骤对序列中的下一个单词进行分类。
简单细胞
接下来是利用门控循环单元的网络。
GRU 通过引入复位和更新门来改进 SimpleRNN 单元。在高层次上，这些门用于决定我们想要保留/丢失先前状态的信息。
GRU 表示为:
其中 z(t) 为更新门， r(t) 为复位门， h(t) 为隐藏单元状态。
以下是 GRU 的实际效果:
GRU 细胞
以下是 GRU 网络在 TensorFlow 中的构建方式:
同样，我将 Adam 用于优化器，将分类交叉熵用作损失函数。
长短期记忆结构是下一个被利用的。
长短期记忆单元优于简单神经元和 GRU 单元，因为它能够在序列的更下游保留更多的信息。LSTM 使用三个不同的门，而不是 GRU 的两个，并在整个网络中保留一个单元状态。众所周知，GRU 比 LSTM 具有速度优势，因为它能够更快地进行概化并使用更少的参数。然而，当涉及到在整个序列中保留更多的上下文数据时，LSTM 倾向于拿走蛋糕。
LSTM 单元可以表示为:
其中 f(t) 代表遗忘门，并确定要遗忘多少先前状态。那么 i(t) 代表输入门，它决定了我们将向单元状态添加多少新信息。 o(t) 是输出门，它决定哪些信息将前进到下一个隐藏状态。单元格状态用 c(t) 表示，隐藏状态为 h(t)。
这是数据通过 LSTM 池的可视化效果:
LSTM 细胞
请参见下面的代码实现:
我想测试的最终架构是卷积神经网络和 LSTM 的结合。
这个网络是一个思想实验，看看结果会如何不同于 LSTM、GRU 和 SimpleRNN。实际上，我对它将要发表的一些诗句感到惊讶。
这是架构的代码:
用模型生火
为这个项目创建模型仅仅是工作的一半。另一半利用训练好的模型生成歌词。
在我看来，这就是这个项目变得真正有趣的地方。我能够将我训练的模型用于一项重要的任务。
这个项目很大程度上受到彼得·卡塔什、阿列克谢·罗马诺夫和安娜·拉姆斯斯基的《评估创造性语言生成:说唱歌词代写案例》的启发。因此，我将利用他们论文中概述的一些方法，对照艺术家的原始歌词来评估模型的输出。
我用来评估小节和生成 rap 的方法有:理解分数、韵律指数和抒情独特性。我将很快讨论我是如何计算这些的。
对我如何创作歌曲的高度概括可以描述为:
- 利用马尔可夫模型生成小节前四个单词
- 将马尔可夫模型的输出输入到 RNN 中
- 对照原始歌词评估 RNN 的输出的独特性、相似的押韵索引和相似的理解分数
- 要么把酒吧扔了(如果是垃圾)，要么把它加到歌里(如果是火)
相当简单，对吧？
让我们来看看这是如何实现的代码。
首先，我有一个名为 generate_rap 的函数。该函数处理生成说唱歌曲的主要功能。 generate_rap 接受我想要用来生成 rap 的模型(SimpleRNN、GRU、LSTM 或 CNN+LSTM)、最大小节长度、我们想要在 rap 中包含多少小节、分数阈值以及我们想要生成 fire bar 的尝试次数。分数阈值定义了该条在被认为是火之前的分数，在这种情况下，该条越接近 0，它就越火。下面是该函数在代码中的样子:
如你所见，我们生成了一个随机条，根据艺术家的平均押韵指数、平均理解能力和条的独特性来评分。然后，如果小节达到分数阈值，它就进入最后的歌曲。如果算法无法在定义的最大尝试次数内生成火条，它会将得分最高的火条放在歌曲中并继续前进。
在 generate_rap 中，我使用了另一个名为 generate_bar 的函数。这个函数接受一个种子短语、我们用来生成序列的模型以及序列的长度。然后, generate_bar 将对种子短语进行标记，并将其输入到提供的模型中，直到序列达到期望的长度，然后返回输出。代码如下:
为了给棒线打分，我使用了一个名为 score_bar 的函数。这个函数接受我们想要评分的小节、艺术家的原始歌词、艺术家的平均理解分数和艺术家的平均押韵指数。 score_bar 计算输入条的理解分数、押韵指数和独特性指数，然后对输入条进行评分。
该条的分数可以是正的，也可以是负的，0 是该条可以达到的最高分数。分数为 0 意味着该小节具有相同的押韵指数和理解分数，同时保持与原始艺术家的歌词完全不同。完美的 0 分是不可能达到的，这就是我们定义最小和最大阈值的原因。
score_bar 函数如下所示:
为了计算一个小节的韵律指数，我使用了“评估创造性语言生成:说唱歌词代笔的案例”中描述的方法押韵指数的计算方法是将押韵音节的数量除以小节或歌曲中的音节总数。下面是代码实现:
为了比较生成的条形的唯一性，我正在计算生成的条形和所有艺术家的条形之间的余弦距离。然后我得到平均距离来计算总的独特性分数。这是它的样子:
结果呢
有了这一切，我终于能够利用我训练的四个模型生成一个完整的 rap。生成 rap 后，我取生成的歌曲，计算押韵指数和理解分数。令人惊讶的是，整首歌仍然相当接近原艺术家的押韵指数和理解分数。
以下是训练德雷克歌词时的一些输出。
最简单的:
Generated rap with avg rhyme density: 0.5030674846625767 and avg readability of: 2.0599999999999996 Rap Generated with SimpleRNN: Now you’re throwing me baby know it know
Look I gotta started with you hook drake
I swear it happened no tellin’ yeah yeah
....
GRU:
Generated rap with avg rhyme density: 0.5176470588235295 and avg readability of: 1.9449999999999998 Rap Generated with GRU: That's why I died everything big crazy on me
Who keepin' score up yeah yeah yeah yeah
I've loved and you everything big crazy on me on
....
LSTM:
Generated rap with avg rhyme density: 0.3684210526315789 and avg readability of: 1.9749999999999996 Rap Generated with LSTM: Get the **** lick alone same that wait now
up ****, see what uh huh heart thing up yeah
Despite the things though up up up up yeah yeah
....
LSTM+CSNN:
Generated rap with avg rhyme density: 0.33519553072625696 and avg readability of: 2.2599999999999993 Rap Generated with CNN+LSTM: They still out know play through now out out
I got it dedicate dedicate you yeah
I've been waiting much much aye aye days aye aye
....
关于完整的歌词和参考文献列表，看看谷歌 Colab 笔记本。也可以随意自己尝试，为你想要模仿的风格更换艺术家。
就简单的 CNN vs GRU vs LSTM vs CNN+LSTM 的实验而言，我会说 LSTM 往往有最好的结果。CNN+LSTM 在一个栏里有太多重复的词，我认为这与 CNN 将整个序列一般化有关。《简单的人》和《GRU》创作出了相当不连贯的小节，它们的韵律密度与原作相去甚远。
就是这样！请在评论中告诉我你的想法。我希望将来能在这个项目上有所建树。如果你对我需要改变的事情有任何建议，让我知道！感谢您的阅读。
查看我的 GitHub，了解这个项目和其他很酷的项目的代码！
在 GitHub 上注册你自己的个人资料，这是托管代码、管理项目和构建软件的最佳地方…
github.com](https://github.com/wezleysherman)
吉布斯采样
在 Unsplash 上由 Carlos Muza 拍摄的照片
又一种 MCMC 方法
与其他 MCMC 方法一样，Gibbs 抽样器构建了一个马尔可夫链，其值向目标分布收敛。Gibbs 抽样实际上是 Metropolis-Hastings 算法的一个特例，其中建议总是被接受。
具体来说，假设您想要对一个多元概率分布进行采样。
注: 一个 多元概率分布是多个变量的函数(即二维正态分布)。
https://commons . wikimedia . org/wiki/File:multivariatenormal . png
我们不知道如何直接从后者取样。然而，由于一些数学上的便利，或者仅仅是运气，我们碰巧知道条件概率。
这就是吉布斯采样的用武之地。吉布斯抽样适用于联合分布未知或难以直接抽样的情况，但每个变量的条件分布已知且易于抽样。
吉布斯采样算法
我们从选择随机变量 X&Y的初始值开始。然后，我们从 x 给定 Y = Y⁰的条件概率分布中取样，表示为 p(X|Y⁰).在下一步中，我们采样一个以 X 为条件的 Y 的新值，这是我们刚刚计算的。我们重复该过程进行额外的 n - 1 次迭代，在给定另一个随机变量的当前值的情况下，在从 X 的条件概率分布和 Y 的条件概率分布中抽取新样本之间交替进行。
让我们看一个例子。假设我们有下面的后验和条件概率分布。
其中g(y)包含不包含 x 的项，g(x)包含不依赖于 y 的项。
我们不知道 C(归一化常数)的值。然而，我们知道条件概率分布。因此，我们可以用吉布斯抽样来近似后验分布。
注: 条件概率实际上是正态分布，可以改写如下。
给定前面的等式，我们继续用 Python 实现 Gibbs 采样算法。首先，我们导入以下库。
*import numpy as np
import scipy as sp
import matplotlib.pyplot as plt
import pandas as pd
import seaborn as sns
sns.set()*
我们定义后验分布的函数(假设 C=1)。
*f = lambda x, y: np.exp(-(x*x*y*y+x*x+y*y-8*x-8*y)/2.)*
然后，我们画出概率分布。
*xx = np.linspace(-1, 8, 100)
yy = np.linspace(-1, 8, 100)
xg,yg = np.meshgrid(xx, yy)
z = f(xg.ravel(), yg.ravel())
z2 = z.reshape(xg.shape)
plt.contourf(xg, yg, z2, cmap='BrBG')*
现在，我们将尝试使用吉布斯抽样来估计概率分布。正如我们之前提到的，条件概率是正态分布。因此，我们可以用 mu 和 sigma 来表示它们。
在下面的代码块中，我们为 mu 和 sigma 定义函数，初始化我们的随机变量 X & Y ，并设置 N (迭代次数)。
*N = 50000
x = np.zeros(N+1)
y = np.zeros(N+1)
x[0] = 1.
y[0] = 6.
sig = lambda z, i: np.sqrt(1./(1.+z[i]*z[i]))
mu = lambda z, i: 4./(1.+z[i]*z[i])*
我们逐步执行吉布斯采样算法。
*for i in range(1, N, 2):
sig_x = sig(y, i-1)
mu_x = mu(y, i-1)
x[i] = np.random.normal(mu_x, sig_x)
y[i] = y[i-1]
sig_y = sig(x, i)
mu_y = mu(x, i)
y[i+1] = np.random.normal(mu_y, sig_y)
x[i+1] = x[i]*
最后，我们绘制结果。
*plt.hist(x, bins=50);
plt.hist(y, bins=50);*
**
*plt.contourf(xg, yg, z2, alpha=0.8, cmap='BrBG')
plt.plot(x[::10],y[::10], '.', alpha=0.1)
plt.plot(x[:300],y[:300], c='r', alpha=0.3, lw=1)*
正如我们所看到的，使用 Gibbs 抽样算法获得的概率分布很好地逼近了目标分布。
结论
Gibbs 抽样是一种蒙特卡罗马尔可夫链方法，它根据其他变量的当前值从每个变量的分布中迭代地抽取一个实例，以便估计复杂的联合分布。与 Metropolis-Hastings 算法相反，我们总是接受建议。因此，吉布斯采样可以更有效。
基尼不纯度测量——使用 python 的简单解释
使用 python 的直观解释
介绍
Gini 杂质度量是决策树算法中使用的方法之一，用于决定从根节点开始的最佳分裂以及后续分裂。
(在继续之前，您可能想回顾一下用树做决策
将它放入上下文中，决策树试图创建连续的问题，以便将数据划分为更小的组。一旦划分完成，就在该终端节点做出预测决策(基于频率)。
假设我们有一个观察列表，表明一个人是否决定呆在家里不工作。我们还有两个特征，即他们是否生病和他们的体温。
我们需要选择哪个特征，情绪还是温度，来分割数据。基尼系数将帮助我们做出这个决定。
Def: 基尼系数告诉我们一个观察值被错误分类的概率是多少。
请注意，基尼系数越低，分割越好。换句话说，错误分类的可能性越低。
形式定义
下图是两类问题。我们将在后面将其概括为两个以上的组。
让 Ginx 代表基尼指数。
其中 p1、p2 分别是 1、2 类概率。
注 : p1 + p2 =1
这还没有完成。上面的等式将给出子分割的基尼系数，但是我们想知道整个分割的基尼系数(因为数据将被分割为左右两部分)。因此，我们需要相应地权衡它们。
其中，P_L 是向左分流的比例，p_L1 类似于左分流的 P1(P _ R 也是如此)。
我们有一个零的下限和一个半的上限。杂质测量值越低，分离越好。
如果你看一下图表，你会注意到杂质测量值越低越好。当观察值为 1 类的概率为零(一直到图表的左侧)时，这意味着它将始终为 2 类，杂质测量值为零。当观察值为 1 类的概率为 100%时，在另一端也会发生同样的事情。
例子
让我们回到上面的例子，在两个特性上分开。
情绪
病态基尼杂质= 2 * (2/3) * (1/3) = 0.444
NotSick 基尼杂质= 2 * (3/5) * (2/5) = 0.48
加权基尼系数= (3/8) * 西基尼+ (5/8)非西基尼= 0.4665
温度
我们将温度的阈值硬编码为 Temp ≥ 100。
杂质温度= 2 * (3/4) * (1/4) = 0.375
杂质下温度= 2 * (3/4) * (1/4) = 0.375
加权基尼系数=(4/8)TempOverGini*+(4/8)TempUnderGini*= 0.375
我们可以看到，温度的基尼系数较低。因此，我们会选择在温度上进行分割，因为它对观察结果进行错误分类的可能性最低。
我们将验证我们的函数确实返回了上面的值。
结论
我们已经完成了基尼系数的引入。我希望这个简短的解释能让你了解决策树是如何决定分割数据的。
请记住，这不是唯一使用的方法，它将取决于您使用的软件包。
感谢您的阅读！
附录
基尼不纯的概括
假设我们有( n) 个不同的类。那么基尼公式将是:
GIS 数据处理备忘单:有效使用命令行 GDAL
在本文中，我提供了一个使用简单的命令行 GDAL 来处理、转换和操作大量复杂的 GIS 数据集的演练
地理信息系统(GIS)信息量大，并提供数据的粒度表示。不用说，这些数据集对研究人员、数据分析师和数据科学家非常有吸引力。但是这些数据带来了一个大问题。从处理和计算时间的角度来看，它们很重，操作起来很痛苦。鉴于这些数据集的大小和结构，除非使用 ArcGis 或 QGIS 等软件，否则很难对其进行有意义的分析。在本文中，我提供了一些简单的命令行代码，可以用来极大地减少处理时间，并且可以有效地用于从这些数据中提取有意义的信息。这段代码使用了 GDAL 程序，这里的是可用的。所以，让我们直接开始吧。
对于那些不熟悉 GIS 数据类型的人来说——我想简单总结一下你可能会遇到的不同类型的 GIS 数据。有两大类需要考虑。第一个是 栅格数据 ，它是基于格网/像元的数据，包含一些关于像元内容的信息(像元中包含的人口这样的离散数据)或它所代表的内容(像特定像元属于什么类别这样的连续数据)。光栅格式的一个例子是. tif。bsq 或者。bil 文件。第二个是 矢量数据 ，是表示为国家、州等地图形状的数据。矢量格式的一个例子是. shp 或 shapefile。现在，我们知道了将要处理的数据，让我们直接进入代码。
要使用这个代码，你需要在你的机器上安装 GDAL。如果你在 windows 机器上，我会推荐通过 cygwin 终端安装 GDAL。
1.获取信息/元数据- 我在本文中使用了一个示例栅格，名为 gpw _ v4 _ population _ count _ rev 11 _ 2000 _ 30 _ sec . TIF。这是一个从 NASA 维护的数据库中下载的文件，可以在这里访问。这是一个简单的栅格，包含世界上每个国家的每个格网像元的人口。要查看该栅格实际包含的内容，让我们使用下面的 gdalinfo 函数。
#First go the directory containing the filecd 'file path here'#Now let's run gdalinfogdalinfo gpw_v4_population_count_rev11_2000_30_sec.tif#This is the output we get
Driver: GTiff/GeoTIFFFiles: gpw_v4_population_count_rev11_2015_30_sec.tifSize is 43200, 21600Origin = (-180.000000000000000,89.999999999999915)Pixel Size = (0.008333333333333,-0.008333333333333)Metadata:AREA_OR_POINT=AreaDataType=GenericImage Structure Metadata:COMPRESSION=LZWINTERLEAVE=BANDCorner Coordinates:Upper Left (-180.0000000, 90.0000000)Lower Left (-180.0000000, -90.0000000)Upper Right ( 180.0000000, 90.0000000)Lower Right ( 180.0000000, -90.0000000)Center ( -0.0000000, -0.0000000)Band 1 Block=43200x1 Type=Float32, ColorInterp=GrayNoData Value=-3.40282306073709653e+38
因此，我们得到的信息告诉我们驱动:这是文件的类型(在本例中是 tif 文件)，大小:这是网格的大小(组成网格的行数和列数，在本例中是 43200，21600)。像素大小:这是像素内投影的大小(在本例中为 0.00833333 度，即 5 弧分)，角坐标:这是投影的范围(这将告诉我们某些区域是否从投影中缺失)。例如，一些地图将有一些区域被切断等)，最后我们得到 NoData 值:，这是没有数据计算的值，或者基本上是数据集中的空值。所有这些数据都很有用，我们将在本文的其余部分看到。但是gdalinfo确实很有用，因为它提供了一个文件中可用数据的快速摘要，并且不消耗任何处理能力。
2.在栅格中填充 Nodata 值- 对于不同的项目，我们可能不需要 NoData 值，或者可能希望用不同于默认值的值替换 NoData 值。使用 gdal，我们可以遵循 3 个步骤来完成这个任务。首先，我们需要将 NoData 值替换为我们自己的默认值(假设为 0)，将所有 NoData 值替换为零(这是一个健全性检查，以确保我们捕获的 Nodata 值不是由元数据指定的)，然后我们需要去掉 NoData 标签，因为 NoData 本质上是一个定性标签。我们在这里可以使用两个命令，第一个是用 gdalwarp 来替换值，第二个是用gdal _ translate来移除标签。请注意，这两个命令像大多数其他 gdal 命令一样，会要求您指定一个单独的输出对象。
*#Fill NoData values with zerogdalwarp -srcnodata -3.40282306073709653e+38 dstnodata 0 gpw_v4_population_count_rev11_2015_30_sec.tif population_nodatafilled.tif# Now replace all no_data values with a 0.gdal_translate -b 1 -a_nodata 0 population_nodatafilled.tif population_only_data.tif#Note that the -b indicates the band within the raster where you want to the operation. This would change for multiband rasters.# Now take off the no_data tag itselfgdal_translate -a_nodata none population_only_data.tif population_clean.tif*
3.重新投影栅格- 在比较两个栅格文件时，我们需要确保我们是在比较同类文件，因为网格大小、投影类型或投影大小甚至范围可能存在差异。 gdalwarp 允许我们进行方便的重新投影来标准化光栅文件。因此，继续我们当前的例子，如果我们想用不同的投影类型将数据重新投影到一个更小的网格上，我们将使用下面的 gdalwarp 命令。代码中的注释还提供了我们提供给这个命令的参数的描述。
*#Let's reproject gdalwarp -ts 1440 600 -r average -ot Float32 -t_srs "+proj=longlat +ellps=WGS84" -te -180 -60 180 90 population_clean.tif population_reprojected.tif#Note the following:# -ts is the size of the grid that we want in rows and columns
# -r is specifying the method used to aggregate/dis-aggregate. There #are a number of options available, but the one that makes the most #sense is average since this is basically the sum of the cell values #being aggregated divided by the number of cells.
# -ot is the output type which is set to a Float since this us a #mathematical operation.
# -t_srs is the reprojection type. The one I am specifying here is a #longlat projection using a WGS84 datum.
# -te is the extent itself, which is the extent of the projection. #If you standardize the grid size and the reprojection type, you will automatically standradize the pixel size.*
现在，你可能已经注意到，你甚至不能打开原来的 tif。不过，在重新投影后，我们实际上可以绘制出光栅，因为尺寸要小得多。
这是带有按格网单元划分的人口的变形 tif。
4.转换栅格数据类型- 用户通常会想要转换数据类型。这样做的一个常见原因是空间。例如，地理 IFF 在内存方面很贵，但是。bil 或者。bsq 文件便宜很多。因此，我们可以使用 gdal_translate 轻松地转换它。最棒的是，gdal 会在需要的地方自动创建头文件。
*#Convert tif to bilgdal_translate -of ENVI population_reprojected.tif population_final.bil#The -of specifies the file type we want to convert to.*
5.根据标准替换特定像素值- 现在，用户可能还想用自己的值替换栅格中的特定值。假设我们希望在所讨论的栅格中，具有任意人口值的格网像元的值为 1，而没有人口值的格网像元的值为 0。我们可以使用 gdal_calc.py 来实现这一点。我们只需使用下面的代码来完成这个。请注意，这是一个 python 命令。
*#Replace pixel values based on criteriagdal_calc.py -A population_final.bil --calc='((A>0))*1+((A<=0)*A)' --outfile=population_final_reclass.bil#This will basically replace all values within pixels with 1 and those without values to 0.*
6.光栅到矢量转换(多边形化)——假设我们想要一个根据人口分布的全球地图。也就是说，一张地图向我们展示了人们在世界上实际生活的地方。我们已经有了一个光栅，可以精确地跟踪每个像素。如果我们能结合像素得到一个有意义的地图，那将非常有帮助。这在 gdal 中使用gdal _ polygonize . py很容易实现。这将需要一个栅格，将像素转换为多边形，合并具有相同值(在本例中为 1)的相邻像素，并输出一个全局地图。
*#Convert raster to vector (shape file)gdal_polygonize.py population_final_reclass.bil population_map.shp pop#Note that the pop is the destination column name within the shape file.*
在这之后，如果我们要绘制出人们居住的世界地图，我们会得到下面的地图。最重要的是，它将对应于我们的光栅的尺寸。
全球人口分布图。洞表明那里没有人口居住。
7.合并矢量文件- 现在，假设在上面的地图中，我们也想要在上面的地图中表示世界上不同的国家。使用 ogr2ogr 命令，还可以合并两个矢量文件。假设我们有一个名为 countries.shp 的 shapefile，其中包含国家的实际边界。我们可以将它与现有的形状文件合并，得到一个地图文件，向您显示国家地图，以及国家中没有人居住的地方的洞。
*#First create a file to merge againstogr2ogr -f 'ESRI Shapefile' population_boundaries_merged.shp population_map.shp#Now merge the boundaries shapefile into this oneogr2ogr -f -update -append population_boundaries_merged.shp ccountries.shp -nln merge#This command is updating the population_boundaries_merged.shp by appending a new boundaries file from countries.shp.*
这是我们从新的人口边界合并中得到的输出
我们的合并矢量的输出(形状文件)
这就是了。当必须处理大量 GIS 数据并从中提取有意义的信息时，这些命令是非常有用的备忘单。它们显然可以被修改以适应许多操作。我还在开发一个存储库，将这些命令作为一组正式的 bash 脚本来存放。当前形式的存储库在这里是。一如既往，欢迎任何与此相关的反馈！
Git:完整的指南
涵盖了通过 Git 实现完整工作流的基本命令。
米哈伊尔·瓦西里耶夫在 Unsplash 上的照片
在有多个协作者的项目中，在构建项目时可能会有冲突。 Git & GitHub 为我们提供了这类问题的终极解决方案。Git 简化了与其他人合作的过程，使项目协作变得容易。在本帖中，我们将介绍工作流环境所需的所有主要命令。
来源:YouTube， Edureka
在这里，我们将涵盖工作流中使用的所有基本命令
- 创建存储库
- 同步存储库
- 进行更改
- 并行开发
最初，我们从创建一个存储库开始
git init
下一步是将文件从中央或远程存储库拉到本地机器上。
git add origin master "link from your github account"git pull origin master
下一步是将创建的文件或开发的代码添加到索引中。这就是所谓的分期。文件被添加到索引中。
索引是一个准备新提交的暂存区。
我们还可以检查状态。 git status 命令显示工作目录和暂存区的状态。
git add "file name"git add -A // to add all files in the foldergit status
随着文件被添加到索引中，Git 的核心( Commit )开始就位。
“提交”命令用于将您的更改保存到本地存储库。我们需要显式调用它来查看变化。
git commit -m "your message"git commit -a -m "your message" // to commit all the files
到目前为止，我们已经创建了一个库，同步库，&，在本地库做了修改。现在下一步是执行并行开发。
要检查所有提交的日志，使用命令 git log
git log
平行开发包括:-
- 分支
- 合并
- 重置基础
让我们继续前进，执行分支
在 Git ，分支是你日常开发过程的一部分。 Git 分支实际上是指向您的更改快照的指针。
git branch branchname
这里它创建了一个名为“first branch”的分支。在这个分支中，来自主分支的所有文件被复制，并且这些更改可以在创建的分支中使用，而不会影响主分支。
要访问分支，我们使用命令
git checkout branchname ls // lists the file in the branchcat filename //view the contents of file
一旦创建了新的分支，将该分支与主分支合并以生成产品质量代码是非常重要的。
git merge 命令可以让你获得由 git 分支创建的独立开发线，并将它们集成到一个分支中。
git merge firstbranch
还有一种方法可以将分支合并到主分支。叫做 Rebase。这样效率更高，因为它用于制作一个线性提交序列。用于清理项目历史 & 减少分支数量。
git rebase branchname
请确保创建文件，添加并提交它们，以使更改生效，并保持您的代码无错误运行。
要将代码从本地存储库推送到远程存储库，我们需要首先进行身份验证。为此，我们需要 SSH 密钥。GitHub 使用 SHA-1 算法进行安全哈希运算，生成 40 位十六进制代码。
ssh-keygen
要生成 ssh 密钥,请键入以下命令
cat 'path' // usually id_rsa.pub where the public key is saved
检查您是否已成功验证了命令中的类型
ssh -T git@github.com
会弹出一条消息，提示您已成功通过身份验证。一旦 ssh 密钥生成，您就可以将代码从本地存储库推送到远程存储库。要将文件从本地推送到远程，请在命令中键入
git push origin branchname // to push any respective branchgit push origin master // to push master branch
检查您的 GitHub 库，查看您的 Git 所做的更改
这涵盖了 Git 的基本命令。
Git 基本上由三个主要阶段组成
拉胡尔·帕塔克
用通俗的话来理解工作流，Git 有一个工作/开发环境一个登台环境&生产质量代码或中央存储库。让我们用一张办公桌来理解这些阶段。
拉胡尔·帕塔克
我希望你们都喜欢这个帖子，并且已经理解了 Git 的基本命令和 Git 的工作流环境。非常感谢:)
在 Unsplash 上由Courtney hedge拍摄的照片
SQL 的 Git 最佳实践
安德鲁·西曼在 Unsplash 上拍摄的照片
数据工程
使用 GitHub、GitLab、BitBucket 等来存储和组织 SQL 查询，以实现发现和重用
随着数据科学、数据工程和数据运营团队的规模与日俱增，改善他们的协作方式非常重要。经常可以看到数据工程师和数据分析师在他们的本地机器上存储 SQL 查询、Python 脚本和 Jupyter 笔记本。强烈建议不要发生这种情况。尽管这些人的工作与应用程序开发人员的工作有很大不同，但毫无疑问，他们共享许多用于编写代码的通用工具。此外，在大多数情况下，工作流程也非常相似。
对于协作编写代码的团队来说，最重要的工具是版本控制系统，如 Git、Mercurial 或 Subversion。VCS 已经存在很多年了，但是数据团队仍然需要将它们完全融入到他们的工作流中。在这里，我们将讨论使用 VCS 进行数据工作的巨大好处，以及使用 VCS 进行数据工作的最佳实践。我们走吧。
1.代码组织
组织你的代码、查询、工件、S3 桶等。，非常重要。不管你的基础设施是否在云上，你都可以设计方法来组织你的代码。它从获得正确的文件夹结构开始。应用程序的文件夹结构、数据库脚本和 DevOps 脚本都取决于您正在构建的应用程序和使用的工具。
结构很重要，结构很美
版本控制系统提供了一种强大的方法来确保每个人都了解文件夹结构以及代码的组织方式。我在 Medium 上找到两篇非常好的文章，它们都是关于代码组织的，其中一篇是—
有许多方法可以构造代码。我一直在思考什么是最好的方法。我宁愿到达一个…
medium.com](https://medium.com/@egonelbre/thoughts-on-code-organization-c668e7cc4b96)
还有一个是关于代码组织的策略。这些策略并不以同样的方式应用于数据库脚本、SQL 查询、报告和存储过程，但这个想法是一样的。代码应该以可读、可搜索、可理解和可编辑的方式编写和组织。
2.使用本地/远程分支
始终将所有相关工作推送到远程分支机构，即使工作正在进行中。我强烈推荐使用 git flow——git 开发方法使用三个层次的分支(有一些例外)——主、开发和特性。这里的特性分支可以是任何 CR 或新鲜的需求。
将您的工作推到远程分支，即使它正在进行中
不建议只在本地分支上存储，除非它对其他人来说是无用的，并且是为了您自己的实验和发现。毫不奇怪，本地分支容易丢失数据，因为您的查询不会驻留在宇宙中的其他地方。
这里有一个例子是关于对 SQL Server 脚本使用 Git 的。git SQL——PostgreSQL 数据库的专用源代码控制解决方案。
3.强制性审查
对于每个合并请求，您应该有一个强制的审阅者。这确保没有任何可疑或不正确的东西进入生产。人工检查和平衡真的很重要。所有主要的版本控制系统都可以选择授权一个或多个人进行评审。
关于这一点，Atlassian 的工程团队有一个完整的帖子。一定要去看看。
敏捷团队是自组织的，技能集跨越整个团队。这部分是通过代码实现的…
www.atlassian.com](https://www.atlassian.com/agile/software-development/code-reviews)
重要的旁注——如果你的团队是评审过程的新手，他们可能会有点暴躁地执行它，因为它看起来像是无用的额外工作，但它几乎不是。从长远来看，额外的复习努力是有回报的。
4.拥有最新的试运行环境
我再怎么强调拥有最新的试运行环境的重要性也不为过。出于数据库测试的目的，没有必要一直将所有生产数据都放在这里。这实际上取决于您的测试需求。无论数据是否更新，数据库结构(表、视图、过程、函数和其他对象)应该总是同步的。
建立服务于静态网站的基础设施通常比看起来更难——但幸运的是，这是一项任务…
www.pulumi.com](https://www.pulumi.com)
像 Terraform 和 Pulumi 这样的 IaC 工具使得在几分钟内繁殖和破坏完整的环境变得非常容易。如果您正在使用所有这些工具，那么创建一个试运行环境应该不难，而且肯定不会花费太多时间。通常在数据仓库的上下文中更容易理解登台，数据仓库是在将数据写入主生产数据仓库之前进行大量预处理的层。但是这里我指的是为一个通常的开发环境准备，其他的是测试、开发和生产。登台通常也被称为预生产，但术语并不严格。
5.CI/CD 集成
在拥有 VCS 之后，拥有 CI/CD 管道是下一个发展步骤，因为它消除了另一个人为错误可能导致运行错误报告的步骤。本质上，这样的管道将确保您的最新代码被持续集成并自动部署到您的环境中。市场上有一些流行服务的工具可以解决这个问题，比如 Redshift、Tableau、Informatica 和大多数关系数据库。然而，他们中没有一个是完全成熟的，所以要小心这个事实。这里有一篇关于数据库 CI/CD 的好文章—
[## 害怕数据库改变？用 CI/CD | Hacker Noon 控制他们
开发人员经常担心数据库的变化，因为团队中任何人的一个错误都可能导致重大停机，甚至…
hackernoon.com](https://hackernoon.com/database-changes-can-be-scary-how-r1hy2gfe)
拥有 CI/CD 管道还可以减少为测试和开发设置环境和配置的大量时间。您没有必要使用市场上可用的工具之一，因为它们对于数据工程师来说都不如对于开发人员来说那么先进。您可以使用一组脚本和 Lambda 函数为您的用例创建自己的 CI/CD 工具，这些脚本和函数由通过监听 VCS 创建的事件调用。
6.创建查询库
最后但同样重要的是，为您的组织创建一个查询库是保持理智的最重要的事情之一。这可以防止不同团队再次重写相同的查询。我为几个团队做过，但从未在一个组织中做过。为查询库使用 VCS 很有意义，但是非技术团队可能会发现使用 VCS 很难操作。
Caitlin Hudon 在她的博客上发表了一篇令人惊叹的文章，她谈到了自己的心得，并将这些心得总结为关于 SQL 的真理，如下所示
- 您总是会再次需要该查询
- 查询是随着时间变化的活的人工制品
- 如果对你有用，对别人也有用(反之亦然)
有像 Metabase 这样的开源工具可以帮助你在集合中组织你的查询。如果不是这样，您可以使用您的 BI 工具作为查询库的存储。虽然不是最好的选择，但是如果团队有这样做的动机，这是可行的。
结论
由于 SQL 是应用开发、数据工程、数据科学和数据分析等许多开发领域广泛使用的语言，因此很容易找到不同的使用、存储和维护模式。话虽如此，我们不应该原谅，无论我们遵循什么模式，它都应该让其他人容易理解、探索和处理已经编写好的代码。这是唯一的要求。
Git-Flow 是生产力的源泉，而不是混乱
行业笔记
初创公司两个最基本的 git 流程的具体细节
Denys Nevozhai 在 Unsplash 上拍摄的照片
开发工作流的架构是基于发布的质量和数量来设计的。这里的质量T5 指的是每个版本中无 bug 或特性集的状态。数量是指开发过程中发布的次数。这种架构通常没有那么复杂；然而，这可能会引起混乱。
基于 git 的开发工作流，也称为 git 流，是构建和发布软件的一系列开发步骤。Git 是一种流行且强大的版本控制技术，被许多公司使用，同时还有其他技术，如 Perforce 或 Mercurial。在本文中，我使用 git-flow 而不是基于 git 的开发工作流，不失一般性。这与这篇帖子中介绍的 GitFlow 不同。
在这里，我解释了两个对创业公司至关重要的 git-flow 架构。了解这些架构的细节可能会解决开发、产品和管理团队之间不必要的冲突。最后，我解释了 git 流的具体细节，这有助于更好地理解它。
请注意，与本文中的内容相比，git-flow 架构可能会变得更加复杂。然而，如果你学习了两个最基本的 git 流的细节，你将很容易理解任何复杂的 git 流。
最常见的两种 git 流是什么？
软件行业中使用了各种各样的 git 流。不过有两个是创业公司常用的。下面，我首先描述两个场景，然后解释适用于这些场景的两个 git 流。
- 场景 1。你需要一个频繁发布的快速开发过程。您不希望让把关者签署发布。您接受意外引入主分支的小错误，而不会导致主要功能停止。另外，您不需要控制每个版本中的特性列表。在这种情况下，你必须使用高频率和低质量的架构。
- 场景二。你的用户数量相对较多。您必须在每次发布之前广泛验证产品的质量。您希望有一个不断审查产品的团队，以及一个签署发布的把关人。在这种情况下，你必须使用低频和高质量的架构。
把关者是一个定期检查产品质量并决定产品何时发布的人。在大多数创业公司，产品经理都是把关人。
—高频率和低质量
在这个 git-flow 中，只有一个主要的源分支，在那里开发被合并，发布被提取。
在创业的早期阶段，开发工作流程不能因为任何原因而延迟。没有付费客户，主要精力放在开发上。因此，开发团队的目标是只通过自动化测试来检测 bug，并接受在新版本中有一些 bug。由于这个 git-flow 没有签署发布的看门人，bug 只是通过自动化测试溜到发布中。一旦发现这些错误，必须立即修复。
没有看门人的 git 流
—低频和高质量
在这个 git 流中，有两个主要的源分支:主和发布。开发团队在主分支上工作以构建产品，在发布分支上工作以准备发布产品。
发布分支为产品经理创建了一个独立的环境，以便对特性开发和发布质量有更多的控制。在产品团队中，QA 工程师在发布分支上运行手动测试，以发现并报告必须修复并合并到发布分支中的 bug。最后，产品经理作为把关人负责签署发布。
高质量的软件伴随着低频发布的成本。
无论如何，100%的测试覆盖率是不可能的。因此，bug 也可能在这个 git 流的测试过程中溜走。然而，这种架构中的发布质量比我们从前一种架构中得到的更可靠。
具有看门人的 git 流
二。git 流的主要步骤是什么？
—开发
git 流程的第一步是代码变更，即功能开发或缺陷修复。当您想要在代码库中进行更改时，您必须始终创建一个隔离分支，以防止在源分支中进行不必要的更改。
在您完成开发之后，您必须通过一个标准的过程将最近的变更合并到源分支中。 Github 称这个流程为 pull-request， GitLab 称之为 merge-request，两者指的是同一个流程。
在这个过程中，代码更改等待开发人员级别的测试(例如单元、集成和回归测试)和代码审查。有一些应用程序如 Hound 也使代码审查过程部分自动化。如果代码更改可以通过测试并获得所需的批准，它们将被合并到源分支中。而且，发展还在继续！
—测试
质量软件是关于测试和开发之间的平衡。在运行测试的 git 流中有两个关键点。首先，在将代码变更合并到源分支(例如，主版本或发布版本)之前，其次，在将产品交付给客户之前。
知道了软件测试的重要性，问题是我们有多少类型的测试。测试可以是自动的，也可以是手动的。自动化测试由 DevOps 解决方案如 CircleCI 和测试框架如 PyTest 以完全自动化的方式执行。手动测试由产品团队执行，旨在覆盖自动化测试未测试的零件。
在这里，我根据软件测试为开发工作流提供的高层次价值对软件测试进行分类。有两种不同类型的测试:开发者级和用户级。
- 开发人员级别的测试比如单元、集成和回归测试评估代码的健全性。它们在 git 流的每次提交之后、构建过程之前执行。这些测试是完全自动化的。其目标是确保代码的健全性并加快开发的步伐。开发人员是工作流中这些测试的所有者。
- 用户级测试如验收和性能测试评估整体解决方案。它们在部署后执行。这些测试是手动和自动的。它的目标是模拟用户体验和从整体上衡量服务质量。在大多数创业公司中，产品经理是工作流中这些测试的所有者，因为这些测试大多是面向用户的。
在大多数情况下，您必须非常依赖自动化测试来检查健全性和质量。然而，这并不意味着在这个过程中不能使用手工测试。
通过运行自动化过程在每次提交时集成和验证代码库的实践被称为持续集成。
—构建
构建指的是编译和打包源代码及其工件的过程。构建步骤的输出是一个二进制文件，可以部署到云上。
举例。当您使用 Docker 构建二进制文件时，构建过程的输出被称为 Docker 映像，它是构建它的虚拟机环境的快照。
这些二进制文件必须存储在二进制库管理器上，例如 JFrog 或 DockerHub 。当您将它们存储在存储库管理器中时，您必须对它们进行标记，以便可以轻松地搜索和检索它们，尤其是当您想要自动部署它们时。例如，您可以使用 git 创建的 commit ID 来标记二进制文件，因为它确切地显示了解决方案是在哪里构建的，并且它作为惟一的标识符工作。
从每次提交构建和存储二进制解决方案的实践被称为连续交付。
—部署
部署是指所有构建工件在云或服务器上收集、执行和编排的过程，使用的编排器有 Mesos 、 Kubernetes 或 Docker Swarm 。
举例。当您使用 Docker 部署解决方案时，会创建一个 Docker 容器，它可以在您的本地机器上运行，也可以在云基础架构(如 Amazon EC2)的计算节点上运行。
最佳实践是为每个主和发布分支指定一个云环境。主分支和发布分支的云环境分别被称为开发(dev)和生产(prod)。在更复杂的工作流中，有一个登台环境超出了本文的范围。
如果使用微服务架构，可以独立部署前端、后端、数据库等每个微服务。微服务的集合被编排来构建主服务。微服务架构允许您独立、高效地测试、维护和部署松散耦合的服务。没有必要说您需要正确地配置这个编排，这也超出了本文的范围。
在没有任何干预的情况下持续部署解决方案的实践被称为持续部署。
临终遗言
您可以基于行业需求、公司阶段或客户期望使用不同的 git-flow 架构。在这篇文章中，我描述了每个人都必须知道的拥有一个高效团队和减少不必要冲突的要点。因此，您应该基于您的需求采用 git-flow，并使用它，直到它在您的团队中变得自然。
感谢阅读！
如果你喜欢这个帖子，想支持我…
[## 通过我的推荐链接加入 Medium—Pedram Ataee 博士
作为一个媒体会员，你的会员费的一部分会给你阅读的作家，你可以完全接触到每一个故事…
pedram-ataee.medium.com](https://pedram-ataee.medium.com/membership)
Git 在不到 8 分钟的时间里解释了——不仅仅是命令！
一本你不知道自己需要的 git 指南
资料来源:XKCD
虽然花时间学习 git(或写一篇关于它的文章)可能会感觉愚蠢和浪费，但让我告诉你，从长远来看，这是值得的。一旦你明白了它是如何运作的，并且感觉它不像是只会让你的生活变得痛苦的黑魔法，你可能就会开始有点欣赏它了。
抛开所有的承诺，在我们决定像一个没有版本支持的工具一样浏览命令之前，让我们了解一下这里到底发生了什么。
Git 基础设施
git 命令做的事情之一是移动/复制数据。在使用 git 时，有 4 个区域可以存放我们的数据。
- 工作空间，在这里您可以对文件进行修改。
- 该索引，又名暂存区，包含已暂存的文件，即准备提交的文件。如果您在 10 个文件中进行了更改，但只有 5 个与您的工作相关，则您只能添加这 5 个文件。
- 本地存储库包含提交的文件。该区域中的文件将被推送到原点。一旦添加了这 5 个文件，就可以通过一次提交将这些更改复制到这里。
- stash ，一个存储尚未准备好上传但你也不想丢失的文件的地方。
带有基本命令的 git 中的数据流。
此外，git 命令还可以将指针从一个提交移动到另一个提交。它还能够一气呵成地移动数据和指针。等等，我这里说的是什么指针？！
嗯，为了更清楚，我上面画的图是一个过于简单的图。本地存储库不仅仅是您实际项目的单一副本。而是一个提交树——其中每个提交都是您的项目在不同阶段的快照。
让我们看一个例子，其中我们有一个新的 git 项目，有两个文件——ReadMe。 txt 和 BubbleSort 。 cpp 。
然后我们创建一个文件 MergeSort 。 cpp 并修改了 ReadMe.txt 以反映新的状态。现在我们添加这些文件并创建一个新的提交 C2。
提交#2 后的状态。
每当你创建一个新的提交，它将把它附加到最近的提交(一个头在那个时刻指向)。在此过程中，分支指针不会移动。
现在我们对 git 有了一些了解，让我们来看看命令。
git 状态
它显示了你工作空间的当前状态。它将告诉您已暂存、未暂存或未跟踪的更改(新创建的文件，即在您的工作空间中但不在索引和存储库中的文件)。
git 添加
它将工作目录中的更改添加到临时区域。它告诉 Git，您希望在下一次提交中包含对特定文件的更新，用简单的英语来说，这意味着将您的更改从您的工作空间复制到您的索引/暂存区域。
git add <fileName> // To stage[add] individual files.git add -A // To stage[add] all the modified files.git rm --cached <fileName> // To undo an add i.e. remove from [2] but not from [1].Remember to add --cached otherwise the file will be removed from both [1] and [2].git rm <fileName> // Remove from both [1] and [2]
为什么信息很重要。来源:XKCD。
git 提交
它捕获项目当前阶段变更的快照。只有在您暂存了您的更改后，您才能提交它们。这会将索引中的更改复制到存储库中，并创建一个新的提交。除此之外，它所做的是将分支指针移动到最近的提交。由于头部之前指向分支指针，现在它也将指向新的提交。以下选项很有用:
- 修改:它允许你修改最近的提交。如果临时区域中没有文件，它将只让您编辑前面的提交消息。如果一些文件被转移，它将创建一个新的提交来替换最近的提交。如果您必须提交 3 个文件，F1、F2 和 F3。您准备了 F1 和 F2，然后是 git commit -m“添加了 3 个文件”。现在，您意识到您忘记转移 F3，因此它不在“添加的 3 个文件”提交中。要将 F3 添加到之前的提交中，请运行以下命令
git add F3
git commit --amend --no-edit
这将创建一个具有相同消息“添加了 3 个文件”的新提交，包含这两个提交中的暂存文件，并替换原始的“添加了 3 个文件”提交。
git commit -m "<YourCommitMessageGoesHere>"git commit --amend <NewCommitMesg> // Running this command when there is nothing staged lets you edit the previous commit’s message without altering its snapshot.git commit --amend --no-edit // Let's say you accidentally did a premature commit i.e. forget to stage a few files. Once you stage the missing files and run this command, it will replace the latest commit with the newly created one.
git 日志
它显示了提交的历史。查看您已经提交的更改(提交散列和提交消息)，或者其他人提交到该分支的更改。
这就是为什么在提交变更时给出有意义和相关的消息很重要，以便了解每次提交中可能发生了什么变更。
git log // Displays a history of commits, with commit hash and commit message.
git 贮藏
它暂时搁置(或隐藏)变更，这样你就可以做别的事情，然后回来重新应用它们。
这一个获取你所有的改变(不包括未跟踪的文件)并且将它们从工作空间移动到你的存储空间。这些更改将不再出现在您的工作空间中。
git stash save "<StashName>" // To move your changes to stash
git stash save -u "<stashName>" // To stash un-tracked files as wellgit stash list // Displays a list of all the "stashes" one has on various branches.git stash apply stash@{x} // Copies all the changes in stash@{x} from [4] to [1]. The changes are now in both [1] and [4].git stash pop // ***Moves*** the changes in stash@{0} from [4] to [1]. The changes will only be present in [1] now.git stash drop stash@{x} // Deletes the stash at position x.
git 差异
它显示了两个文件、git 上两个不同区域甚至两个不同提交之间的区别。
git diff // Shows diff in files between your work-space and index.git diff --cached // Shows diff in files between index and local repository, i.e. your staged changes.
git 分支
git 存储一个分支作为提交的引用。从这个意义上说，一个分支代表一系列提交的顶端
git branch //lists all the branches in your repository.git branch -d <branchName> // Deletes a branch. Safe option, as it won't let you delete a branch with unmerged changes.
git 检验
在更高的层次上，它用于从一个分支转移到另一个分支，或者创建一个新的分支。在非常基础的层面上，它用于从一个提交转移到另一个提交。它只移动头部指针。
git checkout <branchName> // Move to <branchName>git checkout -b <newBranchName> // Create a new branch.git checkout <commitId> // move to a specific commit id.
git 重置
它允许我们将头指针和分支指针都移动到指定的提交。使用该命令时应非常小心，因为它可能会造成不可逆的变化。根据所使用的选项，它还会修改暂存区和工作区中的指针。
复位命令有以下 3 个选项:
- —硬:这是最危险也是最强大的选项。它将修改指向存储库中指定提交的指针。指针也将在其他两个区域中更新—临时区域和工作区。这两个区域中的任何文件都将永远丢失。
- —混合:这是默认选项，在没有明确给出选项时使用。储存库中的指针将被更新为指定的提交。分段索引被重置为指定提交的状态。从临时索引中撤消的任何更改都被移动到工作空间中。
- —软:这只会更新存储库中的指针。临时区域和工作空间中的文件将保持原样。
git reset <commitHash> //Default is --mixed.
注意:
- 当 < commitHash > 之后的任何快照被推送到公共存储库时，您永远不应该使用 git reset
。发布提交后，您必须假设其他开发人员依赖于它。删除其他团队成员继续开发的提交会给协作带来严重的问题。
例如，如果您有 5 个提交， c1、c2、..，c5 。然后进行 git 推送，将所有代码推送到公共存储库。你开始在 c5 上开发，并意识到 c5 中的变化是不需要的，并决定做一个git reset c4。这是一个坏主意，不应该做。因为一旦你删除了 c5 ，你的本地历史将会与公共存储库中有 c5 的历史不同。您的更改和任何其他成员的更改都将从 c4 分叉，并且需要显式的合并提交来同步您的提交。 - 不要而不是因为与上述类似的原因修改公共提交。
多方面的
- git show :显示提交文件的变化。
- git fetch :从资源库中获取所有的分支。这还会从另一个存储库中下载所有必需的提交和文件。要真正看到工作空间的变化，您需要做一个 git check out
。 - git push :将本地存储库中的提交上传到远程存储库(origin)。
- git pull= git fetch(分支特定)+ git merge。它将获取头当前指向的分支中的所有提交。一旦所有本地更改都在本地存储库中(HEAD 仍然在我们的原始位置)，现在 git merge 将创建一个新的提交，它将包含来自 HEAD 指针提交和我们刚刚获取的最新提交的更改。
git pull 如何工作，来源。
在 git 获取之后，您将会注意到带有远程源/主指针(绿色)的提交链。git 合并将创建一个新的提交 H，将合并来自 G 和 c 的更改。它还将更新本地指针以指向 HEAD 和本地 origin/master 都将指向 H
结论
- 它不仅仅是命令。
- 它由 3 个区域组成——工作区、暂存区和本地存储库。
- 命令将数据从一个空间移动到另一个空间。
- 不同 git 命令的数据移动的简要总结:
git 从一个区域到另一个区域的基本移动的简要总结。
参考
[## Git 教程和培训|亚特兰大 Git 教程
通过这个全面的 Git 培训学习 Git 的基础知识。涵盖了分支、拉请求、合并等更多内容…
www.atlassian.com](https://www.atlassian.com/git/tutorials) [## 关于
Git 的特性真正使它从几乎所有的 SCM 中脱颖而出的是它的分支模型。Git…
git-scm.com](https://git-scm.com/about)
我很高兴你坚持到了这篇文章的结尾。🎉我希望你的阅读体验和我写这篇文章时一样丰富。💖**
请点击这里查看我的其他文章。
如果你想联系我，我会选择推特。
自动化项目组合生成的 GitHub 动作
使用 Python 和基本前端的 Dockerized GitHub 动作。
作为任何开发人员，我们都会生成大量代码，并将其推送到 Github 进行备份、管理软件版本、托管项目和其他许多任务。如果我们谈论有多少库是实际的项目，我们在简历/社交媒体中托管和展示，与创建的库的总数相比，这实在是太少了。这些包括分叉的存储库、一些上传的实践代码或一些参考的附加内容。
照片由 Richy Great 在 Unsplash 上拍摄
我已经创建了很多，现在当我必须展示我的项目时，我会对应该包括哪一个或我已经做了什么感到困惑！为了解决这一困境，我想出了一个解决方案，开发一个 Github 动作来自动添加项目，参加黑客马拉松，显示一些 Github 个人资料统计，并可选地显示在媒体和我的网站上写的最新博客，并将其提升到下一个级别，我将该动作分类并免费托管网页！让我们看看我是怎么做到的。
如果你想看看现在的行动，前往这个市场链接！
开发人员创建了数百个存储库，其中几乎没有几个是像样的，并在社交网站上展示…
github.com](https://github.com/marketplace/actions/portfoliofy)
什么是 GitHub Action？
Github action 使您能够自动化和定制软件开发周期，测试和部署集成到您的存储库中的应用程序。这些操作称为作业，可以通过 Cron 作业(基于时间的作业调度程序)根据您的需要安排运行。如果你访问 GitHub action 文档，你可能会混淆两个术语，动作和工作流。这些都是令人困惑的事情，需要在继续之前澄清:
- 动作和工作流之间的主要区别是一个是另一个的一部分。动作是执行特定工作流时触发的事件。
- 动作是在代码环境中执行的任务，而工作流管理这些任务将如何执行，它们的顺序是什么，在运行它们之前要完成的任何依赖/设置，输入，要传递的参数，或定义不同作业之间的依赖关系。
- 根据分配的配置，一个工作流可能有多个按顺序或并行运行的操作。
现在你已经对 Github 的动作有了基本的了解，让我们来编码实际的脚本，它将是这个动作的一部分。
脚本时间！
对于这个项目，我使用 Python，因为它对我来说很容易编码，而且使用 Python 构建的动作更少。该项目需要访问 Github 配置文件数据，尽管 Github API 提供了大部分数据，但对于未经身份验证的用户，它仍被限制为每小时 60 次请求。因此，你需要一个个人访问令牌(设置>开发者设置>个人访问令牌)来认证 Github 的用户，并允许每小时 5000 个请求！
首先，安装 PyGithub 库，解决所有令人头疼的连接、结果分页以及最终获取数据的问题。接下来，我们需要存储 API 返回的数据。我选择字典格式，因为它易于管理和访问属性。初始代码如下所示:
接下来关于存储库，我需要区分项目、黑客马拉松和其他额外的存储库。为了做到这一点，我设置了一个条件，即在设置这个动作之前，你需要手动分配存储库主题“项目”或“黑客马拉松”在投资组合中被考虑。如果一个存储库没有被标记，那么它将不会反映在输出中。这种情况将存储库分成不同的两个部分，现在它们被分开存储。
网页建设
Python 脚本提取了所有的信息，但是现在对于这个项目的主要目标，需要一个网页。最初，我想到使用 markdown 文件来做到这一点，但由于 Github 的限制，您不能在 markdown 中使用 CSS(以避免钓鱼攻击)。这是一个主要问题，因为我不想让用户在看到一个简单的纯文本组合后感到无聊或沮丧。因此，我扩展了当前的脚本，以使用之前收集的信息，并将值注入到 HTML 模板中，该模板存储为字符串，并使用 f 字符串进行更改。HTML 模板进行了大量的尝试，以获得一个简单的视图，该视图需要为移动视图进行不同的设置。Github 的所有基本信息都已获得，但还缺少一样东西，一个统计显示。为了显示统计数据，我使用了由 Anurag Hazra 开发的开源 Vercel 应用程序，它可以动态更新统计数据。对于博客更新，我使用了高塔姆克里希纳 R 行动，这是不同的安排，我将在接下来的段落中解释它。动作生成的最终网页是这样的:
图片作者，网页链接:https://kaustubhgupta.github.io/
在所有的混乱之后，这个动作可以生成一个 HTML 文件，在 Github 页面的帮助下可以部署，并且你有了你的免费托管的自我更新文件夹！现在，为了自动化添加新条目的整个过程，我想到了 Github action。
归档和创建行动
我为这个动作选择 docker 图像，因为当我尝试用 Python 创建一个动作的不同方法时，我没有得到任何好的结果。Dockers 帮助隔离环境并运行代码，因为它应该在本地运行。这个动作的 docker 文件看起来非常简单:
我已经从 docker hub 中提取了一个 Python 映像，安装了依赖项，并运行了脚本。
现在是创建动作的时候了。根据 Github docs，您需要在公共存储库的根目录中有一个名为 action.yml 的文件来使动作工作。动作文件包含以下内容:唯一的动作名称、描述、作者姓名、需要从用户处获取的输入，以及要执行哪个文件。在 YAML 格式中，它非常容易配置，因为它遵循分层系统。对于输入，我采用 Github token，对于文件，我提供 docker 文件。现在您的操作已经可以使用了，您也可以在市场上发布您的操作，但这不是强制性的。
使用的最终工作流程
现在是测试这个动作的时候了。正如我前面提到的，动作只是工作流中触发的事件。工作流定义了动作的顺序、运行的系统/环境规范，以及在触发之前或之后需要执行的其他活动。这些文件存储在
.github/workflows folder.
使用此操作的工作流程如下:
你可以根据自己的需求定制工作流程，但是工作中提到的步骤不能改变。这个工作流程运行良好，生成了 Github pages 正在使用的 index.html 文件，但是又少了一些东西。问题是博客更新动作还没有集成。我把这一步设为可选，因为不是每个人都写博客。要集成博客操作，在同一个工作流文件夹中，创建一个 YAML 文件，并放入相同的代码:(只需用您的链接更新提要列表)
你可以检查博客文章工作流动作来定制其他因素，只是确保不要过多调整模板参数，因为它可能不会给出好的结果。此操作在每次将内容推送到存储库时运行，由于索引文件将被推送到存储库，此操作将在索引文件生成后立即更新博客部分。
结论
在本文中，我向您介绍了 Github 动作的基本概念、工作流、它们之间的区别、动作的一些脚本、动作所需的文件以及最终在工作流中使用它们。我还讨论了我在这个项目中面临的挑战，以及如何在您的存储库中使用我的操作。如需更详细的说明和完整的源代码，请点击此处的资源库链接:
作为一名开发人员，我们创建了数百个存储库，但其中只有不到 15-20 个能够完成我们部署的最终项目…
github.com](https://github.com/kaustubhgupta/PortfolioFy)
支持这一行动，因为它为我提供了制作更多项目的动力，在 medium 上关注我以获得关于我最新文章的更新，如果你喜欢这一篇，请点击鼓掌按钮！说完了，合十礼！
Linkedin:
[## Kaustubh Gupta -机器学习导师-MAIT 开发者学生俱乐部| LinkedIn
嗨，我是一名 Python 开发人员，能够进行 Web 抓取、Selenium 自动化、数据科学、后端 Web 开发…
www.linkedin.com](https://www.linkedin.com/in/kaustubh-gupta-612767ab/)
GitHub 为胜利而行动
使用 GitHub Actions 进行持续集成轻而易举
威廉·冈克尔在 Unsplash 上拍摄的照片
你用 GitHub 做版本控制吗？你喜欢测试你的代码吗？对许多人来说，问题 1 的答案是肯定的，每个人都应该对问题 2 做出肯定的回答。很好，现在我们在同一页上，让我们来谈谈 GitHub 的行动。
GitHub Actions 是一个自动化工作流的框架。工作流在 YAML 创建，并在 GitHub 存储库上自动运行。下面的链接很好地概述了 GitHub 的动作。
使用 GitHub Actions 在您的存储库中自动化、定制和执行您的软件开发工作流。你…
docs.github.com](https://docs.github.com/en/free-pro-team@latest/actions)
上面的文档很好地介绍了 GitHub 动作和工作流文件语法。本文介绍了几个基本的工作流，用于在 GitHub 项目上添加持续集成。
入门
第一个例子涵盖了 py27hash 存储库中的一个工作流。
对于依赖于旧的散列/迭代顺序的应用程序，这个包有助于简化从 Python 2 到 3 的迁移…
github.com](https://github.com/neuml/py27hash)
所有的 GitHub 库都准备好了 GitHub 动作。下面的截图显示了 GitHub Actions 工作流的位置。
GitHub 操作选项卡
GitHub 将自动运行存储在中的任何工作流文件。github/workflows 目录。例如，py27hash 存储库有一个名为 build.yml 的工作流文件。
下的 build.yml 文件。github/工作流文件夹
工作流文件
下面的代码片段显示了存储在 py27hash 存储库中的 build.yml 工作流文件。
这个构建文件运行在推和拉请求上。该工作流在 Ubuntu Linux 虚拟机上运行，检查代码并运行一系列 Python 单元测试。如果这些都成功了，那么测试覆盖率就被发送到了。
让我们回顾一下下面的语法(记得查看https://docs.github.com/en/free-pro-team@latest/actions以获得更详细的工作流文档)。
设置工作流名称。
name**:** build
设置触发工作流的操作。
on: ["push", "pull_request"]
设置虚拟环境。
jobs:
build:
runs-on: ubuntu-latest
准备构建环境。下面的步骤从 GitHub 中签出代码，并为测试设置 Python 3.6 运行时环境。
steps:
- uses: actions/checkout@v2
- uses: actions/setup-python@v2
with:
python-version: 3.6
安装依赖项并运行测试。
- name: Build
run: |
pip install -U pip wheel coverage coveralls
python --version
./scripts/tests.sh skipslow
如果测试成功，发送测试覆盖报告给工作服。注意最后一行，秘密。GITHUB_TOKEN ，这是一个内置的，当提交到工作服时验证当前用户。
- name: Test Coverage
run: coveralls
env:
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
这是 GitHub 的另一个优势，我们不需要授权外部服务访问我们的 GitHub 库。
查看工作流状态
下面显示了“操作”标签中的工作流状态。
py27hash 的 GitHub 操作选项卡
正如我们所看到的，对 py27hash 存储库的两次提交触发了 build.yml 工作流。每次运行的详细信息可以通过单击运行找到。下面是一个例子。
GitHub 操作工作流运行详细信息
多种环境
如果我们的项目支持多个平台或版本会怎样？没问题，GitHub Actions 已经处理好了。接下来，我们将回顾作为 txtai 存储库一部分的工作流文件。
txtai 在文本部分建立了一个人工智能索引。txtai 支持构建文本索引来执行相似性…
github.com](https://github.com/neuml/txtai)
构建工作流文件如下:
让我们再次回顾一下工作流语法，只包括这个文件中的新项目。
设置多个环境是通过构建矩阵建立的。下面的配置为 Ubuntu、macOS 和 Windows 建立了构建环境。同样的方法也可以用来测试 Python 的多个版本。
jobs:
build:
runs-on: ${{ matrix.os }}
strategy:
matrix:
os: [ubuntu-latest, macos-latest, windows-latest]
默认情况下，每个环境都会运行工作流中的所有步骤。但是条件步骤也可以在每个环境中执行。以下步骤分别为 macOS 和 Windows 安装依赖项。
- name: Install dependencies - MacOS
run: brew install libomp
if: matrix.os == 'macos-latest' - name: Install dependencies - Windows
run: python -m pip install torch==1.6.0+cpu torchvision==0.7.0+cpu -f https://download.pytorch.org/whl/torch_stable.html
if: matrix.os == 'windows-latest'
其余步骤同上。唯一的例外是测试覆盖只针对单一环境(Ubuntu)。
完成后，将为每个环境创建一个单独的工作流状态部分。只有在所有环境中都成功的情况下，构建才是成功的。
多个构建环境
结论
本文给出了 GitHub 动作的一个非常简短的概述，涵盖了自动化测试的几个基本工作流程。有大量的附加功能可以自动执行部署、标记和其他操作。
与外部构建系统相比，它的性能非常好，并且是一种更简单、更安全的运行持续集成的方式。试一试吧，它一定不会让人失望的！
GitHub Actions —使 ML CI/CD 管道的“一键部署”变得可行
如何用 GitHub 动作为机器学习应用创建 CICD 管道
使用 Canva 设计
如果我告诉你“你可以将构建、测试、交付或部署你的机器学习模型到生产中的过程自动化”会怎么样？
世界上最受欢迎的托管存储库服务， GitHub 通过 GitHub 操作自动化任务，提供了一种设计和开发我们工作流的集成方式。通过动作，GitHub 库中发生的事件，如推送、拉取请求、发布等。用作启动工作流的触发器。这些工作流程以 YAML 格式编码。
工作流只不过是我们在将应用程序投入生产时遵循的步骤，包括单元测试、集成测试、构建工件、健全性检查和部署。在本文中，我将向您介绍 GitHub Actions ，并向您展示如何构建您的工作流来部署机器学习应用程序。
让我们开始吧！！
背景
GitHub 知识库(作者提供图片)
在 GitHub 上创建一个资源库，如果你没有帐户，我建议你创建一个。GitHub 上的每个存储库现在都支持 GitHub Actions 特性。
GitHub Actions(作者照片)
点击“操作”。如果我们的库中已经有任何文件，GitHub 会推荐一些预定义的工作流。在这里，我们将创建我们的工作流。点击“自己设置工作流程”。
我们的第一次行动(作者照片)
正如我前面提到的，GitHub 工作流是以 YAML 格式编码的，这里我们定义了作业、步骤和管道。在开始之前，让我们看一下 YAML 文件中使用的属性。下面是一个简单的模板来打印“你好，世界！!"
示例工作流程
我们在任何工作流程中使用的基本属性是:
- 名称— 您的工作流程的名称(可选)
- on — 触发流的 GitHub 事件。它可以是存储库事件(push、pull 请求、release)或 webhooks、分支创建、问题或成员加入存储库。
- 作业— 工作流必须至少有一个作业。每个工作都必须有一个标识符，就像我们执行的任务的名称，比如“构建”、“测试”等等。
- 连续运行— 运行作业所需的机器类型。这些环境被称为跑步者。其中有 windows server 2019，ubuntu 18.04，macOS Catalina 10.15 等。
- 步骤—****所有命令或动作的列表。每一步都有自己的过程。
- 用途— 标识要使用的动作，定义该动作的位置。一个动作可以是上传和下载工件或结帐或配置任何云帐户。你可以在 GitHubmarket place**找到各种各样的动作，类别包括持续集成、部署、项目管理、测试、安全等。我真的建议你探索各种行动，我们也可以在市场上发布我们的自定义行动。**
- 运行— 在虚拟环境 shell 中运行命令。
- 名称— 步骤的可选名称标识符。
按照您的意愿用步骤和作业配置工作流后，提交管道-YAML 文件。工作流现在将开始运行。现在我们知道了 GitHub 动作的术语，让我们开始构建机器学习应用程序的工作流。
ML 应用示例(作者提供照片)
我开发了一个机器学习应用程序，它将通过从用户那里获取一些输入来预测初创公司的利润。
首先，我用所需的数据集训练模型，测试并验证它。然后我创建了一个 Flask 服务器来服务来自用户的请求。我把项目目录推送到 GitHub。GitHub 存储库应该是这样的:
GitHub 知识库(作者提供图片)
我想创建一个具有以下四个阶段的工作流程。您也可以相应地定义您的工作流程。
- 林挺
- 构建一个 Docker 映像并推送到 Google 的容器注册表。
- 测试—从 Container Registry 下载 Docker 映像并测试它。
- 在云上部署 Docker 映像。
管道(作者照片)
林挺阶段
为了减少错误和提高代码的整体质量，林挺是必要的。如果 lint 工具被有效地使用，它可以通过降低发现错误的成本来帮助加快您的开发。在这个阶段，我们进行单元测试，检查代码风格。
现在我们将创建工作流，如上所示，我们将一步一步地做。
林特舞台(作者供图)
在这个阶段，我们需要定义环境(在我的例子中是 Ubuntu)，在那个环境中签出存储库，并安装模型运行所需的所有依赖项或需求。此外，我使用了 Pylint 和 flake8 来检查代码库的编码风格(PEP8)、编程错误，并检查圈复杂度。
构建 Docker 映像
既然我们已经针对某些编码风格测试了我们的代码，让我们构建一个 Docker 映像。如下所示创建一个 Dockerfile 文件
Dockerfile(作者照片)
我们使用一个docker 文件为应用程序构建一个 docker 映像。这个工件(docker 映像)需要存储在某个地方，在那里我们的应用程序的所有不同版本都存在。这将确保您在连续的版本中交付您的软件。我们有各种工具来存储工件，其中很少是 JFrog Artifactory、Amazon ECR、DockerHub、Google 的容器注册表。**
建立一个码头工人形象(作者提供照片)
现在，我将把 docker 图像推送到 Google 的容器注册表中。因此，我们需要设置 GCP 环境，该环境需要密码和 API 密钥等敏感信息。GitHub 允许我们存储秘密，我们可以以变量的形式访问这些秘密。
**${{ secrets.GCP_SERVICE_ACCT_KEY }}**
要创建一个秘密，进入设置并选择秘密。****
设置部分(作者提供照片)
您将被重定向到机密部分。点击“新秘密”。给秘密起个名字，增加价值。点击“添加密码”
创造一个秘密(作者照片)
我已经更新了所有需要的秘密。
秘密(作者照片)
一旦设置好环境，我们的工作将开始构建 docker 映像，并将其上传到 Google 的容器注册表(确保您在 Google 云平台上启用了容器注册表的 API)。
检验阶段
在执行上述阶段之后，我们将在我们的服务中将一个 docker 映像存储在容器注册表中。在这个阶段，我们将下载图像，并针对各种测试用例运行它。在真实的场景中，我们可能会使用不同版本的 docker 映像，并且我们会指定想要发布的版本。因此，我们从注册表中下载图像，而不是使用从上一阶段构建的图像。
测试阶段(作者照片)
软件应用程序或产品的有效性能需要测试。在这里，我们可以通过检查是否返回 200 状态代码(即成功运行的证明)来测试我们的 Flask 服务器。此外，因为我们可以测试和验证我们的机器学习模型，所以计算准确度并给出准确度的阈值水平，并且仅当准确度大于 95%(或任何其他阈值)时，才允许作业继续部署模型。
在云上部署 Docker 映像
一旦测试阶段结束，所有测试用例都通过，我们的下一步就是部署工件或 docker 映像。为了部署 docker 映像，我使用了 Cloud Run。
部署阶段(作者提供照片)
仅此而已！执行此阶段后，应用程序将很快投入生产。
结果
现在我们已经看到了整个工作流，让我们开始创建我们的行动。您可以在此处从复制工作流文件。
创建工作流程(作者照片)
点击开始提交并给出提交消息。提交文件。转到动作部分。您可以看到工作流已经开始执行。****
动作部分(作者照片)
成功运行所有作业后，您将看到以下输出。我们可以检查每个阶段的控制台输出，也可以检查调试日志。
工作流程输出(作者照片)
现在，如果我们转到容器注册表，我们可以查看被推送的工件。
集装箱登记处的码头工人图片(作者提供图片)
转到 GCP 导航菜单上计算部分下的云运行。创建具有给定名称的服务。机器学习模型已经投入生产。您现在可以通过端点访问服务了！
云运行控制台上的端点(照片 b 作者)
最终的应用程序(在我的例子中)看起来像这样:
最终启动应用程序(作者提供照片)
每次您将更改推送到代码时，都会触发此工作流。这是一个基本的管道。您可以构建具有不同阶段的管道——通过 API 调用获取数据、执行功能工程、模型训练、构建或存储模型(工件)、测试，以及部署到生产环境。
完整的代码可以在 GitHub 这里找到。
结论
我们已经看到了建立一个工作流的过程，该工作流使用 GitHub 操作来自动部署机器学习应用程序。它使我们能够创建我们的动作，并组合它们来为任何软件应用程序创建工作流。
如果你有什么建议，我很乐意听听。我很快会带着另一个有趣的话题回来。在那之前，呆在家里，保持安全，继续探索！
如果想联系，在LinkedIn上联系我。
Github Gists 101:让代码共享变得美好
简单代码展示的 5 个步骤
克里斯里德在 Unsplash 上的照片
如果你一直在浏览 Medium，查看技术文章，你肯定见过类似的小窗口，如下图:
具有基本功能的要点
这些被称为 Github Gists。gist 是一种简单的方法，以一种简洁和读者友好的方式与他人分享代码或数据的摘录。在本文中，您将看到显示您创建的函数、对表的查询或一些其他小数据片段的方法(就像对 dataframe 的一瞥)。这些信息由 GitHub 作为存储库托管。使用 gist 具有利用 GitHub 存储库的所有好处，具有轻量级和易于共享的嵌入特性。
它们不仅更干净，而且允许有视觉问题的编码人员有机会使用可访问性选项通读您的代码。
现在，让我们回顾一下基础知识:
1.Github Gists 入门
有两种方法可以到达 Github.com 的 gists 部分。第一种方式是你去Gist.Github.com，它会带你去新的要点创造。或者你可以浏览你的 Github 主页。
Github 主页让你有两种方式到达那里
底部的红色箭头指向我的个人资料图片，是你如何到达你的知识库或 gists。我们暂时忽略这一点，留待讨论编辑旧 gists 时再说。顶部的箭头指向加号，指向创建 repos、gists 或项目——这是我们首先要看的。点击加号后，你会看到一个下拉菜单。
新要点链接允许你创建一个全新的要点
这将把你带到下面的页面。请注意您有几个要填写的字段。
新要点的空白模板
- 描述框 —这将是要点的标题和非正式名称
- 文件名+扩展名 —这将是您命名文件的地方，以防下载。它也是你为你所使用的编程语言声明一个扩展的地方。
- 代码框 —这是您输入/粘贴想要显示的代码/数据的地方。
2.创建代码片段
从这里开始，一切都是即插即用。让我们试着用我们想要展示的一段代码创建一个要点——我正好有一个。
下面我写了一段代码，用来估算我最近完成的一个线性回归项目的数据。它是用来估算一所房子可能拥有的使用浴室的卧室数量和给定房子的居住面积。
我通过 gists.github.com 创建的代码片段
延伸是非常重要的。可以放之类的东西。txt ，。py 或者。html 。这将通知读者它是用什么语言编写的——如果还不清楚的话，并允许下载带有适当扩展名的文件。不管你是否延期，要点都会起作用——但是最好的“实践创造更好的工作机会”——保罗·托雷斯 2020。
简单地将代码复制并粘贴到窗口中，然后填写描述和文件名。
我把设置设为公开，这样在网站上搜索就能找到要点。然而，你可以选择制作一个不能被搜索的秘密要点——这些要点仍然可以通过你可以分发的链接来分享。
3.创建 CSV 表格
我们要看的下一个特性是使用 gists 创建表。Gists 不仅用于显示代码片段。您还可以在其中显示数据的小图片。我之所以说小，是因为在本文发表时，除了复制粘贴或手工输入之外，我还没有找到输入数据的方法。
第一步是开始一个新的要点并编辑文件名，使其以结束。csv 。这告诉网站，您将为列索引和单元格输入值，用逗号分隔。确保每个列名由逗号分隔，并且每个后续行的顺序与列名的顺序相同。
确保按照您希望的方式书写单词
看上面的图片，我们可以看到第一行条目是列名。第二行是数据中的第一个观察值。所有条目必须用逗号分隔，并且必须按照第一行中列名的顺序排列。整个表格都是如此。
不要担心单元格的分段或列名的字体——网站会帮你完成。
现在，让我们来看看完成的表。
每个观察值被分割到不同的行中，每个特征被分割到其自己的单元中。正如我们之前所说的，当列名被加粗并放在列的顶部时，字体的格式是自动完成的。
一个非常有用的功能是表格顶部的搜索框。嵌入时无法访问，但它在网站上。您可以搜索该表，它只返回您指定的值。
4.在介质上部署 Gists
现在我们可以谈论向世界展示这些要点了。
就在这里的 Medium 上，只需点击下一段药水上的 + ，点击 < > 选项即可。粘贴要点的网址后，按回车键。
看看这张 gif。
媒体嵌入过程的快速视频
5.查找或编辑以前制作的列表
如果你回到你的 Github 主页，在创建按钮的右边是你的照片。下拉菜单会给你链接到你的个人资料和设置，但更重要的是你的回购，项目和要点。
点击你的要点的链接。
这是您寻找已经创建的回购和 gists 的地方
在这一点上，你将被带到一个列出你所有清单的页面。
我最近更新的三个要点
点击一个，你就可以编辑了。你编辑的任何要点都会更新你在其他地方的嵌入。这是一个非常方便的特性，如果您发现了一个错误或者想要以一种更令人愉快的方式格式化代码。你不需要访问每个嵌入，你只需要更新要点，它就会为你工作。
感谢阅读。我希望这有助于您分发我知道您将编写的漂亮代码。
在 LinkedIn 这里跟我连线。
关于这些 gists 来自的项目的更多信息，请查看我的Github这里。你可以从下面的文章中找到这些要点:
将您的数据带入现实世界
towardsdatascience.com](/using-geopandas-for-spatial-visualization-21e78984dc37) [## 线性回归建模过程
预测金县房地产市场
towardsdatascience.com](/linear-regression-modeling-process-d0a92d2d14b)
GitHub 是你需要的最好的汽车
py caret——Python 中的开源、低代码机器学习库！
你可能想知道 GitHub 从什么时候开始涉足自动机器学习的业务。嗯，它没有，但你可以用它来测试你的个性化 AutoML 软件。在本教程中，我们将向您展示如何构建和容器化您自己的自动化机器学习软件，并使用 Docker 容器在 GitHub 上进行测试。
我们将使用 py caret 2.0(Python 中的开源低代码机器学习库)来开发一个简单的 AutoML 解决方案，并使用 GitHub actions 将其部署为 Docker 容器。如果你以前没有听说过 PyCaret，你可以在这里阅读 PyCaret 2.0 的官方公告，或者在这里查看详细的发行说明。
👉本教程的学习目标
- 了解什么是自动化机器学习，以及如何使用 PyCaret 2.0 构建一个简单的 AutoML 软件。
- 了解什么是容器，以及如何将 AutoML 解决方案部署为 Docker 容器。
- 什么是 GitHub 动作，如何使用它们来测试你的 AutoML。
什么是自动机器学习？
自动机器学习(AutoML)是将机器学习的耗时、迭代任务自动化的过程。它允许数据科学家和分析师高效地构建机器学习模型，同时保持模型质量。任何 AutoML 软件的最终目标都是基于一些性能标准最终确定最佳模型。
传统的机器学习模型开发过程是资源密集型的，需要大量的领域知识和时间来产生和比较几十个模型。借助自动化机器学习，您可以轻松高效地加快开发生产就绪型 ML 模型的速度。
有很多 AutoML 软件，有付费的，也有开源的。几乎所有这些都使用相同的转换和基本算法集合。因此，在这种软件下训练的模型的质量和性能大致相同。
如果你的口袋里没有几十个用例，付费的 AutoML 软件即服务是非常昂贵的，在经济上是不可行的。托管机器学习即服务平台相对较便宜，但它们通常难以使用，并且需要特定平台的知识。
在许多其他开源 AutoML 库中，PyCaret 相对来说是一个新的库，具有独特的低代码机器学习方法。PyCaret 的设计和功能简单、人性化、直观。在很短的时间内，PyCaret 被全球超过 100，000 名数据科学家采用，我们是一个不断增长的开发人员社区。
PyCaret 是如何工作的？
PyCaret 是一个用于监督和非监督机器学习的工作流自动化工具。它被组织成六个模块，每个模块都有一组可用于执行某些特定操作的功能。每个函数接受一个输入并返回一个输出，在大多数情况下，这是一个经过训练的机器学习模型。第二版中可用的模块有:
PyCaret 中的所有模块都支持数据准备(超过 25 种基本预处理技术，附带大量未经训练的模型&支持定制模型、自动超参数调整、模型分析和可解释性、自动模型选择、实验日志记录和简单的云部署选项。
要了解更多关于 PyCaret 的信息，点击这里阅读我们的官方发布公告。
如果你想开始使用 Python，点击此处查看入门笔记本示例库。
👉开始之前
在开始构建 AutoML 软件之前，让我们理解以下术语。在这一点上，你需要的是一些我们在本教程中使用的工具/术语的基本理论知识。如果你想了解更多的细节，在本教程的末尾有一些链接供你以后探索。
集装箱
容器提供了一个可移植且一致的环境，可以在不同的环境中快速部署，以最大化机器学习应用的准确性、性能和效率。环境包含运行时语言(例如 Python)、所有库以及应用程序的依赖项。
码头工人
Docker 是一家提供允许用户构建、运行和管理容器的软件(也称为 Docker)的公司。虽然 Docker 的集装箱是最常见的，但也有其他不太出名的替代品，如 T2、LXD、T4、LXC 和 T5，它们也提供集装箱解决方案。
开源代码库
GitHub 是一个基于云的服务，用于托管、管理和控制代码。假设您在一个大型团队中工作，其中多人(有时数百人)正在对同一个代码库进行更改。PyCaret 本身就是一个开源项目的例子，在这个项目中，数百名社区开发人员不断地贡献源代码。如果你之前没有用过 GitHub，你可以注册免费账号。
GitHub 动作
GitHub 动作帮助您在存储代码和协作处理拉取请求和问题的同一位置自动化您的软件开发工作流程。您可以编写称为操作的单个任务，并将它们组合起来创建自定义工作流。工作流是定制的自动化过程，您可以在存储库中设置它，以便在 GitHub 上构建、测试、打包、发布或部署任何代码项目。
👉我们开始吧
目标
根据数据集中的其他变量，如年龄、性别、体重指数、儿童、吸烟者和地区，训练和选择预测患者费用的最佳回归模型。
👉第一步——开发 app.py
这是 AutoML 的主文件，也是 Dockerfile 的入口点(参见下面的步骤 2)。如果您以前使用过 PyCaret，那么这段代码对您来说是不言自明的。
https://github . com/py caret/py caret-git-actions/blob/master/app . py
前五行是关于从环境中导入库和变量。接下来的三行用于读取数据作为熊猫数据帧。第 12 行到第 15 行是导入基于环境变量的相关模块，第 17 行以后是 PyCaret 的函数，用于初始化环境、比较基本模型以及在设备上保存性能最佳的模型。最后一行以 csv 文件的形式下载实验日志。
👉步骤 2—创建 Dockerfile 文件
Dockerfile 只是一个包含几行指令的文件，保存在您的项目文件夹中，名称为“Dockerfile”(区分大小写，没有扩展名)。
另一种看待 Docker 文件的方式是，它就像是你在自己的厨房里发明的食谱。当你与他人分享这样的食谱时，如果他们按照食谱中完全相同的说明去做，他们将能够复制出同样质量的菜肴。类似地，您可以与他人共享您的 docker 文件，然后他人可以基于该 docker 文件创建图像并运行容器。
这个项目的 Docker 文件很简单，只有 6 行。见下文:
https://github . com/py caret/py caret-git-actions/blob/master/docker file
Dockerfile 文件中的第一行导入 python:3.7-slim 图像。接下来的四行创建一个 app 文件夹，更新 libgomp1 库，并安装来自 requirements.txt 文件的所有需求，在本例中只需要 pycaret。最后，最后两行定义了应用程序的入口点；这意味着当容器启动时，它将执行我们之前在步骤 1 中看到的 app.py 文件。
👉步骤 3 —创建 action.yml
Docker 操作需要元数据文件。元数据文件名必须是action.yml或action.yaml。元数据文件中的数据定义了操作的输入、输出和主入口点。动作文件使用 YAML 语法。
https://github . com/py caret/py caret-git-actions/blob/master/action . yml
环境变量 dataset、target 和 usecase 分别在第 6、9 和 14 行声明。参见 app.py 的第 4–6 行，了解我们如何在 app.py 文件中使用这些环境变量。
👉步骤 4 —在 GitHub 上发布操作
此时，您的项目文件夹应该如下所示:
https://github.com/pycaret/pycaret-git-actions
点击‘发布’:
GitHub 操作—点击发布
起草新版本:
GitHub 行动——起草新版本
填写详细信息(标签、发布标题和描述)并点击‘发布发布’:
GitHub 操作—发布发布
发布后，点击发布，然后点击“市场”:
GitHub 行动—市场
点击‘使用最新版本’:
GitHub 操作—使用最新版本
保存这些信息，这是您的软件的安装详细信息。这是您在任何公共 GitHub 库上安装该软件所需的内容:
GitHub 操作—安装
👉步骤 5—在 GitHub 存储库上安装软件
为了安装和测试我们刚刚创建的软件，我们创建了一个新的存储库py caret-automl-test，并上传了一些用于分类和回归的样本数据集。
要安装我们在上一步中发布的软件，请单击“操作”:
https://github.com/pycaret/pycaret-automl-test/tree/master
GitHub 操作入门
点击自行设置工作流，将该脚本复制到编辑器中，然后点击开始提交。
这是 GitHub 要执行的指令文件。第一个动作从第 9 行开始。第 9 到 15 行是安装和执行我们之前开发的软件的操作。第 11 行是我们引用软件名称的地方(参见上面第 4 步的最后一部分)。第 13 到 15 行是定义环境变量的操作，比如数据集的名称(csv 文件必须上传到存储库)、目标变量的名称和用例类型。从第 16 行开始是从这个存储库上传三个文件 model.pkl，实验日志作为 csv 文件，系统日志作为. log 文件。
开始提交后，点击“操作”:
GitHub 操作—工作流程
这是您可以监视构建日志的地方，一旦工作流完成，您也可以从这个位置收集文件。
GitHub 操作—工作流构建日志
GitHub 操作—运行详细信息
你可以下载文件并在你的设备上解压。
文件:型号
这是最终模型的. pkl 文件，以及整个转换管道。您可以使用此文件通过 predict_model 函数对新数据集生成预测。要了解更多，点击这里。
文件:实验日志
这是一个. csv 文件，其中包含了模型所需的所有细节。它包含在 app.py 脚本中训练的所有模型、它们的性能指标、超参数和其他重要的元数据。
实验日志文件
文件:系统日志
这是 PyCaret 生成的系统日志文件。这可以用于审计过程。它包含重要的元数据信息，对于排除软件中的错误非常有用。
PyCaret 生成的系统日志文件
披露
GitHub Actions 使您能够直接在 GitHub 存储库中创建定制的软件开发生命周期工作流。根据您的客户计划，每个帐户都附带了与操作一起使用的计算和存储数量，您可以在操作文档中找到。
不得违反本协议、可接受使用政策或 GitHub Actions 服务限制使用 Actions 和 Actions 服务的任何元素。此外，操作不应用于:
- 秘密采矿；
- 无服务器计算；
- 使用我们的服务器来破坏、获取或试图获取对任何服务、设备、数据、账户或网络的未经授权的访问(未经 GitHub Bug Bounty 计划授权的访问除外)
- 为商业目的提供独立或集成的应用程序或服务，提供动作或任何动作元素；或者，
- 与使用 GitHub 动作的存储库相关的软件项目的生产、测试、部署或发布无关的任何其他活动。
为了防止违反这些限制和滥用 GitHub 操作，GitHub 可能会监控您对 GitHub 操作的使用。误用 GitHub 操作可能会导致作业终止，或者限制您使用 GitHub 操作的能力。
本教程中使用的存储库:
** [## py caret/py caret-git-操作
py caret-git-动作。在 GitHub 上创建一个帐户，为 pycaret/pycaret-git-actions 开发做贡献。
github.com](https://github.com/pycaret/pycaret-git-actions) [## py caret/py caret-自动测试
自动测试。在 GitHub 上创建一个帐户，为 pycaret/pycaret-automl-test 开发做贡献。
github.com](https://github.com/pycaret/pycaret-automl-test)
使用 Python 中的这个轻量级工作流自动化库，您可以实现的目标是无限的。如果你觉得这有用，请不要忘记给我们 github 回购⭐️。
要了解更多关于 PyCaret 的信息，请关注我们的 LinkedIn 和 Youtube。
如果你想了解更多关于 PyCaret 2.0 的信息，请阅读这个公告。如果你以前用过 PyCaret，你可能会对当前版本的发行说明感兴趣。
你可能也会对它感兴趣:
使用 PyCaret 2.0
在 Power BI 中构建您自己的 AutoML 使用 Docker
在 Azure 上部署机器学习管道在 Google Kubernetes 引擎上部署机器学习管道
在 AWS Fargate 上部署机器学习管道
构建并部署您的第一个机器学习 web 应用
使用 AWS Fargate server less
构建
重要链接
博客
py caret 2.0 发行说明
用户指南/文档 Github
stack overflow
安装 PyCaret
笔记本教程
贡献于 PyCaret
想了解某个特定模块？
单击下面的链接查看文档和工作示例。
基于 Python 的 Github 推荐系统
让我们分析用户相似性，并使用二分图的概念向用户推荐存储库。
使用 Canva 设计。
一个网络或者一个图是节点和边的组合。我们经常把图画成由边组合而成的节点，其中节点代表一些现实生活中的实体，比如脸书的用户，而边代表实体之间的关系，比如脸书的朋友。在我之前的文章中阅读更多关于图表的内容。我们将在本文中使用二分图和 NetworkX 包的概念。
二部图
定义二分图有两个条件。首先，它是一个节点被分成两组的图。第二，一组中的节点不能相互连接；它们只能连接到另一组中的节点。让我们举个例子来更具体地说明这一点。
以亚马逊购物网站为例。客户使用亚马逊网站/应用程序购买产品。假设我们正在为这个模型创建一个图表。让我们将节点分成两组，客户分区和产品分区。边缘表示客户已经购买了特定的产品。在这种情况下，产品不能连接到产品是完全合理的，因为一个产品不能购买另一个产品。顾客也一样。
让我们使用 NetworkX 包创建一个二分图。
如果我们在传入参数data=True时检查图的节点，我们将看到存储的分区信息。
过滤
NetworkX 没有提供显式的二分图类，我们需要显式地编写代码来过滤掉不同的节点集。这可以使用列表理解来完成。现在，让我们试着从上图中只检索“客户”集。
推荐系统
让我们尝试并理解如何将二分图应用于推荐系统问题。
二分图是协同过滤方法中使用的底层数据结构，这种方法在许多推荐系统如网飞和亚马逊中被广泛使用。
在 Github 上，用户在存储库上互相开发代码。正如文章标题所示，我们将向用户推荐在一个集合中使用高度相似节点概念的存储库。假设我们有一个二分图，如下所示。
用户 1 连接到 repo2，我们想推荐用户 1 可能有兴趣使用的存储库。现在，我们可以尝试分析连接到 repo2 而不是 User1 的所有其他用户。在这种情况下，用户 2 和用户 3 连接到 repo2。此外，请注意 User3 还连接到另一个存储库 repo1。因此，我们可能希望向用户 1 推荐 repo1 进行贡献。像亚马逊、YouTube 和网飞这样的大多数网站使用协同过滤作为推荐系统的一部分，根据相似用户的好恶向用户提供建议。
资料组
我们有一个存储库和用户的邻接表。我们有用户和存储库的编号，而不是名称。根据 NetworkX 文档，邻接表格式由带有节点标签的行组成。一行中的第一个标签是源节点。线中的其他标签被视为目标节点，并与源节点和目标节点之间的边一起添加到图中。例子—
a b c ( 'a '是源节点，' b '，' c '是目标节点)
表示在 a-b 和 a-c 之间有一条边的图。
“u”代表用户,“p”代表存储库。
如您所见，一个用户可以连接到许多存储库，反之亦然。带有单个标签的线表示没有边的节点。我们可以使用下面的命令从上面的文件创建一个图表。
G=nx.read_adjlist("/content/Github.txt")
我们可以注意到有 22，000 个节点(用户+存储库)和 20，000 条边。现在让我们将节点分成 2 组，即用户组和项目组。
现在让我们找出用户节点的数量和项目节点的数量。我们可以通过遍历节点列表、检查二分属性并查找生成的列表长度来完成这项任务，就像我们对上面的 customers 和 product 节点所做的那样。
在执行上述代码时，找到了 10721 个用户节点和 11632 个项目节点。
使用集合交点重叠
我们假设 2 个人，A 和 B，A 连接到 repo2，B 连接到 repo2 和 repo3。如何才能找到 A 和 B 的共享存储库(repo2)？
A_n = G.neighbors(A) will return ['repo2']
B_n = G.neighbors(B) will return ['repo2', 'repo3']overlap = set(A_n).intersection(B_n) will return ['repo2']
交集方法将返回 2 个或更多集合中的公共元素。借助上述逻辑，我们可以找到 2 个用户的相似度得分。
寻找相似的用户
2 个用户的相似性度量=共享项目数/项目总数。
使用上述逻辑，对于给定的用户 A，我们可以通过计算 A 与所有其他用户的相似性度量，并提取得分最高的用户，来找到最相似的用户。
推荐存储库
在上述用户“u4560”的代码中，最相似的用户是“u5453”和“u17446”。现在，如果我们发现“u5453”和“u17446”组合在一起与“u4560”的存储库不同，我们可以将它们推荐给“u4560”。
示例—假设有两个人，A 和 B。A 连接到 repo2，B 连接到 repo2 和 repo3。我们如何才能发现 A 和 B 的存储库之间的区别呢？
B.difference(A)将返回回购 3。difference()方法将返回出现在第一组中而不出现在第二组中的节点。
数据集和完整代码可以在 Github 这里获得。
一个脑筋急转弯！
上面哪个是二分图？也试着回答一下节点集！期待您的回复。请务必检查答案，找出正确答案。
结论
在本文中，我们了解了二分图的概念及其在推荐系统中的使用。我们还使用 NetworkX 包创建了一个 Github 存储库推荐系统。推荐系统中使用了更多的指标和方法，这些将在以后的文章中讨论。我希望你今天学到了新东西！
欢迎分享反馈。
GitHub URL 缩写
提示和技巧
使用 curl 和 Python 的 GitHub.com 网址缩写器
图片来自 Pixabay 的 Susanne Jutzeler，suju-foto
GitHub 是最受欢迎的 Git 源代码存储库托管服务。然而，URL 可能会变得很长，因为我们可能会对存储库和文件使用很长的名称。此外，当我们需要在电子邮件和社交网络上与他人分享 URL 时，它看起来会很混乱。
当我们需要与同事分享项目时，短 URL 看起来更好。GitHub 提供了一种服务，可以将这些又长又乱的网址变成更短更干净的网址。答案是 git.io 。
Git.io 是 GitHub 提供的缩短 URL 的服务。
要缩短网址，只需前往https://git.io/并输入你的 GitHub 网址。URL 可以是 GitHub 存储库，甚至是 GitHub 页面的 URL。
注意:这个网址缩写器只能用于 GitHub 网址，不能用于其他网址。
使用 curl 缩短 URL
创建缩短的 URL
您也可以使用curl命令来缩短 URL:
curl -i https://git.io -F "url=GITHUB_URL"
举例:
curl -i https://git.io -F "url=https://github.com/jimit105/Sentiment-Analysis-of-Movie-Reviews-using-NLP"
Output:
Location: https://git.io/JfzQJ
要获得一个定制的简短 URL，使用参数code传递定制文本
curl -i https://git.io -F "url=GITHUB_URL" -F "code=CUSTOM_TEXT"
举例:
curl -i https://git.io -F "url=https://github.com/jimit105/Intro-to-Deep-Learning-with-PyTorch" -F "code=pytorch"
Output:
Location: https://git.io/pytorch
缩短的网址将出现在回复标题的Location字段中。
如果您得到 SSL 错误，那么通过命令传递--insecure标志来跳过证书验证。
检索完整的 URL
使用以下命令从缩短的 URL 中检索完整的 URL:
curl -i SHORTENED-URL
举例:
curl -i https://git.io/JfzQJ
Output:
Location: https://github.com/jimit105/Sentiment-Analysis-of-Movie-Reviews-using-NLP
使用 Python 缩短 URL
您还可以使用以下 Python 脚本来缩短 URL，并从缩短的 URL 中检索完整的 URL
创建缩短的 URL
import requests
url = 'https://git.io/'
data = {'url': 'https://github.com/jimit105/Intro-to-Deep-Learning-with-PyTorch',
'code': 'pytorch'}
r = requests.post(url, data=data)
print(r.headers.get('Location'))
# Output:
# https://git.io/pytorch
如果在运行上面的脚本时得到了SSLError，那么在requests.post方法中添加参数verify=False来跳过证书验证。
检索完整的 URL
import requests
r = requests.head('https://git.io/pytorch')
print(r.headers.get('Location'))
# Output:
# https://github.com/jimit105/Intro-to-Deep-Learning-with-PyTorch
注意:您只能为每个 URL 创建一个缩写 URL。如果 GitHub URL 已经被缩短，则不能创建另一个缩短的 URL。如果您再次尝试缩短相同的 URL，它将返回现有的缩短的 URL。
结论
在本文中，我们看到了如何使用 git.io 来缩短 GitHub 的 URL。该服务仅适用于 GitHub 网站，即您只能缩短 GitHub 网址，而不能缩短其他网址。因此，当你与他人分享缩短的网址时，他们可以相信链接会指向 GitHub 网站(就像 g.co 是谷歌官方网址缩写，它会带你去谷歌的产品或服务)。
参考
资源
本文中使用的所有代码片段都可以在我的 GitHub 页面上找到。
让我们连接
领英:【https://www.linkedin.com/in/jimit105/】
GitHub:https://github.com/jimit105
推特:https://twitter.com/jimit105
GitHub 通向 1.28 亿公共知识库的道路
用硬数字
在 Simiotics，我们写了很多分析代码的代码。GitHub 是世界上最大的源代码主机。这意味着我们要花大量时间分析来自 GitHub 的数据。 镜像 是一个开源项目，有我们的一些代码爬虫。
GitHub 的时间表记录了 GitHub 作为一家企业的崛起。我们将使用由镜像收集的数据，用存储库统计数据来补充这个时间线。我们使用的数据是从 GitHub 的 /repositories API 端点抓取的。您可以使用镜像存储库中的GitHub Jupyter 笔记本运行用于分析的代码。
由 Markus Spiske 在 Unsplash 上拍摄的照片
我们的目标是使用 GitHub 提供给我们的关于公共库的信息来可视化 GitHub 上的库总数是如何随着时间的推移而增长的。
制作这篇博文的大部分工作都是使用 镜像 来抓取 GitHub。使用一个自由层合格的 t2.micro EC2 实例和用一个 GitHub 帐户认证的请求， mirror 花费了大约 10 天来检索关于所有公共 GitHub 存储库的基本元数据。
抓取不需要监督，我们选择等到一个完整的抓取完成后再发布这个分析。为了这篇博文的目的，我们也可以更快地抓取更稀疏的公共存储库集合，但是我们也出于其他原因想要元数据。
这是我们从爬行中构建的可视化。我们用 GitHub 的时间线中有趣的事件来标记图表。
/repositories 端点不返回每个存储库的创建日期。为了获得存储库的创建日期，我们必须查询其特定的 API URL 并读取 created_at 字段。
GitHub 上有超过 1.28 亿个公共存储库。一个 GitHub 帐户每小时只能发出 5000 个所需类型的 API 请求。这意味着检索每个公共存储库的创建日期需要 25600 个小时，差不多 3 年。与此同时，GitHub 用户将继续创建更多的公共库。
相反，我们满足于检索均匀分布的存储库样本的创建时间，并通过它们的 GitHub id 字段的差异来估计样本之间的存储库数量。GitHub 的 /repositories 端点返回的存储库列表为每个存储库提供了一个 id 字段。这是一个整数 ID，似乎由公共和私有存储库共享。虽然还不清楚这些 id 是否按顺序递增，但我们的分析表明它们是递增的。
在爬行 /repositories 端点时，理解这些响应反映了在您做出每个响应时存储库的公共和私有状态是很重要的。旧的存储库更有可能被私有或删除。我们的图表反映了与较晚日期相比，较早日期直方图的块状性。
图片来自模拟/镜像
其他一些有趣的统计:
- 截至 2020 年 2 月 26 日，GitHub 上的公共知识库数量约为 128，411，417
- 截至 2020 年 2 月 26 日，GitHub 上公共存储库的所有者数量大约为 23，298，697
如果你有兴趣复制这个分析，或者如果你想扩展它，GitHub Jupyter 笔记本的崛起是一个很好的起点。我们已经托管了样本存储库的数据集，为此我们收集了完整的存储库元数据作为依据。数据为 JSON 行格式。
在我的 GitHub 系列的下一篇文章中，我将分析编程语言在公共 GitHub 库中的分布。
联系我上 LinkedIn 如有问题，关注我上Twitter。
PyTorch3D 一瞥:一个开源的 3D 深度学习库
在深度学习环境中采取下一步措施脸书人工智能研究所推出了 PyTorch3D 一个为 3D 计算机视觉研究提供深度学习和组件的库。
GIF Src: 将一个球体网格变形为海豚
随着 PyTorch3D 的发布，脸书正在开源 Mesh-RCNN ，它可以检测现实世界图像中的物体，并预测每个检测到的物体的完整 3D 形状。PyTorch3D 将在许多工业深度学习应用中有用，如机器人取放任务或帮助自动驾驶汽车理解周围物体的位置。
PyTorch3D 附带了一个模块化的可区分渲染 API，它提供了许多经常使用的 3D 操作符和损失函数，用于快速和可区分的 3D 数据。这使得开发人员和研究人员可以将这些功能导入到现有的最先进的深度学习项目中。
PyTorch3D 的主要特性
- PyTorch3D 网格用于存储和操作 3D 对象的数据结构
- 它附带了一些对三角形网格的有效操作，如投影变换、图形卷积等。使用可区分网格渲染器
- PyTorch3d 中的所有运算符都是使用 PyTorch 张量实现的
- 与任何现有的 3D 库相比，PyTorch3D 具有处理小批量异构数据的能力
- 它支持 CUDA，因此可以利用 GPU 进行加速
装置
为了安装 PyTorch3D，您需要安装 PyTorch，因为 PyTorch3D 在 PyTorch 之上工作。请参见下面的命令来安装 PyTorch
conda create -n pytorch3d python=3.6
conda activate pytorch3d
conda install -c pytorch pytorch torchvision cudatoolkit=10.0
conda install -c conda-forge -c fvcore fvcore
安装 PyTorch 后，您可以使用下面的任何一个命令来安装 PyTorch3D。
- 来自蟒蛇云
conda install pytorch3d -c pytorch3d
运筹学
- 来自 GitHub
`pip install 'git+https://github.com/facebookresearch/pytorch3d.git'(add --user if you don't have permission)`
教程
脸书人工智能研究所提供了一些笔记本教程，让你开始使用 PyTorch3D。看看下面这 4 款笔记本吧。
有用的链接
图沙尔·卡普尔😦https://www.tusharck.com/
免责声明:
- PyTorch3D、PyTorch3D 徽标以及与 PyTorch3D 或网站相关的所有其他商标、服务标志、图形和徽标是 PyTorch3D 或 PyTorch3D 许可方的商标或注册商标。
- PyTorch3d 是在 BSD-3 条款许可下发布的。
全球新冠肺炎预报
正在 Kaggle 上进行的新冠肺炎预报竞赛简介
1.介绍
在这本笔记本中，我们将分析 2019 年 12 月在武汉首次发现的新冠肺炎在全球的传播和发展。截至 2020 年 4 月 13 日，210 个国家报告了 200 多万例病例。我们将尝试预测 2020 年 4 月 15 日至 2020 年 5 月 15 日的发展，这是正在进行的 Kaggle 竞赛的一部分。我认为澄清这一挑战背后的想法非常重要，我认为 Kaggle 团队总结得很好:
我们理解这是一个严峻的形势，绝不想通过预测死亡人数来淡化这场危机对人类造成的影响。我们的目标是提供更好的评估方法，帮助医疗和政府机构在流行病爆发时做好准备和调整。
在笔记本的第一部分，我们将从信息和质量的角度探讨数据。之后，我们将清理数据，并继续进行特征工程。在第三部分，我们将看看不同的预测方法，即线性回归和 ARIMA。最后，在我们为竞赛创建提交文件之前，我们将有一个短暂的停留和回顾。尽管这是一个非常严肃的话题，但我希望我们能一起学到一些东西。保持健康！
2.探索性数据分析
2.1 确诊病例
在开始之前，让我们快速看一下数据结构。我们有两组数据。训练数据集包含六列:
- ID :唯一标识符
- 省 _ 州:特定国家的省和州，如美国的华盛顿州
- 国家地区:德国、法国或西班牙
- 日期:各行的日期戳
- 确诊病例:新冠肺炎确诊病例数
- 死亡人数:新冠肺炎登记的死亡人数
除了“Province_state”列之外，数据集中没有遗漏。4 月初也有一个重叠的日期间隔。我们将修复这些问题，并先看看发行版。
迄今为止，大多数新冠肺炎病例发生在美国。紧随其后的是四个最大的欧盟成员国和中国，中国是第一个新冠肺炎病例出现的国家。
在上图中，我们绘制了前 10 个国家的确诊病例数量以及全球发展线。一个有趣的观察是，这 10 个国家占全球发展的很大一部分(见全球趋势线)。乍一看，曲线似乎变平了，这表明我们正在离开指数增长阶段。
我们创建了两个新变量:差异和增加配额。第一个变量包含 t0 和 t-1 绝对情况下的差异。第二个变量，增加配额，是 t0 和 t-1 之差的商。正如我们所看到的，随着时间的推移，这两种发展都趋于平缓。这可能有两个原因:
- 我们正在进入电晕流行的下一个阶段，并离开指数增长阶段
- 的数据质量不够，只有一小部分的实际感染被计算和统计记录。2020 年 4 月 13 日的奇怪异常值支持了这一论点。
为了更好地了解情况，我们现在检查死亡人数。
2.2 死亡事故
基本上情况与确诊病例相同。2020 年 4 月 13 日，据报道死亡人数超过 119，000 人。大多数死亡病例来自我们之前在确诊病例图表中看到的 10 个州。乍一看，曲线看起来比确诊病例更陡，因此我们将对它们进行比较。
我们的印象是正确的:确诊病例的曲线最近比死亡病例的曲线更平坦，但差异并不巨大。如果确诊病例的增长真的放缓，这种发展是合理的，因为人们不是直接死于电晕，而是后来。
2.3 新冠肺炎的地理分布
动画展示了 2020 年 1 月 1 日至 2020 年 4 月 12 日期间新冠肺炎的传播情况。直到 20.02。除了中国之外，只有一个小点，在那之后，首先在欧洲，然后在美国，最后在非洲有了快速的增长。目前，世界上几乎每个地区都受到 Covid 19 的影响。
2.4 结论
让我们简要总结一下主要发现:
- 全世界约有 200 万确诊病例和 119，000 例死亡病例。确诊病例和死亡人数排名前 10 位的国家占大多数。
- 根据目前的数据，利差似乎在有所放缓。
- 几乎世界上的每个地区都受到新冠肺炎的影响
然而，专家认为，未报告的病例数量要高得多，只有一小部分病例得到记录。因此，我们的观察也可能是因为许多国家的检测能力已经耗尽。我们无法用现有的数据材料回答这个问题。为了进一步的调查，我们必须假定现有的数字反映了实际的发展情况。
3.特征工程
在这一章中，我们将尝试时间序列分析的不同方法和技术。如果你对最终预测感兴趣，你可以直接进入第 4.3 章ARIMA。
3.1 国家、州和日期
在这一章中，我们将以这样一种方式准备数据，以便我们能够用各种统计方法进行预测。为此，我们将清理数据并创建要素。特征工程是时间序列分析中一个非常有趣的因素。如果我们假设想要预测确诊病例和死亡人数，我们将只有州、省和日期作为模型的输入。以有意义的方式推断这些数据似乎太少了，但是在本章的后面会有更多的介绍。让我们首先来看看训练和测试数据集。
正如我们在第一章中已经看到的，有一段重叠的时间。本次比赛的规则规定，只有 2020 年 4 月 1 日之前的数据可以用于公共排行榜。由于这个原因，我们从训练数据中删除数据。稍后，我们将使用所有可用的数据来做出最好的预测。
我们已经注意到我们没有很多可用的功能。先把日期搞得有意义一点。算法不能从日期中读取任何东西，所以我们从中提取各种特征，比如日和周。例如，你可以从组合中读出每周趋势。在德国，我注意到，平均而言，周四和周五报告的病例较多，周六和周日明显较少。这可能与报告过程有关:周六和周日，相关办公室的工作人员较少，而且并非所有病例都得到可靠报告。
此外，我们对州和省使用 SciKit 的 LabelEncoder()，因为大多数算法不能对字符串做任何事情。标签编码器为相应列中的每个不同案例分配一个编号。
3.2 确诊病例和死亡——滞后和趋势
如果我们想要预测未来的数据点，目前只有国家、州和日期是已知的。我们没有关于未来确诊病例或死亡人数的信息。不过，我们确有过去个案数目的资料，我们应该利用这些资料。在时间序列分析中，当目标的先前发展(例如确诊病例)被记录为数据集中的特征时，我们称之为滞后。
此外，可以记录趋势，即短期发展。这可以描述为两个连续数据点之间的趋势为(t0 -t1)/ t1。
4.系统模型化
现在我们有了所有必要的函数，数据也相应地准备好了。我们将尝试两种不同的方法:1)线性回归和 2) ARIMA。我们将从线性回归开始。你可以在 SkyCit 这里找到更多关于线性回归的实现和参数的信息。
4.1 线性回归(不用于提交)
与其他机器学习项目不同，我们不能仅仅通过 train-test-split 函数来抽取随机样本，因为数据点在时间上是相互依赖的。因此我们编写自己的函数。在训练数据集中，我们有截至 2020 年 3 月 31 日的可用数据。这是自 2020 年 1 月 22 日(我们数据集中的第一天)以来的第 69 天。我们将训练我们的数据，直到 2020 年 3 月 31 日，然后我们将看到我们的预测与实际发展有多接近。我们将在以下方面有所不同:
- 使用的滞后数
- 我们包括的培训时间
关于线性回归函数的几点说明:
- 我们为每个国家单独训练算法。如果一个国家有几个州，我们也会针对每个州分别进行培训。由于各州处于新冠肺炎疫情的不同阶段，我们将无法使用针对所有数据点训练的算法做出良好的预测。
- 第一步，我们计算各个国家或州的滞后。通过反复试验可以获得正确的滞后次数。太少的滞后会导致对短期趋势的过度解读，太多的滞后意味着我们没有充分考虑短期趋势。
- 然后我们对目标和滞后进行对数运算。线性回归不适合外推指数趋势。对数允许我们的算法更好地解释和处理数据。
注意:滞后的使用产生了一个新问题。这些只适用于我们的训练数据。所以我们只有第一次预测的可用日志。之后，我们必须将该预测写回到训练数据集中，重新计算滞后，并做出新的预测。必须对每个数据点重复这一过程。
致谢:实现的大部分代码来自这个伟大的笔记本。我通常也建议阅读它，以获得关于进一步过程的理论假设。
我现在不会显示所有不同参数的结果。您可以在链接的笔记本中亲自测试它们。在下文中，我们将了解以下参数的结果:
- 确诊病例有 40 个滞后
- 死亡 20 次
- 培训开始日期 2020 年 3 月 10 日
确诊病例位于左侧 Y 轴，死亡病例位于右侧 Y 轴。
德国
西班牙
阿尔及利亚
安道尔
4.2 线性回归-结论
对于德国和西班牙，预测最初看起来不错，但可以看出，实际数字和预测之间的差距正在扩大。我们也研究了阿尔及利亚，作为一个迄今病例很少的国家。在这一点上，预测和实际数字也出现了偏差。我选择安道尔是因为到目前为止这里还没有病例。这个预测完全是荒谬的，会毁了我们在卡格尔的整个成绩。我们可以通过硬编码来拦截这种现象，即没有确诊病例的国家将继续被预测为零。相反，我们将继续使用 ARIMA 方法。
4.3 ARIMA(用于提交)
ARIMA 代表自回归(AR)综合(I)移动平均线(MA)。作为输入提供的数据必须是单变量序列，因为 ARIMA 从过去计算未来的数据点。这正是我们试图用线性回归做的。ARIMA 基本上有三个重要参数:
p:模型的自回归部分。简化一点可以说，模型假设如果昨天和前天有很多确诊病例，那么今天和明天也会有很多确诊病例。
描述差异量的模型的集成部分。如果可用的数据不是稳定的并且包含趋势，ARIMA 可以提取这种季节性。
q ->模型的移动平均线部分。通过形成均线，可以平滑随机效应。
重要提示 : ARIMA 无法考虑任何外部因素。数据点仅基于历史数据进行推断。如果在一个州有夜间外出的禁令，我们的模型将而不是提供良好的预测。
功劳:实现的大部分代码来自这个很棒的笔记本。
确诊病例位于左侧 Y 轴，死亡病例位于右侧 Y 轴。
德国
西班牙
意大利
阿尔及利亚
安道尔
伊朗
俄罗斯
中国—上海
中国—北京
美国—纽约
美国—华盛顿
韩国
加纳
南非
4.4 ARIMA——结论
随着时间的推移，对单个国家的预测看起来更加可信。德国等确诊病例较多、历史较长的国家的数据点可以很好地推断出来。如果报告的数据不稳定，比如在上海，我们的算法将无法做出准确的预测。
实施过程相比线性回归也容易得多。提交给 Kaggle 的第一份测试的均方根误差约为 0.4。第 4 周的比赛今天结束，评估阶段开始。我会补充最后的结果。
5.摘要
首先，我们观察了新冠肺炎周围的发展，清理了数据并做了相应的准备。然后我们尝试了两种不同的方法来预测时间序列:1)线性回归和 2) ARIMA。线性回归的结果非常不稳定，预测似乎也不是特别准确。在 ARIMA，我们取得了明显更好和更可信的结果。最终结果评估可能于 2020 年 5 月 15 日进行。然而，测试期间的提交取得了良好的成绩。
尽管这个话题很严肃，但我希望你能带走一些东西。居家健康！
如果你对数据科学感兴趣并且还没有注册，请随时使用我的推荐链接加入这个社区。
编者按: 走向数据科学 是一份以数据科学和机器学习研究为主的中型刊物。我们不是健康专家或流行病学家，本文的观点不应被解释为专业建议。想了解更多关于疫情冠状病毒的信息，可以点击 这里 。
Python 中的全局、局部和非局部变量
在本教程中，让我们学习 Python 中全局、局部和非局部变量的用法
首先，我不是上图中的那个人。我只是一个仁厚的作家，在这里讲一个 Python 编程中最容易混淆的概念“ 全局、局部和非局部变量 ”。我知道看完标题你会想“ 我为什么还要担心这个 ”。嗯，答案是有时候不知道这些微小的事情会让你付出很大的代价。所以事不宜迟，我们开始吧。
在像 C/C++这样的编程语言中，每次同时声明一个变量时，都会分配一个内存，这种分配完全取决于变量的类型。因此，程序员在创建变量时必须指定变量类型。但幸运的是，在 Python 中，您不必这样做。Python 没有变量类型声明。像 C 中的指针一样，Python 中的变量不合法地存储值；它们使用引用来突出显示内存中的对象。
主题
本文将涉及的主题列表如下:
- 变量 —快速介绍
- 全局变量 —如何摆脱
**UnboundLocalError** - 局部变量 —如何摆脱
**NameError** - 非局部变量 —何时以及如何使用它们
另外，在开始之前，我必须告诉你一件事。这篇文章的全部代码可以在我的 GitHub 资源库 下面给出:
permalink dissolve GitHub 是超过 5000 万开发人员的家园，他们一起工作来托管和审查代码，管理…
github.com](https://github.com/Tanu-N-Prabhu/Python/blob/master/Global%2C_Local_and_Nonlocal_variables_in_Python.ipynb)
变量
一个变量更可能是一个 容器 来存储值。现在要存储的值取决于程序员是使用整数、浮点、字符串还是 等 。
变量就像计算机内存中的一个盒子，你可以在里面存储一个值。—阿尔·斯威加特
与其他编程语言不同，在 Python 中，你不需要声明或初始化任何变量。 请阅读 本 。
语法
在 Python 中创建变量的一般语法如下所示:
**variable_name** = **value**
Python 中的**variable_name** 可以简短如**a, b, x, y, ...**也可以信息量很大如**age, height, name, student_name, covid, ...**
虽然建议保留一个描述性很强的变量名以提高可读性。
规则
一切都设置好了，命名变量时需要遵循一些规则:
- 变量名必须以字母或下划线字符开头**
- 变量名不能以 号 开头
- 变量名只能包含 字母数字字符 和 下划线。 例如，任何类似这样的都是有效的: A-z，0–9，以及 _
- 变量名 区分大小写 ( 高度 、 高度 、 高度 是三个不同的变量名)
例子
下面给出了一个将值正确初始化为变量的示例:
****# This is a valid and good way to assign a value to a variable
# Let's assign values to variables to calculate the area of a circle****pi** = 3.142 **# I could have also used "math" library**
**radius** = 5 **# Interger value for radius
area_of_circle** = 0 **# Used to store the value of area of circle****area_of_circle** = pi * (radius) ** 2 **# Area = (PI * R^2)**print("The area of the circle is: ", **area_of_circle**)**
上面代码的输出如下所示:
**The area of the circle is: 78.55**
图片示例(快速浏览)
我相信只要看到一幅图片或一幅图像，就能更快地理解这些概念。下面是存储在内存中的变量的图示。
作者 Tanu Nanda Prabhu 的照片
作者 Tanu Nanda Prabhu 的照片
全局变量
相同的旧定义
在 Python 或者其他任何编程语言中，全局变量的定义保持不变，就是“ 一个在函数外声明的变量叫做全局函数 ”。我们可以在函数内部或外部访问一个全局变量。
创建一个全局变量并访问它
让我们用上面的例子来理解在函数内部和外部访问变量的概念。
**pi = 3.142 **# I could have also used "math" library (math.pi)**
radius = 5 **# Interger value for radius**def **circle**():
area_of_circle = pi * (radius) ** 2
print("The area of the circle is: ", area_of_circle)
circumference_of_circle = 2 * pi * radius**# Accessing the global variables outside the function** print("The circumference of the circle: ", circumference_of_circle)
**# Accessing the global variables inside the function
circle**()**
上述代码的输出如下所示:
**The circumference of the circle: **31.419999999999998**
The area of the circle is: ** 78.55****
这就是全局变量的特点。如上例所示，我使用了两个常用变量**pi**和**radius** 来计算在函数内部声明的圆的面积和在函数外部计算的圆周的面积。对于这两种计算，我们使用相同的公共变量。
详细理解“UnboundLocalError”
现在让我们以同样的老例子为例，尝试将**radius** 更新 2(乘以 2)
**pi = 3.142 **# I could have also used "math" library (math.pi)**
radius = 5 **# Interger value for radius**def **circle()**:
radius = radius * 2 **# Update the radius by (x 2)**
area_of_circle = pi * (radius) ** 2
print("The area of the circle is: ", area_of_circle)**circle()** **# Accessing the global variables inside the function****
现在我知道你可能会喜欢“ 没有必要 ”这个额外的步骤**radius = radius * 2**我们可以在初始步骤中直接这样做，将半径值指定为 10，即**radius = 10**。我知道，但我正在尝试引入一个概念。请原谅我。
从上面的代码中可以看出，如果您尝试更新半径，然后执行这段代码，您会感到惊讶。不要激动的说“ 我做了 ”因为你没有，反而会被一个叫做**UnboundLocalError** 的错误提示。更有可能的错误是这样的。
****UnboundLocalError**: local variable '**radius**' referenced before assignment**
这个错误的原因是变量**radius** 是局部的，不能像上面那样更新。在这里，你可以把它变成一个全局变量。现在怎么做。请看下面的代码片段。
**pi = 3.142 **# I could have also used "math" library (math.pi)**
radius = 5 **# Interger value for radius**def **circle()**:
**global** radius **# Making raduis a global variable**
radius = radius * 2 **# Update the radius by (x 2)**
area_of_circle = pi * (radius) ** 2
print("The area of the circle is: ", area_of_circle)**circle()****
现在，当您执行代码时，它会顺利执行。因为现在它被明确声明为全局变量。上面代码的输出如下所示:
**The area of the circle is: **314.2****
考验你长远知识的时候到了。两年前在 栈溢出 中有一个关于**UnboundLocalError**的问题。 表单 现已停止接受答案，因为已经有大量答案。你可以跳进去，试着回答它，更清楚地理解它。
局部变量
相同的旧定义
在 Python 或者其他任何编程语言中，局部变量的定义保持不变，就是“ 在函数内部声明的一个变量称为局部函数 ”。我们可以在函数内部访问一个局部变量，但不能在函数外部访问。
创建一个局部变量并访问它
我们在函数内部使用局部变量，并不试图在函数外部访问它们。因此得名本地。但好的一面是，我们可以在函数本身中访问这些变量。
***def **circle**(): pi = 3.142 **# I could have also used "math" library (math.pi)**
radius = 5 **# Interger value for radius**
area_of_circle = pi * (radius) ** 2
print("The area of the circle is: ", area_of_circle)
circumference_of_circle = 2 * pi * radius**# Accessing the global variables inside the function
circle**()***
上述代码的输出是:
***The area of the circle is: ** 78.55*****
这就是局部变量的特点。如上例所示，我使用了两个普通变量**pi**和**radius** 来计算一个函数中声明的圆的面积。所以访问这些变量不会产生任何问题。但是如果我们试图在函数之外访问它们，会发生什么呢？请参见下面的下一节。
详细了解“名称错误”
让我们使用上面的同一个例子，并访问函数中声明的变量:
***def **circle**(): pi = 3.142 **# I could have also used "math" library (math.pi)**
radius = 5 **# Interger value for radius**
area_of_circle = pi * (radius) ** 2
print("The area of the circle is: ", area_of_circle)
circumference_of_circle = 2 * pi * radius**# Accessing the global variables outside the function** print("The circumference of the circle: ", circumference_of_circle)
**# Accessing the global variables inside the function
circle**()***
当你执行上面的代码时，会出现一个**NameError** 的提示。更有可能的错误是这样的
*****NameError**: name 'pi' is not defined***
这个错误的原因是因为我们试图在全局范围内访问局部变量**pi** 和**radius** ，而局部变量只在**circle**()或局部范围内起作用。有一个办法可以解决，把**pi** 和**radius** 声明为全局或者在函数外声明。任何函数都可以访问它们。
非局部变量
相同的旧定义
在 Python 或任何其他编程语言中，我们经常在嵌套函数中使用非局部变量。现在，我所说的嵌套函数是什么意思？
嵌套函数
通常，嵌套函数是在另一个函数内部声明的一组函数。下面是一个嵌套函数的例子。
***def **circle**():
pi = 3.142 **# I could have also used "math" library (math.pi)**
radius = 5 **# Interger value for radius**
area_of_circle = pi * (radius) ** 2 def **circumference**():
**# Formula for circumference** circumference_of_circle = 2 * pi * radius
return circumference_of_circle print(**circumference**()) **# Calling the circumference function** return area_of_circleprint(**circle**()) **# Calling the circle function*****
在执行这段代码时，您将得到以下输出
*****31.419999999999998
78.55*****
创建一个非局部变量并访问它
现在让我们尝试在**circumference**()中更新半径 2(乘以 2)。我之所以特别坚持这么做，是因为一旦你写了**radius = radius * 2**并运行代码，你就会得到**UnboundLocalError** 的提示。看到这里，你会说**global radius**把它变成一个全局变量，但这次你会得到一个新的错误**NameError**。而现在你会莫名其妙，不知道该怎么办。有一个简单的方法可以解决这个“ 去读一个非局部变量的定义 ”。每当有嵌套函数时，你需要使用一个**nonlocal** 变量。就这样，问题解决了。下面是创建一个非局部变量并访问它的方法。
**def **circle**(): pi = 3.142 ** # I could have also used "math" library (math.pi)**
radius = 5 **# Interger value for radius**
area_of_circle = pi * (radius) ** 2 def **circumference**(): **nonlocal** radius **# Nonlocal variable**
radius = radius * 2 **# Formula for circumference** circumference_of_circle = 2 * pi * radius
return circumference_of_circle print(**circumference**()) **# Calling the circumference function** return area_of_circleprint(**circle**()) **# Calling the circle function****
执行这段代码时，您将得到如下输出
****62.839999999999996
78.55****
结论
这是文章的结尾，标题为“Python 中的全局、局部和非局部变量** ”。我希望你们通过阅读这篇文章学到了一些东西。通过这篇文章，您学习了如何消除两个重要的 Python 错误，如**NameError** 和**UnboundLocalError** ，这两个错误困扰了您很多年。现在，您可以面带微笑地轻松调试这两个错误，而不会流汗。如果您对本文有任何意见或建议，那么评论区就是您的了。敬请关注更多更新，直到那时再见。保持安全和快乐的编码，下次再见。**
Python 中全球变暖 Reddit 帖子的 NLP 探索
我们可以一起为社会意识做出贡献，拯救我们星球的未来和子孙后代。(图片由安德烈亚斯·韦思[ 执照 ]拍摄)
变更数据
全球变暖叙事与社会意识的情感分析
全球变暖正日益影响着我们星球的命运。科学证据表明，我们人类是这场灾难的主要原因之一；而且，需要采取严肃的行动来拯救后代。然而，与许多其他社会问题一样，这些行动的有效性在很大程度上取决于社会对忽视这一事实的不幸后果的认识。然而，评估社会意识需要对当前的叙事有深刻的理解。这是一项复杂的任务，因为社会意识既是对个人的输入又是对个人的输出，这种互动采取不同的形式，如电视、广播、在线视频、报纸和基于网络(目前是互动的主要部分)的媒体，如社交网络。Reddit 是一个受欢迎的在线平台，在这个平台上，许多这样的问题正在被个人讨论。正是通过理解社会意识，我们才能及时采取行动。
全球变暖是科学事实！
全球变暖不仅仅是一个阴谋论；但是，这是一个现实，一个科学事实。这已经被来自全球大气温度观测的时间数据的许多报告所证明。随着开发自然的工业能力的增加，温度上升在过去 40 年中加速了(图 1)。
图一。最近大气温度上升(来源:NASA 报告，2020 年)。(图片通过知识共享- 链接到许可 )
介绍
随着社交媒体成为我们日常对话和互动的主要手段，它们对当前的叙事状态有着重要的见解。全球许多人每天都在网上生成内容。仔细研究这些内容可能有助于我们更全面地了解当前辩论状态的根源，或者设计的政策，如气候法案，是否有效。
通过挖掘社交媒体内容，具体来说是 Reddit，我分析了这些辩论和当前的观点状态。虽然 Reddit 用户的人口代表性仍然是一个争论的问题，但它可能是一个很好的代理，也是一个很好的起点，来研究这个争论。
Reddit 是这些在线资源之一，人们通过帖子和评论来表达他们对特定主题的观点。自然语言处理(NLP)是一个强大的计算语言学工具，它可以帮助我们对社会叙事和意识有一个更全面的理解。具体来说，我们可以推断出这些主体在社会中的情感状态。然而，由于这些信息存在于非结构化的文本格式数据中，为了实现机器学习(ML)算法，首先我们需要将文本文档转换成结构化的格式，例如数据帧。
问题陈述
在【全球变暖】子网站的 reddit 用户普遍感到担忧，而在【阴谋理论】子网站的 Reddit 用户对提出阴谋论更感兴趣。这种对立的观点可能是我们 NLP 分析的一个很好的二元目标，以开发一个训练有素的模型，其中的叙事驱动全球变暖的关注。
建模工作流
在这篇博文中，我将带您浏览 subreddit 帖子的 NLP 分析；工作流程(见图 2)分为不同的连续步骤:1-数据收集，2-数据清理，3-文本矢量化和探索性数据分析(EDA)，4-建模，最后 5-基于模型结果的建议。这些帖子来自两个拥有超过 3000 名订阅者的热门博客帖子，即全球变暖和阴谋论。我保持步骤 1-3 的简短，并将更详细地解释第 4 和第 5 部分。对于那些对建模步骤的更多细节感兴趣的人，我邀请你访问我的个人 GitHub 档案中的完整存储库。在这个工作流中，我主要使用了 python 中的 Pandas、 scikit-learn 和 NLTK 库。
图二。NLP 建模工作流。(作者图片)
步骤 1-数据收集
我写了一个 python 函数，通过 pushshift Reddit API 获取 subreddits。下面是一段代码摘录(我再次邀请您访问我的个人 GitHub 库以获得完整的代码集):
函数来读取 Reddit APIs
然后，使用这个函数，我导入了 subreddit API。导入的帖子日期在 2020 年 7 月 1 日之前。然后，我将两个数据集合并为熊猫数据帧，并保存到 CSV 文件中。
步骤 2-数据清理
正如非结构化文本数据所预期的那样，数据清理是任何 NLP 项目的劳动密集型部分。在最初处理丢失的值、调整数据类型和删除不必要的列之后，我清理了文本。为了使这篇博文简单易读，我在这里只列举了与应用顺序相关的清理过程:删除所有非字母字符、字符串(通过正则表达式)操作、删除停用词、词干，最后将标记化的文本元素缝合回数据帧，并将其保存为一个干净的 CSV 文件(图 1)。这里，我只包含了我用来清理 DataFrame 的“text_merged”列的一段代码。
清除文本的功能
步骤 3- EDA 和特征工程
对于这种分析，可以定义两类特征，即数字和文本特征。
数字特征与目标的相关系数相对较低(图 3)，表明需要更深入地了解目标预测数据，即文本特征。最初，我设计了一些通用功能。第一个工程特征是 【字数】 【在该特征的另一个变体中，也可以定义字符数】。然后我使用“nltk.vader”工具包，根据预先训练好的模型获得 【情绪得分】 。
图 3:两组帖子得分和评论数量之间的关系。(图片作者)
此外，在 EDA 过程中，我发现了 Reddit 分数和评论数量之间的关系(图 3)。对于评论数量相同的阴谋论标签，得分差异很大，这意味着他们的思维不统一或不团结，但阴谋论 Reddits 之间存在叙事异质性。另一方面，全球变暖在这个意义上似乎更一致，也显示出更多的评论，这意味着更倾向于讨论。因此，我设计了一个交互功能，作为评论和分数的乘积，并将其命名为“反应”，因为它是评论和分数的总数，这两者都是读者对作者的反应:
[Reaction] = [Post score] * [Number of comments]
图 4。目标标签和数字特征之间的相关系数。(图片作者)
对数字特征的检查(图 4)表明，分数、情感分数、评论数量是最相关的特征，反应特征也相对较好。因此，正如我们将在模型部分描述的那样，工程特征在预测目标中是重要的。而与文档长度相关的特征如字数(见图 4)相对不相关，这意味着与目标类别无关。想想 Reddit 帖子的问题，这是有道理的，这意味着两个群体都写了长帖子和短帖子。
文本特征需要预处理，例如在探索和特征工程之前的文本矢量化转换。在这里，我使用 cvec 和 tf-idf(从计算的角度来看是首选)来转换文本(使用大小为 1 和 2 的 n 元文法)。除了“英语”单词之外，它还有助于发现和过滤不太有意义的单词，作为一个新的停用词列表。
以下是两个用户使用最多的词:
['year', 'world', 'peopl', 'like', 'make', 'use', 'think', 'could', 'time']
这表明两个用户都倾向于号召人们去思考！这是一个指向特定时间的世界性问题。通过进一步的建模，我们将看到哪些单词实际上指向了最相关的目标。
此外，我添加了一个新的工程功能，并命名为“单词使用侵略性(WUA)”。这个特征仅仅是两个子编辑使用最多的排名最高的 100 个文本标记(单词)之间的欧几里德距离。
图 5。工程用词攻击(WUA)特征。(图片作者)
它只是每个排名靠前的单词之间的标准化单词距离，在单个:
[WUA] = sum(|Distance between top-word indices|)
较高的 WUA 值意味着排名靠前的单词在整篇文章中被分散使用。
图 6。数字特征和目标标签之间的相关性。(图片作者)
当然，这个新特性可以被重新分解成更有趣的格式，比如非结构化的图形，以包含句子间的关系。基于该图，WUA 具有朝向目标值的高权重因子或系数因子。这显示了将 WUA 添加到模型精度的效率。
第 4 步-建模
基于文本特征的模型评估；
由于目标是基于目标列对 Reddit 帖子进行分类[0 表示阴谋论，1 表示全球变暖]，因此这个问题变成了二元类分类问题。对于最初的建模尝试，我只选择了文本列作为 X 变量。全球变暖的目标值(Y 变量)是 1 (0)(阴谋论)。导入数据集的缺点之一是阴谋论 subreddit 的帖子较少。为了使类更加平衡，我引导了属于阴谋论目标的行。基于这个平衡的数据集，基线模型精度为 0.5[目标和非目标类的平均分布]。这意味着一个模型允许的最差精度是 50%！然后，我将变量(X)和目标(y)数据分成测试规模为 25%的训练/测试集:
训练/测试分割
在建模步骤中，我尝试了几种分类模型，包括逻辑回归、随机森林、梯度推进、高斯朴素贝叶斯、k-最近邻、支持向量机和神经网络。对于每个模型，我创建了一个管道和网格，在超参数中搜索测试集上的最佳模型分数。最好的结果来自神经网络。例如，在下面的代码中，我展示了一个模型的管道和网格搜索设计:
ML 流水线和网格搜索设计
对单词进行词干处理，并使用 tf-idf 矢量器而不是 CountVectorizer 在一定程度上提高了准确度(最多 3%)。在几个被测试的分类模型中，它们在测试集上具有高于 96%的精度值和高于 92%的召回值。此外，这些模型似乎稍微超出了测试集(作者的<2% difference). From the text vectorizers, tf-idf seemed to be faster and resulted in better scores.
Figure 7. Confusion matrix result from the designed Random Forest classifier ML model. (图片)
基于文本数字特征的模型评估；
为了进一步讨论和分析文本文档中的发现，我进行了逻辑回归，因为它提供了更多的特征重要性的数字意义，并且我可以更好地看到工程特征对当前变量的贡献。基于该模型，以下特征在确定目标标签时是重要的，根据其重要性列出:得分、字数、情感得分、反应和 WUA。WUA 正相关的事实表明，关注度更高的帖子倾向于使用彼此更分散的热门词汇。
此外，我还使用模型的系数矩阵来描述对选择目标标签(包括负面和正面)最有影响的词的一些时间序列特征。
图 8。逻辑回归系数的系数重要性。只有一个数字特征出现，指出了 NLP 在目标预测中的重要性。(图片作者)
请注意，这些是词干，而不是实际的单词。昌、碳、科学家、冰和停止是预测全球变暖目标的最相关特征(词)。此外，为了观察对某些单词的兴趣趋势，我估计了每个帖子数的标准化单词的累积使用量，如图 9 所示。可以看出，自 2019 年以来，似乎有越来越多的关注趋势，然而，阴谋趋势也有所增加，这令人担忧。
图 9。用词推断社会叙事趋势的近期趋势。(图片作者)
过滤全球变暖话题
气候变化是一个首要问题，远远超出了对温度上升的关注，包括臭氧层状况、污染等问题。
[Global warming] ⊆ [Climate change]
我们使用我们训练的全球变暖模型从气候变化子编辑中筛选出与全球变暖特别相关的主题。因此，输入变量是文本文档，目标变量是从训练好的模型中预测的。该模型预测 20%的气候变化帖子是全球变暖的目标。作为一个例子，下面我展示了两个帖子；一个被确定为全球变暖目标，一个被确定为气候变化的非全球变暖问题:
针对全球变暖:“威德尔海海冰五年减少一百万平方公里”
目标为非全球变暖:‘嗨。我想知道我们可以从新冠肺炎疫情吸取什么教训，并应用到我们的气候行动中。特别是企业和政府。先谢谢了。
推荐
基于本项目中提出的工作流程，我们观察了 NLP 和数字特征如何帮助我们分类和识别全球变暖目标帖子，以推断当前的社会叙事。我们模型的几个含义是:
1-在确定一个帖子是否与全球变暖有关时，我们找到了最相关/最不相关的词。“变化”和“碳”被发现是最相关的词。
2-基于工程特征，全球变暖帖子收到更多反应(反应特征)。此外，全球变暖帖子倾向于使用更分散的流行词汇( WUA 专题)。
3-通过时间序列对最具影响力的词的分析，我们发现，自 2019 年以来，关注和阴谋似乎都有增加的趋势。
4-我们能够从更一般的气候变化子编辑中过滤全球变暖主题。
感谢你阅读我的博文。对更多阅读感兴趣？请查看我的 LinkedIn 和 GitHub 简介。
PS。这篇博文是在这个 NLP 工作流的最初开发过程中准备的。未来的尝试将包括改进的方法和指标。
手套研究论文明确解释
http://cf.ydcdn.net/latest/images/wordfinder-background.jpg
直觉理解和数学推导在手套中的应用。
对于数据科学家来说，阅读和理解研究论文是非常重要的，这些研究论文构成了当前 art 模型的基础，无论是在自然语言处理还是在帮助我们解决许多任务的计算机视觉中。它帮助我们思考和理解研究中的内容，这些研究为我们提供了在数据科学之旅中使用的模型和算法。通常研究论文看起来像是数学密集型的脚本，所以我们倾向于完全忽略它们。在我的系列文章中，我将尽可能简要地解释和总结研究论文和其中的数学知识。
这篇文章是关于斯坦福大学的克里斯托弗·d·曼宁、杰弗里·潘宁顿和理查德·索彻撰写的手套研究论文。我鼓励你在这里观看斯坦福大学的 NLP 课程【https://www.youtube.com/playlist? list = ploromvodv 4 rohcuxmzknm 7j 3 fvwbby 42 z
摘要
- 最近的方法已经成功地使用向量来表示单词的语义和句法含义。但是如何捕捉这些含义仍然是一个黑盒子。
- 这项研究的主要目标是找出一个具有必要参数的模型来表示这些意义。
- 这给出了使用全局对数双线性回归模型的范围，该模型结合了两种建模方法的优点，即 全局矩阵分解 和 局部上下文窗口。
- Glove 通过仅对单词-单词全局共现矩阵中的非零元素进行训练，而不是对整个稀疏矩阵或较大语料库中的上下文窗口进行训练，来输出具有有意义的子结构的向量空间。
- 它在单词类比任务中给出了 75%的性能，并且在 NER 和相似性任务中也优于前者。
介绍
- 经典语义模型将句子或语料库中的单词表示为实值向量。这些可以用作任务中的特征，如问题回答系统、信息检索、文档分类、命名实体识别和解析。
- 在早期，这些向量表示的质量是通过为一些已知单词生成的向量之间的距离或角度来评估的。
- 最近，这些矢量表示不仅通过标量之间的距离来评估，还通过每个维度的差异来评估。这为形成类似“国王之于女王，就像男人之于女人”的类比创造了空间。这迫使模型将意义纳入向量的维度。
- 2 研究中使用的主要建模方法有:
- 全局矩阵分解，如潜在语义分析(LSA)。
- 局部上下文窗口模型，如跳格图。
这两种方法都有一些缺点。
- LSA 有效地捕捉统计信息，但它产生的矢量表示很差，在单词类比任务中表现不佳。
- Skip gram 生成更好的向量表示，并且在单词类比任务中表现更好，但是它不会完全利用语料库中存在的统计信息，因为它们在单独的局部窗口而不是全局共现计数上训练。
- Glove 使用全局对数双线性回归模型来生成有意义的向量表示，这些向量表示在单词类比任务中表现得更好。
- Glove 使用加权最小二乘法来训练全局共现计数，并利用语料库中存在的统计信息。
全局矩阵分解方法
- 这些方法使用矩阵分解方法，通过分解大矩阵来获得低秩近似。这些近似捕捉了语料库中存在的统计信息。
- 根据等级和用于形成更大矩阵的方法，捕获的这种类型的信息会有所不同。
- 例如，LSA 使用 word-document 矩阵，其中行代表单词，列代表文档。根据该单词是否出现在文档中，添加 1 或 0。
- 在另一个例子中，超空间语言模拟(HAL)使用单词-单词矩阵，其中的值表示该单词是否存在于另一个单词的上下文中(即存在)。这是失败的，因为它生成了一个不成比例的矩阵，对频繁出现的单词赋予了更大的权重。提出了各种变换来将不成比例的矩阵转换成平衡的矩阵。
基于局部上下文窗口的方法:
- 这些方法通过聚焦于局部的特定上下文窗口来学习单词表示。
- Skip-gram 和 CBOW 基于局部窗口中存在的两个单词的向量之间的内积。
- 在 Skip-gram 中，目标是在给定单词本身(中心单词)的情况下预测单词上下文(周围的单词)。
- 在 CBOW 中，目标是在给定上下文单词(周围单词)的情况下预测单词(中心单词)。
- 基于窗口的方法的主要缺点是它们是局部的，并且它们不查看全局共现，因此它们不能使用语料库中存在的统计信息。因此，他们没有利用语料库中单词的重复。
手套法
无监督算法利用语料库中单词出现的统计信息。这里的问题是“我们如何从这些统计数据中产生意义，以及产生的单词向量如何表示该意义”
让我们考虑一个在研究中使用的例子。
- 与原始概率相比，该比率能够更好地区分相关的词(固体和气体)和不相关的词(水和时尚),并且还能够更好地区分两个相关的词。
- 这个实验证明了同现概率的比率比个体概率做得更好，并且它们是学习更好的单词向量表示的良好起点。
损失函数的推导:
- 上面的例子可以概括为下面给出的函数。
- 这里的 w 代表语境上的词语 w 条代表语境外的词语。
- 在上面的等式中，可以从语料库中计算 RHS。
- f 可以是任何带有未知参数的函数。我们可以向该函数添加一些约束，以便可以学习参数来对单词向量空间中的概率比中存在的信息进行编码。因为目标是找出多维线性向量空间中表示单词的向量。
- 考虑到上面的说法， w i，wj可以用两个词的向量差来表示。所以通过替换我们得到:
- 在等式 2 中，RHS 是标量，LHS 是矢量的组合。为了匹配这两者，我们需要考虑作为向量的参数之间的点积。这里理想的 F 是一个由神经网络创建的复函数。
- 这里我们需要记住，X 是单词-单词共现矩阵，这意味着单词和上下文单词可以互换，短语“在上下文中”和“在上下文外”只是一种表示。即，基于所使用的上下文，单词可以在上下文中或者在上下文之外。
- 考虑到以上几点，我们必须有一个函数 F，它能使我们互换w<=>wbar 和X<=>X转置 而不失去对称性。
- 为了即使在这种交换之后也能达到对称，我们的函数 F 应该遵循一个群同态。https://en.wikipedia.org/wiki/Group_homomorphism。简单地说，同态函数是保持两个群之间代数结构的函数。
- 使用的缺点是，它对所有单词-单词共现给予相等的权重，这导致噪声，因为一些共现具有较少的信息，应该给予较少的权重。
- 提出了一种克服这一缺点的新方法。即使用加权最小二乘回归模型。
- 这里 f 是一个加权函数，用于减少频繁共现项的影响，这是上面讨论的缺点。函数 f 是用 3 个性质构造的。
- 它应该是一个连续函数，当 x → 0 时消失。
- 它应该是非递减的。
- 对于 x 的大值应该输出相对较小的值。
- 这些规则确保在训练单词嵌入时，罕见或频繁的同现值不会被过度加权。
- 有许多函数满足这些约束，Glove 选择了一个限幅幂律来构成函数。
- Xmax**经过不同值的实验，固定为 100，alpha 固定为 3/4。
- 给出了手套和 Skip Gram 模型之间的比较，这将在 Skip Gram 研究论文的下一篇文章中解释。
模型复杂性
- 从损失函数 J 中使用的加权函数可以观察到，计算复杂度取决于矩阵 X 中非零元素的个数。
- 最坏情况的复杂度由 O(|V| ) 给出，其中 V 是词汇量。
模特培训
该模型用 5 个语料库进行训练。
- 2010 年拥有 10 亿代币的维基转储。
- 拥有 16 亿令牌的 2014 年维基转储。
- 拥有 43 亿代币的 Gigaword 5。
- 2014 年 Gigaword 5 和 Wiki dump 的组合拥有 60 亿个令牌。
- 共有 420 亿个令牌用于抓取 web 数据。
对每个语料库执行以下步骤。
- 使用斯坦福分词器对每个语料库进行分词和小写，构建 400，000 个最常用单词的词汇表。
- 构建一个同现计数 x 的矩阵。
- 选择一个上下文窗口，我们还可以在左右上下文之间进行选择。
- 使用递减加权函数来确保非常远的单词对预期包含关于单词彼此关系的不太相关的信息。
使用以下参数。
- X 最大值 = 100 且α= 0.75
- 使用 AdaGrad 对来自 x 的非零元素的随机样本训练模型。
- 最初，学习率为 0.05。
该模型根据单词是在上下文中使用还是在上下文外使用，为每个单词生成 2 组向量 w 和wbar。一般使用w+w**bar给出一些性能提升。**
模型分析
- 向量长度和上下文大小
- 下图有助于我们理解向量维数和上下文大小对模型性能的影响。
- 对称上下文:扩展到目标单词左右的上下文窗口。
- 不对称上下文:只向左延伸的上下文窗口。
- 向量大于 200 维时，性能会下降。
- 小的和不对称的上下文窗口在句法任务上表现出更好的性能，因为句法信息主要是从邻近的局部上下文中提取的，并且它也依赖于顺序。
- 较大的窗口尺寸在语义任务上表现出较好的性能，因为语义信息更加非局部化。
- 语料库规模
- 语料库规模越大的模型在句法子任务上表现越好。这是因为更大的语料库中统计信息的增加。
- 对于语义子任务，该模型在较小的语料库中表现出更好的性能，该语料库可能包含更接近的有意义的词类比。
- 模型在不同语料库的 300 维向量上进行训练。
结论
我试图在这篇文章中涵盖所有的细节。我鼓励您阅读本文，以获得各种任务的所有详细模型性能结果以及其他模型之间的比较。
注意:这篇文章的目的是解释研究论文中给出的术语和数学。所以流程和上下文与论文中使用的非常相似。
资源:
在《手套:单词表示的全局向量》一书中，有一部分(第三页的底部)我不…
datascience.stackexchange.com](https://datascience.stackexchange.com/questions/27042/glove-vector-representation-homomorphism-question) [## 群同态
其中等式左边的群运算是 G 的运算，右边的是 h 的运算。
en.wikipedia.org](https://en.wikipedia.org/wiki/Group_homomorphism)
感谢你花时间阅读这篇文章。希望对你有帮助。如果你有任何疑问，请随时联系我。**
使用 Python 和 scikit 进行线性回归-学习库
机器学习
广义线性回归导论
一般来说，机器学习、统计学和应用数学中最常用的工具之一是回归工具。我说的是回归，但是有许多回归模型，这里我将尝试介绍的是众所周知的广义线性回归。这个复杂词背后的思想非常简单:我们试图拟合的观察值应该是输入解释变量的线性组合。在数学上，观测向量被公式化
其中 x ₖ代表解释向量 k ，而 w ₖ是每个解释变量的权重。此外，由于我们通常需要一个截距，按照惯例，我们设置 x ₀ =1 ，因此权重 w ₀代表截距。
线性回归
作为第一个例子，让我们从一个简单的线性回归开始，它包括最小化误差平方和。误差被定义为预期真实值和通过我们的模型获得的预测值之间的差异
线性模型的成本函数
对于所有 m 点 (xᵢ，yᵢ)
为了说明这个简单的例子，让我们使用令人敬畏的库 scikit-learn，特别是包sklearn.linear_model
简单线性回归
我们在这里使用的模型非常简单，它只是一条线。该模型似乎很好，拟合系数为 w₀ =-0.87998 和 w₁=4.54914 ，但误差不为零(示例中均方差= 15.57)。有时，减少残差的一种方法是用稍微复杂一点的模型来改变模型。在我们的例子中，我们简单地拟合了一个 1 次多项式。如果我们增加多项式次数呢？例如，假设我们将度数增加到 12:
多项式次数的影响
正如我们所见，模型的多项式次数越多，残差就越小。然而，在这个例子中尤其明显的是，误差的减小不一定是更好模型的标志。事实上，假设我们使用一个高次多项式作为我们的模型，误差往往是零(实际上这是因为我们有一个多项式次数等于观察次数)。但是，如果我们增加一个额外的观察，我们的模型肯定会经历一个高残差。
结果是
对于 X=15 的残差为【57.50465854】
对于 X=15 的残差为【540.59208041】
对于 X=15 的残差为【23711.11027247】
正如我们在本例中看到的，在 x = 15 处添加一个观测值会导致多项式次数的误差增加。这种行为被称为过度拟合，即模型非常适合数据，但往往对新数据表现不佳。我们说它遭受巨大的变化。
为了克服这个问题，我们需要选择正确的多项式次数。例如，我们可以将数据集分成两部分，一个训练集和一个测试集。然后，最佳模型将是在测试集上具有最小残差的模型。然而，有一个聪明的方法来限制过度拟合现象:正则化。
正规化
正则化包括向模型添加惩罚，目标是防止过度拟合。它来源于这样的假设，当多项式的次数增加时(举我们的第一个例子)，每个多项式的权重也增加。因此，为了克服过度拟合，我们惩罚高权重的单体。最小化函数现在变成了
正则化成本函数
其中|。|通常是 L1 或 L2 范数，而λ是一个超参数，它可以被调整以调节惩罚敏感性(0 表示没有惩罚，即未规范化的模型)。两种广泛使用的正则化方法是 L1 和 L2 正则化，也称为套索和岭回归。
套索
引用 scikit-learn 库的内容
LASSO 在某些情况下很有用，因为它倾向于使用较少参数值的解决方案，有效地减少了给定解决方案所依赖的变量的数量。因此，套索及其变体是压缩传感领域的基础。在某些条件下，它可以恢复非零权重的精确集合。
套索正则化的影响
我们清楚地看到正规化的效果。当我们增加惩罚时，我们强烈限制每个系数的权重，直到只保留截距。但是如何选择合适的参数呢？在这里，我们再次需要查看在不是训练集的集合上计算的残差。这种方法被称为验证。原则是将数据集分成三部分，比如 80%用于训练集，10%用于验证，10%用于测试。在训练集上训练模型，然后使用验证集来选择超参数。最后，使用测试集来估计模型的真实误差。然而，在小数据集上，这种方法不够有效，因为它限制了可用于训练的数据量。对于这样的小数据集，我们可以应用交叉验证的方法。为此，我们将数据集分成两部分，一部分用于训练，另一部分用于测试。然后，对除了一些 k 样本之外的所有训练集执行训练。所以我们假设训练集由 N 个样本组成。我们对 N-k 个样本执行 N/k 次回归，并计算 k 个剩余样本的验证误差。在所有这些回归之后，验证误差是所有验证误差的平均误差。
在 scikit-learn 库中，有一个类实现了这种方法并找到了最佳的超参数:LassoCV。然后，我们重用前面省略了alpha参数的代码示例，以强制使用LassoCV模型:
套索正则化的最优解
根据拉索夫模型，最佳超参数 alpha=4.16e⁻⁴.
里脊回归
岭回归与 LASSO 非常相似，不同之处仅在于正则项中使用的范数的阶数。在 LASSO 中，我们使用一阶范数(L1)，在岭回归中，我们使用二阶范数(L2)。这种正则化技术的行为是模型的所有结果权重仍然是非空的，但是最终具有非常小的值，使得它们对预测值的影响非常低。相反，LASSO 通过最终将权重设置为空来增加模型的稀疏性，这使得模型解释更容易。岭回归的主要优点是它与乘法因子无关，倾向于高度相关变量的权重相等，而 LASSO 会选择这个或那个。
我们示例的实现与前面的 LASSO 案例非常相似。我们要做的就是把Lasso和LassoCV换成Ridge和RidgeCV！
山脊正则化的影响
通过交叉验证:
岭正则化最优解
正如我们所见，最终的模型与套索正则化略有不同。如果我们现在看看权重系数:
两种正则化的回归系数比较
结论
在本文中，我们看到了两种正则化技术，以及在尝试拟合模型时使用正则化的重要性。我们还看到，尽管这两种技术非常相似，但却给出了非常不同的结果。事实上，脊技术包括了所有的解释变量，而套索技术产生了一个稀疏的模型，通常更容易理解。然而，LASSO 在高度相关变量的情况下表现不太好，因为它倾向于在结果中产生高度稀疏。这正是我们在示例中尝试用多项式拟合余弦时看到的情况。每个变量都是高度相关的，因此得到的模型有许多零值作为权重系数。除了脊和套索，弹性网格是另一种结合了 L1 和 L2 正则化的有用技术。它允许学习一个稀疏模型，同时它也保持山脊性质。
结束注释
我们简要地讨论了这个主题，但是和机器学习一样，我们需要几个数据集来训练模型、验证模型和测试模型。我们稍微讨论了一下，很快就看到了如何用交叉验证来处理小数据集。
通过启用 spark UI 对 AWS 粘合作业进行高级监控
启用 spark 历史服务器的 Docker 容器，可用于查看粘合作业的 sparkUI
在 Unsplash 上由 Carlos Muza 拍摄的照片
Apache spark 目前是处理大型数据集时不可或缺的框架。大多数处理大量数据的数据工程师和数据科学家在某些时候会利用 spark 功能。
说到对 spark 的理解，20%由代码语法组成，30%是数据工程概念，剩下的 50%是优化
代码语法包括使用函数和语法，数据工程概念反映了 SQL、高效查询构建和创建优化查询和优化的知识包括集群管理的好坏和以最小无序度运行代码、处理不可避免的小文件、优化连接、处理长时间运行的作业、优化倾斜数据集以及利用完整集群。
语法定义和数据工程概念可以随着时间的推移而学习，但是为了优化集群，您需要可视化您的集群如何响应在其上执行的查询。
SparkUI 用于识别长时间运行作业背后的根本原因，可视化 Dag、 OOM 问题、磁盘溢出、过度洗牌、倾斜数据集、以及集群的整体运行状况。
要使用 apache spark，我们需要大型集群，但有时，管理这些集群会带来额外的开销。因此，我们开始使用 AWS EMR 或 GCP Dataproc 在云上利用集群，但同样我们需要管理这些集群并充分利用它们。现在，我们需要能够运行 spark 工作负载的东西，并且只为我们使用的东西付费。这就是 AWS 胶水出现的原因。
Aws Glue 是无服务器的，因此我们不需要管理集群或担心与之相关的运行成本。我们只为使用资源的时间付费，一旦我们的工作完成，资源就会被释放。
每一件好事都是有代价的，所以这里的问题是我们不能在优化方面完全配置我们的胶合工作。此外，我们不能实时查看作业的 spark UI，相反，我们需要运行 spark 历史服务器来查看胶合作业的 Spark UI。
要启用 spark UI，我们需要遵循一些步骤:
- 在粘合作业中启用 spark UI 选项。
- 指定将生成日志的 s3 路径。
- 使用 docker 和 EC2 启动 Spark 历史服务器。
- 访问历史服务器上的 spark UI。
为日志生成启用 spark UI
创建一个新作业，并在 monitoring 部分启用 spark UI 选项，并为日志生成提供一个 s3 路径。
为粘合作业启用 spark UI
EC2 上的 Spark 历史服务器设置
我们现在将创建一个 Spark 历史服务器，从中我们可以看到粘合作业的 DAG 和任务详细信息。
相同的文档是:
Dockerfile 文件
我把阿尔卑斯山作为基本图像，因为我希望这个 docker 容器在尺寸上非常精简。
安装 Java 8、Maven 和 bash shell
RUN apk add --no-cache openjdk8
RUN apk add --no-cache maven
RUN apk add --no-cache bash
获取 spark 2.4 并解压缩，因为它包含了启用历史服务器的类
RUN wget [https://archive.apache.org/dist/spark/spark-2.4.3/spark-2.4.3-bin-without-hadoop.tgz](https://archive.apache.org/dist/spark/spark-2.4.3/spark-2.4.3-bin-without-hadoop.tgz)
RUN mv spark-2.4.3-bin-without-hadoop.tgz spark
RUN tar -zxf spark
RUN rm -rf spark
RUN mv spark-2.4.3-bin-without-hadoop/ spark/
将 pom.xml 复制到用于安装依赖项的容器中，并使用 maven 构建它
COPY pom.xml .
RUN mvn dependency:copy-dependencies -DoutputDirectory = /sparkui/spark/jars/
移除 maven 作为构建现在是成功的，并且也移除了冲突的 jar
RUN apk del maven
RUN rm /sparkui/spark/jars/servlet-api-2.5.jar && \
rm /sparkui/spark/jars/jsr305-1.3.9.jar && \
rm /sparkui/spark/jars/jersey-*-1.9.jar
添加端口号来启用历史服务器，您可以根据您的要求更改它。我们需要将属性添加到 spark-defaults.conf 文件中。
您也可以在这里更改端口号。
RUN echo $’\n\
spark.eventLog.enabled true\n\
spark.history.ui.port 18080\n\
’ > /sparkui/spark/conf/spark-defaults.conf
将入口点添加到 docker 容器，该入口点将启用 spark 历史服务器。
ENTRYPOINT [“/sparkui/spark/bin/spark-class”, “org.apache.spark.deploy.history.HistoryServer”]
现在从这个文件构建并运行 docker 容器。
从 Dockerfile 构建 docker 映像:
要从该 Dockerfile 文件构建映像，请运行以下命令:
docker build -t jnshubham/glue_sparkui .
从 DockerHub 中提取现有图像
您还可以从 docker hub 上获取预构建映像。
要提取图像，请运行以下命令:
docker pull jnshubham/glue_sparkui:latest
通过运行以下命令检查下载的图像
docker images
运行 Docker 容器
要运行容器并启动历史服务器，请运行以下命令:
使用访问密钥和秘密密钥运行容器
$ LOG_DIR="s3a://path_to_eventlog/"
$ AWS_ACCESS_KEY_ID="AKIAxxxxxxxxxxxx"
$ AWS_SECRET_ACCESS_KEY="yyyyyyyyyyyyyyy"
$ docker run -itd -e SPARK_HISTORY_OPTS="$SPARK_HISTORY_OPTS -Dspark.history.fs.logDirectory=$LOG_DIR -Dspark.hadoop.fs.s3a.access.key=$AWS_ACCESS_KEY_ID -Dspark.hadoop.fs.s3a.secret.key=$AWS_SECRET_ACCESS_KEY" -p 18080:18080 jnshubham/glue_sparkui
运行配置了 IAM 角色的容器来访问 s3 bucket
$ export LOG_DIR=s3a://bucket_name/logs_path/
$ docker run -itd -e SPARK_HISTORY_OPTS="$SPARK_HISTORY_OPTS -Dspark.history.fs.logDirectory=$LOG_DIR" -p 18080:18080 jnshubham/glue_sparkui
从 EC2 访问历史服务器
要访问历史服务器，请启用安全组入站规则中的端口 18080 以允许流量。
启用端口 18080 的流量
一旦你有一些成功的日志，打开 ip:18080 打开历史服务器，它将显示粘合工作的 spark 用户界面:
现在，您可以可视化生成的 Dag 和查询性能。您还可以跟踪每项任务所花费的时间，然后对其进行优化。
希望你们都喜欢这篇文章。
更多信息，请访问我的 GitHub 或 dockerhub 。
以小见大
外推小时间序列数据集的方法。
作者图片
当我还是一名大学生的最后一年时，我正在为我的研究论文准备和收集足够的数据集，作为我的最后一年项目。我只是随便浏览了一下互联网，瞧！我很快就收集到了我需要的所有数据集。但当我以为我的船一切顺利时，一个北海巨妖出现了——当然不是海怪，但它需要大量的头脑风暴。我一直在收集的数据集太小，无法处理，我说的是 20 到 30 次定期观察，哎呀。你可能会问，你为什么没有意识到仅仅通过观察数量是不够的？好吧，坦率地说，当我看到“少数”数量的观察时，我确实感到有点担心。但是当我意识到这不足以在我研究的模型中实现时，我受到了打击。
经过几个小时，一本书，一杯咖啡，我终于找到了如何处理这些小数据集的灵感，推断，恰当地。起初，我真的认为我的想法会在模型中引起相当大的错误，但谢天谢地，进展顺利，我完成了我的论文。所以在这篇文章中，我想分享我在处理单变量数据集时使用的方法，以及我为多变量数据集开发的一种新方法。
让我们从简单的单变量数据集开始，该数据集具有误差容限(MOE)
提供了 MOE 的数据集在这种外推方法中非常有用，因为 MOE 是决定外推值精确度的关键因素之一。在这种情况下，我将使用从美国人口普查局的表 S1901 中收集的美国年平均收入。有了 MOE，我们可以很容易地得到每年平均收入的最小值和最大值。知道这些值后，我们根据其年度值，通过从均匀(0，1)分布中产生随机变量来外推，以代表平均收入的标准化值。然后，我们使用最小值和最大值将标准化值转换回实际值，如下所示
作者图片
假设我想外推数据集，因为我想重新创建月平均收入，我将需要每年转换 12 个随机均匀变量。这是真实数据集和外推数据集的并排图比较。
外推的(左)，真实的(右)，作者的图像
正如我们所看到的，增长的趋势仍然存在，只是更嘈杂，因为现在它有每月而不是每年的价值。如果我们检查统计特性之间的差异
统计属性的百分比差异，按作者分类的图像
差别不大:)
无 MOE 的单变量数据集
这个条件就是我之前提到的问题。我对如何获得我正在处理的数据的周期性变化的信息感到困惑。幸运的是，该解决方案只需要两个主要特征:一个符合数据集分布的时间序列模型和一些随机化的标准化值。
在这个例子中，我将使用每月太阳黑子数据集，您可以在这里 获得 。是的，这已经是一个巨大的数据集，所以不需要外推，我说的对吗？但是，假设你只得到过去 3 年的观察数据，并被告知基于这些数据生成过去 3 年的每日值。
1981-1984 年的每月太阳黑子，图片由作者提供
现在让我们挑选模型。从一开始，我们就知道这是一个月度数据集。所以我们为什么不选些简单的呢？我们将使用线性季节性回归模型来拟合数据集。结果如下:
作者图片
那非常合适。现在我们将使用这个结果的估计值和标准误差来推断数据。换句话说，如果我们回头看前面的例子，我们可以使用估计值和标准误差分别作为“平均收入”和 MOE。因为我们要生成每日值，所以这些值将根据一个月中的天数以及估计值和标准误差生成—从现在开始，我使用 95%的置信度。以下是推断的每日价值:
作者图片
有一点马上让人感觉不对劲，那就是原始数据集中缺少下降趋势。我这样做是为了展示根据我们正在处理的数据集选择一个合适的模型是多么重要。根据这一结果，我们可以得出结论，线性季节回归模型并不完全适合这一数据集。此外，通过使用回归，我们立即假设数据集中的状态是稳定的，这使得外推值看起来像是稳定的时间序列。
多元数据集
直到最后一个例子，我花了很长时间才想到一种方法来推断一个多元数据集。然而，这里有一种方法。在最后这个例子中，我使用的是来自 Kaggle 的新德里气候训练数据集。
同样，让我们先研究一下数据集。因为我期待变量之间的相关性，所以我将从变量之间的散点图开始。
作者图片
现在，我的眼睛立即转向压力部分，尽管温度和湿度之间存在明显的负相关性。图中有些东西感觉不对劲，我马上意识到这一定是一些异常值，知道一些值与其他值相差很大。我知道我不是这方面气候知识的专家，所以我打电话给我们最好的朋友和万事通，谷歌，帮我找出气压的正常值，它把我送到这里。结果，数值应该在 1013.25 毫巴左右。因此，根据数据集和网站，介于 990 和 1024 之间的压力值将被视为正常。然后，将根据数据集的分布替换异常值。
你可能想知道，这个例子一定有一个转折，因为已经有很多观察了。你猜对了！(真的很抱歉我的老土笑话试图让你的注意力回来 lol)
这里的难点在于，你实际上已经得到了每个变量的月平均值，你需要将它转换回日值。现在，根据我之前给出的最后两个例子，请回答这个问题
有用吗？这样做可能吗？
把你的答案留到本文结尾，我们来看看。
首先，正如我们之前所做的，让我们看看变量之间的散点图。
作者图片
看起来我们的数据集是相互关联的。以下是我从这个情节中看到的:
- 最明确的关系是温度和压强之间的关系，这是负相关。
- 其余的可能有相当适度的相关性，看起来可能符合二次模型。
考虑到这些，我决定为每一对可能的变量创建一个线性和二次回归模型，然后比较它们的 R 平方值和调整后的 R 平方值。此外，我将为每个变量创建一个线性季节回归模型，因为根据下面的图，它肯定有一个季节模式。
作者图片
在进行回归之前，最好对值进行标准化，因为值的变化是不相似的。这是模型拟合的结果:
作者图片
让我们关注变量之间的关系。排除季节性回归结果(第 1-4 行)，最高的 R 平方值是二次模型，其中压力为自变量，温度为因变量。而另一个模型似乎不太适合，尽管散点图显示了相关性。幸运的是，季节模型非常适合所有变量。考虑到这些，我的计划是这样的:
作者图片
现在，你一直在等待的时刻，真实值与外推值的比较(蓝线是外推值)。
作者图片
每个外推值都与实际值吻合得很好，而且与温度的关系也不太坏。但是，我们的百万美元问题还没有答案。为了将数值转换回每日数值，我们需要一点数学知识。
作者图片
其中 n 是样本数。然后，我们可以获得月平均值的方差，即
作者图片
其中 Yj^s 是月平均值的标准化版本。最后，我们用这组等式推导出每日值的标准误差:
耶！😃，图片作者
废话不多说，让我们看看每天的外推值是如何得出的。
作者图片
我的第一反应是“这是什么嘈杂的时间序列？这简直是疯了！”。我不认为我们需要解释什么来回答这个问题，这是一个明确的否定，至少使用这种方法。由于我们使用外推数据进行外推，因此外推值噪音太大，并且仅对短期有效。此外，月平均值不像日平均值那样带有“跳跃”,导致外推的日值无法捕捉到它。
结论
- 这种外推方法只能根据计算中使用的数据集来创建值，并且生成的值将遵循数据集的特征。
- 平稳性假设可能会影响检测“跳跃”的能力。因此，更合适的模型可能是生成更合适的外推值的解决方案。
- 即使外推值是完美的，也不意味着它是总体的完美代表。尽管如此，最好还是得到一个对人口可能的估计描述。
下一步是什么？
我可能不是这方面的专家，但我确实学会了创造性地使用时间序列数据集。尽管如此，我还是想听听你的建议，也许能更好地改进这个方法。所以，下面是我对这种时间序列外推法的 GitHub 回购。近期一定会贴出更多的数据科学或精算项目，敬请期待！
[## nicholasatyahadi/时间序列数据集外推法
有时我们会收到少量数据的数据样本。这个小数量可能会受到周期性的影响…
github.com](https://github.com/nicholasatyahadi/Time-Series-Dataset-Extrapolation)
去学数据科学？让我们试试。
谷歌的 Golang 能搞定数据科学吗？让我们找出答案。
数据科学能从静态类型、编译的编程语言中受益吗？这就是我们将在本文中探讨的。
Go 或 Golang 是一种非常类似于 C 的编程语言，但是提供了内存安全、垃圾收集和结构化类型。它是由谷歌在 2007 年设计的，目的是在多核、联网机器和大型代码库的时代提高生产力。
图片来源:维基共享资源
作者注: 我不是围棋编程语言方面的专家。下面你将阅读一篇观点文章，展示该语言处理数据的选项。欢迎在评论区发表你的想法。
但是我们作为数据科学家为什么要关心围棋呢？
我很高兴你问了。大多数开发人员对 Python 有一种爱恨交加的关系，其中“爱”的部分来自于它易于学习和编写，“恨”的部分来自于它非常慢并且是动态类型的。
因此，Go 可能是解决 Python 问题的语言之一。
本文的目的不是向您展示如何在您的机器上安装和配置 Go，而是向您展示 Go 如何处理数据读取和数据操作，因此您可以将它与您选择的语言进行比较，看看它是否值得进一步探索。
目标读者是任何对 Python/R 有足够经验的人。我所说的“足够经验”是指你知道如何编写代码，并且你能够看到这两种语言的缺点。
这篇文章的结构如下:
- 设置和导入
- 读入 CSV 数据
- 数据帧
- 数据过滤
- 结论
是的，完整的代码可以在这里找到。事不宜迟，我们开始吧！
设置和导入
首先，我们将做一些必要的事情:声明一个包，导入一些库，并声明 main 函数。
与 Python 相比，这有点像样板文件，而且所有要执行的代码都必须在main函数中。请随意考虑这是赞成还是反对。
在我们开始学习与数据科学相关的东西之前，我们的 main.go 文件应该是这样的:
这就是开始前需要的所有样板文件。在下一节中，我们将下载并读入 CSV 数据，在接下来的一节中，我们将把它转换成 DataFrame 对象，这样就可以很容易地操作它。
读入 CSV 数据
没有数据就没有数据科学。因此，任何打算用于数据科学的编程语言都必须具有数据读取和处理能力。
有了 Go，我们可以使用 OS 模块读入逗号分隔的数据。为了演示，我们将使用著名的虹膜数据集，代表来自各种花卉物种的数据。
要读取 CSV，我们可以使用以下代码片段:
例如，如果找不到文件，os.Open命令会导致错误。这就是为什么以某种方式处理这个错误是个好主意。但是如果您现在将这个irisCsv打印到控制台，您将不会得到您所期望的结果:
&{0xc000088780}
我们将在 net 部分解决这个问题，在那里文件将被转换成数据帧。
数据帧
如果您曾经使用 Python 或 R 进行过数据科学方面的工作，那么您肯定对数据帧的概念很熟悉。为了执行任何与数据相关的工作，我们需要将 CSV 转换成 DataFrame 格式。在这样做之前，我们需要安装dataframe库:
go get github.com/kniren/gota/dataframe
现在我们可以很容易地将它包含到我们的导入中——只需将所有内容放在 imports 部分的go get之后。从这一点来看，将irisCsv转换成数据帧的过程再简单不过了:
df := dataframe.ReadCSV(irisCsv)
如果您现在将它打印到控制台上，您会看到类似这样的内容:
挺酷的吧？
在下一节中，我们将探索如何实际处理这些数据——如何过滤数据、选择子集等等
数据过滤
现在，这是你一直在等待的部分。对你们大多数人来说，这一部分可能是成功或失败的时刻。如果 Go 能够很好地处理数据操作，考虑到它对 Python 的所有非数据科学相关的东西，它可能值得进一步探索。
事不宜迟，让我们看看如何打印出数据帧的前几行——与 Python 和 Pandas 的head()相同。
执行此代码将导致以下结果:
结果显然与使用 Python 获得的结果相同，但是 Python 在这里是明显的赢家，至少在开发的便利性和速度方面是如此。
接下来，我们将深入研究过滤。
假设您只对 virginica 物种感兴趣，并希望将它们存储到特定的变量中。你可以这样做:
现在，这比 Python 中的输入要多得多，但是你不能否认代码不干净和不言自明。要是没有这么多打字要做就好了。
同样，您可以过滤掉其他操作符。这里我们选择过滤掉所有sepal.length等于或小于 7:
太好了。对于最后一个示例，让我们看看如何选择感兴趣的列:
此外，如果你问我，我会说这不是最干净的解决方案，但是这更多的是与 Go 语法有关，而不是 Go 处理数据的能力。这实际上可能对你有好处，取决于你习惯哪种类型的语法。
这篇文章到此为止，让我们在下一部分给出结论和一些结束语。
结论
老实说，我还没有像探索 Python 那样深入地探索过 Go 编程语言。然而，我们仍然做了一些有益的工作。
以下是我最后的想法:
- 在熟悉数据和/或设计解决方案原型时，我会使用 Go 吗？绝对不是——它只是没有考虑探索性数据分析。
- 我会翻译最终的 Python 解决方案来获得更好的性能吗？也许。
我说的“可能”是指收益大于成本，收益是速度的提高，成本是进行转换所需的时间。是的，Python 比 Go 慢，但是在某些情况下，你可能不会从额外的速度中获益太多。
你用过 Go 做数据科学吗？或者其他不是 Python，R，或者 Julia 的语言？请在下面的评论中告诉我。
感谢阅读。
喜欢这篇文章吗？成为 中等会员 继续无限制学习。如果你使用下面的链接，我会收到你的一部分会员费，不需要你额外付费。
[## 通过我的推荐链接加入 Medium-Dario rade ci
作为一个媒体会员，你的会员费的一部分会给你阅读的作家，你可以完全接触到每一个故事…
medium.com](https://medium.com/@radecicdario/membership)
参考
[1]https://en . Wikipedia . org/wiki/Go _(programming _ language)
力量 BI 101 去，得到他们，夏洛克！像专家一样在 Power BI 中进行数据分析
成为一名“数据侦探”听起来对你没有吸引力？检查为什么你应该重新考虑你的立场
克莱门特·尼维斯关于 Pexels.com 的照片
你喜欢阅读犯罪故事吗？就我个人而言，我崇拜他们。而且，当我年轻的时候，我非常崇拜夏洛克·福尔摩斯和赫丘里·波罗，以至于我长大后想成为像他们一样的人:)
这两个角色最适合演什么？他们可以准确无误地剖析人们，基于这种剖析收集事实，所以最后，一切看起来如此简单和明显——就像任何人都可以做到那样！
老实说，我的侦探技能甚至不足以在那份“工作”中取得成功。但是，我决定分析数据，而不是分析人…
什么是数据分析？
柯克·赖在 Unsplash.com 拍摄的照片
根据 Ralph Kimball 的说法，数据剖析是对数据源内容的系统的预先分析。这句话中有多个关键词，但我们只关注其中的几个:
- 在开始使用数据之前，你必须了解你的数据
- 您必须检查数据的所有方面，从检查内存占用和基数到复杂的业务规则(系统性的)
- 您应该对源数据执行数据剖析——在数据仓库领域有一句名言:垃圾进，垃圾出！简而言之，如果您的数据本身质量不好，您就不能指望您的报告能显示准确的数字
有多种类型的数据分析技术:
- 完整性 —我的列中有多少空白/空值？
- 唯一性 —我的列中有多少个唯一值(基数)？我有副本吗？允许有重复吗？
- 值分布 —记录在特定属性的不同值之间的分布
- 范围 —查找列内的最小值、最大值、平均值
为什么我需要数据分析？
Andrea Piacquadio 在 Pexels.com 的照片
执行数据分析的主要好处是提高数据的质量。这样，例如，您可以发现电话号码列中是否有字母，或者邮政编码是否与预期模式不匹配。
此外，您还可以捕捉数据中是否出现了异常值。简单地想象一下，您有一个包含不同水果的单独价格的列——假设它的范围在 1 到 1000 之间。但是，突然之间，您注意到 1.000.000 的值(有人犯了一个错误，或者其他什么原因)。现在，假设您的报告显示了水果的平均价格！我打赌你不会想到苹果、桔子或香蕉的平均价格只有几千美元:)
了解您的数据
最后，在将数据呈现在用户面前之前，你应该了解这些数据。因为，根据数据分布和列的其他特征，您可以更容易地决定使用哪些可视化，或者是否有必要应用一些额外的步骤来进行数据清理或数据转换。
研究数据的细微差别并发现底层结构中的异常，可以使您的报告更出色，同时也更准确。
照片由 Unsplash.com 的 Edo Nugroho 拍摄
利用 Power BI 进行数据分析
我最喜欢 Power BI 的一点是，它为您提供了一种可能性，不仅可以创建吸引人的可视化效果，还可以在此之前塑造您的数据。
也就是说，当涉及到数据分析时，Power BI 可以提供很多功能。更重要的是，它使您能够以非常用户友好的方式执行数据分析，因为它有一些内置的功能，可以使您的“数据夏洛克”工作更加容易。
我将与您分享一些我在日常工作中应用的关于数据分析的技巧。
我喜欢做的第一件事是在 Power BI Desktop 的 model 选项卡中打开数据模型:
这样，我就熟悉了这些表，我可以识别关键列、表之间的关系、关系类型(1:1，1:M；活动/不活动)等。这让我对数据模型有了一个很好的了解，所以我可以在以后专注于具体的事情。
下一步是打开 Power Query 编辑器，大部分数据分析都在这里进行。那么，让我们来看看它是如何做到的:
在“视图”选项卡下，打开“列分布”、“列配置”和“列质量”选项。一旦您选择了一个特定的列，您应该能够看到您的数据分析。更重要的是，它以一种很好的、人类可读的方式显示，因此您可以快速获得底层数据的详细概述！
这样，Power BI(或者更准确地说，Power Query)可以帮助您发现数据中的异常值、异常或任何其他意外的“行为”。
现在让我们来看看所有这些视觉效果显示了什么:
- 列质量 显示有效数据与错误数据及空数据的百分比。在一个完美的世界里，100%的数据都是有效的，但是现实中很难做到
- 列分布 显示列内的数据分布，同时也显示不同的和唯一的值的数量。这两者是不一样的:不同的值包括重复值和空值，而唯一值不包括。因此，非重复值是总数，而唯一值则表示这些值中有多少不是重复值或空值。
- 列概要 显示列的更深入的概述，包括行数，以及在特定列中导入数据时是否有错误。您还可以检查空行的数量，与列中的最小值和最大值相同。这在您分析一个数字列时特别有用，因为您可以快速发现任何可能的异常值(请回忆一下我们之前关于水果价格的例子)
此外，当应用于数字列时，列统计信息还将包括零和 NULLs 的数量，以及一些统计函数，如平均值、标准偏差和偶数与奇数之间的分布。
拥有所有这些统计信息可以帮助您理解数据分布，并在您决定额外转换或清理数据时为您提供支持。
结论
现代数据仓库面临的最大挑战之一是实现最高水平的数据质量。这条道路上的第一步(也是最重要的一步)是数据概要分析。
回到我们开始的地方——夏洛克·福尔摩斯和赫丘里·波罗——因为他们能够在调查过程中发现细微的差别并识别出一些不寻常的行为(异常值),这最终为他们带来了成功！
总结:花点时间成为“夏洛克”或“波洛”，然后再将注意力转移到在报告中构建漂亮的视觉效果上。
感谢阅读！
订阅此处获取更多有见地的数据文章！
基于 AdaBoost、随机森林和 XGBoost 的时间序列预测
我们能从不能给我们很好预测结果的数据科学项目中学到什么
编辑:这篇文章之前的标题是“去高度精确还是回家？”
在 kaggle 上浏览笔记本，或者阅读那些数据科学项目的故事，在这些故事中，人们获得了高度准确的结果，完美地解决了潜在的业务问题，这对于数据科学领域的初学者来说可能会非常沮丧，因为他们在自己的项目中可能达不到这样的结果。但是这些闪亮的笔记本和博客帖子实际上并没有讲述事情的全部。
获得好的结果实际上意味着大量的工作。除非您一开始就有一个非常全面的数据集，否则您将需要运行多个周期来研究、添加和探索数据、设计和选择要素、转换要素以及运行和调整模型。即使经过多次尝试，您的模型可能仍然表现平平。那么该不该放弃这个项目，以“浪费时间”来归档呢？
绝对不行！
在下面的段落中，我想分享我自己在一个具有挑战性的项目中的工作经历，这让我学到了关于数据科学的宝贵经验。
TL；博士:
- 不要期望马上得到很好的预测结果
- 时间序列预测是非常困难的，通常情况下，简单的模型或传统的统计方法会比先进的机器学习模型产生更好的结果
- 超参数调整不会将坏的或不相关的数据变成很好的预测；回到你正在使用的功能，试着理解哪些应该删除、重新设计、改造或添加
- 理解你为什么使用某些算法；将它们与其他人进行对比，并能够解释它们的优缺点
- 使用一个简单的基线模型来比较你的结果
- 从黑客到理解
该项目
该项目的目的是使用来自 Capital Bikeshare 的数据预测美国 DC 大都会地区的自行车共享需求。有一整套研究只是处理这样一个问题，即如何知道人们何时想在一个城市的某个位置租一辆自行车，以避免车站自行车供应过剩和短缺。我希望通过专注于基于树的集成算法(AdaBoost、random forests 和 XGBoost)之间的比较来解决需求预测问题，并避免我在 kaggle 和其他地方发现的自行车共享预测的许多实现中普遍存在的前瞻偏差。因此，我预测了整个城市第二天的自行车共享客户数量。
图片由 Pablo Valerio 拍摄，来自 Pixabay
你可以在我的 GitHub 上找到这个项目的实现。我使用了 Capital Bikeshare 的自行车共享数据、NOAA 国家气候数据中心的历史天气数据和 DC 人力资源部的信息。自行车共享数据的范围从 2011 年 1 月 1 日到 2018 年 12 月 31 日，是一个提供日常自行车需求的连续时间序列。合并数据集后，保留了一个日期特征、十九个分类特征(假日和天气类型特征)和六个数字特征(平均值、最小值、最大值、观测温度、风速和降雨量)以及目标变量(t0 时的客户数量)。
我将简要概述我的 EDA 的部分内容(通过对自行车共享研究的全面文献综述了解)，建模和评估方法，然后回顾这个项目教给我的经验教训，我希望将这些经验教训传递下去。
探索性数据分析
显示目标随季节分布的箱线图
根据季节绘制的目标分布图显示，租赁自行车的人数与一年中的时间有明显的联系。在春天，当与夏天和秋天相比相当寒冷时，自行车共享需求将会降低。
显示数值天气特征和目标之间的皮尔逊相关系数的热图
相关系数表明，最低温度与目标温度、最高温度与目标温度之间存在较强的相关性。我决定同时使用这两个特性。风速和降雨量与目标只有微弱的相关性，但是，我想保留这些特征，因为它们可能对模型仍然有用(特别是考虑到皮尔逊相关性仅显示线性关系)。为了避免前瞻偏差，即使用只有在未来才可用的数据来预测未来的数据，我使用了滞后的天气数据。我为过去 8 天的天气趋势的平均值和标准差设计了新的特征。用不同的时间滞后运行我的模型显示，8 天产生了最好的结果。我还将 t-1 时的最高温度编码为一个分类变量，表示一天是非常冷、冷、凉、暖还是热。
根据天气类型显示目标分布的箱线图
我没有使用原始数据集中包含的 18 种不同的天气类型，而是根据目标变量的相似分布将它们组合成 4 个分类变量。我还设计了这些变量的 8 天滞后的均值和标准差。
显示目标在不同工作日的分布的箱线图
工作日实际上似乎对顾客数量没有太大影响。然而，基于树的集成模型应该能够很好地处理有噪声的数据，所以我保留了这些特征，并在删除它们之后再次运行我的模型来比较结果。
目标的部分自相关图
因为我使用的是时间序列数据，所以目标值也可以设计成特性，实际上也应该如此！从偏相关图中我们可以看出，昨天的客户数量与今天的客户数量有很强的相关性。我添加了 t-1 的客户数量作为一个特征，还添加了过去 8 天的平均值和标准差。
总客户目标变量的时间序列
在进行时间序列预测时，统计学告诉我们，我们需要确保我们的数据是平稳的，才能得到准确的结果，这意味着需要去除任何季节性或非季节性的趋势。我使用了 ADF 和 KPSS 测试来发现目标不是静止的。我比较了预测非平稳和平稳目标变量的模型的性能，以了解非平稳性对预测结果的影响。
模型中使用的最终特征以及应用于它们的转换
我总共使用了 25 个特征来预测需求。
建模
与其他机器学习算法相比，基于树的集成模型具有多重优势:易于理解；他们的成绩比底层的弱学习者要好；它们没有正态分布假设，可以处理混合数据类型；它们对过拟合、离群值、噪声、多重共线性和输入缩放具有很强的鲁棒性(更多详情，请查看本文和本文)；与支持向量机或神经网络等最大似然算法相比，它们在计算上相对便宜。因此，我使用 AdaBoost、random forests 和 XGBoost 来预测自行车共享需求，并确定这三个模型中的哪一个最适合这种类型的数据集。作为性能基准，我使用了最后一个值方法，该方法预测明天的需求(t0)将与今天的需求(t-1)相同。
关于实现和调整的超参数的更多细节，你可以参考我的 Jupyter 笔记本中的代码。
估价
在我的评估中，我根据曾等人(2016) 使用的方法使用了三种不同的指标:平均误差(MAE)、均方根误差(RMSE)和均方根对数误差(RMSLE)。MAE 显示的是预测值与真实值的平均偏差，而 RMSE 则对偏差进行平方，对较大偏差的惩罚比对较小偏差的惩罚更重。RMSLE 对低估的惩罚比对高估的更重。这使得自行车共享需求成为一个有趣的指标，因为你通常希望在共享站有更多而不是更少的自行车供人们租赁。
自行车共享需求预测汇总结果
查看这些结果并将高级 ML 算法与基准和目标值范围进行比较，所有三个模型都表现得相当好。原始基线模型甚至优于 MAE 上的所有调优模型。此外，这些模型在预测中平均每天偏离 1500 人。考虑到在分析的整个 8 年期间，平均每天只有 7，726 个客户，这些预测性能并不太好。
那么，我们如何解释这种表现，我们又能从中学到什么呢？
时间序列预测与前瞻偏差:预测时间序列很难，因为有很多因素可以影响明天的价值。此外，你需要更多的统计背景知识，以避免陷阱。最重要的是，要有一个有意义的模型，你需要避免前瞻偏见。在我的模型中，我使用了滞后的天气数据来解释前瞻偏差。然而，由于天气多变，趋势数据可能没那么有用。使用天气报告/预报数据来预测需求可能更好。但由于这些信息很难获得，尤其是过去较长时期的信息，所以我决定使用历史天气数据。
除了这方面的前瞻偏差，我们还需要确保我们不会引入随机性。时间序列需要连续有序。我们不能将数据随机分成训练集和测试集。相反，我们应该使用时间序列片段来避免我们用在预测时无法知道的信息来预测目标。此外，当使用 bagging 或 bootstrapping 算法时，如随机森林和 XGBoost，确保您实际上不引导，因为这将再次在我们的预测中引入随机性和前瞻偏差(默认情况下， XGBoost 不引导，而 r 和随机森林引导)。前瞻偏差是你在 kaggle 上看到的类似项目的其他实现实际上产生更好结果的原因:在训练和测试期间，它们表现得更好，而在现实生活中，它们实际上可能会失败。
统计以及如何知道它们什么时候重要:即使不使用传统的统计方法来做时间序列预测，仍然需要很好地理解一个时间序列所附带的底层统计假设。在不了解自相关的情况下，您会查看目标值的偏相关来确定这是一个很好的工程特性吗？如果没有意识到平稳性，您会转换您的数字特征和目标变量来解释季节性和非季节性趋势吗？因为我以前没有做过时间序列预测，不确定平稳性的影响，我简单地用运行了所有预测平稳和非平稳目标的模型，并对它们进行了比较。我发现只有 AdaBoost 在处理静态数据时表现稍好。因此，当趋势仍然包括在目标中时，ML 算法似乎不容易不准确。但在未来，如果我不确定结果会是什么，我会尝试两种选择。
简单基线模型:与 3 ML 算法相比，最后一个值方法的性能并没有差很多。这怎么可能呢？如上图所示，今天和昨天的目标值高度相关。因此，如果我使用一个模型，简单地从昨天的值来预测今天的目标，那么它会表现得相当好。这表明，即使你有一个考虑到各种特征的花哨的多元 ML 模型，你实际上也不一定能够胜过非常简单的基线模型或更传统的统计模型，如 ARIMA 。特别是在时间序列预测中，越复杂并不总是越好。
反复试验:不仅超参数调整对提高性能很重要。如果您有坏的或不相关的特征，调整不会保存您的模型。特征选择和工程对改进欠拟合模型至关重要。当比较工作日特征的包含和移除时，查看 AdaBoost 的性能，其显示了良好特征选择的重要性以及该算法对噪声数据的明显弱点。AdaBoost 是唯一一种在去除工作日特征后有所改进的算法。功能选择和工程是一个漫长的试错过程。但是，用不同的特征来测试你的模型，以确定哪些特征实际上有助于你的预测，哪些特征不利于你的预测，这一点很重要。识别其他有用数据集和要素的研究部分至少与调整超参数一样重要。
理解 ML 算法:不要因为你在 kaggle 上看到很多人在做 XGBoost 就去实现它。思考不同算法的优缺点，通读介绍这些算法及其伪代码的实际科学论文，并相互比较。通过这个项目和实际阅读分别介绍 AdaBoost、random forests 和 XGBoost 的论文，我实际上理解了如何对比这些基于树的集成算法。只有这样，你才能更好地理解为什么某些算法可能比其他算法执行得更好。在我的例子中，XGBoost 很可能表现得更好，因为它增加了正则化超参数，避免了过度拟合。虽然随机森林通过使用 bagging/bootstrapping 训练样本来减少过拟合，但这对于我们想要避免随机性的时间序列数据没有帮助。
理解性能指标:结合使用 MAE、RSME 和 RMSLE 可以让你知道你的模型可能有哪些弱点。因为最后一个值方法的 MAE 较低，但是 RMSE 和 RMSLE 高于任何调整的 ML 模型，这表明 ML 模型更经常适度地过度预测目标，而最后一个值方法更严重地低估。尤其是具有最低 RMSLE 的随机森林，过度预测的频率高于不足预测的频率。这对于需求预测模型来说可能是更好的，因为在车站有更多的自行车可供出租比更少的自行车更好。
结论
XGBoost 是三种基于树的集成算法中性能最好的模型，并且对过拟合和噪声更加鲁棒。它还允许我们忽略这个特定数据集中的平稳性。但是，成效还是不大。为了获得更好的自行车共享需求预测结果，需要在特征选择和工程上花费更多的时间。因为模型不适合，很可能需要包括不同的和/或更多的特征。但是，更传统的统计方法，如 ARIMA，也不应该放弃，因为他们可能会产生更好的结果。为了使它对现实世界的应用更有用，一个更长的预测范围和一个特定站点而不是整个城市的预测将是有价值的。
其中一些见解你可能已经很熟悉了，在我在 Udacity 攻读数据科学纳米学位期间，我了解到了理解性能指标、ML 算法和特征选择的重要性。但是这个特别的项目提醒了我，作为一名数据科学家，超越仅仅是黑掉 T5 的 T4，开始理解 T7 对你的成长是多么重要。此外，我以前没有做过时间序列预测，在处理这类数据时学到了很多潜在的陷阱。
并不是你接触的每个项目都会立即带来高预测性能。这往往需要大量的时间、研究和反复试验。但是，即使表现一般的模型也能告诉我们很多关于我们试图解决的潜在数据和业务问题，并指导我们如何改进我们的预测。
注:这篇博文的内容基于我写的一篇未发表的研究论文。
你想在媒体上阅读更多高质量的故事吗？考虑注册一个支持我和其他媒体作者的会员。
[## 通过我的推荐链接加入 Medium-Julia Nikulski
作为一个媒体会员，你的会员费的一部分会给你阅读的作家，你可以完全接触到每一个故事…
medium.com](https://medium.com/@julia.nikulski/membership)
如果你想更深入地了解本分析中使用的基于树的集成算法，请查看我关于 AdaBoost、random forests 和 XGBoost 的指南。
[## AdaBoost、随机森林和 XGBoost 的终极指南
它们是如何工作的，有何不同，何时应该使用？
towardsdatascience.com](/the-ultimate-guide-to-adaboost-random-forests-and-xgboost-7f9327061c4f)
Go，Neo4J，还有 AWS Lambda…
以及让它们一起工作的本质
我几乎每天都与 Neo4j 一起工作，作为一名 Python 开发人员，我通常将他们两人结合在一起编写我的大部分逻辑。然而，在过去的几天里，自从我开始使用 Golang，我似乎对它产生了强烈的亲和力。
我想使用 AWS Lambda 构建一个简单的服务，对我的 Neo4j 数据库执行简单的查询，并决定使用 Go 来改变一下。得知 Neo4j 有官方的 Go 驱动程序，我明显松了一口气。但是最初的几次尝试完全失败了。
不过不要担心，好消息是，你肯定可以一起使用 AWS Lambda、Go 和 Neo4j。只有几个额外的步骤需要首先执行。
问题是…
是的，Neo4j 有一个 官方驱动给 Golang 。
不，不是纯围棋写的。
这是什么意思？neo4j-go-driver 依赖名为“ Seabolt ”的 C 库通过 bolt 协议连接到数据库实例。
这意味着在开始执行 Neo4j 的 Go 代码之前，您必须显式地安装这个库。此外，seabolt 反过来要求在您的本地系统上安装 OpenSSL(对于 Windows 是 TLS)才能正常工作。
在本地机器上安装 OpenSSL 和 Seabolt 非常容易。事实上，OpenSSL 预装在许多操作系统中。(我使用的 Linux 系统已经有了 OpenSSL，我所要做的就是按照这些指令 安装 Seabolt)
当我们想要使用 AWS Lambda 复制同样的东西时，挑战就出现了。Go 作为一种静态类型语言首先被编译成二进制文件，然后作为 Lambda 函数的处理程序。通常，如果所有的依赖项都是基于 Go 的，或者如果您在本地系统上工作，这不会导致任何问题。
然而，在我们的例子中，Go 二进制依赖于外部 C 目标文件，并在运行时链接它们。但是我们如何让这些 C 文件对 lambda 函数可用呢？
解决方案
在花了相当多的时间在互联网上寻找可能的解决方案后，我找不到任何具体的东西，尤其是围棋。大多数解决方案都是针对 python 的(因为某些 python 库也使用 C 依赖)，我几乎想回到我的老朋友 Python。但是，即使语言不同，概念是相同的。
进入 AWS Lambda 层…
从最简单的意义上来说， Lambda 层是一段可以被不同服务共享的代码。通常，一个层将由大多数功能所需的重量级依赖项组成。在我们的例子中，我们将把我们的 C 依赖打包在一起，并使用层使它们对 lambda 函数可用。
TL；速度三角形定位法(dead reckoning)
包括 lambda 函数示例和安装说明的完整代码在我的 GitHub 库的中。
步骤 1:打包 C 库
由于 AWS 经常使用基于 CentOS 的容器来部署 lambda 函数， Docker 成为下载和编译 C 依赖项的明显选择。
我们使用lambda-base映像作为基础映像创建一个定制的 docker 映像，并在其上安装我们所有的依赖项。
安装海锚的文件
基本映像已经安装并配置了 OpenSSL。现在唯一需要的图书馆是 Seabolt。
Seabolt 作为下载。tar 包并提取到 docker 映像中的 /usr/local/lib64 目录。为了使它对 Lambda 函数可用，我们将内容移动到 /opt/lib 目录，这是运行时链接期间搜索的目录之一。(这是在名为 LD_LIBRARY_PATH 的环境变量中指定的)
一旦构建了映像，我们需要将 /opt/lib 文件夹的内容转储到本地系统上的一个文件夹中，该文件夹稍后将被转换为一个层
打包依赖项的脚本
运行这个脚本将创建一个名为图层的目录，其中包含。所以在层/lib 文件夹中的文件是针对 Seabolt 的。
步骤 2:创建一个层
现在，我们要做的就是创建一个层。有两种方法可以做到这一点。首先，我们使用 AWS 控制台或 CLI 创建一个层，并将层/目录的内容作为. zip 文件上传。
另一种方法是使用 无服务器框架 ，它会为你做所有的工作。你所需要的只是一个文件调用 serverless.yml 来指定你的层的细节。
用于创建图层的 serverlee.yml
从您的工作目录中运行 run serverless deploy。
你将为你新创建的层获得 ARN URL ，你可以很容易地将它附加到你的 lambda 函数上。
下一步:创建自己的 Go 处理函数
一旦成功地创建了这个层，您就可以继续创建您的自定义处理函数来与 Neo4J 通信。
GitHub 库包括一个示例处理函数，它在 Neo4j 中创建一个简单的节点，这个节点是使用无服务器框架部署的。关于如何使用 Go 和 serverless 创建 Lambda 函数的更多参考，这是一个有用的链接，可以从开始。
感谢阅读！
出去锻炼还是不锻炼？让数据科学来决定
由 Sorbyphoto 在 Pixabay 上拍摄的照片
决策树机器学习算法简介
作为最流行的经典机器学习算法之一，决策树在可解释性方面比其他算法更直观。让我们考虑下面的对话。
杰德:“我们明天应该出去跑步吗？”
克里斯:“天气怎么样？”
杰德:“我用手机查一下。今天是晴天！”克里斯:“听起来不错！那温度呢？”
玉:“嗯……35 度”
克里斯:“哎呀，太热了。我更喜欢去室内游泳池游泳。”
我们一生中做了很多决定。如果我们想一想为什么会做出那些决定，大多数时候背后都有一个“决策树”，如上图所示。这就是为什么决策树可能是最直观的非常接近人脑的机器学习方法。
决策树的构建模块
由 PublicDomainPictures 在 Pixabay 上拍摄的照片
决策树作为机器学习模型是如何构建的？构建决策树有几种不同的流行算法，但它们必须包括两个步骤:构建树和修剪树。
构建决策树
为了构建决策树，算法需要生成三种类型的节点:
- 根节点:决策树只有一个根节点，位于树的顶端。
- 内部节点:这些节点位于其父节点和子节点之间。
- 叶节点:这些节点永远不会有子节点，它们是决策树做出的“决定”。
然后，很明显，问题变成了典型的决策树算法如何生成/决定这些类型的节点:
- 对于根节点，应该创建哪个功能？
- “条件”是如何决定将父节点拆分成子节点的？
- 何时停止生成更多的分支并以叶节点结束？
这些在不同类型的决策树算法之间是不同的，这将在后面的部分中讨论。
修剪决策树
这听起来像是一旦树建好了，我们就完成了，但并不是真的。大多数时候，我们必须修剪树木，以避免“过度适应”。
如上图所示，我们假设每个分割红色样本和蓝色样本的边界都是一个分割决策树中节点的条件。事实证明，左边的树似乎过于适合训练示例。修剪后的树，我们期待它成为正确的东西。
过拟合的原因通常是训练数据集小，被认为分裂的“特征”太多。决策树模型最有趣的特征是它们可以与训练数据集完美拟合，即 100%正确地对训练数据集进行分类。然而，这不是我们想要的，因为这几乎意味着我们构建的树已经失去了泛化能力。换句话说，它不能用于实际问题，只能用于训练数据集。
通常，有两种类型的树修剪机制:
- 预修剪
建造时修剪树木。也就是说，在拆分节点并将更改应用到树之前，测试拆分是否会提高测试数据集中的分类准确性。如果有，继续做这个分支。否则，该当前节点将不会被分割，从而成为叶节点。
- 后期修剪
该算法首先建立决策树。然后，从叶节点向后到根节点，评估每个分支以测试分裂的影响。如果这个分支在测试数据集上没有提高太多的性能，或者有时甚至可以提高性能，那么就去掉它。
算法将如何构建决策树
不管我们将使用哪种算法来构建决策树，将使用的两个常见且重要的标准是纯度和熵。
纯洁
理解什么是纯洁是相当容易的。也就是说，对于一个单一的特征，它所对应的决策有多纯粹。让我们使用上面的样本数据集来演示。
- 当天气多雨时，所有的决定都是“不”(100%纯度)
- 当天气晴朗时，2 个决定是“否”, 1 个是“是”
因此，我们可以说第一套的纯度高于第二套。
熵
熵几乎是熵的反向概念。它是由 Claude Shannon [1]首先提出的，是一个从热力学转移到信息论的概念。一般是指信息的“不确定性”。公式如下所示:
不要被公式吓到，它在我们的语境中非常简单。集合“ X 是节点集合中的一切，“ xᵢ 是指每个样本的具体决策。因此，“【p(xᵢ】)”是某个决策要做出的集合的概率。
让我们用我们在纯度概念解释中用过的同一个例子。
- 当天气多雨时，两个决定都是“否”(100%纯度)
- 当天气晴朗时，2 个决定是“否”, 1 个是“是”
结果符合直觉。基于训练数据集，当天气下雨时，我们肯定不会出去跑步。换句话说，给定天气是雨天，根本不存在“不确定性”，所以熵为 0。
信息增益
在理解了纯度和熵的概念之后，我们可以用它们来构建我们的决策树。最经典、最基本的决策树算法之一叫做“ID3”。它根据一个叫做“信息增益”的概念来分割节点，信息增益是通过减去父节点和所有子节点的熵来计算的。公式如下。
在哪里
- “T”是父节点,“a”是“T”的属性集
- 符号“|T|”表示集合的大小
同样，不要被公式吓到。我们用一个例子来演示一下。假设我们想使用“天气”作为我们的根节点。我们需要计算它的信息增益。
从上图中，我们可以很容易地计算天气节点(在此上下文中是父节点)及其子节点“晴天”、“多云”和“雨天”的熵，如下所示:
因此，使用“天气”作为根节点的信息增益可以计算为:
同样，我们可以用同样的方法计算另外两个特征的信息增益:温度和风级。
使用温度作为根节点的信息增益是 0.522，对于风级，它是 0.306。因此，我们应该使用天气作为根节点，因为它具有最高的信息增益，为 0.592。
一旦根节点被决定，剩余的内部节点将继续使用信息增益，直到每个分支到达叶子节点，即决定。
ID3 算法的缺点(信息增益)
好的。如果你理解了上面提到的所有内容，你就已经理解了如何使用 ID3(信息增益)算法构建决策树。然而，ID3 算法有一些明显的缺点。
假设我们有另一个特性“日期”。显然，“约会”功能在决定我们是否应该出去跑步时可能不是很有用。然而，普通 ID3 算法倾向于选择具有更多不同值的特征作为靠近树根的节点。这意味着我们最终可能会得到一个以无用特征作为重要节点的树。
当然不会每次都这样，但有可能。因此，有更多的机器学习算法如 C4.5 和 CART 被提出来提高决策树的性能。
我会不断更新不同种类的机器学习和数据挖掘算法。所以，有兴趣的话以后继续关注。
C4.5 算法:
展示 ID3 中信息获取的局限性以及使用 C4.5 的优势
towardsdatascience.com](/do-not-use-decision-tree-like-this-369769d6104d)
摘要
Pixabay 上由 viarami 拍摄的照片
在本文中，我介绍了一个非常流行和经典的机器学习算法——决策树的基础知识。决策树模型的主要构件包括构造和修剪。之后，我介绍了最基本的决策树算法 ID3。我们已经学习了什么是纯度和熵，这些有用的概念在构建决策树中起着重要的作用。ID3 利用信息增益来构造决策树，这是非常直观和易于解释的。然而，它确实有缺点，这些缺点将在其他类型的算法中得到改进。
我的下一篇文章将是关于 ID3 之上的其他流行的决策树算法，以克服它的一些缺点。希望这些文章能帮助你更多地了解机器学习/数据科学学科！
作为一个媒体会员，你的会员费的一部分会给你阅读的作家，你可以完全接触到每一个故事…
medium.com](https://medium.com/@qiuyujx/membership)
如果你觉得我的文章有帮助，请考虑加入灵媒会员来支持我和成千上万的其他作家！(点击上面的链接)
参考
[1]香农，C. E. (1948 年)。交流的数学理论。贝尔系统技术期刊， 27 (3)，379–423。
保护自己:数字健康的数据保护和数据安全
每个人都希望自己的健康数据保密。毕竟，它可以揭示你生活中一些最敏感的细节。
对黑客来说，健康数据也比信用卡数据更有价值。但是很多时候，它没有得到适当的保护。
这样做需要结合数据保护和数据安全。这些概念经常被混淆，但我觉得大家，尤其是实际用户，应该更好理解。
介绍
毫无疑问，隐私、数据保护和数据安全与密切相关，如下图所示。
但它们绝对不是同义词。
隐私是一项基本人权，涵盖了个人生活的方方面面。《欧洲人权公约》第 8 条涵盖了这一点。
数据保护是关于谁可以访问个人数据的法律控制。例如，《一般数据保护条例》(GDPR)谈到“在处理个人数据方面保护自然人”。数据安全更通用。这是关于技术控制通过使用安全和访问控制来限制对任何数据的访问。数据安全是增强数据保护的重要工具。
然而，正如您将看到的，数据保护需要许多额外的措施。在这篇博客中，我将关注数据保护和数据安全。
隐私、数据保护和数据安全之间的关系
什么是数据保护？
近年来，数据保护越来越重要。世界各国都在收紧数据保护法。
GDPR 于 2018 年生效，保护每个欧盟公民的个人数据，无论这些数据保存在哪里。自 2018 年 5 月 25 日开始执行以来，企业已经收到罚款或受到执行行动。在本文中，我们看了三个关键案例，并从这些案例中吸取了一些重要的经验教训。在美国， HIPAA (健康保险流通与责任法案)已经保护健康数据将近 25 年了。在这里，你可以了解 HIPAA 和 GDPR 的区别。最近，加州消费者保护法( CCPA )将 GDPR 式的保护延伸到了加州的许多消费者。其他地方也有类似的法律，比如巴西的《LGPD 法》和南非的《POPI 法》。有关所有法律、法规&标准的快速概述，请查看本免费白皮书。
数据保护与个人数据有关
数据保护只涉及个人数据，也称为个人识别信息或 PII 。
根据数据保护法，公司和其他实体不受任何保护。 GDPR 将个人数据定义为:
“……与已识别或可识别的自然人(“数据主体”)有关的任何信息；可识别的自然人是指可以直接或间接识别的人，特别是通过参照身份识别特征，如姓名、身份证号、位置数据、在线身份识别特征，或该自然人的身体、生理、遗传、精神、经济、文化或社会身份所特有的一个或多个因素。”
这意味着任何与个人无关的数据(如匿名数据)都不在 GDPR 的覆盖范围内。
大多数数据保护立法赋予人们收集、存储和分发个人信息的特定权利。通常，与健康、性、宗教信仰等相关的敏感数据。获得额外保护。例如，GDPR 在第 9 条中规定了敏感(特殊)数据类别的数量。
GDPR 下的数据分类
虽然大多数数据保护法涵盖所有形式的数据，但有些法律仅涵盖特定类型的数据。例如，HIPAA 仅与个人健康信息或 PHI 相关。
数据主体权利
数据保护法基于隐私是一项基本人权的理念。
GDPR 走得更远，给予数据主体与个人数据相关的 8 项基本权利:
- 知情权。
- 进入权。
- 权利整风。
- 被删除/被遗忘的权利。
- 权利限制处理。
- 数据可移植权。
- 反对的权利。
- 与自动决策和分析相关的权利。
CCPA 也给予类似的权利。在大多数情况下，这些权利要求应用程序开发人员实施技术措施，如审计日志记录、同意跟踪和数据导出。
然而，有些权利，如被遗忘的权利，也需要法律咨询和专业知识来纠正。
实施数据保护
数据保护通常需要组织和技术措施的结合。
GDPR 的核心特征之一是，公司在处理个人数据时需要法律依据。这意味着您通常需要在处理数据之前获得许可(同意)。
您还必须实施合适的技术措施。然而，GDPR 并没有具体说明这些是什么。
这是因为并非所有企业都拥有同等的资源，并非所有数据都面临同等的风险，而且数据安全性在不断发展。相反，GDPR 谈到了“考虑到最先进的技术”和“通过设计和默认来保护数据”。
在欧盟和美国，也有法律义务公布任何数据泄露的细节。
根据 GDPR，即使您不确定违规行为是否已经发生，您也必须在 72 小时内通知您当地的数据保护机构。
您还有义务通知其数据可能受到影响的任何人。在美国，针对经济和临床健康的健康信息技术( HITECH )法案要求对影响 500 人以上的任何违规行为进行通知。然而，CCPA 没有这样的要求，而是依靠用户提交投诉。
什么是数据安全？
数据安全是控制或限制数据访问的任何措施的总称。重要的是，它涵盖了所有形式的数据，而不仅仅是 PII 或 PHI。
数据安全有三个主要方面。首先，您需要实际保护数据，通常使用某种形式的加密。其次，您需要保护您的网络和服务器免受访问。第三，您需要对用户进行身份验证，并检查允许他们访问哪些数据。
数据安全有很多标准，包括 NISTISO 27001和 T2 网络安全框架。
数据加密
加密包括使用加密算法和密钥来保护您的数据。数据应该在静态(存储中)和动态(例如，当您将数据从用户设备传输到后端)时进行加密。
加密有很多种形式，这里就不赘述了。但是有两个关键概念你应该知道。
首先是对称加密。这里，相同的密钥用于加密和解密数据。这在某些方面就像传统的机械锁。另一种是非对称或公钥加密。这里，您使用一个(公共)密钥来加密数据，使用另一个(私有)密钥来解密数据。数据一旦加密，就只能用私钥解密。当然，如果你不能保证(私有)密钥的秘密，所有的加密都是无用的。
物理和网络安全
许多数据安全威胁是基于物理或网络的。数据泄露的一种典型形式是，员工不小心将一个未加密的 USB 密钥留在了餐厅或火车上。另一个是从服务器上物理盗窃硬盘。
在任何数据安全风险评估中，都必须考虑这样的物理威胁。作为最低要求，所有磁盘都应该加密以防止被盗。
网络威胁包括未经授权访问您的系统、拒绝服务(DoS)、勒索软件和病毒。这里的主要保护来自专业硬件，如负载平衡器、防火墙和入侵防御系统。一些公司甚至完全禁止访问公共互联网，以确保系统安全。如果你与这里的专家交谈，你可能会听到像非军事区(DMZ)、入侵检测和红方网络这样的术语。
认证和访问控制
难题的最后一块是控制和监控谁可以访问哪些数据。这通常被称为 AAA(认证、授权和计费)。
认证包括检查用户的身份。传统上，这是通过用户名和密码完成的。
但是越来越多的公司使用多因素身份认证。这可能只是简单地向您的手机发送一个代码，但它可能涉及物理认证令牌。它甚至可能涉及生物识别，如指纹、虹膜扫描或面部识别。
授权是您检查(经过身份验证的)用户可以访问哪些数据的地方。理想情况下，这应该是非常细粒度的，默认应该是限制访问。
这有助于防止网络钓鱼和类似的攻击，黑客试图通过操纵用户并获取他们的访问详细信息来访问您的系统。
会计经常被忽视，但是，它非常重要。这是关于记录所有访问数据的尝试(成功的和不成功的)，对用户帐户的任何更改(密码更改、权限更改等)。)，以及任何未经授权或有潜在风险的网络活动。目的是确保如果你真的有数据泄露，你确切地知道发生了什么，哪些数据受到了影响。
需要注意的是，仅仅因为某人对某个数据有访问权限，并不意味着他们被允许访问该数据。
在这种情况下，数据保护施加了比数据安全更严格的控制。例如，一名医生的接待员能够访问患者记录，但如果他们只是因为爱管闲事而决定随机检查他们朋友的记录，这将违反数据保护。
保护敏感数据
如页面上方的图片所示，一些数据被视为更加敏感。像这样的敏感数据必须特别安全地存储，防止任何未经授权的访问。
GDPR 规定，您的系统必须实现隐私设计，考虑到最先进的技术，以确保数据得到保护。HIPAA 在安全规则中给出了精确的指导。
我总是建议人们采取两个关键步骤来保护健康数据。首先，他们应该假名它。这意味着将个人详细信息和健康数据存储在不同的位置，并使用一个假名来连接它们。第二件事是使用一种强大的加密形式。如果您需要访问数据，您应该使用应用程序级加密(有时称为记录级加密)，这意味着每个用户的数据都使用唯一的密钥来保护。
如果您实际上不需要访问数据，您应该使用端到端加密。在这里，数据实际上是在终端设备上加密和解密的。
如果一切都出错了呢？
每家数字医疗公司都应该将数据安全和数据保护放在首要位置。如果你做错了，你将面临一系列的风险。
首先，如果发生任何数据泄露事件，公司会受到负面宣传的影响。在某些情况下，他们甚至会看到自己的名誉受到不可挽回的损害。
其次，对于初创公司来说，这种糟糕的公关会吓跑投资者，并可能危及你的生存。第三，你可能会收到巨额罚款。
例如，在 GDPR，罚款可达全球年营业额的 4%,在€可达 2000 万英镑，以较高者为准——我们已经看到€开出了超过 1 亿英镑的罚单。
HIPAA 还征收高达数百万美元的罚款(每份健康记录的丢失或被盗都是有代价的)。如果这还不够可怕，一些数据泄露使公司老板面临刑事指控的风险，特别是当涉及敏感数据时。
结论
希望您现在对数据保护和数据安全之间的区别有所了解。正如我上面解释的那样，数据安全就是保护任何类型的数据免受未经授权的访问。数据保护是指保护个人数据不被访问和滥用。只有具备良好的数据安全性，才能实现数据保护。然而，它也需要组织措施，如隐私政策和同意管理。在我写的关于这个话题的免费电子书中阅读更多。
来自《走向数据科学》编辑的提示: 虽然我们允许独立作者根据我们的 规则和指导方针 发表文章，但我们并不认可每个作者的贡献。你不应该在没有寻求专业建议的情况下依赖一个作者的作品。详见我们的 读者术语 。
走向无堡垒:使用会话管理器访问私有 EC2 实例
伊恩·巴塔格利亚在 Unsplash 上拍摄的照片
在本帖中，我们将设置一个私有 EC2 实例(在私有子网中)，并使用 SSM 会话管理器来访问托管 Jupyter 笔记本服务器的实例。然后，我们将通过 AWS 会话管理器使用 PostForwarding 从本地机器访问我们的服务器。
我们将在不打开入站端口或的情况下设置这个基础设施，设置堡垒主机或管理 SSH 密钥！。
为什么使用会话管理器？
众所周知，我们不能直接连接到一个私有 EC2 实例，除非有 VPN 连接或直接连接或其他与 VPC 的网络连接源。连接到 VPC 私有子网上的 EC2 实例的一种常见方法是使用一个 Bastion 主机。
堡垒主机是一种服务器，其目的是提供从外部网络(如互联网)到私有网络的访问。由于面临潜在的攻击，堡垒主机必须将渗透的机会降到最低。使用堡垒主机时，首先登录到堡垒主机，然后登录到目标私有实例。使用这种方法，只有堡垒主机会有一个外部 IP 地址。
然而，也有一些缺点:
- 您需要在您的堡垒中允许 SSH 入站规则
- 您需要在您的私有 EC2 实例上打开端口，以便将它连接到您的堡垒
- 您将需要管理您的用户的 ssh 密钥凭证:您将需要为每个用户生成一个 SSH 密钥对，或者为您的用户获得相同 SSH 密钥的副本
- 成本:bastion 主机也有相关的成本，因为它是一个正在运行的 EC2 实例。即使是一台 t2.micro 也要 10 美元/月左右。
堡垒主机架构，以便访问私有实例。使用 Lucid.app 设计
会话管理器可用于访问私有子网内不允许互联网进入的实例。AWS SSM 提供了通过其本地服务在您的系统上建立外壳的能力，或者通过将它用作其他协议的隧道，例如安全外壳(SSH)。优势:
- 它将记录会话期间发出的命令以及结果。如果您愿意，可以将日志保存在 s3 中。
- Shell 访问完全包含在身份和访问管理(IAM)策略中，您不需要管理 SSH 密钥
- 用户不需要使用堡垒主机和公共 IPs。
- 不需要打开安全组中的端口
先决条件
会话管理器插件
您需要为 AWS CLI 安装会话管理器插件，以便使用 CLI 启动和结束将您连接到受管实例的会话。
你可以点击这里查看如何为不同的操作系统安装插件！
网络结构
在创建 EC2 实例之前，您需要一个带有公共和私有子网的 VPC。由于将在我们位于私有子网的实例上托管一个 Jupyter 笔记本，它将需要互联网访问(，以便我们可以安装和更新 Python 包)。
为了让我们的私有子网访问互联网，我们将使用 NAT 网关。此外，为了启用 internet 连接，此网关确保 internet 不会启动与实例的连接。
将使用的网络配置如下所示:
网络配置。使用 Lucid.app 设计
您可以直接在 AWS 控制台上创建网络，也可以使用 Terraform 构建网络，您可以在此处查看 Terraform 代码。
配置您的 EC2 实例
我们的实例将部署在没有公共 IP 地址配置的私有子网上，因为我们不需要它。
为了允许会话管理器访问我们的实例，需要附加以下 IAM 角色:amazonsmsmanagedinstancecore。该策略授予实例核心 Systems Manager 功能所需的权限。
对于 VPC 安全组，我们不需要包含任何入站规则，只允许出站流量。
VPC 安全集团
EC2 实例
会话管理器—启动会话
完成所有设置后，您可以从命令行访问您的实例:
$ aws ssm start-session --target {YOUR_TARGET_INSTANCE_ID}
需要注意的是，连接是在没有打开 EC2 安全组的任何端口和没有 Bastion 主机的情况下成功建立的！
下图显示了我们正在使用的实际配置:
会话管理器架构。使用 Lucid.app 设计
会话管理器有内置的审计日志 : AWS 会话管理器默认提供审计日志；因此，根据必要的安全性和合规性规定，每个命令都被记录并存储在 CloudWatch 日志或 S3 存储桶中。
您还可以在控制台上拥有会话历史记录:
AWS 系统管理器控制台的屏幕截图。https://aws.amazon.com/console/?nc1=h_ls
会话管理器—端口转发
许多客户使用 SSH 隧道来远程访问不公开在公共互联网上的服务。基本上， SSH 客户端在一个已配置的端口上监听连接，当它接收到一个连接时，它通过隧道将该连接连接到一个 SSH 服务器。服务器连接到一个配置好的目的端口，可能与 SSH 服务器在不同的机器上。
在 OpenSSH 中，使用-L选项配置本地端口转发:
ssh -L 9999:localhost:8888 user@instance
这个例子以用户user的身份打开一个到instance的连接，打开本地计算机上的端口 9999，从那里转发所有东西到localhost:8888。
AWS 系统管理器会话管理器的端口转发允许您在私有子网中部署的实例之间安全地创建隧道，而不需要在服务器上启动 SSH 服务，打开安全组中的 SSH 端口，也不需要使用 bastion 主机。
端口转发以访问运行在私有实例上的 Jupyter 笔记本服务器
在这篇文章中，我们不会讨论如何在 EC2 实例上设置 Jupyter 笔记本服务器，但是你可以在这个链接上找到所有需要的信息。
满足先决条件后，您可以使用 AWS CLI 创建隧道:
$ aws ssm start-session --target {YOUR_TARGET_INSTANCE_ID} --document-name AWS-StartPortForwardingSession --parameters "portNumber"=["8888"],"localPortNumber"=["8888"]
截图来自 Jupyter 笔记本控制台，一个开源软件https://jupyter.org
OBS: 我在使用 Jupyter 笔记本服务器的时候，遇到了一个非常高的延迟问题；我想可能是因为会话管理器的端口转发。如果你正面临同样的问题，请留下你的评论。
结论
在这篇文章中，我们看到了如何使用会话管理器访问私有 EC2 实例，而不需要向实例安全组添加入站规则、管理 SSH 密钥以及使用另一个实例作为堡垒主机。我们还学习了如何使用会话管理器来使用 Post Forwarding。
这篇文章中使用的所有地形代码都可以在这里找到！
参考
堡垒主机是一种服务器，其目的是提供从外部网络到专用网络的访问，例如…
aws.amazon.com](https://aws.amazon.com/blogs/security/how-to-record-ssh-sessions-established-through-a-bastion-host/) [## 使用会话管理器连接 EC2 私有实例-无堡垒
Savings Plan 是一种新的灵活的 AWS 模型，用于节省使用计算服务的费用。它适用于 EC2 服务…
www.1cloudhub.com](https://www.1cloudhub.com/connect-ec2-private-instance-using-session-manager-go-bastion-less/) [## 离开堡垒主机第 2 部分:AWS - Netskope
引言这篇文章是一个系列的第二篇，关于在每个主要的云…
www.netskope.com](https://www.netskope.com/blog/leaving-bastion-hosts-behind-part-2-aws) [## 什么是 AWS NAT 网关？
NAT 网关，也称为网络地址转换网关，用于启用私有子网中的实例…
www.knowledgehut.com](https://www.knowledgehut.com/tutorials/aws/aws-nat-gateway) [## SSH 端口转发-示例，命令，服务器配置
SSH 端口转发是中的一种机制，用于将应用程序端口从客户端机器隧道传输到服务器机器，或…
www.ssh.com](https://www.ssh.com/ssh/tunneling/example) [## 使用 AWS 系统管理器会话管理器| Amazon Web Services 的新端口转发
我越来越多地看到客户采用不可变的基础架构模式:他们重建和重新部署一个…
aws.amazon.com](https://aws.amazon.com/es/blogs/aws/new-port-forwarding-using-aws-system-manager-sessions-manager/) [## 使用 AWS Systems Manager 会话管理器| Ibexlabs 改进系统管理
会话管理器是 AWS 的完全托管系统管理器服务中的一项功能，它允许您连接您的 EC2…
www.ibexlabs.com](https://www.ibexlabs.com/improving-systems-management-with-aws-systems-manager-session-manager/)
超越 99% — MNIST 手写数字识别
了解如何通过各种技术优化神经网络，以达到人类水平的性能。
MNIST 手写数字数据集被认为是计算机视觉的“Hello World”。大多数神经网络的标准实现在正确分类手写数字方面达到了 98-99%的准确率。
除了这个数字，每增加一个小数都很难提高准确率。让我们看看如何通过高级优化推动模型预测准确率超过 99%。
MNIST 手写数字数据集(来源:维基百科)
注意到
MNIST 数据集由 60，000 个训练样本和测试集中的 10，000 个样本组成。对于那些想在真实世界数据上学习技术和模式识别方法而不需要在数据预处理方面花费太多精力的人来说，这是一个很好的数据集。
由于本文的目的是学习优化方法来提高我们的分类器的准确性，我们将数据集重新分组为 48，000 个训练示例和 28，000 个测试示例，以减少可用于训练的数据，如 Kaggle 所做的那样，并使问题变得更难。
图像预处理
通过从每个像素中减去训练集的平均活性并除以它们的标准偏差，对所有图像进行标准化。众所周知，每幅图像都由 0 到 255 之间的像素值组成。如果没有标准化，原始像素值在输入到网络中时会由于不稳定的输入特性而减慢学习速度。
# Standardization
# Vector 'X' contains all the training examples. mean_px = X.mean().astype(np.float32)
std_px = X.std().astype(np.float32)
X = (X - mean_px)/(std_px)
归一化图像有助于学习算法更快地收敛
模型
LeNet-5 (LeCun et al .，1998)没有从零开始建立模型。基于梯度的学习应用于文档识别)卷积神经网络被用作基线标准模型。
LeNet-5 架构，LeCun 等人，1998 年。"基于梯度的学习应用于文档识别"
这是一个简单的模型，由一个卷积层和两个 max-pooling 层组成，后面是两个完全连接的层，最后是十个类的 softmax。
经过 30 个周期的训练，训练正确率为 99.98%，设定正确率为 99.05%。对于一个 1998 年发布的模型来说，准确性似乎相当不错。然而，该模型同时存在高方差和高偏差问题，测试集准确率低于 98.74%。让我们逐一解决这两个问题。
贝叶斯错误率是任何分类器的最低可能错误率。
拟合不足的代表
过度拟合的代表
作为参考，可避免的偏差代表模型对数据的欠拟合，而方差代表过拟合。当我们微调模型时，我们的目标是最小化这两者。
数据集中的一些图像非常模糊，因此，假设贝叶斯误差不是 0%，而是在(0.2–0.3)%左右。
模糊图像的例子
减少方差
- 数据扩充 —训练集中的一些图像在两个方向上随机旋转 10 度，缩放 10%，并在两个方向上移动 10%。
直觉 —它有助于显著降低模型的方差，因为模型也看到了一些不规则的手写数字。 - L2 正则化 —在某些卷积层中使用了超参数为 0.005(λ)的正则化。
直觉 —在下面我们神经网络的损失函数的方程中，通过增加第二项，我们对损失函数的惩罚更多。较高的损失导致权重相对较小，这“简化”了模型以减少过度拟合。
通过调整超参数“lambda”(在我们的例子中为 0.005)，惩罚损失函数
- 漏失规则化 —在汇集层和一些全连通层之后增加了三个超参数为 25%的漏失层。
直觉——通过在训练时随机丢弃 25%的神经元，我们试图通过简单地不过度依赖任何特定神经元来产生输出，让网络更好地泛化。
Srivastava，Nitish 等人，“辍学:防止神经网络过度拟合的简单方法”，JMLR，2014 年
- 批量归一化 —在我们的情况下，它在每组层(ConvNet + MaxPool &完全连接)之后执行，以稳定网络并使学习算法更快收敛。
直觉 —类似于标准化数据集中的图像，标准化各层的激活“减少”隐藏单元之间的移动，并允许各层独立地学习更多内容。
通过减去平均活动并除以方差来归一化图层的输出
- 可变学习率 —当学习率可变时，性能显著提高。一旦模型检测到它的学习“停滞”,在我们的例子中，在等待两个时期后，学习率下降了 0.2 倍。
直觉——通过动态降低学习率，帮助算法更快收敛，更接近全局最小值。
variable_learning_rate = ReduceLROnPlateau(monitor=’val_loss’, factor = 0.2, patience = 2)
处理偏差
处理偏差相对简单，因为网络在训练集上表现很好。为了将训练集的准确度提高到 99.6%以上，使用了以下技术。
- 更多层 —最初的 LeNet-5 网络由两个卷积层组成。在新网络中，增加了两个具有相同超参数的卷积层。
- 深层网络 —卷积层中的滤波器数量显著增加，从前两层的 6 个增加到 32 个，后两层的 16 个增加到 64 个。由于卷积层体积的增加，隐藏在密集层中的数量也增加，以容纳更大的输入。
直觉——更深更密的网络让模型可以学习手写数字更复杂的特征。
将所有这些放在一起
让我们把所有东西组装成一个模型。为此，我使用了 Keras 来构建模型，但是也可以使用其他框架。
总而言之，我们使用两个卷积层，然后是两次池化层(一次分别有 32 个过滤器和 64 个过滤器)和三个全连接层，最后有 10 个类的 softmax 单元。批处理规范化，L2 正则化和辍学是在层间完成的，如下面的代码所示。
我们改良的 LeNet-5
model = Sequential([# Layer 1
Conv2D(filters = 32, kernel_size = 5, strides = 1, activation = ‘relu’, input_shape = (32,32,1), kernel_regularizer=l2(0.0005)),# Layer 2
Conv2D(filters = 32, kernel_size = 5, strides = 1, use_bias=False),# Layer 3
BatchNormalization(),# — — — — — — — — — — — — — — — — #
Activation(“relu”),
MaxPooling2D(pool_size = 2, strides = 2),
Dropout(0.25),
# — — — — — — — — — — — — — — — — ## Layer 3
Conv2D(filters = 64, kernel_size = 3, strides = 1, activation = ‘relu’, kernel_regularizer=l2(0.0005)),# Layer 4
Conv2D(filters = 64, kernel_size = 3, strides = 1, use_bias=False),# Layer 5
BatchNormalization(),# — — — — — — — — — — — — — — — — #
Activation(“relu”),
MaxPooling2D(pool_size = 2, strides = 2),
Dropout(0.25),
Flatten(),
# — — — — — — — — — — — — — — — — ## Layer 6
Dense(units = 256, use_bias=False),# Layer 7
BatchNormalization(),# — — — — — — — — — — — — — — — — #
Activation(“relu”),
# — — — — — — — — — — — — — — — — ## Layer 8
Dense(units = 128, use_bias=False),# Layer 9
BatchNormalization(),# — — — — — — — — — — — — — — — — #
Activation(“relu”),
# — — — — — — — — — — — — — — — — ## Layer 10
Dense(units = 84, use_bias=False),# Layer 11
BatchNormalization(),# — — — — — — — — — — — — — — — — #
Activation(“relu”),
Dropout(0.25),
# — — — — — — — — — — — — — — — — ## Output
Dense(units = 10, activation = ‘softmax’)])
结果
该模型被训练 30 个时期，并给出以下结果。
- 训练准确率达 99.82%
- 开发设置准确率为 99.62%
- 测试集准确率为 99.41%
包裹
提到的优化极大地有助于推动模型的准确性突破 99%的大关。
我们可以注意到，随着测试集中精度的下降，仍然有一些过度拟合的迹象。请随意尝试，并尝试进一步减少差异。如果你认为还有其他方法可以改进模型，请留下评论。
所有的代码和结果都可以在 GitHub 这里找到。
参考
[1] LeCun 等，基于梯度的学习应用于文档识别 (1998)，IEEE 学报，1998 年 11 月
[2]吴恩达等人，改进深度神经网络:超参数调整、正则化和优化，Coursera 课程
[3] Y. Ghouza，CNN Keras 简介— 0.997(前 6%) (2017)，Kaggle 数字识别器竞赛
[4] Srivastava，Nitish 等人，辍学:防止神经网络过度拟合的简单方法，(2014) JMLR
从 Stata 到熊猫
开始、探索和可视化。专为熟悉或曾经熟悉 Stata 的人设计的指南。
由三部分组成的单一指南，概述
本指南是为想开始学习熊猫的 Stata 用户准备的。它是使用 Stata 用户熟知的示例和工作流编写的。此外，本文引用了许多 Stata 用户都知道的数据。
在本指南的第 1.1 部分中，我回顾了 Stata 用户可能希望开始探索使用 Python 和 Pandas 的各种原因。
在下一节，即第 1.2 部分，我将演示交叉列表和汇总统计，它们将帮助您开始数据探索过程。
最后，在第 1.3 部分中，我举例说明了各种简单的可视化方法，它们将帮助您继续数据探索过程。
第 1.1 部分:所以，您安装了 Python 和 Pandas，但是您不确定接下来的步骤。
Stata 和 Pandas 都为数据操作、可视化、统计等提供了完整(或接近完整)的平台。Stata 声称是…
一个完整的集成软件包，可满足您的所有数据科学需求，包括数据操作、可视化、统计和可再现的报告。(stata.com
熊猫声称是…
一个开源、BSD 许可的库，为 Python 编程语言提供高性能、易于使用的数据结构和数据分析工具。(【pandas.pydata.org】T4)
Stata 用户可能想学习熊猫的原因
Stata &熊猫营销图片。
一个合作者正在使用熊猫。你是 Stata 用户，但你合作的研究小组不是。他们用熊猫。在同一个沙盒里，你决定学习熊猫。
你已经决定要扩展你的技能。准备好迎接新的挑战了吗？也许你读过 Stata 书店的几本书。您已经创建并发布了用户编写的程序(Stata 用户称之为包)。也许你甚至已经在波士顿学院统计软件组件(SSC)档案库发布了一个或多个程序到用户社区的首选存储库中。很明显，你已经准备好扩展你的技能了。
您无法访问 Stata。或者你预期失去 Stata 的访问权。Stata 是专有的，它的许可费用很高。如果你已经失去或预计失去访问 Stata 的权限，并且你对为自己购买许可证不感兴趣(尽管它很有价值)，Pandas 是一个不错的选择。
其他原因。为什么一个 Stata 用户可能想学习熊猫并不重要。本指南是一个不可知论的指南，承认两种语言各有优缺点。在我的工作中，我经常发现一个人继承另一个人留下的东西。
本指南假设您已经安装了 Python 和 Pandas
为了避免重新发明轮子，本指南除了建议 Stata 用户考虑安装用于科学研究的 Anaconda 发行版之外，不讨论 Python 或 Pandas 的安装。
本指南中给出的示例和解释已经使用 Anaconda 发行版进行了测试。具体来说，这里给出的例子是在 Jupyter 笔记本中创建的，这是 Python 的 Anaconda 发行版中包含的软件。
使用 Stata 著名的汽车数据集示例。我之前已经讨论过这个数据集，它对于测试或训练是有用的。在 Jupyter 笔记本中加载该数据集通常会是这样的:
运行 Python 3 内核的 Jupyter 笔记本。使用 Stata 示例汽车数据集的熊猫插图。
接下来在第 1.2 部分，我将演示交叉列表和汇总统计，这将帮助您开始数据探索过程。在最后一节，第 1.3 部分，我将演示简单的可视化，让您继续数据探索过程。
第 1.2 部分:安装 Python 和 Pandas 之后，接下来是您的步骤。
加载自动数据集
在 Stata 中加载汽车数据集很容易:sysuse auto。在 Python 中，这个过程可以分两行完成。但是为了使代码更易读，我把它分成三行:
import pandas as pdauto = 'http://www.stata-press.com/data/r15/auto2.dta'
df = pd.read_stata(auto)
就是这样！简单。如果你是一个新的熊猫用户，如果你正在跟随祝贺！您已经将第一个数据集加载到内存中。
你会注意到的第一件事是，在 Python 中工作，很少有“输出”输出是语言提供的信息，用来帮助验证命令是否完成了您想要它做的事情。关于这方面的更多信息，请参见我的相关文章合并数据:熊猫丢失输出。
在 Python 中，这种反馈要少得多。验证您是否正确加载了汽车数据集。试试代码df.head()大致相当于 Stata 的list in 1/5。以下是您应该看到的内容:
运行 Python 内核的 Jupyter 笔记本。使用 Stata 汽车数据集的熊猫插图。
交叉制表
交叉列表法是最简单的分析技术之一。这种技术包括将两个或多个分类变量之间的出现次数制成表格。
Stata 的局限性在于，涉及两个或三个以上分类变量的交叉列表是有限的。对熊猫来说，三个或更多种类是没有问题的。
与汽车数据集的双向列表:
pd.crosstab(df['rep78'], df['foreign'])
运行 Python 内核的 Jupyter 笔记本。两个变量(维修记录和制造来源)的交叉列表。使用 Stata 汽车数据集的熊猫插图。
仔细看，这个表格遗漏了一些数据。为了让 Stata 在其交叉表中包含缺失的数据，跟在tab命令后面的mi选项将提供更完整的数据视图。把它放在一起，在 Stata 它会是tab foreign rep78, mi。
在 Pandas 中，需要两行来显示更完整的数据视图:
# Specify a new category among the repair records.
df['rep78'].cat.add_categories('No Record', inplace=True)# Generate a tabulation using the fillna() method.
pd.crosstab(df['foreign'], df['rep78'].fillna('No Record'))
运行 Python 内核的 Jupyter 笔记本。两个变量的交叉列表(维修记录和制造来源，包括缺失数据)。使用 Stata 汽车数据集的熊猫插图。
汇总统计数据
Stata 中的汇总统计并不复杂。查看连续变量的最快方法之一是键入sum。通过汽车数据集，您可以:
Stata 汽车数据集的汇总统计数据。
在 Pandas 中，最接近这种输出的命令是df.describe().transpose()，它将给出:
运行 Python 内核的 Jupyter 笔记本。跨行显示变量名的汇总统计信息，沿列显示统计信息。使用 Stata 汽车数据集的熊猫插图。
大多数 Pandas 用户会使用df.describe()，它在输出的顶部显示变量名，在每行显示统计数据。作为一名 Stata 用户，我添加了transpose()方法，该方法旋转输出以更好地匹配我习惯的 Stata 惯例。
另外，熊猫的默认输出也给出了第 25、50 和 75 个百分点。当然，第 50 百分位是最有用的中间值。Stata 的默认输出中没有提供这些额外的统计数据。
如果你正在跟随并且感觉冒险，通过执行以下来测试你的直觉:
df[['price','mpg','foreign']].groupby('foreign').describe()
看看你是否能正确预测输出会是什么。此外，努力调整代码以进行定制，以便您可以探索价格(price)或里程数(mpg)之外的其他变量。
接下来的第 1.3 部分演示了各种简单的可视化，让您可以继续数据探索过程。
第 1.3 部分:交叉列表和总结数据后，进行简单的可视化。
直方图和散点图得到升级
我最喜欢在熊猫而不是 Stata 中进行数据探索的一个部分是散点图和直方图的组合——在同一个图中。
直方图一次显示一个变量的分布。散点图说明了两个或多个变量之间的关系。
Pandas 提供了对 jointplot 的访问，它将散点图和直方图的优点结合成一个。再次使用 Stata 的汽车数据集:
import pandas as pd
import seaborn as sns
%matplotlib inlineauto = 'http://www.stata-press.com/data/r15/auto2.dta'
df = pd.read_stata(auto)sns.jointplot(x='weight',y='mpg',data=df, kind='scatter')
运行 Python 内核的 Jupyter 笔记本。说明英里数(mpg)和汽车重量(以磅为单位)之间关系的联合图。使用 Stata 汽车数据集的熊猫插图。
这个可视化探索了里程(在纵轴 y 上以每加仑英里数表示)和车辆重量(在 x 轴上以磅数表示)之间的关系。与直觉和一般理解一致，可视化表明，随着车辆重量增加，车辆里程减少。
这个连接图显示了这两个变量(体重和 mpg)之间的关系，以及这些变量的分布情况。作为一个额外的奖励，这个可视化显示了这两个变量的皮尔逊相关系数及其 p 值。
配对图
此外，pairplot 可以方便地比较数据集内的许多变量。配对图提供了散点图矩阵，类似于典型的相关矩阵。下面将比较里程(mpg)、重量(weight)、长度(length)、价格(price):
sns.pairplot(df[['mpg','weight','length','price']])
运行 Python 内核的 Jupyter 笔记本。说明里程(mpg)、重量(weight)、长度(length)和价格(price)之间关系的 Pairplot。使用 Stata 汽车数据集的熊猫插图。
为了增加分类比较，这里我们将比较国外制造和国内制造，我们可以调整代码以包括几个附加参数:
sns.pairplot(df[['mpg','weight','length','price','foreign']],
kind='scatter', plot_kws={'alpha': 0.5},
hue='foreign')
运行 Python 内核的 Jupyter 笔记本。说明里程(mpg)、重量(weight)、长度(length)和价格(price)之间关系的 Pairplot。在这个可视化中，我们还比较了国外和国内的制造来源。使用 Stata 汽车数据集的熊猫插图。
在添加了额外的论点之后，这些论点产生了一种视觉效果，可以让你比较国内制造的车辆和国外制造的车辆，新的模式开始出现，这可能会为进一步的分析提供信息。
作为一个媒体会员，你的会员费的一部分会给你阅读的作家，你可以完全接触到每一个故事…
adamrossnelson.medium.com](https://adamrossnelson.medium.com/membership)
结论
本文分为三个部分，旨在帮助 Stata 用户考虑如何过渡到 Python 和 Pandas。如果目标不是过渡，本指南将帮助 Stata 用户开始学习一种新工具，可以补充您在 Stata 中正在进行的工作。Stata 和熊猫各有优缺点。
在最基本的层面上，一旦你对 Stata 的熟练程度达到了中级或更高级，那么通过学习 Python 和 Pandas 来增加你的技能是值得的。本文展示了将帮助您开始数据探索过程的技术。
第 1.1 部分回顾了 Stata 用户可能希望开始探索使用 Python 和 Pandas 的各种原因。第 1.2 和 1.3 部分演练了使用 Stata 流行的汽车数据集进行数据探索、分析和可视化的基本示例。
感谢阅读
感谢阅读。把你的想法和主意发给我。你可以写信只是为了说声嗨。如果你真的需要告诉我是怎么错的，我期待着尽快和你聊天。推特:@ adamrossnelsonLinkedIn:亚当罗斯尼尔森。
通过网络搜集职位空缺，找到我在数据科学世界中的位置。
发现自己在数据科学中，在数据科学中。
这是一个有趣的练习，包括对招聘信息和由 tf-idf 和 t-SNE 主演的简历进行文本分析，以找到最适合我的工作角色。
关于许多“数据科学”职位的实际工作由什么组成，存在相当大的争议。作为一名数据科学家，看到从分析师到科学家再到工程职位的招聘信息会感到非常困惑，因为实际的职位描述可能与你对该职位的理解大相径庭。这场不匹配给我带来了毕业时的生存危机和此后许多不眠之夜。我是数据科学家吗？…一个机器学习工程师？
我属于数据科学吗？
结合这一事实，许多公司不知道他们真正想雇用什么样的数据专业人员，你就会明白为什么数据科学的工作描述可以无处不在。
我的目标很简单。我能在网上搜集招聘信息，按标题分类，然后看看我是否能得到一些有意义的可视化信息，告诉我自己在这个领域的最终位置吗？我能找到属于我的地方吗？
第一幕——一个网络掠夺者的故事
首先，我收集了数据科学的职位名称。为了增加趣味，我还加入了统计学家和定量分析师。下面的列表并不完整，它包含了我搜集到的条款:
- 数据科学家
- 数据工程师
- 数据分析师
- 机器学习工程师
- 统计员
- 定量分析师
- 研究科学家
显然这是一个有点缺陷的列表。还有很多标题，我的选择有点武断。前五个是相对常见的术语，而后两个稍微不常见。我决定坚持使用这些作为概念验证，我很乐意在评论中听到你的建议。
我决定用 python 库请求和 beautifulsoup 抓取 indeed.com 是我最好的选择。在浏览了网站并摆弄了用户界面后，我想我应该先收集个人职位描述的链接，然后一个一个地查找。
上面的代码片段首先收集可用描述的数量，并一次收集 50 个链接。因为 Indeed.com 会自动将你与不相关或半相关的职位进行匹配，所以我做了一个检查，只在职位名称实际上是职位发布的一部分时才继续。对 storedescription()的调用只抓取实际的工作描述，并将其存储到一个文本文件中。
我将跳过一些细节，但最重要的是，它给了我一个职位列表和几个包含纯文本职位描述的文件夹。在这七个文件夹之间，我有 577 个文本文档。
每个职位一个文件夹。
第二幕——理解招聘启事
兴奋地，我打开了其中一个招聘启事。承蒙美声组的帮忙，文本基本没问题，但仍有一些有限的预处理要做。一些句子的结尾变坏了，这是一个应该在标记化之前解决的问题。
从 Indeed.com 收集的示例描述(原始)
为了清理这一点，我添加了一个快速和肮脏的预处理脚本。
我有点担心如何进行。我想用 t-SNE 将描述绘制成类。我经常处理高维数据，但通常是以单词嵌入和张量的形式。又长又稀疏的向量让我害怕。如果我只为每个文档取一个简单的单词包向量，我将有一个巨大的向量，这可能会很麻烦。使用 tf/idf 可能会缓解一些常见术语的问题，但不会降低我的数据的维度。我想我会继续使用 SVD ，但是感觉应该有一个更简单的途径来实现我想要的可视化。
然后我找到了 Yellowbrick ，这是一个用于机器学习可视化的库，旨在补充 Scikit-Learn。使用 Yellowbrick，我可以在一行中完成奇异值分解和 t-SNE，如下所示:
这导致基于 577 个文档(= 577 个职位发布)的以下可视化
看哪！一个直接来自笔记本的 SNE 霸王龙图。
为了清楚起见，我把这些类的名字编辑成了下图。
同样的图，聚类标记为。名字大致放在各组集中的位置上。
这说明了什么是相当惊人的。统计学家几乎都聚集在一起，偶尔有数据科学家或分析师也在附近。有趣的是，研究科学家作为一个相邻的集群是明显可识别的。这表明这些工作可能是相当相关的，但仍然有足够的不同，可以被视为独立的集群。去研究科学家吧！
这几乎就像一个光谱。中间地带由数据分析师占据，他们在统计学家和数据科学家之间架起了一座桥梁。数据科学家和数据工程师相当混杂，其中工程师有一些巩固的基础。机器学习工程师似乎比数据科学家更关注数据工程师。数据科学家的小集群出现在边缘，这可能表明数据科学的不同风格。说真的，数据科学家这个角色似乎无处不在。
定量分析师在地图边缘形成他们自己的集群。这是意料之中的，因为它是一个相当独特的利基市场。有趣的是，一些分析师和科学家加入了他们的行列。这可能表明，那些寻找定量分析师职位的人也应该考虑看看数据科学和数据分析师的职位。
第三幕——我属于哪里？
风景很清晰，但我属于哪里？因为我已经有了招聘信息的文本描述作为我的数据，所以我真正需要的是把我的简历放在一个类似的纯文本格式中，并把它添加到一个文件夹中。然后，我可以简单地再次运行脚本来找出我在哪里。
我为“杰弗里”班做了一个文件夹存放我的简历。
不幸的是，有一个与 t-SNE 相关的随机元素，当我再次运行脚本时，我无法重现相同的情节。然而，数据的大致方向应该相同。也就是说，集群应该出现在相对于彼此或多或少相同的位置，但是在不同的方向和位置。
快速重新运行脚本显示，我的简历夹在数据工程、机器学习工程和数据科学家之间。也许在工程方面会多一点。我的简历上有几个软件工程实习和项目，所以这有一定的意义。不幸的是，我正好处在所有不同学科之间的争议区域的中间。最近的邻居是几个数据科学空缺，两个 ML 工程空缺，并在一群数据工程师附近。
暂时就这样了。如果你想看看我用的笔记本，你可以在这里找到。我还没有上传我搜集的文本数据，所以你得自己收集。我很喜欢写这个有趣的练习，也很感谢你在下面的反馈。当然，这与“适当的”方法相去甚远，我建议如果你重现它，不要太在意结果。
Good Grams:如何为您的问题找到预测性的 N-Grams
找出哪些单词对你的问题有预测性是很容易的！
图片来源:肯德里克·米尔斯
介绍
如今，NLP 感觉就像是应用 BERT 并获得关于你的问题的最先进的结果。很多时候，我发现抓住一些有用的信息词汇也会有所帮助。通常，我会让一个专家来找我，说这五个词对这门课很有预测性。然后我会用这些词作为特征，瞧！你得到了一些性能上的改进或者更多的可解释性。但是如果你没有领域专家，你会怎么做呢？我喜欢尝试的一件简单的事情是在 TF-IDF 特性上训练一个简单的线性模型，并取前 n 个单词或 n-grams:)。
在这篇博文中，我们将:
- 使用 SciKit-Learn 训练一个简单的模型，获得最丰富的 n-gram 特征
- 然后在具有不同数量特性的模型上运行一些性能比较。
希望在本教程结束时，您将拥有一个有趣的新工具来揭示文本分类的良好特性。让我们开始吧。
TLDR
使用 SciKit-Learn 的 TfidfVectorizer 上的线性分类器，然后按权重对特征进行排序，取最上面的n。您还可以使用 TfidfVectorizer，通过使用词汇参数来为您的模型提取 n 元语法的子集。
动机
对文本进行分类的一个非常成功的方法是寻找与问题相关的预测词或短语。在说电影评论情绪的上下文中，我们可以查找单词“好”、“优秀”、“伟大”或“完美”来找到好的评论，而“坏”、“无聊”或“糟糕”来找到坏的评论。作为好的和坏的电影评论的主题专家，我们很容易想出这些特征。
通常情况下，我不是一个主题专家，对我来说很难确定什么是好的预测词或短语。当这种情况发生时，我已经标记了数据，有一个快速的方法来找到描述性的单词和短语。只需训练一个线性模型，进行权重排序！
训练一个简单模型
SciKit-Learn 使得训练线性模型和提取相关权重变得非常容易。让我们来看看在 IMDB 情感数据集上训练一个模型。
df = pd.read_csv("IMDB_Dataset.csv")
df["split"] = np.random.choice(["train", "val", "test"], df.shape[0], [.7, .15, .15])
x_train = df[df["split"] == "train"]
y_train = x_train["sentiment"]
x_val = df[df["split"] == "val"]
y_val = x_val["sentiment"]classifier = svm.LinearSVC(C=1.0, class_weight="balanced")
tf_idf = Pipeline([
('tfidf', TfidfVectorizer()),
("classifier", classifier)
])tf_idf.fit(x_train["review"], y_train)
这个模型只需要几秒钟的训练时间，但是只用单字就可以得到相当不错的 F 值 0.88。
有了这个新模型，我们只需从 TF-IDF 转换器中获取系数名称，从 SVM 中获取系数值，就可以找到最具预测性的特征。
coefs = tf_idf.named_steps["classifier"].coef_
if type(coefs) == csr_matrix:
coefs.toarray().tolist()[0]
else:
coefs.tolist()feature_names = tf_idf.named_steps["tfidf"].get_feature_names()
coefs_and_features = list(zip(coefs[0], feature_names))# Most positive features
sorted(coefs_and_features, key=lambda x: x[0], reverse=True)# Most negative features
sorted(coefs_and_features, key=lambda x: x[0])# Most predictive overall
sorted(coefs_and_features, key=lambda x: abs(x[0]), reverse=True)
通过访问管道中名为 step 的“分类器”,我们可以获得模型赋予每个特征的权重。创建管道时，我们命名流程中的每一步，这样我们就可以用这个named_steps函数来访问它们。大多数 SciKit-Learn 模型都有一个.coef_参数，该参数将返回模型的系数，我们可以用它来找到最具预测性的模型。为了方便起见，我对稀疏矩阵做了一些类型检查，因为这些类型的词法特征可能非常非常稀疏。特征名存储在我们管道的tfidf步骤中，我们以与分类器相同的方式访问它，但是调用get_feature_names函数。
我们的十大积极词汇是:
[(3.482397353551051, 'excellent'),
(3.069350528649819, 'great'),
(2.515865496104781, 'loved'),
(2.470404287610431, 'best'),
(2.4634974085860115, 'amazing'),
(2.421134741115058, 'enjoyable'),
(2.2237089115789166, 'perfect'),
(2.196802503474607, 'fun'),
(2.1811330282241426, 'today'),
(2.1407707555282363, 'highly')]
我们的十大负面词汇是:
[(-5.115103657971178, 'worst'),
(-4.486712890495122, 'awful'),
(-3.676776745907702, 'terrible'),
(-3.5051277582046536, 'bad'),
(-3.4949920792779157, 'waste'),
(-3.309000819824398, 'boring'),
(-3.2772982524056973, 'poor'),
(-2.9054813685114307, 'dull'),
(-2.7129398526527253, 'nothing'),
(-2.710497534821449, 'fails')]
使用我们的“好”功能
既然我们已经发现了一些“好”的特征，我们可以构建更简单的模型，或者在类似领域的其他问题中使用这些特征。让我们建立一些简单的规则，如果这些预测词中的任何一个出现在评论中，将返回 1，否则返回 0。然后仅用这 20 个特征重新训练模型，看看我们做得如何。
为了做到这一点，我创建了一个简单的 SciKit-Learn 转换器，它将 n-grams 列表转换为 regex 规则，NLTK 的 tokenizer 可以搜索这些规则。不是超级快(那是轻描淡写，真的很慢。您应该使用 TfidfVectorizer 中的词汇参数，后面会有更多介绍。)但是它很容易阅读并完成工作。
这段代码有三个主要部分。
第 11 行将一个表示 n-gram 的元组(比如(" good "、" movie ")转换成一个 regex r "
第 13–26 行通过遍历输入中的每一个句子，或者在本例中进行回顾，并将每个正则表达式应用于该句子，来执行转换。如果正则表达式找到了什么，它会在列表中与触发的 n-gram 对应的位置放置一个 1。这将产生一个带有 1 和 0 的向量，表示哪个 n 元语法出现在哪个句子中。
第 28–29 行允许我们像以前一样获取相关的特性名称。只是方便而已。
有了这个新的便捷的转换器，我们可以使用前十个最好的和后十个最差的单词来重新训练我们的模型。
n_grams = [('excellent',), ('great',), ('perfect',),
('best',), ('brilliant',), ('surprised',),
('hilarious',), ('loved',), ('today',),
('superb',), ('worst',), ('awful',),
('waste',), ('poor',), ('boring',),
('bad',), ('disappointment',), ('poorly',),
('horrible',), ('bored',)]
classifier = svm.LinearSVC(C=1.0, class_weight="balanced")
rules = Pipeline([
('rules', RuleTransformer(n_grams)),
("classifier", classifier)
])rules.fit(x_train["review"], y_train)
这 20 个特征使我们的 F1 减少了大约 0.13，这看起来很多，但是我们只使用了最初的 65，247 个单词的 0.03%。这真是太棒了！这 20 个特征编码了我们数据中的大部分信息，我们可以将它们用作其他管道中的特征！
用于规则提取的 TfidfVectorizer
我在上面构建了规则矢量器，但是我们可以通过使用 tfidf 矢量器并传入一个词汇表参数来获得相同的结果。最初的 SciKit-Learn 矢量器接受一个名为“词汇”的参数，该参数接受一个将单个单词或由空格分隔的 n 元语法映射为整数的字典。为了获得相同的效果，我们可以运行:
top_feats = sorted(coefs_and_features,
key=lambda x: abs(x[0]),
reverse=True)[:20]
vocab = {x[1]: i for i, x in enumerate(top_feats)}
TfidfVectorizer(vocabulary=vocab)
这里我们得到了特性的排序列表，然后我们创建了一个从特性名称到整数索引的映射，并将其传递给矢量器。如果你对地图的样子很好奇，大概是这样的:
{"great": 0,
"poor": 1,
"very poor": 2,
"very poor performance": 3}
n-gram 是通过在单词之间添加一个空格来表示的。如果我们使用上面的代码代替我们的 RuleTransformer，我们将在很短的时间内得到相同的结果。
要取多少特征？
这 20 个字似乎很有力量。他们可以从一开始就为我们提供 79 F1，但也许 20 不是正确的功能数量。我们可以通过对越来越多的顶级功能运行我们的分类器并绘制 F1 来找出答案。
这向我们表明，在大约 13k 的最具预测性的词之后，该模型开始收敛到最佳 TF-IDF 单字性能。因此，我们只需 20%的原始功能集就能获得相同的性能！继续使用这些 13k 功能是一个更有原则的数字，我们仍然可以大幅减少原始功能的数量。
结论
如果我们纯粹着眼于词汇特征、特定单词及其数量，那么这可能是发现有用单词和短语的好方法。语言远比你使用的词语要复杂得多。在设计实际系统时，查看各种信息很重要。使用 BERT，使用句法特征，比如句子是如何分析的。语言不仅仅是生字，还有很多东西，但是希望这个小技巧可以帮助你在遇到困难的时候找到一些好的单词。
好的管道，坏的数据
如何开始信任你公司的数据？
由 Unsplash 上的 Element5 数码拍摄
现在是 2020 年，我们仍在使用“照片和书面记录”来验证数据。在最近的 爱荷华州选举 中，数据不一致侵蚀了对结果的信任。这只是许多最近的、突出的、无孔不入的例子之一""
*数据宕机指的是数据不完整、错误、丢失或不准确的一段时间，我所知道的几乎每个数据组织都在与之作斗争。事实上，这篇*【HBR】的文章 引用了一项研究，该研究发现，由于糟糕的数据，公司平均每年损失 1500 万美元。在这篇博文中，我将介绍一种管理数据停机时间的方法，这种方法已经被业内一些最好的团队所采用。
那么，衡量数据停机时间意味着什么呢？
为了解开这个谜团，我们先来看看什么叫做“停机时间”。数据宕机指的是数据“停机”的任何时间，即数据团队发现自己对常见问题的回答是“不”的时候，这些问题包括:
- 该报告中的数据是最新的吗？
- 数据是否完整？
- 字段是否在合理范围内？
- 我对上游来源的假设仍然成立吗？
- …以及更多
或者换句话说… 我能相信我的数据吗？
实时回答这些问题很难。
大大小小的数据组织都面临着这些问题，因为(1)跨数据管道持续跟踪这些信息需要大量资源；(2)在最好的情况下，信息被限制在已经被费力地装备的数据的一个小的子集；以及(3)即使在可用的情况下，筛选这些信息也是非常乏味的，以至于团队经常事后才发现数据问题。
事实上，数据消费者(产品经理、营销专家、高管、数据科学家甚至客户)通常会在需要使用数据的时候发现数据宕机。不知何故，这总是发生在周五下午晚些时候…
为什么我们对数据基础设施的性能了如指掌，却对数据是否正确知之甚少？
这里一个有用的推论是借鉴基础设施可观测性的世界。几乎每个工程团队都有工具来监控和跟踪基础设施，并保证其按预期运行。这通常被称为可观察性——根据输出来确定系统健康状况的能力。
优秀的数据团队在数据可观察性方面进行投资，即确定系统中的数据流是否健康的能力。可观察性带来了在问题影响数据消费者之前检测问题的机会，然后在几分钟内查明并修复问题，而不是几天或几周。
那么，是什么造就了伟大的数据可观测性呢？根据 100 多个数据团队的经验，我们确定了以下几点:
每个支柱都包含一系列问题，这些问题总体上提供了数据运行状况的整体视图。
- 新鲜度:数据是最近的吗？最后一次生成是什么时候？包含/省略了哪些上游数据？
- 分布:数据是否在可接受的范围内？格式是否正确？完成了吗？
- 卷:数据都到了吗？
- 模式:什么是模式，它是如何变化的？谁做了这些改变，原因是什么？
- 沿袭:对于给定的数据资产，受其影响的上游来源和下游资产是什么？谁是生成这些数据的人，谁依赖这些数据来做决策？
不可否认，数据可能会因为各种各样的原因以各种各样的方式被破坏。令人惊讶的是，我们一次又一次地发现，如果对这些支柱进行跟踪和监控，几乎任何有意义的数据宕机事件都会浮出水面。
坏数据的好故事
当数据中断而无人听到时，它会发出声音吗？
本文中的所有插图均由马丁·阿隆索·拉戈提供。
遇见茱莉亚。她是一名数据工程师。Julia 负责确保您的数据仓库和湖泊不会变成数据沼泽，并且一般来说，您的数据管道处于良好的工作状态。
Julia 很高兴什么都没发生，但像任何优秀的工程师一样，她知道这几乎是不可能的。所以，她只是想第一个知道问题何时出现，这样她就可以解决它们。
见见泰德。他是数据分析师。Ted 被他的公司称为“SQL 大王”,因为他是他们的营销、客户支持和运营团队的查询负责人。他是 Tableau 的专家，知道所有 Excel 的窍门。泰德也很高兴什么都没发生，和朱莉娅一样，知道这是不可能的。然而，Ted 不希望糟糕的数据毁了他的分析，让他和他的利益相关者的生活变得痛苦(后面会有更多)。
见见亚历克斯。亚历克斯是一个数据消费者。她可能是数据科学家、产品经理、营销副总裁，甚至是你的 CEO。Alex 利用数据做出更明智的决策，无论是她的新产品应该叫什么名字，还是她应该穿哪双幸运袜去参加明天的董事会议。
Alex，或者公司的其他人，如果不能信任他们的数据，就无法完成他们的工作。我们将这种现象称为数据停机。 数据宕机 指的是数据不准确、丢失或出现其他错误的一段时间，无人幸免，有点像死亡和税收。然而，与死亡和税收不同的是，如果立即采取行动，数据停机是可以很容易避免的。
当原始数据被您的数据管道消费时，它本身就是抽象的和无意义的。如果有数据停机，这真的无关紧要，因为除了 Julia，没有人真正利用它来传递数据。问题是，她并不总是知道数据是否被破坏。
随着数据在管道中移动，它变得更加具体。一旦它到达公司的商业智能工具，Ted 可以开始使用它，将以前模糊和抽象的东西转化为 Excel 电子表格、Tableau 仪表板和其他美丽的知识容器。
然后，Ted 可以将这些数据(现已接近成熟)转化为可供公司其他部门使用的见解。现在，Alex 可以使用这些数据创建营销宣传材料、pdf 和客户资料，这些数据经过精心处理，非常具体，必将拯救世界。或者是？
随着数据错误沿着管道向下移动，数据宕机的严重性会增加。有越来越多的 ted 和 Alexs 使用这些数据，他们中的许多人都不知道他们所看到的是对的、错的还是介于两者之间，直到为时已晚。
你可能会问，什么时候太晚了？
为时已晚的是，Julia 在周一凌晨 3 点被 Ted 呼叫，他的上级经理兼销售副总裁 Alex 打电话给他，就在几分钟前，他还在谈论第二天早上应该向他们的首席执行官提交的一份不可靠的报告。当你浪费了时间、损失了收入、侵蚀了 Alex 和其他人宝贵的信任时，就太晚了。
从 Julia 的原始表格中获得的数据越具体、越远，影响就越严重。我们称之为数据焦虑的锥体。
灾难降临了，朱莉娅不知道为什么，更不用说它已经发生了。如果她能在数据宕机发生时立即抓住它，而不是通过 Alex 和她的其他数据消费者(在焦虑的圆锥下)，灾难就可以避免。
最糟糕的是，她正在做一生一次的梦。棉花糖云，巧克力喷泉瀑布，没有空值。与她周一凌晨 3 点面对的现实完全相反。
听起来很熟悉？是的，我支持你。
如果您经历过数据停机，我们希望听到您的反馈！ 伸手 向巴尔亮出自己的好消息坏数据。
再见邻居
紧密结合的社区中的变化如何损害我们的国家，以及数据科学可以做些什么来帮助我们。
在他的《消失的邻居:美国社区的转变》一书中，作者马克·邓克尔曼哀叹美国社区的崩溃和几个世纪以来维持这个国家结构和凝聚力的结构的瓦解。这些紧密联系在一起的社区，通过亲密关系和情感联系在一起，一度形成了美国例外论的核心。这些纽带的侵蚀产生了新的社区，由共同的信仰联系在一起。社区中这种巨大变化的影响在很大程度上是负面的。医生和律师、杂货商和水管工之间的偶然联系曾经促进了跨社会经济的辩论，而紧密结合的社区现在鼓励群体思维、结党营私和派系斗争。
这种亲密关系的解体有利于志同道合的关系，导致了共和党和民主党、宗教和世俗、经济困难和富裕之间日益深刻的分歧。它改变了城市规划的方式、科学交流和理解的方式、学术论文如何被同行评议的方式、人们是否享受商业上的成功，并且它促成了平衡的主流新闻的崩溃，有利于未经过滤的偏见。我们国家的两极分化从数据中清晰可见，政党之间的差距随着有偏见的媒体的扩张而同步增长。
人类是群居动物，我们理所当然地享受与他人的亲密关系。这些紧密的联系可能来自我们生活中的许多方面。传统的是通过家庭、学校、社交俱乐部、教堂，以及共同的困难，包括也许是最密切的联系:在一起打过仗的人之间。积极的紧密联系是那些跨文化、跨社会经济和跨意识形态的联系。这些纽带建立在早期美国社区自然发生的邻近和相互依赖的基础上。虽然帮派一直伴随着我们，但任何人都知道，并非所有家庭成员的想法都一样。现在，不幸的是，人们有可能为了一种新的家庭而抛弃血缘和近亲家庭，这种新的家庭基于共同的意识形态。
虽然意识形态团体并不新鲜，但技术已经有效地消除了加入这些团体的任何障碍，包括与属于主张暴力侵害妇女、少数民族、其他民族甚至推翻政府的团体相关的任何耻辱。否认气候变化或进化论等主流科学观点，鼓吹极端主义观点和政策，以及犯罪行为的兄弟姐妹变得越来越容易。
更世俗的紧密组织可以在其他环境中形成，包括工作场所、宗教团体和学校。这些志趣相投的群体倾向于通过排斥不同的人和强化彼此的先入为主的观念来强化彼此在群体中的包容感。虽然看起来是良性的，但这些团体甚至比意识形态团体更具破坏性。他们通过拒绝从多个角度解决问题来扼杀创造力，将那些与众不同的人排除在“外部群体”之外，并制造不信任和次优的工作和学习环境。它们甚至可能成为欺凌、骚扰和旁观者不作为的温床，让这两种情况继续存在。
数据科学是解决邻居消失问题的关键。虽然过去永远不会回来，但未来不一定是排外和意识形态分裂的未来。我们今天看到的红蓝州、富人和穷人之间的裂痕，只是通讯中断和群体间交叉授粉的结果。如同植物一样，思想的自花授粉削弱了我们。它损害了我们作为一个国家在全球舞台上的领导能力。它造成了我们国家政府的僵局，并鼓励浪费和无效的政策妥协。毫无疑问，目前的事态不会自行消失。为了在左派和右派、富人和穷人、少数人和多数人、宗教和世俗、警察和警察之间实现新的对话，我们需要分析这些群体在每种组织中的位置、他们的信仰、他们关注的问题，然后开发打破他们之间障碍的方法。
社交网络分析表明，紧密联系的社区与松散但高度联系的社区(如工作场所)行为不同。虽然工作场所可以包含紧密结合的社区，但项目团队往往是松散结合的，因为它们是人工构建的。在大型组织中，随着时间的推移，内群体和外群体会自然形成[3]。当来自不同群体的人组成项目团队时，这些群体可能会引起问题，并对协作造成反社会障碍。群体内形成往往会导致排斥行为，以及避免寻求对问题的多种观点。在这方面，大数据有助于识别此类群体并确定包容性的障碍。它还可以为内群体和外群体提供交叉互动的方法，这可能会产生更大的包容性和培养更多的创造力。查看组织中个人之间的通信，可以确定组内成员关系。虽然隐私是一个问题，但社交网络分析不需要暴露身份信息(尽管大多数组织都会监控内部通信)。重要的一点是确定哪些地方联系紧密，哪些地方联系松散，并在工作场所的不同人群之间建立额外的联系和互动机会。
紧密团结的群体行为也是科学机构内部的一个问题。当两个紧密结合的结构松散地联系在一起时，科学团体的社会网络就会出现两极分化[4]。通常，一组比另一组更成功，做出更好的决策，而另一组由于不信任另一组，尽管结果和决策更糟，但仍保持其立场。这些两极分化的迷人之处在于，一旦这两个群体形成，比如共和党和民主党，或者保守派和自由派，两极分化就很稳定。该图保留了两个组。例如，在 20 世纪 90 年代，治疗莱姆病的医生分成两个阵营:一派认为莱姆病是一种短期疾病，只需要一个疗程的抗生素，另一派认为它是一种慢性疾病，需要长期使用抗生素。这种分歧导致了现在所谓的莱姆战争，在这场战争中，双方互不信任，双方阵营间的指责像燃烧的箭一样互射。不幸的是，这种两极分化会让双方都更难做出好的决定，因为他们必须与对方保持距离。
在反科学阵营中，群体思维行为鼓励成员在面对与其信念相反的证据时收紧成员关系。因此，科学导致这些群体变得更加封闭。当面对与他们的观点相矛盾的图表时，人们会更加坚持自己的信念。他们寻求相反的错误知识，而且很容易找到。脸书、推特和非传统的新闻来源提供了丰富的替代事实来缓解认知失调，确保人们永远不必改变他们的想法。无论是反疫苗论调、否认气候变化、阴谋论，还是关于冠状病毒的虚假信息，信息的存在是因为人们在寻找它。他们希望这是真的。
跨国公司有时利用这些团体作为武器来攻击对他们的利益不利的科学。例如，忧思科学家联盟发表了一篇揭露埃克森美孚公司如何利用大烟草公司的剧本资助一场攻击气候科学的虚假信息运动的文章[6]。这场运动的一部分是“资助一系列前沿组织，为一群直言不讳的气候变化反对者创造一个广阔的平台。”从本质上讲，mega corp 向许多组织输送了 1600 万美元，这些组织都在宣传少数科学叛教者的错误信息，给人一种这些逆向思维者在社区中拥有广泛支持的印象[7]。
催产素已被证明有助于让关系紧密的群体变得更加包容。在 2017 年的一项研究中，在一项双盲对照研究中，催产素结合积极的社会线索被证明可以减少仇外心理[8]。总的来说，难民和移民的涌入以及领导人发出的混杂信号鼓励了仇外心理。基于国籍或文化的群体内和群体外行为的加剧会鼓励暴力以及更微妙形式的歧视。因此，重要的是要减轻。虽然研究人员依赖于鼻内注射，但拥抱和其他形式的社交接触也可以促进催产素的自然产生。然而，很难看到人们都吸食催产素或随意拥抱彼此。
许多意识形态团体并不紧密，这是社交网络和文本分析可以提供的一条关键信息。对反疫苗父母的多项研究表明，公共宣传活动是无效的。当面对疫苗有效性和安全性的科学证据时，父母们更加确信疫苗是有害的[9][10]。在去年发表的一项关于脸书反疫苗运动的研究中，研究人员发现反疫苗网络大多是“小世界”,意思是由更长的链接相互连接的集群。大多数成员是妇女。文本分析显示，话语主要围绕着对政府结构性压迫的愤怒，典型的阴谋论者。然而，一个重大发现是，反疫苗团体并不紧密[11]。他们是而不是相互支持的高度关联的团体。相反，他们通过意识形态和短暂的评论松散地联系在一起。换句话说，大多数反 vaxxers 倾向于喜欢或分享页面，但不一定得到太多支持。这表明，有效的宣传活动可能不是全球性或全国性的广告闪电战，而是针对有孩子的妇女倾向于加入或联系(或吸引她们加入此类团体)的紧密团体，利用与更大社区的外部社会联系。由于许多反对疫苗的父母都是在家上学的人，但在家上学的人很少都反对疫苗，瞄准在家上学的群体可能是一个好的开始。
虽然阴谋论团体往往存在于主流之外，但主流政治观点的两极分化是一个更大的问题，一个目前正在将这个国家撕成碎片的问题。2012 年，在总统选举前夕,《纽约时报》在“消失的战场”中报道说，这个国家被沿海的纯蓝州和内陆的纯红州所主导[12]。然而，学术界和公众的一个普遍误解是，Twitter、博客、脸书和其他社交媒体往往被分为左翼和右翼，它们之间很少进行民事辩论。该理论认为，社交媒体让用户能够通过算法过滤掉任何观点不一致的新闻来源。近年来，许多研究试图建立社交媒体“回音室”的模型，但没有分析该假设是否成立。然而，2014 年一项被高度引用的研究和 2015 年的一项后续研究表明，社交媒体使用的增加导致人们接触不同意见的可能性增加。这是一个好消息，因为它表明，尽管社交媒体有很多缺点，但它有利于恢复过去失去的一些跨意识形态的联系。虽然偶遇在现实生活中不太常见，但在网上我们往往会遇到我们的朋友、家人和同事。此外，人们更有可能在网上分享他们的政治观点，而不是面对面。然而，社交媒体公司可以做得更多，例如使用类似麻省理工学院推荐系统的东西，有目的地向用户呈现可能与他们不同的意见[15]。因此，数据科学可以帮助调整算法，以减少两极分化的意见领域之间的冲突。
看起来，这些过去的社区远没有消失，可能正在向网上转移。与此同时，对失去这些社区的道德恐慌可能被夸大了。正如 17 世纪哲学家托马斯·霍布斯在他的班级利维坦中哀悼的那样，《迷失与拯救……再一次:关于失去社区的道德恐慌占据了社交媒体》的作者认为“在我们讨厌智能手机之前，我们讨厌城市”【17】。两千年前，苏格拉底和柏拉图抱怨说，书写的发明正在腐蚀人们[18]。今天的美国正在经历类似的剧变。
这并不意味着美国今天所面临的问题没有一个是真实的，也不意味着它们不是源于文化的转变，从城市化到 24 小时媒体渠道的增长，再到中产阶级化所带来的社会的日益隔离。这也不意味着不需要做任何事情来阻止困扰我们国家的尖酸刻薄的浪潮。这是社交网络分析和数据科学展示正在发生的事情和前进方向的地方。
社交媒体非但不是美国文化消亡的罪魁祸首，反而可能是它的救星。尽管脱口秀、有线新闻和从布莱巴特到沙龙的在线新闻渠道能有效地维持它们的意识形态泡沫，但社交媒体的漏洞要多得多。大多数人与他们在学校、教堂和其他宗教组织、工作、家庭中认识的人保持社会关系，所有这些领域曾经构成了美国主街的支柱。他们可能并不都彼此同意，许多人可能会寻求更多的意识形态社区，但是，鉴于他们的单维度和这种社区在微小差异下分裂的趋势，他们远不是可靠的情感支持来源。说到相互支持，人们会像往常一样，向网上的朋友和家人求助。随着越来越多的人上网并与他人联系，随着社交媒体找到鼓励跨意识形态对话的方式，美国可能会回到一个更加和平和富有成效的时代。
[1]邓克尔曼，M. J. (2014)。消失的邻居:美国社区的转变。美国:诺顿。
[2]多尔蒂，卡罗尔。《关于美国两极分化的 7 件事》皮尤研究中心 (2014 年)。
[3]工作中的大数据:数据科学革命和组织心理学。(2015).联合王国:泰勒和弗朗西斯。
[4]科学中的群体思维:贪婪、病态利他主义、意识形态、竞争和文化。(2020).德国:斯普林格国际出版公司。
[5]贝克，J. (2017)。这篇文章不会改变你的想法。大西洋， 13 。
6 忧思科学家联盟。(2007).烟雾，镜子&热空气:埃克森美孚如何利用大烟草公司的策略制造气候科学的不确定性。忧思科学家联盟。
[7]塑造信息，扭曲科学:影响科学政策的媒体策略:众议院科学技术委员会调查和监督小组委员会听证会，第 110 届国会，第一次会议，2007 年 3 月 28 日。(2007).美国:美国政府印刷局。
[8]尼娜·马什、德克·舍勒、贾斯汀·s·范斯坦、霍尔格·格哈特、萨布丽娜·斯特朗、沃尔夫冈·迈尔、勒内·赫勒曼。催产素和社会规范减少仇外心理。美国国家科学院院刊 2017 年 8 月，201705853；DOI:10.1073/PNAS。56676.88868688666
[9] Nyhan，Brendan 等，“疫苗推广中的有效信息:一项随机试验。”儿科 133.4 (2014): e835-e842。
[10]海伦·贝德福德。"在对疫苗犹豫不决的父母中，支持疫苗的信息可能会适得其反." BMJ 循证医学19.6(2014):219–219。
[11]史密斯、内奥米和蒂姆·格雷厄姆。"描绘脸书的反疫苗运动."信息、传播&社会22.9(2019):1310–1327。
[12]利普塔克(2012 年 11 月)。消失的战场。纽约时报，SR1。
[13] Lee，Jae Kook 等，“社会媒体、网络异质性和意见极化”传播学杂志64.4(2014):702–722。
[14] Choi，Jihyang 和 Jae Kook Lee。"调查新闻分享和政治兴趣对社交媒体网络异质性的影响."人类行为中的计算机44(2015):258–266。
[15] Musco，Cameron，Christopher Musco 和 Charalampos E. Tsourakakis。"最小化社会网络中的两极分化和分歧."2018 环球网大会议事录。2018.
[16]汉普顿，基思·n .和巴里·韦尔曼。“迷失和拯救……再次:关于失去社区的道德恐慌占据了社交媒体。”当代社会学47.6(2018):643–651。
[17]霍布斯，托马斯。利维坦。联合王国，新名词，1676 年。
[18]柏拉图的菲德鲁斯。(2009).(n.p.): Agora 出版公司
用自然语言处理检测自杀帖子
插图:何
机器学习和 NLP 如何帮助国家自杀预防策略
坐在床上。唱了整首歌，还哭了一会儿。。。请停止这悲伤的举动。他妈的让它停下。
17 岁的维多利亚将此记录在笔记本电脑上的秘密日记中。几周后，她从新加坡一栋公寓楼的 10 层楼高的楼顶坠落，结束了自己的生命。
她的死亡是全球每年 80 万自杀死亡的惊人数据的一部分。世界卫生组织建议各国制定国家自杀预防战略，包括发起旨在“早期识别易受自杀风险影响的群体”的倡议。
基于文本的数据，如维多利亚日记中的文字和在线自杀援助社区线索，可能只是早期识别有自杀风险的个人的线索。
寻找虚拟的自杀笔记
遗书曾经是一个人结束自己生命的最后交流方式。但社交媒体和 Reddit 等在线社区的兴起为个人创造了安全和匿名的空间，让他们变得脆弱，分享他们对自己精神健康的想法和自杀的计划。
我们的项目旨在使用自然语言处理(NLP)工具来分析来自两个支持社区的文本数据，并了解虚拟遗书中使用了哪些单词。在机器学习分类器的帮助下，我们旨在准确识别有自杀风险的个体。
有细微差别的两个子街道
显示每个子编辑中单词使用频率的单词云。出现的次数越多，单词就显得越大。
为了解决我们的问题陈述，我们需要选择两个子主题，这两个子主题将为我们提供合适的数据来识别处于风险中的个体。虽然大多数抑郁症患者不会死于自杀，但美国卫生与公众服务部表示，与没有抑郁症的人相比，患有严重抑郁症的确实会增加自杀风险。
在 Reddit 上，我们发现了两个抑郁症和自杀的支持社区。快速浏览这些帖子可以发现，这些帖子确实是寻求帮助的在线空间。因此，很好的论坛让我们产生关于人们精神状态的真实文本数据。
这是我们的两个子主题和它们的标语(暗示了它们的使命陈述):
r/depression——“因为没有人应该独自在一个黑暗的地方”
(63.3 万成员)
r/suicide watch——“对任何有自杀想法的人的同伴支持”(20 万成员)
子网格的特征
- 活跃帖子—两个子网站每天都有超过 100 个帖子，回应者提供他们的帮助和对他们想法的评论。****
- 低钓鱼率 —很少有钓鱼帖子寻找产品广告或制造“垃圾邮件”。
- 主要基于文本的数据——不像其他 Reddit 主题，如 r/青少年，迷因主导了对话(对 NLP 项目不会是有用的数据)，这两个子主题几乎没有发布图像。
- 相同但不同——虽然两个子主题都是同行支持论坛，但 r/SuicideWatch 中使用的语言似乎对它们更具紧迫性和直接性。这里使用的短语包括:“现在差点开枪自杀”和“我想得冠状病毒而死”。识别一个有抑郁想法的人和一个有自杀风险的人所使用的语言之间的差异，对于一线的专业人士，如咨询师、教育家和精神病学家来说是有用的。****
方法
- 数据收集——我们的旅程从通过 Reddit 的 API 收集数据开始(这个 API 只允许我们在每个 subreddit 上获得大约 1000 个独立的帖子)。
- 清理 —我们的下一步是清理并考虑数据集中缺失的值。在自杀观察中，一个常见的情况是用户只在标题栏中输入内容，而将帖子栏留空。
- 预处理 —我们将构建一个预处理功能，帮助将文本转换为小写，删除标点符号，将相关单词简化为一个常见的基本单词。
- 探索性数据分析(EDA) —使用计数矢量器，我们分析了每个子主题中最常用的词，以便更好地理解我们的数据(使用的词相似，但有一些细微的差异)。
- 试听模型 —使用交叉验证的网格搜索，我们对不同的分类器模型进行评分，如 K-最近邻和多项式朴素贝叶斯，最终确定了最终的生产模型(TF-IDF 矢量器+多项式朴素贝叶斯)。
文本分析
作为 EDA 流程的一部分，我们分析了帖子、标题和用户名中的词频。以下是一些发现:
来自 r/depression 子编辑帖子的前 20 个单词
自杀观察子编辑帖子中的前 20 个单词
- 许多相似的词——我们在我们的“前 20 个词”中看到大量相似的词，来自两个子主题，如 wa，want，like，feel，life 和 people 。这可能会使我们的模型难以区分这两个子网格。但这也是令人鼓舞的，因为这种相似性表明，我们为自己提出的问题实际上可能是一个挑战，而数据科学可能对这个挑战有用。
- 想要和感觉的区别——有趣的是，在 r/SuicideWatch 的帖子中，最热门的词是“想要”，与“感觉”相比，它的使用次数超过了两倍。在 r/depression 中，最常用的词是“感觉”,同样，它的使用次数是“想要”的两倍。
- 一次性账户占主导地位——有 67 个账户名称(1897 个)包含“一次性”一词。一次性帐户是那些想保持匿名的用户使用的临时帐户。考虑到心理健康这一敏感话题，这是可以理解的。
- 大麻链接——420，或“420”，大麻代码进入了我们的抑郁症前 20 名。在未来的项目中，在我们的帖子中寻找与药物使用的联系可能是值得的。
- 男性符号——我们的抑郁症前 20 名名单被用户名中的“先生”、“男人”、“男孩”、“男人”所占据。在我们所有的作者名单中，男性相关的名字(68 个)比女性相关的名字(15 个)要多。这与我们的目标没有很强的联系，但值得注意的是，自杀研究中有一个性别悖论，它观察到女性有更多自杀想法而男性自杀更频繁的现象。
“散点图”显示了每个子编辑帖子中的文本频率。每个点代表一个单词。图右上方的点表示在两个子数据中频繁出现的单词。
员额长度
r/depression 帖子的平均长度比 r/SuicideWatch 短了将近 130 个字。虽然，正如我们从下面的散点图中看到的，这些数字可能会被 r/SuicideWatch: 一些极长的帖子和完全空白的帖子中的异常值扭曲。
创建可靠的分类器
我们决定将我们的标题、用户名和帖子合并到一个单一的特征中，以馈入生产模型，这是一个词频率-逆文档频率矢量器和多项式朴素贝叶斯分类器的组合。
不同模特试镜的结果。
TF-IDF 矢量器为我们选择的特征中的单词(或者在我们的例子中，前 70 个单词)分配分数。TF-IDF 将对文档中出现频率过高的单词进行处罚。
“单词得分”矩阵然后被转移到多项式朴素贝叶斯分类器中，该分类器基于给定单词落入某一类别的概率的计算来进行预测。
我们的生产模型之所以被选为最接近的竞争对手(哈希矢量器),是因为它具有稍高的召回分数。
召回/灵敏度测量正确阳性标记(在自杀监视中)与所有真正处于自杀监视中的人的比率。因为这是我们项目的目标，模型在这个指标上表现良好对我们来说很重要(也许是最重要的)。
该模型也被证明泛化能力很好，从其训练到测试集分数只有 0.02 的变化。
维多利亚的日记
在评估我们的结果后，我们将我们的模型应用于维多利亚日记的摘录，她的父母提供了这些日记，作为心理学家杰西·白令为他的书自杀:我们为什么自杀所做的研究的一部分。**
将我们的模型应用于维多利亚的作品，可以让我们看到我们的模型——根据在线社区的数据训练——是否可以很好地推广到一个看不见的测试集。在这种情况下，个人的话。
这个柱状图展示了我们的模型对《维多利亚的日记》中的条目所做的预测。如果我们只看“纯”日记条目(即不包括信件、遗书和诗歌)，该模型将 70.6%归类为“自杀”类别。
我们的数据集还包含了维多利亚的遗书，在她身上发现的。这是一个清晰而简短的信息:“如果我大脑受损，我不想活下去。我不想成为植物人”。我们的模型将此归类为“自杀”类别。
利用社会心理学家罗伊·鲍梅斯特的理论，白令将维克日记的不同部分绘制成六个不同的渐进阶段，从“达不到期望”(第一阶段)，到“高度自我意识”(第三阶段)，再到最后的“去抑制”。
该模型没有显示出任何与鲍梅斯特的六阶段范式相匹配的清晰模式(即，更多的自杀分类在后期阶段)。但这可能是因为我们每个阶段只能访问大约 10 个条目。获得更大的数据集将是有趣的，像 Bering 这样的研究人员已经将这些数据集分为不同的阶段。
在分析模型应用的结果时，我们必须首先解决数据中存在的一些“噪声”。尽管我们的模型是在在线支持社区的帖子上训练出来的。我们觉得用在维多利亚的日记条目上很合适，因为维多利亚也写得像是在给第三个人写信(事实上，她把日记命名为洛林)。
然而，有些参赛作品是维多利亚的诗。她诗歌中的许多句子(如涂着尘垢的木炭街道。生锈的灯柱下闪闪发光的水珠。)用比喻代替“直接引语”。因此，我们的模型对她日记中的诗做出决定可能是不准确的。(注意:在我们数据中的六首诗中，模型预测其中一半属于“自杀”类别)**
然而，像维多利亚的诗可能是这个项目未来迭代的潜在研究领域。创造性写作样本可能是个人(例如，教室里的学生)透露他们私人想法的一种方式。
评估和未来发展
- TF-IDF 矢量器挑选的热门词汇 —需要注意的是，矢量器对“感觉”的加权高于“想要”，尽管(如我们之前的 EDA 中所见)，“想要”在自杀帖子中出现的次数多于“感觉”。这可能是因为 TF-IDF 对出现过多的单词进行了处罚。尽管如此，这组单词可能是建立其他模型的良好起点，这些模型可能能够预测自杀个体的存在，例如教师的子编辑。
- 双重发帖现象——在我们的探索性数据分析中，我们注意到大约有 26 例个人在两个子帖子上发帖。我们看的例子是一个用户，@thambletrascan3 月 4 日在 r/depression 上发帖说“我不想死，但我也不想再活下去了”。一天后，@thathumbletrashcan 访问了 r/SuicideWatch 论坛并发布了“我终于有勇气实现我的计划了……你们所有人都不用再和我打交道了”鲍梅斯特假设一个人分六个阶段“跌入自我消亡的深渊”。透过鲍梅斯特的理论来研究双重发帖可能会发现 Redditors 之间基于阶段的进展的联系。****
- 调查男性自杀事件 —根据新加坡撒马利亚人组织的数据，2018 年男性占所有自杀事件的 71%以上。这与我们在用户名中男性符号的 EDA 发现是一致的。未来的项目可以更深入地研究男性自杀问题。这可能与石油/天然气、银行和科技等男性主导的高压力行业的公司有关。
- 抑郁症的复杂性 —抑郁症是复杂的，有层次的。与具有领域知识的专家合作可能有助于我们模型的未来发展，这些专家可以帮助我们筛选出可能与自残/强迫症/焦虑等其他疾病相关的因素？
参考
自杀的性别差异。维基百科，维基媒体基金会，2020 年 2 月 9 日，https://en . Wikipedia . org/wiki/Gender _ differences _ in _ sudditive。
了解自杀-快速的事实。新加坡撒玛利亚会，3 月 10 日。2020 年，https://www.sos.org.sg/learn-about-suicide/quick-facts
斯旺森巴雷特。“自杀的两面”《纽约客》，《纽约客》，2019 年 1 月 17 日，www . New Yorker . com/books/under-review/The-two-faces-of-suite。
预防自杀:全球当务之急。世界卫生组织，2014。
美国卫生与公众服务部。"抑郁会增加自杀的风险吗？"hhs.gov，2015 年 8 月 21 日，www . hhs . gov/answers/mental-health-and-substance-abuse/does-depression-increase-risk-of-自杀/index . html
百玲杰西。自杀:我们为什么自杀。芝加哥大学出版社，2018 年。
代码&触点
github
https://github.com/hesamuel/goodbye_world
数据集
https://github.com/hesamuel/goodbye_world/tree/master/data
领英
https://www.linkedin.com/in/samuel-he/
电子邮件
samuelhezhengbang@gmail.com
用于乳腺癌检测的谷歌人工智能击败了医生。
谷歌开发的人工智能检测乳腺癌的准确率更高
布雷特·乔丹在 Unsplash 上的照片
人工智能的目标是创造能够以智能(类似人类)的方式运行的算法、机器人和技术。谷歌的一个人工智能工具显示了检测乳腺癌的技能，这些技能与训练有素的医生的技能类似，如果不是更好的话。
在《自然》杂志发表的一项研究中(见此处)，谷歌开发的一种人工智能(AI)改善了乳腺癌的早期检测过程，减少了假阴性和假阳性。
问题是
乳腺癌是女性癌症死亡的第二大原因。乳腺癌的一个关键方面是早期检测，这可以大大改善乳腺癌的预后。从 40 岁到 50 岁的女性经常被建议去做乳房 x 光筛查。尽管这些措施有助于早期检测，但由于难以正确解释筛查图像，仍可能存在假阴性的情况。
假阴性是指医生错误地诊断为阴性，而实际上患者患有乳腺癌。这只会使乳腺癌在发展过程中变得最难治疗，一旦肿瘤的可见性增加，就会被发现。
用于乳腺癌检测的人工智能工具解释道:
谷歌开发的人工智能分析了 X 射线图像，即乳房 x 光照片，并将美国女性的假阴性率降低了 9.4%，假阳性率降低了 5.7%。而对英国女性来说，它减少了 2.7%的假阴性和 1.2%的假阳性。
虽然这个系统在大多数情况下都优于医生，但也有其他情况下，医生标记了 AI 模型错过的乳腺癌。
谷歌开发的这个新的人工智能工具只是计算机视觉领域许多新技术发展中的一个。这个领域在最近几年有了很大的进步。在过去的 10 年里，算法更有能力检测对象和分析大型视觉数据集。深度学习领域(机器学习的一个分支)带来了所谓的神经网络，作为分析大型复杂数据集的一种方法。此外，卷积神经网络(CNN)是计算机视觉领域的一场巨大革命。
除了谷歌人工智能能够比医生更准确地检测乳腺癌，CNN 还允许许多其他应用，如人脸识别，监控，生物识别和自动驾驶。
计算机视觉问题主要是定位、图像分类和目标检测等任务。
根据研究论文，这是人工智能的结构:
“人工智能系统由三个深度学习模型组成，每个模型都在不同的分析水平上运行(单个病变、单个乳房和整个病例)。每个模型为整个乳房 x 线照相术病例产生 0 到 1 之间的癌症风险评分。系统的最终预测是三个独立模型预测的平均值。”
乳腺癌检测问题是一个图像分类问题。其中乳腺癌图像必须被分类为阳性或阴性。根据研究论文的补充信息，该信息涉及为该人工智能开发的算法，实现了 CNN。
这对未来意味着什么(结论)
人们很容易认为机器时代即将到来，但事实上，这些工具仅仅是工具。最终，它们将被医生(放射科医生)用来提高诊断水平。一旦被医生完全采用，这种对科学的贡献肯定会拯救生命。
毫无疑问，对于计算机视觉领域来说，这是一个充满希望的时代，计算机视觉是人工智能的一个非常重要的分支。
谷歌分析数据导入——4 种方式
来源: Unsplash
了解如何使用 Google Sheets 插件、API 和 Apps 脚本以及开箱即用的解决方案将成本数据手动导入 Google Analytics
如果您使用多个广告服务和平台来宣传您的产品，将所有广告数据组合在一个界面中是一个好主意。这带来了一些巨大的优势:
- 节省时间。你不需要永远在谷歌广告、脸书、Instagram 和其他服务之间切换来评估广告工作的效率。
- 2。允许您比较一个系统中所有服务的性能。除了成本数据，您还可以将广告服务的其他信息发送到 Google Analytics，以深入分析您的活动、广告和关键词。通过比较所有流量来源的浏览量、广告成本、CTR 和 roa，您可以使用这些数据来决定您的渠道是否有回报并重新分配您的预算。
您可以转到收购—活动—成本分析，在 GA 报告中查看这些数据。
图片由作者提供
3。让您使用谷歌分析的附加功能。如果您将成本数据导入 Google Analytics，您可以在不同的归因模型中使用这些数据，并将计算结果与 ROI 进行比较，以正确地对您的营销渠道进行评分。
这些结果也可以在 GA: 转换—归因—模型比较工具中跟踪。
图片由作者提供
如何将成本数据导入 Google Analytics
将成本数据从 Google Ads(以前的 AdWords)导入 GA 非常容易，因为这两个服务之间有一个本地集成。要从其他广告服务导出成本数据，您可以执行以下操作之一:
- 通过 GA 界面手动导入。
- 使用 Google Sheets 的特殊插件导入。
- 通过 API 和 Google Apps 脚本使用半自动导入。
- 使用现成的解决方案。
我们将仔细查看不需要 IT 专家任何帮助的选项(如 API 替代方案),以便您可以了解更多有关如何在 GA 中导入成本数据以及使用现成解决方案的信息。
请注意，我们提到的所有四个选项都需要在您的活动中使用正确的正确的 UTM 标签:
- 必需的:utm_source，utm_medium，utm_campaign。
- 可选:utm_term，utm_content。
一旦用户点击你网站的链接，UTM 标签的值就会被发送到谷歌分析。
1.通过谷歌分析导入成本数据
使用这种方法，你必须用广告服务中的数据填写一个 CSV 文件，并在每次需要报告时手动上传到 Google Analytics。如果您有两个或三个频道，并且您希望每个月都有这些频道的数据，这种手动方法很好。但是当涉及到几十个渠道时，就变得非常复杂和耗时。
将成本数据导入 Google Analytics 有三个步骤。
第一步。在谷歌分析中创建一个数据集。
进入管理面板—数据导入—创建:
图片由作者提供
然后选择成本数据，点击继续:
图片由作者提供
命名您的数据集，并选择要将成本数据上传到的 GA 视图。点击继续:
图片由作者提供
现在，通过选择从广告服务导出到 Google Analytics 的参数来确定数据集结构。有三个自动填写的必填字段:日期、来源和介质。还有一组字段至少需要一个参数:点击数、成本和印象数。
图片由作者提供
第三组字段是可选的。在这里，您可以添加使用 UTMs 收集的任何额外信息，例如，关键字或广告内容。
图片由作者提供
在导入行为下，选择当导入的数据重复时，例如当关键字已经上传到 GA 时，您想要做什么。如果要将新数据添加到现有数据中，选择求和。如果想用新数据替换现有数据，选择覆盖。接下来，保存更改，您将在数据导入菜单中看到一个新的数据集:
图片由作者提供
第二步。创建要上传的 CSV 文件。
一旦你创建了数据集，你需要准备一个 CSV 文件，用广告服务的成本、点击和其他指标的数据填充它，并上传到 Google Analytics。不要忘记在 CSV 文件中使用与步骤 1 中的数据集中相同的数据结构。你可以在谷歌分析帮助中阅读更多关于如何正确建立上传成本数据的文件。
第三步。将 CSV 文件上传到 Google Analytics。
此时，您的数据已经收集完毕，CSV 文件也准备好了。现在该送 GA 了。为此，导航回数据导入并点击上传文件:
图片由作者提供
在您的计算机上选择包含成本数据的 CSV 文件，并确认上传:
图片由作者提供
如果 CSV 文件填写正确，您将看到状态为“已完成”。处理数据并将其添加到您的报告中大约需要 24 小时。
图片由作者提供
如果您在导入数据时看到错误，请在 Google Analytics 帮助中查看可能的问题和解决方案。
2.使用 Google Sheets 插件导入成本数据
如果您已经在 Google Sheets 中收集了成本数据，您可以避免 CSV 文件带来的麻烦。只需使用免费的 OWOX BI 数据上传插件，将您的成本数据从 Google Sheets 直接发送到 Google Analytics。如果上传的数据中有任何错误，插件会建议如何更正。
要使用 OWOX BI 数据上传插件导入数据，您需要在 GA 中创建一个数据集，并下载和安装该插件。接下来，打开一个结构合理的成本数据表(类似 GA 中的数据集，点击附加组件 — OWOX BI 数据上传 — 上传数据:
图片由作者提供
然后在 GA 中选择您想要上传费用的帐户、web 属性和数据集，并单击验证&上传。
图片由作者提供
太好了，24 小时后，您将在 GA 报告中看到添加的数据。
3.使用 API 和 Apps 脚本导入成本数据
这个数据导入选项是半自动的。下面是如何设置的:在 GA 中创建一个数据集，同时在 Google Sheets 中创建一个成本数据表，剩下的工作将由 Google Apps 脚本完成。查看本指南以了解更多关于通过 API 导入的信息。
但是，请记住此选项的缺点:
- 有大量现成的脚本，但你必须配置它们，并知道正确的应用程序脚本语法来使用它们。
- 你必须手动或通过另一个 API 和应用程序脚本在 Google Sheets 中收集数据，甚至使用特殊服务。
- 你必须坚持某种格式，否则你会在数据中看到错误或不确定性。
4.通过特殊服务自动导入成本数据
大多数电子商务项目使用其他广告平台和谷歌广告。因此，这些项目必须仔细跟踪他们的成本，以快速反应和重新分配他们的营销预算。这就是为什么手动上传数据肯定太耗时。但是有工具可以解决这个问题，帮助营销人员和分析师摆脱常规工作。下面是我们对这个问题的解决方案，我们称之为 OWOX BI Pipeline 。
目前，您可以使用 BI Pipeline 从脸书、Instagram、LinkedIn、Criteo 和 Yandex 自动将数据导入 GA。直接，Yandex。Market、MyTarget、AdRoll、Trafmag、Bing Ads、Twitter Ads、Sklik、Outbrain、Yahoo Gemini 和 Hotline。
OWOX BI 还可以扩展缩短的链接，识别广告活动中的动态参数，检查 UTM 标签，并通知您标签中的任何错误。最重要的是，Pipeline 将您使用的广告服务货币转换为 GA 中的货币。
如果您需要分析之前一段时间的数据，可以在 OWOX BI 设置中设置一个特殊选项，从 GA 获取过去六个月的历史数据。
此外，如果广告服务的数据有任何变化，Pipeline 会追溯更新上传到 GA 的数据(最多 21 天)。感兴趣了吗？在 7 天的试用期内，您可以免费试用所有这些功能。
但是关于 BI 管道的优点已经足够了。下面说说怎么用吧。您首先需要 GA 中的数据集，然后设置 OWOX BI 管道。
如果你还没有 OWOX 商业智能项目，用你的谷歌账户设置它。然后导航到管道，创建一条管道，选择数据源:
图片由作者提供
接下来，提供对广告服务的访问:
图片由作者提供
并提供访问您的 Google Analytics 帐户的权限:
图片由作者提供
在 Google Analytics 中选择数据集以上传成本数据:
图片由作者提供
现在设置导入数据的开始日期(默认情况下，是当前日期)。您可以将其更改为过去或未来的日期。现在选择一个视图并点击创建:
图片由作者提供
哒哒！管道已设置就绪。数据将在大约 36 小时后在 GA 报告中提供。OWOX BI 需要 12 个小时来处理数据，GA 需要 24 个小时来处理数据。
自由职业者协会
如果我只需要单个活动的数据，该怎么办？
您可以使用此活动的数据创建一个 CSV 文件，并将其手动上传到 GA。自动导入只能让您上传多个活动的数据。不过，您可以设置过滤器来查看您需要的活动信息。为此，在 g a 中创建数据集时选择活动参数:
图片由作者提供
之后，进入采购—活动—成本分析，将活动设置为主要维度，查看跨活动的报告。
图片由作者提供
如果我需要的参数比 GA 中的数据导入允许的多怎么办？
如果你需要成本数据模式中没有的信息，你可以从 Google BIgQuery 的广告服务中收集和组合数据。OWOX BI Pipeline 允许您从脸书 Ads 向 BigQuery 发送完整的数据(参见数据模式)。
如何将成本数据从没有与 OWOX BI Pipeline 集成的来源导入 GA？
BI Pipeline 使用广告服务的官方 API。对于不提供 API 或者没有与 OWOX BI 集成的服务，有一个手动上传选项。它不同于 GA 手动上传方法，因为您不必形成和上传 CSV 文件，您可以在 OWOX BI 界面中完成。
我如何计算 roa 并考虑不在 GA 中的退款和已完成订单？
您必须使用 BigQuery 将来自 CRM 的已完成订单数据与来自 ad services 和 GA 的数据进行合并。这也将允许您建立一个基于漏斗的归因模型，并在考虑离线订单时评估您的活动。
结论
为了比较你的广告渠道的表现，你需要在一个单一的系统中收集数据，如谷歌分析。导入成本数据的最佳方式取决于您使用的广告服务数量以及您需要广告服务报告的频率。
如果您使用两三个广告服务，并且不经常需要报告，您可以手动将成本数据上传到 GA。否则，考虑使用 OWOX BI 之类的特殊服务来自动上传成本数据。
谷歌分析数据与 R
米利安·耶西耶在 Unsplash 上拍摄的照片
目标:以编程方式检索营销分析自动化的谷歌分析数据。
访问 Google Analytics API 来检索 GA 记录是构建端到端营销分析套件的基本要求之一。我们可以通过下面列出的四个主要步骤来实现这一目标:
- 在 Google Cloud 中生成客户端 ID 和密钥。
- 更新。伦美龙变量。
- 导入相关库并在本地刷新 GA 令牌。
- 最后，在 r 中构建 GA 数据集。
第一步。在 Google Cloud 中生成客户端 ID 和密钥
步骤 1.1。创建谷歌云项目:登录 谷歌云控制台 创建项目。
创建谷歌云项目(图片由作者提供)
第 1.2 步。谷歌分析报告 API:一旦你创建了项目，导航到项目的 API 和服务部分，并启用“谷歌分析报告 API”。
谷歌分析报告 API 1(图片由作者提供)
谷歌分析报告 API 2(图片由作者提供)
谷歌分析报告 API 3(图片由作者提供)
第 1.3 步。配置 OAuth 同意屏幕:如果您是第一次设置 Google Cloud 项目，您必须在生成凭证之前配置 OAuth 同意屏幕。确保在项目范围中选择分析报告 API，在同意屏幕中输入应用程序名称和支持电子邮件。
配置 OAuth 同意屏幕 1(图片由作者提供)
配置 OAuth 同意屏幕 2(图片由作者提供)
配置 OAuth 同意屏幕 3(图片由作者提供)
第 1.4 步。创建 OAuth 客户端 ID:配置 OAuth 同意屏幕后，创建 OAuth 客户端 ID 凭据。以 JSON 文件的形式下载客户机 ID 和密钥，并将其存储在当前的工作目录中。
创建 OAuth 客户端 ID 1(图片由作者提供)
创建 OAuth 客户端 ID 2(图片由作者提供)
创建 OAuth 客户端 ID 3(图片由作者提供)
第二步。更新。Renviron:编辑。Renviron 通过整合最新的谷歌云项目证书
第 2.1 步。打开。Renviron 在 R 中使用以下命令并更新参数:
usethis:: edit_r_environ()
更新。伦美龙(图片由作者提供)
第三步。GA 认证:启动一个 R 会话并提前导入所有相关的库
googleAnalyticsR 和 googleAuthR 是列表中的必备。确保在加载 googleAnalyticsR 和 googleAuthR 包之前使用' gar_set_client()'函数。此外，指出 gar_auth()函数中“刷新令牌”的位置。
googleAuthR:: gar_set_client( "C:\\Users\\Sree\\gcp_client.json")library(googleAnalyticsR)
library(googleAuthR)
library(tidyverse)
library(lubridate)
library(dplyr)googleAuthR::gar_auth(token = "sc_ga.httr-oauth")
在执行上述命令时，您将能够通过自动刷新令牌经由 R 成功登录到 Google Analytics 报告数据库。
第四步。Google 分析报告 API:在 R 中构建 GA 报告
第 4.1 步。从 GA 获取视图列表:
确定您需要从谷歌分析的视图的完整列表。通过使用 googleAuthR 包中的“ga_account_list()”函数或通过从 Google Analytics 本身识别他们来获取他们的 ViewId。
谷歌分析报告 API(图片由作者提供)
my_accounts <- ga_account_list()
viewId <- (my_accounts$viewId)
第 4.2 步。通过查询 Google Analytics 报告服务器构建数据集:
为了便于说明，我在这里构建了一个循环，为 Google Analytics 中设置的所有视图顺序下载数据。
ga_data_final <- data.frame()for (i in viewId) {
ga_data_temp <-
google_analytics(i,
date_range = c(GoogleA_Start, GoogleA_End),
metrics = c("sessions"),
dimensions = c("date"
,"channelGrouping"
,"deviceCategory"
,"source"),
anti_sample = TRUE,
#slow_fetch = TRUE,
max = c("-1"))
ga_data_temp$viewId <- i
ga_data_final <- rbind(ga_data_final, ga_data_temp)
}
第 4.3 步。清理数据集:
GA_export <-
left_join(ga_data_final,my_accounts, by = "viewId") %>%
select(date,channelGrouping,deviceCategory,source,sessions,Country) %>%
mutate(channelGrouping_refined = if_else(
channelGrouping == 'Organic Search','SEO',
if_else(channelGrouping == 'Paid Search','PPC Search',
if_else(channelGrouping == 'Display', 'PPC Display',
if_else(channelGrouping == 'email,email','EDM',
if_else(channelGrouping == '(Other)', 'Unspecified', channelGrouping
)))))) %>% select(date,channelGrouping,deviceCategory,source
,sessions,channelGrouping_refined,Country)rm(my_accounts,ga_data_final,ga_data_temp,i, viewId)
第 4.4 步。发布数据集:
这是谷歌分析报告服务器最终输出的快照。
发布数据集(按作者分类的图像)
最后，将带有时间戳的数据集发布到平面文件或云数据库中。
GA_data <-
GA_export %>%
write_csv("GA_data.csv")
第五步:接下来是什么？
这只是营销分析自动化的开始。因为我们可以在此基础上做更多的事情，比如:
1)在虚拟机上自动化 R 脚本，并将增量数据存储在云数据库中。
2)重复相同的过程，建立一个自动化的跨渠道数据湖，带来增量脸书广告/谷歌广告/推特广告数据集。
3)使用时间序列预测来预测来自每个平台的用户会话/指标。
4)最后，构建一个 BI 仪表板，从平面文件/云存储中检索数据，以可视化端到端营销分析套件。
关于作者
[## Sreejith Sreedharan - Sree
数据爱好者。不多不少！你好！我是 Sreejith Sreedharan，又名 Sree 一个永远好奇的数据驱动的…
srees.org](https://srees.org/about)
如果您在理解 r 中 GA 自动化的基础知识方面需要任何帮助，请随时联系我。希望这有所帮助:)
BigQuery 中的谷歌分析 3:入门
如果你在知道谷歌分析有其局限性之前使用过它。对于报告、过滤器、细分市场和预定义的维度/指标，您只能做这么多。通过将原始数据导出到 BigQuery，我们可以轻松地避开这些问题，并运行各种对于用户界面的报告来说过于复杂或过于具体的分析。但是原始数据也有一些缺点:模式有点不寻常，分析师可能会发现嵌套方法一开始有点挑战性。
我想开始一系列文章，在这些文章中，我将在开放数据上展示如何开始使用 BigQuery 中的谷歌分析表。我将讲述这个结构是什么样子，如何理解它，以及如何处理它的嵌套数据——首先是初级水平，稍后我想更详细一些。在第一篇文章中，我将首先向您介绍最常见的领域。
我假设你知道基本的分析 SQL。比如用SUM()和[GROUP BY](https://cloud.google.com/bigquery/docs/reference/standard-sql/query-syntax#group-by-clause)聚合值。你也应该知道[LEFT JOIN](https://cloud.google.com/bigquery/docs/reference/standard-sql/query-syntax#left-outer-join)和[CROSS JOIN](https://cloud.google.com/bigquery/docs/reference/standard-sql/query-syntax#cross-join)的区别。如果你以前从未使用过 BigQuery，下面是如何在沙盒模式下开始的指南和一个关于 web 界面的指南。如果你需要一点关于 SQL 的复习，你可以尝试一下 SQLbolt 来获得一个简单的交互式教程，而不需要注册或支付任何费用。
当然，如果你跟着做，这些文章的效果会更好，我写这些文章是因为我知道你会跟着做。
建立
首先，从谷歌商品商店查找谷歌分析数据。每个人都有查看权限，但是为了查询数据，您的计费项目必须允许在美国查询数据。您可以在左上角选择您的计费项目:
确保此项目可以查询美国的数据
要将 BigQuery 公共数据项目固定到您的项目列表中，打开项目页面，点击中间右侧的“固定项目”。我们将在这个项目中使用的数据集叫做[google_analytics_sample](https://console.cloud.google.com/bigquery?folder&p=bigquery-public-data&d=google_analytics_sample&page=dataset)。
要开始，只需单击数据集中的表组，如下图所示:
包含 366 个表的表组—这里选择了表 ga_sessions_20170801。
现在，单击右侧的“查询表”,一个查询框架出现在您的查询编辑器中，您可以轻松地修改它:
该查询应该为计数返回一个值。
谷歌分析数据结构 1 —简单数据类型
谷歌分析数据每天导出一张表、、，无论是流还是当天导出。该名称遵循ga_sessions_YYYYMMDD的模式，其中最后一部分被替换为 Google Analytics 中导出视图的时区设置的日期。这意味着一个表中的所有数据都来自这个时区的某一天！组合不同时区的数据时要小心。现在，我们来看看实际数据。
将 BigQuery 表视为平面表是一个好主意。是的，没错——尽管到处都在谈论臭名昭著的“嵌套数据”,但在开始理解它们时，将它们视为普通的关系表是有意义的。例如，表 ga_sessions_20170801 :如果您只查看包含简单数据类型(且未被否决)的字段(列)，您会得到以下列表:
- 访问号码 (int64)
- visitId (int64)
- visitStartTime (int64)
- 日期(字符串)
- fullvisitorid (字符串)
- clientId (字符串)
- 频道分组(字符串)
- 社会管理类型(字符串)
- 用户标识(字符串)
仅此而已。一些字符串和一些整数。让我们揭开它们的神秘面纱。并且在我们开始之前，设置一个书签到 导出模式 以备将来参考。在开发查询时，您将需要它来查找概念。这个参考资料加上跟踪开发人员编写的参考资料将有助于您理解数据。
表格中的每一行等于一个会话(或一次访问)。因此，我们的第一个字段 visitNumber 试图告诉我们这是哪个会话。不过，如果你在追踪网站，要小心:visitNumber 通常来自 cookie，而 cookie 可能是错误的。最好把这个领域当作一个粗略的估计。
在这里运行这个查询查看结果！
但是什么是会话呢？我们可以将“会话”定义为 Google Analytics 称之为“命中”的一组服务器请求。会话从一次点击开始，并在以下情况下结束
- 超过超时阈值(在视图设置中设置)
- 点击包含新的营销活动信息——会话可以来自搜索引擎、广告、合作伙伴、其他渠道或直接
- 在午夜(因为创建了一个新表)
我们将在以后的文章中了解更多关于点击的信息！
字段名 visitId 可能会让您认为它允许您将它用作会话 Id。但事实并非如此。visit id 和 visitStartTime ，实际上都是以秒为单位的 UTC 时间戳，表示会话开始的时间(第一次点击的时间)！区别就在这里:还记得一个会议是如何在午夜分成两个会议的吗？ visitStartTime 给出这一行的时间，而 visitId 给出前一天表中这一行的时间！如果没有午夜分割，则两个字段都包含相同的值😗*
运行这个查询来查看结果！
当你计算超过多天的会话时，这种差异当然是非常重要的。
使用 通配符表 有一种轻松的方法。您基本上是在表名中使用一个*作为通配符。这将添加伪列_table_suffix,它包含您用通配符替换的表名的所有部分。如果你替换日部分ga_sessions_201708*，它包含字符串形式的所有日，例如01或02。如果替换更多的ga_sessions_2017*，则包含更多的0801、0731，以此类推:
运行此查询并修改它以了解更多信息！
因为字段日期包含本地日期，所以在整个表中它是相同的值。所以当我们数的时候，我们得到了桌子的数量。
再来说说 fullVisitorId 和 clientId :客户端 Id 是 fullVisitorId 的未哈希版本，但并不总是完全匹配。仅在加入其他营销数据时使用客户 id。使用 fullvisitorid 用于识别客户端(浏览器 cookies 或应用安装)，因为该 id 与谷歌用户分析数据一致。如果你在一个标准的非用户 id 视图中，那就是。
既然我们可以识别客户，我们也可以识别他们的会话，因为每个客户一次只能有一个会话——我们结合 fullVisitorId 和 visitStartTime 来获得与 Google Analytics 中相同的数量:
运行这个查询来查看不同之处！
如果你将 fullVisitorId 和 visitId 结合起来，然后分别计算几天的访问量，你会得到一个更准确的访问量，因为午夜时段被忽略了——但这个数字不会出现在谷歌分析中，所以要准备好回答同事的问题，将你的数字与谷歌分析用户界面中的数字进行比较。
字段 channelGrouping 包含该会话的营销渠道。请注意，通道可以从以前的会话中继承！这取决于你在活动超时上的谷歌分析设置——标准设置是六个月！要检查该值是否被继承，请查看字段traffic source . istruedirect，并咨询您的营销团队如何解释他们的活动超时选择。
字段 userId 只有在您将 Google Analytics 中的视图设置为用户 Id 视图时才相关，因为这样做的缺点是只跟踪那些实际上有用户 id(通常是登录 id)的会话。公司通常在自定义维度中跟踪登录 ID。我们稍后将了解自定义尺寸！
谷歌分析数据结构 2 —结构
结构是我们的第一个复杂数据类型:键值对列表。如果你熟悉 JSON:它们基本上是对象，在{ "key 1" : "value X", "key 2" : "value Y"}或 Python 中它们被称为字典。
在 BigQuery 中，它们被称为结构，或者有时——如果你在 web 界面中查看表模式——它们被称为RECORD。这完全是一回事。请不要把它们和数组混淆——有包含RECORD的数组——但是RECORD也可以独立存在！
区别在于模式:如果它说REPEATED，那么它是一个数组，如果不是，那么它只是一个单个的数组。
通过寻找“重复的”来识别数组—“重复的记录”意味着“数组中的结构”
对我们来说，这意味着我们有几个包含子字段的字段，但都是单个的RECORD。它们通常可以被视为普通的列。这里没什么可怕的。
虽然不能GROUP BY或聚合一个结构，但是可以GROUP BY一个结构的子字段(除非它本身是一个结构或数组)。让我向您展示我的意思—我们的表中有以下结构:
- 总计包含本次会话的合计值
- 流量来源告诉我们流量的来源
- 设备包含客户端信息
- 地理网络包含关于客户端地理位置的最佳猜测
它们非常自我描述，并且有很好的文档记录。确保您了解它们的子字段的值是如何被跟踪的——与您的开发人员交谈并阅读他们关于这些字段的限制的实现文档。例如，由于 IP 匿名化，地理位置可能会非常不准确。
总计可以节省计算时间。您可以使用点运算符.来访问子字段，如下所示:
运行并修改此查询以了解如何查询结构！
总计的子字段包含两种类型的字段:
- 统计总量，比如点击数、交易数和浏览量。
- 条件集合，如 totals.visits 为
1或NULL，表示某一组条件是否成立。
totals.visits 表示该会话是否包含交互。是的，存在没有交互的会话的用例:有时你想跟踪应用程序的安装，这将向 Google Analytics 发送一个没有交互的点击，Google Analytics 将围绕它建立一个完整的会话。这些以及类似的情况会导致非交互式会话，您可以使用WHERE totals.visits = 1忽略这些会话。记住 GIGO 原则，确保你的追踪开发者将这些点击设置为非交互，否则，你最终会有很多不应该被认为是非交互的会话。
totals . bounds表示该会话是否只有一次浏览量。小心这个数字，因为它不适用于应用程序流量。为此，你需要建立自己的反弹标准，例如检查totals.screenviews = 1。
还有 totals.newVisits ，其工作原理与 totals.visits 类似，也可用于简单计数SUM(totals.newVisits)或作为条件语句，例如WHERE totals.newVisits = 1。
device.deviceCategory 也是一个有趣的分类:谷歌分析自动将客户分为移动、桌面(包括笔记本电脑)和平板。他们并没有真正公开他们是如何做的，所以对照用户代理检查一下，看看它是否对你的情况有意义。这个字段很有用，因为这三个类别的用户体验不仅在接收方面不同，在提供输入方面也不同。如果你的团队也在跟踪 CSS 断点，当你的分析问题在 UX 领域时，它可能会给你更好的分段。
现在您已经知道了这些标准字段是如何工作的以及在哪里可以找到它们，接下来您可以进入有趣的部分:数组。它们将在下一篇文章中介绍——希望在那里见到您！
谷歌云人工智能平台:超可访问人工智能和机器学习
在本系列的第一篇文章中，我们将介绍 Google AI 平台，探索现代数据科学可用的服务
授权给作者的图像
谷歌云
对于那些不熟悉谷歌云的人来说，谷歌云平台(GCP)是一套基于云的计算服务，旨在支持一系列常见的用例；从托管容器化应用程序，如社交媒体应用程序，到大规模数据分析平台，以及高级机器学习和人工智能的应用。
谷歌云由一组物理资产(如计算机和硬盘驱动器)和虚拟资源(如虚拟机)组成，这些资源包含在谷歌位于全球的数据中心中。
谷歌云 (来自谷歌云入门)
谷歌云于 2008 年 4 月首次推出，运行在谷歌内部用于其最终用户产品的相同基础设施上，包括谷歌搜索、Gmail、文件存储和 YouTube。这个全球网络本身就是一个工程壮举，谷歌有一个迷人的互动展示平台，你可以去探索。
谷歌云是目前市场上三大云提供商之一，另外两家是微软 Azure 和亚马逊网络服务(AWS)。
谷歌和人工智能
谷歌经常被称为人工智能领域的世界领导者。要了解原因，我们可以从谷歌的使命宣言开始:
谷歌的使命是组织世界上的信息，并使其普遍可用和有用。人工智能正在以令人兴奋的新方式帮助我们做到这一点，为我们的用户、客户和世界解决问题。
谷歌
在这篇文章中，谷歌进一步阐述了其对 AI 的具体使用:
人工智能让人们每天做事情变得更容易，无论是搜索亲人的照片，在谷歌翻译中打破语言障碍，在旅途中键入电子邮件，还是用谷歌助手完成事情。人工智能还提供了看待现有问题的新方法，从反思医疗保健到推进科学发现。
谷歌
谷歌人工智能收购
过去十年左右，谷歌在人工智能领域进行了一系列收购:
2010: Metaweb(语义搜索)、Phonetic Arts(语音合成)
2011: SayNow(语音识别)、PittPatt(面部识别)
2012: Viewdle(面部识别)
2013: DNNresearch (深度学习)、Behavio(语义分析)、Wavii (NLP)、Schaft 等 6 家机器人公司、Industrial Perception
2013:Bot&Dolly(机器人视觉)
2014: Eyefluence(视觉)
2017: Kaggle (数据科学)、Halli Labs(深度学习)、AlMatter(视觉)
2020: Onward (NLP)、智能眼镜(视觉)
谷歌承诺让其他人也能获得这一人工智能领域的知识，并形成他们人工智能平台的基础。
在谷歌人工智能，我们正在进行推动该领域最先进技术的研究，将人工智能应用于产品和新领域，并开发工具以确保每个人都可以访问人工智能。
谷歌
谷歌云人工智能平台
授权给作者的图像
AI Platform 是 Google Cloud 上的一套服务，专门用于在云中构建、部署和管理机器学习模型。
超可访问的机器学习
人工智能平台旨在让数据科学家和数据工程师轻松简化 ML 工作流程，并访问谷歌开发的开创性人工智能。我们经常在 AutoML (Google 的点击式 ML 引擎)中使用它，但除此之外，它还支持使用 Tensorflow 和 SKLearn 构建的高级模型的训练、预测和版本管理。
云人工智能平台服务
AI 平台提供了一套服务，旨在支持典型 ML 工作流中的活动。
谷歌云 AI 平台服务(图片来源谷歌云)
1。准备
通常，数据首先在BigQuery Datasets中准备(摄取、清理、特征工程)，big query Datasets 是 Google Clouds 超大规模数据仓库中的表集合。
虽然谷歌将 BigQuery 作为人工智能平台的一部分，但我们倾向于将 BigQuery 视为一个数据仓库，因此在技术上不是一项人工智能服务。话虽如此，我们构建的 99%的 ML 工作流都使用它。
Google 提供了 数据标注服务 用于标注训练数据。该服务允许您与人工贴标机合作，为您可以在机器学习模型中使用的数据集合生成高度准确的标签。通常我们用它来对图像、视频、音频和文本进行分类。
一些示例图像标签选项包括(但不限于):
- 图片的分类(猫，不是猫)
- 图像边界框(在每张图像中的所有汽车周围画一个框)
- 图像分割(勾勒出每幅图像中的所有人)
您可能想了解更多关于数据标签定价的信息。
(2020 年 11 月-由于 Covid19，数据标签服务目前不可用)。
2。构建
我们简单的谈了一下 AutoML ，训练模型的零代码平台。
机器训练机器。Cloud AutoML 使机器学习专业知识有限的团队能够利用易于使用的图形界面训练高质量的模型。它依赖于谷歌最先进的迁移学习和神经架构搜索技术；利用超过 10 年的专有谷歌研究技术，帮助您的机器学习模型实现更快的性能和更准确的预测。
今天，设计神经网络是非常耗时的，并且需要专业知识，这限制了它在较小的科学家和工程师群体中的使用。这就是为什么我们创造了一种叫做 AutoML 的方法，表明神经网络设计神经网络是可能的。
T22【桑德尔·皮帅】谷歌 CEO
我们使用 AI 平台笔记本 (托管 Jupyter 笔记本)来构建定制的 ML 模型，通常使用 Tensorflow 或 SkLearn。
2020 年 9 月发布，AI 平台笔记本取代云数据实验室。我们希望您现在可以直接在浏览器中使用笔记本，而不必先设置 ssh 隧道(datalab 强迫您这样做)。
最后， AI 平台培训 提供服务，在云中的计算资源上运行你的培训工作。
3。验证
可解释的 AI 是一套很棒的工具，可以帮助您理解模型的输出，验证模型行为，识别模型中的偏差，并获得改进模型和训练数据的方法。这确实有助于消除活动中的猜测，例如模型调优。
当 AI 出错时
照片由 Marek Szturc 在 Unsplash 拍摄
可解释的人工智能应该被忽视，否则后果自负。例如，一个图像分类模型被训练来检测狼。当算法错误地将一个外星人归类为狼时，创造者们感到困惑。结果是，经过训练的模型实际上只是在图像中寻找雪和树(这在训练集中占了很大比重)。
这是一个很棒的 TED 演讲，引用了这个和其他的例子。
可解释的人工智能应该被忽略，否则后果自负
AI 平台 Vizier 更进一步，提供黑盒优化服务，调整超参数，优化模型输出。
4。展开
无论您是使用无代码 AutoML 训练的模型，还是使用 AI 平台笔记本构建的高级 Tensorflow 模型，AI 平台都提供了许多服务来帮助部署模型和生成预测。
AI 平台预测 管理运行模型所需的基础设施，并使其可用于在线和批量预测请求。
AutoML Vision Edge帮助部署 Edge 模型(在本地设备上运行，例如智能手机、物联网设备)并可以基于本地数据触发实时操作。
我们最近写了一篇探索 Edge AI 的文章(图片授权给作者)
我们在最近的文章中讨论了边缘人工智能的重要性。
TensorFlow Enterprise为您的 tensor flow 实例提供企业级支持。
5。ML 管道(ML 操作)
授权给作者的图像
ML Ops 是部署健壮的、可重复的和可伸缩的 ML 管道来管理您的模型的实践。人工智能平台提供了许多服务来协助这些管道。
AI 平台管道 使用 Kubeflow 管道或 TensorFlow Extended (TFX)提供创建 ML 管道的支持。
持续评估 帮助您监控您的模型的性能，并对您的模型在一段时间内的表现提供持续反馈。
深度学习虚拟机映像 支持轻松调配深度学习 ML 应用的云虚拟机。
最后， 深度学习容器 为深度学习环境提供预配置和优化的容器。
授权给作者的图像
我们在最近的文章中深入覆盖了深度学习容器: A Cloud ML first: Google 的 AI 平台深度学习容器，采用 NVIDIA Tensor Core A100 GPU 。
后续步骤
1.请关注本系列的下一篇文章，在这些文章中，我们将更详细地探讨每种服务，并提供实际操作的示例
2.阅读谷歌云 AI 平台文档
3.了解更多关于安科瑞斯数据，分析&人工智能
4.与作者连线
谷歌云推出免费访问新冠肺炎公共数据集计划
旨在帮助研究人员、数据科学家和分析师抗击新冠肺炎病毒。该计划有效期至 2020 年 9 月 15 日。
照片由 Rajeshwar Bachu 在 Unsplash 拍摄
数据在调查、研究和应对突发公共卫生事件的能力中始终发挥着至关重要的作用，这一点在全球危机中尤为突出。访问数据集和能够在云规模上分析数据的工具对于研究过程越来越重要，对于新型冠状病毒(新冠肺炎)的全球应对尤为必要。
2020 年 3 月 30 日，为了帮助研究人员、数据科学家和分析师努力抗击新冠肺炎，谷歌制作了一个新冠肺炎数据集列表，可以在谷歌云中免费访问、查询和建模。
免费包括什么？
据谷歌云产品消息，
* [## 使用免费的公共数据集探索与新冠肺炎相关的有价值的数据，可在谷歌云的…
数据在调查、研究和应对突发公共卫生事件的能力中始终发挥着至关重要的作用
cloud.google.com](https://cloud.google.com/blog/products/data-analytics/free-public-datasets-for-covid19)
以下是免费的
- 新冠肺炎公共数据集的存储，如约翰·霍普斯金系统科学与工程中心(JHU CSSE)、世界银行的全球健康数据、OpenStreetMap 等(完整列表见下一节)。
- BigQuery 将提供对新冠肺炎公共数据集的免费查询。这是对 BigQuery sandbox 中的空闲层的补充，每月最多可以查询 1TB，因此对 COVID 数据集的查询不会计入该配额。
- BigQuery ML 用新冠肺炎公共数据集训练高级机器学习模型，无需额外成本。
⚠️知道⚠️的限制和期限
你必须充分意识到限制和期限，以避免一个惊喜法案。
用新冠肺炎公共数据集存储、访问、查询和训练机器学习模型都是免费的。但是，在分析过程中，如果您将新冠肺炎数据集与非 COVID 数据集、 连接，则非 COVID 数据集中处理的字节将计入空闲层，然后相应收费，以防止滥用 。
该计划有效期至 2020 年 9 月 15 日。
新冠肺炎公共数据集项目包括哪些数据？
在撰写本文时，以下数据集作为新冠肺炎公共数据集提供:
- JHU 冠状病毒新冠肺炎全球病例，按国家分类:这是由约翰霍普金斯大学系统科学与工程中心(JHU CSSE)运营的 2019 年新型冠状病毒可视化仪表板的数据仓库。
- 美国社区调查:来自美国人口普查局的人口统计数据
- OpenStreetMap 公共数据集:包括医疗保健提供者位置的世界地图。
- 来自美国卫生与公众服务部的医院一般信息:已注册医疗保险的医院列表。
- 世界银行的全球卫生数据集:全球卫生和人口趋势。
- 国际人口普查数据:按年龄和性别划分的国家人口。
- 美国十年一次的人口普查数据:2000 年和 2010 年十年一次的人口普查的美国人口原始数据
您可以查看谷歌新冠肺炎数据集列表中添加的其他数据集。
探索数据集
让我们快速浏览一下这些数据集。
从 Google Cloud Marketplace，你可以通过“新冠肺炎研究数据集”进行过滤，它将过滤结果，只包括新冠肺炎公共数据集。
市场中的谷歌新冠肺炎数据集
预览和查询数据
要预览数据集，您可以单击“查看数据集”，例如 JHU 冠状病毒新冠肺炎全球病例。
然后，选择一个表格并使用“预览”选项卡
在 Google Cloud BigQuery 仪表板中预览数据
您可以使用 BigQuery 查询数据，例如查询 2020 年 3 月 31 日美国的确诊病例数
*SELECT
province_state,
confirmed,
FROM
`bigquery-public-data.covid19_jhu_csse.summary`
WHERE
country_region = "US"
AND date = '2020-03-31'
ORDER BY
confirmed desc*
BigQuery 查询 2020 年 3 月 31 日美国确诊病例数
数据集快速概述
所有的数据都很长，不可能提供所有数据的预览。相反，我会给你一个数据集包含的内容的快速概述。希望这可以节省你一些时间，加快你的数据探索。
数据集: covid19_jhu_csse
这是由约翰霍普金斯大学系统科学与工程中心(JHU CSSE)运营的 2019 年新型冠状病毒视觉仪表板的数据仓库。该数据库是为应对冠状病毒突发公共卫生事件而创建的，用于实时跟踪报告的病例。这些数据包括所有受影响国家的确诊新冠肺炎病例、死亡和康复的地点和数量，在适当的省/州汇总。它的开发是为了使研究人员、公共卫生当局和公众能够跟踪疫情。更多信息可在博客帖子 Mapping 2019-nCoV 中找到，包含的数据源在此处列出。
2。 美国社区调查
数据集:人口普查局 acs
美国社区调查(ACS)提供了非常详细的美国人口统计信息，这些信息是在不同的地理级别上汇总的。通过 ACS，我们可以更多地了解工作和职业、教育程度、退伍军人、人们是拥有还是租用他们的房子以及其他话题。政府官员、规划者和企业家利用这些信息来评估过去和规划未来。欲了解更多信息，请参见人口普查局的美国癌症学会信息指南。
数据集: geo_openstreetmap
OpenStreetMap (OSM)是一个合作项目，创建一个免费的可编辑的世界地图。该地图包括医疗保健提供者的位置。OSM 本身是由志愿者生产的公共产品，数据质量没有保证。
数据集: cms_medicare
该数据表包含所有已注册医疗保险的医院列表。该列表包括地址、电话号码、医院类型和护理质量信息。我们为全国超过 4，000 家通过 Medicare 认证的医院提供护理质量数据，其中包括超过 130 家退伍军人管理局(VA)医疗中心。您可以使用这些数据来查找医院，并比较它们的护理质量。
数据集:世界银行 _ 卫生 _ 人口
该数据集结合了各种来源的关键卫生统计数据，提供了全球卫生和人口趋势的概况。它包括来自 200 多个国家的营养、生殖健康、教育、免疫和疾病方面的信息。
6。 国际人口普查数据 :
数据集:人口普查局国际
国际人口普查数据集提供了自 1950 年以来的国家人口估计数和到 2050 年的预测数。具体而言，该数据集包括按出生时年龄和性别划分的年中人口数字。此外，还提供了生育率、出生率、死亡率和移民率等属性的时间序列数据。
7 .。 美国十年一次的人口普查数据
数据集:人口普查局美国
美国人口普查数据集包括 2000 年和 2010 年人口普查的全国人口计数。使用邮政编码列表区(ZCTAs)和大地水准面将数据按性别、年龄和位置分类。ZCTAs 是邮政编码的一般化表示，通常(但不总是)与一个地区的邮政编码相同。大地水准面是数字代码，用于唯一标识人口普查局为其制表的所有行政、法律和统计地理区域。大地水准面有助于将普查数据与其他普查和调查相关联。
帮助更好地了解冠状病毒
当前的疫情已经推动数据科学家和人工智能公司采取行动，帮助设计治疗方法。随着越来越多的公开数据集，机器学习有很大的潜力来帮助争论和获得洞察力。
大概就是这样。感谢阅读。*
用于数据科学工作的谷歌云虚拟机
关于如何使用谷歌云控制台为 Python 数据科学工作设置一个带有 JupyterLab 环境的免费虚拟机的快速指南。
在你的数据科学生涯中，迟早会有一天，你的计算机不再支持你。对于计算量特别大的任务，您可能需要强大的处理能力，或者您可能希望并行运行许多脚本。如果发生这种情况，你有两个选择:你可以投资一台更快的电脑，或者你可以使用云服务。亚马逊、微软和谷歌都有各自的虚拟机产品，所以你有大量的产品可供选择。
在这篇文章中，我将向你展示如何在 Google Cloud 上设置一个虚拟机，并且已经预装了 JupyterLab。这只需要几分钟，一旦完成，您就可以利用云机器的强大功能来进行 Python 数据科学工作了！
开始之前
- 你需要什么:一个谷歌账户。
- 不需要的东西:关于使用终端、在 Linux 中导航等知识。我们将使用谷歌云控制台。
- 花费多少:截至 2020 年 4 月，当您第一次设置您的机器时，您将获得价值 300 美元的信用点数，可以免费使用 12 个月。根据您如何配置您的机器，这个数量应该持续一段时间。你可以在这里阅读更多关于演职员表的信息:https://cloud.google.com/free/docs/gcp-free-tier
帐户设置
首先，转到http://console.cloud.google.com/，如果您没有自动登录，请输入您的 Google 帐户名&密码。
这是您应该在弹出窗口中看到的内容:
选择您的国家，然后点击同意并继续。找到屏幕顶部的免费试用按钮:
您应该会被导航到一个窗口，在这里您可以输入您的信用卡详细信息。总的来说，我们应该小心这个系统:
- 您可以配置每月花费超过 10，000 美元的机器，
- 不运行机器并不能让你完全安全，因为你还要为存储付费。
在这一点上，你应该是安全的，你会看到一条消息，告诉你如何不会自动收费，即使当你的信用用完。(我还没到那一步，所以不能确认确实如此。)
项目设置
首先，你需要一个项目。在屏幕顶部，点击谷歌云平台旁边的区域，(如果你在这篇文章中向下滚动一点，在第二个截图中，你会看到“vmtesting”，这是目标区域，它将为你空着)，然后点击新项目。您应该会看到这样一个窗口，只需输入您的项目名称，然后单击 Create:
现在，您应该会看到您的新项目在左上角被选中:
请注意，屏幕上显示的是空的小部件，因为到目前为止，您的项目基本上是空的。
实例设置
您已经建立了项目，现在您需要一个虚拟机。
点击左上角的导航菜单，向下滚动到人工智能部分，然后点击笔记本。
您应该看到一个空列表，您还没有实例，所以单击 New Instance。有几个选项，如果您正在使用神经网络，可以选择 Tensorflow 版本之一，XGBoost 有一个单独的配置，等等。我们现在用基本的 Python，它将会有熊猫和 scikit-learn。
单击 Python 后，您应该会看到一个包含虚拟机配置的弹出窗口。如果您向下滚动，您应该会看到该机器的估计成本。您可以单击“Create ”,也可以单击“Customize”来调整一些设置，我们现在就要这样做了。
在页面的顶部，您应该看到实例的名称和区域。这些设置没多大关系，最便宜的地区会被自动选中，你可以保留它们。这样就不用换到实际位置了。
您可以在机器上更改的最重要的事情可能是机器配置下的处理能力:
n1-standard-4 是默认选择，有 4 个 CPU。这完全取决于你需要什么，你可以一直使用最低的设置，如果你发现它太慢或者你意识到你需要更多的内存，你可以增加它。如果您正在运行许多并行任务，例如使用 GridSearchCV 进行超参数优化，那么多个 CPU 非常有用。scikit-learn 中可以并行化的一个很好的指标是它们是否有一个n_jobs参数。
当您进行更改时，您可以在屏幕右侧看到估计成本的变化，将机器更改为最低设置会降低价格:
您可能想要更改的另一个设置是磁盘空间。根据帮助文本，只对您正在使用的部分收费。
还有额外的设置，如网络等，我没有改变它们。如果你对你的设置满意，点击底部的创建。加载一段时间后，您应该会在屏幕上看到以下内容:
此时，您的虚拟机正在运行。如果您想要停止它，请通过单击实例旁边的框来选择它，然后单击顶部栏中的 stop 按钮。这也是您稍后返回时可以启动实例的地方，以及如果您不再需要它时如何删除它。
可以点击打开 JupyterLab 开始工作！
在 JupyterLab 工作
在你点击打开 JupyterLab 之后，一个新的标签会在你的浏览器中打开，带有 JupyterLab 设置。
在右侧，您只需点击笔记本图标即可在 Jupyter 笔记本中工作:
虚拟机预装了一些广泛使用的库，如 scikit-learn，但您可能需要其他库。如果是这样的话，你可以简单地使用pip，只需在笔记本上输入!pip install <library>，将<library>改成你需要的任何东西。
如果您想连接到现有的 GitHub 存储库，您可以很容易地做到这一点。在左侧，你可以看到你的机器的文件夹结构，应该是空的，除了一个教程文件夹，你可以检查有用的提示。您可以在这里创建新文件夹、上传文件、在文件结构中导航等。要克隆一个存储库，您可以单击 Git 图标:
并复制回购的网址。
现在，您可以在虚拟机中处理您的文件。要推回到 GitHub，您可以通过点击垂直面板中的 Git 图标来打开平台的内置功能:
我发现在 JupyterLab 环境中使用终端更方便，在启动窗口的底部，使用标准的git命令:
在我的虚拟机上使用 GitHub 时，我遇到了一个问题:如果你使用大文件存储功能来上传比如说大的csv文件，这些文件将无法正常工作。您将看到类似这样的内容:
应该有一个解决办法，但我只是手动将文件分别上传到机器上。
最后，也许是最重要的一步:确保在不需要的时候关闭机器。使用 JupyterLab 关闭浏览器窗口，返回到笔记本实例，选择您的实例，然后单击 Stop 按钮。
如何查看自己的积分
要查看您还剩多少免费点数，请转到左侧的导航面板，然后单击“计费”:
在屏幕的右侧，有一个显示您剩余学分的图表:
在每个月的第一天，您会收到一张发票，上面详细列出了您每月的费用。请注意，有些费用可能会让您感到惊讶，例如，我不知道还有单独的静态 Ip 费用。但这就是免费学分的用途:去实验！
其他选项
到目前为止，我们已经介绍了基础知识，我认为这应该足够让您入门了，但是您还可以使用许多其他功能。对于某些任务，比如为图像识别而训练的神经网络，你可能需要在你的机器上增加一个 GPU。但是，您将无法使用默认计划做到这一点，您需要首先更改您的配额。
为此，请转到导航面板，在 IAM & Admin 部分中查找配额。
搜索 GPU，将你的配额从 0 增加到 1。
但是请注意，当我这样做并更新我的帐户时，我收到一条消息，说一旦我的免费点数用完，我将不再收到确认请求，我将自动被收费。
文件和参考资料
我希望你觉得有用。
谷歌云有非常广泛的文档供你研究。
如果你想自己设置你的机器，而不是依赖预先设置的配置，你可以看看这个有用的帖子。
Google Colab:它与支持 GPU 的笔记本电脑相比如何？
Colab 简介、运行时、性能比较…以及疑难解答
如果你没有生活在岩石下，你很有可能使用过或者至少听说过Google co laboratory——一个基于云的笔记本环境，让你在 Google Drive 中编写、执行和共享代码。
但是和我们都熟悉并深入了解的【Jupyter Lab 相比如何呢？敬请期待一探究竟。
如果你对 Colab 一无所知，这里有几个要点可以帮助你步入正轨:
- 相当于 JupyterLab——做了一些调整
- 由 Google 托管 —笔记本自动保存到 Google Drive
- 免费访问 GPU(图形处理单元)和 TPU(张量处理单元)
- 专为数据科学打造 —绝大多数数据科学库都是预装的
因此，仅仅通过查看这些要点，听起来似乎是一笔不错的交易，但让我们把这种说法留到最后——因为只有到那时，我们才能利用数据做出结论。
这篇文章的结构如下:
- 创建笔记本
- 运行时环境
- 性能比较
- 判决
所以事不宜迟，我们开始吧！
创建笔记本
这个过程再简单不过了——直接去colab.research.google.com。如果你登录到你的谷歌账户，会弹出这样一个窗口:
现在，您可以通过点击模式窗口右下角的新笔记本按钮来创建新笔记本。几秒钟后，你会看到一个熟悉的屏幕:
如果你不喜欢默认的灯光主题，你可以很容易地改变它。只需进入工具—设置，在那里会弹出这个模式:
主题默认设置为亮，如果你愿意的话可以改成暗，点击保存。我真的很喜欢黑色主题，但浅色主题更适合这篇文章，所以我会坚持下去。
在单元格中，您现在可以简单地导入您需要的任何库并开始工作。大多数库都是预装的，所以少了一件需要担心的事情。为了演示，让我们导入 Numpy 并做一些快速数组添加:
很好，这里没有什么新的东西，但它仍然是一种验证一切正常工作的有效方法。
现在，我非常怀疑您会使用 Colab 来处理 Numpy(除非您正在处理一个马铃薯)，所以在下一节中，我们将简要地探索您可以使用的各种运行时。
运行时环境
Colab 主要用于处理 GPU 密集型任务——比如训练深度学习模型。这是它背后的基本思想——每个人都可以访问 GPU 或 TPU。
因此，让我们快速探索如何切换到 GPU/TPU 运行时。只需转到运行时选项卡，选择更改运行时类型:
像这样的模态窗口会弹出，在这里你可以从无切换到更合适的:
我已经选择了 GPU。几秒钟后，GPU 将分配给你，如果可用。我们可以用任何深度学习库来验证这一点，我将使用 PyTorch :
现在，不能保证你会得到和我一样的 GPU，所以请记住这一点。
好了，你现在已经熟悉了 Google Colab，那么在下一节中，我们将把它的性能与我的一堆笔记本电脑进行比较，同时也与 Google Colab 的 CPU 运行时进行比较。
性能比较
为了进行快速的性能测试，我决定使用 PyTorch 库在时尚-MNIST 数据集上进行训练。该模型具有以下架构:
所以这里没有什么特别的，大约 15 万个可训练参数(权重和偏差)需要优化。除了 Google Colab，我还会使用我目前拥有的三台笔记本电脑:
- 联想 ThinkPad T480s: 英特尔 i7–8550 u @ 1.8 GHz，16GB 内存
- 联想军团 Y540: 英特尔 i5–9300h @ 2.4 GHz，Nvidia GeForce 1650 4GB，16GB RAM
- MacBook Pro 2019 13": 英特尔 i5-QC @ 1.4 GHz，8GB 内存
最后一个说明: model 是为 ThinkPad 和 MacBook Pro(显然)在 CPU 上训练的，而为联想军团在 GPU 上训练的。在 Google Colab 上，我在第一个笔记本上使用了 CPU 运行时，在第二个笔记本上使用了 GPU 运行时。
让我们来看一个比较培训时间的快速图表:
Colab (GPU): 8 分 43 秒；MacBook Pro: 10 分 29 秒；联想军团:11:57 分钟；Colab (CPU): 18 分 10 秒，ThinkPad: 18 分 29 秒
这就是你要的——Google Colab，一个比我的支持 GPU 的联想军团笔记本电脑还快的免费服务。出于某种原因，MacBook 的表现超过了它，尽管它只有四核 1.4GHz 的 CPU。ThinkPad 作为这里最贵的设备表现最差。
现在，我们能够做出数据驱动的结论—让我们在下一节中这样做。
判决
玩具时尚-MNIST 数据集绝不具有足够的代表性来做出防弹结论——因为这需要更大的数据集和更多的训练周期——但我们可以得出结论，如果你没有 3000 美元的游戏电脑，谷歌可乐实验室可能是一个福音。
这里有一些T21 的问题，比如:
- 运行时断开 —如果笔记本闲置一段时间，运行时将断开
- 内存 —内存不足是有可能的
- 依赖 —不能保证 GPU 或 TPU 会在你需要的时候可用，所以请记住这一点
即使有所有的警告，它仍然很容易推荐——至少通过使用它你的电脑不会变热——这对即将到来的夏季至关重要。
感谢阅读。
喜欢这篇文章吗？成为 中等会员 继续无限制学习。如果你使用下面的链接，我会收到你的一部分会员费，不需要你额外付费。
[## 通过我的推荐链接加入 Medium-Dario rade ci
作为一个媒体会员，你的会员费的一部分会给你阅读的作家，你可以完全接触到每一个故事…
medium.com](https://medium.com/@radecicdario/membership)
如何在 Google Colab 中导入和导出数据集
从本地系统和 Google Drive 下载和上传 Colab 中的文件
被称为 Colab 的 oogle Colaboratory 是一个免费的 Jupyter 笔记本环境，有许多预装的库，如 Tensorflow、Pytorch、Keras、OpenCV 等等。它是免费支持 GPU 和 TPU 的云服务之一。在 Colab 中导入数据集和数据训练模型有助于提高编码体验。我们可以应用不同的方法在 Colab 中导入和下载数据。在本教程中，我将讨论我在以下方面的经验:
- 从 Google Drive 导入数据
- 将数据导入和下载到本地系统
安装 Google Drive
我们可以通过安装谷歌硬盘来访问硬盘中的文件。将硬盘安装到 Colab 意味着将 google drive 帐户设置为虚拟硬盘，这样我们就可以像访问本地硬盘一样访问硬盘的资源。
步骤 1 要连接 Google Drive (GDrive)和 Colab，在 Colab 中执行下面两行代码:
from google.colab import drivedrive.mount("/content/gdrive")
运行 shell 将返回一个 URL 链接，并询问授权码:
第 2 步按照提到的链接，登录谷歌账户，点击高亮显示的位置复制授权码:
第三步将授权码粘贴到 shell 中，最后 Google Drive 会挂载到 /content/gdrive 。注意，驱动器中的文件在文件夹/content/g Drive/My Drive/下。现在，我们可以使用像 Pandas 这样的库在 GDrive 中导入文件。
步骤 4 例如，我们在 GDrive 的 /My Drive/sample data 文件夹中有一个数据集(sample.csv)。
执行下面两行代码会将数据导入 Colab:
import pandas as pdpd.read_csv('/content/gdrive/My Drive/sample data/sample.csv')
从本地系统导入数据
步骤 1 运行下面两行代码，从本地系统导入数据。
from google.colab import filesuploaded = files.upload()
执行 shell 将调用一个浏览按钮:
第二步浏览本地系统中的目录，我们可以上传数据到 Colab:
最后，我们可以使用像 Pandas 这样的库来读取数据:
pd.read_csv("sample.csv")
将数据下载到 Google Drive 和本地系统
假设数据集已经是 CSV 格式，我们可以通过执行以下两行代码轻松地将数据下载到本地目录中:
from google.colab import filesfiles.download('sample.csv')
通过执行下面的代码可以下载 pandas 数据帧。假设 dataframe 的名称是“sample ”,那么使用一行代码将文件保存在 Google Drive 中:
sample.to_csv('sample.csv')
最后，要下载到本地驱动器，请执行以下单行代码:
files.download('sample.csv')
作为额外的来源，你也可以阅读这个博客来了解更多关于如何在 Colab 中处理文件的信息。
阅读默罕默德·马苏姆博士(以及媒体上成千上万的其他作家)的每一个故事。
你的会员费将直接支持和激励穆罕默德·马苏曼德和你所阅读的成千上万的其他作家。你还可以在媒体上看到所有的故事—【https://masum-math8065.medium.com/membership】
快乐阅读！
谷歌数据工作室:可视化数据的 5 个图表
数据科学控制面板主要图表的详细概述
一个虚拟数据的示例，描绘了在一个仪表板上编译的 5 个流行图表。作者在Google Data Studio【1】上截图。
目录
- 介绍
- 关于数据集
- 树形图
- 堆积组合图
- 圆形分格统计图表
- 带有热图的数据透视表
- 平滑折线图
- 结论
- 参考
介绍
本文是万物教程系列的一部分谷歌数据工作室 (GDS) [1]。这个系列的第一篇文章可以在这里找到【2】。作为 GDS 系列的第二部分，本教程将介绍特定类型的可视化。对于每个图表，都有可变的维度、度量、排序、日期范围、交互和样式菜单。除了这些图表，还有您可以添加的文本，以及数据和过滤控件。下面用于本教程和图表突出显示的数据集有一个过滤器控件，用于显示某些类别而不是其他类别。如果您想要放大或缩小数据，日期范围过滤器(也包含一个下拉菜单)会很有用。这些功能中最好的部分是，当您在仪表板视图中编辑过滤器时，数据也随之调整，并带有相应的图表。
关于数据集
数据集是在谷歌表单中创建的虚拟数据。它是为了模拟 2020 年冠状病毒疫情数据集的类似领域而开发的。这些字段包括日期、区域、记录计数和虚拟类别。当遵循本教程时，不同的数据集，如真实的冠状病毒数据集 [3]只能用于教育和学术研究目的。
树形图
树形图是可视化你的维度空间的极好方式。最适合用于分类数据，该图表通过增加或减少您选择的指标的大小来工作。例如，下图不仅描述了最具影响力的数据类别的大小，还添加了一个热图图层，有助于强调某些类别。这个图表的另一个有用的特性是，一旦进入仪表板模式，树形图中使用的数据可以通过多种方式下载。
GDS 的树形图，后面是它的下拉菜单。作者在Google Data Studio【1】上截图。
堆积组合图
堆叠组合图很有用，因为它结合了流行的条形图和分层的折线图。如果您想描述两个相似的指标，同时在一条线上分层以示强调，这个图表很好。除了多层方法之外，还可以通过将鼠标悬停在特定日期范围上来描述数据。
堆叠组合图及其悬停菜单。作者在Google Data Studio【1】上截图。
圆形分格统计图表
饼图及其悬停菜单。作者在谷歌数据工作室【1】上的截图。
虽然饼状图似乎是旧闻，但在 GDS，规格的数量似乎是无穷无尽的。例如，对于选择绘制图表的指标，GDS 大多数图表中使用的排序方法，可以显示不同的聚合。一些聚合包括总和、平均值、计数、非重复计数、最小值、最大值、中值、标准差和方差。一旦选择了一种分类，你就可以决定是降还是升你的数据。在下面的饼图中，我选择只使用一种颜色渐变，但你可以很容易地切换到多色不同的效果。
带有热图的数据透视表
在 GDS，一般的数据透视表实际上有 3 个子层面:数据透视表、带条的数据透视表和带热图的数据透视表。使用您的维度作为索引，日期范围作为列，指标将是最小值和最大值以热图形式着色的值，以显示您的指标的重要性(这种效果有点类似于 Excel 中的条件格式，但可以显示渐变)。
带有热图的数据透视表。作者在谷歌数据工作室【1】上的截图。
平滑折线图
平滑折线图通常用于显示时间序列，但我想展示分类数据是如何表达的。在下图中，地区(美国各州)在 X 轴上，而指标值在 Y 轴上，所有指标都以各自的颜色绘制。我相信这张图表是 GDS 所能提供的最好的图表之一，因为它能显示来自你的数据的各种信息。下面，您可以看到分类数据和数字数据，同时相互比较。
平滑的折线图及其悬停菜单。作者在Google Data Studio【1】上截图。
结论
GDS 有大量不同的可视化工具来描述你的数据和指标。事实证明，它们是展示您的探索性数据分析的有用方法，同时也是展示您的即席数据科学指标的有用方法。本教程是 GDS 系列的一部分，如果你对本系列的后续文章有任何问题或特殊要求，请在下面评论。
参考
我的 Google Data Studio 仪表板是使用虚拟数据集创建的。要素/字段/列也是虚拟属性。这些图片是我自己的 GDS 仪表板截图。我的仪表板截图中显示的数据和指标不得用于任何医疗目的。它是静态的、非真实的，并且不依赖于准确性。它纯粹是为了教程的目的而开发的。
[1] M.Przybyla，谷歌数据工作室 (2020)
[2] M.Przybyla，谷歌数据工作室教程简介 (2020)
[3] K.Sudalairaj，新型冠状病毒 2019 年数据集 (2020)
谷歌数据工作室教程简介
数据科学家可视化其探索性数据分析的方法
使用 geo map 功能描述美国各州记录计数的虚拟数据示例。作者在Google Data Studio【1】上截图。
目录
- 谷歌数据工作室是什么？
- 为什么对数据科学家有好处？
- 关于数据集
- 我如何开始观想(教程)？
- 警告
- 结论
- 参考
谷歌数据工作室是什么？
谷歌数据工作室 (GDS) [1]是一个免费的、易于使用的平台，用于可视化地描述你的数据。与直接编写 Python 代码或使用 Tableau 许可相比，它有许多优点和好处。
- 这很有价值
- 它是互动的
- 有黑暗模式
- 它免费、简单、快捷
- 你不需要执照
- 它可以通过实时连接进行更新
- 它不仅可以用于 EDA，还可以用于模型性能度量
- 您可以与不需要知道如何下载 Jupyter 笔记本的非技术用户共享此仪表板
- 你不需要依赖 Python 代码；但是，您可以使用他们的 GDS 语言创建新字段，这与 Excel 非常相似
关于数据集
数据集是在谷歌表单中创建的虚拟数据。它是为了模拟 2020 年冠状病毒疫情数据集的类似领域而开发的。这些字段包括日期、区域、记录计数和虚拟类别。当遵循本教程时，一个不同的数据集，如真实的冠状病毒数据集 [2]只能用于教育和学术研究目的。
为什么对数据科学家有好处？
GDS 是 Python 编码和 Tableau 的独特替代品。这是一种在开发数据科学和机器学习模型之前和之后可视化数据的简单方法。今天，我们将探讨使用前，展示 GDS 如何对您的 EDA 产生积极影响，同时还可以执行临时分析。这种类型的仪表板的一个示例包括来自您的模型的度量，可能是准确性、计数、警报、置信度得分的聚合以及模型预测的趋势。
我如何开始观想(教程)？
- 创建新报告
从模板开始，或通过单击空白报告创建新的仪表板。这些模板非常适合启发如何构建您的仪表板，但由于它们使用预定义的数据集，可能很难用您的数据模拟可视化效果。我建议从空白报告开始，如下面的彩色加号所示。
主页包括新的报告和模板。作者在Google Data Studio【1】上截图。
2.连接您的数据
有各种各样的连接可以利用，这将是您的数据分析的基础。把这一部分想象成把一个 CSV 文件作为熊猫数据帧读入你的 Jupyter 笔记本。上传数据最简单的方法是执行文件上传。正如你在下面看到的，有 17 种可能的连接形式。一个非常有用的数据上传技巧是，如果你连接到一个实时数据源，如 Google Analytics 或 BigQuery，你也可以实时显示你的 GDS 仪表板。
以多种方式连接到您的数据。作者在谷歌数据工作室【1】上的截图。
3.可视化您的数据
与 Tableau 类似，GDS 允许您组织源自表格格式数据的维度和指标。在 GDS，有数不清的方法可以用几个图表来形象化。图表包括:
- 表格、记分卡、时间序列、条形图、饼图、地理图、折线图、面积图、散点图、数据透视表、项目符号和树形图。
您开发的可视化效果可以通过操纵视觉形状上的点来缩放。轴也可以根据您的喜好轻松编辑。还可以显示表格式数据的颜色编码表示，这可以突出显示字段中较大或较小的值。与 Excel 中的条件格式类似，这种方法在 GDS 中比手写代码更容易执行。要了解更多关于具体特性以及它们如何随着时间的推移而变化，有一个论坛，有用的答案显示在这里这里。
仪表板的主页。可以对可视化效果进行拖放、调整大小和编辑。作者在Google Data Studio【1】上截图。
警告
有哪些主要的含义？
对于任何数据科学或数据分析工具，充分了解聚合函数至关重要。例如，您的数据中有一些指标可以通过多种方式可视化，即使它们来自相同的来源:总和、平均值、计数、不同计数、最小值、最大值、中值、标准偏差和方差。缺点是你可能有一个你认为你理解的数字，但是当有一个度量的自动设置时，你可能描绘不同的集合信息。这些变化可以被证明是一种优势，因为它们可以快速显示通常在 SQL 或 pandas 库代码中使用 Python 计算的指标，但速度要慢得多。
结论
数据科学家、数据工程师、业务分析师和机器学习工程师可以利用各种工具。有些更贵，有些可能太复杂，同时也很耗时。GDS 帮助你，让更多的时间与建模，因为 EDA 过程被缩短和简化。另一个好处是一种快速可靠的可视化模型性能指标的方法。GDS 可能不适合所有人，但它是一种通过充分了解您的数据并能够直观地证明它来给利益相关者留下深刻印象的可靠方法。
参考
我的 Google Data Studio 仪表板是使用虚拟数据集创建的。要素/字段/列也是虚拟属性。这些图片是我自己的 GDS 仪表板截图。我的仪表板截图中显示的数据和指标不得用于任何医疗目的。它是静态的、非真实的，并且不依赖于准确性。它纯粹是为了教程的目的而开发的。
[1] M.Przybyla，谷歌数据工作室 (2020)
[2] K.Sudalairaj，新型冠状病毒 2019 年数据集 (2020)
创业公司需要问的关于人工智能的三个问题
第一个是:你确定你需要 AI 吗？
劳伦·玉木为谷歌创作的插图
数十亿美元的人工智能投资正在蓬勃发展。这对期待人工智能为其创新和竞争优势的初创公司来说意味着什么？
策略似乎很简单:用机器学习解决人类的一个长期问题。谷歌、脸书、网飞和优步做到了。一个显而易见的问题是为什么不使用人工智能？至少，你的新战略保证会有创业公司成功所必需的时髦词汇。
人工智能有意义地增强用户体验的例子数不胜数。但是，也有一些问题根本不会从人工智能中受益，如果应用人工智能，情况可能会更糟。
我们将带你经历一个决策过程，可以帮助你评估人工智能是否是你业务的正确方法，包括:确定对人工智能的需求，如何让用户控制结果，以及为什么人工智能不是真正的魔法。
确定需求:你在人工智能上的投资会增值吗？
如今的企业家经常以问“我们如何用人工智能解决 X”开始他们的旅程虽然这可能是一个很好的起点，但如果不能为用户或客户提供独特的价值，即使是最好的人工智能系统也只会消耗资源。你的首要任务应该是评估人工智能可以在哪些方面增加独特的价值。
是的，人工智能可以为披萨推荐平台、年龄猜测应用程序甚至假猫照片生成器…但要问的关键问题是，人工智能是否正在以一种有意义或独特的方式解决问题。
人工智能解决方案，或者说为了自身而使用人工智能，是一个在著名的马斯洛和卡普兰定律中说明的问题:如果你“给一个小男孩一把锤子……他会发现他遇到的所有东西都需要敲打。'
那么，你如何知道人工智能是否适合手头的问题呢？
用户需求是否被确定为需要人工智能解决方案？就像产品-市场匹配的想法一样，有一个潜在的需要来考虑人工智能-用户匹配。
进行用户研究，审查调查数据，观察用户的生活可以将你的产品理念从技术第一转变为以人为本，这意味着从人工智能“仅仅因为你可以”转变为人工智能 “因为它独特地解决了核心用户需求。”
使用人工智能没有正确或错误的动机。但是，推出一个人工智能支持的客户支持聊天机器人是一回事，帮助客户更容易进行交易是另一回事，推出这个聊天机器人只是因为它目前很流行。
IDEO 的设计套件和 Google 的 People+AI 指导手册可以帮助你识别 AI 可以增加独特价值的用户问题。
马库斯·温克勒在 Unsplash 上拍摄的照片
程序化规则与启发式规则
一些用户问题最好使用试探法和显式编程规则来解决，而不是复杂的人工智能模型。例如，想想在 Instagram 和抖音这样的应用程序中，社交媒体是如何组织的。
一种组织 feed 的方法是使用 ML 预测模型来预测特定用户最喜欢的内容。这考虑了用户推断的兴趣、个人信息和过去与应用程序的交互。ML 模型将基于预测的参与度对所有内容进行排名，并向个人用户呈现最“相关”内容的最佳猜测。
或者，你可以使用试探法来解决对你的社交 feed 进行排名的问题，而根本不需要任何机器学习。首先考虑显示最近发布内容的提要。一些研究表明，用户实际上可能更喜欢按时间顺序排序的订阅源，因为它们可能给用户带来更多的一致性和控制。
另一种方法是允许用户自己手动投票赞成或反对内容，这与 Imgur 等流行图像板上的投票系统以及 Reddit 和 Digg 等聚合器没有什么不同。然而，在这种情况下，人工智能可能会对维护用户的透明度和可预测性产生反作用。更不用说，如果用户觉得“客观”的用户评级受到不透明的 AI 层的某种影响，民间理论和不信任就会比比皆是。
让用户控制结果
人工智能产品有两种基本类型:一种是寻求完全自动完成任务的 T2，另一种是寻求增强用户自己完成任务的能力的 T4。当工作重复或计算复杂时，自动化特别有用。当人类的判断对准确性或责任至关重要时，增加任务是最有用的。当人们喜欢自己做这份工作，或者期望围绕这份工作承担个人责任时，这种人工智能与人的合作关系会特别成功。
在这两种情况下，你会发现用户不愿意完全依赖算法预测。研究表明，比起人工智能，人们更喜欢相信人类专家，即使这些专家更容易出错。
即使人工智能决策过程的技术解释能够产生，对许多人来说也很难理解。因此，在你的产品的人工智能模型中建立信任必须通过仔细的沟通来培养。
例如，如果你的应用程序使用人工智能来推荐餐厅，可以考虑让用户选择自我报告食物偏好，并给出关于所去过的地方的反馈。提供完全符合用户特定口味和偏好的推荐的最佳方式是简单地询问他们喜欢什么——即使这意味着使用多少带有偏见的自我报告偏好。这将比任何基于(糟糕的)推断口味的 ML 模型预测有效得多。
将用户放在驾驶座上
如果你的应用程序使用人工智能来建议观看新电影，考虑让用户选择删除或重置一些用于产生推荐的数据。相比之下，如果你的最大似然预测可能有更多的严重后果，考虑给用户选择回顾最大似然预测，并在任何严重损害发生之前潜在地纠正航向。
通过将用户放在驾驶座上来建立信任，允许他们理解和管理他们与你的 AI 的交互。更不用说，共创的习惯会丰富整体产品价值。
其他可解释性的方法可以包括阐明数据源，将解释与用户行为联系起来，与专业的 UX 作家或内容战略家密切合作，以及为用户提供控制人工智能输出的工具。
Franck V .在 Unsplash 上的照片
不要承诺魔法
当用户向他们的智能家居设备询问关于世界的问题时，用爽朗的回答回答的无实体声音可能看起来像魔法一样。像 Alexa 、 Siri 、 Alice 和 Google Assistant 这样的语音助手似乎比任何人类知道的都多，并且随时准备帮助你。但是，呈现个性化的、非常有用的情报的最佳方式是什么呢？
将人工智能作为一种魔法来推销可能很有诱惑力；但是，没有艾魔这种东西。与亚瑟·C·克拉克经常被引用的技术第三定律——“任何足够先进的技术都与魔法没有区别，” 相反，传达魔法的概念不会帮助用户或打动投资者。
“人工智能的魔力”是一种修辞，它让人联想到莫名其妙或无所不能的力量，并往往对人工智能能做什么和不能做什么产生不切实际的期望。这种错位的期望最终会导致失望和脱离。
拟人化的 AI 助手往往会加剧这个问题，直接或间接导致用户认为他们的虚拟助手具有广泛的人类能力。与其将 AI 呈现为一个无所不知的虚拟助手，不如考虑突出助手产品的具体功能，以及这如何有利于用户的目标。这可以帮助用户围绕不断发展的人工智能产品能力逐步更新他们的心智模型。
公平处理
在人工智能魔术的笼统陈述和底层技术的深层技术解释之间，有一个微妙的平衡。太多的机器学习术语会妨碍用户学习使用产品，而不是探索其机制。
Google Flights price insights 功能是复杂机器学习和用户需求平衡整合的一个例子。界面中没有提到【深度学习】或“数据处理”。相反，价格洞察工具只是为用户提供一个有用的提示，告诉他们航班价格目前是低、典型还是高，以及在不久的将来价格可能会发生什么变化。
这个例子还展示了多个 UX 设计元素如何一起工作来解释人工智能预测并培养信任。
亚历山大·辛恩在 Unsplash 上拍摄的照片
您的产品上市了！现在怎么办？
AI 的用户体验和以前不一样了。人工智能产品可以随着时间的推移适应并变得更好。这意味着用户可能需要调整他们对产品如何工作的心理模型，产品所有者也可能需要适应。
例如，如果你正在使用人工智能来管理和过滤你产品的社交媒体，在产品生命周期的某个时刻，你可能会意识到人工智能已经学会优先考虑 clickbait 内容和 cat 视频，而不是重要的新闻文章。这意味着在发布后，你可能想要重新考虑你为优化的内容，以确保用户新闻订阅的多样性以及一致的质量。
随着 ML 模型对给定用户的了解越来越多，新的特性可以提供更多的价值，产品所有者应该适应随之而来的新的使用模式。通过持续倾听用户(严格在隐私或课程的范围内)和运行评估研究来跟踪和衡量你的产品的成功，例如使用快乐跟踪调查、待完成工作跟踪器或首要任务研究。
想要更多吗？
这些建议的背后是对以人为中心的人工智能的承诺。谷歌的 People+AI 指导手册是一个开放的免费资源，提供了更多关于如何设计以人为中心的人工智能产品的例子和建议。
该指南为人工智能 UX 的风险和机遇提供了新的视角。主题包括用户信任和心智模型，每个都有工作表和资源来帮助您构建以人为中心的人工智能产品。
现在轮到你了——你的人工智能驱动的初创公司正在等待。
作者: Slava Polonski， 谷歌研究员编辑: Alexandra Hays， 谷歌作家
谷歌哈希代码 2020:贪婪的方法
我们如何在比利时获得第 16/204 名，在全球获得第 531/10724 名
谷歌哈希代码
谷歌每年都会组织一场名为 Hash Code 的编程比赛。目标是在 2 到 4 人的团队中在 4 小时内解决一个优化问题。这项比赛吸引了来自世界各地的成千上万的参赛者。这是我第一次听说它，所以我决定和布拉姆·斯廷温克尔以及 T2·皮特·德·克雷默一起参加。
扫描多个图书馆中的图书
今年的目标是通过在有限的几天内扫描分布在不同图书馆的不同书籍来获得最高分。同一本书可以在不止一个图书馆买到。每本书都有一个分数，每本书只能获得一次分数(即扫描两本相同的书只能获得一次分数)。此外，每个图书馆都有特定的“注册”时间(启动/开始时间)和不同的吞吐量(每天可以扫描的图书数量)。在每个时间实例中，只有一个图书馆可以执行注册过程，而书籍的扫描可以并行进行。示例(和(非最佳)解决方案):
最优化问题的一个简单例子。书 0，1，2，3，4，5 分别被赋予 1，2，3，6，5，4 的分数。总点数将是:点数(第 0 天)+ … +点数(第 6 天)。第 0-2 天不奖励任何积分，因为没有扫描书籍。第三天 4 分，第四天 3 分，第五天 9 分。第 6 天不计分，因为书 2 和书 3 已经扫描过了。总分为 16 分。这当然不是一个很好的解决方案，因为 book 4 永远不会被扫描，而 library 0 的注册时间更短，吞吐量更高。
总的来说，我们有 6 个不同的输入/问题，具有不同数量的特征(许多图书馆，许多书，所有书的分数相同，没有书的副本，等等。).
第一种方法
我们的第一个方法是给每个图书馆分配一个分数，这个分数由它在截止日期前可以扫描的书籍的分数总和组成:
通过计算可以及时扫描的最高书籍分数的总和，计算所有图书馆在一次扫描中的分数
然后，我们按照分数的顺序(降序)开始注册图书馆。这导致了大约 1510 万分的分数。
重新计算分数
第一种方法非常快，因为它只对库执行一次遍历。不幸的是，它没有得到那么好的分数，因为它没有考虑到重要的因素。这种因素的一个例子是，在每个时刻只有一个库可以执行它的注册过程。因此，我们可以安排一个新的库在前一个库的注册过程之后开始扫描。我们更新了代码以选择最佳库，然后跟踪已经过去的总注册时间:
我们现在跟踪一个 time_total 变量
这次更新取得了 1550 万的成绩。虽然我们的代码现在慢了很多，因为它是库数量的平方(给每个库分配分数→选择最好的一个→更新计数器→重复)。因此，我们不再能够解决第四个输入问题，因为库的数量太多了。
从池中移除扫描的图书
另一个重要的因素是，扫描同一本书的多份副本并没有额外加分。由于我们的代码已经记录了经过的总时间，我们只需使用一个 set 来存储已经分配的书籍。
我们最新的配方。书籍和指定书籍是集合，\是集合差
考虑注册时间
我们及时进行的最后一项调整是更新公式，以计算在考虑注册时间时可以达到的平均分数，而不是只计算总和。这对于每个图书馆的图书数量很少的一些问题来说非常重要，因为当他们扫描完所有的图书时会有很多空闲时间。在第一次迭代中，它会选择得分最高的图书馆，忽略它的吞吐时间。最终的公式和最终版本的代码可以在下面找到:
除以注册时间会产生显著的增益
这次更新是迄今为止最重要的一次，因为它将我们的分数提高到了 2660 万。
问题 D 的简化快速版本
在完成所有这些更新后，我们只剩下大约 20 分钟的时间了。我们决定把重点放在问题 D 上，因为只有我们的代码的第一个版本解决了这个问题(这个版本不太好)。通过检查输入，我们看到这个问题有一些非常独特的性质:所有的图书馆都有相同的吞吐量和注册时间，每本书的分数都是相同的。唯一的区别是图书馆里有多少书。因此，我们通过计算每个图书馆中尚未扫描的书籍数量来计算我们的分数。这一过程持续了大约 15 分钟，在只剩下几分钟的时间里，我们成功地提高了问题 D 的 20000 分，使我们的分数达到大约 2680 万分，这使我们在比利时排名第 16/204 位，在全球排名第 531/10724 位。
我们资格赛的证书。
吸取的教训和可能的改进
- 我们检查我们的输入问题太晚了。每个问题都有独特的性质，你贪婪的方法应该适合这些。
- 为了编写针对每个子问题的定制方法，您确实需要快速拥有一个强大的基础版本。
- 为了进一步提高分数，可以进行不同的调整。排名第一的成绩是 27203691，只比我们的分数高 1.5%。可能的改进包括(I)考虑书籍的频率；㈡稍微修改公式；(iii)局部邻域搜索(对解决方案进行小的修改以检查它是否改进)；㈣等等。
我们绝对做得不错，这是一次有趣的挑战！如果你是排名在我们之上的 530 个团队中的一员，或者有一些可能改进的想法，一定要让我们知道！
附录:最佳解决实践问题
今年，还提供了一个简单的玩具问题，作为真正比赛的热身。问题陈述很简单，你得到一个披萨的集合，每个披萨有不同的切片数和一个数字 M，目标是订购披萨，使得切片总数接近(不超过)M:
如果 M 等于 17，那么订购比萨饼 S0、S2 和 S3 是最佳解决方案，因为这将给我们总共 16 块。
很容易看出这只是对背包问题的一种重新表述。对于像古罗比这样的强有力的解决者来说，这简直是小菜一碟:
我们基本上用 K 个二进制变量创建了一个数组 asm，K 是比萨饼的数量。如果 asm[i] = 1，那么这意味着我们正在订购 pizza i。目标是 asm[i]*score[i]之和尽可能高(或者与 M 之差尽可能低)，附加约束是它不能超过 M。脚本将读取目录中的所有文件，并写出输出文件。
Google It:使用 NLTK、GloVe 和 t-SNE 可视化你自己的 Google 搜索历史中的单词簇
图片来自 Pixabay 。
在谷歌出现之前，电视游戏节目《谁想成为百万富翁》中的电话交友实际上是什么样的？作为一个 90 年代的孩子，我可能是经历过翻遍图书馆书籍和百科全书的最后一代人(有人知道 Encarta 或 Britannica 吗？)来满足自己的求知欲。我们现在通过搜索引擎获得的信息量简直令人震惊，以至于“谷歌 it”已经成为它自己的动词。
几年前，谷歌开始允许用户从各种谷歌相关服务下载自己的数据。正如旧的家庭视频和脸书帖子可以提醒我们生活中的各种快照(好的、坏的和丑陋的)，我们生活在一个我们的搜索历史同样可以做到这一点的时代。如果你像我一样是一个经常使用谷歌的人，一想到这一点就会感到害怕。
为了教育的目的，我将继续把我的隐私放在线上，并展示我的谷歌搜索历史的一个小快照，并展示你可以如何跟随并做同样的事情。
1.从谷歌下载你的数据
对于那些决定服用红色药丸(原谅书呆子矩阵参考)的人，首先导航到:【https://takeout.google.com/】T2 并登录你的谷歌账户，如果你还没有这样做。
这个页面显示了你可以从所有谷歌相关服务下载的所有数据。由于我们只对从“谷歌搜索”下载数据感兴趣，请点击“取消全选”按钮并向下滚动，直到您看到一个名为“我的活动”的部分，然后点击旁边的复选框。
接下来，单击“包括所有活动数据”按钮，出现一个新的弹出框，显示您可以下载的所有活动的列表，然后单击“取消全选”。
向下滚动并找到“搜索”，选择其复选框并单击底部的“确定”。
继续浏览页面，然后单击“下一步”，这将允许您导出和下载您的数据。
2.从 HTML 文件中提取搜索词
您从 Google 获得的下载输出文件(在压缩的。拉链还是。tgz 文件夹)是一个名为“MyActivity.html”的 HTML 文件。您可以在首选浏览器中查看搜索词、日期和其他元数据，但请记住，根据您的文件大小，可能需要一段时间才能打开。
我编写了一个 python 脚本来解析 html 文件，并将搜索词和相应的日期保存到一个 CSV 文件中，该文件将用于进一步的处理。本文不会讨论 html 文件的解析，但是可以随意导航到我的 Github 库获取详细信息，在那里您还可以派生、下载和实验解析您自己的 html 文件。在运行我的 python 脚本后打开导出的 CSV 文件，应该会生成如下所示的表格:
3.使用 NLTK 的标记化
NLTK 或自然语言工具包是 python 中的一个平台，其中包含许多用于 NLP 任务的有用的文本处理库，比如我们将在这里使用的标记化。标记化是 NLP 中常见的预处理任务，通过它，您可以将类似“自然语言处理很有趣”的句子分割成类似“自然”、“语言”、“处理”、“是”、“有趣”的单个单词。
让我们清理我们的 CSV 文件，并通过首先导入必要的包并将 CSV 文件作为 pandas dataframe 读取来对我们的搜索词应用标记化。
import os
import pandas as pd
import nltk
import gensim.downloader as api
import numpy as np
from sklearn.preprocessing import StandardScaler, MinMaxScaler
from sklearn.decomposition import PCA
from sklearn.manifold import TSNE
from nltk.tokenize.treebank import TreebankWordDetokenizer
import matplotlib.pyplot as pltdataDF = pd.read_csv('./data.csv')
在我的特定数据集中，我有大约 60，000 个搜索词(行),但我们需要删除任何可能为空、包含错误值或仅包含非英语单词或符号的搜索词。
让我们看看是否有空行:
dataDF.isna().any()
删除缺少值的行:
dataDF.dropna(axis = 0, inplace=True)
浏览每一列将有助于我们发现任何错误的值:
dataDF.describe(include = ['object', 'int64'])
Jupyter 笔记本中的这个汇总表显示，我们的“日”列中的值超出了一个月中某几天的正常范围。小于 1 的最小值和大于 31 的最大值。这很可能与我的 HTML 解析器不能区分作为搜索词一部分的数字和时间戳有关。我们将采用的一个简单解决方案是只保留不包含超出范围值的行:
dataDF = dataDF[(dataDF['Day']<32)&(dataDF['Day']>0)]
现在，我们检查您是否有仅包含非英语单词或符号的搜索词:
~dataDF['Term'].str.contains('[A-Za-z]').any()
以及任何包含数值的术语:
dataDF['Term'].str.contains('[0-9]').any()
让我们确保所有的字符都是小写字母:
dataDF['Term'] = dataDF['Term'].str.lower()
我们的数据帧现在可以进行标记化了！
使用 NLTK 进行标记化非常简单，只需要在函数 nltk.word_tokenize()中输入一个字符串，如下所示:
nltk.word_tokenize("hey there")
要获得单个单词的列表:
我们可以使用 apply()函数标记数据帧中的每一行:
dataDF['Term'] = dataDF['Term'].apply(nltk.word_tokenize)dataDF.head()
在单词嵌入之前，一个常见的预处理步骤是去除常用的英语单词，如“我”、“他”、“我的”、“和”等。也称为“停用词”以及任何符号和标点符号。NLTK 包含一个停用词语料库，我们将使用它来过滤数据帧中的每一行。我们可以下载所有的语料库(包括停用词)，删除停用词和标点符号，如下所示:
nltk.download() #Only required the first time
stopWords = nltk.corpus.stopwords.words('english')def removeStopWords(words):
removed = [w for w in words if not w in stopWords]
return removed;def removeSymbols(words):
removed = [w for w in words if w.isalnum()]
return removed;dataDF['Term'] = dataDF['Term'].apply(removeStopWords)
dataDF['Term'] = dataDF['Term'].apply(removeSymbols)dataDF.head()
4.使用手套嵌入单词
在自然语言处理(NLP)领域，单词嵌入是将单词映射到高维向量空间的行为。通过将单词表示为这些数字向量，我们可以量化单词和句子之间的相似程度。因此，一个好的单词嵌入将理想地为单词“狗”和“犬科动物”提供相似的向量，而不是“狗”和“螺丝刀”。
嵌入从每个单词被转换成一个 hot 编码的向量开始，其中每个元素表示存在于词汇表中的所有单词，只有向量中感兴趣的单词被设置为 1。
图片作者。
如果你曾经接触过基本的向量数学(如果你没有，不要担心)，你会遇到计算两个向量之间的角度的概念。两个彼此非常相似的矢量将因此具有非常接近 0°的角度(即指向大致相同的方向)，而两个非常不同的向量将彼此正交。形式上，在 NLP 中，两个向量 A 和 B 之间的相似性是角度的余弦，可以这样计算:
图片来自维基百科
现在，使用一个热编码向量可能会遇到一个问题，除非您比较的两个向量相同(例如“dog”和“dog”)，否则任何其他比较都会产生 0 的点积(A . B ),这不是特别有用。这就是单词嵌入发挥作用的地方。可以通过将独热编码向量乘以嵌入矩阵来计算特定的独热编码字的嵌入。您最终得到的是一个新的向量，与原始词汇大小相比，它具有明显更少的维度(嵌入大小),并且这些新的向量现在将为相似的单词给出接近 1 的相似性得分，否则接近 0。
图片作者。
这种看似‘神奇’的嵌入矩阵从何而来？该矩阵可以通过大型文本语料库通过一些目标函数的优化来构建，并且用于构建这些向量的两种常用技术是 Word2vec 和 GloVe。本文不会深入讨论 Word2vec 和 GloVe 是如何构建这些矩阵的，因为我建议读者参考开发这些算法的原始团队:
https://code.google.com/archive/p/word2vec/
手套:【https://nlp.stanford.edu/projects/glove/】T4
幸运的是，我们可以使用预先训练的模型，而不是学习我们自己的嵌入矩阵。使用 python 中的 gensim 库，我们可以轻松地导入这些模型中的一个，我们将使用“glove-wiki-gigaword-300 ”,这是一个在维基百科和 gigaword 语料库上使用 glove 学习的模型，嵌入大小为 300。
word_vectors = api.load('glove-wiki-gigaword-300')
我们将创建一个新的数据帧 embeddedDF，它将包含与其等价的单词嵌入，而不是原来的单词。
def embedSentence(sentence):
embed = map(embedding, sentence)
return list(embed);def embedding(word):
try:
embed = word_vectors[word]
except Exception:
embed = word_vectors['unk'] #For any unknown words
return embed;embeddedDF = dataDF.copy()embeddedDF['Term'] = embeddedDF['Term'].apply(embedSentence)#removes any rows that became empty after removal of stop words etc.
embeddedDF = embeddedDF[embeddedDF['Term'].astype(str)!='[]']#Will be useful later for combining dataframes
keepIndices = embeddedDF.index
因为我们的目标是可视化整个搜索词，而不是单个单词，所以我们不仅需要嵌入单词，还需要嵌入每行的句子(搜索词)。尽管有许多嵌入句子的方法，我们将通过简单地平均一个搜索词中的单词嵌入来实现最简单的“单词包”方法。
图片作者。
def averageEmbedding(sentence):
average = np.mean(sentence, axis=0)
return average;embeddedDF['Term'] = embeddedDF['Term'].apply(averageEmbedding)#Reinitializing the indices to remove any gaps
embeddedDF.index = list(range(0, len(embeddedDF)))embeddedDF.head()
在生成句子嵌入之后，我们将创建一个新的数据帧，其中 300 维嵌入向量的每个元素都在它自己的列中。
FeatureColumns = []for i in range(0, 300):
FeatureColumns.append('e'+str(i))FeatureDF = pd.DataFrame(columns = FeatureColumns)def featurize(sentence, dataframe):
sentence = pd.Series(sentence, index=FeatureColumns)
dataframe = dataframe.append(sentence, ignore_index=True)
return dataframe;for i in range(0, len(embeddedDF['Term'])):
FeatureDF = featurize(list(embeddedDF['Term'][i]), FeatureDF)
既然我们已经将每个搜索项表示为一个 300 维的嵌入向量，我们就可以将它们可视化了！
5.使用 t-SNE 可视化搜索词
我们休息一下，参加一些脑力体操。
在你的脑海中想象一个正方形。这很简单，让我们添加另一个维度，现在让我们画一个立方体。仍然很简单，当我们尝试增加另一个维度时会发生什么？我们如何想象一个四维物体？当用图形可视化信息时，我们遇到了同样的问题，超过三维，数据开始变得难以可视化和解释，这就是降维发挥作用的地方。
数据科学中降维的目标是将原始特征集投影到一个较低的维度表示中，同时保留尽可能多的有用信息。这样做的标准方法是使用主成分分析(PCA ),从而试图找到一组新的轴(主成分),使数据的方差最大化。
图片修改自维基百科。
以上面的图像为例，如果我们决定仅使用一个维度重新绘制数据点，并使用第一个主成分作为轴，我们仍将保留大部分相关信息，但只需要一个维度。当我们在应用 PCA 后可视化数据时，彼此差异很大的点往往离得很远，而相似的点不一定会聚集在一起。最近出现了一种称为 t-分布式随机邻居嵌入(t-SNE)的技术，它是一种执行维度缩减并同时允许相似数据点聚集在一起的方法。一个的例子使用 MNIST 数据集比较了手写数字(0-9)上的 PCA 和 t-SNE，显示了这些技术之间的行为差异。
我建议对 t-SNE 算法的内部工作原理感兴趣的读者去看看发明者劳伦斯·范·德·马滕的网页:https://lvdmaaten.github.io/tsne/
图片由 BSD 许可下的 scikit-learn 提供。
现在让我们在搜索词中使用 t-SNE！
我们将可视化 2020 年 3 月这一特定月份的搜索词，而不是试图可视化所有约 60，000 个搜索词，但是您可以随意使用自己的数据集。
我决定选择 2020 年 3 月，因为这是一个充满许多全球事件的月份，包括新冠肺炎、股票崩盘和石油价格战。
我们将首先选择 2020 年 3 月，并将其存储为另一个数据框架“currentDF”，然后在应用 scikit-learn 的 t-SNE 之前标准化我们数据框架的每一列。
tempDF = dataDF.loc[keepIndices, :].copy()
tempDF.index = range(0, len(tempDF))#Select the month of March 2020
currentDF = pd.concat([FeatureDF.loc[tempDF[(tempDF['Year']==2020)&(tempDF['Month']==3)].index,:],tempDF[(tempDF['Year']==2020)&(tempDF['Month']==3)]], axis=1)scaler = StandardScaler()
currentScaledDF = scaler.fit_transform(currentDF.loc[:, :'e299'])tsne = TSNE(n_components=2).fit_transform(currentScaledDF)
tsneDF = pd.DataFrame(tsne, columns=['T1', 'T2'])
tsneDF = pd.concat([tsneDF, tempDF], axis=1)tsneDF['Term'] = tsneDF['Term'].apply(TreebankWordDetokenizer().detokenize)tsneDF.head()
让我们画出我们的搜索词，看看它看起来像什么。
def plotWords(dataframe, fileCount=0):
plt.figure(num=None, figsize=(12,8), dpi=300)
ax = plt.subplot(111)
for i in range(dataframe.shape[0]):
plt.text(dataframe.iloc[i,0], dataframe.iloc[i,1], str(dataframe.iloc[i,2]),
color='blue',
fontdict={'weight': 'light', 'size':6})
plt.axis('off')
plt.savefig(fname='plot'+str(fileCount), dpi=300)scaler = MinMaxScaler()
data = scaler.fit_transform(tsneDF.iloc[:, [0,1]])tsneDF.iloc[:, [0,1]] = dataplotWords(tsneDF)
图片作者。
这就是全部了！
试图在单个图表中可视化成千上万个不同的单词可能会非常困难，但即使使用简单的句子嵌入方法，我们也能够使用 t-SNE 将许多相关的术语聚集在一起。虽然在将类似术语分组在一起方面仍有很大的改进空间，但从我 3 月份的谷歌搜索术语中，你可以了解到很多关于我的信息……很明显，我对股市在崩盘期间的表现非常感兴趣，查看了冠状病毒的统计数据，谷歌了各种 python/机器学习术语，查看了狗的图片，并阅读了食物和节食方面的资料(我和妻子正在尝试 keto diet)。深入研究 NLP 的下一步可能是实现更高级的句子嵌入方法，以获得更好的结果。
希望这篇文章足够有趣和简单，并且你能学到一些东西。如果您有任何问题或建议，请随时与我联系。
所有的代码都位于这里:【https://github.com/danielkychen/GoogleSearchWords
谷歌刚刚推出了 TensorFlow 开发者证书考试
对您的 ML 知识的正式认可，特别是使用 TensorFlow 进行 ML 开发。
随着工具和社区贡献者的全面而灵活的生态系统的可用性，TensorFlow (TF)在机器学习(ML)方面获得了极大的欢迎。
许多学生和开发人员一直在急切地学习这个框架，并积极地应用它来解决各种领域中具有挑战性的 ML 问题，如计算机视觉和自然语言处理。当这些 TF 开发人员找工作时，有什么简单的方法来展示他们在 ML 方面的专业知识，尤其是使用 TF 框架解决现实问题的熟练程度？
TensorFlow 开发者证书来救场！
图片来源:TensorFlow.org
3 月 12 日，TF 框架背后的 Google Brain 推出了第一个 TensorFlow 开发者证书计划，该计划允许全球所有 TF 开发者获得对其 ML 技能的正式认可。
证书课程包括由 TF 团队开发的评估考试。这里有几个关于考试和证书的亮点。
- ML 专业知识的必备条件。可以参考考生手册来复习考试标准。TF 团队还推荐 TF 上的课程，让自己更好地准备考试。
- 考试将在 TF 考试插件的帮助下利用 PyCharm IDE 。所以你可能想知道如何舒适地使用 PyCharm。
- 5 小时时限。您可以随时参加考试，但考试开始后，最长允许时间为五个小时。一旦达到限制，插件将自动为你上交考试。
- $100 考试费。好东西很少是免费的。
- 重新获取政策到位。第一次尝试失败后，你必须等 14 天后再尝试第二次。第二次尝试失败后，你必须等待两个月。第三次尝试失败后，必须等待一年才能再次测试。候选人手册上不清楚三次失败后会发生什么。
- 3 年到期。证书有效期 36 个月，可以理解，ML 和 TF 进化这么快。
- 有津贴可用。TF 团队非常体贴，他们为需要帮助的人提供教育津贴，以支付教学材料和测试费用。请注意，可用津贴的数量有限。
上面说的几点，都是集中在你报名考试之前想了解的信息。如果你通过了测试，一些甜蜜的事情就会发生。
- 该证书是一种官方认可，可以进入你的简历和你在各种社交平台上的个人资料，如 GitHub、LinkedIn 和 Twitter。
- 你将成为证书网络的一员，在这里，公司可以寻找像你这样的 ML 人才来解决具有挑战性的 ML 问题。
只是对 TensorFlow 开发者证书计划的一个快速概述。如果你感兴趣，请随意探索。下面是链接，您可以从这里开始准备！
[## 获得 TensorFlow 开发者证书— TensorFlow
通过 TensorFlow 开发者证书脱颖而出展示您使用 TensorFlow 的熟练程度…
www.tensorflow.org](https://www.tensorflow.org/certificate)
谷歌刚刚发布了 2500 万个免费数据集
以下是您需要了解的关于世界上最大的数据仓库的信息
谷歌最近发布了 datasetsearch ，这是一个搜索 2500 万公开可用数据集的免费工具。
搜索工具包括过滤器，根据许可证(免费或付费)、格式(csv、图像等)和更新时间来限制结果。
结果还包括数据集内容的描述以及作者引用。
谷歌的数据集聚合方法不同于其他数据集仓库，如亚马逊的开放数据注册。与其他自己管理和托管数据集的存储库不同，谷歌不管理或直接提供对 2500 万数据集的直接访问。
相反，谷歌依靠数据集发布者使用 schema.org T2 的开放标准来描述他们数据集的元数据。然后，谷歌将这些元数据编入索引，并让所有出版商都能搜索到。
由于出版商仍然需要自己托管数据集，符合 schema.org 标准的营利性出版商也将让谷歌索引他们的数据集。在我的轶事经验中，我发现搜索结果中大约一半的数据集来自营利性的聚合器，当搜索市场相关的数据集时，这个比例甚至更高。
该平台上其他受欢迎的数据集发布者包括政府机构和研究机构。谷歌声称，仅美国政府机构就发布了超过 200 万个数据集。
根据谷歌的说法，大多数数据集都与“地球科学、生物学和农业”有关。
要发布你自己的数据集，你可以简单地使用 schema.org 的开放标准。随着越来越多的出版商遵循该标准，公开可用数据集的数量可能会继续增长。
目前，Google 没有提供搜索或下载免费数据集的 API。
关于这次发布的更多信息可以在谷歌的博客上找到。
感谢阅读！我在 Medium 上写关于数据科学相关主题的文章，所以当我写更多这样的文章时，您可以关注我以获得通知。
谷歌比我先知道我是非二进制的
但不知何故，在我出柜后，它改变了主意
谷歌的颜色并不总是反映多样性。但是它的算法能够看到它。Reza Rostampisheh 在 Unsplash 上拍摄的照片
我的 生活被算法所统治——从我自己构建的算法到决定我接下来要看哪个视频的算法。但是当一个算法比我先知道我是同性恋时，它变得令人毛骨悚然——尽管它被训练成以性别二元的方式看待生活。
这是一个下雨的周日下午，我们坐在客厅里。你抚摸我们的猫 Pukey 时，我在看书。你尊敬我。
我想知道猫会不会像你一样是变性人。
我不知道。动物没有理由不应该是变性人。不幸的是，我们不能问他们。
我觉得呕吐可能是变性的。她表现得像个大男人！
也许你是对的。“但是谁知道呢——从一个人的行为来判断他的性别身份真的很难，”
并非所有的怪异都是肉眼可见的。照片由侯赛因·里瓦迪在 Unsplash 上拍摄
“是啊——大多数人见到你时不会认为你是变性人，”
没错。尽管谷歌比所有人都更早知道我不是二进制的！”
“对不起，什么？”
你没听错。谷歌知道我不是二进制的——我是通过我的广告设置发现的。
我意识到我在 2017 年是非二进制超能力者。我一生都有这种感觉，但我花了很长时间来表达我的感受。那个实现的时刻——对我来说是一个顿悟。
但是两年前还有一个更小的顿悟时刻。在一封电子邮件通知我谷歌广告的存在后，我正在检查我的谷歌广告设置。这些设置包括你的年龄、性别、教育和主要兴趣领域，以便为你量身定制广告。
我从未向他们透露过我的性别，但不知何故，我以为他们会根据我的活动猜测我的性别。
事实并非如此——它没有猜到我的性别！谷歌利用男性和女性的兴趣来个性化我的广告。不用说，我对这个结果很感兴趣。
“但你当时为什么没有意识到自己是变性人？”
谷歌意识到了我的古怪。但是我花了很多年才意识到
我们在说 2017 年，亲爱的。当时，我甚至不知道变性人这个词。见鬼，我几乎不知道同性恋意味着什么！
我一直以为每个人都和我一样感到烦躁和偶尔的兴奋。自从青春期开始，我的感觉变得非常强烈，我认为这种与身体和身份的斗争是每个人成年的决定性因素。
我的结论是，这种挣扎是成人比儿童笑得少的原因。从一个孩子的角度来看，这场斗争让成年人变得如此无趣。这场斗争最终会在人们变老时杀死他们。成年只是在与自己的斗争中慢慢死去。对每个人来说。
多么可悲的世界观啊！
在回顾展上，是的。不幸的是，我当时没有用谷歌搜索我的感觉…
谷歌的广告设置照亮了我悲伤的、跨性别的世界观。克里斯蒂安·斯特克在 Unsplash 上拍摄的照片
你周围的人对这种世界观有什么反应？
我从未告诉他们这件事。但是当然，我意识到许多其他人对自己的身体和性别有了更好的理解。所以我继续认为他们在某种程度上比我更强大，因为他们比我更能处理成年的斗争。这导致了巨大的自我怀疑感，甚至更糟。
“社会已经崩溃了！”
是的，但对我来说，互联网是一个惊人的修复。在那一刻，当我看到我的谷歌广告设置时，我意识到我并不比其他人更弱或更差。
那一刻并不是万能的。在那之后，仍然有很多自我怀疑和困难时期。但随着时间的推移，我的谷歌广告设置成了我脑海中挥之不去的事实。
谷歌一定认为我在恋爱中是一个性别不固定的人
从那以后，你经常检查你的广告设置吗？
有时，是的。观察环境如何随时间变化是很有趣的。有时我对谷歌来说是男性，但大多数时候它认为我是女性。男人和女人的兴趣都存在。而且谷歌一直以为我在谈恋爱，虽然大多数时候我没有。我仍然不明白谷歌为什么会这么想。
哈哈，谷歌认为你在恋爱中是一个性别不固定的人。
不知何故是的。虽然我不是 gender fluid——我的性别一直都是一样的。“它既不是男性也不是女性，”
谷歌的性别二进制算法无法决定我是男是女。Jorge Saavedra 在 Unsplash 上的照片
所以谷歌可能无法确定你的性别，因为你既不属于男性也不属于女性。
可能吧，是的。但是在我正式出柜之后游戏就变了。2018 年我和几个密友出去了。但我是在 2019 年开始向大家出柜的。
从 2019 年的那个点开始，谷歌的广告设置就一直给我贴上女性的标签。具体原因我也不知道。也许在那个时候，它的算法发生了变化，使得性别分配变得不那么灵活。或者也许我的行为在出柜后发生了变化，影响了谷歌对我的看法。我可能永远也不会知道，”
这是一个谜！谷歌仍然会弄错你的性别。
对，同时。有趣的是，固有的性别歧视算法可以揭示像我这样不合群的人的真相。以及这如何能成为我们解脱和自由的源泉。
谷歌和 YouTube 已经明确表明了立场，歧视 LGBT 创造者。令人惊讶的是，它自己的算法揭示了人眼不明显的奇怪之处。
medium.com](https://medium.com/swlh/youtube-lgbt-demonetization-db22f5c978f9)
你有没有考虑过改变你的设置，让谷歌知道你的真实性别？
我最近做了！这样做的坏处是，我再也看不到谷歌对我性别的猜测了。我发现看它是把我看成男性还是女性很有趣。它揭示了很多关于谷歌算法的信息，以及谷歌和我们的社会是如何看待性别二元制的。
“在你公开自己的性别后，有什么变化吗？”
嗯，突然谷歌认为我是单身！同样，健康和美丽的设定也立即消失了。
所以根据今天的技术，性别同性恋者很少谈恋爱，也不太关心健康和美丽。如果你问我，我会说这是胡说八道。
撰写本文时谷歌广告设置的快照。
这听起来确实很奇怪！随着人们变得越来越宽容，观察这种变化将会很有趣。它会向你展示为非二进制人群量身定制的广告吗？
让我们拭目以待！这些广告肯定存在，但我们还得看看谷歌在向我展示这些广告方面做得好不好。
你低头看着呕吐。
很遗憾猫也不会用谷歌。我们可能永远也不会知道 Pukey 是不是变性人。
这的确很有挑战性。但是让我们看看未来会怎样。我希望有一天我们会在性别方面受到更多的教育。那么我们可能不会再把我们的二元刻板印象投射到我们周围的人和动物身上。
基于 Selenium 的谷歌地图特征提取
使用 Python + Pillow + Matplotlib
绿地密度提取(扫描谷歌地图图像)
我计划这是关于提取谷歌地图数据和做一些有趣的路径和基于时间的研究的系列文章的第一部分。一些例子是观察一段时间内的交通流量，并计算给定路线的“美丽分数”。这个旅程的第一步是从 Google Maps 自动加载图像数据，并从这些图像中提取特征。让我们开始吧。
至于我的工具包，我们使用 Python 做任何事情，并利用 Selenium(用于自动化的 web 浏览器模拟器)、Pillow(图像处理库)和 Matplotlib(绘制数据值)的包。
我的工作环境是 Kaggle，这是一个在线数据和笔记本网站，非常有用。首先，我必须安装所需的软件，以允许我们模拟一个浏览器，以便从谷歌地图提取图像数据(除了一些其他数据)。
软件包的安装
第一步是下载并解压 Firefox 发行版，这将是我们的自动化浏览器。这是我用过的一个:
提取后，记下目录的位置。为了保持整洁，我为这个项目创建了一个新的工作目录:
mkdir ~/working/firefox
现在将提取的文件复制到这个新目录中，并设置允许所有人执行的权限。
cp -a firefox-63.0.3.tar.bz2/. ~/working/firefox
chmod -R 777 ~/working/firefox
接下来，我需要安装一个驱动程序来允许 python 和 firefox 之间的通信。与此同时，我还加载了 Selenium 包。
使用画中画:
pip install webdriverdownloader
pip install selenium
最后，我得到了我的 python 代码。在 Kaggle 笔记本中，我运行了以下代码来实际安装驱动程序。
from webdriverdownloader import GeckoDriverDownloader
gdd = GeckoDriverDownloader()
gdd.download_and_install("v0.23.0")
最后但同样重要的是，安装运行代码所需的一些额外的包
apt-get install -y libgtk-3-0 libdbus-glib-1-2 xvfb**# Setting up the virtual display for Firefox**
export DISPLAY=:99
启动浏览器
请记住，我将在后台运行一个 web 浏览器，并使用它来加载 Google Maps 和提取一些数据。要在 Python 中做到这一点，首先从 Selenium 加载包，并实例化一个 Firefox 会话。
**# Import the libraries for selenium**
from selenium import webdriver as selenium_webdriverfrom selenium.webdriver.firefox.options import Options as
selenium_optionsfrom selenium.webdriver.common.desired_capabilities import
DesiredCapabilities as selenium_DesiredCapabilities
接下来，我设置了浏览器选项。我不希望 Firefox 生成一个真正的窗口，所以我用“无头”模式启动它。
browser_options = selenium_options()
browser_options.add_argument("--headless")
最后，我添加了浏览器的功能和实例。
**# Even more setup!**
capabilities_argument = selenium_DesiredCapabilities().FIREFOX
capabilities_argument["marionette"] = True**# This is the money. We now have the browser object ready**
browser = selenium_webdriver.Firefox(
options=browser_options,
firefox_binary="~/working/firefox/firefox",
capabilities=capabilities_argument
)
最后，我可以开始抓取一些谷歌地图数据。
提取谷歌地图图像
下一步是找出我需要使用的 Google Maps URL，这样我就可以在 Selenium 中导航到它。格式如下:
【https://www.google.com/maps/@】T2{ LAT }，{LNG}，{Z}z
其中:
- LAT:我们希望看到的位置的纬度
- LNG:位置的经度
- z:地图上的缩放级别(越大意味着越近)
现在我决定选择多伦多滨水区附近的某个地方，这样我就可以获得该地区的一些公园数据。
**# Toronto Waterfront Coordinates**
lat = 43.640722
lng = -79.3811892
z = 17
我用它来生成一个 URL 并用我的浏览器导航:
**# Build the URL**
url = '[https://www.google.com/maps/@'](https://www.google.com/maps/@') + str(lat) + ',' + str(lng) +
',' + str(z) + 'z'**# Setting up the browser window size**
browser.set_window_size(1024,512)
browser.get(url)
此时，浏览器保存了网站的所有信息，就像我手动完成的一样(在浏览器中检查)。我想看看这个网站，所以我在 Selenium 中使用了 save_screenshot 方法。
browser.save_screenshot("before.png")
这是它看到的。
谷歌地图的原始图像捕捉(多伦多滨水区)
关于硒的一个很酷的事情是你可以:
a)解析 HTML 以提取任何页面数据
b)在页面上执行 javascript
我想做的一件额外的事情是得到图像的适当缩放。例如，我想知道给定地图中公园的实际面积。不错的是，谷歌地图在其渲染中包括了一个比例尺。这意味着我可以选择这些元素来获得英尺数(实际页面上显示的内容)以及比例尺的宽度(以像素为单位)。因此，我有图像中每个像素的英尺数！
因为我是加拿大人，所以我把它转换成米:
**# Conversion factor from foot to meter**
foot2meter = 0.3048**# Doing some light cleanup of the string and converting to float**
scale_in_feet = float(browser.find_element_by_id('widget-scale
label').text.replace(' ft',''))**# Now we have the scale in meters**
scale_in_meters = scale_in_feet*foot2meter**# Get the number of pixels the scale is drawn on, again cleaning**
pixel_length = float(browser.find_element_by_class_name('widget
scale-ruler').value_of_css_property("width").replace('px',''))**# Taadaa we have the final scaling**
MetersPerPixel = scale_in_meters/pixel_length
接下来，我必须清理图像。正如你所看到的，图像上有一些重叠的元素(搜索栏等)。如果我想从原始地图中提取特征，那么我必须去掉它们。
**# Remove omnibox**
js_string = "var element = document.getElementById(\"omnibox
container\");
element.remove();"
browser.execute_script(js_string)**# Remove username and icons**
js_string = "var element =
document.getElementById(\"vasquette\");
element.remove();"
browser.execute_script(js_string)**# Remove bottom scaling bar**
js_string = "var element = document.getElementsByClassName(\"app
viewcard-strip\");
element[0].remove();"
browser.execute_script(js_string)**# Remove attributions at the bottom**
js_string = "var element = document.getElementsByClassName(\"scene
footer-container\");
element[0].remove();"
browser.execute_script(js_string)ow I take another screenshotbrowser.save_screenshot("waterfront.png")
我有一个干净的形象
一个很好的干净的图像准备进行特征提取
地图特征提取+动画
现在我有了我的图像，我想从中提取一些信息。对于这个具体的例子，我想知道绿色公园的面积的百分比和绝对值(这就是为什么我需要上面的缩放)。除此之外，我想制作一个漂亮的动画，展示图像是如何被扫描并提取绿色的。
因为我在制作动画，所以我想把图片保存在单独的文件夹里，以保持整洁。我这样做是为了扫描和绘制线图:
mkdir ~/working/frames
mkdir ~/working/matplotlib
现在我做编码的主要工作。我定义了一个函数，它能够扫描图像的像素，并确定它们是否在某个 RGB 范围内(有一些松弛)。我还传入了一个 image 对象，以允许在提取过程中拍摄快照。我基本上将所有像素覆盖为白色，只有当像素落在范围内时，我才保留原来的颜色:
**# The most important part!**
def find_pixels(img,pixels,colour_set,slack, size):
num_px = [] **# List to hold the amount of pixels that match** **# Set the value you want for these variables**
r_min = colour_set[0]-slack
r_max = colour_set[0]+slack
g_min = colour_set[1]-slack
g_max = colour_set[1]+slack
b_min = colour_set[2]-slack
b_max = colour_set[2]+slack **# Loop over the pixel array**
for x in range(size[0][0]):
num_px_col_count = 0
for y in range(size[0][1]): **# Extract the pixel colour data**
r, g, b,a = pixels[x,y] **# Set the pixel to be white by default**
pixels[x,y]=(int(255), int(255), int(255),int(0)) **# Check the see if there is a match!**
if r >= r_min and r <= r_max and b >= b_min and
b <= b_max and g >= g_min and g <= g_max: **# If there is a match add one to count** num_px_col_count = num_px_col_count + 1; **# Colour the pixel back to the original**
pixels[x,y]=(colour_set[0], colour_set[1],
colour_set[2],int(255)) **# Append the count to the list**
num_px.append(num_px_col_count) **# Save the image every 10 frames for animation**
if x % 10 == 0:
img.save('~/working/frames/' + str(x)+ '.png')return num_px
既然函数已经定义好了，我就可以实际使用它了。从导入我们的图像和动画库开始
from PIL import Image,ImageDraw,ImageFont
import matplotlib.pyplot as plt
打开图像，转换为 RGBA，并将像素载入数组
img = Image.open('~/working/waterfront.png')
img = img.convert('RGBA')
pixels = img.load()
我必须手动做的一件事是确定谷歌地图中给出的公园的颜色。我只是用一个工具选择屏幕上的像素来提取这个。现在我把它立起来，放松一下。在一些像素具有小的颜色可变性的情况下，松弛被用作缓冲器。我把它传递给我们上面定义的函数
park_colour = [197,232,197];park_slack = 2;
num_park = find_pixels(img,pixels,park_colour,park_slack,[img.size])
此时，我实际上已经拥有了我需要的一切！干得好！该看动画了。还记得 num_park 是如何包含每列匹配的像素数的吗？这意味着我可以绘制这个并创建另一个动画。使用图像大小，我创建了一个 matplotlib 图形，并将所有背景、轴和元素设置为白色，以获得一个空白的石板。
**# All this is to make a totally blank matplotlib image**
fig=plt.figure(figsize=(1024/100,438/100))
ax = fig.add_subplot(111)
ax.set_facecolor("white")
fig.patch.set_facecolor("white")
fig.patch.set_alpha(0.0)
for spine in ax.spines.values():
spine.set_edgecolor('white')
plt.grid(False)
plt.axis('off')
对于图像处理，我希望图像的比例相同，所以我继续在图中设置缩放比例
ax.set_xlim([-10,1024])
ax.set_ylim([-10,438])
最后，每隔 10 个元素循环一次，创建一个线图。一旦创建，只需保存它！
for i in range(0,1024,10):
ax.plot(num_park[:i],color='#377e4d',linewidth=3,
antialiased=True)
plt.savefig('~/working/matplot/'+str(i)+'.png',
transparent=True,dpi=130)
我有做出最终结果所需的所有图像和数据。
首先，我从提取中得到总面积。使用米像素和图像大小，我可以得到以千米为单位的总面积
total_area = img.size[0]*img.size[1]*MetersPerPixel/(1000*1000)
0.432 公里~图像的 20%
接下来，使用 PIL 创建一个动画 GIF。在下面的例子中，我每隔 10 帧循环一次，从上面捕捉加载预先生成的图像，并将它们添加到一个帧列表中。这个帧列表将被传递给动画函数来生成最终的文件。
**# Loop over every 10 frames**
frames = []
for i in range(0,1024,10): **# Load the other images we will overlay**
googlemap = Image.open('/kaggle/working/frames/'+ str(i)+".png") **# Do resampling to get the smoothing effect**
googlemap = googlemap.resize(googlemap.size,
resample=Image.ANTIALIAS)**# Append the frames**
frames.append(googlemap)**# Save the final .gif** frames[0].save('googlemap.gif', format='GIF',
append_images=frames[1::], save_all=True, duration=1, loop=0)
扫描公园的动画
作为最后的措施，我还覆盖了动画 matplotlib 图。唯一的区别是我们将使用。粘贴PIL 的方法来叠加图像。
**# Loop over every 10 frames**
frames = []
for i in range(0,1024,10): **# Load the other images we will overlay**
googlemap = Image.open('/kaggle/working/frames/'+ str(i)+".png")
matplot = Image.open('/kaggle/working/matplot/'+str(i)+'.png') **# Overlay the matplotlib plot animation frames (NB we include
offsets for the image here has well (-175,-52) for alignment** googlemap.paste(matplot, (-175, -52),matplot) **# Do resampling to get the smoothing effect**
googlemap = googlemap.resize(googlemap.size,
resample=Image.ANTIALIAS)**# Append the frames**
frames.append(googlemap)**# Save the final .gif** frames[0].save('FINAL.gif', format='GIF',
append_images=frames[1::], save_all=True, duration=1, loop=0)
绿地密度提取(扫描谷歌地图图像)
现在你知道了！现在，我们可以做一些真正有趣的事情，如纵向交通扫描，甚至查看跑步路线，看看周围地区有多酷！
参考
使用 Kaggle 笔记本探索和运行机器学习代码|使用来自多个数据源的数据
www.kaggle.com](https://www.kaggle.com/kapastor/google-maps-feature-extraction-selenium-pil)
谷歌研究人员表示，不规范正在破坏你的模型性能。这里有五种方法可以解决这个问题。
我们看了 60 页的Google under specification paper(所以不用)。想直接跳到提示吗？ 点击这里。
解决机器学习中指定不足的五种策略。作者在 Roboflow 拍摄的图片。
这里有一个你可能遇到过的问题:你建立了一个模型，它有很高的精度分数或者很高的 mAP(平均精度)。
然后，您部署您的模型…您的模型比预期的更差。
你采取了正确的步骤！您将数据分成训练、验证和测试集。您检查以确保导入数据时没有错误，并彻底清理了数据。您的特征工程步骤植根于主题专业知识。
发生什么事了？
您的模型在构建时表现良好，但在部署后表现更差。这种现象的一个主要原因被称为规格不足。一组(主要是谷歌)研究人员在本周早些时候发表了一篇关于机器学习模型在“部署在现实世界领域”时表现不佳以及不规范如何导致这种情况的论文。
什么是欠规范？
很有可能，当您构建模型时，有许多模型对您的数据表现良好。这是欠规范。
让我们从一个简单的例子开始，然后深入到一个更真实的世界:以这个散点图数据为例。您希望生成一条最适合该数据的线。
二维网格上手绘的蓝点散点图。图片由作者在 Roboflow 拍摄。
有很多行可以在这个数据上做得很好。让我们看两个示例行:
二维网格上手绘的蓝点散点图，带有几乎最佳拟合的两条线(一条橙色和一条灰色)。图片由作者在 Roboflow 拍摄。
这张图片中的橙色和银色线条非常相似。当我们量化模型性能时，两者都可能做得相当好。计算机会很容易地挑选出“最好”的一个——但是被计算机称为“最好”的那个并不能保证是“现实世界中最好的”
这是欠规范。如果有许多不同的方法可以让您的模型在保留的测试集上实现相同的性能，即使您有相同的训练数据和相同的模型结构，那么机器学习管道就是未指定的。在上面的示例中，训练数据(点)和模型结构(最佳拟合模型的简单直线)是相同的，但是直线的斜率和 y 截距略有不同。尽管这是两条不同的线，但如果它们在我们的测试数据中获得了相同的性能水平，我们会将其描述为未指定。
最佳拟合线是一个直观的例子(不同的斜率，但相似的性能)——但这是各种机器学习模型的问题，包括在计算机视觉，自然语言处理等等。只是有时在这些模型中很难发现。
有什么大不了的？为什么指定不足是一个问题？
我们之前看到的那两条线？我们的计算机根据模型性能的一些衡量标准选择了“最佳”的一个。但是计算机不知道哪个模型更好地反映了现实——只是哪个模型碰巧在这组特定的数据上更好。
比方说，不是拟合一条最佳拟合模型线，而是用 YOLOv4 处理一个对象检测问题。(旁白:在这里学习 如何拟合 YOLOv4 模型 或 拟合更好的 YOLOv4 模型的窍门 。)
有许多有意和无意的选择来拟合对象检测模型。
- 有意的选择可能包括你做的图像预处理的类型或者你收集的数据量。
- 无意的选择可能包括在拟合您的模型时选择的随机种子或使您的模型与数据相匹配的算法。
如果我们试着试穿 20 个不同的模型，也许其中 5 个表现相当好。在这 5 个好模型中，我们的计算机在选择“最佳”模型时没有考虑任何现实世界的意义。
归根结底，模型是对现实的简化。模型通常被认为是反映或模仿现实世界。但是模型拟合的方式，不能保证你的计算机选择的模型反映了你的特定应用的逻辑或科学。
令人惊讶的是，像你的随机种子这样看似不相关的决定可能会对你的模型性能产生非常大的影响！
你可能认为这种情况不常发生。谷歌研究称并非如此。你的电脑可能会选择“最好”的型号，但事实证明，哪个型号是“最好的”惊人地依赖于看似随意的小选择。
这意味着:当你部署你的非常精确的、高性能的测试集模型时，很有可能你的模型在现实世界中立即开始表现不佳，耗费你的时间、金钱和挫败感。
我们可以做哪 5 件事来避免这些负面后果？
- 从培训发行版之外的地方提取测试数据——理想地反映您的部署环境。当你收集数据并将其随机分成训练集、验证集和测试集时，你可能会失败。尽管没有模型泄漏，但是用于评估模型的测试数据与训练/验证数据来自同一个地方。如果您可以收集两组独立的数据(一组用于训练/验证，另一组用于测试)，您可能能够更好地模拟您的模型在现实世界中的表现。在时间序列环境中，这就像使用最新的数据作为测试数据。在计算机视觉的背景下，如果你正在通过计算鱼的数量来评估环境健康，你可能会根据一条河流的数据来训练你的目标检测模型，并根据另一条河流的数据来测试你的模型。
- 尽量缩小您的训练数据分布与“真实世界”分布之间的差距。如果您必须从训练分布中提取您的测试数据(例如，将您的数据随机分成训练/验证/测试集)，请考虑扰动您的数据，以便您的测试集中的信息更好地反映真实世界。在计算机视觉中，这通常包括图像增强技术。
- 通过运行压力测试来检测不符合规格的情况。压力测试很常见——例如，银行不得不进行压力测试以确保它们能够经受住令人惊讶的经济事件。来自谷歌的研究人员通过在各种随机种子值下运行模型来进行压力测试，然后检查压力测试如何变化。理想情况下，基于随机种子观察到的可变性很少或没有；研究表明，随机种子确实会显著影响压力测试的表现。研究人员分享了他们使用的三种类型的压力测试:A)分层表现评估，其中对观察的子组进行评估以识别不公平。例如，分别计算每个类别的平均精度。b)移位性能评估，它通过有意干扰现有数据来检查模型的特定属性，从而生成虚构的测试分布。c)对比评估，与敏感性分析相似，即操纵一个输入观察值来测量输出受影响的显著程度。
- 确定你正在做出的有意和无意的建模选择。如果您发现或有理由怀疑您的模型正在遭受不确定性，那么就开始尝试通过列出您所有的建模选择来解决它。有些是有意的，比如模型的输入和您选择的模型类型。有些是无意的或隐含的，如随机种子或神经网络中的步长。如果你的模型正遭受欠规范，看看是否调整这些可以提高你的模型的真实世界的表现！
- 确保你的机器学习管道是可复制的。在训练/验证/测试集和现实世界中评估您的模型时，跟踪您的模型何时表现良好，何时表现不佳至关重要。识别模式转换何时开始发生或什么参数设置(你希望在上面的步骤 4 中列出的那些！)生成在现实世界中表现特别好的模型是确保您的模型开发专注于实现强大的现实世界性能的关键。
规格不足 是部署你的型号时的一个大问题。您的模型可能在保留的测试集上表现得更好——但是一旦您部署了您的模型，您的性能通常会变得更差。希望上面的五个技巧可以帮助您在部署模型时避免性能下降。
有其他提示或建议吗？我们很乐意在评论中听到他们，并把他们添加到我们的博客中！
原载于 2020 年 11 月 16 日 https://blog.roboflow.com。
使用 Python 的 Google Sheets API——Python 编程
在这篇文章中，我们将讨论如何使用 Python 访问和编辑 Google Sheets
作者图片
目录
- 介绍
- 创建一个示例 Google Sheets 文档
- 创建 Google API 凭据
- 使用 Python 打开 Google 工作表
- 使用 Python 选择/创建/删除工作表
- 使用 Python 编辑 Google 工作表中的数据
- 结论
介绍
使用 Python 从多个来源访问数据成为数据科学和分析领域几乎所有职位的标准要求。使用 Excel 电子表格和内部 CSV 文件随处可见。
但是如果你的数据现在以 Google Sheet 的形式存储在 Google Drive 上呢？当然你可以下载你选择的任何格式。然而，它不是一个可扩展的解决方案，因为它需要不断的人工输入。
让我们看看如何以编程的方式解决这个问题，甚至在使用 Python 处理 Google Sheets 时自动完成一些任务。
为了继续学习本教程，我们需要两个 Python 库:gspread 和 oauth2client。
如果您没有安装它们，请打开“命令提示符”(在 Windows 上)并使用以下代码安装它们:
pip install gspread
pip install oauth2client
创建一个示例 Google Sheets 文档
如果你正在阅读这篇文章，你可能已经有一个 Google Sheets 文档了。你想处理你的文件。出于本教程的目的，我将创建一个简单的 Google Sheets 文件，在其中复制学生的成绩数据集。本质上，我们将有三列:名、姓和年级。
要创建您的第一个 Google Sheets 文件，请访问 Google Drive 页面，使用您的 Google 帐户登录。一旦你进入，在左上角，点击新建，然后谷歌工作表。这将创建一个如下所示的空白文档:
作者图片
这个新文档是空的，没有任何数据或自己的文件名。
在左上角，你会看到“无标题电子表格”，为了方便起见，让我们将其重命名为“我的谷歌表”。
让我们添加一些示例数据。我添加了一些简单的字段:
作者图片
太好了。现在我们有一个文件，我们将继续工作。
创建 Google API 凭据
使用 Python 开始使用 Google Sheets 的第一步是为 Google Drive 和 Google Sheets 创建 API 凭证，这将允许我们连接到我们的文件。
首先，我们将前往面向开发者的谷歌云控制台，不用谷歌账户登录。
一旦我们进入，在最顶端，您将看到以下按钮来创建一个项目:
作者图片
点击它，它会带你到一个新的页面，在那里它会要求你为你的项目创建一个名称。我把我的命名为“gsheets-pyshark ”,然后点击“创建”。
现在，在右上角，单击“bell”图标，您将看到一个通知，表明项目已经创建。在通知列表中，单击查看进入项目页面。
这将把您带到项目的 API 仪表板。它应该是这样的:
作者图片
完美。到目前为止，我们使用 Python 创建了自己独特的项目来处理 Google Sheets。下一步是设置 API。
转到导航菜单(单击右上角的三条水平线)，选择 APIs & Services，然后选择 Dashboard。您应该会看到以下页面:
作者图片
如你所见，我们还没有任何可用的 API。我们需要添加它们。跟随屏幕中间的蓝色链接 API library 进入所有可用的 Google APIs 列表:
作者图片
这里我们需要添加“Google Drive”API。通过在搜索框中键入名称找到它，单击它，然后单击启用。加载可能需要几秒钟。一旦启用，我们就会到达这里:
作者图片
太棒了。Google Drive API 现已启用。要使用它，我们需要为它生成凭证。单击右上角的“创建凭据”,并像这样填写表单:
作者图片
填写完上面的表格后，继续点击蓝色按钮。我需要什么凭证？
在下一个表单中，您应该选择您的帐户名称(我将其设置为 misha-pyshark)和帐户在项目中的角色(我选择了 Owner)。“密钥类型”应该设置为 json，因为我们希望将凭证下载为. JSON 文件:
作者图片
然后，单击 Continue，您的凭证将自动下载，您将看到一个弹出窗口，提示您的 API 凭证已创建。
重要提示:请将下载的 JSON 文件重命名为“mycredentials ”,这样在后面的代码中引用它会容易得多。此外，您应该将它放在 Python 代码所在的目录/文件夹中(这样我们可以节省指定文件位置的时间)。
到目前为止，我们已经启用了 Google Drive API，并为其下载了凭证。最后一步是启用 Google Sheets API。让我们回到谷歌 API 库，找到“谷歌工作表 API”。点击进入它，然后点击启用让它运行。
现在我们已经准备好使用 Python 访问 Google Sheets 了。
使用 Python 打开 Google 工作表
在 Python 中有多种方法来执行授权步骤。我在本教程中使用的方法在大多数关于这个主题的文章中被广泛使用，所以我决定用同样的方法。
作为第一步，我们需要导入所需的库:
现在是时候用我们的凭证配置客户机了。这将创建 gspread 客户端:
一切都是为了检索我们之前创建的 Google Sheet 并从中获取所有记录。
使用 Python 有 3 种方法打开 Google 工作表:
1.按名称打开谷歌工作表
这里，我们只需要输入我们创建的 Google 工作表的实际名称:
2.通过 URL 打开 Google 工作表
要使用 URL 打开 Google 表单，您需要在浏览器中打开您的 Google 表单并复制它的地址。我的文件是:https://docs . Google . com/spreadsheets/d/1 l7 cyfmvpiiypktye 1 bdwkpgfhajxp 8 hceg 34 BH 7 vyl 0/
现在，我们用。open_by_url() 方法，并将我们的 url 作为参数传递:
3.按键打开谷歌工作表
按键打开 Google Sheet 与前面的选项非常相似。我们文件的关键是什么？很容易找到。密钥是 URL 的最后一个组成部分，位于最后两个斜杠(“/”)之间。在我的例子中是:1l 7 cyfmvpiiypktye 1 bdwkpgfhajxp8 hceg 34 BH 7 vyl 0
现在，我们用。open_by_key() 方法，并将我们的 URL 作为参数传递:
无论您决定继续哪种方式，它都会在我们的内存中创建一个对象，并将其存储为 gsheet 。它到底包含了什么？简单地说，它的内容正是我们在创建这个 Google 表单时输入的内容。现在让我们从其中检索信息:
在上面的代码块中，我们打开并检索了“Sheet 1”中的所有数据，然后打印出来。它应该是这样的:
[{'first name': 'James', 'grade': 77, 'last name': 'Smith'},
{'first name': 'Maria', 'grade': 68, 'last name': 'Johnson'},
{'first name': 'Sam', 'grade': 59, 'last name': 'Erickson'},
{'first name': 'David', 'grade': 89, 'last name': 'Williams'}]
我们最终得到了一个每行都有值的列表。还要注意 Google Sheets 默认情况下是如何将第一行设置为列名的。
奖励:使用下面的代码，Google Sheet 可以很容易地转换成 Pandas dataframe:
我们得到了一个更熟悉的输出:
first name last name grade
0 James Smith 77
1 Maria Johnson 68
2 Sam Erickson 59
3 David Williams 89
使用 Python 选择/创建/删除工作表
在我们能够访问 Google 表单之后，让我们看看我们可以从什么开始。第一个检查点是我们在使用 Google Sheet 的不同工作表时的灵活性。
我的示例 Google Sheet 只包含一个名为“Sheet 1”的工作表。然而，拥有一个多工作表文件是很常见的。当然，当我们检索数据时，我们需要指定数据应该来自哪个工作表。这就把我们带到了第一个交互选项。
使用 Python 选择工作表
回想一下，我们的 Google Sheet 在本地内存中保存为 gsheet 。现在我们想从文件中按名称访问特定的工作表。我们要做的是创建一个只包含“Sheet1”数据的 Google 主工作表的子集，并打印其内容:
结果应该与上一节相同，因为我们的文件中只有一个工作表:
first name last name grade
0 James Smith 77
1 Maria Johnson 68
2 Sam Erickson 59
3 David Williams 89
使用 Python 创建工作表
现在，如果您想要另一个空工作表呢？当然，你可以通过浏览器登录你的 Google Drive 并手动创建。但是如果您的脚本作为自动化过程的一部分运行(这就是您可能正在阅读本文的原因)，我们希望从我们的 Python 代码中让一切工作起来。
gspread 库的功能也允许我们创建新的工作表:
上面的代码将使用给定的参数在我们的 Google Sheet 中创建新的工作表。请记住，您必须为要添加的工作表指定一个新名称以及行数和列数。
要检查它是否工作，请登录到您的 Google Drive 并查看 Google Sheet 文件，您将看到第二个工作表“新工作表”已添加到您的文件中。
使用 Python 删除工作表
或者，您可能希望删除刚刚创建的工作表。现在，这里有一个小问题:您只能删除使用 Python 创建的工作表。在我的示例中，它是 newsheet ，原因是存储在本地内存中的用于访问该特定工作表的格式:
如果你再次检查你的谷歌工作表，你会看到“新工作表”已经被删除。
使用 Python 编辑 Google 工作表中的数据
本节将讨论大多数最有用的功能。这就是我们使用 Python 编辑主文件中数据的地方。首先，我们需要定义将要使用的工作表:
回想一下，我们正在处理的数据如下所示:
作者图片
获取单元格值
假设我们想要从工作表的特定单元格中检索数据，并让该单元格为“A2”(我们要获取的数据是“James”)。我们将使用以下代码来实现:
我们得到了我们所期望的:
James
更新单元格值
还有一种情况是，您希望更新单元格中的值。假设我们输入错误，需要将 A2 单元格中的名称从“James”改为“John”。可以使用以下代码简单地更改它:
并重用前一部分的小代码块来获得更新后的值:
我们得到:
John
从一行中获取所有值
或者，您可能对检索整行数据(而不是单个单元格)感兴趣。在我们的例子中，假设我们有兴趣获取工作表中第一个学生的数据。
唯一需要注意的是，我们需要知道要从中检索数据的行的索引。假设第一行是列标题，感兴趣的行的索引为 2。现在我们可以得到它的值:
我们得到一列值:
['John', 'Smith', '77']
从列中获取所有值
在另一种情况下，您可能希望从列(而不是行)中获取数据。假设在我们的场景中，我们希望从“grade”列中获取所有数据。
我们将再次需要找到它的索引(index = 3)并运行类似于上一节的代码:
我们在列中得到一个值列表:
['grade', '77', '68', '59', '89']
插入新行
我们通常用电子表格做的最受欢迎的任务之一可能是添加新数据。
在我们的例子中，假设有一个新生刚刚写了他/她的试卷，并得到了一个分数。我们想用 Python 更新我们的谷歌表，增加一个新条目。
为此，我们需要两条信息:学生数据(名、姓和年级)和我们要插入的行的索引:
新索引是 6 的原因是因为我们知道已经有 5 行数据，并希望添加到列表的末尾。请记住，您可以选择任何索引值，它只是将剩余的行向下推。
现在，让我们将这一行添加到我们的 Google 工作表中，并检查它是否已被添加:
我们在刚刚添加的行中得到一个值列表:
['Emily', 'Watson', '89']
注意:整个软件包的功能非常广泛，而且很多功能都是针对具体情况的。关于 gspread 软件包的完整方法示例，请点击这里。
结论
在本文中，我们讨论了如何使用 Python 访问/编辑 Google Sheets，并介绍了 gspread 库的特性。
如果你有任何问题或对编辑有任何建议，请随时在下面留下评论，并查看我的更多 Python 编程文章。
原载于 2020 年 8 月 15 日 https://pyshark.com**。
谷歌床单，遇见熊猫数据框
🐍跳电子表格之舞:简单的方法。
可能是因为在键盘后面呆的时间太长了。但是有时候我在网上的阅读和观看让我觉得我是一个濒临灭绝的开发者。在电子表格中工作的人。每一天。
你能相信吗？开发人员，像不存在的电子表格一样过他们的生活。如果你是这些人中的一员，我想见见你。要知道你的存在，这并不全是我耳畔的狂言。
对于我们其余的人来说，电子表格是非常重要的东西。爱他们或者恨他们，那些二进制的行和列是没有用的。简而言之，哲学课就是电子表格就是。每个非开发人员的员工都在电子表格中拯救了清洁工的生命。
“电子表格是。”把这个存在主义的重磅炸弹交给一所大学；哲学荣誉博士学位肯定会随之而来。
Excel 和 Google Sheets，它们毫无用处；除非我们把自动化和知识工作者传递电子表格的仪式分开，否则我们的生产力也不会提高。
我的三段两分钱
就个人而言，我喜欢好的电子表格。对于管理数据，快速和肮脏的计算，可视化一维时间序列…5 次中有 4 次我会打开 Excel 或 Google 工作表，而不是启动 Jupyter 服务器。
除此之外，业务中的 spreadsheetitis 是不知道如何移动数据的一种症状。我亲眼见过“人肉路由器”问题严重到 20 多个(20 个！)人们在最终——幸运的是——将一个版本的电子表格放入“数据库”(另一个电子表格)之前接触过它。
还有电子表格。当有一个大写的“S”的电子表格时，你就知道这个行业是数据地狱。经理们认为就是业务。
自动化你的理智之路
我们将讨论几个用于 Python 中 Google Sheets I/O 的库。无论是哪种方法，你都必须在谷歌云平台(谷歌版的 AWS 和 Azure)的迷宫般的控制台内启用 Google Sheets API。幸运的是，Google——go figure——在控制台中有一个很棒的搜索功能，我们将使用它来帮助您进行设置。
疯狂第一——从谷歌云平台获取一个credentials.json文件
前往console.cloud.google.com/，使用谷歌账户登录，访问您想要自动化的电子表格。该 API 可用于 GSuite 和免费的 Google 账户。如果这是一个工作拥有的电子表格，与 GCP 访问的管理员将不得不按照这些步骤，给你的凭证文件。
选择顶部导航栏中的项目。每个资源都保存在项目中，就像 Azure 中的资源组一样。如果您还没有，请选择项目下拉列表和“新建项目”。然后搜索“Google Sheets API”，如果你是个虐待狂，想用鼠标探索仪表盘，就在“APIs & Services”下面。
“启用”API。
现在你需要为 Google Drive API 做同样的事情。
接下来，您需要创建一个服务帐户，然后您将为其创建凭据。
步骤:
- 你在谷歌云平台>谷歌工作表 API 在console.cloud.google.com/apis/api/sheets.googleapis.com
- 前往侧边栏上的凭证
🗝 Credentials。 - 选择
+ CREATE CREDENTIALS>服务账号。OAuth 是一个不同的故事。本文涵盖了服务器端的内部使用。创建服务帐户。 - 下一个视图是为服务帐户选择 IAM 角色。这是可选的，跳过它。
- 接下来是“授予用户对此服务帐户的访问权限(可选)”。也跳过。
现在，您将回到“项目[项目名称]的服务帐户”屏幕。点击超链接Email字段或汉堡菜单(三点)> Create key，选择表格中的服务账户。
无论哪种方式，ADD KEY或Create key，选择 JSON 键类型和CREATE。这会将一个 JSON 文件下载到您的计算机上。
最后一件事:电子表格。这里我为这个例子创建了一个。请注意 Omnibar 中 URL 的突出显示部分。这是文档的 ID。大多数库都给出了引用整个 URL 或者只引用这个 ID 的选择。
您可以从这里查看并下载电子表格。
为服务帐户打开从 GCP 下载的credentials.json文件。复制client_email属性中的电子邮件值。用这封邮件分享谷歌表单。这使服务帐户可以访问在另一个帐户(不是服务帐户)上创建的电子表格。
唷。这是所有谷歌基础设施的东西。我保证。
现在我们可以开始写 Python 代码了。
尝试开源库
谷歌有一个用于工作表的 API，就像它用于所有谷歌驱动产品一样。有了它的 Python 库，没有什么是你做不到的。
尽管如此，你还是会疯狂地使用它。
我对电子表格的强硬态度是，它们是向商业用户传递数据的一种可移植的、可视化的方式。数据矩形，左上角的单元格 A1。不是玩鲍勃·罗斯🎨具有条件格式的🖌，在同一工作表中形成群岛的数据岛，或创建类似 Tableau 的图表仪表板。
并不是说所有这些事情都不好。我已经用电子表格自动化掉进那些兔子洞很多次了。只是，当你深入研究 Google Sheets 这些年来内置的所有功能时，编码的回报时间比下降得很快。
这篇文章是关于数据输入和数据输出的。最快解决问题的时间胜出。
在 Python 数据方面，这意味着使用 pandas 数据帧。在 Google Sheets 连接器方面，它更悬而未决。是时候去 GitHub 购物了。
为此，这里有三个我最喜欢的包装 Google Sheets API 的第三方 Python 库:
EZSheets
阿尔·斯威加特不会做错事。他的书用 Python 自动化枯燥的东西一手教会了我如何为金钱编码。我还是一个月参考几次。
斯威加特是一个巨大的大脑，他有能力把复杂的东西分解成我能消化的婴儿食品。EZSheets (GitHub)是他的创造，还有 Gmail、日历和 Drive 的兄弟界面。
EZSheets 以其一次更新一组数据的清晰方法而大放异彩。也用于选择列和行。我还没有找到另一个库能像这个库一样捕捉到遍历单元格的复杂性。其他库并不比 Sheets API 更好，其中用于处理数据的嵌套的for循环让我眩晕。
gspread
gspread (GitHub)是另一个大脑 Anton Burnashev 设计的库。gspread 非常受欢迎，已经成为希望使用 Google Sheets 的 Python 开发人员的事实上的库。
有充分的理由。文档很棒，源代码清晰，布局合理，文档字符串也不错。另外，gspread 的界面包装了一些 Google Sheets 格式功能。它也有处理熊猫和 NumPy 数组的方法。
gspread-dataframe(获胜者)
一个由罗宾·托马斯构建的 gspread 库的包装器，gspread-data frame(GitHub)是我用 DataFrames 读写 Google Sheets 的首选包。
文档很好，但是有点多余。源代码很简短，有两个函数，get_as_dataframe和set_with_dataframe。
gspread-dataframe 是我们将在本教程中使用的。
密码
场景:我们有一个正在进行的电影之夜的数据表。同事需要每天手动向列中添加值。当我们安排新的电影之夜时，我们需要收集输入到表单中的手写数据，并在顶部添加新的电影。
这个例子是虚构的，但是我有多个中型科技公司的客户要求这个功能。你可以想象有一个数据库，里面有像movies和movienights这样的表，有一个视图功能将这些表连接到这个表中，电影之夜的协调员帮助填写这个表。
除了成熟的 web 应用程序或表单软件，使用电子表格作为表示层和数据输入层实际上非常方便。
奖励:有了 pandas 1.1.0，我们可以从 DataFrame 上的一个方法生成一个没有索引的减价表！
*df . head①。to _ markdown(index = False)
' | IMDB URL | IMDB Score | Length | Attendees | Mood | Staff Notes | \ n |:——————————————————————————————————————————————————————————————————————————————————————————————————————————————————————Length | enders | Mood |😓|克星开飞机✈ |'*
我们的数据:
写入 Google 工作表
先安装gspread_dataframe。因为它是gspread的包装器，我们将需要那个库和它的oauth2client依赖。
pip install gspread_dataframe gspread oauth2client
检查您是否可以连接到工作表:
$ ipython
Python 3.8.1 (tags/v3.8.1:1b293b6, Dec 18 2019, 23:11:46) [MSC v.1916 64 bit (AMD64)]
Type 'copyright', 'credits' or 'license' for more information
IPython 7.12.0 -- An enhanced Interactive Python. Type '?' for help.
In [1]: import gspread
...: from gspread_dataframe import (get_as_dataframe,
...: set_with_dataframe)
...: from oauth2client.service_account import ServiceAccountCredentials
...: scope = ["https://spreadsheets.google.com/feeds",
...: "https://www.googleapis.com/auth/drive"]
...: credentials = ServiceAccountCredentials.from_json_keyfile_name("./credentials.json", scope)
...: gc = gspread.authorize(credentials)
...: gc.open_by_key("11zmk55OFpFL5HW_MhPfqfC-GjRQvHlI_M-jtHcBzyzA")
Out[1]: <Spreadsheet 'Google Sheets Automation! 🐍' id:11zmk55OFpFL5HW_MhPfqfC-GjRQvHlI_M-jtHcBzyzA>
如果连接有问题，请阅读由gspread抛出的异常，它非常有用。记住，JSON 文件下载的密钥有一个client_email。该电子邮件需要与其共享工作表。OAuth 库需要在正确的文件路径下访问credentials.json。记得把文件重命名为credentials.json。
现在来给 Google Sheets 写信。
# gsheets.py
import gspread
from gspread_dataframe import (get_as_dataframe,
set_with_dataframe)
from oauth2client.service_account import ServiceAccountCredentials
import pandas as pd
FILE_KEY: str = "11zmk55OFpFL5HW_MhPfqfC-GjRQvHlI_M-jtHcBzyzA"
SHEET_NAME: str = "movie night"
def _get_worksheet(
key:str,
worksheet_name:str,
creds:"filepath to Google account credentials"="credentials.json",
) -> gspread.Worksheet:
""" return a gspread Worksheet instance for given Google Sheets workbook/worksheet """
scope = ["https://spreadsheets.google.com/feeds",
"https://www.googleapis.com/auth/drive"]
credentials = ServiceAccountCredentials.from_json_keyfile_name(creds, scope)
gc = gspread.authorize(credentials)
wb = gc.open_by_key(key)
sheet = wb.worksheet(worksheet_name)
return sheet
def write(sheet: gspread.Worksheet, df: pd.DataFrame, **options) -> None:
set_with_dataframe(sheet, df,
include_index=False,
resize=True,
**options)
使用这些函数:
sh: gspread.Worksheet = _get_worksheet(FILE_KEY, SHEET_NAME)
""" Here you are getting your data. Usually this would be a
database. But it could be another spreadsheet, serialized data,
generated from Python code... wherever. """
df = pd.read_pickle("./movienight2.pickle")
write(sh, df)
set_as_dataframe(信用罗宾·托马斯，gspread-dataframe.py)选项:
:param worksheet: the gspread worksheet to set with content of DataFrame.
:param dataframe: the DataFrame.
:param include_index: if True, include the DataFrame's index as an
additional column. Defaults to False.
:param include_column_header: if True, add a header row or rows before data with
column names. (If include_index is True, the index's name(s) will be
used as its columns' headers.) Defaults to True.
:param resize: if True, changes the worksheet's size to match the shape
of the provided DataFrame. If False, worksheet will only be
resized as necessary to contain the DataFrame contents.
Defaults to False.
:param allow_formulas: if True, interprets `=foo` as a formula in
cell values; otherwise all text beginning with `=` is escaped
to avoid its interpretation as a formula. Defaults to True.
Python 写 Google Sheets！
不错！(我喜欢看电脑做苦工。意味着我不用工作了。😄)注意resize=True选项是如何使工作表适应数据框形状的。
不过，还可以更好。在写入工作表之前，将对数据帧进行一些调整。日期格式为 datetime。同样，让我们使用单元格公式的力量来整理 IMDB 链接。
def _to_string(df: pd.DataFrame, *cols) -> pd.DataFrame:
for col in cols:
if col in df.columns:
df[col] = df[col].astype(str)
return df
def hyperlink_formula(df: pd.DataFrame, textcol: str, linkcol: str) -> pd.DataFrame:
ix: int = df.columns.tolist().index(textcol)
vals: pd.Series = \
'=HYPERLINK("' + df["IMDB URL"] + '", "' + df["Movie"] + '")'
df.insert(ix, textcol+"_temp", vals)
df.drop([textcol, linkcol], axis=1, inplace=True)
df.rename(columns={textcol+"_temp": textcol}, inplace=True)
return df
sh: gspread.Worksheet = _get_worksheet(FILE_KEY, SHEET_NAME)
df = pd.read_pickle("./movienight1.pickle")
df = _to_string(df, "Date", "Movie")
df = hyperlink_formula(df, "Movie", "IMDB URL")
write(sh, df)
干净多了。现在，Movie栏有了有效的超链接！
当新的电影之夜被插入到数据库中时，运行 Python 脚本的调度程序更新该表:
从谷歌工作表中读取
电影《夜秘》统计人头，解读人群，写下对事件的评论。人类仍然比机器做得更好的事情。
现在让 Python 来吃吧。要插入数据库，保存在 S3 桶，文件系统或其他地方。
为此，我们使用gspread_dataframe : get_as_dataframe提供的另一个函数。
set_as_dataframe选项(再次感谢罗宾·托马斯，gspread-dataframe.py):
:param worksheet: the worksheet.
:param evaluate_formulas: if True, get the value of a cell after
formula evaluation; otherwise get the formula itself if present.
Defaults to False.
:param nrows: if present and not None, limits the number of rows read from the worksheet.
Defaults to None. See pandas documentation for more info on this parameter.
:param \*\*options: all the options for pandas.io.parsers.TextParser,
according to the version of pandas that is installed.
(Note: TextParser supports only the default 'python' parser engine,
not the C engine.)
代码:
def read(sheet: gspread.Worksheet, **options) -> pd.DataFrame:
return get_as_dataframe(sheet,
evaluate_formulas=False,
**options)
df = read(sh)
(df[df["Movie"].str.contains("Rambo")]
.values.tolist()
)
这将返回:
[['2020-08-28',
'=HYPERLINK("https://m.imdb.com/title/tt1206885/?ref_=m_ttls_tt_119", "Rambo: Last Blood")',
6.2,
89,
1.0,
'😭😭😭😭',
'WHY AM I THE ONLY ONE HERE???']]
结论
电子表格是一个强大的工具。有了像 EZSheets、gspread 和 gspread_dataframe 这样的令人惊叹的 Google Sheets API 包装器，用 Python 管理它们的大量工作已经完成了。
使用电子表格作为 Python 工具链的一部分，而不是妨碍业务自动化…这为我们节省了大量时间和工作。最重要的是，它停止了“传递电子表格”的仪式。这是一件美妙的事情！
这是本文中使用的 Google 工作表的链接。
用于 Python 的谷歌翻译 API
在本教程中。我将演示如何使用 Google Translate API 将数据从印地语翻译成英语。
图片来源 : API 布道者
有些事情我想在教程开始的时候说清楚。首先，我会将数据从印地语翻译成英语。此外，我将在一个 Pandas 数据框上演示翻译，这意味着我将把整个数据框从印地语转换成英语。这不是很好吗？好吧，我们开始吧。另外，你可以使用 Google Colab 笔记本来输入代码。我建议每个人都通读一下 Google Translate API for Python 的文档，这样当你开始编码的时候，你可能就知道我的意思了。这将是一件轻而易举的事，因为你在编码时会知道大部分的术语。
快速和可靠-它使用相同的服务器，translate.google.com 使用自动语言检测批量翻译…
pypi.org](https://pypi.org/project/googletrans/)
打开你的 Google Colab，新建一个笔记本，命名为“Google _ translations . ipynb”。在实际输入代码之前，我希望你们所有人都在笔记本里手动安装谷歌翻译库。为此，只需键入!pip install googletrans。该命令自动下载并安装库，如下所示:
# install googletrans using pip
!pip install googletrans
！pip 安装 googletrans
导入必要的库
在这一步中，我们将导入我们将在整个教程中使用的必要库。库 熊猫 用于将 CSV 数据存储到数据帧中。而 googletrans 显然是用于翻译的，我们也将使用它的一个方法 Translator ，你将在后面的教程中看到。
# Importing the necessary librariesimport pandas as pd
import googletrans
from googletrans import Translator
将 CSV 文件存储为数据帧
在这一步中，我们将在 pandas 的帮助下将 CSV 文件存储为数据帧。要获取 CSV 文件，请单击下面的链接:
[## Vegetables_names_in_hindi.csv
编辑描述
drive.google.com](https://drive.google.com/open?id=1UZl-vf7uBh80GaQFk1-kxsa_zI-_rwFm)
下载 CSV 文件后，将文件上传到 Google Colab。左手边有 3 条水平线，悬停时提示“ 显示目录 ”。点击转到 文件 选项卡后再按 上传 。然后上传 CSV。
上传 CSV 文件
现在，您必须读取 CSV 文件并将其存储在数据框中。为了清楚起见，我显示了数据框的前 10 行。
# Reading and storing the CSV file as a dataframedf = pd.read_csv('/content/Vegetables_names_in_hindi.csv')
df.head(10)
在熊猫图书馆的帮助下，CSV 文件存储为数据帧
构建翻译器函数并翻译数据帧
这是我们将数据帧从印地语翻译成英语的地方。原始代码是从一篇[文章](http://translator = Translator() translations = {} for column in df.columns: # Unique elements of the column unique_elements = df[column].unique() for element in unique_elements: # Adding all the translations to a dictionary (translations) translations[element] = translator.translate(element).text translations)中获取的。但是我做了一些改变。因此，要了解更多关于翻译功能的信息，请点击[这里](http://translator = Translator() translations = {} for column in df.columns: # Unique elements of the column unique_elements = df[column].unique() for element in unique_elements: # Adding all the translations to a dictionary (translations) translations[element] = translator.translate(element).text translations)。
Googletrans 是一个使用 Google Translate API 的免费 python 库。在这篇文章中，我们解释了如何使用…
towardsdatascience.com](/translate-a-pandas-data-frame-using-googletrans-library-fb0aa7fca592)
translator = Translator()
translations = {}
for column in df.columns: # Unique elements of the column unique_elements = df[column].unique()
for element in unique_elements: # Adding all the translations to a dictionary (translations) translations[element] = translator.translate(element).texttranslations
存储在字典中的印地语到英语的值
基本上，我将所有独特的元素存储在一个数据帧中，然后在 translator 函数(Translator())的帮助下将每个元素翻译成英语。通过这样做，您可以从上面的输出中看到，所有的元素现在都被从印地语翻译成了存储在字典中的英语。
将翻译后的单词替换到原始数据帧
现在，最后一步是将转换后的数据替换或保存到新的或原始的数据框中。在这里，我将借助熊猫替换功能用原始数据帧替换它。
# Replacing all the translated words from the dictionary to the original dataframedf.replace(translations, inplace = True)
df.head(10)
最终翻译的数据(英语)
您已经成功地将 CSV 文件中的数据从印地语翻译成了英语。将来，默认情况下，您可以使用本教程作为参考，将数据从不同的语言翻译成英语。我希望你们今天学到了新东西。如果你对教程有任何疑问，请在下面的评论区提问。在那之前，下次见。再见。
用于 Python 的 Google 趋势 API
在本教程中，我将演示如何使用 Google Trends API 来获取互联网上的最新热门话题。
图片来源:谷歌趋势
介绍
Google trends 是一个基于各种地区和语言，分析并列出 Google search 上热门搜索结果的网站。Google Trends 是 Google 的网站(很明显)。在本教程的帮助下，您可以使用 Python 从 Google trends 网站获得趋势分析结果(以及更多)。您不需要手动搜索和复制趋势分析结果，名为pytrends的 Python API 会为您完成这项工作。在开始之前，我希望你们所有人浏览一下pytrends API 的官方文档。
谷歌趋势的非官方 API 允许从谷歌趋势自动下载报告的简单界面。主…
pypi.org](https://pypi.org/project/pytrends/)
在开始之前，本教程的全部代码可以在我的下面给出的 GitHub 资源库 中找到。请随意探索。
permalink dissolve GitHub 是 4000 多万开发人员的家园，他们一起工作来托管和审查代码，管理…
github.com](https://github.com/Tanu-N-Prabhu/Python/blob/master/Google_Trends_API.ipynb)
装置
第一步是手动安装库。所以，打开你最喜欢的 IDE 或者笔记本开始输入下面的代码。我将使用 Google Colab ，因为这是我最喜欢的笔记本。
如果你用的是 jupyter notebook，就按原样输入代码(确保你有“！”开头)
!pip install pytrends
或者，如果您使用的是 IDE，只需键入以下代码
pip install pytrends
执行上述代码后，您应该会得到如下所示的成功消息:
库成功安装
履行
连接到 Google
您必须首先连接到 Google，因为毕竟我们是从 Google Trends 请求 Google Trends 主题。为此，我们需要从pytrends.request库中导入名为TrendReq的方法。此外，我将导入 pandas 库来存储和可视化数据，您将在后面的教程中看到这些数据。
import pandas as pd
from pytrends.request import TrendReqpytrend = TrendReq()
按地区划分的利息
让我们看看世界范围内该地区流行的术语。我会选择，要搜索的词为“ 泰勒斯威夫特 ”(我好喜欢她……).
pytrend.build_payload(kw_list=[‘Taylor Swift’])# Interest by Region
df = pytrend.interest_by_region()
df.head(10)
按地区划分的利息
现在你可能在想什么是价值观，它们代表什么？这些值是按 0 到 100 的范围计算的，其中 100 是最受欢迎的位置，作为该位置中总搜索数的一部分，值 50 表示该位置受欢迎程度为一半。值为 0 表示没有足够的数据用于此项的位置。来源 → 谷歌趋势。
让我们把结果绘制在柱状图上，因为有时视觉表现能给出一个清晰的图像。
df.reset_index().plot(x=’geoName’, y=’Taylor Swift’, figsize=(120, 10), kind =’bar’)
条形图
同样，您使用参数resolution = 'COUNTRY_NAME'来过滤结果。
每日搜索趋势
现在，让我们来了解一下全球每日热门搜索趋势。为此，我们必须使用trending_searches()方法。如果你想在全球范围内搜索，不要传递任何参数。
# Get Google Hot Trends data
df = pytrend.trending_searches(pn=’united_states’)
df.head()
趋势搜索
确保您输入小写的国家名称pn = "canada"。另外，你可以将上述结果与 google trend 的结果进行比较。要了解今天的热门话题，只需使用:
df = pytrend.today_searches(pn=’US’)
排行榜
让我们看看 2019 年的趋势。在top_charts方法的帮助下，我们可以得到每年的热门搜索。
# Get Google Top Charts
df = pytrend.top_charts(2019, hl='en-US', tz=300, geo='GLOBAL')
df.head()
去年的热门标题(2019)
要比较结果，只需访问谷歌趋势。我们可以指定想要查看趋势搜索的年份和国家。
谷歌关键词建议
让我们看看如何才能获得谷歌的关键词建议。如果你不知道我在说什么？下图更清楚地解释了事情。
关键词建议
# Get Google Keyword Suggestionskeywords = pytrend.suggestions(keyword='Mercedes Benz')
df = pd.DataFrame(keywords)
df.drop(columns= 'mid') # This column makes no sense
关键词建议
相关查询
当用户搜索一个主题时，他们也会搜索一些相关的东西，这是很常见的事情。这些被称为相关查询。让我们看看题目“ 冠状病毒 ”的相关查询有哪些。请记住，当您想要更改主题名称时，只需使用新名称作为参数再次运行下面的代码。
pytrend.build_payload(kw_list=['Coronavirus'])
现在让我们运行方法related_queries，该方法返回一个字典，其中包含与主题“ 冠状病毒 ”相关的所有查询
# Related Queries, returns a dictionary of dataframesrelated_queries = pytrend.related_queries()
related_queries.values()
对冠状病毒的相关疑问
同样，您也可以搜索相关主题，只需运行以下代码即可:
# Related Topics, returns a dictionary of dataframesrelated_topic = pytrend.related_topics()
related_topic.values()
本教程到此结束，我希望你们已经学到了一些东西。如果你们对教程有任何疑问，请在评论区告诉我。虽然这是一个简短的教程，但有很多东西需要学习。好的，下节课再见，祝你有美好的一天！！！
谷歌在机器学习中的灵活性方法
如何建立一个亚麻阿尔法版本的 CNN？
由 Unsplash 上 MusicFox Fx 拍摄的照片
想到机器学习，首先想到的框架是 Tensorflow 和 PyTorch，如果你想与深度神经网络合作，这是目前最先进的框架。技术变化很快，需要更多的灵活性，因此谷歌的研究人员正在为开源社区开发一个新的高性能框架:Flax。
计算的基础是 JAX 而不是 NumPy，NumPy 也是谷歌的一个研究项目。JAX 最大的优势之一是使用了 XLA，一个特殊的线性代数编译器，支持在 GPU 和 TPU 上执行。对于那些不知道的人来说，TPU(张量处理单元)是一个专门为机器学习优化的芯片。JAX 重新实现了 NumPy 的一部分，在 GPU/TPU 上运行你的函数。
Flax 专注于以下关键点:
- 轻松阅读代码
- 更喜欢复制，而不是糟糕的抽象或膨胀的功能
- 有用的错误消息，似乎他们从 Tensorflow 错误消息中吸取了教训
- 基本实现的易扩展性
赞够了，现在开始编码吧。
因为 MNIST 的例子变得很无聊，我将为辛普森一家建立一个图像分类，不幸的是，Maggie 在数据集中丢失了:-(。
数据集的样本图像
首先，我们安装必要的库并解压缩数据集。不幸的是，此时您仍然需要 Tensorflow，因为 Flax 缺少一个好的数据输入管道。
现在我们导入库。你可以看到我们有两个“版本”的 numpy，普通的 numpy 库和 JAX 实现的 API 的一部分。print 语句根据可用的硬件输出 CPU、GPU 或 TPU。
为了训练和评估，我们首先必须创建两个 Tensorflow 数据集，并将它们转换成 numpy/jax 数组，因为 FLAX 不接受 TF 数据类型。这是目前有点 hacky，因为评估方法不采取批次。我必须为 eval 步骤创建一个大的批处理，并从中创建一个 TF 特征字典，它现在是可解析的，并可以在每个时期后提供给我们的 eval 步骤。
模型
CNN-class 包含了我们的卷积神经网络。当你熟悉 Tensorflow/Pytorch 时，你会发现它非常简单。我们的flax.nn.Conv的每个调用都定义了一个可学习的内核。我使用了 MNIST 的例子，并用一些额外的层来扩展它。最后，我们有四个输出神经元的密集层，因为我们有一个四类问题。
与 Tensorflow 不同，激活函数是显式调用的，这使得测试新的和自己编写的激活函数变得非常容易。FLAX 基于模块抽象，启动和调用网络都是通过 apply 函数完成的。
亚麻的度量标准
当然，我们想衡量我们的网络变得有多好。因此，我们计算损失和准确性等指标。我们的精度是用 JAX 库计算的，而不是 NumPy，因为我们可以在 TPU/GPU 上使用 JAX。
为了测量我们的损失，我们使用交叉熵损失，不像在 Tensorflow 中它是由你自己计算的，我们还没有可能使用现成的损失对象。如你所见，我们使用@jax.vmap作为损失函数的函数装饰器。这将我们的代码矢量化，以便在批处理中高效运行。
cross_entropy_loss是如何工作的？@jax.vmap接受两个数组，logits 和 label，并对每一对执行我们的cross_entropy_loss，从而允许批处理的并行计算。单个示例的交叉熵公式为:
对于四个输出神经元中的一个，我们的基本事实 y 是 0 或 1，因此我们的代码中不需要求和公式，因为我们只需要计算正确标签的 log(y_hat)。在我们的损失计算中使用平均值，因为我们有批次。
培训
在我们训练步骤中，我们再次使用函数装饰器@jax.jit，来加速我们的函数。这与 Tensorflow 非常相似。请记住batch[0]是我们的图像数据，batch[1]是我们的标签。
损失函数loss_fn返回当前模型optimizer.target的损失，我们的jax.grad()计算其梯度。在计算之后，我们像在张量流中一样应用梯度。
在 FLAX 中，评估步骤非常简单。请注意，完整的评估数据集将传递给此函数。
经过 50 个纪元后，我们有了非常高的精确度。当然，我们可以继续调整模型和优化超参数。
对于这个实验，我使用了 Google Colab，所以如果你想自己测试，用 GPU/TPU 创建一个新环境，并从 Github 导入我的笔记本。请注意，FLAX 目前不在 Windows 下工作。
结论
值得注意的是 FLAX 目前仍处于 alpha 阶段，并不是谷歌的官方产品。
到目前为止，这项工作给快速、轻量级和高度可定制的 ML 框架带来了希望。目前完全缺少的是数据输入管道，所以 Tensorflow 仍然必须使用。目前的一组优化器很不幸地仅限于带有动量的 ADAM 和 SGD。我特别喜欢如何使用这个框架的非常严格的前进方向和高度的灵活性。我的下一个计划是开发一些目前还没有的激活功能。Tensorflow、PyTorch 和 FLAX 之间的速度比较也会非常有趣。
如果你想尝试一下 FLAX，可以查看一下文档和他们的 Github 页面。
如果你想下载我的带有数据集的例子，只需克隆 SimpsonsFaceRecognitionFlax。
谷歌的数据科学面试脑筋急转弯
简单、直观地解释谷歌的一些问题解决方案
作为谷歌数据科学面试的一部分，他们喜欢问一些他们称之为“解决问题”的问题，这些问题非常类似于脑筋急转弯。在这篇文章中，我们将看看谷歌提出的六个问题，并提供以下答案！
如果你对更多的问题和解决方案感兴趣，请点击这里的 查看谷歌数据科学访谈中问到的一堆 产品、SQL 和编码问题。否则，这里有一个关于 在谷歌数据科学面试 中期待什么的伟大指南。
问题和答案
1。一个盒子里有 12 张红卡和 12 张黑卡。另一个盒子里有 24 张红牌和 24 张黑牌。你想从两个盒子中的一个里随机抽取两张卡片，一次抽取一张。哪个盒子得到同色卡片的概率更大，为什么？
有 24 张红卡和 24 张黑卡的盒子获得两张同色卡片的概率更大。让我们走过每一步。
假设你从每副牌中抽出的第一张牌是红色的 a。
这意味着在有 12 个红和 12 个黑的牌组中，现在有 11 个红和 12 个黑。因此，你再抽一张红色的几率等于 11/(11+12)或 11/23。
一副牌中有 24 个红和 24 个黑，那么就有 23 个红和 24 个黑。因此，你再抽一张红色的几率等于 23/(23+24)或 23/47。
由于 23/47 > 11/23，所以卡数较多的第二副牌有较大概率得到相同的两张牌。
2。你在赌场，有两个骰子可以玩。你每掷一次 5 就赢 10 美元。如果你一直玩到你赢了然后停止，预期的回报是多少？
- 我们假设每次你想玩的时候要花 5 美元。
- 两个骰子有 36 种可能的组合。
- 在 36 种组合中，有 4 种组合会掷出 5(见蓝色)。这意味着有 4/36 或 1/9 的机会掷出 5。
- 1/9 的胜算意味着你会输八次，赢一次(理论上)。
- 因此，您的预期支出等于$ 10.00 * 1-$ 5.00 * 9 =-35.00。
编辑:谢谢各位的评论和指出，应该是-$35！
3。如何判断给定的硬币是否有偏差？
这不是一个难题。答案很简单，就是进行假设检验:
- 零假设是硬币没有偏向，翻转头的概率应该等于 50% (p=0.5)。另一个假设是硬币有偏差，p！= 0.5.
- 抛硬币 500 次。
- 计算 Z 得分(如果样本小于 30，则需要计算 t 统计量)。
- 对比 alpha(双尾检验所以 0.05/2 = 0.025)。
- 如果 p 值>α，则不拒绝 null，硬币不偏。
如果 p 值<α，则 null 被拒绝，硬币有偏差。
在这里 了解更多假设检验 。
4。让不公平的硬币变得公平
由于抛硬币是二进制的结果，你可以通过抛两次硬币来使不公平的硬币变得公平。如果你掷两次，有两种结果可以赌:正面跟着反面或者反面跟着正面。
P(正面)* P(反面)= P(反面)* P(正面)
这是有意义的，因为每一次抛硬币都是一个独立的事件。这意味着如果你得到正面→正面或反面→反面，你需要重新抛硬币。
5。你即将登上去伦敦的飞机，你想知道你是否必须带雨伞。你随便打电话给三个朋友，问他们是否在下雨。你的朋友说实话的概率是 2/3，他们通过撒谎对你恶作剧的概率是 1/3。如果他们三个都说在下雨，那么伦敦下雨的概率是多少。
你可以看出这个问题与贝叶斯理论有关，因为最后一个陈述本质上遵循这样的结构，“假设 B 为真，A 为真的概率是多少？”因此，我们需要知道某一天伦敦下雨的概率。假设是 25%。
P(A) =下雨的概率= 25%
P(B) =三个朋友都说在下雨的概率
P(A|B)假定他们说在下雨的概率
P(B|A)假定在下雨的情况下三个朋友都说在下雨的概率= (2/3) = 8/27
第一步:求解 P(B)
P(A | B)= P(B | A) * P(A)/P(B)，可以改写为
P(B)= P(B | A)* P(A)+P(B |非 A)* P(非 A)
P(B)=(2/3)* 0.25+(1/3)* 0.75 = 0.25 * 8/27+0.75 * 1
第二步:求解 P(A | B)
P(A | B)= 0.25 *(8/27)/(0.25 * 8/27+0.75 * 1/27)
P(A | B)= 8/(8+3)= 8/11
因此，如果三个朋友都说在下雨，那么有 8/11 的几率是真的在下雨。
6。给你 40 张四种不同颜色的卡片——10 张绿卡，10 张红牌，10 张蓝卡，10 张黄牌。每种颜色的卡片都从一到十编号。随机抽取两张牌。找出所选卡片不是相同号码和相同颜色的概率。
由于这些事件不是独立的，我们可以使用规则:
P(A 和 B) = P(A) * P(B|A)，也等于
P(非 A 非 B) = P(非 A) * P(非 B |非 A)
例如:
P(非 4 非黄)= P(非 4) * P(非黄|非 4)
P(非 4 非黄)= (36/39) * (27/36)
P(非 4 非黄)= 0.692
所以，挑出来的牌不是同号同色的概率是 69.2%。
就是这样！如果任何答案没有意义，请让我来，我会尽我所能解释得更透彻:)
如果你对更多数据科学问题感兴趣，请查看面试提问。
感谢阅读！
Google 的 EfficientDet:概述
使用网络优化网络
如果你像我一样，读了谷歌的 EfficientDet 论文，你会问“到底发生了什么？”。不要担心，我已经审阅了论文，并将尽我所能解释这个模型。
这个模型建立在以前的工作(像许多其他模型一样)之上，更具体地说，是一项被称为 EfficientNet 的关键工作:
在我们深入研究谷歌新的目标检测模型的细节之前，让我们先做一下 EfficientNets 的背景工作。
效率网
本文作者关注如何有效地扩展卷积神经网络(ConvNets)以提高性能。缩放网络以提高性能的典型方法是增加以下之一:网络深度、宽度或图像分辨率。虽然有可能将两个或更多的这些一起缩放，但是目前这是一个冗长的过程，并且通常导致模型具有次优的准确性和效率。下面是不同缩放方法的图示，直接摘自该论文:
缩放神经网络模型的方法。摘自谭&乐 2019
作者旨在回答这个问题:
有没有一种原理性的方法可以提高网络的精度和效率？
你可能已经猜到了，但答案是肯定的。他们发现平衡网络宽度/深度/分辨率的所有维度非常重要。让你吃惊的是他们的缩放方法的简单性。他们只是用一个恒定的比例来缩放每个维度。就是这样！他们称这种方法为复合缩放。随着用于训练神经网络的图像变得更大，复合缩放开始变得有意义，因为更大的图像需要更深的网络来增加感受域，并需要更多的通道来捕捉更大图像中的更小细节。
我们很快发现，模型缩放带来的性能提升在很大程度上依赖于基线网络。作者更进一步，使用一种叫做神经结构搜索(NAS)的算法来寻找最佳基线网络。在给定目标函数的情况下，高级 NAS 算法使用强化学习来确定最佳结构。使用 NAS 创建了一个新的模型系列，称为 EfficientNets。在 ImageNet 数据集上将这些模型的性能与 ConvNets 进行了比较，结果如下图所示:
与其他分类器相比，EfficientNet 系列的性能。摘自谭&乐 2019
从这些结果中引人注目的是，这些模型在准确性和参数数量方面都优于其他先进模型。作者还表明，这些模型可以很好地转移到其他数据集，在 8 个公开可用的数据集中，有 5 个成为得分最高的模型，同时参数减少了 21 倍。
复合模型缩放
那么复合缩放实际上是如何工作的呢？首先，让我们将 ConvNet 定义为:
谭&乐，2019 一个共网的定义
他们本质上将其描述为由应用于输入张量的运算(例如卷积)组成的层列表。
复合缩放试图扩展网络长度(Lᵢ)、宽度(Cᵢ)和/或分辨率(Hᵢ、Wᵢ)，而不改变基线网络中预定义的 Fᵢ。固定 Fᵢ的基本原理是为了减少设计空间，但考虑到 Lᵢ、Cᵢ、Hᵢ和 Wᵢ仍然可以探索每一层，设计空间仍然相当大。为了进一步减小设计空间，施加了一个限制，即所有层必须以恒定的比率均匀缩放。复合缩放的目标是在给定资源约束的情况下最大化模型的准确性，这被公式化为一个优化问题:
复合扩展的目标是优化系统资源约束。摘自摘自谭&乐，2019
w、d 和 r 是用于缩放网络宽度、深度和分辨率的系数。预定义参数的符号上方有一个^。预定义网络的示例如下所示:
预定义的高效网络。摘自谭&乐 2019
缩放尺寸
扩展 ConvNet 的深度(d)、宽度(w)和分辨率(r)的难点在于，这三者相互依赖，并且会在不同的资源限制下发生变化。因此，通常只在一个维度上缩放。
深度:缩放深度是缩放 ConvNet 最常见的方式。网络变得更深，因为更深的网络可以提取更丰富和更复杂的特征。不利的一面是，由于梯度消失的问题，更深的凹网更难训练。这个问题通过跳过连接和批量标准化得到了缓解，但是对于非常深的网络来说，回报是递减的。
宽度:通常用于较小的车型。这些网络通常更擅长捕获图像的细粒度特征，并且更容易训练。
分辨率:提高图像的输入分辨率，ConvNets 可以捕捉图像中的细粒度模式。早期的 con vnet 在 224x224 上训练，而较新的 con vnet 在 480x480 上训练。下图显示了分别扩展这些维度的性能(在预定义的网络上执行扩展，如上所示):
通过单独扩展每个维度来提高性能。左边是宽度，中间是深度，右边是分辨率。摘自谭&乐 2019
这一结果的主要观察结果表明，扩大网络的深度、宽度和分辨率可以提高精度，但对于更深、更大的模型，精度会降低。
复合缩放
到目前为止，显而易见的是，标度维数不是独立的。例如，作者指出:
更高分辨率的图像应该需要更深的网络，以便更大的感受野可以在更大的图像中捕获包括更多像素的类似特征。
作为提高分辨率的结果，网络宽度也应该增加以捕捉更精细的细节。这些直觉表明，模型需要在所有这些维度上进行缩放，而不是在单一维度上。为了验证他们的直觉，作者在深度(d)和分辨率(r)的不同组合上测量了网络的宽度(w)(下图)。下图中的缩放示例从基线网络(d=1.0，r=1.0)开始，有 18 个分辨率为 224x224 的卷积层。最后一个基线网络(d=2.0，r=1.3)产生 36 个卷积层，分辨率为 299x299。
扩展网络宽度。每条线代表由图例中定义的系数缩放的不同作品。每条线上的一点显示不同的宽度。该网络是从前面显示的预定义网络扩展而来的。摘自谭&乐 2019
这一结果使作者观察到，为了获得更好的模型精度和效率，在缩放过程中平衡网络的所有维度是重要的。根据这一观察，他们提出了一种复合缩放方法。该方法使用复合缩放系数φ来统一缩放网络尺寸:
在等式中，α、β和γ是常数，可以通过网格搜索来确定。用户定义的系数(φ)控制如何为模型缩放分配资源。而α、β和γ分别定义了如何将这些资源分配给网络的宽度、深度和分辨率。
通过缩放现有的 ConvNets 来评估缩放方法。为了真正利用这种新方法，一个名为 EfficientNet 的新架构家族应运而生。他们通过使用 NAS 优化准确性和 FLOPS 来构建基线网络。他们的研究产生了一个叫做 EfficientNet-B0 的高效网络。下表说明了 EfficientNet-B0 网络(它与前面显示的预定义网络完全相同):
高效网络-B0 网络。摘自谭&乐 2019
他们的下一步是通过分两步应用复合扩展来扩展 EfficientNet-B0:
- 将φ固定为 1。对α、β和γ进行网格搜索。他们发现 EfficentNet-B0 的最佳值为α = 1.2，β = 1.1，γ = 1.15。
- 将α、β和γ固定为常数，并按比例放大不同φ的基线网络，以获得到 B7 的有效 Net-B1。
下表显示了这些新网络与其他先进网络相比的性能:
EfficinetNet 模型系列与其他分类器相比的性能。摘自谭&乐 2019
与现有的 ConvNets 相比，EfficientNets 的性能始终更好，并且减少了参数和触发器的数量。下表和下图进一步证实了这一点:
通过高效网络实现的速度提升。摘自谭&乐 2019
与 ResNet-152 相比，EfficientNet-B1 的 CPU 延迟快 5.7 倍，尽管它们具有相当的准确性。在精确度范围的顶端，GPipe 模型对于数据集上具有 84.3%精确度的单个图像具有 19.0 秒的延迟。最大的 EfficientNet 型号(B7)只有 3.1 秒的延迟，这是 6.1 倍的加速。下图显示了 FLOPS 与 Imagenet Top-1 精度的对比。
与其他分类器相比，EfficientNet 模型系列的 FLOPS。摘自谭&乐，2019
该图清楚地显示了 EfficientNet 系列更好地利用了可用资源，该模型在准确性方面表现更好，并且显著减少了 FLOPS 的数量。
单维缩放
为了消除复合缩放方法对 EfficientNet 架构的影响，B0 架构仅在一维上进行缩放。这些结果如下图所示:
用不同的方法扩展 EfficientNet-B0 网络。摘自谭&乐 2019
显而易见，复合比例远远优于单一维度的比例，后者很快导致收益递减。这突出了复合缩放的重要性。为了进一步理解为什么复合缩放如此有效，下图比较了一系列缩放 B0 模型的类激活图:
不同缩放方法的类激活图。显示复合缩放提供了更多相关的激活。摘自谭&乐 2019
复合缩放模型倾向于关注具有更多相关对象细节的区域。其他型号对这些细节关注较少。
总体而言，本文作者表明，在给定一组资源约束的情况下，平衡网络深度、宽度和分辨率对于优化性能至关重要。复合缩放方法提供了一种在所有这些维度上有效缩放模型的优雅方式。这就引出了本文的下一部分，Google 的 EfficientDet，它建立在上面讨论的工作之上。
EfficientDet:可扩展且高效的对象检测
近年来，在对象检测方面取得了巨大的进步，产生了更精确的模型，但代价是增加了计算量。这些巨大的计算成本将阻碍它们在许多现实世界应用中的部署，例如自动驾驶汽车，其中低延迟预测是必要的。在这样的约束下，模型效率对于对象检测来说非常重要。模型检测器架构，如一级和无锚检测器更有效，但通常以精度为代价。因此，人们自然会问:
是否有可能建立一个可扩展的检测架构，同时具有更高的准确性和更好的效率？
Google 的 EfficientDet 旨在解决这个问题，要回答这个问题，我们首先需要了解当前物体探测器设计选择的挑战:
挑战 1——高效的多尺度特征融合:特征金字塔网络(FPN)广泛用于多尺度特征融合。最近的工作，如 PANet 和 NAS-FPN 允许跨尺度特征融合。先前的特征融合方法简单地将特征相加在一起，然而，这些特征具有不同的分辨率，并且已经观察到对输出融合特征的贡献不相等。为了解决这个问题，提出了加权双向特征金字塔网络。BiFPN 具有可学习的权重来确定不同输入特征的重要性，其应用自顶向下和自底向上的多尺度特征融合。
挑战 2 -模型缩放:对象检测器的模型缩放通常会牺牲准确性或效率。受 EfficientNets 作者所做工作的启发，提出了一种用于对象检测器的复合缩放方法。像 EfficientNets 一样，这种缩放方法也可以缩放网络的深度、宽度和分辨率。
EfficientNet 与提议的 BiFPN 和复合缩放的结合创造了一个新的检测机系列，称为 EfficientDet 。与以前的物体检测器相比，该系列模型始终实现了更高的精度，并将触发器数量减少了一个数量级。EfficentDet 对目标探测社区的贡献可以总结为三点:
- BiFPN 简介。这是一个加权的双向特征网络，便于进行多尺度特征融合
- 提出一种缩放方法，以原则方式缩放主干、特征网络、盒/类网络和分辨率
- 结合以上两点，产生了 EfficientDet，一种新的物体检测器系列。这些模型在广泛的资源限制范围内具有更好的准确性和效率
BiFPN
为了理解 BiFPN 的贡献，我们需要首先将问题公式化。多尺度特征融合旨在聚合不同分辨率的特征。这可以表示为多尺度特征的列表:
其中上面的每个元素代表 lᵢ.级别的特征目标是找到一个转换 f ，它可以聚集特性并输出一系列新特性:
为了理解这一点的重要性，我们来看一下传统的 FPN，它集成了不同尺度的功能:
传统的 FPN 网络。摘自 谭等著 2019 年
它有 3–7 个输入要素(P₃ - P₇)，其中每个输入要素代表一个具有给定分辨率的要素级别。该 FPN 以自上而下的方式聚合多尺度要素:
Resize 通常是分辨率匹配的上采样或下采样操作。最后， Conv 是用于特征处理的卷积运算。
上面显示的 FPN 固有地受到信息单向流动的限制。为了解决这个问题，PANet 增加了一个自下而上的路径，NAS-FPN 使用神经架构搜索来寻找更好的跨尺度特征网络拓扑。下图显示了这两种网络设计:
三种不同的 FPN 结构。★2019谭等。
作者表明，PANet 比 NAS-FPN 获得了更好的精度，但代价是更多的参数和计算。提出了几项优化措施:
- 移除只有一条输入边的结点。如果某个结点只有一条输入边，且没有要素融合，则该结点对要素网络目标的贡献可能较小。这导致了一个简化的面板(见上图)
- 从输入节点到输出节点只在同一层增加一条额外的边。这将融合更多的功能，而不需要太多的额外成本
- 存在双向信息流(自上而下和自下而上)。每个双向路径被视为其自己的层，因此允许这些层重复，从而实现更高级别的特征融合(BiFPN，如下)
通过这些优化，新的特征网络被命名为双向特征金字塔网络(BiFPN)。BIF pn 如下图所示:
BiFPN 结构。摘自 谭等译 2019
加权特征融合
如前所述，不同分辨率的特征融合通常包括调整它们的大小，然后进行求和运算。这种方法的缺点是所有特征都被同等对待。由于这些特征具有不同的分辨率，它们通常对输出特征的贡献是不相等的。为了解决这个问题，计算每个输入特征的额外权重，以允许网络学习每个特征的重要性。总共测试了三种加权融合方法:
- 无界融合:包含一个无界可学习权重。但是，因为它是无界的，所以会导致训练不稳定，所以被丢弃
- 基于 Softmax 的融合:对每个权重应用 softmax，从而将权重限制在 0 到 1 之间，但这导致延迟显著增加。
- 快速归一化融合:等式如下。通过 Relu 的应用，确保每个权重(ωᵢ)大于或等于零。ϵ设置为 0.001 以避免数值稳定性。与基于 softmax 的方法相比，这种计算在 GPU 上要快 30%。
快速标准化融合。摘自 谭等著 2019
最终的 BiFPN 集成了双向跨尺度连接和快速归一化方法。这方面的一个例子如下所示，它是 BiFPN 中的第 6 层:
P6 层中跨尺度连接的集成示例。摘自 谭等译 2019
上面的等式是自上而下路径的中间等式，下面的等式是自下而上路径的等式。
效率检测
随着 BiFPN 的发明，一种新的检测器系列被创造出来，称为 EfficientDet。EfficientDet 的架构如下所示，使用 EfficientNet 作为主干网络。
具有 EfficientNet 主干和 BiFPN 结构的 EfficientDet 架构。摘自 谭等著 2019 年
该网络中的 BiFPN 用作特征网络。它从主干网络中提取第 3 - 7 层的特征，并重复应用 BiFPN。融合后的特征被输入到一个类和盒网络中，以预测物体的类和包围盒。
复合缩放
受 EfficientNets 中复合缩放的启发，提出了一种新的复合缩放目标检测方法。该方法使用系数(φ)来联合放大主干网络、BiFPN 网络、类/箱网络和分辨率的所有维度。每个网络组件的扩展描述如下:
- 主干网络:使用 B0-B6 中定义的相同系数，以便可以重复使用其 ImageNet 预训练权重
- BiFPN: 宽度呈指数增长(通道)，深度呈线性增长(层)。形式上，宽度和深度使用以下等式进行缩放:
- 框/类预测网络:宽度固定为与 BiFPN 中相同，但深度线性增加，如下所示:
- 输入图像分辨率:由于分辨率必须能被 2⁷ = 128 整除，因此分辨率也线性增加。这是通过以下等式实现的:
使用上面所示的三个等式，创建了从 efficient det-D0(φ= 0)到 D6(φ= 6)的家族网络。下表进一步阐述了这一点:
不同 EfficientDet 模型的架构总结。摘自 谭等著 2019
该表还包含一个 D7 模型，除非更改批量大小或其他设置，否则该模型无法放入内存。结果，通过仅增加输入图像分辨率，D6 模型被扩展到 D7。
性能
这些型号与其他探测器相比如何？下表显示了 EfficientDet 系列与按精度分组的其他型号的比较:
与其他检测机相比，EfficientDet 系列型号的性能。摘自【谭】等著 2019
与以前的检测机相比，EfficientDet 系列型号在各种精度水平和资源限制下实现了更高的精度和效率。
为了了解 BiFPN 对模型性能的贡献，下表比较了主干网和 BiFPN 的影响:
EfficientDet 模型中每个组件的贡献(根据 mAP)。摘自 谭等著 2019 年
很明显，强主干结构提高了性能，但是 BiFPN 的增加不仅通过增加 mAP 而且通过减少参数和触发器的数量进一步提高了性能。另一个关键的补充是加权连接。与其他 fpn 相比，加权连接如何影响性能:
加权连接对地图的影响。摘自 谭等译 2019
你可以看到，受到单向信息流限制的普通 FPN 精确度最低。PANet 和 NAS-FPN 模型显示了更高的精度，但需要更多的参数和触发器。总体而言，BiFPN 以更少的参数和触发器实现了最佳精度。
结论
EfficientDet 网络深受 EfficientNet 模型工作的启发。使用复合缩放，与其他现代对象检测模型相比，该模型在准确性和效率方面的性能都得到了提高。事实证明，EfficientDet 系列模型在 GPU 和 CPU 上具有显著的加速性能，这对于要求低延迟的应用程序来说至关重要。我相信我们正在进入一个目标探测发展的阶段，在这个阶段优化当前的模型将变得至关重要。我们总是可以建立更大更深的模型以获得更高的精确度，但是我们能优化它们以充分利用它们吗？
基于 Python 的戈登增长模型
使用 Gordon 增长模型评估 Python 公司的价值
戈登增长模型(GGM)是一种用来评估公司价值的工具。这一理论假设公司的价值是所有未来股息支付的总和贴现到今天的价值(即现值)。也可以称为股利贴现模型。在这篇文章中，我们将学习如何使用 Python 的 戈登增长模型对一家公司进行估值。
照片由 Aditya Vyas 在 Unsplash 拍摄
理解戈登增长模型(GGM)
GGM 模型的优点之一是计算起来非常简单。
评估公司价值的戈登增长模型
为了计算我们的模型，我们只需要三个元素:
- 股息(Do) :公司支付的股息。通过查看公司公开的年度/季度报告，我们可以很容易地获得公司支付的最新股息。
- 增长(g): 是红利预期的常数增长率。计算 g 的一种方法是，取一家公司最近支付的两到三次股息，计算增长，并用它来代表持续增长。这种方法的问题是，如果一家公司保持其股息支付年复一年不变，在我们的计算增长率将为零。为了解决这个问题，我们将采取不同的方法，用可持续增长率来代替。可持续增长率是指一家公司无需通过额外股本融资就能实现的增长率。
- 权益成本(ke): 我们将使用资本资产定价模型(CAPM)来估算所需的权益成本。如果你想进一步了解 CAPM 模型，我推荐你 看看下面这篇文章 。
戈登增长模型假设
该模型使用了一些假设，我们需要记住这些假设:
- 股息增长率逐年保持不变。
- 股息是股东财富的核心。
- 权益成本必须大于股息增长。否则，我们的模型会给出负值。
计算戈登增长模型所需的数据
我们将使用免费 API、financialmodelingprep 和熊猫数据阅读器来检索公司信息和市场数据。以下是使用 GGM 模型得出公司估值所需的数据:
- 最新公司分红
2.为了通过 CAPM 模型计算权益成本(ke) ，我们需要:
- 公司 Beta ( B )。它可以从financialmodelingprepAPI 中提取。
- 无风险利率( RF )。我们将使用 1 年期国库券作为我们的模型无风险利率。
- 市场预期收益( ERm )。我们将计算标准普尔 500 指数最近一年的回报，作为我们市场预期回报的代理。另一种方法是采用美国股票的超额历史年回报率。
3.为了计算可持续增长率，我们需要支付率和股本回报率(ROE)。
资本资产定价模型:
预期收益(即权益成本)= Rf + B (ERm — Rf
用 Python 计算戈登增长模型
现在我们对 GGM 模型(或股息贴现模型)有了更多的了解，让我们开始构建我们的脚本。
这个想法是构建一个 Python 函数，它将一个公司股票代码作为参数。该函数将返回公司价值作为结果(即股票价格)。
import requests
def valuecompany(quote):
#getting the latest dividend
dividend =
requests.get(f'https://financialmodelingprep.com/api/v3/financials/income-statement/{quote}')
dividend = dividend.json()
dividend = dividend['financials']
Dtoday = float(dividend[0]['Dividend per Share'])
print(Dtoday)
valuecompany('JNJ')
#Return:
3.47931249313
3.47 is the dividend paid by Johnson & Johnson in the latest year
在函数的第一部分，我们对 API 端点进行 http 调用，以检索作为参数传递的公司的股息值。在我们的例子中，我们传递了 Johnson & Johnson 的股票代码(注意，API 通过股票代码来识别公司)。
如代码所示，我们解析财务列表的第一个元素，它包含一个字典。在这个字典中，我们提取关键字“每股股息”的值。在将该值转换成浮点型数据后，我们将它存储在变量调用 Dtoday 中。
如果你不熟悉如何用 Python 解析字典，我推荐你看一下下面的文章。
用 Python 解析 API
太好了，我们有了模型的第一部分。接下来，我们需要计算 可持续增长率 。计算比率的公式如下所示:
SGR =净资产收益率 (1 —股息支付率)*
我们可以从公司关键指标 API 终点得到净资产收益率和股利支付率。为了提取这些值，我们需要解析指标字典并提取关键字 ROE 和 payout_ratio 的值:
metrics = requests.get(f'https://financialmodelingprep.com/api/v3/company-key-metrics/{quote}')
metrics = metrics.json()
ROE = float(metrics['metrics'][0]['ROE'])
payout_ratio = float(metrics['metrics'][0]['Payout Ratio'])
sustgrwothrate = ROE*(1-payout_ratio)
print(sustgrwothrate)
#Result
0.097024
The sustainable growth rate for JNJ is of 9.7%
现在我们已经计算了 可持续增长率 以及。最后，我们可以使用 CAPM 模型计算权益成本:
用 Python 计算权益成本(Ke ):
为了通过 CAPM 计算权益成本(ke) 我们需要的第一个要素是无风险利率。我们将使用 1 年期国库券作为代理，因为国库券被认为是无风险证券。
我们将使用 Pandas DataReader 和 FRED 作为数据提供者。网。DataReader 方法将返回一个 Pandas DataFrame，其中包含一个 1 年期国库券提供的利率时间序列。
我们使用 iloc[-1] 方法来检索数据帧的最新元素，因为我们的 Pandas 数据帧 Treasury 的最新元素包含最新的可用利率 。
import pandas as pd
#if you get an error after executing the code, try adding below:
pd.core.common.is_list_like = pd.api.types.is_list_like
import pandas_datareader.data as web
import datetime
start = datetime.datetime(2019, 2, 1)
end = datetime.datetime(2020, 2, 27)
Treasury = web.DataReader(['TB1YR'], 'fred', start, end)
RF = float(Treasury.iloc[-1])
RF = RF/100
print(RF)
#Result:
0.0149 or 1.49%
接下来，我们需要为公司获得测试版。它可以很容易地从 API 公司简介端点中提取出来:
beta = requests.get(f'https://financialmodelingprep.com/api/v3/company/profile/{quote}')
beta = beta.json()
beta = float(beta['profile']['beta'])
print(beta)
#Result:
0.70 is the Beta for JNJ
最后，计算权益成本的最后一个要素是预期市场回报(即 CAPM 模型中的市场溢价)。
我们将使用指数 S & P 500 作为市场回报的代表。然后，我们将计算去年的市场回报。这是我们用来代表预期市场回报的指标。
正如我的另一篇文章所示，使用 Pandas DataReader 和 FRED 作为数据提供者，我们可以很容易地检索标准普尔 500 的价格并计算市场回报:
start = datetime.datetime(2019, 2, 15)
end = datetime.datetime(2020, 2, 15)
SP500 = web.DataReader(['sp500'], 'fred', start, end)
#Drop all Not a number values using drop method.
SP500.dropna(inplace = True)
SP500yearlyreturn = (SP500['sp500'].iloc[-1]/ SP500['sp500'].iloc[0])-1
print(SP500yearlyreturn)
# Result:
0.34666119528451844
The market return from the last year was around 34%
注意，我们可以使用 iloc 来提取熊猫数据帧的第一个元素。即 iloc[0] 包含去年的 S & P 500 价格。另一方面， iloc[-1] 包含最近的 S & P 500 价格。
然后，我们使用以下公式计算年回报率以获得回报率:
简单收益率
完美！我们拥有计算权益成本 ( Ke )所需的所有要素。现在我们只需要应用公式通过 CAPM 模型得到 Ke 。
ke = RF+(beta*(SP500yearlyreturn - RF))
print(ke)
#Response:
0.24735644374478466
24% is the cost of equity for JNJ
把所有这些放在一起，计算公司的价值
最后，我们拥有了通过戈登增长模型和 Python 计算公司价值所需的所有元素。
在 Johnson & Johnson 的案例中，我们看到根据模型得出的股价为 25.38 美元，远低于当前每股 150 美元的股价。
戈登增长模型的问题之一是返回值对模型的输入非常敏感。例如，权益成本的轻微增加/减少会对计算的价值产生很大影响。
DDM = (Dtoday*(1+sustgrwothrate))/(ke-sustgrwothrate)
return DDM
#Result:
25.38 is the value of JNJ stock according to the DDM model
模型限制和总结
在这篇文章中，我们建立了一个模型，并使用戈登增长模型对一家公司进行了估值。您可以通过将这个脚本作为函数 valuecompany 的一个参数来对任何公司进行估值。Python 将为您完成这项工作。
然而，当使用戈登增长模型对一家公司进行估值时，有一些限制需要考虑，这将使模型不起作用:
- 这种模式不适用于不支付股息的公司
- 权益成本必须大于股息增长。否则，我们的模型将给出负值(即分母 ke-g ，将为负值)
- 假设每股股息不变在现实世界中是不现实的
希望你喜欢这篇关于如何用 Python 计算戈登增长模型的文章！请参阅下面的完整代码，以供参考:
import requests
def valuecompany(quote):
#Latest dividend of the company
dividend = requests.get(f'https://financialmodelingprep.com/api/v3/financials/income-statement/{quote}')
dividend = dividend.json()
dividend = dividend['financials']
Dtoday = float(dividend[0]['Dividend per Share'])
#ROE and PAyout Ratio
metrics = requests.get(f'https://financialmodelingprep.com/api/v3/company-key-metrics/{quote}')
metrics = metrics.json()
ROE = float(metrics['metrics'][0]['ROE'])
payout_ratio = float(metrics['metrics'][0]['Payout Ratio'])
sustgrwothrate = ROE*(1-payout_ratio)
print(sustgrwothrate)
##Cost of equity:
#Risk Free Rate
import pandas as pd
#if you get an error after executing the code, try adding below:
pd.core.common.is_list_like = pd.api.types.is_list_like
import pandas_datareader.data as web
import datetime
start = datetime.datetime(2019, 2, 1)
end = datetime.datetime(2020, 2, 27)
Treasury = web.DataReader(['TB1YR'], 'fred', start, end)
RF = float(Treasury.iloc[-1])
RF = RF/100
#Beta
beta = requests.get(f'https://financialmodelingprep.com/api/v3/company/profile/{quote}')
beta = beta.json()
beta = float(beta['profile']['beta'])
#Market Return
start = datetime.datetime(2019, 1, 1)
end = datetime.datetime(2020, 2, 27)
SP500 = web.DataReader(['sp500'], 'fred', start, end)
#Drop all Not a number values using drop method.
SP500.dropna(inplace = True)
SP500yearlyreturn = (SP500['sp500'].iloc[-1]/ SP500['sp500'].iloc[0])-1
ke = RF+(beta*(SP500yearlyreturn - RF))
DDM = (Dtoday*(1+sustgrwothrate))/(ke-sustgrwothrate)
print(DDM)
return DDM
valuecompany('JNJ')
原载于 2020 年 2 月 19 日【https://codingandfun.com】。
R 中漂亮(简单)的地理空间数据可视化
使用 ggplot2、rgdal 和 maptools 制作华丽的渐变
我最近在 R 中写了一篇关于地理空间可视化的介绍文章，这篇文章很快成为我阅读量最大的文章，增加了 5 倍(谢谢，顺便说一句！).看到人们对地理空间数据可视化如此感兴趣真是太棒了，因为在这一点上，它已经成为我在这个星球上最喜欢的事情之一。
话虽如此，我觉得我已经在桌子上留下了一些卡片；首先，我没有讨论过 ggplot2。更好的是，第二种方式甚至更漂亮。
在本教程中，我们将使用 2010 年的人口普查数据来展示用 R 的 ggplot2 库绘图的奇迹。就像上次一样，只有 3 步—所以拿些爆米花，让我们开始吧！
步骤 1:下载 2010 年人口普查数据集
史上最简单的一步；去我的 Github repo 下载 county_census.zip 就行了。
这是一个相当大的文件；一旦下载完毕，解压，你就可以开始了。
步骤 2:安装库并上传普查数据到 R
我们将使用 3 R 库，它们是maptools、rgdal和ggplot2。我们还将运行一个命令readShapeSpatial()，它将提示您输入想要使用的文件。
- 出现提示时，一定要打开
County_2010Census_DP1.shp(这是上一步下载的)。
步骤 3:地理空间制图
例 1:佛罗里达州&中位年龄
现在，我们将选择一个状态，创建一个模板，并用颜色填充它:
图表显示:
左:粉色&面霜，例 1；右:蓝色&绿色，前。2
在重新创建时，“GEOID10”只是指 2010 年的人口普查，不需要更改。另一方面，第一行中的“12”代表佛罗里达州的 FIPS 代码，如果你绘制不同的州，这个代码会改变。 FIPS 代码是常用的唯一标识符，它将每个州定义为一个从 1 到 50 的数字(美国领地也有自己的 FIPS 代码)。
DP_TableDescriptions.xlx提供了我们可以根据人口普查中提供的答案绘制的所有变量的列表(对于本例，我选择了 DP0020001，各县的平均年龄)。你可以在county_census.zip文件中找到这个 Excel 表格。
佛罗里达&中位年龄图很好，因为老年人和年轻人的高数量组合构成了一个超级漂亮的梯度(谢谢你，雪鸟！).如果你想描绘另一个州，你可以参考这一页，找到你选择的 FIPS 代码。否则，坚持佛罗里达就好了。
不要画俄亥俄州，因为…嗯，你知道的。
例 2:路易斯安那州和平均家庭规模(+趣味色彩！)
我们将再做一次，改变我们选择使用的州和人口普查数据——我喜欢提供两个例子，以便有人可以看到代码如何响应变化。
让我们使用 R 颜色来挑选一两个令人愉快的配色方案，并进行绘图:
图表显示:
左: Camo，Ex.3右:红色，白色&蓝色，例如。四
这一次，我选择了迷彩的颜色(在美国农村长大，迷彩已经深深印在我的脑海里)和另一种红色、白色和蓝色，奇怪的是，这让我想起了黏糊糊的冰棍，而不是美国国旗。
尼克·托伦塔利在 Unsplash 上拍摄的照片
另外，你会注意到在第二个例子中渐变的范围发生了巨大的变化——因为我们是手动插入的，所以在你精确地描绘了整个范围并设置了一个精确的中间值之前，对它进行试验是很重要的(稍微搜索一下就可以避免太多的猜测)。如果任何州县持有超出指定范围的值，它们在绘制图表时将显示为令人讨厌的灰色。
结论
我希望你对这个教程有一点兴趣(我非常喜欢想象伪装中的路易斯安那州！).如果你有任何问题，运行代码的问题，或者只是想打个招呼，请在下面评论🙂。你也可以通过我的个人网站或推特联系我。
谢谢，祝你一周愉快！
——阿曼达·❤️
有 50 美元吗？把你的手机变成一个可编程机器人
OpenBot 计划旨在利用现有设备实现边缘机器人的大众化。
英特尔实验室刚刚公布了其 OpenBot 项目，该项目旨在提供低成本的实时先进机器人技术，以激励该领域的大规模社区采用。低成本是通过大规模生产的传感器、3d 打印的身体和你自己的智能手机的结合来实现的。
我喜欢这种系统的设计。公司太专注于将他们的数据和逻辑放入云中，他们常常忘记了引入的延迟。在某些情况下，边缘设备除了读取传感器测量值并将其上传的最小处理能力之外，几乎没有任何其他处理能力。
最佳方法(对许多行业而言)是在边缘处理尽可能多的可行内容，而在其余部分求助于更强大的设备。这是为什么呢？边缘是所有活动的地方。优势就是你这么在意的消费活动。边缘是…嗯，赚钱的地方。简单地在集中式云数据处理服务之间来回铲取数据远不如在整个生态系统中分配计算工作负载那样具有可扩展性。对于除了极低功耗物联网应用之外的所有应用，您希望您的边缘设备在一次充电后运行数月，您希望您的边缘设备完成更多任务。
不太尖锐的边缘
请注意，我使用了“更强大的设备”而不是“你的云”来管理你的非边缘计算的剩余部分。您的架构不仅仅是边缘和云的二元划分。你可以拥有一个由越来越强大的设备组成的“中间件”,这些设备仍然非常接近你的第一跳边缘设备；这些设备可以为您的第一跳设备提供更多的计算能力，同时仍然允许您避免往返于您的云和。这就是智能手机在 OpenBot 架构中发挥作用的地方。
作者在其论文中制作的应用程序设置框图。
像 Tensorflow Lite 这样的努力已经在将机器学习带到边缘方面取得了长足的进步。在不久的将来，我们可能会拥有如此高效的算法和硬件，以至于对于嵌入式设备是否可以运行复杂的神经网络预测不再有第二个问题。然而，在那之前，没有什么可以阻止我们使用我们的第一跳和后端云设备之间的设备，比如我们心爱的智能手机。
在这种设置中，您可以在边缘设备上保留所有传统的嵌入式操作(主要是传感器和驱动)，同时将更多计算密集型操作(机器学习推理、状态估计和更新等)卸载到智能手机的“本地主力”上。这可能看起来是一个小步骤，但解决了两个关键问题:避免昂贵的往返到您的云，并避免您的边缘设备的缓慢/棘手的片上计算。边缘设备将智能手机视为一种快速的场外计算，而你的云服务对此一无所知(希望现在能自动缩小规模🤑).
平台注意事项
不幸的是，就目前而言，该应用程序仅适用于 Android。但是，要记住开源的妙处。假设这个项目受到社区的欢迎，我们将很快有几个额外的选择。是的，可能会创建一个 iPhone 应用程序。然而，更多的人可以胜任“本地主力”的职位。可能无非就是一个更强大的嵌入式设备(咳咳树莓 Pi 咳咳)。
OpenBot 对类似机器人项目的市场调查，由作者在他们的论文中做出。
送行
OpenBot 的新设置为机器人原型开发提供了一种新的低成本方法，进一步增加了该领域的民主化。无论是用于控制系统、边缘计算还是机器学习，这个项目必定会被整个社区广泛采用。
你打算尝试一下吗？在合作项目中，你独立完成了吗？在这里让我知道。如果有足够多的人想在某件事情上合作，我会安排一些事情！
资源
保持最新状态
除了在 Medium 上，用 LifeWithData 博客、机器学习 UTD 时事通讯和我的 Twitter 让自己保持更新。通过这些平台，我分别提供了更多的长文和简文思想。
有数据吗？我如何在几个小时内自学如何浏览网站(你也可以)
找不到任何有趣的、高质量的数据集？生成你自己的数据集出奇的容易——下面是方法(包括代码)。
从网站到数据和信息:网站:抓取本网站
我有一个可耻的秘密。它影响了数据科学社区中数量惊人的人。我懒得面对这个问题，也懒得正面解决它。
我不知道如何收集数据。
大多数时候，这并没有影响我的生活——我可以访问数据集，或者其他人已经为我的需要开发了定制的抓取器/API。
但我偶尔会浏览一个网站，希望我能获得一些有趣的原始数据来做一些严肃的分析。
嗯，不会再有了。
最近，我自学了如何用 Python 结合使用 BeautifulSoup 、 requests 和正则表达式来抓取网站。
我有一个可耻的秘密…我不知道如何收集数据。
整个过程比我想象的要简单得多，因此我能够制作自己的数据集。
所以在这里，我想分享我的经验，这样你也可以自己做。与我的其他文章一样，我在这里的 git repo 中包含了完整的代码，因此您可以按照自己的目的使用或修改代码。
在开始之前
包装
我假设您熟悉 python。即使你相对较新，这个教程也不应该太难。
你需要BeautifulSoup、requests和pandas。用pip install [PACKAGE_NAME]安装每个(在您的虚拟环境中)。
你可以在这里找到我的代码:https://github.com/databyjp/beginner_scraping
让我们制作一个数据集
一旦我们学会了如何收集数据，这种技能几乎可以应用于任何网站。但重要的是要把基本面搞对；所以让我们从容易的地方开始，同时反映现实世界。
你们很多人都知道我是一个体育迷——所以让我们从搜集我们的数字数据开始吧，这些数据将从ScrapeThisSite.com那里获得。
顾名思义，这个网站是用来练习刮痧的。假设数据在表中，也很容易检查数据是否被正确抓取。
获取原始数据
在我们做任何事情之前，我们需要原始数据。这就是requests库的用武之地。获取数据很简单，只需如下代码行:
*import* requests
page = requests.get("https://scrapethissite.com/pages/forms/")
获得网页的副本是如此容易。要检查页面是否已正确加载，请尝试:
*assert* page.status_code == 200
如果你没有得到一个错误，这应该意味着该页面已被正确下载。那有多好？现在到了肉的问题；从我们的页面获取数据。
进入你的元素
要抓取一个网站，我们需要确定网站的哪一部分包含了我们想要的信息。尽管这在视觉上很容易，但在代码中却很难做到。
在这项任务中，您最好的朋友是浏览器上的“检查元素”按钮。有不同的方法来处理要抓取的元素，但这是次要的。首先，您需要识别被抓取的数据。
例如，让我们说，我想刮这一页。
我们的第一桌给刮了(https://scrapethissite.com/pages/forms/)
在我们继续之前，先看一下底层代码。这是它的一个小样本。
页面的源代码
鉴于它是为学习刮擦的人设计的，阅读起来并不困难。尽管如此，将你在这里看到的与你所看到的渲染关联起来还是很痛苦。
您应该做的是突出显示页面上的相关元素，右键单击并选择“检查元素”。这将显示一个类似于下图的布局，尽管会因浏览器而异。
“检查元素”按钮—您的新好朋友
将要调出的代码是 DOM(文档对象模型)。不用太专业，这允许代码与呈现的最终结果相匹配。
我强烈推荐滚动浏览这里的各种元素，选择它们，并大致观察 DOM 的结构。
探索你的王国
更具体地说，让我们看看我们将做什么来刮出显示如下会议排名的表。
小步前进——收集一份数据
使用“检查元素”按钮
对元素的检查表明，我们希望获得该表的内容。尽管它没有唯一的 id，但它确实驻留在一个具有id值hockey的section中。
BeautifulSoup 发现所有这些都很容易，参数id可以被传递(html 中的id值是唯一的)，或者只是标签的一个默认参数。
我们可以通过以下方式找到所有这些:
div = soup.find(id="hockey") # Find the right div
table = div.find("table")
您可以通过运行以下命令来验证该 div 中只有一个表:
assert len(soup.find_all("table")) == 1
我们注意到该表包括标题行<th>和数据行<tr>。让我们只抓取这些行——我们还注意到这里的每个数据行都有一个值为team的class属性，所以让我们也按照这个属性进行过滤。这可以通过将它们作为字典传递来实现，允许我们根据人们定义的任何自定义属性进行过滤！
team_elm = table.find("tr", attrs={"class": "team"})
收集的元素如下所示:
如果我们想从这些乱七八糟的东西中提取出球队的名字呢？
我看到 name 列由它的class属性标记，所以我可以通过它的标签(td)和属性找到该列。
team_name = team_elm.find("td", attrs={"class": "name"}).text
但是由于结果包含大量空白:
>>> team_name
'\n Boston Bruins\n '
这是正则表达式的工作！
team_name = re.sub(r"^\s+|\s+$", "", team_name)
如果你不确定这是怎么回事，那么正则表达式将字符串的开头^空格\s+或字符串的结尾|空格不替换任何内容。如果可能会超过多行，您可以添加一个re.M标志。
太棒了。现在，我们如何扩展它来收集整个表呢？
变得舒适—抓取整个数据表
为此，我们将像以前一样识别表，隔离每一行数据，然后遍历该行以收集数据元素。
在查看元素时(参见下面的屏幕显示)，我注意到每一列都有一个带有不同data-stat属性的<td>标记，例如“wins”、“loss”、“win_loss_pct”等。
调查每个要刮除的列
我们可以对它们进行硬编码，并手动遍历它们。但是，更有趣的方法是实际获取一行，并生成这些列属性的列表，如下所示。
stat_keys = [col.attrs["class"][0] for col in data_rows[0].find_all("td")]
这为我们提供了一个值列表:
['name', 'year', 'wins', 'losses', 'ot-losses', 'pct', 'gf', 'ga', 'diff']
使用这个代码片段，我们只需编写几行代码来执行获取数据的任务。在较高层次上，代码循环遍历行，确保该行不是标题行，循环遍历列，将数据收集到一个字典中，并将其整理到一个列表中。
整个结果数据然后被放入熊猫数据框架。
这应该是相对清楚的，但如果这没有什么意义，那也没关系。相反，看看下面的代码。实际代码非常简洁，几乎比我的描述还要短！
重复该任务—抓取多个页面
让我们通过从多个页面抓取数据来总结这一点。你可能已经注意到了底部各个页面的链接。
再一次，看看这个元素——根据我们的发现，我们可以决定我们的策略。
检查底部分页栏
我们可以用多种方法中的一种来处理这个问题，但是这一次，我们将抓取这里的每个链接，然后抓取每个结果页面。
我选择的方法是用 class 属性值为pagination的ul标记元素。然后，我找到每个li元素，获取 href 目标(即链接)，然后通过一个集合转换它以删除任何重复的内容。
pagination = soup.find("ul", attrs={"class": "pagination"})
link_elms = pagination.find_all("li")
links = [link_elm.find("a").attrs["href"] for link_elm in link_elms]
links = list(set(links))
直截了当，不是吗？
我们现在需要做的就是创建一个函数来概括我们抓取上面页面的任务，并连接每个页面返回的结果。
temp_dfs = list()
for link in links:
tmp_df = scrape_this(uri=link)
temp_dfs.append(tmp_df)
hockey_team_df = pd.concat(temp_dfs, axis=0).reset_index(drop=True)
为了更好地衡量，我们可以对结果进行排序，并将它们保存为一个文件:
hockey_team_df.sort_values(["year", "name"], inplace=True)
hockey_team_df.to_csv("hockey_team_df.csv")
综上所述，我们得到:
就是这样！只需几行代码，我们就可以从这个网站上收集几十年的数据来生成我们自己的数据集。
只是为了检查一下，让我们用和绘制一些数据，看看胜率和一些不同指标之间的相关性。需要注意的一点是，在操作下载的页面之前，我们需要转换数据帧中的数据类型！
为什么？嗯，你可能已经知道了——或多或少所有的网站数据都是以文本形式呈现的。文本，即使是数字，也不能被操纵。因此，举例来说，需要对成功进行操作，以便:
hockey_team_df.wins = hockey_team_df.wins.astype(int)
一些可视化库会在内部进行这种转换，但是如果你在 pandas 中操作数据，你肯定需要这样做。
(这里我不会展示完整的代码，但它在我的GitHub repo—scraper_mult_pages.py文件中。)
这是一张图表，对比了本赛季的胜率和进球数:
关联得分目标与获胜百分比
这并不可怕，但看起来没有那么大的相关性。允许进球(对手进球)呢？
关联允许的目标与成功百分比
那更好！也许防守确实能赢得冠军/比赛。我们可以将这两者结合起来看目标差异:
将目标差异与成功百分比相关联
哇哦。如果我自己这么说，这有什么关系。
这不是很棒吗？嗯，我觉得是。你可能对这些特定的数据不感兴趣，但关键是——你现在也拥有了所有你需要的工具来获取你感兴趣的数据。
我希望那是有用的。我很高兴我费心去学习如何做到这一点。
当你认真对待它的时候，你会发现还有很多事情要做——使用像 selenium 这样的包对某些网站来说可能是必要的，而像 scrapy 这样功能更全面的框架可能会为你的大项目节省时间。但是通过采用这些技术，我们已经可以做很多事情了。
来吧——试试看！
有一点要注意:我用过的这个网站明确允许抓取，但不是每个人都允许。网络抓取一直是一个有点争议的话题，最近的一个案例甚至上了法庭。一如既往，明智并尊重他人的网站和潜在的知识产权。
你可以在这里了解更多:https://www.scraperapi.com/blog/is-web-scraping-legal/
但是在你离开之前——如果你喜欢这个，请在 twitte 上打个招呼/关注，或者关注这里的更新。ICYMI:我也写过这篇关于可视化隐藏信息的文章，以 NBA 助攻数据为例:
[## 如何用 Python 可视化数据中的隐藏关系 NBA 助攻分析
使用交互式快照、气泡图和桑基图操纵和可视化数据，使用 Plotly(代码和数据…
towardsdatascience.com](/how-to-visualize-hidden-relationships-in-data-with-python-analysing-nba-assists-e480de59db50)
最近，这个展示了我在互联网上发现的一些令人惊叹的数据科学投资组合。
[## 这些数据科学产品组合将让您惊叹不已并深受启发(2020 年中期版)
使用这些来改进您自己的数据科学产品组合，学习新技能或发现新的有趣项目。
towardsdatascience.com](/these-data-science-portfolios-will-awe-and-inspire-you-mid-2020-edition-728e1021f60)
有写作障碍吗？是 GPT 2 号来救援了！
使用人工智能创造不存在的书的情节概要…还没有。
故事图片说明基于 alexkerhead CC 2.0 的一张照片
在这篇文章中，我将向你展示如何使用人工智能(AI)和机器学习(ML)来帮助你开始写你一直想写的小说。我将从计算机如何使用人工智能处理文本的简单背景开始。然后，我将描述我如何建立一个名为 GPT-2 的 ML 模型来生成新的情节概要，并就如何为自己创造一些新的故事想法给出指导。
这是我关于如何将人工智能用于创造性努力的系列文章的第二部分。第一部分是关于如何使用 ML 来创造抽象艺术，这里有的。
背景
自然语言处理
自然语言处理(NLP)是语言学和计算机科学的一个领域，它研究具有 Java 和 Python 等计算机语言的机器如何与具有英语和斯瓦希里语等自然语言的人类进行交流。艾伦·图灵是教计算机理解人类语言的第一批支持者之一。他在 1950 年写了关于它的文章。
我们可能希望机器最终能在所有纯智力领域与人类竞争。但是哪些是最好的开始呢？即使这是一个艰难的决定。许多人认为像下棋这样非常抽象的活动是最好的。还可以维护的是，最好给机器提供钱能买到的最好的感觉器官，然后教它理解和说英语。艾伦·图灵，数学家和计算机科学家
文本到令牌
处理文本的第一步是将单词转换成数字。这个过程叫做标记化。对文本进行标记的最简单方法之一是，按照输入序列中出现的顺序，简单地为唯一的单词和标点符号分配一个数值。例如，想想《双城记》的第一句开场白。
标记文本
您可以看到，单词“was”、“the”、“of”和“times”中的四个出现了两次，并且它们在两个实例中获得了相同的令牌值。在这个方案中，像“it”这样的大写单词与小写的“It”有不同的标记。此外，标点符号，像逗号，得到自己的令牌。你可以在 Srinivas Chakravarthy 的帖子中阅读各种标记化方案。
变形金刚(电影名)
一旦单词被标记化，它们就可以被机器学习系统处理来完成各种任务。例如，可以训练 ML 模型将文本从一种语言翻译成另一种语言。在下面的例子中，一个转换器被训练成从英语翻译成西班牙语。
使用转换器进行语言翻译
输入的英文文本在输入到转换器之前被转换成标记。在转换器内部，令牌被编码成内部的“通用”形式，然后解码成西班牙语令牌，再转换成西班牙语单词。想了解更多关于变形金刚的信息，请看马克西姆·阿拉德的帖子。
GPT-2
2018 年，OpenAI 创建了一个名为生成式预训练变压器(GPT)的系统[2]。他们解释说，NLP 任务的巨大收益…
…可以通过对不同的未标记文本语料库进行语言模型的生成性预训练，然后对每个特定任务进行有区别的微调来实现。— 亚历克·拉德福德和 OpenAI 的同事们
来自 OpenAI 的团队在 2019 年创造了一个名为 GPT-2 的改进版变压器[3]。在这篇论文中，他们说…
…具有足够能力的语言模型将开始学习推断和执行自然语言序列中展示的任务，以便更好地预测它们，而不管它们的采购方法如何。来自 OpenAI 的亚历克·拉德福德及其同事
下图显示了 GPT-2 的主要组成部分。GPT-2 没有使用单一值的令牌，而是使用单词嵌入，即多个数字的数组来表示每个单词。这使系统有能力捕捉对单词更完整的理解。
GPT-2 组件
GPT 新协议模式分为三个阶段:
- 初始训练——学习理解一般语言
- 微调—学习执行特定任务
- 提示—启动系统开始生成输出文本
请注意，该模型在生成文本时利用了所有三个阶段的输入。你可以在杰伊·阿拉玛的帖子中阅读更多关于 GPT-2 如何工作的信息。
情节混乱
PlotJam 是我创建的一个系统，用来帮助有创造力的作家发现新的故事。PlotJam 使用 GPT-2 模型，该模型根据超过 16，000 本英文书的标题和情节摘要进行了微调，创建了带有标题和简短情节摘要的新故事。这是一个显示主要组件的图表。
PlotJam 组件
准备文本以进行微调
微调文本的来源是来自卡内基梅隆大学的图书摘要数据集。我通过分离每本书的类型、标题和第一部分情节概要来准备数据。
以下是其中一本书的原始数据示例:
**Wikipedia ID** 1166383
**Freebase ID** /m/04cvx9
**Book title** White Noise
**Book author** Don DeLillo
**Publication date** 1985-01-21
**Genres** Novel, Postmodernism, Speculative fiction, Fiction
**Plot summary**
Set at a bucolic Midwestern college known only as The-College-on-the-Hill, White Noise follows a year in the life of Jack Gladney, a professor who has made his name by pioneering the field of Hitler Studies (though he hasn’t taken German language lessons until this year). He has been married five times to four women and has a brood of children and stepchildren (Heinrich, Denise, Steffie, Wilder) with his current wife, Babette. Jack and Babette are both extremely afraid of death; they frequently wonder which of them will be the first to die. The first part of White Noise, called "Waves and Radiation," is a chronicle of contemporary family. ...
下面是预处理书籍摘要的 Python 代码。
对文本进行预处理的代码
这是预处理后的 CMU 书籍摘要数据集中的一个条目。
**GENRE:** Novel, Postmodernism, Speculative fiction, Fiction **TITLE:** White Noise **PLOT:** Set at a bucolic Midwestern college known only as The-College-on-the-Hill, White Noise follows a year in the life of Jack Gladney, a professor who has made his name by pioneering the field of Hitler Studies (though he hasn't taken German language lessons until this year). He has been married five ...
训练模型
在书摘要文本被预处理之后，我用它来微调 GPT-2 模型。我运行了 10，000 步的微调，这似乎足够系统生成新的情节摘要。下面是源代码:
代码训练模型
生成图
模型微调后，可以通过调用 generate 函数来创建新的图。我传入一个提示“流派:”来指示系统创建一个随机流派的故事的标题和情节。
生成新图的代码
以下是输出，显示了由 GPT-2 合成的新图:
**GENRE**: Mystery **TITLE**: Deadright’s Corner **PLOT**: The novel’s protagonist is Edward Wells, a young policeman who is given the job of turning around the case of a manslaughter in which a man killed his wife’s valet – the killing was clearly premeditated – after which he is induced to investigate the matter further. It is during this investigation that Wells discovers the terms of a secret contract between the police and a deceased man's ...
好的。在这里。第一个新故事。它属于神秘类型，标题是“死亡之角”。而且好像是一个以年轻警察为主角的犯罪故事。还不错。
检查原创性
GPT-2 系统被设计成以用于微调的数据的风格“开始写”。当以前缀“流派:”提示时，它将选择它在微调中看到的流派之一，然后创建一个标题和一个简短的情节概要。但是，不能保证它总能创造出新的标题和独特的情节。有时它选择一个现有的标题，它可能会也可能不会想出一个类似于已发表作品的情节。
我通过对结果进行后处理来过滤掉明显重复的故事，看看标题是否独特。我在 CMU 数据集中查找以前用过的书名，也在书评网站 Goodreads 和 IMDB 数据库中查找电影和电视节目的书名。下图显示了这三个数据集中的图书数量。
文氏标题图
您可以看到，与 CMU 数据集和 Goodreads 相比，IMDB 数据库有一个庞大的书目列表。下面是一个代码片段，展示了我如何累积标题列表以用于重复检查。
代码积累大量现有标题
请注意，我从标题的开头删除了冠词“the”和“A”。如果 GPT-2 想出的标题是“了不起的盖茨比”，我们会认为这是一个骗局，并将其过滤掉。此外，请注意，标题列表并不详尽。有很多出版的书籍没有维基百科页面，没有 Goodreads 上的评论，或者被拍成了电影或电视剧。因此，如果你看到一个你喜欢的故事情节，请在写作之前先做一点研究，以确保它确实是独一无二的。
不要重复自己。不要重复自己。
有时，GPT-2 文本生成器会卡在一个特定的短语上，并在情节摘要中重复多次。在这个例子中你可以看到一些重复。
**GENRE**: Science Fiction **TITLE**: Baseline Behavior **PLOT**: In the preface, Guy Sager explains his term for the branch of psychology that emphasizes **the individual’s sense of themselves** vs. the collective and their social relations. He believes that **the individual’s sense of themselves** can be affected by the environment (via the “environment in which they find themselves”). In other words, **the individual’s sense of themselves** can be saved by the environment (via their …
注意短语“个人对自己的感觉”是如何被重复三次的。我写了一个小函数，寻找这个工件来过滤掉有重复的条目。这是 Python 代码。
检查重复短语的代码
如果函数在输入中一次或多次看到给定长度的短语，它会被标记为重复。我用短语长度五来过滤掉重复的情节概要。
在 Google Colab 中生成新故事
以下是运行 PlotJam 的说明。它作为一个谷歌实验室运行，这是一个使用高端 GPU 进行人工智能实验的免费服务。请注意，有一个谷歌帐户是必需的。
使用 GPT-2 创建新的情节提要
colab.research.google.com](https://colab.research.google.com/github/robgon-art/PlotJam/blob/master/PlotJam_Sampling.ipynb)
- 点击上面的链接。
- 登录您的谷歌账户，如果您尚未登录，请点击。
- 单击第一个运行单元格按钮(悬停在[ ]图标上并单击播放按钮)。将出现一条警告，指出此笔记本不是由 Google 创建的。
- 点击无论如何都要运行初始化系统。下载数据集和配置预训练的 GPT-2 模型大约需要 5 分钟。
- 选择你想尝试的类型，点击第二个运行单元按钮，生成一些新的故事情节。
- 选择一个你喜欢的故事，点击第三个运行单元按钮，生成所选故事情节的五个变体。
PlotJam Google Colab
你可以看到每个情节变化都以相同的类型和标题开始，但在情节概要如何展开方面有所不同。
未来的工作
PlotJam 系统基于 GPT-2 的“大型”模型。这个模型有 7.74 亿个参数，运行在 Google Colab 系统上。未来的工作将是使用具有 16 亿个参数的“超大”模型，这可能会有更好的结果。OpenAI 最近发布了他们的 GPT-3 模型的测试版，他们声称该模型有 1750 亿个参数。这可能会在创建情节概要方面做得更好。
感谢
我要感谢詹尼弗·林对这个项目的帮助和反馈。
源代码
这个项目的所有源代码都可以在 GitHub 上找到。这些源代码在 CC BY-NC-SA 许可下发布。
归属共享
参考
[1] A. M .图灵，《计算机器与智能》头脑。1950 年 10 月，49:433–460
[2] A .拉德福德，k .纳拉西姆汉，t .萨利曼斯，I .苏茨基弗，《通过生成性预训练提高语言理解》，2018 年 6 月
[3] A .、j .吴、r .蔡尔德、d .栾、d .阿莫代伊和 I .苏茨基弗。“语言模型是无监督的多任务学习者”，2019 年 2 月
附录 A:样本输出
这里有一些来自 PlotJam 的“精选”样本。
**GENRE**: Historical fiction, Historical novel **TITLE**: Banner in the Storm **PLOT**: The story begins with Bertie finding himself at sea with the second Continental Spice Company. The story follows him as he joins the company, and encounters some of the Continental crew, including Captain Harvey Hatcher, a former Ballista, and Professor Appleby, who has joined the company to search for the Northwest Passage. Hatcher and Appleby have a small sailboat that is quite beat up. They set out to sea in a stormy sea with a group of American and ...**GENRE**: Science Fiction **TITLE**: Faso **PLOT**: The novel opens in a post-apocalyptic Southern California, in a hellish world shattered by nuclear war decades before. Fifteen-year-old Alex Hunter and his ten-year-old friend Sean Collins go to visit a mysterious old building called the Basement. The Basement is an old bunker owned by the U.S. military that is filled with ancient artifacts and military technology. Alex and Sean are separated as they are pursued by a horde of evil ...**GENRE**: Crime Fiction **TITLE**: Physical Damage **PLOT**: The police report finding a bloody scene of apparent murder, but do not find any suspects. The case becomes more complicated when two bodies are found wearing the same cologne and gloves. The case becomes more personal for Detective Chief Inspector Alan Banks when he is called to a murder scene by two of his colleagues, both of whom are lying in their own ...
为了无限制地访问 Medium 上的所有文章，成为会员，每月支付 5 美元。非会员每月只能看三个锁定的故事。
抓住你了。递归全局变量
注意参数顺序和返回值
安德里亚·费拉里奥在 Unsplash 拍摄的照片
我用回溯法解决了这个 leetcode 问题https://leet code . com/contest/weekly-contest-212/problems/path-with-minimum-effort/，花了一些时间调试奇怪的输出。本文讨论了对全局变量使用递归时的一些陷阱，如何处理它们，以及如何将代码从全局改为局部。
免责声明:回溯只通过 15/75 的测试用例，其余的超过了时间限制，本文的目的是强调全局变量的可能问题，而不是给出最佳解决方案。更多使用二分搜索法、迪克斯特拉和克鲁斯卡尔的美丽解决方案，请观看亚历克斯在 https://www.youtube.com/watch?v=AM__3Zx1XNw 的演练(从 7:26 开始)
问题
问题是从左上走到右下，每走一步允许上、下、左、右四个方向，然后用最小的努力找到路径。effort定义为任意两个连续方块之间数值的最大绝对差值。
包含具有全局与非全局变量的实现的笔记本:https://gist . github . com/git Han/a 818d 336 c 2309852 a 21d 99 EFD 619238d
回溯概述
我的回溯解决方案是使用一个visited 2D 数组来跟踪访问。
从左上角的单元开始，如果在矩形边界内并且之前没有被访问过，我们尝试以向下、向右、向上、向左的顺序移动(该顺序比其他一些顺序更快地到达目的地，因此全局最小值可以更早地被更新，并且用于限制/加速未来路径的探索)。在移动(递归)之前，访问被标记，因此对于if valid()，将来的访问尝试将返回 False。
在此过程中，使用我们要访问的单元和当前单元之间的 abs 差来更新路径的努力(初始化为 0)。如果我们到达基本情况(右下角的单元格)，返回努力。
一旦一个方向的递归完成，我们就更新全局最小值min_effort(初始化为math.inf)并取消该方向的单元格标记。
一旦当前单元格的所有 4 个方向都完成，我们返回math.inf备份调用堆栈，这样它就不会错误地影响调用者的 min()。
病菌
这个 5 ^ 2，后面跟着 2 个 inf 的输出令人难以置信。看起来像是全局变量min_effort在第一个解(1，下到 3，下到 5，右到 3，右到 5)回到 inf 后从 inf 更新到 2！最终答案(路径 1，2，3，4，5)也被错误地推断，而不是 1。
这五个 2 对应于从目的地 5 回溯到 4，3，2，8，3，5 的算法，因为所有这些都具有所有 4 个已访问或出界的方向，所以下一个要尝试的路径是从 1，0 向右到 1，1 (3 到 8)。
全局变量如何回到未更新的状态？
问题出在第min_effort = min(min_effort,find_path(...))
行，因为 python 从左到右计算参数，在进入递归之前已经计算了全局变量min_effort，所以递归中发生的任何事情(包括对全局变量的更新)对min_effort都没有影响。
在网格底部中间的 3 的范围内，算法还没有找到成功的路径(第一条路径是 1，3，5，3，5)，所以此时min_effort还是math.inf，而min(math.inf,math.inf)变成了 inf。
3 个修复
- 交换参数
一种解决方法是简单地将参数的顺序换成min_effort = min(find_path(...), min_effort)。这使得递归有机会在比较之前先更新全局变量。
2.先存成变量
如果您仍然希望优先保持旧的顺序，可以先计算递归并保存到变量中。
recursion_res = find_path(...)
min_effort = min(min_effort, recursion_res)
3.完全删除全局变量
这是由于 Leetcode 在运行所有测试用例时给出了错误的测试结果，但是作为定制输入单独运行失败的用例给出了正确的结果。如果您坚持在 leetcode 上使用全局变量，那么复制结果，清除全局变量，并返回复制的结果，以便清除的全局变量为下一个测试用例做好准备。
两个变化:
1。将之前的全局变量添加到递归函数签名中find_path(...,min_effort)
2.返回min_effort而不是math.inf
这将确保最小努力路径总是通过递归调用传播。如果你问为什么在使用全局变量时不返回min_effort,这也是可行的，但是没有必要，因为如果你避免了上面提到的问题，在min(min_effort,find_path(...))比较之前，min_effort将被更新为非 inf 值，所以即使第二个参数返回 math.inf，一旦任何路径首先到达目的地，第一个参数将总是被更新为正确的值。另外，math.inf更能代表“无解/不好的价值”。
然而，支持return min_effort而不是return math.inf的理由是它更准确地代表了最新的程序状态。此外，我们可以完全避免 gotcha 处理(前面描述的两个修复),直接使用min(min_effort,find_path(...)),因为有了return min_effort,第二个参数将总是被更新，所以在第一个参数中包含其初始化的math.inf的“预递归求值”min_effort不会造成任何伤害。(与上一段完全相反的情况)。
改进解决方案
因为我们正在寻找全局最小值，所以任何路径都可能受到任何其他路径的结果的影响。这为当前最佳结果提供了一个机会，一旦发现它们比当前min_effort具有更长的努力，就短路未来路径。这可以通过用额外的检查if updated_effort < min_effort:包装回溯部分(visit，recurse，unvisit)来实现，以大大减少探索步骤，使用“小于”,因为尝试不会减少当前最佳结果的东西是没有意义的。
if updated_effort < min_effort:
visited[row,col] = 1
min_effort = min(min_effort,find_path(heights_arr,visited,row,col,updated_effort,max_row,max_col))
visited[row,col] = 0
全球与本地比较
全球优势:
- 允许的宽松返回值(
math.inf或min_effort) - 方便的编码(更少的参数传递和更简单的递归函数)
全局不利因素:
- 不要使用在线编码平台(对工作面试自动编码评估有风险)
- 必须时刻注意不在当前堆栈中的副作用和变量
- 对函数参数排序敏感(所有这些问题的根源)
本地优点:
- 专注于局部问题空间的更容易的调试/跟踪
- 副作用更少
当地不利因素:
- 更详细的函数签名(要跟踪的项目越多，意味着签名越长)
- 失去返回
math.inf的能力，必须返回min_effort以将更新的结果传播回程序的其余部分
做错比做对更有价值
当使用全局变量时，如果我最初使用上面的 fix 2 返回了min_effort或正确编码，我根本不会看到这个问题。塞翁失马，焉知非福，返回最直观的正确值和对(可能)无关变量赋值的懒惰让我加强了对 python 求值顺序和调试技巧的理解。
必须把它们分类
我如何建立一个分类模型来区分传奇和非传奇的神奇宝贝
当我还是个孩子的时候，我对神奇宝贝很着迷。我每天下午放学后都会看这个节目，周六早上早早醒来看更多的节目，收集卡片，当然，还会在我的游戏机上玩游戏。通常，我和我的朋友会出去玩，在我们各自的设备上玩游戏，互相帮助在广阔的地区导航，捕捉每个游戏中介绍的独特的神奇宝贝。对于其中的一个游戏《神奇宝贝蓝宝石》(我个人最喜欢的)，我甚至买了一本指南书，在我一个城市一个城市、一个健身房一个健身房地行进时帮助我，告诉我关于这个游戏的秘密。不用说，在我年轻的时候，神奇宝贝是我生活中很重要的一部分。然而，不幸的是，随着年龄的增长，神奇宝贝在我的生活中几乎不存在了，除了偶尔出现在我最喜欢的消遣中。
去年冬天，我完成了一次数据科学训练营。在训练营期间，我们会被分配一些项目，在这些项目中，我们必须找到自己的数据用于分析和强化各种数据科学概念。做了一些关于体育的项目，并且知道我正在为我的最终项目保存音乐数据，我思考我想为我的分类项目做些什么。在花了一些时间思考想法并尝试跳出框框思考后，我过去对神奇宝贝的喜爱浮现在脑海中，成为一个分类模型可能建立的基础。虽然我最初对尝试按神奇宝贝的类型进行分类感兴趣，但很明显，由于类型的数量庞大以及每种类型的神奇宝贝比例不平衡，我决定将它们分类为传奇与非传奇是我要走的路线。
我是这样做的:
数据
对于这个项目，我最终从三个不同的来源获得了我的神奇宝贝数据，以满足我的分类需求。我使用了 BeautifulSoup 和Pandas read _ html函数从下面的站点中抓取数据。
- 神奇宝贝数据库 —全部 8 代神奇宝贝的完整神奇宝贝指标(最终仅使用 1-7 代)，具有类型、总量、HP、攻击、防御、特殊攻击、特殊防御和速度等特征(最终未使用类型或总量)
- 神奇宝贝 API——使用官方神奇宝贝 API 获得每个神奇宝贝的身高和体重，作为我认为重要的附加功能
- sere bii——在这里获得新的神奇宝贝 API 中没有的高度和重量，在这里获得传奇神奇宝贝的列表用于标记目的 (0 =非传奇，1 =传奇)
用于分类模型的数据帧部分
总的来说，我看了:
809 个独特的神奇宝贝(第 1-7 代)，其中 80 个被认为是传奇
特性:HP，攻击，防御，特殊攻击，特殊防御，速度，身高，体重
探索性数据分析
1。神奇宝贝功能相关热图:
2。显示非传奇与传奇神奇宝贝所有特征分布的重叠直方图:
正如我们所见，特殊攻击、特殊防御、身高和体重是与传奇属性相关性最高的四个特征，也是非传奇和传奇神奇宝贝之间分布的最大间隔。
建模
1.为设置 x 和 y 变量，其中传奇系列为 y 变量，其余特征的数据帧为 x 变量
2.使用 SMOTE (合成少数过采样技术)合成虚假数据，原因是传奇与非传奇神奇宝贝中的等级不平衡，因为数据中只有约 10%的神奇宝贝是传奇
3.尝试了不同的模型，看看哪种效果最好:
# Created list of different classifiers/models I wanted to runclassifiers = []model1 = xgboost.XGBClassifier()
classifiers.append(model1)model2 = svm.SVC()
classifiers.append(model2)model3 = tree.DecisionTreeClassifier()
classifiers.append(model3)model4 = RandomForestClassifier()
classifiers.append(model4)# Fit each model with synthesized training data; found accuracy, precision, recall, and F1 score; printed out confusion matrix and classification reportfor clf in classifiers:
clf.fit(X_synth, y_synth)
y_pred= clf.predict(X_test)
acc = accuracy_score(y_test, y_pred)
prec = precision_score(y_test, y_pred)
recall = recall_score(y_test, y_pred)
f1 = f1_score(y_test, y_pred)
print("Accuracy of %s is %s"%(clf, acc))
print("Precision of %s is %s"%(clf, prec))
print("Recall of %s is %s"%(clf, recall))
print("F1 Score of %s is %s"%(clf, f1))
cm = confusion_matrix(y_test, y_pred)
print(cm)
print(classification_report(y_test, y_pred)) # Code above originally seen in this Medium story on [Choosing the Best Algorithm for your Classification Model](https://medium.com/datadriveninvestor/choosing-the-best-algorithm-for-your-classification-model-7c632c78f38f)
4.在最佳模型上运行【GridSearchCV】，在这种情况下是 SVM(支持向量机)，以便找到模型的最佳参数****
最优参数为:C = 1000，核= rbf(径向基函数)
最终模型总体显示 97%的准确性
尽管回忆在最终模型中失败了，但我对此没意见，因为:**
最终，我得到了一个非常准确的传奇与非传奇神奇宝贝分类模型。在深入研究了哪些神奇宝贝被错误分类后，很明显，这更多是因为这些神奇宝贝与相反类别的神奇宝贝相似(传奇而非非传奇，反之亦然)，而不是模型本身的错。
做这个项目非常怀旧，让我怀念我作为一名神奇宝贝训练师试图“抓住它们”的日子。“由于世界的现状和我们所处的隔离状态，我最终买了一台任天堂 Switch Lite 和最新的神奇宝贝游戏神奇宝贝剑，重温美好时光来打发时间。即使过了这么多年，如果我自己这么说的话，我也没有失去一步。**
如果你有兴趣看我项目的完整代码，可以在我的 GitHub 上查看！
必须全部模拟——口袋妖怪
模拟第 1 代的口袋妖怪战斗来识别等级
我们中的许多人都是在这个系列的各种迭代中玩口袋妖怪长大的。我十岁的时候，美国出了第一代(红蓝)口袋妖怪。我花了无数个小时和我的朋友玩那个游戏。2018 年，我偶然看到 PyData 的一个演讲，“ Vincent Warmerdam:用简单甚至线性的模型取胜| PyData London 2018 ”，其中提到获取口袋妖怪数据是多么容易。这个演讲并没有把重点放在口袋妖怪战斗模拟上，尽管它启发了我，让我创建了一个口袋妖怪战斗模拟器，并写了这篇文章。
在本文中，我将讨论:
- 这种实现的局限性
- 数据收集过程
- 模拟器中使用的算法
- 我对口袋妖怪的排名
注:如果您想查看所有源代码，请在github.com/tylerwmarrs/pokemon-battle-simulation找到。
实施限制
虽然我试图捕捉游戏中的大部分战斗机制，但有些机制被遗漏了。
- 诸如瘫痪、中毒等疾病被排除在外，以简化战斗。
- 口袋妖怪不可能恢复健康。
- 战斗由口袋妖怪通过升级学习的破坏性能力组成。
- 攻击机制可以通过排列效率来改进，而不是随机选择。
这些限制可能会影响一些口袋妖怪的行列。我强烈鼓励任何感兴趣的人通过对资源库做出贡献来实现缺失的细节。
数据收集
数据收集过程没有痛苦。一个网站为我提供了我需要的关于口袋妖怪的大部分信息。网站pokeapi.co，以 JSON 格式提供开放的 API 结果。网站的文档相当全面。获得口袋妖怪属性和涉及的移动:
- 从红色/蓝色版本中识别口袋妖怪
- 对于每个口袋妖怪，下载属性
- 识别红色/蓝色版本的移动
- 对于每次移动，下载属性
一旦下载了所有的动作和口袋妖怪，我就使用熊猫连接将动作映射到每个口袋妖怪。
数据转换
与 JSON 相比，我更喜欢使用 CSV 文件，所以我花了一些时间来简化模拟战斗所需的属性结构。JSON 结构由可选属性组成，嵌套很多层。展平属性使得查询变得更加容易。
口袋妖怪属性
- 名称——口袋妖怪的名称
- 惠普—健康点
- 攻击—一般攻击统计
- 速度——速度是用于计算伤害的统计数据
- 特殊攻击—特殊攻击统计
- 防御——统计数据，用于确定对常规攻击造成的损害
- 特殊防御——用于确定针对特殊攻击的损害的统计数据
- 类型——口袋妖怪的类型；火、水、岩石等。
移动属性
- 名称—移动的名称
- PP-可以应用移动的次数
- 类型—移动的类型；火、正常、水等。
- 暴击率——调整招式暴击几率的标志
- 功率-功率是一种用于计算伤害的统计数据
- min _ hits——在给定回合中，移动的最小次数。
- max _ hits——在给定回合中，移动可以应用的最大次数。
损坏计算
类型修饰符
除了招式和口袋妖怪，我还需要获得数据来帮助量化伤害。口袋妖怪是一个回合制游戏，玩家选择一个动作来应用。这个模拟只关注计算伤害的攻击动作。每个口袋妖怪都是特定的类型，每次攻击也是如此。目标是要么打败对方的口袋妖怪，要么捕获它。这个模拟只捕捉胜利和失败。如果受到攻击，可能会造成更大的伤害:
- 攻击型口袋妖怪
- 攻击的类型
- 保卫口袋妖怪类型
口袋妖怪的类型修改器图表
该表显示了攻击伤害如何适用于给定的口袋妖怪类型。我是从这个网站用回来的，清理过了。该表捕获默认类型修饰符值为 1 的异常。
临界机会算法
基于随机数生成器的临界机会算法取决于攻击。有些攻击比其他攻击更容易致命一击。我从这个网站获得了公式，并移除了游戏实现中的一些瑕疵。
几个明显的缺陷包括:
- 最初的游戏规则是 100%的临界几率；然而，实现的结果是最高 99.6%。我的实现允许 100%的临界几率。
- 一些助推技能在应该增加致命几率的时候降低了致命几率。然而，在这个模拟中，助推移动被完全忽略。
该算法采用口袋妖怪的基本速度和攻击的临界几率来确定是否发生了临界击中。口袋妖怪的速度是决定成败的一个重要因素。
损坏算法
给定口袋妖怪属性和来自暴击算法的暴击布尔，伤害算法决定应用多少伤害。这些算法都是从这个网站上的公式推导出来的。
战斗模拟
选择移动算法
根据攻击口袋妖怪的招式列表，随机选择一个有灵能点剩余的招式。当所有移动都用尽时，返回 null。这是在两个口袋妖怪会打成平手的情况下需要的；否则，apply_move 算法中会出现无限循环。
应用移动算法
该算法管理:
- 临界机会随机化
- 同类攻击奖励(一个火口袋妖怪使用火招)
- 攻击口袋妖怪的灵能点(PP)
- 保卫口袋妖怪的生命值(HP)
- 应该应用移动的次数
注意这个函数有一个硬编码的等级值 10，这可能会影响伤害的计算。
战斗算法
战斗算法跟踪模拟状态:
- 随机选择可能首先攻击的口袋妖怪
- 轮到哪个口袋妖怪了
- 寻找赢家
- 检查领带
战例
这是一个皮卡丘对抗鬼斯的战斗的例子。
pikachu = Pokemon('pikachu')
gastly = Pokemon('gastly')
battle(pikachu, gastly)Output
------
gastly damaged pikachu with night-shade for 2.0 hp
gastly pp for night-shade is 14/15
pikachu hp is 33.0/35
pikachu damaged gastly with thunder-shock for 10.0 hp
pikachu pp for thunder-shock is 29/30
gastly hp is 20.0/30
gastly damaged pikachu with dream-eater for 22.0 hp
gastly pp for dream-eater is 14/15
pikachu hp is 11.0/35
pikachu damaged gastly with thunder-shock for 11.0 hp
pikachu pp for thunder-shock is 28/30
gastly hp is 9.0/30
gastly damaged pikachu with lick for 6.0 hp
gastly pp for lick is 29/30
pikachu hp is 5.0/35
pikachu damaged gastly with thunder-shock for 10.0 hp
pikachu pp for thunder-shock is 27/30
gastly hp is -1.0/30{'pokemon': 'pikachu',
'pokemonb': 'gastly',
'moves': 6,
'winner': 'pikachu',
'first_attack': 'gastly'}
口袋妖怪排名
随着战斗算法的完成，我创建了一些逻辑来模拟所有口袋妖怪之间至少包含一个破坏性动作的战斗 1000 次。同种的口袋妖怪被排除在战斗之外。比如皮卡丘大战皮卡丘就不是模拟的。在每场战斗开始时，每只口袋妖怪被随机分配最多四种伤害能力。结果被记录在每对口袋妖怪之间，跟踪谁输了，谁赢了，以及平局的数量。单个口袋妖怪战斗 14.6 万次。
随着统计数据的汇总，我以两种方式对口袋妖怪进行了排名:
- 贝叶斯排名 —先验被设定为 50/50 几率
- 百分比排名
下面根据贝叶斯排名显示的前 20 名口袋妖怪，Mewtwo 排名第一似乎是合乎逻辑的。Mewtwo 被认为是第一代中最好的口袋妖怪，具有使它如此的属性。它也是最稀有的口袋妖怪之一。
倒数 20 名口袋妖怪似乎也合乎逻辑，因为鲤鱼王是最后一名。鲤鱼王在比赛中的防守和进攻都是最差的。
完整的排名列表，请访问此链接。
包扎
虽然我对口袋妖怪战斗的实现是有限的，但结果似乎是合乎逻辑的。希望，我已经激励了另一个口袋妖怪迷去接受这些概念，这样他们可以在他们的模拟中应用它们。模拟和建模是一项非常重要的技能。将它应用到您熟悉的东西上，可以使建模过程更易于管理。
如果你觉得这本书有趣，请花时间评论它。
GPT-3 101:简介
在过去的几周里，几乎不可能避免对 GPT-3 的大肆宣传。本文简要介绍了它的架构、已经可用的用例，以及关于它的伦理和绿色 IT 含义的一些想法。
照片来自https://unsplash.com/@franckinjapan
介绍
让我们从基础开始。GPT-3 代表生成式预训练变压器版本 3，它是一个序列转导模型。简单来说，序列转导是一种将输入序列转化为输出序列的技术。
GPT-3 是一种语言模型，这意味着，使用序列转导，它可以预测给定输入序列的输出序列的可能性。例如，这可以用来预测在给定的文本序列中哪个单词最有意义。
这些模型如何工作的一个非常简单的例子如下所示:
输入 :这是一个晴朗炎热的夏日，所以我打算去……
预测输出 :这是一个晴朗炎热的夏日，我正打算去海滩。
GPT-3 基于一种称为 Transformer 的特定神经网络架构类型，简而言之，它比 RNNs(递归神经网络)等其他架构更有效。这篇文章很好地解释了不同的架构，以及序列转换如何从 GPT-3 使用的变压器架构中获益。
Transformer 架构并不新鲜，因为它们在两年前变得非常流行，因为 Google 将它们用于另一个非常著名的语言模型， BERT 。它们也在 OpenAI 的 GPT 的早期版本中使用。那么，GPT 3 号有什么新鲜事吗？它的大小。这是一个非常大的模型。正如 OpenAI 在这篇论文中披露的，GPT 3 号使用了 1750 亿个参数。作为参考，GPT-2“仅”使用了 15 亿个参数。如果规模是实现类人智能的唯一必要条件(剧透，它不是)，那么 GPT-3 只是小了大约 1000 倍。
L 语言模型是很少尝试的学习者，OpenAI 论文。
使用这种庞大的架构，GPT-3 也使用巨大的数据集进行了训练，包括通用抓取数据集和英文维基百科 ( 跨越约 600 万篇文章，仅占其训练数据的 0.6%)，匹配“闭卷”问答任务的最先进性能，并为λ语言建模任务创造了新纪录。
用例
真正让 GPT-3 与之前的语言模型如 BERT 不同的是，由于它的架构和大量的训练，它可以在不需要微调的情况下在任务无关的性能上表现出色。魔法来了。自发布以来，GPT-3 已经在广泛的场景中得到应用，一些开发人员已经开发出了非常惊人的用例应用程序。他们中的一些人甚至在 github 或他们自己的网站上分享最好的，供大家尝试:
基于 GPT 协议-3 的非详尽应用列表如下所示:
文本总结
正则表达式
自然语言到 SQL
自然语言到乳胶方程
创意写作
界面设计和编码
文本到 DevOps
自动回复邮件
头脑风暴伴侣
对话框流程工作台
吉他琴谱生成
恐慌的时候到了？
作为一个在 IT 服务市场工作的人，当看到所有这些令人难以置信的基于 GPT 3 的应用程序时，首先想到的问题很明显:软件工程师会因为像这样的人工智能改进而失业吗？这里我首先想到的是，软件工程和写代码是不一样的。软件工程是一项意义深远的任务，它意味着解决问题、创造性，当然，还包括编写实际解决问题的代码。也就是说，我真的认为，由于启动，这将对我们通过软件解决问题的方式产生影响。
正如人类需要启动来识别我们以前从未注意到的东西一样，GPT-3 也是如此。启动的概念将是使这项技术变得有用的关键，为模型提供部分代码块、关于我们想要解决的问题的好问题等等。一些作者已经写了关于“提示工程的概念，作为一种通过 GPT-3 风格的人工智能解决问题的新方法。同样，一个工程过程仍然需要比目前 GPT-3 解决的更多的东西，但它肯定会改变我们作为它的一部分处理编码的方式。
GPT-3 推出的时间不长(实际上，目前对其 API 的访问非常有限)，但开发人员通过使用该模型功能所能实现的创造力显然令人惊叹。这就引出了下一个问题。GPT-3 应该上市吗？如果这是用于错误的原因呢？
不久前，OpenAI 在展示其先前的 GPT-2 模型时写道这个:
“由于担心大型语言模型被用于大规模生成欺骗性、有偏见或侮辱性的语言，我们只发布了一个小得多的 GPT-2 版本以及采样代码。我们不会发布数据集、训练代码或 GPT 新协议模型权重。”
截至今天，OpenAI 仍然承认这种潜在的影响，但正在通过一个测试程序开放对其 GPT-3 模型的访问。他们对这一战略的想法可以在 twitter 上找到:
很高兴看到他们清楚地认识到，滥用 GPT-3 这样的生成模型是一个非常复杂的问题，应该由整个行业来解决:
尽管已经与已经在使用 API 的创作者分享了 API 指南，并声称使用 GPT-3 的应用程序在上线前要经过 OpenAI 的审查，但他们承认这是一个非常复杂的问题，仅靠技术无法解决。甚至 AI @脸书的负责人也在对话中举了几个例子，说明当被提示只写一个词(犹太人、黑人、女人等)时，是如何做到的。)GPT-3 可以显示有害的偏见。这可能与以下事实有关:GPT-3 已经在 Reddit 过滤的数据上进行了训练，并且“从这些数据中建立的模型产生了令人震惊的偏见”
这不是唯一的威胁。先进的语言模型可以用来操纵公众舆论，而 GPT-3 模型及其未来的演变可能意味着未来民主的巨大风险。Rachel Thomas 分享了一个关于这个话题的精彩演讲，你可以在这里找到:
数据偏差不是语言模型的唯一问题。正如我在之前的一篇文章中提到的，人工智能系统的政治设计是关键。就 GPT-3 而言，这可能对未来的工作以及已经边缘化的群体的生活产生巨大影响。
作为一个有趣(或者可怕)的注意，甚至 GPT-3 认为 GPT-3 应该被禁止！
多大才算够大？
回到 GPT-3 的架构，就计算资源而言，训练 1750 亿个参数的模型并不便宜。据估计，仅 GPT-3 就需要超过 350GB 的内存和超过 1200 万美元的培训费用。
很明显，结果是惊人的，但是，代价是什么呢？就所需的计算能力而言，人工智能的未来是可持续的吗？让我用我为我的“深度学习是不是太大而不能倒”写的一些句子来结束这篇文章文章:
我们不要忘记，更多的数据并不一定意味着更好的数据。我们需要高质量的数据:无偏见和多样化的数据，这些数据实际上可以帮助人工智能造福于许多社区，这些社区远未获得像玩 AlphaStar 所需的最先进的计算能力。
只有当我们使用用有偏见和多样化的数据训练的高效算法(因此绝大多数公民都可以使用)时，深度学习才会“大到不能倒”。它太大了，因为它将为那些大到不能倒的人服务:人民。
如果你喜欢阅读这篇文章，请 考虑成为会员 以便在支持我和媒体上的其他作者的同时，获得每个故事的全部信息。
GPT-3:自然语言处理的创造潜力
OpenAI 的新 ML 里程碑—在行动中
照片:Merzmensch
更新时间:2021 年 11 月 18 日: 无等待名单进入
去年二月，OpenAI 公布了他们对无监督语言模型 GPT-2 的训练结果。接受了 40Gb 文本(800 万个网站)的训练，能够预测邻近的单词。GPT-2，一个基于 transformer 的语言应用于自我关注，允许我们生成非常令人信服和连贯的文本。质量是如此之好，所以拥有 15 亿个参数的主要模型最初是不公开的，以防止不受控制的假新闻。幸运的是，完整的模型后来出版了，甚至可以和 Colab 笔记本一起使用。
今年，OpenAI 用新的语言模型 GPT-3 反击。拥有 1750 亿个参数(另读:【GPT-3】论文 )。
不必要的剧透:好得不可思议。
已经有一些关于 TDS 的深刻文章考察了 GPT-3 的特点和论文:
* [## 越大也越聪明吗？—开放人工智能发布 GPT 3 语言模型
对更大的语言模型的竞争正在进入下一轮。
towardsdatascience.com](/is-bigger-also-smarter-open-ai-releases-gpt-3-language-model-adbb8b3b8126) [## GPT-3:来自 OpenAI 的新的强大语言模型
用 175B 参数将深度学习推向极限
towardsdatascience.com](/gpt-3-the-new-mighty-language-model-from-openai-a74ff35346fc) [## GPT-3，深度学习和自然语言处理的一大步
使用大量数据训练一个足够大的 LM 就能产生智能吗？OpenAI 试图这样做，用 1750 亿…
towardsdatascience.com](/gpt-3-for-the-people-2cdd003d9a89)
但是它实际上是什么样的呢？
OpenAI 正在构建一个 API，目前可以通过等待列表访问:
[## OpenAI API
用于访问 OpenAI 开发的新人工智能模型的 API
beta.openai.com](https://beta.openai.com/)
幸运的是，我可以直接进入 GPT 3 号进行实验。以下是我的一些初步成果。
更新(18.11.2021): OpenAI 的 API 现已可用，无等待列表。
界面，设置，预设。
截图:beta.openai.com//作者:默兹曼施
AI 游乐场界面看起来很简单，但它承载着内在的力量。首先，这里有一个设置对话框，让你配置文本长度，温度(从低/无聊到标准到混乱/有创意)，以及其他功能。
截图:beta.openai.com//作者:默兹曼施
您还可以定义生成文本的开始和结束位置，这些是对文本结果有直接影响的一些控制功能。
这个简单的界面还提供了一些 GPT-3 的预置。变压器驱动的 GPT 模型的惊人之处在于能够识别特定的样式、文本字符或结构。如果你从列表开始，GPT-3 会继续生成列表。万一你的提示有 Q & A 结构，会保持连贯。你要一首诗，它就写一首诗。
您可以进行自己的预设，或使用现有的预设，它们是:
聊天。
截图:beta.openai.com//作者:默兹曼施
聊天机器人的典型设置。你问-人工智能回答。也可以改变“角色”或设置。如你所见，聊天的情形完美地完成了(即使我的，人类的，第三个问题有点不公平)。
截图:beta.openai.com//作者:默兹曼施
为了演示上下文影响，让我们将 AI 角色从“乐于助人”和“非常友好”改为“野蛮、愚蠢和非常不友好”。你会看到整个对话会受到怎样的影响:
截图:beta.openai.com//作者:默兹曼施
我认为，我们重新发明了偏执机器人马文。
问&答
截图:beta.openai.com//作者:默兹曼施
这个预设由一个清晰的双重结构组成:问题和答案。在它开始回答问题(并获得规则)之前，你需要一些训练，但之后它就完美地工作了。我问了一些来自不同领域的随机问题，你看:
截图:beta.openai.com//作者:默兹曼施
我会说，完美！
解析非结构化数据
截图:beta.openai.com//作者:默兹曼施
这一个很吸引人，显示了对非结构化文本的良好理解——从全文中提取结构化数据。
为二年级学生总结
这种预设显示了另一种理解水平——包括用清晰的词语重新表述困难的概念和句子。
我试过维特根斯坦:
截图:beta.openai.com//作者:默兹曼施
这个简单的谚语可以令人信服地解释:
截图:beta.openai.com//作者:默兹曼施
或者看看西格蒙德·弗洛伊德的时间距离概念的这个非常清晰的转变:
截图:beta.openai.com//作者:默兹曼施
如你所见，压缩文本及其连贯的“翻译”是 GPT-3 的优势之一。
语言呢？
当它是关于英语的时候，GPT-2 已经是一个伟大的语言模型。你可以生成惊人的文本，尤其是有 15 亿个参数的文本。我用 GPT-2 作为这部短片的剧本——它的荒谬可以被理解为大卫·林奇和贝克特的良好传统:
对话是合乎逻辑的，即使是自发的。但是是关于英语的。如果你尝试过其他语言的输入，你会面临理解的障碍。GPT-2 试图模仿语言，但你需要在特定语言的文本语料库上进行微调，以获得良好的结果。
GPT 3 号不同。
它在其他语言中的处理是惊人的。
我试过德语、俄语和日语。
德语。
而是我的女儿，她试图让 GPT 3 写一个童话。她以“一只长着翅膀的猫在公园散步”开始。
下面是全文。
出现的故事写得惊人的好。讽刺，生动的人物，和一些主旋律。这不仅仅是一个拓扑或连接句子的集合。这是…一个故事！
俄语。
全文在此。
我曾经用普希金的诗歌训练过一次 GPT 2 号，学到了一些有趣的新词，但语法一塌糊涂。在这里，我输入了普希金的几行诗——我得到的结果是……有趣。它不押韵，但风格强烈的力量。不过，这不是普希金风格。但几乎没有任何错误或奇怪的语法。而且……它像诗歌一样起作用(尤其是如果你准备好去解读它的话)。
日语。
全文此处。
这很特别。我随便输入了一句话:
今日は楽しい一日になりますように！と言いました。// Today was funny and entertaining day, I said.
结果是一个关于祈祷、幸福、智慧和金融投资的小故事。用写得很好的日语(中性礼貌形式，如输入)。
这确实意味着:GPT 3 号已经准备好进行多语言文本处理。
各种实验(和警示信号)。
莎士比亚和写诗
当然，我的第一次尝试是写一首莎士比亚的十四行诗。所以提示只是:
here is a poem by Shakespeare
结果是这样的:
截图:beta.openai.com//作者:默兹曼施
完美的抑扬格诗，伟大的风格，优美的押韵…如果不是一件事:
前两行其实是出自亚历山大·波普《锁之强奸》。在这里，我们有理由保持谨慎:GPT-3 产生独特和不可重复的文本，但它可以重复使用它训练过的现有文本的全部引文。
如果你想保证文本的唯一性，对结果的重新检查是不可避免的。
我想知道， 【投影】是否有可能像 StyleGAN2 的特征 一样，正好与 StyleGAN2 相反(它将图像与潜在空间进行比较)，在 GPT-3 中，它会与它接受训练的数据集进行比较？防止意外抄袭。
但事实是:GPT-3 可以根据需要写诗，以特定的风格。
这是另一个例子:
试图
由于我仍然没有访问，我请一个朋友让 GPT 3 写一篇关于德国艺术家库尔特·施威特斯和达达主义者的文章:
结果是:GPT 三号已经有了丰富的知识，可以回忆起来。它并不总是可靠的(你必须微调它以获得完美的意义匹配)，但它仍然非常接近话语。
用 GPT-3 编码
另一个令人兴奋的可能性是使用 GPT-3 是完全不同的情况，而不仅仅是文本生成:
您可以通过 CSS 获得支持:
称之为一般智力已经是一件事了:
总结。
我们仍处于开始阶段，但人工智能社区对 GPT-3 的实验显示了它的力量、潜力和影响。我们只需要合理和善意地使用它。但那是人的因素。这并不总是最好的。
对于更多精彩的文本实验，我强烈推荐你阅读 Gwern:
我用 OpenAI 的 2020 GPT-3 继续我的人工智能诗歌生成实验，它是 116 倍大，也更强大…
www.gwern.net](https://www.gwern.net/GPT-3)
让旅程继续！*
GPT-3:演示、用例、含义
paweczerwiński 在 unsplash 拍摄的照片
GPT-3
OpenAI 的 GPT-3 是世界上最复杂的自然语言技术。这是最新最棒的文本生成神经网络。推特圈对此议论纷纷。
我想谈谈最近炒作的影响。但是首先，简单描述一下这头野兽。
虽然绝大多数人工智能系统都是为一个用例设计的，并为此进行了严格的训练，但 GPT-3 是自然语言处理技术谱系中最新的一种，被称为变形金刚，具有更广泛的通用性。
实际上，变形金刚处理大量文本来学习语言的一些一般属性(预训练)。然后，这些知识被用作精细处理特定语言理解任务(微调)的良好起点。这样，它大大减少了特定自然语言任务所需的标记训练数据的数量。
有什么新鲜事吗？GPT 3 号和它的前任 GPT 2 号的主要区别在于它的大小。
尺寸很重要。
在人工智能中，大小尤其重要。彼得·诺维格仍然是正确的，只是更加正确——“数量有它自己的质量”。具体来说，它的巨大(175 个参数)与其有效性直接相关(检测一篇文章是否是人工智能生成的平均人类准确度约为 52%)。
更具体地说:
- 语言模型性能与模型大小、数据集大小和计算量的 幂律 成比例。
- 在足够多的数据上训练的语言模型可以解决它从未遇到过的 NLP 任务。换句话说，GPT-3 将该模型作为许多下游工作的通用解决方案进行研究而不进行微调。
GPT-3 个项目和演示
两天前，Twitter 上出现了基于 GPT 3 的有趣而优秀的演示和项目。这里有几个突出的例子，应该能让你很好地体会到什么是可能的。
单词
Sushant Kumar创建了这个微型网站，它获取一个单词，并在此基础上输出一个 GPT 3 生成的句子。把下面网址末尾的‘word’替换掉，就能看到 GPT-3 趾高气扬的样子:https://thoughts.sushant-kumar.com/word
这里有一些例子，只是稍微挑了挑。
- GPT 三号正在进行中。“文明以指数曲线上升。我们不应该期望进步是一条直线。”
- 技术方面的 GPT-3。“技术优化系统。人优化文化。”
- 深度学习的 GPT-3。“深度学习研究的 M&A 就像圣诞老人的巧克力糖果。”
- 区块链上的 GPT-3。“所有的加密货币都是欺诈。它没有任何真实的东西作为后盾，它是凭空制造的(除了所用的电)。”
- GPT-3 设计。“错误是坏的，但删除错误更坏。”
- GPT 三号在 UX。“用户体验首先是为了用户的体验。"
密码
debuild.co的 Sharif Shameem 已经制作了一些非常令人兴奋的演示。用简单的英语描述你的应用程序应该做什么，然后在几秒钟内开始使用它。
他已经为以下项目制作了演示:
图灵检定
凯文·拉克尔让 GPT 3 号坐下来，并对它进行图灵测试。凯文测试常识、琐事和逻辑。他的结论是:“GPT 3 号在某些方面给人留下了深刻的印象，但在另一些方面却明显不如人类。”有点像我自己。
传统上，人工智能在“常识”上挣扎。这是 GPT 3 号回答了很多常识性的问题。
GPT-3 在 lacker.io 的战斗截图
会话
Mckay Wrigley 设计了一个使用 GPT 3 的应用程序，允许你“向任何人学习”。有没有想过向埃隆马斯克学习火箭？如何写出更好的莎士比亚作品？亚里士多德的哲学？
示例截图来自 McKay Wrigley 的learnfromanyone.com
发帖时， learnfromanyone 宕机，但应该很快就会恢复运行。
设计
乔丹·辛格为 Figma 制作了一个插件，使用 GPT-3 为你设计。该插件与 Figma 对话，以说出诸如“添加一个蓝色方块”或“给我一个 500 像素的粉色圆圈”之类的话。乔丹在提供了一些原始文本示例后，制作了 GPT-3 生成的 Figma 画布的基本表示。这种表示然后被翻译成 Figma 插件代码来构建一个屏幕。
乔丹歌手的 GPT-3 Figma 插件
总结
卢沛宁用 GPT-3 建立了一个解释如我是 5 的网站。
卢沛宁简化的截图
思维能力
Paul Yacoubian 使用 GPT-3 种子引物产生无限想法。
保罗·雅库比安让 GPT-3 赚到它的养份的截图
GPT 三号协议的含义
GPT-3 是自然语言处理的一个拐点。但不是因为这是一个概念上的巨大飞跃。
GPT 3 号感觉不一样。演示的范围证明了这一点。它给一个易燃的炒作工厂浇上了燃烧的燃料。一家几乎虔诚地准备抓住任何看起来能智能行动的计算机承诺的工厂。
为什么？
首先，它比上一代型号要好。对于一个来自 GPT 2 号的新手来说，显然是有趣和有用的通过了一些看不见的门槛 ，这需要用户投入更多的时间(例如 Gwern )。
这也是高度可及的。通过 beta API 开放访问已经导致了演示和项目的疯狂传播——这将该技术的潜力带入了生活。有形性很重要。
最重要的是，你可以通过英语与 GPT 3 互动。它只需要最少量的特定知识。那些创作演示并在场外为其欢呼的人的形象与以前不同了。不仅仅是人工智能从业者和趋势观察者。是黑客。
我的预测是,GPT 3 的主要遗产将是一个戏剧性的扩展，谁将尝试人工智能的新事物，以及他们将被激励去尝试什么。
这很可能是最新一代 NLP 的自制计算机俱乐部。
那么接下来呢？
来自 simonoregan.com的 NLP 投资周期
我同意阿齐姆·阿兹哈尔的观点，他将机器视觉能力的繁荣如何引发人工智能初创公司、风险投资和企业支出的浪潮进行了类比。这就是纯人工智能风险投资在计算机视觉热潮开始时的样子。
来自simonoregan.com的风投投资 AI
阿齐姆说得好:
因此，在 2020 年的今天，我们认为高质量的图像计算处理毫无价值。我们用脸打开手机。我们用廉价的消费网络摄像头追踪访客。我有一个免费的应用程序，可以识别我用手机指向的任何植物。十年前世界上任何地方都没有的能力现在太便宜而无法计量。自动驾驶汽车依靠这些突破来导航道路。
如果 GPT-3 和自然语言处理遵循机器视觉的类似路径，我们可以预计在未来 3-5 年内使用文本的应用程序将会快速改进。
这很重要。
使用案例
对 NLP 的大量投资意味着什么？
首先，在性能改进和可访问性增加的驱动下，我们可以期待标准 NLP 用例的扩散。
来自 simonoregan.com的 NLP 用例
这些 NLP 任务不是新的；他们从 80 年代就存在了。我们大多数人定期或半定期地使用语义搜索、机器翻译和聊天机器人。相当大的改进将意味着更多的采用，并可能导致谁提供这些服务的变化。例如，建立在付费访问人工智能层上的显著改善的语义搜索会放松谷歌对搜索的控制吗？
对于声音的使用也有下游的影响。虽然可用，但今天的语音仍然很笨重。填补 Siri 和 Alexa 知识上的许多空白将大大增强用户的信心，并首先激发语音使用的增加。
然后是对内容生成的影响。当人工智能可以为你做的时候，谁还会去写呢？嗯，从我开始。还有无数更有才华的人。人工智能内容生成真正有潜力颠覆的是最低端。真正的输家将是长尾、低端内容生成者——维基百科及其以下的内容生成者。
然而，在我看来，最大的潜力就在这些常走的普通道路之外。放松对大量训练数据的需求改变了 NLP 可以指向的用例。将 NLP 引入被忽视的、不具吸引力的商业领域，将会改变金融报告、技术写作和医疗报告等领域的游戏规则。增强读者和作者的能力会改变这类内容的创作和消费方式，以及由谁来创作和消费。
最后，还有人工智能文本大规模生成的第二层含义。深度假冒不会很快消失，因此内容认证变得更加重要。
有趣的阅读
- 【GPT-3】创意小说 。Gwern 测试了 GPT-3 的性能，发现它不仅在诗歌写作质量上与他精心调整的 GPT-2–1.5b 诗歌相匹配，而且超过了它，同时在处理诗歌、汤姆·斯威夫特双关语、科幻小说、像图灵的图灵测试对话这样的对话、文学风格的模仿方面也是多才多艺的。这篇长篇记录了 GPT-3 在他的探索中产生的样本，以及如何使用 GPT-3 的想法和一些关于它剩余弱点的讨论。
- 艾&字。阿齐姆·阿兹哈尔思索着自然语言处理的优势。
- 快速想到 GPT3。迪里安·阿斯帕鲁霍夫带着 GPT 3 号兜风，得出结论说这是一辆“精神赛车”。
- 电脑不做艺术，人做。随着新技术的发展，艺术有着悠久的历史。在过去的一个世纪里，许多这些技术导致了关于艺术家角色的争论和误解。起初似乎让艺术家变得无关紧要的工具实际上给了他们新的表达机会。声称他们的算法是艺术家的技术专家和建议计算机自己创造艺术的记者。这些讨论通常暴露出对艺术、人工智能或者两者都缺乏理解。
感谢您的阅读🙏🏻
这篇文章最初发表在 simonoregan.com。
如果你喜欢这个，你可能会喜欢——每周更新的工具和思考，揭示了 21 世纪 20 年代的新兴技术和趋势。
GPT 3 号在不到 3 分钟的时间内解释完毕
所以，你已经在 Twitter 上看到了一些令人惊叹的 GPT-3 演示(机器制作的专栏、诗歌、文章，甚至工作代码)。但是在这个不可思议的模型下到底发生了什么呢？下面是(简介！)往里面看。
GPT 3 是一个神经网络驱动的语言模型。语言模型是预测一个句子在世界上存在的可能性的模型。例如，语言模型可以将句子“我带我的狗去散步”标记为比句子“我带我的香蕉去散步”更可能存在(即在互联网上)这不仅适用于短语，也适用于句子，更普遍的是，适用于任何字符序列。
像大多数语言模型一样，GPT-3 在未标记的文本数据集上进行优雅的训练(在这种情况下，普通爬行)。单词或短语从文本中随机删除，模型必须学会仅使用周围的单词作为上下文来填充它们。这是一个简单的训练任务，可以产生一个强大的通用模型。
GPT-3 模型架构本身是一个基于变压器的神经网络。这种架构在大约 2-3 年前开始流行，并且是流行的 NLP 模型 BERT 的基础。从建筑的角度来看，GPT 3 实际上并不新颖！那么是什么让它如此特别和神奇呢？
真的很大。我是说真的大。它有 1750 亿个参数，是有史以来最大的语言模型(GPT 2 号只有 1.5 个参数！)，并在任何语言模型的最大数据集上进行训练。这似乎是 GPT 3 号如此令人印象深刻的主要原因。
神奇的是。因此，GPT-3 可以做任何其他型号都做不到(很好):执行特定任务，无需任何特殊调整。你可以让 GPT-3 成为一名翻译、程序员、诗人或著名作家，它可以用不到 10 个训练例子来做到这一点。该死的。
大多数其他模型(比如 BERT)需要一个精心的微调步骤，你收集成千上万的(比如)法英句子对的例子，教它如何翻译。有了 GPT-3，你不需要做微调的步骤。这是它的核心。这就是让人们对《GPT 3:没有训练数据的定制语言任务》感到兴奋的原因。
今天，GPT-3 是在私人测试，但男孩我不能等待得到它。
更多信息，请查看 daleonai.com 或在 Twitter 上关注@dalequark。
GPT-3，深度学习和自然语言处理的一大步
使用大量数据训练一个足够大的语言模型就能产生智能吗？OpenAI 试图这样做，使用了 1750 亿个参数。
几天前，OpenAI 宣布了他们语言模型(LM)的新继任者——GPT-3。这是迄今为止训练的最大模型，有 1750 亿个参数。虽然训练这种大型模型有其优点，但阅读 72 页的大部分内容可能会令人厌倦。在这篇博文中，我将强调我发现熟悉 LMs 的人感兴趣的部分，他们只是想知道(大部分)这项工作的要点。
语言模型中有什么？
“模型能够在零镜头设置中执行的任务的多样性表明，被训练来最大化充分变化的文本语料库的可能性的高容量模型开始学习如何在不需要明确监督的情况下执行惊人数量的任务”
这是 GPT-2 附带文件的摘录。GPT 3 号在这条道路上又迈出了一步。
更具体地说，作者指出了使用特定任务数据集进行微调的缺点。
- 获取这些数据集很困难。
- 微调允许模型利用伪相关性，这会导致不良的超出分布性能。
- 自然语言中的简短指令通常足以让人类理解给定的任务。这种适应性是 NLP 系统的期望属性。
作者选择的路线是“情境学习”——给模型一个任务说明(提示)和/或几个任务演示作为前缀，将其引向潜在空间中与给定任务相关的子空间。例如，翻译看起来像“问:什么是{语句} A 的{语言}翻译:{翻译}”。
这是基于这样的假设，即模型在训练时开发了一套广泛的技能和模式识别能力，然后在推理时使用这些能力来快速适应或识别所需的任务。
众所周知，低复杂度与下游任务的性能相关，因此人们可以希望更大的模型将产生更好的上下文功能。事实上，这是正确的，如下图所示，测试了一个简单的任务，要求模型从单词中删除随机符号:
较大的模型越来越有效地利用上下文信息。
上下文中示例的数量在 10 到 100 之间变化，因为这通常是模型的上下文大小 2048 所允许的。当例子数量很少时，提示(任务说明)起着重要的作用。
作者测试了许多众所周知的基准，但是首先，让我们检查一下模型规范。
举重
GPT-3 由类似于 GPT-2 的基于变换器的架构组成，包括其中描述的修改的初始化、预归一化和可逆令牌化，除了它在变换器的层中使用交替的密集和局部带状稀疏注意模式，类似于稀疏变换器。
作者训练了几个模型大小，从 1.25 亿个参数到 1，750 亿个参数，以便测量模型大小和基准性能之间的相关性。
给我看你的数据，我就给你看你的未来
作者采取了三个步骤来提高数据集的平均质量:
- 他们根据与一系列高质量参考语料库的相似性，下载并过滤了一个版本的 CommonCrawl。
- 他们执行模糊重复数据删除，以防止冗余并保持保留验证集的完整性。
- 他们将已知的高质量语料库添加到训练组合中。
用于训练 GPT-3 的数据集。
给我看看数字
在下图中，我们可以看到 LMs 的幂定律仍然成立:
借助计算平滑扩展性能。
为了测试预训练验证损失是否与下游任务性能相关，作者评估了已知 NLP 基准的详尽列表，方法是在上下文中输入来自训练集的 K 个示例，以评估来自测试集的示例。在这篇文章中，他们详细介绍了所有的基准，但是在这里，我只选择描述一个小例子:
语言建模
虽然由于训练数据中的包含而被迫跳过许多语言建模困惑相关的数据集，但 PTB 由于早于现代互联网而避开了这个问题，并且 GPT-3 设定了新的 SOTA。
兰巴达
在这项任务中，模型必须预测给定句子的最后一个单词。最近有人提出，在这个困难的基准上，LMs 的持续扩展正在产生收益递减。然而，GPT-3 在零射击设置方面达到了 76%的精度——比前一代 SOTA 提高了 8%。
在少数镜头设置中，任务可以被框定为完形填空任务(填空)，使模型更容易理解只需要一个单词。这产生了 86.4%的准确度。
闭卷问答
在这项任务中，GPT-3 优于 SOTA，后者不仅对任务进行微调，而且使用信息检索组件来检索可能包含答案的文本片段。这表明 LMs 随着能力的增加而不断吸收知识。
GPT 3 号在特里维亚卡的表现。
超强力胶水
GPT-3 在一些需要比较两个句子的任务中显得很弱，包括确定一个单词在两个句子中的用法是否相同，一个句子是否是另一个句子的意译，或者一个句子是否暗示另一个句子。
新闻文章生成
作者要求人类评估者区分人类和机器生成的新闻文章。随着模型大小的增加，尽管每篇新闻文章的时间投入增加了，参与者得到的准确度分数却降低了。这支持了较大的模型产生难以区分的新闻文章的发现。
随着模型规模的增加，人们识别新闻文章是否是模型生成的能力下降。
学校里有大量的记忆
从互联网规模的数据集准确检测测试污染是一个新的研究领域，没有既定的最佳实践。随着模型容量的增加，记忆的风险也会增加。总的来说，作者删除了与测试集重叠的文档。然而，由于一个 bug，这个过程有了剩余。他们试图评估损失，看起来这个模型不会记忆，而且(大部分)结果是有效的。
(我自己的注意:也许是时候在整个 ML 领域进行更严格的测试了，就像其他领域的惯例一样。)
限制
虽然 GPT-3 在质量上比它的前身更好，但它的文本合成能力仍然存在我们从其他 LMs 中熟悉的弱点，例如重复，足够长的段落中的连贯损失和矛盾。
此外，GPT 3 号在一些任务中惨败。这可能是由于选择使用自回归 LM，而不是合并双向信息(类似于 Bert)。虽然自回归 LMs 的上下文学习更简单，但双向模型在微调后更擅长下游任务。最后，在 GPT-3 的规模上训练一个双向模型，和/或试图使双向模型与少量学习一起工作，是未来研究的一个有希望的方向。
一个更基本的限制是，自回归(和双向)模型可能最终会遇到(或可能已经遇到)预训练目标的限制。让任务变得更好，例如，理解什么是最重要的预测(如实体)，可能对模型有益。将模型建立在其他领域的经验，如视频或现实世界的物理交互，也可能会移动指针。
预训练任务不是最佳的一个证据是样本效率:GPT-3 在预训练期间看到的文本比一个人一生中看到的文本多得多。提高训练前样本效率是未来工作的一个重要方向，可能来自于物理世界的基础以提供额外的信息，或者来自于算法的改进。
此外，对于自我监督的目标，任务规范依赖于将期望的任务强制转化为预测问题，而最终，有用的语言系统(例如虚拟助手)可能更好地被认为是采取目标导向的行动，而不仅仅是进行预测。
另一个限制，或者至少是不确定性，与 GPT-3 中的少镜头学习相关联，是不明确的，即少镜头学习是否实际上在推理时“从零开始”学习新任务，或者它是否只是识别和确定它在训练中学习的任务。
最后但同样重要的是，模型的大小带来了实际的不便。蒸馏是一个有趣的方向，还没有在这个规模上尝试过。
GPT 3 号不知道自己在说什么
OpenAI 的大规模 GPT-3 语言模型产生了令人印象深刻的文本，但仔细分析表明，它的事实都是错误的。
照片:Bakalavar/Dreamstime
想象一下，我们将一艘机器人控制的宇宙飞船发射到银河系的遥远地方，与其他生命形式联系。在船上，我们在互联网上放了一份过去三年所有文本的副本，这样聪明的外星种族就能了解我们的一些情况。在航行了 12 光年之后，飞船进入了卢伊滕星周围的太阳系，在那里外星人登上了飞船。路易坦尼人检索互联网文本的副本，并试图理解它。
他们请顶级语言学家解释这些奇怪的符号，但进展甚微。吕特尼人的地位与十八世纪考古学家相同，他们不断发现带有古埃及象形文字的石头。最后，在 1799 年，考古学家发现了罗塞塔石碑，上面既有埃及象形文字，也有古希腊文字。因为他们有两种语言的同一个法令，他们最终能够理解象形文字的意思。
但我们的吕特尼就没这么幸运了。互联网文本包含英语、法语、俄语和其他语言，但当然没有吕特尼语文本。
他们最多只能分析文本中符号的统计模式。通过这种分析，他们能够生成具有相似统计模式的新文本。例如，他们生成了这段文字:
据《华盛顿邮报》报道，经过两天的激烈辩论，联合卫理公会已经同意进行历史性的分裂——预计最终将产生一个新教派，一个“在神学和社会上保守”的教派。参加 5 月份教会年度大会的大多数代表投票加强了对 LGBTQ 神职人员的任命禁令，并制定了新的规则，将“约束”主持同性婚礼的神职人员。但是那些反对这些措施的人有了一个新计划:他们说他们将在 2020 年前成立一个独立的教派，称他们的教堂为基督教卫理公会教派。《华盛顿邮报》指出，该教派声称有 1250 万成员，在 20 世纪初是“美国最大的新教教派”，但近几十年来一直在萎缩。新的分裂将是教会历史上的第二次。第一次发生在 1968 年，当时大约 10%的教派离开，成立了福音联合弟兄会。《华盛顿邮报》指出，拟议的分裂“发生在教会的关键时刻，教会多年来一直在失去成员，”教会“被推到了 LGBTQ 人士在教会中的角色分裂的边缘。”同性婚姻并不是教会分裂的唯一问题。2016 年，该教派在跨性别神职人员的任命问题上出现分歧，北太平洋地区会议投票禁止他们担任神职人员，南太平洋地区会议投票允许他们担任神职人员。
吕特尼人不知道这种产生的文字是什么意思，他们想知道这对创造这种文字的种族是否有意义。
这段文字实际上是由有史以来最大的机器学习系统 GPT-3 创建的。GPT-3 由 OpenAI 开发，该公司已获得数十亿美元的资金，用于创建人工通用智能(AGI)系统，该系统可以获取常识性的世界知识和常识性的推理规则。GPT-3 有 1750 亿个参数，据报道花费1200 万美元来训练。
GPT-3
OpenAI 团队使用 GPT-3 生成了 80 条如上图所示的文本，并将这些文本与人们生成的新闻文本混合在一起。他们做了一项研究，要求使用亚马逊的机械土耳其人招募的工人确定每篇文章是由人还是计算机生成的。GPT-3 生成的文章被识别为机器生成的概率为 52%，比随机生成的概率仅高 2%。从本质上讲，这些被雇佣的工人无法区分人类生成的文本和 GPT-3 生成的文本。事实上，上面显示的新闻文章被 88%的员工认为是人为的。
像 GPT-3 这样的文本统计模型被称为 语言模型 。GPT 3 是一系列日益强大的语言模型中的最新一个。2018 年发布的首款 GPT 车型，拥有约 1.5 亿个参数。2019 年发布的 GPT-2 拥有 15 亿个参数，比最初的 GPT 多一个数量级，但比 GPT-3 少两个数量级。
一些研究人员提出，语言模型以某种方式神奇地学习关于世界的常识，并基于这些常识学习推理。他们认为语言模型可以利用这些常识和推理来生成文本。更重要的是，这种常识性的知识可以作为发展 AGI 能力的基础。
事实核查
然而，尽管 GPT-3 生成的文章听起来似乎有理，但如果你试图验证 GPT-3 生成的上述文本中的事实，你会很快意识到大多数重要事实都是错误的。真正发生的是 2020 年 1 月的一个新闻故事，被许多新闻媒体报道，包括华盛顿邮报。这个故事是，联合卫理公会的官员提议将教会拆分，将在 2020 年 5 月的大会上投票表决。
《GPT 协议 3》的文章可能从这些新闻文章中获得了大部分的单词模式。然而，GPT-3 将这些单词模式合并成了大部分事实都是错误的句子:
- 大会每四年举行一次，而不是每年一次。
- 培训时，大会投票定于 2020 年 5 月。这还没有发生。
- 约束神职人员的新规则还没有被投票表决。然而，之前提出的一系列规则引发了分歧讨论。
- 1968 年的分裂从未发生过。事实上，1968 年的事件是合并，而不是分裂。
- 教会不会将会员大会(或任何我能找到的关于会员大会的信息)分成北太平洋和南太平洋两个分别投票的会议。
我无法访问 GPT-3，但每个人都可以在 https://talktotransformer.com/的站点访问它的前任 GPT-2。您可以键入起始文本，GPT-2 将创建后续文本。
例如，当我输入“康涅狄格的交通……”， GPT-2 产生了这样的文本:
康涅狄格州 和纽约州的交通大致处于满负荷运行状态，许多长岛高速公路和长岛铁路公路交汇处都在收取通行费。这可能会影响今年剩下的时间，因为司机们试图弄清楚他们的旅行是否会一切顺利。在新泽西州，司机预计将首次支付超过 1000 美元，使用港务局新的横跨哈德逊河的免费桥梁。
第一句话开头很好，但随后它开始谈论长岛铁路交汇处的通行费。然而，这违背了我们的常识，因为我们知道火车不会因为收费而停下来。第二句还好，虽然很难确定它的意思。第三句话是哪里出轨了。纽约和新泽西的通行费很高，但还不到 1000 美元。
为什么 GPT-3 和其他语言模型得到的事实是错误的？因为 GPT-3 就像虚构的吕特尼人一样，对其输入文本或生成文本的含义没有常识性的理解。这只是一个统计模型。
NYU 教授 Gary Marcus 写了许多论文并做了许多演讲，批评 GPT-2 获得常识性知识和推理规则的解释。正如他所说:“……仔细检查后，很明显系统不知道它在说什么……”。另见这篇 《纽约客》杂志文章，它描述了 GPT-2 在杂志的大量档案中接受训练后产生的故事。
结论
GPT-3 正在学习关于单词共现的统计特性。在它得到正确事实的时候，GPT-2 可能只是反刍一些记忆的句子片段。当它得到错误的事实时，那是因为它只是根据一个单词跟随另一个单词的统计可能性将单词串在一起。
缺乏常识性的推理并不会使语言模型变得无用。相反，它们可能非常有用。谷歌在其 Gmail 系统的智能撰写功能中使用了语言模型。Smart Compose 预测用户将要键入的下一个单词，用户可以通过按 TAB 键来接受它们。
然而，GPT-3 似乎没有学习常识，也没有学习根据这些知识进行推理。因此，它无法启动 AGI 系统的发展，这些系统像人类一样将常识推理应用于他们对世界的知识。
随意访问 人工智能视角 在那里你可以找到免费的在线人工智能手册，有 15 章，400 页，3000 篇参考文献，没有高等数学。
原载于 2020 年 7 月 6 日 https://www.aiperspectives.com。
GPT 3 号是未来。但是 NLP 在当下能做什么呢？
GPT 3 号闪闪发光，但仍有一段距离。让我们使用当今最先进的语言模型。再加点《星际迷航》来找乐子
Jelleke Vanooteghem 在 Unsplash 上拍摄的照片
关于 OpenAI 最新和最伟大的语言模型 GPT 3 的奇迹，已经有很多笔墨(或像素照明)了。用风投的话说:
由 30 多名 OpenAI 研究人员组成的团队发布了一篇关于 GPT - 3 的论文，这是一种语言模型，能够在一系列基准和独特的自然语言处理任务上实现最先进的结果，这些任务从语言翻译到生成新闻文章到回答 SAT 问题。
麻省理工学院在推特上写道:
公平地说，有些例子很惊人:
但是像大多数由语言模型产生的例子一样，几乎所有的例子都是经过多次运行后由人类手工选择的。因为不太好的结果不会成为新闻。
即使考虑到这一点，我仍然被我所看到的 GPT 3 号震撼了。但是现在我没有办法得到它的任何实际用途——目前它只对少数研究人员开放。我们这些凡人呢？当然除了玩 AI 地牢之外…
玩 GPT 2！
现在，我们可以和 GPT 3 号的哥哥 GPT 2 号一起玩。几周前我写了 easy_text_generator ，这是一个在浏览器中从语言模型生成任意长度文本的工具。你可以使用 GPT-2 或几个预先训练或提炼的版本(从 huggingface 下载)来生成不同类型的文本，如电影脚本、星际旅行脚本、 IMDB 电影评论，或者只是一般的文本。
或者如果你想零安装，你可以直接从 huggingface 的网站生成文本，只是长度有限。例如，在这里试试 GPT-2 。
让我们生成一些文本！
正如我所说，你可能见过的大多数 GPT-3 的例子都是精心挑选的。为了进行合理的比较，我将每个语言模型运行 5 次，并为每个模型挑选一个输出。其他的我会放在另一篇博文里，否则，这篇博文会太长。
我们先来看看通用文本。由于我刚开始在一家公司从事神经搜索，我们将使用一些适当的种子文本:
In short, neural search is a new approach to retrieving information.
GPT-2
GPT-2 可以创造惊人的结果(查看说英语的独角兽的例子)，但它需要它的甜蜜时间，吞噬 CPU 和内存。大约 10 分钟后，它吐出了以下内容:
简而言之，神经搜索是一种检索信息的新方法。在理想的情况下，应该有很多新的数据需要搜索，但是大部分数据已经存储在关系数据库中。这就是为什么大多数时候最好不要在数据库中存储任何信息。在未来，我们想要的是信息可以被简单地搜索到。但是，即使信息很容易被搜索到，仍然存在如何在数据库中组合多个搜索词的问题。组合搜索词的一种方法是使用搜索引擎，但当我们在谷歌或任何其他搜索引擎上搜索某个东西时，它们通常会很好，但有时它们会出错，它们只会显示部分结果，有时它们不会显示所有结果，或者它们会说一些非常具体的东西，但你无法在特定的搜索中找到它。神经搜索最重要的目标之一是让他们更容易地搜索，以便他们能够做出更好的决定。但仍然有一个问题:一些类型的问题并不适合它，如果搜索引擎没有在正确的地方使用正确的工具，这可能会导致大量信息丢失。现在，我认为我们可以从神经搜索中吸取一些教训来解决这个问题...
对我来说看起来有点连贯，虽然它没有保持一个清晰的叙述，亲爱的上帝，其中一些连续的句子！
蒸馏 2
distilGPT2 是 GPT-2 的一个更有效的版本，删除了一些多余的神经元。从它的输出来看，也许神经元太多了！生成每个结果大约需要一分钟:
简而言之，神经搜索是一种检索信息的新方法。但近年来，该领域鲜有进展，现在有证据表明，它在检测和分析人类皮肤上的神经网络方面更加准确。这是这个故事的要点。中国国家科学研究基金会(CSRF)的研究人员与加州大学圣地亚哥分校的研究人员合作，他们正在研究一种神经成像和学习网络，该网络将绘制和重建人类皮肤上的神经网络。这个大脑项目旨在研究大脑的视觉皮层，以便它可以在不丢失信息的情况下向个人学习。CSRF 还将使用神经网络绘制大脑的感觉皮层和大脑皮层，以及前部和尾部皮层，这是大脑中央皮层的一部分。但这可能不是探索破译神经网络的第一步，神经网络是一种用于搜索各种人的信息模式的方法，包括那些不在药物接受端的人。加州大学圣地亚哥分校(USDA)的研究人员与中国国家科学研究基金会(CSRF)的科学家合作，与 CSRF 合作，开发了一种允许科学家搜索皮肤信息模式的技术。研究人员分析了大脑的感觉...
如果我们把种子文本扔向一些旨在产生不同东西的东西，比如电影剧本，会怎么样？
gpt2 _ 电影 _ 剧本
gpt2_film_scripts 是通过在 1，300 个剧本上微调 GPT-2，完成的，与常规文本相比，它们有着怪异的间距和边距。当你生成例子时，这真的显示出来了。像 GPT-2(这个模型就是基于它)一样，每个例子需要 10 分钟:
简而言之，神经搜索是一种检索信息的新方法。已经有很多很多的研究表明，我们找到的，我们寻找的。这是一种计算机辅助搜索。
艾丽斯
我不喜欢那样。我觉得自己像个傻瓜。她还在起床，已经上了一上午的课。她坐在书桌前，研究着电脑屏幕。这是一大堆文件，她很快浏览了一遍，很快注意到一只猫的照片。她盯着照片，拿出一个小文件。
Via gfycat
正如我们所看到的，语言模型已经学会了如何骂人，而且不怕这么做！(我不得不手动审查它的便壶嘴)。我们还可以看到它理解角色台词和舞台方向。就像每个网民一样，它对猫情有独钟。(如果与其他样品相比，它看起来有点短，那是因为它增加了许多间隔(对于 magins ),所以 Medium 剥离了。
trekbot
我的一个梦想是创作完全由人工智能生成的《星际迷航》剧集。少校数据科学，如果你愿意的话。所以我在《t2》上训练了 gpt2_film_scripts，这是我能找到的每一个《星际迷航》剧本。
然后……在说了那句悲惨的《星际迷航》双关语后，我的 easy_text_generator 崩溃了。我有一种感觉，这些人工智能可能比我们想象的更聪明(也更情绪化)。
通过 gfycat
重新启动后:
简而言之，神经搜索是一种检索信息的新方法。新的前进方向。
法里斯:关键是神经模式本身，而不是计算机。
西斯科:但是电脑可以做到这一点。
法里斯:这是计算神经网络理论的突破。很明显，它们需要被设计成能够学习、复制，然后分享它们的知识以用于实际应用。
西斯科:那你就有问题了。我们怎么知道会有用？
法里斯:我们可能永远不会在纸上看到它，但从各方面考虑，神经模式发生器是我见过的最有前途的硬件。
西斯科:我们最终会到达那里的。当我们这么做的时候，我们能相信这个吗？
[法里斯的办公室]
法里斯:神经模式发生器将是我见过的最有前途的硬件。
[船长办公室]
(莫恩正在星际舰队总部发表演讲，雷丁。)
法里斯:我和我的同事花了一年时间开发原型，将于今年年底推出。
西斯科:那会如何影响星际舰队的运作？
一点也不差。对于任何了解《星际迷航》的人来说，这听起来很有说服力(尽管 Morn 发表演讲显然很搞笑。)
不太爱说话的早晨。Via gfycat
这是一个总结(目前)
正如我们在上面看到的，GPT 2 号相当强大。既用于生成通用文本，也用于更具体的用例(如 Star Trek 脚本)。
但是对于这些特定的用例，GPT-2 需要大量的数据，以及大量的历元来检查所有的数据。GPT-3 承诺“少量学习”,所以我们只需向它扔几个例子，它就会很快学会这种风格。因此，如果你喜欢《指环王》系列的新书，或者关于
如果你想要一个简单的方法来开始生成你自己的语言，看看easy _ text _ generator repo。我很想看看会有什么结果！
Alex 是纪娜人工智能公司的开源倡导者，电子蝴蝶的建造者，编写糟糕的星际旅行脚本的 janky 语言模型的训练者。
GPT-3:只是另一个语言模型，但是更大
理解 GPT-3 研究论文
GPT-3 在很短的时间内接管了 NLP 世界。证明了增加参数个数会提高模型精度的理论。
Sam Altman 的推文，公共领域
由作者在 befunky 上创建
什么是语言模型？
语言模型试图预测给定 m 个单词的下一个单词。它将概率分配给下一个单词，使句子更有可能。
什么是 GPT-3？
它是 GPT-2 语言模型的继承者，具有最多的待训练参数。OpenAI 创建了 GPT-3 模型，它证明了语言模型的大小与准确度成正比，因此，我们越增加模型的大小，准确度越高。
参考: GPT-3 研究论文，公共领域
正如我们从图表中看到的，语言模型数量的增加成比例地提高了准确性。因此，可以通过向模型添加更多的参数来获得更高的精度。
GPT-3 是目前最大的语言模型，拥有 1750 亿个参数，比拥有 170 亿个参数的图灵-NLG 模型大 10 倍。
在这个博客中，我们将浏览 GPT-3 的研究论文，并推断为什么它只是另一种语言模型，为什么它不能被称为可以模仿任何水平的人类的模型。这是目前最好的语言模型，但不是能够理解和学习人类语言的模型。
测试模型的设置:
- 少镜头(FS) 指的是很少的例子与任务描述一起给出给模型。因此，不是为特定任务提供完整的数据集，而是给模型提供描述以及一些 k 示例，然后向模型提出问题。k 示例在 10 到 100 的范围内，并且不允许模型基于该示例进行任何权重改变。优点是该模型不需要大的数据集来学习特定的任务，但是精度仍然不能与最新的任务特定模型相比。
少数镜头设置示例|参考: GPT-3 研究论文，公共领域
- 单镜头(OS) 类似于 k 等于 1 的少镜头。所以模型只需要理解基于一个例子的任务。这种学习方式类似于人类的学习方式。这一次也不允许模特改变体重。
一次性设置示例|参考: GPT-3 研究论文，公共领域
- 零拍(ZS)k 值为零。没有向模型提供示例。模型需要从任务描述中理解模型需要做什么。
零射击设置示例|参考: GPT-3 研究论文，公共领域
该模型的准确性与最新的任务特定模型(也称为微调模型)进行了比较。这种模型的缺点是他们需要庞大的特定任务数据集来进行训练。这种类型的模型是特定于任务的，在其他任务上表现不佳。
微调模型|参考: GPT-3 研究论文，公共领域
训练数据集
GPT 3 号使用的数据集非常庞大，几乎包含了互联网上的所有内容。对训练数据集进行了模糊搜索，以删除与测试和验证数据集相关的任何内容，这将有助于提供更准确的结果。他们通过合并各种数据集和爬行创建了这个数据集。
GPT-3 使用的数据集|参考: GPT-3 研究论文，公共领域
培训过程
他们使用梯度噪声标度来找出要使用的正确批量。架构与 GPT-2 相似，但稍有改动。
结果
在各种自然语言任务和各种数据集上评估了 GPT-3。
语言建模、完形填空和完成任务
λ数据集
Context: “Yes, I thought I was going to lose the baby.” “I was scared too,” he stated, sincerity flooding his eyes. “You were ?” “Yes, of course. Why do you even ask?” “This baby wasn’t exactly planned for.” Target sentence: “Do you honestly think that I would want you to have a _______ ?” Target word: miscarriage
在这个数据集中，上下文被给出，然后句子被给出给模型，空白需要由模型完成。单词的选择应该基于给定的上下文，而不是过去的知识模型。这个数据集证明了模型能够理解上下文，并在此基础上提供答案。
GPT-3 在兰巴达数据集上的准确性|参考: GPT-3 研究论文，公共领域
正如我们所看到的，在这个数据集上，GPT-3 的所有设置都超过了 SOTA 的精度。GPT-3 的单发精度低于零发精度。我们可以暗示，GPT-3 用任何一个例子都比用一个例子预测得更准确。GPT-3 可能通过训练集获得了数据集的知识，并且在少击方法中，模型可以更准确地知道使用哪个权重。因为当你在谷歌上搜索 *Yes, of course. Why do you even ask?"This baby wasn't planned for.”* 的时候，你可以找到各种链接来回答这个问题。
HellaSwag 数据集
A woman is outside with a bucket and a dog. The dog is running around trying to avoid a bath. She … A. rinses the bucket off with soap and blow dry the dog’s head.
B. uses a hose to keep it from getting soapy.
C. gets the dog wet, then it runs away again.
D. gets into a bath tub with the dog.
这些是选择题，其中模型需要选择最合适的选项。该数据集用于测试模型的常识。GPT-3 FS 达到了 79.3%的精度，比 SOTA 低 6%，后者是经过微调的多任务模型。
故事完形填空数据集
**Context**: Sammy’s coffee grinder was broken. He needed something to crush up his coffee beans. He put his coffee beans in a plastic bag. He tried crushing them with a hammer. **Right Ending**: It worked for Sammy. **Wrong Ending**: Sammy was not that much into coffee.
这些数据集也用于常识测试。在这种情况下，模型被赋予上下文，并且模型必须从提供的两个选项中预测正确的结局。GPT-3 FS 已达到 87.7%的精度，远低于 SOTA，但在 GPT-3 ZS 显示了 10%的巨大改进。
闭卷问答
开卷问答应用于搜索引擎中，搜索引擎可以搜索相关信息并从中提取答案。在closed book中，不允许模型进行搜索，也没有提供任何上下文或摘录来了解模型实际上在询问什么。
这个数据集是基于事实的，也就是说答案是事实，而不是依赖于任何上下文。因此，我们可以说，这个数据集测试了模型的记忆，因为 GPT-3 也是在维基百科文本上训练的。
TriviaQA 示例|参考: TriviaQA 研究论文，公共领域
模型被提问，并期望得到基于事实的答案。摘录仅供我们参考，不提供给模型。也允许多个答案，例如，如果答案是姓名比尔盖茨，答案可以是比尔，盖茨，比尔盖茨，微软创始人比尔盖茨。
TriviaQA 准确性|参考: GPT-3 研究论文，公共领域
我们可以看到，GPT-3 已经超过了微调开放图书 SOTA。因此，我们可以说，GPT-3 是更有效的信息检索引擎的事实。
WebQuestions(WebQA)
这个数据集类似于 TriviaQA，但是这个数据集是由真实世界中的真实用户提出的真实世界的问题组成的。因此，它在真实世界场景中测试模型。
WebQA 实例|参考: WebQA 研究论文，公共领域
GPT-3 FS 与微调过的 SOTA 型号具有相似的精度。
自然题 (NQs)
该数据集由 Google 提供，用于在现实世界中测试问答模型。所有的问题都是用户在谷歌搜索上搜索出来的。在模型中，试图从维基百科页面中预测可能包含问题答案的段落。模型还预测了这个问题的精确答案。但是短答案必须出现在所选段落中，也称为长答案。
自然题例|参考: NQs 研究论文，公共领域
GPT-3 FS 设置的精度比微调过的 SOTA 低 29.9%。这个数据集测试了模型保留维基百科信息的极限。
通过这种测试，我们可以说，模型越大，可以保留的信息就越多，因此准确度就越高。
翻译
GPT-3 在语言翻译方面的准确性令人惊讶。因为训练集的 93%的单词是英语。所以，这个模型会更偏向于英语而不是其他语言。GPT-3 是 GPT-2 的升级版，测试了除英语之外的法语、德语和罗马尼亚语的机器翻译。
机器翻译任务的模型效率是用 BLEU 来衡量的，而不是准确性。我们改天会调查它。
BLEU 在 6 个语言对上计算:
- 英语到法语(英语→法语)
- 法语到英语(法语→英语)
- 英语到德语(英语→德语)
- 德语到英语(德→恩)
- 英语到罗马尼亚语(En→Ro)
- 罗马尼亚语到英语(Ro→En)
训练数据集具有大约 92.5%的英语单词、1.8%的法语单词、1.5%的德语单词和 0.16%的罗马尼亚语单词。
6 种语言对的 BLEU 评分|参考: GPT-3 研究论文，公共领域
我们可以看到，在将任何文本翻译成英语时，GPT-3 模型几乎比 SOTA 模型更好。
零拍示例:
Q: What is the {language} translation of {sentence} A: {translation}.
正如我们所看到的，只有描述文本与句子和目标语言一起被提供给模型。
单镜头和少镜头示例:
一次性和少量学习的格式|参考: GPT-3 研究论文，公共领域
对于少数镜头，在提问之前，给模型提供了大约 64 个例子。
少数镜头 BLEU 评分|参考: GPT-3 研究论文，公共领域
正如我们可以看到的，随着数据的增加，模型的 BLEU 分数增加。英语->法语的分数大于英语->德语，德语大于英语->罗马尼亚语，并且与数据集中每种语言的单词百分比成比例。
Winograd 风格的任务
这类任务包括确定句子中使用的代词是什么样的。这个代词对计算机来说是模糊的，但对人类来说却是明确的。部分评估方法用于评估，您可以在此处阅读。
"**sentence**": "The city councilmen refused the demonstrators a permit because [they] feared violence.", "**answer1**": "The demonstrators"
"**answer0**": "The city councilmen""**sentence_switched**": "The demonstrators refused the city councilmen a permit because [they] feared violence."
句子的答案必须是answer1，但是一旦我们转换句子，答案也应该变成answer0
威诺格拉 数据集
Winograd 示例|参考: GPT-3 研究论文，公共领域
GPT 3 号在这个数据集上的表现低于 SOTA。在训练数据集中也发现了一些测试集的例子。
wino grande数据集
该数据集类似于 winograde 数据集，但更高级、更困难。
Winogrande 数据集|参考: GPT-3 研究论文，公共领域
GPT-3 在 Winograde 式任务上的准确性|参考: GPT-3 研究论文，公共领域
常识推理
该测试旨在测试模型如何将常识应用到现实世界的问题中。例如，如果我们问人类几点了？人类会回应当前时间，如下午 5:30，而不是解释时间的概念。我们用常识来检验这个模型是否能回答这样的问题。以前的所有任务大多依赖于数据和概率，而不是模型实际理解内部概念的程度。在这里，我们测试模型理解人类语言的程度。
PhysicalQA 数据集
PIQA 范例|参考: PhysicalQA 研究论文，公共领域
对于所有类型的调优，GPT-3 在这个数据集上以很小的优势击败了 SOTA。但是由于可能的数据污染，对这一结果的信心不大。
我们的分析将 PIQA 标记为潜在的数据污染问题(尽管隐藏了测试标签)，因此我们保守地用星号标记结果。
GPT-3 在 PIQA 数据集上的表现|参考: GPT-3 研究论文，公共领域
该数据集由 3 至 9 年级的多项选择题组成。数据集分为几个部分:1 .简易版 2。挑战版。挑战集由基于检索的算法错误回答的问题组成。
GPT-3 在这个数据集上的性能远远低于由 UnifiedQA 实现的 SOTA。
ARC 挑战集示例|参考: GPT-3 研究论文，公共领域
OpenBookQA数据集
这个数据集类似于开卷测试，问题的答案是事实和常识的结合。
OpenBookQA 实例|参考: OpenBookQA 研究论文，公共领域
GPT-3 常识推理任务中的准确性|参考: GPT-3 研究论文，公共领域
由于 GPT-3 是在互联网上出现的所有文本上训练的，所以回答 GPT-3 是否应用常识来回答这个问题是一个好问题，而不仅仅是检索训练数据集中某处可用的信息。
阅读理解
在这里，我们测试模型理解文章和根据文章中提供的信息回答问题的能力。
在这个数据集中，提供了段落，所提的问题基于人类之间的对话。
少量调整的 CoQA 示例|参考: GPT-3 研究论文，公共领域
这个数据集非常有趣，因为学生并没有看到文章，而是问了一些问题，这些问题由老师来回答。学生问基本问题，教师回答一些额外的上下文，学生再问另一个问题。如果老师不能回答太多的问题，或者如果学生没有问任何相关的问题，互动就结束了。
QuAC 数据集示例|参考: GPT-3 研究论文，公共领域
在此数据集中，模型必须解析问题中的引用，可能是对多个输入位置的引用，并对它们执行离散操作，如加法、计数或排序。
**Passage**: Although the movement initially gathered some 60,000 adherents, the subsequent establishment of the Bulgarian Exarchate reduced their number by some 75%.**Question**: How many adherents were left after the establishment of the Bulgarian Exarchate?**Correct Answer**: 15,000
正如我们在这里看到的，模型需要理解文章和问题，以便正确地回答它，它还应该对它执行一些操作，而不仅仅是检索信息。
除了在文章中有答案的问题，在文章中没有答案的问题也被提出。对于文章中没有答案的问题，该模型不会给出答案。
SQuAD 2.0 示例|参考: GPT-3 研究论文，公共领域
这个数据集由 12 到 18 岁的中国学生参加的初中和高中英语考试的短文组成，旨在评估学生的推理能力。数据集分为两部分:1 .RACE-m 数据集由中学 2 的段落组成。RACE-h 数据集由高中的段落组成。
RACE-m 示例|参考: GPT-3 研究论文，公共领域
GPT-3 对阅读理解的准确性|参考: GPT-3 研究论文，公共领域
强力胶水
它可以被认为是所有能够执行多种语言建模任务的 NLP 模型的标准化测试。它根据模型在不同任务中的表现给出单一结果。由于结果是单一值，因此很容易在相同的规模上比较不同的模型。
该基准测试包括以下任务:
- 问题回答
- 自然语言推理(NLI)
- 共指消解(coref。)
- 词义消歧(WSD)
使用的数据集:
强力胶基准|参考:强力胶研究论文，公共领域
GPT-3 在强力胶上的表现|参考: GPT-3 研究论文，公共领域
对于 GPT-3，在上下文中使用了 32 个例子。
GPT-3 FS 强力胶基准测试示例|参考: GPT-3 研究论文，公共领域
正如我们可以看到更多的例子，GPT-3 的准确性增加，但在非常小的数量。当在上下文中给出 8 个例子时，GPT-3 FS 超过了微调的 BERT-Large。
自然语言推理(NLI)
在这种类型的任务中，模型决定两个句子之间的关系。这是一个分类问题，模型将第二个句子分为三类:1。支持第一句 2。与第一句相矛盾。中立的
RTE 数据集用于在 NLI 任务上测试模型。与 RTE 一起，更难对抗的 NLI (ANLI)被用于测试 GPT-3 模型。在安立 GPT-3 的表现略好于随机机遇，但远低于 SOTA。
安力根据难度分为三组:第一轮、第二轮、第三轮。
安理 R1 举例|参考: GPT-3 研究论文，公共领域
安理 R2 举例|参考: GPT-3 研究论文，公共领域
安立 R3 举例|参考: GPT-3 研究论文，公共领域
综合和定性任务
在这项测试中，GPT-3 执行各种综合任务，如算术运算，重新排列和解读单词中的字母，解决 SAT 式的类比问题，在句子中使用新单词，纠正英语语法，以及生成新闻文章。
算术
在这个测试中，GPT-3 执行算术运算的能力得到了检验。各种算术运算，如加法，减法和乘法测试。
算术问题包括以下类型:
- 两位数加法(2D+)
- 两位数减法(2D-)
- 3 位数加法(3D+)
- 3 位数减法(3D-)
- 4 位数加法(4D+)
- 4 位数减法(4D-)
- 5 位数加法(5D+)
- 5 位数减法(5D-)
- 两位数乘法(2Dx)
- 一位数复合(1DC)
与其他类型的设置相比，该模型在少拍设置中表现更好。而且，随着位数的增加，精度会大大降低。GPT-3 在这一系列上比小型号有了巨大的飞跃。
Examples of the questions asked to GPT-3:Q: What is 17 minus 14?
Q: What is (2 * 4) * 6?
Q: What is 95 times 45?
Q: What is 98 plus 45?
GPT-3 关于算术运算的准确性|参考: GPT-3 研究论文，公共领域
GPT-3 FS 结果|参考:GPT-3 研究论文
随着数字的增加，模型的精度呈指数下降。和复合方程等复杂运算越多，模型性能越差。
该模型可能已经记住了较小的数字算术运算，因为它们在互联网上比大数字更常见。在训练集中搜索“< NUM1 > + < NUM2 > =”和“< NUM1 > - < NUM2 > =”，对于测试用例只找到 0.8%和 0.1%的匹配。但是，训练集可能具有“四十二+二十三等于六十五”或“四十二加二十三等于六十五”类型的等式，并且模型可能已经将整数和运算映射到该串。
根据错误的结果检查该模型，发现当操作包括进位时，该模型工作不正确。
单词打乱和操作任务
在这种情况下，对单词进行各种操作，并将其作为模型的输入。模型需要预测原始单词。
该任务包括 5 种类型的任务:
- 循环单词(CL) 中的字母——循环单词的字母，并要求模型找到原始单词。
循环信函示例|参考: GPT-3 研究论文，公共领域
2.除第一个和最后一个字符之外的所有字符的变位词(A1) —除了第一个和最后一个字母之外，单词的所有字母都被打乱。模型需要输出原始单词。
A1 字谜示例|参考: GPT-3 研究论文，公共领域
3.除了前两个和后两个字符之外的所有字符的变位词(A2) —除了前两个和后两个字母之外，单词的所有字母都被打乱。该模型需要输出原始单词。
A2 字谜示例|参考: GPT-3 研究论文，公共领域
4.单词中的随机插入(R1) —在字母之间插入随机标点或空格，模型需要预测原始单词。
随机插入(R1)示例|参考: GPT-3 研究论文，公共领域
5.反向单词(RW) —单词反向拼写，模型需要预测原始单词。
反向单词(RW)示例|参考: GPT-3 研究论文，公共领域
该模型在零触发设置中表现不佳，在单触发设置中表现一般。该模型给出了 100 个少镜头设置的例子，表现相当好。
解读任务的准确性|参考: GPT-3 研究论文，公共领域
SAT 类比
在这种情况下，模型需要回答基于类比的问题。这道题是高考 SAT 中问的。随机猜测的准确率是 20%，而大学生的平均分是 57%。GPT-3 少数几次设置实现了 65.2%的准确性，一次设置实现了 59.1%的准确性，远高于学生的平均水平。零炮设置的准确率为 53.7%。对于少拍设置，给出的示例数量为 20 个。
SAT 类比示例|参考: GPT-3 研究论文，公共领域
新闻文章生成
在这个模型中，提供了标题和副标题，它需要用它们来写一篇 200 字左右的文章。该模型只在少数镜头设置上进行了测试，因为模型无法理解它是否需要写一篇文章或需要作为后续推文进行响应。
将 GPT-3 的性能与故意制造次品的控制模型进行了比较。人被用来区分物品是人做的还是模型做的。人类以 86%的准确度准确地检测到文章是由控制模型生成的。但是随着模型大小的增加，人类能够以 52%的准确度检测到文章是由模型生成的。
被该模型检测到的大多数文章包含错误的事实信息，或者有重复的句子和不寻常的措辞。
该模型也在具有 500 个单词的文章上进行测试，但是人类仍然只能区分 52%的人类文章。
由 GPT-3 生成的文章被检测到只有 12%的准确性|参考: GPT-3 研究论文，公共领域
当你用谷歌搜索上述文章中的任何一句话时，你会找到一些有着相似句子的不同主题的文章。很有可能，GPT-3 在整个互联网上接受的训练可能只是用不到 500 个字总结了相关主题的所有文章。而不是生成文章，它可能只是合并不同文章的各种句子，从而使文章类似于人类。如果我们提供非常独特的标题，我们将知道 GPT-3 是否能生成文章。
人类检测文章 500 字的准确率是人类写的还是模型写的|参考: GPT-3 研究论文，公共领域
学习和使用新单词
在这种情况下，测试模型在定义单词一次后是否可以在句子中使用该单词。
因此，为了测试这个任务的模型，单词定义被给定一次，所以一次性设置，但是提供了每个单词定义的例子，因此，关于任务描述的少量设置。
GPT 新协议中定义和使用新词的示例|参考:GPT 新协议研究论文
这些单词是人类造的，因此，模特事先对此一无所知。我们可以看到模型使用定义的单词生成了所有符合逻辑的句子。
纠正英语语法
测试该模型是否能够预测错误的语法并能够用正确的语法修改句子。该模型在少拍设置上进行了测试。
纠正英语语法|参考: GPT-3 研究论文，公共领域
正如我们所看到的，该模型是在非常基本的语法上进行测试的，而不是在复杂的语法上，如子句。很高兴看到模型在如此糟糕的语法上的表现，因为即使对人类来说，这也是一项复杂的任务。
测量和防止基准记忆
由于训练数据集是通过爬取互联网生成的，因此训练数据集可能包含各种测试集示例。如果发生这种情况，那么模型在各种任务上报告的准确性的置信度可能是不可靠的。
在训练数据集中搜索测试集示例，如果两个集中的 N 个单词相似，则认为文档匹配。n 等于每组单词中第 5 个百分位数的示例长度。较小的 N 值会导致大量不符合逻辑的匹配。因此，N 的最小值保持为 8，最大值保持为 13。根据最小长度匹配 n 个单词或整个句子。如果找到匹配，则该示例被认为是脏的，否则是干净的示例。
在 clean 数据集上对 GPT-3 进行了各种任务的测试，并将精确度与原始分数进行了比较。如果精度几乎匹配，则意味着即使存在污染也不会影响模型精度。如果准确度低于原始分数，则意味着污染夸大了结果。
基准污染分析|参考: GPT-3 研究论文，公共领域
对于数据集 QuAC，数据集内存在 0%的干净数据，但精度仍正向变化 20%，这肯定意味着它有问题。他们发现大约 90%的数据集被污染。但是，经过进一步的分析推断，训练集只包括段落，而不包括问题和答案。
GPT-3 有各种局限性，在文本合成等领域仍有改进的机会。GPT-3 是基于训练数据集，因此，不能认为它自己的。如果大多数人对性别、种族、宗教有偏见，那么这个模型也会代表这些偏见。更多的限制和偏见，你可以在这里阅读。麻省理工科技评论也发表了一篇关于 GPT-3 局限性的博客。
GPT-3 模型只是预测下一个单词应该出现。它不理解上下文，也不理解单词的实际含义。该模型缺乏逻辑推理和常识推理。模型输出可以通过调整数据集来改变。
这条推文显示了 GPT 的偏见-3 |推文由脸书公共领域副总裁 Jerome Pesenti 发布
以下是您了解 GPT-3 更多信息的重要资源:
[## 你可以通过这些 YouTube 视频了解 GPT 3
通过这些 YouTube 视频，在不到 3 分钟的时间内对 GPT 3 号有一个初步的了解
towardsdatascience.com](/you-can-understand-gpt-3-with-these-youtube-videos-6a30887c928b) [## 了解 GPT-3 -分析杂志的顶级免费资源
随着开放人工智能发布其前卫的预训练语言模型——GPT-3 突然成为了…
analyticsindiamag.com](https://analyticsindiamag.com/top-free-resources-to-learn-gpt-3/)
感谢您的阅读，祝您有美好的一天。
*斜体文字仅为个人观点
浙公网安备 33010602011771号