TowardsDataScience 博客中文翻译 2020（二百五十五）

原文：TowardsDataScience Blog

协议：CC BY-NC-SA 4.0

交叉验证和超参数调整:如何优化你的机器学习模型

原文：https://towardsdatascience.com/cross-validation-and-hyperparameter-tuning-how-to-optimise-your-machine-learning-model-13f005af9d7d?source=collection_archive---------0-----------------------

Alexis Baydoun 在 Unsplash 上拍摄的照片

非常准确地预测 Fitbit 的睡眠分数

在本文的前两部分，我获取并预处理了 Fitbit 睡眠数据，将数据分为训练集、验证集和测试集，训练了三个不同的机器学习模型，并比较了它们的性能。

在第 2 部分中，我们看到使用随机森林和极端梯度增强的默认超参数并评估验证集上的模型性能导致多元线性回归表现最佳，随机森林和梯度增强回归器表现稍差。

在文章的这一部分，我将讨论只使用一个验证集的缺点，我们如何解决这些缺点，以及我们如何调整模型超参数来提高性能。让我们开始吧。

交叉验证

简单训练、验证和测试分割的缺点

在本文的第 2 部分中，我们将数据分为训练集、验证集和测试集，在训练集上训练我们的模型，并在验证集上评估它们。我们还没有接触测试集，因为它旨在作为一个保留集，代表以前从未见过的数据，一旦我们觉得机器学习模型准备好进行最终测试，这些数据将用于评估机器学习模型的泛化能力。

因为我们只将数据分为一组训练数据和一组验证数据，所以我们的模型的性能指标高度依赖于这两组数据。它们只被训练和评估一次，因此性能取决于那一次评估，并且当对相同数据的不同子集进行训练和评估时，性能可能会非常不同，这仅仅是因为如何挑选子集的性质。

如果我们可以多次进行训练和验证测试，每次针对不同的数据子集，每次都训练和评估我们的模型，并在多次评估中查看模型的平均性能，会怎么样？这正是 K 倍交叉验证背后的想法。

k 倍交叉验证

在 K-fold 交叉验证(CV)中，我们仍然从数据集中的剩余数据中分离出一个测试/保留集，用于我们模型的最终评估。剩余的数据，即除测试集之外的所有数据，被分成 K 个折叠(子集)。交叉验证然后遍历折叠，并且在每次迭代中使用 K 个折叠中的一个作为验证集，同时使用所有剩余的折叠作为训练集。重复这个过程，直到每个折叠都被用作验证集。以下是五重交叉验证的流程:

通过在相同训练数据的不同子集上对模型进行 K 次训练和测试，我们可以更准确地表示我们的模型在以前从未见过的数据上的表现。在 K-fold CV 中，我们在每次迭代后对模型进行评分，并计算所有评分的平均值，以获得与仅使用一个训练和验证集相比模型表现如何的更好表示。

Python 中的 k 重交叉验证

因为 Fitbit sleep 数据集比较小，所以我准备使用 4 重交叉验证，比较目前使用的三种模型:多元线性回归、随机森林和极端梯度提升回归器。

请注意，4 重 CV 也可以很好地与第 2 部分中的训练和验证数据进行比较，因为我们将数据分为 75%的训练数据和 25%的验证数据。一个四重 CV 本质上做同样的事情，仅仅四次，并且每次使用不同的子集。我创建了一个函数，它将我们想要比较的模型列表、特征数据、目标变量数据和我们想要创建的折叠数作为输入。该函数计算我们之前使用的性能测量，并返回一个表，其中包含所有模型的平均值以及每种类型的测量在每个折叠中的分数，以备我们进一步研究。下面是函数:

现在，我们可以创建一个要使用的模型列表，并使用 4 重交叉验证调用上面的函数:

生成的比较表如下所示:

使用一个 4 重 CV，随机森林回归器在所有性能指标上都优于其他两个模型。但是在第 2 部分中，我们看到多元线性回归有最好的性能指标，为什么会改变呢？

为了理解为什么交叉验证会产生与第 2 部分中的简单训练和验证不同的分数，我们需要更仔细地看看模型在每个折叠中的表现。上面的 cv_comparison()函数也为每个折叠返回每个不同模型的所有分数列表。让我们来看看三个模型的 R 平方在每次折叠时的比较。为了得到表格格式的结果，让我们快速地将它转换成数据帧:

上表清楚地表明了为什么从四重 CV 获得的分数不同于训练和验证集的分数。R 平方因褶皱而异，特别是对于极端梯度增强和多元线性回归。这也说明了为什么使用交叉验证如此重要，尤其是对于小数据集。如果你只依赖一个简单的训练和验证集，你的结果可能会有很大的不同，这取决于你最终得到的数据的分割。

既然我们知道了什么是交叉验证以及它为什么重要，那么让我们看看是否可以通过调整超参数从我们的模型中获得更多。

超参数调谐

不同于在模型训练期间学习并且不能任意设置的模型参数，超参数是可以由用户在训练机器学习模型之前设置的参数。随机森林中超参数的示例包括森林中决策树的数量、每次分割时要考虑的最大要素数量或树的最大深度。

正如我之前提到的，寻找最佳超参数没有一个放之四海而皆准的解决方案。对于一个机器学习问题表现良好的一组超参数可能在另一个问题上表现不佳。那么我们如何计算出最优超参数是什么呢？

一种可能的方法是使用有根据的猜测作为起点来手动调整超参数，改变一些超参数，训练模型，评估其性能，并重复这些步骤，直到我们对性能满意为止。这听起来像是一个不必要的乏味的方法，事实也的确如此。

比较超参数调音和吉他调音。你可以选择用耳朵给吉他调音，这需要大量的练习和耐心，而且可能永远不会达到最佳效果，尤其是如果你是初学者的话。幸运的是，有电吉他调音器可以通过解释吉他弦的声波并显示其读数来帮助你找到正确的音调。你仍然需要使用机器头来调弦，但这个过程会快得多，电动调音器可以确保你的调弦接近最佳。那么电吉他调音师的机器学习等同于什么呢？

随机网格搜索交叉验证

在 scikit-learn 中，一种最流行的调整机器学习超参数的方法被称为 RandomizedSearchCV()。我们来剖析一下这是什么意思。

在随机网格搜索交叉验证中，我们首先创建一个超参数网格，我们希望优化这些超参数的值。让我们看一个随机森林回归器的超参数网格示例，以及如何设置它:

首先，我们为每个想要调优的超参数创建一个可能值的列表，然后我们使用一个包含键值对的字典来设置网格，如上所示。为了找到和理解机器学习模型的超参数，你可以查看模型的官方文档，参见随机森林回归器的文档这里。

生成的网格如下所示:

顾名思义，随机网格搜索交叉验证使用交叉验证来评估模型性能。随机搜索意味着该算法从网格中为每个超参数随机选择一个值，并使用超参数的随机组合来评估模型，而不是尝试所有可能的超参数组合(在我们的示例中为 27，216 个组合)。

尝试所有可能的组合在计算上会非常昂贵，并且需要很长时间。随机选择超参数可以显著加快这一过程，并且通常为尝试所有可能的组合提供了一个类似的好解决方案。让我们看看如何使用随机网格搜索交叉验证。

随机森林的超参数调整

使用之前创建的网格，我们可以为我们的随机森林回归量找到最佳超参数。我将使用三重 CV，因为数据集相对较小，并且运行 200 个随机组合。因此，总的来说，随机网格搜索 CV 将训练和评估 600 个模型(200 个组合的 3 倍)。因为与极端梯度提升等其他机器学习模型相比，随机森林往往计算缓慢，所以运行这么多模型需要几分钟时间。一旦该过程完成，我们就可以获得最佳的超参数。

下面是如何使用 RandomizedSearchCV():

我们将在最终模型中使用这些超参数，并在测试集上进行测试。

超参数调谐，实现极端梯度提升

对于我们的极端梯度推进回归器，过程基本上与随机森林相同。由于模型的性质，我们试图优化的一些超参数是相同的，一些是不同的。你可以在这里找到 XGBRegressor 的超参数的完整列表和解释。我们再次创建网格:

生成的网格如下所示:

为了使性能评估具有可比性，我还将使用具有 200 种组合的 3 重 CV 进行极端梯度提升:

最佳超参数如下:

同样，这些将在最终模型中使用。

虽然对一些人来说这可能是显而易见的，但我只想在这里提一下:我们不为多元线性回归进行超参数优化的原因是因为模型中没有要调整的超参数，它只是一个多元线性回归。

既然我们已经获得了最佳超参数(至少在我们的交叉验证方面),我们终于可以根据我们从分析一开始就坚持的测试数据来评估我们的模型了！

最终模型评估

在评估了我们的机器学习模型的性能并找到最佳超参数之后，是时候对模型进行最终测试了——全能坚持集。

为了做到这一点，我们在迄今为止所有评估中使用的全部 80%的数据上训练模型，即除测试集之外的所有数据。我们使用在上一部分中找到的超参数，然后比较我们的模型在测试集上的表现。

让我们创建并训练我们的模型:

我定义了一个函数，该函数对所有最终模型进行评分，并创建一个数据框架来简化比较:

用我们的三个最终模型调用该函数，并调整列标题，得到以下最终评估结果:

获胜者是:随机森林回归者！

随机森林在测试集上实现了 80%的 R 平方和 97.6%的准确性，这意味着它的预测平均只相差约 2.4%。还不错！

多元线性回归的表现并不落后，但极端梯度推进未能达到其在该分析中的宣传效果。

结论意见

想出这整个分析和实际进行分析的过程充满了乐趣。一段时间以来，我一直试图弄清楚 Fitbit 是如何计算睡眠分数的，很高兴对它有了更好的理解。最重要的是，我设法建立了一个机器学习模型，可以非常准确地预测睡眠分数。话虽如此，我还是想强调几点:

1. 正如我在第 2 部分中提到的，多元线性回归系数的解释可能不准确，因为要素之间存在高度的多重共线性。
2. 我用于此分析的数据集相当小，因为它依赖于从 Fitbit 获得的 286 个数据点。这限制了结果的通用性，需要更大的数据集才能训练更稳健的模型。
3. 这种分析只使用了一个人的 Fitbit 睡眠数据，因此可能无法很好地推广到具有不同睡眠模式、心率等的其他人。

我希望你喜欢这篇关于如何使用机器学习来预测 Fitbit 睡眠分数的透彻分析，并了解不同睡眠阶段的重要性以及睡眠时间。

我非常感谢建设性的反馈，您可以随时通过 LinkedIn 联系我。

感谢阅读！

交叉验证

原文：https://towardsdatascience.com/cross-validation-c4fae714f1c5?source=collection_archive---------23-----------------------

验证您的机器学习模型性能

来源:维基百科

交叉验证可以是各种模型验证技术中的任何一种，这些模型验证技术用于评估预测模型将多好地推广到该模型以前没有见过的独立数据集。因此，它通常用于我们预测某些事情，并且我们希望粗略估计我们的预测模型在实践中的表现。

“在创建任何机器学习模型之前，我们必须知道什么是交叉验证，以及如何选择最佳的交叉验证”——Abhishek tha kur，Kaggle 的第一位 4x 特级大师

在这篇文章结束时，你将对流行的交叉验证技术有一个很好的理解，我们如何使用 scikit-learn 实现它们，以及如何选择给定特定问题的正确 CV。

流行的交叉验证技术

本质上，选择正确的交叉验证技术归结于我们手头的数据，因此为什么一个交叉验证的选择可能对另一组数据起作用，也可能不起作用。然而，采用交叉验证技术的目标保持不变，我们希望估计预测模型对未知数据的预期拟合水平，因为有了这些信息，我们可以做出必要的调整来制作预测模型(如果需要)或决定使用完全不同的模型。

基于保留的交叉验证

我可能会受到一些经验数据科学家、机器学习和/或深度学习从业者对不恰当术语的滥用，因为交叉验证通常允许预测模型在各种拆分上进行训练和测试，而保留集则不允许。不管怎样，当我们把数据分成一个训练集和一个测试集时，就需要进行基于坚持的交叉验证。这通常是您要实现的第一个验证技术，也是最容易理解的。它包括把你的数据分成不同的部分，你可以在一个数据集上训练你的预测模型，并在测试集上测试它。

注意:有些人更进一步，会有一个训练数据集、一个验证数据集和测试数据集。验证数据集将用于调整预测模型，测试集将用于测试模型的泛化能力。

在划分数据时，要记住的一点是，您必须确定哪些数据用于训练，哪些用于测试。我见过从 60%(训练)-40%(测试)到 80%(训练)-20%(测试)的各种分裂。我相信可以有把握地说，60%-80%的数据应该用于训练预测模型，其余的可能直接用于测试集(或者再次分成验证集和测试集)。

图 1:基于拒绝的验证的例子(来源: Adi Bronshtein ，Python 中的训练/测试分割和交叉验证)

# [https://bit.ly/3fUuyOy](https://bit.ly/3fUuyOy)**import** **numpy** **as** **np**
**from** **sklearn.model_selection** **import** train_test_split
X, y = np.arange(10).reshape((5, 2)), range(5)
**print**(X)
array([[0, 1],
       [2, 3],
       [4, 5],
       [6, 7],
       [8, 9]])**print(**list(y))
[0, 1, 2, 3, 4]

当我们有一个非常大的数据集时，执行基于拒绝的验证技术是最有效的。由于不需要在各种分割上进行测试，这种技术使用的计算能力要少得多，因此使其成为在大型数据集上进行验证的首选策略。

k 倍交叉验证

我简单地提到了由上述“c 组成的交叉验证，ross 验证通常允许预测模型在各种拆分上进行训练和测试，而保留集则不允许— 换句话说，交叉验证是一个重采样的过程。当“k”出现在机器学习讨论中时，它通常用于表示常数值，例如 k-means 聚类中的 k 是指聚类的数量，k 近邻中的 k 是指执行多元投票(用于分类)时要考虑的近邻数量。这种模式也适用于 K-Fold 交叉验证，其中 K 表示给定数据样本应该分成的组的数量。

在 k 倍交叉验证中，原始样本被随机分成 k 个大小相等的组。从 k 个组中，一个组将作为保留组被移除，并且剩余的组将是训练数据。然后，将预测模型拟合到训练数据上，并在保留集上进行评估。这个过程是 k 次，因此所有的组正好服务一次作为坚持组。

图 KFold 交叉验证的例子(来源: Scikit-Learn 文档)

**#** [https://bit.ly/2POmqVb](https://bit.ly/2POmqVb)**import** **numpy** **as** **np**
**from** **sklearn.model_selection** **import** KFoldX = np.array([[1, 2], [3, 4], [1, 2], [3, 4]])
y = np.array([1, 2, 3, 4])
kf = KFold(n_splits=2)
**print(**kf.get_n_splits(X))
2**print**(kf)
KFold(n_splits=2, random_state=None, shuffle=False)**>>> for** train_index, test_index **in** kf.split(X):
**... **    **print**("TRAIN:", train_index, "TEST:", test_index)
**... **    X_train, X_test = X[train_index], X[test_index]
**... **    y_train, y_test = y[train_index], y[test_index]
TRAIN: [2 3] TEST: [0 1]
TRAIN: [0 1] TEST: [2 3]

由于易于理解，k-fold 交叉验证相当流行。并且与执行基于拒绝的验证相比，它通常会产生偏差较小的结果。这种技术通常是回归问题的一个很好的起点，尽管如果目标变量的分布不一致，使用分层 k-fold 可能更好，这将需要目标变量的宁滨。需要考虑的是 k 的配置，它必须分割数据，以便数据样本的每个训练/测试分割足够大，能够在统计上代表更广泛的数据集。

分层 K 折叠

到目前为止，我们介绍的两种技术在许多情况下都是相对有效的，尽管当目标数据具有不平衡的标签时，可能会出现误导性的结果(以及潜在的整体失败)——我一直很小心，不只是将这作为分类任务的一个问题，因为我们可以以某种方式调整回归任务，以便能够执行分层 k-fold 进行验证。相反，一个更好的解决方案是以这样一种方式随机划分，即我们在每个子集中保持相同的类别分布，这就是我们所说的分层。

注:除了我们随机分割数据的方式，分层 k 重交叉验证与简单 k 重交叉验证是一样的。

图 StratifiedKFold 的例子(来源: Scikit-Learn 文档

**#** [https://bit.ly/3iCHavo](https://bit.ly/3iCHavo)**import** **numpy** **as** **np**
**from** **sklearn.model_selection** **import** StratifiedKFoldX = np.array([[1, 2], [3, 4], [1, 2], [3, 4]])
y = np.array([0, 0, 1, 1])
skf = StratifiedKFold(n_splits=2)
**print**(skf.get_n_splits(X, y)
2**print**(skf)
StratifiedKFold(n_splits=2, random_state=None, shuffle=False)**for** train_index, test_index **in** skf.split(X, y):
   **print**("TRAIN:", train_index, "TEST:", test_index)
    X_train, X_test = X[train_index], X[test_index]
    y_train, y_test = y[train_index], y[test_index]TRAIN: [1 3] TEST: [0 2]
TRAIN: [0 2] TEST: [1 3]

根据第一个 4X Kaggle 特级大师 Abhishek Thakur 的说法，可以肯定地说，如果我们有一个标准的分类任务，那么盲目地应用分层 k-fold 交叉验证根本不是一个坏主意。

留一交叉验证

留一交叉验证可以被认为是 k 重交叉验证的特例，其中 k = n ，n 是原始数据集中的样本数。换句话说，数据将在 n - 1 个样本上训练，并将用于预测被遗漏的样本，这将被重复 n 次，使得每个样本充当被遗漏的样本。

图 4:留一简历示例(来源: DataCamp

#[https://bit.ly/2POw0HU](https://bit.ly/2POw0HU)**import** **numpy** **as** **np**
**from** **sklearn.model_selection** **import** LeaveOneOutX = np.array([[1, 2], [3, 4]])
y = np.array([1, 2])
loo = LeaveOneOut()
**print**(loo.get_n_splits(X))
2**print**(loo)
LeaveOneOut()**for** train_index, test_index **in** loo.split(X):
    **print**("TRAIN:", train_index, "TEST:", test_index)
   X_train, X_test = X[train_index], X[test_index]
    y_train, y_test = y[train_index], y[test_index]
    **print**(X_train, X_test, y_train, y_test)TRAIN: [1] TEST: [0]
[[3 4]] [[1 2]] [2] [1]
TRAIN: [0] TEST: [1]
[[1 2]] [[3 4]] [1] [2]

这种技术可能需要大量的计算时间，在这种情况下，k 倍交叉验证可能是更好的解决方案。或者，如果数据集很小，那么预测模型将丢失大量数据(特别是如果交叉验证很大)，因此在这种情况下，留一法是一个很好的解决方案。

组 K-折叠交叉验证

GroupKFold 交叉验证是 k-fold 交叉验证的另一种变体，它确保同一组不出现在训练和测试集中。例如，如果我们想要建立一个预测模型，从患者皮肤的图像中对恶性或良性进行分类，很可能我们会有来自同一个患者的图像。由于我们没有在训练和测试集中分割单个患者，因此我们恢复到 GroupKfold 而不是 k-fold(或分层 k-fold)，因此，患者将被视为组。

图 5:分组文件夹的例子(来源: Scikit-Learn 文档

**#** [https://scikit-learn.org/stable/modules/cross_validation.html](https://scikit-learn.org/stable/modules/cross_validation.html)**from** **sklearn.model_selection** **import** GroupKFold

X = [0.1, 0.2, 2.2, 2.4, 2.3, 4.55, 5.8, 8.8, 9, 10]
y = ["a", "b", "b", "b", "c", "c", "c", "d", "d", "d"]
groups = [1, 1, 1, 2, 2, 2, 3, 3, 3, 3]

gkf = GroupKFold(n_splits=3)
**for** train, test **in** gkf.split(X, y, groups=groups):
   print("*%s* *%s*" % (train, test))[0 1 2 3 4 5] [6 7 8 9]
[0 1 2 6 7 8 9] [3 4 5]
[3 4 5 6 7 8 9] [0 1 2]

注意:这种技术的另一个变体是分层 K 折叠交叉验证，当我们想要保持类别分布并且我们不想同一个组出现在两个不同的折叠中时，执行这种验证。scikit-learn 没有内置的解决方案，但是在这个 Kaggle 笔记本中有一个很好的实现。

包裹

交叉验证是建立机器学习模型的第一步，在决定采用什么技术时，我们考虑我们拥有的数据是极其重要的——在某些情况下，甚至有必要根据数据采用新形式的交叉验证。

“如果你有一个好的交叉验证方案，其中验证数据代表训练和真实世界的数据，你将能够建立一个良好的高度可概括的机器学习模型。”——Abhishek tha kur

这个故事的灵感来自于第一位 4x Kaggle 特级大师 Abhishek Thakur 的《接近(几乎)任何机器学习问题 》(链接是而不是附属链接，并且我没有被要求推广这本书)。如果你已经有了一些机器学习的经验，并且想要更多实用的建议，那么我强烈推荐这本书。

如果你想和我联系，我在 LinkedIn 上最容易找到:

[## Kurtis Pykes -人工智能作家-走向数据科学| LinkedIn

在世界上最大的职业社区 LinkedIn 上查看 Kurtis Pykes 的个人资料。Kurtis 有一个工作列在他们的…

www.linkedin.com](https://www.linkedin.com/in/kurtispykes/)

使用 KNN 进行交叉验证

原文：https://towardsdatascience.com/cross-validation-using-knn-6babb6e619c8?source=collection_archive---------1-----------------------

这是 KNN 系列的第三篇文章。如果你还没有阅读前两部分，我建议你先浏览一遍。第一部分，第二部分

在本文中，我们将了解什么是交叉验证，为什么需要它，以及什么是 k 倍交叉验证？

为了更好地理解交叉验证的必要性，让我先回顾一下如何确定“K”的正确值？

假设，我们有一个数据集，我们将它按照 70:30 的比例分成训练数据和测试数据。也就是说，我保留总数据的 70%来训练我的模型，剩下的 30%来测试它。接下来，我用不同的“K”值训练我的模型，并在我的测试数据上捕捉它的准确性。假设我们得到如下表格:

作者图片

现在，如果你观察，那么在 K=3 时，我得到 90%的最高精度，之后，我们看到精度下降的趋势。所以，我们得出结论的基础是，我的 K=3 的合适值。

这一切听起来不错，但有一个小问题。让我问你一个非常简单而有趣的问题。

机器学习的目的是什么？

如果我考虑上面的例子，并且基于我的理解，对于一个未来看不见的数据点，我的模型将如何准确地预测类别标签。当一个算法在一个看不见的数据点上表现良好时，它被称为推广。机器学习的整体目标是推广。

想想 KNN，我们使用测试数据来确定 K 的正确值，使用训练数据来寻找最近的邻居。我们在测试数据上获得了 90%的准确性，我们还使用这些数据来确定“K”的正确值。我是否可以说，既然我的测试数据达到了 90%的准确率，我就能在未来看不到的数据上保持这种大致的准确率？答案是否。

为了自信地说，我们可以在未来看不见的数据上达到大约 90%的准确性，我需要首先在看不见的数据上测试这个模型。

但是我该怎么做呢？我有我的数据集，我已经把它分成了 70:30 比例的训练和测试数据。我没有更多可用的数据。

为了解决这个问题，我给你介绍一下交叉验证的概念。

在交叉验证中，我们不是将数据分成两部分，而是分成三部分。训练数据、交叉验证数据和测试数据。在这里，我们使用训练数据来寻找最近的邻居，我们使用交叉验证数据来寻找“K”的最佳值，最后我们在完全看不见的测试数据上测试我们的模型。这个测试数据相当于未来看不见的数据点。

为了更好地理解，请考虑下图，该图清楚地区分了拆分:

作者图片

左边的部分没有交叉验证，右边的部分有交叉验证。

在交叉验证部分，我们使用 D_Train 和 D_CV 来找到 KNN，但我们不接触 D_Test。一旦我们找到一个合适的“K”值，我们就在 D_Test 上使用这个 K 值，它也作为一个未来看不见的数据，来发现模型执行的准确程度。

现在，我们已经理解了交叉验证的概念和它的必要性，让我们解决一个与之相关的问题。

问题:

如果你参考上面的图片，我们已经按照 60:20:20 的比例分割了数据，其中我们使用 60%的数据来训练我们的模型，20%用于交叉验证，其余 20%用于测试。在这个交叉验证的过程中，我们丢失了将近 20%的数据，这些数据本来是用于训练的，众所周知，训练数据越多，算法就越好。那么，有没有办法在训练数据下使用那 20%的交叉验证数据呢？

这个问题的答案是 k 倍交叉验证

那么，在 k 倍交叉验证中会发生什么呢？考虑下面的例子:

作者图片

在将总数据集(D_n)分割成训练(D_Train)和测试(D_Test)数据集后，以 80:20 的比例，我们进一步随机将训练数据分割成 4 等份。

作者图片

D1、D2、D3 和 D4 是 D_Train 的四个随机拆分的相等部分。完成分割后，我们按如下方式进行:

作者图片

第一步:对于 K=1，我选择 D1、D2 和 D3 作为我的训练数据集，并将 D4 设置为我的交叉验证数据，并找到最近的邻居并计算其准确性。

第二步:同样，对于 K=1，我选择 D1、D2 和 D4 作为我的训练数据集，并设置 D3 作为我的交叉验证数据，我找到最近的邻居并计算其准确性。

我用 D2 和 D1 作为我的交叉验证数据集重复上述步骤，并计算相应的准确度。完成后，对于 K=1 的相同值，我得到了 4 个精度。因此，我考虑这些精度的平均值，并将其作为 K=1 时的最终值。

现在，我对 K=2 重复上述步骤，找到 K=2 的平均精度。依此类推，我计算不同 k 值的精度。

现在，请注意，对于 K 的每个值，我必须计算 4 次精度。这是因为我随机地将我的训练数据集分成 4 个相等的部分。假设我将我的数据集随机分成 5 个相等的部分，那么我将不得不为每个 K 值计算 5 个不同的精确度，并取它们的平均值。

请注意:大写“K”代表 KNN 中的 K 值，小写“K”代表 k 倍交叉验证中的 K 值

因此，对于上述示例，k-fold 交叉验证中的 k 值是 4(即 k=4)，如果我们将训练数据分成 5 个相等的部分，则 k 值=5。

k =我们随机将训练数据集分成的部分的数量。

现在，我们使用全部 80%的数据来计算最近邻以及 KNN 的 K 值。

K 重交叉验证的一个缺点是，我们要对(KNN 的)每个 K 值重复计算。所以基本上增加了时间复杂度。

结论

我们已经理解了交叉验证的概念，为什么我们需要它，以及 k 倍交叉验证是什么意思。尽管时间复杂度很高，但这个过程是值得的，因为它增加了模型的泛化能力。

感谢阅读！

我希望这些资源和想法对您的数据科学之旅有所帮助。

迪帕克·贾恩

• 如果你喜欢这个， 跟着我 上媒求更
• 我们来连线上 LinkedIn

众包数据标签

原文：https://towardsdatascience.com/crowd-sourced-data-labeling-68fb92b291a5?source=collection_archive---------21-----------------------

照片由乔丹·康纳在 Unsplash 上拍摄

如何利用外包人员获得高质量的标注数据集

作为一名数据科学家，我们花了大量的时间处理数据——清理、规范化、标记。令人欣慰的是，如今许多解决方案将标记工作交给了第三方，解放了数据科学家的宝贵时间，并减轻了手动文本、图片或视频标记的负担。

然而，作为一名数据科学家，我们想知道第三方在标记任务上的表现如何，因为我们通常称输出为**“黄金数据集”**有几种方法可以检查数据集的注释情况。

注释者间协议(IAA) —是两个或更多注释者之间关于标签的协议。例如，如果我们有一个观察，由 7 个不同的人独立地标记为 3 个可能的标签，IAA 是多少注释者同意应该分配的标签的度量。如果所有 7 个人都分配了相同的标签，IAA 将为 100%。也就是说注释者之间的一致是两个(或更多)注释者对某个类别做出相同注释决定的程度的度量。

然而，在现实世界中，并不是所有的注释者都具有相同的技能水平。一些人类注释者在这项任务中可能更有经验，所以他们应该有更高的权重。这时候加权 弗莱斯卡帕 进来了。这是计算注释者一致性的标准，因为有些注释者比其他人更熟练。

如果我们有一份法律文件，并且每个文本段落需要被分类为 3 个可能的标签，例如，特殊法律条款、样板法律文本或合同细节。此外，我们希望每个文本段落由 5 个不同的人类标签分类。一个贴标签的专家应该有更强的发言权，标签应该是什么。这个较高的权重是基于正确性的历史运行平均值。这意味着如果专家始终是正确的，特别是在贴标机不能就标签达成一致的低 IAA 观察上。那么专家的投票将具有更高的权重- 2 个或更多标签员的投票。

众包贴标机的另一个改进是当他们的标签与共识标签不一致时提示贴标机。作为一个节省成本的措施，设置一个小样本——10%由多个标注者标注(抽样率)

通过如上所述的自动设置，可以获得高精度的群体标记系统，其中大量初始观察被发送到甲骨文，并且随着时间的推移，专家将出现，因为他们的标签与低注释者间一致性观察的甲骨文相一致。同样，如果注释者在没有阅读/理解问题的情况下随机分配标签，那么他们的分类将与大多数样本的分类不同。在一个例子中，许多注释者同意类应该是特殊法律条款当“坏的”注释者选择合同细节作为答案时，设置将随着时间的推移降低标注者的等级，甚至完全禁止他们为您标注。

工作示例

在我的工作中，当我的团队需要廉价和高质量的数据集时，我们使用 MTurk。例如，对于一个获得大约 20，000 个高质量标记数据点来微调基于变压器的 NLP 模型的项目，我们做了以下工作

1. 我们(ML 工程师和 SME)手工标记了大约 200 个(或 1%)观察值。
2. 我们在 20 个预先标记的观察值上为 Turkers 设置了资格作业。这将决定哪些 Turkers 我们想登上我们的主要标签工作。这是它看起来的样子—

尝试标记合格测试的 10 台机器的样本

你可以看到 10 号工人甚至没有努力，f1 分数为 23%。我们让 f1 超过 90%的员工来完成这项任务。

3.我们以这样一种方式设置任务，即每个观察将被 5 个不同的 Turkers 标记。每个这样的任务将包含 100 个观察值，99 个未标记，1 个观察值已经由我们的团队预先标记，但对 Turkers 不可见。

4.我们总共发布了 200 个这样的任务，每个任务有 100 个观察值。任务将以最大化观察完整性的方式提供给 Turkers，即，我们希望任务 1 在转移到下一个任务之前由不同的 Turkers 完全完成，以此类推。这里的风险是，如果所有任务对 Turker 都可用，我们将没有可靠的指标，因为 Turker 1 将从任务#10 开始，而 Turker 2 将从任务#103 开始，以此类推，从而妨碍 IAA 计算。

5.Turkers 在连续的 100 次观察中标记了主要的 19，980 (20，000–20)个数据集，我们将监控每个 Turkers 的 IAA 指标。如果任何一个 Turker 的 IAA 降得太低，我们编写的代码就会将他们排除在我们的标记之外。

6.我们还监控了 Turkers 在我们团队预先标记的少数观察中的表现，以确保 Turkers 不会集体误入歧途，因为 IAA 指标监控的是相关性而不是正确性。

7.在整个任务完成后，我们将提升某些工人为主工人，下次我们做标记时，这些工人不需要参加资格考试。在这里，我们甚至可以进行扩展，使这些 Turker 的投票数在 IAA 的计算中更高。

我上面描述的系统是由我们构建的，充分利用了 AWS 的 MTurk APIs，我们不必担心标记者变得懒惰并开始随机标记数据，因为他们会自动从池中删除。

结论

在数据科学家团队中，我们经常需要带标签的数据。对于现代人工智能团队来说，拥有一种自动化的方式来搭载众包工人，以自动化的方式评估和监控贴标机的性能是非常重要的。这些原则中的一些甚至被用于数据编程，在数据编程中，标记功能可以被认为是单个的工人，鉴别器试图辨别哪些标记功能执行，哪些不执行。

如果你有兴趣用 apis ping me 建立自己的自动化众包系统，我们可以抓取☕️电子咖啡👍。

如何:用 ObservableHQ 和 Mechanical Turk 对数据进行群体测试

原文：https://towardsdatascience.com/crowd-testing-data-viz-observablehq-and-mechanical-turk-e3663f9fa5f8?source=collection_archive---------48-----------------------

在可观察的笔记本上开发数据可视化和用户在 Mechanical Turk 上测试它们的技术指南。

(图片来自作者)

数据可视化看似复杂。即使是简单的可视化也有多个组件以令人惊讶的方式交互。出于这个原因，用真人测试可视化是至关重要的。在大多数情况下，做一些(定性的)用户测试，修复问题，然后发布就足够了。

但是有时候你需要更多的确定性。例如，如果你正在为公众设计可视化效果，如果你正在进行学术研究，或者如果可视化效果将成为产品或应用程序的一部分，你可能需要评估一些不同的设计变体，以了解哪种表现最好。

定性测试使得比较设计的不同版本变得困难，因为像排序效应这样的问题。传统的 A/B 测试也没有帮助，因为它们不会透露太多关于用户是否“得到”图表的信息。幸运的是，还有机械土耳其人。

用户测试数据，即机械土耳其人

如果你需要测试数据可视化，你需要统计精度，机械土耳其人是你的朋友。Mechanical Turk 可以(相对)轻松地快速接触到大量“工人”受众，并向他们询问几乎任何问题。

当你测试数据时，你给工人一个“测验”,基于你的想象，看看他们表现如何。显然你不是在测试用户，而是在测试你的设计。用户正确回答的问题越多，回答的速度越快，您就越有信心可视化是健壮的。

迈克·博斯托克和杰弗里·赫尔 在斯坦福发表了一项研究证实了这一点。他们检查了 Mechanical Turk，特别是作为测试数据可视化的平台，并发现*“众包感知实验是可行的，并为可视化设计提供了新的见解。”*

挑战:测试设置

像赫尔和博斯托克这样的研究面临的挑战是，它们通常需要相当多的设置。通常这包括实际启动一个服务器来托管可视化和你自己的“测验”。这并不是一个巨大的负担，但这是可以花在更有启发性的事情上的时间。

不过，多亏了 ObservableHQ ，你可以在一个可观察的笔记本中构建整个实验，并将可视化结果完全无服务器地嵌入到一个机械土耳其人“HIT”(或人类智能任务)中。

额外的好处是，实际上在可观察中对可视化进行原型化通常是快速、令人愉快的，并且支持简单的协作。

在最近的一个实验中，我测试了条形图 v.s .棒棒糖图 v.s .点图，使用这个 ObservableHQ + Mechanical Turk 设置，在几个小时内评估了 3 种不同的有争议的图表类型，有 150 名不同的参与者(发现对理解的准确性和速度有显著影响)。

工作原理:

在本指南中，我将介绍使 Bar /棒棒糖/ Dot 实验工作的技术方面。为了简单起见，我们将构建一个更简单的玩具实验(测试不同颜色的条形图)。

这些实验的完整代码在两个地方:

1. 此处的可观察笔记本。
2. 这个包含 MTurk HIT 的 HTML 的要点在这里。

步骤:

假设我们想做一个实验，看看条形图的颜色是否对理解或速度有任何影响。我们决定测试红色、绿色和蓝色条形图。

为此，我们将…

• 在 ObservableHQ 笔记本中构建 3 种不同的可视化效果
• 将 3 个可视化效果中的 1 个随机嵌入到一个机械 Turk HIT 中
• 将问题作为简单的 HTML 表单输入添加到 HIT 中
• 开展活动！
• 评估结果

在可观察的笔记本中构建可视化效果

首先，在 ObservableHQ 上新建一个笔记本。

然后，我们将从导入 d3 开始。按照惯例，它们通常放在笔记本的底部，但为了保持时间顺序，把它们放在上面。

d3 = require("d3@5")

接下来，我们将制作一个简单的条形图。我们会给它一个color参数，这样我们就可以使用这个相同的条形图来测试我们 3 个实验变体的所有 3 种颜色。

然后，我们可以测试它在下一个单元格中的工作方式:

barChart([1,2,3,4,3,5].map((d,i)=>({x:i, y:d})))

然后，让我们为 3 个不同的变体制作 3 个不同的函数:一个红色条形图、一个蓝色条形图和一个绿色条形图。我们将它们存储在chartVariants中，用变体名称:'red'、'green'和'blue'键接。

chartVariants= ({
  'red': (data,params)=>(barChart(data, {...params, color: '#EB4137'})),
  'green': (data,params)=>(barChart(data, {...params, color: '#8CC432'})),
  'blue': (data,params)=>(barChart(data, {...params, color: '# t'})),
})

接下来，我们将生成一个数据集，并用测试可视化来呈现。

测试数据集很可能是静态的，但是如果我们希望看到可视化在各种数据形状上的表现，那么我们需要用各种底层数据集来测试它。为了在实验中做到这一点，我们将在每次加载图表时使用不同的随机生成的数据集来呈现条形图(因此每个实验参与者都会看到使用不同数据集填充的图表)。

假设我们选择烘焙义卖商品销售作为测试数据集的主题。这很好，有两个原因:1)烘焙销售项目很美味，通常考虑起来很愉快；2)烘焙销售项目是一个广泛熟悉的主题，所以它们对我们的测试参与者来说更容易推理。记住，我们不是在测试工人，我们是在测试可视化。

我们生成测试数据如下…

//Note: if you re-run this cell, it generates a new dataset every time
data0 = ["Brownies", "Cookies", "Cupcakes", "Donuts"].map((treatLabel)=>({x: treatLabel, y: Math.round(Math.random() * 100)}))

(按照惯例，我发现对数据集的变量名及其对应的图表进行编号，可以更容易地跟踪单个实验中的多个图表。这对于我们的单个图表来说显然是矫枉过正了)。

现在我们想看看数据在每个图表变量中的样子。为了在笔记本中方便起见(稍后为了将参与者分配到实验组),我们将定义一个名为chartVariant的变量，然后使用测试数据呈现由chartVariant定义的图表。

但是首先，我们将导入一个单选控件，添加一个 UI 选择器，以便在我们查看笔记本时方便地选择chartVariant。

import { radio } from "@meetamit/multiple-choice-inputs"

然后我们将创建chartVariant选择器，同样是为了在我们查看笔记本时方便地选择chartVariant:

viewof chartVariant = radio({
  title: 'Choose Chart',
  description: 'Please choose which chart to evaluate.',
  options: [
    { label: 'Red', value: 'red' },
    { label: 'Green', value: 'green' },
    { label: 'Blue', value: 'blue' },
  ],
  value: 'red'
})

现在，让我们把它们放在一起，看看我们选择的chartVariant在我们的测试数据集上看起来如何。请注意，如果您在单选按钮中选择不同的颜色，图表将在笔记本中自动更新。

chart0 = {
  const chartFn = chartVariants[chartVariant]
  return chartFn(data0)}

然后点击笔记本上的“发布”,我们就完成了 Observable。我们会在机械土耳其人里做其他的事情。

制造轰动

在《土耳其机器人》的世界里，一个击中(“人类智能任务”)是一个“需要答案的问题”。或者，更具体地说，它是一个需要答案的问题的模板。

机械土耳其人给你一吨的灵活性时，建设击中。通过将所有内容包装在一个 HTMLQuestion 元素中，您可以在 HIT 中包含几乎任何任意的 HTML。为了这个实验的目的，我们不需要太花哨的东西，我们只需要建立一个基本的形式。

要设计和构建 HIT，只需在您最喜欢的编辑器中创建一个普通的 HTML 文件。我们将像构建任何普通 HTML 页面一样构建和调试表单，然后在准备就绪时将其复制并粘贴到 Mechanical Turk 中。

HIT HTML 的结构如下所示:

正如您在上面看到的，这是一个基本的 HTML 表单，底部有一些 javascript，用于设置可观察的嵌入和验证表单。

上面遗漏了两个部分，我们将在下面讨论:

1. 将笔记本元素嵌入该 HTML 的代码
2. 一种跟踪用户回答问题时的时间戳的方法

将可观察图表嵌入 HTML:

Observable 使得将笔记本的各个部分嵌入到网络上的其他页面变得非常简单。你可以在这里看到他们的指南。

在这个实验中，我们希望将图表嵌入到我们创建的笔记本的最后一个单元格(chart0)中。为此，单击单元格左侧的垂直点，然后从菜单中选择“嵌入代码”。它会向您展示一个如下所示的片段:

<div id="observablehq-befff29e"></div>
<script type="module">
import {Runtime, Inspector} from "[https://cdn.jsdelivr.net/npm/@observablehq/runtime@4/dist/runtime.js](https://cdn.jsdelivr.net/npm/@observablehq/runtime@4/dist/runtime.js)";
import define from "[https://api.observablehq.com/@elibryan/observable-mechanical-turk-guide.js?v=3](https://api.observablehq.com/@elibryan/observable-mechanical-turk-guide.js?v=3)";
const inspect = Inspector.into("#observablehq-befff29e");
(new Runtime).module(define, name => name === "chart0" ? inspect() : undefined);
</script>

上面的内容对于静态用例来说很好，但是我们还需要做一些调整，所以你所需要的就是上面的 URL 路径，看起来像是/@elibryan/observable-mechanical-turk-guide.js?v=3.复制它，并用你笔记本的路径替换下面代码中的路径。

我们将使用以下代码将笔记本图表嵌入到我们的 HIT 中:

我们正在做一些值得注意的事情:

• 我们正在从 Observable 公司进口笔记本:import define from “https://api.observablehq.com/@elibryan/observable-mechanical-turk-guide.js?v=3";
• 在开关内部，我们使用return inspect0()呈现图表，并将随机生成的数据集保存到表单中的隐藏元素:document.getElementById("data0").value = JSON.stringify(value);
• 我们通过从图表变量中随机选择来设置experimentVariant，然后将变量键保存到一个隐藏字段document.getElementById(“experiment-variant”).value = experimentVariant;，这样我们就可以在分析时访问它。我们还更新了嵌入图表的状态，以显示带有observableCharts.redefine(“chartVariant”, experimentVariant);的所选变量

此时，如果您在浏览器中加载 HIT HTML，您应该会看到图表呈现。

提出好的测验问题

在上面的 HTML 中，我包含了两个玩具问题的例子。如果你要在现实生活中运行它，你会希望设计得更仔细一点。查看条形/棒棒糖/圆点实验记录，了解评估图表理解能力的实际调查问题的示例和解释。

跟踪答案时间戳

知道一个图表是否能引导观众找到正确的答案是很重要的。但我们也想确保用户可以快速、轻松地搜索图表。为了确定这一点，我们想知道用户回答关于图表的每个问题需要多长时间。

为此，我们存储用户每次“回答”一个问题的时间戳(即每当他们改变表单中的一个字段时)。然后，当我们进行分析时，我们可以通过从之前的时间戳中减去当前答案的时间戳来粗略了解用户回答一个问题花费了多长时间。

这里的方法并不完美。出于很多原因，您不能将此解释为“用户 X 花了 Y 秒回答问题 Z”，但是如果样本足够大，您可以使用此进行比较(例如，“A 组的用户比 B 组的用户多花了 10%的时间”)。

上面的代码遍历表单中的每个单选按钮和文本输入，并对每个按钮和文本调用addTimeStampField。addTimeStampField在每个原始输入字段下添加一个相应的hidden元素。addTimeStampField还将onChange添加到相关的输入事件处理程序中，这样，如果原始输入发生变化，onChange会在隐藏字段中存储当前时间戳，从而节省用户“回答”问题的时间。

就是这样！同样，完整的热门 HTML 的要点可以在这里找到:observable-mturk-experiment-hit.html。这应该既可以在 Mechanical Turk 向导中工作，也可以在浏览器中查看 HTML(这使得构建/调试更加容易)。

接下来，我们将创建一个机械土耳其人项目，并将上述 HTML 复制/粘贴到 HIT 中。

运行实验

要运行该实验，请转到 Mechanical Turk 请求者页面，然后创建一个新项目。创建项目时要记住一些设置:

• 根据赫尔和博斯托克的说法，你为每次点击支付的金额(“每次回应的奖励”)实际上不会影响回应的质量，但会影响人们对你的点击做出回应的速度。他们建议每个问题支付 0.02 美元，以达到美国的最低工资标准。
• 在决定受访者的数量(即有多少独特的员工将参与)时，您可能希望选择一个高于您实现适当统计功效所需的数字。因为人们被随机分配到每个实验组，你可能会以不均衡的小组规模结束，一些小组可能会动力不足。
• 对于工作人员需求，您可以通过设置较高的命中率(例如> = 95%)来获得更好的响应，但是您仍然应该期望随机填写一些答案，并且您将需要一个过程来在实验运行后过滤掉这些答案。

一旦您选择了正确的设置，您将转到设计布局选项卡。它可能会显示一个 WYSIWIG 编辑器，在这种情况下，切换到原始 HTML 视图。然后只需从上面复制/粘贴命中的 HTML。

您可以确保预览和完成屏幕上的一切都正常。您应该可以从您的观察笔记本中看到图表和调查问题。您还应该看到，当您刷新浏览器时，图表会在不同的变量之间切换。

我是谁？不，不，你是谁？！

嗨！我是伊莱·霍德。我帮助客户设计和开发忙碌的人和他们杂乱的数据之间的有效接口。如果你是一名创始人、创客、讲故事者、非营利行善者或商业领袖，正在思考数据、设计和用户心理的交集，我很乐意联系并聆听你的故事。

你可以发电子邮件到 eli@3isapattern.com 给我，或者在推特上关注我。

参考资料:

• J.赫尔，m .博斯托克，众包图形感知:使用机械土耳其人评估可视化设计 (2010)

咀嚼数字。建立模型。预测未来。现在怎么办？

原文：https://towardsdatascience.com/crunch-numbers-build-models-predict-the-future-now-what-3948b82e737f?source=collection_archive---------43-----------------------

菜鸟数据科学家，还是顶级美元价值创造者？你想成为谁？

图片来自皮克斯拜的戈登·约翰逊

我可以告诉你去哪里看，但我不能告诉你看什么。

你是一名数据科学家。恭喜你！你的新工作头衔是“21 世纪最性感的工作”。你肯定在做别人做不到的正确的事情。否则为什么你的技能会有很高的需求？不然你为什么会赚到令人羡慕的薪水？已经对未来感到兴奋了吗？有什么可能出错呢？

你是一名数据科学家。告诉我更多。你的具体职责是什么？对大数据进行统计分析？构建可在分布式系统上扩展的数据管道？成为 SQL 和 Python 的专家？了解 docker 和 kubernetes 的一切？在云上部署预测模型？我错过了什么吗？

再问一次，可能出了什么问题？显然，很多！你看，最性感的工作伴随着大量的嗡嗡声。数据科学，作为一个短语，在过去的十年里已经建立了很多宣传。数据科学作为一种功能，同时也失去了它的焦点。它被抛来抛去，覆盖了比它应该覆盖的更多的功能领域。这对你这个几乎不是人类的数据科学家有什么影响？现在应该学习什么新的回归算法？我还应该掌握哪种编程语言？我该何去何从？有一个简单的答案。

跟着钱走。

不，我不是指追逐通常伴随工作而来的高薪和股票期权，或者盲目地学习技能，根据招聘人员的说法，这些技能可以保证六位数的薪水。更确切地说，“钱”是你对公司目标的直接和切实的贡献——这些目标是你公司的领导层，也就是你，被支付报酬去实现的。是收入和收益的增长吗？是最大化客户的快乐和满意度吗？它是在分析你的应用程序的使用数据，以判断你的产品是否符合市场需求吗？是在控制假新闻在社交媒体上的传播吗？它是在制造无需驾驶的自动驾驶汽车吗？

找出答案是你的责任。当你这样做的时候，定义衡量你的公司是否达到其使命和目标的标准。到那时，所有的人工智能、机器学习、测试和实验都将变得有意义。在你开始享受乐趣之前，先了解你的目标。不是所有的公司都严格用金钱来定义他们的成功。一些公司，尤其是早期创业公司，优先考虑中期目标，这些目标有望为他们未来的成功奠定基础。你的公司愿意烧钱和放弃短期利润来优先考虑客户的幸福吗？如果你还不知道，那就离开你的办公桌去问你的老板。如果你的老板不知道答案，那就去问其他知道答案的人。

“那又怎么样？”

你曾经在完成 15 分钟的演示和一个小时的分析练习后被问过这个问题吗？作为一名有抱负的数据科学家，我的职业生涯从数据工程开始，然后过渡到高级分析和机器学习。我喜欢解决复杂的统计问题和优化问题。和我的同龄人一样，我也痴迷于 python 中最新的大数据工具，尤其是每六个月就有一款新工具问世的时候。如果你追求错误的目标，这一切都没有用。

数据科学是达到目的的手段。它本身并不是目的。

我们不都犯过那些新手的错误吗，比如没有花时间可视化数据，或者在运行分析之前没有识别偏差？当你被天花乱坠的宣传搞得心烦意乱时，你解决不了任何问题。然而，最有害的影响是忘记了你更大的职业目标，这些目标最初让你成为了一名数据科学家。现在，让我告诉你一个好消息。当然，如果你愿意对自己诚实，纠正你的思维过程会更容易。跟着钱走就行了。但是，你可能会问，怎么做呢？这是一个实际可行的框架。

如果你认为你创造了很酷的东西，问问你自己——那又怎样？

是的，你就是那个建立了一个二进制分类器的高手，它有 95%的准确率和一条让你的研究生院机器学习教授骄傲的 ROC 曲线。现在，你能不能用一句话解释一下你想解决的问题是什么？在数据科学中钻研“科学”并觉得自己很重要确实很有诱惑力。然而，除非你真正理解了你试图回答的问题，否则你的工作不会太重要。你可能知道指示你的模型离事实有多远的诊断工具。它们能帮助你和你的利益相关者做出可行的商业决策吗？

相对于随机选择的结果，你的发现有多不确定？

学会定义衡量你想要的结果的标准。根据你的模型减少不确定性的能力来判断你的结果，并给它一个美元值。数据科学社区不断有引人注目的新发展。不要犯不知所措的错误。相反，退一步，想想值得解决的问题，让你的公司和你的职业朝着正确的方向前进。

处理奥斯卡外语片的数据

原文：https://towardsdatascience.com/crunching-the-data-of-the-foreign-language-oscar-fe435716b66?source=collection_archive---------38-----------------------

《寄生虫》让历史赢得了最佳影片，但它也证实了外语类影片的一种新趋势

去年的奥斯卡季中，我们分析了哪些奥斯卡提名更有可能赢得最佳影片的数据,并跟踪了有强烈女性表演的电影与只有男性表演提名的电影的成功。

今年，随着韩国电影《T2》的热播，我们仔细研究了奥斯卡外语片的数据。以下是我和我的合作伙伴若昂·席尔瓦创建的数据 viz，我将分两部分对其进行简要评论。

欧洲独霸奥斯卡最佳外语类奖项

欧洲国家总共获得了 51 个最佳外语片奖

自 1956 年以来，奥斯卡最佳国际故事片奖(Academy Award for the best International Feature Film)每年都会颁发给在美国以外制作的、对白主要为非英语的长篇电影。我们数据的第一部分 viz 使用了一个由旗帜组成的条形图来显示全球四个地区的成功分布情况。

不可否认，这是由欧洲国家的电影主导的——意大利获得了 11 项奥斯卡奖，其次是法国，是最成功的两个国家。这两个国家帮助欧洲获得了 80%的奖项，而美洲只获得了 8%，非洲制作了 5%的获奖电影。昨晚之前，亚洲排名第三，但随着《寄生虫》赢得最佳外语片奖(击败四个欧洲候选人)，亚洲现在与美洲持平，获得 5 个奖项。

但是奥斯卡获奖者有一个新的趋势

在过去的 20 年里，50%的获奖者都不是欧洲人

看看我们数据的第一部分，你可能会认为这纯粹是欧洲占主导地位的故事。但在第二部分，我们在时间线上绘制了非欧洲的胜利，以突出一个新的趋势。阿尔及利亚电影《T4》Z 是第一部在 1969 年获奖的非欧洲电影。象牙海岸在 20 世纪 70 年代获得了唯一一个非欧洲奖项，而阿根廷的一部电影在 20 世纪 80 年代代表了世界其他地区。

从 2000 年开始，随着亚洲第一部获奖电影卧虎藏龙的问世，一种新的潮流开始形成。在过去的 20 年里，现在 50%的获奖者都是非欧洲人，寄生虫证实了这一类别中新形式的多样性。

昨晚,《寄生虫》成为第一部赢得最佳影片最高奖项的外语电影——这一成就是备受赞誉的墨西哥罗马去年未能实现的，也是这一类别中最成功的国家 1998 年未能与精彩的意大利生活是美丽的实现的。这有望为更多关注非英语电影打开大门，或者至少延续比过去更加多样化的外语电影类别的趋势。

我们如何创建我们的数据，即

我们梳理了这一类别的奥斯卡数据，并决定按世界地区(欧洲、亚洲、非洲和美洲)对奥斯卡获奖作品进行分类。然后，我们使用基于浏览器的 UI 和 UX 设计应用程序 Figma 来设计数据，即。

我们使用国旗下载获奖电影的原产国国旗的图像，以形成条形图，每个国家的获奖数量都有重复的旗帜。我们在时间表中再次重复使用旗帜来显示获奖电影的年份，省略了欧洲国家。这清楚地显示了过去 20 年中非欧洲国家的集群。

粉碎零售葡萄酒数据

原文：https://towardsdatascience.com/crushing-retail-wine-data-with-selenium-and-python-f16a13e046a4?source=collection_archive---------19-----------------------

现实世界中的 DS

使用 Selenium 和 Python

照片由阿克谢·肖汉在 Unsplash 上拍摄

在我的上一篇文章中，我谈到了网络抓取作为一种工具，通过从相关零售和电子商务网站中提取知识来帮助你关注竞争或定价趋势。

今天，我们将仔细看看这个过程。我们将用简单的调查术语(谁、什么、为什么、在哪里和如何)来处理它，因为为你的刮擦设置策略将帮助你更快地通过这个过程。

我们还将分享一些使用 Python 和 Selenium 包收集数据并将其压缩成可以操作的数据帧的技巧。

在开始之前，您需要确保您的 Selenium 包安装在 Python 中，并且 ChromeDriver 设置为与 Selenium 一起运行。有关设置 Selenium 和 ChromeDriver 的更多信息，请点击以下链接。

世卫组织(您将从中获取信息的网站)？

当你浏览一个网站时，要考虑三个关键因素:

1. 查看网站的条款和条件，确保您没有违反任何潜在协议。你很可能不希望失去对网站的访问，所以花一些时间了解他们是否会对你抓取他们的数据有意见。在接下来的讨论中，我们将假设一个站点可以被你浏览。
2. 评估你感兴趣的网站。考虑给谷歌 Chrome 添加一个像 BuiltWith 这样的技术剖析器，从顶部了解网站是如何构建的，是什么让它运行的(这将有助于你以后识别元素)。你还将利用谷歌的元素面板来检查你将可以抓取哪些元素(稍后会有更多相关内容)。此外，注意你与网站的交互方式——如果网站返回的结果没有巨大的滚动，你很幸运，如果它是一个无限滚动的网站(像脸书或 Twitter ),你可能需要在代码中考虑一些额外的选项。
3. *识别一个完整的网址:*当你用 Python 写代码时，你需要识别你想要访问的特定网址。我的建议是访问该网站，输入标准来执行您希望进行的任何搜索，并捕获结果网址，以便在发送您的 web scraper 之前满足您的标准。准备好那个网址，作为设置你的网页抓取代码的第一步，通过 Selenium 告诉 ChromeDriver 到底要打开和抓取什么网站。

右键单击页面上的任何文本、图像或价格点，以访问检查功能并打开元素面板

(我们要找的)是什么？

如上所述，我们依靠谷歌的 Inspect 功能和元素面板窗口来检查哪些元素你可以抓取。右键点击页面上你感兴趣的任何一项(图片或文字)，在弹出的菜单中，向下滚动到“Inspect”并点击(见上图)。

这将带您进入元素面板，以便您可以查看站点的文档对象模型(DOM)树，并找到您要提取的元素的正确标识符。

页面上的每个元素都将被引用到 DOM 上的一个节点。面临的挑战是为您需要的每个元素找到最有效、最可靠的定位器。幸运的是，Selenium 为您提供了一个工具箱，里面装满了可供选择的工具，因此，无论是哪个网站，您都有很大的机会使用以下命令找到您需要的东西:

• 按 ID 查找元素
• 按名称查找元素
• 按类名查找元素
• 通过 XPath 查找元素
• 通过 CSS 选择器查找元素
• 通过链接文本查找元素
• 通过部分链接文本查找元素
• 通过标记名查找元素

您可能需要试验其中的一些定位器类型来获得您想要的结果，并且您可能会发现通过在整个代码中使用多个定位器来访问您想要抓取的元素是最好的。互联网上有很多关于部署这些 find 命令的最佳方法的建议。对于本例，我们将使用“按类名查找元素”,如下所示:

当您检查图像或文本时，它会引导您找到它在 DOM 中的元素标识符。这里是一个类名，“vintage title _ _ wine—U7t9G”

在您的代码中，您将调用这个元素来帮助将所需的相关文本抓取到您的文件中—参考第四行:wine = browser . find _ elements _ by _ class _ name(" vintage title _ _ wine—U7t9G ")

(在 GitHub Gist**可以访问上面的代码片段 )

为什么(我们这样刮？)

使用 Python 和 Selenium，有一种更简单的方法将所有信息放入一个列表中——但是结果非常冗长、麻烦且难以操作。

然而，为了能够更有效地处理数据，并最终将它放入我们可以管理的 Python Pandas 数据帧中，我们将使用一个两步过程来定位各个元素，然后访问相关的文本。

这些元素在哪里？

这些元素遍布站点的 DOM 树。因此，对于我们的两步过程，我们的第一步是识别所有的元素，第二步是运行一个简单的 for/循环来遍历每个元素，让 selenium 为我们的审查挑选最好的文本。

在上面的代码中，我们建立了五个单独的列表来存放我们的元素集合。当我们遍历每一个单独的元素列表时，我们将创建五个新的文本列表，它们都是相互对应的。因此，在这个具体的例子中，我们收获了我们的 winery 元素，并用 Selenium 为我们精选的最好的数据粉碎了我们的 winery_list。

Selenium 将收获关键元素，然后我们会告诉它用 for 循环粉碎相应的数据。

如何(我们现在使用这些信息)？

我们现在有五个伟大的列表提供我们收集的数据，我们只是一个简单的 Python 字典，将我们的列表压在一起，形成一个数据帧，我们可以清理，分析，添加，然后提供并与我们的同事分享我们的见解。

一个简单的字典代码，将我们的五个列表压缩成一个单一的数据框架

(在 GitHub Gist 这里 可以访问上面的代码片段)

我们的最终数据框架(在清洁、EDA 或特征工程之前)

如您所见，生成的数据框架以一种我们可以分析并从中获得更多价值的方式汇集了我们的数据，更不用说我们已经建立了一个相对简单的程序来在需要时更新我们的信息。

总的来说，网络抓取可以为我们提供很好的自动化数据访问，这反过来帮助我们获得洞察力，推动我们的业务向前发展。在我们开始写代码之前，建立我们的抓取策略(并考虑谁、什么、哪里、为什么和如何)，对获得我们想要的结果有极大的帮助。

直到下一次…

干杯！

使用 Python 进行股票和加密货币的均值-方差分析

原文：https://towardsdatascience.com/cryptocurrencies-the-new-frontier-part-1-940e787c7ab9?source=collection_archive---------14-----------------------

照片由 Clifford 摄影在 Unsplash

Python，均值-方差分析，有效边界以及加密货币如何拓展边界。

加密货币多年来一直是一个热门话题，这是有充分理由的。对一些人来说，它们是一个黑匣子，对另一些人来说，它们是金融不可避免的未来。不用说，任何人，只要花了至少一部分时间和金钱投资股票和其他资产，近年来都会考虑投资这种新颖的资产类别。

在本文中，我将从均值-方差的角度分析将加密货币纳入传统股票投资组合的影响。本分析的目的不是给出投资建议或对未来做出预测，而是展示为什么考虑将加密货币等替代资产类别与股票一起纳入投资组合是值得的，不管你对它们的看法如何。

如果你对加密货币、金融理论、投资或使用 Python 编程感兴趣，这篇文章是为你准备的。我将深入基础金融理论，并解释如何使用 Python 执行均值-方差分析。虽然这些是复杂的数学主题，但我将主要关注底层逻辑，因为太多的公式会使任何事情看起来比它需要的更复杂。

这篇文章的结构如下:

1. 简要财务概述
2. 解释均值-方差分析
3. 将均值-方差分析应用于股票
4. 使用 Python 计算有效边界
5. 使用 Python 计算资本市场线
6. 向投资组合中添加加密货币并调查结果
7. 比较加密货币与其他替代资产的效果
8. 结论意见

本文的第 1 部分涵盖了第 1 点到第 5 点。您可以在这里找到将加密货币引入投资组合的部分:

[## 加密货币——新的前沿

Python、均值-方差分析、有效边界以及加密货币如何拓展边界

towardsdatascience.com](/cryptocurrencies-the-new-frontier-part-2-7218c6a489f9)

金融中的一些重要措施

提到股票价格(以及一般的任何资产价格)时，最重要和最常用的两个指标是回报率和波动性。

我们所说的回报率通常是指收益率，最常见的形式是简单收益率和对数收益率。要了解这两者之间的区别，请看这篇博客文章。现在，把回报想象成股票价格在给定时间间隔内的百分比变化，也就是说，如果某个股票价格今天是 100 美元，明天跳到 105 美元，回报(简单回报率)是 5%。

对于波动性，我们指的是回报的标准差，即回报方差的平方根。方差是对收益数据集分布程度的一种度量。因为方差是使用平方偏差计算的，所以它与原始观测值没有相同的测量单位。取平方根，即计算标准偏差，将这种测量转换成相同的单位，从而使分布的测量更容易解释和跨数据集比较。更大的利差意味着更多的上下波动，这就是为什么在金融中标准差通常是风险的衡量标准。更多关于标准差这里。

投资者通常会查看平均回报和风险来比较股票并做出投资决策。一般来说，与债券等其他资产相比，股票往往相对不稳定，降低投资股票风险的一种方法是投资多只股票。这就是习语“不要把所有的鸡蛋放在一个篮子里”的实际执行，被称为多元化。

分散投资或通过投资多只股票来降低整体投资组合风险背后的直觉是，选择价格和回报不会同步波动的股票。这样，如果一个下降，另一个可能保持不变或上升。你可以认为这是一种“平衡”。将历史上从未一起波动的股票包括在内，会使投资组合更加平衡。

当我们分析由多只股票组成的投资组合时，我们希望能够计算整个投资组合的预期收益和方差，而不是单只股票的预期收益和方差。为了做到这一点，除了它们的平均回报和标准差之外，我们需要知道投资组合中股票的两个度量之一:它们的协方差或相关性。

协方差和相关性是两个变量之间关系和依赖性的度量。本质上，相关性只是协方差的标准化版本，它测量两个变量之间线性关系的强度和方向。相关性的可能值介于-1 和 1 之间。正相关意味着两个变量趋向于同向移动，负相关意味着两个变量趋向于反向移动，零相关意味着变量之间没有关系。因此，对于投资组合多样化来说，最好的建议是组合那些回报具有低相关性或负相关性的股票(想想“平衡”的类比)。

计算投资组合的预期收益和方差的数学方法超出了本文的介绍范围，但是这篇博客文章用一个双资产投资组合提供了一个很好的解释。我们现在需要知道的是，整个投资组合的预期收益是投资组合中个股预期收益的加权平均值。投资组合的预期方差有点复杂，但本质上是单个股票的方差、它们在整个投资组合中各自的权重以及每对股票之间的相关性的产物。

什么是均值-方差分析？

均值-方差分析，通常被称为现代投资组合理论(MPT ),是一种关于投资组合构建的理论，由 Harry Markowitz 于 1952 年首次提出，后来他获得了诺贝尔经济学奖。该理论背后的主要思想是，通过调整投资组合中单个资产的权重，有可能构建最佳投资组合，在给定的风险水平下，提供最大可能的预期回报。MPT 的一个关键观点是，单个资产的回报率和波动性不应由其本身来评估，而应根据它对投资组合整体回报率和波动性的贡献来评估。

最佳投资组合，即在给定风险水平下最大化预期回报或在给定回报水平下最小化预期波动性的投资组合，可以绘制在图表上。连接最优投资组合的线将是一条向上倾斜的双曲线，它被称为有效边界。之所以称之为“有效”，是因为在给定的风险水平下，基于它的投资组合能提供最高的预期回报。

让我们看看使用 Python 应用均值-方差分析是什么样子的。对于接下来的部分，假设对 Python 有一个基本的了解，但是即使没有它，基本的逻辑和结论也将是清楚的(我强烈建议那些真正想了解 Python 的人搜索未知的 Python 术语)。

将均值-方差分析应用于股票

在开始分析之前，我们需要将股票价格数据导入 Python。令人欣慰的是，Pandas 有一个名为 pandas-datareader 的子程序包，可以很容易地从各种互联网资源中提取数据，并放入 pandas DataFrame 中。我将从雅虎财经中提取股票价格数据。但是我们如何决定提取哪些股票价格数据呢？

在这个例子中，我关注了标准普尔 500 中的 30 只股票。为了简单起见，我假装是一个业余投资者，他知道为了有一个多元化的投资组合，建议投资组合中有 15 到 30 只股票。因为我也知道来自不同行业的股票往往比来自同一行业的股票相关性更低，所以我试图构建投资组合，使其中包含的股票来自许多不同的行业。因为我有点懒，我就查了一下标准普尔 500 的成分，找到了一个按权重排序的列表，浏览了一下列表，从不同行业挑选了股票，直到我有了一个 30 只的列表。这绝不是选择股票的好策略，而且在我们的样本中必然会导致生存偏差，但为了简单起见，这已经足够好了(这也类似于许多人会考虑的相当多样化的投资组合)。

在接下来的内容中，我将包括最重要的代码块和可视化。完整的笔记本可以在这里找到。

下面是从 Yahoo Finance 中提取股票价格数据的代码:

这一提取提供了近五年的股票价格数据。我选择 2015 年 8 月 6 日作为开始日期的原因将在后面的分析中变得清楚。在我继续均值-方差分析之前，让我们简要地看一下这个分析中包含的股票价格的演变。以标准化方式绘制时间序列股票价格数据会产生以下图形:

正如时间序列显示的那样，亚马逊等一些股票在过去五年里取得了令人印象深刻的涨幅。似乎新冠肺炎的传播也导致了 2020 年初所有股票价格的大幅下跌。另一个观察结果是，尽管有不同的轨迹，股票价格往往一起移动，这意味着它们是正相关的。稍后将详细介绍。

正如我前面提到的，MPT 的主要思想围绕着寻找一个投资组合中的股票权重，在给定的波动水平下，这些股票可以带来最高的预期回报。但是我们如何计算出这些“最佳”重量呢？

在我继续之前，我想介绍两个公式，它们将是分析的基础(我知道我说过我将主要关注底层逻辑，但是这些公式对于理解下面的代码是必不可少的)。对于这两个公式以及随后的所有计算，我们假设只允许多头头寸(即只买入股票，不卖出股票)，并且头寸总和为 100%(即权重总和为 1)。第一个是投资组合的预期回报公式:

资料来源:Yves Hilpisch 的《金融 Python》

在上面的公式中，历史平均收益被假定为预期收益的最佳估计值，并被假定为正态分布。最后一个等式是投资组合的预期收益是单个资产预期收益的加权平均值，以向量乘法的形式表示。

第二个基本公式是投资组合的预期方差公式:

资料来源:Yves Hilpisch 的《金融 Python》

上述公式中的最后一个等式只是资产权重向量乘以协方差矩阵和资产权重向量的乘积的转置。

翻译成 Python，这两个公式都可以归结为一行代码，我将很快展示。回到资产的权重。

因为目前我们不知道“最优”资产权重是多少，所以一个好的开始是运行蒙特卡罗模拟，在其中我们随机分配 0 到 1 之间的权重(以权重相加为 1 的方式)。然后，我们计算由此产生的投资组合的预期收益和方差，重复这些步骤，无论我们认为需要多少次，并绘制结果。

我定义了一个函数，它将每日回报的数据帧和一个数字 N 作为输入，N 告诉函数要运行多少次模拟。值得注意的是，收益和(共)方差的“年化”是在收益相互独立且同分布的假设下计算的:

当使用 30 只股票的每日日志回报和 5，000 次模拟调用该函数并绘制结果时，我们得到以下散点图:

在散点图中，我根据夏普比率给点着色。夏普比率是金融中最常见的风险回报指标之一。它被定义为一项投资的超额回报(即超过无风险利率的回报)除以该项投资的波动性。计算夏普比率可以很容易地比较不同风险回报的投资。一般来说，夏普比率越高越好。在这个项目中，我假设无风险利率为 1%。

在下一节中，我将解释我们如何从随机生成的投资组合分散到计算有效边界。

使用 Python 计算有效边界

正如我前面提到的，有效边界是由所有的最优投资组合组成的，这些最优投资组合是由可用于组成这些投资组合的股票组成的。正如“最优投资组合”这个名字所暗示的，寻找构成这些投资组合的权重归结为一个优化问题。但是我们优化什么呢？

让我们考虑一下。我们希望找到在给定风险水平下具有最大预期回报的投资组合。由于 Python 的 SciPy 库中优化函数的设置方式，我们不得不将它重新定义为最小化问题。对于给定的风险水平，寻找具有最大期望回报的投资组合等同于对于给定的期望回报，寻找具有最小风险水平的投资组合。

我们需要做的是定义一个返回重要投资组合统计数据的函数:预期回报、波动性和夏普比率。在设置了最小化函数中使用的一些约束和初始权重后，我们可以调用该函数并生成预定义数量的最优投资组合，我们可以绘制这些投资组合并用于进一步分析。下面的代码就是这样做的:

调用 30 只美国股票的有效边界函数，并将其绘制在随机生成的投资组合散点图的顶部，会得到以下图形:

在上面的观想中，我包括了三颗星星。

蓝星代表最小方差投资组合。每一个位于该恒星上方和右侧的“x”构成了有效边界。位于蓝色星号下方和右侧的“x”不是有效的，因为很明显，具有相同预期波动率(x 轴值)的投资组合具有更高的预期回报(y 轴值)。

红星代表最大夏普比率投资组合，白星代表 5000 个随机生成的投资组合之一。

对于一些人来说，尤其是那些在大学或其他地方看过有效边界可视化的人，可能会感到困惑，为什么位于有效边界上的 x 距离随机生成的投资组合如此之远。其原因是，在沿着有效边界的投资组合中，许多股票被赋予了零权重，因为这是给定波动率下的最大回报。在蒙特卡洛模拟中，每只股票都被赋予一个介于 0 和 1 之间的权重，由于所包含股票的风险回报和协方差特征，这不会导致最优的投资组合分配。以下是最大夏普比率投资组合与白星代表的投资组合的配置比较:

比较最优和次优投资组合的权重分配

权重比较显示，随机选择的投资组合过度分配给不太“有价值”的股票(这里的有价值是指增加投资组合的多样化，同时也有助于预期回报)，而不足分配给更“有价值”的股票。

但是为什么最优投资组合只将资本分配给一部分股票呢？例如，为什么亚马逊在投资组合中占据了 50%以上的份额？为什么谷歌没有投资，但麦当劳却获得了大约 10%的资本分配？

通过查看股票的相关矩阵，并记住上表中显示的预期年回报率，我将提供一个基本逻辑的简单解释。整个相关矩阵太大，无法在此列出，但可以在笔记本中找到。

亚马逊在最大夏普比率投资组合中占据如此大的一块，原因很简单，因为它迄今为止的预期回报率最高，年回报率为 35.5%。此外，如果你考虑到亚马逊的预期波动性，它的吸引力就变得更加明显了。尽管拥有最高的预期回报率，但它的波动性在所有股票中仅排在第七位。事实上，亚马逊的预期波动性与摩根大通非常接近，后者的预期年回报率为 9.2%。

谷歌在最大夏普比率投资组合中的权重为零的原因是因为它是回报与亚马逊的相关性最高的股票。因为亚马逊已经在投资组合中占据了如此大的一部分，以分散投资，从而降低整体投资组合风险，所以剩余的权重需要分配给回报率与亚马逊相关性较低的股票。

这就是麦当劳的用武之地。它的股票回报率与亚马逊股票的相关性最低，这就是为什么尽管回报率平均，但从整个投资组合的角度来看，将它加入投资组合是有价值的。

必须谨慎地做出类似这样的简化陈述，因为在投资组合配置中，人们不能仅通过查看两只股票的风险回报情况和它们之间的相关性来得出任何结论，而是始终需要将投资组合视为一个整体。话虽如此，我认为使用亚马逊、谷歌和麦当劳的例子是理解底层逻辑的一个很好的起点。

短暂的转移话题后，让我们回到有效边界。在这一点上，有效边界的观想只包括单个的点，但是为了使它成为一个合适的边界，我们希望它是一条连续的线。为了使用构成有效边界的现有点创建一条连续线，我们可以插入数据点的 B 样条表示。听起来令人困惑，数学相当先进，但本质上 B 样条插值所做的是将曲线拟合(即近似)为一组点。这使我们能够把有效边界画成一条连续的线，但它也给了我们一个有效边界的连续函数，这在下一节会派上用场。

生成的连续曲线如下所示:

现在我们有了作为连续函数的有效边界，我们可以计算资本市场线。

使用 Python 计算资本市场线

到目前为止，我只考虑了由风险资产(这里是股票)组成的投资组合，但如果我们考虑无风险投资(通常是大型银行的现金账户)与风险投资相结合，会怎么样呢？

事实证明，这是资本市场线(CML)背后的基本理念。本质上，该理论建议投资者首先确定一个有效的风险资产组合(正如我们所做的那样)，然后在组合中加入一种无风险资产。正如我将很快展示的，将无风险投资与高效投资组合相结合，会极大地增强投资者的高效投资机会。

我们选择与无风险投资相结合的有效投资组合，是指有效边界的切线在绘制有效边界的 y 轴上恰好穿过无风险投资的回报。对于利率为 1%(即其回报率)的无风险投资，y 轴上的点将是(0，0.01)。

你们中的一些人可能还记得微积分课程(这里是给那些不知道的人的链接)我们可以用一个函数的一阶导数来找到这个函数在特定点定义的曲线的切线。这就是 B 样条插值给了我们一个连续(可微)函数的事实派上用场的地方。使用该连续函数及其一阶导数，结合一些条件，我们可以求解 CML。为了找到资本市场线，我们使用 SciPy 的 fsolve 函数(它找到一个连续函数的根),条件如下:

资料来源:Yves Hilpisch 的《金融 Python》

换句话说，第一个条件意味着在 x=0 时，函数必须等于无风险利率的回报，即 CML 的直线必须通过 y 轴上的该点。第二个条件简单地说明，对于 x 的任何值，函数必须满足线性函数方程(有些人可能记得在高中时写为 y=mx+b)。第三个条件规定函数的一阶导数必须等于参数 b，即斜率。

允许我们求解有效投资组合的代码是这样的，切线穿过 y 轴上无风险资产的收益:

这导致了以下资本市场线:

在上面的图像中，蓝色的星代表有效的投资组合，切线穿过无风险利率。至少根据现代投资组合理论，通过将无风险投资添加到有效投资组合中，投资者可以通过调整投资于无风险资产的财富比例，获得位于无风险资产和有效投资组合之间直线上的任何风险回报组合(甚至通过借钱超越该点)。投资于无风险资产的比例越大，你就越接近 CML 的原点，反之亦然，(风险)有效投资组合的比例越大，你就越接近蓝星。

下面是上述可视化的放大版本，以便与之前的版本进行比较:

随着 CML 的计算和绘制，本文的第一部分已经完成，我们可以继续分析在投资组合中包含加密货币会产生什么影响。你可以在这里找到文章的第二部分。

加密货币——新的前沿

原文：https://towardsdatascience.com/cryptocurrencies-the-new-frontier-part-2-7218c6a489f9?source=collection_archive---------26-----------------------

照片由 Clifford 摄影在 Unsplash

Python，均值-方差分析，有效边界以及加密货币如何拓展边界。

在这篇文章的第一部分中，我使用了 30 只来自不同行业的美国股票来计算有效前沿和资本市场线(CML)。在本文的这一部分，我将把加密货币添加到组合中，并分析它们对投资组合的影响。

让我们快速回顾一下到目前为止我们所知道的。由于一些股票的风险回报状况，特别是亚马逊，由此产生的有效投资组合显示了令人印象深刻的风险回报状况。由此得出的 CML 的斜率为 1.21，这是沿着这条线的任何财富分配的夏普比率。最优(正切)投资组合的预期年收益率为 27.4%。有效边界和资本市场线看起来像这样:

有可能把这些数字推得更高吗？如果是这样，我们会怎么做？

正如我在本文第 1 部分中提到的，增加与现有投资组合不相关的资产并获得可观的回报，可能会改善整个投资组合的风险回报状况。让我们使用一些流行的加密货币来实现这一点。

关于如何计算最优投资组合的详细描述，Python 中的有效边界和资本市场线请看本文的第一部分:

[## 使用 Python 进行股票和加密货币的均值-方差分析

Python，均值-方差分析，有效边界以及加密货币如何拓展边界。

towardsdatascience.com](/cryptocurrencies-the-new-frontier-part-1-940e787c7ab9)

将加密货币加入投资组合

首先，我们需要导入加密货币价格数据，我们可以将这些数据添加到我们迄今为止分析的 30 只美国股票的价格数据中。在这篇分析中，我重点关注四种最知名和最大的加密货币(就市值而言):比特币、以太坊、Tether 和莱特币。

绘制加密货币价格随时间变化的归一化时间序列如下图所示:

关于上述时间序列的一些观察结果:

1. 用正常的术语来说，以太坊在 2018 年经历了极端的峰值。
2. y 标签刻度的增量为 10，000(与第一部分中的股价时间序列的 y 轴相比)！).
3. 看起来莱特币、以太币和比特币似乎倾向于一起移动(即相关)，但 Tether 没有显示相关性，甚至没有移动。

因为上图中正常化的时间是 2015 年 8 月 6 日(这是以太坊价格被纳入雅虎财经的第一天)，这是一个加密货币极其新颖且价格非常低的时期，y 轴的刻度一直上升到 50，000。以太坊的起价为 2.77 美元，2018 年最高达到 1396.42 美元，几乎是起价的 504 倍。这显然是一个非常特殊的案例，我将在稍后对此进行评论。

上述时间序列揭示了一条对任何投资者都很直观的经验法则(但也可以说在生活中有更广泛的应用)，即更高的回报往往伴随着更高的风险。在这段时间内，投资加密货币的回报可能是巨大的，但时间序列图有很多起伏，在以太坊的情况下，非常极端，使它们非常危险。

在提取相关的加密货币价格并计算每日日志回报后，我很好奇加密货币价格的回报与股票回报之间的相关性。完整的相关性矩阵可以在笔记本中找到，但总结一下，在 2015 年年中到 2020 年年中的时间段内，加密货币回报和股票回报之间几乎没有相关性(至少对于本分析中包含的那些来说)。

加密货币似乎与现有投资组合中的任何股票都几乎不相关，加上它们令人印象深刻的回报，这一事实表明，从均值-方差的角度来看，将它们加入投资组合可能是有益的。让我们看看那是什么样子。

在上面的可视化中，蓝色聚类表示仅基于股票的随机生成的投资组合，橙色聚类表示基于股票和加密货币的随机生成的投资组合。橙色集群在 x 轴上分布得更广，这意味着基于股票和加密货币的随机生成的投资组合具有更广泛的可能风险，特别是朝着风险更高的一端。与此同时，即使风险水平相同，橙色集群也往往位于蓝色集群之上，表明橙色集群的风险回报状况更好。

同时使用股票和加密货币可以实现的有效边界位于仅使用股票的有效边界的上方和左侧，因此可以为任何风险提供更高的回报。

红星代表最大夏普比率投资组合，根据聚类和有效边界，使用股票和加密货币构建的投资组合提供了更高的回报，但也带来了更多的风险。纯股票投资组合和组合投资组合的夏普比率分别为 1.21 和 1.49。

画出各自的资本市场线使画面完整:

将加密货币添加到组合中，并将由此产生的高效投资组合与无风险投资相结合，可以提供比仅使用股票和无风险投资更高的风险回报。

在这一点上，有些人可能会说，“但是，等一下，你所做的只是将一种回报率几乎不相关的资产添加到投资组合中，难道你不能用任何回报率接近与投资组合不相关的资产，如黄金或白银，来实现同样的目标吗？”这是一个很好的观点。让我们看看那个。

黄金和白银与加密货币

在这一节中，我将遵循我用于将加密货币添加到股票投资组合中的相同步骤，但我将把黄金和白银添加到投资组合中，而不是加密货币。

首先，让我们再来看看标准化的时间序列:

一些观察结果:

1. 用正常的术语来说，在特定的时间段内(尤其是临近尾声的时候)，黄金的表现优于白银。
2. 黄金和白银价格似乎密切相关。
3. 新冠肺炎事件导致了黄金和白银的震荡，但白银受到的冲击尤为严重。

查看黄金、白银和所选的 30 只股票之间的相关性矩阵(可在笔记本中找到)突出了一个有趣的事实，这一组新的可用资产与之前的略有不同。与加密货币的回报大多与股票的回报呈小正相关不同，黄金和白银的回报与所选股票的回报呈小负相关(超过 5 年的时间段)。此外，黄金的波动性相对较低，但回报也不错。由于其优越的风险回报状况，黄金在所有最优投资组合中具有一定的正权重，而白银的权重为零。

基于黄金的这两个特征，即与大多数股票的负相关性和良好的风险回报状况，将黄金加入投资组合可以降低包括加密货币在内的货币无法实现的风险(因为它们与股票的相关性大多为正)。让我们看看有效前沿是如何比较的。

在上面的可视化中，绿色聚类稍微集中在蓝色聚类的左侧，但在垂直位置上大致处于相同的水平，这意味着将黄金和白银添加到投资组合中会产生随机投资组合，与只有股票的投资组合相比，其预期回报大致相同，但风险较低。

有趣的是，对于相对较低的风险水平(x 轴上的 0.1 到 0.15 之间)，股票和黄金以及股票和加密货币的有效边界似乎几乎重叠。我将很快放大到有效边界的那一部分。

红星代表最大夏普比率投资组合，由股票和黄金组成的最大夏普比率投资组合位于仅由股票或股票和加密货币组成的投资组合的下方和左侧。这进一步表明了将黄金加入投资组合的影响:它具有降低风险的效果，但由于其有限的预期回报，也降低了可以实现的回报。

放大股票和黄金以及股票和加密货币的有效前沿为我们提供了一个有趣的视角:

存在一个小的预期波动窗口，其中使用股票和黄金构建的最优投资组合实际上提供了比使用股票和加密货币构建的最优投资组合略高的预期回报。

最后，让我们比较一下资本市场线(为了保持形象清晰，我省略了有效边界):

使用由股票和黄金组成的有效投资组合结合无风险投资可以实现的 CML 介于仅股票和股票与加密货币之间。它的斜率更接近股票和加密货币的 CML。一个重要的注意事项是，蓝星代表最优投资组合，其切线穿过无风险利率截距。如果我们假设没有借款(出于多种原因，但主要是因为借款利率往往不同于投资利率)，这些蓝星也是沿着 CML 可以实现的有效投资集的极限。这意味着，尽管其斜率接近使用股票和加密货币的 CML 的斜率，但使用股票和黄金的 CML 的有效投资集在可实现的预期回报方面要有限得多。这是与比特币和以太坊相比，将黄金作为替代资产纳入投资组合的主要区别之一。

对于那些对将所有三种资产类别(股票、密码和金属)结合在一起或引入其他资产类别的效果感兴趣的人，我相信你现在可以自己尝试一下了(如果你遇到困难，请随时联系)。

结论意见

虽然本文中的分析得出了一些有趣的发现和令人印象深刻的风险回报结果，但我想再次说明，这绝不是投资建议，也不能在未来以任何方式复制。我想强调分析的几个非常重要的方面:

1. 该分析基于历史股票价格，这意味着最优投资组合的计算是事后诸葛亮。没有理由相信这些也将是未来的最优投资组合配置。
2. 被包括在内的股票的挑选方式受到生存偏差的影响。这些股票是通过简单地浏览当今标准普尔 500 中的顶级股票列表来挑选的，这意味着为了接近该列表的顶部，它们必须在最近几年中表现相对良好。因此，在我分析的时间范围内，这些股票注定会有不错的风险回报。
3. 加密货币在本次分析期间经历了令人难以置信的价格上涨，这种情况不太可能再次发生(至少以类似的方式)。
4. 根据均值-方差分析，最优投资组合的投资组合配置可能是最优配置，但这并不意味着只投资于少数股票，当这些股票组合成一个投资组合时，可以产生高夏普比率，从而形成一个非常多样化的投资组合，特别是从长期来看。原因是投资组合风险的重要维度超出了标准差。其中一个维度是终极财富转移(TWD)，更多信息请见这里的。
5. 仅仅因为某个资产类别与另一个资产类别不相关，并不意味着将其加入投资组合是有益的。Tether 就是一个很好的例子。由于其作为由法定货币支持的“稳定硬币”的性质，Tether 不会给投资组合增加任何回报。在投资任何资产之前进行研究是非常重要的，这对于加密货币尤其重要！
6. 现代投资组合理论的一些基本假设可能不是当今金融现实世界的完美代表。整个分析的一个基本假设是资产回报是正态分布的。我们来看看亚马逊和比特币的回报分布:

两种分布似乎都有“厚尾”和“高峰”，这意味着更接近平均值的回报和远离平均值的回报比正态分布更有可能出现。离群值似乎也会影响分布。在亚马逊的情况下，最高的每日日志回报大约是均值以上 6.5 个标准差，而在比特币的情况下，最负的每日日志回报几乎是均值以下 10 个标准差。正态分布回报的假设虽然在理论上非常有用，但在现实世界中可能并不完美。

尽管如此，本文的目的并不是预测未来或构建完美的投资组合。本文的目的是解释什么是均值-方差分析，以及如何使用 Python 来完成它。我的目标是用更容易理解的语言解释这个有点复杂的话题，同时指出为什么单单投资股票可能会限制一个人多样化的可能性。

我希望你喜欢这个现代投资组合理论的演示。如果您有任何问题或想聊些什么，请随时通过 LinkedIn 与我联系。

感谢阅读！

用 LSTM 预测加密货币

原文：https://towardsdatascience.com/cryptocurrency-prediction-with-lstm-4cc369c43d1b?source=collection_archive---------13-----------------------

如何预测汇率的趋势

虽然第一种重新分配的加密货币(比特币)是在 2009 年创造的，但数字货币的想法却出现在 20 世纪 80 年代。近年来，加密货币获得了惊人的流行。作为传统货币，加密货币的价值随着时间而变化。使用历史数据，我将使用 LSTM(长短期记忆)层实现一个递归神经网络，以预测未来加密货币价值的趋势。

安德烈·弗朗索瓦·麦肯齐在 Unsplash 上的照片

Kaggle 上有一个关于加密货币市场价格的庞大数据集。我只使用莱特币历史价格数据的一部分。

和往常一样，我们从导入库开始:

import numpy as np
import pandas as pdimport matplotlib.pyplot as plt
import seaborn as sns
sns.set(style="darkgrid", font_scale=1.5)%matplotlib inline

导入库后，我们现在可以获得我们需要的数据:

df = pd.read_csv("crypto-markets.csv", parse_dates=["date"], index_col="date")df.shape
(942297, 12)df.head()

该数据集包括近 100 万行。我只需要“莱特币”的“开放”王子。

df = df[df.slug == "litecoin"][["open"]]df.shape
(2042, 1)

我们现在有莱特币从 2013 年 4 月到 2018 年 11 月的历史数据。让我们来看看它是如何随着时间而变化的。

plt.figure(figsize=(12,6))
sns.lineplot(x=df.index, y="open", data=df).set_title("Price of Litecoin")

在经历了 2013 年底的一个小高峰后，市场陷入了长时间的沉默。然后在 2017 年底达到最高值。我们可以通过应用下采样使图形看起来更平滑。

df.resample('10D').mean().plot(figsize=(12,6))plt.figtext(.5,0.9,"Down-sampled to 10-day periods", fontsize=20, ha='center')

型号

长短期记忆(LSTM)是一种递归神经网络(RNN ),对序列数据建模非常强大，因为它保持一种内部状态来跟踪它已经看到的数据。LSTMs 的常见应用包括时间序列分析和自然语言处理。

LSTM 要求输入是具有形状(batch_size，timesteps，input_dim)的 3D 张量。

我将建立一个模型，使用过去的 90 个值(从 t-90 到 t-1)预测时间 t 时莱特币的价值。因此时间步长的数量是 90。我仅使用“开盘价”进行预测，因此 input_dim 为 1。目标变量是莱特币的“公开”价格，它会受到许多其他因素的影响。例如，另一种加密货币的价值可能会对莱特币产生影响。如果我们还使用第二个变量来进行预测，那么 input_dim 将是 2。

数据预处理

我将重新组织数据，使用前 90 天的值序列来预测时间 t 的值。由于在神经网络中进行了过多的计算，因此最好将这些值标准化。

data = df.iloc[:, 0]hist = []
target = []
length = 90for i in range(len(data)-length):
    x = data[i:i+length]
    y = data[i+length]
    hist.append(x)
    target.append(y)

第一个元素的最后一个时间步长与原始数据的第 90 个时间步长相同，这正是我们计划要做的。

hist 的第二个元素应该只是第一个元素的一个时间步长偏移版本。因此，第二个元素中的最后一个时间步长应该等于目标变量的第一项，即原始数据中的第 91 个时间步长。

让我们仔细检查以确认:

print(hist[1][89])
print(data[90])
print(target[0])2.9
2.9
2.9

Hist 和 target 是列表。我们需要将它们转换成 numpy 数组，并对目标变量进行整形。

hist = np.array(hist)
target = np.array(target)target = target.reshape(-1,1)

让我们检查历史数组和目标数组的形状:

hist.shape
(1952, 90)target.shape
(1952, 1)

Hist 阵列包括 1952 个观测值，每个观测值包括 90 个时间步长(90 天)。

现在，我们可以对数据进行归一化，压缩 0 到 1 范围内的所有数据点，使最大值和最小值分别为 1 和 0。标准化可以通过应用一个简单的数学方程或者仅仅使用一个像 MinMaxScaler 这样的函数来完成。

from sklearn.preprocessing import MinMaxScalersc = MinMaxScaler()
hist_scaled = sc.fit_transform(hist)
target_scaled = sc.fit_transform(target)

预处理的最后一步是调整输入数组的形状，使其与 LSTM 图层兼容。

hist_scaled = hist_scaled.reshape((len(hist_scaled), length, 1))
print(hist_scaled.shape)
(1952, 90, 1)

训练和测试集

我们的数据集包括 1951 个样本(天)。输入样本包括连续 90 天的莱特币价值，目标变量是 90 天后第二天的莱特币价值。

我将以一种方式分割数据集，即 1900 个样本用于训练，然后该模型将用于预测未来 51 天的趋势。

X_train = hist_scaled[:1900,:,:]
X_test = hist_scaled[1900:,:,:]y_train = target_scaled[:1900,:]
y_test = target_scaled[1900:,:]

构建神经网络

import tensorflow as tffrom tensorflow.keras import layers

我将建立一个有 3 个 LSTM 层和 1 个输出层的密集层的模型。

model = tf.keras.Sequential()model.add(layers.LSTM(units=32, return_sequences=True,
                  input_shape=(90,1), dropout=0.2))model.add(layers.LSTM(units=32, return_sequences=True,
                  dropout=0.2))model.add(layers.LSTM(units=32, dropout=0.2))model.add(layers.Dense(units=1))model.summary()

我们现在需要编译模型。编译模型时，应选择用于调整权重的优化器。Tensorflow 提供了许多优化器。回归任务中常用的优化器有“adam”和“rmsprop”。此外，应该选择损失函数。由于这是一个回归任务，我们可以选择“均方误差”。

model.compile(optimizer='adam', loss='mean_squared_error')

是时候训练模型了。我们需要在这里指定两个超参数:

• batch_size=在更新模型的内部参数之前，通过神经网络工作的样本数。如果 batch_size 为 1，则在将每个样本(或观察值)馈送到神经网络后，会更新参数。
• 次数:整个训练集向前和向后通过神经网络的次数。

history = model.fit(X_train, y_train, epochs=30, batch_size=32)

该模型似乎在 30 个时期内收敛，因此没有必要进行额外的时期。损失不到 0.002 我觉得已经很不错了。

让我们想象一下随着时代数量的增加，损失是如何变化的。

loss = history.history['loss']
epoch_count = range(1, len(loss) + 1)
plt.figure(figsize=(12,8))
plt.plot(epoch_count, loss, 'r--')
plt.legend(['Training Loss'])
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.show();

看起来这个模型在 15 个纪元后已经收敛了。之后亏损在 0.0018 附近上下反弹。

现在是做预测的时候了。

pred = model.predict(X_test)plt.figure(figsize=(12,8))
plt.plot(y_test, color='blue', label='Real')
plt.plot(pred, color='red', label='Prediction')
plt.title('Litecoin Price Prediction')
plt.legend()
plt.show()

我们的模型很好地确定了趋势。您可能已经注意到，这些值比原始值小得多，因为我们在训练模型之前对这些值进行了规范化。我们可以进行逆变换来反映真实价格，但趋势是相同的。

pred_transformed = sc.inverse_transform(pred)
y_test_transformed = sc.inverse_transform(y_test)

总有改进的空间。神经网络的燃料是数据，因此我们可以通过收集更多的数据来建立一个更鲁棒和准确的模型。我们还可以尝试调整一层中的节点数量或添加额外的 LSTM 层。我们还可以尝试增加时间步长的数量，在我们的模型中是 90。另一种改进方法是使用 GridSearchCV 调整参数。

请记住，提高模型精度并不总是好的，因为我们最终可能会有一个过度拟合的模型。

你可以在这里找到整个 jupyter 笔记本。

感谢阅读。如果您有任何反馈，请告诉我。

清晰的强化学习

原文：https://towardsdatascience.com/crystal-clear-reinforcement-learning-7e6c1541365e?source=collection_archive---------25-----------------------

用于此插图图片的像素图像

强化学习的综合简明概念

强化学习(RL)是人工智能和机器学习的最热门领域，在过去几年中有许多惊人的突破。这篇文章试图给出整个 RL 光谱的一个简明的视图，而不要过多地进入数学和公式，同时也不要忽略茂密复杂的森林中的树木。

现在首先让我们了解什么是强化学习或 RL？

RL 意味着在头脑中考虑长期结果或累积 回报的情况下采取最佳行动。

用于此插图图片的像素图像

强化学习(RL)是通过与环境交互进行的学习。强化学习代理从其动作的结果中学习，而不是从明确的教导中学习，它根据其过去的经验(利用)以及新的选择(探索)来选择其动作，这是必不可少的，试错学习就像孩子学习一样。RL-agent 接收到的强化信号是一个数字的奖励，它编码了一个动作结果的成功，agent 试图学习选择那些随着时间的推移使累积奖励最大化的动作。

用于此插图图片的像素图像

在我们深入研究 RL 之前，让我们先看看为什么 RL 在人工智能和机器学习领域如此重要。参考下面的图表，它显示了 RL 在生活的各个领域中的应用。

用于此插图图片的像素图像

现在，我将介绍一些经常用来解释强化学习的术语，在深入研究算法和更吸引人的概念之前，人们必须理解这些术语。

用于此插图图片的像素图像

在上图中，我列出了名称、标准符号和图示。现在，我将分别对它们进行定义。

代理人

任何使用某种传感器感知其环境并能够在环境中产生行动的东西都被称为代理。代理执行动作，接受观察，并给予奖励。

环境

环境是代理交互的总体表示。该媒介不被认为是环境的一部分。环境接受一个动作，发出观察和奖励。

状态

状态描述了当前的情况，并决定了接下来会发生什么。代理可能有状态的局部视图，这被称为观察。

报酬

当一个代理在一个州采取行动时，它会收到一个奖励。这里的术语“奖励”是一个抽象的概念，描述来自环境的反馈。奖励可以是正面的或负面的。当奖励为正时，对应的是我们通常意义上的奖励。当奖励为负时，对应的就是我们通常所说的“惩罚”。

Pixabay，Atari & Tesla 图像用于此插图图片

奖励是代理在每个时间步从环境中得到的反馈。然后，它可以使用这个奖励信号(对于好的行为可以是积极的，对于坏的行为可以是消极的)来推断在一种状态下如何表现。总的来说，目标是解决一个给定的任务，尽可能获得最大的回报。这就是为什么许多算法对代理采取的每一个动作都有一个微小的负奖励，以激励它尽快解决任务。奖励是在 RL 中至关重要的设计决策，因为这将鼓励 RL 代理优化行为。例如，以更少的时间赢得象棋比赛或以平均速度驾驶汽车但不发生任何碰撞(汽车可以在空旷的高速公路上加速，而在繁忙的道路上缓慢行驶)。奖励告诉我们什么是好的直接感觉。比如雅达利游戏，每一个时间步代理都是得分或者失分的。

贴现因素

现在的奖励比未来的奖励更有价值。贴现因子，通常表示为γ，是一个乘以未来预期回报的因子，在[0，1]的范围内变化。它控制着未来回报相对于眼前回报的重要性。折扣因子越低，未来的回报就越不重要，代理人将倾向于专注于只产生即时回报的行动。贴现率被限制为小于 1 的事实是一个使无限和有限的数学技巧。这有助于证明某些算法的收敛性。贴现因子用于确定未来报酬的现值(类似于由于通货膨胀等因素贴现的未来货币的现值)。

状态值

状态值“V(S)”是从该状态开始的一段时间内代理可以期望积累的奖励总额。与奖励信号不同，价值函数指定了长期 中什么是好的。

行动

动作是代理在每个状态下可以做的事情。例如，机器人的步幅只能是 0.01 米到 1 米。围棋程序只能在 19 x 19(即 361)个位置中的一个位置放下棋子。自动驾驶汽车可能会向不同的方向行驶。

动作值

动作值或状态-动作值函数(Q 函数)指定代理在具有策略π的状态下执行特定动作的良好程度。Q 函数用 Q(S，A)表示。它表示在遵循策略π的状态下采取行动的价值。这里的‘q’指的是一个动作的质量。

政策

策略是代理从状态中选择的动作。策略是在一种状态下行动的映射，这种状态可以是确定性的或随机性的。该策略由 π表示。

环境模型

这个模型是对环境的模拟。它知道从一个状态到另一个状态的转换，以及对环境的高层次理解。

用于此插图图片的像素图像

现在，我将介绍一些基本概念，如勘探、开发、策略上、策略下等。在我们深入研究 RL 算法之前。

开采和勘探

开发和探索的概念与人类的本性有着内在的联系，作为人类，我们更喜欢已知而不是未知。例如，去餐馆，你可以选择去你最喜欢的餐馆，因为你已经喜欢那里的食物，但除非你尝试另一家餐馆，否则你不会知道是否存在更好的餐馆。

用于此插图图片的像素图像

因此，开发就是去做同样的事情，从一个国家获得最大的价值(这通常被称为贪婪的行为)，而探索就是尝试新的活动，从长远来看，这些活动可能会带来更好的回报，即使眼前的回报可能并不令人鼓舞。在上图中，如果代理人只考虑即时奖励，通过跟随红色路径获得最大奖励，它将在稍后发现具有更高价值的蓝色路径，即使即时奖励较低。这就是为什么需要探索来获得更好的长期回报。

符合政策和不符合政策

在非策略学习中，我们评估目标策略(π)，同时遵循另一个称为的策略行为策略 (μ)(这就像机器人遵循视频或基于另一个代理获得的经验的代理学习)。“在策略上”表示代理遵循它用来更新目标的相同策略。

用于此插图图片的像素图像

规划和学习

RL 算法可分为规划或学习算法。在规划中，代理需要知道环境的模型(代理知道转移概率)，然后在该模型下规划最优策略。在学习问题中，代理不了解环境的动态，它需要通过试错进行交互，以了解环境，从而得出最优策略或最优状态值。

基于模型和无模型

在基于模型的 RL 问题中，代理知道环境的模型，这意味着它知道转换动态，并且主要目标是计划最优动作。在无模型 RL 中，代理不知道转换或其他动态；相反，它必须通过与环境的互动来学习什么样的可选动作会产生最佳结果。

强化学习“规划”算法

马尔可夫决策过程(MDP)

马尔可夫决策过程(MDP)是复杂决策过程的数学表示。(MDP)正式描述强化学习的环境。环境是完全可观察的和静止的(意味着规则不随时间改变)。几乎所有的 RL 问题都可以用 MDP 来形式化。MDP 的定义是:

• 一个状态 S，它代表了在一个定义的世界中，一个人可能处于的每一个状态。只有**现在重要，**这意味着转移函数仅取决于当前状态 S，而不取决于任何先前状态。

用于此插图图片的像素图像

• 一个模型或转移函数 P，它是当前状态、所采取的行动以及我们最终所处的状态的函数。这种转变产生了一定的概率，以状态 S '结束，在途中获得奖励 R，从状态 S 开始，并采取行动 a。
• 奖励是处于一种状态的一个标度值。它告诉我们进入状态的用处。

MDP 的最终目标是找到一个政策，它可以告诉我们，对于任何一个州，该采取什么行动(记住，将州映射到行动是我们的政策)。最优策略是使长期预期回报最大化的策略。一旦找到最优策略，RL 问题就解决了。

在 RL 中，我们考虑如何计算任意策略π的状态值函数 V(S)。这在 RL 文献中被称为政策评估(也称为预测问题)。通过使新策略相对于原始策略的价值函数变得贪婪来改进原始策略的过程被称为策略改进或控制。

广义策略迭代

广义策略迭代(GPI)是指让策略评估和策略改进过程相互作用的总体思想，独立于两种方法的粒度和其他细节。这就像梅西和 c 罗在同一支球队踢一场足球赛。他们每次传球都是为了个人进球而互相竞争，但他们也互相协助为球队赢得比赛。同样，GPI 就像一场足球比赛，最终目标是找到最优政策/最优价值函数。在一次扫描中(可能是全部情节，也可能是每一步或几步)，对策略进行评估，以计算出该策略的价值。然后通过对旧政策采取贪婪的行动来改进政策。重复这一过程，直到出现收敛，并找到最优策略或最优值。

贝尔曼方程

特定状态的值等于当前状态的奖励，加上从该点开始从当前状态 S 过渡到未来状态 S’时得到的折扣奖励。

价值迭代

为了求解贝尔曼方程，我们通常从所有状态的任意值开始，然后基于邻居(从当前状态可以到达的所有状态)更新它们。最后，我们重复直到收敛。这个过程叫做**“价值迭代。”值迭代是一个组合一个(或多个)政策评估扫描，然后执行另一个政策改进扫描**。重复这个过程，直到收敛发生。价值迭代包括:寻找最优价值函数 +一个策略抽取。这两者没有重复，因为一旦价值函数是最优的，那么由此得出的策略也应该是最优的(即，收敛的)。

策略迭代

这是一个 GPI 过程，其中通过执行单调改进的策略和值函数来改进策略:通过重复策略评估，然后执行策略改进。每一个策略都保证是对前一个策略的严格改进(除非它已经是最优的)。因为有限的 MDP 只有有限数量的策略，所以这个过程必须在有限数量的迭代中收敛到最优策略和最优值函数。这种寻找最优策略的方式称为策略迭代。策略迭代包括策略评估 + 策略改进，两者反复迭代直到策略收敛。

RL“学习”算法

在 RL 问题中，我们的目标是找到每个状态的最优值或者找到最优策略。根据算法是如何制定的，它们大致分为三类。我们还可以根据策略(开或关)选择不同的模式

基于值的算法

用于此插图图片的像素图像

蒙特卡洛学习

蒙特卡罗方法是一个简单的概念，当它与环境交互时，代理学习状态和奖励。在这种方法中，代理生成经验样本，然后基于平均回报，为状态或状态-动作计算值。下面是蒙特卡罗(MC)方法的关键特征:

1. 没有模型(代理不知道状态 MDP 转换)
2. 代理人从采样的经验中学习
3. 通过体验来自所有采样剧集的平均回报，学习策略π下的状态值 vπ(s )(值=平均回报)
4. 仅在完成一集之后，值才被更新(因为该算法收敛缓慢，并且更新发生在一集完成之后)
5. 没有自举
6. 仅可用于偶发性问题

在蒙特卡罗方法中，我们使用代理人根据政策采样的经验回报率，而不是预期回报率。考虑下面的图表，我们看到五个不同的轨迹(轨迹是代理在一集里所走的路径),代理从一集开始到结束都经历了这些轨迹。在这种情况下，for starting 状态出现在所有五个样本中，并且该状态的值将是在五个展开中采样的五个值的平均值。

有两种 MC 方法:第一次访问 MC 和每次访问 MC。

用于此插图图片的像素图像

在计算一个状态的值时，只计算第一次访问，即使该状态被多次访问。在每次访问 MC 中，每次在一集内访问该州时，该州的值都会受到访问次数的影响(参考以下示例中的 S3 州值。

用于此插图图片的像素图像

TD(0)

TD(0)是时间差分(TD)学习的最简单形式。在这种形式的 TD 学习中，在每一步值函数都用下一个状态的值和沿途的更新后，得到奖励。这种观察到的回报是保持学习接地气的关键因素，算法在足够数量的采样后收敛(在无穷大的极限内)。所有 TD 方法都具有以下特征:

1. 没有模型(代理不知道状态 MDP 转换)
2. 代理从采样的经验中学习(类似于 MC)
3. 像 DP 一样，TD 方法部分基于其他学习的估计更新估计，而不等待结果(它们像 DP 一样引导)。
4. 它可以从不完整的插曲中吸取教训；因此，该方法同样可以用于连续问题。
5. TD 将猜测更新为猜测，并根据实际经验修改猜测。

参考下图，其中状态值在每一步之后从下一个状态值更新(学习率(α) 是一个决定从下一个状态和当前状态之间的差中取多少来更新当前状态的因素)。这种差异被称为 TD 误差。

用于此插图图片的像素图像

萨尔萨

控制或改进的 TD 算法之一是 SARSA。SARSA 的名字来源于这样一个事实，即代理从一个状态-动作值对向另一个状态-动作值对迈出一步，并在此过程中收集奖励 R(因此它是 S( t)，A( t)，R (t+1)，S (t+1) & A(t+1)元组，它创建了术语 S，A，R，S，A )。SARSA 是一种基于策略的方法。SARSA 使用动作值函数 Q 并遵循策略π。 GPI (广义策略迭代)用于基于策略π采取行动(ε-贪婪确保探索以及贪婪改进策略)。参考下图，我们可以看到下一个操作可以是基于策略的任何下一个操作。

用于此插图图片的像素图像

q 学习

Q-learning 是一种非策略算法。DQN(深度 Q-learning)登上了《自然》杂志的头版，它是一种基于 Q-Learning 的算法(几乎没有额外的技巧)，在雅达利游戏中超越了人类水平的专业知识(我将在未来的帖子中详细介绍 DQN)。在 Q-learning 中，目标策略是贪婪策略，行为策略是ε-贪婪策略(这确保了探索)。

用于此插图图片的像素图像

参考下图。接下来的行动是基于一个贪婪的政策。

用于此插图图片的像素图像

预期 SARSA

预期 SARSA 就像 Q-learning 一样，除了它使用期望值(基于概率的平均值)而不是下一个状态-动作对的最大值，同时考虑了每个动作在当前策略下的可能性。给定下一个状态，Q-learning 算法确定性地将向同一方向移动，而 SARSA 按照期望跟随，因此，它被称为期望 SARSA。参考下文，下一步行动基于预期值。

用于此插图图片的像素图像

基于 SARSA 概念的这些控制算法的主要区别如下图所示。

用于此插图图片的像素图像

接下来，我们将介绍一些基于时间差概念的算法，但这些算法的值不会立即更新，而是在几步之后更新，或者基于几个状态的平均值进行更新。

n 步 TD / SARSA

在 n 步 TD 中，状态值或动作值在一定数量的时间步后更新。在这些情况下，代理在值更新之前收集更多的奖励。在一定数量的步骤之后，根据沿途收集的所有折扣奖励和状态或状态-动作的价值函数来更新价值。

用于此插图图片的像素图像

TD(λ)

TD(λ)是 n 步 TD 的扩展。直觉是将所有可能的 n 步回报平均成一个单一的回报。我们使用随时间呈指数衰减的权重对 n 步回报进行加权。这是通过引入因子λ(值在 0 和 1 之间)并将第 n 次返回加权为(n-1)次幂λ来实现的。因为我们希望所有这些权重相加为一(得到一个加权平均值)，所以我们将它们归一化。

我们可以看到，当λ = 1 时，只保留最后一项，这本质上是蒙特卡罗方法，作为状态，作用过程一直进行到最后，当λ = 0 时，该项还原 TD (0)方法，对于 0

用于此插图图片的像素图像

这可以使用资格跟踪来进一步改进，这是一个绝妙的想法，它允许我们基于对过去发生的事情的记忆来更新每个状态值，并使用当前信息来更新我们到目前为止看到的每个状态的状态值。资格追踪结合了两件事:一是多频繁二是一个州多近。在 RL 中，将在下一个状态学到的东西也扩展到先前的所有状态以加速学习将是有用的。为了实现这一目标，需要有一个短期记忆机制来存储在最后步骤中访问过的状态。这就是资格跟踪概念出现的地方。λ∈[0，1]是称为 trace-decay 或 **accumulating trace，**的衰减参数，其定义了每个被访问状态的更新权重。痕迹随时间减少。这允许对不频繁的状态给予小的权重，而对最近访问的状态给予大的权重。对于λ=0，我们有 TD(0)的情况，只有前一个预测被更新。TD(1)可以被认为是使用 TD 框架的 MC 方法的扩展。在 MC 方法中，我们需要等到剧集结束时更新状态。在 TD(1)中，我们可以在线更新所有之前的状态，并且我们不需要剧集的结尾。现在让我们看看在一个事件中特定的状态跟踪会发生什么。我将考虑一集七次访问，其中访问了五个州。在该事件期间，状态 s1s1 被访问两次。让我们看看它的踪迹会发生什么变化。

参考上图；开始时，迹线等于零。在第一次访问 S1(第一步)后，迹线上升到 1.0，然后开始衰减。在第二次访问(第 3 步)之后，将+1 加到当前值(0.50)，获得 1.50 的轨迹。在三个以上的步骤之后，S1 被重新访问，使得踪迹值为 1.75(注意，这里指数衰减仅仅被显示为在每个步骤中减少 0.25，为了说明的自由，实际值将会不同)。

TD(λ)如何更新值函数？在 TD(λ)中，先前的状态是可访问的，但是它们是基于资格跟踪值更新的。具有小资格轨迹的州将被少量更新**，**，而具有高资格轨迹的州将被大量更新。

深 Q 网(DQN)

这是整合深度学习和强化学习的主要成功故事之一，它打开了新算法的闸门，并重新引起了人们对强化学习领域的兴趣。深度神经网络用作 Q 值的函数逼近器。深度 Q 学习简单地应用神经网络来近似每个动作和状态的 Q 函数，这可以节省大量的计算资源，并且潜在地扩展到连续时间动作空间。

体验回放:我们运行代理，将最近的 10 万个过渡(或视频帧)存储到一个缓冲区中，并从这个缓冲区中抽取一个 512 大小的小批量样本来训练深度网络。当我们从重放缓冲区随机取样时，数据更加相互独立，更接近于同分布(独立同分布)。这使得降雨稳定。

目标网络:我们创建两个深度网络θ-(目标网络)和θ(Q-网络)。我们使用第一个来检索 Q 值，而第二个包括训练中的所有更新。比如说 50，000 次更新后，我们将θ-与θ同步。目的是暂时固定 Q 值目标，这样我们就没有一个移动的目标可以追逐。此外，参数变化不会立即影响θ-，因此即使输入也变得接近 i.i.d。

下面是 DQN 的图表和步骤。

1. 预处理并将状态提供给 DQN，后者将返回状态中所有可能动作的 Q 值
2. 使用ε-贪婪策略(行为策略)选择一个动作。对于概率ε，我们选择随机动作 a，，对于概率 1-ε，我们选择具有最大 Q 值的动作，例如 A= argmax (Q(S，A，θ))
3. 在状态 S 中执行该动作，并移动到新的状态 S ’ 以获得奖励 r。在 Atari 模拟器的情况下，该状态 S '是下一个游戏屏幕的预处理图像。我们将这个过渡存储在我们的重放缓冲器中作为< S，A，R，S’>
4. 接下来，从重放缓冲区中随机抽取一些批次的转换样本，并计算损失，这只是目标 Q(奖励+贴现的最大下一个 Q 值(贪婪目标策略))和预测 Q 之间的平方差。
5. 根据我们的实际网络参数执行梯度下降，以最小化这种损失
6. 每 N 次迭代后，将我们的实际网络参数(θ)复制到目标网络参数(θ-)
7. 重复这些步骤达 M 集数以收敛参数θ

双 Q 学习

Q-Learning 在一些随机环境中表现很差。由于在 Q-learning 中使用Max Q(S’，A’)导致动作值被大大高估，从而导致性能不佳。主要概念是通过将目标中的 max 操作分解为动作选择和动作评估来减少高估。在 Doble Q-learning 中，我们维护两个 Q 值函数 Q-A 和 Q-B(在 Double Deep Q 网络中，这两个通过称为目标网络和 Deep Q 网络的两个不同的函数近似来支持)，每个都从另一个获得下一个状态的更新。Q-A 决定在下一个状态中导致最佳动作值的动作，而 Q-B 使用 Q-A 选择的那个动作来决定状态动作的期望值是多少(这里的算法是维护两个网络)。

用于此插图图片的像素图像

决斗 DQN

q 值可以分解为两部分:状态值函数 V 和优势值 a。优势函数捕获在给定状态下，某个动作与平均动作相比有多好(参见 A3C，了解优势函数的直观解释)。同时，正如我们所知，价值函数捕捉到了处于这种状态有多好。

决斗 Q 网络背后的整个思想依赖于将 Q 函数表示为值和优势函数的总和。

我们简单地用两个网络来学习和的每一部分，然后我们合计它们的输出。参考下图，其中全连接(FC)层有两个头(一个用于 V，一个用于所有 A)。

将这种类型的结构添加到网络中允许网络更好地区分彼此的动作，并且显著地改进了学习。在许多状态下，不同动作的值非常相似，采取哪种动作并不重要。这在有许多操作可供选择的环境中尤其重要。

基于策略的算法

用于此插图图片的像素图像

在基于策略的方法中，我们不是学习告诉我们给定一个状态和一个动作的期望回报总和的值函数，而是直接学习将状态映射到动作的策略函数(选择动作而不使用值函数)。政策梯度背后的关键思想是提高导致更高回报的行动概率，而降低导致更低回报的行动概率，直到我们得出最优政策。

策略梯度方法的目标是直接建模和优化策略。策略 π (A|S)通常用参数化函数 θ 建模。奖励(目标)函数的值取决于这个策略，然后可以应用各种算法来优化 θ 以获得最佳奖励。在基于策略的方法中，我们显式地构建一个策略的表示(映射π:S→A ),并在学习期间将其保存在内存中。

很自然地期望基于策略的方法在连续空间更有用。因为存在无限数量的动作和(或)状态来估计值，因此基于值的方法在连续空间中在计算上过于昂贵。例如，在一般化的策略迭代中，策略改进步骤需要对动作空间进行全面扫描，遭受了维数灾难。

用于此插图图片的像素图像

加固

加强(蒙特卡洛政策梯度)依赖于通过蒙特卡洛方法使用事件样本更新政策参数θ的估计回报。因为样本梯度的期望值等于实际梯度，所以加强是可行的。在加强中，代理使用其当前策略收集一集的轨迹τ，并使用它来更新策略参数。下面是加固的步骤。

1. 随机初始化策略参数θ。
2. 在策略π上生成一个轨迹
3. 估算每个时间步的回报，直到最终状态
4. 通过一步梯度上升更新政策参数:θ(价值函数的梯度可以计算为政策梯度(的对数)的梯度期望值乘以奖励— 这是政策梯度的主要技巧)
5. 重复 2–4 直到收敛

强化以基于策略的方式训练随机策略。这意味着它通过根据其随机策略的最新版本对行为进行采样来进行探索。动作选择的随机性取决于初始条件和训练程序。在整个训练过程中，策略通常变得越来越不随机，因为更新规则鼓励它利用它已经发现的奖励。这可能导致策略陷入局部最优。下图是对钢筋的解释。我们希望更新有正回报的策略参数，并减少有负回报的策略参数。

需要注意的重要一点是，这里没有使用马尔可夫性质，这也可以用于部分观测的 MDP，而不需要在算法上做任何改变。

这种方法的一个主要缺点是方差大和收敛慢。

用基线加强

为了减少方差，一个想法是从返回 G(S)中减去一个称为基线 B(S)的值，其中 B(S)不依赖于动作 a。从数学上仍然可以看出，政策梯度仍然在预期中给出无偏的结果。

所以现在的问题是如何选择 B(S)。对基线的选择之一是计算状态值 V(S，w)的估计，其中 w 是通过诸如蒙特卡罗的一些方法学习的参数向量。

演员-评论家算法

用于此插图图片的像素图像

政策梯度的两个主要组成部分是政策模型和价值函数。除了策略之外，学习价值函数是很有意义的，因为知道价值函数可以帮助策略更新，例如通过减少普通策略梯度中的梯度方差，并且这正是参与者-批评家方法所做的，其中参与者是策略并且批评家是价值函数。

行动者-批评家方法由两个模型组成，这两个模型可能共享也可能不共享参数:

• 评论家更新值函数参数‘w’，根据算法，它可以是动作值 Q 或状态值 v。
• 行动者按照批评者建议的方向更新策略参数‘θ’。

正如我们前面看到的，减少政策梯度方法的方差和增加稳定性的一个方法是用基线减去累积回报(回报)。该基线减法在预期中是无偏的。因此，我们在这里做的是通过一些基线来调整回报，这减少了方差。有许多方法可以改进增强算法。

A3C

异步优势行动者-批评家(A3C) 算法是一种经典的策略梯度方法，特别关注并行训练。这是一个典型的政策梯度方法，特别强调平行培训。该算法使用多个代理，每个代理都有自己的网络参数和环境副本。这些代理与它们各自的环境异步交互，在每次交互中学习。一个全球网络控制着每个代理。随着每个代理获得更多的知识，它有助于全球网络的总知识。全球网络的存在允许每个代理具有更多样化的训练数据。这种设置模拟了人类生活的真实环境，因为每个人都从其他人的经验中获得知识，从而使整个“全球网络”变得更好。

与基于价值迭代法或策略梯度法的一些更直接的技术不同，A3C 算法结合了这两种方法的最佳部分，即该算法预测价值函数和最优策略函数。

典型地，在实施策略梯度(优势的价值)时，代理人也知道回报比其平均值(期望值)好多少。这提供了对环境中的代理的新发现的洞察力，因此学习过程更好。以下表达式提供了 advantage 函数。

优势(S，A) =行动价值(S，A) —状态价值(S)。

参考下图，该图解释了具有四个动作的状态的优势函数，并显示了动作的概率(为了解释，这被用作确定性离散动作，但该概念同样适用于随机连续动作空间)。这里，行动 A3 中的优势值最高，行动者在这种状态下会更多地遵循该行动，如评论家所建议的那样(优势函数)。

请参考下图，该图显示了 A3C 架构如何与工人和全球网络参数一起工作。与此同时，不同的主体从环境中获取不同的信息，并且所有主体都合作学习对环境和问题的全局理解。

A2C

A2C 是 A3C 的“同步”确定性版本；这就是为什么它被命名为“A2C”，去掉了第一个“A”(“异步”)。在 A3C 中，每个代理独立地与全局参数对话，所以有时特定于线程的代理可能会使用不同版本的策略。因此，聚集更新将不是最佳的。为了解决这种不一致，A2C 的协调器在更新全局参数之前等待所有并行参与者完成他们的工作。然后在下一次迭代中，并行参与者从相同的策略开始。同步梯度更新使训练更有凝聚力，并可能使收敛更快。A2C 还能够更有效地利用 GPU，更好地处理大批量数据，同时实现与 A3C 相同或更好的性能。

请参考下图。所有 n 个代理线程等待，直到它们都有更新要执行。然后，我们通过对全局网络的一次更新来平均这 n 个线程上的梯度。事实上，由于批量较大，这应该更有效。

TRPO

为了提高训练的稳定性，我们应该避免一步改变策略太多的参数更新。信任区域策略优化(TRPO) 通过在每次迭代中对策略更新的大小实施 KL 发散约束来实现这一思想。TRPO 是一种基于策略的算法。TRPO 可用于具有离散或连续动作空间的环境。

TRPO 通过采取尽可能大的步骤来更新策略，以提高性能，同时满足允许新旧策略接近程度的特殊约束。这种约束用 KL-Divergence 来表示，这是新旧政策概率分布之间距离的一种度量。

这不同于标准策略梯度，标准策略梯度在参数空间中保持新旧策略接近。但是，即使参数空间中看似很小的差异也会在性能上产生相当大的差异——因此，一个错误的步骤就可能导致策略性能崩溃。这使得对普通策略梯度使用大的步长变得很危险，从而损害了它的采样效率。TRPO 很好地避免了这种崩溃，并倾向于快速单调地提高性能。参考下图，这是 TRPO 如何使用信任区域(循环空间)来限制后续策略的卡通说明，以便新策略不会漂移太多，从而永远不会达到最优策略。红色、黄色和橙色策略在信任区域(由 KL-divergence 设置)之外，因此无法恢复或解决局部最优。

用于此插图图片的像素图像

TRPO 旨在最大化服从信任区域约束的目标函数，该约束强制由 KL-divergence 测量的新旧策略之间的距离在参数δ内足够小。这样，当满足这一硬约束时，新旧政策不会相差太多。请参考下图，了解约束如何适用于两种策略。

聚苯醚（Polyphenylene Oxide 的缩写）

TRPO 实现起来相当复杂。近似策略优化(PPO) 通过使用修剪替代目标来简化它，同时保留类似的约束和类似的性能。PPO 消除了由约束优化产生的计算，因为它提出了一个裁剪代理目标函数。它不是强加硬约束，而是将约束形式化为目标函数中的惩罚。

对于 PPO，我们通过将 KL 散度从一个约束条件转化为一个惩罚项来简化问题，类似于，例如，L1，L2 权重惩罚(以防止权重增长到很大的值)。

PPO-Penalty 近似地解决了类似 TRPO 的 KL 约束更新，但是惩罚目标函数中的 KL-divergence，而不是使其成为硬约束，并且在整个训练中自动调整惩罚系数，以便其被适当地缩放。

PPO-Clip 在目标中没有 KL-divergence 项，完全没有约束。而是依赖于目标函数中的专门剪裁来消除新策略远离旧策略的激励。PPO 确实将政策比率(更新政策与旧政策的比率)限制在 1.0 左右的小范围内，其中 1.0 表示新政策与旧政策相同。

DDPG

(深度确定性策略梯度)，是一种无模型的非策略行动者-批评家算法，它同时学习 Q 函数(行动值)和策略。它使用非策略数据和贝尔曼方程学习 Q 函数**，并使用 Q 函数学习策略。DDPG 可以被认为是针对连续动作空间的深度 Q 学习。**

• DDPG 是一个非策略算法(使用重放缓冲)
• DDPG只能用于有连续动作空间的环境

当存在有限数量的离散动作时，最大值不会造成问题，因为我们可以单独计算每个动作的 Q 值，并直接比较它们，这给了我们最大化 Q 值的动作。但是当动作空间是连续的时，我们不能穷尽地评估该空间(我们必须评估无限数量的动作)，并且因为每次代理想要在环境中采取任何动作时都需要运行它，这是不可行的。

在 DDPG，我们使用重放缓冲区来计算目标，然后更新 Q 函数(梯度下降)，然后更新策略(梯度上升)。我们想学习一个确定性的策略，给出最大化 Q 函数的动作。由于动作空间是连续的，并且我们假设 Q 函数相对于动作是可微的，我们执行梯度上升来求解仅相对于策略参数的最大 Q 值。注意，当我们进行梯度上升以更新策略参数时，Q 函数参数在这里被视为常数。

TD3:双延迟深度确定性政策梯度

双延迟深度确定性策略梯度(TD3)算法是一种无模型、在线、脱离策略的行动者-批评家算法。DDPG 的一个常见故障模式是，学习到的 Q 函数开始显著高估 Q 值，然后导致策略破坏，因为它利用了 Q 函数中的错误。TD3 算法是 DDPG 算法的扩展。

TD3 比 DDPG 做了以下改进。

1. TD3 代理学习两个 Q 值** ( “孪生”)函数，并在策略更新期间使用最小值函数估计。**
2. TD3 更新策略(和目标网络)比 Q 功能更不频繁(“延迟”)(一个策略更新两个 Q 功能更新，这就是孪生延迟名称的由来)
3. 当更新策略时，TD3 代理向目标动作添加噪声**，这使得策略不太可能利用具有高 Q 值估计的动作。**

上图显示了算法中的步骤。我将在这里尝试以简化的方式描述这些步骤。

1. 第一步是初始化策略和 Q 函数的函数近似参数(两个 Q 参数)，将目标参数设置为主参数(1 个用于策略，2 个用于 Q 函数)
2. 重复许多集以收集状态、动作(我们添加噪声和剪辑)、奖励、下一个状态、终端状态指示符来构建重放缓冲区
3. 从重放缓冲器中随机抽取一批过渡细节，并计算目标动作 A’(S’)(使用演员目标网络、剪辑和噪声属性)
4. 计算目标 Q 值，在批评家目标 1** 网络中的 Q’1**
5. 计算目标 Q 值，Q’2 在批评家目标 2** 网络中**
6. 从 Q’1 和 Q’2 中取 Q 值的最小值。
7. **使用 **Critic Model1 中的一步梯度下降计算 Q 函数的损失(将步骤 6 中的 Q 值作为目标 )
8. **使用 **Critic Model2 中的一步梯度下降法计算 Q 函数的损失(将步骤 6 中的 Q 值作为目标 )
9. 采取步骤 7 和 8 计算总损失，并更新评估模型 1** 和评估模型 2 的参数**
10. 每两次迭代中，我们使用从评论家模型 1 输出的 Q 值通过一步梯度上升来更新演员模型的策略参数(步骤 7)
11. ****每两次迭代中，我们通过 Polyak 平均更新一次目标网络的参数(演员目标，评论家目标 1 &评论家目标 2 )。

我们继续上述步骤，直到参数收敛。

软演员兼评论家

软行动者-批评家(SAC)基于最大熵强化学习**，这是一个框架，旨在既最大化预期回报(这是标准的 RL 目标)又最大化政策的熵 ( 熵越高的政策越随机)，这直观地意味着最大熵强化学习更喜欢仍然实现高回报的最随机的政策。**

软演员评论家(SAC)结合了限幅双 Q 技巧**(像 DDPG 一样)，SAC 的一个中心特征是熵正则化。该策略被训练为最大化预期回报和熵之间的权衡，熵是策略中随机性的度量。这与探索-利用权衡有着密切的联系:增加熵会导致更多的探索，这可以加速以后的学习。它还可以防止策略过早地收敛到一个坏的局部最优。**

• SAC 是一种非策略算法。
• SAC 可以在连续或离散的动作空间中工作。

黑斑羚

****IMPALA(重要性加权行动者-学习者架构)受流行的 A3C 架构启发，使用多个分布式行动者来学习代理的参数。每个参与者都使用策略参数的克隆来在环境中操作。

IMPALA 使用为学习策略和基线函数 v 而设置的行动者-批评家。该架构由一组行动者组成，重复生成经验轨迹，一个或多个学习者使用从行动者发送来的经验学习策略非策略。

演员周期性地暂停他们的探索，以与中央参数服务器共享他们已经计算的梯度，中央参数服务器通过计算梯度来应用更新。在 IMPALA 中，生成经验的过程与学习参数策略和基线函数 v 是分离的。多个参与者并行生成经验，而学习者使用所有生成的经验优化策略和值函数参数。参与者定期用来自学习者的最新策略更新他们的参数。因为表演和学习是分离的，我们可以添加更多的演员机器来生成更多的时间单位轨迹。由于训练策略和行为策略不完全同步，它们之间有一个间隙，因此我们需要称为 V-trace 的非策略修正。

图像参考:深度思维

中央学习器计算梯度，产生具有完全独立的参与者和学习者的模型。

图片来自谷歌人工智能博客

为了利用现代计算系统的规模，可以使用单个学习器机器或在它们之间执行同步更新的多个学习器来实现重要性加权的参与者-学习器架构。以这种方式分离学习和行动还有增加整个系统吞吐量的优点，因为行动者不再需要像在诸如批处理 A2C(如下图所示)的架构中那样等待学习步骤。

图像参考:深度思维

然而，将表演和学习分离会导致参与者的策略落后于学习者。为了补偿这种差异，IMPALA 使用了一种称为 V-trace 的非政策优势演员-评论家公式，用于补偿演员非政策获得的轨迹。

最后一个音符

强化学习很复杂，但这并不意味着它必须是深奥的。这个领域正在迅速发展；新的想法和论文层出不穷。我尽量避免所有的数学表达式，这些表达式对于理解更复杂的算法是必不可少的。感兴趣的读者可以深入下面的参考列表，享受数学细节和进一步的解释。

我期待看到您的反馈或分享任何其他更直接的解释或参考任何不同的算法，您可能希望看到作为本文的一部分。

感谢阅读。你可以在 LinkedIn 上联系我。

只需每月 5 美元，就可以无限制地获取最鼓舞人心的内容…点击下面的链接，成为媒体会员，支持我的写作。谢谢大家！
https://baijayanta.medium.com/membership

参考:

https://spinningup.openai.com/en/latest/
https://github.com/dennybritz/reinforcement-learning
https://lilianweng . github . io/lil-log/2018/04/08/policy-gradient-algorithms . html

CSV kit:CSV 数据的瑞士军刀？

原文：https://towardsdatascience.com/csvkit-a-swiss-army-knife-for-csv-data-286db551547b?source=collection_archive---------41-----------------------

评估 csvkit 从命令行操作数据的潜力

马库斯·斯皮斯克在 Unsplash 上拍摄的照片

当面对一个新的 CSV 数据集进行分析时，我们大多数数据科学家会立即启动我们最喜欢的 IDE 或笔记本编辑器，从通常的numpy和pandas导入开始。

这并没有什么错，但是今天我想向您展示如何在不离开命令行的情况下近距离接触您的数据。

我将使用csvkit，一个专门为此设计的工具。我还将在示例中使用 Kaggle 数据集，它也可以从命令行下载，如下所示:

pip install kaggle kaggle datasets download datafiniti/hotel-reviews unzip hotel-reviews.zip

探索数据集

csvcut :

我们对这个数据集了解不多，只知道它与酒店有关。首先，我们想知道那里有哪些列。简单:

csvcut -n Datafiniti_Hotel_Reviews.csv

csvlook :

假设您想看看列province和postalCode的前几个值。在下面的代码中，我们选择带有csvcut的列的子集，并将其作为csvlook的输入:

csvcut -c country,province,postalCode Datafiniti_Hotel_Reviews.csv | csvlook --max-rows 10

或者，我们可以将csvlook的输出传送到head命令，而不是使用--max-rows参数。

csvstat :

现在给定上面的输出，我们可能想要检查数据是否只覆盖美国。要了解更多关于特定列的信息，我们可以使用csvstat:

csvcut -c country,province,postalCode Datafiniti_Hotel_Reviews.csv | csvstat

这是很多非常有用的信息，非常容易获得！注意，我们还从上面的输出中获得了文件中的行数。

如果您想获得所有列的统计数据，您当然可以直接使用csvstat而不用管道:

csvstat Datafiniti_Hotel_Reviews.csv

csvort:

假设现在我们想快速浏览一下最近的评论和城市。我们可以试着用csvsort来做:

csvcut -c reviews.date,city,reviews.title Datafiniti_Hotel_Reviews.csv | csvsort -c reviews.date -r | csvlook --max-rows 10

*旁注:*根据我选择的列，我有时会得到一个值错误，类似于Row has X values, but Table has Y columns。在这种情况下，添加--snifflimit 0可以解决问题。

csvgrep :

为了结束探索阶段，让我们寻找所有提到“安静”或“和平”酒店的评论标题。在下面的命令中，我添加了带有-l标志的行号。csvgrep命令的一个缺点是我不能将它的输出通过管道传递给其他命令。

csvcut -c name,reviews.title -l Datafiniti_Hotel_Reviews.csv | csvgrep -c reviews.title -r "(?i)(quiet|peaceful)

查询数据集

csvkit的一个非常酷的特性是能够用 SQL 从命令行查询数据。

例如，让我们再次搜索安静的酒店，但这次输出他们的城市和酒店名称:

csvsql --query "select city, name from Datafiniti_Hotel_Reviews where [reviews.text] LIKE '%quiet%' limit 10;" Datafiniti_Hotel_Reviews.csv

运行此命令会产生以下输出:

不幸的是，我不得不说，运行这个查询相当慢，这有点违背了使用命令行的初衷。

尽管我们可以将 CSV 保存为本地数据库，然后查询该数据库，但我再次发现，如果我打算走数据库这条路，我还不如全力使用编程语言。

结论

总而言之，我发现 csvkit 的前提很有趣，但是 sql 请求的缓慢运行速度是一个很大的失望。对我来说，价值主张不足以让我放弃熊猫和 jupyter，即使是为了探险。

CubeTrack:使用 Unity + ML-Agents 进行主动跟踪的深度 RL

原文：https://towardsdatascience.com/cubetrack-deep-rl-for-active-tracking-with-unity-ml-agents-6b92d58acb5d?source=collection_archive---------35-----------------------

游戏视图中的立方体追踪(图片由作者提供)

CubeTrack ，对我来说，是一次用 主动对象跟踪 (AOT)和游戏引擎支持的 深度强化学习 (RL)来弄脏我的手的练习，同时我等待着开发一个更复杂、更逼真的模拟我的真实世界部署环境的工具。到目前为止，我一直在现成的健身房环境中工作，但是对定制环境的需求让我选择了 Unity 和 ML-Agents。

ML-Agents 示例环境(图片来自Unity ML-Agents Toolkit Github 库)

ML-Agents 附带的示例环境不包含跟踪问题，因此我遵循创建新环境的指导原则，在平台上保持相同的多维数据集设置。有了这样一个相似、简单的设计，我认为整理这个项目并不需要太多的努力，把我和一些 ML-Agents 项目预置放在一起的游戏对象交换出去(只是为了风格的一致性)，并使这个项目成为一个公共回购。示例环境对于学习、实践、测试和构建非常有用。希望 CubeTrack 可以以同样的方式使用，但在不同的问题空间。

该项目在https://github.com/kirstenrichardson/CubeTrack进行

如果您只是想使用环境，那么您需要知道的一切都在自述文件中。如果你是 RL 的新手，我建议你看一下史云光·斯廷布鲁格的 Youtube 频道上的一些视频，以获得一个总体概述，并进一步了解这里介绍的工作中使用的算法 PPO(近似策略优化)。或者，如果你有更多的时间，并且想更深入地研究，我推荐《深度思维》的大卫·西尔弗的《RL 简介》系列讲座。

如果你已经熟悉 RL，但对如何在 Unity 中用自定义环境解决自定义问题感兴趣，那么请继续阅读，我将介绍 ML-Agents 以及 CubeTrack 是如何组装的。如果你已经熟悉 Unity 和 ML-Agents，只是想知道基于学习的决策促进了成功的跟踪，那么跳到设计选择。

ML-Agents 是 将常规 Unity 场景转化为学习环境 的插件。它提供了一个 Python 低级 API(包含在 Python 包mlagents_envs中),用于处理 Unity 环境中的通信器和 Python 训练脚本之间的通信(要么是工具包附带的实现，它们是自己的 Python 包mlagents的一部分，要么是您选择的实现，可以选择使用第三个 Python 包gym-unity将 Unity 环境包装在 gym 包装器中)。在将 ML-Agents repo 克隆到本地目录(设置为 pipenv )并安装各种 ML-Agents 包之后，我打开 Unity Hub 并在同一位置创建了一个新的 3D Unity 项目。

Version information:
  ml-agents: 0.18.0,
  ml-agents-envs: 0.18.0,
  Communicator API: 1.0.0,
  TensorFlow: 1.14.0,
  Unity: 2019.4.4f1,
  Python: 3.6.9

统一场景

这里没有华而不实。我所需要的是一个非玩家角色(NPC)(不受人类玩家控制的游戏对象)在一个区域内随机移动，提供一个移动的*，以及一个游戏对象代表跟踪器(或 代理 ，使用 RL 术语)响应一些外部“玩家”输入而移动。令人困惑的是，Unity 可以将 NPC 称为人工智能控制的，但人工智能在这里是指预编程的，因此是独立的，而不是像我们的 RL 模型“玩家”那样主动学习，它位于 Unity 的外部。*

层级窗口示例(按作者排序的图像)

CubeTrack 有两个几乎相同的场景，CubeTrack 和 VisualCubeTrack，后者在代理立方体上增加了第一人称视角摄像头。除了游戏相机和照明，场景只包含一个名为 Area(或 VisualArea)的预设——一个包含所有组成 RL 环境的组件的空游戏对象。这个容器预置使复制环境变得容易，拥有多个环境实例可以加速训练，将我们的代理立方体车队的“共享大脑”暴露给并行的多种体验。该区域可分为三个部分:

• 训练场:由一系列立方体组成的场地和墙壁。此外，13 个圆柱体(航路点)以网格模式放置在地面上，它们的网格渲染器组件和胶囊碰撞器组件未选中，因此它们都是不可见的，并且能够通过。
• ***目标:*一个紫色的立方体，用更小的子对象立方体作为头带、眼睛和嘴巴。为了让立方体在平台上移动，添加了一个名为 NavMesh 代理的组件和一个名为TargetMovement的脚本。一个 NavMesh 被烤到了地上(区域预置是开放的，因此它存在于每个区域实例中)，每个航路点都被赋予了标签RandomPoint。然后可以通过脚本从标签为RandomPoint的对象列表中选择一个随机航路点，并将航路点的位置设置为 NavMesh 代理的目的地，即目标立方体。更多细节请参见此视频。
• ***代理:*一个蓝色的立方体，有头带、眼睛和嘴巴，这次有一个刚体组件，使它能够在物理的控制下行动，并施加力。你可以使用刚体的质量和阻力参数来改变立方体滑动的方式。当使用视觉观察时，添加了一个相机作为子对象，并定位为指向正面(向下看的那个transform.forward)。

场景视图显示航路点对象和代理摄像机 FOV(图片由作者提供)

学习环境建立

通过 ML-Agents，将这个普通的 Unity 场景转变为人工智能的训练场所变得超级简单。做这件事的文档是这里是，但是这些是基本步骤…

• 安装 Unity 包

选择游戏对象作为你的 RL 代理…

• 添加一个脚本组件
• 添加一个行为参数组件
• 添加一个决策请求器组件
• (可选)添加一个摄像头传感器组件

转到您的本地 ML-Agents repo 目录(或本地 CubeTrack repo 目录)并…

• 添加一个配置文件

所有这些都准备好了，你的 Unity 场景就可以训练一个模型了。要开始训练，请确保代理多维数据集的行为参数组件下的模型字段显示无。打开终端并使用单一命令行实用程序…

*mlagents-learn ./config/ppo/CubeTrack.yaml --run-id=runName*

…带有结尾标记的任何选项(使用-h 探索 mlagents-learn 命令的完整用法)。然后转到 Unity 编辑器，点击▶️.提供了很大的灵活性，包括恢复尚未结束的训练运行(全局 max_steps 参数)或在现有模型的基础上进行训练。更多详情见此处。

当训练运行完成或提前终止时，模型权重被保存到。“结果”文件夹中的 nn(神经网络)文件。mlagents-learn 命令需要从与您正在使用的配置和结果文件夹相同的位置调用。如果您已经克隆了 ML-Agents repo，那么您可以将您的配置文件与示例环境的所有 yaml 文件放在一起，并从 ML-Agents repo 目录的根目录运行命令。cube track repo 有自己的配置和结果文件夹，因此可以在没有 ML-Agents repo 本地副本的情况下使用。在这种情况下，从 CubeTrack repo 目录的根目录发出命令。

推断非常简单，只需复制并粘贴。nn 文件到您的项目资产文件夹，拖动到模型领域，并点击▶️.

设计选择

观察

首先，我试图用向量观察来培养追踪行为。被选作观察集的变量组在不同的实验运行中有所不同，但最终成为以下 12 个观察集:

• 代理的位置(2 个 obs，对象变换位置的 x 和 z 组件)
• 目标的位置
• 代理的速度(velocity.magnitude)
• 目标的速度
• 代理的面向方向(transform.forward)(矢量 so 3 obs)
• 目标面对的方向

一旦以这种方式实现了跟踪，就添加了一个相机传感器，删除了CollectObservations()功能，并将检查器窗口中的空间大小设置为 0。相机传感器设置为传送 84 x 84 PNG 型号的图像。下面的 GIF 演示了代理的 POV(注意，这是在调整图像大小之前——模型从同一台相机接收图像，但分辨率较低)。喊出身临其境的极限视觉变色龙教程由亚当凯利在这里。

从代理的机载摄像头查看-游戏视图显示 2(图片由作者提供)

在我整理项目和利用 ML-Agents 示例环境中使用的游戏对象之前，我已经通过选择具有最高对比度的材质颜色(黑色目标立方体、浅灰色地面和白色墙壁)、关闭阴影和关闭阴影投射，给了我的代理成功进行视觉观察的最佳机会。在此设置中，足以传递模型灰度 84 x 84 图像(相机传感器组件下的勾选框)，但在 VisualCubeTrack 的较新版本中，需要彩色图像。

(左)最新版本的 CubeTrack(右)早期版本的 CubeTrack(图片由作者提供)

行动

最初，动作空间被设置为连续的。该模型传入了两个浮点值，这两个值在用作同时沿 x 和 z 轴施加的力的大小之前，都使用Mathf.Clamp在-1 和 1 之间进行了限幅。我后来决定了一个简单的 5 选离散行动空间…

行动空间(图片由作者提供，灵感来自托马斯·西蒙尼尼的Unity ML-Agents 简介)

通过将每个动作选项分配给一个箭头键，并对看起来合理的选项进行实验，来测试每种情况下施加的力的大小。前进/后退的幅度为 500，转弯的幅度为 250。

我遇到的一个问题可以被描述为代理持续“超调”，导致旋转行为或钟摆般的向前然后向后移动。我意识到我将决策请求者的决策周期设置为 10，但勾选了“在决策之间采取行动”，导致连续十步采取相同的行动。将决策周期更改为 1 并没有使 sim 不堪重负，也没有消除超调。

奖励

我第一次尝试奖励工程学是受到了下面的博客的启发，这篇博客是由亚当·普莱斯写的关于利用课程学习进行追逃(见他的开源追逃游戏这里)。

* [## 使用 Unity ML-agent 的课程学习

教一队猎人捕捉猎物。

towardsdatascience.com](/curriculum-learning-with-unity-ml-agents-c8e7a1aa5415)

复制“延伸”行为非常有效。我增加了目标的速度，减少了被认为“足够接近”目标的距离。然后，我尝试在这个模型的基础上进行新的培训，鼓励使用计数器变量进行跟踪，计算目标范围内连续FixedUpdate()呼叫的数量。目标速度再次增加，这一次“持续时间”阈值(计数器变量需要达到的值)也增加了。第二阶段进展缓慢！一旦剧集终止代码被删除，代理人的最终行为是只跟踪导致奖励的时间长度，然后失去兴趣(显然是回想起来)。

我需要一个函数来分配每一步的比例奖励，我在的一篇论文中看到了一个这样的例子罗等人(2018) 。该功能如下所示:

奖励函数(图片来自罗等(2018) )

• A 、 d 、 c 和 λ 都是调谐参数。 A 和 d 纯属设计选择， A 为一步可分配的最大奖励(设置为 1，与罗纸相同) d 为最佳前进/后退距离(根据游戏视图中看似合理的差距设置为 3)。
• 括号的左边是奖励代理的位置，右边是代理面对的方向。为了生成[-1，1]范围内的奖励，需要设置 c 和 λ 以使括号中的最大值为 2。Unity 中的旋转从-180°到 180°，因此如果旋转和定位的权重相等，则 λ 应该总是 1/180。 c 的值根据所用训练场地的大小而变化。
• x 和 y 代表从代理到目标的航向矢量的 x 和 z 分量。取方向分量总和的平方根，计算矢量的长度，即距离。当代理和目标在 x 平面上的位置相同，但heading.z为+3 时，整项为零，奖励最高。我意识到heading.z的符号根据目标的行进方向而变化，导致代理人有时因在目标后面而被奖励，有时因在目标前面而被奖励(没有帮助！).因此，有一个额外的代码块来确保在目标的后面发布最高奖励，即使根据世界 z 轴，代理在技术上在目标的前面。

if (Vector3.Dot(heading.normalized, Target.transform.forward) > 0)
 {
  heading.z = Mathf.Abs(heading.z);
 } else {
  heading.z = -Mathf.Abs(heading.z);
 }

• a 是代理的transform.forward矢量和航向矢量之间的角度。这鼓励目标去看目标。最初我将 a (在下面的引用中)的描述解释为代理的transform.forward和目标的transform.forward之间的角度，但是后来的实现(指向的角度)工作得更好，我认为这是有意义的，特别是在视觉设置中。

“当物体完美地站在智能体前面距离 d 处，且不旋转时，奖励 A 最大”—罗等(2018)

下面是该项目的函数的代码实现。

var rDist = Mathf.Sqrt(Mathf.Pow(heading.x, 2f) + Mathf.Pow((heading.z - d), 2f));        
 var r = A - ((rDist/c) + (a*lam));
 AddReward(r);.

结果

培训在我的联想 Thinkpad T480s 笔记本电脑(英特尔酷睿 i7–8550 u 处理器，4 核，8 线程，1.80 GHz 处理器主频)上进行，将max_steps设置为 5M。下图是 TensorBoard 生成的平滑度为 0.99 的累积奖励图。

使用矢量观察(粉色)进行的训练最初需要大约 5 个小时，但使用六个训练场后减少到大约 2 个小时(参见立方体轨道场景中的游戏视图显示 2)。在这种情况下，奖励值代表六个区域实例的平均奖励。曲线图的坐标轴模糊不清，但累积奖励稳定在 2500 左右。注意，在一集中可实现的最大奖励是 3000(除非该集的累积奖励下降到-450 以下，否则该集在 3000 步处终止)，但是将要求代理的随机开始位置和面向方向是从奖励函数中引出直接+1 的位置和面向方向。

5 次不同训练跑的累计奖励超过 500 万步(图片由作者提供)

下面的深蓝色线条说明了 VisualCubeTrack 的第一个版本中视觉观察跟踪的成功，具有高对比度的颜色，没有阴影或阴影。在较新版本的 VisualCubeTrack 中使用灰度图像进行训练导致了显著的性能下降(浅橙色)，而仅改变为彩色观察对改善事情(红色)几乎没有作用。在这两种情况下，训练都被缩短了。直到视觉编码器从simple (2 个卷积层)变为resenet ( IMPALA ResNet —三个堆叠层，每个层有两个剩余块)，进展才有所改善(浅蓝色)，累积奖励稳定在 2300 左右，推理呈现合理行为。这次训练包括一个训练场地，持续了大约 56 个小时。

范围

本博客主要讨论的是第一个“设置”(奖励功能，环境设置，训练配置等。等等。)来引出令人信服的跟随行为，仅此而已。受过训练的代理在 VisualCubeTrack 中的表现尤其有改进的余地。改进的途径包括…

• 进一步调整配置文件中的超参数
• 进一步奖励工程，例如增加长期奖励
• 使用不同的算法(ML-Agents 提供软演员评论家的实现)或不同的实现(在使用 ML-Agents 之前，我选择的 RL 库是来自 Antonin RAFFIN 和其他人的稳定基线
• 使用额外的技术，例如已经提到的课程学习或称为好奇心的内在奖励信号
• 例如，使用域随机化使学习到的策略更加健壮
• 通过在多个环境实例上进行训练或使用可执行文件而不是在编辑器中进行训练来提高训练效率

除了在当前版本的环境中提高性能之外，具有深度 RL 的 AOT 还可以通过以下方式进一步提高…

• 增加学习问题的复杂性，例如引入与目标或增加的障碍碰撞的惩罚
• 使用更加复杂和真实的 sim 卡！！

CubeTrack.nn 上的推论(图片由作者提供)

如果你发现任何疏忽或有任何想法或问题等。那么，请在下面发表评论或在@ KN _ Richardson 给我发推文。注意安全！

[1]:朱利安尼，a .，伯格斯，v .，滕，e .，科恩，a .，哈珀，j .，埃利翁，c .，戈伊，c .，高，y .，亨利，h .，马塔，m .，兰格，D. (2020)。Unity:智能代理的通用平台。 arXiv 预印本arXiv:1809.02627。https://github.com/Unity-Technologies/ml-agents。

[2]:罗文伟、孙平、钟、冯芳、刘文伟、张、汤、王(2018 年 7 月)。基于强化学习的端到端主动目标跟踪。在机器学习国际会议(第 3286–3295 页)。

[3]: A .希尔，a .拉芬，m .埃内斯托斯，a .格莱夫，a .卡内维斯托，r .特拉奥雷，p .达里瓦尔，c .黑塞，o .克里莫夫，a .尼科尔，m .普拉波特，a .拉德福德，j .舒尔曼，s .西多尔，y .吴，《稳定的基线》，，，2018。*

用于深度学习的 WSL2 上的 Cuda 第一印象和基准

原文：https://towardsdatascience.com/cuda-on-wsl2-for-deep-learning-first-impressions-and-benchmarks-3c0178754035?source=collection_archive---------14-----------------------

不打算说谎，微软一直在软件开发社区做一些好事。我喜欢用 Visual Studio 代码编写代码，如果你想为生产优化你的深度学习模型，ONNX 非常棒。WSL2 允许你访问整个 Linux 内核正是我一直想要的，但缺乏 CUDA 支持意味着它对我这个人工智能工程师来说是不可能的。

作为一名人工智能工程师和内容创作者，我需要 Windows 作为工具来创建我的内容，但我需要 Linux 来轻松运行和培训我的人工智能软件项目。我在我的机器上有一个双启动设置，但它并不理想。我讨厌当我在训练一个模型时，我不能使用我的创作工具。所以我必须同步工作而不是异步工作。

我知道大多数深度学习库支持 Windows，但让东西工作的体验，尤其是开源人工智能软件，总是令人头疼。我知道我可以使用类似qemu的东西在 Linux 上运行 Windows 软件，但这需要我将整个 GPU 隔离到 VM，导致我的 Linux 实例无法访问它。

支持 CUDA WSL2 的微软和 Nvidia 来了！所有 Linux 工具在 Windows 上本机运行的承诺将是我的工作流的一个梦想。当他们发布一个预览版本时，我马上就接受了。在这篇文章中，我将写下我的第一印象以及一些基准！

在 WSL2 上设置 CUDA

在 WSL2 上设置 Cuda 对我来说超级简单。Nvidia 有很好的文档解释你需要采取的步骤。令我惊喜的是，我没有遇到一个错误！我不记得上一次设置仍在测试阶段的软件时发生这种情况是什么时候了。

设置我的机器学习工具

作为一名专门花大量时间进行深度学习的人工智能工程师，我需要一些工具来改善我的开发体验。

1. 支持 CUDA 的 docker(NVIDIA-docker
2. PyTorch 作为我选择的深度学习框架

自从双引导进入 Linux 后，我还没有尝试过 WSL2，所以我惊喜地发现我可以像在普通的 Ubuntu 机器上一样轻松地下载和安装我的工具。我安装这些软件包都没有问题。正如你所料，这是一次 Ubuntu 体验。

培训模型

好了，这是真正的考验。首先我将谈谈我的经验，然后我将展示一些基准来比较 WSL2 和裸机 Linux 上的 Cuda。

我认为在训练深度学习模型时，无论你是否有自己的硬件或是否在云上训练，一个常见的工作流程是为所有数据准备一个单独的磁盘，为实际的操作系统准备一个磁盘。WSL2 将自动检测和安装 Windows 10 识别的任何磁盘，因此很酷；但是我在安装的数据驱动器上遇到了文件permissions的问题。

注意 : 这个问题只出现在挂载的驱动器上，如果你在你的 WSL2 文件系统中做任何事情，它都会正常工作。

因此，由于文件权限受到限制，我的训练脚本会在随机数据文件上出错。所以我读了 WSL 文档，它说…

从 WSL 访问 Windows 文件时，文件权限或者从 Windows 权限中计算，或者从 WSL 添加到文件中的元数据中读取。默认情况下，不启用此元数据。

好的，WSL2 计算文件权限，有时会出错，我想，我只需要启用这个元数据就能让它正常工作对吗？嗯，差不多吧…所以我添加了元数据，然后对我所有的数据文件做了chmod -R 777，这是一种快速而肮脏的方法，可以释放权限，这样我就可以继续训练了！嗯，有一点效果…然后它又出现了同样的权限错误！所以我查看了权限，它不知何故恢复了我的更改，回到了受限访问。更有意思的是，如果我多次检查文件权限，它就会恢复到我的 chmod 权限。所以这是随机改变权限，我知道的唯一方法是用ls -l检查权限。我发现了一个奇怪的 WSL2 量子现象，我将硬币…*薛定谔的文件权限 *。当我使用chmod 700将完全的读、写和执行权限只授予 WSL2 用户而不是每个人和他们的妈妈时，问题就解决了。这在某种程度上解决了薛定谔的文件权限问题，所以我继续生活。

从那以后，我开始训练，没有任何问题！一切看起来都很好，模型损失正在下降，没有什么看起来不寻常的。我决定做一些基准测试，比较 Ubuntu 与 WSL2 Ubuntu 与 Windows 10 的深度学习训练性能。

基准测试——Ubuntu vs . wsl 2 vs . Windows 10

为了进行基准测试，我使用了来自 Pytorch 示例回购的 MNIST 脚本。我修改了脚本，使网络更大，以获得更大模型的更准确读数。

*class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(1, 128, 3, 1)
        self.conv2 = nn.Conv2d(128, 128, 3, 1)
        self.conv3 = nn.Conv2d(128, 128, 3, 1)
        self.dropout1 = nn.Dropout2d(0.25)
        self.dropout2 = nn.Dropout2d(0.5)
        self.fc1 = nn.Linear(15488, 15488//2)
        self.fc2 = nn.Linear(15488//2, 10)

    def forward(self, x):
        x = self.conv1(x)
        x = F.relu(x)
        x = self.conv2(x)
        x = F.relu(x)
        x = self.conv3(x)
        x = F.relu(x)
        x = F.max_pool2d(x, 2)
        x = self.dropout1(x)
        x = torch.flatten(x, 1)
        x = self.fc1(x)
        x = F.relu(x)
        x = self.dropout2(x)
        x = self.fc2(x)
        output = F.log_softmax(x, dim=1)
        return output*

我的机器规格是…

• 英特尔 i9 10920X — 12 个内核，24 条线程
• 英伟达 RTX 2080 TI — 11GB VRAM

我对…进行了 3 次测试

• Ubuntu 20.04
• WSL2 Ubuntu 20.04
• Windows 10

我使用 FP32 精度的 512 批次大小，运行 14 个时期。以下是结果…

**

所以说实话成绩还不算太差！在我的英伟达 RTX 2080 Ti 上，支持 CUDA 的 WSL2 比原生 Ubuntu 多花了 18%的时间来训练 MNIST 模型。WSL2 对 CUDA 的支持仍处于早期预览模式，我希望工程师和研究人员以及微软和 Nvidia 最终会达到接近 Ubuntu 的性能。

对于一些人来说，花 18%的时间来训练模型可能是不可行的，但对我来说，如果这意味着我可以异步地训练深度学习模型，并使用我的 Windows 兼容软件工具来创建内容，我可以接受这种小的性能打击。我打算暂时继续使用 Windows 10 和 WSL2 作为我的日常驱动程序，看看效果如何！

✍🏽原载于【https://www.michaelphi.com】

🥇注册我的 电子邮件简讯 ，了解最新的文章和视频！

📺喜欢看基于项目的视频？来看看我的 Youtube ！

科莫说，21%的纽约居民患有新冠肺炎。这是正确的吗？

原文：https://towardsdatascience.com/cuomo-says-21-of-new-york-residents-have-had-covid-19-is-this-correct-23e8a63d2045?source=collection_archive---------60-----------------------

处理统计数据时因果推理的案例研究

撰稿*，编辑* 拉明·拉梅扎尼 。—2020 年 5 月 4 日

如果被选择偏差污染，数据可能会欺骗你。我们的分析需要超越数据本身，调查数据生成/收集过程。图片:来源

“选择偏差”是由优先排除数据中的样本引起的[1]。它是验证统计结果的一个主要障碍，在实验或观察研究中几乎检测不到。这一切都始于我们通常在科学研究中使用样本群体，并假设样本代表总体(统计学方法)。让我们从一个真实的例子开始。

在新冠肺炎疫情危机期间，一项全州范围的研究报告称，21.2%的纽约市居民已经感染了新冠肺炎病毒。该研究对全州 3000 名纽约居民在杂货店和大卖场进行了抗体测试，以表明某人是否感染了该病毒。Cassie Kozyrkov【3】认为这项研究可能受到选择偏差的污染。假设是，研究中的队列主要偏向于高风险人群和已经感染病毒的人群。总人口的大部分可能包括规避风险和谨慎呆在家里的人；这些人被排除在研究样本之外。因此，报告的死亡人数(即 21.2%)很可能是夸大的。Cassie Kozyrkov 在解释这项研究中选择偏差的原因方面做了惊人的工作[3]。但在这里，我们试图调查一个更通用的方法来当场选择偏差问题。

幸运的是，我们有因果推理的工具。因果推断要求我们在分析数据时做出某些似是而非的假设。数据并不总是完整的，也就是说，它并不总是能说明全部情况，仅从数据得出的分析结果(例如，虚假关联)往往会产生误导。例如，人们可能会发现吸烟的人可能会患肺癌，同时有黄色的指甲。如果我们发现这种联系(肺癌和黄指甲)很强，我们可能会得出一些错误的结论，即一个导致另一个。

图片:来源

回到我们的新冠肺炎故事，在抗体测试研究中我们可以做出什么因果假设？让我们考虑图 1，其中以下每个假设代表一个优势。

I)我们知道，如果我们做相关的测试，将会发现抗体。

ii)感染过新冠肺炎病毒并存活下来的人会产生该病毒的抗体。

iii)敢于冒险的人更有可能去户外并参与测试研究。

iv)为了在图表中突出样本群组和总体人口之间的差异， [Elias Bareinboim](http://elias bareinboim columbia) 提出了一个假设变量 S(代表“选择”)。图 1 中方框内的变量代表两个群体不同的特征。您也可以将 S 视为包含/排除标准。变量 S 具有来自变量“冒险”和“携带病毒”的输入边。这意味着样本队列和总体人群在这两个方面有所不同。

图 1:说明选择偏差场景的图形模型。变量 S(方形)是一个产生差异的变量，它是一个假设变量，指出两个群体的不同特征。

现在，我们已经将我们的假设编码成一个透明而简单的图表。你可能想知道为什么我们要费尽周折制作这个图表？这对我们识别选择偏差甚至去偏差过程有什么价值？

好问题。让我们从这样一个问题开始:它如何帮助我们找到识别选择偏差的共同模式/原则？

用因果图识别选择偏差

识别选择偏差的几个快速提示:1)在原因变量和结果变量之间的后门路径上找到任何碰撞器变量，2)当你的数据收集过程以这些碰撞器变量为条件时，选择偏差发生[1]。注意，这些提示是发现选择偏差的充分条件，但不是必要条件。我们所说的条件作用是指只考虑一个变量的一些可能性，而不是全部。

技巧 1 中的后门路径是指原因变量(COVID 测试)和效果变量(抗体%)之间的任何路径，带有指向原因变量的箭头([4]，第 158 页)。在我们的例子中，唯一的后门路径是“新冠肺炎测试←冒险→ S ←携带病毒→抗体%”。如果我们封锁每一条后门路径，就会消除虚假关联。我们如何知道后门路径是否被阻止？

Judea Pearl 在他的书[4]中谈到了 3 条规则，告诉我们如何阻止后门路径和虚假的关联流。如果你对这 3 个规则的完整数学证明感兴趣，请参考[5]

A)在链式连接中，A→B→C，以 B 为条件阻止关于 A 的信息到达 C，反之亦然。

B)在一个分叉或混杂连接中，A←B→C，以 B 为条件阻止关于 A 的信息到达 C，反之亦然。

C)在对撞机中，A→B←C，正好相反的规则成立。当没有以 B 为条件时，A 和 C 之间的路径被阻塞。如果我们以 B 为条件，则该路径是畅通的。请记住，如果这条路径被阻塞，A 和 C 将被视为相互独立。

有了这样的背景知识，我们知道再看我们的图解。我们现在看到，后门路径上有 3 个基本组件:1)一个分叉“新冠肺炎测试←高风险→S”；2)一个对撞机“高风险→ S ←携带”；3)另一个叉“S ←携带病毒→抗体%”。现在我们看到，如果我们不在碰撞器中对变量 S 进行条件运算(规则 c)，这个后门路径就被阻塞了。如果我们以变量 S 为条件(例如，set S={high risk，had virus })，后门路径将被打开，并在您的抗体检测结果中引入虚假关联。

现在我们认识到，如果我们在原因→结果之间的后门路径上以碰撞子为条件并打开后门路径，我们将遇到选择偏差问题。有了这个结论，我们可以很快确定我们的研究是否有选择偏差的问题。当图形复杂时，这种识别过程也可以自动化。所以，我们把这种判断交给算法和计算机。希望您在这一点上确信，使用图形模型是识别选择偏差的更通用和自动化的方法。

do-calculus 无偏估计

为了测量两个变量 X 和 Y 之间的因果关系，Judea Pearl 引入了 do-calculus 符号[4]。例如，P(Y|do(X=x))表示当每个 X 固定为值 X 时，从 X 到 Y 的因果效应.注 P(Y| X=x)反映了 Y 在 X 值为 X 的个体中的总体分布.后者只能表示 Y 与 X 之间的关联.如果你对更多细节感兴趣，请参考([6]，53 页).

现在我们感兴趣的是“新冠肺炎试验→抗体%”之间的因果估计，P(抗体|do(试验))。换句话说，如果我们测试群体中的每个人，因果效应代表抗体发现的可能性。我们的读者可能想知道 do-calculus 在这一点上是否有意义，但是我们如何计算和删除 do-operator 呢？

do-calculus 只有 3 个规则来减少我们熟悉的计算。下面三个规律的完整证明可以参考[7]。

a)当我们观察到一个与 Y 无关的变量 W 时，那么 Y 的概率分布不会改变，

P(Y|do(X)，Z，W) = P(Y|do(X)，Z)。

b)如果一组 Z 个变量阻塞了从 X 到 Y 的所有后门路径，那么以 Z 为条件，do(X)等价于 see(X)，

P(Y|do(X)，Z) = P(Y|X，Z)。

c)如果从 X 到 Y 没有因果路径，那么

P(Y|do(X)) = P(Y)。

在我们的例子中，

我们可以看到，在方程的最后一步，我们需要在研究中测量四个概率项，以获得无偏估计。如果我们假设封闭世界(风险= {高，低}，病毒= {真，假})，这意味着我们需要测量每一个分层的群体。在报告[1]中，他们报告的数值是 P(抗体|测试，风险=高，病毒={。})这与真正的因果效应相比是有偏差的。

现在我们已经看到，do-calculus 可以帮助我们确定我们需要哪些部分来恢复无偏估计。希望您在进行因果推理时，对图形模型结合 do-calculus 的强大功能印象深刻。

参考文献

[1]埃利亚斯·巴伦博姆和朱迪亚·珀尔。控制因果推理中的选择偏差。《人工智能和统计》，第 100-108 页，2012 年。

[2]杰里米·伯克。cuomo 说，一项全州范围的抗体研究估计，2020 年，21%的纽约市居民患有冠状病毒。

[3]卡西·科济尔科夫。21%的纽约市居民真的感染了新型冠状病毒吗？, 2020.

[4]珀尔、朱迪亚和达纳·麦肯齐。原因之书:因果的新科学。基础书，2018。

[5]盖革、丹、托马斯·维尔马和朱迪亚·珀尔。"识别贝叶斯网络中的独立性."网络 20.5(1990):507–534。

[6]珀尔、朱迪亚、玛德琳·格雷穆尔和尼古拉斯·朱厄尔。统计学中的因果推断:初级读本。约翰·威利父子公司，2016 年。

[7]黄、李一民和马可·瓦尔托塔。"珀尔的干涉计算完成了."arXiv 预印本 arXiv:1206.6831 (2012)。

杯形 R-闪亮工具

原文：https://towardsdatascience.com/cuped-r-shiny-tool-7a4869d77f0a?source=collection_archive---------32-----------------------

CUPED 简介

最近，我一直在探索提高实验灵敏度的方法——通过减少与实验前信息相关的方差。如果可以确定实验前指标(协变量)和实验指标之间的强相关性，则在进行任何显著性测试之前，可以控制实验指标中存在的方差。当使用预实验数据(CUPED)方法实施控制时，有几个不同的程序值得考虑，但我在 以前的中型帖子 (改编自【Booking.com】)中已经写过关于“协变方法”的内容。协变量方法关注预实验和实验指标之间的关系(这通常是一个连续变量)，忽略实验开始前存在的差异。所述方差的减少导致实验能力的增加，这意味着您更有可能检测到统计上显著的影响(考虑这是一种降噪的方法，以便检测在您的实验条件之间可能存在或可能不存在的任何真实影响)。

我以前在 CUPED 方法方面的工作包括一个使用我在 Python 中的一些工作的例子，以及如何将预实验信息合并到您在 cookie_id 单元上的实验数据中。遗憾的是，执行这种分析可能是相当劳动密集型的，包括导入数据帧，确保它们具有唯一的标识符，然后执行与实验前和实验数据帧的合并(我们大多数人都没有那么多时间)。

出于这个原因，我构建了一个前端的、用户友好的 R Shiny 工具，它只需要上传几个简单的文件，所有繁重的工作都会为您完成。除了将我的 Python 作品翻译成 R 函数，这是一个相当简单的工作，你可以在这里 找到该工具的 链接。

你也可以在我的 GitHub 上找到该工具的代码。

使用工具

可以通过上面的 url 访问 CUPED 分析工具。您只需为协变量和实验指标填写两个单独的 xlsx 文件。您可以下载这些模板并将它们上传回应用程序。

一旦这些文件被上传回应用程序，就会为您计算 CUPED 调整后的指标，因此不需要额外的代码。应用于每个 cookie_unit 的常数(θ)计算如下:

cor_frame <- inner_join(covariate, metric, by = ‘User_Id’)

 covariance <- cov(cor_frame$Metric, cor_frame$Covariate_Metric)

 variance <- var(cor_frame$Covariate_Metric)

 theta <- covariance/variance

 cor_frame$CUPED_Adjusted_Metric <- cor_frame$Metric — (cor_frame$Covariate_Metric — mean(cor_frame$Covariate_Metric)) * theta

然后，您可以为您的协变量和实验指标绘制散点图；还提供了您的 R 和 p 值，这有助于您确定变量之间的关系强度，以及随后您的协变量是否适合 CUPED 方法:

图一。实验前协变量和实验指标之间的相关性，以及每个实验条件和指标的分布。r 和 p 值在图上给出。

在确定了实验前指标和实验指标之间的关系后，您可以对 CUPED 调整后的指标执行显著性测试。此输出提供组间方差分析(ANOVA)的结果，其中 p 设置为 0.05 :

图二。经 CUPED 调整的指标的组间单向方差分析的输出。

然后，您可以分别生成实验指标和实验前协变量的平均值和标准差的表格。此表中最右边的一行显示了在显著性测试之前，您的 CUPED 调整指标忽略的相对差异量:

图 3。计算前后平均值和标准偏差的表格输出。方差减少的百分比是两个标准差之间的相对差值。

从图 3 中可以看出，在对所有三个实验条件进行显著性测试之前，已经减少了大量的差异。进行这种分析意味着你将提高实验的灵敏度，并得出更大数量的具有统计学意义的测试结论。

您还可以在您的实验中使用的每个个体变体之间生成成对比较(重复 t 检验)。这不仅有助于您识别给定的变异是否超出了您的控制条件，还能识别所有其他比较之间的统计差异:

图 4。表输出显示了 CUPED 调整指标的实验条件之间的独立 t 检验

享受这个工具吧！

弗兰克

使用 K-Means 聚类管理两个人的 Spotify Discover 播放列表

原文：https://towardsdatascience.com/curating-a-spotify-discover-playlist-for-two-people-with-k-means-clustering-a926a9e1ec7d?source=collection_archive---------46-----------------------

选择一个朋友一起发现全新的音乐。我们通过机器学习创建了一个符合你两种口味的冒险播放列表。

照片由晨酿在 Unsplash 拍摄

iTunes 革新了音乐。Spotify 又这么做了。

音乐是我生活中的必需品。不仅因为我可以即时访问 5000 万首歌曲和超过 100 万个播客(耐心等待 9 月份的罗根)，还因为内置的推荐功能，在我还没有听完之前，它就神奇地告诉我我最新喜欢的歌曲是什么。Spotify 研究了我过去 7 年的收听历史，在彻底改变我的音乐品味方面发挥了巨大作用。我对 90 年代地下新灵魂 boombap 的热爱不是由我的韩国家庭介绍给我的，也不是来自我成长的爱看排行榜前 50 名的尔湾郊区。这是因为连续几个小时一次又一次地陷入 Spotify 推荐算法的兔子洞。我已经能够发现最喜欢的艺术家，并使我的流派调色板多样化，这远远超出了没有 Spotify 的情况。

对我的音乐探索之旅最重要的帮助就是 Spotify 的 Discover Weekly 播放列表。通过访问超过 1.1 亿用户的收听历史，Spotify 数据科学家每周一为用户推荐 30 首新歌曲，充分发挥了他们的 ML 能力。

我的每周探索播放列表截图

在 Spotify 的推荐中寻找一颗隐藏的宝石是如此令人愉快的经历，以至于我想知道是否有可能将这变成一次合作体验。我想创建一个探索每周播放列表，了解两个人的音乐品味，并为他们推荐歌曲。由于隔离仍然是一件事，我认为这个“一起发现”播放列表可以作为一种新颖的社交活动。所以我和我的朋友 Arjun Reddy 合作，我们准备好了。

点击这里查看完整的 GitHub 回购:https://github.com/trustinyoon/Spotify-Discover-2gether

数据收集

Arjun 和我决定将为我们的集体音乐品味策划的“一起发现”播放列表自动化，作为一项测试。我们使用 Spotify Web API 的轻量级 Python 库 Spotipy，并创建了一个 Spotify 开发者应用程序来获得 Spotify 个人资料数据的授权。这是官方的 Spotipy 文档:https://spotipy.readthedocs.io/en/2.13.0/

我们还从 Plegas Gerasimos 的回购协议中派生出授权流程代码，其中包含授权流程代码，可在此处找到:【https://github.com/makispl/Spotify-Data-Analysis

然后，我们创建了一个代码，授权访问用户的 Spotify 个人资料，使用 Spotify 的 current_user_top_tracks()函数提取他们的 50 首中期歌曲。中期是最佳的时间范围，因为短期歌曲太短(大约 1 周的歌曲)而长期太长(基本上是用户所有时间的歌曲历史)。然后将用户的前 50 首中期歌曲提取到一个. csv 文件中，并对第二个用户重复这一过程。

我们将前 50 首歌曲合并成一个包含 100 首歌曲的数据框架，用于分析和推荐歌曲。每首歌曲都有 Spotify 提供的关于其不同声音特征的官方数据:可跳舞性、能量、调(音乐调)、响度、模式(小调或大调)、语速、声学、乐器性、活跃度、效价(听起来有多积极/快乐/欢快)和节奏。这些特性用于从我们的数据帧创建集群。在得出其他特征对我们的分析来说是噪音的结论后，我们选择将重点放在可跳性、能量、语速、声音、效价和节奏上。这是我们最近最喜欢的歌曲的分布图。

k 均值聚类

现在我们有了两个用户的前 50 首歌曲，我们可以使用这些歌曲来推荐适合两个人最近音乐品味的新歌。K-means 聚类是我们选择的方法，以便我们可以将组合歌曲中的每首歌曲分组到具有相似声音特征的聚类(子流派/歌曲类型)中。我们选择 k=20，即使 elbow 方法显示最佳 k=6，因为我们希望有更多指定的聚类，并基于不太一般化的聚类来推荐歌曲。如果歌曲在 6 轴图上的位置接近欧几里德距离，则它们将被聚集在一起。下面是 100 首歌曲的三维可视化，分别用它们各自的聚类来标记。

可视化时，一些信息会丢失，因为我们将 6 个特征展平到 3 个维度上。我们仍然能够可视化 20 个聚类，其中在给定的聚类中，每首歌曲彼此之间具有接近的欧几里德距离。

我们可以在下面进一步探究每个集群的摘要。

每个聚类的歌曲数量直方图(左)聚类的平均歌曲特征分布(右)

构建“一起发现”播放列表

一旦我们获得了每个集群的歌曲列表，我们就将每个列表输入到 Spotipy 的 recommendation()函数中，该函数接受 5 首种子歌曲作为推荐的基础。对于包含 5 首以上歌曲的聚类，我们从列表中随机选择 5 首来代表该聚类。包含少于 5 首歌曲的集群，我们保持原样。我们为每个聚类运行推荐功能，每次它为包含少于 5 首歌曲的聚类产生 1 首推荐曲目，为包含 5 首歌曲的聚类产生 2 首推荐曲目。我们想把更多的权重放在有更多歌曲的集群上，因为这意味着我们通常更喜欢那些集群中的歌曲。在获取所有推荐的曲目后，我们将它们放入一个列表中作为 Spotify 函数的参数，该函数会自动创建一个播放列表，并将给定的歌曲列表直接放入用户的 Spotify 库中。

结论

经过一周的编码，我们终于自动化了“一起发现”播放列表！下面是它的样子！

虽然有几首歌我们已经听过了，但我们普遍对推荐的质量非常满意，我们每个人都在个人播放列表中添加了几首推荐的歌曲！

“一起发现”还没有被开发成一个有效的公共网络应用。我们正在寻找任何能够熟练使用 JSON、web APIs 或 UI/UX 的应用程序开发人员，他们有兴趣帮助我们将这个项目变成一个可供任何两个想要一起探索新音乐的人使用的应用程序！如果你感兴趣，请通过 trustinyoon@gmail.com 或 arjunravulareddy@gmail.com联系我们！

---

9/14/20 更新:我们已经建立了一个功能正常的网络应用程序，正在寻找出色的用户界面/UX 和图形设计师来帮助我们的标志，着陆页面美学和营销材料！如果有兴趣，请给 trustinyoon@gmail.com 发邮件，附上你的投资组合链接:)