使用 GitHub 页面为您的项目创建登录页面
使用自定义项目网站展示您的作品
Igor Miske 在 Unsplash 上拍摄的照片
我来自一个实验科学的背景，在那里我们要处理大量自制的实验装置和数据分析脚本。通常，这样做的结果可能是糟糕的文档和难以使用的代码，尤其是在最初的研究生(编写它的人)已经毕业并离开之后。出于这个原因，当我在研究生院研究期间开发一些数据分析脚本时，我决定尽我所能尝试并记录/演示它，以便任何未来的用户都可以直观地使用它。我努力的结果就是这个登陆页面。
我能够用 GitHub Pages 生成这个网站，GitHub Pages 是一种服务，允许您轻松地为您的存储库托管一个静态网站。这样做非常简单，您的网站将位于 URL:
https://<username>.github.io/<repository_name>
1。创建一个孤立分支
为了简单起见，我们不希望克隆我们的master分支的用户也看到将与我们的项目网站相关联的所有 HTML/CSS/JS 文件。为了解决这个问题，我们可以使用一个叫做“孤儿分支”的东西——本质上是一个位于树的根部、没有先前提交的分支。然后，通过将我们所有的网站文件保存在孤立分支中，当库被克隆时，默认情况下只有master上的文件会被显示(尽管任何人如果愿意，仍然可以访问网站分支)。
我们创建自己的孤立分支，用下面的命令将其命名为gh-pages:
git checkout --orphan gh-pages
2。清算 **gh-pages** 分支
这是我第一次做这个的时候发现最恐怖的部分。为了清除gh-pages分支，您将从文件夹中删除所有内容。放心吧，你的master分科档案没了！使用以下命令:
git rm -rf .
你会注意到所有的文件都将从你的本地工作目录中消失，这就是我第一次这么做的原因。同样，不要担心，一切都会好的！
3。添加网页文件
现在，将您的index.html文件，以及任何 CSS 样式表、Javascript 和您的网站运行所需的其他资源添加到您的本地工作目录中。现在准备并提交您的更改:
git add *
git commit -m "Commit Message"
最后，我们希望确保我们将我们的变更推到适当的分支(gh-pages)。
git push origin gh-pages
4。建立 GitHub 页面
在线导航到你的 GitHub 库，进入设置。向下滚动时，您会注意到一个标题为“GitHub Pages”的部分。在标题为“Source”的区域下，您会看到一个下拉菜单，您可以使用它来选择构建您的网站的分支。我们将选择gh-pages。
等几分钟，然后砰！你的网站应该是活的！导航你的浏览器到https://<username>.github.io/<repo_name>看你的精彩创作。
5。为分支机构建立单独的目录
随着您继续编辑您的网站和源代码，您会很快注意到您必须在两个分支之间不断切换:
# Switch to master branch
git checkout master# Switch to gh-pages branch
git checkout gh-pages
虽然简单，但过一段时间后这可能会变得很麻烦——幸运的是，我们可以使用名为worktree的特性为每个分支创建单独的目录。
首先，让我们创建一个单独的、与我们的存储库同名的新目录，或者清除我们的本地工作目录。如果我们清空当前目录，我们希望删除所有的git跟踪信息，我们可以通过以下方式来实现:
# Remove git tracking
rm -rf .git*
现在，让我们将我们的存储库重新克隆到子目录中。我们称这个目录为source，它将是我们保存所有源代码的地方。
git clone https://github.com/<username>/<reponame> source
您会注意到现在有了一个名为source的文件夹，其中包含了来自master分支的所有文件。现在让我们创建一个名为gh-pages的新目录，它将存放我们所有的网站文件:
mkdir gh-pages
导航到源文件夹:
cd source/
现在，我们使用worktree并使我们的gh-pages目录对应于远程gh-pages分支。
git worktree add ../gh-pages gh-pages
你完了！现在，你会注意到，当你转到gh-pages目录时，你将只看到gh-pages分支上的文件，如果你运行一个git branch命令，你将看到当你在source目录时你在master上，当在gh-pages目录时你在gh-pages上。
您现在可以同时自由编辑您的存储库网站和源代码，并且您在 GitHub 上有一个非常棒的项目登录页面！
结束语
感谢您的阅读！你可以在我的个人 GitHub 页面看到我的一些作品。我感谢任何反馈，你可以在 Twitter 上找到我，并在 LinkedIn 上与我联系以获取更多更新和文章。
创建 ML:一个用于训练神经网络的 GUI
让我们用 3 行代码创建一个狗和猫的分类器。
几周前，我买了一台新的笔记本电脑——2019 年的 MacBook Pro，从那以后我就喜欢上了它。很自然地，我开始试验 Swift T1 和 T2 Xcode T3，主要是为了创建一些虚拟的 iOS 应用。在那里我发现了 Create ML——一个用于训练定制神经网络的 GUI 工具。
照片由托马什·斯坦尼斯拉夫斯克在 Unsplash 拍摄
这里有一个直接来自苹果官方文档的简短声明:
将 Create ML 与 Swift 和 macOS playgrounds 等熟悉的工具配合使用，在 Mac 上创建和训练定制的机器学习模型。您可以训练模型来执行任务，如识别图像、从文本中提取含义或查找数值之间的关系。[1]
很好。所以你可以看到，它不仅仅是像我们今天要做的图像分类。
首先要注意的是，对于大多数用户来说，创建 ML 肯定会有一个巨大的缺点——这是一个苛刻的要求:你需要在 macOS 上运行。
如果你没有苹果电脑，这并不是世界末日，因为像 MacInCloud.com 这样的解决方案已经存在。我还没有亲自测试过它们，所以我不能保证你会有一个完美流畅的体验——但总比没有好。
所以概括一下，如果你想继续，你需要运行 macOS，并且安装最新版本的 Xcode 。
这篇文章的结构如下:
- 数据集下载
- 3 行来训练他们
- 模特培训
- 模型评估
- 模型保存
- 结论和下一步措施
简单提一下，在下一篇文章中，我们将创建一个 iOS 应用程序，并将我们的训练模型链接到它。 GitHub repo 已经存在，可以随意查看。
数据集下载
如前所述，我们将制作一个狗和猫的图像分类器，数据集可以从这里下载。
如果您已经下载并解压缩了它，那么在根文件夹中，您将拥有以下结构:
├── test
│ ├── cat
│ └── dog
└── train
├── cat
└── dog
这里有两件事你必须知道:
- 在训练和测试文件夹中的子文件夹名称必须相同
- 预测的类别名称将从子文件夹名称中推断出来——因此这里的猫和狗
*还在跟踪？*太好了，让我们在开始训练之前做好一切准备。
3 行来统治他们
我们现在可以打开 Xcode 并创建一个新的游乐场——一个用于 macOS 的空白游乐场:
随意命名，点击下一个。我们现在看到了以下屏幕:
太好了！在左边部分，我们将编写我们的代码，在右边部分，我们将训练我们的模型。
我们现在可以删除该占位符代码，并输入以下 3 行代码:
import CreateMLUIlet builder = MLImageClassifierBuilder()
builder.showInLiveView()
您的屏幕应该是这样的:
不要担心弃用警告，因为代码会工作得很好。现在，我们可以单击代码下方的蓝色播放按钮。几秒钟后，您将看到以下内容:
就这样，我们可以开始训练了！
模特培训
好了，现在你唯一要做的就是将 train 文件夹拖到这个 Drop Images 开始训练部分:
训练过程将立即开始，由于我们有超过 20K 的训练图像，这显然需要一些时间。所以，喝杯咖啡，休息一下，或者看看火车模型。
现在，过了一段时间(在我的机器上大约半小时)，模型被训练:
正如我们所看到的，它在训练集上表现出色，只需看看它在以前看不到的数据上的表现如何——因此在测试集上。让我们在下一节中探索这一点。
模型评估
要评估测试集上的模型，只需将测试文件夹拖至拖放图像以开始测试部分:
测试过程将大大缩短时间，因为我们只有 2500 张图像用于测试。尽管如此，你也可以休息一会儿，直到它结束。
好了，完成了吗？爽。正如我们所看到的，测试集上的准确率仍然令人印象深刻——98%。
现在我们知道我们的模型已经可以生产了，让我们在下一节探索如何导出它。
模型保存
我们需要保存这个模型，以便以后在我们的 iOS 应用程序中使用。为此，向上滚动模型培训部分并展开下拉列表:
如果您对自动填充的选项感到满意，请点击保存。记住，默认情况下，模型将被保存到 Documents 文件夹中——所以让我们快速验证一下它是否在那里:
厉害！注意**。mlmodel** 扩展？对于您希望在 iOS 上部署的任何模型，这都是强制性的，所以请记住这一点。
我们今天的工作已经完成了，所以让我们做一个简短的总结。
结论
做完这一切后，你可能想知道这个模型到底是怎么表现得这么好的？苹果官方声明如下:
Create ML 利用了苹果产品内置的机器学习基础设施，如照片和 Siri。这意味着你的图像分类和自然语言模型更小，训练时间更少。[2]
简而言之，这意味着苹果有很多预训练的模型，它只需要调整输出层(也称为迁移学习)。如果你以前用过 ResNet 或者 AlexNet ，你就会知道我在说什么。
但是现在你有了它，大约 30 分钟来训练模型，并在测试集上达到 98%的准确率——对于只有 3 行代码来说非常令人印象深刻。
请继续关注下面的文章，我们将把这个模型整合到一个 iOS 应用程序中。
感谢阅读。
喜欢这篇文章吗？成为 中等会员 继续无限制学习。如果你使用下面的链接，我会收到你的一部分会员费，不需要你额外付费。
[## 通过我的推荐链接加入 Medium-Dario rade ci
作为一个媒体会员，你的会员费的一部分会给你阅读的作家，你可以完全接触到每一个故事…
medium.com](https://medium.com/@radecicdario/membership)
资源
[1]https://developer.apple.com/documentation/createml
[2]https://developer.apple.com/documentation/createml
创建 ML:将模型部署到 iOS 应用程序
让我们创建一个简单的狗与猫的 iOS 应用程序！
几天前，我在 Create ML 部分发表了两篇文章中的第一篇，那篇讨论了收集数据和模型训练的过程。今天我们将会有更多的乐趣，因为在文章的最后，你将会在你的 iPhone 上拥有一个能够对狗和猫进行分类的应用程序(或者模拟器)!
安东尼·乔伦在 Unsplash 上的照片
作者注: 我不是 iOS 开发者，这篇文章大概不会演示最干净的解决方案。然而，它仍然完美地工作着，我发现它值得与我的读者们分享。
如果你错过了第一篇文章，你可以在这里找到它:
让我们用 3 行代码创建一个狗和猫的分类器。
towardsdatascience.com](/create-ml-a-gui-for-training-neural-networks-72bd1d651275)
请记住，您不必完全阅读它，因为模型文件可以在官方的 GitHub repo 中获得。尽管如此，我还是强烈建议你这么做，因为你会发现现在训练图像分类器是多么容易。
跟随的前提依然苛刻:
- 你需要一台苹果电脑(或者使用 MacInCloud.com)
- 最新版本的 Xcode 是必须的
- 你应该对 iOS 开发有所了解(目录结构，如何运行应用…)
如果你没有 iPhone，这很酷，因为这款应用可以在模拟器上运行。在开始编写代码之前，让我们快速浏览一下这个应用程序的最终版本,这样可以让你更有动力:
这篇文章的结构如下:
- iOS 项目创建
- 布局
- 代码
- 让我们运行它
- 结论
所以，事不宜迟，我们开始吧！
iOS 项目创建
启动 Xcode 并选择创建新的 Xcode 项目。在那里，选择单视图应用:
这将打开一个新窗口。在这里，您可以指定应用程序的名称——这样做，并将其他所有内容保留为默认值。点击下一个:
最后一步是将应用程序存储在某个地方—您决定最佳位置:
现在将创建项目。这里我们需要做的最后一步是将我们的模型包含到应用程序中。为此，只需拖动**。mlmodel** 文件到项目文件:
这一节就讲到这里。在下一个中，我们将为应用程序创建布局。
布局
布局非常简单——我们将在 Main.storyboard 文件中设计它。我的决定是将视图包装在导航控制器中，这样我们就可以在导航栏中设置摄像头按钮。
还有，导航栏有个标题——狗还是猫？
此外，在内容部分，我们有一个基本的 UIImageView 来显示一个图像，在它下面，我们有一个文本视图来显示预测的类。您看不到它，因为默认情况下它是空白的，一旦我们选择一个图像，它就会被填充。
下面是你最后应该有的截图:
如果你有一些开发 iOS 应用的经验，像这样构造简单的 UI 不是问题。我决定不一步一步地展示这个过程，因为这篇文章很快就会变得很乱。非常欢迎你克隆官方回购，卡壳了可以借鉴。
好的，如果你现在已经跟上了，你应该已经完成了布局部分。在下一节中，我们将开始编写一些代码以及管理权限。
代码
在编写任何 Swift 代码之前，我们需要获得用户的照片库许可——转到 Info.plist 并添加如下:
就这样，现在用户可以允许我们访问他/她的图像。我们现在准备写一些 Swift 代码！
我绝不是 Swift 方面的专家，恰恰相反，我认为自己是一个绝对的初学者，但我发现这段代码工作得非常完美。也许它并没有考虑到最佳实践，但是它将适合我们的需要。
以下是我们需要执行的步骤(嗯，主要步骤):
- 导入库
- 为我们的视图声明变量
- 按下相机按钮时显示图像拾取器
- 处理图像拾取器
- 为图像分类声明一个函数
- 图像拾取控制器的链接检测功能
整个代码必须写在 ViewController.swift 文件中。您可以在下面的要点中找到代码，其中的步骤被写成了注释:
这就是关于代码的大部分内容！在下一部分，我们将运行这个应用程序(但我猜你已经知道它是如何执行的——如果你看过视频演示)。
让我们运行它
现在，我们实际上可以选择在哪个设备上运行应用程序。如果您没有 iPhone，您可以从下拉菜单中选择任何模拟器:
按下启动按钮，编译运行需要一分钟左右的时间。在模拟器上，我上网下载了一些免版税的猫狗图片。
一旦你这样做了，打开应用程序来测试它。以下是从我的设备获得的分类:
是的，我们确实有很多未使用的空白，设计也不完美——但这是一篇数据科学相关的文章，而不是 UI 设计相关的文章。不管怎样，今天就到这里，让我们在下一节快速总结一下。
结论
*我是 iOS 开发者吗？最肯定不是。*在设计和代码质量方面有改进的空间吗？绝对可以。
但是，作为数据科学家，我们没有义务在 UI 设计方面表现出色。我的意思是，你拥有这些技能很好，但这不是强制性的。
这篇文章和之前的 Create ML 文章背后的唯一目标是增加趣味，让你(和我)走出舒适区。编写算法代码并花费数周时间是一回事，但如果你只知道如何使用它，那又有什么意义呢？如果没有好的方法来展示你的作品，那还有什么意义呢？
花点时间想一想。它不必是一个移动应用程序，因为一个简单的网络应用程序与上传组件将只是这个项目的罚款。
感谢阅读。
P.S. 如果模型对你的一些图片分类错误，请告诉我，因为我测试过的每一张图片都被正确分类了。
喜欢这篇文章吗？成为 中等会员 继续无限制学习。如果你使用下面的链接，我会收到你的一部分会员费，不需要你额外付费。
[## 通过我的推荐链接加入 Medium-Dario rade ci
作为一个媒体会员，你的会员费的一部分会给你阅读的作家，你可以完全接触到每一个故事…
medium.com](https://medium.com/@radecicdario/membership)
用 Python 创建音乐推荐系统
推荐系统
熟悉 Tableau 并创建一个协同过滤推荐系统
大家好！推荐系统在网上无处不在，相当标准。亚马逊、网飞和许多这样的公司都在使用推荐系统。我们要构建的这个与 Spotify 或 Youtube 音乐所用的非常相似，但要简单得多。
跟进所需的工具是 Tableau 和 Python3。你可以从这里下载 Tableau。让我先带您浏览一下数据集，稍后我将在数据可视化部分提供 Tableau 的简要介绍。
数据集
百万首歌曲数据集是一百万首当代流行音乐曲目的音频特征和元数据的免费收集。
以下是数据集的链接:
https://static.turi.com/datasets/millionsong/10000.txt
https://static.turi.com/datasets/millionsong/song_data.csv
这是我们需要合并的两个数据集。我们将使用 Python3 连接数据集，并将其导入 Tableau 进行数据可视化。
#importing all the required libraries
import numpy as np
import pandas as pd#importing both the datasets
songmetadata = pd.read_csv(r'Path where the file is located')#one of the file is a text file hence we import it with pd.read_fwf
#fwf stands for fixed width file
othersongdata = pd.read_fwf(r'Path where the file is located')#naming the columns for the othersongdata
othersongdata.columns = ['user_id','song_id','listen_count’]#merging both the datasets and removing duplicates
song_df = pd.merge(othersongdata, songmetadata.drop_duplicates(['song_id']), on="song_id", how="left")#writing the file in .csv to visualize in Tableau
song_df.to_csv(r'Path where you want to store the exported CSV file\File Name.csv', index = False)
组合数据集后，我们得到的是百万首歌曲数据集。该数据集有超过一百万个观察值。数据集由七个变量组成。
**Song_id** = Object
#Unique ID for every song in the dataset, in total there are 1000 songs in the dataset
**User_id** = Object #Unique ID for every user
**Listen_count** = int
#Number of times a song was listened by an user
**Artist_name** = Str
#Name of Artist **Title** = Str
#Title of each song
**Year** = int
#Categorical variable with lot of zero values
**Release** = Str
#Album to which the songs belong to
数据可视化
视觉化给你你不知道的问题的答案—本·施奈德曼
将数据可视化、理解数据并找到见解总是一个很好的实践。我使用 Tableau 是因为它很快，并且提供了大量可视化数据集的选项。Tableau 极大地改进了我的工作流程，而且，我提到过它对学生是免费的吗？
什么是树形图？
我不想撒谎，我喜欢树状图。我在这个项目中广泛使用它们来显示数据。它们很漂亮，可定制，需要关注。
维基百科已经用一种比我更容易理解的格式解释了它，请看下面:
树形图将分层(树形结构)数据显示为一组嵌套的矩形。树的每个分支都有一个矩形，然后用代表子分支的更小的矩形平铺。叶节点的矩形面积与数据的指定维度成比例。【1】通常叶子节点是有颜色的，以显示数据的一个单独的维度。—维基百科
（舞台上由人扮的）静态画面
在写这篇文章的时候，我在想，怎样才能最好地解释“如何在 Tableau 中创建树形图？”。而且我也不想走截图路线。我能做什么？所以我做了一个简单易懂的视频。
要将数据放入 Tableau，需要将。csv 到 excel 工作簿。您可以使用 python 中的以下命令轻松实现:
song_df.to_excel("millionsong.xlsx")
有时转换需要大量的时间，所以我在这里提供了一个可以下载的 excel 工作簿。
绝不是，这是一个全面的 Tableau 指南，它只是一个概述，让你熟悉 Tableau 如何工作以及如何制作树形图。学习 Tableau，查看免费培训，Tableau 官方网站提供这里。
第一个树形图表示数据集中 Year 变量相对于 Listen_count 的比例。该图显示数据集中有许多零。因为我们在创建音乐推荐系统时不打算使用 Year 变量，所以我们不打算删除这些观察值。
第二个树形图表示相对于数据集中的总数 Listen_count 的艺术家。酷玩乐队以 36，406 的点击率成为数据集中最受欢迎的歌手，其次是莱昂国王 T21，点击率为 32，552。
商业问题
太多的选择会让用户不知所措。如果提供的选项太多，用户可能什么都不会买。像 Spotify 这样的流媒体服务有大量的目录。识别用户可能喜欢的曲目并推荐他们可能喜欢的产品对他们的业务至关重要。
我们将创建两个播放列表，一个是受欢迎的播放列表，第二个是识别与用户已经喜欢的歌曲相似的歌曲，从而为他们提供个性化的推荐。
推荐系统
基于内容的推荐系统
CBRS 根据项目的特点和其他项目要素之间的相似性推荐项目。假设用户已经看过喜剧类型的电影，CBRS 将推荐也属于喜剧类型的电影。
协同过滤推荐系统
用户的偏好和态度被认为是创造 CFRS。CFRS 推荐与用户已经选择的项目相似的项目。我们将使用皮尔逊相关来计算相似轨迹之间的关系。
为什么我们不用联想而不用关联？
关联只描述了两个变量之间的关系，而相关不仅描述了关系，还描述了强度。因此，当我们创建一个协同过滤推荐系统时，我们使用相关性。
让我们深入研究代码！
我们将首先创建流行播放列表。我们需要的只是一些数据争论。我尝试在评论中解释代码。尽管如此，如果你有问题，你可以在下面评论。
现在我们将制作 CFRS 并创建个性化播放列表。我使用的观察是，推荐系统的结果在下面给出。
如果你还和我在一起，谢谢。有人抽出时间来看我的作品对我来说意义重大。不要害羞，因为我就是。请在我的 LinkedIn 上与我联系，说‘你好！’，这将使我的一天。
用 Python 创建 NetCDF 文件
一旦你打破了学习曲线，一个强大的数据格式
网格化的空间数据通常存储在 NetCDF 文件中。对于气候数据来说尤其如此。NetCDF 文件通过支持多个变量和详细的元数据，提供了比一些传统栅格格式更大的灵活性和透明度。由于元数据和文件结构的原因，NetCDF 文件比传统的栅格格式更难访问。本文介绍了创建 NetCDF 文件和用 Python 编写数据值的基础知识。我之前写过关于用 Python 从 NetCDF 文件中访问元数据和变量的文章。
创建 NetCDF 数据集
导入netCDF4和numpy模块。然后定义一个扩展名为.nc或.nc4的文件名。调用Dataset，用'w'指定写模式，创建 NetCDF 文件。NetCDF 文件未建立，可以写入。完成后，一定要在数据集上调用close()。
添加维度
NetCDF 文件通常包含三个维度:时间、宽度(x 或经度)和高度(y 或纬度)。宽度和高度尺寸总是固定的。时间维度是动态的(可以增长)，允许将时间步长添加到文件中。在 NetCDF 中，动态的或不断增长的维度被称为“无限的”。
可以添加无限的尺寸，并由None指定。我们将对时间变量使用无限的维度，这样它就可以增长。换句话说，我们可以继续向文件添加时间步长。此外，创建纬度和经度维度。lat和lon定义了我们文件的地理范围和维度。这里我们只是创建了一个大小为 10 的维度。这意味着生成的网格只有 10 行和 10 列。lat和lon的大小或地理距离被指定为变量。其实每个维度都会有对应的变量。
添加 NetCDF 变量
变量包含文件的实际数据。它们还定义了数据所引用的网格。这个文件将包含四个变量。纬度和经度定义了网格值和数据位置。times定义数据文件中的图层。value包含实际数据。要创建变量，指定变量名、数据类型和形状。通过引用维度名称，形状被定义为元组。还指定了附加元数据。这里我们将value的单位定义为Unknown。
分配纬度和经度值
用网格单元创建一个简单的网格，用numpy.arange测量 1 度乘 1 度。将 y 值分配给lats，将 x 值分配给lons。现在我们只需要分配与我们创建的网格尺寸相匹配的数据值。
分配 NetCDF 数据值
将两个时间步长的数据添加到我们创建的值变量中。每个时间步长由一个 2D 数数组表示。每个数组的大小必须与lat和lon尺寸相匹配。用numpy.random创建一个从 0 到 100 的随机数数组。该数组包含第一个时间步长的数据。
接下来，创建一个数组，数组中的值从 0.5 线性增加到 5.0。要做到这一点，用numpy.linspace创建两个 1D 数组，并在相反的轴上将它们加在一起。下面的代码展示了这是如何做到的。创建数组并将其分配给value后，关闭ds。您的 NetCDF 现在已保存并准备就绪。在 QGIS 中打开文件进行可视化，或在 Python 中绘制数组。结果的图像如下所示。
带有随机值的 NetCDF(由作者创建)
带有线性插值的 NetCDF(由作者创建)
结论
一旦您理解了 NetCDF 文件的基本结构，它将是处理空间数据的一种非常有用的方式。在这个例子中，我们创建了一个只有一个数据变量的文件。但是可以将多个变量添加到一个文件中，这可能会减少管理数据所需的文件数量。NetCDF 文件最有用的方面之一是阐明它们包含的数据的文档和元数据。
原载于 2020 年 7 月 13 日https://opensourceoptions.com。
使用 getattribute 创建新功能
继承、包装器、类属性等等！
图片由 josealbafotos 提供
作为一个班级的孩子，很难从父母手中夺回控制权。你可能认为一旦你父母给了你一些功能，你就不能改变它了，但事实并非如此！
我们将考虑一个例子，我们想使用父方法给我们的功能，但是我们想在调用父方法之前或之后做一些事情。如果你从一个定义在不属于你的模块中的类继承，这将特别有用。
背景
为了理解如何实现这一点，我们需要理解 Python 如何调用类方法。
考虑下面的类:
class Person:
def set_name(self,name):
self.name = nameclass Worker(Person):
def set_occupation(self,job):
self.occupation = jobxander = Worker()
所以xander是Worker的一个实例。当我们运行xander.set_name("Xander")时，会发生两件事。
- 班级在
set_name上呼叫__getattribute__ - 然后用参数
"Xander"在xander.set_name上调用__call__
我们想改变父类中一个函数的行为，但是我们没有访问它的权限(可能是因为它属于一个不同的模块)。
我们对__call__没有任何控制权，因为该函数归父函数所有。然而，我们确实可以控制我们自己的__getattribute__,所以让我们改为修改它。
功能包装
因此，要添加新功能，我们需要采用原始方法，在之前或之后添加新功能，并将其包装在新函数中。然后，我们中断__getattribute__的正常行为，注入新的包装器。
让我们看一个基本的例子，我们想在函数运行之前和之后添加print语句。
def print_wrapper(func):
def new_func(*args,**kwargs):
print(f"Running: {func.__name__}")
out = func(*args,**kwargs)
print(f"Finished: {func.__name__}")
return out return new_func
为了获得更多令人兴奋的例子，也为了更全面地理解装饰者，我在这里写下了它们:
[## 用 Python decorators 提升你的代码
日志记录、类型检查、异常处理等等！
towardsdatascience.com](/level-up-your-code-with-python-decorators-c1966d78607)
现在我们需要编写新的__getattribute__函数:
def __getattribute__(self, attr):
attribute = super(Parent, self).__getattribute__(attr)
if callable(attribute):
return print_wrapper(attribute)
else:
return attribute
检查属性是否为callable就是检查被选择的属性是否可以用参数调用，因此应用包装器是有意义的。如果属性只是一个属性，而不是一个方法，那么行为将不会改变。
综上所述，我们上面的基本示例应该是这样的:
class Person:
def set_name(self,name):
self._name = namedef print_wrapper(func):
def new_func(*args,**kwargs):
print(f"Running: {func.__name__}")
out = func(*args,**kwargs)
print(f"Finished: {func.__name__}")
return out
return new_funcclass Worker(Person):
def __getattribute__(self, attr):
attribute = Person.__getattribute__(self,attr)
if callable(attribute):
return print_wrapper(attribute)
else:
return attribute
def set_occupation(self,job):
self._job = job
当我们尝试使用它时，我们会得到:
>>> xander = Worker()
>>> xander.set_name("Xander")
Running: set_name
Finished: set_name
>>> xander.set_occupation("Butcher")
Running: set_occupation
Finished: set_occupation
>>> print(xander.__dict__)
{'_name': 'Xander', '_job': 'Butcher'}
警告的话
使用这些类型的函数，弄乱__getattribute__应该小心，每个属性都会调用它，所以添加计算密集型功能会大大降低程序的速度。摆弄像__getattribute__这样的函数也很容易导致递归错误和内核崩溃，因为类会一次又一次地调用自己。
这种递归的一个例子是，如果你使用__getattribute__调用__dict__，因为__dict__本身调用__getattribute__，所以循环继续…
我们学到了什么？
使用 Python 对象的双下划线方法可以让您节省大量时间和精力。实现同样目标的另一种方法是重新实现每个函数和装饰器。对于上面的例子来说，这可能不会太糟糕，但是想象一下，如果你的父类是像 Pandas 数据框或 NumPy 数组这样的东西，那么这将成为一项非常艰巨的任务。
使用 MLflow 项目和 Docker 创建可重用的 ML 模块
因为你永远不会只训练你的模型一次。
让我们面对现实吧，将机器学习模型投入生产并不容易。从从不同来源收集数据到调整超参数和评估模型性能，从沙盒到生产有如此多的不同步骤，如果我们不小心，可能会分散在许多相互依赖的笔记本或脚本中，所有这些都必须以正确的顺序运行才能重新创建模型。更糟糕的是，当我们迭代和评估模型的新版本时，很容易忽略记录超参数的每个组合和每个结果度量，因此我们经常会忘记在迭代模型构建过程中吸取的教训。
还记得我们用来制作模型第一版的笔记本吗？好吧，当我们完成第二版的时候，那些笔记本已经被调整和改变了太多，如果我们需要的话，我们已经没有希望重新创建第一版了。
在本文中，我将展示如何使用 MLflow 和 Docker 来创建模块化的、可重用的 ML 项目，并允许您轻松地重新创建旧版本的模型和调整参数来构建和评估新的模型。
什么是 MLflow？
MLflow 是一套开源工具，帮助管理 ML 模型开发生命周期，从早期的实验和发现，一直到在中央存储库中注册模型并将其部署为 REST 端点以执行实时推理。在本文中，我们不会涉及模型注册中心或模型部署工具。我们的重点将是 MLflow 跟踪，它允许我们在快速迭代模型的不同版本时评估和记录模型结果，以及 MLflow 项目，我们将使用它将我们的模型开发工作流打包到一个可重用的参数化模块中。
我们将建造什么
在本文中，我们将使用 TensorFlow 和 CelebA 数据集来构建一个基本的卷积神经网络，以预测给定图像的主体是否在微笑。我们将创建一个 Docker 映像，它将作为我们的训练环境，并将包含训练模型所需的所有依赖项。接下来，我们将模型训练代码打包为 MLflow 项目，最后，我们将创建一个简单的驱动程序，该程序将使用不同的超参数值异步启动项目的多次运行。
本地设置
为了跟进，您需要在本地安装 Python 3 、 Docker 和 MLflow。您可以使用pip安装 MLflow
pip install mlflow
构建模型
由于我们的重点是 MLflow，所以我不会详细介绍实际的模型，但是我会简要地介绍一些代码示例，并在本文的最后提供一个工作端到端项目的链接。
首先要做的是加载 CelebA 数据集。我们将使用 TensorFlow 数据集来完成这项工作。
从 tfds 加载的数据集不包含显式目标值。每个记录只是一个图像和关于该图像的一组属性(例如，图像中的人是否在微笑、是否戴着帽子、是否有胡子等等)。)，所以使用data_generator()函数以一种可以传递到模型中的方式格式化数据。该函数返回一个生成器，该生成器将每条记录生成为以下格式的元组:
(image, 1 if subject is smiling else 0)
我们将通过使用tf.data.from_generator并传入data_generator()函数来为模型创建训练和验证数据集。
接下来，我们将使用训练和验证数据集来构建和训练 CNN。
创建项目环境
MLflow 项目允许您以三种不同的方式定义环境: Conda、Docker 容器或本地系统。我们将在项目环境中使用 Docker 容器。
下面是我们简单项目环境的 docker 文件:
requirements.txt 文件包含运行项目所需的包: mlflow 、 tensorflow 和 *tensorflow-datasets。*和 load_data.py 脚本只是从 TensorFlow 加载 CelebA 数据集，并将结果存储在 /app/data 目录中。
注意:在现实世界的场景中，您可能不会将培训/验证数据与项目环境一起存储。相反，您的环境将只包括访问数据所需的配置和库，无论数据存储在哪里(例如，本地数据库或云存储帐户)。我这样做只是为了避免每次项目运行时从 TensorFlow 下载数据集。
打包培训代码
我们现在将前面的模型训练代码打包到一个 MLflow 项目中。MLflow 项目只是一个带有 MLproject 文件的目录，该文件定义了项目的一些内容:
- 项目将运行的环境。对我们来说，这是我们刚刚创建的 Docker 图像。
- 项目入口点。这将是构建和训练模型的 python 脚本。
- 可以传递到项目中的参数。我们将在下面定义其中的一些。
第一步是创建一个 MLproject 文件。正是在这个文件中，我们引用了将被用作项目环境的 Docker 图像。我们还将定义可以传递到项目中的任何参数。
如您所见，我们的项目将使用 gnovack/celebs-cnn 图像作为项目环境(这是上一节中创建的 Docker 图像),并将接受许多参数:批处理大小、时期数、卷积层数、训练和验证样本数，以及一个布尔值，该值指示是否在训练期间对输入图像执行一些随机转换。
接下来，我们将修改模型训练代码，以使用传入的参数，并使用 MLflow 跟踪来记录训练进度。我们将很快讨论 MLflow 跟踪，但现在只知道它由一个跟踪服务器和一个 GUI 组成，跟踪服务器在模型训练运行(MLflow 称之为实验运行)期间跟踪参数和指标，GUI 允许我们查看所有运行并可视化每次运行的性能指标。
我们可以像使用任何命令行参数一样使用argparse来访问项目输入参数。
然后我们可以使用这些参数来动态构建 CNN。我们还将在 MLflow 运行中包装模型训练，使用mlflow.start_run()告诉 MLflow 将我们的模型训练作为 MLflow 实验运行进行跟踪。
关于上述代码的几点注意事项:
mlflow.tensorflow.autolog()支持自动记录 TensorFlow 的参数、指标和模型。MLflow 支持几种机器学习框架的自动日志记录。完整列表见此:https://ml flow . org/docs/latest/tracking . html #自动记录。- 在训练期间随机旋转图像以帮助防止过度拟合的
RandomFlip层，现在根据randomize-images参数的值有条件地添加到模型中。 - 模型中卷积层的数量现在取决于参数
convolutions的值。 - 自定义回调已添加到
model.fit调用中。MLFlowCallback是一个简单的 Keras 回调类，它在每个训练期之后使用mlflow.log_metrics()向 MLflow 跟踪服务器发送模型性能指标
编写驱动程序
定义了 Docker 环境并创建了 MLflow 项目后，我们现在可以编写一个驱动程序来异步执行该项目的一些运行，从而允许我们评估超参数和神经网络架构的不同组合。
在运行项目之前，我们需要启动 MLflow 跟踪服务器。对于本例，我们将只使用您的本地计算机作为跟踪服务器，但是在您与一个工程师和/或数据科学家团队合作的环境中，您可能希望建立一个共享的跟踪服务器，该服务器始终运行，供所有团队成员共享。一些云服务，如 Databricks 和 Azure 机器学习，甚至内置了 MLflow 跟踪服务器。
要运行本地跟踪服务器并打开 MLflow GUI，请运行以下命令:
mlflow ui
我们将使用链接到 Github 中 MLflow 项目的mlflow.projects.run()方法、https://github.com/gnovack/celeb-cnn-project来运行项目(您也可以使用包含 MLflow 项目的本地目录的相对文件路径)。驱动程序脚本使用不同的参数异步运行项目三次。
我们指定synchronous=False，这样我们可以并行执行所有三次运行，而backend='local'表示项目将在您的本地机器上执行。MLflow 还支持在 Databricks 或 Kubernetes 集群上执行项目。
执行驱动程序后，进入 http://localhost:5000/ 查看 MLflow 跟踪 UI 中的三个活动运行。
MLflow 运行。(图片由作者提供)
通过深入每次运行，您可以查看模型性能指标，由于我们创建了MLFlowCallback,这些指标会在每个训练时期后更新，使我们能够在模型仍在训练时绘制这些指标。
MLflow 跟踪指标。(图片作者)
正如您从准确性数字中看到的，我们的模型在使用少量数据进行几次训练后不会赢得任何奖项，但您可以开始看到不同模型的性能趋势(例如，未使用卷积层的顶级模型似乎过度拟合数据，因为训练准确性稳步上升，而验证准确性保持相当稳定)。一旦每次运行完成，它将输出已训练的模型对象作为可以从跟踪服务器下载的工件，这意味着，通过 MLflow 跟踪，我们不仅可以访问历史训练运行的参数和指标，还可以访问已训练的模型。
当处理更复杂的模型和更大的训练数据集时，训练过程很容易需要几个小时或几天才能完成，因此能够实时查看这些指标使我们能够确定哪些参数组合可能会或可能不会产生生产质量的模型，并使我们有机会在看到性能指标中的过度拟合等趋势时停止运行。
结论
在本文中，我们已经看到了如何使用 MLflow 项目将机器学习模型的开发和训练打包到一个封装的可重用模块中，允许我们并行训练模型的几个版本，并在训练过程中实时比较它们的性能。MLflow 还让我们能够跟踪与每个历史项目运行相关的参数、指标和模型，这意味着如果需要的话，我们可以很容易地复制任何以前版本的模型。还值得注意的是，虽然我们在本文中只使用了 TensorFlow，但是 MLflow 跟踪和 MLflow 项目可以与所有主要的 ML 框架一起工作。
感谢阅读！我将留下包含本文中描述的端到端项目的存储库的链接，以及我在从事这项工作时参考的一些有用的文档。如有任何问题或意见，请随时联系我们。
Github 仓库
- 包含构建 Docker 环境所需代码的存储库:https://github.com/gnovack/celeb-cnn-base-image。
- 生成的图像存储在 Docker Hub:【https://hub.docker.com/repository/docker/gnovack/celebs-cnn
- MLflow 项目存储库包含【https://github.com/gnovack/celeb-cnn-project】ml Project 文件和张量流模型代码ml Project
- 执行 MLflow 项目并行运行的驱动程序:https://github.com/gnovack/celeb-cnn-driver
参考
- https://mlflow.org/docs/latest/projects.html#
- https://ml flow . org/docs/latest/tracking . html # tensor flow-and-keras-experimental
- https://www.tensorflow.org/datasets/catalog/celeb_a
- https://www.tensorflow.org/api_docs/python/tf/data/Dataset?hl=en
将 TensorFlow 2 深度学习分类器用作 REST API(有 GPU 支持)，第一部分
端到端 TensorFlow REST API
在这一系列文章中，我将一步一步地解释如何使用 Flask 创建和服务一个图像分类器作为 REST API！🚀稍后我们将把它归档🐳！
在 Jupyter 笔记本上编写深度学习图像分类器很棒，如果你部署你的模型，让你的客户有可能使用它，那就更棒了！
这一系列文章将帮助您从笔记本转向数据科学技术的真实使用案例！我们将深度学习分类器从零到生产🚀！
免责声明:你应该有CNN-卷积神经网络 的先验知识和经验。
我们将用来训练我们的卷积神经网络分类器的数据集是 CIFAR-10 ( 暂时不要下载)。CIFAR-10 数据集包括 10 类 60000 幅 32×32 彩色图像，每类 6000 幅图像。有 50000 个训练图像和 10000 个测试图像。
以下是数据集中的类，以及每个类中的 10 幅随机图像:
准备好了吗？我们走吧！
1 —创建我们的项目结构
受 cookiecutter-data-science 开源模板的启发太多，下面是我最喜欢的数据科学项目结构:
我最喜欢的数据科学项目结构
- 在数据/raw 中，我复制我的原始数据并在*数据/中处理；*我保留预处理过的数据。
- 在 deploy 文件夹中，您可以找到 Dockerfile 和 requirements.txt 或 environment.yml (仅保存生产库)
- 在 models 的文件夹中，我存储了保存的模型。
- 在笔记本文件夹中，我有我的笔记本(。ipynb 文件)
- 在参考文件夹中，我放入了元数据和我在项目中使用的资源的所有参考(pdf，笔记…等等)
- 在报告文件夹中，我放了所有的图表和报告(png、pdf、幻灯片),其中包含与我的团队分享的见解
- 在 src 文件夹中，我的 Python 脚本按以下方式分组:src/API文件夹用于创建 REST API 的脚本，src/ data 文件夹包含用于处理数据的脚本，src/ dags 文件夹包含我的 Airflow DAG s，src/ 【T25
- **测试文件夹包含用于测试我的应用程序的 python 脚本
- 我在那里配置我的 Python 日志记录器
- db_config.json 只是一个 json 文件，包含一些数据库访问配置
为了简化起见，让我们稍微简化一下我们的项目结构，只创建(暂时保留所有内容为空):
- 数据 文件夹
- 部署 文件夹
- 型号 文件夹
- 笔记本 文件夹
- src 文件夹内的 src/model 和 src/api 子文件夹
- environment . yml文件
- logging.yml 文件
就像我一样，你最终会得到这些文件夹
项目结构
太好了！您已经准备好了一个清晰的项目结构！让我们建立我们的工作环境！
2 —开发设置
按照以下步骤创建一个在 environment.yml 文件中定义的虚拟 Python 3 工作环境，并配置您的 GPU:
- 2.1 — 安装 Miniconda 3 (或 Anaconda 3 )
- 2.2 — 确保 conda 在您的路径上(否则将 bin 文件添加到您的 $PATH ):
*$ which conda~/anaconda3/bin/conda*
- 2.3 — 如果你有 CUDA 计算能力 3.5 或更高的 NVIDIA GPU 卡，请按照以下步骤启用 TensorFlow GPU 支持https://www . tensor flow . org/install/GPU # software _ requirements(暂时不要 pip 安装 tensorflow ！首先配置 CUDA，我们将在下一步安装 tf2(2.4)
- 2.4 — 我们现在调用我们的虚拟环境tf2-image-classifier-API*，然后在environment . yml文件中指定所需的包(复制粘贴以下代码): tensorflow-gpu 、 numpy 、 seaborn 、 jupyter 用于创建图像分类器烧瓶和女侍用于休息 API 创建。tqdm 用于获得令人愉快的进度条，最后，opencv-python 用于图像预处理！*
environment.yml 文件
- 2.5 — 现在转到项目根目录，创建一个虚拟环境:
*$ conda env create -f environment.yml*
- 2.6 — 激活虚拟环境
*conda activate tf2-image-classifier-api*
您现在应该已经激活了您的虚拟环境！
奖金(仅供参考，现在不需要):
彻底清除环境
*conda env remove — name tf2-image-classifier-api*
将环境包更新到最新的兼容版本
*conda env update -f environment.yml*
- 2.7 — 从此处 下载 CIFAR-10 数据集，但为 png 格式
- 2.8 — 将下载的 cifar.tgz 文件复制到data/raw文件夹中并解压到那里(你应该会得到 train 文件夹、 test 文件夹和 labels.txt 文件)
解压 cifar.tgz 文件并将其移动到data/raw后
太好了！现在，您的环境和数据集已经为我们的图像分类器训练和预测做好了准备！
3-加载库和数据集
首先在项目的根中运行 jupyter notebook 命令:
**$ jupyter notebook**
现在导航到http://localhost:8888/tree/notebooks
创建新笔记本
创建新的 Jupyter 笔记本
并遵循以下步骤:
3.1 —导入 tensorflow 并检查 GPU 支持
第一次，加载所需的 cuDNN libs(帮助 TensorFlow 发现您的 GPU 设备)需要几分钟时间。如果一切正常，你会得到与我相似的结果(除了我有一个 GTX 960M/CUDA v10.2)。
导入 tf2 并检查 GPU 支持
3.2-导入其他必需的库
3.3-加载数据集
但是之前我们需要定义两个方法；read _ image&load _ dataset
-
使用 OpenCV 读取图像
-
通过可视化一些图像来测试该方法
结果
从训练集中可视化的随机图像
-
加载数据集并以 numpy 数组的形式返回图像和目标
-
现在我们已经准备好加载我们的训练&测试数据集**！**
-
检查您的训练数据和测试数据形状
如果一切正常，你会得到和我相似的结果。
验证数据集形状
太好了！现在我们已经加载了库，数据集也准备好了！让我们创建我们的 CNN 架构！
4 —创建图像分类深度学习模型
我们不需要重新发明轮子，我们将使用这个 CNN 架构但是在 TensorFlow 2.2 中！
我们的 CNN 模型架构— 图片来源
整个模型总共包括 16 层:
- 批量标准化
- 与 64 个大小为(3×3)的不同滤波器进行卷积
- 最大池容量为 2
- ReLU 激活功能
- 批量标准化
4.与 128 个大小为(3×3)的不同滤波器进行卷积
5.最大池容量为 2
- ReLU 激活功能
- 批量标准化
6.与 256 个大小为(3×3)的不同滤波器进行卷积
7.最大池容量为 2
- ReLU 激活功能
- 批量标准化
8.与 512 个大小为(3×3)的不同滤波器进行卷积
9.最大池容量为 2
- ReLU 激活功能
- 批量标准化
10.展平最后卷积运算的三维输出。
11.具有 128 个单元的全连接层
- 拒绝传统社会的人
- 批量标准化
12.具有 256 个单元的全连接层
- 拒绝传统社会的人
- 批量标准化
13.具有 512 个单元的全连接层
- 拒绝传统社会的人
- 批量标准化
14.具有 1024 个单元的全连接层
- 拒绝传统社会的人
- 批量标准化
15.具有 10 个单元的全连接层(图像类的数量)
16.Softmax
4.1 —创建卷积块
定义一种创建卷积块的方法(使用最大池和批量标准化)
4.2 —创建密集块
定义一种创建密集块的方法(带丢弃和批量标准化)
4.3 —使用 TF 2 Keras 创建 CNN 模型
酷！现在我们已经准备好创建 CNN 的助手函数了！
这个函数帮助我们创建一个 CNN Keras 模型准备编译！
现在我们可以定义我们的训练超参数**😗*
训练超参数，你应该调整以获得更好的结果！
现在可以实例化我们的模型了。还有，我们来看看它的总结。
应该能打印出来
**Model: "keras_image_classification_model"
_________________________________________________________________
Layer (type) Output Shape Param #
=================================================================
inputs (InputLayer) [(None, 32, 32, 3)] 0
_________________________________________________________________
batch_normalization_15 (Batc (None, 32, 32, 3) 12
_________________________________________________________________
conv_1_features (Conv2D) (None, 32, 32, 64) 1792
_________________________________________________________________
max_pooling2d_8 (MaxPooling2 (None, 16, 16, 64) 0
_________________________________________________________________
batch_normalization_16 (Batc (None, 16, 16, 64) 256
_________________________________________________________________
conv_2_features (Conv2D) (None, 16, 16, 128) 73856
_________________________________________________________________
max_pooling2d_9 (MaxPooling2 (None, 8, 8, 128) 0
_________________________________________________________________
batch_normalization_17 (Batc (None, 8, 8, 128) 512
_________________________________________________________________
conv_3_features (Conv2D) (None, 8, 8, 256) 819456
_________________________________________________________________
max_pooling2d_10 (MaxPooling (None, 4, 4, 256) 0
_________________________________________________________________
batch_normalization_18 (Batc (None, 4, 4, 256) 1024
_________________________________________________________________
conv_4_features (Conv2D) (None, 4, 4, 512) 3277312
_________________________________________________________________
max_pooling2d_11 (MaxPooling (None, 2, 2, 512) 0
_________________________________________________________________
batch_normalization_19 (Batc (None, 2, 2, 512) 2048
_________________________________________________________________
flatten_2 (Flatten) (None, 2048) 0
_________________________________________________________________
dense_1_features (Dense) (None, 128) 262272
_________________________________________________________________
dropout_4 (Dropout) (None, 128) 0
_________________________________________________________________
batch_normalization_20 (Batc (None, 128) 512
_________________________________________________________________
dense_2_features (Dense) (None, 256) 33024
_________________________________________________________________
dropout_5 (Dropout) (None, 256) 0
_________________________________________________________________
batch_normalization_21 (Batc (None, 256) 1024
_________________________________________________________________
dense_3_features (Dense) (None, 512) 131584
_________________________________________________________________
dropout_6 (Dropout) (None, 512) 0
_________________________________________________________________
batch_normalization_22 (Batc (None, 512) 2048
_________________________________________________________________
dense_4_features (Dense) (None, 1024) 525312
_________________________________________________________________
dropout_7 (Dropout) (None, 1024) 0
_________________________________________________________________
batch_normalization_23 (Batc (None, 1024) 4096
_________________________________________________________________
dense_1 (Dense) (None, 10) 10250
_________________________________________________________________
softmax (Softmax) (None, 10) 0
=================================================================
Total params: 5,146,390
Trainable params: 5,140,624
Non-trainable params: 5,766**
精彩！5140624 个参数来训练！
4.4 —编译我们的 CNN Keras 模型
为了训练我们的模型，我们将使用 RMSprop 作为优化器& 作为损失函数。为什么稀疏分类交叉熵而不仅仅是分类交叉熵？好问题！下面是为什么是！
现在我们可以编译我们的模型了！
使用 RMSProp 作为优化器和 CategoricalCrossentropy 作为损失函数来编译 CNN 模型
4.5 —训练我们的 CNN Keras 模型
一切都准备好训练我们的模型了。然而，让我们定义三个回调:
CNN 培训！
如果一切正常，你的模特应该开始训练了！你应该得到和我相似的结果。
我的 CNN 培训！
太好了！你的 GPU 现在正在燃烧🔥！让它训练你的模型，我们将在训练结束后回来！(这里是我的 GPU 努力工作的截图)
我训练 Keras CNN 时的 GPU
如果你想像汤姆那样，就拍快照吧！
4.5 —测试我们的模型
酷！我们的分类器已经完成训练！是时候评估一下了，对吧？它是如何处理测试图像的？我们可以通过使用下面的命令启动笔记本中的 tensorboard 界面来检查这一点。
*%tensorboard --logdir logs*
此命令应启动 tensorboard，并显示精度和损耗图，用于训练和验证:
张量板
但是等等，对于一个分类器来说，准确度不是一个好的评估指标！让我们检查每一个类的精确度、召回率和 f1 分数！我们能做到这一点要感谢 scikit-learn 的 分类 _ 报告 方法:
分类报告
这些是我的结果:
*precision recall f1-score support airplane 0.84 0.86 0.85 1000
automobile 0.92 0.92 0.92 1000
bird 0.76 0.72 0.74 1000
cat 0.63 0.67 0.65 1000
deer 0.80 0.81 0.80 1000
dog 0.74 0.72 0.73 1000
frog 0.86 0.86 0.86 1000
horse 0.87 0.86 0.86 1000
ship 0.91 0.90 0.91 1000
truck 0.88 0.89 0.88 1000 accuracy 0.82 10000
macro avg 0.82 0.82 0.82 10000
weighted avg 0.82 0.82 0.82 10000*
第一次尝试不错，对吧？ 0.82 精度& 0.82 召回！我们可以调整超参数并重新训练模型以获得更好的结果！
用你的结果来回应这个故事！我很乐意检查它们！😊
让我们做一个推理测试。给出测试集中的图像，让我们发现我们的模型看到了什么！
结果
5-导出模型
不错！我们的模型在测试数据上表现很好，现在我们可以将它导出到磁盘。我们保存的模型用于进行推理，并将作为 REST API 公开！
最后，让我们通过加载来检查保存的模型是否工作正常！
精彩！精彩！精彩！您已经成功创建、训练(在 GPU 上)、测试并保存了一个 TensorFlow 2 深度学习图像分类器！
现在我们准备将它公开为一个带有 Flask 和 waste 的 REST API，稍后将所有东西 Dockerize！
准备好了吗？走吧。
6 —开发一个 REST API
但是等等，这对于一个中等的故事来说已经太多了😔！敬请关注第二部分！🚀
所有的源代码都在我的 GitHub 上👇我会继续推动一切！
* [## Hz iton/tensor flow-2-深度学习-图像-分类器-REST-API-Docker-GPU
媒体故事的源代码🚀创建和服务 TensorFlow 2 深度学习图像分类器作为 REST API 和…
github.com](https://github.com/hzitoun/tensorFlow-2-Deep-Learning-Image-Classifier-REST-API-Docker-GPU)*
太好了！感谢您的阅读！我渴望在第二部里见到你(即将上映)！
我希望我已经帮助你使用 TensorFlow 2.2 创建了一个深度学习图像分类器。在第二部分中，我们将把保存的模型公开为 REST API，稍后我们将对所有内容进行 dockerize！
如果你喜欢这个故事，请考虑分享。那会有很大帮助。
最后，我每天在 LinkedIn 上分享机器学习👉https://www.linkedin.com/in/hamed-zitoun/与我联系😊
用 Python 创建简单的光学字符识别(OCR)
宇宙魔方光学字符识别初学者指南
当为文本挖掘过程收集数据或查找其他参考资料时，我们经常会找到图像形式的源。例如，如果我们要分析 pdf 格式的单词，文件会包含文本图像。这无疑使数据处理变得困难。解决这个问题的一个方法是我们可以使用光学字符识别(OCR)。
OCR 是一种识别图像中文本的技术，例如扫描文档和照片。常用的 OCR 工具之一是 魔方 。宇宙魔方是各种操作系统的光学字符识别引擎。它最初是由惠普公司作为专有软件开发的。后来谷歌接管了开发。
目前，宇宙魔方在 Windows、macOS 和 Linux 平台上运行良好。宇宙魔方支持 Unicode (UTF-8)并支持 100 多种语言。在本文中，我们将从镶嵌 OCR 安装过程开始，并测试图像中文本的提取。
第一步是安装宇宙魔方。为了使用宇宙魔方库，我们首先需要在我们的系统上安装它。如果您正在使用 Ubuntu，您可以简单地使用 apt-get 来安装宇宙魔方光学字符识别:
sudo apt-get install tesseract-ocr
对于 macOS 用户，我们将使用自制软件来安装宇宙魔方。
brew install tesseract
对于 Windows，请参见 魔方文档 。让我们从安装侏儒怪开始。
$ pip install pytesseract
安装完成后，让我们继续用 python 应用宇宙魔方。首先，我们导入依赖项。
from PIL import Image
import pytesseract
import numpy as np
我将使用一个简单的图像来测试魔方的用法。我将使用下面的图像。
示例图像
让我们加载此图像并将其转换为文本。
filename = 'image_01.png'
img1 = np.array(Image.open(filename))
text = pytesseract.image_to_string(img1)
现在，让我们看看结果。
print(text)
这就是结果。
从宇宙魔方获得的结果对于简单的图像来说已经足够好了。因为在现实世界中很难找到真正简单的图像，所以我将添加噪声来观察宇宙魔方的性能。我将使用下面的图像。
有噪声的样本图像
然后，我们将执行与之前相同的过程。
filename = 'image_02.png'
img2 = np.array(Image.open(filename))
text = pytesseract.image_to_string(img2)
print(text)
这就是结果。
结果是……没什么。这意味着宇宙魔方无法读取有噪声的图像中的单词。
然后我们尝试使用一点图像处理来消除图像中的噪声。在这里，我将使用开放简历库。在这个实验中，我使用归一化，阈值和图像模糊。
import numpy as np
import cv2norm_img = np.zeros((img.shape[0], img.shape[1]))
img = cv2.normalize(img, norm_img, 0, 255, cv2.NORM_MINMAX)
img = cv2.threshold(img, 100, 255, cv2.THRESH_BINARY)[1]
img = cv2.GaussianBlur(img, (1, 1), 0)
那么结果就会是这样。
预处理图像
图像足够干净，然后我们将再次尝试与以前相同的过程。这就是结果。
从上图可以看出，结果与我们所期望的一致。
[## 在 Tesseract OCR 中创建文本定位和检测的简单方法
如何利用 Tesseract 来检测、定位和 OCR 文本
medium.com](https://medium.com/@fahmisalman/an-easy-way-of-creating-text-localization-and-detection-in-tesseract-ocr-24cc89ed6fbc)
可以得出的结论是，当构建扫描和处理图像的文档处理管道时，tesseract 是最合适的。这最适合高分辨率输入的情况，在这种情况下，前景文本从背景中整齐地分割出来。
创建 TFRecords 数据集并使用它来训练 ML 模型
有益于处理顺序学习模型的人
嗨，极客们，
希望你一切安好。
在这个故事中，你将了解到。什么是 TFRecords？
2。如何将数据保存为 tfrecords 文件？
3。提取 TFRecord 数据。
4。如何使用 tfrecord 中的数据集来训练模型？
PS——如果你只是来拿代码的话。从这里开始享用吧！
什么是 TFRecords？
TFRecord 是一种 Tensorflow 格式，用于存储二进制记录序列。除了顺序数据，TFrecord 还可以用于存储图像和 1D 矢量。在本文中，我们将看到如何存储和读取以下类型的数据:
(i) Integer。(int64，uint8 等。)
(二)花车。
(三)琴弦。
(四)图像。
TFRecord 只能按顺序读写。因此，它通常被用于序列模型，如 RNN，LSTM 等。但这并不意味着我们只能用它来进行连续学习。
如何将数据保存为 tfrecords 文件？
要将任何数据存储到 tfrecords，我们首先需要创建 TensorFlow 示例。这些张量流示例可以使用 tf.train.examples 函数创建。这个函数将创建一个包含一些特性的示例对象。代码如下-
example = tf.train.Example(features = tf.train.Features(feature = { }))
功能中应该有什么？
这些特征包含我们的图像、数据，还包含该数据的文件名。如果有人使用监督算法，图像的相应标签也会出现在特征中。因此，创建特征的典型代码是—
注意- 图像和相应的标签已经以字节格式保存。
一旦我们创建了一个图像的例子，我们需要把它写入一个 trfrecord 文件。这些可以使用 tfrecord writer 来完成。下面代码中的 tfrecord_file_name 是我们要存储图像的 tfrecord 的文件名。TensorFlow 会自动创建这些文件。
writer = tf.python_io.TFRecordWriter(tfrecord_file_name)
writer.write(example.SerializeToString())
存储图像的代码
提取 TFRecord 数据
如果你知道写它们的正确方法，读 tfrecord 文件就简单多了。过程是一样的。首先，我们需要创建一个用于编写 rfrecord 文件的特性字典。然后我们将使用TF . train . tfrecorddataset函数创建一个 dataset 对象。
创建数据集对象后，我们将使用下面给出的代码将该数据集对象映射到我们想要的数据集。
在上面这段代码中，函数 _extract_fn 将数据集映射到我们想要的东西的列表中(文件名、图像、标签、图像形状)。为此，我们首先解析我们在 tfrecords 生成过程中制作的示例。解析之后，我们需要使用 tf.io.decode_raw() 函数将解析后的示例解码成图像。
如何使用 tfrecord 中的数据集来训练模型？
为了使用从 tfrecord 提取的数据来训练模型，我们将在 dataset 对象上创建一个迭代器。
iterator = tf.compat.v1.data.make_initializable_iterator(batch_dataset)
创建这个迭代器后，我们将循环进入这个迭代器，这样我们就可以在从这个迭代器中提取的每个图像上训练模型。函数 extract_image 通过使用 iterator.get_next()对 tfrecord 中出现的每个图像执行此操作。关于这个函数，请参考下面的代码。
希望你现在对 tfrecord 有所了解，以及我们如何利用它们来训练模型。
编码快乐！
使用“virtualenv”创建虚拟环境，并将其添加到 Jupyter 笔记本中
你是机器学习工程师，正在使用 Python 和 Jupyter Notebook 吗？在本文中，您将看到为什么需要虚拟环境，一些现有工具的区别以及如何将虚拟环境添加到 Jupyter Notebook 中。
照片由 Hitesh Choudhary 在 Unsplash 上拍摄
下面是文章大纲:
- 为什么需要虚拟环境？
virtualenv、virtualenvwrapper、penv和venv有什么区别？- 使用
virtualenv创建一个虚拟环境 - 将虚拟环境添加到 Juypter 笔记本
为什么需要虚拟环境？
像其他编程语言一样，Python 有自己下载、存储和解析包(或库)的方式。默认情况下，您机器上的每个 Python 项目都将使用默认的 Python site-packages 目录(该目录与主 Python 安装相关联，表示为 base(root) 环境)。您可以通过以下方式找到答案:
>>> import site
>>> site.getsitepackages()
['/Users/admin/anaconda3/lib/python3.7/site-packages']
想象一个场景，你在做两个机器学习项目，其中一个使用 TensorFlow v1.5，另一个使用 TensorFlow v2。这将是一个真正的问题，因为 Python 不能区分站点包目录中的版本。TensorFlow v1.5 版和 TensorFlow v2 将驻留在同名的同一目录中。由于版本之间没有区别，两个项目将被要求使用相同的版本，这在这种情况下是不可接受的。这就是虚拟环境工具发挥作用的地方。
Python 虚拟环境的主要目的是为 Python 项目创建一个隔离的环境。每个项目都可以有自己的依赖项，不管其他项目有什么依赖项。
此外，当您需要在共享系统上工作并且没有安装软件包的权限时，虚拟环境也很有用，因为您可以在虚拟环境中安装它们。
下面是一些流行的用 Python 创建虚拟环境的库/工具:virtualenv、virtualenvwrapper、pvenv、venv。
如果你对使用conda创建虚拟环境感兴趣，可以看看:
[## 使用“conda”创建虚拟环境，并将其添加到 Jupyter 笔记本中
你正在使用 anaconda 和使用 Jupyter Notebook 和 Python 吗？在这篇文章中，你将看到如何创建虚拟的…
medium.com](https://medium.com/analytics-vidhya/create-virtual-environment-using-conda-and-add-it-to-jupyter-notebook-d319a81dfd1)
【virtualenv，virtualenvwrapper，pvenv，venv 有什么区别？
[**virtualenv**](https://virtualenv.pypa.io/en/stable/#):是创建隔离 Python 环境最流行的库。你可以通过跑pip install virtualenv得到它。它的工作原理是在本地目录中制作 Python 解释器二进制文件的精确副本(python或python3)。通过修改PATH环境变量，在它前面加上一个自定义的 bin 目录，可以激活一个环境。[**virtualenvwrapper**](https://pypi.org/project/virtualenvwrapper/):是virtualenv的一组扩展。它给你像mkvirtualenv、lssitepackages，尤其是workon这样的命令，用于在不同的virtualenv目录之间切换。如果您想要多个virtualenv目录，这个工具非常有用。**pyvenv**:是 Python 3 附带的库，但是在 Python 3.6 中贬值了，因为它有问题。[**venv**](https://docs.python.org/3.6/library/venv.html#module-venv):是 Python 3.3+附带的库。您可以使用python3 -m venv <path_to_new_env>.运行，它的作用与virtualenv相同，此外还可以延长。
virtualenv继续比venv更受欢迎，尤其是因为前者同时支持 Python 2 和 3。对初学者的一般建议是，从学习同时适用于 Python 2 和 3 的virtualenv和pip开始。在各种情况下，一旦你开始需要其他工具，就拿起它们。
使用“virtualenv”创建虚拟环境
安装virtualenv
检查你是否有virtualenv
which virtualenv
如果没有，请在您的终端中输入以下内容进行安装。
pip install virtualenv
创建虚拟环境
要在当前目录中创建虚拟环境，请执行以下操作:
virtualenv <my_env_name>
下面是一个在当前目录“/Users/admin/Code/WorkSpace/python-venv/”下创建虚拟环境“ nlp ”的例子。
⇒ virtualenv **nlp**
Using base prefix '/Users/admin/anaconda3'
New python executable in /Users/admin/Code/WorkSpace/python-venv/**nlp/bin/python**
Installing setuptools, pip, wheel...done.
使用特定版本的 Python 创建一个环境
也可以使用自己选择的 Python 解释器(比如python2.7)。
virtualenv **-p /usr/bin/python2.7** <my_env_name>
从 requirements.txt 文件创建环境
通常情况下，您总是采取以下步骤:
virtualenv <my_env_name>创造新环境source <my_env_name>/bin/activate激活新环境pip install -r requirements.txt在当前环境中安装需求
或者，你可以考虑使用 pipenv ，它结合了pip和virtualenv。
激活虚拟环境
您可以通过运行以下命令来激活虚拟环境:
source <my_env_name>/bin/activate
下面是一个激活“ nlp 的例子:
⇒ pwd
/Users/admin/Code/WorkSpace/python-venv⇒ **source nlp/bin/activate**⇒ which python
/Users/admin/Code/WorkSpace/python-venv/nlp/bin/python
停用虚拟环境
要停用当前环境，您可以键入:
deactivate
检查你所处的环境
您可以通过运行which python或which pip来快速验证您是否在环境中，如果一切顺利，这将返回 python 可执行文件在环境中的路径:
⇒ which python
/Users/admin/Code/WorkSpace/python-venv/nlp/bin/python⇒ which pip
/Users/admin/Code/WorkSpace/python-venv/nlp/bin/pip
移除环境
要删除一个环境，请确保您已将其停用，然后cd进入环境目录并键入
sudo rm -rf <my_env_name>
向 Jupyter 笔记本电脑添加虚拟环境
确保 IPython 内核可用，但是您必须手动添加一个具有不同 Python 版本或虚拟环境的内核。
首先，你需要激活你的虚拟环境。
接下来，安装为 Jupyter 提供 IPython 内核的 ipykernel :
然后，您可以通过键入以下命令将您的虚拟环境添加到 Jupyter:
python -m ipykernel install --user --name=<my_env_name>
例如:将虚拟环境" nlp "添加到 Jupyter，它应该会打印以下内容:
⇒ python -m ipykernel install --user --name=**nlp**
Installed kernelspec nlp in /Users/admin/Library/Jupyter/kernels/**nlp**
之后，您可以cd进入 env 文件夹并检查配置文件kernel.json
现在你可以在 Jupyter 笔记本中选择环境作为内核。这看起来是这样的:
从 Jupyter 笔记本中选择一个虚拟环境
在打开的笔记本中更改虚拟环境
从 Jupyter 笔记本中删除虚拟环境
删除虚拟环境后，您还需要将其从 Jupyter 中删除。先来看看有哪些内核可用。您可以使用以下命令列出它们:
⇒ jupyter kernelspec list
Available kernels:
d2l /Users/admin/Library/Jupyter/kernels/d2l
nlp /Users/admin/Library/Jupyter/kernels/nlp
...
现在，要卸载内核，您可以键入:
jupyter kernelspec uninstall <my_env_name>
尽情享受吧！
仅此而已。感谢阅读。
使用 Python 创建你想要的任何形状的单词云
创建漂亮单词云的分步指南
词云示例— Twitter 美国航空公司情绪(https://www . ka ggle . com/crowd flower/Twitter-Airline-情绪)
数据可视化(如图表、图形、信息图等。)为企业提供了交流重要信息的价值，但如果您的数据是基于文本的呢？如果你希望惊人的可视化格式突出重要的文本数据点，那么使用单词云。
如果你不熟悉单词云，它是由一组单词组成的图片，其中每个单词的大小代表频率或重要性。单词越大、越粗，在一篇文章中被提到的次数就越多，也就越重要。字云易读易懂。关键词对读者来说很突出，并且在视觉上吸引观众。
然而，你可能会厌倦看到单词 cloud 的简单形式。如果我告诉你，WordCloud 也可以根据我们的喜好定制。在本文中，我们将探索如何在 python 中生成您想要的任何形状的单词云。那么，我们开始吧。
如果想看这篇文章的完整代码，请访问我的 github 。第一步，安装将要使用的包，即 wordcloud 。打开终端(Linux / macOS)或命令提示符(windows)并键入:
$ pip install wordcloud
我们将从对互联网上的一篇文章进行网络搜集开始。如果你对网页抓取不熟悉，建议你看一下我之前的一篇文章，标题是 用 Python 制作 4 行网页抓取新闻 。
抓取网站的简单方法
towardsdatascience.com](/scraping-a-website-with-4-lines-using-python-200d5c858bb1)
在这篇文章中，我将从维基百科上抓取标题为’ 冰淇淋 ’ 的新闻。
from newspaper import Articlearticle = Article('[https://en.wikipedia.org/wiki/Ice_cream'](https://en.wikipedia.org/wiki/Ice_cream'))
article.download()
article.parse()
我们只取文章的正文，也就是:
article.text
简单词云
我们先做一个简单的单词云。第一步是导入我们将使用的依赖项。
from wordcloud import WordCloud
import matplotlib.pyplot as plt
这里我们用的是 wordcloud 库和 matplotlib。wordcloud 库用于生成单词云，matplotlib 用于显示单词云的结果。之后我们调用词云函数，显示词云。
wc = WordCloud()
wc.generate(article.text)
plt.imshow(wc, interpolation="bilinear")
plt.axis('off')
plt.show()
这是我们创造的简单单词云的结果。
简单词云
此外，wordcloud 函数有参数，包括:
- 背景颜色=背景的颜色
- max_words =使用的唯一字的最大数量
- 停用词=停用词列表
- max_font_size =最大字体大小
- random_state =确保在
- 相同的顺序，所以即使生成多次，结果也是一样的
- 宽度=输出的宽度大小
- height =输出的高度大小
让我们尝试使用上面的参数。首先，让我们导入 wordcloud 库提供的停用词
from wordcloud import STOPWORDS
然后我们输入下面的代码
wc = WordCloud(background_color="white", max_words=2000,
stopwords=STOPWORDS, max_font_size=256,
random_state=42, width=500, height=500)
wc.generate(article.text)
plt.imshow(wc, interpolation="bilinear")
plt.axis('off')
plt.show()
这就是结果。
带参数调整的简单单词云
添加自定义字体
我们也可以改变使用的字体。你可以从网站https://www.dafont.com下载字体供个人使用。接下来，在参数中输入字体的路径。
font_path = 'path/to/font'
wc = WordCloud(stopwords=STOPWORDS, font_path=font_path,
background_color="white", max_words=2000,
max_font_size=256, random_state=42,
width=500, height=500)
wc.generate(article.text)
plt.imshow(wc, interpolation="bilinear")
plt.axis('off')
plt.show()
这就是结果
自定义字体
添加自定义遮罩
接下来我们将为单词 cloud 添加一个遮罩。请记住，所用图像的背景必须是白色的，否则，系统会将背景视为物体。另外，背景不能是透明的，因为透明的颜色会被认为是黑色。我将使用下面的图像作为一个面具。
图像遮罩
我们需要添加一些依赖项来加载图像。
from PIL import Image
import numpy as np
接下来，在参数中输入字体的路径。
mask = np.array(Image.open('path/to/image'))
wc = WordCloud(stopwords=STOPWORDS, font_path=font_path,
mask=mask, background_color="white",
max_words=2000, max_font_size=256,
random_state=42, width=mask.shape[1],
height=mask.shape[0])
wc.generate(article.text)
plt.imshow(wc, interpolation="bilinear")
plt.axis('off')
plt.show()
这就是结果。
掩蔽词云
调整颜色
我们还可以调整单词 cloud 中使用的颜色。基本上，我们可以自由决定我们将使用的颜色，但在这篇文章中，我将讨论相当常用的颜色。我们只用一种颜色。但是，我们必须定义要使用的函数。
def one_color_func(word=None, font_size=None,
position=None, orientation=None,
font_path=None, random_state=None):
h = 160 # 0 - 360
s = 100 # 0 - 100
l = 50 # 0 - 100return "hsl({}, {}%, {}%)".format(h, s, l)
使用的颜色格式是 HSL 格式(色调、饱和度、亮度)。更多详情，请访问 HSL 颜色选择器 了解更多关于所用颜色的信息。那么要形成词云，我们所要做的就是将我们已经创建的函数添加到词云函数中。
wc = WordCloud(stopwords=STOPWORDS, font_path=font_path,
mask=mask, background_color="white",
max_words=2000, max_font_size=256,
random_state=42, width=mask.shape[1],
height=mask.shape[0], color_func=one_color_func)
wc.generate(article.text)
plt.imshow(wc, interpolation="bilinear")
plt.axis('off')
plt.show()
图像会是这样的。
一种颜色
除此之外，我们还可以在一定范围内随机产生相似的颜色。我将在明度中添加一个随机函数来调整颜色的亮度。
def similar_color_func(word=None, font_size=None,
position=None, orientation=None,
font_path=None, random_state=None):
h = 40 # 0 - 360
s = 100 # 0 - 100
l = random_state.randint(30, 70) # 0 - 100return "hsl({}, {}%, {}%)".format(h, s, l)
然后，和以前一样。将函数输入到 wordcloud 函数中。
wc = WordCloud(stopwords=STOPWORDS, font_path=font_path,
mask=mask, background_color="white",
max_words=2000, max_font_size=256,
random_state=42, width=mask.shape[1],
height=mask.shape[0], color_func=similar_color_func)
wc.generate(article.text)
plt.imshow(wc, interpolation="bilinear")
plt.axis('off')
plt.show()
结果会是这样的。
相似的颜色
此外，我们可以定义我们将使用的许多颜色。举个例子。
def multi_color_func(word=None, font_size=None,
position=None, orientation=None,
font_path=None, random_state=None):
colors = [[4, 77, 82],
[25, 74, 85],
[82, 43, 84],
[158, 48, 79]]
rand = random_state.randint(0, len(colors) - 1)return "hsl({}, {}%, {}%)".format(colors[rand][0], colors[rand][1], colors[rand][2])
并将该功能添加到 wordcloud 功能中。
wc = WordCloud(stopwords=STOPWORDS, font_path=font_path,
mask=mask, background_color="white",
max_words=2000, max_font_size=256,
random_state=42, width=mask.shape[1],
height=mask.shape[0], color_func=multi_color_func)
wc.generate(article.text)
plt.imshow(wc, interpolation="bilinear")
plt.axis('off')
plt.show()
结果是这样的。
多种颜色
最后但同样重要的是，根据蒙版生成颜色。我们将需要 wordcloud 库提供的功能。
from wordcloud import ImageColorGenerator
然后添加蒙版颜色，将函数添加到 wordcloud 函数中。
mask_colors = ImageColorGenerator(mask)
wc = WordCloud(stopwords=STOPWORDS, font_path=font_path,
mask=mask, background_color="white",
max_words=2000, max_font_size=256,
random_state=42, width=mask.shape[1],
height=mask.shape[0], color_func=mask_colors)
wc.generate(article.text)
plt.imshow(wc, interpolation="bilinear")
plt.axis('off')
plt.show()
这是最后的结果。
生成的颜色
正如我们所看到的，单词云的颜色遵循原始图像的颜色。
所以对于这篇文章，我希望你能从我所说的中获得新的知识。如果你有其他看法，请写在评论里。以后我会分析这个词云的用法进行文本分析。
创建您的第一个聊天机器人！
图片来自 Pixabay 的LukáSKU cius
30 秒解释聊天机器人如何工作
无论您是数据科学家、数据分析师还是软件工程师；无论你是否对 NLP 工具和方法有很强的把握，如果你在这里，你可能想知道聊天机器人是如何工作的，如何建立一个，但从来没有这个需要或机会。嗯……你现在在这里，所以让我们把它做好。
你会惊讶地发现，你很可能对创建自己的聊天机器人很熟悉
用例？
可能是查询一个简单的数据库、订购、预订、客户服务等等。我们每天都和聊天机器人互动。
里面是什么？
聊天机器人都是关于所谓的规则匹配引擎。
以最简单的形式；这就意味着当你收到一条信息时，你会怎么处理它？
一种方法是重复最初输入的内容。虽然这看起来过于简单和无趣，但是在你使用聊天机器人进入更复杂的领域之前，这个想法是一个很好的基础。
让我们把手弄脏吧
def parrot_talk(incoming_message):
bot_response = "Hi, my name is Randy the Parrot, you said: " + message
return bot_response
print(parrot_talk("hello!"))
显然这是一个简单的例子，让我们把它提高一个档次。
responses = {
"Hello": "Hey! How can I help you?",
"I need a refund": "I'm happy to help, can you give me more detail?"
}
def respond(message):
if message in responses:
return responses[message]
respond("I need a refund?")
类似于你第一次看到的，这是一个客服聊天机器人。我们在上面的字典中所做的是建立与我们的客户可能说的话相关的关键字…这些关键字然后映射到适当的响应。
显然，这里的限制是，它要求消息与字典中的键完全相同。
我们可以很快变得非常严格，对任何给定的消息使用正则表达式，创建一个标志来指示文本中各种术语的存在&然后关闭该标志来填充我们的响应。
为了更进一步，我们可以部署 ML 算法，该算法可以预测消息是否属于给定的意图或主题，然后我们可以将其映射回适当响应的字典。
挑战
你见过 LinkedIn 上的自动回复吗？你应该试着通过点击这些提示来进行对话…除了有趣，这也是对复杂和缺乏复杂的有趣探索。对于聊天机器人来说，最困难的事情之一是跟踪任何给定对话状态的能力，一旦你在 LinkedIn 上进行聊天，这一点就会非常明显。
结论
乍看之下，聊天机器人非常容易创建。祝数据科学快乐！
Linux 服务器中的 Cron 作业入门:初学者完全教程
照片由 Sai Kiran Anagani 在 Unsplash 上拍摄
动手教程
使用 cron 自动化您的日常工作
目录(仅适用于 web)
1 [What are cron, cron job, and crontab?](#bed8)
2 [Understand a cron job syntax](#4a20)
3 [How to handle an error on your cron job](#f0c2)
• [Send output to a specific file](#5f39)
• [Use /dev/null](#99b9)
4 [Write a simple cron automation script](#d7e8)
5 [Conclusion](#2c02)
6 [References](#62e2)
什么是 cron、cron job 和 crontab？
Cron 是一个帮助 Linux 用户安排任何任务的系统。然而，cron 作业是在给定时间段内运行的任何定义的任务。它可以是一个 shell 脚本或一个简单的 bash 命令。Cron job 帮助我们自动化我们的日常任务，它可以是每小时，每天，每月等。
**注意:**在大多数 Linux 系统中，我们必须获得系统管理员的许可，才能定义
**crontab**中列出的特定 cron 作业
同时，crontab 代表 cron 表。这是一个包含 cron 作业列表的 Linux 系统文件。我们在 crontab 中定义我们的任务——bash 命令、shell 脚本、Python 脚本等等。
**# Check cron service on Linux system**
sudo systemctl status cron.service
检查 Linux 系统上的 cron 服务(图片由作者提供)
理解 cron 作业语法
是时候在**crontab**上学习 cron 作业语法了。
**crontab -a <filename>**:新建一个**<filename>**作为 crontab 文件**crontab -e**:编辑我们的 crontab 文件，或者创建一个不存在的文件**crontab -l**:显示我们的 crontab 文件**crontab -r**:删除我们的 crontab 文件- 显示我们上次编辑 crontab 文件的时间
**minute(s) hour(s) day(s) month(s) weekday(s) command(s)**
crontab 文件中六列的描述(图片由作者提供)
**注意:**日名 0–6 以星期日开始。我们可以很容易地确定我们在 https://crontab.guru/的行程
如何处理 cron 作业中的错误
如果 cron 作业遇到错误，默认情况下，它会向系统管理员发送一封电子邮件。相反，当我们遇到错误时，我们将找出两种常见的方法。
1 将输出发送到特定文件
这是一种常见的方式，我总是在我的 cron 工作中使用它。很简单。我们只需要创建一个文件来保存我们的 cron 作业日志。它将打印出输出，以防作业正确完成，或者如果失败，打印出一个错误。
在本教程中，它只是创建了一个**log.out**文件。输出将被重定向到**log.out**。
* * * * * cd /home/audhi && /bin/bash shell-script.sh >> log.out
crontab 文件中上述语法的描述如下。
*** * * * ***意味着一个任务将在一周的每一天、每月的每一天、每小时的每一分钟被执行- 目录将切换到 shell-script.sh 所在的
**/home/audhi** **/bin/bash**是 Bash shell 的路径和可执行文件**>>**符号将把输出附加到一个现有文件中(**log.out**)，而单个**>**符号将覆盖该文件**shell-script.sh**是某个 shell 脚本
Linux 系统上的 crontab 文件(图片由作者提供)
注意:我们需要在 crontab 中编写完整清晰的命令。需要使用
**cd**指定文件位置
2 使用/dev/null
我们可以轻松地将 cron 作业日志和错误发送到**dev/null**，而不是通过电子邮件发送警报。无论我们向**dev/null**发送或写入什么，都将被丢弃。
* * * * * cd /home/audhi && /bin/bash shell-script.sh > /dev/null 2>&1
命令的简短描述:
**> /dev/null**告诉 cron 将输出(STDOUT)重定向到**/dev/null****2**是标准错误 (STDERR)的文件描述符**&**是文件描述符的符号(没有它，后面的**1**将是文件名)**1**是标准输出 (STDOUT)的文件描述符
**注意:**2>&1 告诉 cron 将所有错误(STDERR)重定向到与标准输出(STDOUT)相同的位置
编写一个简单的 cron 自动化脚本
为了完成本文，我创建了一个 Python 脚本来演示如何使用 cron 作业。这个 Python 脚本将从印度尼西亚最大的在线新闻之一 Kompas News 中收集新冠肺炎数据。你可以在我的 GitHub repo 找到我的新冠肺炎数据网页抓取的 Python 脚本。它的文件名是**Web Scraping Covid-19 Kompas News.py**。
打开我们的终端，键入**crontab -e**打开一个 crontab 文件。然后，向下滚动并键入以下命令。
5 16 * * * cd 'covid19 data' && /usr/bin/python3 'Web Scraping Covid-19 Kompas News.py' >> test.out
crontab 文件中上述语法的描述如下。
- crontab 位于
***/home***而我的脚本在***/home/covid19 data***所以我们需要先切换到***/home/covid19 data*** **python3**解释器位于**/usr/bin/python3**- 输出将被重定向到
***/home/covid19 data***中的**test.out**文件
注意: cron 使用本地时间
还可以学习Apache air flow作为作业编排来自动化常规任务！**
**** [## Apache Airflow 作为新冠肺炎数据的作业编排(通过电子邮件和电报发送通知)
印度尼西亚新冠肺炎数据的网络采集
medium.com](https://medium.com/analytics-vidhya/apache-airflow-as-job-orchestration-e207ba5b4ac5)
结论
cron 作业在 Linux 系统上运行，以运行和执行我们的常规任务(终端命令)。关于 cron 作业，要学习的最重要的事情是终端上的 bash 命令，如何设置我们的任务调度，并确保在我们的脚本在生产环境中运行时捕捉到所有的可能性，以便我们可以防止错误。
参考
[1] Schkn。Linux 上的 Cron Jobs 和 Crontab 讲解(2019)https://dev connected . com/Cron-Jobs-and-Crontab-on-Linux-Explained/。
[2] C .默里。 用实例了解 Linux 中的 Crontab(2019)https://Linux handbook . com/Crontab/# quick-introduction-to-key-cron-concepts。
[3]阿加莎。克龙约伯: 潘端冷卡普 untuk 佩穆拉 2020(2020)。****
在 Apache Beam 中创建您的第一个 ETL 管道
在这篇文章中，我将为您的 Python 应用程序介绍另一个 ETL 工具，叫做 Apache Beam 。
什么是阿帕奇光束？
根据维基百科:
Apache Beam 是一个开源的统一编程模型，用于定义和执行数据处理管道，包括 ETL、批处理和流(连续)处理…
与气流和路易吉不同，阿帕奇 Beam 不是服务器。它是一个包含一组 API 的编程模型。目前，它们可用于 Java、Python 和 Go 编程语言。典型的基于 Apache Beam 的管道如下所示:
(图片来源:https://beam . Apache . org/images/design-your-pipeline-linear . SVG))
从左边开始，从数据库中获取数据(提取)，然后经过多个转换步骤，最后将其存储(加载)到数据库中。
让我们讨论一些 Apache Beam 中使用的术语:
- 管道 :-一条管道封装了整个数据处理体验；从数据采集到加载到数据存储。
- p 集合 :-是数据的集合。数据可以是来自固定源的有界的或来自单个或多个流的无界的。
- PTransform :- 它是一个作用于p 集合中每个元素的进程。
- ——一个可移植的 API 层，帮助创建在不同引擎或运行程序上执行的管道。目前支持 Direct Runner(用于本地开发或测试目的)、 Apache Apex、Apache Flink、Gearpump、Apache Spark 和 Google DataFlow。
发展
使用pip安装 Python SDK:
pip install apache-beam
Apache Beam SDK 现在已经安装好了，现在我们将创建一个简单的管道，它将从文本字段中读取行，转换大小写，然后反转。
以下是管道的完整程序:
导入必要的库后，我们将调用PipelineOptions进行配置。例如，如果你正在使用谷歌云数据流，那么你需要传递必要的选项，如项目名称或云名称等。您还可以在它的flag参数中传递命令行参数，例如，输入和输出文件名。
第一步是数据摄取或获取，我们将调用ReadFromText从文本文件中读取数据。管道符号(|)是一个重载操作符，它将PTransform应用于PCollection。如果你使用过 Linux 管道，你应该不难理解。在我们的例子中，集合是通过ReadFromText产生的，然后通过ParDo a 函数传递给ToLower()。Pardo对PCollection的每个元素应用一个函数。在我们的例子中，它运行在文件的每一行。如果您在ToLower()函数中添加一个print()命令，您会看到它将遍历集合并打印存储在element变量中的每一行。我们构造一个 JSON 对象，并将每个元素的内容存储在其中。之后，它通过另一个PTransform，这次是通过ToReverse来反转内容。最后通过调用WriteToText函数将数据存储在文本文件中。当您使用file_name_suffix参数时，它会创建带有适当扩展名的输出文件，例如对于我们来说，它创建为processed-00000-of-00001.txt。默认情况下，Apache Beam 创建多个输出文件，这是在分布式系统上工作时的一种习惯。这些文件的原始内容是:
巴基斯坦的冠状病毒病例在一天内翻了一番，周一迪拜的总数为 106 例:在信德省当局确认 53 例新病例后，巴基斯坦的冠状病毒病例周一已上升至 106 例。信德省现在是巴基斯坦疫情最严重的省份，截至周一下午，共报告了 106 例冠状病毒病例中的 88 例。这是迄今为止该国新型冠状病毒病例增加最多的一次。信德省首席部长法律、反腐败机构和信息顾问穆尔塔扎·瓦哈卜(Murtaza Wahab)周一在推特上说，从与伊朗接壤的塔夫坦边境隔离区返回的 50 人新冠肺炎病毒检测呈阳性
在第一次转换时，它会将所有字符转换成小写。例如如下所示:
巴基斯坦的冠状病毒病例在一天内翻了一番，周一迪拜的总数为 106 例:在信德省当局确认 53 例新病例后，巴基斯坦的冠状病毒病例周一已上升至 106 例。
正如你所看到的，我已经返回了一个字典列表。这样做的原因是，如果我不这样做，它会在一行返回一个字符，所以冠状病毒会变成:
c
o
r
o
n
a
v
I
r
u
s
这是不希望的。我还不知道为什么会发生这种情况，把一行单词分成单个的字符，但是现在，我找到的解决方法是返回一个字典列表。在最后一次转换中，我不带任何词典返回。运行后，将创建一个名为processed-00000-of-00001 . txt的文件，该文件将包含以下内容:
从第 601 天起，我就不在这里了
。根据第 601 号法令第 35 条的规定，难民事务高级专员办事处将向难民事务高级专员办事处提供援助
。你知道吗？我不知道你在说什么。没有任何迹象表明，佛陀 601 号公路上的幸存者已经死亡
91-2005 年，全国人大常委会通过了《全国人大常委会关于维护互联网安全的决定》
如您所见，该文件现在包含相同的内容，但顺序相反。
结论
Apache Beam 是编写基于 ETL 的应用程序的好工具。我只是讨论了它的基本原理。您可以将它与云解决方案集成，并将数据存储到典型的数据库中。我希望您会发现它很有用，并将在您的下一个应用程序中尝试它。
与往常一样，代码可以在 Github 上获得。
原载于 2020 年 3 月 27 日http://blog . adnansiddiqi . me。
创建您自己的数据科学课程
约翰·施诺布里奇在 Unsplash 上的照片
如何设计个性化的数据科学学习路径
随着数据科学领域在过去十年中的发展，在线课程、学位课程和训练营的数量也在增加，这些课程和训练营有望教会你成为数据科学家所需的一切。尽管这些课程中有许多会为你提供核心原则的坚实基础，但它们绝不是针对你个人的。
随着现在数据科学可用的学习资源数量的增加，对于许多人来说，创建自己的定制学习课程可能是最佳选择。通过创建个性化的学习路径，你将只学习你需要学习的东西，深入到特别适合你的目标的领域，并且在大多数情况下，与支付学位课程或训练营相比，花费要少得多。
在下面的文章中，我将描述为什么为数据科学创建自己的课程是一个好主意，如何开始以及如何在没有老师或讲师的情况下保持继续学习的动力。
决定你想成为什么
数据科学是一个广阔的领域，事实上，有许多不同类型的角色可以在数据科学的保护伞下进行分类。就所需的技能组合而言，尤其是某些技能所需的知识深度而言，这些角色各不相同。
例如，机器学习工程师的角色将需要深入的编程和数据工程知识，因此这类角色的课程重点将更接近软件工程技能。而从事新算法和技术研究的数据科学家需要更广泛的数学和统计概念知识。
因此，提前确定你最感兴趣的数据科学领域，然后围绕你需要发展的特定技能设计课程至关重要。
你已经知道了什么？
由于数据科学是一个相对较新的领域，许多学习数据科学的人已经拥有了通过以前的工作或学术研究获得的技能和经验。在设计你的课程时，考虑你已经掌握的可以转移的技能是很重要的。
例如，如果你已经获得了一个数学学科的博士学位，那么你可能已经具备了所需的数学概念的必备知识。因此，你的课程可能更适合获取软件工程技能。然而，如果你以前做过软件工程师，这是进入数据科学越来越常见的途径，那么你的重点可能是获取机器学习算法背后的数学和统计学理论知识。
你需要学习什么？
一旦你知道了你最感兴趣的数据科学的具体领域，并从以前的研究或工作经验中确定了任何可转移的技能，就该列出你需要学习的技能了。
要做到这一点，首先要看看所有数据科学家都需要的核心技能，不管是在哪个特定领域。如今，这通常是 python、SQL、数据分析、机器和深度学习、数据工程，以及至少对机器和深度学习背后的数学和统计学的基本理解。如果你还没有这些领域的知识或经验，那就把它们添加到你的列表中。
接下来，你需要看一些你感兴趣领域的招聘广告。每份工作列出的要求将会给你一个很好的主意，在这些领域中你需要获得更深层次的知识。然后，您可以将这些添加到您的列表中。
确定你的学习风格
不同的人用不同的方式学得最好。有些人通过视觉和听觉方法学得最好，如幻灯片和视频，有些人喜欢单独或集体学习，而另一些人更喜欢通过做来学习。
20 世纪 70 年代，新西兰教师尼尔·弗莱明创造了学习风格的瓦尔克模型。这个模型将学习风格分为七种不同的类型。传统课程假设每个人通过使用特定的媒介都能学得最好。然而，我相信要真正尽可能高效地学习，找到最适合你个人学习风格的合适材料是很重要的。为了了解你是哪种类型的学习者，你可以参加这个测验。
有大量不同的学习材料可用于获取数据科学职业所需的技能。如果你是一个实用的学习者，你可以尝试基于浏览器编程的课程，如 Dataquest 和 codeacademy ，或者尝试参加 kaggle 竞赛。如果你通过讲座和视频学得更好，那么 coursera 有一系列使用这种材料的课程。
庆祝你的成功
最后，一旦你确定了你需要学习的技能和你想如何学习它们，你需要决定一种方法来跟踪你的进步，这样你就可以庆祝你的成就。
我建议创建一个学习路线图。这不必是什么花哨的东西，我用谷歌表跟踪我的。重要的是找到一种方法来记录你正在学习的技能，并包括一种方法来标记或记录你在这些技能上的进展。
我用来学习数据科学的路线图如下图所示。这包括一个带有评分系统的谷歌表单上的一长串技能。每月一次，我会对照这个技能和熟练程度列表给自己打分，并与上个月进行比较。
通过记录你的进步，并定期停下来庆祝你的成功，你将保持动力继续学习你的课程。
概括地说，要为学习数据科学创建量身定制的课程，您需要采取以下步骤:
- 决定你最感兴趣的数据科学的具体领域。
- 确定你已经拥有的任何可转移的技能。
- 列出你需要学习的技能。
- 了解你的学习方式，找到最适合你的资源。
- 想办法跟踪你的进步，定期庆祝你的成功。
关于学习数据科学的完全免费资源列表，请参见我以前的文章— 如何免费学习数据科学。
要了解如何加快学习速度，请参见— 学习数据科学的最快方法。
感谢阅读！
用熊猫创建你自己的数据框架
创建样本数据框的简单方法
由 Unsplash 上的 chuttersnap 拍摄
Pandas 是一个非常强大的 Python 数据分析库，可以加速项目的预处理步骤。在这篇文章中，我将介绍用熊猫创建样本数据框的不同方法。
练习是学习任何学科的关键基础。在编码中更是如此。为了建立流畅的编码技能，练习起着关键的作用。因此，在学习和练习数据分析和操作的基础知识时，创建自己的样本数据框架可能比在网上搜索合适的数据框架更方便。Pandas 提供了许多方法来创建具有所需形状和特征的样本数据帧。
让我们来看看创建自己的数据框架的不同方法。一如既往，我们从进口熊猫开始。
import pandas as pd
import numpy as np
我们可以创建一个字典并直接将其转换为数据帧:
dict_a = {'col_a':[1,2,5,8],
'col_b':['John','Nancy','Adam','Julia'],
'col_c':[True,True,False,True]}df_a = pd.DataFrame(dict_a)
我们甚至不需要指定数据类型，因为 pandas 能够推断出它们:
df_a 是一个相对较小的数据帧。对于某些任务，我们可能需要更大的数据框架，但是键入一个有许多条目的字典是乏味的。在这种情况下，我们可以使用 numpy 来创建样本数组。然后，这些数组可以用作字典中的值:
dict_b = {'col_a': np.random.randn(50),
'col_b': np.random.randint(10, size=50)}df_b = pd.DataFrame(dict_b)df_b.shape
(50,2)
np.random.randn(50) 创建 50 个正态分布的值， np.random.randint(10，size=50) 创建 50 个介于 0 和 10 之间的整数值。正如我们所看到的，结果数据帧的大小是(50，2)。让我们看看前 5 行:
我们还可以用 numpy 创建二维数组，并将这些数组直接转换成数据帧。要用 np.random.randint 创建二维数组，我们需要将一个元组传递给 size 参数:
df_c = pd.DataFrame(np.random.randint(10, size=(6,4)))
Pandas 分配整数列名，但是我们可以使用列参数来改变它:
df_d = pd.DataFrame(np.random.randint(10, size=(6,4)),
columns=['a','b','c','d'])
我们也可以改变索引值。这次让我们使用 np.random.randn 创建一个二维数组:
然后我们将使用 pandas 的 date_range 函数定义一个时间序列索引。然后将该索引传递给索引参数:
index = pd.date_range('2020-01-01','2020-01-05')df_e = pd.DataFrame(np.random.randn(5,4),
columns=['a','b','c','d'],
index=index)
我们还可以使用 dtype 参数指定数据类型。回想一下我们创建的第一个数据帧。熊猫从值中推断出数据类型。让我们用指定的数据类型创建相同的数据帧:
dict_a = {'col_a':[1,2,5,8],
'col_b':['John','Nancy','Adam','Julia'],
'col_c':[True,True,False,True]}df_a = pd.DataFrame(dict_a, dtype='category')
数据帧看起来相同，但数据类型不同:
我们也可以使用多个字典来创建一个数据框架。我们创建一个字典列表，并将其输入到 pd。数据帧函数。字典的值将按照它们在列表中的顺序插入数据帧:
dict_a = {'col_a':[1,2,5,8],
'col_b':['John','Nancy','Adam','Julia'],
'col_c':[True,True,False,True]}dict_b = {'col_a':[1,7,9,18],
'col_b':['a','d','c','t'],
'col_c':[True,False,False,True]}list_g = [dict_a, dict_b]df_g = pd.DataFrame(list_g)
但是，通过这种方式，字典的值将被合并并放入数据帧的一个单元格中:
熊猫的一大优点是通常有多种方法来完成一项任务。所以，千万不要把自己局限在一种方式上，去寻找不同的方式和解决方法。用这种观点处理简单的任务是很重要的，因为这也有助于解决复杂的问题。
感谢您的阅读。如果您有任何反馈，请告诉我。
用 Python 创建自己的 NFL 触地得分道具
Izaac Crayton 在 Unsplash 上拍摄的照片
用泊松分布模拟离散事件的统计框架
动机
我很兴奋地展示一些推断方法来估计触地道具，因为这些方法本身非常强大，并且有多种应用。最大的好处是，根据定义，推断方法估计目标变量的潜在分布。在这种情况下，这意味着我知道一个球员投出 2 次触地得分、3 次触地得分、4 次触地得分或 10 次触地得分的可能性有多大，而不仅仅是一个平均值。了解整个分布很重要，因为道具从来不会问你点估计。当然，除了 props 之外，这些发行版还有许多应用。例如，您可能想知道在一段固定的 DNA 上由于辐射导致的预期突变的数量，或者一年中由于机械故障导致的飞机坠毁的数量。运动更有趣，但我不得不承认它们在现实生活中不那么重要。
其次，相对于传统的统计技术，过去我在黑盒机器学习模型方面有着不成比例的经验。从 Keras API 导入密集层可以解决很多问题，但这并不令人满意。很难回答这样的问题，这个模型是否过拟合？我的模型在做什么？有了一点经验，用推理来回答这类问题就容易多了。
贝叶斯推理
当我谈到推理模型时，我通常指的是贝叶斯推理。贝叶斯推理允许我们使用先验信息来估计我们的目标。你很少会对你试图估算的东西毫无头绪。贝叶斯推理允许我们创建一个“弱信息”先验。我知道一个球员每场比赛的传球触地得分是积极的。我知道这不会是什么荒谬的事情，比如每场比赛 20 次触地得分。我可以在制作模型时使用这类信息。
假设我们想估计拉马尔·杰克逊在 2019 赛季第 3 周的传球达阵输出。我从小到大上的统计课对这个问题没有很好的解决方法。一种方法可能是平均他在第一周和第二周的产量，并以此作为猜测。或者，我们可以使用上一季的平均值。很明显，这两种方法都有缺陷。在第一周和第二周，他平均 3.5 次传球达阵。熟悉足球的人都知道，场均 3.5 次传球达阵在低量传球进攻中是完全史无前例的。他还打了一个非常弱的迈阿密海豚队，这将夸大他的数字。去年，他在常规赛中平均每场比赛有 0.86 次触地得分。即使有更大的样本量，这也不能令人满意。他很年轻，他可能在休赛期取得了一些进步。该团队还致力于围绕他的技能与人员。
很容易说他的传球触地得分会在 0.85 到 3.5 之间。很难说他的传球输出会在 0.85 到 3.5 之间的哪个点结束。这就是贝叶斯推理可以帮助我们的地方。
边际可能性
贝叶斯方法为我们提供了一种数学上可靠的方法，将先验估计与小样本数据结合起来。我想远离密集的数学，但我也认为很重要的是要注意到，在我们拥有强大的个人电脑之前，贝叶斯推理是不太可能的。如果非要我猜的话，这就是为什么它们在传统的统计学课上不被强调的原因。贝叶斯推断需要估计边际可能性，那是极其困难的。这是维基百科的解释:
不幸的是，边际可能性通常很难计算。已知一小类分布的精确解，特别是当被边缘化的参数是数据分布的 共轭先验 时。在其他情况下，需要某种 数值积分 方法，要么是一般方法如 高斯积分 或 蒙特卡罗方法 ，要么是专门用于统计问题的方法如 拉普拉斯近似
实际上，这意味着你可以成为一名世界级的数学家，或者安装 Python 和 R 包来为你完成所有繁重的工作(繁重的工作意味着从后面采样数千次来代替求解积分)。
泊松分布
泊松分布对于我们的着陆推进估算是理想的。如果您不熟悉它们，您可以将它们视为在固定时间段内对计数进行建模的一种良好而简单的方法。例如，假设我每天喝大约 0.86 杯咖啡。我每天咖啡摄入量的泊松分布可以用均值为 0.86 的泊松分布来建模。与正态分布不同，我不需要知道标准差或任何其他参数。方差等于平均值。
那似乎好得难以置信。有时候就是！在现实世界中，随着时间的推移，数据科学家很可能需要更多的参数来更好地建模计数。然而，泊松分布本身是非常强大的，没有进一步的复杂性。
我们可以使用相同的统计框架来模拟我一天喝的咖啡量和拉马尔在一场比赛中触地得分的次数，这很酷。在这篇文章中，我将把重点放在他身上，因为他是一个有趣的案例。他被幻想足球专家预测为 2019-20 年任何 16 场比赛首发中触地得分最低的球员，但最终获得了最多的触地得分。这并不一定意味着幻想分析师的工作很糟糕。离群发生！
如果 mu = 0.86，你会期望大约 41%的时间没有传球触地得分。大约 23%的情况下，你会期望两个或更多。
以下是使用泊松建模所需的假设:
- 接地计数是离散的，不能为负✅
- 触地得分是✅的独立项目
- 触地得分的平均发生率是常数✅
好吧，我承认，这些假设并不完美。在现实世界中，假设几乎从来都不是！平均速度是复杂的，比如两分钟的训练和更多的传球。还有其他可能的方法，如负二项分布或有序逻辑回归。在这种情况下，我认为 Poisson 会以更低的复杂性提供类似的性能。其他离散概率分布值得今后进一步探讨。无论你选择哪种方法，请注意小样本是一个问题，因为一个赛季只有 16 场比赛。
制作一个先验
我需要预先估计一个赛季中一个四分卫每场比赛会投多少次达阵。用外行人的话来说，我是在用以前的足球知识对每个四分卫会投多少次达阵做出有根据的猜测。如果我觉得懒，我可以用全联盟的平均值。然而，仅仅一个平均值就从我们的模型中窃取了有用的信息。我们只有 16 个数据点(有时更少！)来计算这些 QB 在传球达阵方面有多好。所以，让我们用更有力、更有信息的先验知识。
我查阅了 2014 年整个赛季的共识幻想足球预测。根据这些预测，我将专家意见作为先验。我可以更肯定他们会接近真相。当然，我在赛季后写这篇文章，拉马尔度过了职业生涯的一年。我知道追溯过去，那些专家会错的。让我们假装我不知道，因为如果我已经知道了未来，统计分析还有什么意义呢？经过一番计算，我发现每场比赛的实际传球得分与专家意见的方差为 0.22。
下面是我用NFL scraper数据逐季查找每场比赛达阵的 python 代码块。
我正试着练习一些 R(感谢反馈)。这里是 R 中相同的代码。
对于先验我们可以使用什么样的分布？我不想向你抛出另一种分布，但是第三种分布使得数学计算非常简单。我要讲的第三种分布是伽玛分布。伽马分布被称为泊松分布的共轭先验。
与正态分布不同，伽马分布由形状参数 k 和速率参数 β 定义。现在，我只有平均值和方差。这些可以用一点代数很容易地转换:
平均值= k / β
方差= k / β
对于平均值，我使用 FantasyPros 共识预测值代入 1.1 TD/G 的平均预测值。对于方差，我使用 0.22，这是我之前找到的。在这一切之后，我们终于有了拉马尔·杰克逊传球达阵的先验，这是基于对 2019 年的共识幻想预测:
检查你的先验是否有意义总是一个好主意。请注意，在 1.1 下有很大的可能性，但在 0 时可能性接近于零。从历史触地得分率来看，传球触地得分率几乎为零有点荒谬。此外，我们现在知道拉马尔·杰克逊在 MVP 赛季的场均得分约为 2.4。我们预计 2.4 有非零的可能性，但仍然非常小。这与分布是一致的。
更新先验
更新我们的伽马分布出奇的容易。我们实际上只是将数据添加到形状和速率参数中:
**import scipy.stats as ss
import numpy as np# k = shape parameter (found above)
# b = rate parameter# 100 decimals between 0 and 8 to create a smooth line
x = np.linspace(start=0, stop=8, num=100) # y = np.array([ ... season touchdown counts ])def posterior(x,y): shape = k + y.sum()
rate = b + y.size
return ss.gamma.pdf(x, shape, scale=1/rate), shape, rate**
函数只有 3 行，说明 Gamma 是个不错的选择！请注意，随着季节数据量的增加，我们对先验的依赖越来越少。此外，随着猜测的进行，我们会变得更加确定。通过许多比赛，我们可以对速度非常有信心。不幸的是，对于我们这些糟糕的数据科学家来说，由于伤病、自由球员签约、教练变更等原因，达阵率可能会随着时间而改变。这种复杂性破坏了我们的假设，因此分析并不完美。
让我们快速检查一个案例，在这个案例中，触地率与期望值相差不远。例如，德肖恩·沃森在 16 场比赛中预计有 27 次触地得分，实际上在 15 场比赛中有 26 次:
在这种情况下，我们验证了我们的先验，并且越来越确定我们是对的！我们得到的德尚沃森的泊松分布在赛季前后看起来完全一样。然而拉马尔:
拉马尔在一场对抗普通防守的比赛中 0 次触地得分的概率从大约 32%到大约 13%！
调整防御
如果我们要创造令人尊敬的预测，我们需要更多的信息，而不仅仅是谁在打四分卫。我将展示如何调整防御，并将其他效果留给您尝试建模。例如，您可能有多种方法来包括主场优势、每场比赛的传球码数或维加斯总分。然而，在如此小的样本量下，你能模拟的效果是有限的。准确的主场优势可能需要多个赛季的数据。
防御调整可能是戏剧性的。例如，新英格兰全年只允许 13 次传球触地得分。迈阿密在他们的第一场比赛中让了 5 分。我用现代的 R 和 Python 包，实际上建模这些效果真的很容易。这就是所谓的泊松回归。我们简单地构造一个线性函数:
theta =拦截+QB _ 随机 _ 效果+防御 _ 随机 _ 效果
这里的截距项本质上是一个联盟平均值。QB 的“随机效应”是他们投掷达阵球的技巧。投很多传球达阵的 QBs 会有相对高的随机效应，而防很多达阵的防守会有负的随机效应。
我们也可以像 QBs 一样给出防御的模型先验。我使用 5 年的加权平均值作为先验，除了两个例外——亚利桑那州和旧金山——我在我的代码中解释了这一点(链接如下)。
**唯一复杂的部分是，我们不能把θ代入泊松分布。我们需要一个链接函数来模拟数据的平均值。对于泊松，这意味着使用 lambda = exp(theta)。我不打算在这里深究链接函数，但是它们在所有类型的回归中都是常见的。
在 Python 中，我使用 PyMC3 对 QBs 建模。这些不是你唯一可以使用的软件包。其实我一般用 pystan。以下是两者的模型代码:
结果
终于！说实话，我以为这篇文章会短很多。这是我对 QB 通过触地投影的结果:
“CI”代表可信区间。类似于置信区间，但是如果你把两者混为一谈，会有人发疯的。
这里有一个防御的例子:
由于样本量小，这些误差线很宽。比如马特·斯塔福德，只打了 8 场。因此，他的误差线比其他人更宽。在我看来，QBs 和 defenses 的排名大致正确。你可以看到幻想足球预测先验的影响，因为尽管拉马尔投出更多的达阵，但布里斯的排名在拉马尔之前。也有可能是拉马尔打的防守更轻松。前科是一种特征，而不是缺陷。信息丰富、准确的先验通常有助于模型的准确性。我们不想对一个赛季反应过度，说拉马尔是联盟中最好的达阵传球手，而在赛季初我们认为他是最差的。前科也不占数据优势，他还是排第二！一个可能的改进是对我们不确定的年轻 QB 使用较高的方差先验，而对已经在联盟中存在很长时间的 QB 使用较低的方差先验。
我们免费得到一个很好的特写。这些排名自然会根据日程安排的强度进行调整。在收集了一个赛季的数据之后，让我们来比较一些假设的比赛。最低预期的传球触地得分比赛将是雅各比·布里塞特对阵芝加哥。最高分是德鲁·布里斯对迈阿密。这些分布应该类似于拉马尔季前赛和季后赛，但由于防守调整，稍微更具戏剧性:
根据模型，布里塞特几乎有 50%的机会不掷达阵传球。预计 Brees 将投出 3 分，但有很大范围的可能结果。
放映超级碗
我想重申，即使我显示出价值，我也不建议下这些赌注。几乎可以肯定，这种模式过于简单，无法超越市场线。我用季后赛数据更新了数据，找到了帕特·马霍斯和吉米·G 的泊松分布:
好，我们可以用这种方法计算这些人覆盖任何触地问题的概率。我查了 DK Sportsbook 的超级碗传球触地得分线。他们有 Pat Mahomes 在-215/+168 超过 1.5 传球 TDs，Jimmy Garappalo 在-112/-112 超过/低于 1.5 传球 TDs。使用泊松回归方法，我有 54%的 Mahomes 通过两个或更多的 TD，有 42%的 Jimmy Garappalo 通过两个或更多的 TD。使用一个隐含的概率计算器，这意味着我显示吉米 G 的价值在-138 以下。我显示了+117 以下的值。
Mahomes 在他的 18 场比赛中有 7 场没有得到 2 分，面对 SF 的强大防守，我认为这就是为什么泊松模型可能低估了他的传球得分。此外，他带伤打了几场比赛，这可能降低了他的“真实”总得分。
实际上，我认为市场可能会有点符合我的数字。他对阵绿湾只传了 8 次，酋长队跑位防守弱。我可能错了。与他们今年的大多数比赛不同，49 人队在这场比赛中更有可能落后，他们在本赛季的几次比赛中得了很多分。
结论
虽然这是一个简单的模型，但泊松回归是一种具有多种应用的强大方法。就像在足球比赛中，人们也可以模仿其他类型的达阵或拦截来命名一对情侣。我喜欢通过这个模型工作，我计划在未来做类似的贝叶斯推理方法。这里是我为这篇文章创建的笔记本的链接。另外，这里有一个类似的例子我跟踪模拟橄榄球比分。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
