TowardsDataScience 博客中文翻译 2021（一百七十三）

原文：TowardsDataScience Blog

协议：CC BY-NC-SA 4.0

类别不平衡:带有不平衡学习的随机抽样和数据扩充

原文：https://towardsdatascience.com/class-imbalance-random-sampling-and-data-augmentation-with-imbalanced-learn-63f3a92ef04a?source=collection_archive---------3-----------------------

探讨了类别不平衡问题、准确性悖论以及利用不平衡学习库解决这一问题的一些技术。

图一。阶级失衡视觉描述|作者图片|图标取自维塔利-戈尔巴乔夫

开发用于分类的机器学习模型时出现的挑战之一是类别不平衡。大多数用于分类的机器学习算法是在假设类平衡的情况下开发的，然而，在现实生活中，拥有适当平衡的数据并不常见。由于这个原因，已经提出了各种替代方案来解决这个问题以及应用这些解决方案的工具。这就是不平衡学习 [ 1 ]的情况，这是一个 python 库，实现了最相关的算法来解决类不平衡的问题。

在这篇博客中，我们将看到什么是类不平衡，实现精度作为不平衡类的度量的问题，什么是随机欠采样和随机过采样，以及不平衡-学习作为一种替代工具，以适当的方式解决类不平衡问题。然后，博客将被划分如下:

• 什么是阶层失衡？
• 准确性悖论
• 欠采样和过采样
• 不平衡——在实践中学习

什么是阶层失衡？

当每个类别的样本不平衡时，类别不平衡的问题就出现了，也就是说，在类别的分布之间没有平衡的比率。这种不平衡可大可小。根据样本大小，从 1:2 到 1:10 的比率可以理解为轻微失衡，大于 1:10 的比率可以理解为强烈失衡。在这两种情况下，具有类别不平衡问题的数据必须用特殊技术处理，例如欠采样、过采样、成本敏感等等。稍后，我们将介绍欠采样和过采样以及它们与 imblearn [ 1 ]的实现。

准确性悖论

在处理分类问题中的不平衡数据时，要考虑的一个基本问题是要使用的度量标准。准确度通常被用作事实上的度量，但是对于类别不平衡问题，这不是一个好的选择，因为准确度可能会产生误导，这个问题更好地被称为 准确度悖论 。为了更好地理解 精度悖论 ，我们来看看图 2。

图二。准确性悖论|作者图片|图标取自 Freepik

当使用准确度作为衡量标准来评估用具有类别不平衡问题的数据集训练的机器学习模型时，结果可能会令人误解。正如我们所看到的,的准确度是 92%,这将使我们假设模型足够好。然而，如果我们仔细观察，我们可以看到模型学会了将所有东西分类为类 0，这产生了具有足够好的准确性的效果。在这些情况下，除了应用一些方法来修复类不平衡问题之外，建议引入其他评估指标，如精度、召回和 F1-Score。让我们看看图 3，以便更好地理解精度、回忆和F1-得分指标如何帮助我们更好地了解结果。

图 3。准确度、精确度、召回率和 F1 分数|作者图片

让我们看看刚刚发生了什么。准确性是一个衡量真阳性和真阴性之间平衡的指标，然而，当数据集呈现类不平衡问题时，模型将最有可能学习将所有东西都向主导类分类，在这种情况下向类 0 分类。因此，即使模型已经将 100%的数据分类为 0 类，考虑到真阴性的数量占主导地位，精确度也将足够好。这就是为什么当存在类别不平衡问题时，准确性度量经常会产生误导(准确性悖论)。

精度度量标准测量:“在所有被模型分类为阳性的元素中，有多少实际上是正确的”正如我们所观察到的，精度是完美的，这将使我们认为*“嗯，准确度和精度足够好了*”，然而这并不完全正确，因为在类别 1 的 10 个元素中，只有 2 个被正确分类，也就是说，8 个被错误分类，这可以在召回指标中观察到。

回忆度量标准:“被模型分类为正类的那些与被分类为负类但实际上是正的那些之间的平衡”。正如我们所看到的，召回值非常低，这给了我们一个信号，表明有些事情不对劲，也就是说，几个真正呈阳性的样本被归类为阴性。在一个真实的环境中，让我们想象阳性类别指的是"患有癌症"，而阴性类别指的是"没有患有癌症"，在这种环境中，我们会将许多真正患有癌症的人归类为没有患癌症的人，这将是一个灾难性的错误。

最后，为了概括精度和召回度量，我们实现了F1-分数度量，它被理解为精度和召回之间的调和平均值，换句话说，它提供了两个度量之间的比率。我们可以看到， F1-Score 值很低，这是另一个指标，表明有些事情不对劲(在我们的例子中，精度很完美但是召回很差)。

到目前为止，我们已经看到了什么是类不平衡问题，使用不平衡类的一些后果，以及在评估呈现类不平衡问题的模型时要考虑的一些指标。现在，让我们来看看可以用来调整类不平衡的一些替代方案，具体来说，让我们来看看应用基于欠采样和过采样的技术的效果。

欠采样和过采样

正如我们已经看到的，当等级分布之间没有平衡时，就会出现等级不平衡问题，也就是说，一个或多个等级相对于一个或多个剩余的等级可能是主导的。直观上，这个问题可以通过向少数类添加样本、从多数类移除样本或者两者的结合来解决。因此，从多数类中移除样本的过程称为欠采样，向少数类添加样本的过程称为过采样。

随机欠采样是指多数类的随机抽样。这一过程一直进行到少数群体达到平衡。虽然这种技术有助于在多数类和少数类之间建立平衡，但当从多数类中移除样本时，可能会丢失重要信息。

随机过抽样是指从少数类中随机复制样本。执行加法过程，直到相对于多数类达到平衡，然而，这种技术可能导致要训练的模型过度适合少数类。

随机欠采样和随机过采样可以理解为解决类不平衡问题的基本技术。今天，有更多有前途的技术试图改善基于随机的方法的缺点，如合成数据增强(SMOTE [ 2 ]，ADASYN [3])或基于聚类的欠采样技术(ENN [ 4 ])。

好了，我们已经知道了基于欠采样和过采样的技术是什么，让我们看看如何在实践中实现它们吧！

不平衡——在实践中学习

不平衡学习是由 Guillaume lematre 等人 6 开发的开源 Python 库 5 ，它提供了一套处理类不平衡问题的算法。这样一套算法被组织成 4 组:欠采样、过采样、过采样和欠采样的组合和集成学习方法。出于我们的目的，此时我们将只使用欠采样和过采样扩展。

以下示例将使用一个不平衡数据集。将训练一个机器学习模型(决策树)，并将评估度量准确度、精度、召回和f1-分数。随后，将应用下的和过采样算法，并且将再次评估前述度量，以在没有修复不平衡问题的情况下训练模型时获得的结果与应用欠采样和过采样时获得的结果之间进行比较。

所以我们先生成一个不平衡的玩具数据集:

代码片段 1。合成数据生成

生成的不平衡数据集将如图 4 所示:

图 4。不平衡数据集|作者图片

我们可以看到，生成的数据集呈现出类不平衡的问题，比例为 1:10。在应用欠采样和过采样算法之前，我们将定义一个能够用固定数据集训练决策树的函数。

代码片段 2。模型训练功能

正如我们已经观察到的，该函数实现了分层 K 折叠交叉验证技术，以保持每个折叠的类之间的平衡。

为了执行演示比较，我们将定义一组应用每种采样算法的函数(随机超过和下采样)、 SMOTE 以及 dummy 版本(该版本在不考虑类别不平衡问题的情况下训练决策树)。

代码片段 3。基于欠采样和过采样的技术

哑函数(第 6 行)，用代码片段 1 中生成的数据训练一个决策树，而不考虑类不平衡问题。随机欠采样应用于第 10 行，随机过采样应用于第 17 行， SMOTE 应用于第 25 行。在图 5 中，我们可以看到当应用每种算法时，类平衡是如何转变的。

图 4。作者对随机抽样和 SMOTE | Image 的比较

如我们所见，欠采样算法从多数类中移除样本，使其与少数类对齐。另一方面，过采样算法复制了 minority 类的元素(您可以看到，该图类似于图 4 中的图)。最后 SMOTE (一种数据扩充技术)，增加少数类的样本，直到它与多数类平衡。结果如图 6 所示。

图 6。结果

正如我们所看到的，当应用技术纠正职业平衡问题时，模型的有效性得到了提高。对于这个特殊的例子，基于合成数据扩充(SMOTE)的技术显示了更好的结果。归根结底，要实现的技术将完全取决于您正在处理的数据。值得一提的是不平衡学习提供了各种各样的算法来解决不平衡类的问题，值得看一看它的文档[ 1 ]。

结论

在这篇博客中，我们看到了类不平衡的问题，以及在处理不平衡数据集时必须考虑的指标。我们还看到了一个如何使用基于采样和数据扩充的算法来解决类不平衡问题的例子。我们还利用了不平衡学习库来扩展示例中使用的算法。

参考

[1]https://imbalanced-learn.org/stable/user_guide.html

[2] SMOTE:合成少数过采样技术

[3] ADASYN:用于不平衡学习的自适应合成采样方法

[4] 使用编辑数据的最近邻规则的随机属性

【https://github.com/scikit-learn-contrib/imbalanced-learn

[6] 不平衡学习:一个 Python 工具箱来解决机器学习中不平衡数据集的诅咒

分类损失的类别权重

原文：https://towardsdatascience.com/class-weights-for-categorical-loss-1a4c79818c2d?source=collection_archive---------16-----------------------

当数据集不平衡时，类权重通常用于分类问题。我们在引擎盖下看这个。

Suket Dedhia 的绘画作品

在寻找关于类权重的“确切”解释时，我不仅没有找到任何东西，对 tensorflow 和 PyTorch 中的实现进行逆向工程，我发现它们并不一致。因此，在这篇笔记中，我将以二进制分类问题为例来研究数学。之后，我还将很快讨论多类分类问题。

二元分类

不平衡数据集是指不同类别的数据点数量相差很大的数据集。有几种方法可以解决这个问题(欠采样、过采样、增加显式偏差和类别权重在张量流示例中讨论)，这里我们将讨论类别权重。

让我们来看一个标签为 0 和 1 的二元分类问题。类权重的传统选择是

虽然最近讨论了一个更复杂的方法。

一个数据点的分类交叉熵损失函数为

其中，y=1，0 表示阳性和阴性标签，p 是阳性类别的概率，w1 和 w0 是阳性类别和阴性类别的类别权重。

对于 minibatch，PyTorch 和 Tensorflow 的实现有一个归一化的区别。PyTorch 有

而 Tensorflow 有

当批量较小时，这两者之间的差异很重要(对于较大的批量，大数法则抑制 PyTorch 实现中的批量相关波动)。

让我们看看最后一层的梯度下降。其余的使用简单的链式法则/反向传播。我们将重点关注一个数据点的损失。批次的结果是这些的平均值，并且取决于如上所述的特定实现。类别 1 的概率是

而类 0 的是 1-p。W 是权重向量，x 是前一层的输出。我忽略了对简单性的偏好。

简单的微积分表明，损失相对于重量的梯度为

这给出了对重量的修正

先看看这个没有类权重的例子，看看会发生什么。**如果样本为正类，即 y=1，则梯度指向 x 方向，向量长度与(1-p)成正比。概率离 1 越远，这个向量就越长。相反，如果样本属于负类，即 y=0，则梯度指向 x 的对面，向量的长度与 p 成比例。p 离 0 越远，向量越长。**想想这个，说服自己这是正确的行为。

现在，当我们打开级重量时，我们看到它们调整前述长度。我们取 p=0.5。在这种没有类权重的情况下，y=1 和 y=0 的梯度向量将分别沿着 x 和逆着 x 具有相等的长度。然而，如果 w1 > > w0，那么 y=1 的梯度向量将比 y=0 的梯度向量长得多。这将使前一种情况下对 w 的修正比后一种情况下大得多。w1 < < w0 时反之适用。

多类问题

为了完整性(你将看到额外的简单性),让我们也做多类问题。在这种情况下，交叉熵损失为

其中 alphas 是类权重(很抱歉切换通知，但是随着额外权重的继续，使用‘w’表示类权重会变得混乱)

softmax 下第 I 类的概率由下式给出

这很容易验证(如果看起来不容易，那么你应该实际计算并说服自己)

利用我们得到的链式法则

具体地看将是有启发性的，因此，不失一般性地，让我们假设真正的标签是 y0=1，而所有其他的 y 是 0。然后我们得到类的权重更新为正

正确类别的权重更新将权重与 x 对齐，并且如果强度与预测的偏离程度和正确类别的类别权重成比例，则强度与 x 对齐

而对负的类的权重更新是

不正确类别的权重更新使权重与 x 不对齐，并且强度再次与预测的偏离程度成比例，但是注意，它们与正确类别的权重成比例，而不是与不正确类别的权重成比例。如果人们盯着损失函数看一段时间，后一个事实就很明显了。

注意，校正的效果是使正确类的权重与 x 更加对齐，而不正确类的权重与 x 更加不对齐。

函数式编程中的“类”？

原文：https://towardsdatascience.com/classes-in-functional-programming-ee48a50b6235?source=collection_archive---------10-----------------------

小窍门

用 currying 模仿 Python 中的类的行为

作者:爱德华·克鲁格、斯蒂芬·莱西和道格拉斯·富兰克林。

照片由迈克尔·里维拉·🇵🇭在 Unsplash 上拍摄

Python 非常适合面向对象编程(OOP)。面向对象编程关注的是由属性和方法组成的对象。属性是数据，方法是作用于属性和其他数据的函数。类在 Python 中很常见。

一个类可以被认为是一个对象的蓝图。Python 程序员通过使用关键字“class”并添加定义它的属性和方法来创建类。一旦我们有了蓝图，我们就可以轻松地重用它们来创建一个实例。

因为 Python 是一种多范例语言，所以它不仅可以用于面向对象编程，还可以用于函数式编程！您可以编写一个使用其中一种范式甚至两种范式的 Python 程序。

面向对象编程将逻辑和数据结合成对象，而函数式编程将逻辑和数据分开。我们将说明这两种范例都可以用来获得相似的结果。

先说功能性的。程序员往往更熟悉 OOP。

什么是 currying，它如何表现得像一个类？

Currying 是将接受多个参数的函数简化为单参数函数的过程。

我们可以把班级想象成一个蓝图。让我们把 currying 想象成一个生产函数的工厂——在下面的例子中，是柑橘榨汁机。

咖喱和水果榨汁机

让我们用一个柑橘榨汁机厂的例子，他们生产的柑橘榨汁机和新鲜果汁来解释 currying。

照片由 Edgar Castrejon 在 Unsplash 上拍摄

柑橘榨汁机厂回一个柑橘榨汁机，是取水果，回果汁的功能。那么，我们怎样才能从一家生产榨汁机的工厂变成一杯新鲜的果汁呢？

我们追求功能。看看下面的代码。

注意我们如何与第 31 行及以下的函数交互。首先，我们使用citrus_press_factory创建一个名为lemon_press的新函数。然后我们通过“lemon”和“lime” 到我们的lemon_press去取一些新鲜的果汁，味道很好但是有点酸。

我们去喝点更甜的吧，橙汁。在第 34 行，我们试图传递一个“orange”到我们的 lemon press 中，产生一个错误。看起来柠檬榨汁机只能用柠檬和酸橙！如果我们真的想做橙汁，我们就必须用我们的citrus_press_factory来做一个橙子榨汁机！

试着用柠檬榨汁机榨橙汁

根据工厂规范，我们似乎可以做一个柚子压榨机来榨出一些柚子汁。但是当我们试图在第 36 行为此目的制作一个 pomelo press 时会发生什么呢？

试图在我们的柑橘工厂制造一台柚子压榨机

看起来我们又遇到了一个错误。要创建一个citrus_press的实例，你必须使用citrus_press_factory.中的一个有效值。类似地，要制作一些果汁，你向citrus_press传递一个水果，它可以用它作为输入。

既然我们已经理解了 currying，那么让我们用一个 Python 类并把它重写为 currying 模式。

Python 类—口袋妖怪

在下面的例子中，我们创建了一个名为 Pokemon 的类。当我们在第 5 行使用带有参数self和sound 的__init__方法时，Pokemon 类被实例化。

要了解更多关于 Python 中的类的背景知识，请阅读由 Sadrach Pierre 博士撰写的文章

接下来，我们在 Pokemon 类中创建一个名为cry的方法，该方法返回sound。在这种情况下，sound 是数据，cry 是逻辑。注意类Pokemon如何将数据存储为self.sound。

既然 Pokemon 类已经创建好了，我们可以用它来创建一个对象。在第 23 行，我们创建了一个名为pikachu 的类实例，并传递了sound“Pika”第 24 行显示pikachu.cry()返回“Pika”

我们如何用数据和逻辑分离来创建这种行为？

“T21”怎么能产生类似的结果呢

如前所述，我们使用 currying 将多参数函数分解成连续的单参数函数。为此，我们首先在第 11 行创建一个名为make_pokemon的函数，它接受参数sound并返回cry。函数cry返回传递给make_pokemon的sound。

让我们调用这些函数来说明它们的行为。回想一下我们的果汁压榨机的例子！

通过将make_pokemon(“Pika”)的结果存储为pickachu_cry,我们创建了一个新函数，在被调用时返回“Pika”。

我们看到两者:

和

回报同样的叫声，“鼠兔。”

这表明创建一个类和使用固化可以产生相同的结果。在这两个例子中，我们都创建了可重用的代码。此外，这两个选项都允许程序员在程序中的单个位置对代码进行更改。

经典 Seq2Seq 模型与 Seq2Seq 模型对比注意

原文：https://towardsdatascience.com/classic-seq2seq-model-vs-seq2seq-model-with-attention-31527c77b28a?source=collection_archive---------20-----------------------

现在就来关注一下吧！

阿图尔·图马斯扬在 Unsplash 上的照片

“我需要关注。我喜欢这种关注。”—比尔弗利

介绍

在本文中，我们将分析一个经典序列对序列(Seq2Seq)模型的结构，并展示使用注意力解码器的优势。
这两个概念将为理解 论文中提出的变压器注意力是你所需要的全部。

Yoshua Bengio 分享了在人工智能中使用注意力机制来训练意识的价值。

目录:

• 什么是 Seq2Seq 模型？
• 经典的 Seq2Seq 模型是如何工作的？
• 注意

什么是 Seq2Seq 模型？

在 Seq2seq 模型中，神经机器翻译接收单词序列形式的输入，并生成单词序列作为输出。
从例子来看，“Cosa vorresti ordinare？”在意大利语中作为输入，变成“您想点什么？”作为英语输出。
或者，输入可以是一幅图像(图像字幕)或一长串单词(文本摘要)。

来源:图片由作者提供。

经典的 Seq2Seq 模型是如何工作的？

Seq2Seq 模型通常包括:

• 一个编码器
• 一个解码器
• 一个上下文 ( 向量)

请注意: 在神经机器翻译中，编码器和解码器都是 RNNs

编码器通过将所有输入转换成一个向量来处理它们，这个向量被称为上下文(通常长度为 256、512 或 1024)。上下文包含编码器能够从输入中检测到的所有信息(记住，在这种情况下，输入是要翻译的句子)。
最后，向量被发送到解码器，解码器形成输出序列。

神经机器翻译中的时间步骤

现在我们已经对序列到序列模型有了一个高层次的概述，让我们简要地分析一下输入是如何被处理的。

来源:图片由作者提供。

时间步骤#1: 意大利语单词“Stai”被发送到编码器
编码器根据其输入和先前输入更新其隐藏状态(h1)。
时间步骤#2: 字“attento”被发送到编码器
编码器基于其输入和先前输入更新其隐藏状态(h2)。
时间步骤#3: 单词“Thomas”被发送到编码器
编码器基于其输入和先前输入更新其隐藏状态(h3)。
时间步骤#4: 最后一个隐藏状态成为发送给解码器的上下文
解码器产生第一输出“Be”
时间步骤#5: 解码器产生第二输出“小心”
时间步骤#6: 解码器产生第三输出“托马斯”

编码器或解码器的每一步都是 RNN 处理其输入并生成该时间步的输出。
你可能注意到了，我们最后的隐藏状态( h3 ) 变成了发送给解码器的内容。在这个中存在经典序列对序列模型的限制；编码器“被迫”只发送一个向量，而不管我们的输入有多长，也就是说，我们的句子由多少个单词组成。
即使我们决定在编码器中使用大量的隐藏单元，目的是拥有更大的上下文，那么模型会过度拟合短序列，并且随着我们增加参数的数量，我们会受到性能的影响。

这就是注意力解决的问题！

注意力

至此，我们明白了要解决的问题在于上下文向量。这是因为，如果输入的是一个包含大量单词的句子，那么模型就会有问题。
bah danua 等人和 Loung 等人提出了解决方案。这两个出版物介绍并完善了“注意”的概念。这项技术通过关注输入序列的相关部分，使得机器翻译系统有了相当大的改进。

直觉 seq 2 seq 模型中的编码器与经典的编码器工作方式相似。这一次接收一个单词，并产生下一步使用的隐藏状态。
随后，与之前不同，不仅最后的隐藏状态(h3)将被传递到解码器，而且所有的隐藏状态都将被传递到解码器。

来源:图片由作者提供。

让我们更好地关注发生在编码器和注意力解码器内部的过程。

编码器

在到达编码器之前，我们的句子的每个单词都通过一个 嵌入过程 转换成一个向量(大小为 200，或 300)。
中的第一个字，在我们的例子中是“Stai”，一旦它转换成矢量就被发送到编码器。这里 RNN 的第一步产生了第一个隐藏状态。对于第二个的和第三个的字，同样的情况发生，总是考虑先前的隐藏状态。
一旦我们的句子的所有单词都被处理完毕，隐藏状态( h1，h2，h2 ) 将被传递给注意力解码器。

编码器。来源:图片由作者提供。

注意力解码器

首先，一个重要的过程发生在注意力解码器中:

• 每个隐藏状态被分配一个分数。
• 分数经过一个 softmax 函数。
• 隐藏状态和相关的 softmax 分数相互相乘
• 最后，将获得的隐藏状态相加以获得单个向量，即上下文向量。

这个过程允许我们放大序列中的重要部分，减少不相关的部分。
至此，我们要明白分数是如何分配给每个隐藏状态的。你还记得 Bahdanau 和 Luong 吗？嗯，为了更好地理解注意力解码器内部发生了什么以及分数是如何分配的，我们需要说一些关于倍增注意力的更多事情。

乘法注意力是通过开发先前为加法注意力所做的工作而发展起来的。
在论文《基于注意力的神经机器翻译的有效方法》中，Loung 引入了几个评分函数:

• 点积
• 一般产品
• 串联产品

从上到下:1) 点积，2) 一般积，3) 串联积。来源:图片由作者提供。

在本文中，我们将分析 g 一般产品注意事项(2) 。
这是因为，在我们的情况下，一旦确立了每种语言都倾向于有自己的嵌入空间，那么编码器和解码器就没有相同的嵌入空间。

多亏了这个产品，分数将由解码器的隐藏状态、权重矩阵和编码器的隐藏状态集合相乘得到。

现在我们知道了分数是如何计算的，让我们试着理解一下注意力解码器在 Seq2Seq 模型中是如何工作的。

在第一时间步，注意力解码器 RNN 接受 <结束> 令牌的嵌入，以及初始解码器隐藏状态。RNN 处理其输入，产生一个输出和一个新的 解码器隐藏状态向量(h4) 。输出被丢弃。
从这里开始注意步骤:

1-每个 编码器隐藏状态 被分配一个 分数 从 获得一般生产注意 。

一般产品注意事项。来源:图片由作者提供。

2-分数经过一个 softmax 函数。

Softmax。来源:图片由作者提供。

3- 编码器隐藏状态 与相关的of max 分数 相乘。将得到的隐藏状态相加，得到**【C4】**。

语境。来源:图片由作者提供。

4-上下文向量(c4) 与 解码器隐藏状态(h4) 串接。
源自拼接的向量通过 完全连接的神经网络 ，其基本上乘以权重矩阵(Wc)* 并应用双曲正切激活。
这个全连接层的输出将是我们在输出序列中的第一个输出单词(输入:“Stai”->输出:“Be”)。*

来源:图片由作者提供。

第二时间步从第一步的 输出【Be】开始，并随着 解码器产生隐藏状态(h5) 。接下来是上述的注意步骤*。
重复以下时间步骤所述的过程。*

注意解码器。图片由作者提供。

结论

如果你设法来到这里，恭喜你！非常感谢你花时间阅读这篇文章。
希望这篇文章已经让你对经典 Seq2Seq 模型*，以及 Seq2Seq 带注意模型有了很好的初步了解。
如果你注意到任何思维方式、公式或形象上的错误，请告诉我。最后但同样重要的是，如果你想深化所涉及的主题，我在下面给你留下了一些非常有用的资源:*

• C5W3L07 吴恩达注意力模型直觉
• chaud Hari 等人对注意力模型的仔细调查
• 杰伊·阿拉姆马的可视化神经机器翻译模型
• 深度学习 7。DeepMind 深度学习中的注意力和记忆

再次感谢您阅读我的文章。如有任何问题或信息，可在 LinkedIn 联系我，或在下方留言评论。

参考资料:

• Bahdanua 等人，“通过联合学习对齐和翻译的神经机器翻译”
• Loung 等人，“基于注意力的神经机器翻译的有效方法”
• 可视化神经机器翻译模型(Seq2seq 模型的机制，注意)Jay Alammar

分类决策树，容易解释

原文：https://towardsdatascience.com/classification-decision-trees-easily-explained-f1064dde175e?source=collection_archive---------22-----------------------

决策树是更高级的机器学习模型的构建模块之一。说到分类问题，它们到底是如何构建的？

照片由@ szmigieldesign@ unsplash.com 拍摄

不不管你在数据科学方面多么有经验，你可能听说过决策树。这种简单易懂的算法受到很多人的喜爱，是许多算法的基础，这些算法赢得了大量机器学习竞赛，并引导项目走向成功。

Random Forest、XGBoost 或 LightGBM 是一些基于 if-else 规则构建算法的简单而有效的算法。

决策树到底是怎么构建的？它如何选择组成规则的变量和阈值？如果你一直想了解这个算法是如何工作的，你来对地方了。

让我们从一个简单的角色扮演挑战开始。

我们有装有两枚鸵鸟蛋的盒子——我们需要将这些盒子海运到其他国家。我们已经做了一个实验，发送了 38 个盒子来测试两个鸡蛋是否安全到达目的地— 然后我们用散点图绘制两个鸡蛋的重量，试图了解这些变量与包装结果之间是否有任何关系:

鸡蛋的重量和包装的有效性

蓝点由安全抵达目的地的箱子组成。不幸的是，我们的一个或两个鸡蛋打破了，我们的包装被认为是无效的。

(还是救几只鸵鸟吧！)

来源:https://giphy . com/gifs/natgeowild-NAT-geo-wild-鸵鸟-国家地理-i3R0nglQHQipENYJkG

在与快递员核实后，您了解到，当您发送两个非常重的鸡蛋时，它们会相互挤压并可能破裂。当你送两个太轻的鸡蛋时，它们有太多的空间在盒子里移动，并折叠到它的边界。为了避免浪费大量的箱子，您希望构建一个算法来告诉您哪些箱子对于海外旅行应该是有效的。

对于一个人来说，执行某种 if-else 规则并在上面的例子中画出一些边界似乎很容易。类似这样的快速草图:

If-Else 规则用于区分有效和无效的包

这些象限产生以下 if-else 规则:

• 如果蛋 1 >的重量为 2.66 而蛋 2 >的重量为 1.95 ，则包装很有可能会破损。
• 如果蛋 1 的重量< 2.66 和蛋 2 的重量> 1.95 ，则包裹很有可能完好无损地到达。
• 如果蛋 1 <的重量为 2.66 而蛋 2 <的重量为 1.95 ，则包装很有可能会破损。
• 如果蛋 1 > 2.66 的重量和蛋 2 < 1.95 的重量，则包装很有可能完好无损地到达。

有了这些规则，我们可以很容易地建立一个系统，让我们决定是否应该把包裹送到海外。

基于这一系统，让我们将我们的分类形象化:

因此…如果人类可以在自己身上做到这一点，为什么要使用算法呢？主要问题是大多数数据集并不像我们上面看到的那样排列整齐(99.9%确定大多数真实生活中的数据集看起来不是这样的，我可以向你保证)——那么用 3 个以上的变量来绘制这些边界呢？疯狂的不可能！

这就是为什么我们需要机器来为我们做这些工作。

进入决策树！

决策树实际上非常简单，可以用一句“简单”的话来概括:“决策树是一种算法，它递归地在空间中搜索可能的最佳边界，直到我们无法这样做为止”。让我们去掉行话，从数学上把这句话分解一下。

想象一下，我们的第一次分割不是一个最佳分割——蛋 1 的重量超过或小于 1.5:

我们的树的次优分割—蛋 1 的重量≥ 1.5

这个决策界限并没有真正划分“盒子”或象限中的类。使用这个规则会给我们一个次优的分类，因为我们不能很好地将有效的和损坏的包分开。让我们画一棵真正的树，展开我们的论点，只是为了好玩:

鸡蛋 1 重量≥ 1.5 公斤的拆分生成的树(图标归属:Stockio.com)

在右边的分支中(我们一会儿会谈到树的解剖)，我们有 19 个有效的包和 9 个破损的包。当蛋 1 的重量较高时，包装完好无损地到达的概率较高(19/28 或大约 68%)。另一方面，包裹到达时破损的概率是 9/28 。

如果你看左边的节点，包有效或破损的概率是完全一样的，5/10 或 50%。我们很难对低于 1.5 阈值的点进行分类，因为每个类别中的示例数量没有差异。

看起来这基本上是一个抛硬币的过程——用“树的语言”来说，这意味着这是一个真正不纯的节点。

理解这是否是一个好的分裂的关键是量化由这个分裂产生的两个节点的杂质。从正确的节点开始:

我们的分裂决策树的右节点——蛋 1 的权重≥ 1.5(图标归属:Stockio.com)

杂质始于概率，我们现在已经如下:

• 有效包的概率— 19/28 = 67.85%
• 包装破损的概率— 9/28 = 32.15%

我们现在引入一个非常重要的概念，称为基尼不纯度，这是一个让我们为每个分割赋值的概念，如果你研究过其他算法，这将类似于成本函数，我们希望选择具有最小 G ini 不纯度的分割。

为了对节点做出最终决定，我们需要计算分割中每个节点的部分杂质——对于该节点，部分基尼杂质为以下公式(其中我们插入有效包和破损包的概率):

这将产生 0.43622 的值。较低的部分杂质意味着更好地分离类别的节点。

好了，我们有了右节点的值——让我们计算左节点的部分杂质，从概率开始:

我们的决策树的左节点具有分裂-蛋 1 的权重< 1.5 (icon attribution: Stockio.com)

• Probability of valid package — 5/10 = 50%
• Probability of broken package — 5/10 = 50%

Now we can calculate the 左节点的部分杂质:

右节点的部分杂质是 0.5。注意它是如何变高的，因为当我们想要分开这些类的时候，我们有一个更困难的时间。

**我们如何将两部分杂质结合起来？**这是容易的部分！我们将根据每个节点的样本数量对杂质的平均值进行加权，逐步计算:

• 右节点 28 例；
• 左侧节点上的 10 个示例；
• 右节点部分杂质= 0.43622；
• 左节点的部分杂质= 0.5；

分裂整体的杂质是(鼓点！):

来源:https://giphy.com/gifs/GBvkxysAR8Svm

乌夫，终于！这种分裂的基尼系数是 0.4565——我们现在有一个单一的值可以附加到这个阈值上，并可以与其他潜在的候选值进行比较。

通过设计，我们将希望选择将实现最小杂质的分离，因为该分离将转化为更好的分类。

让我们测试另一个分裂！例如，鸡蛋 1 的重量> 2.3:

为我们的蛋重 1 ≥ 2.3 的树拆分。

这种分割会生成以下树:

蛋重 1 ≥ 2.3 生成的树。(图标归属:Stockio.com)

看来这根本就不是一个好的分裂！这两个类在两个叶节点中似乎是平衡的。“叶子是什么？” —你问。

在计算这种分割的基尼系数之前，有必要检查一下决策树的结构:

决策树的剖析(图标归属:Stockio.com)

• 根节点是我们的树的底部，在分裂之前，我们在那里有我们所有的鸡蛋盒子。
• 分支由应用 if-else 规则后盒子将采用的每条路径组成。
• 叶节点由盒子将结束的节点组成，取决于上面的分支。
• 如果树有不止一级的深度(我们马上就能到达那里！)然后叶节点变成内部节点。

让我们来分析一下这种分裂的数字，看看我们的基尼系数:

• 右节点的部分杂质是 0.4753
• 左节点的部分杂质是 0.455

鉴于此，我们对这种分裂的基尼不纯是(击鼓！):

来源:https://giphy.com/gifs/GBvkxysAR8Svm

这次分裂的基尼系数比我们测试的第一次分裂更差。这是有意义的，因为大多数类在两个节点中似乎是平衡的。

那么……我们如何找到最佳分割？

递归搜索整个空间的可能分裂可能是一个好主意！这实际上是决策算法在内部做的事情。

如果我们计算“鸡蛋 1 的重量”变量中所有可能分裂的基尼系数杂质，我们将得到一个如下图:

鸡蛋重量的所有可能阈值的基尼系数杂质的“成本函数”图 1

上面的图表明，当我们选择“鸡蛋重量≥ 1”作为阈值时，杂质在某处最小化——让我们检查一下这是否是真的，可视化我们的树与该分裂:

蛋的重量 1 ≥ 1 生成的树。(图标归属:Stockio.com)

• 右节点的部分杂质是 0 . 444；
• 左节点的部分杂质是 0.48；

这种分割的基尼系数可以用以下公式计算:

这与我们在递归搜索中实现的最小分割相匹配，应该是我们的第一次分割(应该吗？)!

…

记住我们有两个变量！如果蛋 1 的重量不是用来划分我们的类的最佳变量呢？

让我们检查鸡蛋 2 变量重量的每个分割的杂质图:

在鸡蛋重量的所有可能阈值上的基尼系数杂质的“成本函数”图 2

对于鸡蛋 2 的重量，我们可能有一个候选值——0.95 和 1 之间的区间可能是一个很好的第一次分割。

为了说明这一点，我们现在测试的是:

为我们的蛋重 2 ≥ 0.95 的树拆分。

卵重 2 ≥ 0.95 生成的树。(图标归属:Stockio.com)

• 右节点的部分杂质是 0 . 444；
• 左节点的部分杂质是 0.48；

这与我们看到的“鸡蛋 1 的重量”最佳分割模式完全相同！所以，我们最后的计算还是:

我们有了决策树的起点！根据您将用来使树适应数据的系统，可能会选择以下两种之一:

• 鸡蛋的重量 1 < 1 and Weight of Egg 1 ≥ 1
• Weight of Egg 2 < 0.95 and Weight of Egg 1 ≥ 0.95

为什么？因为这些是最小化基尼系数 的阈值——我们的例子中有一个平局，这在现实世界的数据集中并不常见。

但是…我们现在去哪里？

我们种植我们的树！

让我们关注一下左叶节点:

卵重 2 ≥ 0.95 生成的树。(图标归属:Stockio.com)

**左边的节点对应于所有低于阈值的例子。**如果我们只对这些例子进行递归搜索，我们将会发现一个完全纯粹的分割——注意新的垂直阈值，橙色:

蛋重 1 ≥ 2.9 的新阈值。

这对应于以下树:

用两级阈值生成的树(图标属性:Stockio.com)

作为分支“鸡蛋重量 2 < 0.95”的结果的叶节点现在是内部节点。为什么？因为它会让更多的树枝向前延伸！

新的叶节点是由分支使用“鸡蛋 1 的重量”生成的，您可以在内部节点的正下方看到它。

如果您进行计算，这些新节点将具有:

• 左节点有部分杂质=0。
• 右节点有部分杂质=0。

这个拆分的基尼杂质是什么？没错，0！

这意味着这是一个纯节点，因为它完美地划分了我们的类。过了这一点就不能分班了。

另一个分支呢？通过再次迭代我们的分类树，我们将达到一个新的阈值:

用两级阈值生成的树(图标属性:Stockio.com)

又一个纯节点！这种分裂的基尼系数的详细情况是:

• 偏杂左节点: 0
• 部分杂质右节点 : 0.4770408
• 基尼杂质 为拆分:0.4047619

现在，我们可以继续沿着我们的树往下，以产生更多的阈值，直到我们在所有的叶节点上达到节点纯度*。*

生成的最终阈值为:

请注意所有点是如何被分组到它们的小“盒子”中的。下面是我们今后如何对我们的观点进行分类:

如果我们收到一组新的盒子，我们会将它们放入这些方块中的一个，根据方块的颜色，我们将知道是否应该发送我们的鸡蛋— 我们已经建立了分类树算法！

一个挑战:你能自己画出由这些阈值生成的树吗？

最后的想法

• 达到节点纯度并不是阻止树生长的唯一(可能也不是最好的)标准。达到节点纯度很可能意味着您的模型只适合训练数据，而不能很好地适用于真实世界(这是每个预测模型的真正目标)。
• **与上面的论点相关，决策树确实容易过拟合。**您可以根据 if-else 规则隔离样本中的几乎所有示例，但这几乎肯定会导致算法过度拟合。
• 有时，输入的微小变化(从原始数据中选择特定的样本)可能会导致树的结果产生巨大的差异。
• **关于决策树，下一步要学习的是理解超参数调整和交叉验证的概念。**它们是保证你的决策树在未来使用新样本时足够健壮的关键——我们将在下一篇博文中探讨这些概念。
• 自从引入随机森林以来，决策树很少在生产中使用，因为随机森林更健壮，一般来说——我们还将在后续的博客文章中介绍随机森林。
• 基尼系数并不是决定最佳分割的唯一公式(例如，熵也可以用作一个标准)。
• **对于回归树，基本原理是相同的，**但是不使用基尼系数，而是使用回归的误差度量(通常为均方根误差)。

感谢你花时间阅读这篇文章！我希望你喜欢它，它帮助你最终理解了决策树背后的数学和逻辑。

想了解更多？在 Udemy 上查看我的 R 的数据科学课程，在这里我们将接触更多的算法，并深入研究数据科学概念。

本课程是你成为数据科学家的第一步，我们将慢慢地理解所有概念，并注意理解算法背后的基础和理论。本课程是你进入数据科学世界的无风险(30 天退款政策)机会，我非常希望你成为我的学生！

安全操作中的分类

原文：https://towardsdatascience.com/classification-in-security-operations-dc6f43adcae8?source=collection_archive---------36-----------------------

奇莫诺在 Pixabay 上的照片

网络安全行业的每个人都在争先恐后地获取必要的人工智能和机器学习，以领先于攻击者。虽然许多网络安全公司肯定只在一次次的流行推销中使用人工智能/人工智能，但大多数网络安全专业人士确实认为人工智能/人工智能在安全领域有其一席之地。

ML 或任何数据分析的基本问题是分类。安全运营中心不断解决一系列分类问题。给定一些输入数据集，安全分析师首先必须确定活动是恶意的还是非恶意的。因此，第一个问题是二元分类。在下图中，我将这个问题进一步分解。红点标记分类发生的位置，黄框标记分类的结果。

事件检测(作者图)

分类决策 1:这些数据对检测有用吗？

安全分析师喜欢他们的日志和 IDS 警报，但所有数据都需要持续仔细检查，以确定与事件检测的相关性。安全工程师不仅要考虑删除无用的事件检测源，还要考虑添加新的创新数据源。一般来说，人类不会操作循环的这一部分——SOC 尽可能从网络和日志中获取数据，并希望这些数据足以满足他们的工作需求。因此，AI/ML 自然适合这里。主机计算能力是主要的阻碍因素；因为如果主机必须智能地确定哪些数据可以帮助实时检测，它将使用计算开销来运行这样的算法。无论系统选择发送什么数据，都将传递给下一个分类决策。

分类决定 2:这是一个事件吗？

在决定将哪些数据传递给我们的入侵检测系统后，入侵检测系统必须决定这些数据是否属于恶意活动。这是一个二元分类问题，那么为什么上图是三种情况呢？机器学习工程师将开发一种算法，以根据输入的训练数据来确定系统数据是否表征了事故。该算法将返回事件发生的概率。因此，案例代表了这个返回概率的阈值。分析师必须确定适当的阈值以避免警报疲劳，并每天处理适当数量的警报。情况 1 的阈值将非常高。请注意，由于事件发生的频率较低，因此这可能不是一个接近 1 的阈值—情况 1 的阈值实际上可能非常接近于 0，仅比下一个阈值大。情况 2 的阈值仍然很高，但会生成几个警报。这将使分析师能够通读生成警报的数据，并决定如何对事件进行分类。SIEM 反馈决策点的循环代表了这个迭代过程。

事件调查和响应

NIST 网络安全框架将网络安全事件定义为“被确定会对组织产生影响，从而需要响应和恢复的网络安全事件”我从来不喜欢这个定义，这里我们需要一些更具体的东西。我更喜欢一个简单的定义:网络安全事件是分析师决定进一步调查的事件。这自然导致了 NIST 网络安全框架在响应分析中的第一项:“来自检测系统的通知被调查。”事件调查和响应也是分类问题。下图显示了三个二元分类问题，分析师必须解决这些问题才能在事件生成后关闭事件。

事件调查和响应(作者提供的数字)

分类决定 3:上下文数据的充分性

分类再次回到所提供数据的质量。决策点 2 根据决策点 1 的数据对事件进行分类，但这些数据侧重于检测而非调查。换句话说，我们只需要回答这个问题:这种反常的行为是我们应该调查的吗？现在我们需要回答:到底发生了什么，我们如何解决？为了回答这些问题，分析师可能需要查询额外的数据源。AI/ML 在这里可以提供重要的价值，因为它可以根据上下文数据快速确定哪些数据可能对分析师的调查有用，并自动将这些数据添加到事件案例对象(数据水合)中，供分析师进一步审查。

分类决定 4:真实事件

在收集额外的上下文数据的过程中，分析师将经常确定该事件是误报。在这种情况下，她会简单地关闭事件，而不会发现。这个错误总是会发生，因为上下文数据是集中的和大量的。将该判定点移回判定点 2，从而要求所有可能必要的上下文数据命中 IDS，这将使网络过载，并使事件检测成为计算上不可能的任务。两步事件确定使用分类，以减少计算和网络需求。因此，该步骤中的 AI/ML 算法需要适应分析师添加到上下文数据中的输入。算法可以在后台连续运行，或者在事故案例文件改变时运行，以改变在分类决策 2 中生成的事故可能性值。

分类决定 5:减缓成效

有一天，我们的人工智能霸主可能会基于上下文数据自动生成缓解措施。然而，现在分析师必须在调查完成后运用他们的最佳判断来制定缓解措施。分析师使用归纳推理和科学方法，而不是演绎推理。换句话说，他们必须利用自己的最佳判断来制定缓解措施，并通过测试来验证这些措施，而不是通过一系列关于事故的“如果-那么”陈述来得出一组正确的缓解措施。实际执行缓解后，如果缓解成功，分析师将关闭事件。分析师将开发自动测试，在开发缓解措施时验证他们实现的缓解措施。由于分析人员已经构建了这些测试，并且它们自然地从缓解开发中出现，AI/ML 在这个决策点上没有表现出显著的价值。

针对机器学习和分析问题

那些不熟悉安全操作的人可能认为单个 ML 算法可以帮助并最终取代安全分析师。虽然这样的超级机器可能有一天会存在，但上述五个决策点中的每一个都代表了一个具有不同数据源和所需分类结果的独特问题。事实上，上面的图片和将安全运营缩小到五个决策是对安全运营挑战的过度简化。这种简化的价值在于确定我们可以从哪里开始使用机器学习来提高安全运营的效率。机器学习工程师应该寻求在这五个决策点中的一些点上实现分类，以便帮助、缓解和关注安全操作员。

野外分类

原文：https://towardsdatascience.com/classification-in-the-wild-4787c4ffca38?source=collection_archive---------26-----------------------

让我们深入分类指标并讨论一些技巧，它们可以提高您的分类管道性能。

帕特里克·托马索在 Unsplash 上拍摄的照片

嗨，我是 Sergey，在过去的 5 年多时间里，我一直致力于基于 ML 的项目。在我的职业生涯中，我参与过不同的项目，创业公司，大公司，赢过几次比赛，写过几篇论文。我还启动了Catalyst——一个基于 PyTorch 的高级框架，以提高我作为深度学习实践者的生产力。有了这样一条路径，我最近决定写一系列关于深度学习“一般事情”的帖子。几个想法之后，我决定从 ML 评估技术和度量标准开始:如何理解它们？什么时候使用它们？在这种情况下，今天，我想深入研究深度学习中的分类指标，并讨论一些技巧，这些技巧可以提高你的分类管道性能。

你可以在 这个 colab 笔记本 下面找到所有的例子。
博文原文为 此处 。

实验 01:典型分类

分类任务对于任何深度学习实践者来说看起来都是众所周知的。长话短说，我们有一些以(some-data, label)格式标记的数据，并想创建一个模型，它可以为我们将some-extra-data转移到label。例如，让我们回顾一下简单的 CIFAR10 分类:

典型的分类管道。

总结上面一个例子:

• 我们创建resnet9网络
• 在CIFAR10上训练它 10 个纪元
• 有CE损耗、Adam优化器、MultiStep调度器
• 和accuracy作为验证度量

这个例子看起来像一个非常普通的分类管道。我们能做得更好吗？我们去看看吧！

实验 02:焦点丢失

从一个简单的改进开始，让我们介绍一下FocalLoss而不是CE。长时间回顾，请阅读原始论文，短时间回顾:由于基于真实概率和预测概率之间的差异对每样本损失进行重新加权，FocalLoss更好地处理了类别不平衡，重点关注难以区分的类别。因此，它为具有严重类别不平衡的分类任务提供了更好的性能(真实情况，而不是 CIFAR 情况)。更重要的是，它不会在您的管道中引入任何额外的复杂性。所以让我们来看看:

无焦点分类。

虽然我们还没有明显改善 CIFAR10 的结果，但FocalLoss通常有助于更实际的案例。最后一个小技巧，我也想提一下——多准则用法:

多标准分类设置示例。

这种方法为您提供了一种平衡简单分类(使用CE损失)和侧重不平衡分类(使用FocalLoss)的方法。

实验 03:分类指标

好的，正如我们已经看到的，由于FocalLoss，我们可以“提高”一下accuracy的性能。但是有一些额外的分类标准可以更好地理解您的模型:

• precision -显示标签预测中的模型保证。例如，假设precision为高，模型预测某个输入I的某个标签L。在那种情况下，I实际上是L的概率很大。
• recall -显示模型在数据流中找到所有类实例的能力。当然，高的recall并不意味着所有的模型预测都足够准确，但是它给了我们覆盖所有类实例的高概率。
• f-score -是precision和recall之间的调和平均值。因此，它可以被视为理解模型在数据流中找到所有相关类(recall)并正确标记它们(precision)的能力的统一分数。此外，f-score beta参数允许我们在聚合时优先选择precision或recall。

此外，在模型训练和预测过程中，还有两件事需要检查:

• support -每个类只有简单数量的样本。这似乎是不经意的，但是你拥有的数据点越多，你就能找到自信的洞察力。有时，即使您有一个包含各种类的大型数据集，也可能有只有少数几个示例的类，从而导致训练和评估期间出现不可预测的结果。向您的管道中添加一个support指标，为您提供了一种在训练期间“验证”数据集的简单方法。
• confusion matrix -易于跟进你的分类模式简历区分不同类别的能力。虽然它明显地帮助您分析模型的正确性(混淆矩阵对角线)，但它也让您对类的分布和标记有了重要的了解。在我的实践中，有几个案例是confusion matrix在数据集更新期间帮助发现不正确的标记——仅仅是在confusion matrix上检查类的交互异常。

让我们将它们添加到我们的管道中:

包含所有必备指标的分类示例。

对于这些指标，有一些关键的技巧需要注意。所有这些都可以通过类的*“每类”或“聚合”来计算。【Per-class】结果对于理解模型性能至关重要，因为在很多情况下，您的模型在最重要的类上可能表现“良好”，但“比以往任何时候都差”。例如，我们可以查看一些文本分类模型，这些模型对问候意图非常有效，但对有害意图的预测却失败了，从商业角度来看，这可能更有价值。【聚合】*如果你想快速查看几个数字的模型性能，结果是必不可少的。有三种最常见的聚合策略:

• 微:所有样本对最终平均度量的贡献相等，
• 宏:所有类对最终平均度量的贡献是相等的，
• 加权:在平均过程中，每个类的贡献根据其大小进行加权。

上述指标的另一个重要注意事项是，它们的所有结果都是基于数据集的，这意味着您不能简单地平均基于批处理的微指标来获得基于数据集的微统计数据。

张量板

由于我们有大量不同的指标，使用 tensorboard 来观察它们会容易得多:

tensorboard --logdir ./logs

上述管道的精度指标。(图片由作者提供)

推断&报告

此外，还有一种以用户友好的方式表示所有上述指标的方法，用于审查最终模型性能:

分类报告结果。(图片由作者提供)

有了这样的分类报告，断定模型的最终性能就容易多了。

阈值

我想在本教程中提到的最后一个关键步骤是阈值。虽然它们不是花哨的深度学习模型，但它们为您提供了一种无需任何额外学习即可针对您的生产案例调整这些模型的方法。因此，举例来说，你可以为一些贫穷的工人阶级设置一个阈值1.0，以阻止模型预测它。只要这是生产深度学习中的基本实践，它也包含在催化剂中:

正如您所看到的，我们已经能够稍微改进我们的模型性能，即使是在像 CIFAR 这样简单的设置中(在 CIFAR 上学习模型非常容易)。当然，在基准测试期间会有数据泄漏，因为我们是在同一个test集上调优和评估thresholds，所以在现实世界的例子中，您必须将数据集分成train、valid和test部分，以防止任何数据泄漏。然而，即使有如此严格的评估设置，thresholds的使用通常会给你的兴趣指标带来关键的 2–8%的改善，这是巨大的。

结论

总而言之，这篇博文的主题是:

• 分类问题仍然是一个有待改进的领域(特别是在闭集和开集领域，但这是另一篇文章)，
• 在你的下一个实验中尝试FocalLoss，如果你的数据中有一个类不平衡(一个很常见的情况)，
• 使用PrecisionRecallF1Support和ConfusionMatrix分析您的模特在训练中的表现，
• 使用classification report了解您的最终模型分类性能，
• 在模型部署期间尝试使用thresholds,针对您的特殊情况调整模型，并提高最终性能。

如果您想更深入地了解这个分类示例，您可以:

• 用CIFAR100代替默认的CIFAR10，
• 查看我们的 CV 数据集，
• 尝试为 NLP 采用相同的管道( Albert 在 TPUs 上的培训示例)，

或者针对您想要的任何分类问题进行调整；)

这些都是这篇博文分类的重要步骤。如果你想查看更多深度学习最佳实践——订阅[scitator](https://scitator.com/post/2110-classification/twitter.com/scitator) & [catalyst-team](https://twitter.com/CatalystTeam)。感谢您的阅读，敬请期待更多内容！

分类—让我们了解一下基础知识

原文：https://towardsdatascience.com/classification-lets-understand-the-basics-78baa6fbff48?source=collection_archive---------28-----------------------

机器学习(监督学习)

照片由 Reiseuhu 在 Unsplash 上拍摄

在我之前的博客中——机器学习的阴影——我们讨论了机器学习算法的两种主要类型。只是为了温习一下，我们有监督学习(其中目标已知/数据被标记，模型在此监督下工作)和无监督学习(其中目标未知/数据未被标记，因此算法没有任何监督)。

在这篇博客中，我们将只讨论分类。我们将讨论一些与分类相关的基本但重要的问题，例如— 分类到底意味着什么？什么样的数据可以分类，什么不能分类？有哪些分类算法？

分类的真正含义是什么？

在开始分类之前，让我们了解数据集的不同部分及其与算法的一般关系。

作者图片

我在上面的图片中创建了一个“假设”数据集，只是为了解释这个理论(吃披萨或可乐或蔬菜完全是你的选择，请不要让我为健康/不健康负责！😛)

1. 数据集 —任何以行列形式排列的数据都适用于 ML。列分为两种类型—变量(可以是一列或多列)和目标(总是一列)。这些行是我们的数据点。
2. 目标/标签 —是我们要预测的列。这是我们的结果列，我们想知道未来的数据。在这个数据集中，它的列“适合/不适合”用蓝色标记。我们的整个监督学习依赖于这一列，因为这是我们想要知道的。
3. 变量/特征 —目标列以外的列。这些列帮助 ML 模型预测未来数据点的目标。在这个数据集中，变量是- >“吃比萨饼”、“喝可乐”、“吃蔬菜”和“锻炼”。
4. 你可能会想什么样的栏目是“人物”。嗯，当我们在 ML 算法中输入数据时，有一些列我们不使用，因为我们不希望我们的模型“过拟合”或了解每个场景，相反，我们希望算法理解一般模式，并创建一个模型来预测同样的情况。我们将在以后的博客中讨论更多的过度拟合问题。

现在你已经熟悉了数据集和算法的关系，让我们回到分类上来。顾名思义，分类就是根据某些理由对数据进行分类。这是一种监督学习。在分类中，目标列应该是分类列。如果目标只有两个类别，如上面数据集中的类别(适合/不适合)，则称为二元分类问题。当有两个以上的类别时，这是一个多类分类问题。“目标”列在分类问题中也称为“类”。

什么样的数据可以分类，什么不能分类？

为了对事物进行分类，我们需要有限的范畴。因此，我们需要一个数据集，其类别标签为— [0，1]，[通过，失败]，[适合，不适合]，[好，更好，最好]等。如果我们在目标列中有这样类型的值，我们可以使用分类方法来解决这个问题。但是如果我们在目标列中有连续的数值，比如[100，23，44，46，44.7，24.8，…等等。]，我们无法在这样的数据集上进行分类。在这种情况下，我们要么将该值转换为类值，例如— {values >50 将被视为 1，而以<50 is 0}, or we use other methods like regression to solve the problem which is out of the scope of this blog.

To understand this better, let’s take an example of the employee salary and other features dataset (below):

Data For Non-Classification Problem(Image By Author)

The above image consists of some data points, with Salary as our target variable. Now since Salary is a continuous number column (since salary is always numeric), we cannot treat this as a classification problem. But if we really want to treat this as a classification problem due to some reason, we can bin the target column into two categories **为例— Salary > 70，000 为高，Salary < 70，000 为低。**完成此操作后，数据集将如下所示:

将回归转换为分类问题(图片由作者提供)

所以现在我们的数据已经可以作为一个分类问题来处理了。当然，基于所使用的不同类型的算法，我们需要做其他的数据处理工作，但是我们现在至少有了一个分类的目标。

ML 算法或模型如何对数据进行分类？

既然我们知道了数据集如何与 ML 模型相关，以及哪些数据集可以用作分类问题，我们也应该知道如何解决它们，对吗？

世界上有很多算法正被用来解决分类问题，甚至每天都有更新的算法被推出。其中一些算法是— 决策树、 **【支持向量机】(SVM)、随机森林、梯度提升树(GBT)、K-最近邻(KNN)、**等。决策树是理解每个人分类的基本算法，也是理解树在机器学习中如何工作的基本算法。但是我喜欢保持我的博客简短，决策树应该有一个完整的博客，所以我会在这里停下来，并尝试尽快提出我的下一个关于决策树的博客！❤

同时，你可以按以下顺序查看我以前的博客，了解数据预处理和 ML 项目流程:

1. 面向非数据科学家的数据科学
2. 弥合业务差距&数据科学
3. 数据科学—我该从哪里开始？
4. 数据里面有什么！
5. 理解数据中的模式
6. 特征工程——保留什么，删除什么？
7. 不同深浅的机器学习

我希望这个博客能帮助一些人理解他们之前没有得到的东西(并让他们继续提问)！😃

分类指标—混淆矩阵解释

原文：https://towardsdatascience.com/classification-metrics-confusion-matrix-explained-7c7abe4e9543?source=collection_archive---------30-----------------------

照片由陈伶俐·桑特兰在 Unsplash 上拍摄

我正在撰写一系列博客文章，旨在涵盖各种数据科学和机器学习概念的基础知识。我这么做主要是为了自己更好的理解这些概念。我希望在这个过程中，我也能帮助别人理解他们。好吧，我们开始吧！

在机器学习领域，混淆矩阵(也称为误差矩阵)是一个表格，允许我们可视化算法的性能。它仅用于分类任务。

这个名字来源于这样一个事实，即很容易看出一个算法是否混淆了两个或更多的类(即没有做出正确的预测)

二元(2 类)分类器示例

让我们从最简单的例子开始。想象一下，我们训练了一个机器学习模型来检测照片中是否有狗。这是一个二元分类任务，意味着只有两个类别(照片中的“狗”或“不是狗”)。如果照片中有狗，则用于训练过程的标签为 1，否则为 0。在二进制分类任务中，我们经常把这些类叫做正和负。当我们向模型传递一张新照片时，它会预测照片中是否有一只狗。

现在，假设我们要对 10 张新照片进行分类。我们可以使用我们的分类器对照片进行分类。每张照片都会收到一个包含标签(0 或 1)的预测，该标签代表两个类别(狗或非狗)。因此，对于每张照片，我们将有预测类和实际类。根据这些信息，我们可以为这 10 张照片生成一个混淆矩阵。稍后，我会给你一个链接，链接到一个很棒的绘制混淆矩阵的例子。现在，假设在我们通过了预测类和实际类之后，返回下面的混淆矩阵:

混淆矩阵—二元分类器 10 只狗

矩阵的每一列代表实际类中的实例，而每一行代表预测类的实例(反之亦然)。我们训练了一个模型来检测两个类，因此我们最终只有 4 个代表不同信息的单元格:

• т第一行第一列的单元格包含真实底片的数量(在我们的例子中，该单元格包含不包含狗的正确预测照片的数量)。模型真实预测这 3 张照片中没有狗。
• т第一行第二列的单元格包含假阳性的数量(在我们的例子中，该单元格包含预测为狗的照片的数量，但实际上照片不包含狗)。模型错误地预测这两张照片中有一只狗。
• т第二行第一列的单元格包含假阴性的数量(在我们的例子中，该单元格包含预测为不是狗的数量，但实际上照片包含一只狗)。模型错误地预测在这张照片中没有狗。
• т第二行第二列的单元格包含真阳性的数量(在我们的例子中，该单元格包含包含狗的正确预测照片的数量)。模型真实预测这 4 张照片中有一只狗。

我们可以很容易地看到，我们的模型正确预测了 10 张照片中的 7 张，并错误分类(混淆)了 3 张照片。从上面的观察，我们可以决定我们的分类器是否足够好，并继续对错误分类的照片进行额外的分析。

多类分类器示例

这是一个非常简单的例子。在某些情况下，我们需要训练一个模型来预测两个以上的类。让我们想象一下，我们想要训练一个模型来预测一张照片是否包含一只狗、猫或兔子。在这种情况下，类的数量将是 3。现在，假设我们传递 27 张照片进行分类(预测),我们得到以下混淆矩阵:

混淆矩阵-多类分类器 27 张照片

同样，矩阵的每一列代表实际类中的实例，而每一行代表预测类的实例。然而，这次我们有 9 个单元，因为我们有 3 个类。

请注意，我所说的真实的猫是指被归类为猫的照片，而且是真实的猫。另外，所谓的假猫，我指的是那些我们归类为猫但实际上不是猫的照片。对/错单词告诉我们预测是否正确，猫/狗/兔子单词告诉我们实际等级。

从这个混乱矩阵中可以得出一些见解:

• 模型只正确预测(分类)了全部 27 张照片中的 15 张。有 3 张正确预测的照片包含猫，4 张正确预测的照片包含狗，8 张正确预测的照片包含兔子。
• 从所有错误分类的照片中，我们有:2 张预测为狗但实际包含猫的照片，2 张预测为猫但实际包含狗的照片，1 张预测为兔但实际包含狗的照片，3 张预测为猫但实际包含兔的照片，以及 5 张预测为狗但实际包含兔的照片。
• 此外，我们可以看到，我们没有任何错误预测为兔子的照片，实际上包含一只猫。

现在你知道如何阅读一个混淆矩阵和它代表什么。这里有一个很好的例子，展示了如何使用 sklearn 软件包轻松生成漂亮的混淆矩阵。

摘要

混淆矩阵可以用来分析分类器的性能，并让我们了解应该朝哪个方向改进分类器。然而，我们只是看了两个由少量类别(2 和 3)训练的分类器生成的混淆矩阵。想象一下，我们要训练一个有 100 个类的分类器。在这种情况下，也许我们需要一些指标来聚集混淆矩阵提供的信息。请继续关注下一篇文章，我将向您展示我们如何使用准确度、精确度和召回指标，这些指标的定义只是使用矩阵值的公式。

好了，这就是所有的人！我希望你喜欢这篇博文。如果你对我有任何反馈，请告诉我。这里有一张图片总结了混淆矩阵的定义和例子。

如果你想在我发表新的博客文章时得到通知，你可以订阅我的简讯。这是我在 LinkedIn 上的简介，如果你想和我联系的话。我将很高兴与你联系在一起。

资源:

• https://en.wikipedia.org/wiki/Confusion_matrix
• https://sci kit-learn . org/stable/auto _ examples/model _ selection/plot _ confusion _ matrix . html

机器学习中的分类模型和阈值

原文：https://towardsdatascience.com/classification-models-and-thresholds-97821aa5760f?source=collection_archive---------16-----------------------

如何选择阈值以及它们为什么重要

Pawel Czerwinski 在 Unsplash 上的照片

分类模型是监督机器学习的子集。分类模型读取一些输入，并生成将输入分类到某个类别的输出。例如，一个模型可能会读取一封电子邮件，并将其分类为垃圾邮件或非垃圾邮件—二进制分类。或者，模型可以读取医学图像，比如乳房 x 光照片，并将其分类为良性或恶性。

像逻辑回归这样的分类算法会生成一个概率分数，为属于某个类别的输入分配一定的概率。假设分类是二进制的(恶性或良性，垃圾邮件或非垃圾邮件)，这个概率然后被映射到二进制映射。在前面的垃圾邮件示例中，模型可能会读取一封电子邮件，并生成 92%的垃圾邮件概率得分，这意味着该电子邮件确实是垃圾邮件的可能性非常高。对于频谱两端的概率分数，映射非常明显。分数接近0 意味着该电子邮件很可能不是垃圾邮件，而接近 100 意味着该电子邮件很可能是垃圾邮件。然而，映射决策在许多情况下并不完全明显。考虑 58%的分数，这应该被归类为垃圾邮件吗？同样，32%的分数是否应该被归类为非垃圾邮件？

为了将逻辑回归或类似的概率分类模型的输出映射到二元分类类别中，您需要定义一个分类阈值。这个阈值代表决策边界。在前面的垃圾邮件分类器示例中，高于该阈值的值将被映射到垃圾邮件类别，而低于或等于该阈值的值将被映射到非垃圾邮件类别。问题是你如何选择这个门槛，这个选择意味着什么。

在我们能够回答这个问题之前，我们将需要稍微走一点弯路来理解如何度量模型。像我们这样将电子邮件分类为垃圾邮件或非垃圾邮件的模型可以通过这 4 种测量进行评估:真阳性、假阳性、真阴性和假阴性，这些都在下面的 2x2 中定义。绿色象限代表现实(真相)和模型(预测)之间的一致，而红色象限代表不一致。

作者图片

使用上述 4 个度量，我们可以导出另外两个度量，这两个度量有助于评估模型的性能以及最终如何选择阈值。

真阳性率(TPR): 这衡量模型能够正确预测阳性病例的程度。这是模型能够相对于被模型错误分类为阴性的真阳性和阳性病例的总和正确识别真阳性的功能；假阴性。更令人困惑的是，这种测量经常被称为敏感度或回忆

作者图片

真负率(TNR): 这是正例的逆例。它衡量模型能够正确识别真正负面案例的程度。这是相对于真阴性和模型错误分类为阳性的情况的总和的真阴性的函数；假阳性。这种测量也被称为特异性

作者图片

现在让我们用一个说明性的例子来展示这些测量。假设我们有一个模型，将 10 封电子邮件分类为垃圾邮件(正面)或非垃圾邮件(负面)。下表的第一行显示了这 10 封邮件的真相。在这 10 封邮件中，5 封是真正的垃圾邮件，5 封不是。该模型为每封输入的电子邮件生成一个概率分数，如下面第二行所示。最后五行使用 5 个不同的阈值将这个概率分数映射到一个二元决策——垃圾邮件还是非垃圾邮件。第一个阈值是 0.5，这意味着如果该模式的概率大于 50%，则该电子邮件将被分类为垃圾邮件，任何低于该分数的邮件都将被分类为非垃圾邮件。其他阈值为 0.3、0.8、0.0 (100%垃圾邮件)和 1.0 (100%无垃圾邮件)。后两个阈值是极端情况。最后，标为绿色的单元格表示真阳性和真阴性，而标为红色的单元格表示假阳性和假阴性。

作者图片

下表显示了之前定义的 4 个测量值，以及所用三个阈值中的每一个的 TPR 和 TNR。注意 TPR 和 TNR 是如何受阈值变化影响的。还要注意敏感性(TPR)和特异性(TNR)之间的反比关系。一个增加，另一个减少。找到正确的阈值是这两种测量之间的权衡。

作者图片

这很直观。阈值非常高(0.8)的模型会错误地将大多数电子邮件归类为非垃圾邮件。相反，阈值非常低(0.3)的模型会很快将大多数电子邮件分类为垃圾邮件。两者都是正确的，最终重要的是模型的预期用途和这些阈值的含义。

想象一下，如果实际部署了阈值为 0.3 的模型来过滤您的电子邮件提供商的垃圾邮件。该模型将非常积极地将大多数电子邮件归类为垃圾邮件。这种方法的后果将是你错过了非垃圾邮件，这些邮件最终会出现在你的垃圾邮件文件夹中…你必须定期检查你的垃圾邮件文件夹，看看它是否包含非垃圾邮件(误报)信息。这可能会导致糟糕的用户体验。或者，阈值非常高(0.8)的垃圾邮件过滤器可能会导致收件箱充满垃圾邮件。这也不是很好的用户体验。

在回答我们最初的问题之前，我们需要引入另一个概念:如何选择“正确的”阈值。这个概念就是接收算子曲线，简称 ROC。ROC 绘制了不同阈值下模型的灵敏度和特异性(实际上它绘制了1-特异性)。这类似于前面的例子，它显示了一个模型沿 5 个不同阈值的敏感性和特异性。下图显示了各种模型的示例性 ROC。每条曲线代表一个分类模型

图像由马丁·托马斯——自己的作品， CC0

该曲线有助于理解 TPR 和 FPR(对于不同阈值为 1-TNR)之间的权衡。此外，曲线下面积(AUC)提供了一个数字来概括模型的性能。完美模型的 ROC 为 1，而表现不佳的模型(随机分类器)的 ROC 为 0.5。ROC 是理解不同阈值之间权衡的有用诊断工具，AUC 提供了基于一般能力比较模型的有用数字。

快到了，我保证！

最佳阈值是最大化 TPR 和最小化 FRP 的点。我们可以在 TPR 约为 0.65 的蓝色曲线上大致了解一下。除了瞎猜，我们还可以选择使特异性和敏感性的几何平均值最大化的阈值。

作者图片

确定最佳阈值的几何平均法实际上可能不是您想要使用的最佳点(双关语)。简单地选择最大化 TPR 和最小化 FRP 的点可能会有一些不期望的结果。考虑一个模型的情况，该模型将罪犯分类为应该判死刑或不应该判死刑的人——我希望这样的模型永远不要被开发出来，但是请原谅我。您可能希望尽量减少假阳性，因为假阳性的后果是非常不利的:您的模型会让一个无辜的人走向死亡。您必须采取的平衡措施是选择一个阈值来减少误报，同时也产生一个合理的 TPR。下图描述了这一点。

作者图片

使用几何平均法将得出上面红点所示的阈值。这个阈值将导致大约 18%的 FPR。可选地，沿着 ROC 曲线(绿点)选择较低的阈值导致约 2%的 FPR。这里明显的权衡是通过选择绿点处的阈值，TPR 降低约 10%，但考虑到我们模型中假阳性的后果，这可能是一个很好的权衡。

因此，使用什么阈值的答案毕竟是“视情况而定”😃

最初发表于【https://karimfanous.substack.com】。

雷达回波的分类

原文：https://towardsdatascience.com/classification-of-radar-returns-c79fa1ce42eb?source=collection_archive---------29-----------------------

电离层数据集的案例研究

由 VM Quezada 在 Unsplash 上拍摄的照片

1. 介绍
2. 问题陈述
3. 映射到 ML/DL 问题
4. 理解数据
5. 数据处理和探索性数据分析
6. 结构
7. 结论和未来工作
8. 参考

1.介绍

电离层位于大气层和外层空间的地平线上。有趣的是，电离层探索属于太阳系探索的范畴。电离层是地球大气层从 48 公里到 965 公里的电离部分，包括热层和部分中间层和外逸层。[维基百科]

研究电离层的十个重要原因

• 它容纳了地球大气中所有的带电粒子。
• 它是地球大气层和太空的分界线。
• 在这个区域可以感觉到轨道阻力。
• 地球轨道卫星最喜欢去的地方。
• 它受到地球上天气条件波动的影响。
• 无线电和全球定位系统信号被电离层的辐射干扰。
• 受太空天气条件的影响。
• 空气辉光发生在原子和分子被太阳光的辐射激发而发光并释放多余能量的地方。
• 太空机构用不可见类型的光研究电离层
• 2019 年 10 月，美国宇航局加入了 GOLD，使用 ICON-电离层连接探测器研究电离层

2.问题陈述

在电离层研究中，我们需要将信号分为有用的(好的)或无用的(坏的)以供进一步分析。通常在这种分析中，手动干预是必要的，这是一项痛苦耗时的任务。约翰·霍普斯金应用物理实验室已经把从拉布拉多鹅湾雷达收集的数据存入了 UCI 机器学习知识库。

3.映射到 ML 问题

这个来自地球物理领域的问题可以映射成机器学习中的二分类问题。我们需要将数据分为好的(“g”)和坏的(“b”)。好的(‘g’)雷达显示了一些在电离层中返回的证据，而坏的(‘b’)雷达是那些不通过电离层的信号。

4。理解数据

“这些雷达数据是由拉布拉多鹅湾的一个系统收集的。该系统由 16 个高频天线的相控阵组成，总传输功率为 6.4 千瓦。目标是电离层中的自由电子。使用自相关函数处理接收的信号，自相关函数的自变量是脉冲的时间和脉冲数。鹅湾系统有 17 个脉冲数。该数据库中的实例由每个脉冲数的 2 个属性描述，对应于由复合电磁信号“[UCI 档案]产生的函数返回的复合值。

给定的数据集包含 351 行和 35 列。前 34 列是特征，最后一列包含“g”和“b”的分类标签。

5。数据预处理和探索性数据分析

给定的数据集包含 34 个特征。在深入研究特性的重要性之前，为了找出哪个特性更有用，哪个不是，先做一个随机数据分析。

我们将把数据集转换成 pandas 数据框，并执行进一步的处理。在转换成 pandas 数据框后，我们将删除数据集中任何重复的行。因此，最终的数据帧有 350 行和 34 列。

我们需要使用 MinMaxScaler 规范化数据集，然后对数据集执行初步的 EDA。概率密度函数图和累积密度函数如下所示。

PDF 绘图

CDF 图

由于特征值高度重叠，我们无法从上述图中推断出任何关于特征的重要信息。

我们现在将绘制具有相应标签的要素的热图，以检查是否可以进行任何重要的分析。

相关矩阵的热图

根据上面的热图，除了图中的要素高度重叠之外，无法推断出更多信息。

我们使用 sklearn 的选择测试功能来选择前 k 个重要特性。这在分类任务中使用。sklearn 的实现是用于分类的 ANOVA(分析均值之间的差异)。

计算最佳特性的代码

最重要的 5 个特征

降维

让我们使用一些降维技术，如主成分分析和 t-SNE，看看我们是否可以从我们的数据中获得任何其他见解。

主成分分析

我们使用主成分分析来找出数据集中的哪些成分解释了 80%以上的方差

代码和分析

从上图可以明显看出，1 到 10 之间的特征解释了最大方差。因此，“选择最佳”的输出和 PCA 的输出几乎匹配。

t-SNE: t 分布式随机邻域嵌入

让我们对数据集运行 t-SNE 算法，进行多次迭代并改变困惑分数，并检查是否有任何现象可以解释数据集中所有要素的高度重叠性质，从而使分析变得复杂。

基于 t-SNE 图，通过迭代= 50k 和不同的困惑分数，特征是不可区分的。因此，由于这些是电离层中的信号或辐射，它们由复数表示，因此它们需要更详细的机器学习模型来解释它们的行为。

6.结构

我们需要建立一个有监督的机器学习模型来解决这个二元分类问题。为了对好的和坏的回报进行分类，我们需要找到将两者平均分开的超平面。

我们可以使用 SVM 分类器来完成这项任务。使用 sklearn 的带 loss='hinge '的 SGDClassifier，可以得到 LinearSVM 模型。我们为模型评估选择的度量是 AUC。

具有所有 34 个特征的模型的训练和测试 AUC 被评估为 0.5。这意味着数据集本质上是高度随机的。因此，我们需要只选择最佳特征，并在这些特征上拟合模型，以获得所需的 AUC。

对数据集的前 5 个要素运行分析的代码如下。在这种情况下，获得的 AUC 从 0.5 提高到 0.7

为了进一步提高 AUC 和准确性，我们可以使用梯度推进决策树。梯度推进决策树在处理异构数据和相对少量的数据时非常有效。CatBoostClassifier 是 Yandex 公司的一个开源库。获得的 AUC 在训练数据集和测试数据集上提高到 0.85

在相同的上运行分类报告后，我们得到以下结果

分类报告

在将 GBDT 模型用于雷达回波的二元分类任务之后，在训练和测试数据集上的准确率分别提高到 85%和 89%。

根据应用物理实验室【3】的研究论文，深度学习神经网络模型，如简单的多层感知器，在特异性和敏感性方面超过了任何机器学习模型

我们已经实现了一个 MLP 模型与亚当优化。模型摘要和模型如下所示。关于代码实现，请参考文章末尾给出的 Github 链接。

多层感知器的自定义层实现在研究论文中给出的测试数据集上给出了更好的准确性。获得的测试准确度为 98%。完整的代码可以在下面参考资料部分提供的 GitHub 链接中找到。

7.结论和未来工作

对于给定的数据集，具有 5 个隐藏层和 Adam 优化器的多层感知器简单地优于其余的模型对应物

根据该研究论文，利用 MLFN 效应、非相干散射、雷达脉冲吸收和发射机干扰来分析不良回波的原因将是令人感兴趣的。我对研究这些方法感兴趣，并使用深度学习方法来实现和分析它们。

这些可以探索电离层研究的新的研究途径。

8。参考文献

1. https://www.appliedaicourse.com/
2. UCI 机器学习知识库:电离层数据 Se t
3. https://www . jhuapl . edu/Content/tech digest/pdf/V10-N03/10-03-Sigillito _ class . pdf
4. Github 源代码。
5. 链接到我的 LinkedIn 个人资料

高光谱数据分类

原文：https://towardsdatascience.com/classification-on-hyperspectral-data-19c48c432b96?source=collection_archive---------25-----------------------

这是一个循序渐进的教程，介绍如何使用支持向量机执行特征约简，然后对高光谱数据进行分类

米卡·科霍宁的照片

简介

本教程的目标是将 PCA 应用于高光谱数据。(要了解 PCA，请阅读文章“高光谱数据的 PCA”。).在使用 PCA 降低数据的维度之后，通过应用支持向量机(SVM)对图像中的不同材料进行分类来对数据进行分类。

步伐

在本教程中，我们将使用高光谱 Gulfport 数据集。您可以从以下链接下载数据。

https://github.com/GatorSense/MUUFLGulfport

MUUFL Gulfport 数据包含基于像素的地面真实地图，该地图通过手动标注场景中的像素来提供。在场景树中标记了以下类别，主要是草地、地面、混合地面、泥土和沙子、道路、水、建筑物、建筑物的阴影、人行道、黄色路缘、布料面板(目标)和未标记的点。

步骤 1:导入库

步骤 2:加载数据

原始数据中有 65 个波段。

RGB 图像

步骤 3:去掉未标记的和一些类数据

移除未标记的数据点，并且将一些相似的类合并成一个。例如，水和建筑阴影合并成一类，因为它们具有相似的光谱。此外，布面板和黄色路缘类被忽略，因为他们的数量很少，因此，没有足够的培训。

因为地面真相标签从一开始。所以在最后一行，我从所有标签中减去 1，以确保它们从零开始。

步骤 4:将数据分为训练和测试

步骤 5:对原始数据应用 SVM 分类器

我对训练数据进行了 K 重交叉验证。

步骤 6:对 PCA 数据应用 SVM 分类器

我已经应用了 3 个模型的集合，并在训练数据上使用了 K-fold 交叉验证。

计算多数票后所有三个模型的最终预测。

步骤 7:绘制 PCA 后的最终图像

应用 PCA 后的图像

结论

PCA 前的数据维数为 65，PCA 后的数据维数为 3。主成分分析将数据的维数降低了近 21 倍。

从上面的结果我们可以得出结论，当我们将 SVM 应用于原始数据时，准确率在 88.7% 左右，而将 SVM 应用于主成分分析后，准确率在 88.9% 左右。所以在这两种情况下，我们得到了几乎相同的精度。

这就是为什么我们对减少的数据应用分类器。降低了时间和空间复杂度。根据问题的不同，与使用原始数据相比，PCA 的准确性可能更高。

感谢阅读！我希望这篇文章对你有用。如果你有任何问题，请随意提问。

参考

https://github.com/GatorSense/MUUFLGulfport https://scikit-learn.org/stable/modules/generated/sklearn.svm.SVC.html https://machinelearningmastery.com/k-fold-cross-validation/ https://scikit-learn.org/stable/modules/generated/sklearn.decomposition.PCA.html https://machinelearningmastery.com/standardscaler-and-minmaxscaler-transforms-in-python/

分类性能指标

原文：https://towardsdatascience.com/classification-performance-metrics-69c69ab03f17?source=collection_archive---------47-----------------------

探索各种性能测量方法，用具体的例子和插图来评估您的分类器。

分类性能指标包括照片。

评估一个分类器通常比评估一个回归量更困难，因为有许多可用的性能度量，并且不同类型的问题需要特定的度量。了解度量之间的差异以及何时使用它们仍然是解决任何分类问题的关键技能。

在本文中，我将从理解最重要的概念之一——混淆矩阵开始，然后进入其他度量，为您提供一种更简洁的方法来对分类器进行评分。

混淆矩阵

混淆矩阵是评估分类器性能的最佳方法之一。基本思想是计算一个类中的实例被正确分类或被错误分类为另一个类的次数。

混淆矩阵中的行代表实际类别，而每列代表预测类别。一个完美的分类器只会有真 正和真 负，这意味着它的混淆矩阵只会在其对角线上有非零值。

使用混淆矩阵计算准确度。

在混淆矩阵中，有两种类型的错误需要注意:假阳性或 I 型错误和假阴性或 II 型错误。这些术语来自统计学中的假设检验，并与分类问题互换使用。

从混淆矩阵中，你可以计算出各种不同的指标，包括最简单的一个准确度。准确度定义为正确分类的实例总数除以实例总数。在上面的例子中，我们计算的准确率为 86.11%！看起来不错，对吧？好吧，让我们来看一个虚拟分类器，它只是将每个实例分类为负类。

使用虚拟分类器计算准确度。

没错，虚拟分类器具有更好的准确性，这仅仅是因为正面分类器占总实例的 10%左右。这说明了为什么准确性通常不是首选的性能指标，尤其是当您处理不平衡的数据集时(例如，当一些类比其他类出现得更频繁时)。

精确度和召回率

混淆矩阵为您提供了有价值的信息，但有时您可能需要更简洁的度量。一种方法是计算被分类在正类中的所有实例的准确度。这叫做精度。由于 precision 只关注 I 类错误，所以它经常与另一个称为召回的指标(也称为灵敏度或真阳性率)一起使用。

计算精确度、召回率和 F1 分数。

这里我们看到，即使我们有超过 85%的准确率，我们的分类器只有 62.8%的时间是正确的。此外，它仅检测到 41.8%的阳性类别。将精确度和召回率结合成一个称为 F1 分数的指标通常是有帮助的。F1 分数被定义为精确度和召回率的调和平均值。它对较低的值赋予较重的权重，这意味着当这些值接近时，它将始终落在精度范围内，并回忆和偏好。

一种赋予精确度或召回率更大权重的方法是使用 Fβ分数，该分数赋予召回率β倍的重要性。因此，小于 1 的值有利于精度，大于 1 的值有利于召回。

精确度/召回率的权衡

有时你更关心精确度，有时你更关心回忆。例如，如果您训练一个分类器来检测欺诈性信用卡活动，如果您的分类器精度较低，只要它具有非常高的召回率(这意味着可能会有一些错误警报，但几乎所有的欺诈活动都会被检测到)，这并不是什么大问题。

另一方面，假设你训练了一个分类器，它检测自然界中的蘑菇是否可以食用(无毒)。当预测蘑菇可食用(高精度)但将一些可食用蘑菇错误分类为有毒(低召回率)时，您可能更喜欢您可以信任的分类器，而不是将有毒蘑菇错误分类为可食用的分类器。

现在你可能已经知道，提高精确度会降低回忆，反之亦然。这被称为精度/召回权衡。

通过绘制精度/召回率与阈值的关系来解释精度召回率的权衡。

要理解精度/召回率的权衡，您必须理解分类器如何将实例分配给正类或负类。每个分类器都有一个决策函数，它计算得分/概率，如果得分/概率大于某个阈值，则该实例被分配给肯定类；否则，它被分配给负类。

通过改变这个阈值，您可以有效地改变假阳性的数量，而以您的假阴性为代价。提高阈值会提高精度，降低召回率。而降低阈值会增加召回率并降低精确度。

在某些情况下，召回曲线会比精确曲线更平滑。这是因为当您提高阈值使其看起来平滑时，召回率总是降低，但是尽管提高了阈值，精确度也可能降低。

我们也可以直接绘制精度与召回率的关系图，以帮助我们选择一个好的精度/召回率折衷方案。

精确/召回曲线及其应用。

精度/召回曲线允许您准确地看到在给定期望精度的情况下，您将获得什么样的召回。在上面的例子中，您可能希望在急剧下降之前选择 90%左右的精度。您可以通过搜索最低可能阈值来做到这一点，该阈值至少可以提供您想要的精度。

到目前为止，您可能已经知道，通过设置足够高的阈值，在分类器上实现您想要的任何精度是相当容易的。但是，一个具有高精度和低召回率的分类器不是很有用。了解业务问题将帮助您决定一个好的精度/召回权衡。

受试者工作特性曲线

接收器工作特性曲线是另一种用于分析二元分类器误差的工具。它与精确度/召回率曲线非常相似，但 ROC 曲线不是绘制精确度对召回率，而是绘制真阳性率 ( 召回)对假阳性率 ( 下降)。

通过测量曲线下的面积(AUC ),我们可以对分类器的性能进行评分。完美分类器的面积为 1，而随机分类器的面积为 0.5。我们用虚线对角线表示随机分类器。我们希望我们的分类器尽可能远离这条线(朝向左上角)。

受试者工作特性曲线及其应用。

现在，您可能想知道是否应该使用精确度/召回曲线或 ROC 曲线，因为它们非常相似。当数据集不平衡或者当您更关心假阳性而不是假阴性时，最好使用精度/召回曲线。否则，使用 ROC 曲线。

结论

希望这篇文章已经使您能够为您的问题选择一个合适的度量标准，找到一个好的精确度/召回率的折衷，并使用 ROC 曲线和 ROC AUC 分数来评估和比较各种模型。

一如既往地感谢您花时间阅读我的文章。我希望你从阅读中学到的和我从写作中学到的一样多。

本文中的所有插图都是我画的，我计划画更多像这样的文章。

如果你喜欢这里的内容，就给我一个关注吧！😃

不平衡数据分类

原文：https://towardsdatascience.com/classification-with-imbalanced-data-f13ccb0496b3?source=collection_archive---------5-----------------------

使用各种重采样方法来改进机器学习模型

照片由 Unsplash 上的 Aziz Acharki 拍摄

在具有大量不平衡类别的数据上构建分类模型可能很困难。使用过采样、欠采样、重采样组合和自定义滤波等技术可以提高精度。

在本文中，我将介绍几种不同的方法来处理分类任务中的数据不平衡。

1. 过采样
2. 欠采样
3. 组合过采样和欠采样
4. 自定义过滤和采样

场景和数据概述

为了演示各种类别不平衡技术，将使用一个虚构的信用卡违约数据集。在我们的场景中，我们试图构建一个可解释的分类器，它接受两个输入(年龄和卡余额)并预测某人是否会错过即将到来的付款。

下面的图表显示了数据模型。您将看到数据中有一些随机的默认值(橙色点)，但它们只占很小的百分比(374 个训练示例实例中的 24 个，约 6.4%)。这可能会使一些机器学习分类算法变得具有挑战性，并且我们可能希望在某些情况下限制我们潜在的模型选择集，以获得可解释性/监管因素。

在这种情况下，我们的目标是使用逻辑回归的准确率达到 90%以上，F1 分数达到 50%以上(精确度/召回率的调和平均值)。

按作者分类的数据概述、图像和数据

基线逻辑回归

对于用于比较的基线模型，我们将运行简单的 逻辑回归 并绘制决策界限，以及计算各种准确性指标。

基本逻辑回归符合我们 90%以上的准确性目标，但在精确度/召回率方面失败了。您将在下面看到为什么默认类的相对大小如此之小，模型只是将每个单个数据点预测为 未默认 (由决策边界图中的浅蓝色背景表示)。

基线逻辑回归-在任何重采样之前，按作者分类的图像

然而，在我们的数据的左上方有一个明显的部分(非常年轻的高余额年龄)，似乎比随机违约更频繁。当引入重采样方法时，我们能做得更好吗？

过采样

处理这个问题的一种流行方法是使用 SMOTE 进行过采样。不平衡学习是一个 python 库，为不平衡类的分类任务提供了许多不同的方法。一种流行的过采样方法是 SMOTE 。

SMOTE 代表合成少数过采样技术。根据名称，您可能会直观地知道它是做什么的——用较少的数据点为类创建合成的附加数据点。它通过考虑其他特征来做到这一点——你几乎可以认为它是在我们必须添加新数据点的少数样本之间使用插值。

应用 SMOTE 很简单；我们只需传入我们的 x/y 训练数据，并取回所需的重采样数据。绘制这些新数据，我们现在显示了类的平均分布(350 个默认与 350 个非默认)。创建了许多新的默认类数据点，这应该允许我们的模型学习一个函数，该函数不仅仅预测每个数据点的相同结果。

SMOTE 调整后的训练数据，图片由作者提供

在这个重新采样的数据上拟合新的逻辑回归模型产生下面的决策边界。

您现在可以看到，不是蓝色背景代表整个图表的非默认决策(如我们的基线模型)，而是根据 SMOTE 重采样数据训练的新模型预测左上角部分的默认决策(用浅橙色背景表示)。

SMOTE 决策界限，作者图像

对只有几个数据点的类进行过采样肯定会导致更高的默认预测百分比，但是我们达到目标了吗？准确率下降至约 76%，但 F1 分数上升至约 30%。还没有，让我们尝试一些额外的方法，看看是否可以改进。

欠采样

用较少的例子对类进行过采样的反面是用较多的例子对类进行欠采样。使用编辑最近邻的方法，我们可以战略性地对数据点进行欠采样。这样做将导致以下修改的训练数据——我们仍然有 24 个默认类数据点，但是在我们的新训练数据集中，多数类现在只有原始 350 个数据点中的 287 个数据点。

ENN 调整训练数据，图片由作者提供

这导致以下决策界限。该模型正确地将左上角作为最频繁违约的区域，但 F1 分数并不在我们需要的位置。当然，仍有一些数据点可以捕捉，以创建一个更理想的决策边界。

ENN 决定界限，图像由作者

欠采样+过采样

另一种流行的方法是结合这两种方法。我们可以使用 SMOTE 进行过采样，然后使用 ENN 清理数据点。这在 imblearn 中被称为 SMOTEENN 。

SMOTEENN 调整后的训练数据，图片由作者提供

我们的标签数更接近相等，但是我们的总数据点更少。这对我们的指标有什么影响？

SMOTEENN 决策界限，作者图片

这种方法导致了更多的极端决策边界，准确性进一步下降，F1 分数更低。

自定义采样+ Smote

对于我们的数据，SMOTE 似乎有所帮助，但也许我们可以更有针对性地选择想要过采样的数据点。我们可以采取的一种方法是使用一个简单的 K 最近邻分类器，只挑选那些邻居也属于我们默认的具有某种概率阈值的类的数据点。

有了这些，我们现在有了下面的一组数据——将我们默认的类从 24 个减少到 10 个(但是希望去掉 有噪声的 数据点，这些数据点可能会扰乱我们的 SMOTE 过程并创建过于激进的插值)。

KNN 过滤数据，作者图片

执行 SMOTE(使用与前面步骤中相同的代码)会产生以下训练数据集—从我们最初的 10 个样本中创建 350 个默认的类样本:

自定义采样+ SMOTE 调整后的训练数据，图片由作者提供

我们训练了另一个新的逻辑回归模型和 使用这个重新采样的数据，我们现在达到了我们的目标！ 我们可以看到，在对我们调整后的数据进行训练后，决策边界现在考虑到了那部分违约。准确率仍然是 90%以上，F1 分数高于我们 50%的目标。

自定义采样+ SMOTE 决策界限，图片由作者提供

摘要

在建立机器学习模型时，有多种方法来处理不平衡的类。根据您的约束、目标和数据，有些可能比其他更适用。我们还可以提出一些创造性的重采样方法，以便构建一个分类器，正确地针对我们感兴趣的决策范围和场景，过滤掉数据中可能出现的噪声。

所有的例子和文件都可以在 Github 上找到。

原发布于https://data stud . dev。

分类器很简单，如果你认为贝叶斯

原文：https://towardsdatascience.com/classifiers-are-easy-if-you-think-bayes-d3da1afbec36?source=collection_archive---------23-----------------------

许多分类术语与贝叶斯概念直接对应:评估分类器变得容易多了

图片由塔纳西斯·帕帕萨恰里亚斯从皮克斯拜拍摄

评估分类器可能很棘手。首先，术语相当混乱，很难记住。有许多不同的评估指标可用，使用其中一个而不是另一个的原因可能很模糊。

但是这些概念不必混淆。事实上，一旦你以正确的方式构建分类问题，它们就变得相当直观。我最近说服自己，构建这个问题的正确方法是…贝叶斯方法！

在这篇文章中，我将解释很多分类术语是如何与贝叶斯概念一一对应的。这种关系很好理解，所以我在这里没有发现任何新的东西。尽管如此，它很少在教程和书籍中被提及。这很不幸，因为理解这种 1:1 的映射非常重要，原因有二:

1. 贝叶斯思维非常直观，这意味着复杂的分类术语变得更加清晰和容易记忆；
2. 评估分类器也变得更简单，因为每个评估指标的优点和缺点通过贝叶斯透镜变得直观。

我将从贝叶斯的快速回顾/介绍开始。我将在阐明分类器和贝叶斯术语之间 1:1 映射的同时做到这一点。最后，我将解释这种映射如何对您的分类器日常工作非常有用，尤其是对它们的评估。

开始吧！

(重新)定义分类问题

首先，我们需要一些符号。假设给你一个由特征向量 X 表示的数据点，你知道 X 可以属于两个可能的类之一:类 0 ( y =0)或类 1 ( y =1)。不幸的是，你不知道 X 属于哪一类，但是你得到了一个黑盒(分类器)，它做了一个有趣的把戏:它获取特征向量 X ，它进行一些计算并最终输出关于 X 属于哪一类的猜测( g = 1 表示分类器正在猜测类 1， g = 0 类 0)。

根据 Bayes 的说法，这是一个分类器

猜测并不总是可靠的:你在许多测试特征向量上尝试分类器，你最终得到的是正确和错误预测的混合体。因此，自然的问题是:给定这些测试，我如何量化分类器的可靠性？

输入贝叶斯

为了形式化评估分类器的过程，我们将使用贝叶斯规则(或定理)的概率形式，如下所示:

其中 P(…)表示概率，P(…|…)表示条件概率， θ 、 θ 和 O 为随机变量。

简而言之，这条规则显示的是，在进行观察后，我们应该如何将我们之前对理论的信念(最右边的项， P(θ)/P( θ) )改变为新的、更新的信念(最左边的项， P(θ|O)/P( θ|O) )，该信念考虑了观察结果。Bayes 告诉我们，正确的方法是将之前的信念乘以一个乘法因子(中间的那个词， P(O|θ)/P(O| θ) )，我们懂点数学就能计算出来。

这是总的想法，但是为了了解这个公式如何帮助理解分类器，我们需要更详细地研究这个公式的每个组成部分。我们将看到，在我们的分类问题中，每个术语都对应一个等价的概念。

理论

θ和θ是关于世界的两种替代说法或 学说*；*

在我们的分类问题中，这些只是我们关于 X 来源的替代理论，即: θ = " X 属于第 1 类"( y=1 )， θ = " X 属于第 0 类"( y=0 )。我们不知道这两种理论哪一种是正确的，我们希望分类器能提供一些线索。

先前赔率

P(θ)/P( θ)是我们在对世界进行任何观察之前，对理论θ为真的置信度(用赔率表示)( 先验赔率*)；*

在我们的分类问题中，这仅仅是 P(y=1)/P(y=0) 。我们应该给这个比率分配什么值？嗯，在询问分类器之前，我们对 X 一无所知，因此合理的做法是将 P(y=1)/P(y=0) 设置为等于这两个阶层在人口中的相对比例(例如，如果你衣柜中白/黑袜子的比例是 3/2，那么你分配给一只随机的白袜子的几率是 3/2)。因此，先验就是我们在分类设置中称之为 1 级的患病率。

小心小概率…(照片由迪伦·诺尔特在 Unsplash 上拍摄)

请注意，严重不平衡的数据集将导致先前的赔率非常高(因为分子 P(y=1) 接近 1，分母 P(y=0) 接近 0)或非常低( P(y=1) 接近 0， P(y=0) 接近 1)。

观察

O 是一个 观察 ，一个我们碰巧观察到的与理论θ和θ 有关的世界事实

在我们的分类问题中，当我们将特征向量 X 馈送给分类器时，观察值 O 是分类器的输出。换句话说，就是分类器对 X 的类的猜测。这是我们想要用来改变我们先前对 θ的信念的信号。

我们用二进制变量“ g ”来表示这个猜测。为了简单起见，我们假设分类器是猜测类 1，即 g = 1 。

一个拟人化的分类器正试图猜测(照片由莱曼·汉瑟·杰罗娜在 Unsplash 上拍摄)

似然比

P(O|θ)是理论θ赋予事实“O”发生的概率。它被称为θ的“似然函数”。同样，P(O| θ)是θ分配给“O”发生的概率。他们的比率 P(O|θ)/P(O| θ)被称为“ 【似然比 ”，它量化了理论θ在多大程度上给观察“O”比θ不同(更高或更低)的概率:如果差异很大(似然比非常高或非常低)，那么这一项乘以先前的赔率将导致我们信念的强烈更新，这具有直观意义。

在我们的分类问题中， P(O|θ) = P(g =1|y=1) :这是分类器会猜测 X 属于第 1 类( g=1 )的概率，在 X 确实属于 1 ( y=1 )的场景下。如果你熟悉(令人困惑的)分类器术语，你会知道这只不过是分类器的真阳性率(TPR) ！

而 P(O| θ) 呢？这就是 P(g =1|y=0) ，即当实际上 X 属于 0 类时，分类器会猜测 X 属于 1 类的概率。你认出它了吗？这个术语无非就是假阳性率(FPR) ！

这两项都可以很容易地用你收集的关于测试特征向量的实验来计算。

现在，这两项在贝叶斯规则中以比率的形式出现， P(g =1|y=1)/P(g =1|y=0) 。我们刚刚展示了这可以重写为 TPR/FPR。

有印象吗？你知道任何比较 TPR 和 FPR 的分类标准吗？具体来说，TPR/FPR 的比率越高，度量就越高？是的， AUC ！！这个非常常见的分类器的度量只是简单地描述了贝叶斯定理中的似然比！

计算 AUC 的 ROC 曲线示例( MartinThoma，CC0，通过 Wikimedia Commons )

后验概率

P(θ|O)/P( θ/O)是我们在观察事实 O ( 后验概率 )后对理论θ的确信程度(再次表示为赔率)。根据贝叶斯规则，它可以通过将先验概率乘以似然比来计算。

在我们的分类问题中，后验概率是 P(y=1|g=1)/P(y=0|g=1) 。

如果我们思考这个表达式的含义，我们会立即意识到分子 P(y=1|g=1) (当分类器预测时 X 真正属于第 1 类的概率)是分类器的精度！这是分类器的另一个流行的评估指标，通常被描述为 AUC 的替代。我们可以看到这两者是如何通过贝叶斯法则紧密联系在一起的。

顺便说一下，后验概率的分母 P(y=1|g=0) ，也是一个标准的分类指标——尽管在数据科学家中没有 precision 那么受欢迎——称为错误发现率。

分类器，重温

现在让我们欣赏贝叶斯框架给我们的关于分类器的新视角。为此，在这里重写贝叶斯规则是有用的，连同贝叶斯术语(公式的顶部)和相应的分类器概念(底部):

贝叶斯规则，分类器(底部)和贝叶斯术语(顶部)之间的对应关系(图片由作者提供)

我们发现 AUC(以及从中得出的 ROC 曲线)只不过是一种总结似然比的方法。如果我们再看看贝叶斯规则，我们认识到似然比是将先验信念转换为后验信念的乘法因子。因此AUC 真正量化的是使用分类器改变我们的先验概率的程度:如果乘法因子非常高或非常低，那么分类器的使用将显著改变我们关于 X 属于哪一类的信念，这是好的(AUC 将用接近 1 的值捕捉这一事实)；如果乘法因子反而接近 1，那么它对先验的影响将是可忽略的，我们的先验信念不会改变太多，并且分类器是无用的(并且 AUC 将接近 0.5)。

这使得 AUC(以及总体 ROC 曲线)成为评估分类器的一个很好的默认选项。它有一个很好的特性，就是作为一个关于分类器的度量标准，而不是其他任何东西——特别是，它不是关于数据集的(数据集的属性，比如类之间的比例，是由先前的概率捕获的)。

然而，AUC 和似然比没有捕捉到的是使用分类器后我们将得到的关于 X 的绝对置信度……毕竟，似然比只是告诉我们，由于使用了分类器，先验信念发生了多大程度的变化。但是有些情况下，即使一个非常强大的贝叶斯更新也不会改变太多，在实践中，你对理论的信心 θ …

例如，如果在使用分类器之前，您认为 X 非常非常不可能属于类别 1(假设θ的先验概率为 1/1，000，000)，那么即使使用强贝叶斯更新(假设可能性比为 100)也不会改变我们的情况(后验概率将为 100*1/1，000，000 = 1/10，000，这仍然是极小的概率)。正如我们所见，当目标样本严重失衡时，这些非常小的先验概率就会出现。

这就是精确度发挥作用的地方。当目标不平衡时，Precision 是更好的选择，因为在这种情况下，您希望在使用分类器后查看您的信念——也就是说，您希望查看后验概率。精度完全是 that⁴.

优秀的 AUC？在全押之前，你可能还是想检查一下你的后验概率(图片由 cottonbro 提供，来自 Pexels

后验概率(又名精度)的缺点是，因为它们考虑了似然比和先验概率，所以它们不仅仅是关于分类器的度量。相反，它们测量分类器的可靠性(似然比)和应用分类器的实际数据集(先验概率)之间的相互作用(实际上是乘积)。因此，尽管精度很有用，但它并不能告诉我们分类器本质上有多好，而且它会随着数据集的变化而变化(特别是，如果您在生产中获得的类的流行程度与训练集不同，它也会变化)。

不需要选择一个指标(如果你认为贝叶斯)

那么，哪个指标是最好的呢？像往常一样，没有明确的答案，这完全取决于你的特定问题和背景。标准的手册答案是，通常应该选择 ROC/AUC，除非目标严重失衡，在这种情况下，您希望使用 precision。

作为经验法则，这很好，但是我希望通过用贝叶斯术语来描述这个问题，你现在能够看到这个启发背后的原因。ROC/AUC 通常是一个很好的默认选择，因为可能性评估了分类器在分离两个类别时的内在性能，与类别 1 与类别 0 相比有多罕见的问题无关(编码在先前的优势中)。当目标不平衡时，Precision 是更好的选择，因为在这种情况下，即使是好的分类器也只能给我们很小的信心，在实践中，关于分类问题，你会意识到只看后验概率。

理想情况下，你希望看到两者的全貌。您既想知道分类器总体上有多好，又想知道它在实践中与数据集的交互有多好。如果你思考贝叶斯，你就能记住这两个方面，做出更好的决定。

[1]从技术上讲，AUC 是在分类器阈值的整个范围内总结 TPR/FPR 比率*，而在这个贝叶斯框架中，为了简单起见，我们保持阈值固定。*

[2]通常其形式是在分类器阈值的整个范围内取平均值，也称为平均精度。

[3]非常小的似然比实际上会转化为接近 0 而不是 1 的 AUC，但我们可以将这种情况视为以错误方式使用的良好分类器…

[4]通过贝叶斯框架，很明显整个“如果目标不平衡，不要使用 AUC”的建议只是为了避免基础利率谬误。

用自然语言处理对投诉进行分类

原文：https://towardsdatascience.com/classifying-complaints-with-natural-language-processing-e3b2765d525f?source=collection_archive---------21-----------------------

如何使用 NLP 模型对传入的消息进行排序

图片由作者提供，布鲁诺/德 / 皮克斯拜

消费者金融保护局 (CFPB)，一个 2011 年才开始运作的联邦机构，在金融领域照顾消费者的利益。作为这一使命的一部分，当消费者觉得自己受到了征信机构、银行、信用卡公司或其他金融服务提供商的不公正对待时，他们可以提出投诉。

这些投诉可供数据科学家下载，作为一个数据集，它们为构建自然语言处理(NLP)分类系统提供了一个很好的切入点。

我创建了一个模型来分析投诉，并将其分为五类。这种模型或类似的模型有许多实际用途。它可以用于简化组织的传入消息的路由和处理，并可以简化消费者的投诉提交过程。

类别

除了投诉的叙述和关于他们自己的信息，在线表格还要求消费者将他们提交的材料分为九个产品类别中的一个。我的数据集包括一年的提交内容，经过清理后有 16 万条叙述。出于我的目的，我最终将产品类别分为五类:

1. 信用报告
2. 收债
3. 信用卡(包括预付卡)
4. 抵押贷款(包括助学贷款、车贷等。)
5. 零售银行业务(包括储蓄和支票账户以及 Venmo 等在线服务)

对于大多数班级来说，特定的单词占主导地位。例如，该饼图显示术语“card”在信用卡类中出现 67.6%，但在抵押和贷款类中只出现 1.71%。

在我的探索性数据分析过程中，我还发现这些类是不平衡的。超过一半的提交属于信用报告类别，其他四个类别占提交的 8%到 14%。

阶级失衡

处理建模投诉

为了用数据训练一个机器学习模型，首先我必须把它转换成模型可以使用的形式。

1. 我把每个故事都符号化了。换句话说，我将叙述拆分成一个(小写)单个字符串的列表:[“my “、” bank “、” scammed “、” me”]。
2. 从标记中，我删除了任何带有数字、标点符号或奇怪符号的字符串，如“xxxx ”, CFPB 在匿名化数据时将这些符号用作占位符。
3. 我知道像“银行”和“信贷”这样的词可能对我的模型有用，而像“the”和“if”这样的词太常见了，没有什么帮助。所以，我去掉了这些所谓的停用词。
4. 在语言学中，一个引理是字典中的关键词；这就是为什么“购买”、“购买”和“已购买”都出现在购买条目下。我对叙述的符号进行了符号化，将单词简化为它们的关键概念。
5. 最后，我必须将单个令牌连接回更长的字符串，以便模型能够使用它们。

经过这些转换后，数据集中的第一个叙述现在以“采购订单日发货金额收到……”开始这种文本作为人类语言没有什么意义，但可以用于 NLP 模型。

建模管道

在建模之前，我必须再次通过矢量化来转换数据。换句话说，我使用工具给投诉语料库中的每个词分配一个数字频率。然后，我将语料库分为训练集(80%)和测试集(20%)。

我尝试了各种类型的模型，即多项朴素贝叶斯、随机森林、决策树、KNN、梯度推进和 XG 推进，或多或少使用了默认参数。我寻找那些有大量正确分类的文本，并且在训练集和测试集之间有相似结果的模型，这意味着模型不会过度拟合数据。

从我的前三个基线模型中，我试验了各种参数来改善结果。除了调整模型的参数，我还尝试了两种矢量化技术的不同参数，计数矢量化和 TF-IDF。

我的获胜者是一个计数矢量器，带有多项式朴素贝叶斯模型，这种组合将 86%的文本分类到正确的类别中。我使用了另一个模型，Gradient Boosting，它的性能与获胜的那个相差不远，来检查它发现的对投诉分类最重要的特征(在这种情况下是单词)。

为了再次检查我的管道，我从 CFPB 的 API 下载了 1000 个新提交的内容。我通过函数运行它们，以处理用于建模的投诉，对数据进行矢量化，并将其输入到训练好的模型中。我得到了类似的结果，模型对新投诉的正确分类率为 84%。本质上，一旦模型被训练，机构理论上可以使用它来实时分类收到的提交。

局限性和展望

我使用的数据的一个局限性是，产品类别是由消费者自己选择的。考虑到他们可能不太了解金融服务业务，他们可能选择了错误的类别。让 CFPB 的员工仔细检查记叙文的类别会很有趣，尤其是那些被模型错误分类的类别。

即使这些分类都是正确的，这 160，000 个故事仍然需要由人类来分类。尽管幸运的是，这些投诉被标记了产品类别，但是当文本没有被预先标记时，它可能是 NLP 建模的绊脚石。(见我的中帖可能解决这个问题。)

然而，我使用的过程可以被复制用于其他 NLP 分类任务，无论是将文本分类为问题、子主题还是情感。在有人可以选择将文本标记为我不知道的数据集中，数据科学家可以使用标记有确定内容的文本来重新处理我不知道。一般来说，NLP 技术非常有用和有效。

[ 项目的 GitHub 资源库

使用录音和 Python 对情绪进行分类

原文：https://towardsdatascience.com/classifying-emotions-using-audio-recordings-and-python-434e748a95eb?source=collection_archive---------5-----------------------

实践教程

声音和声学理论可以用于尖端的情感识别技术。下面是我们如何使用 Python 来应用它

在过去的几年中，情感识别技术已经被广泛应用于各种不同的应用中，并且在当今的行业中似乎变得更加流行。从心理学研究到客户需求的高级分析，这些技术的潜力似乎是无穷无尽的。然而，对于不具备音频帧和声波分析专家特权的普通数据科学家来说，这些方法仍然被认为是极其复杂和难以理解的。

在本文中，我们的目标是通过展示一个使用 python 和 Librosa 的情感识别分类器的例子，使这一过程尽可能地容易和简单——这是一个 python 包，使音频文件的分析变得非常简单和直接。我们将从理论和技术上解释这个过程的每一步。

首先，为了理解如何创建一个处理音频声音并理解其内在含义的算法，我们首先需要理解人类大脑是如何做完全相同的事情的。

声波等等

我们要讲的第一个术语是声波。声音可以定义为通过弹性材料介质(如空气)传播的机械扰动。它以纵波形式传播(因此称为“声波”)，由交替的压缩和稀疏，或者高压区域和低压区域组成，以一定的速度移动。我们的身体能够产生声波的方式源于我们的声门脉冲，当我们说话时，声门脉冲操纵我们的声带。这显然对产生声音非常有帮助，但不足以真正理解它们，更不用说相互交流了。为了实现这一点，我们有自己的声道。

声道是一个描述我们口腔和咽喉中不同器官系统的术语，包括鼻腔、舌尖、牙齿、软腭等等。这个系统的目标是作为我们声门脉冲的过滤器，以某种方式理解我们产生的不同声音。为了让事情变得简单，我们可以说我们的语言是我们使用声道对我们的声门脉冲进行不同运动和操作的结果。稍后，我们将更多地讨论分析这些声波的方法，但现在，在我们深入这项任务的更务实部分时，让我们记住这些细节。

我们的数据集——探索声波

为了创建这个算法，我们结合了三个不同的数据集，其中包括语音记录和它们各自的标签——快乐、悲伤、愤怒、平静等。我们使用的数据集是拉夫德斯、苔丝和 SAVEE 。由于最终的数据集似乎在某些特征上非常不平衡(例如，我们的男性记录比女性记录少得多，与“消极”情绪相比，“积极”情绪的数量相对较少)，我们决定首先从简化的模型开始——对男性和女性进行 3 个不同类别的分类(总共 6 个不同类别【1】):

mydf.head()

我们的数据集

mydf.info()

使用我们之前提到的 Librosa，我们成功绘制了一个声波的原始显示:

ind = np.random.randint(0,len(mydf))
data, sampling_rate = librosa.load(mydf['path'][ind], sr=44100)
emotion = mydf['emotion2'][ind]plt.title(f'Sound wave of- {emotion}')
librosa.display.waveplot(data, sampling_rate)
plt.show()

声波表示

然后，我们在时间-频率域中显示相同的信号，以便我们可以检查信号随时间变化的不同频率和幅度。这是通过对我们的数据执行傅立叶变换来实现的:

D = np.abs(librosa.stft(data))
librosa.display.specshow(D, sr=sampling_rate, x_axis='time', y_axis='linear');
plt.colorbar()
plt.show()

光谱的线性表示

上面的图显示了我们的频率随时间变化的线性表示，似乎没有给我们太多有价值的信息。原因是人类只能听到集中在非常小的频率和振幅范围内的声音(例如，不像狗)。为了解决这个问题，我们对频率和振幅都应用了对数标度。请注意，对数据应用对数标度后，我们不再以幅度为单位测量信号，而是以分贝为单位。

DB = librosa.amplitude_to_db(D, ref=np.max)
librosa.display.specshow(DB, sr=sampling_rate, x_axis='time', y_axis='log');
plt.colorbar(format='%+2.0f db')
plt.show()

声谱图

这个结果提供了更多的信息，因为我们可以看到不同频率的分贝数随时间的变化。这种表示的正式术语叫做声谱图。由于声谱图能够近似人类对声音的感知，因此声谱图本身也被证明在情绪分类方面非常有用。

深入声波中

既然我们已经了解了声谱图，让我们考虑一下声波的频谱；也就是说，在我们给定的时间范围内，分贝与频率的关系如下:

plt.magnitude_spectrum(data, scale='dB')
plt.show()

对数标度谱

对数标度谱是通过对我们的数据应用傅立叶变换，然后对结果进行对数标度变换而获得的。频谱图和对数标度频谱都是通过类似的数学运算实现的，它们之间的区别在于，前者显示的是频率和分贝随时间的变化，而后者显示的是分贝和频率之间的关系。一个细微但重要的区别。

回到我们对语音的定义，我们可以说我们的对数标度频谱是语音本身的非常准确的表示。正如我们前面提到的，语言可以被描述为声道和声门脉冲的结合。为了有效地分析我们的语音，我们需要从没有附加噪声的语音中提取声道，声道类似于滤波器，包含关于声音含义的完整信息。为了简化事情，我们需要从没有声门脉冲的语音中提取声道。

现在让我们考虑对数标度频谱的更平滑版本——频谱包络:

光谱包络

上面的图类似于我们的对数标度谱的主要和最重要的部分——我们可以检查主要的周期性、最大值点(用红色标记)以及总体趋势。这个频谱包络相当于我们所认为的声道，其最大值点称为“共振峰”。这些波峰包含了声音的主要“身份”,被认为是我们声波中最重要的部分。研究表明，我们的大脑可以通过共振峰来识别大部分讲话的意思。

MFCC 是这次任务的目标

既然我们认识到了我们的声道，我们需要找到一种方法从我们的讲话中提取它。为此，我们需要再进行一些数学运算。首先，我们需要将对数标度频谱转换为 Mel 标度【2】，然后对数据执行离散余弦变换。最后一个变换与我们之前使用的傅立叶变换相对相似，因为它也从我们当前的状态创建了一个光谱。所以基本上，我们在这里做的是在之前的光谱上创建一个光谱。我们的新频谱现在被称为倒谱，而我们的新频率被称为倒频。所有这些混乱的原因很简单——使用我们新的倒谱和倒频，我们可以很容易地区分我们的频谱包络(声道)和噪音(声门脉冲)。不仅如此，离散余弦变换已经产生了这个倒谱的主要和最重要的系数——梅尔频率倒谱系数，也称为 MFCC 系数！

幸运的是，Librosa 让这项工作变得非常简单，我们可以用一行简单的代码提取 MFCC 氏症，我们很快就会看到。

数据准备

要使用 MFCC 作为我们的特征，我们首先需要他们在一个同质的形状。由于我们的每一个信号波的长度都略有不同，这个过程也会导致 MFCC 波的长度不同，这对于为我们的数据创建模型没有太大的帮助。因此，我们首先使所有信号波的长度相同——比平均值短的信号被填充(使用中值)，比平均值长的信号被截断(我们还事先去掉了极端长度的信号)。

然后，我们很容易地从每个信号波形中提取出 MFCC。我们从每个信号波中提取 20 个不同的系数，每个系数包含一个给定长度的向量。注意——传统的 MFCC 数通常是 12-13，Librosa 函数的默认值是 20。第一个系数通常是携带关于语音的大多数重要信息的系数，因此在大多数情况下，使用大量的 MFCC 不会改进模型。

mfccs = []
for i in tqdm(X):
    mfcc = librosa.feature.mfcc(y=i, sr=44000, n_mfcc=20)
    mfcc = mfcc.T
    mfccs.append(mfcc)

正如我们所见，每个样本包括 20 个长度为 236 的 MFCC，每个长度为【3】。在此过程中，我们还丢弃了 3 个异常值。现在，我们终于为建模做好了准备。

建模

众所周知，RNN 网络非常适合语音识别任务。然而，有大量的研究证明，在很多情况下，CNN 网络可以胜过 RNN 网络。在这种情况下，我们决定使用 1 维卷积层和 1 维池层来构建 CNN 网络(因为我们的训练数据由 3 维组成)。

我们的 CNN 网络由两个模块组成，每个模块由 1 维卷积层、激活函数(“ReLu”)、1 维池层和 dropout 构成。这两个模块之后是两个完全连接的密集层和一个“SoftMax”激活功能，因为我们正在处理一个多类问题:

model = Sequential()model.add(layers.Conv1D(256, 5,padding='same',
                 input_shape=(236,40)))
model.add(layers.Activation('relu'))
model.add(layers.MaxPooling1D(pool_size=(8)))
model.add(layers.Dropout(0.2))model.add(layers.Conv1D(128, 5,padding='same'))
model.add(layers.Activation('relu'))
model.add(layers.MaxPooling1D(pool_size=(4)))
model.add(layers.Dropout(0.1))model.add(layers.Flatten())
model.add(layers.Dense(64))
model.add(layers.Dense(7))
model.add(layers.Activation('softmax'))

我们设法达到了相对较好的结果，达到了 90%的准确率。正如所料，男性录音的分数明显低于女性，因为我们的数据集中男性样本少得多:

我们第一个分类模型的指标

之后，我们瞄准了一个更复杂的模型——对不同的情绪进行分类:“恐惧”、“惊讶”、“悲伤”、“厌恶”、“快乐”、“愤怒”和“中性”【4】。样本的分布比前一次更平衡，所以我们期望这次的分类更平衡。

不同情绪的分布——我们第二个分类模型的目标

我们对数据进行了与之前相同的处理，并运行了完全相同的模型。这些是我们得到的结果:

我们第二个分类模型的指标

正如所料，这种分类看起来相对平衡，结果也相当不错。我们还可以观察混淆矩阵，它表明我们的绝大多数样本被正确分类:

有趣的是，有相当多被预测为‘中性’的样本结果是‘悲伤’(1.5%)。这也许可以用声音表达悲伤时的微妙特征来解释，这些特征很可能被误认为与中性情绪有关。

然后，我们想进一步检查这些类之间的关系，所以我们使用 PCA 和 KMeans 聚类进行降维，将数据分为 7 个聚类。我们的希望是找到 7 个独特的群体来对应我们的 7 种情绪。我们通过检查分类标签和类别预测之间的相关性并查看与不同标签相关的类别分布，来检查分类标签和类别预测之间的关系。最终我们得出了这个散点图:

我们可以清楚地检查 7 个不同的集群。我们注意到的第一件事是“愤怒”似乎相对独立于其他情绪。“中性”似乎位于中间，这当然是有意义的，而且它和“悲伤”之间也有一些接近，这可以解释我们之前关于两者之间联系的假设。“厌恶”也接近于“悲伤”，而“快乐”接近于“惊讶”——两者似乎都很直观。解释“恐惧”的位置有点困难，因为它最近的邻居是“快乐”，这没什么意义。在这种情况下，I t 与“惊喜”的接近似乎更直观。

总的来说，这些结果证明了即使使用一个简单的 CNN 网络，我们也可以以很高的可信度从音频记录中对情绪进行分类，甚至检查它们之间的关系。

最后的话

音频分类之所以如此有趣，是因为复杂的理论可以用普通的实用方法来表达。数学程序可以用来成功地实现这些概念的方式是不可思议的。幸运的是，大部分艰苦的工作都是由预制工具完成的。然而，了解这些工具背后的理论概念仍然是成功构建和使用这些模型的关键。

我们希望这篇文章有助于阐明这个迷人的主题，使它更容易理解，也希望更有用。

欲了解更多信息，请点击查看我们的项目。

参考

-https://www . Microsoft . com/en-us/research/WP-content/uploads/2016/02/CNN _ aslptrans 2-14 . pdf

-https://www . izotope . com/en/learn/understanding-spectrograms . html

——【https://arxiv.org/pdf/2007.11154.pdf

-https://arxiv.org/pdf/2012.14781.pdf

——https://saurabhgarg1996.github.io/files/6.pdf

-https://www.youtube.com/watch?v=4_SH2nfbQZ8&t = 1357s

• http://www . socsci . UCI . edu/~ JSP rouse/courses/S12/155/lectures/lectures 4
• https://librosa.org/doc/latest/index.html

【1】数据框中的列“情绪 2”是我们的第一个目标，列“情绪 3”是我们的第二个目标。本文稍后将对这两种方法进行更详细的描述。

【2】一种以更真实的方式模拟人类声谱的音阶，因为人耳无法轻易识别高于 500Hz 的频率变化。

【3】为了简单起见，我们调换了 MFCC 的形状。

注意，为了达到平衡的分类，我们使用了具有更多样本的情感。

使用多层感知器分类器(MLP)对手写数字进行分类

原文：https://towardsdatascience.com/classifying-handwritten-digits-using-a-multilayer-perceptron-classifier-mlp-bc8453655880?source=collection_archive---------10-----------------------

什么是多层感知器？MLP 的利与弊是什么？我们能用 MLP 分类器准确地分类手写数字吗？学来的重量是什么样的？

图 1:一个多层感知器网络(来源)。

1.简短介绍

1.1 什么是多层感知器(MLP)？

一个 MLP 是一个监督机器学习(ML)算法，属于前馈人工神经网络类[1]。该算法本质上是对数据进行训练，以便学习一个函数。给定一组特征和目标变量(例如标签)，它学习用于分类或回归的非线性函数。在本文中，我们将只关注分类的情况。

1.2 MLP 和逻辑回归之间有什么相似之处吗？

有！逻辑回归只有两层，即输入和输出，然而，在 MLP 模型的情况下，唯一的区别是我们可以有额外的中间非线性层。这些被称为隐藏层。除了输入节点(属于输入层的节点)，每个节点都是一个使用非线性 激活 函数【1】的神经元。由于这种非线性性质，MLP 可以学习复杂的非线性函数，从而区分不可线性分离的数据！参见下面的图 2 中带有一个隐藏层的 MLP 分类器的可视化表示。

如果你想在交互式路线图和活跃的学习社区的支持下自学数据科学，看看这个资源:https://aigents.co/learn

1.3 如何训练 MLP？

MLP 使用反向传播进行训练【1】。你可以看看这个网站这里的正式数学公式。

1.4 Main 的主要优势和劣势

优点

• 可以学习非线性函数从而分离不可线性分离的数据【2】。

缺点

• 隐藏层的损失函数导致一个非 - 凸优化问题，因此存在局部最小值。
• 由于上述问题，不同的权重初始化可能导致不同的输出/权重/结果。
• MLP 有一些超参数，例如隐藏神经元的数量，需要调整的层数(时间&功耗)[2]。
• MLP 可以是敏感的特征缩放【2】。

图 2:带有一个隐藏层和一个标量输出的 MLP。图片改编自 scikit-learn python 文档。

2.使用 scikit-learn 的 Python 实践示例

2.1 数据集

对于这个动手操作的例子，我们将使用 MNIST 数据集。MNIST 数据库是著名的手写数字数据库，用于训练几个 ML 模型[5]。有 10 个不同数字的手写图像，因此类别数为10(参见图 3 )。

注:由于我们处理的是图像，这些用2D数组表示，数据的初始维数是每幅图像的**28** by **28**(28x28 pixels)。然后，2D 图像被 展平 ，并因此在最后由矢量表示。每个 2D 图像被转换成一个尺寸为[1, 28x28] = **[1, 784]**的 1D 向量。最后，我们的数据集有***784*** 特征/变量/列。

图 3:来自数据集的一些样本(来源)。

2.2 数据导入和准备

import matplotlib.pyplot as plt
from sklearn.datasets import fetch_openml
from sklearn.neural_network import MLPClassifier

# Load data
X, y = fetch_openml("mnist_784", version=1, return_X_y=True)# Normalize intensity of images to make it in the range [0,1] since 255 is the max (white).
X = X / 255.0

记住每个 2D 图像现在被转换成一个 1D 向量与维度[1, 28x28] = **[1, 784]** **。**现在我们来验证一下这个。

print(X.shape)

这返回:**(70000, 784)** 。我们有 70k 的展平图像(样本)，每个包含 784 个像素(28*28=784)(变量/特征)。这样，输入 层 权重 矩阵将具有形状784 x #neurons_in_1st_hidden_layer.输出层权重矩阵将具有形状 #neurons_in_3rd_hidden_layer x #number_of_classes.

2.3 模型培训

现在让我们建立模型，训练它并执行分类。我们将使用3隐藏层，每个层分别带有50,20 and 10神经元。此外，我们将最大迭代次数设置为100，学习率设置为0.1。这些就是我在介绍中提到的超参数。我们不会在这里对它们进行微调。

# Split the data into train/test sets
X_train, X_test = X[:60000], X[60000:]
y_train, y_test = y[:60000], y[60000:]

classifier = [MLPClassifier](https://scikit-learn.org/stable/modules/generated/sklearn.neural_network.MLPClassifier.html#sklearn.neural_network.MLPClassifier)(
    hidden_layer_sizes=(50,20,10),
    max_iter=100,
    alpha=1e-4,
    solver="sgd",
    verbose=10,
    random_state=1,
    learning_rate_init=0.1,
)# fit the model on the training data
classifier.fit(X_train, y_train)

2.4 模型评估

现在，让我们来评估这个模型。我们将估计训练和测试数据和标签的平均准确度。

print("Training set score: %f" % classifier.score(X_train, y_train))
print("Test set score: %f" % classifier.score(X_test, y_test))

训练集得分:0.998633
测试集得分:0.970300

伟大的成果！

2.5 可视化成本函数演变

训练中损失减少的速度有多快？我们来编一个好看的剧情吧！

fig, axes = plt.subplots(1, 1)axes.plot(classifier.loss_curve_, 'o-')
axes.set_xlabel("number of iteration")
axes.set_ylabel("loss")
plt.show()

图 4:训练迭代中损失的演变。图由作者制作。

在这里，我们看到损失在训练期间下降得非常快，并且在40th迭代之后饱和(记得我们将最大 100 次迭代定义为超参数)。

2.6 可视化学习到的重量

这里，我们首先需要了解权重(每层的学习模型参数)是如何存储的。

根据文档，属性classifier.coefs_是权重数组的形状(n_layers-1, )列表，其中索引 I 处的权重矩阵表示层i和层i+1之间的权重。在这个例子中，我们定义了 3 个隐藏层，我们还有输入层和**输出层。**因此，我们期望层间权重有 4 个权重数组(图 5 中的in-L1, L1-L2, L2-L3 和 L2-out)。

类似地，classifier.intercepts_是偏置向量的列表，其中索引i处的向量表示添加到层i+1的偏置值。

图 5:作者在 Notes (iOS)上的手工图。

让我们验证一下:

len(classifier.intercepts_) == len(classifier.coefs_) == 4

正确返回True。

提醒:输入 层 权重 矩阵将具有形状784 x #neurons_in_1st_hidden_layer.输出层权重矩阵将具有形状 #neurons_in_3rd_hidden_layer x #number_of_classes.

可视化输入层的学习权重

target_layer = 0 #0 is input, 1 is 1st hidden etcfig, axes = plt.subplots(1, 1, figsize=(15,6))
axes.imshow(np.transpose(classifier.coefs_[target_layer]), cmap=plt.get_cmap("gray"), aspect="auto")axes.set_xlabel(f"number of neurons in {target_layer}")
axes.set_ylabel("neurons in output layer")
plt.show()

图 6:输入和第一个隐藏层之间的神经元的学习权重的可视化。图由作者制作。

或者把它们重新塑造成 2D 的形象。

# choose layer to plot
target_layer = 0 #0 is input, 1 is 1st hidden etcfig, axes = [plt.subplots](https://matplotlib.org/api/_as_gen/matplotlib.pyplot.subplots.html#matplotlib.pyplot.subplots)(4, 4)
vmin, vmax = classifier.coefs_[0].min(), classifier.coefs_[target_layer].max()for coef, ax in zip(classifier.coefs_[0].T, axes.ravel()):
    ax.matshow(coef.reshape(28, 28), cmap=plt.cm.gray, vmin=0.5 * vmin, vmax=0.5 * vmax)
    ax.set_xticks(())
    ax.set_yticks(())
[plt.show](https://matplotlib.org/api/_as_gen/matplotlib.pyplot.show.html#matplotlib.pyplot.show)()

3.摘要

MLP 分类器是一个非常强大的神经网络模型，能够学习复杂数据的非线性函数。该方法使用前向传播来构建权重，然后计算损失。接下来，使用反向传播来更新权重，从而减少损失。这是以迭代的方式完成的， 迭代的号 是一个输入超参数**，如我在介绍中所解释的。其他重要的超参数是每个隐层中** 神经元的数量 和总共的隐层数量**。这些都需要微调。**

那都是乡亲们！希望你喜欢这篇文章！

只需 5 秒钟就可以订阅我的邮件列表:https://seralouk.medium.com/subscribe

敬请关注并支持这一努力

如果你喜欢并发现这篇文章有用，请关注我！

有问题吗？把它们作为评论贴出来，我会尽快回复。

最新帖子

https://medium.com/mlearning-ai/how-to-use-python-sql-to-manipulate-data-in-1-min-bbf9ec17dc5d

参考

[1]https://en.wikipedia.org/wiki/Multilayer_perceptron

[2]https://sci kit-learn . org/stable/modules/neural _ networks _ supervised . html # MLP-tips

[3]https://scikit-learn . org/stable/modules/neural _ networks _ supervised . html # mathematical-formulation

https://en.wikipedia.org/wiki/Backpropagation

https://en.wikipedia.org/wiki/MNIST_database

和我联系

• 邮件列表:https://seralouk.medium.com/subscribe
• 领英:https://www.linkedin.com/in/serafeim-loukas/
• 研究之门:https://www.researchgate.net/profile/Serafeim_Loukas

使用 PCA +深度学习对 MNIST 数字进行分类

原文：https://towardsdatascience.com/classifying-mnist-digits-using-pca-deep-learning-852aeaff48a5?source=collection_archive---------15-----------------------

用 PCA 对 MNIST 数据进行预处理，建立更高效的 CNN 模型

由尼克·希利尔在 Unsplash 上拍摄

什么是主成分分析？

数据科学中的许多重要概念之一包括主成分分析(PCA)，这是一种无监督的学习方法。它通常被用作大型数据集的降维方法或简化其复杂性，这是通过将一组大型变量转换为一组小型变量，同时保留数据集中的大部分变量来实现的。PCA 通过将数据几何投影到更低的维度上来减少数据，这些维度又被称为主成分(PC)。该方法的目标是通过使用最少的主成分找到我们数据的最佳摘要，通过选择我们的主成分，我们最小化原始数据与其在主成分上的投影值之间的距离。

什么是深度学习？

深度学习是机器学习的一个子集，受人脑结构的启发。深度学习算法试图通过不断分析具有给定逻辑结构的数据，得出与人类相似的结论。为了实现这一点，深度学习使用了一种多层结构的算法，称为神经网络。无论是 Alexa、Siri 还是 Cortana，深度学习都有助于他们理解语音和语言。深度学习使用不同类型的神经网络架构，如对象识别、图像和声音分类以及针对不同类型问题的对象检测。深度学习算法训练的数据越多，它就越准确。

MNIST 数据集

MNIST 数据集(修改后的国家标准与技术研究所数据库)是深度学习爱好者中更受欢迎的数据集之一。该数据集包含 42，000 个带标签的灰度图像(28 x 28 像素),这些图像是训练集中从 0 到 9 的手写数字，以及 28，000 个未带标签的测试图像。

在这篇博客中，我将演示如何使用 PCA 建立 CNN 模型来识别 MNIST 数据集中的手写数字，以实现高精度。

要遵循的步骤

1. **导入库并加载数据集:**导入必要的库、包和 MNIST 数据集
2. 数据预处理
3. PCA 实施
4. 创建 CNN 模型
5. 训练和评估模型

1.导入库并加载数据集

我们首先导入训练数据所需的所有必要的库，然后加载我们的 MNIST 数据集，可以在这里找到—您也可以使用 keras.datasets 来导入 mnist 数据集！

# Import Libraries
%matplotlib inline
import pandas as pd
from sklearn.decomposition import PCA
import numpy as np
import matplotlib.pyplot as plt
from sklearn.preprocessing import StandardScaler
from keras.utils.np_utils import to_categorical
from sklearn.preprocessing import LabelEncoderfrom tensorflow.keras.layers import Input,InputLayer, Dense, Activation, ZeroPadding2D, BatchNormalization, Flatten, Conv2D
from tensorflow.keras.layers import AveragePooling2D, MaxPooling2D, Dropout
from tensorflow.keras.models import Sequential,Model
from tensorflow.keras.optimizers import SGD
from tensorflow.keras.callbacks import ModelCheckpoint,LearningRateScheduler
import keras
from tensorflow.keras import backend as K
from sklearn.preprocessing import StandardScaler
from scipy.linalg import eigh# Load the Dataset
train = pd.read_csv("data/train.csv")
test = pd.read_csv("data/test.csv")
train.head()

作者图片

数据集的样本图像:

作者图片

2.预处理数据

首先，我们将数据集分成训练集和测试集

y_train = train['label']
X_train = train.drop(['label'], axis=1)
X_test = test
X_train.shape, y_train.shape, X_test.shape#Output
((42000, 784), (42000,), (28000, 784))X_train = X_train/255
X_test = X_test/255

注意，我们没有 y_test，因为测试集的标签没有给出。接下来，我们将标准化数据，这在 PCA 实施中很重要，因为它将原始数据投影到最大化方差的方向上。

3.PCA 实施

现在，我们将对我们的数据实施 PCA。首先，我们将标准化我们的数据，并计算我们的协方差矩阵。协方差可以认为是变量之间线性关系的方向。协方差矩阵是降维的第一步，因为它给出了强相关特征数量的概念，并且它通常是降维的第一步，因为它给出了强相关特征数量的概念，以便可以丢弃那些特征。

standardized_scalar = StandardScaler()
standardized_data = standardized_scalar.fit_transform(X_train)
standardized_data.shape# Output
(42000, 784)cov_matrix = np.matmul(standardized_data.T, standardized_data)
cov_matrix.shape# Output
(784,784)

接下来，我们将计算特征值和特征向量。协方差矩阵(或相关性)的特征向量和特征值描述了 PCA 的来源。特征向量(主成分)决定新属性空间的方向，特征值决定其大小。

# Calculate eigenvalues and eigenvectors
lambdas, vectors = eigh(cov_matrix, eigvals=(782, 783))
vectors.shape# Output
(784,2)vectors = vectors.T
vectors.shape
# (2, 784)

然后，我们将计算单位向量和它的新坐标。单位向量是大小为 1 的向量，我们试图找到使方差最大化的单位向量。

new_coordinates = np.matmul(vectors, standardized_data.T)
print(new_coordinates.shape)
new_coordinates = np.vstack((new_coordinates, y_train)).T# Output
(2, 42000)df_new = pd.DataFrame(new_coordinates, columns=["f1", "f2", "labels"])
df_new.head()

作者图片

让我们来看一下跨多个组件(784)保留的累积方差的可视化:

作者图片

4.创建 CNN 模型

在构建 CNN 模型之前，我们需要采取一些预处理步骤。这包括将训练集转换为一个数组，对输入数据进行整形以使其符合模型预期的形状，以及对图像标签进行编码。

X_train = np.array(X_train)
y_train = np.array(y_train)X_train = X_train.reshape(X_train.shape[0], 28, 28, 1)
print(X_train.shape, y_train.shape)# Output
(42000, 28, 28, 1) (42000,)nclasses = y_train.max() - y_train.min() + 1
y_train = to_categorical(y_train, num_classes = nclasses)
print("Shape of ytrain after encoding: ", y_train.shape)# Output
Shape of ytrain after encoding:  (42000, 10)

现在我们可以建立我们的 CNN 模型，我建立了一个 2D CNN 模型，有 3 层和 1 个完全连接的层。

input_shape = (28,28,1)
X_input = Input(input_shape)# layer 1
x = Conv2D(64,(3,3),strides=(1,1),name='layer_conv1',padding='same')(X_input)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = MaxPooling2D((2,2),name='maxPool1')(x)
# layer 2
x = Conv2D(32,(3,3),strides=(1,1),name='layer_conv2',padding='same')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = MaxPooling2D((2,2),name='maxPool2')(x)
# layer 3
x = Conv2D(32,(3,3),strides=(1,1),name='conv3',padding='same')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = MaxPooling2D((2,2), name='maxPool3')(x)
# fc
x = Flatten()(x)
x = Dense(64,activation ='relu',name='fc0')(x)
x = Dropout(0.25)(x)
x = Dense(32,activation ='relu',name='fc1')(x)
x = Dropout(0.25)(x)
x = Dense(10,activation ='softmax',name='fc2')(x)conv_model = Model(inputs=X_input, outputs=x, name='Predict')
conv_model.summary()

经过 40 个纪元，我们达到了 99.8%的准确率！

作者图片

摘要

从这篇文章中，我们使用神经网络对手写数字进行分类，并使用 PCA 对数据进行预处理。有关五氯苯甲醚及其用途的更多信息，请参见以下有用的文章。感谢您的阅读，所有代码都在我的 Github 上！😃

https://medium.com/towards-artificial-intelligence/principal-component-analysis-pca-with-python-examples-tutorial-67a917bae9aa https://medium.com/analytics-vidhya/a-deep-dive-into-principal-component-analysis-pca-4e8a6d5a6386

用神经网络对卫星图像中的船舶进行分类

原文：https://towardsdatascience.com/classifying-ships-in-satellite-imagery-with-neural-networks-944024879651?source=collection_archive---------22-----------------------

如何从零开始训练 CNN 的一课

内特·切尼在 Unsplash 上的照片

没有什么比谷歌地图更能说明卫星图像的无处不在。一项完全免费的服务为任何人提供互联网接入，获取整个地球的卫星图像。虽然谷歌地图是免费的，但也存在其他付费的替代品，它们可以更频繁地为商业用途拍摄地球表面的照片。世界各国政府也将其卫星用于许多国内用途。

由于卫星图像的可用性超过了人类手动浏览它们的能力，因此必须开发一种对它们进行分类的自动化方法。图像分类是计算机视觉中的一个基本问题，神经网络提供了一个有趣的解决方案。

对海湾中的船只进行分类

卫星图像数据集中的船只包含 4000 张船只和非船只的注释图像。取自星球 API 的 1000 张飞船图像统一为 80px x 80px，包含一艘处于不同方位的飞船，但总是在中心附近。

取自数据集的示例。CC-BY-SA 许可下的所有图像。

在 3000 幅非船只图像中，大约 1000 幅描绘了随机特征，如海洋或建筑物，大约 1000 幅描绘了船只的部分但不完整的图像，最后 1000 幅描绘了被其他机器学习模型错误标记的图像。

取自数据集的示例。CC-BY-SA 许可下的所有图像。

附带的 JSON 文件包括图像的 ID 和图像是否包含船只的标记，相应地用 1 或 0 表示。此外，它还包含每个图像的实际像素值。

排列为 19，200 个整数值，前三分之一包含红色通道中的所有像素值，接下来是绿色通道中的像素值，最后三分之一包含蓝色通道中的像素值。由于像素值是在数据集中明确说明的，实际的图像本身在技术上不需要下载，但它们是一个很好的参考。

为了对这些图像进行分类，将训练一个卷积神经网络(CNN)。作为一种人工神经网络，CNN 模仿大脑中的神经元，特别是那些用于视觉的神经元。网络中的每个神经元都开发了一个独特的特征图，可以识别图像中的特征。在浅层网络中，要素地图可能会识别垂直线或水平线。但是，随着图层被添加到网络中，要素地图可能会识别更复杂的结构，例如眼睛，或者在本例中是船只。

存在各种库来编写 CNN，但是本教程将使用 Keras 来介绍 TensorFlow。

Python 中的卷积神经网络

import tensorflow as tf
import pandas as pd
import numpy as np

在训练任何东西之前，使用基本导入。TensorFlow 是一个机器学习库，主要关注神经网络。Pandas 是一个电子表格类型的库，用于帮助解析数据。最后，NumPy 有助于快速有效地处理数字。

# Read the data
df = pd.read_json("shipsnet.json")

这一行只是导入 JSON 文件，并将其作为数据帧读取。

# Normalize and reshape the image data
df["normalized_data"] = df["data"].apply(lambda x: (np.array(x) / 255).reshape(80, 80, 3))

像素值存储在标题为“数据”的数据框的列中事实上，这些像素值还不能被 CNN 处理。相反，新数据被转换成一个 NumPy 数组，然后除以 255 来对值进行规范化。所有 19，200 个值现在应该是介于 0 和 1 之间的某个值。接下来，数据被整形为 80 x 80 x 3 的矩阵，这样它就被格式化为一张图片。

# Define X and Y
X = df["normalized_data"]
Y = df["labels"]# Split the data into training and testing sets. Use a 75/25 split
from sklearn.model_selection import train_test_split
(X_train, X_test, Y_train, Y_test) = train_test_split(X, Y, test_size=0.25, random_state=42)

定义了 X 和 Y 值。y 是标题为“标签”的列，包含 1 和 0 的数组，以定义图像是否包含船。X 是从像素值中提取的归一化图像数据。

定义了 X 和 Y 后，它们被分成 75/25 的训练集和测试集。因此，该模型将在 3000 幅图像上进行训练，并在 1000 幅其他图像上验证其结果。

# Transform the training and testing data into arrays
X_train = np.array([x for x in X_train])
X_test = np.array([x for x in X_test])
Y_train = np.array([y for y in Y_train])
Y_test = np.array([y for y in Y_test])

不幸的是，TensorFlow 不接受 Pandas 系列，因此训练和测试数据被转换为数组。

from tensorflow.keras import datasets, layers, models
from tensorflow.keras.layers import Activation# Starts the model with a sequential ANN
model = models.Sequential()

经过几次导入，真正的 CNN 已经准备好了。CNN 被初始化为一个序列模型%2C%20layers.)，它确保每一层接收一个输入和一个输出。

# Adds the first convulsion layer and follows up with max pooling
model.add(layers.Conv2D(32, (3, 3), activation='relu', input_shape=(80, 80, 3)))
model.add(layers.MaxPooling2D((2, 2)))

前两层被添加到模型中。第一层是卷积层，其使用“ ReLu ”激活函数，并期望 80×80×3 的输入张量，即训练图像的精确尺寸。32 表示图层输出的维度，而(3，3)表示卷积窗口的大小，在本例中为 3px x 3px。

添加的下一层用于最大池化，其池大小为 2 x 2。

# Add additional hidden layers
model.add(layers.Conv2D(64, (3, 3), activation='relu'))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(64, (3, 3), activation='relu'))

与前面的代码非常相似，这两行代码是网络的附加隐藏层。虽然输出大小发生了变化，但这些层遵循与前两层相同的基本模式。

# Flattens the input into a 1D tensor
model.add(layers.Flatten())# Makes the input more readable for classification
model.add(layers.Dense(64, activation='relu'))# Classifies - ensure the input in the number of classes, indexed
# at 0
model.add(layers.Dense(1))# Final activation function
model.add(Activation('sigmoid'))

第一行简单地将张量展平为一维，这将使处理更容易。下一行，第一个密集层，格式化结果输入。

下一个密集层与分类有关。因此，传递的唯一参数是类的数量，索引为 0。因为在这个例子中有两个类，ship 或者 not-ship，所以传递 1。

最后，添加一个激活层，告知是否激活神经元。

model.summary()

在继续下一步之前，花点时间用总结的方法回顾一下模型。输出应该如下所示:

模型总结。图由作者制作。

请注意每一行是如何描述 CNN 内置的一个层的，以及它的输出形状和参数数量。

# Compile the model
# Use binary_crossentropy because there are only 2 classes present
model.compile(loss='binary_crossentropy', optimizer='rmsprop', metrics=['accuracy'])

这一行只是编译模型。如果添加图层时存在输入/输出维度问题，程序会在这一步通知您。

损失函数采用二元交叉熵，因为该模型仅使用两个类别。使用更多的类将需要一些不同的东西。损失函数的完整列表可在这里查看。优化器被当作 RMS prop 算法，但是其他的也是可用的这里。度量参数只是查看需要优化的内容，在本例中就是准确性。

# Train the model
gen_model = model.fit(X_train, Y_train, epochs=10, validation_data=(X_test, Y_test))

终于到了拟合模型的时候了。传递训练和测试数据非常简单。epochs 参数本质上是告诉模型要经历多少次迭代。

设定时代的回报边际递减。数字越大，通常精度越高，但是精度的每一次提高都会降低，直到接近数据集能够产生的最大精度。此外，更多的纪元将需要更长的时间来运行。对于这个数据集，10 将返回好的结果。

当模型训练时，每个历元的输出如下所示:

为模型定型的输出。作者制作的图

在返回样本数并给出训练历元的时间后，该行还将返回其自己的训练图像集的模型的损失和准确性，以及其验证集的损失和准确性。

在这种情况下，在第 10 个时期，该模型在其自己的训练图像上实现了 99.27%的准确性，在该模型从未见过的图像上实现了 98.5%的准确性。

估价

在过度庆祝之前，应该对结果进行更深入的分析。

# Evaluate the model
from sklearn.metrics import classification_report, confusion_matrix
predictions = model.predict(X_test)
print(classification_report(Y_test, predictions.round()))
print(confusion_matrix(Y_test, predictions.round()))

这些行导入一些函数来帮助评估模型的准确性，将模型应用到测试数据，并打印分类报告和混淆矩阵。

分类报告:

模型的分类报告。图由作者制作。

测试数据由 1000 幅图像组成，其中 733 幅是非舰船，267 幅是舰船。非船舶的精度为 99%，略高于船舶的精度 97%。本质上，对于所有被模型归类为船只的图像，97%都是真实的船只。该模型能够分别回忆起 99%的非船只图像和 98%的非船只图像。

总的来说，对于一个简单的 CNN 来说，这些都是很好的结果。

现在，看看混乱矩阵:

模型的混淆矩阵。图由作者制作。

在 733 幅非船只图像中，725 幅被正确识别，8 幅被误标为船只。这些都是误报。

在 267 张舰船图像中，262 张被正确识别，5 张被误标为非舰船。这些是假阴性。

保存和加载模型

如果每次需要的时候都需要训练，CNN 可能不会很有用。在这种情况下，训练时间只需要几分钟，但在更深的具有更多纪元的网络上，训练可能需要几个小时甚至几天。因此，有一个简单的方法可以调用来保存整个模型。

# Save the model for later use
model.save("ShipCNN.h5")

save 方法只接受路径名，将其保存为 H5 文件。

# Load a model
new_model = tf.keras.models.load_model("model.h5")

加载预先保存的文件也相当简单。调用 summary 方法来检查模型的架构是否符合预期也是一个好主意。

结论

使用卫星图像训练 CNN 提供了完美的数据集。所有的图像都是同样的大小，在基本相同的角度和距离拍摄，每艘船都保留了俯视图。虽然改变这些参数中的任何一个都会使分类问题变得更加困难，但船只图像展示了神经网络应用于计算机视觉问题的能力。

使用的 CNN 相对简单，但仍然只需要几分钟的训练就可以返回很高的准确度。接近人类水平的表现，1000 张图像中只有 13 张被错误标记。虽然应用程序是理想化的，但潜力是显而易见的。