开发和销售 Python API —从头到尾教程
本文从头到尾描述了开发 Python API 的过程，并在更困难的领域提供了帮助。
最近看了一篇博文，是关于建立自己的 API 并出售的。
我很受启发，想测试一下是否有效。仅用了 5 天时间，我就能够从头到尾创建一个 API。所以我想我会分享我遇到的问题，详细阐述文章介绍的概念，并提供一个快速的清单来自己构建一些东西。所有这些都是通过开发另一个 API 实现的。
目录
关于这篇文章
这篇文章可以被认为是其他文章的教程和理解(列在我的“灵感”部分)。
它从头到尾描绘了一幅开发 Python API 的图画，并在更困难的领域提供了帮助，比如 AWS 和 Rapidapi 的设置。
我想这对其他想做同样事情的人会有帮助。我在路上遇到了一些问题，所以我想分享一下我的方法。这也是一个很好的方式来建立副业项目，甚至可能赚一些钱。
如目录所示，它由 4 个主要部分组成，即:
- 设置环境
- 使用 Python 创建问题解决方案
- 设置 AWS
- 设置 Rapidapi
你会在 Github 上找到我所有的开源代码:
您将在 Rapidapi 上找到最终结果:
如果你觉得这篇文章有帮助，请告诉我和/或购买 Rapidapi 上的功能以示支持。
放弃
我与本文中使用的任何服务都没有关联。
我不认为自己是专家。如果你觉得我错过了重要的步骤或者忽略了什么，可以考虑在评论区指出来或者联系我。此外，始终确保监控您的 AWS 成本，不要为您不知道的事情付费。
我总是乐于听取建设性的意见以及如何改进。
使用的堆栈
我们将使用
- Github(代码托管)，
- 依赖和环境管理，
- Jupyter 笔记本(代码开发和文档)，
- Python(编程语言)，
- AWS(部署)，
- Rapidapi(销售市场)
1.创建项目手续
它总是一样的，但却是必要的。我按照以下步骤来做:
- 创建本地文件夹
mkdir NAME - 用
NAME在 Github 上创建一个新的存储库 - 创造康达环境
conda create --name NAME python=3.7 - 激活康达环境
conda activate PATH_TO_ENVIRONMENT - 创建 git 回购
git init - 连接到 Github repo。添加自述文件，提交并
*git remote add origin URL_TO_GIT_REPO
git push -u origin master*
现在我们有:
- 本地文件夹
- github 知识库
- anaconda 虚拟环境
- git 版本控制
2.创建问题的解决方案
然后我们需要创造一个解决问题的方法。为了便于演示，我将展示如何将 excel csv 文件转换成其他格式。基本功能将首先在 Jupyter 笔记本上进行编码和测试。
安装软件包
安装 jupyter 笔记本和 jupytext:
*pip install notebook jupytext*
在.git/hooks/pre-commit中设置一个钩子，用于正确跟踪 git 中的笔记本变化:
*touch .git/hooks/pre-commit
code .git/hooks/pre-commit*
把这个复制到文件里
*#!/bin/sh
# For every ipynb file in the git index, add a Python representation
jupytext --from ipynb --to py:light --pre-commit*
之后让钩子可执行(在 mac 上)
*chmod +x .git/hooks/pre-commit*
找到解决问题的方法
*pip install pandas requests*
添加一个.gitignore文件并添加数据文件夹(data/)以不将数据上传到主机。
下载数据
下载一个示例数据集 (titanic dataset) 并保存到一个数据文件夹中:
*def download(url: str, dest_folder: str):
if not os.path.exists(dest_folder):
os.makedirs(dest_folder) filename = url.split('/')[-1].replace(" ", "_")
file_path = os.path.join(dest_folder, filename) r = requests.get(url, stream=True)
if r.ok:
print("saving to", os.path.abspath(file_path))
with open(file_path, 'wb') as f:
for chunk in r.iter_content(chunk_size=1024 * 8):
if chunk:
f.write(chunk)
f.flush()
os.fsync(f.fileno())
else:
print("Download failed: status code {}\n{}".format(r.status_code, r.text)) url_to_titanic_data = 'https://web.stanford.edu/class/archive/cs/cs109/cs109.1166/stuff/titanic.csv'download(url_to_titanic_data,'./data')*
创建功能
转换格式
*df = pd.read_csv('./data/titanic.csv')
df.to_json(r'./data/titanic.json')*
Jupyter 笔记本中的转换示例
用 REST 构建服务器来执行功能
在 jupyter notebook 中开发了功能后，我们希望在 python 应用程序中实际提供该功能。
有很多方法可以使用 jupyter 笔记本的某些部分，但是为了简单起见，我们现在重新创建它。
添加一个app.py文件。
例如，我们希望用户上传一个 excel 文件并返回转换成 JSON 的文件。
浏览互联网，我们可以看到已经有软件包可以处理 flask 和 excel 格式。所以让我们利用它们。
*pip install Flask*
启动 Flask 服务器时使用
*env FLASK_APP=app.py FLASK_ENV=development flask run*
Tipp:用 Postman 测试你的后端功能。它很容易设置，并允许我们快速测试后端功能。在“表单-数据”选项卡中上传 excel:
用邮递员测试后端
在这里您可以看到上传的 titanic csv 文件和数据集返回的列名。
现在我们只需编写将 excel 转换成 json 的函数，如下所示:
*import json
import pandas as pd
from flask import Flask, requestapp = Flask(__name__)@app.route('/get_json', methods=['GET', 'POST'])
def upload_file():
if request.method == 'POST':
provided_data = request.files.get('file')
if provided_data is None:
return 'Please enter valid excel format ', 400 data = provided_data
df = pd.read_csv(data)
transformed = df.to_json() result = {
'result': transformed,
} json.dumps(result) return result if __name__ == '__main__':
app.run()*
(查看我的库中的完整代码。)
例如，现在我们有了将 csv 文件转换成 json 的功能。
3.部署到 AWS
在本地开发之后，我们想把它放到云中。
设置 zappa
在我们本地创建应用程序后，我们需要开始在一个真实的服务器上设置主机。我们将使用 zappa 。
Zappa 使得在 AWS Lambda + API Gateway 上构建和部署无服务器、事件驱动的 Python 应用程序(包括但不限于 WSGI web apps)变得超级简单。可以把它想象成 Python 应用程序的“无服务器”网络托管。这意味着无限扩展、零停机、零维护，而成本只是您当前部署的一小部分！
*pip install zappa*
由于我们使用的是 conda 环境，我们需要指定它:
*which python*
会给你/Users/XXX/opt/anaconda3/envs/XXXX/bin/python(针对 Mac)
移除bin/python/并导出
*export VIRTUAL_ENV=/Users/XXXX/opt/anaconda3/envs/XXXXX/*
现在我们能做的
*zappa init*
来设置配置。
只要点击浏览所有内容，你就会有一个zappa_settings.json的样子
*{
"dev": {
"app_function": "app.app",
"aws_region": "eu-central-1",
"profile_name": "default",
"project_name": "pandas-transform-format",
"runtime": "python3.7",
"s3_bucket": "zappa-pandas-transform-format"
}
}*
请注意，我们还没有准备好部署。首先，我们需要获得一些 AWS 凭证。
设置 AWS
AWS 凭据
首先，你需要得到一个 AWS access key id和access key
你可能认为这很简单:
要获得凭据，您需要
- 转到:http://aws.amazon.com/
- 注册并创建一个新账户(他们会给你一年试用期或类似的选择)
- 转到您的 AWS 帐户概述
- 账户菜单；子菜单:安全凭证
但是不，AWS 中的权限更多！
使用 IAM 中的用户和角色设置凭据
我发现 Peter Kazarinoff 的这篇文章非常有帮助。他非常详细地解释了下一部分。我下面的要点方法是一个快速总结，我经常引用他的步骤。如果你被困在某个地方，请查看他的文章了解更多细节。
我尽可能简单地分解它:
- 在 AWS 控制台中，在搜索框中键入 IAM。IAM 是 AWS 用户和权限仪表板。
- 创建一个组
- 为您的群组命名(例如 zappa_group)
- 为您的小组创建我们自己的特定内联策略
- 在“权限”选项卡的“内联策略”部分下，选择链接以创建新的内联策略
- 在设置权限屏幕中，单击自定义策略单选按钮，然后单击右侧的“选择”按钮。
- 创建一个用 json 格式编写的定制策略
- 通读并复制此处讨论的一项政策:【https://github.com/Miserlou/Zappa/issues/244
- 向下滚动到“我的自定义策略”查看我的策略的片段。
- 使用您的 AWS 帐号粘贴和修改 json 后，单击“验证策略”按钮以确保您复制了有效的 json。然后单击“应用策略”按钮，将内联策略附加到该组。
- 创建一个用户并将该用户添加到组中
- 回到 IAM 控制面板，使用“用户”左侧菜单选项和“添加用户”按钮创建一个新用户。
- 在“添加用户”屏幕中，为新用户命名，并选择编程访问的访问类型。然后点击“下一步:权限”按钮。
- 在“设置权限”屏幕中，选择您之前在“将用户添加到组”部分创建的组，然后单击“下一步:标记”。
- 标签是可选的。如果需要，添加标签，然后单击“下一步:查看”。
- 查看用户详细信息，然后单击“创建用户”
- 复制用户的密钥
- 先不要关闭 AWS IAM 窗口。在下一步中，您将把这些密钥复制并粘贴到一个文件中。此时，将这些密钥复制并保存到一个安全位置的文本文件中不失为一个好主意。确保不要在版本控制下保存密钥。
我的自定义策略:
*{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iam:AttachRolePolicy",
"iam:GetRole",
"iam:CreateRole",
"iam:PassRole",
"iam:PutRolePolicy"
],
"Resource": [
"arn:aws:iam::XXXXXXXXXXXXXXXX:role/*-ZappaLambdaExecutionRole"
]
},
{
"Effect": "Allow",
"Action": [
"lambda:CreateFunction",
"lambda:ListVersionsByFunction",
"logs:DescribeLogStreams",
"events:PutRule",
"lambda:GetFunctionConfiguration",
"cloudformation:DescribeStackResource",
"apigateway:DELETE",
"apigateway:UpdateRestApiPolicy",
"events:ListRuleNamesByTarget",
"apigateway:PATCH",
"events:ListRules",
"cloudformation:UpdateStack",
"lambda:DeleteFunction",
"events:RemoveTargets",
"logs:FilterLogEvents",
"apigateway:GET",
"lambda:GetAlias",
"events:ListTargetsByRule",
"cloudformation:ListStackResources",
"events:DescribeRule",
"logs:DeleteLogGroup",
"apigateway:PUT",
"lambda:InvokeFunction",
"lambda:GetFunction",
"lambda:UpdateFunctionConfiguration",
"cloudformation:DescribeStacks",
"lambda:UpdateFunctionCode",
"lambda:DeleteFunctionConcurrency",
"events:DeleteRule",
"events:PutTargets",
"lambda:AddPermission",
"cloudformation:CreateStack",
"cloudformation:DeleteStack",
"apigateway:POST",
"lambda:RemovePermission",
"lambda:GetPolicy"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"s3:ListBucketMultipartUploads",
"s3:CreateBucket",
"s3:ListBucket"
],
"Resource": "arn:aws:s3:::zappa-*"
},
{
"Effect": "Allow",
"Action": [
"s3:PutObject",
"s3:GetObject",
"s3:AbortMultipartUpload",
"s3:DeleteObject",
"s3:ListMultipartUploadParts"
],
"Resource": "arn:aws:s3:::zappa-*/*"
}
]
}*
注意:用您的 AWS 帐号替换内嵌政策中的 XXXXXXXXXXX。
您的 AWS 帐号可以通过点击“支持→”支持中心找到。您的帐号列在左上角的支持中心。上面的 json 是对我有用的。但是，我估计这组安全权限可能太开放了。为了增加安全性，你可以慢慢削减权限，看看 Zappa 是否还在部署。上面的设置是最后对我起作用的。如果你想了解更多关于运行 Zappa 所需的特定 AWS 权限，你可以在 GitHub 上深入讨论:https://github.com/Miserlou/Zappa/issues/244。
在项目中添加凭据
使用以下命令在根目录下创建一个.aws/credentials文件夹
*mkdir ~/.aws
code ~/.aws/credentials*
并从 AWS 粘贴您的凭据
*[dev]
aws_access_key_id = YOUR_KEY
aws_secret_access_key = YOUR_KEY*
与config相同
*code ~/.aws/config[default]
region = YOUR_REGION (eg. eu-central-1)*
注意，code是用我选择的编辑器 vscode 打开一个文件夹。
将分配给用户的 AWS 访问密钥 id 和秘密访问密钥保存在文件~/中。AWS/凭据。请注意。aws/ directory 需要在您的主目录中，并且凭据文件没有文件扩展名。
现在，您可以使用
*zappa deploy dev*
使用 zappa 部署应用程序
不应该再有任何错误了。但是，如果还有一些，您可以使用以下命令进行调试:
*zappa status
zappa tail*
最常见的错误是与权限相关的(然后检查您的权限策略)或关于不兼容的 python 库。无论哪种方式，zappa 都会为调试提供足够好的错误消息。
如果您更新您的代码，不要忘记使用
*zappa update dev*
AWS API 网关
要在市场上设置 API，我们需要首先用 API-key 限制它的使用，然后在市场平台上设置它。
我发现 Nagesh Bansal 的这篇文章很有帮助。他非常详细地解释了下一部分。我下面的要点方法是一个快速总结，我经常引用他的步骤。如果你被困在某个地方，请查看他的文章了解更多细节。
我再一次把它分解:
- 转到 AWS 控制台并转到 API 网关
- 点击你的 API
- 我们希望创建一个 x-api-key 来限制对 api 的不希望的访问，并且也有一个计量使用
- 为 API 创建一个使用计划，包括所需的限制和配额限制
- 创建关联的 API 阶段
- 添加 API 密钥
- 在 API 键概述部分，单击 API 键处的“显示”并复制它
- 然后将 API 与键相关联，并丢弃所有没有键的请求
- 回到 API 概述。在“资源”下，单击“/任意”转到“方法请求”。然后在“设置”中，将“需要 API 密钥”设置为真
- 对“/{proxy+}方法执行相同的操作
它看起来像这样
在 AWS API 网关中设置限制
现在，您已经限制了对 API 的访问。
4.设置 Rapidapi
在 Rapidapi 上创建 API
- 转到“我的 API”和“添加新 API”
- 添加名称、描述和类别。请注意，以后不能再更改 API 名称
- 在 settings 中，添加您的 AWS API 的 URL(它在您使用 zappa 部署时显示)
- 在“转换”下的“访问控制”部分，添加您在 AWS 中添加的 API 键
Rapidapi 中的访问控制
5.在安全选项卡中，您可以检查一切
6.然后转到“端点”,通过单击“创建 REST 端点”从 Python 应用程序添加路径
添加 REST 端点
7.为您的 API 添加图像
8.制定定价计划。Rapidapi 发表了一篇自己的关于定价选择和策略的文章。正如他们总结的那样，如何定价取决于你的偏好和产品。
9.我创建了一个免费增值定价计划。这样做的原因是，我想给免费测试它的机会，但增加了定期使用它的价格。此外，我想创建一个计划来支持我的工作。例如:
制定价格计划
10.创建一些文档和教程。这很容易解释。我们鼓励这样做，因为如果你的 API 被恰当地记录下来，人们会更容易使用它。
11.最后一步是公开您的 API。但在此之前，亲自测试一下是很有用的。
测试您自己的 API
创建私人测试计划
设置好一切之后，您当然应该使用提供的代码片段进行测试。这一步并不简单，我必须联系支持人员来理解它。现在我在这里简化一下。
为自己制定一个私人计划，不要设定任何限制。
转到 API 的“用户”部分，然后转到“免费计划用户”，选择您自己并“邀请”您加入私人计划。
将您自己加入您的私人计划
现在，您已经订阅了自己的私人计划，可以使用提供的代码片段测试功能。
使用 Rapidapi 测试端点
上传一个示例 excel 文件，然后单击“测试端点”。然后你会得到一个 200 ok 的回复。
在 Rapidapi 中测试端点
创建使用 API 的代码
现在要使用 API，您可以简单地复制 Rapidapi 提供的代码片段。例如 Python 和请求库:
*import requestsurl = "https://excel-to-other-formats.p.rapidapi.com/upload"payload = ""
headers = {
'x-rapidapi-host': "excel-to-other-formats.p.rapidapi.com",
'x-rapidapi-key': "YOUR_KEY",
'content-type': "multipart/form-data"
}response = requests.request("POST", url, data=payload, headers=headers)print(response.text)*
最终结果
https://rapidapi.com/Createdd/api/excel-to-other-formats
灵感
文章“作为产品的原料药。如何在你只知道一个后端的情况下销售你的作品？
制作一个解决问题的 API
使用无服务器架构进行部署
通过 API 市场分发
对于设置一切，我发现 Nagesh Bansal 的文章非常有帮助:
- https://medium . com/@ bansalnagesh/how-to-sell-your-API-B4 b5 C9 a 273 f 8
- https://medium . com/@ bansalnagesh/launch-your-API-on-AWS-with-0-pred-cost-using-zappa-in-10-minutes-eb6d 00623842
彼得·卡扎林诺夫的这篇文章:https://python forundergradengineers . com/deploy-server less-we B- app-AWS-lambda-zappa . html
我鼓励你也看看那些文章。
你也可以直接在 Github 上阅读我的文章(为了更好的代码格式)
关于
丹尼尔是一名企业家、软件开发人员和律师。他曾在各种 IT 公司、税务咨询、管理咨询和奥地利法院工作。
他的知识和兴趣目前围绕着编程机器学习应用程序及其所有相关方面。从本质上说，他认为自己是复杂环境的问题解决者，这在他的各种项目中都有所体现。
如果您有想法、项目或问题，请不要犹豫与我们联系。
*
你可以在 https://www.buymeacoffee.com/createdd 支持我* * [## 主页
关于我丹尼尔是一名企业家，软件开发人员和律师。他曾在各种 IT 公司，税务咨询…
www.createdd.com](https://www.createdd.com/) 
连接到:
用 Python 在 10 分钟内开发数据库驱动的 REST API
用 Python 做一个完整的 CRUD REST API。我提到过它是数据库驱动的吗？
REST APIs 在我们身边无处不在，被用来构建高质量的软件。在数据科学中，它们用于将机器学习模型部署到生产中，所以不，从长远来看，你无法避免它们。今天我们将使用 Python 和Flask-RESTful创建一个简单但功能齐全的数据库驱动 API。
照片由 Cookie 在 Unsplash 上的 Pom 拍摄
以下是所用技术的简要概述:
- Python 是一种神奇的编程语言，广泛用于各种类型的任务
- Flask-RESTful—
Flask库的扩展。使我们能够快速开发 API - SQLAlchemy —一种 ORM(对象关系映射器)。帮助我们在不编写 SQL 的情况下与数据库通信
差不多就是这样。这篇文章应该很容易理解，完成它不应该花费你超过 10-15 分钟的时间(如果按照代码进行的话)。
这篇文章的结构如下:
你可以在这里下载源代码。让我们开始吧。
问题描述
我们想创建一个存储用户数据的数据库(想想网站上的注册表单)。我们可以访问用户名、密码、真实姓名和年龄等信息。
接下来，我们想开发一个 REST API 来简化数据库处理。此外，API 使我们的逻辑可用于任何编程语言、终端和工具，如。
我们希望以尽可能简单的方式从数据库中读取、插入、更新和删除记录。让我们就这样做吧，从下一节开始。
设置和模型声明
首先，在某个地方创建一个新目录，并在其中创建一个 Python 文件。我把我的命名为app.py，因为这是一个惯例，但这不是一个要求——所以你可以随意命名你的。
让我们继续进口，好吗？我们需要几个库:Flask、Flask-RESTful、Flask-SQLAlchemy和Flask-Marshmallow。以下是进口货:
from flask import Flask, request, jsonify
from flask_sqlalchemy import SQLAlchemy
from flask_marshmallow import Marshmallow
from flask_restful import Resource, Api
当这个问题解决后，我们可以继续初始化。我们必须创建一个Flask应用程序和 API 的实例，并指定数据库的位置。我们正在使用，因此请确保您首先熟悉它:
[## Python 有一个内置的数据库——下面是如何使用它
如何利用内置数据库进行数据存储和操作
towardsdatascience.com](/python-has-a-built-in-database-heres-how-to-use-it-47826c10648a)
我们还必须制作一个SQLAlchemy和Marshmallow的实例。后者用于使处理 JSON 响应变得轻而易举。代码如下:
app = Flask(__name__)
api = Api(app)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///users.db'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
db = SQLAlchemy(app)
ma = Marshmallow(app)
厉害！现在让我们进入正题，为我们的用户声明一个模型。SQLAlchemy需要它来动态构建和执行 SQL，所以我们不必担心这个问题。如简介部分所述，我们将处理姓名、年龄、用户名和密码等数据。
我们需要指定数据类型和它们的大小，所以SQLAlchemy可以创建表。这一切都发生在继承自SQLAlchemy.Model的class内。最后，我们将把参数传递给类的构造函数。代码如下:
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(32), unique=True)
password = db.Column(db.String(32))
first_name = db.Column(db.String(32))
last_name = db.Column(db.String(32))
age = db.Column(db.Integer)
def __init__(self, username, password, first_name, last_name, age):
self.username = username
self.password = password
self.first_name = first_name
self.last_name = last_name
self.age = age
上面的代码片段应该易于阅读和理解，因为没有什么复杂的东西。现在我们可以为我们的用户声明一个模式。这只是继承自Marshmallow.Schema的另一个类，用于避免令人头疼的 JSON 解析。代码如下:
class UserSchema(ma.Schema):
class Meta:
fields = ('id', 'username', 'password', 'first_name', 'last_name', 'age')
此时，我们已经准备好初始化数据库并创建users表。为此，在根文件夹中打开一个新窗口，执行如下所示的所有操作:
厉害！我们需要做的最后一件事是使用声明的UserSchema。我们将声明两个变量——一个用于获取单个用户，另一个用于获取多个用户:
user_schema = UserSchema()
users_schema = UserSchema(many=True)
我们现在可以继续实际的 API 开发了。
API 开发
现在，我们将处理五件不同的事情:
所有这些逻辑都写在一个名为UserManager的类中。你可以随意命名你的名字，但这个似乎更合适。在谈到我们需要编写的样板代码的数量时,Flask-RESTful非常友好。它是最小的。首先，我们需要声明一个继承自Flask-RESTful.Resource的类。这是一个起始代码:
class UserManager(Resource):
pass
我们将从实现获取一个/所有用户的逻辑开始。后面的每个代码块都在UserManager类中。
获取用户
在UserManager类中，我们将声明一个名为get的静态方法。这一次命名非常重要，因为方法的名称代表了我们打算发出的 HTTP 请求的类型。请求是获取数据最合适的方式，所以我们将使用它。
逻辑是这样的:
- 检查用户是否在 URL 后面附加了
ID参数——如果是，我们需要单个用户的数据。如果没有，我们需要所有用户的数据 - 通过
SQLAlchemy进行相应的查询 - 使用
flask.jsonify函数返回 JSON 格式的数据
这是代码:
@staticmethod
def get():
try: id = request.args['id']
except Exception as _: id = None
if not id:
users = User.query.all()
return jsonify(users_schema.dump(users))
user = User.query.get(id)
return jsonify(user_schema.dump(user))
让我们继续插入新用户。
插入用户
这次我们将使用 HTTP 请求。这意味着用户应该以 JSON 格式为新用户传递数据——在测试部分会有更多的介绍。此外，我们的新静态方法必须命名为post。
这是我们必须实现的逻辑:
- 获取提供的用户名、密码、名字、姓氏和年龄的 JSON 数据
- 用提供的数据创建一个
User类的实例 - 将该用户添加到数据库中，并提交事务
- 返回一条消息，表明用户已被插入
这是一个相对简单的函数。代码如下:
@staticmethod
def post():
username = request.json['username']
password = request.json['password']
first_name = request.json['first_name']
last_name = request.json['last_name']
age = request.json['age']
user = User(username, password, first_name, last_name, age)
db.session.add(user)
db.session.commit()
return jsonify({
'Message': f'User {first_name} {last_name} inserted.'
})
让我们继续更新现有用户。
更新用户
要更新现有用户，我们将使用 HTTP 请求。然后，静态方法被命名为put，您已经猜到了。这是逻辑的概述:
- 检查呼叫中是否传递了用户
ID。否则，将返回一条错误消息。这是因为我们一次只更新一个用户 - 获取提供的用户名、密码、名字、姓氏和年龄的 JSON 数据
- 根据提供的数据为数据库用户设置值，并提交事务
- 返回一条消息，表明用户已被更新
这种方法比前一种稍微复杂一点，但是仍然相当容易实现:
@staticmethod
def put():
try: id = request.args['id']
except Exception as _: id = None
if not id:
return jsonify({ 'Message': 'Must provide the user ID' })
user = User.query.get(id)
username = request.json['username']
password = request.json['password']
first_name = request.json['first_name']
last_name = request.json['last_name']
age = request.json['age']
user.username = username
user.password = password
user.first_name = first_name
user.last_name = last_name
user.age = age
db.session.commit()
return jsonify({
'Message': f'User {first_name} {last_name} altered.'
})
删除用户
这是我们要实现的最终方法。它的任务是从数据库中删除单个用户。我相信您现在已经猜到我们将发出什么类型的 HTTP 请求，以及必须如何调用该方法。逻辑是这样的:
- 检查呼叫中是否传递了用户
ID。否则，将返回一条错误消息。这是因为我们一次只删除一个用户 - 从数据库中删除用户并提交事务
- 返回一条消息，表明用户已被更新
代码如下:
@staticmethod
def delete():
try: id = request.args['id']
except Exception as _: id = None
if not id:
returnjsonify({ 'Message': 'Must provide the user ID' })
user = User.query.get(id)
db.session.delete(user)
db.session.commit()
return jsonify({
'Message': f'User {str(id)} deleted.'
})
整个UserManager班就这样。接下来让我们完成文件，开始测试。
收尾
为了完成app.py文件，我们需要将UserManager类附加到某个实际的端点上。我已经决定把我的名字命名为/api/users，但是命名的决定取决于你。
此外，从终端执行文件后，我们需要运行Flask应用程序。以下是两者的代码:
api.add_resource(UserManager, '/api/users')
if __name__ == '__main__':
app.run(debug=True)
就这样——我们可以开始测试了。
测试
要启动我们的应用程序，请在根文件夹中打开一个新的终端窗口，并运行以下命令:
厉害！API 现在在http://127.0.0.1:5000/api/users运行，我们可以开始测试了。为了使这个过程简单明了，我决定使用这个应用程序。您不必这样做，因为您可以直接从 Python 甚至从终端做任何事情。我们将从插入开始，因为这对空数据库最有意义。
如果您正在跟随，请打开 Postman 并按照下面的说明进行操作。
创建新用户
获取所有用户
获取单个用户
更新用户
删除用户
差不多就是这样了！一切都像宣传的那样工作，所以让我们在下一部分总结一下。
结论
这是一篇很长的文章，值得一读——我承认这一点。不过，我希望你已经设法跟上了，如果没有，请参考源代码。
了解如何使用 API 以及如何设计它们是任何数据科学家的基本技能，Python 提供了一种令人惊讶的简单入门方式。现在由你来决定向你认为合适的方向发展。请在下面的评论区留下你的想法。
感谢阅读。
加入我的私人邮件列表，获取更多有用的见解。
喜欢这篇文章吗？成为 中等会员 继续无限制学习。如果你使用下面的链接，我会收到你的一部分会员费，不需要你额外付费。
[## 通过我的推荐链接加入 Medium-Dario rade ci
作为一个媒体会员，你的会员费的一部分会给你阅读的作家，你可以完全接触到每一个故事…
medium.com](https://medium.com/@radecicdario/membership)
原载于 2020 年 10 月 6 日 https://betterdatascience.com*。*
使用 Docker 容器在本地开发胶水工作
Docker 容器在本地测试 glue spark ETL 脚本，而不会产生任何额外的成本，也不会使用开发端点
图片由 Free 提供-照片来自 Pixabay
随着当前世界数据量的不断增加，对处理大数据的服务的需求非常高。当我们考虑大数据时，大多数数据工程师使用的框架非常少。阿帕奇 Spark 就是其中之一。
Apache Spark 是一个分布式处理引擎，它需要一个大型集群来执行任何类型的分析或简单地对数据集执行 ETL。要使用 Apache Spark，我们需要建立自己的大型集群，这非常昂贵，或者我们可以在云上利用它们。在这里，我们将讨论 AWS 提供的服务。因此，为了处理大型数据集并使用 spark 对其进行分析，AWS 提供了两个主要服务
- AWS EMR(弹性地图缩减)
- AWS 胶水
AWS EMR 为我们提供集群来执行我们的处理，并且非常昂贵，因此我们需要仔细确定我们需要集群多长时间，以及如何适当地优化我们的作业。我们不会在这篇文章中讨论 EMR，因为它本身就是一个非常大的讨论话题。
AWS Glue 是一个完全托管的 ETL 服务，由 amazon web services 提供，用于处理大量数据。AWS Glue 最好的部分是它在 AWS 无服务器保护伞下，我们不需要担心管理所有这些集群和与之相关的成本。在无服务器模式中，我们为我们使用的东西付费，因此，如果我们的工作只使用 25 个 DPU 来处理我们的数据，并且运行 20 分钟，那么我们最终只需支付利用 25 个 DPU 20 分钟的成本，而不会多花一分钱。
如今，AWS Glue 是创建基于 python 或 scala 的 spark 处理作业的最大需求。要在 AWS glue 上开发 jobs，我们有三个选项。让我们逐一讨论。
- 直接在 glue 编辑器中创建作业并运行作业:
如果您是 spark 开发人员，并且不太熟悉 glue libraries 及其图生成，那么无论如何都要避免使用这个编辑器。这是写给那些非常确定他们正在写什么，并且从心里知道他们的工作将在第一轮中运行的人。这是完全不推荐的，只有当我们需要对现有的工作做一些改变时才可以考虑。当您在代码中使用胶水库时，直接使用作业编辑器是很好的，因为它会在您编写代码时生成谱系图。在选择这个选项之前，我建议浏览一下胶水库这里。
2。创建一个胶开发端点:
您可以设置一个 glue dev 端点，并将其链接到 zeppelin 笔记本或您的 pycharm IDE，或者您甚至可以连接本地 jupyter 笔记本。如果您想在开发工作时测试它们，这是一个更好的选择。要设置 Glue Dev 端点，您可以遵循官方 AWS 文档这里。这个 glue dev 端点的唯一问题是它的成本。您将为它运行的时间付费，所以它基本上是用您想要的容量和安装在集群上的胶水库来启动 EMR 集群。如果开发成本不是问题，并且可以考虑的话，这是最好的选择之一。
3。使用 AWS 胶水库并在本地 Docker 容器上运行它们
考虑到作业的开发和在相对较小的数据集上测试作业，并且一旦作业准备好使用 glue job console 本身运行它们，这是迄今为止最好的选择。通过这个选项，您可以在您的机器上灵活地使用 glue libraries，或者您可以根据您的数据集大小启动 EC2 实例，并在这些 EC2 上启动 docker 容器，因为这将是一个相对便宜的选项，也是最适合运行您的作业的选项。
要在本地设置 AWS glue，你可以点击这里查看 AWS 文档。但这似乎并不奏效，我们将详细讨论它。因此，我创建了一个 Docker 图像，并将解释我们正在做什么。
DockerFile 文件
我将 centos 作为基础映像，然后设置这些 env 变量，稍后我们将需要它来下载库
ENV MAVEN=https://aws-glue-etl-artifacts.s3.amazonaws.com/glue-common/apache-maven-3.6.0-bin.tar.gz
ENV SPARK=https://aws-glue-etl-artifacts.s3.amazonaws.com/glue-1.0/spark-2.4.3-bin-hadoop2.8.tgz
ENV GLUE=https://github.com/awslabs/aws-glue-libs.git
然后，我们将创建一个目录 glue 并安装所需的库，如 Java、python、wget、tar 和 Python 包，并将我们的工作目录设置为 glue
RUN mkdir glue
RUN yum install -y python3 java-1.8.0-openjdk java-1.8.0-openjdk-devel tar git wget zip
RUN ln -s /usr/bin/python3 /usr/bin/python
RUN ln -s /usr/bin/pip3 /usr/bin/pip
RUN pip install pandas
RUN pip install boto3
RUN pip install pynt
WORKDIR ./glue
现在在这个目录下会下载 maven，spark 和 glue libs 并解压。然后我们将更新 path 变量，并向它添加 SPARK_HOME、JAVA_HOME、MAVEN_HOME 和 GLUE_HOME 变量。
#To get the latest aws libraries
RUN git clone -b glue-1.0 $GLUE#To get latest spark version
RUN wget $SPARK#To install Maven for dependencies
RUN wget $MAVENRUN tar zxfv apache-maven-3.6.0-bin.tar.gz
RUN tar zxfv spark-2.4.3-bin-hadoop2.8.tgz#Removing zip files inorder to reduce the final docker image size
RUN rm spark-2.4.3-bin-hadoop2.8.tgz
RUN rm apache-maven-3.6.0-bin.tar.gz#Setting up env variables
RUN mv $(rpm -q -l java-1.8.0-openjdk-devel | grep "/bin$" | rev | cut -d"/" -f2- |rev) /usr/lib/jvm/jdk
ENV SPARK_HOME /glue/spark-2.4.3-bin-spark-2.4.3-bin-hadoop2.8
ENV MAVEN_HOME /glue/apache-maven-3.6.0
ENV JAVA_HOME /usr/lib/jvm/jdk
ENV GLUE_HOME /glue/aws-glue-libs
ENV PATH $PATH:$MAVEN_HOME/bin:$SPARK_HOME/bin:$JAVA_HOME/bin:$GLUE_HOME/bin
RUN sed -i '/mvn -f/a rm /glue/aws-glue-libs/jarsv1/netty-*' /glue/aws-glue-libs/bin/glue-setup.shRUN sed -i '/mvn -f/a rm /glue/aws-glue-libs/jarsv1/javax.servlet-3.*' /glue/aws-glue-libs/bin/glue-setup.sh
现在我们将使用 maven 编译所有的依赖项。这个 shell 脚本运行 maven build 命令并获得所有需要的依赖项。
我们只运行一次，这样我们的 docker 映像就可以预先包含这些库，从而节省以后运行 spark 作业的时间。
RUN sh /glue/aws-glue-libs/bin/glue-setup.sh
最后，我们将清理所有的 tmp 目录，并使用 bash 作为容器的入口点。
RUN yum clean all
RUN rm -rf /var/cache/yum
CMD ["bash"]
现在使用 docker 文件并创建您的容器，以便开始开发 glue spark 作业。
从 Dockerfile 构建 docker 映像
要从该 Dockerfile 文件构建映像，请运行以下命令:
docker build -t jnshubham/glue_etl_local .
从 DockerHub 中提取现有图像
要使用现有的映像来启动您的容器，只需从 docker hub 中提取映像，并运行所提供的命令来提交作业
要提取图像，请运行以下命令:
docker pull jnshubham/glue_etl_local:latest
通过运行以下命令检查下载的图像
docker images
运行 Docker 容器
要运行容器并进入 repl shell:
docker run jnshubham/glue_etl_local "gluepyspark"
进入终端并提交 spark 作业运行
docker run -it jnshubham/glue_etl_localgluesparksubmit script.py --JOB_NAME script
这样，您将能够在本地机器上测试您的作业，或者您也可以根据您的数据大小在任何 EC2 实例上使用它。
更多信息，请访问我的 GitHub 或 dockerhub 。
使用谷歌云人工智能平台开发、训练和部署 TensorFlow 模型
实用指南
张量流模型训练和部署的实用流程
TensorFlow 生态系统在开发涉及深度学习的应用程序方面已经变得非常受欢迎。原因之一是它有一个强大的社区，围绕核心库开发了许多工具来支持开发人员。在本教程中，我将指导您如何在 google colab 中制作模型原型，在 Google Cloud AI 平台上对其进行训练，并将最终完成的模型部署在 Google Cloud AI 平台上进行生产。我将包括工作的谷歌 colab 笔记本电脑，以重建工作。
Google colab 是 TensorFlow 中用于模型原型制作的免费资源，并附带各种运行时。准备一台带有 GPU 或 TPU 的机器一开始可能会很昂贵，但是用户可以从带有 google colab 的免费 GPU 开始。请记住，colab 资源有限，可能不适合正确训练需要大量计算资源的模型。尽管如此，colab 是构建模型原型和进行一些初步实验的完美工具。
可视化工作流程的框图
谷歌云平台上的培训模型
一旦您对模型管道感到满意，就该用适当数量的历元和完整数据集来训练模型了。正如你可能知道的那样，训练深度学习模型需要很长时间和一大群 CPU 的 GPU 或 TPU。一种选择是用户建立他们自己的计算集群，这在大多数情况下既昂贵又耗时。另一种选择是使用云计算来训练模型，然后按需付费。TensorFlow 团队发布了一个名为 Tensorflow Cloud 的包，让用户在谷歌云平台上训练模型，没有任何麻烦。我遵循了的步骤，使用 TensorFlow Cloud 博客在 Google Cloud 上训练你的 TensorFlow 模型，并将分享我为使它工作所面临的一些问题。向 GCP 平台提交培训工作的项目指南中定义了一些先决条件。
- Python >= 3.5
- 一个谷歌云项目
- 一个认证的 GCP 账户
- 谷歌人工智能平台为您的 GCP 账户启用的 API。我们使用人工智能平台在 GCP 部署 docker 图像。
- 如果您希望使用本地 docker 流程进行构建，可以使用功能版本的 docker ，或者使用创建一个云存储桶与 Google Cloud build 一起用于 docker 映像构建和发布。
创建 GCP 项目后，按照下面的步骤为环境配置 Google cloud 身份验证。
# Authenticate
from google.colab import auth
auth.authenticate_user()
在环境中设置PROJECT_ID
os.environ['PROJECT_ID']='gcpessentials-rz'!gcloud config set project $PROJECT_ID
创建服务帐户并设置tensorflow-cloud包所需的一些权限。下载服务帐户密钥并作为环境变量添加为**GOOGLE _ APPLICATION _ CREDENTIALS。**向谷歌云平台提交工作需要这些凭证。
os.environ['PROJECT_ID']='gcpessentials-rz'!gcloud config set project $PROJECT_IDos.environ['SA_NAME']='gcpessentials-rz'!gcloud iam service-accounts create $SA_NAME!gcloud projects add-iam-policy-binding $PROJECT_ID \--member serviceAccount:$SA_NAME@$PROJECT_ID.iam.gserviceaccount.com \--role 'roles/editor'!gcloud iam service-accounts keys create key.json --iam-account $SA_NAME@$PROJECT_ID.iam.gserviceaccount.comos.environ['GOOGLE_APPLICATION_CREDENTIALS']='key.json'
即使完成了上述步骤，我还必须在云构建设置下启用service Accounts和cloud_build状态。下面是我的项目设置的快照。
下一步是创建 GCP_BUCKET 来存储向 Google Cloud 提交作业所需的数据。
BUCKET = 'tf2-model-training'
!gsutil mb gs://$BUCKET
一旦我们在 google colab 中建立了环境并创建了 GCP_BUCKET，我们就必须准备笔记本来训练模型。以下是准备笔记本时需要考虑的一些要点。
- 使用 google colab 在笔记本上测试少量的纪元代码
- 确保笔记本中没有错误，并删除任何不必要的代码
- 准备
requirements.txt并上传到 google colab 环境。 - 将训练好的模型保存在 GCP_BUCKET 中(将用于部署)
一旦我们准备好笔记本，我们就使用tensorflow-cloud包在谷歌云平台上提交培训。
import tensorflow_cloud as tfcBUCKET = 'tf2-model-training'labels= {'phase': 'test','owner': 'raza',}tfc.run(requirements_txt="requirements.txt",distribution_strategy="auto",chief_config='auto',docker_image_bucket_name=BUCKET,job_labels=labels,)
上面的代码会把笔记本转换成identifier-Fg45-a.py，以 docker 的形式提交 Google 云平台上的训练。提交作业后，您可以看到如下图所示的消息。
向 GCP 提交培训工作的状态
等待几分钟后，工作开始实际培训
通过点击提供的链接，您将看到如下图所示的页面
使用人工智能平台查看训练进度的链接
您可以点击view logs查看日志，如下图所示。日志有助于了解代码中发生了何种异常。
培训日志
在提交庞大的作业之前，测试几个时期的管道提交脚本，然后提交完整的作业
如果一切顺利，你的模型将使用谷歌人工智能平台进行训练，并与其他资源一起保存在 GCP _ 水桶中。
用于培训的 Google Colab 笔记本
下面是使用 TensorFlow-Cloud 包在 Google AI 平台上运行培训的工作笔记本。
在谷歌云平台上部署训练好的模型
一旦模型被训练和最终确定，用户希望在可扩展的基础设施上部署该模型。Google Cloud 还提供了必要的基础设施，无需大量修改就可以在其平台上部署 TensorFlow 模型。我将向您展示如何在 google 云平台上部署该模型。在培训结束时，我们将最终确定的模型保存在 Google Cloud Bucket 中。下面是部署模型的步骤。
- 使用人工智能平台配置模型服务
- 对部署的模型执行预测
使用下面的命令集来配置模型，以便在 Google colab 中进行部署。我已经在模型中用 TensorFlow 详细解释了如何在 Google Cloud 上部署模型，并在 Google Cloud 平台上服务。
按照上面教程中的相同步骤，我已经将模型配置为v2。
获取已部署模型的预测
一旦部署了模型，并且您可以看到绿色的勾号，就该测试模型的预测了。一些需要考虑的要点。
- 使用测试&测试型号预测使用您的版本或型号选项卡下的选项卡。
- 输入 JSON 数据取决于您如何定义您的模型
# [Reference](https://github.com/GoogleCloudPlatform/python-docs-samples/blob/master/ml_engine/online_prediction/predict.py)
import googleapiclient.discovery
def predict_json(project, model, instances, version=None):
service = googleapiclient.discovery.build('ml', 'v1')
name = 'projects/{}/models/{}'.format(project, model)
if version is not None:
name += '/versions/{}'.format(version)
response = service.projects().predict(
name=name,
body={'instances': instances}
).execute()
if 'error' in response:
raise RuntimeError(response['error'])
return response['predictions']
为预测加载看不见的数据
df_new_products = pd.read_csv(data_path + 'proposed_new_product.csv')
tdata_instances = {'dense_input':df_new_products.values[0].tolist()}
predictions_gcloud = predict_json(CLOUD_PROJECT, 'earnings_prediction', tdata_instances, version='v2')
predictions_gcloud = predictions_gcloud[0]['dense_3'][0] + 0.1159
predictions_gcloud = predictions_gcloud/0.0000036968
print('Earnings predictions for Proposed product - ${}'.format(predictions_gcloud))Earnings predictions for Proposed product - $259671.15201209177
用于预测的 Google Colab 笔记本
下面是对部署的模型执行预测的工作笔记本
结论
在本指南中，我们已经了解了在tensorflow-cloud包的帮助下，使用 Google Cloud AI 平台使用 TensorFlow 2.3.0 训练深度学习模型，并将训练好的模型部署在 Google Cloud AI 平台上。以下是一些重要的经验教训
- 使用 Google Colab 构建张量流模型
- 使用 TensorFlow-Cloud 在 Google Cloud AI 平台上训练模型
- 训练后将训练好的模型保存在 GCP 桶中
- 在 GCP 建立服务模型
- 使用云中部署的模型进行预测
参考资料/阅读/链接
- https://blog . tensor flow . org/2020/04/how-to-deploy-tensor flow-2-models-on-cloud-ai-platform . html
- https://blog . tensor flow . org/2020/08/train-your-tensor flow-model-on-Google . html
- https://scikit-learn.org/stable/modules/preprocessing.html
将您的数据作为产品开发
理解大数据
起草数据工程实务
TL:吻博士💕DevOps！
图片来自 slon.pics
在一次工作讨论的启发下，我试图写下我个人对数据工程最佳实践的看法。要做到这一点，我认为最好先通过回答以下问题来定义数据工程的目标:
我们这些数据工程师试图推动的成果 是什么？
然后，在我们清楚结果之后，让我们详细说明哪些原则和实践可以帮助我们实现这一点。
免责声明:我有在我称之为大企业的工作经验(> 50，000 名员工)，与科学家密切合作或直接在产品/分析团队工作。如果你在一个小公司工作，像一个人的军队，或者在一个新成立的公司，有些事情可能是不相关的——尽管我认为前提和原则仍然适用。
前提:数据是一种产品
闲置和休眠的数据本身是没有价值的，正是这些数据产生的结果为你(和公司)创造了价值。这意味着数据是一种产品。没有真正使用/购买它的客户，它就不会产生任何东西。
如果我们遵循这个简单的前提，我们可以很快得出一些简单的指标，告诉我们我们的数据产品有多成功:
- 产生价值的产品的使用
- 上市速度和变化速度
- 质量和可靠性
- 可用性和互操作性
打造好的产品=保持简单
以我的经验来看，产品思维真的有助于我的工作更有影响力。每次我们开发某样东西时，解决方案的价值、可行性、合意性和可行性的产品维度应该是我们所考虑的。
大部分时间我们将花在如何构建和操作解决方案上，这将决定它们的可行性。因此，了解业务问题，然后设计可持续的解决方案至关重要。在这里，我看到了产品思维模式和 KISS 之间的紧密联系(简单点，笨蛋)。后者是构建可持续(长期可行的)产品的关键。
一个(过于)简单的例子:假设我们是星巴克，每天都需要决定我们要向每一家店发送多少纸杯。现在，如果有一个实时纸杯数据流来监控库存并对变化做出反应，岂不是很酷？—绝对不是。如果我们只需要每天做一次决定，我们可以通过每天运行的简单 cronjob 来完成。
保持简单只做您的解决方案需要的事情；仅仅因为我们可以做一些更奇特的事情并不意味着我们应该这样做。
开发产品的实践
剧透:数据工程师和软件工程师的最佳实践实际上是一样的。特别是 DevOps 实践改进了我们的构建方式，虽然也有数据操作，但后者只是一个将 DevOps 原则与数据领域联系起来的术语。
这并不意味着数据工程和软件工程是一样的，但事实是软件工程师在快速构建产生价值的数字产品方面已经领先，我们应该从中学习。
让我们更详细地分析一下，并将其与上面的指标联系起来。
**用法和产生的价值。**这才是最重要的，我们希望推出有影响力的产品。我们从软件开发中知道，这可以通过了解我们的消费者并与他们密切合作来有效地完成，最好是在同一个团队中。了解需求，理解痛点，并迭代地解决它们。实际上，这意味着我们必须试验和改进我们的产品。从技术上来说，这意味着我们需要能够跟踪这一点，并不断能够开发新的功能(或回滚更改)。
**上市速度。**自动化流程和工具，我们需要能够在生产级别快速交付和开发数据产品。有效地做到这一点的唯一方法，尤其是在分析环境中，是拥有解耦的数据资产。如果每次我们必须首先更新大量的管道，以向我们可信赖的星型模式添加新的维度(从而打破一些未记录的下游依赖)，我们就没有机会获得任何可持续的速度。
质量和可靠性。在开发和运营方面，我们首先需要的是健康的持续改进心态。我们永远不会从一开始就制造出完美的产品。从技术上讲，这意味着我们应该始终有一个良好的 CI/CD 设置(DevOps)。从精神上来说，这意味着我们必须接受一种死后文化。换句话说，我们尽最大努力利用自动测试/自修复 pods 数据质量检查来发现问题。当事情不可避免地出错时，我们确保从中吸取教训并改进产品！
**可用性和互操作性。**可用性不仅仅是数据产品的存在，而是其消费的难易程度。不是为我们，而是为我们的消费者。我们的产品必须被用来最大限度地创造价值，所以我们需要让它容易获得。我们需要使用标准界面来促进不同团队使用我们的产品，也就是说，我们不会为我们的消费者做出技术选择，也不会让他们跳过技术关卡。为了保持敏捷和快速，我们需要将我们内部开发的关注点从我们与消费者共享的界面中分离出来。
以上几点都是从软件工程师在构建数字产品时学到的经验教训中得来的。在我看来，它们都同样适用于数据工程——尽管它们的实现可能在技术上有所不同。
还有一点:**永恒性。**这在软件工程最佳实践中可能不那么重要/普遍，更多来自函数式编程人员，但它对数据工程非常有影响。尤其是在分析领域。尝试实践功能数据工程，这意味着:我们不改变历史，相反，我们快照所有的数据。不这样做是一条通往疯狂的道路——这是一件值得写一整篇文章的事情。现在，我将留给你们一个指针，指向 Maxime Beauchemin 的一些工作，他有一些关于❤️.功能数据工程的很棒的材料
数据工程实践
如果你做到了，那太好了！让我们试着将事情进一步归结为一些我们作为数据工程师可以在日常生活中应用的简单而切实的实践。
版本控制— 我们所有的工作都需要进行版本控制，包括我们的代码、数据和数据文档。进化，实验，必要时回滚！
自动化测试和部署 —自动化测试提供高质量和可持续的质量。自动化部署提高了我们的效率，减少了错误。我们需要这个(查看 Python for DevOps 开始)！
使数据可用并保持可用 —尽可能以最简单的方式使您的数据可用。并确保它保持可用—使用监控和警报来主动修复问题。
测试并交流数据质量 —持续评估您产品的数据质量并进行交流，最好是通过自动化数据文档。使用监控和警报来主动解决问题。
分离关注点— 确保你没有将事情紧密地耦合在一起。不要马上把所有东西都放在一个星型架构中，尽可能保持数据产品的分离。
与同事分享最佳实践— 与我们的数据工程同事交流，了解最佳实施方案，并分享它们。最终我们把最好的想法放到一个框架里，抽象出实现细节——>利润！
构建不可变的数据集— 数据是历史，历史是不可变的。更新观察值(行)会导致分析数据历史时出现问题。这对于调试和机器学习用例有着巨大的影响。我们努力使它变得简单，并通过保存历史来支持我们数据产品的下游使用- >数据是不可变的。
这些是我的最佳实践，这些实践(依我拙见)给我们带来了最大的经济效益，并且与前面描述的指标密切相关。这并不意味着没有更多东西可以学习！
关于在大公司中定位的说明
如果我们遵循数据作为产品的前提，我们必须密切了解我们的消费者，我们必须与他们进行实验，以获得最佳结果。我们必须共同创造价值，并不断改变以找出可行的方法，我们必须不断关注我们的产品，以进一步改进它。
本质上，这意味着在一个产品团队中工作，而不是在一个集中的数据团队中工作(从我的经验来看，这太棒了😉).当然，分散数据工程师的概念并不新鲜，你甚至可以说这只是认真对待跨职能团队——我同意这一点。其中一个将此整合并推广的人是 Zhamak Dehghani，她写了一篇很棒的文章，从鸟瞰的角度描述了这种方法如何大规模应用(她在 Youtube 上也很有说服力)👍).我相信我在这篇文章中描述的是一个数据工程师的观点和动机，因此我完全同意她的观点。
结论
我用这篇文章来理清自己的思路，理清自己的一些想法。
通过这样做，我希望我能够给一些人一些东西来思考。也许是一些关于如何改进他们的日常数据工程工作或如何变得更有生产力的灵感。如果你不同意我的观点，我也很乐意听取你的意见并向你学习。
我相信我们可以通过数据产品推动的结果是有影响力的，我们必须让他们成为一等公民。我们拥有实现这一目标的所有工具和技术，让我们开始行动吧！💪
开发数据科学模型预测假新闻
使用随机森林、GridSearchCV、Python 和 NLP 进行假新闻检测
freestocks 在Unsplash【1】上拍摄的照片。
目录
- 介绍
- 探索性数据分析
- 特征工程
- 模型
- 准确(性)
- 特征重要性
- 摘要
- 参考
介绍
解读一篇新闻文章是否有效可能很困难。作为一名研究数据科学、分析 Vidhya 和数据系列的新作者，我获得了一些直觉，可以发展出一双辨别真假的眼睛。我想用数据科学和机器学习来测试我的理论，而不是纯粹依靠直觉。我编译了 Python 代码，构建了一个随机森林模型来预测一篇文章是否是假的。作为一名数据科学家，我一直对创造力和自动化很好奇——我相信我的文章和关于这个模型的工作结合了科学和艺术的两个方面来预测新闻的有效性。下面，我概述了我为这个模型使用的代码，以及对进一步工作的评论，以及对真正的文章的特征感兴趣的非技术用户的总结。
探索性数据分析
这个模型中使用的数据集是从我的虚拟数据中创建的。我正在使用一些常见文章的特征或特性，并试图预测它们是否是假的。在我的情况下，false 是由预先确定的标签决定的，true 也是如此。出于本教程的考虑，这些数据是从我自己的文本中随机生成的。这种数据和模型的伟大之处在于，它可以被缩放和重新定义，比如你从更多的来源收集了几篇文章，你的标签可以是来自脸书、推特甚至纽约时报的真实世界的文章。现在我们知道了我的目标变量 fake(或 true ),让我们看看我用来构建模型的特性:
- 标题——文章标题中使用的文字/单词(主要的 20 个理由等等)。)
- 副标题——文章副标题中使用的文本/词语(施工区等)。)
- title_characters —(“:”，“-”，分割文字的特殊字符)
- 图像计数—使用的图像数量
下面是数据帧的前五行:
返回数据的前几行。作者截图[3]。
特征工程
由于该模型中同时使用了文本和数字特征，自然语言处理(NLP)有利于预测。我使用了常见的术语频率逆文档频率矢量器，将文本计数转换为术语重要性的加权矩阵。然后，我为文本特征如标题和副标题编译了 TextTransformer 和tfidf 矢量器。接下来，我使用 NumberTransformerr 类执行了一个类似的方法，但是针对的是数字特性。最后，我将所有的特征，文本和数字结合在一起。下面使用的代码 [3]用于特征工程，NLP，并最终准备/预处理数据，使其能够正确输入到模型中。
# use the term-frequency inverse document frequency vectorizer to transform count of text
# into a weighed matrix of term importance
vec_tdidf = TfidfVectorizer(ngram_range=(1,2), analyzer='word', norm='l2')# compile both the TextTransformer and TfidfVectorizer
# to the text features
title = Pipeline([
('transformer', TextTransformer(key='title')),
('vectorizer', vec_tdidf)
])
subtitle = Pipeline([
('transformer', TextTransformer(key='subtitle')),
('vectorizer', vec_tdidf)
])# compile the NumberTransformer
# to the numeric features
title_character = Pipeline([
('transformer', NumberTransformer(key='title_character')),
])
image_count = Pipeline([
('transformer', NumberTransformer(key='image_count')),
])# combine all of the features, text and numeric together
features = FeatureUnion([('title', title),
('subtitle', subtitle),
('title_character', title_character),
('image_count', image_count)
])
模型
数据科学过程的下一部分，也许是最有趣的部分，是创建一个预测目标变量的模型。在这种情况下，模型是一个随机森林分类器。我创建了一个通用的分类器，然后将所有的特征和分类器统一在一个管道中。我从变量 y 中分离出这些特性，并相应地存储起来以备后用。下一步是对数据进行训练-测试分割，同时建立 70:30 的训练和测试规模，然后为再现性引入随机状态。为了了解模型在新数据上的表现，开发这种分割，并最终在完全不可见的数据上进行测试(这将是模型的真实应用)。
下一步是为 GridSearchCV 创建一个参数网格进行搜索。该网格用于测试几个列出的参数，并查看哪一个是最好的。对于我的模型，我查看了n _ estimates。我创建了一个对象来存储评估器，这是已经创建的管道，其中 param_grid ，2 的 cv (交叉验证)，1 的 n_jobs (为了更快的计算)，1 的 verbose (为了查看文本输出)，以及用于模型诊断的 return_train_score 。我不仅查看了 mean_train_score ，还想看看这个模型在查看带有 mean_test_score 的新数据时有多有用。我用grid _ search . best _ params找出了哪些参数是最好的，这有助于区分 30 个估计量是最好的。
以下是用于此流程建模部分的代码:
# create the classfier from RF
clf = RandomForestClassifier()# unite the features and classfier together
pipe = Pipeline([('features', features),
('clf', clf)
])# split the data into train and test
# isolate the features from the target field
text_numeric_features = ['title', 'subtitle',
'title_character', 'image_count']y = 'fake_true'X_train, X_test, y_train, y_test = train_test_split(df[text_numeric_features], df[y],
test_size=0.30,
random_state=42
)# parameter grid to scan through
param_grid = {
'clf__n_estimators': [10, 20, 30, 40, 50, 100]}grid_search = GridSearchCV(estimator = pipe, param_grid = param_grid,
cv = 2, n_jobs = 1, verbose = 1, return_train_score=True)grid_search.fit(X_train, y_train)grid_search.cv_results_['mean_train_score']grid_search.cv_results_['mean_test_score']grid_search.best_params_clf_test = grid_search.best_estimator_
准确(性)
也许数据科学建模过程中最令人满意的部分是看到您的结果。我在我的 X_test 上预测并将其分配给 preds。我使用 metrics.accuracy_score 来确定我的准确性。
我的模型准确率是 91%
看看这个模型的准确性。作者截图[3]。
要使用引用的代码，请参见以下内容:
# test stats
preds = clf_test.predict(X_test)# print out accuracy
print("Accuracy:", metrics.accuracy_score(y_test, preds))
特征重要性
最重要的功能(字数/计数栏数)。作者截图[3]。
在非数据科学词汇中，特征重要性是指数据集的哪些部分对于预测响应变量非常重要，或者在这种情况下，一篇文章的特征是重要的，以及它们有多重要。因为这个模型是新的，而且数据很少，我看了看绘制最高的特征(大部分是文本)，因为使用的特征都很重要。
我调用了**grid _ search . best _ estimator _**来返回一篇虚假文章的特征重要性。在数据框架中，有几个词不会导致一篇假文章。然而，有很多有助于确定一篇假货。重要词汇包括:
- 文章正文— 1000，000(格式错误的数字)
- 图像计数—一篇文章 20 张图像(过高)
以下代码用于特征重要性分析:
pd.DataFrame(grid_search.best_estimator_.named_steps["clf"].feature_importances_)importances = list(zip(grid_search.best_estimator_.named_steps["clf"].feature_importances_, df.columns))
importances.sort(reverse=True)print(grid_search.best_params_)
print(grid_search.best_score_)feature_importances = grid_search.best_estimator_.named_steps["clf"].feature_importances_feat_importances = pd.Series(grid_search.best_estimator_.named_steps["clf"].feature_importances_,
#index=df.columns
)
feat_importances.nlargest(10).plot(kind='barh')
plt.title("Top 10 Important Features")
plt.show()
摘要
对于任何数据科学模型和数据集，重要的是要注意，没有一个特征是预测的主要原因，或者在这种情况下，如果一篇文章是假的。正是它们的结合创造了一篇或真或假的文章。虽然我的分析和模型很擅长预测，但最擅长的是根据我自己的数据进行分类。要改变这种模式，除了收集各种真假文章进行训练之外，不需要做太多的工作。一篇文章的关键属性是:
- 文章标题、文章副标题、文章特殊字符和图片数量
将来要测试的其他字符包括:
- 正文、画质、图像分类(照片是什么？)、读者数量、星期几、一天中的时间、照片或代码的位置、字母的大小写以及其他一些信息
我希望这篇文章既有趣又有用，并为您提供了一些关于如何对假新闻进行分类的想法，以及构建您自己的数据科学模型的想法和代码。
对于我的模型中使用的所有代码，请参见下面的要点【4】:
GitHub 要点作者使用的代码【4】。
参考
[1]， Unsplash ，(2016)
[3] M.Przybyla，截图(2020 年)
[4] M.Przybyla，要点 (2020)
sklearn， sklearn (2020)
熊猫，熊猫 (2020)
培养数据科学家的思维模式
当数据科学家意识到他们部门或公司内的某个事件时，他们有责任确保该事件产生的任何数据都得到考虑，并得到充分利用
我看过很多关于如何从零开始，将自己转变成一名可雇佣的数据科学家的精彩资源。这些资源建议学习 Python 或 R，掌握数据管理和清理，理解有效和有意的数据可视化，或者甚至学习机器学习。
所有这些技能都是无价的，要成为一名行业数据科学家，通常需要这些技能的不同组合。然而，掌握这些技能并不意味着战斗结束。数据科学家除了具备上面列出的一些技术技能外，还应该从团队中其他人独有的角度来分析公司的日常活动。当数据科学家意识到一个事件(需要一个新的 KPI、即将发布到生产中的功能、最近客户流失的增加、新的营销活动等)时。)，他们有责任确保该事件产生的任何数据都得到考虑，并充分发挥其潜力。
例如，我们能想出一些有创意的、特定领域的方法来衡量新特性发布的成功吗？我们能分析数据并分离出客户离开网站之前的一个源事件或一系列行为吗？我们能合理地证明营销策略 A 优于策略 B 吗？
保持数据科学家的心态至关重要。捕捉这种思维模式本质的一个很好的方法是，将数据科学家的复杂职责和思维过程并列在一起。
坚定，但适应性强
“决心驱使数据科学家从数据中获取尽可能多的价值，适应性让数据科学家保持诚实。”
我不断提醒自己，“如果你不相信自己，谁会相信你呢？”没有人比你更了解你的工作。没有人像你一样相信你的工作。没有人会真正知道你的发现什么时候可以像你一样被展示。没有人会像您一样知道您的模型何时可以部署到生产中。你被聘用是因为你的特殊技能为公司带来了独特的价值。你有责任确保你所做的所有工作都是诚实和正直的。当你需要下定决心并倡导你的工作时，你必须这样做。您可以通过多种方式做到这一点，但这里有几个例子:
- 争取宝贵的时间与高级工程师、业务伙伴或经理会面，以获得阻碍你完成分析的问题的答案
- 向您的同事解释您的项目想法如何以及为什么会产生对 X、Y 和 Z 部门有益的见解
- 提醒你自己和你的上司，准确、有价值的洞察力来自时间、诚信和对细节的关注…不是仓促的分析和拼凑的预测模型
另一方面，数据科学家必须愿意在时机成熟时为团队做出贡献。如果公司的工作重心发生了转移，他们应该能够迅速转变，将注意力转移到手头的任何重要任务上。数据科学家应该总是愿意学习新东西，无论是新领域(如消费金融、出站电子邮件营销、公民技术)还是新的商业智能软件。数据科学家应该有决心，但永远不应该让对研究的追求阻止他们看到何时该转移重点。有时，如果业务方面决定有更重要的优先事项，或者当前项目被认为是一个死胡同，甚至可能是时候完全放弃一个项目了。数据科学家应始终尽最大努力在以下方面保持适应性:
- 尝试新的软件包、算法、软件等。这是同事们建议的，即使你从第一天起就忠于“不成功便成仁”的技术
- 最大限度地减少负面评论当你的经理要求你放弃一个你非常兴奋的项目，专注于一个需要立即关注的“热点项目”时
- 不断地从不同的角度处理问题，并试着站在公司不同角色的角度考虑问题
- 接受不正确的假设，用它们来进一步推动你的研究，不要让它们阻碍、阻止或分散你的注意力
我知道决心和适应能力并不一定是完全相反的。但是，这两种特质的本质确实在某种程度上实现了平衡，从而使数据科学家变得更加全面。这种决心促使数据科学家尽可能地从他们所掌握的数据中获取所有价值，并让他们有信心相信这些发现是准确的、有价值的、值得一听的。适应性让数据科学家保持诚实，防止他们在教育和技能发展方面停滞不前，并且(在我看来)让他们总体上更容易共事。
口齿伶俐，但好奇
所有的技术人员在这个行业都很快认识到，交流你的想法、关注点和关于项目的新想法是非常困难的……尤其是当你试图和一个和你不在同一个领域的人交谈时。然而，数据科学中最需要的“软技能”之一是有效的沟通，因为数据科学家是故事讲述者。当决定下一季度专注于公司的哪个部门时，数据科学家需要提出一个叙述来证明哪个重点会给公司带来最大的利益。当数据科学家开发一个模型来帮助预测消费者行为时，他/她必须向利益相关者传达为什么该模型会对收入产生积极影响。数据科学家必须能够发现最复杂和最深刻的见解，但这不是他们任务的终点。一个伟大的发现只能让你到此为止！他们必须将这些见解转化为成熟的故事和可操作的项目，吸引业务对手，并让他们相信这些见解的实际价值。成为口齿伶俐的可能是一个很难掌握的任务，但是这里有一些方法可以练习:
- 更多地关注构建数据库表、代码库或过程的文档的机会，这将使公司的其他员工受益
- 在与业务伙伴讨论时，花时间解释为什么某些东西会起作用或者数据来自哪里(注意:这是互利的！他们学习，你练习你的沟通！)
- 练习将复杂的数据科学概念传达给身边不在该领域的人(家人、朋友、重要的其他人等)的能力。)
能够解释你的发现显然是数据科学家工作流程中非常重要的一部分，但比说话更重要的是提问和倾听的能力。数据科学家应该总是向他们的业务伙伴提问。虽然他们不是编写代码的人，但是业务伙伴(产品所有者、主管、执行官等。)是那些拥有有价值的、基本的特定领域知识的人，这些知识将帮助代码获得价值。商业对手不是分析数据的人。但是，他们是生成数据的人，或者至少参与了数据的生成，他们拥有不可或缺的行业知识，这些知识将极大地帮助你的分析。同样，数据科学家应该总是询问有关他/她自己工作的问题。如果那里有一个 0 或者 NULL 会发生什么？我丢失数据了吗？这些数字有意义吗？数字胜于雄辩，所以听着！这里有几个在工作中变得更加好奇的好机会:
- 在任何 sprint 计划或项目会议之前，为你的同事准备一份问题清单，这样在你着手一项任务之前，你可以获得尽可能多的信息
- 确保在接受数据源为事实、将一段代码投入生产或向高管层提交发现之前，完成尽职调查测试
与前面提到的特征相似，善于表达和好奇并不相互排斥。但是，这两种特质确实在某种程度上相互补充，将数据科学家变成了一股不可忽视的力量。这种表达使数据科学家能够与来自各种背景的同事和客户联系；它还允许他们提供更有力、更相关的解释和演示。不断的调查推动数据科学家不断保持他们工作的质量，并不断追求卓越。
数据科学的领域如此广阔。每天都有新的语言、包、软件和算法发布，而且没有减缓的迹象。随着所有这些新工具的不断涌现，保持你的技能达到标准的压力总是存在的。不管你把时间集中在哪些工具上，如果你不断检查你的心态，你将会成为更好的数据科学家。坚定，但适应性强。表达清晰，但好奇。
原载于 2020 年 4 月 24 日https://data dreamer . io。
使用 Plotly Dash & TigerGraph 开发新冠肺炎文章的动态作者搜索(第 4 部分)
议程
- 背景
- 安装和导入软件包
- 建立与 TigerGraph 的连接
- 排序数据
- 创建应用程序
- 创建 Plotly 图像
- 建立布局和元素
- 配置用户输入
- 运行应用程序
- 后续步骤
1.背景
CORD-19 是一个巨大的开源新冠肺炎文章数据库。该数据集最初是作为数据分析师收集有意义的信息的挑战而创建的，这些信息可以回答关于该病毒的一些未解决的问题。虽然我没有参加那个挑战，但我发现数据库是一个有趣的工作工具，于是我开始研究和实践计算机科学中的新课题，并将它们应用于这些数据。
这是一个系列的第 4 部分，详细介绍了我为创建一个完整的端到端应用程序而采取的所有步骤，该应用程序分析 CORD-19 数据集的元数据。在第 1 部分的中，我们看了如何使用 scispaCy，一个为医学数据设计的 NLP 工具，从研究论文的摘要中提取关键词。在第 2 部分中，我们看到了如何使用 TigerGraph Cloud 在图形中建模我们的数据及其相互联系。在第 3 部分的中，我们介绍了如何编写查询来有效地搜索和提取图表中的数据。在本系列的最后一部分，我们将探索使用我们的图形查询来提取数据，并使用 Python 库 Plotly 和 Dash 可视化地表示这些数据。
这个项目的完整代码可以在我的 GitHub 页面上找到。
2.安装和导入我们的包
我们有相当多的软件包需要安装和导入。要安装软件包，请从终端执行 pip 安装。
pip install package_name
然后，无论您在哪里编写代码(我使用了 Atom ，导入以下包。
在 Google Colab 这样的在线平台上运行 Dash 相当困难，所以我建议把所有东西都写在本地。
3.连接到 TigerGraph 云
我们使用 pyTigerGraph 连接到 TigerGraph 云，pyTigerGraph 是由 Parker Erickson 制作的 python 包。他在 Medium 上写了一些令人惊叹的文章，你可以在这里查看。要连接到 Cloud，我们需要输入域名、图名和一个 API 令牌(为了保护我自己的图的隐私，我没有包括它)。
要获得自己图形的令牌，请进入 TigerGraph Cloud 上的管理门户，然后选择创建秘密。
tigergraph 管理页面
一旦创建了您的秘密，您就可以使用以下代码获得您的令牌:
一旦您的连接建立，我们可以运行我们的查询。
为了运行我们的查询，我们输入查询名称、参数、超时时间和大小限制。你可以在 pyTigerGraph 这里看到这个函数和所有其他函数的完整文档。
我们正在运行两个查询。第一个获取数据库中所有作者的列表。查询代码如下所示:
CREATE QUERY AuthorSearchDash() FOR GRAPH MyGraph {
/* This querry grabs all authors in our database */ SumAccum<INT> @pubNum; ListAccum<VERTEX> @pubList; Seed={AUTHOR.*}; Author = SELECT a FROM Seed:a-()-:t ACCUM a.@pubNum +=1, a.@pubList +=t ORDER BY a.@pubNum DESC; PRINT Author;
}
第二个查询获取我们所有的出版物。该代码如下所示:
CREATE QUERY GrabPubs() FOR GRAPH MyGraph {
/* Grab all publications with their relevant information */ Seed = {PUBLICATION.*}; Pubs = SELECT s FROM Seed:s -() - :t; PRINT Pubs[Pubs.id, Pubs.pub_title, Pubs.pub_url];
}
要进一步了解在 TigerGraph Cloud 中编写 GSQL 查询，请参考本系列的第 3 部分。
4.整理我们的数据
导入数据后，我们现在需要对其进行排序，使其更易于管理。我们使用 pandas 将数据存储为数据帧。然后，我们使用 flat-Table 来标准化我们的数据。最后，我们将数据分类到列表和字典中，以提供更快的查找。
由于我们的应用程序是动态的，它需要连续查找数据。如果数据存储在列表或字典中，这比存储在数据帧中要快得多。
5.创建我们应用程序的实例
我们使用之前导入的 Dash 包实例化我们的应用程序。我们还指定了要使用的样式表。顾名思义，样式表是应用于仪表板的样式和布局的集合。我们使用 Bootstrap 框架，因为它允许我们方便地配置我们的应用程序布局。
我们还在这里创建了两个字典。这些将在稍后用于创建我们的条形图的颜色。
6.创建一个空的 Plotly 条形图
接下来，让我们创建图表。我们现在只是创建一个空白图表，因为当用户与仪表板交互时，图表会更新。我们使用 Plotly Express 制作条形图。图表中的 x 轴代表作者的姓名，而 y 轴代表每位作者的出版物数量。
7.建立我们的布局和元素
这是我们代码的核心所在。Dash 的工作原理是模仿你的网站的 HTML 结构。如果你没有 HTML 的经验，不要惊慌。我之前没有任何经验，仅仅通过查看 Dash 文档就能学到很多东西。而且，如果你以前有过 HTML 的经验，这应该看起来很熟悉。
让我们浏览一下这个仪表板的结构。我们从包含仪表板中所有内容的父 Div 开始。然后，我们为标题和副标题添加两个组件。然后，我们使用 Dash Bootstrap(还记得我们之前导入的样式表)创建一个包含两个等宽列的行。在左栏中，我们有一个包含作者列表的下拉列表，一个显示出版物数量的 div，一个显示出版物列表的 div。在右栏，我们有我们的图表。
8.用用户输入更新我们的用户界面
现在，我们已经完成了仪表板布局。但是，为了使它动态，我们需要添加回调。回调允许我们从特定的容器(比如下拉菜单)获取输入，执行一些操作或更新，并将结果输出到其他容器。我们使用了三个回调函数，每个回调函数对应一个我们输出数据的容器。
更新我们的表格
这个回调从 dropdown 容器中获取输入(因此输入是作者的名字),并打印出与该作者对应的文章表。这些出版物以及它们的细节都来自我们之前制作的字典。
更新我们的数字字段
这是最简单的回调。我们只需从下拉列表中取一个作者的名字，并打印相应数量的出版物。由于我们在开始时创建了字典，这变得特别容易。
更新我们的图表
我们的第三次回调用我们刚刚选择的作者的新条形图更新了条形图。我们在 Plotly 中用 add_trace 函数添加了这个条。每当向图形中添加跟踪时，该跟踪都会收到自己的图例图标。为了防止这种情况，我们创建了 legendgroups ，并使用一些操作来只显示还没有显示的组。
9.运行我们的仪表板
我们通过在本地服务器上运行应用程序来结束我们的代码
有了这两行代码，我们的程序就完成了。要运行代码，打开终端，切换到代码所在的目录，然后运行 python 脚本。运行前，确保您的图形解决方案已启动。
cd location/where/code/is/located
python app_name.py
调用脚本后，需要一段时间来加载。最终加载后，您应该会看到如下所示的内容:
终端输出
打开 URL，您应该会看到这个屏幕。
仪表板图像
就这样，你可以看到你辛辛苦苦建立的仪表板！但是，现在不要停止。试一试，看看我们已经实现的所有功能。
仪表板使用示例
10.后续步骤
这是我第一次处理 Plotly 和 Dash。我知道代码有很大的优化和定制空间，这个我就留给你了。但是，在微调运行时和使仪表板在视觉上更有吸引力(我认为美学显然不是我的强项)的过程中，您还可以添加更多的交互式模块。最好的部分是我们已经写好了查询。如果您参考本系列的第 3 部分,我们编写了这里没有实现的多个查询。特别是，在这个仪表板中实现查询查找相似的出版物和查询查找引用给定关键字的顶级出版物是非常有趣的。我希望有一天能自己解决这些问题，但我也希望你们也能这样做。或者，进一步编写一些新的查询，提取其他有用的数据进行显示。
结论
到此，这个简短的系列就结束了。这是一段不平凡的旅程。我们首先使用 NLP 从我们收集的新冠肺炎文章中提取数据。然后，我们将数据映射到一个图表中，并学习如何编写查询来搜索数据。最后，我们学习了如何在后端实现查询来创建可视化用户界面。感谢您和我一起探索数据科学中一些非常酷的话题。我希望你已经学到了一两件可以应用到你正在做的任何事情上的东西，无论是一个有趣的小项目还是一个全面的应用程序。感谢阅读，敬请关注未来更多文章！
资源
- https://www . ka ggle . com/Allen-institute-for-ai/CORD-19-research-challenge
- https://towards data science . com/using-scispacy-for-named-entity-recognition-785389 e 7918d
- https://towards data science . com/linking-documents-in-a-semantic-graph-732 ab 511 a01e
- https://towards data science . com/graph-query-searches-part-3-A8 BFF 845 C3 f1
- https://github . com/akash-Kaul/Dash-Publication-visualizer . git
- https://atom.io/
- https://medium.com/@parker.erickson
- https://Parker Erickson . github . io/pyTigerGraph/query functions/
- 【https://dash.plotly.com/
使用 Plotly 和 Dash-akash-Kaul/Dash-Publication-Visualizer 对新冠肺炎文章进行动态作者搜索
github.com](https://github.com/akash-kaul/Dash-Publication-Visualizer) [## 阿卡什·考尔-数据科学实习生-未来学家学院| LinkedIn
查看阿卡什·考尔在全球最大的职业社区 LinkedIn 上的个人资料。阿卡什有 5 个工作列在他们的…
www.linkedin.com](https://www.linkedin.com/in/akash-kaul-6a8063194/)
培养对数据科学的良好态度
作为一名专业或有抱负的数据科学家、机器学习或人工智能工程师，你需要养成良好的工作态度。
Arif Riyanto 在 Unsplash 上拍摄的照片
目前在数据科学领域的任何人，AI/ML 都可以说这是一个非常广泛和动态的领域，因此，为了实现你的目标或学习许多新东西，你也必须非常灵活。在这个故事中，我将分享一些我认为已经在这个领域或寻求进入这个领域的每个人都应该采用的东西。
要有创意
作为数据人员，我们必须知道并接受这样一个事实，即做事没有唯一的方式。我们必须避免拘泥于一种特定的做事方法，而是探索我们可以用于特定用例的许多工具、框架、库和包。不要执着于一件事，用那些让你的工作更容易、更快的事情。如果目前没有什么适合你的，那就创造一些东西，联系你社区里志同道合的人，一起创造一些东西。可能对以后几百人甚至几千人都有帮助。不要害怕开始，需要时寻求帮助，测试你的创造力。
好奇
学习是一个永无止境的过程，因此，你永远不会知道太多。好奇心是每个数据科学家、人工智能或人工智能工程师都需要培养的基本态度。不知道某事并不可耻，知识只有在寻求时才能找到。每当需要的时候，养成提问或寻求清晰的习惯。这表明你对这个话题非常感兴趣，并证明你愿意学习更多的知识来获得更多的知识。作为通过从数据中进行推断来工作的人，我们必须确保我们知道如何完成工作，我们需要做什么来完成工作，以及我们为什么要做某些事情来完成工作。向你的同事或主管询问关于你的工作或项目的技术问题，将有助于你理解你正在做的工作的核心概念，并指导你完成工作。
保持一致
对于有抱负的数据科学家、AI 或 ML 工程师来说，最重要的事情之一是一致性。很难在一个学习轨道上坚持这么长时间，尤其是当事情似乎停滞不前的时候。要知道每个人都有突破的时候，就像每朵花都有绽放的时候一样。坚持学习，坚持一个学习计划，不要不惜一切代价去违背。你的突破会到来，但是当它到来的时候一定要做好准备。作为初学者，你所学的一切都是你在行业中会用到最多的东西，所以不要跳过最初的步骤。如果你坚持不懈地学习，你会比你预期的更快地为行业做好准备。
编写干净且可重用的代码
这个领域的大多数人每天都在编写代码。这个领域可能有一些人的具体工作任务不包括编写代码，但对于我们大多数每天花很多时间编写代码的人来说，我们需要接受一组道德规范，使我们成为优秀的优秀程序员。代码伦理基本上是一种公认的编写代码的方式，它使我们的工作看起来整洁有序。遵守代码道德有许多好处，最常见的是，它给你一种职业程序员的感觉，并证明你是一个有条理的人。有许多代码道德规范，但我认为每个程序员都需要知道的基本规范是:
- 给变量命名:不要把任何变量命名为任何字母表或字母之类的东西。你的变量名应该告诉任何看代码的人这个变量代表什么。它可以是一个单词或两个或更多单词的简短形式。您可以使用下划线来分隔缩短的单词，或者使用一种称为驼峰式大小写的样式。在这里，您连接两个单词，第一个单词以小写开始，任何新单词以大写开始。例如 MyVar1 或 firstVariableName。
- 缩进:缩进是编码中必须遵循的原则，因为它以一种更具可读性和组织性的方式构建代码。
属于一个块的任何代码，如函数、子程序、循环和 if 语句必须缩进以显示其在程序中的作用域。 - 注释:注释是不影响代码结果的任何文本，它只是让某人知道你在程序中做了什么或者在代码块中正在做什么的一段文本。注释不应该美化代码。它们将作为指导方针。所以坚持简单的评论。不要做
!!#<<!--comment--!>>
简单的评论就可以了，比如:
# This is a comment
广泛阅读
作为一名数据科学家，人工智能或 ML 工程师，你只有学得好才算好。阅读你在你的领域感兴趣的主题的博客帖子、文章或论文，会对你拓宽知识面和学习新事物有很大帮助。经常阅读，让自己了解优秀作家的文章。
自我测试
落地数据科学，AI/ML 工作最常涉及的是参加编码测试的过程。这可能是非常压倒性和困难的，尤其是如果你没有准备好。让自己为编码测试做好准备的最好方法是每天测试自己。这不仅能帮助你提高技能，还能让你变得更快更有时间意识。互联网上有许多平台，你可以在那里进行编码测试，但我最熟悉的一个是 HackerRank 。坚持每天至少进行一次测试，随着时间的推移，你会非常擅长编码测试。此外，你可以留意模拟面试，或者让朋友或同事偶尔面试你一次。这有助于你在真正的面试中建立自信，并为你在实际面试中可能被问到的一些问题做好准备。
建立稳固的投资组合
作为一名数据科学家、人工智能或 ML 工程师，一份好的投资组合应该包括你已经完成的个人或专业项目、你的成就、专业目标和目的、技能、兴趣和教育背景。一份可靠的投资组合会让你脱颖而出，很容易让你受到招聘人员和雇主的青睐。
建立一个良好的网络
与和你兴趣相投的人交往，经常保持联系。向这些人寻求帮助或分享想法。与一些你尊敬的人互动，向他们寻求技巧和其他问题，这些可以帮助你成为数据科学家、人工智能或人工智能工程师。
准备团队工作
在大多数公司，数据科学家、数据工程师、人工智能和人工智能工程师作为一个团队一起工作，因此，任何渴望进入这个行业的人都需要让自己具备一些团队工作技能，以帮助团队取得进步。团队工作技能可以是软技能和技术技能。软技能主要指与团队中其他人的沟通和关系，无论是同事还是主管。技术技能是应用于工作的核心技能，可以带来最大的进步。学习如何使用分布式版本控制工具，如 Git 和 Github，对于团队工作来说是非常重要的，因为它让团队中的每个人都可以自由地作为一个团队一起工作，而彼此却不在一起。你可以从的这篇文章中学习如何使用分布式版本控制系统，比如 Git 和 Github。
利用你的领域知识成为你的优势
作为一名数据科学家，你的领域知识就是你的超能力。— 德里克·德贝杜伊
如果数据科学家在专业领域工作，他们会工作得最好。一名研究银行和金融的数据科学家将在金融公司工作得最好，而一名接受过生物科学培训的数据科学家同样会在生物行业的公司工作得最好。数据科学是当今发展最快和最多样化的领域，你不需要拥有计算机科学的理学学士或理学硕士学位就能从事数据科学职业。无论你在哪个领域找到自己，只要你真的想，你都可以成为一名数据科学家。展开你的翅膀，作为数据科学家在你的领域里伸出援手。将领域转换到你知之甚少的领域会大大降低你作为该领域数据科学家的价值。在一家需要数据科学家来处理气候或地理空间数据的公司中，受过金融数据处理培训的数据科学家几乎毫无用处。人们可能会说“每个数据都是数据”，但作为一名数据科学家，你必须知道理解你的数据是利用数据取得任何工作进展的关键。
感谢您花时间阅读这篇文章。欢迎你在回复区分享你的想法和观点，你可以直接在推特或 LinkedIn 上联系我。祝你有美好的一天。
非常感谢 Benacq 校对并纠正了我写这篇文章时犯的许多错误。
使用 PyCaret 开发心脏病预测模型
来源:Adobe Stock(许可证编号 262173764)
背景
在一个发达的专业数据科学环境中，你可能可以访问 AWS、GCP、Azure 或其他平台或软件，并使用工具来进行实验设置、跟踪和记录。但是，如果你只是想让一个试点项目启动并快速运行，或者你正在做一个研究项目呢？这就是 py caret(https://pycaret.org/)快速系统地做实验的能力可能派上用场的地方！
PyCaret 是什么？它的创建者将其描述为“…开源的、低代码的Python 机器学习库，允许你在几秒钟内从准备数据到在你选择的笔记本环境中部署你的模型。”任何能让你在内容上花更多时间并最大化影响的东西都是好的，对吗？
在下面的例子中，我们将开发、评估和检验一个使用 PyCaret 预测心脏病的模型。因为这是我第一次使用 PyCaret，所以我也将在最后提供一些想法和第一印象。一如往常，在任何涉及健康的示例应用中，关联、推论和评论绝不构成医疗建议或专业知识。用于支持本文的笔记本和其他材料可以在我的 Github 上获得(https://Github . com/Jason-Bentley/medium _ articles/tree/master/heart _ disease _ py caret)。
数据
克利夫兰诊所处理过的心脏病数据集(https://archive.ics.uci.edu/ml/datasets/heart+Disease)包含 13 个特征和 303 名患者的结果。当分为两类时，结果表明患者是否患有心脏病，并且是感兴趣的目标。总体而言，队列中 45%的患者患有某种程度的心脏病，因此我们的目标是平衡的。
对于我们的简略探索性数据分析(EDA)，我们将比较有心脏病和无心脏病患者的特征，并使用图(图 1 和图 2)更详细地查看连续特征。
图一。队列表
图二。连续特征的绘图
来自 EDA 的指示是我们可能期望的。患有心脏病的患者更可能是老年人、男性、无症状胸痛、较高的血清胆固醇、较低的最大心率、运动诱发的心绞痛、运动期间与休息时相比较高的 st 段压低、平坦或向下倾斜的运动 ST 段峰值斜率、受影响的主要血管以及通过铊负荷试验识别的血流缺陷(固定或可逆)。
我们在预处理时需要考虑 EDA 的一些观察结果:
- 连续(通过荧光镜检查确定的血管计数)和分类特征(铊负荷试验心脏血流)的一些缺失值。
- ST-T 异常的静息心电图结果在整个队列中只有 4 例——这是一个罕见的水平，我们可以将其与另一个水平相结合，或者您可以将其视为一个低方差的特征。我们可能还想结合其他功能的水平。
- 一些潜在的异常值，一个没有心脏病的患者的血清胆固醇水平高于 500，心脏病组中的两个患者的 ST 段压低值> 5。
实验装置
我结合了一些类别(胸痛的典型和非典型心绞痛；静息心电图 ST-T 异常与左心室肥厚:峰值运动 ST 段斜率平缓或下降；血流铊负荷试验中的固定缺陷和可逆缺陷)并将运动期间的血清胆固醇和 st 下降调整至 99.5 百分位，以解决上述第 2 点和第 3 点。
修改后的数据通过 setup() 功能成为实验的基础。该功能有大量输入，因为它创建了一个数据处理管道，涵盖许多常见任务，如转换、归一化、插补等。完整的列表可以在这里找到(【https://pycaret.org/preprocessing/】T2)。
在实验设置中，我们将使用 65%的数据进行训练。为了解决缺失值，我们将数值和分类特征的插补方法分别设置为中位数和众数。运行时，我们首先确认分类变量和数字变量的名称。然后创建管道的其余部分，实验设置完成，生成一个漂亮的汇总表，突出显示管道的各个方面(图 3)。
图 3。实验设置包括确认特征类型，然后生成管道汇总表(截断)。
我们可以看到，我们保留了原始数据中的所有观察值(如果我们选择使用 PyCaret 来过滤离群值，那么与原始数据相比，采样数据中的观察值数量会更少)。使用我们的 65%训练 35%测试分割，我们分别有 196 和 107 个观察值。总共有 15 个特征(5 个数字特征和 10 个分类特征)。第 4 行中突出显示的部分表示检测到缺失数据，第 13 行和第 14 行表示我们对这些数据进行估算的选择。
重要的是，这个设置对象构成了所有后续工作的基础。模型开发的许多后续函数调用会将结果保存为实验对象的一部分，以便可以随时访问它们，而且还可以保存整个过程。例如，实验对象包含用于采样、训练和测试特征矩阵以及目标向量的单独项目。
模型开发
设置完成后，为了快速识别一组好的候选模型，我们使用 compare_models() 。这使用默认超参数来评估不同的分类模型，并使用 10 重交叉验证来评估训练数据中的性能。有 18 种可能的分类器可用，但为了好玩，让我们将自己限制在一些增强方法(梯度，极端和轻)，两种风格的 SVM(线性，径向基)和随机森林。 compare_models() 的输出很好地总结了被评估者的六个常用分类器指标(图 4)。
图 4。compare_models()的输出
理想情况下，我们会选择最佳候选模型，并在调整后选择最终选项。然而，为了简单起见，鉴于我们的极端梯度推进模型是一个很好的准确性候选，让我们继续这样做。如果我们想查看上表中所选分类器的 CV 结果，我们可以使用 create_model() 函数为一个特定的模型创建一个对象。
超参数调优是使用 tune_model() 函数完成的，这稍微提高了性能(图 5)。例如，精确度从 0.82 提高到 0.85。请注意，如果你看引擎盖下，随机网格搜索与 10 次迭代正在使用。当然，可以使用更多的迭代，甚至是不同的方法，例如 hyperopt，但是为了本文的目的，我们将继续查看模型。
图 5。调整后候选模型的性能
evaluate_model() 函数提供了一个交互式单元格输出，其中包含许多常用的有用图表和摘要。可用性可能取决于您正在评估的模型，但是大多数对于所有模型都是通用的，并且代表了我们在评估模型时想要的一组良好的标准输出。交互式单元格如下所示，其中灰色框中的每个选项都可以在笔记本中点击。查看我们的混淆矩阵作为示例输出(图 6)，我们可以看到在测试集中我们有 45 个真阴性，36 个真阳性，以及 13 个假阳性和假阴性的实例，这给了我们 76%的准确率。
图 6。evaluate_model()中调优模型的混淆矩阵
为了理解是什么特征驱动了模型的心脏病预测，通常使用 SHAP 值(https://shap.readthedocs.io/en/latest/)。PyCaret 允许我们使用函数 interpret_model() 创建选定的基于 SHAP 的输出，以便更好地理解我们的模型。
图 7。SHAP 值汇总图
对于我们的模型，三个主要因素(图 7)是受影响的主要血管的数量，其中最低值(0)降低了预测风险，无症状胸痛(如果存在)增加了预测风险，铊负荷试验表明正常血流(高值)降低了预测风险。我们还可以看到一些似乎对预测风险没有影响的因素:空腹血糖高、胸痛(心绞痛或非心绞痛)和性别。
为了更深入一点，我们可以看看在我们的测试集中，特征对患者的预测风险评分的贡献(图 8)。
图 8。对高风险患者的预测贡献
与基础风险评分(平均模型输出= -0.21，概率= 0.45)相比，该患者的高度 ST-T 抑制、最大心率、铊负荷试验的血流缺陷、无症状胸痛和 2 条受影响的主要血管均导致心脏病的高预测风险评分(4.97，概率= 0.99)。
使用 predict_model() 函数，我们可以使用拒绝集来检查性能。性能比训练 CV 差一点，所以我们可能有点过度拟合，但也可能更差(图 9)。另外，通过适当的超参数调整，我们也可以克服这个问题。
图 9。我们所选模型的保留集性能与训练数据中的默认和调整模型性能的比较
最后，为了在实践中使用这个模型，我们可能还希望将预测的心脏病可能性分组，以便我们可以定义要采取的一系列行动。一种方法是根据预测的风险十分位数，在测试组中绘制心脏病发病率图。我们设定阈值的位置取决于具体情况，需要具备专业的临床知识并了解收益与成本。由于这是一个例子，我掩饰这一点。目测之后，我们假设有三个不同的风险组(低、中、高)，每个风险组都有不同的跟进措施。
图 10。根据预测的风险十分位数，测试组的心脏病发病率。虚线是队列中的总体风险(0.45)
读者可能已经注意到上面的输出缺少 Python 代码。那么，在我自己准备数据并生成上面的一些自定义数字之后，设置数据管道、使用 CV 识别候选模型并对其进行调优、评估和解释，以及最终评估保留测试集的性能，到底需要多少 PyCaret 代码呢？这就是，7 个功能，最少的输入！
# experiment set-up
exp1 = setup(hd_df,
train_size=0.65,
target='target',
session_id=101,
ignore_features=['num', 'target_c'],
numeric_imputation = 'median',
categorical_imputation = 'mode')# find a good candidate model
compare_models(blacklist=['lr', 'lda', 'qda', 'et', 'catboost', 'ada', 'ridge', 'dt', 'nb', 'gpc', 'knn', 'mlp'],
fold=10,
turbo=False)# tune the candidate model - you can skip create_model as this is called as part of tune_model anyway
tuned_model = tune_model('xgboost')# evaluate
evaluate_model(tuned_model)# SHAP-based feature importance and understanding of prediction
interpret_model(tuned_model)
interpret_model(tuned_model, "reason", observation=94)# performance in hold-out test set
predict_model(tuned_model)
摘要
这是我第一次尝试使用 PyCaret，虽然仍然有大量的文档需要完成，但我的第一印象是它太棒了！它真的让我可以很快地了解我想了解的细节，文档和可用的教程都很有帮助。
正如我们看到的实验设置，找到一个模型，调整，评估和检查当然是低代码。低代码当然并不意味着在数据理解、数据清理和功能工程方面跳过尽职调查，但是 PyCaret 方法意味着你可以在这些事情上花更多的时间。
当然，任何低代码解决方案都需要权衡灵活性。以下是我的一些观察:
- 在实验设置中，您不能选择仅应用于选定特征的预处理选项，并且并非所有可能性都可用。例如，不能对单个要素应用法线变换，也不能设置阈值来修剪要素以减少异常值。
- 您需要检查构造的管道对象，以了解预处理步骤的执行顺序。生成管道流程图表示的功能可能是一个奇妙的未来附加功能。
- 允许超参数调整的不同方法的灵活性将是很大的，例如访问 hyperopt 的简单方法。我确实自己尝试了一些实验，在实验对象之外使用 hyperopt，然后将这些参数传回到模型摘要中是可能的(但是很笨拙)。
- 包含 SHAP 值的函数是很棒的，但是这种功能没有扩展到通过标准 SHAP 库提供的全套可视化。例如，通过 link='logit '参数传递单个力图的多患者力图，或者选择用于相关性图中交互项的变量，都不能通过 interpret_model() 获得。然而，您可以从实验对象中获取模型对象和测试数据，并自己进行 SHAP。
- 您可以通过实验对象访问的内容有些随意，您可能需要稍微搜索一下您想要的内容，或者您可能需要检查实际的函数(即，您选择的估计器的调整模型中使用的参数网格)。然而，这些可以被访问，因此可以创建模型开发的定制摘要/可视化，并且希望在未来的更新中，从引擎盖下获得您需要的东西可能会更加用户友好。
- 该结构引导用户遵循适当的标准化工作流程来开发预测模型。
- 将最终模型和整个实验作为单独的对象保存的能力对于部署和可再现性来说是非常重要的。
- 虽然我能够提取信息并创建自己的总结，例如初始训练、调整和保持之间的性能指标，但从实验对象创建这种性质的总结报告的功能将是非常棒的。
在未来，我希望更多地利用 PyCaret 来处理更大的数据集，其中高基数特性的内置处理会非常有用。一如既往，欢迎评论、想法、反馈和讨论。
开发机器学习管道
在数据科学领域，你的表现取决于你构建工作的方式
E 即使最有经验的数据科学家也不总是熟悉开发机器学习管道的最佳实践。对于应该包括哪些步骤，它们的顺序应该是什么，以及总的来说，如何确保您创建的见解是准确和有价值的，存在很多困惑。描述实用和正确方法的好资源也非常有限。
然而，在许多数据科学项目之后，你开始意识到构建管道的方法总是相同的。
机器学习管道是模块化的，根据情况，可以添加或跳过一些步骤。你有分类变量吗？添加代码对它们进行一次性编码。你有丢失的数据吗？引入一些代码来估算它们。
为了给出更实用的方法，您可以在我的 Github 上找到一个示例管道。这个例子旨在开发一个预测模型，用于估计驾驶员发生严重事故的风险。
1.商业问题
任何机器学习管道都是从最重要的一步开始的，这根本不是机器学习，而是商业问题。在对我们要实现的目标进行彻底讨论之前，机器学习不应该发挥作用。
所有利益相关者都应该参与到这样的对话中，尤其是业务团队和最终用户。应该仔细倾听他们的目标，在整个项目过程中，应该始终牢记他们的需求和目标。因为，说到底，做机器学习是没有意义的，不管它有多性感，除非它能解决利益相关者的问题。你应该问你的利益相关者:这个项目的动机是什么？有哪些痛点？结果将如何被使用？
即使在这些问题得到回答之后，立即开始编写机器学习模型也是错误的。有没有更容易、更务实、更有效的解决方案来实现你的利益相关者的目标？我们能否使用描述性统计或更容易使用的工具，如 Excel？当且仅当答案是否定的，我们才能继续下一步。
2.翻译需求
一旦同意 ML 是正确的方法，下一步就是将目标、难点和限制转化为技术需求。换句话说，您需要将业务需求转化为易于应用于标准建模技术的东西。如果你的利益相关者寻求一个实数的预测，那么使用回归模型；如果您必须预测有限的一组值，分类模型是最合适的解决方案。
3.数据收集
没有数据，任何机器学习项目都不可能成功。要保证项目的成功，需要获得足够多的高质量样品。更具体地说，像线性回归或逻辑回归这样的算法即使只有几百个观察值也能很好地工作，而更复杂的算法，从 CART 到神经网络，至少需要几千个。
就质量而言，来自自动化、不灵活系统的数据，在没有人为干预的情况下，将更适合机器学习应用。例如，应该避免自由文本字段。如果数据收集设置是数据科学家创建的 Google 表单，下拉列表比自由文本框更受欢迎。
然而，总的来说，每个数据科学家都应该接受这样的事实:数据将会是杂乱的，手工输入的，充满了缺失的数据。这只是工作的一部分。
4.数据加载
数据集最常见的格式通常是 CSV 和 Excel 文件。要加载数据，您可以使用:
vehicles = pd.read_csv(‘Data/Vehicles.csv’, low_memory=False)
casualties = pd.read_csv(‘Data/Casualties.csv’, low_memory=False)
accidents = pd.read_csv(‘Data/Accidents.csv’, low_memory=False)
也就是说，如果您可以从数据库中获取数据，这将是首选。数据库被配置为保持完整性，这意味着只允许通过完整性检查的数据。此外，数据库维护跨表的关系，同时易于更新。这样做，脚本可以通过编程从相同的源中提取数据，这保证了数据的一致性。为此，请使用适合各种 SQL 的 Python 库。例如，要连接到 PostgreSQL 数据库，您可以使用 psycopg2 库。要建立连接:
con = psy.connect(host=<Database Address>,
user=<Username>,
password=<Password>,
dbname=<Database Name>)
一旦建立了连接，就可以使用*熊猫:*轻松获取数据
pd.read_sql('select * from tbl_vehicles', con)
5.探索性分析
一旦数据加载到内存中，熟悉它们是关键。应进行初步探索性分析，以了解数据集的粒度、可用的信息类型和目标变量。
通常要计算的统计数据是每个特征的平均值和标准差，以及突出显示特征分布的直方图。值的范围也是注意异常值的关键。获得最有用的统计数据的一个简单方法是使用:
vehicles.head()
vehicles.describe()
其中第一行给出了前 k 行，而第二行显示了数据的基本统计。
要显示感兴趣特征的分布，您可以使用熊猫。hist()函数:
casualties.Casualty_Severity.hist()
6.数据聚合
数据通常不是正确的格式。它可以是不适合任务的粒度，例如在“伤亡级别”而不是“车辆级别”，其中每一行对应一个伤亡。此外，它可以跨多个文件拆分，需要将多个数据集聚合在一起。
为了克服这些限制，我们可以，例如，简单地使用熊猫的 groupby 函数。在本例中，我们做到了:
casualties.groupby(['Accident_Index', 'Vehicle_Reference'])['Casualty_Severity'].min().reset_index()
这使得我们可以为每辆车只选择最严重的伤亡事故(得分最低)，在“车辆级别”汇总这些信息。
7.数据清理
在我们熟悉数据集之后，我们可以开始构建生产管道本身。第一步是处理数据，清除错误和不一致。例如，日期应该在合理的范围内(例如，过去事件的日期不应该在未来)，并且在日期功能中采用一致的格式(例如，我们不应该有一个“mm/dd/yyyy”格式的列和另一个“dd/mm/yyyy”格式的列)。
如果模型在预测一个未来的结果，比如下个月发生车祸的可能性，我们只能考虑所谓的“事前”信息。这些特征是目前已知的，即驾驶员的年龄、通常驾驶的汽车的发动机类型等。同时必须删除所有“事后”信息。这些包括诸如事故地点、天气状况等特征。直到要预测的事件发生后才知道。否则会让我们的模型“窥视未来”，使其无法预测结果。
8.特征工程
另一个关键步骤是特征工程。这一步包括从结构化格式的数据中提取信息。例如，我们可以通过从收集驾驶员数据的日期中减去出生日期来得出驾驶员的年龄。这一步可以帮助机器学习算法更好地识别数据中的信号。
8.1 处理分类特征
通常教授许多不同的技术来处理分类特征。此类特征的问题在于它们不是数字，因此无法计算量化指标，如数字和类别之间的距离。
对类别进行编码的一种常见方式是将它们映射到数字，只需将相同的数字分配给相同的类别。然而，这种方法是极其有害的，因为它创造了现实中并不存在的关系。例如，如果我们将[‘汽车’，‘摩托车’，‘自行车’]编码成[1，2，3]，我们基本上是在声明’自行车’是’汽车’的三倍，不管那是什么意思，或者两次’汽车’等于’摩托车’。
更好的方法是一键编码和目标编码。一键编码包括创建额外的二进制特征，每个类别的值一个，如果样本具有这样的值，则假设为 1，否则为 0。这可以通过以下方式实现:
pd.get_dummies(data[c])
相反，目标编码是用目标变量的平均值替换分类值的过程。这样做，我们基本上可以根据分类变量对目标变量的影响对它们进行排序。
9.分割培训、验证和测试
一旦我们有了一个包含相关特征的数据集，我们就可以把它分成训练集、验证集和测试集。通常情况下，训练和验证占 70%的数据，而测试是剩下的 30%。如果有足够的数据，测试集可以减少到 20%，因为样本的数量无论如何都足够多。这种分割通常是随机进行；然而，这个一般规则有几个例外。
第一，在分类问题中，我们经常使用分层抽样。如果少数类的频率明显低于其他类，这一点尤为重要。在这种情况下，如果我们随机选择一个拆分，我们可能会很不幸地没有选择训练集中少数类的任何样本，而是选择测试集中的所有样本，从而大大降低性能。
相反，当使用时态数据时，分割应该按顺序进行。特别地，训练数据应该是时间上排序的数据的最初 70%,而测试集应该是最近的部分。这阻止了模型“展望未来”。
10.归罪
只有分割数据集后，我们才能处理丢失的值。如果我们用所有的数据集来估算数据，从技术上来说，我们就是在作弊。我们将用来自测试集的信息填充训练集。正确的方法是仅用训练集拟合插补学习者，然后转换训练集和测试集。
有许多方法可以用来估算缺失数据。最著名的包括计算平均值、中间值或其他常量指标。然而，这些方法通常是要避免的。主要原因是它们完全改变了特征的分布，减少了方差，因为我们增加了多次常数项。此外，他们没有考虑功能之间的关系，一次只关注一个功能。
两个更好的解决方案是 MICE 和 KNN，前者适合一个分布，后者考虑用最接近的邻居来估算数据。为了选择 K 的参数，可以使用验证，使用肘方法，增加 K 的数量，直到验证集上的性能仅略微增加。
lnr = si.KNNImputer()lnr.fit(train_X)train_X = lnr.transform(train_X)
test_X = lnr.transform(test_X)
11.系统模型化
现在，你可以训练你的模型，但是…你应该选择哪一个？
这在很大程度上取决于我们要完成的任务、样本数量以及我们想要的互操作性水平。在医疗保健和金融等风险较高的领域，了解一个模型为什么会做出预测至关重要。如果模型没有如此强烈的含义，我们可以使用更复杂的黑盒算法，如神经网络。
一般来说，测试的模型应该在可解释性和性能方面有所不同。如果一个更简单的模型达到的性能几乎接近更复杂的模型，同时更容易理解，那么这个模型应该是首选的。
我通常使用的模型有:
- 逻辑回归(或用于回归任务的线性回归)
- 随机森林
- XGBoost
为了调整此类模型的参数，我们通常执行网格搜索，测试所有参数组合以找到最佳组合。
12.性能赋值
为了评估模型的性能，我们可以使用各种度量标准，但是分类和回归任务有两个不同的集合:
对于回归，使用均方误差(MSE)、均方根误差(RMSE)和 R。其中，RMSE 和 R 通常是首选，因为 RMSE 的原始任务单位相同，而 MSE 的单位是平方。如果我们想预测投掷物体的距离，RMSE 会用米(或英里)来计算误差，而 MSE 会用平方米(或平方英里)来计算，这就失去了很多直觉。
对于分类，通常可以计算的指标是准确性、敏感性(或真阳性率)和特异性(或真阴性率)。另一个有用的度量是通过绘制不同阈值下的灵敏度和特异性，获得更全面的图，ROC 曲线(接收器操作特征曲线)。在这些度量中，准确性通常是最常用的度量之一，然而，当类严重不平衡时，它就变成了一个无意义的度量。为了解决这个问题，AUC，即 ROC 曲线下的面积，是通常首选的指标，因为它更可靠。AUC 从 0.5(随机选择)到 1(完全分类)。
13.部署
最后，一旦我们对模型的性能感到满意，并且无法实现进一步的改进，我们就可以继续进行最后的步骤。这些包括向利益相关者展示结果，强调性能、特性重要性等。以及在生产中部署模型。要做到这一点，我们可以利用 Amazon Web Services 或 Azure 等平台来托管该模型，并通过前端让最终用户可以使用该模型进行交互。
摘要
开发机器学习管道的过程涉及相同的一组步骤:
- 商业问题
- 翻译需求
- 数据收集
- 数据加载
- 探索性分析
- 数据聚合
- 数据清理
- 特征工程
- 分割培训、验证和测试
- 归罪
- 系统模型化
- 性能赋值
- 部署
要阅读更多类似的文章，请关注我的 Twitter ，LinkedIn或我的 网站 。
为数据科学家开发 Python 库
来源: Pexels (CC0)的 luis gomes 。
很大一部分数据科学家每天都使用 Jupyter 笔记本。如果你不熟悉 Jupyter 笔记本，你可能会问，为什么它们这么受数据科学家的欢迎？我对这个问题的回答是因为他们太棒了！Jupyter 笔记本允许交互式编程。有了这些笔记本，除了许多其他功能，您可以轻松地用 markdown 记录您的代码，轻松地查看单元格的输出，以及创建和查看数字。如果你以前从未使用过 Jupyter 笔记本，我强烈建议你尝试一下(这里是一篇很好的博客文章，讲述了 Jupyter 笔记本的一些其他酷功能)。这些笔记本是数据科学家和所有科学家的完美之选。它们允许我们轻松地试验创建新的模型，记录我们的试验，并轻松地调试代码。
尽管 Jupyter 笔记本是数据科学家通常用于实验和创建模型的工具，但实现数据科学项目的实际生产代码很少写在笔记本上。通常它们是用 Python 文件编写的(即。py 文件),当在生产环境中工作时，这是一个合理的选择。例如，历史上，Jupyter 笔记本存在一些版本控制问题。这很大程度上与渲染问题有关。一台计算机呈现 Jupyter 笔记本的方式在另一台计算机上可能不同，因此如果两个不同的开发人员在一台笔记本上工作，这可能会出现一些问题。此外，许多软件工程师不熟悉 Jupyter 笔记本电脑，因此在数据科学家和软件工程师的团队中，软件工程师不太可能想要参与和维护写在笔记本电脑中的生产代码(不是说没有例外！).但这真的很丢人！Jupyter 笔记本非常适合记录和讲述一个图书馆是如何发展的故事。我还发现在 Juptyer 笔记本上编码时，调试代码更容易，最重要的是实验！
不要害怕！随着 fast.ai 团队开发的名为 nbdev 的惊人 Python 库的发布，许多这些问题都得到了解决。最终，nbdev 的目标是允许在 Jupyter 笔记本中创建 Python 库。其工作方式是，在 Jupyter Notebook 中编写您希望包含在库中的代码，并在您希望包含在生产代码中的单元格中，在单元格顶部包含#export标记(如下图所示)。当您准备好导出库时，您只需在命令行中键入nbdev_build_lib，您的代码将被导出到 Python 文件中。很简单！
来自 nbdev 网站。
再说一次，Jupyter 笔记本电脑的真正强大之处在于增强的文档功能。nbdev 不仅可以轻松地在笔记本上开发生产代码，还可以集成文档。Jupyter 笔记本允许使用 markdown，这使得讲述/记录代码甚至演示代码的特性变得很容易。例如，在上图中，有描述combined_cos函数的文档，甚至还有下面的示例值图。该代码不会被导出到生产代码中，而是保存在 Jupyter 笔记本中以供记录。这可以允许用户容易地理解功能。还有，文档可以转换成可以托管在 GitHub 页面上的网页，非常有用(如下图所示)！直接从源代码中提取代码文档的想法非常强大，我发现这是一个非常有用的特性。你再也不用担心库的文档是与源代码同步的，因为有了 nbdev，文档是直接从源代码中提取的。
来自 nbdev 网站。
结论
如果你是数据科学家/软件工程师，给 nbdev 一个机会吧！fast.ai 团队有很棒的教程如果你想入门的话。我使用 nbdev 创建了一个异常检测库，这是一次很棒的体验——我也发现维护这个库很容易。nbdev 还有很多我没有在这里描述的其他特性(例如，导出到 pip，解决合并冲突)，这些特性可以在教程和 nbdev 的文档中找到。祝您编码愉快，如果您在开发数据科学库方面需要帮助，请访问我的网站获取我的联系信息！
数据科学、迪士尼和 Tindering
与数据科学长期关系的 5 个事实
图片由俏皮话
TL；DL —谈恋爱很容易。持久的爱很难。在第一次约会并与数据科学建立长期关系之前，你应该知道以下 5 个事实。最后，您可以通过现场调查了解社区对数据科学的承诺程度。
免责声明 :所有观点均为本人观点。我交替使用“数据科学”、“机器学习”和“分析”。
喜欢读什么？ 跟我上 中 ，LinkedIn，或者Twitter。
外星人、火绒和爱情
我最近看到了俏皮话的一个娱乐性和挑衅性的视频。它探索了什么是真爱，以及现代夫妻之间的互动。这让我想起了我们与“数据科学”(或任何职业)的关系。
YouTube:里克和莫蒂谈爱情
如果你很忙，以下是要点:
- 一个外星人做了一个类似 Tinder 的 app 这个应用程序让“爱”变得丰富。
- 这太棒了。人们可以很容易地逃离糟糕的情况。
- 但是，恶性循环从未打破。我们相爱，争吵，逃避，重复。
- 在某一点上，每个人都累了，并问:我们为什么要这样做？什么是真正的爱情？我们如何维持良好的关系？
坠入爱河又失恋的故事
让我们将它与数据科学领域的职业生涯进行对比。
你对数据科学一见钟情是因为它太性感了——嗯，它是 21 世纪最性感的工作。谁不会得意忘形？所以，向右滑动。
然后，你带着最好的西装、妆容或任何你想做的事情去约会。数据科学展示了所有奇妙的可能性和新奇的小玩意。事实上，数据科学非常喜欢你，并决定给你一个机会进一步探索事情。
接下来，你最终通过签署要约结婚(哎呀)。在迪斯尼电影中，这是灰姑娘和白马王子幸福生活的时刻。电影结束；幕布落下；人群欢呼鼓掌。
但是在现实中，白马王子变懒了(可能还变胖了)。灰姑娘变得脾气暴躁(并且可能满脸皱纹)。灰姑娘宝宝一直在哭。迷人国王生病了。魅力大叔引发内战。最后，王子像懦夫一样逃跑了。
现在，你开始质疑数据科学是否适合你，并开始寻找新的工作。恶性循环开始。你爱上别的，受挫，寻找出路，重复。进入数据科学就像使用 Tinder 寻找关系一样。
那么，我们为什么不专注于寻找合适的人(例如数据科学职业)并维持良好的关系呢？
事实核查
我相信每个人都想要幸福、满足和健康的关系，无论是个人还是事业。建立这种关系的关键是理解并诚实面对现实。
这里有 5 个重要的(伪)事实可以帮助你做到这一点:
**事实 1:数据科学使用最好的自拍滤镜。**雇主希望尽可能好地描述数据科学角色。这可以理解。所以，问问他们每天都做些什么。不要被个人资料图片骗了。
事实 2:家务永远不会结束。“天下没有免费的午餐。”凡事都有代价。恋爱，关系好也不例外。注意那些为了享受数据科学的乐趣而不得不做的无聊事情。
事实 3:家庭动态可能很复杂。许多数据科学团队试图向业务、工程和产品同行证明价值。这会导致紧张、困惑和沮丧。
事实四:狗狗很可爱；孩子可能很烦人。制作原型就像养狗一样。它需要更少的工作和温暖的心。相比之下，将 ML 部署到生产中就像有了孩子一样。这需要做更多的工作，而且当东西坏了的时候很烦人，尤其是在半夜。
事实 5:变化是唯一不变的。就像我们一样，数据科学也随着时间而变化。我们不知道未来 5 年、10 年它会变成什么样。接受和适应变化在一段关系中至关重要。保持学习和好奇心，否则就会落后。
认识、理解和接受这些事实是走向健康和可持续关系的重要一步。
斗牛中的最后一剑
那么，什么是真正的爱情呢？
“爱是最持久的建筑。真正的爱情是持久的，有时是痛苦的，战胜时间、空间和世界设置的障碍。”
法国哲学家阿兰·巴迪乌
那么，你对数据科学的热爱是真的吗？
喜欢读什么？ 跟我上 中LinkedIn，或者*Twitter。你想学习如何沟通，成为一名有影响力的数据科学家吗？查看我的《 用机器学习影响 》指南。*
这里有几篇你可能会喜欢的文章:
每个懒惰的全栈数据科学家都应该使用的 5 套工具
towardsdatascience.com](/the-most-useful-ml-tools-2020-e41b54061c58) [## 被遗忘的算法
用 Streamlit 探索蒙特卡罗模拟
towardsdatascience.com](/how-to-design-monte-carlo-simulation-138e9214910a) [## 数据科学很无聊
我如何应对部署机器学习的无聊日子
towardsdatascience.com](/data-science-is-boring-1d43473e353e) [## ML 和敏捷注定的联姻
如何不对 ML 项目应用敏捷
towardsdatascience.com](/a-doomed-marriage-of-ml-and-agile-b91b95b37e35) [## 人工智能的最后一英里问题
如何培养人类和人工智能之间的信任
towardsdatascience.com](/fixing-the-last-mile-problems-of-deploying-ai-systems-in-the-real-world-4f1aab0ea10) [## 又一个 AI 冬天？
如何部署更多的 ML 解决方案——五种策略
towardsdatascience.com](/the-last-defense-against-another-ai-winter-c589b48c561)*
发展对机器学习模型预测的信任
使用 LIME 解释和说明机器学习模型做出的预测
肖恩·梅因斯在 Unsplash 上拍摄的照片
如果我告诉你今天投资 10 万美元在一只特定的股票上，因为我的机器学习模型预测会有高回报。你会问我的问题将是解释我的预测的基础，因为这对你来说是一个重大的决定。你不想赌博，但想根据数据做出明智的决策。
为了信任机器学习模型的预测，你会问以下问题。
- 模型是如何做出预测的？
- 为什么模型会对特定的实例做出特定的预测？
- 哪些特征对预测的影响最大，哪些影响最小，并给出一个易于理解的解释。
- 模型的解释应该呈现特征和模型预测之间的文本或视觉定性关系。
在这篇文章中，你将学习使用 LIME 来解释机器学习模型的预测，并解释对做出预测贡献最大的特征。
有几种解释机器学习模型的技术，但这里我们将讨论 LIME(局部可解释模型-不可知论者解释)。
什么是石灰？
LIME 是机器学习模型的局部可解释模型不可知解释，它让你理解个体预测，
- LIME 可以解释机器学习模型的单个预测，而不是解释整个数据集。
- 它是局部忠实的，并且具有局部保真性，这意味着全球基本特征在局部环境中可能不那么重要，反之亦然。它通过用一个可解释的模型对其进行局部近似来做到这一点。
- 它是模型不可知的，可以应用于分类器以及基于回归的机器学习算法。
石灰是怎么起作用的？
LIME 扰动输入数据集以查看预测中的变化。这些扰动是基于数据的方差。
- 它创建一个可解释的表示，该表示根据输入数据的小扰动进行训练，这提供了一个用于解释个体预测的良好的局部近似。
- 它在可解释表示数据 和原始数据之间创建相似性分数，以了解它们有多相似
- 使用可解释制图表达数据集上的模型进行预测。
- 它在可解释的表示数据集上尝试不同的组合，以找到最大可能匹配模型在原始数据集上所做预测的最小要素集。
- 确定的最小特征集给出了原始数据的大部分信息以及相似性得分，用于解释个体预测。
有哪些不同的机器学习模型可以用到 LIME？
LIME 与模型无关，可以用于
- 分类以及回归问题。
- 它可以使用 NLP 在文本数据上使用。
- 可应用于图像数据
- LIME 也可以应用于表格数据，其中列代表特征，行是单独的实例。
如何将 LIME 应用于基于分类的机器学习模型？
石灰在使用表格数据的分类模型中的应用
使用的数据集是默认信用卡客户数据集。
对于分类问题，值 1 意味着客户将拖欠付款，值 0 表示客户不会拖欠信用卡付款。
加载数据并显示列名
**import pandas as pd
import numpy as np
np.random.seed(0)
df = pd.read_csv(r'c:\data\default of credit card clients.csv')
df.columns**
创建特征和目标变量
**Y = df[['default payment next month']]**
**X = df[['LIMIT_BAL', 'SEX', 'EDUCATION', 'MARRIAGE', 'AGE', 'PAY_0', 'PAY_2', 'PAY_3', 'PAY_4', 'PAY_5', 'PAY_6', 'BILL_AMT1', 'BILL_AMT2','BILL_AMT3', 'BILL_AMT4', 'BILL_AMT5', 'BILL_AMT6', 'PAY_AMT1', 'PAY_AMT2', 'PAY_AMT3', 'PAY_AMT4', 'PAY_AMT5', 'PAY_AMT6']]**
将数据集分成训练和测试
**from sklearn.model_selection import train_test_split
from sklearn import preprocessing****X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size = 0.4)**
创建随机森林分类器并拟合训练数据
**from sklearn.ensemble import RandomForestClassifier**
**model = RandomForestClassifier(max_depth=6, random_state=0, n_estimators=10)
model.fit(X_train, Y_train)**
显示特征重要性
**importances = model.feature_importances_
indices = np.argsort(importances)****features = X_train.columns
plt.title('Feature Importances')
plt.barh(range(len(indices)), importances[indices], color='b', align='center')
plt.yticks(range(len(indices)), [features[i] for i in indices])
plt.xlabel('Relative Importance')
plt.show()**
创建石灰表格实例
因为我们的数据集是表格形式的，所以我们创建了 LimeTabularExplainer()的一个实例。 training_data :通过训练数据集，
模式:可以是回归或分类。我们正在处理一个分类问题，所以我们将模式参数设置为“分类”
feature_names :数据集中的所有输入特征，用于计算每个特征的统计数据。平均值，计算数值特征的标准偏差，而分类特征被离散化为四分位数。
训练 _ 标签:传递训练目标变量
**import lime
from lime.lime_tabular import LimeTabularExplainer****explainer= LimeTabularExplainer(*training_data*=np.array(X_train),
*mode*='classification',
*feature_names*=list(X_train.columns),
*training_labels*=np.array(Y_train),
*random_state*=12**
使用从训练数据生成的计算统计
- 创建扰动的样本实例，这是一个可解释的表示数据集。
- 当属性不在同一标度上时，缩放数据以计算相似性得分的距离。
为预测生成解释
现在，您可以通过将观察结果传递给 explain_instance() 来为特定的观察结果生成解释
data_row: 指定需要解释的观察结果
classifier_fn: 需要为分类模型指定模型预测概率，采用 numpy 数组，输出预测概率。对于回归模型，我们可以指定模型预测。
num_features :我们需要解释的最大特征数
**exp = explainer.explain_instance(X_test.iloc[0], model.predict_proba, num_features=8)****exp.as_pyplot_figure()
from matplotlib import pyplot as plt
plt.tight_layout()**
在 python 笔记本中显示 HTML 解释
**exp.show_in_notebook(show_table=True, show_all=True)**
如何解读结果？
对于观察，概率预测是 87%，即客户不会拖欠信用卡付款。
客户未拖欠信用卡付款的原因
客户没有拖欠本月、2 月、3 月、4 月、5 月和 6 月的任何付款(PAY_0、PAY_2、PAY_3、PAY_4、PAY_5 和 PAY_6 为 0)。最近三个月的付款少于 1800 美元
让我们来看另一个观察的解释。
**exp = explainer.explain_instance(X_test.iloc[731], model.predict_proba)
exp.show_in_notebook(show_table=True, show_all=False)**
对于观察，概率预测是 75%，客户将拖欠信用卡付款。
客户拖欠信用卡付款的原因
客户将本月、2 月、3 月、4 月、5 月和 6 月的付款延迟了两个月(PAY_0、PAY_2、PAY_3、PAY_4、PAY_5 和 PAY_6 为 2)。消费信贷少于或等于 500 美元。
基于回归的机器学习模型如何应用 LIME？
LIME 在使用表格数据的回归模型中的应用
使用的数据集是房地产价格预测 n。
这里我们将使用 RandomForestRegressor 。
#Importing required libraries
**import pandas as pd
import numpy as np
import plotly
np.random.seed(0)
import matplotlib.pyplot as plt
import lime
from lime.lime_tabular import LimeTabularExplainer
from sklearn.model_selection import train_test_split
from sklearn import preprocessing
from sklearn.ensemble import RandomForestRegressor**#Reading the data file
**df = pd.read_csv(r'c:\data\Real estate.csv')**# Creating the input features and target variable
**Y = df[['Y house price of unit area']]
X = df[[ 'X2 house age',
'X3 distance to the nearest MRT station',
'X4 number of convenience stores', 'X5 latitude', 'X6 longitude']]**# check for missing data
**X.isnull().sum()**#Creating train and test data
**X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size = 0.2)**#Random Forest Regressor
**model = RandomForestRegressor(max_depth=50, random_state=0, n_estimators=1000, bootstrap=True)
model.fit(X_train, Y_train)**#printing feature importances
**importances = model.feature_importances_
indices = np.argsort(importances)
features = X_train.columns**
**plt.title('Feature Importances')
plt.barh(range(len(indices)), importances[indices], color='b', align='center')
plt.yticks(range(len(indices)), [features[i] for i in indices])
plt.xlabel('Relative Importance')
plt.show()**
创建一个石灰表格实例
将模式指定为回归。
**explainer= LimeTabularExplainer(training_data=np.array(X_train),
mode='regression',
feature_names=list(X_train.columns),
class_names=['Y house price of unit area'],
random_state=12
)**
为预测生成解释
**exp = explainer.explain_instance(X_test.iloc[0], model.predict, num_features=4)****exp.as_pyplot_figure()
from matplotlib import pyplot as plt
plt.tight_layout()**
**exp.show_in_notebook(show_table=True, show_all=False)**
结论
LIME 是一种模型不可知的机器学习技术，用于以人类可理解的格式解释基于分类或回归的模型的预测。LIME 为一次观察提供当地的解释。它最适用于表格数据、图像和文本。
参考资料:
我为什么要相信你？解释任何分类器的预测
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
