如何从复杂格式的文件中检索数据
我从 PDF 扫描图像中提取数据的方式
当我提取数据对马来西亚汽车市场进行分析时，我遇到了如何检索干净数据的问题。
我一直在谷歌上寻找可能有其他来源获得数据，但我没有找到答案。起初，我以为 pdfMiner 能够从 PDF 中提取一些文本，但都是 PDF 文件中的扫描图像。这是我唯一能得到的消息来源。
我很震惊，并感到累了，只是得到数据，并开始我的分析。过了一会儿，我尽力让引擎再次启动，谷歌搜索我找到了一个答案——OCR(光学字符识别)。
OCR 是一种识别数字或手写字符的技术。我发现最常用的库是 Python 中的 Tesseract OCR，这是一个由惠普公司发起的开源项目。在 Google 接手开发后，Google 发布了最稳定的基于深度学习框架的版本 4 . 0 . 0——LSTM(long short memory)。
简单来说，OCR 会逐行读取，逐字符识别字符，有两种
- 模式识别
- 基于特征的识别
1.模式识别
20 世纪 60 年代，一种叫做 OCR-A 的特殊字体被开发出来，用于银行支票等。所以，在当时，字体、笔画和字体大小都是标准化的，这样它就可以很容易地被识别为一个字符。然而，这种方式不能够识别不同种类的笔迹。
2.基于特征的识别
例如，一个字母“A ”,您可以将其视为 3 个笔画的组合:
因此，基于特征的识别可以在学习特征(笔画)时识别不同类型的笔迹。
换句话说，与简单的模式识别相比，像 LSTM 这样的基于特征的方法的当前技术能够识别字母“A”的特征。
我如何为马来西亚车辆分析检索数据
例如，在 NLP 中，我们经常有很多关于如何执行建模的想法，或者短语挖掘的多种方法。然而，当涉及到如何获取数据时，却常常被忽视。
首先，我必须通过谷歌搜索一些关键字，例如，马来西亚汽车协会(MAA)，但结果不是我想要的。因此，我试图更加具体，包括像 pdf 这样的关键字，所以最终使用了这个关键字:data 2017 年车辆销售数据。pdf 格式，以搜索所需的年度报告。通过改变年份，你将能够得到所有的年度报告。
然后，更有趣的部分来了:如何从包含快照图像的 pdf 中获取数据。我会把它分成两部分。
1.读入 pdf 文件，提取你需要的页面
我用的工具是 pdf2image 。它会将 pdf 的所有页面转换成图像。下面是我想提取文本的倒数第二页的快照。
所以我用 pdf2image 提取倒数第二页。然后，我只提取前 20 个品牌的汽车，并裁剪掉不相关的文本部分(如下图的紫色边界框所示)。使用这种方法，你将能够减少提取文本的噪音。
2.应用 OCR 将文本提取到 CSV
在裁剪掉所有不需要的部分后，我利用 tesserocr 包提取文本。以下是我在使用这个软件包时遇到的一些经验和问题。
如果你使用 tesserocr 的默认模型，你会发现这个模型犯了一些错误，例如 6 被预测为 8 和质子被预测为大虾，但总体来说还不错。因此，如果您使用默认模型，请对所有文本进行手动检查，以确保解析正确。
根据我的经验，使用宇宙魔方 3 和宇宙魔方 4 的主要区别是:
- 宇宙魔方 4 文本识别比宇宙魔方 3 好。
- 宇宙魔方 3 的数字识别比宇宙魔方 4 好。
Tesseract 支持超过 130 种语言，所以当你发现在解析文本时存在很多错误时，也许你应该考虑改变语言。
资源
作者克里斯·伍德福德。最后更新:2018 年 12 月 11 日。你曾经努力去阅读朋友的笔迹吗？算你自己吧…
www.explainthatstuff.com](https://www.explainthatstuff.com/how-ocr-works.html) [## Tesseract 版发布了基于 LSTM 的新引擎和更新的构建系统| Packt Hub
谷歌昨天发布了其 OCR 引擎 Tesseract 的 4.0 版本。宇宙魔方 4.0 带有一个新的神经网络(LSTM)…
hub.packtpub.com](https://hub.packtpub.com/tesseract-version-4-0-releases-with-new-lstm-based-engine-and-an-updated-build-system/)
最后的想法
其实还有更好的 OCR 服务，比如可以使用 Google OCR 付费服务进一步提高准确率。
我希望你喜欢这个帖子，并在下面评论你感兴趣的话题，我会努力为你创造内容！
关于作者
Low 魏宏是 Shopee 的数据科学家。他的经验更多地涉及抓取网站，创建数据管道，以及实施机器学习模型来解决业务问题。
他提供爬行服务，可以为你提供你需要的准确和干净的数据。你可以访问 这个网站 查看他的作品集，也可以联系他获取抓取服务。
如何在 15 分钟内用一个数据库和一个 GPU 在 Google Cloud 上运行一个数据科学的笔记本？
设置您的云外壳
首先，你需要有一个谷歌账户，并访问你的谷歌云控制台这里。
登录后，如果您是第一次使用 google cloud，您需要创建您的项目，方法是点击弹出窗口右上角的“选择一个项目，然后点击“新建项目，并按照几个简单的步骤创建您的第一个项目:
完成后，你应该会在谷歌云控制台窗口的顶部横幅中看到你的项目名称，而不是新项目。
现在，点击 Google Cloud 控制台窗口右上角的图标，打开您的云外壳(如果是第一次点击，您需要激活它，只需点击“启动云外壳”)。
你的云外壳窗口应该出现在当前谷歌云控制台窗口的底部。彩色文本是你的项目的名称，例如我的项目在这里是名称“first proj”+一个由谷歌提供的 id:
确保您的 ggcloud 组件保持最新并准备就绪:
sudo gcloud components update
安装和设置数据实验室
激活 API
Google Cloud console 要求您激活 API 以允许它们在您的项目上运行，如果您不这样做，您将不得不处理一个HTTPError 403:Access Not Configured错误。去那里，让我们激活所需的 API:https://console.developers.google.com/apis/library
搜索计算引擎 API 并启用它(如果尚未创建计费帐户，您将需要创建计费帐户)，确保 Google 云存储 API 已经启用:
安装 DataLab
gcloud components install datalab
现在，我们将创建一个数据实验室，该命令将创建一个具有数据科学基本要求的实例(我在这里选择了 n1-highmen-8，带有 8 个 vCPUs 和 52 GB 内存，请不要犹豫更改机器类型。要查看机器详情，请点击此处并点击此处):
datalab beta create-gpu your-datalab-instance-name --machine-type n1-highmem-8
您必须接受 NVidia GPU 驱动程序安装，然后选择一个区域，并按照查看步骤使用 SSH 访问您的 datalab 实例。
重要说明:默认情况下，create-gpu 命令使用 Nvidia Tesla K80 创建一个实例，该实例仅在那些选定的区域上可用:
us-west1-b
us-central1-a
us-central1-c
us-east1-c
us-east1-d
europe-west1-b
europe-west1-d
asia-east1-a
asia-east1-b
安装完成后，您可以通过在云 Shell 中键入以下命令，在 windows 浏览器中运行您的 datalab:
datalab connect your-datalab-instance-name
然后通过点击*改变端口:*将端口设置为 8081 打开一个窗口浏览器
给你！您刚刚安装了您的 Datalab Google 实例，它看起来应该如下图所示。你现在可以像使用普通的 Jupyter 笔记本一样使用它了。
设置你的谷歌云存储
一个实例不应该被用作一个存储环境这就是为什么 Google Cloud 提供了许多不同服务来提供不同种类的存储服务。这里我们就用最简单的一个:谷歌云存储。
点击左侧菜单，进入谷歌云的“存储”服务。
创建存储桶:
一切就绪，谷歌云存储非常简单，只需像通常的操作系统一样点击即可访问:
在你的数据实验室使用你的谷歌云存储
这是一个简单的示例函数，从 bucket 中读取一个文件和一个 csv。
import google.datalab.storage as storage
import pandas as pd from io
import BytesIO def get_bucket(bucket_target):
shared_bucket = storage.Bucket(str(bucket_name))
return shared_bucketdef read_file_from_bucket(file_target):
shared_bucket = get_bucket(bucket_target)
sample_object = shared_bucket.object(str(file_target)
sample_text = sample_object.read_stream()
return sample_textdef read_csv_from_bucket(bucket_name,csv_file_name):
%gcs read --object gs://+bucket_name+/+file_name --variable csv_as_bytes
df = pd.read_csv(BytesIO(csv_as_bytes))
return df
要打印存储桶的内容，请执行以下操作:
shared_bucket = get_bucket(bucket_name)
for obj in shared_bucket.objects():
if obj.key.find('/') < 0:
print(obj.key)
例如，要打印文本文件:
sample_text = read_file_from_bucket(file_name)
print(sample_text)
要获取 csv 表格作为数据帧:
df = read_csv_from_bucket(bucket_target,file_target)
df.head()
现在，您已经有了一台连接到存储云的高性能笔记本电脑，可以用于您的数据科学项目了！
尽情享受吧！😃
如何从 EC2 实例运行 Spark 应用程序
为什么你会这样做，而不是使用电子病历？好吧，问得好。在某些情况下，使用 EC2 可能比使用 EMR 更便宜，但在其他情况下，EMR 可能是可取的。无论如何，下面是如何从 EC2 实例运行 Spark 应用程序:
Photo by Steve Richey on Unsplash
我使用了一个深度学习 AMI (Ubuntu 16.04)版本 25.3，带有一个 p3 实例，用于加速计算。
SSH 到您的 EC2 实例。
ssh -i pem_key.pem ubuntu@public_dns_key
从一开始，你就安装了一些东西。
您在 EC2 终端中键入:
java -version
它返回:
openjdk version “1.8.0_222”OpenJDK Runtime Environment (build 1.8.0_222–8u222-b10–1ubuntu1~16.04.1-b10)OpenJDK 64-Bit Server VM (build 25.222-b10, mixed mode)
Java 8 是我们希望 Spark 运行的，所以这很好。
我的应用程序是使用 python 编写的，所以我想检查它是否已安装。
python --version
它返回:
Python 3.6.6 :: Anaconda, Inc.
太好了！
现在你需要安装 Hadoop。
我使用了以下准则:
https://data wookie . netlify . com/blog/2017/07/installing-Hadoop-on-Ubuntu/
- 去 Spark 下载网站看看它用的是哪个版本的 Hadoop:
It uses Hadoop 2.7, as of November 2019, this may be different for you.
2.它使用 Hadoop 2.7。好了，现在转到 Hadoop 镜像站点并使用 wget
- 右键单击，将链接复制到 Hadoop-2.7.7.tar.gz
- 输入你的 ubuntu 终端(粘贴你刚刚复制的，我加粗是为了让你知道你的可能不一样):
wget [**http://apache.mirrors.ionfish.org/hadoop/common/hadoop-2.7.7/hadoop-2.7.7.tar.gz**](http://apache.mirrors.ionfish.org/hadoop/common/hadoop-2.7.7/hadoop-2.7.7.tar.gz)
3.打开压缩的内容
tar -xvf hadoop-2.7.7.tar.gz
4.找到 java 的位置
type -p javac|xargs readlink -f|xargs dirname|xargs dirname
它返回:
/usr/lib/jvm/java-8-openjdk-amd64
好的，复制你的输出^
5.好了，现在编辑 Hadoop 配置文件，这样它就可以与 java 交互了
vi hadoop-2.7.7/etc/hadoop/hadoop-env.sh
键入i通过粘贴您复制的输出来插入和更新 JAVA_HOME 变量
要退出 vim，使用 ESC + :wq！(wq 代表 write 和 quit，解释点就是强制)
6.设置 HADOOP_HOME 和 JAVA_HOME 环境变量。JAVA _ HOME 环境变量指向计算机上安装 JAVA 运行时环境(JRE)的目录。目的是指向 Java 安装的位置。
您可以通过使用
export JAVA_HOME=/usr/lib/jvm/java-8-openjdk-amd64export HADOOP_HOME=/home/ubuntu/hadoop-2.7.7
并更新您的路径:
export PATH=$PATH:$HADOOP_HOME/bin/
但是如果关闭 EC2 实例，这可能无法保存。所以我使用 vim 并把这些导出添加到我的。bashrc 文件。
不及物动词 bashrc，I 表示插入，然后:wq 表示完成。
PS:这是你如何删除路径中的副本，你不需要这样做，它们不会伤害任何东西，但如果你想知道:
if [ -n "$PATH" ]; then
old_PATH=$PATH:; PATH=
while [ -n "$old_PATH" ]; do
x=${old_PATH%%:*} # the first remaining entry
case $PATH: in
*:"$x":*) ;; # already there
*) PATH=$PATH:$x;; # not there yet
esac
old_PATH=${old_PATH#*:}
done
PATH=${PATH#:}
unset old_PATH x
fi
来源:https://UNIX . stack exchange . com/questions/40749/remove-duplicate-path-entries-with-awk-command
7.找到你的。bashrc 文件，在您的主目录中键入source .bashrc
8.现在要检查版本，您可以回到您的主目录并键入
hadoop 版本，它应该会告诉您
9.您可以从您的主目录中删除压缩的 tar 文件:rm hadoop-2.7.7.tar.gz
现在你需要安装 Spark。我遵循这些准则:
https://data wookie . netlify . com/blog/2017/07/installing-spark-on-Ubuntu/
1.转到该站点并复制第一个镜像站点的链接地址
2.在你的 ubuntu 终端中输入 wget 并粘贴复制的链接
wget [http://mirrors.sonic.net/apache/spark/spark-2.4.4/spark-2.4.4-bin-hadoop2.7.tgz](http://mirrors.sonic.net/apache/spark/spark-2.4.4/spark-2.4.4-bin-hadoop2.7.tgz)
3.现在解压压缩的 tar 文件
tar -xvf spark-2.4.4-bin-hadoop2.7.tgz
4.给你的环境变量添加火花export SPARK_HOME=/home/ubuntu/spark-2.4.4-bin-hadoop2.7
5.安装 scala。为什么我们在这里用简单的方法？因为我们不需要查看 jar 文件或任何东西。
sudo apt install scala
现在你必须确保 Spark、Hadoop 和 Java 能够协同工作。在我们的情况下，这也包括能够从 S3 读和写。
a.导航到 EC2 终端中的文件夹~/spark-2.4.4-bin-hadoop2.7/conf
运行代码:
touch spark_defaults.confvi spark_defaults.conf
在这里，您需要添加下面几行:
如果 2FA 适用于您:确保您的访问密钥和秘密密钥是用于服务帐户的(不与用户名/密码相关联)
spark.hadoop.fs.s3a.access.key ***your_access_key***spark.hadoop.fs.s3a.secret.key ***your_secret_key***spark.hadoop.fs.s3a.impl org.apache.hadoop.fs.s3a.S3AFileSystemspark.driver.extraClassPath /home/ubuntu/spark-2.4.4-bin-hadoop2.7/jars/**hadoop-aws-2.7.3**.**jar**:/home/ubuntu/spark-2.4.4-bin-hadoop2.7/jars/**aws-java-sdk-1.7.4.jar**
b.如何确保这些 jar 文件是正确的呢？？我把它们加粗是因为它们对你来说可能不一样。所以要检查，去你的 Hadoop jars。
使用 cd 转到以下文件夹:cd ~/hadoop-2.7.7/share/hadoop/tools/lib并检查哪些罐子用于aws-java-sdk和hadoop-aws，确保这些。jar 文件与您刚刚放入spark_defaults.conf的内容相匹配。
c.将这些文件复制到 spark jars 文件夹:
为了让下面的代码工作，请放在~/hadoop-2.7.7/share/hadoop/tools/lib文件夹中
cp **hadoop-aws-2.7.3.jar** ~/spark-2.4.4-bin-hadoop2.7/jars/cp **aws-java-sdk-1.7.4.jar** ~/spark-2.4.4-bin-hadoop2.7/jars/
配置 Hadoop
a.让你的每个工作节点都可以访问 S3(因为我们的代码从 S3 读写)
https://github.com/CoorpAcademy/docker-pyspark/issues/13
编辑文件hadoop-2.7.7/etc/hadoop/core-site.xml以包含以下行:
<configuration>
<property>
<name>fs.s3.awsAccessKeyId</name>
<value>*****</value>
</property><property>
<name>fs.s3.awsSecretAccessKey</name>
<value>*****</value>
</property>
</configuration>
b.将下面的 jar 文件复制到hadoop-2.7.7/share/hadoop/common/lib目录
sudo cp hadoop-2.7.7/share/hadoop/tools/lib/aws-java-sdk-1.7.4.jar hadoop-2.7.7/share/hadoop/common/lib/sudo cp hadoop-2.7.7/share/hadoop/tools/lib/hadoop-aws-2.7.5.jar Hadoop-2.7.7/share/hadoop/common/lib/
好了，现在您已经准备好克隆您的存储库了
git 克隆路径/到/your/repo.git
确保将下面一行添加到您的。bashrc 文件:
export PYTHONPATH=$PYTHONPATH:/home/ubuntu/repo
PYTHONPATH 是一个环境变量，您可以设置它来添加额外的目录，python 将在这些目录中查找模块和包。对于大多数安装，您不应该设置这些变量，因为 Python 运行不需要它们。Python 知道在哪里可以找到它的标准库。
设置 PYTHONPATH 的唯一原因是维护您不想安装在全局默认位置(即 site-packages 目录)的自定义 Python 库的目录。
来源:https://www . tutorialspoint . com/What-is-Python path-environment-variable-in-Python
现在运行您的代码！
快乐火花！
有关在 EC2 中使用 Spark 的更多信息
查看 Snipe.gg 的博客:
[## 在 AWS 上运行 Apache Spark，而不会让银行破产
在 Snipe，我们处理大量的数据。考虑到有超过 1 亿的活跃联盟…
medium.com](https://medium.com/snipe-gg/running-apache-spark-on-aws-without-busting-the-bank-5566dad18ea3)
在他们的案例中，他们发现
[……]在检查了 EMR 定价后，我们发现 EMR 在其使用的 EC2 实例的价格上增加了高达 25% 的定价开销
这个博客也很好地突出了工具和生产我刚刚概述的努力的考虑。
如何在云中运行 Jupyter 笔记本
专注于数据科学而不是开发运维
介绍
开始从事数据科学时，DevOps 任务是您应该担心的最后一件事。试图掌握数据科学的所有(或大部分)方面需要大量的时间和实践。然而，如果你碰巧参加了新兵训练营或其他类型的学校，很可能你迟早要完成小组项目。然而，在没有任何 DevOps 知识的情况下协调这些可能是一个相当大的挑战。我们如何共享代码？我们如何处理非常昂贵的计算？我们如何确保每个人都在使用相同的环境？诸如此类的问题很容易阻碍任何数据科学项目的进展。
对于熟悉 GitHub 和云计算的人来说，这些问题可能非常直接。尽管如此，根据我参加纽约市数据科学学院为期 12 周的训练营的个人经验，这些问题与试图处理极其昂贵的计算或在小组中工作的数据科学新手非常相关。虽然人们确实可以使用 AWS、Azure、GCP(谷歌云平台)或任何其他云服务提供商来解决这些问题，但同时掌握数据科学和云计算是一项不必要的困难任务。为什么不使用熟悉的带有扩展的工具呢？
云端的 Jupyter 笔记本
Jupyter 笔记本在数据科学领域非常受欢迎，这是理所当然的。它们为用户提供了简洁的界面，并且易于使用。基本上，他们让用户专注于他们想做的事情:写一些代码并立即执行。然而，也有局限性。首先，Jupyter 笔记本运行在你的本地机器上，使你的计算能力完全依赖于你的计算机的 CPU/GPU/RAM/等。规格。虽然大多数笔记本电脑对于一个人在开始从事数据科学时遇到的基本任务来说绰绰有余，但一旦你开始在本地机器上进行机器学习，特别是深度学习，你可能会很快遇到障碍。此外，当进行团队项目时，需要找到一种方法与队友共享 Jupyter 笔记本。虽然使用 GitHub 可以让你分享你的代码，但它需要你知道如何使用 GitHub，而且它不能让你仅仅分享一个链接，让你的队友能够看到和编辑你的工作。顺便提一下，GitHub 还要求你的所有队友记得将他们的最新版本提交给 GitHub，如果你以前从未从事过数据科学小组项目，这很容易被忘记。
因此，一个人要么需要知道如何与云服务提供商和 GitHub 合作，要么就会有延迟的团队项目和非常热门的笔记本电脑。
土星云
土星云允许你在云中快速旋转 Jupyter 笔记本，并根据你的需求进行缩放。基本上，它让你可以在 AWS、Azure 或 GCP 内部的虚拟机上运行你的 Jupyter 笔记本，而不需要你知道如何正确设置和使用这些服务。它还有几个非常好的特性，使它有别于其他产品，例如让您能够指定 conda 环境、requirements.txt 或 docker 映像，以便跨所有团队标准化环境。您还可以使用链接与公众或队友共享您的 Juypter 笔记本。这消除了理解如何使用 GitHub 进行基础数据科学项目的需要。如果您确实知道如何使用 GitHub，它仍然提供了一种快速方便的方法来测试和开发代码。因此，(有抱负的)数据科学家可以专注于数据科学，而不是开发运维，并以比其他方式更快的速度完成他们的项目。
除此之外，Saturn Cloud 使您只需点击一下鼠标就可以部署 Spark 或 Dask 集群。这简化了处理非常昂贵的计算的问题，只需点击一下鼠标就可以使用分布式计算。Saturn Cloud 还为您自动化了版本控制，避免了由于团队成员没有提交他们的最新版本而产生的潜在问题。
由于我个人更喜欢演示而不是描述，我将快速向您展示如何使用土星云旋转 Jupyter 笔记本。
Spinning up a Jupyter Notebook on Saturn Cloud
首先，命名您的笔记本电脑并定义您想要使用的 VM(虚拟机)。你需要做的就是指定磁盘空间和内存。如果你默认 10 分钟不使用它，Saturn Cloud 会自动终止你的虚拟机。但是，您可以将它更改为您喜欢的任何时间段。使用高级选项，您可以定义您希望您的团队使用的环境。点击 create 后，你云端的 Jupyter 笔记本就启动了。
一旦启动并运行，您将看到以下内容:
通过点击“转到 Jupyter 笔记本”，您可以在云端访问您的 Jupyter 笔记本并开始编码。对于大多数简单的任务，这基本上就是你需要做的全部。如果您想要使用更高级的选项，，例如部署 Spark/Dask 集群或使用 GPU 处理您的工作负载，您只需在现有的 Jupyter 笔记本电脑中点击上面的蓝色按钮，并按如下方式定制您的虚拟机即可:
Adding a GPU to your VM
为什么要为虚拟机添加 GPU(图形处理单元)？非常简单地说:把你想要训练的算法(比如一个神经网络)想象成一系列的数学计算。现在，有了 GPU，你基本上可以同时进行所有的计算，而有了 CPU，你可以一个接一个地进行计算。本质上，这就是为什么 GPU 是昂贵计算的更好选择，特别是在机器学习方面。
正如您所看到的，使用土星云可以非常直观地开始在云端使用 Jupyter 笔记本。一旦您的笔记本运行，您还可以轻松地从笔记本内部与公众或您的队友分享。为了证明这一点，我出版了一本笔记本，可视化纽约市的老鼠目击事件，您可以使用以下链接访问:
结论
当试图启动数据科学团队项目时，开发运维可能是一个真正的难题。托管带有土星云的 Jupyter 笔记本，同时还负责版本管理等工作，并能够根据需要扩展或缩小，这可以极大地简化您的生活。就个人而言，快速轻松地共享笔记本的能力确实很有帮助。然而，最重要的是，在开始任何项目之前，你应该仔细评估和确定你的需求。
如何在 3 分钟内免费在 AWS 上运行 RStudio
说到数据分析，我有理由从你的本地电脑转移到云端。最突出的是，您可以运行无限数量的机器，而不需要拥有或维护它们。此外，您可以在几分钟内随意缩放。如果您选择运行 t2.micro 服务器，在最初的 12 个月内，您可以每月免费运行 750 个小时！之后，每个月和服务器就要几美元。
好吧，让我们开始吧！可以理解的是，在点击了一个承诺在 3 分钟内为你提供解决方案的标题后，你将没有时间去阅读一篇十分钟的关于 RStudio Sever 和 T2 亚马逊网络服务的文章。所以我跳过正式的介绍，直接切入正题。
**第一步:**登录你的 AWS 账户(如果你是 AWS 新手，也可以创建一个)
**第二步:**转到 Louis Aslett 的网站，选择您希望您的虚拟机驻留的地区，然后单击它旁边的链接(例如， ami-02bf650155c44b475 代表美国西部，N. California)。该链接将直接引导您到 EC2 管理控制台。
步骤 3: 单击启动实例向导。几乎所有的东西都已经预先填写好了，你的屏幕应该看起来像下面的截图。先不要按“查看并启动”。为了确保万无一失，我们需要检查一遍整个过程，所以请按“下一步:……”。
Nothing to change here. Press Next: Configure Instance Details.
Nothing to change here. Press Next: Add Storage.
Nothing to change here. Press Next: Add Tags.
Nothing to change here. Press Next: Configure Security Group
啊哈！这里你需要再次活跃起来。点击“添加规则”，选择 HTTP 并将“源”从自定义改为任意位置。现在它应该看起来像下面的截图。
你快完成了！只需按下下一页的“查看并启动”和“启动”。最后一步是选择 SSH 安全密钥。虽然这不是最安全的设置，但最快的是选择不带钥匙继续。只需复制下一个截图中的设置，然后按“启动实例”
现在，亚马逊将完成剩下的工作。
不幸的是，这可能需要 5 分钟…
但是嘿！那不是我的错，对吗？请不要因为我在题目中的虚假承诺而生气。一个小小的点击诱饵不会伤害任何人……给我写封电子邮件，告诉我我是如何滥用你的信任，以及谷歌和脸书的算法是如何支持这种新闻报道方式的。我向你保证:一旦你写完第一段，你的服务器就启动并运行了！😃
JK，实际上只需要一分钟。
Server still pending…
… and this is how it looks like once everything is done.
如果你的主机长得像上面的截图:恭喜你！您现在是 RStudio 服务器的所有者。
只需复制“IPv4 公共 IP”(这里:54.193.0.253)，并在一个新的标签中打开它。RStudio 服务器要求您登录。您的初始用户名是“rstudio ”,密码是该服务器的“实例 ID ”(这里是:i-09784d4946595e752 ),也可以在 AWS 控制台中找到。
请击鼓……
搞定了。
现在，您可以复制想要在云中运行的脚本，或者编写一个新的脚本。RStudio 服务器的外观和操作与本地 RStudio 几乎完全相同。
那不是很容易吗？
好吧，该表扬就表扬。路易·阿斯莱特就是这个原因。他为虚拟机准备了模板，即所谓的 Amazon 机器映像(AMI ),它可以开箱即用地运行 RStudio 服务器(以及 my things more)。这些是您在步骤 2 中选择的。
如果你对我的逐步指导有困难，请访问他制作的视频。它不再是最新的了，但是有了这个指南，你将在几分钟内实现它！如果你有困难，可以写评论。现在开始用您的脚本填充您的 RStudio 服务器吧！
请务必关注我的媒体简介，获取有关 RStudio、数据科学和影响者欺诈的新帖子的更新。如果你想谈论我在市场营销方面的研究或数据科学，你可以在 LinkedIn 或 Twitter 联系我。
感谢阅读，
乔纳斯·施罗德
如何在数据科学团队中运行 Scrum
在数据项目中使用 scrum 框架时，关于团队结构、技能、交叉功能、产品待办事项、冲刺长度、困难和好处的实践经验技巧。
后续——不要错过我即将发表的文章，其中包含一个案例研究的产品 backlog 项目，它展示了如何将 pbi 分成更小的部分并创建垂直切片。
我在一个敏捷团队中工作，该团队由 7 个团队和 58 个人组成，旨在为银行的现有产品提供人工智能功能。其中一个团队是架构团队，其他的是交付团队。
商业案例示例
它可以是任何数据科学案例，如客户流失预测、客户风险计算、信用评分、人脸识别、情绪检测、欺诈检测、预防性维护等
团队结构
Scrum 团队需要包括 3 到 9 名成员。我建议团队的最佳人数是 5 人，包括产品负责人。
有 4 个重要问题需要考虑:
问题 1:团队应该具备哪些技能？
这个列表可能会更长，我已经指出了最关键的技能:
- 分析以理解领域和需求
- 从不同来源收集必要数据的数据传输
- 数据预处理以创建模型所需的特征
- 可视化，从数据中获得洞察力，并与业务部门交流
- 建模以创建预测模型
- 建立数据管道，实现完全自动化的现场体验
- API 或 web 服务开发来打开预测服务
- 测试上线后的“平静生活”。
- 仪表板开发，以技术和商业方式监控生产寿命。
问题-2:对于一个由 5 个人组成的团队来说，拥有所有这些技能可能吗？
不容易，但有可能。团队成员是跨职能的(产品负责人除外)。这并不意味着所有的团队成员都必须是所有这些领域的专家，但是他们应该在一两个领域是合格的。这就是 T 型人的确切定义。
我的观察告诉我，这个交叉功能的最佳候选人是具有软件开发背景的人。
问题 3:这些技能有角色吗？
理想情况下，不应该有。事实上，作为一个拥有大量数据的新生部落，我们决定从角色开始。因此，我们分享了 4 个不同的角色:
- 数据翻译:调整团队和业务方面，分析领域
- 数据科学家:建模
- 数据工程师:数据处理
- 数据架构:为其他团队的基础设施需求服务
问题-4:为什么 5 人是最佳团队规模？
不是规则，而是基于最佳实践的理论:
- 团队可以挤在一辆车里，一起参加活动:)
- 当团队规模越来越大时，scrum 仪式变得越来越低效，越来越耗时，这对团队的整体效率产生了负面影响。
- 团队可能倾向于创建更小的团队来一起工作，这导致了知识转移和同步问题。
产品待办事项 &在 Sprint 评审中呈现什么？
对于一个典型的软件开发团队来说，答案非常简单:产品 backlog 项目通常是用户故事，团队总是展示一个工作软件(即使 PBI 是一个错误，而不是用户故事)。
然而，数据科学团队的答案更复杂。以下是产品待办事项类别以及每种类别的展示内容:
- 数据洞察:这类产品 backlog 项目的主要焦点是理解现有的数据和结构。输出通常是图表或表格。在最初的冲刺阶段，有更多的洞察型输出。如果客户流失是一个项目，那么“流失率与时间”线图或“根据客户年龄组的流失率”条形图就是很好的例子。
- 模型结果:这对于团队和涉众来说都是最有吸引力的类别。您处理预测模型，并在 sprint 评审中展示它们的结果，一起讨论它们。一般来说，我们会集体思考模型的准确性和稳健性，模型在哪些领域表现最佳，在哪些领域表现不佳。当然，3 到 6 个月后工作的可能结果也包括在议程中。对于这种类型的 PBI，与业务部门的额外会议可能是必要的，因为讨论可能比预期花费更多的时间。
- 仪表板:它是最接近工作软件原则的产品积压类别。团队创建一个仪表板，并在评审中将其显示为工作仪表板。在模型的成熟度达到一定水平之后，团队可以处理这种类型的待定项。
- API 开发:如果模型将作为服务开放，则需要进行服务开发。当团队完成此 PBI 时，他们会展示几张幻灯片，其中包括与现有软件的集成架构、API 的响应字段、现有软件将如何使用它获得的这些响应、API 对现有结构的非功能性影响(例如响应时间)。
- ETL 开发:如果模型结果将被批量使用，就需要 ETL 开发。当团队完成此 PBI 时，他们会展示几张幻灯片，其中包括与现有软件的集成架构、文件中传输的字段、现有软件如何使用它获得的字段、如何安排此文件传输。
- 法规项目:处理数据的团队应了解 GDPR(一般数据保护法规)，这些法规可能因国家/地区而异。专门处理客户数据的数据科学团队可能需要准备一些文档并获得一些批准。这个 PBI 是为了所有这些作品的努力。
- 监控和推广:应该监控人工智能模型在生产中的表现。A/B 测试是最好的方法之一。结果可能比预期的更糟，可能需要进行一些修改。应制定并遵循推广战略。
产品待定项必须是什么样的？如何创建薄的垂直切片并分解它们？—不要错过我的下一篇文章，我将为您提供关于这些主题的更多细节和示例。
冲刺长度
冲刺长度可以在 1 周到 4 周之间。我相信 1 周对于软件开发团队来说是完美的，但是对于数据科学团队来说太短了。由于数据传输和预处理任务可能需要几天时间，并且准备好的数据本身并不是要呈现的输出，团队必须对其进行更多的工作以产生一些输出。
我们已经开始了为期一周的冲刺，但团队不得不在每个冲刺阶段都加班加点，毫无例外地出现了精疲力竭的信号。然后团队决定将冲刺长度改为 2 周。
以下是经过两周冲刺后观察到的结果。
- 快乐团队
- 产出质量提高
- 利益攸关方对产出更加满意
- 团队速度增加！！！1 周冲刺的平均速度约为 35，2 周冲刺的平均速度变为 85(平均速度在最少 5 次冲刺后计算)。
困难
让我们接受它——scrum 是一种很好的工作方式。尽管如此，在所有团队成员都习惯了它的方法之前，请为一些挑战做好准备，比如:
- 那些习惯于处理详细项目计划的人开始批评 scrum 缺乏远见。他们掌握 scrum“路线图”哲学需要时间。
- 喜欢独自工作的人开始抱怨花费在仪式和交流上的时间。他们相信如果不被打扰，他们的生产力会提高。
- 学习为数据科学项目创建薄的垂直产品 backlog 项目的艺术需要时间。
- 对于软件开发来说，编写和声明 done 的定义很容易。设置最小测试覆盖率或者把完成用户验收测试作为一个必须的例子。此外，您可以将其应用于您的所有 pbi。另一方面，对于数据科学敏捷团队来说，这些任务更具挑战性。由于所涉方案预算多种多样，几乎不可能为所有项目找到一个共同的完成定义。此外，即使对于一些 PBI 类型，比如迭代试错模型，找到 done 的定义也是很痛苦的。
- 编写验收标准也比软件开发案例更复杂。PBI 数据洞察类型的验收标准是什么？团队只是探索数据和领域，然后将可视化带到评审会议上进行讨论。“应该对数据进行可视化”并不是验收标准的一个好例子，对吗？
好处
尽管存在上述所有困难，但还是有很多好处:
- 团队精神建立起来了，工作变成了一项有趣的活动。
- 自我组织能力提高。团队在回顾会议中解决了大部分问题。
- 应用 scrum 让团队保持一致。每个团队成员都知道产品的远景和路线图。
- 在几次冲刺之后，团队速度变得确定，可预测性出现了。
总之
在这篇文章中，我试图分享我自己关于在数据项目中使用 scrum 框架的想法。请注意，条件和规则可能因团队和案例的不同而不同。这使得 scrum 令人兴奋，不是吗？
如果你有任何进一步的问题，请不要犹豫，写信给:haydarozler@gmail.com。
如何对 PDF 文件运行 SQL
pdf 是今天分发和共享固定布局文档的事实标准。对我的笔记本电脑文件夹的快速调查显示，账户报表、收据、技术论文、书籍章节和演示幻灯片都是 pdf 格式的。许多有价值的信息都可以在各种 PDF 文件中找到。这也是 Rockset 支持对 PDF 文件进行 SQL 查询的重要原因，我们的使命是让数据对每个人都更有用。
Rockset 中 pdf 上的快速 SQL
Rockset 使开发人员和数据从业者可以轻松地在各种数据格式的半结构化数据上接收和运行快速 SQL，如 JSON、CSV 和 XLSX，而无需任何前期数据准备。现在将 PDF 添加到混合数据中，用户可以将 PDF 数据与来自不同来源的其他格式的数据组合到他们的 SQL 分析中。或者一起分析多个 pdf 也可能是有价值的，如果你像我一样有一系列的电费账单，我们将在下面的简短例子中看到。
上传 pdf 文件
从现有的集合中，点击控制台右上角的上传文件按钮，并指定 PDF 格式以摄取到 Rockset 中。
查询 pdf 中的数据
我上传了 9 个月的电费。我们可以使用 DESCRIBE 命令来查看从 pdf 中提取的字段。
> describe "elec-bills";
+--------------------------------------------+---------------+---------+-----------+
| field | occurrences | total | type |
|--------------------------------------------+---------------+---------+-----------|
| ['Author'] | 9 | 9 | string |
| ['CreationDate'] | 9 | 9 | string |
| ['Creator'] | 9 | 9 | string |
| ['ModDate'] | 9 | 9 | string |
| ['Producer'] | 9 | 9 | string |
| ['Subject'] | 9 | 9 | string |
| ['Title'] | 9 | 9 | string |
| ['_event_time'] | 9 | 9 | timestamp |
| ['_id'] | 9 | 9 | string |
| ['_meta'] | 9 | 9 | object |
| ['_meta', 'file_upload'] | 9 | 9 | object |
| ['_meta', 'file_upload', 'file'] | 9 | 9 | string |
| ['_meta', 'file_upload', 'file_upload_id'] | 9 | 9 | string |
| ['_meta', 'file_upload', 'upload_time'] | 9 | 9 | string |
| ['author'] | 9 | 9 | string |
| ['creation_date'] | 9 | 9 | int |
| ['creator'] | 9 | 9 | string |
| ['modification_date'] | 9 | 9 | int |
| ['producer'] | 9 | 9 | string |
| ['subject'] | 9 | 9 | string |
| ['text'] | 9 | 9 | string |
| ['title'] | 9 | 9 | string |
+--------------------------------------------+---------------+---------+-----------+
Rockset 解析出所有元数据，如author、creation_date等。从文档中随同text。
text字段通常是 PDF 中大多数信息所在的地方，所以让我们检查一下示例text字段中有什么。
+--------------------------------------------------------------+
| text |
|--------------------------------------------------------------|
| .... |
| .... |
| Statement Date: 10/11/2018 |
| Your Account Summary |
| .... |
| Total Amount Due: |
| $157.57 |
| Amount Enclosed: |
| ... |
+--------------------------------------------------------------+
合并来自多个 pdf 的数据
在 Rockset 中获取并索引了我 9 个月的电费账单后，我可以对这段时间内的使用情况做一些简单的分析。我们可以运行 SQL 查询来选择text中的月/年和账单金额。
> with details as (
select tokenize(REGEXP_EXTRACT(text, 'Statement Date: .*'))[3] as month,
tokenize(REGEXP_EXTRACT(text, 'Statement Date: .*'))[5] as year,
cast(tokenize(REGEXP_EXTRACT(text, 'Total Amount Due:\n.*\nAmount Enclosed'))[4] as float) as amount
from "elec-bills"
)
select concat(month, '/', year) as billing_period, amount
from details
order by year asc, month;
+----------+------------------+
| amount | billing_period |
|----------+------------------|
| 47.55 | 04/2018 |
| 76.5 | 05/2018 |
| 52.28 | 06/2018 |
| 50.58 | 07/2018 |
| 47.62 | 08/2018 |
| 39.7 | 09/2018 |
| <null> | 10/2018 |
| 72.93 | 11/2018 |
| 157.57 | 12/2018 |
+----------+------------------+
并将结果绘制在超集中。
我 10 月份的账单出人意料地为零。账单金额提取不正确吗？我回去查了一下，结果是我在 10 月份收到了一份加州气候信用，这使我的账单归零了，所以摄取和查询 pdf 就像它应该的那样工作了！
最初发表于【rockset.com】。
如何从语言模型中取样
标准抽样技术与新核心抽样的探讨
Humans often choose words that surprise language models (Holtzman et al 2019)
像 GPT-2 这样的因果语言模型被训练来预测给定一些上下文下一个单词的概率。例如，给定“我吃了一个美味的热 __ ”,模型可能以 80%的概率预测“狗”，以 5%的概率预测“煎饼”，等等。这个结构很酷的一点是，它们可以用来生成任意长度的序列。我可以给这个模型一个“我吃了”，从结果分布中抽取一个令牌来得到“我吃了一个”，然后再次通过这个模型来得到另一个分布和结果令牌。我们想重复多久就重复多久。事实证明，这一代人经常要么陷入重复的循环，要么忘记主题，跑题。为什么会发生这种情况，我们如何更好地采样以生成更像人类的文本？
本帖是霍尔茨曼等人 2019 对神经文本德代的好奇案例的总结和探索。我发现这是我近年来读过的最透彻、可读性最强的论文之一，所以如果这篇文章引起了你的兴趣，请看看吧！
如果我们总是对最可能的单词进行采样，标准的语言模型训练目标会导致我们陷入像“我不知道”这样的循环中。我不知道。我不知道。”这是不自然的，但现代语言模型中模型的大部分注意力只在最近的几个标记上。相反，流行的生成抽样方法是基于分布的抽样。但是采样也遇到了一个问题:如果我们有 50K 个可能的选择，即使底部的 25K 个记号每个都极不可能，它们总共可能有例如 30%的概率质量。这意味着每一个样本，我们都有 1/3 的机会完全偏离我们的“思路”由于前面提到的短上下文，这将导致不可恢复的错误级联，因为每个下一个单词都严重依赖于这个最近的错误单词。
为了防止尾部取样，最常用的方法是温度和顶部 k 取样。
温度 采样受统计热力学启发，高温意味着更可能遇到低能态。在概率模型中，对数起着能量的作用，我们可以通过将对数除以温度来实现温度采样，然后将其输入 softmax 并获得采样概率。例如:
>>> import torch>>> import torch.nn.functional as F>>> a = torch.tensor([1,2,3,4.])>>> F.softmax(a, dim=0)tensor([0.0321, 0.0871, 0.2369, 0.6439])>>> F.softmax(a/.5, dim=0)tensor([0.0021, 0.0158, 0.1171, 0.8650])>>> F.softmax(a/1.5, dim=0)tensor([0.0708, 0.1378, 0.2685, 0.5229])>>> F.softmax(a/1e-6, dim=0)tensor([0., 0., 0., 1.])
或者视觉上
较低的温度使模型对其首选越来越有信心，而高于 1 的温度会降低信心。0 温度相当于 argmax/max 似然，而无限温度对应于均匀采样。
Top k 采样是指按概率排序，将第 k 个令牌以下的概率归零。它似乎通过去除尾部来提高质量，使其不太可能偏离主题。但是在某些情况下，真的有很多词我们可以合理地从中取样(下面的广泛分布)，而在某些情况下没有(下面的狭窄分布)。
Holtzman et al 2019
为了解决这个问题，作者提出了 top p 采样，也称为核采样，其中我们计算累积分布，并在 CDF 超过 p 时立即截止。在上面的广义分布示例中，可能需要前 100 个令牌才能超过 top_p = .9。在窄分布中，我们可能已经超过了 top_p = .9，在我们的样本分布中只有“热”和“暖”。通过这种方式，我们仍然避免了对极其错误的记号进行采样，但是当最高得分的记号具有低置信度时，保持了多样性。
为什么最大似然抽样不起作用？在培训过程中，永远没有机会看到复合错误。该模型被训练成基于人类生成的上下文来预测下一个令牌。如果它通过生成一个坏的分布而得到一个错误的标记，下一个标记将使用“正确的”人类生成的上下文，而与上一个预测无关。在生成过程中，它被迫完成自己自动生成的上下文，这是它在训练过程中没有考虑的设置。
定性结果
以下是使用 top_k=40 和上下文“我吃了一个美味”的示例
这里是使用 top_p=0.9 和相同“我吃了美味”上下文的示例:
自己试试这里！您可以在运行时>启用 GPU，更改运行时类型，无需额外运行时即可获得大批量数据。
超越纸张:自动选择 p 和 k
我发现很难确定这些样本中哪一个更像人类。为此，我设计了一个实验来根据经验确定top_k和top_p。
我们的目标是使用 top_k 和 top_p 来最大化选择我们给出的实际下一个单词的概率。当搜索最佳 k 和 p 值时，实际上很容易通过分析确定给定样本。对于 k，我们找到“黄金”令牌出现的排序索引。对于 p，我们找到黄金令牌的 CDF。例如，如果上下文是“我吃了一份美味的热食”,实际单词是“狗”,但模型的预测分布最有可能是“煎饼”,我们将向下搜索概率，直到在索引 3 处找到“狗”。在指数 1 时，CDF 可能是 62%。在指数 3 处，CDF 可能是 86%左右，所以我们把它记为最优 p。
在许多例子中，我们可以计算最佳 p 和 k 值的直方图，并计算它们的汇总统计数据。我在维基百科的一个随机部分进行了测试，其上下文长度为 15。这比模型被训练的时间(1024)要短得多，但是对于像 https://duet.li 或聊天机器人这样的设置是常见的。
===== ks =====max 29094.00mean 233.69median 3.00len 13376.00===== ps =====max 1.00mean 0.59median 0.60len 13376.00
你可以在我的 colab 笔记本里自己尝试一下。
如果对模型的训练集进行评估，则选择 top_k = 1 是最佳选择。但是由于模型稍微超出了范围，最有可能的标记有时会出现在列表的底部。此外，我们还有一个 50K 的令牌词汇表。在许多数据集中，我们永远不会看到所有的令牌，但模型对此并不确定。通过使用 top_p 或 top_k 将大部分概率质量归零，我们合并了我们的先验以从不选择这些从未在训练中见过的令牌。
也就是说，这种对 k 和 p 的寻找仍然是在模型的世界观的背景下，因此这只是一个创可贴。我们真正想要的是修正训练。
固定训练
我也开始考虑改变培训目标，以更好地匹配生成任务。例如，当模型生成看起来不像人类的整个序列时，我们可以训练某种鉴别器来惩罚它吗？如何将 GAN 架构应用于非连续域并不简单。我发现了没有强化学习的对抗性文本生成和一个基于 RL 的想法，但似乎这些还没有成为主流。我认为将这些想法应用到过去几个月席卷艺术领域的大型变形金刚上会很有趣。
感谢 雅罗斯拉夫布拉托夫 的反馈和编辑
如何通过一个文件保存和共享您的机器学习模型(以及更多)
Photo by Jonathan Pielmayer
忘记模块导入。只需一行代码，您就可以在一个 Python 文件中存储和分发经过训练的 ML 模型等。
在处理机器学习模型时，通常建议您将它们存储在某个地方。在私营部门，您经常在生产前培训和存储它们，而在研究和未来的模型调整中，在本地存储它们是一个好主意。我总是使用令人惊讶的 Python 模块 pickle 来做这件事。
我最近发现了一个有用的窍门。您不仅可以存储模型，还可以将整个函数和变量都存储在同一个文件中！当你想和其他人分享你的模型，但是你知道那个人不一定安装了所有需要的模块/功能，或者只是不具备这样做的专业知识时，这就特别方便了。他们只是想在一台具有基本 Python 环境的计算机上运行该算法以查看结果。
我将在这里向你展示如何做这个简单的把戏。
假设在您的本地计算机中，为了进行分类分析，您首先加载这些 sklearn 和 numpy 模块:
from sklearn.metrics import accuracy_score, f1_score
from sklearn import svm
from numpy import average
稍后用交叉验证测试模型的准确性。最后，在验证完模型的准确性之后，用一些数据拟合最终模型:
sv_t = svm.SVC()
sv_t.fit(Features,Classes)
现在到了有趣但相当简单的部分。您可以将经过训练的模型以及任何功能/模块存储到一个 pickle 中，以便以后在其他地方分发！
Free to use and part of the public domain Pickle drawing taken from here. Image generated with Inkscape
这样你就可以将训练好的模型sv_t加上例如 numpy 的average函数和 sklearn 模块的f1_score函数保存在一个文件中。为此，您只需:
import pickle
pickle.dump([sv_t,average,f1_score], open('complete_ml.pkl', 'wb' ))
就是这样！下次您(或其他人)从任何计算机加载 pickle 文件 complete_ml.pkl 时:
sv_t,average,f1_score = pickle.load(open('complete_ml.pkl','rb'))
您将可以访问存储的训练模型以及您想要打包在一起以供将来分发的任何函数和变量。为什么要这样做？嗯，正如我在乞求中所说的，很多时候你想要共享、部署和分发你的 ML 管道到其他计算机，这些计算机可能没有预装所有需要的模块。有了这个技巧，唯一需要的模块就是 Pickle，它是 Python 的标准库的一部分。
希望这个简单的指南对你的 ML 之旅有所帮助，它让我的 ML 之旅与众不同。
感谢您的阅读！
如何在多个 GPU 上扩展训练
如何在多个 GPU 中训练 PyTorch 模型
深度学习模型的最大问题之一是，它们变得太大，无法在单个 GPU 中训练。如果在单个 GPU 中训练当前的模型，它们将花费太长时间。为了及时地训练模型，有必要用多个 GPU 来训练它们。
我们需要来缩放训练方法，以使用 100 个甚至 1000 个 GPU。例如，一位著名研究员能够将 ImageNet 的训练时间从 2 周减少到 18 分钟，或者在 2 周内训练出最大和最先进的 Transformer-XL，而不是 4 年。他使用了 100 个 GPU 来完成这个任务。
我们非常关心我们的训练迭代速度。因此，为了提高我们的迭代速度，我们必须将我们的训练扩展到多个 GPU。在这篇博文中，我将介绍如何用 PyTorch 扩大训练规模。我们已经在 TensorFlow ( <2.0) and scaled our training, using Horovod )中有了一些模型，这是优步工程团队开发的一个工具。如果你走这条路，我们建议使用他们的 Docker 镜像来安装它。
我们发现 PyTorch 在易用性和控制性之间取得了最好的平衡，同时又不牺牲性能。PyTorch 构建了两种方法来在多个 GPU 中实现分布式训练:nn.DataParalllel和nn.DistributedParalllel。它们是包装和更改代码以及在多个 GPU 中增加训练网络的能力的简单方法。
nn.DataParallel更容易使用，但要求只能在一台机器上使用。nn.DataParalllel仅使用一个进程来计算模型权重，并在每批中将其分配给每个 GPU。
在这篇博文中，我将详细介绍nn.DataParallel和nn.DistributedDataParalllel是如何工作的。我将介绍两者之间的主要区别，以及在多个 GPU 中进行训练的工作原理。我将首先解释训练神经网络是如何工作的。
训练循环
首先，让我们回顾一下训练神经网络通常是如何工作的。为此，我们将使用由 HuggingFace 创建的一些图像:
训练神经网络时，每个循环都有四个主要步骤:
- 正向传递，由神经网络处理输入
- 计算损失函数，比较预测标签和地面实况标签
- 进行反向传递，根据损耗计算每个参数的梯度(使用反向传播)
- 使用梯度更新参数
对于大于 1 的批量大小，我们可能希望批量规范化训练。关于批处理规范化的深入解释，我推荐阅读这篇博文:
目前在斯坦福大学有一门很棒的课程，叫做 CS231n -卷积神经…
kratzert.github.io](https://kratzert.github.io/2016/02/12/understanding-the-gradient-flow-through-the-batch-normalization-layer.html)
数据并行
DataParallel 有助于将训练分布到单台机器的多个 GPU 中。让我们详细了解一下 DataParallel 是如何工作的。每当使用数据并行训练神经网络时，都会发生几个步骤:
Image created by HuggingFace
- 小批量在 GPU 上拆分:0
- 将小批量分割并移动到所有不同的 GPU
- 将模型复制到 GPU
- 正向传递发生在所有不同的 GPU 中
- 计算与 GPU:0 上的网络输出相关的损耗，并将损耗返回给不同的 GPU。计算每个 GPU 上的梯度
- 对 GPU:0 上的梯度求和，并使用优化器更新 GPU:0 上的模型
简单的例子
让我们把这个编码起来。首先，让我们进口我们需要的一切
我们定义一个非常简单的卷积模型来预测 MNIST
第 4–14 行:我们正在定义这个神经网络的层次。
第 16–21 行:我们定义了向前传球
main()函数将接受一些参数并运行训练函数:
第 2–6 行:我们实例化模型并将其设置为在指定的 GPU 中运行，并通过使用DataParallel在多个 GPU 中并行运行我们的操作。
第 9–23 行:我们定义损失函数(标准)，和优化器(在这种情况下，我们使用 SGD)。我们定义了训练数据集(MNIST)和数据加载器。
第 24–45 行:这就是训练神经网络的循环发生的地方。我们加载输入和预期输出。我们运行向前传递和向后传递以及优化器。
这里肯定有一些额外的东西(例如，GPU 和节点的数量)我们还不需要，但将整个框架放在适当的位置是有帮助的。
分布式数据并行
为了 nn。’ DistributedDataParallel '，机器每个 GPU 有一个进程，每个模型由每个进程控制。GPU 可以都在同一个节点上，也可以跨多个节点。只有渐变在进程/GPU 之间传递。
在训练过程中，每个进程从磁盘加载自己的小批量，并将其传递给 GPU。每个 GPU 执行其正向传递，然后梯度在 GPU 之间全部降低。每层的梯度不依赖于先前的层，因此梯度 all-reduce 与向后传递同时计算，以进一步缓解网络瓶颈。在反向过程结束时，每个节点都有平均梯度，确保模型权重保持同步。
辅导的
为了用多重处理来做到这一点，我们需要一个脚本来为每个 GPU 启动一个进程。每个进程都需要知道使用哪个 GPU，以及它在所有正在运行的进程中的排名。我们需要在每个节点上运行脚本。
让我们来看看每个函数的变化。我已经把新代码隔离开来，以便于查找。
让我们回顾一下主函数的参数:
args.nodes是我们正在使用的节点总数(机器数量)。args.gpus是每个节点(每台机器上)的 GPU 数量。args.nr是当前节点(机器)在所有节点(机器)中的排名，从 0 到args.nodes- 1。
让我们一行一行地看看新的变化:
第 12 行:根据节点数和每个节点的 GPU 数，我们可以计算出world_size，或者要运行的进程总数，它等于 GPU 总数乘以节点数。
第 13 行:这告诉多处理模块为进程 0 寻找什么 IP 地址。它需要这样做，以便所有的进程可以同步开始。这需要在所有节点上保持一致。
第 14 行:同样，这是查找进程 0 时使用的端口。
第 15 行:现在，不再运行一次 train 函数，我们将产生args.gpus进程，每个进程运行train(i, args)，其中i从 0 到args.gpus - 1。记住，我们在每个节点上运行main()函数，这样总共会有args.nodes * args.gpus = args.world_size个进程。
我可以在终端中运行export MASTER_ADDR=10.57.23.164和export MASTER_PORT=8888，而不是第 13 和 14 行。
接下来，让我们看看对train的修改。我会再把新线路围起来。
我已经删除了一些代码，并用...代替，以使本教程更容易阅读，但如果你想要完整的脚本，这里是。
第 3 行:这是该流程在所有流程中的全局排名。我们将在第 6 行使用这个。
第 4–6 行:初始化流程并与其他流程连接。这是“阻塞”，意味着在所有进程都加入之前，没有进程会继续。我用的是NCCL，因为它是最快的…init_method告诉进程组在哪里寻找一些设置。在这种情况下，它在查看MASTER_ADDR和MASTER_PORT的环境变量，我们在main中设置了这些变量。这就是为什么我们把它设置为env://。我们可以在那里设置world_size和WORLD_SIZE.
第 23 行:将模型包装成一个[DistributedDataParallel](https://pytorch.org/docs/stable/nn.html#distributeddataparallel)模型。这将模型复制到每个 GPU 上。
第 35–39 行:[nn.utils.data.DistributedSampler](https://pytorch.org/docs/stable/_modules/torch/utils/data/distributed.html)确保每次加载数据时，每个进程都获得不同的训练数据片段。如果您想要调试并验证每个 GPU 都加载了正确的数据，您可以计算加载到每个 GPU 中的张量的 sha。
第 46 行和第 51 行:使用nn.utils.data.DistributedSampler而不是通常的洗牌方式。这就是为什么我们将 shuffle 设置为 false。
比方说，要在 4 个各有 8 个 GPU 的节点上运行，我们需要 4 个终端(每个节点一个)。在节点 0 上(由main中的第 13 行设置):
然后，在其他节点上:
对于 i∈1，2，3。换句话说，我们在每个节点上运行这个脚本，告诉它在训练开始之前启动彼此同步的args.gpus进程。
请注意，有效的 batch_size 现在是每 GPU batch_size(脚本中的值)* GPU 总数(全局大小)。
问题
当在几个 GPU 而不是一个 GPU 中运行同一模型时，可能会出现一些问题。可能出现的最大问题是主 GPU 可能会耗尽内存。这样做的原因是因为第一个 GPU 将为不同的 GPU 保存所有不同的输出以计算损失。
每当您训练网络时，以下信息将显示在控制台上:ran out of memory trying to allocate 2.59GiB
为了解决这个问题，并减少内存使用量，我们使用两种技术:
- 减少批量大小
- 将 Apex 用于混合精度
第一种技术非常简单，通常只需要改变一个超参数。
第二种技术意味着我们将降低神经网络中使用的权重的精度，因此使用更少的内存。混合精度意味着对某些事情使用 16 位，但对权重等事情保持 32 位。要了解更多关于混合精度的信息，我推荐阅读这篇博文:
[## 做深度学习的时候 FP16 和 FP32 有什么区别？
回答(第 1 题，共 3 题):这是一个适时的问题，因为我们上周五刚刚给 Horovod 添加了 FP16 支持。所以很自然，我…
www.quora.com](https://www.quora.com/What-is-the-difference-between-FP16-and-FP32-when-doing-deep-learning)
混合精度的顶点
为了解决内存不足的问题，我们建议使用较低精度的数字。这使我们能够使用更大的批量，并利用 NVIDIA Tensor 内核加快计算速度。
为了让 APEX 工作，我们需要更改代码的 2 个部分。第一个是在代码库中的train循环中:
训练步骤
第 18 行:[amp.initialize](https://nvidia.github.io/apex/amp.html#unified-api)包装混合精度训练的模型和优化器。注意，在调用amp.initialize之前，模型必须已经在正确的 GPU 上。opt_level从使用所有浮点的O0到使用半精度的O3。O1和O2是不同程度的混合精度，其细节可以在 Apex 文档中找到。
第 20 行:[apex.parallel.DistributedDataParallel](https://nvidia.github.io/apex/parallel.html)是nn.DistributedDataParallel的替代产品。我们不再需要指定 GPU，因为 Apex 只允许每个进程使用一个 GPU。它还假设脚本在将模型移动到 GPU 之前调用了torch.cuda.set_device(local_rank)(第 10 行)。
第 37–38 行:混合精度训练要求损失被缩放，以防止梯度下溢。Apex 会自动执行此操作。
确保无论何时初始化 AMP，你都设置了opt_level=O1，因为它的实现有一个错误
检查站
每当使用 Apex 时，我们需要改变我们保存和加载模型的方式，请参见下面的问题。我们需要改变保存检查点并将其加载到模型中的方式:
第 5 行:我们将amp.state_dict添加到检查点
第 19 行:我们在这里加载state_dict到 amp。
结论
有了所有这些，您应该能够开始在多个 GPU 中训练您的模型。我们建议在尝试将训练扩展到多个 GPU 之前，先在一个 GPU 中训练一个小模型。但是，如果有必要进行规模化训练，本教程可能会有所帮助。
链接和参考:
https://lambda labs . com/blog/introduction-multi-GPU-multi-node-distributed-training-nccl-2-0/
https://medium . com/south-park-commons/scaling-transformer-XL-to-128-GPU-85849508 EC 35
https://yang kky . github . io/2019/07/08/distributed-py torch-tutorial . html
正在下载 ImageNet…
结果是:
我写了一个软件工具，它使用 ImageNet API 提供的 URL 从 ImageNet 数据创建新的数据集。
你可以告诉这个工具:“我想要一个有 200 个类的数据集，每个类至少有 800 张图片”，它就会开始收集图片。
此外，在这个过程中，我做了一个小分析，得出了关于 ImageNet 图片 URL 状态的有趣结论。
完整的故事:
我需要在大于 32x32 像素的图像上构建和训练分类 ConvNet，因此我必须找到一个包含用类标记的更大图像的数据集。ImageNet 就是这样一个数据集。
ImageNet 广泛用于图像分类模型的基准测试。它包含超过 20 000 个类别的 1400 万张图片。
获取数据的一种方法是使用 ImageNet LSVRC 2012 数据集，它是整个 ImageNet 的 1000 个类别的选择，包含 128 万张图像。
但是我不一定想要也不需要下载 20 000 个类中每一个类的 150GB 的数据和图像。出于原型和测试的目的，数据集的较小子集就足够了，例如，100 个类的数据集。
ImageNet 项目不拥有任何图像，但是它们通过 API 或在一个文件中为每个图像提供 URL 列表。
我想了解我能够从 ImageNet 创建什么样的数据集。我分析了 URL 列表并绘制了每类图像直方图:
峰值大约是每类 1200 张图片，超过 1000 个这样的类。足以创建 100 个类数据集的许多变体，每个类至少有 1000 个图像。
下载和第一次观察
于是我写了一个程序，开始下载。
在这个过程中，我观察到了 5 件事:
- 许多网站都关闭了。许多图像找不到了。(这些网址来自 2011 年)
- 从自己的 URL 逐个下载图片是一个缓慢的过程，但关闭的不包含图片的 URL 会使这个过程更慢——在大多数情况下，下载图片比意识到网站不会用图片来响应要快。
- 图像来源的多样性很高。
- 大量图片来自 Flickr。
- 在某些网站上，如果图像不存在，则返回另一个图像，并带有一些文本，表明该图像不存在。例如:
这是一个不太容易解决的问题。
我想到了一个可能解决一些问题的选择——只使用 Flickr 网址。
为了继续，我首先检查了 ImageNet 中是否有足够的 Flickr 图片来创建足够大的数据集。快速 URL 解析显示，700 万张图片来自 Flickr，正好是一半。
然后我检查了只有 Flickr URLs 的每个类的图像，得到了下面的图像:
高峰已经过去，形势看起来不再那么好了。
为了更好地理解这种情况，我创建了每类图像的反向累积图，它不是显示每类有多少个图像，而是显示每类有多少个图像:
它显示大约有 2000 个类，每个类至少有 1000 个图像，这仍然非常好，对于我的目的来说绰绰有余。
Flickr 网址与其他网址
现在我需要检查仅使用 Flickr 网址是否会改善下载过程。
我运行了一段时间我的下载器。在这个过程中，我尝试了 25 000 个随机网址。对于我发出的每一个 URL 请求，我都标记了图片下载是否成功，并测量了处理 URL 所花费的时间。
首先，我想知道我尝试的网址中有多少是 Flickr 网址，有多少是其他网址:
至少在我的随机样本中，这些 URL 在 Flick 和 other 之间平均分布，这将使它们更容易比较。
以下是 Flickr URLs 与其他 URL 的请求时间对比:
似乎下载者在其他网址上花了很多时间。让我们看看所花的时间有多有成效。以下是 Flickr 网址与其他网址的成功比较:
在这里，我们可以看到，其他网址需要更多的时间，不太成功。我计算了一下平均值:大约。80%的 Flickr 网址是成功的，而只有 30%的其他网址是成功的
现在让我们检查一下最有趣的指标—Flickr URL 和其他 URL 每次成功花费的时间:
该图显示，下载者在其他 URL 上平均每次成功花费 2 到 10 秒(平均接近 4 秒)，而在 Flickr URLs 上，每次成功的时间始终保持在 0.5 秒以下。一个非常显著的差异。每张图片 0.5 秒仍然很慢，但比使用所有的 URL 要快得多，也更一致。
ImageNet 下载器
在这个过程中，我编写了一个下载器，它将创建一个包含 Y 个类的数据集，每个类包含 X 张图片。我准备好用了放在 GitHub 上。
下载器将随机挑选每班至少有 YY 图像的班级。但是如果你有什么特殊的需求，你可以指定一个下载的类列表。要选择类，您可以查看一下类列表 csv ，其中我列出了出现在 ImageNet 中的每个类及其名称、id 和 URL 计数。
默认情况下，下载器将只使用 Flickr 网址，但如果你足够勇敢，并准备等待更长时间，并准备清理坏图像的数据，你可以关闭该选项。
更新:多处理器工作人员带来 25 倍的性能提升
我已经实现了并行请求处理。**有了 24 名员工，我的速度提高了 25 倍——大约。每幅图像约 0.02 秒。2 到 6 MB/s 的总下载速度。**我担心 Flickr 会以某种方式限制带宽和下载的数据量，但幸运的是，情况并非如此——我通过在短时间内下载 1000 x 1000 的图像数据集(60GB 的数据)测试了这些限制，没有出现任何问题。
如何搞砸一个计算机视觉项目
统计数据(它们准确吗？)告诉 85%的 AI 项目没有交付。这样只剩下 15%的真正成功，而这些项目成功的原因是很充分的。从规划到沟通，我们来看看是什么让一个基于 AI 的计算机项目脱颖而出。
第一课:承诺过多，兑现不足
AI 就是炒作，毫无疑问。过多的承诺和过少的兑现是很容易的。最好的例子？自动驾驶汽车。他们是 AI 领域过度承诺的完美例子！回顾汽车制造商在 2016 年讲述的自动驾驶汽车愿景很有趣。结果发现他们中的一些人非常乐观。
Tesla Semi prototype (Steve Jurvetson). Is promising big stuff a good idea?
另一方面，熟悉人工智能的人知道，我们在 2020 年初看到完全自动驾驶汽车的可能性很小。挑战是巨大的，许多分析师并不完全理解它会涉及到什么。
为了避免过度承诺，你必须找到现实世界中的用例，这些用例做出微小但重要的步骤。你的项目投资回报率必须是显而易见的。仅仅因为说话或对着相机挥手很酷就替换日常用品，但这些用例通常假设技术会完美无瑕。
你猜怎么着？一开始就不会完美无瑕。
因此，你的 AI 实现——尤其是你的第一个项目——应该总是有备份！在上面有趣的视频中，一把好的旧钥匙可能会很有用…
就部署和目标而言，这意味着您的计算机视觉应用程序应该为您的用户带来更多的东西，但如果它不能按预期工作，就永远不应该妨碍他们。
第二件重要的事情是要有一个狭窄的焦点。我将在未来的帖子中讲述更多这方面的内容，但深度学习需要大量数据。深度学习是巨大的。因此，如果你计划部署一个超级炒作的人工智能项目，例如，能够检测到野外的任何物体，但只有几百个样本可用，你就完蛋了。
我喜欢来自 Charles Ollion 的这篇文章，它讲述了是什么让计算机视觉项目变得容易或困难。
所以，如果你想搞砸，最简单的方法就是选择一个模糊的项目，没有明确的投资回报，有很大的复杂性，只有很少的数据。例如，从头开始实现面部检测算法显然属于这一类。
第二课:不要从计划开始
如果你不知道你要去哪里，你可能不会到达那里。
正如《阿甘正传》提醒我们的，猜测有时被高估了。一个计算机视觉项目有一条清晰而稳定的成功之路，步骤总是相同的。你猜怎么着？我知道很多(我的意思是，很多)才华横溢的数据科学家有时会忘记这一点。
好了，计划是这样的！
The Data Science process — long version
我来告诉你数据科学家的肮脏秘密:我们喜欢做的部分是“实验”，看到了吗，上图中的黄色小方块？
如果这部分花费了你项目工作的 20%以上，那么相信我:你完蛋了。为什么？因为在没有仔细的问题定义的情况下开始，没有可能揭示深度学习不是这个特定问题的解决方案或者一个团队已经用完全不同的方法解决了它的最先进的分析，在没有组织数据收集的情况下开始(在第 4 课中有更多关于这一点的内容)，并且在没有适当沟通的情况下部署一些半生不熟的东西…嗯。
你想毁掉你的项目吗？这里有一个 3 步食谱:
- 甚至在明确定义项目之前就组建数据科学团队
- 打开 Jupyter 笔记本
- 观看您的项目崩溃
如果你在实验阶段之前错过了一个步骤，那么你肯定会在这个项目上花费两倍以上的费用。
第四课:垃圾进，垃圾出
说到准备工作，数据科学中有一个神奇的公式:垃圾进，垃圾出。如果你不给你的团队提供代表你的算法将会起作用的数据，你就完了。
Garbage in. What do you expect to come out? Photo by Elevate on Unsplash
例子不胜枚举。最好的情况下，你的算法会完全不准确。更糟糕的是，它会有偏见，在伤害发生之前没有人会注意到。好的，想要一些例子吗？
还记得我们的自动驾驶汽车吗？算法目前主要在美国接受训练。想象你是一家英国汽车制造商。啊哦:突然，左手驾驶似乎是一个问题…
你是一名放射科医生，正在开发最先进的深度学习放射学软件(我猜每周都有 10 家公司因为这个承诺而成立)。你的实验室只能买得起一台好的 GE 医疗设备，但是你的客户有 Phillips 医疗设备。嗯，理论上是可行的。实际上，你没有证据证明它会。你完蛋了。
Photo by Mathew Schwartz on Unsplash
一个更微妙的例子。几年前，我开发了一个系统，可以自动检测你智能手机上的积分卡。这是一个困难的问题，因为它是一个有 500 个类别的分类器，而每个类别只有一个样本。我们成功了(根据我们的目标衡量标准)，因为我们大量使用了数据增强和其他技巧来使我们的深度学习部分工作。
A thumb on a credit card, from The Verge
我们最引以为傲的技巧之一是在卡片的不同部分模拟拇指，并将其输入神经网络。答对了。除了它有缺陷和偏见:它只适用于白人男性的拇指。哎呀。
但总的来说，我经常看到客户有一个很好的数据集，但完全无法使用，因为它不是在生产环境的条件下捕获的。测试材料不能很好地概括。在 90%的情况下，我们在 NumeriCube 不得不从头开始重做数据集。要做到这一点，我们必须按顺序执行这些步骤——当您还不知道将使用哪种摄像机时，如何为系统收集图像呢？
你想确保你的计算机视觉项目失败吗？给它输入不准确的数据。经验之谈。
第五课:永远不要评估
计算机视觉项目失败的最后一种方式——但还有其他方式——是忽略评估部分。我所说的“评估”，是指从写下你的业务目标开始，到满意地查看你的生产监控系统，确认一切正常为止。
How deep will your project fail? Photo by Gonard Fluit on Unsplash
首先，在开始编写任何代码之前(嘿，在编写代码之前你应该做很多事情)，开始陈述你将用来决定你的项目是否成功的度量标准。
哦，小心点，有诡计。例如，如果你说“我希望我的癌细胞检测器在 99%的情况下都是正确的”，我已经可以给你一个有效的算法:
def is_cell_cancerous(img):
"""A very powerful algorithm that returns True if the given image is of a cancerous cell and False otherwise. Gives more than 99% accuracy provided you feed it with less than 1% cancerous cell images."""
return False
明白了吗？这里的精度指标不令人满意，您必须使用其他方法。什么？这取决于你的项目目标，但考虑 F1 分数，确保你的数据集是平衡的，并使用可以在现实世界中测量的指标。例如，如果您想检测图片上的汽车，使用平均精度(地图)很适合于训练，但可能您的用户希望有一个计数而不是表面的百分比…
事实上，许多项目在开始后就找到了他们的客观标准。在 NumeriCube 公司，我们习惯于在开始项目之前就与客户协商目标指标，但那是因为我们有丰富的经验。当你开始第一个项目时，保持低目标(参见第一课:不要承诺过多)。
结论…
我们还可以说很多其他的事情来帮助构建更好的数据科学项目:清晰的沟通，让利益相关者参与进来，分享最佳实践，在需要时使用外部输入…你对此有什么看法？我们谈谈吧！
如何保护云中的健康数据
数据保护是一个大新闻，人们开始意识到保持健康数据安全的重要性。在这篇博客中，我将探讨数字健康公司应该使用哪些数据安全技术来保护您的健康数据的安全。
我一生都在研究健康数据安全。我在医疗保健 IT 巨头 GPI 做了 4 年的软件架构师。然后，我对这个主题的热情让我完成了一个博士学位。2014 年，我将我对商业和数据安全的兴趣结合起来，创建了 Chino.io ，这是一家专注于数字健康的网络安全公司。
五年后的今天，GDPR 让所有人都关注这个话题。数据保护不再仅仅是一项“值得拥有”的功能。最近，我在看到了许多案例，在这些案例中，公司因为犯错而遭受巨额罚款和名誉损失。2019 年早些时候，英国 IPO 因违反 GDPR 对英国航空公司和马里奥特处以总计 3 . 2 亿€的罚款。在这两起事件中，违规都与糟糕的数据安全实践有关。
遗憾的是，你不能依靠你的云提供商来确保你的应用安全。保护健康数据需要你做比 Azure 或 AWS 所能提供的更多的事情。
背景
在读博士期间，我意识到妥善保护健康数据极其困难。从法律上讲，健康数据受到特殊对待，因为它非常敏感。在美国，它受《健康保险流通与责任法案》( HIPAA )保护。而在欧盟，根据 GDPR和的规定，它被定义为一个特殊的个人数据类别。
这些法律对数据安全采取了非常不同的方法。HIPAA 对数据安全给出了精确的指示，而 GDPR 谈论的是提供“最先进的”安全。但是，最终的结果是一样的。有些特定的数据安全和管理措施是你必须实施的，而这些并不容易做好。
2017 年，谷歌 DeepMind 因不当访问 160 万患者的健康数据而被判有罪。这场争议对他们的 Streams 应用程序的声誉产生了持久的影响。
数据保护与数据安全
在这一点上，澄清数据保护和数据安全之间的区别可能是有用的。数据保护是指保护个人数据的安全。这是通过结合组织措施和数据安全来实现的。组织措施包括用户协议、关于谁可以访问数据的政策、关于数据可以存储多长时间的准则等。数据安全性与您如何存储数据有关，以便只有被允许的人才能访问这些数据。本文主要关注数据安全性。
健康数据的数据安全性
历史上，健康数据存储在本地。例如，每家医院都有自己的患者记录服务器。然而，电子医疗应用程序需要数据在应用服务器上可用。这些服务器通常位于云中。正确保护这些数据很难。使用了 3 种关键技术:加密、假名化和匿名化。让我们详细看一下其中的每一个。
加密
数据加密通过使用合适的加密操作对数据进行编码来保护您的数据。您可以加密静态数据(例如，存储在您的设备或服务器上的数据)或传输中的数据(通过网络)。如下图所示，有三种主要的加密形式。
通常，数据库级安全性对于大多数数据来说已经足够好了。这就是云提供商为客户提供的服务。但是，对于健康数据，您应该使用记录级(应用程序级)加密。在这里，每个单独的记录都用自己的密钥加密。对于保护敏感聊天(例如医生和患者之间的聊天)，端到端加密可能更合适。在这里，消息在发送到网络之前被加密，并且只能由接收者解密。这些技术不是主流云提供商提供的。
假名化
假名化包括用假名替换所有的个人标识符。这可能是一个真实的假名，但通常是一个数字或字母数字标识符。假名是随机生成的。这一过程如下图所示。
假名在数据保护中被用来掩盖一个人的身份。然后，敏感数据可以与假名一起存储，而假名和相关个人信息的列表(映射)被分开存储。这使得攻击者更难窃取数据。但是，假名数据仍然算作个人数据。
匿名化
匿名包括完全删除所有个人数据，然后混淆或掩盖剩余数据。这样做的目的是确保您无法从剩余的数据中重新识别特定的个人。标准技术包括概括、交换、扰动和聚合。众所周知，正确对待匿名非常困难。下图显示了聚合的工作原理。
问题是，匿名化要求将根据数据的独特性而变化。例如，如果你有一组 20 个病人，但只有一个超过 50 岁，那么简单地将年龄四舍五入到最近的十年是不够的。人们对不同的技术进行了大量的研究，如 k-匿名和差分隐私，这些技术试图保证数据的匿名性。
我应该使用哪种数据安全技术？
在设计电子医疗应用程序时，您需要了解使用哪种技术或技术组合。当我向客户提供建议时，我首先会问他们的使用案例是什么。他们是否只需要存储数据，是否需要能够搜索数据，或者是否需要将数据用于商业智能和分析。
存储健康数据
如果您只想安全地存储健康数据，最好的方法是使用记录级加密。然而，有几个问题你需要明白。
- 记录级加密很难实现。它需要密钥管理和强大的登录和权限系统来控制谁可以访问密钥。
- 数据在数据库中被加密。这意味着您无法直接搜索它。您需要考虑这对您的应用程序设计的影响。
- 像这样的加密数据库永远不会像未加密数据库那样响应迅速。在设计应用程序时，您需要记住这一点。
- 理想情况下，您需要将用户详细信息和记录数据存储在不同的系统中。这增加了一层额外的保护。它还允许您减少加密的数据量。
共享健康数据
通常，您需要能够在受信任的各方之间共享健康数据。例如，一个病人，他们的家庭医生和医院顾问。这里，重要的是提供强大的 AAA 控制。AAA 代表认证、授权和计费。它用于控制谁有权访问数据，允许他们对数据做什么，并记录每次数据访问/更改。
通常，你只需要分享实际的健康数据，而不是随之而来的个人信息。这通常是您的系统使用 AI 来分析扫描和患者观察数据的情况。在决定加密哪些数据时，这是您应该考虑的事情之一。
分析健康数据
大数据是大新闻，即使这些数据像健康记录一样敏感。例如，制药公司可以从分析和理解典型的患者档案中获得巨大的利益。这就是数据匿名化的用武之地。问题是，匿名健康数据尤其困难。很多时候，留下的数据对任何有意义的分析都不再有用。
结论
确保数据安全总是很重要的。但是健康数据让这个问题变得更加困难。你不能只是把问题委托给你的云提供商。既然您已经了解了相关技术，那么您就知道应该向您的技术团队提出哪些正确的问题，以确保您不会与 GDPR 或 HIPAA 发生冲突。
关于作者
Jovan Stevovic ，博士在完成博士学位后于 2014 年联合创办了 Chino.io 。Jovan 是健康数据的数据保护、隐私和安全方面公认的专家。他担任过 5 个创业加速器的顾问，是柏林和整个欧盟健康技术社区的受人尊敬的成员。
如何保护你的 Azure 数据工厂管道
1.介绍
Azure Data Factory (ADFv2)是一个流行的工具，用于协调从内部到云的数据接收。在每个 ADFv2 管道中，安全性都是一个重要的主题。常见的安全方面如下:
- Azure Active Directory (AAD)对数据和端点的访问控制
- 管理身份(MI)以防止关键管理流程
- 数据和端点的虚拟网络(VNET)隔离
在本博客的剩余部分，将讨论如何使用 AAD、MI、VNETs 和防火墙规则来保护 ADFv2 管道。关于 Azure 功能安全性的更多细节，请参见我的另一篇博客。关于如何使用快照和增量备份来防止数据湖中的数据丢失的解决方案，请看这个博客。
更新 2020–07–26:现在可以在一个 托管的 VNET 中运行 ADFv2 Azure 托管集成运行时。这是在公共预览，这个博客还没有更新这个功能。
2.Azure 数据工厂管道的架构
在这个 ADFv2 管道中，数据从 SQLDB 中读取，使用 Azure 函数进行转换，并写入 ADLS gen2 帐户。该项目的架构可以在下面找到。
2. Azure Data Factory pipeline architecture
Azure 服务及其在本项目中的使用描述如下:
- SQLDB 被用作包含将被复制的表格数据的源系统。
- Azure 数据工厂 v2 (ADFv2)被用作将数据从源复制到目的地的编排器。ADFv2 使用一个自托管集成运行时 (SHIR)作为计算，它运行在 VNET 中的虚拟机上
- Python中的 Azure 函数用于解析数据。函数无法访问其他 Azure 资源
- Azure 数据湖存储 gen2 (ADLS gen2)用于存储来自 10 个 SQLDB 表的数据和由 Azure 函数创建的元数据文件
- Azure Active Directory(AAD)是微软的身份和访问管理服务，用于对 Azure 资源进行认证和授权
以下安全方面是该项目的一部分。
- AAD 访问控制 : SQLDB、ADLS gen 2、Azure 函数只允许 ADFv2 的 MI 访问数据。这意味着不需要在 ADFv2 或密钥库中存储任何密钥。
- 防火墙规则 : SQLDB、ADLS gen 2、Azure Function 都有防火墙规则，只允许 SHIR 的 VNET 作为入站网络
在下一章中，将实现 ADFv2 流水线架构。
3.创建和部署 ADFv2 管道
在本章中，将执行以下步骤来创建和部署 ADFv2 管道。
- 3a。安装准备工作和资源
- 3b。在 ADFv2 中创建自托管集成运行时
- 3c。保护 ADLS 第二代帐户
- 3d。安全 SQLDB 数据库
- 3e。部署和保护 Azure 功能
- 3f。配置并运行 ADFv2 管道
3a。安装准备工作和资源
在本教程中，资源的部署将尽可能使用代码来完成。需要安装以下资源:
- 安装 Azure CLI
- 安装 Azure PowerShell
- 安装 Visual Studio 代码
- 在 Visual Studio 代码中安装 Azure 函数 Python 库
安装好预备程序后，就可以安装基础资源了。打开 Visual Studio 代码，创建一个新的终端会话并执行下面的命令。
# Login with your AzureAD credentials
az login# set parameters
$rg = "<<Resource group>>"
$loc = "<<Location, e.g. westeurope>>"
$adfv2 = "<<Adfv2 name>>"
$sqlserv = "<<Logical sql server>>"
$sqldb = "<<SQLDB name>>"
$sqluser = "<<SQLDB username>>"
$pass = "<<SQLDB password, [use https://passwordsgenerator.net/](https://passwordsgenerator.net/)>>"
$adls = "<<adls gen 2 account, only alphanumeric>>"
$funname = "<<Azure Function name>>"
$funstor = "<<Azure Function storage>>"
$funplan = "<<Azure Function plan>>"
$vnet = "<<Azure VNET name>>"# create resource group
az group create -n $rg -l $loc# create Azure Data Factory instance
az resource create --resource-group $rg --name $adfv2 --resource-type "Microsoft.DataFactory/factories" -p {}# create logical SQL server and SQLDB
az sql server create -l $loc -g $rg -n $sqlserv -u sqluser -p $pass
az sql db create -g $rg -s $sqlserver -n $sqldb --service-objective Basic --sample-name AdventureWorksLT# create ADLS gen 2 account and container
az storage account create -n $adls -g $rg -l $loc --sku Standard_LRS --kind StorageV2 --hierarchical-namespace true
az storage container create --account-name $adls -n "sqldbdata"# create Azure Function
az storage account create -n $funstor -g $rg --sku Standard_LRS
az appservice plan create -n $funplan -g $rg --sku B1 --is-linux
az functionapp create -g $rg --os-type Linux --plan $funplan --runtime python --name $funname --storage-account $funstor# create VNET
az network vnet create -g $rg -n $vnet -l $loc --address-prefix 10.100.0.0/16 --subnet-name shir --subnet-prefix 10.100.0.0/24
3b。在 ADFv2 中创建自托管集成运行时
在这一部分中，将配置 ADFv2 中的自托管集成运行时。这将使用之前创建的 VNET 中运行的虚拟机来完成。执行下面的 Azure CLI 脚本。
# use the same parameters in step 3a, plus additional params below:$shir_rg="<<rg name>>"
$shir_name="<<shir name>>"
$shir_vm="<<name of VMs on which SHIR runs>>"
$shir_admin="<<name of VMs on which SHIR runs>>"
$shir_pass="<<VM password, [use https://passwordsgenerator.net/](https://passwordsgenerator.net/)>>"az group deployment create -g $shir_rg --template-uri [https://raw.githubusercontent.com/Azure/azure-quickstart-templates/master/101-vms-with-selfhost-integration-runtime/azuredeploy.json](https://raw.githubusercontent.com/Azure/azure-quickstart-templates/master/101-vms-with-selfhost-integration-runtime/azuredeploy.json) --parameters existingDataFactoryName=$adfv2 existingDataFactoryResourceGroup=$rg existingDataFactoryVersion=V2 IntegrationRuntimeName=$shir_name NodeCount=2 adminUserName=$shir_admin adminPassword=$shir_pass existingVirtualNetworkName=$vnet existingVnetLocation=$loc existingVnetResourceGroupName=$rg existingSubnetInYourVnet="shir"
脚本可能需要 15 分钟才能完成。运行脚本后，您可以在 ADFv2 实例中验证它是否已成功部署，另请参见下文。
3b1. Self-hosted Integration Runtime successfully deployed
3c。保护 ADLS 第二代帐户
在这一部分中，ADLS gen2 帐户将受到保护。这是按如下方式完成的:
- 添加 RBAC 规则，即只有 ADFv2 的 MI 可以访问 ADLS gen 2
- 添加防火墙规则，只有 SHIR 的 VNET 可以访问 ADLS gen 2 容器
在这种情况下，Azure PowerShell 用于使用相同的变量配置规则
# Get params, PowerShell is used here, can be done in VSC terminal
Set-AzDataFactoryV2 -ResourceGroupName $rg -Name $adfv2 -Location $l
$adfv2_id = Get-AzDataFactoryV2 -ResourceGroupName $rg -Name $adfv2
$sub_id = (Get-AzContext).Subscription.id# Give ADFv2 MI RBAC role to ADLS gen 2 account
New-AzRoleAssignment -ObjectId $adfv2_id.Identity.PrincipalId -RoleDefinitionName "Reader" -Scope "/subscriptions/$sub_id/resourceGroups/$rg/providers/Microsoft.Storage/storageAccounts/$adls/blobServices/default"New-AzRoleAssignment -ObjectId $adfv2_id.Identity.PrincipalId -RoleDefinitionName "Storage Blob Data Contributor" -Scope "/subscriptions/$sub_id/resourceGroups/$rg/providers/Microsoft.Storage/storageAccounts/$adls/blobServices/default/containers/sqldbdata"# Turn on firewall
Update-AzStorageAccountNetworkRuleSet -ResourceGroupName $rg -Name $adls -DefaultAction Deny# Set service endpoints for storage and SQL to subnet
Get-AzVirtualNetwork -ResourceGroupName $rg -Name $vnet | Set-AzVirtualNetworkSubnetConfig -Name "shir" -AddressPrefix "10.100.0.0/24" -ServiceEndpoint "Microsoft.Storage", "Microsoft.SQL" | Set-AzVirtualNetwork# Add firewall rules
$subnet = Get-AzVirtualNetwork -ResourceGroupName $rg -Name $vnet | Get-AzVirtualNetworkSubnetConfig -Name "shir"
Add-AzStorageAccountNetworkRule -ResourceGroupName $rg -Name $adls -VirtualNetworkResourceId $subnet.Id
在最后一步之后，从 Azure 门户访问您的存储帐户将被拒绝(因为它不是 VNET 的一部分)。要允许从门户访问，您需要将您的 IP 地址列入白名单。
3d。安全 SQLDB 数据库
在这一部分中，SQLDB 将受到保护。这是按如下方式完成的:
- 添加数据库规则，只有 ADFv2 的 MI 可以访问 SQLDB
- 添加防火墙规则，只有 SHIR 的 VNET 可以访问 SQLDB
Azure PowerShell 用于配置规则。
# Configure AAD access to logical SQL server
Connect-AzureAD
$aaduser = "<<your aad user email address>>"
Set-AzSqlServerActiveDirectoryAdministrator -ResourceGroupName $rg -ServerName $sqlserver -DisplayName $aaduser# log in SQL with AAD (e.g. via portal query editor, SSMS or VSC)
# Execute following SQL statement
CREATE USER [<<your Data Factory name>>] FROM EXTERNAL PROVIDER;
EXEC sp_addrolemember [db_datareader], [<<your Data Factory name>>];# Add firewall rules
$subnet = Get-AzVirtualNetwork -ResourceGroupName $rg -Name $vnet | Get-AzVirtualNetworkSubnetConfig -Name "shir"
New-AzSqlServerVirtualNetworkRule -ResourceGroupName $rg -ServerName $sqlserver -VirtualNetworkRuleName "shirvnet" -VirtualNetworkSubnetId $subnet.Id
要从计算机进行访问以进行测试，您需要清空您的 IP 地址。
3e。部署和保护 Azure 功能
在这一部分，将部署 Azure 功能。这是按如下方式完成的:
- 将源部署到功能
- 添加防火墙规则，只有 SHIR 的 VNET 可以访问 Azure 功能
- 添加只有 ADFv2 的 MI 才能访问 Azure 功能的 App 注册
第一步是使用这个快速入门在 python 中创建一个 Azure 函数。随后，更新 requirement.txt，init。py 并从这个 git 库添加 cdmschema.py。然后将您的函数发布到步骤 3a 中创建的$funname。要增强安全性，请使用以下 Azure CLI 脚本添加防火墙规则:
az webapp config access-restriction add -g $rg -n $funname --rule-name "shirvnet" --action Allow --vnet-name $vnet --subnet "shir" --priority 300
最后，对 Azure 函数的 AAD 访问可以通过向 Azure 函数添加一个 app 注册来配置，并且只允许 ADFv2 的 MI 访问 Azure 函数。参考这个教程和这个 PowerShell 脚本如何做到这一点。
3f。配置并运行 ADFv2 管道
在这一部分中，将配置和运行 ADFv2 管道。转到您的 Azure Data Factory 实例，选择设置一个代码存储库并导入下面的 GitHub 存储库 rebremer 和项目 adfv2_cdm_metadata ，见下文。
3f1. Setup code repository in ADFv2
只有管道 BlogADFv2sec 与这个博客相关。为 ADLS gen2、Azure Function 和 SQLDB 定制此管道的相关链接服务，另请参见下文。
3f2. Customize linked services in pipeline BlogADFv2sec
查看此链接如何使用 Applications Insights 登录 Azure 功能。下面是一个日志记录的例子。
3f3. Logging ADFv2 pipeline
最后一步，管道可以在 ADFv2 中运行。转到您的管道并单击 debug。当一切顺利时，所有的绿色检查将出现在输出中，如下所示。
3f4. Successful run of pipeline
4.结论
在这篇博客中，创建了一个部署安全 ADFv2 管道的架构，其中数据从 SQLDB 读取，使用 Azure 函数转换，并写入 ADLS gen2 帐户。其中，AAD 访问控制、托管身份、虚拟网络和防火墙规则用于保护管道，另请参见下面的架构。
4. Azure Data Factory pipeline architecture
注来自《走向数据科学》的编辑: 虽然我们允许独立作者根据我们的 规则和指导方针 发表文章，但我们不认可每个作者的贡献。你不应该在没有寻求专业建议的情况下依赖一个作者的作品。详见我们的 读者术语 。
如何销售你的数据集？
构建新的人工智能商业模式
作为一名顾问，我经常帮助公司认识到数据的战略重要性。大多数时候，决策者希望利用这些数据集来构建可靠的人工智能解决方案，但在某些情况下，他们将数据视为新的收入来源。因此，越来越多的公司正在探索将数据资产出售或授权给第三方的方法。
我希望这篇文章能帮助你更好地理解数据集在 AI 项目中的战略重要性，以及如何销售它们。
在当今世界，拥有大量数据并不是独一无二的。的确，数据本身越来越成为一种商品。然而，有效利用数据的能力可以成为竞争优势的来源。
从战略的角度来看，访问高质量的数据对于各种企业都变得越来越重要。事实上，数据非常有价值。它有助于创造优质产品，形成进入壁垒，并且可以直接货币化。
近年来，数据处理技术的重大进步推动了对数据的需求。云存储，新的数据科学技术，处理能力的提高，以及人工智能子领域的进一步发展和普及，都使公司能够从他们的数据资产中释放出新的见解，通常是以趋势，模式和关联的形式。
在人工智能背景下，挑战在于创建大型相关数据集，以便模型可以被训练，结果可以更准确。
数据是用文本、数字或多媒体表示的观察或测量结果(未处理或已处理)。数据集是一个结构化的数据集合，通常与一个独特的工作主体相关联。
我的数据集应该收费多少？
给数据集定价可能很棘手，但总的来说，我发现三个因素让数据集更有价值:
**此外，其他人很难从头开始构建你的数据集，这也是一个强大的因素。**根据我的经验,“最佳”数据集是符合预算、满足项目数据数量和质量需求以及时间限制的数据集。
最近，我不得不为一个计算机视觉项目购买一个数据集。选择可能是压倒性的，价格和方法各不相同。知道你到底在买什么，以及这个特定的数据集是否会对你的人工智能项目有所帮助，这一点至关重要。
根据您的项目，您可能只需要开放数据，但在许多情况下，CV 模型的真正优势只能通过收集专有训练数据来开发，这些数据类似于您期望您的最终模型在上工作良好的数据。这些数据通常是细微的，并且不同于一般可用的数据集。
为什么数据估值很重要？
一些决策者寻求将他们的数据货币化，以创造新的收入流。然而，他们往往低估了将数据暴露给第三方的可能后果。实际上，尽管越来越多的人认识到潜在的好处，但大多数组织对向公司外部公开什么数据非常谨慎。事实上，花时间评估您的数据的战略重要性，以确定销售您的数据集是否真的会影响您的竞争地位或实现您从中获益的能力，这是非常关键的。
在并购过程中，对数据资产不准确的估价会让股东付出高昂的代价(M&A)。
在您尝试从数据集获得收入之前，请确保它:
- 可靠的
您必须能够验证您的数据是从可靠的来源收集的，并且是以不损害有效性的方式收集的。你还需要足够的数据和正确的数据才能有代表性的样本。这个元素在人工智能项目中很重要，可以避免偏见。
- 相关的
您的数据必须符合客户的业务需求。显然，这些需求会因公司而异。因此，您必须了解他们的目标，并弄清楚您的数据集如何能有所帮助。此外，你应该确保它是有组织的，并且是他们可以使用的格式。
- 所有权
**不要以为因为你可以访问某些数据，这些数据就自动归你所有……**例如，在医疗行业，确保你的数据集中的那些患者已经签署了一份合同，授权对他们的数据、图像等进行商业使用。而且在出售的时候，一定要让买家签下一份专门用于研究目的的合同，并加上一条不公开披露数据库中那些数据的条款。
- 安全且匿名
重要的是，您的数据是安全的，并且可能是匿名的。有几种技术确实存在:
加密隐藏了数据，因此如果被盗就无法读取。**否则可以使用标记化。**它替换数据中的值，同时保留某些元素，但使用不同的流程来执行此操作。它始终保证信息的安全，您可以更加灵活地选择应该标记哪些字段，甚至可以只标记部分字段。
你的数据集值多少钱？
**事实是，在数据集上贴上价格标签并没有精确的公式。**可能基于多个属性，包括使用类型和频率、内容、年龄、作者、历史、声誉、收入潜力、安全要求等。**此外，数据价值会随着时间的推移而变化，以响应新的公司优先事项、诉讼或法规。**但是，这些元素应该有助于您更好地理解数据集的价值。有三种最常见的方法来评估数据集:
您还应该考虑其他因素，如数据量、收集数据的频率、数据集的完整性、信息的稀缺性、信息的组织、可靠性以及分析的难易程度。
现实情况是，大多数组织仍然专注于存储、保护、访问和分析大量数据的挑战，这些工作主要由信息技术(IT)部门负责。此外，他们中的大多数没有正式的数据评估实践。
作为战略资产的数据
**对于一些公司来说，利用数据资产赚钱并不是一个新概念。**的确，客户数据可以直接或间接产生货币价值。然而，越来越多的公司试图通过结合内部和外部数据来创建独特的数据集。
传统的有形资产通常表现出递减的使用回报。也就是说，它们用得越多，价值就越低。但是数据经常会随着使用次数的增加而增值。也就是说，被视为资产的数据可以展示出不断增加的使用回报。
**的确，数据被使用得越多，价值就越大。**换句话说，如果您将数据视为一种资产，那么它可以变得更有价值(它是不可耗尽的、不会退化的、持久的、具有战略意义的)。
另一个需要考虑的因素是使用时间:在正确的时间使用正确的数据，例如，在特定的零售销售时刻收集的交易数据可能具有非常高的价值。
公司能做什么？
在考虑出售数据集之前，公司制定数据评估政策至关重要。首先要有一个数据目录，这样所有的数据资产以及它们的用途都是已知的。总体而言，在整个公司范围内创建数据策略是确定数据价值优先级的第一步。
不幸的是，我意识到，当公司正在收购、出售或剥离拥有大量数据资产的业务部门时，他们往往会考虑数据估值流程。可以肯定的是，在未来，首席数据官的一些不断演变的职责可能包括为此目的对公司数据进行估值。
需要建立内部数据评估专业知识。
有数据卖和知道怎么卖不是一回事。一些公司依靠外部专家，而不是内部专家来评估他们的数据。随着数据和人工智能项目日益增长的战略重要性，这种情况可能会改变。
我认为，寻求将其数据资产货币化的公司将首先需要解决如何在自己的组织中获取和发展估值专业知识的问题。
了解如何评估公司数据资产的价值有助于确定哪些项目比其他项目更具战略意义。
原始和外部数据的重要性
**由外部数据和内部数据组成的数据集的兴起还有一个有趣的因素。**你接触的独立数据源越多，你的洞察力就越强。您可以将数据连接到其他专有数据集或公共数据集，以创建唯一的数据集。
此外，我们更倾向于原始数据，因为它有无限多的可能最终用途，这取决于用户和意图，并且可以随着时间的推移而改变。事实上，两家公司可能有不同的用例，因此需要集成不同的数据源和不同类型的分析，并会导致很大程度上不同的最终价值。数据的这一方面使得通过基于收入的方法进行货币化估值变得特别困难，因为不同买家之间可能的用途会发生巨大变化。
销售是最难将数据集货币化的方式，这主要是因为它需要一种独特的商业模式，而大多数公司并不具备这种模式。
大多数进入数据货币化业务的公司都确定了能够增强内部数据的合作伙伴。我建议公司从数据中发现趋势和见解，这些趋势和见解不容易被复制或从竞争对手那里获得。
商业模式
数据货币化可以通过不同的方式实现。你既可以卖给你整个数据集，也可以分析它并出售你的人工智能结果。我确定了 3 种商业模式:
另一件要记住的事情是，当你在市场上出售数据集时，你基本上是在授予买方以某种方式使用该数据集的许可，但你也可以保留你所出售的特定数据集的所有权，并可以出售任意数量的数据集许可。
如何使用 Python 发送带附件的电子邮件
使用 Python 电子邮件库实现报告自动化的几个简单步骤。
Photo by Web Hosting on Unsplash
作为一名数据分析师，我经常会收到这样的请求:“你能每周给我发一份报告吗？”或者“你能每个月通过邮件把这些数据发给我吗？”。发送报告很容易，但如果你每周都要做同样的事情，那就太烦人了。这就是为什么您应该学习如何使用 python 来发送电子邮件/报告以及在您的服务器上安排脚本。
在本文中，我将向您展示如何从 Google BigQuery 中提取数据，并将其作为报告发送。如果你只想知道如何使用 Python 发送电子邮件，你可以跳到电子邮件部分。
导入库
像往常一样，我们必须在进入编码部分之前导入库。我们将使用 SMTP 协议客户端发送电子邮件。 ConfigParser 用于读取存储 SQL 查询的配置文件。我将在下一部分解释细节。
从 BigQuery 提取数据
首先，您必须创建一个配置文件来存储所有的 SQL 查询。将 python 脚本与 SQL 查询分开是一种很好的做法，尤其是当您的 SQL 查询很长(超过 20 行)时。这样，您的主脚本就不会被冗长的 SQL 查询弄得杂乱无章。
配置文件示例
*【报告 1】*是您的子配置。filename、dialect和query是子配置的属性。
您可以使用以下代码读取配置文件。
写一个函数来读取子配置的属性
这个自定义函数将读取您传入的子配置文件的属性，并输出一个 CSV 文件。
yourProjectID将是您的 BigQuery 项目 ID，而credential.json将是您的 BigQuery 凭证 JSON 文件。如果您希望使用 Web Auth 登录，您可以删除它。
现在，您只需要一个循环来提取您在配置文件中定义的所有文件。config.sections()将返回您的配置文件中的子配置文件列表。
通过电子邮件发送您的报告和附件
定义您的电子邮件内容
以上是你如何定义你的电子邮件属性，如发件人，收件人，抄送和主题。htmlEmail将是你的邮件正文。您可以使用纯文本或 html 作为您的电子邮件正文。我更喜欢使用 html，因为我可以做更多的格式化工作，比如粗体、斜体和改变字体的颜色。
同样的事情，我们将使用循环来附加所有的文件。
发送电子邮件
出于演示目的，密码被硬编码在脚本中。这不是一个好的做法。为了更安全，您应该将密码保存在其他文件中。
现在你已经学会了如何使用 Python 发送带有附件的电子邮件。如果我犯了任何错误或打字错误，请给我留言。
您可以在我的 Github 中查看完整的脚本。如果你觉得这篇文章对你有用，请鼓掌支持我。干杯！
如何在 Oracle Cloud 上用 Ubuntu 18 设置 GPU VM
介绍
如果你想开发一个深度学习模型，并希望获得成功的可能性很大，你需要两样东西:
- 大量的数据，用于模型的训练
- GPU 形式的足够的计算能力
深度学习模型通常基于深度(多层)神经网络。通常用于模型训练的算法是基于某种形式的“反向传播算法，它需要许多“张量”运算。对于这种操作，GPU 比 CPU 更有效，因为它可以以一定程度的并行性执行，即使使用现代 CPU 也无法实现。举例来说，英伟达 P100 拥有 3584 个内核，能够处理 5.3 万亿次浮点运算。
因此，与使用 CPU 所需的时间相比，如果您采用现代 GPU，您将能够将训练模型所需的时间减少至少一个数量级。
但是 GPU 还是很贵。另外，在这个领域，发展势头强劲，你的 GPU 可能会很快老化。
因此，选择采用基于云的环境，你只需为使用付费，这是现在最好的选择。仅举一个例子，在 Oracle Cloud 上，您可以使用一个带有一个 NVidia P100 (16 GB)、12 个 OCPU 和 72 GB Ram (VM)的 VM。GPU2.1 形状)约 30 $/天。如果需要，您可以使用更多的 GPU 来获得图形。
话虽如此，为 TensorFlow 正确设置环境并不是一件最简单的事情，你有可能无法充分利用你的 GPU。我在网上做了一些研究，发现文档并不完美。为此，我决定写这篇关于如何为 TensorFlow 和 GPU 设置 Ubuntu 18 环境的笔记。
环境。
如前所述，我正专注于在 Oracle 云基础架构(OCI)中设置虚拟机，我希望使用以下组件:
- Ubuntu 18.04
- Anaconda Python 发行版
- 张量流
- Jupyter 笔记本
稍微复杂一点的是操作系统库、用于 GPU 的 Nvidia 驱动程序、CUDA 工具包版本和 TensorFlow 版本之间的正确对齐。如果所有这些都没有正确对齐，您可能会面临 TensorFlow 程序将正确运行的环境，但不使用 GPU，并且执行时间要长得多。不完全是你想要的。
我在这里记录了到目前为止我发现的最简单的一系列步骤，老实说，我是从个人角度开始写这篇笔记的。然后我决定，也许这是值得分享的。
虚拟机。
从 OCI 控制台，我为创建虚拟机选择的设置如下:
- 外形:VM。GPU2.1 (1 个 GPU，12 个 OCPU)
- 操作系统:Ubuntu 18.04
- 公共 IP:是
- 启动卷:100 GB 的磁盘空间
我还添加了一个公钥，以便能够使用 ssh 远程连接。
虚拟机的创建速度很快。很好。
虚拟机操作系统设置。
首先要做的是更新可用包的列表:
sudo apt update
那么，既然我们要使用 Jupyter 笔记本 ，我们就需要在板载防火墙中打开端口 8888。推荐的方法如下:
sudo iptables -I INPUT -p tcp -s 0.0.0.0/0 --dport 8888 -j ACCEPT
sudo service netfilter-persistent save
不要使用 ufw。您可能会取消将虚拟机连接到存储所需的一些设置。
在此之后，我们需要添加一个入站网络安全规则，以便能够从浏览器连接到端口 8888:
Log into OCI console.Under **Core Infrastructure** go to **Networking** and then **Virtual Cloud Networks**.Select the right cloud network.Under **Resources** click on **Security Lists** and then the security list that you’re interested in.Under **Resources**, click **Ingress Rules** and then **Add Ingress Rule**.Enter 0.0.0.0/0 for the Source CIDR, TCP for the IP Protocol, and 8888 for the destination port.At the bottom of the page, click **Add Ingress Rules**.
此时，我们需要安装正确的 Nvidia 驱动程序。这是一个关键点，我已经浪费了一些时间。对于 Ubuntu 18，我发现的最简单的方法如下:
sudo apt install ubuntu-drivers-commonsudo ubuntu-drivers autoinstall
重新启动后(强制)，您可以使用以下命令检查驱动程序是否正确安装(输出被报告)。从命令中，您还可以获得驱动程序的版本。
**nvidia-smi**Mon Sep 30 13:34:03 2019+ — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — -+| NVIDIA-SMI 430.26 Driver Version: 430.26 CUDA Version: 10.2 || — — — — — — — — — — — — — — — -+ — — — — — — — — — — — + — — — — — — — — — — — +| GPU Name Persistence-M| Bus-Id Disp.A | Volatile Uncorr. ECC || Fan Temp Perf Pwr:Usage/Cap| Memory-Usage | GPU-Util Compute M. ||===============================+======================+======================|| 0 Tesla P100-SXM2… Off | 00000000:00:04.0 Off | 0 || N/A 37C P0 24W / 300W | 0MiB / 16280MiB | 0% Default |+ — — — — — — — — — — — — — — — -+ — — — — — — — — — — — + — — — — — — — — — — — ++ — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — -+| Processes: GPU Memory || GPU PID Type Process name Usage ||=============================================================================|| No running processes found |
“nvidia-smi”命令在未来也将有助于检查 GPU 在训练过程中的使用。
软件安装。
下一步是安装 Anaconda Python 发行版。
在撰写本文时，“七月版”是最新的版本，但是您应该查看 Anaconda 站点。
wget [https://repo.continuum.io/archive/Anaconda3-2019.07-Linux-x86_64.sh](https://repo.continuum.io/archive/Anaconda3-2019.07-Linux-x86_64.sh)bash Anaconda3–2019.07-Linux-x86_64.sh -becho -e ‘export PATH=”$HOME/anaconda3/bin:$PATH”’ >> $HOME/.bashrcsource ~/.bashrc
使用以下命令对 Anaconda 发行版进行最后一次更新是值得的:
conda update -n base -c defaults condaconda init bash
source ~/.bashrc
至此，我得到了 4.7 版本。最后两个命令允许使用“conda 激活”命令。
接下来，我们需要创建一个新的“conda”虚拟环境，我们称之为“gpu”
conda create --name gpu
conda activate gpu
之后，我们可以在创建的“GPU”env 中安装 Python:
conda install python
下一个重要步骤是 TensorFlow 的安装。这里要安装支持GPU的版本。重要的是使用 conda 而不是 pip 进行安装，因为这样可以确保正确安装和满足所有依赖关系。
conda install tensorflow-gpu
接下来，Jupyter 安装:
conda install nb_condajupyter notebook --generate-config
之后，您需要在 Jupyter 的配置中写入以下几行
In /home/ubuntu/.jupyter/jupyter_notebook_config.py file, add the following linesc = get_config()
c.NotebookApp.ip = '0.0.0.0'
c.NotebookApp.open_browser = False
c.NotebookApp.port = 8888
这样，您就可以从 VM 外部(任何 IP 地址)连接到 Jupyter。
然后，因为您只希望通过 SSL 进行连接，所以可以使用 OpenSSL 生成自签名证书:
openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout jupyter-key.key -out jupyter-cert.pem
完成所有这些步骤后，您可以使用以下命令启动 Jupyter
jupyter notebook — certfile=jupyter-cert.pem — keyfile=jupyter-key.key
(最终，您可以添加 nohup)。
浏览器会给你一个安全警告，但你知道你在做什么，可以马上继续。
测试你的 GPU。
现在，终于到了检查一切是否正常的时候了。在开始训练复杂的深度学习模型之前，我们希望确定 TensorFlow 将使用 GPU。因此，我们使用 TensorFlow 进行测试。
在笔记本电池类型中:
import tensorflow as tffrom time import strftime, localtime, timewith tf.Session() as sess:devices = sess.list_devices()devices
在输出中，您应该在可用设备列表中看到 GPU。
然后作为最后的检查(我在 StackOverflow 上找到的)
import tensorflow as tfif tf.test.gpu_device_name():print(‘Default GPU Device: {}’.format(tf.test.gpu_device_name()))else:print(“Please install GPU version of TF”)
您希望看到第一个“print”语句的输出。
作为最终检查:
- 看看 Jupyter 生产的日志；
- 运行你的模型，同时执行“nvidia-smi”命令；您应该会看到大于 0 的“易变 GPU 利用率”
结论。
如果你想在深度学习领域认真实验，你需要 GPU。有几种方法可以用 GPU 建立 Linux 环境:在这篇文章中，我记录了如何在 Oracle OCI 上用最新的 LTS Ubuntu 版本建立一个环境。
此外，我还记录了如何确保 TensorFlow 实际使用 GPU。
如何在 Amazon RDS 上建立 PostgreSQL 数据库
LPhoto by Joshua Sortino on Unsplash
PostgreSQL 是一个开源的对象关系数据库系统，使用 SQL 语言进行交互和维护。它已经被证明是一个高度可扩展的数据库解决方案，因为它允许您管理万亿字节的数据，并且可以处理许多并发用户。PostgreSQL 也是符合 ACID 的，以确保出错时的有效性。
当您需要创建关系数据库时，您应该**选择 PostgreSQL 数据库，**其中数据被组织到一个或多个由列和行组成的表中，使用唯一的键来标识每一行。一个表中的行通常使用该唯一键链接到其他表中的行。
虽然有许多地方可以托管您的 PostgreSQL 数据库，但是本文特别关注在 亚马逊关系数据库服务 (亚马逊 RDS) 上托管您的数据库。Amazon RDS 允许在 AWS 云中设置关系数据库，非常容易使用。
如果您刚刚开始使用所有 AWS 服务，希望您会发现这很有帮助！在本文的大部分时间里，我将介绍 AWS 上的 PostgreSQL 设置，然后介绍如何执行一些其他有用的数据库操作。如果您已经建立了数据库，请随意跳过！⏭⏭
这篇文章涵盖了哪些内容:
- 如何在 Amazon RDS 中创建 PostgreSQL 数据库
- 如何从外部连接到 PostgreSQL 数据库
- 如何使用 SQL 在数据库中创建表
- 如何使用 SQL 将数据插入数据库的表中
- 如何使用 SQL 删除数据库中的表
在 Amazon RDS 中创建 PostgreSQL 数据库
要在 AWS 中创建 Postgres 数据库，首先登录您的帐户并在 AWS 管理控制台中搜索RDS。点击左边工具条上的Databases，你将被带到一个如下所示的页面。
RDS Databases View
点击右上角的橙色Create database按钮，现在你可以开始为你的新数据库选择选项了。
选择一种数据库创建方法
选择Standard Create以便您可以定制数据库配置。
选择发动机选项
我们正在创建 Postgres 数据库，因此选择 PostgreSQL 并保留默认版本 11.5-R1。
为您的用例选择一个模板
因为我们正在测试，所以我选择了免费层！
自定义设置
您可以更改DB instance identifier和Master username或保留默认值。我把我的用户名改成了test-db和，并保留了默认用户名postgres。您也可以让 Amazon RDS 为您生成一个密码，或者您可以指定自己的密码。在这个例子中，我指定了我自己的。
数据库实例大小
DB instance 类决定 Amazon RDS DB 实例的计算和内存容量。您需要的 DB 实例类取决于您的处理能力和内存需求( Amazon 文档)
这是您希望选择满足内存需求的实例的地方。对于免费层，我们只有Burstable classes作为选项，我将这部分保留为默认的db.t2.micro。
存储大小
您可以在这里指定数据库的存储要求。您还可以选择启用存储自动扩展，以便您的数据库是动态的，可以自动扩展🙂
同样，我只是保留了storage type、allocated storage、maximum storage threshold的默认值，并保留了enable storage autoscaling选中的✅
可用性&耐用性
该选项用于创建一个备用数据库，以防停机，这样您的数据库就可以一直正常运行。该选项在空闲层不可用。
连通性
您可以在这里指定以下连接配置:
- VPC —为该数据库实例定义虚拟网络环境的 VPC
- 子网组 —定义数据库实例可以使用哪些子网和 IP 范围的子网组
- 公共可访问性 —数据库是否可公开访问
- VPC 安全组 —允许 VPC 之外的流量进入的安全组
- 可用性区域 —通过将故障与其他可用性区域隔离来提高高可用性
- 数据库端口 —数据库实例将用于应用程序连接的 TCP/IP 端口
我保留了除Publicly accessible部分之外的所有默认值，我将它改为Yes，这样我的数据库就可以在 VPC 之外访问，就像从 Jupyter 笔记本上访问一样。
数据库认证
在此部分中，您可以从以下选项中选择如何验证您的数据库凭据:
- 密码认证 —通过 DB 引擎的本机密码认证特性管理您的数据库用户凭证。
- 密码和 IAM 数据库认证 —通过 DB 引擎的本机密码认证功能和 IAM 用户和角色管理您的数据库用户凭证。
- 密码和 Kerberos 认证 — 通过 DB 引擎的原生密码认证特性和 AWS 目录服务创建的 AWS 托管 Microsoft AD 管理您的数据库用户凭证。这样，您可以集中存储和管理用户凭证，而不是为每个数据库实例单独存储和管理。
让我们和Password authentication一起去吧。
创建数据库
最后，单击底部的create database开始创建数据库，您应该会在页面上看到以下消息。这需要几分钟时间！
连接到 AWS RDS 中的 PostgreSQL 数据库
下载 Jupyter 笔记本跟随
我们将使用 psycopg2 库在 Jupyter 笔记本中本地连接到 postgres 数据库(您也可以从 IDE 或终端连接)。继续使用!pip install psycopg2-binary安装 psycopg2，然后可以运行下面的代码进行连接。
注意 :对于 *POSTGRES_DBNAME* ，当我放入真正的数据库名时，它实际上从来没有工作过，在这种情况下我将其命名为 test-db，我必须放入 *postgres* 来代替。如果它最终不能使用您给定的数据库名称，尝试默认的 *postgres* 它可能会工作。
import psycopg2 as ps# define credentials
credentials = {'POSTGRES_ADDRESS' : '', # change to your endpoint
'POSTGRES_PORT' : '', # change to your port
'POSTGRES_USERNAME' : '', # change to your username
'POSTGRES_PASSWORD' : '', # change to your password
'POSTGRES_DBNAME' : ''} # change to your db name# create connection and cursor
conn = ps.connect(host=credentials['POSTGRES_ADDRESS'],
database=credentials['POSTGRES_DBNAME'],
user=credentials['POSTGRES_USERNAME'],
password=credentials['POSTGRES_PASSWORD'],
port=credentials['POSTGRES_PORT'])cur = conn.cursor()
如果你没有得到一个错误，你已经成功地连接到你的 postgres 数据库！🎊
在 Postgres 数据库中创建表
既然您已经成功地创建了一个 postgres 数据库，让我们在其中创建一个表。
首先，验证数据库中有什么—应该什么都没有。您可以使用以下返回空列表的代码进行检查。
query = """SELECT * FROM pg_catalog.pg_tables
WHERE schemaname != 'pg_catalog'
AND schemaname != 'information_schema';"""cur.execute(query)
cur.fetchall()
注意: 如果您跳过了本文的部分内容，请先确保您已经连接到了数据库(见上文)😀
您可以通过运行以下代码来创建您的第一个表:
cur.execute("""CREATE TABLE table_1
(column_1 integer,
column_2 float,
column_3 varchar(50),
column_4 boolean);""")# Commit table creation
conn.commit()
这将创建一个名为table_1的表，包含 4 列。我已经包含了一些常见的 SQL 数据类型，因此您可以将它们更改为您的表的数据类型。
如果我们运行上面的代码来检查数据库中的表，我们会得到下面的响应，可以看到 table_1 现在在数据库中:
[(‘public’, ‘table_1’, ‘postgres’, None, False, False, False, False)]
**好处:**如果您想要系统地创建一组给定了表名列表的表，您可以使用下面的代码:
table_list = [] # a list of string table namesfor table_name in table_list:
cur.execute("""CREATE TABLE {table_name}
(column_1 float,
column_2 float,
column_3 float,
column_4 float);""".format(table_name=table_name))# Commit table creation
conn.commit()
将数据插入 PostgreSQL 数据库的表中
现在 postgres 数据库中有了一个表，可以开始输入数据了。
若要插入一行数据，请运行以下代码:
data = [1, 2.2, 'three', True]
insert_query = """INSERT INTO table_8
(column_1, column_2, column_3, column_4)
VALUES (%s, %s, %s, %s);"""# execute insert
cur.execute(insert_query, data)
# commit data insert
conn.commit()
我将数据放入一个列表中，确保数据类型与为表中的列选择的数据类型相匹配。确保自定义正在创建的表，以匹配将要插入的数据类型。然后，我编写了将该列表插入到表中的查询，执行该查询，并将它提交到表中。如果不提交执行，您的数据将不会保存到表中。
通过从表中提取数据来验证数据是否已保存:
select 语句返回我们插入的数据，所以我们知道它是有效的！
要在表中插入多行数据，请运行以下代码:
data = [[5, 5.5, 'five', True], [5, 5.5, 'five', True], [5, 5.5, 'five', True]]
insert_query = """INSERT INTO table_1
(column_1, column_2, column_3, column_4)
VALUES (%s, %s, %s, %s);"""# execute multiple inserts
cur.executemany(insert_query, data)
# commit data insert
conn.commit()
这里的区别在于，变量data是一个包含要插入的数据的列表列表。我们还使用cur.executemany而不是cur.execute来遍历我们的数据列表并插入所有的输入。
同样，您可以使用简单的 select 语句验证是否插入了三行新数据:
现在，您可以看到 select 语句返回了使用前面的 insert 语句添加的 3 个新行。
删除/删除 SQL 中的表
你最终会想要删除这个测试表，开始你真正的工作——或者你可能像我一样搞砸了一些事情🙃
使用 SQL 命令DROP TABLE删除 postgres 数据库中的一个表:
cur.execute("""DROP TABLE table_1""")
conn.commit()
确保您确实提交了，否则您的表不会被删除！使用我们之前用来检查的代码来验证您的数据库包含的表。
就是这样！现在，您可以在 AWS 上建立自己的 PostgreSQL 数据库，创建表，添加数据，并删除任何不需要的表。如果你按照教程学习并发现任何错误，请让我知道，这样我可以修复它！
您还可以使用更好的用户界面来管理 PostgreSQL。我推荐 pgAdmin，这里可以免费下载。
这篇文章最终将成为我和我的团队在从事一个名为 Cryptolytic 的项目时所学到的经验的系列文章的一部分(文章将很快写出来并链接到这里)。这是我们在进行项目时希望拥有的指南。
包含本文中使用的所有代码的笔记本可以在这里找到，这是我们的密码破解项目的回购文件中的内容——所以如果你很好奇，可以去看看！
在 twitter @elizabethets 上找到我或者在 LinkedIn 上联系我！
来源:
**** [## 什么是亚马逊关系数据库服务(Amazon RDS)？
Amazon 关系数据库服务(Amazon RDS)是一个 web 服务，它使设置、操作和扩展关系数据库变得更加容易
docs.aws.amazon.com](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Welcome.html) [## 关于
PostgreSQL 是一个强大的、开源的对象关系数据库系统，它使用并扩展了 SQL 语言和
www.postgresql.org](https://www.postgresql.org/about/) [## 密码破解-app/密码破解
你可以在 Cryptolytic 找到这个项目。Trello 板产品 Canvas Cryptolytic 是一个为初学者修修补补的平台…
github.com](https://github.com/Cryptolytic-app/cryptolytic) [## 关系数据库
关系数据库是基于数据关系模型的数字数据库，由 E. F. Codd 于 1970 年提出。一个…
en.wikipedia.org](https://en.wikipedia.org/wiki/Relational_database) [## 酸
在计算机科学中，ACID(原子性、一致性、隔离性、持久性)是数据库的一组属性…
en.wikipedia.org](https://en.wikipedia.org/wiki/ACID)****
如何建立假设
一些读者要求在我的文章*中附上一个简单的基于事实的例子(没有*不确定性或概率)，以向您展示如何建立决策环境。你的愿望就是我的命令！**
让我们用两个不同的默认动作来演示两个场景，看看它是如何工作的。假设我刚刚接到朋友的电话:“我们今晚出去好吗？”**
第 0 步:接触你的感觉
场景 1 - 我生活在一个永久的状态 FOMO 。街道充满了冒险！
场景 2 - 这是漫长的一周。这张沙发有多舒服？太舒服了。
本例中的场景彼此无关。它们代表了两个平行的宇宙。我给你们看这两个只是为了教学的目的。实际上，你只生活在一个世界，所以你只看到一个场景。
第一步:写下默认的动作
场景一 —默认情况下，我们出去吧！说服我不要。
场景二:默认情况下，我会留在家里。说服我不要。
由决策者选择他们喜欢的默认操作。如果你得不到更多的信息，这个行动就是你承诺要做的任何事情。这些默认动作对不同版本的平行宇宙我来说似乎是合理的。没有一个是“正确”的，除非我诚实地去做。
第二步:写下可供选择的行动
情景 1 —替代行动是留在家中。
场景二 —备选行动是外出。
这与默认操作正好相反。
步骤 3:描述零假设(H0)
如果天气好的话，我很乐意默认(出去)。无效假设是没有雨。
场景 2 —如果没有有趣的现场音乐，我很乐意做我的默认(不出去)。无效假设是我今晚的音乐选择是可证明的蹩脚。
步骤 4:描述备选假设(H1)
场景 1 —我的 null 的反义词是什么？下雨了。呃。比错过更糟。那会说服我改变主意。
场景二 —我的 null 的反义词是什么？我喜欢的一个乐队在我附近有现场演出。那会说服我改变主意。
现在，让我们来看一些数据可能到达的三种不同方式…
分析证据然后决定！(无聊的数据)
场景一——你给我看数据:“科学家刚刚发现了一种新的海蛞蝓。”我该怎么办？我没学到任何改变主意的东西，我们出去吧！
场景二 —你给我看数据:“科学家刚刚发现了一种新的海蛞蝓。”我该怎么办？我没学到任何改变我主意的东西，我要留在家里。
请注意，sea slug 仿真陈述导致拒绝 null 失败，而不是接受 null。可能还会下雨，我只是从数据上不知道，所以我还是继续做我打算做的事情。
分析证据然后决定！(惊人的数据)
场景一 —你给我看数据:“下雨了。”我该怎么办？不是我默认的动作。我会待在家里。
场景二 —你给我看数据:“*斯潘塞·克鲁格 *一小时后登台。”我该怎么办？不是我默认的动作。我随时都可以离开沙发去斯潘塞。
这些事实很容易解释——它们让我的无效假设看起来很可笑(事实上， p 值为 0 ),所以它们迫使我在每种情况下采取替代行动。如果我们得到了相同的数据，但是我们颠倒了它出现在哪个场景(世界)中，会怎么样？
分析证据然后决定！(无聊的数据)
场景一 —你给我看数据:斯潘塞·克鲁格 一小时后登台。”我该怎么办？我没学到任何改变主意的东西，我们出去吧！
场景二—你给我看数据:“下雨了。”怎么办？我没学到任何改变我主意的东西，我要留在家里。
如果你不小心，你可能会错误地认为证据与决策有关。事实上，这个证据不会比海蛞蝓仿真陈述更能改变我的想法…尽管我更想去看一场精彩的表演。不管音乐如何，我也会在场景 1 中做出同样的决定。当然，看一场精彩的演出会让我对出去感觉更好，但无论如何我都会这么做。
如果你已经理解了这一点，你已经准备好添加一些细微的差别——深入研究“ 一句话中的统计推断 ”以获得更深入的例子。
感谢阅读！人工智能课程怎么样？
如果你在这里玩得开心，并且你正在寻找一个为初学者和专家设计的有趣的应用人工智能课程，这里有一个我为你制作的娱乐课程:
Enjoy the entire course playlist here: bit.ly/machinefriend
喜欢作者？与凯西·科兹尔科夫联系
让我们做朋友吧！你可以在 Twitter 、 YouTube 、 Substack 和 LinkedIn 上找到我。有兴趣让我在你的活动上发言吗？使用表格取得联系。
如何为数据科学或其他任何事物建立一个令人敬畏的 Python 环境
介绍
用 Python 编码很棒，而且随着每个新版本的发布，越来越棒！对我来说，这主要是由于大量免费可用的库、其可读性以及最近引入的类型注释。然而，尤其是我们作为数据科学家，往往会产生大而乱的 Jupyter 笔记本或 python 文件，难以理解。除此之外，当一个项目依赖于同一个库的不同版本时，我们经常会遇到版本冲突。修复这个问题需要太多时间，并且经常会导致其他项目出现问题。必须有一种方法来避免这种情况，并方便我们的生活。在本文中，我将介绍我使用的工具和我通常遵循的技术。希望这能帮助未来的我记住所有这些，更重要的是，也能帮助你学到一些有用的东西。事不宜迟，让我们把手弄脏吧。
Python 环境
翻译
让我们从使用 python 时最重要的事情开始:解释器。当然，你可以简单地下载并安装你最喜欢的 python 版本，然后把所有东西都放进去。但是，如果您的程序需要不同的 python 版本，或者程序依赖于同一第三方模块的不同版本，并且您希望在这些程序之间无缝切换，该怎么办呢？
Pyenv 会帮你做到的！
Pyenv 是一组三个工具，我在这里介绍其中的两个，它们是 pyenv (用于安装 python)和 pyenv-virtualenv (用于配置你的全局工具)。您可以通过以下方式安装它们
curl [https://pyenv.run](https://pyenv.run) | bash
之后，给你的加上以下几行。bashrc (同为。zshrc)在您的终端中使用 pyenv
export PATH="~/.pyenv/bin:$PATH"
eval "$(pyenv init -)"
eval "$(pyenv virtualenv-init -)"
最后，重启你的终端。如果你是 mac 用户，当然可以用 brew 安装 pyenv。
现在，您可以使用 pyenv 安装几乎任何 python 解释器，包括 pypy 和 anaconda。注意，pyenv 在您的机器上本地构建 python。构建 python 需要几个库。在我的 Ubuntu 机器上，我必须安装以下几个软件，以免遇到问题
sudo apt-get install build-essential libsqlite3-dev sqlite3 bzip2 libbz2-dev zlib1g-dev libssl-dev openssl libgdbm-dev libgdbm-compat-dev liblzma-dev libreadline-dev libncursesw5-dev libffi-dev uuid-dev
现在，要安装 python 解释器，只需
pyenv install VERSION_YOU_WOULD_LIKE_TO_INSTALL
您可以通过 pyenv 列出所有可用的版本
pyenv install --list
具体来说，让我们安装 python 3.7.5，并将其作为默认的全局解释器
pyenv install 3.7.5
pyenv global 3.7.5
当您键入 Python-version 时，应该会返回 Python 3.7.5
依赖性管理
在 python 中管理项目依赖关系可能会变得混乱或手动。有很多工具可以帮你做到这一点。
我用的最多的是诗词。
除了许多其他的东西，诗歌可以帮助你轻松地
- 管理项目的依赖关系，
- 通过虚拟环境分离您的项目，
- 轻松构建应用程序和库。
作者建议安装诗歌的方式是
curl -sSL [https://raw.githubusercontent.com/sdispater/poetry/master/get-poetry.py](https://raw.githubusercontent.com/sdispater/poetry/master/get-poetry.py) | python
另一种方式，我将向您展示的是使用 pip 和 pyenv-virtualenv。你可能会问:为什么不只是皮普？因为这将在你的全球环境中安装诗歌及其依赖项，而你可能不需要也不想要它们。所以，这里是必要的命令
**# Create a virtual environment called tools that is based on 3.7.5**
pyenv virtualenv 3.7.5 tools
**# Install poetry into the tools virtual env**
pyenv activate tools
pip install poetry
**# Check installed poetry version**
poetry --version
**# Leave the virtual env**
pyenv deactivate
**# This does not work yet**
poetry --version
**# Add your tools virtual env to the globally available ones**
pyenv global 3.7.5 tools
**# Now this works and you can start using poetry**
poetry --version
在我们开始使用 poem 创建我们的第一个项目之前，我建议对它进行配置，这样它可以在项目目录内的. venv 文件夹中创建您项目的虚拟环境。当您使用像 VS Code 或 PyCharm 这样的 ide 时，这非常方便，因为它们会立即识别出这一点并选择正确的解释器
# That seems to be peotry prior to 1.0.0
poetry config settings.virtualenvs.in-project true# That is poetry since 1.0.0
poetry config virtualenvs.in-project true
请注意，您只需设置此配置一次，因为它是全局设置并保持不变的。
最后，我们已经准备好了使用诗歌创建我们的第一个项目，太棒了！我把这个项目叫做 dsexample ，一个我知道的愚蠢的名字，但是我不想浪费更多的时间去寻找一个更好的名字。为了向您展示如何使用诗歌，我添加了特定版本的 pandas 和带有所有额外要求的 fastapi
**# Initialze a new project**
poetry new dsexample
cd dsexample
**# Add modules and create virtual environment.**
poetry add pandas=0.25 fastapi --extras all
**# As an example of how you could add a git module**
poetry add tf2-utils --git [git@github.com](mailto:git@github.com):Shawe82/tf2-utils.git
如果你想看一个使用我在这里给你的所有东西的真实项目，请去我的 Github Repo 。
一致的格式和可读性
现在，我们已经创建了我们的项目，我们将开始在它上面添加越来越多的代码。理想情况下，您的代码库格式一致，以确保可读性和可理解性。这可能会成为一个非常乏味的过程，尤其是如果你不是唯一一个在代码库上工作的人。
黑色 前来救援！
Black 是 python 的一个工具，可以让你专注于必要的内容。它通过自动化将您从手工代码格式化中解放出来。因为它太棒了，让我们把它添加到我们的 dsexample 项目中，并格式化所有文件
**# We add black as a development dependency with --dev as we don't
# need it when it comes to production**
poetry add --dev black=19.3b0
**# Assume we are inside the current toplevel dsexample folder**
poetry run black .
很好，现在所有的文件看起来都很好。
类型正确性
从 Python 3.5 开始，如果我说错了请纠正我，类型注释是标准库的一部分。通过类型注释，您的代码变得更容易理解、维护，并且不容易出错。为什么不容易出错？因为您可以静态地检查变量和函数的类型是否与预期的匹配。当然，这必须是自动化的
又来了 mypy ！
Mypy 是 python 代码的静态类型检查器，可以在错误出现之前发现它们。使用诗歌向您的项目添加 mypy 和类型检查就像添加 black 一样简单
**# We add mypy as a development dependency with --dev as we don't
# need it when it comes to production**
poetry add --dev mypy
**# Assume we are inside the current toplevel dsexample folder**
poetry run mypy .
运行 mypy 可能会产生很多错误。当然，你可以把它配置成只警告你感兴趣的东西。你可以在你的项目中添加一个 mypy.ini 文件，并让你和未来的我参考文档以获得更多细节。
自动化自动化
有了 black 和 mypy，我们可以避免手动格式化代码或遇到可避免的错误。但是，我们仍然需要手动执行这些工具。那不也应该是自动化的吗？是啊！
预提交就是你所需要的一切。
Pre-commit 是一个在您将代码提交到存储库之前执行检查的工具(我想当然地认为您的代码在 git 版本控制之下)。当这些检查失败时，您的提交将被拒绝。这样，您的存储库将永远看不到 mall 格式的代码，或者没有类型检查的代码，或者其他任何依赖于您将要包含的检查的代码。所以让我们安装预提交。
您可以使用 poem 将它直接安装到您的项目中，或者安装到您的本地机器上。我更喜欢后者，因为预提交只在本地使用，而不在 CI/CD 服务器上使用。相反，black 和 mypy 应该运行在 CI/CD 服务器上，因此，将它们添加到项目的 dev 依赖项中是有意义的。下面是我建议如何利用现有的工具虚拟环境来安装它
**# Install pre-commit** **into the tools virtual env**
pyenv activate tools
pip install pre-commit
**# Leave the virtual env**
pyenv deactivate
**# As we have already added the tool venv, it will work directly**
pre-commit --version
要使用它，你首先需要添加一个名为的配置文件。将 pre-commit-config.yaml 提交到项目的顶层文件夹。在这个文件中，您配置了所有应该运行的钩子。使用 mypy 和 black，这个文件看起来像
repos:
- repo: [https://github.com/ambv/black](https://github.com/ambv/black)
rev: 19.3b0
hooks:
- id: black
language_version: python3.7
- repo: [https://github.com/pre-commit/mirrors-mypy](https://github.com/pre-commit/mirrors-mypy)
rev: v0.740
hooks:
- id: mypy
最后，您必须告诉预提交通过执行来设置挂钩
**# I assume your are in the top level folder**
pre-commit install
现在，钩子将在每次提交时运行。黑色挂钩不仅会检查格式问题，还会相应地格式化文件。每当您添加一个新的钩子时，建议您在所有文件上手动运行预提交，因为它只涉及自上次提交以来已经更改的文件
pre-commit run --all-files
就这样，我们实现了自动化！
包裹
有很多工具可以帮助你专注于重要的事情。在这里，我只给你介绍了几个，当然，还有其他更多。希望你已经学到了新的东西，可以专注于内容。感谢您的关注，如果有任何问题、意见或建议，请随时联系我。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
