从零开始的生成分类算法
机器从零开始学习
艾达、QDA 和朴素贝叶斯
二次判别分析决策边界。(图片由作者提供。来源。)
概率生成算法(如朴素贝叶斯、线性判别分析和二次判别分析)已经成为流行的分类工具。这些方法可以通过 scikit-learn 在 Python 中轻松实现，或者通过 e1071 在 R 中轻松实现。但是这些方法实际上是如何工作的呢？本文从零开始推导它们。
(注意本文改编自我的书机器从零开始学习中的一章，网上免费提供)。
符号和词汇
在本文中，我们将使用以下约定。
- 设 v [ i ]为向量 v 中的第 i 个条目。
- 目标是我们试图建模的变量。预测值是我们用来模拟目标的变量。
- 目标是一个标量，记为 y. 预测值组合成一个矢量，记为 x 。我们还假设 x 中的第一个条目是 1，对应截距项。
- P(x)指的是xP(y = k)指的是 y 等于 k 的概率
1.生成分类
大多数分类算法分为两类:判别分类器和生成分类器。判别分类器将目标变量 y 建模为预测变量 x 的直接函数。例如，逻辑回归使用以下模型，其中是系数的长度-D 向量，而 x 是预测值的长度-D 向量:**
逻辑回归模型
相反，生成分类器将预测器视为根据其类别生成的——即，它们将 x 视为 y 的函数，而不是相反。然后他们使用贝叶斯法则从P(x| y = k)到P(y = k |x)，如下所述。
创成式模型可以分为以下三个步骤。假设我们有一个分类任务，有 K 个无序类，用 k = 1，2，…，K. 表示
- 估计目标属于任何给定类别的先验概率。即对于 k = 1，2，…，K. 估计 P(y = k)
- **在属于每个类别的目标上估计预测值条件的密度。即估计p(x| y = k)为 k = 1，2，…，K.
- 计算目标属于任何给定类别的后验概率。即通过贝叶斯法则计算出P(y = k |x)与P(x| y = k)P(y = k)。
然后，我们将一个观察结果分类为属于类别 k ，对于该类别，下面的表达式是最大的:
注意，我们不需要p(x)，它将是贝叶斯规则公式中的分母，因为它在所有类中都是相等的。
2.模型结构
生成分类器模拟两种来源的随机性。首先，我们假设在𝐾可能的类之外，每个观察独立地属于𝑘类，其概率由向量中的第 k 个条目给出。即𝝅**【k】给出 P(y = k)。**
第二，我们假设的一些分布以 y. 为条件。我们通常假设x 来自于相同的族分布，而不管 y，如何，尽管它的参数取决于类。例如，我们可以假设
虽然我们不会假设 x 如果 y = 1 是分布 MVN 而是分布多元- t 否则。注意，然而，向量 x 中的各个变量可能遵循不同的分布。例如，我们可以假设中的 i th 和 j th 变量分布如下**
然后，机器学习任务是估计这些分布的参数——目标变量 y 的 𝝅 以及索引x***| y = k*(在上述第一种情况下，*_ k和𝚺**) K. 一旦完成，我们就可以为每个类计算 P(y = k) 和P(x| y = k)。 然后通过贝叶斯法则，选择使 P 最大化的类k(y = k |x)。***********
3.参数估计
现在让我们开始估计模型的参数。回想一下，我们计算P(y = k |x)用
为了计算这个概率，我们需要首先估计(这告诉我们 P(y = k) )然后再估计分布p(x| y = k)中的参数。这些被称为类别先验和数据似然性。**
注意:由于我们将讨论跨观测值的数据，所以让 y_n 和x***_ n*分别作为第 n 次观测值的目标和预测值。(下面的数学在原本中稍微整齐一点。)**
3.1 类别优先级
让我们从推导的估计开始，类别先验。设 I_nk 为指示器，如果 y_n = k 则等于 1，否则等于 0。我们希望在给定数据的情况下找到一个表达式来表示 𝝅 的可能性。我们可以将第一次观察具有目标值的概率写为如下:
这相当于 𝝅 给定单个目标变量的可能性。要找出所有变量的可能性，我们只需使用乘积:
这给了我们类先验概率。为了估计 𝝅 通过的最大似然，我们先取对数。这给了
其中类别 k 中的观测值数量由下式给出
现在我们准备通过优化对数似然来寻找 𝝅 的 MLE。为此，我们需要使用拉格朗日函数，因为我们有一个约束条件，即中的条目之和必须等于 1。这个优化问题的拉格朗日函数如下:
拉格朗日最优化。第一个表达式表示对数似然，第二个表示约束。
更多关于拉格朗日的内容可以在原著中找到。接下来，我们对𝜆和中的每一项进行拉格朗日导数:**
这个方程组给出了下面直观的解，即我们对 P(y = k) 的估计只是来自 k. 类的观察值的样本分数
3.2 数据可能性
下一步是对给定 y 的 x 的条件分布进行建模，以便我们可以估计这个分布的参数。这当然取决于我们选择用来建模 x 的分布族。下面详细介绍三种常见的方法。
3.2.1 线性判别分析
在 LDA 中，我们假设下面的分布为 x
**对于 k = 1，2，…，k。注意，每个类都有相同的协方差矩阵，但有唯一的均值向量。
让我们推导这种情况下的参数估计。首先，我们来求似然和对数似然。请注意，我们可以将所有观测值的联合似然性写成
因为
然后，我们插入多元正态 PDF(去掉乘法常数)并取对数:
最后，我们有我们的数据可能性。现在我们通过最大化这个表达式来估计参数。
让我们从𝚺.开始首先，简化对数似然，使相对于 𝚺 的梯度更加明显。
然后，我们求导。注意，这里使用了“数学笔记”中介绍的矩阵导数(2)和(3)。
然后我们设置这个梯度等于 0，并求解 𝚺.
在哪里
半路上！现在来估计_ k*(第 k 类的均值向量)，让我们单独看一下每个类。设 C_k 是类 k. 中的一组观测值，只看涉及 𝝁 _k、的项，我们得到*
使用“数学笔记”中的等式(4)在这里，我们得到梯度为
最后，我们将这个梯度设置为 0，并找到我们对平均向量的估计:
其中最后一项给出了类别 k. 中 x 的样本均值
3.2.2 二次判别分析(QDA)
QDA 看起来非常类似于 LDA，但是假设每个类都有自己的协方差矩阵。即，
对数似然在 LDA 中是相同的，除了我们把 𝚺 与 𝚺 _k:
同样，让我们单独看看第 k 类的参数。类别 k 的对数似然由下式给出
我们可以取这个对数似然相对于*【𝝁****_ k的梯度，并将其设为 0，以求解我们对***【𝝁****_ k的估计。然而，我们也可以注意到，LDA 方法的这个估计是成立的，因为这个表达式不依赖于协方差项(这是我们唯一改变的)。因此，我们再次得到**
**为了估计 𝚺 _k，我们取类 k. 的对数似然的梯度
然后我们将它设为 0，得到我们的估计值:
在哪里
3.2.3 朴素贝叶斯
朴素贝叶斯假设 x 内的随机变量是独立的取决于观察的类别。即如果 x 是 D 维的，
*这使得计算*p(x| y = k)变得非常容易——为了估计p(x【j】| y)除了 j th 之外，我们可以忽略 x 中的所有变量。
作为一个例子，假设 x 是二维的，我们使用下面的模型，其中为了简单起见，σ是已知的。
和以前一样，我们通过只查看每一类中的项来估计每一类中的参数。设 θ _k = (μ_k，σ_k，p_k) 包含类别 k 的相关参数类别 k 的可能性由下式给出:
其中，由于 x 中的条目之间的假设独立性，两者相等。代入法向密度和伯努利密度分别为 x_n1 和 *x_n2，，我们得到*
那么我们可以采用如下的对数似然
**最后，我们准备寻找我们的估计。对 p_k 求导，我们得到
这将给我们一个合理的结果
请注意，这只是 x_2 的平均值。同样的过程将给出 μ_k 和 σ_k. 的典型结果
4.进行分类
不管我们对p(x| y = k)的建模选择如何，对新的观察值进行分类都很容易。考虑一个测试观察值×x***_ 0*。对于 k = 1，2，…，K ，我们用贝叶斯法则计算**
其中𝑝̂给出了以 y_0 为条件的x****_ 0的估计密度。然后，我们预测最大化上述表达式的任何值 k。**
结论
LDA、QDA 和朴素贝叶斯等生成模型是最常用的分类方法。然而，他们的试衣过程的细节(尽管是艰苦的)经常被掩盖。这篇文章的目的是让这些细节清晰。
虽然为生成模型估计参数的低级细节可能相当复杂，但高级直觉相当简单。让我们用几个简单的步骤来回顾一下这种直觉。
- 估计观测值来自任何给定类别的先验概率 k. 在数学中，估计 p(y = k) 的每个值 k.
- 估计预测值的密度条件对观测值的分类。即估计 k. 的每个值的p(x| y = k)**
- 使用贝叶斯规则获得一个观察值来自任何给定其预测值的类的概率(达到一个比例常数):p(y = k |x)。**
- 选择哪个值 k 最大化第三步中的概率(称之为 k) 估计 y = k。**
就是这样！要想从头看到更多像这样的衍生，请查看我的免费在线书籍！我保证他们大部分数学都比较差。
语言的生成模型和社会缺陷
OpenAI 生成模型的简史及其误用对社会的潜在影响。
对缺点的理解并不完全取决于某项特定技术的缺点或缺陷，而是取决于这项技术如何改变世界，无论是好是坏。
2015 年，一家名为 OpenAI 的公司由埃隆·马斯克、山姆·奥特曼、彼得·泰尔等人创立并向公众亮相。创始人以及微软和印孚瑟斯、等大公司承诺总计 10 亿美元用于创建“非营利企业”。
最初，OpenAI 是作为一个非营利组织成立的，部分原因是当时对人工智能近年来的发展感到担忧。OpenAI 作为非营利组织的理由与这些担忧没有太大关系，而是根据一篇介绍性博客文章的以下内容:
“作为一个非营利组织，我们的目标是为每个人而不是股东创造价值。研究人员将被强烈鼓励发表他们的工作，无论是作为论文、博客帖子还是代码，我们的专利(如果有的话)将与世界共享。我们将与许多机构的其他人自由合作，并期望与公司合作研究和部署新技术。”
2017 年，斯蒂芬·霍金(Stephen Hawking)将人工智能的出现描述为很可能是“我们文明史上最糟糕的事件”，突显出整个社会对其发展缺乏监督。早在 2014 年，马斯克本人在麻省理工学院(MIT)发表演讲时就认为，人工智能的发展是人类“最大的生存威胁”。
先锋大厦，OpenAI 和 Neuralink 的办公室所在地。(HaeB / CC BY-SA
几年后，在 2018 年，OpenAI 公布了第一篇关于生成性预培训的论文，这就是后来被称为 GPT 的开端。
这篇论文由亚历克·拉德福德和其他三位 OpenAI 同事撰写，得出的结论是，语言的生成模型实际上可以获得“重要的世界知识”和“处理长期依赖的能力”。由此，该模型还将能够解决“诸如问题回答、语义相似性评估、蕴涵确定和文本分类”等任务。
GPT-2:
关于 GPT-2 的研究论文于 2019 年 2 月发布，但由于围绕滥用措施的潜在利用，特别是关于假新闻的构建和发展的原因，其全面功能的发布被扣留，这一主题将在下文详述。
Transformer 语言模型的工作方式是通过人类主动输入至少几个单词到一页，然后模型继续自动预测和生成接下来人工生成的几行应该是什么。
*《卫报》*进行了一项类似于的实验，以乔治·奥威尔的小说《1984》开头为特色。该行如下所示:
这是四月里一个晴朗寒冷的日子，时钟正敲 13 下
GPT-2 设法使用这一行，这一行只产生了以下生成的文本片段，按照卫报及其文章，怪异地遵循“模糊的未来主义语气和小说风格:
“我在车里，正要去西雅图找一份新工作。我加油，插钥匙，然后让它跑。我只是想象着今天会是什么样子。一百年后。2045 年，我是中国农村贫困地区一所学校的老师。我从中国历史和科学史开始。”
当然，如果第二次、第三次或第四次输入完全相同的文本，该模型不会重复。有趣的是，这个文本明显不同于其他人工智能生成模型，尤其是在理解领域。
弗兰基·查马基在 Unsplash 上的照片
OpenAI 现任研究副总裁 Dario Amodei 表示，与以前相比，使用的模型“大了 12 倍，数据集大了 15 倍，范围也大了很多。实质上，向 GPT-2 提供的大量数据是其卓越的质量和可理解性背后的主要原因。
如果你有兴趣亲自体验 GPT-2，亚当·金创建了一个网站，利用 GPT-2 的完整模型，并将其命名为与变形金刚对话。
GPT-3:
2020 年 5 月，GPT-3 在 GitHub 上发布，与 GPT-2 的开发相比，它的大小有了天文数字的增长。前身模型是利用完整版本中的 15 亿个参数构建的。相比之下，GPT-3 是用 1750 亿个参数建造的，增加了 115 倍。
虽然由于 GPT-3 数据集和模型规模的增加，该模型的性能水平(与自然语言处理相关)甚至比 GPT-2 更好，但 OpenAI 也公开表示该模型可能接近其绝对极限。
这篇论文详细介绍了 GPT-3 的成功、局限性、更广泛的影响以及更多的内容，有效地证实了简单地向一个模型扔更多的数据并不能在无限的轨道上产生更好的结果。
它还围绕滥用的可能性，特别是在创建更大的模型时:
“任何依赖生成文本的对社会有害的活动都可能被强大的语言模型所增强。示例包括错误信息、垃圾邮件、网络钓鱼、滥用法律和政府程序、欺诈性学术论文写作和社会工程借口。这些应用中的许多限制了人们写出足够高质量的文本。产生高质量文本生成的语言模型可以降低执行这些活动的现有障碍，并提高它们的效率。”
一个语言生成模型必须发展得越多，特别是与它所拥有的数据和信息的数量相关，它就越适用于一般用途的应用程序，包括但不限于它对恶意行为的使用。
假文本的产生和问题:
虽然 OpenAI 最初是一家非营利性企业，但该公司转向了盈利模式，或者用他们的话说，一种“利润上限模式，根据他们的博客和 TechCrunch 的说法，这种模式将允许他们“在超过某个点后削减投资回报。
围绕这一举动的基本原理不仅仅是获得更多的投资资本，而是植根于一种理解，即积累比他们已经拥有的更多的计算能力，“建造人工智能超级计算机”等等，将需要在未来几年内投资数十亿美元。
安娜·阿尔尚蒂在 Unsplash 上的照片
向盈利模式的转变当然与保持透明度和问责制有关，但对于 OpenAI 生产和开发 GPT 等模型也存在其他问题。
如前所述，2019 年 2 月，OpenAI 拒绝发布 GPT-2 ，纯粹是因为其被用于恶意目的的可能性。像 GPT-2 这样的模型的出现导致学者和记者将生成的文本称为“ deepfakes for text ”，该公司花时间“讨论技术突破的后果”。
滥用的例子包括上述主题:
“错误信息、垃圾邮件、网络钓鱼、滥用法律和政府程序、欺诈性学术论文写作和社会工程借口”
该公司承认，这些领域需要产生“高质量文本”的能力，但这正是为什么所谓的“deepfakes for text”的发展令人担忧，特别是在新闻、学术研究和小说家等领域。
该技术的当前状态，至少就 OpenAI 的开发而言，还远远没有完全消除和消除基于人类的输入。这一事实，再加上处理预先确定的语言和文本的神经网络的发展很可能肯定有其局限性，并没有引起人们的警惕。
尽管如此，不应该低估对其增长的关注，特别是随着时间的推移技术不断发展。
除了这些改进之外，OpenAI 还从该技术“太危险而不能积极使用”的心态转变为根据 The Verge 发布“其第一个商业产品”。
该公司最终得出结论，鉴于目前的技术状态，对 GPT-2 的恶意使用的担忧是不必要的，但新的发展要大得多，甚至更准确，并且“现在是你的，但要付出代价”。
受到人工创建文本的发展积极影响的领域的例子包括“微软新闻和 MSN 组织”，其中“数十名记者和编辑工作者”截至 2020 年 5 月已被解雇。根据 The Verge 的一篇文章，这是由于微软更大力度地依靠人工智能来挑选新闻和内容……在 MSN.com，在微软的 Edge 浏览器内，以及在该公司的各种微软新闻应用。
随着技术的发展，现实世界的影响肯定存在，而且只会继续增长。如果没有与这种生成性文本模型的增加的生产相关的任何种类的监督，整个工作领域在未来都有被关闭的风险。
虽然具体日期当然还不能确定，但微软的举动是所有类型的新闻和内容创作可能不幸未来的开始的一部分。
LSTM 的生成诗
在我的 Metis 数据科学训练营的最后一个项目中，我使用 LSTM 模型构建了一个诗歌生成器。
照片由Á·阿尔瓦罗·塞拉诺在 Unsplash 上拍摄
这是我 Metis 数据科学训练营的最后一个项目。我做的前四个项目如下:
这一次，我的目标是通过将诗歌语料库输入长短期记忆(LSTM)神经网络来生成短诗。
TL；博士:
- 检索到一个三行诗的语料库
- 用两种方法训练了一个 LSTM 模型:清洗单词序列；原始单词序列与斯坦福的手套嵌入配对
- 对干净的单词序列的训练产生了不太有意义的诗歌；手套嵌入训练产生了更好的结果，但是不一致
- 下一步将是尝试附加种子、附加特征、不同的模型超参数，以及更大和/或改进的诗歌语料库
一.背景
对于我的顶点，我想找到一种方法将我在机器学习方面的新兴技能与我现有的对诗歌的兴趣(阅读和写作；顺便说一下，我在 Instagram 上收集的俳句可以在这里找到。
[## 我的 Instagram 账户中的一个俳句，搭配一张我拍的照片。
www.instagram.com/kunojilym](https://www.instagram.com/p/B16if6WHvZ8/?utm_source=ig_web_copy_link)
生成性诗歌似乎是一个很好的起点。然而，除了吸引我的兴趣之外，这样的模型还可以有实际应用:
- 它可以作为进一步创作诗歌和创造性写作的动力
- 如果诗歌可以基于主题/图像生成，这可以在各种领域中具有更广泛的应用，例如在广告和营销中。
二。数据集
在这个项目中，我使用了杰里米·尼曼为他自己的生成诗帖子收集的三行诗数据集；在他的例子中，他专注于创作俳句(因此限制为 3 行)。
使用神经网络生成俳句，同时强化 5–7–5 音节结构。
towardsdatascience.com](/generating-haiku-with-deep-learning-dbf5d18b4246)
该数据集又是由如下各种其他数据集组合而成的。
总共 31，410 首诗
三。模型
我使用 Keras 构建了一个 LSTM 神经网络模型，该模型接受 15 个令牌的序列，并输出下一个令牌(或者更准确地说，下一个令牌的概率)。模型结构如下图所示。
我的 LSTM 模型
使用这个模型，我尝试了如下两种方法，训练了 200 个 epoches:
a)用干净的单词进行单词标记化
使用这种方法，我首先通过小写字母和删除所有非字母数字字符来清理单词；我保留了停用词，因为它们在诗歌语境中可能有意义。
大写字母和标点符号也可以有诗意，虽然可以说没有那么多，所以我决定在这种方法中忽略它们。
然后我将每首诗处理成一系列 15 个记号的序列:
- 一首诗的第一个序列是用 14 个空格填充的第一个单词。
- 每个后续序列会将下一个单词推入序列，丢弃多余的令牌。例如，第二个序列是用 13 个空格填充的前两个单词。
- 特殊记号用于行尾和诗尾。
所有诗歌的结果序列被连接起来。下图说明了这一过程。
令牌是为了说明的目的
b)利用手套嵌入的单词标记化
这种方法类似于第一种方法，有两个主要区别:
- 每个序列现在都与斯坦福手套的 300 维嵌入配对；正是这个 15 x 300 的向量，而不是 15 个标记的序列，被输入到 LSTM 中。下面举例说明。
令牌是为了说明的目的
- 单词标记未被清除；换句话说，所有的大写和标点符号都被保留。这是因为手套嵌入物能够容纳这种代币
四。结果呢
培训结果如下。
基于分类交叉熵损失，使用手套的第二种方法似乎产生更好的结果。但是真正的诗歌呢？
这是从第一个模型中挑选出来的:
从第一种方法中选择最佳结果
即使在“最好”的情况下，第一种方法产生的诗歌似乎也不太有意义。将其与第二种方法中的选择进行比较:
从第二种方法中选择最佳结果
这些结果更加连贯，甚至富有诗意。
然后，我组装了一个 Flask 应用程序，它调用第二个模型，并访问存储在 PostgreSQL 数据库中的嵌入内容来生成诗歌，如下面的视频所示。
“创作温度”与诗歌创作人在选择诗歌的下一个词时的“冒险”程度相关。温度为 0 意味着生成器每次都选择最“可能”的单词，而温度越高，生成器选择不太“可能”的单词的可能性越大。
动词 （verb 的缩写）观察
- 使用手套嵌入的第二种方法似乎比使用干净标记的第一种方法更经常地产生听起来自然的诗歌。也就是说，如视频所示，甚至第二种方法也不是万无一失的，平均来说，它似乎在超过 50%的时间里都不会产生“像样的”诗歌。
- GloVe 方法产生了一个大小超过 1 GB 的模型**，相比之下，cleaned tokens 方法的大小仅为 81 MB。由于包含了 300 维的单词嵌入，T4 的特征数量增加了 300 倍，这并不奇怪。可以尝试更少的嵌入(例如 100 维)来观察结果是如何受到影响的。**
- 两个模型都受到数据集词汇的限制。下一步可能是扩展这个词汇表，以包含斯坦福手套模型所包含的内容。
不及物动词后续步骤
除了上述观察结果，该项目在未来还有其他几个可能的方向:
- 目前，该模型使用一个起始单词作为种子来生成诗歌的其余部分。我可以使用附加种子来提高相关性，例如情感、主题或图片。
- 我还可以使用诗歌的附加特征来提高模型输出的质量，例如音节或词性。
- 我可以调整我的 LSTM 模型的超参数**，例如通过使用额外的层或节点，或者通过尝试不同的激活函数。**
- 最后，我可以将更多的诗歌添加到我的数据集中，和/或从数据集中移除低质量的诗歌**。最后一点是非常主观的，因为不同的人对什么是一首好诗有不同的看法。**
谢谢你坚持到最后。我的其他项目的链接如下:
** [## MTA 十字转门数据:我对数据科学项目的第一次体验
在 Metis 数据科学训练营的第一个项目中，我研究并分析了 MTA 十字转门 2 个月的数据。
towardsdatascience.com](/mta-turstile-data-my-first-taste-of-a-data-science-project-493b03f1708a) [## MyAnimeList 用户评分:网络抓取和线性回归的乐趣
在我在 Metis 数据科学训练营的第二个项目中，我使用线性回归模型来预测动画在…
towardsdatascience.com](/myanimelist-user-scores-fun-with-web-scraping-and-linear-regression-9dd97900a82b) [## 拖网渔船在捕鱼吗？模拟全球渔业观察数据集
在我在 Metis 数据科学训练营的第三个项目中，我根据以下特征来判断拖网渔船是否在捕鱼…
towardsdatascience.com](/is-a-trawler-fishing-modelling-the-global-fishing-watch-dataset-d1ffb3e7624a) [## 识别假新闻:骗子数据集及其局限性
在我的第四个 Metis 数据科学训练营项目中，我应用分类和 NLP 技术来确定一个片段是否…
towardsdatascience.com](/identifying-fake-news-the-liar-dataset-713eca8af6ac)
要关注我的数据科学之旅，您可以订阅我的博客或关注我的数据科学系列，链接如下。
经过几年的涉猎，我的数据科学之旅真正开始于 Metis 数据科学训练营。总共…
medium.com](https://medium.com/series/my-data-science-journey-c99fa6378209)
下次再见了。**
生成性与鉴别性概率图形模型
朴素贝叶斯和逻辑回归的比较
作者照片
生成模型和判别模型是广泛使用的机器学习模型。例如，逻辑回归、支持向量机和条件随机场是流行的判别模型；朴素贝叶斯、贝叶斯网络和隐马尔可夫模型是常用的生成模型。
概率图形模型(PGM)是一个丰富的框架，用于编码复杂域上的概率分布，如大量相互作用的随机变量的联合分布。
在本文中，我们将以朴素贝叶斯和逻辑回归为例，将生成模型和判别模型的图形结构作为 PGM 进行探索。我们还将讨论这些模型的相似之处和不同之处。
模型结构
假设我们正在解决一个分类问题，根据邮件中的单词来决定一封邮件是否是垃圾邮件。我们有一个联名款的标签 Y=y ，特点是 X={x 1 ，x 2 ，…x n } 。模型的联合分布可以表示为 p(Y，X) = P(y，x 1 ，x 2 …x n ) 。我们的目标是估计垃圾邮件的概率: P(Y=1|X) 。生成模型和判别模型都可以解决这个问题，但方式不同。
让我们看看它们为什么以及如何不同！
为了得到条件概率 P(Y|X) ，生成模型从训练数据中估计先验 P(Y) 和似然 P(X|Y) ，并使用贝叶斯规则计算后验P(Y | X)
另一方面，判别模型直接假定 P(Y|X) 的函数形式，并且直接从训练数据估计 P(Y|X) 的参数。
上图显示了生成模型和判别模型的结构差异。圆圈代表变量，线的方向表示我们可以推断的概率。在我们的垃圾邮件分类问题中，给定 X:电子邮件中的单词，Y 是未知的。我们看到判别模型图(右)中的箭头从 X 指向 Y，这表明我们可以直接从给定的 X 推断出 P(Y|X) ，然而，生成模型图(左)中的箭头指向相反的方向，这意味着我们需要首先从数据中推断出 P(Y) 和 P(X|Y) 的值，并使用它们来计算 P(Y|X) 。
数学推导
上图显示了扩展特征 X 时这两个模型的潜在概率分布。我们可以看到，每个特征 x i 依赖于前面所有的特征:{x 1 ，x 2 …x( i-1) }。这不会影响判别模型，因为它们只是将 X 视为给定的事实，并且它们需要估计的只是 P(Y|X ),但是这使得生成模型中的计算变得困难。
- 生成模型(朴素贝叶斯)
后验概率可以写成:
我们看到所有 X 的依赖性使得很难推断 P(X|Y ),因为我们需要将 x i 的概率限制在 Y 和{x 1 ，x 2 …x( i-1) }上。为了简化问题，我们假设所有的 X 是条件独立的:
有了这个假设，现在我们可以将后验分布改写为:
创成式模型的图形结构也发生了变化:
2。判别模型(逻辑回归)
如前所述，我们可以利用训练数据直接估计判别模型的后验概率:
在逻辑回归中，我们将后验概率参数化为:
最大似然估计用于估计参数。
比较
1.准确(性)
当不满足条件独立性的假设时，生成模型不如判别模型精确。比如在我们的垃圾邮件分类问题中，让 x 1 =邮件数据中“银行”出现的次数，邮件数据中 x 2 =邮件中“账户”出现的次数。不管是否垃圾，这两个词总是一起出现，即 x 1 = x 2。在朴素贝叶斯中学习得到**p(x1| y)= p(x2 | y)**，对证据进行双重计数。逻辑回归没有这个问题，因为它可以设置α1=0 或α2=0。
2.缺失数据
生成模型可以处理缺失数据，而判别模型通常不能。在生成模型中，我们仍然可以通过忽略看不见的变量来估计后验概率:
然而，判别模型通常需要观察所有的特征 X。
3.表演
与判别模型相比，生成模型需要较少的数据来训练。这是因为生成模型在做出更强的假设(条件独立性假设)时更有偏见。
4.应用
判别模型之所以“判别”，是因为它有用但只对判别 Y 的标签有用，所以只能解决分类问题。除了分类之外，生成模型还有更多应用，例如抽样、贝叶斯学习、映射推理。
结论
生成模型和判别模型都是我们用来解决机器学习问题的非常有用的模型。使用哪种模型取决于用例及数据。一般来说，当我们对数据的基本分布有一个概念并希望找到该分布的隐藏参数时，通常使用生成模型，而当我们只想找到将数据分成不同类的边界时，判别模型更适合。
机器学习中的生成分类器与鉴别分类器
它们的不同之处以及它们如何执行分类任务
莎伦·麦卡琴在 Unsplash 上的照片
分类是机器学习中的一项普遍任务。流失预测、垃圾邮件检测、图像分类只是一些常见的例子。
有许多不同的算法可以执行分类任务。这些算法可以分为两大类，生成型和鉴别型。
在这篇文章中，我将试着解释生成性和区别性分类器之间的区别，以及它们是如何分类的。
生成分类器
考虑这样一种情况，我们有一个特征 x 和一个目标变量 y，我们试图根据 x 的值来预测 y。
生成分类器学习联合概率分布 P(x，y)。重点是特性和目标变量如何一起出现。目标是能够解释数据是如何生成的。
一旦模型捕获了生成数据的过程，它就可以对新的示例(即数据点)进行预测。因此，生成分类器的关键因素是能够学习底层数据分布。
为了进行预测，生成分类器通过使用贝叶斯规则将联合概率(P(x，y))转换为条件概率(P(y|x))。如果你不熟悉这个符号，P(y|x)表示给定 x 值时 y 的概率。
朴素贝叶斯分类器和隐马尔可夫模型是生成分类器的例子。
假设我们有一些属于蓝色或橙色类的点。这些点绘制在下图中。图中还显示了基于 x 和 y(训练数据)的已知值的联合概率分布。
(图片由作者提供)
基于联合概率分布来决定新数据点的标签。例如，上图中的绿点标记为橙色。
由于创成式模型了解数据分布，因此它们也可用于生成新数据。
区别性分类器
鉴别分类器试图找到分隔类别的边界。检查所有可能的边界阈值，并选择误差最小的阈值。
这些边界可以是硬的或软的，这取决于算法。软边界意味着允许一些例子被错误分类。例如，软间隔支持向量机(SVM)，顾名思义，创建一个软边界。
逻辑回归、SVM 和基于树的分类器(例如决策树)是区别分类器的例子。
判别模型直接学习条件概率分布 P(y|x)。回想一下，生成模型学习联合概率 P(x，y ),然后通过使用贝叶斯规则将其转换为 P(y|x)。
考虑下面的例子。数据点属于类别 0 或类别 1。逻辑回归模型绘制了一个边界，该边界指示数据点属于类 1 的概率(即 P(y=1 | x))。
(图片由作者提供)
极端值
生成模型对异常值更敏感，因为异常值有可能极大地影响分布。
在判别模型的情况下，异常值只是一个错误分类的例子。
考虑以下情况，在橙色类中有 2 个异常值。
(图片由作者提供)
由于这些异常值，橙色分布主导了一系列更有可能属于蓝色类的值。
我们不知道可能存在多少异常值，也不知道这些值有多极端。因此，在存在异常值的情况下，判别方法更适合。
结论
生成模型和判别模型都有优点和缺点。否则，我们就不会谈论这两个问题。
例如，生成型模型更需要数据。他们需要足够的数据来准确地表示分布。生成模型在计算上也比判别模型更昂贵。
判别模型对异常值更稳健，而异常值可能对数据分布有很大影响，从而对生成模型的准确性产生负面影响。
生成模型和判别模型在机器学习中都非常有用。最佳选择取决于任务和数据的特征。
感谢您的阅读。如果您有任何反馈，请告诉我。
遗传算法:简单直观的指南
了解什么是元试探法，以及为什么我们有时使用它们而不是传统的优化算法。通过一个简单的分步指南，学习元启发式遗传算法(GA)及其工作原理。
(图片由 Freepik 提供)
无论你是数据科学家、数据分析师还是机器学习工程师，运筹学和优化都应该是你工具箱的一部分。在深入研究遗传算法(GA)之前，我将解释什么是元启发式算法，以及为什么我们有时使用它们而不是传统的优化算法。之后，我将介绍元启发式算法 GA，并解释其工作原理及其背后的直觉。
什么是元启发式算法？
元启发式算法是强大的优化算法，不依赖于问题 —这意味着它们的框架不是专门为某个问题设计的，但你可以用它们来解决几乎任何优化问题(不像启发式算法通常适用于手边的问题)。
许多元启发法是受自然启发的。例如，模拟退火算法的灵感来自加热然后慢慢冷却金属或玻璃的过程。另一个例子是蚁群优化，它模仿蚂蚁在前往食物源并通过信息素相互交流时的行为方式。
为什么我们使用元启发式算法而不是传统的优化算法？
传统的优化算法，如贪婪算法、分支定界算法和 Dantzig 的单纯形算法等等，都有缺点。以下是我们倾向于使用元启发式算法而不是传统优化算法的几个重要原因:
#1-速度和问题大小:
**简答:**比传统算法更快，可以处理更大的问题。
为了解释这一点，让我们以旅行商问题(TSP) 为例。TSP 是一个广泛使用的优化问题，它表明有一个销售人员必须旅行到 n 个城市，每个城市只经过一次，然后返回他们出发的城市。给出的问题是，他们应该走哪条路线(从哪个城市到哪个城市)来最小化旅行的距离？
图 1: 一个有 6 个城市的 TSP(图片由作者提供)
假设您想要解决某个包含 6 个城市的 TSP，距离在左边的图像中给出(图 1)。可以看出，城市 A 和城市 B 之间的距离是 4 个单位的距离。
在这里，你需要找到推销员应该采取的最佳路线，以尽量减少旅行的距离。在这种情况下，最佳路线是，如果他们从 D 到 C 到 A 到 B 到 E，然后回到 D(因为你回到了出发城市)，这个距离将是 41 个单位(7+11+4+6+13=41)，而如果销售人员采取最差的路线，在这种情况下，它将是 E 到 A 到 D 到 B 到 C，然后回到 E，总距离将是 53 个单位，比最佳的 41 个单位要长。请记住，从 D 到 C 到 A 到 B 到 E，然后回到 D 与从 A 到 B 到 E 到 D 到 C，然后回到 A 是一样的，因为单个路由是一个闭环；你可以从环中的任何一点开始，以同一点结束，移动的距离是相同的。
对于 n 个城市，可能的路线组合数量将是 ((n-1)！)/2 。它是 (n-1) ，因为你从哪个城市开始并不重要，只有当城市之间的距离对称时(即城市 A 和城市 B 之间的距离等于城市 B 和城市 A 之间的距离)，它才被除以 2。在不对称的情况下，可能的组合数量是 (n-1)！。在我们的 6 个城市的例子中，所有的距离都是对称的，组合的总数是*((6–1)！)/2* 有 60 种可能的组合。
现在想象一个场景，你有 25 个城市，而不是只有 6 个，在这种情况下组合的总数将是*((25–1)！)/2* 总共有 3.10224210 条可能的路径。客观地说，如果你有一台每秒能分析 10，000，000 个组合的计算机，你的计算机需要 3.10224210 ⁶秒才能找到所有的组合，也就是 983，041，000 年左右！
元启发式算法寻找从一个解决方案到一个更好的解决方案的方法，而不考虑那里的每一个组合；它会选择比现有解决方案更好的解决方案，并根据一些规则对其进行更新(第 2 点和第 3 点应该能更好地解释这一点)。
#2-局部最小值和全局最小值:
**简而言之:**它可以避免陷入局部最小值并逃离它，因为它使用随机性(或随机数)来接受更差的移动(对于最小化问题，更大的 f(x) )，因为它们可能导致更好的答案(即更好的局部最小值或全局最小值)。
当你处理一个最优化问题时，你总是试图最小化一个目标函数，比如总行程，或者最大化一个目标函数，比如利润。
**图 2:**f(x)的搜索空间中的局部极小值(x1)和全局极小值(x2)(图片由another bookon data science提供)
对于最小化问题，你会经常听到术语局部最小值和全局最小值(最大化问题的局部最优和全局最优)。让我们看看左边的图 2，其中 x1 是局部最小值，而 x2 是全局最小值。让我们假设我们有一个函数 f(x) ，如果你输入 x1 ，我们将得到 f(x)=10 ，如果我们输入 x2 ，我们将得到 f(x)=6 ，显然 x2 是比 x1 更好的输入，因为 6 低于 10，10 比更好无论函数 f(x) 是什么，它只是问:要得到可能的最低值 f(x) 的 x 应该是什么？
图 3: 我们当前的 x 值是 2(图片由作者编辑)
假设你从 x1 左边的一个点开始，这里 x=2 (图 3)，你想用一个贪婪算法来最小化你的 f(x) 函数。贪婪算法倾向于只更新 x 如果它给你一个更好的答案，在我们的例子中，一个更低的 f(x)。现在我们试一下 x=2.1 ， f(x=2.1) 比 f(x=2) 低所以我们新的 x 会变成 2.1。仍然有改进的空间，所以我们继续这样做，直到我们到达 x1 这里 f(x=3) 。
**图 4:**a——我们当前 x 的值是 3。如果我们将 x 增加到 3.1，b- f(x)会变得更差(更大)。c- x2 是比 x1 更好的选择，因为 f(x=x2)比 f(x=x1)小(图片由作者编辑)
然而，如果我们想要将 x 增加到 3.1，您可以看到它给出了更高的 f(x) ，如图 5 所示。因此，贪婪算法的最佳 x 将是当 x 等于 3 时(在 x1 )。
通过查看图像(图 4)，可以清楚地看到 x2 甚至是比 x1 更好的选择，以降低 f(x) 但是在处理实际问题时，搜索空间是未知的，您需要为 x 尝试许多许多值，以便能够绘制如图所示的搜索空间。尽管如此，由于 x 的值有无限多种可能性，找到能够产生最佳结果的 x 的值有时是不可能的。然而，如果我们有 x 的上界和下界，找到全局最小值(最佳解)是可能的。
回到我们为什么使用元试探法，使用贪婪算法，当我们的 x 变成值为 3 的 x1 时，任何其他更新都会给出更差的 f(x) ，因此找到的最佳解决方案将是 f(x=3) 并且算法将终止。使用元启发式算法，我们有时会接受更差的移动(在图像的情况下，当 x=3.1 )。我们接受更糟糕的举措的原因是，它们有可能让我们找到更好的解决方案，比如 x=x2 。如果我们继续朝着山顶更新 x ，我们将能够向下返回并找到 x2 其中 f(x2) < f(x1) 。
图 5: 具有两个输入变量的搜索空间(图片由 mathworks 提供)
**注意:**如果我们要计算一个问题的所有可能的解决方案，我们不会在意陷入局部最小值，因为我们可以从所有组合中选择最佳答案，这将为我们提供全局最小值，然而，正如前面所讨论的，随着问题变得越来越大，计算所有可能的解决方案所需的时间也越来越长。
如果你回头看一下图 2-4，你只会看到一个变量( x )，我们试图找到它的最佳值，使我们得到最低的 f(x) 。但是，在现实生活的问题中，你会有数量多得多的变量需要优化(找到每个变量的最佳值)。在图 5 中，我们有 2 个变量需要优化( x 和 y )，其中 f(x) 将在 z 轴上。这个案子，还有上一个，只要看看剧情就能轻松解决。然而，当你有两个以上的变量时，就不可能通过查看图表来绘制和求解，因为你不能绘制超过 3 个维度。
#3-邻域搜索和基于人口的搜索:
**简答:**特别是在处理一个基于群体的搜索方法时，你会在你的搜索空间里一下子有很多解。这意味着您将能够评估许多点或解决方案，而不是只拥有一个解决方案并更新它。
图 6: 收敛到局部最优的邻域搜索算法(图片由 CMU 提供)
有了元试探法，你的算法要么是邻域(或局部)搜索算法，要么是基于种群的算法。如果你的算法是邻域搜索，这意味着你在整个搜索过程中有一个点或解，你在算法运行时更新这个解。由于它是一个元启发式算法，如果它陷入局部极小值，这个解决方案能够逃脱，这种情况会继续下去，直到算法终止，您收敛到一个最终的解决方案，如图 6 所示。当你的算法接近搜索结束时，接受更差走法的概率变小了，这是因为你的算法需要收敛到更好的解。邻域搜索算法的例子是模拟退火和禁忌搜索。
图 7: 基于群体的搜索算法中的解决方案(图片由作者编辑)
对于基于群体的搜索算法，您可以在搜索空间中同时拥有多个解决方案，就像它们的“群体”(图 7)，其中随着算法的每次迭代，一定数量的解决方案会更新并成为新的解决方案。每种基于群体的搜索算法在如何选择要更新的解决方案以及如何进行更新方面都有自己的规则。基于群体的搜索算法往往非常强大，因为你可以探索搜索空间中的各个点，而不是一个点，最后，当你的算法终止时，你可以从它收敛到的最后一次更新中选择最佳解决方案，或者，跟踪所有更新并从中选择最佳解决方案。基于群体的搜索算法的例子有 GA(稍后将讨论)、进化策略、粒子群优化和蚁群优化。
在深入 GA 之前先总结一下…
虽然传统算法能够很好地处理小问题，但是当问题很大时我们倾向于使用元启发式算法，因此需要更多的时间。元启发式算法能够避免陷入局部极小值。虽然在处理一个非常大的问题时，例如无界问题，其中每个决策变量可以取任何实数，您的搜索空间将无限大，因此，您可能无法找到全局最小值，即使使用元启发式算法，但您将找到一个足够好的局部最小值。最后，基于群体的搜索算法具有在搜索空间中搜索各种点的巨大优势，这增加了算法找到更好的局部最小值或全局最小值的机会。
那么，什么是遗传算法呢？
遗传算法是由霍兰德在 20 世纪 70 年代开发的一种基于群体的元启发式算法。遗传算法使用从自然中获得灵感的技术，更具体地说是进化，来寻找问题的最优或接近最优的解决方案。它应用进化概念，如繁殖和适者生存来解决问题。遗传算法属于进化算法的大类。
如果我尝试用几句话来解释遗传算法，我会说遗传算法是一种优化问题的方法，通过创建许多解决方案并以与进化概念相关的某些方式更新这些解决方案，以达到“足够好”的解决方案或可能的最佳解决方案。
在连续问题中，您想要找到最优值的决策变量采用实数，GA 中的解决方案如图 8 所示。这被称为染色体(有时被称为字符串)。下面的每个方块被称为一个**“基因”，而每个基因取的值被称为一个“等位基因”**。
**图 8:**GA 中一条染色体的例子(图片由作者提供)
在现实生活的问题中，大多数决策变量是受约束和有界的，因此它不会取无穷大的值(这不是一个实数)。例如，如果你有一个优化问题，想让某个公司的利润最大化(或成本最小化)，它可能会问你我们能设定的最大劳动小时数是多少，通常是给定其他条件。你可能首先倾向于说，我们可以有无限的小时数，但由于这是不可行的，公司往往会设定一个每月的最大限制，例如，它可能会说每周的小时数不应超过 120，因此，小时数的下限( x )将是 0，上限将是 120 ( 0≤x≤120 )。
既然我们可以将决策变量 x 放在界限之间，那么就可以找到计算小时数的实数。
图 9: 每个基因及其对应的 2^i(图片由作者提供)
对于图 9 中的染色体，或任何其他编码为 0 和 1 的 GA 染色体(在连续问题的情况下)，每个基因将用 2^i 表示(2 的 I 次方，其中 i 从 0 开始，在最右边，染色体中的基因越多，就增加 1，即 2⁰，2，2，2，…，2^i )。
为了解码这个染色体(将其转换为实数值)，我们使用公式 1，其中通过将基因中每个值与其对应的 2^i 的乘积相加来计算比特* 2^i 的总和。查看图 9，从右边开始，这将等于(02⁰)+(12)+(0 * 2)+(0 * 2)+(02⁴)+(12⁵)+(02⁶)+(12⁷)+(12⁸)，这将给出值 418。*
公式 1: 解码 g a 染色体
对于公式 1 的第二部分，精度，公式在下面的公式 2 中给出，其中 l 是染色体的长度，在我们的情况下是 9，因为我们有 9 个基因， b 是上限，我们有 120(在该示例中给出为允许的最大小时数)，而 a 是下限，为 0。现在的精度将是*(120–0)/(2⁹-1)，等于 0.234833，因此解码染色体将是 4180.234833+0 ，即 98.16 小时——一个介于 0 和 120 之间的值。
公式二: GA 精度
重要提示:如果我们将 9 基因染色体中的所有基因替换为 1，我们应该得到允许的最大值 120，如上限所定义，如果我们将所有基因替换为 0，我们应该得到允许的最小值 0，如下限所定义。当我们都是 1 时，让我们试着解码染色体。我们乘以 2^i 的比特总和将是*(12⁰)+(12)+(1 * 2)+(1 * 2)+(12⁴)+(12⁵)+(12⁶)+(12⁷)+(12⁸)，看，没有零，这将给出我们总共 511。如果我们用精度 0.234833 乘以 511，并加上 a (为 0)，我们将得到 120。注:你实际上会得到 119.99963，因为精度 0.234833 有更多的位数但我只取了小数点后的前 6 位，然而，如果你包括所有的位数，你应该得到正好 120。
染色体表示(编码)称为“基因型”，而染色体的解码值称为“表现型”。
**注:**染色体的长度( l )由用户设定。字符串越长，解码值就越准确，但这需要在计算时间上有所取舍。
如果我们有不止一个决策变量呢？
假设我们有一个最小化问题，我们需要为 x 和 y 找到最佳值，这将给出最低的 f(x) 。你会如何表达？简单，我们会有一条染色体，其中一半基因代表 x ，另一半代表y。请记住，对于每一个 x 和 y ，代表每一个开始的基因都有一个相应的 2⁰.值
参见图 10，其中绿色基因代表 x 而蓝色基因代表 y ，它们都占据相同的字符串，但是在对每个字符串进行解码以获得其相应的值时，它们应该被分别对待。你用和上面完全一样的方法解码。当你有两个以上的决策变量时，同样的原则也适用。
图 10: 具有两个决策变量(x 和 y)的染色体(图片由作者提供)
在深入了解 GA 之前，您需要了解的术语:
除了上述术语，如染色体、基因、等位基因、基因型和表型，我在这里解释一些其他的术语，它们的解释可能会相互交织:
1-种群:我们说的种群，是指某一代的一组解( gen )。请记住，GA 是一种基于群体的搜索算法，这意味着在每一次(gen)中，我们在搜索空间中都有几个解决方案。所有这些都有可能更新并成为新的解决方案。在 GA 中，群体大小在整个搜索过程中保持不变，因此如果您的群体大小为 100，您将在每个 gen 中有 100 个解决方案，每个都是可以解码为某个值的染色体或字符串。
图 11: 人口规模为 10，向读者显示前 4 个(图片由作者提供)
图 11 显示了一个群体大小为 10 的例子(群体大小通常比 10 大得多，但是为了便于说明，我使用了 10)，每个群体的染色体大小为 8。所有 10 条染色体都填充了 0 和 1(我只显示了填充的前 4 条，也是为了说明的目的，但它们都将填充 0 和 1)。
重要提示:您想要开始算法的初始群体是随机选择的。你最初设置染色体的长度和你想要在群体中有多少条染色体(群体大小)，随机填入 0 和 1，你的第一代就是这种情况。下一代的种群是操纵和更新上一代种群的结果，，即创建一个 gen #1 的随机种群，产生的后代成为 gen #2 的种群，然后他们的后代成为 gen #3 的种群，以此类推。
**2 代:**您的算法在终止前将运行代代。每一代都有相同的人口规模，但有不同的解决方案(有些可能与上一代相同)。在进入下一代(例如从 gen #1 到 gen #2 )之前，您需要使用交叉和变异算子更新您的当前种群，以在搜索空间中创建新的解决方案(后代)。当你得到一组等于种群大小的新解后，你就可以进入下一代，重新开始使用新解作为你的种群。
3-父母和后代:在每一代中，你们当前的人口都是潜在的父母，有一些机会“交配”并产生“后代”，即有机会成为父母。这些后代是一组新的解决方案，将继续成为下一代的群体，然后他们的后代将成为下一代的群体，以此类推。把它想象成我们在现实生活中是如何产生后代的。
我们如何更新人口和创造后代？
GA 的灵感来源于进化和适者生存，意思是为了产生后代， 2 条染色体或“父母”会繁殖创造 2 个后代或“孩子”。
父选择:
因为我们在寻找解决问题的好的或最好的解决方案，我们需要尝试让我们的新的和更新的解决方案来自好的解决方案。
将有一个父代选择方法，我们将应用于群体以找到 2 个好的解决方案，这将是 2 个父代，并对所选的父代应用称为交叉的算子以产生子代。那么，我们如何才能确保选择 2 个好的解决方案来做父母呢？
首先，你需要知道仅仅因为一个解决方案(染色体)与群体中的其他部分相比不好，并不意味着它不会作为父代被选中，这仅仅意味着它被选中的机会更低。有许多父母选择方法发展，但两个广泛使用的是锦标赛选择和轮盘赌选择。
**1-锦标赛选择:**想法很简单，你从群体中随机选择 k 个解决方案(有或没有替换)，其中你设置值 k ，并挑选最好的一个作为父#1，然后通过挑选另一个 k 解决方案并选择最好的一个作为父#2 来重复。简单吧？但是你怎么知道哪个是最好的呢？你通过比较它们对应的目标函数值就知道了至于说哪个染色体是你的 f(x) 的最佳选择。
举例:我们以布斯函数 f(x，y)=(x+2y-7) +(2x+y-5) 为一个最小化问题，其中 x 和 y 均以 -10≤x，y≤10 为界，其中-10 和 10 为下界( a )和上界我们想知道xx和 y 的值是多少，这将使我们得到最低的 f(x) 。
图 12: 使用锦标赛选择方法的父母#1 选择(图片由作者提供)
现在我们要选择父母来产生后代，我们设置 k=3 。我们从我们拥有的群体中随机选择 3 条染色体，然后我们将每条染色体解码成实际值 x 和 y 。从随机选取的第一条染色体开始，例如，如果解码后的 x 为 2.1，解码后的 y 为 3.6，我们将这些值代入 f(x) 得到f(x)=(2.1+2 * 3.6-7)+(2 * 2.1+3.6–5)，等于 13.13。然后我们尝试另一条被选中的染色体，通过同样的过程发现，例如，它的 f(x) 是 8.32，那么我们选中的最后一条染色体和它的 f(x) 是 16.84。由于这是一个最小化问题，我们需要最低的 f(x) 作为更好的解决方案，因此，给我们 8.32 的染色体优于给我们 13.13 和 16.84 的另外两条染色体，所以这将是父代#1 ，这在图 12 中示出。为了找到父母#2，我们重复同样的事情。【f(x)】对于任何一条染色体都称为适应度，适应值，或目标函数值。
因此，使用以下步骤应用锦标赛选择方法:
- 随机选择 k 个方案
- 为每个 k 染色体找到 f(x)
- 选择给出最佳 f(x) 的染色体，如果有多个解并列最佳，选择任意一个
- 设置为父#1
- 重复查找父#2
2-轮盘赌轮选择:**染色体的适应度(【f(x)】)用于关联概率以选择亲本。对于最大化问题，f(x) 越高，被选中的概率就越高。如图 13 所示，我们需要从群体中选择 5 个解决方案。概率基于解决方案与其他解决方案相比有多好，概率越高，被选中的机会就越大，这就是适者生存理论，但仍然会给更差的解决方案一些被选中的机会。
图 13: 轮盘赌轮盘选择方法(图片由 NCL 提供)
图 14: 概率的累积和(图片由作者提供)
为了得到每个解的概率，你把所有的适应值( f(x) )加在一起得到总数，然后用每个 f(x) 除以总数得到它在总数中所占的百分比。然后，您选择一个介于 0 和 1 之间的随机数，并从概率集中选择解决方案作为父#1。如果 5 个解决方案基于它们的适合度得到概率 5%、12%、14%、31%和 38%，并且你的随机数出来是 0.89，那么它将在 0.62 和 1.00 的范围内，这将使我们选择染色体#3，它有 38%的概率被选中。如果我们的随机数是 0.16，那么我们会选择 4 号染色体，其概率为 12%。正如您在图 14 中看到的，范围是基于概率的累积和。
***表 1:*5 条染色体及其相应概率的示例(作者提供的表格)
另一个例子:如果我们有 5 条染色体，它们的适应值如下:#1: 3.12、#2: 5.18、#3: 6.46、#4: 4.23 和#5: 3.66，对于一个最大化问题，我们首先将它们相加得到它们的总和22.65。现在，我们将每个除以总数*(即 3.12/22.65)得到百分比。我们将分别得到 0.13775、0.2287、0.28521、0.18675 和 0.16159，当你相加时，应该得到 1.00。之后，我们找到累积概率，这允许我们创建一个范围，我们的随机数将从中进行选择。在表 1 中，如果我们得到一个介于 0 和 0.137748344 之间的随机数，那么染色体#1 被选为亲本的概率是，为了得到染色体#4，该随机数应该高于 0.651655629 并且低于 0.838410596。*
好吧，但是如果我们有一个最小化问题会发生什么呢？
在最大化问题中，染色体的概率与其适应值相关，适应值越高越好，概率也越高。但是，如果我们有一个最小化问题，适应度越小越好，但我们需要将它与更高的概率相关联，如何实现？有许多方法可以做到这一点，我选择的一种方法是取每个适应度值的反相、 f(x) ，这样当你取最低数字的反相并与其他数字的反相比较时，它将是最高的。
例如，如果我们有一个最小化问题，3 条染色体的适应值是 2、4 和 6。我们希望 2(最低的 f(x) )得到最高的概率，6 得到最低的概率。所以，我们把它们反过来:2 会变成 1/2 (0.5)，4 会变成 1/4 (0.25)，6 会变成 1/6 (0.16667)。加上 0.5 到 0.25 到 0.16667，现在健身总数是 0.91667。因此，相关概率分别为 0.54545、0.27273 和 0.18182。可以看到 2，最低的 f(x) ，概率最高为 0.54545。
交叉:
现在我们有了 2 个父代，下一步是执行交叉操作并创建后代或子代。做交叉的方法有很多，这里我将解释两种常用的方法:
***重要提示:*我将使用字母而不是 0 和 1 来展示它是如何工作的，因为用 0 和 1 来解释可能会引起混淆。
#1-单点交叉:
图 15: 单点交叉示例(图片由作者提供)
当我们有 2 个双亲时，我们通过随机选择一个截止点来应用单点交叉。您可以通过选择一个随机整数来指定交叉发生的位置。例如，假设我们的随机整数是 6(这取决于您将使用什么编程语言，例如 Python，从 0 开始索引)。所以分界点之后的基因会在双亲之间交换。参见图 15，来自父#1 的[R，Z，P]将与来自父#2 的[A，F，W]互换，这将创建子代:子#1 和子#2。
#2-两点交叉:
图 16: 两点交叉示例(图片由作者提供)
这个想法和单点交叉是一样的，但是我们不是随机选择一个整数，而是选择两个整数并交换它们之间的值。在图 16 中，两点交叉使我们用[P，S，D]交换[T，B，L]来创建后代。您可以通过 if 或 while 语句使这两个随机整数彼此不同，也可以允许这两个整数偶然相同，但如果发生这种情况，它将成为单点交叉。这是基于用户的偏好。
***注意:*交叉算子可以基于概率来完成，因此您不会每次都执行交叉，但是，大多数研究倾向于应用概率 1 (100%),交叉确保算子将在每次选择父代后发生。
突变:
为了在搜索空间中产生多样性，以一定的概率(通常很低，例如 0.1 或 0.01)引入变异算子。在通过杂交两个父代来创建子代之后，对子代应用变异。
图 17: 突变实例(图片由作者提供)
这样做的方法很简单:你从第一个孩子开始，一个一个地检查每个基因。你从第一个基因开始，得到一个随机数，如果这个随机数小于突变的概率，你就突变，否则，移动到下一个基因，应用另一个随机数，以此类推。但是当我们变异时会发生什么呢？很简单，如果你想突变的基因的值是 0，它就会变成 1，如果基因的值是 1，它就会变成 0。请看图 17，红框表示哪些基因将被突变，绿框显示突变的结果。由于突变的概率很低，所以不会有很多(甚至零)基因会发生突变。
把所有的放在一起
下面的流程图，图 18，是我个人在使用锦标赛选择作为父选择方法时为 GA 开发的流程图。我发现网上几乎所有的流程图对初学者来说都有点难以理解。流程图中的符号如下: M 为世代数， N 为种群大小， p_c 为交叉概率， p_m 为变异概率， k 为锦标赛选择时随机选择的染色体数。
图 18: 带有锦标赛选择的 GA 流程图(图片由作者提供)
首先，我们选择世代数( M )、群体大小( N )、交叉概率( p_c )、突变概率( p_m )、锦标赛选择要选择的染色体数( k )。假设我们设置 M=100 ， N=120 ， p_c=1.00 ， p_m=0.10 ， k=3 。我们要解决的问题是一个连续最小化问题。
- 我们随机创建一个 120 条染色体的群体(每条染色体由 0 和 1 随机创建，长度由您选择( l )。此时此刻，我们在 gen #1 。
- 使用锦标赛选择选择 2 个父母的时间到了。我们从群体中随机选择 3 个解决方案，并找到具有最佳适应值(最低 f(x) ，因为我们正在处理最小化问题)的解决方案，这将是 parent #1 。然后，我们再次选择 3 个随机解决方案，并找到最佳方案，即 parent #2 。
- 在 p_c 处，我们将两个父母杂交得到两个孩子。
- 在下午*，我们对 2 个孩子进行变异，得到 2 个变异的孩子。*
- 我们将这两个变异的孩子存储在一个数组中。
- 做步骤 2 到 5 N/2 次(60 次)——60 因为 120/2 是 60。我们需要为每一代后代重建一个 120* 的种群，以保持种群规模一致。因为每次我们产生 2 个孩子或者 2 个突变的孩子，我们需要执行步骤 2 到 5 60 次才能得到下一代的 120 个种群( 1202* )。将所有产生的变异子代存储在一个数组中。在这一点上，我们应该有 120 个种群，它们是 gen #1 的突变后代。*
- 我们转移到下一代， gen #2 ，重复步骤 2 到 6* 。产生的后代现在将成为第三代的种群。*
- 继续这样做，直到你完成所有的 100 代。
- 你有两个选择: 1) 要么从 gen #100 (收敛解:你的算法在终止前收敛到右边的解)中选择最佳解(变异的子染色体)，要么， 2) 从每一代的变异子染色体中，在你进入下一代之前，将最佳的变异子染色体存储在一个单独的数组中。你对所有代都这样做，这样在你的算法结束时，你将有一个数组，它对每代都有最好的解，每代都有你的算法所见过的最好的 100 个解。然后从这 100 条染色体中选出最好的作为你的最终解决方案——我，我自己，选择选项#2，因为这样，你可以确保你有算法遇到的最好的答案因为在数组中，如果你最终选择了算法收敛到的答案，解决方案#100 就是相同的解决方案，因为当你选择算法收敛到的答案(选项#1)时，你选择的是唯一的最好的 gen #100 ，它与数组#100 相同这样，你就能确保从所有 100 代人中选出最好的，而不仅仅是最后一代。因为很有可能你可能在更早的一代(例如 gen #42 )达到可能的最佳解决方案，但随后 GA 算法将开始进入搜索空间中比你在 gen #42 时更差的其他地方，并最终收敛到一个糟糕的解决方案。
- 现在你有了最好的染色体，解码它得到真实的值，这样你就解决了问题！
恭喜你！您现在知道 GA 是什么以及它是如何工作的了！
摘要
遗传算法是一种强大的基于种群的搜索元启发式算法。它的灵感来自于进化论及其概念，如繁殖和适者生存。
在这个解释中，我介绍了遗传算法如何应用于连续优化问题，其中染色体用 0 和 1 表示(编码)。我们学习了如何将一条染色体解码成实际值和如何选择父母，进行交叉产生孩子，以及如何对他们进行变异。关于如何执行遗传算法的流程图和逐步指南也已经过详细说明。
最后注意:**交叉和变异的相同原理可以应用于组合问题，例如 TSP，其中您想要优化的不是采用实数的决策变量，而是离散元素*，例如旅行者或车辆路线。虽然交叉和变异背后的思想对于组合问题来说是相同的，但是我们应用它们的方式略有不同，因为您不希望以像[A，D，B，D]这样的旅行者路径结束，其中城市 D 被提到两次，而城市 C 不包括在路径中，如果您在离散问题上使用连续的交叉或变异方法，这可能会发生。*
2020 Dana Bani-Hani —未经许可和适当引用，不得使用由 Dana Bani-Hani 开发的文章、代码和图像。
参考
荷兰，约翰·亨利。自然和人工系统中的适应:生物学、控制和人工智能应用的介绍性分析。麻省理工学院出版社，1992 年。
图二:https://www.anotherbookondatascience.com/chapter6.html
图 6:https://www . cs . CMU . edu/AFS/cs/project/Jair/pub/volume 15/ambite 01 a-html/node 9 . html
【http://www.edc.ncl.ac.uk/highlight/rhjanuary2007g02.php】图 13:
基于遗传算法的机器人控制器方法
用 Python 实现
今天，我们要解决的一个现实问题是设计一个机器人控制器。有许多技术可以用来解决这个问题。其中包括遗传算法、粒子群优化算法和神经网络。
我们需要做的是将一种算法应用于机器人，作为设计机器人控制器的方法，使机器人能够执行复杂的任务和行为。
自主机器人是指在没有人类帮助的情况下，能够独立完成一定工作的机器人。
机器人的能力之一是从一点移动到另一点，这称为自主导航。想象一下，我们建造了一个可以在仓库里移动货物的机器人。在本文中，我们将使用 Python 语言实现这一功能。机器人如何看到它的局部环境？是的，我们将安装传感器，这使机器人可以环顾四周，我们给了它轮子，所以它可以根据传感器的输入进行导航。最大的问题是我们如何将传感器数据与电机动作联系起来，以便机器人能够在仓库中导航。
一般来说，我们经常使用神经网络，通过在学习过程中使用强化学习算法，成功地将机器人传感器映射到输出。但是我们今天将使用另一种方法，那就是使用遗传算法。通常，遗传算法将通过使用适应度函数来评估大量个体，以找到下一代的最佳个体，该适应度函数基于某些预定义的规则来计算个体的表现。
然而，我们将面临一个新的挑战，对每个机器人控制器进行物理评估对于一个大群体来说是不可行的，因为对每个机器人控制器进行物理测试是困难的，而且这样做需要时间。为此，我们将使用我们的遗传算法知识来设计和实现机器人控制器，并将其应用于虚拟环境中的虚拟机器人。
目标
我们的机器人可以采取四种行动:向前一步，左转，右转，什么也不做。
下图中机器人也有六个传感器。
有 6 个传感器的机器人
- 前面三个
- 一个在左边
- 一个在右边
- 一个在后面
迷宫由机器人无法跨越的墙壁组成，并将有一条勾勒出的路线。我们将设计一个机器人控制器，它可以使用机器人传感器来成功地引导机器人通过迷宫。
解决方案
遗传算法伪代码
基本遗传算法的伪代码如下
generation = 0;
population[generation] = initializePopulation(populationSize);
evaluatePopulation(population[generation]);
While isTerminationConditionMet() == false do
parents = selectParents(population[generation]);
population[generation+1] = crossover(parents);
population[generation+1] = mutate(population[generation+1]);
evaluatePopulation(population[generation]);
generation++;
End loop;
这个伪代码演示了一个遗传算法的基本过程。接下来，我们将用 Python 实现它们。
将传感器值映射到动作
如前所述，机器人有四个动作，可以用二进制表示如下:
- “00”——什么都不做；
- “01”——前进；
- “10”——左转；
- 还有“11”——右转。
我们还有六种不同的传感器。为了简化表示，我们将测量限制为二进制编码，也就是说，小于阈值的值表示检测到障碍物，大于阈值的值表示畅通无阻。6 个传感器为我们提供了 2⁶ = 64 种可能的传感器输入组合。由于一个动作需要 2 位，我们的控制器需要 64*2 = 128 位的存储来表示任何可能的输入。假设我们需要 128 位来表示不同组合指令。但是，我们应该如何组织染色体，以便对其进行编码和解码呢？
我们有一个人类可读的输入和输出列表，如下所示:
- 传感器#1(前):开
- 传感器#2(左前):关闭
- 传感器#3(右前):开
- 传感器#4(左侧):关闭
- 传感器#5(右):关闭
- 传感器#6(背面):关闭
我们还有一个二进制值为 10 的“左转”指令。下一步是获取六个传感器值并进一步编码。
000101 => 10
如果我们现在将传感器值的位串转换为十进制，我们会得到以下结果:
5 => 10
因此，我们可以使用传感器的十进制值作为染色体中的位置，表示传感器输入的组合，如下所示。
xx xx xx xx xx 10 xx xx xx xx (… 54 more pairs…)
从下图中可以看出，传感器值的组合产生了一个二进制输出，描述了典型的染色体如何将机器人的传感器值映射到动作。
这种编码方案初看起来可能很迟钝，染色体也不可读，但它有几个有用的特性。
- 首先，染色体可以作为一组位来操作，这使得交叉、变异和其他操作更加容易。
- 其次，每个 128 位的值都是有效的解。
履行
首先，我们需要在(world.py文件)中创建并初始化一个迷宫来运行机器人。我们创建的迷宫对象使用整数来表示不同的地形类型:
- 1 定义了一面墙；
- 2 是起始位置；
- 3 描绘通过迷宫的最佳路线；
- 4 是目标位置；
- 0 是一个空位置，机器人可以走过，但不在通往目标的路线上。
我们编写了一个构造函数来从一个 double int 数组创建一个新的迷宫，并实现公共方法来获得起始位置，在迷宫中找到一条路线。
个人
一个个体由一条由多个基因组成的染色体代表。
机器人
接下来，我们需要创建一个能够遵循指令并通过执行这些指令来生成路线的机器人。
人口
群体是指一组染色体。
遗传算法
我们实现了计算适应度、选择个体、交叉和变异的方法。
机器人控制器
最后，我们可以编写一个实际执行算法的类。如下创建另一个名为main.py的新文件。
输出。
很简单，对吧？
参考
[1] 遗传算法简介
[2]https://github . com/house cricket/基于遗传算法的机器人控制器方法
优化机器学习超参数的遗传算法
来自的照片
超参数调整对于机器学习模型的正确运行至关重要。您可以查看Timo bhm的文章，了解超参数调整的概述。
遗传算法为超参数调整提供了一种强大的技术，但它们经常被忽视。
在这篇文章中，我将展示遗传算法的概述。我还将提供一个详细的分步指南，介绍如何利用可用的库，使用遗传算法来优化机器学习模型的超参数。
遗传算法利用自然选择进化的基本概念来优化任意函数。
文章概述
这篇短文将介绍差分进化，并教授如何利用它来优化核岭回归中使用的超参数。
我提供了一些代码片段来展示如何在 Python 中使用差分进化算法。完整的代码和图表也在 GitHub 库中提供，因此任何人都可以深入了解细节。
差分进化算法概述
遗传算法，如差异进化，利用了自然选择进化的基本概念。在我们的例子中，我们有一个由包含具有不同值的参数的向量构成的群体。
参数相当于生物系统中的基因。它们的精确值在不同的向量之间是不同的。参数的不同组合导致向量显示不同的适应值。
随机参数突变被引入到群体中，并且具有较大适应度的向量比其他向量长寿。
作者图片
使用迭代过程，差分进化可以按照以下步骤最小化函数:
**1 —初始化:**用边界内随机参数值的 NP 个向量创建初始种群。
**2 —初始评估:**计算 NP 向量的函数值。
3 —对于群体中的每个载体:
**3.1 —突变:我们构建了一个突变向量，其中每个参数的值被计算为从群体中随机选择的其他向量的参数的突变。计算该突变载体的常用策略是 best1bin ，其中突变载体的每个参数 pᵢ 如下式所示计算。突变参数是最佳载体(具有最低值的载体)的 pᵢ 参数加上突变率 (F) 乘以随机选择的两个载体【r₁】和 r₂ 的差的变化。
***3.2 —重组:*通过选择其每个参数作为当前载体的值或突变载体的值来创建试验载体。对于每个参数，我们在(0，1)区间内生成一个随机均匀数 R 。如果 R 低于 a 重组率，那么我们接受突变参数；否则，我们使用当前参数的参数。
***3.3 —替换:*评估试验矢量的功能。如果它比当前向量更稳定，就用试验向量代替当前向量。
***4 —重复步骤 3，直到群体收敛:*当群体中函数的标准偏差小于函数平均值的特定百分比时，迭代停止。如果在最大迭代次数后没有达到收敛，循环也会停止。
所有这些过程都已经在主流编程语言的几个库中实现了。在这里，我们将使用 Python 中的 Scipy 的实现，它让我们只需使用几行代码就可以做任何我们想做的事情。
生成数据
例如，我们将使用遵循二维函数【f(x₁,x₂)=sin(x₁)+cos(x₂】的数据，加上区间(-2，2)中的一个小的随机变化来增加趣味。因此，我们的数据将遵循以下表达式:
在下图中，我们以灰度显示 sin(x₁)+cos(x₂) 的值作为参考。然后，我们用彩色点来表示我们的 441 个点(21 x 21 网格)，在区间 x₁ 😦-10，10)和 x₂ 😦-10，10)中用上面的表达式计算。
作者图片
我们在下面提供了一个代码片段，其中包含用于生成数据的函数:
机器学习模型
我们的目标是使用之前生成的数据来训练一个 ML 模型，该模型将能够预测函数 f(x₁,x₂) 在不同配置下的值。
在本文中，我将使用核岭回归 (KRR)。我们将对 KRR 使用径向基函数核，它取决于高斯核方差 γ 。对于 KRR，我们还需要优化正则化超参数 α 。如果你想知道更多关于 KRR 及其实现的细节，请随意查看我最近关于这个主题的教程。
在这里，我们使用 10 重交叉验证，其中我们的数据分为用于优化模型的训练集和用于测量模型准确性的测试集。作为准确性度量，我们将使用均方根误差( RMSE )，它代表测试集中的 f(x₁,x₂) 值与我们的模型预测的值之间的平均误差。
上一步:探索超参数空间
作为可选的第一步，我们可以执行网格搜索，查看 RMSE 如何随两个超参数α和γ的值而变化。
我们在下面展示了这个网格的外观，以及用于执行超参数网格搜索的代码。下图让我们初步了解了什么样的超参数值会产生较小的 RMSE。
作者图片
超参数调谐
最后，我们可以使用 Scipy 提供的差分进化算法，通过最小化我们模型的 RMSE 来优化超参数。
Scipy 的差分进化函数需要输入:
- *KRR _ 功能 *。这是其输出(RMSE)将被最小化的功能。它需要输入:I)具有超参数的元组以优化(α和γ)和 ii) X，y 包含我们的数据的变量。
- 定义超参数可能值的边界。
- 由KRR _ 函数使用的额外变量*。在我们的例子中，这将作为一个包含 X 和 y. 的元组给出*
- 差分进化算法的其他相关选项有:
- 策略。在我们的例子中，默认的策略=‘best1bin’* 已经足够好了。采用这种策略，突变载体的每个参数值作为该参数的最佳载体值的变化而获得，与另外两个随机载体的差异成比例。*
- 人口规模。这就选择了我们要考虑的矢量数量。一个较大的数字将会减慢进度，但会使它更有可能发现全局最小值。这里，我们使用默认值 popsize=15。
- 突变常数。该值控制参数在突变阶段的变化程度。较大的值意味着较大的搜索半径，但会减慢收敛速度。我们使用突变的默认值=0.5。**
- 复合常数。该常数控制重组阶段试验载体的参数改变的可能性。更大的值意味着突变更容易被接受，这可能会加速收敛，但有导致群体不稳定的风险。我们使用默认值重组=0.7。**
- 公差。该值控制算法何时被视为收敛。我们将使用 tol=0.01 ，这意味着当群体中所有向量的 RMSE 的标准差小于平均 RMSE 的 1%时，该算法被认为是收敛的。
此代码返回导致最小化 RMSE 的收敛超参数值:
*Converged hyperparameters: alpha= 0.347294, gamma= 3.342522
Minimum rmse: 1.140462*
我们可以取消函数KRR _ 函数的最后一行的注释，以打印所有中间值:
*alpha: 63.925979 . gamma: 19.290688 . rmse: 1.411122
alpha: 59.527726 . gamma: 2.228886 . rmse: 1.421191
alpha: 24.470318 . gamma: 3.838062 . rmse: 1.379171
alpha: 61.944876 . gamma: 15.703799 . rmse: 1.407040
alpha: 68.141245 . gamma: 0.847900 . rmse: 1.431469
[...]
alpha: 0.347408 . gamma: 3.342461 . rmse: 1.140462
alpha: 0.347294 . gamma: 3.342522 . rmse: 1.140462
alpha: 0.347294 . gamma: 3.342522 . rmse: 1.140462
alpha: 0.347294 . gamma: 3.342522 . rmse: 1.140462*
我们可以采用差分进化算法探索这些配置，并在之前的超参数网格搜索的基础上绘制它们:
作者图片
除了研究的所有中间值，我们还用红色标出了收敛值。这样，我们可以观察算法如何在设定的边界内探索不同的配置，并最终收敛到最小化 RMSE 的(α，γ)组合。
结论
我们已经介绍了如何生成一个简单的二维数据集，以及如何用核岭回归来拟合它。我们已经介绍了差分进化的基础知识，以及如何使用这种算法来优化机器学习模型的超参数。
请记住这里展示的数据集、代码、图像等。在这个 GitHub 库中提供。
如果你对遗传算法优化机器学习超参数的更复杂的应用感到好奇，请随时查看我们最近在利物浦大学与东北师范大学合作的工作。在这项工作中，我们使用差分进化算法来优化几个机器学习模型，以预测有机太阳能电池的效率。
这篇文章对你有帮助吗？让我知道你是否能够成功地使用差分进化算法来优化你的机器学习模型的超参数！
使用 DEAP 库的 Python 中的遗传算法
应用于大量营养素膳食计划的优化
在本文中，我将介绍 Python 中的遗传算法，以及一个优化膳食计划的例子。
示例以及如何应用优化
当优化膳食计划时，有许多事情要考虑。在这个例子中，我们将为一个人制定一个每周膳食计划，这个人已经决定了他们想要吃多少卡路里，以及这些卡路里中有多少百分比应该来自蛋白质、碳水化合物和脂肪。
除了这些固定值，优化程序还需要一个预定义的产品列表，用户可以从中进行选择。对于这些产品中的每一种，我们知道每单位的卡路里数，以及脂肪、蛋白质和碳水化合物的百分比。
我们示例中人员的目标数量是:
总热量= 2500 * 7 天= 17500 卡路里
蛋白质百分比= 30%
碳水化合物百分比= 50%
脂肪百分比= 20%
下面列出了可供选择的产品:
Python 中的遗传算法——产品表。作者配图。
优化的目标
优化程序的目标是找到一周的产品列表，其中每周总热量和宏量营养素尽可能接近目标量。
本文将使用 DEAP 的遗传算法。来源:https://deap.readthedocs.io/en/master/_images/deap_long.png
遗传算法优化
存在许多优化算法，遗传算法是其中之一。遗传算法之所以迷人，是因为其背后的思想非常耐人寻味:遗传算法是基于遗传学中自然选择的思想。
繁殖/交配
那么优化在遗传学中是如何工作的，比如在动物中？这是一个简单的原则:一个个体被编码为一系列基因。这种动物可能会也可能不会通过与伴侣繁殖将自己的基因组合传递给下一代。如果发生这种情况，后代将拥有来自母亲和父亲的基因组合。
变化
除了繁殖，还有第二个影响将决定新一代的基因库:突变。由于许多随机环境，有一些基因会在任何新个体中随机改变。
选择
达尔文的选择原则指出，适者生存。我们认为在繁殖前死亡的动物有不良基因。因为它们不繁殖，所以它们不会把基因传给下一代。这样下一代的基因会比上一代略好。
人口优化
这种自然选择的原理可以看作是一种优化算法。通过死亡，大自然把每一代人的坏基因都扔了出去。剩下的人口会越来越好。
将遗传算法应用于其他优化
对于优化的其他用例，遗传算法实现了相同的迭代交配、变异和选择方法。而不是用一个基因序列作为一个个体，它可以是许多其他的东西。
例如，在优化膳食计划的例子中，我们可以将“购物清单”写成个人。只买 1000 根香蕉而不买其他东西会是一个相对糟糕的购物清单。每样东西买 10 个已经很现实了。
因此，我们为这种遗传优化所做的如下:
- 生成大量随机购物清单
- 通过测量它们离目标数量的距离来选择最佳的。
- 然后，将这些顶级候选项混合在一起，以给出新的购物列表，这些列表是顶级父候选项的随机组合(应用了一些随机变异)
- 我们重复第 2 步和第 3 步，直到我们观察到几代人都没有改善(或者尽可能长)
- 然后，我们从最终群体中选择最佳个体，我们确信这是我们可能拥有的最佳购物清单之一。
Python 中的遗传算法
听起来很神奇，我们用 Python 做个实际案例吧。我们将使用 DEAP 图书馆，因为它有许多我们可以重复使用的基因功能。你可以跟着这里的总笔记本走。
在 Python 中设置输入
首先，让我们确定目标营养素的数量。我用不同的方式设定它们，因为实际上它们通常以每份营养素的百分比来表示，但为了优化，用克来表示更容易。
Python 中的遗传算法——目标数量。作者配图。
创建产品表的第二件事是:
Python 中的遗传算法——产品表。作者配图。
为我们的具体示例设置 Python 中的 DEAP 工具箱
设计 DEAP 工具箱设置
现在是更困难的部分，为我们的具体例子建立 DEAP 工具箱。你需要指定你的染色体的形状。最简单的形状是列表。
在本例中，我选择了长度为 21 的列表，因为在 products 表中有 21 个产品。然后我知道第一个元素是香蕉的数量，第二个元素是橘子的数量等等。
为 DEAP 工具箱设置的语法
我知道，但是算法不需要知道。它在个体中是不可见的。正如我们在下面看到的，这个个体是使用 creator.create 创建的，这里它被指定为 list，但是有一个附加的 fitness。这种适合度被定义为 FitnessMin。
个人现在还没有填写。填充发生在函数“个人”被注册到工具箱的地方。个体是基于函数 n_per_product 的，它返回 21 个随机数的列表:正如您所认识到的，这些是每个产品的数量。
人口只是登记为一份个人名单。
评估函数是我定义的，它计算总购物清单的卡路里数与目标卡路里数之间的绝对差值。就像你在笔记本上看到的，把其他的量加进去是相对容易的。
Python 中的遗传算法—建立 DEAP 工具箱。作者配图。
交配，变异和选择功能是直接从 DEAP 图书馆。
优化循环
下面的函数进行优化。几乎是从 DEAP 的例单中逐字抄来的。感谢我为这个例子选择的设置，只需要做很少的修改。
Python 中的遗传算法——主函数。作者配图。
遗传算法的结果
上一代的最佳个体是下面显示为“单变量 _ 选择”列的列表。
Python 中的遗传算法。作者配图。
Python 中的遗传算法。作者配图。
Python 中的遗传算法——解决方案。作者配图。
多元优化
目前，我们只优化了卡路里的数量，而没有考虑是否主要是蛋白质、脂肪或碳水化合物远离目标。DEAP 有可能非常容易地从单目标转移到多目标优化。
代码中唯一要改变的是 evaluate 函数，它现在应该返回四个值的元组(卡路里误差、蛋白质误差、脂肪误差和碳水化合物误差),并添加一个权重向量来平衡每一个值的权重。
Python 中的遗传算法——多目标评估。作者配图。
单目标与多目标优化
进一步检查单目标和多目标优化的结果是有趣的。在使用当前权重的情况下，它给出了以下内容:
- 计算四个目标的误差，我们看到多元解的总误差更好
- 我们还看到误差的分布是不同的。例如，如果蛋白质的正确性更重要，可以通过增加蛋白质的权重来调整。
Python 中的遗传算法——分析结果。作者配图。
最终，产品表总是限制因素:在某些时候，不可能找到完美达到目标的特定产品的组合。为了有一个更好的解决方案，我们必须增加更多的产品。
结论
关于遗传算法的实际工作还有很多要了解的，但是我希望这篇文章至少给你一个使用 Python 中的 DEAP 库开始使用遗传算法的快速方法，以及一个很好的用例例子。
不要犹豫，使用带有两个例子的示例笔记本，在遗传算法的学习道路上更进一步。现在，感谢阅读！
遗传算法——解决 IBM 的 2020 年 1 月问题
遗传算法的 Python 介绍
蒂姆·莫斯霍尔德在 Unsplash 上的照片
你好。
这篇文章是对 GAs 的温和介绍，也是对 IBMs 2020 年 1 月问题的解决方案。如果你想创造你自己的 GAs 或者在读完这篇文章后想玩玩我的代码，请随意拿起这本装有所有代码的笔记本。尽情享受吧！
问题是
每个月 IBM 都会在他们的思考博客中发布一个与编程相关的挑战。通常，这些挑战与编程有关，但偶尔纸笔解决方案也是可行的。前一个是 2020 年 1 月挑战，下面是问题陈述:
“一个园丁有 12 桶特殊液体来浇灌他的兰花；正好有两桶有毒。使用任何数量，甚至一滴，从一个有毒的桶会杀死珍贵的兰花在 24 小时内。园丁在兰花死亡前只有三天时间，除非他能找出哪十桶是好的。他愿意牺牲四株兰花，用这些桶中的一个子集的混合物给它们浇水。他怎么能找到毒桶呢？”
表 1:挑战页面中的 8 筒配置
让我们花点时间思考一下问题是什么。本质上，我们有一个兰花浇水槽表，如上表所示。每个槽包括一组字母，每个字母代表一个桶。我们的任务是提出一个类似的表，其中有 4 朵兰花(行)，3 天(列)，总共 12 个桶，从 A 到 l 标记。我们想要这样的解决方案，即无论哪两个桶中毒，我们总是可以通过查看哪一天哪些兰花死亡来找出它。作为一个例子，让我们考虑在上面只有 8 个桶的环境中，A 和 B 中毒了。
- 第一朵兰花在第一天死去
- 第二朵兰花在第二天死去
- 第三朵兰花也在第一天死去
- 第四朵兰花存活了下来。
事实证明，无论你选择哪种桶的组合来下毒，你都不会得到相同的结果(兰花是如何死去的)。事实上，**每一对中毒的桶都有一个独特的结果，**这基本上是我们所追求的完美解决方案。
表 1:不起作用的 12 桶配置
乍一看，有 12 个不同的槽和 12 个桶，因此找到一个好的配置似乎很简单，但困难在于如果兰花在第一天死亡，剩下的两天浇水将不会提供任何额外的信息。上述解决方案不起作用的原因是不可能区分例如毒对 A&B 和 A&C，因为无论哪种方式，只有第一朵兰花会在第一天死亡，其余的存活下来！从第一张图中可以看出，2 天 8 桶的解决方案不包括在多天内对同一株兰花使用同一桶。
好的，我们可以猜测一个好的解决方案是每个槽大约有 2-3 桶。我们就不能试试不同的组合，看看什么有效吗？嗯，没有。
考虑到我们有 12 个不同的槽，为了简单起见，我们假设在每个槽中，我们正好使用 3 个不同的桶来给兰花浇水。可能的组合数将是(121110)，大约等于 2.8*1⁰ ⁷，所以强制所有组合是不可能的。但是，这个问题在 NP(不确定是什么意思？→ 看这个。即使搜索空间呈指数增长，也只需要相对较少的努力就可以检查一个解决方案是否是好的。
验证解决方案
毒桶只有 66 对可能(|{AB，AC，AD… LL}| = 12 选 2 = 66)。给定一种配置(例如上表)并检查所有 66 种中毒桶组合，我们可以通过简单地检查是否有任何相同的结果来确定解决方案是否良好。为什么会这样？因为如上所述，一个完美的解决方案，园丁必须能够准确地找出有毒的桶，但只看可怜的兰花发生了什么。因此，如果给我们一个给兰花浇水的配置，如果我们发现重复的结果，这不是最终的解决方案。
量化兰花结果的一个简单方法是用一个从 0 到 3 的数字来表示它们的每一个命运，这表示兰花死于哪一天(从 0 开始)。因此，对于有八个桶的表 1，如果 A 和 B 中毒，结果将是(0，1，0，3)。这里的 3 只是表示兰花存活了下来。我们使用第 1→ 0 天，因为零索引使编程更简单。因此结果(0，1，0，3)可以理解为“第一天兰花 1 和 3 死亡，第二天兰花 2 和兰花 4 存活”。
现在我们的任务变成了**寻找一个桶的配置(就像前面的表格一样),这样对于 66 个毒药桶对，所有的结果(我们用 0-3 的 4 个数字表示)都是唯一的。**因为我们喜欢单一的解决方案(而不是计算所有的方案)，所以我们可以利用 GAs。
遗传算法
作为进化算法的一个子类，遗传算法(GA)是一种元启发式算法，它使用进化过程的元素来解决搜索和优化问题。很拗口，但本质上归结起来就是不是迭代地改进一个解决方案，而是获取大量可能的解决方案，并将它们相互结合。
这基本上是所有气体能量的来源。想象一下，给你一个随机配置的桶，你确定这不是最终的解决方案。您应该移动/移除/添加哪些桶？你越来越接近了吗？你离最终解决方案还有多远？
事实证明这些是很难问的问题，因为这不是一个凸或可微的问题，很多好的方法是不可行的。这就是 GAs 的疯狂之处:**你不需要精确估计你离解决方案有多远——只是一种比较解决方案的方法。**添加一些随机性和大量的迭代，我们就可以了！
遗传算法很大程度上受到进化论的启发，并且使用许多相同的术语，这可能并不令人惊讶，但是让我们更详细地看看遗传算法的两个基本组成部分:
人口
一组候选解称为群体。在我们的例子中，群体中的一个成员将是三天中桶的一种配置。随机初始化种群，并且进一步的世代是初始种群的更新和改进版本。就像进化一样，旧的单位被新的、可能更好的单位取代。如何测试哪些解决方案优于其他解决方案？
健身
适应度函数给每个候选人一个分数。这个分数有两个目的。
- 选择—删除不好的解决方案
- 结束条件—检查我们是否找到了最终解决方案
适应度是你想要最小化/最大化的东西(对于 ML 的那帮家伙，你可以把它想成一个损失函数)。
但是在我们的问题中，衡量一个解决方案有多好的好方法是什么？我们的问题是谨慎的，它需要一些严肃的问题工程来找出什么样的答案结构会给出好的结果的潜在原则。
一种方法是采用结束条件并详述它。我们的最终条件是找到一种给兰花浇水的方法，这样无论哪一对桶实际上有毒，园丁总能精确地找出它们是哪两个桶。如果有毒桶的组合会产生完全相同的结果，则解决方案无效(记住 4 位数表示)。现在让我们反过来想想，如果我们有最坏的解决方案，我们不会使用任何桶。这将给园丁零信息，因为所有的毒药桶组合将产生重复！所以也许有一种可能的方法来衡量一个答案有多好，就是简单地数一数有多少重复！
气体的神奇之处在于，我们的测量不必完全精确。这就足够了，这是一个我们想要着陆的大概估计，我们可以让随机过程来处理剩下的事情。
因此，为了我们的目的，我们可以用一个适应度函数来计算桶的给定配置
66 - # of unique outcomes.
如果有任何重复的结果(这是我们想要惩罚的)，则适应性得分较高，而“更好”的解决方案得分较低。最优解的分数是 0，因为正好有 66 个唯一的结果。我们现在的目标是简单地最小化我们人口中成员的这种适应性。但是怎么才能最小化呢？
评估
第一步是评估人口。这是我们根据解决方案的好坏对其进行排名的地方。在我们的设置中，这是基于重复的数量。如果候选解具有较少的重复，则它们的排名较高，在没有重复的情况下，最好的总是有效的解。
选择
在我们对群体进行评估和排序之后，自然选择就发生了。有很多有趣的方法可以做到这一点，但关键的想法是去除不好的解决方案，以便为更好的解决方案留出空间。
交叉
现在，我意识到大多数麻省理工学院的学生对有性生殖有了基本的了解，但是我发现在和学生的交谈中，很多时候他们对细节有点模糊。所以让我们先来思考一下它是如何工作的。— 帕特里克·温斯顿开始了关于遗传算法的讲座
交叉有多种形式，但 GAs 的基本思想是好的解决方案可以相互组合，以产生可能更好的解决方案。在我们的例子中，我们可以使用一种最简单的交叉方法，即单点交叉。
单点交叉的工作原理如下:
- 取两个母解
- 选择一个随机的位置将它们分开
- 在子表之外，创建新的两个子解决方案，它们是两个父解决方案的组合。
在我们的例子中，分割位置(或支点)是一个随机的槽。在下面的图片中，单点杂交是在随机槽(兰花 3 |第 2 天)对两个任意亲本进行的
父配置
相应的子配置
对于交叉，可以包含精英主义、，这意味着在交叉后是否保留父代。如果保留父代，我们就不能创造同样多的子代，因为否则，种群规模将在每次迭代中增长，这可能会导致一些不稳定。通常，精英主义使算法稳定，因为好的解决方案停留的时间更长。如果我们在没有精英主义的情况下进行杂交，这意味着我们可以创造更多的后代，但如果进行过于随机的杂交，我们可能会失去潜在的可行解。
交叉的一个问题是，它本质上只是将旧的解决方案组合在一起。就其本身而言，这并不能保证找到一个好的解决方案，如果将两个好的解决方案组合在一起并不能构成一个更好的解决方案，我们可能会陷入局部最小值。那么，我们如何逃离死胡同，想出更新颖的解决方案呢？
突变
记住，当你在生活中不知道该做什么时，总是随机选择。省去了同样预期收益的麻烦。—组合学老师，2019
这里也是如此。与交叉相对应，突变是纯粹的随机变化。任意改变群体中个体成员的随机因素服务于一个重要的目的，因为我们不知道我们是否实际上接近实际的最佳解决方案，或者我们是否被困在局部体面的解决方案中。在更抽象的层面上，如果一个群体仅通过使用相同的候选人池来进化，它很可能变得非常同质，并可能错过更好的解决方案。
在我们的兰园中，变异将会从某个配置中随机添加和删除桶。通常，变异的作用较小，用于逃脱死胡同，因此变异率(即候选解发生变异的概率)较小。
过多的变异会使遗传算法变成一个随机猜测机器，过少的变异会导致它错过潜在的非常好的解决方案。慎用。
算法
总结我们到目前为止学到的东西，并放入算法框架中，
- 首先，初始化种群并定义一个适应度函数。
2.其次，重复以下步骤，直到找到有效的解决方案。
- 评估:根据候选人的健康程度对其进行排名。
- 选择:删除弱(不太适合)的候选人
- 交叉:繁殖后代解(即通过合并旧解产生新的候选解)。
- 突变:添加一些突变(在这里和那里随机调整候选)。
由于显而易见的原因，循环的每次迭代，新的群体被称为代、。这些操作的顺序可以根据不同的 GAs 而有所不同，但是理论上就是这样，现在到 Python！
代码
现在我们可以开始实现实际的算法了。在下面的代码中，我们从导入组合-方法和随机- 包开始。字母表是包含所有可能桶的列表，从 A 到 L ，而 test_answer 显示了每个单独答案应该具有的结构，也就是一个 4x3 列表，其中每个元素也是桶的列表，即槽。
例如，在下面的代码中，slot [“D “，” K”]是第一行第二列的元素，所以这意味着兰花 1 在第二天用桶 D 和桶 K 浇水。
from itertools import combinations
import randomALPHABET = list("ABCDEFGHIJKL")test_answer = [
[["A","J"], ["D","K"], ["G"]],
[["G","H"], ["A","B"], ["D","E"]],
[["E","F"], ["H","I"], ["B",]],
[["C","J"], ["F","K"], ["I","C"]]
]
init_population 创建第一代，即填充那些 4x3 列表的群体，其中每个槽(元素)填充 3 个随机桶。
def **init_population**(n):
"""Return a population of n random solutions. Each solution is
a 4x3 list, with each element being a selection of 3 distinct
random barrels.
"""
return [[[random.sample(ALPHABET,k=3) for d in range(3)] \
for o in range(4)] for i in range(n)]
接下来我们定义适应度函数，为每个候选解调用。概括地说，我们希望它
- 检查所有可能的有毒桶组合
- 给定一个桶形配置，模拟每种组合的兰花会发生什么
- 计算独特结果的数量
- 返回 66 -那个数字
def **fitness**(candidate):
"""Return number of unique outcomes. Iterate through all
possible pairs of poisonous barrels and the twelve slots.
For each poisonous pair generate the outcome as a list
e.g. [0,1,2,3], where the indexes are the orchids and
numbers they day that orchid died (3 indicates that it
did not die). Calculate the number of unique outcomes by
adding outcomes o a set and return 66 - the length of
that set. For a perfect solution there are 66 unique
outcomes, thus return 0.
"""
combs = list(combinations(ALPHABET,2))
outcomes = set()
for poisoned in combs: # Iterate through all poisonous barrels
died_on = []
for o in range(4): # Orchid
dead_orchid = False
for d in range(3): # Day
if not dead_orchid and any([p in candidate[o][d]
for p in poisoned]):
dead_orchid = True
died_on.append(d)
elif not dead_orchid and d==2:
died_on.append(3) # Add the "survive" token 3.
outcomes.add(tuple(died_on))
return 66 - len(outcomes)
评估相当简单，只返回按适应度排序的人口。
def **evaluation**(population):
"""Return a population sorted by fitness."""
return sorted(population, key= lambda x:fitness(x))
选择返回人口中更好的一半(这样就有空间给更多优秀的候选人)
def **selection**(population):
"""Return top half of population."""
return population[:len(population)//2]
接下来是性的部分，即*交叉。*请注意，交叉操作会返回一个两倍于输入大小的新群体！所以我们假设选择是预先完成的。
def **crossover**(population,elitism=False):
"""Return a new population, generated by randomly pairing
members of population (out-of-place). For each random pair,
select a random pivot slot and generate 2 children:
child1[j] = parent1[j],
child2[j] = parent2[j], when j < pivot slot
and
child1[j] = parent2[j],
child2[j] = parent1[j], when j >= pivot slot
If elitism
return parents and the child1s.
Else
return child1s and child2s
"""
children = []
n_pop = len(population)
for i in range(n_pop): # Cross N times
parent1,parent2 = random.sample(population,k=2)
child1 = [[None for a in range(3)] for b in range(4)]
child2 = [[None for a in range(3)] for b in range(4)]
pivot = random.randrange(12) # Select a pivot slot.
for j in range(12): # Iterate through slots
o = j//3
d = j%3
if j < pivot:
child1[o][d] = parent1[o][d]
child2[o][d] = parent2[o][d]
else:
child1[o][d] = parent2[o][d]
child2[o][d] = parent1[o][d]
children.append(child1)
if not elitism: children.append(child2)
if elitism:
return population+children
else:
return children
还有最后一个成分，*突变。*对于每个候选，它选择是否变异，取决于 p_mutate。如果它确实发生了变异，无论是增加还是移除桶，它都会掷硬币。此外，如果只有一个或更少的桶，那么添加相同类型的桶和删除桶是没有意义的。返回一个(可能稍微)变异的群体。
def **mutation**(population,p_mutate):
"""Return a mutated population (out-of-place). For each
candidate, mutate with probability p_mutate.
If mutate:
Select random slot.
Flip a coin whether to add or remove a random barrel.
Else:
The candidate is not affected.
Return new (partially mutated) population.
"""
mutated_population = []
for candidate in population:
if random.random() < p_mutate:
# Mutate
# Choose random slot
o,d = random.randrange(4),random.randrange(3)
if random.random() < 0.5 and len(candidate[o][d]) > 1:
# Remove a barrel
remove = random.choice(candidate[o][d])
new_slot = [e for e in candidate[o][d] if e!=remove]
else:
# Add a barrel
addable = list(set(ALPHABET)-(set(candidate[o][d])))
add = random.choice(addable)
new_slot = [e for e in candidate[o][d]] + [add]
mutated_candidate = [[d for d in o] for o in candidate]
mutated_candidate[o][d] = new_slot
else:
# Don't mutate
mutated_candidate = [[d for d in o] for o in candidate]
mutated_population.append(mutated_candidate)
return mutated_population
我们走吧！现在我们只需创建训练循环。我选择了 0.9 的突变率，因为即使会发生突变，它对解决方案的影响也很小，所以有更多的突变也不会有什么坏处。此外，我只是粗略估计了 1000 人的人口规模，但它同样适用于 10，1000 或 10，000 人。精英主义似乎加快了事情的进展，所以这是可行的，但是你可能还是想尝试一下不同之处！
p_mutate = 0.9
n_pop = 100
best_fitness = 9999# Initialize population
pop = init_population(n_pop)
pop = evaluation(pop)i = 0
while best_fitness > 0:
pop = selection(pop)
pop = crossover(pop,elitism=True)
pop = mutation(pop,0.5)
pop = evaluation(pop)
if fitness(pop[0]) < best_fitness:
best_fitness = fitness(pop[0])
print(f"New best fitness: {best_fitness} | i={i}")
i+=1
print(pop[0])
它打印出类似这样的东西(在普通的笔记本电脑上大约需要 1-5 分钟)
New best fitness: 14 | i=0
New best fitness: 11 | i=5
New best fitness: 9 | i=13
New best fitness: 7 | i=14
New best fitness: 6 | i=20
New best fitness: 4 | i=23
New best fitness: 3 | i=70
New best fitness: 2 | i=101
New best fitness: 1 | i=770
New best fitness: 0 | i=915
[[['J', 'H'], ['A', 'K'], ['D', 'K', 'A', 'B']], [['L', 'F'], ['G', 'E', 'I', 'F'], ['D', 'L', 'G']], [['G', 'B'], ['L', 'K'], ['E', 'H', 'K', 'G']], [['A', 'I'], ['F', 'D', 'J', 'A'], ['E']]]
这就是我们的解决方案！对于实际的挑战，我重用了适应度函数中的一些代码来验证它实际上是一个正确的解决方案，但是假设一切顺利，这个应该是可行的。但是我们学到了什么？
有趣的是，我们可以从迭代中看到，计算最后几步需要成倍增加的时间(我运行了几次，得到了类似的模式)，这意味着从 1 或 2 适应度到 0 比从 14 到 2 要困难得多。有可能在适应度=1 附近存在局部最小值，其中交叉开始产生非常相似的结果，并且重要的多样性丢失。有可能这最后一步是通过纯粹的随机运气实现的，因为我们不知道有多少可能的正确解决方案。然而，突变率已经非常高了，所以将其更改为 1 不会有太大的差异，并且为了获得更稳定和更快的结果，该突变可能不只是一次更改一个插槽(可能在一次突变中更改几个？).
余波
当你处理一个搜索或优化问题时，遗传算法是有用的，而更传统的方法是不可行的(例如梯度下降或简化问题)，然而搜索空间太大而不能蛮干。从本质上来说，GAs 只是一种更精细的有根据的猜测方式，但是它们通过利用概率和计算能力以一种优雅的方式做到了这一点。他们有能力解决一些非常棘手的问题(比如旅行推销员问题)。然而，这些问题需要是 NP 的，因为检查一个解决方案的良好性(即计算适应度)在计算上不能太昂贵。因此，应用 GAs 适合复杂问题的特殊情况，在这种情况下，其他方法不适用(一种思考方式是，如果其他方法都不起作用，您可能想尝试一下 GAs)。一般来说，我建议使用 GAs 作为最后的手段，例如，当没有特定领域的知识或者问题不能被映射到一个更简单的图问题(它会有自己的，可能更快的方法)时。
一些好的属性是 GAs 很容易创建，并且(如上所示)可以使用普通 Python 来完成。此外，一个人不需要对问题有深入的理解就能找到解决方案，有时一个大概的启发就足够了！这就是我个人喜欢 GAs 的原因，它们提供了一个很好的中间地带，一个相对简单的程序可以用一种天生直观的方法来解决一个复杂的问题(毕竟，有什么比进化更容易理解)。
基因组组装——基因组分析的圣杯
组装 2019 新型冠状病毒基因组
T he 2019 新型冠状病毒或冠状病毒病(新冠肺炎)疫情目前已经威胁到整个世界。科学家们正在夜以继日地研究新冠肺炎的起源。你可能最近听说了新冠肺炎的完整基因组已经发表的消息。科学家是如何算出新冠肺炎的完整基因组的？在这篇文章中，我将解释我们如何做到这一点。
基因组
一个基因组被认为是所有的遗传物质，包括一个生物体的所有基因。基因组包含了生物体构建和维持所需的所有信息。
定序
我们如何读取基因组中存在的信息？这就是序列发挥作用的地方。假设你已经读过我的上一篇关于 DNA 分析的文章，你知道测序是用来确定一个有机体的单个基因、完整染色体或完整基因组的序列。
图一。PacBio 测序仪。PacBio 是第三代测序技术，可产生长读数。图片由肯尼斯·罗德里格斯提供，来自皮克斯拜 (CC0)
被称为测序机器的特殊机器被用来从我们感兴趣的基因组中提取短的随机序列。目前的测序技术不能一次读取整个基因组。它读取平均长度在 50-300 个碱基(下一代测序/短读取)或 10，000-20，000 个碱基(第三代测序/长读取)之间的小片段，这取决于所使用的技术。这些短片被称为读作。
如果你想了解更多关于病毒基因组如何从临床样本中测序的细节，你可以阅读以下文章。
基因组组装
一旦我们有了基因组的小片段，我们必须根据它们的重叠信息将它们组合(组装)在一起，并构建完整的基因组。这个过程叫做组装。组装就像解决一个拼图游戏。被称为组装器的特殊软件工具被用来根据它们如何重叠来组装这些读数，以便生成被称为重叠群的连续串。这些重叠群可以是整个基因组本身，也可以是基因组的一部分(如图 2 所示)。
图二。排序和组装
装配工分为两类，
两种主要类型的装配工
在生物信息学文献中可以找到两种主要类型的装配器。第一种是重叠-布局-一致性(OLC)方法。在 OLC 方法中，首先，我们确定读数之间的所有重叠。然后我们将所有的读数和重叠以图表的形式排列出来。最后，我们识别共有序列。SGA 是一个基于 OLC 方法的流行工具。
第二种汇编程序是 DBG 图法。DBG 方法不是使用完整的读数，而是将读数分成更短的片段，称为k-mer(长度为 k )，然后使用所有的k-mer 构建一个德布鲁因图。最后，根据德布鲁因图推断基因组序列。黑桃是一个基于 DBG 方法的流行汇编程序。
基因组组装会出什么问题？
基因组包含在基因组中多次出现的核酸模式。这些结构被称为重复。这些重复会使组装过程变得复杂并导致歧义。
我们不能保证测序机器能够产生覆盖整个基因组的读数。测序机器可能会错过基因组的某些部分，并且不会有覆盖该区域的读数。这将影响装配过程，并且那些遗漏的区域将不会出现在最终装配中。
基因组组装者应该解决这些挑战，并尽量减少组装过程中造成的错误。
如何评估程序集？
组件的评估非常重要，因为我们必须决定最终的组件是否符合标准。其中一个广为人知且最常用的汇编评测工具是。下面列出了一些用于评估组件的标准。
- N50: 覆盖组件总长度的 50%所需的最小重叠群长度。
- L50: 比 N50 长的重叠群的数量
- NG50: 覆盖 50%参考基因组长度所需的最小重叠群长度
- LG50: 比 NG50 长的重叠群的数量
- NA50: 要求覆盖组件总长度 50%的对齐砌块的最小长度
- LA50: 比 NA50 长的重叠群的数量
- 基因组比例(%): 与参考基因组比对的碱基百分比
弄脏手
让我们开始做实验吧。我将使用汇编程序****来汇编从测序患者样本中获得的读数。黑桃利用下一代测序读取。你也可以免费下载。您可以从相关的主页(我提供了链接)获得代码和二进制文件，并运行这些工具。********
键入以下命令，并验证工具是否正常工作。
****<your_path_to>/SPAdes-3.13.1/bin/spades.py -h
<your_path_to>/quast-5.0.2/quast.py -h****
下载数据
我想你知道如何从国家生物技术信息中心(NBCI)下载数据。如果没有，可以参考这个链接。
我们实验的读数可以从 NCBI 下载，NCBI 登记号为 SRX7636886 。您可以下载运行 SRR10971381 ，其中包含从 Illumina MiniSeq 运行中获得的读数。确保下载 FASTQ 格式的数据。下载的文件可以找到为**sra_data.fastq.gz**。您可以使用 gunzip 提取 FASTQ 文件。
提取之后，您可以运行下面的 bash 命令来计算数据集中的读取次数。您将看到有 56，565，928 次读取。
**grep '^@' sra_data.fastq | wc -l**
你可以从 NCBI 下载公开的新冠肺炎完整基因组[3]，GenBank 登录号为 MN908947 。你会看到一个 FASTA 格式的文件。这将是我们的参考基因组。注意，我们已经将其重命名为**MN908947.fasta**。
装配
让我们把新冠肺炎的作品汇编起来。运行以下命令，使用黑桃来组合读数。您可以提供压缩的。gz 档直接给黑桃。
**<your_path_to>/SPAdes-3.13.1/bin/spades.py --12 sra_data.fastq.gz -o Output -t 8**
这里我们使用了通用的黑桃汇编器作为本文的演示。然而，由于 reads 数据集由 RNA-Seq 数据组成(从我的上一篇文章中了解更多关于 RNA 的信息)，最好使用--rna选项。
在Output文件夹中，你可以看到一个名为**contigs.fasta**的文件，其中包含我们最终组装的重叠群。
评估装配结果
使用以下命令在组件上运行撤销。
**<your_path_to>/quast-5.0.2/quast.py Output/contigs.fasta-l SPAdes_assembly -r MN908947.fasta -o quastResult**
查看评估结果
一旦 QUAST 完成，您可以进入 quastResult 文件夹并查看评估结果。您可以通过在 web 浏览器中打开 report.html 文件来查看 QUAST 报告。您可以看到类似于图 3 所示的报告。您可以点击“扩展报告”了解更多信息，如 NG50 和 LG50。
图三。撤销报告
您可以研究不同评估标准的值，如基因组比例 NG50、NA50、错配和重叠群数量。此外，您可以使用 Icarus contig 浏览器(点击“在 Icarus contig 浏览器中查看”)查看与参考基因组的重叠群比对，如图 4 所示。
图 4。撤销报告
从 Icarus contig 浏览器中，我们可以看到名为NODE_1的 contig 与新冠肺炎的参考基因组非常接近。它的基因组比例为 99.99%(如图 3 所示)。此外，29，900 个碱基对的总比对长度非常接近 29，903 个碱基对的参考基因组的长度。
可视化装配图
有一个名为 绷带 的工具可以用来可视化装配图。您可以从它们的主页下载预编译的二进制文件并运行该工具。您可以加载可在黑桃输出文件夹中找到的图形文件**assembly_graph_with_scaffolds.gfa**(进入文件→加载图形→选择。在Output中打开 gfa 文件)进行包扎，点击“绘制图形”进行可视化，如图 5 所示。请注意，图 5 中第一行线段中间的绿色长曲线线段对应于我们的黑桃组合的 NODE_1。
图五。使用绷带可视化的新冠肺炎读数数据集的黑桃装配图的一部分。
他们最初是如何发现新冠肺炎基因组的？
由于新冠肺炎的参考基因组现在是可获得的，我们可以评估我们的装配。然而，起初，新冠肺炎没有确切的参考基因组。那么科学家们是怎么弄明白的呢？正如我在之前的文章中解释的，分析病毒基因组属于宏基因组学，有许多技术可以做到这一点。他们分析了重叠群的覆盖范围(覆盖重叠群中每个碱基位置的平均读数)，并与蝙蝠 SARS 样冠状病毒(CoV)分离株— 蝙蝠 SL-CoVZC45 (GenBank 登录号mg 772933)【3】。结果显示，它们最长的组装重叠群具有高覆盖度(从我们的组装中，您可以看到 NODE_1 也具有高覆盖度值),并且与 bat SL-CoVZC45 非常接近。他们已经进行了更多的测试来证实这一点，我就不赘述了。
最后的想法
基因组组装为我们研究生物体基因组内部的实际情况铺平了道路。即使在新冠肺炎病毒爆发期间，基因组组装也在识别这种致命病毒的实际遗传密码方面发挥了重要作用。
如果你检查新冠肺炎基因组的大小，它是 29903 个碱基对(大约 30k 个碱基对)。随着第三代测序技术的进步，我们可能能够直接对小基因组如病毒基因组的全长进行测序。随着阅读长度变得更长，组装阅读的需求将会减少，最终，我们将可以从测序仪中直接获得基因组(特别是在宏基因组学中，基因组的范围从几千个碱基到几兆个碱基)！此外，革命性的基于纳米技术的方法，如量子测序技术【4】包括石墨烯纳米器件【5】可能会变得流行。
谢谢大家的阅读。如果你觉得我的文章有趣，请在你的网络上分享。我也很想听听你的想法。
干杯！
参考
[1]挖掘冠状病毒基因组寻找爆发起源的线索|科学|美国科学促进会(https://www . Science mag . org/news/2020/01/Mining-coronavirus-genomes-clues-outbreak-s-origins)
[2]李振玉等.两大类组装算法的比较:重叠-布局-一致性和 de-bruijn-graph，功能基因组学简报，第 11 卷，第 1 期，2012 年 1 月，第 25-37 页。https://doi.org/10.1093/bfgp/elr035
[3]吴芳芳，赵，于等等一种新型冠状病毒在中国发现与人类呼吸系统疾病相关。性质 (2020)。https://doi.org/10.1038/s41586-020-2008-3**
[4]张一日和金武南。从头全基因组组装的现在和未来。生物信息学简报，第 19 卷，第 1 期，2018 年 1 月，第 23–40 页。https://doi.org/10.1093/bib/bbw096
****[5]希雷玛和德克尔。用于 DNA 测序的石墨烯纳米器件。 Nature Nanotech 11，127–136(2016)。https://doi.org/10.1038/nnano.2015.307
使用德布鲁因图的基因组组装
基因组测序后，我们可以找出基因组中 DNA 核苷酸或碱基的顺序——组成生物体 DNA 的 As、Cs、Gs 和 Ts 的顺序。整个基因组不能一次全部测序，因为可用的 DNA 测序方法一次只能处理很短的 DNA 片段。因此，相反，科学家必须将基因组分成小片段*(缩写)*，对片段进行测序，然后按照正确的顺序重新组装，以获得整个基因组的序列。
基因组组装可以被描述为一种计算过程，它将之前提到的来自生物体细胞内靶 DNA 不同部分的称为读数的众多短序列集合在一起。这是一个算法驱动的自动化过程。DNA 序列组装程序利用序列重叠来以正确的顺序进行序列组装。
图 1-https://www.yourgenome.org/
实现基因组组装有许多挑战。一个主要的挑战是处理错误的读数。无论使用何种测序技术，读数都不会 100%准确。为了克服这种测序，可以多次使用相同的 DNA 片段。一个部分被排序的次数叫做覆盖率。覆盖面越广，可信度就越高。所以覆盖率高导致了大量的 DNA 序列的短阅读。这些短文像拼图中的小块碎片一样混在一起。它们应该被组织在一起，并按照正确的顺序组合成基因组序列。因此，组合这些短的阅读片段来获得原始基因组是一项艰巨的任务。
从头基因组组装
这是一种在不使用参考基因组的情况下将短的核苷酸序列组装成更长的序列的程序。在这种进行装配的方法中，假设没有源 DNA 序列长度、布局或组成的先验知识。序列汇编器的最终目标是从短序列中产生长的连续序列片段(重叠群)。然后，重叠群有时被排序并相对于彼此定向以形成支架。两种常见的从头组装器是贪婪算法组装器和布鲁因图组装器。在贪婪方法中，它的目标是局部最优，而在图方法中，它的目标是全局最优。我们将在本文中讨论后者。
一般 de nevo 装配也包括脚手架和间隙填充步骤。支架是将一系列不连续的基因组序列连接成一个支架，由已知长度的缺口分隔的序列组成。连接的序列通常是对应于阅读重叠的连续序列。
图 2-de nevo 装配的一般工作流程
德布鲁因图装配工
早期，一种应用于第一代测序数据的有效组装方法是重叠-布局-一致性方法，该方法涉及所有读数对的比较以识别重叠。但是这对于用第一代方法组合这些读数所需的计算既不实际也不困难。
在 20 世纪 40 年代，一位名叫 Nicolaas de Bruijn 的荷兰数学家开始对寻找最短的环形字符串感兴趣，该字符串包含给定字母表中所有可能的子字符串，每个子字符串长度相同。他想出的解决方案包括构建一个以所有可能的(k1)聚体为节点的图。如果节点 A 中的(k-mer 是 k-mer 的前缀，而节点 B 中的(k-mer 是 k-mer 的后缀，则每个 k-mer 都是从节点 A 到节点 B 的边。
现在这个问题的答案是找到一条穿过图的路径，这条路径恰好穿过每条边一次，或者换句话说，欧拉路径。下面是一个例子，其中长度为 10 的序列“ ATGCTAGCAC ”由五个长度为 6 的读取组合而成。
图 3-使用德布鲁因汇编程序的过程
读取被分成指定大小为 k 的较小片段。在上面的示例中，k 对应于 3。确定了 k-mers，并绘制了以(k–1)mers 为节点、k-mers 为边的德布鲁因图，如文中所述。通过这个网络追踪欧拉路径，导致原始基因组序列的重建。
在从给定的短读数重建原始序列的过程中，可以指定以下步骤。
步伐
- 从 k-mer 集合中取出所有(k-1)个 mer，例如 ATG、TGC-> AT、TG、GC。我们应该已经超过了 k-mer 读取的大小。
- 构造一个节点为 k-1-mers 的多图；仅当两个 k-1 mer 来自同一读数时，在两个 k-1 mer 之间画一条边。 Ex: GCT & CTA
带 GCT 和 CTA 的多重图
3.以这种方式构造的图保证具有欧拉轨迹，跟随该轨迹并连接节点以形成我们的原始序列。将出现与此类似的图形。
多重图重建序列 ATGCTAGCAC
现在这个算法可以用来组装 k-mer 读数。我们可以放宽条件，接受超过给定长度的读取，并将每个 k-mer 分成(k-mer，以考虑具有 k-n 个重叠而不是 k-1 个重叠的读取。此外，重建更容易组装的部分(重叠群)并省去不明确的部分是方便的。
以下 Jupyter 笔记本可用于实现德布鲁因汇编程序。
用于德布鲁因装配工的 Jupyter 笔记本
的确，基于 de Bruijn 图的组装方法开始时，有些违背直觉，用一组较短的固定长度的全重叠序列代替每个读数，但这是一种流行的基因组组装方法。
可以免费下载、使用和修改的稳定和健壮的软件包已经被开发出来，用于使用 de Bruijn 图从短阅读中组装基因组。一种名为 Velvet 的流行软件似乎在组装基因组方面表现得非常好(主要是在细菌上)。
虽然 de bruijn 组装器是实现组装的流行手段，但是对于 de bruijn 基因组组装来说仍然存在一些挑战。序列错误、不均匀的测序深度、重复的部分和计算成本是几个主要的挑战。
参考文献:
- https://link . springer . com/content/pdf/10.1007% 2fs 40484-019-0166-9 . pdf
- https://www . your genome . org/facts/how-do-you-put-a-genome-back-together-after-sequencing
- 细菌基因组学-基因组组织和基因表达工具
面向数据科学家的基因组学、转录组学和蛋白质组学
细胞、DNA、RNA 和蛋白质
图片来源:维基百科，归功于威廉·克罗夫特。
你的基因组大约有 750 兆字节的信息(3 个 10⁹字母 x 1 个字节/4 个字母)。这大约是一个操作系统的一半大小，除了它为一个完整的人体编码，并且整个代码适合一个比一粒米小一百倍的体积。你的大脑是由你的基因组指定发展的，是一台不可思议的超级计算机，它需要的电力也比昏暗的灯泡少——实际上比人造超级计算机的能效高数万倍。
那么基因组是如何工作的呢？
基因组学、转录组学和蛋白质组学是数据驱动的领域，旨在回答基因组如何为一个有生命、有呼吸的人(或猫、或植物、或细菌)编码的问题。这篇文章向对“组学”数据感兴趣的计算科学家和工程师介绍了基因组学、转录组学和蛋白质组学，并希望快速介绍这些数据的来源和数据背后的关键生物学。这篇文章使用最少的术语和多种类比来阐明这些不同类型的“组学”数据之间的异同，以及它们如何为现存最复杂的软件之一——你的 DNA——提供不同的窗口。
牢房
细胞是所有生物的基本组成部分:人、狗、老鼠、树、花、苍蝇和细菌。所有形式的“组学”都在测量细胞内发现的大量物质。
这是用显微镜拍摄的一些细胞的照片。我用红色标出了一些单元格。每个红色圆圈对应一个单元格:
修改自维基百科。
罗伯特·胡克在 1665 年发现并命名了细胞。他称它们为细胞，因为在显微镜下它们看起来像“细胞”或小房间——换句话说，“细胞”被称为“细胞”，因为它们在显微镜下看起来像监狱的细胞。
来自人、狗、老鼠、树、花和苍蝇的细胞是“真核细胞”，这意味着这些细胞将它们的 DNA 打包在一个袋子里(细胞核)。
来自细菌的细胞被称为“原核细胞”，因为它们不把 DNA 保存在袋子里(即它们没有细胞核):
这是早期(真核生物)细胞的特写照片，细胞核用棕色圈起来:
DNA 和基因
你的 DNA 是由 30 亿个字母组成的长序列，存在于你的细胞核内。你身体里的每个细胞(很少例外)都有你整个基因组的完整拷贝(即你所有的 DNA)。因为你的身体里大约有 37.2 万亿个细胞，这意味着你携带了大约 37.2 万亿份你的整个 DNA 序列！其中的含义很有趣:这意味着你指尖的一个细胞包含了构建整个大脑所需的所有指令。
“基因”是编码制造蛋白质指令的特定 DNA 片段。
我们可以把身体想象成一个工厂，它需要某些“机器”(蛋白质)来运转:
基因是一组如何建造特定机器的指令。例如，基因 B 包含建造机器 B(蛋白质 B)的指令，基因 Q 包含建造机器 Q(蛋白质 Q)的指令等等。
只有 1% 的基因组实际上由基因组成。基因被称为基因组的“编码”部分，因为基因“编码”蛋白质。人类基因组中大约有 25，000 个基因，相当于 25，000 个使你身体运转的小机器(蛋白质)。
剩下的 99%的基因组是“非编码的”基因组的“非编码”部分仍然很重要，因为它告诉细胞如何利用“编码”部分。
换句话说，如果“编码”部分作为如何制造不同机器的指令，那么“非编码”部分作为如何在工厂中使用这些机器的指令:何时需要打开机器，何时需要关闭机器，需要多少台机器，何时应该使用机器，等等。
如果我们把基因组想象成一本书，它将包含一些关于如何构建机器的文本(编码部分，在下面以橙色和蓝色显示)，以及一些关于如何使用机器的文本(非编码部分，在下面以黑色显示):
由维基百科上的空白开卷图片修改而来
核苷酸:DNA 的构件(A，T，C，G)
DNA 中的 30 亿个字母来自一个有限的字母表，只有 4 个可能的字母:A、T、C 和 G。(有趣的事实:这就是为什么电影《Gattaca》讲述了一个基因“劣等”的人战胜他的社会的故事，在片名中只使用了字母 A、T、C 和 G。)
这是人类基因 S100A10(也称为“p11”)的完整 DNA 序列，基因组中最短的基因之一:
CCGGTTACCTCTGGTTCTGCGCCACGTGCCCCACCGGCAGGACGGCCGGGTTCTTTGATT TGTACACTTTCTAAAACCAAACCCGAGAGGAAGGGCAGGCTCAGGGTGGGATGCCCTAAA TATTCGAGAGCAGGACCGTTTCTACTGAAGAGAAGTTTACAAGAACGCTCTGTCTGGGGC GGGCGAGCGCTCTGCGAGGCGGGTCCGGGAGCGAGGGCAGGGCGTGGGCCGCGCGCCCGG GGTCGGGGGAGTCGGGGGCAGGAAGAGGGGGAGGAGACAGGGCTGGGGGAGCGCCCTGCC GAGCGCCCGCCAGGCTCCTCCCCGTCCCGCACCGCCTCCCTCTACCCACCCGCCGCACGT ACTAAGGAAGGCGCACAGCCCGCCGCGCTCGCCTCTCCGCCCCGCGTCCACGTCGCCCAC GTCGCCCAGCTCGCCCAGCGTCCGCCGCGCCTCGGCCAAGGTGAGCTCCCAGTTCGGCCC
【序列来源: ebi.ac.uk
DNA 的组成部分(四个字母 A、T、C 和 G)被称为“核苷酸”它们的全称是鸟嘌呤(G)、腺嘌呤(A)、胞嘧啶和胸腺嘧啶(T)。
每个核苷酸构件依次由碳、氢、氧和氮组成。例如，胞嘧啶由 13 个原子组成。这是 2D 关于胞嘧啶的“棍球漫画”:
基于cs.boisestate.edu所示的化学结构
这是胞嘧啶的 3D 效果图:
3D 渲染来源:维基百科
(技术说明:上面胞嘧啶的图片实际上是“核碱基”胞嘧啶，它是最基本的化学部分。“核苷”是核碱基加上糖核糖。“核苷酸”DNA 的直接构建模块——是核碱基加上糖核糖再加上一个或多个磷酸基团。因此，从技术上来说，为了让上面显示的胞嘧啶图片代表真正的 DNA 构建模块，它需要添加一个核糖和一个磷酸。)
当我们将核苷酸 A、T、C 和 G 串在一起形成 DNA 时，我们得到了一种叫做“核酸”的东西——因此 DNA 的全称是“脱氧核糖核酸”。
DNA 是双链的；为了简单起见，我在上面的卡通图中只展示了一条线。DNA 的双链性质是“双螺旋”的原因:
来自维基百科的动画
这两股 DNA 相互缠绕形成双螺旋。一条链中的信息是另一条链中信息的“镜像拷贝”。这是由于 A、T、C 和 G 构件是如何相互配对的。a 与 T 配对，C 与 g 配对。因此，如果一条链读为“AAATTC ”,则相反的链将总是读为“TTTAAG”。一条链的信息量等于另一条链的信息量。
拥有两份相同的信息似乎是一种浪费，但事实上 DNA 的双链性质非常重要:
- 双链促进了 DNA 复制(即复制整个基因组，这必须在每次一个细胞分裂成两个细胞时发生，因为每个“子细胞”都需要基因组的完整副本)；
- 双链使得身体能够错误纠正基因组(即，如果在复制过程中出现错误，双链能够纠正错误)；
- 双链比单链更稳定，这对生命蓝图的稳定非常重要。
从计算的角度来看，你只需要一条链的序列来进行分析。
人类基因组计划是一个国际项目，旨在找出一个人的完整 DNA 序列——即读出一个人基因组中所有 30 亿个 A、T、C 和 G 字母。人类基因组计划花费了 27 亿美元。如今，花少几个数量级的钱获得完整的基因组序列是可能的——例如，你可以花 299 美元通过 Nebula Genomics 获得你的整个基因组序列。
基因组学
基因组学是对人类、动物、细菌等的 DNA 序列的研究。为了了解健康和疾病，基因组经常被相互比较。
例如:
- 可以比较健康人和病人的基因组，以了解影响疾病风险或直接导致疾病的基因(例如参见“全基因组关联研究”)。
- 许多人的基因组可以进行比较，以了解与疾病无关的基因组中的自然变异——例如，影响头发颜色、眼睛颜色、身高和其他特征的基因。
- 为了重建生命树和理解进化史，可以比较人和动物的基因组。
基因的异同
这个星球上任何随机选择的男人和这个星球上任何随机选择的女人有 99.9%的基因相同。
黑猩猩和人类总体上有 96%的基因相同(在编码区域有 98%的基因相同):
狗和狼有 99.9%的相似性，事实上它们在基因上是如此相似，以至于从技术上来说它们是同一物种:
因此，大部分基因组学是关于识别导致差异的微小基因组部分(狗是一个特别有趣的研究物种，因为它们在大小、颜色、行为、寿命和疾病风险方面有很大差异)。基因组学可能是“大海捞针”，特别是在比较不同的人类基因组以了解疾病风险时，因为任何给定的两对人类几乎都是相同的。
各种基因组数据
假设一个人的 DNA 序列可以存储大约 750 兆字节。然而，在现实中，DNA 测序的过程并不完美，它不是从开始到结束获得完整基因组的一个完美读数，而是产生许多部分读数，这些读数必须像拼图一样组装在一起。例如，假设给你以下句子片段:
- “鸟儿飞了进来”
- 《天空中的苍蝇》
- “在天空中歌唱”
把这些句子对齐叠加起来，就可以重构出“小鸟在天空中飞翔歌唱”这句话了。
因为 DNA 是以这种方式测序的，所以直接从测序机器上得到的原始 DNA 序列大约是 200 千兆字节，并且在分析之前必须被“清除”。想了解更多信息，你可以看看这篇文章。
到目前为止，我们只是在谈论获得完整的基因组序列，这被称为“全基因组测序”也可以用其他种类的基因组测量进行基因组研究:
- 全外显子组测序(“WES”):在这项技术中，只有基因组的编码部分(编码蛋白质的部分)被测序。
- SNP 基因分型:在这项技术中，只测量已知重要位置的单个字母。“SNP”是“单核苷酸多态性”:单一，因为它只有一个位置(例如“4，576，877 位”)，核苷酸，因为 DNA 的构件是核苷酸，并且在该位置有一个核苷酸(A、T、C 或 G)，以及多态性，因为这些是被考虑的特殊位置，已知它们在群体中是变化的(即它们是“多态性的”)。在一个 SNP 上有某些核苷酸而不是其他核苷酸会导致戏剧性的后果。例如，镰状细胞贫血症这种疾病可以由单个核苷酸的改变引起。
RNA &转录
像 DNA 一样，RNA 是一种核酸——具体来说，是核糖核酸。
DNA 和 RNA 的比较:
- DNA 由 A、T、C 和 g 组成。RNA 由 A、U、C 和 g 组成。因此，RNA 含有 U(尿嘧啶)而不是 T(胸腺嘧啶)。
- DNA 是双链的。RNA 是单链的。
- DNA 是用来稳定、长期储存制造生物所需的所有信息的。RNA 被用作临时模板来帮助制造蛋白质。
这是可以从人类基因 S100A10 中提取的 RNA 序列:
AAUCAAAGAACCCGGCCGUCCUGCCGGUGGGGCACGUGGCGCAGAACCAGAGGUAACCGGUUUAGGGCAUCCCACCCUGAGCCUGCCCUUCCUCUCGGGUUUGGUUUUAGAAAGUGUACAGCCCCAGACAGAGCGUUCUUGUAAACUUCUCUUCAGUAGAAACGGUCCUGCUCUCGAAUACCGGGCGCGCGGCCCACGCCCUGCCCUCGCUCCCGGACCCGCCUCGCAGAGCGCUCGCCCGGCAGGGCGCUCCCCCAGCCCUGUCUCCUCCCCCUCUUCCUGCCCCCGACUCCCCCGACCACGUGCGGCGGGUGGGUAGAGGGAGGCGGUGCGGGACGGGGAGGAGCCUGGCGGGCGCUCGUGGGCGACGUGGACGCGGGGCGGAGAGGCGAGCGCGGCGGGCUGUGCGCCUUCCUUAGUGGGCCGAACUGGGAGCUCACCUUGGCCGAGGCGCGGCGGACGCUGGGCGAGCUGGGCGAC
[使用arep.med.harvard.edu计算]
RNA 被用作构建蛋白质的模板。首先，一段 RNA 是基于 DNA 中的一个基因构建的。从 DNA 上制造 RNA 的过程被称为“转录”，因为 RNA 是从 DNA 上“转录”下来的，利用了前面讨论的配对规则(除了这次不是 DNA 链-DNA 链配对来形成双螺旋，而是 D NA 链-RNA 链配对来制造 RNA 模板):
- RNA C 与 DNA G 配对
- RNA G 与 DNA C 配对
- RNA U 与 DNA A 配对
- RNA A 与 DNA T 配对
接下来，这段 RNA 被用来制造蛋白质，这个过程被称为“翻译”，因为 RNA 的核苷酸构件被“翻译”成蛋白质的氨基酸构件:
转录组学
“转录组学”是对 RNA 序列的研究。转录组学很有趣，因为它告诉我们在身体的不同部位什么基因被“开启”。
让我们回到 DNA 序列作为指导手册的类比:
回想一下，橙色和蓝色文本分别包含构建“机器 Z”和“机器 B”的指令(代表两个基因，它们提供构建蛋白质 Z 和蛋白质 B 的指令)。
现在，假设我们每次要向工厂的一个房间添加新的机器 Z 时，都必须为“机器 Z”影印页面—也许我们正在将机器 Z 指令的影印页面交给某个要去构建机器 Z 的工人。如果我们为“机器 Z”影印页面总共 25 次， 然后有人溜进工厂的房间，计算机器 Z 页的复印总数，就可以推断出在工厂的那个特定房间里，我们需要 25 台机器 Z。
这样，通过统计工厂某个房间(身体部位)的影印(RNA 转录物)数量，我们就可以推断出工厂那个部位使用最多的是哪些机器(蛋白质)。
身体是由组织构成的——比如肌肉是一种组织，神经细胞是另一种组织。这是来自 genevisible 的图表，显示了 S100A10 基因“表达”的前 10 个组织——换句话说，S100A10 基因在这些组织中最频繁地被转录成 RNA:
从图表中我们可以看到，S100A10 基因在身体的某些部位比其他部位使用得更多。“表达”只是从 DNA 中提取一段 RNA 的另一种说法。当一个基因被用来制作 RNA 模板时，我们说这个基因被“表达”了。短语“测量基因表达”指的是检测特定目的基因制造 RNA 的程度。换句话说，“测量基因表达”与“测量转录组”相同。
蛋白质&翻译
到目前为止，我们已经讨论了 DNA 是如何变成 RNA 的。现在我们将讨论 RNA 的用途:作为制造蛋白质的模板。
蛋白质是在体内执行不同工作的小机器。我不会轻易使用“机器”这个词——蛋白质确实是分子机器。下面是一个动画，展示了马达蛋白质驱动蛋白沿着微管(一种微观支撑结构，像建筑物中的木梁)拖动囊泡(一种微观存储容器，像背包):
蛋白质是由氨基酸组成的。在人类中，有 20 种氨基酸可以作为蛋白质的组成部分。
以下是用于制造人体蛋白质的 20 种氨基酸，以及它们的单字母和三字母缩写:
- G —甘氨酸
- 脯氨酸(Pro)
- 甲——丙氨酸
- V —缬氨酸(Val)
- L —亮氨酸
- I —异亮氨酸(Ile)
- M —蛋氨酸(Met)
- C —半胱氨酸
- F —苯丙氨酸
- Y —酪氨酸
- W —色氨酸
- H —组氨酸(His)
- K —赖氨酸
- R —精氨酸
- 问 —谷氨酰胺(Gln)
- N —天冬酰胺(Asn)
- E —谷氨酸
- D —天冬氨酸(Asp)
- S —丝氨酸
- T —苏氨酸
回到我们的 S100A10 的例子，这是最终由基因 S100A10 产生的蛋白质的完整蛋白质序列:
MPSQMEHAMETMMFTFHKFAGDKGYLTKEDLRVLMEKEFPGFLENQKDPLAVDKIMKDLD QCRDGKVGFQSFFSLIAGLTIACNDYFVVHMKQKGKK
【序列来源:uniprot.org
提醒:
- 当你读出一个蛋白质序列时，“G”代表氨基酸“甘氨酸”，但当你读出一个 DNA 序列时，“G”代表核苷酸“鸟嘌呤”。
- 类似地，“C”在蛋白质序列中代表“半胱氨酸”,但在 DNA 序列中代表“胞嘧啶”,
- “T”代表蛋白质序列中的“苏氨酸”,但代表 DNA 序列中的“胸腺嘧啶”,
- “A”在蛋白质序列中代表“丙氨酸”,但在 DNA 序列中代表“腺嘌呤”。
- 幸运的是，你可以很快分辨出一个序列是蛋白质还是 DNA，因为蛋白质序列将包含比 ATCG 更多的字母。
尽管氨基酸和核苷酸的名字听起来很相似，但它们之间有很大的不同，具有不同的分子结构。这是 20 种氨基酸的示意图(其中 O 是氧，H 是氢，N 是氮，不带字母的角是碳):
来源:维基百科
蛋白质是用一段 RNA 作为模板制成的。RNA 模板规定了应该用什么样的氨基酸来制造蛋白质。
你可能会问，如果 RNA 只由 4 种核苷酸组成，怎么可能为由 20 种不同氨基酸组成的蛋白质指定指令？如果核苷酸和氨基酸之间有一对一的映射，那么我们只能编码 4 种不同的氨基酸。如果核苷酸和氨基酸之间存在二对一的映射，那么我们只能使用这些 2 元核苷酸编码来编码 4 x 4 = 16 种不同的氨基酸:
因为两个仍然不够，身体用 3 个核苷酸来表示一个氨基酸。使用 3 个氨基酸提供了 4×4×4 = 64 种可能性，这足以编码 20 种可用的氨基酸(留下一些三联体来编码“开始”和“停止”)。3 个氨基酸的组合被称为“三联体”或“密码子在“翻译”(从 RNA 制造蛋白质)的过程中，身体以三个字母为单位读取 RNA，一次产生一个氨基酸。
“打破遗传密码”发生在 1966 年，指的是通过实验确定哪些氨基酸对应于哪些核苷酸三联体的艰苦努力的结果。
这是遗传密码，显示了从 RNA 三联体(如“UUU”)到氨基酸(如“苯丙氨酸”)的映射:
序列“AUG”(标记为红色)既作为“起始”指示(“起始密码子”)又作为氨基酸甲硫氨酸(Met)的编码。序列“UAA”、“UAG”和“UGA”都代表“停止”剩下的三个字母代码都表示特定的氨基酸。从图中可以看出，遗传密码是多余的，即有多种方式编码同一种氨基酸。
这是我们的图表，包括所有的部分:DNA、RNA 和蛋白质。
注意，标记为“基因”的 DNA 序列具有序列 CGCCAT，根据前面描述的配对规则，它对应于所示的 RNA 序列:GCGGUA。然后，使用遗传密码表，我们可以看到，RNA 中的 GCG 对应的是氨基酸丙氨酸(Ala)，而 RNA 中的 GUA 对应的是氨基酸缬氨酸(Val)。(为了简单起见，我在图中省略了“开始”和“停止”密码子)。
快速补充一下的实际大小:真正的基因比图片中显示的 6 个核苷酸要大得多。平均蛋白质编码基因由 53，600 个核苷酸组成(也写作“53.6 kb”，其中 kb =千碱基；53.6 x 1,000 个碱基)。最大的基因是 2.4 兆碱基(dystrophin)，正如你所想象的，它编码了一段真正巨大的 RNA，最终是一段真正巨大的蛋白质。
可视化蛋白质
有许多方法可以看到一个给定基因最终产生的蛋白质。蛋白质是以氨基酸序列的形式产生的，但它们最终会折叠成对其功能非常重要的三维结构。确定蛋白质的三维结构需要大量的工作，确定蛋白质的功能也需要大量的工作。x 射线晶体学是一种可以用来确定蛋白质三维结构的技术。还有一个大的计算研究领域专注于预测仅给定其序列的蛋白质的 3D 结构(这是一个非常困难的问题)。
这是几个由 S100A10 基因产生的蛋白质的图像，来自瑞士模型。如果你想以一种互动的 3D 方式移动这些渲染图，你可以在这里这样做。
首先，这是 S100A10 蛋白的“球和棒”渲染，其中每个原子是一个球，原子之间的连接是棒:
这是一个“空间填充”渲染:
下面是一个“表面”渲染:
最后，这是一幅卡通渲染图(螺旋是一种抽象的非文字形式的 3D 主题，称为“阿尔法螺旋”，在许多蛋白质中可见):
蛋白质组学
你可能已经猜到了，蛋白质组学指的是对蛋白质的大规模研究。你可能会奇怪，如果我们有基因组学(了解构建身体的所有指令)和转录组学(了解身体的哪些部分需要哪些机器)，为什么还会有人想研究蛋白质组学。
事实证明，转录组学并不能完美地代表身体的哪个部位需要什么样的机器，因为 RNA 并不能以 1:1 的比例合成蛋白质。换句话说，你不能仅仅统计基因 A 产生的 RNA 片段的数量就得出结论，因为基因 A 有 100 个 RNA 片段，这意味着产生了 100 个版本的蛋白质 A。有时候，RNA 根本没有被制成蛋白质。有时，某一段 RNA 被用来制造许多蛋白质，而其他时候，一段 RNA 只被用来制造少数蛋白质。因此，蛋白质组学提供了一种更直接的方法来评估特定身体部位的机器总数。
通过结合基因组学、转录组学和蛋白质组学的分析，我们可以更全面地了解生物的健康状况和功能。
细胞的内部生命
最后，我强烈推荐观看 YouTube 视频“细胞的内部生活”它描绘了我们在这篇文章中谈到的许多过程，是对我们所有人体内分子机制的惊人和生物学上准确的描述。
总结
- DNA 是生命的蓝图。人体内的 30 亿个 DNA 字母包含了构建身体的所有指令。
- 基因组学是对大规模 DNA 序列的研究。
- 转录是用 DNA 制造 RNA 模板的过程。
- 翻译是使用 RNA 模板制造蛋白质的过程。
- 转录组学是对 RNA 序列的大规模研究。
- 蛋白质是在体内执行不同功能的分子机器。
- 蛋白质组学是对大规模蛋白质的研究。
原载于 2020 年 4 月 11 日 http://glassboxmedicine.com*。*
利用 Spotify 的音频分析对电子舞曲进行流派分类
使用机器学习深入研究 EDM
Aditya Chinchure 在 Unsplash 上拍摄的照片
介绍
电子舞曲有一个史诗般的起源故事。它始于 DJ 用鼓机给迪斯科唱片配音，并在非法的仓库派对上播放。我们今天所知的 EDM 已经发展成为一个价值 7 . 5 亿美元的庞大产业。随着受欢迎程度的提高，越来越多的听众将会接触到他们从未听过的流派和子流派。
随着 Spotify 等流媒体服务使用机器学习算法推出个性化歌曲推荐，发现新音乐也变得前所未有的简单。作为一名听众，第一次听到一首歌并沉浸在一种新的风格中是最令人愉快的部分。发现自己在一个有趣的兔子洞，异想天开地添加越来越多的歌曲到您保存的歌曲。可能会导致 Spotify 图书馆混乱无序。
该项目探索了机器学习算法的应用，使用 Spotify 的音频分析对给定歌曲的流派进行识别和分类。允许用户按流派自动组织他们的图书馆。
这个项目的所有代码可以在这里找到:【https://github.com/towenwolf/genre-classification
数据集
包含 7 个独特的电子舞曲类别的 21，000 首歌曲的音频分析:tech house，techno，trance，psy-trance，trap，drum & bass 和 hardstyle。这些歌曲是从 136 个用户创建的播放列表中收集来的，来自可靠的来源，如经过验证的唱片公司和官方 Spotify 播放列表。
为了获得数据集，我在 python 上编写了一个脚本，从 Spotify 的开发者应用程序获取凭证，读取播放列表的 csv 文件，检索播放列表中每首歌曲的音频特征，并创建一个按流派标记的歌曲数据框。该脚本还删除了任何重复的，低于 50 bpm 的低节奏歌曲，以及超过 16 分钟的歌曲。最终的数据集随机抽取了每个类别的 3000 首歌曲进行分析。
数据帧的每一行代表一首歌曲，列是歌曲的音频特征测量:
声学 —一首歌曲是纯声学的还是合成的概率。歌曲的录音将具有接近 1 的值。
乐器性 —一首歌不含人声的概率。纯器乐歌曲的值会更接近 1。
语音度 —一首歌只包含语音的概率。朗读单词轨道和声乐简介的值将接近 1。
可跳性 —一首歌的可跳性从 0 到 1 不等。
活跃度 —检测录像中是否有观众，范围从 0 到 1。
价——一首歌的意境。听起来快乐的歌曲值接近 1，听起来悲伤的歌曲值接近 0。
能量 —强度和活动的感知度量。高能轨道感觉起来很快，很响，很嘈杂，接近 1。
Key —估计的轨道整体 Key。
响度 —音轨的整体响度，单位为分贝(dB)。
Mode —表示一个音轨的模态(大调或小调)，大调用 1 表示，小调为 0。
速度 —轨道的总体估计速度，单位为每分钟节拍数(BPM)。
拍号 —一个音轨的估计整体拍号。
持续时间 —音轨的持续时间，单位为毫秒(ms)。
获取 _ 数据笔记本
使用 Spotify 的 API 来构建数据集而不是分析原始音频的优点是节省时间和计算能力，尤其是在大型数据集的情况下。要了解如何使用 Spotify 的 API，请查看这篇文章。
探索性数据分析
为了找到有助于按流派对歌曲进行分类的特征，我们应该听听它们之间的差异……一些歌曲比其他的快/慢吗？因为我们没有时间去听数据集中的每一首歌。让我们通过查看每种风格的速度分布直方图来直观地检查差异。
图 1:歌曲速度
我们看到一些节奏较低的歌曲，特别是陷阱、鼓和贝斯以及硬派风格的歌曲。我怀疑音频分析返回的是半场节奏，而不是全程节奏。这不是问题，考虑到中场休息在音乐上是正确的。只是换个角度看每分钟打多少拍，只数第一和第三个四分音符而不是一、二、三、四。比如一首 140 bpm 的歌，半场就 70 bpm 了，这对于某些流派来说很常见。为了解决这个问题，我编写了一个函数，将任何作为半场时间返回的速度更改为全时时间，以保持数据的一致性。
当使用用户创建的播放列表时，我们遇到的另一个潜在问题是将不属于该流派的歌曲添加到播放列表中，导致错误标记的观察。例如，用户可能错误地将一首说唱歌曲放在了家庭播放列表中。查看技术宅节奏的描述统计，我们可以看到最小值和最大值远远高于和低于平均值。
techhouse
count 3509.000000
mean 124.917453
std 2.845667
min 95.075000
25% 123.995000
50% 124.995000
75% 125.998000
max 217.009000
这些远离平均节奏的数据点告诉我们，它们实际上并不属于科技流派。如果我们像这样给算法错误标记的观察值，它会导致分类器正确预测的问题。因此，为了解决这个问题，我根据阿贝尔顿的音乐制作章节中关于节奏的内容，用流派的已知节奏为数据设置了一个阈值。
类型的速度范围
- 配音:60-90 BPM
- 嘻哈音乐:60-100 次/分钟
- 房价:每分钟 115 至 130 美元
- 技术/催眠:120-140 次/分钟
- dubstep:135–145 BPM
- 鼓和贝斯:160–180 BPM
图 2:调整半场/用户错误后的歌曲速度
图 3:按流派的节奏统计
在对用户的错误进行调整并将半拍节奏改为全拍节奏后，流派节奏的分布显示出围绕其均值和等方差的单峰结构。从统计学上讲，数据具有这些特征是很重要的，因为许多算法使用假设正态性的线性模型。这意味着在预测一首歌曲的风格时，节奏会有很大的分量。
现在，除了速度，还有什么其他音频分析功能可以帮助预测正确的流派？
图 4–15:音频分析特征直方图
如果你看一下可跳舞性的直方图(图 7)，我们会发现技术宅和电子乐平均来说比所有其他流派更“适合跳舞”。这并不奇怪，豪斯和泰克诺以他们的高帽和掌声让舞者们点头而闻名。数据的结构是正常的，并且类型的平均值彼此不同，表明这将是另一个有助于分类的特征。
观察歌曲整体响度的差异(图 12)也给了我们一些对流派差异的洞察。陷阱，鼓&低音和 hardstyle 都是以非常高的分贝录制的，揭示了这些流派在扬声器上可以输出的强度和力量。听这些流派的时候不要把耳机开得太大。
歌曲的持续时间(图 15)也在它可能属于的流派中起作用。Psy-trance 和 techno 歌曲比其他类型的歌曲长得多，75%以上的数据在每首 6-15 分钟之间。
不适合分析的突出特征是调、调式和拍号，这些都是与歌曲的音乐性相关的分类特征。它们可能在以后的分析中有用，但对于本项目，它们将从要素选择中移除。
训练机器学习分类器
为了训练分类模型，我们需要将数据分成特征和标签。使用来自 sklearn 的标签编码器对类型标签进行编码。
X = data[features].copy()
y = LabelEncoder().fit_transform(data[‘genre’])
列车测试分离
然后使用 sklearn 的 train_test_split 将数据分成训练集和验证集，随机将数据分成 80/20%的块，用于训练和验证分类器。
X_train, X_test = train_test_split(X, test_size=0.2, random_state=98)
y_train, y_test = train_test_split(y, test_size=0.2, random_state=98)
数据预处理
使用 sklearn 的 MinMaxScaler，所有的特征将被转换为 0 到 1 之间的相同比例。
scaler = MinMaxScaler()
scaler.fit(X_train)X_train = pd.DataFrame(scaler.transform(X_train), columns = X.columns)
X_test = pd.DataFrame(scaler.transform(X_test), columns = X.columns)
分类器
既然数据准备好了，分类器就要被训练并预测每种类型的概率。分类器是一种算法或“机器”,它使用统计数据来输出一个数学模型，该模型与我们输入的数据相匹配。允许我们预测有用的东西，比如一首歌是什么类型的！在本文中，我们不打算深入研究每一种算法的数学原理，但会提供一个简短的解释，说明是什么使这些分类算法成为这个用例的候选算法。
逻辑回归
是一个线性数学模型，通常用于二元分类。在这种情况下，我们有 7 个类别，并将实施 One vs Rest 方法，该方法将训练 7 个单独的模型，概率最高的一个将是预测的类别。
# Train logistic regression model
logreg = LogisticRegression(penalty='l2', max_iter=10000, multi_class='ovr')
logreg.fit(X_train, y_train)# Probabilities of each genre
logreg_probs = logreg.predict_proba(X_test)
随机森林
是适合许多决策树分类器的集成分类器。使用 sklearn 的 GridSearchCV 找到了最佳参数。
# Train random forest model with optimal parameters
rf = RandomForestClassifier(max_depth=25, min_samples_leaf=1, min_samples_split=5, n_estimators=1200)
rf.fit(X_train, y_train)# Probabilities of each genre
rf_probs = rf.predict_proba(X_test)
XGBoost
Boosting 是另一种通过组合多个弱学习器(如决策树)获得的集成分类器。使用 sklearn 的 GridSearchCV 找到了最佳参数。
# Train model with optimal parameters
xgb = XGBClassifier(max_depth=5, learning_rate=0.1, objective='multi:softprob', n_estimators=500, sub_sample = 0.8, num_class = len(genres))
xgb.fit(X_train, y_train)# Probabilities of each genre
xgb_probs = xgb.predict_proba(X_test)
SVM
经典的分类算法，常用于二元分类。就像逻辑回归一样，将使用一对其余的方法。
# Train model with optimal parameters
svm = SVC(gamma='auto', probability=True)
svm.fit(X_train, y_train)# Probabilities of each genre
svm_probs = svm.predict_proba(X_test)
评估分类模型
逻辑回归
准确率:84%
F1 得分:0.84
ROC AUC: 0.974
墙壁时间:543 毫秒
对于一个简单的分类器来说还不错，预测最正确的类型是技术宅和 psy-trance。
随机森林
准确率:93%
F1 得分:0.93
ROC AUC: 0.994
挂壁时间:40.6 秒
随机森林的表现明显更好。建议决策树分类器是使用该数据进行分类的好方法。
XGBoost
准确率:93%
F1 得分:0.93
ROC AUC: 0.994
挂壁时间:52.2 秒
得分几乎与 random forest 完全相同，只是在预测上有微小的变化。预测的准确性有一个清晰的结构。
支持向量机
准确率:88%
F1 得分:0.88
ROC AUC: 0.986
挂壁时间:16.1 秒
除了电子音乐和硬派音乐之外，大多数音乐类型都有相对较高的准确度。错误地预测了两者的关系。
受试者工作特征曲线
评估分类器算法性能的另一种方法。说明了特异性和敏感性的权衡，曲线下面积越大，预测越准确。
图 20:分类器的 ROC 曲线
XGBoost 和 Random forest 算法在预测歌曲类型方面表现最佳。在对技术宅进行分类时，所有算法都表现良好，在所有分类器上都具有近乎完美的准确性。一些 techno 的例子经常与 hardstyle 混淆，反之亦然，也是 psy-trance 的陷阱。这表明这些流派之间的差异可能比音频特征能够检测到的更微妙。
讨论
Random Forest 和 XGBoost 的性能在大规模自动分类流派的能力方面都很有前途。能够根据音频分析的特征来确定一首歌曲的流派，可以帮助听众组织他们的图书馆或推荐类似的歌曲。
但最终，真正让每种音乐风格独一无二的是它在聆听时激发的感觉和情感。自己听一听，这里有分析中使用的 Spotify 播放列表的链接。
接下来，我想找到算法有效分类一个流派的最少歌曲数量。这样一来，流派数量的规模就可以包括大量的小众流派。如果某个流派有足够多的播放列表，那么分类器甚至能够预测最狂野的流派，比如俄罗斯波尔卡硬核音乐(见下文)。所以，走出去，做一些你最喜欢的类型的公共播放列表。
Gif 由 Ohmagif.com 的未知
参考
[## 使用机器学习技术的音乐流派分类
在音乐信息检索领域，根据音乐文件的类型对其进行分类是一项具有挑战性的任务
arxiv.org](https://arxiv.org/abs/1804.01149) [## 开始使用 Spotify 的 API & Spotipy
《数据科学家快速入门指南》,指导如何浏览 Spotify 的 Web API 并使用 Spotipy Python 访问数据…
medium.com](https://medium.com/@maxtingle/getting-started-with-spotifys-api-spotipy-197c3dc6353b) [## 节奏和风格
一首音乐的风格(或流派)是由许多因素决定的，包括声音的类型和…
learningmusic.ableton.com](https://learningmusic.ableton.com/make-beats/tempo-and-genre.html) [## 欢迎来到 Spotipy！- spotipy 2.0 文档
Spotipy 是 Spotify Web API 的轻量级 Python 库。有了 Spotipy，您可以完全访问所有音乐…
spotipy.readthedocs.io](https://spotipy.readthedocs.io/en/2.9.0/) [## 制作自己的 Spotify Discover 每周播放列表
每周一醒来我都很兴奋。在你认为我是那种喜欢每天去上课的怪人之前…
towardsdatascience.com](/making-your-own-discover-weekly-f1ac7546fedb) [## Spotipy:如何从一个播放列表中读取超过 100 首曲目
感谢贡献一个堆栈溢出的答案！请务必回答问题。提供详细信息并分享…
stackoverflow.com](https://stackoverflow.com/questions/39086287/spotipy-how-to-read-more-than-100-tracks-from-a-playlist)
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
