TowardsDataScience 博客中文翻译 2022（四百一十一）

原文：TowardsDataScience

协议：CC BY-NC-SA 4.0

使用 LSTM 的推特情感分析

原文：https://towardsdatascience.com/using-lstm-in-twitter-sentiment-analysis-a5d9013b523b

详细了解 LSTM 应用于情感分析的能力

尼古拉·伯恩森在 Unsplash 上拍摄的照片

当你坐上汽车的驾驶座时，你是能够发动引擎开车离开，还是在开车离开之前，你需要考虑你将如何做以及这个过程的每一步？对于大多数人来说，这是第一选择。

这也是递归神经网络(RNNs)的工作方式。你不需要从头开始考虑你一天中要做的每一个基本任务，因为我们有一个叫做记忆的小东西，循环神经网络也是如此。但是他们是如何学习和储存这些记忆的呢？

rnn 有环路，允许它们从信息中学习。来源:https://colah.github.io/posts/2015-08-Understanding-LSTMs/

在上图中，神经网络的一个单元接收某种类型的输入 Xt 并输出一个值 *Ht。*然后，循环将信息提供给下一个单元格，依此类推。因此，rnn 可以被认为是同一个网络的副本，每个都向下一个传递信息。当我们看一个完整的链时，就更容易理解了，它是上图中展开的环:

展开的递归神经网络的完整链。来源:https://colah.github.io/posts/2015-08-Understanding-LSTMs/

在过去的几年中，RNNs 已经被成功地应用于多种自然语言处理项目中。这些应用包括语音识别、语言建模、翻译，当然还有我们将在本文中探讨的情感分析。如果没有一种特殊的 RNN，这一切都是不可能的，那就是 LSTM(长短期记忆)。出于许多目的，LSTMs 比传统的递归网络工作得更好，这里我们将展示如何以及为什么。但首先，我们需要谈谈为什么我们不能只使用正常的 RNNs，它有什么问题。

rnn 令人兴奋的一点是，它们可以在预测中使用过去的信息。考虑一个试图根据前面的单词来预测一个句子的最后一个单词的模型。在句子“书在桌子上”中，最后一个单词的选择范围很窄，而“桌子将是一个很好的预测，不需要太多额外的上下文就可以正确预测。在相关单词与预测之间的距离很小的情况下，RNNs 可以很好地预测。然而，如果我们需要更多的上下文来进行单词预测，会发生什么呢？

想想这个句子“这几天我一直在学习，在桌子上，有一本书”。最近的信息表明，桌子上有一些物体，但如果我们想缩小到哪个物体，我们应该进一步回到句子。然后，如果我们在第一句话中查看单词“学习，我们将获得预测正确所需的额外上下文。由于句子以“我一直在学习”开头，所以桌子上不太可能有足球或伏特加酒瓶，而不是一支笔或一本书。这正是为什么 LSTM 模型现在被广泛使用，因为它们被特别设计成具有长期“记忆”，能够比受长期依赖问题影响的其他神经网络更好地理解整体背景。

理解 LSTM 如何工作的关键是细胞状态。细胞状态通过一些微小的线性相互作用来运行整个链，在这些相互作用中，LSTM 可以通过称为门的结构来添加或删除信息。有两个门:一个 sigmoid 神经网络层和一个逐点乘法操作。

单元格状态是穿过顶部的粗体线条。来源:https://colah.github.io/posts/2015-08-Understanding-LSTMs/

盖茨负责选择哪些信息将通过。例如，sigmoid 层将 sigmoid 函数应用于原始向量，并输出 0 和 1 之间的值。那是什么意思？零值将阻挡所有信息，而值 1 将让所有信息通过第一门并在单元状态流中继续。

“忘记”栅极层将 sigmoid 函数应用于单元状态。来源:https://colah.github.io/posts/2015-08-Understanding-LSTMs/

我们已经说过，LSTM 的第一个决定来自 sigmoid 层门，我们也可以称之为“忘记”门。该层查看两个输入: *Xt，*带有矢量化文本，我们希望预测情感(借助于标记器，如下图所示)，以及 Ht-1 带有模型已经拥有的先前信息。然后，应用 sigmoid 函数，并且它为每个单元状态 Ct-1 输出 0 和 1 之间的数字。

Tokenizer:这就是如何将原始文本矢量化为 LSTM 模型的输入。每个字相当于编码器定义的一个数字。来源:作者

在本文中，我们不会详细介绍其他 LSTM 层，因为重点是展示如何将其应用于 Twitter 情感分析，但该算法的演练在这里详细解释。既然我们已经谈论了很多 LSTM 理论，让我们编码并展示如何使用它来预测推文的情绪。

最初，我们需要获得一个包含分类推文的数据集来训练和测试我们的模型。我选择了 Kaggle 的 Tweet 情感提取比赛的数据集。这个数据集是大约 27，500 条推文的集合。

那么，让我们加载数据:

import pandas as pd

df_train = pd.read_csv('train.csv',sep=',')
df_train.text=df_train.text.astype(str)
df_val = pd.read_csv('test.csv',sep=',')
df_val.text=df_val.text.astype(str)

预览我们加载的训练数据集(df_train)。来源:作者

加载完数据后，我们的下一步是合并训练和验证数据集以创建单个数据集，我们可以对其应用预处理步骤，尤其是标记化过程，稍后我们将对此进行详细解释。

df = pd.concat([df_train.assign(ind="train"),df_val.assign(ind="validation")])

现在，下一步是去除中立情绪。这不是共识，但是一些文章表明去除中性词是增强情感分析模型性能的一种方式。二元分类的结果更容易解释，模型往往表现更好。此外，因为我们要处理数组，所以有必要将“正”标签转换为 1，将“负”标签转换为 0。

df **=** df**.**loc[(df['sentiment'] **==** 'Positive') **|** (df['sentiment'] **==** 'Negative')]

df**.**loc[df['sentiment'] **==** 'Positive','sentiment'] **=** 1 df**.**loc[df['sentiment'] **==** 'Negative','sentiment'] **=** 0

现在好戏开始了！让我们开始操纵推文并对它们进行预处理，以准备我们的 LSTM 模型的输入。为此，我们需要加载两个库:Spacy 和 RE(正则表达式)。Spacy 是一个令人惊叹的自然语言处理库，它有一些工具，如预训练的单词向量、词汇化、存储的停用词、实体识别，以及用于 60 多种语言的其他工具。我们所要做的就是在我们的 Python 环境中安装 Spacy 并下载我们想要的语言，在本文中是英语。然后我们将下载 en_core_web_sm 这是一个英语培训的管道，它有较小的版本(也有中等和较大的版本)。然后，我们使用空间函数“load”将刚刚下载的管道应用到“ nlp 对象。

*# pip install -U spacy
# python -m spacy download en_core_web_sm*

**import** spacy
**import** renlp **=** spacy**.**load('en_core_web_sm')

既然已经加载了 NLP 库，我们可以开始文本预处理了。首先，我们应该将我们的文本列转换为字符串，然后我们可以删除停用词，并使用上面刚刚创建的 nlp 加载管道中的“lemma_”和“is_stop”方法，通过一行代码应用词汇化。然后，我们必须将字符串转换成小写，并使用正则表达式库，这样我们就可以删除空格(\s)和字母数字字符(\w)，只留下对我们的模型有影响的单词。

df["text"] **=** df["text"]**.**astype(str)
df["text"] **=** df['text']**.**apply(**lambda** x: " "**.**join([y**.**lemma_ **for** y **in** nlp(x) **if** **not** y**.**is_stop]))
df['text'] **=** df['text']**.**apply(**lambda** x: x**.**lower())
df['text'] **=** df['text']**.**apply((**lambda** x: re**.**sub('[^\w\s]','',x)))

现在是时候对我们的推文进行矢量化了，我们将使用 Keras 库预处理工具来完成这项工作。首先，我们必须基于词频定义要保留的最大单词数，我们将它设置为 3000，以便在我们的向量中有一个稳定的单词种类。当我们将记号赋予文本时，重要的是我们在完整数据(df)上进行，否则，如果我们仅将记号赋予训练 tweets，然后尝试使用相同的记号来转换验证数据集，我们可能会得到错误。有些单词只出现在验证数据集中，而对于标记器来说是未知的，因为它只适合使用训练数据集单词。因此，我们将使我们的 tokenizer 对象适合我们的完整数据集。

**from** tensorflow.keras.preprocessing.text **import** Tokenizer
**from** tensorflow.keras.preprocessing.sequence **import** pad_sequences

max_features **=** 3000
tokenizer **=** Tokenizer(num_words**=**max_features, split**=**' ')
tokenizer**.**fit_on_texts(df['text']**.**values)

将记号赋予器仅适用于训练数据集的另一个问题是输出的形状。例如，让我们想象我们的火车数据集只有一条推文，上面的例子是“ le chat est noir ”。在标记化之后，我们将得到一个形状为(1，4)的数组。然后，如果我们试图预测一条推文“我很高兴”的情绪，一个形状为(1，3)的数组，这是不可能的，因为这些数组的形状不匹配。在这种情况下，我们可以使用 numpy lib pad 用 0 填充测试数组，以匹配标记器的原始形状(1，4)。这样做之后，我们仍然会遇到上一段提到的不适合单词的问题，因为单词“ I ”、“ am ”或“ happy ”都不适合分词器，最终我们的数组将是[0，0，0，0]。可以使用 max_features 参数将 tokenizer 的形状设置为一个限制，但通常情况下，它与最大元素的形状相同，或者在我们的示例中，与包含最多单词的 tweet 的形状相同。

既然记号赋予器已经适合完整的数据框，我们可以分割回训练和验证数据集。

df_train, df_val **=** df[df["ind"]**.**eq("train")], df[df["ind"]**.**eq("validation")]

在拆分回 df_train 和 df_val 并拟合记号化器之后，是时候对 tweets 进行矢量化了。这可以使用 Keras 'texts _ to _ sequences和 pad_sequences 来完成。

X_train **=** tokenizer**.**texts_to_sequences(df_train['text']**.**values)
X_train **=** pad_sequences(X_train)X_val **=** tokenizer**.**texts_to_sequences(df_val['text']**.**values)
X_val **=** pad_sequences(X_val)

矢量化的 X_train 数组。来源:作者

在对推文进行矢量化之后，是时候检查数据集的形状是否匹配了，否则我们需要调整其中一个。

[X_train.shape,X_val.shape]

我们得到的输出是[(16.363，20)，(2.104，18)]，意味着 X_train 数据集有 16.363 行(或 tweets)和 20 个特征(或单词)，X_val 数据集有 2.104 行(或 tweets)和 18 个特征(或单词)。因此，我们需要用 0 填充 X_val 数据集，以匹配 X_train 的 20 个特征。但是我们怎么能对一个数组这么做呢？当然是 Numpy！使用 numpy lib pad，我们可以使用 X_train 的形状减去 X_val 的形状，以获得两个数组之间的特征(或单词)差异，并用常数值 0 填充 X_val 以匹配形状。

**import** numpy **as** np
X_val **=** np**.**lib**.**pad(X_val, ((0,0),(X_train**.**shape[1] **-** X_val**.**shape[1],0)), 'constant', constant_values**=**(0))
X_val**.**shape

长度与 X_train 匹配的矢量化 X_val 数组。来源:作者

我们得到的输出是(2.104，20)，最后，训练和验证数组具有相同的特征长度(20)，可以用于我们的预测。现在，我们预处理的最后一步是准备我们的目标值，所以我们要从这些变量中取出虚拟变量，并将它们转换成数组，以便在我们的训练和验证中使用。

Y_train **=** np**.**array(pd**.**get_dummies((df_train['sentiment'])**.**values))
Y_val **=** np**.**array(pd**.**get_dummies((df_val['sentiment'])**.**values))

训练和验证数组都设置好了，是时候构建我们的 LSTM 模型了！但是我们从哪里开始呢？喀拉斯！最受欢迎的深度学习和神经网络库之一，它运行在机器学习库 TensorFlow 之上。它允许我们建立一个模型，并使用 Keras 上的 sequential 类，我们可以将一个线性堆栈的层组合到我们的模型中。这些层与我们在本文第一部分的 LSTM 解释中提到的层相同。

**from** tensorflow.keras.models **import** Sequential
**from** tensorflow.keras.layers **import** Dense, Embedding, LSTM, SpatialDropout1D

现在，构建 LSTM 网络的第一步是创建一个嵌入层。嵌入层允许我们将每个单词转换成固定长度的向量，这是一种更好的方式来表示这些单词，同时降低维度。max_features 参数是我们已经在标记化中设置的词汇表的大小，embed_dim 参数是我们想要的每个单词的向量的长度，input_length 是一个序列的最大长度，所以在我们的例子中，我们可以使用 X_train.shape[1]，它输出 20。就这样，我们的嵌入层完成了。

max_features = 3000
embed_dim = 128model **=** Sequential()
model**.**add(Embedding(max_features, embed_dim,input_length **=** X_train**.**shape[1]))

继续，在我们的嵌入层之后，是时候给我们的模型添加一个空间下降 1D 层了。空间下降层的主要目的是避免过度拟合，这是通过概率性地移除该层的输入(或我们正在构建的网络中嵌入层的输出)来实现的。总而言之，它具有模拟许多不同网络的效果(通过丢弃随机元素，或者在我们的例子中是它们的 30%——代码上的 0.3 个参数),并且最终，网络的节点对于未来的输入更加健壮，并且倾向于不过度拟合。

model**.**add(SpatialDropout1D(0.3))

最后，是时候添加我们的明星层，一个我们谈论了这么多，唯一的 LSTM！我们定义的第一个参数 lstm_out 为 256，它是输出空间的维数，我们可以选择一个更大的数来尝试改进我们的模型，但这可能会导致许多问题，如过拟合和长训练时间。dropout 参数应用于我们模型的输入和/或输出(线性变换)，而 recurrent dropout 应用于模型的递归状态或单元状态。换句话说，经常性的辍学影响了网络的“记忆”。对于这个 LSTM 网络，我选择使用更大的压差和 0.5 的经常压差，因为我们的数据集很小，这是避免过度拟合的重要一步。

lstm_out = 256model**.**add(LSTM(lstm_out, dropout**=**0.5, recurrent_dropout**=**0.5))

现在我们的 LSTM 层已经完成了，是时候准备我们的激活函数了。我们通过添加一个密集连接的层来实现我们网络的激活功能，并输出我们最终阵列所需的维度。正如我们之前看到的，在 LSTM，我们需要一个 sigmoid 神经网络层，这正是我们选择 sigmoid 激活的原因。sigmoid 函数输出一个介于 0 和 1 之间的值，它可以让信息不流过或完全流过这些门。

最后，我们准备编译模型，这是为训练配置模型。我们将为我们的损失函数选择分类交叉熵，这是一种广泛使用的损失函数，用于量化分类问题中的深度学习模型错误。对于我们的优化器，我们将使用 Adam 优化器，这是 Adam 算法的一种实现，它是随机梯度下降的一种健壮扩展版本，是深度学习问题中最常用的优化器之一。此外，选择的指标将是准确性，因为我们有一个情绪分析问题，我们需要预测它是正面还是负面的推文。

model**.**add(Dense(2,activation**=**'sigmoid'))
model**.**compile(loss **=** 'categorical_crossentropy', optimizer**=**'adam',metrics **=** ['accuracy'])
print(model**.**summary())

这是我们的最终模型:

Model: "sequential"
_________________________________________________________________
 Layer (type)                Output Shape              Param #   
=================================================================
 embedding (Embedding)      (None, 161, 128)          384000    

 spatial_dropout1d (Spatia  (None, 161, 128)         0         
 lDropout1D)                                                     

 lstm_3 (LSTM)               (None, 256)               394240    

 dense_3 (Dense)             (None, 2)                 514       

=================================================================
Total params: 778,754
Trainable params: 778,754
Non-trainable params: 0
_________________________________________________________________

随着模型的建立，是时候执行每个数据科学家都喜欢的命令了。因此，让我们将我们的模型拟合到 X_train 和 Y_train 阵列，10 个历元应该足以获得预测的良好性能。批量大小是在执行重量更新(一个时期)之前，通过网络运行的样本数量，我们将保持它较低，因为它需要较少的内存。

batch_size = 32
model.fit(X_train, Y_train, epochs = 10, batch_size=batch_size, verbose = 2, shuffle=False)

培训的回访历史。来源:作者

在 10 个时期后，我们可以看到我们的模型的性能在每个时期都有所提高，损失减少，精度增加，最终在训练数据集上达到 94.4%的高精度。

现在是时候使用我们训练过的模型来衡量它在测试数据集上的性能了，这是我们之前构建的 X_val 。在深度学习问题上这样做的一个好方法是建立一个函数，这里我们有一个情感分析分类问题，在验证(或测试)数据集上检查我们模型的准确性、f1 分数和混淆矩阵是一个好主意。下面是我用过的一个:

import matplotlib.pyplot as plt
import seaborn as snsdef evaluate_lstm(model, X_test,Y_test): pos_cnt, neg_cnt, pos_correct, neg_correct = 0, 0, 0, 0
 results = [] for x in range(len(X_test)):
  result =   model.predict(X_test[x].reshape(1,X_test.shape[1]),
  batch_size=1,verbose = 3)[0] if np.argmax(result) == np.argmax(X_test[x]):
   if np.argmax(X_test[x]) == 0:
    neg_correct += 1
  else:
    pos_correct += 1

  if np.argmax(X_test[x]) == 0:
   neg_cnt += 1
  else:
   pos_cnt += 1
  results.append(np.argmax(result)) Y_test_argmax = np.argmax(Y_test,axis=1)
 Y_test_argmax  = Y_test_argmax.reshape(-1,1)
 results = np.asarray(results)
 results = results.reshape(-1,1) conf_matrix = confusion_matrix(Y_test_argmax, results)
 fig = plt.figure(figsize=(6, 6))
 sns.heatmap(conf_matrix, annot=True, fmt="d", cmap = 'GnBu');
 plt.title("Confusion Matrix")
 plt.ylabel('Correct Class')
 plt.xlabel('Predicted class')

并将该函数应用于 X_val 数组，我们得到:

accuracy,f1, fig = evaluate_lstm(model,X_val,Y_val)
print(f'Accuracy:{accuracy:.3f}')
print(f'F1 Score: {f1:.3f}')

度量和混淆矩阵。来源:作者

我们得到了 87.3%的准确率和 0.878 的 F1 分数，这两个分数都很棒！另一个积极的事情是，该模型在积极(1)和消极(0)情绪上都表现良好。当然，验证数据集推文与训练数据集推文的主题相似，数据集在正面和负面推文之间保持平衡，这一事实会影响这些指标。它仍然显示了神经网络在情感预测方面的能力。该模型可以用新的推文进行训练，以提高对特定主题的预测性能等。

最终，神经网络只是线性代数，神奇的事情发生了。

使用机器学习估计价格弹性

原文：https://towardsdatascience.com/using-machine-learning-to-estimate-price-elasticity-47a2ba71bdb0

丽贝卡·马修斯在 Unsplash 上拍摄的照片

在我研究生院分析项目的最后一个学期，我的任务是估算葡萄酒的价格弹性。乍一看，这似乎是一个简单的目标。在经济学中，我学到价格弹性是给定价格变化百分比时需求变化的百分比。你所要做的就是查看每个价格下的购买数量，以确定价格弹性。为什么你甚至需要机器学习来解决这类问题？

为了理解这种简单化的方法有多大的缺陷，让我们考虑以下问题:

价格是影响你是否购买产品或服务的唯一变量吗？

如果你回答“不”，那么你可以想象经济理论和现实之间的潜在差距。为了估计价格弹性，除了产品或服务的价格之外，你可能还需要考虑许多变量。否则，您的弹性模型可能会受到预测性能不佳的影响。

带有一些个人修改的典型机器学习开发过程。在数据准备阶段增加了“规划+研究”部分以及“探索性数据分析”文本。作者开发的图像。

规划+研究

因为我从未试图在简单的财务分析之外评估弹性，这个问题需要一些研究。当我向一位有很强物理学背景的同事描述这个问题时，这导致了我有过的最刺激的对话之一。在为他定义了价格弹性之后，我们试图用微积分中的导数(即测量变化)的基本原理来解决这个问题。这个讨论，再加上来自 UW 大学“定量分析”课程的帖子，促使我使用对数转换的多元线性回归来解决我的问题。对数转换变量的解释反映了变量之间的百分比变化，这是期望的结果。

估算葡萄酒价格弹性以及每个所需维度所需的算法如下:

1. 筛选与您正在评估弹性的维度相关的销售数据的特定子集(例如，如果评估红酒的价格弹性，则仅筛选红酒销售)
2. 对未来销售目标变量和当前价格特征执行对数转换
3. 训练一个线性回归模型来准确预测未来的销售额
4. 价格弹性估计将是对数转换的系数，价格特征
5. 对每个弹性评估重复步骤 1-4

数据准备

建立高层次计划后，我开始准备数据。这通常是任何模型开发过程中最耗时的部分。目标是在进行任何分析之前，识别并执行必要的步骤来预处理和转换数据。虽然数据很容易获得，但数据库文档还有许多不足之处。表之间的关系不明显，主键也不明显。此外，数据定义留下的问题多于答案。为了说明这种模糊性，让我们想象下面的模拟产品表。你认为下表中的销售价格是什么意思？

没有清晰的文档，我不得不思考以下问题:

销售价格是每单位、每产品或每箱的价格吗？

所有饮料的标准单位是什么？

“售价”是否含税？

用如此多的未知数来估计弹性不仅不准确，而且不道德。为了填补这一知识空白，我需要向我们的利益相关者问几十个问题。一些例子包括:

• 为什么有的价格为零？
• 当出现等价的栏目时，哪一个应该是最靠谱？
• 为什么“X”列中似乎缺少这么多信息？
• 为什么这个“ID”列不都是唯一值？
• 在弹性估计之前，可以过滤掉哪些记录？

获取该领域和特定于数据库的知识的过程是数据专业人员经常忽视的技能。数据准备过程中的一个失误或误算的假设会导致下游的错误结论。

PS:这就是为什么许多数据科学团队越来越多地嵌入业务职能部门，而不是像 IT 部门那样独立的部门。

探索性数据分析

在这个准备阶段，我也在探索数据。为了建立一个可解释的模型，你需要了解数据的分布，各种模式，并找到可以解释弹性的特征。在这一步中，可视化是数据专家最好的朋友。

使用直方图，我能够了解消费者在美国不同州、年份、账户(如酿酒厂)、品种(如梅洛)、价格区间(如每瓶 10-15 美元)、销售渠道(如在线)等方面的购买行为。对于提供给我的数据切片，它是一个跨越几个维度的不平衡数据集。消费者购买的很大一部分是在加利福尼亚，并且大多数购买都来自一个账户。此外，各年间账户数量不一致，因为随着时间的推移增加了一些账户。

观察多年来的购买时间序列表明，消费者的购买行为可能存在一定的季节性。这一观察极大地影响了我在机器学习开发周期下一步的特征工程决策。

也许最有趣的观察结果是通过在线渠道购买的比例增加，以及在 COVID 影响的年份中销售额的急剧下降和上升。购买行为的这些重大变化塑造了我们后来的一些建模决策，例如排除 2016 年之前的数据。

特征工程

数据准备和特征工程之间的界限可能有点模糊。在对数据表中的数据进行预处理之后，我将相关记录转换成“模型可读”的格式。对于 python 中流行的机器学习库 scikit-learn 来说，这需要将所有特征转换成数值。诸如购买地点(如加利福尼亚)等特征必须转换成具有二进制值的“虚拟列”(即 1 表示是，0 表示否)。这个虚拟变量创建过程被应用于所有感兴趣的分类列，并且可以使用 pandas 库中的“get_dummies”方法轻松应用。请参见下面的代码示例。

import pandas as pd
dummy_variable_columns = ['Day_of_week', 'Month', 'Status']
sales_dataframe_new = pd.get_dummies(sales_dataframe_old, columns=dummy_variable_columns)

一个最常见的，也是最令人沮丧的特征工程步骤包括日期维度的修改。我从订单日期中提取了不同的时间段(例如，月、周、日、年),以测试不同时间间隔内消费者行为的季节性。销售的时间序列看起来非常像一个正弦图，以至于我回想起了高中三角函数课。这启发了我去研究和创建时间的正弦和余弦变换，作为模型中的特性进行测试。

由于销售额呈现为正弦曲线，我决定在不同的周期长度内测试数据框架的聚合(即特征向量和销售额)。这个有点复杂的任务很容易完成，这要归功于熊猫的另一种方法，叫做“重新取样”。这个方法转换了 dataframe，这样每一列都可以在我需要的任何时间段(例如，每 45 天)进行聚合。请参见下面的代码示例。

sales_dataframe_new_45daycycle = sales_dataframe_new.resample('45D', on='Order_Date', origin='start', label='right', closed='right').sum()

上面代码片段的结果是，我现在可以看到 45 天周期内每条记录的总销售额，而不是特定日期的订单。我看到的不是同一种红酒的 5 个不同订单，而是总销售额、总销量、总订单数、每个月的总订单数等。每 45 天一个周期。将所有列转换为数字格式是此重新聚合的必要先决条件。

现在数据框架已经有了新的结构，我计算了每条记录的每卷平均价格，并对这个值和总销售量进行了对数转换。因为我们需要估计未来的需求，所以我必须创建一个列，它是未来对数转换后的销售量。这得益于熊猫的“转换”方法。请参见下面的代码示例。

sales_dataframe_new_45daycycle['log_quantity_sold_future'] = sales_dataframe_new_45daycycle['log_quantity_sold_current'].shift(periods=-1)

运行这段代码后，我们的数据框架中的每条记录都有当前价格和未来时期的销售额。这种设置是训练逻辑模型所必需的，因此当前价格(一个已知的特性)被用来解释未来的需求量——一个未知的目标，因为你无法知道未来的销售额。

*有读者记得 SOHCAHTOA 吗，这个有趣的首字母缩写词有助于记住不同的三角函数？

模特培训

在向非技术观众传达模型训练阶段时，很容易呈现复杂任务的假象。实际上，由于现在有成熟的机器学习库可用，训练模型通常是开发周期中比较容易的步骤之一。下面的代码反映了我在创建训练和测试集、标准化数据、训练逻辑回归模型以及将模型拟合到缩放的特征向量(即，对数转换价格、时间维度等)时所做的工作。)以及目标向量(即对数转换后的未来需求)。

import numpy as np
import sklearn# Set up the train and test sets
train_x, test_x, train_y, test_y = train_test_split(sales_dataframe_new_45daycycle.loc[:, sales_dataframe_new_45daycycle.columns != 'log_quantity_sold_future'].to_numpy(),
                                                 sales_dataframe_new_45daycycle['log_quantity_sold_future'].to_numpy(),
test_size=0.20,
 random_state=20)#Standardize the feature vector and target vector
scaler = preprocessing.StandardScaler().fit(train_x)
train_x_scaled = scaler.transform(train_x)
test_x_scaled = scaler.transform(test_x)# Build and fit the linear regression model
lr = LinearRegression()
lr.fit(train_x_scaled, train_y)

上面的代码片段省略了特征选择/正则化过程。特征选择过程主要是通过排除与未来需求相关性差的特征来驱动的。

模型评估

虽然 R 平方和均方根误差(RMSE)是学校教授的最常见的评估指标，但我经常发现平均绝对误差(MAE)和平均绝对百分比误差(MAPE)是更容易解释的评估指标。后一种度量提供了实际值和预测值之间的距离的更直观的度量。

对于其中一个多元线性回归模型，模型评估指标如下:

使用 MAPE，我能够与利益相关者沟通，我们模型的预测与实际销售值相比平均相差 1.4%。此外，特征向量解释了未来需求中 75%的偏差。这个模型在可解释性方面是成功的，在预测方面也非常准确。

结论

总的来说，我的结论是葡萄酒是一种缺乏弹性的商品；然而，消费者的行为因葡萄酒的每个子集而异(即不同的销售渠道、品种等)。).假设消费者在所有情况下都缺乏弹性，并且在未来仍将缺乏弹性，这将是一个错误。此外，有一些数据子集的样本量太小，对它们各自的弹性估计值没有信心。为了改进这一分析，我将把替代产品价格(如啤酒)纳入特征向量，并研究估计弹性的替代方法。用更有弹性的商品(如快餐)重复这一过程会很有意思，看看估计揭示了什么。

数据通才

注意:所有文本、数据和代码均经过修改，以隐藏任何敏感信息。

使用 Make for Data Science 项目改变了我的生活

原文：https://towardsdatascience.com/using-make-for-data-science-projects-changed-my-life-23de1597e2e

基岩实用程序有助于保持代码模块化，并提高迭代速度

马丁·w·柯斯特在 Unsplash 上的照片

数据科学项目的存在是为了从数据中可重复地产生知识。

也就是说，从探索性数据分析和可视化，通过统计建模，一直到具有庞大参数空间的尖端深度学习架构，我们所掌握的所有工具的统一目的是创造新知识。从广义上讲，我们要么通过推理直接学习，要么通过构造证明我们的黑盒可以解决给定的问题。卓越要求我们的过程透明，以至于其他人可以复制它、仔细检查它、修补它并改进它。

经典且历史悠久的构建工具 GNU Make 使得这些目标非常容易实现。

在为本文创建的示例项目中，我们将下载 NeurIPS abstracts (在 CC 4.0 下发布)，对它们进行一些转换，最后拟合一个潜在的 Dirichlet 分配模型。自始至终，我们将使用 Make 来编排这个过程。我们将介绍的众多优势包括:

1. 一种表达培训管道中各步骤之间依赖关系的自然方式。(阅读“逃离‘拍摄这些笔记本代码单元的顺序正确吗……’地狱。”)
2. 向模块化迈进:简单的依赖管理鼓励我们将我们的程序块分割成小而漂亮的庙宇。
3. 轻松利用实用程序:因为 Make 为我们编排了命令，所以我们可以利用安装在主机上的任何东西。想在 python 的下游任务之前用 sed 处理文本吗？柠檬汽水，范姆。
4. 更快的迭代:Make 帮助我们避免不必要的重复计算，加速我们的创新周期，帮助我们更快地构建。
5. 更容易的外部协作:通过依赖一组脚本——而不是例如笔记本——并表达它们的依赖性，Make 帮助我们将规范交给数据工程领域的朋友，而不需要太多额外的工作。

示例项目遵循 DrivenData 发布的 DS cookie cutter 。这个模板第一次让我了解了 Make for DS 的价值，这本身就是一个效率提升。

什么是品牌

(有经验的 Make 用户，随意跳过这一节——你会觉得很无聊。)

按照传统设计，Make 是可执行文件的构建工具。来自GNU.org:

GNU Make 是一个工具，它控制从程序的源文件生成程序的可执行文件和其他非源文件。Make 从一个名为 makefile 的文件中获取如何构建程序的知识，该文件列出了每个非源文件以及如何从其他文件中计算出它。写程序的时候要为它写一个 makefile，这样才有可能用 Make 来构建和安装程序。

例如，在 C++项目中，Make 文件是很常见的。但这是它最常见的用法，不是的限制。更多来自 GNU:

Make 根据哪些源文件发生了变化，自动计算出哪些文件需要更新。如果一个非源文件依赖于另一个非源文件，它还会自动确定更新文件的正确顺序。因此，如果您更改一些源文件，然后运行 Make，它不需要重新编译您的所有程序。它只更新那些直接或间接依赖于您所更改的源文件的非源文件。[…] Make 并不局限于构建一个包。您还可以使用 Make 来控制软件包的安装或卸载，为其生成标记表，或者您想经常做的任何事情，只要写下如何做就值得了。

概括地说，Make 管理检查哪些文件需要创建或重新创建的过程:如果自上次生成输出后没有任何变化，我们可以跳过重新创建它的步骤。它可以用来管理任何一系列我们想要重现的命令。

这非常自然地有助于分析或机器学习项目。考虑这个非常标准的数据科学工作流程:

1. 通过文件下载或查询数据库获得一些数据。
2. 对数据进行清理、插补等处理。
3. 工程师特征。
4. 训练和比较一系列模型架构或配置。

在这个非常常见的 DS 项目周期中，我们做出了几十个决定，包括如何处理什么、尝试哪些超参数、不同的插补方法等等。

易于表达

这些步骤中的每一步都可以在 Make 规则中自然地表达出来。例如，假设我们需要从 UCI ML 存储库中下载一个类似于 NeurIPS 数据集的文件。我们可以用curl来下载。这形成了一个简单的 Make 规则:

data/raw/NIPS_1987-2015.csv : curl -o $@ [https://archive.ics.uci.edu/ml/machine-learning-databases/00371/NIPS_1987-2015.csv](https://archive.ics.uci.edu/ml/machine-learning-databases/00371/NIPS_1987-2015.csv)

用 Make 的语言来说，我们想要创建的这个目标文件没有先决条件，只有一个创建它的方法。那个$@是一个 Make 自动变量，它填充了目标的名称。导航到演示项目文件夹的根目录，运行make --recon data/raw/NIPS_1987-2015.csv,您应该会看到 Make 将运行的命令来生成文件:

curl -o data/raw/NIPS_1987-2015.csv [https://archive.ics.uci.edu/ml/machine-learning-databases/00371/NIPS_1987-2015.csv](https://archive.ics.uci.edu/ml/machine-learning-databases/00371/NIPS_1987-2015.csv)

在没有--recon标志的情况下运行make data/raw/NIPS_1987-2015.csv，该命令将实际运行。再次运行它，你会得到这条消息，Make 的方式告诉我们不要浪费时间再次下载它:

make: `data/raw/NIPS_1987-2015.csv' is up to date.

我们看到原始文件是按列排列的，我们想转置它。我们将把转置后的版本放在data/interim中，快速编写一个轻量级脚本来执行 op，并在另一个规则中表达依赖性和执行:

data/processed/NIPS_1987-2015.csv : src/data/transpose.py data/raw/NIPS_1987-2015.csv $(PYTHON_INTERPRETER) $^ $@

这里我们使用了$^，另一个自动变量满足了所有的先决条件。使用--recon标志进行的另一个调用make data/processed/NIPS_1987-2015.csv --recon将向我们展示我们将在实际运行中看到的命令，即它将使用我们编写的 python 脚本创建目标文件:

python3 src/data/transpose.py data/raw/NIPS_1987-2015.csv data/processed/NIPS_1987-2015.csv

当训练模型时，这一步自然依赖于处理后的数据:

models/%_topics.png : src/models/fit_lda.py data/processed/NIPS_1987-2015.csv src/models/prodlda.py $(PYTHON_INTERPRETER) $< $(word 2, $^) $@ --topics $*

在这里，我们编写了fit_lda.py来训练一个模型，并为每个主题创建一个词云，我们在png目标文件中捕获它。这是为了举例而简化的。在一个典型的、专业的构建中，我们的目标会更加全面:我们会包括学习曲线、数据集每个部分的错误摘要，以及任何我们需要经验地比较不同模型架构的东西。我们还利用了模式规则，在目标中使用字符%，以及 Make 的word宏。我们将在模块化一节中详细介绍这些内容。

这些步骤中的每一步都自然依赖于前面的步骤，Make 为我们提供了表达它们的自然方式。

更快的迭代

Make 为您处理依赖关系。假设您已经编写了处理数据的脚本和步骤，并将结果保存到一个文件中。你现在正处于训练模特的阶段。当您修改训练脚本时，Make 会识别出训练数据文件的时间戳没有更改，并跳过重新生成它的步骤。

现在，想象一下，在这个模型开发过程中，你了解到一个边缘情况，实际上是一个我们没有考虑到的预处理。很平常的事情。

自然，我们更新执行预处理操作的脚本。Make 会将此脚本识别为包含已处理数据的文件的先决条件，当您下一次运行命令来训练模型时，Make 会识别出需要重新创建数据。当所有先决条件都比目标旧时，Make 会跳过重建步骤。

在数据科学项目过程中，这种事情会发生几十次。让它更快可以大大提高你的迭代速度。Edmund Lau 在 《有效的工程师 *，*中写道迭代速度在软件工程环境中的应用，但关键的要点是数据科学:“你迭代得越快，你就能学到越多。”(附属链接。)对我来说，避免这种不必要的重复已经使项目更有效率。

鼓励模块化

当然，您可以使用 Make 执行一个脚本来一次性完成所有这些工作。它对实施模块化没有任何作用，因为我们已经在这个例子中实现了它。

但是这些步骤都需要时间，你重复的次数越多，你的迭代速度就会越慢。谁愿意花额外的时间等待重新处理他们的数据？有很多方法可以避免这些额外的重新处理步骤，但是 Make 使它变得简单。

能够灵活地创建规则是非常强大的。例如，假设您正在比较几种型号配置。在一个神经网络中，你可以改变几个层中隐藏单元的数量，非常少的参数，等等。Make 提供了一种简单的方法来保存和比较这些数据。

在我们的主题建模例子中，开始时我们可能不知道有多少主题会导致一组可解释的、合理的主题。我们可以使用我们编写的模式规则快速训练我们的模型。又来了:

models/%_topics.png : src/models/fit_lda.py data/processed/NIPS_1987-2015.csv src/models/prodlda.py $(PYTHON_INTERPRETER) $< $(word 2, $^) $@ --topics $*

模式规则使得使用相同的通用执行模式来声明构建许多文件的规则变得容易。在我们的例子中，我们使用自动变量$*来包含在实际执行中匹配的词干，并且我们使用它作为我们的主题模型中的主题数量。结合一个虚假的目标all，我们可以使用一次make all训练多个模型:

all : models/10_topics.png models/20_topics.png

然后我们可以比较两者的输出。

显示来自 10 个主题的潜在狄利克雷分配模型的主题中的常用词的词云。图片作者。

显示来自 20 个主题的潜在狄利克雷分配模型的主题中的常用词的词云。图片作者。

利用公用事业

假设您有一千个文本文件，都有同样的 20 行样板文件需要删除。无聊吧？制作也很简单:

data/processed/%.txt : data/raw/%.txt sed 1,20d $^ > $@

就像我们之前依赖于curl一样，我们可以使用任何我们想要的东西来处理我们的数据，任何读取我们的 Makefile 的人都将确切地知道我们是如何创建这些处理过的数据的。简单、可重复且透明。

易于协作

至少在我的经验中，对于“我们如何让我们的模型去生产？”有很多答案。因为有组织和架构。很多(大部分？)组织拥有多年的数据，以及随之而来的遗留限制。这可能意味着，尽管我们很想采用最新的无缝 MLOps 框架，但我们会发现自己正在与软件或数据工程团队合作。

通常，这些团队通过经验被训练成“你能帮助 DS 团队部署这个吗？”通常翻译成，“你能把这个没有记录任何进入模型构建的假设的糟糕的笔记本，以某种方式把它变成一个可维护的构建过程吗？我把它扔过去的时候，你站在栅栏的对面！”

Make 并不是挥去这些挑战的魔杖。但是，在 Make 中编排的构造良好的模型管道已经将流程表达为 DAG。通过显式指定先决条件，Make 规则精确地显示了给定步骤之前必须做的事情。这样，即使我们的模型构建必须在其他环境中重建，我们的 Makefile 也给出了该过程的详细规范。

“当然，我们可以帮忙，”我们的软件或数据工程朋友开始说道，令人不寒而栗。“你能给我们介绍一下你的模型训练/构建过程吗？”

“总的来说，如果你克隆我们的回购协议，导航到项目并运行带有-B和--recon标志的make all，它将向你展示所有的步骤是如何执行的。我来拍一个回购的链接稍等……”

当他们运行这个命令时—-B标志告诉 Make 只需改造所有的目标，即使它们没有过时——他们将看到我们为构建我们的模型所必须做的一切:

curl -o data/raw/NIPS_1987-2015.csv https://archive.ics.uci.edu/ml/machine-learning-databases/00371/NIPS_1987-2015.csv python3 src/data/transpose.py data/raw/NIPS_1987-2015.csv data/processed/NIPS_1987-2015.csv python3 src/models/fit_lda.py data/processed/NIPS_1987-2015.csv models/10_topics.png --topics 10 python3 src/models/fit_lda.py data/processed/NIPS_1987-2015.csv models/20_topics.png --topics 20

你为什么讨厌笔记本，你这个怪物？

我绝对没有，我发誓。它们作为交流工具非常有用——我宁愿在任何一天写或读一个光滑的笔记本，而不是一个幻灯片——对于互动，DS 思想笔记。“哦，当我画这个的时候，我们看到了一些共线性…让我们计算并打印 R 平方…”是我很多个早上喃喃自语的事情。我喜欢所有的笔记本，无论是 IPython 笔记本还是填充了不必要的高质量纸张的实体笔记本。(我是英语专业的。)

我想象珍妮特·温特森在写《激情》https://amzn.to/3HAlcFy的时候填满了几十个实体笔记本。(附属链接。然而，在这个过程的最后，她出版了一部简洁统一、美丽迷人的小说。你，我亲爱的数据科学家，同样也是一个有野心和远见的艺术家，当我们把最终的媒介和勾画出的让我们到达那里的想法混淆时，我们给自己造成了伤害。

抛开痛苦的隐喻不谈，笔记本是版本控制的噩梦。

包扎

我们已经了解了 Make 如何通过将您的工作流分解为模块化的块，并使所有这些块协调运行，从而使您的生活变得简单，并使流程易于重现。但是我们只是触及了 make 及其。这里有一些关于进一步发展这些技能的便利资源。

• 完整示例项目展示了如何编写单独的脚本来完成上面讨论的每个步骤。
• 它建立在这种千篇一律的基础上，这是一种惊人的自以为是的方式，以神话般的、合理的意见为基础建立项目。这本书非常值得一读，尤其是它简洁地论证了简单的约定如何提高建模的生产率和可重复性。
• 这本伟大的书可以帮助人们深入了解 GNU Make 的全部功能，我们在这里只是涉猎了一下。(附属链接。)它的主要焦点是传统的软件项目，但这不是障碍:它全面地展示了 Make 的功能，并给出了全面的、有指导的介绍。如果你想避免仅仅从文档中学习新技术时遇到的麻烦，这可能是一本好书。

原载于 2022 年 3 月 1 日https://Easter . ai*。*

使用 MLflow 跟踪机器学习实验

原文：https://towardsdatascience.com/using-mlflow-to-track-machine-learning-experiments-adbf27e9d36c

物流跟踪简介

图片来自 Unsplash

机器学习生命周期有各种各样的步骤，需要在生产的道路上加以考虑。简而言之，这绝不像训练您的模型一次，然后直接投入部署那么简单。 ML 是一个迭代的过程，你将需要许多周期的训练和所有的组件来获得你的用例的最佳模型。

MLflow 是一个开源平台，通过四个主要组件帮助端到端地管理这个 ML 生命周期: MLflow 跟踪、 MLflow 项目、 MLflow 模型和模型注册。在本文中，我们将具体了解如何使用 MLflow Tracking 管理/监控模型训练的不同迭代。我们将通过一个简单的 Sklearn 线性回归示例来了解波士顿住房数据集。如果你想直接跳到代码，这里是 Github 库。

目录

1. 安装/设置
2. MLflow 跟踪示例
3. 其他资源和结论

安装/设置

这里的设置非常简单，因为 MLflow 是一个开源包，您可以使用它。

安装 MLflow

如果您想获得 MLflow 文档的完整访问权限，请从他们的库开始，其中还附带了一大组示例，涵盖了我们讨论过的所有主要组件。

要开始使用我们的模型，请创建一个示例 Python 文件，并在您的环境中添加以下包(如果没有安装的话)。

例如包装

MLflow 跟踪示例

我们现在可以开始构建将由 MLflow 跟踪的模型。在开始我们的模型构建之前，我们将创建一个主函数来捕获我们的模型和 MLflow 跟踪。在这个函数中，我们需要首先创建一个将被跟踪的 MLflow 实验。这可以通过对 MLflow 库使用 set_experiment 调用来完成。

创建 MLflow 实验

这里我们设置一个活动的实验来跟踪，如果这个实验不存在它是为我们创建的。现在，我们可以构建我们的模型，我们将使用 MLflow 进行跟踪。对于 Boston Housing 数据集，我们将使用 Sklearn 构建一个简单的线性回归模型。

模特培训

在模型训练之后，我们可以捕获一个样本度量，例如 RMSE ，我们可能希望根据我们脚本的不同迭代来监控/跟踪它。

RMSE 公制

然后，我们可以通过使用 log_metric API 调用，使用特定的 MLflow 来跟踪这个指标。这里，我们将 RMSE 指定给 log_metric 调用，以便 MLflow 在模型的迭代中进行跟踪。

使用 MLflow 跟踪指标

这里没有涉及的另一个关键特性是，您可以指定您希望 MLflow 跨实验跟踪的超参数。这可以通过在 log_param 中的类似调用来完成。这对于更复杂的算法尤其有用，当您在实验中对不同的超参数进行基准测试/比较时也是如此。

现在我们可以使用模型注册中心来记录我们的模型。MLflow 附带了一个专门为 Sklearn 模型制作的 API 调用。

将模型记录到模型注册表中

现在，如果我们运行这个 Python 文件几次，我们应该会看到一个 RMSE 显示。与此同时，运行将被捕获到一个名为 mlruns 的目录中，该目录将在执行 Python 文件时创建。

mlruns 目录已创建(作者截图)

MLflow 的真正力量来自简单的 UI 界面，您可以利用它来可视化这些不同的实验。在与 Python 文件相同的目录中，在终端中运行下面的命令,您应该能够访问 UI。

打开 UI 后，您应该能够在侧面板上看到我们创建的实验。

实验已创建(作者截图)

如果我们点击这个实验，我们应该看到我们执行模型训练的不同运行/次数。我们还应该看到我们在 RMSE 记录的指标。

实验运行(作者截图)

随着实验变得越来越复杂，您可以添加更多的指标、参数，并轻松过滤这些运行，以获得最佳性能的模型。为了进行进一步的查询或可视化，您还可以下载一个 CSV 文件，使用 Pandas、Matplotlib 等库进行比较。

其他资源和结论

MLflow 是一个非常强大的工具，可以轻松跟踪您的大规模 ML 实验。当试图将你的 ML 生命周期推向生产时，考虑这样的工具是必要的。每一步都需要监控和维护，MLflow 使这一过程非常直观和易于使用。

我希望这是对 MLflow 和 MLOps 入门的有用介绍。在以后的文章中，我们将探索更复杂的例子和 MLflow 的其他特性，比如模型托管。

如果你喜欢这篇文章，请在 LinkedIn 上与我联系，并订阅我的媒体 简讯 。如果你是新手，使用我的 会员推荐 报名。

使用多阶段构建将您的 docker 映像缩小 10 倍

原文：https://towardsdatascience.com/using-multi-stage-builds-to-make-your-docker-image-almost-10x-smaller-239068cb6fb0

留下不必要的工具，清理你的 Docker 图片

如果你完成了建造，你需要清理你的工具

在这篇短文中，我们分多个阶段构建图像，以显著减小 docker 图像的大小。最终，我们会得到一个图像，做完全相同的事情，但是尺寸却小了 10 倍！我们这样做的方法是留下我们用来建立图像的工具。

首先，我们将创建一个 docker 文件，用于以“常规”方式构建图像。然后我们升级这个文件，利用一个额外的阶段，留下我们不必要的工件。最后，我们将通过试验不同的 docker 图像来进一步优化。让我们看看我们能减掉多少脂肪；我们来编码吧！

开始之前

我们使用了很多终端命令。不熟悉的话可以看看 这篇 。

设置

假设我们正在构建一个需要地理数据的应用程序。Open StreetMap 为我们提供了这种地理数据:通过geofabrik.de，我们可以以.osm.pbf格式下载每个国家的地理数据。接下来我们可以使用一个叫做Osmium的工具将这些文件合并在一起。想象一下，我们只需要将这个合并文件输入到我们的应用程序中。

总之:我们只需要使用curl(下载)和osmium(合并)一次:当我们获得合并后的文件时，我们就不再需要这些工具了。在两阶段构建中，我们在第一阶段下载这些工具，在那里使用它们，然后只将结果(合并的文件)带到下一阶段，留下工具。

在我们看到两阶段构建之前，让我们看看“正常”的方式。

1.普通的身材

在这一部分，我们将用最简单的方式来建立我们的形象。尽管如此，我们还是要记住一些小技巧来最小化我们的形象，详见本文https://mikehuls.medium.com/5-easy-to-implement-tricks-to-trim-down-your-docker-image-size-263978a6ed29。这是 dockerfile 文件:

FROM ubuntu:20.04# BUNDLE LAYERS
RUN apt-get update -y && apt install -y --no-install-recommends \
  curl \
  osmium-tool \
 && rm -rf /var/lib/apt/lists/*RUN mkdir /osmfiles \
 && mkdir /merged \
 && curl [https://download.geofabrik.de/europe/monaco-latest.osm.pbf](https://download.geofabrik.de/europe/monaco-latest.osm.pbf) -o /osmfiles/monaco.osm.pbf \
 && curl [https://download.geofabrik.de/europe/andorra-latest.osm.pbf](https://download.geofabrik.de/europe/andorra-latest.osm.pbf) -o /osmfiles/andorra.osm.pbf \
 && osmium merge /osmfiles/monaco.osm.pbf /osmfiles/andorra.osm.pbf -o /merged/merged.osm.pbf

这个 does 文件正是我们需要的:安装 curl 和 osmium，下载文件并合并它们。我们最终得到驻留在/merged中的合并文件。

注意，我们在获得合并文件后不做任何事情。出于本文的目的，我们将保持这个 docker 文件简单，并跳过对文件的实际操作。

让我们来看看这张图片的大小:

testimg:latest        a88a8848201b   16 seconds ago       96.9MB

正如你看到的图像大约是 97MB。在下一部分中，我们将使用多个阶段来升级 docker 文件。

本文清理了大量垃圾(图片由杰里米·贝赞格在 unsplash 上提供)

2.实现多阶段构建

在前面的例子中，我们只使用了一次构建工具(curl 和 osmium)。使用后，它们会留在我们的印象中。打个比方:你买了一辆新车，但发现所有用于制造汽车的工具都还在后备箱里，占据了宝贵的空间！

在这一部分，我们将重点放在留下我们用来制造汽车的工具。让我们检查新的 docker 文件并检查代码。

FROM ubuntu:20.04 AS final
FROM ubuntu:20.04 as build# BUNDLE LAYERS
RUN apt-get update -y && apt install -y --no-install-recommends \
  curl \
  osmium-tool \
 && rm -rf /var/lib/apt/lists/*RUN mkdir /osmfiles \
 && mkdir /merged \
 && curl [http://download.geofabrik.de/europe/monaco-latest.osm.pbf](http://download.geofabrik.de/europe/monaco-latest.osm.pbf) -o /osmfiles/monaco.osm.pbf \
 && curl [http://download.geofabrik.de/europe/andorra-latest.osm.pbf](http://download.geofabrik.de/europe/andorra-latest.osm.pbf) -o /osmfiles/andorra.osm.pbf \
 && osmium merge /osmfiles/monaco.osm.pbf /osmfiles/andorra.osm.pbf -o /merged/merged.osm.pbfFROM finalRUN mkdir /merged
COPY --from=build /merged /merged

如你所见，我们使用了两个阶段:一个称为构建，一个称为最终。在我们的建造阶段安装卷曲和锇。使用它们创建合并文件，最后只需将merged文件夹复制到final阶段。

一旦我们输入了FROM final，我们就“进入”了最后一个阶段，所以FROM final之后的任何事情都会在那里发生。二号线的FROM ubuntu:20.04 as build也是如此。请注意，curl 和锇只是在我们的构建阶段安装的。一旦我们到达 docker 文件的末尾，我们只保留我们所处的阶段。因为 final 阶段在 dockerfile 的末尾是活动的，所以 build 阶段中的所有内容都会被留下。让我们来看看新容器的尺寸:

testimgbetter:latest        7342ee3948e8   3 seconds ago    75.1MB

我们的新形象是 75MB :通过留下我们不再需要的工具，我们节省了超过 20MB 或不到 20%的空间。这已经是非常好的改进了。让我们来看看如何进一步优化。

3.具有较小最终图像的多阶段

在前一部分中，我们在构建和最终阶段都使用了ubuntu:20.04图像。对于构建阶段，这是非常合理的；在这里我们做复杂的事情:安装包，下载东西，git 克隆，在其他情况下甚至可能使用cmake或make来编译代码！然而，最终阶段并不需要像构建阶段那么智能。

这一部分的想法是，你需要一个大而丰富的图像，像复杂的构建阶段的ubuntu:20.04。然后，我们可以将来自构建阶段的结果复制到基于更简单图像的最终阶段。在我们的例子中，我们甚至可以使用非常小的图像，如 Alpine。让我们稍微调整一下我们的 docker 文件:

FROM alpine:3.14 AS final

现在，一旦构建阶段完成，我们只需将合并后的文件复制到 alpine 阶段。让我们检查一下新构建的图像的总大小:

testimgbetter                                                latest        8ad3278671e1   17 minutes ago   7.95MB

我们从 75MB 降到了略低于 8MB: 几乎减少了90%！****

请注意，使用 alpine 图像并不总是有效；本文这一部分的想法是，我们可以使用比构建阶段更小的最终图像。

整洁有序(图片由谷仓图片在 unsplash 上拍摄)

结论

在本文中，我们重点了解了 docker 构建的方式，并通过删除所有我们不再需要的工具来最小化 docker 映像。我们可以通过多个阶段非常有效地做到这一点:执行复杂的任务，如在丰富的映像中安装和构建，然后将结果复制到更精简的最终映像中，并留下构建阶段。

本文中的例子非常少；只留下了curl和osmium。有这样的例子，我使用了一个更大的构建阶段，并通过留下我们不再需要的工件，使节省了超过 1.5GB** ，图像大小从 1.8GB 变为 0.3GB ！**

我希望这篇文章是清楚的，但如果你有建议/澄清，请评论，以便我可以做出改进。与此同时，看看我的 其他关于各种编程相关主题的文章 ，比如:

• 面向绝对初学者的 Docker
• Docker 为绝对初学者编写
• 把你的代码变成一个真正的程序:使用 Docker 打包、运行和分发脚本
• Python 为什么慢，如何加速
• Python 中的高级多任务处理:应用线程池和进程池并进行基准测试
• 写你自己的 C 扩展来加速 Python x100
• 【Cython 入门:如何在 Python 中执行>每秒 17 亿次计算
• 使用 FastAPI 用 5 行代码创建一个快速自动记录、可维护且易于使用的 Python API

编码快乐！

—迈克

页（page 的缩写）学生:比如我正在做的事情？跟我来！

**https://mikehuls.medium.com/membership **

使用自然语言处理和文本分析对政治文本进行聚类

原文：https://towardsdatascience.com/using-nlp-and-text-analytics-to-cluster-political-texts-41fdb2c3a325

NLTK 和古根海姆项目文本的 scipy

在文本分析的保护伞下，有许多 python 包可以帮助我们以产生有趣结果的方式分析当前和历史文本。在这个项目中，我试图用余弦相似性聚类法对跨越数千年的政治著作进行分类。我使用的具体标题是:

马基雅维利的《君主论》

汉密尔顿、麦迪逊和杰伊的《联邦党人文集》

恩格斯的《英国工人阶级的状况》

摩尔的《乌托邦》

戈德曼的《无政府主义和其他论文》

霍布斯的《利维坦》

《美国宪法》

密尔的《代议制政府的思考》

马克思和恩格斯的《共产党宣言》

亚里士多德的《政治学》

洛克的《政府第二论》

第一步是下载文本语料库(直接从古根海姆项目的网站下载)。然后，我需要导入文件，并在文本文件中找到每项工作的开始和结束行。* 古根海姆项目文件下载为。txt 文件，并在实际工作的上下有额外的行。*

*# For loop to find the start and end points of the books*
**for** i **in** book_id:
    ...
    a **=** df**.**line_str**.**str**.**match(r"\*\*\*\s*START OF (THE|THIS) PROJECT")
    b **=** df**.**line_str**.**str**.**match(r"\*\*\*\s*END OF (THE|THIS) PROJECT")
    ...

使用 for 循环和其他字符串操作，我匹配了它们的公共开始和结束元素。txt 文件，以便确定每个文学作品的起点和终点。

作者图片

Doc&Library Tables:
下面的 regex 部分搜索每本书以分离出章节，从而开始创建 OCHO(内容对象的有序层次结构)样式表。

 OHCO **=** ['book_id', 'chap_num', 'para_num', 'sent_num', 'token_num']roman **=** '[IVXLCM]+'
caps **=** "[A-Z';, -]+"
chap_pats **=** {
    5: {
        'start_line': 40,
        'end_line': 680,
        'chapter': re**.**compile("^ARTICLE\s+{}$"**.**format(roman))
    },
    61: {
        'start_line': 19,
        'end_line': 1529,
        'chapter': re**.**compile("^\s*Chapter\s+{}.*$"**.**format(roman))
    },
    1232: {
        'start_line': 1000, *# This was mannually found through trial and error becuase the previous start had issues*
        'end_line': 4828,
        'chapter': re**.**compile("^\s*CHAPTER\s+{}\."**.**format(roman))
    },
    ...
}

现在我们已经有了 book_id 和章节的分类，我们可以填充每个文本层次结构的其余部分。我们按照熊猫和字符串操作将每一章分解成段落。生成的表称为 Doc 表，将在后续步骤中使用。我们还能够分离出标题和作者来完成库表。

在下面的图片中，我们可以看到一个显示图书 id、章节、段落编号和字符串的 doc 表示例。以及完整的库表。

作者图片

作者图片

Token & Vocab 表
为了进一步分解 Doc 表，我们需要定义每个单独的术语。下面的函数接收我们的 Doc 表，将每个段落的字符串解析成句子，然后将这些句子解析成单独的术语。这个操作主要是通过 nltk 包使用 nltk.sent_tokenize、nltk.pos_tag、NLTK 来完成的。WhitespaceTokenizer 和 nltk.word_tokenize。

*# Tokenize doc table to derive TOKEN table*
**def** tokenize(doc_df, OHCO**=**OHCO, remove_pos_tuple**=False**, ws**=False**):

    *# Paragraphs to Sentences*
    df **=** doc_df**.**para_str\
        **.**apply(**lambda** x: pd**.**Series(nltk**.**sent_tokenize(x)))\
        **.**stack()\
        **.**to_frame()\
        **.**rename(columns**=**{0:'sent_str'})

    *# Sentences to Tokens*
    *# Local function to pick tokenizer*
    **def** word_tokenize(x):
        **if** ws:
            s **=** pd**.**Series(nltk**.**pos_tag(nltk**.**WhitespaceTokenizer()**.**tokenize(x)))
        **else**:
            s **=** pd**.**Series(nltk**.**pos_tag(nltk**.**word_tokenize(x)))
        **return** s

    df **=** df**.**sent_str\
        **.**apply(word_tokenize)\
        **.**stack()\
        **.**to_frame()\
        **.**rename(columns**=**{0:'pos_tuple'})

    *# Grab info from tuple*
    df['pos'] **=** df**.**pos_tuple**.**apply(**lambda** x: x[1])
    df['token_str'] **=** df**.**pos_tuple**.**apply(**lambda** x: x[0])
    **if** remove_pos_tuple:
        df **=** df**.**drop('pos_tuple', 1)

    *# Add index*
    df**.**index**.**names **=** OHCO

    **return** dfTOKEN **=** tokenize(DOC, ws**=True**)*# Creating VOCAB table and adding columns to TOKEN data*
...

作者图片

上面有我们的令牌表并不意味着我们完成了。我们现在需要在这个表的基础上创建一个 Vocab 表来索引我们的文本语料库中使用的每个术语。使用字符串和矩阵操作，以及 NLTK 模块的 PorterStemmer()函数，我们进一步构建我们的令牌表并创建我们的 Vocab 表。

下面分别是令牌表和 Vocab 表的示例。从我们的令牌表中可以看出，每个术语现在都对应于一个编目的 term_id，可以使用我们新的 Vocab 表来引用它。此表提供了术语 id、术语、术语词干、在整个语料库中出现的次数、停用词区别以及最常见的词性。

作者图片

作者图片

TFIDF 表:
接下来，我们需要使用这些表来创建一个 TFIDF 表。TFIDF 表根据每个文本内的使用频率和语料库中文档之间的使用频率来衡量每个术语。此表的目的是为我们提供最有影响力和最有用的分析单词的结果，同时减少停用词或其他常用词的影响，否则这些词会一直使用，如“and”、“of”、“The”等。请注意，我们在代码块的开头定义了不同的包组织，这些可以用来在不同的层次元素上创建 TFIDF 表。

SENTS **=** OHCO[:4]
PARAS **=** OHCO[:3]
CHAPS **=** OHCO[:2]
BOOKS **=** OHCO[:1]**def** tfidf(TOKEN, bag, count_method, tf_method, idf_method):

    *#Create Bag of Words and DTCM*
    BOW **=** TOKEN**.**groupby(bag**+**['term_id'])**.**term_id**.**count()\
        **.**to_frame()**.**rename(columns**=**{'term_id':'n'})
    BOW['c'] **=** BOW**.**n**.**astype('bool')**.**astype('int')
    DTCM **=** BOW[count_method]**.**unstack()**.**fillna(0)**.**astype('int')

    *# TF calculations, will comment out all but 'sum' given that will be what I use*
    **if** tf_method **==** 'sum':
        TF **=** DTCM**.**T **/** DTCM**.**T**.**sum()

    TF **=** TF**.**T
    DF **=** DTCM[DTCM **>** 0]**.**count()
    N **=** DTCM**.**shape[0]

    *# IDF calculations, will comment out all but 'standard' given that will be what I use*
    **if** idf_method **==** 'standard':
        IDF **=** np**.**log10(N **/** DF)

    *# create TFIDF table*
    TFIDF **=** TF ***** IDF
    **return** TFIDFTFIDF **=** tfidf(TOKEN, BOOKS, 'n', 'sum', 'standard')*# Add tfidf_sum column to Vocab table*
VOCAB['tfidf_sum'] **=** TFIDF**.**sum()

正如我们在下面的 TFIDF 表的图像中所看到的，我们得到了一个非常稀疏的结果，因为我们当前包含了在语料库中找到的每个单词。在尝试最终的聚类分析之前，我们需要进一步减少这种情况。

作者图片

此外，在将该 TFIDF 表的求和原则添加到 Vocab 表，并对最高 tfidf_sum 值的结果进行排序之后，我们得到了具有最具影响力的单词的表:

作者图片

不出所料，最有影响力的词与政治术语有关，这符合我们的预期，因为语料库由各种政治著作组成，像“and”或“the”这样的正常使用的词可能无关紧要。

为了帮助简化我们的 TFIDF 表，我们将把 number 列减少到最常见的 4000，这是由上面的 Vocab 表中的 tfidf_sum 列排序的。

聚类:
现在我们已经得到了最终的表，我们可以开始聚类过程并查看我们的结果。下一个代码块在每个作品之间创建配对，比较它们的距离和相似性度量，将文档聚类为最相似/最近的距离。出于本文的目的，我将只展示余弦相似性集群，但是您也可以运行这个代码块中包含的其他测试(cityblock、euclidean、jaccard、dice、correlation 和 jensenshannon)。实际的相似性/距离计算是使用 scipy 的空间距离模块和 pdist 函数运行的。

*# Normalize the TFIDF table, create PAIRS and lists for PAIRS testing*
**def** tab_doc_tab(TFIDF_table, Doc_table):
    L0 **=** TFIDF_table**.**astype('bool')**.**astype('int')
    L1 **=** TFIDF_table**.**apply(**lambda** x: x **/** x**.**sum(), 1)
    L2 **=** TFIDF_table**.**apply(**lambda** x: x **/** norm(x), 1)
    PAIRS **=** pd**.**DataFrame(index**=**pd**.**MultiIndex**.**from_product([Doc_table**.**index**.**tolist(), Doc_table**.**index**.**tolist()]))**.**reset_index()
    PAIRS **=** PAIRS[PAIRS**.**level_0 **<** PAIRS**.**level_1]**.**set_index(['level_0','level_1'])
    PAIRS**.**index**.**names **=** ['doc_a', 'doc_b']
    tfidf_list **=** ['cityblock', 'euclidean', 'cosine']
    l0_list **=** ['jaccard', 'dice','correlation']
    l1_list **=** ['jensenshannon']
    **for** i **in** tfidf_list:
        PAIRS[i] **=** pdist(TFIDF_table, i)
    **for** i **in** l0_list:
        PAIRS[i] **=** pdist(L0, i)
    **for** i **in** l1_list:
        PAIRS[i] **=** pdist(L1, i)
    **return** PAIRSPAIRS **=** tab_doc_tab(TFIDF_cluster, DOC)

最后，我们运行聚类函数并显示余弦相似性测试的结果。我们使用 scipy 模块的 scipy.cluster.hierarchy 函数来创建我们的聚类图的框架，并使用 matplotlib 来显示下面的实际聚类。

*# Create Clusters*
**def** hca(sims, linkage_method**=**'ward', color_thresh**=**.3, figsize**=**(10, 10)):
    tree **=** sch**.**linkage(sims, method**=**linkage_method)
    labels **=** list(DOC**.**title**.**values)
    plt**.**figure()
    fig, axes **=** plt**.**subplots(figsize**=**figsize)
    dendrogram **=** sch**.**dendrogram(tree, 
                                labels**=**labels, 
                                orientation**=**"left", 
                                count_sort**=True**,
                                distance_sort**=True**,
                                above_threshold_color**=**'.75',
                                color_threshold**=**color_thresh
                               )
    plt**.**tick_params(axis**=**'both', which**=**'major', labelsize**=**14)hca(PAIRS**.**cosine, color_thresh**=**1)

作者图片

上面的图片是我们看到每个作品的聚类以及每个作品之间的紧密联系的结果。基于我们的结果，我们可以看到余弦相似性聚类提供了相当准确的结果。有三大类，我称之为西方政治哲学、美国政治哲学和共产主义政治哲学。每个文本都与相似的文本适当地聚集在一起，来自相同作者的一些文本更紧密地聚集在一起，例如恩格斯的文本。

结论:
我们从。txt 文件，创建了各种文本表，如 Library、Token、Vocab 和 TFIDF 表。一旦我们得到了我们需要的所有表格，我们运行余弦相似性度量，并根据相似的作品对文本进行聚类。这个项目最终能够找到我们所期望的三个集群，给定我们对作者的了解，以及每个政治文本的主题。

这个项目的完整代码可以在我的 GitHub 页面上找到:https://GitHub . com/nbehe/NLP _ texts/blob/main/Beheshti _ project _ code . ipynb

这个项目是我的文本分析课程的一个大项目的一小部分。我将为该项目的其他部分撰写额外的文章，其中我们将研究其他非监督模型，如主成分分析、主题建模和情感分析。与文本分析一样，尤其是本文，大部分代码都致力于创建运行这些模型所需的表。我选择保留所有代码，而不是只保留一部分，这样其他人就可以看到我的所有步骤。来自这个项目的代码是我自己写的，由讲师提供的，以及通过课程材料提供的作品的混合物。

使用 Panel 和 hvPlot 可视化几十年的野火

原文：https://towardsdatascience.com/using-panel-and-hvplot-to-visualize-decades-of-wildfires-2ac8d6f5db25

让我们建立一个仪表板，使用 Holoviz 工具了解更多关于 1992 年至 2015 年期间发生的数百万起野火的信息

马特·帕尔默在 Unsplash 上拍照

我最近写了一篇关于使用 Python 库 Panel 制作数据仪表板的文章。我们创建了一个简单的仪表板，允许我们可视化数据集每年的各种汇总图。在这篇文章中，我想在这些技能的基础上，使用 Panel 制作一个仪表板来查看美国野火记录的时间序列。

我们的数据集包括 1992 年至 2015 年间发生在美国的超过 180 万起野火。我们的目标是构建一个数据仪表板，帮助我们更好地了解这些野火的原因、发生地点等。

数据准备

由作者创建

导入我们的数据非常简单。我们可以使用sqlite3连接到我们的 SQLite 数据库，并查询我们想要处理的信息。这些信息被存储在一个熊猫数据框中，这样我们就可以删除阿拉斯加和夏威夷，使绘图更容易。最后，我们可以通过从火灾数据中减去发现火灾的日期来计算燃烧时间。

绘制野火地图

让我们从绘制所有火灾的地图开始，这样我们就可以看到空间分布。我们可以使用 hvPlot 轻松做到这一点，因为它利用了 Datashader 来光栅化我们的 180 万个点，这使得它们更易于渲染。

由作者创建

你可以使用贴在这里的互动笔记本与这些情节互动。令人印象深刻的是，使用 hvPlot 创建高质量的空间可视化是多么容易。由于它利用了其他 Holoviz 库——holo views、Geoviews、Datashader 和 Colorcet——它简化了创建交互式地图所需的许多常规步骤，该地图仍然可以响应大型数据集。

带有时间滑块的简单仪表板

用静态图来可视化时间序列数据可能会很烦人，然而，Panel 的小部件让我们可以使用各种方法来操作和子集化我们的数据，比如选择年份的滑块。

制作带面板的仪表板有三个步骤:

1. 定义一个小部件，比如选择年份的整数滑块或下拉列表。
2. 定义一个绘图函数，将滑块中的年份值作为输入。
3. 布局和渲染我们的仪表板。

由作者创建

制作简单仪表板的快速方法

当我们只有一个图和一个小部件要显示时，布置仪表板似乎需要很多额外的代码。对于这样一个简单的仪表板，我们可以使用.interactive来制作数据帧和/或数据管道的交互式副本。

要了解这是如何工作的，让我们看看是否可以制作一个小部件，让我们选择火灾的原因，并让地图只显示这些火灾。

由作者创建

令人高兴的是，我们不必担心我们的仪表板的布局，而是可以定义我们的小部件和附带的绘图。在这篇文章中，我们不会关注交互式数据框架，但是，我认为在创建这些不太复杂的仪表板时提到它们是有好处的。

构建我们的仪表板

我们有了基本的地图，但仪表板最强大的部分之一是能够一次看到我们数据的多个方面。让我们创建一些地块来配合我们的地图，然后使用面板将它们连接在一起。

火灾规模

我们可以从绘制每个尺寸等级发生的火灾数量开始；野火按燃烧面积大小分类，A 级最小，G 级最大。

由作者创建

我们所有的绘图函数都将年份作为参数，这样当滑块值改变时，它们可以对数据进行子集化。这里，我们可以使用子集化的数据按照大小分类对数据帧进行分组，并使用.size()来计算每组中的火灾数量。

按原因划分的燃烧时间

我们接下来的两个图都将着眼于野火的原因；野火有许多原因，其发生频率和潜在危险有很大差异。让我们先来看看 2003 年每场野火的平均燃烧时间。

由作者创建

按原因划分的火灾数量

现在，不考虑燃烧时间，让我们简单地看看 2003 年各组引起的火灾数量。

由作者创建

我们可以看到两个图之间的一些有趣的差异，比如吸烟是如何导致第二长的野火，而它在引起的野火总数中排名第九。除了闪电，燃烧时间最长的火灾并不是最频繁发生的。

当我们思考是什么让野火难以扑灭时，这是有意义的；如果火灾发生在更偏远的地方，那么很难在早期控制住火势。闪电、吸烟和营火都有可能在这类地区引发火灾，这些地区有大量的木材可以燃烧，周围很少有人报告烟雾的最初迹象。

也有一些年份可能看起来很不一样，比如 2006 年，少量的输电线故障导致了平均持续几天的大火灾。让我们来看看:

由作者创建

这里需要注意的是 Panel 和 hvPlot 如何识别这两个图共享相同的 y 轴，并重新组织第二个图以匹配第一个图。尽管我对两个数据帧都进行了排序，所有这一切还是发生了，所以如果你想避免这种情况，就在你的图中添加.opts(axiswise=True)。

把它放在一起

现在，我们已经有了小部件和一些要在我们的时间序列中探索的图，我们可以继续创建我们的仪表板了！

由作者创建

就这样，我们有了一个工作仪表板！我知道 gif 并不理想，所以一定要检查一下互动笔记本，这样你就可以自己摆弄这些情节了。撇开 gif 不谈，考虑到我们这么快就把它组合在一起，这是一个相当不错的仪表盘。

改进的余地

我确信我们可以通过简化绘图函数中运行的代码来提高响应速度。对于那些我不想解释每一行代码是做什么的文章，我会尽量让代码片段可读性更好。

例如，当通过year对数据帧进行子集化时，会有很多重复；我们可能会在每次year值改变时对数据帧进行一次子集化，然后将子集化后的数据传递给每个绘图函数。

包扎

除了制作实际的情节之外，我们几乎不需要付出任何努力，当谈到将我们的情节“链接”在一起时，hvPlot 和 Panel 可以为我们做的事情非常酷。

Holoviz 工具有时会让人感到有些畏惧，因为它们已经创建了一个庞大且相互关联的生态系统，有许多方法可以产生类似的可视化效果。在 Python 中使用数据可视化时，需要记住的一件关键事情是，总有许多工具和方法可以实现您的目标。有些可能比其他人有优势，但重要的是开始尝试它们。

资源:

• 剧情互动笔记本
• 将纬度/经度转换为纬度/经度 (Holoview 文档)
• 在平铺地图上覆盖数据 (hvPlot 文档)

注: 如果您喜欢在 Medium 上阅读我和其他人的内容，请考虑使用下面的链接订阅，以支持这样的内容创建，并解锁无限的故事！

https://medium.com/@willmnorris/membership

引文

数据集:野火(公共领域 CC0)

短，凯伦 C. 2017。美国 1992–2015 年的空间野火发生数据[FPA FOD 20170508]。第四版。柯林斯堡，CO:林务局研究数据档案。【https://doi.org/10.2737/RDS-2013-0009.4

使用 Panel 在 Python 中构建数据仪表板

原文：https://towardsdatascience.com/using-panel-to-build-data-dashboards-in-python-e87a04c9034d

让我们使用 Holoviz 的 Panel 构建一个交互式数据仪表板

由 Unsplash 上的路径数码拍摄

Holoviz 正迅速成为一套流行的 Python 绘图库，适用于初学者和老手。Holoviz 由几个包组成，目的是使可视化数据变得更容易，而不管数据类型如何，同时提高绘图的质量。其中一些库包括 hvPlot、Panel、HoloViews 和 GeoViews。

在本帖中，我们将学习如何使用 Panel 来创建交互式数据面板和 web 应用程序。Panel 很快成为我最喜欢的仪表板工具之一，因为它很容易学习基础知识，同时还有足够的深度来创建更复杂的应用程序。它还非常灵活地支持您可以使用的绘图类型，这意味着如果您已经使用 follow 创建了一个地图，您不必花费时间使用另一个工具重新构建它，以将其集成到仪表板中。

为什么选择仪表板？

数据仪表板并不是新的实践；多年来，企业一直使用仪表板来跟踪和了解他们的数据。仪表板通常是用 JavaScript 或无代码软件构建的，然而，有了 Panel 这样的新库，使用 Python 创建仪表板变得前所未有的简单。在整个工作流程中选择使用相同的语言可以帮助节省大量时间，尤其是在您进行原型设计的时候。

仪表板提供了几个关键的好处，如交互性、可定制性和可共享性。因为我们可以定义小部件，比如改变时间序列中年份的滑块，所以我们可以进行有意义的交互，帮助用户看到数据的变化。

能够自定义布局还允许混合不同种类的图或使用多个图来显示数据集的不同维度。最后，可分享性。Panel 可以轻松地将仪表板部署为 web 应用程序，这意味着您可以快速地与更多用户在线共享您的工作。

材料

我们在本帖中创建了几个互动的情节，然而，它们不容易直接嵌入媒体，所以你可以跟随这个互动 Jupyter 笔记本。

小组介绍

在我们开始使用 Panel 创建第一个仪表板之前，让我们先快速讨论一下它的基本工作原理。

成分

使用 Panel 制作的应用程序由三个主要组件组成:

• 窗格:窗格是你的地块的渲染视图。您的绘图可以是用许多流行的 Python 绘图库创建的对象。窗格本质上只是将现有的绘图转换成 Panel 可以处理的对象。
• 小部件:小部件允许用户输入，比如点击或输入数据，允许用户与应用程序交互。
• 面板:面板是一个容器，它包含了组成你的应用程序的窗格和小部件。面板是分层的，这意味着面板中可以有面板。面板还可以将元素组织成行和列、选项卡或网格。

这三个对象是面板仪表板的基本构件。我们将绘图转换成窗格，创建小部件来控制变量，然后将它们组织成一个面板——或一组面板。

蜜蜂

Panel 的主要优势之一是它的灵活性。我们可以使用 Panel 在 15 分钟内创建一个快速仪表板，如果这个概念可行，我们可以继续定制我们的仪表板，甚至将其集成到一个更大的软件项目中，而不必重新开始使用新工具。

Panel 通过提供四种不同 API 的选项，能够提供快速绘图和更复杂的功能。在这篇文章中，我们将关注其中的两个:交互函数和反应函数。

交互 API

交互功能是开始构建交互式仪表板的最简单的方法。您只需提供一个函数，然后 Panel 就会生成与之交互所需的 UI。我们可以用 Jupyter 笔记本内部的面板创建一个简单的交互功能，如下所示:

由作者创建

这里我们创建一个简单的函数，它返回一个数的乘积，然后我们告诉 Panel 我们想要与这个函数交互。现在,x的值根据滑块改变，我们可以使用x作为函数的参数，使它们响应我们的交互。

反应功能

交互功能之所以如此简单，是因为它们为我们创建了 UI 元素，就像上面例子中的滑块一样。反应式功能允许我们分别构建 UI 元素和功能，并决定如何链接它们。

我们可以使用流行的帕尔默企鹅数据集制作一个快速的示例图，如下所示:

由作者创建

这里有三个步骤:

1. 声明我们的两个选择小部件，这将让我们选择我们的任何列作为 x 轴或 y 轴。
2. 使用嵌套的行和列，pn.Row(pn.Column(<TITLE AND WIDGETS>), <PLOT>)，把我们的内容组织成一行，但把它分成两列。
3. 使用pn.bind()将我们的散点图与我们的两个小部件连接起来，然后 Panel 为我们处理剩下的部分。

从图中单独声明窗口小部件可以让我们更好地控制 UI 元素的样式和组织，与使用交互函数相比，唯一的缺点是必须编写一些额外的代码。我真的很喜欢反应式函数更具声明性，这使得每个元素要做什么变得非常清楚。

创建带有面板的仪表板

我们将在本帖中使用的数据集包括 2020 年至 2022 年全球数据科学工作的信息。数据集中大约有 600 个作业，这对于一个例子来说是一个很好的大小，不管我们决定制作什么样的情节，浏览器都不会很难加载这个例子。

让我们将数据导入 Python，看看我们在处理什么。

由作者创建

我们可以看到，我们有员工的经验水平、工资、远程工作比率以及公司和员工的位置等信息。我们可以从中制作出很多有趣的图表，所以让我们创建一些来研究数据，然后填充我们的仪表板。

基本情节

Medium 不支持直接上传 HTML，所以文章中的情节不是交互式的。如果你想与剧情互动，你可以跟随这个互动笔记本。

让我们从导入 hvplot pandas 库开始，并将 holoviews 扩展设置为 bokeh。我是 Plotly 的长期粉丝，这也是 holoviews 扩展的一个选项，但我真的很喜欢 bokeh 的默认样式。

我们先做一个简单的箱线图来看一下工资根据经验水平的分布。

由作者创建

这里我们可以看到 hvPlot 是如何取代 DataFrame 的正常绘图功能的。现在，对于其余的图，我希望能够按年份对数据进行子集划分，因此我们将使用以年份作为参数的函数。我们的下一个图将是一个条形图，显示按经验水平划分的平均工资。

由作者创建

现在，我们可以调用plot_bars1(2021)将数据子集化为当年的工作。你可能已经明白我的意思了…

现在我们有了一个函数，它将年份作为参数并返回一个图，我们准备将它连接到一个滑块来控制我们的年份。当我们可以用 Panel 创建一个简单的 UI 时，为什么要用不同的输入手动运行函数呢？

年份滑块

我们将创建我们的年份滑块，很像反应式函数演示中的选择菜单，只是使用了不同类型的小部件。我们还可以创建一个简单的函数来显示 markdown 中的年份，这样我们就可以看到如何将滑块的值链接到函数的输入。

将小部件的值链接到函数有两种主要方法，要么是我们上面看到的pn.bind()方法，要么是我们在本例中看到的@pn.depends()装饰器。这两种方式都可以，但是我很喜欢装饰者立即声明依赖关系，而不是等到展示仪表板的时候。

现在，在 Jupyter 笔记本中，我们可以呈现这些，并查看滑块的值如何改变显示降价的函数的输入值。

由作者创建

如果你想知道，value_throttled只是告诉面板不要重新运行该功能，直到你释放你的鼠标；这可以防止当您将滑块移动几个槽口时它运行多次。

最终剧情！

我们已经有了我们的基础设施，现在我们只需要制作几个图来填充我们的仪表板，并将它们连接到我们的滑块。让我们看看哪些国家在某一年的平均工资最高。

由作者创建

我知道配色方案不是很好，但我想给近 60 个国家中的每一个国家分配一种独特的颜色，这样当一年发生变化时，不同国家的颜色就不会重复。

你可能已经注意到，这是根据雇员居住的国家来计算平均工资，但是公司所在地呢？我还创建了一个功能来完成几乎相同的任务，除了使用公司位置。

由作者创建

盘面设计

现在我们已经准备好把它们放在一起了。Panel 支持多种排列对象的方式。在这个例子中，我们将使用行和列，因为这是最直观的开始。我们可以在彼此内部嵌套任意多的行和列。

我们将使用一个WidgetBox作为我们的容器，它基本上只是一个Column，但有一点额外的样式，使里面的项目更明显地组合在一起。我还使用了pn.bind()来展示将年份滑块附加到每个绘图上的效果。

由作者创建

我们终于在 Jupyter 笔记本上有了一个正常工作的仪表盘！一旦掌握了这三个基本步骤，您可能会发现使用 Panel 创建交互式仪表板有多快——创建绘图功能 , 定义小部件，以及定义布局。

当然，仪表板可以比这复杂得多，但是，像为时间序列数据集的年份添加一个滑块这样简单的事情可以对数据可视化的影响产生巨大的影响，特别是如果您想与没有编码的任何人共享它。

本地提供仪表板

要在本地托管我们的仪表板，我们所要做的就是从您的工作目录在终端中运行panel serve xxxx.ipynb。现在您可以在localhost通过浏览器访问它。

包扎

我们在这篇文章中讨论了很多，但是我希望我们如何使用 Panel 来制作交互式仪表板的核心概念是清楚的。这篇文章仅仅触及了使用 Panel 和其他 Holoviz 库所能做的事情的表面。我们可以从像 Folium 这样的库中添加地图，或者我们可以配置一个套索样式的选择工具，以允许查看者自己选择数据子集。幸运的是，Holoviz 拥有优秀的文档，我将在未来几周内在 Panel 上发布一系列帖子。

资源

• 带剧情的互动 Jupyter 笔记本
• 面板文件
• HV plot 简介

注: 如果你喜欢在 Medium 上阅读我和其他人的内容，可以考虑使用下面的链接订阅，以支持这样的内容创作，并解锁无限的故事！

https://medium.com/@willmnorris/membership

数据引用

• 数据科学职位数据— 公共领域(CC0 1.0)
  https://www . ka ggle . com/datasets/ruchi 798/Data-Science-job-salary
• 企鹅数据集 —知识共享， PamlerPenguins

艾莉森·玛丽·霍斯特。(2020).帕尔默企鹅:帕尔默群岛(南极洲)企鹅数据。https://doi.org/10.5281/zenodo.3960218

使用 PCA 将神经网络中的参数数量减少 30 倍

原文：https://towardsdatascience.com/using-pca-to-reduce-number-of-parameters-in-a-neural-network-by-30x-times-fcc737159282

同时还能获得更好的性能！—神经网络和深度学习课程:第 17 部分

Unsplash 上 MagicPattern 原图，作者编辑

在之前的文章中，我们创建了一个多层感知器(MLP)分类器模型来识别手写数字。

我们为网络架构使用了两个具有 256 个神经元的隐藏层。即使是这样一个小网络，我们总共得到了 269，322 个参数(权重和偏差项)。获得如此大量的网络参数的主要原因是输入层的大尺寸。

因为 MLP 的输入图层采用 1D 张量，所以我们需要将二维 MNIST 影像数据重塑为一维数据。这个过程在技术上叫做 展平 图像。

(图片由作者提供，用 draw.io 制作)

图像中的每个像素代表一个输入。如果图像中有 784 个像素，我们在 MLP 的输入层需要 784 个神经元。当输入层的大小增加时，我们得到网络中大量的总参数。这就是为什么 MLP 不是参数有效的。当我们使用高像素值图像数据(例如 500 x 500 px 图像)时，输入层的大小会显著增加。

获得网络中大量总参数的问题是，我们需要大量计算资源来训练神经网络，并且这也是耗时的。

MLP 不适用于图像数据。还有一种更好的神经网络架构，称为卷积神经网络(CNN 或 ConvNets) ，用于处理图像数据。它的输入层可以获取高维数据，因此我们不需要展平图像。

如果有一种方法可以减少图像中的像素数量，而不会损失太多的图像质量，我们仍然可以有效地将 MLPs 用于图像数据。如果我们能做到这一点，输入层的大小将会非常小，MLP 模型将是参数有效的。

我们可以将主成分分析(PCA) 应用到展平的图像中，以显著减少像素数量，同时仍然获得几乎相同的图像质量，但现在像素更少了！

一般的工作流程是:

(图片由作者提供，用 draw.io 制作)

首先，我们将 PCA 应用于 MNIST 数字数据，并在保持 91.4%图像质量的同时将维数(像素数)减少了 7.48 倍！然后，我们建立我们在第 16 部分中建立的相同的 MLP 模型。现在，输入的形状是(100，)，而不是(784，)。这将显著减少网络中总参数的数量。此外，我们有机会减少隐藏层中的神经元数量，因为现在输入大小很小。这也将有助于显著减少网络中的总参数数量。

将主成分分析应用于 MNIST 数据

如果您通过 Keras API 获取 MNSIT 数据，您将为训练集获得 60，000 幅手写数字灰度图像，为测试集获得 10，000 幅手写数字灰度图像。每个灰度图像都是二维的，宽 28 像素，高 28 像素。

(图片由作者提供)

我们需要在应用 PCA 之前展平这些图像。展平后，我们得到:

(图片由作者提供)

我们可以将这个新的训练集图像数组视为一个简单的数据集，它有 60，000 行(图像数)和 784 列(图像中的像素数)。现在，我们可以像往常一样应用 PCA。注意，我们将 PCA 分别应用于训练集和测试集。

当考虑单个展平的图像时，像素的数量代表它的维度。当我们降低维度时，我们减少了图像中的像素数量。

对 MNSIT 数据进行主成分分析，选择最佳主成分数(作者代码)

运行上述代码后，我们得到以下输出。

选择最佳主成分数(图片作者提供)

我们可以看到，前 100 个分量捕获了原始图像数据中大约 90%的可变性。这足以保持原始图像的质量。因此，我们选择了前 100 个组件，并对所选组件的数量再次应用 PCA。

用所选组件再次应用 PCA(作者代码)

(图片由作者提供)

我们将原始图像数据的维数减少了 7.84 倍(784/100)，同时保持了原始数据中 91.43%的可变性。

图像样本:应用 PCA 前后(图片由作者提供)

压缩后的图像依然清晰可辨！

**注意:**这里不打算多解释 PCA 过程。敬请参考下面的文章系列(我写的)，了解 PCA 和降维的一切。

点击此图进入我的 PCA 与降维特辑(作者截图)

使用压缩(缩减)的图像数据构建 MLP 分类器

现在，我们建立与在第 16 部分中相同的 MLP 分类器模型，但是使用压缩的图像数据(更少的维度和更少的像素)！

(作者代码)

(图片由作者提供)

这次我们得到了 0.9745 的准确度分数。之前(即在应用 PCA 之前)，我们得到了 0.9804 的准确度分数。我们只损失了很少的准确度分数。也就是 0.0059。

如果我们现在检查总参数的数量，我们会得到:

MLP.summary()

应用 PCA 后的可训练参数数量(图片由作者提供)

先前(即，在应用 PCA 之前)，我们总共获得了 269，322 个参数。这次我们总共只得到 8874 个参数。因此，在应用 PCA 后，我们将总参数数量减少了 30 倍(269，322 / 8，874 )!我们只损失了 0.0059 的模型精度。

我们可以通过应用主成分分析得到更好的结果。这次我说的是过度拟合的问题。

我在培训期间测量了模型的性能。

(作者代码)

(图片由作者提供)

这可以与相应的前一种情况相比较:在应用五氯苯甲醚之前。

(图片由作者提供)

很明显， 模型在应用 PCA 后过拟合更少。该模型对新的未见过的数据(测试数据)进行了很好的概括。原因是:

PCA 去除数据中的噪声，只保留数据集中最重要的特征。这将减轻数据的过度拟合，并提高模型对未知数据的性能。除此之外，当数据中有许多要素时，模型会变得更加复杂。复杂的模型往往会过度拟合数据。PCA 通过减少数据中的特征数量(维度)来处理模型的复杂性—来源: 如何通过维度减少来缓解过度拟合 (我自己的文章)

摘要

• 我们将 PCA 应用于 MNIST 数据，并成功地将原始图像数据的维数降低了 7.84 倍。因此，我们可以显著减小 MLP 输入层的大小。我们在原始数据中保留了 91.43%的可变性。所以，图像还是可以识别的。
• 在应用 PCA 之后，我们仅损失了非常少量的准确性。
• 我们可以将 MLP 模型中的总参数数量减少 30 倍！这是因为我们大大减少了 MLP 输入层的大小和隐藏层中神经元的数量。因为现在输入量很小，我们有机会减少隐藏层中神经元的数量。通过增加隐藏层中神经元的数量，您不会获得太多的性能改善。不过，最好还是通过设置不同的值来做一些实验，然后测量性能。
• 应用主成分分析后，模型的过拟合程度降低。我解释了原因。另外，请注意，该模型仍然过拟合，因为我们还没有对该模型应用任何正则化技术。
• 对 MNIST 图像数据应用 PCA 是容易的，因为图像是灰度的，其被表示为二维(2D)张量。PCA 过程对于表示为三维(3D)的 RGB 图像来说是复杂的。阅读这篇文章了解如何将 PCA 应用于 RGB 图像。要了解 RGB 和灰度图像的区别，请阅读这篇文章。

今天的帖子到此结束。

如果您有任何问题或反馈，请告诉我。

我希望你喜欢阅读这篇文章。如果你愿意支持我成为一名作家，请考虑 注册会员 以获得无限制的媒体访问权限。它只需要每月 5 美元，我会收到你的会员费的一部分。

https://rukshanpramoditha.medium.com/membership

非常感谢你一直以来的支持！下一篇文章再见。祝大家学习愉快！

加入我的神经网络和深度学习课程

点击此图片进入我的神经网络和深度学习课程(作者截图)

鲁克山·普拉莫迪塔
2022–06–12

利用马铃薯提取可解释信息

原文：https://towardsdatascience.com/using-potato-for-interpretable-information-extraction-f2081a717eb7

作者图片

关于

本文是对土豆库的介绍。POTATO 是一个独立于语言的人在回路 XAI(可解释的人工智能)框架，用于提取和评估自然语言处理(NLP)中任何分类问题的可解释图特征。

该文章包括:

• 基于规则的文本分类方法简介
• 马铃薯图形模式定义简介
• 自动学习模式
• 人在回路(HITL)框架

介绍

目前，文本处理任务(和许多其他领域一样)由机器学习模型主导。但随着这些模型的参数呈指数增长，可解释性降低了。

其中可解释的模型具有以下特征[1]:

• 公平性——无偏预测
• 隐私 —更少的信息泄露
• 可靠性 — 输入的微小变化不会严重影响输出
• 信任、可审计性——我们知道是什么导致了这些预测
• 可调试 —如果生产中出现错误，我们可以更改型号

最近的 NLP 解决方案在公共基准上取得了最先进的结果，这些解决方案依赖于具有数百万参数的深度学习(DL)模型(例如 BERT [2])。这些模型需要大量的训练数据，很难解释它们的决策[3]。此外，深度学习模型带来了从数据集学习非预期偏差的风险[4]。基于规则的系统可以提供准确和透明的解决方案，但构建和维护起来可能会很费时费力。POTATO 是一个快速原型框架，支持创建基于规则的文本分类器。在 POTATO 中，我们不是使用机器学习模型来直接学习任务，而是学习规则系统。使用这种方法，最终模型保持完全透明。

基于规则的系统

优点

• 基于规则的系统通过设计是可以解释和说明的
• 在“真实世界”的应用中很受欢迎，并且不需要大量的前期投资(不需要 GPU)
• 完全可定制，可调试

缺点

• 难以维护
• 基准测试的性能较差(基准测试主要由 DL 方法决定)
• 需要领域专业知识
• 维护和开发非常耗时

在 POTATO 中，我们试图通过结合机器学习和规则系统来解决基于规则的模型的一些缺点:学习规则！

为了演示规则系统，我们将使用来自 Semeval 2010 关系提取数据集的一个例子。关系抽取是从文本中抽取实体间语义关系的任务。通常在两个实体之间定义。关系具有语义类别(例如，目的地、成分、被使用、被建立等)…)，任务是将关系分类到正确的类别中。

我们将只使用实体-目的地标签。该类的一个示例:

• 钻石戒指(entity1) 被丢进不给糖就捣蛋的人的袋子(entity2) 。

要定义规则，我们可以只使用一个简单的正则表达式:

r”entity1 .* dropped into .* entity2"

但是只使用正则表达式是一种幼稚的方法，因为我们对文本的结构一无所知(标记、语法类别等)…).我们可以使用更高级的 python 包，比如 spaCy 的 TokenMatcher 或 Holmes Extractor。有了它们，我们将能够定义一个更复杂的规则，将词性(POS)标签(单词的语法类别)考虑在内:

pattern = [{‘POS’: ‘VERB’},{‘LOWER’: ‘into’},{‘TEXT’: {‘REGEX’: ‘.*’}},{‘LOWER’: ‘entity2’}]

但是我们可以在图表上写规则，而不是在文本的符号上写规则，这可以利用文本的潜在图表结构。在 POTATO 中，我们使用 networkx python 包来表示图形。有了 networkx，我们为图形表示提供了统一的接口，用户可以在任意图形上书写图形模式。在土豆中，目前我们支持三种类型的图形:AMR【5】， UD (使用节包【6】)和4 lang【7】。在图 1 和图 2 中可以看到一个示例模式，我们可以看到上面定义的示例的 4lang 图(钻石 戒指 被放入不给糖就捣蛋的人的 袋子 )和应用的模式。

图 1:图形上定义的模式示例，ANY 节点意味着我们匹配该节点中的任何字符串(图片由作者提供)

图 2:从文本和应用特征构建的 4lang [7]语义图(图片由作者提供)

与简单的正则表达式模式相反，这种模式也与以下示例相匹配:

The man placed the **entity1** into the **entity2**.
Industries have pushed **entity1** into fragile marine **entity2**.
I am putting the **entity1** into a MySQL **entity2**.
The **entity1** were released into the **entity2**.

使用和设置

POTATO 是一个用 python 编写的人在回路的 XAI 框架，它提供:

• 用于多个图形库(4lang、stanza、AMR)的统一 networkx 接口
• 一个 python 包，用于学习和评估作为规则的可解释图形特征
• 内置于的人在回路(HITL) UI 框架简化了
• REST-API 在生产模式下使用提取的特性进行推理

我们所有的组件都是在 MIT 许可下开源的，可以用 pip 安装。

该工具严重依赖于 tuw-nlp 库来构建图表和匹配特征。您可以使用 pip 安装 tuw-nlp:

pip install **tuw-nlp**

然后按照指令安装软件包。

然后从 pip 安装 POTATO:

pip install **xpotato**

土豆的第一个进口包装:

**from** xpotato.dataset.dataset **import** Dataset
**from** xpotato.models.trainer **import** GraphTrainer

我们将从 Semeval 数据集[8]中手动选取几个句子来展示 POTATO 的能力。

表 1:来自 Semeval 2010 关系抽取数据集的例句[8]

注意，我们用 XXX 和 YYY 替换了有问题的两个实体。

然后，下一步是初始化数据集并提供标签编码。然后将句子解析成图形，为此我们可以使用 parse_graphs() 方法(也需要选择图形格式)。目前我们提供三种类型的图形: ud 、 fourlang 、 amr 。您还需要提供想要解析的语言。目前我们支持英语(en) 和德语(de) 。

我们将使用表 1 中的例子(我们将引用在第一列中指定了 id 的样本)。用 python 初始化的例子可以用下面的代码完成:

dataset = Dataset(sentences, label_vocab={"Other":0, "Entity-Destination(e1,e2)": 1})
dataset.set_graphs(dataset.parse_graphs(graph_format="fourlang"))

检查数据集:

df = dataset.to_dataframe()

我们还可以检查任何被解析的图形

**from** xpotato.models.utils **import** to_dot
**from** graphviz **import** SourceSource(to_dot(dataset.graphs[0]))

作者图片

用土豆写规则

如果数据集准备好了，图形也解析好了，我们就可以编写规则来匹配标签。我们可以手动编写规则，也可以自动提取规则(POTATO 也提供了一个两者都做的前端)。

最简单的规则就是图中的一个节点(本例中是从到):

# The syntax of the rules
# List[List[rules that we want to match]
# List[rules that shouldn't be in the matched graphs]
# Label of the rule
rule_to_match = [[["(u_1 / into)"], [], "Entity-Destination(e1,e2)"]]

初始化规则匹配器:

**from** xpotato.graph_extractor.extract **import** FeatureEvaluator
evaluator = FeatureEvaluator()

匹配数据集中的规则:

*# The function will return a dataframe with the matched instances:* evaluator.match_features(df, rule_to_match)

该函数将返回带有匹配示例的数据帧。该规则将匹配任何包含节点到的句子。在我们的例子中，我们将匹配表 1 中编号为 0、1、2、3、4、5、6、9、14 的例子(例如，科学家将 XXX 倒入品脱 YYY 中。)

我们工具的核心特性之一是我们也能够匹配子图。为了描述一个图形，我们使用彭曼符号。

例如，字符串 (u_1 / into :1 (u_3 / pour)) 将描述一个具有两个节点(“into”和“pour”)以及它们之间带有标签“1”的单个有向边的图。用字符串*(u _ 1/into:1(u _ 2/pour):2(u _ 3/YYY))*描述一个子图，当我们只有单个节点作为特征时，只会返回 3 个例子而不是 9 个。

*#match a simple graph feature* evaluator.match_features(df, [[[“(u_1 / into :1 (u_2 / pour) :2 (u_3 / YYY))”], [], “Entity-Destination(e1,e2)”]])

此功能将在示例 0、1、9 上匹配。

我们还可以添加我们不想匹配的否定特征(这不会匹配存在‘pour’的第一行):

*# match a simple graph feature with a negated feature. 
#The negated features go into the second parameter.* evaluator.match_features(df, [[[“(u_1 / into :2 (u_3 / YYY))”], [“(u_2 / pour)”], “Entity-Destination(e1,e2)”]])

匹配例 2、3、5、6。

如果我们不想指定节点，regex 也可以用来代替节点和边名:

*# regex can be used to match any node (this will match instances 
# where ‘into’ is connected to any node with ‘1’ edge)* evaluator.match_features(df, [[[“(u_1 / into :1 (u_2 / .*) :2 (u_3 / YYY))”], [], “Entity-Destination(e1,e2)”]])

我们还可以从训练数据中提炼正则表达式规则，这将自动替换正则表达式。* '具有高精度的节点。

evaluator.train_feature("Entity-Destination(e1,e2)", "(u_1 / into :1 (u_2 / .*) :2 (u_3 / YYY))", df)

这个返回***(u _ 1/into:1(u _ 2/push | pour):2(u _ 3/YYY))【替换掉了】。 "用 推倒* )*

人在回路规则学习

土豆的想法是:

• 使用子图作为训练简单分类器(LogReg，Random Forest 等)的特征。)
• 仅生成特定边数的子图(以避免大量特征)
• 基于功能重要性向用户建议规则
• 通过 UI，用户可以接受、拒绝、编辑、组合模式
• 子图可以将正则表达式作为节点或边标签
• 可以细化未指定的子图

要从已标记的数据集中自动提取规则，请使用图表要素训练数据集，并根据相关性对其进行排序:

***from** sklearn.model_selection **import** train_test_splittrain, val = train_test_split(df, test_size=0.2, random_state=1234)trainer = GraphTrainer(train)features = trainer.prepare_and_train(min_edge=1)*

特征变量将包含自动提取的规则:

*(u_15 / into :1 (u_26 / push))
(u_15 / into :1 (u_19 / pour :2 (u_0 / xxx)))
(u_15 / into :1 (u_19 / pour))
(u_19 / pour :2 (u_0 / xxx))
(u_15 / into :2 (u_3 / yyy))*

用户界面

除了前面介绍的后端，POTATO 还提供了一个 HITL 用户界面，允许用户从数据集中提取规则。为了启动 HITL 用户界面，我们需要加载一个数据集，作为一组带标签或不带标签的图形。除了我们预定义的格式( ud，4lang，amr )之外，任何有向图都可以加载。建议和评估规则需要基础事实标签(使用上一节描述的特征学习方法)，如果这些不可用，可以在高级模式下启动 UI，使用规则引导和注释标签。一旦加载了数据集，就可以启动 HITL 前端，用户将看到图 3 所示的界面，该界面是使用 streamlit 库构建的。

图 3 所示的前端提供:

• 1 — 数据集浏览器，允许用户查看数据集所有行的文本、图形和标签。查看器使用 graphviz 库呈现图形，并且还提供 PENMAN 符号，用户可以复制该符号来快速编辑规则。
• 2 — 用户可以选择要处理的类(如果处理多标签分类，则为数不多)。
• 3 — 为每个类构建的规则列表保存在一个列表中，它们可以被修改、删除或添加新的特性。
• 4 — 可以在训练和验证数据集上查看和评估规则。
• 5 — 可以通过查看真阳性、假阳性或假阴性示例来分析每个规则的预测。
• 6 — 按钮 suggest new rules 返回一个建议图表的列表以及它们在训练数据上的表现，允许用户选择那些应该添加到规则列表中的图表，这个界面如图 4 所示。对于包含正则表达式的规则， Refine 按钮将用高精度标签的析取来替换正则表达式。这个函数是使用上一节描述的方法实现的。

图 3:土豆的主页面允许用户 1 浏览数据集并查看处理后的图形， 2 选择您想要在其上构建基于规则的系统的类， 3 修改、删除、添加新规则并获得建议， 4 查看所选规则的结果， 5 查看每个规则的示例预测(图片由作者提供)

图 POTATO 建议的模式，按精度排序(图片由作者提供)

如上所述，前端是一个 streamlit 应用程序，我们可以从训练和验证数据集开始。首先用下面的代码保存它们:

*train.to_pickle(“train_dataset.pickle”)
train.to_pickle(“val_dataset.pickle”)*

然后，可以通过一行命令行启动 streamlit 应用程序:

*streamlit run frontend/app.py -- -t train_dataset.pickle -v val_dataset.pickle*

每个类的规则都以 JSON 格式自动保存到磁盘上，这个文件可以被加载用于进一步的编辑或推理。

*streamlit run frontend/app.py -- -t notebooks/train_dataset -v notebooks/val_dataset -hr features.json*

高级模式

如果标签没有提供或者只是部分提供，前端也可以在高级模式下启动，用户可以在开始注释几个例子，然后系统根据提供的例子逐渐提供规则。

然后，可以启动前端:

*streamlit run frontend/app.py -- -t unsupervised_dataset -m advanced*

评价

如果您已经准备好了特性，并且想要在测试集上评估它们，您可以运行:

*python scripts/evaluate.py -d test_dataset.pickle -f features.json*

结果将是一个带有标签和匹配规则的 csv 文件。

服务

如果您已经准备好提取的特性，并希望在生产中使用我们的包进行推理(为句子生成预测)，我们还提供了一个构建在 POTATO 上的 REST API(基于 fastapi )。

首先安装 FastAPI 和uvicon

*pip install fastapi
pip install "uvicorn[standard]"*

要启动服务，您需要为服务设置语言*、图形 _ 类型和特性。这可以通过环境变量来完成。*

示例:

*export FEATURE_PATH=/home/adaamko/projects/POTATO/features/semeval/test_features.json
export GRAPH_FORMAT=ud
export LANG=en*

然后，启动 REST API:

*python services/main.py*

它将在端口 8000 上启动运行在 localhost 上的服务(它还将初始化正确的模型)。

然后，您可以使用任何客户端发出 post 请求:

*curl -X POST localhost:8000 -H 'Content-Type: application/json' -d '{"text":"The suspect pushed the XXX into a deep YYY.\nSparky Anderson is making progress in his XXX from YYY and could return to managing the Detroit Tigers within a week."}'*

答案将是一个带有预测标签的列表(如果没有匹配的规则，它将返回“无”):

*["Entity-Destination(e1,e2)","NONE"]*

streamlit 前端也有一个推理模式，可以使用实现的规则系统进行推理。可以从以下方面入手:

*streamlit run frontend/app.py -- -hr features/semeval/test_features.json -m inference*

结论

POTATO 能够快速构建基于规则的系统，并为 NLP 任务的深度学习模型提供透明、可解释和可审计的替代解决方案。如果你想阅读更多关于这个框架的内容，或者想尝试一下，你可以查看以下资源:

• 你可以查看我们题为土豆:可解释的信息提取框架的论文
• 该框架的代码可以在 GitHub 上获得，使用麻省理工学院的许可:https://github.com/adaamko/POTATO，你也可以查看知识库，获得更多的例子和多个任务的预建规则系统
• 关于这个框架的研讨会的幻灯片也可以得到
• 查看我们关于该工具的快速演示(约 2 分钟)视频:https://youtu.be/PkQ71wUSeNU
• 更长的版本有详细的方法描述和背景研究(约 1 小时):https://youtu.be/6R_V1WfIjsU

参考

[1] Doshivelez 等人，迈向可解释机器学习的严格科学，(2019)

[2] Devlin 等人，用于语言理解的深度双向转换器的预训练，(2019)

[3] Serrano 等人，注意是可解释的吗？，(2019)

[4] Bender 等人，论随机鹦鹉的危险:语言模型会不会太大？(2021)

[5]巴纳雷斯库等，【Sembanking 的抽象意义表示，(2013)

[6]齐等， Stanza:面向多种人类语言的 Python 自然语言处理工具包，(2020)

[7]科尔奈等著，语义学 (2019)

[8] Hendrix 等， SemEval-2010 任务 8:名词对之间语义关系的多向分类 (2010)

使用主成分分析(PCA)进行机器学习

原文：https://towardsdatascience.com/using-principal-component-analysis-pca-for-machine-learning-b6e803f5bf1e

了解如何使用 PCA 来降低数据集的维数

萨姆·张在 Unsplash 上的照片

在机器学习中，经常会有包含大量特征的高维度数据集。高维数据集带来了许多问题，最常见的是过度拟合，这降低了超出训练集中内容的概括能力。因此，您应该采用降维技术来减少数据集中的要素数量。主成分分析 ( PCA )就是这样一种技术。

在本文中，我将讨论 PCA 以及如何将它用于机器学习。特别是，我将向您展示如何在一个样本数据集上应用 PCA。

什么是主成分分析？

简而言之，PCA 是一种降维技术，它将数据集中的一组特征转换为数量更少的特征，称为主成分，同时试图在原始数据集中保留尽可能多的信息:

作者图片

PCA 的主要目的是减少数据集的变量数量，同时尽可能多地保留信息。

在本文中，我不解释 PCA 的工作原理，而是将解释留到下面的视频中，该视频提供了一个很好的 PCA 工作原理的演示。

【https://www.youtube.com/watch?v=FgakZw6K1QQ

理解 PCA 的一个很好的类比是想象自己拍了一张照片。想象你在一场音乐会上，你想通过拍照来捕捉气氛。一张照片只能在二维空间捕捉，而不是在三维空间捕捉大气。虽然维度的减少会导致您丢失一些细节，但是您仍然能够捕获大部分信息。例如，照片中一个人的相对大小告诉我们谁站在前面，谁站在后面。因此，2D 图像仍将使我们能够对大部分信息进行编码，否则这些信息只能在 3D 中获得:

尼古拉斯·格林在 Unsplash 上的照片

同样，在对数据集应用 PCA 后，减少的特征(称为主成分)仍然能够充分表示原始数据集中的信息。

那么在数据集上使用 PCA 有什么优势呢？以下是您希望使用 PCA 的几个原因:

• 删除相关特征。PCA 将帮助您移除所有相关的要素，这种现象称为多重共线性。查找相关的要素非常耗时，尤其是在要素数量很大的情况下。
• 提高机器学习算法性能。随着 PCA 减少了特征的数量，训练模型所需的时间也大大减少了。
• 减少过拟合。通过移除数据集中不必要的要素，PCA 有助于克服过度拟合。

另一方面，PCA 也有其缺点:

• 自变量现在更难解释了。PCA 把你的特征简化成更少的组件。每个组件现在都是原始特征的线性组合，这使得它的可读性和可解释性更差。
• 信息丢失。如果不小心选择正确的组件数量，可能会发生数据丢失。
• 特征缩放。因为 PCA 是一个方差最大化练习，所以 PCA 要求在处理之前对特征进行缩放。

在数据集中有大量要素的情况下，PCA 非常有用。

在机器学习中，PCA 是一种无监督的机器学习算法。

使用样本数据集

在这篇文章中，我将使用来自 sklearn 的经典乳腺癌数据集来演示 PCA:

from sklearn.datasets import load_breast_cancer
breast_cancer = load_breast_cancer()

乳腺癌数据集是说明 PCA 的一个很好的例子，因为它具有大量的特征，并且所有特征的数据类型都是浮点数。让我们打印该数据集中的要素名称和数量:

print(breast_cancer.feature_names)
print(len(breast_cancer.feature_names))

您应该看到以下内容:

['mean radius' 'mean texture' 'mean perimeter' 'mean area'
 'mean smoothness' 'mean compactness' 'mean concavity'
 'mean concave points' 'mean symmetry' 'mean fractal dimension'
 'radius error' 'texture error' 'perimeter error' 'area error'
 'smoothness error' 'compactness error' 'concavity error'
 'concave points error' 'symmetry error' 'fractal dimension error'
 'worst radius' 'worst texture' 'worst perimeter' 'worst area'
 'worst smoothness' 'worst compactness' 'worst concavity'
 'worst concave points' 'worst symmetry' 'worst fractal dimension']
30

让我们也打印出目标，并检查目标的含义和目标的分布:

import numpy as npprint(breast_cancer.target) 
print(breast_cancer.target_names) 
print(np.array(np.unique(breast_cancer.target, return_counts=True)))

您应该会看到类似这样的内容:

[0 0 0 0 0 0 0 0 0 0 0 0 0 0 
 ...
 1 1 1 1 1 1 1 0 0 0 0 0 0 1]
['malignant' 'benign']
[[  0   1]
 [212 357]]

目标值 0 表示肿瘤是恶性的，而 1 表示肿瘤是良性的。目标不平衡，但不严重。

检查特征和目标之间的关系

此时，能够可视化每个特征如何影响诊断是有用的——肿瘤是恶性的还是良性的。让我们为每个特征绘制一个直方图，然后用颜色区分恶性和良性肿瘤:

import numpy as np
import matplotlib.pyplot as plt_, axes = plt.subplots(6,5, figsize=(15, 15))malignant = breast_cancer.data[breast_cancer.target==0]
benign = breast_cancer.data[breast_cancer.target==1]ax = axes.ravel()                     # flatten the 2D arrayfor i in range(30):                   # for each of the 30 features
    bins = 40 #---plot histogram for each feature---
    ax[i].hist(malignant[:,i], bins=bins, color='r', alpha=.5)
    ax[i].hist(benign[:,i], bins=bins, color='b', alpha=0.3) #---set the title---
    ax[i].set_title(breast_cancer.feature_names[i], fontsize=12)    #---display the legend---
    ax[i].legend(['malignant','benign'], loc='best', fontsize=8)

plt.tight_layout()
plt.show()

您应该会看到以下输出:

作者图片

对于每个特征，如果两个直方图是分开的，这意味着该特征是重要的，并且它直接影响目标(诊断)。例如，如果您查看平均半径特征的直方图，您会发现肿瘤越大，肿瘤越有可能是恶性的(红色):

作者图片

另一方面，平滑度误差功能并不能真正告诉您肿瘤是恶性还是良性:

作者图片

将数据加载到数据帧中

下一步是将乳腺癌数据加载到熊猫数据框架中:

import pandas as pddf = pd.DataFrame(breast_cancer.data, 
                  columns = breast_cancer.feature_names)
df['diagnosis'] = breast_cancer.target
df

您应该会看到以下输出:

方法 1-使用所有特征训练模型

在我们对数据集执行 PCA 之前，让我们使用逻辑回归来训练一个使用数据集中所有 30 个特征的模型，并看看它的表现如何:

from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_splitX = df.iloc[:,:-1]      
y = df.iloc[:,-1]#---perform a split---
random_state = 12
X_train, X_test, y_train, y_test = \
    train_test_split(X, y,
                     test_size = 0.3,
                     shuffle = True,
                     random_state=random_state)#---train the model using Logistic Regression---
log_reg = LogisticRegression(max_iter = 5000)
log_reg.fit(X_train, y_train)#---evaluate the model---
log_reg.score(X_test,y_test)

该模型的精度为:

0.9239766081871345

方法 2-使用简化的特征训练模型

对于下一个方法，让我们检查各种特性，并尝试消除那些与目标最不相关的特性。同时，我们还希望移除那些显示多重共线性的特征。目的是减少特征的数量，看看是否可以提高模型的精度。

获取相关因子

让我们首先获得每个特征相对于目标(诊断)的相关性:

df_corr = df.corr()['diagnosis'].abs().sort_values(ascending=False)
df_corr

您应该看到以下内容:

diagnosis                  1.000000
worst concave points       0.793566
worst perimeter            0.782914
mean concave points        0.776614
worst radius               0.776454
mean perimeter             0.742636
worst area                 0.733825
mean radius                0.730029
mean area                  0.708984
mean concavity             0.696360
worst concavity            0.659610
mean compactness           0.596534
worst compactness          0.590998
radius error               0.567134
perimeter error            0.556141
area error                 0.548236
worst texture              0.456903
worst smoothness           0.421465
worst symmetry             0.416294
mean texture               0.415185
concave points error       0.408042
mean smoothness            0.358560
mean symmetry              0.330499
worst fractal dimension    0.323872
compactness error          0.292999
concavity error            0.253730
fractal dimension error    0.077972
smoothness error           0.067016
mean fractal dimension     0.012838
texture error              0.008303
symmetry error             0.006522
Name: diagnosis, dtype: float64

然后，我们提取与目标具有相对高相关性的所有那些特征(我们任意地将阈值设置为 0.6):

# get all the features that has at least 0.6 in correlation to the 
# target
features = df_corr[df_corr > 0.6].index.to_list()[1:]
features                          # without the 'diagnosis' column

现在你看到了以下特征:

['worst concave points',
 'worst perimeter',
 'mean concave points',
 'worst radius',
 'mean perimeter',
 'worst area',
 'mean radius',
 'mean area',
 'mean concavity',
 'worst concavity']

但是很明显，有几个特征是相关的-例如，半径、周长和面积都是相关的。其中一些功能必须删除。

检查多重共线性

让我们移除那些显示多重共线性的要素:

import pandas as pd
from sklearn.linear_model import LinearRegressiondef calculate_vif(df, features):    
    vif, tolerance = {}, {} # all the features that you want to examine
    for feature in features:
        # extract all the other features you will regress against
        X = [f for f in features if f != feature]        
        X, y = df[X], df[feature] # extract r-squared from the fit
        r2 = LinearRegression().fit(X, y).score(X, y)                

        # calculate tolerance
        tolerance[feature] = 1 - r2 # calculate VIF
        vif[feature] = 1/(tolerance[feature])
    # return VIF DataFrame
    return pd.DataFrame({'VIF': vif, 'Tolerance': tolerance})calculate_vif(df,features)

您应该会看到以下输出:

作者图片

您的目标是移除 VIF 大于 5 的那些要素。您可以用不同的特性反复调用calculate_vif()函数，直到您得到一个所有 VIF 值都小于 5 的特性集。

经过一些尝试，我将范围缩小到 3 个特征:

# try to reduce those feature that has high VIF until each feature 
# has VIF less than 5
features = [
 **'worst concave points',
    'mean radius',
    'mean concavity',** ]
calculate_vif(df,features)

他们的 VIF 价值观看起来很棒:

作者图片

训练模型

随着 30 个特征减少到 3 个，现在让我们使用逻辑回归来训练模型:

from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_splitX = df.loc[:,features]            # get the reduced features in the 
                                  # dataframe
y = df.loc[:,'diagnosis']# perform a split
X_train, X_test, y_train, y_test = \
    train_test_split(X, y, 
                     test_size = 0.3,
                     shuffle = True,                                                    
                     random_state=random_state)log_reg = LogisticRegression()
log_reg.fit(X_train, y_train)
log_reg.score(X_test,y_test)

这一次，精确度下降到:

0.847953216374269

方法 3-使用简化特征(PCA)训练模型

最后，让我们将 PCA 应用于数据集，看看是否可以训练出更好的模型。

执行标准缩放

还记得 PCA 对缩放很敏感吗？因此，第一步是对 30 个特征执行标准缩放:

from sklearn.preprocessing import StandardScaler# get the features and label from the original dataframe
X = df.iloc[:,:-1]
y = df.iloc[:,-1]# performing standardization
sc = StandardScaler()
X_scaled = sc.fit_transform(X)

应用主成分分析

您现在可以使用 sklearn.decomposition 模块中的PCA类将 PCA 应用于特性:

from sklearn.decomposition import PCAcomponents = None
pca = PCA(n_components = components)# perform PCA on the scaled data
pca.fit(X_scaled)

PCA 类的初始化器有一个名为n_components的参数。您可以为其提供下列值之一:

• 一个整数，用于指示要将要素减少到多少个主分量。
• 0
• 【 . In this case, the number of components returned will be the same as the number of original features in the dataset

Once the components are determined using the 【 method, you can print out the 之间的浮点数解释差异:

# print the explained variances
print("Variances (Percentage):")
print(pca.explained_variance_ratio_ * 100)
print()

您应该会看到以下输出:

Variances (Percentage):
[4.42720256e+01 1.89711820e+01 9.39316326e+00 6.60213492e+00
 5.49576849e+00 4.02452204e+00 2.25073371e+00 1.58872380e+00
 1.38964937e+00 1.16897819e+00 9.79718988e-01 8.70537901e-01
 8.04524987e-01 5.23365745e-01 3.13783217e-01 2.66209337e-01
 1.97996793e-01 1.75395945e-01 1.64925306e-01 1.03864675e-01
 9.99096464e-02 9.14646751e-02 8.11361259e-02 6.01833567e-02
 5.16042379e-02 2.72587995e-02 2.30015463e-02 5.29779290e-03
 2.49601032e-03 4.43482743e-04]

那么如何解读上面的输出呢？你可以这样理解:

• 仅第一个分量就捕获了数据中约 44%的可变性
• 第二个捕获了数据中大约 19%的可变性，等等。
• 这 30 个组件总共捕获了 100%的数据可变性。

理解上述结果的一个更简单的方法是打印累积差异:

print("Cumulative Variances (Percentage):")
print(pca.explained_variance_ratio_.cumsum() * 100)
print()

您现在应该会看到以下输出:

Cumulative Variances (Percentage):
[ 44.27202561  63.24320765  72.63637091  79.23850582  84.73427432
  88.75879636  91.00953007  92.59825387  93.98790324  95.15688143
  96.13660042  97.00713832  97.81166331  98.33502905  98.64881227
  98.91502161  99.1130184   99.28841435  99.45333965  99.55720433
  99.65711397  99.74857865  99.82971477  99.88989813  99.94150237
  99.96876117  99.99176271  99.99706051  99.99955652 100\.        ]

现在，您可以将累计差异解释如下:

• 仅第一个分量就捕获了数据中约 44%的可变性
• 前两个组件捕获数据中大约 63%的可变性，依此类推。
• 前 8 个分量一起捕获了数据中大约 92.6%的可变性。

查看累积方差的直观方法是绘制 scree 图。

碎石图是主成分的线形图。

# plot a scree plot
components = len(pca.explained_variance_ratio_) \
    if components is None else componentsplt.plot(range(1,components+1), 
         np.cumsum(pca.explained_variance_ratio_ * 100))
plt.xlabel("Number of components")
plt.ylabel("Explained variance (%)")

scree 图使您可以轻松直观地看到捕捉数据中各种可变性所需的组件数量:

作者图片

现在，让我们应用主成分分析，根据期望的解释方差(比如 85%)找到期望的组件数量:

from sklearn.decomposition import PCApca = **PCA(n_components = 0.85)**
pca.fit(X_scaled)print("Cumulative Variances (Percentage):")
print(np.cumsum(pca.explained_variance_ratio_ * 100))components = len(pca.explained_variance_ratio_)
print(f'Number of components: {components}')# Make the scree plot
plt.plot(range(1, components + 1), np.cumsum(pca.explained_variance_ratio_ * 100))
plt.xlabel("Number of components")
plt.ylabel("Explained variance (%)")

您将获得以下输出:

Cumulative Variances (Percentage):
[44.27202561 63.24320765 72.63637091 79.23850582 84.73427432 88.75879636]
Number of components: 6

正如您从图表中看到的，需要 6 个组件来涵盖数据中 85%的可变性:

作者图片

您还可以使用pca对象的components_属性找出对每个组件有贡献的每个特性的重要性:

pca_components = abs(**pca.components_**)
print(pca_components)

您将看到如下输出:

[[2.18902444e-01 1.03724578e-01 2.27537293e-01 2.20994985e-01
  1.42589694e-01 2.39285354e-01 2.58400481e-01 2.60853758e-01
  1.38166959e-01 6.43633464e-02 2.05978776e-01 1.74280281e-02
  2.11325916e-01 2.02869635e-01 1.45314521e-02 1.70393451e-01
  1.53589790e-01 1.83417397e-01 4.24984216e-02 1.02568322e-01
  2.27996634e-01 1.04469325e-01 2.36639681e-01 2.24870533e-01
  1.27952561e-01 2.10095880e-01 2.28767533e-01 2.50885971e-01
  1.22904556e-01 1.31783943e-01]
 [2.33857132e-01 5.97060883e-02 2.15181361e-01 2.31076711e-01
  1.86113023e-01 1.51891610e-01 6.01653628e-02 3.47675005e-02
  1.90348770e-01 3.66575471e-01 1.05552152e-01 8.99796818e-02
  8.94572342e-02 1.52292628e-01 2.04430453e-01 2.32715896e-01
  1.97207283e-01 1.30321560e-01 1.83848000e-01 2.80092027e-01
  2.19866379e-01 4.54672983e-02 1.99878428e-01 2.19351858e-01
  1.72304352e-01 1.43593173e-01 9.79641143e-02 8.25723507e-03
  1.41883349e-01 2.75339469e-01]
 [8.53124284e-03 6.45499033e-02 9.31421972e-03 2.86995259e-02
  1.04291904e-01 7.40915709e-02 2.73383798e-03 2.55635406e-02
  4.02399363e-02 2.25740897e-02 2.68481387e-01 3.74633665e-01
  2.66645367e-01 2.16006528e-01 3.08838979e-01 1.54779718e-01
  1.76463743e-01 2.24657567e-01 2.88584292e-01 2.11503764e-01
  4.75069900e-02 4.22978228e-02 4.85465083e-02 1.19023182e-02
  2.59797613e-01 2.36075625e-01 1.73057335e-01 1.70344076e-01
  2.71312642e-01 2.32791313e-01]
 [4.14089623e-02 6.03050001e-01 4.19830991e-02 5.34337955e-02
  1.59382765e-01 3.17945811e-02 1.91227535e-02 6.53359443e-02
  6.71249840e-02 4.85867649e-02 9.79412418e-02 3.59855528e-01
  8.89924146e-02 1.08205039e-01 4.46641797e-02 2.74693632e-02
  1.31687997e-03 7.40673350e-02 4.40733510e-02 1.53047496e-02
  1.54172396e-02 6.32807885e-01 1.38027944e-02 2.58947492e-02
  1.76522161e-02 9.13284153e-02 7.39511797e-02 6.00699571e-03
  3.62506947e-02 7.70534703e-02]
 [3.77863538e-02 4.94688505e-02 3.73746632e-02 1.03312514e-02
  3.65088528e-01 1.17039713e-02 8.63754118e-02 4.38610252e-02
  3.05941428e-01 4.44243602e-02 1.54456496e-01 1.91650506e-01
  1.20990220e-01 1.27574432e-01 2.32065676e-01 2.79968156e-01
  3.53982091e-01 1.95548089e-01 2.52868765e-01 2.63297438e-01
  4.40659209e-03 9.28834001e-02 7.45415100e-03 2.73909030e-02
  3.24435445e-01 1.21804107e-01 1.88518727e-01 4.33320687e-02
  2.44558663e-01 9.44233510e-02]
 [1.87407904e-02 3.21788366e-02 1.73084449e-02 1.88774796e-03
  2.86374497e-01 1.41309489e-02 9.34418089e-03 5.20499505e-02
  3.56458461e-01 1.19430668e-01 2.56032561e-02 2.87473145e-02
  1.81071500e-03 4.28639079e-02 3.42917393e-01 6.91975186e-02
  5.63432386e-02 3.12244482e-02 4.90245643e-01 5.31952674e-02
  2.90684919e-04 5.00080613e-02 8.50098715e-03 2.51643821e-02
  3.69255370e-01 4.77057929e-02 2.83792555e-02 3.08734498e-02
  4.98926784e-01 8.02235245e-02]]

每个要素的重要性通过输出中相应值的大小来反映，大小越大，重要性越高。下图显示了如何解释上述结果:

作者图片

出于好奇，让我们打印出对 6 个组成部分贡献最大的前 4 个特征:

print('Top 4 most important features in each component')
print('===============================================')
for row in range(pca_components.shape[0]):
    # get the indices of the top 4 values in each row
    temp = np.argpartition(-(pca_components[row]), 4)

    # sort the indices in descending order
    indices = temp[np.argsort((-pca_components[row])[temp])][:4]

    # print the top 4 feature names
    print(f'Component {row}: {df.columns[indices].to_list()}')

您将看到以下输出:

Top 4 most important features in each component
===============================================
Component 0: ['mean concave points', 'mean concavity', 
              'worst concave points', 'mean compactness']
Component 1: ['mean fractal dimension', 'fractal dimension error', 
              'worst fractal dimension', 'mean radius']
Component 2: ['texture error', 'smoothness error', 
              'symmetry error', 'worst symmetry']
Component 3: ['worst texture', 'mean texture', 
              'texture error', 'mean smoothness']
Component 4: ['mean smoothness', 'concavity error', 
              'worst smoothness', 'mean symmetry']
Component 5: ['worst symmetry', 'symmetry error', 
              'worst smoothness', 'mean symmetry']

将所有 30 列转换为 6 个主成分

现在，您可以将数据集中 30 列的标准化数据转换为 6 个主要成分:

X_pca = pca.transform(X_scaled)
print(X_pca.shape)
print(X_pca)

您应该得到以下输出:

(569, 6)
[[ 9.19283683  1.94858307 -1.12316616  
   3.6337309  -1.19511012  1.41142445]
 [ 2.3878018  -3.76817174 -0.52929269  
   1.11826386  0.62177498  0.02865635]
 [ 5.73389628 -1.0751738  -0.55174759  
   0.91208267 -0.1770859   0.54145215]
 ...
 [ 1.25617928 -1.90229671  0.56273053 
   -2.08922702  1.80999133 -0.53444719]
 [10.37479406  1.67201011 -1.87702933 
   -2.35603113 -0.03374193  0.56793647]
 [-5.4752433  -0.67063679  1.49044308
  -2.29915714 -0.18470331  1.61783736]]

创建机器学习管道

现在，让我们创建一个机器学习管道，以便我们可以正式化整个过程:

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA
from sklearn.linear_model import LogisticRegression_sc = StandardScaler()
_pca = PCA(n_components = components)
_model = LogisticRegression()log_regress_model = Pipeline([
    ('std_scaler', _sc),
    ('pca', _pca),
    ('regressor', _model)
])

然后，我们将数据集分为训练集和测试集，并使用训练集训练模型:

# perform a split
X_train, X_test, y_train, y_test = \
    train_test_split(X, y, 
                     test_size=0.3,
                     shuffle=True, 
                     random_state=random_state)# train the model using the PCA components
log_regress_model.fit(X_train,y_train)

让我们对模型进行评分，看看它的表现如何:

log_regress_model.score(X_test,y_test)

我们现在有以下准确度:

0.9824561403508771

摘要

在本文中，我们讨论了 PCA 背后的思想以及使用它的利与弊。特别是，我们训练了三个模型:

• 使用乳腺癌数据集中的所有 30 个特征
• 仅使用数据集中的 3 个要素
• 将 PCA 应用于数据集，然后使用 6 个组件进行训练

对于您自己的数据集，尝试一下我在本文中演示的各种方法，看看哪种方法性能更好，将会很有用。

如果你喜欢阅读我的文章，并且认为它对你的职业/学习有所帮助，请考虑注册成为一名灵媒会员。每月 5 美元，你可以无限制地访问 Medium 上的所有文章(包括我的)。如果你使用下面的链接注册，我会赚一小笔佣金(不需要你额外付费)。你的支持意味着我将能够投入更多的时间来写这样的文章。

https://weimenglee.medium.com/membership