生产中的机器学习
从生产分类模型中学到的有用技巧
照片由 Wojciech 然后在 Unsplash 上拍摄
在生产中，风险很高。人们将会阅读模型的输出。输出更有意义。
最近，我和我的团队创建了一个 NLP 分类器，并在一个大型保险数据集上投入使用。它使用 TfidfVectorizer 和 LinearSVC 对自由文本进行分类。
但我很快意识到，把东西投入生产与理论是如此不同。
图片由 Juan C. Antúnez 在 flprobatelitigation 上拍摄
我认为，在生产中，获得模型预测的概率非常重要。例如，如果您的模型以 50%的概率对某件事情进行分类，那么应该有人对该预测进行调查。如果他们发现一个错误，你阻止了模型破坏公司的一个关键系统。
但是获得一个预测的概率并不总是那么简单。
在本文中，我将介绍一种从 scikit-learn 的 SVM 分类器中提取概率的方法。
这对于将我们的模型投入生产至关重要。
概率校准
我们不仅想要预测的类别标签，还想要预测的概率。Scikit-learn 在他们的文档中有一个关于这个主题的有趣章节。
我们需要创建一个回归器(或校准器)，将分类器的输出映射到一个介于0和1之间的值。这个校准器会给我们每次预测的概率。
本质上，校准器将试图预测:
其中f是分类器的输出。
或者更直白地说:给定我们的分类器的输出，我们对这个输出 100%确定的概率是多少？
约翰·普拉特的这篇论文指出，sigmoid 函数可以用作回归变量。我们得到以下结果:
为了找到 A 和 B，我们可以使用最大似然估计。这将涉及最小化负对数可能性:
其中ti是目标概率。
给我看看代码
代码非常简单。Scikit-learn 隐藏了抽象层背后的大部分复杂性。
你需要做的就是这个:
# from: https://stackoverflow.com/questions/26478000/converting-linearsvcs-decision-function-to-probabilities-scikit-learn-pythonsvm = LinearSVC()
clf = CalibratedClassifierCV(svm)
clf.fit(X_train, y_train)
CalibratedClassifierCV 将使用 k 重交叉验证方法来拟合训练数据。默认值为 5 倍。点击查看更多信息。
然后，我们将提取所有 k 倍预测类的平均概率。predict_proba是我们这里需要的函数。虽然函数本身看起来像一个未完成的句子，但它非常有用。
y_proba = clf.predict_proba(X_test)
要得到预测的类，我们可以简单地使用预测函数。
clf.predict(X_test)
评估校准品
校准器与数据的吻合程度如何？我们怎么知道？
为此，我们可以使用sklearn.metrics.brier_score_loss。更多信息可在这里找到。
如果这个分数非常高，那么我们就不能查看校准器的概率输出——它们是无用的。相反，我们需要寻找更好的方法来安装校准器。这篇文章提供了一些安装校准器的好方法。
结束
真的就是这样！
我相信，随着我们继续保持这种模式，我会有更多的内容要添加。我想分享这个帮助我们有效地将模型投入生产的小技巧。希望有人会觉得它有用。
如果我犯了一个错误，或者你有兴趣寻求帮助，请随时通过推特联系我。
原载于 2020 年 9 月 30 日https://spiyer 99 . github . io。
使用 Apache Airflow 在生产中进行机器学习
如何使机器学习项目在生产中具有健壮性和可解释性的实际案例
目录:
1。简介
“所有的模型都是错的，但有些是有用的。”—乔治·博克斯。
使用机器学习(ML)来构建解决方案本身就是一项复杂的任务。虽然学术 ML 源于 20 世纪 80 年代的研究，但机器学习系统在生产中的实际实现仍然相对较新。
今天，我想分享一些关于如何使用 Apache Airflow 使您的 ML 管道健壮且可解释的想法。整个项目可以在 Github 上找到。代码被 dockerized ，所以即使你不熟悉这项技术，使用它也很简单。
这个题目是复杂的，多方面的。在本文中，我将只关注任何 ML 项目的两个部分——数据验证和模型评估。目标是分享实用的想法，你可以在你的项目中相对简单地引入，但仍然可以获得很大的好处。
这个主题非常广泛，所以我们来介绍几个限制条件:
- 我们将使用 Apache Airflow 作为管道编排工具；
- 我们将考虑一个 ML 培训管道。
- 我们将关注大多数项目中常见的实际问题。
如果您不熟悉 Airflow，它是一个以编程方式创作、调度和监控工作流的平台[1]。气流工作流被构建为任务的有向无环图(Dag)。Airflow scheduler 在遵循指定依赖关系的同时，对一组工作线程执行您的任务。命令行实用程序使在 Dag 上执行复杂的手术变得轻而易举。用户界面使得可视化生产中运行的管道、监控进度以及在需要时解决问题变得容易。
2.数据有效性
数据验证是确保数据存在、正确和有意义的过程。在任何组织中，通过自动验证检查来确保数据质量是构建数据管道的关键步骤。
在模型训练之前需要数据验证步骤，以决定是否可以训练模型或停止管道的执行。如果管道识别出以下情况，则自动做出该决定[2]:
- 数据模式偏差:这些偏差被认为是输入数据中的异常，这意味着下游管道步骤，包括数据处理和模型训练，接收到不符合预期模式的数据。模式偏差包括接收到意外的功能、没有接收到所有预期的功能或接收到具有意外值的功能。
- 数据值偏斜:这些偏斜是数据统计属性的显著变化，这意味着数据模式发生了显著变化，您需要检查这些变化的性质。
数据验证的重要性:
- 模型的质量取决于数据的质量。
- 通过量化数据质量增加对数据质量的信心。
- 校正训练好的 ML 模型可能是昂贵的——预防胜于治疗。
- 如果数据无效，则停止训练新的 ML 模型。
Airflow 提供了一组检查操作符，使我们能够轻松验证数据质量。让我们看看如何在实际例子中使用这样的操作符。
2.1 检查操作员
CheckOperator 期望一个返回单行的 SQL 查询。第一行中的每个值都使用 python bool 转换进行计算。如果任何值返回 False，则检查失败，并显示错误。因此，只需在管道中添加一个任务，我们就可以检查特定日期的数据是否存在。
2.2 IntervalCheckOperator
对于更复杂的检查，气流有间隔检查操作器。检查以 SQL 表达式形式给出的度量值是否在之前“ days_back ”中度量值的特定容差范围内。
这项检查的一个关键点是比率公式——使用哪个公式来计算两个指标之间的比率。你可以从两种可能中选择:
***max _ over _ min:***max(cur，ref) / min(cur，ref)
relative _ diff*:计算 abs(cur-ref) / ref*
IntervalCheckOperator 允许您同时检查一些特定表的不同比率的不同指标。
2.3 ValueCheckOperator
一个简单而强大的操作符。它使用 SQL 代码执行纯值检查。您可以使用任何复杂度的 SQL 查询来获取任何值。如果计算值等于传递值，且有一定的容差，则检查通过。
使用来自 Airflow 的检查操作符，当您看到检查失败时，更容易理解问题出在哪里，而不是处理代码中的错误。
管道开始处的数据检查列表
在当前示例中，我使用所有检查来测试输入数据。但是您也可以检查任何输出值。此外，将检查添加到 ETL 管道中也很有用。
3.模型验证
给定新数据，成功训练模型后，会发生此步骤。在推广到生产之前，我们会对模型进行评估和验证。理想情况下，离线模型验证步骤应该包括[2]:
- 使用测试数据集上的训练模型产生评估度量值，以评估模型的预测质量。
- 将新训练的模型与当前模型(例如，生产模型、基线模型或其他业务需求模型)生成的评估度量值进行比较。在将其推广到生产之前，您要确保新模型比当前模型产生更好的性能。
- 确保模型的性能与数据的各个部分一致。
3.1 现实中的模型验证
实际上，保留代表性的测试数据集可能很难，而且成本很高。但是我们仍然要监控重新训练的模型的质量。
我们能做的最简单的事情就是使用训练数据集计算指标。这个想法是，研究人员知道原型制作最后一步的训练集和测试集的误差度量值。如果下一次训练后的误差值变得更高或更低，我们不应在生产中使用该模型。另外，如果你观察到误差值的上升趋势，可能意味着模型的退化。
3.2 模型的元数据监控
想法是一样的。您希望能够对您的模型进行快速诊断，这将持续很长时间。模型的元数据可以让您看到模型生命周期的一些关键时刻。
我们希望有一些简单但有用的解决方案，我们甚至可以为现有的项目快速实现。您可以开始监视这些属性:
- 训练数据的数量；
- 范畴特征的多样性；
- 数字特征的标度、平均值、最小值、最大值；
- 算法的学习属性。例如:SGDClassifier[3]的“*coef _”*或 RandomForestRegressor [4]的“feature _ importances _”；
这里有一个使用 sklearn 的例子:
例如，根据您公司的技术堆栈，您可以将值存储到数据库并构建 Grafana 仪表板，或者如果您使用 Datadog，只需记录值并构建仪表板。
4.摘要
在投产新项目时，您应该记住的主要观点是:
- 数据验证步骤非常重要。校正已训练的 ML 模型可能是昂贵的——如果数据无效，则停止训练新的 ML 模型。
- Airflow 是一个强大的工具，它允许我们用最少的实现工作来检查数据。
- 分配代表性的测试数据集既困难又昂贵。监控训练数据集上的误差值仍然是一个很好的替代方案。
- 存储模型的元数据可以帮助我们看到模型本质的关键变化。
您可以在资源库DanilBaibak/ml-in-production中找到该项目的代码。
参考资料:
关于生产中的机器学习主题的其他有用参考:
- ML 测试分数:ML 生产准备和技术债务削减的指标 (2017) Breck 等。(谷歌)
- 机器学习的软件工程:案例研究 (2019) Amershi 等。(微软)
- 监控生产中的机器学习模型
- 气流最佳实践
使用 PyCaret 在 SQL 中进行机器学习
通过在 SQL Server 中集成 PyCaret 将您的 ML 代码发送到数据
这篇文章是一个关于如何使用【py caret】(Python 中的一个低代码 ML 库)在 SQL Server 中训练和部署无监督机器学习聚类模型的分步教程。****
我们将在本文中讨论的内容:
1.如何免费下载并安装 SQL Server
2.如何创建新数据库并将数据导入数据库
3.如何在数据库中启用和使用 Python 脚本
4.如何训练聚类分析算法，以便为数据集中的每个观察值分配分类标签
一、将代码带入数据——ML 使用数据库的案例
执行 ML 实验的首选工具/环境是命令行、ide 或笔记本。然而，当数据变得非常大时，或者当需要将 ML 模型投入生产时，这样的工具/环境可能会造成限制。迫切需要能够对数据所在的模型进行编程和训练。MS SQL Server 在其 SQL Server 2019 版中引入了这一功能。使用 SQL Server 进行机器学习的独特优势在于:
I .从系统中提取大量数据既繁琐又耗时。在服务器上进行 ML 实验将代码转化为数据，而不是将数据转化为代码
二。ML 实验大多在计算机/cpu 内存中执行。在大型数据集上训练 ML 算法时，大多数机器都遇到了性能上限。SQL Server 数据库上的 ML 避免了这种情况
三。很容易将 ML 管道与其他 ETL 过程集成和部署在一起
二。SQL 服务器
SQL Server 是一个微软关系数据库管理系统。作为数据库服务器，它执行存储和检索不同应用程序请求的数据的主要功能。在本教程中，我们将通过在 SQL Server 中导入 PyCaret 库，使用SQL Server 2019****Developer进行机器学习。
三。下载软件
如果您以前使用过 SQL Server，很可能您已经安装了它，并且可以访问数据库。如果没有， 点击此处 下载 SQL Server 2019 Developer 或其他版本。
四。设置环境
在 SQL Server 中使用 PyCaret 功能之前，您需要安装 SQL Server 和 PyCaret。这是一个多步骤的过程:
步骤 1 —安装 SQL Server
下载 SQL Server 2019 开发者版文件“SQL2019-SSEI-Dev.exe
打开文件并按照说明进行安装(建议使用自定义安装选项)
选择新的 SQL Server 独立安装
在实例特性选项中，选择包括机器学习服务和语言扩展和**机器学习服务器(单机版)**下的 Python 在内的特性
点击接受，同意安装 Python
安装可能需要 15-20 分钟
步骤 2 —安装 Microsoft SQL Server Management Studio(SSMS)
点击这里 或者打开 SQL Server 安装中心下载“SQL Server 管理工具”文件SSMS-Setup-ENU.exe
打开“SSMS-Setup-ENU.exe文件开始安装
安装可能需要 5-10 分钟
步骤 3-为机器学习创建一个数据库
一旦您安装了所有的东西，您将需要启动服务器的一个实例。为此，请启动 SSMS。在登录阶段，会要求您输入 SQL Server 的名称，您可以从下拉菜单中选择。一旦建立了连接，您就可以看到服务器上的所有对象。如果您是第一次下载 SQL Server，并且没有可以使用的数据库，则需要先创建一个新数据库。
在对象资源管理器面板中，右键单击数据库，然后选择新建数据库
输入数据库名称和其他信息
设置可能需要 2-3 分钟，包括创建数据库、用户和设置所有权
步骤 4 —导入 CSV 文件
现在，您必须使用 SQL Server Management Studio 将 CSV 文件导入数据库。
在数据库中创建一个表"珠宝"
右击数据库，选择任务 - > 导入数据
对于数据源，选择平面文件源。然后使用浏览按钮选择 CSV 文件。在点击下一个按钮之前，花一些时间配置数据导入。
对于目标，请选择正确的数据库提供程序(例如 SQL Server Native Client 11.0)。输入服务器名称；勾选使用 SQL Server 认证，输入用户名、密码，以及数据库，然后点击下一步按钮。
在选择源表和视图窗口中，您可以在单击下一个按钮之前编辑映射。
检查立即运行并点击下一个按钮
单击“完成”按钮运行包
数据加载结果
步骤 5-为 Python 脚本启用 SQL Server
我们将通过使用sp _ execute _ external _ script系统存储过程在 SQL Server“内部”运行 Python。首先，您需要打开一个’新查询’。在实例中执行以下查询，以启用远程脚本执行过程:
EXEC sp_configure ‘external scripts enabled’, 1RECONFIGURE WITH OVERRIDE
**注意:**在继续下一步之前，重新启动实例。
可以执行以下 SQL 语句来检查 Python 路径并列出已安装的包。
检查 Python 路径:
EXECUTE sp_execute_external_script@language =N’Python’,@script=N’import sys; print(“\n”.join(sys.path))’
脚本执行结果
列出已安装的软件包:
EXECUTE sp_execute_external_script@language = N’Python’,@script = N’import pkg_resourcesimport pandas as pdinstalled_packages = pkg_resources.working_setinstalled_packages_list = sorted([“%s==%s” % (i.key, i.version) for i in installed_packages])df = pd.DataFrame(installed_packages_list)OutputDataSet = df’WITH RESULT SETS (( PackageVersion nvarchar (150) ))
脚本执行结果
步骤 6-将 PyCaret Python 包添加到 SQL Server
要安装 PyCaret 包，请打开命令提示符并浏览到安装 SQL Server 的 Python 包的位置。默认位置是:
C:\Program Files\Microsoft SQL Server\MSSQL15.MSSQLSERVER\PYTHON_SERVICES
导航到“脚本目录，使用 pip 命令安装 PyCaret 包
pip.exe install pycaret
命令提示符— PyCaret 安装
命令提示符— PyCaret 安装结束
注意:确保您有权访问 SQL Server 目录以安装软件包和/或更改配置。否则，软件包安装将会失败。
安装可能需要 5-10 分钟
**注意:**万一运行 SQL 脚本时遇到“ lightgbm ”模块丢失的问题。请遵循以下说明:
一、卸载“ lightgbm
pip.exe uninstall lightgbm
二。重新安装“灯 gbm
pip.exe install lightgbm
执行以下 SQL 以从 SQL Server 验证 PyCaret 安装:
EXECUTE sp_execute_external_script@language = N’Python’,@script = N’import pkg_resourcespckg_name = “pycaret”pckgs = pandas.DataFrame([(i.key) for i in pkg_resources.working_set], columns = [“key”])installed_pckg = pckgs.query(‘’key == @pckg_name’’)print(“Package”, pckg_name, “is”, “not” if installed_pckg.empty else “”, “installed”) ’
脚本执行结果
动词 （verb 的缩写）ML 实验示例 SQL Server 中的集群
聚类是一种机器学习技术，它将具有相似特征的数据点分组。这些分组对于探索数据、识别模式和分析数据子集非常有用。集群的一些常见业务用例有:
以营销为目的的✔客户细分。
促销和折扣的✔顾客购买行为分析。
✔在诸如新冠肺炎的流行病爆发中识别地理群集。
在本教程中，我们将使用 PyCaret 的 Github 存储库中的“**jewellery . CSV”**文件。
珠宝数据集中的样本数据点
1.k 均值聚类
在 SQL Server 中运行以下 SQL 代码:
EXECUTE sp_execute_external_script@language = N’Python’,@script = N’dataset = InputDataSetimport pycaret.clustering as pcdataset = pc.get_clusters(data = dataset)OutputDataSet = dataset’,@input_data_1 = N’SELECT [Age], [Income], [SpendingScore], [Savings] FROM [jewellery]’WITH RESULT SETS(([Age] INT, [Income] INT, [SpendingScore] FLOAT, [Savings] FLOAT, [Cluster] varchar(15)));
2.输出
SQL 语句结果
包含标签的新列’ Cluster’ '被附加到原始表。
默认情况下，PyCaret 训练一个具有 4 个聚类的 K-Means 聚类模型(即表中的所有数据点都被分为 4 组)。默认值可以很容易地更改:
要更改聚类数，可以使用 get_ clusters()函数中的 num_clusters 参数。
要更改模型类型，请使用 get_clusters()中的模型参数。
3。k 模式
使用 6 个集群训练 K-Modes 模型参见以下代码:
EXECUTE sp_execute_external_script@language = N’Python’,@script = N’dataset = InputDataSetimport pycaret.clustering as pcdataset = pc.get_clusters(data = dataset, model=”kmodes”, num_clusters = 6)OutputDataSet = dataset’,@input_data_1 = N’SELECT [Age], [Income], [SpendingScore], [Savings] FROM [jewellery]’WITH RESULT SETS(([Age] INT, [Income] INT, [SpendingScore] FLOAT, [Savings] FLOAT, [Cluster] varchar(15)));
按照这些步骤，您可以为珠宝数据集中的每个观测点分配聚类值。您也可以对其他数据集使用类似的步骤，对它们执行聚类。
不及物动词结论
在这篇文章中，我们学习了如何在 SQL Server 中运行 Python 库(PyCaret)来构建集群模型。类似地，根据业务问题的需要，您可以构建和运行其他类型的监督和非监督 ML 模型。
您可以进一步查看 PyCaret 网站，获取关于其他监督和非监督实验的文档，这些实验可以在 SQL Server 中以类似的方式实现。
我以后的帖子将是在 SQL Server 中使用 Python 和 Pycaret 探索监督学习技术(回归/分类)的教程。
七。重要链接
PyCaret
PyCaret:教程
股票中的机器学习。重新定义公司集团。
亨尼投资
应用聚类开发识别可比公司的新方法
在投资界的一个普遍信念是，被低估的公司提供了一个巨大的机会来获得高于平均水平的利润。我们这个时代最成功的投资者，包括沃伦·巴菲特、霍华德·马克斯和菲尔·费舍尔，都非常依赖这种方法为自己和客户创造财富。
识别被低估的公司非常具有挑战性，因为这涉及到进行定量预测预测未来 5-10 年的情况。幸运的是，对许多人来说，情况并不总是如此。霍华德·马克斯将这一概念与市场周期的概念联系起来。有些时候所有东西都很便宜。你只需要买些东西，除非你的判断非常错误，否则你会做得很好。
避免大错特错的一个方法是了解哪种公司不太可能是好的投资选择。
产业作为群体是没有用的
目前，我们按照公司做什么来给公司分组。我们认为科技股，如苹果公司(T16)、谷歌公司(T19)、微软公司(T20)、T21 公司()是一个群体，石油公司(T30)和天然气公司(如雪佛龙公司(T22)、埃克森美孚公司(T25)或西方石油公司(T27)是一个群体，以及许多其他基于行业的群体。
这些分组对于将一家公司与商业活动联系起来是有意义的，但在根据其规模、结构和种类来确定类似的公司时，它们也是相当无用的。
例如，在新冠肺炎危机中，一个诱人的问题是:
哪些公司****在价格下降最多？
哪些 公司****不太可能破产**？**
商业中被低估的和？这是一个好的机会吗？
很好地理解行业分类不太可能在回答这些问题时提供切实的价值。我们已经观察到航空公司和游轮公司的股票价格遭受了巨大的损失，而像 Zoom 这样的“远程工作”技术却使它们的价格翻了一番。
https://www.vhinny.com/display/ZM
虽然这些都是激动人心的机会，但现在和要问的一个重要问题是:
- 处于底部的公司可能非常便宜。在它们回升之前，我应该买哪些？
- 处于顶端的公司可能被高估。在价格回落之前，我应该卖出哪些股票来固定利润？
为了回答这些问题，作为一名数据科学家，我建议开发一种更好的方法，根据公司的业务表现而不是业务活动来定义公司集团。
价值【10 b+】美元的公司很可能与那些价值低于【500】美元的公司截然不同。拥有高比例有形资产的公司不同于根本没有有形资产**的公司。与负债少的公司相比，负债多的公司面临更大的风险。这些属性的各种组合呢？**
在这项研究中，我将特别使用机器学习和无监督聚类来定义这些属性，并开发一种新的股票分组方法。
选择维度
有了 Vhinny 的财务数据，我有~100 个功能可以选择。不像之前的研究，我用它们来预测明年的收入，聚类要求我从一开始就有选择性。更不用说处理许多功能的计算 复杂性了，两位数的功能很难评估。
首先，我根据自己的投资直觉选择了几个特征，来捕捉最能让公司与众不同的主要方面。看完完整的清单后，我的选择落在了:
- 净收入—获取盈利能力
- 总资产—获取规模
- 负债权益比——捕捉融资结构
- 营业利润——捕捉盈利的难度
- 每股收益增长(EPS) —捕捉逐年增长
让我们来看看这些功能是如何相互关联的:
这个斯皮尔曼相关图表明，除了资产和净收入之外，大多数特征都不相关。这在直觉上是有道理的，因为赚很多钱通常需要大量资产来维持这种收入水平。
拥有相关特征不太可能帮助我提高聚类提供的洞察力。为了减轻这一点，我将删除净收入。没有它，我的公司简介就无法了解公司的盈利能力。让我们将净收入转换成盈利能力，盈利能力简单地定义为公司当年的收入是正还是负。
这是新的相关矩阵:
看起来不错。用盈利能力代替净收入后，我得到了包含独立特征的数据集，同时代表了所有感兴趣的维度。
这是一个煮咖啡或绕着街区转一圈的好时机。在下一篇文章中，我将研究这些特性之间的分布，并做简单的预处理，为集群做好准备。
顺便说一下…
我们连线吧！
我很高兴和那些和我一样走向财务独立的人联系。如果你也在寻求经济独立，或者你想合作、交流想法，请联系我们！以下是一些可以找到我的地方:
- www.vhinny.com—投资研究平台，为您自己的分析提供金融数据
- https://www.linkedin.com/company/vhinny——加入我们 LinkedIn 上的社区，在那里我和其他贡献者分享与投资相关的内容
干杯！
用 PyCaret 实现 Tableau 中的机器学习
在几分钟内设置 ML 管道的逐步集成指南
PyCaret 是最近发布的 Python 开源机器学习库，它在低代码环境中训练和部署机器学习模型。要了解更多关于 PyCaret 的信息，请阅读这个公告。
本文将展示 PyCaret 如何与 Tableau Desktop 和 Tableau Prep 集成，这为分析师和数据科学家向其仪表板、报告和可视化添加一层机器学习开辟了新途径。通过减少编码所需的时间以及购买额外软件的需求，快速原型制作现在可以在整个组织的分析师已经熟悉和可用的环境中实现。
学习目标
- 训练有监督的机器学习模型，并在 PyCaret 中创建 ML 管道
- 将经过培训的 ML 管道加载到 Tableau 桌面和 Tableau 准备中
- 创建一个仪表板，传达来自模型的见解
- 了解如何使用 Tableau 将模型部署到生产中
直销业务背景
此处的示例将重点介绍如何建立一个基本的直接营销倾向模型，该模型使用分类算法来预测哪些客户在通过文本或电子邮件收到要约后最有可能主动拜访。
然后将创建一个仪表板，它可以采用经过训练的模型，并预测新活动可能会有多成功，这对设计促销计划的营销人员来说是有价值的。
通过使用 PyCaret 和 Tableau，企业可以快速设置报告产品，使用现有软件和最少的前期开发时间持续生成预测视图。
开始之前
需要遵循的软件:
1 — Tableau 桌面
Tableau Desktop 是一款可视化分析工具，用于连接数据、构建交互式仪表盘以及在整个组织内分享见解。
2 —表格准备
Tableau Prep 提供可视化界面，通过设置流程和时间表来组合、清理和调整数据。
3 — Python 3.7 或更高版本
Anaconda 是用于数据科学的 Python 编程语言的免费开源发行版。如果你以前没用过，可以在这里下载。
https://www.anaconda.com/distribution/
4 — PyCaret Python 库
要安装 PyCaret 库，请在 Jupyter notebook 或 Anaconda 提示符下使用以下代码。
pip install pycaret
这可能需要 15 分钟。如果遇到任何问题，请查看 project GitHub 页面了解已知问题。
5—tabby Python 库
TabPy 是运行 python 脚本所需的 Tableau 支持的库。
从 GitHub 页面:
tabby(Tableau Python 服务器)是一个分析扩展实现，它通过允许用户执行 Python 脚本和通过 Tableau 的表计算保存的函数来扩展 Tableau 的功能。
要安装 TabPy，请在 Anaconda 提示符或终端中使用以下代码。
pip install tabpy
安装后，使用下面的代码启动一个使用默认设置的本地服务器。
tabpy
要将 Tableau 连接到 TabPy 服务器，请转到“帮助”>“设置和性能”>“管理分析扩展连接”。选择 TabPy 并输入 localhost、端口 9004(默认)并测试连接。
Python 脚本现在可以通过输出为表计算的计算字段在 Tableau 中运行。
有关自定义服务器选项，请参考 TabPy GitHub 页面。在外部服务器和/或云上运行 TabPy 和配置 Tableau 服务器将不会在这篇文章中讨论，但是请看这里了解更多信息。
直接营销数据
将使用的数据集包含通过文本和电子邮件发送给客户的各种营销优惠信息。它包含组织成 ID 列的 64000 条记录、与客户或发送的消息相关的 10 个特征以及指示是否有访问发生的二进制目标。数据可以在这里下载。
预先训练一个模型
虽然可以在 Tableau 中执行模型训练过程，但这通常不是首选方法，因为每次刷新数据或用户与视图交互时，脚本都会重新运行。这是有问题的，因为:
- 当用新数据重新训练模型时，预测可能会发生意外变化。
- 不断重新运行脚本会影响仪表板的性能。
更合适的方法是在 Tableau 中使用预训练模型来生成对新数据的预测。在这个例子中，我们将使用 Jupyter notebook 来演示如何使用 PyCaret 来直接完成这个过程。
在 PyCaret 中构建模型
在 Jupyter Notebook 中运行以下代码将训练一个朴素贝叶斯分类模型，并创建一个保存为 pickle 文件的 ML 管道。
注意，建立和保存模型只用了 4 行代码。完整的笔记本可以在这里下载。
包含训练模型和管道的 Pickle 文件
看不见的数据将用于模拟尚未收到报价的新客户列表。当仪表板部署到生产环境中时，它将连接到包含新客户信息的数据库。
请注意，在设置阶段，PyCaret 执行自动预处理，在这种情况下，通过一次热编码将功能数量从 10 个扩展到 39 个。
这只是 PyCaret 内置功能的皮毛，因此强烈建议查看 PyCaret 网站上的分类模块和教程。这里不涉及所选型号的具体细节。
将模型加载到 Tableau 桌面
现在，看不见的数据将被传递给训练好的模型，并在 Tableau 桌面中进行标记。
说明:
1)打开 Tableau 并连接到在上面的代码中创建的文本文件 new_customer.csv。这只是一个例子，但理想情况下，新的或未标记的客户数据将驻留在数据库中。
2)在新的工作表中，选择分析>创建计算字段，或在数据窗格中单击鼠标右键。输入以下代码:
SCRIPT_INT("
import pandas as pd
import pycaret.classificationnb = pycaret.classification.load_model('C:/Users/owner/Desktop/nb_direct')X_pred = pd.DataFrame({'recency':_arg1, 'history_segment':_arg2, 'history':_arg3, 'mens':_arg4, 'womens':_arg5,'zip_code':_arg6, 'newbie':_arg7, 'channel':_arg8, 'segment':_arg9, 'DM_category':_arg10})
pred = pycaret.classification.predict_model(nb, X_pred)
return pred['Label'].tolist()",
SUM([recency]),
ATTR([history_segment]),
SUM([history]),
SUM([mens]),
SUM([womens]),
ATTR([zip_code]),
SUM([newbie]),
ATTR([channel]),
ATTR([segment]),
SUM([DM_category])
)
- 脚本函数指定将从计算中返回的数据类型。在这种情况下，它是访问的二元预测标签。
- PyCaret 中的 load_model()函数加载先前保存的模型和转换管道，该管道被保存为 pickle 文件。
- X_pred 是一个 dataframe，它将通过 _arg1、_arg2、_arg3…符号将连接到 Tableau 的数据映射为输入。这些字段列在脚本的末尾。
- predict_model()采用定型模型并根据新的数据输入进行预测。注意，新数据是通过 PyCaret 设置阶段(编码)创建的转换管道传递的。
- 然后，标签以列表的形式返回，可以在 Tableau 中查看。
3)通过将 ID 和标签列拖动到视图中，可以看到模型预测。
重要的是要理解输出是一个有一些限制的表格计算:
- 该脚本只有在拖到视图中时才会运行。
- 除非两者都在视图中，否则不能用作进一步计算的基础。
- python 生成的数据不能追加到 Tableau 提取中。
- 每次视图更改时都会运行该脚本，这可能会导致长时间的等待。
这些缺点非常明显，因为当每个记录都必须包含在视图中时，仪表板选项变得有限，在这种情况下，脚本运行 3200 条记录需要大约 4 分钟。
可行的应用包括生成可以导出的评分列表或如下所示的摘要视图。
由此得出的一个例子是，高消费客户最有可能光顾，这在商业上是有道理的，但也可能是不必要折扣的一个指标。
将模型加载到 Tableau 准备中
绕过在 Tableau Desktop 中直接运行脚本的限制的一个很好的替代方法是使用 Tableau Prep。可以连接新数据，然后将其传递给模型，不同的是，这一次预测的标签被附加到输出中。当连接到 Tableau 时，新列可以正常使用，而不是作为表计算。
说明:
1)打开 Tableau Prep 并连接到在上述代码中创建的文本文件 new_customer.csv。
2)在流窗格中选择文件旁边的“+”按钮，并添加脚本选项。像在 Tableau Desktop 中一样，使用 localhost 和 9004 连接到应该还在后台运行的 TabPy 服务器。
3)接下来，需要创建以下 python 脚本，并使用浏览选项连接到 prep。可以在这里下载。
创建一个加载 pickle 文件的函数，该文件包含保存的模型和转换管道。装载到 prep 中的数据自动保存在 df 对象中，并传递给模型。
PyCaret 输出将返回初始数据集和两个新追加的列；标签(预测)和分数(预测的概率)。输出模式确保将列和数据类型正确读入 prep。
然后必须将函数名输入到 prep 中。
4)选择脚本图标旁边的“+”号，然后选择输出。可以发布为. tde 或。将 hyper 文件发送到 Tableau 服务器，这是生产环境中的首选方法，但在本例中，会将. csv 文件发送到桌面。
请注意 label 和 score 列现在是如何追加到原始数据集的。选择“运行流程”以生成输出。此处可以下载的流量文件。
在服务器环境中，可以安排流运行的时间，并在数据到达实际的 Tableau 仪表板之前自动完成评分过程。
将流输出加载到 Tableau 中
新标记的数据现在可以连接到 Tableau Desktop，而没有表计算限制和变慢。
可以创建聚合和任何其他所需的计算，以设计显示各种预测指标的摘要仪表板:
一旦数据和 ML 管道建立，营销人员和高管将能够快速跟踪即将到来的活动可能如何进行，只需最少的干预。包含示例仪表板和早期脚本的 Tableau 文件可以从这里下载。
结束语
本文展示了 PyCaret 如何与 Tableau Desktop 和 Tableau Prep 集成，以便在现有工作流中快速添加一层机器学习。
通过使用组织和 PyCaret 库熟悉的工具，可以在几分钟内建立完整的 ML 管道，从而使预测分析原型快速启动。
有用的链接
PyCaret: Youtube
浏览器中的机器学习
在线构建可共享的机器学习模型
Jupyter 笔记本是用于构建机器学习模型的最常见的环境之一。然而，它们也有一些缺点。Jupyter 笔记本非常适合在本地开发机器学习模型，但很难分享和协作使用该工具生成的代码。
此外，还需要合理的设置，尤其是如果您不是 python 的当前用户。您需要设置一个 python 环境，安装 Jupyter 及其依赖项，以及您可能需要的任何其他 python 包。
幸运的是，有一些工具可以让您在笔记本上直接在浏览器中运行和开发 python 代码，而不需要任何设置。在这篇文章中，我将简要介绍其中的两个工具；
- 谷歌联合实验室
- Kaggle 内核
谷歌合作实验室
Google Colaboratory ，通常被称为 colab，是 Google 创建的一个产品，允许任何人在浏览器中创建和运行 python 代码。它有许多内置的标准机器和数据科学库，包括 pandas 和 scikit-learn。您还可以在每个笔记本中安装几乎任何其他 python 库。
要访问 colab，你需要注册一个谷歌账户，然后你就可以免费访问笔记本环境和包括 GPU 在内的计算资源。
让我们快速演示一下。
登录到您的 Google 帐户后，转到 drive 并选择新的 Google 协作室。
这将打开一个新的空笔记本。
您可以通过运行pip freeze来查看预安装的软件包。
如果你需要安装任何还没有的包，你可以通过运行pip install package来完成。
有多种方法可以导入数据，包括直接从 Google drive 加载文件。让我们看一个从本地 CSV 文件导入数据的例子。
首先，我们运行这段代码。
from google.colab import filesuploaded = files.upload()
然后，您会看到一个按钮，用于选择存储在本地系统上任何位置的文件。
您现在可以自由地编写代码来创建您的机器学习模型。
Google colab 笔记本可以通过链接共享，就像你可以共享任何 Google 文档一样。链接的接收者可以运行和编辑您的代码。
Kaggle 内核
Kaggle 内核需要一个 Kaggle 帐户，但也可以完全免费使用。它们与 Google colab 笔记本非常相似，但一个优点是它们包括版本控制。
一旦你创建了一个帐户，你可以导航到网站的内核部分，并选择新笔记本。
和 colab 一样，Kaggle 内核提供了许多标准的 python 库，你可以用pip freeze查看。导入其他库使用与 colab 完全相同的方法，安装包也是如此。
加载数据非常简单。首先选择文件，然后添加或上传数据。
现在你有很多选择。您可以使用 Kaggle 数据集、内核输出文件或上传您自己的本地 CSV 文件。
正如我提到的，Kaggle 内置了版本控制。这意味着您可以将更改提交到您的内核或其他人的内核，并在需要时跟踪和恢复到以前的版本。这有助于合作。
这是对这些工具中可用选项和功能的简要介绍。这两者的功能都值得进一步研究。我经常使用浏览器内笔记本向他人提供我的工作演示，尤其是那些可能不会使用 Jupyter 笔记本或 python 的非数据科学家。这两个工具也可以成为学习机器学习和数据科学的好方法，而无需在本地设置 python 和笔记本环境的开销。
感谢阅读！
我每月发送一份时事通讯，如果你想加入，请点击此链接注册。期待成为您学习旅程的一部分！
云中的机器学习与内部部署
云只是别人的电脑
开发人员之间流传着一个笑话，云只是别人电脑的一个词。但事实是，通过利用云，您可以获得使用本地服务器场无法实现的优势。
超级云提供商(AWS、Azure、GCP)能够提供更低的总拥有成本，同时提供从可扩展性到安全性的卓越功能。当你只能在需要的时候从货架上拿下来的时候，在内部构建所有东西是没有经济意义的。云供应商不断创新解决方案，例如只按使用时间计费的服务器，而不是按运行和等待请求的时间计费的服务器。他们还能够吸引可扩展性和安全性等方面的专业人才，这是其他所有供应商无法做到的。
云和机器学习
大多数机器学习实验都是从理解你笔记本电脑上的数据开始的，不需要那么多计算能力。但是很快你就会遇到超出你的本地 CPU 所能提供的需求。云是迄今为止更具可扩展性的进行机器学习的地方。您将获得最新的 GPU，甚至是您自己无法负担和维护的 TPU。
但是，当您的需求满足以下一些标准时，本地服务器场是一种有效的替代方案:
- 您需要 24/7 的计算能力(例如，由于大型团队或大型模型)
- 出于合规性或其他原因，您拥有不能离开数据中心的敏感数据
在许多情况下，混合解决方案也可能是可行的，其中初步模型测试在内部完成，生产就绪模型在更强大的云机器上开发，或者通过在推断之前尝试数百个不同的模型来开发。在大多数情况下，使用正确的工具，云是进行原型开发和生产就绪机器学习的最快方式。
在云中进行机器学习的三个主要原因:
- 灵活的资源使用以应对尖锐的硬件资源需求
- 只需点击一个按钮，即可访问最新的硬件
- 不受限于特定硬件的解耦架构
ML 云实施的最佳实践
在与数百家从事机器学习的公司合作后，我们已经看到了内部硬件和云计算的好处。关键要点如下:
- 云提供商之间存在差异，尤其是对于寻求数据隐私的企业而言，找到最适合您的提供商
- 确保您的数据与您要使用的计算位于同一个云数据中心。如果您的数据需要从世界各地的本地数据存储进行传输以进行计算，则大型数据集上的训练模型会变得很慢。如果您使用 AWS EC2 来最小化延迟等，请将您的数据存储在 S3。
- 对于结构化数据(数据库或 Spark 集群中的表格数据)，使用预处理步骤，首先将数据转储到平面文件中。文件为数据库查询提供了持久层，从而在训练模型时提高了版本控制和可重用性。遵循“提取一次，无限训练”的黄金原则。
- 混合解决方案是一种最佳实践:如果你已经有本地硬件，不管是一个 Tesla V100 还是一个 Titan RTXs 的服务器群，都可以使用它们。向云的过渡不会一蹴而就，这很好。
- 获得一个机器学习平台，将硬件从数据科学家那里抽象出来。
- 让您的数据科学家专注于数据科学，而不是 DevOps 或 MLOps，无论他们使用哪种云或本地硬件。
最初发表于【https://blog.valohai.com】。
网络分析中的机器学习——谷歌分析变得更好了吗？
谷歌分析 4 最近推出，它具有先进的机器学习能力。未来 5 年，ML 会统治网络分析的世界吗？
企业一直试图以更好的方式了解客户及其买家的旅程，以推动更好的转化率和增加终身价值 。而且，在当今世界，当买家的大部分旅程都在网上时，网络分析变得比以往任何时候都更加重要。
网络分析与机器学习能力结合在一起，对企业来说确实非常了不起。谷歌分析 4 已经在这条路上走了一英里。
在这篇文章中，我将谈论谷歌分析 4 以及新引入的机器学习功能如何更好地改变分析。
但在我们开始之前，让我们回顾一下机器学习是如何改变网络分析的！
网络分析中的机器学习
除非能够分离和处理，否则收集的数据毫无用处。随着网络用户数量的不断增加，网站间的平均流量也在不断增加。
在使用机器学习的大数据分析(BDA)出现之前，分析这些庞大的数据集是一件痛苦的事情。
大数据分析(BDA)
一篇名为《 关于将大数据分析整合到大洞察以创造价值的调查 》的研究论文提到了大数据分析的七个特征，具体如下:
BDA 的七个特征包括“量”(支持非常大的数据量)、“速度”(快速分析数据流)、“多样性”(支持不同种类的数据)、“准确性”(支持高数据质量)、“价值”(洞察和利益的价值)、“可变性”(支持不断变化)和“价”(支持数据的连通性)。
说到这里，我们大多数人都知道，两种最常见的数据分析算法是有监督的 ML 算法和无监督的 ML 算法。
对于一些不知道这两者之间区别的人来说，简单地说，这里有监督 ML 和非监督 ML 算法。
无监督方法/算法是自我学习模型，主要用于发现未检测到的信息/模式。
另一方面，监督 ML 算法采用已知的输入数据&该数据的已知输出，并使用该信息来训练模型，以便为全新的数据集生成合理的预测。
这两者结合在一起，已经完全改变了企业使用网络分析的方式，并且变得更好。
大数据分析在企业决策方面使用网络分析的重要性与日俱增。这相应地增加了机器学习算法在网络分析中的应用的紧迫性，用于价值创造和 有机业务增长 。
谷歌分析和机器学习
谷歌分析是网络分析领域的领导者，分析收集的两种主要数据类型是——用户属性/维度和事件。
企业一直在使用这些数据，通过更好地了解用户来优化网站数据。
在用户维度类别中，Google Analytics 收集的一些数据类型有— 年龄、性别、国家、设备型号/类别等。Google Analytics 收集的一些事件类型有— 搜索、选择内容、注册、点击、文件下载、首次访问等。
数以百万计的小型和大型企业使用谷歌分析以更好的方式了解他们的客户，并为他们创造更好的用户体验。
在网络分析中使用机器学习绝对不是一件新鲜事，但是在谷歌分析 4 中使用机器学习的方式是全新的！
多年来，人们已经在网络分析中使用机器学习功能，以更好的方式理解网络流量。
例如，我们之前已经了解过数据科学— 将 Google Analytics 命中级别数据发送到 BigQuery 和 自动将数据导入到 Google Analytics 。
除此之外，我们已经看到监督或无监督聚类如何帮助我们以更全面的方式理解 web 流量。
如果你不熟悉如何使用聚类——一种理解网络流量的机器学习技术，这里有一篇 Russ Thompson 的文章，可以帮助你获得基本的想法。
但当我们谈论在网络分析中使用机器学习时，你应该知道每个机器学习模型都需要几个元素来实现最大影响:
- 你需要你的 ML 模型来回答的问题。
- 准备数据馈入你的模型。人们更喜欢使用 R 从 Google Analytics 或任何其他来源收集网络分析数据。
- 评估您的 ML 模型的产出。虽然你可能理解 web analytics 中的机器学习模型产生的数据，但你必须实现数据可视化，以便管理层和非技术团队成员都能理解。
- **利用数据获得更好的投资回报。**提高商业投资回报率是在网络分析中使用机器学习的核心原因之一。
但是，如果谷歌分析自己开始使用 机器学习 并通过以比以往任何时候都更容易理解的格式使用数据来展示见解，从而帮助你最大限度地利用它，会怎么样呢？好消息是——谷歌分析 4 正在这么做！
谷歌分析 4:机器学习如何改变谷歌分析？
2020 年 10 月，谷歌使 谷歌分析 4 在公共领域 可用。然而，类似的东西的测试版于 2019 年 7 月发布。
最初的想法是将应用和网络分析结合起来，从总体上激发 更好的营销 和业务投资回报率。
在 Google Analytics 中测试机器学习的可用性 1 年多之后，Google 终于在测试期推出了 Google Analytics 4，即所谓的 App+Web Properties。
在 Analytics 4 之前，你可以问这样的问题:“上个月哪些产品的购买量超过了 100 次？”分析智能将使用其 ML 功能生成结果。
但下面是引入机器学习后，Google Analytics 4 的新功能。
实时监控流量
您现在可以用所有支持的语言提问，以实时生成结果。您可以使用属性“实时”来获取过去 30 分钟的分析数据。例如，你可以监控一天促销活动的网站/应用流量。
您还可以监控您正在开展的活动的即时效果，或者最近在您的网站或应用程序上所做的更改对其有何影响。
搜索即时答案
你可以用自然语言询问分析数据，以在谷歌分析 4 中获得即时答案。您可以指定属性、指标、时间范围或维度。
例如，您可以搜索 “亚利桑那州上周转化率” 或 “美国上周移动用户” 以获得报告、数据、见解等。
跨平台分析
“应用+网络属性”和现在的谷歌分析 4 的一个关键亮点是它能够通过结合你的网络和应用用户的数据向你展示洞察力。使用机器学习功能，Google Analytics 4 可以根据您选择的任何属性(指标、维度等)为您提供即时数据可视化。
您可以使用 Google Analytics 4 在您的用户漏斗中定义多达 10 个步骤，并清晰地可视化您的用户在每个步骤中是如何进入或退出的。这将帮助你找到对你的网络或 移动应用 用户来说什么有用，什么没用的答案！
智能提醒
如果您的网站或应用程序使用机器学习功能看到用户的显著增加/减少或您的网络/应用程序数据的变化趋势，新的 Google Analytics 4 会提醒您。
这些智能警报将帮助您在用户数量突然增加或突然减少时采取任何即时措施。此外，新的 Analytics 4 可以帮助您提前预测您的用户行为。例如，它可以让你预测特定用户群的收入——流失概率。
谷歌信号
虽然谷歌信号并不新鲜，但在谷歌分析 4 中打开谷歌信号确实可以帮助你提高营销投资回报率，并采取措施进行 实时线索生成 。
例如，使用来自打开广告个性化的用户的谷歌数据，Analytics 4 在谷歌信号打开时生成更准确的用户计数报告。
这些只是在引入机器学习功能后，新的谷歌分析 4 中引入/改变的一些东西。话虽如此，Google Analytics 引入 ML 只是一个开始。
总的来说，机器学习在谷歌分析以及网络分析的未来中扮演着重要的角色。
机器学习在未来网络分析中的作用
你知道吗 微软 Clarity——微软 的网络分析工具将于 2020 年 10 月公开发售。
虽然谷歌分析 4 和微软 Clarity 的全面比较尚未公布，但可以肯定地说，鉴于其分析应用数据的能力，分析 4 也优于 Clarity。
话虽如此，甚至微软 Clarity 也增加了机器学习功能，允许其用户使用“过量记录”、“死点击”等参数来过滤网站数据和会话记录。
网络分析中的机器学习绝对是未来，而且前景光明。随着自然语言处理的新进展，如谷歌的大鸟，机器学习肯定会彻底改变我们今天看待和使用网络分析的方式。
谷歌研究人员最近在 arXiv 上发表了一篇题为《大鸟:更长序列的变形金刚》的论文。
towardsdatascience.com](/understanding-bigbird-is-it-another-big-milestone-in-nlp-e7546b2c9643)
谷歌和微软正式将先进的机器学习和人工智能纳入网络分析的好处是，它将使营销人员和企业更容易执行和衡量活动。
此外，它还将帮助 降低企业的营销成本 ，通过实时优化投资回报率，以及消除使用第三方人工智能/人工智能工具进行更智能的网络分析的需求。
这篇文章讲述了这个疫情如何给了人工智能-ML 阿朵急需的推动，以及这个新发现的…
towardsdatascience.com](/the-story-of-newly-found-friendship-ai-ml-and-the-pandemic-6ceb02376ebd)
机器学习对于保持家庭照明变得越来越重要
机器学习超越了图像分类和语音识别。了解为我们的家庭供电变得多么重要。
演职员表:作者修改自维基百科
你有没有想过，为什么每当你打开灯，它们就会工作？发电站怎么知道你要按下 3 中的开关…2…1…嗯，他们没有！每当你按下开关来点亮你的房间或打开空调，你就向整个电网发送振荡信号。对于一个灯泡来说，这些振荡可能微不足道，但当你考虑整个建筑一起被点亮时，它可能会在整个城镇的电网中发送电波——我们作为电力工程师，真的很担心这一点。如果这些波浪不停下来会发生什么？
演职员表:修改自维基百科
有什么问题？
作为一个孩子，这个问题对我来说似乎是一个更可怕的问题——当我跑向我的妈妈和爸爸，从黑暗中想象的幽灵手中拯救自己的时候。但是当我长大到可以攻读这个领域的博士学位时，我意识到它远不止于此。这个问题会让美国这样的国家每年损失 1500 亿美元。但是你认为问题出在哪里？— 如此庞大的电力系统的复杂性。不信你看下图。
演职员表: GENI
你能数出那些线吗？——肯定不是。这代表了美国互联电网。现在再想一想——如果你突然点亮一栋大楼，这样一个由输电线路和发电站组成的复杂网络将如何识别和处理我之前告诉你的电波，并满足你的电力需求？
当电网比现在小得多、简单得多、也不像现在这样互联互通时，传统的控制方法在控制电网方面已经被证明是成功的。然而，对于更复杂的系统，分布式私人发电，如太阳能和风能，不确定性被证明是这种稳定电网的传统技术的风险。
这就是机器学习的用武之地！
我非常确定，每当你听到 ML，你的脑海中就会浮现一些想法。
这是给计算机科学家的。
像谷歌和脸书这样的大公司使用这个。
它用于语音和图像识别。或许还能预测股票价值。
别担心，几年前我也戴着同样的帽子。当我听到 ML 和神经网络时，我不能想到任何其他事情。我承认，我也不明白，但不管是谁知道，他们对我来说都是神奇的神。但是我确信即使是上帝也不知道有一天我会在这个领域获得博士学位，而且我会喜欢这样做。
从现在开始，它可能会变得有点技术性，但我保证让每个人都能理解它，并为这个研究领域激发一些聪明的头脑。
电力系统最大似然研究的现状
美国现代电力工业始于 1879 年托马斯·爱迪生发明的第一只实用灯泡。很快，第一座集中式火力发电厂建成，并在纽约州投入使用。从那以后，很多事情都变了。公司从直流电(DC)转向交流电(AC)。更多的家庭，更多的工厂成为网络系统的一部分。直到大约二十年前，电网仍然主要由化石燃料供电。然而，可再生技术和其他替代发电资源的最新进展使得电网变得更加复杂，也为令人惊叹的新奇研究工作开辟了领域。我将试着强调几个我认为最令人兴奋的 ML 研究正在发生的主要领域——但是请注意，我向你保证还有更多！
广域监控系统(WAMS)
WAMS 由传感器、服务器和算法组成，它们在广域范围内发挥作用，就像完整的北美电网一样，保持系统的稳定性，这样你和我就可以在炎热的天气里继续操作我们的空调。在过去的十年中，安装了大量被称为相量测量单元(PMU)的快速采样传感器，从而实现了对整个系统的实时监测和控制。
本文简要介绍了相量测量单元(PMU)的概念。PMU 的起源可以追溯到…
link.springer.com](https://link.springer.com/article/10.1007/s40565-018-0423-3) 
学分:环评
电网的庞大规模、大量的数据流以及由不同的功耗和太阳能和风能的渗透引起的系统中广泛的不确定性，对稳定此类系统的传统控制提出了挑战。因此，研究人员正朝着基于 ML 的控制和监控这种巨大系统的方向发展。
大量工作正在进行，以使用神经网络的通用函数近似(UFA)属性，通过从 PMU接收的大量数据来近似电力系统的未知动态。这不仅能够更好地洞察系统的特性，而且有助于做出实时和更明智的控制决策。这个问题不仅让控制理论家感兴趣，甚至大数据科学家和电力工程师也需要携手合作来解决这个庞大的问题。
演职员表: SlidePlayer
以图中所示系统的闭环控制为例。我们希望跟踪输入参考信号，然而，由于系统中的不确定性，传统的控制器无法提供理想的结果。另一方面，神经控制器，其基本上将误差信号( e )作为输入，并向系统输出致动信号。学习块通过使用期望的性能度量评估跟踪信号来评估该神经控制器的性能，并相应地调整神经控制器的参数。这在控制社区中也被称为**“强化学习”**，这是另一个被电力公司广泛采用的非常流行的研究。
不仅仅是针对神经网络，一般来说，在使用强化学习(RL)方面也正在进行一些令人惊讶的研究——这是 ML 和系统识别技术的应用，以解决这个具有挑战性的问题。如果你从来不知道这些术语也是 ML 的一部分，恭喜你！—你只需要知道 ML 有多多样化。
负荷预测
预测用电量对于有效的能源需求管理至关重要。糟糕的预测和不正确的决策不仅会给发电公司造成数百万美元的损失，还会让消费者几个小时没有电，导致业务和生产力损失。
传统的负荷预测方法依赖于时间序列分析和回归模型。这些模型在过去给出了令人满意的结果，但是最近它们的可信度和可靠性开始受到质疑。虽然这不是唯一的原因，但很大程度上是由于电网中大量可再生能源的涌入。
学分: Unsplash
这种可再生能源的发电不仅不确定，而且非常依赖的短期和长期天气预报。更麻烦的是，天气、国家节假日、最近电动汽车的繁荣等因素。使得准确预测变得更加困难。当被迫考虑如此大量的参数进行预测时，传统方法表现不佳。
演职员表:月亮、智勋和朴、成宇和罗、成民和黄、恩俊。(2019).建筑能耗预测的人工神经网络结构比较分析。国际分布式传感器网络杂志。15.
在过去的十年中，许多研究人员对使用复杂的 ML 结构解决这个复杂的问题产生了兴趣，例如使用神经网络的深度学习。Moon 等人的图显示了如何使用神经网络，使用各种信息作为输入，如日期、天气甚至节假日，来进行负荷预测。准确的负荷预测问题对电力工程师来说是如此迷人和关键，以至于研究人员研究了各种各样的 ML 技术，而不仅限于预测的深度学习。例如，一种流行的神经网络结构，称为长短期记忆(LSTM)框架，已被大量研究用于处理时间序列信息，以做出准确的短期负荷预测，这在电力公司的日常规划中变得非常重要。
随着负荷需求的增加和电站的复杂化，提前了解电力系统的运行状况是非常必要的。
www.sciencedirect.com](https://www.sciencedirect.com/science/article/pii/S1876610219310008)
能源市场
演职员表: Pixabay
你可能听说过也可能没有听说过这个术语。本质上，能源市场是处理能源或电力贸易和供应的市场。对能源的投标在决定电力公司的利润方面起着重要作用。这个市场非常依赖准确的负荷预测。一般来说，大多数市场都有提前一天定价和实时定价。这取决于各种因素，如预期的能源成本、拥挤和传输损耗、可靠性等。运营商根据这些信息和他得到的报价，决定买卖能源和合适的价格。然而，这种定价的动态性高度非线性，运营商很难实时决定“最优”定价。
运营商依靠算法来为他们做出这个决定。机器学习，特别是被称为深度学习极值理论(DL-EVT)的深度学习框架正被广泛用于寻找非线性动力学的最优解，以便运营商做出购买或出售电力的最佳价格的决定。
智能电网
演职员表: Pixabay
如果你读过一些关于电学和最近研究的东西，你可能肯定听说过这个术语。智能电网基本上是一组分布在电网中的传感器和执行器，允许信息在消费者和电力公司之间来回流动。这种信息交换允许对电网进行自动实时控制，使其高度可靠和稳定。在线和实时做出决策的能力高度依赖于机器学习架构来做出最佳决策，以最小化成本约束，如传输损耗、稳定性约束甚至客户舒适度。
什么？—客户舒适度？怎么会？
一些公用事业公司通过传感器和致动器远程有效地控制它们的空调单元来控制大型建筑物的温度。这给了公用事业公司实时控制电网的某个部分的完全杠杆作用，以确保整个系统能够满足电力需求和稳定性要求，同时建筑物所有者看到他们的电费有很大折扣让公用事业公司控制。智能电网已经成为电力行业的一个重要方面，顶级研究人员和工业家称之为电力的未来。随着可再生能源、分布式能源(如电池储能、智能电网)的涌入，保持弹性和性能是前进的方向。猜猜看，这是一个热门的研究领域，尤其是对那些对大数据和机器学习感兴趣的人来说。
没有大数据科学家和 ML 工程师，智能电网的未来是不完整的。
IEEE 的智能电网网站提供有关智能电网的信息、资源和专业知识。IEEE 已经在…
smartgrid.ieee.org](https://smartgrid.ieee.org/)
我希望你喜欢这篇文章，它让你对机器学习如何被广泛用于我们的电网有了深入的了解。如果它让你兴奋，那很好。如果它让你感到困惑，那就更好了——因为老实说，即使在这个领域做了两年的研究，我仍然不理解其中的许多内容！如果你想和我联系或问我任何事情，请发邮件到***【jishnudeep.kar@gmail.com】***或在insta gram上 DM 我。
如果你喜欢这个，你可能也会喜欢这些。
如果你计划去美国，并且对那里的文化太过好奇，这可能是你最好的剧透！
medium.com](https://medium.com/illumination/cultural-shock-visiting-the-usa-from-india-a-students-perspective-1f901df99984) [## 为什么我要辞去 7 万美元的工作，过“无聊”的生活？
在进入印度最负盛名的 IIT 德里学院后，我唯一的梦想就是获得高薪…
medium.com](https://medium.com/the-innovation/why-i-left-my-70k-job-for-a-boring-life-160129d42f21) [## 新冠肺炎会扼杀美国梦吗？
不，还没有结束。保持你的梦想。是时候和这个疫情战斗了，迎头痛击！
medium.com](https://medium.com/illumination/will-covid-19-kill-the-american-dream-daad8f6c5cea)
机器学习变得越来越容易。软件工程仍然很难
意见
为什么这对软件工程师有利，对 ML 工程师不利
来自 Pexels 的 Andrea Piacquadio 的照片
免责声明:这是一篇观点文章。也有失偏颇。我认为，如果有更多的多面手和创造者(而不是专家)来制造东西和解决问题，这个世界会变得更好。
在过去的 5 年里，机器学习变得更加容易。同时，软件工程比以往更加复杂。
这对软件工程师来说是一件好事。但不适合 ML 专家。
这是 ML 向软件工程和数据科学向数据分析的进展。
机器学习工具变得越来越平易近人
谷歌很乐意让每个人都可以接触到训练 ML 模型，不管他们的技术知识如何(见:技术民主化)。
随着 ML 变得触手可及，云服务的市场也在增长，而理解算法的价值却在侵蚀。
从前，我们手工编写算法。然后 Sklearn 允许用几行代码做同样的事情。
最初的张量流很难使用。Keras 使它变得容易。
谷歌、微软和亚马逊现在都在云中提供选择、训练和调整模型的服务，然后立即在 API 后面提供模型。
要有人能训练人工智能还需要一段时间。但是随着复杂性的降低，它变成了经验丰富的软件工程师放在口袋里的另一个工具。
机器学习的发展集中在几种语言中
语言是一条护城河。句号。
你知道 COBOL 吗？如果是的话，你有一份终身工作。世界金融体系有赖于此。没有人再学习 COBOL 了。
大多数机器学习都是用 Python 实现的，而软件开发则分散在大量语言中。
https://www.tiobe.com/tiobe-index/
如果每个 ML 工程师都有 Python 经验，那么你就是在和每个 ML 工程师竞争。在软件方面，你只与使用相同技术的工程师竞争。
我总是惊讶地看到许多高薪的 Ruby on Rails 工作。它几年前就过时了，但是许多大公司(Shopify、Instacart、Kickstarter 等)因为传统原因还在使用它。
你完全可以也应该学习多种语言。成为一名优秀的软件工程师就靠它了。
软件工程包含更大范围的技能
我们期望软件工程师至少对所有的事情都有一些了解。
速写
后端工程师仍然知道浏览器是如何工作的。一个前端工程师有一些数据库的概念。两者都可以防止像 SQL 注入那样的安全漏洞。
对软件有一个整体的理解，更容易改变专业。它还让您能够构建端到端的解决方案。
广泛的技能组合使软件工程师更适合模糊的环境。随着需求的增加，软件工程师通常会转向数据科学。相比之下，数据科学家不太可能开发软件。
随着人们开始将 ML 视为硬编码条件逻辑的替代方案，我们将会看到更多的软件工程师从事 ML 工作。
成为一名合格的全栈开发人员需要数年时间
并且包含许多独立的技能。
优化数据库、构建 API 微服务和打造响应性前端毫无共同之处。它们可能用三种不同的语言实现。
我们在这些领域很少看到自动化。
相比之下，全栈 ML 工程师现在正在完成日益强大的 AutoML，为此我可以写一个 SOP，并委托一个实习生训练分类器。
软件工程技能组合中的所有部分自动化消失还需要一段时间。
机器学习是对产品的补充，而不是产品本身(通常)
少数公司将人工智能作为其核心产品，但大多数公司使用它来补充现有产品。
Medium 可能会使用机器学习进行文章推荐，但核心产品是写作/发布平台。
有趣的是，大多数公司将 ML 用于简单和相似的用例。这使得单个公司很容易将所述用例作为 SaaS 产品来提供。突然之间，创业公司不再需要在内部构建它了。
相比之下，像基础设施这样的问题就非常复杂和定制化。AWS 上没有现成的解决方案可以很快处理 Medium 的基础设施。
基础设施变得异常复杂
AWS 已经扩展到 200 多种不同的云服务。
Heroku 在云中运行应用程序的 PaaS 方法非常棒。但是在任何大规模下都变得非常昂贵。
因此，现在我们有一个全新的云堆栈需要管理(网络、数据库、服务器)，其中的一个小失误就可能导致巨大的安全漏洞。
有一个完整的开发子集叫做“云工程”，其工作是让软件在 AWS、GCP 或 Azure 上工作。
在较小的公司中，基础设施通常落在高级开发人员的肩上。
这是复杂的东西。但这也意味着工作和难以复制的技能。
前端开发是不断发展的
独自站在前端开发的顶端是一种技能。
当我开始开发时，用 jQuery 构建响应性前端是可以的。然后公司开始转向 Angular 或 React。Angular 变成 Angular 2(带有突变)。React 从类转移到功能组件，并增加了挂钩。
所有上述框架/库的工作方式完全不同。
有几家公司正在研究基于实体模型的自动生成前端。但同事们一致认为，他们离生产质量还有很长的路要走。
前端开发中的技术能力，加上对完美的感觉，令人惊讶地感觉暂时是合理的。
结论
软件开发是复杂的，包含各种各样的问题。这种复杂性有利于就业。
但更重要的是，广泛的技能组合赋予了端到端解决实际问题的能力。
为了建立一个典型的人能够解决他们自己社区中的问题的社会，软件工程是一个很好的起点。
机器学习有一席之地吗？绝对的。但是解决问题不仅仅是训练一个模型
学软件工程。制造东西。解决问题。
机器学习并不总是数据问题的解决方案
大数据和机器学习
概观
有人给了我一个很大的文件数据集，有人称之为大数据，并让我想出一个数据问题的解决方案。人们经常将大数据与机器学习联系在一起，并自动跳转到机器学习解决方案。然而，在处理了这个数据集之后，我意识到机器学习不是解决方案。这个数据集是作为一个案例研究提供给我的，我必须完成这个案例研究，这是一个 4 步面试过程的一部分。
任务描述
该数据集由一组跟踪多个建筑项目中的电子邮件活动的文件组成。所有数据都被匿名了。任务是探索数据集，并报告任何见解。我被告知，客户关心的是项目的持续时间和现场说明的数量，以及在项目中看到的变化，因为这些通常都要花钱。
数据 ETL
首先，通信数据被读入并附加在一起。对数据进行了重复检查。未找到重复项。
由于客户关心项目的持续时间，要求响应的日期和发送日期之间的差异是以天计算的。但是，有相当多的“要求响应日期”和“发送日期”值缺失。这些记录被排除在外；因此，数据集从 7 个变量的 20，006，768 条记录减少到 3，895，037 条。然后，将通信数据与邮件类型文件相结合，以确定通信类型是否对持续时间有影响。最后，合并一个包含每个项目记录数量的文件。
通常，在没有正当理由的情况下排除数据不是好的做法；然而，由于该数据集是作为工作申请流程的一部分分配给我的，我没有机会更好地理解该数据集以估算日期。
正如您可以从下面导入数据集的代码中看到的，除了项目 ID、记录数、类型 ID 和类型名之外，我们没有太多关于电子邮件的信息。
作为大量的。csv 文件必须从单个目录读入，我使用 lapply 和 fread 函数读入文件，并使用 rbindlist 追加文件列表。
将统一数据集对象保存为 R 对象是一种很好的做法，这样可以避免以后必须重新运行导入代码，因为根据文件的数量，此过程可能会非常耗时。
特征工程
创建了新的变量来理解项目持续时间。这些是以天为单位的持续时间，以及项目是否在日期要求的响应后提交。如果是，那么就是晚了，否则就是早了或者准时了。
然后将唯一的通信数据集连接到通信类型 ID(主键)上的邮件类型文件。这后来被加入到项目 ID 的主文件中。
加入后，我的初步见解如下:
- 通信 id 是唯一的，因此不需要汇总，也不会有助于分析。
- 有太多的组织 id，没有合理的方法对它们进行分组，因此将排除作为预测器。
- 有太多的用户标识——不是一个有用的预测器，尤其是一些只有 1 的频率计数。也被排除在预测因素之外。
为了为每个通信 ID、项目 ID 和类型名创建一个唯一的行，我需要聚集其他特性。我通过计算延迟提交的次数或计数、早期提交的次数以及计算汇总统计数据(如最大值、最小值和平均持续天数)来实现这一点。
系统模型化
对数据进行分组将 7 个变量的数据集大小减少到 51，156 个观察值。目前的样本量太小，但是，由于错过了回复日期，大部分数据都减少了，包括每个项目 ID 的每条记录将是每个组织和用户 ID 的比较。客户似乎对现场说明和变更感兴趣，这可能在通信类型 ID 和类型名称中找到，而项目 ID 中的数据对于任务要求来说太细了。
我们确实有一个问题，我们不知道每个 ID 代表什么，以及它是否重要。
运行两种类型的模型:
GLM(高斯)用于确定可能对平均持续天数的增加或减少产生影响的最佳预测值的线性组合。
运行 GBM(高斯)来再次确定最佳预测值以及它们与平均项目持续时间(天数)的关系
运行多个模型是一种良好的做法，以确保选择具有更高准确性和可解释性的模型。
我首先使用随机拆分将数据集划分为训练集(70%)和测试集(30%)。回想起来，我可以按日期分割模型，以确定我的模型在预测未来平均持续时间方面的表现。
由于我的笔记本电脑速度很慢，我使用了 H2O 软件包中的 glm 和 gbm 函数来利用该软件包提供的并行处理云服务器。我对我的训练集进行了五重交叉验证。在这种方法中，训练集被分成 5 个等价集。在每一轮中，一组用作测试组，所有其他组用于训练。然后在剩余的四组上训练该模型。在下一轮中，另一组被用作测试组，剩余的组被用于训练。然后，该模型计算测试集上五个模型中每个模型的准确性，并提供平均模型准确性度量。
glm 模型的输出如下所示。对于连续的目标变量，RMSE 和 R 平方通常用作精度度量。我们希望 RMSE 尽可能接近 0，R 平方值尽可能接近 1。在我们的例子中，我们可以看到，对于这两个指标，我们的模型精度都很糟糕。
现在，让我们看看 gbm 的输出。这个模型的结果稍微好一点，但没有什么值得夸耀的。
结果显示，在模型中输入的 1500 个预测因子(1500 个是由于分类变量的二元化)中，有 672 个预测因子具有一定程度的影响。尽管模型可以选择多次运行以产生最佳输出，但只运行了 2 次迭代。这样做的原因是因为在两次迭代后达到了λ的最佳值，给出了 0.38% R 平方的差模型准确度分数(拟合优度分数)。
虽然平均记录数在 glm 中不是一个重要的预测因子，但在 gbm 中它似乎是最重要的，其次是通信类型和类型名称。
由于两个模型的低精度，我不想从输出中做任何扣除。
我决定通过绘制最佳预测值来进一步研究输出。从下面的方框图中，我们可以看到，与持续时间通常接近于零的电子邮件和传真相比，PM 审批请求样本的平均持续时间最长，变化也最大。
在下面的方框图中，我们可以看到付款索赔的平均持续时间比设计查询和不符合项通知的平均持续时间长。
结论
模型的质量取决于数据质量及其特征。在这种情况下，我们从非常少的要素开始，并且对数据集的理解非常差，这导致尽管进行了一些要素工程，但还是移除了大部分数据集和较差的模型准确性。
在本例中，我们发现，仅仅探索数据集就可以回答企业提出的问题，即什么影响项目持续时间，付款持续时间和 PM 审批请求示例会导致持续时间增加。
每个项目的站点说明和变化的数量可以通过项目 ID 和类型名计算频率来再次探索。
这是一个不需要预测模型的例子。为了构建精度更高的模型，需要额外的要素/数据集以及对数据集的更好理解。
我很想听听你的想法，以及我是否可以用不同的方式处理这个问题！😃
所有代码都可以在这里找到:https://github . com/shedoedatascience/email _ analysis/blob/master/email _ analysis _ documentation。Rmd
机器学习就是股票。建立无监督的公司分类。
亨尼投资
实现有意义的公司集群所需的数据探索和处理
这篇文章的想法是建立一个新的，数据驱动的公司分类基于他们的财务状况，而不是他们做的业务类型。
这项研究的前提是基于这样一个想法，即值得购买的优秀股票在同行中会更优秀。在这种情况下，我将同行群体定义为具有相似财务结构(例如，小市值、大量债务、盈利)的一组公司。
如果你没有读过介绍，我建议你在这里读一下我为这项研究写的前言:
加快速度
在上一篇文章中，我选择了 5 个维度来定义公司的财务结构:
- 盈利能力——捕捉公司是否赚钱
- 总资产——捕捉公司规模
- 负债权益比——捕捉融资结构
- 营业利润——捕捉盈利的难度
- 每股收益增长(EPS) —捕捉逐年增长
我还确保了这些维度是独立的。这是一个重要的考虑因素，因为我想衡量一家公司在各个独立领域的表现，而不考虑它在其他领域的表现。这是我之前展示过的 Spearman 相关图:
来自 Vhinny 的财务数据
数据探索
在我进入集群之前，让我们评估一下这 5 个特性的分布。理解分布对于选择合适的聚类算法至关重要。它还会显示出我将在预处理过程中处理的数据中的潜在流。
以下是所有五(5) 特征在单一图上的分布:
选择功能的分布
X 轴显示每个特征的值。 Y 轴显示落入每个对应箱的公司数量。对于这项分析，每家公司都在 2019 年报告了一次财务状况。本研究中使用的公司总数约为 4，000 家。
有几个观察可能会引起人们的注意:
- 负债转股
- 高得惊人的比例债务对股权低于 0.5
- 资产和债转股的偏态分布
负债转股并不常见，但也是可能的。虽然债务不能为负，但如果总负债超过公司总资产，权益可以为负。
偏斜分布也可以，只是我们在选择聚类算法时必须记住这一点。一些算法依赖于正态分布的假设，这在这里不成立。
大多数低于 0.5 的债务权益比率确实令人担忧。许多上市公司严重依赖债务融资，债务融资往往超过股东权益。经过进一步的研究，我在这个特性中发现了许多 0，表明在数据提取过程中存在潜在的流动。纵观我选择的所有特征，除了盈利能力，我认为它们都不为零。
用空值代替所有的 0 后，我们看到债务与股本比率发生了显著变化。其他功能没有受到显著影响:
选择功能的分布
该图与之前的图相同，除了深蓝色图表仅使用非零值构建。将蓝色图表放在红色图表之上，唯一明显的区别是债转股的特征。我会相信蓝色前进，依靠我的商业意识。
选择聚类算法
聚类练习一般是一半艺术，一半科学。因为没有一致的度量来评估算法的性能，所以在找到可行的解决方案之前，经常尝试许多算法。虽然一些距离测量可以用于比较，但它仍然是相当抽象的。流行的聚类方法的一个很好的概述可以在这里找到。
我为这项研究选择的方法是 K-means 聚类，因为它的计算效率、 O(n) 和相对简单的配置。我要做的唯一决定是关于簇的数量，它可以通过实验以一种非常简单的方式确定。
集群前的最后步骤
在数据探索阶段，我们已经看到了资产和债转股特征的偏态分布。由于 K-means 算法是基于寻找数据中的最优均值，因此偏态分布是危险的，因为异常值可能会不可控地将这些均值拉向自己的方向。
处理这个问题的一个方法是去除异常值。由于 4，000 个示例并不是过多的数据，因此删除数据点是不可取的。相反，我可以在分布中强制执行最大值和最小值以减小它们与平均值的距离。
一种方法是使用分位数和四分位间距来限定分布中的最小和最大值。在这种情况下，我使用了
- Q1-3 * IQR 封顶分钟
- Q3+3*IQR 到上限最大值
其中 Q1 和 Q3 以及第一个(25%)和第三个(75%)分位数和 IQR 是四分位间距。我为 IQR 任意选择了 3 的倍数，以保持上限相对远离中间值，从而不会显著扰乱原始分布。
下面是此操作的示例代码，以更好地说明这种方法。
此封顶过程应用于数据集中的所有要素。资产和债务对权益比率的最终分配如下所示:
原始分布尾部封顶的效果
后续步骤
本分析的数据探索和预处理阶段到此结束。在下一篇文章中，我将根据数据确定最佳的集群数量，并确定公司的特征。
顺便说一下…🤚
我们连线吧！
我很高兴与那些和我分享通往财务独立之路的人联系。如果你也在寻求经济独立，或者你想与人合作，交流想法，请联系我们！以下是一些可以找到我的地方:
- www.vhinny.com—投资研究平台，为您自己的分析提供金融数据
- https://www.linkedin.com/company/vhinny——加入我们 LinkedIn 上的社区，在那里我和其他贡献者分享与投资相关的内容
干杯！
深入研究支持向量机
以及用支持向量机求解的 Kaggle 数据集
内容
在本帖中，我们将介绍:
(一)支持向量在支持向量机中的作用
(二)支持向量机的成本函数
(iii)支持向量机作为大幅度分类器
(iv)在核的帮助下通过支持向量机的非线性决策边界
(v)使用支持向量机的欺诈性信用卡交易欺诈数据集检测
在之前的帖子中，我们仔细研究了机器学习中的高偏差和方差问题，并讨论了正则化以及其他一些技术如何在解决这些问题中发挥重要作用。在本帖中，我们将详细了解另一种被称为支持向量机的监督学习算法。在本帖的后面，我们将解决一个 Kaggle 数据集，以检测使用 SVM 的欺诈性信用卡交易。
支持向量机(SVM)
SVM 是一种受监督的机器学习方法，解决回归和分类问题。然而，它主要用于分类问题，其中它在 n 个特征维度中构造超平面。n 维特征空间有一个 n-1 维的超平面。例如，在具有两个特征的数据集中(二维特征空间)，由 SVM 构建的超平面是曲线(直线、圆等)。)如果我们正在解决两个类的分类问题，那么 SVM 分类器的工作是找到使两个类之间的间隔最大化的超平面。在我们了解支持向量机的工作原理之前，我们先来了解一下支持向量机这个名字的由来。
SVM 在行动(来源
什么是支持向量？
我们知道 SVM 分类器为分类构建超平面。但是 SVM 分类器是如何构造超平面的呢？让我们通过只考虑两个类来发展直觉。我们知道超平面必须从两个类中间的某个地方通过。这些类之间的良好分离通过超平面来实现，该超平面与来自两个类的最近训练数据点具有最大距离。在旁边的图中，标记每个类的极端的 2 条虚线构成了每个类的支持向量。这些支持向量有助于在它们的支持向量的帮助下找到最大化超平面与两个类别中的每一个的距离(余量)的超平面。
支持向量机的工作原理
支持向量机可以拟合线性和非线性决策边界作为分类器，并且与逻辑回归相比，支持向量机的主要优势之一是，由于成本函数大大简化，它们可以快速计算训练参数。
价值函数
让我们回忆一下逻辑回归中用于二元分类的二元交叉熵代价函数。这里，为了简化起见，我们将忽略偏差项，因此我们通过逻辑回归对总共“m”个训练示例中的第 I 个训练示例进行的最终预测将表示为 h(x(i)) = sigmoid(W * x(i))
这个成本函数可以分为两部分:当 y(i) = 1 时，项(1-y(I))* log(1-h(x(I)))变为 0，当 y(i) = 0 时，项 y(i)*log(h(x(i))变为 0。这些方程(成本对 W * x)的对应图表(不包括正则项，因为它对两者都是通用的)是:
SVM 使用了这个成本函数的轻微修改，这提供了它比逻辑回归计算的优势。对于 y = 1 的情况，我们看到，当 W * x >= 1 时，成本函数的所有值都更接近于 0，当 W * x < 1, the -log(h(x)) function values are approximated by a straight line by calculating the derivative of the cost function when W * x = 0. Similarly for the case y = 0, we see that the cost function has all its values closer to 0 when W * x <= -1 and when W * x > 1 时，通过计算 W * x = 0 时成本函数的导数，log(1-h(x))值由直线近似。
现在，由于我们不再使用对数成本函数，让我们将逻辑回归成本函数中的对数部分重命名。我们把 -log(h(x))换成 cost1(h(x)) ，把 -log(1 — h(x))换成 cost0(h(x)) 。我们在这里忽略常数(1/m ),因为它不影响我们的最小化目标，并有助于我们简化计算。因此，支持向量机的最终成本函数如下所示:
这导致成本函数的以下数学等式:
与输出概率值的逻辑回归不同，支持向量机输出 0/1。当 h(x) >=1 时，SVM 输出 1，当 h(x) <= -1, the SVM outputs 0. In logistic regression, we saw that when h(x) > 0 时，输出为概率> 0.5，四舍五入为 1，当 h(x) < 0, the output was a probability < 0.5 which was rounded-off to 0. The range of (-1, 1) is an 时，额外的安全系数允许支持向量机做出比逻辑回归更有把握的预测。
现在让我们稍微重新参数化一下成本函数。目前，我们的成本函数是 A + λB 的形式，其中 A 是成本函数，B 是正则项。我们把它转换成 CA + B 的形式吧，这里 C 的作用类似于 1/λ。
SVM 作为一个大幅度分类器
前面，我们读到了支持向量在寻找一个超平面中的作用，该超平面作为一个分类器，与两个类中的每一个都有最大的距离。这种分类器被称为大幅度分类器。大范围分类器是以更大的置信度预测给定数据点的类别的分类器。逻辑回归的情况并非如此。让我们看看为什么这种情况会发生在 SVM 身上。
我们将 SVM 成本函数重新参数化为 C*A + B ，其中 A 是与 SVM 输出(成本分量)相关联的损失， B 是正则化项(正则化分量)，并且 C 起到类似于 1/λ的作用。当我们选择 C 非常大的时候，那么我们的模型就容易过拟合。为了应对这一点，我们希望 A 应该接近零，否则将会有不希望的巨大成本。由于 A 的值与参数 W(在图中用‘θ’表示)成正比，这意味着参数本身将具有非常小的值。因此，在 C 较大的情况下，优化目标只是找到 B 中出现的训练参数的最小值。正式定义，这种情况下的最小化目标是:
在 SVMs 的实现中，使用向量化，并且计算向量 W(图中的“θ”)和特征向量(X)的点积。从矩阵乘法的知识中，我们知道当计算两个向量(假设 u 和 v 的点积时，我们得到向量 u 在向量 v 上的投影。同样，当计算 W 和 X 的点积时，我们得到矢量 X 在 W 上的投影，并且投影的长度( P )等于
其中||thetha||是θ的 L2 范数。这个等式可以表示为:
因此，最小化目标可以重新表述如下:
现在让我们举个例子来看看这个最小化目标是如何在 SVM 产生大幅度分类器的。
考虑下面的二元分类问题，其中“X”表示特征 x1,“O”表示特征 x2。根据我们当前的优化目标，我们知道只有当 p.||theta|| <= -1 for y = 0 (x1) and p.||theta|| > = 1 且 y = 1 (x2)时，SVM 才能最小化成本函数，即训练样本的投影和参数向量之间的角度分别在 900–1800°和 2700–3600°之间。
在下图中，考虑左图(绿色)中的决策边界。参数向量(θ向量)与其垂直，因为参数向量右侧的区域具有 900–1800°的角度，而决策边界左侧的区域具有 2700–3600°的角度。对于这个决策边界，我们看到训练样本(用红色和粉红色表示)的投影长度相当小。在这种情况下，为了满足 p . | |θ| |<= -1 for y = 0 (x1) and p.||theta|| >= 1(x2)的条件，θ需要具有大的值。因此，成本函数的值并未最小化，因此左侧图像中以绿色表示的决策边界不会被 SVM 选择。
现在，考虑下图右边的决策边界(绿色)。对于相同的训练示例，我们看到它们在参数向量上的投影与之前的决策边界相比更大。现在为了满足 p.||theta|| <= -1 for y = 0 (x1) and p.||theta|| > = 1 (x2)的条件，我们已经有了一个很大的投影向量值‘p’。这意味着小的θ值就足够了，这反过来也最小化了成本函数。因此，右图所示的决策边界最有可能被 SVM 选择用于二元分类任务，通过比较两个决策边界，我们可以清楚地看到，SVM 选择的分类器确实是一个大间隔分类器。
让我们记住，当 SVM 方程 C*A + B 中的参数 C 非常大时，证明了我们上面得出的结论。当 C 的值很小时，我们可以得到类似的结果，因此我们推广了这一说法。我鼓励读者思考这个问题。这将有助于进一步阐明 SVM 背后的数学原理。
非线性决策边界的 SVM
到目前为止，我们已经看到了 SVM 被用作具有线性决策边界的分类器的场景。SVM 使用内核方法来完成这项任务。在讨论核方法之前，让我们理解为什么复杂的多项式特征不适用于非线性 SVM 分类。让我们借助线性回归对它有一个直观的认识。
在线性回归中，对于具有“n”个输入特征的训练数据，我们将输出表示如下:
y = W1x1 + W2x2 + W3x3 + ………+ Wnxn。
对于“m”个训练示例，我们得到的输出是一条直线。那么，我们怎样才能得到一个非线性的决策边界呢？我们知道，次数大于 1 的多项式会产生非线性输出。但是使用这些多项式作为输入特征存在以下问题:
(I)对于小至 5 个特征的数量，有无数种选择特征的可能性。输出的示例表示可以是 y = w1x 1+w2x 2 x3+w3x 1 x4 X5+w4x2x 4+………(可能有几吨)。请记住，5 次多项式不需要具有 5 次多项式的所有特征。
(ii)对于如此复杂的特征表示，不能直观地确定决策边界，这使得难以调整特征以获得更好的结果。
(iii)此外，计算这些复杂的特征在计算上非常昂贵，因此是不期望的。
核心方法
由于上述非线性分类器的多项式特征向量的所有缺点，SVMs 通过结合使用核方法提供了一种非常智能和有效的方法来生成非线性决策边界。内核的神奇之处在于找到一个函数，避免了高维计算所隐含的所有麻烦。在机器学习中，核方法是一类用于模式分析的算法，其最著名的成员是支持向量机。内核方法需要用户指定的内核，即原始表示中成对数据点的相似性函数。核方法优于特征向量，因为它们在计算复杂的非线性决策边界时大大减少了计算时间。内核方法的输出是一个标量。
在这里，虽然我们将核的使用限制在 SVM，但需要注意的一件重要事情是，可以使用点积表示的每个机器学习算法都可以用核来代替。然后，我们可以使用这些带有内核的机器学习算法中的任何一种，这两种算法都能提供更快、更好的结果。尽管有不同类型的内核方法，我将使用高斯内核做进一步说明。
生成非线性决策边界
如果内核不进行如此复杂的计算，那么它们是如何生成如此好的非线性决策边界的呢？为训练示例定义一些界标，并且使用相似性函数(内核)使用每个定义的界标来计算每个示例的相似性。训练样本 xi 和地标 lj 的高斯核或高斯相似度函数表示为 exp(-||xi — lj||2 / 2σ2) 。由此，我们可以看到，对于靠近地标的训练示例 xi ，其特征值 fi 接近 1，而对于远离地标的训练示例 xi 其特征值接近 0，这似乎是相似性的良好度量。
使用高斯核计算的相似性值被认为是各个训练示例的新特征值，然后可以将其与它们的权重参数(W/θ)相联系，以计算最终的输出类别。在帖子的前面，我们看到最小化目标受制于权重向量和输入特征向量的点积> =1 或<= -1. After computing the new feature values using kernels, the conditions of the optimization objective change a bit. Although the inequality values remain the same, the dot product is now computed between the weight vector and the new feature vector computed using Gaussian kernel. Just to clarify, although the output of the kernel method is a scalar value, that scalar value is computed against a single landmark. Against L landmarks, L values are computed which then form a feature vector for a given training example.
Minimization objective when C > > 1 的条件，并且使用了核方法
考虑一个训练数据集(具有 2 个仅用于演示目的的要素),该数据集具有 2 个没有线性决策边界的输出类。让我们看看在训练集上定义几个界标(假设 3 个)如何帮助解决非线性决策边界。在下图中，我们看到，对于粉红色的训练示例 X，与地标 L2 和 L3 相比，它非常接近地标 L1。对于这个例子，使用高斯核计算相似性，我们得到对应于 L1 的特征值 f1 接近 1，对应于 L2 和 L3 的特征值(f2 和 f3)接近 0。根据上面的等式，我们预测一个当θ* f > = 1 时。现在，如果对应于这些特征的θ值是 2、0.5 和 1，则 21 + 0.50 +1*0 = 2 即> = 1。对多个训练示例执行相同的步骤给我们提供了具有高精度的适当的非线性决策边界。
选择地标
我们看到了界标结合核方法如何帮助定义支持向量机中复杂的非线性决策边界。现在，选择地标的明显问题出现了。选择标志的一种方式是将所有训练示例转换为标志，然后通过使用高斯核计算训练示例和每个标志之间的相似性来计算每个训练示例的特征向量。
地标测绘训练示例
一旦选择了这些标志并且计算了这些新的特征向量，最终的优化目标被修改为:
其中 f(i)表示使用高斯核计算的新特征向量。这里要注意的一点是，特征向量的数量(n)将等于训练样本的数量(m ),因为每个训练样本都是地标。
计算权重参数
在线性和逻辑回归中，我们看到了如何使用梯度下降来计算权重。我们不能使用原始形式的梯度下降来计算支持向量机的最优权重参数，因为 SVM 中的成本函数在所有点上都不可微。因此，为了计算 SVM 的权重参数，使用了梯度下降的一些变体，如亚梯度下降，甚至各种复杂的算法。次梯度下降中的权重更新看起来像:
W = W — alpha * subgradient_wrt_W(J)，其中“alpha”是学习率。
求解次导数不像偏导数那么简单，需要我们很好地理解极限和不等式。斯坦福大学的这份 pdf 文件的前 2 页是一个很好的资源，它会给你一个如何计算次导数的直觉。
一旦计算出分类任务的最佳权重参数，我们就可以运行 SVM 分类器，计算训练和测试精度，以评估模型的性能。
在这篇文章中，我在 coursera 上教授支持向量机时使用了 Andrew NG sir 的各种例子，以及我提供直觉的能力。如果你有时间的话，我推荐你去看看他开设的机器学习课程。
到目前为止，我们已经了解了很多关于支持向量机的知识。我们从支持向量的作用开始，然后深入理解 SVM 的成本函数如何隐含地倾向于大间隔分类器，随后使用核技巧来计算非线性决策边界，通过各种示例使事情易于理解。最后，我们了解到普通(普通)梯度下降在计算权重参数时是如何不起作用的，因此需要使用次梯度下降。学了这么多之后，现在是时候将我们的注意力转移到信用卡交易 Kaggle 数据集上，以巩固我们的概念并了解 SVM 的运行情况。
问题陈述
在本节中，我们将使用 SVM 来确定欺诈性信用卡交易。这个问题的数据集可以在这里找到。这里需要注意的一点是，该数据集的特征已经作为 PCA(主成分分析，我们将在后面的帖子中看到)转换的结果进行了计算。它有两方面的帮助:
(I)维护用户数据的机密性。
(ii)由于 PCA 变换，数据集中的特征相互独立。
让我们从将数据集作为数据帧加载到内存开始。
import numpy as np
import pandas as pd
import matplotlib.pyplot as pltfrom sklearn import preprocessing, svm
from sklearn.metrics import confusion_matriximport os
for dirname, _, filenames in os.walk(‘/kaggle/input’):
for filename in filenames:
print(os.path.join(dirname, filename))
df = pd.read_csv(“/kaggle/input/creditcardfraud/creditcard.csv”)
df.head()
数据集有 31 个列/特征，其中 28 个是通过 PCA 变换计算的，其他特征只是数字特征。现在让我们看看欺诈性和非欺诈性交易在数据集中是如何分布的。
print(df[‘Class’].value_counts())
与 284315 笔非欺诈性(0)交易相比，有 492 笔欺诈性(1)交易，这是一个很大的偏差。显然，我们需要对我们的数据进行重新采样，否则我们可以通过简单地将每个交易预测为 0(非欺诈性)来实现高准确性。
print(“Accuracy by predicting all transactions as non-fraudulent: “ + str((284315 / (284315 + 492)) * 100) + “%”)
因为所有的欺诈交易都被忽略了，所以这样的系统没有用。我们需要等量的欺诈性和非欺诈性交易进行训练，以便更好地捕捉这两种交易的特征。首先，让我们从“时间”和“金额”两个方面来分析欺诈交易数据。
df_fraud = df[df[‘Class’] == 1]
plt.figure(figsize=(15, 12))
plt.scatter(df_fraud[‘Time’], df_fraud[‘Amount’])
plt.title(“Fraudulent transactions”)
plt.xlabel(“Time”)
plt.ylabel(“Amount”)
plt.show()
在任何时候，我们都有一些欺诈性交易，在预测它们时，时间是一个不相关的因素。此外，从上图可以看出，大多数欺诈交易的金额都非常小。
df_huge_fraud_amounts = df_fraud[df_fraud[‘Amount’] > 1000]print(“Number of fraudulent transactions over the amount of 1000 are: “ + str((df_huge_fraud_amounts.shape[0])))
给定的数据集表明这些特征是使用 PCA 变换计算的，因此它们应该是相互独立的。让我们通过计算特征之间的相关性来检查是否是这种情况。
import seaborn as snsplt.figure(figsize = (15, 12))
df_correlation = df.corr()
sns.heatmap(df_correlation)
plt.title(“Heatmap representing correlations”)
plt.show()
热点图的对角线代表最高的相关性(接近 1.0)，即要素与其自身的相关性。其他特征对之间的相关性具有-0.2 到 0.2 之间的值，这对应于非常小的相关性。这表示所提到的特性实际上是相互独立的，因此没有一个特性可以基于它们之间的依赖关系而被删除。
由于与非欺诈性交易相比，欺诈性交易的总数太小，我们需要对数据集进行重新采样。通过应用过采样，我们重复欺诈交易，直到它们在数量上接近非欺诈交易。通过应用欠采样，我们消除了一些非欺诈性交易，因此非欺诈性交易的最终数量与数据集中的欺诈性交易大致相同。通过对此数据集应用过采样，训练数据集将变得巨大(284315 个非欺诈性交易，相比之下只有 492 个欺诈性交易)，因此我们使用欠采样。
df_train = df[:200000]
df_train_fraud = df_train[df_train[‘Class’] == 1]
df_train_not_fraud = df_train[df_train[‘Class’] == 0]print(df_train_fraud.shape[0]) # 385
由于有 385 个欺诈交易，我们将把非欺诈交易减少到这个数字左右，以使每种交易的训练示例数量相等。
df_sample = df_train_not_fraud.sample(400)
df_train_final = df_train_fraud.append(df_sample)
df_train_final = df_train_final.sample(frac = 1).reset_index(drop = True)df_train_final.head()
我们现在可以看到“Class”列既有 0 也有 1。我们从数据集中抽取了前 200，000 个样本，并从总共 284，315 笔非欺诈交易中随机选择了 400 笔(接近 385 笔)非欺诈交易。因此，我们已经成功地实现了欠采样，并且我们的最终训练集包括 785 个训练样本。欠采样会导致数据中一些重要特征的丢失。但是首先，让我们看看应用 SVM 分类器得到的结果。现在让我们将数据分成训练集和测试集。
X_train = df_train_final.drop([‘Time’, ‘Class’],axis=1)
y_train = df_train_final[‘Class’]X_train = np.asarray(X_train)
y_train = np.asarray(y_train)df_test = df[200000:]
X_test = df_test.drop([‘Time’, ‘Class’],axis=1)
y_test = df_test[‘Class’]X_test = np.asarray(X_test)
y_test = np.asarray(y_test)print(df_test[‘Class’].value_counts())
我们看到测试数据集包含 107 个欺诈交易。如果 SVM 分类器在非欺诈性交易上表现相当好，并且还可以检测到许多这些欺诈性交易，我们可以说我们的模型做得相当好。
classifier = svm.SVC(kernel=’linear’)
classifier.fit(X_train, y_train)
predictions = classifier.predict(X_test)
现在，我们已经对训练数据集应用了 SVM 分类器，并将测试数据集的预测结果存储在“预测”变量中。为了评估模型的性能，让我们绘制混淆矩阵并确定以下内容:
(i) 真正:原始输出类为正例(此处为非欺诈交易)，预测输出类也为正例(此处为非欺诈交易)。
(ii) 误报 : 原始输出类是正例(此处为非欺诈交易)，但预测输出类是负例(此处为欺诈交易)。
(iii) 假阴性:原输出类为负例(此处为欺诈交易)，但预测输出类为正例(此处为非欺诈交易)。
(iv) 真否定:原始输出类是否定示例(此处为欺诈交易)，预测输出类也是否定示例(此处为欺诈交易)。
对于一个银行系统来说，如果一些非欺诈性交易被检测为欺诈性交易，他们会进行调查，但如果欺诈性交易被标记为非欺诈性交易，那么这可能会导致巨大的损失。因此，我们的目标是尽可能地减少假阴性的总数，同时也尽量降低假阳性的数量。现在，让我们画出混淆矩阵。
import itertoolsclasses = np.array([‘0’,’1'])def plot_confusion_matrix(cm, classes,title=’Confusion matrix’, cmap=plt.cm.Blues):
plt.imshow(cm, interpolation=’nearest’, cmap=cmap)
plt.title(title)
plt.colorbar()
tick_marks = np.arange(len(classes)) plt.xticks(tick_marks, classes, rotation=45)
plt.yticks(tick_marks, classes) fmt = ‘d’
thresh = cm.max() / 2. for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):
plt.text(j, i, format(cm[i, j], fmt),
horizontalalignment=”center”,
color=”white” if cm[i, j] > thresh else “black”)plt.tight_layout()
plt.ylabel(‘True label’)
plt.xlabel(‘Predicted label’)cm = confusion_matrix(y_test, predictions)
plot_confusion_matrix(cm,classes)
混淆矩阵有
(一)81746 真阳性
㈡3224 次误报
㈢11 次假阴性
㈣96 张真正的底片
由此，我们可以得出结论，大多数欺诈性交易都已被捕获，只有 11 个交易被错误分类，这比我们之前在解决此问题时讨论的产生极高准确性但没有捕获任何欺诈性交易的模型要好得多。
print(‘Total fraudulent transactions detected: ‘ + str(cm[1][1]) + ‘ / ‘ + str(cm[1][1]+cm[1][0]))
print(‘Total non-fraudulent transactions detected: ‘ + str(cm[0][0]) + ‘ / ‘ + str(cm[0][1]+cm[0][0]))print(‘Probability to detect a fraudulent transaction: ‘ + str(cm[1][1]/(cm[1][1]+cm[1][0])))
print(‘Probability to detect a non-fraudulent transaction: ‘ + str(cm[0][0]/(cm[0][1]+cm[0][0])))print(“Accuracy of the SVM model : “+str(100*(cm[0][0]+cm[1][1]) / (sum(cm[0]) + sum(cm[1]))) + “%”)
这篇文章的完整代码可以在这里找到。
我们的主要关注点是尽可能多地捕获欺诈交易，鉴于我们在整个数据集中只有大约 800 个欺诈案例，我们通过检测 96/107 欺诈交易完成了出色的工作。
这个帖子到此为止。我们深入研究了支持向量机的概念，我确保为每一部分都提供了直觉，以便读者更好地快速理解。我们唯一没有详细讨论的主题是次梯度下降，但是相信我，所有实现 SVM 的 python 包，只要你知道 SVM 是如何工作的，有了它们的所有参数，次梯度下降在这些包中是自动实现的。在下一篇文章中，我们将深入研究随机森林和决策树，并使用它们解决一个 Kaggle 数据集。
机器学习作业不会因为你盯着它们而跑得更快
在您做更多令人兴奋的事情时，让您的 python 脚本文本状态更新和警告消息。
图片由 Free-Photos 来自 Pixabay
尽管很吸引人，但我没有时间坐下来看长时间运行的数据管道时钟、模型训练和 python 脚本来处理我的任务。通常，我们希望确保没有需要关注的失败。这个问题的一个解决方案是发送一封电子邮件或文本来获取你想要的任何状态更新。你可以放心地去做其他的事情。
关于如何从 python 脚本发送电子邮件和文本有几个很好的教程。根据您是在组织内工作还是在项目中工作，设置会有所不同。对于本例，我将设置一个 Twilio 电话号码，并在 python 脚本运行期间使用该帐户向自己发送文本更新。
设置 Twilio 帐户后，您可以访问您的帐户 id 和 API 令牌。要通过 API 发送文本，您需要请求一个 Twilio 电话号码。整个过程大约需要 2 分钟。非常快！
下面的脚本是典型的机器学习类型的脚本。在这种情况下，autoML 脚本使用 mljar 包运行。我不仅想知道脚本何时完成运行，还想在出现故障时得到提醒。
# Example of sending text status updates while running an autoML script.import pandas as pd
# scikit learn utilites
from sklearn.metrics import accuracy_score
from sklearn.model_selection import train_test_split# mljar-supervised package
from supervised.automl import AutoML######################################################
# [https://www.twilio.com/docs/python/install](https://www.twilio.com/docs/python/install)
from twilio.rest import Client# Your Account Sid and Auth Token from twilio.com/console
# DANGER! This is insecure. See [http://twil.io/secure](http://twil.io/secure)
account_sid = 'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx'
auth_token = 'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx'
client = Client(account_sid, auth_token)
#######################################################try:
input_df = pd.read_csv('train.csv')
input_df.fillna(0)
print('Input file columns: ' + str(input_df.columns))train_data = input_df[['id', 'keyword', 'location', 'text']]train_label = input_df[['target']]print('train data : ' + str(train_data.head(1)))
print('train label: ' + str(train_label.head(1)))X_train, X_test, y_train, y_test = train_test_split(
pd.DataFrame(train_data), train_label, stratify=train_label, test_size=0.25,
random_state=27
)
except:
message = client.messages.create(
body='mljar data load and split failed',
from_='+1xxxxxxxxxx', #twilio #
to='+1xxxxxxxxx'
)
print(message.sid)try:
automl = AutoML(mode="Explain")
automl.fit(X_train, y_train)
message = client.messages.create(
body='mljar Explain completed',
from_='+xxxxxxxxxx',
to='+1xxxxxxxx'
)
except:
except:
message = client.messages.create(
body='mljar Explain failed',
from_='+xxxxxxxxx',
to='+1xxxxxxxxxx'Nothing is more disappointing than logging onto your computer after waiting hours for a model to train and finding that it failed hours ago! Prevent this by setting up text or email alerts. It’s simple, fast, and is satisfying when you get the ‘successful completion’ text.
没有什么比提交一个脚本运行后登录到您的计算机上，发现它几个小时前就失败了更令人失望的了！通过设置文本或电子邮件提醒来防止这种情况。当你收到“成功完成”的信息时，这是简单、快速和令人满意的。
机器学习乐高图像识别:使用虚拟数据和 YOLOv3
我最近一直在做乐高和 3D 模型。对于我目前的项目，我希望建立一个乐高图像识别程序。我的理想场景是抓起一把乐高，把它们扔在桌子上，拍张照片，然后让程序给它们分类。
(乐高是乐高集团的注册商标，乐高集团并不赞助、认可或授权此事。登陆乐高官方网站【http://www.lego.com】。)
我在任何机器学习项目中遇到的最大挑战是收集和格式化训练数据。我很确定这是每个人在机器学习中遇到的最大挑战。以正确的格式获得正确的数据总是交易杀手。
因此，我将使用乐高积木的虚拟 3D 模型来创建训练数据。
乐高分拣机
有几个很酷的例子，人们用乐高图像识别和机器学习来建造乐高分拣机。我的场景有点不同，因为我想从一张图片中同时识别多个 LEGO。不然我的场景和分拣机很像。第一个例子是这里的和。他们似乎采取了暴力手段。手动标记一堆部件，训练算法，在乐高部件上重新运行…清洗，重复…直到你有工作解决方案。这是一个不错的方法，我以前在其他项目中使用过！但我一直在玩几个乐高 3D 建模程序，我在想它可能会创建虚拟数据。我最近遇到了一台通用乐高分拣机，它引用了“虚拟”的积木，所以我猜他们的想法和我类似。[注:在我完成这个项目后，我发现了一个丹尼尔·韦斯特的精彩视频，他解释说他确实使用了合成乐高数据用于他的通用分类机。]
虚拟训练数据
好的，那么我需要哪些训练数据呢？我们需要大量的乐高图片，并标上乐高编号。我想从多个角度拍摄每件作品的照片。当我把一组乐高积木扔到桌子上时，它们会以不同的方向落地。正面朝上、颠倒、不同的旋转等。通常我会希望在一张图片中有多个乐高玩具的训练图片，每个图片上都有边界框。但是我要做几个简化的假设来开始。
正如我提到的，我花了很多时间在乐高建模软件上。有一些令人惊讶的开源和免费软件程序。我从 LDRAW.org 下载了一套这样的软件包。LDRAW 是一种被广泛接受“砖块”格式。(砖块是乐高，和乐高兼容的，塑料部件。)你真的应该花点时间探索一下 LDRAW 社区的创作，超级有创意！
我最终选定了 LDCad ，这是罗兰·梅尔克特的一个很棒的程序。保养得很好。伟大的工具。我首先考虑使用其他开源的选项。我最初计划弄清楚一个命令行工具，最好是 python，它将从 LDRAW LEGO 模型自动生成图像。WebGL 的东西看起来很有前途。但是最终我意识到投资去真正理解底层脚本将会花费比我所能得到的更多的时间。LDCad 使用 LUA，这是一种脚本格式，有很多可用的脚本示例。这使得快速学习变得容易多了。
使用 LDCad
让我们保持简单。我编写了一个 LUA 脚本，它遍历 LDRAW 文件中的一系列片段。对于每一个乐高积木，脚本通过一系列角度旋转相机来捕捉整个积木的图像。动画实际上看起来像作品本身在旋转，但它实际上是相机。
让我们来看看这是如何实现的。
LDCad 将脚本称为“动画”。我把我的动画游行叫做。为了方便起见，我将动画放在 LDCad 提供的 samples.lua 脚本文件中。
剧本分为两个主要部分:onParadeStart()和 onParadeFrame()。LDCad 中脚本的结构让我想起了微控制器状态机。基本上，onParadeStart()在用户启动动画时运行一次。并且 onParadeFrame()在动画的每一帧上运行。
所以在 onParadeStart()中，我初始化了 LDRAW 文件并定义了像 unViewPosition 和 ViewPosition 这样的常量。我还初始化了计数器，用于循环显示作品和相机视角。
onParadeStart()
在 onParadeFrame()中，我构建了一系列 if … else … if 来充当 switch 语句。它循环遍历所有的片段。循环所有动画模式。循环通过所有的摄像机视角。递增计数器并随着它的进行更新摄像机位置。
onParadeFrame()
我将每秒帧数(FPS)设置为 8，因为这给了我 8 张不同的图片，每张图片来自不同的相机视角，用于每个相机观察循环。动画的长度基于片段的数量乘以相机观察循环的数量。当你为机器学习训练阶段提取图片时，你将需要所有这些信息。
一旦设置并注册了游行脚本，它将作为一个菜单选项出现在 LDCad 程序中。您可以在 LDCad 中打开 LDRAW 文件，然后运行游行动画。LDCad 允许您将动画导出为一系列 png 图像文件。不错！
制作乐高图像
我拿了一个我在家里没有打开过的小乐高玩具。31072-极限引擎。
31072 —极限引擎
这是一个较小的套件，共有 109 件，49 个独特的作品。我认为这将是一个很好的项目测试。我使用了一个 python 脚本和 rebrickable.com 的API来下载这个特定套件的零件清单。
rebrickable.com
在 API 返回的 JSON 部件列表中，是 LEGO 部件 id 和相应的 LDRAW 部件 id。可重新点击 api 文档表明可重新点击零件号“主要”基于 LDRAW。深入研究 api 调用的 JSON 输出，我发现可重复调用的部分 id 是比 external_ids:LDraw 下面列出的 id 更可靠的 LDRAW id。不是 100%确定为什么，但它对这个项目来说已经足够好了。我编写了创建 LDRAW 文件的脚本，每个唯一的 LDRAW 部件 id 对应一行。
LDRAW 格式要求每行上的每个片段都有一个位置和方向。尽管这些坐标对我们的动画来说并不重要，但格式确实需要符合“子文件参考线”的 LDRAW 文件格式
1 x y z a b c d e f g h i
- 1 表示“子文件参考线”
- x y z 是位置坐标
- a b c d e f g h i 是标准 4x4 齐次变换矩阵的左上 3×3 矩阵。
- 我选了 4(红色)作为颜色。(颜色不应该影响识别。)
- 例如……1 4 0 0 0 1 0 0 1 0 0 0 0 0 0 1 3023 . dat
一旦构建了 LDRAW 文件，我就在 samle.lua 脚本的注册函数中将动画长度设置为 245 秒。因为时长应该是(件数)*(相机循环次数)
49 * 5 = 245
在 LDCad 程序中，我加载了我的 LDRAW 文件，并运行动画来检查它。然后我选择会话->动画->OpenGL 导出选项。我设置了 300X300 的图像尺寸。也许比需要的要大，但是我想要足够的像素来适应不同的尺寸。我把背景设置为#FFFFFF(白色)。并导出到我选择的文件夹中。
导出动画后，我有了 1960 张图片。49 件独特作品各 40 张图片。这可能有些矫枉过正。或者它可能在角度和照明方面没有足够的变化。创新和实验将是反复的。
现在我们有了一些图像，让我们转向机器学习！
YOLOv3 物体检测
我将使用 YOLOv3 算法进行训练。尽管 YOLO 特别限制“小对象”被“紧密地”组合在一起，但我认为这种实现方式会很好。小和靠在一起是相对的。如果我们试图在一张桌子上辨认出乐高积木，并且在图像中有更大的物体，这些限制将会是一个问题。但是如果整张图片是一个类似大小的乐高积木的集合，那么就没问题了。仅供参考——YOLO 绝对是矫枉过正。
YOLO(你只看一次)是速度优化。最常见的应用是实时或近实时视频分析。我们可以为这个项目选择 fast-CNN 或其他单镜头探测器。但是我想用 YOLOv3，因为我没用过，尝试新事物很好玩！
我找到了一个关于“如何从头开始训练自己的 YOLOv3 探测器”的快速演练。
让我们试一试吧！
培训数据格式
YOLOv3 需要一组带有边界框的带标签的训练图像。以及描述训练数据和图像的文本文件。文本文件所需的格式要求每个训练图像占一行，包含…绝对文件路径、xmin、ymin、xmax、ymax、label_id。x 和 y 坐标是要识别的对象的边界框。label_id 是对 data_classes 的引用。最终，label_id 将是每个 LEGO 块的部件 id 的引用。但是我们将把零件 id 放在 Data_classes.txt 文件中。
所以我构建了一个简短的 python 脚本，从部分 id 列表中创建 Data_classes.txt 文件。并将该文件放在“数据- >模型 _ 权重- >数据 _ 类. txt ”中
我有图像文件路径，可以从用于构建 Data_classes.txt 文件的零件号数组中获取 label_id。但是我也需要边界框。我确信有许多有效的方法来完成这项任务。但是我用了 PIL 的图片。这是一种作物用途。并且由于训练数据是人工的并且包含统一的背景，裁剪图像提供了与紧密边界框相同的坐标。
我创建了一个 python 脚本，将所有这些信息放在一个 data_train.txt 文件中。然后把那个文件放到“Training _ Images->vott-CSV-export->data _ train . txt”中。
在 YOLOv3 这样的模型上，可以尝试无数的调整和优化。如果您从上面链接的参考实现开始，设置这两个文件将允许您训练第一次迭代。
现在可以从命令行运行 Train_YOLO.py。
结果！
所以模型训练了很久。102 个时代。在我的家庭服务器上呆了 48 个小时。再说一次，我相信还有很多很多的优化要做。
我打开我的乐高盒子，抓了一把积木，扔在桌子上，拍了张照片，然后进行推理。
推理检测
我的天啊。不算太坏。在第一次训练中，它就答对了几道题！
正如所料，灯光和阴影扮演了重要角色。零件的方向也被考虑在内。越是独特的部分，比如车轮，越能被准确、频繁地挑选出来。
我认为这是一个很好的开始！没有任何模型调整，并使用简单的虚拟数据相机旋转动画程序。在这个项目快结束的时候，我发现了一段丹尼尔·韦斯特的视频，他解释说他确实在他的通用分类机器中使用了合成乐高数据。他谈到了虚拟数据的挑战以及通过混合一些真实数据来改善结果的技巧。也许我会尝试一下。但是我也想到了另一个利用乐高和机器学习的酷项目。一天的时间永远不够。
机器学习:使用 Pyspark 的线性回归
简介:
PySpark 是用 Python 编写的 Python API，用于支持 Apache Spark。Apache Spark 是一个分布式框架，可以处理大数据分析。Spark 是用 Scala 写的，可以和 Python，Scala，Java，R，SQL 语言集成。Spark 基本上是一个计算引擎，通过并行和批处理系统处理大量数据。当你下载 spark 二进制文件时，会有单独的文件夹来支持上述语言。
基本上有两种主要类型的算法-转换器:转换使用输入数据集，并使用转换()将其修改为输出数据集。
估计器是采用输入数据集并使用 fit()生成经过训练的输出模型的算法。
在这一节，我将展示使用 Spark 和 Python 的机器学习实现。我将在这里重点介绍在 Spark 环境中实现的基本 ML 算法线性回归。该程序已在独立服务器中执行。
首先，如下所示导入库。最重要的是给出 Spark 二进制文件在系统中的路径。否则，您可能会在执行代码时遇到问题。
火花时段:
这是 Dataframe API & dataset 编程火花的入口点。它允许您使用 spark 执行各种任务。spark 上下文、hive 上下文、SQL 上下文，现在所有这些都封装在会话中。在 spark 2.0 之前，sparkContext 用于访问所有 spark 功能。spark 驱动程序使用 sparkContext 通过资源管理器连接到集群。sparkConf 创建 sparkContext 对象，该对象存储配置参数，如 appName(用于标识 spark 驱动程序)、应用程序、内核数量以及在 worker 节点上运行的执行器的内存大小。从 spark 2.0 开始，这两个特性被封装在 spark 会话中。因此，每次您想使用 spark 执行任务时，您都需要创建一个会话，并且在执行之后，您必须结束该会话。
现在使用 read.csv()读取数据集，您可以允许 spark 读取数据集并在需要时执行。这里我使用了一个 r[real estate dataset](http://Real estate.csv)used。
在这里，您可以注意到诸如 No 和 X1 交易日期之类的列与房屋价格无关，并且在数据集中没有正确给出交易日期。因此，我们将删除这些列
colm = ['No','X1 transaction date']
df = dataset.select([column **for** column **in** dataset.columns **if** column **not** **in** colm])
有一个很酷的 spark 语法可以做到这一点。如果您在 select()中应用列表理解，您将获得所需的数据框。此数据框不同于熊猫数据框。嗯，和《星火》和《熊猫》里创造的物体有关。
Spark 数据帧是分布式的，因此在处理大型数据集时，您将获得并行处理和处理速度的优势。
Spark 确保容错。因此，如果您的数据处理在处理之间中断/失败，spark 可以从沿袭中重新生成失败的结果集。
df.printSchema()#outputroot
|-- X2 house age: string (nullable = true)
|-- X3 distance to the nearest MRT station: string (nullable = true)
|-- X4 number of convenience stores: string (nullable = true)
|-- X5 latitude: string (nullable = true)
|-- X6 longitude: string (nullable = true)
|-- Y house price of unit area: string (nullable = true)
如果您查看数据集的模式，它是字符串格式的。让类型转换浮动。
**from** **pyspark.sql.functions** **import** coldf = df.select(*(col(c).cast('float').alias(c) **for** c **in** df.columns))
让我们检查空值。
df.select([count(when(col(c).isNull(), c)).alias(c) **for** c **in** df.columns]).show()
太好了！不存在空值。但是列名有点长。所以我们现在将用我们自己的自定义名称来替换它们。重命名列名有几种技术，我使用 reduce()来实现。你可以用另一种方式表演。
**from** **functools** **import** reduce
oldColumns = df.schema.names
newColumns = ['Age','Distance_2_MRT','Stores','Latitude','Longitude','Price']
df = reduce(**lambda** df, idx: df.withColumnRenamed(oldColumns[idx], newColumns[idx]),range(len(oldColumns)), df)
尝试不同的技术，也让我知道。
分享就是关爱: )
现在，我们将进行分割以获得要素和标签列。
向量汇编器:
VectorAssembler 是一个转换器，它将给定的列列表合并成一个向量列。这对于将原始特征和由不同特征转换器生成的特征组合成单个特征向量以训练 ML 模型是有用的。
**from** **pyspark.ml.feature** **import** VectorAssembler
*#let's assemble our features together using vectorAssembler*
assembler = VectorAssembler(
inputCols=features.columns,
outputCol="features")
output = assembler.transform(df).select('features','Price')
这将转换目标和功能列。现在我们将它分成训练和测试数据集。
train,test = output.randomSplit([0.75, 0.25])
现在让我们应用一个线性回归模型
**from** **pyspark.ml.regression** **import** LinearRegression
lin_reg = LinearRegression(featuresCol = 'features', labelCol='Price')
linear_model = lin_reg.fit(train)print("Coefficients: " + str(linear_model.coefficients))
print("**\n**Intercept: " + str(linear_model.intercept))#Output
Coefficients: [-0.2845380180805475,-0.004727311005402087,1.187968326885585,201.55230488460887,-43.50846789357342]
Intercept: 298.6774040798928
我们得到的每一列和截距的系数。
trainSummary = linear_model.summary
print("RMSE: **%f**" % trainSummary.rootMeanSquaredError)
print("**\n**r2: **%f**" % trainSummary.r2)#Output
RMSE: 9.110080
r2: 0.554706
用于测试数据集
**from** **pyspark.sql.functions** **import** abs
predictions = linear_model.transform(test)
x =((predictions['Price']-predictions['prediction'])/predictions['Price'])*100
predictions = predictions.withColumn('Accuracy',abs(x))
predictions.select("prediction","Price","Accuracy","features").show()
r-测试数据集的平方值
**from** **pyspark.ml.evaluation** **import** RegressionEvaluatorpred_evaluator = RegressionEvaluator(predictionCol="prediction", \
labelCol="Price",metricName="r2")
print("R Squared (R2) on test data = **%g**" % pred_evaluator.evaluate(predictions))#output
R Squared (R2) on test data = 0.610204
现在让我们检查调整后的 R 平方。
调整后的 R-square:
调整的 R 平方是 R 平方的修改版本，已经针对模型中预测器的数量进行了调整。只有当新项对模型的改进超过偶然预期时，调整后的 R 平方才会增加。当预测者对模型的改进小于预期时，它会减少。我们使用调整后的 R2 值来惩罚与输出数据不相关的此类特征的过度使用。
r2 = trainSummary.r2
n = df.count()
p = len(df.columns)
adjusted_r2 = 1-(1-r2)*(n-1)/(n-p-1)
我们得到调整后的 r 平方值 0.54 用于训练和测试。
现在，让我们进一步探索 spark 中的 LinearRegression()。
lin_reg = LinearRegression(featuresCol = 'features', labelCol='Price',maxIter=50, regParam=0.12, elasticNetParam=0.2)
linear_model = lin_reg.fit(train)
在这里你可以应用套索，山脊，弹性网正则化，阿尔法值你可以修改。有一篇关于这些概念的非常好的文章。这是一个用于学习 Apache Spark Notes 的共享存储库。这个共享存储库主要包含文强在 IMA 数据科学奖学金期间的自学和自学笔记。感谢乔治·冯，ML 实验室的高级数据科学家。
我将在未来的故事中分享其他 spark 实现的 ML 算法。
对于建议，我将在LinkedInGmailTwiiter&关注我在GitHub的工作。**
PyCaret 简化了机器学习
PyCaret 的工作
我们经常被困在时间紧迫的场景中，无法完成任务。在机器学习中，在这种情况下非常有用的库是 PyCaret 。
PyCaret 是 Python 中的一个开源库，对于一些机器学习活动非常有用。它可以帮助你从数据预处理到模型的部署。PyCaret 如此有用和方便的原因是，任何事情都可以用很少几行代码实现，并且代码非常容易理解。我们可以更专注于对数据进行实验，而不是写几行代码。除了有助于数据预处理、编码分类特征之外，PyCaret 还通过考虑尽可能少的性能指标(如准确性、F1 分数、召回率等)来了解哪个模型更好。
在 Unsplash 上 Prateek Katyal 拍摄的照片
让我们深入 PyCaret 的工作。
1.安装:
PyCaret 的安装非常容易。它就像任何其他 python 库一样。可以通过在命令行中运行以下命令来安装它:
pip install pycaret
如果您使用的是 Google Collab，那么 PyCaret 可以通过以下方式安装:
!pip install pycaret
安装 PyCaret 将自动为您安装以下所有依赖项。
如果您不知道这些依赖性，您不必担心，因为 PyCaret 会处理这些依赖性。
一旦你安装了 PyCaret，你可以使用 import pycaret 将它导入到你的 jupyter 笔记本中
import pycaret
2.准备好数据
一旦 PyCaret 被导入，我们必须为构建模型准备好数据。我们可以通过以下两种方式加载数据:
1。熊猫数据框
2。来自 PyCaret 存储库的数据
让我们首先讨论如何使用 Pandas dataframe 加载数据。Pycaret 支持 pandas dataframe，可以通过使用“read_csv”和文件路径轻松加载数据。
import pandas as pd
data = pd.read_csv("data/train.csv")
data.head()
以类似的方式，我们可以加载 pandas 支持的所有其他类型的数据。
加载数据的另一种方法是使用 PyCaret 的存储库。它由可以非常容易地导入的数据集组成。如果您想了解 PyCaret 存储库中的数据集，请点击此处。
from pycaret.datasets import get_data
nba = get_data('nba')
3.环境设置
在设置环境之前，我们必须为数据集导入适当的模块。PyCaret 支持 6 个模块，这些模块中的任何一个都可以用一行代码导入。
PyCaret 支持以下 6 个模块。
Pycaret 环境的核心设置在于一个名为 setup()的函数。
setup()函数启动环境和管道来处理用于建模和部署的数据。在 PyCaret 中执行其他函数之前，必须启动该函数。
大约有 50 个参数被输入到 setup()函数中，但是我们不必担心，因为大多数参数都被设置为默认值，并且是可选的。只有两个强制参数需要输入，它们是 dataframe {类似数组的稀疏矩阵}和目标列。
setup()函数在后台自动进行 数据预处理和 数据采样。它在默认参数下运行，但是这些参数可以根据个人需求进行更改。
在我们的例子中，我们取一个名为***【NBA】的数据集，其中目标变量为【TARGET _ 5Yrs】***，这是一个二元分类问题。因此，我们使用导入分类模块
from pycaret.classification import *
pycar = setup(nba, target = 'TARGET_5Yrs')
一旦您运行上面的命令，您的数据集就被设置为一个分类模型，并且您可以看到输出消息声明 “设置成功完成！” 你会看到一组参数及其描述和与之对应的值。
现在让我们来看看 setup()函数的功能:
setup()函数对输入数据帧执行数据预处理。在任何 ml 模型中，数据预处理在构建 ml 模型中起着至关重要的作用。所以在 setup()函数中，PyCaret 为机器学习准备了超过 20 个特征的数据。机器学习管道是基于 setup()函数中定义的参数构建的。现在，我将详细解释 setup()函数中涉及的预处理步骤。如果你不知道这些，不要惊慌，因为我们的朋友 PyCaret 为我们做了这些。
PyCaret 为您处理的预处理功能有:
—取样和分割
—缩放和变换
—数据准备
—特征工程
—无人监管
让我详细阐述一下 PyCaret 能够完成的预处理步骤。
- 取样和分割
(一)列车试分裂:
机器学习中的任何数据集都被分成训练和测试数据集。这样做是因为当给定一个看不见的数据时，知道机器学习模型的工作是很重要的。在 PyCaret 中，默认情况下，70%的数据属于训练数据集，30%的数据属于测试数据集。
from pycaret.classification import *
reg1 = setup(data = nba, target = 'TARGET_5Yrs')
输出:
但是，只需在函数中传递 train_size 参数，就可以改变这些数据集的大小。
参数:列车尺寸
from pycaret.classification import *
reg1 = setup(data = nba, target = 'TARGET_5Yrs', train_size = 0.6)
分割后的数据(分割= 60%):
输出:
(二)采样:
如果数据集的样本/数据点很大，即超过 25，000 个样本，则 PyCaret 会自动进行采样。构建了具有各种样本大小的基本估计量，并获得了显示每个样本的性能度量的图。然后，可以在文本框中输入所需的样本大小。Sampling 是一个布尔参数，默认值为 True。
取样示例:
from pycaret.datasets import get_data
income = get_data('income')
from pycaret.classification import *
model = setup(data = income, target = 'income >50K')
此功能仅在 pycaret.classification 和 pycaret.regression 模块中可用。
- 数据准备
在执行机器学习流水线时，拥有正确的数据非常重要。很多时候，数据可能会损坏，可能会有一些丢失的值，或者应该对数据进行分类。所有这些在构建模型中起着至关重要的作用，需要在使用数据本身之前解决。
(一)缺失值插补:
数据中缺少记录是非常常见的，默认情况下，机器学习算法无法处理这个问题。PyCaret 自动进行缺失值插补。用于数字特征的缺省插补技术是“平均值”,用于分类特征的缺省值是“常数”。setup()函数中的参数名称是
参数:
数值 _ 插补:字符串，默认= ‘均值’
分类 _ 插补:字符串，默认值= ‘常量’
只要在 setup()函数中给出参数，就可以根据问题改变这些参数。
#import the hepatitis dataset from PyCaret repository
from pycaret.datasets import get_data
nba = get_data('hepatitis')
启动设置( )之前:
启动安装程序( )后:
㈡改变数据类型:
PyCaret 自动检测数据集中存在的要素的数据类型。这些值有时可能是错误的。因此，这个问题可以通过给定一个参数来解决，例如
参数:
numeric_features = [‘列名’]
category _ features =[’ column _ name ']或 date _ features = ’ date _ column _ name
ignore _ features =[’ column _ name ']
这些参数可用于覆盖 PyCaret 检测到的数据类型。当我们不想考虑任何特性时，可以使用另一个参数 ignore_features 。
示例:如果特性“GP”是分类的，但是 PyCaret 将其解释为数字，那么它可以被覆盖。
代码片段(从数字到分类):
from pycaret.classification import *
pycar = setup(nba, target = 'TARGET_5Yrs', categorical_features = ['GP'])
输出:
ignore_features 的示例:
这里我们将忽略数据帧的 MIN 列。
代码段(忽略数据集中的“MIN”列):
from pycaret.classification import *
pycar = setup(nba, target = 'TARGET_5Yrs', ignore_features = ['MIN'])
输出(“MIN”列已被忽略):
㈢一个热编码:
分类特征不能直接用于机器学习算法。必须使用一次性编码对它们进行分类。PyCaret 使用一键编码自动对分类特征进行编码。
示例:
在这里，名称是一个分类特征。因此 PyCaret 对其进行编码。
输出(’ Name '列已被一键编码):
㈣序数编码:
与其他分类特征相比，遵循“差、好、优”等顺序的分类特征应进行不同的编码。这是由 PyCaret 通过发送一个参数来完成的
参数:序数 _ 特征:字典
默认值为无。
代码:
from pycaret.datasets import get_data
emp = get_data('employee')
from pycaret.classification import *
model = setup(data = emp, target = 'left', ordinal_features = {'salary' : ['low', 'medium', 'high']})
输出:
model[0]
㈤基数编码:
通过使用一键编码，可以为邮政编码或国家等特征获得非常大的稀疏向量。因此，我们可以使用基数编码来解决这个问题。Pycaret 在 setup()中有一个参数，它为您进行基数编码。参数是
参数:high_cardinality_features:字符串，默认值=无
代码:
from pycaret.datasets import get_data
inc = get_data('income')
from pycaret.classification import *
model = setup(data = inc, target = 'income >50K', high_cardinality_features = ['native-country'])
输出:
㈥处理未知水平:
我们多次遇到这样的情况，测试数据具有新的级别，而这些级别在训练数据中并不存在。这由 PyCaret 通过给定“最频繁”或“最不频繁”的值来自动处理。setup()函数中的参数是
参数:
handle _ unknown _ categorical，default = True
unknown _ category _ method:string，default = ’ least _ frequent ’
- 缩放和变换
比例和变换非常重要，因为有时数据可能会有很大的变化范围或不同的比例。
( i)正常化:
归一化是一个非常重要的预处理步骤，它将确保数值不会分布得太广。当参数 normalize 设置为 true 时，PyCaret 进行归一化。有几种方法可以标准化数据。参数 normalize_method 的默认值是 z 值，其中平均值为 0，标准差为 1。其他值包括 min-max(值的范围为 0 到 1)、maxabs(确保每个要素的最大绝对值为 1)、robust(根据四分位数范围进行归一化，如果存在异常值，则更好)。
参数:规格化，normalize_method
归一化示例(使用默认的 normalize_method: Z-score):
代码:
from pycaret.classification import *
pycar = setup(nba, target = 'TARGET_5Yrs', normalize = True)
输出:
normalize_method 的示例:
代码(使用“最小最大”方法进行标准化):
from pycaret.classification import *
pycar = setup(nba, target = 'TARGET_5Yrs', normalize = True, normalize_method = 'minmax')
输出:
pycar[0]
㈡转型:
转换用于将数据转换为高斯或近似高斯分布。当参数转换设置为 true 时，PyCaret 进行规范化。有几种方法可以转换数据。参数 transformation_method 的默认值是 **yeo-johnson。**transformation _ method 的另一个值是分位数。
参数:转换，转换方法
示例:
from pycaret.classification import *
pycar = setup(nba, target = 'TARGET_5Yrs', transformation = True)pycar[0]
输出:
- 特征工程
特征工程是机器学习的创造性方面。特征工程是利用乘法、三角函数、对数函数等特征的组合，将数据转换到另一个空间。
(一)特色互动:
PyCaret 允许通过使用现有功能创建新功能。两个要素可以彼此相乘或相除以形成新的要素。使用的参数有 特征 _ 交互(乘法)，特征 _ 比率(除法) 。默认情况下，这两个参数都设置为 false。这些参数可在 setup()功能中更改，以获得特征交互。
参数:
feature_interaction: bool，default = False
feature_ratio: bool，default = False
interaction_threshold: bool，默认值= 0.01
示例:
从 PyCaret 存储库导入“血液”数据集
代码:
from pycaret.classification import *
model = setup(data, target = 'Class',feature_interaction = True, feature_ratio = True)
model[0]
输出:
㈡多项式特征:
就像在特征交互中一样，新特征是使用多项式次数(a)创建的。使用的参数是多项式 _ 特征，默认设置为假，多项式 _ 次数是一个整数，默认设置为 2。这些参数可以在 setup()函数中更改，以获得多项式特征。
参数:
多项式 _features: bool，default = False
多项式次数:int，默认值= 2
多项式 _ 阈值:浮点，默认值= 0.1
示例:
从 PyCaret 存储库导入“血液”数据集
代码:
from pycaret.classification import *
model = setup(data, target = 'Class', polynomial_features = True)
model[0]
输出:
(三)三角学特征:
这与多项式特征非常相似。使用的参数是trigon metric _ features，默认设置为 false。可以在 setup()函数中更改该参数，以获得三角函数特征。
参数:三角学 _features: bool，default = False
(四)群体特征:
当特征彼此相关时，可以使用 setup()函数中的 group_features 参数对这些特征进行分组。使用该参数可以获得平均值、中位数等信息。特性列表在参数 group_features 中传递。
参数:
group_features:列表或列表列表，默认值=无
group_names: list，默认值= None
(五)Bin 数字特征:
有时，连续要素可以有很大范围的值。在这种情况下，我们使用特征宁滨。setup()函数中使用的参数是 bin_numeric_features ，用于对数字特征进行绑定。
参数:bin_numeric_features: list，默认值= None
㈥结合稀有水平:
前面我们已经看到了一种热编码，其中像国家这样的特征在编码成数值时会生成一个稀疏矩阵。在这种情况下，模型的计算时间会随着要素数量的增加而增加。在这种情况下，特性中具有高基数的罕见级别被组合在一起。
参数:
combine_rare_levels: bool，default = False
稀有级别阈值:浮点型，默认值= 0.1
- 功能选择
选择好的和有用的特征是非常重要的，因为它有助于模型的解释。
(一)特征重要性:
它用于确定在预测目标变量时最重要的特征。setup()函数中使用的参数是 feature_selection ，默认为假。另一个名为的参数 feature_selection_threshold 存在，需要使用，尤其是在使用多项式或特征交互时。默认值为 0.8。
参数:
feature_selection: bool，default = False
feature _ selection _ threshold:float，默认值= 0.8
㈡消除多重共线性:
当一个要素与另一个要素高度相关时，就存在多重共线性。这将导致模型不稳定。因此，可以通过使用参数移除多重共线性将其移除，该参数在 setup()函数中默认设置为 false。可使用参数多重共线性 _ 阈值设置阈值以删除特征的数量，默认设置为 0.9。
参数:
remove_multicollinearity: bool，default = False
多重共线性 _threshold: float，默认值= 0.9
(三)主成分分析:
这主要用于降维。当数据集由许多维度组成时使用它。但是当使用 PCA 时，存在信息损失。这里使用的参数是 pca_method ，其默认值是线性的。其他可以使用的方法是 RBF 和增量。下一个参数是 pca_components ，它可以接受 int 和 float 值。如果给定一个整数值，那么它意味着要出现的特征的数量，如果存在浮点值，那么它意味着要保留的信息的百分比。
参数:
pca: bool，default = False
pca_method: string，default = 'linear ’
pca_components: int/float，默认值= 0.99
㈣忽略低方差:
在多分类特征具有偏斜分布并且一个或两个特征相对于其他特征占优势的情况下，模型获得的方差将非常低。在这种情况下，我们可以忽略该功能。
在忽略特征之前，应满足以下标准 (参考) :
—特征/样本大小中唯一值的计数< 10%
— Count of most common value / Count of second most common value > 20 次。
参数:ignore_low_variance: bool，default = False
- 无人监管
㈠创建集群:
聚类对于无监督学习非常重要。通过将 create_cluster 值设置为 true，数据集中的每个点都被分配给一个特定的聚类，并且每个聚类都被用作一个新要素。Cluster_iter 参数用于控制用于形成一个聚类的迭代次数。
参数:
create_clusters: bool，default = False
cluster_iter: int，默认值= 20
㈡消除异常值:
离群值会影响模型的性能，因此需要移除。PyCaret 使用 SVD 通过 PCA 去除异常值。可以通过将参数 remove_outliers 设置为 true 来移除离群值。异常值的百分比可以由参数 outlier_threshold 控制，其默认值为 0.5。
参数:
remove_outliers: bool，default = False
outliers_threshold: float，默认值= 0.05
设置使用所有 belowinput 参数，但请记住，只需输入两个强制参数，即数据和目标，其余所有值均设置为默认值/可选值。
设置 ( data，target， train_size = 0.7，sample_estimator = None，categorical _ features = None，category _ attraction = ’ constant '，ordinal_features = None，high_cardinality_features = None，high _ cardinality _ method = ’ frequency '，numeric_features = None，numeric _ attraction = ’ mean '，date_features = None，ignore_features = None，normalize = False，normalize rare_level_threshold = 0.10，bin_numeric_features = None，remove_outliers = False，outliers_threshold = 0.05，remove _ multi 共线性= False，multi 共线性 _threshold = 0.9，create_clusters = False，cluster_iter = 20，polynomial_features = False，polynomial_degree = 2，trigonometry _ features = False，多项式 _threshold = 0.1，group_features = None，group_names = None，feature_selection = False，feature _ sel
简而言之，你可以只使用下面的代码，而不是给出所有这些参数。
设置(数据、目标)
4.比较模型
PyCaret 的一个主要用途就是可以用来比较几种基于性能指标的机器学习模型。因此可以确定最佳模型。*这些模型通过使用 10 倍交叉验证进行计算。*这对于了解模型的行为以及哪个模型更适合非常有用。比较模型的代码非常简单。
比较模型()
compare_models()
*结果:*该函数返回一个分数网格，指定每个性能指标的最佳模型。
用于分类的性能度量是准确度、AUC、召回率、精确度、F1、Kappa。
用于回归的性能指标有 MAE、MSE、RMSE、R2、RMSLE、MAPE
该表按精度排序，但可以通过在排序参数中给定不同的值来修改。默认情况下，折叠值为 10。这可以根据我们正在解决的问题而改变。
5。创建模型
一旦我们了解了哪个模型更好，就该创建模型了。创建模型的代码非常简单。
create_model(‘模型名称’)
输出是一个 knn 模型和一个分数网格，它说明了准确性、AUC、召回率、精确度、F1 和 kappa 值。
knn_model = create_model('knn')
结果:
我在 create _ model(‘KNN’)函数中使用‘KNN’表示构建了一个 K-NN 模型。同样，您可以通过在 create_model('model name ')中使用以下任一表示来构建其他模型。
默认情况下，模型是使用 10 倍 CV 创建的。相反，我们可以通过使用折叠参数来改变它。
创建模型(使用 7 折 CV):
knn_model = create_model('knn '，fold = 7)
knn_model = create_model('knn',fold = 7)
输出:获得的结果 knn_model 将在 7 折交叉验证上训练。
创建模型(四舍五入到小数点后两位):
我们可以在创建模型功能中使用舍入参数来舍入性能指标。
knn_model = create_model('knn '，round = 2)
knn_model = create_model('knn',round = 2)
结果:分数网格中的指标将四舍五入到两位数。
6.调整模型
顾名思义，我们可以使用 tune_model()函数来优化模型，在 create_model()函数中，模型是使用默认的超参数创建的。tune_mode()函数的功能是，它将自行调整模型的超参数，并生成一个分数网格作为输出。
调谐前:
knn_model = create_model('knn')
调谐后:
tuned_knn = tune_model('knn')
Tuning_model(使用优化):
使用的默认优化方法是 accuracy，但是我们可以通过使用 tuned_model()函数的优化参数来更改它。
tuned_knn = tune_model('knn '，optimize='AUC ')
tuned_knn = tune_model('knn',optimize='AUC')
以类似的方式，我们可以使用其他优化措施，如“召回”、“精度”、“F1”。
*结果:*绩效评估值的得分有所提高。
7.集合一个模型
PyCaret 还执行模型的集合。由于集成提高了模型的性能(在大多数情况下)，我们可以在 PyCaret 中使用打包、提升、混合和堆叠来集成我们的模型。
集合 _ 模型(模型 _ 名称)
示例:对于这个示例，我们将构建一个简单的决策树，并在其上执行集成。
创建一个简单的决策树:
代码:
dt = create_model('dt')
组装后:
代码:
bag_dt = ensemble_model(dt)
我们可以看到组装后的显著差异。装袋是默认技术。
以类似的方式，我们可以执行增强、混合和堆叠。点击此处获取更多信息。
8.绘制和评估模型:
在一个模型被创建之后，绘制模型的性能度量并对其进行分析是非常容易的。使用 plot_model 可以实现不同类型的可视化，如 AUC、精度-召回曲线、决策边界等。
plot_model(model_name，plot = "type ")
绘图代码:
logreg = create_model('lr')
plot_model(logreg, plot = 'boundary')
我们在代码中使用了 plot = "boundary ",它表示决策边界。以类似的方式，我们可以使用其他图使用他们的字符串类型。下表是 PyCaret 支持的绘图类型。
此外，对于包含概率的模型，我们可以在校准的分类器的帮助下使用模型校准来预测结果的真实概率。提供概率值增加了可解释性并减少了不确定性。
校准型号(型号名称)
代码:
#Create a simple decision tree
dt = create_model('dt')#Calibrate the model
calib_dt = calibrate_model(dt)
除此之外，还有一个非常有用的函数 evaluate_model(model) ，用于显示所有的可视化效果。这只适用于 jupyter 笔记本界面。它提供了一个交互式用户界面，我们可以在其中选择我们需要的可视化类型。
代码:
evaluate_model(logreg)
以下是 evaluate_model 工作方式的视频演示。
这些可视化对于不同的机器学习模块是不同的。点击此处了解更多可视化信息。
9.解释模型
在 PyCaret 中也可以对模型进行解释。使用 shap 值来确定特征的重要性。形状值中的图形由 x 轴和 y 轴组成。x 轴由 shap 值组成，这些值以积极或消极的方式显示功能的影响。y 轴由特征值组成。
model = create_model('xgboost')
interpret_model(model)
shap 值主要用于确定某个要素对于预测分类标注的重要性。右侧的红色表示该功能做出了积极的贡献。
10.预测模型
到目前为止，所有的结果都是基于 k 倍交叉验证(训练数据集)。现在，我们将在测试数据集上预测模型的性能。
代码:
rf_holdout_pred = predict_model(rf)
创建模型后的输出:
在测试数据集上预测模型后的输出:
11.保存模型
PyCaret 使我们能够使用 save_model(name，model_name = ’ ')将整个模型管道保存到二进制 pickle 文件中。一旦保存了模型，我们就可以使用 load_model()随时加载它。我们将保存在步骤 9 中创建的 xgboost 模型，命名为‘py caret _ model’。
代码:
save_model(model, 'pycaret_model')
我们可以通过使用 load_model()函数简单地加载这个保存的模型。
代码:
load_saved_model = load_model('pycaret_model')
#Now our previous model is loaded into **saved_model** and is ready to predict/classify.
除了只保存模型，还可以使用 save _ experiment(experiment _ name = ’ py caret _ experiment ')以类似于保存模型的方式保存整个实验。通过这样做，您可以保存所有的模型及其输出。
load_experiment(experiment_name='pycaret_experiment'
也可以实现实验的加载。
load_saved_exp = load_experiment(‘pycaret_experiment’)
这就是了，你最终训练好的模型/实验可以用一行代码调用和使用。我们还可以在 AWS 中部署构建好的模型。因此，我们可以使用非常少的代码行构建一个完整的管道模型。
结论
总之，PyCaret 是一个非常有用的库，可以帮助您节省大量的时间，因为您已经基本了解了机器学习中的概念，如算法如何工作、性能指标、数据预处理等。PyCaret 在很短的时间内产生显著的结果。我肯定会建议探索 PyCaret ，因为这是值得的！
我要感谢 Moez Ali 和 PyCaret 的团队提供了这个库。
感谢阅读到最后。如果有任何错误或建议，请不吝赐教。
如果你想联系我，请通过 LinkedIn 联系我。
参考文献:
[## 宣布 PyCaret:一个用 Python 编写的开源低代码机器学习库
Python 中的开源低代码机器学习库。
towardsdatascience.com](/announcing-pycaret-an-open-source-low-code-machine-learning-library-in-python-4a1f1aad8d46) [## 预处理- PyCaret
PyCaret 是一个部署就绪的 Python 库，这意味着当您执行一个实验时，所有步骤都会自动…
pycaret.org](https://pycaret.org/preprocessing/) [## 函数- PyCaret
函数是 PyCaret 中按顺序执行任务的一组操作。PyCaret 中的所有函数都接受一个输入…
pycaret.org](https://pycaret.org/functions/)
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
