掌握 Git 和 GitHub 的基础知识
Photo by Max Duzij on Unsplash
软件工程
开始使用 Git & GitHub 所需要知道的一切
Prod 已关闭！这次又是什么？我们编写的测试用例涵盖了我们能想象到的所有用例——在我们昨天更新服务后，它们都通过了。如果我们能够回到过去，调查我们代码最近的所有变化，看看哪里出错了！这就是 Git 要解决的类型的问题。
在本文中，我将向您展示如何使用 Git 来跟踪项目中文件的历史，以便您能够在项目中出现 bug 时进行诊断。
Git 和 GitHub 有什么区别？
GitHub 是一个允许用户托管文件的网络应用程序，有点像 DropBox 或 Google Drive——但它是为托管 Git 库而设计的。 Git 是一个命令行工具，主要由程序员用来管理软件项目的版本管理(历史)。每个项目都存在于一个保留所有变更历史的 Git 仓库中。
1.安装 Git
通过下面的链接，你可以点击页面顶部你正在使用的操作系统来安装 Git。在你安装了 Git 之后，如果你在 Windows 上，进入你的命令提示符，或者如果你在 MacOS 或 Linux 上，进入你的终端。键入“git”并按回车键。如果你看到任何关于 Git 的信息，说明你安装正确！如果您得到“找不到命令”——尝试卸载并重新安装 git，或者重新配置您的环境变量。
Git 带有内置的 GUI 工具(git-gui，gitk ),但是有几个第三方工具供用户寻找一个…
git-scm.com](https://git-scm.com/downloads)
2.创建 GitHub 帐户
下面的链接会带你去 GitHub。在那里，您可以使用您的电子邮件地址设置一个帐户。
GitHub 汇集了世界上最大的开发人员社区来发现、共享和构建更好的软件。来自…
github.com](https://github.com/)
3.创建您的第一个存储库
在 GitHub 的任何页面上，当您登录时，您会在右上角工具栏中的个人资料图片旁边看到一个白色加号。单击加号将显示一个下拉菜单，您应该在其中选择:“新存储库”。在那里，您应该将存储库命名为“Master _ Git _ And _ GitHub _ Basics _ Article”——考虑到它们不允许在名称中使用空格。您不需要添加描述，并且可以启用默认的“公共”访问。对于本课，您不应该选中“用自述文件初始化”复选框，最后，您不需要添加一个. gitignore 文件或一个许可证 —因此您可以单击底部的“创建存储库按钮。
接下来的页面会有很多微小的吓人的文字。在此页面上，您需要担心的唯一信息是顶部标有“快速设置”的蓝色阴影框。在蓝色的“快速设置”框内，确保选择了“ HTTPS ”，而不是“宋承宪”。在菜单的最左侧有一个剪贴板图标按钮，您可以选择它将您需要的 URL 地址复制到您的计算机上。
在您的终端或 git bash 中，使用“ cd directory_name ”命令转到您想要放置存储库的目录。然后运行下面的命令( 用你从 GitHub 复制的 URL 替换我的 URL):
**git clone** [**https://github.com/ClairvoyantCoding/Master_Git_And_GitHub_Basics_Article.git**](https://github.com/ClairvoyantCoding/Master_Git_And_GitHub_Basics_Article.git)
Cloning the repository and then changing directory into the repository (Image by author)
运行该命令应该会在运行该命令的目录中创建一个空文件夹。你可以认为克隆一个库就像下载it — 但是更多。它还会下载对这些文件所做的所有更改的历史记录。让我们在命令提示符或终端中运行命令"CD Master _ Git _ And _ GitHub _ Basics _ Article"进入我们刚刚克隆的新存储库。现在我们已经在存储库中了，我们可以使用以下命令来获取存储库的状态:
**git status**
git status 命令将向我们展示自上次提交以来对我们的库所做的所有更改。对我们来说，它会说:
Checking the status of our repository using “git status” (Image by author)
注意:如果您的 Git Bash/Terminal/Command 提示符没有显示相同的配色方案和绿色的“(main #)”消息，不要担心。我将 Git Bash 配置文件配置为给我这些额外的颜色和消息。
所有这些告诉我们的是，我们还没有任何历史，因为我们没有任何提交。您可能想知道“branch main 上的是什么意思——但是我们将在下一篇文章中解决这个问题。现在我们将添加一些历史。
4.创建我们的第一个提交
在 Git 仓库中，我们在提交中记录历史。正如我们在 git status 输出中看到的，我们目前没有提交。为了创建一个提交，我们需要在我们的存储库中做一些更改。在文件资源管理器或 finder 窗口中创建一个新文件，并将其拖到存储库目录中。我的文件将只是没有内容的“ file.txt ”。现在，如果我返回到我的命令提示符或终端并运行" git status "，我将看到我的新文件:
Using the “touch” command to create a file and running “git status” to see the changes to the repository (Image by author)
现在你可以看到 git status 在向我们展示我们的变化时是多么有用。您会注意到 file.txt 文件列在未跟踪文件中。记住 Git 想要跟踪存储库中发生的所有变更——但是我们必须告诉它要跟踪哪些文件。为了使这一点更明显，让我们添加第二个名为 file2.txt 的文件，这样我们可以看到当我们跟踪一个文件而不跟踪另一个文件时会发生什么。在将第二个文件添加到存储库中并验证它在您运行" git status 时显示为未跟踪之后，我们将学习下一个 Git 命令:
**git add file.txt**
我们使用“git add”选择要跟踪的文件。请注意，我们只选择了第一个文件。现在，当我们运行 git status 时，我们得到了输出:
Creating file2.txt, adding file.txt so it’s ready to commit, and checking the status of the repository (Image by author)
请注意， file.txt 列在新标题下:“待提交的变更”，而 file2.txt 仍列在“未跟踪”下。请记住，我们并没有通过添加文件来跟踪任何东西——我们只是在提交时选择了要跟踪的文件。既然我们已经选择了要添加到提交中的更改，我们可以使用以下内容创建项目中的第一个提交:
**git commit -m "adding file.txt"**
该命令将创建我们的提交，并显示消息:“正在添加 file.txt ”。每一个提交都必须有一个消息来描述发生了什么变化，这样在未来就可以很容易地浏览我们的历史。让我们看看我们的提交命令的输出:
Commiting the file.txt we added in the previous step (Image by author)
这告诉我们，我们添加了一个新的提交，即“根提交”，因为这是第一个提交。未来提交将不会是“根提交”。我们的提交有消息“添加了 file.txt ”，它只包含一个文件更改，我们在那里创建了“ file.txt ”。最后，我们将学习另一个命令，该命令将按降序列出我们存储库中的所有提交:
**git log**
该命令输出:
Using git log to see all of our previous commits (Image by author)
只列出了一个提交，因为我们只有一个，它还告诉我们每个提交的作者、日期和消息。
5.推动你的改变
一旦您提交了您的更改——没有人能够在您的 GitHub 个人资料上看到它们，除非您使用以下命令推送您的代码:
**git push**
Pushing your changes from your local machine to your GitHub repository (Image by author)
现在，您的更改已经上传到您的 GitHub，供所有人查看。去看看！
See the file.txt file we pushed from our local repository to our GitHub online repository (Image by author)
注意， file2.txt 不在这里，因为我们没有选择提交它。我们可以点击屏幕中间工具栏最左边的“ 1 commit ”来查看我们所有的提交，就像 git log 向我们展示的那样。
6.现在怎么办？
现在你知道如何使用 git 命令了:克隆，状态，添加，提交，日志，以及推送。现在，您可以用新的变更不断更新您的存储库。 git 添加您更改的文件以选择它们为提交的。然后提交一条描述你做了什么的消息，然后将推送到 GitHub 让其他人看到。请继续关注下一个教程，在那里我们将学习所有关于使用 git 分支在我们的软件项目中与其他开发者合作的内容。
要学习更高级的 Git & GitHub 概念，你可以在这里阅读我的第二篇 Git & GitHub 文章
感谢阅读！我很乐意听到你的反馈或回答任何关于我的文章的问题，所以请在下面评论。
Google BigQuery 机器学习入门——泰坦尼克号数据集
W 虽然还在测试阶段，biqquery ML已经从去年年中开始发售；然而，直到最近，我才开始使用这个基于谷歌云的机器学习产品。作为一名非数据科学家，我的第一印象——有什么不喜欢的？毕竟，对于任何一个分析师来说，从基于 web 的 SQL 编辑器中舒适地运行 ML 模型的能力是梦想成真。这个平台不仅消除了学习编程语言的需要，无论是Python还是SAS；它还通过利用现有的 BigQuery 数据源简化了数据工程过程，而不必将外部数据引入到您的模型中。实际上，该产品消除了进入这一令人垂涎的数据科学专业的许多障碍，并通过允许任何具有足够的 SQL 知识的分析师运行线性和逻辑回归模型，而不必投资昂贵的硬件，例如通常需要支持可扩展 ML 项目的多核GPU。下图很好地展示了平台的功能:****
BigQuery ML demo from Google AI Blog
许多有抱负的数据科学学生转向值得信赖的 泰坦尼克号:机器从灾难中学习 来自最受欢迎的 Kaggle 竞赛的数据集来练习使用二进制分类模型。事实上，对于一个初学者来说，二元分类模型是一个相当容易掌握的概念:你的任务是简单地预测某个事件是否会发生；或者某个条件将评估为真还是假。对于这个问题，任何人都能够理解这样一个概念，即预测一名特定的泰坦尼克号乘客是否能在有史以来最具纪念意义的沉船事故中幸存下来:这里只有两种可能性。要跟进，你只需登录现有的 Kaggle 帐户或创建一个新的帐户，并下载所有三个文件提供。使用 Kaggle 网站(谷歌早在 2017 年就收购了)和 BigQuery 平台(谷歌的另一款产品)的讽刺意味并没有在我身上消失。让我们使用示例数据集和一个工作中的 BigQuery 实例来深入研究这个问题。**
我们可以应用不同的分析框架来确定需要哪些步骤来完成手头的任务。对我有效的方法通常包括以下内容，让我们在机器学习过程中采用它:
- 了解你的数据
- 争论你的数据
- 执行分析
不言而喻，理解我们在这里试图完成的是什么是理所当然的。与你可能面临的任何业务问题类似，我们必须准确理解这项工作的目标是什么:选择相关因素来帮助我们准确预测某个乘客是否能在泰坦尼克号失事中幸存。
第一步——探索泰坦尼克号数据集
A .定义数据
首先，让我们看看 Kaggle 为我们提供的数据。我们可以将三个 CSV 文件:训练和测试数据集，以及性别 _ 提交作为可供我们分析的三个数据库表。我们将使用训练集来建立我们的机器学习模型，同时我们将在测试集上运行模型来预测结果(沉船的存活率。)提交表可以作为一个模板，我们可以通过将结果提交给 Kaggle 进行评分来测试我们预测的准确性。根据数据字典，在我们的训练表中有相当多的字段，我们可以在预测存活率的解决方案中考虑这些字段:****
passengerid—分配给每位乘客的唯一 ID；
幸存——幸存标志，其中 1 的值表示乘客幸存， 0 表示遇难乘客——这代表我们试图预测的目标值；
Pclass —旅客的车票等级，也可以解释为社会经济地位的代理: 1 代表头等车票/上层市民， 2 代表二等车票/中层，而 3 代表三等车票持有者/下层市民；
姓名 —乘客姓名；
性别 —乘客的性别，请记住，为了建立模型，我们需要将这种字符串类型的记录转换为数字数据类型；
年龄 —乘客的年龄(年)；
SibSp —一起旅行的兄弟姐妹/配偶人数；
Parch —一起旅行的父母/子女人数；
车票 —旅客的车票号码；
票价 —乘客票价，该乘客为其车票支付了多少钱；
客舱—分配给乘客的客舱号；
已装船—装船港( C =瑟堡， Q =皇后镇， S =南安普顿)
B .确定丢失了什么
我们可以从查看数据集中缺失的**值开始。当处理像我们这样的小数据集时，快速抽查通常就足够了。事实上，只要浏览记录，我们就可以确定只有三个字段缺少值:年龄、船舱和上船。为了量化丢失值的影响，让我们对这些数据运行第一个 SQL 查询:****
似乎五分之一的记录缺少年龄值，而四分之三的舱室记录找不到，891 个记录中只有两个缺少登船标志:****
请注意，我在查询中使用了标准 SQL ，并将我们的训练数据导入到保存在 BigQuery 实例中的 dataset_Titanic 数据集内的 prj-titanic 项目的 tbl_train 表中。**
实际上，不是所有可用的变量(或我们应该选择在模型中使用它们的特征)都应该在任何给定的预测模型中使用；在泰坦尼克号数据集的情况下，我们可以从有史以来票房第二高的电影中回忆起 妇女和儿童优先 政策对妇女和儿童有利，他们在使用救生艇方面享有优先权。头等舱乘客似乎是下一个受青睐的群体。让我们研究我们的数据，看看事实上性别、年龄和阶级是否可以很好地预测乘客的存活率。
C .哪些数据是相关的？
下面的快速查询验证了上述关于性别维度的假设。根据提供的数据，女性几乎是 4(！)比男性更有可能在这次事故中幸存下来:
**********
Survival rate by gender
请注意，上面的图表来自无缝的 BigQuery 和 DataStudio 集成；来自谷歌的真正端到端探索性数据分析解决方案。
当查询存活率的 Pclass 变量时，我们还可以确认乘客类别实际上应该是我们模型的特征/预测值之一:
Survival rate by passenger class
当涉及到可视化数据时，使用分类数据比使用连续数据类型的值要容易得多。在我们绘制年龄变量的结果之前，让我们对不同年龄段的乘客进行分类。你可能会想到更好的解决方案，但我个人会使用五个年龄组:
**儿童-13 岁以下
**少年-13 至 18 岁之间
青壮年 -年龄在 19 至 35 岁之间
成年- 36 至 55 岁年龄段
**老年公民——55 岁以上。
当我们运行新的查询时，很明显，儿童的存活率确实比其他年龄组高得多。青少年占据了第二的位置:
**********
Survival rate by Age category
自然，很难想象诸如姓名、乘客 ID 、车票等类似的字段可能与生存有任何关系，然而其他不太直观的字段实际上可能是有帮助的。如果我们按开始的类别来看存活率，会发生什么？忽略两个显示 100%存活率的缺失记录，瑟堡在存活率方面从其他两个港口中脱颖而出，皇后镇比南安普顿更受欢迎:
Survival rate by port of embarkation
步骤 2—数据清理
A .处理缺失值
完成 EDA 过程后，是时候让我们参与一些基本的数据争论任务了。假设我们热衷于使用上面讨论的所有四个字段:年龄、性别、**p 类和已着手，我们需要考虑 177 缺失年龄值和 2 已着手值。
让我们根据我们所知道的关于乘客的一切来推断出装货港。最简单的解决方案是根据乘客的登机点来查看乘客的分布情况，南安普敦代表了所有乘客的 72% :
Number of passengers by port of embarkation
此外，我们可以考虑使用 PClass 信息来查看大多数头等票持有者是否从特定的港口出发。在以下查询的帮助下，我们可以确定 59% 的乘客也是从南安普顿出发的:
完成该任务的另一种方法是查看舱室信息是否可用于填充这些缺失值。经过一些基本的搜索我们可以得知舱字段的第一个字母指的是甲板，这自然与乘客等级值高度相关。在我们的例子中， B 恰好代表长廊(不要与上层长廊混淆)甲板。看看这个甲板上已知的装载港口的乘客分布，这是一个公平的掷硬币决定，大约一半的人( 51.11% 准确地说)从南安普顿开始他们的旅程，剩下的一半来自瑟堡。
总结以上所有发现，让我们大胆地(经过计算)假设缺失的上船值应该被赋值为 S 【南安普顿】的值。]处理 177 缺失的年龄值并不简单，部分原因是这个样本的大小，部分原因是数据集中缺少可靠的预测因子。我们也许可以通过查看乘客的名字来解读他们的头衔，并做出可靠的假设，即所有已婚乘客(夫人等)肯定不是孩子。除了查看数据中的平均值或众数，放大他们的实际年龄会变得更加困难。让我们简化我们的生活，在这里采取简单的方法:让我们忽略所有缺少年龄值的记录，希望有足够大的剩余数据集用于我们的预测模型。
B .为模型准备数据
说到模型，它们不能很好地处理文本/字符串数据类型，我们需要将所有这些字段转换成数值。例如，对于性别字段，我们或许可以将值 1 分配给所有男性，将值 0 分配给所有女性。****
转到头等舱领域，我们可以从之前的观察中回忆起，头等舱的乘客比二等舱的乘客更有可能存活。然而，如果我们仅使用 1 和 2 的名义值用于各自的票等级，这种关系将被错误地解释为二等票乘客比一等票持有者更有可能死亡 两倍于 。我们可以通过创建三个字段(每个乘客等级一个)并相应地标记记录来扩展这种关系。头等票持有者将在 PClass1_Flg 字段中具有值真(读:1)，并且对于 PClass2_Flg 和 PClass3_Flg 列具有值假(读:0):****
我们将对年龄类别字段应用类似的原则，并根据乘客年龄组创建五个新字段来标记记录。**
第三步——运行我们的机器学习泰坦尼克号模型
A .创建我们的模型
我们终于完成了所有的准备工作，准备进入项目的最后阶段。为了演示创建我们的模型是多么容易，让我们遵循下面的 BigQuery ML 语法，并运行我们的第一个基于单一特征的逻辑回归模型——性别:
******CREATE OR REPLACE MODEL `ModelName`
OPTIONS (model_type = 'logistic_reg') AS
SELECT field(s) FROM TableName******
Who knew that it only takes a couple of lines of SQL code to create a Machine Learning model?
B .评估模型结果
评估我们的模型只需要一行代码，结果看起来相当有希望
******SELECT * FROM ml.evaluate(model `ModelName`)******
运行我们的模型
关键时刻到了，让我们对照测试数据运行我们的模型，让我们创建一个包含模型结果的表格:**
SQL Code for the table containing model predictions
处理单个功能/专栏并不困难，但是我们从 EDA 中回忆起，性别似乎是生存的最佳预测因素。是时候将这个表格保存为 CSV 格式，并制作我们的 Kaggle submission 。这个相当轻松的练习产生了 76.55% 的准确率，使我们在所有 Kaggle 参赛者中名列前茅 74% 。不需要太多的分析能力就可以看出，这个分数实际上是与其他 1，481 名竞赛参与者共享的，因此，实际上，我们处于前 60% ！从这里开始肯定有成长的空间，但对于第一次尝试来说不会太寒酸。
Kaggle ranking for the first submission
D .实验和优化
测试和迭代绝对是这里的精神。我们可以通过使符合我们的需求来进一步试验这个模型，可以改变学习率、设置正则化、限制迭代次数等等。所有这些参数都可以在模型语句的选项部分找到。**
此外，我们可以尝试通过改变所使用的特征来提高我们的模型的准确性；让我们使用这种方法。我非常难过地意识到，通过添加额外的特征(年龄类别、乘客级别和装载港口)，模型的准确性实际上下降了:
Another less successful Kaggle submission
我们应该可以做得更好，对吗？如果我们考虑到这样一个事实，即家庭成员呆在一起互相帮助可能会有更好的生存机会。幸运的是，我们可以加上一起旅行的父母/孩子的数量( parch )和兄弟姐妹/配偶的数量( sibsp )来计算家庭的总人数。这有助于了解根据我们之前的 EDA，这两个字段中没有缺失值。还请注意，独自旅行的乘客在任一字段中都会有 0 值。让我们建立一个新的、更全面的、更准确的模型:
这种策略是正确的，我们略微提高了我们提交的准确性到 77% ，并向上移动了 1476 位，绕过了所有使用性别作为唯一预测指标的人。我们现在只与 583 家竞争对手分享我们的位置，实际上使我们进入了前 54% ！
我不确定我们可以达到什么样的实际准确度水平，(排行榜上所有 95%以上的分数看起来都很可疑)，但要记住的一点是，模型的类型可能在这里发挥作用，也许随机森林可以产生比分类更好的结果？尽管如此，要提高我们的分数，还有很多工作要做。
如果你正在寻找接下来的步骤，谷歌确实为两者提供了 BigQuery ML 入门指南:数据分析师和数据科学家赛道。祝你的机器学习之旅好运！请分享你的想法和使用的方法，如果你在你的结果中更成功的话！
2019 年 3 月 31 日编辑——感谢 Felipe Hoffa 提供的非常翔实的评论，我了解到我上面使用的一些代码实际上是多余的；事实上，BigQuery 让事情变得更加简单。
替换此代码:
****CREATE OR REPLACE MODEL `xxx.xx`
OPTIONS (model_type='logistic_reg') AS
SELECT Survived AS label,
CASE WHEN Sex = 'male' THEN 1 ELSE 0 END AS Gender****
有了这句话:
****CREATE OR REPLACE MODEL `xxx.xx`
OPTIONS (model_type='logistic_reg') AS
SELECT Survived AS label,
Sex****
如果你想学习更多的 BigQuery 和 BigQuery ML 技巧和诀窍，请阅读 Felipe 的精彩文章和他到目前为止分享的所有其他文章。
附注抱歉，菲利普，旧习难改:我把你的例子中的前导逗号换成了我的尾随逗号。
Google Colab 入门
为沮丧和困惑的人准备的简单教程
Photo by FuYong Hua on Unsplash
你知道它就在那里。你知道在某个地方有免费的 GPU，就像一个胖胖的，多汁的，成熟的黑莓挂在稍微够不着的树枝上。
美丽的闪电般的速度只为你等待。
想知道到底如何让它工作？你来对地方了！
Photo by Breno Machado on Unsplash
对于任何还不知道的人来说，谷歌已经做了有史以来最酷的事情，它提供了基于支持免费 GPU 的 Jupyter 笔记本的免费云服务。这不仅是一个提高你的编码技能的伟大工具，而且它还允许任何人使用流行的库来开发深度学习应用程序，如 PyTorch 、 TensorFlow 、 **Keras、**和 OpenCV。
Colab 提供 GPU，而且完全免费。说真的！
当然，这是有限度的。(当然，具体细节可以在他们的常见问题页面上找到。)支持 Python 2.7 和 3.6 ，但还不支持 R 或 Scala 。你的会话和大小是有限制的，但是如果你有创造力并且不介意偶尔重新上传你的文件，你肯定可以绕过它…
Colab 是从提高 Python 编码技能到使用深度学习库的理想选择，比如 PyTorch 、 Keras 、 TensorFlow 和 OpenCV 。你可以在 Colab 中创建笔记本，上传笔记本，存储笔记本，共享笔记本，安装你的 Google Drive 并使用你存储在那里的任何东西，导入你最喜欢的目录，上传你的个人 Jupyter 笔记本，直接从 GitHub 上传笔记本，上传 Kaggle 文件，下载你的笔记本，以及做你想做的任何事情。
太牛逼了。
第一次在 Google Colab 中工作完全是惊人的简单，但是也有一些小的挑战！如果你对 Jupyter 笔记本有所了解的话，你可以使用 Google Colab，但是有一些小的区别可以让你在自由的 GPU 上自由飞翔和坐在电脑前用头撞墙…
Photo by Gabriel Matula on Unsplash
这篇文章是写给那些困惑、沮丧、只想让这件事成功的人的！
设置您的驱动器
为你的笔记本创建一个文件夹
(从技术上讲，如果你想开始在 Colab 中工作，这一步并不是完全必要的。然而，由于 Colab 是在您的驱动器之外工作的，所以指定您想要工作的文件夹并不是一个坏主意。你可以去你的 Google Drive 点击“新建”,然后创建一个新文件夹。我之所以提到这一点，是因为我的谷歌硬盘上令人尴尬地散落着看起来像一百万个零散的 Colab 笔记本，现在我不得不处理这些。)
如果你愿意，当你已经在你的 Google Drive 中的时候，你可以创建一个新的 Colab 笔记本。只需点击“新建”，将菜单下拉至“更多”，然后选择“合作实验室”
否则，你可以直接去谷歌实验室。
游戏开始。
您可以通过单击笔记本的名称并更改它，或者通过将“文件”菜单下拉到“重命名”来重命名您的笔记本
设置您的免费 GPU
想用 GPU？就像进入“运行时”下拉菜单，选择“更改运行时类型”，在硬件加速器下拉菜单中选择 GPU 一样简单！
获取编码！
如果您愿意，现在就可以轻松地开始运行代码！你可以走了！
让它变得更好
想要安装您的 Google Drive 吗？使用:
from google.colab import drive
drive.mount('/content/gdrive')
然后你会看到一个链接，点击它，允许访问，复制弹出的代码，粘贴到框中，点击回车，你就可以开始了！如果你没有在左边的边框中看到你的驱动器，只需点击“刷新”,它就会显示出来。
(运行单元，单击链接，复制页面上的代码，将其粘贴到框中，按 enter 键，当您成功安装驱动器时，您会看到这一点):
现在，您可以在屏幕的左侧看到您的驱动器！(您可能需要点击“刷新”)此外，您可以通过以下方式随时找到您的驱动器
!ls "/content/gdrive/My Drive/"
如果您想下载一个共享的 zip 文件链接，您可以使用:
!wget
!unzip
例如:
!wget -cq [https://s3.amazonaws.com/content.udacity-data.com/courses/nd188/flower_data.zip](https://s3.amazonaws.com/content.udacity-data.com/courses/nd188/flower_data.zip)
!unzip -qq flower_data.zip
这将在几秒钟内为您提供 Udacity 的花卉数据集！
如果你上传的是小文件，你可以用一些简单的代码直接上传。然而，如果你愿意，如果你不想运行一些简单的代码来获取一个本地文件，你也可以只去屏幕的左侧，并点击“上传文件”。
谷歌 Colab 在几乎每个层面上都非常容易使用，尤其是如果你对 Jupyter 笔记本非常熟悉的话。然而，抓取一些大文件并让几个特定的目录工作确实让我犯了一两分钟的错误。
我在另一篇文章中介绍了开始使用 Google Colab 中的 Kaggle，所以如果你对此感兴趣，请查看一下！
导入库
进口是相当标准的，除了少数例外。
在大多数情况下，你可以像在其他笔记本上一样运行import来导入你的库。
PyTorch 不一样！在运行任何其他 Torch 导入之前，您需要运行
更新！(01/29) Colab 现在支持原生 PyTorch！！！你不需要运行下面的代码，但是我把它留在这里，以防有人有任何问题！
# [http://pytorch.org/](http://pytorch.org/)
from os.path import exists
from wheel.pep425tags import get_abbr_impl, get_impl_ver, get_abi_tag
platform = '{}{}-{}'.format(get_abbr_impl(), get_impl_ver(), get_abi_tag())
cuda_output = !ldconfig -p|grep cudart.so|sed -e 's/.*\.\([0-9]*\)\.\([0-9]*\)$/cu\1\2/'
accelerator = cuda_output[0] if exists('/dev/nvidia0') else 'cpu'!pip install -q [http://download.pytorch.org/whl/{accelerator}/torch-0.4.1-{platform}-linux_x86_64.whl](http://download.pytorch.org/whl/{accelerator}/torch-0.4.1-{platform}-linux_x86_64.whl) torchvision
import torch
然后你可以继续进口。如果你试图简单地运行import torch，你会得到一个错误信息。我真的建议点击弹出的非常有用的链接。如果你这样做，你会得到代码的权利，你可以只点击“安装火炬”将其导入到您的笔记本电脑。代码会在你屏幕的左侧弹出，然后点击“插入”
不能用 import 语句简单地导入您想要的其他东西？尝试 pip 安装！请注意，Google Colab 希望在大多数命令前有一个感叹号。
!pip install -q keras
import keras
或者:
!pip3 install torch torchvision
并且:
!apt-get install
也有用！
我确实发现枕头可能有点问题，但是你可以通过跑步来解决
import PIL
print(PIL.PILLOW_VERSION)
如果你得到低于 5.3 的任何东西，进入“运行时”下拉菜单，重启运行时，并再次运行单元。你应该可以走了！
通过将“文件”拖放到“新 Python 3 笔记本”，可以很容易地创建一个新笔记本。如果你想打开某个特定的东西，把“文件”菜单下拉到“打开笔记本…”
然后你会看到一个类似这样的屏幕:
如你所见，你可以打开一个最近的文件，来自你的 Google Drive 的文件，GitHub 文件，你也可以在那里上传一个笔记本。
GitHub 选项很棒！您可以轻松地按组织或用户进行搜索来查找文件。如果您没有看到您要找的内容，请尝试检查存储库下拉菜单！
永远储蓄
保存您的工作很简单！你可以做好 ol 的“command-s”或者下拉“File”菜单来保存。您可以通过拖放“文件”->“在驱动器中保存副本”来创建笔记本的副本你也可以通过“文件”->“下载”来下载你的工作簿。ipyb”或“下载. py”
这至少应该足以让您在 Colab 上运行，并利用那个可爱的免费 GPU！请让我知道，如果你遇到任何其他的新手问题，我也许可以帮助你。如果可以的话，我很乐意帮助你！
如果你想接触或找到更多酷的文章，请来和我一起在内容简约！
如果你是数据科学、机器学习和人工智能的新手，你可能想看看 NumPy 的终极初学者指南！
开始使用 NumPy 需要知道的一切
towardsdatascience.com](/the-ultimate-beginners-guide-to-numpy-f5a2f99aef54)
或者你可能对其中的一个感兴趣！
- 如何毫不费力地用 GitHub 页面免费创建一个网站(即使你不知道自己在做什么)
- 数据清理和预处理完全入门指南
- WTF 是图像分类？
- 深度学习简介:为新手和新手征服神经网络
- 如何构建准确率大于 97%的图像分类器
或者也许你想知道如何让你自己的帖子被注意到！
创建内容的简单技巧，易于查找，阅读起来令人兴奋
medium.com](https://medium.com/swlh/how-to-write-and-publish-articles-that-get-noticed-60e9701daed4) 
Photo by Sarah Cervantes on Unsplash
感谢阅读！❤️
使用 Flow 开始使用 H2O
看看 H2O 的开源 UI，它将代码执行、文本、情节和富媒体结合在一个文档中。
[
](http://Image by PublicDomainPictures from Pixabay)
数据收集很容易。做决定很难。
今天，我们可以访问海量的数据，这些数据每天都在增加。这主要是由于数据收集能力的激增和存储这些收集的数据的计算能力的增加。然而，收集数据是一回事，理解数据完全是另一回事。从数据中获得洞察力应该是快速和容易的，并且获得的结果应该是容易解释和说明的。H2O 提供了一个单一的平台，通过更快更好的预测建模，使评分和建模成为可能。
【H2O】是一个分布式可扩展机器学习的内存平台*。顺便说一句，H2O 既是产品的名字，也是产品背后的公司( H2O.ai )的名字。它是完全开源的，使用大家熟悉的接口，比如 R、Python、Scala、Java、JSON，甚至还有一个 web 接口。H2O 的最新版本被称为 H2O-3，它可以与 Spark 和 Hadoop 等多种大数据技术无缝合作。还有，H2O 支持很多常用的机器学习算法，比如 GBM 、随机森林、深度神经网络、 Word2Vec 、堆叠集成等等。*
High-Level architecture of H2O
请随意查看我的文章，标题为 与 H2O 一起民主化机器学习 ，这篇文章概述了 H2O 及其安装和使用。
H2O 流
H2O 流 是 H2O 的独立接口。我们可以使用浏览器指向本地主机，然后直接与 H2O 引擎通信，而不必处理 Python 或 R 或任何其他语言。它是一个很棒的工具，可以通过一个简单的 web 界面，使用 H2O 所有可用的优秀算法快速建立数据模型，无需任何编程。人们可以很容易地运行神经网络，GBM，GLM，K-means，朴素贝叶斯等。只需点击几下。
Flow 是 H2O 的一个基于网络的界面，是新用户入门和学习 H2O 提供的所有可用功能和算法的好方法。
Flow 可以被认为是用于探索性数据分析和机器学习的GUI++REPL+讲故事环境的混合体，具有异步、可重写的记录/回放功能。这里有一份关于 H2O 流量的优秀的 用户指南 供阅读更多相关内容。
设置
H2O 在 Java 上运行，这是它工作的先决条件。H2O 使用 Java 7 或更高版本，你可以在 Java 下载页面获得。
从这个链接下载 H2O，并遵循下面定义的步骤。
Installing H2O
安装运行后，将浏览器指向http://localhost:54321进入流程界面。
连接
*如果你用过 Jupyter Notebook，Flow 的界面会显得很熟悉。就像在 Jupyter 笔记本里一样，Flow 也有两种单元格模式:**编辑和命令。*访问此链接了解更多关于单元模式的信息。
Flow Interface
工作
Flow 将命令作为一系列可执行单元发送给 H2O。可以对单元格进行修改、重新排列或保存到库中。在 Flow 中，我们可以在文本单元格和可执行单元格之间切换，我们可以键入或让 H2O 生成一个可编程运行并在用户之间共享的 CoffeeScrip t。要执行单元格，点击CTRL+ENTER 或使用工具栏中的Run 图标。
现在让我们在 Flow UI 中使用 H2O 来处理一个机器学习问题，并仔细看看它的各种功能。
使用 H2O 预测客户流失
预测客户流失是客户关系管理(CRM)领域的一个众所周知的问题，也是现代营销策略的一个关键要素。留住客户对组织来说非常重要，我们将看到 H2O 如何通过快速创建预测模型，然后利用这些见解来提高客户忠诚度，从而在数据科学管道中发挥重要作用。
使用的数据集属于 2009 KDD 杯挑战赛。这也可以在流程界面的Examples > Browse installed packs > examples > KDDCup 2009_Churn.flow 下访问。或者，使用以下链接分别访问培训和验证数据:
这是我们将用来执行训练和预测的流程管道。
Machine Learning Pipeline
1.导入/上传数据
在自动完成搜索输入字段中输入文件路径，然后按 Enter 键。从搜索结果中选择文件，并点击Add All 链接进行确认。我们也可以上传一个本地文件，或者直接提到数据集的 url。
让我们看看如何将训练数据导入到流接口中。
解析数据
下一步是解析导入的数据。我们可以选择解析器的类型，但大多数情况下，H2O 会自动为我们找出答案。在解析设置页面中，我们可以选择列名和列类型。对于 churn 列，让我们将数据类型从 numeric 改为 enum ，它代表分类变量。Churn 列是响应列，因此在模型构建过程中，该列将自动扩展为虚拟变量。
接下来，当您点击parse按钮时，数据被解析并转换成.hex格式。
也可以通过点击相应的列来可视化每个标签数据。让我们想象一下流失列及其各种分布。
建筑模型
在我们继续模型构建过程之前，需要做两件重要的事情:
- 输入缺失数据
点击Data选项卡下的估算选项，选择数据集所选列的估算标准。
- 将数据拆分为训练集和测试集。
通过指定分割比率来实现分割数据，并相应地创建训练和测试帧。点击数据下拉菜单，选择分割框。
- 建立一个 GBM 模型
一旦您完成了对数据的探索，您就可以开始构建将投入生产的预测模型。点击Model选项卡，Flow 弹出所有可用算法的列表。H2O 支持各种各样的算法，从 GLM 到 GBM 到 AutoML 到深度学习。以下是完整的列表:
为了这篇文章，我们将构建一个通用助推机 (GBM)，这是一种前向学习的集成方法。选择数据集和响应列，并将所有其他选项保留为默认值，然后构建模型。
查看模型
我们还可以查看模型结果，这有助于我们快速判断模型的表现。我们得到了评分历史、ROC 曲线、变量重要性和许多其他相关信息，这些信息对判断我们模型的性能非常有帮助。
验证数据的预测
在我们构建并调整了模型的参数以获得一些合适的指标之后，我们就可以对我们的验证数据集进行预测了。将验证数据集导入流程界面，并点击分数>预测选项卡，进行必要的预测。
生产模型
数据科学家的最终目标不仅是构建一个健壮的模型，而且是一个可以轻松投入生产的模型。H2O 允许您将您构建的模型转换成一个普通的旧 Java 对象或优化的模型对象。H2O 生成的 MOJO 和 POJO 模型旨在易于嵌入到任何 Java 环境中。因此，如果有一个用于监控客户流失的内部应用程序，我们可以轻松快速地导出一个普通旧 Java 对象(POJO) ，并进一步将其传递给开发人员，以将其集成到他们现有的应用程序中。这样，我们的预测模型可以成为我们业务流程的一部分。
结论
流程的独特之处在于，用户可以通过点击整个工作流程。然而，这种点击机制还会生成一个 CoffeeScript，可以对其进行编辑和修改，并可以保存为笔记本进行共享。因此，一直以来，我们不会盲目地点击并运行，但我们知道每一个被执行的单元格背后的代码。
关于 H2O 的进一步阅读:
互联网数据分析入门:流量分析
数据分析的本质其实就是做数据对比分析。没有数据对比，往往很难用单一指标统计来发挥数据的价值。在本帖中，我将以互联网行业为背景进行数据业务分析，希望分享一些我在流量分析方面的经验。
比如我们计算公司 2018 年 1 月 29 日的同比流量。可以直接对比 2017 年 1 月 29 日的流量吗？仔细看这两个日期，会发现 2018 年 1 月 29 日是星期一，2017 年 1 月 29 日是星期天。对于很多行业的公司来说，非工作日和工作日的数据往往差别很大。这个时候，直接从日期层面去比较它们是没有意义的。选取 2017 年 1 月 30 日周一的流量数据进行对比可能更有价值。
简而言之，在互联网流量数据分析方面，有四种通用的数据分析方法。
- 比较和分析流量模式，调整不同时间段的企业服务和促销活动。
- 对比分析结构和比例，指导目标群体的营销。
- 对比分析异常情况，发现问题及时调整策略。
- 比较和跟踪活动流程的变化，总结活动的经验，以便进行后续有针对性的调整。
接下来，我们使用 FineReport 创建流量数据分析模板。然后，我们试着对数据做一些比较分析。
1.用户视图的每周分布
对于互联网公司来说，流量数据往往与工作周有关。对此，我们可以宏观计算一下周一到周日的平台总流量数据。首先，我们仔细观察工作日和非工作日的数据。我们发现周末的流量高于工作日的流量，这是互联网行业的普遍现象。
Made with FineReport
明确了用户流量的周分布后，我们就有了大致的推广方向。周末的用户群更大，所以相对于工作日，我们可以在周末投入更多的推广活动来引导新用户，维持老用户的活跃度。
然后我们思考下一步:我们如何安排工作日和周末的活动推广时间？
我们可以分析工作日和周末的用户流量趋势，我们在特定时间段进行推广，这样就可以用更低的成本获得更多的用户流入。
我们先来统计一下每个工作日的流量时间分布。我们用 FineReport 做出如下流量分布图。可以看出，工作日的流量主要集中在每天的 9:00、13:00、20:00。所以在得到用户流量规律后，我们就可以在用户活动高峰期多做产品推广，达到成本最低，吸引流量最多。
Made with FineReport
与工作日不同，周末的交通高峰在 10 点以后开始。针对周末用户流量分布的特点，互联网公司应该延迟推广时间。
Made with FineReport
2.推广渠道流量分配
互联网行业的推广渠道主要分为三种:线上渠道、线下渠道、新媒体。比较和分析每个渠道对企业的价值，制定有针对性的营销策略。
Made with FineReport
如上图所示，由于推广渠道是多层次的，我们用 FineReport 的多层饼状图来统计数据。从下图的数据可以看出，一级渠道的主要战力来自于新媒体营销。如今，像脸书和推特这样的社交媒体拥有广泛的受众和庞大的用户群。公司需要在这些渠道中投入大量的推广费用。
其次，线上渠道的效果也不容忽视。也是做好搜索引擎优化(SEO)的重要一环。相比线上渠道和新媒体营销，线下渠道需要更多的资金、时间、人力成本，受众相对较少，所以这类活动往往是针对核心粉丝而办的。
Made with FineReport
3.月度指标趋势对比
在分析月度指标的数据之前，我们先简单介绍一下互联网营销的一些常用指标:
- 页面视图
- 访问
- 唯一访客
我们用以上三个基本指标来衡量流量数据量。此外，平均访问深度(总浏览量/访问量)、平均在站时间(总在站时间/总浏览量)、跳出率(跳出率/访问量)都可以用来衡量流量指标的优劣。
Made with FineReport
分析上图中的流量指标可以发现，10 月份是 2017 年的流量高峰，应该和公司在节假日做的促销活动有关。浏览量、点击量和访问量分别为 4941、1290 和 2182。通过计算我们得到的跳出率为 59.12%，明显低于其他时间段的跳出率。所以可以借鉴 10 月份的促销活动。
Made with FineReport
最后，我们分析用户的访问深度(跳出率=跳出率/访问量)。我们使用 FineReport 分析企业不同时间段的 VIP 用户、老用户、新用户的统计数据。
总体来看，VIP 用户的访问深度略高于老用户和新用户，但并不太明显，说明 VIP 群体的活跃度还有待提高。同时，老用户的访问深度和新用户几乎一样。公司显然需要在用户活跃度的运营上投入更多。建议结合忠诚度较高的老用户和 VIP 用户，构建平台生态圈。并且可以对老用户和 VIP 用户实行一些优惠政策，比如有针对性的商品折扣，基于用户画像的优惠商品推送等。
好了，以上都是我的一些流量分析经验。我将继续分享互联网运营中的转化、消费和留存技巧。欢迎大家交流互联网数据分析方法。
您可能也会对…感兴趣
原载于 2019 年 7 月 16 日http://www.finereport.com。
Kaggle 入门
介绍
Kaggle 是一个了不起的社区，让有抱负的数据科学家和机器学习实践者聚集在一起，在竞争环境中解决数据科学相关的问题。许多统计学家和数据科学家在一个友好的社区中竞争，目标是为预测和分析数据集生成最佳模型。任何拥有数据集和需要解决问题的公司都可以从 Kagglers 中受益。Kaggle 不仅为数据科学项目提供了专业的设置，还为新人开发了一个学习和实践数据科学和机器学习技能的环境。
这个博客将作为对 Kaggle 平台的介绍，并简要介绍加入比赛、参与讨论、创建内核和排名的过程。
Kaggle 级数系统
Kaggle 有一个排名系统，可以帮助数据科学家跟踪他们的进展和表现。奖牌是为完成的某些活动而颁发的。当一个卡格勒获得足够多的勋章在升级系统中上升一级时，他们就会升级！
Kaggle 排名可以来自三个不同的“专业类别”:竞赛、内核和讨论。
三类各有五个等级:新手、贡献者、高手、高手、特级大师。Kaggle 的大部分用户被认为是“新手”，这实质上意味着他们没有与社区互动，没有运行任何脚本或提交任何比赛。新手级别以上的每个用户都提交过数据，并使用数据集进行预测和分析。
给聪明人一句话，向 Kaggle 上的每个人学习，尤其是那些排名较高的人！Kaggle 取得巨大成功的原因之一是其学习友好的环境和学习新技能的便利性。观看关于数据科学技术的视频教程是一个很好的开始，但是没有什么比通读一位经验丰富的数据科学家的内核和解释，然后在自己的模型中使用您学到的技能更有价值的了。
讨论板
讨论板是一个提问、回答问题和与社区互动的好地方。总有一些人贴出我们可以借鉴的伟大问题的答案。还有一个“入门”论坛，供想要学习 Kaggle 平台背后的基础知识的新 ka ggler 们使用。Kaggle 在讨论板中提供了六个独特的论坛，每个论坛都有不同的目的。
数据集
你需要任何种类的数据用于 T2 科学项目。Kaggle 在其“数据集”选项卡中提供了大量可用的数据集。截至这篇博客发表时，已经有超过 17，730 个公开的数据集。可以通过多个过滤器对数据集进行排序，以准确找到您要查找的内容。一旦你找到你想要的数据集，你只需点击它，然后点击“下载”将数据下载到你的机器上。
开始你的第一场比赛！
在 Kaggle 的“竞赛”标签下，有许多你可以参加的竞赛。这就像“数据集”选项卡，在这里您可以单击竞争对手并为您的模型下载数据。有一些比赛是专为初学者设计的，目的是让他们进入并学习 Kaggle 和数据科学的基础知识。其中一个初学者友好竞赛是著名的 MNSIT 数据集，我们将在其中创建一个模型，该模型将对手写数字进行分类，并根据测试数据进行预测。这篇博文将使用 MNIST 数据集，也将向竞赛提交预测。我们需要做的第一件事是查看我们的数据，并开始考虑建立我们的模型。首先，我们可以启动一个新的内核。
核心
根据 Kaggle 的文档，内核是云计算环境，支持可重复和协作的分析。内核允许 Kaggler 在浏览器中创建和运行代码，而不需要在他们的机器上下载 Python 和包。Kaggle 提供的一种内核是笔记本。如果你熟悉 Jupyter 笔记本，那么你熟悉 Kaggle 的笔记本，因为它们是一回事！
我们需要创建我们的内核，为此，我们可以点击“创建内核”并选择“笔记本”选项，在 Jupyter 笔记本中进行分析。笔记本打开后，你会注意到一些预先写好的代码，称为“启动代码”。Starter 代码将导入一些公共库，并将打印数据文件夹中的目录。对于这个博客，我们将删除起始代码，自己编写我们的导入。在第一个笔记本单元格中，我们将为我们的项目编写所有必要的导入，并将打印出我们下载的“digit_data”文件夹中的所有内容。
import matplotlib.pyplot **as** plt
import seaborn **as** sns
import numpy **as** np
import pandas **as** pd
import os**print**(os**.**listdir('digit_data'))
输出:
['test.csv', 'train.csv', 'sample_submission.csv']
下一步包括将我们的数据加载到笔记本中。请注意，我们的数据文件夹为我们提供了一个训练和测试文件。我们可以使用 pandas，一个数据分析 Python 库，将 CSV 文件读入我们的训练和测试数据帧。
train **=** pd**.**read_csv('digit_data/train.csv')
test **=** pd**.**read_csv('digit_data/test.csv')
一旦我们加载了我们的数据，我们将想要了解数据是什么。为了对我们的数据集中的内容有一个简要的概述，我们可以使用 panda 的.head()方法来打印出我们的数据集的头，或者顶部。我们可以将显示的行数设置为 5。
train**.**head(5)
5 rows × 785 columns
我们必须对训练数据做的第一件事是将它分成输入，或 X(特征)和输出(y)。通过查看我们的数据，我们可以看到输出(y)是“标签”列。这意味着我们的 X 数据将是除“标签”列之外的每一列，而 y 数据将只是“标签”列。要分开它们，我们可以使用 pandas 的.drop()方法，并给出我们想要删除的列的名称。为了让熊猫知道我们想要删除一个列，我们将“axis”设置为 1。
在分割我们的训练数据后，我们可以打印出目前为止所有东西的形状。在打印形状之后，我们还可以打印测试和训练数据中的样本。训练数据的形状将会是(42000，784)。这意味着有 42000 行，784 列。每行代表数据中的一个数字。每列代表图像的一个像素值。我们在 MNIST 数据集中的图像应该具有 28x28 (28 x 28 = 784)的形状。每个图像被展平成一行。
x_train **=** train**.**drop('label', axis**=**1)
y_train **=** train['label']**.**astype('int32')**print**('x_train shape: ', x_train**.**shape)
**print**('y_train shape: ', y_train**.**shape)
**print**('test shape: ', test**.**shape)
**print**('\nsamples in test: ', test**.**shape[0])
**print**('samples in train: ', x_train**.**shape[0])
输出:
x_train shape: (42000, 784)
y_train shape: (42000,)
test shape: (28000, 784)samples in test: 28000
samples in train: 42000
让我们找出每个数字有多少个样本。据我们所知，我们的数据可能是不平衡的，一些数字可能比其他数字显示得更多。这可能会妨碍我们的训练！为了检查我们训练的每个数字有多少个样本，我们可以再次使用 pandas 并在 y 训练集上使用value_counts()方法。
**print**('Number of Examples Per Digit:\n', y_train**.**value_counts())
输出:
Number of Examples Per Digit:
1 4684
7 4401
3 4351
9 4188
2 4177
6 4137
0 4132
4 4072
8 4063
5 3795
Name: label, dtype: int64
另一个令人惊叹的高级 Python 库是 Seaborn，它在数据科学中被大量用于可视化。Seaborn 是一个数据可视化库，它在很大程度上基于 matplotlib，但众所周知它可以制作更有吸引力的图形。由于我们喜欢吸引力，我们将与 Seaborn 合作，可视化我们在训练集中有多少每个数字的样本。在可视化了数据中的平衡并使用 pandas 查看了样本的准确数量后，我们可以自信地说我们的数据非常平衡，没有数字被过度表示。
sns**.**countplot(y_train)
MNIST 数据集中的每个手写数字都包含 RGB 值在 0–255 之间的像素。为了标准化这个范围的值，我们可以将每个像素值除以 255。这将使每个像素值更接近(在 0-1 范围内)，并使我们的神经网络更容易学习。例如，RGB 值 56 将变成. 219，RGB 值 230 将变成. 901。
然后，我们可以对 x_train 和测试集中的值进行整形。我们希望对它们进行整形，首先是样本数，然后如前所述，每个数字的尺寸为(28x28x1)或 28 行、28 列和 1 个颜色通道，因为图像没有颜色。
x_train **/=** 255.0
test **/=** 255.0x_train **=** x_train**.**values**.**reshape(x_train**.**shape[0], 28, 28, 1)
test **=** test**.**values**.**reshape(test**.**shape[0], 28, 28, 1)
现在我们可以打印训练和测试数据的最终形状。
**print**('x_train shape: ', x_train**.**shape)
**print**('y_train shape: ', y_train**.**shape)
**print**('test shape: ', test**.**shape)
输出:
x_train shape: (42000, 28, 28, 1)
y_train shape: (42000,)
test shape: (28000, 28, 28, 1)
要查看 MNIST 数据集包含的内容，我们可以使用 matplotlib 中的 pyplot 并显示八幅图像。图像将来自训练集(x_train ),在每个图像之上，我们可以将子情节标题设置为相应的输出(y_train)。
plt**.**figure(figsize**=**(12,10))**for** img **in** range(10):
plt**.**subplot(5, 5, img**+**1)
plt**.**imshow(x_train[img]**.**reshape((28, 28)), cmap**=**'binary_r')
plt**.**axis('off')
plt**.**title('Label: ' **+** y_train[img]**.**astype('str'))plt**.**show()
现在我们可以开始创建我们的模型了。为了对每个数字进行分类，我们将使用卷积神经网络。幸运的是，Keras 是一个高级 Python 神经网络库，提供了一个简单快捷的资源来建立深度学习模型。我们将不得不导入 Keras，顺序模型和在 CNN 中使用的必要层。
import keras
from keras.models import Sequential
from keras.layers import Dense, Dropout, Flatten, Conv2D, MaxPooling2D
from keras.utils import to_categoricalfrom sklearn.model_selection import train_test_split
我们可以使用 Keras’ to_categorical()函数将我们的类向量转换成一个二进制类矩阵。我们在 y_train 的班级被标注为 1，2，3，4 等。to_categorical()将创建一个列数与类别数相同的矩阵，其中 1 表示“是”，0 表示“否”。Keras 的文档给出了一个直观的例子。你可以在这里查看 Keras 的文件或者看下面的例子:
# Consider an array of 5 labels out of a set of 3 classes {0, 1, 2}:
> labels
array([0, 2, 1, 2, 0])
# `to_categorical` converts this into a matrix with as many
# columns as there are classes. The number of rows
# stays the same.
> to_categorical(labels)
array([[ 1., 0., 0.],
[ 0., 0., 1.],
[ 0., 1., 0.],
[ 0., 0., 1.],
[ 1., 0., 0.]], dtype=float32)
一旦完成，我们的数据就可以进行训练了！我们可以将数据分成训练集和测试集，然后开始训练我们的模型。
y_train **=** to_categorical(y_train, 10)
x_train, x_test, y_train, y_test **=** train_test_split(x_train, y_train, test_size **=** 0.1, random_state**=**1)
现在，我们可以创建我们的 CNN 模型，这多亏了 Keras，非常容易。我们将需要使用二维卷积层、最大池层和密集层，它们是完全连接的层。我们也将使用 dropout 和 flatten。展平我们的数据从卷积层和池层获得结果矩阵，并将其“展平”成一个长的输入数据向量(列)。我们的输出层将使用带有 10 个输出节点的 softmax 激活函数(数据中的类的数量)。
model **=** Sequential()
model**.**add(Conv2D(32, kernel_size**=**(3, 3), activation**=**'relu', input_shape**=**(28,28,1)))
model**.**add(Conv2D(64, (3, 3), activation**=**'relu'))model**.**add(MaxPooling2D(pool_size**=**(2, 2)))model**.**add(Dropout(0.25))model**.**add(Conv2D(64, (3, 3), activation**=**'relu'))
model**.**add(Conv2D(128, (3, 3), activation**=**'relu'))model**.**add(Dropout(0.25))model**.**add(Flatten())
model**.**add(Dense(128, activation**=**'relu'))
model**.**add(Dropout(0.5))
model**.**add(Dense(10, activation**=**'softmax'))
在我们训练模型之前，我们必须首先定义损失函数、优化器以及评估模型的指标。
model**.**compile(loss**=**'categorical_crossentropy', optimizer**=**'Adadelta', metrics**=**['accuracy'])
现在我们终于可以训练我们的模型了！我们将给.fit()函数我们的训练数据，并让它运行 12 个时期或迭代。
model**.**fit(x_train, y_train, batch_size**=**128, epochs**=**12, verbose**=**1,
validation_data**=**(x_test, y_test))
输出:
Train on 37800 samples, validate on 4200 samples
Epoch 1/12
37800/37800 [==============================] - 144s 4ms/step - loss: 0.3357 - acc: 0.8946 - val_loss: 0.1302 - val_acc: 0.9610
Epoch 2/12
37800/37800 [==============================] - 154s 4ms/step - loss: 0.0894 - acc: 0.9738 - val_loss: 0.0518 - val_acc: 0.9848
Epoch 3/12
37800/37800 [==============================] - 145s 4ms/step - loss: 0.0623 - acc: 0.9818 - val_loss: 0.0398 - val_acc: 0.9879
Epoch 4/12
37800/37800 [==============================] - 142s 4ms/step - loss: 0.0481 - acc: 0.9858 - val_loss: 0.0426 - val_acc: 0.9860
Epoch 5/12
37800/37800 [==============================] - 145s 4ms/step - loss: 0.0398 - acc: 0.9872 - val_loss: 0.0358 - val_acc: 0.9898
Epoch 6/12
37800/37800 [==============================] - 134s 4ms/step - loss: 0.0350 - acc: 0.9891 - val_loss: 0.0305 - val_acc: 0.9907
Epoch 7/12
37800/37800 [==============================] - 144s 4ms/step - loss: 0.0302 - acc: 0.9911 - val_loss: 0.0275 - val_acc: 0.9917
Epoch 8/12
37800/37800 [==============================] - 133s 4ms/step - loss: 0.0269 - acc: 0.9918 - val_loss: 0.0292 - val_acc: 0.9910
Epoch 9/12
37800/37800 [==============================] - 140s 4ms/step - loss: 0.0225 - acc: 0.9929 - val_loss: 0.0400 - val_acc: 0.9886
Epoch 10/12
37800/37800 [==============================] - 132s 3ms/step - loss: 0.0215 - acc: 0.9933 - val_loss: 0.0330 - val_acc: 0.9914
Epoch 11/12
37800/37800 [==============================] - 133s 4ms/step - loss: 0.0191 - acc: 0.9938 - val_loss: 0.0304 - val_acc: 0.9910
Epoch 12/12
37800/37800 [==============================] - 155s 4ms/step - loss: 0.0183 - acc: 0.9943 - val_loss: 0.0314 - val_acc: 0.9921<keras.callbacks.History at 0x1a30906ac8>
看起来我们的模特干得不错！我们可以对模型进行评估，并获得训练集和测试集的损失和准确性。一旦我们收到损失和准确性，我们可以打印出来，并四舍五入为简单。
loss, accuracy **=** model**.**evaluate(x_test, y_test, verbose**=**0)
train_stat **=** model**.**evaluate(x_train, y_train, verbose**=**0)**print**('Train Loss: ', round(train_stat[0], 5))
**print**('Train Accuracy: ', round(train_stat[1]*****100, 4), '%')
**print**('Test Loss: ', round(loss, 5))
**print**('Test Accuracy: ', round(accuracy*****100, 4), '%')
输出:
Train Loss: 0.00551
Train Accuracy: 99.8413 %
Test Loss: 0.03136
Test Accuracy: 99.2143 %
由于我们的模型经过了训练，并且已经证明相当准确，我们可以开始进行预测。我们将使用 Keras’ .predict()方法来预测 x_test 数据中每个数字的输出。
predictions **=** model**.**predict(x_test)
因为我们正在 Kaggle 中为一个比赛创建一个内核，我们将需要创建一个新的包含我们预测的 CSV 文件。这个文件将是我们提交给比赛，一旦它被创建，我们就完成了比赛！
results **=** np**.**argmax(predictions, axis **=** 1)results **=** pd**.**Series(results, name**=**"Label")submission **=** pd**.**concat([pd**.**Series(range(1,28001),name **=** "ImageId"),results],axis **=** 1)submission**.**to_csv("submission.csv", index**=**False)
Kaggler 提供了一个很好的平台来学习和应用你所获得的知识和技能到真实的比赛和数据集中。有大量的数据集可供选择，每场比赛都有一个非常友好的社区来帮助你。我会推荐报名 Kaggle，试试看！
自然语言处理(NLP)入门—预处理、单词嵌入、文本分类等等！
使用简单的 Python 库
如今自然语言处理领域发生了太多的事情(GRUs、LSTMs、XLNet、BERT 等等！).弄清楚从哪里开始可能会令人困惑。本文讨论了自然语言处理的基础知识，包括数据清理、规范化、编码、情感分析和一个简单的文本分类器，它使用了基本而强大的 Python 库。这往往是潜入复杂的深度学习模型之前的第一步。
数据清理和规范化
根据问题的性质，这一步可能需要，也可能不需要。如果我们的模型试图最大程度地学习语言，那么最好使用其原始格式的数据，事实上，现代深度学习技术建议不要删除停用词、表情符号或小写字母，因为它们提供了额外的上下文。然而，如果你试图基于某些单词的出现进行趋势分析或分类(就像在一个单词袋模型中)，这有助于执行这个步骤。这里我想强调几个常见的预处理步骤:
- 去除标点:在尝试训练一个机器学习模型时，通过去除标点有助于减少过拟合(比如！、*等。).但是，注意不要去掉一些重要的东西，比如问号(？)有助于认识问题。
- **移除表情符号:**有时人们会将表情符号附加在不带空格的单词上(例如:you❤)，这样就很难理解这些单词。移除表情符号有助于解决这种情况。同样，在删除这些表情符号时要小心，因为表情符号实际上可能对情感分析和主题分类等任务非常有用。
- **删除停用词:**对于数据探索和趋势分析这样的任务，看到“the”、“and”、“of”等常用词可能不是很有用。这个
sklearn包实际上有一个常用英语停用词的集合，我们可以用它来移除这些停用词。 - **使所有文本小写:**这是规范化文本最简单的方法。(毕竟，
BeTTer和better确实有相同的语义含义) - **词干化:**另一种规范化的方法是用词根形式替换派生的词(例如:‘posting’，‘posted’，‘posts’都用‘post’替换)。为了阻止单词，我们使用由
nltk.提供的[PorterStemmer](https://tartarus.org/martin/PorterStemmer/)util - **提取/移除标签和提及:**标签和提及对于识别数据趋势非常有用。这有助于将它们从你的文本中提取出来，并分别进行分析。
这里有一个简单的函数来执行上述任务:
词汇向量——它们是什么？
机器学习算法只能处理固定长度的数字输入，也就是说，它们不能接受字符串输入来处理文本数据！这就是单词向量的用武之地，我们用固定长度的向量来表示每个单词。然后使用单个单词向量对句子进行编码。
一键编码:
这是最简单的单词编码方式。它假设一个单词包表示法，其中每个单词被视为一个独立的实体，单词关系被忽略(例如，job和occupation被视为完全独立的单词，尽管它们实际上具有相同的含义)。该方法包括从整个语料库中创建不同单词的词汇表，该词汇表的长度是每个单词向量的长度。每个向量在单词向量中都有一个指定的索引，该索引被标记为1，而其他的被标记为0以表示特定的单词。
例如:
这里的词汇表由 9 个不同的单词组成，这些单词可以被编码成长度为 9 的向量。单词向量表示有going:【1，0，0，0，0，0，0，0】good:【0，1，0，0，0，0，0，0，0】等等…
使用这种表示，文本Tomorrow will be a good day可以编码成:[0，1，1，0，1，1，0，1，0]。注意单词will是如何被忽略的，因为它根本不存在于词汇表中。拥有一个好的和广泛的词汇是使这个模型工作良好的必要条件。还要注意单词关系(出现的顺序，语义关系)在这个表示中是如何被完全忽略的。
Word2Vec 单词嵌入:
这种单词编码方法(通常称为单词嵌入)考虑了上下文。例如，我们可以预期单词king和royal比parrot 和honey具有更小的空间距离。Word2vec 使用浅层两层神经网络来执行特定任务(基于所使用的方法)，并为每个单词学习隐藏层的权重。这些学习的隐藏层权重被用作我们的最终单词向量。可以阅读原文深入了解这些词向量是如何获得的。但是在高层次上，这是使用 Word2Vec 获得基于上下文的单词向量的两种常用方法:
CBOW(连续字袋):
source : https://arxiv.org/pdf/1301.3781.pdf
CBOW 模型架构试图基于源上下文单词(周围单词)来预测当前目标单词(中心单词)。
Skip — Gram 模型:
source: https://arxiv.org/pdf/1301.3781.pdf
Skip-gram 模型体系结构试图实现与 CBOW 模型相反的功能。它试图在给定目标单词(中心单词)的情况下预测源上下文单词(周围的单词)。
在这两种情况下，窗口大小(每边考虑的周围单词的数量)都是一个超参数。
手套:
Glove 与 Word2vec 非常相似，但与 Word2vec 不同，Glove 利用了单词的全局共现，而不仅仅是局部上下文，这使得它在某些方面更加强大。还是那句话，通读原文可以更好的理解。
单词嵌入——我如何使用它们？
既然我们对什么是单词嵌入以及为什么它们有用有了一个大致的概念，那么让我们来谈谈如何利用它们。
使用预先训练的单词向量:
有许多公开可用的不同向量长度的预训练词向量，如 Glove 、 fasttext 等。这些已经在大规模语料库(维基百科，twitter 和常见的爬行数据集)上进行训练，可以下载并用于在我们的语料库中编码单词。
示例:使用词向量相似度找到与给定文档最相似的文档
问题陈述:
给定一组属于不同主题的文档(训练集)，当给定一个新文档时，我们能从原始集中找到与之最相似的文档吗？
方法:
- 将预先训练好的单词向量文件加载到字典中，以单词为键，以其向量表示为值。
- 通过对特定文档中存在的单词的单词向量进行平均，找到训练集中每个文档的质心向量(忽略不属于词汇表的单词)
- 找到新文档的质心，从训练集中挑选其质心最接近新文档质心的文档(使用合适的相似性度量，如欧几里德距离、余弦相似性等。)
代码:
以下是一些辅助函数加载手套字典，找到质心，并找到质心之间的距离:
从头开始生成单词向量的训练:
如果您想为您的特定语料库找到单词向量，您可以使用gensim包进行训练。
举例:
代码:
输出:
在上面的例子中，我刚刚使用了来自维基百科页面的两行文字。训练非常快速和简单，所有你需要输入的是单词列表、你需要的单词向量的大小、窗口大小(要考虑的周围单词的数量)以及要被认为是词汇表的一部分的单词的最小出现次数。检查词汇、获取向量以及查看语料库中最常见的单词都很容易。当然，从头开始训练可能不会总是产生与预训练一样好的结果，但它对于涉及看起来与预训练中使用的数据集非常不同的数据的问题是有益的。
数据探索
带有文本数据的 EDA 不像表格或数字数据那样简单。然而，有一些库可以使这些任务变得更容易。在本文的其余部分，我使用了来自 Kaggle 的以下数据集:
识别和分类有毒的在线评论
www.kaggle.com](https://www.kaggle.com/c/jigsaw-toxic-comment-classification-challenge/data)
使用空间探索:
Spacy 是一个非常强大的 NLP 库，有多种用途。它可以用于命名实体识别，识别一个词所属的词性，甚至给出词的向量和情感。
代码:
输出:
来自spacy的nlp函数将每个单词转换成一个具有各种属性的令牌，就像上面例子中提到的那样。
Wordcloud:
单词云是一种简单而有趣的方式，可以直观地显示各种单词在我们的语料库中出现的频率。让我们以评论数据中出现频率最高的名词为例:
代码:
输出:
article, talk, and page are the most frequently occurring nouns
情感分析
在自然语言处理中，一个非常常见的任务是识别一个特定的评论或一段文本是积极的还是消极的。vaderSentiment包提供了一种快速简单的方法来实现这一点:
代码:
from vaderSentiment.vaderSentiment import SentimentIntensityAnalyzer
sentiment_analyzer = SentimentIntensityAnalyzer()def get_sentiment_score(text):
return sentiment_analyzer.polarity_scores(text)['compound']
输出:
The sentiment score for a toxic comment seems to be close to -1 whereas a non-toxic one has a score greater than 0 as expected
文本分类
对于分类，我用过的最简单的库之一是fasttext。它由脸书于 2016 年发布，使用了这种线性技术，既可以将单词向量组合成代表文本的向量，也可以计算分类标准。它只需要很少的时间训练，并给出了最常见的文本分类问题体面的结果。它可以用来提出一个基线模型。你可以阅读原文来更好的理解fasttext分类器背后的机制。
这是我如何使用[fasttext](https://fasttext.cc/docs/en/supervised-tutorial.html)来分类有毒和无毒评论:
使用 jovian.ml 共享](https://jovian.ml/aakanksha-ns/toxic-comments)
我们已经触及了大部分基础知识，但是当然，NLP 还有很多内容。然而，这篇文章是一个很好的起点，希望对初学者有所帮助，因为这些是我刚开始时学到的第一件事！
自然语言处理入门:美国航空公司情感分析
部分
- 自然语言处理简介
- 数据集探索
- 自然语言处理
- 培养
- 超参数优化
- 未来学习的资源
自然语言处理简介
自然语言处理(NLP)是机器学习的一个子领域，涉及处理和分析自然语言数据，通常以文本或音频的形式。NLP 中的一些常见挑战包括语音识别、文本生成和情感分析，而一些部署 NLP 模型的高调产品包括苹果的 Siri、亚马逊的 Alexa 和许多可能会在线互动的聊天机器人。
为了开始学习 NLP 并介绍该领域的一些核心概念，我们将使用流行的 Twitter 美国航空公司情绪数据集建立一个模型，试图预测与美国航空公司相关的推文的情绪(积极、中立或消极)。
代码片段将包含在这篇文章中，但是对于完全可复制的笔记本和脚本，请在其 Comet project 页面上查看与该项目相关的所有笔记本和脚本。
数据集探索
让我们从导入一些库开始。确保安装慧星用于实验管理、可视化、代码跟踪和超参数优化。
# Comet
from comet_ml import Experiment
几个标准包:pandas，numpy，matplotlib 等。
# Standard packages
import os
import pickle
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
Nltk 用于自然语言处理功能:
# nltk
import nltk
from nltk.tokenize import sent_tokenize, word_tokenize
from nltk.corpus import stopwords
from nltk.stem.snowball import SnowballStemmer
机器学习模型的 Sklearn 和 keras :
# sklearn for preprocessing and machine learning modelsfrom sklearn.model_selection import train_test_split
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.metrics import accuracy_score
from sklearn.utils import shuffle
from sklearn.preprocessing import OneHotEncoder
from sklearn.feature_extraction.text import TfidfVectorizer# Keras for neural networks
from keras.models import Sequential
from keras.layers import Dense, Dropout, BatchNormalization, Flatten
from keras.layers.embeddings import Embedding
from keras.preprocessing import sequence
from keras.utils import to_categorical
from keras.callbacks import EarlyStopping
现在我们将加载数据:
raw_df = pd.read_csv('twitter-airline-sentiment/Tweets.csv')
让我们检查数据帧的形状:
raw_df.shape()
>>> (14640, 15)
所以我们有 14640 个样本(推文)，每个样本有 15 个特征。让我们来看看这个数据集包含哪些要素。
raw_df.columns
'tweet_id'、'airline_sentiment'、'airline_sentiment_confidence'、'negativereason'、'negativereason_confidence'、'airline'、'airline_sentiment_gold'、'name'、'negativereason_gold'、'retweet_count'、'text'、'tweet_coord'、'tweet_created'、'tweet_location'、'user_timezone'
让我们也来看看每个航空公司的航空公司情绪(代码可以在彗星上找到):
# Create a Comet experiment to start tracking our workexperiment = Experiment(
api_key='<HIDDEN>',
project_name='nlp-airline',
workspace='demo')experiment.add_tag('plotting')airlines= ['US Airways',
'United',
'American',
'Southwest',
'Delta',
'Virgin America']**for** i **in** airlines: indices = airlines.index(i)
new_df=raw_df[raw_df['airline']==i]
count=new_df['airline_sentiment'].value_counts()
experiment.log_metric('{} negative'.format(i), count[0])
experiment.log_metric('{} neutral'.format(i), count[1])
experiment.log_metric('{} positive'.format(i), count[2])
experiment.end()
每家航空公司的负面推文都比中性或正面推文多，维珍美国航空公司在所有美国航空公司中获得了最平衡的正面、中性和负面传播。虽然在这篇文章中我们将重点放在特定于 NLP 的分析上，但是也有更深入的特性工程和探索性数据分析的极好来源。Kaggle 内核这里的和这里的在分析与情绪相关的受众和推文长度等特征时特别有指导意义。
让我们创建一个只有tweet_id、text和airline_sentiment特性的新数据帧。
df = raw_df[['tweet_id', 'text', 'airline_sentiment']]
现在让我们来看看一些推文本身。数据是什么样的？
df['text'][1]> "[@VirginAmerica](http://twitter.com/VirginAmerica) plus you've added commercials to the experience... tacky."df['text'][750]> "[@united](http://twitter.com/united) you are offering us 8 rooms for 32 people #FAIL"df['text'][5800]> "[@SouthwestAir](http://twitter.com/SouthwestAir) Your #Android Wi-Fi experience is terrible! $8 is a ripoff! I can't get to [@NASCAR](http://twitter.com/NASCAR) or MRN for [@DISupdates](http://twitter.com/DISupdates) #BudweiserDuels"
接下来，我们将执行一些标准的 NLP 预处理技术，为训练准备好数据集。
自然语言处理
为了构建自然语言处理模型，必须进行一些基本的文本预处理步骤，以便将文本从人类语言转换成机器可读的格式，以便进一步处理。这里我们将介绍一些标准实践:标记化、停用词移除和词干化。你可以参考这篇文章来学习额外的文本预处理技术。
标记化
给定一个字符序列和一个已定义的文档单元，标记化就是将它分割成称为标记的离散片段的任务。在分割文本的过程中，标记化通常还包括丢弃某些字符，比如标点符号。
将记号简单地认为是单词是简单的(并且经常是有用的),但是为了更好地理解 NLP 记号化的特定术语，斯坦福大学 NLP 小组的概述非常有用。
NLTK 库有一个内置的标记器，我们将使用它来标记美国航空公司的推文。
from nltk.tokenize import word_tokenizedef tokenize(sentence):
tokenized_sentence = word_tokenize(sentence)
return tokenized_sentence
停用词删除
有时，可能对确定文档的语义质量没有什么价值的常用词被完全排除在词汇表之外。这些被称为停止字。确定停用词列表的一般策略是根据收集频率(每个术语在文档中出现的总次数)对术语进行排序，然后过滤出最频繁的术语作为停用词列表——根据语义内容进行手动过滤。
NLTK 有一个标准的停用词表，我们将在这里采用。
from nltk.corpus import stopwords
class PreProcessor:
def __init__(self, df, column_name):
self.stopwords = set(stopwords.words('english')) def remove_stopwords(self, sentence):
filtered_sentence = []
for w in sentence:
if ((w not in self.stopwords) and
(len(w) > 1) and
(w[:2] != '//') and
(w != 'https')):
filtered_sentence.append(w)
return filtered_sentenceStemming
出于语法目的，文档使用不同形式的单词(看，看，看，看，看),这些单词在许多情况下具有非常相似的语义特征。词干化是一个粗略的过程，通过这个过程，一个单词的变体或相关形式被简化(词干化)为一个常见的基本形式。因为词干化是从单词中移除前缀或后缀字母，所以输出可能是也可能不是属于语言语料库的单词。词汇化是一个更精确的过程，通过这个过程，单词被适当地简化为它们所来自的基本单词。
示例:
词干 :汽车，汽车，汽车的，汽车的’变成汽车
单义化 : am，are is 成为 be
词干化单句 :“男孩的汽车是不同颜色的”变成了“男孩的汽车是不同颜色的”
最常见的英文文本词干算法是【波特算法】(TO DO)。 Snowball ，一种用于词干算法的语言，由 Porter 在 2001 年开发，是其 SnowballStemmer 的 NLTK 实现的基础，我们将在这里使用它。
from nltk.stem.snowball import SnowballStemmer
class PreProcessor:
def __init__(self, df, column_name):
self.stemmer = SnowballStemmer('english') def stem(self, sentence):
return [self.stemmer.stem(word) for word in sentence]
这些预处理步骤的代码可以在 Comet 上找到。
接下来，我们将创建一个预处理器对象，包含每个步骤的方法，并在我们的数据框的text列上运行它，以对 tweets 进行分词、词干提取和删除停用词。
preprocessor = PreProcessor(df, 'text')
df['cleaned text'] = preprocessor.full_preprocess()
现在，我们将把数据分成训练集、验证集和测试集。
df = shuffle(df, random_state=seed)*# Keep 1000 samples of the data as test set*test_set = df[:1000]*# Get training and validation data*X_train, X_val, y_train, y_val = train_test_split(df['cleaned_text'][1000:], df['airline_sentiment'][1000:], test_size=0.2, random_state=seed)*# Get sentiment labels for test set*y_test = test_set['airline_sentiment']
既然我们已经将数据分成了训练集、验证集和测试集，我们将对它们进行 TF-IDF 矢量化处理
TF-IDF 矢量化
TFIDF，或词频——逆文档频率，是一种数字统计，反映了一个词对集合或语料库中的文档有多重要。它通常用于产生与单词相关联的权重，这些权重在信息检索或文本挖掘的搜索中是有用的。单词的 tf-idf 值与单词在文档中出现的次数成比例地增加，并被包含该单词的语料库中的文档数量所抵消。这种偏移有助于调整某些词通常出现得更频繁的事实(想想看，如果没有偏移，像’ a ‘，’ the ‘，’ to '这样的停用词可能会有非常高的 tf-idf 值)。
Source: https://becominghuman.ai/word-vectorizing-and-statistical-meaning-of-tf-idf-d45f3142be63
我们将使用 scikit-learn 实现的 TfidfVectorizer ，它将一组原始文档(我们的 twitter 数据集)转换成一个 TF-IDF 特性矩阵。
vectorizer = TfidVectorizer()
X_train = vectorizer.fit_transform(X_train)
X_val = vectorizer.transform(X_val)
X_test = vectorizer.transform(test_set['cleaned_text'])
培养
我们准备开始训练我们的模型。我们要做的第一件事是创建一个彗星实验对象:
experiment = Experiment(api_key='your-personal-key', project_name='nlp-airline', workspace='demo')
接下来，我们将使用 keras 构建一个光梯度增强分类器(LGBM) 、一个 XGBoost 分类器和一个相对简单的神经网络，并比较这些模型的性能。通常，如果不进行测试，很难判断哪种架构的性能最好。Comet 的项目级视图有助于轻松比较不同实验的执行情况，并让您轻松地从模型选择转移到模型调整。
LGBM
# sklearn's Gradient Boosting Classifier (GBM)gbm = GradientBoostingClassifier(n_estimators=200, max_depth=6, random_state=seed)gbm.fit(X_train, y_train)# Check resultstrain_pred = gbm.predict(X_train)val_pred = gbm.predict(X_val)val_accuracy = round(accuracy_score(y_val,val_pred), 4)train_accuracy = round(accuracy_score(y_train, train_pred), 4)# log to cometexperiment.log_metric('val_acc', val_accuracy)experiment.log_metric('Accuracy', train_accuracy)XGBOOST
XGBoost
xgb_params = {'objective' : 'multi:softmax',
'eval_metric' : 'mlogloss', 'eta' : 0.1, 'max_depth' : 6, 'num_class' : 3, 'lambda' : 0.8, 'estimators' : 200, 'seed' : seed}target_train = y_train.astype('category').cat.codestarget_val = y_val.astype('category').cat.codes# Transform data into a matrix so that we can use XGBoostd_train = xgb.DMatrix(X_train, label = target_train)d_val = xgb.DMatrix(X_val, label = target_val)# Fit XGBoostwatchlist = [(d_train, 'train'), (d_val, 'validation')]bst = xgb.train(xgb_params, d_train, 400, watchlist, early_stopping_rounds = 50, verbose_eval = 0)# Check results for XGBoosttrain_pred = bst.predict(d_train)val_pred = bst.predict(d_val)experiment.log_metric('val_acc', round(accuracy_score(target_val, val_pred)*100, 4))experiment.log_metric('Accuracy', round(accuracy_score(target_train, train_pred)*100, 4))
神经网络
*# Generator so we can easily feed batches of data to the neural network***def** **batch_generator**(X, y, batch_size, shuffle):
number_of_batches = X.shape[0]/batch_size
counter = 0
sample_index = np.arange(X.shape[0])
**if** shuffle:
np.random.shuffle(sample_index)
**while** True:
batch_index = sample_index[batch_size*counter:batch_size*(counter+1)]
X_batch = X[batch_index,:].toarray()
y_batch = y[batch_index]
counter += 1 **yield** X_batch, y_batch
**if** (counter == number_of_batches):
**if** shuffle:
np.random.shuffle(sample_index)
counter = 0*# Initialize sklearn's one-hot encoder class*onehot_encoder = OneHotEncoder(sparse=False)
integer_encoded_train = np.array(y_train).reshape(len(y_train), 1)
onehot_encoded_train = onehot_encoder.fit_transform(integer_encoded_train)
integer_encoded_val = np.array(y_val).reshape(len(y_val), 1)
onehot_encoded_val = onehot_encoder.fit_transform(integer_encoded_val)
experiment.add_tag('NN')*# Neural network architecture*initializer = keras.initializers.he_normal(seed=seed)
activation = keras.activations.elu
optimizer = keras.optimizers.Adam(lr=0.0002, beta_1=0.9, beta_2=0.999, epsilon=1e-8)
es = EarlyStopping(monitor='val_acc', mode='max', verbose=1, patience=4)*# Build model architecture*model = Sequential()
model.add(Dense(20, activation=activation, kernel_initializer=initializer, input_dim=X_train.shape[1]))
model.add(Dropout(0.5))
model.add(Dense(3, activation='softmax', kernel_initializer=initializer))
model.compile(optimizer=optimizer, loss='binary_crossentropy', metrics=['accuracy'])*# Hyperparameters*epochs = 15
batch_size = 32*# Fit the model using the batch_generator*hist = model.fit_generator(generator=batch_generator(X_train, onehot_encoded_train, batch_size=batch_size, shuffle=True), epochs=epochs, validation_data=(X_val, onehot_encoded_val), steps_per_epoch=X_train.shape[0]/batch_size, callbacks=[es])
使用 Comet 的 project view 比较我们的模型，我们可以看到我们的神经网络模型比 XGBoost 和 LGBM 实验表现出了相当大的优势。
现在让我们选择神经网络架构，并对其进行微调。注意，因为我们已经存储了我们所有的实验——包括我们现在不打算使用的 XGBoost 和 LGBM 运行——如果我们决定在未来重新访问这些架构，我们所要做的就是在 Comet 项目页面中查看这些实验，我们将能够立即重现它们。
超参数优化
既然我们已经从 XGBoost、LGBM 和神经网络的简单 keras 实现的初始搜索中选择了我们的架构，我们将需要进行超参数优化来微调我们的模型。对于复杂的建模任务来说，超参数优化可能是一个极其困难、计算量大且缓慢的过程。Comet 已经建立了一个优化服务，可以为你进行这种搜索。只需传入您想要扫描超参数空间的算法、要搜索的超参数和范围，以及最小化或最大化的度量，Comet 可以为您处理建模过程的这一部分。
from comet_ml import Optimizer
config = {
"algorithm": "bayes",
"parameters": {
"batch_size": {"type": "integer", "min": 16, "max": 128},
"dropout": {"type": "float", "min": 0.1, "max": 0.5},
"lr": {"type": "float", "min": 0.0001, "max": 0.001},
},
"spec": {
"metric": "loss",
"objective": "minimize",
},
}
opt = Optimizer(config, api_key="<HIDDEN>", project_name="nlp-airline", workspace="demo")
for experiment in opt.get_experiments():
experiment.add_tag('LR-Optimizer') # Neural network architecture initializer = keras.initializers.he_normal(seed=seed)
activation = keras.activations.elu
optimizer = keras.optimizers.Adam(
lr=experiment.get_parameter("lr"),
beta_1=0.99,
beta_2=0.999,
epsilon=1e-8) es = EarlyStopping(monitor='val_acc',
mode='max',
verbose=1,
patience=4)
batch_size = experiment.get_parameter("batch_size") # Build model architecture model = Sequential(# Build model like above)
score = model.evaluate(X_test, onehot_encoded_val, verbose=0)
logging.info("Score %s", score)
运行我们的优化后，很容易选择能够产生最高精度、最低损耗或您想要优化的任何性能的超参数配置。这里我们保持优化问题相当简单:我们只搜索 epoch、batch_size 和 dropout。下面显示的平行坐标图是 Comet 的另一个固有特性，它提供了我们的优化器遍历的底层超参数空间的有用可视化:
Comet Visualizations Dashboard
让我们运行另一次优化扫描，这次包括要测试的一系列学习率。
Comet Visualizations Dashboard
我们再次看到产生更高val_acc值的潜在超参数空间的区域。
比方说，现在我们想比较两款更好的型号的性能，以保持微调。只需从您的列表中选择两个实验并单击Diff按钮，Comet 将允许您直观地检查每个代码和超参数的变化，以及两个实验的并排可视化。
从这里，您可以继续您的模型建设。微调我们从架构比较和参数优化扫描中抽出的一个模型，或者回到起点，将新架构与我们的基线模型进行比较。你所有的工作都保存在你的彗星项目空间。
未来学习的资源
有关 NLP 的其他学习资源，请查看 fastai 的新的 NLP 课程或由 Hugging Face 发布的这篇博客文章，其中涵盖了 NLP 中一些最好的最新论文和趋势。
多亏了道格拉斯·布兰克。
10 分钟内开始使用 neo4j
在本文中，我们将使用 neo4j 创建第一个图形数据库。
安装 neo4j 后，我们将探索创建数据库的两种方法:
- 手动键入密码查询
- 使用 Excel 公式生成密码查询。如果您从 Excel 文件开始，这将非常有用
在深入研究代码之前，我们先来了解一下什么是 neo4j，以及为什么了解这项技术很重要。
neo4j 是什么？
Screenshot of neo4j browser (source: neo4j website)
简单来说，neo4j 就是图形数据库的 mySQL。它提供了一个图形数据库管理系统、一种查询数据库的语言、一个密码和一个带有 neo4j 浏览器的可视化界面。
Neo4j 是一个开源项目，由一家私人公司维护。它有一个免费版本，我们将在这里使用。注意，我不工作，也不接受他们的任何东西。
对我来说，neo4j 的主要优势在于:
- 免费版本非常适合原型制作。我从来不需要高级版本
- neo4j 浏览器给了你很多自定义可视化的自由。它可以被非数据科学家使用
- 与 SQL 非常相似的语言 CYPHER 允许简单和复杂的查询，以获得您想要的结果。掌握所有的概念需要一些时间，但经过一些练习后，它会变得强大
- LOAD CSV 函数，它简化了从 CSV 文件创建图形的任务
另一件很棒的事情是脚本语言中有多种可用的 API，比如 Python。但是这将在另一篇文章中介绍。
一.设置 neo4j
- 下载并安装 neo4j 桌面
You have to fill the form to download neo4j
2.安装完成后，点击“我的项目”下的“新建图形”，然后“创建一个本地图形”。记下图形的名称和密码。
3.运行数据库，点击“播放”标志。
Now open the neo4j browser with the new graph you created. A bar at the top will appear and you’ll type queries there
二。创建您的 neo4j 图形数据库
假设你的数据是关于人和组织的。人是一种“节点”,而组织是另一种。它们可以通过特定的关系连接在一起。就像有人在一家公司工作过，有人是这家公司的董事长，或者一家公司是另一家公司的母公司。
1.在 neo4j 浏览器中编写密码查询
CYPHER 是一种灵活的语言，你可以同时创建节点、关系甚至两者。
让我们从简单直观的方式开始:创建节点，然后创建关系。
使用以下语法创建一个节点:
CREATE ( x: LABEL {属性名称:属性值})
其中 x :是节点的变量名，你可以随便叫它。当您重用它时，例如使用 RETURN x 在查询末尾绘制节点时，这很有用。
LABEL :是节点的标签。在我们的例子中，我们有两个标签:组织和个人
例如
创建(p:Org { Name:" super robotics Limited " })
点击回车键，您将得到一个确认(或一个错误)，表明节点已经创建。在我的例子中，它起作用了，正如“添加了 1 个标签，创建了 1 个节点…”
顺便说一下，通过运行上面的查询，我们隐式地创建了一个名为 Org 的标签。
让我们创建一个担任该组织主席的人，并将他与该组织相关联。
创建(p: Person { Name: “Patrick Moon” })
然后
MATCH (p:Person)，(o:Org)
其中 p.Name = "Patrick Moon "和 o . Name = " super robotics Limited "
CREATE§-【r:主席】- > (o)
RETURN p，r，o
Adding the RETURN at the end of the query will plot the newly created relationship. Note that neo4j has a color coding that differentiates labels automatically.
现在我们有点明白 CYPHER 是如何工作的了:要么你创建一些新的东西，然后从 create 开始，要么你试图在图中找到现有的东西，然后从 MATCH 开始。节点在括号()中，关系在方括号[]中，属性在花括号{}中。
注意 : 2 个查询如果把图搞砸了对从头开始重新开始很有用:删除所有节点和关系: match (n)-[r]-() delete n，r 删除所有节点:match(n)Delete n
_ _ _ _ _ _ _
好了，现在让我们假设我们有一个 Excel，其中有 100 多人链接到组织，我们不想写 100 次相同的查询。让我们用 Excel 中的老方法来做吧。
2.使用 Excel 公式从 Excel 粘贴密码查询
在这个例子中，我从维基百科的文章中复制并粘贴了著名公司首席执行官名单的数据。
我们希望为每一行创建一个查询，同时创建:
- 公司的一个节点
- CEO 的一个节点
- 两者之间的关系
让我们开始吧:
= " CREATE(:PERSON { Name:" " & B2 & " " " })-[:CEO { Since:" " & D2 & " " “，备注:” " " & E2 & " " " }]–>(:ORG { Name:" " & A2 & " " })"
注意，我删除了节点(p 和 o)和关系®中的第一个变量。这是因为我们将同时向 neo4j 发送 184 个创建查询，所以我们需要确保它理解每个节点(p 或 o)和关系®都不同于上面一行创建的节点。
一旦您复制并粘贴了所有行的公式，您将得到如下结果:
现在让我们将创建的公式复制并粘贴到 neo4j 中。显示图表中的所有节点
匹配返回
结论
在本文中，我们已经完成了安装 neo4j 和创建您的第一个图表的初始步骤，大概花了 10-15 分钟吧？相当简单。
下一步
在图表中搜索有趣的模式…
使用 PyTorch 框架开始使用 NLP
PyTorch 是最流行的深度学习框架之一，它基于 Python，由脸书支持。
在本文中，我们将研究 PyTorch 提供的帮助自然语言处理(NLP)的类。
PyTorch 中有 6 个类可用于使用递归层的 NLP 相关任务:
- torch.nn.RNN
- 火炬. nn.LSTM
- 火炬网
- 火炬
- 火炬. nn.LSTMCell
- 火炬. nn .格鲁塞尔
理解这些类、它们的参数、它们的输入和输出是开始在 Pytorch 中为自然语言处理(NLP)构建自己的神经网络的关键。
如果你已经开始了你的 NLP 之旅，很可能你已经遇到了类似的图表(如果没有，我们建议你看看克里斯·奥拉的这篇精彩的、经常被引用的文章——了解 LSTM 网络):
来源—【http://colah.github.io/posts/2015-08-Understanding-LSTMs/
教师使用这种展开图向学生提供这种神经网络的递归结构的简单易懂的解释。从这些漂亮的、展开的图表和直观的解释到 Pytorch API 可能被证明是具有挑战性的。
来源—https://pytorch.org/docs/stable/nn.html#recurrent-layers
因此，在本文中，我们旨在通过以清晰和描述性的方式解释 PyTorch 中相关类的参数、输入和输出来弥补这一差距。
Pytorch 基本上有两个等级的类来构建循环网络:
- 多层类— nn。新泽西州 RNN。GRU·安迪。LSTM这些类的对象能够表示深度双向递归神经网络(或者，如类名所示，它们的一个或多个进化架构——门控递归单元(GRU)或长短期记忆(LSTM)网络)。
- 细胞水平类— nn。新罕布什尔州 RNNCell。格鲁塞尔和 nn。LSTMCell这些类的对象只能代表一个单元格*(同样，一个简单的 RNN 或 LSTM 或 GRU 单元格)，它可以处理一个时间步长的输入数据。(记住，这些细胞没有 cuDNN 优化，因此没有任何融合操作，等等。)*
同一级别的所有类共享相同的 API。因此，理解上述两个层次中任何一个类的参数、输入和输出就足够了。
为了使解释简单，我们将使用最简单的类——torch . nn . rnn 和 torch.nn.RNNCell
火炬. nn.RNN:
我们将使用下图来解释 API —
来源——【http://colah.github.io/posts/2015-08-Understanding-LSTMs/
参数:
- input_size —输入 x 中期望特征的数量
这表示向量 x[i]的维数(即上图中从 x[0]到 x[t]的任何向量)。请注意，这很容易与序列长度混淆，序列长度是我们在如上展开 RNN 后得到的细胞总数。
- hidden_size —处于隐藏状态的特征数量 h
这表示向量 h[i]的维数(即上图中从 h[0]到 h[t]的任何向量)。总的来说，在确定网络的权重矩阵的形状时，隐藏大小和输入大小是必要的和充分的。
- 层数 —循环层数。例如，设置 num _ layers =将意味着将两个 RNN 堆叠在一起以形成堆叠的 RNN，其中第二 RNN 接收第一 RNN 的输出并计算最终结果。默认值:1
此参数用于构建深度 rnn，如下所示:
这里，红色单元代表输入，绿色块代表 RNN 单元，蓝色块代表输出
所以对于上图，我们将 num_layers 参数设置为 3。
- 非线性 —要使用的非线性。可以是“tanh”或“relu”。默认值:“tanh”
这是不言自明的。
- 偏差-如果为假，则该层不使用偏差权重 b_ih 和 b_hh。默认值:真
在深度学习社区，一些人发现去除/使用偏见不会影响模型的性能。因此这个布尔参数。
- batch_first —如果为真，则输入和输出张量提供为(batch，seq，feature)。默认值:False
- dropout —如果非零，在除最后一层之外的每个 RNN 层的输出上引入一个丢弃层，丢弃概率等于 dropout。默认值:0
该参数用于控制 RNN 体系结构中的退出正则化方法。
- 双向 —如果为真，则成为双向 RNN。默认值:False
创建双向 RNN 非常简单，只需将该参数设置为 True！
因此，要在 PyTorch 中制作 RNN，我们需要向该类传递两个强制参数——input _ size 和 hidden_size。
一旦我们创建了一个对象，我们就可以用相关的输入“调用”该对象，它就会返回输出。
输入:
我们需要向对象传递 2 个输入——input 和 h_0:
- 输入 —这是一个形状张量*(序列长度，批次，输入大小)。*为了处理可变长度的输入，我们将较短的输入序列打包。详见torch . nn . utils . rnn . pack _ padded _ sequence()或torch . nn . utils . rnn . pack _ sequence()。
- h_0 —这是一个形状张量(num_layers * num_directions，batch，hidden_size)。对于双向 RNNs，num_directions 为 2，否则为 1。这个张量包含批处理中每个元素的初始隐藏状态。
输出:
以类似的方式，对象向 us 返回 2 个输出——output 和 h_n:
- 输出 —这是一个形状为*(序列长度，批次，数量方向*隐藏尺寸)的张量。*它包含来自 RNN 最后一层的输出特征(h_k ),对于每个 k
- h_n —这是一个大小为(num_layers * num_directions，batch，hidden_size)的张量。它包含 k = seq_len 的隐藏状态。
如前所述，torch.nn.GRU 和 torch.nn.LSTM 具有相同的 API，也就是说，它们接受相同的参数集，接受相同格式的输入并以相同格式返回。
torch.nn.RNNCell:
因为这仅代表 RNN 的单个单元格，所以它仅接受 4 个参数，所有这些参数的含义与它们在 torch.nn.RNN 中的含义相同。
参数:
- input_size —输入 x 中预期特征的数量
- hidden_size —处于隐藏状态的特征数量 h
- 偏差 —如果为假，则该层不使用偏差权重 b_ih 和 b_hh。默认值:真
- 非线性 —要使用的非线性。可以是“tanh”或“relu”。默认值:“tanh”
再说一次，因为这只是 RNN 的一个细胞，输入和输出维度要简单得多——
输入(输入，隐藏):
- 输入 —这是一个包含输入特征的形状张量(batch，input_size)。
- hidden——这是一个形状张量(batch，hidden_size ),包含批处理中每个元素的初始隐藏状态。
输出:
- h’—这是一个形状张量(batch，hidden_size)，它为我们提供了下一个时间步的隐藏状态。
这是关于自然语言处理(NLP)py torch 框架的入门知识。如果你正在寻找关于什么是可能的和你能构建什么的想法，请查看使用 RNNs 和 CNN 的自然语言处理的深度学习。
原载于 2019 年 3 月 19 日【blog.exxactcorp.com。
NumPy 入门
NumPy 代表NumericalPython它是 Python 中的一个核心 科学计算 库 。它提供了高效的 多维数组对象 和各种操作来处理这些数组对象。
在这篇文章中，你将了解到
1。安装数字
2。在 NumPy
3 中创建数组。NumPy 数组上的基本操作
安装 Numpy
- Mac 和 Linux 用户可以通过 pip 命令安装 NumPy:
pip install numpy
2.因为 windows 没有像 linux 或 mac 那样的包管理器，所以你可以从这里下载 NumPy。一旦你下载了合适的**。从链接的 whl** 文件中，打开命令提示符。导航到下载的目录。whl 文件。最后，使用以下命令安装它:
pip install name_of_the_file.whl
注意:如果您正在使用 Anaconda，您不需要安装 NumPy，因为它已经与 Anaconda 一起安装了。然而，您可以通过命令在 Anaconda 中安装任何包/库:
conda install name_of_the_package
# conda install numpy
要在我们的程序中使用 Numpy 库，你只需要导入它。
import numpy as np
NumPy 中的数组简介
NumPy 数组是 同质网格 的值。数组的维数在 NumPy 中称为 轴 。轴数称为 秩 。给出数组沿每个维度的大小的非负整数元组称为其 **形状。**例如，考虑下面的 2D 阵列。
[[11, 9, 114]
[6, 0, -2]]
- 这个数组有两个轴。长度 2 的第一轴和长度 3 的第二轴。
- 秩=轴数= 2。
- 形状可以表示为:(2，3)。
在 NumPy 中创建数组
要创建一个数组，可以使用 数组numpy 的方法。
*# Creating 1D array
a = np.array([1, 2, 3])# Creating 2D array
b = np.array([[1,2,3],[4,5,6]])*
创建 NumPy 数组的函数:
*a = np.zeros((2,2)) # Create an array of all zerosb = np.ones((1,2)) # Create an array of all onespi = 3.14
c = np.full((2,2), pi) # Create a constant array of pid = np.eye(3) # Creates a 3x3 identity matrixe = np.random.random((2,2)) # Create an array of random values*
为了创建数字序列，NumPy 提供了一个类似于 range 的函数，它返回数组而不是列表。
- arange :返回给定区间内间隔均匀的值。步长是指定的。
- linspace :返回给定间隔内间隔均匀的值。num 返回元素的数量。
*A = np.arange(0, 30, 5) # Creates [ 0, 5, 10, 15, 20, 25]B = np.linspace(1, 15, 3) # Creates [ 1.0, 8.0, 15.0]*
你可以用 重塑 的方法重塑一个数组。考虑一个形状为(a1，a2，a3，…，an)的数组。我们可以改变它的形状并将其转换成另一个形状为(b1，b2，b3，……，bM)。
唯一的条件是:()a1 * a2 * a3… aN) = (b1 b2 * b3 … bM )**
即两个数组中的元素数量必须相同。*
访问数组元素:切片
就像 Python 列表一样，NumPy 数组也可以切片。由于数组可能是多维的，因此必须为数组的每个维度指定一个切片。例如
*a = np.array([[1,2,3,4], [5,6,7,8], [9,10,11,12]])*
这将创建一个如下所示的数组
*[[1 2 3 4]
[5 6 7 8]
[9 10 11 12]]*
现在让我们假设你想从中访问元素。
*# Accessing an element
b = a[rowIndex, colIndex]# Accessing a block of elements together
c = a[start_row_index:end_row_index, start_col_index:end_col_index]*
注 1:**Python 中的 Index 从 0 开始。
注 2: 每当我们将元素块指定为start _ row _ index:end_row_index时，它就意味着
【start _ row _ index，end _ row _ index】
NumPy 数组上的基本操作
基本算术运算
*# Create a dummy array for operations
a = np.array([1, 2, 5, 3])# Add 3 to every element
a += 3# Subtract 5 from every element
a -= 5# Multiply each element by 7
a *= 7# Divide each element by 6
a /= 6# Squaring each element
a **= 2# Taking transpose
a = a.T*
其他一些有用的功能
*# Create a dummy array
arr = np.array([[1, 5, 6], [4, 7, 2], [3, 1, 9]])# maximum element of array
print(arr.max())# row-wise maximum elements
arr.max(axis=1)# column wise minimum elements
arr.min(axis=0)# sum of all array elements
arr.sum()# sum of each row
arr.sum(axis=1)# cumulative sum along each row
arr.cumsum(axis=1)*
两个 NumPy 数组上的操作
*a = np.array([[1, 2], [3, 4]])b = np.array([[4, 3], [2, 1]])print(a+b) # [[5, 5], [5, 5]]print(a-b) # [[-3, -1], [1, 3]]print(a*b) # [[4, 6], [6, 4]]print(a.dot(b)) # [[8, 5], [20, 13]]*
NumPy 提供了很多数学函数，比如 sin，cos，exp 等。这些函数也对数组进行元素操作，产生一个数组作为输出。
*a = np.array([0, np.pi/2, np.pi])print(a)print(np.sin(arr)) *# sin of each element*print(np.cos(arr)) *# cosine of each element*print(np.sqrt(arr)) *# square root of each element*print(np.exp(arr)) *# exponentials of each element*print(np.log(arr)) *# log of each element*print(np.sum(arr)) *# Sum of elements*print(np.std(arr)) *# standard deviation**
NumPy 中的排序数组
*a = np.array([[1, 4, 2], [3, 4, 6], [0, -1, 5]])# array elements in sorted order
print(np.sort(a, axis=None))# sort array row wise
print(np.sort(a, axis=1))*
这就是 NumPy 的故事。我们已经讨论了很多重要的概念。我希望它能让你明白很多。
Nvidia Jetson Nano 入门和安装 Tensorflow GPU
作为 Nsemble.ai 的部署工程师，我致力于研究和交付基于云和 IOT 的机器学习和深度学习解决方案。在 IOT 设备上部署对象检测模型是一项繁琐的任务。甚至高端深度学习模型在 Raspberry pi 等基本设备上的处理速度也很慢。我研究了一段时间，得到了这个惊人的设备适合生产准备所谓的英伟达杰特森纳米。它的图形体验令人惊叹，也很划算(99 美元)。这种物联网设备非常适合部署繁重的深度学习模型。
这是一个简单的博客，用于开始使用 Nvidia Jetson Nano IOT 设备(设备概述和操作系统安装)，然后安装 tensorflow 的 GPU 版本。
介绍
NVIDIA Jetson Nano 开发者套件是一款面向开发者、学习者和开发者的小型人工智能电脑。在遵循这个简短的指南之后，你将准备好开始构建实用的人工智能应用程序、酷酷的人工智能机器人等等。
Nvidia Jeston Nano newly opened
准备安装
入门项目
microSD 卡
Jetson Nano 开发套件使用 microSD 卡作为启动设备和主存储。对于你的项目来说，拥有一张足够大且足够快的卡是很重要的；推荐的最低容量是 16GB 的 UHS-1 卡。
请参阅以下说明，用操作系统和软件刷新您的 microSD 卡。
微型 USB 电源
您需要使用优质电源为开发套件供电，该电源可以在开发套件的微型 USB 端口提供 5V⎓2A。并非每个额定为“5V⎓2A”的电源都会这样做。
可选项目
无线网络适配器
Jetson Nano 开发套件包括一个千兆以太网端口，但也支持许多常见的 USB 无线网络适配器，例如 Edimax EW-7811Un。
将图像写入 microSD 卡
要准备您的 microSD 卡，您需要一台能够通过内置 SD 卡插槽或适配器连接互联网并读写 SD 卡的计算机。
- 下载 Jetson Nano Developer Kit SD 卡映像，并记下它保存在电脑上的位置。
- 根据您使用的计算机类型，按照以下说明将图像写入您的 microSD 卡。
使用 SD 协会的 SD 存储卡格式化程序格式化您的 microSD 卡。
SD Formatter
- 下载、安装并启动用于 Windows 的 SD 存储卡格式器。
- 选择卡驱动器
- 选择“快速格式化”
- 将“卷标”留空
- 单击“格式化”开始格式化，并在警告对话框中单击“是”
使用 Etcher 将 Jetson Nano Developer Kit SD 卡映像写入您的 microSD 卡
- 下载、安装并启动蚀刻机。
Etcher overview
Etcher 用于使 sd 卡可使用 nvidia 开发商为 jetson nano 提供的 ready to go ubuntu desktop 提供的操作系统启动
- 单击“选择图像”并选择之前下载的压缩图像文件。
- 如果尚未插入 microSD 卡，请将其插入。
如果 windows 用这样的对话框提示您，请单击“取消”:
4.单击“选择驱动器”并选择正确的设备。
5.点击“闪！”如果您的 microSD 卡通过 USB3 连接，Etcher 大约需要 10 分钟来写入和验证图像。
6.Etcher 完成后，Windows 可能会让您知道它不知道如何读取 SD 卡。只需点击取消，取出 microSD 卡。
Click cancel
设置和首次引导
设置步骤
- 展开纸架，放入显影盒中。
- 将显影组件放在纸架顶部。
- 将 microSD 卡(已写入系统映像)插入 Jetson Nano 模块底部的插槽中
4.打开电脑显示器的电源并连接。
5.连接 USB 键盘和鼠标。
6.连接您的微型 USB 电源(5V⎓2A).Jetson Nano 开发套件将自动通电并启动。nvidia 一启动，显示器上的第一个输出就会是这样的。
第一次开机
一旦开发套件通电，Micro-USB 连接器旁边的绿色 LED 就会亮起。当您第一次启动时，Jetson Nano 开发工具包将带您完成一些初始设置，包括:
- 审查并接受英伟达捷成软件 EULA 公司
- 选择系统语言、键盘布局和时区
- 创建用户名、密码和计算机名
- 登录
登录后
您将看到这个屏幕。恭喜你！
Ubuntu Desktop as soon as system boots up on Nvidia Jetson Nano
故障排除
力量
如果您无法启动您的 Jetson Nano 开发工具包，问题可能出在您的 USB 电源上。请使用像这个一样的优质电源。
同样重要的是，要有优质的电源线将电源连接到开发套件:
- 最好使用永久连接电源线的电源。
- 较短的电缆会降低电压。
显示
不支持 HDMI 转 DVI 适配器。请使用支持 HDMI 或 DP 输入的显示器。
在 Nvidia Jetson Nano 上安装 tensor flow GPU
我之所以包括这一步，是因为在这个设备上安装 GPU 版本非常容易。
打开终端并输入以下命令:
安装依赖项:
sudo apt-get install python3-pip libhdf5-serial-dev hdf5-tools
安装 tensorflow-gpu 库
sudo pip3 install --pre --extra-index-url [https://developer.download.nvidia.com/compute/redist/jp/v42](https://developer.download.nvidia.com/compute/redist/jp/v42) tensorflow-gpu
如果出现 HTTP 404 Not found 错误，请尝试以下命令
pip3 安装—pre—extra-index-URLhttps://developer.download.nvidia.com/compute/redist/jp/v42tensor flow-GPU
Plot.ly 入门
Source: Bailey Zindel on Unsplash
Python 中强大可视化的引导式演练
作者:爱丽丝·李和伊桑·戴伊
Matplotlib 还行，Seaborn 很棒，但是 Plot.ly？这是一个全新的水平。Plot.ly 通过提供完全交互性的选项和许多编辑工具，提供了比一般图形更多的功能。与其他产品不同的是，它可以选择在离线和在线模式下显示图形，它还配备了一个强大的 API，当设置完成后，它将无缝地在 web 浏览器中显示图形，并能够保存本地副本。你将遇到的唯一的挫折之一是处理许多选项来找出你想要用于你的情节的工具。
概观
我们将从在 Python 中设置 plot.ly 的基础开始。在那之后，我们将从一些基本的可视化开始，从典型的盒须图到 choropleth 图，以及沿途的代码分解。我们在本指南中使用 Zillow Economics 数据集进行了所有可视化，该数据集包含 1996 年至 2017 年按位置汇总的各种住房指标的时间序列数据。如果你对这篇文章的完整代码感兴趣，可以查看下面的 GitHub 链接；否则，用于创建可视化效果的所有代码都将包含在每个可视化效果中。
我们的希望是，到最后，您将对 plotly API 如何工作有一个基本的直觉，并且对您可以应用于自己的项目的通用框架有一个感觉。你可以在这里找到一个指向 plotly cheatsheet 的链接，如果你对用于可视化的任何参数有兴趣，你可以使用help()函数访问文档。关于所有类型的图和参数的更多细节，这里的是关于 Plotly 的 Python 开源图形库的更多信息的链接。
安装
Plotly 是一个运行在 JSON 上的平台，JSON 是一种以字典格式将参数传递给 plotly API 的格式。我们可以使用plot.ly包在 python 中访问这个 API。要安装软件包，打开终端并输入$ pip install plotly或$ sudo pip install plotly。
Plotly 的图表是使用在线网络服务托管的，因此您首先需要在线设置一个免费帐户来存储您的图表。要检索您的个人 API 密钥，请点击此处的链接:https://plot.ly/settings/api#/。一旦你这样做了，你就可以用set_credential_files()函数开始设置 plotly，如下所示。
import plotlyplotly.tools.set_credentials_file(username=’YourAccountName’, api_key=’YourAPIKey’)``
在线和离线绘图
在 plotly 上显示可视化效果时，绘图和数据都会保存到您的 plotly 帐户中。无需在云中购买更多空间，您最多可以在云中存储 25 个图，但这些图像可以轻松地存储在本地，并在为更多空间腾出空间时删除。
有两种主要的方法来显示 plotly 图。如果您正在使用 Jupyter Notebook 或其他交互式 python 环境(扩展名为.ipynb的文件)，py.iplot()函数会在单元格下方的输出中显示绘图。另一方面，py.plot()返回一个可以保存的 url，并且也使用默认的 web 浏览器打开。
Plotly 离线模式也使您能够在本地保存图形。要离线绘图，您可以使用plotly.offline.plot()或plotly.offline.iplot()。同样，iplot()功能用于 Jupyter 笔记本，并将在笔记本内显示图形。plot()创建一个保存在本地的 HTML 页面，以便在网络浏览器中打开。
基本结构
正如我们之前提到的，所有 plot.ly 可视化都是使用 Json 结构创建的，Json 结构是要使用 API 修改的参数列表，因此本质上您将看到参数和通用结构来制作每个绘图，如果您学习了其中一个，您可以制作其余的。
import plotly.plotly as py
import plotly.graph_objs as go
import plotly.plotly as py:具有与 plotly 服务器通信的功能
import plotly.graph_objs as go:具有生成图形对象的功能。这是一个有用的模块，用于调用帮助来查看作为对象参数的所有属性。对象也有不同的有用方法，如 update 方法，可用于更新 plot 对象以向其添加更多信息。
广义结构
graph_objs类包含几个结构，这些结构在 plot.ly 中创建的可视化中是一致的，与类型无关。
我们从trace开始，它可以被认为是一个单独的层，包含数据和数据应该如何绘制的规范(即线条、标记、图表类型)。下面是 trace 结构的一个示例:
trace1 = {
"x": ["2017-09-30", "2017-10-31", "2017-11-30", ...],
"y": [327900.0, 329100.0, 331300.0, ...],
"line": {
"color": "#385965",
"width": 1.5
},
"mode": "lines",
"name": "Hawaii",
"type": "scatter",
}
如您所见，trace是要绘制的数据的参数字典，以及关于颜色和线型的信息。
我们可以通过将它们附加到一个列表来编译几个跟踪，我们称之为data。列表中轨迹的顺序决定了它们在最终绘图上的放置顺序。通常，数据应该是这样的:
data = [trace1, trace2, trace3, trace4]
layout = go.Layout():该对象用于数据的布局，包括数据的外观和可变特性，如标题、轴标题、字体和间距。就像trace一样，是字典的字典。
layout = {
"showlegend": True,
"title": {"text": "Zillow Home Value Index for Top 5 States"},
"xaxis": {
"rangeslider": {"visible": True},
"title": {"text": "Year from 1996 to 2017"},
"zeroline": False
},
"yaxis": {
"title": {"text": "ZHVI BottomTier"},
"zeroline": False
}
}
我们最终可以使用go.Figure()函数来编译数据和布局，它最终会被传递给我们选择的绘图函数。
fig = go.Figure(data = data, layout = layout)
条形图
go.Bar()创建一个条形图类型的图。在go.Layout()函数中，我们可以指定重要的信息，比如barmode = “group”，它将每年不同的条形图组合在一起，x 和 y 轴的标签，以及完整图表的标题。
线条图
go.Scatter()实例化散点图类型的痕迹，与条形图或其他形式相反。
我们可以使用 mode 参数更改标记的模式。即使我们使用的是散点图，我们也可以生成散点图，在散点图上创建线条和标记(点)。
mode = “lines+markers”
时间序列线图
在这里，我们添加了一个范围滑块，使用rangeslider参数调整可以包含在主图中的数据域。
我们还传递了一个颜色字典，其中包含每个州的唯一颜色。为此，我们使用了 seaborn color_palette()函数，指定了颜色范围，以及分布中需要的离散值的数量。因为 plot.ly 不接受 RGB 元组，我们可以使用as_hex()函数将输出转换为十六进制代码。
多重散点图
为了创建这个布局，我们使用make_subplots()函数创建子情节，并使用append_trace()函数将轨迹添加到网格上的特定位置，而不是将轨迹附加到单个字典。
等值区域图
有了 choropleth，我们可以使用 figure factory 类走捷径，它包含一组函数来轻松绘制更复杂的图形，如地理地图。
import plotly.figure_factory as ff
从ff.create_choropleth()函数中，我们传递一组FIPS值，或特定于每个县、市或州的地理标识码，其中values(ZHVI _ 底层)对应于要分配给该地区的数据。
最后的想法
正如上面不同类型图表的例子所描述的，Plot.ly 是一个强大的工具，可以为广泛的受众开发视觉愉悦和易于理解的情节。它有许多好处，包括可以广泛地访问离线和在线模式，并且包含可以在笔记本和网络浏览器中显示生成的图形的功能。由于在交互性方面的额外优势，Plotly 是 Matplotlib 和 Seaborn 的一个很好的替代品，并且可以增强演示的效果。
如果您有任何问题，请告诉我们！
Polynote 入门:网飞的数据科学笔记本
Source: https://polynote.org/
图沙尔·卡普尔😦https://www.tusharck.com/)
2019 年 10 月 23 日，网飞宣布开源推出 Polynote:一款新的多语言笔记本，这是他们开发的内部基于 JVM 的 ML 平台笔记本，现在向公众发布。它具有一些迄今为止您在笔记本 ide 中缺少的革命性功能，特别是对于数据科学家和机器学习研究人员来说，它通过一流的 Scala 支持、Apache Spark 集成、多语言互操作性(包括 Scala、Python 和 SQL)为他们提供了以前不存在的工具和灵活性。自动完成功能在顶部添加了樱桃。以下是帮助您设置和运行带有 Apache Spark 配置的笔记本的步骤。
设置 Polynote 笔记本 IDE 的步骤(Mac/Linux)
- 下载以下内容:
- 多项式:https://github.com/polynote/polynote/releases
- 阿帕奇火花:https://spark.apache.org/downloads.html
- Java(根据您的操作系统选择):https://www . Oracle . com/tech network/Java/javase/downloads/JDK 8-downloads-2133151 . html
2.打开终端并转到下载位置:
cd Users/user_name/Downloads
3.解压缩 tar 文件:
tar -zxvpf polynote-dist.tar.gz
cd polynote
4.解压缩 Apache Spark 文件(您可能需要根据 Spark 版本更改文件名):
tar -zxvpf spark-2.4.4-bin-hadoop2.7.tgz
cd polynote
5.现在，您需要设置一些环境变量以使 polynote 正常运行，请设置以下变量:
注 :
- 将用户名更改为您的用户
- 将 JAVA_HOME path 变量中的 jdk1.8.0_191.jdk 修改为您系统中安装的版本。要检查版本，您可以在终端上运行
java -version。
**export** **JAVA_HOME**=/Library/Java/JavaVirtualMachines/jdk1.8.0_191.jdk/Contents/Home/**export** **SPARK_HOME**=/Users/user_name/Downloads/spark-2.4.4-bin-hadoop2.7**export PATH**="$PATH:$SPARK_HOME/bin:$SPARK_HOME/sbin"
6.检查 spark-submit 是否工作，在您的终端中键入 spark-submit ，然后您应该会看到类似这样的内容。
Usage: spark-submit [options] <app jar | python file | R file> [app arguments]Usage: spark-submit --kill [submission ID] --master [spark://...]Usage: spark-submit --status [submission ID] --master [spark://...]Usage: spark-submit run-example [options] example-class [example args]
...
...
7.您还需要安装一些 python 依赖项:
pip3 install jep jedi pyspark virtualenv
注意 :如果你在 Mac 上得到一个“无效活动开发者路径”的错误，你需要通过运行下面的命令来安装 xcode 开发者工具。然后之后就可以安装上面的依赖项了。
xcode-select --install
8.在 polynote 目录下运行以下命令，在浏览器上启动笔记本 IDE(与 Google Chrome 配合使用效果最佳)
./polynote
9.打开谷歌浏览器，复制粘贴以下网址:
[http://127.0.0.1:8192/](http://127.0.0.1:8192/)
您的 Polynote 笔记本 IDE 现在应该已经启动并运行，应该会看到如下内容:
Polynote welcome page
制作您的第一个 polynote 笔记本并设置 spark 配置
- 单击左侧窗格中的加号图标创建一个笔记本。
2.在弹出的对话框中输入您的 polynote 笔记本的名称，然后按 ok。
3.点击 配置&依赖 就在你的笔记本名称上方。
4.在这里为笔记本设置 Spark 配置，点击 保存&重启 。
spark.driver.userClasspathFirst: truespark.executor.userClasspathFirst: truespark.master: local[*]
5.添加一个新单元格，添加以下代码，然后按 shift enter 键:
**val** scalaDF = spark.createDataFrame(List((8, **"bat"**),
(64, **"mouse"**),
(-27, **"horse"**)))
6.要可视化您的数据帧，运行以下代码并按下图形图标。
scalaDF
7.将打开一个弹出框，您可以在其中设置指标和轴，以可视化您的数据框架，如下所示:
Sample Graph
8.要在 python 中使用数据帧，请执行以下操作:
- 添加一个新的单元格，将该单元格的语言从 Scala 更改为 Python，并运行以下代码:
**from** pyspark.sql **import** DataFramepythonDF = DataFrame(scalaDF, sqlContext) # sqlContext is provided by PolynotepandaDF = pythonDF.toPandas()pandaDF
您可以从下面的 git URL 查看 polynote 笔记本。
https://github . com/tusharck/polynotebook-sample/blob/master/first _ polynotebook . ipynb
也可以查看下面关于混合编程语言的 polynote 文档:
https://polynote . org/docs/03-mixing-programming-languages . html
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
