机器学习 1：第 11 课

原文：medium.com/@hiromi_suenaga/machine-learning-1-lesson-11-7564c3c18bbb

译者：飞龙

协议：CC BY-NC-SA 4.0

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

使用 SGD 优化多层函数的回顾[0:00]

NLP 的朴素贝叶斯和逻辑回归回顾[9:53]

交叉熵[16:34]

if y == 1: 
    return -log(ŷ)
else: 
    return -log(1-ŷ)

更多的 n-grams 特征 [21:41]

veczr =  CountVectorizer(
    ngram_range=(1,3), 
    tokenizer=tokenize, 
    max_features=800000
)
trn_term_doc = veczr.fit_transform(trn)
val_term_doc = veczr.transform(val)
trn_term_doc.shape
'''
(25000, 800000)
'''
vocab = veczr.get_feature_names()
vocab[200000:200005]
'''
['by vast', 'by vengeance', 'by vengeance .', 'by vera', 'by vera miles']
'''

y=trn_y
x=trn_term_doc.sign()
val_x = val_term_doc.sign()
p = x[y==1].sum(0)+1
q = x[y==0].sum(0)+1
r = np.log((p/p.sum())/(q/q.sum()))
b = np.log(len(p)/len(q))

m = LogisticRegression(C=0.1, dual=True)
m.fit(x, y);

preds = m.predict(val_x)
(preds.T==val_y).mean()
'''
0.90500000000000003
'''

回到朴素贝叶斯 [22:54]

r.shape, r
'''
((1, 800000),
matrix([[-0.05468, -0.161  , -0.24784, ...,  1.09861, -0.69315, -0.69315]]))
'''

np.exp(r)
'''
matrix([[ 0.94678,  0.85129,  0.78049, ...,  3\.  ,  0.5 ,  0.5  ]])\
'''

x_nb = x.multiply(r)
m = LogisticRegression(dual=True, C=0.1)
m.fit(x_nb, y);

val_x_nb = val_x.multiply(r)
preds = m.predict(val_x_nb)
(preds.T==val_y).mean()
'''
0.91768000000000005
'''

基线和二元组：简单、良好的情感和主题分类

论文

这种技术最初是在 2012 年提出的。Chris Manning 是斯坦福大学出色的自然语言处理研究人员，而 Sida Wang 我不认识，但我认为他很棒，因为他的论文很棒。他们基本上提出了这个想法。他们所做的是将其与其他方法在其他数据集上进行比较。其中一件事是他们尝试了 IMDB 数据集。这里是大二元组上的朴素贝叶斯 SVM：

正如你所看到的，这种方法胜过了他们研究的其他基于线性的方法，以及他们研究的一些受限玻尔兹曼机的神经网络方法。如今，有更好的方法来做这个，事实上在深度学习课程中，我们展示了我们在 Fast AI 刚刚开发的最新成果，可以达到 94%以上的准确率。但是特别是对于一种简单、快速、直观的线性技术来说，这还是相当不错的。你会注意到，当他们这样做时，他们只使用了二元组。我猜这是因为我看了他们的代码，发现它相当慢且难看。我找到了一种更优化的方法，正如你所看到的，所以我们能够使用三元组，因此我们得到了更好的结果，我们的准确率是 91.8%，而不是 91.2%，但除此之外，它是相同的。哦，他们还使用了支持向量机，在这种情况下几乎与逻辑回归相同，所以有一些细微的差异。所以我认为这是一个相当酷的结果。

我要提一下，在课堂上你看到的是我经过多周甚至多个月的研究得出的结果。所以我不希望你认为这些东西是显而易见的。完全不是。就像阅读这篇论文，论文中没有描述为什么他们使用这个模型，它与其他模型有何不同，为什么他们认为它有效。我花了一两周的时间才意识到它在数学上等同于普通的逻辑回归，然后又花了几周的时间才意识到区别实际上在于正则化。这有点像机器学习，我相信你从你参加的 Kaggle 竞赛中已经注意到了。就像你提出了一千个好主意，其中 999 个无论你有多么自信它们会很棒，最终都会变成垃圾。然后最终在四周后，其中一个终于奏效，给了你继续度过另外四周的痛苦和挫折的热情。这是正常的。而且我可以确定，我所认识的机器学习领域最优秀的从业者都有一个共同的特点，那就是他们非常顽强，也被称为固执和执着，这绝对是我似乎拥有的声誉，可能是公平的，还有另一点，他们都是非常擅长编码的。他们非常擅长将他们的想法转化为新的代码。对我来说，几个月前通过这个工作是一个非常有趣的经历，试图至少弄清楚为什么这个当时的最新成果存在。

更好的版本：NBSVM++ [43:31]

所以一旦我弄清楚了，我实际上能够在此基础上进行改进，并且我会向你展示我做了什么。这就是我非常幸运能够使用 PyTorch 的原因，因为我能够创建出我想要的定制化内容，并且通过使用 GPU 也非常快速。这就是 Fast AI 版本的 NBSVM。实际上，我的朋友 Stephen Merity 是一位在自然语言处理领域出色的研究人员，他将其命名为 NBSVM++，我觉得这很可爱，所以这就是，尽管没有 SVM，但是它是一个逻辑回归，但正如我所说，几乎完全相同。

所以首先让我向你展示代码。一旦我弄清楚这是我能想到的最好的线性词袋模型的方法，我将其嵌入到 Fast AI 中，这样你只需写几行代码就可以了。

sl=2000
# Here is how we get a model from a bag of words
md = TextClassifierData.from_bow(
    trn_term_doc, 
    trn_y, 
    val_term_doc,
    val_y, sl
)

所以代码基本上是，嘿，我想为文本分类创建一个数据类，我想从词袋（from_bow）中创建它。这是我的词袋（trn_term_doc），这是我们的标签（trn_y），这是验证集的相同内容，并且每个评论最多使用 2000 个独特的单词，这已经足够了。

然后从那个模型数据中，构建一个学习器，这是 Fast AI 对基于朴素贝叶斯点积的模型的泛化，然后拟合该模型。

learner = md.dotprod_nb_learner()
learner.fit(0.02, 1, wds=1e-6, cycle_len=1)
'''
[ 0\.       0.0251   0.12003  0.91552]
'''
learner.fit(0.02, 2, wds=1e-6, cycle_len=1)
'''
[ 0\.       0.02014  0.11387  0.92012]                         
[ 1\.       0.01275  0.11149  0.92124]
'''
learner.fit(0.02, 2, wds=1e-6, cycle_len=1)
'''
[ 0\.       0.01681  0.11089  0.92129]                           
[ 1\.       0.00949  0.10951  0.92223]
'''

经过 5 个时代，我的准确率已经达到了 92.2。所以现在已经远远超过了线性基准（在原始论文中）。所以让我给你展示一下那段代码。

所以代码非常简短。就是这样。这看起来也非常熟悉。这里有一些小调整，假装这个写着Embedding的东西实际上写着Linear。我马上会展示给你看 embedding。所以我们基本上有一个线性层，特征的数量作为行，记住，sklearn 特征意味着基本上是单词的数量。然后对于每个单词，我们将创建一个权重，这是有道理的——逻辑回归，每个单词有一个权重。然后我们将它乘以r值，所以每个单词，我们有一个r值每个类。所以我实际上做了这个，这样可以处理不仅仅是正面和负面，还可以找出是哪个作者创作了这个作品——例如可能有五六个作者。

基本上我们使用这些线性层来得到权重和r的值，然后我们取权重乘以r，然后相加。所以这只是一个简单的点积，就像我们为任何逻辑回归所做的那样，然后进行 softmax。我们为了获得更好的结果所做的非常小的调整是这个+self.w_adj：

我添加的东西是，这是一个参数，但我几乎总是使用这个默认值 0.4。那么这是做什么的呢？这再次改变了先验。如果你考虑一下，即使我们将这个r乘以文档矩阵作为它们的自变量，你真的想从一个问题开始，好的，惩罚项仍然在将w推向零。

那么w为零意味着什么？如果我们的系数都是 0 会怎么样？

当我们将这个矩阵与这些系数相乘时，我们仍然得到零。所以权重为零最终会说“我对这个事情是正面还是负面没有意见。”另一方面，如果它们都是 1，那么基本上就是说我的意见是朴素贝叶斯系数是完全正确的。所以我说零几乎肯定不是正确的先验。我们不应该真的说如果没有系数，那就意味着忽略朴素贝叶斯系数。1 可能太高了，因为我们实际上认为朴素贝叶斯只是答案的一部分。所以我尝试了几个不同的数据集，基本上是说取这些权重并加上一些常数。所以零在这种情况下会变成 0.4。换句话说，正则化惩罚将权重推向这个值而不是零。我发现在许多数据集中，0.4 效果非常好且非常稳健。再次，基本思想是在使用简单模型从数据中学习的同时，尽可能地融入我们的先验知识。所以结果是，当你说让权重矩阵的零实际上意味着你应该使用大约一半的r值时，这比权重应该全部为零的先验效果更好。

问题：w是表示所需正则化量的点吗？w是权重。所以x = ((w+self.w_adj)*r/self.r_adj).sum(1)正在计算我们的激活。我们计算我们的激活等于权重乘以r，然后求和。所以这只是我们的正常线性函数。被惩罚的是我的权重矩阵。这就是受到惩罚的地方。所以通过说，嘿，你知道，不要只使用w —— 使用w+0.4。0.4（即self.w_adj）不受惩罚。它不是权重矩阵的一部分。因此，权重矩阵实际上免费获得了 0.4。

问题：通过这样做，即使经过正则化，每个特征都会获得一些形式的最小权重吗？不一定，因为它最终可能会为一个特征选择一个系数为-0.4，这将表示“你知道，即使朴素贝叶斯说对于这个特征r应该是什么，我认为你应该完全忽略它”。

休息期间有几个问题。第一个是关于这里正在发生的事情的总结：

这里有w加上权重调整乘以r：

所以通常，我们所做的是说逻辑回归基本上是wx（我将忽略偏差）。然后我们将其更改为rx·w。然后我们说让我们先做x·w这部分。这里的这个东西，我实际上称之为 w，这可能很糟糕，实际上是w乘以x：

所以，我没有r(x·w)，我有w·x加上一个常数乘以r。所以这里的关键思想是正则化希望权重为零，因为它试图减少Σw²。所以我们所说的是，好吧，我们希望将权重推向零，因为这是我们的默认起点期望。所以我们希望处于这样一种情况，即如果权重为零，那么我们有一个对我们来说在理论上或直观上有意义的模型。这个模型（r(x·w)），如果权重为零，对我们来说没有直观意义。因为它在说，嘿，将所有东西乘以零会消除一切。我们实际上在说“不，我们实际上认为我们的r是有用的，我们实际上想保留它。”所以，让我们取(x·w)并加上 0.4。所以现在，如果正则化器将权重推向零，那么它将将总和的值推向 0.4。

因此，它将整个模型推向 0.4 倍r。换句话说，如果您将所有权重一起正则化到 0.4 倍r，那么我们的默认起点是说“是的，您知道，让我们使用一点r。这可能是一个好主意。”这就是这个想法。这个想法基本上是当权重为零时会发生什么。您希望那是有意义的，否则正则化权重朝着那个方向移动就不是一个好主意。

第二个问题是关于 n-grams。所以 n-gram 中的 N 可以是 uni，bi，tri，等等。1，2，3，等等个 grams。所以“This movie is good”有四个 unigrams：This，movie，is，good。它有三个 bigrams：This movie，movie is，is good。它有两个 trigrams：This movie is，movie is good。

问题：您介意回到w_adj或0.4的内容吗？我在想这种调整会不会损害模型的可预测性，因为想象一下极端情况，如果不是 0.4，如果是 4,000，那么所有系数基本上会是…？确切地说。因此，我们的先验需要有意义。这就是为什么它被称为 DotProdNB，因此先验是我们认为朴素贝叶斯是一个好的先验的地方。因此，朴素贝叶斯认为r = p/q是一个好的先验，我们不仅认为这是一个好的先验，而且我们认为rx+b是一个好的模型。这就是朴素贝叶斯模型。换句话说，我们期望系数为 1 是一个好的系数，而不是 4,000。具体来说，我们认为零可能不是一个好的系数。但我们也认为也许朴素贝叶斯版本有点过于自信。所以也许 1 有点高。因此，我们相当确定，假设朴素贝叶斯模型是适当的，正确的数字在 0 和 1 之间。

问题继续：但我在想的是只要不是零，您就会将那些应该为零的系数推到非零的地方，并使高系数与零系数之间的差异变小。嗯，但是您看，它们本来就不应该是零。它们应该是r。请记住，这是在我们的前向函数中，所以这是我们正在计算梯度的一部分。所以基本上是说，好吧，您仍然可以将 self.w 设置为您喜欢的任何值。但是正则化器希望它为零。所以我们所说的是，好吧，如果您希望它为零，那么我将尝试使零给出一个合理的答案。

没有人说 0.4 对于每个数据集都是完美的。我尝试了一些不同的数据集，并发现在 0.3 和 0.6 之间有一些最佳值。但我从未发现一个比零更好的数据集，这并不奇怪。我也从未发现一个更好的数据集。因此，这个想法是一个合理的默认值，但这是另一个您可以玩耍的参数，我有点喜欢。这是另一件您可以使用网格搜索或其他方法来找出对您的数据集最佳的东西。实际上，关键在于在这个模型之前的每个模型，据我所知，都隐含地假设它应该为零，因为它们没有这个参数。顺便说一句，我实际上还有第二个参数（r_adj=10），它是我对 r 做的相同的事情，实际上是通过一个参数除以 r，我现在不会太担心，但这是另一个您可以用来调整正则化性质的参数。最终，我是一个实证主义者，而不是一个理论家。我认为这似乎是一个好主意。几乎所有我认为是一个好主意的事情最终都被证明是愚蠢的。这个特定的想法在这个数据集上给出了良好的结果，也在其他一些数据集上给出了良好的结果。

**问题：**我仍然对w + w_adj感到困惑。你提到我们执行w + w_adj是为了不让系数设为零，我们对先验赋予了一些重要性。但你也说过学习的效果可能是w被设为负值，这可能会使w + w_adj为零。所以如果我们允许学习过程确实将系数设为零，那为什么这与只有w不同呢？因为正则化。因为我们通过Σw²对其进行惩罚。换句话说，我们在说，你知道，如果忽略r是最好的选择，那将会花费你（Σw²）。你将不得不将w设为负数。所以只有在这显然是一个好主意的情况下才这样做。除非这显然是一个好主意，否则你应该将其保留在原处。这是唯一的原因。今天我们所做的所有事情基本上都是为了最大化我们从正则化中获得的优势，并且说正则化将我们推向某种默认假设，几乎所有的机器学习文献都假设默认假设是所有事物都是零。我在说的是，从理论上讲这是有道理的，而从经验上讲，事实证明你应该决定你的默认假设是什么，这将给你带来更好的结果。

**问题继续：**那么可以这样说，在某种程度上你是在前往将所有系数设为零的过程中设置了一个额外的障碍，如果确实值得的话，它将能够做到这一点吗？是的，确实如此。所以我会说，没有这个默认障碍，使系数非零是障碍。现在我要说的是，不，障碍是使系数不等于 0.4r。

**问题：**所以这是 w²乘以某个常数的总和。如果常数是，比如说 0.1，那么权重可能不会趋向于零。那么我们可能就不需要权重衰减了？如果常数的值为零，那么就没有正则化。但如果这个值大于零，那么就会有一些惩罚。而且可以推测，我们将其设置为非零是因为我们过拟合了。所以我们想要一些惩罚。所以如果有一些惩罚，那么我的观点是我们应该惩罚那些与我们的先验不同的事物，而不是惩罚那些与零不同的事物。我们的先验是事物应该大致等于r。

嵌入[1:05:17]

罗斯曼竞赛

笔记本

几年前在 Kaggle 上有一个名为 Rossmann 的竞赛，这是一个德国的杂货连锁店，他们要求预测他们商店中商品的销售情况。这包括分类和连续变量的混合。在 Guo/Berkhahn 的这篇论文中，他们描述了他们的第三名作品，这比第一名作品简单得多，但几乎一样好，但简单得多，因为他们利用了这个所谓的实体嵌入的想法。在论文中，他们认为他们发明了这个，实际上早些时候由 Yoshua Bengio 和他的合著者在另一个 Kaggle 竞赛中写过。尽管如此，我觉得 Guo 在描述这个如何在许多其他方面使用上走得更远，所以我们也会谈论这个。

笔记本在深度学习存储库中，因为我们在深度学习课程中讨论了一些深度学习特定方面，在这门课程中，我们主要将讨论特征工程，我们还将讨论这个嵌入的想法。

让我们从数据开始。所以数据是，2015 年 7 月 31 日，第 1 号店开业。他们正在进行促销活动。有学校假期。不是国家假期，他们卖出了 5263 件商品。这是他们提供的关键数据。所以目标显然是在没有销售信息的测试集中预测销售额。他们还告诉你，对于每家商店，它是某种特定类型的，销售某种特定种类的商品，其最近的竞争对手距离一定距离，竞争对手在 2008 年 9 月开业，还有一些关于促销的更多信息，我不知道这意味着什么。就像许多 Kaggle 竞赛一样，他们允许您下载外部数据集，只要您与其他竞争者分享。他们还告诉您每家商店所在的州，因此人们下载了德国不同州的名称，他们为德国每周下载了一些谷歌趋势数据。我不知道他们得到了什么具体的谷歌趋势，但是有的。对于每个日期，他们下载了一堆温度信息。就是这样。

这里一个有趣的见解是，Rossmann 可能在某种程度上犯了一个错误，设计这个比赛是一个可以使用外部数据的比赛。因为实际上，你并不能知道下周的天气或下周的谷歌趋势。但当你参加 Kaggle 比赛时，你并不在乎这些。你只是想赢，所以你会利用一切可以得到的。

数据清理

首先让我们谈谈数据清理。在这个获得第三名的参赛作品中，实际上并没有进行太多的特征工程，特别是按照 Kaggle 的标准，通常每一个细节都很重要。这是一个很好的例子，展示了使用神经网络可以取得多大的成就，这让我想起了昨天我们谈到的索赔预测比赛，获胜者没有进行任何特征工程，完全依赖深度学习。房间里的笑声，我猜，是来自那些在比赛中进行了一点点特征工程的人们😄

顺便提一下，我发现在比赛中努力工作，然后比赛结束了你没有赢得比赛。然后获胜者出来说这就是我赢得比赛的方法。这是你学到最多的时候。有时候这种情况发生在我身上，我会想，哦，我想到了那个，我试过了，然后我回去发现我那里有个 bug，我没有正确测试，然后我意识到，哦，好吧，我真的需要学会以不同的方式测试这个东西。有时候就像，哦，我想到了那个，但我假设它不会起作用，我真的要记住在做任何假设之前检查一切。你知道，有时候就像，哦，我没有想到那个技术，哇，现在我知道它比我刚刚尝试的一切都要好。否则，如果有人说，嘿，你知道这是一个非常好的技术，你会说好的。但是当你花了几个月的时间尝试做某事，然后别人用那个技术做得更好时，那就相当有说服力了。所以这有点困难，我站在你面前说这里有一堆我用过的技术，我赢得了一些 Kaggle 比赛，我得到了一些最先进的结果。但是当这些信息传达给你时，已经是二手信息了。所以尝试一些东西真的很棒。而且尤其是在深度学习课程中，我注意到，我的一些学生尝试了我说的这个技术，他们第二天就进入了 Kaggle 比赛的前十名，他们说，好的，这算是非常有效。Kaggle 比赛有很多原因是有帮助的。但其中一个最好的方式是比赛结束后发生的事情，所以对于现在即将结束的比赛，确保你观看论坛，看看人们在分享解决方案方面分享了什么，如果你想了解更多，可以自由地问问获胜者，嘿，你能告诉我更多关于这个或那个吗。人们通常很乐意解释。然后最好是尝试自己复制一下。这可以变成一个很棒的博客文章或很棒的内核，可以说，某某说他们使用了这个技术，这里是这个技术的一个非常简短的解释，这里是一点代码展示它是如何实现的，这里是结果展示你可以得到相同的结果。这也可以是一个非常有趣的写作。

数据尽可能易于理解总是很好的。因此，在这种情况下，来自 Kaggle 的数据使用各种整数表示假期。我们可以只使用一个布尔值来表示是否是假期。所以只需清理一下：

train.StateHoliday = train.StateHoliday!='0'
test.StateHoliday = test.StateHoliday!='0'

我们有很多不同的表需要将它们全部合并在一起。我有一种用 Pandas 合并事物的标准方法。我只是使用了 Pandas 的合并函数，具体来说我总是进行左连接。左连接是保留左表中的所有行，你有一个关键列，将其与右侧表中的关键列匹配，然后合并那些也存在于右表中的行。

def join_df(left, right, left_on, right_on=None, suffix='_y'):
    if right_on is None: 
        right_on = left_on
    return left.merge(
        right, 
        how='left', 
        left_on=left_on,
        right_on=right_on, 
        suffixes=("", suffix)
    )

我总是进行左连接的关键原因是，在进行连接之后，我总是检查右侧是否有现在为空的内容：

store = join_df(store, store_states, "Store")
len(store[store.State.isnull()])

因为如果是这样，那就意味着我漏掉了一些东西。我没有在这里展示，但我也检查了行数在之前和之后是否有变化。如果有变化，那就意味着右侧表不是唯一的。所以即使我确定某件事是真的，我也总是假设我搞砸了。所以我总是检查。

我可以继续将州名合并到天气中：

weather = join_df(weather, state_names, "file", "StateName")

如果你看一下谷歌趋势表，它有这个周范围，我需要将其转换为日期以便加入它：

在 Pandas 中这样做的好处是，Pandas 让我们可以访问所有的 Python。例如，在系列对象内部，有一个.str属性，可以让你访问所有的字符串处理函数。就像.cat让你访问分类函数一样，.dt让你访问日期时间函数。所以现在我可以拆分该列中的所有内容。

googletrend['Date']=googletrend.week.str.split(' - ',expand=True)[0]
googletrend['State']=googletrend.file.str.split('_', expand=True)[2]
googletrend.loc[googletrend.State=='NI', "State"] = 'HB,NI'

使用这些 Pandas 函数非常重要，因为它们将被向量化，加速，通常通过 SIMD 至少通过 C 代码，以便运行得又快又顺利。

和往常一样，让我们为我们的日期添加日期元数据：

add_datepart(weather, "Date", drop=False)
add_datepart(googletrend, "Date", drop=False)
add_datepart(train, "Date", drop=False)
add_datepart(test, "Date", drop=False)

最后，我们基本上是在对所有这些表进行去规范化。我们将把它们全部放入一个表中。因此，在谷歌趋势表中，它们主要是按州划分的趋势，但也有整个德国的趋势，所以我们将整个德国的趋势放入一个单独的数据框中，以便我们可以加入它：

trend_de = googletrend[googletrend.file == 'Rossmann_DE']

因此，我们将有这个州的谷歌趋势和整个德国的谷歌趋势。

现在我们可以继续为训练集和测试集同时加入。然后检查两者都没有空值。

store = join_df(store, store_states, "Store")
len(store[store.State.isnull()])
'''
0
'''
joined = join_df(train, store, "Store")
joined_test = join_df(test, store, "Store")
len(joined[joined.StoreType.isnull()]),len(joined_test[joined_test.StoreType.isnull()])
'''
(0, 0)
'''
joined = join_df(joined, googletrend, ["State","Year", "Week"])
joined_test = join_df(joined_test, googletrend, ["State","Year", "Week"])
len(joined[joined.trend.isnull()]),len(joined_test[joined_test.trend.isnull()])
'''
(0, 0)
'''
joined = joined.merge(trend_de, 'left', ["Year", "Week"], suffixes=('', '_DE'))
joined_test = joined_test.merge(trend_de, 'left', ["Year", "Week"], suffixes=('', '_DE'))
len(joined[joined.trend_DE.isnull()]),len(joined_test[joined_test.trend_DE.isnull()])
'''
(0, 0)
'''
joined = join_df(joined, weather, ["State","Date"])
joined_test = join_df(joined_test, weather, ["State","Date"])
len(joined[joined.Mean_TemperatureC.isnull()]),len(joined_test[joined_test.Mean_TemperatureC.isnull()])
'''
(0, 0)
'''

我的合并函数，如果有两列是相同的，我将左侧的后缀设置为空，这样它就不会影响名称，右侧设置为_y。

在这种情况下，我不想要任何重复的内容，所以我只是浏览并删除了它们：

for df in (joined, joined_test):
    for c in df.columns:
        if c.endswith('_y'):
            if c in df.columns: 
                df.drop(c, inplace=True, axis=1)
for df in (joined,joined_test):
    df['CompetitionOpenSinceYear'] = \
        df.CompetitionOpenSinceYear.fillna(1900).astype(np.int32)
    df['CompetitionOpenSinceMonth'] = \
        df.CompetitionOpenSinceMonth.fillna(1).astype(np.int32)
    df['Promo2SinceYear'] = \
        df.Promo2SinceYear.fillna(1900).astype(np.int32)
    df['Promo2SinceWeek'] = \
        df.Promo2SinceWeek.fillna(1).astype(np.int32)

这家商店的主要竞争对手自某个日期以来一直开业。因此，我们可以使用 Pandas 的to_datetime，我传入年、月和日。所以这将给我们一个错误，除非它们都有年和月，所以我们将缺失的部分填充为 1900 年和 1 月（见上文）。而我们真正想知道的是这家商店在这个特定记录时已经开业多久了，所以我们可以进行日期相减：

for df in (joined,joined_test):
    df["CompetitionOpenSince"] = \
        pd.to_datetime(dict(
            year=df.CompetitionOpenSinceYear,
            month=df.CompetitionOpenSinceMonth, 
            day=15
        ))
    df["CompetitionDaysOpen"] = \
          df.Date.subtract(df.CompetitionOpenSince).dt.days

现在如果你考虑一下，有时竞争对手的开业时间晚于这一行，所以有时会是负数。而且可能没有意义有负数（即将在 x 天后开业）。现在话虽如此，我绝不会在没有先运行包含它和不包含它的模型的情况下放入这样的东西。因为我们对数据的假设往往是不正确的。在这种情况下，我没有发明任何这些预处理步骤。我写了所有的代码，但它都是基于第三名获奖者的 GitHub 存储库。因此，知道在 Kaggle 竞赛中获得第三名需要做什么，我相当肯定他们会检查每一个这些预处理步骤，并确保它实际上提高了他们的验证集分数。

for df in (joined,joined_test):
    df.loc[df.CompetitionDaysOpen<0, "CompetitionDaysOpen"] = 0
    df.loc[df.CompetitionOpenSinceYear<1990,"CompetitionDaysOpen"]=0

[1:30:44]

因此，我们将创建一个神经网络，其中一些输入是连续的，而另一些是分类的。这意味着在我们的神经网络中，我们基本上会有这种初始权重矩阵。我们将有这个输入特征向量。一些输入将只是普通的连续数字（例如最高温度，到最近商店的公里数），而另一些将被有效地独热编码。但我们实际上不会将其存储为独热编码。我们实际上会将其存储为索引。

因此，神经网络模型需要知道这些列中的哪些应该基本上创建一个嵌入（即哪些应该被视为独热编码），哪些应该直接输入到线性层中。当我们到达那里时，我们将告诉模型哪个是哪个，但实际上我们需要提前考虑哪些我们想要视为分类变量，哪些是连续变量。特别是，我们要将其视为分类的东西，我们不希望创建比我们需要的更多的类别。让我告诉你我的意思。

这次比赛的第三名决定将比赛开放的月数作为一个他们要用作分类变量的东西。为了避免创建比需要的更多的类别，他们将其截断到 24 个月。他们说，超过 24 个月的任何东西，截断到 24 个。因此，这里是比赛开放的唯一值，从零到 24。这意味着将会有一个嵌入矩阵，基本上会有一个嵌入向量，用于尚未开放的事物（0），用于一个月开放的事物（1），依此类推。

for df in (joined,joined_test):
    df["CompetitionMonthsOpen"] = df["CompetitionDaysOpen"]//30
    df.loc[df.CompetitionMonthsOpen>24,"CompetitionMonthsOpen"] = 24
joined.CompetitionMonthsOpen.unique()
'''
array([24,  3, 19,  9,  0, 16, 17,  7, 15, 22, 11, 13,  2, 23, 12,  4, 10,  1, 14, 20,  8, 18,  6, 21,  5]
'''

现在，他们绝对可以将其作为一个连续变量来处理[1:33:14]。他们本可以只是在这里放一个数字，表示开放了多少个月，然后将其视为连续变量，直接输入到初始权重矩阵中。但我发现，显然这些竞争对手也发现了，尽可能地将事物视为分类变量是最好的。这样做的原因是，当你通过一个嵌入矩阵传递一些内容时，意味着每个级别可以被完全不同地处理。例如，在这种情况下，某物是否开放了零个月或一个月是非常不同的。因此，如果你将其作为连续变量输入，神经网络将很难找到具有这种巨大差异的功能形式。这是可能的，因为神经网络可以做任何事情。但如果你不让它变得容易。另一方面，如果你使用嵌入，将其视为分类变量，那么零和一将有完全不同的向量。因此，尤其是在你有足够的数据时，尽可能地将列视为分类变量是一个更好的主意。当我说尽可能时，基本上意味着基数不要太高。因此，如果这是每一行上唯一不同的销售 ID 号码，你不能将其视为分类变量。因为那将是一个巨大的嵌入矩阵，而且每样东西只出现一次，或者是距离最近商店的公里数到小数点后两位，你也不会将其作为分类变量。

这是他们在这次比赛中都使用的经验法则。事实上，如果我们滚动到他们的选择，这是他们的做法：

他们的连续变量是真正连续的东西，比如到竞争对手的公里数，温度等。而其他一切，基本上，他们都视为分类变量。

今天就到这里。下次，我们将结束这个话题。我们将看看如何将这个转化为神经网络，并总结一下。到时见！

机器学习 1：第 12 课

原文：medium.com/@hiromi_suenaga/machine-learning-1-lesson-12-6c2512e005a3

译者：飞龙

协议：CC BY-NC-SA 4.0

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

视频 / 笔记本

我想今天我们可以完成在这个 Rossmann 笔记本中的工作，看一下时间序列预测和结构化数据分析。然后我们可能会对我们学到的一切进行一个小小的复习，因为信不信由你，这就是结尾。关于机器学习没有更多需要知道的东西，只有你将在下个学期和余生中学到的一切。但无论如何，我没有别的要教的了。所以我会做一个小小的复习，然后我们将涵盖课程中最重要的部分，那就是思考如何正确、有效地使用这种技术，以及如何让它对社会产生积极影响的方式。

上次，我们谈到了这样一个想法，当我们试图构建这个 CompetitionMonthsOpen 派生变量时，实际上我们将其截断为不超过 24 个月，我们谈到了原因，因为我们实际上希望将其用作分类变量，因为分类变量，由于嵌入，具有更多的灵活性，神经网络可以如何使用它们。所以这就是我们离开的地方。

for df in (joined,joined_test):
    df["CompetitionMonthsOpen"] = df["CompetitionDaysOpen"]//30
    df.loc[df.CompetitionMonthsOpen>24, "CompetitionMonthsOpen"]= 24
joined.CompetitionMonthsOpen.unique()
'''
array([24,  3, 19,  9,  0, 16, 17,  7, 15, 22, 11, 13,  2, 23, 12,  4, 10,  1, 14, 20,  8, 18,  6, 21,  5])
'''

让我们继续进行下去。因为这个笔记本中发生的事情可能适用于你处理的大多数时间序列数据集。正如我们所讨论的，虽然我们在这里使用了df.apply，但这是在每一行上运行一段 Python 代码，速度非常慢。所以只有在找不到可以一次对整列进行操作的矢量化 pandas 或 numpy 函数时才这样做。但在这种情况下，我找不到一种方法可以在不使用任意 Python 的情况下将年份和周数转换为日期。

还值得记住这个 lambda 函数的概念。每当你尝试将一个函数应用到某个东西的每一行或张量的每个元素时，如果没有已经存在的矢量化版本，你将不得不调用像DataFrame.apply这样的东西，它将运行你传递给每个元素的函数。所以这基本上是函数式编程中的映射，因为很多时候你想要传递给它的函数是你只会使用一次然后丢弃的东西。使用这种 lambda 方法非常常见。所以这个 lambda 是为了告诉df.apply要使用什么而创建的函数。

for df in (joined,joined_test):
    df["Promo2Since"] = pd.to_datetime(df.apply(
        lambda x: Week(x.Promo2SinceYear, x.Promo2SinceWeek).monday(), 
        axis=1
    ).astype(pd.datetime))
    df["Promo2Days"] = df.Date.subtract(df["Promo2Since"]).dt.days

我们也可以用不同的方式来写这个 [3:16]。以下两个单元格是相同的：

一种方法是定义函数（create_promo2since(x)），然后通过名称传递它，另一种方法是使用 lambda 在现场定义函数。所以如果你不熟悉创建和使用 lambda，练习和玩弄df.apply是一个很好的练习方法。

持续时间 [4:32]

def get_elapsed(fld, pre):
    day1 = np.timedelta64(1, 'D')
    last_date = np.datetime64()
    last_store = 0
    res = []

    for s,v,d in zip(
        df.Store.values,
        df[fld].values, 
        df.Date.values
    ):
        if s != last_store:
            last_date = np.datetime64()
            last_store = s
        if v: last_date = d
        res.append(((d-last_date).astype('timedelta64[D]') / day1))
    df[pre+fld] = res

fld = 'SchoolHoliday'
df = df.sort_values(['Store', 'Date'])
get_elapsed(fld, 'After')
df = df.sort_values(['Store', 'Date'], ascending=[True, False])
get_elapsed(fld, 'Before')

使用zip的重要性[9:26]

fld = 'StateHoliday'
df = df.sort_values(['Store', 'Date'])
get_elapsed(fld, 'After')
df = df.sort_values(['Store', 'Date'], ascending=[True, False])
get_elapsed(fld, 'Before')
fld = 'Promo'
df = df.sort_values(['Store', 'Date'])
get_elapsed(fld, 'After')
df = df.sort_values(['Store', 'Date'], ascending=[True, False])
get_elapsed(fld, 'Before')

滚动函数[16:11]

bwd = df[['Store']+columns].sort_index() \
    .groupby("Store").rolling(7, min_periods=1).sum()
fwd = df[['Store']+columns].sort_index(ascending=False) \
    .groupby("Store").rolling(7, min_periods=1).sum()

分类与连续 [21:46]

for v in cat_vars: 
    joined[v] = joined[v].astype('category').cat.as_ordered()

apply_cats(joined_test, joined)

for v in contin_vars:
    joined[v] = joined[v].fillna(0).astype('float32')
    joined_test[v] = joined_test[v].fillna(0).astype('float32')

idxs = get_cv_idxs(n, val_pct=150000/n)
joined_samp = joined.iloc[idxs].set_index("Date")
samp_size = len(joined_samp); samp_size150000

samp_size = n
joined_samp = joined.set_index("Date")

数据标准化

现在我们有了joined_samp，我们可以像以前一样将其传递给 proc_df 来获取因变量以处理缺失值。在这种情况下，我们传递了一个额外的参数do_scale=True。这将减去均值并除以标准差。

df, y, nas, mapper = proc_df(joined_samp, 'Sales', do_scale=True)
yl = np.log(y)

这是因为如果我们的第一层只是一个矩阵乘法。这是我们的权重集。我们的输入大约是 0.001 和另一个是 10⁶，例如，然后我们的权重矩阵已经初始化为 0 到 1 之间的随机数。然后基本上 10⁶的梯度将比 0.001 大 9 个数量级，这对优化不利。因此，通过将所有内容标准化为均值为零标准差为 1 开始，这意味着所有的梯度将在同一种规模上。

我们在随机森林中不需要这样做，因为在随机森林中，我们只关心排序。我们根本不关心值。但是对于线性模型和由线性模型层构建而成的东西，即神经网络，我们非常关心规模。因此，do_scale=True为我们归一化我们的数据。现在，由于它为我们归一化了数据，它会返回一个额外的对象mapper，其中包含了每个连续变量被归一化时的均值和标准差。原因是我们将不得不在测试集上使用相同的均值和标准差，因为我们需要我们的测试集和训练集以完全相同的方式进行缩放；否则它们将具有不同的含义。

因此，确保您的测试集和训练集具有相同的分类编码、相同的缺失值替换和相同的缩放归一化的细节非常重要，因为如果您没有做对，那么您的测试集根本不会起作用。但是如果您按照这些步骤操作，它将正常工作。我们还对因变量取对数，这是因为在这个 Kaggle 竞赛中，评估指标是均方根百分比误差。均方根百分比误差意味着我们根据我们的答案和正确答案之间的比率受到惩罚。我们在 PyTorch 中没有一个叫做均方根百分比误差的损失函数。我们可以编写一个，但更简单的方法是对因变量取对数，因为对数之间的差异与比率相同。因此，通过取对数，我们可以轻松地得到这个效果。

你会注意到 Kaggle 上绝大多数的回归竞赛要么使用均方根百分比误差，要么使用对数的均方根误差作为他们的评估指标。这是因为在现实世界的问题中，大多数时候，我们更关心比率而不是原始差异。因此，如果您正在设计自己的项目，很可能您会考虑使用因变量的对数。

然后我们创建一个验证集，正如我们之前学到的，大多数情况下，如果你的问题涉及时间因素，你的验证集可能应该是最近的时间段，而不是一个随机子集。所以这就是我在这里做的：

val_idx = np.flatnonzero(
    (df.index<=datetime.datetime(2014,9,17)) & 
    (df.index>=datetime.datetime(2014,8,1)))

当我完成建模并找到一个架构、一组超参数、一定数量的 epochs 以及所有能够很好工作的东西时，如果我想让我的模型尽可能好，我会重新在整个数据集上进行训练 — 包括验证集。现在，至少目前为止，Fast AI 假设你有一个验证集，所以我的一种折中方法是将我的验证集设置为只有一个索引，即第一行：

val_idx=[0]

这样所有的代码都能继续运行，但实际上没有真正的验证集。显然，如果你这样做，你需要确保你的最终训练与之前的完全相同，包括相同的超参数、相同数量的 epochs，因为现在你实际上没有一个正确的验证集来进行检查。

问题：我有一个关于之前讨论过的 get_elapsed 函数的问题。在 get_elapsed 函数中，我们试图找出下一个假期还有多少天。所以每年，假期基本上是固定的，比如 7 月 4 日、12 月 25 日都会有假期，几乎没有变化。那么我们不能从以前的年份查找，然后列出今年将要发生的所有假期吗？也许可以。我的意思是，在这种情况下，我猜对于Promo和一些假期会改变，比如复活节，这种方法可以适用于所有情况。而且运行起来也不会花太长时间。如果你的数据集太大，导致运行时间太长，你可以在一年内运行一次，然后以某种方式复制。但在这种情况下，没有必要。我总是把我的时间看得比电脑的时间更重要，所以我尽量保持事情尽可能简单。

创建一个模型

现在我们可以创建我们的模型。要创建我们的模型，我们必须像在 Fast AI 中一样创建一个模型数据对象。所以一个列模型数据对象只是一个代表训练集、验证集和可选测试集的标准列结构化数据的模型数据对象。

md = ColumnarModelData.from_data_frame(
    PATH, val_idx, df, 
    yl.astype(np.float32), 
    cat_flds=cat_vars, 
    bs=128, 
    test_df=df_test
)

我们只需要告诉它哪些变量应该被视为分类变量。然后传入我们的数据框。

对于我们的每个分类变量，这里是它所拥有的类别数量。因此，对于我们的每个嵌入矩阵，这告诉我们该嵌入矩阵中的行数。然后我们定义我们想要的嵌入维度。如果你在进行自然语言处理，那么需要捕捉一个词的含义和使用方式的所有细微差别的维度数量经验性地被发现大约是 600。事实证明，当你使用小于 600 的嵌入矩阵进行自然语言处理模型时，结果不如使用大小为 600 的好。超过 600 后，似乎没有太大的改进。我会说人类语言是我们建模的最复杂的事物之一，所以我不会指望你会遇到许多或任何需要超过 600 维度的嵌入矩阵的分类变量。另一方面，有些事物可能具有相当简单的因果关系。例如，StateHoliday ——也许如果某事是假日，那么在城市中的商店会有一些行为，在乡村中的商店会有一些其他行为，就是这样。也许这是一个相当简单的关系。因此，理想情况下，当你决定使用什么嵌入大小时，你应该利用你对领域的知识来决定关系有多复杂，因此我需要多大的嵌入。实际上，你几乎永远不会知道这一点。你只知道这一点，因为也许别人以前已经做过这方面的研究并找到了答案，就像在自然语言处理中一样。因此，在实践中，你可能需要使用一些经验法则，并尝试一些经验法则后，你可以尝试再高一点，再低一点，看看哪种方法有帮助。所以这有点像实验。

cat_sz=[
    (c, len(joined_samp[c].cat.categories)+1) 
    for c in cat_vars
]
cat_sz
'''
[('Store', 1116),
 ('DayOfWeek', 8),
 ('Year', 4),
 ('Month', 13),
 ('Day', 32),
 ('StateHoliday', 3),
 ('CompetitionMonthsOpen', 26),
 ('Promo2Weeks', 27),
 ('StoreType', 5),
 ('Assortment', 4),
 ('PromoInterval', 4),
 ('CompetitionOpenSinceYear', 24),
 ('Promo2SinceYear', 9),
 ('State', 13),
 ('Week', 53),
 ('Events', 22),
 ('Promo_fw', 7),
 ('Promo_bw', 7),
 ('StateHoliday_fw', 4),
 ('StateHoliday_bw', 4),
 ('SchoolHoliday_fw', 9),
 ('SchoolHoliday_bw', 9)]
'''

这里是我的经验法则。我的经验法则是看看该类别有多少个离散值（即嵌入矩阵中的行数），并使嵌入的维度为该值的一半。所以如果是星期几，第二个，有八行和四列。这里是(c+1)//2 ——列数除以二。但是我说不要超过 50。在这里你可以看到对于商店（第一行），有 116 家商店，只有一个维度为 50。为什么是 50？我不知道。到目前为止似乎效果还不错。你可能会发现你需要一些稍微不同的东西。实际上，对于厄瓜多尔杂货比赛，我还没有真正尝试过调整这个，但我认为我们可能需要一些更大的嵌入大小。但这是可以摆弄的东西。

emb_szs = [(c, min(50, (c+1)//2)) for _,c in cat_sz]
emb_szs
'''
[(1116, 50),
 (8, 4),
 (4, 2),
 (13, 7),
 (32, 16),
 (3, 2),
 (26, 13),
 (27, 14),
 (5, 3),
 (4, 2),
 (4, 2),
 (24, 12),
 (9, 5),
 (13, 7),
 (53, 27),
 (22, 11),
 (7, 4),
 (7, 4),
 (4, 2),
 (4, 2),
 (9, 5),
 (9, 5)]
'''

问题：随着基数大小变得越来越大，您正在创建越来越宽的嵌入矩阵。因此，您是否会因为选择了 70 个参数而极大地增加过拟合的风险，因为模型永远不可能捕捉到数据实际巨大的所有变化[36:44]？这是一个很好的问题，所以让我提醒您一下现代机器学习和旧机器学习之间的区别的黄金法则。在旧的机器学习中，我们通过减少参数数量来控制复杂性。在现代机器学习中，我们通过正则化来控制复杂性。所以简短的答案是不。我不担心过拟合，因为我避免过拟合的方式不是通过减少参数数量，而是通过增加丢弃率或增加权重衰减。现在说到这一点，对于特定的嵌入，没有必要使用比我需要的更多的参数。因为正则化是通过给模型更多的随机数据或实际上对权重进行惩罚来惩罚模型。所以我们宁愿不使用比必要更多的参数。但是在设计架构时，我的一般经验法则是在参数数量方面慷慨一些。在这种情况下，如果经过一些工作后，我们觉得商店实际上似乎并不那么重要。那么我可能会手动去修改它，使其更小。或者如果我真的发现这里的数据不够，我要么过拟合了，要么使用的正则化比我感到舒适的要多，那么您可能会回去。但我总是会从参数慷慨的角度开始。在这种情况下，这个模型表现得相当不错。

好的，现在我们有一个包含每个嵌入矩阵的行数和列数的元组列表[38:41]。所以当我们调用get_learner来创建我们的神经网络时，这是我们传入的第一件事：

• emb_szs: 我们的每个嵌入有多大

• len(df.columns)-len(cat_vars): 我们有多少连续变量

• [1000,500]: 每一层要创建多少个激活

• [0.001,0.01]: 每一层使用的丢弃率是多少

m = md.get_learner(
    emb_szs, 
    len(df.columns)-len(cat_vars),
    0.04, 1, 
    [1000,500], 
    [0.001,0.01], 
    y_range=y_range
)
m.summary()

然后我们可以继续调用fit。我们训练了一段时间，得到了大约 0.1 的分数。

m.fit(lr, 1, metrics=[exp_rmspe])
'''
[ 0\.       0.01456  0.01544  0.1148 ]
'''
m.fit(lr, 3, metrics=[exp_rmspe])
'''
[ 0\.       0.01418  0.02066  0.12765]                           
[ 1\.       0.01081  0.01276  0.11221]                           
[ 2\.       0.00976  0.01233  0.10987]
'''
m.fit(lr, 3, metrics=[exp_rmspe], cycle_len=1)
'''
[ 0\.       0.00801  0.01081  0.09899]                            
[ 1\.       0.00714  0.01083  0.09846]                            
[ 2\.       0.00707  0.01088  0.09878]
'''

所以我尝试在测试集上运行这个，并且上周我把它提交到了 Kaggle，这里是结果[39:25]：

私人分数 0.107，公共分数 0.103。所以让我们看看这将如何进行。让我们从公共排行榜开始：

在 3000 个参赛者中排名第 340。这不太好。让我们试试私人排行榜，排名是 0.107。

哦，第 5 名[40:30]。所以希望您现在在想，哦，有一些 Kaggle 比赛即将结束，我参加了，并且花了很多时间在公共排行榜上取得好成绩。我想知道那是否是个好主意。答案是否定的，那不是。Kaggle 公共排行榜并不是要取代您精心开发的验证集。例如，如果您正在进行冰山比赛（哪些是船只，哪些是冰山），那么他们实际上在公共排行榜中放入了大约 4000 张合成图像，而在私人排行榜中没有放入任何图像。所以这是 Kaggle 测试您的一个非常好的方面，“您是否创建了一个好的验证集并且是否信任它？”因为如果您更信任排行榜的反馈而不是验证反馈，那么当您认为自己排名第 5 时，您可能会发现自己排名第 350。在这种情况下，我们实际上有一个相当不错的验证集，因为正如您所看到的，它大约是 0.1，而我们实际上确实得到了大约 0.1。所以在这种情况下，这个比赛的公共排行榜完全没有用。

问题：那么，公共排行榜的前几名实际上与私人排行榜的前几名有多少对应呢？因为在流失预测挑战中，有 4 个人完全超过了其他人[42:07]。这完全取决于情况。如果他们随机抽取公共和私人排行榜，那么这应该是非常有指示性的。但也可能不是。所以在这种情况下，公共排行榜上的第二名最终赢得了比赛。公共排行榜上的第一名排在第七位。事实上，你可以看到这里的小绿色标记。而另外一个人则跃升了 96 个名次。

如果我们用刚刚看过的神经网络进入，我们将跃升 350 个名次。所以这取决于情况。有时他们会告诉你公共排行榜是随机抽样的。有时他们会告诉你不是。通常你必须通过查看验证集结果和公共排行榜结果之间的相关性来判断它们之间的相关性有多好。有时，如果有 2 或 3 个人远远领先于其他人，他们可能已经发现了某种泄漏或类似的情况。这通常是一种存在某种技巧的迹象。

好的，这就是 Rossmann，这也是我们所有材料的结束。

回顾[44:21]

伦理与数据科学

幻灯片

现在让我们谈谈最重要的部分。我们在这门课程的早期谈到了很多机器学习实际上是有些误导的。人们关注预测准确性，比如亚马逊有一个协同过滤算法用于推荐书籍，最终推荐出它认为你最有可能高评的书。结果他们最终可能会推荐一本你已经有或者你已经知道并且本来就会购买的书，这并没有太大价值。他们应该做的是找出哪本书可以推荐给你，从而改变你的行为。这样，我们实际上最大化了由于推荐而带来的销售增长。所以这种优化影响你的行为与仅仅提高预测准确性之间的区别的想法。提高预测准确性是一个非常重要的区别，在学术界或行业中很少被讨论，令人惊讶。在行业中更多地被讨论，但在大多数学术界中被忽视。所以这是一个非常重要的想法，即最终你的模型的目标，想必是影响行为。所以请记住，我实际上提到了我写的一篇关于这个的论文，在那里我介绍了一种叫做传动系统方法的东西，我谈到了如何将机器学习纳入到我们如何实际影响行为的方式中。这是一个起点，但接下来的问题是，如果我们试图影响行为，我们应该影响什么样的行为，以及如何影响，当我们开始影响行为时可能意味着什么。因为现在很多公司，你最终会在那里工作，都是大公司，你将会构建能够影响数百万人的东西。那意味着什么呢？

实际上我不会告诉你这意味着什么，因为我不知道[1:05:34]。我要做的只是让你意识到一些问题，并让你相信其中两件事：

1. 你应该关心。

2. 这些是重大的当前问题。

我希望你关心的主要原因是因为我希望你想成为一个好人，并向你展示不考虑这些事情会让你成为一个坏人。但如果你不觉得有说服力，我会告诉你这个事实。大众汽车被发现在排放测试中作弊。最终被判刑的人是实施那段代码的程序员。他们只是按照指示去做。所以如果你认为自己只是一个技术人员，只是按照指示去做，那是我的工作。我告诉你，如果你这样做，你可能会因为听从指示而被送进监狱，所以 a)不要只是听从指示，因为你可能会成为一个坏人，b)你可能会被送进监狱。

第二件要意识到的事情是，在当下，你在工作中与二十个人开会，大家都在讨论如何实施这个新功能，每个人都在讨论[1:06:49]。每个人都在说“我们可以这样做，这是一种建模的方式，然后我们可以实施它，这是这些约束条件”，你心里有一部分在想我们是否应该这样做？那不是考虑这个问题的正确时机，因为在那时很难站出来说“对不起，我不确定这是一个好主意”。你实际上需要提前考虑如何处理这种情况。所以我希望你现在考虑这些问题，并意识到当你陷入其中时，你可能甚至意识不到正在发生什么。那只是一个像其他会议一样的会议，一群人在讨论如何解决这个技术问题。你需要能够认识到哦，这实际上是一个具有道德影响的事情。

Rachel 实际上写了所有这些幻灯片。很抱歉她不能在这里展示，因为她对这个问题进行了深入研究。她实际上曾身处困难环境，亲眼目睹这些事情发生，我们知道这是多么困难。但让我给你们一个了解发生的情况。

所以工程师试图解决工程问题并导致问题并不是一件新事。在纳粹德国，IBM，被称为 Hollerith 的集团，Hollerith 是 IBM 的原始名称，它来自于实际发明用于跟踪美国人口普查的打孔卡的人。这是世界上第一次大规模使用打孔卡进行数据收集。这变成了 IBM，所以在这一点上，仍然被称为 Hollerith。因此，Hollerith 向纳粹德国出售了一个打孔卡系统，每张打孔卡都会编码，比如这是犹太人，8，吉普赛人，12，用毒气室处决，6。这里有一张描述如何杀死这些不同人的卡片。因此，一名瑞士法官裁定 IBM 的技术协助促成了纳粹分子的任务，并犯下了反人类罪行。这导致了大约二千万平民的死亡。根据我从犹太虚拟图书馆得到这些图片和引用的观点，他们认为“犹太人民的毁灭变得更不重要，因为 IBM 的技术成就的振奋性质只会因为可以获得的奇幻利润而进一步提高”。这是很久以前的事情，希望你们不会最终在促成种族灭绝的公司工作。但也许你们会。

www.nytimes.com/2017/10/27/world/asia/myanmar-government-facebook-rohingya.html www.nytimes.com/2017/10/24/world/asia/myanmar-rohingya-ethnic-cleansing.html

也许你们会去 Facebook，他们现在正在促成种族灭绝。我认识在 Facebook 工作的人，他们根本不知道他们在做什么。现在，在 Facebook，罗辛亚人正处于缅甸的种族灭绝中，他们是缅甸的一个穆斯林族群。婴儿被从母亲怀中抢走扔进火里，人们被杀害，数以百千计的难民。在接受采访时，进行这些行为的缅甸将军表示，我们非常感谢 Facebook 让我们知道“罗辛亚假新闻”，这些人实际上不是人类，他们实际上是动物。现在，Facebook 并不是要促成缅甸罗辛亚人的种族灭绝，不是。相反，发生的是他们想要最大化印象和点击量。结果是，Facebook 的数据科学家发现，如果你拿人们感兴趣的东西并向他们提供稍微更极端的版本，你实际上会得到更多的印象，项目经理们说要最大化这些印象，人们点击了，这就产生了这种情况。潜在的影响是非常巨大和全球性的。这实际上正在发生。这是 2017 年 10 月。正在发生。

问题：我只是想澄清这里发生了什么。所以这是在促进虚假新闻或不准确的媒体吗？是的，让我详细介绍一下，发生的事情是在 2016 年中期，Facebook 解雇了它的人类编辑。所以是人类决定如何在你的主页上排序的。这些人被解雇，被机器学习算法取代。所以这些机器学习算法是由像你们这样的数据科学家编写的，他们有清晰的指标，他们试图最大化他们的预测准确性，并且像“我们认为如果我们把这个东西放在比这个东西更高的位置，我们会得到更多的点击”。结果表明，这些用于在 Facebook 新闻源上放置内容的算法倾向于说“哦，人类的本性是我们倾向于点击那些刺激我们观点的东西，因此更极端版本的我们已经看到的东西”。这对于最大化参与度的 Facebook 收入模型来说是很好的，它在他们所有的关键绩效指标上看起来都很好。那时，有一些负面新闻，我不确定 Facebook 现在放在他们的热门部分的东西是否真的那么准确，但从人们在 Facebook 优化的指标的角度来看，这看起来很棒。所以回到 2016 年 10 月，人们开始注意到一些严重的问题。

例如，在美国，将住房针对某些种族是非法的。这是非法的，然而一个新闻机构发现 Facebook 在 2016 年 10 月确实在做这件事。再次强调，并不是因为数据科学团队中的某个人说“让黑人不能住在好社区”。而是，他们发现他们的自动聚类和分割算法发现了一群不喜欢非裔美国人的人，如果你用这种广告针对他们，那么他们更有可能选择这种住房或其他什么。但有趣的是，即使被告知了三次，Facebook 仍然没有解决这个问题。这就是说这些不仅仅是技术问题。它们也是经济问题。当你开始说你得到报酬的事情（也就是广告），你必须改变你构建这些方式的方式，这样你要么使用更多花钱的人，要么减少对少数群体或其他基于算法的人的针对性，这可能会影响收入。我提到这个原因是因为在你的职业生涯中，你会在某个时候发现自己在一次对话中，你会想“我不确定这在道德上是否可以接受”，而你正在与之交谈的人在心里想“这会让我们赚很多钱”，你永远不会成功地进行对话，因为你在谈论不同的事情。所以当你与比你更有经验和更资深的人交谈时，他们可能听起来像他们知道他们在谈论什么，只要意识到他们的激励并不一定会集中在如何成为一个好人上。就像他们并不是在想如何成为一个坏人，但在我看来，你在这个行业中花的时间越多，你对这些事情的麻木程度就越高，比如也许得到晋升和赚钱并不是最重要的事情。

例如，我有很多擅长计算机视觉的朋友，其中一些人已经创建了似乎几乎是为了帮助威权政府监视他们的公民而量身定制的初创公司。当我问我的朋友们，你们有没有考虑过这种方式的使用，他们通常会对我提出的问题感到有点冒犯。但我要求你们考虑这个问题。无论你最终在哪里工作，如果你最终创建了一个初创公司，工具可以被用于善良或邪恶。所以我并不是说不要创建优秀的计算机视觉目标跟踪和检测工具，因为你可以继续创建一个更好的外科手术干预机器人工具包。我只是说要意识到这一点，考虑一下，谈论一下。

所以我发现这个很有趣。这实际上是一个很酷的事情，meetup.com 做了。他们考虑到了这一点。他们实际上考虑到了这一点。他们认为你知道，如果我们建立一个像我们在课堂上学到的协同过滤系统来帮助人们决定去哪个 meetup。它可能会注意到在旧金山，比起女性，更多的男性倾向于参加技术 meetup，因此它可能会开始决定向更多男性推荐技术 meetup。结果是更多男性会参加技术 meetup，结果是当女性参加技术 meetup 时，她们会觉得哦，这里都是男性，我真的不想去技术 meetup。结果是算法会得到新的数据，表明男性更喜欢技术 meetup，所以继续下去。因此，算法的这种初步推动可能会产生这种恶性循环。最终，你可能会得到几乎全是男性的技术 meetup。因此，这种反馈循环是一个微妙的问题，当你考虑构建算法时，你真的要考虑到你正在改变的行为是什么。

所以另一个有点可怕的例子是在这篇论文中，作者描述了美国许多部门现在正在使用预测性执法算法。那么我们去哪里找即将犯罪的人。你知道，算法简单地反馈给你基本上你给它的数据。所以如果你的警察局过去曾经进行过种族歧视，那么它可能会稍微更频繁地建议你去黑人社区检查是否有人犯罪。结果是你的警察会更多地去黑人社区，结果是他们逮捕更多黑人，结果是数据显示黑人社区更不安全。结果是算法告诉警察，也许你应该更频繁地去黑人社区，依此类推。

这不像是未来可能发生的模糊可能性。这是来自认真研究数据和理论的顶尖学者的记录工作。这些严肃的学术工作表明，不，这正在发生。再次，我相信开始创建这种预测性执法算法的人并没有想过如何逮捕更多黑人。希望他们在想，天哪，我希望我的孩子在街上更安全，我该如何创造一个更安全的社会。但他们没有考虑到这种恶性循环。

关于社交网络算法的这篇文章实际上是最近《纽约时报》上我一个朋友 Renee Diresta 写的，她做了一些令人惊讶的事情。她建立了一个第二个 Facebook 账号，一个假账号。那时她对反疫苗运动非常感兴趣，所以她开始关注一些反疫苗者，并访问了一些反疫苗链接。突然间，她的新闻动态开始充斥着反疫苗者的新闻，以及其他一些东西，比如化学尾迹和深层国家阴谋论等等。于是她开始点击这些内容，她点击得越多，Facebook 推荐的极端离谱的阴谋论就越多。所以现在当 Renee 去那个 Facebook 账号时，整个页面都充满了愤怒、疯狂、极端的阴谋论内容。这就是她看到的一切。所以如果这是你的世界，那么在你看来，这就像是一个不断提醒和证明所有这些东西的连续。所以再次强调，这种失控的反馈循环最终告诉缅甸将军们，他们的 Facebook 主页上罗兴亚人是动物、假新闻，以及其他一切。

很多这些也来自偏见。所以让我们具体谈谈偏见。图像软件中的偏见来自数据中的偏见。所以我认识的大多数在谷歌大脑构建计算机视觉算法的人，很少有人是有色人种。所以当他们用家人和朋友的照片来训练算法时，他们用的是很少有色人种的照片。所以当 FaceApp 决定我们要尝试查看很多 Instagram 照片，看看哪些被点赞最多时，他们并没有意识到，答案是浅色面孔。所以他们建立了一个生成模型让你看起来更“性感”，这是实际照片，这是更性感的版本。所以更性感的版本更白，鼻孔更少，看起来更欧洲化。这显然不受欢迎。再次强调，我不认为 FaceApp 的任何人会说“让我们创造一些让人看起来更白的东西”。他们只是用周围的人的一堆图像来训练它。这也有严重的商业影响。他们不得不撤回这个功能。他们受到了大量的负面反弹，这是应该的。

这里有另一个例子。谷歌照片创建了这个照片分类器，飞机、摩天大楼、汽车、毕业典礼和大猩猩。所以想想这对大多数人来说是什么样子。对大多数人来说，他们看到这个，他们不了解机器学习，他们会说“搞什么鬼，谷歌的某个人写了一些代码把黑人称为大猩猩”。这就是它看起来的样子。我们知道那不是发生的事情。我们知道发生的是谷歌计算机视觉专家团队中没有或只有少数有色人种的人建立了一个分类器，使用他们可以获得的所有照片，所以当系统遇到皮肤较黑的人时，它会认为“哦，我之前主要只见过大猩猩中的这种情况，所以我会把它放在那个类别中”。再次强调，数据中的偏见会导致软件中的偏见，商业影响也非常显著。谷歌因此受到了很多负面公关影响，这是应该的。有人在他们的 Twitter 上发布了这张照片。他们说看看谷歌照片刚刚决定做的事情。

你可以想象第一届由人工智能评选的国际选美大赛发生了什么。基本上结果是所有美丽的人都是白人。所以你可以看到这种图像软件中的偏见，这要归功于数据中的偏见，也要归功于构建团队缺乏多样性。

在自然语言处理中也可以看到同样的情况。这里是土耳其语。O 是土耳其语中没有性别的代词。没有他和她之分。但当然在英语中，我们并没有一个广泛使用的无性别单数代词，所以谷歌翻译将其转换为这个。现在有很多人在网上看到这个并且字面上说“那又怎样？”它正确地反馈了英语中的通常用法。我知道这是如何训练的，就像 Word2vec 词向量一样，它是在谷歌新闻语料库、谷歌图书语料库上训练的，它只是告诉我们事情是如何的。从某种角度来看，这是完全正确的。用来创建这种有偏见算法的有偏见数据实际上是人们几十年来写书和报纸文章的实际数据。但这是否意味着这是你想要创建的产品？这是否意味着这是你必须创建的产品？仅仅因为你训练模型的特定方式导致它最终做出这样的结果，这真的是你想要的设计吗？你能想到这可能会产生什么负面影响和反馈循环吗？如果这些事情中的任何一件让你感到不安，那么现在，幸运的是，你有一个新的很酷的工程问题要解决。我如何创建无偏见的自然语言处理解决方案？现在有一些初创公司开始做这个，并开始赚钱。所以这对你来说是机会。就像嘿，这里有一些人因为他们糟糕的模型而创造出了扭曲的社会结果。你可以去建立一些更好的东西。Word2vec 词向量中的偏见的另一个例子是餐厅评论中排名较低的墨西哥餐厅，因为“墨西哥”这个词在美国新闻和书籍中更常与犯罪相关的词语联系在一起。同样，这是一个正在发生的真实问题。

Rachel 实际上对普通的 Word2vec 词向量进行了一些有趣的分析。她基本上把它们拿出来，根据一些在其他地方进行的研究来看这些类比。所以你可以看到，Word2vec 向量方向显示父亲对医生就像母亲对护士一样。男人对计算机程序员就像女人对家庭主妇一样，等等。所以很容易看出这些词向量中包含了什么。它们在我们今天使用的几乎所有自然语言处理软件中都是基础的。

这里有一个很好的例子。ProPublica 实际上在这个领域做了很多有益的工作。现在许多法官都可以访问判决指南软件。因此，判决指南软件告诉法官对于这个个体，我们建议这种类型的刑罚。当然，法官不懂机器学习，所以他们有两个选择，要么按照软件的建议行事，要么完全忽视它，有些人属于每个类别。对于那些属于按照软件建议行事的人，这里是发生的事情。对于那些被标记为高风险的人，实际上没有再次犯罪的人中，白人约四分之一，非裔美国人约一半。所以，那些没有再次犯罪的人中，如果是非裔美国人，他们被标记为高风险的情况几乎是白人的两倍。而那些被标记为低风险但实际上再次犯罪的人中，白人约一半，非裔美国人只有 28%。所以这是数据，我希望没有人会刻意创造这样的情况。但是当你从有偏见的数据开始，数据显示白人和黑人吸食大麻的比率大致相同，但黑人被监禁的频率大约是白人的 5 倍，美国的司法系统的性质，至少目前来看，是不平等的，不公平的。因此，输入到机器学习模型中的数据基本上会支持这种现状。然后由于负面反馈循环，情况只会变得越来越糟。

现在我要告诉你关于这个有趣的事情，研究员阿贝·龚指出了一些问题。以下是一些正在被问到的问题。所以让我们来看一个。你的父亲是否曾被逮捕过？你对这个问题的回答将决定你是否被关押以及关押多久。现在作为一个机器学习研究员，你认为这可能会提高你算法的预测准确性并获得更好的 R²。可能会，但我不知道。也许会。你试试看，哦，我有了更好的 R²。那么这意味着你应该使用它吗？还有另一个问题。你认为因为一个人的父亲是谁而把他关押更长时间是合理的吗？然而，这些实际上是我们现在问罪犯的问题的例子，然后将其放入一个机器学习系统中来决定他们的命运。再次，设计这个的人可能他们是专注于技术卓越，获得 ROC 曲线下面积的最大值，我发现了这些很好的预测因子，让我又多了 0.02。我猜他们没有停下来思考，这样决定谁应该更长时间被关押是否合理。

因此，将这些放在一起，你可以看到这会变得越来越可怕。我们以 Taser 这样的公司为例，Taser 是一种会给你一个大电击的设备，Taser 设法与一些学术研究人员建立了良好的关系，这些研究人员似乎会说他们要他们说的话，以至于现在如果你看数据，结果表明如果你被电击，你可能会死亡的概率相当高。这并不罕见。然而，他们支付给研究这个问题的研究人员一直回来说“哦不，这与电击无关。他们之后立即死亡完全无关。这只是一个偶然事件，事情发生了”。因此，这家公司现在拥有 80%的身体摄像机市场份额。他们开始收购计算机视觉 AI 公司。他们将尝试使用这些警察身体摄像机视频来预测犯罪活动。那意味着什么？这就像是我现在有一些增强现实显示，告诉我电击这个人，因为他们即将做一些坏事？这是一个令人担忧的方向，所以我确信没有人在 Taser 或他们收购的公司中的数据科学家会认为这是他们想要帮助创造的世界，但他们可能会发现自己或你可能会发现自己处于这种讨论的中心，虽然这不是明确讨论的话题，但你内心可能会有一部分在想“我想知道这可能会被如何使用”。我不知道在这种情况下应该做什么才是正确的，因为你可以询问，当然人们会说“不不不”。那你能做什么？你可以要求一些书面承诺，你可以决定离开，你可以开始研究事情的合法性，比如说，至少保护自己的法律情况。我不知道。想一想你会如何应对。

这些是 Rachel 提出的一些问题，作为需要考虑的事情。如果你正在考虑构建一个数据产品或使用模型，如果你正在构建机器学习模型，那是有原因的。你正在尝试做某事。那么数据中可能存在什么偏见？因为无论数据中存在什么偏见，最终都会成为你预测的偏见，潜在地影响你正在影响的行动，潜在地影响你返回的数据，你可能会得到一个反馈循环。

如果构建它的团队不够多样化，你可能会错过什么？例如，Twitter 的一位高级执行官在选举之前很久就警告了 Twitter 存在严重的俄罗斯机器人问题。那时 Twitter 高管团队中唯一的黑人。唯一的一个。不久之后，他们失去了工作。因此，拥有一个更多样化的团队意味着拥有更多样化的观点、信仰、想法和寻找的事物等等。因此，非多样化的团队似乎会犯更多这样的错误。

我们能审计代码吗？它是开源的吗？检查不同群体之间的不同错误率。我们是否可以使用一个极易解释和易于沟通的简单规则？如果出了问题，我们是否有一个处理问题的好方法？

当我们与人们谈论这个问题时，很多人都去找 Rachel 说我对我的组织正在做的事情感到担忧，我该怎么办[1:36:21]？或者我只是担心我的 toxic workplace，我该怎么办？而 Rachel 往往会说你有考虑过离开吗？他们会说我不想失去工作。但实际上，如果你会编程，你是整个人口的 0.3%。如果你会编程和做机器学习，你可能是整个人口的 0.01%。你是极其极其受欢迎的。所以实际上，显然一个组织不希望你觉得自己可以随时离开找另一份工作，这不符合他们的利益。但这绝对是真的。所以我希望你们在这门课程中能够获得足够的自信，认识到你有能力找到工作，特别是一旦你有了第一份工作，第二份工作就会容易很多。所以这很重要，不仅是为了让你觉得你实际上有能力去做出道德行为，而且也很重要意识到如果你发现自己处在一个 toxic 环境中，这是相当普遍的不幸。在湾区尤其存在很多糟糕的科技文化/环境。如果你发现自己处在这样的环境中，最好的做法就是赶紧离开。如果你没有自信认为自己可以找到另一份工作，你就会被困住。所以这真的很重要。很重要的是要知道你在结束这个项目时拥有非常受欢迎的技能，特别是在你有了第一份工作之后，你现在是一个拥有受欢迎技能和在该领域就业记录的人。

问题：这只是一个广泛的问题，你知道人们正在做一些什么来处理数据中的偏见吗[1:38:41]？你知道，这目前是一个有争议的话题，有人试图使用算法方法，他们基本上试图说我们如何识别偏见并将其减去。但我知道的最有效的方法是试图在数据层面上处理它。所以从一个更多元化的团队开始，特别是一个团队包括来自人文学科的人，比如社会学家、心理学家、经济学家，了解反馈循环和对人类行为的影响，他们往往配备了识别和跟踪这类问题的良好工具。然后尝试将解决方案纳入到过程中。但我无法告诉你有一个标准的处理方法，告诉你如何解决它。如果有这样的东西，我们还没有找到。简短的答案是，需要一个多样化的聪明团队意识到问题并努力解决。

评论：这只是针对整个班级的一个普遍性建议，如果你对这些感兴趣，我读过一本很酷的书，Jeremy 你可能听说过，Cathy O’Neil 的《Weapons of Math Destruction》。它涵盖了很多相同的内容[1:40:09]。是的，谢谢你的推荐。Kathy 很棒。她还有一个 TED 演讲。我没能完成这本书。它太令人沮丧了。我只是说“不要再看了”。但是，它确实很好。

好的。就这样了。谢谢大家。对我来说，这真的很紧张。显然，这原本是我和 Rachel 分享的事情。所以我最终做了我一生中最困难的事情之一，那就是独自教授两个人的课程，照顾生病的妻子和一个幼儿，还要学习深度学习课程。而且还要用我刚写的新库来完成所有这些。所以我期待着能好好休息一下。但这一切都是完全值得的。因为你们太棒了。我对你们对我给予的机会作出的反应以及我给予你们的反馈感到非常高兴。所以恭喜。