使用 PyTorch 深度学习框架的序列数据批量采样器
在 PyTorch 框架的 dataloader 中使用零填充顺序数据集时，优化 GPU 利用率
杰西卡·约翰斯顿在 Unsplash 上的照片
注意——要了解如何为自定义数据集编写数据加载器，无论是顺序的还是图像的，请参考这里的。
对于数据点大小可能不同的顺序数据集，我们使用零填充使所有数据点大小相同。因此，批处理可以转换为张量，并传递到图形卡(GPU)进行并行处理。
但是这种方法不是最佳的。考虑两批 8 个数据点，每个数据点的大小如下:
- 批次 1— [2，5，5，4，6，7，8，2]，批次的最终大小= 8*8
- 批次 2— [2，32，5，36，6，34，8，2]，批次的最终大小= 36*8
在批次 1 中，所有数据点需要使用零填充转换为大小 8，而在批次 2 中，所有数据点需要转换为大小 36。在这两种情况下，最小大小都是 2，但是在批次 1 中，我们只给大小为 2 的元素添加了 6 个零，而在批次 2 中，我们需要添加 34 个零。因此，我们可以看到，批处理 2 在处理无用的零时浪费了大量 GPU 内存，而批处理 1 是一种高效的打包方式，浪费的 GPU 很少。这个例子显示了问题所在，也给出了我们的解决方案。如果我们能以某种方式手工制作批次，那么我们就能确保每个包装都是有效的。
但是我们怎么做呢？？
还记得内部提供的 getitem 函数中的 index 变量吗，如果我们可以手动为每个批次提供索引，那么我们的工作就完成了。为此，我们可以使用数据加载器中的 batch_sampler 参数，如下所示。
train_dataset = Dataset_seq(word2id, train_path)
sampler = Sampler(tokens, data, bin_size) #data is list of sentences
present in whole corpus
train_batch_sampler_loader = DataLoader(
train_dataset,
batch_sampler = sampler,
collate_fn = collate_fn)
现在，将使用我们将在下面定义的 sampler 函数来提供一个批次的索引。
注意——对于不同的时期，最好在一批中有不同的数据点集，即如果在第一个时期一批通过(数据 1、数据 2、数据 3、数据 4 )，在其他时期，我们应确保不一起提供相同的数据集(数据 1、数据 2、数据 3、数据 4 )。这是为了确保我们的模型不会学习提供数据点的模式/顺序。
现在让我们来理解如何为我们的采样器函数编写算法:
- 我们将创建一个包含每个数据点长度的列表 text_len 。
- 然后，我们将创建箱(或桶数据),使得每个箱存储大小小于或等于对应于该箱的大小的数据点的索引。这里，对应于每个库的大小取决于 bin_size。例如，如果 bin_size = 2，那么 bin 的大小将是 3，5，7…直到最大尺寸出现在 text_len 中。
- 如果说 text_len = [2，3，4，5，6，7，8]，那么我们将得到{3: [0，1]，5: [2，3]，7: [4，5]，8: [6]}即索引 0，1 处的值大小≤ 3，索引 2，3 处的值大小≤ 5，依此类推。最后一个 bin 的大小为 8，因为这是 text_len 中的最大大小。
- 现在，我们已经根据大小分离了所有数据，我们将创建我们的批次。为此，我们将使用一个参数 n_tokens ，该参数指示 GPU 中可以加载的最大总大小(包括零填充)。因此，如果 n_tokens=500 ，那么我们可以使每一批在补零之后，一批中每个数据点的大小之和小于或等于 500。
- 现在，为了形成批，我们从最大的桶开始，继续按顺序挑选索引，直到该批的总大小刚好小于或等于 *n_tokens。*一旦形成一个批次，我们将其附加到 final_indicies 中，这是一个列表列表。这个过程一直持续到所有的数据点(存在于所有的箱中)被拾取并被分配给一批。
- 为了确保不在不同时期发送相同的一组批，在每个时期之后，我们随机打乱为每个箱存储的列表。因此，当我们按顺序开始从箱子中挑选时，我们每次都会得到不同的数据。
请参考下面的算法代码
我希望这个博客能帮助你理解和探索新的应用。请分享你的反馈和其他方法，让这个博客变得更好。
成为 介质会员 解锁并阅读介质上的许多其他故事。关注我们的 中的 ，阅读更多此类博文。
使用 GPyTorch 的批量多维高斯过程回归
实践教程
克里金法[1] ，更普遍的说法是**高斯过程回归(GPR)，**是一种强大的非参数贝叶斯回归技术，可用于从时间序列预测到插值的应用。
本演示中的 fit GPR 模型示例。高维高斯过程回归/克里金模型在许多不同领域都很有用，例如插值。图片来源:作者。
GPyTorch [2] ，一个为高斯流程设计的包，通过 PyTorch 后端、批量训练和推理、和CUDA 硬件加速，充分利用了硬件加速方面的重大进步。
在本文中，我们研究 GPyTorch 的一个具体应用:为分批、多维插值拟合高斯过程回归模型。
进口和要求
在我们开始之前，让我们确保所有的包都已安装并导入。
安装块
要使用 GPyTorch 进行推理，您需要安装gpytorch和pytorch:
# Alternatively, you can install pytorch with conda
pip install gyptorch pytorch numpy matplotlib scikit-learn
导入块
一旦我们的软件包安装完毕，我们就可以导入所有需要的软件包:
# GPyTorch Imports
import gpytorch
from gpytorch.models import ExactGP, IndependentModelList
from gpytorch.means import ConstantMean, MultitaskMean
from gpytorch.kernels import ScaleKernel, MultitaskKernelfrom gpytorch.kernels import RBFKernel, RBFKernel, ProductKernel
from gpytorch.likelihoods import GaussianLikelihood, LikelihoodList, MultitaskGaussianLikelihood
from gpytorch.mlls import SumMarginalLogLikelihood, ExactMarginalLogLikelihood
from gpytorch.distributions import MultivariateNormal, MultitaskMultivariateNormal
# PyTorch
import torch
# Math, avoiding memory leak, and timing
import math
import gc
import math
创建一个批量 GPyTorch 模型
为了创建一个批处理模型，更一般地说，是 GPyTorch 中的任何模型，我们子类化的gpytorch.models.ExactGP类。像标准 PyTorch 模型一样，我们只需要为这个类定义构造函数和forward方法。对于这个演示，我们考虑两个类，一个在我们的整个输入空间上有一个内核，另一个在我们的不同输入上有一个分解的内核【5】。
全输入，批量模式:
该模型使用包装有输出比例超参数的 RBF/平方指数核来计算输入的所有维度之间的核。此外，您可以选择使用自动相关性确定(ARD) [2]为每个特征维度创建一个长度比例参数。
分解后的内核模型:
该模型使用 RBF/平方指数核的乘积计算输入的所有维度之间的分解核，每个核考虑特征空间的单独维度。然后，用 outputscale 超参数包装这个分解后的产品内核。此外，您可以选择使用自动相关性确定(ARD) [2]为两个 RBF 核中的每个特征维度创建一个长度尺度参数。
预处理数据
为了准备拟合高斯过程回归的数据，考虑如何拟合我们的模型是有帮助的。为了利用 PyTorch [3]和 CUDA [4]的硬件加速和批处理，我们将我们预测的变量集的每个结果建模为独立的。
因此，如果我们有需要拟合插值的 B 批数据，每一批都有 N 个样本，X 维度为CY 维度为 D ，那么我们将数据集映射到以下维度:
- X 数据:(B，N，C) → (B * D，N，C)……这是通过平铺完成的。
- Y 数据:(B，N，D) →(B * D，N)……这是通过堆叠完成的。
在某种意义上，我们平铺我们的 X 维数据，使得对于我们的向量值 Y 取的每个值，特征重复 D 次。这意味着我们的批量模型集中的每个模型将负责学习一批 X 的特征和同一批 Y 、、中的单个输出特征之间的映射，从而导致我们的批量模型中总共有 B * D 个模型。这种预处理(平铺和堆叠)是通过以下代码块完成的:
# Preprocess batch data
B, N, XD = Zs.shape
YD = Ys.shape[-1]
batch_shape = B * YD
if use_cuda: # If GPU available
output_device = torch.device('cuda:0') # GPU
# Format the training features - tile and reshape
train_x = torch.tensor(Zs, device=output_device)
train_x = train_x.repeat((YD, 1, 1))
# Format the training labels - reshape
train_y = torch.vstack(
[torch.tensor(Ys, device=output_device)[..., i] for i in range(YD)])# train_x.shape
# --> (B*D, N, C)
# train_y.shape
# --> (B*D, N)
我们执行这些转换是因为尽管 GPyTorch 拥有为批量模型和多维模型(在包文档中表示为多任务)设计的框架，不幸的是(据我所知)GPyTorch 还不支持批量多维模型。由于批处理和硬件加速，上述代码无法对 Y 的不同维度之间的相关性进行建模，从而大幅提高运行时间。
训练批量、多维 GPR 模型！
现在，随着模型的创建和数据的预处理，我们已经准备好训练了！下面的脚本使用 PyTorch 的自动微分框架执行优化超参数的训练。在这种情况下，优化了以下批量超参数:
- 长度刻度
- 输出规模
- 协方差噪声(原始和受限)
请查看本页 [5],了解关于每个超参数的作用的更多信息。
该培训功能如下所示:
运行推断
现在，我们已经在训练数据上训练了一组批量多维高斯过程回归模型，我们现在准备运行推断，在这种情况下，用于插值。
为了证明这种拟合的有效性，我们将训练一个批量多维模型，并将其预测与根据随机生成的数据评估的解析正弦函数进行比较，即
X = {xi}，xi ~ N(0_d，I_d)，i.i.d.
Y = sin(X)，逐元素，即 yi = sin(xi)对于所有 i
(其中 0_d 和 I_d 指 d 维零向量(零均值)和 d 维单位矩阵(单位协方差)。上面的 X 和 Y 将作为我们的测试数据。
为了评估这些预测的质量，我们将计算结果预测的均方根误差(RMSE) 与 Y 的真实分析值进行比较。为此，我们将每批抽取一个测试点( X 中的 C 尺寸，以及 Y 中的 D 尺寸)，即我们在批量 GPR 模型中拟合的每个 GPR 模型将预测单一结果。将对所有批次的预测样本计算 RMSE。
结果
上述实验导致各批次的平均 RMSE 约为 **0.01。**自己试试！
下面是从上面的脚本生成的结果，显示了 X 和 Y: 中每个维度的预测值和真实值
将我们的预测值与真实分析值进行比较的结果。第一列显示 X 的前两个维度与 Y. 的给定预测维度的关系第二列显示 X 的前两个维度与 Y. 的给定真解析维度的关系最后一列显示 X 的给定维度与 Y. 的相同预测维度的关系图片来源:作者。
下表列出了基础数据分布不同方差程度的 10 次迭代的平均 RMSE 值:
在我们的批量多维高斯过程回归模型的测试集上，基础正态分布与平均 RMSE 的方差。图片来源:作者。
总结
在本文中，我们看到我们可以使用 GPyTorch、创建批处理、多维度高斯过程回归模型，这是一个最先进的库，在其后端利用 PyTorch 进行加速推理和优化。
我们使用解析正弦波实验评估了这种批量多维高斯过程回归模型，并发现在对多元(即独立数据)标准正常生成的数据进行回归时，我们能够实现约为 0.01 的 RMSE ，这表明这些模型的非参数功效非常适合各种函数近似和回归任务。
敬请关注完整的 GitHub 资源库！
这里有更多的可视化！请注意，下面的模型利用的批量大小为 1，但与上面的模型来自同一个类，并为每个输出维学习一维高斯过程回归量。
将 GPR 拟合到 Ackley 测试函数。图片来源:作者。
将 GPR 拟合到 Branin 测试函数。图片来源:作者。
将 GPR 拟合到 Rastrigin 测试函数。图片来源:作者。
用余弦 8 测试函数拟合探地雷达。图片来源:作者。
参考
[1]奥利弗，玛格丽特和理查德·韦伯斯特。“克里金法:地理信息系统的一种插值方法.”《国际地理信息系统杂志》4.3(1990):313–332。
[2] Gardner，Jacob R .等，“Gpytorch:带 gpu 加速的黑盒矩阵-矩阵高斯过程推断。” arXiv 预印本 arXiv:1809.11165 (2018)。
[3]亚当·帕兹克、萨姆·格罗斯、弗朗西斯科·马萨、亚当·莱勒尔、詹姆斯·布拉德伯里、格雷戈里·查南、特雷弗·基林、林泽铭、娜塔莉亚·吉梅尔斯海因、卢卡·安提加、阿尔班·德斯迈松、安德烈亚斯·科普夫、、扎卡里·德维托、马丁·赖森、阿利汗·特贾尼、萨桑克·奇拉姆库尔蒂、伯努瓦·施泰纳、、、、接君·巴伊和苏史密斯·钦塔拉。Pytorch:命令式风格，高性能深度学习库。在 H. Wallach、H. Larochelle、A. Beygelzimer、f .达尔凯-Buc、E. Fox 和 R. Garnett 编辑的《神经信息处理系统的进展》第 32 卷第 8024-8035 页中。柯伦联合公司，2019。
[4] NVIDIA，Vingelmann，p .和 Fitzek，F. H. P. (2020 年)。 CUDA，发布时间:10.2.89 。从 https://developer.nvidia.com/cuda-toolkit取回。
[5]仁食谱，【https://www.cs.toronto.edu/~duvenaud/cookbook/】。
使用云调度程序和函数在 GCP 批处理作业
演示如何使用云调度程序、发布/订阅和云功能在 GCP 平台中设置无服务器批处理作业。
卢卡斯·布拉塞克在 Unsplash 上的照片
在设计和实现解决方案时，我经常面临围绕数据存储和处理设置循环批处理作业的需求。最近，我一直在努力让我的基础设施尽可能保持无服务器，所以在这篇文章中，我将向你展示如何利用谷歌云平台来免费运行你的项目可能需要的几乎任何批处理作业**。**
用例
对我来说，当涉及到数据处理、协调和清理时，这个批处理模式是最有用的。这是一个涉及数据聚合的示例…
存储桶可以是一个有效的流数据存储库，但是如果您的有效负载很小并且很频繁，那么如果您必须频繁读取，为每个有效负载创建一个文件会非常昂贵。我通过运行一个批处理作业来解决这个问题，将单独的有效负载合并到每小时或每天的文件中，这是一个更具成本效益的解决方案。
或者数据库清理怎么样…
如果您有一个包含大型时间序列数据集的 SQL 数据库，定期清除对性能至关重要。您可以将一个重复的作业压缩到一个 web 应用程序或 ETL 系统中，该系统将数据加载到您的表中，但是我使用这种无服务器批处理方法来解耦解决方案并简化维护。
体系结构
我们将使用 3 个 GCP 服务来实现我们的无服务器批处理解决方案。云调度器将触发我们的批处理事件，发布/订阅将用于将事件传输到云函数，云函数将执行所需的批处理操作。
作者图表
定价
GCP 提供了一个非常慷慨的免费层，我在下面为我们需要调度和运行批处理作业的三个服务做了一个简化的成本表。每 5 分钟运行一次的批处理作业将使用 1 个云调度程序作业、大约 9，000 次云功能执行和大约 9MB 的发布/订阅吞吐量。
作者图表
如果你的项目需要 3 个以上的工作，你将被收取每月 10 美分的额外工作。
配置
发布/订阅
首先，让我们配置一个发布/订阅主题，因为在我们设置调度程序和无服务器功能时都需要它。主题可以在 GCP 控制台的这里进行配置。
作者图表
- 正如你所看到的，我们需要配置的只是主题名称——我使用的是
example-topic
云调度程序
接下来，我们将云调度器配置为我们的批处理触发器。点击这里并创建您的调度作业。
作者图表
- 在我的示例中，我将调度程序配置为每 30 分钟运行一次，但是您可以根据需要设置任何时间段
- 指定我们在上一步中创建的主题—我使用的是
example-topic - 我们的云函数不需要任何东西，除了来自调度器的触发器，所以有效载荷值并不重要，你可以输入任何值——我用的是
run
云函数
我们差不多完成了，最后一步是创建一个云函数，当调度程序触发一个事件时，这个云函数就会被触发。这里可以找到云功能配置。
作者图表
- 选择云发布/订阅作为触发类型
- 选择在第一步中创建的主题
- 继续进行代码配置—我将使用现成的 Node.js 函数。该函数只是记录发布/订阅有效负载的内容。
该功能可能需要一分钟才能完全部署。
请记住，在这一步中，您可以使用任何可用的编程语言。
测试
为了测试我们的配置，我们需要查看云调度器列表，并使用RUN NOW选项手动触发我们的调度器。
作者图表
为了确保我们的功能成功触发，我们可以前往我们的云功能列表，选择您之前配置的功能并查看Logs选项卡。
作者图表
您应该看到日志输出，表明您的函数已经运行，并且还应该显示您为云调度程序配置的有效负载消息。
成功了！
结论
现在，在 5 分钟内，我们配置了一个 100%免费的解决方案，您可以使用它来运行各种类型的批处理作业。如果您发现自己需要快速设置一个高度解耦的解决方案来启动或运行批处理作业，那么现在您可以使用 GCP 快速简便地完成它。
祝好运，编码快乐！
原载于 2021 年 2 月 7 日【http://www.theappliedarchitect.com】。**
面向人员分析应用的自动 ML 巨头之战
评估用于员工流失预测的 Tpot & Pycaret 自动机器学习库
展望未来并预测将要发生的事情有多强大？在数据科学中，机器学习实现了这一点！巧妙的，通过从过去发生的事情中学习来预测未来可能发生的事情。我们可以想象，这种技术的应用在人员分析中可能是革命性的，一个经典的用例是预测员工辞职。
自出现以来，ML 已经成熟了很多，并且今天处于这样一个阶段:初涉概念并且通常被预测分析的想法吓倒的数据科学家也可以投入到探索 ML 中，并缩短解决问题的时间。Auto ML 正是实现这一点的途径—为您的数据集评估和应用最佳 ML 管道来执行预测分析。因此，我强烈鼓励人员分析师(具有编程知识)采取这些令人放心的步骤进入预测分析的世界。在本文中，我们将在开源数据集上评估两个强大的 auto ML 库— Tpot 和 Pycaret，以根据一些已知的特征信息预测流失—某人是留下还是离开。
为什么是自动 ML？
对我来说，选择 auto ML 而不是传统 ML 是一个很容易的决定，因为前者可以缩短从数据准备到预测的求解时间。因为当你试图按照下图中概述的步骤顺序，一次对一个 ML 模型进行优化，使其对你的数据集具有最佳预测能力时，会浪费很多时间。而在 auto ML 中，一般来说，所有这些步骤，包括超参数调整、对单个模型进行分组以产生整体最佳组合预测模型，都被配置为在其母公司的保护下发生，用户的干预最少甚至没有。
作者图片
了解基础知识
下一部分将说明正在评估的两个 auto ML 库如何在开源 HR 流失 Kaggle 数据集上预测流失。在此之前，我们需要熟悉下图中捕获的一些关键指标— 混淆矩阵、精确度、召回率、F1 ，以选择获胜的 ML 模型。请注意，这并不是评估任何机器学习模型的所有指标的详尽列表，而是与手头的任务最相关的，并且已经结合这个特定的 ML 任务进行了解释。
作者图片
在看了上面的关键因素之后，我还建议看一下 AUC (曲线下面积)分数，简单地说，它衡量真正积极预测与随机猜测的准确性。准确性度量是所有观测值的所有真实预测(包括正面的&负面的)的度量，与精确度和召回率相比，它在这种情况下并不是一个非常具有指示性的度量，因为一个模型可以基于它对留下的群体(真实的负面)的正确预测而高度准确，但是它对离开的群体(真实的正面)的预测可能完全错误，这是我们情况下的目标。
值得注意的是，本文中考虑的示例是监督(二元)分类机器学习模型——分类，因为响应变量是分类的，保存表示员工离开或留下的值。因此，这些指标实际上是以一种简化的方式根据案例研究进行解释的。
评估自动 ML 库
有许多介绍评估模型的在线资源；本文下面的参考资料部分包含了一些有用的链接，供进一步阅读。本文将着重于通过理解给定的数据集，将 Pycaret 和 Tpot auto ML 库应用于预测辞职员工的业务任务。
第一步是在命令提示符窗口中使用pip install tpot和pip install pycaret安装我们正在评估的 auto ML 库。安装完成后，下一步是打开 Jupyter 环境进行编码(本文使用 JupyterLab 作为编码平台)。
让我们从库和数据集的导入开始。
作者图片
打印数据集的形状(或者更具体地说，pandas 数据框)显示有 14，999 行和 9 列。head()函数输出数据集中的前 5 行，让我们对正在处理的信息有所了解。
作者图片
很明显，标有“左”的列表示流失，“1”表示离开的人，“0”表示继续留下的人。这是我们的回应栏目。剩余的列是特征，我们将把它们提供给 ML 模型，以解释与响应的关系，然后基于这些解释进行预测。
我们可以进一步推断，所有的特征列都是数值型的，仅仅是因为它们保存的值不是离散的(就像性别—男性，女性是离散值)。这也适用于“薪金”列，该列包含“低”、“中”和“高”的值，因此清楚地展示了这些值之间的内在关系，即高薪金>中薪金>低薪金。在我们评估 auto ML 模型之前，使用下面的代码进行一个简单的检查，确认是否有任何列包含丢失的值，但是幸运的是，对于这个数据集，没有丢失的值，代码只是返回 0。在您可能正在处理的真实业务案例数据集中，决定您希望如何处理任何缺失值(删除它们或估算平均值等)至关重要。通常，auto ML 库在建模中配置了某种程度的缺失值插补，以满足大多数情况。
作者图片
1。Pycaret
让我们从设置 Pycaret 分类模块开始。这一步必须通过的元素是“数据”中的数据框和“目标”参数中的响应列。还有更多的参数可以使用，并进一步增强 setup()函数的用法；然而，对于这个示例，我们将退回到依赖配置默认值。在缺省值中需要指出的是，训练测试分割是 70–30 %,除非在调用 setup()函数时进行了调整。
作者图片
从下面执行 setup()函数的输出中可以看出，Pycaret 将大多数特性列解释为 categorical。
作者图片
我们可以使用“numeric_features”参数传递我们想要将数据类型更改为数字的列，因此更新后的代码如下所示。
作者图片
执行这个更新的设置代码现在显示了作为列表传递给“numeric_features”参数的特性列，所有这些特性列都反映为数字数据类型。
作者图片
我们仍然需要处理“salary”列，将其从当前的分类数据类型转换为“Numeric”因为列中的值是字符串类型，所以一种转换方法是为这些字符串值分配数字，以保持高>中>低:2>1>0 的关系。这种改变可以在评估 ML 模型之前作为数据准备的一部分来完成，因为它也是评估 Tpot 的通用改变。
作者图片
现在我们可以看到,“salary”列中的值已经被转换为代表以前的低、中和高字符串值的数字。随后，执行 Pycaret 分类 setup()并在列表中为“numeric_features”参数传递“salary ”,可以将所有功能列反映为数字数据类型。
作者图片
作者图片
然后，根据 setup()函数的提示，我们可以按“enter”键来初始化模型，并开始可视化 auto ML 可以带来的神奇效果这一激动人心的部分。通过调用下面的 compare_models()函数，我们将在代码环境中看到 Pycaret 对训练分割运行 10 重交叉验证，以对特征与响应的关系做出最佳解释，从而实现对测试分割或未来未知数据的最佳预测。默认结果排序是通过准确度度量，因此被称为通过 F1 度量排序的参数，以查看此处用例的最佳精度-召回平衡模型。
作者图片
作者图片
具有最佳度量分数的 ML 模型方便地用黄色突出显示，以便缩小和简化我们的选择过程。在执行 compare_models()函数之后，变量“best_model”保存这种情况下的随机森林分类器。对于给定的数据集，我们可以简单地使用随机森林分类器模型，因为这个 ML 模型显示了最有希望的整体度量分数。没有比这更简单的了！
需要注意的是，作为 compare_models()函数输出的指标是 10 次交叉验证的平均值。现在让我们看看测试分割的混淆矩阵，以揭示预测与实际相比有多准确。
作者图片
作者图片
我们可以看到，与真实阴性和真实阳性中反映的绝大多数准确预测相比，假阴性和假阳性中反映的失误相当小，因此解释了> 95%的平均指标。
绘图模型还有其他基本绘图套件，您可以通过更改“plot”参数来指定其他值，如“pr”来绘制精度-召回曲线，“auc”来绘制 ROC 曲线并确认 AUC，等等。
预测的最后一步非常简单，只需调用 predict_model()函数并传递所选的 ML 模型和数据集来进行预测。对于此图，初始数据集已被重新使用，但可以很容易地调整为一个新的数据集，其中包含模型的未知数据，以便进行新的预测。
作者图片
正如我们在下面看到的，predict_model()函数输出提供了额外的列—“Label”反映了 ML 模型对数据集中每个行项目的预测，而“Score”反映了“Label”中预测的概率百分比这就是我们所需要的，让我们的商业利益相关者对那些可能离开的人有所预见，以便采取适当的行动来留住他们。
作者图片
2. TPOT
与 Pycaret 相比，Tpot 在执行方面有所不同。首先，我们需要分割整个数据集，以清楚地定义“X”和“y”中的特征和响应，并进一步定义与 Pycaret 保持一致的 70–30%的训练测试分割。形状函数输出确认分割。
作者图片
作者图片
类似地，在准备训练 Tpot 分类器模型时，将“n_splits”参数设置为 10，以匹配与 Pycaret 一致的 10 重交叉验证。针对此用例调整的其他参数与您将在下面的参考资料链接中找到的参数相比，是“计分”从准确性更改为 f1，类似于在 Pycaret 中基于相同的精度-召回平衡指标选择排名最佳的模型，以及“n_jobs”从-1 更改为 6，这影响了 Tpot 构建 ML 管道所用的系统内核数量(数字越大，使用越少，因为-1 会用完所有内核)。
作者图片
Pycaret 与 Tpot 的一个重要区别是，后者需要将近 2 个小时来拟合最佳 ML 模型，而前者只需不到 2 分钟。2 小时后，这是 Tpot 在拟合了列车特征-响应后的输出。对于给定的数据集，性能最好的 ML 管道获得了大约 97.2%的平均 F1 分数，这与我们从 Pycaret 的 compare_models()函数输出中获得的结果没有太大的不同。我们还看到，顶级模型本身是 KNeighbours 和决策树分类器的组合，因此这也不同于 Pycaret 的最佳模型输出。
作者图片
太好了！既然我们已经走了这么远，让我们最终使用训练过的 Tpot 模型来访问测试集上的预测，并看看我们是否真的取得了优于 Pycaret 的结果。要执行预测，我们只需调用函数plot_metrics(X_test, y_test, model)，其中 plot_metrics()是一个自定义函数，它被定义为使用传统的 matplotlib 和 seaborn 库来获得下面的图(代码细节请参考参考资料中提供的 GitHub gist 链接)。
作者图片
结论
我们上面看到的结果表明，对于这个给定的数据集，通过最少的干预和时间，我们可以缩小范围并可能“生产化”的最佳自动 ML 将是 Pycaret。很重要的一点是，用实际业务数据最终确定 ML 模型可能需要比依赖默认值更多的实验(如超参数调整、堆叠、混合模型、特征缩放等)。)即使使用 auto ML，也要在初始缩小部分做大量繁重的工作。愉快地探索您的业务数据！
- 延伸阅读资源 —
整体之战——随机森林 vs 梯度推进
机器学习领域最流行的两种算法，谁会赢？
Geran de Klerk 在 Unsplash 上拍摄的照片
如果你在机器学习领域呆过一段时间，你肯定听说过一个叫做偏差-方差权衡的概念。这是任何机器学习实践者都应该学习和意识到的最重要的概念之一。
本质上，偏差-方差权衡是机器学习中的一个难题，即具有低偏差的模型通常具有高方差，反之亦然。
偏差是模型预测的实际值和期望值之间的差异。结果，一个高偏差的模型被认为是过于简单，数据拟合不足。
另一方面，方差表示模型对训练数据中微小波动的敏感性。具有高方差的模型对噪声敏感，因此会过度拟合数据。换句话说，该模型非常适合训练数据，但不能概括看不见的(测试)数据。
考虑到这一点，在本文中，我想分享几种平衡偏倚和方差的技术之一:集成方法。
首先，什么是合奏法？
集成方法涉及聚合多个机器学习模型，目的是减少偏差和方差。理想情况下，集成方法的结果将优于任何单独的机器学习模型。
有 3 种主要的集合方法:
- 制袋材料
- 助推
- 堆垛
出于本文的目的，我们将只关注前两个:打包和提升。具体来说，我们将检查和对比两种机器学习模型:随机森林和梯度增强，它们分别利用了打包和增强技术。
此外，我们将在本文的后半部分应用这两个算法来解决泰坦尼克号生存预测竞赛，以了解它们在实践中是如何工作的。
https://www.kaggle.com/c/titanic
决策图表
在我们开始之前，重要的是我们首先理解什么是决策树，因为它是随机森林和梯度推进的基础算法。
决策树是一种监督学习算法，它为任何基于树的模型(如随机森林和梯度推进)奠定了基础。决策树可用于分类和回归问题。
树的每个节点代表一个变量和该变量上的一个分割点(假设该变量是数值型的)。树的叶节点包含树用来进行预测的输出变量。
让我们以 Kaggle 房价预测比赛为例。
假设我们正在构建一个决策树模型，该模型将考虑一所房子的各种特征，例如卧室数量、地段大小、邻居位置等，以便对其最终销售价格进行预测。
为简单起见，假设我们模型的最终结果看起来像这样:
图片来源丹·贝克尔，卡格尔
给定一个随机房屋，我们的模型现在能够从决策树的最顶端(根节点)向下遍历到树的底部(叶节点),并给出该特定房屋的预测价格。
更具体地说，基于这个模型，一栋拥有两个以上卧室、面积大于 11，500 平方英尺的房子的预测价格为 233，000 美元，以此类推。
当然，决策树可以变得比上面显示的更加复杂和精密，具有更大的深度和更多的节点，这反过来将使树能够捕捉预测器和目标变量之间更详细的关系。
随机森林(装袋)
既然我们已经了解了什么是决策树以及它是如何工作的，让我们来检查一下我们的第一个集成方法，bagging。
Bagging 也称为 bootstrap aggregating，是指使用不同的训练数据子集(引导数据集)创建和合并独立、并行决策树集合的过程。
密切注意的话，独立和*平行。*使用随机森林构建的决策树对模型中的其他树没有任何知识和影响。这是装袋的一个关键特征。
一旦构建了所有的树，模型将选择由单个决策树做出的所有预测的模式(多数投票),并将结果作为最终预测返回。
我希望现在已经很清楚，装袋通过在多棵树上分散错误的风险来减少对单棵树的依赖，这也间接减少了过度拟合的风险。
显然，随机森林并不是没有缺陷和不足。以下是一些应该和不应该使用随机森林的情况:
何时使用随机森林
- 它可用于分类( RandomForestClassifier )和回归( RandomForestRegressor )问题
- 您对预测值的重要性(特征重要性)感兴趣
- 您需要一个快速的基准模型，因为随机森林可以快速训练，并且需要最少的预处理，例如特征缩放
- 如果您有杂乱的数据，例如缺失数据、异常值等
何时不使用随机森林
- 如果你正在解决一个复杂、新奇的问题
- 透明度很重要
- 预测时间很重要，因为模型需要时间来聚合来自多个决策树的结果，然后才能得出最终预测
总结一下随机森林，这里有一些要考虑的关键超参数:
- n_estimators: 控制将建立多少个单独的决策树
- max_depth: 控制每个单独的决策树可以有多深
梯度推进(推进)
另一方面，Boosting 采用迭代方法，通过关注先前迭代中的错误，将多个弱的顺序模型组合起来，创建一个强模型。
弱模型是仅比随机猜测稍好的模型，而强模型是与真实分类强相关的模型。
boosting 不同于 bagging 的一个重要区别是，boosting 下的决策树不是独立构建的，而是以连续的方式构建的，其中每棵树都有效地从之前的错误中学习错误。
还值得注意的是，还有其他的增强变体，例如 AdaBoost (自适应增强) XGBoost (极端梯度增强)和 LightGBM (轻度梯度增强)，但是对于本文的目的，我们将只关注梯度增强。
与上一节类似，以下是一些应该和不应该使用梯度增强的情况:
何时使用梯度增强
- 它可用于分类(GradientBoostingClassifier)和回归(GradientBoostingRegressor)问题
- 您对预测值的重要性(特征重要性)感兴趣
- 预测时间很重要，因为与随机森林不同，梯度推进下的决策树不能并行构建，因此构建连续树的过程需要一些时间
何时不使用梯度增强
- 透明度很重要
- 培训时间很重要，或者当您的计算能力有限时
- 您的数据非常嘈杂，因为梯度增强往往会强调甚至最小的误差，因此，它可能会过度适应数据中的噪声
此外，以下是梯度增强需要考虑的一些关键超参数:
- learning_rate: 促进了算法找到最优解的速度和速度
- max_depth: 控制将建立多少个单独的决策树(梯度推进下的树通常比随机森林下的树浅)
- n_estimators: 控制要建立多少棵连续的树(梯度推进下的树的数量通常比随机森林多)
泰坦尼克号案例研究
正如所承诺的，现在让我们在一个实际的项目中应用随机森林和梯度推进，泰坦尼克号生存预测竞赛，以加强我们在本文中已经覆盖的内容。
如果你想继续，请点击这里查看我的 GitHub 上的完整笔记本。
让我们先来看看数据集的前 5 行。
现在，我们将执行一些特征工程和数据预处理，以便为建模准备好数据。具体来说，我们将执行以下操作:
- 在年龄栏中填入乘客的平均年龄
- 将 SibSp 和 Parch 特性组合成一个特性:family_size
- 创建一个新特征 cabin_missing，它作为 cabin 列中缺失数据的指示器
- 对性别列进行编码，将 0 分配给男性乘客，1 分配给女性乘客
- 训练测试分割(80%训练集和 20%测试集)
我将在本文中省略细节，但是如果您对这些步骤背后的基本原理和实际代码感兴趣，请参考我的笔记本。
我们的数据现在可以用于建模了！
随机森林分类器
要查看该模型的默认超参数:
# Default hyperparameters for RandomForestClassifier
print(RandomForestClassifier())
在我们将模型拟合到训练数据之前，我们可以使用 GridSearchCV 来找到超参数的最优集合。
# Set up GridSearchCV
rf = RandomForestClassifier(n_jobs = -1, random_state = 10)
params = {
'n_estimators': [5, 50, 250],
'max_depth': [2, 4, 8, 16, 32, None]
}
cv = GridSearchCV(rf, params, cv = 5, n_jobs = -1)# Fit GridSearchCV to training set
cv.fit(X_train, Y_train)# Best parameters
cv.best_params_
- 最大深度: 4
- n _ 估计量: 50
换句话说，这个训练集的最理想的随机森林模型包含 50 个最大深度为 4 的决策树。
最后，我们可以继续使用这组超参数来拟合我们的模型，并随后评估它在测试集上的性能。
# Instantiate RandomForestClassifier with best hyperparameters
rf = RandomForestClassifier(n_estimators = 50, max_depth = 4, n_jobs = -1, random_state = 42)# Fit model
start = time.time()
rf_model = rf.fit(X_train, Y_train)
end = time.time()
fit_time = end - start# Predict
start = time.time()
Y_pred = rf_model.predict(X_test)
end = time.time()
pred_time = end - start# Time and prediction results
precision, recall, fscore, support = score(Y_test, Y_pred, average = 'binary')
print(f"Fit time: {round(fit_time, 3)} / Predict time: {round(pred_time, 3)}")
print(f"Precision: {round(precision, 3)} / Recall: {round(recall, 3)} / Accuracy: {round((Y_pred==Y_test).sum() / len(Y_pred), 3)}")
- 拟合时间: 0.469
- 预测时间: 0.141
- 精度: 0.797
- 召回: 0.689
- 精度: 0.799
# Confusion matrix for RandomForestClassifier
matrix = confusion_matrix(Y_test, Y_pred)
sns.heatmap(matrix, annot = True, fmt = 'd')
作者图片:随机森林的混淆矩阵
梯度推进分级机
现在，让我们来看看梯度增强如何对抗随机森林。
类似地，要查看该模型的默认超参数:
# Default hyperparameters for GradientBoostingClassifier
print(GradientBoostingClassifier())
使用 GridSearchCV 查找最佳超参数。
# Set up GridSearchCV
gb = GradientBoostingClassifier(random_state = 10)
params = {
'n_estimators': [5, 50, 250, 500],
'max_depth': [1, 3, 5, 7, 9],
'learning_rate': [0.01, 0.1, 1, 10, 100]
}cv = GridSearchCV(gb, params, cv = 5, n_jobs = -1)# Fit GridSearchCV to training set
cv.fit(X_train, Y_train)# Best parameters
cv.best_params_
- 学习率: 0.01
- 最大深度: 3
- n _ 估计数: 250
正如我们所看到的，使用梯度推进构建的树比使用随机森林构建的树更浅，但更重要的是两种模型之间估计量的差异。梯度增强比随机森林有更多的树。
这证实了我们之前讨论的随机森林和梯度增强的结构以及它们的工作方式。
接下来，让我们将我们的梯度推进模型拟合到训练数据。
# Instantiate GradientBoostingClassifier with best hyperparameters
rf = GradientBoostingClassifier(n_estimators = 250, max_depth = 3, learning_rate = 0.01, random_state = 42)# Fit model
start = time.time()
rf_model = rf.fit(X_train, Y_train)
end = time.time()
fit_time = end - start# Predict
start = time.time()
Y_pred = rf_model.predict(X_test)
end = time.time()
pred_time = end - start# Time and prediction results
precision, recall, fscore, support = score(Y_test, Y_pred, average = 'binary')
print(f"Fit time: {round(fit_time, 3)} / Predict time: {round(pred_time, 3)}")
print(f"Precision: {round(precision, 3)} / Recall: {round(recall, 3)} / Accuracy: {round((Y_pred==Y_test).sum() / len(Y_pred), 3)}")
- 适合时间: 1.112
- 预测时间: 0.006
- 精度: 0.812
- 召回: 0.703
- 精度: 0.81
# Confusion matrix for GradientBoostingClassifier
matrix = confusion_matrix(Y_test, Y_pred)
sns.heatmap(matrix, annot = True, fmt = 'd')
图片由作者提供:渐变增强的混淆矩阵
这里，我们观察到，与随机森林相比，梯度增强具有更长的拟合时间，但是预测时间要短得多。
同样，这与我们最初的预期一致，因为训练是在梯度增强下迭代完成的，这解释了更长的拟合时间。但是，一旦模型准备就绪，与随机森林相比，梯度增强进行预测所需的时间要短得多。
概括一下，随机森林:
- 创建独立、并行的决策树
- 使用一些深度决策树可以更好地工作
- 拟合时间短，但预测时间长
相比之下，梯度增强:
- 以连续的方式构建树，其中每一棵树都在前一棵树所犯错误的基础上进行改进
- 与多个浅层决策树一起使用效果更好
- 拟合时间长，但预测时间短
感谢您的阅读。请随意查看我下面的其他文章！
https://medium.com/geekculture/70-data-science-interview-questions-you-need-to-know-before-your-next-technical-interview-ccfbd37a37b3 https://chongjason.medium.com/i-finally-got-a-data-science-job-39f58774785
拜耳大规模建模和加载数据的方法
早在 4 月份，我们就为我们的社区举办了一次在线会议，名为 Orbit 2021 ，通过聆听来自拜耳医药公司的 Henning Kuich、Dan Plischke 和 Joren Retel，我们的社区得以一窥拜耳医药公司的一个团队如何使用 TypeDB 来加速他们的药物研发渠道。
目标
拜耳的团队从根本上想要更好地了解疾病，以便他们能够创造更好的治疗干预措施。对疾病的更深入了解使得能够识别和开发具有很少或没有副作用的新治疗干预。
为了实现这一点，他们需要建立一个模型，准确地表示疾病的生物系统，并将其映射到他们可用的大型生物医学数据集。
挑战
描述疾病—数据模型
为了在 TypeDB 中模拟疾病，他们从可以调整的概念开始。将它们建模为 TypeDB 模式中的实体，如下所示:
define
gene sub entity;
variant sub entity;
protein sub entity;
complex sub entity;
indication sub entity;
这里，gene、variant、protein和complex被选为实体，因为它们可以以某种形式与疾病相关联。通过实体indication对感兴趣的疾病进行建模。在实践中，他们需要捕捉生物系统内部的内在相互关系，而生物是复杂的！当然，这意味着我们需要担心生物系统中大量的其他事情。
比如genes在cells中表示，cells是tissues的一部分，而tissues在一个organisam中。这些数据可以来自临床研究中的分析和实验。将所有这些放在一起，并建立正确的关系模型，可能会得出如下结果:
请注意，由于拜耳所做工作的性质，他们无法展示模型的全部细节
为什么是强类型数据库？
为什么 Bayer 团队选择使用 TypeDB 作为这类建模的数据库？
生物学中的一切都是极其相关和依赖于上下文的，这使得在传统的关系数据库中表示数据非常困难。正因为如此，Henning 和他的团队认为 TypeDB 的类型系统是一种更自然的生物学建模方式。
生物医学实验是高度特定于环境的，因此在构建生物医学知识图时，您希望能够快速询问使用了哪些参数，实际的化验是什么，是在体外还是在细胞中？这需要一个能够捕捉这种复杂程度的数据库，以及一种允许我们轻松地对这些数据提出复杂问题的查询语言。有了 TypeDB，Henning 的团队就能做到这一点。
Bayer 还利用了 TypeDB 中本机推理引擎的优势。推理可以为拥有类似复杂生物医学数据的团队做很多事情。例如，Henning 和他的团队使用 TypeDB 的推理引擎，根据它们在染色体上的位置来推断variant到gene的连接。
基因本质上只是基因组中的序列，实际上是沿着一长串其他位置的位置。变体是这些序列的变体，也沿着相同的数字和位置延伸。使用 type QL(TypeDB 的查询语言)，该团队能够根据重叠位置将变异映射到基因，而不是依赖于其他需要他们导入变异和基因之间关系的数据库。重要的是，这避免了维护其他数据库的需要，因为定期更新和迁移这些数据库需要很长时间。所有这些都可以通过使用 TypeDB 的推理引擎来避免。
TypeDB 还允许您在数据库生命周期中的任何时间点重新定义模式。例如，我们可以添加一个新的定义，根据基因的位置来定义与基因相关的变异。这很重要，尤其是当我们添加新的数据集时。所有这些都使 Henning 的团队能够更有效地运作，并加速他们的药物发现过程。
通过 github 上的 BioGrakn-Covid repo，你可以看到一个在生物学领域完全充实的模式的例子。
加载数据和开源的 TypeDB 加载器
既然有了一个模式来表示我们正在使用的系统，那么大规模加载数据就成了下一个挑战。为了以拜耳想要的方式做到这一点，亨宁和他的团队构建并开源了 TypeDB Loader (以前的 GraMi)，这是一个用于 TypeDB 的数据迁移工具。在这里，我们描述它是如何工作的，以及拜耳团队是如何使用它的。
Henning 的团队决定构建他们自己的定制加载器的原因是，他们想要一种更好、更具可伸缩性的方式来将大量数据加载到 TypeDB 中。为了加载数据，最初的 TypeDB 文档建议构建一个读入文件(例如以表格格式)的函数，并构建一个生成插入查询的模板函数。然后，我们可以使用其中一个客户端驱动程序将其插入到 TypeDB 数据库中。但是，在大规模这样做时，会引入 TypeDB Loader 试图解决的许多挑战:
- 处理所需模板函数的重复逻辑
- 注意潜在的脏数据，防止插入过程中的错误
- 每个事务的插入查询的并行化和批处理
- 大数据容错
TypeDB Loader 是如何工作的？
使用已定义的 TypeDB 模式，我们的第一步是将数据映射到模式。这在两个配置文件中处理。第一个是处理器配置，它包含数据和模式之间的逻辑；例如，必须为每种类型生成哪些属性。这决定了某些属性是否是必需的，并确保获取的数据产生正确类型的正确属性。
第二个配置文件是数据配置文件。在这里，我们可以指定正在读取哪个数据文件，它是什么类型的文件，在处理器配置中使用什么类型的处理器，然后将数据中的列映射到处理器配置中的实际处理器。这确保了所有内容都被正确插入。
拜耳团队还希望能够在数据迁移发生时对其进行监控。插入了什么，哪里可能发生了错误，以及由于什么原因在哪里停止了。这允许您从停止的确切位置重新开始迁移，消除了复制或丢失数据的风险。
现在如何使用 TypeDB Loader？
TypeDB Loader 是一个 Java 应用程序和库，使您能够将其用作 CLI 工具或在自己的 Java 项目中使用。一旦决定了使用这两种方法中的哪一种，就可以指定正在与哪个 TypeDB 实例进行对话以及正在写入哪个数据库。然后提供您的数据配置、处理器配置、TypeDB 模式，然后确定您希望在哪里跟踪迁移状态。这可以像一个 JSON 文件一样简单。
就是这里，TypeDB Loader 从这里开始。Henning 和他的团队正在继续发布更新，并鼓励任何感兴趣的人关注#typedb-loader 频道中关于 Discord 的进展。
TypeDB Loader 的最新版本(GraMi 0.1.1)增加了哪些特性？
- 将带有属性的嵌套关系作为角色扮演者导入
- 将属性追加到现有类型
- 向现有数据追加或插入数据
- 更新模式，包括更新规则
- 对数据插入进行大量测试，以防止数据丢失或错误
- 在迁移开始前捕捉错误的处理器和数据配置验证
- 为快速入门自动生成处理器配置框架
TypeDB 装载机路线图的下一步是什么？
- 改进数据警告日志记录，这是一个更易于理解和解析的整合输出
- 规则管理，使应用和定义或未定义的规则变得更容易
- 直接从 SQL 表中读取，而不仅仅是文件
- 构建 Kafka 连接器，使其成为更大的数据处理基础设施的一部分
理解贝叶斯定理的 3 种方式将提高您的数据科学
入门
掌握这个直观的统计概念将提高你作为决策者的可信度。
贝叶斯定理为我们提供了一种根据新证据更新信念的方法，它考虑了我们先前信念的强度。运用贝叶斯定理，你试图回答这个问题:根据新的证据，我的假设的可能性有多大？
在本文中，我们将讨论贝叶斯定理可以改进您的数据科学实践的三种方式:
最后，你会对基本概念有深刻的理解。
#1 —更新
贝叶斯定理提供了一个检验假设的结构，考虑了先前假设的强度和新的证据。这个过程被称为贝叶斯更新。
贝叶斯定理，其中 A 代表假设，B 代表与假设相关的新证据。
换句话说，这个公式就是“给定 B 的可能性 等于 ( 开括号)给定 B 的可能性 乘以A 的可能性(闭括号 ) 除以B 的可能性”
让我们再看一遍公式，这次是变量的定义:
“根据新证据提出假设的可能性 等于 新证据为真的可能性假设假设假设也为真 乘以 观察到新证据之前假设的可能性，除以( 除以【T41)新证据的可能性。”
这可以进一步缩短:
“后验概率 等于 可能性 乘以 先验概率 除以 b y 边际可能性。”
不管贝叶斯定理现在听起来是否直观，我保证你一直都在使用它。
真实世界的例子
假设你的朋友打电话告诉你，她很抱歉，但她今晚不能来吃饭了。她最近收养了一只患了流鼻涕的宠物考拉。她真的需要呆在家里监控情况。
你的假设是你的朋友不会无缘无故地抛弃你。(毕竟，你做了一个卑鄙的 phở，你的朋友会疯狂地跳过它。)根据她新宠物的最新证据，你的假设为真的可能性有多大？
为了评估我们的朋友因为照顾考拉而不去吃饭的后验概率**，我们需要考虑你的朋友需要和考拉呆在家里的可能性，假设你的朋友是一个正直的人，没有好的理由不会放弃晚餐计划。你可能会得出这样的结论:通常负责任的好朋友很有可能会呆在家里照看宠物。**
接下来，我们将可能性乘以先前的****概率。在你的朋友打电话之前，你对她的晚餐计划的信心有多强？如果你认为你的朋友坚如磐石，通常不愿意在最后一刻改变计划，那么你的先验概率很大，不管有没有新的证据，你都不太可能改变这一观点。另一方面，如果你的朋友很古怪，你已经在想她是否会打电话取消约会，你的先验概率很低，这也可能会质疑她关于和考拉呆在家里的说法。****
最后，我们用考拉所有权的边际可能性除以上面的计算🐨
贝叶斯推理是建立在这种灵活的、常识性的方式上的，这种方式基于我们先验的力量和新证据的可能性来更新我们关于世界的模型。事实上，贝叶斯定理最初的应用是评估上帝的存在。
当涉及到生活和数据科学的关键问题时，作为评估信念如何随时间变化的直观方法，贝叶斯定理是最棒的。
#2 —沟通
正如贝叶斯定理可以帮助你理解和阐明面对新的证据你如何更新你的理论，贝叶斯也可以让你成为一个更强的数据科学传播者。
数据科学从根本上讲就是应用数据来改进决策。
决定你生活结果的只有两件事:运气和你决定的质量。你只能控制这两样东西中的一个。—安妮·杜克，扑克冠军和作家
提高决策质量通常意味着说服决策者。正如每个人的情况一样，您组织中的决策者正在参与对话
真实世界的例子
我曾经是一家热气球制造商的顾问。我的任务是帮助建立一个数据库，提高客户对其供应链、制造流程和销售的端到端理解。
第一天，工厂经理带我们参观了车间，他自豪地描述了一份新的更轻、更便宜的原材料供应商合同。
但是有一个问题。当我的团队将企业内不同数据源的数据表连接起来时，我们发现了新供应商的材料和 2.5%的废品增长之间的联系。
工厂经理有很强的预感，新的供应商对他的业务是一个净积极因素。我们有一些相反的证据。我们也有贝叶斯定理。我们明白这个事实:
先验越强，改变它需要的证据就越多。
在带着我们的发现去找工厂经理之前，我们需要收集额外的证据，证明不存在其他因素，(例如，磨损的机器、新员工、环境条件等)。)导致不同的废料水平。
最终，我们带着更多的证据找到了经理，并帮助他重新谈判供应商合同。
#3 —分类
贝叶斯定理可以应用于文本分析用例，这种技术被称为朴素贝叶斯，因为它天真地假设数据集中每个输入变量(在这种情况下，每个单词)的独立性。
真实世界的例子
假设你发现了一堆你祖父母写的信。他们有一段混乱的关系，有足够的戏剧来证明洛基的浪漫并不局限于真人秀中的年轻人。
来自 Pexels 的 RODNAE Productions 摄影
您希望构建一个情感分类器来确定大多数内容是正面的还是负面的。一种方法是利用朴素贝叶斯。
像朴素贝叶斯这样的生成分类器将建立一个模型，说明一个类(在本例中，正或负)如何生成一些输入数据。给定一个观察(来自我们的 letters 测试语料库的一个新句子)，它返回最有可能生成该观察的类。这与学习输入特征的预测能力的判别分类器如逻辑回归形成对比。
朴素贝叶斯建立在单词袋技术的基础上——基本上是将文档转换成直方图，记录每个单词被使用的次数。
您可以使用我们在第 1 部分中学习的贝叶斯推理公式的稍加修改的版本来计算每个观察的最可能类。稍微修改的是朴素贝叶斯的朴素部分:假设每个单词的概率在给定的类中是独立的，因此你可以将它们相乘来产生句子与类一起的概率。**
via 语音和语言处理 作者丹尼尔·茹拉夫斯基&詹姆斯·马丁
在上面的公式中， wᵢ 表示文档中一个单词的计数 c. 公式的分母是单词落入给定类别的条件概率之和。
公式中的+1 防止了在一个类中没有观察到单词的情况下乘以零的任何机会。这种加一的技术叫做拉普拉斯平滑。
最后，|V|由所有类中所有单词的并集组成。
贝叶斯定理词汇
- 后验概率:根据新证据假设的可能性
- 可能性:假设假设假设为真，证据为真的可能性
- 先验概率:在新的证据出现之前，你相信假设是正确的力量
- 边际可能性:证据
- 朴素贝叶斯(Naive Bayes):一种分类算法，假设数据集特征之间的朴素独立性
- 生成分类器:模拟一个特定的类如何生成输入数据
- 单词袋:将文档转换成直方图的文本的简化表示
- 拉普拉斯平滑:避免乘以零的简单加法平滑技术
摘要
我坚信贝叶斯定理对数据科学家是有用的，但我会根据你在评论中给我的反馈更新后验概率。期待听听大家如何在生活和工作中运用贝叶斯定理。
更多文章促进您的数据科学
**** </10-python-skills-419e5e4c4d66> ****
贝叶斯定理，用可视化清晰地解释
如果您的 COVID 检测呈阳性，那么您实际上患有 COVID 的几率有多大？
动机
想象一下你来医院检测有没有 COVID。您收到了坏消息:您的 COVID 检测呈阳性！然而，你认为结果有可能是错误的。
作者图片
通过在互联网上做一些研究，你知道三条信息:
- 假定一个人是健康的，那么这个人具有阳性测试结果的概率是 0.01
- 假设患者患有 COVID，则患者检测结果为阳性的概率为 0.98
- 患者患有 COVID 的概率为 0.01。
注意:这些数字不是真实的，是为了教学目的而编造的。
如果患者的 COVID 检测呈阳性，那么他患 COVID 的概率是多少？
这个测试似乎有很高的准确性。检测阳性后，你得 COVID 的概率应该很高吧？
在解决这个猜测之前，让我们用贝叶斯定理来回答这个问题。
贝叶斯定理是什么？
贝叶斯定理是一个简单的数学公式，用于计算条件概率。这个定理表明:
作者图片
一般来说，贝叶斯定理使用与事件相关的新信息来更新事件的概率。
让我们试着用一个例子来理解这个定理。想象有 8 人用 COVID 检测出阴性人和 6 人用 COVID 检测出阳性。在测试呈阳性的 6 人中，只有 4 人确实患有 COVID。
我们表示:
作者图片
作者图片
要获得随机选择的 COVID 和检测阳性的人的概率，我们只需将 COVID 和检测阳性的人数除以接受检测的总人数**。**
作者图片
为了得到一个随机选择的人患有 COVID 的概率，假设该人测试结果为阳性，我们将患有 COVID 且测试结果为阳性的人数除以测试结果为阳性的人数。
作者图片
请注意，P(+和 D)与 P(D|+)之间的唯一区别在于
- P(+和 D)的样本空间由所有测试的人组成
- P(D|+)的样本空间仅由测试为阳性的人组成。
请注意，这个等式:
作者图片
类似于等式:
作者图片
因此，我们可以说
作者图片
酷！现在我们了解了贝叶斯定理，让我们用它来解决文章开头提到的问题。
问题
一个人有 COVID 的概率是:
作者图片
这意味着，如果从一组人中随机选择一个人，这个人有 1%的几率患有 COVID。
作者图片
假设一个人是健康的，那么这个人检测结果为阳性的概率是
作者图片
这意味着，如果从一群健康人中随机选择一个人，这个人被检测为阳性的概率是 1%。
作者图片
假设一个人有 COVID，则他的检测结果为阳性的概率为
这意味着，如果从一群患有 COVID 的人中随机选择一个人，这个人被检测为阳性的概率是 98%。
作者图片
问题
如果一个随机选择的人 COVID 检测呈阳性，那么这个人有 COVID 的概率是多少？
作者图片
基于贝叶斯定理，该概率可以通过以下等式来计算:
作者图片
因为
作者图片
我们有:
作者图片
因为我们已经知道 P(+|D)和 P(D)，我们只需要找到 P(+)。
查找 P(+)
P(+)是随机选择的人检测为阳性的概率。我们可以用下面的等式求出 P(+):
作者图片
作者图片
我们已经知道 P(+|D)，P(D)和 P(+|H)，所以我们只需要找到 P(H)。
P(H)可以通过用 P(D)减去 1 得到:
作者图片
作者图片
因此，P(+)是
作者图片
求 P(D|+)
现在我们可以用之前找到的 P(+)的值来找到 P(D|+)。
作者图片
如果一个人的 COVID 检测呈阳性，那么他患 COVID 的概率只有 49.7%！这意味着有超过 50%的几率你没有感染 COVID** ，即使你的 COVID 检测呈阳性。**
作者图片
等等！这听起来不对劲
这里一定有问题！毕竟，我们得到的初始统计数据表明测试具有非常高的精确度**。**
请记住，假设一个人是健康的，这项测试在 99%的情况下都能正确预测这个人的状况。
作者图片
假设一个人患有 COVID，该测试在 98%的情况下都能正确预测该人的状况。
作者图片
为什么如果一个人测试呈阳性，那么这个人确实患有 COVID 的概率小于 50%？因为患 COVID 的人只占 1%。
作者图片
因此，即使测试非常准确，如果您用 COVID 测试为阳性，您也很有可能没有 COVID，因为出现 COVID 的情况非常罕见。****
有了贝叶斯定理，我们可以根据新的信息更新我们的信念。很酷，不是吗？
怎么做才能增加 P(D|+)？
提高 P(D|+)的一个方法是提高测试的准确性。然而，由于测试已经非常准确，很难让它更加准确。
另一个增加 P(D|+)的方法是测试两次。如果随机选择的一个人在的两次检测申请中的每一次检测结果为阳性**，那么这个人实际患病的概率是 99% ！**
作者图片
你可以在这里找到这个概率是如何计算出来的。
模拟贝叶斯定理
为了更好地理解贝叶斯定理，我们可以使用 Seeing Theory ，这是由 Daniel Kunin 创建的一个网站，用于可视化概率和统计。
下面的 GIF 展示了我用视觉理论模拟上面提到的问题。
作者 GIF
你可以试试上面的模拟这里。
右栏的 9 个球是测试呈阳性的人。在这些人中，6 人患有 COVID，3 人健康。
作者图片
我们可以看到这个模拟中的 P(D|+)是 6/9=0.67，和我们之前发现的 0.497 的结果不一样。这是因为我们只模拟了 500 人的实验。
如果我们用非常多的人，P(D|+)会非常接近 0.497。
结论
恭喜你！您刚刚学习了什么是贝叶斯定理，以及如何使用它来解决现实世界中的问题。如果你仔细观察你周围的问题，你会发现贝叶斯定理可以用来解决许多现实世界的问题。
当你想根据一条新信息更新概率时，贝叶斯定理可能会派上用场。
我喜欢写一些基本的数据科学概念，并尝试不同的算法和数据科学工具。你可以在 LinkedIn 和 Twitter 上与我联系。
如果你想查看我写的所有文章的代码，请点击这里。在 Medium 上关注我，了解我的最新数据科学文章，例如:
** **
解释贝叶斯定理
数据科学基础
贝叶斯统计简介
贝叶斯定理提供了一种在有新信息时计算事件更新概率的方法。简单来说就是条件概率的一种计算方式。在这篇文章中，我们将看看贝叶斯定理的概述，然后我们将把这个定理应用到一个简单的问题上。
1.贝叶斯定理概述
我们可以使用贝叶斯定理通过以下公式找到条件概率:
贝叶斯定理公式
这些组件有特殊的名称:
‘一’是利益的事件。作为起点，P(A)代表我们的先验信念:事件 A 发生的概率。利用新证据 B，将后验置信或更新的概率表示为 P(A|B):给定证据 B 的事件 A 已经发生的概率。
我们可以从更常见的条件概率公式中自己推导出这个公式。事件 A 的概率给定事件 B 由下式得出:
等式 1
使用相同的公式，让我们看看给定 A 的 B 的逆概率:
等式 2
如果我们重新排列这个等式，我们会看到:
重新排列的等式 2
现在，如果我们用重新排列的等式 2 替换第一个等式的分子，我们就得到贝叶斯定理的公式。
有些问题我们不会知道 P(B)。这意味着我们需要在求解 P(A|B)之前找到 P(B)。在这种情况下，公式可以扩展为:
现在，让我们看一个应用定理的例子。
2.例子
让我们假设有一种疾病，在一个村庄的 33%的人口中发现。诊断测试具有 86%的敏感性和 79%的特异性。我们想知道如果一个病人检测结果呈阳性，他患病的概率。
2.1.直观地解决它
首先，让我们用直觉来解决这个问题。在这样做的同时，我们希望将概率转化为计数。首先，让我们假设这个村庄有 21 个居民。为什么是 21？因为一幅图像中的 21 只熊猫看起来很合适。任何数字都可以。一般来说，10 的倍数如 100 或 1000 是好的。
📍我们知道的第一条信息是: “有一种疾病，在一个村庄 33%的人口中发现”
有 7 个居民得了这种病。所以剩下的 14 个居民没有患病。让我们想象一下居民们:
全村居民|作者图片
在这里，这两种熊猫代表了某人是否得了这种病:
📍我们知道的第二条信息是: “一个诊断测试有 86%的灵敏度”
这意味着 86%的患病者得到了阳性结果。
患病的 7 名居民中，有 6 人检测呈阳性。所以剩下的一个居民被错误地检测为阴性。
疾病患者|作者图片
在这里，绿光代表阴性测试结果，而红光代表阳性测试结果。
📍我们知道的最后一条信息是: “一个诊断测试有 79%的特异性。
这意味着 79%没有患病的人得到了阴性结果。
在 14 名未患病的居民中，有 11 人检测结果呈阴性。所以剩下的三个居民被错误地检测为阳性。
无病者|作者图片
我们试图回答的问题是:
如果我们观察人群中被检测为阳性的子集，答案就显而易见了:
那些测试过的正面|作者图片
因此，如果测试结果呈阳性，一个人有 67%的概率患有这种疾病。换句话说，虽然一个人一般有 33% (先验)的患病几率，但一旦检测出阳性(证据)，患病的概率就会增加到 67% (后验)。说一个人即使被检测为阳性，仍有 33%的机会患病是愚蠢的。
2.1.用贝叶斯定理解决它
现在，让我们用贝叶斯定理公式来解决它:
由于我们想知道在检测结果为阳性的情况下，患某种疾病的概率，我们可以将事件定义如下:
◼️ 事件 A: 患病
◼️ 事件 B: 检测结果为阳性
虽然我们知道分子中的值，P(正):得到阳性检验的概率并不容易提供给我们。所以我们可以使用扩展公式:
这意味着:
我们知道以下情况:
现在，我们可以将这些值代入公式:
我们得到了同样的答案，但是以一种更简洁的方式。
卢卡斯·乔治·温迪特在 Unsplash 上拍摄的照片
您想要访问更多这样的内容吗？媒体会员可以无限制地访问媒体上的任何文章。如果你使用 我的推荐链接 ，成为会员，你的一部分会费会直接去支持我。
希望你已经对贝叶斯定理有了一些直觉。感谢您阅读我的文章。如果你感兴趣，这里有我其他一些帖子的链接:
◼️️ 比较随机森林和梯度推进
◼️️ 决策树是如何建立的？
◼️️ 管道，ColumnTransformer 和 FeatureUnion 说明
◼️️ FeatureUnion，ColumnTransformer &管道用于预处理文本数据
再见🏃 💨
医学检验的贝叶斯定理
理解医学检验的贝叶斯定理。解释结果和更多测试的组合
照片由 Testalize.me 在 Unsplash 上拍摄
B 阿耶斯定理是统计学中的主要定理之一，也是科学中应用最广泛的公式之一。
直到上世纪中叶，它的重要性一直在稳步增长。现在，它被认为是所有统计学课程的基础，应用于几乎所有的研究领域，而不是工业领域。
乍一看，贝叶斯定理似乎令人困惑，并且常常难以理解，而这在本质上并不容易的统计学领域已经存在。
然而，如果我们分析引导贝叶斯得出他的定理的思维过程，我们会看到这些是自然的和逻辑的思维方式。
定理
贝叶斯定理是以托马斯·贝叶斯牧师的名字命名的。大约在 1740 年，贝氏进行了一项思维实验:他想象自己背靠一张平的方形桌子，把一个球发射到桌子上，但不知道球会落在哪里。
然后，他想到发射第二个球，这次问他的助手球是落在第一个球的左边、右边、前面还是后面。使用这个系统，他能够缩小每次新发射的第一个球的位置。
使用这种系统不可能准确地知道第一个球落在哪里；但是它创造了一种方法，或者说一种思维方式，通过这种方法，每一个新的证据都可以提高估计值。这是他的定理创造的最有趣的范式转变之一
贝叶斯从未发表过他的想法。在他 1761 年去世后，他的朋友理查德·普莱斯发现了他的笔记并扩展了它们。通过应用现代标准，我们应该把这个定理称为贝叶斯价格定理。然而，尽管普莱斯做了工作，这个定理仍然不为人知，直到被皮埃尔·西蒙·拉普拉斯重新发现。他重新陈述了定理给出了“(给定一个事件)原因的概率与事件(给定其原因)的概率成正比”。
用更现代的话来说:贝叶斯定理描述了一个事件发生的可能性，基于可能与该事件相关的条件的先验知识。
经典表示
该公式最经典的表示如下:
贝叶斯定理(作者图片)
其中 A 和 B 是我们想要分析的两个事件，并且:
- P(A)和 P(B)是事件 A 和事件 B 的不同且独立的概率。A 是假设为真的概率。 P(A)是前面的*。*
- P(B) 是看到证据的概率。这个元素叫做。**
- P(A|B) (读作:A 的 P 使得给定 B 的 P 的 B)是条件概率，因此，事件 A 的概率，给定事件 B 已经发生(为真)。这被称为概率** 或条件概率。**
- 反之亦然， P(B∣A) 是 b 给定 a 的概率.假设为真时看到证据的概率。这种可能性被命名为。**
因此，该公式将先验概率与后验概率联系起来，并有可能将新的观察结果整合到基于先前观察结果的已建立模型中。
典型的例子
让我们从一个简单的例子开始，看看当我们拥有所有需要的信息时，贝叶斯定理是如何工作的。
让我们考虑一所由 60%的男生(B)和 40%的女生(G)组成的学校，其中所有的男生都留着短发，而留长发的女生(L)和留短发的女生的比例相等(50/50)。
我们遇到了一个剪短发的学生。 学生是女生的概率有多大？
发型事件与学生的性别有关，因此这些是我们的因变量。学生的性别是自变量。
- 考虑到整个学校，学生剪短发(事件 S)的概率是所有男生加上一半女生:P(S)=60%+(40/2)%=80%
- 假设学生是女生，留短发的学生的相关概率为:P(S∣G) = 50%
这是因为女生在长发和短发之间平分秋色。 - 假设学生是男生，留短发的学生的相关概率是:P(S∣B)=100%
因为所有男生都留短发。
我们现在可以应用公式来计算条件概率*😗**
p(g∣s)= p(g)p(s∣g)/p(s)= 0.4×0.5/0.8 = 0.25→25%
综上，留短发的学生是女生的概率是 16%。
理解医学测试的贝叶斯定理
为了评估诊断测试的性能，我们需要使用通常所说的混淆矩阵。这是一个简单的 2 乘 2 表格网格，其中计算了测试的预测与患者的真实情况。
混乱矩阵(图片由作者提供)
如果患者被预测为阳性，并且确实受到疾病的影响，则称之为真阳性*。***
与之相反的是真阴性*，患者是健康的，并且预测如此。***
剩下的元素是夫妇假阳性*，被认为受影响但健康的人和假阴性，被认为健康但患病。***
很容易看出最后两种在医学上是最危险的。一个假阳性的个体最好的情况是受到惊吓，最坏的情况是不需要治疗。假阴性反而会推迟必要的治疗。
医学悖论
让我们看一个医学测试和逻辑错误的例子，这种逻辑错误经常被称为医学悖论，尽管这种说法并不恰当。
让我们假设我们有一个医学测试，它被宣传有 99%的准确率，对于一种影响 0.1%人口的疾病。如果在 10 万人身上进行。该测试有以下结果:
对 10 万人的测试结果(图片由作者提供)
我们想了解:
测试 P(+)结果为阳性，以及受疾病 P(D|+)影响的概率是多少？
给定 99%的测试准确度，我们可能认为有 99%的测试是准确的。但是贝叶斯定理告诉我们一些其他的东西。让我们看看如何:
让我们找到贝叶斯定理的所有元素:
- 被疾病感染的概率(D)，未经检验等于它在人群中的传播，这是先验假设: P(D) = 0.1%。**
- 与之相反，不患此病的是: P( D) = 1-P(D) = 99.9%
- 测试结果为阳性的概率是所有阳性结果的总和除以品尝的总人数:(97+999)/100，000 = P(+) = 1.096%
- 与之相反的是 P(-) = 1-P(+) = 98.904%
使用混淆矩阵，我们可以构建另一个矩阵来帮助我们解决问题:
(图片由作者提供)
如果我们计算一下，这相当于:
- TPR 通常被称为灵敏度，代表 P(+|D)，等于 97%。
- TNR 或更一般的特异性，因此 P(-| D)等于 99%。
- FNR 也称为遗漏率，P(-|D)等于 3%。
- FPR 已知虚警 P(+| D)的概率为 1%
在这些指标中，灵敏度和特异性是与医学测试最相关的指标，通常最好有一项测试能预测更多的 FP 而不是 FN，因为通常会进行第二次测试来确认疾病，而几乎没有人想再次检查他们是否没事。**
回到我们的问题，看看在测试呈阳性时感染该疾病的概率是多少，我们可以在以下公式中看到所有结果:
- P(D|+)= P(+|D) P(D)/P(+) → 8.9%
- P( D|+) = P(+| D) P( D) /P(+) → 91.1%
- P(D|-) = P(-|D) P(D)/P(-) → 0%
- P( D|-) = P(-| D) P( D)/P(-) → 91.1%
我们可以看到，如果我们以 99%的准确度测试阳性，我们仍然有 91%的概率 P( D|+)健康，只有 9%的概率 P(D|+)患病。这比 99%更不可怕。
鉴于我们的测试和疾病的传播，有 1.1%的人测试呈阳性，只有 9%的人在测试中实际患病。
给定两个阳性测试的患病概率
然而，让我们想象我们想要使用相同的程序做第二个测试。
鉴于两次阳性检测，受影响的概率有多大？
首先，我们需要计算两次结果为正的概率。应该是:
P(++) = P(+│D) P(D)+P(+│ D) P( D)
如果我们计算一下，结果会是:0.0010408
现在，为了计算 P(D|++ ),我们将使用以下公式:
给定两个阳性和相等测试的患病概率(图片由作者提供)
现在的结果是:90.4%
这意味着我们几乎可以肯定，如果进行第二次阳性测试，结果是正确的。我们可以通过增加第三个测试等等来尝试。
贝叶斯测试的美妙之处在于，我们可以根据新的测试来更新我们的信念。
简单解释的贝叶斯定理
如果无知是福，知道如何处理不完整的知识是关键。贝叶斯定理将所有这些形式化。
贝叶斯定理形式化地描述了在我们对影响事件实现的其他因素的不完全了解以及我们预先存在的信念的情况下，如何计算事件发生的概率。比如今天天阴的话会下雨吗？
让我们从一些基本定义开始。事件 A 发生的概率是一个介于 0 和 1(或 0%和 100%)之间的数字，在数学上由某个函数 P(A)表示，称为边际概率，即，与其他事件无关。如果我们同时考虑两个事件 A 和 B ，那么这个概率就是一个二维函数 P(A，B)称为联合概率。值得注意的是，它是对称的，意味着 P(A，B) = P(B，A)。如果这两个事件完全不相关，那么它分解为 P(A，B) = P(A)*P(B)。
接下来我们可能想知道的是，在已知 B 已经发生的情况下，事件 A 发生的概率是多少。这叫做条件概率，用一个函数 P(A|B)来描述。统计学中有一个著名的原理叫做乘积法则告诉你如何从条件事件的联合概率 P(A，B)和边际概率即 P(B)推导出条件概率 P(A|B)。这其实很简单:
P(A|B) = P(A,B) / P(B)
除以 P(B)确保概率在 0 和 1 之间。值得注意的是，条件概率是而不是对称的，这意味着通常 P(A|B) ≠ P(B|A)。例如，阴天下雨的可能性(例如 30%)比下雨时阴天下雨的可能性(例如 99%)要小。
这些关系很容易颠倒过来:
P(A,B) = P(A|B) * P(B)
P(B,A) = P(B|A) * P(A)
这基本上说明了联合概率是掌握系统完整信息的关键。
问题是，在大多数情况下，我们对某个过程的知识是不完整的，这意味着我们无法获得联合概率 P(A，B)！另一方面，在假设事件 B 为真的情况下，我们通常对事件 A 的发生有一些了解，并且我们可能对事件 A 总体发生的可能性有一些预先存在的想法。然后，由德高望重的托马斯·贝叶斯设计的一个定理来拯救我们，告诉我们如何在两个条件概率之间“切换”，即*😗
P(B|A) = P(A|B) * P(B) / P(A)
这很容易通过认识到以下几点得出:
P(A|B) * P(B) = P(A,B)
P(B|A) * P(A) = P(B,A) = P(A,B)
=>
P(A|B) * P(B) = P(B|A) * P(A)
=>
P(B|A) = P(A|B) * P(B) / P(A)
在贝叶斯统计行话中，P(B|A)是后验概率(我们要计算的)，P(A|B)称为似然，P(B)称为先验概率，归一化因子 P(A)是边际似然或模型证据。简单地说，可能性编码了事件 A 在一些假设 B 下可能发生的概率，先验是我们相信 B 实际上是可能的。稍微延伸一下:假设我们已经观察到了看起来像是奇迹的东西，并且我们相信不管上帝是否存在，奇迹都会发生，那么上帝存在的概率是多少？也许这就是托马斯·贝叶斯在考虑的事情。
总结一下:
- 联合概率:P(A 和 B) = P(A，B) = P(B，A)
- 条件概率:P(给定 B)= P(A|B)
- 乘积法则:P(A|B) = P(A，B) / P(B)
- P(A|B) * P(B) = P(A，B) = P(B，A) = P(B|A) * P(A)
- P(B|A)= P(A|B)*P(B) / P(A)(贝叶斯定理)
两个变量之间的联合概率分布示例及其沿 x -和 y 轴绘制的相应裕量概率分布(左)，以及 X2 固定为给定值时 X1 的条件概率分布示例(右)。图片作者。
如果你正在阅读这篇文章，可能是因为你听说过朴素贝叶斯分类器及其在拒绝不需要的电子邮件方面的成功。它是如何工作的，为什么它是“天真”的？
首先，我们在谈论一个分类器，它是一个统计模型，根据一些特征向量 X 的值将实例分成不同的(通常是互斥的)类别。在上面提到的例子中，特征可以是是否下雨，类别可以是是否应该带伞。贝叶斯定理的完全应用将需要相当多的计算，例如归一化因子 P(X)的计算，这通常意味着在多维特征空间上运行马尔可夫链 蒙特卡罗积分。然而，在大多数应用中，我们只想知道类别，而不是(归一化的)概率。这样，定理可以简化为:
P(umbrella | X ) ∝ P(X | umbrella) * P(umbrella)
另一个大问题是特性 X 之间的相关性。在现实生活中，湿度、温度和一天中的时间之间存在相关性，分类器应该在优化步骤中考虑这一事实。例如，湿度的增加可能与温度的增加相关。然而，在实践中，经常会出现这样的情况，即输入要素被处理或设计成其相关性实际上非常小或可以忽略不计。如果是这样，那么可能性(记住这是一个条件概率！)分解为:
P(X|umbrella) = P(rainy|umbrella) * P(cloudy|umbrella) * P(humid|umbrella) * P(hour|umbrella)
因此，对于特征向量的给定实例 X = ( X _1， X _2， X _3， X 4)，算法只需找到 P(雨天=X 1 |雨伞)、P(多云= X _ 2 |雨伞)等的最大值…然后将这些因素相乘:
umbrella = argmax_j P(umbrella_j) * Prod_i[ P(X_i|umbrella_j) ] = max{
P(Y) * P(X_1|Y) * P(X_2|Y) * P(X_3|Y) * P(X_4|Y),
P(N) * P(X_1|N) * P(X_2|N) * P(X_3|N) * P(X_4|N)
}
在许多情况下，处理一个可能有上百个特性的产品会导致数值不稳定或内存溢出。然后，通常采用产品的负对数，而不是最小化函数:
-logP(X|umbrella) = -logP(umbrella) - log(P(X_1|umbrella) - log(P(X_2|umbrella) - log(P(X_3|umbrella) - log(P(X_4|umbrella)
总之，贝叶斯定理是一种计算给定事件 A 的概率的正式方法，这种方法基于对其与其他事件 B _1、 B _2、……以及我们先前的信念的不完全了解。它在统计学中的重要性不能被夸大，它的应用无处不在。我们在这里讨论了朴素贝叶斯分类器，这是一种流行的方法，例如在 scikit-learn 库中实现的方法。我在之前的文章中也讨论过如何用贝叶斯优化来训练神经网络。
贝叶斯定理——机器学习的核心
机器学习基础
贝叶斯定理的一个例子及其重要性
作者形象
许多机器学习模型试图以某种方式估计后验概率。**监督机器学习模型的训练可以被认为是利用所接收的每个数据点来更新估计的后验。**这句话是理解机器学习的关键，要想完全理解它的意义，首先必须理解贝叶斯定理。
贝叶斯定理在数据科学中应用广泛。它构成了机器学习文献的基础。这篇文章形象化了一个小例子，以帮助形成对定理的直观理解。
贝叶斯推断
贝叶斯推断是基于新信息更新结果概率的过程。在收到此信息之前，我们可能预先相信某个事件正在发生。然而，一旦我们收到新的信息，结果的概率可能会改变。正确更新结果概率的方法是通过贝叶斯推断。
贝叶斯定理指出，后验概率(给定所接收的新信息的事件概率)与看到新信息的可能性乘以先前的信念成比例。在机器学习领域，后验概率和先验概率之间的这种比例关系是反复出现的。
贝叶斯推理示例
假设你在面试时被问到以下问题:
乔是一名大学工科学生。试着从下面的陈述中猜测他是否会在他的学士课程中获得一等奖:
“乔最近的一次任务刚得了第一名。乔是个好学生，工作努力”
大多数人可能会认为，乔更有可能获得第一名。让我们编一些数字，应用贝叶斯定理。
- 乔的班上有 100 名学生
- 10 末会得到第一个学士
- 在总共 10 名将获得第一名的学生中，90%符合上述说法
- 在这 90 位没有获得第一的人中，只有 20%符合上面的说法
作者形象
在上图中，底部是随机学生获得第一名的概率。如前所述，这是 10%，并显示为 P(C1)。在这些学生中，90%的人符合这一说法，他们是 P(s|C1)。在没有获得第一名的人中，只有 20%的人符合这个标准，P(s|C2)。
橙色区域是将获得第一个并符合陈述的人员。在“绿色区域”中的是不会获得第一个总体评分但也符合该陈述的学生。
我们知道乔符合这种说法，所以他要么处于有利地位，要么处于不利地位。Joe 出现在橙色区域的概率就是用橙色区域除以橙色和绿色区域之和:
后验概率与似然性乘以先验概率成正比。给定陈述，乔获得第一名的概率是符合陈述的学生获得第一名的概率，除以符合陈述的学生人数。
在实践中，分母通常称为 P(s)，即该陈述为真的学生数。然而，人们几乎总是最终将分母扩展成上面看到的形式。
我们可以把数字代入，看看乔是否会得第一名:
因此，在给出的陈述中，乔获得学士学位的概率只有 33%。即使这句话对得第一名的人来说是正确的 4 倍多，因为只有少数学生得第一名，乔得不到第一名的可能性仍然更大。显然，这是一个愚蠢的例子，我编造了这些数字，但你会明白为什么这种问题可能是反直觉的，为什么贝叶斯推理是如此有用。
结论
现在你可以去看看这篇文章的最初陈述，希望它能给你一个关于机器学习的新视角。
贝叶斯推理、贝叶斯分类器和估计后验概率很容易成为我在机器学习中最喜欢的话题。要理解更复杂的算法，理解这个简单的规则是极其重要的。如果你想了解这个话题的更多内容，可以去 youtube 上的 3Blues1Brown 看看，他对贝叶斯定理有很好的解释，并给出了自己的例子。
支持我
希望这对你有帮助，如果你喜欢它，你可以 跟我来！
您也可以成为 中级会员 使用我的推荐链接，访问我的所有文章和更多:https://diegounzuetaruedas.medium.com/membership
你可能喜欢的其他文章
贝叶斯 A/B 测试在 5 分钟内完成
什么是贝叶斯 A/B 测试，什么时候应该使用它？
A/B 测试的困境。图片作者。
最近，贝叶斯 A/B 测试得到了大量的宣传，因为它的方法易于理解，并允许有用的计算，如治疗优于控制的概率。贝叶斯推理在小样本上也表现得更好；根据 2019 中期帖子，贝叶斯 A/B 测试可以减少 75%的所需样本量。
虽然这些方法在计算上比传统的 frequentist 方法更昂贵，但是它们是离线计算的，这降低了性能要求。主要的挑战是选择有效的分布来支持推理。
任何拥有实验管道和计算机的人都可以利用贝叶斯 A/B 测试技术。以下是如何…
贝叶斯 A/B 测试的步骤
- **根据您的兴趣选择您的发行版。**这里，我们讨论二项式、多项式和指数分布。它们涵盖了大多数业务用例。
- **计算你的先验。**基于上面选择的分布，我们接下来选择一个共轭先验，并选择最能反映我们预实验数据的分布参数。分布参数可手动选择或使用库选择。
- 运行实验。
- **使用蒙特卡罗模拟计算三个关键指标。**这些指标是提升百分比、最佳概率和预期损失。
但是，到底是怎么回事呢？
好了，让我们慢下来，了解一下到底发生了什么。
贝叶斯统计
从第一格开始，我们来说说贝叶斯推断是什么。一句话，贝叶斯推理利用条件概率来帮助我们理解数据如何影响我们的信念。
贝叶斯方法。图片作者。
假设我们从天空是红色的先验信念开始。看了一些数据后，我们很快就会意识到这种先前的想法是错误的。因此，我们执行贝叶斯更新来改进我们关于天空颜色的不正确模型，最终得到一个更准确的后验信念。
似然分布和共轭先验
我们信念的一个关键组成部分是我们数据的结构。我们经常通过分布来描述这种结构。例如，在我们的天空例子中，假设有各种颜色(红色、白色、蓝色等。)，我们的分布将是多项式。如果我们看一组数字，我们的分布可能是正态。如果数据是真/假值，它将是二项式，等等。
这些分布被称为似然分布，因为它们显示了我们的数据呈现某个值的可能性。
对于我们的天空例子，我们正在处理一个多项式分布，但是还有一个分布我们需要考虑。当执行贝叶斯更新时，我们必须考虑概率分布的共轭先验分布。共轭是来自同一个家族的分布。对于我们的情况，多项式分布的共轭先验是狄利克雷分布。
**共轭先验是我们数据的可能性分布的来源。**例如，如果我们正在抛硬币，那么二项式分布显示了抛硬币的次数 n 看起来像是正面的概率 p 。但是，往往 p 本身就有分布。 p 的分布是共轭先验分布。
好吧，那是很多，但是如果你想继续学习共轭先验，这里有一个来自麻省理工学院的很好的资源。
让我们继续将这些发行版用于不同的业务应用程序。
商业中常见的分配
通常，我们可以在业务环境中观察到三种主要类型的数据(尽管其他分布也是有用的):
- 二进制:用户有一个选项可以选择的数据。
- 分类:用户有一组选项可供选择的数据。
- 连续:用户有一组选项可以选择的数据，但是我们只观察这些选项的集合。
对于二进制数据，让我们举一个在线 ML 教科书商店转换的具体例子。 Conversion=1 表示用户购买了一本书，而 conversion=0 表示他们没有购买。
在这个场景中，二项式分布描述了我们的数据。二项式的共轭先验是 beta 分布，下面可以看到这两个分布。
具有不同超参数值的贝塔(上)和二项式(下)。图片作者。
转到我们的第二类数据，分类数据的似然分布是多项式，它的共轭先验是狄利克雷。因为这些图通常是高维的，所以我们不打算展示可视化。
最后，对于连续数据，我们使用带有伽玛共轭先验的指数分布。如果你想知道它们长什么样，可以看看这些链接。
很简单，对吧？根据数据类型，只需应用这些分布就可以了。
贝叶斯统计计算
现在我们已经了解了如何为我们的实验选择一个分布，让我们学习如何确定实验影响。我们通过计算三个统计数据来做到这一点:
- 治疗电梯
- 成为最佳的可能性
- 预期损失
对于我们的第一个计算，治疗提升仅仅是我们的治疗和控制之间的百分比变化。这是我们的治疗效果，可以用下面的公式计算。为了简单起见，让我们假设只有一种治疗和一种对照。
treatment_lift = (treatment - control) / control
对于我们的第二次和第三次计算，我们需要开发一个蒙特卡罗模拟。为什么你会问？因为我们只有一个数据样本，所以我们无法计算任何概率——我们不知道数据在其他样本中会是什么样子。因此，为了生成更多的数据，我们利用了关于我们的数据生成机制(后验分布)的知识和来自该机制的样本。10，000 个样本是一个很好的经验法则。
对于我们的第二个统计数据，即最佳概率，我们只需查看所有模拟样本，并计算我们的处理优于我们的控制的时间百分比。这个比例成为我们的最佳治疗的概率。查看下面的 pythonic 伪代码。
# probability best of treatment
samp_treatment = sample_from_distribution(treatment_dist, n=10000)
samp_control = sample_from_distribution(control_dist, n=10000)probability_best = mean(int(samp_treatment > samp_control))
最后，对于我们的第三个统计，我们希望计算预期损失，即我们为实施不正确的治疗所付出的代价。为了计算预期损失，我们迭代样本并计算 max(treat - control，0) 。然后，我们取这些零界值的平均值来确定我们的预期损失。
# pythonic pseudo code - expected lossloss = mean(max(samp_control - samp_treatment, 0))
预期损失和最佳概率是贝叶斯实验的两个主要卖点。Frequentist 方法不提供任何值。
有关这些计算的详细信息，请查看这篇帖子。
现在你知道了！
实施说明
- 如果你选择一个有效的先验，贝叶斯 A/B 测试需要一个较小的样本量，这样你可以更快地得到结果。
- 贝叶斯方法比频率主义方法计算量更大。
- 当选择先验时，偏向弱先验，即较小的超参数值。
感谢阅读！我将再写 46 篇文章，将“学术”研究引入 DS 行业。查看我对贝叶斯 A/B 测试的链接/想法的评论。
贝叶斯 A/B 测试解释
用 Python 实现解释贝叶斯 A/B 测试
来自水花的图片由亚历山德罗·克罗斯托
A/B 测试在各个行业都有很多应用。从试图确定最佳市场群体到医疗药物测试，它有各种应用，并允许企业根据结果做出决策。有两种常用的方法来进行 A/B 测试，频率主义方法和贝叶斯方法，这两种方法都是从假设测试的基础开始的。在本文中，我将介绍贝叶斯方法在 A/B 测试中的解释和实现。这篇文章假设你对实践中的 A/B 测试有一个很好的理解，如果没有，你可以在这里了解更多关于它和频率主义方法。
目录
- 贝叶斯方法
-贝叶斯机器学习 - 贝叶斯 A/B 测试
-探索漏洞利用困境 - 问题陈述
- 贝叶斯班迪特/汤普森采样
-贝叶斯定理
-贝塔分布 - 履行
- 结束语
- 资源
贝叶斯方法
贝叶斯方法源于一个主要规则，即一切都是随机变量。例如，如果给定某个数据集，并要求您查找数据的平均值和方差，您的输出将只是一个映射到平均值的数值和一个映射到方差的数值。然而，在贝叶斯方法中，你不再寻找一个数字，而是一个分布。
When trying to identify the mean, you can see the difference of approaches below :
Frequentist : ῦ
Bayesian : p(ῦ | data)
贝叶斯机器学习
如果你从机器学习的角度来考虑这个问题，那么你可以看到 A/B 测试在直觉上与强化学习非常相似。强化学习指的是允许代理在一个环境中采取行动，以最大化奖励的概念。A/B 测试可以被视为一组随机实验，随机划分用户，以最大化某些回报。
例如，如果我们要用 A/B 测试对网站上两个按钮的点击率进行建模，不同按钮的不同布局可以被定义为一个动作，点击率的增加可以作为一种奖励。我们想选择一个布局，将最大限度地提高点击率。
贝叶斯 A/B 测试
给定一些数据，贝叶斯程序可以概述为以下步骤[1]:
- 确定先验分布(高斯、泊松、贝塔等。)，这表达了我们在看到任何数据之前对参数(例如ῦ)的初步理解
- 选择一个统计模型(马尔可夫链，贝叶斯土匪等。)这反映了我们对给定ῦ的 x 的信念
- 在观察一些数据后，更新我们的信念并计算后验分布 p(ῦ | x)。后验分布是一种概率分布，它描绘了在观察数据后您对参数的更新信念。
可以想象，观察次数(N)越大，你的后验分布的近似值就越好。然而，如果你的观察次数太多，你会失去很多可以为你的网站带来收入的印象。例如，如果你正在为你的网站运行 A/B 测试，以确定哪个(两个)登陆页面产生非常高的点击率，那么你做的样本越多，你接触到的登陆页面的人就越多，这将减少你可能获得的点击次数。因此，样本大小既不太大也不太小是理想的。
探索漏洞利用困境
在强化学习中，当代理通过评估可能导致积极结果的场景来收集信息时，被称为**探索。在探索之后，人们学习在给定当前已知信息的情况下具有最高可能结果的最优决策，这被称为开发。**最好是平衡剥削，和剥削。
问题陈述
假设您想要测试在您的平台上创建用户的两个不同的位置。你的位置 1 位于网站的左上角，而位置 2 位于右上角。两个登录页面之间唯一的区别是注册按钮在两个不同的位置，其他都是一样的，我们的实验是 iid 。
贝叶斯土匪/汤普森抽样
在我们探索贝叶斯强盗算法之前，我们需要对贝叶斯定理和贝塔分布做一点回顾。
贝叶斯定理
图片由 Tirthajyoti Sarkar 提供从这里
本质上，后验~似然*先验
贝塔分布
这是一个以区间[0，1]为界的连续概率分布，取决于两个参数 α 和 *β。*两个 α 和 β 都必须为正。在不涉及算法的情况下，贝塔分布的概率密度函数可以用下面的公式来模拟:
图片由作者提供
要获得更详细的解释和推导，请访问维基百科的测试版页面这里。
该动画展示了β分布如何随着其参数α和β的不同值而变化。来源: Pabloparsil 来自维基百科
现在我们可以探索贝叶斯土匪/汤普森采样算法。为了这个实验的目的，让我们假设我们知道位置 1 和位置 2 的点击率概率。当然，在现实世界的例子中，这不会发生，但为了评估我们的算法在这种情况下的表现，让我们说p(pos1) = 0.1和p(pos2) = 0.55
既然我们没有任何现存的观察，我们就不可能有任何先验的信念。为了模拟我们的先验概率，我们可以使用α = 1 和β=1 的β分布。这将是[0，1]域上的均匀分布。我们选择均匀分布，因为我们不知道结果可能是什么，因此我们给每一个可能的值相等的概率。注意，对于行业场景，如果您有可用的先验知识，那么您应该在您的实现中使用这些先验知识。
对于这种方法，一步中的后验成为下一步中的先验，我们的后验和先验都可以通过 beta 建模。
** Beta * Data = Beta**
|____| |____|
prior posterior
实施
请注意，由于分布的随机抽样，您的实现可能会有稍微不同的结果。
如你所见，该算法很快收敛到最佳分布。根据这个实验的结果，很明显位置 2 比位置 1 更好，应该是你网站上注册按钮的位置。
结束语
频率主义者和贝叶斯方法的主要区别在于贝叶斯认为参数是随机变量。进行 A/B 测试的步骤贝叶斯方法是确定你的先验分布，选择一个统计模型，并计算和更新你的后验分布。一般来说，贝叶斯方法比其他传统的 A/B 测试收敛得更快。这意味着需要更小的样本才能得出结论。
资源
- [1]http://www.stat.cmu.edu/~larry/=sml/Bayes.pdf
- [2]https://jamesmccaffrey . WordPress . com/2017/11/30/the-epsilon-greedy-algorithm/#:~:text = In % 20 short % 2C % 20 epsilon % 2d greedy % 20 means，the % 20 multi % 2d armed % 20 bandit % 20 problem。
- [3]https://www . dynamic field . com/lesson/Bayesian-approach-to-ab-testing/
- [4]https://towards data science . com/intro-to-reinforcement-learning-the-explore-exploit-dilemma-463 CEB 004989
- https://web.stanford.edu/~bvr/pubs/TS_Tutorial.pdf
- [6]https://github . com/lazy programmer/machine _ learning _ examples/tree/master/ab _ testing
如果您喜欢这篇文章，您可能也会感兴趣:
PyMC3 中的贝叶斯 A/B 测试
贝叶斯统计
抛弃 p 值，拥抱更直观的概率
由 OpticalNomad 在 Unsplash 上拍摄的照片
有时，你不得不在两个选项中做出选择。这可能是在完全不知情的情况下，你只有 50%的可能性做出更好的选择。在一些不知情的情况下，你甚至可以用一个简单的技巧来提高这个概率，正如我在另一篇文章中所展示的。
然而，通常情况下，你能够收集一些信息帮助你选择更好的选项。一个简单而聪明的方法是 A/B 测试，你可能已经听说过或者已经使用过了。
两个实验的结果。是 A 还是 B 产生的价值更高？你对此有多确定？图片由作者提供。
在本文中，我将简要解释 A/B 测试背后的动机，并概述其背后的逻辑。这种方法的问题在于它使用了容易被误解的 p 值。
因此，我们将花时间用少许贝叶斯魔法来改进这种方法，产生贝叶斯 A/B 测试。最重要的是，我们将使用 Python 中出色的 PyMC3 库实现一个简单的贝叶斯 A/B 测试。
如果您不完全确定什么是贝叶斯统计，或者您以前从未使用过 PyMC3，请查看我关于这个主题的入门级文章:
A/B 测试动机
假设您经营着一家相当成功的在线商店，每天有大约 10，000 名访问者。这 10000 人中大约有 100 人实际上在你的店里买了东西——你所谓的转化率大约是 100/10000 = 1%，相当小。
大多数网上商店的转化率在 1-3%左右，亚马逊甚至超过 10%。
因为无论如何都会有很多人光顾你的店铺，但只有很少一部分人成为顾客，所以你决定提高你的店铺的转化率，因为这是提高收入的最大杠杆。你认为:
是什么让人们不买我的好产品？
你想不出一个好的解释，所以你向一些朋友寻求灵感。他们告诉你，他们不喜欢你购买按钮的蓝色。也许红色会更吸引人？这是你可以测试的东西！
让战斗开始吧！图片由作者提供。
方法如下:
以 50%的概率随机将新访客分配到蓝队或红队。蓝队的人会看到蓝色按钮，红队会看到红色按钮。在运行这个过程一段时间后，您检查哪个团队实现了更高的转化率。
*术语:*你称蓝队对照组，红队治疗组或试验组。对照组给你一个指示，如果你让一切保持原样会发生什么，治疗组告诉你如果你做某种干预会发生什么，比如改变按钮的颜色。
请注意，如果您想轻松评估实验，这种随机化很重要。你应该而不是做的事情包括:
- 将所有男性分配到红色团队，将所有女性分配到蓝色团队，因为即使一个团队的转化率高得多，你也无法知道这是因为按钮的颜色还是仅仅因为性别。
- 本周将每个人分配到红色团队，下周分配到蓝色团队，因为即使一个团队的转换率很高，你也无法知道这是因为按钮的颜色，还是因为人们在一周内购买了更多的东西，而不考虑颜色。也许其中一周包括像黑色星期五或圣诞节这样的节日，或者其他更微妙的季节模式。
- …
你明白了。为了提取按钮颜色效果 *，*应该没有其他混淆效果可以解释两个团队的不同转换率。
准备 A/B 测试
让我们假设您为您的 A/B 测试进行了一天的适当的数据收集，并最终获得了一些数据。你有 10，000 名访客，你将他们随机分为蓝队(对照组)和红队(治疗组)。你记下这位游客是否买了东西(编码为 1 )或没有买(编码为 0 )。
我们使用以下代码模拟结果:
import numpy as np
np.random.seed(0)
blue_conversions = np.random.binomial(1, 0.01, size=4800)
red_conversions = np.random.binomial(1, 0.012, size=5200)
你可以看到我把 1%作为对照组转化率，1.2%作为治疗组转化率。所以你已经知道，如果采样没有做什么奇怪的事情，红色按钮应该表现得更好！但让我们从现在开始假装我们不知道这些数据是如何产生的，因为这是我们在现实中经常面临的问题。
另外，请注意，这些组有不同的大小，这通常是随机分配的结果。他们在 10000/2 = 5000 左右，但不太可能得到如此完美的 50:50 分成。然而，这很好。
两个 NumPy 数组都由 1 和 0 组成，大多数条目都是 0。
print(blue_conversions)
# output: [0 0 0 ... 0 0 0]
print(red_conversions)
# output: [0 0 0 ... 0 0 0]
接下来，我们可以检查的是 one(即购买了某些东西的访问者)的份额。
print(f'Blue: {blue_conversions.mean():.3%}')
print(f'Red: {red_conversions.mean():.3%}')
# output: Blue: 0.854%, Red: 1.135%
这表明红色按钮的性能可能会更好，但我们现在还不能确定。即使不同组之间的转化率完全相同，一组最终的转化率也很可能比另一组高。
我们仍然必须排除这仅仅是由于偶然而发生的，这正是 A/B 测试的目的。
进行 A/B 测试
现在让我们看看我们如何能对正在发生的事情提出一个更好的解释。蓝色按钮好还是红色按钮好？首先，我们将再现传统的方式，然后，我们将做贝叶斯风格。
传统的方式
我不会在这里深入探讨，因为有大量的资源可以完美地解释如何进行一个普通的 A/B 测试。你想知道以下两个假设哪个是正确的:
图片由作者提供。
基本上，你计算某种测试统计，例如在费希尔精确测试或 T2 韦尔奇的 t-测试中。然后计算一个 p 值，并检查它是否在某个任意范围内，比如 5%。让我们来看看韦尔奇的 t 测试。
from scipy.stats import ttest_ind
print(f'p-value: {ttest_ind(blue_conversions, red_conversions, equal_var=False, alternative="less").pvalue:.1%}')
# output: p-value: 7.8%
因为有些人纠结于 p 值，你可以这样解读:
假设₀是真实的，我们得到我们观察到的或者更极端的结果的几率最多是 7.8%。
由于 7.8% > 5%，我们保持原假设。没有证据表明红色按钮明显比蓝色按钮好，所以我们只保留蓝色按钮。
我认为 p 值的定义相当不直观——每个曲解过 p 值的人都证明了这一点。最常见的误解如下:
蓝色更好的概率是 7.8%。(错！！！)
虽然这是 p 值告诉你的而不是，但是能够表达出这样一个清晰而简短的陈述是可取的，不是吗？好吧，那么，贝氏拯救。
贝叶斯方法
贝叶斯 A/B 测试有以下优点:
- 它使您能够以一定的概率做出一个版本比另一个版本更好的陈述。正是我们想要的。
- 你不需要知道所有的统计测试。您只需构建一个合适的生成模型，然后按下贝叶斯推理按钮。
我假设你现在已经有一些关于使用 PyMC3 的先验知识，否则，检查我上面的链接文章。
为了更清楚地说明这些优点，让我们借助 PyMC3 用贝叶斯方法来分析我们的问题。首先，我们需要考虑要推断哪些参数。这很容易，有两个未知参数:
- 蓝色按钮的转换率
- 红色按钮的转换率。
我们现在需要决定两个参数的先验分布。由于转换率可以在 0 到 1 之间，所以贝塔分布是有意义的。Beta 分布有两个参数 a 和 b，，你可以通过改变它们来创建不同的分布。
图片由作者提供。
因为我们知道转换率相当小，例如，两者的良好先验都是β(1，99)。
图片由作者提供。
现在，我们必须模拟我们观察到的结果(包含 0 和 1 的数组)是如何与这些参数联系起来的。最直接的方法是使用伯努利变量，因为它们只能取值 0 和 1，并使用单个概率参数。
长话短说，我们可以写下面的小程序:
import pymc3 as pm
with pm.Model():
blue_rate = pm.Beta('blue_rate', 1, 99)
red_rate = pm.Beta('red_rate', 1, 99)
blue_obs = pm.Bernoulli('blue_obs', blue_rate, observed=blue_conversions)
red_obs = pm.Bernoulli('red_obs', red_rate, observed=red_conversions)
trace = pm.sample(return_inferencedata=True)
加上解释，这个程序应该对你有意义。在模型的前两行，我们定义了先验知识。之后，我们设计模型的输出(伯努利变量),并使用observed参数额外给出来自 A/B 测试准备的观察结果。最后一行是著名的贝叶斯推理按钮的 PyMC3 版本。
在trace对象的帮助下，你可以重建转换率的后验分布。
import arviz as az
az.plot_posterior(trace)
图片由作者提供。
我们发现，蓝色的转化率约为 0.854%，红色的转化率约为 1.135%，这与我们的最大似然估计值非常接近，甚至还有一个可信的估计区间。比如蓝率在 0.62%到 1.1%之间，有 94%的概率。
整洁，对不对？但这并没有回答我们的问题。红色按钮的转化率比蓝色按钮的转化率高的概率有多大？为了回答这个问题，我们可以对两个后验分布进行采样，看看红色比率高于蓝色比率的频率。幸运的是，样本已经存储在trace对象中。我们只需了解红色速率样本比蓝色速率样本大的频率。
blue_rate_samples = trace.posterior['blue_rate'].values
red_rate_samples = trace.posterior['red_rate'].values
print(f'Probability that red is better: {(red_rate_samples > blue_rate_samples).mean():.1%}.')
# Output (for me):
# Probability that red is better: 91.7%.
这是我们可以合作的事情！这对我们来说很容易理解，但对其他所有人来说也很容易理解，我特别关注业务部门。红色按钮更好，概率在 92%左右。
完美！”，你想着和你店里的红版，希望它能提高你的转化率。
Uaaa，uaaa，uaaa。图片由作者提供。
现在想象一下:这只是一个微小的变化，却有可能增加你的销售额。可能有各种各样的或大或小的东西你可以修补，让你的商店更好。比赛刚刚开始。
结论
在许多情况下，我们不得不在两个选项中做出选择。这可以只是一个按钮的颜色，也可以是一个对象在网站上的位置，按钮或图像上的文本，或者任何可能被改变的东西。
在两个版本之间进行选择的一种方法是运行 A/B 测试。这个想法很简单:你把你的顾客分成两组，唯一不同的是你想改变的东西，也就是一个按钮的颜色。这样你就可以确定只有你改变的事情导致了结果的改变，其他的都没有。不是人们的年龄或性别，也不是你收集数据的工作日。
通常，人们使用 p 值进行经典的 A/B 测试。虽然这对于统计学家来说是一个熟悉的概念，但普通人经常会对涉及 p 值的陈述感到困惑。这就是为什么我们转向贝叶斯 A/B 测试，它允许每个人都可以很容易地掌握结果。最后，我们甚至可以用 PyMC3 不用太多代码就能得出这样的结果。
我希望你今天学到了新的、有趣的、有用的东西。感谢阅读！
作为最后一点，如果你
- 想支持我多写点机器学习和
- 无论如何都要计划获得中等订阅量，
为什么不通过此链接https://dr-robert-kuebler.medium.com/membership？这将对我帮助很大！😊
说白了，给你的价格不变，但大约一半的订阅费直接归我。
非常感谢，如果你考虑支持我的话！
有问题就在LinkedIn上写我！
贝叶斯 AB 检验—第一部分—转换
系列结构
在之前的一篇博文中，我讨论了使用贝叶斯 AB 测试方法而不是频繁测试方法的优势。在这一系列的博客文章中，我将更深入地研究相关的计算，以及如何在现实世界中实现它们。该系列的结构如下:
- 基于转换的测试度量(速率度量)的建模和分析
- 基于收入的测试指标的建模和分析
- 计算测试持续时间
- 选择一个合适的先验
- 用多个变量运行测试
因此，废话不多说，让我们进入如何在贝叶斯产品实验中建模、使用和分析基于转换的测试指标。
实验背景
根据在上一篇文章中使用的例子，让我们假设我们最近改变了追加销售屏幕上的信息，并希望在向更广泛的用户群发布之前进行 AB 测试。我们假设我们所做的改变将会带来更好的转化率。
与 frequentist 方法类似，我们可以将𝑋促销屏幕上的每次转换建模为伯努利随机变量，转换概率为𝜆:
在频率主义方法下，我们假设𝜆是一个常数，而在贝叶斯方法下，我们将其建模为一个随机变量，有自己的概率分布。我们的第一步是使用过去的数据为这个分布选择一个合适的近似值。我们称之为我们之前的𝜆.分布
然后，我们设定损失阈值，这是我们在犯错时愿意接受的最大预期损失。与任何统计建模一样，贝叶斯实验方法是建立在真实世界数据的近似值之上的。因此，我们总是有可能从测试中得出错误的结论。这个损失阈值让我们可以说，即使我们得出了错误的结论，我们也可以确信转化率不会下降超过我们可以接受的水平。
最后，我们以随机实验的形式抽取样本，并使用这些样本来更新分布，从而更新我们关于𝜆在追加销售屏幕的控制和治疗版本下的信念。我们可以使用这些后验分布来计算治疗优于对照组的概率以及错误选择治疗的预期损失。
所以我们的第一步是选择𝜆.的先验分布要做到这一点，我们可以看看我们最近(过去几周)收集的关于这一转换的数据。我生成了一个样本先验数据集，我们可以用它来做这个练习。
import pandas as pdprior_data = pd.read_csv('prior_data.csv')
print(prior_data.head())
print(prior_data.shape)
因为这个数据集是人工生成的，所以它已经是这个练习的理想格式。在现实世界中，我们可能需要执行一些 ETL 操作来获得这种格式的数据。然而，这超出了本文的范围。
我们看到我们有 5268 个用户的样本大小，对于每个用户，我们可以看到他们是否在这个屏幕上转换。我们可以继续计算之前的转换率。
conversion_rate = prior_data['converted'].sum()/prior_data.shape[0]print(f'Prior Conversion Rate is {round(conversion_rate, 3)}')
选择先验分布
我们看到先前的数据给出了大约 30%的转化率。我们现在用它来为𝜆.选择一个先验分布选择先验是贝叶斯实验方法的一个重要方面，值得单独发表。我将在本系列的第 4 部分中对此进行更深入的探讨。然而，为了这篇文章的目的，我将使用一个粗略的方法来选择一个先验。
我们将使用 beta 分布来模拟我们的转换率，因为它是[0，1]上的灵活分布，也是良好的共轭先验。当我们用实验数据计算后验概率时，这将使我们的计算更容易。
为我们的转换选择先验分布时，最好选择比先验数据建议的更弱的先验。我将在本系列的第 4 部分再次深入探讨这个问题，但是本质上，选择太强的先验可能导致我们的后验分布是错误的，因此可能导致错误的计算和结论。
记住这一点，让我们看看不同强度的潜在前科。
import numpy as np
from scipy.stats import beta
import matplotlib.pyplot as pltfig, ax = plt.subplots(1, 1)x = np.linspace(0,1,1000)beta_weak = beta(round(conversion_rate, 1)*10 + 1, 10 + 1 - round(conversion_rate, 1)*10)beta_mid = beta(round(conversion_rate, 1)*50 + 1, 50 + 1 - round(conversion_rate, 1)*50)beta_strong = beta(round(conversion_rate, 2)*100 + 1, 100 + 1 - round(conversion_rate, 2)*100)ax.plot(x, beta_weak.pdf(x), label=f'weak Beta({int(round(conversion_rate, 1)*10) + 1}, {10 + 1 - int(round(conversion_rate, 1)*10)})')ax.plot(x, beta_mid.pdf(x), label=f'mid Beta({int(round(conversion_rate, 1)*50) + 1}, {50 + 1 - int(round(conversion_rate, 1)*50)})')ax.plot(x, beta_strong.pdf(x), label=f'strong Beta({int(round(conversion_rate, 2)*100) + 1}, {100 + 1 - int(round(conversion_rate, 2)*100)})')ax.set_xlabel('Conversion Probability')
ax.set_ylabel('Density')
ax.set_title('Choice of Priors')
ax.legend()
先验选择(图片由作者提供)
这里我们可以看到三个先验分布，它们的平均转换率约为 30%，与我们的先验数据相似，但都比先验数据的真实分布弱得多。
让我们选择一个在图中最弱和中等先验之间的先验(𝐵𝑒𝑡𝑎(7,15)
其中𝐵(𝑎,𝑏)是被定义为的β函数
并且具有该属性
prior_alpha = round(conversion_rate, 1)*20 + 1
prior_beta = 20 + 1 - round(conversion_rate, 1)*20prior = beta(prior_alpha, prior_beta)fig, ax = plt.subplots(1, 1)x = np.linspace(0,1,1000)ax.plot(x, prior.pdf(x), label=f'prior Beta({int(round(conversion_rate, 1)*20) + 1}, {20 + 1 - int(round(conversion_rate, 1)*20)})')
ax.set_xlabel('Conversion Probability')
ax.set_ylabel('Density')
ax.set_title('Chosen Prior')
ax.legend()
选择的先验(图片由作者提供)
设置损失阈值
既然我们已经选择了先验，我们需要选择我们的𝜖，这是我们在错误选择错误变量的情况下愿意接受的最高预期损失。让我们假设这对我们来说是一个重要的转变，所以我们希望对这个𝜖.相当保守我们不愿意接受超过 0.5%的相对预期损失。所以我们设定𝜖=0.005∗0.3=0.0015.
我们有一个预期损失的先验和阈值，所以我们可以开始运行我们的实验并从中收集数据。
实验结果
让我们假设我们已经让我们的实验运行了几个星期，并想检查我们是否能从中得出任何结论。为了做到这一点，我们需要使用我们的实验数据来计算我们的后验分布，然后我们可以使用它来计算每个变量变得更好的概率，以及错误选择每个变量的预期损失。
出于本练习的目的，我生成了一个样本实验数据集。让我们从探索它和聚合它开始，找出每个变体的转换率。
experiment_data = pd.read_csv('experiment_data.csv')print(experiment_data.head())
print(experiment_data.shape)
我们看到该数据集与之前的数据集相似，只是多了一列，用于指定用户被分配到哪个组，以及他们看到哪个变量。再次值得注意的是，由于这个数据集是人工生成的，它已经是这个练习的理想格式，不需要额外的 ETL 操作。
我们现在可以开始汇总数据了。
results = experiment_data.groupby('group').agg({'userId': pd.Series.nunique, 'converted': sum})results.rename({'userId': 'sampleSize'}, axis=1, inplace=True)results['conversionRate'] = results['converted']/results['sampleSize']print(results)
我们可以通过观察得知治疗有更好的转化率，但我们需要进行进一步的计算，以更新我们对对照组和治疗组变异体各自的转化概率𝜆_𝑐和𝜆_𝑡的看法。
有了我们的实验数据，我们现在可以计算每个变量下的后验分布。但在此之前，让我们探索一下，仅仅从我们现有的信息中，这是如何可能的背后的数学原理。我们将使用一个定理[1]陈述如下:
假设我们有先验知识
假设一个变体被展示给𝑛的访问者，而𝑐改变了信仰，那么该变体的后验分布由下式给出
让我们继续证明这一点。根据贝叶斯定理，我们得到了
由于我们将每次转换建模为具有概率𝜆的伯努利 RV，给定𝜆，我们可以将向𝑛游客展示变量的结果建模为二项式 RV。所以我们有
因此，使用我们先前的定义
现在让我们只考虑系数
利用贝塔函数的定义，我们可以说
将(3)和(4)替换回(2)
将(5)替换回(1)
自𝑓(𝜆以来；𝑎+𝑐,𝑏+𝑛−𝑐)是在[0，1]上的分布，分母是 1，我们得到了我们想要的结果。
现在我们已经充分相信了数学，我们可以计算我们的后验分布。
control = beta(prior_alpha + results.loc['control', 'converted'], prior_beta + results.loc['control', 'sampleSize'] - results.loc['control', 'converted'])treatment = beta(prior_alpha + results.loc['treatment', 'converted'], prior_beta + results.loc['treatment', 'sampleSize'] - results.loc['treatment', 'converted'])fig, ax = plt.subplots()x = np.linspace(0.26,0.42,1000)ax.plot(x, control.pdf(x), label='control')
ax.plot(x, treatment.pdf(x), label='treatment')
ax.set_xlabel('Conversion Probability')
ax.set_ylabel('Density')
ax.set_title('Experiment Posteriors')
ax.legend()
实验后验(图片由作者提供)
现在我们已经得到了后验分布，我们可以继续计算联合后验分布。由于随机实验是基于将用户随机分配到一个变量的想法，我们可以假设这两个分布是独立的。请注意，情况并非总是如此。例如，在某些情况下，网络效应可能会发挥作用，我们需要考虑到这一点。这种假设也依赖于随机分配过程的正常工作。
让我们假设我们的随机分配方法工作正常，没有网络效应。在这种假设下，我们可以说:
让我们用这个来计算我们的联合后验分布。
import seaborn as snsjoint_dist_for_plot = []
for i in np.linspace(0.26,0.42,161):
for j in np.linspace(0.26,0.42,161):
joint_dist_for_plot.append([i, j, control.pdf(i)*treatment.pdf(j)])joint_dist_for_plot = pd.DataFrame(joint_dist_for_plot)joint_dist_for_plot.rename({0: 'control_cr', 1: 'treatment_cr', 2: 'joint_density'}, axis=1, inplace=True)tick_locations = range(0, 160, 10)
tick_labels = [round(0.26 + i*0.01, 2) for i in range(16)]heatmap_df = pd.pivot_table(joint_dist_for_plot, values='joint_density', index='treatment_cr', columns='control_cr')ax = sns.heatmap(heatmap_df)
ax.set_xticks(tick_locations)
ax.set_xticklabels(tick_labels)
ax.set_yticks(tick_locations)
ax.set_yticklabels(tick_labels)
ax.invert_yaxis()
关节后部(图片由作者提供)
图表中的蓝线代表𝜆_𝑐=𝜆_𝑡.由于后关节在这条线以上，我们可以用它作为治疗效果更好的直观指示。如果后关节在这条线以下，那么我们可以很确定控制会更好。如果关节后部的任何部分在线上，那么哪种变型更好就有更多的不确定性。
为了量化这一点，我们需要计算𝑝(𝜆_𝑡≥𝜆_𝑐)和𝐸𝐿，错误选择治疗的预期损失。
import decimal
decimal.getcontext().prec = 4control_simulation = np.random.beta(prior_alpha + results.loc['control', 'converted'], prior_beta + results.loc['control', 'sampleSize'] - results.loc['control', 'converted'], size=10000)treatment_simulation = np.random.beta(prior_alpha + results.loc['treatment', 'converted'], prior_beta + results.loc['treatment', 'sampleSize'] - results.loc['treatment', 'converted'], size=10000)treatment_won = [i <= j for i,j in zip(control_simulation, treatment_simulation)]chance_of_beating_control = np.mean(treatment_won)print(f'Chance of treatment beating control is {decimal.getcontext().create_decimal(chance_of_beating_control)}')
从模拟中我们看到𝑝(𝜆_𝑡≥𝜆_𝑐)=0.9718 so 治疗有 97%的机会比对照组好。
既然我们已经计算了治疗效果更好的可能性，我们需要计算𝐸𝐿.每个变量的损失函数由下式给出
因此，每个变量的预期损失由下式给出
我们用这个来计算预期损失[2]
decimal.getcontext().prec = 4loss_control = [max(j - i, 0) for i,j in zip(control_simulation, treatment_simulation)]loss_treatment = [max(i - j, 0) for i,j in zip(control_simulation, treatment_simulation)]all_loss_control = [int(i)*j for i,j in zip(treatment_won, loss_control)]all_loss_treatment = [(1 - int(i))*j for i,j in zip(treatment_won, loss_treatment)]expected_loss_control = np.mean(all_loss_control)
expected_loss_treatment = np.mean(all_loss_treatment)print(f'Expected loss of choosing control: {decimal.getcontext().create_decimal(expected_loss_control)}. Expected loss of choosing treatment: {decimal.getcontext().create_decimal(expected_loss_treatment)}')
通过运行模拟，我们看到:
𝐸𝐿 = 0.0001369 < 0.0015 = 𝜖
因为其中一个变异的预期损失低于我们在测试开始时设定的阈值，所以测试达到了显著性。我们可以很有把握地得出结论，治疗效果更好，错误选择治疗的预期成本不会超过我们能接受的水平。因此，我们强烈建议将追加销售屏幕的处理方式推广到我们的其他用户群。
我希望这个案例研究有助于您理解实现贝叶斯 AB 测试方法所需的计算。观看这个空间的系列的下一部分！
参考
[1] VWO 白皮书作者:C. Stucchio
[2] 贝叶斯 A/B 测试——一个模拟的实践探索作者 Blake Arnold——我使用了 Blake 代码中的逻辑来计算预期损失
我还发现迈克尔·弗拉斯科的《贝叶斯 A/B 测试的力量》非常有助于理解贝叶斯 A/B 测试方法的技术层面
我这篇文章的代码可以在这里找到
感谢阅读这篇文章！我希望它能帮助您更好地理解如何实现转换度量的贝叶斯 AB 测试方法。
如果你喜欢阅读我的文章，愿意支持我的写作，并且正在考虑订阅一个媒体，请随时使用我下面的推荐链接。我会从你的订阅费中提成。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
