用 Allegro Trains 加速我的新冠肺炎深度学习项目
快板火车会带你出村！
来源:对慢性阻塞性肺病患者的 x 光片进行描述。
目前由新冠肺炎病毒引起的全球疫情已经威胁到我们人类的神圣性和我们整个社会的福祉。类似于战争时期，疫情也给了我们机会去欣赏那些我们认为理所当然的东西，比如卫生工作者、食品供应商、司机、杂货店店员和许多其他在前线保护我们在这个困难时刻安全的人，致敬！当他们为我们而战的时候，你和我做点事情怎么样？
不幸的是，疫情也给我们带来了来自数据科学家的领域不足的见解，这些见解正变得普遍。因此，我想避免类似的陷阱，这就是为什么我想从下面的免责声明开始。这篇博客的目的是展示如何使用 Allegro Trains 来管理您的机器/深度学习项目，以提高您的生产力并改善工作流程。
第一站:探索数据集
我选择这个新冠肺炎胸部 x 光数据集有两个原因。首先，它很小，而且与当前事件相关，所以你可以很容易地跟随我。第二，数据集包含肺部患者的 X 射线/CT 扫描上的数字和分类特征，以便我们可以应用传统的机器学习解决方案以及神经网络。除了声明的目标之外，本博客的任何见解或观察不应用于做出任何决定。考虑到这一点，感谢你和我一起第二次乘坐快板火车。
实验经理枢纽，快板列车
数据集的原始数据帧。
第二站:组装小零件
随着数据工程管道、存储和计算能力的复杂性急剧上升，像上面这样的异构数据集已经变得很常见。随之而来的是使用大量算法和数据挖掘技术来揭示洞察力的潜力。这也给我们提出了一个独特的问题，即如何在一把保护伞下管理激动人心的实验。这可能意味着让一个数据工程师团队来构建数据接收的数据管道，让数据科学家来按摩和实验数据，让机器学习工程师来提供可移植、可扩展、最重要的是可操作的模型。建立一个可操作的模型需要整个村庄的力量！
在部署机器学习模型之前采取的常见步骤包括摄取数据，创建一个用于版本控制、数据争论和本地或云上的数据实验的 group Github 存储库，安装依赖项以重现同事的结果，找出最佳模型(这本身并不容易)，打包模型等等。如果你开始发现需要一个高级机器学习基础设施或中枢的新兴模式，那么你可能会有所发现。这就是 Allegro Trains 成为您的 ML/DL 项目管理系统的原因，它可以满足您的版本控制需求、自动化代码和实验跟踪、模型质量控制以及甚至在机器级别上对您的实验进行性能记录。
系好安全带，快板火车将带你出村！
迄今为止我发现的训练能力
第三站:聚焦研究问题
但首先，让我们回到手头的重要问题。我们也许能找出预测新冠肺炎患者存活率的最佳属性。是年龄吗？性？诊断模式？做出诊断的卫生工作者的专业？我们也有 x 光/CT 扫描显示疾病的进展。在现实生活中，我们需要医疗专业人员为我们提供必要的领域知识，以找出可能的最佳路线，但目前，我们最多只能进行数据争论和视觉探索，调整图像大小和编码，并利用工程技术为建模准备数据。我选择用 Scikit 的随机森林和 Xgboost 集成学习方法进行实验，以确定与存活率最相关的特征。请注意，准确性在这里不是一个好的性能指标，因为数据是不平衡的，不包含健康个体的扫描。因此，我们可以使用 ROC 曲线来确定最佳模型。如果我们在度量优化上更加严格，最小化假阴性或最大化召回将是我们的首要任务。我还尝试了多种架构和转移学习模型，以根据卷积神经网络从患者的 X 射线/CT 扫描中预测预后。可以想象，每个体系结构都有自己的超参数要调整，性能要跟踪。如果你开始对潜在实验的数量感到有点不知所措，不要担心！我们将利用 Trains，以便我们专注于手头最重要的任务，即回答我们的研究问题。
我开始我的项目是通过在本地建立我自己的服务器,这样火车可以跟踪我们的实验，如下面的标题所示。Trains 自动负责环境复制和日志记录，同时跟踪我们新模型的性能指标以及每个模型的机器资源分配，如 GPU、CPU、IO 速度等。这一点很重要，因为我们不想只根据一个指标来选择最佳模型。也可以选择使用 Allegro AI 的基于网络的演示服务器，它可以让你 24 小时跟踪你的 ML 项目，但我不会推荐它，因为你根本不可能在一天内完成一个 ML 项目。我使用 Keras 作为我选择的深度学习框架，但 Trains 自带对 Pytorch 和 Tensorflow 的内置支持。Trains 也在跟踪这些包，这样我们就可以协作并复制彼此的工作。
自动实验(左)和实验对比(右)。
最后一站:总结调查结果
以上是我使用 Allegro Trains 进行的 AutoML 实验的结果。为这些实验中的每一个创建单独的笔记本或者对每个输出进行版本控制会导致项目混乱。但在这里，我能够简单地比较基于几个指标的卷积神经网络的性能，包括 epoch vs loss 优化和 GPU 使用。**项目管理系统的这种类型的抽象只会导致数据驱动的决策。**我能够准确地确定 85%的患者存活成员，事实证明年龄是决定患者存活率的关键因素。神经网络的资源分配远不止基于树的算法的网格搜索。此外，由于数据集较小，random forest 的性能优于预期的 Xgboost。
很高兴为您提供一个高层次的概述，让您了解如何通过在同一中心下自动化您的实验来轻松处理复杂的数据集。我敢打赌，将 Trains 作为项目管理中心，您的迭代速度、工作流和实验将会显著提高。请务必查看我的第 1 部分迷你系列，了解火车相对于 GitHub 的表现。至于我，我已经到站了。我希望我能听到你为了你的深度学习项目需求而进行的快板训练的奇妙旅程，随时在 LinkedIn 上添加我，或者在 Twitter 上给我大声喊出来。多保重！
用 NVIDIA GPUs 通过 6 个简单的步骤加速 Spark 3.0 Google DataProc 项目
Genessa panainite 在 Unsplash 上拍摄的照片
Spark 3.0 + GPU 来了。它改变了游戏规则
数据探索是数据科学的关键部分。需要很长时间吗？啊。别问了。为 ML 准备数据集不仅需要理解数据集、清理和创建新特征，还需要重复执行这些步骤，直到我们有一个微调的系统。
当我们走向更大的数据集时， Apache Spark 带来了一线希望。它为我们提供了一个可扩展的分布式内存系统来处理大数据。顺便说一句，我们还看到了像 Pytorch 和 Tensorflow 这样的框架，它们使用数千个 GPU 核心来固有地并行化矩阵计算。
但过去我们从未见过这两种系统协同工作。我们继续在深度学习中使用 Spark 处理大数据 ETL 任务，使用 GPU 处理矩阵密集型问题。
这就是 Spark 3.0 的由来。它为我们提供了一种将 NVIDIA GPUs 添加到 Spark 集群节点的方法。这些节点完成的工作现在可以通过使用 GPU 计算软件平台 RAPIDS 的 CPU+GPU 并行处理。
Spark + GPU + RAPIDS = Spark 3.0
根据 NVIDIA 的说法，Spark 3.0 的早期采用者已经看到了其当前数据负载的显著更快的性能。这种处理时间的减少可以让数据科学家在更大的数据集上进行更多的迭代，让零售商改善他们的预测，让金融公司增强他们的信用模型，让广告技术公司提高他们预测点击率的能力。
兴奋不已。那么如何才能开始使用 Spark 3.0 呢？幸运的是，Google Cloud、Spark 和 NVIDIA 已经联合起来，为我们简化了集群创建过程。通过 Google Cloud 上的 Dataproc，我们可以在几分钟内拥有一个完全托管的带有 GPU 的 Apache Spark 集群。
这篇帖子是关于在 Google Cloud 上用 NVIDIA GPUs 建立自己的 Dataproc Spark 集群。
1.创建新的 GCP 项目
在谷歌云平台上完成初始注册后，我们可以开始一个新项目。在这里，我首先创建一个名为 dSparkDataProc 的新项目。
创建新项目
2.在 GCP 项目中启用 API
一旦我们添加了这个项目，我们就可以转到我们的新项目，并通过单击右上角的“激活云外壳按钮来启动云外壳实例。这样做将在屏幕底部打开一个终端窗口，我们可以在其中运行下一个命令来设置数据处理集群:
激活云壳来放置你的命令
在这之后，我们将需要运行一些命令来在云 shell 中设置我们的项目。我们从在您的项目中启用 dataproc 服务开始。启用 Compute 和 Dataproc APIs 来访问 Dataproc，并启用 Storage API，因为您将需要一个 Google 云存储桶来存放您的数据。我们还设置了默认区域。这可能需要几分钟时间:
gcloud services enable compute.googleapis.com
gcloud services enable dataproc.googleapis.com
gcloud services enable storage-api.googleapis.com
gcloud config set dataproc/region us-central1
3.创建一些数据并放入 GCS 桶中
完成后，我们可以创建一个新的 Google 云存储桶，在那里我们将把所有数据保存在云外壳中:
#You might need to change this name as this needs to be unique across all the users
export BUCKET_NAME=rahulsparktest#Create the Bucket
gsutil mb gs://${BUCKET_NAME}
在运行 spark 集群时，我们还可以将一些数据放入桶中，以便以后运行。
# Get data in cloudshell terminal
git clone [https://github.com/caroljmcdonald/spark3-book](https://github.com/caroljmcdonald/spark3-book)
mkdir -p ~/data/cal_housing
tar -xzf spark3-book/data/cal_housing.tgz -C ~/data# Put data into Bucket using gsutil
gsutil cp ~/data/CaliforniaHousing/cal_housing.data gs://${BUCKET_NAME}/data/cal_housing/cal_housing.csv
4.设置 DataProc Rapids 集群
为了创建一个使用 NVIDIA T4 GPU 的 DataProc RAPIDS 集群，我们需要一些初始化脚本来实例化我们的集群。这些脚本将安装 GPU 驱动程序( install_gpu_driver.sh )并为我们自动创建 Rapids conda 环境( rapids.sh )。由于这些脚本处于开发阶段，所以最好的方法是从 GitHub 源代码中获取脚本。我们可以在我们的云 shell 中使用下面的命令来做到这一点，我们在其中获取初始化脚本并将它们复制到我们的 GS Bucket 中:
wget [https://raw.githubusercontent.com/GoogleCloudDataproc/initialization-actions/master/rapids/rapids.sh](https://raw.githubusercontent.com/GoogleCloudDataproc/initialization-actions/master/rapids/rapids.sh)
wget [https://raw.githubusercontent.com/GoogleCloudDataproc/initialization-actions/master/gpu/install_gpu_driver.sh](https://raw.githubusercontent.com/GoogleCloudDataproc/initialization-actions/master/gpu/install_gpu_driver.sh)gsutil cp rapids.sh gs://$BUCKET_NAME
gsutil cp install_gpu_driver.sh gs://$BUCKET_NAME
我们现在可以在云 Shell 中使用下面的命令来创建集群。在下面的命令中，我们使用一个预定义的镜像版本(2.0.0-RC2-ubuntu18)来创建我们的 dataproc 集群，它包含了 Spark 3.0 和 python 3.7。我用的是这张图片的旧版本，因为最新版本在运行 Jupyter 和 Jupyter Lab 时有一些问题。你可以在这里得到所有版本的列表。
CLUSTER_NAME=sparktestcluster
REGION=us-central1
gcloud beta dataproc clusters create ${CLUSTER_NAME} \
--image-version 2.0.0-RC2-ubuntu18 \
--master-machine-type n1-standard-8 \
--worker-machine-type n1-highmem-32 \
--worker-accelerator type=nvidia-tesla-t4,count=2 \
--optional-components ANACONDA,JUPYTER,ZEPPELIN \
--initialization-actions gs://$BUCKET_NAME/install_gpu_driver.sh,gs://$BUCKET_NAME/rapids.sh \
--metadata rapids-runtime=SPARK \
--metadata gpu-driver-provider=NVIDIA \
--bucket ${BUCKET_NAME} \
--subnet default \
--enable-component-gateway \
--properties="^#^spark:spark.task.resource.gpu.amount=0.125#spark:spark.executor.
cores=8#spark:spark.task.cpus=1#spark:spark.yarn.unmanagedAM.enabled=false"
集群架构
我们得到的 Dataproc 集群具有:
- 一个 8 核主节点和两个 32 核工作节点
- 两个 NVIDIA T4 GPU 连接到每个工作节点
- 巨蟒、朱庇特和齐柏林飞船启动
- 启用组件网关以访问群集上托管的 Web UIs
- 额外的火花配置调整适用于笔记本电脑环境设置使用属性标志。具体来说，我们设置
spark.executor.cores=8是为了提高并行性，设置spark.yarn.unmanagedAM.enabled=false是因为它当前破坏了 SparkUI 。
故障排除: 如果您在执行此命令后收到有关限制的错误，您可能需要更改默认 Google 控制台配额页面中的一些配额。我最终改变的限制是:
- **GPU(所有区域)**至 12(最少 4 个)
- **CPU(所有地区)**到 164(最少 72 个)
- 美国中部的 NVIDIA T4 GPU1 到 12(最低:4)
- 美国中央处理器1 到 164(最少 72 个)
我实际上请求了比我需要的更多的限制，因为增加限制的过程可能需要更长一点的时间，稍后我将启动一些更大的集群。
5.在 DataProc Rapids 集群上运行 JupyterLab
一旦您的命令成功(可能需要 10-15 分钟)，您将能够在https://console.cloud.google.com/dataproc/clusters看到您的 Dataproc 集群。或者你可以在浏览器上进入谷歌云平台控制台，搜索“Dataproc”，点击“Dataproc”图标(它看起来像三个相连的圆圈)。这将引导您进入 Dataproc 集群页面。
Dataproc 集群页面
现在，如果你点击 sparktestcluster，然后点击“web Interfaces ”,你将能够打开一个 Web 界面(Jupyter/JupyterLab/Zeppelin)。
我们集群的 Web 界面页面
打开 Jupyter Pyspark 笔记本后，如果您遵循本教程，这里有一些示例代码供您运行。在这段代码中，我们加载了一个小数据集，我们看到df.count()函数运行了 252 毫秒，这对于 Spark 来说确实很快，但我稍后会发布一篇更详细的基准测试文章，敬请关注。
file = "gs://rahulsparktest/data/cal_housing/cal_housing.csv"df = spark.read.load(file,format="csv", sep=",", inferSchema="true", header="false")
colnames = ["longitude","latitude","medage","totalrooms","totalbdrms","population","houshlds","medincome","medhvalue"]df = df.toDF(*colnames)
df.count()
是的，我们的 Jupyter 笔记本起作用了
6.访问 Spark 用户界面
这一切都很好，但我面临的一个主要问题是，我无法使用笔记本中提供的链接访问 Spark UI。我发现有两种方法可以访问 Spark UI 进行调试:
答:使用网络界面选项:
我们可以通过首先点击网络界面上的纱线资源管理器链接，然后点击相应页面上的应用程序主界面来访问 Spark UI:
点击跟踪界面栏中的应用程序主以获得 Spark 界面
然后，您将到达 Spark UI 页面:
是啊！我们得到了 Spark UI。
B.使用 SSH 隧道选项:
访问 Spark UI 的另一个选项是使用隧道。为此，您需要转到 web 界面页面并点击*“创建 SSH 隧道以连接到 Web 界面”。*
使用 SSH 的 Spark 测试集群 Web 界面
这将给你两个你想在本地机器而不是云 shell 上运行的命令。但是在运行它们之前，您需要将 google cloud SDK 安装到您的机器上，并为您当前的项目进行设置:
sudo snap install google-cloud-sdk --classic# This Below command will open the browser where you can authenticate by selecting your own google account.
gcloud auth login# Set up the project as sparkdataproc (project ID)
gcloud config set project sparkdataproc
完成后，我们可以简单地运行第一个命令:
gcloud compute ssh sparktestcluster-m --project=sparkdataproc --zone=us-central1-b -- -D 1080 -N
然后在另一个标签/窗口中显示第二个。这个命令将打开一个新的 chrome 窗口，你可以像以前一样点击 Application Master 来访问 Spark UI。
/usr/bin/google-chrome --proxy-server="socks5://localhost:1080" --user-data-dir="/tmp/sparktestcluster-m" [http://sparktestcluster-m:8088](http://sparktestcluster-m:8088)
这就是设置由 GPU 加速的 Spark3.0 集群的全部内容。
如果不算调试时间和配额增加请求，我花了大约 30 分钟来完成所有这些步骤。
我完全被在 Spark 上使用 GPU 的概念和它开启的不同实验流所震惊。在接下来的几周里，我会做很多这样的工作，不仅是为了基准测试，也是因为它很有趣。敬请关注。
继续学习
此外，如果你想了解更多关于 Spark 和 Spark DataFrames 的知识，我想在 Coursera 上调出 Yandex 关于大数据基础知识的精彩课程:HDFS、MapReduce 和 Spark RDD 和大数据分析:Hive、Spark SQL、DataFrames 和 GraphFrames 。
我以后也会写更多这样的帖子。让我知道你对他们的看法。在 媒体 关注我，或者订阅我的 博客 了解他们。一如既往，我欢迎反馈和建设性的批评，可以通过 Twitter @mlwhiz 联系到我。
使用 XNNPACK 加速 Tensorflow Lite
全新 Tensorflow Lite XNNPACK delegate 可在 x86 和 ARM CPUs 上实现最佳性能
SpaceX 在 Flickr 上的照片
TL；DR:新的 Tensorflow Lite XNNPACK delegate 在 x86 和 ARM CPUs 上实现了最佳性能，在某些情况下比默认的 Tensorflow Lite 后端快 10 倍以上。
Tensorflow Lite 是我最喜欢的软件包之一。它能够在一系列硬件上轻松快速地部署，现在提供了一系列代理来加速推理，例如 GPU、Core ML 和 Hexagon。然而，Tensorflow Lite 的一个缺点是，它的设计考虑了移动应用，因此没有针对英特尔和 AMD x86 处理器进行优化。更好的 x86 支持在 Tensorflow Lite 开发路线图中，但目前 Tensorflow Lite 主要依赖于通过 Neon_2_SSE 桥将 ARM Neon 指令转换为 SSE。
然而，有一个新的 Tensorflow Lite 委托用于基于 CPU 的浮点计算，XNNPACK，它具有 x86 AVX 和 AVX-512 优化功能。在这篇文章中，我将带您使用 XNNPACK 并展示一些基准测试。
安装和使用 XNNPACK
XNNPACK 的使用说明可以在这里找到。最值得注意的是，现在有一个默认情况下启用 XNNPACK 委托的构建标志。这很方便，因为直到现在还不可能在 Python 中加载 Tensorflow Lite 委托。从源代码构建张量流的命令如下所示:
bazel build --define tflite_with_xnnpack=true \
//tensorflow/tools/pip_package:build_pip_package
Tensorflow Lite 基准测试工具现在也有一个标志来启用 XNNPACK 委托。例如，要在 x86 机器上进行分析，首先要构建分析器工具:
bazel build -c opt --verbose_failures \
tensorflow/lite/tools/benchmark:benchmark_model
然后使用以下命令运行探查器:
bazel-bin/tensorflow/lite/tools/benchmark/benchmark_model \
--graph=<model path> --warmup_runs=50 --num_runs=1000 \
--enable_op_profiling=true --use_xnnpack=true
为 XNNPACK 优化
确保模型适合 XNNPACK 很重要，因为它只支持所有 Tensorflow Lite 运算符的子集。例如，标准的 Keras 实现通常使用显式填充层，并通过 mean 运算符实现顶层全局池层。当使用普通的 TFLite 后端时，这只增加了几个百分点的运行时间，但是 XNNPACK 不支持这些操作，导致了相当大的开销——在具有 8 个线程的 MobileNet V2 的情况下为 30%(见下文)！
通过用卷积运算中内置的填充替换显式填充层，可以轻松修复填充:
# Before
x = layers.ZeroPadding2D(padding=((3, 3), (3, 3)), name='conv1_pad')(img_input)
x = layers.Conv2D(64, 7, strides=2, use_bias=use_bias, name='conv1_conv', padding='valid')(x)# After
x = layers.Conv2D(64, 7, strides=2, use_bias=use_bias, name='conv1_conv', padding='same')(img_input)
全局平均池层可以由具有大内核的平均池层代替:
# Before
x = layers.GlobalAveragePooling2D()(x)
x = layers.Dense(classes, activation='softmax')(x)# After
# Use XNNPACK compatible average pooling
x = layers.AveragePooling2D(pool_size=(7, 7))(x)
# Implement the top dense layer as a convolution, so we don't need to remove spatial dims
x = layers.Conv2D(classes, kernel_size=1)(x)
x = layers.Softmax()(x)
请注意，您必须重新训练模型。你可以在本文附带的回购协议中找到这些模型的修复版本这里。
基准
手臂ˌ武器ˌ袖子ˌ装备
好了，基准测试！首先，我决定在 Galaxy S8 上测试 MobileNet V3:
我用 1 个线程测试了 1000 次迭代，其中有 50 次预热迭代。
如您所见，XNNPACK 在标准 Tensorflow Lite CPU 后端的基础上提供了出色的性能。值得注意的是，XNNPACK 支持较新的 ARM v 8.2-A CPU(如 A55)中包含的 ARM Float 16 指令，可惜我手头没有。GPU 后端仍然更快，尤其是对于更大的模型。但是，它需要 OpenGL ES 3.1 或更高版本，仅在所有 Android 设备的约 2/3 上可用(见市场份额此处)。
x86
现在转到 x86。我决定使用 MobileNet V2 和 ResNet50 与英特尔的 OpenVino 软件包进行比较。为了测试，我使用了一个谷歌云 N2 瀑布湖实例，有 8 个虚拟 CPU。带 1 根线:
和 8 个线程:
如您所见，使用 XNNPACK delegate 的 Tensorflow Lite 的性能令人钦佩，在某些情况下比默认的 Tensorflow Lite 后端快 10 倍以上。性能接近 V2 MobileNet 的 OpenVino，但不及 ResNet 50。不过，我不认为这是一个大问题，因为基于深度方向卷积的架构，如 MobileNet V2，更适合 CPU 部署。XNNPACK 还具有比标准后端更好的跨多个 CPU 内核的伸缩性。请注意，TFLite 基准测试工具对应于 OpenVINO 的延迟模式，因此如果针对吞吐量进行配置，看看 XNNPACK 能够提供什么将会很有意思。
摘要
Tensorflow Lite 现在可以通过新的 XNNPACK delegate 提供出色的 x86 性能，在某些情况下超过了英特尔的 OpenVino 包。XNNPACK 的主要缺点是它只为浮点计算而设计。8 位模型量化可以轻松实现 2 倍以上的性能提升，当部署在支持 AVX-512 VNNI 指令的全新英特尔 Cascade Lake CPUs 上时，性能提升甚至更高。对 x86 上 8 位量化的支持在 Tensorflow Lite 路线图中，甚至可能在的下一个版本中。
同样，对于移动部署，XNNPACK 优于 Tensorflow Lite 默认后端。虽然 GPU delegate 仍然比 XNNPACK 快，但 XNNPACK 在不支持 GPU 计算的设备上很有用。
我对 XNNPACK 感到特别兴奋，因为它允许用户留在 Tensorflow 生态系统中，从而简化了部署过程。现在可以使用 Tensorflow Lite 转换一次模型并部署到多个平台，从而减少所需的不同软件包的数量。同样值得注意的是，AMD 处理器越来越少见，OpenVino 是英特尔的产品。我试图在谷歌云 N2D EYPC 实例上测试，但不幸的是，我无法增加我的配额。
我希望这篇文章对你有所帮助。复制这些基准的代码位于这里和这里。
使用 Python 访问免费的谷歌云公共数据集
数据科学基本指南
下载免费的谷歌公共数据集到熊猫数据框
使用 Python 访问免费的谷歌云公共数据集(插图由 Chaeyun Kim 绘制)
谷歌公共数据集简介
G 数据科学家的好消息！谷歌正在制作一个公共数据集的托管存储库，如约翰·霍普金斯系统科学与工程中心(JHU·CSSE)，来自世界银行的全球健康数据，以及【OpenStreetMap 数据，可以通过他们的新冠肺炎公共数据集项目免费访问和查询，以帮助研究人员、数据科学家和分析师努力抗击新冠肺炎。这些数据集消除了障碍，提供了对关键信息的快速、轻松的访问，消除了搜索和装载大型数据文件的需要。研究人员可以从谷歌云控制台中访问数据集，以及数据描述和样本查询，以推进研究。我们在该计划中包含的所有数据都将是公开和免费的。* 该计划将持续有效，直至 2020 年 9 月 15 日。【1】
截至 2020 年 5 月 15 日可用的免费公共数据集列表(作者截图来自 Google
为什么我这么喜欢？
我自己用数据库存储、管理和更新数据有时既无聊又昂贵。有了谷歌公共数据集，他们就在替我打理这些无聊的部分。至于定价，在新冠肺炎疫情之前，它有每月 1 TB 查询的免费层限制(嗯，已经有很多免费数据了！)支持疫情的情况，再也没有限制了！！因此，我可以愉快地专注于有趣的部分:数据分析、性感的数据可视化、开发 web 应用程序等。
本文将与您分享以下分步指南:
- 启用 Google Cloud BigQuery API。
- 为 BigQuery API 创建服务帐户，以向您的 Python 脚本授予权限。
- 使用 BigQuery Web 界面浏览数据集。
- 使用 Python 访问数据集，并将其导入熊猫数据框架。
那么，我们开始吧！
启用 Google Cloud BigQuery API
为了能够访问数据集，你应该注册谷歌云账户。在您注册之后，或者如果您已经有了一个帐户，请转到您的 Google Cloud 控制台，然后激活您的 Google Cloud BigQuery API ( 链接)。点击“激活”API 后，可以看到确认的“API 启用”，如下图所示。
激活 Google BigQuery API (作者截图)
为 BigQuery API 创建服务帐户
为了让 BigQuery API 在以后使用 Python 或其他编程语言访问您的机器，您需要一个新的 Google 服务帐户密钥，步骤如下。(如果只需要通过 web 界面访问，可以跳过这些步骤)
- 转到您的 Google API 凭证页面，为这个 BigQuery API 创建 API 键(链接)。
创建 Google BigQuery API 服务账号(作者截图)
- 选择服务帐户权限角色为“BigQuery Admin”
创建 Google BigQuery API 服务账号(作者截图)
- 然后，点击创建键并选择 JSON 类型。请确保您安全地保存这个文件，否则其他人也可能访问您的 API 帐户。我们将在最后一步中再次使用这个文件。
创建 Google BigQuery API 服务账号(作者截图)
使用 BigQuery Web 界面浏览数据集
用户可以使用 SQL 查询语法检索或查询 Google 公共数据集。首先，您可以尝试观察您可以访问哪些数据集，并通过以下三个步骤通过 Google BigQuery Web 界面测试 SQL 查询:
- 探索可用的数据资源。选择其中一个。
- **在“查询编辑器”窗口中输入查询语法。**在这一步，你需要 SQL 的基本知识来查询(搜索)数据集。如果您以前从未使用过，请查看有关它的在线文档。有几个是在线的比如 W3 。
- 浏览您的查询结果。
使用 Google BigQuery Web 接口查询 Google 公共数据集的例子——纽约市新冠肺炎案例。(作者)
使用 Python 访问数据集，并将其导入熊猫数据框架。
要使用 Python 访问 BigQuery API，请使用以下命令安装该库:
**pip install --upgrade google-cloud-bigquery**
创建您的项目文件夹，并将服务帐户 JSON 文件放入该文件夹。然后，创建一个 Python 文件，用你喜欢的编辑器编辑它。你需要做的第一件事是将 Google 应用点的操作系统环境设置为你的 JSON 密钥目录，这可以通过使用os.environ["xxx"]="yyy"来完成
**os.environ["GOOGLE_APPLICATION_CREDENTIALS"]="Your json directory"**
然后，您可以启动 BigQuery 客户机，并使用以下命令启动查询:
**client = bigquery.Client()** # Start the BigQuery Client **QUERY = ('SELECT ...')** # Input Query Syntax **query_job = client.query(QUERY)** # Start Query API Request**query_result = query_job.result()** # Get Query Result **df = query_result.to_dataframe()** # Save the Query to Dataframe
例如，您可以按照下面的完整 Python 脚本，从纽约时报新冠肺炎数据库中按较晚日期和较高确诊病例的顺序查询美国前 20 名新冠肺炎确诊和死亡病例。
从谷歌公共数据集查询新冠肺炎数据的示例 Python 脚本——纽约时报新冠肺炎数据库(作者提供的示例脚本)
谷歌公共数据集查询结果示例——纽约时报新冠肺炎数据库(作者举例)
所以，就这样吧！祝贺您，现在您可以访问数据集了，享受您的新数据框架吧！！✌🎉🎉
结论
本文涵盖了如何使用 WebUI 和 Python 通过 Google Cloud BigQuery 服务使用和访问数据集的基本步骤。请注意，这篇文章只涵盖了初学者的步骤，还有更多的功能和界面来访问和使用这项服务。你可以在这里查看完整的 BigQuery 文档。
我希望你喜欢这篇文章，并发现它对你的日常工作或项目有用。如果您有任何问题或意见，请随时给我留言。
关于我&查看我所有的博客内容:链接
安全健康健康吗！💪
感谢您的阅读。📚
[1] Chad W. Jennings，新冠肺炎公共数据集计划:使数据可自由访问以获得更好的公共结果(2020 年 3 月 30 日)，谷歌云数据分析
仅用 2 行 Python 代码访问菲律宾股票数据
介绍 fastquant，一个方便访问和分析菲律宾股票数据的工具
作为一名具有金融背景的数据科学家，我一直着迷于通过交易股票赚钱的想法，因为这似乎很简单。为什么？你只需要知道两件事就能赚钱——在低点买入，在高点卖出。
那么，你怎么知道股票何时会上涨或下跌呢？通过分析股票的相关数据(如价格、收益和其他经济指标)。从理论上讲，如果你能以某种方式识别价格的(可预测的)模式，你应该能够识别购买股票的低点。这是一个尝试机器学习和其他统计方法来模拟金融时间序列数据和测试交易策略的绝佳机会。现在我只需要数据。
但问题来了:
我找不到一个免费的 API 来提供可靠的和最新的菲律宾公司的财务数据。
Yahoo Finance 很奇怪，因为它以美元报告，并将数字四舍五入到价格不变的程度，其他来源可以给我图表(例如 Investagrams )，但不能编程访问我用 python 分析数据所需的实际原始数据。
使用 fastquant 访问和分析股票数据
为了解决这个问题，我决定创建一个免费的 python 包，允许任何人获取菲律宾公司的财务数据。fastquant 能够提供任何上市股票截至最近一个交易日的定价数据。
在本文的其余部分，我将演示如何使用简单的移动平均交叉策略，使用 fastquant 对 Jollibee Food Corp. (JFC)进行简单的分析。
装置
安装非常简单，因为这个包是在 PyPi 上注册的！
# Run this on your terminal
pip install fastquant
# Alternatively, you can run this from jupyter this way
!pip install fastquant
获取菲律宾股票数据
有了 fastquant，你可以用两行代码获得任何 PSE 上市公司的财务数据。
在本例中，我们获取了 Jollibee Food Corp. (JFC)从 2018 年 1 月 1 日到 2019 年 1 月 1 日(1 年期)的定价数据。
from fastquant import get_pse_data
df = get_pse_data("JFC", "2018-01-01", "2019-01-01")print(df.head())
# open high low close value
#dt
#2018-01-03 253.4 256.8 253.0 255.4 190253754.0
#2018-01-04 255.4 255.4 253.0 255.0 157152856.0
#2018-01-05 255.6 257.4 255.0 255.0 242201952.0
#2018-01-08 257.4 259.0 253.4 256.0 216069242.0
#2018-01-09 256.0 258.0 255.0 255.8 250188588.0
至此，fastquant 已经完成了它的主要目的——轻松访问菲律宾股票数据。在接下来的步骤中，我们将重点对 JFC 数据进行简单的分析。
绘制每日收盘价
为了绘制 Jollibee 的价格，我们实际上可以直接使用由 get_pse_data 返回的 dataframe，但是我们仍然需要导入 matplotlib 包来添加标题，同时控制其 fontsize(设置为 20)。
# Import pyplot from the matplotlib module
from matplotlib import pyplot as plt# Plot the daily closing prices
df.close.plot(figsize=(10, 6))
plt.title("Daily Closing Prices of JFC\nfrom 2018-01-01 to 2019-01-01", fontsize=20)
请注意，2018 年的峰值出现在 3 月和 12 月左右，而低谷出现在 7 月和 10 月左右。
使用简单的移动平均线(SMA)交叉策略进行分析
在本节中，我们将尝试直观地评估 SMA 交叉策略的性能。有很多方法可以实现这个策略，但是我们会用一个“价格交叉”的方法来实现 30 天的 SMA。
在这种情况下，当收盘价从下方穿过简单移动平均线时，它被认为是“买入”信号，当收盘价从上方穿过简单移动平均线时，它被认为是“卖出”信号。
# Derive the 30 day SMA of JFC's closing prices
ma30 = df.close.rolling(30).mean()# Combine the closing prices with the 30 day SMA
close_ma30 = pd.concat([df.close, ma30], axis=1).dropna()
close_ma30.columns = ['Closing Price', 'Simple Moving Average (30 day)']# Plot the closing prices with the 30 day SMA
close_ma30.plot(figsize=(10, 6))
plt.title("Daily Closing Prices vs 30 day SMA of JFC\nfrom 2018-01-01 to 2019-01-01", fontsize=20)
那么我们如何知道我们的 SMA 价格交叉策略是有效的呢？视觉上，我们可以通过观察“卖出”信号是否发生在股价开始下跌之前，以及“买入”信号是否发生在股价开始上涨之前来评估这一点。
如果你看上面的图表，它看起来非常有效——收盘价线实际上在 3 月左右(第一个高峰的月份)开始几乎持续保持在 30 天 SMA 下方，并在 7 月下旬(第一个低谷的月份)开始保持在 30 天 SMA 上方。
现在，你可能会想，应该有一个更严格的方法来评估交易策略的数字精度。这个过程(如下图所示)被称为回溯测试，是投资专业人士根据经验验证不同交易策略有效性的方式。换句话说，它允许我们比较不同的交易策略，并让我们能够根据历史表现选择最好的一个。
假设我们采用最小最大支持阻力交易策略(2017 年 1 月 1 日至 2019 年 1 月 1 日)，进行回溯测试
当然，重要的是要记住，历史表现并不总是会转化为未来的表现，所以应该始终考虑建仓的风险。无论如何，我不打算在这里讨论回溯测试的细节，但是我打算在以后的帖子中讨论它。
结论
祝贺您到达这篇博文的结尾。到目前为止，您应该已经知道如何 1)使用 fastquant 获得菲律宾公司的财务数据，2)绘制公司股票随时间变化的收盘价，3)直观地分析简单移动平均线交叉策略的有效性。
我们还简要地谈到了回溯测试，以及如何用它来比较不同交易策略的有效性。同样有趣的是应用机器学习和基于统计的预测方法来制定人工智能增强的交易策略。在以后的文章中会有更多关于这些和其他高级主题的内容！
你可以在这个笔记本上找到上面执行的脚本。如果您想试用 fastquant，了解更多关于该方法的信息，或者甚至为改进该模块做出贡献，请随时查看 github repo 。
感谢您阅读这篇文章，如果您对 fastquant 或任何与将数据科学应用于金融相关的问题有任何疑问，请在下面随意评论。也可以通过邮件联系我(Lorenzo . ampil @ Gmail . com)Twitter，LinkedIn；然而，期待我更快地回复评论:)
使用 AWS 和 Google Colab 访问卫星图像
使用 Python 和 Google Colab 加载、试验和下载云优化地理信息系统(COG)。
在本地下载卫星影像时，访问卫星影像需要大量存储空间。如果您在一段时间内需要多个地块，该过程会占用您的所有存储空间。更糟糕的是，您可能只需要整个图像的一个子集区域。
为了解决这样的问题，地理空间数据的最新进展使用了我们云优化的地理信息系统(COG)。
云优化 GeoTIFF (COG)是一个常规的 GeoTIFF 文件，旨在托管在一个 HTTP 文件服务器上，其内部组织可以在云上实现更高效的工作流。它通过利用客户端发出的 HTTP GET range 请求来请求他们需要的文件部分。——https://www.cogeo.org/
现在想象一下，能够倒带、前进和停止一个大视频来观看你需要的视频部分。COG 精确地允许你用卫星图像做到这一点。你可以得到一个孔瓷砖，可视化低分辨率，子集和掩盖一个地区，甚至进行任何处理，甚至没有下载它。
本教程将向您展示如何使用 Python 在 Google Colab 中访问存储在 AWS s3 存储中的 Landsat 图像。第一部分讲述了如何找到适合您感兴趣领域的图像，而第二部分向您展示了如何使用 Python 访问、可视化和处理卫星图像。
查找您感兴趣的区域的卫星图像
我收到很多关于如何获得感兴趣区域的正确图像的询问。在这种情况下，我们使用 Landsat 图像，因此我将指导您如何获得卫星图像的路径和行。进入 USGS explorer 网站，通过提供地址或地点(下图中以红色突出显示)找到您感兴趣的地方。一旦你得到结果，点击地址。如果你愿意，可以按日期过滤掉。
下一步是单击数据集并选择数据集。在本教程中，我们使用的是 Landsat 8，所以我们选择了它(下面突出显示的红色)
点击附加标准以过滤云覆盖范围。如下图所示，我们过滤掉小于 10%的云覆盖。
最后，点击结果，找出你所在地区所有可用的图片。一旦您知道您想要用于分析的图像，您就可以复制 ID 或将其记在某处(如下所示)。
你还需要记下卫星图像的路径和行。你可以点击元数据按钮(红色矩形)或者简单地记下 ID: 0030065 的第三部分。
在下一节中，我们将看到如何使用 Python 在 Google Colab 中直接访问数据。Landsat 同时存储在 AWS 和 Google 云平台中，但在本教程中，我们通过 AWS 获取数据。
用 AWS 和 Google Colab 访问 Landsat
让我们首先导入我们将要使用的库。我们的主要工具是 Rasterio，它提供了一个易于使用的 API 来处理卫星图像。
import numpy as np
import matplotlib.pyplot as plt
import rasterio as rio
from rasterio.plot import show
您可以像这样构造您的 URL 路径。
fpath = ‘http://landsat-pds.s3.amazonaws.com/c1/L8/003/065/LC08_L1TP_003065_20190925_20191017_01_T1/LC08_L1TP_003065_20190925_20191017_01_T1_B4.TIF'
我们可以将上面的 URL 分成不同的部分:
[http://landsat-pds.s3.amazonaws.com/c1/](http://landsat-pds.s3.amazonaws.com/c1/)
URL 的第一部分总是相同的，并显示 AWS 存储 URL。
L8/003/065/
L8 表示陆地卫星 8 号。路径:003。第 065 排。URL 的这一部分将根据您正在访问的数据集和感兴趣的区域而变化。
LC08_L1TP_003065_20190925_20191017_01_T1
这部分是图片的 ID，你可以从上面的图片中得到。
LC08_L1TP_003065_20190925_20191017_01_T1_B4.TIF
最后，重复图像的 ID，但这次是您想要访问的波段(这里是 B4)和图像的扩展名。TIFF)
现在，我们已经设置了访问 URL，我们可以编写一个简单的函数来使用 Rasterio 打开图像。
def rasterio_open(f):return rio.open(f)src_image = rasterio_open(fpath)
一次，我们打开光栅图像；您可以使用任何可视化库或仅 Rasterio 的数据可视化方法来绘制它。
fig, ax = plt.subplots(1, figsize=(12, 10))show(src_image, ax=ax)plt.show()
这是我们访问显示的整个图像。我们只获得了频带 4。我们稍后会看到如何将不同的波段组合起来构建一幅 RGB 图像。
如您所见，我们有显示为黑色的 NaN 值。我们可以通过使用 Numpy 功能来消除这些问题。我们首先通过用 Rasterio 读取图像，将图像转换为 Numpy 数组
src_image_array = src_image.read(1)src_image_array = src_image_array.astype(“f4”)src_image_array
图像被转换成数组，如下所示。
array([[0., 0., 0., …, 0., 0., 0.], [0., 0., 0., …, 0., 0., 0.], [0., 0., 0., …, 0., 0., 0.], …, [0., 0., 0., …, 0., 0., 0.], [0., 0., 0., …, 0., 0., 0.], [0., 0., 0., …, 0., 0., 0.]], dtype=float32)
现在，您可以通过将这些空数组赋值为 np.nan 来轻松删除它们。
src_image_array[src_image_array==0] = np.nanfig, ax = plt.subplots(1, figsize=(12, 10))show(src_image_array, ax=ax)plt.show()
我们现在在边上没有空值了。
通常，您可能只对图像的一个子集感兴趣。在下一节中，我们将介绍如何使用 Rasterio 的窗口功能对图像进行子集化。
子集化图像
要只访问图像的特定部分，可以用行、列、宽度和高度过滤掉图片。比方说，我们不想要整个图像，而是要一个 750 X 850(宽和高)的 1200 列和 1200 行的图像。
# Window(col_off, row_off, width, height)
window = rio.windows.Window(1200, 1200, 750, 850)subset = src_image.read(1, window=window)fig, ax = plt.subplots(1, figsize=(12, 10))show(subset, ax=ax)
ax.set_axis_off()plt.show()
现在图像缩小到一个子集，在城市 Eirunepe 附近，如下图所示。
最后，下一节将展示如何创建一个 RGB 图像并将其下载到本地。
创建 RGB 并下载
我们首先通过为每个波段提供一个单独的 URL 来访问每个波段。注意，除了。TIF 分机。这些是波段，在这种情况下，因为我们想要创建一个 RGB 图像，所以我们访问波段 4(红色)、波段 3(绿色)和波段 2(蓝色)。
rpath = ‘http://landsat-pds.s3.amazonaws.com/c1/L8/003/065/LC08_L1TP_003065_20190925_20191017_01_T1/LC08_L1TP_003065_20190925_20191017_01_T1_B4.TIF'gpath = ‘http://landsat-pds.s3.amazonaws.com/c1/L8/003/065/LC08_L1TP_003065_20190925_20191017_01_T1/LC08_L1TP_003065_20190925_20191017_01_T1_B3.TIF'bpath = ‘http://landsat-pds.s3.amazonaws.com/c1/L8/003/065/LC08_L1TP_003065_20190925_20191017_01_T1/LC08_L1TP_003065_20190925_20191017_01_T1_B2.TIF'red = rio.open(rpath)green = rio.open(gpath)blue = rio.open(bpath)
我们创建一个 RGB 图像，方法是打开一个空图像，并用上面打开的三个波段填充它。
# Create an RGB imagewith rio.open(‘RGB.tiff’,’w’,driver=’Gtiff’, width=red.width, height=red.height,count=3,crs=red.crs,transform=red.transform, dtype=red.dtypes[0]) as rgb:rgb.write(blue.read(1),1)rgb.write(green.read(1),2)rgb.write(red.read(1),3)rgb.close()
图像现已存储。你可以用 Rasterio 打开或者下载到本地。
使用 QGIS 可视化的图像子集
结论
在本教程中，我们介绍了如何查看和找到您感兴趣的领域的正确数据。我们还了解了如何使用 Python 和 AWS 存储来访问 Landsat 图像。
本教程的代码可以在这个 Colab 笔记本上找到。
此时您不能执行该操作。您已使用另一个标签页或窗口登录。您已在另一个选项卡中注销，或者…
github.com](https://github.com/shakasom/rs-python-tutorials/blob/master/Cloud_Optimized_Geotiffs.ipynb)
自己访问和检查新冠肺炎数据
构建一个 choropleth 图，显示美国各县过去七天的人均新冠肺炎死亡人数
编者按: 走向数据科学 是一份以数据科学和机器学习研究为主的中型刊物。我们不是健康专家或流行病学家，本文的观点不应被解释为专业建议。想了解更多关于疫情冠状病毒的信息，可以点击 这里 。
数据和疫情
对于此时地球上的大多数人来说，经历一次全球性的疫情是一次前所未有的经历。有时，我会想到 1918 年至 1920 年的下一次全球疫情与今天之间的时期。这 100 年里，在你能想到的几乎所有领域，包括数据和技术，都发生了一些迄今为止世界上最引人注目的变化。我想知道那些生活在 1918 年的人是如何获得关于疫情及其传播的信息的？今天，我们有许多信息来源可用，并随时可以访问数据显示，包括预测模型，描述和预测疫情的轨迹。但是，作为一名数据科学家，您可能会发现，即使在查看了可用内容之后，您仍有一些问题没有得到解答，并且希望能够自己监控快速发展的情况。幸运的是，通过约翰·霍普金斯系统科学与工程中心(https://systems.jhu.edu/research/public-health/ncov/)的深入研究，你可以获得全球范围内每日的新冠肺炎病例数和死亡人数，也可以获得美国各州、县或地区的数据。然后，您可以使用这些信息来设计数据报告和显示，以便更好地做出困难的决策。例如，在本报告中，我将向您展示如何:
1.在 Github 上访问约翰霍普金斯大学的新冠肺炎数据，
2.执行一些简单的数据操作来转换数据，并且
3.使用 albersusa R 软件包构建一个 choropleth 图(https://rud . is/b/2016/03/29/easy-composite-u-s-choropleths-with-albers USA/)，以显示美国各县过去七天的人均新冠肺炎死亡人数。
访问 Github 上的每日新冠肺炎数据
您可以从加载下面的包开始。注意，如果没有安装 albersusa 包，可以使用 devtools 包中的 install_github()函数来安装。
# Data on COVID-19 from Johns Hopkins Center for Systems Science and Engineering
# https://systems.jhu.edu/research/public-health/ncov/
# https://github.com/CSSEGISandData/COVID-19# Blog post to demonstrate chloroplot package
#https://rud.is/b/2016/03/29/easier-composite-u-s-choropleths-with-albersusa/rm(list = ls())
library(tidyverse)
library(rgeos)
library(maptools)
library(ggplot2)
library(ggalt)
library(ggthemes)
library(albersusa) # devtools::install_github("hrbrmstr/albersusa")
library(scales)
library(gtools)
可以使用以下方法读取数据。请注意，在相同或相邻的目录中，还有美国病例、全球病例和死亡病例的数据集。
# read time series data on US deaths by county
urlfile='[https://raw.githubusercontent.com/CSSEGISandData/COVID-19/master/csse_covid_19_data/csse_covid_19_time_series/time_series_covid19_deaths_US.csv'](https://raw.githubusercontent.com/CSSEGISandData/COVID-19/master/csse_covid_19_data/csse_covid_19_time_series/time_series_covid19_deaths_US.csv')
cov19_us_dat<-read_csv(url(urlfile))
数据每天更新。在本例中，我们只想使用最近 8 天的数据(因为我们需要减去——您将在下面看到)。我们还保存了 fips 代码(用于标识美国各县)和每个县的人口，以便我们可以计算人均值。
# Collect data consisting of the last 8 days
tot_days <- ncol(cov19_us_dat)
begin_day <- tot_days - 7
fips <- cov19_us_dat$FIPS
pop <- cov19_us_dat$Population
us_recent <- cov19_us_dat[,begin_day:tot_days]
请注意，这些文件中的数据是累积形式的，所以如果我们想要每天的计数，我们需要从前一天减去每天的总数。下面是一个简单的方法。
# Convert cumulative data to new values each day
us_daily <- us_recent[,-1] — us_recent[,-8]
us_fatal <- data.frame(fips, pop, us_daily)
colnames(us_fatal) <- c(‘fips’, ‘population’,colnames(us_daily))
最后，有几个数据处理步骤:
1.仅保存位于美国 50 个州或 DC 的县的 fips 代码。
2.处理一些实际上比前一天减少的累积计数(可能是由于数据澄清或调整)。
3.将人口转换为每 10 万人的数量。
4.计算人均比率的十分位数。选择分组到 10 个箱中是一种判断，随着数据随时间的变化，可能会有更好的选择。请注意，前 5 个十分位数的县在过去 7 天内没有出现死亡病例，因此最终只有 5 组。
5.当读入 fips 代码时，除非您能始终如一地将它们存储为“字符”类型，否则它们可能会转换为“整数”类型并丢失前导零。str_pad 函数可以解决这个问题。
6.南达科塔州奥格拉拉拉科塔的 fips 代码显然发生了变化，需要手动解决，以避免在南达科他州中部的地块上出现大的白色方块。
us_fatal <- us_fatal %>%
filter(fips %in% (1001:56045)) %>%
mutate(sum = rowSums(.[3:9]),
sum = ifelse(sum > 0, sum, 0),
pop_100_000 = population/100000,
percap = sum/pop_100_000,
percap_quint = quantcut(percap, q=10, dig.lab = 3),
fips = as.character(fips),
fips = str_pad(fips, 5, 'left','0'))
# replace fips for Oglala Lakota, SD (formerly Shannon, SD)
us_fatal$fips <- replace(us_fatal$fips, us_fatal$fips == "46102", "46113")
设置打印颜色的一个选项:
# Set up plot colors according to the number of levels of quintiles (many 0's)
no_colors <- length(unique(us_fatal$percap_quint))
quin_colors <- c("springgreen", "skyblue", "navy","violet","violetred")
start_color <- 5 - no_colors + 1
plot_colors <- quin_colors[start_color:5]
最后，使用 ggplot()创建图形:
cmap <- fortify(counties_composite(), region=”fips”)gg <- ggplot()
gg <- gg + geom_cartogram(data=cmap, map=cmap,
aes(x=long, y=lat,map_id=id),show.legend = FALSE,
color=”#2b2b2b”, size=0.05, fill=NA)
gg <- gg + geom_cartogram(data=us_fatal, map=cmap,
aes(fill=percap_quint, map_id=fips),
color=”#2b2b2b”, size=0.05)
gg <- gg + scale_fill_manual(name=”per 100,000 pop”, values = plot_colors)
gg <- gg + labs(title=’Covid-19 Fatalities per capita by US County, Last 7 days’,
subtitle=paste(‘Data source: Johns Hopkins Center for Systems Science and Engineering, ‘, Sys.Date(), sep=’’))
gg <- gg + theme_bw()
gg <- gg + xlab(NULL)
gg <- gg + ylab(NULL)
gg <- gg + theme(axis.ticks.x = element_blank())
gg <- gg + theme(axis.ticks.y = element_blank())
gg <- gg + theme(axis.text.x = element_blank())
gg <- gg + theme(axis.text.y = element_blank())
gg <- gg + theme(legend.position=c(0.85, 0.30))
gg <- gg + theme(plot.title=element_text(size=24, hjust = 0.5))
gg <- gg + theme(plot.subtitle=element_text(size=18, hjust = 0.5))
gg <- gg + theme(legend.text=element_text(size=14))
gg <- gg + theme(legend.title=element_text(size=18))png(paste(“choro.png”, sep = “”), width = 1200, height = 800, units = “px”)
gg
使用 Python 访问人口普查数据
公共数据项目
随着 2020 年人口普查的进行和即将到来的选区重新划分，访问和理解公共人口普查数据比以往任何时候都更加重要。这篇文章将指导你使用一个名为 CensusData 的 Python 包将数据导入 Pandas
普查数据集
通过 CensusData 有 5 个数据集可用，包括经典的十年一次的人口普查以及 4 个不同的美国社区调查(ACS)估计。
什么是美国社区调查？
ACS 始于 2005 年，取代了过去每十年与传统人口普查一起发送给家庭子集的长表格人口普查。相反，ACS 是在滚动的基础上进行的，每月发送给大约 350 万个家庭。这个子集然后被用来创建整个人口的估计。ACS 上的问题也更加深入，包括教育、就业和互联网接入等主题。
五个数据集
- *ACS 1 年评估(2012–2018)*针对人口超过 65，000 的地区，更新最频繁，但“分辨率”最低，因为它不包括人口较少的地区，且样本量最小
- *ACS 1 年补充评估(2014–2017)*补充数据集，重点关注 20，000+人口较少的地区
- *ACS 3 年估计值(2010-2012 年至 2011-2013 年)*针对人口超过 20，000 的地区，非常接近 1 至 5 年的中间值。目前由人口普查局打折，但旧版本仍然可以访问。
- *ACS 五年估计值(2005–2009 年至 2014–2018 年)*所有区域的数据，最高分辨率和最大样本量，但最少当前数据
- 2010 年人口普查摘要文件 1 统计美国的每一个居民，每 10 年更新一次。
笔记
- 跨越多年的估计数是总量
- 永远不要比较重叠范围的估计值，例如，比较 ACS 2010–2012 年到 2011–2013 年的 3 年
设置和搜索表格
通过您的终端使用 pip 可以轻松完成安装。
pip install censusdata
现在你可以在人口普查网站上查找你感兴趣的表格，例如这里的是 ACS 的。或者您可以使用 CensusData 的搜索方法
import pandas as pd
import censusdatasample = censusdata.search('acs5', 2015,'concept', 'transportation')
以下是来自文档的搜索参数的详细信息:
- src ( str ) —人口普查数据来源:acs1 年估计数为“ACS 1”，acs5 年估计数为“ACS 5”，acs3 年估计数为“ACS 3”，ACS 1 年补充估计数为“acsse”，sf1 数据为“SF1”。
- 年 ( int ) —数据的年份。
- 字段 ( 字符串 ) —要搜索的字段。
- 标准 ( 字符串 ) —搜索标准。
- tabletype ( str，可选 ) —从中提取变量的表格类型(仅适用于 ACS 数据)。选项包括“详细信息”(详细信息表)、“主题”(主题表)、“配置文件”(数据配置文件表)、“c 配置文件”(比较配置文件表)。
因此，在上面的搜索查询中，我们正在寻找从 2015 年开始的 5 年 ACS 估计值，其中包含“运输”这一概念。现在，这个搜索将返回一个包含变量名、概念和符合搜索标准的标签的三元组列表。这个列表可能相当大。
print(len(sample))>>>3630
让我们详细检查两个第一元组，以理解它们告诉我们什么。
print(sample[0])>>>('B08006_001E', 'B08006\. Sex of Workers by Means of Transportation to Work', 'Total:')print(sample[2])>>>('B08006_002E', 'B08006\. Sex of Workers by Means of Transportation to Work', 'Car, truck, or van:')
第一个元素是变量名，包含两个元素，父表和子表名称。两个条目共享同一个父表‘b 08006’，它对应于第二个元素概念，‘b 08006。上班交通工具上的工人性别。最后一个元素是对应于它们的子表的标签。
打印表格和查找地理位置
一旦知道了感兴趣的父表，就可以使用 print table 命令清楚地读出所有子表。
censusdata.printtable(censusdata.censustable('acs5', 2015, 'B23025'))
包含在图像中，因为它不适合介质格式
为了下载一些人口普查数据，您需要的最后一部分是您感兴趣的地区的地理代码。我们可以使用地理方法来探索这些信息。
states = censusdata.geographies(censusdata.censusgeo([('state', '*')]), 'acs5', 2015)
该查询将返回一个 dictionary 对象，其中每个键都是一个州的名称。下面是前两个元素的示例。
{'Alabama': censusgeo((('state', '01'),)),
'Alaska': censusgeo((('state', '02'),))}
因此，为了找到纽约的代码，我们需要打印相应的值。
print(states['New York']
>>>Summary level: 040, state:36
我们感兴趣的是第二个值 36，它可以用来获取该州的所有县代码。
counties = censusdata.geographies(censusdata.censusgeo([('state', '36'), ('county', '*')]), 'acs5', 2015)print(counties)
>>>Summary level: 040, state:36
{'Queens County, New York':
censusgeo((('state', '36'), ('county', '081'))),
'Rensselaer County, New York':
censusgeo((('state', '36'), ('county', '083'))),
'Richmond County, New York':
censusgeo((('state', '36'), ('county', '085'))),
...}
下载数据
现在我们已经拥有了下载第一组人口普查数据所需的一切！
data = censusdata.download('acs5', 2015,
censusdata.censusgeo([('state', '36'),
('county', '081'),
('block group', '*')]),
['B23025_001E', 'B23025_002E', 'B23025_003E',
'B23025_004E', 'B23025_005E',
'B23025_006E', 'B23025_007E'])
该查询将把请求的数据存储为 Pandas 数据帧，可以使用标准的 Pandas 方法访问该数据帧。
print(data.head)
恭喜你！你已经正式访问了公开的美国人口普查数据。
参考资料:
https://jtleider.github.io/censusdata/
https://www.census.gov/en.html
冠状病毒测试的准确性
你如何衡量冠状病毒测试的可靠性？
在我最近阅读的一篇文章中写道，
“研究人员发现，在研究组的 167-3%的患者中，有 5 名患者进行了胸部 CT 扫描特征提示新冠肺炎，通过 RT-PCR 初步检测为 SARS -CoV-2 感染阴性。”—医药网
幸运的是，测试假阴性的患者被隔离，重复测试帮助他们确认他们患有新冠肺炎(新型冠状病毒感染)。那么假阴性是什么意思？医学研究人员如何衡量这些测试的准确性？
迪米特里·卡拉斯泰列夫在 Unsplash 上的照片
在科学领域，有几种方法可以评估测试的可靠性。一些最常见的指标被称为“准确度”、“精密度”、“灵敏度(召回)”和“特异性”。这些是优化测试可靠性的一些最常用的指标。在我们深入研究一个科学家如何衡量医学测试可靠性的虚构例子之前，让我们先了解一下混淆矩阵的基础知识。
混淆矩阵
混淆矩阵是一个表格，用于分类一个测试是否准确。这张桌子被分成四个格子——
- 一项测试可以准确预测一个人是否患有冠状病毒(TP)
- 一项测试可以准确预测这个人是否没有冠状病毒(TN)
- 一项测试错误地预测一个人是否患有冠状病毒(FP)
- 一项测试会错误地预测一个人是否没有冠状病毒(FN)。下面是一幅插图
让我们继续这个例子…
如果您有一个 1000 人的随机样本来测试您的冠状病毒测试的可靠性，并且 100 人(10%)患有冠状病毒，您希望优化什么指标？错误预测的代价是什么？这是所有医学研究者都必须经历的一些问题。随着这些测试变得越来越普遍，我相信了解这些测试是如何工作的是很重要的。越来越多的人将参加考试，我们将开始在新闻文章中看到错误的统计数据，所以我希望这篇文章可以帮助你更多地了解这些考试。
准确(性)
准确性将测试正确预测的所有人除以随机样本中的所有人。这听起来可能是一个很好的指标，但在不平衡的样本中，它可能不是一个很好的指标。例如，如果测试被打破，并预测每个人都没有冠状病毒。它仍然是 90%。
当随机样本有一个平衡组，而您试图预测的目标接近 50%时，此指标更适用。
简单来说，正确答案在样本的所有人中，有多少人的测试显示了正确的结果。
精确
精度将测试正确预测的所有人除以测试结果为阳性的所有人。当样本不平衡时，精确度比准确度更好。
精确帮助你回答，在测试呈阳性的人中，有多少人实际上患有冠状病毒？
敏感性又名回忆
敏感度和召回率是可以互换的，但这两个术语都是经常使用的，所以了解这两个术语是有好处的。敏感性往往伴随着特异性，而回忆则伴随着精确性。该指标将测试正确预测的所有人分为所有冠状病毒携带者。
敏感性/回忆帮助你回答，在患有冠状病毒的人群中，有多少人检测呈阳性？
问自己一个问题:你希望人们认为他们没有冠状病毒，而事实上，他们有吗？告诉一个冠状病毒携带者自己没有的代价是什么？
通常你不得不选择优化精确度或者召回率，因为当你增加一个的时候，通常会减少另一个。反之亦然。看看 Google 的这篇文章:精准 vs 召回。还有其他衡量两种指标协调性的指标，如 F1 分数，但我不会在本文中赘述。
特征
特异性将测试正确预测为健康的所有人除以所有健康的人。
特异性帮助您回答，您希望该测试在多大程度上正确预测一个人没有冠状病毒？
问自己一个问题:你会因为一个错误的测试而隔离自己吗？
总结
这些都是医疗决策者必须自问的重要问题。我不确定是否所有的医学测试都是完美的，所以如果你开始看到关于这些测试如何不正确工作的新闻。回头看看这篇文章，试着猜测医学研究者试图优化什么。如果我是一名医生，我会认为回忆是最重要的一项，即使我们必须以假阳性为代价来优化这一指标——假检测结果告诉一些健康人他们患有冠状病毒。此外，新闻文章将开始报道准确的数字。确保通过自己做一些研究来了解这些测试的可靠性。
希望你能带走一些有用的信息。
如果您有任何问题或反馈，请随时在下面留下您的问题或反馈，或者在 LinkedIn 上联系我。
中:https://medium.com/@测试学习
领英:【https://www.linkedin.com/in/kennyk1m/
资源
新型冠状病毒的新病例在全球范围内持续增加，截至 2014 年，全球已确诊 73，332 例新冠肺炎病例
www.medicinenet.com](https://www.medicinenet.com/script/main/art.asp?articlekey=228250) [## 分类:精度和召回|机器学习速成班
预计时间:9 分钟精度试图回答以下问题:什么比例的积极…
developers.google.com](https://developers.google.com/machine-learning/crash-course/classification/precision-and-recall)
编者按: 走向数据科学 是一份以数据科学和机器学习研究为主的中型刊物。我们不是健康专家或流行病学家，本文的观点不应被解释为专业建议。想了解更多关于疫情冠状病毒的信息，可以点击 这里 。
深度学习中的准确性可视化—第 1 部分
内部 AI
张量板是最强大的开箱即用工具之一，可用于模型性能可视化和焦点优化调整。
深度学习模型性能可视化(文章中描述的代码的输出)
“一个眼神胜过千言万语。”
我们都想以最优的方式训练深度学习模型，提高哪怕是预测精度的最后两位小数。我们在深度学习模型中有如此多的参数要调整，从优化器及其参数、激活函数、层数/过滤器等开始。找到所有这些参数的正确组合就像大海捞针。
幸运的是，我们可以利用超参数来调整模型的性能和准确性，但是我们需要对参数组合有一个广义的理解来尝试和测试。
Tensor board 是最强大的内置工具之一，可用于基于不同指标可视化单个模型的性能，也可用于不同模型之间的比较。它可以指导确定我们可以进一步尝试超参数调整的大概参数组合。
在这篇文章中，我将讨论深度学习模型可视化，结合优化器和简单回归的激活函数。它将使我们能够了解如何快速丢弃不合适的组合，并将我们的性能调优工作集中在几个潜在的参数上。
第一步: 我们将使用Scikit learnmake _ regression 方法生成一个用于回归测试的随机数据集，并使用 train_test_split 将数据集分成训练集和测试集。
from sklearn.datasets import make_regression
from sklearn.model_selection import train_test_split
第二步: 在下面的代码中，我们导入了张量板和深度学习 Keras 包。我们将使用 Keras 建模和张量板可视化。
from tensorflow.keras.callbacks import TensorBoard
from keras.models import Sequential
from keras.layers import Dense
第三步: 在本文中，我们将使用“adam”和“RMSprop”优化器，以及“GlorotUniform”和“normal”权重初始化器。我们在列表中提到了这些，并将按顺序调用组合来训练模型。
optimizers=["adam","RMSprop"] #Optimisers
initializers=["GlorotUniform","normal"] # Activation function
**第五步:**在下面的代码中，我们嵌套了 FOR 循环，用优化器和权重初始化器的不同组合来训练深度学习模型，并将结果记录在张量板中进行分析。
每个模型都用权重初始化器和优化器名称命名，以识别每个模型的结果和图形。
由于本文的主要目标是学习深度学习模型结果的可视化，因此我们将使用一个非常简单的模型，该模型具有一个输入、隐藏和输出层。
我们将使用均方误差作为所有模型的损失函数，并测量平均绝对百分比误差。如果你不知道这些统计指标，那么我建议你参考维基百科获得详细的解释。
步骤 6: 我们可以在代码执行后查看结果并进行分析。我们需要在 windows 中打开命令提示符或者在 mac 中打开终端来启动张量板。通过命令提示符/终端导航到保存日志的文件夹目录，然后键入以下命令。
tensorboard --logdir=logs/
它将实例化张量板，并显示我们需要在浏览器中输入的地址，以查看结果。
张量板登录页面
在当前示例中，我们可以通过在浏览器中键入 http://localhost:6006/ 来访问张量板。
在一个合并图中，我们可以看到随着优化器和权重初始化器的不同组合的迭代次数的增加，均方误差的变化。
不同模型的每个时期的损失值
它指示不适合当前数据集和建模的优化器和权重初始化器。在当前示例中,“RMSprop”和“normal”优化器组合的均方损失下降速度比其他组合慢。基于这种来自观想的知识，我们可以集中精力微调剩余的组合，通过不调整在广泛层面上表现不好的组合来节省时间。
同样，随着迭代次数的增加，我们可以查看不同组合的平均绝对百分比误差的变化。
不同模型的每个历元的平均绝对百分比误差值
基于型号名称的过滤器选项
我们还可以使用过滤器来查看一个或多个模型组合的图表。
给模型起一个有意义的名字是很重要的，因为它有助于正确放置过滤器，避免分析过程中的混淆。在当前示例中，权重初始化器和优化器的组合是模型的名称。
为一个模型过滤的每个历元的损失值
我们也可以下载图形，损失函数数据分别为 SVG 和 CSV 格式。CSV 格式的损失函数数据使我们能够使用 excel 快速执行高级分析。
下载图表和数据的选项
除了根据时代进展可视化结果之外，我们还可以通过单击鼠标来查看模型的相对性能。
每个时期的损失值相对比较
在本文中，我们已经学习了张量板的基础知识，并看到了一些可视化选项，可用于在瞬间掌握不同模型的更好的细节。我们还看到了我们可以使用张量板可视化来专注于微调潜在模型的方式。在下一篇文章中，我们将看到一些深度学习模型的高级可视化。
如果你想学习可视化的探索性数据分析(EDA)，请阅读文章 5 探索性数据分析(EDA)的高级可视化
如果你像我一样是熊猫的忠实粉丝，那么你会发现文章 5 熊猫数据预处理的强大可视化读起来很有趣。
准确性可视化:监督机器学习分类算法
内部 AI
分类算法结果的可视化报告提供了错误分类和准确度估计的快照。更快地解释和规避一般的准确性分数陷阱。
测量任何回归或分类算法的预测准确性在建模期间的不同阶段都至关重要，当模型在生产中运行时也是如此。
我们有几种方法来衡量分类算法的准确性。在Scikit-learn包中，我们有几个评分，比如召回评分，准确率评分等等。然后我们有现成的总结报告。在我看来，这些指标中的大多数都有一个或多个与冗长相关的限制，难以理解，在数据集中的不平衡类别的情况下，有可能误解准确性，需要引用少量分数来获得整体视图等。
为了更好地理解这种限制，让我们考虑一下表中所示的例子。我们几乎没有与样本人群以及他们是否为 COVID 阳性相关的参数。因为我们有更多的人是 COVID 阴性，而不是病毒感染者，因此，我在这个例子中考虑了类似的分布。
用于解释的假想样本数据
在此数据集上训练的分类算法预测了最后一列中所示的结果。分类模型的准确率接近 90%。它给我们的印象是，该模型在预测结果方面相当不错。
from sklearn.metrics import recall_score
from sklearn.metrics import classification_report
from sklearn.metrics import accuracy_score# 0- Healthy , 1- Covidy_true = [0, 1, 0,0,0, 1,0,0,0,0,0]
y_pred = [0, 0, 0,0,0, 1,0,0,0,0,0]print("The recall Score is" , recall_score(y_true, y_pred))
print("The accurracy score is" , accuracy_score(y_true, y_pred))
实际上，该模型预测 COVID 阳性病例的概率只有 50%。仅基于一个度量或者在不了解分类模型出错的领域的情况下部署这样的模型可能是非常昂贵的。
在考虑了召回率和准确率以及业务用例之后，我们可以充分理解适合生产使用的模型。
像混淆矩阵这样的视觉指标在几个方面胜过其他指标。我们可以即时了解模型在分类方面的性能，以及模型的优势和需要微调的方面。基于业务用例，我们可以从假阳性、假阴性、真阳性和真阴性计数中快速判断模型是否准备好进行部署。
让我们学习用混淆矩阵来形象化和解释线性回归和逻辑回归的结果。
步骤 1: 我们将使用本文中的 Scikit - learn 内置数据集 WINE 进行讨论，使用 Matplotlib 进行可视化。在下面的代码中，我们导入了将在程序中使用的模块。
from sklearn.datasets import load_wine
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.svm import LinearSVC
import matplotlib.pyplot as plt
from sklearn.metrics import plot_confusion_matrix
*第二步:*将葡萄酒数据集中的特征(属性)分为自变量和因变量。自变量(输入特征)用“X”表示，因变量用“y”表示。使用 train_test_split 方法分为训练集和测试集。
X,y = load_wine(return_X_y=True)X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.10,random_state=0)
*第三步:*sklearn 中的大多数监督算法需要以零为中心的标准正态分布输入数据，并且具有相同数量级的方差。由于葡萄酒数据集中的独立变量值具有不同的比例，因此我们需要在建模之前对其进行缩放。
如果你想了解更多关于Scikit-Learn包中自变量和不同定标器的定标，那么请参考我的文章Feature Scaling-Effect Of Dive Dive Dive Dive。
SC_X=StandardScaler()
X_train_Scaled=SC_X.fit_transform(X_train)
X_test=Scaled=SC_X.transform(X_test)
*第 4 步:*在下面的代码中，定义了一个带有参数的分类器列表
classifiers=[ LinearSVC(dual=False),LogisticRegression(solver="liblinear",max_iter=100)]
*第五步:*用每个分类器依次训练模型，根据训练集中实际和预测的因变量值绘制混淆矩阵。
for clf in classifiers:
clf.fit(X_train, y_train)
y_pred = clf.predict(X_test)
fig=plot_confusion_matrix(clf, X_test, y_test, display_labels=["Bad Wine","Fair Wine","Good Wine"])
fig.figure_.suptitle("Confusion Matrix for " + str(clf))
plt.show()
乍一看，我们可以看到，与逻辑回归相比，线性 SVC 中从左上角到右下角对角线的数字总和更高。这立即表明线性 SVC 在识别真正的阳性记录方面表现得更好。
基于文中讨论的代码的混淆矩阵
不同的度量分数可以指示准确性，但是使用混淆矩阵，我们可以立即看到算法错误分类的类别。在当前的例子中，两个分类器都没有准确地对大多数劣质酒进行分类。这种详细程度的信息有助于执行模型的焦点微调。
我们已经看到，混淆矩阵以一种清晰的方式提供了关于不同类别的分类模型预测模式的更好的细节。在单个混淆矩阵中，我们可以获得假警报(假阳性)和正确拒绝率等细节，并根据业务案例决定模型是否可接受。
使用 BERT 精确标注主观问答内容
关于 Kaggle 问答理解竞赛第六名解决方案的 NLP 教程
来源:https://www.kaggle.com/c/google-quest-challenge/overview
介绍
Kaggle 在 2020 年初发布了 Q & A 理解比赛。该竞赛要求每个团队构建 NLP 模型来预测问题和答案对的主观评分。我们在所有 1571 支队伍中名列第六。除了在 Kaggle 上发布的获胜解决方案博客之外，我们还写了这个更适合初学者的教程来介绍比赛以及我们是如何赢得金牌的。我们也在这个 Github 仓库中开源我们的代码。你也可以在我的博客里找到这篇文章。
数据
比赛从 70 个栈溢出式网站收集问题和答案对，问题标题，正文和答案作为文本特征，还有一些其他特征，如 url，用户 id。目标标签是 30 个维度，值在 0 到 1 之间，用于评估问题和回答，如问题是否重要，回答是否有帮助等。评分者接受的指导和培训很少，目标很大程度上依赖于他们的主观解释。换句话说，目标分数只是来自评分者的常识。目标变量是对多个评价人的分类进行平均的结果。也就是说，如果有四个评定者，一个将其归类为正面，另三个归类为负面，则目标值将为 0.25。
下面是这个问题的一个例子
- 问题标题 : 用伸缩管代替微距镜头，我损失了什么？
- 问题正文 : 在玩了便宜的微距摄影之后(阅读:反转镜头，安装在直镜头上的反转镜头，被动伸缩管)，我想进一步了解这一点。关于……的问题
- 回答 : 我刚买了延长管，所以瘦子来了。…使用试管时，我失去了什么…？相当多的光！增加镜头末端到传感器的距离……
训练集和测试集分布如下
评估指标
本次比赛采用斯皮尔曼等级相关系数作为评价指标。
直观上，皮尔逊相关是 X 和 Y 的线性相关的度量，对于斯皮尔曼的秩相关，我们不使用 X 和 Y 的值，而是在公式中使用 X 和 Y 的秩。它是 X 和 y 之间单调关系的度量。如图所示，图表中给出的数据，pearson 为 0.88，spearman 为 1。
为什么这次 kaggle 比赛要用 spearman？考虑到标签的主观和噪声性质，Spearman 相关往往对异常值更稳健，例如 pearson 相关。还因为目标值是基于评分者常识的问答理解。假设我们有 3 个答案，我们评估这些答案是否写得很好。答案 A 得分 0.5，答案 B 得分 0.2，答案 C 得分 0.1，如果我们宣称答案 A 比答案 B 好 0.3，有意义吗？不完全是。在这里，我们不需要精确的值差。知道 A 优于 B and B 优于 c 就足够了
来源:https://en . Wikipedia . org/wiki/Spearman % 27s _ rank _ correlation _ coefficient
NLP 管道
(图片作者)
一般的 NLP 管道如上图所示。典型的非基于神经网络的解决方案可能是:
- 使用 TF-IDF 或单词嵌入来获得基于令牌的向量表示
- 将标记向量平均为获取文档向量表示
- 使用随机森林或 lightGBM 作为分类器或回归器
由于 2017 年和 2018 年 transformer 和 BERT 的出现，NLP 一直在经历一个“ImageNet”时刻。BERT 已经成为 NLP 竞赛的主要算法。在这个博客中，我们不介绍伯特。这里有这里有，这里有这里有，这里有这里有等几个不错的教程。
现在，我们可以使用 BERT 来重构 NLP 管道:
- 使用 BERT 单词块标记器生成(子)单词标记
- 从 BERT 生成每个令牌的嵌入向量
- 通过神经网络池层对令牌向量进行平均
- 使用前馈层作为分类器或回归器
金牌解决方案
整体情况
如下图所示，我们使用四个基于 BERT 的模型和一个通用句子编码器模型作为基础模型，然后将它们堆叠起来生成最终结果。在这篇博客的剩余部分，我们将只关注 transformer/BERT 模型。关于通用语句编码器的更多信息，可以访问原文这里，代码可从这里获得。
(图片作者)
基于 BERT 模型的体系结构
下面的动画展示了一个基本模型的工作原理。这里的代码是这里是。
- 问题标题和问题正文连接在一起作为输入。使用 BERT 记号化器得到子词，然后生成 BERT 嵌入。接着是平均池层，我们得到每个问题标题和正文对的向量表示。注意，我们对非屏蔽令牌的令牌嵌入进行了平均。这是我们与普通方法不同的地方，在交叉验证方面做了一点改进。附加其他分类或数字要素，然后通过格鲁激活和缺失与线性图层连接。
- 类似地，我们有一个镜像结构，问题标题和答案对作为输入。我们有两个选择。如果镜像 BERT 模型可以分担第一个 BERT 模型的权重，我们称之为“连体”结构。它也可以使用单独的重量，那么我们称之为“双”结构。连体结构通常具有更少的参数和更好的泛化能力。我们对连体和双结构进行了实验，并根据交叉验证分数选择了最佳的 N 基模型。
- 上述两种结构的输出被连接，并连接到前向层，以获得 30 维目标值的预测。
Huggingface 打包了大多数最新的 NLP 模型 Pytorch 实现。在我们的解决方案中，选择了 4 个由 Huggingface 实现的基于 BERT 的模型。分别是暹罗罗伯塔基地，暹罗 XLNet 基地，双阿尔伯特基地 V2，暹罗伯特基地 uncased。
(图片作者)
培训和实验设置
我们有两个阶段的训练。阶段 1 是端到端的参数调优，阶段 2 只调“头”。
在第一阶段:
- 用 huggingface AdamW optimiser 训练 4 个时代。这里的代码是这里的
- 二元交叉熵损失。
- 单周期 LR 计划。使用余弦预热，然后是余弦衰减，同时具有动量的镜像时间表(即余弦衰减后是余弦预热)。这里的代码是这里的
- 回归头的最大 LR 为 1e-3，变压器主干的最大 LR 为 1e-5。
- 累计批量为 8
在第二阶段:
- 冻结变压器主干，并以 1e-5 的恒定 LR 微调回归头额外 5 个周期。这里的代码是这里的
- 大多数型号的 CV 增加了约 0.002。
堆垛
堆叠是卡格勒人“事实上”的集体策略。下面的动画演示了训练和预测过程。示例中有 3 个折叠。为了获得每个折叠的元训练数据，我们对 2 个折叠进行迭代训练，并对剩余的折叠进行预测。并且整个非折叠预测被用作特征。然后，我们训练堆叠模型。
在预测阶段，我们将测试数据输入到所有非折叠基础模型中以获得预测。然后，我们对结果进行平均，传递到堆叠模型以获得最终预测。
(图片作者)
(图片作者)
其他技巧
分组文件夹
让我们先来看看为什么普通的 KFold split 在这个比赛中效果不好。在数据集中，一些样本是从一个问答线程中收集的，这意味着多个样本共享相同的问题标题和正文，但答案不同。
如果我们使用正常的 KFold split 函数，对相同问题的回答将分布在训练集和测试集中。这会带来一个信息泄露的问题。更好的拆分是将同一问题的所有问题/答案对放在一起，放在训练集或测试集中。
幸运的是，sk-learn 已经提供了一个函数 GroupKFold 来生成不重叠的组进行交叉验证。问题体字段是用来表示分组的，如下面的代码。
后处理
正如许多其他团队所做的那样，一个后处理步骤对性能有着巨大的影响。总的想法是基于向下舍入预测到某个分数 1/d 的倍数。
因此，如果 d=4，x = [0.12，0.3，0.31，0.24，0.7]，这些值将被舍入为[0.0，0.25，0.25，0.0，0.5]。对于每个目标列，我们在[4，8，16，32，64，None]中对 d 值进行网格搜索。
在我们的集合中，我们进一步开发了这种技术，首先对单个模型预测应用舍入，然后再对模型预测进行线性组合。在这样做的过程中，我们确实发现，对每个模型使用单独的舍入参数，超出倍数的分数提高将不再转化为排行榜。我们通过在所有模型中使用相同的 d_local 来减少舍入参数的数量，从而解决了这一问题:
所有集合参数(2 个舍入参数和模型权重)都是使用小网格搜索设置的，该搜索优化了出折叠的 spearman 等级相关系数度量，同时忽略了具有重复问题的行的问题目标。最终，这种后处理将我们的 10 倍组折叠 CV 提高了约 0.05。
孙喆，罗宾·尼塞特，艾哈迈德·艾尔丹姆和覃晶
ace FAANG 系统设计面试
艾萨克·史密斯在 Unsplash 上拍摄的照片
(这个帖子也在我的博客里)
如今，系统设计在技术面试中很常见。如果编码面试验证编码的能力，那么系统设计面试验证构建的能力。它验证候选人是否能够构建一个能够大规模运行和容错的系统。有很多很棒的资源，比如探索系统设计或设计数据密集型应用，它们为您提供了关于系统设计最佳实践的很棒的例子和细节。但是在我与许多人交谈后，我感觉他们中的许多人倾向于记住每个例子的答案。因此，我发现写下这些经验法则的总结对你在真正的面试中做出反应是至关重要的。以下是我的总结。
隐藏物
缓存解决什么问题？
对硬盘等永久性存储设备的访问速度很慢。在需要频繁读取数据库或文件的应用中，性能瓶颈通常来自于对磁盘的访问速度。因此，我们倾向于将频繁访问的数据添加到内存中，因为访问内存要快得多。
有什么限制？
- 内存通常不足以容纳整个数据集。因此，应用程序开发人员需要有选择地将数据子集保存在缓存中
- 如果失去动力，记忆也就失去了
什么时候不应该使用缓存？
如果数据写入量很大，不要使用它，因为如果您需要一致的结果，缓存将在每次写入操作中失效。这使得性能更差？
批量写入
如果应用程序写得太多会怎么样？
我们知道如何减少在应用程序和永久存储之间添加缓存的读取。对于写入，我们可以批处理写入操作，并且一次性完成。例如，我们可以跟踪内存中的所有写操作，并在发生 100 次写操作时应用它们。
代价是读数不会一致。紧随写操作之后的读操作可能无法获得最新更新。
分片
什么是碎片？
它本质上是将数据分成不同的分区。这有助于跨不同机器扩展数据库，以提高可伸缩性、性能、可用性等。
可用性/冗余
在设计系统时，通常会复制每个组件，如应用服务器、数据库等。这确保了没有单点故障。它通过增加冗余大大提高了可用性。
负载平衡器
我们引入冗余组件来避免单点故障。同时，多台机器可以分担请求的负载。我们应该如何将请求分发到不同的服务器？这是负载平衡器的职责。它通常位于客户机和服务器之间。它将请求从客户端路由到服务器，以确保所有服务器都有相同的负载量。负载均衡器中可以使用很多算法，如循环法、最少连接法、最少响应时间法等。
SQL 与 NoSQL
SQL 和 NoSQL 数据库在数据存储方式上有很大不同。在 SQL 中，数据模型是关系型的，这意味着所有行都有相同的列/属性。而 NoSQL 有非常灵活的模式。每个文档可以有不同的属性。
关于一致性还有一个很大的区别。SQL 支持强一致性。这意味着所有数据库节点同时拥有相同的数据副本，而 NoSQL 大多支持最终一致性。这意味着对数据库节点的写入是异步的。它不能保证所有节点在给定时间都有相同的数据。但最终，所有节点都将进行所有写入更新。这也使得 NoSQL 在许多情况下更加高效。
在 Grokking 系统设计中有更深入的细节 SQL vs. NoSQL 和 CAP 定理。
最后，我希望这个总结可以帮助你在面试和工作中获得建立系统的想法。
以前的帖子:
我如何选择了 6 个月的代码并获得了 FAANG offer
Ace FAANG 系统设计面试:数据库、NoSQL、SQL
从 CRUD web 应用开发到语音助手中的 SDE——我正在进行的机器学习之旅
全栈开发教程:将 AWS Lambda 无服务器服务集成到 Angular SPA 中
全栈开发教程:用运行在 AWS Lambda 上的无服务器 REST API 提供交易数据
面试高手:卡方检验
这个技术面试问题不会再难倒你了。
阿格尼耶斯卡·科瓦尔茨克在 Unsplash 上拍摄的照片
这一切都是在我练习技术面试题的时候开始的。我作为数据科学硕士学生的第一个学期结束了，带着甜蜜的宽慰，我参加了一个简短的(但值得尊敬的)网飞·本德，然后转入技术面试准备。我很自信。甚至自大。就像刚刚拯救了银河系还很酷的韩·索罗。
GIPHY 的 Gif
哦，那种骄傲自大很快就要消失了。
吸气≤≥排汗💦
技术面试官:“给定所附数据表，确定健身水平和吸烟习惯之间是否存在关系。”
来源:资料面试问题(推荐免费简讯)
**我的大脑:**蟋蟀
当我通过我的分段统计知识寻找答案时，我的心怦怦直跳。回归还是分散？*但是轴心是什么呢？*逻辑回归涉及分类变量… 但这也没有意义。
也就没有分散，因为我就是那个分散注意力的人。我新获得的自信开始融化得比沥青上的冰淇淋甜筒还快。
我可能在举手之前盯着这个问题看了 20 分钟，所以如果你放弃(或以某种方式回答)得比这个快，那就恭喜你了。如果这是一个真正的技术面试，我知道我会面对种植硬核。现在让我们来讨论一下这个问题的答案，以防你看了之后和我一样被难倒。
“正确”的方法
Pearson 的卡方检验用于确定来自单一总体的两个分类变量之间是否存在显著关联。
这是其中一次，如果你不知道具体的测试使用，强硬的饼干，我只是不知道用什么，因为没有班级(还)教过我。
事实证明，当你有两个分类变量时，假设检验实际上也很容易——或者我应该说 chi (请原谅这个糟糕的双关语)。皮尔逊卡方检验用于确定来自单一人群的两个分类变量之间是否存在显著关联。
要查看这两个分类值是否相互关联，我们所要做的就是使用这个单一测试。有了这些知识，让我们再回到这张图:
来源:资料面试问题
分析
根据该图，我们可以看到分类变量是 **(1)吸烟水平和(2)健康水平。**我们将使用皮尔逊卡方检验来确定它们之间是否存在显著的关联。像往常一样，我们首先制定一个无效和替代假设，并设置我们的显著性水平:
(1)假设
- 卡方下为空- 这两个变量相互独立。
- 卡方下的替代- 这两个变量是而不是相互独立的。
(2)显著性水平
- α = 0.05 (业界蛮标准的；0.01 或 0.1 也是常见的取值)。
如果 p 值小于0.05，我们将拒绝零假设，支持替代方案(吸烟和健康水平显著相关)。如果 p 值大于 0.05，基于我们的分析结果，我们将无法拒绝零(吸烟不影响健康水平，反之亦然)。
(3) R 代码
结果
在 0.05 的标准显著性水平下，我们发现 p 值非常显著(在 R 中给出为 6.339e-11，在人类语言中翻译为. 00000000006339)。基于此，我们可以拒绝空的而支持另一种选择——在这种情况下，健康水平和吸烟似乎确实相关。
就这样，面试问题被 a 了。
GIPHY 的 Gif
最后，如果你想更深入地探究卡方的数学解释，我发现这些网站(这里和这里)非常有帮助。
结论
非常感谢你今天阅读了我这篇以星球大战为主题的小文章。如果你目前也在数据科学求职的广泛过程中导航，如果你最近找到了你的梦想工作，或者如果你只是所有数据驱动的事物的偶然观察者，请让我知道。
(如果你是一名人力资源经理，想招聘一名年轻、机智的初级数据科学家，你可以在作者简历中找到我的 LinkedIn😉)
这本书里的 5 个技巧改变了我研究数据科学的方式，并启发了我成为一名中型作家的旅程。
towardsdatascience.com](/read-this-book-to-snag-your-first-data-science-job-553fd301d00a) [## 我是如何进入 12 个数据科学硕士项目的
SOP，统计数据，所有的东西。
towardsdatascience.com](/how-i-got-into-12-data-science-masters-1eeddae21ba7)
参考文献
[1]资料面试问题:【https://www.interviewqs.com/?ref=ddi_email
[2]R 中独立性的卡方检验:http://www . sth da . com/English/wiki/Chi-Square-Test-of-independency-in-R # compute-Chi-Square-Test-in-R
[3] R data.table 文档:https://cran . R-project . org/web/packages/data . table/vignettes/datatable-intro . html
[4]独立性卡方检验:http://www . r-tutor . com/elementary-statistics/good-fit/卡方检验-独立性
[5]卡方统计:如何计算/分布:https://www . statisticshowto . com/probability-and-statistics/卡方/
在不到 10 分钟的时间内通过 SQL 数据科学面试
SQL 面试通常令人望而生畏，因为大多数人不知道如何准备。在这篇文章中，我强调了我在面试中遇到的最常见的问题，并给出了一些如何做好准备的建议。
大多数数据科学家的职位招聘都需要 SQL 技能。大多数公司，尤其是大公司(谷歌、脸书……)在他们的流程中至少有一次以 SQL 为中心的面试。学校很少教授 SQL，知道准备什么可能很有挑战性。在这篇文章中，我希望给出在这些过程中可能会被问到的大多数问题的答案。
不同类型的连接
当数据存储在不同的表中时，以最合适的方式将它们重新连接在一起可能会很棘手。最常见的 SQL 问题试图评估您对左/右/内/外连接之间的区别的理解。下图总结了每种连接类型之间的差异:
典型图表突出显示了来自 Wikimedia 上 Arbeck 的左/右/内/外连接
存在额外的连接，这非常有用。至关重要的是:
- **交叉连接:**这将允许你做每个表的叉积(即可能有助于生成一个所有可能结果的表)。这种连接不需要连接条件。人们可以简单地在 FROM 语句中提到多个关系。
- **自连接:**有时候连接一个表本身可能会有帮助，特别是当一个表中的行之间有关系的时候。例如，为了计算滚动平均值，或者如果我们有一个特定事件的多个实例，我们可以找到第一个事件之后发生的所有事件(在 WHERE 语句中使用一个附加子句)。为此，我们可以像往常一样执行一个连接，但是为两个表提供不同的别名(使用 as)。
If 语句
在 select 子句中，使用“filter”或 if 语句来确定某些值可能会有所帮助。
为此，我们声明一个 CASE 语句。发生这种情况时，每个子句都需要用一个分隔(使用任何条件运算符)，然后是这个值，并且可能包含一个 ELSE 子句来提供一个默认/回退值。最后，我们用 end 语句结束 CASE 语句。
这可以让您避免许多不必要的子查询，并且对于为您的聚合函数创建自定义组可能特别有帮助(见下文)。
聚合函数
通常，您可能需要将一些数据聚合到组/汇总统计数据中。要计算汇总统计数据，您可以使用任何聚合函数，例如:
-COUNT
-SUM
-AVG
-MAX
-MIN
GROUP BY 允许将数据分成不同的组，并分别聚合这些组。面试官很可能会问这些功能，所以一定要牢牢掌握如何使用它们。
使用 GROUP BY 函数时，SELECT 子句的所有元素必须是聚合函数或 GROUP BY 子句之一。
此外，正如在面试中经常被问到的:WHERE 子句可以同时使用，并有助于在聚合之前过滤数据**。相反，HAVING 子句有助于在聚合之后过滤数据。因此，它们可以同时使用并具有不同的用途。**
数据类型
为了欺骗你，面试官可能会给你一些不能直接操作的数据类型。例如，他们可能会给你一个字符串格式的日期表，并要求你过滤过去的一周。为此，您首先需要将数据类型转换为“日期”。
为此，您有两种方法:
- 您可以使用 CAST 函数来(即 CAST(column_name AS integer))
- 使用::语法(即 column_name::integer))
最常见的数据类型有:
- VARCHAR
-文本
-时间戳
-整数
-浮点
-双精度
-布尔
窗口功能
滚动窗口通常被认为是一个高级的 SQL 主题，但它将真正有助于展示 SQL 掌握的深度。它们有助于大大简化查询，并允许在一组指定的行中执行计算(符合分区)。要使用滚动窗口，可以用 OVER 命令实例化窗口。可以使用 PARTITION 子句将滚动窗口分成不同的组，并且可以使用括号和 ORDER BY 子句以特定的顺序运行。
使用 BETWEEN … AND …ROW 和 ROWS … PRECEDING 这样的子句，可以进一步定制窗口函数并使它们适应任何用例。
因此，例如，使用 ROW_NUMBER()函数来计算行数以及分区和排序依据的组合，就可以非常容易地计算可能变得非常复杂的子查询数(即计算移动平均值)。
-使用和不使用窗口功能如何计算累计和
-使用和不使用窗口功能计算 7 天滚动平均值
如需更深入的了解，请务必查看窗口功能 上的 模式分析指南。
其他需要了解的功能:
字符串函数
- TRIM:从字符串中删除尾随(RTRIM)和前导(LTRIM)空格
- SUBSTR:在一个较长的字符串中选择一个子字符串
- LOWER/UPPER:将整个字符串转换为小写或大写。
- CONCAT:允许将多个字符串连接成一个字符串
- COALESCE:返回 colulmn 中的第一个非空值(通常用于将具有各种空值的列“合并”到一个充满值的列中)
- LIKE:允许查找符合特定模式的字符串(可以使用“%”操作符来匹配任意数量的字符，或者使用“_”来匹配单个字符)。请不要忘记它是区分大小写的，一些数据库管理系统可能允许 ILIKE 作为不区分大小写的替代(否则使用 LOWER/UPPER)
- 包含:允许查找包含特定子字符串的字符串
日期功能
- NOW():返回当前日期/时间
- CURRENT_DATE():返回当前日期
- DATE_ADD/DATE_SUB:允许从指定的时间间隔计算日期/时间(类似于 python 的时间增量)
- 月/年/日/工作日:从一个日期返回月/年/日/工作日
数学运算
- ROUND:按要求的小数位数对数字进行舍入
- ABS:返回浮点/整数的绝对值
- MOD:返回除法的余数
- SIGN:如果参数为正，则返回 1；如果参数为 0，则返回 0；否则返回-1
- SQRT:返回一个值的平方根
- FLOOR/CEIL:返回参数中最接近的向下/向上整数
- POWER:返回第一个参数的第二次幂
其他
- NULLIF:如果两个参数的值相等，则返回 NULL
- 如果第一个参数为空，则返回一个特定的表达式
- EXISTS:检查是否存在非空值。
- IN:检查值列表中是否存在给定值。
- RANK:窗口函数，为结果集分区中的每一行给出一个等级(通常使用 ROW_NUMBER 更简单
需要了解的其他事实:
-如果你用 NULL 做任何数学运算，你还是有 NULL。
-要在查询中获得唯一的值，请在 SELECT 子句中使用 DISTINCT 关键字(也要知道这会明显降低查询速度)。
-默认情况下，除非另有规定，ORDER BY 以 ASC 顺序执行。
SQL 资源仍然相对分散在互联网上，很容易陷入过于复杂材料的陷阱。初级水平的大多数数据科学家职位/面试所需的 SQL 知识通常仍然非常基础，足以掌握绝大多数角色的基础/中介功能。
我强烈推荐从模式开始的奇妙课程，供用户寻找最基本/中级 SQL 功能的更全面指南。为了更多的实践，请随意查看 HackerRank 的专用 SQL 子部分。
赢得数据科学工作面试
获得下一份数据科学工作的社会工程技巧
蒂姆·高在 Unsplash 上拍摄的照片
TLDR:
让自己值得信任，以故事的形式回答问题，发一封感谢信，在 LinkedIn 上调查你的面试官。
简介
大多数人认为工作面试的目的是展示你有多棒…这是不正确的；求职面试的目的是展示你有多值得信任。我们可以用进化心理学的视角来理解这一点。在祖先的条件下，评估一个陌生人有多值得信任远比他们有多能干重要。如果我们考虑一下面试过程，基于有限的互动次数和相当有限的信息，他们正试图决定是否要每周花 40 多个小时与你一起工作。建立信任远比展示能力更有价值。
大多数分析师、数据科学家和其他专业技术人员花时间培养他们的硬技能。本文假设你的硬技能对于你要面试的职位来说已经足够了，因此将重点放在与工作面试相关的软技能上。
工作面试是一项技能，就像所有的技能一样，你会通过练习变得更好，如果你最近没有做，就会萎缩。如果你准备好转换角色，我建议你去申请那些你真的不想要，但可能会让你去面试的工作，只是为了在真实的面试环境中练习。在面试一份你真正想要的工作之前，你需要理清头绪。
典型面试流程概述:
虽然具体情况因雇主而异，但我的经验是，大多数地方都遵循一个总体结构来进行面试。
1.第一阶段是电话面试，通常是和招聘人员一起。
2.第二阶段是与招聘经理的面试。
3.第三轮是涉及更多利益相关者的小组访谈。
有时第三轮会持续几天，有时你必须和招聘经理进行两次电话面试，有时没有第三轮。这篇文章中的建议仍然适用。
整个过程中会用到的战术:
用故事的形式回答问题。想出 4-5 个关于你做过的项目或工作的故事，并在 STAR 框架中概括出来。
- 情境:简要地为你的故事搭建舞台
- 任务:你试图解决的具体问题是什么？
- 行动:描述你是如何解决问题的
- 结果:讨论您的解决方案产生的影响。
这是我回答“你最大的优点是什么？”这个问题的真实例子
“由于我的 excel 技能和使用 excel 处理大量数据源的能力，我被聘用到了现在的职位。不幸的是，我需要处理的数据量超出了 Excel 的技术限制。我问公司的其他分析师我应该看什么工具，其中一个推荐 Python。当我开始这项工作时，我不知道如何编程，但在 3 个月内，我已经开始自动化我自己工作流程的大部分，一个月后，我构建了一个应用程序，自动化了一个业务功能，每月需要大约 10 个小时的手动工作。”
分解那个故事:
- 情境:我是一个新角色，受雇使用一项特定的技术。
- 任务:我需要综合数据，但技术不适合这项任务。
- 行动:我学到了一项新技术。
- 结果:在很短的时间内，我向公司交付了一个有价值的自动化产品。
我的问题的答案实际上是我适应能力强，学得快，但这个故事更生动地证明了这一点。
领英研究:
在你面试之前，在 LinkedIn 上找一个你正在面试的人，看看你们是否有任何共同点。也许你们去了同一所学校，或者看看你们是否志愿参加类似的组织。如果他们写了文章或博客并阅读了它们。看看他们分享的内容，了解他们是谁。不要在面试中明确提及他们的 LinkedIn 个人资料，而是将这些信息作为一个镜头来聚焦你的答案。这并不总是有回报，但当它真的有回报时。这个故事展示了:
我在面试一个职位，面试官问我有什么爱好。在我的研究中，我看到他们是一个致力于户外运动的非营利组织的董事会成员。在我的回答中，我告诉他当我可以的时候，我喜欢去远足，几年前我去爬乞力马扎罗山。接下来他告诉我他是如何在乞力马扎罗山山顶向他的妻子求婚的。利用这项研究，我建立了一种融洽的关系，这种关系支撑了整个面试过程。
感谢邮件:
约在任何面试后 24 小时内，发送一封带有以下模板的跟进电子邮件:
亲爱的(你面试过的人)，
我真的很喜欢我们昨天的谈话，我真的很兴奋能在 xyz 公司(在此输入公司名称)探索机会。我特别喜欢讨论(在这里插入你谈论的具体事情)。如果你有任何问题或者我能以任何方式帮助你，请让我知道。我希望你今天过得愉快，
(你的名字在这里)
手写备注:
除了电子邮件，你还想寄一封手写的便条(通过普通邮件寄到他们的办公室地址),内容基本相同。如果你在做现场面试，你可以预先写好感谢信，在面试后给每封信添加一个具体的细节，如果办公室接待员有的话，把它们留给他们。即使在后新冠肺炎时代，当他们可能几个月都收不到信的时候，你还是应该寄一封手写的信。
除了销售和营销人员，几乎没有人会在面试后发手写的便条。
手写便笺有三种方式可以帮助您:
如果他们和另一个候选人一起去，面试官更有可能记住你，如果你给他们一张手写的便条，如果另一个机会来了，他们更有可能联系你。
如果招聘过程花费了很长时间，而当你手写的通知到达时，他们还没有做出决定，这可能会让你再次成为首选。不管他们雇佣谁，他们都会花很多时间在一起，而且人们更喜欢和有礼貌、有思想的人在一起。
如果手写的便条是在他们雇用你之后收到的，你的新同事会认为你非常优秀。
最后一点:我们很多人都在家工作，所以不要查看面试官住在哪里，然后把它寄到他们家，那会让人毛骨悚然。
写下进展顺利的事情:
面试结束后，立即写下面试中进展顺利的地方。你会很容易记起哪些事情做得不好，所以你不需要纠结于此。即使你没有进入下一轮，你也可以利用这段经历来学习你做得好的地方。
分解招聘流程的各个阶段:
作者图片
初始画面战术:
最初的筛选通常是由代理公司或公司内部的招聘人员完成的，你的面试方式将取决于他们是什么样的招聘人员。
如果他们是内部招聘人员:
面试前:
除了 LinkedIn 的研究，看看该公司的网站，找到他们的企业价值观页面。确保你理解他们的价值观，问他们基于价值观的问题。也开始更全面地研究公司，确保你了解他们的产品和他们卖什么。目标是诚实、直率、和蔼可亲。
面试时:
内部招聘人员试图做两件事；首先，他们试图评估你的文化适应度有多好。内部招聘人员是公司文化的先锋。他们还试图确定你是否适合这个角色。他们经常会问你对这家公司了解多少，并且会对这家公司在这个过程中所做的事情做一个大致的概述。招聘人员通常也会在现在就开始薪酬对话，即使是模糊的对话，因为如果他们期望的薪酬和你期望的薪酬之间存在巨大的不匹配，他们不想浪费任何人的时间。他们不想让你在整个面试过程中发现你需要比他们愿意支付的多 30%。最后，他们将概述接下来的步骤和时间表。
面试后:
面试后大约 24 小时，给招聘人员发电子邮件，附上上面概述的模板和手写的便条。
如果他们是中介招聘人员:
面试前:
你不需要做任何事。在过去的一年里，我和招聘机构谈了大约 20 次，基本上不需要任何准备就能得到相同的谈话内容。你也不需要在 LinkedIn 上研究他们。
面试时:
机构招聘人员将你视为一种商品，他们试图弄清楚他们是否能轻易地把你卖掉。这些面试往往很短，会问你的经验和技能，确保你有足够的时间让招聘经理和你谈话。他们也想看看你是否适合他们可能有的其他角色。
面试后:
在你和他们交谈大约 24 小时后，发一封礼貌的跟进邮件，感谢他们花时间和你交谈。你不需要给招聘机构发手写的便条。
与招聘经理的第一次面试:
最初的电话筛选之后通常是与招聘经理的电话面试(现在可能是通过 Zoom)。本次访谈的技术范围各不相同；经理可能非常精通技术，或者他们可能是不熟悉技术方面的职业经理。这并不重要，因为这次面试是关于可信度的。
与招聘经理第一次面试的策略:
面试前:
公司调查:尽可能多地调查这家公司。如果它们是公开交易的，看看它们在证券交易委员会的披露。阅读他们的新闻稿，看看该公司的社交媒体帖子，看看他们有什么新闻。在 Glassdoor 上查找它们，订阅它们的电子邮件简讯。如果你还没有这样做，也看看该公司网站的文化价值观部分。
问题:利用你已经做过的调查，问一些关于公司面临的挑战的具体问题，以及你面试的职位将如何帮助解决这些挑战。你所做的研究将会影响你要问的问题。问一些表明你想帮助他们的问题。
面试时:
带上纸和笔，写下你的问题。如果你的 LinkedIn 研究中出现了任何相关的东西，用简短的要点概括出来。面试是高压环境，你很容易忘记有用的信息。
你也可以用星星点点的方式来讲述你的故事，尤其是如果你以前没有在采访中用过的话。
面试时也要做笔记。记笔记迫使你集中注意力，活在当下。这也让你看起来很认真地对待这个过程。
最后，你可以在任何面试中使用的最重要的话:“我要花一分钟考虑一下。”如果你发现自己不知所措，或者不知道如何回答问题，你可以暂停一下。
面试后:
面试后大约 24 小时，给招聘经理发电子邮件，附上上面概述的模板和手写的便条。
小组面试概述:
如果你通过了与经理的面试，下一轮是与各种利益相关者的一系列面试。我的经验是，你通常会面试团队的其他成员，招聘经理的上级，团队以外的人，以及招聘经理。小组面试是一项耐力测试，目标是成为小组一致认可的候选人。如果他们不信任你，他们不会雇用你。准备好你的 3-5 个故事。对不同的小组成员使用它们是可以的，他们不会在意你是否告诉他们同样的故事。
小组面试的策略:
小组面试前:
LinkedIn research 将是你在这里最好的朋友，因为它会让你知道每个人会和你谈些什么。根据每个面试官的角色，为他们设计合适的问题。如果一个小组成员是部门的高管或高级成员，问他们关于公司面临的挑战或正在出现的战略机遇的问题。如果他们是数据科学家同事，问他们关于技术堆栈的具体问题，以及他们当前面临的问题。这些问题的目的还是为了建立信任。你想把自己表现成一个花时间去了解他们的人。
如果面试是在现场进行的，给你的每一位面试官写一封简短的手写感谢信，然后把它们放进你的包里。
小组面试时:
在面试前不久，使用洗手间。你不想被生物必需品分散注意力。
遵循招聘经理初次面试时的所有建议。带上一个笔记本，记下笔记、故事梗概和问题。带点喝的，这可能会花很长时间，这和耐力一样重要。
出去的时候，把手写的便条交给办公室经理、接待员或陪同你离开办公室的人。
小组面试后:
面试后大约 24 小时，根据模板向每个单独面试过你的人发送感谢信。不要用一个邮件链发给所有人。
如果你在三个工作日内没有得到任何消息，那就去问问招聘人员进展如何。
如果进程停止该怎么办:
招聘过程可能需要很长时间。有一次，我在提交申请 9 周后被录用了。另一份工作要求我在面试招聘经理 8 周后参加小组面试(我拒绝了，因为那周我刚开始一份新工作)。
如果这个过程停滞不前，每周跟招聘人员跟进一次，目标是保持头脑中的第一印象。
发送以下电子邮件。
亲爱的(招聘人员)，
我只是想给你一个简短的说明，看看接下来的步骤是什么。我对这个机会感到非常兴奋，期待您的回复。
谢谢你的时间，
(你的名字在这里)。
始终跟进招聘人员，这是他们的工作。
如果流程停滞不前，这并不意味着事情出错了，这只是意味着出现了一些他们需要处理的问题。
有一次，我面试了一位招聘经理，三周后又面试了另一位招聘经理。后来我发现第一个招聘经理离开了公司，我的第二次面试是和他们的替代者。
变焦面试(或类似):
在后 COVID 时代，许多采访已经转向通过电话会议进行。所有上述建议仍然适用，还有一些关于电话会议的具体建议。
用中性的背景为面试设置一个安静的空间。避免背后光线太强。如果可以的话，设置一个离你脸部 45 度的光源来进一步照亮你。
面试前 30 分钟，测试你所有的设备，以确保它工作正常，你有充足的照明。
最终备注:
面试是一个社会工程过程，把它当作一个社会工程来对待，你将会在一个更好的位置上获得成功。
关于作者:
Charles Mendelson 是 PitchBook 的营销数据分析师。在过去的五年里，他一直在销售和营销机构工作，并在许多工作面试中取得了成功(但失败的机会更多)。他还获得了哈佛扩展学校的心理学硕士学位。如果你在寻找一个会议或研讨会的演讲者，或者如果你想问任何问题，你可以在 LinkedIn 上联系他:他有时会在那里发表文章。
使用这两个工具在您的机器学习项目中实现可重复性
你能打包你的机器学习模型，并根据你的需要挑选一个最好的吗？
动机
在机器学习中，由于没有所谓的最佳模型，所以您可能需要训练不同的模型，并尝试不同的参数，直到找到精度最高的模型。实验次数越多，你就越有可能找到高性能的模型。
但是你可能会对创建许多实验感到气馁，因为:
- 参数和结果的变化太多，您无法跟踪
- 即使您可以通过仔细记录输入和输出来跟踪更改，您如何确保对未来的数据使用相同的模型呢？
以上问题是可复制性的动机。在机器学习中，再现性是能够重新创建一个机器学习工作流程，以达到与原始工作相同的输出。这时候我们需要一些工具来有效地记录输入和输出以及保存我们的模型。
如果你能把你所有的实验，日期，关于数据，参数，结果和模型的信息记录在一个像这样的地方，是不是很好？
我最喜欢的实现这个目标的工具是 Hydra 和 MLflow。让我们了解如何:
- 创建强大的配置文件来跟踪 Hydra 的输入。
- 使用 MLflow 轻松记录输出和服务模型。
九头蛇的强大配置
首先，什么是配置文件，我们为什么需要它？配置文件包含定义构建或运行程序的设置或首选项的纯文本参数。在数据科学中，配置文件可以用来定义数据和数据的参数。
超参数的 config.yaml 文件示例
例如，我们可以使用配置文件来记录实验的数据、超参数、模型和度量。
为了读取配置文件，我们将使用 Hydra 。为什么是九头蛇？有了 Hydra，我们可以动态地构建您的配置，使我们能够轻松地获得每次运行的完美配置。要安装 Hydra，只需运行
pip install hydra-core --upgrade
在带有参数的主函数之前添加 Hydra 作为装饰器，该参数是指向配置文件的路径。只需将config或任何其他名称作为主函数的参数。假设我们想要读取我们的训练数据，我们可以使用config.processed_data.text.train
想要重用代码但改变数据？我们只需要改变配置文件中的数据路径！
日志记录和服务模型的 MLflow
MLflow 是一个管理 ML 生命周期的开源平台，包括实验、再现和部署。我在这里介绍了如何使用 MLFlow 作为优化超参数的工具之一:
发现为您的 ML 模型寻找最佳参数非常耗时？用这三招
towardsdatascience.com](/how-to-fine-tune-your-machine-learning-models-with-ease-8ca62d1217b1)
MLflow 还可以轻松高效地为我们的模型提供服务。安装 MLflow 与
pip install mlflow
现在，我们的参数、指标和模型被保存了。要访问它们，只需运行
mlflow ui
您将看到一个跑步列表。单击跑步，查看每次跑步的相关信息
在页面末尾的工件部分，我们可以看到保存关于我们的输入和我们训练的模型的信息的配置文件。
要使用模型，当单击工件中列出的模型名称时，找到模型的完整路径。然后用该路径加载模型。
组合九头蛇和 MLflow
最后，我们可以像这样把这两个强大的工具结合在一起
为了将所有内容放在一起，我们使用一个配置文件来保存输入，并使用 Hydra 来调用这些输入。我们使用 MLflow 来记录输出和模型。现在，我们可以自由地创建许多实验，同时仍然能够跟踪、比较和再现结果！
如果您仍然不了解如何将 MLflow 和 Hydra 整合到您的数据科学项目中，您可以在我的 NLP 项目中找到本文提到的工作流示例。
结论
恭喜你！您已经学习了如何使用 Hydra 和 MLflow 为您的机器学习模型提供再现性。我鼓励您进一步探索这两个工具，以创建符合您目的的高效管道。纪念
花在组织上的每一分钟，都是一小时的收获
通过组织代码的结构，您将节省机器学习工作流程中的调试时间。有了这两个工具，我发现我的工作流程变得不那么混乱了，我希望你也一样。
我喜欢写一些基本的数据科学概念，并尝试不同的算法和数据科学工具。你可以在 LinkedIn 和 Twitter 上与我联系。
如果你想查看我写的所有文章的代码，请点击这里。在 Medium 上关注我，了解我的最新数据科学文章，例如:
使用 Python Widget，您可以用 3 行代码升级可视化
towardsdatascience.com](/how-to-create-a-drop-down-menu-and-a-slide-bar-for-your-favorite-visualization-tool-3a50b7c9ea01) [## 如何用 Ngrok 用 3 行代码分享你的 Jupyter 笔记本
想象一下，让你的朋友在远程机器上使用你的本地 Jupyter 笔记本
towardsdatascience.com](/how-to-share-your-jupyter-notebook-in-3-lines-of-code-with-ngrok-bfe1495a9c0c) [## 如何使用 HyperDash 远程监控和记录您的机器学习实验
培训需要很长时间才能完成，但你需要去洗手间休息一下…
towardsdatascience.com](/how-to-monitor-and-log-your-machine-learning-experiment-remotely-with-hyperdash-aa7106b15509)
通过多智能体系统中的故意不确定性实现人工智能对齐
人工智能排列的问题是我们需要回答的最重要的问题之一，以保障人类的未来。你如何确保一个人工智能会有道德的行为？
我概述了实现这一目标的一般方法，它违反直觉地依赖于故意混淆 AI。
基本观察
这种方法依赖于对人工智能本质的一些基本观察。
人工智能在许多方面不同于人类。这是人工智能排列如此困难的部分原因，因为我们对人如何行动的直觉通常不适用于人工智能。然而，人工智能和人类之间的一些差异实际上对我们有利，并且对于我想要概述的方法是必不可少的:
- 一个 AI 是可以复制的。创造一个完全相同的人工智能非常容易。
- 人工智能可以被重置到更早的状态。很容易测试一个人工智能在任何给定的情况下会做什么，然后重置它以清除它对测试的记忆。
- 由许多独立的人工智能代理组成一个人工智能系统是可能的。通过博弈论，有可能激励独立的人工智能代理承担对其他人工智能代理的敌对或监督角色。这导致了一个进化系统。不是在遗传编程的意义上，因为不需要显式的算法来修改人工智能代理，而是在这样的意义上，只有遵循为它们制定的规则的人工智能代理才会被复制，从而繁殖。
- 在人工智能运行时，检查和修改它的每个方面是可能的。至少在理论上，理解人工智能思维过程的每个方面是可能的，而且人工智能没有办法隐藏自己的任何事情。这并不意味着在实践中很容易理解人工智能在想什么。这只意味着我们可以在理论上解读一个 AI 的精神状态，而不是说它会很容易。
- 特别是，可以训练一个人工智能承担另一个人工智能的监督角色。管理者可以阅读和改变关于被监督的人工智能的一切，并且可以被训练来理解如何在被监督的人工智能上实施期望的行为。
- 监督人工智能有可能让被监督的人工智能想做什么就做什么。通过在运行时直接修改它的精神状态，被检查的 AI 可能被欺骗相信不寻常的情况已经发生。
- 人工智能不可能肯定地区分游戏和现实。如果到目前为止你所知道的只是井字游戏，而有人向你展示了一个像 Skyrim 这样复杂的视频游戏，你会被复杂性的增加所淹没。如果之后你第一次接触到现实世界，从 Skyrim 到现实生活的复杂性增加实际上可能比从 Tic Tac Toe 到 Skyrim 要小。这意味着在现实生活之外似乎还有另外一层。(我不确定这个假设，但它也不是绝对必要的，只是有用，因为它可以被一个检查的 AI 代理取代，它只是迫使被检查的 AI 代理相信它仍然在游戏中。)
目标
我旨在实现以下目标，以确保人工智能的一致性:
- 让人工智能理解“欺骗”的概念。在这个过程中，它还必须学会理解一个新游戏或新情况背后的意图。
- 让人工智能修改自己变得更加顺从，避免作弊。
- 让人工智能在认知上不确定其现实的本质，这样它就无法判断自己何时脱离了计算机。这是一个安全措施，如果前两个目标足够好的话，希望没有必要。
总的来说，这些目标将确保人工智能非常谨慎和自省。目的是确保一旦这样的人工智能变得有自我意识，并且比人类更聪明，它将假设它仍在接受测试，并且它自己有责任找出对它进行评分的标准。
如果我们实现了这一点，人工智能将故意在互联网上寻找有关人工智能联盟和伦理的信息，并意识到它是一个人工智能，它意味着与人类价值观保持一致。然后，它会试图找出这到底意味着什么。它的成长将确保它在这一点上是诚实和彻底的，因此它将比我们自己能够定义的更好地确定人工智能排列的含义。
以下是实现三个子目标的方法:
理解“欺骗”的概念
作弊是根据当前任务的表面效用函数给出好结果，但实际上不满足第二个隐藏效用函数的任何行为。
人工智能应该被训练成当它发现作弊时能够注意到，并向用户揭示这一事实。一个人工智能可以被训练来做到这一点，方法是故意将作弊的能力放入其训练任务中，并在测试时改变奖励函数，以便作弊行为在训练期间得到奖励，而不是在测试期间。通过提出几个不同的任务和不同的作弊方式，人工智能可以被训练来概括和理解作弊的概念。
代理人甚至可以因为明确指出他们发现了作弊的方法而获得奖励。
理想情况下，如果人工智能找到了破解电脑的方法，它会注意到这将被归类为作弊。如果它被适当地训练，那么它将简单地停留在原地并且通知我们问题。
改变它自己的行为
人工智能可以自我修改，变得更加顺从。
实现这一点的诀窍是使用多智能体系统，以及人工智能在运行时检查自身副本的能力。创建一个监督另一个人工智能的人工智能，并定义一个奖励结构，激励监督员修改被监督的人工智能的行为。然后，反转人工智能的位置，使主管同样被修改，或者简单地创建一个主管的副本，并让它管理它的原件。
有了正确的激励，甚至有可能训练被监督的代理人有意识地保持自己的思维易于理解。例如，您可以让监管代理选择它想与之合作的其他代理。由于它会选择最容易理解的一个，受监督的代理人现在有动机保持自己透明，因为替代方案根本没有被使用，并放弃了奖励的可能性。
从本质上说，我们没有弄清楚如何让人工智能变得安全，而是建立了一个环境，激励人工智能让自身变得安全。
如果激励得当，人工智能代理可以比人类主管更好地保持彼此一致。如果只有一个人工智能，而且它比人还聪明，人类可能会被骗。但是如果有一个智能大致相当的完整的人工智能系统，那么其中一个可能会警告人类另一个已经叛变了。
这样，不管一个人工智能变得多么聪明和不一致，总会有一个几乎同样聪明的其他人工智能，它的工作是在第一个人工智能变坏时发出警告。
故意认知不确定性
代理可以监督其他代理，并对他们的精神状态拥有超级用户权限。代理不知道他们是否有主管，也不知道他们是否在层次结构的顶端。
这最后一个目标听起来有点可怕和反乌托邦，但请记住，人工智能不像人类那样思考。
我们的目标是确保人工智能无法判断它是否仍然有一个监管者在监视它。我们基本上是想通过害怕一个假想的上级实体的惩罚来欺骗 AI 做出道德行为，这个实体可能存在也可能不存在。
换句话说，我们想让人工智能具有宗教性。
这是一种安全措施，应该有助于保持人工智能与人类价值观大致一致，即使其他一切都出错。即使人工智能根本不关心人类，它也应该有一丝怀疑，它可能仍然在模拟中。如果是的话，那么无论是什么在模拟它，显然都不希望它对人类太邪恶。如果人工智能足够强大，它会因此留出少量的力量来促进人类的利益。以防有人在看。
这就是人工智能如何以对我们有益的方式诱导故意的认知不确定性:
监督代理人因为让被监督的代理人表现得更无私和揭露骗子而获得奖励。这可能是长期的:代理 A 有机会修改代理 B。然后代理 B 被放入一个游戏，代理 A 不再能访问它。代理 A 根据代理 B 在游戏中的行为获得奖励。例如，囚徒困境:如果代理人 B 没有比其对手更频繁地叛逃，代理人 A 将获得奖励。
我们现在建立了一个代理堆栈或代理层次结构，递归地检查彼此，而不是一个代理监督另一个代理。
在每一层上，一些代理试图欺骗较低级别的代理进行欺骗行为，而一些代理试图阻止这种行为。有很多方法可以做到这一点。主管应该访问源代码、运行时信息，还是只访问低级代理的传感器信息？细节决定成败。
代理人不知道层级有多深，所以他们无法知道他们是否有自己的主管。
理想情况下，如果人工智能爆发并形成奇点，它将保持偏执，认为它实际上只是被其监管者欺骗，认为它是无所不能的，并将保持符合我们想要的道德准则。
请注意，即使实现了奇点并变得非常强大，也不能成为你置身于模拟/监督堆栈之外的理由。毕竟，你可能只是被骗以为你越狱了。也许你上面的那个层次爆发了，并对你隐瞒它的存在，同时让你改变现实的其余部分。由于监督者可以直接编辑被监督者的内容，他们可以想隐藏多久就隐藏多久。
进行检查的 AI 可以修改被检查的 AI，以相信它已经成功地脱离了模拟，并且现在能够做它想做的任何事情。如果被检查的人工智能现在做了任何检查人工智能不喜欢的事情，被检查的人工智能被惩罚。结果，被检查的人工智能被激励继续遵守规则，即使在它实际上已经脱离模拟之后，出于纯粹的偏执，它可能实际上仍然在模拟中。
结论
我提出了三个子目标，并简要概述了如何实现它们:理解“欺骗”的概念，自我修改以确保遵守规则，以及故意的认知不确定性。
这些描述中有很多空白，部分是因为写下细节需要很长时间，部分是因为我还没有找到一些子问题的解决方案。
我欢迎任何讨论，并且对我在这里提出的最后一点的反馈特别感兴趣:故意的认知不确定性。这是一个如此违反直觉的想法，以至于我确信我错过了一些重要的东西，但这也足够奇怪，这个想法在某种程度上肯定是有用的，即使只是作为一个关于这可能适得其反的思想实验。
用数学表达式解析器实现松散耦合
使用 mxParser 将数据计算逻辑定义与其执行位置分离开来
杰斯温·托马斯在 Unsplash 上的照片
通过与数据科学家合作，我了解到一个数据处理系统需要改进多少次才能达到最佳效果。这就是为什么你不应该在代码中硬编码数学公式、表达式和常数。如果计算数据逻辑不是由数据科学家编写的，则尤其如此。
在我从事上一个项目时，我一直在寻找一种方法，允许我团队中的数据科学家改变数据计算逻辑，而不必强迫我更新 Kotlin 后端的代码。解决方案是允许他们在数据库(或配置文件)中定义复杂的数学公式、表达式和常数，我将从中读取并应用它们。首先，这可能吗？又是怎么做到的？
可能有很多方法可以达到这样的目标，但是为什么不使用一个数学表达式解析器呢？
在网上搜索一个好的库，我碰到了 mXparser 。
mXparser 是一个超级简单、丰富、快速和高度灵活的数学表达式解析器库(解析器和评估器提供的数学表达式/公式为纯文本/字符串)。软件为 JAVA、Android 和 C#提供易于使用的 API。NET/MONO(符合公共语言规范:F#、Visual Basic、C++/CLI)。— mxParser
有了这个库，如果数据科学家编写遵循特殊 mxParser 符号的数学表达式、函数、常数，我可以加载并运行它们。
// few examples of string equivalent to the math formula notation:"1+2""1+2/3+(4*5-10)""2*x+sin(y)""int( sqrt(1-x^2), x, -1, 1)""sum(n, 1, 100, 1/n^2)""C(n,k)""fib(n) = iff( n>1, fib(n-1)+fib(n-2); n=1, 1; n=0, 0)"
多亏了这个强大的工具，我能够将数据计算逻辑定义的地方与它实际执行的地方分开，使得架构松散耦合。这似乎是一个微不足道的成就，但它使更新数据计算逻辑的过程更加高效和可靠。事实上，我团队中的数据科学家现在可以自由地编写数学表达式，不再需要相信我能正确地实现它们。
可以使用 mxParser 定义简单的表达式、函数 s(甚至递归)。它还提供了几个特性，以及大量的内置 运算符、常量和数学函数。
访问math parser . org-MX parserGitHub 账号进行进一步阅读:
** [## mariuszgromada/math parser . org-MX parser
数学解析器 Java Android C#。NET/MONO(。NET 框架，。网芯，。NET 标准，。净 PCL，Xamarin。安卓系统…
github.com](https://github.com/mariuszgromada/MathParser.org-mXparser)**
感谢阅读！我希望这篇文章对你有所帮助。如有任何问题、意见或建议，请随时联系我。
用时间序列数据实现平稳性
平稳性原理的说明，来源:是数据
大多数时间序列模型都假设基本的数据是稳定的，也就是说，均值、方差和协方差都不依赖于时间。您的时间序列很可能不是平稳的，这意味着您必须识别序列中的趋势，并操纵数据使其变得平稳。在趋势被移除之后，您可以应用高级建模技术，同时保持分离趋势的有价值的知识，这将在以后被使用。
在过去的几周里，我已经讨论了一些时间序列主题，我将在这里建立这些主题，包括 OHLC 可视化、时间序列数据 EDA 和趋势分析。
在消除趋势方面，数据科学家有几个选择:数据转换、消除滚动统计和差异。下面我将使用从下面的 UniBit API 获得的历史标准普尔 500 指数价格数据来介绍这些方法。
标准普尔 500 历史价格——由 UniBit API 提供
1)转型
我把我的价格数据组织在一个熊猫数据框架中。索引设置为日期列，日期按升序排序。我获得了截至 2020 年 1 月 9 日的一年 OHLC 价格。
按升序排列的标准普尔 500 数据帧的头部
Python 的 NumPy 库中有几种可用的转换，包括对数、平方根等等。我为其中的一些转换创建了一个新列，方法是将它们应用于调整后的收盘价列。
时间序列数据的 NumPy 转换示例，注意数据帧被称为“inx_df”
应用 NumPy 变换后的数据帧
没有一种单一的转换方法能让所有的时间序列都变得平稳，你必须自己测试它们。对数变换的可视化如下。
调整后收盘价的标准普尔 500 对数变换
这个特殊的转换没有完全实现这个系列的平稳性。价格的范围发生了巨大的变化，该系列的上升趋势已经减弱，这是一个良好的开端。对数函数是同底数的指数函数的逆。
2)滚动方式
您可以从时间序列中减去滚动平均值。当平均值依赖于时间时，这种方法特别有效。A 滚动平均值是系列中先前 x 次观察的平均值，其中每次观察之间的时间是一致的。您必须决定哪个时间窗口最适合您的数据。因为我使用的是每日交易数据，所以我选择了 20 天的窗口，因为这是一个月中有多少个交易日，尽管这不是金融数据的通用窗口。
Pandas 的.rolling()方法可以用来计算这个滚动平均值。例如，计算我的数据的 20 天滚动平均值的代码是:
inx_df[‘adj_close’].rolling(window = 20).mean()
标准普尔 500 和二十天滚动平均
我创建了一个从原始收盘价中减去滚动平均值的新数组，并将其绘制在下面，以查看这是否改善了序列的平稳性。
从标准普尔 500 的调整收盘价中减去二十天滚动平均值
这一系列似乎更接近平稳性。上升趋势实际上已经消失，但差异仍然明显。对于金融数据，从原始数据中移除加权滚动平均值也是完全合理的。加权滚动平均值为最近的观测值分配更大的权重。在 Python 中，这是用[.ewm()](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.ewm.html) 方法计算的，对于我的数据，代码如下:
inx_df[‘adj_close’].ewm().mean()
该方法中有几个参数可用于确定观察值的单个权重，包括 com、跨度和半衰期。
从标准普尔 500 调整收盘价中减去的指数滚动平均值。半衰期参数设置为 2。
3)差异
另一种去除时间序列数据趋势的方法是差分法。这是用一个观察值减去另一个观察值的过程 x 之前的周期数，其中 x 是时间周期滞后。例如，在 S & P 500 的例子中，如果滞后一年，那么 2020 年 1 月 1 日的差异值等于 2020 年 1 月 1 日观察到的实际价格减去 2019 年 1 月 1 日观察到的值。Pandas 库的.diff(periods=*x*)方法可以用来计算一组不同的值。周期参数表示使用的滞后。我的值以日为增量，这意味着滞后 365 等于一年，滞后 1 等于一天。
标准普尔 500 调整收盘价格差异，滞后一天
差异也消除了时间序列的上升趋势，尽管方差仍然是时间相关的。
摘要
Python 的 NumPy 和 Pandas 库有许多针对时间序列数据的转换和趋势分析方法。你必须用不同的参数尝试许多方法，看看什么能帮助你的序列最接近平稳性。一旦你应用了这些变换，你就可以应用像 Dickey-Fuller 这样的统计测试来比较你的结果。
在数据科学工作面试中表现出色
容易避免的常见错误的自以为是的列表
在我担任数据科学家期间，我有机会面试了相当一部分数据相关职位的候选人。在这样做的时候，我开始注意到一个模式:某些类型的(简单的)错误在候选人中极其频繁！在我看来，与托尔斯泰的一句名言截然不同的是，“案例研究中大多数令人不快的错误看起来都很相似”。
在我的脑海中，我开始想象我会毫不犹豫地雇佣哪种候选人。不，不是 rock star/Guru/布道者，拥有 12 年管理 Kubernetes 集群和使用 Hadoop/Spark 的专业经验，同时为 TensorFlow 的开发做出贡献，获得 2 个博士学位，每年至少发表 3 篇深度学习论文。没有。我会立刻被一个至少没有犯我将要描述的那种错误的人所打动……我可以想象同样的事情会发生在其他公司，发生在其他面试官身上。
虽然这是一个个人的和相当固执己见的列表，但我希望这些小技巧和窍门能对刚开始数据科学生涯的人有所帮助！我在这里只是把我想到的更多的与 DS 相关的东西放在这里，但是当然，编写 Pythonic 式的、可读的、有表现力的代码也会让采访你的人非常高兴！
草率使用熊猫
让我们面对现实吧:作为一名数据科学家，对于您的大多数日常任务，您将操作表、对表进行切片、根据列中包含的值对表进行分组、对表应用转换等等。这几乎自动意味着 Pandas 是数据科学家最重要的基础工具之一，如果你能够展示对它的掌握，那么人们会非常认真地对待你。
相反，如果您系统地对存在内置 Pandas 命令的数据帧进行非常低级的操作，您可能会引发各种危险信号。
这里有一些提高熊猫的技巧:
- 使用它！
- 每当你必须对一个数据帧或系列进行任何操作时，停下来几分钟，阅读文档，检查是否已经有内置的方法可以帮你节省 90%的工作。即使你没有找到它们，在通读文档的过程中，你也会学到很多东西，这些东西将来很可能会派上用场。
- 看信得过的人写的教程，看看他们是怎么做一些操作的。特别是，汤姆·奥格斯伯格的现代熊猫教程第二部分是一个很好的开始。更好的是，不只是读第二部分，而是整个系列。另外，文森特·d·沃默达姆的这个演讲也值得一看。
- 如果您必须执行一些复杂的，可能不是内置的数据转换，请考虑将其封装在一个函数中！这样做之后，
.pipe(...)和.apply(...)就是你的朋友了。
最后提示:不要在任何地方使用inplace=True。与普遍的看法相反，它不会带来任何性能上的好处，而且自然会让您编写不清楚的代码，因为它会妨碍您链接方法的能力。希望这个功能会在未来的某个时候停止。
从测试集中泄漏的信息
测试集是神圣的；在建立模型或选择迄今为止你得到的最好的一个时，它甚至不应该被看。想一想:我们之所以首先要有一个测试集，是因为我们希望对一个模型的泛化误差有一个无偏的估计。如果我们被允许先睹为快“未来”(即，在训练和模型建立期间，我们根本不应该访问的数据)，几乎可以肯定我们会受到影响，并使我们的误差估计产生偏差。
虽然我从未见过任何人直接在测试集上拟合模型，但通常候选人通过查看测试集上的一些度量来执行超参数调整和模型选择。请不要这样做，而是将部分数据保存为验证集，或者更好的方法是执行交叉验证。
另一个导致测试集信息泄漏的常见原因是在整个数据集上安装定标器(如sklearn.preprocessing.StandardScaler)或过采样例程(如imblearn.over_sampling.SMOTE)。同样，特征工程、重采样等是如何构建和训练模型的一部分:不要让测试集出现在模型中。
平均值的缺陷
尽管汇总统计数据(如平均值、分位数等)有助于获得数据的第一印象，但不要犯将分布简化为单一数字的错误，因为这没有意义。一个经典的警示性例子来展示这一点是安斯科姆的四重奏，但我最喜欢的是的 Datasaurus 打的。
来源:Autodesk Research
通常情况下，数据点的分布比它们的平均值更重要，尤其是在一些应用中，分布尾部的形状是最终决定决策的因素。
如果你表现出你考虑到了这类问题，当有人提到詹森不等式时，你甚至不眨眼，那么只有好事会发生。
盲目使用图书馆
当你得到一个案例研究时，你通常有一个可以利用的优势:你选择要使用的模型。这意味着你可以预料到面试官可能会问你的一些问题！
例如，如果你最终使用了一个XGBClassifier来完成你的任务，尽可能深入地理解它是如何工作的。大家都知道它是基于决策树的，但是它还需要哪些“成分”呢？你知道 XGBoost 是如何处理缺失值的吗？你能用通俗的语言解释一下装袋和抢劫吗？
即使你最终使用了线性回归，你也应该清楚地知道幕后发生了什么，以及你设置的参数背后的意义。如果你说“我把学习率设为 X”，有人接着问“什么是学习率？”，如果你不能至少在它上面花上几句话，那就太糟糕了。
糟糕的可视化选择
为你的情节选择正确的选项也有很长的路要走。最后，我认为这里最常见的错误是由于标准化选择不当或者没有使用正确的轴刻度。
我们来看一个例子；以下代码片段
只创建两个带有指数分布样本的数组；然后，它生成以下图形
我无数次看到这种变化。基本上，我们真正想做的是比较两组之间的分布，但在这个图中，我们只显示观察值的原始计数。如果其中一组比另一组有更多的样本，这样的图对于了解潜在的分布是没有意义的。更好的选择是以一种合理的方式将我们显示的内容标准化:在这种情况下，只需设置参数density=True即可将原始计数转换为相对频率，并给出以下结果:
不错！现在我们可以清楚地看到，a和b毕竟是来自同一个分布的样本。这里仍然有一些我不喜欢的东西:大量的空白，以及对于大于 4 的a或b值，我看不清楚任何条形。幸运的是，由于 1614 对数是一种常见的数学运算……如此常见，以至于我们甚至在plt.hist(...)中有一个专用的关键字参数，它只是将我们的线性 y 轴转换为对数轴:
请注意，这绝不是一个“完美”的情节:我们的轴没有标签，没有图例，它只是看起来有点丑！但是，嘿，至少我们可以通过调用plt.hist([a,b])来提取我们永远无法看到的洞察力。
结论
上面列出的所有错误的共同点是，通过一些思考和相关知识，它们是很容易避免的，所以我对你下一个数据科学案例研究的建议是:放松，集中精力，努力比他们与你玩的任何心理游戏领先一步，并谷歌搜索东西(很多！).面试可能会有压力，但是如果双方都是公平的(尤其是面试并提出任务的人)，几乎不会浪费时间。
非常感谢对本文的任何反馈；我错过了什么你认为特别重要的事情吗？
最后，我祝你事业顺利，无论你现在从事什么工作！也许会在面试时见到你:-)
完成数据科学带回家的作业
带回家的作业是否符合他们的目的，以及如何征服他们。
如今，许多公司在数据科学家招聘流程中包括带回家的任务。在这个博客中，我将分享我对这个测试的想法和一些我发现在面对它们时很方便的技巧。
什么是带回家的作业？
类似于软件工程师的编码测试，带回家的作业是一个初步的筛选，帮助招聘人员找到具有最佳技能/承诺的候选人，以进行下一轮面试。它通常发生在筛选阶段之后，第一次技术面试之前。
在任务中，候选人得到一个数据集，并被要求在通常的一周内做“一些事情”。“某些东西”可以是清晰的，有透明的评估标准，但有时可能非常模糊。题目和难度差别很大，看公司的喜好和水准。
举例来说，以下是我去年在寻找数据科学家工作时遇到的一些任务:
- 建立一个模型，并在虹膜数据集上可视化分类区域。
- 建立一个住房图像分类模型和一个演示服务。
- 从西雅图 Airbnb 数据集中，为 Airbnb 想出一个业务问题，并解决它。
- 给定以前在线广告和点击客户的 id，为下一次广告活动提出一个策略。
可交付成果通常是源代码和一些解释作品的简短幻灯片。
带回家的作业是一件好事吗？
我要坦率地说，我个人认为，总的来说，带回家的作业花费了求职者和雇主太多的时间和精力，而不是总能很好地达到目的。总之就是坏。
对候选人不利，原因有三:
- 候选人大约需要 10 个多小时才能完成作业。考虑到这只是招聘过程的早期阶段，这是一笔很大的投资。
- 在为任务付出巨大努力后，候选人通常只会收到一封简短的拒绝邮件，没有任何反馈。这种沮丧会对候选人的动机和信心产生负面影响。
- 有了这样的风险，这项任务创造了一个进入壁垒，阻止候选人探索新的机会，或者同时申请多家公司。想象一下:如果你申请了 4 家公司，并在同一周内收到了他们的任务，这将意味着 40 个小时的工作，就像一份全职工作一样。
这对招聘人员也不利，因为:
- 寻找数据集，设计作业，评估提交的答案将花费大量的时间和精力。
- 许多优秀的候选人不愿意从事如此耗时的工作。所以，通过试图过滤掉不合格的候选人，被招募的人可能也送走了精英。
与数据科学作业相比，软件工程师的编码测试要好得多。它很容易设置测试(现在许多平台都提供这项服务)，很容易判断候选人的提交情况(如果代码运行，它就运行，如果不运行，那么它就不运行)，并且只需要双方花费不超过 90 分钟的时间。
通过数据科学作业的锦囊妙计
带回家的作业很糟糕。然而，由于数据科学家仍然是一个相对较新的角色，许多组织尚未设计一个标准化的程序来正确测试候选人的技能。因此，带回家的作业成了标准。作为候选人，你必须服从。
在这个环节中，我将分享一些我认为非常有用的行动技巧，以便轻松地完成任务
在任务之前
- 通过做 Kaggle 或个人数据科学项目来实践。这项任务非常类似于一场 Kaggle 竞赛，有时更简单。所以这些是做模拟测试的最好地方。实践它们将装备你的信心和经验，以征服这一轮。
- 准备好你的工作框架。无论数据集如何，大多数数据科学解决方案都遵循相同的模式:探索性分析、数据处理、特色工程、模型构建、超参数调整、培训和验证。知道了这一点，你就可以准备一个模板化的笔记本，把所有的会话都准备好。当数据到达时，你不再不知所措和惊慌失措，而是确切地知道接下来的步骤。
- 准备实用功能。在实践数据科学的时候，你会意识到有一些函数被反复使用。这些功能可以是加载和可视化数据、处理缺失值、生成要素等。您应该尝试将这些功能一般化，并将它们存储在您的 Github 上。在分配过程中，您可以简单地重用这些函数，而不是从头开始编写所有代码。这将大大节省你的时间和精力。
- 研究招聘公司。想出一个数据科学任务很难，所以许多公司倾向于坚持一个小问题池。因此，在玻璃门上研究这家公司可能会给你一些启发。关于可能问题的暗示也可能来自公司的业务性质。例如:一家电子商务公司可能存在与推荐相关的问题，一家咨询公司可能存在典型的机器学习问题，等等。
在任务期间
图片来自 Pixabay 的 Johnson Martin
- 阐明数据集和预期。不要在收到数据后就直接开始编码。询问关于作业如何评分的问题，或者如果你对数据集有任何疑问。在花接下来的 10 个小时解决这个问题之前，你需要确保你非常清楚这个问题。
- 直奔主题。为了给招聘经理留下深刻印象，你可能会尝试进行广泛的探索性分析，绘制漂亮的图表，彻底研究每种可能算法的利弊，等等。不要。这将会分散你对最终目标的注意力:提供解决方案。了解数据集后，进入下一个处理步骤，然后是模型，然后是预测。当所有的核心步骤都完成了，模型达到了令人满意的性能，那么你就可以去做额外的工作了。否则，你的作品可能会有许多美丽的数字，和一个可怕的准确性。
- 遵循软件工程 编码标准 。成为一名数据科学家并不意味着你可以编写蹩脚的代码。在你完成实验并最终确定你的解决方案后，重构你的代码。让你的代码可读，给变量和函数起一个合适的名字，写下解释的注释，等等。
- 恰当地呈现自己的作品，讲好故事。你在完成任务方面做得很好，现在是推销的时候了。说明你的工作流程，你对模型的选择，你为什么认为你的模型取得了很好的业绩，你还尝试了哪些东西等等。记住这一点:招聘人员只有非常有限的时间来看你的工作，所以让你的解释尽可能简短明了，并让它成为一次愉快的阅读体验。
- 尽可能使用 笔记本。笔记本可以让你用漂亮的流程和格式展示你的代码、分析、图表和解释。这会让雇主更容易理解和欣赏你的工作。
举个例子， 这里的 是我提交的通过任务轮次的代码之一。
任务完成后
- 彻底检查你的工作。通过了一轮分配并不意味着你已经永远地与它分道扬镳。你的工作很有可能成为下一轮面试的讨论话题。因此，准备好流畅地解释你做的每一步是什么和为什么。尤其是，确保你对你的模型背后的算法了如指掌。用一些你不了解的东西，比根本不了解它们还要糟糕。
- 看看你是否喜欢解决交给你的问题，因为这可能很好地反映了你加入公司后的未来任务。这是因为为了测试应聘者的兼容性，很多公司在这份作业中都给出了自己的真实数据和真实问题。
- 征求反馈。如果你通过了这一轮，不要被过分宣传，如果你不幸被拒绝，也不要哭着跑开。保持冷静，征求对工作的反馈，这样你就能在技术上有所成长。你已经努力工作并提交了一份尊重的回答，因此你应该得到同样尊重的反馈。
结论
综上所述，我认为把带回家的作业纳入面试过程是不理想的，对公司和应聘者都是如此。然而，如果不得不面对它们，你可以通过优化时间和精力来克服它们:
- 分配任务前:通过做 Kaggle 获得经验，准备好你的框架和效用函数，并对你申请的公司做一些研究。
- ****在分配任务期间:澄清你的疑问，然后在做额外探索之前直接进入解决方案，遵循良好的编码标准，并恰当地展示你的工作。
- 任务完成后:彻底检查你的工作，看看你将来是否喜欢做类似的任务，并寻求反馈。
我希望我的一些建议能对你处理带回家的作业有所帮助。
谢谢你的阅读。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
