包含真实项目的端到端 OptimalFlow 自动化机器学习教程
公式 E Laps 预测—第 2 部分
在本教程的上一篇 第 1 部分 中，我们讨论了如何实施数据工程以准备合适的数据集，从而提供进一步的建模步骤。而现在我们将重点讨论如何使用 OptimalFlow 库( 文档||GitHub)来实现 Omni-ensemble 自动化机器学习。
为什么我们使用 OptimalFlow ？你可以阅读另一个关于它的介绍的故事:一个全方位的自动化机器学习——optimal flow。
步骤 1:安装 OptimalFlow
用 Python 3.7+设置好自己的工作环境，通过Pip 命令安装 OptimalFlow 。目前，最新版本是 0.1.7。更多包的信息可以在 PyPI 找到。
pip install OptimalFlow
步骤 2:仔细检查缺失值
在本教程第 1 部分的数据准备之后，大多数特性都准备好了，可以进入建模过程。当数据流到达autoPP(optimal flow 的 自动特征预处理模块)时，类别特征中的缺失值不受欢迎。因此，我们需要仔细检查清理后的数据，并对缺失值的要素进行数据清理。对于这个问题，我只发现’组’功能有丢失的值，并使用以下代码来转换它。
步骤 3:自定义设置
OptimalFlow 提供开放接口，供用户在各个模块中进行自定义设置。甚至在autoCV(optimal flow的模型选择&评估模块)中，您也可以自定义设置具体的模型或超参数搜索空间。你可以在 文档 中找到更多细节。
如下面的代码，我们为autoPP(optimal flow的 auto feature 预处理模块)设置了缩放器和编码器算法； autoFS 的选择器( OptimalFlow 的自动特征选择模块)；估算器为autoCV模块。
对于特征选择和模型选择，我们建立了选择器和估计器搜索空间。
请注意:“稀疏度”和“列数”是您可以设置的两个限制，以减少数据集组合的数量。通常，当数据集的稀疏度太低时，特征内的方差将很低，这意味着信息值将很低。根据可接受的数据集数量，您可以尝试这两个参数的不同值设置，这些数据集将通过管道簇遍历实验(PCTE)过程来找到其管道工作流的最佳模型。当然，从 autoPP 模块生成的数据集组合越多，在 OptimalFlow 自动机器学习中进一步处理需要的时间就越多。反之，当没有满足稀疏性和列数限制的数据集组合时，后续过程无法继续。所以，要小心，用这些设置尝试一些值。
步骤 4:管道集群遍历实验(PCTE)
optimal flow中的核心概念/改进是流水线簇遍历实验(PCTE) ，这是 Tony Dong 在 Genpact 2020 GVector 大会上首次提出的一种框架理论，利用系综流水线算法优化和自动化机器学习工作流。**
与使用单个流水线的其他自动化或经典机器学习工作流的重复实验相比，流水线簇遍历实验更强大，因为它通过集合所有可能的流水线(流水线簇)和自动化实验将工作流从 1 维扩展到 2 维。凭借更大的覆盖范围，在没有人工干预的情况下找到最佳模型，并且由于其在每个组件中的系综设计而更加灵活地处理不可见的数据，管道簇遍历实验为数据科学家提供了一种更方便和“全自动”的机器学习方法。
为了实现 PCTE 过程， OptimalFlow 提供了 autoPipe 模块来实现。更多示例和功能详情可在文档中找到。
下面是我们在 自动管道 模块中设置的属性:
- 对于 autoPP 模块:给它我们上面设置的自定义参数；设置预测列为“Total_Lap_Num”，选择 model_type 为“regression”(防止哑变量陷阱)；
- 对于拆分规则:设置 20%验证，20%测试，60%训练数据；
- 对于 autoFS 模块:设置 10 个顶级特性，5 个交叉验证文件夹；
- 对于 autoCV 模块:使用快速回归器类，5 个交叉验证文件夹。
下面是这个自动化过程的简单描述:
- 基于我们之前的自定义设置， autoPP 模块将生成总共#256 个数据集组合(基于我们自定义的稀疏度和列限制设置)。我们的 PCTE 进程将会经历所有这些。它将使用 autoFS 模块自动选择前 10 个功能。并使用调整后的超参数搜索最佳模型，最终在 流水线簇 内找到具有流水线工作流的最佳模型。
你会在自动生成的日志文件中找到 PCTE 进程的所有日志信息，这些日志文件是由 OptimalFlow 的 autoFlow 模块创建的。
****
模块自动生成的日志文件
PCTE 过程几乎涵盖了数据科学家需要涵盖的所有机器学习步骤，并通过其管道工作流信息自动搜索最佳模型，以便于评估和实施。
虽然 PCTE 不会为每个机器学习流水线操作节省时间，但当 OptimalFlow 为时，数据科学家可以转移到其他任务，帮助他们摆脱繁琐的模型实验和调整工作。
这是我所理解的真正的自动化机器学习过程。OptimalFlow 应该自动完成所有这些任务。
流水线簇遍历实验 (PCTE)过程的输出包括应用于准备好的数据集组合的预处理算法的信息(DICT_PREP_INFO)、为每个数据集组合选择的顶部特征(DICT_FEATURE_SELECTION_INFO)、模型评估结果(DICT_MODELS_EVALUATION)、分割数据集组合(DICT_DATA)、模型选择结果排序表(models_summary)。
这对于数据科学家来说是一个有用的功能，因为当他们想要重用以前的输出时，检索以前的机器学习工作流是很痛苦的。
步骤 5:用最佳模型保存管道群
由于当有大量数据集组合作为输入时，PCTE 过程将持续很长时间，我们最好将上一步的输出(管道集群最优模型)保存为 pickles，用于结果解释和可视化步骤。
步骤 6:建模结果解释
下一步，我们将通过导入上一步中保存的 pickles 来查看我们的建模结果。我们可以使用下面的代码找到 PCTE 自动化流程后具有最佳流程的前 3 个模型:
很明显，具有可调超参数的 KNN 算法性能最好。我们可以从 PCTE 的输出中检索整个管道工作流程。
具体来说:
最佳流水线由 KNN 算法组成，该算法使用 256 个数据集组合中的数据集 _214、数据集 _230，具有最佳参数[(‘权重’: ‘距离’)，(’ n _ 邻居’:’ 5 ‘)，(‘算法’:’ kd_tree’)]。R 平方是 0.971，MAE 是 1.157，MSE 是 5.928，RMSE 是 5.928，延迟分数是 3.0。
所有 256 个数据集的流水线性能评估结果都可以通过 autoViz 模块的动态表函数生成(更多细节和其他已有的可视化示例可以在这里找到)，你可以在找到。/temp-plot . html
由 autoFS 模块选择的前 10 个特性是:
特征预处理细节到 Dataset_214，Dataset_230:具有前 10%和后 10%离群值的 Winsorization 通过平均编码方法对“匹配名称”和“仅日期”特征进行编码；通过 OneHot 编码方法对“组”特征进行编码；预处理步骤中不涉及缩放器。
仅此而已。我们做了第一个 OptimalFlow 自动化机器学习项目。简单容易，对吧？😎
*更多的事情需要考虑:
我们模型的顶部管道具有非常高的 R 平方值，超过 0.9。对于大多数物理过程来说，这个值可能并不令人惊讶，但是，如果我们预测人类的行为，这个值就有点太高了。因此，我们还需要考虑 MSE 等其他指标。
在本教程中，我们将真实项目简化为更适合optimal flow初学者的情况。所以基于这个出发点，这个结果可以接受成为你第一个 OptimalFlow 自动化机器学习的输出。
这里有一些建议，如果您想继续改进我们的示例脚本，以便用更实用的优化模型方法更深入。
- 高 R 平方值通常意味着过度拟合。因此，放弃更多的功能，以防止这一点；
- 聚合是汇集数据的好主意，但它也让我们丢失了逐圈和逐时的差异信息；
- 缩放方法对于防止过度拟合也是必不可少的，我们可以从 custom_pp 中移除“None ”,并在步骤 3 中添加一些其他缩放方法(即，minmax、robust );
总之:
OptimalFlow 是一个简单易用的 API 工具，用简单的代码实现 Omni-ensemble 自动化机器学习，也是证明流水线簇遍历实验 (PCTE)理论的最佳实践库。**
它的 6 个模块既可以连接起来实现 PCTE 过程，也可以单独使用来优化传统机器学习工作流的组件。你可以在 文档 中找到它们各自的用例。
“算法专家认为没有免费的午餐.”—卡尔伯森
最后但同样重要的是，作为数据科学家，我们应该永远记住:无论什么样的自动化机器学习算法，“没有免费的午餐定理”永远适用。
关于 OptimalFlow 的相关阅读:
使用 OptimalFlow 进行机器学习中的集成特征选择—使用简单代码选择顶级特征的简单方法
关于我:
我是一名医疗保健和制药数据科学家以及大数据分析和人工智能爱好者。我开发了 OptimalFlow 库，帮助数据科学家以一种简单的方式构建最优模型，并用简单的代码实现机器学习工作流的自动化。
作为一名拥有多年分析经验的大数据洞察寻求者、流程优化者和人工智能专家，我使用数据科学中的机器学习和问题解决技能将数据转化为可操作的洞察，同时提供战略和量化产品作为最佳结果的解决方案。
你可以在 LinkedIn 或者 GitHub 上和我联系。
包含真实项目的端到端 OptimalFlow 自动化机器学习教程
公式 E Laps 预测—第 1 部分
在这个端到端的教程中，我们将说明如何使用optimal flow(文档||GitHub)，一个 Omni-ensemble 自动化机器学习工具包，来预测车手在 FIA Formula E 比赛中需要完成的圈数。这是一个典型的回归预测问题，影响了车队的赛车和能量策略的表现。
为什么我们使用 OptimalFlow ？你可以读另一个关于它的介绍的故事:一个全方位的自动化机器学习——optimal flow。
项目背景:
比赛中剩余的圈数可以确定其策略，即决定积极驾驶并消耗更多电池，或保守驾驶并节省能源。车队总是知道汽车电池的状态。
可用数据:
Formula E 官方网站:【https://results.fiaformula.com】上的公开数据，包括每位车手单圈的历史比赛计时数据和天气数据(风、雨等)
本条工程简化为:
我们将把问题简化为一个目标，来预测一场 Formula E 比赛的总圈数。我们将忽略其他人为干预因素，如撞车的可能性，或安全车对比赛时间的影响，这可能会影响特征的变化。
第一步:获取数据
从【https://results.fiaformula.com】获取公共时间和天气数据，并保持它们的层次结构，保存在类似结构的文件夹中。我们将提取他们的文件夹字典作为关于系列赛季(即 2017–2018)、比赛地点(即柏林)、比赛类型(即 FP1)等的特征。
第二步:数据整合
在将数据输入 OptimalFlow 模块之前，需要进行基本的数据工程步骤。有 3 种类型的数据:分析数据、天气数据和分类数据。对于这个简化的问题，我们可以把分析数据看成是人种数据，而忽略分类数据。此外，我们将包括从自由练习，资格赛，超级极，和比赛的分析数据。
下一个挑战是我们发现天气数据和比赛数据是分开的，这将很难找到它们之间的影响关系。因此，我们需要通过创建“关键”列/特征来建立连接。
为了创建连接键，我们应该快速浏览原始数据，但是显然，这里没有比赛日期信息，只有逐圈计时数据。但是我们知道天气数据和分析数据都保存在同一个文件夹目录中，这意味着我们可以使用数据的文件目录信息作为“关键”来合并天气和分析/比赛数据。
**
因此，将所有天气数据合并到一个数据集，并按年份追加比赛数据。同时，saved 单独提取所有数据集的文件位置信息(命名为‘file _ loc’)，以便进一步与天气数据合并。
经过前面的编码，我们将收到每年的比赛数据集，和天气综合数据集。
接下来，我们将在所有年度比赛数据集中找到共同的特征，并将年度比赛数据集合并为一个完整的数据集，将其保存为“contest_data.csv”。
然后，我们需要使用数据集的文件目录信息来创建“key”列，以连接综合天气数据和综合比赛数据。(请原谅我在以下代码中拼错了“天气”这个词……)
从竞赛数据的文件目录信息中提取属性
从天气数据的文件目录信息中提取属性
因此，我们将为进一步的合并步骤获得元数据数据集。您将拥有“match_key”作为我之前提到的“key”列。
步骤 3:探索性数据分析(EDA)
在统计学中，探索性数据分析(EDA)是一种分析数据集以总结其主要特征的方法，通常采用可视化方法。可以使用或不使用统计模型，但 EDA 主要是为了查看数据可以告诉我们什么，而不仅仅是正式的建模或假设测试任务。
我更喜欢使用 pandas-profiling 库来加速这一步。但这一步只是让我们对集成数据集、特征关系有一个总体感觉，并了解哪些特征可能与我们的最终预测目标相关。所以我们不需要在这一步花太多时间，还有 OptimalFlow 的 autoFS(自动特征选择模块)，以及 autoPP (自动特征预处理模块)会帮助我们覆盖它们，以防我们在 EDA 步骤中遗漏一些见解。
步骤 4:数据聚合
我们需要预测一场比赛的总圈数，所以一圈一圈的比赛数据和一次又一次的天气信息作为依赖因素并不清晰和强大。
所以更好的想法应该是数据聚合。我们不知道哪种聚合方法会极大地影响预测结果，所以我们可以尝试常见的计算方法，如平均值、中值、偏斜度、标准差等。，并将它们应用于综合天气数据和比赛数据。下面是天气数据聚合的代码示例:
天气数据聚合
然后我们将比赛数据与天气数据合并。合并后的数据集中共有 74 个要素。每一行记录都涵盖了特定 Formula E 事件/比赛中的一名车手，具有聚合的比赛和天气特征。这个输出或者我们通常所说的“预测”在我们的问题中是“【Total _ Lap _ Num】”列。
总而言之:
数据准备对于机器学习至关重要。作为进一步建模步骤的基础，它通常需要数据工程师和数据科学家的共同努力。领域经验和对数据源的熟悉是影响如何清理和集成原始数据的策略的关键因素。
在本教程的 第二部分 中，我们将使用 OptimalFlow 库来实现 Omni-ensemble 自动化机器学习。
关于 OptimalFlow 的相关阅读:
使用 OptimalFlow 进行机器学习中的集成特征选择—使用简单代码选择顶级特征的简单方法
关于我:
我是一名医疗保健和制药数据科学家以及大数据分析和人工智能爱好者。我开发了 OptimalFlow 库，帮助数据科学家以简单的方式构建最优模型，用简单的代码实现机器学习工作流程的自动化。
作为一名拥有多年分析经验的大数据洞察寻求者、流程优化者和人工智能专家，我使用数据科学中的机器学习和问题解决技能将数据转化为可操作的洞察，同时提供战略和量化产品作为最佳结果的解决方案。
你可以在我的 LinkedIn 或 GitHub 上与我联系。
为数据科学家设置多类影像分类的端到端管道
图片由来自 Pixabay 的 Louise Dav 拍摄
使用 PyTorch 和迁移学习
你有没有想过脸书是如何处理一些用户分享的侮辱性和不恰当的图片的？或者脸书的标签功能是如何工作的？或者说 Google Lens 是如何通过图像识别产品的？
以上都是图像分类在不同设置下的例子。多类图像分类是计算机视觉中的一项常见任务，我们将图像分为三类或更多类。
以前我都是用 Keras 做计算机视觉项目。然而，最近当从事多类图像分类的机会出现时，我决定使用 PyTorch。我已经把所有的 NLP 任务从 Keras 转移到 PyTorch，那么为什么不把 vision 也转移呢？
PyTorch 功能强大，我也喜欢它更 pythonic 化的结构。
在这篇文章中，我们将使用 Pytorch 为图像多类分类创建一个端到端的管道。 这将包括训练模型，将模型的结果以一种可以显示给业务伙伴的形式，以及帮助轻松部署模型的功能。作为一个附加的特性，我们也将使用 Pytorch 来增加测试时间。
但是在我们学习如何进行图像分类之前，我们先来看看迁移学习，这是处理这类问题最常见的方法。
什么是迁移学习？
迁移学习是将知识从一项任务转移到另一项任务的过程。从建模的角度来看，这意味着使用在一个数据集上训练的模型，并对其进行微调以用于另一个数据集。但是为什么会起作用呢？
先说一些背景。每年视觉识别社区都会为一个非常特殊的挑战而聚集在一起:Imagenet 挑战。这项挑战的任务是将 1，000，000 幅图像分为 1，000 个类别。
这一挑战已经导致研究人员训练大型卷积深度学习模型。结果包括像 Resnet50 和 Inception 这样的优秀模型。
但是，训练一个神经模型意味着什么呢？本质上，这意味着研究人员在一百万张图像上训练模型后，已经学习了神经网络的权重。
那么，如果我们能得到这些重量呢？然后，我们可以使用它们，并将它们加载到我们自己的神经网络模型中，在测试数据集上进行预测，对吗？实际上，我们可以走得更远。我们可以在这些研究人员已经准备好的神经网络之上添加一个额外的层来对我们自己的数据集进行分类。
虽然这些复杂模型的确切工作方式仍然是一个谜，但我们知道较低的卷积层可以捕捉边缘和梯度等低级图像特征。相比之下，更高的卷积层捕捉越来越复杂的细节，如身体部位、面部和其他组成特征。
来源:可视化和理解卷积网络。你可以看到前几层是如何捕捉基本形状的，在后面的层中形状变得越来越复杂。
在上面来自 ZFNet(Alex net 的变体)的示例中，ZFNet 是在 Imagenet 任务上获得成功的第一批卷积神经网络之一，您可以看到较低层是如何捕捉线条和边缘的，而后面的层是如何捕捉更复杂的特征的。通常假设最终的全连接层捕获与解决相应任务相关的信息，例如，ZFNet 的全连接层指示哪些特征与将图像分类到 1，000 个对象类别之一相关。
对于新的视觉任务，我们可以简单地使用预先在 ImageNet 上训练的最新 CNN 的现成特征，并在这些提取的特征上训练新的模型。
这个想法背后的直觉是，一个经过训练可以识别动物的模型也可以用来识别猫和狗。在我们的例子中，
一个在 1000 个不同类别上训练过的模型已经看到了很多真实世界的信息，我们可以使用这些信息来创建我们自己的定制分类器。
理论和直觉就是这样。我们如何让它真正发挥作用？让我们看一些代码。你可以在Github上找到这篇文章的完整代码。
数据探索
我们将从 Kaggle 的船数据集开始，以理解多类图像分类问题。该数据集包含大约 1，500 张不同类型的船只照片:浮标、游轮、渡船、货船、平底船、充气船、皮艇、纸船和帆船。我们的目标是创建一个模型，该模型查看船只图像并将其分类到正确的类别中。
以下是数据集中的图像示例:
以下是类别计数:
由于类别*“货运船”
“充气船”*“船”没有太多的图像；我们将在训练模型时删除这些类别。
创建所需的目录结构
在我们可以训练我们的深度学习模型之前，我们需要为我们的图像创建所需的目录结构。现在，我们的数据目录结构看起来像这样:
images
sailboat
kayak
.
.
我们需要我们的图像被包含在 3 个文件夹train、val和test。然后，我们将对train数据集中的图像进行训练，对val数据集中的图像进行验证，最后对test数据集中的图像进行测试。
data
train
sailboat
kayak
.
.
val
sailboat
kayak
.
.
test
sailboat
kayak
.
.
您可能有不同格式的数据，但是我发现除了通常的库之外，glob.glob和os.system函数非常有用。在这里你可以找到完整的数据准备代码。现在让我们快速浏览一下我在准备数据时发现有用的一些不常用的库。
什么是 glob.glob？
简单地说，glob 允许您使用正则表达式获取目录中文件或文件夹的名称。例如，您可以这样做:
from glob import glob
categories = glob(“images/*”)
print(categories)
------------------------------------------------------------------
['images/kayak', 'images/boats', 'images/gondola', 'images/sailboat', 'images/inflatable boat', 'images/paper boat', 'images/buoy', 'images/cruise ship', 'images/freight boat', 'images/ferry boat']
什么是 os.system？
os.system是os库中的一个函数，它允许你在 python 中运行任何命令行函数。我通常用它来运行 Linux 函数，但它也可以用来运行 python 中的 R 脚本，如这里的所示。例如，在从 pandas 数据框中获取信息后，我在准备数据时使用它将文件从一个目录复制到另一个目录。我也使用 f 字符串格式。
import osfor i,row in fulldf.iterrows():
# Boat category
cat = row['category']
# section is train,val or test
section = row['type']
# input filepath to copy
ipath = row['filepath']
# output filepath to paste
opath = ipath.replace(f"images/",f"data/{section}/")
# running the cp command
os.system(f"cp '{ipath}' '{opath}'")
现在，既然我们已经在所需的文件夹结构中有了数据，我们可以继续进行更令人兴奋的部分。
数据预处理
转换:
1。Imagenet 预处理
为了将我们的图像用于在 Imagenet 数据集上训练的网络，我们需要以与 Imagenet 网络相同的方式预处理我们的图像。为此，我们需要将图像缩放到 224×224，并按照 Imagenet 标准对其进行标准化。我们可以利用火炬视觉transforms图书馆做到这一点。这里我们取 224×224 的CenterCrop，按照 Imagenet 标准进行归一化。下面定义的操作按顺序发生。您可以在这里找到由 PyTorch 提供的所有转换的列表。
transforms.Compose([
transforms.CenterCrop(size=224),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406],
[0.229, 0.224, 0.225])
])
2。数据扩充
我们可以为数据扩充做更多的预处理。神经网络在处理大量数据时效果更好。数据扩充是一种策略，我们在训练时使用它来增加我们拥有的数据量。
例如，我们可以水平翻转一艘船的图像，它仍然是一艘船。或者我们可以随机裁剪图像或添加颜色抖动。这是我用过的图像转换字典，它适用于 Imagenet 预处理和增强。这本字典包含了我们在这篇伟大的文章中使用的训练、测试和验证数据的各种转换。正如您所料，我们没有对测试数据和验证数据应用水平翻转或其他数据增强转换，因为我们不想在增强的图像上获得预测。
# Image transformations
image_transforms = {
# Train uses data augmentation
'train':
transforms.Compose([
transforms.RandomResizedCrop(size=256, scale=(0.8, 1.0)),
transforms.RandomRotation(degrees=15),
transforms.ColorJitter(),
transforms.RandomHorizontalFlip(),
transforms.CenterCrop(size=224), # Image net standards
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406],
[0.229, 0.224, 0.225]) # Imagenet standards
]),
# Validation does not use augmentation
'valid':
transforms.Compose([
transforms.Resize(size=256),
transforms.CenterCrop(size=224),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
]),
# Test does not use augmentation
'test':
transforms.Compose([
transforms.Resize(size=256),
transforms.CenterCrop(size=224),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
]),
}
以下是应用于训练数据集中图像的训练变换示例。我们不仅从一幅图像中得到许多不同的图像，而且它还帮助我们的网络变得对物体方向不变。
ex_img = Image.open('/home/rahul/projects/compvisblog/data/train/cruise ship/cruise-ship-oasis-of-the-seas-boat-water-482183.jpg')t = image_transforms['train']
plt.figure(figsize=(24, 24))for i in range(16):
ax = plt.subplot(4, 4, i + 1)
_ = imshow_tensor(t(ex_img), ax=ax)plt.tight_layout()
数据加载器
下一步是向 PyTorch 提供培训、验证和测试数据集的位置。我们可以通过使用 PyTorch datasets和DataLoader类来做到这一点。如果我们将数据放在所需的目录结构中，这部分代码将基本保持不变。
# Datasets from folderstraindir = "data/train"
validdir = "data/val"
testdir = "data/test"data = {
'train':
datasets.ImageFolder(root=traindir, transform=image_transforms['train']),
'valid':
datasets.ImageFolder(root=validdir, transform=image_transforms['valid']),
'test':
datasets.ImageFolder(root=testdir, transform=image_transforms['test'])
}# Dataloader iterators, make sure to shuffle
dataloaders = {
'train': DataLoader(data['train'], batch_size=batch_size, shuffle=True,num_workers=10),
'val': DataLoader(data['valid'], batch_size=batch_size, shuffle=True,num_workers=10),
'test': DataLoader(data['test'], batch_size=batch_size, shuffle=True,num_workers=10)
}
这些数据加载器帮助我们遍历数据集。例如，我们将在模型培训中使用下面的数据加载器。数据变量将包含形式为(batch_size, color_channels, height, width)的数据，而目标的形状为(batch_size)，并保存标签信息。
train_loader = dataloaders['train']
for ii, (data, target) in enumerate(train_loader):
建模
1.使用预先训练的模型创建模型
现在，这些预先训练好的模型可以在torchvision图书馆使用:
在这里，我将在我们的数据集上使用 resnet50，但是您也可以根据自己的选择有效地使用任何其他模型。
from torchvision import models
model = models.resnet50(pretrained=True)
我们从冻结模型重量开始，因为我们不想改变 renet50 模型的重量。
# Freeze model weights
for param in model.parameters():
param.requires_grad = False
我们需要做的下一件事是用我们的自定义分类器替换模型中的线性分类层。我发现，要做到这一点，最好先看看模型结构，以确定最终的线性层是什么。我们可以简单地通过打印模型对象来做到这一点:
print(model)
------------------------------------------------------------------
ResNet(
(conv1): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)
(bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
(relu): ReLU(inplace=True)
.
.
.
.(conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)
(bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
(relu): ReLU(inplace=True)
)
)
(avgpool): AdaptiveAvgPool2d(output_size=(1, 1))
**(fc): Linear(in_features=2048, out_features=1000, bias=True)**
)
在这里，我们发现从卷积层获取输入的最后一个线性层被命名为fc
我们现在可以使用我们定制的神经网络简单地替换fc层。该神经网络将来自前一层的输入输入到fc，并给出形状(batch_size x n_classes)的 log softmax 输出。
n_inputs = model.fc.in_features
model.fc = nn.Sequential(
nn.Linear(n_inputs, 256),
nn.ReLU(),
nn.Dropout(0.4),
nn.Linear(256, n_classes),
nn.LogSoftmax(dim=1))
请注意，现在添加的新层在默认情况下是完全可训练的。
2.在 GPU 上加载模型
我们可以使用 PyTorch 的 DataParallel 来使用单个或多个 GPU(如果我们有)。这里是我们可以用来检测 GPU 以及在 GPU 上加载模型的 GPU 数量。现在，我正在双英伟达泰坦 RTX 图形处理器上训练我的模型。
# Whether to train on a gpu
train_on_gpu = cuda.is_available()
print(f'Train on gpu: {train_on_gpu}')# Number of gpus
if train_on_gpu:
gpu_count = cuda.device_count()
print(f'{gpu_count} gpus detected.')
if gpu_count > 1:
multi_gpu = True
else:
multi_gpu = Falseif train_on_gpu:
model = model.to('cuda')if multi_gpu:
model = nn.DataParallel(model)
3.定义标准和优化器
当你训练任何模型时，最重要的事情之一是损失函数和优化器的选择。这里我们想使用分类交叉熵，因为我们有一个多类分类问题和 Adam 优化器，这是最常用的优化器。但是，由于我们对模型的输出应用 LogSoftmax 运算，因此我们将使用 NLL 损耗。
from torch import optimcriteration = nn.NLLLoss()
optimizer = optim.Adam(model.parameters())
4.训练模型
下面给出了用于训练模型的完整代码。它本身看起来可能很大，但本质上我们所做的如下:
- 开始运行纪元。在每个时代-
- 使用
model.train()将模型模式设置为训练。 - 使用列车数据加载器循环数据。
- 使用
data, target = data.cuda(), target.cuda()命令将你的数据加载到 GPU - 使用
optimizer.zero_grad()将优化器中的现有梯度设置为零 - 使用
output = model(data)向前运行批次 - 使用
loss = criterion(output, target)计算损失 - 使用
loss.backward()通过网络反向传播损耗 - 使用
optimizer.step()采取优化步骤改变整个网络的权重 - 训练循环中的所有其他步骤只是为了维护历史和计算准确性。
- 使用
model.eval()将模型模式设置为评估。 - 使用
valid_loader获得验证数据的预测，并计算valid_loss和valid_acc - 打印每个
print_every时期的验证损失和验证准确度结果。 - 保存基于验证损失的最佳模型。
- **提前停止:**如果交叉验证损失在
max_epochs_stop内没有改善，则停止训练并加载验证损失最小的最佳可用模型。
下面是运行上述代码的输出。只显示最近几个时代。在第一个纪元中，验证精度从大约 55%开始，我们以大约 90%的验证精度结束。
下面是显示损失和准确性指标的训练曲线:
训练曲线
推理和模型结果
我们希望我们的结果以不同的方式使用我们的模型。首先，我们需要测试精度和混淆矩阵。创建这些结果的所有代码都在代码笔记本中。
1.试验结果
测试模型的总体精度为:
Overall Accuracy: 88.65 %
这是测试数据集结果的混淆矩阵。
我们也可以看看类别的准确性。我还添加了列车计数，以便从新的角度查看结果。
2.单个图像的可视化预测
出于部署目的，能够获得对单个图像的预测是有帮助的。你可以从笔记本上找到密码。
3.可视化类别的预测
我们还可以看到用于调试和演示的分类结果。
4.测试时间增加后的测试结果
我们还可以增加测试时间来提高我们的测试精度。这里我使用了一个新的测试数据加载器和转换:
# Image transformations
tta_random_image_transforms = transforms.Compose([
transforms.RandomResizedCrop(size=256, scale=(0.8, 1.0)),
transforms.RandomRotation(degrees=15),
transforms.ColorJitter(),
transforms.RandomHorizontalFlip(),
transforms.CenterCrop(size=224), # Image net standards
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406],
[0.229, 0.224, 0.225]) # Imagenet standards
])# Datasets from folders
ttadata = {
'test':
datasets.ImageFolder(root=testdir, transform=tta_random_image_transforms)
}# Dataloader iterators
ttadataloader = {
'test': DataLoader(ttadata['test'], batch_size=512, shuffle=False,num_workers=10)
}
然后，我们可以使用以下函数获得测试集上的预测:
在上面的函数中，在得到预测之前，我对每张图片应用了 5 次tta_random_image_transforms。最终预测是所有五次预测的平均值。当我们在整个测试数据集上使用 TTA 时，我们注意到准确率提高了大约 1%
TTA Accuracy: 89.71%
此外，以下是 TTA 的结果与正常结果的分类比较:
在这个小数据集中，TTA 似乎没有增加多少价值，但我注意到它增加了大数据集的价值。
结论
在这篇文章中，我谈到了使用 PyTorch 进行多类图像分类项目的端到端管道。我们致力于创建一些现成的代码来使用迁移学习训练模型，可视化结果，使用测试时间增加，并获得对单个图像的预测，以便我们可以在需要时使用任何工具部署我们的模型，如 Streamlit 。
你可以在 Github 上找到这篇文章的完整代码。
如果你想了解更多关于图像分类和卷积神经网络的知识，看看来自吴恩达的深度学习专业。此外，要了解 PyTorch 的更多信息并从基础开始，您可以看看 IBM 提供的深度神经网络与 PyTorch 课程。
谢谢你的阅读。将来我也会写更多初学者友好的帖子。在 媒体 关注我，或者订阅我的 博客 了解他们。一如既往，我欢迎反馈和建设性的批评，可以通过 Twitter @mlwhiz 联系到我。
此外，一个小小的免责声明——这篇文章中可能会有一些相关资源的附属链接，因为分享知识从来都不是一个坏主意。
本帖首发 此处 。
使用三种机器学习模型基于勒布朗数据的端到端游戏预测方案
机器学习
使用三种不同的分类器(包括逻辑回归、随机森林分类器和深度学习分类器)对二元分类问题进行综合指导。
照片由 JC Gellidon 在 Unsplash
我是 机器学习 和 篮球 的超级粉丝，所以我喜欢把这两个结合起来生成一些迷你项目。在这篇文章中，我想和你分享其中的一个项目。
不管你是不是篮球迷，你都必须知道勒布朗詹姆斯。作为核心球员，他的表现对比赛结果至关重要。所以，我在这个项目中试图回答的问题是 “我们能根据勒布朗的比赛数据预测比赛结果吗？”
我把它框定为一个二元分类问题，以团队的“赢”或“输”作为输出标签。特征是勒布朗·詹姆斯每场比赛的基本统计。
我在项目中实现了三个分类器，随机森林分类器深度学习分类器* ，通过使用机器学习中流行的两个 Python 库，sk learn，以及keras。*
我正在一步一步地完成这个项目，希望对你有所帮助。
准备数据集
这里列出了代码中使用的库。
*import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.model_selection import StratifiedKFold
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier
from keras.layers import Dense, Dropout
from keras.models import Model, Sequential
from keras.wrappers.scikit_learn import KerasClassifier
from sklearn.model_selection import GridSearchCV*
我手动整理了勒布朗从赛季2003–2004到赛季2019–2020*(直到 3 月 NBA 停赛)的比赛基本统计。总共有 1258 场比赛。进口代码如下:*
*df = pd.read_csv("lebron_2003_2020_career_gamelog.csv",index_col=0)
df.head()*
端到端游戏预测(由虞风
从上图可以看到基础统计和游戏结果*(“赢”和“Winby”)。*
然后，我要确保数据类型是“float32 ”,这样我就可以直接将它们提供给 keras 中的神经元网络模型。数据类型转换代码如下:
*df = df.astype('float32')*
接下来，我需要使用如下代码指定数据集中的特征空间和标签:
*y = df['Win']
X = df.drop(columns=['Win','Winby'])*
列“ 赢 ”是记录的游戏结果，其中 1 表示 赢 ，0 表示 输 。而“ Winby ”一栏则是该组件的游戏分数差，其中正数表示 赢 ，负数表示 输 。因此，有必要将它们从特征空间中移除。
接下来，数据被分成 训练 和 测试 集合，其中测试集合在模型评估步骤之前永远不会被触及。代码如下:
*X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2,stratify=y, random_state=42)*
你可能会注意到，我在这里使用了一个 分层分割 ，避免了游戏结果在训练数据中偏向一类的情况。“分层=y”表示基于我们的输出标签 y 完成“分层分割”。
到现在为止，牛排已经做好了，我们需要开始预热烤箱。
模特培训
Ashim D’Silva 在 Unsplash 上拍摄的照片
正如我提到的，将使用三个模型，逻辑回归，随机森林分类器，以及深度学习分类器*。为了使它们都符合相同的 Scikit-Learn 工作流，我们需要首先以如下的 Scikit-Learn 风格定义深度学习模型:*
*def my_DL(epochs=6,batchsize=512):
model = Sequential()
model.add(Dense(32,activation='relu'))
model.add(Dense(16,activation='relu'))
model.add(Dense(1,activation='sigmoid'))
model.compile(loss='binary_crossentropy',optimizer='rmsprop', metrics=['accuracy']) return model*
具体来说，这个神经网络有两个隐层，分别是 32 个和 16 个节点。网络的损失函数、优化器和度量分别固定为’二元交叉熵’、 rmsprop 和’精度’。
该编译模型有两个可调参数， 历元 为历元数， 批次大小 为每批样本数。这两个参数都有默认值，格式类似于 sklearn 中的分类器。
不能从数据中训练出来但需要在训练过程前赋值的模型参数称为 超参数 。这些超参数总是与模型的复杂度相关，需要正确选择以避免欠拟合或过拟合问题。
要选择最佳的超参数集，我们可以用两种方法。首先，我们可以进一步将训练数据集分成两部分，即 训练 和 验证 数据集。然后，我们需要在验证集合上评估来自训练数据集的训练模型。最佳超参数集是在验证集上具有最佳性能的超参数集。
然而，当样本量很小时，只有一个数据分割会有偏差。所以， 交叉验证 是另一种训练超参数的方式，更受欢迎。因此，我在这个项目中使用交叉验证。
我在下面列出了超参数调谐的全部功能，并将详细介绍。
*def train_hyper_tune(X,y):
# create the pre-processing component
my_scaler = StandardScaler()
my_imputer = SimpleImputer(strategy="median")
# define classifiers
## Classifier 1: Logistic Regression
clf_LR = LogisticRegression(random_state=0,penalty='elasticnet',solver='saga')
## Classifier 2: Random Forest Classifier
clf_RF = RandomForestClassifier(random_state=0)
## Classifier 3: Deep Learning Binary Classifier
clf_DL = KerasClassifier(build_fn=my_DL)
# define pipeline for three classifiers
## clf_LR
pipe1 = Pipeline([('imputer', my_imputer), ('scaler', my_scaler), ('lr_model',clf_LR)])
## clf_RF
pipe2 = Pipeline([('imputer', my_imputer), ('scaler', my_scaler), ('rf_model',clf_RF)])
## clf_DL
pipe3 = Pipeline([('imputer', my_imputer), ('scaler', my_scaler), ('dl_model',clf_DL)])
# create hyperparameter space of the three models
## clf_LR
param_grid1 = {
'lr_model__C' : [1e-1,1,10],
'lr_model__l1_ratio' : [0,0.5,1]
}
## clf_RF
param_grid2 = {
'rf_model__n_estimators' : [50,100],
'rf_model__max_features' : [0.8,"auto"],
'rf_model__max_depth' : [4,5]
}
## clf_DL
param_grid3 = {
'dl_model__epochs' : [6,12,18,24],
'dl_model__batchsize' : [256,512]
}
# set GridSearch via 5-fold cross-validation
## clf_LR
grid1 = GridSearchCV(pipe1, cv=5, param_grid=param_grid1)
## clf_RF
grid2 = GridSearchCV(pipe2, cv=5, param_grid=param_grid2)
## clf_DL
grid3 = GridSearchCV(pipe3, cv=5, param_grid=param_grid3)
# run the hyperparameter tunning process
grid1.fit(X,y)
grid2.fit(X,y)
grid3.fit(X,y)
# return results of the tunning process
return grid1,grid2,grid3,pipe1,pipe2,pipe3*
如代码所示，函数内部主要有六个步骤:
第一步。创建预处理函数。
*# create the pre-processing component
my_scaler = StandardScaler()
my_imputer = SimpleImputer(strategy="median")*
我使用特征的中值来估算缺失值，使用标准缩放器来标准化数据。这一步对于所有三种型号都是一样的。
第二步。定义所有三个分类器。
*# define classifiers
## Classifier 1: Logistic Regression
clf_LR = LogisticRegression(random_state=0,penalty='elasticnet',solver='saga')
## Classifier 2: Random Forest Classifier
clf_RF = RandomForestClassifier(random_state=0)
## Classifier 3: Deep Learning Binary Classifier
clf_DL = KerasClassifier(build_fn=my_DL)*
首先，逻辑回归分类器通常被用作“Hello world！”机器学习书籍中的模型。这里，它与惩罚函数一起使用，以避免过度拟合。带有这个罚项的模型称为“弹性网”，它是正则化中 l1 和 l2 范数的组合。
对于那些对我们为什么选择弹性网作为惩罚条款感兴趣的人，请阅读我下面的另一篇文章:
从弹性网开始，记得调好定义 l1 范数之比的超参数。
towardsdatascience.com](/a-practical-suggestion-in-linear-regression-cb639fd5ccdb)
第二，随机森林分类器以更自由的方式定义，而不固定任何超参数。它的三个超参数将在下面的步骤中进行调整，我将在后面详细介绍。
第三，这里使用的深度学习分类器是基于前面提到的 Scikit-Learn 风格模型， my_DL 。谢天谢地，Keras 为 Scikit-Learn API 提供了精彩的包装器。我通过将函数 my_DL 传递给函数 KerasClassifier()来直接调用它。
第三步。为每个模型定义一个管道，将预处理和建模结合在一起。
# define pipeline for three classifiers
## clf_LR
pipe1 = Pipeline([('imputer', my_imputer), ('scaler', my_scaler), ('lr_model',clf_LR)])
## clf_RF
pipe2 = Pipeline([('imputer', my_imputer), ('scaler', my_scaler), ('rf_model',clf_RF)])
## clf_DL
pipe3 = Pipeline([('imputer', my_imputer), ('scaler', my_scaler), ('dl_model',clf_DL)])
对于这三个模型中的每一个，我都用 sklearn 中的 流水线函数将预处理和分类器组合成一个流水线。对于处理的每一步，都应该给出一个名称。例如，我将我的逻辑回归模型命名为“ lr_model ”，并在管道中通过 clf_LR 调用它。
将所有内容合并到一个管道中的目的是确保在交叉验证中对训练数据进行完全相同的处理。这对于避免数据泄露至关重要。
步骤四。为每个模型创建超参数空间。
# create hyperparameter space of the three models
## clf_LR
param_grid1 = {
'lr_model__C' : [1e-1,1,10],
'lr_model__l1_ratio' : [0,0.5,1]
}
## clf_RF
param_grid2 = {
'rf_model__n_estimators' : [50,100],
'rf_model__max_features' : [0.8,"auto"],
'rf_model__max_depth' : [4,5]
}
## clf_DL
param_grid3 = {
'dl_model__epochs' : [6,12,18,24],
'dl_model__batchsize' : [256,512]
}
这部分比较灵活，因为这三个模型中有大量的参数。选择与模型复杂性密切相关的参数很重要。例如，随机森林模型中树的最大深度是一个必须调整的超参数。有兴趣的可以参考下面这个帖子。
当训练数据中的性能比测试数据中的性能好得多时，就会发生过度拟合。默认…
towardsdatascience.com](/one-potential-cause-of-overfitting-that-i-never-noticed-before-a57904c8c89d)
注意，管道中的步骤名称需要在超参数空间中指定。比如深度学习模型中的历元数命名为***“dl _ model _ _ epochs”，其中“dl _ model”是我的管道中深度学习模型的名称“epochs”***是可以传递给我的深度学习模型的参数名称。它们在超参数空间中以字符串格式由“__”连接。
第五步。通过交叉验证设置跨超参数空间的网格搜索功能。
# set GridSearch via 5-fold cross-validation
## clf_LR
grid1 = GridSearchCV(pipe1, cv=5, param_grid=param_grid1)
## clf_RF
grid2 = GridSearchCV(pipe2, cv=5, param_grid=param_grid2)
## clf_DL
grid3 = GridSearchCV(pipe3, cv=5, param_grid=param_grid3)
与随机搜索相比，网格搜索的计算成本更高，因为它跨越了整个超参数空间。在这个项目中，我使用网格搜索，因为超参数空间相对较小。
对于每个网格搜索，我使用 5 重交叉验证 来评估超参数组合的平均性能。
第六步。运行调整过程。
# run the hyperparameter tunning process
grid1.fit(X,y)
grid2.fit(X,y)
grid3.fit(X,y)
这一步非常简单，在三个定义的管道上执行网格搜索。
最后，我们只需要运行如下函数:
my_grid1,my_grid2,my_grid3,my_pipe1,my_pipe2,my_pipe3 = train_hyper_tune(X_train, y_train)
我们可以通过拉出网格搜索结果中的最佳分数来检查训练性能。
端到端游戏预测(由虞风
看起来随机森林在训练数据集上具有最好的性能。但是这三个模型彼此之间非常相似。
测试数据的模型评估
韦德·奥斯汀·埃利斯在 Unsplash 上的照片
在前面的步骤中选择了超参数之后，我使用它们在整个训练数据上重新训练模型。代码如下所示:
def train_on_entire(X,y,pipe,grid_res):
# fit pipeline
pipe.set_params(**grid_res.best_params_).fit(X, y)
# return the newly trained pipeline
return pipe
这里，**** * grid _ RES . best _ params _***用于将网格搜索中的最佳参数传递给管道，以进行超参数设置。
在用 X 和 y 重新调整后，返回的管道 管道 是在整个训练数据集上完全训练的模型。
然后，我们需要在测试数据集上评估这个经过训练的模型。
train_on_entire(X_train,y_train,my_pipe1,my_grid1).score(X_test,y_test)
train_on_entire(X_train,y_train,my_pipe2,my_grid2).score(X_test,y_test)
train_on_entire(X_train,y_train,my_pipe3,my_grid3).score(X_test,y_test)
逻辑回归、随机森林分类器和深度学习分类器在准确度方面的性能分别为 0.869 、 0.901 和 0.877 。
从结果中我们可以得出几个结论。 首先， 随机森林分类器在这次预测中似乎表现优于其他两种方法。 第二， 深度学习方法在处理这样的表格化数据集时并没有表现出优势。 第三， 这三种方法都说明勒布朗的比赛数据对比赛结果有预测能力，可见他在球队中的统治地位。
就是这样，端到端的机器学习项目。我希望你从中学到了一些东西。
克里斯汀娜·戈塔迪在 Unsplash 上的照片
参考资料:
- 【https://keras.io/scikit-learn-api/
- https://sci kit-learn . org/stable/modules/generated/sk learn . model _ selection。stratifiedkfold . html # sk learn . model _ selection。分层折叠
- https://sci kit-learn . org/stable/modules/generated/sk learn . pipeline . pipeline . html
- https://sci kit-learn . org/stable/modules/generated/sk learn . linear _ model。LogisticRegression.html
- https://sci kit-learn . org/stable/modules/generated/sk learn . ensemble . randomforestclassifier . html*
端到端 AWS 定量分析:使用 AWS 和 AWSCLI 自动运行脚本
凯文·Ku 从派克斯拍摄的照片
建设 AWS 管道
使用 AWSCLI 旋转、运行和拆除 AWS 服务器
在之前的一篇文章中，我们探讨了如何使用 Python 从在线资源(在我们的例子中，是 Yahoo！金融)。
我们开发了两个 Python 脚本；一个为我们抓取数据，一个使用 sklearn 的决策树分类器处理数据。然后，我们将它们上传到 AWS 上的一个 S3 存储桶中，以便安全保管，也便于从其他 AWS 服务中访问。
在本帖中，我们将探讨如何建立一个工作流，为我们创建一个处理服务器，在该服务器上训练我们的数据模型，然后在完成后移除该服务器。
在亚马逊网络服务(AWS)上运行一组模型
AWS 的定价模式是“按使用付费”，这意味着我们可以创建一个服务器，在其上进行一些数据处理，然后拆除它，我们将只为服务器运行的时间付费。此外，我们将使用一个名为 AWSCLI(AWS Client)的客户端库来启动服务器(创建服务器的时髦术语)和关闭它。我从 Brent Lemieux 的一篇帖子中开始了解我需要什么来启动服务器，我强烈建议你去看看那篇帖子。
配置我们的客户端应用程序
首先，我们将安装和配置 AWSCLI。我将使用 AWSCLI v2。一旦安装，我们可以测试它的工作
aws2 --version
>>> aws-cli/2.0.0dev2 Python/3.7.5 Windows/10 botocore/2.0.0dev1
然后我们配置它。在配置 AWSCLI 时，本页可能对默认区域选择有用。
我们还应该通过运行
aws2 emr create-default-roles
创建引导文件
配置完成后，我们可以使用 AWSCLI 并启动我们的服务器。阅读 Brent Lemieux 的文章，他描述了如何创建一个引导文件来为我们初始化服务器。你会注意到我们需要在服务器上安装像 pandas 和 matplotlib 这样的包，因为它只附带了很少的 python 包。
这将是我们的引导文件:
自举 _ 文件. sh
- 第一行设置
python命令指向 python 3(目前是 3.6)而不是默认的 2.7(为什么默认还是 2.7？贝佐斯，这已经过去 6 年了。这样，我们漂亮的脚本将由 python 3.x 运行 - 第二个命令使用 python 来安装我们需要的库。在这里，您可以随意添加任何其他对您有用的库。
- 第三个命令将我们的
workflow-scriptsbucket 的内容复制到集群中。你必须用你的桶名替换**workflow-scripts**。 - 第四行运行将为我们获取数据的脚本(您可以在这里获取)，并将数据存储在适当的 S3 桶中。你必须用你的桶名替换
**data-files**。
这个引导脚本将是我们的服务器建立后运行的第一个项目。
配置对 S3 的读/写权限
我们现在有了设置脚本和基本的数据处理脚本。我们差不多准备好运行我们的代码了。我们需要确保我们的脚本可以读取和写入 S3 桶。
我们将向默认角色添加一个策略来允许这一点。
这是什么意思？嗯，当我们创建一个 EMR 集群(一组为我们执行处理的计算机)时，我们给该集群分配一个角色，这意味着我们给它一些权限，让它在集群中安装库。这就像是我们的集群能够做的动作的集合。希望我们按照指示创建了默认角色**。**但是，这些角色不包括与私有的 S3 存储桶进行交互的权限。有两种方法可以解决这个问题:
- 让我们的桶中的文件完全公开(真的真的真的真的真的真的很糟糕的主意)
- 在 AWS 配置上投入更多时间，并让一些角色能够与我们拥有的 S3 资源进行交互(好得多)
导航到 AWS 中的 IAM 控制台，我们将找到所有可用角色的列表:
EMR/EC2 访问的默认角色
然后，我们将单击每个默认角色，并选择添加一个内联策略
添加内嵌策略
然后，我们将向我们的角色添加完整的读写策略，如下所示:
S3 资源的读写策略
实际上，我们可以更具体地说明我们的政策，以及我们的角色如何与我们的 S3 团队互动。现在，我们只需为所有四个资源组(访问点、存储桶、作业和对象)选择 Any ，我们就可以检查并批准策略了。
如果有需要，应该选择更严格的条件。
纱线的配置文件
我们要为这个演示做的事情将需要我们机器上的大量 RAM，超过默认值所允许的。所以我们必须创建一个配置文件来帮助我们避开这个问题。
一般来说，大数据通常不会完全加载到 RAM 中，而是使用 HIVE 或 Spark 进行交互。然而，为了将 Spark 与我们经典的机器学习方法进行比较，我们将反叛并将大量数据加载到 RAM 中。
让我们在本地机器上创建一个名为 config.json 的配置文件。
它处理我们的资源管理器 YARN(另一个资源协商器)，并告诉我们可以为整个应用程序分配多少内存，以及告诉 YARN 不要检查内存违规(整个内存中只有一小部分会分配给我们的 Python 脚本，因此我们需要停止检查这一小部分之外的违规)。
同样，这是为了比较我们的基础sklearn决策树，而不是处理大数据的方式。
为我们的集群设置身份验证
我们必须从 EC2 仪表板创建一个密钥对，并将其下载到我们的计算机上
EC2 密钥对接口
一旦下载了密钥对，就必须通过运行命令使其可读
chmod 400 my-key-pair.pem
在文件上使用终端(Mac)或 Git-Bash (Windows)。这允许您稍后连接到启动的实例(如果它正在运行)。
通过 AWS CLI 启动 EMR 集群
我们期待已久的时刻终于到来了。使用 AWSCLI，我们可以在家中舒适地启动一个集群来为我们做一些工作。为此，我们将运行以下命令:
aws2 emr create-cluster \
--name "**Spark cluster with step**" \
--release-label emr-5.29.0 \
--applications Name=Spark \
--log-uri **s3://log-bucket/logs/** \
--ec2-attributes KeyName=**my-key-pair** \
--instance-type m5.2xlarge \
--instance-count 1 \
--bootstrap-actions Path=**s3://scripts-and-setup/bootstrap_file.sh** \
--configuration file://config.json \
--steps Name="Command Runner",Jar="command-runner.jar",Args=["spark-submit","--deploy-mode=cluster","--executor-memory","20G","**s3://workflow-script/process_data.py**, **s3://data-files/**AAPL.csv"] \
--use-default-roles \
--auto-terminate
这个命令有很多东西，所以让我们打开重要的部分:
aws2 emr create-cluster—希望这是不言自明的--name "**Spark cluster with step**"—用您喜欢的任何名称替换此名称，但这将是集群的名称--release-label emr-5.29.0—要使用的集群版本。不同版本的集群包含各种其他应用程序的不同版本，如 Hadoop、Spark、Hive 等--applications Name=Spark—我们将推出一款 spark 应用--log-uri **s3://log-bucket/logs/**— 这是我们将日志发送到的地方。您需要一个日志存储桶，以防您的集群出现故障，并且您可以查看出错原因的日志。你必须用你的桶替换它。--ec2-attributes **KeyName=my-key-pair**— 这是一个密钥对，如果需要，您可以使用它来建立到集群的 ssh 连接--instance-type m5.2xlarge—这是我们将使用的实例类型和大小。AWSCLI 不支持小于 xlarge 的--instance-count 1—我们将只启动一个实例(实际上并不是一个集群，但是我们将在下一篇文章中讨论)--bootstrap-actions Path=**s3://scripts-and-setup/bootstrap_file.sh**—这是命令的一部分，告诉集群使用哪个脚本来启动集群。您必须用您的脚本文件位置替换它--configuration file://config.json—这告诉 AWSCLI 使用我们创建的 config.json 文件，前缀file://告诉 AWSCLI 这是一个本地文件(尽管我们也可以将它存储在 AWS S3 上)- 这个很密集，所以让我们把它再分开一些。首先，我们将使用
command-runner.jarJar 文件来运行我们的 python 脚本。这是一个 Java 可执行文件，它将运行我们的 python 脚本并管理所有与 Spark 相关的工作。
成那个样子。jar 文件我们发几个参数Args。它们是spark-submit，它说这个任务被提交给 Spark 框架，--deploy-mode=cluster，它说我们在集群内部启动我们的可执行文件(相对于从我们的家，非 AWS 机器)，我们要求 Spark 框架在运行我们的脚本和它的其他步骤时使用 20GB 的内存(实际上我们的脚本变得有点少，因为内存分配是如何在 Spark 和 YARN 之间工作的)用命令"--executor-memory"和"20G"， 最后是最后一个参数
**s3://workflow-scripts/process_data.py**, **s3://data-files/AAPL.csv**，通过 AWS 的魔法，它被解析成
**s3://workflow-scripts/process_data.py** **s3://data-files/AAPL.csv**(注意逗号被空格替换，形成一个完整的命令)。 这是 Spark 环境将运行的完整命令，这是我们的 Python 脚本(下载到这里)及其所有参数。对于这一步，您必须用自己合适的名称替换存储桶名称。 --use-default-roles—告诉 AWS 使用我们之前设置的默认角色- 这是一个真正美丽的论点。它告诉集群在所有处理完成后终止，因此我们不会为集群无所事事地坐在那里并收取我们的信用卡费用而付费。如果为了调试的目的，您想要保持集群运行，您可以省略它或者使用显式版本
--no-auto-terminate。但是，确保手动终止，然后。
我们运行的结果
在我的机器上输入命令后，集群启动用了大约 2 秒钟，然后又用了 12 分钟来完成我要求的一切并终止。当检查 S3 存储桶的日志时，决策树分类器报告已经运行了 8 分钟进行拟合和预测。
到目前为止，我们已经启动了一个节点来为我们做一些处理，请注意，我们已经从使用比家用笔记本电脑更强大的机器中获益。我们使用 sklearn 进行分析的代码现在在一台功能强大的计算机上运行了大约 12 分钟。
虽然这个集群在分布式计算领域还没有做太多工作，但我们已经做好了基础工作，可以看到 Spark 在发挥作用。我在这里提到过几次 Spark，在下一篇文章中，我将最终展示这个框架在我们用决策树探索的相同数据上的实际应用。
迄今为止的总成本
我想在这里停下来谈一谈成本。实践和磨练 AWS 技能的最大摩擦点之一是这样一个事实，即在大多数数据科学信息和技能都是免费的(来自 Kaggle 的免费数据集，Python 和 R 等免费编程工具)的世界中，AWS 需要花钱，而且直到第二天收到账单时才完全清楚要花多少钱。
在学习和尝试正确设置的过程中，我已经旋转(设置)并拆除了 100 多个集群，到目前为止，我的总账单是注册 AWS 大约 1 美元，加上所有这些集群不到 5 美元。到目前为止，我便宜的账单很大程度上是因为我的每个“集群”中只有一个实例(--instance-count 1)，并且我使用类型为m5.xlarge的集群练习了大多数旋转和拆卸。我把数据帧的尺寸缩小到原型，最终只在m5.2xlarge上做了原型。
端到端 AWS 定量分析:设置我们的脚本和 AWS
照片由energepic.com从派克斯拍摄
建设 AWS 管道
机器学习关注的是如何理解大量难以处理的数据。很大一部分机器学习工作现在可以在台式机上完成，甚至可以在笔记本电脑上完成，只要配置合适。
尽管如此，仍有大量的工作需要在专业的云计算架构上完成，这些架构要在合理的时间内处理难以置信的大量数据。
在这篇文章中，我想重点介绍建立端到端管道的想法，这将利用亚马逊网络服务(AWS)进行量化交易。
这篇文章的目的不是为您提供一台印钞机，而是展示在 AWS 上部署全自动工作流所需的步骤。
这组帖子将把工作流程分为四个主要部分:
- 编写脚本来获取数据，在数据上使用基本的 ML 模型，并将这些脚本存放在 AWS 上
- 为我们的基本 ML 模型建立一个 AWS 框架，并自动使用它
- 通过 Spark 利用我们的 ML 功能
- 在我们的 ML 完成运行后，自动准备我们的分析摘要
获取数据
因为我们对股票的历史数据感兴趣，所以有几种选择。Quandl 是一项可以提供每日股票数据(以分钟为单位)的服务，但它需要付费。对于这篇文章，我将选择免费选项，并使用雅虎财经。
哈哈。Finance 有几个库被设计成通过它的 API 与它交互，并建立到 Python 的桥梁，所以我将使用 yfinance 。
如果我们使用 yfinance，我们可以构建以下代码
虽然这段代码完成了工作，但是到目前为止，它只针对一个独特的用例场景:
- 它只获取 AAPL 的数据
- 并且只在特定的日期范围内这样做
我们也许应该把它包装成一个函数，这样我们就可以使它稍微更通用一些
现在，我们需要一些方法来获取相关的日期，并使其适用于雅虎上的任何资产！金融。
计算开始和结束日期
让我们从简单的部分开始，开始和结束时间。我们可以很容易地得到今天的日期，然后找到五年前的日期。然后，我们可以很容易地将两者转换成适当的字符串类型。
>>>> 2020-02-13
>>>> 2015-02-13
我们可能也应该将它封装成一个函数:
当我们获得数据时进行处理
获得数据后，我们想对它做一点处理，为机器学习做准备。
首先，我们将在数据框中添加一个Return字段，记录当天的回报是否为正。
我们可以计算连续收盘价之间的差值，也可以计算同一天的开盘价和收盘价之间的差值。我选择后者，只是为了让人们意识到这也是一个可以考虑的选择。
一旦我们得到了回报，我们就可以创建一些特性，并在以后为我们的 ML 算法创建一个目标。让我们把那些也加上
把所有的放在一起
这部分代码的最后一部分是将我们编写的所有代码放入一个脚本，该脚本接受我们的股票 id 和一个路径作为命令行参数，并将股票数据帧保存到提供的路径中。我们将添加更多的文档来创建更易于管理的代码库。
我们将把这个脚本称为“获取数据”
获取数据
我们已经添加了相当多的 docstrings 和其他文档，以防我们以后想要更改某些内容。
现在我们可以称这个脚本为:
python obtain_data.py MSFT --output_directory \ /usr/boris/destination
让它获取微软(MSFT)的数据，并将结果写入/usr/Boris/destination/msft . csv 中的本地 CSV 文件
处理数据
在我们获得数据之后，我们想要以某种方式处理它。出于本教程的目的，我们将假设我们想要使用一个决策树来使用我们之前创建的Target列对我们的数据进行分类。我们将从使用 sklearn 的决策树分类器开始。
>>> 0.0002604
很明显，对于这种规模的数据集，我们真的不需要 AWS。我们可以做一点小手脚，用下面的代码让数据集变大:
现在，数据集的大小最终达到 41，222，144 行，在我的笔记本电脑上处理大约需要 10 分钟。
我们将创建另一个 python 脚本，它接受一个文件位置作为命令行参数，将文件扩展为其原始大小的 2 倍⁵，然后处理它。在 AWS 上，我们将使用 sklearn 和 Spark 来比较处理时间。
流程 _ 数据. py
将脚本放在可访问的位置
我们希望 AWS 计算实例能够运行我们的脚本。我们可以做的一件事就是简单地使用 SSH 将文件传输到实例，但是稍后我们想让我们的实例自动设置、运行和拆除，而不需要我们做太多，所以我们将这些脚本放在 AWS 的 S3 存储桶中。这将使我们未来的计算实例可以轻松地访问该文件。
首先，我们需要创建一个 S3 桶(1)，并给它一个有用的描述性名称。创建完成后，我们可以在 S3 仪表板中看到它(2)。
创建 S3 存储桶
然后，我们将脚本上传到 bucket 中，以便我们的 AWS 实例可以访问脚本及其功能
上传我们刚刚创建的文件
此外，我们将设置另外三个存储桶；一个用于日志文件，一个用于数据文件，一个用于安装 bash 文件。我们最终的 S3 建筑应该是这样的:
我们做到了！
一个 python 脚本，可以在 AWS 上使用，为我们挖掘数据。下一步是创建一个运行脚本和处理挖掘数据的地方。下一篇文章将详细讨论这个问题！
EDA:变量关系和填充缺失值
初学者回归技巧
房地产预测的端到端回归技术-第 1 部分
作为我作为数据科学家旅程的一部分，端到端数据探索和模型开发是我学习成功的关键。这个系列将提供一个端到端的预测爱荷华州的房屋销售价格。为了便于阅读，本系列将分为四个部分:
- EDA 第一部分 : 标绘预热和填充缺失值
- EDA 第二部分 :特征工程和变量编码
- EDA 第三部分: 统计测试
- 预测建模: 训练和调优 XGBoost
- 堆叠模型 :结合 XGBoost 与 Enet、Ridge、Lasso
打开一个 Jupyter 笔记本， 下载数据 ，跟着自己实施以下策略。我已经包括了一些“练习”来帮助你。我隐藏了全部代码，以迫使你专注于思考过程。此外，通过自己把代码打出来，你会获得经验，最终会变得流利。不过，如果你一路上需要帮助，可以在这里 找到我的完整笔记本 。
如果你已经读过我的文章《 初学者看 Kaggle 》，你就知道接下来会发生什么:让我们用 EDA 来弄脏我们的手吧。这将是这个系列这一部分的唯一焦点。
住房价格的探索性数据分析
第一部分将主要关注基本绘图和缺失值插补。我的目标是概述一个建立直觉的过程，即哪些变量在起作用，哪些变量对销售价格有最大的影响。我还想评估变量之间的关系，因为这将让我们了解如何智能地填充缺失的数据。
我们在 4 部分系列中的数据探索重点如下:
- 直观地呈现数据 —对我们的数据进行图形化和绘图可以让人们洞察我们的数据在现实世界中的含义。我们有 79 个变量在发挥作用，所以这是一个很好的方式来感受正在发生的事情。然而，所有的可视化都应该持保留态度。他们没有讲述整个故事。
- 寻找和处理缺失数据 —在这一阶段，我们将分析哪些变量有缺失值，它们为什么缺失，以及我们可能如何处理缺失数据。
- 特征工程——我们能否在数据中找到并定义潜在的模式，帮助我们更好地描述和解决我们的问题？
- **实力的关联。**假设一个变量与销售价格相关，那么这种关系有多强？
- **分类变量对销售价格的 ANOVA F-检验。**与连续变量不同，我们不一定能确定类别和连续数据之间的传统相关性度量。通过方差分析或 ANOVA 分析，我们可以了解邻域等分类变量对连续变量销售价格是否有显著影响。
练习 1:** 注册一个 Kaggle 帐户，下载我们将使用的数据！我把我的数据保存在一个名为data的文件夹里，这个文件夹和我的笔记本在同一个目录下。
import pandas as pd
train_df = pd.read_csv('data/train.csv', index_col='Id')
test_df = pd.read_csv('data/test.csv', index_col='Id')
train_df.describe().T.head(10)
热身 1:目标变量的分布
为了开始了解我们的数据，我们将绘制我们的目标变量分布以及一些不同的转换。我们这样做有几个原因:
- 我们希望理解我们的数据，直观地查看数据有助于我们建立对影响结果的潜在因素的直觉。它让我们头脑中的轮子转动起来，并有希望激发可能带来有价值见解的问题。
- 转换变量的分布是常见的行业惯例。转型并不总是必要或有益的。数据转换有效性背后的数学理论很深入，并且经常被争论(特别是在深度学习领域)。只要说“视情况而定”，然后进行实验就够了！
在转换之前，我们的销售价格数据是右偏的，这意味着平均值比中值偏向更高的价格。通过sklearn.preprocessing.PowerTransformer()应用 Yeo Johnson 变换，我们得到了标准正态分布的一个非常好的近似值:
import sklearn.preprocessing as pre
import seaborn as sns
import matplotlib.pyplot as pltpt = pre.PowerTransformer()
ptd = pt.fit_transform(train_df.SalePrice.to_numpy().reshape(-1,1))
plt.title(f'Yeo Johnson, Skew: {stats.skew(ptd.squeeze()):.3f}')
sns.distplot(ptd, kde=True)
我还使用对数变换进行了检验，但我们无法接近正态分布:
这些转换改变了数据的含义(注意横轴上缺少“销售价格”标签)。转换目标变量的主要目的是希望辅助机器学习算法的训练。同样，这需要实验，直到本系列的第 3 部分才会涉及。
热身 2:检查基本直觉
作为我们的第二个热身练习，让我们来检验一下我们的直觉:对最终销售价格起作用的不仅仅是数量，还有质量:
fig, axes = plt.subplots(2,2, figsize=(12,12))
sns.scatterplot(
x='GrLivArea',
y='SalePrice',
hue='OverallQual',
data=train_df, ax=axes[0,0])...plt.tight_layout()# Try reproducing the plot below using the above code as a hint.
在第一栏中，我们将销售价格与地上居住区(又名 GrLivArea) 的价格以及房屋建筑材料的整体质量进行了比较。我们所看到的是，销售价格是根据居住面积和质量来分级的。这在散点图中的强线性趋势、色调的均匀分级以及总体质量的箱线图中是明显的。
有点令人惊讶的是，我们看到描述总体状况的变量，**总体成本，**似乎对销售价格几乎没有影响。第二个散点图中数据点的色调是随机的，箱线图是无序的。这是反直觉的，我们可以稍后再去探究我们所看到的是否有意义。
另外，请注意数据中的两个异常值。在散点图中可以看到两处住宅，它们的居住面积都很大，但相对于其他同等面积的住宅，它们的售价却非常低。
*** * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 练习 2:** 调查你对其他变量的直觉以及它们与销售价格的关系，并绘制出它们之间的关系。看看 Seaborn 的绘制关系的伟大工具。**** * * * * * * * * * * * * * * * * * * * * * * * * * * * ****
处理缺失数据
我们的下一轮分析将关注我们缺失的数据。我们想知道数据丢失的原因，以及我们如何填补空白。丢失的数据是丢失了可能对我们有用的信息。为了更好的预测，尝试填补这些空白通常是值得的。
训练集中缺少数据:
首先，我们将解决我们缺少的训练数据中的缺口。我写了一个小函数来可视化一个数据集中缺失的数据。在我的完整笔记本中寻找一个叫做viz_missing(df)的方法:
柱状图显示了大量缺失的数据。如果我们想得到真正好的结果，就不应该忽视这些数据。过程的这一部分是乏味的，但却是必要的。我鼓励你关注以下思考过程:
- 选择一个希望填充缺失数据的变量。
- 看看是否有另一个变量，与你正在研究的变量有关。
- 确定缺失的数据是否可以用相关变量来解释。
- 如果使用步骤 2 和 3 无法确定缺失的信息，请考虑使用平均值、中值或众数。请注意，这对小数据集来说可能是危险的。
示例 1:缺少池质量数据
上图中缺失数据量最大的变量是PoolQC，代表“池质量和条件”。
在查看了我们的数据字典之后，我们应该注意到只有一个其他变量描述了一个家庭的游泳池。这个变量就是PoolArea。请注意，没有与该变量相关联的缺失数据。
我的直觉是，所有有PoolArea = 0的家庭可能与缺少PoolQC信息的家庭相关联。换句话说，这些家庭没有游泳池，这就是为什么他们遗漏了游泳池质量变量。我们可以用几行代码来检验这种直觉:
*# Get number of homes with missing PoolQC that also have 0 PoolArea.
np = train_df[train_df.PoolQc.isna() & (train_df.PoolArea == 0)]
count = np.shape[0]# Get total number of missing PoolQC entries
missing = train_df.PoolQC.isna().sum()count, missing
>>> (1452, 1452)*
因此我们看到，对于所有 1452 个缺少PoolQC条目的家庭，该家庭的PoolArea为 0。这证明我们的直觉是正确的。我们可以用多一行代码来填补空白:
*train_df.PoolQC.fillna("NA", inplace=True)*
示例 2:缺少地段临街面
LotFrontage根据数据字典，是与物业相连的道路的英尺数。这次我们没有任何额外的变量来告诉我们为什么LotFrontage会丢失。这意味着我们将不得不以不同的方式填补空白。
我们可以合理地假设，几乎每一块地产都至少触及某条道路或小巷的一小部分。这可能不是普遍正确的，但可能是规则而不是例外。我们将利用这种直觉，用我们拥有这些数据的所有房屋的平均值或中值来填充任何缺失的LotFrontage:
*train_df.LotFrontage.fillna(train_df.LotFrontage.median(), inplace=True)*
我选择用中值来填充缺失的条目，因为它对异常值更稳健。
**** * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 练习 3:** 对测试集和训练集中的所有缺失数据执行相同的调查。你应该需要一段时间。很多都不见了！
我将在本系列的第 2 部分结束。完成练习 1-3 需要花费你相当多的时间，我们鼓励你在继续之前先把这些练习编码好。
如果您有任何问题、意见或批评，请在评论区联系我！
基于能量的模型和生成算法的未来
苹果 | 谷歌 | SPOTIFY | 其他
Will Grathwohl 在 TDS 播客
背景图片由艾哈迈德·迪里尼
编者按:迈向数据科学播客的“攀登数据科学阶梯”系列由 Jeremie Harris 主持。Jeremie 帮助运营一家名为sharpes minds的数据科学导师初创公司。可以听下面的播客:
研究生院中的机器学习和工业中的机器学习是非常不同的东西。在行业中，部署和数据收集变得很关键，唯一重要的是你是否能以足够快的速度交付真正客户想要的产品，以满足内部期限。在研究生院，有一种不同的压力，集中在算法开发和新颖性上。通常很难知道你最适合哪条道路，但这就是为什么与两者都做过的人交谈会如此有用——如果他们的学术研究经验来自世界顶尖大学之一，还会加分。
在今天的《走向数据科学》播客中，我采访了 Will Grathwohl，他是多伦多大学的博士生，谷歌人工智能的学生研究员，也是麻省理工学院和 OpenAI 的校友。Will 在行业和学术环境中看到了前沿的机器学习研究，并分享了一些关于这两种环境之间差异的深刻见解。他最近还发表了一篇关于能源模型这一迷人主题的文章，其中他和他的合著者提出了一种关于生成模型的独特思维方式，这种方式在计算机视觉任务中实现了最先进的性能。
以下是我们聊天中我最喜欢的一些带回家的东西:
- 在工业界，人们非常重视以最简单、最快的方式解决问题，使用现成的算法，而不是提出尖端的模型。部署和数据收集最终消耗的时间比您预期的要多，这可能会令人感到窒息——特别是如果您的角色碰巧更倾向于将模型投入生产，而不是从头开始训练它们。
- 然而，学术研究也有其自身的压力。除了发表论文的压力之外，学术机器学习的竞争越来越激烈，进入博士项目实际上仅限于已经在顶级期刊和会议上发表过论文的人。进入博士项目需要专注，并不适合每个人，所以在走上这条道路之前，认真问问自己是否愿意做出两年多的承诺来为他们定位是值得的。
- 两种最常见的机器学习模型是判别模型和生成模型，前者返回单个数字(如分类器或回归器)，后者产生新的输入(如图像生成模型，或某些语言模型)。生成模型特别酷，因为它们被迫学习足够多的数据来产生新的样本，而不仅仅是对它们进行分类。直觉上，这应该使他们在分类和回归任务中真正有效(因为你当然可以认为学习绘画的最好方法是创作新的绘画)。但这并没有发生:随着时间的推移，人们变得如此专注于生成现实的样本，以至于他们越来越少关注区分性应用程序的生成模型的最初承诺。
- 威尔的最新研究提出了一种关于生成模型的强大的新思维方式，这种方式使它们能够更有效地应用于区分性任务。他的团队展示了最先进的成果，我们在聊天中深入探讨了这项研究。
基于 python 和 LSTM 深度学习模型的能源消费时间序列预测
如何利用时间序列进行深度学习
戴维·赫尔曼在 Unsplash 上的照片
本文的目的是向读者展示 python 中的一个类，该类具有非常直观和简单的输入，可以使用深度学习对时间序列数据进行建模和预测。理想情况下，读者应该能够复制本文或 GitHub 资源库中的代码，根据自己的需要对其进行裁剪(例如，向模型中添加更多层),并在工作中使用它。
本文中使用的所有代码都可以在这里找到:
【https://github.com/Eligijus112/deep-learning-ts
这篇文章的数据可以在这里找到:
https://www.kaggle.com/robikscube/hourly-energy-consumption
用于深度建模的包是 TensorFlow 和 Keras。
时间序列是按连续顺序排列的数字数据点序列。这些点通常定期测量(每月、每天、每小时等)。).本文中使用的数据频率是每小时一次，测量时间是从 2004 年 10 月 1 日到 2018 年 8 月 3 日。原始数据点的总数为 121271 。
Python 中的时间序列示例
时间序列的可视化:
能源消耗时间序列的折线图
对于给定的时间序列，深度学习算法的主要目标是找到函数 f ,使得:
Yₜ = f(Yₜ₋₁，Yₜ₋₂，…，Yₜ₋ₚ)
换句话说，我们希望基于相同能耗的 p 滞后估计一个解释能耗当前值的函数。
这篇文章不是要解释为什么长期短期记忆(LSTM)深度学习网络有利于时间序列建模或它是如何工作的。有关这方面的资源，请查看以下精彩文章:
数据只能反向理解；但它必须向前看。-索伦·克尔凯郭尔，期刊*
pathmind.com](https://pathmind.com/wiki/lstm) [## LSTM 和 GRU 的图解指南:一步一步的解释
嗨，欢迎来到长短期记忆(LSTM)和门控循环单位(GRU)的图解指南。我是迈克尔…
towardsdatascience.com](/illustrated-guide-to-lstms-and-gru-s-a-step-by-step-explanation-44e9eb85bf21)
有关 Keras 中 LSTM(或任何 RNN 图层)的实现，请参见官方文档:
用于递归层的 keras . engine . Base _ layer . wrapped _ fn()基类。Arguments 单元格:RNN 单元格实例。一个 RNN 细胞…
keras.io](https://keras.io/layers/recurrent/)
首先，我们需要读取数据:
读取每小时数据的代码示例
然后我们需要一个函数，将时间序列转换成 X 和 Y 矩阵，供深度学习模型开始学习。假设我们想要创建一个使用 3 滞后解释当前时间序列值的函数:
Yₜ = f(Yₜ₋₁，Yₜ₋₂，Yₜ₋₃)
我们有这样的数据:
ts = [1621.0, 1536.0, 1500.0, 1434.0, 1489.0, 1620.0]
我们想要创建两个矩阵:
X = [
[1621.0, 1536.0, 1500.0], # First three lags
[1536.0, 1500.0, 1434.0], # Second three lags
[1500.0, 1434.0, 1489.0], # Third three lags
]Y = [1434.0, 1489.0, 1620.0]
**这是对时间序列使用深度学习时最重要的技巧。**你不仅可以将这些 X 和 Y 矩阵提供给递归神经网络系统(如 LSTM)，还可以提供给任何普通的深度学习算法。
函数从时间序列中创建 X 和 Y 矩阵
深度学习模型有一个 LSTM 层(也用作输入层)和一个输出层。
定义 LSTM 深度学习模型
在我在互联网上搜索一个易于使用的时间序列深度学习模型的过程中，我看到了各种文章，这些文章将建模的几个部分分开，如如何定义模型，如何为模型创建矩阵等。我没有找到一个包或一个类，把所有东西都打包成一个易于使用的实体。所以我决定自己来做:
建模类
开始上课:
# Initiating the classdeep_learner = DeepModelTS(
data = d,
Y_var = 'DAYTON_MW',
lag = 6,
LSTM_layer_depth = 50,
epochs = 10,
batch_size = 256,
train_test_split = 0.15
)
该类的参数是:
数据 -用于建模的数据。
Y_var -我们要建模/预测的变量名。
滞后 -用于建模的滞后数量。
LSTM _ 层 _ 深度-LSTM 层中神经元的数量。
时期 -训练循环的数量(正向传播到反向传播循环)。
batch_size -深度学习模型在寻找参数时使用的梯度下降的数据样本的大小。所有数据都被分成 batch_size 大小的块，并通过网络传送。在每个 batch_size 的数据在模型中前进和后退之后，模型的内部参数被更新。
要了解更多关于时期和批量大小的信息，请访问:
随机梯度下降是一种具有多个超参数的学习算法。两个超参数…
machinelearningmastery.com](https://machinelearningmastery.com/difference-between-a-batch-and-an-epoch/)
train_test_split -用于测试的数据份额。1 - train_test_split 用于模型的训练。
拟合模型:
# Fitting the modelmodel = deep_learner.LSTModel()
在上面的命令之后，你可以看到球迷最喜欢的训练画面:
Keras 中模型的训练
用更多的滞后(因此，更大的 X 矩阵)训练模型增加了训练时间:
deep_learner = DeepModelTS(
data = d,
Y_var = 'DAYTON_MW',
lag = 24, # 24 past hours are used
LSTM_layer_depth = 50,
epochs = 10,
batch_size = 256,
train_test_split = 0.15
)model = deep_learner.LSTModel()
多滞后模型的训练
现在我们已经创建了一个模型，我们可以开始预测。使用用 p lags 训练的模型进行预测的公式:
Yₜ₊₁ = f(Yₜ，Yₜ₋₁，…，Yₜ₋ₚ₊₁)
# Defining the lag that we used for training of the model
lag_model = 24# Getting the last period
ts = d['DAYTON_MW'].tail(lag_model).values.tolist()# Creating the X matrix for the model
X, _ = deep_learner.create_X_Y(ts, lag=lag_model)# Getting the forecast
yhat = model.predict(X)
如果数据被分成训练集和测试集，那么 deep_learner.predict() 方法将预测测试集中的点，以查看我们的模型在样本外的表现。
yhat = deep_learner.predict()# Constructing the forecast dataframe
fc = d.tail(len(yhat)).copy()
fc.reset_index(inplace=True)
fc['forecast'] = yhat# Ploting the forecasts
plt.figure(figsize=(12, 8))
for dtype in ['DAYTON_MW', 'forecast']: plt.plot(
'Datetime',
dtype,
data=fc,
label=dtype,
alpha=0.8
)plt.legend()
plt.grid()
plt.show()
时间序列预测
正如我们所看到的，模型创建中隐藏的 15%数据的预测值接近真实值。
我们通常希望提前预测最后的原始时间序列数据。类 DeepModelTS 有方法 predict_n_ahead(n_ahead) 预测 n_ahead 时间步。
# Creating the model using full data and forecasting n steps aheaddeep_learner = DeepModelTS(
data=d,
Y_var='DAYTON_MW',
lag=48,
LSTM_layer_depth=64,
epochs=10,
train_test_split=0
)# Fitting the model
deep_learner.LSTModel()# Forecasting n steps ahead
n_ahead = 168yhat = deep_learner.predict_n_ahead(n_ahead)
yhat = [y[0][0] for y in yhat]
上面的代码预测了未来一周的步骤(168 小时)。与之前的 400 小时相比:
超出时间范围的预测
总之，本文给出了一个简单的管道示例，用于时间序列数据的建模和预测:
读取和清除数据(1 行 1 时间步)
选择滞后数量和模型深度
初始化 DeepModelTS()类
拟合模型
提前 n _ 步预测
我希望读者可以在他/她的专业和学术工作中使用本文展示的代码。
基于相对论引力理论的在线讨论参与动力学
当物理学在解决社交计算方面派上用场的时候
从物理和生物过程中进行类比在历史上被证明对计算机科学领域是有益的——神经网络、进化算法、社区增长模型等等。这种类比往往依赖于一些非常简单但有力的假设。这些类比中的科学严谨性应该被小心地提醒——大多数这样的类比实际上是“类比”,而不是对统一理论的主张。在本文中，我们将详细阐述“广义相对论的场方程”如何帮助建模在线讨论平台上的用户参与度。首先，我们需要定义我们要建模的参与动力是什么，以及革命性的场方程如何发挥作用。
用户参与度与引力
让我们从一个非常简单的用户参与讨论的模型开始。我们有一些用户数量固定的讨论平台。现在，一个随机的用户发布一些东西——一个观点，新闻，一个音乐视频，或者可能是一个讽刺的“模因”。并非所有用户都开始评论这篇文章；只有那些对帖子主题“感兴趣”的人才会加入讨论。然而，这种“兴趣”并不是一种静止的现象。随着时间的推移，特定的讨论可能会吸引以前不感兴趣的用户。
利用这个讨论平台的简单模型，我们可以从两个非常基本的假设开始:(I)用户居住在一个 n 维空间上的点上(并且在移动),使得近邻具有共同的兴趣；以及(II)讨论具有在不同程度上吸引不同用户的一些属性。第二个假设是，用户和讨论之间可以没有吸引力，但没有排斥。实际上，用户可能会对讨论感到“厌恶”,因此选择不参与。但是实际上不可能识别“排斥”(“不喜欢”或“否决”也是参与)，除非用户明确这样说。
这两个假设反映了讨论平台和引力场之间惊人的相似性。人们可以想象一个讨论具有某种“质量”性质，它会随着时间而变化。这个质量在 n 维用户空间的不同点产生了一些“引力”,根据引力的大小，用户会来到那个位置。为了更详细地计算质量和拉力，我们需要重温一下重力实际上是如何工作的。
图一。存在大质量物体和光的引力弯曲时时空流形的曲率:红线表示光线的实际弯曲运动，而虚线表示不间断的路径(来源:http://www . zamandayolculuk . com/cetin bal/htmldosya 1/relativity file . htm)。
爱因斯坦场方程
到目前为止，阿尔伯特·爱因斯坦在他的广义相对论中给出了对引力最精确的描述。著名的爱因斯坦场方程将引力描述为“时空的弯曲”。在这里，空间(3 维)和时间(1 维)不是独立的实体；相反，它们构成了时空(四维)的复杂混合体。任何质量-能量-动量的存在都会在时空的几何中产生一个曲率，结果，任何移动的物体都会弯曲它的路径(被拉着)(见图 1)。场方程是:
不进入严格的数学细节，上述等式的左侧对应于流形的曲率，而右侧对应于能量-动量密度。
从用户交互到用户时空
因此，如果我们想开发一个类似的用户参与模型，我们需要做的第一件事就是定义用户到一些固定维度点(向量)的映射。这种映射应该保持我们的第一个假设，即共同感兴趣的用户必须保持密切联系。为了从数学上定义“共同兴趣”，我们可以在一对用户之间分配三种类型的接近度:
I)交流接近度:用户已经回复了彼此之前的评论或帖子；II)时间接近度:用户在最近的时间内对同一讨论发表了评论；III)语义接近度:用户评论了语义相似的帖子。
这三种邻近性加在一起，为每一对用户分配一个聚合邻近性(或共现)值。现在，如果我们用一个 n 维向量来表示每个用户，使得他们的标量积与他们的接近度成比例，我们就得到期望的用户空间。与时间值连接，这产生了用户时空。
从讨论中获取能量
下一个任务是将讨论表示为随时间变化的能量函数。在论坛中，讨论是否会吸引用户取决于各种特征——讨论的主题、帖子和评论中表达的观点的极性、文本的可读性、不同的词语用法以及发表评论的用户。我们可以学习一个参数化的非线性函数，它将这些特征映射到固定维度的向量(在这种情况下，维度必须与用户时空相同)。这种表示将初始化应力-能量张量的对角元素， Tμv.
把所有的碎片放在一起
我们为简化参与度建模问题所做的最后一个假设是，用户在共同兴趣的基础上形成自然集群。因此，我们将用户空间划分为集群，并预测每个时间段内来自特定集群的用户对给定帖子发表评论的概率。聚类中心被认为是聚类的位置向量。我们建立了一个学习计算度量张量的模型
从集群位置和应力-能量张量的讨论特征。对于不同时间间隔的给定讨论，这两个张量的组合将给出每个集群中心的用户时空的曲率。现在，我们可以比较这些曲率来决定哪些集群更有可能是接合集群。
应该记住的是，这个简单的模型并不声称在线讨论平台遵循广义相对论。相反，它将用户交互历史与讨论的文本特征相融合，非常类似于广义相对论如何提供重力的整体定义，将能量密度与时空几何相融合。
研究的细节可在 https://arxiv.org/pdf/1908.03770.pdf 获得
这就是查克拉博蒂。使用相对论引力理论对在线讨论的参与动力学进行建模，第 19 届 IEEE 数据挖掘国际会议 (ICDM)，中国北京，2019 年 11 月 8 日至 11 日。
设计多层感知器
数字神经数学简评
作者绘画
在这篇文章中，我将简要地概述从左边图像中描述的单层感知器到右边图像中描述的多层结构的数学发展；现在被称为*神经网络:*现代人工智能的基础单元。
要深入了解感知机发展的历史和社会影响，请阅读迈克尔·伊比的内核连接:感知机图解。
Theano、TensorFlow、Keras、py torch——每一个都提供了让深度学习更容易获得的资源。我花了很多时间处理这些模块。然而，有时我会忘记数学上到底发生了什么。每个库都有自己的语法。我发现每一种语法的透镜形成了我对架构如何通过功能处理信号的概念化，例如:向前和向后传播；或者如何应用激活。像任何实用程序库一样，有许多元素被整齐地打包并存储在引擎盖下。让我们打开其中一些工具。
使用 Keras 和玩具数据集作为基线。
用玩具数据集展示 keras 建筑的笔记本
也许我厌倦了，但那太容易了。这可能只是让一个模型运行起来的一个练习，但是在设计一个模型的时候，你应该练习的不仅仅是你的打字速度。下面是一个笔记本，我在其中获得了相同的数据集 raw，并能够产生更好的分数，从数据中获得更多洞察力，以及将定制功能设计到从 Numpy 构建的定制多层感知器。
笔记本走过预处理和训练 Senti_Net
后退一步
我们如何到达这里？我们如何把感知器这样的东西作为简单的逻辑算子，发展成深度学习模型？
什么是感知器？
感知器是一个线性的二进制分类器。它找到了两个阶级之间最清晰的界限。为了实例化更直观的描述，感知器能够感知两个给定类之间的差异，并检测给定数据点属于哪个类。它能够感知将一个数据点与另一个数据点线性分离的代表性空间。
作为逻辑运算符
逻辑运算符是控制信号流的函数。产生二进制输出的主要逻辑运算符有三种。
- 和
- 运筹学
- 不
在程序设计中，一个逻辑运算器将一个多输入信号通过线性激活处理后，解析成一个合成的单一输出。如果您的数据是图表上的一个点，这尤其有用；比如图上的(3，4)。(3，4)是一个身份，是一个位置。感知器可以评估该点的位置，并区分身份属于哪个类别。再次假设类属性是线性划分的。
逻辑运算符如何工作
和
并且是真值运算符。并且只有当两个输入都为真时才为真。换句话说，如果 A 和 B 都是 1，AND 运算符只会产生 1。如果 A =1，B =0，那么结果=0。这意味着，在 1 和 0 之间的四个可能结果中，只有一次是真的:当两个点都是 1 时。
运筹学
OR 是 AND 的反义词。除非两个操作数都为 0，否则 OR 始终为真。这意味着 A = 1，B = 0 为真。此外，A = 0 和 B = 1 也成立。A = 1 和 B = 1 是三次，真！只有 A = 0 和 B = 0 是假的。
而 AND 只有 25%的时间是正确的，或者 75%的时间是正确的。
不
没有什么是简单反向投资。如果 A 和 B = 1，那么 NOT = 0；如果 A 和 B = 0，那么 NOT = 1。
*下一个笔记本里有每个操作员的直接例子
感知器是第一个为模拟生物、神经功能而开发的算法和硬件实例。然而，大约 20 年后，在 80 年代，人们普遍意识到，感知器在解释任何不适合其线性受体的数据方面严重不足。现实是多维的，非线性的。
此外，感知器正确地指出，单层感知器无法分类非线性模式；它的分类能力仅限于线性可分的模式。在欧几里德几何中，线性可分性是指将两组数据聚类成 A 和 B 区域。这最容易用二维平面来形象化。如果一条线或决策面能够将数据整齐地分为 A 和 B，则该模式被认为是线性可分的。如果数据分布不是如此清晰地界定，模式被认为是非线性的。
迈克尔·伊比
步进到乙状结肠
感知机发展的另一个重要观点是:不仅有 0 和 1，而且在 0 和 1 之间有无限的连续可能性。通过 sigmoid 和 sigmoid 导数的识别，感知器能够生成类的可能性，以及更新感知器在可能性预测中的置信度。
下面的笔记本给出了逻辑运算符的例子，并演示了 sigmoid 的实现。此外，它显示了如何在反向传播中使用 sigmoid 的衍生物。
从单层感知器到多层感知器的逻辑
让我们使用上面笔记本中的函数更仔细地看看梯度下降的过程。
每个时期的更新是如何发生的
现在让我们更仔细地看看 SENTI_NET 的架构，情感分类多层感知器。
感觉网
我们可以看到，Senit_Net 不仅仅是一个 MLP，它还有一个文本预处理单元。虽然这可以在外部完成，但我想构建专门处理文本的模型。Senti_Net 是硬编码的，只能辨别积极和消极情绪，但可以在任何带标签的文本数据上进行训练。我们可以在笔记本的末尾看到，利用一个经过训练的 Senti_Net，在传递它从未见过的政治推特的文本数据后，它能够准确地对情绪进行分类。
在我建立 Senti_Net 之后，我想看看我是否可以制作另一个二元分类器，但我没有将情绪分类为*【正面】或【负面】*，而是让 MLP 对一条推文是来自民主党还是共和党进行分类。结果可以在下面的笔记本中找到。
** Twitter 数据由来自*的推文组成
- 乔·拜登
- 巴拉克·奥巴马
- 伯尼·桑德斯
- 希拉里·克林顿
- 迈克·彭斯(都是@Mike_Pence 和@VP 手柄)
- 唐纳德·特朗普
- 肖恩·哈尼蒂
*从每个账户——从 4 月 21 日星期二开始——按时间顺序回顾，提取了 3000 条推文
Tw 网分类推文是来自民主党还是共和党
Tw 网表现还不错！将这两个模型加在一起，你就可以探究每一方推文的情绪。
这个练习的目的是激发人们对深度学习图书馆的好奇心。我们经历了一个简单的 MLP，但是现在问问你自己 CNN，或者 RNN 在数学上是如何表现的。是什么样的复制过程使变得智能？例如，MLP 的数学正在复制识别的过程。感知这个和那个之间的能力。人工智能有时可能看起来超凡脱俗或神奇，但当人们密切关注时，人工智能不仅揭示了数学的美，还揭示了人类如何使用数学作为表达我们大脑内部过程的交流工具的美。
数据科学项目的工程最佳实践
让您的数据科学项目更加可靠、可测试和可部署
乔恩·泰森在 Unsplash 上的照片
介绍
在本帖中，我们将学习一些最佳实践来提高生产数据科学代码的质量和可靠性。
注意:这里提到的大多数东西对软件工程界来说并不陌生，但是在数据科学的实验世界中，它们经常被忽略/错过。
在这篇文章中，我将简要地提到一些主题和我们可以做的事情，以使我们的项目更加可靠，我将创建一些后续文章，使用一个项目示例来更详细地描述这些步骤。此外，在这篇文章中，我将假设一个 Python (pyspark)数据科学项目，但是这些想法可以应用于任何其他编程语言或项目。
希望你觉得有用。
代码重构
这是拥有更好代码的第一步。它是简化现有代码设计而不改变其行为的过程。
数据科学项目大部分时间都写在 jupyter 笔记本上，很容易失控。强烈建议在将代码投入生产之前进行代码重构。
解决的问题
- 提高代码可读性——让我们的团队更容易理解
- 降低复杂性——更小、更易维护的功能/模块
行动项目
- 将代码分解成更小的函数
- 注释功能
- 更好的命名标准
- 移除未使用的代码位
单元测试
单元测试是一种测试代码中每个功能的方法。目的是验证代码中的每个函数都按预期执行。
在数据科学项目中，测试几乎总是被忽略。您的项目中有一些部分可能不需要测试用例，但是在一个项目中，有许多其他组件可以很容易地进行单元测试。
例如，模型评估是在实验阶段完成的，我们可能不需要在单元测试中再次测试，但是数据清理和数据转换是绝对可以进行单元测试的部分。
解决的问题
- 这有助于尽早修复错误
- 它有助于新手理解代码的作用
- 支持快速代码更改
- 确保不良代码不会合并到
行动项目
- 创建接受所有必需参数作为参数的函数，而不是在函数内进行计算。这使得它们更容易测试
- 如果函数读取函数中的 spark 数据帧，请更改函数以接受数据帧作为参数。然后我们可以传递手工制作的数据帧来测试这些功能。
- 我们将为每个功能编写一系列单元测试
- 我们将使用 python 框架，如 unittest、pytest 等。对于单元测试
- 测试将是代码库的一部分，将确保没有坏代码被合并
- 我们的 CI/CD 管道将进一步使用这些测试来阻止不良代码的部署
集成测试
集成测试将系统作为一个整体进行测试。它检查所有功能组合在一起时是否工作正常。
很多时候，项目会依赖外部系统，例如，您的 pyspark 代码可能会向 Cassandra 读取/写入数据。我们可以创建集成测试，将整个项目作为一个单元进行测试，或者测试项目在外部依赖下的表现。
解决的问题
- 它确保整个项目正常运行。
- 它检测与多个模块协同工作相关的错误。
行动项目
- 我们将创建一个本地基础设施来测试整个项目
- 外部依赖可以在 Docker 容器上本地创建
- pytest 或 unittest 等测试框架将用于编写集成测试
- 代码将根据本地基础设施运行，并测试正确性
代码林挺
在 jupyter 笔记本上编写项目本质上并不遵循最佳的命名或编程模式，因为笔记本的重点是速度。林挺帮助我们识别 python 代码中的语法和风格问题。
解决的问题
- 它有助于检测样式错误
- 强制更好/最佳的写作风格
- 检测结构问题，如使用未初始化或未定义的变量
- 让代码更容易使用
行动项目
- Flake8 或 black 将用于检测逻辑和代码风格的最佳实践。
- 下一步，Lint 测试将被集成到 CI/CD 中，以使基于不良写作风格的构建失败
代码覆盖率
代码覆盖率帮助我们发现我们通过测试用例测试了多少代码。这是一个很好的质量指示器，可以告知项目的哪些部分需要更多的测试。
解决的问题
- 监控测试了多少代码。
行动项目
- 像 coverage.py 或 pytest-cov 这样的工具将用于测试我们的代码覆盖率。
GitHub 回购分支机构权限
我们将设置权限来控制谁可以读取和更新 Git repo 分支中的代码。这将保持我们的主(部署分支)干净，并强制基于拉请求+构建测试的过程将代码合并到主中。
此外，强制同行评审过程和自动化测试可以确保我们的代码库中有更少的错误合并，并且其他团队成员会意识到项目中合并的变更。
解决的问题
- 主人总是干净的，随时可以部署
- 强制最佳实践—拉式请求+自动化构建测试
- 将避免意外删除分支
- 避免不良代码在主服务器上合并
行动项目
我们将使用以下内容设置分支设置:
- 主分支不允许重写分支历史记录
- 没有拉取请求，我们不能在 master 中直接合并代码
- 将代码合并到主代码至少需要 1 次批准
- 只有当所有自动化测试用例都通过后，代码才会合并
分支上的自动化测试执行
当我们的拉请求被创建时，在合并之前测试它以避免破坏任何代码/测试是一个好主意。
解决的问题
- 自动运行测试
- 避免不良代码在主服务器上合并
行动项目
- Github 上的 CI/CD 设置。
- 任何新的分支代码推送都应该触发自动测试
- 应该在创建拉请求时触发自动测试
- 如果所有测试都是绿色的，则将代码部署到生产环境中
监控和警报
这是软件工程世界中非常重要的一步，但是对于数据科学项目来说，几乎总是被跳过。我们将监控我们的工作，如果代码中出现运行时错误，我们将发出警报。
取决于你的项目是否仅仅是做预测，你可能不会非常广泛地发出警报，但是如果项目与几个系统对话并且处理大量的数据/请求，从长远来看，进行监控将会使你的生活变得容易得多。
解决的问题
- 更多的可见性，而不是黑盒代码执行
- 监控输入和输出处理统计
- 监控基础架构可用性/依赖性
- 过去运行失败/成功趋势
- 当 ML 管道失败/崩溃时提醒我们
行动项目
- 如果您有一个监视工具(强烈推荐)—将输入/输出统计数据的事件发送到监视器
- 如果没有可用的监控工具—在日志文件中记录所有重要的统计信息。
- 如果没有监控工具——我们可以将重要的跑步统计数据添加到数据库中，以备将来参考
- 构建 Slack/微软团队集成，提醒我们管道通过/失败状态
就这样
这个帖子到此为止。希望这些是有用的提示。请分享您的想法和应用于数据科学项目的最佳实践。
原载于 2020 年 11 月 7 日【https://confusedcoders.com】。
工程和数据科学@ travel triangle——构建复杂且可扩展的假日市场(第一部分)
本博客讨论了由我们的工程和数据科学团队开发的通用和可扩展框架，并让您对工程指南和 culture @ TravelTriangle 有所了解
TravelTriangle 假日产品景观
TravelTriangle(TT)是一个在线度假市场，它将旅行者与多家当地旅行社联系起来，帮助他们打造一个定制的难忘假期。
假期是一个复杂的实体，涉及许多活动的部分。它包括最终确定目的地、城市、航班、酒店、活动、观光、出租车、日期、预算、公司、代理商。对于不同的人来说，所有这些终结都以不同的顺序发生。对于一些预算的最终确定是第一位的，对于其他活动的最终确定。在每一步，都有多个因素参与最终确定。旅行者、代理商、旅游顾问等多个参与者以及多种产品和电话互动增加了额外的复杂性。
由于问题的多方面复杂性，在过去的几十年里，假日销售一直通过电话、电子邮件进行，因为这对旅行社来说是一个非常主观的销售过程。
在 traveltriangle，我们一直致力于为旅行者创造最佳的度假计划和预订体验
技术愿景和通用框架
你可以在此阅读我们解决这一复杂旅游生态系统的整体产品愿景。多个 B2C 和 B2B 产品线(当前和未来)促使我们尽可能地让我们的技术架构松散耦合、高度可配置和有效重用。
此外，作为首席技术官，我一直认为，技术团队应该尽可能地致力于更新的东西，而不只是忙于增强已开发的东西，只是一个功能一个功能地增加。这也有助于我们节俭地开发东西，保持最高的效率，不损害质量，反过来，让非工程团队能够快速移动，并且也是用最少的技术带宽(因为它相当昂贵:)。
考虑到这一点，我们总是将一组功能组合起来，首先在更大的框架上理解，这应该能够无缝地在顶部实现更多的功能，而不需要在每个功能出现时构建它们。事实上，该框架应该可以轻松地扩展到类似的其他产品线。
…通过适当的设计，这些功能很便宜。这种方法是艰巨的，但不断取得成功。—丹尼斯·里奇
以下是我们的工程和分析团队迄今为止构建的几个通用框架，以便灵活高效地实现我们的产品和技术愿景:
可配置和实验框架(CERE)
实现我们的产品愿景的第一步也是最重要的一步是，我们的产品团队如何推出足够多的实验/变化，分析数据并不断搅动实验，以快速排除故障，而不会陷入技术带宽和/或发布周期。实验可以围绕优化当前以及为旅行者和代理商测试新的页面和/或产品流。此外，迫切需要了解用户的心理，通过使用高级 ML 算法的详细数据理解，将他们聚集在一个或另一个细分市场中，并在此明确或派生意图的基础上，触发/测试多种行动，以使旅行者和代理之间的规划周期更快、更有效。
我们设计了一个早期实验方法( blog here )，以使团队能够发布和测试处理高频率用例的新变体。然而，这种方法不能扩展到其他用例，其他用例的频率正在增加，而且，一旦我们在 React+Redux 堆栈上移动页面，这种方法就停止工作了。我们开始在启用实验的任何页面加载上获得闪烁效果。为了避免闪烁，我们搜索了许多解决方案，然后我们在 Nginx、varnish 和我们自己开发的动态 UI 框架的帮助下构建了自己的解决方案，该框架使任何页面都可以拾取组件以及组件中的数据，以动态呈现整页。该框架对于我们的移动和桌面平台是通用的。对于这款应用，由于应用内页面渲染的细微差别，我们不得不做一些调整(完整的博客在此)。
借助 GTM、用于基本 HTML 更改的 VWO 以及与 varnish 和 Nginx 集成的内部动态 UI 框架，我们能够让产品团队测试不同种类的动态生成的前端页面，并运行 A/B 测试以更快、更客观地获得结果。
然而，我们还没有完全达到目标。同样的方法/工具不能用于后端工作流。为了解决这一挑战，我们首先将我们的架构转移到基于事件，这样我们就可以轻松地配置和控制触发器，并在其上关联所需的操作。我们使用 Kafka 在发布/订阅模式上开发了自己的事件流。我们进一步使其可配置和 A/B 测试友好，为此我们在规则引擎和事件驱动架构上开发了 CERE(可配置实验和规则引擎)，让产品团队在不需要技术带宽的情况下随时调整和测试不同的后端工作流。
在这一点上，我们的框架已经很好地建立了快速实验，前端和后端的动态流程。利用这一点，我们的产品团队能够改变我们的产品页面和工作流程，引导分配流程，使用不同的沟通渠道等。等等。不需要任何技术带宽和/或发布周期。
面向松散耦合和经济高效的可扩展性的微服务设计
我们的每条产品线(B2B 或 B2C)都会有不同的技术差异和规模增长。例如，面向旅行者的浏览页面需要以极快的速度显示丰富的数据和内容，而事务性页面需要在信息方面更加可靠和一致。内部服务的报告量更大，需要更快的大数据处理，以便团队能够利用实时数据进行分析和决策。需要第三方库存或支付提供商集成的其他系统甚至会有更多不同的细微差别和规模。
资料来源:Oracle.com
微服务方法是我们的大救星。我希望我们一开始就采取了这种方法，但迟到总比不到好。每种服务在各自的方面都有不同的扩展，需要不同的基础设施、不同类型的数据库以及遵循不同的开发指南。此外，它甚至给了我们很大的优势，让我们可以在近期或长期需要更高并发性的地方，从 RoR 到 Golang 重写我们的一些服务。此外，我们能够轻松地从 MySQL、MongoDB 和 Redshift 中选择不同的 SQL/NoSQL 数据库。
当我们大约在 2-2.5 年前开始转向微服务架构时，我们的大多数团队成员都是开发微服务的新手，虽然这看起来非常有利可图，但它也有自己的缺点。
- 我们必须认识到这样一个事实，我们不是为了中断而分解服务，而是只在必要的时候分解服务。
- 工作流变得越来越复杂，单个事务现在可能跨越许多服务，并需要更精细的状态和状态转换。
- 回滚和数据不一致也需要注意，因为现在有多个数据存储。
- 从测试和部署的角度来看，QA 和 DevOps 团队需要分别发展他们的测试和 CI/CD 方法。
- 此外，我们必须确保服务发现和服务间通信顺利进行，同时服务本身具有弹性，断路器得到有效使用。
- 除此之外，还有对通用服务的迫切需求，如认证/授权、API 网关、服务注册等。开始出现(我们仍在通过在原始整体层本身上创建立面层来构建相同的和当前创建的工作区)。
也就是说，从 monolith 转移到微服务在一开始看起来开销很大…😃)更不用说，服务器成本的急剧增加，但是，你会在不久的将来看到结果。它将在开发、可伸缩性、故障处理、更好的团队责任分离，甚至在近期节省服务器成本方面带来很多效率。
数据仓库、数据湖和数据建模
任何没有被衡量的东西，都不会得到改进。有多个接触点以及一个供旅行者和代理商与产品/系统互动的平台。需要有一个中央数据储存库。此外，我们还希望使用数百万个数据点，如旅行者浏览、预订、个人资料、通话、电子邮件等数据，向旅行者建议下一个最佳行动项目，以及从过去的数据中可以获得哪些有意义的见解？
TravelTriangle 的核心文化价值观之一是以数据为中心。以下是任何人想到数据湖时都要注意的几个方面，这也符合大数据的 4v(容量、多样性、准确性和速度):
- 将所有来源的数据收集到一个
- 验证和三角测量数据的正确性
- 结构化数据以消除噪音并对其进行处理
- 对数据进行分析或建模，以获得业务洞察力(大数据的第五个方面——价值)
- 将洞察力融入系统和/或日常决策中
- 保持对新品种和新数据量的培训或更新见解
虽然很快会有一个完整的独立博客围绕这一点，我将简单地提及我们在 TravelTriangle 使用的方法、工具和技术，以建立我们自己的数据仓库、数据湖，并培训和部署各种数据模型，以从数据中获取洞察力&为旅行者和代理商实时触发某些行动。
我们使用细分工具以及产品和营销团队使用的外部工具将各种产品线的事件传递到我们的中央数据仓库(RedShift)。然而，对于我们的业务量来说，分段已经变得太昂贵了，因此我们正在用我们内部的实时消息流(“RTMS”)来转换它，以便将事件从任何来源转发到目的地。然而，在“RTMS”整合一个新的目的地并不像在细分市场那么容易，但我们可以接受——现在代替成本，不需要在需要的时候使用高科技…)
此外，我们还开发了一个内部数据管道来同步 MySQL 数据库和 redshift 之间的数据。由于频繁的问题和/或需要定制，AWS 数据管道未能满足我们的期望，因此在使用 AWS DMS 一段时间后，我们选择在内部开发自己的数据管道。我们也尝试了 AWS Glue、AWS data pipeline，但都无法满足我们的实时同步要求。目前，我们使用外部资源，如 FlyData 和 Stitch，但由于我们的数据量每月增长数倍，它们变得相当昂贵。(博客即将推出…)
对于利益相关者的第 2 天报告，我们选择了 Superset 和 Redash。在我们探索过的所有工具中，这些工具满足了我们的大部分需求，而且是开源的。超集中唯一缺少开发的是漏斗可视化，一旦可用，它就可以满足我们所有的需求。我们的工程师还使用各种技术优化技术优化了 Superset 和 Redash，以支持 5 倍的请求和从 10 秒到 1 秒的响应时间，以及长达 3-4 秒的少量繁重报告。我们现在正在为我们测试和集成 druid、PySpark 和类似的大数据工具，以决定一个并将其与我们的主要应用程序集成，以便更快地处理大数据。
在 TravelTriangle 上集中数据，并能够向我们的团队显示实时报告以执行日常分析后，我们开始为我们的业务用例开发和培训数据模型。一个这样的例子是动态线索评分，它必须是我们帮助代理有效地确定其线索优先级的实时基础。我们目前使用 EMR 来处理模型，并将我们的应用程序与 Kafka 集成在一起
通信/通知层(Sandesh)
通知是任何系统不可或缺的一部分，无论是促销系统还是交易系统。我们知道它必须是全渠道的，因此应该快速集成任何新的通信渠道/ API。此外，该流程需要高度可配置、可重用以及与任何其他微服务无缝集成(通过事件或 API)
“Sandesh”，我们在这里称之为通知服务，负责不同的交互媒介，可以是短信、IVRs、电子邮件、WhatsApp 或推送通知。通过集成一个映射层和提供者 API，还可以灵活地添加另一种通信媒介。
由于这项服务需要高并发性和 IO，我们还必须实现一般的速率限制、突发处理以及队列管理系统。基于前面提到的实验框架构建的通知模板引擎为产品团队提供了非常高的灵活性，可以根据通知类型和时间 A/B 测试他们的消息以及不同媒体的性能，而且也不需要技术带宽和/或新版本。
此外，我们还创建了数据事件来监控和分析不同媒体上每条消息的发送率、打开率(短信除外)以及点击率，所有这些都存储在我们的中央数据仓库中，以便从中进行分析并得出有意义的见解。
我们的促销活动目前通过外部工具 WebEngage 进行管理，但是，我们正在将活动管理器与我们的通知服务和实验框架进行内部集成。
虽然这篇文章提到了一些与我们的技术愿景和路线图一致的框架，但第二部分将告诉您更多的框架，以及我们的 QA 和 DevOps 团队为提高发布质量和周转时间而构建的框架。
发生了很多有趣的事情@ TravelTriangle。如果您需要了解更多细节，请告诉我们，或者发送电子邮件至 lead_on@traveltriangle.com，与我们一起亲眼见证，同时解决更具挑战性的问题，打造世界级的度假 B2C 和 B2B 生态系统。
如果你知道你的网络中有人可能对解决这些问题感兴趣，请分享这篇文章。
如果你喜欢这篇文章，就去喜欢和/或鼓掌，这样别人可能会偶然发现这篇文章。
【https://www.linkedin.com】最初发表于。
学习的工程机器
软件工程与基于 ML 的软件系统开发的相关性
我们正在通过调查开发包含 ML 组件的软件系统的最佳实践来研究机器学习工程的新兴学科。在本文中，我们分享了研究动机和方法、一些初步结果，并邀请大家参加我们关于 ML 工程最佳实践的 7 分钟在线调查 。
机器学习是新一波人工智能的关键
不可否认，人工智能(AI)正在经历一波新的关注、能量和极高的期望。这一浪潮是由我们互联的数字社会产生的大量数据以及巨大计算资源的低门槛可用性所驱动的。
在各种人工智能技术中，机器学习(ML)尤其扮演着关键角色。
当前人工智能的激增是由机器学习推动的，根据谷歌趋势对搜索词的相对兴趣表明了这一点。
从例子中学习复杂行为
机器学习允许我们解决复杂的问题，不是通过费力地编写新代码，而是通过让一个现有的算法从例子中学习新的行为。我们正在见证图像识别、语音处理、医疗诊断、证券交易、自动驾驶、产品设计和制造等领域的突破性成果。
机器学习是否取代编程？
机器学习的快速崛起是否意味着软件系统将不再需要编程？我们会需要数据科学家而不是软件开发人员吗？
对于那些经历过与软件相关的项目延迟、系统中断和无限期不完整特性集的人来说，一个没有程序员的世界可能看起来很有吸引力。
机器学习需要编程吗？
但没那么快。机器学习将而不是取代编程，而是使软件工程学科更加丰富和复杂，这有几个原因。
- ML 算法本身是需要开发、测试和维护的软件。
- 使用 ML 算法需要编程，用于接收、清理、合并和增强数据的任务，用于将数据输入 ML 算法，用于运行重复的训练实验以生成、评估和优化 ML 模型，以及用于在生产系统中测试、集成、部署和操作 ML 模型。
- 经过训练的 ML 模型只是构建复杂软件系统的一个构件。
那么，有什么不同呢？
尽管如此，机器学习的一些具体特征对传统的软件开发实践提出了挑战。对于涉及机器学习组件的应用程序，要管理的数据量通常要大得多。开发过程倾向于包括更多的快速循环实验，在这些实验中，替代解决方案被例行地尝试、比较和丢弃。并且最终产品中固有的不确定性水平更高。
机器学习工程师的出现。根据谷歌趋势对搜索词的相对兴趣。
ML 工程
在全球范围内，许多组织正在逐步学习如何开发包含 ML 组件的软件系统。随着越来越多的人自认为是 ML 工程师，机器学习工程学科正在兴起。这引发了有趣的问题:
- ML 工程和软件工程有区别吗？还是一个是另一个的子学科？
- 当用 ML 组件构建软件系统时，已建立的软件工程最佳实践同样适用吗？或者这些最佳实践需要修改或替换吗？
- 一套规范的 ML 工程最佳实践能够被识别出来，从而指导从业者并教育新人吗？
调查 ML 工程实践
为了调查这些问题，软件工程和机器学习领域的研究人员已经合作。
我们已经开始广泛回顾的科学和流行文献，以确定从业者和研究人员描述和推荐了哪些实践。这些实践的范围从数据管理(例如，如何处理大型数据集的存储和版本控制)，到模型训练(例如，如何运行和评估训练实验)，再到操作(例如，如何部署和监控训练模型)。
组织成实践团体的 ML 工程的方面。
调查 ML 工程实践的采用
然后，我们在用 ML 组件构建软件的团队代表中进行的调查中嵌入了确定的实践。本次调查目前正在进行中， 向新参与者 开放(见下文)。在撰写本文时，大约有 200 个团队参与其中。早期的结果表明，较大的团队倾向于采用更多的工程实践。
我们关于机器学习团队采用工程实践的全球调查的早期结果。较大的团队倾向于采用更多的实践。
还有，早期的结果告诉我们，有些实践被广泛采用，可以被认为是*，而另一些实践只被更大组织中更有经验的团队应用，可以被认为是*。**
更高级实践的一个例子是使用所谓的自动化机器学习技术，团队能够以自动化的方式进行模型选择和超参数优化。早期调查结果表明，与非科技公司和政府相比，这些技术在科技公司和(学术)研究实验室中的采用程度要高得多。
我们关于机器学习团队采用工程实践的全球调查的早期结果。与非科技公司和政府组织的团队相比，科技公司、大学和非商业研究实验室的团队往往会更多地利用自动化机器学习技术。
迈向 ML 工程最佳实践目录
我们正在利用调查结果将最佳实践整理成一个全面的目录。在目录中，每个 ML 工程实践都被记录在一个统一的结构中，就像过去的设计模式和重构一样。
该结构的要素包括实践的意图和动机，在各种环境中的适用性，与其他实践的相互依赖性，以及如何应用该实践的简短且可操作的描述。我们还提供参考文献和支持工具。
使用调查结果，我们还能够量化每个实践的难度。这有助于我们将它们按照从基础到高级的难度级别进行分类，指导团队优先采用它们。
我们的最终目标是，最终的目录将有助于 ML 工程团队的形成和有效性，不仅在 ML 工程已经得到广泛采用的大型技术公司，而且在较小的非技术组织中。
参加调查！
如果您是构建包含机器学习组件的软件的团队的一员，请通过参加我们的调查来帮助我们**。**
拿调查:【https://se-ml.github.io/survey/】
Joost Visser 是莱顿大学软件和数据科学教授。此前，Joost 在软件改进小组担任过各种领导职务。他是许多关于软件质量和相关主题的出版物的作者。
更多信息请咨询 SE4ML 项目网站 。
这篇文章的早期版本发表在Bits&Chips中。
涵盖构建机器学习(ML)的软件工程(SE)最佳实践的文章精选列表…
github.com](https://github.com/SE-ML/awesome-seml/blob/master/readme.md)**
使用工具提示页面增强电源 BI 报告
了解关于工具提示页面如何增强您的 Power BI 报告的各种技巧
Salvatore Ventura 在 Pexels 上拍摄的照片
Power BI 是一个很棒的工具(我知道你也意识到了)。我最喜欢它的一点是，它提供了许多可能性，可以使用一些简单的技术来增强您的报告，并为您的用户创造无与伦比的体验。
在我之前的文章中，我分享了 5 个简单的技巧来提高你的 Power BI 开发过程。由于只包括了五个，我最喜欢的技术之一没有在那里找到位置，因为我已经决定为此专门写一篇文章。
最酷的技巧之一是创建工具提示报告页面。只需几分钟的时间，您就可以让您的用户更加灵活地浏览数据窗口。
默认提示
我已经使用 Contoso 数据集创建了一个简单的报告。默认情况下，当您将鼠标悬停在数据栏上时，您将看到特定数据部分的数字:
在这里，您可以看到 2009 年 6 月的销售额约为 8200 万英镑。
自定义工具提示
比方说，我想让我的用户有机会通过将鼠标悬停在数据栏上来快速获得对底层数据的更好的概述。
第一步是通过单击“+”号创建一个新的报告页面。
在新创建的页面的格式部分，我们需要应用一些设置来使这个页面成为工具提示页面。在“页面大小”菜单下，选择“工具提示大小”,而不是默认的 16:9。
然后，在“视图”选项卡的“页面视图”下，我选择“实际大小”，这样我就可以创建“实际”大小的可视化效果，因为它将显示在主报表页面上。
我已经将我的工具提示报告页面重命名为工具提示 1(当然，您应该给它一个更有意义的名称，尤其是当您处理多个工具提示页面时)。在这个页面上，我放置了一个显示总销售额的卡片和一个显示销售额排名前 5 的地区的聚类条形图。我还隐藏了这个页面，这样用户打开报告时就看不到它了。
最后一步是“告诉”Power BI 我打算将这个页面用作工具提示。因此，在页面信息下，我将工具提示切换为开:
现在，让我们切换回主页。在“格式”窗格下，有一个工具提示菜单。您只需要在 Type 下选择报告页面，并在 page:
就是这样:现在，当用户悬停在特定的数据栏上时，他可以立即看到向下钻取的数据，如我们的工具提示中所定义的！
2009 年 6 月的工具提示数据
2009 年 8 月的工具提示数据
让它成为你自己的…
除了默认的工具提示页面大小(320x240px)，您还可以创建自己的工具提示页面大小。不要选择“页面大小”下的工具提示，只需选择“自定义”并输入您想要的值。我已经创建了一个工具提示页面 Tooltip 2，并将大小改为 328×200 像素。它只是显示每种产品颜色的销售额，所以现在当用户将鼠标悬停在产品上时，他将看到所选产品每种颜色的数字:
这样，我就能看出 2009 年 Adventure Works 品牌的最大销售额来自哪种颜色。
最后，您可以在工具提示页面上指定工具提示字段。这意味着您的报告中引用指定字段的每个可视内容都将显示您的工具提示页面，而不是默认的 Power BI 工具提示。
现在，如果我返回到主报告，并将自动选项作为工具提示报告页面，任何显示销售额度量的可视化工具都将显示我定制的工具提示！多酷啊！
因此，当我将鼠标悬停在品牌名称上时，我将获得销量和前 5 名地区:
带有动画工具提示的专业级
最后一项技术是真正的专业水平，并归功于来自 Exceleratorbi 的 Jason Cockington，他详细解释了这一点。总之可以添加 GIF 作为工具提示！这非常有用，因为许多用户并不了解所有 Power BI 功能，需要某种指导才能充分利用报告。
最常见的情况之一是，当您在报表中创建钻取页面时，您的用户并不知道它，或者根本不知道如何访问它。所以，我创建了一个 GIF(网上有很多免费的 GIF 创建者，这个就是其中之一)展示了从主页面表格到每个品牌销售额详细概览的钻取操作步骤。
在你创建了一个 GIF 之后，之前在这篇文章中解释的所有步骤都是一样的。唯一的区别是，您应该将 GIF 设置为背景图像，透明度为 100%,并将 Image Fit 属性设置为 Fill，而不是将 GIF 作为图像放在工具提示页面上:
接下来，在主页表格上，我打开了可视标题工具提示图标:
最后，在可视标题工具提示下，我定义了新创建的工具提示页面(在我的例子中它被称为 GIF 工具提示)。
因此，现在当某人将鼠标悬停在一个小问号图标上时，他会看到如何执行钻取操作的动画说明。厉害！
结论
报告页面工具提示是一个非常强大的功能，它们可以丰富你的报告。但是，使用它们时要小心，尤其是当您的报表包含许多视觉效果时，因为渲染时间的增加会导致性能下降。
至于 Power BI 中的任何其他技术:尝试在用户体验增强和关于报告性能的额外开销之间找到正确的平衡。
成为会员，阅读 Medium 上的每一个故事！
订阅这里获取更多有见地的数据文章！
什么是 Python 类，你如何使用它？
了解 Python 的类机制
克里斯里德在 Unsplash 上的照片
W 在从事数据科学项目或任何 Python 编程项目时，你很可能会发现自己使用了大量自制的函数和变量。为了简化项目过程，您甚至可能已经创建了一个完整的脚本，其中包含了您创建的函数。
这些函数可以用于代码中的许多事情。从清理数据帧到训练机器学习模型。创建大量的函数来组织你的 Python 代码是很有用的，但是还有另一种方法可以让你的代码看起来和行为起来更像样——通过使用 Python 类 ！
什么是 Python 类？
Python 类就像是创建新对象的大纲。对象是您在处理代码时希望操作或更改的任何东西。每当一个类对象被实例化，也就是当我们声明一个变量时，一个新的对象就从零开始。只要需要，类对象可以反复使用。
示例:约会档案
在我们的案例中，在我们以前的文章中，我们一直在撰写一系列关于创建约会算法的文章，该算法通过使用机器学习对约会档案进行聚类和分类。看这里:
为约会应用程序利用无监督机器学习
towardsdatascience.com](/dating-algorithms-using-machine-learning-and-ai-814b68ecd75e)
在上面的文章中，我们经历了数据预处理的整个过程，以便让我们的数据变得对人工智能友好，例如将约会简档转换为一组数字。对象，在本例中为，是为了让所有这些发生而需要操作的约会配置文件。
这个数据预处理步骤是通过使用许多函数来实现的。它不是以最好的方式组织的，但是它完成了工作。然而，我们可以通过利用 Python 类来改进这个过程。
约会档案的类别
为了学习更多关于类对象和利用它们，我们将为我们的人工智能约会算法实现一个类对象。让我们将我们使用的代码组织和整理成一个类对象。
类对象用途
首先，我们必须问自己——我们希望这个类对象做什么？我们希望它:
- 创建新的约会档案。
- 将新的个人资料添加到更大的约会个人资料池中。
- 对简档进行缩放或矢量化，以使其对机器学习模型友好。
基本上，我们希望它将整个数据预处理步骤浓缩到一个类对象中，然后我们可以将它用于我们希望添加的每个新的约会配置文件。每当我们需要创建一个新的约会档案时，我们都可以使用这个类对象。
构造一个类
在创建类之前，我们建议您导入必要的库。在我们的课程中，我们将使用以下库来格式化新的约会配置文件:
import pandas as pd
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.preprocessing import MinMaxScaler
首先，为了创建一个类对象，您只需键入以下内容:
class CreateProfile:
类的名字是主观的，但是关于名字格式的一般规则是遵循一个叫做 [的东西。这是我们的类对象的开始，我们将从这里开始构建。](https://en.wikipedia.org/wiki/Camel_case#:~:text=Camel%20case%20(stylized%20as%20camelCase,iPhone%22%20and%20%22eBay%22.)
在类中，切换到开始定义我们的第一个函数。通常，当创建一个类时，你必须定义一个名为__init__的函数，以self作为初始参数。
class CreateProfile:
def __init__(self):
什么是__init__”功能？
当一个类被实例化时，一个__init__函数被调用。通过实例化，我们指的是当你声明一个类的时候，它可以自己发生，也可以通过把它赋给一个变量来发生。以下是实例化类对象的一些快速示例:
CreateProfile()# ORprofile = CreateProfile()
这里我们正在实例化类对象，通过这样做，我们隐式地调用了__init__函数。在实例化类对象时，__init__函数中的任何参数也将是相同的参数。这些初始参数可以是我们希望在整个类对象中操作的数据。但是对于self参数，在实例化类对象时没有必要替换。
什么是“自我”？
self参数只会在构建 Python 类时出现。它在整个类中使用，通常是在该类中创建的任何函数的第一个参数。但是，无论何时实例化后使用类对象，self都不会是你需要填充的参数。
self参数是一个隐式参数，当实例化该类或者在该类中使用自定义函数时，总是会调用这个参数。self指的是它正在操纵的对象。在我们的例子中，我们希望创建新的约会资料。
使用“自我”
为了进一步理解self的用法，我们将继续构造我们的类。让我们填写一些我们的__init__函数将采用的其他参数:
class CreateProfile:
def __init__(self,
dataset=None,
profile=None): self.dataset = dataset
self.profile = profile
正如你在这里看到的，我们在self后面添加了一些参数。这些论点现在是空的，但我们将使用熊猫数据框架来创建一个新的约会档案。为了在整个类中使用这些 DFs，我们必须将它们分配给对象或self,稍后我们将使用函数对其进行操作。
类别属性
当在我们的__init__中分配这些 DFs 时，我们有效地创建了类属性。在实例化类之后可以调用它们，它们将返回我们分配给对象的任何变量(self):
# Instantiating the class
new_profile = CreateProfile()# Calling the class attribute
new_profile.dataset
这将返回我们在实例化该类时提供的任何数据集。在这种情况下，运行这段代码将不会返回任何内容，因为None是在__init__函数中建立的默认参数。
我们也可以运行new_profile.profile来返回我们正在创建和操作的概要文件。这个创建的配置文件现在将是空的，但是我们将使用新的信息填充它，并通过使用我们稍后将构造的类中的一些自定义函数来格式化它。
为了进行下一步，让我们建立所有的类属性来创建我们最终的__init__函数。我们将需要它们用于类中未来的自定义函数:
在这里，我们为新的概要文件添加了更多的条件和更多的属性，供以后使用
类方法(函数)
我们在类中创建的函数被称为方法。函数和方法本质上是一样的，但是在类对象的上下文中，函数被称为方法。为了操作和利用给定的数据，我们需要为我们的类创建一些方法。
在这种情况下，我们将使用我们之前创建的日期配置文件的合成数据集。参见以下文章，了解该数据集的创建:
我如何使用 Python Web Scraping 创建约会档案
towardsdatascience.com](/generating-fake-dating-profiles-for-data-science-cd3b929972bc)
该数据集将为我们提供创建新约会档案的背景。
使用类方法创建新的约会配置文件
我们希望我们的类做的第一件事是创建一个全新的概要文件，如果它还没有提供的话。为此，我们可以在__init__方法下创建一个新方法:
class createProfile:
def __init__(self,
dataset=None,
profile=None): self.dataset = dataset
self.profile = profile # Here we add another function
def enter_info(self):
# Code goes here
如你所见，我们仍然在使用self参数。当我们键入下面的代码时，我们将需要它:
上面的方法在整个代码中都使用了self。当我们使用self.profile时，我们指的是我们在__init__方法中分配的属性。首先，我们检查它是否是一个空的数据帧，它确实是。接下来，我们将使用在__init__方法中分配的self.dataset变量，并使用它的特性来创建新的概要文件。
我们允许选择使用更大数据集中的随机信息来填充新的配置文件，或者手动输入信息。在输入配置文件信息之后，方法用新的配置文件信息覆盖属性。如果您试图再次运行这个方法，它将返回字符串:"概要文件中已经包含的数据。
如果你想输入新的信息，你必须重新初始化这个类，然后从头再运行一次。实例化该类将从头开始整个过程。
运行类方法
下面是我们如何从实例化步骤开始运行该方法:
# Instantiating with the data from the DF of synthetic profiles
new_profile = createProfile(dataset=data)# Running the method
new_profile.enter_info()
这正是我们所需要的。只有两行代码。当我们运行它时，它要么为配置文件输入随机信息，这是函数的默认行为，要么提示我们手动输入信息，如下所示:
对于每个需要信息的功能，都会出现此提示
无论哪种方式，class 方法都将创建一个全新的概要文件，供我们以 DataFrame 的形式操作:
新的约会档案
更多类方法
对于我们来说，创建一个全面的类，它必须做的不仅仅是创建一个新的约会配置文件。在这种情况下，我们将添加之前在__init__方法中提到的方法。下面是我们将添加到类中的方法，以使用我们的新概要文件:
我们的类中将要用到的其余方法
解释每种方法
类中的每个方法都执行特定的功能。给定在self中创建的属性，这些方法将用每个方法的结果值替换类的属性。
add_profile_to_dataset()—此方法假设已经有一个包含信息的约会档案。它将比较来自剖面图和更大数据集的要素，以查看它们是否匹配。如果它们匹配，那么它会将新的配置文件添加到数据集中，并返回添加了新配置文件的更大的数据集。否则，它会通知用户数据集的要素与剖面图的要素不匹配。vect_text()—对于新的概要文件数据，该方法实例化CountVectorizer()来为概要文件的 Bios 中使用的每个单词创建一个数字数组。然后它创建一个数字数组的 DF 并返回它。scale_profile()—给定新的轮廓数据，该方法使用适合更大轮廓数据集的MinMaxScaler()来缩放新的轮廓数据。此外，在该方法的参数中，有一个不进行缩放的已排除要素或列的列表。然后，它使用self.scaled_profile属性，并用一个包含缩放值的新 DF 重新分配它，并返回那个 DF。format_profile()—这种方法基本结合了前面两种方法:vect_text()和scale_profile()。如果运行这两个方法返回的属性已经存在，那么它将连接两个 DF 并返回结果 DF。如果没有，那么它仍然运行这些方法，并返回两个 DFs 的连接结果。
运行每个方法与之前运行enter_info()方法相同:
# Running each method after having ran enter_info()
new_profile.add_profile_to_dataset()new_profile.vect_text()new_profile.scale_profile()new_profile.format_profile()
查看类属性
现在我们已经运行了类中的所有方法，我们可以通过查看每个方法使用的新类属性来检查结果。
# Running each attribute to check their results
new_profile.combined_df.tail(5)new_profile.vectorized_textnew_profile.scaled_profilenew_profile.formatted_profile
如果您运行这段代码，您将能够看到每个方法处理的类属性以及它们的最终结果(按顺序*)😗
每个属性的结果(从上到下):组合 _df、矢量化 _text、缩放 _profile、格式化 _profile
正如您所看到的，新的概要文件有一个索引值 6600 ，并且显示了每个方法如何操作它。我们现在可以随时引用类中的每个属性，它将包含这些结果。
导入类
在创建一个类时非常有用的一点是，我们可以将我们创建的类导入到其他 Python 文件或笔记本中。只需将 Python 类保存在一个.py文件中，您可以在以后导入它。只要确保它在同一个目录中。您可以像导入任何其他 Python 库一样导入该类:
from your_file_name import CreateProfile
现在，您可以随时使用 Python 类，而无需复制/粘贴代码。
关闭
使用类来简化我们的数据预处理步骤对于任何开始数据科学项目的人来说都是非常有用的。在我们的例子中，我们需要一种方法来处理新概要文件的创建和格式化。Python 的类的伟大之处在于我们可以随时重用它。如果我们想添加另一个约会配置文件，那么我们所要做的就是实例化另一个类对象。这可以继续下去，直到我们对新创建的配置文件的数量感到满意。
总的来说，类对象可以用来在编码项目中组织代码。这里我们只讨论了 Python 类的基础知识，还有一些概念需要学习。如果你想了解更多关于 Python 的类，那么 点击 这里 。
如果需要，可以查看下面参考资料中的 Github 以获得完整代码。到目前为止，您可能已经看到了为您的项目创建 Python 类的价值。
资源
使用无监督机器学习和 NLP - marcosan93/AI-Matchmaker 的匹配简档
github.com](https://github.com/marcosan93/AI-Matchmaker) [## 我用机器学习和人工智能做了一个约会算法
为约会应用程序利用无监督机器学习
towardsdatascience.com](/dating-algorithms-using-machine-learning-and-ai-814b68ecd75e) [## 我为数据科学制作了 1000 份假的约会资料
我如何使用 Python Web Scraping 创建约会档案
towardsdatascience.com](/generating-fake-dating-profiles-for-data-science-cd3b929972bc)
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
