PyTorch 几何图形中的大型图形采样
大型图上的图形深度学习技术
有时，我们会遇到大型图形，迫使我们超出 GPU 或 CPU 的可用内存。在这些情况下，我们可以利用图形采样技术。 PyTorch Geometric 是一个图形深度学习库，允许我们轻松实现许多图形神经网络架构。该库包含许多标准的图形深度学习数据集，如 Cora、Citeseer 和 Pubmed。但是最近图形开放数据集中出现了使用大规模网络的趋势，如开放图形基准 (OGB) [3]。在 OGB，各种数据集从 ogbn-arxiv (169，343 个节点)这样的“小型”网络一直到 ogbn-papers100M (111，059，956 个节点)这样的“大型”数据集。也许 ogbn-arxiv 可以适合内存，如果你只是用一个小的 GCN 或其他东西做一个节点分类，但是尝试任何超出这个范围的东西，或者在 OGB 使用一个中到大的数据集，你可能不得不求助于对图形进行采样。
有多种方法可以对大型图表进行采样，我将尝试介绍两种主要的方法。
- 邻居采样器
来自 3 层邻域采样器的二部图草图
2.GraphSAINTSampler
来自 GraphSAINTSampler 小批量的子图采样器的草图
neighborhood sampler类来自 GraphSAGE paper， 大型图形上的归纳表示学习【2】。如果你之前没有使用过 SAGEConv，你可以把它想象成学习一个基于节点的邻域输出节点嵌入的函数，而不是直接学习所有的节点嵌入。这使得它对归纳任务特别有用，因为你可以通过它从未见过的 GNN 节点。
我画了一个 3 层的 GNN 邻居样本的抽象视图，每个层都被分成一个二分图邻居样本。
邻域采样的三层 GNN 示意图
我试图用蓝色画出源节点，用红色画出目标节点。如您所见，目标节点也有自循环，因此它们出现在二分图的左侧和右侧。下面是代码的样子:
*train_loader = NeighborSampler(data.edge_index, node_idx=train_idx,
sizes=[15, 10, 5], batch_size=1024,
shuffle=**True**, num_workers=12)*
sizes指定每个源节点要采样的邻居数量。想象一下，从我们想要计算嵌入的节点集开始(这些是上图第 3 层中最后的红色节点)。然后，我们计算超参数指定的所有样本，最终返回给我们——相反。这意味着当我们遍历所有层时，我们最终只得到我们感兴趣的节点嵌入。
注意:每个小批量中的节点 id 是大图中的原始节点 id。该采样器本身不对子图进行采样，而是对邻域进行采样，以学习聚合函数。
从 ogbn-products 数据集上 PyTorch Geometric 中的 GraphSAGE 示例中，我们可以看到train_loader由batch_size、n_id和adjs组成。
***for** batch_size, n_id, adjs **in** train_loader:
...
out = model(x[n_id], adjs)
...*
n_id是采样过程中使用的每个节点的所有节点 id，包括采样的邻居节点和源节点。通过传递我们的模型x[n_id],我们只隔离了在这一批计算中使用的那些节点的节点特征向量。adjs中有 3 个adj，由一个edge_index、e_id和size组成。因此，在 PyTorch 几何模型的 SAGE 模型中，我们有:
***def** forward(self, x, adjs):
**for** i, (edge_index, _, size) **in** enumerate(adjs):
x_target = x[:size[1]]
x = self.convs[i]((x, x_target), edge_index)
**if** i != self.num_layers - 1:
x = F.relu(x)
x = F.dropout(x, p=0.5, training=self.training)
**return** x.log_softmax(dim=-1)*
现在你可以看到adjs中的三个二分图分别被传递到三个卷积层。
这种方法的一个可能的缺点是，我们实际上并没有从训练数据中为每一批抽取子图。采样器试图模仿在训练数据集网络上的 GNN 卷积，而不是在每次迭代中获取实际样本。这可能是有益的，这样就不会使你的训练循环产生偏差，但是如果你正在做一些简单的分类或者链接预测之外的事情，我会遇到一些关于索引的问题。然而，从另一个角度来看，与子图采样相比，这种方法可能是有益的，因为我们减少了训练数据的偏差。
GraphSAINTSampler 允许您处理原始训练数据集的实际子图，并重写从 0 到 n 的节点 id，其中 n 是子图中的节点数。
GraphSAINTSampler 父类有三个子类:GraphSAINTNodeSampler、GraphSAINTEdgeSampler 和 GraphSAINTRandomWalkSampler。这些类中的每一个都使用它们各自的采样方案来计算节点的重要性，这转化为采样的概率分布[5]。这个初始采样器就像一个预处理步骤，估计被采样的 V 中的节点 v 和 E 中的边 e 的概率。该概率稍后被用作子图的归一化因子[4]。
下面是 PyTorch Geometric 中的 graph_saint 示例中的 GraphSAINTRandomWalkSampler 示例。
*loader = GraphSAINTRandomWalkSampler(data, batch_size=6000,
walk_length=2, num_steps=5,
sample_coverage=100,
save_dir=dataset.processed_dir,
num_workers=4)*
请记住，根据您设置超参数的方式，加载器可能不会加载整个数据集。batch_size超参数是每批抽样的行走次数。例如，使用 Citeseer 数据集和batch_size = 1、walk_length = 1和num_steps = 1，我们得到 1 个包含 2 个节点的数据样本。使用batch_size = 10,我们得到 1 个有 20 个节点的数据样本。使用batch_size = 100,我们得到大约 200 个节点——在每次迭代中可能会改变，例如 189、191 等。num_steps超参数是每个时期的迭代次数。因此，如果我们将num_steps增加到2，那么节点的数量将增加到大约 380，其中有一个batch_size = 100和一个walk_length = 1。walk_length超参数指的是采样器每次随机行走的长度，返回节点数量的结果将根据网络的分类性而有很大的不同。这实际上编译了 PyTorch Geometric 的torch_sparse库中稀疏张量表示上的随机行走的 C++实现(以及随后的 cuda 实现)。请参阅关于使用自定义 C++操作符扩展 TorchScript 的 PyTorch 教程了解更多信息。
Citeseer 数据集上各种超参数的 GraphSAINT 数据加载器中的节点数
GraphSAINT 论文最重要的方面之一是计算归一化统计量，以减少每个子图样本中的偏差。GraphSAINTSampler 计算这些统计数据，这部分由sample_coverage超参数控制。得到的统计数据作为data对象的一个edge_norm属性返回。我们可以在用edge_norm属性正向传递我们的图形神经网络之前修改edge_weight属性。
*edge_weight = data.edge_norm * data.edge_weight
out = model(data.x, data.edge_index, edge_weight)*
[1]费伊先生。 PyTorch 几何。图形深度学习库。
[2] W. Hamilton 等人，大型图上的归纳表征学习 (2017)。
[3] W .胡等著开图基准 (2020)。
[4] H. Zeng 等， GraphSAINT:基于图抽样的归纳学习方法 (2020)
5 布朗斯坦先生。简单可扩展图形神经网络 (2020)。
数据科学的抽样方法
梅根·麦克莱恩在 Unsplash 上的照片
从人群中获取样本的最好方法是什么？
语境
在大多数研究中，分析整个人口是相当困难的(或者有时是不可能的)，所以研究人员使用样本来代替。在统计学中，调查抽样是为了进行调查而从我们的总体中获取样本的过程。作为数据科学家，我们通常使用以前收集的数据，所以我们不会花太多时间考虑如何实际做到这一点。然而，正如我们将在本文中看到的，我们的数据可能会有不同的偏差，这取决于它是如何采样的，因此您可以更好地理解每个采样设计的含义。绘制这些样本的方法有很多种，根据上下文的不同，有些方法可能比其他方法更好。
概率 x 非概率
抽样设计有两大类:概率和非概率。在概率抽样中，人口中的每个元素都有一个已知的和非零的和概率存在于样本中。这种方法通常是优选的，因为其属性，例如偏差和采样误差，通常是已知的。在非概率抽样中，人口中的一些元素可能没有被选取，样本在总体上不具有代表性的风险很大。然而，在某些情况下，概率抽样有时是不可能的，或者非随机抽样可能更便宜。
现在让我们来看看每个类别中的一些不同的抽样设计及其特性。
概率抽样
无替换的简单随机抽样
这可能是最明显的抽样方法:如果你有 1000 个人，而你只能分析 100 个人，那么你将一次随机选择一个人，直到你有 100 个样本。这将使每个个体在样本中具有相同的概率。
SRSWR 是一个无偏抽样设计，这意味着我们期望从样本中计算出的参数是无偏的。这通常是更好的抽样设计，但有一个小小的警告:你可能会得到一个非常糟糕的样本，完全是运气不好，得到的结果根本不能代表你的总体。在这种情况下，对你的样本进行分层可能会有所帮助(我们稍后会谈到这一点)。
然而，在实践中，获得一个真正简单的随机样本并不那么简单。例如，对于选举投票，你是怎么做的？你不可能真的有一份全国所有人的名单来随机选择。例如，您可以列出所有可用的个人电话号码，并从中进行选择。我的观点是，要做到这一点，你可能需要一份全部人口的名单——如果你在街上随机采访人们，这实际上不是完全随机的:根据你选择去的地点，你的样本可能会产生不同的结果。
泊松采样
在泊松抽样设计中，你的总体中的每个元素都将经历一个伯努利试验，以确定它们是否会出现在样本中。如果总体中每个元素的概率都相同，这就是所谓的伯努利抽样的特例。这也取决于你是否有一份人口中所有元素的清单。假设您有一份您所在国家的所有公司的列表，并且您想要对它们进行调查。举例来说，你可以根据它们的规模，为它们中的每一个分配一个概率 p ，或者甚至为每一个分配一个不同的概率(你可能想给更大的公司更大的权重)。注意，在这种情况下，你无法事先知道样本的确切大小——这就是我们所说的随机大小抽样设计。
分层抽样
在某些情况下，根据某些特征对人口进行分层可能会非常有用。假设你想对你公司的 1000 名员工做一个调查，看看他们对自己的工作有多开心，但是你只有时间去采访其中的 100 人，所以你取了一个样本。有了 SRSWR，你可能会有 50 个会计人员，却没有数据科学家。这会让你认为你公司的员工比他们实际上更不快乐，因为数据科学家是他们工作中最快乐的人，而会计师……嗯，他们是会计师。在这种情况下，您可以做的是将您的人口划分为几个部门，然后从每个部门中随机抽取样本，抽取与部门规模成比例的样本。
这种方法在某些情况下非常有用:
- 阶层之间的差异很小(你知道，从以前的研究来看，同一部门的人在工作幸福感方面感觉差不多)
- 阶层之间的差异很大(你在工作中的快乐程度很大程度上取决于你所在的部门)
然而，在实践中，实现起来可能是昂贵且复杂的。因为它需要你人群的先前信息，当你在更广泛、更昂贵的研究之间进行更小的研究时，它可能是有用的。:如果您的国家每 10 年进行一次人口普查，并且您需要每 5 年一次的中间信息，您可以使用您的人口普查数据来帮助进行较小的中间研究。
非概率抽样
志愿者抽样
这是一种广泛使用的方法:当你在一个脸书小组上发布一份调查表格，并要求人们为你填写时，你会得到这种结果。这很容易，也很便宜，但它会导致很多偏见，因为你实际上是在脸书取样的人，看到了你的帖子，最重要的是:他们愿意为你填写表格。这可能会对喜欢你的人或有足够时间填写表单的人进行过度采样。
它可以作为第一个验证步骤，看看以后是否有兴趣追求更昂贵的方法。
抽样断定法
在这个抽样设计中，您将根据您现有的领域知识选择您的样本。如果你想为一门新的编程在线课程调查潜在客户，你可能已经知道什么样的人会喜欢这门课程，并开始在 LinkedIn 上寻找他们。
不言而喻，这种方法容易产生你自己的偏差，你不应该根据它的结果得出确定的结论。它可以在与志愿者取样相同的情况下使用。
结论
现在你知道了一些最常见的抽样设计，何时使用它们以及它们的注意事项。调查抽样本身是一个完整的专业领域，对于那些为政府机构工作的统计人员来说特别有用，但数据科学家了解基础知识以了解他们的收集方法的含义或自己进行调查是有好处的。
一旦你采样了你的数据，然后呢？嗯，你需要应用一些特征工程来理解它。此外，您可能会喜欢这篇关于数据科学家项目管理工作流程的文章。
随时联系我关于LinkedIn如果你想进一步讨论，这将是一种荣幸(老实说)。
旧金山阿片类药物危机和毒品问题及其对公共安全的影响
使用机器学习和分类技术的旧金山毒品和犯罪分析
禁毒战争是一个阶段，指的是政府主导的行动，旨在通过加大和加强对违法者的惩罚来阻止非法毒品的使用、分销和交易。这场运动始于 20 世纪 70 年代，至今仍在发展。因此，近年来美国许多州正在经历阿片类药物危机。有一个正在进行的辩论，阿片类药物危机是墨西哥和中美洲移民的产物，而不是大型制药公司的放松管制和私人医疗保健系统的失败。因此，在这种情况下，旧金山正面临着严重的毒品问题和阿片类药物危机。我与卡提克亚舒克拉和郝舒一起选择了这个数据集来执行 EDA，并应用数据科学分类算法，如 XGBoost、KNN、回归、朴素贝叶斯和随机森林，以从可视化结果中获得洞察力。旧金山(SF)在推动进步的公共卫生解决方案方面有着悠久的历史，包括医用大麻和针头交换，在这两者都合法或被广泛接受之前。这是如此不成比例，以至于加州通过了一项法案，允许旧金山开设安全注射点(SIS)。
旧金山阿片类药物危机
旧金山(SF)在推动进步的公共卫生解决方案方面有着悠久的历史，包括医用大麻和针头交换，在这两者合法或被广泛接受之前。这是如此不成比例，以至于加州通过了一项法案，允许旧金山开设安全注射点(SIS)。
安全注射点(SIS):
安全注射场所是受医疗监督的设施，旨在提供一个卫生和无压力的环境，在这个环境中，个人能够静脉注射非法娱乐性药物，并减少公共药物使用造成的滋扰。它们是针对毒品问题的减少危害方法的一部分。北美的第一家 SIS 网站于 2003 年在温哥华市中心东区(DTES)附近开业。
潜在问题:
比较不同社区的犯罪类型。你可能会被袭击的前五个街区是哪里？某些“成对”犯罪是否经常在某个街区同时发生？
为旧金山政府确定安装 SIS 的潜在社区
目标变量:
- 2003 年至 2018 年犯罪类型与邻里之间的相关性
- 某些类型的犯罪是经常一起发生，还是特别一起发生
- 2013 年至 2018 年使用的药物类型与社区之间的相关性
- 确定旧金山政府建设安全注射点的潜在社区/区域
- 根据提供的空间和时间特征预测犯罪的类型/类别
数据:
我们的数据来自旧金山警察局的数据库。这是从 2003 年 1 月到 2018 年 5 月的犯罪历史数据。数据集有 13 列和 2215024 行。
数据集元数据
分析和推论:
- 我们统计了每一类犯罪的发生次数，并绘制了图表。由于分布是偏斜的，我们通过取对数来标准化它。以下是标准化的犯罪类别分布。
2.有 915 个不同的犯罪描述，这些描述决定了犯罪是否与毒品有关。因此，我们计算了每种犯罪描述的发生率，并过滤掉低于 97%的犯罪描述，剩下的用于创建聚类图。
3.创建了一个聚类图，以探索不同类型的犯罪分布(即每个 PD 区(即警区)的犯罪分布)。同样，由于这种分布是偏斜的，它影响了我们的模型(如下所示)。人们可以观察到侠盗猎车手是一个离群值，除此之外，我们没有获得任何信息，因此需要规范化。
4.因此，使用最小-最大归一化进行归一化，因为记录日志不会保留一个特征相对于另一个特征的大小比例。下面是标准化的聚类图:
在这里，我们可以观察到以下情况:
(一)*南部:*极高的盗窃发生率，包括从汽车中盗窃
(二)*湾景:*重大的暴力和威胁事件
(iii) Tenderloin: 似乎是一个异常值，拥有毒品用具的发生率极高。Tenderloin 似乎是安装 SIS 的潜在候选人，尽管它可能是假阳性(即这些可能是由于大麻)。因此，人们需要更深入地研究。
5.接下来，我们使用一些正则表达式和字符串模式匹配过滤了与毒品相关的犯罪，并统计了每个与毒品相关的描述的出现次数。同样，分布是倾斜的，它影响了下面显示的聚类图。人们可以观察到 Tenderloin 是一个异常值，我们没有获得其他信息。
6.下面是标准化的聚类图，显示了各县与毒品相关的犯罪的分布情况。
推论:
从上面的聚类图，我们可以清楚地得出结论，田德隆，南部，使命和北部是安装 SIS 的最佳候选人
7.此后，进行时间序列分析，以分析阿片类药物随时间的变化趋势。首先，我们压缩了大量与毒品相关的犯罪描述，以创建阿片类药物组/特征(即巴比妥酸盐特征、可卡因特征、大麻特征、冰毒特征等)。然后，我们为每个组创建了一个 30 天的窗口，并统计了从 2003 年 1 月 1 日到 2018 年 5 月 15 日每个月的 30 天窗口内每个组的事件数量。
为了去除月份的周期性特征，我们将它们从 0 到 187 进行索引。下面是一个堆积直方图，代表这些趋势。如你所见，与冰毒和海洛因相关的事件显著上升。
8.为了使趋势更加清晰，以下是 2003 年至 2018 年期间类阿片趋势的标准化分布。
人们可以观察到，与裂纹相关的事件在此期间有所减少。同样，大麻相关事件在 2016 年合法化后有所下降。但是与冰毒和海洛因相关的犯罪显著上升——这是断定这是一种流行病的实质性证据。
型号选择:
- 我们从一个二元逻辑回归模型开始，该模型预测了犯罪是否与毒品有关的可能性，给出了某些地理坐标。这将有助于旧金山政府根据预测向某些地区分配资源。我们最初的准确率是 94%，高得“令人怀疑”。因此，我们检查了偏见——我们发现我们的目标阶层是不平衡的——也就是说，与毒品相关的犯罪相比，与毒品无关的犯罪要多得多。因此，我们使用 SMOTE 对目标类进行了过采样。在此之后，我们的准确率为 77%，这是有意义的，尽管 AUC 从 0.68786 上升到 0.69875。
目标类别分布(过采样前)
目标类别分布(过采样后)
这种不平衡的分布可以通过欠采样或过采样来解决。选择过采样的原因是，尽管欠采样可能有效，但在此过程中会丢失许多有用的数据。这些数据对逻辑回归算法是有意义的。
过采样技术是 SMOTE ，代表合成少数过采样技术。原因有二。首先， SMOTE 是一种非常常见的过采样技术。其次，当对不平衡数据集中的少数类进行过采样时，可能发生的情况是，模型最终会学习到少数几个示例的太多细节，通常是通过随机添加少数类数据这样的简单方法。另一方面，SMOTE 学习少数数据点的邻域的属性。这样，模型可以更好地泛化。
过采样前的 AUC
过采样后的 AUC
推论
我们意识到二元逻辑回归(即二元 LR)不足以解决我们的问题。例如，如果我们使用这些预测来分配政府资源，那么我们可能会有很高的假阳性率。由于仅仅找到非毒品/毒品相关犯罪高发的地理坐标/区域是不够的，我们需要更深入地研究，例如，我们希望在谋杀率高于纵火率的地方分配更多的资源。于是我们转而使用其他多类模型，如多项逻辑回归(多项 LR) 、 XGBoost 、 KNN 和随机森林。
项目:
结论:
XGBoost 表现最好。上述模型预测了每一类犯罪的可能性，给出了地理坐标，以及犯罪是在白天还是在晚上发生。我们可以使用这些可能性/概率&在给定的地理坐标上聚合，来识别社区并相应地分配政府资源。
权衡:
- 特征缩放:我们每次归一化数据时都使用最小-最大归一化，虽然它不能很好地处理异常值，但另一方面它保留了原始的缩放比例。在对数/z 分数归一化的情况下，异常值得到很好的处理，但不会保留原始比例。对我们的分析来说，保留比额表更重要。因此，总会有权衡。
- AUC/ROC 与 Precision/Recall (PR): 我们使用 PR 作为我们的评估指标。由于我们的目标阶层不平衡，我们希望我们的模型考虑到这一点。
在现实世界中，由于正负样本非常不均匀，所以更多地使用 PR 曲线。ROC/AUC 曲线不能反映分类器的性能，但是 PR 曲线可以具有更好的可解释性。
AUC(ROC 下面积)是有问题的，尤其是当数据不平衡时。正面例子的出现率相对较低。用 AUC 来衡量分类器的性能，问题是 AUC 的增加并不能真正反映一个更好的分类器。这只是太多反面例子的副作用。由于我们更关心真阳性的实际预测，而不是模型的“整体”性能，因此 PR & F-1 评分似乎更合适。
代码:
您可以在我们的 github 资源库查看整个项目的代码和 jupyter 笔记本:
旧金山(SF)在推动进步的公共卫生解决方案方面有着悠久的历史，包括医疗…
github.com](https://github.com/gandalf1819/SF-Opioid-Crisis)
除此之外，您还可以在这里进一步查看 Tableau 分析:
[## Tableau 公共
编辑描述
public.tableau.com](https://public.tableau.com/profile/chinmaynw#!/vizhome/SFDrugOpioidCrisis/Sheet1)
参考资料:
[1]https://www . kqed . org/news/11766169/旧金山-芬太尼-死亡-几乎-150
[2]https://www . SF chronicle . com/Bay area/article/Bay-Briefing-芬太尼-流行病-恶化-in-San-14032040.php
https://data.sfgov.org/d/wkhw-cjsf
[7]https://www . quora . com/What-the-meaning-of-min-max-normalization
基于 Python 的 Plotly 的桑基图基础
可视化流量和比较比例的绝佳选择
在本文中，我将介绍使用 Plotly 和 Python 绘制桑基图的基础知识。
它们是一个方便的图表，用于可视化任何一种可测量的流量——一些例子是旅行者、拼写者和金钱的流量。
这张图表的制作归功于爱尔兰船长马修. H. P. R .桑基，他用它来形象化蒸汽机的能源效率。
桑基图的思想类似于网络图，其中链接连接节点。
主要区别在于，在桑基的模型中，链接具有不同的宽度，它们共同编码一个可测量的变量。
亲自动手
对于下面的例子，我将结合 Jupyter Lab 使用 Plotly 来探索如何创建一个 Sankey。
import plotly.graph_objects as go
用 Plotly 构建图表有不同的方法；我将使用图形对象，用 Jupiter 小部件可视化图形，并为最终的可视化导出一个 HTML。
逻辑
构建一个 Sankey 可能相当困难，特别是如果您有太多的节点和连接，我将使用列表作为例子来简化它，但是您可以用 JSON 文件或 Pandas 数据帧来修改这个逻辑。
我们将使用go.Sankey来构建图表，这需要一个link。
那个link是一本包含我们想要绘制的连接数据的字典。
source = [0, 0, 1, 1, 0]
target = [2, 3, 4, 5, 4]
value = [8, 2, 2, 8, 4]
源和目标是 Plotly 将连接的节点的索引列表，值是将定义这些连接的宽度的数字列表。
link = dict(source = source, target = target, value = value)
data = go.Sankey(link = link)
print(data)
我们将 Sankey 对象保存到一个名为 data 的变量中，现在我们可以将该数据传递给一个图形；
fig = go.Figure(data)
并显示图表。
fig.show()
就是这个想法。让我们试着识别这些节点，这样我们就能更清楚地看到什么在连接什么。
我们需要一个包含节点数据的字典，它应该包含一个带有标签的列表。我们还可以添加更多的参数，比如pad来定制节点之间的距离，或者thickness来定义它们的句柄的大小。
# data
**label = ["ZERO", "ONE", "TWO", "THREE", "FOUR", "FIVE"]**
source = [0, 0, 1, 1, 0]
target = [2, 3, 4, 5, 4]
value = [8, 2, 2, 8, 4]# data to dict, dict to sankey
link = dict(source = source, target = target, value = value)
**node = dict(label = label, pad=50, thickness=5)**
data = go.Sankey(link = link, **node=node**)# plot
fig = go.Figure(data)
fig.show()
那更好理解。我们可以阅读列表，并想象它们之间的联系。
用例
现在让我们用一些真实的数据来尝试一下，我将尝试改变温哥华 2020 年预算中的这种可视化。
我希望看到资金从运营支出流向地区和服务的比例。
我将从总支出的一个节点开始，它将连接到四个领域，然后将链接到它们的细分领域——让我们快速勾画一下这个想法。
用 sketch.io 绘制
我已经使用了百分比来查找值，并为链接构建了以下列表。
source = [0, 0, 0, 0, # Op Expeditures
1, 1, # Public Safety
2, 2, # Eng n Util
3, 3, 3, 3, 3, 3, # Community Serv
4, 4, 4] # Corp Supporttarget = [1, 2, 3, 4,
5, 6,
7, 8,
9, 10, 11, 12, 13, 14,
15, 16, 17]value = [484500, 468350, 355300, 306850,
339150, 145350,
371450, 96900,
129200, 80750, 48450, 48450, 32300, 16150,
113050, 129200, 64600]
让我们也为节点定义标签。
label = ['Operating Expeditures',
'Public Safety',
'Engineering and Utilities',
'Community-Related Services',
'Corporate Support',
'Police',
'Fire',
'Utilities',
'Engineering Public Works',
'Parks and Recreation',
'Arts, Culture, and Community Services',
'Library',
'Development, Buildings, and Licensing',
'Planning, Urban Design, and Sustainability',
'Other',
'Corporate Support',
'Debt and Capital (Non-Utility)',
'Contingencies and Transfers']
一旦我们准备好数据，剩下要做的就是定义我们的图形和绘图。
很好，越来越好了。
我们可以在图表中使用另一种编码，即颜色。
我们可以定义节点和链接的颜色；为此，我们需要一个每个元素有一种颜色的列表。
color_node = [
'#808B96',
'#EC7063', '#F7DC6F', '#48C9B0', '#AF7AC5',
'#EC7063', '#EC7063',
'#F7DC6F', '#F7DC6F',
'#48C9B0', '#48C9B0', '#48C9B0', '#48C9B0', '#48C9B0', '#48C9B0',
'#AF7AC5', '#AF7AC5', '#AF7AC5']color_link = [
'#EBBAB5', '#FEF3C7', '#A6E3D7', '#CBB4D5',
'#EBBAB5', '#EBBAB5',
'#FEF3C7', '#FEF3C7',
'#A6E3D7', '#A6E3D7', '#A6E3D7', '#A6E3D7', '#A6E3D7', '#A6E3D7',
'#CBB4D5', '#CBB4D5', '#CBB4D5']
在这里，我试图突出每个支出的区域，我对节点和链接使用相似的颜色，一个比另一个亮一点。
几乎准备好了，剩下要做的就是添加标题、调整细节和导出 HTML 文件。
我们可以在绘图之前更新图形的布局，这允许我们更改字体、背景颜色、定义工具提示上的信息等等。
fig.update_layout(
hovermode = 'x',
title="Vancouver Operating Expeditures by Area of Service",
font=dict(size = 10, color = 'white'),
paper_bgcolor='#5B5958'
)
一旦可视化准备就绪，我们就可以将其导出为 HTML。这可能是最自然的部分，我们所要做的就是调用.write_html(‘filename.html’)。
这里你可以看到另一个例子，我增加了营业收入。
https://thiagobc23.github.io/plotly-sankey/van.html
我试图移除白色的文字阴影，但是我在 Plotly 中找不到解决方案，我找到的最好的答案是覆盖 CSS 。
你可以在这里找到这篇文章的代码，在这里找到带有交互式 Sankey 的网页。
感谢你花时间阅读我的文章，我希望你喜欢它。
更多资源: Plotly —图形对象
Plotly —桑基图
桑坦德银行客户满意度——使用 Python 的自我案例研究
作为 self 案例研究的一部分，使用 Python ( github link 和Linkedin**)**对 Kaggle 中的桑坦德客户满意度数据集进行分类建模
目录
- 商业问题
- 使用机器学习来解决业务问题
- 评估指标(曲线下面积)
- 探索性数据分析
- 特征工程
- 现有解决方案
- 我的模型实验
- 摘要、结果和结论
- 未来的工作
- 链接到我的个人资料— Github 代码和 Linkedin
- 参考
加勒特·帕克在 Unsplash 上拍摄的照片
1.商业问题
本案例研究基于 2016 年开展的 Kaggle 竞赛。客户满意度是当今每个公司最重要的关键绩效指标之一，被视为公司成功的关键因素。不开心的顾客不会留下来。更重要的是，不开心的顾客很少在离开前表达他们的不满。桑坦德银行是一家西班牙跨国银行和金融公司，业务遍及欧洲、北美、南美和亚洲。在桑坦德银行举办的这场 Kaggle 竞赛中，我们需要根据公司提供的功能，提前预测客户是否对他们的服务不满意。这将有助于他们在客户离开之前采取主动措施提高客户满意度。
2.使用机器学习来解决业务问题
这个问题是一个分类建模任务，以确定客户(数据点)是否不满意。
我们有两个文件:test.csv 和 train.csv，其中包含大约 370 个匿名的特征和一个作为目标的依赖特征。每个数据点代表一个客户，如果客户对公司的服务不满意，TARGET 中的值为 1，如果客户满意，TARGET 中的值为 0，并且数据集严重失衡。
3.评估指标(曲线下面积)
这里使用的度量是 ROC (接收器工作特性)曲线下的面积，ROC(接收器工作特性)曲线是在不同阈值下真阳性率(灵敏度或召回率)(TPR)和假阳性率(FPR)之间的图下的面积。AUC 有助于确定模型是否擅长区分类别。AUC 越高，模型预测 0 为 0 和 1 为 1 的能力越强。AUC 为 0.5 意味着模型进行随机猜测(随机模型)，而 AUC 为 0 意味着模型预测 0 为 1，1 为 0，而 AUC 为 1 是理想的分类器。
来源 — AUC 是 ROC 曲线下的面积
这里有一篇关于 AUC 的非常好的文章。
在机器学习中，性能测量是一项基本任务。所以说到分类问题，我们可以…
towardsdatascience.com](/understanding-auc-roc-curve-68b2303cc9c5)
4.探索性数据分析
我们将首先深入研究数据集，并通过可视化观察所有特征，这将有助于我们获得结论以及特征工程的想法。总共有 370 个特征都是匿名的(不包括“目标”特征)。我们能够从文献综述中以及通过观察值的分布来获得匿名化特征所传达的信息。
由于有许多特性，我们将检查具有零方差的特性(不包含任何信息，即仅存在 1 个唯一值)，如果发现，将删除它们。
发现 34 个特征具有零方差，并且这些都被移除。
我们现在将检查重复的特征(即它们在数据点上共享相同的值，不需要相同的特征名称)。
发现 12 个特征是重复的，其中 6 个被移除。
我们现在将移除所有的稀疏特征(具有很少信息的特征)。设置一个条件，使得如果特征具有为 0 的 99%的值，则它被认为是稀疏特征。
也没有发现缺失值。
去除不必要的特征后的最终特征数是 142。
现在，我们将探索每一项功能。
4.1 目标
我们可以看到数据集非常不平衡，只有 3.96%的客户不满意，96.04%的客户满意。
4.2 var3(地区)
通过查看其他文献以及当前唯一值的数量(=208)，此功能可能包含客户所在地区的信息。此功能中还有一个异常值-999999，它可能缺少值。除了异常值，这些值的范围从 0 到 208。发现最常见的唯一值是 2(对于训练和测试数据，大约 97%)。首先，我们将把所有-999999 转换为-1 值，并且只考虑不包括“2”的值来研究值计数。
“var3”的值计数，不包括最常见的值“2”
由于查看值计数，我们可以看到-1 仅代表整个数据集的一小部分(即使在排除 2 之后)。因此，我们将用此功能最常用的值“2”替换缺失的值。
4.3 var15(年龄)
在训练数据中发现 var15 的最小值为 5，最大值为 105。因为 var15 的值是从 5 到 105，所以可以有把握地认为该特征暗示了客户的年龄。文献综述也证明了这一点。
训练和测试数据具有相似的分布，两者都由最年轻的客户组成。
不满意的顾客的最小年龄是 23 岁。似乎每个年轻顾客(23 岁以下)总是很满意。因此，我们可以在特征工程期间创建一个新的特征，它本质上是告诉客户是否在 23 岁以下。
4.4 var38(抵押价值)
从 kaggle 的各种文献可以推断，var38 可能是抵押价值。
var38 的值计数
这里我们不能得到任何信息，因为一个值有很高的频率。我们将打印出每个百分点值。
以百分位数表示的 var38 值
我们可以看到，0 百分位值和 10 百分位值之间有着巨大的差异。这与 90 百分位值和 100 百分位值的情况相同。现在，我们将检查低于 97.5 百分位的所有值的 var38 分布图(高于 97.5 百分位的值 1 占主导地位，无法提取可用信息)
我们可以看到上面的图是右偏的，峰值在 100，000 到 150，000 之间。我们可以应用对数变换并检查结果分布。
应用对数变换后
我们可以看到它看起来类似于正态分布。由于机器学习模型在正态分布上工作得更好，因此我们可以为该特征创建具有对数变换和不具有对数变换的新数据集，并在特征工程阶段比较性能。
4.4 带有关键字的功能
有几个特征有特定的关键字，它们是:“imp”、“ind”、“num”、“saldo”。这些关键字被发现是从一些文献中获得的一些西班牙语单词的缩写形式。
“num”要素在数据集中具有最高的制图表达。
现在我们要做的是通过为每个关键字随机选择 2 个特征来逐个探索每个关键字的特征，然后我们将得出结论。
4 . 4 . 1‘imp’特性
imp’ likey 是 importe 的缩写词，在西班牙语中表示数量(从文献综述中推断)。带有“imp”关键字的特征的总数是 14。通过查看包含“imp”关键字的两个随机选择的特性的值计数，我们可以看到这两个特性最常出现的值都是 0。0 在这两个特征中占了 87%以上。
随机选择的“imp”特征训练和测试数据的频率图
对数变换后不包括 0 的随机选择的“imp”特征的分布
同样在对数变换之后，分布(不包括 0)变得很像高斯分布。因此，我们可以为所有“imp”功能制定一个策略。
imp 特性的策略:
- 我们可以创建一个具有对数变换(不包括 0) imp 特征的新数据集。
- 我们还可以创建另一个没有应用转换的数据集(保持原样)。
4 . 4 . 1“saldo”功能
具有 saldo 关键字的特征的数量是 26。现在，我们将像处理“imp”特征一样处理数据。通过查看这两个特征的值计数，我们可以看到 0 也是最常见的值(大约占整个训练数据集的 95%)。
训练和测试数据的频率图
发现所有“saldo”特征都是连续的。
对数变换后的随机“萨尔多”特征(不包括零)
同样在这里(类似于“imp”功能)，我们可以创建新的数据集，将对数变换应用于 saldo 功能，除了 0 值将保持不变。
“萨尔多”特色战略:
- 我们可以使用经过对数变换(不包括 0)的 saldo 要素创建一个新数据集。
- 我们还可以创建另一个没有应用转换的数据集(保持原样)。
4.4.3“数量”特征
“num”可能是数字的缩写形式。探索所有“num”特征的值计数，我们可以说每个具有“num”关键字的特征本质上都是分类的。
一些带有“num”关键字的特性及其对应的唯一值的数量
为带有“num”关键字的功能找到的唯一值的最大数量是 172(总数据点约为 70k)，最小数量是 2。我们将为“数字”功能采用一种策略:
针对“数字”功能的战略
- 我们将对允许的唯一值的最大数量设置一个阈值，以便将一个特征定义为分类特征。我们将阈值设置为 10。
- 我们可以使用响应编码、一个热编码创建新数据集，并保留“num”个要素的要素不变。(这只适用于根据上述规则定义的分类特征)
4 . 4 . 3“ind”特征
“ind”功能可能指指示器。查看值计数后，所有具有“ind”特征的特征只有 2 个唯一值。
针对“ind”特性的策略
我们保留这些功能不变。
5.特征工程
从文献回顾中可以理解，对于特定数据点，不同特征上零的出现次数是识别客户是否不满意的一个重要特征。因此，我们将为预处理后的数据创建要素，如下所示:
no_zeros: 一个数据点的不同特征中出现的零值数量
no_nonzeros: 一个数据点的不同特征中存在的非零值的数量
现在，我们将添加一个特性，该特性计算不同关键字特性(’ saldo ‘，’ ind ‘，’ num ‘，’ imp’) 中的个零和非零值:
现在，我们将对具有 50(不含)到 210(含)个唯一值的所有特性的每个唯一值取所有“saldo”和“imp”特性的平均值，并将其添加为特性。
**K 均值聚类:**我们将在对这个特定步骤应用标准化之后，添加 k = 2，4，6，8，10 的 K 均值聚类值作为特征。注意:我们在这个步骤之后获得的特征是不标准化的，因为我们需要应用对数变换。我们应用标准化来获得 K-means 聚类特征。
**移除与目标高度相关的特征和低相关的特征:我们将移除彼此高度相关的所有特征，保留一个。我们将移除与“目标”特征具有低相关性的所有特征。对于移除高相关特征，阈值保持为任何高于 0.95 相关值的特征，而对于移除与“目标”的低相关值，阈值是任何低于 10-3 相关值的特征。
创建新数据集:
现在，我们将使用日志转换创建新的数据集。我们将对功能’ var38 ‘，所有’ saldo ‘和’ imp '功能应用对数变换，零值除外，零值将保持不变。
现在我们有两个数据集，一个是对数转换的，另一个是普通数据集(没有任何对数转换)。现在，我们将对这些应用一个热编码和响应编码，并创建新的数据集。这里，编码应用于唯一值的数量在 3 和 10 之间(包括 3 和 10)的那些特征。这里有一篇关于如何计算 响应编码 的文章。对于响应编码，我使用拉普拉斯平滑来平滑数据(假设在测试数据中有一个在训练数据中没有看到的类别值，我们不希望该唯一值的概率为零，所以我们应用平滑)。通过手动检查从一组阿尔法中随机选择的特征的响应编码值，根据结果编码值的变化程度来找到最佳阿尔法。
最后，创建了 6 个数据集，它们是:
- 正常
- 普通带一个热编码
- 正常带响应编码
- 测井转换
- 用响应编码转换的日志
- 用一个热编码转换的日志
现在我们将标准化所有数据集。标准化后，我们将应用主成分分析(这里 n=2)并将其作为特征添加到每个数据集。
最初，我们只有 142 个用于训练和测试数据的特征。现在我们已经创建了 6 个数据集，要素的最终数量如下:
- 正常:359 特性
- 普通带一个热编码:446 个特征
- 正常带响应编码:374 特征
- 测井转换:359 个特征
- 响应编码转换的日志:374 个特征
- 一次热编码转换的日志:446 个特征
6.现有解决方案
- 德里克·范登艾森。(2017).桑坦德客户满意度 : 在预处理中，他去除了方差为零的特征、稀疏特征以及重复的列条。现在，在标准化之后，他移除了具有 0.99 或更高的高相关值的所有第一对相关特征。**特征工程:**从 var3 (Nationality)特征中创建新的特征，其本质上携带了客户是否来自最普通的国家或具有最普通的价值的信息。var15(年龄)、var36 和 var38(抵押价值)也是如此，var15 的值为-999999，这可能意味着缺少值。创建的另一个特性告诉我们数据点的值是否为-999999。创建此功能后，var3 中的所有-999999 值都被替换为最常用的值。对 var36 也是如此，因为它的值为 99，与其他唯一值(包括 0、1、2 和 3)相差甚远。Var36 是一个热编码，因为其值表明它是分类的。另一个功能是计算数据点中 0 的数量(dmi3kno，2015)。此外，还为数据点功能创建了多个 1。作者创建了 3 个模型:逻辑回归、随机森林和 XGBoost ，具有超参数调整的 10 折分层交叉验证。发现度量 AUC 对于 XGBoost 是最好的。
- kweonwooj 用 Python : 重新实现 pjpan 的第 34 位解(用 R 代码)，在这次重新实现中，用户删除了所有有常量(只有 1 个唯一值)的特性，删除了所有重复的特性，保留了一个。将 9999999999 和-99999 等所有极值转换为-1。移除稀疏要素，条件是如果要素的 99%值为 0，则该要素被声明为稀疏。对于这组列“num_meses_var8_ult3”、“num_meses_var13_largo_ult3”、“num_op_var40_comer_ult1”，这组列中的所有 meses 列的值都被更改为 int 类型。而集合中的所有其他特征的值除以 3(这些特征的唯一值为 3 的倍数)。数据在 XGBoost 上用 10 个分层的 k 折叠进行训练。预测的测试值是所有这些模型测试预测值的平均值，这些预测值符合 10 个分层的 k 倍。
对于我的方法，我已经创建了 6 个数据集，这在特征工程部分进行了详细说明，并将在这 6 个不同的数据集上建模。
7.我的建模实验
我有 6 个数据集，所以我要做的是，对每个数据集，我将在逻辑回归、决策树、随机森林、XGBoost 和 LightGBM 上建模。首先，对数据集进行随机分割，对“目标”进行分层(确保训练和测试中唯一“目标”值的比例相同)，分割比例为 85:15。在数据集上建模后，我基于随机森林模型选择了个顶级特征，然后为每个数据集创建了包含前 250 个特征的新数据集。然后基于具有前 250 个特征的数据集创建随机森林、XGBoost 和 LightGBM 模型。使用随机搜索 CV 进行逻辑回归、决策树和随机森林找到最佳超参数。
用于随机搜索 cv 的不同超参数
这里 class_weight = 'balanced '处理了类的不平衡。对于决策树和随机森林，在拟合具有最佳超参数的模型之后，在这些模型之上拟合校准的分类器(以获得概率值)。
这里的模型不是决策树分类器就是随机森林分类器。
对于 XGBoost 和 **LightGBM，**我手动更改了每个参数，并根据以下文章找到了最佳参数。对这两个模型使用 RandomSearchCV 耗费了大量时间。
XGBoost(或极端梯度推进)不再被引入，只是在太多的数据科学中被证明是相关的…
towardsdatascience.com](/fine-tuning-xgboost-in-python-like-a-boss-b4543ed8b1e)
下面是 XGBoost 的代码，类似的还有 LightGBM (除了物镜在 LightGBM 中变成‘二进制’)。
不同数据集的组合 AUC 图如下所示:
日志数据集的 AUC 分数(已排序)
正常数据集的 AUC 分数(已排序)
基于验证 AUC 的每个数据集的最佳模型
然后，我们根据集合和堆叠的验证 AUC，从每个数据集中选择最佳模型。我们不从所有模型中取出最好的模型，因为对于堆叠和集成，模型之间的差异越大(这确保我们从不同的数据集取出模型，否则在相同数据集上训练的模型将出现)，最终集成/堆叠分类器的性能将越好(每个模型将是不同主题的专家，即例如:如果我们建立狗分类器模型，我们可以建立分类器，使得一个模型将检测尾部， 另一个模型将检测人脸等，因此结合这些模型将提供更好的性能，这就是我所说的不同模型的意思)。 所以数据集之间的差异越大，模型之间的差异就越大。
然后，获得的最佳模型在提供的整个训练数据集上进行训练(我们之前分割了数据)，然后用于预测测试“目标”概率值。然后，获得的 6 个“目标”被用作创建新数据帧的特征。在该数据帧的顶部训练分类器(堆叠)。这里使用的分类器是逻辑回归(通过随机搜索 CV 找到的超参数)，并且在 Kaggle 中提交“目标”的测试概率值。还提交了从 6 个最佳模型获得的 6 个测试概率值，并记录了它们的公开 AUC 分数。然后，基于获得的公开 AUC 分数，选择最佳的 2 个模型(这里是“log re(top 250) xgb”和“normal re(top 250)”)，然后对概率值进行简单的平均集合。然后在 Kaggle 上提交获得的值，并记录公开的 AUC 分数。
8.摘要、结果和结论
带有 kaggle 公共 AUC 分数的模型
我们可以从上面的结果数据框中看到，拟合于对数变换响应编码(前 250 个特征)数据集的 XGB 模型和拟合于正常响应编码(前 250 个特征)数据集的 XGB 模型表现非常好。这两个模型的简单平均组合能够获得 0.82746 的 kaggle 公共 AUC 分数，仅比公共排行榜中的最高分数(0.84532)低约 2%。在 Log transformed(所有特征)上训练的 xgb 模型表现很差，因为它具有最差的公开分数。对分类特征进行响应编码极大地改进了模型，因为与在响应编码数据集上训练的模型相比，在其他数据集模型上训练的模型不会产生很好的结果。
日志响应编码(前 250 个功能)xgboost 模型(前 20 个功能)
正常响应编码(前 250 个功能)xgboost 模型(前 20 个功能)
此外，从所使用的两个集合模型的特征重要性图中，我们可以看到，在这两个模型中，具有最高重要性的共同特征是“var15”(代表从文献综述中推断的“年龄”)，这意味着年龄是决定客户是否满意的重要因素。
9.未来的工作
- 我们可以使用贝叶斯优化来找到每个模型的最佳超参数。
- 我们也可以尝试实施深度学习模型来解决问题。
10.链接到我的个人资料— Github 代码和 Linkedin
你可以在这个 github 链接 上找到这个案例研究的完整代码。你可以在 Linkedin 或ashishthomas7@gmail.com联系我。
11.参考
- https://www . Applied ai course . com/course/11/Applied-Machine-learning-course
- 桑坦德银行客户满意度调查(2017 年)
- kweonwooj 用 Python 重新实现 pjpan 的第 34 位解决方案(用 R 代码实现)
- https://medium.com/r/?URL = https % 3A % 2F % 2f towards data science . com % 2f fine-tuning-xgboost-in-python-like-a-boss-b 4543 ed 8 B1 e
- https://towards data science . com/mercari-price-re commendation-for-online-retail-sellers-979 C4 d07 f 45 c？gi=5873f2d314af
- https://medium . com/@ thewingdwolf . winterfell/response-coding-for-categorical-data-7bb 8916 c6dc 1
- https://towards data science . com/understanding-AUC-roc-curve-68b 2303 cc9 C5
如何发现财务数据中的欺诈和异常
内部审计、财务和税务会计及控制等领域的一些数据分析示例
莎伦·麦卡琴在 Unsplash 上的照片
来自《走向数据科学》编辑的提示: 虽然我们允许独立作者根据我们的 规则和指导方针 发表文章，但我们并不认可每个作者的贡献。你不应该在没有寻求专业建议的情况下依赖一个作者的作品。详见我们的 读者术语 。
像 SAP 这样的软件，用于处理公司的所有业务流程，如记账、控制、销售等。托管大量数据，尤其是财务数据，这些数据可能会带来重要的见解，需要由商业智能、会计或内部审计等部门进行控制。下面对常见检查的概述应该提供了一个实用的分析用例列表。
可疑的变化
在 CDHDR 和 CDPOS 表的帮助下，您可以分析表中的变化，还可以识别可疑的过程，如订单中的不同值，该值从 20.000 €变为 19.999 €，刚好低于现有的限制。您需要的是对提到的表的访问(至少是读取)，对这些表如何工作的理解和一些 SQL。
示例:SQL 结果—值的变化:
UDATE |CHANGENR |VALUE_NEW |VALUE_OLD01/01/2020 |1234 |20.000 |
02/03/2020 |1234 |19.999 |20.000
另一个例子是查看客户的信用限额更改的频率——在某个订单之前的许多更改或更新也值得查看。
示例:SQL 结果—计数变化[1]:
OBJECTCLAS |OBJECTID |FNAME |Count_ChangesKLIM |543 |KLIMK |6
检查重复项
为了监控主数据的质量，同时防止不正确的预订甚至欺诈，检查重复数据总是一个好主意—一个著名的例子是 SAP 数据中的客户数据。对于像这样的更深入的分析，您可能需要 SQL 之外的其他方法，并且您可能更喜欢 python 笔记本。
示例:使用 Python 进行字符串相似性检查[2]:
import distance
distance.levenshtein("customer_abc", "customer_abcd")
双重支付
重复支付意味着赔钱，因此你可以检查 BSEG 表中的财务记录是否有重复。以下 SQL 连接 BSEG 的 BSEG，以标识具有相同公司代码、金额等的记录。但是具有不同文档编号。
示例:SQL 检查重复项[3]:
SELECT B1.MANDT,B1.BUKRS,B1.GJAHR,B1.BELNR BELNR1,B1.BUZEI BUZEI1,B2.BELNR BELNR2,B2.BUZEI BUZEI2,B1.DMBTR FROM BSEG BSEG_1 JOIN BSEG BSEG_2 ON (BSEG_1.MANDT=BSEG_2.MANDT AND BSEG_1.BUKRS=BSEG_2.BUKRS AND BSEG_1.DMBTR=BSEG_2.DMBTR AND BSEG_1.SHKZG=BSEG_2.SHKZG) WHERE B1.BELNR!=B2.BELNR
周末和节假日交易
由于权责发生制会计(年度账目、流转税的提前返还等),在不寻常的日期过账可能会有风险。)或者诈骗。要获取日期为创建日期或更改日期的记录，您可能需要来自 getfestivo 等开放 API 的假日日期，并调用类似以下的 API:
示例 API 调用[4]:
[https://getfestivo.com/v2/holidays?api_key=**[**](https://getfestivo.com/v2/holidays?api_key=[) **YOUR API KEY HERE]**&country=DE&year=2020
不寻常的预订文本
要确定不应该存在的费用，您可以在 BKPF 表中使用以下内容搜索不寻常的预订文本:
SQL 文本搜索示例:
... FROM BKPF
WHERE UPPER(BKTXT) LIKE = “Cancellation”
OR UPPER(BKTXT)= “Credit note”
UPPER(BKTXT)= “fee”
UPPER(BKTXT)= “Switzerland”
.....
结论
这些只是 SAP 系统中少数可能的分析问题，但由于我们讨论的是财务数据，这是一个重要的话题，您和您的公司应该意识到这些问题，并渴望培养分析能力。在本文中，示例与 SAP 相关，但是其他具有财务模块的 ERP 系统，如 Oracle 或 DATEV，也将以相同的方式工作，并且案例也是相似的。
进一步的资料和阅读
[1]石，董，(2015)使用 CAATs 对 SAP 进行审计。
[2]pypi.org，https://pypi.org/project/Distance/
[3]DAB-GmbH，https://www . da b-Europe . com/file admin/public data/Downloads/2016 _ 04 _ DAB _ Gesamtkatalog _ es . pdf
[4]费斯蒂沃，https://getfestivo.com/documentation
谷歌云中的 SAP 数据分析
如何将 SAP 与谷歌云平台(BigQuery、Data Studio 或 recently looker 等强大数据分析工具的提供商)相结合，以获得强大的数据分析平台和宝贵的见解。如果您对 SAP 数据的实用数据分析方法感兴趣，这篇文章可能也会让您感兴趣。
云是数据分析的推动者——图片由 Alex Machado 在 Unsplash 上提供
体系结构
SAP HANA 已经内置了 SAP 数据服务，因此您可以轻松地将数据从 SAP 应用程序或其底层数据库导出到 BigQuery。然而，GCP 和思爱普的结合对于那些仍然生活在 ERP 世界中的公司来说也是可能的。
以下几点显示了将数据从 SAP 加载到 Google Services 的可能性:
- 使用 talend/Google data flow/等数据集成工具，通过 RFC(远程函数调用)接口提取数据。
- 编写 ABAP 程序
- fivetran 等第三方连接器
- 使用 SAP 复制服务器
因此，可能的解决方案如下所示:
SAP 到大型查询—图片来自 Google [1]
实现增量负载
获取数据是第一步。之后，您将处理如何实现一个 delta 逻辑的问题，因为您可能不想通过满载定期加载所有数据。这只会带来加载时间长、没有历史数据等缺点。尤其是控制、内部审计等部门。通常基于历史数据视图构建他们的数据分析。
虽然 SAP 数据服务已经内置在 CDC 向导中，但其他数据集成方法可能需要一些额外的工作。要实现这一步，非常了解 SAP 表和表结构是很重要的。在自己的逻辑上实现增量加载尤其可以借助两个表来实现: CDHDR (改变标题)和 CDPOS (改变位置)。这些表跟踪主数据或事务数据的变化。
数据转换
随着基于列的数据仓库工具(如 BigQuery)的出现，由于性能以及源系统和目标系统之间不同的表结构或数据类型，数据转换通常是必要的。
一个例子是，在 SAP 中，你有 BKPF(会计凭证标题)和 BSEG(会计凭证段)表。由于其基于列的结构，对 BigQuery 中的数据进行反规范化是有意义的。解决方案可以是连接 BKPF 和 BSEG，如果需要，还可以连接其他主数据和参考表——例如借助 BigQuery DTS(数据传输服务)中的内置功能。因此，您可以得到一个非规范化的数据对象体系结构，如下图所示:
插图:从原始表格到非规范化数据对象-作者图片
另一个获得性能和成本效率的转换是使用嵌套数据结构。BigQuery 或 Amazon 的 Redshift 等较新的数据仓库技术确实能更好地处理这种数据结构。使用嵌套数据的用例有，例如标题/段表，如 BKPF 和 BSEG，或者如果一个表包含的列变化不大，如:
namelastname
结合历史上经常变化的列，如[2]:
address(一个嵌套重复的字段及其后续嵌套字段):address.addressaddress.city
实施(自助)申报
最后一部分将实现报告和数据分析的可能性。有了 BigQuery，数据分析师已经有了一个很好的分析工具。数据科学家可以使用数据实验室或 GCP 内众多 ML 服务之一。Data Studio 可能是业务用户共享 KPI、仪表板等的合适解决方案。为了在 BigQuery 中实现角色/用户访问模型，通常使用 BUKRS 属性(公司代码)，这样用户就只能看到分配给他的公司代码的数据，这也是 SAP 处理用户权限的方式。
结论 SAP 和 GCP 的结合将为贵公司带来巨大的数据分析能力和可能性。SAP 系统托管了大量想要分析的有趣数据，而 GCP 提供了许多数据分析/科学家工具和服务，可以实现这一点。
资料来源和进一步阅读:
[1] Google，https://cloud . Google . com/solutions/sap/docs/big query-replication-from-sap-apps？hl=de
[2]谷歌，https://cloud.google.com/bigquery/docs/nested-repeated
https://blogs.sap.com/2018/04/08/hana-sda-google-bigquery/
https://cloud . Google . com/solutions/sap/docs/big query-sap-export-using-SDS
讽刺分类(使用快速文本)
我们将使用 FastText python 模块为新闻标题构建一个讽刺分类器。
FastText 是由脸书研究团队创建的一个库，用于高效学习单词表示法和句子分类。它在 NLP 社区中吸引了很多人，特别是作为一个强大的单词表示基线，取代了 word2vec，因为它在获取单词向量时考虑了字符 n 元语法。这里我们将使用 FastText 进行文本分类。
数据收集自https://www . ka ggle . com/RMI SRA/news-headlines-dataset-for-sneach-detection。这里讽刺的是来自TheOnion而非讽刺的是来自HuffPost。现在让我们跳到编码。**
首先，让我们检查数据来决定方法。可以从https://www . ka ggle . com/RMI SRA/news-headlines-dataset-for-stranship-detection/data 下载数据？select =挖苦 _ 头条 _ 数据集 _v2.json 。
***#load data*
**import** **pandas** **as** **pd**
df = pd.read_json("Sarcasm_Headlines_Dataset_v2.json", lines=**True**)
#shuffle the data inplace
df = df.sample(frac=1).reset_index(drop=**True**)
*# show first few rows*
df.head()**
基本上，在阅读带有 pandas 的表格形式的 json 时，数据集包含 3 列，其中‘headline’包含新闻的标题文本,‘is _ anticate’包含分别表示讽刺和非讽刺的 1 和 0。如果我们看到讽刺和非讽刺的例子的代表性是
0 14985
1 13634
Name:is _ sniptic，dtype: int64
现在来看看课文是如何寻找讽刺和非讽刺的例子的:
**#word cloud on sarcastic headlinessarcastic = ‘ ‘.join(df[df[‘is_sarcastic’]==1][‘headline’].to_list())plot_wordcloud(sarcastic, ‘Reds’)**
***#word cloud on sarcastic headlines* sarcastic = ' '.join(df[df['is_sarcastic']==0]['headline'].to_list()) plot_wordcloud(sarcastic, 'Reds')**
现在，在构建分类器模型之前，我们需要对文本进行一些清理，以消除噪声。既然这些都是新闻标题，就不包含太多废话。我想到的清理是把所有的字符串都变成小写，去掉所有不是字母数字的内容，用一个特定的标签替换数字。
**df['headline'] = df['headline'].str.lower()
df['headline'] = df['headline'].apply(alpha_num)
df['headline'] = df['headline'].apply(replace_num)**
现在，我们已经准备好清理文本和它们相应的标签来构建一个二元讽刺分类器。如前所述，我们将使用 FastText python 模块构建模型。
首先，需要在环境中安装 FastText python 模块。
***#Building fasttext for python\*
!git clone https://github.com/facebookresearch/fastText.git
!cd fastText
!pip3 install .**
我们需要以 FastText api 可以理解的格式准备好训练和测试文件。我们希望用来训练模型的文本文件的默认格式应该是 __ label __
***#data preparation for fasttext*
**with** open('fasttext_input_sarcastic_comments.txt', 'w') **as** f:
**for** each_text, each_label **in** zip(df['headline'], df['is_sarcastic']):
f.writelines(f'__label__**{each_label}** **{each_text}\n**')**
文件中的数据如下所示:
**!head -n 10 fasttext_input_sarcastic_comments.txt__label__1 school friends dont find camp songs funny
__label__0 what cutting americorps would mean for public lands
__label__0 when our tears become medicine
__label__1 craig kilborn weds self in private ceremony
__label__1 white couple admires fall colors
__label__1 mom much more insistent about getting grandkids from one child than other
__label__0 diary of a queer kids mom
__label__1 sephora makeup artist helping woman create the perfect pink eye
__label__1 kelloggs pulls controversial chocobastard from store shelves
__label__0 winston churchills grandson introduces a new nickname for donald trump**
这里 __label__0 表示非讽刺，__label__1 表示讽刺。现在我们已经准备好开始训练分类器模型了。为此，将把数据集分为训练(90%)和测试(10%)数据集。用于监督二元分类的 FastText 函数是 train_supervised 。
***''*
*For classification train_supervised call will be used:*
*The default parameters to it:*
*input # training file path (required)*
*lr # learning rate [0.1]*
*dim # size of word vectors [100]*
*ws # size of the context window [5]*
*epoch # number of epochs [5]*
*minCount # minimal number of word occurences [1]*
*minCountLabel # minimal number of label occurences [1]*
*minn # min length of char ngram [0]*
*maxn # max length of char ngram [0]*
*neg # number of negatives sampled [5]*
*wordNgrams # max length of word ngram [1]*
*loss # loss function {ns, hs, softmax, ova} [softmax]*
*bucket # number of buckets [2000000]*
*thread # number of threads [number of cpus]*
*lrUpdateRate # change the rate of updates for the learning rate [100]*
*t # sampling threshold [0.0001]*
*label # label prefix ['__label__']*
*verbose # verbose [2]*
*pretrainedVectors # pretrained word vectors (.vec file) for supervised learning []*
*'''*
model = fasttext.train_supervised('sarcasm_train.bin', wordNgrams=2)**
要测量测试数据集中的性能:
***#measuring performance on test data*
**def** print_results(sample_size, precision, recall):
precision = round(precision, 2)
recall = round(recall, 2)
print(f'{sample_size=}')
print(f'{precision=}')
print(f'{recall=}')
print_results(*model.test('sarcasm_test.bin'))***sample_size=2862
precision=0.87
recall=0.87*****
结果虽然不完美，但看起来很有希望。我们现在保存模型对象，以便将来进行推理。
***#save the model*
model.save_model('fasttext_sarcasm.model')**
FastText 还能够压缩模型，以便通过量化牺牲一点点性能来获得更小的模型文件。
**# with the previously trained `model` object, call
model.quantize(input='sarcasm_train.bin', retrain=True)\
# results on test set
print_results(*model.test('sarcasm_test.bin')) ***sample_size=2862
precision=0.86
recall=0.86*****
如果你看到精度和召回似乎遭受 0.01 分，但是，看看模型文件大小:
**!du -kh ./fasttext_sarcasm****98M ./fasttext_sarcasm.ftz
774M ./fasttext_sarcasm.model*****
压缩模型只有基本模型的 1/12。因此，这是模型大小和性能之间的权衡，用户必须根据用例来决定。既然分类器模型已经训练好并准备好了，现在是准备好推理脚本的时候了，这样您就可以计划部署了。
**def predict_is_sarcastic(text):
return SarcasmService.get_model().predict(text, k=2)if __name__ == '__main__':
ip = 'Make Indian manufacturing competitive to curb Chinese imports: RC Bhargava'
print(f'Result : {predict_is_sarcastic(ip)}')***Result : (('__label__0', '__label__1'), array([0.5498156 , 0.45020437]))*****
从上面可以看出，最大概率的结果标签是 __label__0，这意味着根据训练的模型，所使用的标题是非讽刺性的。在 model.predict()调用中，k 的值表示您希望输出的类的数量以及它们各自的概率分数。由于我们使用了 softmax 激活(FastText 中默认的一个)，两个标签的概率之和为 1。
总之，在进行任何 NLP 分类时，FastText 可以是一个强大的基线，并且它的实现非常容易。这篇文章的所有源代码可以在我的 git repo 找到。FastText python 模块没有得到官方支持，但对于技术人员来说，这不应该是一个实验问题:)。在以后的文章中，波斯特将尝试讨论如何将训练好的模型转移到生产中。
fastText 是一个用于高效学习单词表示和句子分类的库。在本文档中，我们…
github.com](https://github.com/facebookresearch/fastText/tree/master/python) [## sambit 9238/深度学习
深度学习技术在自然语言处理、计算机视觉等领域的实现。-sambit 9238/深度学习
github.com](https://github.com/sambit9238/Deep-Learning/tree/master/sarcasm_classifier)**
自然语言处理中的讽刺检测
一个高度复杂现象的研究综述
梅勒妮·德雷维克在 Unsplash 上的照片
⚠️读了我在⚠️博客中的原帖
当你试图知道某人是否在讽刺你时，你可能会做出这样的表情。对人类来说不易察觉，机器呢？
**注意:**为了简洁起见，这篇文章将只考虑使用 tweets 和使用深度学习模型的讽刺检测。
讽刺检测在 NLP 中是一个非常狭窄的研究领域，它是情感分析的一个特例，它不是检测整个光谱中的情感，而是关注讽刺。因此，这个领域的任务是检测给定文本是否是讽刺性的。
我们遇到的第一个问题是，与情绪分析中情绪类别的定义非常明确(爱客观上有积极的情绪，恨消极的情绪，无论你问谁或你说什么语言)不同，讽刺的边界没有那么明确。在开始发现讽刺之前，先了解一下什么是讽刺是至关重要的。
什么是讽刺？
牛津词典提供了如下定义:
讽刺是使用通常表示相反意思的语言来嘲笑或表达轻蔑。
有些人可能不同意它的目的，但有一个惯例，人们使用积极的话来传达消极的信息。当然，它因人而异，高度依赖于文化、性别和其他许多方面。例如，美国人和印度人对讽刺的理解是不同的。
此外，有人讽刺并不意味着其他人认为这是说话人的意图。这种主观性将对 DL 模型的性能产生影响。
1.数据:推特数据集
首先，两个 Twitter 数据集被用来进行研究:
里洛夫等人，2013 年
他们的数据集由自动提取的推文组成:35k 包含标签#挖苦和 140k 随机推文。
里洛夫数据集的一个例子
与其他数据集相比，该数据集很大，但与 DL 模型中使用的数据集相比，该数据集非常小。这是不平衡的，这意味着非讽刺性的推文比讽刺性的多，这是现实的，因为讽刺在我们的日常互动中非常罕见，数据集应该尽可能地代表现实。关于讽刺的类型，这个数据集捕捉了**有意的讽刺，**这条推文被贴上讽刺的标签是因为作者希望它是这样，它没有考虑人们的看法。
Ptáek 等人，2014 年
他们的数据集由手动标注的推文组成:他们将 7k 条推文标注为讽刺，并添加了另外 7k 条随机推文。
Ptáek 数据集的一个例子
这个数据集要小得多，因为手动标注更加耗时。这些研究人员还选择使其平衡，增加比通常更多的讽刺例子，以帮助模型更好地概括。在这种情况下，被标记为讽刺的推文是注释者认为是讽刺的(认为是讽刺)，作者的意图没有被考虑。
这条推文在 2013 年疯传，这名女子在登机前写了这条推文，当她抵达她所访问的非洲国家时，推特爆炸了，她收到了许多指责她的各种消息，她甚至失去了工作……当有人最终让她发言时，她说她是在讽刺和开玩笑，她无意冒犯任何人。但在那个时候，她的意图无关紧要。
2.特征
历史上，原始推文添加了许多层功能:
- 清理:删除其他标签，链接，图片。
- 词法功能:删除停用词、标记化、弓形、词性标注
- 实用特征:表情符号、提及
- 上下文不一致:上下文不一致。可以是显式的，也可以是隐式的
- 用户嵌入 : 风格和个性特征。这种嵌入以两个相似用户具有相似嵌入的方式编码一个 Twitter 用户的信息。因为他们在推特上谈论同一个话题，用相似的风格写作，或者有可比的行为模式。
用户嵌入的想法是，如果在训练数据中有一个具有某种个性的用户，他们碰巧发出讽刺性的推文，那么当我们获得新数据时，有一个新用户具有类似的风格，因此与前一个用户类似的嵌入，无需查看新用户的推文，我们就可以预测这个用户是否会讽刺。仅仅通过观察嵌入的相似性。
最后两个特征是在撰写本文时才出现的，已经取代了早期研究中使用的纯语言和词汇特征。
3.模型
有无数的 DL 模型和架构的组合，这篇文章的目的不是深入分析模型。
直到 2017 年，大多数模型都是机器学习模型、逻辑回归、SVM 和 CNN 的一些尝试。
大约在 2017 年，LSTMs 开始有牵引力，由于它们的顺序性质和更容易处理长期依赖性，它们接管了 ML 模型。像变形金刚这样的注意力模型也很快取代了它们，现在变形金刚、密集网络和 CRF 层的组合正在被使用。
4.分析
不同的论文有不同的评价方法，但在几乎所有的情况下，人的评价很差，模型的评价更差。可能的原因是少量的数据和人类本身无法察觉讽刺。
分析当前研究立场的主要论文之一来自 2019 年 Oprea 和 Magdy，他们提出了 3 个旨在回答的问题:
- 用户嵌入是否预示了推文的讽刺性质？
- 用户嵌入在 Riloff 和 Ptacek 数据集之间扮演什么角色？
- 这两个数据集之间的性能差异是什么？
换句话说，第一个问题是，我们是否可以在不看推文的情况下，仅通过了解用户过去的行为和个性来预测讽刺。概括一点，讽刺是随机的，还是有某些性格特征使某人更可能是讽刺的？
如果是，它们对这两个数据集的影响是什么？了解某人，他们的爱好和兴趣，他们的个性，是否有助于我们发现他们是否在讽刺我们？
至于性能，在这两个数据集上训练模型，DL 模型在哪里表现得更好？
我鼓励读者停止阅读一段时间，根据你的直觉和你目前所读的内容，尝试猜测答案并思考原因。
这只猴子正在努力思考用户嵌入，并阻止你马上看到答案，鼓励你花一分钟思考它们:)
保罗·尼科勒洛在 Unsplash 上的照片
该论文表明，用户确实有一种基于他们的历史行为来决定是否讽刺的倾向。对我们来说，有些人比其他人更讽刺似乎是很自然的，但这是第一次有人在推特上发表这样的观点:是的，个性和讽刺是相关的。
为了回答第二个问题，用户嵌入在 Ptacek 数据集上是很好的预测器，但在 Riloff 数据集上不是。这意味着当察觉到别人的讽刺时，了解他们是有帮助的。但是当检测到他们有意的讽刺时，添加用户嵌入似乎不会增加任何价值。
关于第三个问题，DL 模型在 Riloff 上表现相当不错，在 Ptacek 上表现不佳。这可能有很多原因，平衡/不平衡，他们捕捉的不同类型的讽刺，但在我看来，在这一点上，它只是大小的问题(Riloff 的 35k 讽刺性推文，Ptacek 的 7k)。我相信这个模型在 Riloff 上有更好的结果，只是因为有更多的推文可以训练。如果数据集具有相同的大小，那么观察它们之间的差异将会非常有趣。
这篇论文也是第一次正式表示，由于 Riloff 和 Ptacek 之间的结果缺乏一致性，他们得出结论，这些数据集是不等价的，它们捕捉了不同的现象，即有意和感知的讽刺。
这篇论文的意义是巨大的，我希望看到它对 2020 年以后发表的论文的影响。
5.当前立场和未来研究
目前，一般来说，人们使用的主要是文本数据，一般来自 Twitter 和 Reddit，但也来自其他论坛帖子。
至于特征，他们使用了一些词汇特征、单词的上下文嵌入(BERT)和用户嵌入。
每个月都有新的发布模型，通常是一些密集层的变形金刚组合。
现在常见的一些错误有:
- 假阴性:模型没有检测到讽刺性的推文，很可能是因为它们非常特定于特定的情况或文化，并且它们需要 DL 模型所不具备的高水平的世界知识。最有效的讽刺是专门针对人、情境和说话者之间的关系的讽刺。
- 以非常礼貌的方式写的讽刺性的推文不会被发现。有时候，人们用礼貌作为讽刺的方式，用非常正式的词来形容与随意的谈话不相称。以非常正式的方式称赞某人是一种常见的讽刺方式。
未来的研究
作为未来的研究，我希望看到在数据集上做更多的工作，更大，更完整，更多样化的数据集，而不是不断增长的复杂的 DL 模型。一个模型和它的数据一样好，而且迄今为止使用的数据集都有它们的偏见和局限性。
实际上，在 2019 年底发布了一个新的数据集，Oprea 和 Magdy 的 iSarcasm，用户可以贡献自己讽刺的推文，并包括对为什么讽刺的解释，以及一些关于他们的元数据。不幸的是，它不是很大(大约 1k 条推文)，但在我看来，这是朝着正确方向迈出的一小步。
DL 的最大挑战之一似乎是将世界知识添加到模型中，这将加速训练，并极大地有助于泛化和偏向。但问题是怎么做。截至目前，没有答案。
最后，有些人正在超越文本，使用图像和音频的多模态讽刺检测，根据电视节目如《生活大爆炸》和《老友记》的数据训练模型。它仍处于早期阶段，但考虑到讽刺的多模态性，它看起来很有希望。很多时候讽刺的不是文字，而是语调或者面部表情。
这是截至 2020 年初讽刺检测的概述，我希望它足够信息量，以便任何具有最低限度机器学习知识的人都可以理解并了解最新的研究。
你可以在我的 Github 中找到发表在《讽刺检测》上的大多数论文的注释，以及我的演示文稿中的幻灯片。我已经把我在帖子中直接引用的具体论文的链接放了出来。
我很乐意讨论发现讽刺的想法和方法，或者解释一些不清楚的概念。欢迎在 Twitter 上和我聊天。感谢阅读！
SARS 基因组符合本福特定律，具有核碱基的笛卡尔乘积
~Python 代码~
恒星也以多种方式遵循本福德定律。(图片作者)
许多人可能听说过来自网飞的书呆子和娱乐纪录片 的本福德定律连接 章节“数字”老实说，那是我第一次听说它的地方。1 到 9 中较小数字的第一位优势…这是一种隐藏的模式，我们都以某种方式融入其中，无法摆脱。
鉴于目前的事件，我想知道本福特定律如何适用于病毒基因组序列，因为本福特定律需要大量的实例才能恰当地适用。SARS 物种基因组(包括新型冠状病毒，通常称为新型冠状病毒)的核苷酸或核碱基长度约为 29，800(也称为基因组的组成部分:A，T，G，C)。出版物已经显示了本福德对特定基因的分析趋势，但是仅仅看基因组序列似乎不能说明生物信息，除了提供一些有趣的“玩弄”法律。今天，我将玩转法律，揭开 SARS 序列的“本福特性”。首先，我导入了序列文本文件，去掉了换行符。然后，我将字符串分割成单个字母，并创建了一个函数“count_pattern”用于计数(代码如下所示)。在这篇文章中，我展示了 2003 年非典和 2019 年新型冠状病毒的例子(点击查看基因组信息)。
创建更多实例的一种方法是查看特定的核碱基(我称之为 bp )排列在基因组中出现了多少次(即 AG、at、GC、ATG、GGG、CTA、ATGC、CGTT……被发现了多少次)。为了穷尽这个列表，我们只取 bp: A，T，G，c 的笛卡尔积【简而言之，什么是笛卡尔积？这是一种重复的排列:比方说，把苹果、梨和香蕉按照一定的顺序放进四个口袋#1、2、3、4，每个口袋一个水果。]为了不出现大多数个位数，我从单个 BP(A、T、G、C 分别出现的次数)到 5 bp(即 AGTGC)进行了计数。
值得一提的一个“bug”是 Python 3 中的 count 函数不会多次重复计算排列中的同一个字符。例如，如果遇到’…AAAA…，‘我们知道技术上有 3 个‘AA’在里面，但是函数会回答 2。同样，如果遇到…TTTTT…，'在这种安排下，该函数将只记录 1 个“TTT”，而我们将记录 3 个。为了快速解决这个问题*(暂时忘记优雅)，我简单地半手工将 repeat=3 & 5 的计数添加到 2 bp 的计数中，将 repeat=4 & 5 的计数添加到 3 bp 的计数中，将 repeat=5 的计数添加到 4 bp 的计数中。我没有深究，但数学就是这样解决的。这仅适用于 bp 一致的计数排列。*
有趣的是，似乎有一种奇偶依赖或交替趋势:**偶数BP 排列的计数产生了一种更像本福特的趋势***——这意味着第一位数更有可能是 1 和 2，**，而奇数*BP 排列的计数似乎大大违反了本福特定律。**注意 y 轴是自然对数而不是线性刻度，以更好地显示下计数值。
笛卡尔乘积 bp 数的 sar(作者图片)
新型冠状病毒按笛卡尔积的 bp 数(作者图片)
然而，如果将所有的数据汇总在一起，我们会得到一个基于曼-惠特尼检验的类似本福特的曲线(SARS 和新型冠状病毒序列的 P > 0.86)。虽然曼-惠特尼检验可能不是检测任何细微差别的最佳方法，但由于趋势很明显，我将暂时搁置它。黑色条代表实际数据，而紫色曲线是公式 log(1+1/d)得出的本福特曲线。
SARS 样本结果(图片由作者提供)
新型冠状病毒样本结果(图片由作者提供)
我们能从这个练习中学到什么？我被本福德定律的流行所震惊——它似乎以某种方式潜伏在这个世界的计数之下。有许多方法可以创建要计数的实例(就像这里介绍的一样)。虽然我不是遗传学专家，但我敢打赌这篇文章的结论对其他基因组也适用。我也想知道随机生成的序列是否符合这个结论。本福特定律是所有可测量事物的基础，还是仅仅是“自然发生”的事物？“自然发生”到底是怎么定义的？也许研究人员可以致力于建立更有意义的标准和指导方针，利用本福特定律来检测欺诈行为，并提供可操作的见解。一篇显示人类大脑电活动也遵循这一普遍规律的文章可以在这里找到。我将把进一步的见解和解释留给任何感兴趣的人——但我对探索这个话题很感兴趣。
来自 FASTA 的文字截图
🛰️从卫星探测海岸线变化的四个步骤
Python 和 OpenCV 来检测海岸线随时间的变化
介绍
海岸是一个非常动态的系统 在这个系统中，海岸线的侵蚀、后退或前进现象受到众多气象、地质、生物和人为因素的控制。
在海洋磨蚀的作用大于沉积物的情况下，有明显的海岸侵蚀的情况，字面上导致地球表面 解体和破坏 。
来源: 弗林德斯大学 (CC0)
本文的目标是
在本文中，我们将使用一种叫做 的算法对 Landsat 8 平台上的【OLI】传感器*** 获取的两幅卫星图像进行 Canny 边缘检测*** 。
通过这种方法， 我们将能够可视化和评估一个特定的欧洲地区遭受强烈侵蚀作用的海岸线的进程:霍尔德内斯海岸。
这里的是拟定的工作流程 :
整个管道:从进口到产品。
开始吧！但是之前…
0.陆地卫星 OLI 数据简介
Landsat 8 是一个轨道平台，安装在一个名为 OLI(实用陆地成像仪)的 11 波段多光谱传感器 上。
具体来说，在本文中，我们将仅使用分辨率为 30 米的波段(即前 7 个波段)。
美国地质调查局地球资源卫星 8 号
资料可以免费下载 ，注册后通过USGS:https://earthexplorer.usgs.gov/提供的平台。
此外，正如通常使用的那样， 我们将使用反射率 ，即从地球表面反射的阳光量【0–1】，而不是使用入射阳光的原始数据。
1.包导入
在各种常见的软件包中，本文我们将使用来轻松处理 光栅 图像，使用 OpenCV 来应用 Canny 算法和 Scikit-Learn 到 段
2.数据导入
让我们定义一个变量，它告诉我们要保留的波段数以及先前在 JSON 中输入的辅助数据:
这个 Json 是来自 Landsat OLI 成像仪(我创造的)的信息集合。一种说明书。看起来是这样的:**
bands.json 文件包含了我们将要使用的波段的所有有用信息。
请记住，我们将只使用 30 米分辨率的波段，所以只有前 7 个。如果你愿意有较低的分辨率(100m)，你可以嵌入 重要的 TIRS 1 和 TIRS 2 波段以及 。
正如上面几行已经提到的，我们将使用来自 OLI 陆地卫星 8 号的两个不同的采集数据:
- 2014/02/01
- 2019/07/25
为了方便和加速两个采集 的所有操作，我们将定义一个 Acquisition()类 ，它将允许我们封装所有必要的函数。
在代码执行期间，这将允许我们执行一些支持功能，例如:
- 在指定路径中搜索 GeoTIFF
- 加载 采集；
- 收购 登记 (对齐)；
- 采集子集采集**
好了， 我们现在可以使用 : 来启动整个代码
结果应该是这样的:
**Searching for 'tif' files in Data/2014-02-01
Found 7 'tif' files
Loading images
Done
Searching for 'tif' files in Data/2019-07-25
Found 7 'tif' files
Loading images
Done**
我们的 14 幅 OLI 图像(7 个波段中的 2 次采集)现已加载。
2.1.子集化多光谱立方体
在这个阶段，在两个多光谱立方体 的 的“对齐”(或更正式的注册)之后，我们负责剪切掉我们不感兴趣的采集部分。
让我们使用函数**sub estimates()**来“剪切”不需要的数据。
因此，让我们 定义 AOI ( 感兴趣区域)并使用 【采集() 类中的函数**subestimages()**进行子集化:
搞定了。
3.数据探索
3.1.可视化多光谱立方体
让我们尝试查看 2019/07/25 收购的所有乐队。 纯粹出于审美原因 ，在制作图像剧情之前，我们先用**standard scaler()**对图像进行标准化处理。
这应该是结果。
正如你所看到的，有些波段比其他波段更亮。这很正常。
3.2.以复合 RGB 显示多光谱立方体
现在让我们尝试在使用波段 4(红色)、3(绿色)和 2(蓝色)获得的 RGB 合成 中可视化这两个采集。
偏置和增益被定义 只是为了得到一个漂亮的 viz 。
这就是结果！有趣的是，这两种采集在反射率方面有着显著的不同。
好了，继续进行 海岸线检测 。
4.自动海岸线检测
在本段中，我们将使用 Canny 的方法 进行边缘检测。
在进行真正的检测之前，有必要准备数据集，尝试通过聚类算法 对其进行分割，以区分海洋和陆地 。
4.1 数据准备
在这个阶段，我们应该为聚类操作重塑两个多光谱立方体。
4.2 使用 K 均值的图像分割
让我们通过 k-means 对这两个收购 进行分段(使用你更喜欢的模型)。
4.3.收购细分结果
这里有两个集群确定代表浮现的土地和水体。
4.4.Canny 边缘检测算法
Canny 的传统钥匙技术分为以下几个阶段:
- 降噪 通过与高斯滤波器卷积；
- 图像 四个方向 (水平、垂直、2 斜)的渐变计算；
- 提取 梯度局部极大值；
- 阈值带迟滞 用于边缘提取。
让我们立即开始，通过 将聚类结果转换成图像 ，然后 通过具有 15×15 内核的高斯滤波器降低噪声 :
稍微模糊图像后，我们可以使用OpenCV****Canny()**模块继续执行真正的 Canny 技术:
在一行代码中，我们获得了梯度，提取了局部最大值，然后对每次采集应用了具有滞后的阈值。
注意:使用 Canny()参数探索不同的结果。
4.5.结果呢
这是结果。
以下是一些细节:
5.结论
从结果中可以看出，Canny 的算法在其原始管道中工作得相当好，但其性能像往常一样取决于所涉及的数据。
事实上，所使用的聚类算法允许我们分割初始的多光谱立方体，其性能当然可以改进。并行使用几个聚类模型可以全面改善结果。
🤝如有任何疑问、反馈或合作要求，请随时* 联系我Linkedin*。我会很高兴和你聊天！**
👉要获得更多类似的内容，并关注即将发布的文章，请不要忘记在 Medium 上 关注我。
👉 如需参考本文，请联系我。谢谢你。
土星云托管已推出:为每个人的 GPU 数据科学
数据科学的未来&机器学习支持 GPU
GPU 计算是数据科学的未来。RAPIDS、TensorFlow 和 PyTorch 等包实现了数据科学所有方面的闪电般快速处理:数据清理、特征工程、机器学习、深度学习等。利用 GPU 计算的挑战在于，它需要对内部硬件或基础设施进行投资，以便在云上利用 GPU。
今天，土星云宣布推出土星云托管，这是一个端到端 GPU 数据科学的云托管解决方案，适合所有初创公司、小型团队、学生、研究人员和修补数据科学家的需求。
鸣谢:土星云
TL；DR:Saturn Cloud Hosted是实时的，任何人只需点击一个按钮，就可以注册并启动支持 GPU 的数据科学机器。您可以立即开始免费试用！
鸣谢:土星云
注册后几秒钟内，您就可以启动 JupyterLab 实例，该实例具有针对最流行的 GPU 数据科学包的预配置环境，由英伟达 T4 或 V100 GPU 提供支持。当您的数据大小超过单个 GPU 时，您可以轻松地扩展到由多个 GPU 机器组成的集群。几百甚至！Saturn Hosted 负责所有硬件供应、环境设置和集群通信挑战，因此数据科学家可以直接投入工作。
土星云托管的 GPU 改变世界。鸣谢:土星云
由 NVIDIA GPUs 托管的土星云的愿景是将世界上最快的数据科学和机器学习能力带给每个人，无论预算、资源和时间如何。虽然 GPU 加速工具在以前是一种奢侈品，但随着时间的推移，价格下降，加上云可用性和 Saturn Cloud 提供的基础设施，使其成为日常用户的强大工具。
GPU 上更快的随机森林
让我们探索使用 Apache Spark 在 CPU 机器集群上实现分布式随机森林训练，并将其与使用 RAPIDS 和 Dask 在 GPU 机器集群上训练的性能进行比较。
TLDR :我们使用 3 亿个实例训练了一个随机森林模型:Spark 在 20 节点 CPU 集群上耗时 37 分钟，而 RAPIDS 在 20 节点 GPU 集群上耗时 1 秒。这比 GPU 快了 2000 多倍。
您可以在此阅读关于该基准测试的更多内容。我们在 Spark (CPU)和 RAPIDS (GPU)集群上对纽约市出租车数据的 300，700，143 个实例训练了一个随机森林模型。两个集群都有 20 个工作节点，小时价格大致相同。以下是工作流程每个部分的结果。
Spark 是 37 分钟，而 RAPIDS 是 1 秒钟！
GPU 粉碎了它——这就是为什么你现在拥有它们会如此激动。想想当你不需要为一次拟合等待超过 30 分钟时，迭代和改进模型的速度会有多快。一旦您添加了超参数调整或测试不同的模型，每次迭代很容易增加到几个小时或几天。
需要看到才相信？你可以在这里找到笔记本！或者继续阅读，看看如何在 Saturn Cloud Hosted 中建立一个项目，并为自己运行它。
借助土星云托管的 GPU 加速数据科学
在 Saturn Cloud Hosted 上使用 GPU 很容易上手，我们将使用一个数据样本完成上面的随机森林模型训练练习。该示例使用纽约市出租车数据来训练随机森林模型，该模型将乘坐分为“高小费”或“低小费”乘坐。当你创建一个帐户时，这些笔记本会被预加载到一个“examples-gpu”项目中，或者你也可以自己点击这里获取这些笔记本。
我们首先将一个 CSV 文件加载到一个数据帧中，但是因为我们使用的是 RAPIDS cudf 包，所以数据帧被加载到 GPU 内存中:
然后经过一些特征处理，我们训练我们的随机森林模型！
Saturn Cloud Hosted 的伟大之处在于这段代码“能够正常工作”。环境已经给你设置好了，GPU 也接好了，现在你可以专注于训练一个模型了。
如果数据集很大，使用单个 GPU 可能不够，因为数据集和后续处理必须适合 GPU 内存。这就是土星云上的 Dask 星团发挥作用的地方！您可以从 UI 或笔记本中定义集群，确保为 Dask 工作人员选择 GPU 大小:
接下来就是为分布式 GPU 处理导入适当的 RAPIDS 模块和子模块:
你想要一个简单的方法来获得超快的 GPU 数据科学吗？
是啊！有了土星云托管，您可以在几秒钟内启动 GPU 集群。Saturn Cloud 处理所有工具基础设施、安全性和部署问题，让您立即开始使用 RAPIDS。点击这里免费试用土星云主持的！
如果您所在的公司需要虚拟私有云解决方案，土星云也提供企业解决方案，您可以在这里找到。
作者:
亚伦·里希特，土星云高级数据科学家
米（meter 的缩写））塞巴斯蒂安·梅蒂，土星云的创始人
使用记录聚合节省 Amazon Kinesis 流成本
使用 KPL 记录聚合降低 AWS 成本的案例研究
几年前，我们为一个客户开发了一个流管道，使用 Kafka 代理在他们自己的数据中心运行。流媒体管道是使用 Kafka Producer API 开发的。由于业务前所未有的增长，他们决定将其基础架构迁移到 AWS 云。作为迁移的一部分，我们决定实现 Kinesis Streams 来替代 Kafka。
在我们参与之前，客户内部团队已经做了一些调查并得出了一些数字。这是他们想出的办法:
平均记录大小: 77 字节
记录格式: JSON
[centos @ IP-172–31–70–220 ~]$ python 3 single _ record _ producer . py
向 Kinesis 流发送这些数量的记录:1
(图片作者)
(作者图片)
(作者图片)
假设每秒 25000 条记录，Kinesis 计算器估计的账单为**$ 1196.82/月**——相当高
由于明显的原因，客户对价格感到担忧，所以他们联系了我们。这篇文章的目的是展示你如何利用运动聚合来获得优势。你可能知道 Kinesis 流的成本是基于 2 个因素:
- 碎片成本/小时(固定-根据所需碎片数量计算)
- PUT 有效负载(根据 PUT 有效负载而变化)—PUT 有效负载单元以 25KB 有效负载区块计算。这就是使用 Kinesis 记录聚合可以节省成本的地方。
什么是 Kinesis 记录聚合？
在大量情况下，数据工程师使用 Kinesis 生产者库(KPL)将记录写入 Kinesis 流。 聚合 是 KPL 的一部分，允许客户增加每个 API 调用发送的记录数量。
数据工程师通常按如下方式构建他们的代码:
从源
循环中取出数据记录，用于记录:
调用 kinesis_client.put_record 方法发送一条 78 字节 记录
结束循环
相反，这是他们应该做的事情:
从源
循环中取出数据记录进行记录: 调用 Kinesis 聚合器—一次放入 12 条记录 请求
调用 kinesis_client.put_record 方法发送 984 字节 记录
结束循环
[centos @ IP-172–31–70–220 ~]$ python 3 aggregate _ record _ producer . py
向 Kinesis 流发送这些数量的记录:12
(作者图片)
现在是成本节约…
(图片作者)
(作者图片)
95.75 美元/月，相比之下1196.82 美元/月—** 对于节省来说还不错**
我希望您获得了一些关于如何为客户节约成本的宝贵见解。Kinesis 记录聚合当然是一个非常有效的方法，但是我建议你应该从开发周期的一开始就实现它。否则，您将需要重构大量代码来实现它。
我希望这篇文章是有帮助的。亚马逊 Kinesis 是由 Datafence 云学院提供的 AWS 大数据分析课程的一部分。课程是周末自己在网上教的。
保存日期
如何在 SQL 查询中生成缺失日期
在本文中，我们将讨论:
- 如何使用 Presto SQL 生成一个包含日期范围的表
- 连接应该从另一个表中补齐缺失数据的表的经验法则。
在对数据进行计算之前，数据完整性是我们需要解决的最重要的事情之一。即使有正确的意图，我们有时也会忽略数据中的错误。当错误不在我们拥有的数据中，而是在我们没有的数据中时，这将变得非常困难。
当执行考虑数据中样本数量的计算(计算平均值或中值)时，我们需要处理值为 NULL 或零的行。
让我们假设我们经营一家网上商店，想要查看一个客户一个月内的平均日购买量。在客户没有购买的日期，我们的数据中不会有这种迹象。如果我们忽略这个问题，计算每个客户的平均购买量，我们会得到一个过高的估计。
customer_id | order_date | purchase_amount |
10000100005411274 | 2020-04-11 | 1 |
10000100005411274 | 2020-04-16 | 1 |
10000100005411274 | 2020-04-18 | 2 |
10000100005411274 | 2020-04-21 | 2 |
10000100005411274 | 2020-04-24 | 1 |
如果我们在不看我们的原始数据的情况下计算客户的日均购买量，我们会认为他的平均购买量是 1.4(真是个客户！).
为了解决这个问题，我们必须为所有客户生成并匹配所有日期。通过 Presto SQL，我们可以在一个简单的查询中做到这一点:
SELECT
*CAST*(date_column AS DATE) date_column
FROM
(VALUES
(SEQUENCE(*date*('2020-04-01'),
*date*('2020-04-30'),
INTERVAL '1' DAY)
)
) AS t1(date_array)
CROSS JOIN
UNNEST(date_array) AS t2(date_column)
使用 SEQUENCE，我们将创建一个日期在我们范围内的数组，并在数组中的每个元素与数组本身之间执行一个交叉连接。结果是每个不同日期对应一列。
一种快速的替代方法是从我们的初始数据中提取所有不同的日期，而不考虑客户，并将其存储为 WITH AS 语句。
接下来，我们将执行另一个交叉连接，以匹配我们的客户和不同的日期，从而填充缺失的日期:
with all_dates as (
SELECT
*CAST*(date_column AS DATE) date_column
FROM
(VALUES
(SEQUENCE(*date*('2020-04-01'),
*date*('2020-04-30'),
INTERVAL '1' DAY)
)
) AS t1(date_array)
CROSS JOIN
UNNEST(date_array) AS t2(date_column)
)
select distinct customer_id
,date_column as order_date
from customer_purchases
cross join all_dates
最后，我们将把客户和日期之间的新匹配加入到包含我们数据的初始表中。
重要通知
强表应该是我们用客户和日期创建的新表，而左连接表应该是我们的初始数据。如果我们执行内部连接，我们将丢失所有没有购买的日期。此外，我们需要确保不要在 where 子句中放置处理左连接表中的列的条件，这将把左连接变成内连接。
with all_dates as (
SELECT
*CAST*(date_column AS DATE) date_column
FROM
(VALUES
(SEQUENCE(*date*('2020-04-01'),
*date*('2020-04-30'),
INTERVAL '1' DAY)
)
) AS t1(date_array)
CROSS JOIN
UNNEST(date_array) AS t2(date_column)
),customers_dates as (
select distinct customer_id
,date_column as order_date
from customer_purchases
cross join all_dates)
select u.customer_id
, u.order_date
, *coalesce*(p.purchase_amount,0) purchase_amount
from customers_dates u
left join customer_purchases p
on u.customer_id = p.customer_id
and u.order_date = p.order_date
order by customer_id asc-------------------------------------------------------------------- customer_id | order_date | purchase_amount|
................. | .......... | ............. |
10000100005411274 | 2020-04-13 | 0 |
10000100005411274 | 2020-04-14 | 0 |
10000100005411274 | 2020-04-15 | 0 |
10000100005411274 | 2020-04-16 | 1 |
10000100005411274 | 2020-04-17 | 0 |
10000100005411274 | 2020-04-18 | 2 |
现在我们可以用正确的方法计算平均每日购买量。
总结(TL；博士):
1.使用 SEQUENCE，我们可以创建一个包含一系列日期的数组，并将它们转换成表格。这种方法对于填充数据中缺失的日期非常有效，可以确保没有发生的日期仍然会出现。
2.当在两个表之间执行左连接时，如果 where 子句中的条件寻址来自左表的列，则将左连接转换为内连接。人们很容易忽略这一点，当在同一个查询中使用表间连接应用条件时，应该三思而行。
通过更聪明地做事来节省时间
提高工作效率的 5 个简单技巧
西蒙·米加吉在 Unsplash 上的照片
时间是每个任务、每个项目的主要限制因素。如果你有无限的时间，你基本上可以做任何事情，取得任何成就。因此，明智的做法是优化你处理日常任务的方式，让它们花费更少的时间。当然，我们希望完成的工作量和质量保持不变。如果你在一个地方节省了一些额外的时间，你可以把它花在其他事情上。
在本文中，我将分享 5 个关于如何优化工作方式的技巧，并在处理数据科学项目时节省一些额外的空闲时间。实际上，这些技巧中的大部分都非常通用，不仅适用于数据科学，也适用于其他领域。
1.使用脚本自动化小型重复性任务
我相信这个想法对你来说并不新鲜。但是在现实中，你有多经常遵循这个建议呢？我见过许多人一次又一次地输入相同的行，每天在容易避免的地方重复完全相同的代码、文本和命令。
不要写两遍相同的代码。
我打赌你听说过这样一句话，甚至可能在为一些开源或商业产品编写代码时遵循这条规则。但是这条规则不仅仅对源代码有效。你的日常小任务呢？我将提供一个小例子让你更好地理解这个想法。
对于我的数据科学项目，我通常需要相当多的工具。像朱庇特笔记本，有的。txt 文件，用于存储临时笔记和链接，控制台终端打开我的项目的主目录，文件浏览器，互联网浏览器，等等。在我的互联网浏览器中，我通常喜欢打开一些预定义的标签，如我的电子邮件、我的日历、Kaggle、Matplotlib 函数参考等等。
因此，当我启动电脑时，我首先要做的是启动许多程序和应用程序。我已经测量过了——我可以设法在大约 2 分钟内开始。没有那么多，因为我一天只需要做一次，对吗？但后来我计算了一下，需要多长时间。每个工作日 2 分钟等于每周 10 分钟。总计每月 40 分钟。总计每年 480 分钟。顺便说一下，这正好是 8 小时或 1 个工作日。所以基本上，每年我都要花一整天的时间打开电脑。
然后有一天我写了一个大约 20 个命令的小脚本，它启动 Jupyter notebook，打开终端，打开浏览器，以及我需要的所有其他东西。除此之外，它甚至检查我的互联网连接，因为有时我的电脑无法捕捉无线网络，我需要重启网络接口几次才能让它工作。我的脚本替我做了。
现在我可以把这 2 分钟花在不同的任务上。例如，我可以在电脑启动时用手机查看电子邮件，或者做一些其他的小事情。我知道，那只是每天 2 分钟。但是事情总结起来。
如果你每个工作日只花 2 分钟做一些重复性的工作，那么到年底，你将会每天工作 8 小时。
当你在电脑上工作时，有很多事情可以实现自动化。甚至你在浏览器中的操作也可以自动化，使用一些工具，比如 Selenium，它可以移动鼠标并执行点击。我很确定在你典型的日常工作流程中有几个自动化的机会，你只需要发现它们。
2.开发时避免大量数据
这个我再举个例子解释一下。
您对新数据集进行探索性数据分析(称为 EDA)。这不是一个巨大的数据集，但却是一个相当大的数据集，比如说，大约有 1000 万行。在如此大的数据上，一些操作可能会非常慢。在 EDA 的过程中，你需要一次又一次地运行相同的代码片段——修复一些 bug 和错别字，调优一些参数，检查一些想法。如果每次运行只需要几秒钟，那么整个过程会非常慢。
您可以通过在开始时对整个数据集的某个随机子集进行采样来优化这一点。这个子集应该足够小，以允许代码快速运行，但也应该足够大，以代表全部数据。
只是要小心——如果你只抽取了很小一部分数据，那么就要避免对数据下结论。那就在这个阶段写一个无 bug 的代码吧。由于切换到完整版本的数据后，结论可能会发生变化。因此，如果采样数据部分足够大，效果会更好。“足够大”的确切含义可能因情况而异，但例如，大约 30-50 万行足够快，并且在大多数情况下仍然代表表格数据。
如果你使用 Pandas Python 库，那么sample函数可以帮你做到这一点。如下例所示，我们将包含完整数据的熊猫数据帧df_full采样为仅包含原始数据 20%的较小数据帧df_used:
df_used = df_full.sample(frac=0.2)
当您完成 EDA 并修复了所有错误后，现在可以将代码行从前面的示例切换到下面的示例:
#df_used = df_full.sample(frac=0.2)
df_used = df_full
现在，重新运行您的笔记本，只需等待一次，就可以在完整的大数据集上执行缓慢的操作。
这不仅适用于 EDA，也适用于涉及大数据规模的大多数任务，如训练模型、执行 SQL 查询等。首先，让它没有错误地工作，然后在完整数据上运行。
3.使用复制粘贴模板
也许有人告诉过你，复制粘贴总是不好的？如果是，不要相信他们——有些情况下，复制粘贴是最有效的做事方式。
考虑一个任务，比如绘制一些变量来呈现 EDA 结果。作为一名数据科学家，您很可能已经多次完成这样的任务。我用的是 Matplotlib Python 库。
下面给出了一些用 Matplotlib 在 Jupyter 笔记本中绘制两个数组值的简单示例代码，以供参考。
import matplotlib.pyplot as plt
plt.figure(figsize=(10,6))
plt.plot(df.index, df['value1'], label='Value 1')
plt.plot(df.index, df['value2'], label='Value 2')
plt.title('Results of my EDA')
plt.legend()
每次从头开始写所有这些行不是很有效率。即使过一段时间后，您将学会在不查看 Matplotlib 文档的情况下编写那些行和必要的参数，它仍然会很慢，并且会有引入一些错别字的风险。
另一方面，也不值得创建自己的自定义库函数作为 Matplotlib 函数的包装，因为您将需要许多不同的绘图，通常有轻微但重要的变化。因此，这种定制的包装器代码会增长得非常快，以支持所有需要的绘图变量，过一段时间后，您会发现自己要花很多时间来维护该包装器并修复其中的错误。
对于这种情况，有一个更好的解决方案——准备一个基本模板，您可以根据需要对其进行复制粘贴和编辑。包括关于最重要参数的注释，这样您就不需要每次都在文档中查找它们。
抄写文本比书写快。
我有一个*。txt* 文件，包含许多常用的代码片段模板(通常每个模板有 5-10 行)。用于绘制折线图、绘制饼图、应用宁滨将连续变量转换为分类变量等的模板。每当我需要一些常用的功能时，这让我节省了一些时间。
4.写你自己的 StackOverflow 式的笔记
你遇到过一些不平凡的任务吗？为了完成这项任务，你很可能不得不在 Google 上搜索信息，阅读工具文档，在 YouTube 上观看演示视频，或者做一些其他耗时的事情。当你经过几个小时的奋斗成功完成任务后，你会愉快地忘记它。有时…直到下一次你需要再次做完全相同的事情。
几年前，当我刚刚开始从事数据科学项目时，我必须安装 XGBoost 库，这是当时用于表格数据预测的最先进的库。在那时，在我的 Windows 上安装 XGBoost 确实是一项重要的任务，因为要获得最新版本，我必须从源代码中编译它。为了编译它，我必须先安装 Visual Studio。此外，我必须安装一些依赖项才能让一切正常工作。基本上，我花了整个晚上的时间从头开始设置一切。
在我的 XGBoost 在 Windows 上运行之后，我高兴地开始使用它…直到大约 4 个月后我的硬盘崩溃。然后，我花了几乎完全相同的时间再次安装它，因为我几乎不记得我到底做了什么让它工作。现在，这次我花了额外的 5 分钟来记下关键点、主要信息来源的链接以及最棘手部分的解决方案。
大约 6 个月后，我买了一台新的笔记本电脑，这为我节省了很多时间。然后当我咨询我的朋友在他的机器上安装 XGBoost 时。
每当你遇到一个不简单的棘手任务时，就值得考虑记下一些关于解决方案的简短笔记。因为有可能你将不得不再次做同样的事情。可以用简单的*。txt* 文件，一些应用程序的笔记或任何你喜欢的工具。我建议您保持在线访问，以防您可能需要从其他设备上查看它。
5.使长程序步骤独立
考虑一个典型的机器学习流水线。您读取一些输入数据，执行清理，转换数据，计算要素，训练模型，然后进行预测。比方说，你有一个程序，一个接一个地完成所有这些步骤。现在，您获得了一些额外的输入数据，并希望重新计算您的预测。这很简单——你只要运行你的程序，过一段时间它就会给你新的预测。
现在，让我们说，你想检查是否改变你的模型中的一些参数可以给你更好的准确性。你改变程序中的参数，重新运行程序，再次得到新的预测。但是等等——这一次您实际上不需要重新读取输入数据。所有的数据转换和特征计算也不是必须的。你只是想用新的参数重新训练模型。
因此，如果有可能从某个预定义的点重新运行程序，效率会更高。在这个特殊的例子中，只是模型训练和预测。
通过不必要的执行代码，你只是在浪费时间和电力。
这就是我非常喜欢使用 Jupyter 笔记本来完成数据科学任务的原因。它们内置了将整个程序分割成小步骤(单元)的支持。每个单元都可以独立执行。要记住的主要技巧是不要修改先前单元格中定义/计算的变量。否则，从中间的某个地方重新运行笔记本时，可能会导致错误的结果。
实际上，使用传统的 Python 脚本也可以实现类似的独立步骤，只需要一些额外的小工作。执行此操作的示例伪代码:
step = read_input_argument()
if step==0: #read and clean initial input data data = read_and_clean_data() save_to_disk(data, 'step1.csv')
if step<=1: #transform data
if step==1:
data = read_from_disk('step1.csv') data = transform(data) save_to_disk(data, 'step2.csv')
if step<=2: #calculate features
if step==2:
data = read_from_disk('step2.csv') data = get_features(data) ...
这样的程序接收step参数。如果它的值为 0，将执行整个程序。如果该值等于 1，程序将跳过清理输入数据，但将使用一个预先保存的临时文件与已经清理的数据。通过这种方式，您可以指定开始程序执行的步骤，从而节省大量时间，不必花费无数次清理和转换不需要的数据。
另外一个建议是保持足够大的步长。否则，您可能会遇到这样的情况:在每一步之后，写入/读取中间临时文件的成本都要高于在步骤中完成的实际工作的成本。
一些最后的话
不是所有的东西都适合每个人。所以，可能不是所有的建议都像对我一样对你有用。但希望你能得到一些改进工作方式的新想法。
请随意留下你关于节省时间和更有效做事的建议和技巧的评论。
效率高，事半功倍，给自己多留点时间！
感谢阅读！
节省成为职业棒球手的时间:轻松且免费
阿里·沙阿·拉哈尼在 Unsplash 上拍摄的照片
通过使用现成的 AWS SageMaker 笔记本
如果你熟悉大数据、云计算和机器学习的基础知识，并希望获得新的知识和经验，AWS SageMaker 及其现成的笔记本是一个不错的选择。
首先什么是 aws:
亚马逊网络服务(AWS)是世界上最全面、最广泛采用的云平台，从全球数据中心提供超过 175 种全功能服务。从计算、存储和数据库等基础设施技术到机器学习和人工智能、数据湖和分析以及物联网等新兴技术，AWS 的服务和这些服务中的功能远多于任何其他云提供商。这使得将您现有的应用程序迁移到云中变得更快、更容易、更具成本效益，并构建几乎任何您可以想象的东西。 *
其次，什么是 SageMaker:
亚马逊 SageMaker 是一个完全托管的机器学习服务。借助亚马逊 SageMaker，数据科学家和开发人员可以快速轻松地构建和训练机器学习模型，然后直接将其部署到生产就绪的托管环境中。它提供了一个集成的 Jupyter 创作笔记本实例，可以方便地访问您的数据源进行探索和分析，因此您不必管理服务器。它还提供了常见的机器学习算法，这些算法经过优化，可以针对分布式环境中的海量数据高效运行。 *
那么，我说的熟悉是什么意思呢？如果你能勾选以下所有方框，你应该很熟悉:
——你知道回归和分类的区别以及使用的领域。
-你听说过一些算法，比如 k 近邻、随机森林、极端梯度推进和主成分分析。你可以处理像 Keras，Tensorflow，PyTorch 或者 Chainer 这样的框架。
-你了解 AWS 的概念。
——你知道创造和使用 Jupyter 笔记本。
**准备好了吗？**好了，让我们直入主题，攀登 ML 阶梯:
众所周知，aws 是一家全方位服务的云提供商。当人们听到“云”这个词时，有些人可能只会想到存储和数据库解决方案。但这仅仅是开始。不幸的是，他们提供各种各样的服务。比如图像和物体识别、BI 和 CRM 工具、区块链网络或虚拟现实应用。
他们的大多数服务和工具都可以通过 API 或使用 aws 管理控制台来访问。
AWS 管理控制台的登录页面
**专业提示:**如果你是 AWS 新手，还没有账户，你可以免费获得一个。这还不够:有了 AWS 免费层，你还可以访问几乎所有的 AWS 服务。存储大小和计算时间有一些限制。即使是免费的，你也必须在注册时提供你的信用卡信息。最好是设定一个预算限额，这样就不会被收费。如果你是学生，那就更好了:你可以获得一个免费教程的 AWS 教育账户，预算 100 美元，而且不需要提供你的信用卡或银行账户。
1。开始
登录 AWS 管理控制台，在搜索框中输入 Sagemaker 并点击结果。
专业提示: AWS 有几个数据中心。如果您必须遵守特殊的治理政策，您可以选择适合您的区域。例如，如果您必须遵守 GDPR，您可以在五个 EU-地点之间进行选择。位置对网速也很重要。注意:目前只有 US-East-1 (N. Virginia)支持学生帐户。
支持的 aws 区域
单击左侧的笔记本实例，然后单击创建笔记本实例:
如何创建新的笔记本实例
**提示:**通过设置生命周期配置，您可以设置每次启动或创建笔记本时运行的默认脚本。通过使用这种方法，您的工作效率会更高，因为您不需要每次都指定经常使用的库、工具或存储位置。
SageMaker 生命周期配置
2。创建新笔记本时的选项
2.1。笔记本实例类型 Sagemaker 提供了广泛的实例类型选择，经过优化以适应不同的机器学习(ML)用例。他们做工作的方式不同。通过混合使用 CPU、GPU、内存和网络容量。选择正确的实例类型取决于您。甚至可以动态地更改实例类型。如果你的项目变得越来越大，你就可以把资源变得越来越大。
实例示例
举例:
ml.t2.medium =机器学习标准二代中等大小
ml.r5.2xlarge =机器学习内存优化第五代超大
2.2。弹性推断
为了加快你的学习进度，你可以选择 GPU 驱动的实例类型。另一方面，GPU 驱动的实例比 CPU 或 RAM 驱动的实例更昂贵。但是对于实时操作来说，它们的延迟通常太高。如果你不想妥协，你应该看看弹性推理。弹性推理允许您将适量的 GPU 驱动的推理加速附加到 Sagemaker 模型上。为您的应用选择最佳的 CPU 实例类型，附加适量的 GPU 加速，获得两全其美。
2.3。权限和加密
IAM 代表身份和访问管理。IAM 是一项服务，可以帮助您安全地控制对 AWS 资源的访问。您使用 IAM 来控制谁被验证(登录)和授权(有权限)使用资源。
注册您的第一个帐户时，您将拥有一个全访问单点登录帐户(也称为 root 用户)。AWS 强烈建议不要使用 root 用户执行日常任务，甚至是管理任务。相反，您应该从单个 IAM 角色开始。你也可以加密你的笔记本。更多细节请看 AWS 文档。
权限和加密
2.4。可选定制
亚马逊虚拟私有云(亚马逊 VPC)使您能够将 AWS 资源启动到您定义的虚拟网络中。这个虚拟网络非常类似于您在自己的数据中心运行的传统网络，具有使用 AWS 的可扩展基础架构的优势。
可选定制
将 Git 存储库与您的 notebook 实例相关联，以便在源代码控制环境中保存您的笔记本，即使您停止或删除您的 notebook 实例，该环境也会持续存在。您可以将一个默认存储库和最多三个附加存储库与一个笔记本实例相关联。存储库可以托管在 AWS CodeCommit、GitHub 或任何其他 Git 服务器上。它有助于坚持、合作或学习。
2.5。完了！
如果您完成了参数设置，您可以点击创建笔记本实例。如果您的笔记本处于活动状态，可能需要一段时间。通常几分钟。休息一下，喝杯咖啡，为下一步做准备。
3。启动你的笔记本
当您的笔记本处于使用状态时，您可以使用 Jupyter 或 JupyterLab 启动它。在这个演示中，我们使用常规 Jupyter。
亲提示: 离开时一定要把笔记本停好。即使没有模型，也有成本。
笔记本正在使用中
然后点击 SageMaker 示例
SageMaker 笔记本列表
正如你在上面的图片中看到的，有大量不同的例子。它们按主题分组。每个话题都是可扩展的。选择一个最符合你需求的。由于我们正在使用大数据和机器学习，我们选择:“使用 XGBoost 的客户流失预测-
使用梯度提升树来预测移动客户离开”。点击使用，笔记本启动。
机器学习笔记本
笔记本讲的是什么: 笔记本描述了使用机器学习(ML)来自动识别不开心的客户，也称为客户流失预测。失去客户对任何企业来说都是代价高昂的。尽早发现不满意的客户，让你有机会激励他们留下来。
关于使用 XGBoost 进行客户流失预测的 SageMaker 笔记本
现成的笔记本带你经历一个典型的 ML 循环的每一步。这是一个公共数据集，所以很容易按照说明。现在，您可以看到并学习如何使用 XGBoost 算法来构建、训练和学习。玩得开心，享受吧！
专业提示:
为了最大限度地利用本教程并获得完整的理解，阅读一下关于 AWS S3 会很有好处。
当停止或完成工作时，请始终记住移除托管端点并避免被收费。
本笔记本展示了如何使用 aws 现成的 SageMaker jupyter 笔记本来增加您的 ML 知识！我希望你喜欢它。如果您有任何问题或建议，请随时使用下面的评论功能。敬请关注更新！
拯救之旅:动力、深度参与和动态细分市场
我们再看一眼 Jupiter 的早期数据，对用户进行细分，并试图预测是什么让一个人从低倾向储蓄者变成高倾向储蓄者
版权所有木星储蓄。知识共享署名 4.0 国际许可。
合成:
- 应用程序参与度、储蓄势头和奖励能够以约 90%的准确率预测储蓄者的细分动态。
- 储蓄者抵制简单的分类，但是关注他们的旅程，而不是他们的静态点，导致可以采取行动的结构和意义。
- 关于固有用户特征或“大数据”的毫无根据的先验可能是无益的，尤其是在早期应用数据科学时。
寻找既健壮又有用的片段
在之前的一篇文章中，我们看了一下 Jupiter 关于促使用户存更多钱的数据。在这一期节目中，我们将着眼于木星首批约 1000 名储户的总体行为，或者说细分和聚类。
第一步是传统的“RFM”细分——“新近度”(某人最近储蓄了多久)、“频率”(他们储蓄的频率)，以及“货币量”(他们的余额是多少)。
我们将所有储蓄者分成四分之一，然后组合标签，因此“111”意味着“前四分之一最近，前四分之一频率，前四分之一货币”，等等。通常当你这样做的时候，一个或两个部分会占主导地位(如果事情进展顺利，111；如果你遇到麻烦，444)。这是我们的情节:
标准分割技术中的高度异质性
至少我们最大的细分市场是 111，但这是一个很大的分散。我们可以将 111 和 112 归类为“频繁，高价值”，然后将 443 和 442 归类为“不频繁，低价值”，但这最多只能吸引 30%的用户。
储户不会落入一个漂亮的桶或几个角色
在这之后，我们吵了很久。我们添加了行为数据并运行了一系列分析( K-Means 、 HDBScan 、 t-SNE 等)。大多数出现了和 RFM 一样的结果——大量的分散，没有直观的结构。不过，最终我们结合了两种方法，并开始取得进展:
(1)应用主成分分析( PCA )来找到用户事件流中变化的主要来源。我们可以通过他们打开 Jupiter 应用程序和参与“片段”(应用程序内的金融知识片段)的频率、以及他们保存和赎回 boost 的频率来解释用户之间的差异。交叉相关性加强了这一发现。参与是一个有意义的变化轴。
(2)将储蓄者分为每月储蓄一次以上的储蓄者和储蓄一次或一次以下的储蓄者，合并每个用户的事件计数，并在每个较大的池中运行聚类算法(HDBScan)。这种划分使我们能够在两个池中的每个池中找到仅 2-3 个聚类点的良好匹配，总共有五个细分市场。
当重新结合在一起并根据余额记录绘制时，我们最终找到了一种聚类方法，这种方法既代表了高维行为数据，又显示了值的清晰级数。这五个部分来自数据，而不是我们的先验，所以我们不能给它们起一个可爱的名字，但是我们可以开始问一些关于它们的好问题。
储蓄者按储蓄和余额的频率绘制，按价值分类着色
使用丰富的数据使分段动态化
细分只有在导致行动时才有用。所以我们问，我们能不能找到过去储户行为的一个方面，来预测他们现在属于哪一类？从那以后，我们的哪一个杠杆将最有效地影响这种行为，从而将储户转移到更有价值的细分市场？
首先，我们运行了各种模型，使用每个用户的事件计数作为输入特征，并将他们的最终细分作为目标标签。不幸的是，没有一个模型的精度远远超过 0.5——这是抛硬币的结果。考虑到一个内部结构复杂的小数据集，这并不奇怪。
但在这里，拥有一个丰富的数据集，构建和结构化，以方便流畅地进行这些分析，变得非常宝贵。对于我们来说，储蓄器的每个方面——事件、余额、行为——都是一系列实时事件的集合。通过一点跑腿工作，我们可以滑动分段和事件几乎任意地沿着时间线计数。
从 6 月初到 9 月底，我们使用这种能力在 3.5 个月的时间内每 3 天收集一次数据。这让我们从几百个数据点增加到接近 15000。
当我们把自己局限在单一时间点的问题上时，我们的模型仍然没有得到很大的提升，“我们能预测用户当前的细分市场吗？”这在某种程度上并不令人惊讶。如果数据增加接近重复，那么数据增加的帮助要比“大数据”的天真想法小得多。关于静态横截面结构的问题，仅移动横截面就非常接近于复制(参见下面的投影图)。
有限数据与增强数据的 t-SNE 图:二维空间已经填满，但没有清晰的结构出现
所以我们改变了问题，变成了关于在时间上的进化，一个更有价值也更容易处理的问题。
我们问:什么能预测储户是否会在下个月“升级”他们的细分市场？ **从一个关于用户在哪里的问题，我们产生了一个关于用户要去哪里的问题。**在我们扩展的数据集中，每次我们都要向前看一个月，并检查用户群的变化。基本面数据点成了储户旅程中的一个阶段。
这并没有使扩增完全没有损失，但确实使它明显更好。对于理解静止的你这个问题，今天的你和一个月前的你或多或少是一样的；对于理解你的储蓄习惯是如何演变的问题，今天的你和一个月前的你有很大的不同，足以找到额外的意义。
参与+推动价值增长的动力
证据就在布丁中——模型度量。根据我们增加的数据，我们运行模型来预测某一天的某个特定储户，在当时对他们的一切都了解的情况下，是否会在下个月增加一个细分市场。仅使用简单的模型，准确率立即跃升至 70%，具有良好的假阳性/假阴性率。
由于数据集相当平衡，我们决定引入一些重型机器，并将数据输入谷歌云的 AutoML。它拟合了一个相当复杂的梯度增强树，并达到了 90%的准确度。我们担心标签泄露，但是交叉相关性、训练曲线和特征重要性分数都让我们放心了。
那么哪些特性最重要呢？
第一，气势。最重要的两个特征(25%和 15%)是储蓄者的余额四分位数和最近四分位数。因此，能够存很多钱(按原始金额计算)确实很重要——如果不重要的话，坦率地说，这很可疑——但这只能解释一个人晋升的可能性的四分之一。紧随其后的是近期。将这些放在一起作为对“动力”的粗略衡量，可以解释储户未来 40%的动力。
二、订婚，尤其是深度订婚。下一个重要的特性是用户打开应用程序的频率。然后——这让我们吃惊——用户查看应用内信息存档的频率。紧接着是**用户点击屏幕中央的金融知识“金块”**的频率。
这些可以解释为用户不只是打开应用程序，而是觉得有理由去探索它。每一个都占总特征重要性的 10%。当结合其他一些相关功能(如共享推荐代码或探索“拯救伙伴”)时，深度参与总共解释了另外 30%的变化。
最后，情感奖励和储蓄习惯。与我们前一篇文章中的发现相呼应，用户存钱的频率和他们是否已经兑现了一次提升占了另外 15%的特征重要性。最后的 10%分散在一系列其他功能中。
最终模型中的特征聚类和重要性
如何防止储户将下移到价值段？动力和参与因素同样重要。但是他们加入了出站通信。也就是说，如果我们最近给用户发了信息或让他们提高报价，用户就不太可能降级(通过退出或进入休眠状态)，即使他们没有深度参与应用程序。这是一种解脱，因为我们曾经想知道，打扰人们，或者只是过于频繁地提醒他们有这个储蓄罐，有时会导致提款。注意:并不是说我们认为这是垃圾邮件的许可证。
结论:使用(或不使用)旧的心智模型和大数据与丰富数据
总的来说我们能说什么？首先，我们第一篇文章中的发现得到了一些强化——行为是可塑的，情感和参与很重要，不仅仅是消费应用，也不仅仅是交易和加密。
还有另外两个更广泛的观点。有时我们会惊讶地经常被问到，“你的目标人群是什么？”一方面，如果只是最初的捷径，这是一个可以理解的问题。在某种程度上，年龄会对储蓄产生影响——职业道路只是让可用于储蓄的收入和不同年龄的储蓄压力有所不同。
但是仔细观察，这个问题可能代表一个没有根据的先验。更糟糕的是，这可能是一条糟糕的捷径。讽刺地说:如果你能在年龄和性别上做一个 Excel 支点，并认为它是连贯的，为什么要试图理解储蓄者行为的细微差别？过分简单的数据工具导致过分简单的想法，这些想法成为主导未来分析的先验知识。
我们有木星拯救者的年龄数据。我们还没有发现它能有效地解释储蓄者的行为。我们不需要它来达到预测节段运动 90%的准确性，或诱导反应率 70%以上的准确性，或在抵制任何简单分割的数据中寻找意义。
如果人口统计学很重要，他们会以结构的形式出现——所以只需要寻找结构。如果他们不这样做，他们就是一种虚假的一致性，是由简单的工具或大而有限的数据造成的。
一个相关的注释是关于如何判断数据。其他都等于，数据越多越好(好得多)。但是其他的几乎都不等于。
我们 Jupiter 团队中的一些人使用新的纯数字银行(“neobanks”)。今年搬家国的时候开的账户(非常【2020 年初)。我用它作为我的主要银行账户。仅仅是交易数量就足以说明这一点。但是这个应用程序一直在使用宝贵的屏幕空间来帮助我“迁移到我们这里作为你的主要账户”。鉴于我交易的参考，它还不断为我提供我显然已经拥有的产品和服务的折扣。
这个 neobank 拥有 500 多万用户，因此它拥有“大数据”，但这些数据要么非常差，要么使用非常糟糕，要么两者兼而有之，因此这些数据不会比他们拥有 50 个数据点更有实际用途。
因此，这将是我们一段时间内的最后一次数据发布。我们希望这篇文章和上一篇文章能让我们更好地了解我们正在构建的东西。希望他们也清楚地表明了丰富的数据可以做多少事情，即使是在早期——只要你抛开过去，充分利用现代数据方法的力量。
最重要的是，我们希望他们已经表明，一些关于储蓄的旧观念——都是关于违约的，你不能让它变得有趣，只是减少摩擦，等等——至少对严肃的问题是开放的。即使这给我们带来了竞争，我们也希望其他人将很快超越已经厌倦的现代金融科技储蓄工具包(这里一个目标，那里一个总结)，更接近理解储户的行为，并帮助他们改变这种行为。
使用 AWS Lambda 进行 scikit-learn 预测可节省 95%的基础设施成本
用于实时机器学习推理的 AWS Lambda 与 AWS SageMaker
声明:我是 模型动物园 的开发者，一个专注于易用性的模型部署平台。
在 https://modelzoo.dev/lambda-vs-sagemaker-cost/试用我们的工具
如果你是一个需要部署机器学习模型进行实时推理的 AWS 客户，你可能会考虑使用 AWS SageMaker 推理端点。然而，模型部署还有一个选项，这个选项有时会被忽略:直接在 **AWS Lambda 上部署。**虽然它有一些警告，但是 Lambda 的简单性和成本效益使得它值得考虑 SageMaker 端点用于模型部署，特别是当使用 scikit-learn 、 xgboost 或 spaCy 时。在本文中，我们将回顾使用 AWS Lambda 进行 ML 推理的一些好处和注意事项，并深入一些相关的基准测试。我们表明，在低使用率的情况下(每月< 2M 预测)，当将模型从 SageMaker 迁移到 Lambda 时，您可以节省高达 95%的基础设施成本。我们还将展示 scikit-learn-lambda ，这是我们的开源工具包，用于在 AWS Lambda 上轻松部署 scikit-learn。
什么是 AWS SageMaker 推理端点？
通过 SageMaker 端点进行实时 ML 推理的 AWS 基础设施图
SageMaker 推理端点是 AWS 提供的令人印象深刻的端到端机器学习工具包的许多部分之一，从数据标记( AWS SageMaker 地面真相)到模型监控( AWS SageMaker 模型监控器)。SageMaker 推理端点提供了围绕 GPU 加速、自动缩放、AB 测试、与培训管道集成以及与离线评分集成的功能( AWS 批量转换)。这些特性的代价很高——最便宜的推断端点(ml.t2.medium)将花费您**$ 50/月来运行 24/7。下一个最佳终点(ml.t2.xlarge)是$ 189.65/月**。
什么是 AWS Lambda？
AWS Lambda 是一个通用的无服务器计算平台
AWS Lambda 是无服务器计算运动的先驱，让您无需提供或管理服务器即可运行任意功能。它只在需要的时候执行你的代码，并且自动伸缩，从每天几个请求到每秒几百个请求。Lambda 是一个通用的函数执行引擎，没有任何机器学习的特定功能。它激发了一个不断增长的工具社区，一些来自 AWS 本身(无服务器应用模型)和一些外部附属的(无服务器框架)。
AWS Lambda 对实时机器学习推理的好处
- Lambda 有一个按请求付费模式，可以随着你的成长而扩展。这是赞成还是反对取决于你的使用水平，但特别是成本效益服务在 2M 预测每月。在撰写本文时，SageMaker 不支持在低活动期自动调整到零。
- Lambda 需要一个更简单的实现计算模型，其中并发/自动伸缩可以在逻辑之外透明地处理。
- Lambda 要求降低 维护工作量，无需管理任何底层服务器或逻辑。
- Lambda 有一个丰富的开发者生态系统(开源和 SaaS)，用于监控、记录和测试无服务器应用，比如无服务器应用。有了 SageMaker，你就依赖于 AWS 特有的资源，比如用于工具的 SageMaker 兼容容器和 SageMaker Python SDK 。
AWS Lambda 用于实时机器学习推理的缺点
导致冷启动延迟的请求生命周期。
- Lambda 对可用资源有限制，最大 3，008 MB 物理内存和不支持 GPU 加速。对于使用具有严格延迟要求的大型模型的基础架构来说，这可能是一个障碍。
- 当在 5-10 分钟的不活动期后调用该函数时，Lambda 会导致冷启动延迟。AWS Lambda上的冷启动是一篇很棒的博文，深入探讨了影响冷启动延迟的一些因素。
- AWS Lambda 中的包大小限制非常严格，压缩后为 50 MB，解压缩后为 250 MB。有变通办法( AWS Lambda Layers )，但是这对于捆绑常见的 ML 依赖项(如 TensorFlow (~400 MB)和 PyTorch (~250 MB)来说可能是一个恼人的障碍。
- Lambda 不能直接使用 Docker 容器作为依赖，而是有自己的依赖管理系统 AWS Lambda Layers 。这有时需要用户在打包时做一点额外的工作。
案例研究:scikit-learn
pharm assesse是一个模型动物园用户，其任务是更自信、更高效地治疗更多患者。他们开发了一个专有模型，可以使用 scikit-learn 自动进行小病评估、诊断和治疗&文档，现在正在与一组初始用户一起测试它。他们的模型大小约为 50 MB，是 Lambda 部署的理想选择。
设置
通过 Model Zoo，PharmAssess 能够使用简单的 Python API 部署其 scikit-learn 模型。在幕后，Model Zoo 将把 scikit-learn 模型打包并部署到 AWS Lambda 函数中(参见我们的 quickstart 获取完整示例)。
import modelzoo.sklearnmodel = ... # train model
modelzoo.sklearn.deploy(model)
如果您喜欢维护自己的模型存储、部署和监控堆栈，您可以使用我们的开源包 scikit-learn-lambda 通过无服务器框架将模型部署到您自己的 AWS 云上:
$ git clone [https://github.com/model-zoo/scikit-learn-lambda](https://github.com/model-zoo/scikit-learn-lambda)
$ cd scikit-learn-lambda
$ cp <model file> scikit-learn-lambda/model.joblib
$ serverless deploy
延迟基准
AWS Lambda 的一个重要警告是“冷启动”，即在 5-10 分钟不活动后发生的初始化开销。为了了解严重性，我们生成了具有三个隐藏层的 MLPClassifier 模型，每个隐藏层使用 100、250、500、750 和 900 的层大小。每个模型都在 iris 数据集上训练，并使用 joblib 库序列化到磁盘。这导致模型文件的大小分别为 0.68 MB、4.08 MB、16.17 MB、36.25 MB 和 52.13 MB。我们使用 scikit-learn-lambda 将每一个部署到具有 1024 MB 内存的 lambda 函数，并测量三个样本的平均冷启动延迟，以生成上面的基准。
我们还在下面绘制了十五个样本的平均“热”延迟，每个模型的平均延迟在 2-5 毫秒左右。
有一些解决冷启动延迟的方法，比如每隔几分钟就触发你的函数来保持它的热度或者使用提供的并发。但是，如果针对 p90+延迟进行优化是一项重要的业务需求，那么无服务器模式可能不适合您的使用案例。
成本基准
AWS Lambda 的使用情况很难结合每个请求的时间、内存使用情况和每月的总请求量来衡量。我们创建了这种交互式可视化，以帮助我们了解各种使用场景下的每月成本，以 SageMaker 端点为基准。
[## AWS Lambda 与 AWS SageMaker 成本计算器
modelzoo.dev](https://modelzoo.dev/lambda-vs-sagemaker-cost/)
成本差异不言自明:使用上面观察到的平均热延迟和 1024 MB 的分配内存，Lambda 比来自最低成本层的单个 SageMaker 端点便宜一个数量级。按请求付费的模型也使其非常适合 AB 测试和原型开发——您可以部署您训练的每一个模型，而不必担心利用不足。
TL；dr:什么时候应该使用 AWS Lambda？
一般来说，AWS Lambda 对较小的模型(<50MB) that can use CPUs for inference and for which you expect a usage pattern of <2M requests/month. This makes it ideal for building 原型或新产品有意义，它们使用轻量级模型库【2】，如 scikit-learn 、 xgboost 或 spaCy 。
使用 JSON 和 YAML 文件保存和加载 Keras 模型
使用 JSON 和 YAML 文件保存和加载深度学习模型的快速简单的方法
维克托·弗雷塔斯在 Unsplash 上的照片
你如何与在世界不同地方工作的其他团队成员分享你训练的深度学习模型，或者如何在训练期间或之后保存深度学习模型及其训练的权重，或者如何从你停止的地方恢复模型的训练？
要回答以上问题我们需要保存一下
- 模型建筑
- 模型的训练权重或参数
共享保存的文件将允许其他人重新创建模型来进行推理或从您停止的地方继续进一步的训练。可以通过加载模型来重新创建模型，并从包含模型架构和预训练权重的保存文件中训练权重。
使用不同的方法来保存和加载深度学习模型
- JSON 文件
- YAML 档案
- 检查点
在本文中，您将学习如何将 Keras 开发的深度学习模型保存为 JSON 或 YAML 文件格式，然后重新加载该模型。
为了保存模型，我们首先创建一个基本的深度学习模型。我使用了时尚 MNIST 数据集，我们用它来保存，然后用不同的方法重新加载模型。
我们需要安装两个库:**pyyaml and h5py**
**pip install pyyaml
pip install h5py**
我用的是 Tensorflow 1.14.0
#Importing required libararies
**import os
import tensorflow as tf
from tensorflow import keras**#Loading Fashion MNIST dataset
**(train_images, train_labels), (test_images, test_labels) = tf.keras.datasets.fashion_mnist.load_data()**#creating a smaller dataset
**train_labels = train_labels[:1000]
test_labels = test_labels[:1000]**#Normalizing the dataset
**train_images = train_images[:1000].astype('float32') / 255
test_images = test_images[:1000].astype('float32') / 255**# Reshaping the data for inputing into the model
**train_images = train_images.reshape((train_images.shape[0], 28, 28,1))
test_images = test_images.reshape((test_images.shape[0], 28, 28,1))**#Defining and compiling the keras model
**def create_model():
model = tf.keras.Sequential()
# Must define the input shape in the first layer of the neural network
model.add(tf.keras.layers.Conv2D(filters=64, kernel_size=2, padding='same', activation='relu', input_shape=(28,28,1)))
model.add(tf.keras.layers.MaxPooling2D(pool_size=2))
model.add(tf.keras.layers.Dropout(0.3))
model.add(tf.keras.layers.Conv2D(filters=32, kernel_size=2, padding='same', activation='relu'))
model.add(tf.keras.layers.MaxPooling2D(pool_size=2))
model.add(tf.keras.layers.Dropout(0.3))
model.add(tf.keras.layers.Flatten())
model.add(tf.keras.layers.Dense(256, activation='relu'))
model.add(tf.keras.layers.Dropout(0.5))
model.add(tf.keras.layers.Dense(10, activation='softmax'))** #Compiling the model **model.compile(loss='sparse_categorical_crossentropy',
optimizer='adam',
metrics=['accuracy'])
return model**# Create a basic model instance
**model = create_model()****model.summary()**
使用 JSON 文件保存和加载模型架构
将模型保存和加载到 JSON 文件的步骤
- 将训练数据拟合到模型中
- 使用 to_json() 将模型架构保存到 JSON 文件中。返回的字符串将保存在一个 JSON 文件中
- 使用 save_weights() 保存训练好的重量
- 通过读取 JSON 文件从 JSON 文件中重新加载模型架构，然后使用 model_from_json() 将模型架构重新加载到新模型中
- 将使用 load_weights() 重新加载已训练的重量
将列车数据拟合到模型中
#Fit the train data to the model **model.fit(train_images,
train_labels,
batch_size=64,
epochs=100,
validation_data=(test_images,test_labels))**
将模型架构和权重保存到 JSON 文件
使用 to_json() 将模型架构写入 JSON 文件，并使用***save _ weights()***保存训练好的模型的权重
**from keras.models import model_from_json**# serialize model to json
**json_model = model.to_json()**#save the model architecture to JSON file
**with open('fashionmnist_model.json', 'w') as json_file:
json_file.write(json_model)**#saving the weights of the model
**model.save_weights('FashionMNIST_weights.h5')**#Model loss and accuracy
**loss,acc = model.evaluate(test_images, test_labels, verbose=2)**
原始模型的损失和准确性
将模型架构从 JSON 文件重新加载到新模型
我们已经创建了一个新的模型: model_j ，它将与保存的模型具有相同的架构
我添加了 glorot_uniform 库，因为我得到了初始化器的警告
**from keras.initializers import glorot_uniform**
#Reading the model from JSON file
**with open('fashionmnist_model.json', 'r') as json_file:
json_savedModel= json_file.read()**#load the model architecture
**model_j = tf.keras.models.model_from_json(json_savedModel)
model_j.summary()**
新模型与先前保存的模型具有相同的架构
将训练好的重量重新加载到新模型中
使用 load_weights() 将预训练的权重加载到新模型中
**model_j.load_weights('FashionMNIST_weights.h5')**
只有模型架构和预训练的权重被加载到新模型中，但是缺少模型编译细节，所以我们需要编译模型。
我们可以指定不同的优化器来编译模型，比如将优化器从 Adam 改为“Rmsprop”或“SGD”
#Compiling the model
**model_j.compile(loss='sparse_categorical_crossentropy',
optimizer='SGD',
metrics=['accuracy'])**
我们可以检查新模型的损失和准确性，以确认是否加载了相同的训练重量
loss,acc = model_j.evaluate(test_images, test_labels, verbose=2)
使用 JSON 文件的新模型的测试数据的模型损失和准确性
使用 YAML 文件保存和加载模型架构
将模型保存和加载到 YAML 文件的步骤
- 将训练数据拟合到模型中
- 使用 to_yaml() 将模型架构保存到 YAML 文件中。返回的字符串将保存在 YAML 文件中
- 使用 save()将训练好的重量保存在 H5 文件中。
- 通过读取 YAML 文件从 YAML 文件中重新加载模型架构，然后使用 model_from_yaml() 将模型架构重新加载到新模型中
- 使用 save() 保存训练后的重量，并使用 load_model() 加载到新模型中
我们将使用之前的模型保存到 YAML 文件。我们不会再次拟合该模型，因为它已经被训练过了。
将模型架构保存到 YAML 文件
使用 to_yaml() 将模型架构写入 YAML 文件
#saving the model to a YAML file
**yaml_model= model.to_yaml()**# writing the yaml model to the yaml file
**with open('fashionmnist_yamlmodel.yaml', 'w') as yaml_file:
yaml_file.write(yaml_model)**
将模型架构从 YAML 文件重新加载到新模型
从 YAML 中读取模型架构，并使用***model _ from _ YAML()***将其恢复为新模型 model_y
我们得到了与原始模型相同的模型架构
**#Read the model architecture from YAML file**
**with open('fashionmnist_yamlmodel.yaml', 'r') as yaml_file:
yaml_savedModel=yaml_file.read()**# Load the saved Yaml model
**from keras.models import model_from_yaml
model_y= tf.keras.models.model_from_yaml(yaml_savedModel)
model_y.summary()**
**使用 HDF5 格式的*Save()***将权重保存在单个文件/文件夹中
- 模型的架构，以便我们可以随时随地重新创建它
- 模型的训练权重
- 训练配置如损失函数、优化器等。
- 优化器的状态
Save()有助于导出模型并重新创建整个模型，或者从您离开的地方继续训练。
可以使用 load_model()、 恢复模型，这也负责使用保存的训练配置编译模型。
#saving the smodel's architecture, weights, and training configuration in a single file/folder.**model.save('fashionmnist.h5')**
恢复模型
# loading the model from the HDF5 file
**model_h5 = tf.keras.models.load_model('fashionmnist.h5')**
让我们在测试图像上评估新恢复的模型。注意，我们在这里没有编译模型
**loss,acc = model_h5.evaluate(test_images, test_labels, verbose=2)**
使用 YAML 文件的新模型的测试数据的模型损失和准确性
我们得到大致相同的损失和精度，因为我们没有在这里设置种子。
结论:
我们现在可以保存权重，并使用 JSON 文件或 YAML 文件将它们重新加载到一个新的模型中，这将允许您与世界分享您出色的深度学习工作，或恢复您的训练以获得更好的表现。
使用检查点保存和加载模型将在下一篇文章中讨论
参考资料:
[## 保存和加载模型| TensorFlow 核心
您看到了如何将权重加载到模型中。手动保存它们与模型一样简单
www.tensorflow.org](https://www.tensorflow.org/tutorials/keras/save_and_load)
https://keras . io/getting-started/FAQ/# how-can-I-save-a-keras-model
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
