机器学习&图像到音频字幕
杰森·罗斯韦尔在 Unsplash 上的照片
关于机器学习如何用于将图像直接翻译成语音的简要文献综述。
机器学习已经扩展到许多不同的领域和学科。尝试新的领域是成长和学习新事物的最好方式。以下是研究人员如何应用机器学习直接从图像中生成音频描述的总结。
图像 2 语音:自动生成图像的音频描述
研究人员在不使用文本作为中间形式的情况下为图像生成音频字幕。
Clustergen、VGG16、LSTM、MSCOCO、语音-COCO、XNMT、Flickr、Flickr-Audio
丹尼尔·山特维克在 Unsplash 上的照片
摘要和导言
研究人员提出了人工智能的一个新领域，图像 2speech。他们将主要任务定义为:
" Image2Speech 系统应该直接生成图像的语音描述，而不需要首先生成文本."
以前，image2speech 问题被分解为两个步骤:image2txt，然后 txt2speech。但是，一些语言没有书面形式(例如阿尔及利亚语、摩洛哥语、黎凡特语、各种阿拉伯语等)，因此传统的 img 2 语音翻译不适用于这些语言。
方法
研究人员使用标准的开源库、软件和数据来开发他们的模型。图一。展示了这些技术是如何相互关联的。
- VGG16 (从图像中提取 CNN 特征)
- XNMT (从 CNN 特征生成语音单元)
- ClusterGen (将语音单元转换成音频)
- Kaldi 和 Eesen (自动语音识别，将音频翻译成语音单元)
- Flickr 图像数据集和 Flickr 音频
- MSCOCO 和演讲-COCO
图一。图像速度的实验方法。来源:作者
Image2Speech 系统由三个独立的网络组成(VGG16、XNMT 和 Clustergen)。整个网络根据图像和音频描述对进行训练。
作者使用 VGG16 提取图像特征，然后 XNMT 将这些图像特征转化为语音单元，最后 Clustergen 将语音单元转化为音频。
" XNMT(可扩展机器翻译工具包)专门用于训练序列对序列神经网络."
数据
数据来自两个不同的来源。它们都有一个图像数据集(Flickr 和 MSCOCO)和一个音频数据集(Flickr-Audio 和 SPEECH-MSCOCO)。因此，每个图像都伴随有文本字幕和该文本字幕的音频朗读。
示例图像 1000268201。来源:公共领域
上图的字幕是由亚马逊土耳其机械公司的工人制作的:
- 一个穿着粉色连衣裙的孩子正在入口通道爬上一组楼梯。
- 一个女孩走进一栋木制建筑。
- 一个小女孩爬进木制玩具屋。
- 一个小女孩爬楼梯去她的玩具屋
- 一个穿着粉色连衣裙的小女孩走进了一个小木屋。
MSCOCO 是最大的 image2txt 和 text2speech 数据集。它是如此之大，以至于研究人员在训练过程中无法将它全部包含进来。
结果
在所有模型被训练之后，它们实现了 78.8%的电话错误率。作者将此描述为:
“不是完全自然的，而是由可理解的单词组成的可理解的句子”
结论
作者定义了一个新的人工智能领域，比传统的 image2speech 更具挑战性和限制性。在没有任何中间文本的情况下，从图像生成语音是新应用的独特问题。在本文中，作者提出了第一个此类模型，并希望鼓励其他人继续构建更有趣的模型。
机器学习和更多
关于机器学习如何使听力损失者受益的简要文献综述。
towardsdatascience.com](/machine-learning-hearing-loss-d60dab084e3f)
参考文件
Mark Hasegawa-Johnson，Alan Black，Lucas Ondel，Odette Scharenborg，Francesco Ciannella，《图像 2speech:自动生成图像的音频描述》，载于 inter speach(2020)http://www . cs . CMU . edu/~ awb/papers/Hasegawa Johnsons 17 icnlssp . pdf
坚果壳中的机器学习
图片由肖恩·巴蒂通过 pixabay.com 提供
怎么这么热闹？
机器学习是一个概念，也是当今科技环境中经常被丢弃的热门词汇，就解释而言，它还有很多需要改进的地方。人们经常把机器学习算法称为黑匣子；虽然机器学习的某些方面可能缺乏透明度，但通过了解机器学习的一些背景知识，可以减轻很多沮丧或困惑。
作为一门学科，机器学习比你想象的要简单得多，并且可以简化为许多组成部分。当机器学习在您的业务、项目或组织的背景下提出时，拥有这种高层次的视角将允许您理解并参与对话。
机器学习是由什么组成的？
机器学习有两个主要领域，我们将在这里进行分解。你遇到的大多数“ML”解决方案都属于这两类:监督学习和非监督学习
监督学习
监督机器学习问题的想法是，你实际上有一个预定义的数据集，其中包含所谓的因变量和响应变量。因变量是你想要理解的，自变量是你可以用来理解事物的。
监督学习的世界又分为两个子类:回归和分类。当我给出这些例子时，监督学习的全貌应该会变得更加清晰
回归
当我们在监督学习子类的上下文中谈论回归时，我们实际上谈论的是连续变量的预测。换句话说，不是预测某个东西是不是垃圾邮件，是不是猫，是不是什么即分类；那么我们预测的是一个可以“持续”的数字。
让我们用几个例子来说明这一点
假设你想预测个人收入。你有一个数据集，它详细描述了某人的经历、教育、技能等等…在此基础上，你可以利用这些变量来预测他们可能会生产什么。
另一个经典的例子是房价。您想知道您的房子在给定市场中的价格，因此您可以传递该市场的房屋销售数据来创建一个模型，该模型使用房间数、平方英尺、地块大小、建造年份等数据点来预测房屋价值。
希望这锁定了回归&也提高了分类。
分类
还记得我说的那些不是回归吗？那些东西是分类的。我们在这里仍然使用监督学习，但它不是预测一个连续的数字。
我们试图预测类别或阶层。这又引入了一个难题，但是当涉及到分类时；你可以试着预测某样东西属于或不属于某个类；即二进制分类，或者你可以预测一个记录属于哪一类；即多类分类。
对于二元分类，您可能希望预测一个机会/交易的结果是赢还是输。
你可以根据收视率、票房和预算来预测电影类型。
无监督学习
当谈到无监督学习时；模型会自己识别自然模式，而不是命令你的模型去理解什么。
使聚集
可能最流行的无监督学习方法被称为聚类。类似于我刚才描述的回归；假设您正在查看住房数据，但您希望了解住房的自然分组，而不是预测给定的变量，聚类将允许您根据与定义的组的最大相似性和与其他组的最大不相似性来识别住房的自然分组。
有了住房数据，你可以指定你关心平方英尺和房子的价值；你可能会看到自然分组可能是房屋类型、不同市场、年龄等的指标。
结论
机器学习活动还可能属于另外两个新兴的、不太流行的类别。那些是强化学习和半监督的。我不会在这里深入探讨这两个问题，但是如果你觉得这很有帮助，并且想要更多类似的内容，可以看看我在 datasciencelessons.com 的博客。
感谢阅读！祝数据科学快乐！
学术研究与实践中的机器学习
典型工业机器学习项目的阶段
安迪·凯利在 Unsplash 上的照片
作为解决大数据世界问题的关键技术之一，机器学习肯定越来越受欢迎。作为一名博士毕业生，我来自这个领域的学术方面。然而，自从我开始尝试在实践中应用我的“知识”以来，我发现建立一个 ML 模型来解决一个业务问题和写一篇论文之间有相当大的区别。
学术研究通常只关注理论。我们曾经试图将模型的精度提高一点点。即使我们在某个特定的课题上只迈出了一小步，也不妨碍我们写出一篇优秀的学术论文并发表。
实际上，对于一个基于行业的项目，只关注机器学习的一个方面是不够的。我们通常需要按照一定的步骤来解决问题，根据我过去的经验，如下所示:
因此，以下这些常用短语对于典型的工业 ML 项目至关重要:
- 问题建模
- 特色工程
- 型号选择
- 模型组装
在本文中，我将在其余部分介绍这些阶段，并说明为什么这些步骤对于解决实际问题是必要的，以及学术研究和工业项目在这些方面有什么不同。
问题建模
照片由Olav Ahrens rtne在 Unsplash 上拍摄
在开始解决问题之前，我们需要对问题进行建模，因为实际问题通常很复杂。这是实践和学术研究的显著区别之一。当我们专注于学术研究的理论时，使用一些公共数据集是很常见的。这可以节省我们收集数据的时间和预算，并使我们能够从其他类似研究的相同基线开始，这有利于以后的评估。
问题建模从收集信息开始，以便理解它，然后将问题抽象成可预测的东西。
我们需要为问题建模做的具体步骤
- 阐明业务逻辑(领域知识)
- 提取现有要素(输入)
- 定义要预测的内容(输出)
- 选择合适的评估指标
- 选择原始数据集的最相关子集(采样)
- 基于评估指标交叉验证模型
就我而言，有很多数据科学家和机器学习工程师通常会从一个 ML 问题的特征工程开始，这被认为是一个不合适的过程。
问题建模不应该被忽略的原因有很多，但是我发现下面两个子步骤是主要的。
评估指标
评估方法有很多种，如混淆矩阵、ROC/AUC、MAE 和 MSE。在学术研究项目中，选择任何有意义的人都是常见的，最重要的是，与其他算法相比，你的算法在这些指标下显示出最佳结果。这实际上并不尴尬，因为我相信所有的研究人员都想强调他们已经取得的进步，尽管他们可能也想在“未来工作”部分展示一些局限性。一般来说，这就是在学术研究中使用评估指标的方式，以强调贡献。
说到行业，这样评价你的模式会很危险。你可以向你的老板展示该模型在特定评估指标下的先进性。但是，如果您没有选择最适合问题的适当方法，该模型可能最终在实验中非常有效(当您向您的老板炫耀时)，但在实践中却不有效(生产使用)。想象一下，如果您的模型是对患者进行分类，以确定他们是否患有疾病，如果该模型在实践中运行不佳，可能会产生巨大的影响甚至危及生命的后果。
因此，我们需要选择能够最好地反映问题空间的评估指标，以及能够产生与原始数据集最相似的波动的评估指标。选择一个正确的度量标准可以确保您有一个合适的方法来评估您的模型，不仅针对您的测试数据集，而且针对您的实际使用。此外，它将极大地提高 ML 模型迭代的效率。
交叉验证
在学术研究中，大多数时候，小样本数据集不会成为问题，除非你的研究主题是使用有限的样本训练一个好的模型。然而，在实践中只有很小的样本量是很常见的。这可能是因为您的信息系统冷启动，或者您的企业还没有太多的用户，或者只是因为一些限制，如隐私政策，不允许您有足够的样本。
假设我们的样本数据集中只有 100 个条目，基于这个数据集训练了两个不同的模型。模型 A 有 98%的准确率，模型 B 有 92%的准确率。我们是否可以简单地说 A 型比 B 型“更好”？答案是否定的。
样本数据集太小，所以它没有足够的信心来确定哪个模型比另一个更先进。交叉验证是增加这种信心的技术之一。最常见的方法是保留，它将样本数据集分成训练集和测试集。还有一些其他方法，如 K 倍交叉验证和 bootstrap 抽样。这些交叉验证技术有助于使用相对较小的样本数据集使您的模型更接近实际用途。
特征工程
米卡·鲍梅斯特在 Unsplash 上的照片
如果你的学术研究课题不是关于特征工程的，你大概不会被这个困扰。您可以下载公共数据集，如 MovieLens 等。然后，使用您的算法训练一个模型，并将其与在同一数据集上使用其他算法训练的模型进行比较，以显示您的算法是如何进步的。然而，特征工程对于工业 ML 项目总是必要的，因为所收集的数据集对于您的企业来说是唯一的，并且大多数时候甚至不能直接用于训练可用的模型。
例如，一个制造工厂可能有 100 多个与设备相关的传感器，您需要训练一个模型来预测设备何时会出现异常。您可能会发现，在特征工程阶段，可能只有 20 个传感器会导致“异常”。此外，有些传感器可能无法独立工作。它必须与其他传感器一起转换，以便与该设备的“异常”相关联。因此，在实践中几乎不可能准备好原始数据集。为了在模型可以被很好地训练之前找到有意义的特征，特征工程对于大多数项目是强制性的。
通常，存在各种因素，机器学习工程师需要应用不同的原则和方法来执行特征工程任务，例如在问题建模阶段或业务逻辑本身中选择不同的模型。
因此，在我们完成了问题建模、数据过滤和清理之后，是时候开始特性工程了。这是一项关键但困难的任务，通常依赖于对 ML 的经验以及对领域知识的透彻理解。不夸张的说，大部分成功的机器学习项目都有优秀的特征工程。
型号选择
瑞安·昆塔尔在 Unsplash 上拍摄的照片
虽然特征工程很重要，但它仍然不是成功的工业机器学习模型的唯一因素。也就是说，选择不同的模型会导致完全不同的预测结果。换句话说，如果我们为问题选择的模型不合适，那么迭代模型变得实用可能是非常低效的，或者最有可能的是，永远没有一个有用的模型。
这在学术研究中很少困扰我，因为大多数时候，我们会分析特定类型的 ML 模型。我们甚至可能会寻找一个合适的数据集，以确保它更适合模型，而不是相反。然而，在一个工业 ML 项目中，我们正在解决一个特殊的问题，因此我们不能选择数据集。因此，我们只能为所提供的数据集选择模型。
我们应该根据不同的情况选择不同的模式。例如，逻辑回归可能适用于布尔型预测目标，随机森林通常适用于一些分类问题，深度学习通常是图像/语音识别的最佳选择。
因此，在一系列特征工程任务之后，我们还需要考虑哪种类型的模型可以从具有最佳潜在结果的特征中学习潜在模式。毫无疑问，选择一个合适的模型需要对大多数流行的模型有深刻的理解，并有丰富的行业经验。
模型装配
同样，除非你的研究课题是关于模型组装的，那么你就不会担心这个问题。然而，当涉及到一个行业项目时，你会发现为一个 ML 问题集合不同的模型是非常有效的。
正如在模型选择一节中提到的，我们需要选择一个最适合问题的模型。然而，这也是因为不同的模型在从特征中捕捉不同类型的潜在模式方面各有所长。很多时候，我们需要组装多个模型才能有一个更优的模型。
ML 模型有多种组装方法，如加权、投票、装袋和堆叠。与模型选择类似，模型组装也依赖于对模型的深刻理解和数据科学家的个人经验来优化组装的模型。
结论
总之，在如何利用机器学习模型方面，学术研究和基于行业的项目之间存在明显的差异。
对于学术研究，我们通常只关注机器学习的一个方面，并尽力改善这一单一方面。对于我们的研究论文中没有涉及的其他方面，我们可以不花力气，或者只花很少的力气。
对于一个基于行业的机器学习项目，如果你来自学术背景，就不要被困住。也就是说，不要只关注一个方面，而是遵循典型的阶段来建模问题，执行特征工程，选择合适的模型并进行优化组装。
让我们建立实用的机器学习模型！
作为一个媒体会员，你的会员费的一部分会给你阅读的作家，你可以完全接触到每一个故事…
medium.com](https://medium.com/@qiuyujx/membership)
如果你觉得我的文章有帮助，请考虑加入 Medium 会员来支持我和成千上万的其他作者！(点击上面的链接)
金融中的机器学习:使用图形套索识别国际股票交易所交易基金中的交易对
TL；博士: 在这篇文章中，我将尝试解决识别相关股票投资组合的问题，这通常是 pairs 交易策略的第一步，也是最重要的一步。这种方法利用了图形 lasso 算法，该算法已被证明是许多实际问题的强大机器学习解决方案，如识别共同变化的大脑区域，社交媒体网络分析等。这是关于这个主题的系列教程中的第一篇，重点是它的一个应用； 我的第二篇帖子 以血淋淋的细节阐述了其背后的美丽理论，未来的帖子将展示该算法如何带来令人惊讶的营销洞察力。所以请关注我，敬请期待。
马库斯·斯皮斯克在 Unsplash 上拍摄的照片
股票投资的世界是诱人的，我们许多有技术的人都希望进入其中。然而，浪费我们的时间去筛选股票宇宙的基本面，比如说，仅仅在 SP500，对于有创造力的头脑来说，这本身就过于乏味和卑微了。
幸运的是，凭借编码知识和对机器学习的兴趣，你完全有能力在量化投资领域大展拳脚。下面，我将说明如何，作为创建自己的交易策略的第一步，使用一种称为图形套索的强大的机器学习算法，在国际股票 ETF 报价机中识别有意义的配对和聚类，以创建一个投资组合，这将是建立自己的配对交易策略的第一步，也是最重要的一步。
在整个教程中，我将把细节保持在最低限度和有意义的可行范围内，以便让您快速入门，您可以自由探索该算法的更多可能性。
系好安全带，让我们上路吧！
图形套索简介
还记得名为 lasso 的回归方法吗？该方法用于通过添加 L1 正则化项来导出回归问题的稀疏解。图形套索是它在图形世界的延伸。
图形套索不是估计回归问题中独立变量的系数，而是估计数据的精度(逆协方差)矩阵。因此，它不是像 lasso 回归中那样将许多系数推至 0，而是将矩阵中的许多值推至 0。
为什么是“图形化”？因为精度矩阵可以显示为唯一地对应于一个无向图(在后面的部分中有更多的介绍)。
换句话说，图形化套索的目标是从你的数据中归纳出一个具有稀疏连接的无向图。这个事实将在我们稍后尝试说明 ETF 图并识别可能的集群时派上用场。
关于算法更具体的数学处理，请参考我在这个系列的第二篇文章，它一步一步地分析了算法。
数据准备
在这个实验中，让我们使用报价机的每日收盘价。我们将使用雅虎财经提供的历史数据。例如，要将股票行情系统 QQQ 的历史数据下载到您的本地机器上，您可以导航到 https://finance.yahoo.com/quote/QQQ/history?p=QQQ 的，选择日期范围，然后点击“下载”。在我们的实验中，假设我们对某些国家特别好奇，并检索以下国家 ETF 的数据:
#Setting up the mapping from ticker to country
etfs = {"EWJ":"Japan","EWZ":"Brazil",
"FXI":"China","EWY":"South Korea",
"EWT":"Taiwan","EWH":"Hong Kong",
"EWC":"Canada","EWG":"Germany",
"EWU":"United Kingdom","EWA":"Australia",
"EWW":"Mexico","EWL":"Switzerland",
"EWP":"Spain","EWQ":"France",
"EIDO":"Indonesia","ERUS":"Russia",
"EWS":"Singapore","EWM":"Malaysia",
"EZA":"South Africa","THD":"Thailand",
"ECH":"Chile","EWI":"Italy",
"TUR":"Turkey","EPOL":"Poland",
"EPHE":"Philippines","EWD":"Sweden",
"EWN":"Netherlands","EPU":"Peru",
"ENZL":"New Zealand","EIS":"Israel",
"EWO":"Austria","EIRL":"Ireland","EWK":"Belgium"}
然后，我们做一些整理工作来简化数据格式，以便于以后的处理:
symbols, names = np.array(sorted(etfs.items())).T
现在，您应该已经下载了这些国家 ETF 的数据文件。下一步是将它们整理成一个大数据文件，其中列是股票代号，如上面排序的“EWK”，行是时间顺序的日期。你可以使用一个简单的 Python 脚本或者其他你喜欢的工具来实现。
让我们将整理好的文件读入熊猫数据帧:
#Read in series of daily closing prices
#The file 'input.csv' uses the tickers above as columns, and dates #as index in df
df = pd.read_csv("input.csv", index_col='Date')
数据处理
在应用算法之前，我们需要注意一件事:
#Convert price series to log return series
df = np.log1p(df.pct_change()).iloc[1:]
这一行代码将每日收盘价的时间序列转换成一系列的对数回报。请注意，这一步不是强制性的，但在这种情况下通常是一种良好的做法。可以论证如下:
虽然股票价格不是正态分布，但对数回报也不是，而是比价格更接近正态分布。应用数学家喜欢正态性，因为当他们使用不同的分析工具/算法处理数据时，它减轻了很多痛苦，其中大部分都假设数据正态性能够有意义地发挥作用。
底线:学会热爱高斯，获得对他的分布的品味，尽你所能在你的数据中发现它。
核心
现在我们准备应用算法:
#Calling Glasso algorithm
edge_model = covariance.GraphicalLassoCV(cv=10)
df /= df.std(axis=0)
edge_model.fit(df)
#the precision(inverse covariance) matrix that we want
p = edge_model.precision_
这里我们利用 Python 中的 sklearn 包来方便地实现图形化套索。请注意我是如何检索得到的精度(逆协方差)矩阵的，这是我们这里的重点。我们选择精确(逆协方差)矩阵，而不是协方差矩阵的原因是图形套索与其他无聊算法的区别，也是我下一篇文章的主题。现在，它足以说:
(1)是的，大多数人做协方差分析，但那可能是因为他们只知道这些。既然你已经听说过逆协方差，请从现在开始把它用到你的优势上。
(2)精度矩阵可以唯一定义一个无向图:其单元格( i ， j )的值，如果等于 0，则表示变量 i 和 *j，*之间的条件独立性，如果不为零，则表示条件(不)依赖的程度；并且这些依赖关系映射到无向图，使得如果两个顶点是条件独立的，则它们之间没有链接。
说了这么多，让我们看看使用 Seaborn 是什么样子的:
sns.heatmap(p)
我们得到了:
x 和 Y 标签遵循 ETF 的排序顺序
它看起来不错，但实际上并没有告诉我们太多。图形套索的强大之处在于它能够学习精确矩阵，然后将矩阵映射到图形。
所以让我们这样做:
#prepare the matrix for network illustration
p = pd.DataFrame(p, columns=cols, index=cols)
links = p.stack().reset_index()
links.columns = ['var1', 'var2','value']
links=links.loc[ (abs(links['value']) > 0.17) & (links['var1'] != links['var2']) ]
#build the graph using networkx lib
G=nx.from_pandas_edgelist(links,'var1','var2', create_using=nx.Graph())
pos = nx.spring_layout(G, k=0.2*1/np.sqrt(len(G.nodes())), iterations=20)
plt.figure(3, figsize=(30, 30))
nx.draw(G, pos=pos)
nx.draw_networkx_labels(G, pos=pos)
plt.show()
上面的代码片段将精度矩阵转换为图形，并使用 Python 中的 Networkx 包来绘制它。我已经尝试让节点尽可能稀疏，这样节点标签就不会重叠，但还是不太令人满意。你自己试试看。
为了解决这个问题，让我们再做一步，将图形导出到 Gephi 中:
nx.write_gexf(G, 'graph.gexf')
在 Gephi 中打开文件并调整其布局，我们得到了以下有趣的国家 ETF 集群:
集群:混乱中的秩序
天真的是，你可以把这三个集群视为三个独立的投资组合，然后计算出每个组合的套期保值比率。或者更好的是，您可能想要尝试添加边权重并说明节点之间的结合强度，并基于该信息进一步将大型集群划分为较小的集群。请随意添加更多的数据和股票代码，并开始自己的研究。
群集布局看起来很有趣。它与地理位置非常匹配，这并不奇怪，因为地理上聚集在一起的国家往往会形成紧密结合的共同市场，并往往有大致共同变化的股票市场。同样有趣的是，东亚市场如何首先通过新加坡，然后通过澳大利亚和加拿大连接到欧洲集群。我无法深入分析这些联系，现在就把它留给好奇的读者去娱乐或困惑。
克里斯汀·罗伊在 Unsplash 上的照片
请记住，随着世界的发展和国家之间不断的友好或不友好，集群会发生变化。这是对任何交易算法的期望，以解释世界上的范式转变。
做你自己的实验，并把它作为你建立自己的交易算法的第一步。请继续关注这方面的更多信息，以及机器学习、金融和更多其他有趣的话题。
来自《走向数据科学》编辑的提示: 虽然我们允许独立作者根据我们的 规则和指导方针 发表文章，但我们并不认可每个作者的贡献。你不应该在没有寻求专业建议的情况下依赖一个作者的作品。详见我们的 读者术语 。
面向初学者的 Apache Spark 中的机器学习—医疗保健数据分析
图片由皮克斯拜的 Gerd Altmann 提供
大数据/数据科学/教程/指南/ Apache Spark /机器学习
使用 Databricks 在 Apache Spark 中构建第一个机器学习模型的分步指南
简介:
Apache Spark 是一个集群计算框架，旨在实现快速高效的计算。它可以用相对较低的计算能力处理数百万个数据点。Apache Spark 构建在 Hadoop 的 Map-Reduce 之上，是其扩展，可以有效地使用不同的集群计算组合。Spark 的主要特性是内存集群计算，它提高了应用程序的速度，包括交互式查询和流处理。
这篇文章是使用数据块在 Spark 中开发预测模型的快速入门指南。
我将使用 Databricks 的免费社区版本，感谢他们！
关于数据/背景信息:
在这篇文章中，我将使用机器学习来帮助我们预测患者患糖尿病的概率。数据集是从UCI 机器学习库下载的。
在这里，我使用提供的关于患者的信息来预测糖尿病的概率。这是一个二元分类问题，我将尝试预测属于糖尿病类别的观察值的概率。
我将首先演示最少量的探索性分析，然后跳转到机器学习模型(即回归和基于树的模型)，并比较和总结结果。
数据预处理和探索；
以下代码行加载数据并创建 dataframe 对象。将 Inferschema 设置为 true 可以很好地猜测每一列的数据类型。
#The Applied options are for CSV files
df = spark.read.format("csv") \
.option("inferSchema","true") \
.option("header","true") \
.option("sep",",") \
.load(file_location)
我还创建了一个字典来存储与数据类型相关的特性。在我们的例子中，我们有一个“整型”和“双精度型”。
from collections import defaultdictdata_types = defaultdict(list)
for entry in df.schema.fields:
data_types[str(entry.dataType)].append(entry.name)
查看列及其数据类型的代码输出
让我们看看数据集的前 5 行。
display(df.limit(5))
糖尿病数据集由 768 个数据点组成，每个数据点有 9 个特征:
“结果”是我们要预测的特征，其中 0 表示患者没有糖尿病，1 表示患者确实有糖尿病。在这 768 个数据点中，500 个标记为 0，268 个标记为 1。
display(df.groupby('Outcome').count())
使用 Databricks 的一个优点是，它有助于将查询可视化为一些基本的绘图选项，以便更好地理解数据和代码。
我们有一个完整的数据集，没有任何缺失值，但是要找到更多关于处理缺失数据的信息，您可以参考这篇文章:
https://www . analyticsvidhya . com/blog/tag/missing-values-treatment/
处理分类数据:
在我们的数据中，我们只有一个分类列，即超过 17 个类别的“怀孕”。下面的代码显示了如何将分类列/特征转换为一键编码。在 Spark 中，使用“字符串索引器”为每个类别分配一个唯一的整数值。0 被分配给最频繁的类别，1 被分配给下一个最频繁的类别，依此类推。
from pyspark.ml import Pipeline
from pyspark.ml.feature import OneHotEncoder, StringIndexerstage_string = [StringIndexer(inputCol= c, outputCol=
c+"_string_encoded") for c in strings_used]
stage_one_hot = [OneHotEncoder(inputCol= c+"_string_encoded",
outputCol= c+ "_one_hot") for c in strings_used]ppl = Pipeline(stages= stage_string + stage_one_hot)
df = ppl.fit(df).transform(df)
在上面的代码中，我使用了一个管道，它可以在一次迭代中有效地处理一系列任务。人们可以列出任务清单，管道会处理所有事情。
一般来说，机器学习管道描述了编写代码、将其发布到生产、进行数据提取、创建训练模型和调整算法的过程。在 ML 平台上工作是一个连续的过程。但是对于 Apache Spark 来说，管道是一个将步骤转换、评估和装配到一个对象中的对象。这些步骤被称为 ml 工作流。
向量汇编程序:
这里的想法是将一个给定的列列表组装成一个向量列，并将它们捆绑在一起。这是 Spark 的机器学习模型所需的额外步骤。这一步骤通常在数据探索和预处理步骤结束时执行。在这个阶段，我正在使用一些原始的和一些转换的特征来训练一个模型。
from pyspark.ml.feature import VectorAssemblerfeatures = ['Pregnancies_one_hot','Glucose','BloodPressure',
'SkinThickness','Insulin','BMI','DiabetesPedigreeFunction','Age']vector_assembler = VectorAssembler(inputCols = features,
outputCol= "features")
data_training_and_test = vector_assembler.transform(df)
模型拟合:
我们有几个内置的分类器，包括随机森林、提升树、逻辑回归等。首先，作为一个例子，我实现了 Random Forest，指定了分类器中树的数量，并将其余参数保留为默认值。
为了评估我们模型的性能，我使用 ROC 曲线度量。您可以选择自己喜欢的“metricName”。
该模型的准确率为 82.5%。这表明我们的模型在默认参数下运行良好。
from pyspark.ml.classification import RandomForestClassifier
from pyspark.ml.evaluation import BinaryClassificationEvaluator(training_data, test_data) = data_training_and_test.randomSplit([0.7, 0.3], 2017)
rf = RandomForestClassifier(labelCol = "Outcome",
featuresCol = "features", numTrees = 20)
rf_model = rf.fit(training_data)predictions = rf_model.transform(test_data)
evaluator= BinaryClassificationEvaluator(labelCol = "Outcome", rawPredictionCol="probability", metricName= "areaUnderROC")
accuracy = evaluator.evaluate(predictions)print("Accuracy:",accuracy*100)
功能选择:
特征选择过程有助于过滤掉不太重要的变量，从而得到更简单、更稳定的模型。在 Spark 中，实现特性选择不像在 Python 的 scikit-learn 中那样简单，但是可以通过将特性选择作为管道的一部分来管理。这个想法是:
- 首先安装分类器。例如，您可以选择回归模型或基于树的模型，任何您选择的模型。
- 如果使用随机森林，则查找要素重要性；如果使用逻辑回归，则查找系数。
- 将最重要的功能集存储在列表中。
- 从 ml 库中使用’ VectorSlicer '方法，并从刚才选择的列表中创建一个新的 vector。
下面的代码显示了如何从我们之前拟合的模型中创建一个重要特性的列表。大于 0.03 的特征被保留，rf_model 是拟合的随机森林模型。
importance_list = pd.Series(rf_model.featureImportances.values)
sorted_imp = importance_list.sort_values(ascending= False)
kept = list((sorted_imp[sorted_imp > 0.03]).index)
取 0.03 是随机的，可以基于 AUC 度量尝试不同的值。后来我用矢量切片器收集所有重要性大于 0.03 的特征。
from pyspark.ml.feature import VectorSlicer
vector_slicer = VectorSlicer(inputCol= "features",
indices= kept, outputCol= "feature_subset")
with_selected_feature = vector_slicer.transform(training_data)rf_modified = RandomForestClassifier(numTrees=20,
labelCol = "Outcome", featuresCol="feature_subset")
test_data = vector_slicer.transform(test_data)
prediction_modified = rf_modified.fit(with_selected_feature)
.transform(test_data)evaluator_modified = BinaryClassificationEvaluator(labelCol = "Outcome",rawPredictionCol="probability", metricName= "areaUnderROC")
accuracy = evaluator_modified.evaluate(prediction_modified)print("Accuracy: ",accuracy*100)
通过特征选择，我们看到准确率提高了 1%,总体准确率为 83%。从完整的特征集中，我们得到了 82%的准确率。在处理大数据时，即使 1%的改进也很重要。
最后，我只想说，Apache Spark 是一个简洁易用的开源框架。
感谢您抽出时间阅读！
我总是期待着学习和成长，如果您有任何问题或建议，请联系我！
领英|sagardaswani1703@gmail.com|Github
计算流体力学中的机器学习
我的暑期实习经历！
从我在日内瓦和平区坐过的桌子上看到的景色。图片鸣谢:Moi。
2018 年夏天，我获得了一个在瑞士日内瓦高等教育学院实习的绝佳机会。
我花了几乎三个月的时间用机器学习解决了一个问题，在我见过的最美丽的国家之一，遇到了这么多了不起的人。有什么不喜欢的，对吧？
该项目
顾名思义，该项目涉及用机器学习模型取代格子玻尔兹曼方法中的复杂计算，以提高名为 帕拉博斯—ParallelLatticeBoltzmannSolver 的模拟器的性能。
我在这里会完全诚实；当我在那里得知这个项目时，我有点不知所措。我没有物理学背景，对机器学习也相当陌生。我不认为我有足够的资格做这样的事情——冒名顶替综合征的可用性必须是 100%,似乎从不错过任何机会！无论如何，我决定全力以赴，看看我能走多远，因为这是我们学习的方式。
背景
格子 Boltzmann 方法(LBM)是计算流体动力学(CFD)中模拟单相和多相流体流动的并行算法。它有助于模拟复杂的边界条件和多相界面。
它将流体建模为虚拟粒子，这些粒子在离散网格上执行连续的碰撞和流动步骤。常用的点阵命名为 *DnQm，*这意味着点阵具有 n 的空间维度和 m 的离散速度。在每个时间步中，任何节点上的粒子只能以一种离散速度移动到它们最近的相邻位置。一旦粒子移动到它们相邻的位置之一，它们将与同时到达同一位置的其他粒子发生碰撞。
LBM 的粒子运动。来源。
在直接数值模拟中——计算流体动力学中的一种模拟——在没有任何湍流模型的情况下数值求解纳维尔-斯托克斯方程。
大涡模拟(LES)是计算流体力学中用于模拟湍流的数学模型。计算域的大小应至少比表征湍流能量的尺度高一个数量级，同时计算网格应足够精细，以解决最小的动态有效长度尺度，从而进行精确模拟。
如果通过使用非常精细的网格直接求解纳维尔-斯托克斯方程来精确地解决所有的涡流(网格应该比最小的湍流涡流更精细，湍流涡流本质上是水的环流),则会导致很高的计算成本。为了克服这些计算成本，在 LES 中，仅直接计算大尺度运动(大涡流)，而小尺度(亚网格尺度(SGS))运动被建模。
最后，LBM 告诉我们，我们可以将流体想象为空间和时间中的虚拟粒子，DNS 告诉我们如何模拟每个粒子的行为——给定系统的物理条件——在每个时间步长，les 通过近似亚网格尺度的涡流，使得在尺度范围变化很大时对湍流做这些事情成为可能。
我花了大约两周的时间学习它背后的物理学，设置我的系统(最初默认语言为法语)，获得 IDE——使用一个名为 Qt 的 IDE，浏览软件代码以了解更高层次上发生的事情。
问题陈述
使用机器学习来学习大涡模拟中亚网格尺度(SGS)运动的模型，并将其与现有模拟器集成，以取代当前的亚网格计算。
- 使用的语言:C++，因为它很快。
- 该模型需要体积小、速度快，以便可以轻松部署，而不会增加内存负载或延迟模拟。
- 建议不要使用外部框架，如 TensorFlow 或 PyTorch。
解决办法
解决一个大而复杂的问题的最好方法是把它分解成更小更简单的问题。我做了同样的事情，把我的问题分成以下三个问题:
- 设计一个简单的结构来模拟亚网格尺度的运动。
- 根据时间和其他约束来训练和优化模型。
- 将模型与现有软件集成。
子问题#1 -模型架构和训练数据:
训练数据有九个输入属性:
1:密度
2–3:速度
4–6:应力
7:涡度
8–9:密度梯度
输出有 3 个代表残余应力张量的属性。它有大约一百万个字节组。
该架构的目标是在不牺牲性能的情况下尽可能保持简单。我决定使用最简单的神经网络，称为感知器模型。它由输入层、输出层和隐藏层组成。
在神经网络模型的输入层之前添加了一个缩放层，以便在将训练数据输入模型之前对其进行标准化。由于预测输出是一个回归问题，因此在预测新的未知数据的值时，在输出层之后添加了一个未缩放层。
下一个任务是找到模型中每一层的尺寸。输出层有 3 个节点，每个节点对应于训练数据输出部分的一个属性。
我将输入节点的数量保持为 9，并开始研究隐藏节点的数量，以找到隐藏层的最佳大小，同时跟踪平均平方误差和测试所需的时间。我从极端情况开始，保持隐藏节点的数量非常低和非常高——保持学习速率、时期数和其他变量不变——然后通过遵循非常类似于二分搜索法的方法缩小范围。然后我发现中值也是如此，然后是(低，中)和(中，高)的中值，这两个中误差较小的一个成为我们新的搜索空间。
一旦决定了隐藏节点的最佳数量，我还会考虑模型的输入数量。令人惊讶的是，如果我将输入减少到 6，结果并没有大幅下降。因此，如果需要进一步缩小模型尺寸，我也有这个选择。几年后，我了解到这就是所谓的“消融研究”，即移除模型的特征并评估其对输出的影响，这是一个值得遵循的良好实践。
以上所有工作都是在原始训练数据的子集上完成的，以确保项目的顺利进行。
在这一部分，我花了大约两周的时间，熟悉了 OpenNN 库，编写了模型代码，并对数据集进行了试验，以获得上述值。
子问题#2 -训练模型:
一旦我们的模型架构最终确定，我发现自己在寻找数据集子集上给定架构的最佳学习率。同样，我遵循了一个非常类似于二分搜索法的策略——从极端开始，然后从那里缩小范围。我使用了拟牛顿法进行权重优化，这可以在 C++的 OpenNN 库中找到。
一旦这样做了，我就开始学习上面练习中发现的三个最小的错误。然后，对于每个学习率，我在整个数据集上训练模型。我重复了五次，最终选择了在这五次运行中表现最好的学习率。
这是一个缓慢的过程，因为每次训练大约需要一天的 0.5-0.75 分钟。我在这上面花了大约三个星期。
子问题#3 -与 Palabos 集成:
第一件事是在没有任何 IDE 的情况下运行代码；我更新了所需包的路径，并链接了所需的库。
一旦完成，模型被调用，而不是模拟亚网格尺度漩涡的函数。我们尝试在几个场景下运行该模块，并将性能与我们从模拟漩涡中获得的结果进行比较。
总体体验
我在实习期间过得很愉快。做这个项目我学到了很多；比如如何解决一个大问题，为给定问题开发人工智能解决方案的方法，等等。
外卖:
——如果现在让我再做一次，我还会以同样的方式做事吗？大部分，是的。但是我会更加重视项目的测试和验证方面。如果我有更多的时间，我可能也会这样做，但如果我现在这样做，我会确保在计划期间专门为此分配一些时间——包括整合之前和之后。
-我意识到我喜欢使用 ML，并将其应用于新问题或改进现有解决方案。所以，是的，我现在正在寻找更经常地做这件事的方法——人工智能/人工智能的新应用！有一个好的导师会有很大的不同。我是唯一参与这个项目的人。但是我的导师真的很有帮助。他会听我说些什么，然后指导我。我完全可以控制我想如何做这个项目，但同时我总是让他指导我。我想这就是这次经历如此充实和令人满意的原因。
我也遇到了一些非常善良和了不起的人，他们现在仍然是我的朋友。谢谢你 2018 年夏天给了我难忘的美好经历。❤
参考资料和更多信息
我认为你会喜欢:D 的其他文章
我很高兴你坚持到了这篇文章的结尾。🎉我希望你的阅读体验和我写这篇文章时一样丰富。💖
请点击这里查看我的其他文章。
如果你想联系我，我会选择 Twitter。
优惠券推荐中的机器学习
演职员表:模拟世界
多臂强盗如何帮助星巴克向顾客发送个性化的优惠。
你多久会等一次优惠券来购买一件商品？在一些无趣的交易之后，你是否想放弃使用这项服务？
优惠券系统已被广泛用于提高消费者对基于数字的平台的参与度。通过向用户提供挑战和相应的奖励，公司的服务不仅变得更有吸引力，而且最重要的是，它可以使用户成为常客，从而增强品牌对其客户的影响。然而，知道提供哪种优惠券可能是一项相当复杂的任务，因为每个客户对每个优惠的反应都不同，经常向他们提供糟糕的交易可能会将他们从您的业务中拖走。
为了克服这个问题，可以使用机器学习技术来建立数据驱动的客户档案，并开发更好的优惠券推荐。就此而言，这篇文章展示了如何在星巴克移动奖励应用程序中使用 K-Means 聚类结合多臂强盗来构建优惠券推荐系统。
这篇文章是提交给 Udacity 的机器学习工程师 Nanodegree 的 capstone 项目的结果，其源代码可以在这个资源库中找到。有关更多技术信息，如参数扫描和数据集预处理，请参考关于存储库的详细报告。
所以事不宜迟，言归正传！
学分:免费
星巴克奖励手机 App
每隔一天，星巴克都会向用户发送可过期的优惠，这些优惠有自己的难度和过期日期。每个报价可以通过多种营销渠道(电子邮件、手机、社交媒体和网页)发送，一旦完成报价挑战，他们将获得与难度级别一样高的奖励金额。
当用户查看优惠时，他们可以决定:
- 完成挑战:)
- 忽略挑战，但仍然在没有优惠券的情况下进行购买:|
- 忽略一切:(
以下是几周以来 app 营销漏斗中流量的一瞥:
星巴克奖励应用中顾客流的桑基图(图片由作者提供)。
发送报价后，我们有兴趣根据每个营销渠道进行分析:
- 该要约未被转换；
- 这变成了购买；
- 这导致了未来的购买
- 这些都被忽略了，但用户仍然从应用程序中购买。
在样本数据集中，100%的报价都被浏览过——很可能是因为报价是通过多种渠道发送的。高比例的浏览报价带来了一个积极的特点，即让顾客了解品牌和他们提议的报价。当这些建议导致购买行为时，可以推断出顾客不仅知道该品牌的服务，而且也被它所吸引。
然而，相当多的购买是在没有使用优惠券的情况下进行的。这表明即使使用了适当的营销渠道，奖励提议对用户也没有吸引力，这更多地涉及产品的特性而不是营销策略本身。也许通过使用相同的渠道改变发送的报价(这将是我们的推荐系统的任务)，客户将接受报价并因此获得奖励。
在漏斗的末端，要约提议可以实现的最重要的任务之一是说服客户进行未来购买。这可以作为一种代理，吸引客户成为品牌的拥护者[2]。
当客户倾向于重复购买某个公司的产品时，他/她可能会说服他们的同行尝试某个产品，从而在市场上产生更多的品牌认知度和吸引力。
请注意，这是移动奖励应用程序的一个相当大的缺陷，因为只有来自 111k 的 22.9k 才会导致未来的购买。
请记住，在发送要约后，用户参与漏斗的各个步骤所需的时间与销售线索状态高度相关。**销售线索是潜在买家，其状态可以是冷淡、热情或合格[3]。**用户一看到报价，就可能被认为是潜在客户，因为他对此感兴趣。
例如，当客户打开电子邮件报价时，他可能会被其标题内容所吸引——因此我们认为他是在为热身**。然而，如果他/她不继续接受这份工作，他会变得越来越冷淡，这意味着他对接受这份工作的兴趣会逐渐减少。**
理想情况下，用户应该花很短的时间从查看和提供并完成它。这是我们数据集的运行时间分布:
从(a)发送和提供到观看它和(b)观看和提供并完成它(作者的图像)的时间推移分发。
请注意从查看要约到完成要约的时间分布(以小时计)大致遵循长尾分布。这意味着大多数购买来自于迅速完成的报价。为了分析分布的尾部有多长，我们可以将数据拟合到一个幂律分布，其概率分布函数定义如下
其中参数 α 越低，尾巴越长。对于我们的数据集，在第一个时间间隔中α = 10.57，在第二个时间间隔中α = 7.01。自然地，这些经过的时间很大程度上受要约的属性影响，如难度和持续时间，这只会影响用户查看要约时的延时——因此解释了为什么我们在延时中有更长的尾巴(b)。
这个营销方面的概述帮助我们创建一个定制函数，该函数指示给定客户的报价有多合适:我们将把它称为 MAB 奖励函数 ，其算法描述如下。
(图片由作者提供)
多股武装匪徒(MAB)
MAB 算法在统计学中已经被广泛研究了一段时间，用来解决老虎机问题。想象一下，你有一个代理人(强盗),他可以重复地从 k 台可用的机器中拉出一只手臂，并可能从中获得奖励。
当强盗与吃角子老虎机互动时，他注意到其中一个似乎给了更多的奖励，因此很想利用这个杠杆。然而，其他机器可能会给予更多奖励。在这种情况下，他需要决定是否
- 利用一台迄今为止累计回报最高的机器，或者
- 探索其他机器，从长远来看，它们可能会带来更好的累积回报。
理论上，代理人是在试图估计每台机器的报酬概率分布函数，而不是在那些期望报酬低的人身上浪费太多的尝试。
在其最简单的数学公式中，MAB 由 k 个机器组成，它们有自己的概率分布 p 、预期回报μ和方差σ——所有这些对代理人来说最初都是未知的。在每个时期T∈【1，T 】一个手臂 a_i 被拉动，并且获得奖励。然后，强盗遵循一个策略来选择下一条手臂:到目前为止给出最高回报的手臂或者另一条可能带来更好回报的手臂。第轮 T 的最高收益由下式给出
其中μ*是最佳臂的预期回报。换句话说，他需要做出开采-勘探权衡的决策。
已经采用了几种技术来解决这个问题，其中之一是ϵ-greedy 方法[1]。在这个经典的方法中，每一轮强盗选择概率为 1 的具有最高经验平均值的手臂——ϵ，或者选择概率为ϵ.的随机手臂
可以推断，ϵ参数对开采-勘探权衡有很大影响。对于更高的ϵ，选择最高经验均值臂的贪婪行为被选中的概率更低，从而导致土匪探索更多的选项。相反，在ϵ较低的情况下，算法倾向于选择贪婪动作。
ϵ-greedy 是无数算法的基础。为了在最初的几轮中有更多的勘探和在以后的几轮中有更多的开发，可以用衰减ϵ-greedy 方法应用一个轮变β。在这种情况下，第 n 轮的ϵ定义为
其中β控制ϵ减少的速度， n 是当前回合。此外，可以定义阈值λ，以便在后面的回合中限制最小探索。
MAB 算法已经在许多需要进行顺序决策的应用中使用，例如推荐系统。在这种情况下，MAB 被用于建模消费简档，考虑向用户(代理)提供若干项目(老虎机),并且他们可以根据奖励概率分布函数来消费它。
对于当前的 Starbucks 奖励项目，它们将用于建立客户档案模型，将每只手臂视为一个要约和一个定制的奖励函数，该函数定义为掌握获得的优惠券奖励和营销成就，这将在后面看到。
在星巴克的奖励应用中应用 MAB
将 MAB 应用于一个问题的一个关键步骤是定义它的回报函数。正如我们所见，客户进入营销漏斗的深度在很大程度上表明了优惠策略的好坏。在这个意义上，可以使用下面的奖励函数:
其中所有变量都是二进制的，除了提供奖励。该等式的下限为 0，这发生在要约未被查看时(使得 offerCompleted = 0 和 futurePurchase = 0 )。当给出一个高报价奖励，并且所有的二元变量都是 1，包括未来的购买，这是营销策略的圣杯时，最好的奖励就来了。
一旦我们建立了这个功能，我们就可以考虑以下变量来创建数据驱动的客户档案:
- 年龄，收入
- 订阅后的年数
- 每种产品的平均mab 奖励
在对用户进行聚类之后，每一组都被建模为一个 MAB，有要约作为可拉的手臂。下图描绘了 MAB 训练的 20 个实现的平均回报演变(所有参数决策在项目报告中讨论，此处):
ϵ-greedy 衰减表示 20 次实现的平均奖励(图片由作者提供)。
注意平均报酬是如何上升的，直到一个收敛区域。这是勘探-开采权衡变化的结果:开始时，我们尽可能多地勘探，以便找到更好的武器。随着时代的推移，利用最好的武器变得更加频繁，直到没有观察到平均奖励的显著提高。
最后，用户群可以被预测，他们的报价推荐可以通过 MAB 的帮助来完成。由于每次迭代只能拉动一只手臂，自然会出现对产品多样性的关注。那么，在培训阶段选择报价的频率如何呢？我们用下图来核对一下:
按类别选择的武器数量(图片由作者提供)。
可以看出，10 个选项中有 3 个被大多数集群高度选中，这意味着，一般来说，30%的产品组合是被推荐的。这个数字受 MAB 收敛后勘探速度的影响很大。当探索度较低时，该模型倾向于仅推荐已经显示提供最高回报的报价。更高的探索可以为该推荐器带来更好的多样性，然而这可能在使用预测方面影响模型的性能。
包扎
我们已经看到优惠券如何成为一种强大的参与工具，让用户更接近公司的服务。通过瞄准正确的线索和客户，不仅可以提高转化率，而且最重要的是，可以与他们建立长期关系。然而，制定成功的目标战略可能需要建立数据驱动的客户档案。这就是公司依靠机器学习的力量来提供个性化建议的地方。
在无数的推荐算法中，多臂强盗因其使用手工制作的奖励函数的灵活性而被广泛探索，例如我们用于 graps 营销方面的函数。如果你想深入研究一种更强大的 MAB 方法，我强烈推荐阅读 Spotify 研究人员开发的关于 BaRT(作为治疗方法的替代物)[4]的文章。
[1]萨顿，理查德 s 和巴尔托，安德鲁 G. 强化学习:导论 (2018)，麻省理工学院出版社。
[2] P. Kotler，H. Kartajaya 和 I. Setiawan，营销 4.0:从传统走向数字 (2016)
【3】冷、暖、合格引线的区别
[4] J. McInerney，B. Lacker，S. Hansen，K. Higley，H. Bouchard，A. Gruson，R. Mehrotra。探索、利用和解释:用强盗个性化可解释的推荐 (2018)，ACM 推荐系统会议(RecSys) 。
数据科学面试中的机器学习
5 个需要研究的挑战性问题和主题
凯文·Ku 在 Unsplash 上的图片
概观
机器学习问题通常是数据科学面试中最难的部分，这是有充分理由的。这篇文章将强调几个示例问题，对机器学习的一般评论，以及在理论和应用方面需要研究的主题。讨论的问题来自 https://datascienceprep.com/的，涵盖了顶级科技公司的面试问题。
5 个挑战性问题
- 假设我们使用高斯混合模型(GMM)对欺诈性交易进行异常检测，将传入的交易分为 K 类。用公式描述模型设置，以及如何评估后验概率和对数似然。我们如何确定一项新交易是否应被视为欺诈？
- 假设您正在对具有 K 个类的一些数据运行线性判别分析(LDA)模型。从数学上描述你如何将形心投影到 L < K-1 维的子空间。
- 描述核平滑的思想和数学公式。如何计算核回归估计量？
- 假设我们正在运行概率线性回归，它很好地模拟了一些 y 和 x 之间的潜在关系。现在假设所有输入都添加了一些噪声ε，这与训练数据无关。新的目标函数是什么？你是怎么计算的？
- k-means 聚类中对于 k 个聚类和 n 个样本点使用的损失函数是什么？使用 1)批量梯度下降，2)使用学习率ε对聚类 k 的聚类均值进行随机梯度下降来计算更新公式。
一般评论
机器学习并不适用于每个数据科学角色，因为数据科学是一个广阔的领域，但对于相关角色来说，它是一个既有深度又有广度的重要研究领域。然而，无论角色如何，我认为对任何数据科学家或有抱负的数据科学家来说，研究机器学习都是有用的，原因有三:
- 它是数学、计算机科学和统计学的交叉，每一个都是一个丰富的研究领域，是一生坚实知识的基石。
- 机器学习提供了理论和应用的完美结合——有无数的事情值得好奇，也有事物如何在实践中运行和使用。
- 正如软件已经颠覆了世界范围内的商业格局一样，机器学习已经颠覆了，并将继续帮助现有的企业取得巨大的进步，并带来一系列令人惊叹的未来企业。
研究机器学习
有两个与机器学习相关的主要关注领域:理论和应用。理论需要模型背后的所有数学基础，以及它们为什么以及如何以这种方式工作，而应用需要所有真实世界的用例，从而大规模技术可以利用这种模型。学习和精通这两者同样重要。
理论上，有大量的教科书和其他在线资源可供你使用。有必要理解各种算法和框架背后的数学，以便了解模型如何调整和运行背后的模式。这样做将导致对应用程序的更好理解，并且熟悉如何考虑对各种模型的不同适应。此外，熟悉所有技术细节肯定有助于机器学习面试问题的理论方面。
对于应用程序，假设您可以获得足够的感兴趣的数据(Kaggle 和 Open AWS 提供了许多数据集),则有无数的实际项目可以研究！)——如果不可行，也值得了解一下有多少公司大量利用机器学习(例如，阅读关于网飞使用推荐系统的文章)。这将加强你的理论理解，并提供对一些世界顶级企业如何使用机器学习来大规模产生大量价值的见解。
要研究的主题
下面的列表并不详尽，但包含了从鸟瞰的角度来看什么是好的话题的想法:
- 对模型的一般理解:偏差-方差权衡，评估模型拟合，抽样，交叉验证等。
- 线性模型:回归(简单和多重)，模型选择，收缩方法
- 分类:线性方法(LDA，逻辑回归等。)和非线性(支持向量机、决策树等。)
- 神经网络:反向传播，CNN，RNNs，LSTMs 等。
- 无监督学习:聚类(K-means)、PCA、因子分析等。
当学习每一种方法时，一定要沉浸在事物的应用方面——有许多真正有趣的公司在他们业务的核心部分使用上述各种方法。例如:许多企业利用欺诈检测—在那里可以运行和使用哪些模型？推荐引擎呢？投放广告？客户终身价值分析？
注意:还有很多其他领域(强化学习，计算机视觉，博弈论话题等。)为了简洁起见，在上面的列表中省略了它们。
感谢阅读！
如果你有兴趣在数据科学采访中进一步探索机器学习，请查看这个发给你练习问题的时事通讯。
医疗保健中的机器学习:检测黑色素瘤
通过应用若干机器学习算法，使用患者的诊断报告和皮肤病变图像来检测病变是癌性的还是非癌性的。
皮肤癌是最常见的癌症。它的发生是由于皮肤细胞的异常生长，通常是在暴露于阳光的区域。有三种主要类型的皮肤癌——基底细胞癌、鳞状细胞癌和黑色素瘤。特别是黑色素瘤，尽管它是最不常见的皮肤癌，但却造成了 75%的皮肤癌死亡。
黑色素瘤是一种致命的疾病，但如果早期发现，大多数黑色素瘤可以通过小手术治愈。
在本文中，我们将通过应用几种机器学习算法将病变分类为良性或恶性，从患者的诊断记录和皮肤病变的图像中识别黑色素瘤。更好地检测黑色素瘤有机会对数百万人产生积极影响。
注意:下面的代码是使用 Kaggle 提供的数据集 SIIM-ISIC 黑色素瘤分类 在 Kaggle 内核上实现的。你可以在这里找到完整的代码。
我们将遵循以下步骤来实现该算法。
导入库
让我们通过在 Kaggle 内核中导入所需的库来开始实现，如下所示:
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import cv2
import pydicom as dicom
import pandas as pd
import numpy as np
from sklearn.metrics import accuracy_score, confusion_matrix
from sklearn.metrics import mean_squared_error, r2_score
导入的 pydicom 库用于处理数据集中提供的图像。这些图像属于 DICOM(医学数字成像和通信)类型，这是传输、存储、检索、打印、处理和显示医学成像信息的国际标准。
分析数据集
下一步是导入 Kaggle 提供的数据集 SIIM-ISIC 黑色素瘤分类 。
df = pd.read_csv('/kaggle/input/siim-isic-melanoma-classification/train.csv')
df.head()
SIIM-ISIC 黑色素瘤分类数据集
从上面给出的数据集，我们可以推断黑色素瘤的分类取决于两件事，即患者的详细信息和患者皮肤损伤的图像。整个过程解释如下。
我们获取患者的详细信息和皮肤病变图像，然后应用机器学习算法来检测此人是否患有癌症。
图像分类
让我们从检测数据集中提供的图像中存在的黑色素瘤开始。
黑色素瘤迹象包括:
- 带有深色斑点的褐色大斑点
- 颜色、大小或感觉改变或出血的痣
- 边缘不规则的小病灶，部分呈现红色、粉色、白色、蓝色或蓝黑色
- 发痒或灼烧的疼痛损伤
- 手掌、脚底、指尖或脚趾，或口腔、鼻子、阴道或肛门粘膜上的黑色病变
使用这些迹象，机器学习算法将皮肤损伤分类为良性或恶性。
让我们从从整个数据集中抽取一小部分数据样本来开始实现。
s0 = df.target[df.target.eq(0)].sample(50).index
s1 = df.target[df.target.eq(1)].sample(60).indexdf = df.loc[s0.union(s1)]
df['target'].value_counts()
这是我们新生成的数据集，我们将使用它来训练我们的机器学习模型。
现在让我们来看看这些图片。这些图像以 DICOM 格式呈现，因此我们使用由 pydicom 库提供的 dicom.dcmread() 函数来读取图像。
image = '/kaggle/input/siim-isic-melanoma-classification/train/' + df['image_name'][1512] +'.dcm'ds = dicom.dcmread(image)plt.imshow(ds.pixel_array)
显示恶性和良性癌症区别的图片
下一步是训练我们的机器学习模型。为了做到这一点，图像应该首先以模型能够理解的格式表示。为此，我们需要将图像转换成像素格式。
因此，对于数据集中的每个图像，我们使用 dicom.dmread() 读取图像，并使用 ds.pixel_array 提取像素。这些像素是多维的，因此我们使用 flatten 函数将其转换为一维数组。然后，我们将这些像素格式的图像添加到一个名为 images 的列表中。
images = []for x in df['image_name']:
image = '/kaggle/input/siim-isic-melanoma-classification/train/' + x +'.dcm'
ds = dicom.dcmread(image)
pixels = ds.pixel_array
images.append(pixels.flatten())
使用像素表示图像
现在，出现的问题是每个图像都有不同数量的像素，因此生成的数组具有不均匀的长度。为了解决这个问题，我们使用填充技术，要么向数组添加额外的值，要么丢弃某些值，以使数组的长度等于指定的最大长度。
import tensorflow as tf
images = tf.keras.preprocessing.sequence.pad_sequences(
images,
maxlen = 720,
dtype = "int32",
padding = "pre",
truncating = "pre",
value = 0
)
我们还需要一个包含图像的测试数据集来测试我们的模型。我们可以如下生成测试数据集。
test = df.tail(50)
test.head()
测试数据集
一旦我们准备好数据集，我们就重复上面显示的过程。也就是说，我们首先将图像转换为其像素格式，然后应用填充技术，使图像具有相同数量的像素。
test_images = []
count = 0for x in test['image_name']:
image = '/kaggle/input/siim-isic-melanoma-classification/train/' + x +'.dcm'
ds = dicom.dcmread(image)
pixels = ds.pixel_array
test_images.append(pixels.flatten())
count +=1
print(count)test_images = tf.keras.preprocessing.sequence.pad_sequences(
test_images,
maxlen = 720,
dtype = "int32",
padding = "pre",
truncating = "pre",
value = 0
)
最后，是时候训练我们的模型了。
我们将使用几种机器学习算法来训练我们的模型，然后测试它以查看准确性得分。
我们将设置的值
X =图像(包含像素格式图像的列表)
y = NP . array(df[’ target '])(表示图像中的病变是良性还是恶性的值)
1。逻辑回归
from sklearn.linear_model import LogisticRegressionX = images
y = np.array(df['target'])
classifier_lr = LogisticRegression()
classifier_lr.fit(X,y)X_test = test_images
y_test = np.array(test['target'])
y_pred_lr = classifier_lr.predict(X_test)print('Accuracy Score: ',accuracy_score(y_test,y_pred_lr))
print('Confusion Matrix: \n',confusion_matrix(y_test,y_pred_lr))
逻辑回归算法给出的精确度
2。支持向量机
from sklearn import svm
X = images
y = np.array(df['target'])
classifier_svm = svm.SVC()
classifier_svm.fit(X,y)X_test = test_images
y_test = np.array(test['target'])
y_pred_svm = classifier_svm.predict(X_test)print('Accuracy Score: ',accuracy_score(y_test,y_pred_svm))
print('Confusion Matrix: \n',confusion_matrix(y_test,y_pred_svm))
支持向量机算法给出的精度
3。决策树
from sklearn.tree import DecisionTreeClassifier
X = images
y = np.array(df['target'])
classifier_dt = DecisionTreeClassifier()
classifier_dt.fit(X,y)X_test = test_images
y_test = np.array(test['target'])
y_pred_dt = classifier_dt.predict(X_test)print('Accuracy Score: ',accuracy_score(y_test,y_pred_dt))
print('Confusion Matrix: \n',confusion_matrix(y_test,y_pred_dt))
决策树算法给出的精确度
4。随机森林
from sklearn.ensemble import RandomForestClassifier
X = images
y = np.array(df['target'])
classifier_rf = RandomForestClassifier()
classifier_rf.fit(X,y)X_test = test_images
y_test = np.array(test['target'])
y_pred_rf = classifier_rf.predict(X_test)print('Accuracy Score: ',accuracy_score(y_test,y_pred_rf))
print('Confusion Matrix: \n',confusion_matrix(y_test,y_pred_rf))
随机森林算法给出的精确度
5。自适应增压
from sklearn.ensemble import AdaBoostClassifier
X = images
y = np.array(df['target'])
classifier_ab = AdaBoostClassifier()
classifier_ab.fit(X,y)X_test = test_images
y_test = np.array(test['target'])
y_pred_ab = classifier_ab.predict(X_test)print('Accuracy Score: ',accuracy_score(y_test,y_pred_ab))
print('Confusion Matrix: \n',confusion_matrix(y_test,y_pred_ab))
自适应升压算法给出的精度
6。梯度增强
from sklearn.ensemble import GradientBoostingClassifier
X = images
y = np.array(df['target'])
classifier_gb = GradientBoostingClassifier()
classifier_gb.fit(X,y)X_test = test_images
y_test = np.array(test['target'])
y_pred_gb = classifier_gb.predict(X_test)print('Accuracy Score: ',accuracy_score(y_test,y_pred_gb))
print('Confusion Matrix: \n',confusion_matrix(y_test,y_pred_gb))
由梯度推进算法给出的精度
在使用几种机器学习算法对图像进行训练和测试后，我们得到了不同的准确度。有些算法会使数据过拟合，而有些算法会使数据欠拟合。因此，我们继续使用逻辑回归算法，因为它既不过度拟合也不欠拟合数据，给出 96%的准确度。
显示使用机器学习算法获得的精确度的条形图
使用病历进行分类
为了方便起见，我们先将*“anatom _ site _ general _ challenge”重命名为“site”*。
df = df.rename(columns = {'anatom_site_general_challenge':'site'})
为了开始数据的训练，我们首先需要理解数据。让我们应用一些可视化和数据清理技术来更好地解释我们的数据。
首先，让我们使用以下代码删除数据集中所有缺失的值
df = df.dropna(axis=0, how = 'any')
考虑到 age_approx 并作为一个因素，我们可以使用下面的代码来创建如下所示的图表。
age = []
for i in range(df.shape[0]):
try:
if df['target'][i] == 1:
age.append(df['age_approx'][i])
except:
passplt.figure(figsize=(15,5))plt.subplot(1,2,1)
sns.distplot(age)
plt.title('Distribution of age of people having malignant cancer')plt.subplot(1,2,2)
sns.countplot(y = age)
plt.ylabel('Age')
plt.title('Count plot of age of people having malignant cancer')
使用 age_approx 作为因子创建的图表
从上面的图表中可以推断出以下几点:
- 大多数恶性肿瘤患者的年龄在 40 至 80 岁之间
- 年龄值大于 60 岁的癌症患者人数最多，其次是年龄值在 55 至 60 岁之间的人。
- 患有癌症且年龄值低于 10 岁的患者数量非常少。
考虑到站点，作为一个因素，我们可以使用下面的代码来创建下图。
site = []
for i in range(df.shape[0]):
try:
if df['target'][i] == 1:
site.append(df['site'][i])
except:
passsns.countplot(y = site)sns.countplot(y = site,palette="rocket")
plt.title('Graph showing count of patients having cancer and the site it is located in')
plt.ylabel('Site')
使用站点作为因素创建的图表
从上面的图表中可以推断出以下几点:
- 大多数病人的躯干都有皮肤损伤
- 极少数患者的手掌/溃疡或口腔/生殖器部位出现皮肤损伤。
如您所见，属性性别、位置和诊断包含分类数据。因此，我们使用 pandas.get_dummies() 将分类数据转换为模型可以理解的虚拟变量或指示变量。
我们还删除了不需要的列，良性 _ 恶性和患者 id 。
这可以通过以下方式完成:
df = pd.get_dummies(df, columns = ['sex'],drop_first=True)df = pd.get_dummies(df, columns = ['site'],drop_first=True)df = pd.get_dummies(df, columns = ['diagnosis'],drop_first=True)
df = df.drop('diagnosis_unknown', axis = 1)df = df.drop(['benign_malignant', 'patient_id'], axis = 1)
df.head()
我们的数据集现在包含 16 个属性。下一步是选择正确的属性来训练我们的模型。我们可以通过找出属性和目标之间的相关性来做到这一点。为此，让我们使用以下代码生成一个热图:
plt.figure(figsize = (10,10))
sns.heatmap(df.corr()[['target']].sort_values('target').tail(16), annot = True)
显示属性和目标之间相关性的热图
从上面的热图可以推断出以下几点:
- 诊断 _ 黑色素瘤与目标值直接相关。因此，如果一个人被诊断患有黑色素瘤，他就患有癌症，如果一个人没有被诊断患有黑色素瘤，他就没有癌症。
- 年龄 _ 近似值、性别 _ 男性和部位 _ 上肢与目标正相关。
- 诊断痣、部位下肢和部位躯干与目标呈负相关。
这也可以从下图中得到解释。
显示属性和目标之间相关性的图形
现在让我们训练我们的机器学习模型。我们将使用几种机器学习算法来训练我们的模型，然后测试它以查看准确性得分。
我们首先创建训练和测试数据集。
X = df[['diagnosis_melanoma','site_torso','diagnosis_nevus','site_lower extremity','site_upper extremity', 'sex_male', 'age_approx']]y = df['target']from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.3, random_state = 1)
现在，我们需要应用分类算法，该算法采用这些属性并根据目标值训练模型。这可以通过使用上面使用的相同算法和程序来训练具有皮肤损伤图像的模型来完成。
在成功训练算法之后，我们获得以下准确度分数:
正如你所看到的，支持向量机算法没有过度拟合数据，并给出了 98%的准确率，我们选择它进行进一步处理。
我们选择了逻辑回归算法来从图像中预测癌症，我们选择了支持向量机来基于患者的医疗细节和诊断来预测癌症。
在我们的下一步也是最后一步，我们测试患者的全部记录，并检测他或她是否患有癌症。
患者记录如下:
image_name = ISIC_0149568
年龄 _ 大约= 55 岁
sex_male = 0
站点 _ 下肢= 0
site_torso = 0
场地 _ 上肢= 1
诊断 _ 黑色素瘤= 1
诊断 _ 痣= 0
image_path = '/kaggle/input/siim-isic-melanoma-classification/train/ISIC_0149568.dcm'
details = [[55,0,0,0,1,1,0]]
image_to_test = []
ds = dicom.dcmread(image_path)
pixels = ds.pixel_array
plt.imshow(pixels)
image_to_test.append(pixels.flatten())image_to_test = tf.keras.preprocessing.sequence.pad_sequences(
image_to_test,
maxlen = 720,
dtype = "int32",
padding = "pre",
truncating = "pre",
value = 0
)print(train2.predict(image_to_test))if train1.predict(details) == [1]:
result1 = 'Malignant'
else:
result1 = 'Benign'if train2.predict(image_to_test) == [1]:
result2 = 'Malignant'
else:
result2 = 'Benign'print('Result from patient details: ', result1)
print('Result from patient image: ', result2)
图像路径存储图像名称的路径
详细信息存储患者记录的详细信息
训练 1 是使用患者记录训练的模型。
train2 是使用患者皮肤病变图像训练的模型。
执行代码后，我们得到如下结果:
最终测试后的输出
正如你所看到的，算法正确地检测出病人患有癌症。因此，我们可以推断，机器学习算法可以有效地用于医疗保健和医疗领域。
如果你想知道如何使用神经网络而不是机器学习算法对图像进行分类点击这里。
参考
识别病变图像中的黑色素瘤
www.kaggle.com](https://www.kaggle.com/c/siim-isic-melanoma-classification/overview) [## 皮肤癌——症状和原因
皮肤癌——皮肤细胞的异常生长——通常发生在暴露在阳光下的皮肤上。但是这种常见的形式…
www.mayoclinic.org](https://www.mayoclinic.org/diseases-conditions/skin-cancer/symptoms-causes/syc-20377605)
Java 中的机器学习
如何在 Java 中构建和部署 ML 模型？
迈克·肯尼利在 Unsplash 上的照片
机器学习(ML)已经在学术界和工业界的不同领域获得了重大承诺。随着时间的推移，ML 在图像、语音识别、模式识别、优化、自然语言处理和推荐等众多应用领域的参与度不断提高。
给计算机编程以从经验中学习，最终将消除对这种细致编程工作的需求。阿瑟·塞缪尔 1959 年。
机器学习可以分为四种主要技术:回归、分类、聚类和强化学习。这些技术主要以两种形式解决不同性质的问题:监督学习和非监督学习。监督学习要求在训练模型之前对数据进行标记和准备。无监督学习可以方便地处理未标记的数据或具有未知特征的数据。本文不描述 ML 的概念，也不深入描述这个领域中使用的术语。如果你是全新的，请看看我以前的文章开始你的 ML 学习之旅。
Java 中的机器学习库
这里是一个众所周知的用于 ML 的 Java 库的列表。我们将逐一描述它们，并给出使用其中一些框架的真实例子。
在每个库的旁边，下面的图标将指示每个框架中默认提供的算法的主要类别。
新西兰黑秧鸡
Weka GUI 工具包的截图。
Weka 是由新西兰怀卡托大学开发的开源图书馆。Weka 是用 Java 编写的，对于通用机器学习来说非常有名。Weka 提供了一种数据文件格式，称为 ARFF。ARFF 分为两部分:报头和实际数据。标题描述了属性及其数据类型。
阿帕奇看象人
Apache Mahout 提供了一个可扩展的机器学习库。Mahout 使用 MapReduce 范式，可用于分类、协作过滤和聚类。Mahout 利用 Apache Hadoop 处理多个并行任务。除了分类和聚类之外，Mahout 还提供了推荐算法，比如协作过滤，从而促进了快速构建模型的可伸缩性。
深度学习 4j
Deeplearning4j 是另一个专注于深度学习的 java 库。这是一个很棒的 Java 深度学习开源库。它也是用 Scala 和 Java 编写的，可以与 Hadoop 和 Spark 集成，提供高处理能力。当前的版本是测试版，但是有很好的文档和快速入门的例子(点击这里)。
木槌
Mallet 代表语言工具包的机器学习。它是少数几个用于自然语言处理的专门工具包之一。它提供了主题建模、文档分类、聚类和信息提取的能力。有了 Mallet，我们可以用 ML 模型来处理文本文档。
火花 MLlib
众所周知，Spark 可以提高处理大量数据的可伸缩性和整体性能。Spark MLlib 还拥有高性能算法，可在 Spark 上运行，并嵌入 Hadoop 工作流。
Encog 机器学习框架
Encog 是一个用于 ML 的 Java 和 C#框架。Envog 有用于构建 SVM、神经网络、贝叶斯网络、HMM 和遗传算法的库。Encog 已经开始作为一个研究项目，并得到了近 1000 个关于谷歌学术的引用。
恐鸟
海量在线分析(MOA)提供了用于分类、回归、聚类和推荐的算法。它还提供了异常检测和漂移检测的库。它是为实时处理产生的数据流而设计的。
Weka 示例:
我们将使用一个小型糖尿病数据集。我们将首先使用 Weka 加载数据:
import weka.core.Instances;
import weka.core.converters.ConverterUtils.DataSource;
public class Main {
public static void main(String[] args) throws Exception {
// Specifying the datasource
DataSource dataSource = new DataSource("data.arff");
// Loading the dataset
Instances dataInstances = dataSource.getDataSet();
// Displaying the number of instances
*log*.info("The number of loaded instances is: " + dataInstances.numInstances());
*log*.info("data:" + dataInstances.toString());
}
}
数据集中有 768 个实例。我们来看看如何得到属性(特征)的数量，应该是 9。
*log*.info("The number of attributes in the dataset: " + dataInstances.numAttributes());
在构建任何模型之前，我们希望确定哪一列是目标列，并查看在该列中找到了多少个类:
// Identifying the label index
dataInstances.setClassIndex(dataInstances.numAttributes() - 1);
// Getting the number of
*log*.info("The number of classes: " + dataInstances.numClasses());
加载数据集并确定目标属性后，现在是构建模型的时候了。我们来做一个简单的树分类器，J48。
// Creating a decision tree classifier
J48 treeClassifier = new J48();
treeClassifier.setOptions(new String[] { "-U" });
treeClassifier.buildClassifier(dataInstances);
在上面的三行中，我们指定了一个选项来指示一个未修剪的树，并为模型训练提供了数据实例。如果我们在训练后打印生成的模型的树结构，我们可以遵循模型如何在内部构建它的规则:
plas <= 127
| mass <= 26.4
| | preg <= 7: tested_negative (117.0/1.0)
| | preg > 7
| | | mass <= 0: tested_positive (2.0)
| | | mass > 0: tested_negative (13.0)
| mass > 26.4
| | age <= 28: tested_negative (180.0/22.0)
| | age > 28
| | | plas <= 99: tested_negative (55.0/10.0)
| | | plas > 99
| | | | pedi <= 0.56: tested_negative (84.0/34.0)
| | | | pedi > 0.56
| | | | | preg <= 6
| | | | | | age <= 30: tested_positive (4.0)
| | | | | | age > 30
| | | | | | | age <= 34: tested_negative (7.0/1.0)
| | | | | | | age > 34
| | | | | | | | mass <= 33.1: tested_positive (6.0)
| | | | | | | | mass > 33.1: tested_negative (4.0/1.0)
| | | | | preg > 6: tested_positive (13.0)
plas > 127
| mass <= 29.9
| | plas <= 145: tested_negative (41.0/6.0)
| | plas > 145
| | | age <= 25: tested_negative (4.0)
| | | age > 25
| | | | age <= 61
| | | | | mass <= 27.1: tested_positive (12.0/1.0)
| | | | | mass > 27.1
| | | | | | pres <= 82
| | | | | | | pedi <= 0.396: tested_positive (8.0/1.0)
| | | | | | | pedi > 0.396: tested_negative (3.0)
| | | | | | pres > 82: tested_negative (4.0)
| | | | age > 61: tested_negative (4.0)
| mass > 29.9
| | plas <= 157
| | | pres <= 61: tested_positive (15.0/1.0)
| | | pres > 61
| | | | age <= 30: tested_negative (40.0/13.0)
| | | | age > 30: tested_positive (60.0/17.0)
| | plas > 157: tested_positive (92.0/12.0)Number of Leaves : 22Size of the tree : 43
Deeplearning4j 示例:
此示例将构建一个卷积神经网络(CNN)模型来对 MNIST 图书馆进行分类。如果你不熟悉 MNIST 或者 CNN 是如何对手写数字进行分类的，我推荐你快速浏览一下我之前的帖子，它详细描述了这些方面。
像往常一样，我们将加载数据集并显示其大小。
DataSetIterator MNISTTrain = new MnistDataSetIterator(batchSize,true,seed);
DataSetIterator MNISTTest = new MnistDataSetIterator(batchSize,false,seed);
让我们仔细检查一下我们是否从数据集中获得了 10 个唯一的标签:
*log*.info("The number of total labels found in the training dataset " + MNISTTrain.totalOutcomes());
*log*.info("The number of total labels found in the test dataset " + MNISTTest.totalOutcomes());
接下来，让我们配置模型的架构。我们将使用两个卷积层加上一个输出扁平化层。Deeplearning4j 有几个选项可以用来初始化权重方案。
// Building the CNN model
MultiLayerConfiguration conf = new NeuralNetConfiguration.Builder()
.seed(seed) // random seed
.l2(0.0005) // regularization
.weightInit(WeightInit.*XAVIER*) // initialization of the weight scheme
.updater(new Adam(1e-3)) // Setting the optimization algorithm
.list()
.layer(new ConvolutionLayer.Builder(5, 5)
//Setting the stride, the kernel size, and the activation function.
.nIn(nChannels)
.stride(1,1)
.nOut(20)
.activation(Activation.*IDENTITY*)
.build())
.layer(new SubsamplingLayer.Builder(PoolingType.*MAX*) // downsampling the convolution
.kernelSize(2,2)
.stride(2,2)
.build())
.layer(new ConvolutionLayer.Builder(5, 5)
// Setting the stride, kernel size, and the activation function.
.stride(1,1)
.nOut(50)
.activation(Activation.*IDENTITY*)
.build())
.layer(new SubsamplingLayer.Builder(PoolingType.*MAX*) // downsampling the convolution
.kernelSize(2,2)
.stride(2,2)
.build())
.layer(new DenseLayer.Builder().activation(Activation.*RELU*)
.nOut(500).build())
.layer(new OutputLayer.Builder(LossFunctions.LossFunction.*NEGATIVELOGLIKELIHOOD*)
.nOut(outputNum)
.activation(Activation.*SOFTMAX*)
.build())
// the final output layer is 28x28 with a depth of 1.
.setInputType(InputType.*convolutionalFlat*(28,28,1))
.build();
架构设置好之后，我们需要初始化模式，设置训练数据集，触发模型训练。
MultiLayerNetwork model = new MultiLayerNetwork(conf);
// initialize the model weights.
model.init();
*log*.info("Step2: start training the model");
//Setting a listener every 10 iterations and evaluate on test set on every epoch
model.setListeners(new ScoreIterationListener(10), new EvaluativeListener(MNISTTest, 1, InvocationType.*EPOCH_END*));
// Training the model
model.fit(MNISTTrain, nEpochs);
在训练期间，分数收听者将提供分类准确度的混淆矩阵。让我们看看十次训练后的准确度:
=========================Confusion Matrix=========================
0 1 2 3 4 5 6 7 8 9
---------------------------------------------------
977 0 0 0 0 0 1 1 1 0 | 0 = 0
0 1131 0 1 0 1 2 0 0 0 | 1 = 1
1 2 1019 3 0 0 0 3 4 0 | 2 = 2
0 0 1 1004 0 1 0 1 3 0 | 3 = 3
0 0 0 0 977 0 2 0 1 2 | 4 = 4
1 0 0 9 0 879 1 0 1 1 | 5 = 5
4 2 0 0 1 1 949 0 1 0 | 6 = 6
0 4 2 1 1 0 0 1018 1 1 | 7 = 7
2 0 3 1 0 1 1 2 962 2 | 8 = 8
0 2 0 2 11 2 0 3 2 987 | 9 = 9
木槌示例:
如前所述，Mallet 是一个强大的自然语言建模工具包。我们将使用 Mallet 包中的工具 David Blei 提供的样本语料库。Mallet 有一个专门的库，用于为分类标注文本标记。在我们加载数据集之前，Mallet 有管道定义的概念，您定义管道，然后提供要通过的数据集。
ArrayList<Pipe> pipeList = new ArrayList<Pipe>();
管道被定义为一个“数组列表”，它包含了我们在构建主题模型之前通常要做的步骤。文档中的每个文本都将通过以下步骤:
- 小写关键字
- 标记文本
- 删除停用词
- 映射到要素
pipeList.add( new CharSequenceLowercase() );
pipeList.add( new CharSequence2TokenSequence(Pattern.*compile*("\\p{L}[\\p{L}\\p{P}]+\\p{L}")) );
// Setting the dictionary of the stop words
URL stopWordsFile = getClass().getClassLoader().getResource("stoplists/en.txt");
pipeList.add( new TokenSequenceRemoveStopwords(new File(stopWordsFile.toURI()), "UTF-8", false, false, false) );
pipeList.add( new TokenSequence2FeatureSequence() );
一旦定义了管道，我们将传递代表每个文档原始文本的实例。
InstanceList instances = new InstanceList (new SerialPipes(pipeList));
现在到了传递输入文件来填充实例列表的步骤。
URL inputFileURL = getClass().getClassLoader().getResource(inputFile);
Reader fileReader = new InputStreamReader(new FileInputStream(new File(inputFileURL.toURI())), "UTF-8");
instances.addThruPipe(new CsvIterator (fileReader, Pattern.*compile*("^(\\S*)[\\s,]*(\\S*)[\\s,]*(.*)$"),
3, 2, 1)); // data, label, name fields
从最后一个命令行中，您可以注意到我们提供了关于 CSV 文件如何构造的说明。资源文件夹中的源文件大约有 2000 行。每行代表一个原始文档文本，由逗号分隔的三个属性组成(名称、标签和文档内容)。我们可以使用以下命令打印在输入文档中找到的实例数量:
*log*.info("The number of instances found in the input file is: " + instances.size());
现在，让我们为文档的主题建模。假设我们在 2k 文档中有 100 个不同的主题。Mallet 使我们能够设置两个变量:alpha 和 beta 权重。Alpha 控制主题词分布的集中程度，beta 表示主题词分布上的前词权重。
int numTopics = 100;// defining the model
ParallelTopicModel model = new ParallelTopicModel(numTopics, 1.0, 0.01);
// adding the instances to the model
model.addInstances(instances);
我们在这个例子中选择的模型是 LDA(潜在狄利克雷分配)的实现。该算法使用一组观察到的关键词相似度来分类文档。
我喜欢 Mallet 的一点是它的 API 功能可以很容易地设计并行处理。在这里，我们可以为每个子样本定义多线程处理。
model.setNumThreads(2);
我们现在只剩下两件事，定义模型训练的迭代次数，并开始训练。
model.setNumIterations(50);
model.estimate();
关于如何在 github 上的完整示例中显示主题建模结果，我留下了更多的细节。
进一步阅读
- 【书】:botjan kalu la 著，O’Reilly 出版的 Java 中的机器学习。
- **【书籍】😗*机器学习:Java 开发者端到端指南，作者:Richard M. Reese，Jennifer L. Reese，Bostjan Kaluza，Uday Kamath 博士，Krishna Choppella。
- 【教程】 Spark MLlib 示例。
- 【教程】 用木槌进行机器学习。
本帖中提供的所有例子都可以在my Githubreprasority 上找到。
朱莉娅的机器学习
Julia 中机器学习入门的完整指南
朱莉娅是什么？
Julia 是一种相对较新的编程语言，它在机器学习领域越来越受欢迎。随着它变得越来越受欢迎，我想写这篇文章来深入概述为什么以及如何在 Julia 中开始机器学习。
由茱莉亚项目—https://julialang.org，公共领域，https://commons.wikimedia.org/w/index.php?curid=87405047
为什么要用 Julia 做机器学习？
速度和编译
Julia 相对于其他机器学习语言的主要优势是速度。Julia 的速度优势有两个主要原因，首先，它是一种编译语言。其次，它是为并行性而设计的。
类似脚本的语法
尽管有速度优势，但 Julia 的语法并不是很复杂。它感觉更像一种脚本语言，从 Python 或 R 背景转换到 Julia 相对容易。
社区、开发和图书馆
朱莉娅越来越受欢迎，也越来越成熟。随着这种增长，社区也在增长。尽管仍然远远小于 Python 社区，但看到社区和可用库数量的增长是一个好迹象。
在 Jupyter 笔记本上运行 Julia
Julia 的另一个优点是，它可以在 Jupyter 笔记本上运行。而且非常容易安装！以下是将 Julia 安装到 Jupyter 笔记本的方法:
- 从他们的网站下载并安装 Julia
- 打开 Julia 命令行
- 运行命令
using Pkg - 运行命令
Pkg.add("IJulia") - 启动一个 Jupiter 笔记本，你可以在笔记本的右上角选择 Julia(参见图片)
Julia 中虹膜数据集的数据准备
在进入真正的机器学习部分之前，需要把数据导入并准备好。这里我将只介绍三个基本步骤:导入一个 csv 文件，对一个分类变量进行热编码，以及进行训练测试分割。
数据准备 1 —在 Julia 中导入 CSV 文件
在 Julia 中入门的第一步是导入数据。在这种情况下，我们使用一个包含虹膜数据的 csv 文件。要将 csv 文件作为数据框导入，您需要添加如下所示的“CSV”和“DataFrames”库。然后，您使用“CSV。File”函数读取 csv 文件，DataFrame 函数将其转换为数据帧。
数据准备 2-一个热编码因变量(品种)
对于某些模型，您将需要一个分类变量的热编码。为此，您可以使用“车床”库。它具有 OneHotEncode 函数，可将数据帧转换为 OneHotEncode 数据帧。之后，您可以使用“选择”功能删除原始列。
数据准备 3-列车测试分离
对于模型评估，您将需要一个训练测试分割。下面的代码使用库“Random”来实现这一点。基本上，它会选择一个随机的索引子集，并将它们视为训练集，而未选择的索引将作为测试集:
朱莉娅的机器学习
Julia 中用于机器学习的资源仍然相对分布在不同的包中。Julia 还不像其他机器学习编程语言那样受欢迎，有时要找到特定的模型可能需要一些工作。寻找(或编写)在 Python 和 r 中容易获得的某些基本数据准备函数也可能需要更多的努力。
好消息是，有人倡议在更大的图书馆中重组机器学习模型。在这一点上，有两个库正在激烈竞争成为 Julia 的首选机器学习库:MLJ 和 Scikit Learn。
这两项倡议是伟大的，但它们尚未完全完成。因此，对于某些模型，它们只是向其他更小的机器学习库提供包装器。正因为如此，我发现涵盖其中两个较小的库也很重要:用于广义线性模型的“GLM”和用于许多基于树的模型的“决策树”。我将从较小的库开始，以较大的项目结束。
Julia 使用 GLM 图书馆的逻辑回归
以下示例使用 GLM 库对 Iris 数据拟合三个逻辑回归模型。GLM 使用“公式”接口，这在面向统计的库中很常见。我们可以指定一个族(在这种情况下为二项式)和一个链接类型(在这种情况下为 Logit 链接),以便创建所需的 GLM 类型。这是在下面代码片段的第一部分完成的。
在该片段的最后，三个模型的预测水平连接，以便为一对所有多类分类的应用做准备。
以下是打印出来的串联预测概率(这是“preds”变量中的内容):
在下面的代码片段中，我们将每行的三个预测概率转换为每行一个类别预测。该决定基于三个预测概率中的每一个之间的最高预测概率:
这是重新分类的“preds_cat”数组的外观:
作为最后一步，下面是如何使用一个简短的 for-loop 来计算我们在测试集上的 GLM 预测的准确性:
Julia 中的决策树使用 DecisionTree.jl 库
在下面的代码片段中，您将看到如何在 Julia 中构建决策树。首先，它重新导入 Iris 数据，因为决策树支持使用分类变量。如介绍中所述，这是使用 Julia 的一个优势。
然后，该模型被创建为决策树分类器的实例。我们可以给出几个超参数，例如本例中使用的 max_depth。感叹号的 fit 语法非常特殊。
最后两步是使用 predict 函数对测试集进行预测，并计算准确性，与前面的模型一样。
Julia 中的随机森林使用 DecisionTree.jl 库
正如您将看到的，随机森林模型的应用方式几乎与决策树相同。一开始可能会比较混乱，但是随机森林模型也是决策树库的一部分！
Julia 中机器学习的主要包
现在我们已经看到了如何在 Julia 中使用两个很大但很小的库来进行机器学习，让我们来看看更大的库。如前所述，有两个主要的软件包在竞争成为 Julia 的首选 ML 库:Scikit Learn 和 MLJ。我们去查查他们俩。
Julia 中用于机器学习 Scikit Learn
很多人都知道 Scikit 是从 Python 中学习的。它是 Python 中用于机器学习的包，在 Julia 中拥有它也很棒。如果我们能使用和 Python 一样的语法，那就简单多了！
让我们看一个在 Julia 中学习 Scikit 的例子。这个代码片段从导入 Scikit 学习库开始。下一步是加载您想要使用的模型(在这种情况下是逻辑回归)。使用“适合！”语法(注意感叹号)，模型训练好了。
之后，使用预测函数用训练好的模型预测测试集。最后，计算精度。
在 Julia 中使用 Scikit Learn 也有它的缺点。例如，我们可以在 Julia 中使用的 Scikit Learn 库的很大一部分实际上只是 Python 的包装。除了一些已经在 Julia 中实现的模型，Julia 模型实际上使用 Pycall 来调用 Python 代码。
但是，如果我们想换成朱丽亚，应该是为了拥有朱丽亚的好处。Julia 的一个主要优势是相对于 Python 的速度优势，调用 Python 代码真的不是我们应该在这里做的。如果只是一个 Python 包装器，我们还不如直接用 Python 学习 Scikit。
另一个缺点是 Scikit Learn 中的 Python 模型不支持分类变量。除了对它们进行编码之外，在 Scikit Learn 中真的没有什么可以做的，这确实是一个缺点(特别是对于基于树的模型)。正如您在整个例子中看到的，Julia 允许我们将分类变量视为一个变量，而不是一组热编码的虚拟变量。所以当我们把 Julia 仅仅作为 Python 包装器时，Julia 的优势也将消失。
茱莉亚的机器学习 MLJ
Julia 中机器学习的一个竞争对手是 MLJ 包。它承诺解决分类变量的问题，它是纯粹的-朱莉娅。这使得探索变得非常有趣。它还得到了艾伦图灵基金会的大力支持，这让我相信这个图书馆会一直存在下去。
现在，让我们在下面的代码片段中看看机器学习中 MLJ 的例子。有几件事和平常不一样。特别是，创建机器是一种语法选择，对许多人来说是新的。更不寻常的是必须加载一个模型，而不是导入一个包。
但是在这些语法差异之后，MLJ 库的使用并没有本质上的不同。MLJ 语法很容易学习，在 MLJ 的文档网站上有很好的文档。
结论
在这篇文章中，我们看到了 Julia 中的四个机器学习库。其中两个库(MLJ 和 Scikit Learn)似乎是接管 Julia 机器学习领域的真正竞争对手。
Scikit Learn 拥有 Python 实现中熟悉的语法的巨大优势，并获得了社区的信任。另一方面，Scikit Learn 通常只是简单地调用 Python 代码，这首先就剥夺了使用 Julia 的大部分优势。
作为一个真正的朱莉娅项目，MLJ 有很大的优势。它的语法有点新，但是差别似乎很小。对 MLJ 来说，真正的挑战是赢得更大社区的信任和欢迎。
我希望这篇文章已经给了你开始使用 Julia 所需要的一切，我祝你好运！
朱莉娅的机器学习终于有所进步
最近的软件包开发使数据处理变得切实可行。
(src = julia-lang.org)
自从我第一次开始使用 Julia，我和其他许多来自 Python 和 R 等具有强大生态系统的语言的叛逃者都有一个问题，那就是数据处理。在 Julia 中，数据处理似乎被忽视了，通常用单独的包来解决一个问题，而有些问题则被完全忽略了。有时已经有可用的函数，但是它们非常难以使用，要求您在通过任何预处理算法之前断言类型并转换数据。由于这个原因，不仅训练一个模型很困难，而且将一个模型放入一个管道并部署它也是完全不可能的。
然而，随着 Julia 开发人员所取得的超前和令人兴奋的进步，预处理已经比我原先想象的可能发展得更远。因此，Julia 已经成为机器学习的一个更可行的选择。随着对 Genie 及其相应文档的大量添加，部署 API 已经成为一种
蛋糕漫步。
Genie 为您管理所有的虚拟环境，现在文档已经发布，并由出色的开发人员 Essenciary (Adrian Salceanu)不断改进，使 Julia 更适合作为日常 web 框架使用。
(src = http://genieframework.com)
PyCall
这可能令人惊讶，但 Julia 目前面临的最大挑战之一是 PyCall.jl。这是因为就其现状而言，太多的包依赖于它，反过来又依赖于 Python。虽然我完全理解，Python 的生态系统要比 Julia 的生态系统大得多，但反过来，Julia 失去了所有获得的速度，使用 PyCall 甚至比使用 Python 本身还慢，
那为什么还要用朱莉娅呢？
训练-测试-拆分
训练-测试-分割是一个基本的工具，对于机器学习的任何延伸都是完全需要的。为了验证一个算法，你必须首先有一个训练集和一个测试集，有些人甚至选择了一个验证集。参考这个线程，
我暗暗希望这个问题至少在一周内不要出现，直到我找到时间写文档…
discourse.julialang.org](https://discourse.julialang.org/t/simple-tool-for-train-test-split/473)
关于 Julia 的论述，我认为很明显，数据帧的测试序列分割在某种程度上被忽略了。MLDataUtils 可能是大多数人用于训练-测试-分割的包，相信我的话:
它当然可以更好。
幸运的是，几个月来，已经有更好的从模块车床。
using Lathe.preprocess: TrainTestSplit
train, test = TrainTestSplit(df)
我们甚至可以调整我们的分割百分比，就像这样:
train, test = TrainTestSplit(df,0.5)
这将为我们的测试和训练集把数据分成两半。
特征缩放
我认为在 Julia 模块中最常见的是 SkLearn 形式。我不认为我们应该从一个完全独立的语言中，在一个完全独立的范例中，接受或强制这种构造。一个很好的例子是 Julia 中的特征标量。大多数(如果不是全部)特征标量符合 SkLearn 的写作风格，该风格自 2010 年以来一直定义 Python 机器学习模块。但是 SkLearn 的标量如此表现的原因只有一个，那就是 SkLearn 的奇妙管道。
在 Julia 中，我们没有类，反过来我们也不能让方法成为一个对象的子对象。取而代之的是，我们有一些结构，它们可以采用一个方法来对该结构保存的数据执行一个操作。此外，Julia 必须提供的唯一管道是语法管道——这很好，但肯定消除了与 SkLearn 一致的点，因为它们不使用相同的方法。为了正确理解这一点，以下是标准标量(Z 分数规格化器)的公式:
有了这样一个简单的公式，fit 只需要计算样本均值和标准差。以 Julia 的速度，这些计算当然可以在微秒内完成，就像在 Python 中一样。无论如何，这都不是一个困难的计算，只需一个简洁的 for 循环和另外两行代码就可以完成。幸运的是，车床用一种简单的方法再次罢工，采取任何数组:
using Lathe.preprocess: StandardScalar
scaledX = StandardScalar(trainX)
很简单，对吧？
除了标准标量之外，Lathe 还附带了大量其他标量，将来还计划实现一个单位长度标量。到目前为止，用？()方法将显示所有可用的标量:
- 重新标度
- 任意重新标度
- 均值归一化
分类编码器
分类编码器是 Julia 生态系统中另一个极度缺乏的领域。只有一个编码器可用，通常通过 Flux 使用，称为 one hot 编码器。为了让你了解复杂的 Flux 的 one hot encoder 有多无聊，你可以看看这里的源代码:
放松点。Flux 是不会让你 tensor - FluxML/Flux.jl 的 ML 库
github.com](https://github.com/FluxML/Flux.jl/blob/master/src/onehot.jl)
该文件中的代码总共有 130 行，在我看来，这个大小根本没有必要。要使用车床的 one hot 编码器，我们只需调用方法“OneHotEncode”:
using Lathe.preprocess: OneHotEncode
encoded_df = OneHotEncode(df,:columnname)
下面是计算它的代码，总共只有 7 行:
管道
ipelines 对于 SkLearn 和机器学习整体来说是一个非常重要的特性。Julia 严重缺乏使用管道的真正好的库。Julia 中的大多数管道不采用构造模型，也不允许任何简单的序列化读写。然而，对于车床，实际上存在使用与车床模型的其余部分相同的预测函数的管道，并且允许一组可迭代的步骤以及用于预测的模型。如果你想阅读一个完整的，虽然过时的车床管道教程，你可以在这里查看:
[## 在 Julia 中用车床 0.0.7 构建管道(不稳定)
数据科学的很大一部分是数据科学的一个子集，称为数据工程。数据工程(DE)包括…
towardsdatascience.com](/building-pipelines-with-lathe-0-0-7-unstable-in-julia-f7ba1850bde3)
此外，对于有价值的文档，您可以简单地使用？()方法在车床.模型.管道上
结论
我相信很多 Julia 模块都有很多不尽人意的地方。一些不提供任何数据帧兼容性，而另一些通过使简单的算法变得过于复杂而制造了更多的问题。Julia 语言非常灵活，这不仅在笔记本中对我们有利，在模块中也是如此。我认为，正是因为这个原因，Julia 的生态系统让很多新人对这门语言望而却步，这让我很沮丧。事实是，就包而言，现在 Python 轻而易举地做得更好。我认为这很容易改变，展望未来，我对朱莉娅的生态系统，包括车床的未来感到非常兴奋！
Max 中的机器学习:分类
如何使用 ml.lib 包在 Max 中执行简单机器学习任务的分步指南。
机器学习已经成为一个热门话题有一段时间了，像“人工智能”、“神经网络”和“深度学习”这样的词在任何地方都被用来描述项目的前沿性质和系统的所谓的智能。这些词的误用并不能抹杀这样一个事实，即机器学习可以成为在我们的系统中实现的一个非常有趣和强大的工具。在这篇文章中，我将概述如何通过 ml.lib 包在 Max 环境中使用机器学习分类算法。我将使用这篇文章的循序渐进的性质来描述和探索机器学习和分析算法的一些基本方面，而不会太专业！最后，尽管本教程将使用 Max 和从 Max 包管理器中获得的 ml.lib 包，但在从 Deken 包管理器中安装 ml.lib 的纯数据上可以遵循相同的步骤。
ml.lib
ml.lib 启动窗口:提供的所有类型的机器学习算法的概述。
ml.lib 或机器学习库是一个 Max 包，它在 Max 环境中提供了许多机器学习算法。所提供的算法属于不同的类别，即:特征提取、分类、回归和时间序列分类。在这篇文章中，我将把重点放在分类算法上，但是本文中包含的大部分知识也可以应用于大多数其他 ml.lib 对象。
分类
分类算法是称为监督学习的机器学习分支的一部分。监督学习与无监督学习的不同之处在于，它是基于基础事实的。换句话说，在监督学习算法中，我们使用带标签的数据集来训练我们的机器学习算法，给定数据样本和期望的输出，我们要求算法近似输入和输出之间的关系( David Soni 有一篇很棒的文章详细介绍了监督学习和非监督学习之间的差异，如果你对这个主题感兴趣，应该去看看)。这些算法可能是最容易理解和使用的，这就是为什么我们要把它们作为我们机器学习之旅的起点。
ml.lib 为我们提供了 7 种不同的分类算法，每种算法都有自己的优缺点。然而，在本文中，我们将只关注 ml.svm 的使用，原因有二:
- 支持向量机(SVM)算法是一个标准的和众所周知的算法，学习它的优点和缺点可能在其他环境中派上用场。
- 由于 ml.lib 的工作方式，所有分类算法都以完全相同的方式工作，并接受相同的数据。因此，通过学习如何使用一个，我们不仅能够使用它们，而且一旦我们创建了模型，我们还能够交换对象，以查看一个是否比另一个执行得更好。
事不宜迟，我们走吧。
入门指南
ml.svm.maxhelp 文件概述以及 ml.lib 附带的分类示例。
虽然 ml.lib 附带了一些帮助文件和一组示例，但是密集的补丁可能会吓到您。因此，本教程将从头开始，一步一步地构建一个最小的示例。
添加、训练、地图
除了时序分类对象，几乎所有的 ml.lib 对象都遵循相同的三个原则:添加、训练、映射。这些对象要求用户(1)添加一些数据，然后用作(2)训练数据，以便能够(3)将新的输入数据映射到预测的输出。
增加
正如我们之前在简介中提到的，ml.svm 是一种分类算法，属于监督学习类别。这意味着对象将期望添加的数据被标记。让我们看看这在 Max 中是什么样子的。
携带属于类别 1 的大小为 3 的特征向量的 add 消息的剖析。
需要传递给 ml 对象的 add 消息需要包含三个元素:
- 附加字，指定了我们要传递的信息的种类，
- 类别号，也就是我们给被传递数据的标签，
- 我们希望机器学习对象将其作为输入并在训练阶段使用以从数据中学习的特征向量或特征列表。
就是这样，这是为了将你的数据添加到 ml 对象中你唯一需要知道的事情。然而，考虑到解释的抽象性，让我们看一个实际的例子，看看这些概念是如何在补丁中转移的。
一个简单的 3 类场景的展示:3 个多滑块设置在 3 个不同的位置，三个 add 消息携带滑块的值，并分别将它们分配给类 1、2 和 3，并全部输入 ml.svm 对象。
在这个实际例子中，我们可以看到几乎什么都没有改变。我们向 svm 对象提供 3 条添加消息，每条消息都有不同的类。这些添加消息包含长度为 3 的特征向量，该向量表示与其连接的滑块的 3 个值。在类 1 中，所有滑块都接近其最大值，在类 2 中，它们被放置在 0 值附近，在类 3 中，它们都接近其最小值。这个小例子设置了一个场景，我们的 ml 对象将能够识别三个滑块的位置。
火车
现在我们已经将数据添加到 ml 对象中，我们需要训练它。训练是为 ml 对象(在我们的例子中是 ml.svm)提供学习和生成模型所需的数据的行为。模型是作为训练过程的结果而产生的人工制品，并且将负责输入数据的预测。
考虑到我们已经在“添加”阶段添加了数据，我们只需要训练模型。为此，向模型传递一条带有“train”一词的消息，等待一段时间(取决于添加的数据量)然后瞧！你的模特已经训练好了，准备好了。
地图
现在我们的模型已经准备好了，我们可以通过使用“map”消息来测试它。
携带大小为 3 的特征向量的地图消息的剖析。
map 消息的结构类似于没有类别号的 add 消息。这是因为该类将是 ml 对象在接收到一些输入数据后所要预测的对象。因此，在添加和训练了具有长度为 3 的特征向量的 ml 对象之后，通过 map 消息作为输入传递的任何长度为 3 的特征向量都将被分析，并且类别将被预测。让我们使用上面的滑块例子来看看这在实践中是如何工作的。
把所有的放在一起
从开始到结束:添加，训练和映射和 ml.svm 对象。
从上面的 gif 可以看出，这三个步骤正是本文所概述的:添加、训练、映射。一旦创建了模型，通过地图消息输入到 ml 对象中的 3 个滑块的任何位置都将被分析，并且预测的类将被输出。
与简单的查找表不同，这将使您能够预测原始添加数据中没有的滑块位置的类别。如果滑块没有对齐怎么办？机器学习算法将近似并提供给你一个类别预测。
虽然这不一定是最令人印象深刻的机器学习示例，但它展示了 Max 用户在他们的补丁中实现机器学习算法是多么容易。
最后一点
考虑到这个复杂的主题，试图让本教程尽可能简单是一个艰难的挑战。出于这个原因，我有目的地在文章的结尾留下了一些次要但重要的东西，以便感兴趣的读者能够获得开始玩机器学习所需的所有信息。
使您的模型更加健壮
正如你在最终的 gif 中所看到的，我为每一个类提供了带有许多稍微不同的滑块位置的添加消息。我可以简单地将第一类的所有滑块设置为最大，将第二类的所有滑块设置为中间，将第三类的所有滑块设置为最小，但是我决定提供数据中有一点“噪声”的多个示例。我们不需要深入 ml 概念来理解:
我们提供给 ml 对象的数据越少，生成的模型就越难正确预测类。
出于这个原因，提供多个彼此稍有不同的类的例子总是好的，允许 ml 对象从同一个类的多个实例中学习。然而，注意不要给你的 ml 对象太多的数据，因为这可能导致无限的训练时间和糟糕的结果。关键是提供大量的好数据。
清除、写入和读取
有一些重要的信息值得一提，尽管它们没有出现在文章的主要部分。清除允许您清除模型中的数据。无论你是搞砸了一条添加信息，还是只想重新开始，这都是你想要记住的信息。
相反，写和读允许您保存和加载您创建的数据和模型。保存和加载数据将使您避免将所有的类重新添加到 ml 对象中，但是更重要的是，保存预先训练的模型将使您避免训练阶段。这对于需要一段时间训练的大型数据集非常有用。
把一个模型换成另一个
正如本文开头提到的，ml.lib 捆绑的所有分类算法都以完全相同的方式工作。这意味着，如果您最初选择的算法没有您想象的那么好，您可以保存您已经添加的数据，并将其替换为同一类别中的任何其他算法(即任何其他分类算法)。一旦新算法到位，你需要做的就是读取之前保存的数据，重新训练模型。
最后但同样重要的是…
如果您想要复制上面显示的示例 patch，请记住从“检查器”标签中启用您的多滑块上的“鼠标移动时连续数据输出”。
修补愉快！
医学中的机器学习:学会信任
Pexels
机器学习正迅速在医疗保健行业的许多方面发挥主导作用，从诊断到治疗，甚至是人口层面的流行病学。直到最近，医学还是由自学和经验推动的。然而，随着数据库规模的增长和人工智能实施变得更加强大，在医学和医疗保健领域应用机器学习的好处正变得越来越为人所知。
医疗管道的几乎每个方面都受到了 ML 平台涌入的影响。经历显著增长的三个领域是皮肤病诊断、人群水平的疾病爆发预测和种族差异的改善。
Pexels
作为医学诊断工具的 ML 算法
机器学习在医学中的第一个应用是用于诊断皮肤肿瘤的图像分析。发表于 2019 年，该研究使用了一组由专家医生人工标记的超过 10，000 张图像来训练算法。在某些情况下，训练有素的算法甚至可以以比当前执业医生更高的准确率诊断皮肤癌病变。
在这项研究中专门测试的前三种算法能够区分七种预定义的疾病，包括基底细胞癌，一种常见的皮肤癌。然而，重要的是要注意，分类器对于分布外图像的性能有所下降，并且仍然需要有经验的医生的专业知识。然而，随着标记数据集在更广泛的疾病中变得更加可用，在这些边缘情况下，人和机器之间的当前差异可能会减少。
有趣的是，尽管许多诊所没有在诊断中积极使用机器学习预测算法，但 ML 的原则仍被引入医学院课程。一种特殊类型的皮肤病称为色素性光化性角化病，其特征是鳞状斑块。这是算法比训练有素的医生更擅长诊断的疾病之一，事实证明，算法比平时更关注瑕疵周围的皮肤，而不是瑕疵本身。
在指导学生在他们自己的诊断程序中关注相似的区域后，准确率提高了三分之一以上。这个例子和其他例子展示了医生和 ML 平台如何能够一起优化诊断。
Pexels
人口水平的疫情预测
ML 在医疗保健中的另一个日益增长的应用是监控人群水平的健康，特别是用于跟踪和预测疫情和流行病。这可以从最近世界各地公共卫生部门部署的众多新冠肺炎预测模型中看出。
这些模型既有回顾性的作用，也有前瞻性的作用。利用过去的数据，这些模型可以帮助研究人员了解疾病的起源(通常被称为零号病人)，以及它是如何在人与人之间传播的。然后，它可以帮助预测疾病将如何继续传播，以及哪些人群最容易受到感染。在群体水平上，这些问题的复杂性和所涉及的变量的数量使得没有 ML 的帮助很难完成。
然而，早在新冠肺炎疫情爆发之前，用于人口层面健康监测的机器学习就已投入使用。神经网络已经被用于预测寨卡的传播，以协助政府有效分配监控资源。对于这个特定的模型，疾病地理扩张的准确性超过 85%，即使有 12 周的扩展预测窗口。
甚至早在 2016 年，机器学习就被用来预测印度的疟疾疫情。支持向量机和神经网络允许研究人员纳入天气、相关案例和社会经济数据等广泛的参数，以提前 20 天预测传播。
机器学习在医学中对抗种族差异的应用
在公共卫生领域，一个越来越重要的考虑因素是卫生保健资源对所有人群的可用性。最近，华盛顿特区乔治华盛顿大学的米尔肯公共卫生学院开始开发一个机器学习管道来理解和预测医疗保健中普遍存在的种族差异。
不幸的是，在护理方面存在许多差距，这意味着某些种族或社会经济背景的人得不到同等水平或可用性的护理。例如，临床试验通常排除某些种族、性别或社会经济群体，这意味着结果并不像预期的那样广泛适用。因此，这个新研究小组的目标是探索这些健康的社会决定因素，并确定哪些环境因素影响健康风险和结果。这将有助于回答持续的研究问题，如为什么美国黑人更容易患癌症等慢性病。
然而，这个项目的最大障碍是缺乏正确标记和组织的数据。例如，大型国家数据库缺少关于患者种族的信息，这被认为是差异的一个重要指标。
无论如何，研究小组的第一个目标是了解与全关节置换术相关的死亡率，这是美国最常见的外科手术之一。这种方法是骨质疏松症的一种常见治疗方法，预计在未来几年需求将会增长。如果成功，该模型可以扩展到其他常见的程序，以预测种族和社会经济因素对结果的影响。
Pexels
在医学中应用机器学习的危险和弱点
很明显，ML 在医疗保健中扮演着越来越重要的角色。但是，在引入这项技术时，仍然需要记住一些复杂的问题。首先，当然是医疗数据的隐私。根据健康保险流通与责任法案(HIPAA ),对于什么样的健康数据可以共享以及数据的匿名程度有严格的指导原则。这可能会限制研究的应用范围。
对算法的过度依赖也应该被阻止，特别是当它们仍然容易出错的时候。例如，在一个为预测皮肤癌而开发的初步算法中，输入训练数据集的不正确甚至恶意操作被证明会导致完全误诊。不幸的是，这可能被用于欺诈利益，因此医疗团队和患者必须注意这种危险。
然而，为了应对这些风险，一些算法正在建立一个制衡系统，以尊重人类专家的意见。事实上，在某些情况下，人类-人工智能混合诊断工具的性能比单独使用任何一种工具都要好。很明显，医疗保健的未来取决于训练有素的人类专家和经验与机器学习算法的预测能力的集成。
这个故事最初发表在 Lionbridge.ai，你可以在这里 阅读故事原文，了解更多关于 Lionbridge 。
使用 PyCaret 实现 Power BI 中的机器学习
几分钟内在 Power BI 中实现机器学习的分步教程
机器学习遇上商业智能
PyCaret 1.0.0
上周我们宣布了 PyCaret ，这是一个用 Python 编写的开源机器学习库，它在低代码环境中训练和部署机器学习模型。在我们之前的帖子中，我们演示了如何在 Jupyter Notebook 中使用 PyCaret 来训练和部署 Python 中的机器学习模型。
在本帖中，我们展示了一个关于如何将 PyCaret 集成到 Power BI 中的逐步教程，从而允许分析师和数据科学家在他们的仪表板和报告中添加一层机器学习，而无需任何额外的许可或软件成本。PyCaret 是一个开源的免费使用的 Python 库，它提供了一系列专门为 Power BI 构建的函数。
在本文结束时，您将了解如何在 Power BI 中实现以下内容:
- 聚类 —对具有相似特征的数据点进行分组。
- 异常检测 —识别数据中罕见的观察值/异常值。
- 自然语言处理 —通过主题建模分析文本数据*。*
- 关联规则挖掘 —在数据中发现有趣的关系。
- 分类 —预测二进制(1 或 0)的分类类标签。
- 回归 —预测连续值，如销售额、价格等
“PyCaret 通过为业务分析师、领域专家、公民数据科学家和经验丰富的数据科学家提供免费、开源和低代码的机器学习解决方案，使机器学习和高级分析的使用民主化”。
Microsoft Power BI
Power BI 是一种业务分析解决方案，可让您在整个组织中可视化数据和共享见解，或将它们嵌入到您的应用程序或网站中。在本教程中，我们将通过将 PyCaret 库导入 Power BI 来使用 Power BI 桌面进行机器学习。
开始之前
如果您以前使用过 Python，很可能您的计算机上已经安装了 Anaconda 发行版。如果没有，单击此处下载 Python 3.7 或更高版本的 Anaconda 发行版。
https://www.anaconda.com/distribution/
设置环境
在我们开始在 Power BI 中使用 PyCaret 的机器学习功能之前，我们必须创建一个虚拟环境并安装 pycaret。这是一个三步走的过程:
✅ 步骤 1——创建一个蟒蛇环境
从开始菜单打开 Anaconda 提示符并运行以下代码:
conda create --name **myenv** python=3.6
Anaconda 提示符—创建环境
✅ 步骤 2 —安装 PyCaret
在 Anaconda 提示符下运行以下代码:
conda activate **myenv**
pip install pycaret
安装可能需要 10-15 分钟。
✅t16】第三步——在 Power BI 中设置 Python 目录
创建的虚拟环境必须与 Power BI 链接。这可以使用 Power BI Desktop 中的全局设置来完成(文件→选项→全局→ Python 脚本)。默认情况下，Anaconda 环境安装在以下位置:
C:\Users\ 用户名\ AppData \ Local \ Continuum \ anaconda 3 \ envs \ myenv
文件→选项→全局→ Python 脚本
📘示例 Power BI 中的集群
聚类是一种机器学习技术，它将具有相似特征的数据点分组。这些分组对于探索数据、识别模式和分析数据子集非常有用。集群的一些常见业务用例有:
以营销为目的的✔客户细分。
促销和折扣的✔顾客购买行为分析。
✔在诸如新冠肺炎的流行病爆发中识别地理群集。
在本教程中，我们将使用 PyCaret 的 github 资源库中的**’ jewellery . CSV’**文件。您可以使用 web 连接器加载数据。(Power BI 桌面→获取数据→来自 Web)。
链接到 csv 文件:https://raw . githubusercontent . com/py caret/py caret/master/datasets/jewellery . CSV
Power BI 桌面→获取数据→其他→ Web
来自 jewellery.csv 的样本数据点
K-均值聚类
为了训练聚类模型，我们将在 Power Query Editor 中执行 Python 脚本(Power Query Editor→Transform→Run Python script)。
超级查询编辑器中的功能区
将以下代码作为 Python 脚本运行:
from **pycaret.clustering** import *****
dataset = **get_clusters**(data = dataset)
超级查询编辑器(转换→运行 python 脚本)
输出:
聚类结果(代码执行后)
最终输出(点击表格后)
包含标签的新列**‘集群’**被附加到原始表格。
一旦您应用了查询(Power Query Editor→Home→Close & Apply)，以下是您如何在 Power BI 中可视化集群:
默认情况下，PyCaret 训练一个具有 4 个聚类的 K-Means 聚类模型(即表中的所有数据点都被分为 4 组)。默认值可以很容易地更改:
- 要更改聚类数，您可以使用 get_clusters( ) 函数中的num _ clusters参数。
- 要更改模型类型，使用 get_clusters( ) 内的 模型 参数。
请参见下面的示例代码，该代码用于训练具有 6 个群集的 K-Modes 模型:
*from **pycaret.clustering** import *
dataset = **get_clusters**(dataset, model = 'kmodes', num_clusters = 6)*
PyCaret 中有 9 种现成可用的聚类算法:
训练一个聚类模型所需的所有预处理任务，如缺失值插补(如果表中有任何缺失值或空值*)，或归一化，或一次热编码，都是在训练一个聚类模型之前自动执行的。单击此处了解更多关于 PyCaret 预处理功能的信息。*
💡在这个例子中，我们使用了 get_clusters( ) 函数来分配原始表中的分类标签。每次刷新查询时，都会重新计算分类。实现这一点的另一种方法是使用 predict_model( ) 函数，使用 Python 或 Power BI 中的预训练模型来预测聚类标签(参见下面的示例 5，以了解如何在 Power BI 环境中训练机器学习模型)。
💡如果你想学习如何使用 Jupyter 笔记本在 Python 中训练一个聚类模型，请参见我们的聚类 101 初学者教程。(不需要编码背景)。**
📘示例 2 —电力 BI 中的异常检测
异常检测是一种机器学习技术，用于通过检查表中与大多数行明显不同的行来识别稀有项目、事件、、或观察值。通常，异常项目会转化为某种问题，如银行欺诈、结构缺陷、医疗问题或错误。异常检测的一些常见业务用例有:
✔欺诈检测(信用卡、保险等。)使用财务数据。
✔入侵检测(系统安全、恶意软件)或监控网络流量的起伏。
✔识别数据集中的多元异常值。
*在本教程中，我们将使用 PyCaret 的 github 资源库中的**anomaly . CSV’*文件。您可以使用 web 连接器加载数据。(Power BI 桌面→获取数据→来自 Web)。
链接到 csv 文件:https://raw . githubusercontent . com/py caret/py caret/master/datasets/anomaly . CSV
来自 anomaly.csv 的样本数据点
k 近邻异常检测器
与聚类类似，我们将从 Power Query Editor 运行 python 脚本(转换→运行 Python 脚本)来训练异常检测模型。将以下代码作为 Python 脚本运行:
*from **pycaret.anomaly** import *****
dataset = **get_outliers**(data = dataset)*
超级查询编辑器(转换→运行 python 脚本)
输出:
异常检测结果(代码执行后)
最终输出(点击表格后)
两个新列附加到原始表。标签(1 =异常值，0 =内部值)和分数(具有高分数的数据点被归类为异常值)。
应用查询后，以下是如何在 Power BI 中可视化异常检测的结果:
默认情况下，PyCaret 用 5%的分数训练一个K-最近邻异常检测器(即表中总行数的 5%将被标记为异常值)。默认值可以很容易地更改:
- 要更改分数值，您可以使用 get_outliers( ) 函数中的 分数 参数。
- 要更改模型类型，使用 get_outliers( ) 内的 模型 参数。
请参见以下代码，用于训练分数为 0.1 的隔离林模型:
*from **pycaret.anomaly** import *
dataset = **get_outliers**(dataset, model = 'iforest', fraction = 0.1)*
PyCaret 中有超过 10 种现成的异常检测算法:
训练异常检测模型所需的所有预处理任务，例如缺失值插补(如果表中有任何缺失值或空值*)，或归一化，或一热编码，它们都在训练异常检测模型之前自动执行。单击此处了解更多关于 PyCaret 预处理功能的信息。*
💡在本例中，我们使用了 get_outliers( ) 函数来分配离群值标签和分数以进行分析。每次刷新查询时，都会重新计算离群值。实现这一点的另一种方法是使用 predict_model( ) 函数，使用 Python 或 Power BI 中预训练的模型来预测异常值(参见下面的示例 5，了解如何在 Power BI 环境中训练机器学习模型)。
💡如果你想学习如何使用 Jupyter 笔记本在 Python 中训练一个异常检测器，请参见我们的异常检测 101 初学者教程。(不需要编码背景)。**
📘示例 3 —自然语言处理
有几种技术被用来分析文本数据，其中主题建模是一种流行的技术。主题模型是一种用于在文档集合中发现抽象主题的统计模型。主题建模是一种常用的文本挖掘工具，用于发现文本数据中隐藏的语义结构。
在本教程中，我们将使用 PyCaret 的 github 资源库中的*‘kiva . CSV’*文件。您可以使用 web 连接器加载数据。(Power BI 桌面→获取数据→来自 Web)。
链接到 csv 文件:https://raw . githubusercontent . com/py caret/py caret/master/datasets/kiva . CSV
潜在狄利克雷分配
在超级查询编辑器中以 Python 脚本的形式运行以下代码:
*from **pycaret.nlp** import *****
dataset = **get_topics**(data = dataset, text = 'en')*
超级查询编辑器(转换→运行 python 脚本)
***‘en’是表格‘kiva’*中包含文本的列的名称。
输出:
主题建模结果(代码执行后)
最终输出(点击表格后)
一旦代码被执行，带有主题权重和主导主题的新列被附加到原始表。在 Power BI 中，有许多方法可以可视化主题模型的输出。请参见下面的示例:
默认情况下，PyCaret 使用 4 个主题训练一个潜在的 Dirichlet 分配模型。默认值可以很容易地更改:
- 要更改主题数量，您可以使用 get_topics( ) 函数中的 num_topics 参数。
- 要更改模型类型，使用 get_topics( ) 中的 模型 参数。
参见训练具有 10 个主题的非负矩阵分解模型的示例代码:
*from **pycaret.nlp** import *
dataset = **get_topics**(dataset, 'en', model = 'nmf', num_topics = 10)*
PyCaret 有以下现成的主题建模算法:
📘示例 Power BI 中的关联规则挖掘
关联规则挖掘是一种基于规则的机器学习技术，用于发现数据库中变量之间的有趣关系。它旨在使用兴趣度来识别强规则。关联规则挖掘的一些常见业务用例有:
✔购物篮分析，了解经常一起购买的项目。
✔医学诊断，用于帮助医生确定给定因素和症状下疾病的发生概率。
在本教程中，我们将使用 PyCaret 的 github 库中的*‘France . CSV’*文件。您可以使用 web 连接器加载数据。(Power BI 桌面→获取数据→来自 Web)。
链接到 csv 文件:https://raw . githubusercontent . com/py caret/py caret/master/datasets/France . CSV
来自法国的样本数据点. csv
Apriori 算法
现在应该清楚了，所有 PyCaret 函数都是作为 python 脚本在 Power 查询编辑器中执行的(转换→运行 Python 脚本)。运行以下代码，使用 Apriori 算法为关联规则模型定型:
*from **pycaret.arules** import *
dataset = **get_rules**(dataset, transaction_id = 'InvoiceNo', item_id = 'Description')*
超级查询编辑器(转换→运行 python 脚本)
***‘invoice no’是包含交易 id 的列，‘Description’*包含感兴趣的变量，即产品名称。
输出:
关联规则挖掘结果(代码执行后)
最终输出(点击表格后)
它返回一个包含前因和后果的表格，以及相关的指标，如支持度、信心、提升等。点击这里了解更多关于 PyCaret 中的关联规则挖掘。
📘示例 5 —功率 BI 的分类
分类是一种受监督的机器学习技术，用于预测分类类别标签(也称为二元变量)。分类的一些常见业务用例有:
✔预测客户贷款/信用卡违约。
✔预测客户流失(客户会留下还是离开)
✔预测患者结果(无论患者是否患有疾病)
在本教程中，我们将使用 PyCaret 的 github 资源库中的*‘employee . CSV’*文件。您可以使用 web 连接器加载数据。(Power BI 桌面→获取数据→来自 Web)。
链接到 csv 文件:https://raw . githubusercontent . com/py caret/py caret/master/datasets/employee . CSV
目标:表格‘员工’**包含一家公司中 15，000 名在职员工的信息，如在该公司工作的时间、每月平均工作时间、晋升历史、部门等。基于所有这些列(在机器学习术语中也称为特征，目标是预测员工是否会离开公司，由列*‘left’*表示(1 表示是，0 表示否)。
与聚类、异常检测和非监督机器学习下的 NLP 示例不同，分类是一种监督的技术，因此它分两部分实现:
第 1 部分:在 Power BI 中训练分类模型
第一步是在 Power Query Editor 中创建一个表*‘employee’*的副本，用于训练模型。
超级查询编辑器→右键单击“员工”→复制
在新创建的复制表*’ employee(model training)'*中运行下面的代码来训练一个分类模型:
*# import classification module and setup environmentfrom **pycaret.classification** import *****
clf1 = **setup**(dataset, target = 'left', silent = True)# train and save xgboost modelxgboost = **create_model**('xgboost', verbose = False)
final_xgboost = **finalize_model**(xgboost)
**save_model**(final_xgboost, 'C:/Users/*username*/xgboost_powerbi')*
超级查询编辑器(转换→运行 python 脚本)
输出:
该脚本的输出将是一个保存在指定位置的 pickle 文件。pickle 文件包含整个数据转换管道以及经过训练的模型对象。
💡另一种方法是在 Jupyter 笔记本电脑中训练模型，而不是 Power BI。在这种情况下，Power BI 将仅用于使用 Jupyter notebook 中预训练的模型在前端生成预测，该模型将作为 pickle 文件导入 Power BI(遵循下面的第 2 部分)。要了解更多关于在 Python 中使用 PyCaret 的信息，点击这里。
💡如果你想学习如何使用 Jupyter Notebook 在 Python 中训练一个分类模型，请看我们的二进制分类 101 入门教程。(不需要编码背景)。**
PyCaret 中有 18 种现成可用的分类算法:
第 2 部分:使用训练好的模型生成预测
我们现在可以使用原始*‘employee’*表上的训练模型来预测该员工是否会离开公司(1 或 0)以及概率%。以 python 脚本的形式运行以下代码来生成预测:
*from **pycaret.classification** import *****
xgboost = **load_model**('c:/users/*username*/xgboost_powerbi')
dataset = **predict_model**(xgboost, data = dataset)*
输出:
分类预测(代码执行后)
最终输出(点击表格后)
*两个新列附加到原始表。**‘Label’列表示预测，‘Score’*列表示结果的概率。
*在本例中，我们预测的数据与我们用于训练模型的数据相同，但仅用于演示目的。在实际设置中，**‘左’*列是实际结果，在预测时未知。
在本教程中，我们已经训练了一个极端梯度推进 (‘xgboost’) 模型，并使用它来生成预测。我们这样做只是为了简单。实际上，您可以使用 PyCaret 来预测任何类型的模型或模型链。
PyCaret 的 predict_model( ) 函数可以与使用 PyCaret 创建的 pickle 文件无缝协作，因为它包含整个转换管道以及经过训练的模型对象。点击这里了解更多关于预测 _ 模型功能的信息。
💡训练分类模型所需的所有预处理任务，如缺失值插补(如果表中有任何缺失值或空值*)，或一键编码，或目标编码，它们都在训练模型之前自动执行。单击此处了解更多关于 PyCaret 预处理功能的信息。*
📘示例 6—功率 BI 的回归
回归是一种受监督的机器学习技术，用于在给定过去数据及其相应的过去结果的情况下，以最佳可能的方式预测连续结果。与用于预测二元结果(如是或否(1 或 0))的分类不同，回归用于预测连续值，如销售额、价格、数量等。
在本教程中，我们将使用 pycaret 的 github 资源库中的*‘Boston . CSV’*文件。您可以使用 web 连接器加载数据。(Power BI 桌面→获取数据→来自 Web)。
链接到 csv 文件: https://raw . githubusercontent . com/py caret/py caret/master/datasets/Boston . CSV
目标:表格【波士顿】**包含波士顿 506 所房屋的信息，如平均房间数、财产税税率、人口等。基于这些列(在机器学习术语中也称为特征，目标是预测由列*‘medv’*表示的房屋的中值。
第 1 部分:在 Power BI 中训练回归模型
第一步是在 Power Query Editor 中创建一个*‘Boston’*表的副本，用于训练模型。
以 python 脚本的形式在新的重复表中运行以下代码:
*# import regression module and setup environmentfrom **pycaret.regression** import *****
clf1 = **setup**(dataset, target = 'medv', silent = True)# train and save catboost modelcatboost = **create_model**('catboost', verbose = False)
final_catboost = **finalize_model**(catboost)
**save_model**(final_catboost, 'C:/Users/*username*/catboost_powerbi')*
输出:
该脚本的输出将是保存在指定位置的 pickle 文件。pickle 文件包含整个数据转换管道以及经过训练的模型对象。
PyCaret 中提供了 20 多种现成的回归算法:
第 2 部分:使用训练好的模型生成预测
我们现在可以使用训练好的模型来预测房屋的中值。在原始表*【波士顿】*中运行以下代码作为 python 脚本:
*from **pycaret.classification** import *****
xgboost = **load_model**('c:/users/*username*/xgboost_powerbi')
dataset = **predict_model**(xgboost, data = dataset)*
输出:
回归预测(代码执行后)
最终输出(点击表格后)
包含预测的新列*‘标签’*被附加到原始表。
*在本例中，我们预测的数据与我们用于训练模型的数据相同，但仅用于演示目的。在实际设置中，**‘medv’*列是实际结果，在预测时是未知的。
💡训练回归模型所需的所有预处理任务，如缺失值插补(如果表格中有任何缺失值或空值*)，或一键编码，或目标转换，它们都在训练模型之前自动执行。单击此处了解更多关于 PyCaret 预处理功能的信息。*
下一个教程
在使用 PyCaret 系列的 Power BI 中的机器学习的下一篇教程中，我们将更深入地探讨 PyCaret 中的高级预处理特性。我们还将看到如何在 Power BI 中生产机器学习解决方案，并在 Power BI 的前端利用 PyCaret 的力量。
如果你想了解更多，请保持联系。
在我们的 Linkedin 页面上关注我们，订阅我们的 Youtube 频道。
另请参见:
初级 Python 笔记本:
开发管道中有什么？
*我们正在积极改进 PyCaret。我们未来的开发管道包括一个新的时间序列预测模块，与 **TensorFlow、*的集成，以及对 PyCaret 可扩展性的重大改进。如果您想分享您的反馈并帮助我们进一步改进，您可以在网站上填写这张表格或者在我们的 Github 或 LinkedIn 页面上发表评论。
想了解某个特定模块？
从第一个版本 1.0.0 开始，PyCaret 有以下模块可供使用。点击下面的链接，查看 Python 中的文档和工作示例。
重要链接
用户指南/文档
Github 资源库 安装 PyCaret
笔记本教程
贡献于 PyCaret
如果你喜欢 PyCaret，请给我们 github 回购的⭐️。
在媒介上跟随我:https://medium.com/@moez_62905/
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
