fast.ai 机器学习笔记（二）

机器学习 1：第 5 课

原文：medium.com/@hiromi_suenaga/machine-learning-1-lesson-5-df45f0c99618

译者：飞龙

协议：CC BY-NC-SA 4.0

来自机器学习课程的个人笔记。随着我继续复习课程以“真正”理解它，这些笔记将继续更新和改进。非常感谢 Jeremy 和 Rachel 给了我这个学习的机会。

视频

复习

• 测试集，训练集，验证集和 OOB

我们有一个数据集，其中有很多行，我们有一些因变量。机器学习和其他任何工作之间的区别是什么？区别在于，在机器学习中，我们关心的是泛化准确性或泛化错误，而在其他几乎所有情况下，我们只关心我们能够如何将观察结果映射到。所以，泛化是机器学习的关键独特部分。如果我们想知道我们是否做得好，我们需要知道我们是否做得好泛化。如果我们不知道这一点，我们什么也不知道。

问题：泛化，你是指缩放吗？能够扩展吗？[1:26] 不，我一点也不是指缩放。缩放在许多领域中是重要的。就像好吧，我们有一个在我的电脑上使用 1 万个项目的东西，现在我需要让它每秒处理 1 万个项目。所以缩放很重要，但不仅仅是对于机器学习，而是对于我们投入生产的几乎所有东西都很重要。泛化是我说的，好吧，这是一个可以预测猫和狗的模型。我看了五张猫的图片和五张狗的图片，我建立了一个完美的模型。然后我看了另一组五只猫和狗，结果全都错了。所以在这种情况下，它学到的不是猫和狗之间的区别，而是学到了那五只具体的猫长什么样，那五只具体的狗长什么样。或者我建立了一个预测特定产品的杂货销售模型，比如上个月新泽西的卫生纸销售，然后我把它投入生产，它扩展得很好（换句话说，延迟很低，没有高 CPU 负载），但它无法预测除了新泽西的卫生纸之外的任何东西。事实证明，它只在上个月做得好，而不是下个月。这些都是泛化失败。

人们检查泛化能力最常见的方法是创建一个随机样本。他们会随机选择几行数据并将其提取到一个测试集中。然后他们会在其余的行上构建所有模型，当他们完成时，他们会检查在测试集上获得的准确性（其余的行被称为训练集）。所以在建模过程结束时，在训练集上，他们得到了 99%的准确性，预测猫和狗，最后，他们会将其与测试集进行比较，以确保模型真正泛化。

现在的问题是，如果不行怎么办？嗯，我可以回去改变一些超参数，做一些数据增强，或者尝试创建一个更具泛化性的模型。然后我再次回去，做了所有这些之后，检查结果仍然不好。我会一遍又一遍地这样做，直到最终，在尝试了五十次之后，它泛化了。但它真的泛化了吗？因为也许我所做的一切只是偶然找到了这个恰好适用于那个测试集的模型，因为我尝试了五十种不同的方法。所以如果我有一个东西，巧合地 5%的时间是正确的，那么很可能不会偶然得到一个好的结果。所以我们通常会将第二个数据集（验证集）放在一边。然后，不在验证集或测试集中的所有内容现在都是训练集。我们训练一个模型，对其进行验证以查看其是否泛化，重复几次。然后当我们最终得到了我们认为会根据验证集成功泛化的东西（在项目结束时），我们会对其进行测试。

问题：所以基本上通过制作这两层测试集和验证集，如果一个对了另一个错了，你就是在双重检查你的错误？它检查我们是否过度拟合验证集。所以如果我们一遍又一遍地使用验证集，那么我们最终可能得不到一组适用于训练集和验证集的可泛化的超参数，而只是一组恰好适用于训练集和验证集的超参数。所以如果我们对验证集尝试了 50 种不同的模型，然后在所有这些之后，我们再对测试集进行检查，结果仍然是泛化的，那么我们会说好的，我们实际上已经得到了一个可泛化的模型。如果不是，那么就会说我们实际上现在过度拟合了验证集。在那一点上，你会陷入麻烦。因为你没有留下任何东西。所以想法是在建模过程中使用有效的技术，以防止这种情况发生。但如果它确实发生了，你希望找出原因——你需要那个测试集，否则当你投入生产时，结果却不能泛化，那将是一个非常糟糕的结果。你最终会发现点击你的广告的人会减少，或者销售你的产品会减少，或者为高风险车辆提供汽车保险的人会减少。

问题：所以只是为了确保，我们需要检查验证集和测试集是否一致，还是只保留测试集？如果你像我刚刚做的那样随机抽样，没有特定的原因需要检查，只要它们足够大。但我们将在稍后的不同情境中回答你的问题。

我们学到的另一个随机森林的技巧是一种不需要验证集的方法。我们学到的方法是使用 OOB 分数。这个想法是，每次我们在随机森林中训练一棵树时，都会有一些观察结果被保留，因为这就是我们获得一些随机性的方式。因此，让我们基于这些保留样本计算每棵树的分数，然后通过对每行不参与训练的树进行平均，得到整个森林的分数。因此，OOB 分数给我们提供了与验证分数非常相似的东西，但平均来看，它稍微差一些。为什么？因为每一行都将使用一部分树来进行预测，而树越少，我们知道预测就越不准确。这是一个微妙的问题，如果你没有理解，那就在这一周内考虑一下，直到你明白为什么，因为这是对你对随机森林理解的一个非常有趣的测试。为什么 OOB 分数平均来看比你的验证分数差一些？它们都使用随机保留的子集。

总的来说，这通常足够了。那么在使用随机森林时为什么还要有一个验证集呢？如果是一个随机选择的验证集，严格来说并不是必需的，但你有四个层次的测试——所以你可以在 OOB 上测试，当那个工作良好时，你可以在验证集上测试，希望到检查测试集时不会有什么意外，这将是一个很好的理由。

Kaggle 的做法是相当聪明的。Kaggle 的做法是将测试集分成两部分：一个公共部分和一个私有部分。他们不告诉你哪个是哪个。所以你将你的预测提交给 Kaggle，然后随机选择其中 30%用来告诉你排行榜分数。但是在比赛结束时，这部分将被丢弃，他们将使用另外 70%来计算你的真实分数。这样做的目的是确保你不会持续使用来自排行榜的反馈来找出一组在公共部分表现良好但实际上不具有泛化性的超参数。这是一个很好的测试。这也是为什么在比赛结束时使用 Kaggle 是一个很好的做法的原因之一，因为在比赛的最后一天，当他们使用私有测试集时，你的排名会下降一百名，然后你会明白，这就是过拟合的感觉，练习和获得这种感觉要比在公司中有数亿美元的风险要好得多。

这就像是可能的最简单情况，你可以使用一个随机样本作为你的验证集。为什么我可能无法使用一个随机样本作为我的验证集，或者可能失败呢？我的观点是，通过使用一个随机验证集，我们可能会对我们的模型完全产生错误的看法。要记住的重要事情是，当你构建一个模型时，你总是会有一个系统误差，即你将在比构建模型时晚的时间使用该模型。你将在生产中使用它，到那时，世界已经不同于你现在所处的世界，即使在构建模型时，你使用的数据也比今天的数据旧。因此，在你构建模型的数据和实际使用的数据之间存在一些滞后。大部分时间，如果不是大部分时间，这是很重要的。

因此，如果我们正在预测谁会在新泽西购买卫生纸，而我们需要两周时间将其投入生产，并且我们使用了过去几年的数据进行预测，那时情况可能会大不相同。特别是我们的验证集，如果我们随机抽样，而且是从四年的时间段中抽取的，那么绝大多数数据将是一年多以前的。也许新泽西人的购买习惯可能已经发生了巨大变化。也许他们现在正经历着严重的经济衰退，无法再购买高质量的卫生纸。或者也许他们的造纸工业飞速发展，突然间他们购买更多卫生纸，因为价格便宜。世界在变化，因此如果你为验证集使用随机样本，那么实际上你正在检查你在预测完全过时的事物方面有多好？你有多擅长预测四年前发生的事情？这并不有趣。因此，在实践中，每当有一些时间因素时，我们要做的是假设我们已经按时间排序，我们将使用最新的部分作为我们的验证集。我想，实际上应该正确地执行：

这是我们的验证集，这是我们的测试集。所以剩下的就是我们的训练集，我们使用它并尝试能够建立一个模型，使其仍然适用于比模型建立时更晚的时间。因此，我们不仅仅是在某种抽象意义上测试泛化性能，而是在一个非常具体的时间意义上，即它是否能泛化到未来。

问题：正如您所说，数据中存在一些时间顺序，那么在这种情况下，是明智地使用整个数据进行训练，还是只使用最近的一些数据集进行训练？是的，这是一个完全不同的问题。那么如何确保验证集的质量良好呢？我在所有训练数据上构建了一个随机森林。它在训练数据上看起来不错，在 OOB 上也看起来不错。这实际上是有 OOB 的一个很好的原因。如果在 OOB 上看起来不错，那么这意味着你在统计意义上没有过拟合。它在一个随机样本上表现良好。但是然后在验证集上看起来不好。那么发生了什么？嗯，发生的是你在某种程度上未能预测未来。你只是预测了过去，所以 Suraj 有一个关于如何解决这个问题的想法。好吧，也许我们应该只训练，也许我们不应该使用整个训练集。我们应该只尝试最近的一段时间。现在缺点是，我们现在使用的数据更少，因此我们可以创建更少的丰富模型，但好处是，这是更为最新的数据。这是你必须尝试的事情。大多数机器学习函数都有能力为每一行提供一个权重。例如，对于随机森林，你可以在每一行上设置一个权重，并以某种概率随机选择该行。因此，我们可以设置概率，使得最近的行有更高的被选中的概率。这可能非常有效。这是你必须尝试的事情，如果你没有一个代表未来的验证集，与你正在训练的数据相比，你就无法知道哪些技术是有效的。

你如何在数据量和数据新旧之间做出妥协？我倾向于这样做，当我遇到这种时间问题时，也许大部分时间都是这样，一旦我在验证集上找到了一个表现良好的模型，我就不会直接在测试集上使用那个模型，因为测试集比训练集要远得多。所以我会重新构建那个模型，但这次我会将训练和验证集合并起来重新训练模型。在那一点上，你没有办法对验证集进行测试，所以你必须确保你有一个可重现的脚本或笔记本，以确保完全相同的步骤，因为如果你出错了，你会发现在测试集上出现了问题。所以我在实践中所做的是，我需要知道我的验证集是否真正代表了测试集。所以我在训练集上建立了五个模型，并尝试让它们在我认为它们有多好的方面有所不同。然后我在验证集上对我的五个模型进行评分，然后我也在测试集上对它们进行评分。所以我没有作弊，因为我没有使用来自测试集的任何反馈来改变我的超参数——我只是用它来检查我的验证集。所以我从验证集和测试集中得到了五个分数，然后我检查它们是否在一条线上。如果不是，那么你将无法从验证集中获得足够好的反馈。所以继续这个过程，直到你得到一条线，这可能会很棘手。试图创建尽可能接近真实结果的东西是困难的。在现实世界中，创建测试集也是如此——测试集必须尽可能接近生产。那么实际使用这个产品的客户组合是什么样的，你构建模型和投入生产之间实际会有多少时间？你能够多频繁地更新模型？这些都是在构建测试集时需要考虑的事情。

问题：所以首先你在训练数据上建立了五个模型，如果没有得到直线关系，就改变你的验证和测试集？通常你不能真正改变测试集，所以这是假设测试集已经给定，你改变验证集。所以如果你开始用一个随机样本验证集，然后结果千奇百怪，你意识到哦，我应该选择最近的两个月。然后你选择了最近的两个月，结果还是千奇百怪，你意识到哦，我应该选择从每个月的第一天到第十五天，然后不断改变验证集，直到找到一个能够反映你的测试集结果的集合。

问题：对于五个模型，你可能从随机数据、平均值等开始？也许不是五个糟糕的模型，但你想要一些变化，尤其是你想要一些在时间上可能泛化得更好的模型。一个是在整个训练集上训练的，一个是在最后两周训练的，一个是在最后六周训练的，一个使用了很多列可能会过拟合一些。所以你想要知道如果我的验证集在时间上无法泛化，我想看到这一点，如果在统计上无法泛化，我也想看到这一点。

问题：你能详细解释一下你所说的改变验证集以使其表示测试集是什么意思吗？看起来是什么样子？让我们以杂货竞赛为例，我们试图预测接下来两周的杂货销售额。Terrance 和我尝试过的可能的验证集是：

• 随机样本（4 年）

• 最近一个月的数据（7 月 15 日至 8 月 15 日）

• 过去的两周（8 月 1 日至 15 日）

• 一个月前的同一天范围（7 月 15 日至 30 日）

这个比赛中的测试集是 8 月 15 日至 30 日。所以上面是我们尝试的四个不同的验证集。随机的结果是完全不稳定的。上个月的结果不错但也不是很好。过去的两周，有一些看起来不好，但总体上还不错。一个月前的同一天范围内，他们有一个基本完美的线。

问题：我们到底是在与测试集中的什么进行比较？我建立了 5 个模型，可能是 1.只是预测平均值，2.对整个数据集进行某种简单的组平均，3.对过去一个月的数据进行某种组平均，4.构建整个数据集的随机森林，5.从过去三周构建随机森林。在每一个上，我计算验证分数。然后我在整个训练集上重新训练模型，并在测试集上进行相同的计算。所以现在每个点告诉我它在验证集上表现如何，它在测试集上表现如何。如果验证集有用，我们会说每次验证分数提高，测试集分数也应该提高。

问题：当你说“重新训练”时，你是指在训练和验证集上重新训练模型吗？是的，所以一旦我得到了基于训练集的验证分数，然后在训练和验证集上重新训练，并与测试集进行对比。

问题：通过测试集，你是指将其提交到 Kaggle 并检查分数吗？如果是 Kaggle，那么你的测试集就是 Kaggle 的排行榜。在现实世界中，测试集是你放在一边的第三个数据集。这第三个数据集反映真实世界生产差异是机器学习项目中最重要的一步。为什么这是最重要的一步？因为如果你搞砸了其他一切但没有搞砸这个，你会知道你搞砸了。如果你有一个好的测试集，那么你会知道你搞砸了，因为你搞砸了其他东西并测试了它，结果不尽人意，没关系。你不会毁掉公司。如果你搞砸了创建测试集，那将是可怕的。因为那样你就不知道自己是否犯了错误。你尝试构建一个模型，你在测试集上测试它，看起来不错。但测试集并不代表真实世界环境。所以你实际上不知道你是否会毁掉公司。希望你有逐渐将事物投入生产的方式，这样你就不会真的毁掉公司，但至少会毁掉你在工作中的声誉。哦，Jeremy 试图将这个东西投入生产，在第一周我们尝试的队伍中，他们的销售额减半了，我们再也不会让 Jeremy 做机器学习工作了。但如果 Jeremy 使用了适当的测试集，那么他会知道，哦，这只有我的验证集说的一半好，我会继续尝试。现在我不会惹麻烦了。我实际上很喜欢 Jeremy - 他能提前识别出将会出现泛化问题的情况。

这是每个人在机器学习课程中都会谈论一点的事情，但通常停在你学到了 sklearn 中有一个叫做 make train_test_split的东西，它返回这些东西，然后你就可以继续了，或者这里是交叉验证函数。这些东西总是给你随机样本的事实告诉你，如果不是大部分时间，你不应该使用它们。随机森林免费提供 OOB，这很有用，但只告诉你这在统计意义上是泛化的，而不是在实际意义上。

交叉验证

在课外，你们一直在讨论很多，这让我觉得有人一直在过分强调这种技术的价值。所以我会解释什么是交叉验证，然后解释为什么你大部分时间可能不应该使用它。

交叉验证意味着我们不只是拿出一个验证集，而是拿出五个，例如。所以让我们首先假设我们要随机洗牌数据。这是至关重要的。

1. 随机洗牌数据。

2. 将其分成五组

3. 对于模型 №1，我们将第一个称为验证集，底部四个称为训练集。

4. 我们将训练并检查验证，得到一些 RMSE、R²等。

5. 我们将重复这个过程五次，然后取 RMSE、R²等的平均值，这是交叉验证的平均准确度。

使用交叉验证相比标准验证集的好处是什么？你可以使用所有的数据。你不必留下任何东西。而且你还有一个小小的好处，你现在有了五个模型，可以将它们组合在一起，每个模型使用了 80%的数据。有时这种集成可以很有帮助。

有哪些原因你不会使用交叉验证呢？对于大型数据集，它会花费很长时间。我们必须拟合五个模型而不是一个，所以时间是一个关键的缺点。如果我们在进行深度学习，需要一天的时间来运行，突然之间需要五天，或者我们需要 5 个 GPU。那么关于我之前关于验证集的问题呢？我们之前对为什么随机验证集是一个问题的担忧在这里完全相关。这些验证集是随机的，所以如果一个随机验证集对你的问题不合适，很可能是因为，例如，时间问题，那么这五个验证集都不好。它们都是随机的。所以如果你有像之前一样的时间数据，就没有办法进行交叉验证，或者没有好的方法进行交叉验证。你希望你的验证集尽可能接近测试集，而你不能通过随机抽样不同的东西来做到这一点。你可能不需要进行交叉验证，因为在现实世界中，我们通常并没有那么少的数据 —— 除非你的数据是基于一些非常昂贵的标记过程或一些昂贵的实验。但如今，数据科学家并不经常做这种工作。有些人在做，如果是这样，那么这是一个问题，但我们大多数人不是。所以我们可能不需要。即使我们这样做了，它会花费很多时间，即使我们这样做了并花费了所有的时间，它可能会给我们完全错误的答案，因为随机验证集对我们的问题是不合适的。

我不会花太多时间在交叉验证上，因为我认为它是一个有趣的工具，易于使用（sklearn 有一个可以使用的交叉验证工具），但在我看来，它并不经常是你工具箱中的重要部分。有时会用到。所以这就是验证集。

树解释[38:02]

from treeinterpreter import treeinterpreter as ti
df_train, df_valid = split_vals(df_raw[df_keep.columns], n_trn)
row = X_valid.values[None,0]; row
'''
array([[4364751, 2300944, 665, 172, 1.0, 1999, 3726.0, 3, 3232, 1111, 0, 63, 0, 5, 17, 35, 4, 4, 0, 1, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 12, 0, 0, 0, 0, 0, 3, 0, 0, 0, 2, 19, 29, 3, 2, 1, 0, 0, 0, 0, 0, 2010, 9, 37,
        16, 3, 259, False, False, False, False, False, False, 7912, False, False]], dtype=object)
'''
prediction, bias, contributions = ti.predict(m, row)

prediction[0], bias[0]
'''
(9.1909688098736275, 10.10606580677884)
'''

idxs = np.argsort(contributions[0])
[
   o for o in zip(
      df_keep.columns[idxs], 
      df_valid.iloc[0][idxs], 
      contributions[0][idxs]
   )
]
'''
[('ProductSize', 'Mini', -0.54680742853695008),
 ('age', 11, -0.12507089451852943),
 ('fiProductClassDesc',
  'Hydraulic Excavator, Track - 3.0 to 4.0 Metric Tons',
  -0.11143111128570773),
 ('fiModelDesc', 'KX1212', -0.065155113754146801),
 ('fiSecondaryDesc', nan, -0.055237427792181749),
 ('Enclosure', 'EROPS', -0.050467175593900217),
 ('fiModelDescriptor', nan, -0.042354676935508852),
 ('saleElapsed', 7912, -0.019642242073500914),
 ('saleDay', 16, -0.012812993479652724),
 ('Tire_Size', nan, -0.0029687660942271598),
 ('SalesID', 4364751, -0.0010443985823001434),
 ('saleDayofyear', 259, -0.00086540581130196688),
 ('Drive_System', nan, 0.0015385818526195915),
 ('Hydraulics', 'Standard', 0.0022411701338458821),
 ('state', 'Ohio', 0.0037587658190299409),
 ('ProductGroupDesc', 'Track Excavators', 0.0067688906745931197),
 ('ProductGroup', 'TEX', 0.014654732626326661),
 ('MachineID', 2300944, 0.015578052196894499),
 ('Hydraulics_Flow', nan, 0.028973749866174004),
 ('ModelID', 665, 0.038307429579276284),
 ('Coupler_System', nan, 0.052509808150765114),
 ('YearMade', 1999, 0.071829996446492878)]
'''

array([[4364751, 2300944, 665, 172, 1.0, 1999, 3726.0, 3, 3232, 1111, 0, 63, 0, 5, 17, 35, 4, 4, 0, 1, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 12, 0, 0, 0, 0, 0, 3, 0, 0, 0, 2, 19, 29, 3, 2, 1, 0, 0, 0, 0, 0, 2010, 9, 37,
        16, 3, 259, False, False, False, False, False, False, 7912, False, False]], dtype=object)

contributions[0].sum()*-0.7383536391949419*

外推[49:23]

df_ext = df_keep.copy()
df_ext['is_valid'] = 1
df_ext.is_valid[:n_trn] = 0
x, y, nas = proc_df(df_ext, 'is_valid')

m = RandomForestClassifier(
      n_estimators=40, 
      min_samples_leaf=3, 
      max_features=0.5, 
      n_jobs=-1, 
      oob_score=True
)
m.fit(x, y);
m.oob_score_
'''
0.99998753505765037
'''

fi = rf_feat_importance(m, x); fi[:10] 

feats='SalesID', 'saleElapsed', 'MachineID'.describe()

(X_valid[feats]/1000).describe()

x.drop(feats, axis=1, inplace=True)
m = RandomForestClassifier(
   n_estimators=40, 
   min_samples_leaf=3, 
   max_features=0.5, 
   n_jobs=-1, 
   oob_score=True
)
m.fit(x, y);
m.oob_score_
'''
0.9789018385789966
'''

fi = rf_feat_importance(m, x); fi[:10]

set_rf_samples(50000)
feats=['SalesID', 'saleElapsed', 'MachineID', 'age', 'YearMade', 'saleDayofyear']X_train, X_valid = split_vals(df_keep, n_trn)
m = RandomForestRegressor(
   n_estimators=40, 
   min_samples_leaf=3, 
   max_features=0.5, 
   n_jobs=-1, 
   oob_score=True
)
m.fit(X_train, y_train)
print_score(m)
'''
[0.21136509778791376, 0.2493668921196425, 0.90909393040946562, 0.88894821098056087, 0.89255408392415925]
'''

for f in feats:
    df_subs = df_keep.drop(f, axis=1)
    X_train, X_valid = split_vals(df_subs, n_trn)
    m = RandomForestRegressor(
         n_estimators=40, 
         min_samples_leaf=3, 
         max_features=0.5, 
         n_jobs=-1, 
         oob_score=True
    )
    m.fit(X_train, y_train)
    print(f)
    print_score(m)
SalesID 
'''
[0.20918653475938534, 0.2459966629213187, 0.9053273181678706, 0.89192968797265737, 0.89245205174299469]
'''
saleElapsed 
'''
[0.2194124612957369, 0.2546442621643524, 0.90358104739129086, 0.8841980790762114, 0.88681881032219145]
'''
MachineID
'''
[0.206612984511148, 0.24446409479358033, 0.90312476862123559, 0.89327205732490311, 0.89501553584754967]
'''
age
'''
[0.21317740718919814, 0.2471719147150774, 0.90260198977488226, 0.89089460707372525, 0.89185129799503315]
'''
YearMade
'''
[0.21305398932040326, 0.2534570148977216, 0.90555219348567462, 0.88527538596974953, 0.89158854973045432]
'''
saleDayofyear
'''
[0.21320711524847227, 0.24629839782893828, 0.90881970943169987, 0.89166441133215968, 0.89272793857941679]
'''

reset_rf_samples()

df_subs = df_keep.drop(
   ['SalesID', 'MachineID', 'saleDayofyear'], 
   axis=1
)
X_train, X_valid = split_vals(df_subs, n_trn)
m = RandomForestRegressor(
   n_estimators=40, 
   min_samples_leaf=3, 
   max_features=0.5, 
   n_jobs=-1, 
   oob_score=True
)
m.fit(X_train, y_train)
print_score(m)
'''
[0.1418970082803121, 0.21779153679471935, 0.96040441863389681, 0.91529091848161925, 0.90918594039522138]
'''

plot_fi(rf_feat_importance(m, X_train));

np.save('tmp/subs_cols.npy', np.array(df_subs.columns))

我们的最终模型！

m = RandomForestRegressor(
   n_estimators=160, 
   max_features=0.5, 
   n_jobs=-1, 
   oob_score=True
)
%time m.fit(X_train, y_train)
print_score(m)
'''
CPU times: user 6min 3s, sys: 2.75 s, total: 6min 6s
Wall time: 16.7 s
[0.08104912951128229, 0.2109679613161783, 0.9865755186304942, 0.92051576728916762, 0.9143700001430598]
'''

正如你所看到的，我们进行了所有的解释，所有的微调基本上都是用较小的模型/子集进行的，最后，我们运行了整个过程。实际上，这只花了 16 秒，所以我们现在的 RMSE 是 0.21。现在我们可以将其与 Kaggle 进行比较。不幸的是，这是一个较旧的比赛，我们不允许再参加，看看我们会取得怎样的成绩。所以我们能做的最好的就是检查它是否看起来我们可能会根据他们的验证集做得很好，所以应该在正确的范围内。根据这一点，我们本来会得第一名。

我认为这是一系列有趣的步骤。所以你可以在你的 Kaggle 项目和更重要的是你的现实世界项目中按照相同的步骤进行。其中一个挑战是一旦你离开这个学习环境，突然间你周围都是从来没有足够时间的人，他们总是希望你赶快，他们总是告诉你这样做然后那样做。你需要找到时间远离一下然后回来，因为这是一个你可以使用的真正的现实世界建模过程。当我说它提供了世界级的结果时，我的意思是真的。赢得这个比赛的人，Leustagos，不幸地去世了，但他是有史以来最顶尖的 Kaggle 竞争者。我相信他赢得了数十个比赛，所以如果我们能够得到一个甚至接近他的分数，那么我们做得真的很好。

澄清：这两者之间 R²的变化不仅仅是因为我们删除了这三个预测因子。我们还进行了reset_rf_samples()。因此，要真正看到仅仅删除的影响，我们需要将其与之前的最终步骤进行比较。

实际上与 0.907 的验证相比。因此，删除这三个因素使我们的分数从 0.907 提高到 0.915。最终，当然最重要的是我们的最终模型，但只是澄清一下。

从头开始编写随机森林！

笔记本

我的原始计划是实时进行，但当我开始做的时候，我意识到那样会很无聊，所以，我们可能会一起更多地走一遍代码。

实现随机森林算法实际上是相当棘手的，不是因为代码很棘手。一般来说，大多数随机森林算法在概念上都很容易。一般来说，学术论文和书籍往往让它们看起来很困难，但从概念上讲并不困难。困难的是把所有细节搞对，知道什么时候是对的。换句话说，我们需要一种好的测试方法。因此，如果我们要重新实现已经存在的东西，比如说我们想在一些不同的框架、不同的语言、不同的操作系统中创建一个随机森林，我总是从已经存在的东西开始。因此，在这种情况下，我们只是把它作为学习练习，用 Python 编写一个随机森林，因此为了测试，我将把它与现有的随机森林实现进行比较。

这是至关重要的。每当你在涉及机器学习中的非平凡量的代码时，知道你是对还是错是最困难的部分。我总是假设在每一步都搞砸了一切，所以我在想，好吧，假设我搞砸了，我怎么知道我搞砸了。然后令我惊讶的是，有时候我实际上做对了，然后我可以继续。但大多数时候，我做错了，所以不幸的是，对于机器学习来说，有很多方法可以让你出错，而不会给你错误。它们只会让你的结果稍微不那么好，这就是你想要发现的。

%load_ext autoreload
%autoreload 2
%matplotlib inline

from fastai.imports import *
from fastai.structured import *
from sklearn.ensemble import RandomForestRegressor, 
                             RandomForestClassifier
from IPython.display import display
from sklearn import metrics

因此，考虑到我想要将其与现有实现进行比较，我将使用我们现有的数据集，我们现有的验证集，然后为了简化事情，我只会从两列开始。因此，让我们继续开始编写一个随机森林。

PATH = "data/bulldozers/"

df_raw = pd.read_feather('tmp/bulldozers-raw')
df_trn, y_trn, nas = proc_df(df_raw, 'SalePrice')
def split_vals(a,n): 
   return a[:n], a[n:]
n_valid = 12000
n_trn = len(df_trn)-n_valid
X_train, X_valid = split_vals(df_trn, n_trn)
y_train, y_valid = split_vals(y_trn, n_trn)
raw_train, raw_valid = split_vals(df_raw, n_trn)
x_sub = X_train[['YearMade', 'MachineHoursCurrentMeter']]

我写代码的方式几乎都是自顶向下的，就像我的教学一样。因此，从顶部开始，我假设我想要的一切都已经存在。换句话说，我想要做的第一件事是，我将称之为树集合。要创建一个随机森林，我首先要问的问题是我需要传入什么。我需要初始化我的随机森林。我将需要：

• x：一些自变量

• y：一些因变量

• n_trees：选择我想要的树的数量

• sample_sz：我将从一开始使用样本大小参数，因此您希望每个样本有多大

• min_leaf：然后可能是一些可选参数，表示最小叶子大小。

class TreeEnsemble():
    def __init__(self, x, y, n_trees, sample_sz, min_leaf=5):
        np.random.seed(42)
        self.x,self.y,self.sample_sz,self.min_leaf = x,y,sample_sz,min_leaf
        self.trees = [self.create_tree() for i in range(n_trees)]

    def create_tree(self):
        rnd_idxs = np.random.permutation(len(self.y))[:self.sample_sz]
        return DecisionTree(
            self.x.iloc[rnd_idxs], 
            self.y[rnd_idxs],
            min_leaf=self.min_leaf
         )

    def predict(self, x):
        return np.mean([t.predict(x) for t in self.trees], axis=0)

对于测试，最好使用一个固定的随机种子，这样每次都会得到相同的结果。np.random.seed(42)是设置随机种子的方法。也许值得一提的是，对于那些不熟悉的人来说，计算机上的随机数生成器根本不是随机的。它们实际上被称为伪随机数生成器，它们的作用是在给定一些初始起点（在这种情况下是 42）的情况下，生成一系列确定性（始终相同）的数字，这些数字被设计为：

• 尽可能与前一个数字不相关

• 尽可能不可预测

• 尽可能与具有不同随机种子的东西不相关（因此以 42 开头的序列中的第二个数字应该与以 41 开头的序列中的第二个数字非常不同）

通常，它们涉及使用大素数，取模等等。这是一个有趣的数学领域。如果你想要真正的随机数，唯一的方法就是你可以购买一种叫做硬件随机数生成器的硬件，里面会有一点放射性物质，以及一些检测它输出了多少东西的东西，或者会有一些硬件设备。

问题：当前系统时间是否是有效的随机数生成器[1:09:25]？这可能是一个随机种子（我们用来启动函数的东西）。一个非常有趣的领域是，在您的计算机中，如果您没有设置随机种子，它会被设置为什么。通常，人们会使用当前时间来确保安全性 - 显然，我们在安全方面使用了很多随机数，比如如果您正在生成 SSH 密钥，它需要是随机的。事实证明，人们可以大致确定您创建密钥的时间。他们可以查看id_rsa的时间戳，然后尝试在该时间戳周围的所有不同纳秒起始点上尝试随机数生成器，并找出您的密钥。因此，在实践中，许多需要高度随机性的应用程序实际上都有一步说“请移动鼠标并在键盘上输入一段时间的随机内容”，这样就可以让您成为“熵”的来源。另一种方法是他们会查看一些日志文件的哈希值或类似的东西。这是一个非常有趣的领域。

在我们的情况下，我们的目的实际上是消除随机性[1:10:48]。所以我们说，好吧，生成一系列以 42 开始的伪随机数，所以它应该始终相同。

如果您在 Python 面向对象方面没有做过太多事情，这基本上是标准习语，至少我是这样写的，大多数人不这样写，但是如果您传入五个要保存在此对象内部的东西，那么您基本上必须说self.x = x，等等。我们可以从元组中赋值给元组。

这是我的编码方式。大多数人认为这很糟糕，但我更喜欢一次看到所有东西，这样我就知道在我的代码中，每当我看到类似这样的东西时，它总是在方法中设置的所有内容。如果我以不同的方式做，那么现在一半的代码会从页面底部消失，你就看不到了。

这是我考虑的第一件事 - 要创建一个随机森林，您需要哪些信息。然后我需要将该信息存储在我的对象内部，然后我需要创建一些树。随机森林是一些树的集合。因此，我基本上想到使用列表推导来创建一组树。我们有多少棵树？我们有n_trees棵树。这就是我们要求的。range(n_trees)给我从 0 到n_trees-1的数字。因此，如果我创建一个列表推导，循环遍历该范围，每次调用create_tree，我现在有了n_trees棵树。

为了写这个，我根本不用思考。这一切都是显而易见的。所以我把思考推迟到了这一点，就像好吧，我们没有东西来创建一棵树。好吧，没关系。但让我们假装我们有。如果我们有了，我们现在创建了一个随机森林。我们仍然需要在此基础上做一些事情。例如，一旦我们有了它，我们需要一个预测函数。好的，让我们写一个预测函数。在随机森林中如何进行预测？对于特定的行（或行），遍历每棵树，计算其预测。因此，这里是一个列表推导，它正在为x的每棵树计算预测。我不知道x是一行还是多行，这并不重要，只要tree.predict对其起作用。一旦你有了一系列东西，要知道的一个很酷的事情是你可以传递numpy.mean一个常规的非 numpy 列表，它将取平均值 - 你只需要告诉它axis=0表示跨列表平均。因此，这将返回每棵树的.predict()的平均值。

我发现列表推导允许我按照大脑的方式编写代码[1:14:24]。你可以将这些单词翻译成这段代码，或者你可以将这段代码翻译成单词。所以当我写代码时，我希望它尽可能像那样。我希望它是可读的，所以希望当你查看 fast.ai 代码时，试图理解 Jeremy 是如何做 x 的，我尽量以一种你可以阅读并在脑海中转化为英语的方式来写东西。

我们几乎已经完成了我们的随机森林的编写，不是吗[1:15:29]？现在我们只需要编写create_tree。我们将从数据的随机样本构建一个决策树（即非随机树）。所以再次，我们在这里延迟了任何实际的思考过程。我们基本上说好吧，我们可以选择一些随机 ID。这是一个很好的技巧要知道。如果你调用np.random.permutation传入一个int，它会给你一个从零到那个int的随机洗牌序列。所以如果你获取那个的前:n项，那现在就是一个随机子样本。所以这里不是在这里做引导法（即我们不是在进行有放回的抽样），我认为这是可以接受的。对于我的随机森林，我决定它将是一种我们进行子抽样而不是引导法的情况。

np.random.permutation(len(self.y))[:self.sample_sz]

所以这是一个很好的代码行，知道如何编写，因为它经常出现。我发现在机器学习中，我使用的大多数算法都有些随机，所以我经常需要某种随机样本。

就我个人而言，我更喜欢这种方式，而不是引导法，因为我觉得大多数时候，我们拥有的数据比我们一次想要放入树中的数据要多[1:18:54]。当 Breiman 创建随机森林时，是 1999 年，那是一个非常不同的世界。现在我们有太多的数据。所以人们倾向于启动一个 Spark 集群，当他们没有意义时，他们会在数百台机器上运行它，因为如果他们每次只使用一个子样本，他们可以在一台机器上完成。Spark 的开销是巨大的 I/O 开销。如果你在单台机器上做某事，通常会快上数百倍，因为你没有这种 I/O 开销，而且编写算法也更容易，可视化更容易，更便宜等等。所以我几乎总是避免分布式计算，我一生都是这样。即使在 25 年前我开始学习机器学习时，我也没有使用集群，因为我总觉得无论我现在用集群能做什么，五年后我都可以用一台机器做到。所以为什么不专注于始终尽可能地在一台机器上做得更好呢。这将更具互动性和迭代性。

所以再次，我们延迟思考到必须编写决策树的时候[1:20:26]。希望你能明白这种自顶向下的方法，目标是我们将不断延迟思考，直到最终我们不知不觉地写完整个东西而不必实际思考。请注意，你永远不必设计任何东西。你只需说，如果有人已经给我提供了我需要的确切 API，我该如何使用它？然后实现下一个阶段，我需要实现的确切 API 是什么？你继续下去，直到最终你注意到哦，这已经存在了。

这假设我们有一个名为DecisionTree的类，所以我们将不得不创建它。我们知道我们将不得不传递什么，因为我们刚刚传递了它。所以我们传递了x和y的随机样本。我们知道决策树将包含决策树，这些决策树本身包含决策树。因此，当我们沿着决策树向下走时，原始数据的某个子集将被包含在内，因此我将传递我们实际上将在这里使用的数据的索引。所以最初，它是整个随机样本。我们还传递min_leaf的大小。因此，我们为构建随机森林所做的一切，我们将传递给决策树，除了当然不包括对于决策树无关的num_tree。

class DecisionTree():
   def __init__(self, x, y, idxs=None, min_leaf=5):
      if idxs is None: 
         idxs=np.arange(len(y))
      self.x,self.y,self.idxs,self.min_leaf = x,y,idxs,min_leaf
      self.n,self.c = len(idxs), x.shape[1]
      self.val = np.mean(y[idxs])
      self.score = float('inf')
      self.find_varsplit()

   # This just does one decision; we'll make it recursive later
   def find_varsplit(self):
      for i in range(self.c): self.find_better_split(i)

   # We'll write this later!
   def find_better_split(self, var_idx): 
      pass

   @property
   def split_name(self): 
      return self.x.columns[self.var_idx]

   @property
   def split_col(self): 
      return self.x.values[self.idxs,self.var_idx] 
      
   @property
   def is_leaf(self): 
      return self.score == float('inf')

   def __repr__(self):
      s = f'n: {self.n}; val:{self.val}'
      if not self.is_leaf:
         s += f'; score:{self.score}; split:{self.split}; var:{self.split_name}'
      return s

• self.n: 这棵树中有多少行（我们给定的索引数量）

• self.c: 我们有多少列（独立变量中有多少列）

• self.val: 对于这棵树，它的预测是什么。这棵树的预测是我们依赖变量的均值。当我们谈论索引时，我们并不是在谈论用于创建树的随机抽样。我们假设这棵树现在有一些随机样本。在决策树内部，整个随机抽样的过程已经消失了。那是由随机森林完成的。所以在这一点上，我们正在构建的只是一棵普通的决策树。它不以任何方式是随机抽样的任何东西。所以索引实际上是我们到目前为止在这棵树中得到的数据的哪个子集。

一个快速的面向对象编程入门

我会跳过这部分，但这里有关于self的有趣内容：

你可以随意命名它。如果你把它命名为除了“self”之外的任何其他名称，每个人都会讨厌你，你是个坏人。

机器学习 1：第 6 课

原文：medium.com/@hiromi_suenaga/machine-learning-1-lesson-6-14bbb8180d49

译者：飞龙

协议：CC BY-NC-SA 4.0

来自机器学习课程的个人笔记。随着我继续复习课程以“真正”理解它，这些笔记将继续更新和改进。非常感谢 Jeremy 和 Rachel 给了我这个学习的机会。

视频 / 幻灯片

我们已经看过很多不同的随机森林解释技术，论坛上有一些问题是这些到底有什么用？它们如何帮助我在 Kaggle 上获得更好的分数，我的答案是“它们不一定会”。因此，我想更多地谈谈为什么我们要做机器学习。这有什么意义？为了回答这个问题，我想向你展示一些非常重要的东西，即人们主要在商业中如何使用机器学习的例子，因为这是你们大多数人在结束后可能会在某家公司工作。我将向你展示机器学习的应用，这些应用要么基于我自己亲身参与的事情，要么是我知道直接在做这些事情的人，因此这些都不是假设的——这些都是人们正在做的实际事情，我有直接或间接的了解。

两组应用[1:26]

水平应用

几乎每家公司都必须尝试向其客户销售更多产品，因此进行营销。因此，这些框中的每一个都是人们在营销中使用机器学习的一些示例：

让我们举个例子——流失。流失是指试图预测谁会离开的模型。最近在电信领域做了一些流失建模。我们试图弄清楚这家大型手机公司的哪些客户会离开。这本身并不那么有趣。构建一个高度预测性的模型，说 Jeremy Howard 几乎肯定会在下个月离开，可能并不那么有帮助，因为如果我几乎肯定会在下个月离开，你可能无法做任何事情——为了留住我，成本可能太高。

因此，为了理解我们为什么要进行流失建模，我有一个可能对你有帮助的小框架：设计出色的数据产品。几年前我和几位同事一起写了这篇文章，在其中，我描述了我将机器学习模型转化为赚钱的东西的经验。基本技巧是我称之为驱动器方法，这是这四个步骤：

定义目标[3:48]

杠杆[5:04]

数据[7:01]

模型[8:45]

人力资源应用。

在人力资源领域有很多有趣的应用，比如员工流失，这是另一种流失模型，其中发现杰里米·霍华德已经厌倦了讲课，他明天就要离开了。你会怎么做？知道这个事实实际上并不会有帮助。那将会太迟了。你实际上想要一个模型，告诉你什么样的人会离开 USF，结果发现每个去楼下咖啡厅的人都会离开 USF。我猜他们的食物很糟糕或者其他什么原因。或者我们支付不到 50 万美元一年的人都会离开 USF，因为他们无法负担旧金山的基本住房。因此，你可以使用员工流失模型，不是为了知道哪些员工讨厌我们，而是为什么员工离开。再次强调，真正重要的是解释。

问题：对于流失模型，听起来你需要预测两个预测因子——一个是流失，另一个是你需要优化你的利润。那么它是如何工作的[18:30]？是的，确切地说，这就是模拟模型的全部内容。你找出我们试图最大化的目标，即公司的盈利能力。你可以创建一个相当简单的 Excel 模型或其他模型，它说这是收入，这是成本，成本等于我们雇佣的人数乘以他们的工资等。在这个 Excel 模型中，有一些单元格/输入是随机的或不确定的。但我们可以用模型来预测，这就是我要做的，我要说好，我们需要一个预测模型，来预测如果我们改变他们的工资，某人留下的可能性有多大，如果我现在增加他们的工资，明年他们离开的可能性有多大等。因此，你需要一堆不同的模型，然后你可以用简单的商业逻辑将它们绑定在一起，然后进行优化。然后你可以说，如果我给杰里米·霍华德 50 万美元，那可能是一个非常好的主意，如果我付给他更少，那可能就不是了，或者其他什么。你可以找出整体影响。所以我真的很惊讶，为什么这么少的人这样做。但大多数行业中的人用 AUC 或 RMSE 等来衡量他们的模型，这实际上并不是你真正想要的。

更多水平应用…[22:04]

垂直应用[23:29]

其他应用[31:02]

随机森林解释方法[37:17]

基于树方差的置信度

这告诉我们什么？为什么我们对此感兴趣？它是如何计算的？

树的预测方差。通常预测只是平均值，这是树的方差。

在这里填充一个细节，我们通常只取一行/观察结果，然后找出我们对此有多自信（即树中有多少方差）或者我们可以像我们在这里做的那样为不同的组找出答案[39:34]。

我们在这里所做的是看是否有任何我们非常不确定的组（这可能是由于观察很少）。我认为更重要的是当你在操作中使用这个时。比如说你正在做一个信用决策算法。所以我们正在确定 Jeremy 是一个好风险还是一个坏风险。我们应该借给他一百万美元吗。随机森林说“我认为他是一个好风险，但我一点也不自信。” 在这种情况下，我们可能会说好吧，也许我不应该给他一百万美元。而在另一种情况下，如果随机森林说“我认为他是一个好风险，而且我非常确定”，那么我们就更愿意给他一百万美元。而且我是一个非常好的风险。所以请随意给我一百万美元。我之前检查过随机森林——在另一个笔记本中。不在 repo 里 😆

对于我来说，很难给你们直接的经验，因为这种单个观察解释实际上是你需要把它放到前线的那种东西。这不是你在 Kaggle 上可以真正使用的东西，而更像是如果你实际上在发布一些可能会花费很多钱的大决策的算法，你可能不太关心随机森林的平均预测，而更可能是你实际上关心平均值减去几个标准差（即最坏情况的预测）。也许有一个我们不确定的整个组，所以这是基于树方差的置信度。

特征重要性 [42:36]

部分依赖 [50:46]

树解释器

Prince：我认为这更像是特征重要性，但特征重要性是针对完整的随机森林模型，而这个树解释器是针对特定观察的特征重要性。所以让我们说这是关于医院再入院的。如果患者 A 将要再次入院，那么对于该特定患者，哪个特征会产生影响，我们如何改变这种情况。它是从平均预测开始计算，然后看每个特征如何改变该特定患者的行为。

Jeremy：我在微笑，因为这是我很长时间以来听到的最好的技术沟通示例之一，所以思考为什么这么有效是非常有意义的。Prince 所做的是，他尽可能具体地举例说明。人类在理解抽象概念方面要差得多。因此，如果您说“它需要某种特征，然后在该特征的观察中”，而不是医院再入院。因此，我们举了一个具体的例子。他做的另一件非常有效的事情是将类比与我们已经理解的东西联系起来。因此，我们已经理解了数据集中所有行的特征重要性的概念。因此，现在我们将为单个行执行此操作。因此，我真的希望我们从这次经验中学到如何成为有效的技术沟通者。因此，Prince 在使用我们可以利用的所有技巧进行有效的技术沟通方面是一个非常好的榜样。希望您觉得这个解释有用。除了向您展示它是什么样子之外，我没有太多要补充。

使用树解释器，我们挑选出一行：

还记得我们在一开始谈到的置信区间吗（即基于树方差的置信度）？我们说你主要用于一行。所以这也是为一行。就像“为什么这个患者可能会再次入院？”这是我们关于该患者或在这种情况下该拍卖会的所有信息。为什么这个拍卖会这么贵？然后我们调用ti.predict，我们得到价格的预测，偏差（即树的根 - 这只是每个人的平均价格，所以这总是一样的），然后是贡献，即这些事情有多重要：

我们计算的方法是说一开始，平均价格是 10。然后我们根据围栏进行分割。对于那些有这个围栏的人，平均价格是 9.5。然后我们根据制造年份小于 1990 进行分割，对于那些有这个制造年份的人，平均价格是 9.7。然后我们根据米数进行分割，对于这个分支，我们得到了 9.4。

然后我们有一个特定的拍卖会，我们通过树传递它。碰巧它走了最顶层的路径。一行只能通过树有一条路径。所以我们最终到了 9.4。然后我们可以创建一个小表格。当我们逐步进行时，我们从顶部开始，我们从 10 开始 - 这是我们的偏差。我们说围栏导致了从 10 变为 9.5（即-0.5）。制造年份将其从 9.5 变为 9.7（即+0.2），然后米数将其从 9.7 降至 9.4（-0.3）。然后如果我们把所有这些加在一起（10-0.5+0.2-0.3），哎呀，那就是预测。

这让我们来到我们的 Excel 电子表格：

上周，我们使用 Excel 进行了这项工作，因为没有一个很好的 Python 库可以制作瀑布图。所以我们看到我们得到了我们的起点这是偏差，然后我们有我们每个贡献，最后我们得到了我们的总数。现在世界变得更美好了，因为 Chris 为我们创建了一个 Python 瀑布图模块，并将其放在 pip 上。所以我们再也不必使用 Excel 了。我想指出，瀑布图至少在我从事业务以来一直在商业沟通中非常重要 - 大约 25 年了。Python 可能已经有几十年的历史了。但尽管如此，Python 世界中没有人真正想到“你知道，我要制作一个瀑布图”，所以直到两天前它们才存在，也就是说这个世界充满了应该存在但不存在的东西。而且并不一定需要花费很多时间来构建。Chris 花了大约 8 个小时，所以数量相当可观但不过分。现在以后，当人们想要 Python 瀑布图时，他们将最终到达 Chris 的 Github 存储库，并希望找到许多其他美国大学的贡献者，他们使其变得更好。

为了帮助改进 Chris 的 Python 瀑布，您需要知道如何做到这一点。因此，您需要提交一个拉取请求。如果您使用一个叫做hub的东西，那么提交拉取请求将变得非常容易。他们建议您将git别名为hub，因为事实证明，hub 实际上是 git 的一个严格的超集。它让您可以执行git fork，git push和git pull-request，然后您现在已经向 Chris 发送了一个拉取请求。没有 hub，这实际上是一种痛苦，需要像去网站并填写表格之类的事情。因此，这给您没有理由不提交拉取请求。我提到这一点是因为当您面试工作时，我可以向您保证，您正在与之交谈的人将检查您的 github，如果他们看到您有提交经过深思熟虑的拉取请求并被接受到有趣的库，那看起来很棒。这看起来很棒，因为它表明您是一个实际做出贡献的人。它还表明，如果它们被接受，那么您知道如何创建符合人们编码标准、具有适当文档、通过测试和覆盖率等的代码。因此，当人们看着您并说哦，这里是一个有着成功贡献历史的人，接受了开源库的拉取请求，这是您作品集的一个很好的部分。您可以具体引用它。因此，无论是我是构建 Python 瀑布的人，这是我的存储库，还是我是为 Python 瀑布贡献货币数字格式化的人，这是我的拉取请求。每当您在使用任何开源软件时看到某些不正常的东西，这不是问题，而是一个很好的机会，因为您可以修复它并发送拉取请求。所以试一试。第一次有拉取请求被接受时，感觉真的很棒。当然，一个很大的机会是 fastai 库。由于我们的一位学生，我们现在对fastai.structured库的大部分文档字符串都有了，这也是通过拉取请求完成的。

有人对如何计算这些随机森林解释方法或为什么我们可能想要使用它们有任何问题吗？在本周末，您将需要能够从头开始构建所有这些。

问题：只是看着树解释器，我注意到一些值是nan。我明白为什么要保留它们在树中，但nan如何有特征重要性呢？让我把问题传递给你。为什么不呢？换句话说，Pandas 中如何处理nan，因此在树中呢？有人记得，注意这些都是分类变量，Pandas 如何处理分类变量中的nan，fastai 又是如何处理的？Pandas 将它们设置为-1 类别代码，而 fastai 将所有类别代码加一，因此最终变为零。换句话说，记住，当它到达随机森林时，它只是一个数字，只是零。然后我们将其映射回这里的描述。所以问题实际上是为什么随机森林不能在零上分裂？它只是另一个数字。所以它可以是nan，高，中，低= 0，1，2，3。因此，缺失值是通常教得很糟糕的事情之一。通常人们被教导要删除具有缺失值的列或删除具有缺失值的行，或者替换缺失值。这绝不是我们想要的，因为缺失通常是非常非常有趣的。因此，我们实际上从我们的特征重要性中学到，耦合器系统nan是最重要的特征之一。出于某种原因，嗯，我可以猜测，对吧？耦合器系统nan可能意味着这是一种没有耦合器系统的工业设备。现在我不知道是什么类型，但显然是更昂贵的类型。

我参加了一个为大学拨款研究成功而举办的比赛，迄今为止最重要的预测因素是某些字段是否为空[1:15:41]。结果表明，这是数据泄漏，这些字段大多数情况下只在研究拨款被接受后填写。所以这让我赢得了那个 Kaggle 比赛，但实际上并没有对大学有太大帮助。

外推[1:16:16]

交互重要性[1:17:24]

回到现场编码。

因此，为了尝试这个，你几乎肯定想先创建一个合成数据集。就像 y = x1 + x2 + x1*x2 或者其他什么。有一些你知道存在交互效应，有一些你知道不存在交互效应，你想确保最终得到的特征重要性是你期望的。

所以可能第一步是使用树解释器风格的单变量特征重要性。这种方法的一个好处是，你拥有多少数据并不重要。你只需要遍历树来计算特征重要性。所以你应该能够以一种相当快速的方式编写代码，所以即使只用纯 Python 编写，也可能足够快，这取决于你的树的大小。

我们将讨论外推和我想要做的第一件事是创建一个具有简单线性关系的合成数据集。我们将假装它就像一个时间序列。所以我们需要创建一些 x 值。创建这种类型的合成数据的最简单方法是使用linspace，它默认创建 50 个观测值在开始和结束之间均匀分布的数据。

然后我们将创建一个因变量，所以让我们假设 x 和 y 之间存在线性关系，并且让我们添加一点随机性。在低和高之间使用random.uniform，所以我们可以添加-0.2 到 0.2 之间的某个值，例如。

接下来我们需要一个形状，基本上就是你想要这些随机数的维度是什么，显然我们希望它们与x的形状相同。所以我们可以直接说x.shape。

换句话说，(50,)是x.shape。记住，当你看到括号里有逗号的时候，那就是一个只有一个元素的元组。所以这是形状为 50，我们添加了 50 个随机数。现在我们可以绘制这些数值。

好的，这就是我们的数据。当你作为数据科学家工作或在这门课程中做考试时，你需要能够快速地创建一个类似的数据集，将其绘制在图表中而不用考虑太多。正如你所看到的，你不必真的记住太多东西。你只需要知道如何按shift + tab来检查参数的名称，搜索一下，或者尝试找到linspace如果你忘记了它的名字。

所以让我们假设这是我们的数据。我们现在要构建一个随机森林模型，我想要构建一个随机森林模型，让它像一个时间序列一样运行。所以我将左边部分作为训练集。然后将右边部分作为我们的验证或测试集，就像我们在购物或推土机中所做的那样。

我们可以使用与我们在split_vals中使用的完全相同的代码。所以我们可以说：

x_trn, x_val = x[:40], x[40:]

这将数据分为前 40 个和后 10 个。我们可以对 y 做同样的操作。

y_trn, y_val = y[:40], y[40:]

接下来要做的是创建一个随机森林并拟合它，这需要 x 和 y。

m = RandomForestRegressor().fit(x, y)

这实际上会导致错误，原因是它期望 x 是一个矩阵，而不是一个向量，因为它期望 x 有多列数据。

重要的是要知道，只有一列的矩阵和向量不是同一回事。

所以如果我尝试运行这个代码，“预期 2D 数组，实际得到 1D 数组”：

所以我们需要将一维数组转换为二维数组。记住我说过x.shape是(50,)。所以x有一个轴，x 的秩是 1。变量的秩等于它的形状的长度 - 它有多少个轴。我们可以将向量看作是秩为 1 的数组，将矩阵看作是秩为 2 的数组。我很少使用向量和矩阵这样的词，因为它们有点毫无意义 - 它们只是更一般的东西的具体例子，它们都是 N 维张量或 N 维数组。所以 N 维数组可以说是秩为 N 的张量。它们基本上意味着相同的事情。物理学家听到这个会很疯狂，因为对于物理学家来说，张量有一个非常具体的含义，但在机器学习中，我们通常以相同的方式使用它。

那么我们如何将一维数组转换为二维数组。我们可以这样做的方法有几种，但基本上我们是切片。冒号（:）表示给我在那个轴上的所有东西。:, None表示给我第一个轴上的所有东西（这是我们唯一拥有的轴），然后None是一个特殊的索引器，表示在这里添加一个单位轴。所以让我给你看看。

它的形状是(50, 1)，所以它是秩为 2 的。它有两个轴。其中一个是一个非常无聊的轴 - 它是一个长度为一的轴。所以让我们将None移到左边。这是(1, 50)。然后提醒你，原始的是(50,)。

所以你可以看到我可以将None作为一个特殊的索引器放在那里引入一个新的单位轴。x[None, :]有一行和五十列。x[:, None]有五十行和一列 - 这就是我们想要的。在这门课程和深度学习课程中，这种对秩和维度的玩耍将变得越来越重要。所以花很多时间用 None 切片，用其他东西切片，尝试创建三维、四维张量等。我会向你展示两个技巧。

第一个是你永远不需要写,:，因为它总是被假定的。所以这些是完全相同的：

你会在代码中一直看到这样的写法，所以你需要认识到它。

第二个技巧是x[:, None]是在第二维度（或我猜是索引 1 维度）添加一个轴。如果我总是想把它放在最后一个维度怎么办？通常我们的张量在我们不注意的情况下改变维度，因为你从一个单通道图像变成了一个三通道图像，或者你从一个单个图像变成了一个图像的小批量。突然之间，新的维度出现了。所以为了让事情更一般化，我会说...，这意味着你需要多少维度来填充这个。所以在这种情况下（x[…, None].shape），它是完全相同的，但我总是尝试以这种方式写，因为这意味着当我得到更高维度的张量时，它将继续工作。

所以在这种情况下，我想要 50 行和一列，所以我会称之为 x1。现在让我们在这里使用它，这样就是一个二维数组，所以我可以创建我的随机森林。

然后我可以绘制出来，这就是你需要打开大脑的地方，因为今天早上的人们非常快地理解了这一点，这是非常令人印象深刻的。我将绘制y_trn与m.predict(x_trn)。在我开始之前，这会是什么样子？它应该基本上是一样的。我们的预测希望与实际相同。所以这应该落在一条线上，但有一些随机性，所以不会完全相同。

那是容易的。现在让我们做困难的，有趣的那个。那会是什么样子？

想想树的作用，想想右边有一个验证集，左边有一个训练集：

所以想想森林只是一堆树。

Tim: 我猜测由于所有新数据实际上都在原始范围之外，所以它们基本上都是一样的 - 就像一个巨大的群体。

Jeremy: 是的，对。所以忘掉森林，让我们创建一棵树。所以我们可能首先在这里分裂，然后在这里分裂，… 所以我们的最终分裂是最右边的节点。当我们从验证集中取一个时，它会将其通过森林，最终预测最右边的平均值。它无法预测比那更高的任何东西，因为没有更高的东西可以平均。

因此，要意识到随机森林并不是魔法。它只是返回附近观察值的平均值，其中附近在这种“树空间”中。所以让我们运行它，看看 Tim 是不是对的。

天啊，太糟糕了。如果你不知道随机森林是如何工作的，那么这将完全搞砸你。如果你认为它实际上能够对任何它以前没有见过的数据进行外推，尤其是未来的时间段，那就错了。它只是无法做到。它只是对它已经看到的东西进行平均。这就是它能做的全部。

好的，我们将讨论如何避免这个问题。在上一课中，我们稍微谈到通过避免不必要的时间相关变量来避免这个问题。但最终，如果你真的有一个看起来像这样的时间序列，我们实际上必须处理一个问题。我们可以处理这个问题的一种方法是使用神经网络。使用一些实际上具有可以拟合这样的函数或形状的东西，这样它将可以很好地外推：

另一种方法是使用你们在早上课上学到的所有时间序列技术来拟合某种时间序列，然后去趋势化。然后你会得到去趋势化的点，然后使用随机森林来预测这些点。这特别酷，因为想象一下你的随机森林实际上试图预测两种不同状态的数据。所以蓝色的在下面，红色的在上面。

如果你尝试使用随机森林，它将做得相当糟糕，因为时间看起来更加重要。所以它基本上仍然会像这样分裂，然后像那样分裂，最终一旦到达左下角，它会像“哦，好吧，现在我可以看到两种状态之间的差异了。”

换句话说，当你有这么大的时间序列时，直到每棵树都处理时间，你才能看到随机森林中的其他关系。因此，解决这个问题的一种方法是使用梯度提升机（GBM）。GBM 的作用是创建一棵小树，然后通过第一棵小树运行所有内容（可能是时间树），然后计算残差，下一棵小树只是预测残差。所以这有点像去趋势化，对吧？GBM 仍然无法对未来进行外推，但至少它们可以更方便地处理时间相关数据。

在接下来的几周里，我们将更多地讨论这个问题，最终的解决方案将是使用神经网络。但是现在，使用某种时间序列分析，去趋势化，然后在随机森林上使用它并不是一种坏技术。如果你在玩类似厄瓜多尔杂货竞赛之类的东西，那将是一个非常好的东西来尝试。

机器学习 1：第 7 课

原文：medium.com/@hiromi_suenaga/machine-learning-1-lesson-7-69c50bc5e9af

译者：飞龙

协议：CC BY-NC-SA 4.0

来自机器学习课程的个人笔记。随着我继续复习课程以“真正”理解它，这些笔记将继续更新和改进。非常感谢 Jeremy 和 Rachel 给了我这个学习的机会。

视频

我们将完成从头开始构建我们自己的随机森林！但在此之前，我想解决一些在这一周中出现的问题。

随机森林在一般情况下的位置

我们大约花了一半的课程时间来讲解随机森林，然后在今天之后，这门课程的第二半将广义地讲解神经网络。这是因为这两者代表了覆盖几乎所有你可能需要做的技术的两个关键类别。随机森林属于决策树集成技术类别，与梯度提升机是另一种关键类型，还有一些变体，比如极端随机树。它们的好处是它们非常易解释，可扩展，灵活，适用于大多数类型的数据。它们的缺点是它们完全不会对超出你所见范围的数据进行外推，就像我们在上周课程结束时看到的那样。但它们是一个很好的起点。我认为有很多机器学习工具的目录，很多课程和书籍并没有试图筛选出来，说对于这些问题，使用这个，对于那些问题，使用那个，完了。但它们更像是这里有 100 种不同算法的描述，而你根本不需要它们。比如，我不明白为什么今天你会使用支持向量机。我想不出任何理由去做那样的事情。人们在 90 年代喜欢研究它们，因为它们在理论上非常优雅，你可以写很多关于支持向量机的数学，人们确实这样做了，但实际上我认为它们没有任何用武之地。

在详尽的列表中，有很多技术可以包括在人们采用机器学习问题的每一种方式中，但我更愿意告诉你如何实际解决机器学习问题。我们即将结束今天的第一堂课，这是一种决策树集成的一种类型，在第二部分，Yanett 将告诉你另一种关键类型，即梯度提升，我们即将启动下一课程，介绍神经网络，其中包括各种广义线性模型（GLM）、岭回归、弹性网络套索、逻辑回归等都是神经网络的变体。

有趣的是，创造随机森林的 Leo Breiman 在他的晚年才做出了这一成就，不幸的是，他在之后不久就去世了。因此，关于随机森林的学术文献很少，部分原因是因为在那个时候支持向量机（SVM）开始流行，其他人没有关注它们。另一个原因是随机森林在理论层面上相当难以理解（在理论上分析它们），很难撰写关于它们的会议论文或学术论文。因此，关于它们的研究并不多。但近年来出现了一股新的经验机器学习浪潮，关注的是什么实际上有效。Kaggle 是其中的一部分，但也有像亚马逊和谷歌这样的公司利用机器学习赚取大量利润。因此，如今很多人都在写关于决策树集成的文章，并为决策树集成创建更好的软件，如 GBM 和 xgboost，以及 R 的 ranger 和 scikit-learn 等等。但很多这方面的工作是在工业界而不是学术界进行的，但这是令人鼓舞的。当然，目前在学术界进行的深度学习工作比决策树集成要多，但两者都在取得很大进展。如果看看今天用于决策树集成的软件包，排名前五或六名的最好的软件包，我不确定其中有哪个在五年前真的存在，也许除了 sklearn 之外，甚至三年前也没有。这是一个好的现象。但我认为还有很多工作要做。比如，上周我们讨论了找出哪些交互作用最重要的问题。你们中一些人在论坛中指出，实际上已经有一个梯度提升机的项目，这很棒，但似乎还没有类似的项目用于随机森林。随机森林相比 GBM 有一个很好的优势，那就是它们更难出错，更容易扩展。因此，希望这个社区可以帮助解决这个问题。

您的验证集大小 [5:42]

回到完成随机森林的部分 18:39

from fastai.imports import *
from fastai.structured import *
from sklearn.ensemble import RandomForestRegressor, RandomForestClassifier
from IPython.display import display
from sklearn import metrics
PATH = "data/bulldozers/"

df_raw = pd.read_feather('tmp/bulldozers-raw')
df_trn, y_trn, nas = proc_df(df_raw, 'SalePrice')
def split_vals(a,n): 
    return a[:n], a[n:]
n_valid = 12000
n_trn = len(df_trn)-n_valid
X_train, X_valid = split_vals(df_trn, n_trn)
y_train, y_valid = split_vals(y_trn, n_trn)
raw_train, raw_valid = split_vals(df_raw, n_trn)
x_sub = X_train[['YearMade', 'MachineHoursCurrentMeter']]

class TreeEnsemble():
  def __init__(self, x, y, n_trees, sample_sz, min_leaf=5):
    np.random.seed(42)
    self.x,self.y,self.sample_sz,self.min_leaf = x,y,sample_sz,min_leaf
    self.trees = [self.create_tree() for i in range(n_trees)]

  def create_tree(self):
    rnd_idxs = np.random.permutation(len(self.y))[:self.sample_sz]
    return DecisionTree(
        self.x.iloc[rnd_idxs], 
        self.y[rnd_idxs],
        min_leaf=self.min_leaf
    )

def predict(self, x):
    return np.mean([t.predict(x) for t in self.trees], axis=0)
class DecisionTree():
    def __init__(self, x, y, idxs=None, min_leaf=5):
        self.x,self.y,self.idxs,self.min_leaf = x,y,idxs,min_leaf
        m = TreeEnsemble(
            X_train, y_train, 
            n_trees=10, 
            sample_sz=1000, 
            min_leaf=3
        )

class DecisionTree():
    def __init__(self, x, y, idxs=None, min_leaf=5):
        if idxs is None: 
            idxs=np.arange(len(y))
        self.x,self.y,self.idxs,self.min_leaf = x,y,idxs,min_leaf
        self.n,self.c = len(idxs), x.shape[1]
        self.val = np.mean(y[idxs])
        self.score = float('inf')
        self.find_varsplit()

 # This just does one decision; we'll make it recursive later
    def find_varsplit(self):
        for i in range(self.c): 
            self.find_better_split(i)

    # We'll write this later!
    def find_better_split(self, var_idx): 
        pass

    @property
    def split_name(self): 
        return self.x.columns[self.var_idx]

    @property
    def split_col(self): 
        return self.x.values[self.idxs,self.var_idx]

    @property
    def is_leaf(self): 
        return self.score == float('inf')

    def __repr__(self):
        s = f'n: {self.n}; val:{self.val}'
        if not self.is_leaf:
            s += f'; score:{self.score}; split:{self.split}; var: {self.split_name}'
        return s

m = TreeEnsemble(
    X_train, y_train, 
    n_trees=10, 
    sample_sz=1000,
    min_leaf=3
)
m.trees[0]
'''
n: 1000; val:10.079014121552744
'''

给定变量找到最佳分割点

让我们尝试编写找到分割点的函数。因此，我们需要实现find_better_split。它将接受一个变量的索引，并找出最佳的分割点，确定它是否比我们目前为止的任何分割更好，对于第一个变量，答案总是肯定的，因为到目前为止最好的分割点是没有分割，这是无穷糟糕的。

所以让我们首先确保我们有东西可以进行比较。我们要进行比较的是 scikit-learn 的随机森林。我们需要确保 scikit-learn 的随机森林获得与我们完全相同的数据，因此我们首先创建集成，从中提取一棵树，然后找出这棵树使用了哪个特定的随机样本x和y，然后将它们存储起来，以便我们可以将它们传递给 scikit-learn（这样我们就有完全相同的信息）。

ens = TreeEnsemble(x_sub, y_train, 1, 1000)
tree = ens.trees[0]
x_samp,y_samp = tree.x, tree.y

所以让我们继续使用 scikit-learn 创建一个随机森林。一个树（n_estimators），一个决策（max_depth），没有自助采样，所以整个数据集。所以这应该与我们即将创建的东西完全相同。让我们试试看。

m = RandomForestRegressor(
    n_estimators=1, 
    max_depth=1,
    bootstrap=False
)
m.fit(x_samp, y_samp)
draw_tree(m.estimators_[0], x_samp, precision=2)

我们需要定义find_better_split函数，并且它需要一个变量。让我们定义我们的x（即自变量），说好，它是树中的所有内容，但只有在这个节点中的那些索引，而在树的顶部是所有内容，只有这一个变量（var_idx）。然后对于我们的y，它就是在这个节点中的索引处的因变量。所以这就是我们的x和y。

让我们现在逐个检查我们独立变量中的每个值。我会告诉你接下来会发生什么。假设我们的独立变量是 YearMade，它不会按顺序排列。所以我们要去到第一行，然后说好，这里的 YearMade 是 3。那么我要做的是尝试计算如果我们决定以数字 3 为分支时的得分。我需要知道哪些行大于 3，哪些行小于或等于 3，它们将成为我的左侧和右侧。然后我们需要一个得分。我们可以使用很多得分，所以在随机森林中，我们称之为信息增益。信息增益就像我们的得分因为我们将数据分成这两组而变得更好了多少。我们可以用很多方法来计算它：基尼系数、交叉熵、均方根误差等等。如果你考虑一下，有一个均方根误差的替代公式，数学上与一个约束尺度内相同，但稍微容易处理一些，那就是我们要找到一个分割点，使得这两组数据的标准差尽可能低。所以我想找到一个分割点，把所有的猫放在这边，所有的狗放在那边。所以如果这些都是猫，那些都是狗，那么这边的标准差为零，那边的标准差也为零。否则，这是一群完全随机混合的猫和狗，那是一群完全随机混合的猫和狗，它们的标准差会高得多。明白了吗？事实证明，如果找到一个最小化这两组标准差或者具体来说是两个标准差的加权平均的分割点，数学上与最小化均方根误差是相同的。如果你想的话，课后你可以自己证明这一点。

首先，我们需要找到，将其分成两组[37:29]。那么所有大于三的东西在哪里？4、6 和 4。所以我们需要它们价格的标准差。

接下来是标准差小于或等于 3，我们只需取这两者的加权平均值，这就是我们的得分。如果我们在 3 上分割，那就是我们的得分。

然后下一步是尝试在 4 上分割，尝试在 1 上分割，尝试在 6 上分割，多余地再次尝试在 4 上分割，然后再次在 1 上分割，找出哪个效果最好。这就是我们的代码：

def find_better_split(self, var_idx):
   x,y = self.x.values[self.idxs,var_idx], self.y[self.idxs] 
   for i in range(1,self.n-1):
      lhs = x<=x[i]
      rhs = x>x[i]
      if rhs.sum()==0: 
          continue
      lhs_std = y[lhs].std()
      rhs_std = y[rhs].std()
      curr_score = lhs_std*lhs.sum() + rhs_std*rhs.sum()
      if curr_score<self.score: 
          self.var_idx,self.score,self.split = var_idx,curr_score,x[i]

我们将逐行进行，假设左侧是x中小于或等于特定值的任何值。右侧是x中大于此特定值的每个值。

lhs 和 rhs 中将包含什么数据类型？它们实际上会包含什么？它们将是布尔数组，我们可以将其视为零和一。因此，lhs 将是一个数组，每次它不小于或等于时为 false；否则为 true，而 rhs 将是相反的布尔数组。现在我们不能对空集合取标准差，所以如果没有任何大于这个数字 (x[i]) 的值，那么 rhs 将全部为 false，这意味着总和为零。在这种情况下，让我们不再继续这一步，因为没有什么可以取标准差，显然这不是一个有用的分割。

假设我们已经走到这一步，现在我们可以计算左侧和右侧的标准差，然后取加权平均值或求和，这两者对于一个标量来说是相同的，因此这就是我们的得分。然后我们可以检查这个得分是否比迄今为止的最佳得分更好，我们迄今为止的最佳得分，最初将其初始化为无穷大，因此最初这是更好的。如果更好，让我们存储所有我们需要的信息：哪个变量找到了这个更好的分割，我们找到的得分是多少，以及我们分割的值是多少。就是这样。如果我们运行这个，并且我正在使用％timeit，它会看这个命令运行需要多长时间，并试图给出一个统计上有效的度量，这样你就可以看到，它已经运行了 10 次以获得平均值，然后又运行了 7 次以获得运行间的平均值和标准差，所以它花了我 76 毫秒加减 11。

%timeit find_better_split(tree,1)
tree
'''
76.6 ms ± 11.8 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
n: 1000; val:10.079014121552744; score:681.0184057251435; split:3744.0; var:MachineHoursCurrentMeter
'''

所以让我们来检查这是否有效。find_better_split(tree, 0)，0 代表YearMade，1 代表MachineHoursCurrentMeter，所以当我们用 1 时，我们得到了MachineHoursCurrentMeter，得分为 681.0184057251435，然后我们再次用零运行，得到了更好的分数（658），并分割了 1974。

find_better_split(tree,0); tree
'''
n: 1000; val:10.079014121552744; score:658.5510186055949; split:1974.0; var:YearMade
'''

所以 1974 年，让我们与上面的 scikit-learn 的随机森林进行比较，是的，这棵树也是这样做的。所以我们确认了这种方法给出了与 sklearn 的随机森林相同的结果。你还可以在这里看到值 10.08 与 sklearn 的根节点的值匹配。所以我们有了一个可以处理一个分割的东西。

问题：为什么我们不在 x 上放一个 unique？因为我还没有尝试优化性能。你可以在 Excel 中看到我检查了这个1两次，4两次，这是不必要的。

好的，Yannet 已经在考虑性能，这是好事。那告诉我这段代码的计算复杂度是多少？

！

O(n²) 是因为有一个循环和 x<=x[i]，我们必须检查每个值，看它是否小于 x[i]。了解如何快速计算计算复杂度是很有用的。我可以保证你做的大多数面试都会要求你即兴计算计算复杂度。而且当你编码时，你希望它成为第二天性。这种技巧基本上是“有循环吗？”如果有，那么显然我们要做这个 n 次，所以涉及到一个 n。循环里面还有循环吗？如果有，那么你需要将它们两个相乘。在这种情况下，没有。循环里面有任何不是常数时间操作的东西吗？所以你可能会看到一个排序在里面，你只需要知道排序是 nlog(n) —— 这应该是第二天性的。如果你看到一个矩阵相乘，你需要知道那是什么。在这种情况下，有一些东西在进行逐元素数组操作，所以要留意任何地方，numpy 在对数组的每个值做一些操作。在这种情况下，它正在检查每个 x 的值是否小于一个常数，所以它将不得不这样做 n 次。所以要将这个扩展成一个计算复杂度，你只需要将循环中的事物数量乘以循环内部的最高计算复杂度，n 次 n 是 n²。

问题：在这种情况下，我们不能只是预先对列表进行排序，然后进行一次nlog(n)的计算吗？有很多事情可以做来加快速度，所以在这个阶段我们只关心的是计算复杂度。但绝对可以。当然，它肯定不是最好的。所以接下来我们要做的就是这个。就像好吧，n²不太好，所以让我们试着让它变得更好。

所以这是我尝试改进的地方。首先，标准差的方程式是什么？

实际上，我们通常不使用那个公式，因为它要求我们多次计算x减去平均值。有谁知道只需要 x 和 x²的公式吗？

www.wolframalpha.com/input/?i=standard+deviation

这是一个非常好的知识点，因为现在你可以计算任何东西的方差或标准偏差。你只需要首先抓取列本身。列的平方。只要你把它们存储在某个地方，你就可以立即计算标准偏差。

所以这对我们有用的原因是，如果我们首先对我们的数据进行排序。然后如果你考虑一下，当我们一步一步地向下走时，每一组都与左边的前一组完全相同，只是多了一件东西，右边则少了一件东西。因此，我们只需要跟踪 x 的总和和 x²的总和，我们只需在左边添加一个东西，x²再添加一个东西，在右边移除一个东西。因此，我们不必每次都遍历整个数据集，因此我们可以将其转化为 O(n)算法。这就是我在这里所做的一切：

tree = TreeEnsemble(x_sub, y_train, 1, 1000).trees[0]
def std_agg(cnt, s1, s2): 
    return math.sqrt((s2/cnt) - (s1/cnt)**2)

def find_better_split_foo(self, var_idx):
  x,y = self.x.values[self.idxs,var_idx], self.y[self.idxs]

  sort_idx = np.argsort(x)
  sort_y,sort_x = y[sort_idx], x[sort_idx]
  rhs_cnt,rhs_sum,rhs_sum2 = self.n, sort_y.sum(), (sort_y**2).sum()
  lhs_cnt,lhs_sum,lhs_sum2 = 0,0.,0.

  for i in range(0,self.n-self.min_leaf-1):
    xi,yi = sort_x[i],sort_y[i]
    lhs_cnt += 1; rhs_cnt -= 1
    lhs_sum += yi; rhs_sum -= yi
    lhs_sum2 += yi**2; rhs_sum2 -= yi**2
    if i<self.min_leaf or xi==sort_x[i+1]:
      continue

    lhs_std = std_agg(lhs_cnt, lhs_sum, lhs_sum2)
    rhs_std = std_agg(rhs_cnt, rhs_sum, rhs_sum2)
    curr_score = lhs_std*lhs_cnt + rhs_std*rhs_cnt
    if curr_score<self.score: 
      self.var_idx,self.score,self.split = var_idx,curr_score,xi

我对数据进行排序，然后我会跟踪右侧的事物数量（rhs_cnt），右侧事物的总和（rhs_sum）和右侧的平方和（rhs_sum2）。最初所有事物都在右侧。因此最初n是计数，y.sum()是右侧的总和，y²（y**2）的总和是右侧的平方和。然后最初左侧没有任何事物，因此为零。然后我们只需要循环遍历每个观察值：

• 左手计数加一，右手计数减一。

• 将值加到左手总和，从右手总和减去。

• 将值的平方加到左手，从右手减去。

现在我们需要小心，因为如果我们说小于或等于一，例如，我们不会停在第一行，而是必须将该组中的所有内容都包括在内。

所以我要做的另一件事是确保下一个值不同于这个值。如果是的话，我会跳过它。所以我只是要再次检查这个值和下一个值不相同（**if** xi==sort_x[i+1]:）。只要它们不相同，我就可以继续前进，通过传入计数、总和和平方和来计算我的标准偏差。那个公式就在那里：

现在我们可以对右侧进行同样的操作，这样我们就可以像之前一样计算加权平均分数，下面的所有行都是一样的。

所以我们把 O(n²)的算法转换成了 O(n)的算法。一般来说，像这样的东西会给你带来比将某些东西推送到 Spark 集群或者更快的 RAM 或者在 CPU 中使用更多核心等更多价值。这是你想要改进你的代码的方式。具体来说，编写代码时不要过多考虑性能。运行它，看看它是否对你的需求足够快。如果是，那么你就完成了。如果不是，进行性能分析。在 Jupyter 中，你可以使用%prun，它会告诉你算法中时间花在哪里。然后你可以去看看实际花费时间的部分，思考它在算法上是否尽可能高效。在这种情况下，我们运行它，从 76 毫秒降到不到 2 毫秒。现在一些新手可能会认为“哦，太好了，我节省了 60 多毫秒”，但关键是这将被运行数千万次。所以 76 毫秒版本太慢了，对于实际使用的任何随机森林来说都是不切实际的。而另一方面，我找到的 1 毫秒版本实际上是相当可接受的。

%timeit find_better_split_foo(tree,1)
tree
'''
2.2 ms ± 148 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
n: 1000; val:10.079014121552744; score:658.5510186055565; split:1974.0; var:YearMade
'''

然后检查，数字应该与之前完全相同，而且确实如此。

find_better_split_foo(tree,0); tree
'''
n: 1000; val:10.079014121552744; score:658.5510186055565; split:1974.0; var:YearMade
'''

现在我们有了一个函数find_better_split，它可以做我们想要的事情，我想把它插入到我的DecisionTree类中。这是一个非常酷的 Python 技巧。Python 可以动态执行所有操作，因此我们实际上可以说DecisionTree中名为find_better_split的方法就是我刚刚创建的那个函数。

DecisionTree.find_better_split = find_better_split_foo

将其放在该类中。现在我告诉你这件事稍微令人困惑的地方是，左边的find_better_split和右边的find_better_split实际上并没有任何关系。它们只是恰好以相同的顺序拥有相同的字母。所以我可以将其命名为find_better_split_foo，然后我可以调用它。现在我的函数实际上被称为find_better_split_foo，但我期望调用的方法是名为 DecisionTree.find_better_split 的东西。所以在这里，我可以说：

DecisionTree.find_better_split = find_better_split_foo

在使用的每种语言中，了解命名空间的工作原理是很重要的。其中最重要的一点是了解它是如何确定名称所指的内容的。所以这里（DecisionTree.find_varsplit）意味着DecisionTree类内部定义的find_better_split，而不是其他地方。右边的这个意味着全局命名空间中的find_better_split_foo。许多语言没有全局命名空间，但 Python 有。因此，即使它们恰好以相同的顺序拥有相同的字母，它们也不以任何方式指向相同的内容。就像这边的家庭可能有一个叫 Jeremy 的人，而我的家庭也有一个叫 Jeremy 的人。我们的名字恰好相同，但我们并不是同一个人。

现在我们已经将find_better_split方法放入了具有这个新定义的DecisionTree中，当我现在调用TreeEnsemble构造函数时，决策树集合构造函数会调用create_tree，create_tree实例化DecisionTree，DecisionTree调用find_varsplit，它会遍历每一列以查看是否可以找到更好的分割点，我们现在已经定义了find_better_split，因此当我们创建TreeEnsemble时，它已经执行了这个分割点。

tree = TreeEnsemble(x_sub, y_train, 1, 1000).trees[0]; tree
'''
n: 1000; val:10.079014121552744; score:658.5510186055565; split:1974.0; var:YearMade
'''

好的。这很不错，对吧？我们一次只做一点点，测试每一步。当你们实现随机森林解释技术时，你们可能想尝试以这种方式编程，检查每一步是否与 scikit-learn 所做的匹配，或者与你们构建的测试匹配。

完整的单棵树[55:13]

m = RandomForestRegressor(
    n_estimators=1, 
    max_depth=2, 
    bootstrap=False
) 
m.fit(x_samp, y_samp) 
draw_tree(m.estimators_[0], x_samp, precision=2)

def find_varsplit(self):
    for i in range(self.c): 
        self.find_better_split(i)
    if self.is_leaf: return
    x = self.split_col
    lhs = np.nonzero(x<=self.split)[0]
    rhs = np.nonzero(x>self.split)[0]
    self.lhs = DecisionTree(self.x, self.y, self.idxs[lhs])
    self.rhs = DecisionTree(self.x, self.y, self.idxs[rhs])

DecisionTree.find_varsplit = find_varsplit

tree = TreeEnsemble(x_sub, y_train, 1, 1000).trees[0]; tree
'''
n: 1000; val:10.079014121552744; score:658.5510186055565; split:1974.0; var:YearMade
'''

tree.lhs
'''
n: 159; val:9.660892662981706; score:76.82696888346362; split:2800.0; var:MachineHoursCurrentMeter
'''

tree.rhs
'''
n: 841; val:10.158064432982941; score:571.4803525045031; split:2005.0; var:YearMade
'''

tree.lhs.lhs
'''
n: 150; val:9.619280538108496; score:71.15906938383463; split:1000.0; var:YearMade
'''

tree.lhs.rhs
'''
n: 9; val:10.354428077535193
'''

预测 [1:01:43]

现在我们有了一个可以构建整个树的东西，我们想要有一个可以计算预测的东西。所以提醒一下，我们已经有了一个可以为TreeEnsemble计算预测的东西（通过调用tree.predict(x)），但在DecisionTree中没有叫做tree.predict的东西，所以我们需要写一个。

为了让这更有趣，让我们开始增加我们使用的列数。

cols = [
    'MachineID', 'YearMade', 'MachineHoursCurrentMeter',
    'ProductSize', 'Enclosure','Coupler_System', 'saleYear'
]

让我们再次创建我们的TreeEnsemble。

%time tree = TreeEnsemble(X_train[cols], y_train, 1, 1000).trees[0]
x_samp,y_samp = tree.x, tree.y
'''
CPU times: user 288 ms, sys: 12 ms, total: 300 ms
Wall time: 297 ms
'''

这一次，让我们将最大深度设为 3。

m = RandomForestRegressor(
    n_estimators=1, 
    max_depth=3, 
    bootstrap=False
)
m.fit(x_samp, y_samp)
draw_tree(m.estimators_[0], x_samp, precision=2, ratio=0.9, size=7)

所以现在我们的树变得更加有趣。现在让我们定义如何为树创建一组预测。因此，树的一组预测就是每一行的预测。就是这样。这就是我们的预测。因此，树的预测是数组中每一行的预测。所以再次，我们跳过思考，思考很困难。所以让我们继续推迟。这个**for** xi **in** x很方便，对吧？请注意，无论数组的秩如何，您都可以使用 numpy 数组中的for blah。无论数组中的轴数是多少。它的作用是遍历主轴。

这些概念在我们进入越来越多的神经网络时将变得非常重要，因为我们将一直在进行张量计算。因此，向量的主轴是向量本身。矩阵的主轴是行。三维张量的主轴是表示切片的矩阵等等。在这种情况下，因为 x 是一个矩阵，这将循环遍历行。如果您以这种方式编写您的张量代码，那么它将很好地推广到更高的维度。在这个 x 中有多少维度并不重要。这将循环遍历每个主轴。因此，我们现在可以称之为 DecisionTree.predict。

def predict(self, x): 
    return np.array([self.predict_row(xi) for xi in x])

所以我需要做的就是编写predict_row。我一直在拖延思考，这很好，实际上我需要做工作的地方，现在基本上是微不足道的。如果我们在叶节点，那么预测值就等于我们在原始树构造函数中计算的那个值（即y的平均值）。如果不是叶节点，那么我们必须弄清楚是沿左路径还是右路径进行预测。因此，如果这一行中的变量（xi[self.var_idx]）小于或等于我们决定拆分的值，则我们沿左路径前进；否则我们沿右路径前进。然后，确定我们想要的路径/树之后，我们只需在其上调用predict_row。再次，我们无意中创建了递归的东西。如果是叶节点，则返回该值；否则根据需要返回左侧或右侧的预测值。

def predict_row(self, xi):
    if self.is_leaf: return self.val
    t = self.lhs if xi[self.var_idx]<=self.split else self.rhs
    return t.predict_row(xi)
DecisionTree.predict_row = predict_row

注意这里的self.lhs **if** xi[self.var_idx]<=self.split **else** self.rhs，这个 if 与上面的 if 没有任何关系：

if something:
    x= do1()
else:
    x= do2()

上面的这个 if 是一个控制流语句，告诉 Python 沿着这条路径或那条路径进行一些计算。下面的这个 if 是一个返回值的运算符。

x = do1() if something else do2()

所以你们做过 C 或 C++的人会认出它与这个是完全相同的（即三元运算符）：

x = something ? do1() : do2()

基本上我们要做的是，我们要得到一个值，如果something为真，我们会说这个值是(do1())，否则是另一个值(do2())。你可以用冗长的方式来写，但那将需要写 4 行代码来做一件事，而且还需要你编写的代码，如果你自己或向别人阅读时，表达方式并不自然。我想说“我要走的树是左边，如果变量小于分割值，否则是右边。所以我想按照我思考或说代码的方式来编写我的代码。因此，这种三元运算符对此非常有帮助。

所以现在我已经对一行进行了预测，我可以将其放入我的类中：

DecisionTree.predict = predict

现在我可以计算预测。

%time preds = tree.predict(X_valid[cols].values)
'''
CPU times: user 156 ms, sys: 4 ms, total: 160 ms
Wall time: 162 ms
'''

现在我可以将我的实际数据与我的预测数据进行对比。当你做散点图时，通常会有很多点重叠在一起，所以一个好的技巧是使用 alpha。Alpha 表示透明度，不仅在 matplotlib 中，在世界上几乎所有的图形包中都是如此。因此，如果将 alpha 设置为小于 1，那么这意味着你需要将 20 个点叠加在一起才能完全显示为蓝色。这是一个很好的方法来看看有多少点重叠在一起 - 散点图的一个好技巧。

plt.scatter(preds, y_valid, alpha=0.05)

这是我的 R²。

metrics.r2_score(preds, y_valid)
'''
0.50371522136882341
'''

那么现在让我们继续进行一个没有最大分裂次数的随机森林，我们的树集合也没有最大分裂次数，我们可以将我们的 R²与他们的 R²进行比较。

m = RandomForestRegressor(
    n_estimators=1, 
    min_samples_leaf=5, 
    bootstrap=False
)
%time m.fit(x_samp, y_samp)
preds = m.predict(X_valid[cols].values)
plt.scatter(preds, y_valid, alpha=0.05)

metrics.r2_score(preds, y_valid)
'''
0.47541053100694797
'''

它们并不相同，但实际上我们的稍微好一点。我不知道我们做了什么不同，但我们会接受它😊 所以现在我们有了一个对于一个只有一棵树的森林，在使用一个真实的实际数据集（推土机的蓝皮书）进行验证时，与 scikit-learn 相比提供了同样好的准确性。

把它放在一起

让我们继续完善这个。现在我想要做的是创建一个包含这段代码的包。我通过创建一个方法，再创建一个方法，然后将它们拼接在一起来创建这个包。现在我回到笔记本中，收集了所有实现方法的单元格，然后将它们全部粘贴在一起。

class TreeEnsemble():
  def __init__(self, x, y, n_trees, sample_sz, min_leaf=5):
    np.random.seed(42)
    self.x,self.y,self.sample_sz,self.min_leaf = x,y,sample_sz,min_leaf
    self.trees = [self.create_tree() for i in range(n_trees)] 
  def create_tree(self):
    idxs = np.random.permutation(len(self.y))[:self.sample_sz]
    return DecisionTree(
        self.x.iloc[idxs], 
        self.y[idxs], 
        idxs=np.array(range(self.sample_sz)), 
        min_leaf=self.min_leaf
    )

  def predict(self, x):
    return np.mean([t.predict(x) for t in self.trees], axis=0)def std_agg(cnt, s1, s2): return math.sqrt((s2/cnt) - (s1/cnt)**2)class DecisionTree():
  def __init__(self, x, y, idxs, min_leaf=5):
    self.x,self.y,self.idxs,self.min_leaf = x,y,idxs,min_leaf
    self.n,self.c = len(idxs), x.shape[1]
    self.val = np.mean(y[idxs])
    self.score = float('inf')
    self.find_varsplit()

  def find_varsplit(self):
    for i in range(self.c): self.find_better_split(i)
    if self.score == float('inf'): return
    x = self.split_col
    lhs = np.nonzero(x<=self.split)[0]
    rhs = np.nonzero(x>self.split)[0]
    self.lhs = DecisionTree(self.x, self.y, self.idxs[lhs])
    self.rhs = DecisionTree(self.x, self.y, self.idxs[rhs]) def find_better_split(self, var_idx):
    x,y = self.x.values[self.idxs,var_idx], self.y[self.idxs]
    sort_idx = np.argsort(x)
    sort_y,sort_x = y[sort_idx], x[sort_idx]
    rhs_cnt,rhs_sum,rhs_sum2 = self.n,sort_y.sum(),(sort_y**2).sum()
    lhs_cnt,lhs_sum,lhs_sum2 = 0,0.,0. for i in range(0,self.n-self.min_leaf-1):
      xi,yi = sort_x[i],sort_y[i]
      lhs_cnt += 1; rhs_cnt -= 1
      lhs_sum += yi; rhs_sum -= yi
      lhs_sum2 += yi**2; rhs_sum2 -= yi**2
      if i<self.min_leaf or xi==sort_x[i+1]:
       continue lhs_std = std_agg(lhs_cnt, lhs_sum, lhs_sum2)
      rhs_std = std_agg(rhs_cnt, rhs_sum, rhs_sum2)
      curr_score = lhs_std*lhs_cnt + rhs_std*rhs_cnt
      if curr_score<self.score: 
       self.var_idx,self.score,self.split = var_idx,curr_score,xi @property
  def split_name(self): return self.x.columns[self.var_idx]

  @property
  def split_col(self): return self.x.values[self.idxs,self.var_idx] @property
  def is_leaf(self): return self.score == float('inf')

  def __repr__(self):
    s = f'n: **{self.n}**; val:**{self.val}**'
    if not self.is_leaf:
      s += f'; score:**{self.score}**; split:**{self.split}**; var:
           **{self.split_name}**'
    return s def predict(self, x):
    return np.array([self.predict_row(xi) for xi in x]) def predict_row(self, xi):
    if self.is_leaf: return self.val
    t = self.lhs if xi[self.var_idx]<=self.split else self.rhs
    return t.predict_row(xi)

就是这样。这就是我们一起编写的代码。

ens = TreeEnsemble(X_train[cols], y_train, 5, 1000)
preds = ens.predict(X_valid[cols].values)
plt.scatter(y_valid, preds, alpha=0.1, s=6);

metrics.r2_score(y_valid, preds)
'''
0.71011741571071241
'''

这里我们有一个蓝色推土机的模型，使用了我们完全从头开始编写的随机森林，R²为 71。这很酷。

性能和 Cython

当我尝试比较这个与 scikit-learn 的性能时，这个要慢得多，原因是虽然很多工作是由 numpy 完成的，numpy 是优化良好的 C 代码，但想想树的最底层。如果我们有一百万个数据点，树的底层有大约 500,000 个决策点，底下有一百万个叶子。这就像调用了 500,000 个分割方法，其中包含多次调用 numpy，而 numpy 只有一个要计算的项目。这是非常低效的。这是 Python 在性能方面特别不擅长的事情（即多次调用大量函数）。我们可以看到它并不差。对于 15 年前被认为是相当大的随机森林来说，这被认为是相当不错的性能。但是现在，这至少比应该的速度慢了几百倍。

scikit-learn 的开发人员为了避免这个问题所做的是，他们使用了一种叫做 Cython 的东西来实现。Cython 是 Python 的一个超集。所以你写的任何 Python 代码基本上都可以作为 Cython 来使用。但是 Cython 运行方式有所不同。它不是直接传递给 Python 解释器，而是将其转换为 C 语言，编译，然后运行该 C 代码。这意味着，第一次运行时会花费一些时间，因为需要进行翻译和编译，但之后运行会快得多。所以我想快速向你展示一下这是什么样子，因为你肯定会遇到 Cython 可以帮助你工作的情况，而你大部分一起工作的人可能从未使用过它（甚至可能不知道它的存在），所以拥有这种超能力是非常棒的。

在笔记本中使用 Cython，你可以这样说：

%load_ext Cython

这里是一个 Python 函数fib1：

def fib1(n):
    a, b = 0, 1
    while b < n:
        a, b = b, a + b

这里是一个 Cython 函数。它与顶部的%%cython完全相同。实际上，它的运行速度大约是fib1的两倍，因为它进行了编译。

%%cython
def fib2(n):
    a, b = 0, 1
    while b < n:
        a, b = b, a + b

这里是同样的版本，我使用了一个特殊的 Cython 扩展叫做cdef，它定义了返回值和每个变量的 C 数据类型。基本上这就是你可以用来开始加快运行速度的技巧。在那一点上，现在它知道它不只是一个名为 T 的 Python 对象。所以 fib3，它和之前完全一样，但我们说我们传递给它的东西的数据类型是什么，然后定义每个变量的数据类型。

%%cython
def fib3(int n):
    cdef int b = 1
    cdef int a = 0
    cdef int t = 0
    while b < n:
        t = a
        a = b
        b = a + b

所以如果我们这样做，现在我们有了一个快 10 倍的东西。

%timeit fib1(50)
'''
705 ns ± 62.5 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
'''
%timeit fib2(50)
'''
362 ns ± 26.5 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
'''
%timeit fib3(50)
'''
70.7 ns ± 4.07 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
'''

这并不需要太多额外的工作，只是用一点 Python 和一些标记，所以知道它的存在是很好的，因为如果有一些定制的东西你想要做，实际上要去 C 语言编译并链接回来是很痛苦的。而在这里做起来相当容易。

问题：当你在使用 Cython 版本时，对于 numpy 数组，是否有特定的 C 类型[1:17:16]？是的，有很多特定的内容用于将 Cython 与 numpy 集成，有一个完整的页面介绍了这些内容。所以我们不用担心过多细节，但你可以阅读那个页面，基本上可以了解基本思想。

使用 NumPy 与 Cython — Cython 0.29a0 文档

cython.readthedocs.io

有这个cimport，基本上是将某种类型的 Python 库导入到代码的 C 部分，然后你可以在 Cython 中使用它。这很简单直接。

所以你现在的任务是实现：

• 基于树方差的置信度

• 特征重要性

• 部分依赖

• 树解释器

对于那个随机森林。删除冗余特征根本不使用随机森林，所以你不必担心这个。外推不是一种解释技术，所以你也不必担心这个。所以只是其他的。所以基于树方差的置信度，我们已经编写了那段代码，所以我怀疑我们在笔记本中拥有的完全相同的代码应该继续工作。所以你可以尝试确保让它工作。特征重要性是通过变量洗牌技术实现的，一旦你让它工作，偏依赖只是几行代码之遥，因为你不是洗牌一列，而是用一个常数值替换它。几乎是相同的代码。

然后树解释器，这将需要您编写一些代码并思考。一旦您编写了树解释器，如果您愿意，您就非常接近创建特征重要性的第二种方法 - 即在所有行中累加重要性的方法。这意味着，您将非常接近进行交互重要性。事实证明，xgboost 实际上有一个非常好的交互重要性库，但似乎没有一个适用于随机森林，因此您可以从使其在我们的版本上运行开始（如果您想进行交互重要性），然后您可以使其在原始的 scikit-learn 版本上运行，这将是一个很酷的贡献。有时，针对自己的实现编写代码更好，因为您可以清楚地看到发生了什么。

如果在任何时候遇到困难，请在论坛上提问。关于如何寻求帮助的整个页面都在维基上有。当你在 Slack 上向同事寻求帮助，当你在 Github 或 Discourse 上向技术社区的人寻求帮助时，正确地寻求帮助将有助于让人们愿意帮助你并能够帮助你。

• 搜索你遇到的错误，看看是否已经有人问过。

• 你已经尝试过如何修复它了吗？

• 你认为出了什么问题？

• 你用的是什么样的电脑？它是如何设置的？软件版本是什么？

• 你确切地输入了什么，确切地发生了什么？

你可以通过截屏来做到这一点，所以确保你有一些非常容易使用的截屏软件。所以如果我要截屏，我只需按下一个按钮，选择区域，复制到剪贴板，转到论坛，粘贴进去，然后就完成了（你甚至可以将图像缩小！）。

更好的做法是，如果有几行代码和错误消息需要查看，可以创建一个 Gist。Gist 是一个很方便的 Github 工具，基本上可以让你分享代码。如果我想要创建一个这样的 Gist，我实际上有一个扩展：

点击那个，给它起个名字，然后点击“公开”。这样就可以将我的 Jupyter 笔记本公开分享。然后我可以复制那个 URL，复制链接位置，然后粘贴到我的论坛帖子中。然后当人们点击它时，他们会立即看到我的笔记本。

现在，这个特定的按钮是一个扩展，所以在 Jupyter 上，您需要点击 Nbextensions，然后点击 Gist-it。当您在那里时，您还应该点击 Collapsible Headings，这是我使用的一个方便的功能，让我可以折叠和展开内容。

如果您打开 Jupyter 时没有看到这个 Nbextensions 按钮，那么只需搜索 Jupyter Nbextensions — 它会告诉您如何使用 pip 安装并设置它。

神经网络广义定义 [1:23:20]