这是 Adam Geitgey 的一张图片。一张图片只是一堆数字，每个数字都是从 0 到 255，暗的接近 255，亮的接近 0。这是来自 MNIST 数据集的一个数字的例子。MNIST 是一个非常古老的，就像神经网络的 hello world 一样。所以这是一个例子。

这里有 28x28 个像素。如果是彩色的话，会有三个 —— 一个红色的，一个绿色的，一个蓝色的。我们的任务是查看数字数组并弄清楚这是一个棘手的数字 8。我们如何做到这一点？

我们将使用一小部分 FastAI 的内容，并逐渐去除更多，直到最后，我们将从头开始实现自己的神经网络，自己的训练循环，以及自己的矩阵乘法。因此，我们将逐渐深入挖掘更多。

from fastai.imports import *
from fastai.torch_imports import *
from fastai.io import *
path = 'data/mnist/'
import os
os.makedirs(path, exist_ok=True)

MNIST 的数据，这个非常著名的数据集的名称，可以从这里获取：

URL='http://deeplearning.net/data/mnist/'
FILENAME='mnist.pkl.gz'
def load_mnist(filename):return pickle.load(gzip.open(filename, 'rb'), encoding='latin-1')

我们在 fastai.io 中有一个叫做 get_data 的东西，它会从 URL 中获取数据并将其存储在你的计算机上，除非它已经存在，否则它将继续使用它。我们这里有一个叫做 load_mnist 的小函数，它简单地加载数据。你会看到它是压缩的，所以我们可以使用 Python 的 gzip 来打开它。然后它也被 pickled，所以如果你有任何类型的 Python 对象，你可以使用这个内置的 Python 库叫做 pickle 来将其转储到你的磁盘上，分享它，稍后加载它，你会得到与开始时相同的 Python 对象。你已经看到了类似于 Pandas 的 feather 格式的东西。Pickle 不仅仅适用于 Pandas，也不仅仅适用于任何东西，它基本上适用于几乎每个 Python 对象。这可能会引发一个问题，为什么我们不为 Pandas 的 DataFrame 使用 pickle。答案是 pickle 适用于几乎每个 Python 对象，但对于几乎任何 Python 对象来说，它可能不是最佳选择。因此，因为我们正在查看具有超过一亿行的 Pandas DataFrames，我们真的希望快速保存，所以 feather 是专门为此目的设计的格式，因此它会非常快速地完成。如果我们尝试 pickle 它，那将需要更长的时间。另外请注意，pickle 文件仅适用于 Python，因此你不能将它们交给其他人，而 feather 文件可以传递。所以值得知道 pickle 的存在，因为如果你有一些字典或某种对象漂浮在周围，你想要稍后保存或发送给其他人，你总是可以将其 pickle 化。所以在这种特殊情况下，deeplearning.net 的人们很友好地提供了一个 pickled 版本。

Pickle 随着时间的推移有些变化，所以像这样的旧 pickle 文件（这是 Python 2 的一个），你实际上必须告诉它是使用这个特定的 Python 2 字符集编码的。但除此之外，Python 2 和 3，你通常可以打开彼此的 pickle 文件。

get_data(URL+FILENAME, path+FILENAME)
((x, y), (x_valid, y_valid), _) = load_mnist(path+FILENAME)

一旦我们加载了这个，我们就像这样加载 ((x, y), (x_valid, y_valid), _)。所以我们这里正在做的事情叫做解构。解构意味着 load_mnist 给我们返回了一个元组的元组。如果在等号的左边有一个元组的元组，我们可以填充所有这些内容。所以我们得到了一个训练数据的元组，一个验证数据的元组，以及一个测试数据的元组。在这种情况下，我不关心测试数据，所以我把它放到一个名为 _ 的变量中，Python 的人们倾向于认为这是一个特殊的变量，我们把要丢弃的东西放进去。它实际上并不特殊，但非常常见。如果你看到有东西被赋值给下划线，那可能意味着你只是要丢弃它。

顺便说一下，在 Jupyter 笔记本中它确实有一个特殊的含义，即你计算的最后一个单元格始终在下划线中可用。但这是一个独立的问题。

然后元组中的第一件事本身就是一个元组，所以我们将把它放入 x 和 y 中作为我们的训练数据，然后第二个元组放入 x 和 y 中作为我们的验证数据。所以这就是所谓的解构，它在许多语言中都很常见。有些语言不支持它，但那些支持的语言，生活会变得更容易。一旦我看到一些新的数据集，我就会查看我得到了什么。它是什么类型？Numpy 数组。它的形状是什么？50,000 x 784。那么因变量呢？那是一个数组，它的形状是 50,000。

type(x), x.shape, type(y), y.shape
'''
(numpy.ndarray, (50000, 784), numpy.ndarray, (50000,))
'''

我们之前看到的 8 的图像不是长度为 784，而是大小为 28 乘以 28。所以这里发生了什么？事实证明，他们只是将第二行连接到第一行，将第三行连接到第二行，将第四行连接到第三行。换句话说，他们将整个 28 乘以 28 展平成一个单一的一维数组。这有意义吗？所以它的大小将是 28²。这绝对不是正常的，所以不要认为你看到的一切都会是这样。大多数时候，当人们分享图像时，他们会将它们分享为 JPEG 或 PNG 格式，你加载它们，你会得到一个漂亮的二维数组。但在这种特殊情况下，出于某种原因，他们拿出来的东西被展平成了 784。这个“展平”这个词在处理张量时非常常见，所以当你展平一个张量时，这意味着你将它转换为比你开始的更低秩的张量。在这种情况下，我们为每个图像开始时是一个秩为 2 的张量（即矩阵），然后我们将每个图像转换为一个秩为 1 的张量（即向量）。所以整体来说，整个东西是一个秩为 2 的张量，而不是一个秩为 3 的张量。

所以只是为了提醒我们这里的行话，这在数学中我们会称之为向量。在计算机科学中，我们会称之为一维数组，但是因为深度学习的人们必须表现得比其他人更聪明，我们不得不称之为秩为 1 的张量。它们基本上意思相同，除非你是物理学家——在这种情况下，这意味着其他事情，你会对深度学习的人们感到非常生气，因为你会说“这不是张量”。所以就是这样。不要责怪我。这只是人们说的话。

所以这要么是一个矩阵，要么是一个二维数组，要么是一个秩为 2 的张量。

一旦我们开始进入三维，我们开始用完数学名字，这就是为什么我们开始友好地说秩为 3 的张量。所以实际上，没有什么特别的关于向量和矩阵使它们比秩为 3 或秩为 4 的张量更重要。所以我尽量不使用向量和矩阵这些术语，因为我真的不认为它们比其他秩的张量更特别。所以习惯将numpy.ndarray (50,000, 784)看作秩为 2 的张量是很好的。

然后是行和列。如果我们是计算机科学人员，我们会称之为零维和一维。但如果我们是深度学习人员，我们会称之为轴零和轴一。然后为了更加混淆，如果你是一个图像人员，列是第一个轴，行是第二个轴。

所以如果你想到电视，1920 乘以 1080——列乘以行。其他人包括深度学习和数学家，行乘以列。所以如果你使用 Python 图像库，你会得到列乘以行；几乎其他所有情况，行乘以列。所以要小心。[一个学生问“为什么他们这样做？”]因为他们讨厌我们，因为他们是坏人，我猜😆

在深度学习中有很多，许多不同领域汇集在一起，如信息论、计算机视觉、统计学、信号处理，最终形成了深度学习中的这种混杂的命名法。通常，每个版本的事物都会被使用，所以今天，我们将听到一些被称为负对数似然或二项式或分类交叉熵的东西，这取决于你来自哪里。我们已经看到了一些被称为独热编码或虚拟变量的东西，这取决于你来自哪里。实际上，这只是相同的概念在不同领域中有点独立地被发明，最终它们找到了通往机器学习的道路，然后我们不知道该如何称呼它们，所以我们称它们为以上所有的东西——就像这样。所以我认为这就是计算机视觉中的行和列发生的事情。

让我们来看一下这些数据。所以我们在验证集中有 10,000 张图像，每张图像都是长度为 784 的秩为 1 的张量。

x_valid.shape(10000, 784)

为了显示它，我想将它转换为一个 28x28 的秩为 2 的张量。Numpy 有一个 reshape 函数，它接受一个张量并将其重塑为你请求的任何大小的张量。现在如果你考虑一下，你只需要告诉它有D个轴，你只需要告诉它你想要的D-1个轴，因为最后一个，它可以自己算出来。所以总共，这里一共有 10,000 乘以 784 个数字。所以如果你说我希望我的最后一个轴是 28x28，那么你可以算出（第一个轴）这必须是 10,000，否则它就不会适合。所以如果你放-1，它会说让它尽可能大或尽可能小以使其适合。所以你可以看到，它算出来必须是 10,000。你会看到这种方法在神经网络软件的预处理中经常使用。我可以在这里写 10,000，但我试图养成一种习惯，就是每当我提到输入中有多少项时，我倾向于使用-1，因为这意味着以后我可以使用子样本，这段代码不会出错。如果它是不平衡的，我可以进行一些分层抽样，这段代码不会出错。所以通过在这里使用-1 这种大小，它使得以后的更改更具弹性。这是一个很好的习惯。

x_imgs = np.reshape(x_valid, (-1,28,28)); x_imgs.shape(10000, 28, 28)

能够取张量并重新塑形、改变轴线等等的想法是你需要能够完全不假思索地做到的[23:56]。因为这种情况会经常发生。比如，这里有一个例子。我尝试读取一些图像，它们是扁平化的，我需要将它们重新塑形成一堆矩阵——好的，重新塑形。我用 OpenCV 读取了一些图像，结果发现 OpenCV 按照蓝绿红的顺序排列通道，其他所有的都希望它们是红绿蓝的。我需要颠倒最后一个轴。如何做到这一点？我用 Python 图像库读取了一些图像。它将它们读取为行、列、通道，PyTorch 希望通道、行、列。我该如何转换。所以这些都是你需要能够不假思索地做到的事情，就像立刻就能做到。因为这种情况经常发生，你绝不想坐在那里想了很久。所以确保你在这一周花很多时间练习今天你将看到的所有东西：重新塑形、切片、重新排序维度等等。所以最好的方法是自己创建一些小张量，开始思考，比如我应该尝试什么。

问题：在归一化时，您说许多机器学习算法在数据归一化时表现更好，但您也刚刚说过尺度并不重要？我说对于随机森林来说并不重要。因此，随机森林只会根据顺序输出结果，所以我们喜欢它们。我们喜欢随机森林是因为它们对分布假设不太担心。但我们现在不是在做随机森林，我们在做深度学习。而深度学习确实会在乎尺度。

问题：如果我们有参数化，那么我们应该进行尺度调整。如果我们有非参数化，我们就不需要进行尺度调整？不完全是这样。因为像 k 最近邻是非参数化的，尺度很重要，所以我会说涉及树的事情通常只会在某个点进行分割，所以你可能不在乎尺度，但你可能需要考虑这是一个使用顺序还是使用具体数字的算法。

问题：您能直观解释一下为什么它需要尺度吗，因为这可能会澄清一些问题？直到我们开始进行随机梯度下降时才需要，所以我们会讲到那一点。所以现在，我们只能说相信我的话。

问题：您能解释一下尺度是什么意思吗？因为当我想到尺度时，我认为所有数字应该大致相同大小。在我们进行深度学习时，猫和狗的情况是这样的，你可能有一只小猫和一只大猫，但它仍然知道它们都是猫？我想这是语言被重载的问题之一。在计算机视觉中，当我们对图像进行缩放时，实际上是增加了猫的大小。在这种情况下，我们正在缩放实际的像素值。因此，在这两种情况下，缩放意味着使某物变大和变小。在这种情况下，我们将数字从零到 255，并使它们的平均值为零，标准差为一。

问题：您能解释一下是按列还是按行？一般来说，当您进行缩放时，不仅仅考虑图像，而是输入到机器学习的内容。好的，当然。这有点微妙，但在这种情况下，我只有一个平均值和一个标准差。所以基本上，平均有多少黑色。因此，平均而言，我们有一个平均值和一个标准差跨越所有像素。在计算机视觉中，我们通常会按通道进行操作，所以通常会有一个数字代表红色，一个数字代表绿色，一个数字代表蓝色。一般来说，您需要为每个您希望表现不同的事物准备不同的归一化系数。因此，如果我们像处理一个结构化数据集，其中包括收入、公里数和孩子数量，您需要为这些事物准备三个单独的归一化系数，因为它们是非常不同的事物。因此，在这里有点领域特定。在这种情况下，所有像素都是灰度级别，因此我们只有一个缩放数字。而在其他情况下，如果它们是红色与绿色与蓝色，您需要以不同方式缩放这些通道。

问题：所以我有点难以想象如果在这种情况下不进行归一化会发生什么。我们会讨论到那里。这就是 Yannet 所说的为什么我们要归一化的原因，目前我们正在归一化是因为我说我们必须这样做。当我们开始研究随机梯度下降时，我们基本上会发现，如果你…基本上为了稍微提前一点，我们将会通过一堆权重进行矩阵乘法。我们将以这样一种方式选择这些权重，以便当我们进行矩阵乘法时，我们将尝试保持数字与它们最初的规模相同。这基本上需要我们知道初始数字的规模。因此，如果我们知道它们一直是均值为零，标准差为一，那么就更容易为许多不同类型的输入创建一个单一的神经网络架构。这将是简短的答案。但我们将学到更多关于它的知识，如果在几节课后你仍然不太明白为什么，让我们回过头来讨论，因为这是一个非常有趣的话题。

问题：我试图可视化我们正在使用的坐标轴。所以在绘图中，当你写x_valid.shape时，我们得到了 10,000 乘以 784。这意味着我们带入了那个维度的 10,000 张图片吗？是的，确切地说。问题继续：在下一行，当你选择重塑时，为什么将 28、28 作为 Y 或 Z 坐标？或者它们按照那个顺序有什么原因吗？

是的，有的。几乎所有的神经网络库都假设第一个轴相当于一行。就像一个单独的东西，它是一个句子或一幅图像或销售示例。所以我希望每个图像都是第一个轴的单独项目。然后，这样就为图像的行和列留下了另外两个轴。这是完全标准的。我认为我从来没有见过一个不是这样工作的库。

问题：在归一化验证数据时，我看到你使用了 x 数据的均值和标准差（即训练数据）。我们不应该使用验证数据的均值和标准差吗？不，因为你看，那样的话，你将使用不同的数字对验证集进行归一化，因此现在这个像素的值在验证集中的含义与在训练集中的含义不同。这就好像如果我们将一周的天数编码，使得星期一在训练集中是 1，在验证集中是 0。现在我们有了两组不同的数据，其中相同的数字具有不同的含义。

让我举个例子。假设我们正在处理全彩色图像，我们的训练集包含绿色青蛙、绿色蛇和灰色大象。我们正在训练以弄清楚它们各自是什么。然后我们使用每个通道的均值进行了归一化。然后我们有一个验证集和一个测试集，里面只有绿色青蛙和绿色蛇。如果我们使用验证集的统计数据进行归一化，我们最终会说平均而言都是绿色。所以我们会去除所有的绿色，因此我们现在将无法有效地识别绿色青蛙和绿色蛇。所以我们实际上希望使用我们训练时使用的相同的归一化系数。对于那些正在学习深度学习课程的人，我们实际上做得更多。当我们使用预训练的网络时，我们必须使用原始作者训练时使用的相同的归一化系数。因此，这个数字在你使用它的每个数据集中都需要有一致的含义。这意味着当你查看测试集时，你需要根据训练集的均值和标准差对测试集进行归一化。

show(x_imgs[0], y_valid[0])

所以验证 y 值只是一个长度为 10,000 的秩为 1 的张量。记住这是一种奇怪的 Python 事情，一个包含这一个东西的元组需要一个尾随逗号。所以这是一个长度为 10,000 的秩为 1 的张量。

y_valid.shape(10000,)

这里有一个例子。只是一个数字 3。这就是我们的标签。

y_valid[0]
'''
3
'''

好的，所以我们将从上到下开始，创建一个神经网络，并假设很多东西。然后逐渐我们将深入研究每个部分。所以要创建神经网络，我们需要导入 PyTorch 神经网络库。有趣的是，PyTorch 并不叫 PyTorch——它叫 torch。所以torch.nn是负责神经网络的 PyTorch 子部分。我们将称之为 nn。我们将从 Fast AI 中导入一些部分，以使我们的生活变得更容易。

from fastai.metrics import *
from fastai.model import *
from fastai.dataset import *import torch.nn as nn

这里是如何在 PyTorch 中创建神经网络的。最简单的神经网络，你说 Sequential。Sequential 意味着我现在要给你一个我想要在我的神经网络中的层的列表。所以在这种情况下，我的列表中有两个东西。第一件事说我想要一个线性层。现在线性层基本上会执行y = ax + b，但是矩阵矩阵相乘，而不是单变量。所以它基本上会执行一个矩阵乘积。矩阵乘积的输入将是一个长度为 28 乘以 28 的向量，因为这是我们有多少像素，输出需要是大小为 10（我们稍后会讨论原因）。目前这就是我们如何定义一个线性层。然后，我们将详细讨论这一点，但是几乎每个神经网络中的线性层之后都必须有一个非线性。然后我们将在一会儿学习这个特定的非线性，它被称为 softmax，如果你已经学过深度学习课程，你已经见过这个。这就是我们如何定义一个神经网络。这是一个两层神经网络。

net = nn.Sequential(nn.Linear(28*28, 10),nn.LogSoftmax()
).cuda()

还有一种隐含的额外第一层，即输入层，但是使用 PyTorch，你不必显式提及输入。但通常我们在概念上认为输入图像也是一种层。因为我们正在相当手动地进行操作，使用 PyTorch 我们没有利用 Fast AI 中构建你的东西的任何便利性，我们必须然后写.cuda()，这告诉 PyTorch 将这个神经网络复制到 GPU 上。从现在开始，该网络实际上将在 GPU 上运行。如果我们没有说，它将在 CPU 上运行。这给我们返回了一个神经网络——一个非常简单的神经网络。

然后我们将尝试将神经网络拟合到一些数据上。所以我们需要一些数据。Fast AI 有一个 ModelData 对象的概念，基本上是将训练数据、验证数据和可选的测试数据包装在一起的东西。所以要创建一个 ModelData 对象，你可以这样说：

• 我想创建一些图像分类器数据（ImageClassifierData）

• 我将从一些数组中获取它（from_arrays）

• 这是我将保存任何临时文件的路径（path）

• 这是我的训练数据数组（（x，y））

• 这是我的验证数据数组（（x_valid，y_valid））

这只是返回一个将所有这些包装起来的对象。所以我们将能够拟合到这些数据上。

md = ImageClassifierData.from_arrays(path, (x,y),(x_valid, y_valid))

现在我们有了一个神经网络和一些数据，我们将在一会儿回到这里，但基本上我们说我们想使用什么损失函数，想使用什么优化器，然后说拟合[1:01:07]。

loss=nn.NLLLoss()
metrics=[accuracy]
opt=optim.Adam(net.parameters())

我们说将这个网络net拟合到这个数据md上，每次遍历每个图像一次（n_epochs），使用这个损失函数loss，这个优化器opt，并打印出这些指标metrics。

fit(net, md, n_epochs=1, crit=loss, opt=opt, metrics=metrics)

这里说这是 91.8%的准确率。所以这就是最简单的神经网络。它正在创建一个矩阵乘法，然后是一个非线性，它试图找到这个矩阵的值（nn.Linear(28*28, 10)），基本上是尽可能好地拟合数据，最终预测这是 1，这是 9，这是 3。

所以我们需要一些关于“尽可能好”的定义。那个东西的一般术语叫做损失函数。所以损失函数是一个函数，如果这个函数更低，那么就更好。就像随机森林一样，我们有信息增益的概念，我们得选择用什么函数来定义信息增益，我们主要看的是均方根误差。大多数机器学习算法我们称之为类似于“损失”的东西。所以损失是我们如何评分我们有多好的东西。最终，我们将计算损失对我们正在乘以的权重矩阵的导数，以找出如何更新它。

我们将使用一种称为负对数似然损失（NLLLoss）的东西。负对数似然损失也被称为交叉熵，它们实际上是一样的。有两个版本，一个称为二元交叉熵或二元负对数似然，另一个称为分类交叉熵。它们是一样的，一个是当你只有一个零或一个依赖时，另一个是如果你有猫、狗、飞机或马，或者 0、1、到 9 等等。所以这里我们有交叉熵的二元版本：

def binary_loss(y, p):return np.mean(-(y * np.log(p) + (1-y)*np.log(1-p)))

所以这里的定义是-(y * np.log(p) + (1-y)*np.log(1-p))。我认为理解这个定义的最简单方法可能是看一个例子。假设我们试图预测猫和狗。1 代表猫，0 代表狗。所以这里，我们有猫、狗、狗、猫（[1, 0, 0, 1]）。这是我们的预测（[0.9, 0.1, 0.2, 0.8]）。我们说 90%确定是猫，90%确定是狗，80%确定是狗，80%确定是猫。所以我们可以通过调用我们的函数来计算二元交叉熵。

对于第一个，我们有y=1，p=0.9（即(1 * np.log(0.9)，因为第二项被跳过了）。对于第二个，第一部分被跳过（乘以 0），第二部分将是(1-0)*np.log(0.9)。换句话说，这个的第一部分和第二部分将给出完全相同的数字，这是有道理的，因为第一个我们说我们对是猫 90%有信心，而实际上是，第二个我们说我们对是狗 90%有信心，而实际上是。所以在每种情况下，损失都来自于我们本可以更有信心。所以如果我们说我们 100%有信心，损失将为零。

acts = np.array([1, 0, 0, 1])
preds = np.array([0.9, 0.1, 0.2, 0.8])
binary_loss(acts, preds)
'''
0.164252033486018
'''

所以让我们在 Excel 中看一下。从顶部行开始：

1. 我们的预测

2. 实际/目标值

3. 1 减去实际/目标值

4. 我们的预测的对数

5. 我们的预测的对数的 1 减

6. 总和

如果你仔细想一想，我希望你在这一周内考虑一下，你可以用一个 if 语句来替换这个(np.mean(-(y * np.log(p) + (1-y)*np.log(1-p))))，而不是 y，因为 y 总是 1 或 0，所以它只会使用np.log(p)或(np.log(1-p)中的一个。所以你可以用一个 if 语句来替换这个。所以我希望你在这一周内尝试用一个 if 语句来重写这个。

然后看看你是否能将其扩展为分类交叉熵。所以分类交叉熵的工作方式是这样的。假设我们试图预测 3、6、7、2。

所以如果我们试图预测 3，而实际上预测了 5，或者试图预测 3，却意外地预测了 9。5 而不是 3 并不比 9 而不是 3 更好。所以我们实际上不会说实际数字有多远。我们会用不同的方式表达它。换句话说，如果我们试图预测猫、狗、马和飞机。猫和马之间有多远？所以我们会稍微不同地表达这些。与其把它看作是一个 3，不如把它看作是一个在第三个位置上有一个 1 的向量：

不要把它看作是一个 6，让我们把它看作是一个零向量，第 6 个位置是 1。换句话说，独热编码。所以让我们对我们的因变量进行独热编码。这样现在，我们不再试图预测一个数字，而是预测十个数字。让我们预测它是 0 的概率，它是 1 的概率，依此类推。

所以让我们假设我们正在预测 2，这里是我们的分类交叉熵[1:07:50]。所以它只是在说，这个预测是否正确，有多大偏差，依此类推，对每一个进行计算，然后将它们全部加起来。分类交叉熵与二元交叉熵是相同的。我们只需要将它们加起来跨越所有的类别。

所以尝试将 Python 中的二元交叉熵函数转换为 Python 中的分类交叉熵。也许创建带有 if 语句的版本和带有求和和乘积的版本。

这就是为什么在我们的 PyTorch 中，我们将这个矩阵的输出维度设置为 10，因为当我们将一个有 10 列的矩阵相乘时，我们将得到一个长度为 10 的结果，这正是我们想要的[1:08:35]。我们想要有 10 个预测。

这就是我们正在使用的损失函数。然后我们可以拟合模型，它会遍历每个图像，这么多次（epochs）。所以在这种情况下，它只是查看每个图像一次，并且会根据这些梯度稍微更新那个权重矩阵中的值。

所以一旦我们训练好了，我们就可以用这个模型(net)在验证集(md.val_dl)上进行predict。

preds = predict(net, md.val_dl)

现在这会输出一个 10,000 乘以 10 的东西。我们有 10,000 张图像进行验证，实际上每张图像进行 10 次预测。换句话说，每一行都是它是 0 的概率，它是 1 的概率，它是 2 的概率，依此类推。

preds.shape
'''
(10000, 10)
'''

在数学中，有一个我们经常做的操作叫做argmax。当我说它很常见时，很有趣的是在高中，我从来没有见过 argmax。大一，我也从来没有见过 argmax。但不知何故，大学毕业后，一切都与 argmax 有关。所以有些事情在学校里似乎并没有真正教，但实际上它非常关键。argmax 既是数学中的一个东西（它只是完整地写出argmax），它在 numpy 中，在 PyTorch 中，非常重要。它的作用是让我们拿这些预测数组，然后在给定的轴上（axis=1 - 记住，轴 1 是列），就像 Chis 所说的，对于每一行的 10 个预测，让我们找出哪个预测值最高，然后返回不是那个值（如果只是说 max，它会返回值），argmax 返回值的索引。所以通过说argmax(axis=1)，它将返回实际上是数字本身的索引。所以让我们取前 5 个：

preds.argmax(axis=1)[:5]
'''
array([3, 8, 6, 9, 6])
'''

这就是我们如何将我们的概率转换回预测的方法。我们保存下来并称之为preds。然后我们可以说preds何时等于真实值。这将返回一个布尔数组，我们可以将其视为 1 和 0，一堆 1 和 0 的平均值就是平均值。这给了我们 91.8%的准确率。

preds = preds.argmax(1)
np.mean(preds == y_valid)
'''
0.91820000000000002
'''

所以你想要能够复制你看到的数字，这里就是。这里是我们的 91.8%。

所以当我们训练这个模型时，最后一件事告诉我们的是我们要求的任何指标，我们要求的是准确率。然后在此之前，我们得到了训练集的损失。损失又是我们要求的任何损失(nn.NLLLoss())，第二件事是验证集的损失。PyTorch 不使用损失这个词，他们使用准则这个词。所以你会在这里看到crit，这就是准则等于损失。这就是我们想要使用的损失函数，他们称之为准则。同样的事情。所以np.mean(preds == y_valid)就是我们如何重新创建准确率的方法。

plots(x_imgs[:8], titles=preds[:8])

因此，现在我们可以继续绘制八幅图像以及它们的预测。对于我们预测错误的那些，您可以看到它们为什么错误。数字 4 的图像非常接近数字 9。它只是在顶部少了一个小交叉。数字 3 非常接近数字 5。它在顶部有一点额外的部分。所以我们已经开始了。到目前为止，我们实际上还没有创建一个深度神经网络。我们实际上只有一个层。因此，我们实际上所做的是创建了一个逻辑回归。逻辑回归就是我们刚刚构建的内容，您可以尝试使用 sklearn 的逻辑回归包来复制这个过程。当我这样做时，我得到了类似的准确性，但这个版本运行得更快，因为它在 GPU 上运行，而 sklearn 在 CPU 上运行。因此，即使对于像逻辑回归这样的东西，我们也可以使用 PyTorch 非常快速地实现它。

问题：当我们创建我们的网络时，我们必须执行.cuda()。如果不这样做会有什么后果？它只是不会快速运行。它将在 CPU 上运行。

问题：为什么我们必须先进行线性操作，然后再进行非线性操作？简短的答案是因为这是通用逼近定理所说的结构，可以为任何函数形式提供任意精确的函数。长答案是通用逼近定理为何有效的细节。另一个简短答案是，这就是神经网络的定义。因此，神经网络的定义是一个线性层，后跟一个激活函数，再后跟一个线性层，再后跟一个激活函数，依此类推。我们在深度学习课程中会更详细地讨论这一点，但就此目的而言，知道它有效就足够了。到目前为止，当然，我们实际上还没有构建一个深度神经网络。我们只是构建了一个逻辑回归。因此，在这一点上，如果你考虑一下，我们所做的就是将每个输入像素乘以每个可能结果的权重。因此，我们基本上是在说，平均而言，数字 1 具有这些像素点亮。数字 2 具有这些像素点亮。这就是为什么它不是非常准确的原因。这不是现实生活中数字识别的工作方式。但到目前为止，这就是我们构建的全部内容。

问题：所以你一直在说这个通用逼近定理。你有定义过吗？是的，但让我们再次讨论一下，因为这值得谈论。因此，Michael Nielsen 有一个名为神经网络与深度学习的优秀网站。他的第四章现在实际上很有名，其中他通过演示神经网络可以以足够大的规模逼近任何其他函数，只要它足够大，来详细介绍这一点。我们在深度学习课程中详细讨论了这一点，但基本的诀窍是，他展示了通过几个不同的数字，您基本上可以使这些事物创建小盒子，您可以将盒子上下移动，您可以将它们移动，您可以将它们连接在一起，最终基本上可以创建像塔一样的连接，您可以用来逼近任何类型的表面。

因此，这基本上就是诀窍。因此，我们所需要做的就是，鉴于此，找到神经网络中每个线性函数的参数。因此，找到每个矩阵中的权重。到目前为止，我们只有一个矩阵，我们只是构建了一个简单的逻辑回归。

问题：我只是想确认一下，当你展示被错误分类的图像的例子时，它们看起来是矩形的，所以只是在渲染时，像素被不同地缩放了吗？它们是 28 乘 28 的。我认为它们看起来是矩形的，因为它们顶部有标题。Matplotlib 经常会调整它认为的黑色与白色以及具有不同大小轴等的东西。因此，有时你必须小心一点。

欢迎回到机器学习！我非常兴奋能够分享一些由旧金山大学学生在这一周内构建或撰写的惊人内容。我将向你展示的许多东西已经在互联网上广泛传播：大量的推文和帖子以及各种各样的事情发生。

由Tyler White提供

他开始说，如果我创建一个合成数据集，其中自变量是 x 和 y，因变量是颜色，会怎样。有趣的是，他向我展示了一个早期版本，那时他没有使用颜色。他只是把实际的数字放在这里。

这个东西一开始根本不起作用。一旦他开始使用颜色，它就开始运行得非常好。所以我想提一下，不幸的是我们在 USF 没有教给你的一件事是人类感知的理论，也许我们应该。因为实际上，当涉及到可视化时，最重要的事情是了解人眼或大脑擅长感知的是什么。关于这个有一个整个学术研究领域。我们最擅长感知的事情之一就是颜色的差异。这就是为什么当我们看这张他创建的合成数据的图片时，你可以立刻看到，哦，这里有四个较浅红色的区域。他所做的是，他说好，如果我们尝试创建一个关于这个合成数据集的机器学习模型，具体来说他创建了一棵树。而酷的事情是你实际上可以绘制这棵树。所以在他创建了这棵树之后，他在 matplotlib 中完成了所有这些。Matplotlib 非常灵活。他实际上绘制了树的边界，这已经是一个相当不错的技巧——能够实际绘制这棵树。

然后他做了更聪明的事情，他说好的，那么树做出了什么预测？嗯，这是每个区域的平均值，所以为了做到这一点，我们实际上可以绘制平均颜色。这实际上相当漂亮。这是树所做的预测。现在这里变得非常有趣。你可以，如你所知，通过重新采样随机生成树，所以这里有通过重新采样生成的四棵树。它们都非常相似但略有不同。

现在我们实际上可以可视化装袋，为了可视化装袋，我们简单地取四张图片的平均值。这就是装袋。就是这样：

这是一个随机森林的模糊决策边界，我觉得这很神奇。因为这就像，我真希望在我开始教你们随机森林的时候有这个，我本来可以跳过几节课的。就像“好的，这就是我们做的”。我们创建决策边界，对每个区域进行平均，然后重复几次并对所有结果进行平均。这就是随机森林的做法，我认为这只是一个通过图片将复杂问题变得简单的很好的例子。所以恭喜 Tyler。事实上，他实际上重新发明了别人已经做过的事情。一个叫 Christian Innie(?)的人，他后来成为了世界上最重要的机器学习研究者之一，实际上在他写的一本关于决策森林的书中几乎完全包含了这个技术。所以 Tyler 最终重新发明了一个世界上最重要的决策森林专家创造的东西，这实际上很酷。我觉得这很有趣。很好，因为当我们在 Twitter 上发布这个时，引起了很多关注，最终有人能够说“哦，你知道吗，这实际上已经存在了”。所以 Tyler 已经开始阅读那本书。

由 Jason Carpenter

另一件很酷的事情是 Jason Carpenter 创建了一个全新的库叫做 Parfit。Parfit 是为了选择超参数而并行拟合多个模型。我真的很喜欢这个。他展示了如何使用它的清晰示例，API 看起来非常类似于其他基于网格搜索的方法，但它使用了 Rachel 写的验证技术，我们几周前学到的使用一个好的验证集。他在介绍它的博客文章中，回顾了什么是超参数，为什么我们必须训练它们，并解释了每一步。然后这个模块本身非常完善。他为其添加了文档，为其添加了一个很好的 README。当你实际看代码时，你会发现它非常简单，这绝对不是坏事，简单是好事。通过编写这段代码并将其打包得如此完美，他使其他人使用这个技术变得非常容易，这很棒。

由Vinay Patlolla

我真的很高兴看到的一件事是 Vinay 继续结合了我们课堂上学到的两件事：一是使用 Parfit，另一是使用我们在上一课中学到的加速 SGD 分类方法，将两者结合起来，说“好的，现在让我们使用 Parfit 来帮助我们找到 SGD 逻辑回归的参数”。我认为这真的是一个很好的主意。

由 Prince Grover

我认为很棒的另一件事是，Prince 基本上总结了我们在随机森林解释中学到的几乎所有内容。他甚至比那更进一步，因为他描述了随机森林解释的每种不同方法。他描述了如何做到这一点，例如，通过变量置换来计算特征重要性，每个方法都有一个小图片，然后非常酷，这里是从头开始实现它的代码。我认为这是一篇非常好的文章，描述了很多人不理解的东西，并且准确展示了它是如何工作的，既有图片又有实现代码。所以我认为这真的很棒。我在这里真的很喜欢的一件事是，对于树解释器，他实际上展示了如何将树解释器的输出输入到由 USF 学生 Chris 构建的新瀑布图包中，以展示如何实际上在瀑布图中可视化树解释器的贡献。所以再次，这是一种很好的结合我们学习和作为一个团队构建的多种技术。

由Davesh Maheshwari提供

有一些有趣的内核分享，下周我会分享更多，Davesh 写了这篇非常好的内核，展示了在检测冰山与船只的 Kaggle 竞赛中的挑战。这是一种很难可视化的奇怪的双通道卫星数据，他实际上通过并基本上描述了这些雷达散射的工作原理的公式，然后实际上设法编写了一个代码，使他能够重新创建实际的 3D 冰山或船只。我以前没有见过这样做。如何可视化这些数据是非常具有挑战性的。然后他继续展示如何构建神经网络来尝试解释这一点，这也非常棒。

笔记本

让我们回到 SGD。所以我们正在回顾这份笔记本，Rachel 基本上带领我们从头开始学习 SGD，目的是进行数字识别。实际上，今天我们看的很多东西都将紧随计算线性代数课程的一部分，你可以在 fast.ai 上找到MOOCs，或者在 USF，它将成为明年的选修课。所以如果你觉得这些东西有趣，我希望你会考虑报名参加选修课或在线观看视频。

所以我们正在构建神经网络。我们假设已经下载了 MNIST 数据，通过减去平均值并除以标准差对其进行了标准化。这些数据略有不同，虽然它们代表图像，但它们被下载为每个图像都是 784 个长的秩为 1 的张量，因此已经被展平。为了绘制它的图片，我们必须将其调整为 28x28。但实际的数据不是 28x28，而是 784 个长的展平数据。

我们要采取的基本步骤是从训练世界上最简单的神经网络开始，基本上是一个逻辑回归。因此没有隐藏层。我们将使用一个名为 Fast AI 的库进行训练，并使用一个名为 PyTorch 的库构建网络。然后我们将逐渐摆脱所有库。首先，我们将摆脱 PyTorch 中的nn（神经网络）库，并自己编写。然后我们将摆脱 Fast AI 的fit函数，并自己编写。然后我们将摆脱 PyTorch 的优化器，并自己编写。因此，在本笔记本的最后，我们将自己编写所有部分。我们最终依赖的唯一两个 PyTorch 给我们的关键事物是：

• 具有编写 Python 代码并在 GPU 上运行的能力

• 具有编写 Python 代码并使其自动为我们进行微分的能力。

因此，这两件事我们不打算自己尝试编写，因为这很无聊且毫无意义。但除此之外，我们将尝试在这两件事的基础上自己编写其他所有内容。

我们的起点不是自己做任何事情。基本上所有事情都已经为我们完成。因此，PyTorch 有一个nn库，其中包含神经网络的内容。您可以通过使用Sequential函数创建一个多层神经网络，然后传入您想要的层的列表，我们要求一个线性层，然后是一个 softmax 层，这定义了我们的逻辑回归。

from fastai.metrics import *
from fastai.model import *
from fastai.dataset import *import torch.nn as nnnet = nn.Sequential(nn.Linear(28*28, 10),nn.LogSoftmax()
).cuda()

我们线性层的输入是 28 乘以 28，输出是 10，因为我们希望为我们的图像中的每个数字 0 到 9 之间的每个数字获得一个概率。.cuda()将其放在 GPU 上，然后fit拟合模型。

loss=nn.NLLLoss()
metrics=[accuracy]
opt=optim.Adam(net.parameters())
fit(net, md, n_epochs=5, crit=loss, opt=opt, metrics=metrics)

因此，我们从一组随机权重开始，然后使用梯度下降进行拟合以使其更好。我们必须告诉拟合函数要使用什么标准，换句话说，什么算作更好，我们告诉它使用负对数似然。我们将在下一课中了解这是什么。我们必须告诉它要使用什么优化器，我们说请使用optim.Adam，这方面的细节我们在本课程中不会涉及。我们将构建一个更简单的称为 SGD 的东西。如果您对 Adam 感兴趣，我们刚刚在深度学习课程中涵盖了这一点。您想要打印出什么指标，我们决定打印出准确率。就是这样。所以在我们拟合后，我们通常会得到大约 91、92%的准确率。

那么我们实际上在这里构建了什么？嗯，正如我所说的，我们实际上构建的是可以像常规函数一样运行的东西。所以我想向你展示如何实际上将其作为一个函数调用。为了能够将其作为一个函数调用，我们需要能够向其传递数据。为了能够向其传递数据，我需要获取一个 MNIST 图像的小批量。为了方便起见，我们使用了 Fast AI 的ImageClassifierData.from_arrays方法，它会为我们创建一个 PyTorch DataLoader。PyTorch DataLoader 是一种获取几张图像并将它们放入一个小批量并使其可用的东西。你基本上可以说给我另一个小批量，给我另一个小批量，给我另一个小批量。所以在 Python 中，我们称这些东西为生成器。生成器是一种东西，你基本上可以说我想要另一个，我想要另一个，我想要另一个。迭代器和生成器之间有非常紧密的联系，我现在不打算担心它们之间的区别。但你会看到，为了获得我们可以说请给我另一个的东西，为了获取我们可以用来生成小批量的东西，我们必须取出我们的数据加载器，这样你就可以从我们的模型数据对象中请求训练数据。你会看到有很多不同的数据加载器可以请求：测试数据加载器、训练数据加载器、验证数据加载器、增强图像数据加载器等等。

dl = iter(md.trn_dl)

所以我们要获取为我们创建的训练数据加载器。这是一个标准的 PyTorch 数据加载器，稍微被我们优化了一下，但是思路是一样的。然后你可以说这个（iter）是一个标准的 Python 东西，我们可以说将其转换为一个迭代器，即我们可以一次从中获取另一个的东西。一旦你这样做了，我们就有了一个可以迭代的东西。你可以使用标准的 Python next函数从生成器中获取一个更多的东西。

xmb,ymb = next(dl)

所以这是从一个小批量返回 x 和 y。在 Python 中，您可以使用for循环来使用生成器和迭代器。我也可以说 x 小批量逗号 y 小批量在数据加载器中，然后做一些事情：

所以当你这样做时，实际上是在幕后，它基本上是调用next很多次的语法糖。所以这都是标准的 Python 东西。

所以它返回了一个大小为 64 乘以 784 的张量，这是我们所期望的。我们使用的 Fast AI 库默认使用小批量大小为 64，这就是为什么它这么长。这些都是背景零像素，但它们实际上并不是零。在这种情况下，为什么它们不是零呢？因为它们被标准化了。所以我们减去了平均值，除以标准差。

xmb
'''
-0.4245 -0.4245 -0.4245  ...  -0.4245 -0.4245 -0.4245
-0.4245 -0.4245 -0.4245  ...  -0.4245 -0.4245 -0.4245
-0.4245 -0.4245 -0.4245  ...  -0.4245 -0.4245 -0.4245...             ⋱             ...          
-0.4245 -0.4245 -0.4245  ...  -0.4245 -0.4245 -0.4245
-0.4245 -0.4245 -0.4245  ...  -0.4245 -0.4245 -0.4245
-0.4245 -0.4245 -0.4245  ...  -0.4245 -0.4245 -0.4245
[torch.FloatTensor of size 64x784 (GPU 0)]
'''

现在我们要做的是将其传递给我们的逻辑回归。所以我们可能会这样做，我们将使用vxmb（变量 x 小批量），我可以取出我的 x 小批量，我可以将其移动到 GPU 上，因为记住我的net2对象在 GPU 上，所以我们的数据也必须在 GPU 上。然后我要做的第二件事是，我必须将其包装在Variable中。那么变量是做什么的呢？这是我们免费获得自动微分的方式。PyTorch 可以自动微分几乎任何张量。但这需要内存和时间，所以它不会总是跟踪。要进行自动微分，它必须跟踪确切的计算方式。我们将这些东西相加，我们将其乘以那个，然后我们取了这个的符号等等。你必须知道所有的步骤，因为然后要进行自动微分，它必须使用链式法则对每个步骤求导，然后将它们相乘。所以这是缓慢和占用内存的。所以我们必须选择说“好的，这个特定的东西，我们以后会对其进行求导，所以请为我们跟踪所有这些操作。”我们选择的方式是将一个张量包装在Variable中。这就是我们的做法。

你会发现它看起来几乎和一个张量一样，但现在它说“包含这个张量的变量”。所以在 PyTorch 中，一个变量的 API 与张量完全相同，或者更具体地说，是张量 API 的超集。我们对张量可以做的任何事情，我们也可以对变量做。但它会跟踪我们做了什么，以便我们以后可以求导。

vxmb = Variable(xmb.cuda())
vxmb
'''
Variable containing:
-0.4245 -0.4245 -0.4245  ...  -0.4245 -0.4245 -0.4245
-0.4245 -0.4245 -0.4245  ...  -0.4245 -0.4245 -0.4245
-0.4245 -0.4245 -0.4245  ...  -0.4245 -0.4245 -0.4245...             ⋱             ...          
-0.4245 -0.4245 -0.4245  ...  -0.4245 -0.4245 -0.4245
-0.4245 -0.4245 -0.4245  ...  -0.4245 -0.4245 -0.4245
-0.4245 -0.4245 -0.4245  ...  -0.4245 -0.4245 -0.4245
[torch.cuda.FloatTensor of size 64x784 (GPU 0)]
'''

所以我们现在可以将其传递给我们的net2对象。记住我说过你可以将其视为函数。所以请注意，我们没有调用.forward()，我们只是将其视为函数。然后记住，我们取了对数，为了撤销这个操作，我正在使用.exp()，这将给我概率。所以这是我的概率，它返回的大小是 64 乘以 10，所以对于小批量中的每个图像，我们有 10 个概率。你会看到，大多数概率都非常接近零。而其中一些则要大得多，这正是我们所希望的。就像好吧，它不是零，不是 1，不是 2，它是3，不是 4 等等。

preds = net2(vxmb).exp(); preds[:3]
'''
Variable containing:Columns 0 to 5 1.6740e-03  1.0416e-05  2.5454e-05  1.9119e-02  6.5026e-05  9.7470e-013.4048e-02  1.8530e-04  6.6637e-01  3.5073e-02  1.5283e-01  6.4995e-053.0505e-08  4.3947e-08  1.0115e-05  2.0978e-04  9.9374e-01  6.3731e-05Columns 6 to 9 2.1126e-06  1.7638e-04  3.9351e-03  2.9154e-041.1891e-03  3.2172e-02  1.4597e-02  6.3474e-028.9568e-06  9.7507e-06  7.8676e-04  5.1684e-03
[torch.cuda.FloatTensor of size 3x10 (GPU 0)]
'''

我们可以调用net2.forward(vxmb)，它会做完全相同的事情。但这并不是 PyTorch 的所有机制实际上是如何工作的。他们实际上将其称为函数。这实际上是一个非常重要的想法，因为这意味着当我们定义自己的架构或其他内容时，任何你想要放入函数的地方，你都可以放入一个层；任何你想要放入一个层的地方，你都可以放入一个神经网络；任何你想要放入一个神经网络的地方，你都可以放入一个函数。因为就 PyTorch 而言，它们都只是它将调用的东西，就像它们是函数一样。所以它们是可以互换的，这是非常重要的，因为这就是我们通过混合和匹配许多部分并将它们组合在一起来创建非常好的神经网络的方式。

让我举个例子。这是我的逻辑回归，准确率达到了 91%多一点。我现在要把它转换成一个带有一个隐藏层的神经网络。

我要做的是创建更多的层。我要改变这个，使其输出 100 而不是 10，这意味着这个输入将是 100 而不是 10。现在这样还不能让事情变得更好。为什么这肯定不会比之前更好呢？因为两个线性层的组合只是一个线性层，但参数不同。

所以我们有两个线性层，这只是一个线性层。为了使事情变得有趣，我将用零替换第一层中的所有负数。因为这是一个非线性转换，这个非线性转换被称为修正线性单元（ReLU）。

所以nn.Sequential简单地会依次调用每个层对每个小批量进行操作。所以做一个线性层，用零替换所有负数，再做一个线性层，最后做一个 softmax。这现在是一个有一个隐藏层的神经网络。所以让我们尝试训练这个。准确率现在已经提高到 96%。

所以这个想法是，我们在这节课中学习的基本技术在你开始将它们堆叠在一起时变得强大。

问题：为什么你选择了 100？没有原因。输入一个额外的零更容易。神经网络层中应该有多少激活是深度学习从业者的规模问题，我们在深度学习课程中讨论过，而不是在这门课程中。

问题：在添加额外的层时，如果你做了两个 softmax，这会有影响吗，或者这是你不能做的事情？你绝对可以在那里使用 softmax。但这可能不会给你想要的结果。原因是 softmax 倾向于将大部分激活推向零。激活，只是为了明确，因为在深度学习课程中我收到了很多关于什么是激活的问题，激活是在一个层中计算出来的值。这就是一个激活：

这不是一个权重。权重不是一个激活。它是你从一个层计算出来的值。所以 softmax 会倾向于使大部分激活接近于零，这与你想要的相反。通常你希望你的激活尽可能丰富、多样且被使用。所以没有什么能阻止你这样做，但它可能不会工作得很好。基本上，你的所有层几乎都会跟随非线性激活函数，通常是 ReLU，除了最后一层。

问题：在做多层时，比如说 2 或 3 层，你想要改变这些激活层吗？不。所以如果我想要更深，我会直接这样做。

现在这是一个两个隐藏层的网络。

问题：所以我想我听到你说有几种不同的激活函数，比如修正线性单元。有一些例子，为什么会使用每一个呢？是的，很好的问题。所以基本上当你添加更多的线性层时，你的输入进来，你把它通过一个线性层然后一个非线性层，线性层，非线性层，线性层和最终的非线性层。最终的非线性层正如我们讨论过的，如果它是多类别分类但你只选择其中一个，你会使用 softmax。如果是二元分类或多标签分类，你会使用 sigmoid。如果是回归，通常你根本不会有，尽管我们在昨晚的深度学习课程中学到有时你也可以在那里使用 sigmoid。所以它们基本上是最终层的主要选项。对于隐藏层，你几乎总是使用 ReLU，但还有另一个你可以选择的，有点有趣，叫做 leaky ReLU。基本上如果它大于零，它是y = x，如果小于零，它就像y = 0.1x。所以它与 ReLU 非常相似，但不是等于 0，而是接近于 0。所以它们是主要的两种：ReLU 和 Leaky ReLU。

还有其他一些，但它们有点像那样。例如，有一种叫做 ELU 的东西相当受欢迎，但细节并不太重要。像 ELU 这样的东西有点像 ReLU，但在中间稍微弯曲一些。它通常不是基于数据集选择的东西。随着时间的推移，我们发现了更好的激活函数。所以两三年前，每个人都使用 ReLU。一年前，几乎每个人都使用 Leaky ReLU。今天，我想大多数人开始转向 ELU。但老实说，激活函数的选择实际上并不太重要。人们实际上已经表明，你可以使用相当任意的非线性激活函数，甚至是正弦波，它仍然有效。

所以尽管今天我们要做的是展示如何创建这个没有隐藏层的网络，将其转变为下面这个网络（下面）准确率为 96%左右将会很简单。这是你可能应该在这一周尝试做的事情，创建这个版本。

现在我们有了一个可以传递我们的变量并得到一些预测的网络，这基本上就是我们调用fit时发生的事情。所以我们将看看这种方法如何用于创建这种随机梯度下降。需要注意的一件事是将预测的概率转换为预测的数字是，我们需要使用 argmax。不幸的是，PyTorch 并不称之为 argmax。相反，PyTorch 只是称之为 max，并且 max 返回两个东西：它返回给定轴上的实际最大值（所以max(1)将返回列的最大值），它返回的第二件事是该最大值的索引。所以 argmax 的等价物是调用 max 然后获取第一个索引的东西：

这就是我们的预测。如果这是 numpy，我们将使用np.argmax()。

preds = predict(net2, md.val_dl).argmax(1)
plots(x_imgs[:8], titles=preds[:8])

所以这是我们手动创建的逻辑回归的预测，在这种情况下，看起来我们几乎全部正确。

接下来我们要尝试摆脱使用库的是我们将尝试避免使用矩阵乘法运算符。相反，我们将尝试手动编写。

因此，接下来，我们将学习一些似乎是一个小的编程概念的东西。但实际上，至少在我看来，这将是我们在这门课程中教授的最重要的编程概念，也可能是你需要构建机器学习算法的所有重要编程概念。这就是广播的概念。我将通过示例展示这个概念。

如果我们创建一个数组 10、6、-4 和一个数组 2、8、7，然后将它们相加，它会依次添加这两个数组的每个分量——我们称之为“逐元素”。

a = np.array([10, 6, -4])
b = np.array([2, 8, 7]) a + b
'''
array([12, 14,  3])
'''

换句话说，我们不必编写循环。在过去，我们必须循环遍历每一个并将它们相加，然后将它们连接在一起。今天我们不必这样做。它会自动为我们发生。因此，在 numpy 中，我们自动获得逐元素操作。我们可以用 PyTorch 做同样的事情。在 Fast AI 中，我们只需添加一个大写 T 来将某物转换为 PyTorch 张量。如果我们将它们相加，结果完全相同。

因此，这些库中的逐元素操作在这种情况下是相当标准的。有趣的不仅仅是因为我们不必编写 for 循环，而且实际上更有趣的是由于这里发生的性能问题。

这是广播的一个稍微复杂的版本。这里有一个名为c的数组。这是一个秩 1 张量。

c = np.array([10,20,30]); c
'''
array([10, 20, 30])
'''

这是之前的矩阵m——秩 2 张量。我们可以添加m + c。那么这里发生了什么？

m + c
'''
array([[11, 22, 33],[14, 25, 36],[17, 28, 39]])
'''

你可以看到它所做的是将[10, 20, 30]添加到每一行。

所以我们可以想象它似乎做了与广播标量相同类型的想法，就像复制了它。然后将这些视为秩 2 矩阵。现在我们可以进行逐元素加法。

问题：通过查看这个例子，它将其复制下来生成新的行。如果我们想要获得新的列，我们应该如何做[56:50]？我很高兴你问了。所以我们会这样做：

现在将其视为我们的矩阵。要让 numpy 这样做，我们需要传入一个矩阵而不是一个向量，而是传入一个具有一列的矩阵（即秩 2 张量）。基本上，numpy 会将这个秩 1 张量视为秩 2 张量，表示一行。换句话说，它是 1 乘 3。所以我们想要创建一个 3 乘 1 的张量。有几种方法可以做到这一点。一种方法是使用np.expand_dims(c,1)，如果你传入这个参数，它会说“请在这里插入一个长度为 1 的轴”。所以在我们的情况下，我们想将其转换为 3 乘 1，所以如果我们说expand_dims(c,1)，它会将形状改变为(3, 1)。所以如果我们看看它是什么样子的，它看起来像一列。

np.expand_dims(c,1).shape
'''
(3, 1)
'''
np.expand_dims(c,1)
'''
array([[10],[20],[30]])
'''

所以如果我们现在加上m，你可以看到它确实做了我们希望它做的事情，即将 10、20、30 添加到列[58:50]：

m + np.expand_dims(c,1)
'''
array([[11, 12, 13],[24, 25, 26],[37, 38, 39]])
'''

现在由于单位轴的位置是如此重要，所以通过实验创建这些额外的单位轴并知道如何轻松地做到这一点是非常有帮助的。在我看来，np.expand_dims并不是最容易的方法。最简单的方法是使用一个特殊的索引None来索引张量。None的作用是在那个位置创建一个长度为 1 的新轴。因此，这将在开始添加一个新的长度为 1 的轴。

c[None]
'''
array([[10, 20, 30]])
'''
c[None].shape
'''
(1, 3)
'''

这将在末尾添加一个新的长度为 1 的轴。

c[:,None]
'''
array([[10],[20],[30]])
'''
c[:,None].shape
'''
(3, 1)
'''

或者为什么不两者都做呢

c[None,:,None].shape
'''
(1, 3, 1)
'''

所以如果你考虑一下，一个张量中有 3 个元素，可以是任何你喜欢的阶数，你可以随意添加单位轴。这样，我们可以决定我们希望广播的方式。所以在 numpy 中有一个非常方便的东西叫做broadcast_to，它的作用是将我们的向量广播到那个形状，并展示给我们看看那会是什么样子。

np.broadcast_to(c, (3,3))
'''
array([[10, 20, 30],[10, 20, 30],[10, 20, 30]])
'''

所以如果你对某个广播操作中发生的事情感到不确定，你可以使用broadcast_to。例如，在这里，我们可以说，而不是(3,3)，我们可以说m.shape，看看将会发生什么。

np.broadcast_to(c, m.shape)
'''
array([[10, 20, 30],[10, 20, 30],[10, 20, 30]])
'''

这就是在我们将其添加到m之前会发生的事情。所以如果我们说将其转换为列，那就是它的样子：

np.broadcast_to(c[:,None], m.shape)
'''
array([[10, 10, 10],[20, 20, 20],[30, 30, 30]])
'''

所以这就是广播的直观定义。现在希望我们可以回到那个 numpy 文档并理解它的含义。

从Numpy 文档 [1:01:37]：

广播这个术语描述了 numpy 在算术运算期间如何处理具有不同形状的数组。在一定的约束条件下，较小的数组（较低秩的张量）被“广播”到较大的数组上，以便它们具有兼容的形状。广播提供了一种向量化数组操作的方法，使循环发生在 C 而不是 Python 中。它可以在不进行不必要的数据复制的情况下实现这一点，并通常导致高效的算法实现。

“向量化”通常意味着使用 SIMD 等技术，以便多个操作同时进行。它实际上并不会进行不必要的数据复制，只是表现得好像进行了复制。所以这就是我们的定义。

现在在深度学习中，你经常处理 4 阶或更高阶的张量，并且经常将它们与 1 阶或 2 阶的张量结合在一起，仅凭直觉正确地执行这些操作几乎是不可能的。所以你真的需要了解规则。

这里是m.shape和c.shape [1:02:45]。所以规则是我们将逐个元素地比较我们两个张量的形状。我们将一次查看一个，并且我们将从末尾开始向前移动。当这两个条件之一为真时，两个维度将是兼容的。所以让我们检查一下我们的m和c是否兼容。所以我们将从末尾开始（首先是尾部维度）并检查“它们是否兼容？”如果维度相等，则它们是兼容的。让我们继续下一个。哦，我们缺少了。c缺少一些东西。如果有东西缺失会发生什么，我们会插入一个 1。这就是规则。所以现在让我们检查一下——这些是否兼容？其中一个是 1，是的，它们是兼容的。所以现在你可以看到为什么 numpy 将一维数组视为一个代表行的 2 阶张量。这是因为我们基本上在前面插入了一个 1。这就是规则。

在对两个数组进行操作时，Numpy/PyTorch 会逐个元素地比较它们的形状。它从尾部维度开始，逐步向前推进。当两个维度兼容时

• 它们是相等的，或者

• 其中之一是 1

数组不需要具有相同数量的维度。例如，如果你有一个256*256*3的 RGB 值数组，并且你想要按不同的值缩放图像中的每种颜色，你可以将图像乘以一个具有 3 个值的一维数组。根据广播规则对齐这些数组的尾部轴的大小，显示它们是兼容的：

Image  (3d array): 256 x 256 x 3
Scale  (1d array):             3
Result (3d array): 256 x 256 x 3

例如，上面是你经常需要做的事情，即你从一幅图像开始，256 像素乘以 256 像素乘以 3 个通道。你想要减去每个通道的平均值。所以你有 256 乘以 256 乘以 3，你想要减去长度为 3 的东西。是的，你可以做到。绝对可以。因为 3 和 3 是兼容的，因为它们是相同的。256 和空是兼容的，因为它会插入一个 1。256 和空是兼容的，因为它会插入一个 1。所以你最终会得到这个（每个通道的平均值）会在所有这个轴（从右边数第二个）上广播，然后整个东西将在这个最左边的轴上广播，所以我们最终会得到一个 256 乘以 256 乘以 3 的有效张量。

有趣的是，数据科学或机器学习社区中很少有人理解广播，大多数时候，例如，当我看到人们为计算机视觉进行预处理时，比如减去平均值，他们总是在通道上写循环。我认为不必这样做非常方便，而且通常不必这样做速度更快。所以如果你擅长广播，你将拥有这种非常少数人拥有的超级有用的技能。这是一种古老的技能。它可以追溯到 APL 的时代。APL 是上世纪 50 年代的，代表着 A Programming Language，肯尼斯·艾弗森写了一篇名为“符号作为思维工具”的论文，他在其中提出了一种新的数学符号。他提出，如果我们使用这种新的数学符号，它会给我们提供新的思维工具，让我们能够思考以前无法思考的事情。他的一个想法就是广播，不是作为计算机编程工具，而是作为数学符号的一部分。因此，他最终将这种符号实现为一种思维工具，作为一种名为 APL 的编程语言。他的儿子继续将其进一步发展为一种名为 J 的软件，这基本上是当你将 60 年来非常聪明的人们致力于这个想法时得到的结果。通过这种编程语言，你可以用一两行代码表达非常复杂的数学思想。我们有 J 是很棒的，但更棒的是这些想法已经进入我们所有人使用的语言中，比如在 Python 中的 numpy 和 PyTorch 库。这些不仅仅是一些小众的想法，它们是思考数学和进行编程的基本方式。

让我举个例子，这种符号作为思维工具的例子。这里我们有 c：

这里我们有 c[None]：

注意现在有两个方括号。这有点像一个一行向量张量。这里是一个小列：

这将会做什么呢？

所以从广播规则的角度来看，我们基本上是将这个列（维度为（3，1））和这个行（维度为（1，3））进行操作。为了使这些符合我们的广播规则，列必须被复制 3 次，因为它需要匹配 3。行必须被复制 3 次以匹配 3。所以现在我有两个矩阵可以进行逐元素乘积。

所以正如你所说，这是我们的外积。

现在有趣的是，突然间这不再是一个特殊的数学案例，而只是广播这个一般概念的一个特定版本，我们可以像外加一样：

或者外大于：

或者其他。所以突然间我们有了这个概念，我们可以用它来构建新的想法，然后我们可以开始尝试这些新的想法。

有趣的是，numpy 有时会使用这个方法。例如，如果你想创建一个网格，numpy 就是这样做的：

实际上返回的是 0、1、2、3、4；一个作为列，一个作为行。所以我们可以说好的，这是 x 网格（xg）逗号 y 网格（yg），现在你可以做类似这样的事情：

所以突然间我们把它扩展成了一个网格。所以有趣的是一些简单的概念是如何被不断地建立和发展的。所以如果你熟悉 APL 或 J，这是一个由许多层层叠加而成的整个环境。虽然在 numpy 中我们没有这样深层次的环境，但你肯定可以看到这种广播的想法在简单的事情中体现出来，比如我们如何在 numpy 中创建一个网格。

这就是广播，现在我们可以使用这个来实现矩阵乘法。那么为什么我们要这样做呢？显然我们不需要。矩阵乘法已经被我们的库完美地处理了。但是很多时候你会发现在各种领域，特别是在深度学习中，会有一些特定类型的线性函数，你想要做的事情并没有完全为你做好。例如，有一个叫做张量回归和张量分解的领域，目前正在得到很大的发展，它们讨论的是如何将高阶张量转化为行、列和面的组合。事实证明，当你这样做时，你基本上可以处理非常高维的数据结构，而不需要太多的内存和计算时间。例如，有一个非常棒的库叫做TensorLy，它为你做了很多这样的事情。所以这是一个非常重要的领域。它涵盖了所有的深度学习，还有很多现代机器学习。所以即使你不会定义矩阵乘法，你很可能会想要找到一些其他略有不同的张量积。所以了解如何做这个是非常有用的。

让我们回过头来看看我们的二维数组和一维数组，秩为 2 的张量和秩为 1 的张量[1:14:27]。

m, c
'''
(array([[1, 2, 3],[4, 5, 6],[7, 8, 9]]), array([10, 20, 30]))
'''

记住，我们可以使用@符号或旧方法np.matmul进行矩阵乘法。当我们这样做时，实际上我们基本上是在说1*10 + 2*20 + 3*30 = 140，所以我们对每一行都这样做，然后我们可以继续对下一行做同样的事情，依此类推以获得我们的结果。

m @ c  # np.matmul(m, c)
'''
array([140, 320, 500])
'''

你也可以在 PyTorch 中这样做

T(m) @ T(c)
'''
140320500
[torch.LongTensor of size 3]
'''

但是（m * c）这不是矩阵乘法。那是什么？逐元素广播。但请注意，它创建的数字[10, 40, 90]正是我在做矩阵乘法的第一部分时需要计算的三个确切数字（1*10 + 2*20 + 3*30）。

m * c
'''
array([[ 10,  40,  90],[ 40, 100, 180],[ 70, 160, 270]])
'''

换句话说，如果我们对列求和，即轴等于 1，我们就得到了矩阵向量乘积：

(m * c).sum(axis=1)
'''
array([140, 320, 500])
'''

所以我们可以在不依赖库的特殊帮助下做这些事情。现在让我们将这扩展到矩阵矩阵乘积。

matrixmultiplication.xyz/

矩阵矩阵乘积看起来是这样的。有一个很棒的网站叫做matrixmultiplication.xyz，它向我们展示了当我们将两个矩阵相乘时会发生什么。从操作的角度来看，这就是矩阵乘法。换句话说，我们刚刚做的是首先取第一列和第一行相乘得到 15：

然后我们取第二列和第一行得到 27：

所以我们基本上是在做我们刚刚做的事情，矩阵向量乘积，我们只是做了两次。一次用这一列（左边），一次用那一列（右边），然后我们把这两个连接在一起。所以我们现在可以继续这样做：

(m * n[:,0]).sum(axis=1)
'''
array([140, 320, 500])
'''
(m * n[:,1]).sum(axis=1)
'''
array([ 25, 130, 235])
'''

这就是我们矩阵乘法的两列。

我不想让我们的代码太乱，所以我不打算真的使用那个，但是现在我们有了它，如果我们想要的话。我们不再需要使用 torch 或 numpy 矩阵乘法。我们有自己的方法可以使用，只使用逐元素操作、广播和求和。

这是我们从头开始的逻辑回归类[1:18:37]。我只是把它复制到这里。

class LogReg(nn.Module):def __init__(self):super().__init__()self.l1_w = get_weights(28*28, 10)  # Layer 1 weightsself.l1_b = get_weights(10)         # Layer 1 biasdef forward(self, x):x = x.view(x.size(0), -1)x = x @ self.l1_w + self.l1_b return torch.log(softmax(x))

这是我们实例化对象的地方，复制到 GPU。我们创建一个优化器，我们将在稍后学习。然后我们调用 fit。

net2 = LogReg().cuda()
opt=optim.Adam(net2.parameters())fit(net2, md, n_epochs=1, crit=loss, opt=opt, metrics=metrics)
'''
[ 0\.       0.31102  0.28004  0.92406]
'''

所以目标是现在重复这一过程，而无需调用 fit。为此，我们需要一个循环，每次抓取一个小批量的数据。对于每个小批量的数据，我们需要将其传递给优化器，并说“请尝试为这个小批量提供稍微更好的预测”。

正如我们学到的，为了一次抓取训练集的一个小批次，我们必须向模型数据对象请求训练数据加载器。我们必须将其包装在iter中以创建一个迭代器或生成器。这样就给我们了我们的数据加载器。所以 PyTorch 将其称为数据加载器。我们实际上编写了自己的 Fast AI 数据加载器，但基本上是相同的思路。

dl = iter(md.trn_dl) # Data loader

接下来我们要做的是获取 x 和 y 张量，从我们的数据加载器中获取下一个。将其包装在Variable中以表明我需要能够对使用此计算的导数进行求导。因为如果我不能求导，那么我就无法得到梯度，也无法更新权重。而且我需要将其放在 GPU 上，因为我的模块在 GPU 上（net2 = LogReg().cuda()）。所以现在我们可以将该变量传递给我们实例化的对象（即我们的逻辑回归）。记住，我们的模块，我们可以将其用作函数，因为这就是 PyTorch 的工作原理。这给我们提供了一组预测，就像我们以前看到的那样。

xt, yt = next(dl)
y_pred = net2(Variable(xt).cuda())

现在我们可以检查损失[1:20:41]。我们定义损失为负对数似然损失对象。我们将在下一课中学习如何计算它，现在，只需将其视为分类问题的均方根误差。所以我们也可以像调用函数一样调用它。所以你可以看到这在 PyTorch 中是一个非常普遍的想法，将一切都理想地视为函数。在这种情况下，我们有一个负对数似然损失对象，我们可以将其视为函数。我们传入我们的预测和实际值。同样，实际值需要转换为变量并放在 GPU 上，因为损失是我们实际想要求导的东西。这给我们带来了我们的损失，就是这样。

l = loss(y_pred, Variable(yt).cuda())
print(l)
'''
Variable containing:2.4352
[torch.cuda.FloatTensor of size 1 (GPU 0)]
'''

这是我们的损失 2.43。所以它是一个变量，因为它是一个变量，它知道它是如何计算的。它知道它是用这个损失函数（loss）计算的。它知道预测是用这个网络（net2）计算的。它知道这个网络由这些操作组成：

所以我们可以自动获取梯度。要获取梯度，我们调用l.backward()。记住l是包含我们损失的东西。所以l.backward()是添加到任何变量的东西。然后调用.backward()，这表示请计算梯度。这样就计算了梯度并将其存储在内部，基本上对于用于计算的每个权重/参数，现在都存储在.grad中，我们稍后会看到，但基本上存储了梯度。然后我们可以调用optimizer.step()，我们很快将手动执行这一步。这部分表示请让权重变得更好一点。

因此，optimizer.step()正在做的是，如果你有一个非常简单的函数像这样，优化器所做的就是说好的，让我们选择一个起始点，计算损失的值，计算导数告诉我们哪个方向是向下的。因此，它告诉我们我们需要朝那个方向走。然后我们迈出一小步。

然后我们再次取导数，采取一个小步骤，并重复，直到最终我们采取的步骤如此之小以至于停止。

这就是梯度下降的作用。小步骤有多大？基本上在这里取导数，所以让我们说导数是 8。然后我们乘以一个小数，比如 0.01，这告诉我们要采取什么步骤大小。这里的这个小数被称为学习率，它是设置的最重要的超参数。如果你选择的学习率太小，那么你的下降步骤将会很小，而且会花费很长时间。学习率太大，你会跳得太远，然后你会跳得太远，最终会发散而不是收敛。

在这节课中我们不会讨论如何选择学习率，但在深度学习课程中，我们实际上向你展示了一种非常可靠地选择一个非常好的学习率的特定技术。

因此，基本上正在发生的是，我们计算导数，我们调用执行step的优化器，换句话说，根据梯度和学习率更新权重。

希望在这样做之后，我们的损失比之前更好。因此，我刚刚重新运行了这个，得到了一个 4.16 的损失。

一步之后，现在是 4.03。

所以它按照我们希望的方式运行，基于这个小批量，它更新了我们网络中的所有权重，使它们比之前更好。因此，我们的损失下降了。

欢迎回到机器学习！这周最令人兴奋的事情当然是 Fast AI 现在在 pip 上了，所以你可以pip install fastai：

这周有几个来自 USF 学生的很酷的内核。我想强调两个都来自文本规范化竞赛的内核，该竞赛旨在尝试将标准英语文本转换为文本，还有一个俄语的。你要尝试识别可能是“第一，第二，第三”之类的东西，并说这是一个基数，或者这是一个电话号码或其他什么。我快速搜索了一下，发现学术界曾尝试使用深度学习来做这个，但他们没有取得太多进展，实际上我注意到Alvira 的内核在这里得到了 0.992 的排名，我认为是前 20 名。这完全是启发式的，是特征工程的一个很好的例子。在这种情况下，整个事情基本上完全是特征工程。基本上是通过查看和使用大量正则表达式来弄清楚每个标记是什么。我认为她在这里做得很好，清楚地列出了所有不同的部分以及它们如何相互配合。她提到她也许希望将这个变成一个库，我认为这将是很好的。你可以使用它来提取文本中的所有部分。这是自然语言处理社区希望能够做到的事情，而不需要像这样大量手写代码。但目前，我很感兴趣看看获胜者到底做了什么，但我还没有看到机器学习被用来做这个特别好。也许最好的方法是将这种特征工程与一些机器学习结合起来。但我认为这是一个有效特征工程的很好例子。

这位是另一位 USF 的学生，她做了类似的事情，得到了类似的分数，但使用了自己不同的规则。同样，这也会让你在排行榜上获得一个不错的位置。所以我觉得看到我们的一些学生参加比赛并通过基本的手写启发式方法获得前 20 名结果的例子很有趣。这就是，例如，六年前的计算机视觉仍然是这样。基本上最好的方法是大量仔细手写的启发式方法，通常结合一些简单的机器学习。所以我认为随着时间的推移，这个领域肯定在努力向更多自动化方向发展。

实际上有趣的是，在刚刚结束的安全驾驶员预测比赛中，一个 Netflix 奖获得者赢得了这个比赛，他发明了一种处理结构化数据的新算法，基本上不需要任何特征工程。所以他使用了五个深度学习模型和一个梯度提升机获得了第一名。他的基本方法与我们迄今为止在这门课程中学到的以及明天将要学习的内容非常相似，即使用全连接的神经网络和独热编码，特别是我们将要学习的嵌入。但他有一个非常聪明的技巧，就是在这个比赛中有很多未标记的数据。换句话说，他们不知道那个司机是否会提出索赔。所以当你有一些标记和一些未标记的数据时，我们称之为半监督学习。在现实生活中，大多数学习都是半监督学习。在现实生活中，通常有一些被标记的东西和一些未被标记的东西。所以这是最实用的学习方式。而结构化数据是公司日常处理的最常见的数据类型。所以这个比赛是一个半监督的、结构化数据比赛，使其非常实用。

所以他赢得比赛的技巧是进行数据增强，你们在深度学习课程中学到的，基本上就是这样的想法，比如如果你有图片，你会水平翻转它们或者稍微旋转一下。数据增强意味着创建新的数据示例，这些示例是你已经拥有的数据的略微不同的版本。他的做法是对于数据中的每一行，他会随机地用另一行替换 15%的变量。所以现在每一行代表的是原始行的 85%混合，15%是随机选择的另一行。这是一种随机改变数据的方法，然后他使用了一种叫做自动编码器的东西，我们可能要等到深度学习课程的第二部分才会学习，但自动编码器的基本思想是你的因变量与自变量相同。换句话说，你试图预测你的输入，如果你被允许进行恒等变换，例如，显然可以轻松地预测输入，但自动编码器的技巧是至少在一个层中具有比输入更少的激活。所以如果你的输入是一个百维向量，你通过一个 100 乘以 10 的矩阵，创建十个激活，然后必须从中创建原始的 100 维向量。那么你基本上已经有效地对其进行了压缩。事实证明，这种类型的神经网络被迫在数据中找到相关性、特征和有趣的关系，即使数据没有标记。所以他使用了这个而不是进行任何手工工程。这些是一些有趣的方向，如果你继续进行机器学习研究，特别是如果你明年参加深度学习课程的第二部分，你会学到的。你可以看到特征工程正在消失，这就是刚刚一个小时前。所以这确实是非常近期的。但这是我长时间以来看到的最重要的突破之一。

笔记本

这（LogReg）是我们创建的那个小手写的nn.Module类[9:15]。我们定义了损失。我们定义了学习率，我们定义了优化器。optim.SGD是我们接下来要尝试手写的东西。所以nn.NLLLoss和optim.SGD，我们是从 PyTorch 中借鉴的，但我们自己编写了模块LogReg和训练循环。

net2 = LogReg().cuda()
loss=nn.NLLLoss()
learning_rate = 1e-2
optimizer=optim.SGD(net2.parameters(), lr=learning_rate)
for epoch in range(1):losses=[]dl = iter(md.trn_dl)for t in range(len(dl)):# Forward pass: compute predicted y and loss by passing x to# the model.xt, yt = next(dl)y_pred = net2(V(xt))l = loss(y_pred, V(yt))losses.append(l) # Before the backward pass, use the optimizer object to zero# all of the gradients for the variables it will update# (which are the learnable weights of the model)optimizer.zero_grad() # Backward pass: compute gradient of the loss with respect# to model parametersl.backward() # Calling the step function on an Optimizer makes an update# to its parametersoptimizer.step()val_dl = iter(md.val_dl)val_scores = [score(*next(val_dl)) for i in range(len(val_dl))]print(np.mean(val_scores))

所以基本思想是我们将经历一些时期[9:39]，所以让我们经历一个时期。我们将跟踪每个小批次的损失，以便在最后报告。我们将把我们的训练数据加载器转换为迭代器，以便我们可以循环遍历它 - 遍历每个小批次。现在我们可以继续说for张量in数据加载器的长度，然后我们可以调用next来从该迭代器中获取下一个自变量和因变量。

然后记住，我们可以通过调用模型来将 x 张量（xt）传递给我们的模型，就好像它是一个函数一样。但首先，我们必须将其转换为一个变量。上周，我们在输入Variable(blah).cuda()来将其转换为一个变量，Fast AI 中的一个简写是大写V。所以张量的大写T，变量的大写V。这只是 Fast AI 中的一个快捷方式。这将返回我们的预测。

接下来我们需要做的是计算我们的损失，因为如果我们没有计算损失，就无法计算损失的导数。所以损失接受预测值和实际值。实际值再次是 y 张量，我们必须将其转换为一个变量。变量跟踪所有计算步骤。实际上，在 PyTorch 网站上有一个很棒的教程。

接下来我们需要做的是计算我们的损失，因为如果我们没有计算损失，就无法计算损失的导数。所以损失接受预测值和实际值。实际值再次是 y 张量，我们必须将其转换为一个变量。变量跟踪所有计算步骤。实际上，在 PyTorch 网站上有一个很棒的教程。在 PyTorch 网站上，有一个教程部分，其中有一个关于 Autograd 的教程。Autograd 是随 PyTorch 一起提供的自动微分包的名称，它是自动微分的实现。因此，Variable 类是真正的关键类，因为它可以将张量转换为我们可以跟踪其梯度的东西。基本上在这里他们展示了如何创建一个变量，对变量进行操作，然后可以回头查看 grad 函数（grad_fn），这是它跟踪以计算梯度的函数。因此，当我们对这个变量和从该变量计算出的变量进行更多操作时，它会继续跟踪。稍后，我们可以进行.backward()，然后打印.grad并找出梯度。所以你会注意到我们从未定义过梯度，我们只是定义它为(x + 2)² * 3之类的表达式，它可以计算梯度。

这就是为什么我们需要将其转换为一个变量。所以l现在是一个包含损失的变量。它包含了这个小批量的损失的单个数字。但它不仅仅是一个数字。它是一个作为变量的数字，所以它是一个知道如何计算的数字。

我们将把这个损失添加到我们的数组中，这样我们以后可以得到它的平均值。现在我们要计算梯度。所以l.backward()是一个指令，表示计算梯度。所以记住当我们调用网络时，实际上是调用我们的前向函数。这就像是向前走一遍。然后向后就像是使用链式法则向后计算梯度。

optimizer.step()是我们即将编写的内容，即根据梯度和学习率更新权重。zero_grad()，我们将在手动编写时解释。

然后最后，我们可以将验证数据加载器转换为迭代器。然后我们可以遍历它的长度，每次取出一个 x 和 y，并询问我们定义的分数，即你预测了哪个，实际上是哪个，并检查它们是否相等。然后这些的平均值将是我们的准确率。

def score(x, y):y_pred = to_np(net2(V(x)))return np.sum(y_pred.argmax(axis=1) == to_np(y))/len(y_pred)

问题: 为什么你要将其转换为迭代器而不是使用普通的 Python 循环[14:53]？我们正在使用普通的 Python 循环，所以问题实际上是与什么进行比较。所以，也许你在考虑的替代方案可能是，我们可以使用类似带有索引器的列表。问题在于我们每次获取一个新的小批次时，我们希望它是随机的。我们希望有一个不同的洗牌过的东西。所以这个for t in range(len(dl))，你实际上可以无限迭代。你可以循环遍历它任意次数。所以这种想法在不同的语言中被称为不同的东西，但很多语言称之为流处理，这是一种基本的想法，而不是说我想要第三个或第九个东西，而是说我想要下一个东西。这对网络编程非常有用——从网络中获取下一个东西。对于 UI 编程也非常有用——获取下一个事件，比如有人点击了一个按钮。事实证明，这对于这种数值编程也非常有用——就像我只想要下一个数据批次。这意味着数据可以是任意长的，因为我们一次只获取一部分。我想简短的回答是因为这是 PyTorch 的工作方式。PyTorch 的数据加载器被设计为以这种方式调用。所以 Python 有这个生成器的概念，它是一种可以创建行为像迭代器的函数的方式。Python 已经认识到这种流处理编程方法非常方便和有用，并且在各处支持它。所以基本上任何你使用for ... in循环的地方，任何你使用列表推导的地方，这些东西都可以是生成器或迭代器。通过这种方式编程，我们获得了很大的灵活性。听起来对吗，Terrence？你是编程语言专家。

Terrence: 是的，我的意思是你说的很对。你可能会提到空间的问题，但在这种情况下，所有这些数据都必须在内存中，因为我们有…

Jeremy: 不需要在内存中。事实上，大多数情况下，使用 PyTorch，小批次将根据需要从分布在磁盘上的单独图像中读取，所以大多数情况下它不在内存中。

Terrence: 但一般来说，你希望尽可能少地一次性保存在内存中。所以流处理的想法也很棒，因为你可以进行组合。你可以将数据传送到另一台机器。

Jeremy: 是的，组合很棒。你可以从这里获取下一个东西，然后将其发送到下一个流中，然后你可以获取它并做其他事情。

Terrence: 你们都认识到，当然，在命令行管道和 I/O 重定向中。

Jeremy: 谢谢，Terrence。与真正知道自己在谈论什么的人一起工作的好处。

现在让我们拿掉优化器。我们唯一剩下的是负对数似然损失函数，实际上我们也可以替换。我们在笔记本中有 Yannet 从头开始编写的实现。正如我们之前学到的那样，只需要一行代码。你可以用一个 if 语句来做到。所以我不知道为什么我如此懒惰，要包括这个。

所以我们要做的是，再次获取我们自己编写的模块（逻辑回归模块）。我们将再次进行一个 epoch。我们将循环遍历迭代器中的每个元素。我们将获取我们的独立和依赖变量用于小批量，将其传递给我们的网络，计算损失。所以这一切和以前一样，但现在我们要摆脱optimizer.step()，我们要手动做。所以基本的技巧是，正如我提到的，我们不会手动进行微积分。我们调用l.backward()来自动计算梯度，这将填充我们的矩阵。这就是我们构建的模块：

所以线性层权重的权重矩阵，我们称为l1_w，偏差我们称为l1_b。它们是我们创建的属性。所以我只是把它们放到了叫做w和b的东西里，基本上是为了节省一些输入。所以 w 是我们的权重，b 是我们的偏差。所以权重，记住权重是一个变量，要从变量中获取张量，我们必须使用.data。所以我们想要更新这个变量中的实际张量，所以我们说：

w.data -= w.grad.data * lr

• -=我们想要朝着梯度的相反方向前进。梯度告诉我们哪个方向是向上的。我们想要向下。

• w.grad.data * lr当前梯度乘以学习率。

这就是梯度下降的公式。正如你所看到的，这是你可能想象到的最简单的事情。就像更新权重等于它们现在的值减去梯度乘以学习率一样。对偏差也是同样的操作。

net2 = LogReg().cuda()
loss_fn=nn.NLLLoss()
lr = 1e-2
w,b = net2.l1_w,net2.l1_bfor epoch in range(1):losses=[]dl = iter(md.trn_dl)for t in range(len(dl)):xt, yt = next(dl)y_pred = net2(V(xt))l = loss(y_pred, Variable(yt).cuda())losses.append(loss)# Backward pass: compute gradient of the loss with respect # to model parametersl.backward()w.data -= w.grad.data * lrb.data -= b.grad.data * lrw.grad.data.zero_()b.grad.data.zero_()   val_dl = iter(md.val_dl)val_scores = [score(*next(val_dl)) for i in range(len(val_dl))]print(np.mean(val_scores))

问题：当我们在顶部执行next时，当循环结束时，我们如何获取下一个元素？所以这个(**for** t **in** range(len(dl)):)是在长度范围内的每个索引进行循环，所以这是 0、1、2…在这个循环结束时，它将打印出验证集的平均值，然后回到 epoch 的开始，在这一点上，它将创建一个新的迭代器。所以基本上在 Python 的后台当你调用iter(md.trn_dl)时，它基本上告诉它重置其状态以创建一个新的迭代器。如果你对它是如何工作感兴趣，所有的代码都可以供你查看。md.trn_dl是fastai.dataset.ModelDataLoader，所以我们可以看一下它的代码，看看它是如何构建的。所以你可以在这里看到，__next__函数跟踪了它在self.i中经历了多少次，这里是__iter__函数，当你创建一个新的迭代器时会调用这个函数。你可以看到它将其传递给另一个类型为 DataLoader 的东西，然后如果你对它是如何实现的感兴趣，你可以查看 DataLoader。

所以我们编写的 DataLoader 基本上使用多线程，允许同时进行多个操作。这非常简单。只有大约一屏的代码，所以如果你对简单的多线程编程感兴趣，这是一个值得一看的好东西。

问题：为什么你把这个包装在for epoch in range(1)中，因为这只会运行一次？因为在现实生活中，我们通常会运行多个 epochs。就像在这种情况下，因为这是一个线性模型，它实际上在一个 epoch 内训练到了它能达到的最好状态，所以如果我在这里输入 3，你会看到在第一个 epoch 之后它实际上不会有太大的改进。但当我们回到顶部时，我们将看一些稍微更深入和更有趣的版本，这将需要更多的 epochs。所以如果我要把这个转换成一个函数，我会像这样写def train_mdl，你会传入一些 epochs 的数量之类的东西。

要记住的一件事是，当你创建这些神经网络层时，记住这个（LogReg()）在 PyTorch 看来只是一个 nn.Module ——我们可以将其用作一个层，我们可以将其用作一个函数，我们可以将其用作一个神经网络。PyTorch 不认为这些是不同的东西。因此，这可能是另一个网络中的一层。那么梯度是如何工作的呢？所以如果你有一个层，我们可以将其看作是激活或通过某些其他非线性/线性激活函数计算出的一些激活。然后从该层，很可能我们会将其通过矩阵乘积来创建一些新层。因此，如果我们抓取像这样的一个激活，实际上会用来计算每一个输出。

因此，如果要计算导数，你必须知道这个权重矩阵如何影响每个输出，并将所有这些加在一起以找到一个激活在所有输出上的总影响。这就是为什么在 PyTorch 中你必须告诉它何时将梯度设置为零。因为想法是你可能有很多不同的损失函数或者下一组激活中的很多不同的输出，所有这些都会增加或减少你的梯度。所以你基本上必须说，好的，这是一个新的计算 — 重置。所以这就是我们这样做的地方：

在我们执行l.backward()之前，我们说重置。所以让我们拿出我们的权重，拿出梯度，拿出它们指向的张量，然后zero_。在 PyTorch 中，下划线作为后缀意味着“原地”，听起来像一个小技术细节，但记住这一点非常有用。几乎每个函数都有一个下划线版本的后缀，它会原地执行操作。所以通常 zero 返回一个特定大小的零张量，所以 zero_ 意味着用一堆零替换这个内容。

好了，就是这样。这就是从头开始的 SGD。如果我去掉我的菜单栏，我们可以正式说它适合在一个屏幕内。当然，我们还没有得到我们的逻辑回归的定义，那是另外半个屏幕，但基本上没有太多内容。

问题：为什么我们需要多个 epochs？简单回答就是，假设我们的学习率很小。那么它就不会走得很远。没有什么规定说通过一个 epoch 就足以让你达到目标。所以这就像是，好吧，让我们增加学习率。当然，我们可以增加学习率，但谁能说最高的学习率是稳定学习的足够多呢。对于大多数数据集和大多数架构来说，一个 epoch 很少能让你达到最好的结果。线性模型的行为非常好。所以你通常可以使用更高的学习率并更快地学习。此外，通常无法获得如此好的准确性，因此也没有太多的提升空间。因此，进行一个 epoch 将是罕见的。

然而，我们将从应用简单的线性模型开始。对我来说有点可怕，因为我们将进行 NLP，而我们的 NLP 专家就在房间里。因此，如果我搞砸了，David，请大声告诉我。NLP 指的是我们处理自然语言文本的任何建模。有趣的是，我们将看一个情况，线性模型在解决特定问题时非常接近最先进技术。几周前，我实际上使用递归神经网络超越了最先进技术，但这实际上将向你展示线性模型非常接近最先进技术。

现在在自然语言处理中，你必须将文本转换为单词列表，这就是所谓的标记化。这实际上并不是微不足道的，因为如果这实际上是This movie is good.或This “movie” is good.，你如何处理标点符号呢？更有趣的是，如果这是This "movie" isn’t good.，你如何将一段文本转换为标记列表呢？一个好的标记器会将这个转换为：

之前：This "movie" isn’t good.

之后：This " movie " is n’t good .

所以你可以看到，在这个版本中，如果我现在按空格分割这个文本，每个标记要么是一个单独的标点符号，要么是这个后缀n't，被视为一个单词。这就是我们可能想要对这段文本进行标记化的方式，因为你不希望good.成为一个对象。没有good.或"movie"是一个对象的概念。所以标记化是我们交给标记器的事情。Fast AI 中有一个我们可以使用的标记器，这就是我们如何使用标记器创建我们的术语文档矩阵：

veczr = CountVectorizer(tokenizer=tokenize)

sklearn 有一个相当标准的 API，这很好。我相信你以前见过几次。一旦我们建立了某种“模型”，我们可以把CountVectorizer看作是一种模型，这只是定义它将要做什么。我们可以调用fit_transform来执行这个操作。

trn_term_doc = veczr.fit_transform(trn)
val_term_doc = veczr.transform(val)

在这种情况下，fit_transform将创建词汇表，并基于训练集创建术语文档矩阵。transform有点不同。它表示使用先前拟合的模型，这在这种情况下意味着使用先前创建的词汇表。我们不希望验证集和训练集在矩阵中有不同顺序的单词。因为那样它们会有不同的含义。所以这里说的是使用相同的词汇表为验证集创建一个词袋。

问题：如果验证集中有不同于训练集的单词集合怎么办[1:11:40]？这是一个很好的问题。通常，大多数这些词汇创建方法会为未知单词设定一个特殊标记。有时你也可以说，如果一个单词出现少于三次，就称之为未知。但是，如果你看到了以前没有见过的东西，就称之为未知。所以（即“未知”）只会成为词袋中的一列。

当我们创建这个术语文档矩阵时，训练集有 25,000 行，因为有 25,000 条电影评论，有 75,132 列，这是唯一单词的数量。

trn_term_doc
'''
<25000x75132 sparse matrix of type '<class 'numpy.int64'>'with 3749745 stored elements in Compressed Sparse Row format>
'''

现在，大多数文档并不包含这 75,132 个单词中的大部分。所以我们不想把它实际存储为内存中的普通数组。因为这样会非常浪费。所以，我们将其存储为稀疏矩阵。稀疏矩阵的作用是将其存储为一种只指示非零值位置的东西。所以它会说，文档编号 1，单词编号 4 出现了 4 次。文档编号 1，术语编号 123 出现了一次，依此类推。

(1, 4) → 4
(1, 123) → 1

这基本上就是它的存储方式。实际上有许多不同的存储方式，如果你学习 Rachel 的计算线性代数课程，你将了解不同类型的存储方式以及为什么选择它们，如何转换等等。但它们都类似于这样，你不需要太担心细节。重要的是它是高效的。

所以我们可以拿到第一条评论，这给了我们一个 75,000 个长稀疏的一行长矩阵，其中有 93 个存储元素。换句话说，这些单词中有 93 个实际上在第一个文档中使用。

trn_term_doc[0]
'''
<1x75132 sparse matrix of type '<class 'numpy.int64'>'with 93 stored elements in Compressed Sparse Row format>
'''

我们可以通过说veczr.get_feature_names来查看词汇表，这给我们提供了词汇表。这里是一些特征名称的元素的示例：

vocab = veczr.get_feature_names(); vocab[5000:5005]
'''
['aussie', 'aussies', 'austen', 'austeniana', 'austens']
'''

我并没有故意选择那个有澳大利亚的，但那是重要的单词，显然😄我这里没有使用分词器。我只是按空格分割，所以这与矢量化器所做的不完全相同。但为了简化事情，让我们拿到所有小写单词的集合。通过将其设置为集合，我们使它们成为唯一的。所以这大致是可能出现的单词列表。

w0 = set([o.lower() for o in trn[0].split(' ')]); w0
'''
{'a','absurd','an','and','audience','be','better','briefly.','by','can',...
}
'''
len(w0)
'''
91
'''

这个长度是 91，与 93 相似，唯一的区别是我没有使用真正的分词器。所以基本上就是这样。创建了这个唯一的单词列表并将它们映射。我们可以通过调用veczr.vocabulary_来查找特定单词的 ID。所以这就像veczr.get_feature_names的反向映射，它将整数映射到单词，veczr.vocabulary_将单词映射到整数。

veczr.vocabulary_['absurd']
'''
1297
'''

所以我们看到“荒谬”在第一个文档中出现了两次，所以让我们检查一下：

trn_term_doc[0,1297]
'''
2
'''

这就是，这是 2。否则，不幸的是，澳大利亚人没有出现在与猪有不自然关系的电影中，所以这是零：

trn_term_doc[0,5000]
'''
0
'''

这就是我们的术语文档矩阵。

问题：它是否关心单词之间的关系，比如单词的顺序？不，我们抛弃了顺序。这就是为什么它是一个词袋。我并不是在声称这一定是一个好主意。我要说的是，在过去几十年里进行的绝大多数自然语言处理工作通常使用这种表示，因为我们并不真正知道更好的方法。如今，我们越来越多地使用递归神经网络，我们将在第 1 部分的最后一个深度学习课程中学习。但有时这种表示方法效果还不错，实际上在这种情况下也会效果不错。

事实上，当我在我的电子邮件公司 FastMail 时，我们做的很多垃圾邮件过滤都使用了下一个技术朴素贝叶斯，这是一种词袋方法。如果你收到很多包含“伟哥”一词的电子邮件，而且它们一直是垃圾邮件，你从来没有收到朋友谈论“伟哥”的电子邮件，那么很可能说“伟哥”的东西无论语言的细节如何，都可能来自垃圾邮件发送者。所以这就是使用术语文档矩阵进行分类的基本理论。

现在这就是理论和实践之间的区别。理论上，朴素贝叶斯听起来还可以，但是它是朴素的，不像泰勒，它是朴素的。所以泰勒可能会说，与其假设我应该使用这些系数r，为什么不让我们学习它们呢？所以让我们学习它们。我们完全可以学习它们。

那么让我们创建一个逻辑回归，并拟合一些系数。这实际上会给我们提供与之前完全相同的功能形式，但现在我们不再使用理论上的r和理论上的b，而是根据逻辑回归计算这两个值。这样更好。

m = LogisticRegression(C=1e8, dual=True)
m.fit(x, y)
preds = m.predict(val_term_doc)
(preds==val_y).mean()
'''
0.85504000000000002
'''

所以这有点像是，为什么要基于某种理论模型进行某些操作呢？因为理论模型几乎永远不会像数据驱动模型那样准确。因为理论模型，除非你在处理某种物理问题或者某种你认为这实际上是世界如何运作的东西，否则没有……我不知道，我们是在真空中工作，有确切的重力等等。但是在现实世界中，事情是这样的——更好的方法是学习你的系数并计算它们。

Yannet：这个dual=True是什么[1:31:30]？我希望你会忽略，不会注意到，但你看到了。基本上，在这种情况下，我们的术语文档矩阵比高度更宽。逻辑回归有一个几乎在数学上等价的重新表述，当它比高度更宽时，速度会更快。简短的答案是，每当它比高度更宽时，加上dual=True，它会运行得更快。这只需要 2 秒。如果你不在这里加上它，那么需要几分钟。因此，在数学中，有一种问题的双重版本的概念，这些版本在某些情况下可能更适合。

这是二值化版本[1:32:20]。差不多一样。所以你可以看到我用术语文档矩阵的符号进行了拟合，并用val_term_doc.sign()进行了预测。

m = LogisticRegression(C=1e8, dual=True)
m.fit(trn_term_doc.sign(), y)
preds = m.predict(val_term_doc.sign())
(preds==val_y).mean()
'''
0.85487999999999997
'''

现在问题是，对于我们词汇表中大约有 75,000 个术语的每个术语都会有一个系数，考虑到我们只有 25,000 条评论，这似乎是很多系数[1:32:38]。所以也许我们应该尝试对此进行正则化。

所以我们可以使用内置在 sklearn 的 LogisticRegression 类中的正则化，它使用的参数是C。这有点奇怪，较小的参数表示更多的正则化。这就是为什么我使用1e8基本上关闭了正则化。

所以如果我打开正则化，将其设置为 0.1，那么现在是 88%：

m = LogisticRegression(C=0.1, dual=True)
m.fit(x, y)
preds = m.predict(val_term_doc)
(preds==val_y).mean()
'''
0.88275999999999999
'''

这是有道理的。你会认为对于 25,000 个文档的 75,000 个参数，很可能会过拟合。事实上，它确实过拟合了。因此，这是添加 L2 正则化以避免过拟合。

我之前提到过，除了 L2（查看权重的平方）之外，还有 L1（仅查看权重的绝对值）[1:33:37]。

我之前在措辞上有点粗心，我说 L2 试图将事物变为零。这在某种程度上是正确的，但如果你有两个高度相关的事物，那么 L2 正则化会将它们一起降低。它不会使其中一个变为零，另一个变为非零。因此，L1 正则化实际上具有这样的特性，它会尽可能使尽可能多的事物变为零，而 L2 正则化具有这样的特性，它倾向于使一切变得更小。实际上，在任何现代机器学习中，我们并不关心这种差异，因为我们很少直接尝试解释系数。我们尝试通过我们学到的技术来审查我们的模型。我们关心 L1 与 L2 的原因仅仅是哪一个在验证集上的错误更小。你可以尝试两种方法。使用 sklearn 的 LogisticRegression，L2 实际上会更快，因为你不能使用dual=True，除非你使用 L2，而 L2 是默认的。所以我并没有太担心这种差异。

所以你可以看到，如果我们使用正则化和二值化，我们实际上做得相当不错：

m = LogisticRegression(C=0.1, dual=True)
m.fit(trn_term_doc.sign(), y)
preds = m.predict(val_term_doc.sign())
(preds==val_y).mean()
'''
0.88404000000000005
'''

问题：在我们学习关于类似于组合 L1 和 L2 的 Elastic-net 之前。我们可以这样做吗？是的，你可以这样做，但需要更深层次的模型。我从来没有见过有人发现这有用。

最后我要提到的是，当你做 CountVectorizer 时，你也可以要求 n-gram。默认情况下，我们得到的是单字，也就是单个单词。但是如果我们说ngram_range=(1,3)，那也会给我们二元组和三元组。

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']
'''

也就是说，如果我现在说好的，让我们继续使用 CountVectorizer，并获取特征名称，现在我的词汇表包括二元组：'by vast'，'by vengeance'和三元组：'by vengeance .'，'by vera miles'。所以现在做的事情与之前相同，但在分词之后，它不仅仅是抓取每个单词并说这是你的词汇表的一部分，而是抓取相邻的每两个单词和每三个单词。这实际上对利用词袋方法非常有帮助，因为我们现在可以看到not good与not bad与not terrible之间的区别。甚至像"good"这样的词可能是讽刺的。因此，实际上使用三元组特征将使朴素贝叶斯和逻辑回归变得更好。这确实让我们走得更远，使它们变得更有用。

问题：我有一个关于分词器的问题。你说max_features，那么这些二元组和三元组是如何选择的？由于我使用的是线性模型，我不想创建太多特征。即使没有max_features，它实际上也可以正常工作。我想我有大约 7000 万个系数。它仍然有效。但没有必要有 7000 万个系数。所以如果你说max_features=800,000，CountVectorizer 将按照所有内容出现的频率对词汇表进行排序，无论是单字、二元组还是三元组，然后在前 800,000 个最常见的 n 元组之后截断。N-gram 只是单字、二元组和三元组的通用词。

所以这就是为什么train_term_doc.shape现在是 25,000 乘以 800,000。如果你不确定最大值应该是多少，我只是选择了一个非常大的数字，不太担心，似乎也没问题。这并不是非常敏感的。

好了，我们时间到了，明天我们将看到什么…顺便说一句，我们可以用我们的 PyTorch 版本替换这个 LogisticRegression：

明天，我们实际上会在 Fast AI 库中看到一个可以做到这一点的东西，但明天我们还将看到如何将逻辑回归和朴素贝叶斯结合在一起，以获得比任何一个都更好的结果。然后我们将学习如何从那里开始创建一个更深层的神经网络，以获得几乎是结构化学习的最新结果。好的，到时候见。