如何利用机器学习在 GitHub 上实现任务自动化，以获得乐趣和利润
关于如何使用tensor flow和公共数据集构建预测和应用问题标签的 GitHub 应用程序的教程。
由哈默尔·侯赛因、迈克尔·贾斯特兹·布斯基和杰里米·路易
挑逗:建立一个模型，标签的问题，并推出它作为一个产品！
Link to this issue. More examples can be viewed here.
Link to this issue. More examples can be viewed here
从此页面 将此应用程序安装到您的 GitHub 存储库中。
动机:难以捉摸的完美机器学习问题
Finding the ideal machine learning problem can feel like searching for treasure or chasing dragons. Image credit.
我们的数据科学家朋友和同事会将理想的预测建模项目描述为这样一种情况:
- 有一个丰富的数据，它已经被贴上标签或者标签可以被推断出来。
- 这些数据可以用来解决现实问题。
- 问题与你热衷的领域有关，或者你想解决的问题是你自己的，你可以成为你的第一个客户。
- 有一个平台可以让你的数据产品接触到大量的受众，有机制收集反馈并改进**。**
- 你可以用最少的花费和时间创建这个，希望使用你熟悉的语言和工具。
- 如果你的产品成功了，有一种方法可以将它货币化。
上面的列表是令人向往的，数据科学家很幸运地遇到了满足所有这些的问题(如果我们能找到满足其中一半的问题，作者会感到幸运！).
进入 GH-Archive 和 GitHub 应用程序:数据遇到机会的地方
今天，我们展示了一个数据集、平台和领域，我们认为它们满足上述标准！
数据集:GH-Archive。
GH-Archive 通过从 GitHub REST API 中摄取大部分这些事件来记录来自 GitHub 的大量数据。这些事件以 JSON 格式从 GitHub 发送到 GH-Archive，称为有效载荷。以下是编辑问题时收到的有效负载的示例:
A truncated version of this example.
可以想象，考虑到 GitHub 上的事件类型和用户数量，有大量的有效负载。幸运的是，这些数据存储在 BigQuery 中，允许通过 SQL 接口快速检索！获取这些数据是非常经济的，因为当你第一次注册一个帐户时，谷歌会给你 300 美元，如果你已经有一个帐户，费用非常合理。
因为数据是 JSON 格式的，所以解嵌套数据的语法可能有点陌生。我们可以使用 JSON_EXTRACT 函数来获取我们需要的数据。下面是一个示例，说明如何从问题有效负载中提取数据:
Example query syntax you might use for GH-Archive data stored on BigQuery. Pay close attention to the syntax used.
关于如何从 BigQuery 中提取 GitHub 问题的分步解释可以在本文的附录部分中找到，但是，重要的是要注意，除了问题数据之外，还可以检索 GitHub 上发生的几乎任何事情的数据！您甚至可以在 BigQuery 中从公共 repos 中检索到大量的代码。
平台:GitHub Apps**&GitHub market place**
GitHub 平台允许你构建能够执行许多动作的应用，比如与问题交互、创建存储库或者修复拉请求中的代码。由于你的应用程序所需要的只是从 GitHub 接收有效负载并调用REST API，你可以用你选择的任何语言编写应用程序，包括 python。
最重要的是， GitHub marketplace 为你提供了一种在可搜索平台上列出你的应用并向用户收取月费的方式。这是将你的想法货币化的好方法。你甚至可以托管未经验证的免费应用作为收集反馈和迭代的方式。
令人惊讶的是，使用机器学习的 GitHub 应用并不多，尽管这些公共数据集是可用的！提高对此的认识是这篇博文的动机之一。
一个端到端的例子:用机器学习自动标记 GitHub 问题
Automatically labeling issues can help with organizing and finding information. Photo by Susan Yin
为了向您展示如何创建自己的应用程序，我们将带您完成创建一个能够自动标记问题的 GitHub 应用程序的过程。请注意，这个应用程序的所有代码，包括模型训练步骤，都位于这个 GitHub 存储库中。
第一步:注册您的应用&完成先决条件。
首先，您需要设置您的开发环境。完成本文中的步骤 1-4。您不需要阅读“Ruby 编程语言”一节，或者第 4 步之后的任何步骤。确保你设置了一个 Webhook secret，即使这个部分是可选的。
请注意，GitHub 应用程序和 Oauth 应用程序之间存在差异。出于本教程的目的，我们对 GitHub 应用程序感兴趣。您不需要太担心这一点，但是如果您在浏览文档时知道这一区别是很好的。
第二步:用 python 轻松地与 GitHub API 交互。
您的应用程序需要与 GitHub API 进行交互，以便在 GitHub 上执行操作。使用您选择的编程语言中的预构建客户端是非常有用的，这样可以使工作变得更加轻松。虽然 GitHub 上的官方文档向您展示了如何使用 Ruby 客户端，但还有针对许多其他语言的第三方客户端，包括 Python。出于本教程的目的，我们将使用 Github3.py 库。
作为应用程序与 GitHub API 接口的最令人困惑的方面之一是认证。对于下面的指令，使用 curl 命令，而不是文档中的 ruby 示例。
首先，您必须通过签署一个 JSON Web 令牌(JWT)来认证为一个应用。一旦您签署了 JWT，您就可以使用它作为应用安装进行验证。在认证为应用程序安装时，您将收到一个安装访问令牌，您可以使用它与 REST API 进行交互。
请注意，作为应用程序的身份验证是通过 GET 请求完成的，而作为应用程序安装的身份验证是通过 PUT 请求完成的。尽管在示例 CURL 命令中说明了这一点，但这是我们在开始时忽略的一个细节。
即使您将使用 Github3.py 库，了解上述认证步骤也是有用的，因为可能存在不支持的路由，您可能希望使用请求库来实现自己。对我们来说就是这种情况，所以我们最终围绕 Github3.py 库编写了一个名为 mlapp 的薄包装器来帮助我们与问题进行交互，这就是这里定义的。
下面是可用于创建问题、发表评论和应用标签的代码。这个代码在这个笔记本里也有。
The above code created this issue on GitHub. This code is also available in this notebook.
你可以在这里看到这个代码产生的问题。
第三步:获取和准备数据。
如前所述，我们可以使用托管在 BigQuery 上的 GH-Archive 来检索问题示例。此外，我们还可以检索人们为每个问题手动应用的标签。下面是我们用来构建所有这些标签的帕累托图的查询:
Link to this query. Data produced by this query is available in this spreadsheet.
Top issue labels from the public dataset. There is an extremely long tail (not shown here).
这个电子表格包含了整个帕累托图的数据。有一个不相互排斥的问题标签的长尾。例如，增强和特征标签可以组合在一起。此外，标签的质量和含义可能因项目而异。尽管存在这些障碍，我们还是决定简化问题，将尽可能多的标签分成三类:特性请求、 bug 和问题使用我们在手动查看前 200 个标签后构建的试探法。此外，我们咨询了一个大型开源项目 Kubeflow 的维护者，作为我们的第一个客户来验证我们的直觉。
我们尝试创建名为 other 的第四个类别，以便获得不在前三个类别中的项目的负面样本，然而，我们发现信息是嘈杂的，因为在这个“其他”类别中有许多 bug、功能请求和问题。因此，我们将训练集限制在我们可以归类为特性请求、bug 或问题专有的问题上。
应该注意的是，这种训练数据的安排远非理想，因为我们希望我们的训练数据尽可能接近真实问题的分布。然而，我们的目标是用尽可能少的时间和费用构建一个最小的可行产品，并在以后进行迭代，所以我们采用了这种方法。
最后，我们特别注意消除重复问题。为了保守起见，我们解决了以下类型的重复(通过在重复集中任意选择一个问题):
- 同一回购协议中相同标题的发行。
- 不管标题如何，正文内容相同的问题。通过仅考虑问题正文中的前 75%字符和后 75%字符，删除了更多重复项。
用于对问题进行分类和消除重复问题的 SQL 查询可通过此链接查看。您不必运行此查询，因为我们来自 Kubeflow 项目的朋友已经运行了此查询，并将结果数据作为 CSV 文件托管在 Google Cloud Bucket 上，您可以通过遵循本笔记本中的代码来检索。笔记本中还有对原始数据的探究以及对数据集中所有字段的描述。
步骤 4:建立和训练模型。
现在我们有了数据，下一步是构建和训练模型。对于这个问题，我们决定借用我们为类似问题构建的一个文本预处理管道，应用在这里。这个预处理管道清理原始文本，标记数据，构建词汇表，并将文本序列填充到相等的长度，这些步骤在我们之前的博客文章的“准备和清理数据”部分中进行了概述。在这本笔记本中概述了完成这一问题标签任务的代码。
我们的模型接受两个输入:问题标题和主体，并将每个问题分类为 bug 、特性请求或问题。下面是我们用 tensorflow 定义的模型架构。Keras :
Code available in this notebook.
关于该模型的几点注意事项:
- 你不必使用深度学习来解决这个问题。我们只是使用了我们为另一个密切相关的问题建立的现有管道，以便快速引导我们自己。
- 模型架构简单得令人尴尬。我们的目标是让事情尽可能简单，以证明您可以使用简单的方法构建真正的数据产品。我们没有花太多时间调整或试验不同的架构。
- 我们预计，通过使用更先进的架构或改进数据集，该模型还有很大的改进空间。我们在这篇博文的后续步骤部分提供了几个提示。
评估模型
下面是一个混淆矩阵，显示了我们的模型在三个类别的测试集上的准确性。该模型确实很难对问题进行分类，但在区分 bug 和特性方面做得相当不错。
请注意，由于我们的测试集并不代表所有问题(因为我们只过滤了我们可以分类的数据集)，所以应该对上面的准确性指标持保留态度。我们通过从用户那里收集明确的反馈在一定程度上缓解了这个问题，这允许我们重新训练我们的模型并非常快速地调试问题。我们将在后面的章节中讨论显式反馈机制。
做预测
以下是模型预测玩具的例子。完整的代码可在本笔记本中获得。
Link to the notebook.
我们希望选择合理的阈值，这样模型就不会向人们发送太多不正确的预测(这意味着我们的应用程序在某些情况下可能不会提供任何预测)。我们通过在几个回购上测试我们的系统并就可接受的假阳性率咨询几个维护者来选择阈值。
步骤 5:使用 Flask 来响应有效负载。
现在，您已经有了一个可以进行预测的模型，并且有了一种以编程方式向问题添加评论和标签的方法(步骤 2)，剩下的工作就是将这些部分粘在一起。您可以通过以下步骤实现这一点:
- 启动一个 web 服务器，监听来自 GitHub.com 的有效负载(在步骤 1 中注册应用程序时，您指定了 GitHub 将有效负载发送到的端点)。
- 验证有效载荷来自 GitHub(由脚本中的 verify_webhook 函数说明)。
- 如果需要，可以使用 GitHub API(您在第 2 步中学到的)来响应有效负载。
- 将您收到的适当数据和反馈记录到数据库中，以便于模型再训练。
实现这一点的一个很好的方法是使用像 Flask 这样的框架和像 SQLAlchemy 这样的数据库接口。如果您已经熟悉 flask，下面是当 GitHub 通知某个问题已经打开时应用预测问题标签的代码的截断版本:
This code is also available here.
如果您不熟悉 Flask 或 SQLAchemy，也不用担心。你可以从这个精彩的 MOOC on Flask、HTML、CSS 和 Javascript 中了解到关于这个主题你需要知道的一切。如果你是一个数据科学家，这个课程是一个很大的时间投资，因为这将允许你以一种轻量级的方式为你的数据产品构建接口。我们参加了这个课程，并对它印象深刻。
我们把它作为一个练习，让读者在 GitHub 库中浏览剩余的 flask 代码。
收集明确的用户反馈。
This screenshot was taken from this issue.
如上所述，明确的反馈是通过要求用户做出反应来请求的👍或者👎一个预言。我们可以将这些反应存储在数据库中，这样我们就可以重新训练和调试我们的模型。这可能是作为 GitHub 应用程序发布数据产品的最令人兴奋和最重要的方面之一！
你可以在我们应用的主页上看到更多预测和用户反馈的例子。例如，这是 kubeflow/kubeflow 回购的页面:
Link to this page.
请安装我们的应用程序，它是免费的！
如果你喜欢你到目前为止读到的内容，并希望支持这个项目，请在你的公共存储库安装这个应用程序(即使安装在那里，这个应用程序也不会对私人回购做出预测)，并在它做出预测时给我们的机器人反馈👍 👎。
这里是安装我们 app 的链接。
结论:构建自己的机器学习应用的技巧
- 不要害怕使用公共数据集。除了标签问题之外，您还可以做更多的事情(参见参考资料一节获得一些想法)。
- 不要害怕快速迭代，即使解决方案并不完美。构建模型有时是项目中最小的组成部分，获得用户反馈是非常有价值的，所以你不要浪费时间。
- 尝试咨询至少一个真实的客户或用户，并让他们指导和验证决策。
- 利用机会收集明确的用户反馈。这将允许您快速改进您的解决方案和模型。
第二部分和后续步骤
我们没有涉及的一个方面是如何大规模地为你的应用服务。当您刚刚起步时，您可能不需要担心这一点，并且可以通过您最喜欢的云提供商在一台服务器上提供这一服务。您也可以使用 Heroku 之类的服务，这将在下面参考资料部分链接的 Flask 课程中介绍。
在第二部分中，我们将讨论以下内容:
- 如何在 Kubernetees 上部署您的 Flask 应用程序，以便它可以扩展到许多用户。
- 使用 Argo 管道管理模型训练和服务管道。
我们相信有很多机会来改进我们在这篇文章中阐述的方法。我们想到的一些想法是:
- 构造更好的标签和不属于标签集的项目的负样本。
- 使用来自 fastai 的工具探索最先进的架构，例如多头注意力。
- 在大型语料库上进行预训练，并在 GitHub 问题上进行微调，以使用户能够预测特定于回购的标签，而不是一小组全球标签。
- 使用额外的数据，比如关于存储库的信息或者打开问题的用户，也许学习这些实体的嵌入。
- 允许用户自定义标签阈值和标签名称，以及选择要预测的标签。
资源
- 我们 app 的网站。
- 我们 app 的安装页面。
- GitHub 储存库包含所有这些代码。
- 需要灵感来开发其他可以使用机器学习和公共 GitHub 数据集构建的数据产品吗？看这些例子:(1) GitHub 问题摘要(2)自然语言语义代码搜索。
- 堆栈交换提供的公共数据可能对迁移学习有用。最近利用这些数据的一个很酷的机器学习项目是 stackroboflow.com。
- 源代码上的机器学习，将机器学习应用于代码的文献综述，作者米尔托斯·阿拉玛尼斯。
- 关于烧瓶的优秀课程: HarvardX CS50 Web 。
- MOOCs 由 fastai 进行机器学习和深度学习。
- 我们的 repo 和相关教程中的代码假定您熟悉 Docker。这篇博客文章为数据科学家提供了 Docker 的简单介绍。
- Kubeflow 项目包含了我们将在这篇博文的第 2 部分使用的资源。此外，这篇博文的内容将成为 2019 年 4 月 17 日即将到来的演讲的主题。
取得联系！
我们希望你喜欢这篇博文。请随时与我们联系:
- 哈默尔·侯赛因
- 米哈尔·贾斯特日斯基
- 杰里米·路易
放弃
本文中提出的任何想法或观点都是我们自己的。提出的任何想法或技术不一定预示任何公司的未来产品。这个博客的目的只是为了教育。
最大似然估计、映射和贝叶斯推理
通过关注与最大似然法和映射的区别，掌握贝叶斯推理的思想
Photo by Aysha Begum on Unsplash
最大似然法、映射和贝叶斯推断是推断观测数据背后的概率分布特性的方法。话虽如此，MLE/MAP 和贝叶斯推断还是有很大区别的。
在本文中，我将通过关注 MLE/MAP 和贝叶斯推理之间的差异来介绍贝叶斯推理。
**注:**本文假设了 MLE 和 MAP 的初步知识。如果你不熟悉这些方法，请参考下面的文章。
以足球为例获得最大似然法和地图的直觉
towardsdatascience.com](/a-gentle-introduction-to-maximum-likelihood-estimation-and-maximum-a-posteriori-estimation-d7c318f9d22d)
最大似然估计和贝叶斯推理的区别
让我们从 MLE 和 MAP 的重述开始。
给定观测数据 D ，MLE 和 MAP 对概率模型参数 θ 的估计如下。
MLE 给出了使可能性最大的值 P(D|θ) 。MAP 给出了使后验概率最大化的值 P(θ|D) 。由于两种方法都给你一个固定值，它们被认为是点估计量。
另一方面，贝叶斯推理完全计算后验概率分布，如下式。因此，输出不是单个值，而是概率密度函数(当 θ 是连续变量时)或概率质量函数(当 θ 是离散变量时)。
这就是 MLE/MAP 和贝叶斯推断的区别。MLE 和 MAP 返回单个固定值，但贝叶斯推断返回概率密度(或质量)函数。
但是为什么我们甚至需要完全计算分布，当我们有 MLE 和 MAP 来确定 θ 的值时？要回答这个问题，让我们看看 MAP(和其他点估计器)不好用的情况。
地图(或一般意义上的点估计器)不能很好工作的情况
假设你在一个充满老虎机的赌场，赢的概率为 50% 。玩了一会儿后，你听到谣言说有一个特殊的吃角子老虎机有 67% 的获胜概率。现在，你正在观察人们玩两个可疑的吃角子老虎机(你确定其中一个是特殊的吃角子老虎机！)并得到了以下数据。
A 机:4 局 3 胜
B 机:121 局 81 胜
凭直觉，你会认为机 B 是特别的那一个。因为在机器上 4 次游戏中有 3 次获胜，所以可能只是偶然发生。但是机 B 的数据看起来不像是偶然发生的。
但是为了以防万一，您决定通过使用超参数 α=β=2 的 MAP 来估计这两台机器的获胜概率。(假设结果( k 在 n 次游戏中获胜)遵循二项式分布，吃角子老虎机的获胜概率 θ 作为其参数。)
公式和结果如下。
*甲机:(3+2–1)/(4+2+2–2)= 4/6 =*66.7% *乙机:(81+2–1)/(121+2+2–2)= 82/123 =*66.7%
与你的直觉不同，通过地图估算的两台机器的获胜概率 θ 完全相同。因此，通过地图，你不能确定哪一个是特殊的老虎机。
但是真的吗？难道看起来不明显的是机器 B 更有可能是特殊的一个吗？
贝叶斯推理
为了看看机器 A 和机器 B 之间是否真的没有区别，让我们全面计算后验概率分布，而不仅仅是地图估计。
在上述情况下，后验概率分布 P(θ|D) 计算如下。(详细的计算将在下一节介绍。)
A 机和B 机的 P(θ|D) 绘制如下。
虽然两种分布在 θ=0.666… 上都有其 模态 (这就是为什么它们的 MAP 估计值相同)，但是分布的形状却大不相同。在机 B 的分布中模式周围的密度远远高于机 A 的分布。这就是为什么你想计算完整的分布，而不仅仅是地图估计。
贝叶斯推理的计算
由于我们在上一节中跳过了对 P(θ|D) 的计算，所以我们在本节中来看看详细的计算过程。
地图和贝叶斯推理都是基于贝叶斯定理。贝叶斯推理和 MAP 的计算区别在于，在贝叶斯推理中，我们需要计算 P(D) 称为边际似然或证据。这是贝叶斯定理的分母，它确保 P(θ|D) 在所有可能的 θ 上的积分值*变为 1。(*若 θ 为离散变量，则为 P(θ|D) 之和。)
P(D) 是通过联合概率的边缘化得到的。当 θ 为连续变量时，公式如下。
考虑到链式法则，我们得到以下公式。
现在，把这个放到后验概率分布的原始公式中。下面计算是贝叶斯推理的目标。
让我们为上面的情况计算一下 P(θ|D) 。
从 P(D|θ) — 似然 —即给定参数 θ 时，观察到数据 D 的概率。上例中， D 为“4 局 3 胜”，参数 θ 为机 A 的获胜概率。由于我们假设胜数服从二项式分布，公式如下，其中 n 为匹配数， k 为胜数。
那么P(θ)—*θ—*的先验概率分布就是表达我们对 θ 的先验知识的概率分布。这里，对应于可能性 P(D|θ) 的概率分布，使用特定的概率分布。叫做共轭先验分布。
由于二项分布的共轭先验是贝塔分布，所以我们这里用贝塔分布来表示 P(θ) 。贝塔分布描述如下，其中 α 和 β 为超参数。
现在我们得到了*P(D |θ)P(θ)——*公式的分子——如下。
然后，P(D)——公式的分母——计算如下。注意 θ 的可能范围是 0 ≤ θ ≤ 1。
有了第一类欧拉积分，上面的公式可以变形为下面。
最后我们可以得到 P(θ|D) 如下。
预期后验概率
你可能已经注意到了，MAP 估计的是后验分布的 模 。但是我们也可以使用其他统计量进行点估计，比如θ|D 的 期望值 。使用 θ|D 的期望值的估计称为期望后验。
让我们用 EAP 估计一下 2 台机器的中奖概率。从上面的讨论来看，这种情况下的 P(θ|D) 低于*。*
因此，估计如下所述。
利用第一类欧拉积分和伽玛函数的定义，上述公式可以变形为以下公式。
因此，在超参数 α=β=2 下，EAP 对 2 台机器获胜概率的估计低于*。*
*甲机:(3+2)/(4+2+2)= 5/8 =*62.5% *乙机:(81+2)/(121+2+2)= 83/125 =*66.4%
结论
如上所述，贝叶斯推断比点估计(如 MLE 和 MAP)提供了更多的信息。然而，它也有一个缺点——积分计算的复杂性。本文中的情况非常简单，并且通过分析得到了解决，但是在现实世界的应用程序中并不总是这样。然后，我们需要使用 MCMC 或其他算法来代替直接积分计算。
希望这篇文章能帮助你理解贝叶斯推断。
最大似然估计与最大后验概率
机器学习和深度学习之旅
MLE 和 MAP 背后的数学，展示了这两种方法的联系和区别
Image by Author
最大似然估计(MLE)和最大后验估计(MAP)都用于估计分布的参数。MLE 也广泛用于估计机器学习模型的参数，包括朴素贝叶斯和逻辑回归。它如此普遍和受欢迎，以至于有时人们甚至在不太了解它的情况下使用 MLE。例如，当对数据集拟合正态分布时，人们可以立即计算样本均值和方差，并将其作为分布的参数。虽然最大似然法是一种非常流行的参数估计方法，但是它是否适用于所有的情况呢？MLE 是如何工作的？MLE 和 MAP 有什么联系和区别？这篇博客的目的就是要回答这些问题。
最大似然估计
MLE 的目标是推断似然函数p(X |θ)中的θ*。*
使用这个框架，首先我们需要导出对数似然函数，然后通过使关于θ的导数等于 0 或通过使用各种优化算法(如梯度下降)来最大化它。由于对偶，最大化对数似然函数等于最小化负对数似然。在机器学习中，最小化负对数似然是优选的。例如，它在逻辑回归中用作损失函数，交叉熵。
以抛硬币为例，更好的理解 MLE。例如，如果你掷一枚硬币 1000 次，有 700 个正面和 300 个反面。这枚硬币正面朝上的概率是多少？这是一枚公平的硬币吗？
首先，每次抛硬币都遵循伯努利分布，因此可能性可以写成:
在公式中， xi 表示单尾(0 或 1)，而 x 表示总头数。然后记录下可能性:
对数似然函数对 p 求导，则我们可以得到:
最后， p 的估计值为:
因此，在这个例子中，这个典型硬币的正面概率是 0.7。显然，这不是一枚公平的硬币。
根据大数定律，一系列伯努利试验的经验成功概率将收敛于理论概率。然而，如果你把这个硬币抛 10 次，有 7 个正面和 3 个反面。结论还成立吗？
即使 p(Head = 7| p=0.7) 大于 p(Head = 7| p=0.5) ，我们也不能忽视 p(Head) = 0.5 的可能性仍然存在。那就是 MLE(频率主义推理)的问题。它从不使用或给出假设的概率。
举一个更极端的例子，假设你掷硬币 5 次，结果都是正面。是不是就可以下结论 p(Head) =1？答案是否定的。这又引出了另一个问题。当样本容量较小时，极大似然估计的结论不可靠。
最大一条后路
回想一下，我们可以用贝叶斯法则把后验写成似然性和先验的乘积:
公式中， p(y|x) 为后验概率； p(x|y) 是似然性； p(y) 是先验概率 p(x) 是证据。
为了得到 MAP，我们可以用后验概率代替 MLE 中的似然性:
对比 MAP 和 MLE 的方程，我们可以看到唯一的区别就是 MAP 在公式中包含了先验，也就是说可能性是由 MAP 中的先验来加权的。
在先验服从均匀分布的特殊情况下，这意味着我们给*θ的所有可能值分配相等的权重。*在这种情况下，映射可以写成:
根据上面的公式，我们可以得出结论，当先验服从均匀分布时，最大似然估计是映射的一个特例。这就是地图和 MLE 的联系。
让我们回到前面的例子，抛一枚硬币 10 次，有 7 个正面和 3 个反面。本次应用 MAP 计算 p(头)。贝叶斯分析从选择一些先验概率值开始。这里我们列出三个假设，p(head)等于 0.5，0.6 或者 0.7。相应的先验概率等于 0.8、0.1 和 0.1。类似地，我们计算第 3 列中每个假设下的可能性。注意，列 5，后验，是列 4 的归一化。
在这种情况下，即使当 p(head)=0.7 时可能性达到最大，当 p(head)=0.5 时后验性达到最大，因为现在可能性被先验加权。通过使用 MAP， p(头) = 0.5。但是，如果改变第 2 列中的先验概率，我们可能会有不同的答案。因此，对 MAP(贝叶斯推理)的主要批评之一是，主观先验是主观的。
希望看完这篇博客，你清楚 MLE 和 MAP 的联系和区别，以及如何自己手动计算。在下一篇博客中，我将解释 MAP 如何应用于收缩方法，如套索和岭回归。如果你有兴趣，请阅读我的其他博客:
这一系列博客将从理论和实现两个方面对深度学习进行介绍。
medium.com](https://medium.com/@songyangdetang_41589/table-of-contents-689c8af0c731)
Mmmm 美食色情！使用自然语言处理的聚类和分类研究
介绍
作为一个美食爱好者和经常在 reddit 上冲浪的人，subreddit r/foodporn (一个发布美食图片的 reddit 论坛)似乎是我为一个使用自然语言处理(NLP)的无监督学习项目收集数据的好地方。
无监督学习是指我们事先不知道数据的潜在结构，并试图揭示这种结构。与之相反的是监督学习，在监督学习中，我们确实事先知道数据的结构，这些数据是以*标签的形式存在的。*通常，无监督学习包括基于数据点彼此的相似性对数据点进行分组/聚类。
我这个项目的目标是在 r/foodporn 上展示任何潜在的结构。进入这个项目，我有一种预感，如果我们把标题聚集在一起，我们会看到一个自然的烹饪结构。也就是说，我们会观察到日本食物群、意大利食物群等等。
数据收集和清理
我使用了 pushshift API 从 subreddit 中抓取了 48，000 个帖子。具体来说，我提取了过去 48 个月中每月排名前 1000 的帖子。以下是其中一个帖子的例子:
因为我只分析了文章标题，所以上面例子的数据是文本“熏火腿，山羊奶酪，小芝麻菜，番茄和意大利面”。
我从清理我的数据开始。这包括将所有单词小写，删除标点符号、表情符号和数字，以及过滤广告和非英语帖子。
经过清洗和过滤，我有 42，234 个标题可以玩。
矢量化
这里我要介绍一些行话，把一切放在 NLP 的语境中。每当我说“文档”时，我指的是一个 r/foodporn 标题的单独实例。当我说“文集”时，我指的是整个“文档”集合(我的标题的整个集合)。
在 NLP 中，我们必须将所有文档转换成数字向量，这样我们就可以对它们运行统计模型。有许多方法可以做到这一点。我选择的方法(也是最流行的方法之一)是 TF-IDF(词频——逆文档频率)。本质上，TF-IDF 在语料库中所有唯一单词的上下文中查看给定文档中的所有单词。如果一个术语在一个文档中出现多次，它就被认为是重要的。但是如果一个术语在语料库中出现多次，这就否定了它的重要性。
以“培根”为例。单词“bacon”经常出现在所有的标题中，所以如果我们在查看一个特定的标题时看到单词“bacon ”,这并不能使这个文档变得独特。TF-IDF 给“培根”的数字很低。TF-IDF 会给一个更稀有的词，比如“生鱼片”一个更高的数字。由于“生鱼片”是一个罕见的词，它比“培根”更能区分标题。你可以在这里阅读更多关于 TF-IDF 的信息。
每个文档的 TF-IDF 输出是一个向量，其长度等于语料库中唯一单词的数量。在我的例子中，有 20，857 个独特的单词。因此，在我的整个语料库上运行 TF-IDF 会得到一个 42，234 乘 20，857 的矩阵(文档数乘以唯一单词数)。
主题建模/聚类
我的文档以这种形式矢量化后，我终于可以对它们进行分组了！但是理想的组数应该是多少呢？为了找到答案，我反复对我的数据进行聚类(使用 K-Means )，增加我的聚类数，并绘制出与每个聚类数相关的剪影分数。在高层次上，轮廓分数是考虑到聚类的内聚和分离的度量。单个集群越密集，彼此之间的距离越远，效果越好。低轮廓分数反映了强聚类。
不出所料，随着我增加聚类数，轮廓得分会下降。但是看起来我们开始在 6 个集群附近达到收益递减点，所以我选择 6 个作为我理想的组数。
最后，我使用了一种称为 NMF(非负矩阵分解)的降维技术，将我的 42，234 个标题分成 6 组(在 NLP 项目的降维环境中，组正式称为“主题”)。NMF 的内部运作超出了这篇博客的范围，但是你可以在这里阅读更多关于 NMF 的内容。NMF 允许我们通过从单词空间到主题空间来降低矩阵的维度。在这种情况下，我们将一个 20，857 元素长的单词空格压缩成一个 6 元素长的主题空格。在这个过程中，我们丢失了一些信息，但是增加了可解释性。
通过模拟 6 个主题，我期望看到每个主题对应一种美食。
够了，别再说这些疯狂的数据科学巫术了。来看看成果吧！
结果
以下是 6 个话题中最重要的 10 个单词:
在我对我的主题建模之后，我检查了它们，看它们在我试图解决的问题的上下文中是否有意义。
看起来主题 1 是一系列经典的美国午餐配料，重点是脂肪和奶酪。我把这个题目命名为汉堡。
如果考察话题 2，显然和披萨/意大利菜有关。我把这种披萨命名为披萨。这个题目好具体啊！
话题 3 有点过了。单从这个话题的前 10 个词很难看出这个话题的本质是什么，所以我查看了前 30 个词，看到了像马萨拉、姜黄、馄饨和面条这样的词。我给它取名为亚洲融合。
话题 4 显然是一个甜点话题。就像披萨这个话题一样，我喜欢这个有多明显。
我将主题 5 命名为早餐，尽管可以说它的本质更像是健康三明治类型的配料。
最后，我将主题 6 命名为美国主菜。与其他话题相比，这个话题相当宽泛。
让我们使用 T-SNE 来想象标题如何落入不同的主题:
有意思。对于披萨、汉堡和亚洲融合主题(粉色、红色和蓝色)有很强的区分。美国主菜、甜点和早餐主题(黄色、绿色和紫色)都有一些不同的区域，但也在最大的“斑点”中明显混合。这意味着这些主题没有很好地相互分离。
在这些主题之上创建了一个分类器之后，我观察到这是真的。我的分类器将一个字符串作为输入，并将其转换为一个 6 长度的概率向量，对应于这里的 6 个主题。具有最高概率的主题是分类器的输出。你可以自己试试这里！
你会注意到分类器做出了一些好的预测和一些坏的预测。例如，它会正确地将“大黄派”、“鸡肉炒面”和“凤尾鱼和马苏里拉面包片”分类，但它认为“龙虾通心粉和奶酪”是汉堡，“意大利面”是亚洲融合。
结论
与我的预期相反，r/foodporn 标题主题并不完全属于美食类，但它们确实反映了帖子的潜在结构。一些群体很容易区分，而另一些则混杂在一起。
一些主题之间的混合反映了人们正在发布跨越多个主题的标题，对应于不容易归类的食物。鉴于当今美食界正在进行的大量烹饪融合和实验，这很有意义。今天的菜肴比以往任何时候都更难分类，因为它们越来越多地由来自世界各地的食材组成。
不混杂的话题也有意义。甜点之所以如此独特，是因为人们没有把“巧克力”和“排骨”混在一起，“馅饼”和“烤肉”混在一起，“饼干”和“洋葱”混在一起。同样，也有一些东西让披萨和汉堡与众不同。
感谢你阅读我的帖子，我希望你会觉得有趣！如有任何问题/意见，请随时联系我们。
项目代码: Github
项目 App: 美食分类器
关于我的更多信息: LinkedIn
使用 CNN 的 MNIST 数据集 Python 示例
https://www.pexels.com/photo/person-encoding-in-laptop-574071/
自动驾驶汽车普及只是时间问题。没有卷积神经网络，这项巨大的工程壮举是不可能实现的。卷积神经网络使用的算法比传统人工神经网络中使用的算法更适合视觉图像处理。卷积神经网络由卷积层和池层组成。
卷积层
卷积层利用了所有图像都可以按照 1s 和 0s 到进行编码的事实，创建特征图。特征检测器只是一个矩阵，它的值对应于图像的一个特征(即尖耳朵，狭缝眼睛……)。该矩阵覆盖图像的一部分，并对该位置的所有值执行逐位乘法。逐位乘法的结果被求和并放入特征图的相应位置。然后，它转移到图像的另一部分，并重复该过程，直到它遍历了整个图像。
汇集层
池很像卷积，只是我们不使用特征检测器。相反，我们使用最大池。最大汇集的过程包括在由窗口(nxn 矩阵)覆盖的特征图区域内取最大值，并将其放入汇集的特征图的相应位置。汇集是有用的，因为它减小了图像的大小，使得即使在空间方向上存在差异，也能更容易地计算和检测模式。
例如，假设数字 4 与猫的眼睛吻合。无论照片拍摄时猫的眼睛是直视相机还是偏向一侧，max pooling 可能仍然会得出相同的值。
这是足够的背景资料，对代码。前面的示例使用 Keras(一种高级 API)在 TensorFlow 中构建和训练模型。
import keras
from keras.datasets import fashion_mnist
from keras.layers import Dense, Activation, Flatten, Conv2D, MaxPooling2D
from keras.models import Sequential
from keras.utils import to_categorical
import numpy as np
import matplotlib.pyplot as plt
运行下面的代码行来导入我们的数据集。
(train_X,train_Y), (test_X,test_Y) = fashion_mnist.load_data()
时尚 MNIST 数据集包含 10 个类别的 70，000 幅灰度图像。这些图像以低分辨率(28 x 28 像素)显示了单件衣服，如下所示:
https://github.com/zalandoresearch/fashion-mnist
数据预处理
当使用卷积层作为我们模型的第一层时，我们需要将我们的数据整形为(n_images、x_shape、y_shape、channels)。你真正需要知道的是，对于灰度图像，你应该将channels 设置为 1，当你有一组 RGB 图像作为输入时，将channels 设置为 3。
train_X = train_X.reshape(-1, 28,28, 1)
test_X = test_X.reshape(-1, 28,28, 1)
负一与指定训练集中的图像总数相同。
train_X.shapeOut[00]: (60000, 28, 28, 1)
修改每个像素的值，使它们的范围从 0 到 1，将提高我们的模型学习的速度。
train_X = train_X.astype('float32')
test_X = test_X.astype('float32')train_X = train_X / 255
test_X = test_X / 255
我们的模型不能直接处理分类数据。因此，我们必须使用一个热编码。在一种热编码中，数字 0 到 9 被表示为一组 9 个 0 和一个 1。该数字由数字 1 的位置决定。例如，你可以将 3 表示为[0, 0, 0, 1, 0, 0, 0, 0, 0, 0]。
train_Y_one_hot = to_categorical(train_Y)
test_Y_one_hot = to_categorical(test_Y)
培养
我们的卷积层将有 64 个神经元(特征映射)和一个 3×3 特征检测器。反过来，我们的池层将使用具有 2x2 矩阵的最大池。卷积神经网络几乎总是由人工神经网络处理。在 Keras 中，Dense层实现了操作output = activation(dot(input, weight) + bias)。我们的人工神经网络的输入必须是一维的，因此我们预先将其展平。
model = Sequential()model.add(Conv2D(64, (3,3), input_shape=(28, 28, 1)))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2,2)))model.add(Conv2D(64, (3,3)))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2,2)))model.add(Flatten())
model.add(Dense(64))model.add(Dense(10))
model.add(Activation('softmax'))model.compile(loss=keras.losses.categorical_crossentropy, optimizer=keras.optimizers.Adam(),metrics=['accuracy'])
由于卷积神经网络中涉及的算法使用矩阵，您可以从在 GPU 上运行 TensorFlow 中受益匪浅。如果你使用 CPU 训练模型，我不建议超过 10 个历元，因为这需要一段时间。批量大小必须与进入第一个卷积层的图像数量相匹配。
model.fit(train_X, train_Y_one_hot, batch_size=64, epochs=10
到了第十个纪元，我们获得了 94%的准确度*，从各方面考虑，这确实是很好的。让我们看看我们的模型在分类新图像方面做得有多好。*
*test_loss, test_acc = model.evaluate(test_X, test_Y_one_hot)
print('Test loss', test_loss)
print('Test accuracy', test_acc)Out[]: Test loss 0.2947616615891457
Out[]: Test accuracy 0.9006*
正如你所看到的，基于测试的准确性，我们稍微过度拟合了我们的模型。
让我们来看看我们的模型做出的第一个预测。
*predictions = model.predict(test_X)
print(np.argmax(np.round(predictions[0])))Out[30]: 9*
数字 9 有一个匹配的类别Ankle boot。
运行以下代码将显示第一幅图像。
*plt.imshow(test_X[0].reshape(28, 28), cmap = plt.cm.binary)
plt.show()*
我们的模型正确地对测试数据集中的第一幅图像进行了分类。
基于卷积神经网络的 MNIST 手写数字分类
这篇文章的目标是使用 PyTorch 实现一个 CNN 来分类 MNIST 手写数字图像。
这篇文章是关于卷积神经网络(CNN)介绍的 2 部分系列文章的一部分。
第二部分— Pytorch 实现 CNN 对 MNIST 手写数字进行分类
本帖没有详细解释卷积层、最大池层、全连接层、脱落层等概念的工作原理。如果不熟悉，请阅读第 1 部分。
你可以在这里找到代码—https://github.com/iamkrut/MNIST_handwriting_classification
从这个页面可以得到 MNIST 手写数字数据库，它有 60，000 个样本的训练集和 10，000 个样本的测试集。这是从 NIST 可获得的更大集合的子集。数字已经过大小标准化，并在固定大小的图像中居中。
对于那些希望了解现实世界数据的各种模式识别方法，同时花费最少的精力进行预处理和格式化的人来说，这是一个很好的数据库。
获取 MNIST 数据集并准备训练、验证和测试数据加载器
我们可以从 NIST 网站下载数据集，但使用 PyTorch 提供的torchvision下的dataset API 更方便，它直接获取 MNIST 数据。
我们获取 NIST 提供的训练集和测试集。为了获取训练集，我们将参数train设置为True，而为了获取测试集，我们将其设置为False。dataset API 还允许我们处理我们想要应用于数据的任何转换。我们设置transform=transforms.Compose([transforms.ToTensor()]))将图像数据转换成张量。
mnist_trainset = datasets.MNIST(root='./data', train=True, download=True,
transform=transforms.Compose([transforms.ToTensor()]))mnist_testset = datasets.MNIST(root='./data', train=False, download=True, transform=transforms.Compose([transforms.ToTensor()]))
mnist_trainset的尺寸为 60000，mnist_testset的尺寸为 10000
然后，我们将测试数据集分成两组，一组用于验证，另一组用于测试。我们做 90%–10%的测试，即 9000 次用于验证，1000 次用于测试。我们使用torch.utils.data.random_split()函数来完成这项工作。
mnist_valset, mnist_testset = torch.utils.data.random_split(mnist_testset, [int(0.9 * len(mnist_testset)), int(0.1 * len(mnist_testset))])
之后，我们为所有三个集合准备数据加载器。DataLoader 基本上将数据集和采样器结合起来，并在给定的数据集上提供一个 iterable。
它还允许我们选择批量大小。批次大小是一个超参数，它定义了模型在更新内部模型参数之前查看的样本数量。这个概念被称为小批量梯度下降，因为模型对小批量数据进行处理以计算梯度，并根据梯度修改模型参数。我们选择train_dataloader的批量为 64，val_dataloader和test_dataloader的批量为 32。
train_dataloader = torch.utils.data.DataLoader(mnist_trainset, batch_size=64, shuffle=True)
val_dataloader = torch.utils.data.DataLoader(mnist_valset, batch_size=32, shuffle=False)
test_dataloader = torch.utils.data.DataLoader(mnist_testset, batch_size=32, shuffle=False)
可视化数据
开发深度学习模型的第一步是可视化数据。因此，让我们从列车组中绘制一些图像。
该图显示了数字图像及其顶部的标签。如果你把图像数据打印出来，你可以看到数值在 0 和 1 之间。所以不需要对图像数据进行归一化。
定义模型
我们将定义一个简单的卷积神经网络，它有两个卷积层，后面是两个完全连接的层。
下面是我们将用于 CNN 的模型架构。
Model Architecture
我们用 RelU 激活函数和 max-pool 层跟踪每个卷积层。RelU 引入了非线性，max-pooling 有助于消除噪声。
第一卷积层self.conv_1接收维度为 1 的通道，因为图像是灰度的。内核大小被选择为 3×3，步长为 1。该卷积的输出被设置为 32 个通道，这意味着它将使用 32 个核来提取 32 个特征图。我们用填充大小 1 填充图像，这样输入和输出维度是相同的。该层的输出尺寸将为32×28×28。
这就是我们如何定义self.conv_1层:
self.conv_1 = torch.nn.Conv2d(in_channels=1, out_channels=32, kernel_size=3, stride=1, padding=1)
我们对其应用 RelU 激活，然后是内核大小为 2、步距为 2 的最大池层。这将特征图向下采样到尺寸 32 x 14 x 14 。
这就是我们如何定义self.relu层:
self.relu = torch.nn.ReLU()
这就是我们如何定义self.max_pool2d层:
self.max_pool2d = torch.nn.MaxPool2d(kernel_size=2, stride=2)
第二卷积层self.conv_2将具有 32 的输入通道尺寸。我们选择输出通道大小为 64，这意味着它将提取 64 个特征图。这一层的内核大小为 3，步幅为 1。我们再次使用填充大小 1，以便输入和输出维度保持相同。该层的输出尺寸将为 64 x 7 x 7 。
这就是我们如何定义self.conv_2层:
self.conv_2 = torch.nn.Conv2d(in_channels=32, out_channels=64, kernel_size=3, stride=1, padding=1)
然后，我们用一个 RelU 激活和一个内核大小为 2、步幅为 2 的 max-pooling 层来跟进。下采样的特征图将具有尺寸64×7×7。
我们对此使用相同的定义self.relu和self.max_pool2d，因为self.relu是相同的操作，定义它两次没有意义。类似地self.max_pool2d也是相同的操作，因为它们使用相同的内核大小和步数。
最后，使用两个完全连接的层self.linear_1和self.linear_2。我们将把特征地图的展平版本传递给第一个完全连接的层。因此，它的尺寸必须是 64×7×7，等于 3136 个节点。该层将连接到另一个具有 128 个节点的全连接层。这将是我们的最后一层，所以输出的维度应该与总类相匹配，即 10 。因此，我们有两个完全连接的层，大小为 3136 x 128 ，后面是 128 x 10 。
该层self.linear_1和self.linear_2定义如下:
self.linear_1 = torch.nn.Linear(7 * 7 * 64, 128)
self.linear_2 = torch.nn.Linear(128, 10
由于我们想要丢弃两个线性层之间的连接以减少过拟合，我们定义self.dropout的连接丢弃概率为 0.5，如下所示:
self.dropout = torch.nn.Dropout(p=0.5)
以上所有的层和操作都是在类torch.nn.Module的 overridern __init__方法下定义的
def __init__(self):
super(Model, self).__init__()
self.conv_1 = torch.nn.Conv2d(in_channels=1, out_channels=32, kernel_size=3, stride=1, padding=1)
self.conv_2 = torch.nn.Conv2d(in_channels=32, out_channels=64, kernel_size=3, stride=1, padding=1)
self.max_pool2d = torch.nn.MaxPool2d(kernel_size=2, stride=2)
self.linear_1 = torch.nn.Linear(7 * 7 * 64, 128)
self.linear_2 = torch.nn.Linear(128, 10)
self.dropout = torch.nn.Dropout(p=0.5)
self.relu = torch.nn.ReLU()
接下来，我们通过覆盖类torch.nn.Module的forward方法来定义我们希望数据如何流经这些层
def forward(self, x):
x = self.conv_1(x)
x = self.relu(x)
x = self.max_pool2d(x)
x = self.conv_2(x)
x = self.relu(x)
x = self.max_pool2d(x)
x = x.reshape(x.size(0), -1)
x = self.linear_1(x)
x = self.relu(x)
x = self.dropout(x)
pred = self.linear_2(x)
return pred
定义模型对象、损失函数和优化器
我们定义了一个Model()类的实例，并将其命名为model
model = Model()
**损失标准:**损失函数告诉我们模型预测的好坏。由于我们正在处理多类分类，我们选择交叉熵作为我们的损失函数。我们使用结合了 softmax 函数nn.LogSoftmax()和nn.NLLLoss()损失函数的torch.nn.CrossEntropyLoss。
criterion = torch.nn.CrossEntropyLoss()
优化器:优化器通过响应损失标准的输出更新模型，将损失函数和模型参数联系在一起。我们将使用 Adam 作为优化器，其学习率为 0.001 。
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
培训和评估
我们将训练 100 个时期的模型，并挑选验证损失最低的模型。
训练循环
对于每个时期，我们使用 train_dataloader 上的枚举函数迭代通过 train_dataset 的批次。
首先，我们将模型设置为训练模式。这使我们能够启用 dropout 层，并在训练模式下设置模型。
model.train()
对于每一批，我们将该批图像张量传递到模型中，该模型将返回一个具有该批预测的张量。
pred = model(image)
得到预测后，我们将它们与它们的实际标签一起传递到交叉熵损失标准中，并计算损失。
loss = criterion(pred, label)
我们使用这个损失值进行反向传递，并使用 Adam optimizer 来修改模型参数。
loss.backward()
optimizer.step()
在每次迭代之前，我们需要将优化器梯度归零。
optimizer.zero_grad()
我们通过将每批迭代的所有损失相加，并通过迭代计数对其进行平均，来获得整个时期的训练损失。除此之外，我们还通过将损失值存储在列表train_loss中来跟踪每个时期的训练损失
这是整个循环的样子:
model.train()
# training
for itr, (image, label) in enumerate(train_dataloader):
if (torch.cuda.is_available()):
image = image.cuda()
label = label.cuda()
optimizer.zero_grad()
pred = model(image)
loss = criterion(pred, label)
total_train_loss += loss.item()
loss.backward()
optimizer.step()
total_train_loss = total_train_loss / (itr + 1)
train_loss.append(total_train_loss)
验证循环
对于训练循环之后的每个时期，我们进行验证循环，以查看该模型在验证集上的表现。
首先，我们将模型设置为评估模式
model.eval()
然后，我们使用 enumerate 函数迭代验证数据加载器中的每个批次。我们采取了与训练相似的步骤，但我们不会将失败反向传播。之后，我们将模型的预测与实际标签进行比较，并计算模型的准确性。与训练阶段类似，我们通过将每批迭代的所有损失相加，并通过迭代计数对其进行平均，来获得该时期的验证损失。我们通过将每个时期的损失值存储在val_loss中来跟踪每个时期的确认损失
整个循环如下所示:
for itr, (image, label) in enumerate(val_dataloader):
pred = model(image) loss = criterion(pred, label)
total_val_loss += loss.item()
pred = torch.nn.functional.softmax(pred, dim=1)
for i, p in enumerate(pred):
if label[i] == torch.max(p.data, 0)[1]:
total = total + 1
accuracy = total / len(mnist_valset)
total_val_loss = total_val_loss / (itr + 1)
我们绘制了每个时期的训练和验证损失，它们分别存储在列表train_loss和val_loss下。
fig=plt.figure(figsize=(20, 10))
plt.plot(np.arange(1, no_epochs+1), train_loss, label="Train loss")
plt.plot(np.arange(1, no_epochs+1), val_loss, label="Validation loss")
plt.xlabel('Loss')
plt.ylabel('Epochs')
plt.title("Loss Plots")
plt.legend(loc='upper right')
plt.show()
下面是训练和验证损失图
Loss plot
如所见，第 12 个时期具有最低的验证损失 0.02092566 和精度 0.99388889，之后模型开始过拟合并且验证损失激增。
培训日志如下所示:
Training dataset size: 60000
Validation dataset size: 9000
Testing dataset size: 1000Epoch: 1/100, Train Loss: 0.27790789, Val Loss: 0.04998713, Val Accuracy: 0.98311111
Saving the model state dictionary for Epoch: 1 with Validation loss: 0.04998713Epoch: 2/100, Train Loss: 0.09957011, Val Loss: 0.04592616, Val Accuracy: 0.98533333
Saving the model state dictionary for Epoch: 2 with Validation loss: 0.04592616Epoch: 3/100, Train Loss: 0.07494711, Val Loss: 0.03318010, Val Accuracy: 0.98900000
Saving the model state dictionary for Epoch: 3 with Validation loss: 0.03318010Epoch: 4/100, Train Loss: 0.06168462, Val Loss: 0.02777057, Val Accuracy: 0.99033333
Saving the model state dictionary for Epoch: 4 with Validation loss: 0.02777057Epoch: 5/100, Train Loss: 0.05156403, Val Loss: 0.02722912, Val Accuracy: 0.99100000
Saving the model state dictionary for Epoch: 5 with Validation loss: 0.02722912Epoch: 6/100, Train Loss: 0.04502778, Val Loss: 0.02404975, Val Accuracy: 0.99233333
Saving the model state dictionary for Epoch: 6 with Validation loss: 0.02404975Epoch: 7/100, Train Loss: 0.03968575, Val Loss: 0.02311387, Val Accuracy: 0.99211111
Saving the model state dictionary for Epoch: 7 with Validation loss: 0.02311387Epoch: 8/100, Train Loss: 0.03550077, Val Loss: 0.02516144, Val Accuracy: 0.99188889Epoch: 9/100, Train Loss: 0.02957717, Val Loss: 0.02641086, Val Accuracy: 0.99144444Epoch: 10/100, Train Loss: 0.02666702, Val Loss: 0.02112512, Val Accuracy: 0.99344444
Saving the model state dictionary for Epoch: 10 with Validation loss: 0.02112512Epoch: 11/100, Train Loss: 0.02564372, Val Loss: 0.02457329, Val Accuracy: 0.99266667Epoch: 12/100, Train Loss: 0.02233217, Val Loss: 0.02092566, Val Accuracy: 0.99388889
Saving the model state dictionary for Epoch: 12 with Validation loss: 0.02092566Epoch: 13/100, Train Loss: 0.02011606, Val Loss: 0.02414113, Val Accuracy: 0.99322222Epoch: 14/100, Train Loss: 0.02053968, Val Loss: 0.02243329, Val Accuracy: 0.99388889.
.
.Epoch: 99/100, Train Loss: 0.00538922, Val Loss: 0.05434694, Val Accuracy: 0.99366667Epoch: 100/100, Train Loss: 0.00425748, Val Loss: 0.06263806, Val Accuracy: 0.99288889
测试和可视化结果
我们为具有最低验证损失的模型获取保存的模型状态字典，并将其加载到我们的模型中。接下来，我们将模型设置为评估模式。
model.load_state_dict(torch.load("model.dth"))
model.eval()
我们通过测试数据加载器进行枚举，并以与验证循环相同的方式计算模型的准确性。我们还将结果存储在“结果”列表中。使用这个模型，我在测试集上获得了 0.99300000 的准确度。
results = list()
total = 0
for itr, (image, label) in enumerate(test_dataloader):
pred = model(image)
pred = torch.nn.functional.softmax(pred, dim=1)
for i, p in enumerate(pred):
if label[i] == torch.max(p.data, 0)[1]:
total = total + 1
results.append((image, torch.max(p.data, 0)[1]))
然后我们画出结果。
# visualize results
fig=plt.figure(figsize=(20, 10))
for i in range(1, 11):
img = transforms.ToPILImage(mode='L')(results[i] [0].squeeze(0).detach().cpu())
fig.add_subplot(2, 5, i)
plt.title(results[i][1].item())
plt.imshow(img)
plt.show()
预测标签显示在每个图像的上方。从结果可以看出，我们的模型预测得很好。
放弃
虽然这篇文章介绍了用 pytorch 实现 CNN 模型对 MNIST 手写数字进行分类，但这绝不是最好的实现。使用数据扩充、调整漏层、正则化、批量归一化、超参数调整可以进一步提高性能。等等。它的目标是那些试图进入计算机视觉领域并希望从某个地方开始的初学者。
2019 年世界移动通信大会:最新的人工智能进展
2019 年洛杉矶世界移动通信大会上一些最新人工智能进展的回顾。
(Source: https://www.iwsinc.com/events/2019/mobile-world-congress-americas-in-los-angeles-october-22-29-2019/)
介绍
今年 10 月，我有机会参加了在洛杉矶举行的 2019 年世界移动通信大会。在这篇文章中，我将概述一些最新的人工智能公告，以及 5G 网络将如何用于支持人工智能应用。
5G 人工智能驱动的应用
英伟达 EGX
NVIDIA 在世界移动通信大会上发布的最重要的公告之一是 EGX(边缘计算平台)。EGX 是一个高性能的云原生平台，旨在让公司以低延迟从远程位置快速传输数据。许多公司已经决定利用这个平台，一些例子是:沃尔玛，三星和宝马。
“我们已经进入了一个新时代，数十亿个永远在线的物联网传感器将通过 5G 连接起来，并由人工智能处理。”
—英伟达首席执行官黄仁勋
EGX 之所以成为可能，得益于三种主要技术的结合:人工智能、物联网和 5G。
- **物联网:**智能设备如今变得越来越普遍。行业通常使用物联网来远程利用数据，并使用收集的信息做出明智的决策。在工业应用中使用物联网设备的主要问题之一一直是需要实时快速捕获、处理和传输数据。如果这三个要求中的任何一个不能满足，那么我们的物联网设备将无法快速响应环境的变化并将异常情况报告回云。如果您有兴趣了解更多关于物联网设备工作原理的细节，请点击此处获取更多信息。
- **人工智能:**在物联网设备中使用 AI 来处理收集的数据。根据应用，捕获的数据可以是许多不同的形式。一些例子是:时间序列数据、摄像机记录和异常检测。在物联网应用中，充分利用运行我们的人工智能模型所需的内存和处理能力变得非常重要。因此，根据应用的不同，可以在本地(如果有隐私相关的问题)或在云上(使我们能够利用更先进的人工智能模型)执行我们的人工智能数据处理。
- 5G: 最后，5G 现在可以让我们持续加速物联网设备和云之间的通信。因此，这可以让我们在云上运行更复杂的应用程序，如在线游戏和增强/虚拟现实驱动的应用程序。
英伟达在世界移动通信大会上提供的应用示例之一是智能零售(图 1)。在本例中，摄像机网络用于实时跟踪顾客在购物时挑选购买的商品，持续提升顾客的零售体验。
Figure 1: NVIDIA Smart Retail [1]
此外，NVIDIA 还宣布了与微软的智能边缘计算新合作，将微软 Azure 服务与 NVIDIA EGX 集成在一起(图 2)。
“通过与英伟达合作，我们将 Azure 和 Azure AI 的力量带到了边缘，为我们的客户带来了突破性的体验。”
—微软首席执行官塞特亚·纳德拉
如果你有兴趣了解更多关于微软人工智能工具的信息，更多信息请点击这里。
Figure 2: NVIDIA CEO Jensen Huang 2019 Keynote
虚拟现实数据可视化
数据可视化是分析大量数据时非常重要的一步。执行数据可视化的一些主要好处是:
- 它可以帮助我们深入了解数据分布背后的动态。
- 深入了解我们的数据可以帮助我们建立更好的机器学习模型。
- 创建图表摘要可以让其他人更容易理解我们的数据调查。
在世界移动通信大会上，不同的公司推出了虚拟现实(VR)驱动的数据可视化工具(例如 Virtualitics 和 BadVR )。事实上，由于 5G，现在甚至可以更容易地直播重数据 VR 应用。
虚拟现实创造了一个完全人工的环境，用户可以完全沉浸其中。使用 VR 来可视化数据集可能会增强客户体验，并更好地理解数据集功能(特别是对于蛋白质折叠等医疗应用)。
特别是，Virtualitics 还可以使用其 Python API 与 Jupyter 笔记本集成(如下视频所示)，使每个人都可以创建 ar 数据可视化图表。
Video 1: Virtualitics Python API [2]
如果你正在寻找关于 AR/VR 编程的介绍，你可以在这是我以前的文章中找到更多关于它的信息。
希望您喜欢这篇文章，感谢您的阅读！
联系人
如果你想了解我最新的文章和项目，请通过媒体关注我，并订阅我的邮件列表。以下是我的一些联系人详细信息:
文献学
[1] TechRepublic，英伟达的智慧零售体验——梅西拜仁。访问:https://www . techrepublic . com/pictures/photos-everything-cool-at-mwc 19-los-Angeles/15/
[2]虚拟化— Python API，虚拟化 sVR。访问地点:https://www.youtube.com/watch?v=Hf6TlLfjZRA
移动数据、特征工程和层次聚类
美国拥有世界上最大的汽车市场之一，仅次于中国。截至 2017 年，美国道路上有 2.704 亿辆注册车辆，每年发生数百万起车祸。根据国家公路交通安全局的数据，2016 年美国警方报告的机动车碰撞事故估计有 700 万起。这导致 2016 年约 2.07 亿美元的碰撞损失。能够预测司机在未来几个月提出索赔的可能性，为保险公司提供了提前调整保费和计划条款的能力。
将预测分析应用于保险索赔并不是什么新鲜事，但是我们正在见证从传统的、静态的和一般的基于数据的模型(司机年龄、驾照年龄、汽车类型等)的转变。)到基于实际驾驶行为(突然刹车和其他种类的异常驾驶行为指标)的模型。
这种转变主要是由大数据框架的出现及其操纵和分析更大和更少结构化数据集的能力所驱动的。这导致一些公司开始通过使用保险公司安装在受保人汽车中的设备来收集与驾驶模式相关的数据。
特征工程
虽然存在许多设备来监控和记录汽车提供的数据，但新旧车型之间可用数据元素的质量存在很大差异。因此，在给定的保险公司的投资组合中，大部分收集的数据可能包含更少的信息，并且数据非常不均匀。在这种情况下，设计一组信息丰富的驱动程序特性来支持 ML 模型是一个真正的挑战；是时候超越直接数据进行思考了…
我们可处理的记录总数约为 1.23 亿条，仅代表 2000 人在从一个月到 18 个月的不同时间段内的旅行。
根据时间戳、坐标和速度，我们构建了加速度、常规行程(如果驾驶员总是停在相同的坐标，例如往返于工作场所，或者访问许多不同的地方相似的路线(如果采用相同的路线去那些地方，即驾驶员总是遵循相似的坐标序列，或者他的行为更随机，遵循不同的路线)。然后，我们查看车辆运行的时间段，以确定它是周末旅行型驾驶员、临时驾驶员还是高峰时间驾驶员*。*
另一件值得关注的事情是旅行时覆盖的区域,并解读司机有许多短途本地旅行和许多公里的长途“直线”旅行。这超出了通常的自动特征工程，并且需要移动性研究的概念，例如回转半径、覆盖的最大面积、基于熵的移动性可预测性等。当然，所有上述数量随后在不同的时间范围内(例如周、天、月)进行观察和总结(平均值、标准偏差、1、2、3 度的峰度…)来创建一组超过 500 个特征。
为了改进我们的建模，我们还通过使用公共 API，利用了在线提供的许多外部数据源。例如，我们包括日出/日落时间的信息，以确定夜间驾驶。公共气象机构提供(在西班牙，研究在西班牙进行，人们可以在 http://www.aemet.es/es/datos_abiertos/AEMET_OpenData 的访问此信息))访问地理上不同点的雨、风和温度的历史数据，我们也包括这些数据，以便模拟驾驶条件。
Openstreetmaps 提供了许多其他数据，包括一些道路在不同点的速度限制(尽管必须小心，因为它是一个公共贡献的数据库，因此必须检查数据的完整性)。与谷歌地图地理编码 API 和维基百科提供的数据一起使用，它允许确定道路的名称，以及它们是高速公路还是城市地区。所有这些数据都有助于建立一个更详细的司机档案，独立于汽车能够提供的数据。最后，包括来自汽车测量本身的特征和从公共数据构建的特征，我们构建了一组 1200 个特征，输入到我们的 ML 模型中。
熵
超越直接的移动性测量(距离、速度……)的一个方法是从人们的日常习惯来思考。也就是说，从一个物理领域的方法(你走了多少公里，以什么速度)走向一个象征领域的方法(你去了什么地方，多久……)。例如，两个人可以一天走 10 公里，但表现出非常不同的行为；例如，他们中的一个可能从家通勤到工作，而另一个去健身房，然后去工作，然后去他的孩子的学校，然后再回家。因此，这两个个体，尽管具有相同的物理域轮廓，却表现出非常不同的符号域轮廓。另一个例子是，两个人一天去 5 个不同的地方，其中一个人去完全相同的 5 个地方，而另一个人每天都去相同的两个地方，每天在另外三个地方之间交替。
这里的关键概念是个人的可预测性，或者说他的随机性。如果一个人在一天内访问了 5 个不同的地方，而第二个人只访问了 2 个地方，则第一个人更随机，因为他的运动历史包含更高的不确定性(如果必须猜测第一个人在哪里，猜对的可能性是 1/5=0.2，而另一个人是 1/2=0.5)。
现在的问题是，我们如何总结人类流动性的这些维度？在信息论领域，有一个概念可以很好地捕捉到一系列事件中的随机程度，这个概念就是熵。Shannon 熵考虑了事件在序列中的分布，并提供了一个代表“预期惊喜”或随机变量所包含的不确定性的值(在我们的例子中是访问位置的序列)。当随机变量的所有值具有相同的出现概率时，香农熵达到其最大值，也称为哈特利熵。
对于我们的模型，我们包括 Shannon 熵的原始值，并通过 Hartley 熵对每天、每周、工作日、周末和每月聚集的访问和停止点序列进行归一化(个体停止超过 30 分钟的点)。
分层聚类
在这个具体的问题中，能够用外部来源扩充数据集的一个关键点是能够过滤掉数据点的数量。事实上，如前所述，日志平均跨度超过一年，大约每 30 秒记录一次数据点(在最好的情况下)，这导致每个驾驶员有数百万个数据点。由于对不同 API 的调用次数和处理 HTTP 请求所需时间的限制，获取数据集中每个点的信息是不可行的。接下来的问题是如何选择获取这些信息的最佳点？
我们解决这个特殊问题的方法是通过集群。然而，存在各种各样的聚类算法，所以下一个问题是使用哪一个？
不用说，有 2000 名不同的司机，分散在西班牙各地，携带不同的数据收集设备，导致有不同的**位置历史，**聚类需要有意义。因此，使用依赖于预定义参数的算法是一个挑战，因为这些参数需要根据不同的情况进行调整。由于这个原因，我们放弃了简单的聚类技术，如 k-NN，因为我们无法知道最终的聚类数。基于密度的聚类算法也被丢弃，因为它们对超参数非常敏感。为了说明这一点，我们进行了一些测试，结果显示在下图中。在左图中，我们看到使用 HDBSCAN(一种基于密度的算法)对用户的行程进行聚类的结果，每个聚类的最小点数等于 2，最小距离等于 10，而在右图中，参数分别更改为 10 和 10。可以看出，对于这个特定的驾驶员和城市区域，结果之间存在巨大差异。因此，基于密度的算法被丢弃，因为它需要在每个场景中为每个驱动程序调整不同的参数集。
Results of clustering a single driver trip with HDBSCAN with two different parameter values
最后，我们转向了层次聚类。这一系列算法只需要集群中各点之间的最大距离来执行任务，我们将所有驾驶员的距离设置为 100 米，因为这是我们想要反映驾驶员行程的粒度。不需要设置其他参数，也不需要设置最终的聚类数或每个聚类的点数。在不同的层次聚类算法中，由于内存限制，我们只关注其中的两种:CLINK 和 SLINK。两者的主要区别在于如何计算聚类之间的距离:SLINK 测量两个前聚类的最近点之间的距离来决定是否合并它们，而 CLINK 测量最远点之间的距离。这样，CLINK 更适合我们的目的，因此我们可以确定没有两个点比阈值更远(使用 SLINK，两个合并聚类的最近点低于 100 m 的阈值，但是我们不知道两个聚类的其余点会发生什么，它们可能更远，从而覆盖具有不同速度限制或道路类型的不同街道或道路)。
下图说明了使用 CLINK 解决我们的问题可以获得的结果。左手边的图像表示特定驾驶员的聚类位置，而右手边的图像是具有所有收集位置的原始图像。可以看出，聚类允许我们在信息损失最小的情况下显著减少点的数量，因为仍然可以识别所有的行程和道路。
Clustering results using CLINK. Light colored points represent the original locations while the dark ones represent the clustered ones.
使用 CLINK 算法，我们可以对附近的点进行聚类，减少冗余，同时在城市级别(需要更近的数据点来描绘整个城市的位移)和公路级别(速度和加速度的变化不太频繁，允许在不损失准确性的情况下更大程度地消除冗余)保持不同的粒度。此外，我们在数据库中引入了空间索引，以便在司机之间高效地共享地理信息。这允许例如将道路类型和速度限制外推至具有非常相似坐标的驾驶员行程，这在某种意义上相当于不同驾驶员之间的聚类。
结论
从现实生活场景中成功获得预测分析的关键往往是数据，而不是算法的复杂性。它是关于创造性的，能够提取揭示数据复杂性的创新属性。只有到那时，建模算法才能充分挖掘数据的潜力，并提供最佳预测。
这项工作由高级数据科学家艾丽西亚·罗德里格斯和 GDSLINK 的首席数据科学家 Florian Lyonnet 完成。
模态系列# 1——如何从数据样本中估计整体模态
使用 numpy 和 scipy，通过 KDE 和优化来估计数据集的真实数据外模式。
courtesy of pixabay.com
当寻找数据集模式时，人们自然会使用 scipy.stats.mode 。但是，这将仅显示数据中最频繁的成员，即离散模式。这个值不一定是最可能的数据点，令人不安的是，我们的样本数据中可能没有这个值。
在这篇文章中，我们将看到一个简单的方法来估计这个值，假设一个连续的数据空间，和一个单峰分布。
我们来过:
1。KDE
2。内核方法考虑事项
3。带宽考虑因素
4。优化和方法
5。搜索空间边界、起点和约束
6。事实真相。讨论
请注意，如果您正在寻找一个多模态评估，它将单独发布。
1.KDE
核密度估计用于将数据概率插入密度函数。从 2013 年的 Jake Vander plas nice 帖子中可以看到各种 KDE 包的性能展示及其性能。在这篇文章中，我们将使用scipy . stats . Gaussian _ kde进行轻量级实现。
首先，我们需要考虑数据集的大小和维度，因为这种方法计算量很大。
2.内核方法注意事项
您可能已经注意到，高斯内核通常是许多实现中的默认内核。然而，如果您正在寻找对您的模态评估的更多控制，我推荐 scikit-learn 的密度估计。除了高斯核之外，它还有各种默认的核。此外，它允许各种距离度量。
3.带宽考虑
带宽大小对于 KDE 模式估计至关重要。不同的带宽可以用显著不同的值来估计相同数据的模式。这是由于我们数据中的局部密度。带宽越高，KDE 插值越光滑，信息量越少，反之亦然。
然后，我们希望处于一个最佳点，结合我们数据的概率密度的一个信息丰富而又圆滑的表示。谢天谢地，根据经验，我们可以在两个略有不同的函数中进行选择，它们是“Scott”和“Silverman”。
- Silverman —假设高斯分布
- Scott —假设正态分布数据
这两种方法在 scipy 中都是默认的。
当处理高度稀疏、偏斜或多模态数据时，应该通过局部密度持久性优化来调整带宽，我将在以后的帖子中介绍这一点。
同时，让我们假设一个有效的 ether a Scott 或 Silverman 因子的分布。
4.优化和方法
为了找到我们数据的模式，我们需要找到概率空间中的最大密度。同样，我们假设一个单峰分布，或者至少对突出的模式感兴趣。
如果怀疑多模态数据分布，局部优化器可能会将结果限制在局部模式。在这种情况下，我们应该使用全局优化器。请注意，全局优化器计算量更大。
在本文中，我们使用 SHGO 作为我们的全局优化器。
如果性能考虑很严格，那么切换到本地优化器。从 scipy.optimize 中选择一个适合您的用例。
KDEPDF的 argmax 也能给出很好的估算模式。在实现中，在第 6 节中，我们调用一个函数来做这件事，以便将其结果与估计的模式进行比较。它的签名是: mode_explicit()
局部优化的一个补充示例基于上述方法，并假设其起点 x0 为 PDF 的 argmax 。它的签名是:refined _ mode _ estimation()
我们对提出的每种方法进行计时和评级。代码下方的第 6 节给出了一个摘要。
5.搜索空间界限、起点和约束
为了搜索和运行时的效率，我们的搜索空间应该被智能地限制，并且起点应该被智能地选择。
理想情况下，可以从数据的先验知识中选择寻找模式的界限，例如，如果我们期望模式接近数据的最小值，我们可以说界限是:[min(数据)，median(数据)]。
如果没有先验知识，我们可以假设界限是值频率超过值频率平均值的极值，即:
Figure 1. closing in roughly on the distribution region of interest
至于优化的起点，即使优化器 API 可能规定它是可选的，先验知识总是有帮助的。如果您的数据在先前的粗略模式估计值附近足够密集，您可能希望使用样本模式作为 X0，即模式(数据)。如果不假设先验，一般的起始值可以是数据的中间值。
一些优化器允许结合线性和非线性的约束。如果您怀疑数据分布是多模态的，并且确定您所追求的模态在特定的约束空间内，这是一个重要的优势。这种约束可以定义为标准(多项式、指数、三角函数等)或自定义函数。
这篇文章将包含一个一阶多项式的简单约束例子。
6。真相
请注意，这个实现是针对一维特征数组的，即 shape = (N，)
进口、KDE 和模式估计函数:
现在，让我们绘制一些随机数据分布，看看每个模式估计器在哪里找到它的目标。
Figure 2. showing mode estimators results on the data distribution
打印输出:模式估计器发现的结果
实际模式为 0.5
模拟模式:0.555
模式 _ 显式模式:0.495
模式 _ 估计模式:0.49450735297344983
精确模式 _ 估计模式:0.494507269722724
看上面的图，提出的方法似乎有重叠，并且非常接近真实的分布模式。然后，我们希望看到这个测试在不同的数据上执行多次，并查看每种方法的统计数据。我们还可以很容易地检查每种方法的平均运行时间，以适应可用性。这是通过下面的代码完成的。
打印输出:每个估计器
————————
scipy _ mode _ error
平均运行时间:0.000201535701751709【秒】
—————————————————
————————
PDF _ mode _ error
平均运行时间:0.021175224542617797【秒】
———————————
MAE:0.027330000000000
——————————KDE _ 模式 _ 优化 _ 误差
平均运行时间:0.002447342872619629【秒】
————————————
平均运行时间:0.027139275371412374【平均运行时间
— — — — — — — —
精炼 _ mode _ 模式 _ 优化 _ 误差
平均运行时间:0.02179007077217102【秒】
———————————
平均运行时间:0.0273878963979849【平均运行时间
7.讨论
在模态系列的第一章中，我们处理一个单峰分布估计。KDE 是一个信息丰富的工具，我们可以用它来达到我们的目标，而且有不止一种方法。
我们使用一维数据来解释我们的技术，但是它适用于任何更高维度——考虑到 API 的限制。当然，维度越高，这个过程的计算量就越大。关于高维度的另一件事——它对内核带宽更敏感，这可能导致更稀疏的密度。一个很好的经验法则是使用标准的斯科特或西尔弗曼规则。**
你可能也会发现这些很有启发性
**[## Python 中的核密度估计
上周，迈克尔·莱纳发表了一篇关于直方图和核密度估计之间关系的精彩解释…
jakevdp.github.io](https://jakevdp.github.io/blog/2013/12/01/kernel-density-estimation/)** **[## 直方图和核密度估计 KDE 2
你可以在这里下载整篇文章作为 Jupyter 笔记本。众所周知，直方图是一种非常常见的方法…
mglerner.github.io](https://mglerner.github.io/posts/histograms-and-kernel-density-estimation-kde-2.html)** ** [## 模态测试和核密度估计
当处理大量可能具有不同数据分布的数据集时，我们面临着…
towardsdatascience.com](/modality-tests-and-kernel-density-estimations-3f349bb9e595)
本系列的下一步——基于 KDE 的多模态估计
我要感谢奥利·科恩 对我的宝贵评论、校对、编辑和评论。**
如何解决下一个回归问题
Photo by Campaign Creators on Unsplash
您的下一个回归模型要考虑的关键思想
汤姆·奥尔波特，杰米·王，杰克·斯塔尔福特
本文将介绍一些在构建回归模型时需要考虑的想法。为了生成适合您的数据的回归模型，您需要检查几个假设，并测试异常值和多重共线性。读完这篇文章后，你应该对如何实现一个合适的回归模型有一个更好的想法。
当在数据中寻找关系时，仅仅拟合回归并期望最好的结果是没有用的。为了使模型准确，线性回归有许多需要满足的假设。一些常见的假设是:
- 线性:因变量和预测变量之间存在线性关系。如果不存在线性关系，那么线性回归就是数据的不准确表示
- 无多重共线性:预测变量不在同一直线上，这意味着它们不高度相关
- 无自相关(时间上的序列相关):自相关是指一个变量在整个观测中与自身相关
- 同方差:残差中没有模式，意味着方差是常数
- 正态分布:残差、自变量和因变量必须正态分布
- 残差平均值为零，表示数据均匀分布在回归线上
数据集分布
线性回归模型的第一个假设是自变量或预测值(X)和因变量或结果(y)具有线性关系。
线性回归假设自变量和因变量是正态分布的，这可以用许多不同的方法来检验；最简单的方法是观察值的直方图。其他检验正态性的方法包括拟合优度检验、夏皮罗-维尔克检验，这些都是数值检验，或者生成 Q-Q 图来检验正态性。
有时，由于中心极限定理，30 或更大的样本量是确定正态性的阈值，该定理指出，当样本量至少为 30 时，添加独立且同分布的随机变量将导致正态分布，即使随机变量本身不是正态的。
然而，最小样本量没有真正正确的答案(许多人使用 50 + 8k，其中 k 是模型中参数的数量)。样本大小也是拟合度和时间/成本之间的权衡。没有足够的样本将导致回归线拟合不佳，但更多的样本需要投入时间和金钱来收集数据。
然而，预测变量和响应变量不一定是正态的。非正态分布的数据集可以通过对其应用变换来修复，以便使其正常。如果数据集由于异常值的存在而偏斜，那么这些点也必须被适当地处理以恢复正态性，这可以通过分布图来实现。
线性回归中的残差被假设为正态分布。非正态残差分布是数据集存在“错误”的主要统计指标，可能包括缺失变量或非正态自变量/因变量。
此外，还假设残差方差是同方差的；假设残差具有恒定的方差。这很重要，因为它证明了误差是均匀分布的，这意味着线性回归是数据集中所有点的“最佳”拟合。异常值会影响残差的正态性，因为每个数据点都会将直线移向异常值。因此，查看残差是线性回归线拟合程度的最佳指标，如果有任何正态性问题，我们应该做些什么来修复它。
极端值
离群值是数据集中不遵循该数据集预期趋势的点。异常值有能力改变回归的斜率。对于线性回归，斜率的这种变化会对输出产生影响，因为变量的影响已被点扭曲。
当考虑异常值时，我们需要考虑它们的影响，这是由点的杠杆和残差决定的。杠杆是该点离数据集中心的距离，该点离中心越远，杠杆越高，是一个介于 0 和 1 之间的数字。
Points with low leverage
Point on far right has high leverage
看上面的图，我们可以看到，图 1 中最右边的点比图 2 中最右边的点具有更小的杠杆作用，因为离这些点的中心的距离更大。
为了查看某个点是否是异常值，我们还检查了该点的残差值。残差被定义为数据集中每个点距离真实值的距离。
然而，这些值因数据而异，解释学生化(标准化)残差可能更容易。
影响是点对回归斜率的影响。具有高杠杆的点有可能对回归的斜率有更大的影响。考虑两个人坐在跷跷板上，这个人坐得离中心越远，就越容易在跷跷板上上下移动，但是这个人的质量也很重要。数据集的大小也会影响离群值的影响，数据集越大，离群值的影响就越小。计算点影响的常用方法是库克距离。
一旦你确定数据集中有异常值，有几种方法可以有效地处理它们。第一个选项是从数据集中移除点。这有利于完全消除该点的影响。但是，如果数据集很小或该点具有高杠杆作用，则应考虑替代方法，因为它也可能将偏差引入回归，并在数据中找到错误的关系。另一种方法是给点分配一个新值，比如相似值的平均值，这就是所谓的插补。这种方法通常在已知值不正确的情况下使用，在使用的数据集很小的情况下非常有用，因为它不会删除值。另一种方法是转换整个数据集，而不是使用记录的值。当已知异常值是该点的真实值并且该点具有高杠杆时，这可能是有用的。
诊断图
诊断图通常以 4 种不同的方式绘制残差趋势，对于验证是否满足线性回归的假设非常有用。在本节中，我们将介绍每个情节。
残差与拟合图
残差与拟合图主要用于检查自变量和因变量之间的关系确实是线性的。良好的残差与拟合图在水平线周围具有相当随机的残差散布，这表明该模型充分解释了线性关系。
在上图中，案例 1 是一个“好”模型的好例子，因为通过点的线接近水平。案例 2 显然是一个抛物线拱，这表明自变量和因变量之间还有一些其他的关系没有被探究。
正常 Q-Q 图
正态 Q-Q 图检查残差的正态性。假设一个好的线性回归模型的主要假设之一是残差的正态性，这个图可以告诉我们很多变量之间的关系，如前所述。一个“好的”线性回归模型会有接近虚线的残差，就像案例 1 一样。显然，情况 2 有明显的问题，因为残差不遵循线性模式，而是指数模式。
比例位置图
也称为分布位置图，比例位置图检查残差的同方差。如前所述，验证残差的方差保持不变可确保生成良好的线性回归模型。一个“好”的模型将在一条水平线周围随机散布，表明方差保持不变。情况 1 是一个很好的例子，而情况 2 表明，随着点慢慢变得更远，残差的方差逐渐增加。
残差与杠杆图
残差与杠杆图允许我们找到显著影响线性回归线的情况。为此，该图生成一条指示库克距离的线，库克距离被定义为当从回归模型中移除一个观察值时回归模型中所有变化的总和。库克距离之外的任何一点都被认为是有影响的。库克距离的一般临界值是 0.5。一个点的库克距离得分越大，对回归线的影响越大。这种方法非常善于识别异常值和杠杆点。
在查看该图时，我们只想删除位于库克距离之外的任何数据点。例如，在情况 1 中，在指示库克距离的虚线之外没有点，因此不需要移除任何异常值或利用点。然而，在情况 2 中，有一个数据点远在库克的距离阈值之外，表明它是一个高影响点，应该被处理。
多重共线性
关于线性回归模型的一个大假设是我们的预测变量是独立的。这意味着每个预测变量不依赖于任何其他自变量。只有响应变量会这样做，这就是为什么它也被称为因变量。
然而，假设我们有一个模型，我们绘制两个预测值的图表:
这些变量看起来并不独立，但我们假设它们是独立的。所以我们的假设没有实现。当两个或多个我们假设独立的变量实际上相互依赖时，我们就有多重共线性。
多重共线性主要有两种类型。一种叫做“结构多重共线性”。这是我们在旧的预测变量的基础上建立新的预测变量的时候。一个常见的例子是从 X 中得到一个预测变量 X，很明显 X 和 X 是相关的，那么我们如何解决这个问题呢？一种方法是从模型中去掉 X。但是有些二次模型需要这个平方分量。所以我们做了一件事叫做集中预测。为了确定预测值的中心，我们找到 X 的平均值，并从我们的观测值中减去它。这导致大约一半的观察值为负值，但是当我们对 X 求平方时，我们仍然会得到正值。所以现在 X 对 X 的图形是抛物线的形状，降低了两个预测值之间的 R。
多重共线性更常见的形式称为“基于数据的多重共线性”。当看似不相关的变量相关时，就会发生这种情况。在第一种形式的多重共线性中，X 与 X 相关，因为它是 X 的函数。但是，如果我们期望独立的变量(如脉搏和体表面积)相关，则我们有基于数据的多重共线性。这种类型是最常见和最有问题的，发生这种情况有两个主要原因。一种是当收集数据的人仅仅依赖观察数据，而不是混合观察数据和实验数据。另一种更广泛的情况发生在设计不良的实验中，这意味着研究人员收集数据的方式使得某些变量可能会相互影响。
我们知道什么是多重共线性，但是为什么这对我们的模型来说是个问题呢？假设我们试图用变量 X₁、X₂和 X₃.来预测 y
如果我们只基于 X₁和 X₂建立一个模型，我们得到 y = 4 + X₁+ 3X₂.相反，如果我们基于 X₁和 X₃建立一个模型，我们得到 y = 5–5x₁+7x₃.注意到系数是如何变化的吗？这些模型仍然准确地预测 y，但是它们以一种非常不同的方式进行。所以多重共线性给你的模型带来的主要缺陷是一个变量的影响不能被孤立。更确切地说，多重共线性不影响模型的准确性，它使得很难找到一个变量的影响。在我们的第一个模型中，X₁增加一个单位导致 y 增加一个单位，但是我们的第二个模型中，X₁增加一个单位导致 y 减少 5 个单位。因此，如果您的目标只是建立一个模型来预测某件事，多重共线性可以忽略不计。但是，如果您想要了解每个变量对因变量的影响，就需要解决多重共线性问题。
我们知道什么是多重共线性，以及它如何影响我们的模型，但是我们如何检测它呢？一种方法是绘制每个变量之间的相关系数图，并寻找高的相关系数。但是这种方法假设一个变量只能依赖于另一个变量。如果多个预测因子之间存在更复杂的关系，比如 X₁= 2X₂ + 3X₃，会怎么样？检测多重共线性的一种更好的方法是称为方差膨胀因子(VIFs)的方法。
如果存在多重共线性，每个模型之间的系数会有很大差异。如果一个模型只有一个自变量，那么该变量系数的方差最小，它被称为基线方差。如果我们将那个独立变量与所有其他独立变量进行回归，就可以创建另一个模型。这个模型会有一定的 R 值。可以看出，基线方差增加了一个因子，该因子由包含该大回归的 R 的方程给出。
这被称为 VIF，它可以针对每个独立变量进行计算。小于 4 的 VIF 被认为是好的:假设该变量没有多重共线性。介于 4 和 10 之间的 VIF 表明变量之间可能存在多重共线性，可能需要进行一些调查。高于 10 的 VIF 是模型中变量间多重共线性的强有力指标。
这些 Vif 可用于校正多重共线性。做到这一点的一个方法是去除一些具有高 VIF 的预测值。如果这些变量只是因为我们有科学理由让它们留在那里而不能被移除，我们仍然有一些选择。我们可以为高 VIF 的预测者收集更多的数据，然后根据这个新的更完整的数据集重建波动率指数。如果这仍然不能改变它，那么我们将不得不删除一些变量。
结论
现在，我们已经看到了在拟合回归模型时应该考虑的几种方法，它们将有助于提高模型的性能。
关键词汇
残差、拟合值、QQ 图、多重共线性、样本大小、杠杆、影响、异常值、库克距离、VIF
模型平均:一种处理模型不确定性的稳健方法
模型平均的介绍，使机器学习预测对模型条件较差的数据不太敏感。
Everyone is working individually, then through consensus amongst them, they are coming up with better work. Photo by You X Ventures on Unsplash
在我们的机器学习模型中，我们试图根据描述符值来映射预测器，以模拟生成该值的底层函数。然而，如果我们的数据不能很好地代表数据的真实分布，那么我们的模型将不会像我们希望的那样有效，这是由于对不良数据的限制。例如，一个简单的线性回归模型的参数(如斜率和截距)取决于我们用来拟合模型的数据。因此，我们的模型的通用性很差。
当模型的不确定性很高并且会干扰预测的质量时，如何建立稳健的预测模型？解决这个问题的一个方法是在许多模型之间达成共识。这个想法是，当我们试图建立预测模型时，一些模型将正好适合预测点，而一些将高估或低估。通过对所有模型进行平均，我们可以消除高估和低估。特别是在大量模型的限制下，我们可以应用中心趋势定律，该定律指出，随着数值越来越多，概率分布接近中心平均值。因此，如果我们可以建立许多模型，并对它们取平均值，我们可以预期最终的预测比单个的预测更稳健。在本练习中，我们将看到这种近似有多好。
整体大于各部分之和。
像往常一样，我们首先加载数据。在这个练习中，我们将使用 sklearn.datasets. 中的波士顿住房数据
Loading the Boston data and splitting it into training and testing dataframe
现在，为了实现模型平均，我们将使用 RMSE(均方根误差)作为模型拟合度。然后我们将使用以下公式对它们进行平均，
Model averaging formula
这里，我们将用模型 i 的平方 RMSE 的倒数来加权模型 i 的预测 y。现在，让我们写一个类来简化我们的工作，
Model averager class
在上面的代码中，我们可以使用任何估计器，比如 KernelRidge 等等，但是我使用了简单的 LinearRegressor ，因为它在计算上更便宜。此外，我使用样本方差来计算 RMSE，但如果我们想要近似总体方差，我们可以使用留一估计，这也是计算密集型的。现在，我们有一个代码来完成模型平均。让我们在数据上实现它，
Compiling model data and then making a prediction on test data
在这里，我们首先建立所有的模型，然后根据我们的测试数据进行预测。现在，让我们看看我们的模型平均性能有多好:
Script to plot the histogram of the RMSE value of different models
运行这个脚本将产生下面的图，
Histogram of all the model RMSE and model averager RMSE
我们可以看到，我们的模型平均性能，正如预期的那样，位于所有其他模型的中间。有不同的方法来提高模型平均器的性能，例如我使用的方案可以改进，我们可以对几个最好的模型进行平均，而不是对所有的模型进行平均(我打算在以后的文章中讨论这些)。虽然性能似乎不如我们所希望的那样令人兴奋，但是这种方案对于模型的不确定性将是非常鲁棒的(以可以忽略的精度为代价)。
基于模型的特征重要性
从模型参数中提取重要特征的技术
在之前的一篇文章中，我讨论了一种称为前向特征选择的模型不可知的特征选择技术，它基本上提取了所选 KPI 的最优值所需的最重要的特征。但是它有一个警告——很大的时间复杂度。为了避免这个问题，可以从被训练的模型中直接获得特征重要性。在这篇文章中，我将考虑 2 个分类和 1 个回归算法来详细解释基于模型的特征的重要性。
逻辑回归
这是一种固有的二进制分类算法，它试图在 k 维空间中找到分隔两个类别的最佳超平面，从而最小化逻辑损失。
Logistic loss expression
k 维权重向量可用于获得特征重要性。w_j 的大正值表示第 j 个特征在正类预测中的较高重要性。较大的负值表示负类预测的重要性较高。这从物流损耗的表述就可以看出来。SGD 通过为在预测数据点属于正类和负类时更重要的特征设置学习大的正权重来减少损失。
为了说明上述概念，让我们尝试从具有 9 个属性的玻璃识别数据集中提取前 4 个特征，即
- 折射率
- % Na 含量
- %毫克含量
- 铝含量%
- 硅含量%
- % K 含量
- %钙含量
- % Ba 含量
- 铁含量%
都是实值的。完整的代码可以在这里找到。
目标是根据上述特征，从 7 个类别中预测玻璃的类型。为了使事情简单易懂，只选择了属于 2 类的点。这给我们留下了一个二元分类问题，使得逻辑回归成为解决这个问题的理想选择。
最终数据集有 146 个点，每个点有 9 个属性。目的是预测给定的玻璃成分是浮法加工的还是非浮法加工的。EDA 揭示了特征之间的比例差异，因此最小-最大比例用于挤压区间[0，1]中的所有特征值。
接下来，使用 C 上的网格搜索来搜索最佳超参数(该术语乘以逻辑损失，在此处找到更多)。最好的超参数提供 0.54 的对数损失和大约 70%的准确度。考虑到我们仅有的少量数据，这还不错。
为了方便起见，这里列举了使用 SGD 学习的参数发现的最重要的特征。
随机森林分类器
随机森林是一个使用决策树作为基础学习器的集成模型。基础学习者是高方差、低偏差的模型。通过汇总所有基础学习者做出的决策来预测响应变量，减少了整个模型的方差。这个想法是为了确保每个基础学习者学习数据的不同方面。这是通过行和列采样实现的。在分类设置中，聚合是通过采取多数表决来完成的。
在决策树的每个节点，基于信息增益(例如)或计算成本更低的基尼系数杂质减少来决定用于分割数据集的特征。将 I.G .最大化(或 Gini 杂质减少)的特征被选择作为分裂特征。然后根据分割特征的值将数据分割到其子代中。如果要素是分类的，则属于分割要素的每个类别的数据都将归属于一个单独的子要素。在数字特征的情况下，该特征的最佳阈值(用于决定将该特征用作分割特征的阈值)用于将数据分割成两部分，每部分归一个子代。
f_j is chosen as splitting feature
由于某个特征在决策树的所有级别上相加而得到的信息增益决定了该特征的重要性。这也可以从这样的事实中看出，在每个节点上，在最大化信息增益的特征上进行分裂。
随机森林包括多个决策树，因此特征 j 的特征重要性是由特征 j 在所有树上产生的 I.G .的归一化和。让我们回到玻璃识别数据集，看看随机森林认为哪些特征是重要的。
在解决这个任务时，随机森林的表现明显优于逻辑回归。它给出了 90%以上的准确性和 0.22 对数损失。Scikit-learn 的随机森林模型有一个 feature_importance_ attribute，它给出了由每个特征在所有级别上导致的基尼系数杂质减少值，该值在所有树之间进行了标准化。这里唯一感兴趣的超参数是基础学习者的数量。执行网格搜索，给出 33 个基础学习者作为最佳值。随机森林很少过度适应，通常，它们会随着基础学习者数量的增加而饱和，增加计算开销而不降低性能。这里总结了结果。
贝叶斯线性模型
首先简单介绍一下贝叶斯模型，以及它们与常用的传统机器学习模型(也称为频繁模型)的区别，如 KNN、逻辑回归、SVM、决策树等。我们大多数人都习惯于这样
Inference using frequentist model
贝叶斯模型不是对给定的输入预测 1 个输出，而是给出一个分布，从中可以对输出进行采样。贝叶斯模型通过给出响应变量的概率分布来显示其不确定性。通常，响应变量被建模为高斯型。
Inference using Bayesian model
这里 β (模型参数或权重向量)也是从分布中采样的——每个参数一个。如这里的所述，目标是在给定输入 X 和输出 y 的情况下，确定模型参数的后验概率分布
Courtesy: Will Koehrsen
后验概率分布是通过使用像马尔可夫链蒙特卡罗 (MCMC)这样的采样方法进行采样来估计的。随着更多样本的抽取，估计值收敛到真实值。
从后验分布获得的模型参数的平均值可用于对它们进行点估计，进而对响应变量的正态分布的平均值进行点估计。响应变量本身可以用它的平均值来估计。这些估计的确定性取决于个体分布，并随着输入模型的数据量的增加而增加。模型权重可以用类似于线性回归或逻辑回归的方式来解释。特征权重的绝对值越高，其重要性越大。在两个或更多特征具有相似权重的情况下，其值如其分布所指示的那样更确定的特征应当被给予更高的重要性，因为模型对其值比对其他特征更有信心。
使用上述见解，让我们检查在给定一堆关于电子设备的信息的情况下，哪些特征对于预测电子设备的公布评级更重要。数据集可以在这里找到。使用 2 条链和 2000 次后验抽取，获得以下分布
由于数据非常少(167 个训练点),我们有一个高标准偏差，显示出高模型不确定性。随着数据的增加，也就是说，随着我们收集更多的证据，模型估计值会提高，并最终超过先验值，在这种情况下，假设先验值为高斯型。对于无限数据，贝叶斯模型收敛于 frequentist。平均权重值用于获取特征重要性。
这个帖子到此为止。请在评论区告诉我其他提高功能重要性的好方法。下次见…再见。
来源
- https://towards data science . com/贝叶斯线性回归简介-e66e60791ea7
- https://towards data science . com/Bayesian-linear-regression-in-python-using-machine-learning-to-predict-student-grades-part-2-b 72059 A8 ac7e
- https://github . com/WillKoehrsen/Data-Analysis/blob/master/Bayesian _ lr/Bayesian % 20 linear % 20 regression % 20 project . ipynb
- https://wise odd . github . io/tech blog/2017/01/05/Bayesian-regression/
基于模型的策略优化
回顾基于模型的强化学习的最新进展。
简介
由于在 Atari 等视频游戏、Mujoco 等模拟机器人控制环境以及象棋、围棋和扑克等游戏中取得了一些惊人的成功，深度强化学习近年来获得了很大的声誉。大多数 RL 成功案例的一个显著特征是使用模拟环境，通过反复试验实现高效的数据生成。这一点非常重要，因为大多数先进的 RL 算法需要大量数据来实现其出色的性能，通常需要与环境进行数亿次交互，有时甚至数十亿次。
这种样本低效的一个关键原因是，大多数最先进的 RL 算法属于无模型家族，这意味着它们是非常通用的学习算法，假设没有环境或奖励函数的知识，使它们完全依赖于直接交互。这显然与我们人类学习执行任务的方式非常不同，因为我们可以在尝试执行任务之前，使用我们的经验来想象我们的行动和计划的结果。例如，当一个人试图走过潮湿的地板时，他可能会在第一步滑倒，但会迅速调整他的内部模型，即脚的位置和移动方向如何影响稳定性，并很可能在接下来的步骤中表现得更好。与无模型算法不同，我们不只是尝试不同的行走方式，并使用反馈(我们是否摔倒)来最终找出正确的方式。
但是，如果那些通用的无模型算法在这些困难的任务上工作得如此之好，为什么还要费心去做其他的事情呢？这是因为并不是所有的事情都可以容易可靠地模拟，在许多真实世界的用例中，我们的模拟不够精确，以至于我们无法在目标环境中部署使用它们训练的模型。这种情况的一个明显的例子是机器人控制和规划，因为即使简单的机器人系统也无法精确模拟，更不用说复杂的机器人系统了。但是，即使我们能够创建精确的模拟，这也可能是一项重大的任务，并且只适用于特定的机器人模型。弥合模拟机器人和真实机器人之间的差距是一个活跃的研究领域，我之前已经写过一些有趣的想法。
在这些环境中，我们没有可靠的模拟，或者运行模拟非常耗时或昂贵，我们不能希望使用需要与环境进行十亿次交互的学习算法，因为这将花费令人望而却步的时间量或不可接受的成本。看来我们可以从不同的范例中获益。
基于模型的规划
如果我们正在解决一个我们实际上知道模型或者有足够好的近似的问题呢？我们能利用这些知识做出更好的决定或学习更好的政策吗？这实际上是自动规划、组合优化和控制等领域中非常常见的情况。在许多控制应用中，由于特定问题的领域知识(通常以线性模型的形式)，我们可能有一个近似的动态分析模型，这允许我们使用模型预测控制(MPC)等技术提前进行规划。
在 MPC 中，我们提前计划一个固定的时间范围，使用我们的近似模型来“模拟”我们的系统由于我们采取的行动而转变到的状态。假设我们希望飞机遵循目标轨迹，我们可以使用我们使用我们的模型(具有可以随机选择的一些初始动作)推出的状态和目标轨迹中的状态之间的距离之和，并且获取成本函数关于动作的导数(因为成本函数和近似模型都是可微分的)，并且使用梯度下降最小化成本函数。在这种情况下，我们不是在学习一个策略(尽管如果我们愿意，我们可以尝试拟合一个模型来预测优化的操作)，而是使用我们的模型来计划。
另一种方法可以是使用我们已知的模型来学习策略，这种情况的一个非常著名的例子是 AlphaGo Zero (AGZ)。在 AlphaGo Zero 中，我们有一个完美的游戏模型；我们非常清楚给定一个动作时游戏棋盘的状态是如何变化的，并且可以在树搜索算法中使用这些知识，例如蒙特卡罗树搜索(MCTS)。
在 AlphaGo Zero 中，我们试图学习 MCTS 算法中使用的策略和价值函数，而 MCTS 搜索结果又被用来改进策略。这是可能的，因为我们可以“向前看”,并在实际采取行动之前，对我们的政策可能产生的后果进行推理。这一过程被证明是非常有效的，由此产生的系统可以通过从与自己的比赛中学习，在与世界上最强的选手的比赛中获得超人的表现。
基于模型的强化学习
如果我们甚至在不知道模型的问题中也能实现上述好处，那会怎么样？毕竟，环境模型是从一个状态-行动到下一个状态和回报的转移概率的函数映射，因此，也许我们可以从与环境的交互中学习该函数，并将学习到的模型应用于提前计划或生成大量的“模拟推出”以改进我们的政策，从而减少与真实系统的交互(这是昂贵的)。我们的代理可以与环境交互以收集真实数据，并使用监督学习方法来拟合转换函数和报酬的模型。一旦我们有了一个好的模型，我们就可以在部署期间使用它来执行类似 MPC 的规划，或者生成大量的虚拟训练数据来改进将在部署中使用的学习策略(在硬件受限或时间关键的应用中，避免实时规划可能是可取的)。
虽然这个想法看起来很直观，也很强大，但事情并没有这么简单。当试图在强化学习的环境中学习环境的模型时，出现了几个问题，这些问题导致了被称为基于模型的强化学习的整个研究领域。
复合误差
不可避免的是，学习到的模型不会非常精确，随着我们在时间上进一步传播我们学习到的模型，小错误会复合并快速增长。这些复合误差使得我们通过类似 MPC 的计划制定的任何计划和我们生成的任何虚构数据都不可靠，给我们的计划和政策带来偏见。这是导致基于模型的 RL 方法往往比无模型方法实现更低渐近性能的因素之一。
一个常见的解决方法是使用一个非常有偏见的模型，如果明智地选择，它可能会概括得更好。例如，如果我们的环境动态可以用线性模型合理地近似，由于对模型类别的严格限制，我们可能实现良好的概括和极好的样本复杂性，但是这对于除了最简单的问题之外的所有问题显然是不现实的。高斯过程是在更实际的情况下使用的一种常见模型类，具有良好的效果，它可以从很少的例子中有效地学习，并且还可以在其预测中给出不确定性的度量。但是，高斯过程对于大型数据区域的净规模确实很好，并且在预测期间进行查询的成本可能很高。另一种引入偏见的方法是使用领域知识，我之前在 的另一篇文章中写过这个。
这突出了模型类选择中一个有趣的权衡；如果我们选择低容量模型，我们可能会在训练开始时出现的小数据体制中获得良好的性能，但无法利用较大的数据体制，这是后期阶段的典型特征，此时我们已经收集了足够的数据。另一方面，如果我们使用高容量模型，如深度神经网络，我们可能很容易在低数据状态下过度拟合，但可以利用更大的数据量来获得更准确的模型。
模型开发
当我们试图使用我们学习到的模型来优化轨迹或政策时，不完美模型的另一个结果就会出现。一种常见的情况是，在状态空间的一些近似较差的区域，我们的模型可能会错误地预测高回报，从而促使我们的策略或搜索算法“主动”搜索出这些区域，即使我们的模型基本上是准确的。由于这些误差是我们特定模型参数的随机产物，它们很难避免，特别是在高容量模型类中，如深度神经网络。如果我们能够对模型的不确定性有所了解，这个问题就有可能得到解决。在这种情况下，我们可以衡量“熟悉”的状态，从而在优化时谨慎地接近不熟悉的状态，而不是贪婪地寻找虚假的高回报。
有大量关于基于模型的强化学习的研究论文，这些论文使用技术来缓解我上面提到的问题，我现在将查看我喜欢的两篇最近的论文，并检查它们如何处理这些问题。
PETS——带有轨迹采样的概率集合
这份 2018 年的报告采取的路线是学习一个用于规划的模型，而不是学习一项政策。作者认识到必须处理两种不确定性:环境中固有的随机不确定性，以及反映模型对不同输入状态-动作的置信度的认知不确定性。
通常，神经网络被用作确定性模型，如在回归问题的情况下。在这些情况下，神经网络输出数字，并且它们被视为预测，而不给出任何关于置信度的信息。虽然可以将输出视为分布(如高斯分布)的平均值，但这并没有什么帮助，因为我们对输出分布的方差一无所知。在 PETS 的论文中，作者使用了一个概率神经网络，它的输出参数化了下一个状态和奖励的高斯分布。当在环境转变数据上训练这样的模型时，不使用均方误差作为损失，我们使用在由我们的模型预测的分布下的真实下一状态的负对数可能性。这使我们能够对环境中固有的随机性进行建模，因为我们希望区分这种类型和另一种类型，并避免尝试“探索”差异较大的过渡，而不像由于数据不足而无法确定 who 的过渡状态。
为了解决第二种类型的不确定性，作者用学习模型的集合取代了单一的学习模型，每个学习模型都在真实环境交互数据集的单独样本上进行训练。当聚合多个不同模型的预测时，我们可以消除它们各自的怪癖和错误，有点类似于随机森林如何通过聚合不同的模型来提高决策树的性能。使用模型的集合，优化算法很难利用未充分探索的状态，因为每个模型给出的预测往往具有高的方差和较小的偏差，并且集合技术将降低方差。
在论文的上图中，我们可以看到，两个不同模型的集合有助于减少未探索状态中的误差，并有助于通过测量总体中的方差来了解不确定性。
在 PETS 算法中，通过使用相当复杂的采样方案，学习的模型集合被用于预先计划，在使用来自集合的交替模型预测转换时，被称为交叉熵方法(不是交叉熵损失函数…)的优化算法被用于改进计划中的动作。使用这种算法，作者可以在少量试验(大约 100K 时间步长)中获得与最先进的无模型 RL 算法(如近似策略优化和软因素批评)相当的性能。
MBPO——基于模型的政策优化
最近一篇名为“何时信任你的模型:基于模型的政策优化”的论文采用了不同的路线，它不是使用已知的环境模型来进行规划，而是使用它来收集虚拟数据来训练政策。本文详细介绍了 RL 中模型使用的一项非常有趣的理论研究，并使用神经网络泛化能力的经验评估来证明使用学习模型预测的合理性。
在 MBPO，作者采用了来自 PETS 论文的概率神经网络集成，但是介绍了一种使用该集成来生成训练数据的好的和简单的方法。正如我们之前所讨论的，复合模型误差使得长时间的学习任务非常困难，因为为了生成数据，我们从初始状态的分布中采样，并使用我们学习的模型向前传播，从而增加了误差。然而，在 MBPO，作者提出了一种解开任务范围和模型传播范围的方法，该方法从先前在与环境交互期间看到的随机状态开始，并向前传播短轨迹。这样，我们就可以用误差较大的几条长轨迹和误差较小的许多短轨迹进行交易。
MBPO 算法可以简要概括如下:
为了使用集成对轨迹进行采样，作者建议在每个时间步统一选择一个模型，对于策略优化步骤，他们选择了 Soft Actor Critic，这是一种最先进的非策略 RL 算法。使用所有这些技术，作者获得了与最好的无模型算法相当的结果，并超过了其他基于模型的方法，如 PETS。
至少从样本复杂性的角度来看，这似乎是物理系统采用 RL 的一个有前途的方向。还有其他困难的挑战，如物理系统上的奖励规格和检测，以及安全问题，但将样本复杂性降低到合理的水平是重要的一步。
基于模型的强化学习
基于模型的强化学习如何工作的俯视图。
Photo by Sebastian Herrmann on Unsplash
更新:学习和练习强化学习的最好方式是去 http://rl-lab.com
介绍
如果你玩过即时战略游戏(RTS ),比如《帝国时代》或其他游戏，你肯定知道你是从一个几乎黑屏开始的。你要做的第一件事是向各个方向派遣部队侦察地形，发现敌人的位置，以及战略位置和资源，如地雷，森林等…
你实际上正在做的事情实际上是为你所处的世界建立一个地图(或模型)。
在创建了这张地图后，不管是部分还是全部，你都要开始计划你的行动，准备即将到来的战斗。
所谓计划，我们指的是在你的大脑中模拟动作，而不是在游戏环境中真正执行它们。这种模拟将节省您的时间，但是，它是基于您已经建立的模型。如果这个模型是不准确的和有偏见的，你的计划将土崩瓦解。
让我们考虑一个国际象棋游戏的例子:
假设你正在下一盘棋，你走了一步，然后你一直等到你的对手走了一步，然后你又走了一步，你的对手也跟着走了一步，然后你发现你的第一步还是不够好！通常，如果你正在学习，你的老师会让你后退，这样你就可以从错误中学习。然而，你已经损失了相当多的时间。
另一方面，如果你在头脑中模拟这些动作(每个人都是这样做的)，并告诉自己“如果我做这个动作，我的对手可以用这个动作反击，那么我就做这个动作，等等……”你会避免前面所有的场景。
你实际上正在做的是，根据你对国际象棋的了解，在你的头脑中展开一棵搜索树，从这棵树上，你将选择可能导致胜利的最佳走法。
现在用一个人工智能代理代替你自己，你得到了基于模型的强化学习。
您可以清楚地看到这将如何节省培训时间。当然，这在具有高反应性的小环境中(例如网格世界)不会很明显，但是对于更复杂的环境，例如任何 Atari 游戏，通过无模型 RL 方法学习是耗时的，而另一方面，通过减少一组动作来创建模型，然后使用该模型来模拟情节是更高效的。
什么是模型？
抽象地说，模型是你自己对现实或你所处环境的表现。
在 RL 中，这转化为具有对MDP【S，A，P，R】的表示 M。这意味着拥有一个真实的 MDP 的版本 i (最好尽可能准确)。
如果我们假设状态空间 S 和转移概率 A 是已知的，那么模型 M i 将变成[S，A，P i ，R i 。
因此，根据模型 M i 在执行动作 A 之后从状态 S 到 S ’,服从概率 PI(S’ | S，A)，类似地，当在状态 S 时具有奖励 R '并且执行动作 A 服从关系 R i ( r’ | S，A)。
基于模型和无模型的区别
无模型方法直接学习经验，这意味着它们或者在真实世界(例如:机器人)或者在计算机(例如:游戏)中执行动作。然后他们从环境中收集奖励，无论是积极的还是消极的，他们更新他们的价值函数。
这是与基于模型的方法的关键区别。无模型方法在真实环境中学习。
相反，基于模型的算法在学习阶段减少了与真实环境的交互次数。它旨在基于这些交互构建一个模型，然后使用该模型模拟进一步的情节，不是在真实环境中，而是通过将它们应用到构建的模型中，并获得该模型返回的结果。
如前所述，这具有加速学习的优点，因为不需要等待环境响应，也不需要将环境重置到某个状态来恢复学习。
然而，不利的一面是，如果模型不准确，我们可能会学到与现实完全不同的东西。
另一点值得注意的是，基于模型的算法仍然会使用无模型的方法来构建模型或进行规划/模拟。
学习模型
学习模型包括在真实环境中执行动作并收集反馈。我们称之为体验。
所以对于每个状态和动作，环境会提供一个新的状态和奖励。基于这些经验，我们试图推导出这个模型。正如人们所猜测的，这就是监督学习问题。
我们通过使用一种可用的监督学习技术来解决这个问题，它可以是回归或神经网络或其他东西。
根据监督学习技术，该模型将由查表、神经网络或其他方法来表示
具体例子
下面的例子描述了两个状态 A 和 B，从 A 到 B 以及从 B 到两个可能的终端状态的转换。我们假设没有贴现因子。
为了建立模型，我们在真实环境中运行几集，我们收集着陆状态和结果，然后我们推导出模型的[P，R],如下所示:
我们可以看到，根据我们的经验(我们运行的测试),从 A 到 be 的时间是 100%,奖励为 0，而从 B 到上终端状态的时间是 75%,奖励为 1，到下终端状态的时间是 25%,奖励为 0。
这表明，如果我们使用该模型(而非真实环境)进行模拟，并且每次在 A 处运行任意一组测试(采样),该模型将告诉我们，当 r =0 时，我们将 100%地移动到 B，并且每次在 be 处，我们可以在 r = 1 时上升 75%的时间，在 r = 0 时上升 25%的时间。
现在，我们可以使用蒙特卡罗等方法来计算价值函数，在我们的示例中，这将导致 V(A) = 1 和 V(B)= 0 . 75。
作为蒙特卡洛值计算的提醒:
g(s)= r+𝛄g(s’)其中 g 是每一集之后在状态 s 的返回。V(s) =所有剧集的平均 G(s)
V(B)=(6 * G1+2g 2)/8 =(6 * 1+2 * 0)/8 = . 75
V(A)=([G(A)+G(B)]+[G(A)+G(B)])/2 =((0+1)+(0+1))/2 = 1
PS。我们认为没有贴现，所以𝛄 = 1
主循环
总之，基于模型的 RL 的主循环如下:
- 我们在真实环境中行动，收集经验(状态和奖励)，
- 然后我们推导出一个模型，并用它来生成样本(规划)，
- 我们从样本中更新价值函数和策略，
- 使用这些价值函数和策略来选择要在真实环境中执行的动作，
- 然后重新开始循环。
Dyna 架构
基于模型的 RL 的变体，称为 Dyna Architecture。它不是使用真实的经验来构建模型，而是用来更新价值函数。
Dyna-Q 算法
算法从初始化 Q 和模型开始，然后进入主循环。它从当前状态开始，根据策略选择一个动作，在真实环境中执行该动作，观察奖励 R 和新状态 S’。
随着 R 和 S’可用，它更新 Q(S，A)和模型。
注意，S’现在成为当前状态。
现在进入规划阶段。算法进入第二个循环，它迭代 n 次，在这个循环中，算法随机选择一个状态和一个相关联的动作，将它们应用到模型中，并从模型中获得奖励和新的状态，然后它像在外循环中一样更新 Q(S，A)。
基于模拟的搜索
需要注意的是，如前所述，规划阶段从观察的状态空间中随机抽取状态样本，并不强调代理所处的当前状态。
基于模拟的搜索通过获取我们在真实环境和规划阶段中到达的当前状态 St 来改变这一过程。它从 St 开始运行多个模拟。请注意，这不再是 Dyna-Q 中的随机状态。
因此规划阶段现在变成了从当前状态 St 开始从模型 M 生成 K 集的循环
上标 K 是指该集的索引，其中 K 是总集数。
规划阶段基于模拟的搜索有多种实现方式，如简单的蒙特卡罗搜索、蒙特卡罗树搜索(MCTS) 。
简单蒙特卡罗搜索
简单的蒙特卡罗搜索由一个模型和一个模拟策略π(专用于规划阶段的策略)组成。
然后从真实的当前状态 St 开始，我们采取每个可能的动作 a 并且我们生成 K 个模拟开始 St 和动作 a.
之后，通过将 Q(St，a)计算为模拟情节的所有回报的平均值来评估每个模拟
现在，通过选择在 St 处使 Q 值函数最大化的动作，来选择要在真实环境中执行的动作
蒙特卡罗树搜索
蒙特卡洛树搜索算法在文章强化学习中的蒙特卡洛树搜索中有详细讨论。
它被用作来自 Deep Mind 的 Alpha Zero 的积木。
其他资源
你可能也会对下面的文章感兴趣:基于模型和无模型的强化学习——py tennes 案例研究
使用 Scikit-learn 进行模型设计和选择
使用 Scikit-learn 调整、训练和评估模型
Photo by Alex wong on Unsplash
**目的:**本文的目的是从头到尾建立一个管道，以便在一个合成数据集上访问 18 个机器学习模型的预测性能。
**材料和方法:**使用 Scikit-learn，我们为分类任务生成一个类似 Madelon 的数据集。我们的工作流程的主要组成部分可以概括如下:(1)创建训练集和测试集。(2)然后通过 Z 分数归一化来缩放特征。(3)应用特征选择算法来减少特征的数量。(4)训练和评估机器学习算法。将使用受试者操作曲线下面积(AUC)评估 18 个训练分类器的预测能力。
硬件:我们在配备英特尔酷睿 i7–8700 处理器、12 个 CPU、3.70 Ghz 和英伟达 GeForce RTX 2080 的工作站上训练和评估我们的模型。
**注意:**如果你是从零开始，我会建议你按照这篇文章安装所有必要的库。欢迎你来 fork 我的储存库，里面包含了这篇文章的全部内容。
数据集
我们将使用 Scikit-learn 为分类任务生成一个类似 Madelon 的合成数据集。Madelon 数据集是一个人工数据集，包含放置在边长为 1 的五维超立方体的顶点上的 32 个聚类。聚类被随机标记为 1 或-1 (2 类)。
我们将生成的数据集将包含 30 个特征，其中 5 个将提供信息，15 个将是冗余的(但提供信息)，5 个将重复，最后 5 个将是无用的，因为它们将被随机噪声填充。数据集的列将按如下顺序排列:
- 信息特征—第 1–5 列:这些特征是您构建模型时真正需要的唯一特征。因此，一个五维的超立方体。
- **冗余特征—第 6–20 列:**这些特征是通过线性组合具有不同随机权重的信息特征而形成的。您可以将这些视为工程特性。
- 重复特征——第 21–25 列:这些特征是从信息特征或冗余特征中随机抽取的。
- **无用特征——第 26–30 列:**这些特征充满了随机噪声。
让我们从导入库开始。
Script 1 — Importing the libraries.
现在我们可以生成数据集了。
Script 2 — Getting the data: Notice that we set the random_state = 1000. This is done simply to ensure that we will work with the same data . You can remove it if you want.
通过无替换的随机抽样，我们创建了我们的训练和测试集。
Script 3 — Creating the training and test set. The size of the test set is set to be 20% of the data.
分类器
我们将训练和调整 18 个分类器，并使用受试者操作曲线下面积(AUC)评估它们的性能。讨论每个分类器的任何技术细节都超出了本文的范围；然而，对于感兴趣的读者，你可以点击下面列表中的链接。每个分类器都有一个标签，由括号中的字符串表示。
- 线性判别分析 (LDA)
- 二次判别分析 (QDA)
- Adaboost 分类器 (AdaBoost)
- 装袋分级机(装袋)
- 额外树分类器(额外树集合)
- 梯度增强分类器(梯度增强)
- 随机森林分类器(随机森林)
- 山脊分级机(山脊)
- SGD 分类器 (SGD)
- 伯努利 NB 分类器(BNB)
- 高斯 NB 分类器(GNB)
- K 最近邻分类器 (KNN)
- MLP 分类器 (MLP)
- 线性 SVC (LSVC)
- Nu SVC (NuSVC)
- SVC (SVC)
- 决策树分类器 (DTC)
- 额外的树分类器(等等)
Script 4 — Initializing the classifiers. This list was obtained from a Kaggle notebook.
分类器超参数
这里我们将创建一个字典，它的键-值对包括
- 键:表示分类器的字符串
- 值:对应分类器的超参数字典
这里使用的超参数决不代表每个分类器的最佳超参数网格。欢迎您随意更改超参数网格。
Script 5 — Defining the hyper-parameter grid for each classifier.
特征选择方法
机器学习可能涉及每个训练实例的数千个特征的问题。从一大群特征中确定最优特征子集是机器学习中的一项常见任务。这样做的好处是很多的。例如，找到最具描述性的特征可以降低模型的复杂性，使找到最佳解决方案变得更容易，最重要的是，它减少了训练模型所需的时间。在某些情况下，可以获得轻微的性能提升。
幸运的是，使用成熟的方法通常可以大大减少特征的数量。然而，必须注意的是，通过删除特性，您的系统性能可能会稍差(因为您试图用较少的信息进行预测)。
有三种选择特征的常用方法。即过滤器、包装器和嵌入式方法。全面解释它们超出了本文的范围。因此，如果你不熟悉这些方法，我会建议你阅读这篇文章，还有这篇文章。
在我们的工作流程中，我们将首先应用过滤方法来快速减少特征的数量，然后应用包装方法来确定最大化分类器性能所需的最小特征数量。
1.过滤方法:基于相关性的特征选择
让我们假设，如果两个或更多的特征高度相关，我们可以随机选择其中一个，丢弃其余的，而不会丢失任何信息。为了衡量特征之间的相关性，我们将使用 Spearman 的相关系数。如果两个要素的 Spearman 相关值为 1，则表示它们完全相关，0 表示不相关，而-1 表示高度相关但方向相反(一个要素增加，而另一个要素减少)。
在特征选择算法的这一步，我们首先使用所有特征计算系数矩阵的绝对值，参见图 1 。然后，我们确定一组相关系数大于 0.95 的特征。从每组相关的特征中，我们将选择其中的一个并丢弃其余的。你可以随意改变我设定的门槛。
Script 6 — Removing highly correlated features. To use a threshold of 0.90, change 0.95 to 0.90 in line 19.
Figure 1 — Spearman’s correlation matrix. Notice that the last 5 features don’t correlate with any other feature since they are filled with random noise.
这将从数据集中移除 6 个要素，数量并不多，即要素 13 和要素 21–25。然而，在我处理过的真实数据集中，这一步减少了高达 50 %的特征数量。请注意，如果您有数千个特征，这可能会在计算上很昂贵。
2.包装器方法:带交叉验证的递归特征消除
在移除高度相关的特征之后，我们将通过应用递归特征消除算法来进一步减少特征的数量。Scikit-learn 带交叉验证的递归特征消除( RFECV )对象只允许您使用具有feature_importances_或coef_属性的估计器/分类器。根据经验，我注意到 RFECV 经常高估您真正需要的特性的数量。
2.a .调整基本估计值
首先，您需要选择用于 RFECV 的基本估计量。为了便于说明，我将选择一个随机的森林分类器作为基础。欢迎您选择以下任一项作为基本估计值。
This is executed in the Classifiers section.
一旦确定了基本估计量，我们将调整它的超参数。这样做的原因是为了减少过度拟合的风险和最大化估计器的性能。为此，我们将创建一个 Scikit-learn 管道对象，它将与 Scikit-learn GridSearchCV 对象一起使用。
GridSearchCV 将在超参数网格上执行详尽的搜索，并将报告将最大化交叉验证分类器性能的超参数。这里有一篇很好的中间文章，展示了更详细的解释。我们将设置折叠数为 5。
以下是我们管道中的步骤。
**第一步——特征缩放:**在你的算法中使用它们之前，缩放你的特征是一项常见的任务。这样做是为了确保数据集中的所有要素都具有相同的比例。因此，值较大的要素不会优先于值较小的要素。你可以参考这篇文章获得更详尽的解释。我们将使用训练集中的样本通过 Z 分数归一化来缩放数据(训练和测试)。所有要素都以零为中心，标准偏差为 1。
**步骤 2 —分类器:**定义在管道中使用的分类器对象。
Script 7 — Tuning the classifier. To change the base estimator, change the classifier label in line 5. See the Classifiers section to see the list of available labels. To change the number of folds that GridSearchCV uses to 10, set cv = 10, in line 23. Similarly, you can also change the scoring.
调整随机森林分类器的处理时间为 4.8 分钟。
2.b .使用调整后的估计器递归选择特性
一旦我们调优了我们的基本估计器，我们将创建另一个类似于第一个的管道，但是这个管道将在第二步中具有调优的分类器。现在出现了一个技术性问题。因为 Scikit-learn 管道对象没有feature_importances_或coef_属性，所以如果我们想在 RFECV 中使用它，我们必须创建自己的管道对象。约翰·雷米向我们展示了如何做到这一点。谢谢你，约翰！
Script 8 — Defining a custom Pipeline object that is compatible with RFECV and RFE.
最后，我们可以在新管道中使用 RFECV。唷！去拿瓶啤酒，伙计。
Script 9 — Selecting features using a recursive feature elimination with cross-validation (RFECV).
现在让我们来想象一下结果。用 python 绘图有点疯狂，但不管怎样。
Script 10 — Visualizing the results of RFECV. All this code to make a Figure 2, yuck! You might need to adjust the xlim(), ylim(), and ax.axhline() if you change the data set or base estimator.
Figure 2 — Area under receiver operator curve (AUC) as a function of number of features. The classifier’s performance peaks around 10 features.
多美的身材啊！在图 2 中，我们可以看到分类器的性能是许多特征的函数。如您所见，性能峰值约为 10 个特性，AUC 约为 0.89；但是，如果您检查 selected_features 列表的长度，您会注意到 RFECV 确定您需要超过 18 个特性才能达到最高性能。
有问题的是，我们从 30 个特征开始，知道其中只有 5 个是真正必要的，在我们的特征选择算法之后，我们以超过 18 个代表性特征结束。为了解决这个问题，看一下图 2 ，直观地确定你想要使用多少个特性(例如 10 个)，并使用 Scikit-learn RFE 对象，其中n_features_to_select参数设置为 10。请注意，在添加了 7 个特性之后，随着特性的增加，性能的提升是最小的。你可以用这个作为你的阈值，但我喜欢包含一点冗余，因为我不知道其他 17 个分类器的最佳特征数。从 sci kit-了解 RFE 文档:
给定给特征分配权重的外部估计器(例如，线性模型的系数)，递归特征消除(RFE)的目标是通过递归地考虑越来越小的特征集来选择特征……该过程在修剪集上递归地重复，直到最终达到要选择的特征的期望数量。
Script 11 — Using recursive feature elimination (RFE) to select a given number of features. To change the size of the selected features to 12, set n_features_to_select =12 in line 9.
现在你可能想知道为什么我们不从 RFE 开始，而不是 RFECV。嗯，在现实生活场景中，你不会预先知道你真正需要多少特性。通过使用 RFECV，我们能够获得最佳的特征子集；然而，根据我的经验，它经常被高估。然而，从 RFECV 中我们获得了性能曲线，从中我们可以做出我们需要多少特性的明智决定。使用 RFE 的一个缺点是结果没有交叉验证。
特征重要性
一旦我们确定了所选的特征，我们就可以根据分类器来研究它们的重要性。我推测，对于分类器来说，一些冗余特征实际上比真实特征更能提供信息。让我们看看这是不是真的。
我们将首先使用所选的特征来训练调整后的随机森林分类器。然后我们将使用feature_importances_属性并用它创建一个条形图。请注意，只有当您选择作为基础的分类器包含一个 feature_importances_ 属性时，下面的代码才会起作用。
Script 12 — Visualizing the feature importances.
Figure 3 — Random Forest feature importance. Large values imply a greater importance.
最重要的特征是特征 6 和 19，它们属于冗余特征类。冗余功能似乎比信息功能(功能 1-5)更重要，这似乎有悖常理。话又说回来，在 Kaggle 比赛中经常可以看到，特色工程可以给你一个助力。重要的是要注意，由机器学习分类器分配的特征重要性本质上是随机的，是不健壮的。例如，如果您要重新运行 RFE，您可能会获得稍微不同的结果，因为我们没有修复随机森林中的种子。这就是为什么如果你的计划是从你的特性重要性中得出一些结论，你需要交叉验证你的结果。这里有一篇关于机器学习随机性的优秀文章。另外，如果你的分类器没有调优，不要相信特征的重要性。这里有一篇关于如何更稳健地确定特征重要性的精彩文章。
迭代分类器调整和评估
既然我们已经确定了代表性特征的子集，我们将调整和训练 18 个模型，以调查其中性能最高的模型。为此，我们将迭代脚本 4 中定义的分类器，并使用脚本 7 使用脚本 5 中定义的超参数来调整它们。我们将对脚本 7 做一些小的修改，并添加几行额外的代码来评估测试集上调优的分类器性能，并保存结果。
Script 13 — Tuning classifiers on training set and evaluating on test set.
脚本 13 在我的工作站上运行了大约 30 分钟。我估计在阿朵核心 CPU 这将需要大约 3 个小时。所有结果都将存储在名为results *的字典对象中。*字典results的内容可以通过分类器 _ 标签访问(参见分类器部分)。对于每个分类器，我们存储以下对象:
- 分类器:经过训练的分类器流水线对象。你可以用它来预测新的样本。
- 最佳参数:包含在训练集中获得最佳性能的参数的字典。
- 训练 AUC :在训练集中得到的交叉验证的 AUC。
- 测试 AUC :测试集中得到的 AUC。
让我们来看看结果:
Script 14 — Visualizing the results of Script 13.
Figure 4 — Bar plot of classifier performance on training and test set.
从图 4 中，我们可以直观地确定 SVC、NuSVC、梯度增强和 AdaBoost 分类器在测试集中获得了最高的性能。查看 pandas dataframe 对象auc_scores的内容以查看数字结果。
结束语
如果你读到了这篇文章的结尾，那么恭喜你！我们实际上浏览了很多材料。我希望这能对你有所帮助。您可以在我的 GitHub 资源库中找到本文的所有代码。不客气叉吧。如果您想使用它，只需修改脚本 2 并确保以下内容:
- 加载数据并对所有分类变量进行编码。
- 注意任何缺失值或异常值。
- 平衡您的数据集(如果需要)。
- 将特征矩阵 X 存储到熊猫数据帧对象中。对 y 中的目标进行同样的操作。
如果您的数据集包含大约 1000 个样本和 30 个特征，那么执行整个过程大约需要 30-45 分钟——假设您的硬件与我的相似。
现在给出一些建议，以确定下一步如何进一步提高这些分类器的性能。
最简单的方法是选择五个性能最好的分类器，用不同的参数进行网格搜索。一旦对最佳参数的位置有了感觉，就可以在参数空间中对该点进行更精细的网格搜索。在您进一步调优这些分类器之后，从五个分类器中选择最好的三个，并在 Scikit-learn 的 VotingClassifier 中使用它们。这很可能会提高性能，但会增加建模的复杂性。您也可以考虑堆叠—要了解更多信息，请单击此处。
你也可以研究特征工程。这会给你带来最大的回报。我正计划写一篇关于这个主题的文章。
在 LinkedIn 找到我。下次见！
无模型预测:强化学习
第 4 部分:利用蒙特卡罗学习、时间差学习和 TD( λ) 的无模型预测
之前，我们研究了通过动态规划来解决已知的 MDP 的规划。在本帖中，我们将使用无模型预测来估计未知 MDP 的价值函数。也就是说，我们将着眼于一个未知的 MDP 的政策评估。这一系列的博客文章包含了大卫·西尔弗在关于强化学习的介绍中解释的概念总结。
将对无模型预测的三种主要方法进行说明:
- 蒙特卡罗学习
- 时差学习
- TD(λ)
这篇文章主要着眼于在未知的 MDP 中评估一个给定的政策，而不是寻找最优政策。
蒙特卡罗学习
蒙特卡洛 方法都是直接从剧集经验中学习的 无模型 。蒙特卡洛从全集中学习无引导。MC 的一个缺点是它只能应用于所有情节都必须终止的情节马尔可夫决策过程。
无模型: 对 MDP 转场/奖励一无所知
自举 : 更新涉及到一个估计
蒙特卡洛政策评估
目标 :给定一个策略 *π，*从几集经验中学习 v_π(策略值)。
Given policy π with each state, action and associated reward for taking that action
Recall: return is the total discounted reward
Recall: value function is the expected return
蒙特卡罗策略评估 用经验均值收益代替预期收益。评估一个状态下策略的价值函数的两种方法是使用 首次访问蒙特卡罗策略评估 或 每次访问蒙特卡罗策略评估。
首次访问蒙特卡洛政策评估
- 评估给定策略的状态值
- 第一个时步( t) 那个状态( s) 在一集里被访问
- 增量计数器: N(s) ← N(s) + 1
- 增量总回报: S(s) ← S(s) + Gₜ
- 价值由平均收益估计: V(s) = S(s)/N(s)
- V(s) → v_π(s) 为 N(s) → ∞
蒙地卡罗政策评估
- 评估给定策略的状态值
- ****每一个****t)那个状态( s) 都是在一个情节中被访问
- 增量计数器: N(s) ← N(s) + 1
- 增量总回报: S(s) ← S(s) + Gₜ
- 价值由平均收益估计: V(s) = S(s)/N(s)
- V(s) → v_π(s) 为 N(s) → ∞
在上述两种评估方法中，我们必须跟踪算法的统计数据。也就是说，我们只能在完成所有剧集后计算其价值。为了解决这个问题，我们可以使用 增量均值 等式来增量更新该值。
增量均值 一个序列的均值₁，₂，…x₁，x₂，…可以增量计算。
Incremental Mean
**增量蒙特卡罗更新 更新 V(s) 增量后集 S₁，A₁，R₂，…，Sₜ.为每个状态 Sₜ 带回车 Gₜ :
Replace step 3–5 with the above. (Gₜ − V(Sₜ)) can be viewed as the error between the return and the mean at time step t
在非平稳问题中(事物四处漂移，你不需要记住很久以前发生的事情)，我们可以使用移动平均方法，即忘记旧的情节。
Incremental Monte-Carlo updates
时差学习
时间差 是*无模型的。*时间差分法直接从经验/与环境的相互作用中学习。时态差从不完整的剧集中学习，通过 自举 (更新值函数的猜测)。****
在 MC 和 TD 中，目标都是从政策 π 下的经验中在线学习 v_π 。
如果我们要应用 增量每次访问蒙特卡罗 我们就朝着实际返回 Gₜ 更新值 V(Sₜ】
最简单的时差学习算法，TD(0)****随着我们更新值 V(Sₜ) 趋向于一个估计值返回rₜ₊₁+γv(sₜ₊₁)****
【rₜ₊₁+γv(sₜ₊₁】)是TD 目标***【δₜ=rₜ₊₁+γv(sₜ₊₁)-v(sₜ】)是TD 误差* 。**
TD 学习立即更新值函数，这允许它在知道每一步之后的最终结果 之前学习 ，不像 MC 必须等到剧集结束之后才知道返回。TD 工作在 持续(非终止)环境 中，而 MC 只工作在阶段性(终止)环境/完整序列中。
举例说明 TD 和 MC 之间的区别，如果我们试图预测在沿途的每个州开车回家需要多长时间。在 MC 中，我们会给每个状态分配我们在旅程结束时得到的值(实际结果)。
在 TD 中，我们将使用下一个状态对当前状态的影响(估计结果)来更新每个状态的值。
在偏差和方差之间有一个权衡。 MC 使用返回 Gₜ 时有高方差和零偏*，这依赖于的许多随机动作、过渡和奖励。因此，即使在函数逼近的情况下，它也具有良好的收敛性，并且对初值不敏感。*
TD 有低方差和部分偏差为TD 目标 取决于一个随机动作，跃迁和奖励。通常比 MC 更有效率。 TD(0) 收敛于 v_π(s) 但不总是用函数逼近。与 MC 不同，它对初始值更敏感。
批量 MC 和TD
所以我们看到 MC 和 TD 收敛: V(s) → v_π(s) 作为经验 → ∞ 但是实际上我们不可能永远进行下去，那么这些算法对于有限经验的批量求解是如何收敛的呢？
假设我们有两个状态 A，B 有无贴现和 8 集经验。
AB Example
状态 A 的值是多少。 V(一) ？ MC 收敛于以最小均方误差最佳拟合观察回报的解。
*因此 *V(A)=0。因为状态 A 唯一一次出现在一集里是在 return 为 0 的时候。
TD(0) 收敛到最大似然马尔可夫模型的解。这是最符合数据的 MDP 解决方案。
因此 V(A)=0.75 。因为我们在 8 集里得到了 6 集的奖励。与 MC 不同，TD 利用了马尔可夫特性。
备份方法之间的比较
蒙特卡罗备份: 状态的值 Sₜ 只能在到达终端状态时计算
时间差 TD(0)备份:
仅使用一步前瞻来计算状态值 Sₜ 。
动态编程备份: 在 Sₜ 处的值通过一步查看每个可能的状态来计算，并计算出期望值。
n 步返回 一种介于 TD(0)和 MC 之间的方法，这里我们有 n 步时差学习。因此，该值将通过向前看 n 步并应用时间差学习方法来计算。
TD(λ)
我们可以不用查看每个 n 步回报 Gₜ⁽ⁿ⁾ ，而是使用一个衰减加权和来组合所有 n 步回报，称为λ-回报* 。*
前视 TD(λ)
现在可以使用 前视 TD(λ) 计算状态下的值
前视着眼于未来以计算λ回报，并向其更新价值函数，并且只能从完整的剧集中计算。
后视 TD(λ)
后向视图提供了从不完整序列在线更新每一步值的机制。我们为每个状态 s 保留一个 合格轨迹 ，并与 TD 误差 δₜ 和合格轨迹 eₜ(s】成比例地为每个状态 s 更新 V(s) 。
合格追踪
合格追踪结合了频率启发式和新近启发式*。
- 频率启发式:将信用分配给最频繁的状态
- 最近启发式:将信用分配给最近的状态*
Eligibility Trace Equations
摘要
我们已经研究了各种用于无模型预测的方法，例如蒙特卡罗学习、时间差学习和 TD(λ)。当给定一个策略时，这些方法允许我们找到一个状态的值。在下一篇文章中，我们将使用无模型方法寻找最优策略。
参考
- 关于 RL 的 UCL 课程——第 4 讲
- 《强化学习导论》，萨顿和巴尔托，1998 年
如果你喜欢这篇文章，并想看到更多，不要忘记关注和/或留下掌声。
机器学习中的模型参数和超参数—有什么区别？
分析影响模型质量的参数
在机器学习模型中，有两种类型的参数:
- **模型参数:**这些是模型中必须使用训练数据集确定的参数。这些是拟合参数。
- **超参数:**这些是可调整的参数，为了获得具有最佳性能的模型，必须对其进行调整。
例如，假设您想要使用 m 维训练数据集构建一个简单的线性回归模型。那么你的模型可以写成:
其中 X 是预测矩阵，而 w 是权重。这里 w_0，w_1，w_2，…，w_m 是模型参数。如果模型为了确定权重 w_0，w_1，w_2，…，w_m，使用梯度下降算法最小化目标函数，那么我们可以有一个优化器，比如 GradientDescent(eta，n_iter)。这里，eta(学习速率)和 n_iter(迭代次数)是超参数，为了获得模型参数 w_0，w_1，w_2，…，w_m 的最佳值，必须对其进行调整。有关这方面的更多信息，请参见以下示例: 机器学习:使用梯度下降的 Python 线性回归估计器。
scikit-learn 软件包中使用的超参数示例
- 感知器分类器
Perceptron(n_iter=40, eta0=0.1, random_state=0)
这里，n_iter 是迭代次数，eta0 是学习速率，random_state 是混洗数据时使用的伪随机数生成器的种子。
2。训练、测试分割估计器
train_test_split( X, y, test_size=0.4, random_state=0)
这里，test_size 表示要包含在测试分割中的数据集的比例，random_state 是随机数生成器使用的种子。
3。逻辑回归分类器
LogisticRegression(C=1000.0, random_state=0)
这里，C 是正则化强度的倒数，random_state 是混洗数据时使用的伪随机数生成器的种子。
4。KNN (k 近邻)分类器
KNeighborsClassifier(n_neighbors=5, p=2, metric='minkowski')
这里，n_neighbors 是要使用的邻居数量，p 是闵可夫斯基度量的幂参数。当 p = 1 时，这相当于对 p = 2 使用 manhattan_distance 和 euclidean_distance。
5。支持向量机分类器
SVC(kernel='linear', C=1.0, random_state=0)
这里，kernel 指定了算法中使用的核类型，例如 kernel = 'linear '表示线性分类，kernel = 'rbf '表示非线性分类。c 是误差项的惩罚参数，random_state 是在混洗数据以进行概率估计时使用的伪随机数发生器的种子。
6。决策树分类器
DecisionTreeClassifier(criterion='entropy',
max_depth=3, random_state=0)
在这里，criterion 是衡量分割质量的函数，max_depth 是树的最大深度，random_state 是随机数生成器使用的种子。
7。套索回归
Lasso(alpha = 0.1)
这里，α是正则化参数。
8。主成分分析
PCA(n_components = 4)
这里，n_components 是要保留的组件数。如果未设置 n_components，则保留所有组件。
重要的是，在模型建立期间，这些超参数被微调，以便获得具有最高质量的模型。一个模型的预测能力如何依赖于超参数的很好的例子可以从下图中找到(来源: 好坏回归分析 )。
Regression analysis using different values of the learning rate parameter. Source: Bad and Good Regression Analysis, Published in Towards AI, February 2019, by Benjamin O. Tayo.
从上图可以看出，我们模型的可靠性取决于超参数调整。如果我们只是为学习率选择一个随机值，比如 eta = 0.1，这将导致一个糟糕的模型。为 eta 选择一个太小的值，比如 eta = 0.00001，也会产生一个不好的模型。我们的分析表明，最佳选择是当 eta = 0.0001 时，从 R 平方值可以看出。
好的和坏的机器学习模型之间的区别取决于一个人理解模型的所有细节的能力，包括关于不同超参数的知识以及如何调整这些参数以获得具有最佳性能的模型。在没有完全理解模型的错综复杂的情况下，将任何机器学习模型作为黑箱，都会导致模型被证伪。
参考
- 《Python 机器学习》，第二版，塞巴斯蒂安·拉什卡。
- 机器学习:使用梯度下降的 Python 线性回归估计器 。
- 坏与好的回归分析 。
理解机器学习中的成本函数
“计算机能够看、听和学习。欢迎来到未来。”戴夫·沃特斯
所以，我已经开始学习 Coursera 上流行的机器学习课程。我想，为什么不分享我正在学习的东西呢？所以，今天我要谈谈机器学习的两个基本话题。
- 模型表示
- 价值函数
模型表示:
大多数机器学习算法的主要目标是构建模型。我们可以把这个模型称为hypothesis。hypothesis基本上将input映射到output。input变量指特性，output变量指目标。我们将用来学习的数据集称为training集。我们的目标是，给定一个训练集，学习一个函数 h : X → Y，使得 h(x)是 Y 的相应值的一个“好的”预测器。
当我们试图预测的目标变量 y 是连续的，比如房子的价格，我们称学习问题为regression问题。当 y 只能取少量的离散值时(例如，如果给定居住面积，我们想预测一个住所是房子还是公寓)，我们称之为classification问题。
假设通常被提出
这里θ1 和θ2 是参数。
让我们用θ1、θ2 和 x 的随机值的一些例子来形象化我们的假设:
让我们看另一个例子:
创建模型的目标是选择参数或θ值，以使训练数据 x 的 h(x)接近 y。
成本函数:
成本函数将帮助我们找出“如何将最佳直线拟合到我们的数据”，即:我们可以通过使用cost function来测量我们假设的accuracy。用作cost function的一个常见功能是[mean squared error](https://en.wikipedia.org/wiki/Mean_squared_error)。它测量predicted value和actual value之间的差异。
注:平均值减半(1/2)是为了便于计算梯度下降，因为平方函数的导数项将抵消(1/2)项。
我们想得到最好的线路。当分散的点与直线的平均垂直距离平方最小时，我们将得到最好的直线。让我们看一个例子，其中我们的成本函数将为 0，我们将有最好的可能线:
当θ1 = 1 时，我们得到的斜率为 1，我们的成本函数为 0。
现在让我们假设θ1 = 0.5
我们可以看到，这将我们的成本函数增加到 0.5833
现在我们将绘制更多的 J(θ1)值:
我们可以看到，当θ1 = 1 时，成本函数处于最小值。这是符合逻辑的，因为我们的初始数据是一条斜率为 1 的直线，它穿过我们模型中的每个数据点。
免责声明:我只是分享我从吴恩达著名的机器学习课程中学到的东西。在下一篇文章中，我将谈论梯度下降。
为我最糟糕的事求情(！)笔迹。
K 近邻模型的选择、调整和评估
It’s a beautiful day in the neighborhood
数据科学生命周期的核心是模型构建。虽然相对不复杂，但一个被称为 K-最近邻或 KNN 的模型是一种展示模型制作过程基础的可靠方法……从选择，到超参数优化，最后是准确度和精确度的评估(然而，对准确度的重要性要有所保留)。如果奥卡姆剃刀教会了我们什么，那就是简单不是一件坏事，所以让我们深入了解一种算法，这种算法通常是构建机器学习中其他非常复杂的模型的一个组件。
一、型号选择
对于本演练，我已经选择了模型为 KNN。在选择模型时，先做最好的科学家通常会做的事情:查看数据。你有一点还是很多？
最佳的模型选择将在偏差和方差之间有一个良好的平衡，并且理想地将两者都最小化。因为我已经提到了机器学习这个术语，所以重要的是要区分我这里指的不是算法偏差，而是统计偏差。算法偏差是一个非常重要和活跃的讨论话题，但它超出了我的博客文章的范围。统计偏差涉及参数的预期值和真实值之间的差异，方差指的是在对被研究的数据子集(称为训练集)多次重复学习过程后，模型预测的波动程度。
这就把我们带入了关于拟合优度的讨论。在深入了解 KNN 工作原理的细节之前，如果我们查看下图，黑线是一个模型示例，它与 tje 数据非常吻合，可以从红点中识别蓝点。尽管没有画出来，欠拟合模型应该是一条从左上到右下的完美对角线(欠拟合意味着高偏差)。绿线可以说是完美的，它将所有蓝点归类在一起，红点也是如此。然而，它代表了过度拟合的定义，并且不能很好地推广到新的数据(在第三节中对此有更多介绍)。
本质上，偏差和方差合在一起将构成给定模型中可以减少的误差量:
Reducible Error = Squared Bias + Variance
无论一个模型能够多么完美地最小化偏差和方差，在我们的熵宇宙中总会存在一定程度的不可避免的误差或噪声。这就是所谓的不可约误差。
在其核心，K-最近邻算法是非常直观的。空间中与两个苹果和三个橘子距离相等的点将如何分类？柑橘打破了平衡，现在我们有四个柑橘。
二。模型调整
通常在建模中，参数和超参数调整都是需要的。区别在于它们是在模型拟合之前(超参数)还是之后(参数)。
KNN 是一个相对简单的分类工具，但它在很多时候也非常有效。据说在大约三分之一的分组案例中**，它是最有效的分类器。三分之一！这个模型可能很小，但也很强大。**
该算法在各种编程语言中有不同的迭代，但我将在这里讨论 scikit-learn，它是用 Python 编写的。基本算法使用欧几里德距离为测试集中的每一行找到最近的 K(K 是我们的超参数)训练集向量，或“邻居”。多数投票决定分类是什么，如果碰巧出现平局，则决定由碰巧在训练数据中首先列出的邻居做出。
**对我来说，这是可视化超参数实际作用的最佳算法。**突击测验！在图中的每个 K 值处，中间的问号将被归类为蓝色圆圈。但是当 K 不断增加时呢？在下面的评论中留下你的答案，有机会赢得最有价值的奖品，知识！
下图提出了一个有趣的问题。显然，当 K 等于 11 时，拼图块就是一个笑脸。但是当 k 是四的时候呢？根据文档，如果两组邻居具有相同的距离但不同的标签，则结果将取决于训练数据的排序。
What is the optimal K for solving how this piece of the puzzle should be classified?
请注意，在算法的不同迭代中，这可能会有所不同。例如，在 R 的 KNN 分类系统中，平局是随机打破的。
著名的(读起来:臭名昭著的)Iris 数据集是统计学经典中的经典，它恰当地展示了这种算法工具是如何投入使用的。分析的四个特征的散点图可视化应该清楚地表明，KNN 将能够在四个比较中的三个中容易地区分这三个单独的物种。至少在两个被比较的物种之间，一个特征匹配稍微有点复杂，但是即使在比较萼片长度和萼片宽度的情况下，KNN 也能够以不同程度的成功区分三个物种，这取决于我们将 K 设置为什么。
如果您想用沙箱保护这里讨论的内容，甚至想将一些方法集成在一起，也可以随时使用它。你可能会在不知不觉中赢得卡格尔比赛！
既然我们已经挑选出了模型，并且对最近邻上下文中超参数的含义有了更好的理解，那么我们如何优化 K 呢？学习曲线。
Seaborn Visualization of a KNN learning curve
上图中我们看到了一条学习曲线，它来自一个优秀的 Kaggle 页面，该页面以皮马印第安人的糖尿病流行为背景研究了 KNN。我们可以清楚地看到，测试分数 11 的最大值表示算法的最佳值，K = 11。这又回到了我们关于偏差和方差的讨论。第一个门(偏差)太多，你会看到一个学习曲线，表明一个简单的模型:低测试和低训练分数，它们在价值上也非常相似。超过第二个门数(方差),培训和测试分数之间将有显著差异。两者的良好平衡意味着模型既准确又精确。一个模型甚至可以用第四种可能性来描述:既不准确也不精确。在高偏差、高方差的情况下就是这种情况。自己回答:四个类别中哪一个最能描述这种可视化的学习曲线？
三。模型评估
在科学中，评估一个模型基本上意味着看它处理新数据的能力。当我们看拟合优度时，这是在一般意义上偶然发现的(记住我们的红点和蓝点)。
为了在机器学习模型的背景下评估 K-最近邻，我们需要权衡它的一些优点和缺点。KNN 被用作许多其他更高级算法的构建模块，这种现象我之前简单提到过，被称为集成或混合。您还可以使用 ML 其他领域常见的一些变化来微调算法。
无监督的和有监督的 K-最近邻的区别在于它的用途——前者用于聚类，后者用于分类。如果我们谈论的是无监督的 KNN，你可以在一种蛮力方法、球树、 KD 树之间切换，或者甚至让算法本身来确定聚类的最佳方式(自动)。我认为这种可定制性是支持 KNN 的一点，因为它允许您灵活地处理大小数据集。除法通常发生在接近 30 的样本数上:低于这个数，粗略地说，一个蛮力策略更好。在此之上，基于树的方法是可行的。但是，太远了，并且所涉及的时间复杂性不再成立。也就是说，随着 N(样本数量)的上升，KNN 的计算时间呈指数增长，迅速偏离可以被认为有用的东西。
这里另一个值得注意的缺点与您想要处理的数据的结构有关，它被称为维数灾难，尽管这种疾病可以通过使用 scikit-learn 的邻域成分分析(简称 NCA)来解决。这也是一种监督(学习)距离度量算法，旨在与使用默认度量(欧几里德距离)相比，提高 KNN 分类的准确性。它源于一种更广泛的算法策略，用于处理被称为主成分分析(PCA)的维度问题。当 NCA 与 K-邻居分类器结合使用时，它是优雅、简单和强大的；没有需要微调的额外参数的复杂性。还有一个巨大的好处是能够处理多类问题，而不增加模型的大小。
进一步的改进，如最近质心分类器(这种模型的另一个监督应用)，只能证明这一系列算法是最大似然法的基础。我们正在向越来越先进的领域推进，我建议你参考下面链接的 sk-learn 的文档来深入研究。
引用作品:
糖尿病分步分类-KNN-详细，Shruti Iyyer。
机器学习中的模型评估、模型选择、算法选择，塞巴斯蒂安·拉什卡。
型号选择的“简短”介绍，David schnleber。
K-最近邻完全指南及其在 Python 和 R 中的应用。
http://www . arc 2020 . eu/counting-apple-or-oranges-climate-change-stats-vs-food-systems-thinking/
https://www . python-course . eu/k _ nearest _ neighbor _ classifier . PHP
https://ionds . com/WP-content/uploads/2016/10/over fitting-image-model-case-300 x300 . png
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
