ShowMeAI-人工智能工具笔记-十-

ShowMeAI 人工智能工具笔记（十）

T81-558 ｜ 深度神经网络应用-全案例实操系列(2021最新·完整版) - P46：L8.5- 2020年春季Kaggle深度学习应用竞赛 - ShowMeAI - BV15f4y1w7b8

嗨，我是Jeff Heaton。欢迎来到华盛顿大学深度神经网络的应用课程。好吧，又到了学期的这个时候了，是我班级2020年春季Kle比赛的时间。现在，这个学期将围绕计算机视觉。这是我们第一次做计算机视觉，所以我对此感到兴奋。

我们进行了自然语言处理。上次，我觉得这是一个很棒的深度学习适用技术。这次，我们将查看脸部，并试图检测他们是否戴眼镜。现在，这些是我用Gs生成的脸。所以我们将使用Gs的潜在向量来尝试检测眼镜，以及图像本身，查看我关于Kaggle神经网络和其他AI主题的所有视频。

点击订阅按钮和旁边的铃铛，选择全部以便接收每个新视频的通知。如果你去我的GitHub仓库。T 81，5，58。Jeff Heaton用户网址已提供。你可以向下滚动并访问。😊。

我有Kle。我发誓，在页面搜索时复制让我变得懒惰。所以我通常会这样做8，5。这里总是有一个链接指向当前学期的Kle比赛。2020年春季Kle作业，我刚刚发布，你点击这个并进入。现在我的说法是这个比赛还没有启动，只有主办方和Kgel的管理员可以看到。你在这里不会看到这个，因为我将在发布这个视频时打开它，但这就是比赛。

我们这个学期正在进行一个计算机视觉比赛。它也与Gs有关。所以我给你一堆照片，在这些照片中你会看到这样的脸，我让你做的就是预测这个脸上是否有眼镜。

现在你需要小心，因为眼镜的样式多种多样，你可以有太阳镜，你可以有那种你。

甚至可以看到他的眼睛。你可以有那种可以看到他眼睛的太阳镜。你可以有厚框、薄框，或者真的很薄的框。我自己也戴这种眼镜。乍一看，你可能不会认为她甚至戴了眼镜，但如果你放大她，你会看到，确实如此。

有眼镜，只是非常，非常淡。我希望这个视频的Koc不会妨碍你看到这些，但这基本上就是我们要做的。现在，我想提到的一个事情是，对于这个比赛，你需要将代码提交给我，或者至少如果你是华盛顿大学的学生，你将把代码提交给我。而我将不再接受的一个事情。

我还问过，如果你是通过互联网加入的，你也不应该这样做。只有。😊

测试集中大约有几千张你要提交的图片。坐在那里翻阅所有图片并标记为有眼镜或没有眼镜并不困难。利用你的大脑，使用你的生物神经网络。大家都知道你可以做到，但这其实没有太大价值。所以不要这样做。

由于数据中的噪声，你可能不会得到满分。稍后我们会讨论这个。所以让我们看看这个评估。你将使用对数损失函数进行评估。数据集基本上是这样的：如果有眼镜则为 1，如果没有眼镜则为 0。

你将发送一个概率，表示你认为他们是否戴眼镜。你将根据对数损失进行评分。所以如果你非常自信，比如说你很确信他们不是戴眼镜的人，你就写 0.12，而标签实际上是 1，这对于该个体的提交格式来说将会是相当高的损失。😊

这些文件中你会看到 ID 号码。所有训练集的编号最多到 4500。测试集从 4501 开始。规则是你可以组建最多五人的团队，不能人工标记数据，必须使用模型。所以不要只是坐在那里翻阅我的所有图片并标记它们是否戴眼镜。

没有眼镜，眼镜，眼镜。大家都知道你可以做到，如果这是一个真正的 kggle，投入大量资金的那种，我会给你提供大量带噪声的图片，所以不要这样做。如果你在 kle 竞赛中处于前位，你无论如何都得提交你的模型，如果你的模型只是硬编码的零和一，你可能不会赢得任何东西。

me2 奖项。这是一个 kle 竞赛。我是说，这是一个课堂上的 kle。因此，这不算在 ti 或排名中。除了夸耀权利，没有其他实际的奖品。然而，这更多是为了我的学生。虽然外部人士可能会进入这个位置。

我可能也会对排名第一到第三的团队这样做。我会给你写一份很好的 LinkedIn 推荐信，说明你是大约 80 人中最顶尖的选手之一。这至少是本学期 Warho 的情况。现在，对我来说，创建这些数据集的挑战在于，我从不在 Kagel 上创建仅在互联网上公开可用的数据集，那样没有乐趣，因为网上已经发布了各种代码。

有一些kggles可能对你有帮助。猫或狗可能会有点用处。有几种技术可以用来处理这些。

我会深入研究这个，可能会在学期进行中发布一些代码，给你一些提示。我不会发布任何过于强大的东西来在排行榜上获得高分。至于规则，就像我说的，不能有人为标记。现在如果你能教你的猫标记，那就不算。

所以我们从数据开始。这个比赛的数据有一个大文件，大约6GB。所以并不是特别大。这个文件里有所有的图像。如果你下载它，我来给你看看这个文件是什么样的。这是图像文件。

所以这是一个包含所有这些PG的大压缩文件。里面有相当多的文件。如果你查看所有这些文件，会发现大约有5000个。大约500。我猜这就是测试集的构成。如果你查看这些个体。

你会看到有些人戴眼镜，有些人不戴。有些人戴太阳镜，还有各种性别、种族背景和面部毛发以及帽子。这些图像中有很多不同的种类。至于如何真正分类这些，你有两种方式。你可以使用图像，或者使用gan向量。

我马上会给你展示gan向量，但我们先聊聊几种处理这些图像的方法。你可以写一个简单的分类器，告诉你这个人是否戴眼镜，你可以选择分类器的路径。

我强烈建议你使用迁移学习，利用已经学到很多特征的数据，然后在其基础上进行训练。我认为这会是最有效的方法。你也可以用Yolo来看这个，应该会很有趣。老实说我还没尝试过，但可以运行Yolo看看它是否识别出这些眼镜的部分或眼镜本身。

我可能应该先尝试那个。我不认为Yolo一定会100%锁定这个，但谁知道呢，或许Yolo就是解决这个问题的关键。但这里面有几个层次。现在让我给你展示一下训练样本及这些文件的样子，如果你下载它们。如果你去数据那里，每张图像确实都有一个对应的向量，包含512个数字，这就是你输入给Nvidia风格生成脸的内容。

这些数字生成了这个面孔，背景也是如此。现在你可能能够使用这512个数字。老实说，如果你能创建一个仅使用这些数字而不依赖图像的预测器，准确预测眼镜与否，那真的很酷。我对你如何做到这一点很感兴趣，我们甚至可以进行某种合作。

也许是中等规模的出版物或其他事情。如果你愿意，我绝对会和你一起工作。让我们看看这些文件，你可以同时使用向量和图像。现在，当你去数据页面时，它会展示文件。让我们快速看看样本。这是一个样本提交。

这是一个样本。你可以看到4500，然后对于这个样本，我预测了0.64。这是这些人中总体戴眼镜的百分比，这与一般情况相符。至少在美国，一般人口样本中大约有500人，所以绝对不要简单地给它们标记。

现在我们来看训练数据。这是训练数据。在训练数据中，这一部分很长。这是向量。这是你的潜在向量，数量为512，然后是标签眼镜0110。我生成了所有这些数据，并没有手动创建5000个个体并逐一标记。这就是潜在使用这个向量来判断谁戴眼镜，谁不戴眼镜的挑战，因为这些数据是通过我一个算法生成的。

我还有另一个视频讲解这个算法是如何工作的。如果你想认真对待这些向量，可能需要先观看那个视频，你会看到我如何创建这个训练集，以及我是如何生成GAN向量的。

这有很高的可能性是戴眼镜的人或不戴眼镜的人。现在，请注意。我说的是很高的可能性。数据并不完美。我提前告诉你这些。我原本想让你自己发现，但我会收到很多邮件，告诉我你的数据不正确，因为我看到其中有人戴眼镜，但你说他们没有，反之亦然。

我们先来看看这个。我只提取了眼镜中的ID。

现在我们同时展示了两者。我们来验证一下数据。好吧，第一人。没有眼镜，有眼镜，有眼镜。看看那两个一。没有眼镜，没有眼镜。所以连续两个没有，1，2，3，有眼镜，没有眼镜。好吧，嗯，那是第10个人。第10个人有眼镜，没有，1，好吧，可能有错误，15，没有，15是没问题的。好吧，那么19。

好吧，我翻了不少这些才找到一个。但这个是错的。所以30。它说这个人应该戴眼镜，但他们没有。所以我实际上是在做我让你们做的事情的反面。我让你们查看向量或图像，告诉我他们是否戴眼镜。

当我研究GANs并进行这项工作时，我对自己提出的挑战是尝试编写一个算法，生成一堆要么戴眼镜要么不戴眼镜的向量。我只是纯数学。没有，甚至不查看图像。我的算法相当准确。

我翻了大约30个这些，才找到一个不正确的。所以我让我的算法生成这个戴眼镜的人，但它没有做到。所以即使你建立了一个完美的分类器。你和你的队友坐在那里标注所有这些，而你本不应该这样做。但你可以自己完全用没有任何神经网络的方式输入。😊，1或0。

你仍然无法获得完美的分数，因为你用人脑可能会说这个人没有戴眼镜。我的算法假设你会。所以如果你想获得绝对最高的分数，这个挑战几乎有两个层次。第一个层次是从向量或图像中找出谁戴眼镜，谁不戴眼镜；第二个层次是如果你真的想征服噪声，那么你可能需要找出这些个体中哪些被错误分类，也许他们的向量在高维空间中彼此接近。

也许聚类会找出，我老实说不太确定，我还没有尝试去分析它。如果你观看我另一段关于潜在向量的视频。我会在本次竞赛描述链接中放一个链接。你可能会得到一些关于如何做到这一点的线索。所以理论上。

你可能在没有人工标注的情况下获得完美的零对数损失。即使你进行了人工标注，实际上你也不应该这样做。但如果你这样做了，你仍然无法获得完美的分数，因为你会有错误。我认为向量中可能有线索。我认为它们在某种高维空间中彼此靠近。

但我并不是完全确定。观看另一段视频，你会看到更多相关内容。好的。这就是本学期的竞赛，如果你有任何问题，请在反馈中留言。如果你有任何问题，请在评论中留言，祝你在本学期的竞赛中好运。希望我没有让它变得太简单。😊或者难以承受。我的目标始终是如此。

感谢你观看这个视频。此次竞赛对来自互联网的成员开放，同时也欢迎正在参加我课程的华盛顿大学学生。如果你觉得这种事情有趣，请订阅我的YouTube频道。非常感谢。

T81-558 ｜ 深度神经网络应用-全案例实操系列(2021最新·完整版) - P47：L9.1- Keras迁移学习简介 - ShowMeAI - BV15f4y1w7b8

嗨，我是杰夫·希顿。欢迎来到华盛顿大学的深度神经网络应用课程。你知道吗，训练一个神经网络需要很多工作，而且可能需要大量的计算时间。大部分时间是你的计算机在工作，但仍然可能需要很长时间，尤其是如果你没有一块几千美元的GPU。

这就是迁移学习派上用场的地方。迁移学习让你可以使用那些由大公司或创业公司开发的神经网络，或其他在GPU上花了大量资金的人，利用这些训练来进行你自己的项目。想了解我的AI课程和项目的最新动态，请点击订阅旁边的铃铛，以便获得每个新视频的通知。

迁移学习是深度学习中一个非常重要的概念。这是因为它需要大量的时间、计算资源和金钱来训练先进的神经网络，特别是在计算机视觉和自然语言处理领域。

在表格数据中，你不会看到迁移学习，因为实际上没有很多已经为此类数据训练好的神经网络。这取决于你的表格数据集，表格数据集往往非常不同。相比之下，计算成像和计算机视觉之间往往有很多共同点。

你将看到的一些元素，如边缘、轮子、眼睛、鼻子和嘴巴，在许多计算机视觉任务中都是常见的。因此，你可以将谷歌、微软等大公司在训练这些先进神经网络时所积累的知识迁移到你的神经网络，以作为基础。

所以，如果你打算教一个神经网络识别几种非常特定的图像类型，你可能不想完全从头开始训练这个神经网络。如果你可以迁移一个已经在ImageNet或其他常见计算机视觉数据集上训练好的神经网络权重系统。其工作方式通常是找到一个预训练的神经网络，它会有多层。

这些层到底是什么其实并不重要。你可以确实展示它们，当我们在这里运行示例程序时你会看到，通常你会削减掉顶部部分。所以，ImageNet是一个非常常见的数据集，其他一些数据集通常会针对10个不同的图像类别进行训练。因此，我们可能希望为比这小得多的东西进行训练。

移动那个顶层，仅转移这些层。这些层的所有权重将转移到我们的神经网络中。我们将仅训练为我们的新神经网络添加的新层。所以这里我们添加一个稠密层，它将从这些较低层学习，而只有这两个顶层将实际被训练。

这些底层基本上成为特征工程，特别是用于计算机视觉任务。这些正在学习进入imagenet和其他数据集的所有构建块，这些数据集是神经网络训练的基础。首先，我们将看一个非常简单的迁移学习示例，这将是表格数据。这使你能够查看一个非常简单的例子，我们将使用鸢尾花数据集。

只是为了让我们看到这一切如何结合在一起。通常，你可能不会创建其他人会转移的迁移学习神经网络，除非你真的😊，承诺获取大量数据并建立一个高级训练设置，使用GPU和其他东西，并花费一些严肃的钱。不过，对于这个，我们将创建那个初始的神经网络，然后我们将其转移到其他地方。

我们基本上要尝试对比这三个原始鸢尾花数据集之外的其他花进行分类。我们希望原始鸢尾花数据集的一些学习能够转移到这个新的数据集上。

所以我们要做的第一件事就是加载训练数据并构建我们的神经网络。我们在这里构建的这个神经网络模拟了科技公司或研究人员使用高级计算技术来进行严肃训练的过程。

所以现在我们有一个鸢尾花数据集。我们可能会在此时保存它，以便我们能够转移它。我们快速检查一下准确性，大约为98%。所以这相当准确，并且。打印出摘要。我们经常使用摘要来分析我们转移的神经网络。这里我们可以看到我们基本上有一些稠密层，50，25和3，就像我们在神经网络中设置的那样。

所以5025和3的摘要在观察这些情况和了解发生了什么时非常有用。总参数就是我们在神经网络中的权重数量，在这种情况下可训练参数是相同的，因为所有内容都是可训练的。现在，当我们将这个简单的神经网络转移到其他东西时。

我们会标记一些不可训练的层，我们将看到这一点。所以现在我将向你展示，我们基本上可以重建这个神经网络。我们创建了model2 sequential。我将原始模型中的所有层添加到这里。当我们运行这个时，我们在上面看到一个完全的副本1603，就像我们之前看到的一样。作为 sanity check。

我们将评估模型2。请查看这里，看看准确率是多少。准确率应该与我们转移过来的原始准确率完全一致。因此，我们基本上完成了迁移学习。我们已经转移了一切。通常这不是你想要做的事情。我们会有一个重复的神经网络，可以分类与原始神经网络相同的三种花，但并不太有用。

它变得有用的地方在于，如果我们想添加这些假花。我称它们为假花，因为它们是假设的。这再次显示了，如果你想真正创建自己的神经网络供他人转移时，你会经历的机制。我们现在要做的是创建模型3。我将把前两层移入并去掉输出层。

这些将是新模型的特征工程。你会看到我们的参数更少，因为我们去掉了原本要做最终层的顶层，这取决于你的观点，但我们去掉的是输出层。现在我们要添加一个新的softmax层，带有四个输出神经元，以分类这四种假花。

我们运行它，基本上现在我们有5025，但我们还有一个4附加在上面。现在，我们也可以添加一些额外的密集层，也许可以提供一些额外的处理。但对于这样简单的网络，其实并不是特别必要。现在，当我们添加这些标记的新层时，将其可训练性设置为false。

对于我们转移进来的原始层，这里可训练性设置为false。这对于迁移学习非常重要，因为我们不想训练我们已经拥有的权重。这就是我们进行转移的原因。这是好处。因此，你会看到总参数为1629，但其中只有1525是前两层。

输入和5025是唯一可训练的层。所以这些数字在这里是不同的。我创造了一些人为的值，这些值将用于这四种花。我只给每种花两个训练样本。但这只是展示了你将要经历的机制。

这里是与X输入相对应的这四种花的独热编码。我们将仅通过训练最后的输出层来拟合神经网络，并试图看看它能多好地分类这四种新花型。我们运行它，看到上次运行时的准确率大约为88。我们来看看这是什么。

所以在这种情况下实际上是完美的准确率。这是神经网络的随机性质，你会得到不同的结果。因此，我们已经完成了整个过程。这就是你如何真正创建一个你想要转移的神经网络。接下来的课程中，我们将转移其他人的神经网络，而不是自己去制作那些网络。

所以我们将简单地成为消费者，这通常是情况的常态。感谢你观看这段视频，在下一个视频中，我们将看看如何。😊！

实际上要找到一些这样的开放神经网络，你可以将其应用于自己的学习以进行迁移学习。这个内容经常更新，所以请订阅频道以保持对本课程及其他人工智能主题的最新了解。

T81-558 ｜ 深度神经网络应用-全案例实操系列(2021最新·完整版) - P48：L9.2- 流行的Keras预训练神经网络 - ShowMeAI - BV15f4y1w7b8

嗨，我是杰夫·赫顿。欢迎来到华盛顿大学的深度神经网络应用课程。迁移学习很棒。你可以将现有学习融入到你的神经网络中。但我们从哪里获得这些神经网络？在这个视频中，我们将探讨如何找到它们。😊

这些类型的神经网络以及一些流行的网络。如果你想看到更多类似于人工智能主题的视频，请点击订阅按钮和铃铛，订阅我的YouTube频道，这样你就能收到每个新视频的通知。谢谢！Keras内置了许多可以从提供者转移的模型。

因此，了解如何利用这些资源很重要。我们会讨论它们。现在，你也可以在Keras之外找到一些模型。就像我们对Yolo所做的那样。Yolo本质上是迁移学习。我们几乎转移了整个Yolo和StyleGAN，但这为我们提供了可以实际使用的预先存在的模型，你可以根据需要自定义并进一步微调训练。

我们还将查看这两个网站。它们非常重要，这里有很多好的信息。TensorFlow模型库和带代码的论文。这两个网站有大量能够进行迁移学习的资源。😊！

你可能想在自己的项目中使用的神经网络。如果你查看模型库，可以通过星星看到一些最受欢迎的模型。你也可以订阅以获取新的模型。这里有视频，不仅仅是计算机视觉，TensorFlow显然现在非常受欢迎。

这里有很多G和其他你会看到的东西。对于这个课程，我会给你提供链接，指向我们正在转移的实际神经网络，通常我们使用的是已经内置于Kis中的模型，但如果你想在未来寻找自己的项目，这绝对是一个非常有价值的网站，而带代码的论文也很棒。

这里是那些发布了代码的论文，或者有时没有热情的论文，作者会迅速为论文编写代码并在这里发布。所以这是另一个很好的地方，可以找到你可能希望在自己的项目中转移的神经网络。

我在这里列出了所有内置于Keras中的内容，你实际上可以加载的完整列表在Keras文档中可以找到。这些是MobileNet将使用的一些，其他的一些也非常有用。MobileNet很好，因为它设计用于在移动设备上运行，因此它所需的计算能力与其他一些相比并不高。很多这些我在这里给你提供了链接，你可以点击这里的主要链接，查看实际论文。通常你需要阅读实际论文中的信息，以了解每个网络的实际用途，并获取一些额外的信息。Keras文档给出的仅是使用它所需的基本信息，但我在这里给你提供了Keras提供的链接，以获取使用这些信息的指导。现在，安装Keras时并不会下载所有这些权重。

显然，我们的汽车会是一个非常大的下载，因此当你第一次运行这些时，你会看到汽车在后台进行下载，以便从原始研究者那里提取权重。这些开发这些技术的研究者很有趣，他们并不一定具备某些公司的强大计算能力。我看到几个行业使用Yo的例子，他们尝试微调Yolo权重，以识别多个对象。我们在之前的模块中见过Yolo，但他们往往只是直接使用Yo，因为改进它是困难的，因为它做得非常好。DenseNet等很多都是尝试提供比以往更深的预训练网络。ResNet有几个不同版本，它可以提供一些非常先进的特征识别，MobileNet也很有用。

V2，那是我最喜欢的两个。你会看到我在课堂上使用这些。这让你能够使用一个为移动设备和物联网进行了广泛训练的神经网络。稍后在课程中，我们会谈到如何实际进行物联网的部署。因此，进行神经网络计算，无论是在边缘还是在云端。

这些对那会很有用。我们将在本课程的最后谈论这个。你可以在描述中看到Cf 10以及所有这些训练过的各种图像数据集。再说一次，更多的ResNets，VGG也是一个非常受欢迎的选择。我没有过多使用它，我在日常工作中并不经常做计算机视觉。

但这些都是计算机视觉的很好的起点。感谢观看本视频。在下一个视频中，我们将利用其中一些优秀的内容。😊。

开放的神经网络是为我们开发的。我们将从计算机视觉开始。这个内容经常更新，所以请订阅频道，以便及时了解本课程和其他人工智能相关主题。

T81-558 ｜ 深度神经网络应用-全案例实操系列(2021最新·完整版) - P49：L9.3- 计算机视觉和Keras的迁移学习 - ShowMeAI - BV15f4y1w7b8

嗨，我是Jeffheine，欢迎来到华盛顿大学深度神经网络应用的视频。在本视频中，我们将研究迁移学习，以及如何将为我们开发的计算机视觉神经网络迁移到汽车领域，以获取我AI课程和项目的最新消息。

点击铃铛旁边的订阅，以便收到每个新视频的通知。所以让我们为计算机视觉在汽车领域进行一些实际的迁移学习，以展示如何使用mobilenet。我们将把它完全转移到我们的Python代码中，并能够识别10种不同的图像类型。我们还将实现一个非常简单的例子，展示如何扩展这个学习。

我们真的在尝试看看是否可以仅仅添加几张图像，并实际教会它识别几种不同的犬种，我们会看到我们在这个真实项目中的成功程度。为了做到这一点，我们需要捕获相当多的额外图像。你将有机会尝试这个。

😊。

在作业中创建你自己的计算机视觉迁移学习。我们将尝试创建微软犬种图像搜索。这是一个微软可能花费了一段时间进行的项目。我们将尝试做一个非常简单的简易版，只识别几种犬种。

但你基本上可以输入狗的图片，它会通过卷积告诉你。可能是迁移。我不知道他们是从零开始训练的，还是使用现有神经网络的一些迁移。但无论如何，在我们甚至尝试迁移学习之前，先看看能否加载并实际运行mobilenet。

所以我要引入这些导入，这样我们就有了，这个命令基本上会从Kis加载imagenet，以便我们可以在mobilenet中使用它。让我来执行这个。😊。

现在，如果这是你第一次运行它，你会看到下载条在加载，并且会下载整个mobilenet imagenet。这可以是一个非常好的学习如何构建神经网络的方式。你可以查看这些的摘要，它会显示给你，顺便提一句。

这包括我这里的顶部，实际上这只是意味着加载整个内容，当我们进行迁移学习时，会说为false，意味着关闭输出层，就像我们在前一部分中所做的那样。但我们会取网络的底部部分用于特征工程，而顶部部分则用于网络。

我们将输入自己的图像，以便教它分类我们在原始imageNet中没有的图像。这看起来是这样的。你会注意到这里有一些有趣的事情。我们使用的滤波器数量相对较少，随着层级的增加，数量逐渐增多，如256、512等等。你可以看到它们在广泛使用批量归一化，因此观察这些是非常有趣的。

这些经过极为研究的权重库是如何转移的。它们是如何构建其深度神经网络的。当你最终到达这里时，你会看到成千上万的节点。这些是最终的输出层，将被移除，但这些是用于分类这1000种不同图像的部分。因此，让我们尝试看看它将如何分类图像。

现在我从谷歌图像搜索中抓取了一些网址。这些是各种不同的图像。我只是想看看imageNet分类的效果。欢迎你把自己的图像放进来，也进行分类。你也可以从文件中加载它们。让我们开始运行吧。它应该在加载那些网址，实际上已经完成了，你会看到我选择的第一张图像。这第一张图像是一个足球，确实来自Shopify。

所以我实际上是在做谷歌图像搜索。找到一张图像并右键点击，复制图像网址，然后放到这里。所以这实际上是一个我偶然发现的待售真实足球。但是你会注意到，imageNet的移动网络以99%的概率认为这是一只足球。所以它非常准确。它说下一个是蜂窝，但对此不太确定。

但我可以看到它对蜂窝的分类。这是相似的形状，哑铃、气球，或者墙壁时钟，谁知道呢？所以这些只是它完成的一些分类。现在你可以利用上面的Python代码，编写各种计算机视觉应用。你甚至不需要训练神经网络，只需使用移动网络。

你将拥有这个能力。我随便选择了一辆车。它实际上识别为赛车，绝对不是敞篷车，而是一种跑车，是一辆卡车。它确实将其识别为皮卡车。它绝对不是两栖车。如果你把它放在水里，它会沉到底部。非常有趣。

还显示了类编号，类别在0到999之间，这些是你拥有的类别，可能是1到1000，我不太确定索引是什么。你看，我希望它能把我分类为一个人，但它把我分类为西装，我想这是律师的同义词。

我可能会对此感到不快。它说我有一条温莎领带。其实我没有带领带。要让我穿上领带是非常困难的。我非常少穿。新郎。我曾经是新郎，当我和妻子结婚时，但那天并不是。我绝对没有穿风衣。而且我不知道为什么它认为我是一部手机。

我经常使用它，但我不是一部手机。这是我的狗 Hckory。他是一只英国斗牛犬。但这是非常特写的。所以我试图故意让它困惑，并且我成功了。图像网中有一些狗品种，所以它已经可以进行一些品种识别。但它说这是一个哈巴狗，或者也许是法国斗牛犬，完全是错误的国家和错误的品种。

绝对不是拳击手，绝对不是斗牛犬。这是最大的狗之一。我甚至不知道这是什么。所以使用这个，以及上面的代码。你基本上可以加载这个图像网。然后你可以开始对其进行分类，或者如果需要，可以使用 Yolo。如果你想查看我之前关于这一模块的内容，你可以学习实际创建需要在屏幕上识别多个事物的东西。

所以可能有一辆车和一个人，知道它们实际的 X 和 Y 坐标，但你可以做很多事情。你可能会写一个机器人狗门，只对你狗的分类开放，那将是一个有趣的项目，但这基本上展示了我们之前提到的制作方框，它只是做了一个 Instagram 类型的。

让它变成肖像。我们遍历所有的 URL，我基本上逐一加载 URL，将其转换为图像，加载后将其调整为 224 x 224 的高度，然后将图像转换为数组。必要时扩展维度，然后我预处理图像，使用 Ks 提供的预处理输入来帮助你预处理图像，然后我准备好进行下一步。

在这里的预测中，我基本上打印出这个数字，即 agm。我还使用了 Kis 提供的解码预测功能，这让我打印出这个漂亮的概率列表。因此，这可以成为你可能想要创建的各种应用程序的起点。

但让我们尝试进行实际的迁移学习。所以我将再次加载相同的内容，但将 top 设置为 false。我加载并打印出摘要。你会看到底部的那 1000 层不见了。我们直接停止在 1024 层。因此，这和我们之前在这一部分看到的很相似，但我们提早停止了。

现在一切仍然可以训练。我们稍后将其标记为不可训练，然后添加额外的层。所以我将添加两个 1024 的密集层，继续往下。这些将是可训练的。你在上面看到的所有内容都将是不可训练的。然后我放一个 softm。在这里，因为我们将基本上添加三种不同类型的狗，这里我实际上构建了模型。

在这里我把前20个标记为不可训练，最后一个标记为完全可训练。现在Kira有一些非常不错的功能，可以让你从文件夹中进行训练。我将根据这个文件夹进行训练。你放置这些的结构变得非常重要。所以这是用户Jheton下载的trans文件夹。这只是我恰好放置它的地方。

所以转移学习的文件夹。让我给你看看那个文件夹。这是我设置的文件夹。你会看到我有A、B和C类，这就是我三种狗。我这里没有一个庞大的训练集。所以A类，这些都是斗牛犬类型的动物，然后B类是贵宾犬，C类是德牧。

这就是你如何设置它。你只需标记这些。你在这里有图像。它们可以是JPEG或PNG格式，你命名为。

将常见类别分组在一起。这给你提供了文件夹名称的理由，然后实际的文件会放到每个文件夹中。你实际命名这些文件并不重要。我只是简单地指向这里。这告诉它目标大小，所以它会根据需要将所有文件缩放到224。我们尝试将其分类为类别，所以我们想要三个类别，我们继续运行，发现9张图像属于三个类别。

现在如果你想训练这个，你需要自己提取图像并创建那个目录结构。有些图像可能有版权，所以我不能真的创建这些的集合，但你也可能不想做犬种分类，并且你可能希望获取更多的图像。理想情况下，你可能想要每个类别50到100张，但这只是个尝试。现在我将开始训练它。

实际上这会很快，我只训练了五个epoch，我当然可以做更多，这可能会给我们更好的准确性。我将快进到完成的部分。现在我们完成了。所以让我们继续。我为不同的狗放入了不同的URL，这些狗不在训练集中。让我们看看它实际表现得如何。再次强调，这主要是走个过场。如果你真的要这样做，你需要更多的图像，对吧，那是一只德牧。

它说这是2类。这里还有一只德牧，也是2类。现在这里有一只斗牛犬。如果这也是2类，那就是个彻底的失败。所以它认为这只斗牛犬与这些德牧相似。可能是因为没有足够训练。这只斗牛犬，我的斗牛犬，它认为这完全是另一回事。

然后贵宾犬也被分类为两类。所以你可能需要更多的图像。但这只是让你了解这个过程，以便你可以为任何你想要的图像构建这个。感谢观看这个视频。在下一个视频中，我们将继续讨论迁移学习。😊

汉语言库或可以转移到我们的用途的神经网络，这个内容经常变化，所以请订阅频道，以便及时了解这门课程和其他人工智能主题。

T81-558 ｜ 深度神经网络应用-全案例实操系列(2021最新·完整版) - P5：L1.4- 深度学习的 Python 文件处理 - ShowMeAI - BV15f4y1w7b8

嗨，我是 Jeff Heaton，欢迎来到华盛顿大学的深度神经网络应用课程。在这个视频中，我们将研究如何在 Python 中处理文件。这为我们在 Keras 和 TensorFlow 中进行更复杂的操作做好准备。我们特别会看到如何处理文本文件和图像文件，因为这些是我们在本课程中主要处理的文件类型。要获取我 AI 课程和项目的最新信息，请点击旁边的铃铛订阅，以便在每个新视频发布时收到通知。让我们来看看 Python 文件处理。在这个神经网络课程中，我们将处理三种类型的文件，分别是 CSV 文件、图像文件和文本文件。CSV 文件通常带有 CSV 扩展名，你可以把它们想象成 Microsoft Excel 文件。事实上，在大多数计算机上，你双击 CSV 文件时，Excel 会弹出打开。

图像文件主要是 P&G 或 JPEG 格式，还有 GF 文件等。图像是神经网络特别擅长处理的内容，所以在这节课中我们将看到很多不同的图像，文本文件则有 TXT 扩展名。

这些通常只是原始文本，往往与自然语言处理有关。在这节课中我们将简要看到其他类型的文件，如 JSON 和 H5。这些文件将来自三个主要位置，你的硬盘。如果你使用 Windows，你会看到像这样的路径。如果你使用 Mac，你会看到这样的文件。我假设你们大多数人会使用 Google Coabab。

所以请观看关于如何从 Google Collab 阅读这些内容的教程。基本上你会有一条类似于 Macintosh 的路径。CSV 文件可以通过 pandas 阅读。在下节课中我们会大量使用 pandas。现在需要注意的是我这样做的方法。

我给你提供大多数 CSV 文件的网页地址，这在 data.heatinresearch.com。这是我自己的网址，独特于这节课。我在那里有所有数据文件，这样无论你是在 Google Coab、Mac、Windows 或其他设备上运行，它都能正常工作。上面的命令直接从互联网加载 Fisher 的 I 数据集。好的。

文件已加载，你可以显示前五条记录。这是一个非常经典的数据集，如果你以前没有见过，它基本上是关于花朵的四个测量值，并定义了物种。由于文件是按顺序排列的，所以一开始实际上有三种不同的物种。

你只看到第一个鸢尾花，它是sattosa。这是一个经典的分类数据集，你试图利用这些值来分类它是什么类型的鸢尾花。读取图像需要使用PIL库，但它的工作方式类似于读取CSV文件。你基本上会这样做。运行它，它会从这个URL加载图像。

这是华盛顿大学的一栋建筑。现在看起来并不是这样，多亏了所有的建筑，但至少前面的草坪如此。但这就是加载JPEG的一种方式。现在当我们进行一些练习时，我们将会有很多很多的图像。你可能会真的以这种方式获取图像。

但你需要将它们放在你的Google Drive的一个文件夹中。我在Google Colab视频的介绍中向你展示了如何做到这一点。所以如果你使用Google Colab，请确保观看那个视频。相信我，对于我们在这门课上进行的一些图像处理来说，这是必要的。

你会需要Google Colab，因为它有GPU。你也可以读取或流式处理大型CSV文件。流式处理的好处在于，你并不会一次性将整个CSV文件加载到内存中，如果你只是读取CSV文件并计算每一行的统计数据。

你真的不需要将整个内容加载到内存中。你可以简单地读取每一行并进行处理。因此，在这里，我正在使用I数据集。我将其打开以进行流处理，这意味着整个内容不会一次性加载到内存中。我将对我们看到的那四个值进行求和。

我创建了一个包含四个零的数组和NumPy。我记录了我读取的行数。然后我运行这个。你会看到这基本上是那四个值的平均数。我将遍历这一行，所以对于每一行，我基本上都要将那一行转换为NumPy数组。当我们处理NumPy时，你会看到更多这个的内容。但这就是如何创建NumPy数组的方法。我只取位置零到四，我不需要物种信息。

物种是第五个。我将它们转换为浮点数。因为它们是整数，并且可能会以整数或字符串或其他值的形式出现。如果这一行的长度合适，我会跳过任何空行。我相信最后会有一行空行。我进行求和。这是一个向量求和。

所以这基本上是将第两行中的所有内容提取出来。因此，数组中的那四个值。我将其添加到我拥有的另一个数组中，并保持计数递增。所以这就是向量加法，它是将四个数字相加。就像这就是向量除法。这返回一个向量或数组，但它将每个元素除以计数。在这门课程中，向量数学非常有用，因为我们经常处理向量。

这是一种低维形式的张量。所以我们可以在任何时候进行整个张量的数学运算。这是一个很好的优化。读取一个文本文件。这是《美国独立宣言》。这只是一个我找到的文本文件，它有一个网址，并且是一个纯文本文件。你可以运行它，它基本上会打印出《美利坚合众国独立宣言》的原始文本。感谢观看这个视频，这部分结束了文件处理和Python。在下一个视频中，我们将查看函数Ladas和mapR，内容常常会变化，所以请订阅以便及时了解人工智能的相关主题。

T81-558 ｜ 深度神经网络应用-全案例实操系列(2021最新·完整版) - P50：L9.4- 自然语言处理和Keras的迁移学习 - ShowMeAI - BV15f4y1w7b8

嗨，我是杰夫·希顿。我们与华盛顿大学一起研究深度神经网络的应用。在这段视频中，我们将看看自然语言预训练神经网络，您可以将其迁移到您当前的项目中，了解我最新的人工智能课程和项目。

点击订阅和旁边的铃铛，以便接收每个新视频的通知。迁移学习也常用于自然语言处理。现在我们将有一个完整的自然语言处理模块即将上线。这只是给我们一个简要的介绍。通常，使用迁移学习时，您是在神经网络中添加一个嵌入层。

这基本上是将原始文本（例如句子）编码成某种向量，以便输入到神经网络中。这个向量可以被预测，因为它是一个固定长度的数值输入，而普通句子的单词数量可以变化很大。您还需要仔细考虑如何实际编码您的文本。😊

有多种不同的嵌入层或编码器，基本上是您将迁移的模型。我们将在几个模块后看到更多关于这一点的内容，一旦我们进入本课程的自然语言处理模块。我在这里列出了一些我用来组合这个简单示例的来源，展示我们如何分析互联网电影数据库并尝试预测评论是积极还是消极的。要使用这个示例，您需要安装Tensorflow hub和Tensorflow datas。

您可以运行这两个PP安装。如果您每次重新启动Google Coab，您都需要重新运行这些。我已经在我当前的本地环境中安装了这些。我要做的第一件事是加载互联网电影数据库的评论。这些评论涵盖了各种电影，有些是积极的，有些是消极的。

我们的想法是训练神经网络，通过阅读这些评论来判断它们是积极还是消极的。接下来我们将使用一个名为Google news swivel的预训练嵌入模块，维度为20。这是一个相对较低分辨率的编码器，只有20个维度，确实比我们在进入自然语言处理模块时看到的word'reve和其他编码器要低得多。

我将加载预训练的神经网络，它是内置于Curs中的。因此他们为我们提供了相当简单的使用方式。让我们看看前三条电影评论。这是前三条电影评论。您可以看到它们几乎都是自由格式的文本。这是非结构化数据，而结构化数据在神经网络中使用特别困难。

不用担心，我们可以处理那些非结构化数据。基本上，这里是我们之前用于打印的内容。我们将把它传递到中心层。中心层是我们刚刚从 Tensorflow Hub 转移过来的层，即谷歌训练的嵌入层。那么现在让我们看看这三条评论在这里的样子。现在你可以看到它们实际的向量，每个向量由 20 个数字组成。

在这方面训练和处理神经网络要容易得多。你基本上可以将原始文本输入到神经网络的开头，它将基于那些句子生成的向量进行处理。那么，单个数字意味着什么，这很难说，但向量之间的距离是有意义的。所以如果你计算两个不同句子的向量之间的距离，更相似的句子通常会更靠近。

我们将在谈论词向量到 V 的过程中更深入地了解如何对这些嵌入层创建的向量进行线性或代数运算。现在让我们继续向我们正在构建的神经网络中添加中心层以及其他一些层。使用 sigmoid 激活函数，并且只有一个输出神经元，因为这是一个二元分类器。它要么是正面评价，要么不是。我们将编译这个神经网络。

采用二元交叉熵损失函数，并且我们将使用 Adam 优化器进行训练。我们将数据拆分为训练集和测试集，这样我们可以在一个上进行训练，在另一个上进行验证，我们将使用相对较大的批量大小 512 来进行拟合。因此，这将经历若干个训练周期，我们将快进这个过程。好的，神经网络已完成训练。我们可以进行评估。

这是在测试集上运行的结果。可以看到其准确率约为 85%。让我们使用图表，看看训练的进展情况。你会注意到在我拟合时保存了历史记录，这对于查看训练的进展非常有用。我将运行这个图表，这很有趣，因为你可以看到这确实显示了过拟合的现象。你可以看到训练损失在不断下降。

并且验证损失持续下降，但最终开始平稳。这几乎是过拟合的教科书式描述，这也是你使用早停法的原因。因此，损失在下降。这基本上是那个图像的镜像。准确率在上升。你同样可以看到过拟合开始发生的地方。

验证集开始平稳，尽管训练集将不断变得更好。感谢观看这段关于迁移学习的视频。该内容经常变化。因此请订阅频道，以便随时了解该课程和其他人工智能主题的最新动态。

T81-558 ｜ 深度神经网络应用-全案例实操系列(2021最新·完整版) - P51：L9.5- Keras特征工程的迁移学习 - ShowMeAI - BV15f4y1w7b8

嗨，我是Jeffeine，欢迎来到华盛顿大学的深度神经网络应用视频。在这个视频中，我们将继续讨论迁移学习，我们将看到如何使用你自己训练的神经网络。进行特征工程和降维，获取我最新的AI课程和项目。

点击订阅和旁边的铃铛，以便接收每个新视频的通知。迁移学习也可以用于特征工程。例如，你要分类图像，但不仅仅是图像。也许你想要某个人的图像。而且你还要把其他统计信息放进去，比如他们的年龄、性别。

以及其他东西，这样神经网络可能会给你一些健康评估。再次使用人寿保险行业的例子，这就是我日常工作的内容。在这里，我们将简单地看看如何撕掉。你通常迁移的这些神经网络的顶层，使用下面的部分进行特征工程。

我将继续运行这部分介绍，基本上这段代码和之前的一样，我正在抓取。实际上，这里有一张图像，是一个足球。我显示这个足球，并且我留下神经网络，没有输出层。

这就像我们要进行迁移学习一样。除了。我实际上要继续显示模型摘要。所以如果我运行这个。我现在可以看到对于224乘224的输入图像。经过所有这些，而不是将其分类到1000个。图像中。

这是这种类型的神经网络的分类类别。我们正在使用它训练的最终层，恰好是一个1024的向量。所以你可以看到基本上这里是那个1024的向量。它相对稀疏，这有点有趣。所以，这些基本上是最后稠密层学习识别和分类的特征类型。

你可以简单地将这些提取出来，作为工程特征的一部分。作为你的特征向量的一部分。所以你会有来自你分类的任何图像的1024个值。并且它并不是将其分类到足球，而是将其分类到你看到的所有这些独立特征，稠密层能够用来判断这是一个足球。

因此，你得到的是CNN为你生成的原始特征工程输入。这可以被用作编码的一种方式。图像，或者就像我们在最后一部分看到的那样。你可以做类似的事情，用嵌入层来编码自然语言处理的字符串值。

感谢观看这个视频。在接下来的模块中，我们将开始研究时间序列。这个内容经常变化，因此请订阅频道，以便及时了解本课程及其他人工智能主题。😊

T81-558 ｜ 深度神经网络应用-全案例实操系列(2021最新·完整版) - P52：L10.1- 深度学习、TensorFlow和Keras的时间序列数据编码 - ShowMeAI - BV15f4y1w7b8

嗨，我是杰夫·希顿，欢迎来到华盛顿大学的深度神经网络应用模块。在本模块中，我们将开始研究时间序列，特别是如何对时间序列数据进行编码。无论你是使用卷积神经网络还是LSTM，你都需要将数据以特定形式输入到时间序列中，以获取我最新的AI课程和项目的信息。

点击旁边的铃铛订阅，以便在每个新视频发布时收到通知。

首先，让我展示一下时间序列和序列的含义，因为这些将成为我们在本模块中实际创建的代码的重要概念，该代码使用LSTM和时序卷积神经网络。所以如果你考虑表格数据，我们可以从几次使用过的每加仑英里数据集开始。

这有汽车，能给你像汽车加速度、每加仑英里的数据，重量实际上并不重要，只是一系列这些数据，然后也许是一个类型。实际的每加仑英里数据集不太完整，但可能会有像汽车、卡车的加速度。我不知道这些都可以是归一化值0.8。

也许这数据很快，可能每加仑一英里，现在也许变得相当慢，重量将是中等范围，类型我们将只做汽车和卡车。所以零，我是说汽车。这是一行数据。我们将尝试预测一些东西。现在我们要预测的是汽车品牌，我们将用虚拟变量来实现，可能有三种不同类型的品牌，汽车可以是这些虚拟变量中的一种，而这是目标，对于这辆特定的汽车，可能是类型B。如果你创建这样的内容，你的神经网络传统上看起来将是这样的，你将有这四个输入，所以你将有一个四个神经网络，每个基本上连接到其中之一，这是一个神经网络，你将有多个层，里面会有各种东西，最后这一部分将成为你的输出神经元，所以A、B和C各一个。

所以这基本上是我们在整个课程中遇到的典型神经网络v表格数据。现在对于计算机视觉，序列变得非常相似。现在我们可能会有一系列汽车进入。因此，例如，我们不是在试图预测A、B或C，而是试图预测未来我们实际上将销售哪种类型的汽车。因此，实际上你要做的是向这个模型添加额外的输入神经元，你会在这里放四个，并且你基本上会进行时间序列处理，这样第一个就是插槽1，第二个就是2，随着你进行的过程中，不断添加四个神经元的组，你会说，好的，我有一个序列，我已经销售了这种类型的。

首先，我可能会再卖一辆车，我会在这里填入，并且它在第二个位置。我们接下来要卖什么类型的车？所以你基本上会随着数据的进入逐步构建这些序列。因此，你有你的数据，Y基本上就是下一个，确切来说就是下一个类型。这就是在我们拥有LSTM和时序卷积神经网络之前，传统上是如何做到的。你会进行时间序列编码，基本上就是做一个滑动窗口。

如果你销售了汽车1、2、3和4，你的第一个窗口可能就是这四辆车，然后你已经销售了汽车5，接下来汽车5将是你的输出，然后随着时间的推移，你可能会用这些来进行预测，所以它会不断滑动，你会利用你销售了汽车2的事实。

用3、4、5来预测2，这被称为序列，而序列中的每个元素不一定只是一个值，而是所有四个值的加速度、重量、类型等等，这些都是你输入到神经网络中以进行预测的。现在，卷积神经网络与LSTM之间的重要区别在于，随着你将更多值添加到序列中，你有多少个神经元。在这种情况下，我们有一个大小为4的序列，随着你添加越来越多的这些值。

将值纳入你的序列。你的输入神经元的数量在增加，这就是这些模型的一个限制，比如你有一个大小为100的序列。现在，使用越来越大的序列大小总是会增加额外的复杂性，无论你是在做传统神经网络还是LSTM，因为你必须在反向传播中展开它，这样才能开始实际训练。

但让我们看看LSTM是如何实际工作的。我们不会在底部添加这些额外的神经元，而是简单地传入这些汽车的每一行。因此，也许你连续售出了五辆车，那就是你的序列大小。当你将这五辆车的四个预测值（加速度、每加仑多少英里、重量和类型）传入时，这些值都会输入到你的四个输入神经元中。对于下一个，你将再次调用神经网络，并发送序列中的第二个。随着这一过程的进行，你在提供。

网络中有越来越多的汽车。现在，传统的非递归神经网络与此不同。如果你传入这些加速度、每加仑多少英里、重量和类型的值。如果你传入0、8、2、5和0，你将始终得到相同的类型。就像我们在IR数据集上做的那样，给定神经网络的相同四个输入总是会产生相同的输出，除非你重新训练它，而这些递归神经网络保持状态。

所以当你发送一组输入时，它会给你一个预测，它总是会给出一个预测。然后当你发送第二组时，前面的输入已经被看过。因此，这可以让你观察你的汽车经销商连续售出了这五辆车，基于此我预测下一辆车会是其他车型。你并不是在增加输入神经元，而是简单地发送更多的值。

神经网络和神经网络的内部状态在你每次预测时都会发生变化。这会影响后续的预测。现在，非常重要的一点是要理解这些，因为这涉及到序列到底是什么，比如说你正在做的事情就和我之前提到的一样。

你已经卖出了车1，然后车2，再然后车3。现在每辆车将作为四个值的输入向量，指示其类型，然后卖出了车4和车5。因此，当你依次将这些输入呈现给神经网络时，如果你的序列大小是5，每个输入都是这样，这里是你的神经网络。所以当你将这四辆车依次输入到神经网络中时，我的意思是这辆车是第一、第二、第三和第四。

该神经网络的内部状态正在变化。因此，你首先输入一个，然后是两个，再然后是三个，它预测接下来会是什么车。关于序列的问题在于，神经网络的内部状态何时重置？它在开始时重置。

序列的结束。所以如果我们定义了一个序列大小为四，就像我们这里所示的那样。它将在这里重置，然后再这里重置。当你向前滑动时，因为你不想只做一个预测，现在你想预测两个、三个、四个，你想使用两个来进行预测。

3、4 和 5 并预测接下来会发生什么，现在你将在这里重置它，并在这里重置它。那么现在让我们看看在 Python 中这实际上会是什么样的代码。假设你要预测未来的某些东西，比如股票价格，你现在将有实质上三个维度，而之前你只有两个。第一个轴将是你的训练集元素，这些就像我们在其他数据集中看到的行，它们是你提供给神经网络进行预测的单个训练元素。

不管 x 有多大，y 也必须相应地大，因为这决定了这个训练集实际会产生多少预测。你的第二个轴将是序列的成员，也就是你的时间步，比如第一天、第二天、第三天、第四天，这完全取决于你想如何在 CSV 文件中表示这些内容。通常情况下，第二个轴实际上会成为行，行会变成时间步，轴一则是训练集元素。你从 CSV 文件中无法真正判断这些，只能根据你设置的序列大小来了解。同时也重要的是，序列大小通常是以某种最大序列来设定的。所以如果你将序列大小设置为 10，那么你将有 10 个时间步进入其中。如果对于特定序列的训练没有 10 个元素，通常会将第二个轴上剩余的值置为零，因为这些神经网络足够聪明，可以学习何时收缩和扩展，数据中的特征像输入那些是你的第三个轴，所以它们在大多数数据集中就像你的列。

我们之前看到过像每加仑多少英里这样的数据，前面的例子中提到的每加仑多少英里、发动机大小、汽车类型都在你的第三个轴上。所以这三个轴都是你需要的，因此你现在基本上是在处理一个立方体。让我们看一下代码，我们基本上有一个时间序列。这是一个股票价格，开始时是 32，然后变为 41，接着又回到 32，再变为 20，最后变为 15，你可能想要。

确定在序列的每个点上，是否视其为买入、卖出或持有，其中 1 表示买入，-1 表示卖出，0 表示持有。因此，对于这些行中的每一行，每个训练集元素，你必须有一个 Y 值。你会注意到我在这里加了括号。这实际上是一个二维数组。我这么做的原因是因为你可能想要为此拥有多个输入。

也许你想为每只股票添加交易量。那么，这一天的交易量是多少呢？假设是 32，或许这一天的交易量很大，而那一天的交易量不那么大。所以你可以在这里放入多个不同的值。实际上，这非常常见。如果这些是图像，比如你试图在视频序列上进行预测。

那么这里会有很多你需要添加的值。实际上，你可能会在这里添加2D数据，以表示像素的网格，我们可以看到这本质上是在构建一个CSV文件，这里是它的样子，因此你的x是第一列，然后是预测的Y。

现在，就像我之前开始告诉你的那样，我们可能想要加入交易量，这是你在股市中追踪的两个常见统计数据。股价和交易量，这两者都会上下波动，我们并不预测这两者中的任何一个。

我们试图预测我们是想买、卖还是持有。如果我们创建这种数据，我们可以看到它的样子，注意它是一种数组的数组。你有外层数组，然后在那个数组内部有每对股价和交易量，我们基本上可以将其转换为非常类似CSV的格式。现在序列大小，你可能会发现序列大小可能是3，如果是3的话。

你将对0到2进行预测，这是一个序列，然后预测3。接下来你的序列将是1、2、3，你将预测4，依此类推。现在这是我们实际定义序列大小的地方。因此这里我们有51、2、3、4、5作为我们的序列大小。我们正在创建的确实是三维数据，因为这是第一、第二和第三维。

你可以通过计算前导大括号的数量来知道我们可以打印这些数据，三维数据看起来要复杂得多。但这确实是我们在本模块接下来部分将开始创建的数据，因为我们将实际训练LSTM模型使用这样的数据，即使只有一个特征。

你仍然需要三维数据。这是你正在获取股价，而你只有一个值，但你正在设置这三个维度。因为你没有交易量，所以即使只有一个，你也必须处理3D数据。感谢观看这个视频，在下一个视频中我们将讨论LSTM中的递归神经网络，以便跟上本课程和其他人工智能主题的进展。

T81-558 ｜ 深度神经网络应用-全案例实操系列(2021最新·完整版) - P53：L10.2- 使用Keras和TensorFlow编程LSTM - ShowMeAI - BV15f4y1w7b8

嗨，我是杰夫·希亚，欢迎来到华盛顿大学的深度神经网络应用。在这个视频中，我们将探讨用于时间序列的LSTM和GRU神经网络。想要获取我AI课程和项目的最新信息，请点击旁边的订阅铃铛，以便接收到每个新视频的通知。我们正在研究递归神经网络。递归神经网络。

这有很多不同类型的神经网络，我们将首先看其中一种经典类型，主要是因为它相对容易理解。然后我们将看更现代的类型，如LSTM和GRU。这些不同类型的递归神经网络之间确实存在一些相似之处。因此，递归神经网络通常有一些上下文神经元的概念。

上下文神经元代表一种短期记忆。它在对神经网络的调用之间保持一个值。所以当你试图用神经网络进行预测时，那就是一次对神经网络的调用。😊。

然后你会一次又一次地调用它，当你逐行预测时，上下文神经元开始时为零，但它们会随着后续输入到神经网络中而持有一个值，随着序列的处理而变化。因此，在我们看到这些输入神经元每个都有值的序列之前，这些上下文神经元在每个序列开始时为零，并且随着这些序列的处理，它们保持更新其值。

当你移动到下一个序列时，这个值总是会回到零。上下文在序列之间总是回到零，这是一种非常重要的特性。因此，这是下面两个具有上下文的隐藏神经元的例子。所以我们现在不会像之前那样简单地向前传递。我们将会接收一些反馈。

从我们输出的数据中获取一些反馈。所以你有输入。这是输入1，输入2。进入Hi 1和Hi 2。这些神经元将基于传入的加权和值输出一些结果，然后经过激活函数。它们将产生一些输出。在经典神经网络处理中。

那个输出会直接传到下一层或神经网络的输出端，如果这是最后一层。但在这种情况下，我们将把从隐藏神经元输出的相同值继续传递。那条虚线意味着我们将把它复制到上下文中。因此，通常每个上一层的神经元会有一个上下文神经元。

你只是简单地复制输出。没有权重，什么都没有。它只是一个复制。实线有权重。所以接下来发生的事情是，输入到这个第一个隐藏层hidden1不仅仅是来自前一层的内容，还会得到来自context1的输出，同时也会得到来自context2的输出。

至少在这个特定的情况下。这个神经元的设置，这个网络的设置。这两者都是加权的。所以它会学习如何处理这个值，这里没有权重。简单地说，无论输出什么，都将其复制到下一个层。因此，你始终保留来自隐藏神经元的先前输出值。

并且让它保持直到下一个调用，然后你把它复制回去。你让它形成下一个调用时对隐藏层的输入，并且它就成为输入的一部分。因此，实际上，它就像有三个输入神经元连接到hidden1，但其中两个是上下文层，正好是来自上一个的输出。

这个输出确实是持续存在的。它并不是仅仅影响下一个、下下一个，等等。由于复制到这个上下文中的值，它会被反馈到这里，反流。几乎就像是蝴蝶效应。它对这个神经元的输出产生影响，这个输出然后又被复制到这里，并且在每次调用这个神经网络时持续进行。

这就是上下文如何随着时间的推移影响输出的方式。这也是让神经网络能够处理时间序列的原因。而这些实线导致在神经网络中向后复制的事实，它们有权重，使得神经网络能够随着数据的输入，逐渐学习如何处理这些数据。

这就是时间序列神经网络。所以LSTM神经网络是实现这种记忆的一种方式。现在，我可以用一种几乎是外行的方式来描述这一点，如果我们有一个科学计算器。

我们甚至不会使用这个计算器的任何高级功能。我们主要关心的是记忆加和记忆清除。LSTM神经网络和门控递归GRU神经网络有门，这些是这种神经网络的真正创新。

它们可以让它记住东西，无论是长时间还是短时间。你要处理三个门：输入门、遗忘门和回忆门，有时叫输出门。你可以把这些门视为与神经网络或上下文的记忆有关。

你可以把它们想象成计算器上的记忆按钮。假设我们神经元的输出是5。我们有这三个门。这三个门会告诉你该怎么做。你应该记住它吗？这就像记忆加，因此我把它放进去。现在我们在上下文中有了这个五。

当它下次工作时，我们可能需要决定是否应该回忆起来。这就是MR按钮。这是输出或回忆门。如果你这样做，你的5就会回来。还有一个遗忘门。遗忘门意味着神经网络输入发生了一些事情。它决定需要丢弃记忆，你现在可以清除它。

如果你这样做，你甚至无法进行MR，因为没有记住任何东西。对于这些递归神经网络来说，能够忘记是很重要的。这是元素神经网络的一个限制。你必须慢慢地随着时间的推移而忘记。另一个限制是你不能长时间保留某些东西。

因此，这些新神经网络有门的事实，你可以记住某些东西并将其放入记忆中，然后随着时间的推移再忘记。正如奥特曼所说，对于人类而言，我们最大的优点和缺点之一是能够忘记。如果我们记住了一切，我们的头脑将变得过于混乱，无法正常运作。

重要的是要知道该忘记什么，并且只忘记不重要的东西。那么让我们看看LSTM神经网络。这是LSTM的图示。你有输出，本质上是当前时间、前一时间和下一时间的Y帽。现在，这不是三个不同的LSTM。这是同一个LSTM，而LSTM就像网络中的一个神经元。

你将拥有多个LSTM，就像你有多个隐藏神经元一样。你有输入。这是随时间变化的输入。因此，你只需要一个当前、前一和下一的单一输入值。随着时间的推移，每个相同的LSTM都会将Y帽传递给下一个。所以这是预测，但它也在随着时间保持上下文。

所有这些网络都有某种上下文。神经网络。经典的Elman和Jordan神经网络，或更现代的LSTM和GRU单元在内部。这就是LSTM的运作。你有这些门：遗忘门、输入门、输出门，还有各种阈值夹持函数，比如sigmoid和tanh。稍后你会看到这些，如果你愿意，可以查看这个图示，它基本上代表了与这些方程相同的内容。

我几乎喜欢用方程来思考这些，我会快速带你浏览这些方程。这基本上是在看一种线性代数计算。因此你有权重，那是遗忘门的权重、输入门的权重，每一层的偏差，所以你有偏差神经元和这个向量。

上一个输出和当前输入。这是你要乘以的权重向量。因此，你要做的第一件事是，顺便说一下，S表示sigmoid函数，10 H表示双曲正切。在我们谈论sigmoid和10 H之前，让我先给你展示一下。

注意这些形状。这是一个sigmoid函数。它的值从0到1，并且会夹住这些值。所以如果非常负，它会夹住到0。如果非常正，它会夹住到1。双曲正切。顺便说一句，这与三角学无关。机器学习研究仅仅是因为这些形状。

所以这是一个阶跃函数。另一种类型的阶跃函数。但注意，现在的范围是负1到1。所以，它有一个更大的范围。有时我们需要这些负值，我们会在通过这些方程时看到，我们确实需要这些负值。现在让我们来看看这些方程。我们首先要做的是计算遗忘门、输入门和最终的输出门的系数。

因为这三个值主要会是零或一，因为这些是sigmoid使用的地方。你希望它们是0或1，因为这些值，你希望它们开启或关闭。这是一个系数。因此，如果遗忘门计算为0，这有点反向，但零意味着我们应该遗忘，一意味着我们应该记住。

所以我们根据sigmoid函数计算遗忘门。它通过查看遗忘权重，将其转换为0到1范围。因此，遗忘的权重就是训练能力。随着神经网络的学习，这个值会改变。

通过乘以前一个输出和当前输入的向量，并添加偏置，这也是一个学习参数。通过调整这两个，我们学习何时遗忘。如果F变成0，我们就会遗忘。如果I变成1，我们就会记住。所以你有权重，这些与之前的功能完全相同，这些是你的两个学习参数。

这些会被调整，这就是它学习何时记住或何时输入的方式。C是你的上下文。C上方的小波浪号仅表示你的候选上下文。现在的上下文是它正在记住的值，记住的值是来自神经元的输出。神经元的输出可以是从负一到一。

你不能用sigmoid来做，因为负1到1会剪切掉一半的值，任何低于0的值。因此，我们使用双曲正切是因为双曲正切可以在负一和一之间流动。这样我们就拥有了更完整的值范围。但训练的工作方式与之前完全相同。我们有上下文的权重。

这就是它学习如何具体处理上下文的方式。我们还有一个偏置。这只是候选上下文。真正成为上下文的是这个。现在这是一个不同的格式，因为我们不在学习，这些是用于学习的。这只是一个开关门。注意你有遗忘门和输入门。

输入表示应该进入上下文的内容，遗忘意味着我们是否应该记住之前的上下文。加号将这两个结合在一起。因此，遗忘上下文。如果这是0乘以一个系数，如果是0的话，那么它将抹去之前的上下文，因为0乘以任何东西都是0，输入意味着如果我们在遗忘输入，这将消灭之前的上下文。

这就是为什么它像是内存加按钮，因为这是你的前一个上下文。抱歉，这个是你的前一个上下文。这是候选上下文。所以这是我们在这里计算的可能进入上下文的内容。如果我们应该放入某些东西。所以现在你已经创建了输出门。

你的最终输出本质上将来自于之前的上下文乘以你的输出。这就是LSTM的计算方式。还有另一种类型的递归神经网络，与此非常相似。

这称为GRU，门控递归单元。它的工作原理与此非常相似。让我放大一点。这是学术论文。这不是介绍GRU的学术论文，但它是对门控递归网络的实证评估。实证意味着实验性的。

所以他们并没有做任何数学证明来含糊其辞。他们只是字面上尝试测试数据，并展示GRU实际上能实现什么。在很多情况下，GRU和LSTM的功能非常相似，并且有着相似的准确性。这篇论文更侧重于评估处理时间，GRU没有那么多门，因此更简单。因此你会注意到在摘要中，他们说他们进行了评估。

此外，我们发现GRU与LSTM相当，并且他们也评估了之前的非递归神经网络。因此如果我们查看论文，我想展示的特别有趣的部分是你在这里有我们刚才看到的LSTM及其门。你可以看到顶部的输入门，F门和输出门。

所以在递归神经网络或GRU中，你只有两个门：R和Z，这使得它的算法更简单，并且几乎不需要另一个门。因此，它所需的计算时间更少，并且他们展示了如何计算这些门。但是在最后，论文展示了学习过程，实际上LSTM和GRU在某种程度上是等价的，并展示了实际的时间。

注意这里，GRU的处理时间比LSTM少得多。这就是他们的优势。你可以处理得更多，你的训练影响会消耗更少的时间。现在我们将看一个实际的LSTM例子。我们将看到两个例子。第一个例子非常简单。

这旨在向你展示这种递归类型的神经网络在最简单状态下可以做什么，而这一点是普通神经网络无法做到的。接下来的例子将会看一个实际的应用，我们将查看太阳黑子的时间序列数据，并观察这种递归神经网络如何预测时间序列中的某些东西，至少在一个非常基本的层面上。

预测太阳黑子活动。这展示了如何通过Keras的LSTM神经网络构建一个非常简单的tensorflow。我将继续运行这个程序。它需要一些时间来训练，但还算不错。所以它正在运行，你可以从星号中看到。这向神经网络展示了如何从时间序列中预测某些东西。

这个时间序列基本上可以想象成像是一个在房子前面的相机，就像一个针孔相机，它看到一辆车驶过，可能只看到了一点点车漆的颜色。所以在我们直视的同一位置，我们看到的是零。这意味着我们什么都没看到。但是在下一个时间切片中，我们看到了一辆车。

然后在下一个时间切片中，我们仍然可以看到这辆车，因为它正好在我们看到的针孔前面。现在在接下来的序列中我们再次看到零，因为基本上这辆车已经从我们的针孔中经过并继续前行。

这里是一些序列，一辆不同颜色的车经过，可能是一辆双色车。不管这两个颜色是什么，或许一个是红色，另一个是蓝色，类似这样的。如果我们想让这个更复杂，我们可能会有三个输入。我们会为每一个颜色制作某种RGB表示。但是。

我们处理的是一个非常非常简单的例子。我有这些训练集元素。我正在设置Y，在这个情况下，它在说，嘿。一辆单色的车经过，第二辆是双色车，然后是一辆三色车。然后我们又有一辆双色车的例子。

这是两个，另外一个例子是三个和一个。它在教神经网络，无论在序列中的哪个位置，它仍然是那辆有颜色的车，只是这辆车刚好进入了我们的时间切片，因为它比其他车晚出现。

但这仍然是同一辆颜色的车，和上面很早出现的这辆车是一样的。那么接下来我们要做的是把所有这些元素拿出来。顺便说一下，我们可以表示并且只有一个输入。我们可以把它表示为一个旧的神经网络，我们会有1，2，3，4，5，6。我们将会有六个输入。

但问题是这个一，我们需要去掉所有这些。如果我们想这么做，我们基本上会去掉所有这些方括号，使它们看起来像那样，它将只是经典的输入。我们不想这样做，我们把这些当作序列处理，即使它们是经典的输入。

这些都是输入1、输入2、输入3。如果你把在输入1上的某个东西移动到输入3，那将是完全不同的模式识别，对于神经网络来说，你不能随意地把这些移动到这里并让它仍然识别出来。在经典神经网络和LSTM中，你绝对不能。所以这个神经网络已经训练好了，我们在这里得到了输出，你可以看到训练的结果，我们训练了200个周期，运行了一段时间。

还不错。在我解释的过程中，它在后台运行。现在我们得到了结果。所以现在对于这个神经网络，我在这里有这个代码，我可以在上面尝试例子。让我说，这段代码的设计是我可以随意修改。所以这是一个实时演示，我不知道它将产生什么，希望它能产生一些看起来很聪明的东西，这就是想法。这是一个两色的车，恰好经过这里，我可以运行它，希望它会识别出来，结果确实如此。如果那辆双色车在这里出现，去掉了我不想要的多余价格，它仍然应该说是二，或者如果我忘记了一个逗号，我的电脑不再处于插入模式。让我们继续运行，这确实会让它混淆，如果你接近开头。所以这是二。如果我们把它移得更远，它仍然应该视为二。

这可能意味着它是一辆更长的车，或者可能意味着它是一辆行驶较慢的车。如果我们把所有的改成一，它应该能识别出这是一辆单色车，它确实如此。如果我不知道，这是一辆单色车，可能带有一点红色的涂料，也许一部分是蓝色。

2是红色。看看它在那里的表现。我不知道它会怎么做。我将它识别为一辆两厢车，但至少它不把它识别为三厢车或其他东西。所以这是学习序列。你可以在一个非常简单的例子中看到它是如何学习识别这些模式的。

它甚至可以非常短，并且能够识别它。这就是LSTM的强大之处。它能够识别这些模式，确实是随着时间的推移。接下来我们将看看太阳黑子示例。现在你可以从这个网站获取每日太阳黑子数据文件，我已经将它们加载到我的实例中，但如果你想运行这个特定的示例，你需要下载这些文件。让我们继续读取这个数据。

这基本上显示了年份，而且回溯得相当远，所以1818年第一月第一天，它给你提供了这个值，顺便说一下，这个值只是编码年份日期的一种方式，它给出了太阳黑子值，负一意味着我们没有数据，还有观察数量。如果我们运行它并且去掉缺少观察的数据行，我们会有11000多条记录，我们也可以直接取。

我们将做的是取2000年前的训练集。我们要评估的测试集是2000年后的所有数据。我们为每个数据集创建一个训练集。所以我们为训练集和测试集分别创建一个pandas集合，用于太阳黑子的值。这就是我们要预测的实际太阳黑子数量。

我们打印出每个观察的数量。所以训练数据绝对更大，你几乎有55000个，测试集略多于6000个值。现在我们需要做的是将其转换为序列。这可能是稍微棘手的部分。所以这会将太阳黑子数据转换成一个立方体，用于训练LSTM，为此我们需要使用这个两个序列的函数。这给你序列大小和观察值。所以序列大小将是我们定义的。

所以序列大小将是10，你取数据并剪掉10个观察值，然后向前移动一点，剪掉下一个10。下一个10是一个滑动窗口，构建出所有的立方体行，但观察值是在后面的。所以在这里，我们将其转换为这个序列。我们通过获取从1到1加上I加上序列大小的观察值来取窗口。

我们正在循环整个观察范围。所以不论观察的长度是多少，直到减去序列大小，这样我们就可以在仍有足够数据构建出完整序列时停止。我们基本上会构建这个。

这看起来真的像是X训练，我在这里打印出它们的形状，形状有55000行，有10，这是序列。但它只有一列，因为它只是我们试图预测的时间值，即太阳黑子的数量。我们只打印出X训练。这就是它的样子。

你可以看到个别的太阳黑子值在这里移动。这是一个三维数据结构。所以你有255，2，55到这里。这是一行。你有所有的太阳黑子值，10个在一起。没有足够的展示10个。这就是为什么你有三个点。现在我们将尝试构建模型并拟合它。

当我们运行这个时，它将训练1000个周期。这需要一点时间。我们确实开启了早停机制，因此不会真正花费那么多时间。这可能是一个GPU实例训练会快得多的情况。

但是我们将在最后一节课中看到一个例子，当时我们进行高性能计算，并利用GPU实例等其他工具。因此，我们有6131个样本正在训练。我们报告验证损失。注意，在让它运行一段时间后，损失迅速下降，它不会达到1000个周期的全部时间，会提前停止。不过我会让这个过程在时间快进中运行一下。好的，早停机制已经生效。

你可以看到在16个Ex之后这一点开始生效，我们现在已经训练好了神经网络并准备就绪，可以看到RMSsC。所以它预测了大约22个太阳黑子，这给了你一个整体准确性的概念。这不是一个特别先进的网络，但它确实展示了如何表示输入数据，将其分解成那两组序列，正是我给你的那两个序列函数是实现这一点的关键部分。感谢你观看这个视频。下一期视频见。

我们将看看如何将LSTMs和CNNNs结合使用。

要为图像加上说明，这个内容经常变化，所以请订阅频道，以便及时了解这门课程和人工智能的其他主题。

T81-558 ｜ 深度神经网络应用-全案例实操系列(2021最新·完整版) - P54：L10.3- 使用Keras和TensorFlow生成文本 - ShowMeAI - BV15f4y1w7b8

嗨，我是杰夫·希顿。欢迎来到华盛顿大学的深度神经网络应用模块。在这一模块中，我们将看看如何使用LSTM进行文本生成。我们将看到如何从文本文件创建奇思妙想的😊随机生成。

它会为你生成莎士比亚风格的文本。更有趣的是，你可以给它源代码，它会生成合理有效的，虽然不能编译的C源代码，这些是基于它所训练的C代码生成的。现在，这种LSTM的奇思妙想用法在过去几年中确实得到了不少关注。

这引出了下一部分，我们将使用同样的技术为图片生成字幕。要获取我最新的AI课程和项目，点击订阅并点击旁边的铃铛，以便在每个新视频发布时收到通知。在这一部分和下一部分中，我们都将利用这项技术，在那里我们会做字幕生成，基本上是神经网络，或者实际上是几个神经网络可以查看图像并为其生成字幕，比如你可能会看到一只狗在草地上奔跑，神经网络会字面上写出“狗在草地上奔跑”。在这一部分中，我们将采取婴儿步伐，看看如何训练LSTM在任何类型的文本上，并输出随机的无意义文本。

非常多以这种格式。现在这使用了所有相同的技术，并使我们能够做一些更有用的事情，即实际生成字幕，但这算是第一步。这在几年前非常受欢迎。

有一篇经典的博客文章，我想你会称之为“递归神经网络的非理性有效性”。我将很快给你展示这一点，因为这里的一些例子展示了不同类型的文本可以被生成。

这是安德烈·卡帕西的博客，当他还是斯坦福大学的学生时正在攻读博士学位，偶然间，他所研发的字幕技术也在下一部分中有着重要的地位。所以他尝试生成的第一件事情就是保罗·格雷厄姆的文章，你可以在这里阅读，基本上他创造了LSTM，它能够随机生成这样的文本。

现在的文本是无意义的，这让投资者感到惊讶，他们不会筹集资金。我并不是在与公司的时间相处，他们都是。如果你没有注意，这看起来像是合法的文本，它甚至插入了字幕。如果你想想这里到底发生了什么。

真正令人着迷的是，这个神经网络必须从零开始学习。它并不知道英语。它学会了如何放置撇号，学会了如何使用逗号，学会了在句子末尾使用句号。它学会了在句子开头使用大写字母。

因此，它自学了很多语法。它通过阅读文本学习这些语法，而不是通过将语法规则硬编码到程序中。十年前，自然语言处理中的语法规则和解析树的硬编码非常常见。但随着神经网络和深度神经网络，以及我们正在处理的循环神经网络的出现。

还有更好的方法来做到这一点。我们也会看到神经网络生成莎士比亚的作品。现在非常有趣的是，如果你以前读过莎士比亚，这是戏剧，这是演员们说不同的角色。这非常像莎士比亚的样子。你有一个名字，你有那个人接下来要说的话的下一个名字。

它会预测接下来会说什么。循环神经网络能够弄清楚莎士比亚戏剧的总体格式，并将其写出来。这并不是真正的莎士比亚，但它的样子有点像莎士比亚。我想我现在应该变成这里面，它没有弄清楚英语的某些东西，所有的一词变成了“成为”，接近一天时的“小”。我是说，这就是无意义，但它正确地将这些单词串在一起。

它正确使用冠词。它通常能够弄清楚动词的一致性和其他方面。它通常能正确标点句子。所以这是生成莎士比亚的内容。维基百科生成的内容是。如果你曾经查看过维基百科页面的源代码，它显示你媒体维基标记。所以如果你曾想在维基百科上写一篇文章。

你会用这种形式书写。你放入双括号，这意味着链接，因此这链接到维基百科某处的约翰·克莱尔文章。所以它模拟了维基百科的形式，这非常酷，并且它也开始弄清楚URL的样子。在阅读这些内容之前，它对URL一无所知，而这甚至不是Yahoo上的真实页面，如果你尝试访问，即使在生成时也是如此。

这会给你一个错误。它本质上是记录神经网络的幻觉。我相信这是安德烈在这里称之为的。它弄清楚了维基百科符号的其他有趣部分，我觉得这个非常有趣。如果你曾经处理过学术论文，特别是为了发表和学术期刊，以及会议，我相信你已经处理过LaTeX，LaTeX对于富含数学的文本非常有效。

这里的递归神经网络在一堆 LaTeX 文档上进行了训练，然后被要求生成自己的 LaTeX。就像如果你阅读博客文章可以获得更多细节一样，它大多数情况下是可以编译的。虽然有一些错误需要作者修复，但它能够生成非常像数学的 LaTeX，甚至还有图表。

所以这一切都是从它所阅读的文本中产生的幻觉。这几乎就像一个孩子拼凑单词并开始理解英语。这就是正在发生的事情。在接下来的部分中，我们将看到如何使用相同的技术真正生成真实的英语。

如果你以前没有见过，这就是 LaTeX 源代码的样子。这基本上生成了上面的大部分内容。这可能是它的简化形式。我觉得这个非常迷人。他们用 C 语言编写了源代码，并在大量 C 源代码上训练了递归神经网络。

然后他们告诉它自己梦见 C 源代码。如果你以前没有接触过 C，实际上它的整体语法与 Java 非常相似，令人惊讶的是递归神经网络吸收了多少，看，它的缩进都是正确的。

我是说，这真的很酷，它在声明变量，它在进行检查。现在它确实倾向于使用一些从未定义的局部变量。所以这是个问题，但它正在学习如何正确使用指针语法。它在所有正确的位置放置了分号，当需要时使用括号，对于需要多行的内容使用括号，对于单行则不使用。

这几乎是令人毛骨悚然的，它对源代码的理解达到了什么程度，它在注释中加入了随机文本，这种方式类似于先前生成莎士比亚的程序。它正在学习生成随机内容。

英语文本用于评论。那么现在我们来看看如何生成这样的文本。这些只是我的导入。我将继续执行这个。没有什么特别的事情发生。我将读取一个文本文件。也就是一本完整的书。我们将只用一本书来训练它。所以它不会完美，但会产生一些有趣的东西。

我们将使用《金银岛》这本书。所以《金银岛》是在很久以前写的。这本书的特别之处在于，它是一本儿童书，但几乎为此后的海盗故事奠定了基础。我的意思是，独腿海盗、肩膀上有鹦鹉的海盗，"X" 标记着地点。

所有这些都来自《金银岛》。我小时候读过这本书。这是一本非常有趣的书，而我并不是一个喜欢读小说的人，强烈推荐给对海盗感兴趣的人。但我们来看看能否用神经网络生成海盗故事。我将读取它的文本。你可以看到它来自古腾堡计划。

其中包含大量的英语。也许还有其他语言，我没有跟上古腾堡项目。他们有这本书。在线文本。所以这对于自然语言处理项目非常棒。我将使用您在上面看到的原始文本，并对其进行一些转换。我会删除任何非ASCII字符。范围是0到127。顺便提一下。

我所做的一切都非常基于英语。但我见过LSTM被应用于其他语言，比如中文、日文和其他亚洲语言。所以如果您对这种文本生成感兴趣，几乎可以在任何内容上生成。您在前面的部分中看到。

我只是展示了一个例子，而不是实际的代码，而是链接到某人的例子，该例子使用Gs生成中文字体。所以我会引入这个，获取处理后的文本，运行这一部分，它告诉我语料库的长度。这是《孤岛惊魂》文档的长度。总共有60个不同的字符，尤其是因为我剔除了很多非ASCII字符。

顺便说一下，这一切都非常不错。😊 这段代码基于Kira的一个示例。我对其进行了少许更改，但如果您需要，我在上面有原始示例的链接。基本上，您可以在几乎任何文本上运行这段代码，我在《孤岛惊魂》上运行了它。原始代码实际上是查看哲学家尼采并生成额外的文本。

看起来是来自尼采的。所以当您运行这一部分时，它使用的最大长度是40，这是您的序列大小。我们将抓取这个文本的40个字符块，然后给它下一个字符。所以在那之后的第40个字符，它将用来训练模型。

给定这40个字符，尝试生成下一个字符，这就是我们实际生成文本的方式。然后我们将选择40个真实文本字符作为种子开始。接着，它会生成第41个字符，然后我们给它39个种子字符和第41个字符。

生成的第41个字符，然后它生成下一个字符，因此它会不断生成更多，最终我们会超出种子，得到的都是生成的文本，因为它生成了第一个字符，然后是第二个、第三个、第四个，依此类推。我们将看到实际的代码，但基本上这是遍历整个文件，将其分成40个字符的块，第41个作为y步长，这意味着对每个抓取的40个字符块向前移动三个字符，如果您在这里输入1。

它会抓取尽可能多的序列，因为它只会将其移动一个字符，您将得到更多冗余序列，因为如果您向前移动一个字符，您将获得39个相同的字符。

向前移动一个。因此我们将运行这个，它将《金银岛》减少为 132000 个这样的序列。如果你打印出其中一个，可以看到这很好地展示了项目 Gutenberg 的电子书《金银岛》，然后看到它向右移动了三个。

所以这些都是输入，然后它将被训练以预测下一个字符是什么。现在我们将进行向量化。这将其转换为实际的 x 和 y，接下来会用到，运行需要一点时间，但还不错。我们实际上使用的是索引。所以如果我们看一下这些形状，所有这些序列，40 是输入向量，60 是输出的虚拟变量。

所以这个输出基本上将是这 60 个字符的虚拟变量。记得我说过可能会在《金银岛》中出现 60 个不同的字符。这基本上是生成这些字符的。然后 Y 形状非常简单。它是 132000，但这些都是相同的虚拟变量。这些都是预期字符。所以所有在训练数据中出现的 60 个字符以及输出字符都表示为虚拟变量。这就是这些变得有点浪费的地方。我是说，如果我有完整的 255 ASI 集，那将是 255 个虚拟变量，这简直疯狂，尤其是使用 Unicode，看看这些虚拟变量。

这些基本上是输出。所以一个是真的，其余都是假的，这表示这个特定的字符是下一个预期的字符，LSTM 模型本身相对简单。我直接从示例中获取超参数，在 Car 中我们有一个 LSTM 层，包含 128 个神经元，我实际上没有使用 dropout 或其他类似的东西，我见过一些例子确实使用了这些，示例使用 RMS 进行了训练，你可能可以。

使用 Adam 也是如此。我将继续运行这个，让它开始训练神经网络，同时我解释一些内容，因为运行需要一点时间。你可能想在 Google Colab 或类似的地方在 GPU 上运行这个。

好的，这里是总结，这在很大程度上呼应了我们刚才提到的内容。尽管有这些星号，它实际上已经通过了这些。这是样本函数。这实际上是生成文本的。因此，你传递的 pres 是输出神经元。这将在《金银岛》中是 60 个值。

这将是 60 个概率。所以这 60 个输出神经元中值最高的就是具有最高可能性的字符。然而，我们并不是简单地这样做，我们将这些输出神经元规范化为 softm，使它们的概率相加为 10，然后我们有一个叫温度的东西。现在温度就是安德烈在他之前展示给你看的博客文章中提到的东西，本质上是 1。

将是最保守的。它几乎会选择概率最高的字符，零则会稍微更随机，我们将看到它产生的示例，零会有更多的语法错误，但会生成更有趣的文本，我们将看看其中的一些例子，你实际上可以将其设置得更高，甚至高于1。

0为使其更保守，这本质上是一个softmax函数，它基本上是在做一个求和，并确保所有这些概率加起来确实等于1。0这是文本生成器，所以我们在每个epoch结束时将其作为回调挂接上。这是非常有用的，因为这个神经网络训练需要一些时间，我想我们训练了六个epoch。

我们可以看到它在最后生成的效果。因此，基本上我们为这些温度展示它。这是0.2，比较宽松，到1.2则相对保守，非常保守，我们基本上生成种子。因此，种子来自我们处理过的文本《金银岛》，这个种子将用于启动生成，换句话说，这40个字符是用于生成下一个字符的第一个字符，然后它会继续下去。

然后我们将为接下来的400个字符生成内容，并将其构建为输入序列供神经网络使用，在我们进行预测时，我们将生成的内容加到我们预测的下一个字符上，因此我们不断添加更多的字符，最终种子会从边缘滑落，因为第一个字符被移除，因为一旦我们在末尾添加一个生成的字符。

我们必须从开始的部分弹出一些内容，以保持在400范围内，然后我们像以前一样打印文本。所以这实际上会输出训练神经网络时的文本，我们把刚才看到的函数作为一个lambda回调，这样在Keras运行时就可以调用它，然后我们基本上像之前看到的那样拟合它，因为我们有那个回调。

这就是输出的样子。这是第一次epoch，你可以看到它在这里进行训练，这里是生成的文本，这可能获取了一些媒体维基的信息，但可以在“声音的船长”找到。现在请记住，神经网络是在第一次epoch上，它的训练效果不是很好，但看看，它已经搞清楚了名词前通常会有的“the”这类事物。这是使用非常低的温度，所以这将是质量较低或最不保守的。如果我们去最保守的1.0。

2。信息可以在以下位置找到，尽管目前的效果仍然不佳，因为它实际上刚刚开始。我们已经进行了第二个周期和第三个周期，它继续训练，并随着进程不断展示结果。它将在60时结束，因此五个中的60我们不会让这个东西完全运行，但我们可以看到它正在生成自己的海盗故事。这听起来像是海盗的谈话，实际上我不认为这在语法上是正确的。这听起来像是关于你的故事，我并不擅长用海盗口音说话。在这里，你可以看到它实际上是作为查询神经网络时输出的。这是文本生成的一个很好的例子。除了显示它确实能够掌握英语及其相关内容之外，这并没有特别的用处。在下一部分中，我们将看到如何从图像生成标题。感谢观看本视频以及下一个视频。

我们将探讨如何使用相同的技术来标记图片并生成描述该图片内容的标题。

T81-558 ｜ 深度神经网络应用-全案例实操系列(2021最新·完整版) - P55：L10.4- 使用Keras和TensorFlow进行图像描述生成 - ShowMeAI - BV15f4y1w7b8

嗨，这是杰夫·希顿。欢迎来到华盛顿大学深度神经网络的应用。在这个视频中，我们将探讨卷积神经网络与LSTM的有趣结合，这使我们能够为图像添加描述，以便看到图像中的多个元素并用一句话来描述它。要获取我最新的AI课程和项目，请点击旁边的铃铛订阅，以便收到每个新视频的通知。图像描述生成。

至少我第一次看到的是安德烈·卡帕西的论文。我们在上一节中提到过这个人，一些LSTM文本生成的内容来自于他。他在这方面也做了一些非常有趣的工作。所以这位研究者非常有趣，现在为特斯拉工作。

他为我们现在处理的一些计算机视觉软件创建了大量代码。这实际上是他论文中的一幅图像，或者至少是他网站上的一幅图像，展示了描述生成的效果。😊。

通常在生成描述之前，我们会尝试将某物分类为猫。然而，这里还有一个滑板，以及其他一些部分，比如门。后来我们进入了多图像分类，所以我们会说猫和滑板，就像是黄色。现在我们想要实际将文本生成与图像分类结合起来，能够为这些图像写描述。我们将使用重度迁移学习，因为从头开始训练这个东西会耗费很长时间，即使使用迁移学习。

我们将使用相对较小的图像集，它不会完美，但会生成一些具有相当好意义的描述。它们不会完美。当我们使用我在这个课程的GitHub上存放的个人家庭照片时，我们会看到这一点。

你在这个课程中见过很多这样的例子，其中一些来自狗Hickory，它们是非常好的测试，因为它们完全不在Imagenet中，而且都是我选择的照片，因为我认为从机器学习的角度来看，它们很有趣，有些可能并不容易被这些神经网络分类。现在我们将从Inception V3和GloVe进行迁移。Inception V3是众多经过Imagenet训练的神经网络之一，MobileNet我们在这个课程中也用过几次。现在我已设置为可以使用MobileNet而不是Inception，但在这个案例中Inception表现更好。我会在到达那部分时详细说明实际的区别，GloVe是自然语言处理的嵌入。

我们将在下一个模块中学习更多关于这些内容的知识，当我们进入自然语言处理时。这基本上就是它的工作方式。实际上，这与我们在上一章中进行的文本生成非常相似。但现在我们不仅仅是生成随机的无意义句子，而是实际上要生成有意义的句子。

你可以理解我们为什么从前面的部分开始，并学习如何仅教授神经网络。语法的基础以及如何将内容组合在一起。实际上，我们只是在引导它们了解语法知识。我们并不是在真正教它们语法。相信我，早期的自然语言处理痴迷于教神经网络所有关于语法规则的知识，并将语法规则编码化。

相信我，这非常困难。现在，想法是使用大数据，大量文本，让神经网络自己学习语言。这就是它的工作方式。以前，我们在生成无意义句子时会输入大约20个字符。现在我们不再基于字符，而是基于词。

我们可以基于字符做字幕。这可能需要更多的训练，而这就是我目前正在使用的技术。如果你想尝试基于字符的方法，我绝对鼓励你。我也很好奇你会得到什么结果。你可以使用这段代码作为起点。

但是由于现在是基于词的，我们将呈现一个向量。这将输入到神经网络中，单个元素不是字符，而是单词，我们有一个特殊的标记词叫做“start”，这就是一切的起点。因此，与之前给种子不同，因为我们需要生成整个字幕。

我们真的无法给它种子，因为我们不知道字幕是如何开始的。所有字幕都以单词“start”开头，而这甚至不是实际的单词“start”。这只是我们使用的一个标记。然后我们最初只发送“start”，但这是诀窍。神经网络可以接受许多不同的输入和多个内容。

所以我们的输入实际上与前面的部分非常相似，但我们也输入了整张图像。所以有两个输入进来，我们会看到Kira的功能性API与序列相比在这里绝对是必要的。

所以我们使用模型和Kira的功能性API来处理Resnet以及目前课程中的其他几个部分。但我们肯定会使用模型和功能性API，因为这是一个相当复杂的神经网络，我们给它一张图片，然后像在前面的部分一样逐步构建这个网络。

所以我们从开始部分开始。一张狗在草地上奔跑的照片。那实际上是我的狗。然后神经网络会接收这两者，并返回概率。然后它会说，好吧。我想下一步可能是“跑”。现在，如果我们在这里输入“a”和“狗”，那么“开始一只狗跑”将是最高概率。现在。

这真的很长，因为这组虚拟变量包含了这个词汇表中的每一个单词。我们稍后会看到词汇表的大小，但有很多虚拟变量。所以这是我们要构建的整体结构，我们将训练这个神经网络，显然使用迁移学习，这样我们就不必从头开始训练。

那么你应该总是使用迁移学习，如果可以的话。我不会实际运行这段代码。根据我的记忆，大约需要两个小时或三小时来训练这个神经网络。所以我已经把它全部运行过了，Github上上传的版本应该是预先运行过的。

现在你可能会看到一些不同的标题。如果你将这段视频中的内容与实际网站进行比较，因为如果我重新运行，这一切都是随机的。所以你绝对可以得到不同的结果。随着学期的进展，我会倾向于重新运行这些，因为不同版本的Tensorflow会出现。所以你会看到不同的结果。这些是你需要的所有导入，唯一有点有趣的是这些是开始和“in”标记。

所以我们在这里用开始标记启动它，并不断添加额外的单词。如果我们仅输入“开始”，它会希望给我们一个，然后我们再输入“开始”和“a”，它会希望给我们“狗”，然后我们给出“开始”、“a”和“狗”，它会希望给我们“跑”，然后继续。

最终它会给我们一个“in”标记。所以要么我们在这里撞墙而没有空间，要么我们得到一个“in”标记。这就是神经网络的输出可以是非常不固定长度的原因。如果你需要一个神经网络生成一个句子或提供一些不固定长度的内容，这就是你通常需要做的。你需要逐步构建，让神经网络为你不断添加新的元素。Epochs指的是我们将训练它的周期数，我们不使用提前停止或其他任何东西。如果你想尝试mobilenet，只需将这里的值设为false，这样效果不好。

我有我的小时和分钟字符串，因为我们会计时这些事情花费了多长时间，绝对要使用coab。GPU是你的朋友，如果你有自己的更快的GPU，绝对要使用它。你需要下载一些数据集。所以在这里我有路径内容在我的驱动器上。现在，如果你将你的东西放在不同的位置，可能需要更改这个路径，但你需要为该文件夹中的每一个目录创建目录。

你可以从源代码中看到，它们的名称都是这个，然后你需要创建一个数据目录，输出文件将创建在这里。这些文件应该直接来自标题。因此，解压这两个文件并放到那里。顺便说一下，获取 flicker8k 数据集可能有点棘手。可以在这里阅读相关文章。

关于这个问题有一些版权问题。因此，这很复杂。并不是说很难获得。我无法将其放入我的 GitHub 存储库，因为它不是我的。所以如果你点击那个链接，你可以准确找到如何获取它的方法。因此，我们将清理这个数据集，并开始处理它，顺便说一句。

这个数据来自 Flickr。它有 8000 张图像及其对应的标题。因此，这正是我们需要的，我们需要将其拆分，而我们在这里所做的就是清理描述。我们基本上将其转换为小写，并去掉标点符号。这些是我们正在移除的某些标点符号。我们基本上是在移除。

这里是一些非常简短的词。我们正在移除那些没有字母组成的词，并逐渐确定长度。因此，我们需要知道最大标题长度，因为这将是我们的序列长度。然后我们逐渐构建这些词的字典。接着，我们可以打印出我们收集到的内容。因此，查找的实质是独特词汇的数量以及我们字典中的词汇数量和最大长度。

最大标题长度。然后我们加载 GloVe 嵌入。GloVe 嵌入基本上是词汇中每个词的向量。这些词汇中的每个词都将有一个相应的向量，这些就是我们放入神经网络进行预测的特征，而不是直接进行。

说索引号码或虚拟变量。这比为每个词汇使用一个虚拟变量要好得多，因为词汇中有很多词，这将会产生大量的额外数据。我们确实在神经网络的输出中使用了词汇的虚拟变量。

但我们不会在输入中使用。另一个优点是，这些词的向量，相似的词，向量在欧几里得空间中会更接近。因此，利用线性代数，你基本上是在计算两个向量之间的距离。两个相似的词在空间中会相当接近。我们读取所有的图像名称。

我们基本上准备加载所有内容。训练集中有 6000 张图像，测试集中有 1000 张。然后我们构建所有这些描述。因此，将从开始标记开始。接着会有标题的实际词汇，并以停止结束。这就是我们基本上如何开始和结束标题生成过程的方法，正如我们在之前的图表中所看到的那样。

现在，我这里有代码可以使用inception或mobilenet。这输出维度中的这个数字，确实是原因所在。所以这会转换每一张图片。使用inception，如果你直接使用inception，它会返回1000个概率，因为imagenet中有1000张图片，每一张图片。

它会给你这个图像是其中之一的概率。我们去掉了那一层，下面是一个2048维的密集连接层。我们基本上像之前在迁移学习中的特征工程中看到的那样使用这些输出。我们将其用作特征工程。因此，这个从inception中输出的2048维向量，上面的一些层被去掉了。

这就是我们在这里做的。我们去掉了两个层。这些本质上成为了这些图像的工程特征。再说一次，就像使用glove一样，2048维的相似图像在向量空间中应该更接近。注意这里输出维度有多少。因为mobile net试图与移动设备和功耗非常兼容，所以那里没有密集连接的层。

所以当你去掉那些顶层时，你的维度数量会激增，而你有50。这对于特征工程来说并不是理想的，因为这会是一个非常稀疏的向量。至少我在许多实例中检查时，会发现很多维度为0，结果不会那么好，使用2048维的结果会更好。

不过你可以进行实验，代码应该都能正常工作。这些是你需要更改的关键常量。你需要改变高度和宽度，因为不同的迁移神经网络是为不同的图像大小训练的，它会打印出摘要。

这相当长。它是我们迁移的一个长神经网络。我们将创建训练集。因此，对于每张图像，我们需要对其进行编码。我们基本上是将图像编码为输出维度的大小。现在就是这样。你无法改变那个常量和输出大小。

所以我们本质上是在处理图像。我们将其调整为标准大小。我们不担心保持宽高比。迁移的神经网络往往会解决这个问题。我们进行迁移神经网络需要的任何预处理。我们在这里扩展维度。我们基本上是将这些图像加载时的长字符串处理。

并将其放回到图像应该真正处于的网格中。在这里，我们实际上执行任何预处理，而不是在这里。那基本上是转换为数组，然后我们调用mobilenet或inception进行预测。那是如何变成2048维向量的。然后我们将其重塑为正确的大小。

本质上是为了预测或输入到神经网络中。这是我们生成训练集的地方。这是我们反复调用的地方，这可能需要一些时间。因此，在加载后我们实际上会将训练集进行序列化，所以我们正在加载所有这些JpeEgs或PGs，或者那些图像数据，并将它们转化为这个东西压缩成的2048个向量。

所以这大量的图像处理不一定需要花费巨大的时间，但可能会花一些时间，这就是我们处理标题的地方，我们将它们整理成相似的结构。现在我们有30000个标题，因为每张图像最多提供五个不同的标题，这就是数据的方式。因此，每张图像实际上都有多个标题，这样挺不错的。我们将去掉一些。

不经常出现的单词。因此我们的词汇量降到了1651。这帮助了很多。我们建立了两个索引。每一个我们处理的1651个单词，这也添加到标记中。我们有一个根据索引号返回单词的索引，还有一个根据单词返回索引的类似的索引。因此，你有一个双向的字典来查找这些单词。

我们会将最大长度加上两个，以考虑这个开始和结束标记。然后这就是使用数据生成器的实际样子。我们将开始，只需开始。它应该，所以我们多次调用那个神经网络。调用它会开始添加一个。所以这就是训练集的实际样子。

所以只是一张图片和一个标题。这里的想法是这个训练集将是巨大的。因此对于每张图像，这只是一个图像。这是我的狗在草地上跑的情景。它不在数据集中，但我用它作为例子。对于这一张，我们将有五个不同的标题。我们可能会有像“狗在草地上跑”这样的标题。

狗跑动的所有这些不同变体可能是什么样的标题。但对于每一个，这里只展示一个标题。我们需要生成它的所有阶段。我们需要生成这个图像并开始返回“狗”，然后用这个图像开始返回“狗”。开始“狗”，返回“跑”。在这个训练集中有很多数据。

所以我们将使用一种叫做生成器的东西，以使其在RA要求方面不那么疯狂。然后你将得到你的第二张图片，因为数据集中有56000个这样的。所以每一个，你必须真的在训练集中将图像复制五次，以对应每个标题的五个版本。然后每个标题还会有一些额外的条目。

所以你需要为每一个中间位置复制那张图片。这是大量的数据。所以我们使用数据生成器。数据生成器是我们将要使用的。不会像之前那样生成这个大矩阵来传入。基本上，这里发生的事情是它在遍历所有的键。

这些基本上是我们拥有的所有图像。然后对于每一个图像，我们循环遍历所有描述。因此有五个描述。然后我们生成。这些是我们需要为每张图片生成一个、为每个描述生成一个的维度的百分比。然后是这些词的每种组合，以便我们捕捉到所有的中间形式。

我们还考虑到每批次希望有多少张照片，这是一个训练超参数。这个大的循环并不是直接运行并生成的。如果这样做，它会倾倒大量数据。这就是Python中yield命令的作用。这基本上是一个动态集合，你正在构建，每次你触发yield时。

它基本上让这个循环保持在冷冻干燥模式。所以它只是冻结它，并让程序继续进行它的工作。然后下次这个被调用时，它会回到这里，并从上次循环的确切位置重新开始并返回。返回它。这些是GloVe嵌入，以便我们可以将这些单词转换为每个单词的200个值。

你必须设置那个常量。你不能改变它，因为它是由GloVe固定的。然后我们基本上只是构建所有那些我们拥有的标题词的输入，并将它们全部查找。你可以看到这个的基本形状。所以我们使用了一个嵌入层。我们有1652个单词，每个单词都有200个元素。

这200个元素是GloVe将每个单词转化为的向量，因此相似的单词在向量空间中会更接近。这使用了一种叫做Akira的嵌入层。我们将在下一个模块中学习更多关于这个的知识，当你学习NLP时。这些非常好。这让你在内部进行整个查找。

这就是神经网络的样子。😊 输入1是你的图像，输入2是你将每次发送的逐渐增加的标题。这就是嵌入层的作用。它使用词汇量大小，并利用我们创建的嵌入矩阵，这个矩阵基本上成为那个层的权重，我们稍后会看到我们在这里创建它时并没有转移它。

它用随机权重初始化，但基本上是一个这种大小的矩阵，以便为你执行那些查找。它会查找每个单词并填入正确的200个值。我们有一些丢弃层，并且我们有256的LSTM，这实际上非常类似于我们在前一部分用于文本生成的LSTM层。我们基本上将这些添加到神经网络中，我们有一个最终的256密集层，最后的输出层将是词汇大小，因为你有虚拟变量输出。

本质上，我们创建一个模型，这使用的是Keras功能性API，以便我们可以有输入。我们可以有多个输入，输入一个和多个输入，当我谈论它时，比如说可能有三张图片进来，或者一张图片和一个标题，或者三张图片加一个标题，随你如何设置。

这是我刚才描述的我们网络的摘要。这非常重要。这是我们基本上从GloVe获取嵌入矩阵并将其直接放入神经网络权重中的地方。所以我们覆盖了神经网络的权重。它为我们提供了一个查找，当它看到单词5时，例如，它会去到列行。

根据矩阵的方向，将其放入特征向量。我们可以为分类交叉熵构建整个神经网络，因为这是一个分类神经网络。我们现在将以批量大小为三进行训练。这是我从一些原始论文中获得的。我们基本上正在进行这个。因此，我们有10个训练周期。

我们将在这个学习率下进行20个训练周期，然后是最后一个周期。我们正在减少学习率。我们也可以为此使用调度程序，但这相当简单。现在我们保存神经网络。如果我们看到它已经存在，我们只需加载它。我们不重建它，因为这部分会花费一些时间。

现在，当我们需要实际生成标题时，这就是将要执行的函数。这实际上与我们在前面部分生成随机文本的函数有些相似。它将构建一个序列，长度达到最大值，基本上就是从起始标签开始。它会用零填充序列，因为必须到达末尾。

我们将请求一个预测。我们的最大值获取这些预测中概率最高的那个，因为那就是我们要添加的单词。然后我们加一个空格。如果我们得到了停止标记，那么我们就停止并继续。最后，我们将其分离并返回一个文本字符串，告诉我们标题基本上是什么。

现在如果我们调用这个并评估它。这是一些实际结果。你可以看到这两个人一起骑自行车。它说，穿白衬衫的男人站在一个戴蓝色帽子的女人旁边。好吧，接近。它对正在发生的事情有个不错的想法。如果我们查看更多这些，这里还有另外一个。

有一只狗被网球轰炸。狗在追逐一个球。好吧，是的。它有点跳跃着去追。可以接受。有一只狗在混凝土上或者可能是在雪上。两只狗在草地上奔跑。好吧，现在是一只狗。黑白狗在雪中奔跑。这是我看到的三个中最准确的一个。

所以这很好。再说一次，这些并不完美。需要投入更多训练，可能还要更大的数据集，才能让这些更好。看起来有两个家伙走在地上，旁边有一些奇怪的涂鸦。穿黑色外套的人站在穿黑色夹克的女人旁边，距离相当近。

它没有搞清楚性别，但在一个男孩身上搞对了性别。两个孩子在蹦床上玩。穿红色衬衫的小男孩正在从秋千上跳下来。我可以理解。也许那儿有个秋千。但我重新运行了几次，它确实注意到了蹦床。所以它能看见这些东西，真不错，有时有两个穿比基尼的女人在海岸线附近。

一群年轻人。好吧，我相信他们正在爬上岩石进入水中。所以你可以看到它正在弄清楚，看到岩石，看到了水。很有趣的是它把语法弄对了，进入水中。所以我想它在东西前加了冠词，做得很好。

这是只狗，狗在草地上跑。所以好吧，这些照片是这样的。现在。它并没有用这些进行训练。这些来自同一组。这是测试集。如果你在我一些照片上评估它们，这些来自GitHub，它的表现不太好。现在，这有点残酷。

但这就是你测试这些东西并展示局限性的方法。我站在这里，这是佛罗里达的一所大学。其实这是我获得博士学位的大学。那是个塔迪斯（TARDIS）。如果你看过《神秘博士》，那就是里面的东西。但这只是一个电话亭。

可能没有塔迪斯，只有电话亭在训练集中。所以穿黑色衬衫的人。其实是蓝色衬衫，但我把责任推给了相机。还有牛仔裤，我的牛仔裤可见。所以在街上看起来很酷。好吧，它可能认为这些事情通常发生在街上。但实际上是在建筑物内部，但这实际上还不错。

这是我坐在那里的样子，穿黑色衬衫的人。甚至一点也不接近。我只在被迫出席时才会系领带。我现在不喝酒。这是我母亲的狗。两只狗在草地上打斗。我不知道那只狗，也许正在经历双重人格。我注意到在Flickr数据集中，很多照片都有人的动作。这儿没有人。

这是我和妻子参观的一家民宿，我们刚拍了张照片。所以这完全是一幅风景照。没有工作人员。这儿有台阶。也许这是我、我的妻子和穿红色衬衫的狗。这里说的是我的妻子，她不是男人。她是个女人，坐在凳子上，穿着他的鞋子。

远远不够。这是我坐着的样子。我喜欢这块石头。它在华盛顿大学。我称它为 GitHub 岩石，因为它看起来很像 GitHub 的那些绿色方块。穿着泳裤的人。我并不是穿着泳裤在战争鞋中间。我可能会因为手里拿着饮料而失去工作。是的，它真的让我想要得到。

我并不是穿着泳裤、手里拿着饮料在大学的中间，所以无论如何。这只是尝试在一些图片上，所以在这门课程和其他主题及人工智能方面保持最新。

T81-558 ｜ 深度神经网络应用-全案例实操系列(2021最新·完整版) - P56：L10.5- Keras中的时间卷积神经网络 - ShowMeAI - BV15f4y1w7b8

嗨，我是杰夫·伊顿，欢迎来到华盛顿大学的深度神经网络应用课程。你知道吗？ LSTM、GU 和一般的递归神经网络在时间序列预测中确实失去了某些青睐，尽管这些是最初的深度学习，甚至传统的元素和乔丹网络被引入用于时间序列。但你猜怎么着，卷积神经网络也能处理这些事情。

有关我的 AI 课程和项目的最新信息，请点击旁边铃铛的订阅，以便在每个新视频发布时收到通知。你通常会将卷积神经网络视为图像，或者至少你几年前是这样想的。

现在，CNN 被应用于各种各样的事物。特别是时间序列，很多最新研究确实使 CNN 在一些复杂的时间序列和自然语言处理任务中占据优势。所以我将向你展示如何使用时间卷积神经网络，Keras 在这方面并没有我希望的那么先进的预构建库，其中最好的一个链接在这里。

但目前在 Tensorflow 2.0 上不可用。我怀疑在学期开始时会得到纠正。所以当我们达到学期的这个节点时，我会给你更新。对于这一部分，我们将使用我之前给你提供的关于时间序列的两个示例。

所以，这里我有的时间序列玩具数据，以及日斑的示例。我们会展示我们在 LSTM 中做的这两个，几乎可以使用完全相同的代码。只需将 CNN 替换为 LSTN。数据实际上以我之前告诉你的设置3D张量输入的格式进入，仍然适用。我们在这里设置3D张量。这是同样的示例。

这是关于潜在汽车的训练，正前方只看着一小束激光。所以我们可以看到，颜色1的汽车在这里。因此，Y 被分类为1。颜色2的汽车在这里，被分类为2。如果你想了解更多细节，我在模块10的第二部分讨论了这个数据集。

这只是一个玩具数据集，用于真正展示如何使用 LSTM，但在这种情况下，我们替换掉了 LSTM。我们使用的是 con1D。这本质上是内置于 Keras 的时间卷积。更高级的版本，我会在我们达到学期的这个节点时更新你该库的进展，是使用一种叫做残差的东西。

这非常接近我们在 Resnet 中使用的内容。现在，在整个学期中，我们将使用 con1D。我不会在最后一分钟更换，因为我总是在学期开始时锁定版本。相信我，Tensorflow 和 Kias 在一个学期内可能会有很大变化。

这些东西以光速移动。所以让我继续运行。它将像LSTM一样训练。我的想法是，我可以在这些中的任何一个地方放一辆车。它会学习到，好的，这两个在一起，或者甚至三个在一起。也许是一辆长车可以被识别为二或三等。

不管是什么颜色，完全没有RGB编码。只是一个是一个颜色，两个是另一个颜色。同样，这只是一个玩具示例。看起来它已经训练好了。好吧，让我们试一下。我把车子放在了向量的边缘上，但我们还是运行一下。它仍然表示这是某种类型的车。如果我移动车子，或许它就会改变。

早些时候拍的照片就在这里。它应该仍然返回一个，工作方式与之前的示例非常相似，之前使用的是LSTM。如果你想要Sunspot数据的完整描述，请参考该模块的第二部分。但本质上这是每月的日冕数。

我们试图预测这些，因为它会上下波动。我在这里有数据文件的链接，因为数据文件是由政府提供的。因此，你需要下载并将其复制到你的文件夹中。我把它放在数据目录下，但你可以放在任何地方。我现在就运行这个，已经加载好了。

这就是Spot数据的样子。我们主要处理年份和月份，查看Spot值。在这些早期年份，它们不一定总是有值。这里我们修剪掉那些缺失观测值的早期年份。我们将其分为测试集和训练集，2000年前的都是训练集。

2000年后的数据是测试集。我们将这些数据转换为序列，和之前做的一样，这只是时间序列编码。因此，我们处理序列大小为25。所以我们将其分成25组，然后尝试预测第26个。这有很多不同的组。

我们可以从数据中提取的信息。我们可以查看Xtrain的样子，所以它包含那些序列。25。这是最初的日冕数，所以253、240，所有这些日冕，然后y只是一个数组，表示在训练序列之后的日冕数。这是我们构建模型和训练的地方。这使用了提前停止功能。我会快进这部分。

所以让我们在训练集上运行RMSE。然后在测试集上运行RC，看看表现如何，21的RC实际上相当不错。这是日冕数，这些数值在几百左右。所以准确性是合理的。这个内容经常变化，所以请订阅频道以保持对该课程及其他人工智能主题的最新了解。

T81-558 ｜ 深度神经网络应用-全案例实操系列(2021最新·完整版) - P57：L11.1- Python中的Spacy入门 - ShowMeAI - BV15f4y1w7b8

嗨，我是杰夫·希顿，欢迎来到华盛顿大学的深度神经网络应用课程。现在我们将开始探讨自然语言处理，特别是汽车相关的内容。我们将首先看看一些工具，这些工具帮助我们在将数据预处理到神经网络之前进行处理。我们将讨论Spacy，这是关于AI课程的最新内容，并提醒你注意我们主要处理自然语言的内容，它涉及字符、率、故事，基本上是对其的再现。处理它的第二种方法是按词级进行，而我们确实在字幕中按词级处理过，实际上你可以将这两种技术应用于任何类型的问题，词级NLP可以很好地处理。

你可以使用Python中可用的额外库，在将这些单词送入实际的神经网络之前对其进行处理。字符级别有其优点，因为你并不在处理这些问题，因为你让神经网络自己去弄清楚英语后缀、前缀以及所有这些语法类型的表达。

一些技术对于其他技术来说更好。自然语言处理的传统方法是进行大量的语法分析。而现代的新技术几乎是端到端的，神经网络直接在原始文本上操作。

然而，你有时仍然会在词级上进行一些处理。因此，我们将看到如何使用一些Python包来处理文本中的实际单词，在将它们发送到神经网络之前。关于可用于Python的自然语言处理库，除了Tensorflow，还有几个，但是我看到的两个特别突出的是NLTK和Spacey，这在Kaggle比赛及相关文献中得到了体现。

NLTK的出现时间比Spacey更早，已经使用了一段时间。目前我都使用过这两者，我更喜欢Spacey。这就是我们在课堂上将使用的工具。它更面向对象，而且这种面向对象的方式很好，相信我。

这可能会以一种糟糕的面向对象方式实现，意味着它实际上将单词转换为个体对象，从而提供关于这些单词相当多的信息。现在，安装Spacey时，它应该在你通过模块1并完成我给你的所有Pip安装时已经安装过。

Spacey是我指定的你应该安装的包之一。然而，如果你只是安装Spacey，它是无法工作的。它需要一个词典。我建议你为这门课安装英语词典，因为这正是我们要使用的。如果你还没有安装词典，可能在运行这个模块中的代码时你没有。

你会遇到一个错误，比如要安装 spacey 字典。这是我发现的最佳命令，如果你遇到问题，你可能想要谷歌搜索它们，或者在课堂的 Piazza 或 Sla 上发帖，我会看看如果你遇到特定错误我能做些什么，同时在评论中发帖。我遇到过几乎所有可以想象的错误。嗯，这不是事实，总是会有人让我感到惊讶。

但我并不总能调试所有内容，因为我需要在我的计算机上实际运行它给你带来问题。所以相信我，如果你遇到错误，谷歌是你的朋友，只需复制并粘贴这段内容到谷歌，你可能会被引导到 Stack Overflow。你将会听到的一些术语，像这种分词是一个重要的概念，分词就是将句子拆分成单个单词。

这比听起来更困难。让我在这里放一个单元格。考虑一下这些句子。如果我给你这个句子：这是一个测试，那将很容易进行分词，单词是“这”、“是”和“一个测试”。所以里面有四个单词。然后你会得到更复杂的句子，比如“好的，但这怎么样？”

现在你需要决定如何进行分词。你可能不想失去那个逗号。那个逗号可能是有用的，或者你可能希望逗号消失。所以如果你把它拆分成一个单词列表，可能会变成“好的，但这怎么样？”所以你必须决定是基于空格进行拆分还是其他。然后你会遇到像这样的东西。

如果你是基于标点符号进行分词，现在将会是 u 是一个单词，S 是一个单词，a 是一个单词，你希望把它们放在一起。但是，除非你对语言有一些知识，否则你真的不知道这里发生了什么。这些看起来只会像是三个有点不连贯的字母，这就是为什么你需要为此安装字典。你还需要处理像这样的事情，好的，我通常不会对数据使用连字符。

但你可能不想把它们分成两个单词。所以如果处理带有连字符的情况。但是有时连字符确实会，比如如果你要做一个短破折号或类似的东西，你不会想把它合并为这个，因为它在句子中进行了一次突变。我觉得我会这样做。等一下，我会这样做，或者也许那听起来不错。这些是在尝试分词句子时你会遇到的一些问题，看看我在这里的示例。

这里有 U. K.。所以你想让它保持在一起。而美元符号。你可能会想去掉它，但它确实给你提供了有关那个词的信息。所以我们可以运行这个，我会告诉你 spacey 的分词是你在词级别的自然语言处理过程中最常做的事情之一。另一个常见的操作是将单词简化为其根形式。

所以“buying”会变成“by”。这样你就会失去一些信息。但如果你进行简单查找，“look”会变成“look”，其余的都是它们的基本形式。但这将其分解成一个漂亮的词组，这样你就不必自己解析和进行标记化。相信我。

别找空格，使用正则表达式并自己进行标记化。这实际上是一个相当困难的问题，需要加载字典。这样你就可以将“UK”这样的词放在一起。这也挺有趣的。我不常用这个。我更喜欢端到端的方法，不用处理英语的语法形式，比如动词、形容词等等。

这给了你空间，可以对这些词做出最佳猜测。但问题在于，它是上下文相关的。因此，词语有时可以作为名词或动词使用。这完全取决于词语的使用方式，所以这可能非常困难。这不仅仅是简单的查找。这也很有用，因为这可以让你快速弄清楚。

不同的词在数量上是有差异的。这儿还有其他一些，比如“none”。还有几个我一时想不起的，但它让你知道这个词是否像某些东西。所以“$1”就像一个数字。虽然“billion”是一个词，但在语法上也像是数字的根。如果你想更深入地研究语法，甚至可以让它为你图示句子。

所以如果你运行这个，我想要一个笔记本电脑、一个iPad和一只狗。我想看看它是否能搞清楚那个词组，结果有点成功了，它给了你一个英语句子的图示，你实际上可以将其用作可遍历的树，这样你可以在代码中使用。

我通常不使用这些，但有时看到句子的图示，尤其是复杂句子的自动图示，还是挺有趣的。顺便提一下，这些图示往往会失败，运行这个图示时，有一个常见的问题。

注意“star”仍然在这里。所以如果你尝试运行下一个步骤，打印出句子，你可能会想，为什么我的打印这么慢。嗯，是因为上面这个家伙仍在运行，因为它需要启动一个网络服务器来实际显示给你，你可以从中看出。所以最好将其断开，现在你可以运行其他的。这就是我之前告诉你的，你可以将词语还原到它们的根层次。

这非常有用。我会经常使用这个，因为这样你就不必担心像“hanging”这样的问题。所有这些都会变成“hang”，而这只是一个你可以遍历的列表，可以根据需要处理那些停用词。停用词是自然语言处理中的一个非常常见的术语，你可以在这里看到所有的停用词。

这些是英语中非常常见的词，但通常（我强调通常）价值很低。所以停用词通常被移除或降重，这只是停用词的一个列表。因此，你通常会做的事情是遍历这些。

像这样的句子并移除停用词。你在进行自然语言处理时使用相对简单的词频统计和统计分析，可能需要移除停用词。不过，我在参加Cale的自然语言处理竞赛时遇到过一个例子，我打印出了我的程序没有正确解析的句子。其中有一个句子特别有趣。

那是什么呢？嗯，是什么呢？这是公司中负责计算机和数据系统的部分。嗯，我程序做的第一件事是将所有内容转换为小写。那是什么？好吧，那是一个完全不同的问题。就像我不知道你在课堂上带来了什么新的电子设备放在我桌子上，我会问那是什么。所以仅仅把所有内容转换为小写可能会让你陷入麻烦。然后当我将那个句子转换时。

移除停用词后，它变成了这样。由于这三个词都是停用词，因此产生了一个空行。所以这是一个合法的问题，询问的是某件事情。那是什么呢？但你必须意识到这些常见的缩略语，而不仅仅是去除它们，否则每次进行转换和清理时都会丢失信息，也许那些信息并不重要。

但你必须对这些自然语言处理的事项保持警觉。

感谢你观看这个视频。在下一个视频中，我们将讨论更多自然语言处理工具，特别是Word2Vec。这个内容经常变化，因此请订阅频道以保持更新，了解本课程和其他人工智能主题。😊

T81-558 ｜ 深度神经网络应用-全案例实操系列(2021最新·完整版) - P58：L11.2- Word2Vec和文本分类 - ShowMeAI - BV15f4y1w7b8

嗨，我是Jeffheine，欢迎来到华盛顿大学的深度神经网络应用课程。在这个视频中，我们将探讨Word to V，这是一种预训练模型。你可以从谷歌和其他来源获取它，帮助你进行自然语言处理。关于我最新的AI课程和项目，请点击订阅并按旁边的铃铛以接收每个新视频的通知。

Word to V是一种非常有趣的技术，它解决了如何将单词转换为向量的问题。我们之前看到的编码基本上是使用一些虚拟变量和索引。你将每个单词转换为一个单词编号。这是端到端神经网络的一种有效方式，而且效果很好。

但随着词汇量的不断增大，这种方法就不太有效了。Word to V是一种将单词转换为向量的方法，而向量和线性代数之间可以进行各种运算。你可以对Word to V进行这些运算，它可以实现一些非常有趣的事情。Word to V基本上将相似的单词放在向量空间中彼此靠近。

我看到了这个。

我在推特上发了一条消息，我觉得很有趣，关于Word to V的卡布奇诺和浓缩咖啡。那位女士说的是浓缩咖啡，但我点的是卡布奇诺，而小机器人则说：“别担心，它们之间的余弦距离非常小，几乎是一样的。”所以在这方面你确实要小心，不过这两个词非常相似，它们在Word to V的映射上也会非常接近。我给了这个特定卡通的原始来源链接。我建议用于Word to V的软件是GitHub的新闻向量。这需要大量内存，我使用的是完整的大型谷歌字典，带有大的编码。这是我在一个Kaggle比赛中使用的技术，在那场比赛中你会被给出两个问题，核心挑战是你需要判断这两句话是否相同。我在那个挑战中大量使用了这项技术。

最终，我进入了前7%。所以效果相当不错。它让我在这场比赛中取得了相对较高的名次。我们将使用大的谷歌新闻向量，如果你点击这个链接，它会带你到这个的GitHub镜像。这是一个相当大的文件，我们使用300维的向量，来自谷歌新闻的训练。

如果你尝试下载，它们不会让你直接下载，因为文件实在太大了，达到了1.53GB。所以，是的，这就是它的大小。我们需要下载这个压缩文件，然后将其表示为RA。我使用的是相当大的文件，如果你的电脑有16GB的内存，这个可能会工作，我用了32GB以确保安全。

让我继续回到我的，我将继续并展示它的样子。内存方面，所以我将创建一个新的终端。这是我实例上的Linux终端。它只是你典型的Linux命令提示符，我将运行一个叫做top的命令，如果你在Linux中从未见过top，它有点像进程管理器，我不会详细介绍这里发生的一切，但请特别注意内存，内存以千字节显示，你可以按住shift和E，然后它会切换，现在我们是在千兆字节。如果你进行大量高性能计算，你会经常使用这个top命令，如果你在Linux环境中工作。这是我有的可用内存量。这是我通过AWS使用的30GB机器，规模还不错，你可以在AWS上获得更大的机器，内存绝对可以更大，但32GB对我来说足够，这正是我喜欢的。

使用AWS实例进行这个。我不需要购买一台大型电脑并让它放在我的桌子下快速贬值，直到将来某天我带它去技术回收日。我不常需要32GB的电脑，但当我需要时，可以从亚马逊租用，费用不到一美元一个小时，所以我们将看看当我们开始加载时，这个费用如何减少。你可以在这里运行的这个命令会为你下载它，我已经在我的实例上下载了这个文件，所以我不需要重新下载。

这部分根据你的互联网速度，进展相当快。不过，这里需要稍微长一点时间，因为我们正在导入Jenison，这是我喜欢用于Python的word tove处理程序，它相当不错，我将继续运行它，它会把word tove加载到内存中，这需要一点时间，我会继续进行。

运行那个单元，然后我将翻回这里，你会看到我的内存开始下降。所以是30.3，在这个过程中，它基本上在加载，如果我只有6GB或8GB，我知道会耗尽，32GB可能有点多，我可能可以在16GB的实例上运行，但我们看看它会下降到什么程度。我将让它运行，并可能稍微加快一点，好吧，似乎完成了，或者至少占用内存的部分完成了。我们剩下24，所以是的，我之前在我的8GB实例上尝试过，这并不是很好，所以现在它已加载完成。我想指出这个特别的警告，慢版本基本上意味着我的包并不都是最新的，这一点是相当真实的，因为我运行的是一个较旧的版本，但并不是最旧的版本。

我使用的Tensorflow版本是为课堂准备的，并且在整个过程中保持不变。因此，由于依赖于该版本的Tensorflow和最新版本的Gsum，它无法像想要的那样快速访问其数据，这可能是加载时间稍长的原因，但不会影响我们这里要讨论的示例。所以首先让我给你展示一下这些向量的样子。

我们只使用了单词hello，所以加载的模型就是一个字典。我们将展示hello的条目，它已经加载到W中，我将打印它的长度。它是300。因此，可以理解为什么这么大，如果我打印出模型中每个单词的长度都是300，这里就是hello的样子，这是一组包含所有这些数字的向量。

定义在高维空间中，因此在300维空间中有一个点。hello这个词恰好在附近，或其他与hello紧密相关的词。因此，这个模型占用数千兆字节的空间，这仅仅是hello的300个浮点数，字典中可能还有数万个单词，全部来自谷歌新闻。所以让我向你展示一下如何对其进行某种线性代数操作。

你有猫和狗，如果我们运行这个，它会查找这两个向量，我只需计算它们之间的距离并打印出来。如果我放入像cat和car这样的词，距离就会大得多。你需要小心的是词汇和意思的文本分析，Cat和car仅相差两个字母。所以有时你会用它们之间的距离比较两个单词。

所以它们是怎样的？比如我的名字，Jeff和Jeffrey很接近，因为JEFF是开头，而你只需在结尾加上REY。这是一种常见的文本分析类型。但是Cat和car在拼写上很接近，但在意义上却非常不同。所以我们可以回到这个点，并且我们可以尝试之前的例子，这里她点了一杯卡布奇诺，所以猫和狗之间的距离，机器人可能有点夸大了，因为他说它们实际上是同一种东西。我不知道两个非常相似的饮料，比如可乐和百事可乐，没那么相似，这很有趣，可乐和苏打水类似。因此这些词在谷歌新闻中可能并没有出现过那么频繁。

作为与相似事物紧密相连的事物，你可以在这里尝试不同的词汇。你可以加载我提供的代码并进行实验，我们可以做国王和女王，这又引出了我的下一个示例，更相似，但这里你可以对它进行数学运算，这非常有趣。这是一个经常被引用的例子，你可以进行女王等于国王减去男性加上女性的运算。因此，如果你取一个国王的概念，减去男性后，它变成了类似于君主的东西，但再加上女性，它基本上变成了国王，或者抱歉，女王。所以如果我们运行这个并请求与这个方程最相似的，它会返回女王、君主或许是公主。所以这实际上非常酷，它能够执行这样的表达式，这对自然语言非常有用。

处理这些向量可以为这些词提供输入。它仍然需要大量内存，因此你需要处理每个词的300个输入，但这比我见过的65000个词的字典要好得多，然后有65000个虚拟变量。

所以这是另一种编码类型，你可以利用它，展示一些其他的工作效果，这很有趣。以下代码显示了哪些项目与其他项目不属于同类，我有早餐、晚餐和午餐，以及谷物，而谷物是你可以早餐吃的东西。

它并不真正像其他那些，它能识别出来。你可以在这里放入任何你想放的东西，汽车、卡车、男人、猫，它会说猫、房子、杂货店和狗。我从未尝试过这些。我们看看它是否有效。做得好。好的。它让我对它的信心稍微降低了一点，和可乐与百事可乐一起。

但我敢打赌，由于它们是不同的公司，这就是它的本质。Google新闻可能主要有这些样本，那里被更多地称为公司，这显示了两个词之间的相似度更像是一个百分比。

所以我们可以这样做。它们的差异更多。所以显然，它确实把这些视为公司。我们做颜色，如果我们做像iPhone和Android这样的东西，因为它们非常不同，你可以看出Google制作了这个。我想你可以找到一些最相似的词之间的关系，比如狗、小狗、猫。

Google，Tever Rotweiler，以及所有这些。然后我还有一些链接，你可能想进一步探索LSTM。这是不可思议的有效性。这非常有趣。它学习生成，所以你在特定作者的作品上训练LSTM，它学习生成听起来惊人地像该作者可能生成的文本，LSTM音乐生成了一些YouTube视频中生成的音乐。

然后是一个较早的论文，涉及我在那里的研究，试图从头开始进行自然语言处理。所以忘记 Wordnet 和我们为帮助自然语言处理创建的所有其他东西。

这基本上向你展示了如何从头开始进行这个操作。好的，这是我在这个模块中要分享的所有内容。感谢观看这个视频，在下一个视频中我们将继续这些内容。

我们学习使用的各种软件包。利用间谍和单词转为 V，并与 Kis 一起进行自然语言处理。此内容经常变化，因此请订阅频道以保持对本课程和其他人工智能主题的最新了解。

T81-558 ｜ 深度神经网络应用-全案例实操系列(2021最新·完整版) - P59：L11.3- Keras中的嵌入层 - ShowMeAI - BV15f4y1w7b8

嗨，我是杰夫·希顿。欢迎来到华盛顿大学的深度神经网络应用课程。那么，Kira的嵌入层是什么？这是你可以在Keras中使用的另一种层类型。但是它们有什么用呢？它们用于自然语言处理，关于我最新的AI课程和项目，请点击旁边的小铃铛订阅，以便收到每个新视频的通知。

Keras提供了一种叫做嵌入层的东西。这些通常在Keras中用于自然语言处理。然而，它们并不一定只与NLP一起使用。实际上，我认为嵌入层几乎是单热编码的替代品，单热编码就是虚拟变量，或者你想称之为的，处理分类值。所以假设你有100种不同的可能性用于该分类值，现在你需要一种方法来对其进行编码。

说到虚拟变量，你将有100个虚拟变量。如果你处理的是极大的基数，这就变得不切实际。😊！

这些分类，特别是如果你处理的是英语单词。想想你如何对英语单词进行虚拟编码。你需要为每个英语单词准备一个虚拟变量。现在，spacey中的一些选项可能对你有用。

你可以将词转化为它们的词干，比如“could”可以被转化为“have”，这样你就可以处理许多动词，例如“bra”，你总是可以有一个“run”。这样你就不必处理“brought”，它总是可以是“bring”或“bringing”。

但这些都是你可以用来降低维度的一些方法。不过，嵌入层实际上可以学习你所需的单词或任何你想传递的词汇或分类。现在，这通常用于序列。我们会将其发送到LSTM或时序卷积神经网络中，但。

这并不一定是必要的。那么让我们看看一个简单的嵌入层。现在，我们将看到当我们像这里那样创建一个嵌入层时的情况。顺便提一下，你可以在我们的图像字幕示例中看到另一个例子，我们使用了嵌入，并直接加载了GloVe嵌入层。

但我们并没有详细讨论嵌入层实际上做了什么。一切都和你在这里看到的一样。所以现在我们要学习如何训练一个嵌入层。在这里，我们定义了这个嵌入层，我们的输入维度计数将是10。

输入维度。基本上是类别的数量或单词的数量。你的词汇量有多大。如果你使用独热编码，你将在这里得到10个虚拟变量。然而，我们将稍微减少这个维度，实际上并不是一个维度减少。

但我们将把这些编码成四个数字的向量，而不是通常的10个数字的虚拟变量。并且它不是零和一。所有这四个元素都将在那个向量中使用。现在，输入链接。这有点有趣。这基本上是你的序列链接。如果你在处理自然语言处理，那么在这种情况下。

我们只会有两个这样的，因为这是一个非常、非常简单的例子。你会注意到这个神经网络。我用这个术语是比较宽泛的，它只有一个嵌入层。因此，这个神经网络实际上将嵌入直接输出到输出层，你会看到它。我说的是原子和均方误差，但这其实并不重要。

我们不会训练这个非常简单的神经网络。我要继续运行这个，它实际上并不做任何事情，只是定义这个模型。现在你应该真正把嵌入层看作一个查找表。所以我们有这10个输入维度。而且你将传入的每一个这10个分类值。

这些将返回输出维度中的一组不同的唯一四个数字。所以这个查找表，你可以把它想象成有10行和四列。这是一个查找表。嵌入层就是一个查找表。我们现在将继续运行这个。我们将给它一些输入数据。输入数据只是这里的一小段序列。

2，1 和 2 都在输入范围内，它将改变这两个输入分类。这两个整数。输入总是整数。所以你在转换字符或单词。这通常用于单词，但也常常用于字符。因此这并不一定是这样。

你转换的内容总是提供整数。因为它们基本上是查找表。这些实际上是权重矩阵中的行，也就是嵌入层。然后我们将请求进行预测，并打印出输入数据的形状以及返回的预测结果。查找表。你可能会期待它全部为零。

因为我们从未定义查找表。我们从未训练这个神经网络。那么这些数字从哪里来，它们实际上是随机初始化的。所以它们就像神经网络所有层的随机权重。在你实际查看嵌入权重之前，这并没有太多意义。

所以如果我们查看嵌入权重，注意有10行和四列。这是10个词汇元素。然后我们要求有四个，这个四是任意的，我们可以设为六、八或十，这并不重要。

这有点像维度减少的概念，尽管不完全是。现在我们要做的，但再次强调我称之为维度减少是因为，代替有10个虚拟变量，你现在有这四个值。

现在让我们看看这些权重实际上意味着什么。所以第一个对应于这一列的权重，整个东西可以是一个列或维度向量，注意0.4763。它与这里的这个向量完全相同。第二个。这是行。假设你从0开始计数，0，1，这是1，2是下一个负2，70，2。

看看这个。这只是一个查找表。这就是嵌入层的全部。因此，我们在本课中使用的手套嵌入，实际上只是一个包含大量英语单词的表，我忘记有多少了。我认为它的向量大小为200，如果我没记错的话。别引用我。

但每个手套嵌入都有一些任意的向量长度。我们只需将该矩阵直接加载到权重中。我们称其为设置权重。这就是我们所做的。然后我们定义了这个嵌入层。现在，当你训练这个神经网络时，你想要将这些嵌入权重标记为非可训练的，否则。

它们将开始从原本的设置值中被拉离。如果你在进行迁移学习，你可能不希望这些权重被修改。我们稍后将看到更多关于如何训练这些权重的信息。现在，我将其与虚拟变量进行比较。通常，你想证明某物等同于其他事物时，可以看看能否在其他事物中模拟该东西。

所以我们将使用嵌入层基本上为我们提供虚拟变量。我在这里做的是创建一个输入维度3。这将是一个具有三个可能值的分类变量。虚拟变量看起来是这样的。基本上是你看到的虚拟变量的对角线，因为虚拟变量，简要回顾一下，本质上一个值是1或热编码。

这就是为什么它被称为“一热编码”。其他值都是0。这是你可以编码分类值的一种简单方法。输出维度也将是3，因为我们编码的内容有三列。如果你在做虚拟变量，这些值将始终保持不变。

这就是虚拟变量如此低效的原因，因为假设你的输入维度是 100。你有 100 个类别。你仍然可以将其压缩得非常小。你不想太小，但可以将其设置为 4 或 8 并进行训练。我们将很快看看如何做到这一点。然后输入长度就是你的序列长度。所以这就是你希望一次编码多少个。

然后我们将使用 atom 和 MSC 重新编译它，我们将不会训练这个神经网络。因此，这两个真的无关紧要。但我们会在嵌入层设置权重。现在，我们确实需要将这里的查找转换为列表，因为你可能不会真正深入研究这一点，但如果它朝多个方向发展，你可以有多个查找矩阵。

但那将是一个更高级的设置。如果你感兴趣，可以参考 Kira 的文档。没错，那是一个列表。让我们继续运行它。但现在，始终嵌入你的矩阵列表，你就可以顺利进行。接下来，我们实际上创建了一个作为嵌入层的虚拟模拟器。

我将继续在这里简要介绍一下，我们将对这两个类别进行编码，并查看它的运行情况。这里是虚拟变量。这样你可以将其中一个放在神经网络的前面，甚至不需要编码虚拟变量。

有更好的方法来处理这个，但这是你可以做到的一种方式。如果你想使你的神经网络真正能够输入这些值，并自动将其转换为虚拟变量。这很酷。你会经常做这样的事情，这就是你想要使用迁移学习来引入你的虚拟变量的时候。然而，真正的乐趣在于，也许这并不是最真实的乐趣。😊你可以自己训练这些。

这是处理神经网络需要输入高维类别的好方法，而这些类别没有简单的方法可以转换为虚拟变量。假设你有一个 20000 维的类别，你可以将其定义为嵌入，选择一些任意的维度数，比如 2040。这是一个超参数，你需要进行调整，实际上是 atom 更新规则或反向传播。

所有的变量。它将执行梯度下降，并为你训练嵌入。让我们看看如何做到这一点。这使用了一些自然语言处理的函数。这实际上展示了现在你可以多么轻松地构建这些 NLP 神经网络。所以这里有 10 条餐厅评论。前几条都是负面的。再也不来了。糟糕的服务。

无礼的女服务员，食物糟糕，这些其他人。Re喜欢它。很棒，超棒的服务。太棒了。糟糕的工作，做得不错。所以这些只是你可以选择的不同值。注意我放入了随机的感叹号。还有一个稍微随机的例子，更多是应用于评估承包商。

但噪声是好的。1表示负，0表示正。所以这些是标签。这是y。我们将在其上训练一个神经网络。因此我们将说我们的词汇大小为50。我们可以任意选择这个数字。我们不必真正计算其中的单词数量。

我们将使用汽车的一热编码。汽车的一热编码很酷。😊。这让我有点害怕，但对于示例来说很好。它基本上是在为你进行标记。因此，将这些词分解，将这些句子分解为单词。

然后将每个分配给一个索引。所以它在后台做了很多事情。通常，我喜欢对这些有更多的控制，我想知道它是如何被标记的，并且我想知道它是如何将这些索引分配给它的。但这对于示例来说是好的。当我们展示如何将这些连接到其他人在生产环境中使用的API时，我们会看到我们非常关心锁定这些索引值。

如果我在现实世界或企业环境中部署这个，我不希望某次变得索引为5，进行重训练，而现在为4。并且潜在的数据现在编码错误。所以你必须对所有这些小心。然后我将继续运行这部分。

我们将继续运行并编码这些。这些是你所有的序列。我们希望这些序列的长度一致，因为这就是序列的工作方式。我们将使用最大长度4。看看吧。它们都很好，并且进行了零填充。谢谢你。Kiras，我们将创建一个非常简单的顺序神经网络。

我们将在最后有一个稠密层。因此这里面有学习。这里有一个权重矩阵。但我们也在嵌入层中进行学习。神经网络实际上将学习如何创建这些嵌入，以便将这些词以有意义的方式分离并映射到欧几里得空间。这可以让你避免处理大量的虚拟变量，并创建一个非常复杂的神经网络。

嵌入对于NLP来说很棒。继续运行，我们将打印一个摘要。你看到了吗？继续拟合它。我只是运行它。😊，100个周期，非常非常快地训练。让我们看一下本质上的嵌入。每一行都是一个不同单词的嵌入。我甚至不会尝试解释其中的原因。

这里基本上就像是权重，这些权重的计算方式与实际层的权重是相同的。这里有一层也在学习。但是嵌入权重与神经网络中的其他权重一起学习。然后我们可以在最后评估这个神经网络。准确性实际上是完美的。

准确性完美的原因是我在这里没有放置任何重叠。负面评论中的所有单词都不在正面评论中。这只是一个玩具示例。感谢观看这个视频，在下一个视频中我们将研究端到端的自然语言处理。这个内容经常变化。所以请订阅频道以便及时了解该课程及其他人工智能主题。

T81-558 ｜ 深度神经网络应用-全案例实操系列(2021最新·完整版) - P6：L1.5- Python 函数、Lambda 和 Map／Reduce - ShowMeAI - BV15f4y1w7b8

嗨，我是杰夫·赫顿，欢迎来到华盛顿大学的深度神经网络应用视频。在这个视频中，我们将看看如何使用函数，甚至是Lambdas，这使你可以将一个函数传递给另一个函数。这是Python编程语言的一项非常强大的特性，让我们可以用数据处理做出非常有趣的事情，特别是在下一个模块当我们开始使用pandas时，我们将看到如何使用像map这样的东西。

reduce、filter以及在集合上进行的基本操作，利用可以传入的Lambda函数。有关我最新的AI课程和项目，点击订阅，并点击旁边的铃铛以便接收每个新视频的通知。函数在许多不同的编程语言中非常常见，它们允许你处理代码。

并将其打包为一个函数，而不是在程序源代码中到处重复。这里我创建了一个名为say hello的函数，这就是在Python中定义它们的方式。你在函数定义中不需要任何东西来说明你是否会返回某个值。Python通过你是否返回某个值来知道它是一个函数，或者通过你不返回某个值来知道它是一个过程。

而一个过程通常被称为不返回值的函数。这是一个过程，所以它不返回任何东西，它接受几个值，参数，发言者，问候的人和问候语。现在注意到上面的equal hello。这意味着它有一个默认值，因此如果你不提供问候语。

然后它默认将其设置为“你好”。我们可以运行这个。它调用了三次。第一次，它用一个发言者和一个要问候的人调用它。第二次，它用一个发言者和一个要问候的人调用，并且改变了问候语，所以变成了“再见”。你也可以使用命名参数，这在你有很多参数时非常有用，这样就不会让人感到困惑。

你可以说，发言者是杰夫，同意的人是约翰和格林，你可以随意混合顺序。这并不特别重要。如果我们运行这个，你会看到它说“你好，约翰，我是杰夫。再见，约翰，我是杰夫。”对于最后一个也是同样的情况。现在是函数。一个真正的返回某个值的函数，这里你会看到我基本上传入了一个字符串。

这段代码的作用是剥离，所以Str会去除字符串开头和结尾的空白。字符串基本上是一个数组。因此，字符串的第一个字符是字符串的第0个元素。我将其转换为大写。然后我说，嘿，我想要从1到末尾的其余部分，因为如果我说1到2，它会只获取字符串的一部分，所以如果我们这样做。

它定义了函数，现在你可以很容易地调用它。我传入带有空格的 hello，它返回给我大写的 hello。Python 的 map 函数非常有用，这源于函数式编程中的 map。Map 来自于 Hadoop 的名声。现在这并不涉及大数据或类似的东西。

这就是简单的 map 函数。map 接受一个值列表，并对每个值应用一个函数。所以在这里我将运行它。list 将输出从 map 转换为一个列表，以便可以显示。我们给它处理字符串，这是我们在所有值上应用的函数。

在这个列表中。所以它将给我返回一个列表。map 总是返回一个列表，包含所有来自你调用 map 的函数的值。与我们在 Python 中的 comprehension 非常相似。所以在这里我们将把它看作是一个 comprehension，基本上做相同的事情。

所以在这里我们调用处理字符串为 X 和 L。现在，comprehension 是一种 Python 特有的东西，而 map 在许多编程语言中都很常见。我倾向于使用 comprehension，但其他人会使用 map，因为他们可以编写代码，使其能被不仅仅是 Python 程序员理解。

因为这个理解在这里所做的并不一定明确，除非你已经使用过 Python。Filter 是另一个函数式的。你可以处理的一种运算符。filter 接受一个列表，并将其过滤为一个可能更小的列表。可以是与输入列表相同大小的列表，但这定义了一个函数，问它是否大于五？

然后我们取这个列表，其中一些值不大于五，我们处理这个列表，因此只有 10 和 20 大于五。其余的都被过滤掉。所以 filter 可以是一个非常方便的方式。基本上，应用一个函数检查项目是否应该包含在列表中。Lambda 非常方便，它是一种函数，属于匿名函数。

通常 lambda 只有一行，但它们当然可以更长。lambda 基本上创建一个函数，一种表达式，你可以直接赋值给变量。所以在这里我将运行这个，而不是写这个冗长的函数，虽然两行不算太长，但仍然。我们简单地将其写为 lambda，因此 Lambda 替代了大于五的函数。

它没有名字，字面上只是直接传递到 filter 函数中。所以如果你要写非常短的函数以传递给诸如 map 和 reduce 以及 filter 的东西。这可以是编写这些函数的很好方式，然后再 reduce。因此这些其他像 filter 和 map 的东西。你有一个列表输入，一个列表输出。

这是一个将列表减少为单一值的示例。所以它将列表简化为一个单一值。这展示了如何进行简单的求和。😊，所以这是reduce的工作方式。你在lambda中有两个值，第一个是累加器，来自于前面的值。然后是你要加到这个累加器上的值。

感谢观看本模块关于Python编程语言的内容。在下一个模块中，我们将看到如何开始使用Python附带的Pandas库，它可以让你为表格神经网络准备数据。这部分内容经常更新，所以请订阅频道，以便及时了解本课程及其他人工智能主题。

T81-558 ｜ 深度神经网络应用-全案例实操系列(2021最新·完整版) - P60：L11.4- 使用Spacy和Keras进行自然语言处理 - ShowMeAI - BV15f4y1w7b8

嗨，我是杰夫。欢迎来到深度神经网络的应用。在这个视频中，我们将看看自然语言处理，特别是，我们将结合使用Spacey、Keras和word2vec，了解我的AI课程和项目的最新动态。点击订阅，并点击旁边的铃铛，以接收每个新视频的通知。之前我们进行了文本生成，查看了《金银岛》。

我们让神经网络生成自己的海盗故事。我们将继续这个项目，但这次我们将使用单词级文本生成。之前我们使用的是字符级文本生成。关于这两者，存在很多争论。我的倾向是生成字符级，并与神经网络真正实现端到端。

让它自己理清语法和句子结构，而不是在名词和动词等方面进行大量特征工程，但你当然可以进行单词级别的处理。如果你选择单词级别，那么提供额外的特征可能是有用的。😊

不论是名词、动词或其他东西，这个问题不算复杂。我们不会在这个例子中做得太复杂，但我会展示如何逐字生成文本，这是我们在生成字幕时所用的。尽管你确实可以在字符级别进行字幕生成。

在这里，我导入了需要的包和库，分别用于spacy和Keras。我获取了《金银岛》的文本，就像之前那样。现在我开始处理spacy，所以我将使用spacy进行分词，将《金银岛》的文本拆分为单个单词。当我们进行字符级编码时，不需要进行这种分词，因为分词由神经网络处理。

它学习了什么是空格，并学会了如何将单词拆分开。由于我们按单词进行处理，我们需要进行实际的分词，而spacy正是为我们完成这个任务。因此，我们实际上是遍历所有的token，即它找到的所有单词。这只是代码，这第一行是相当有用的一行。

这将字符减少到ASCII码0到127的字符。因此，这确保你仅处理这些单词中的ASCII字符。这会去掉很多额外的垃圾字符，比如这个奇怪的版权符号和奇怪的字母A，然后我们还会去掉任何空白字符，因为一旦你去掉一些字符，可能会出现嵌入在其中的空白。

我们确保标记不是数字，也不是网址、电子邮件或其他类似的东西。现在你可能想处理这些，但对于这个简单的例子，我们只是将它们剔除。现在在字符逐个处理时，我们只是让它们通过，有趣的是，神经网络会学习生成网址、电子邮件地址等。当我们这样做时，单词的总数是6421。

我们打印出一些这些内容。现在其中一些是数字，那是罗马数字。但我们会继续让它通过，这不会造成任何伤害。我们在这里创建两个查找表，一个是单词到索引。因此，这会将单词像“孤独”转换为一个索引。现在如果你想使这些更加一致，你可能想对这些进行排序，因为那样索引将始终保持相同。

所以在生产环境中，你需要考虑确保这些索引真的保持不变。否则，如果你训练你的神经网络并改变这些索引，它是不会工作的。然后我们对文本进行标记化，基本上是将原始《金银岛》文本中的每个单词替换为索引号。因此现在它更适合被输入到像嵌入层或其他文本翻译输入中。

现在我们将做的这项工作与我们在字符中所做的类似，只不过我们创建的是单词序列，而不是字符序列。因此，这实际上是相同的代码，我们处理最多六个单词的单词序列。“步进”意味着我们每次向前移动三个单词，否则我们在这里会有很多冗余，因为如果句子是“这是一个测试”。

第一个序列将是“这是”，下一个序列你将向前移动三个单词，因此你不会立即开始于第二个单词。你将这个数字做得越小，你就会有越多的重复，然后我们看看这些序列是什么样的。

至少前五个。这些是我们正在训练的序列，我们在训练神经网络。如果你有这个单词、这个单词、这个单词、这个单词、这个单词和这个单词，那么下一个单词是什么？然后我们将其向量化，这本质上只是将其转换为笨重的数组，以便我们实际能够用它来训练神经网络。

这与我们进行的字符级编码完全相同，但实际上就是逐个构建这些。同时也构建Y，以便我们有虚拟变量从Y端输出，以便我们可以进行预测。我们使用虚拟变量。这就是X的形状。这使得我们如何编码这一点非常明显。

所以X形状基本上是我们生成的32005个序列，最大序列大小是6。然后我们有这么多值，因为我们有虚拟变量进入。基本上，我们为这六个每个都有一个虚拟变量。所以这实际上是我们预生成的很多数据。这是使用嵌入层可以使其更高效的地方，但它适合内存。

所以我对此基本满意。y是相似的。我们这里没有六个，因为我们不预测序列。我们只是预测下一个字符。因此，我们有相同数量的行，但现在我们有这些虚拟变量，告诉我们6400个单词中实际会是哪个。你可以看到这些虚拟变量的样子，基本上我们在创建非常小的、简单的LSTM。

有128个神经元。它的层。我们将再次使用Rs prop进行优化，保持与我从字符编码中提取的示例类似。现在这不是Kira的正式示例，我只是修改了Kira的前一个示例以进行LSTM生成，我只是修改它以实际处理单词而不是字符。我们打印一个摘要，它大约有400万个权重，我们正在训练，这是样本函数，这与基于字符的完全相同。我们基本上在做一个softm函数，温度决定了它在句子方面的保守程度，愿意冒险的程度，因此数字越高，创造力越强，但数字越低则更容易出错。这基本上是一个softm，确保在试图预测下一个单词时，所有66400个词汇的概率。

这些概率的总和为1，因为它们是概率，因为我们将基本上取最高的那个。这就是我们将预测的下一个单词。这与之前的例子非常相似。我们在每个迭代结束时调用它，基本上在每次训练过程中生成一些文本。我们可以看到它生成的文本越来越好。

我们将为每个生成100个单词。我们将构建输入序列。因此，我们将随机抽样六个，或者无论那个输入向量为多少。我记得是六个单词。是的，确实是6。所以我们正在抽样六个单词的组，开始训练。现在我们将向下滚动，这很多。

这已经训练了一段时间。这就是为什么我没有为视频运行这些。它会花费相当长的时间。所以温度，这是一个相当保守的温度，而这也是训练。你可以看到它正在创造的海盗故事。我自己沉没了几段，它回复让我在商业中感到不安。因此摩根新闻。

Davy 在薄荷中回归。我没有看到任何语法错误，这真的很酷。还有一件我觉得很迷人的事是我的分词器。我可能没有花足够的时间在分词器上，但它将 I 和 ill 视为词汇中的两个不同词。这就是这里有空格的原因，因为我们添加了空格。

它不知道什么是空格，但它发现通常在 I 后面会是 ill，或者会是 S。它并不是像把这个撇号 S 附加在 fell 上那样，而是真正理解句子结构。这真的非常酷，自然语言处理在这一点上取得了巨大的进步。

深度学习技术的应用使得文本生成在单词层面上非常有效。我认为即使不做太多优化，也能产生非常真实的单词和句子结构，尤其是关于海盗故事的可信文本。感谢观看这个视频，期待下一个视频。

我们将深入探讨自然语言处理与光标，并查看嵌入层。😊。

这个内容经常变化，所以请订阅频道，以便及时了解该课程和其他人工智能主题的更新。

T81-558 ｜ 深度神经网络应用-全案例实操系列(2021最新·完整版) - P61：L11.5- 使用Keras和TensorFlow从头开始学习英语 - ShowMeAI - BV15f4y1w7b8

嗨，我是Jeffine。欢迎来到华盛顿大学的深度神经网络应用。你知道吗，也许我们人类被高估了。毕竟，AI在几小时内就能掌握国际象棋，甚至不需要人类知识的帮助。我们尝试进行自然语言处理，使用了各种高级插件，比如L T K和Space E等。

也许我们应该让神经网络从零开始学习英语或其他语言。这被称为端到端神经网络。有关我最新的AI课程和项目，请点击订阅，并点击旁边的铃铛以接收每个新视频的通知。继续前进。我们将看另一种类型的。😊

欢迎来到华盛顿大学的深度学习应用，看看我们如何教神经网络学习阅读。这是我从这两篇论文中提取的内容，同时我也使用了Kira示例中的代码，Kira的创建者实现了端到端神经网络作为cururas的一个示例，这最终可能会构建成Kira的特定层类型，以便你可以直接使用，但现在你会看到一些用于实际实现这种网络类型的底层代码，还有一个在线JavaScript演示，你也可以用来玩一玩。如果你愿意，我们将实际创建一个端到端神经网络并加以利用，这些只是一些必要的导入和工具函数，它们是根据Kira的示例创建的，我对这些进行了些许更改，使其工作得更好，并消除了一些Hatheng生成的警告，因为这些警告可能是在Kis的较旧版本上生成的。我还在最后添加了一个问答部分。

原始代码训练了网络并给出了准确率，但没有提供任何使用它的方法。所以我在最后创建了那部分。让我们继续运行它。它告诉你正在使用Tensorflow作为后端，然后我们看到它仍在运行。它需要一点时间才能完成，但在此期间，让我向你展示一下我们正在做的一些部分。

这是一个标记化的函数，它使用正则表达式分离句子中的单词，因此这会将“Bob D the apple. Where is the apple?”转换为一个数组，而不是一个大句子。这被称为标记化，它将句子标记化并为你分解。这一部分是故事，因此它将以Babbby任务格式存在的故事分解为三部分。你将会看到，它们是通过制表符分隔的，我不会详细讲解所有步骤，但基本上，它的作用是提取三个部分，其中包括“约翰走进浴室，玛丽走进卧室”的故事。

这一部分是三部分中的第一部分，第二部分是关于“约翰在哪里”或其他问题，第三部分是答案，这种类型的神经网络的答案总是一个单词。因此，你在问一个故事的问题，然后给出一个相关的问题，它会返回一个单词。重要的是要意识到神经网络的训练涉及权重，而不是学习特定的句子，因为在神经网络训练后，你会给它新的句子，它应该能够回答关于这些句子的问题，因为训练数据中包含了各种情况，比如“玛丽在浴室”和“玛丽在卧室”，这些都是特定于某个训练示例的位置，它并不是在学习这些位置，而是在学习如何阅读新故事并能对其进行回答。然后，这里我们称之为的函数会通过调用其他函数获取故事，这些函数刚才提到的解析故事，并将故事以向量格式返回，这可以传递给神经网络进行处理。

对故事进行向量化，我将展示这具体是怎样的。但本质上，它的作用是提取所有的句子、故事，计算有多少个独特的单词，然后进行向量化，并转换成纯数字形式，每个单词都有一个数字索引来替换，我们稍后会看看它是如何工作的。这段代码基本上下载数据，所以我们从AWS获取数据并下载到这个GZ文件中，然后提取出我们想要的部分，我们正在进行10K挑战。

这是一个较小的数据集，虽然仍然相当大，但它让我们能够在电脑上运行。我要指出的是，我通常运行这些示例的电脑使用的是AWS实例，正如我之前讨论的那样，我基本上访问我的网站，你无法使用那个URL，因为它是我的AWS实例，这会让我产生一些费用，虽然不多，但我通常使用的是8GB的内存。

实例化这个课堂环节，因为有相当多的内容，我实际上使用了一个16GB的内存。如果我使用的是更大的数据集，我会需要更高的内存，可能在一台8TB的计算机上运行。因此我们来运行这个部分，我会继续运行这一部分，因为我已经运行了之前的部分。它正在提取挑战的故事，并且现在我已经运行过了，它已经下载了它们。如果你是第一次运行这个，它可能需要下载这些。

让我运行这个，让你看看数据实际上是什么样子的。所以这是一个故事，玛丽搬到了浴室，约翰去了走廊，玛丽在哪里，答案是浴室。这里还有另一个故事，而且将会有多个句子。玛丽搬到了浴室，约翰去了走廊，丹尼尔回到了走廊，桑德搬到了花园，丹尼尔在哪里？所以它需要读取这些并找到他最后说他搬到的位置，并用不同的方式描述它。

回到“搬到”和“去”的问题。所以它确实需要学习读取这些训练示例。我需要再次强调，神经网络并不记得玛丽在浴室。这仅仅是这个特定句子的独特性。还有一大堆这样的句子，大约有10000个供其训练，答案总是一个单词，因此它学习读取这样的句子。最终我们会看到，我们可以为它编造自己的临时故事，它会读取并回答一些内容，但我们会看到它有一些非常重要的局限性。所以首先我们需要构建词汇，这是这个程序一个非常重要的限制。我们将运行它，让我给你看看那是什么样子。它非常快速地构建词汇。它对所有这10000个训练故事和1000个测试故事进行了处理，所以我们将在这些上进行训练，并在这些上进行测试，看看它能学会多好地读取。它提取了一些非常重要的极值，这些将会被隐含或施加在训练的神经网络上。我们有22个独特的单词，这将是词汇，如果你查看所有那些句子。

玛丽搬到浴室，所有那些单词，你会发现有多少个独特的。只有22个独特的单词。当你添加更多单词时，这个神经网络变得非常非常占用内存，因为这些基本上变成了虚拟变量，所以这是一个很大的限制。但是如果你给它更多的内存和计算机，确实有示例可以学习更大的词汇。最大故事长度是68，所以我们将基本上创建一个输入，由68个单词和22个虚拟变量组成，那就是嵌入，另一个输入是问题，因此查询或问题的最大长度是4个单词。

因此，这个神经网络的输入将成为故事，最大为68个单词，旁边是22个虚拟值，查询长度是四个单词，旁边也是22个虚拟值。因此，它实际上变成7268加上4乘以22个虚拟值的输入。你可以看到，如果你开始添加额外的单词，这个会迅速变得很大，这就是词汇的样子。

现在这个神经网络需要一些时间来训练，在我运行的这个较快实例上，它大约需要四分钟进行训练，但在计算核心较少的较慢实例上，这可能会花费更长时间，因此我们希望保存这个神经网络。我们还希望保存这个词汇表，因为我们需要查找。这是基于映射的，而Python中的映射顺序是可以改变的，因此你不能保证将东西放入映射后总是会有相同的大小。这是查找表，它告诉我们零对应的是句号，二对应的是丹尼尔，依此类推。当我们对这些进行向量化时，它会将这些词转变为查找值，例如玛丽是4，玛丽会变成4，移动15，所以它会变成415等等。因此，为了构建训练集，让我继续执行这部分，它告诉你输入将会是什么样子，所以你有一个10000乘以68的输入向量，一个10000乘以4的输出，然后答案将是词汇大小，让我给你展示一些单独的训练元素。

这显示了故事，所以你会注意到我们始终保持这个长度相同。68是所有故事中单词的最大长度，并且进行了填充。填充是在左边，所以开头是全零，然后是你在这里得到的实际单词。现在一个重要的事情是要展示这些零，填充的工作方式，我们必须在最后进行调整。这是一个非常重要的部分，我会在最后给你展示，但请注意我们有21个单词，如果你数一数这两个东西，如果你在关注，你可能会看到22个独特的单词，所以数学不太对劲。我们有的额外值实际上是空值。所以null 0实际上是映射中的第一个值，但实际上这个值加1，所以0会变成1，依此类推。我们看到我们必须在最后进行调整，但这就是我们这里有零的原因。因此那些实际上是空值，然后我们进入查找的实际值，问题也是如此。现在这个问题的最大长度是四。

所以我们现在没有零填充，我们需要编译神经网络，因为Keras本身不支持端到端的神经网络，基本上必须在这里创建计算图，至少在某种程度上。我将向你展示这看起来有点像什么，我们不会真正深入所有细节，我需要带你看整篇论文才能了解，但我们基本上创建了三个编码器，其中两个用于句子，然后两个用于从句子中提取事实，然后将这些事实与问题编码在一起，试图构建答案。所以你需要两个用于输入的编码器，而你还有一个用于问题的编码器，输入维度变成词汇大小，以便构建那些占位变量，输出维度基本上是下一层中的值的数量。然后我们将这些全部结合在一起，最终汇聚到一个LSTM中，我们使用了dropout正则化。

在整个过程中，它最终进入了答案的softmax，这基本上是对词汇中哪个是答案的分类。最后，我们创建模型并训练或编译它，我们并不训练。这个部分运行得非常快，基本上创建了神经网络，神经网络现在已经构建并编译。这是我们将实际训练它的地方，我们将使用32的批量大小和120的epochs。现在这一点非常重要。

我们将保存神经网络，因为构建这个网络需要一段时间，我们不想就这样丢弃它，所以我们保存神经网络。我从原始示例中添加了这段代码，他们没有保存神经网络，但我们将其保存为H5文件，这是一种二进制文件。我还将词汇保存为pickle文件，pickle是Python中的标准序列化格式，我报告了经过的时间。所以我将继续运行这个，并加速处理。

但实际上完成这个过程可能需要4到8分钟，你可以看到时代正在快速推进，并且它正在处理训练集。训练集包含100个元素，所以它只是继续进行。使用任何形式的提前停止，它将在120时停止，好的，还不错。使用这个更快的AWS实例大约需要四分钟。这个代码我不会执行，神经网络已保存，聊天机器人已保存为H5格式，词汇也保存为pickle文件。如果你正在运行这个并且已经保存了聊天机器人和pickle文件，你基本上可以只运行这部分，而不是训练，我们将评估准确性。注意，我们的做法与之前的代码非常相似，只是看输入，由于计算图早期的结构方式，输入有所不同。

输入实际上是两个向量，一个是输入，另一个是查询，所以输入是故事，玛丽去了走廊，等等，查询是问题，比如玛丽在哪里，我们将运行它并打印出预测结果，这就是我们之前看到的典型概率。你现在会看到我们并没有看到所有的值，但每一行基本上显示的是你拥有的22个词汇的概率。

这些词是答案。现在你可以看到，如果你使用一个合适大小的词汇量，比如20000个词，这种类型的网络的输入会变得非常非常大。因此，就像之前一样，我们将取这些的arg max，现在的arg max基本上是每个的索引，所以这显示词汇单词12是期望的答案，9是期望的答案，151215，并不是所有的词汇列表中的词都经常是答案。你肯定能看到某些数字比其他数字更常被选中。我们也可以打印出我们的最终准确率，95%实际上非常好。现在我想告诉你如何进行临时查询。我从汽车中复制的原始示例没有显示准确率或告诉你如何分解这些向量，因此这些都是这个类添加的。如果你碰巧查看我上面链接的原始示例，他们也没有告诉你如何进行临时查询，我认为这是最酷的部分。你训练了这个伟大的神经网络，它学会了如何阅读，所以你想尝试测试。

所以我在这里给出的是字面上的原始文本。它会输出其词汇量。它在提醒你。记住，我只知道这些词，我告诉它玛丽去洗手间了。约翰去了花园。等等。玛丽在哪里，我运行临时查询。这是我添加到程序中的一个区域，所以你会看到玛丽去了花园。约翰去了花园。这是一个简单的例子，我只是随便编造的，然后我问，玛丽在哪里。

他们都在花园里。所以如果我运行这个，它会说花园。我可以把它改成玛丽去了洗手间，它会更好地改变示例或答案。一个实时演示，洗手间好，玛丽旅行了，根据英语系统，"旅行"可以有几种拼写方式。他们使用两个L，所以我必须使用两个L，但这没关系，它仍然理解约翰去了花园。

你可以在这里添加其他人，我可以添加丹尼尔，我们把玛丽移到走廊，然后我们可以运行它，而它并没有重新训练神经网络，而是使用已经学会阅读这些句子的神经网络来回答问题。

我也可以改变查询，比如问丹尼尔在哪里，它会为此进行调整。让我试试。现在让我给你展示一些效果不太好的事情。如果我说丹尼尔去了比赛，那就超出了词汇范围。因为在字典中找不到，所以会崩溃。我老实说还没有尝试这个，但我想试试。我只是好奇它会怎么做，它是否有时间的概念。如果我说丹尼尔去了走廊。

玛丽去了洗手间。丹尼尔去了卧室。丹尼尔改变了他的地点，他曾在走廊，然后去了卧室。如果我问它这个问题会发生什么？它很聪明。它能理解，因为如果我改变这个，丹尼尔在走廊，他去了洗手间，然后它会为另一个更新。

如果你考虑编写一个传统程序来做到这一点，你需要解析这些内容并保持某种状态，以了解每个人的位置。神经网络只是弄清楚如何做到这一点，并且它会随着后续答案的出现而覆盖这些状态。我敢打赌，训练集中有一些示例教它这一点，教它最后一个答案是正确的。你可以调整训练集，以便第一个答案是正确的。

基础信息，它会学习到你也可以在这里加入“最初”这个词，并为“丹尼尔去了走廊。玛丽去了洗手间。丹尼尔去了卧室。”进行训练。问丹尼尔最初在哪里，它很可能会学会知道那是该人最初所在的位置。我还想尝试一些其他的事情，问它桑德拉在哪里，她在这个故事中根本没有出现。

所以它不能说我不知道。它说她在花园里。如果我必须打赌，让我实际上去打印它的预测。那么这就是概率，除了我将其切换到最大值，所以我只打印出概率，几乎是它的置信度。所以它显示出是的，它相当确定，90%的置信度是我在这里看到的最高概率。如果我必须猜测，它在说桑德拉在花园里，因为在训练集中，她最常待的地方可能就是那里。

我不知道，我需要验证那个假设，但这真的是一个相当酷的技术。你可以轻松地玩这个，并训练它学习你自己的句型。你可以做一些事情，比如丹尼尔最初提到的那样。你只需生成适当的训练数据，它就会真的学会阅读你提供的那些句子。句子越复杂，神经网络需要的规模就越大，所以神经网络的架构我没有详细展示，而是直接说到你需要将大小从32增加，然后在这些密集层中，现在只是在做一个密集层，词汇大小就是输入到softmax的内容，但你可以创建一些额外的密集层和正则化层。事实上，作者甚至指出你可能需要添加这些。因此，这显示了你如何基本上从零开始教神经网络阅读，它的能力有限，词汇量也小，但在16GB的计算机上运行四分钟，这实际上还不错。感谢观看视频。

接下来的模块我们将探讨强化学习，这个内容变化频繁，因此请订阅频道以便及时了解本课程和其他人工智能主题。

T81-558 ｜ 深度神经网络应用-全案例实操系列(2021最新·完整版) - P62：L12.1- OpenAI Gym介绍 - ShowMeAI - BV15f4y1w7b8

嗨，我是Jeffy。欢迎来到华盛顿大学的深度神经网络应用模块。在这个模块中，我们将看看AI Gym。所以AI Gym是一个😊基准平台，让你在Python中评估你的强化学习程序，与著名游戏如Atari游戏等进行对比。所以我们将看到如何实际与这个接口，并使用它来观看游戏在屏幕上播放，或者以离线方式训练，看看我关于kgel神经网络和其他AI主题的所有视频。

点击订阅按钮和旁边的铃铛，并选择全部以接收每个新视频的通知。那么让我们来看看OpenAI Gym。在这个模块和接下来的五个部分中，我们将讨论强化学习。强化学习与监督学习或无监督学习不同，它有时被称为自我监督。你将给计算机提供某种游戏。

并且这不一定是游戏。它可以是任何有明确规则且可以在计算机中完全模拟的东西。所以基本上是一个游戏，但要将其用于其他类型的学习，你需要以某种方式表达你的问题，使规则明确，以便在进行过程中有一种增量的进展。每局游戏可以称为一个回合，你经历一系列步骤，在每一步，计算机可以采取特定的动作，然后在结束时。

它的性能被评估，成功了还是失败了，每一步都有所评估。根据表现给予奖励，机器重复进行这个过程，并且能够学习并变得非常擅长。这在围棋和国际象棋中被用来开发出超强的计算机，能够下得比教它的任何人都要好，它基本上是通过与自己下棋来做到这一点，因为规则非常明确。

它变得越来越好。令人惊讶的是，它不需要任何关于国际象棋的先前知识。所以那些谈论著名开局的国际象棋书籍，几乎就像是一个来自另一个平行地球的外星人，自主发展了国际象棋，但这两个星球没有分享任何国际象棋的技巧。

所以这些来自平行世界的极高级棋手来到地球下棋，他们遵循完全不同的规则。我认为这也是击败这些高度优化机器的复杂性的一部分。

所以让我们看看OpenAI实验室。OpenAI实验室基本上是一堆游戏。甚至是Atari游戏都设置好，让你的程序可以与它们竞争。这就是OpenAI Gym。你可以看到他们有Atari游戏，这些游戏是通过Atari运行的。

这个在Mac和Linux上效果很好，在Windows上，你可以让它工作。但在Windows上让Atari模拟器工作有一些复杂性。你看到的经典游戏，比如这个杆车和摆锤，运行得很好，我们将开始使用杆车和山地车。

这些都是一些相当经典的游戏，例如，让我给你展示一下它们的样子。如果你点击环境，你会看到这些是经典的控制游戏。我们特别要处理的游戏是cartpo和山地车。山地车有两个版本，这在我们看到如何实际与这些互动时变得很重要。

这里有一辆山地车，它基本上有一个布尔油门。要么你把脚踩在刹车上到底，要么踩在油门上到底。山地车的目的是尽量到达这个旗帜。

车的发动机根本没有足够的动力去做到这一点。即使你全力踩下去，它也是如此。因此我们基本上必须……你在这个游戏中有三个控制：向前、向后和刹车。所以推上去，它大概能到这里，然后就会滑回去。它的动量不足。因此，它需要尽可能快地向后滑回到这里。

用力推上去，然后用力推上去，最终通过前后摇摆，你会获得足够的动量让它上坡。因此，这需要一点AI来学习如何做到这一点。我还会给你展示一个我写的算法，基本上是一些if语句，能够解决这个问题。无论你往哪个方向走，如果你在上坡，就始终让油门全力以赴向上走。

你可以部分踩下油门或部分松开。我认为这并没有什么帮助。我觉得你几乎需要全力踩下去才能上坡。这只是试图保持平衡，所以你有这种拉力。想象一下，如果你拿一根米尺或一根码尺，试图在手上平衡，然后在房间里走动，而不让它掉下来。

这基本上是它试图做的事情。所以让我们回到这里，到这一部分的注释中，在Google Collab中实际上现在我们正在打开它在Collab中打开它。让我们看看如何实际利用AI gym。我这里有一些基本信息，但我们要做的第一件事是导入AI gym和我向你展示的每个游戏基本上都称为一个环境，而我刚刚定义的这个函数本质上是查询环境，你需要打开环境，然后你需要打开该环境的规范。

我在这里所做的是你可以为我们将要处理的每个环境运行它，并且我还将向您展示它适用于几个Atari游戏。如果你为mountain car运行它，它告诉你动作空间，这种类型的动作空间是离散的。这意味着你可以做三种离散的事情来运行那辆山车。

你可以倒着走，你可以踩刹车。我觉得你在踩刹车。它可能在空转，我不确定，你可以向前走。我告诉你，我处理几乎所有这些环境时，我通常会查看该环境的源代码和Github，以真正理解它们是如何工作的。现在是观察空间。所以你有动作空间。这些都是你可以做的事情，然后观察空间基本上是世界如何改变的。现在有两个框值框基本上意味着连续的，所以有两个连续的变量返回，并且这两个基本上告诉你汽车的位置左右，所以它在山上上升到哪里，以及在哪一边，所以本质上是屏幕上的X，然后另一个值是它的速度是多快，这取决于它移动的方向，这就是整个。

Unniverse只需要这两个值最大的情节步骤。所以每一集都是这场比赛的一场比赛，如果汽车没有在200步之内解决问题，那么这一集就会结束。我们放弃了。想象一下一步像一帧，想象你在玩一个视频游戏，你知道一个视频游戏，你的渲染引擎可能每秒钟发射30帧，这就是电影的情况，每一步都是一帧，所以它最多会有200个那些不确定的步骤。我特别不喜欢这个命名。这些大多数情节或环境都是随机的。所以你的车不像那辆车的物理计算完全可预测。现在你可以种子，你可以把一个种子放进去，这就是不确定性的意思，如果你种子，那意味着它将是确定性的，但如果你不种子，它就有些随机。所以这就是。

本质上，这意味着我所处理的大多数环境都是非确定性的，因此如果你给它设定种子，它们就会是相同的。这一点很重要，如果你训练了一个神经网络来玩山地车，而你用不同的种子让它玩，它可能会输，因为它面临随机情况。它已经学习了一些关于如何玩游戏的基本理念。

但是如果我不知道，你看世界上最好的赛车手，没有保证他们每次都会赢，因为有很多随机因素，这些随机因素只是他们无法控制的事情，超出每场比赛的范围，他们可能不会赢。现在每一步都是同样的道理。

你会得到一个奖励，所以你本质上给它一个动作，它会给你反馈观察结果，那么下一步的世界看起来是怎样的，然后你再给它另一个动作，它会告诉你世界的样子。奖励阈值本质上就是你的基本奖励，所以如果你得到负奖励。

110你没有做得很好。现在山地车在奖励上非常吝啬。你只有在获胜时才能获得奖励，这使得训练有些困难。想象一下，如果你要建造这座建筑，而在每一步都没有任何反馈。你建造完整个建筑，然后告诉你它的好坏。

这非常令人沮丧，但神经网络实际上可以优化一些可以赢得山地车的策略，我们将在下节课中看到一个例子。现在我也可以查询环境以获取小车平衡的情况。所以这是一个试图平衡杆子和小车的情况，该动作空间是离散的。

所以你不能停止，你在一个方向上移动，或者另一个方向，而你的观察空间有四个值。我不得不查看代码才能弄清楚这些是什么，但本质上是小车的位置，你只在两个维度上移动小车，小车的速度有多快，因为当你从这两个离散值中施加更大的力量时。

驾驶时，你加速，杆子的角度是多少，杆子的末端速度是多少，这就是物理。通常你会想到摆的速度，我的意思是，它本质上是一个倒立摆。末端的速度是多少。你可以把小车推向左边或右边。

所以我们处理的这两个值是离散的，意味着只有两个设置。还有一个变量，两个可能的设置或者连续的，这就是箱子。所以有四个连续值。如果你在处理山地车的连续类型，它们都是箱子。所以动作空间只是加速器。

你可以给它正加速度或负加速度，以及连续范围或零，意味着什么都没有。出于某种原因，最大剧集步数是 999。而且这是一个双重负面非确定性。因此，它不是确定性的。然后奖励范围可以从负数到正数，奖励阈值是 90。别担心这个警告。我认为这实际上是 OpenAI Gym 中的一个错误。OpenAI Gym 维护得不多，上面有很多问题被发布。

但这仍然是一个很棒的工具包，用于突破。这是一个 Atari 游戏，我想展示他们为一些 Atari 游戏所做的事情，这真的很迷人。所以观察空间本质上是一个 210 乘以 160 乘以 3 的图像。因此本质上是一个红绿蓝图像，你在这里做的是使用图像，那么用户在看什么呢？他正在看屏幕，就像一个用户一样，这很酷，它只是看着那个图像并学习如何玩游戏，剧集步数可以持续很久，你知道的，1000 次。非确定性几乎总是为假，奖励范围可以是任何东西，阈值他们通常甚至不给你一个，我通常不使用范围和阈值。

Kd FYs 现在，我认为这真的很有趣。他们还给你提供了突破性内存。你看到的是 Atari 2600 的内存。Atari 2600 的内存是 128 字节，不是 K 不是 MB，当然也不是 GB。因此，这并不是很多内存。我是说，天哪，图像大小比这个游戏所需的内存还要大。我是说，一行是 210 乘以 3 字节。所以，这不算是很多内存。

但是通过查看这个游戏的内存，你可以大概知道发生了什么。而那些 128 字节在老式游戏中是用来做什么的。他们称之为内存映射，谁知道，只有 Atari 开发者知道。他们可能甚至没有使用全部的 128 个字节。仅仅通过查看内存来操控，你可以在玩游戏时获得信息。

你能够玩这个游戏。现在这两者，动作空间。所以输入是 4。这是你的摇杆。四个方向：上、下、左、右，因为你在移动那个小方块，试图击打球，而你不需要给球一个击打命令。

仅仅因为它击中了你的角色就会导致它弹出，而令人着迷的是，我们将看到如何开发一个代理，它能够学习玩这些雅达利游戏。我还想给你展示，因为我们在CoLab中，如果你在自己的本地计算机上运行，会发生什么，当你尝试渲染和播放这些游戏时，窗口会弹出，你将实际看到雅达利游戏。所以如果你想在CoLab中实际玩雅达利游戏，因为CoLab是一个虚拟环境，我会告诉你如何做到这一点。我们将运行这部分，它会进行pip安装，我们正在安装Python虚拟显示，这对CoLab很有用，我还用它生成一些我附加的展示视频，给你展示一些播放的东西，给你一个Python虚拟环境。

环境基本上会将其渲染为文件，然后我们可以将其转换为视频。让我们继续运行这些。所以基本上，你将玩吉他游戏并录制视频，你可以下载视频或在CoLab中观看，所以你不能实时观看，只能事后看到，但这也很好，这就是你在CoLab中能做的。这里的部分我提供了链接，因为我从一个非常方便的写作中获得了这些功能，该写作介绍了如何在CoLab中使用它，所以我将运行这些，只需定义它，以显示视频并为你设置，我们将播放《亚特兰蒂斯》版本零，所以我将继续运行。这里的基本情况是，它没有使用任何AI，而是从动作空间进行采样，基本上在随机行为中取样，看，这就是游戏，这并没有真正进行。

这是一个实时视频，记录了那个细胞运行时的简短片段。现在你可以反复观看，时长约为一分钟16秒，你可以看到玩家被击败得很惨。这里有一把枪，你可以发射一些宇宙飞船，但随着游戏的进行，宇宙飞船最终会将其摧毁。这里的想法是，要热爱1980年代的图形，这是一个水下城市，这里是水，哦，主炮被击毁了，所以当你失去生命时，这是对AIG的概述，我们将在接下来的每个模块中更多地使用它。

感谢观看这个视频，如果你对强化学习和为游戏训练的更多内容感兴趣，请订阅我的YouTube频道，非常感谢。

T81-558 ｜ 深度神经网络应用-全案例实操系列(2021最新·完整版) - P63：L12.2- 用于游戏学习的Q-Learning算法简介 - ShowMeAI - BV15f4y1w7b8

嗨，我是杰夫·海顿。欢迎来到华盛顿大学的深度神经网络应用。在这个视频中，我们将基于使用 G。我们在上一个视频中看到了 Open AI gym。现在我们将对其应用 Q 学习。我们将看到如何利用机器学习构建一个基本的查找表，以展示环境可能作用于的任何状态应采取的行动。然后我们将继续展示深度神经网络如何成为一个非常复杂的表的表示，从而无需逐个存储每种组合。

这标志着深度 Q 神经网络的开始。想要查看我关于 Cale 神经网络和其他 AI 主题的所有视频，请点击订阅按钮和旁边的铃铛，并选择全部以接收每个新视频的通知。那么让我们看看 Q 学习。我将在 Google coabab 中运行这个。这实际上并不需要 GPU。这里的代码甚至没有设计用来利用 GPU。

😊。

我将给你一个基于 Python 的表格 Q 学习查找实现。这实际上就是 Q 学习的工作原理。在下一部分中，我们将扩展这个并且实际使用 Kra 的 TF agents 在深度学习中实现这一点，然后完全超越这一点，使用更复杂的环境，比如一个 Atari 游戏。这里是 Google Coab 的设置，我们肯定要使用 Tensorflow 2。

这里有一些额外的代码，如果你在运行 coabab，它将会执行，因为截至录制这段视频时，coab 并不包含 TF agents 和一些我想要的其他功能，这样我才能在浏览器中直接展示视频。TF agents 提供了一种非常好的方法，可以在环境渲染时仅从单一图像中捕捉快照并展示给你，还有其他方式。

绕过这个，但是TF代理使得这一切变得很简单，除此之外我们在这个视频中不使用TF代理。我们将在下一个视频中使用TF代理。我将继续运行这一部分。它会显示使用Google Colab，一旦这个部分真正运行，我就会运行这部分以安装我希望拥有的所有库，这可能需要一些时间，所以我们会快进。在Q学习中，有几个术语我会在我们进行时提到，所以现在了解这些是有好处的。代理可以想象成一个视频游戏，尽管在本章的最后部分我们将做一些不是视频游戏的事情，但代理是你的玩家，即在环境中进行游戏的计算机玩家。环境是代理存在的宇宙，环境有状态，随着代理的互动，环境的状态会变化，而代理通过与环境的互动来与之互动。

首先，在这个视频的这一部分，看看环境的状态。环境状态只是一个数字向量，告诉我们小车的位置或速度等信息，但当我们进入Atari时，环境实际上是一个网格，就是视频屏幕，游戏正在进行，一步是通过环境的一个周期，所以你采取一个动作，就像向上移动。

向下移动，向左移动，向右移动，然后看看这对环境产生了什么影响。一个完整的执行某个动作并查看结果的周期就是一步，所有步骤直到你完成目标或被杀死，或者模拟结束，这叫做一个回合，这就像是一场视频游戏的游玩。一轮是一个训练构造，它可以是一些回合，具体取决于你如何配置，然后终止状态是导致游戏结束的步骤。

你赢了，生命用尽，类似的情况。所以Q学习基本上建立了一个表，以便在这个环境中的每个状态给我们指示哪个动作将是最有奖励的，因为在这个过程中，你在每一步结束时会获得奖励，这告诉你这一步的有效性。有些游戏意味着在最后才会给你奖励。

只有在你想要的时候才会到达最后的终点。那些可能会有点难以优化。但Q学习仍然可以做到。这几乎就像你完成四年学位课程，最后要么获得文凭，要么不获得。如果没有，谁知道你做错了什么。但这就是我们让计算机经历的折磨。

所以我们将使用一个叫做山地车的东西。这是一个经典的强化学习“你好，世界”类型的东西，本质上就是山地车。现在如果你在这里运行这段代码，我不会运行它，因为它已经渲染了。但这会向你展示你所指定的环境的一个帧。

我正在指定山地车。如果我输入太空侵略者，它将绘制太空侵略者。所有小外星人都在下来被击毁。所以这就是山地车的工作原理。这个游戏的想法是你的山地车本质上可以提供向前的推力。因此你实际上只有三个可以采取的行动，其中一个行动是无动作。

然后另外两个动作要么是向这边加速上坡，要么是向这边加速上坡。诀窍是你的车子力量不够，无法上坡。试着直接冲上去。我稍后会给你展示。你并不太成功。所以你需要做的是冲上坡，尽可能往上走，然后你会回滚，但你会在这个坡的一侧积累一些势能。

然后你加速，直接冲上去。😊 再往上。通常你可能会在两次尝试中完成。但想法是利用来自另一个山丘的势能，保持你的动量，从而一路到达这里。因此，你可以施加左侧的力量，或者不施加力量，或者施加右侧的力量。这些数字指定了这些离散动作的方式，Q表的工作原理是你只能施加离散动作。因此这三件事情是没有像施加最大左侧力量或施加一半力量的情况，像你的汽车一样，当你按下油门时，全力加速给你完全不同的结果，而轻轻踩下则是另一回事。这在Q学习中是可能的，但你需要使用一些特殊的技巧和其他东西。

当我们进入使用深度神经网络的深度Q学习时，我们会详细讲解这个，但通常假设这些是离散动作，但连续动作也可以，只需为这些使用不同的算法。在本模块的最后部分我们将讨论。

看看深度神经网络的一个应用，深度Q网络，而不是一个游戏。它确实采取了连续动作。现在，山地车环境。基本上你所拥有的就是这辆车的位置。我相信零就在这里，然后是负值和正值，还有速度。

它的速度有多快，这也是正值或负值，这些都是连续的值。因此，你往这边走的速度或往那边走的速度，负值与正值。现在这是使用一些代码，允许你实际可视化并看到它上升，我没有上次视频中的代码。让我来运行这个。因此，我将运行它，它给你提供几个函数来显示视频，实际上可以在网页浏览器中查看视频，这很方便，因为很多时候你需要一个GPU，你可能想在Google Colab上运行这些以利用免费的GPU，但如果你本地运行，也可以在浏览器中显示。

😊，通常会弹出并展示给你。那么现在让我来运行它。这是一个非常顽固的山地车，试图将最大加速度施加到右侧。所以它就是全力以赴地往右推。试图攀登山峰，最终力量不足。现在你看到的这个输出。

你可以看到状态。因此状态显示了汽车的位置，它的速度有多快。它达到完全速度并有所波动，这有点随机。然后这是位置。你可以看到它基本上越来越往山上走，在某个时候，确实就在那附近，它开始滑回下来。一幅图胜过千言万语。所以如果你看这个。

这就是它的作用，试图，试图是谁的希腊人，把圆石推上山？如果我没记错的话是西西弗斯。这基本上是一个不可能完成的任务。现在，我用传统编程的方法。我编写了一个车来解决这个问题。对于这样的简单情况，是的。我可以写一个完全确定性的程序，只需给它一些规则。

规则基本上是我将要观察的状态。我只关注状态，不会关注速度。我不在乎。我只想知道状态的位置。如果这个位置大于零，就这样。

然后我将向这个方向推。如果车是往这边走，我将向这个方向推，尽量让它尽可能地往这一边走，以积累尽可能多的势能。这个程序其实非常简单。如果位置，状态的第一个元素大于零，我就施加。

推向右边。否则，我施加零，即推向左边。一是完全没有动力。我认为没有任何刹车施加，但我们真的不需要刹车来实现我们的目标，或者让发动机减速。所以我们在这里运行它。我们看到相同的步骤。注意没有奖励。

这就像试图完成你四年的大学，而你唯一得到的反馈是你毕业了还是没有。但我们会一直到最后，最终，哦，我没有展示最后的步骤。所以你甚至看不到你最终得到的奖励，当这个东西获胜时。但让我们看看我编程的汽车是如何工作的。

你可以看到它变得更成功并且赢得了比赛。好吧，那是一个硬编码的规则。想象一下，如果特斯拉的工程师坐在那里，试图考虑到你在实际驾驶汽车时可能出现的每一种情况，那将是相当痛苦的。而且这根本行不通。你永远也想不到所有的事情。我的意思是，这几乎是一个 A1 B 世界，像是平坦的世界，因为我不能真正向上或向下移动。

我只在左右移动。因此，强化学习的工作方式是我们有代理和环境。代理在环境中采取一些动作。然后从中有两个输出。一个是下一个帧的状态，另一个是你从这个动作中获得的奖励，针对山地汽车。

你只有在成功并且完全上山时才能获得奖励。现在，我会简要提一下，因为在强化学习中，有时如果环境不一定给你奖励，你可以通过设计自己的奖励来获得更大的效果。这可能是做一些事情，比如说，好的。

我会给它一个奖励，可能是因为它比以前上山更进一步之类的。所以用你作为人类的思维和启发式，实际想出一些中间奖励，以便给它更好的结果。现在这条线表示训练发生并且进行调整。然后下一个状态进入代理，继续进行。

它继续，一直继续，现在，这个方程是 Q 学习通常的表示方式。如果你之前没见过很多这种方程，它看起来有点复杂和疯狂，但其实没那么糟。我想带你逐步了解它的各个部分，因为这实际上相当重要。因此，Q 学习的工作方式是保持那个表格。

所以，为环境可能处于的每一个状态准备一个表格。在这种情况下，这是所有可能位置和所有可能速度的网格，因为这就是你拥有的两个状态，以及状态 T。这意味着所有这些状态。因此，在这个问题中，S 实质上是一个数组，保存这两个值，针对你可能采取的每个动作。因此，在那个网格中的每个不同状态。

你可以采取三种动作。所以这实际上是一个立方体，网格上的每个值本质上是三种动作以及你在那里的预期奖励。所以这实际上是说，值将会被改变。

本质上将会被添加。所以这个旧值，几乎就像编程中的那样。a 等于 a 加上某些其他值加上子 delta a 等于 a 加 1。如果整个事情是一个。所以这里的整个部分就是我们计算的 delta，我们要改变的 Q 值。这在机器学习中非常典型。我甚至不知道我学习过多少算法具有完全相同的格式。

就像神经网络中的权重，权重等于权重加上梯度乘以学习率。学习率用于缩放它。如果没有这个学习率，那么这个整个大的值就会在各个地方翻转这些 Q 值。这样会是一个过于激进的变化。就像学习算法对它所学到的每一个小新事物都超级兴奋，以至于完全覆盖了之前学到的大部分内容。

所以你的 alpha 是你的学习率。我在这个示例中使用的学习率是 0.1。因此，我们要计算的这个 delta 的十分之一就是我们要应用的。他们称之为时间差。我直接从维基百科上拿的这个方程。现在你得到了一个奖励。所以让我们看看这个奖励，因为一切都依赖于奖励实际上是如何发生的。

我喜欢把这些方程看作是块，然后把块撕开。所以在这个乘以学习率的 delta 内部，实际上有两个部分。注意这个旧值。那是你在这里添加的相同旧值。你可以做一些代数简化和消去，而不需要那个。

但这只是写成这样的方式。基本上我们希望整个东西是一个 delta 被添加到这个。因此我们必须减去旧值，这样基本上这是我们的新值。这是旧值，所以这两者之间的差异。我们希望得到这个新值。因此我们需要从中减去旧值，以便看到幅度的变化。

然后我们用学习率进行缩放并添加它。因此让我们看看新值，因为那是有趣的部分。这只是设置 delta。我们需要知道我们希望改变多少。所以这是我们最终想要达到的理论新值。因此，奖励。

Re 是重要的。奖励是我们因应用当前状态和行动而获得的。因此我们在更新当前状态下我们所采取的任何行动的 Q 值。奖励，基本上，奖励就是我们将要获得的未来价值的估计。所以表中的那些值。它们告诉你在特定状态下每个行动的奖励。

通常你只是采取那些动作中的最高一个。但我们想要评估现在不采取的另外两个动作，我们想要得到最终将获得的奖励。所以我们所做的就是在应用完动作后，无论获得了奖励与否，然后我们采用这个折扣因子，这个值设为0。

95，因此我们正在基于该动作进入的下一个状态，考虑95%的最大Q值。所以不论该动作导致的是什么新状态。我们查看该新状态的Q值，并取这些动作Q值的最大值。

所以这是一个最大值的估计，正如它所说的，这是下一步的最佳未来奖励。你不一定想直接应用这个，因为那样的话思维就太过于未来了，而此时此刻是相当重要的。我们刚刚得到的奖励是在这两者之间的平衡，但这是一个非常常见的设置，我使用的是95%。

所以我们在很大程度上考虑了这两者。因此，这就是这个方程如何工作的。我想带你逐步了解，因为这是机器学习中一个非常常见的格式方程，我给你描述了这些值的含义。

我们刚刚经历了所有这些。所以让我们看看Q学习的汽车。Q学习的汽车基本上会学习以类似于我给你的预编程汽车的方式进行操作。关键是它是由一个对重力、坡度或其他任何事物没有概念的机器学习的。它只是和汽车玩，直到最终获得奖励，并将其分配到行动中，最终得到一个相当好的程序。

这就是Q学习的汽车。它正在计算离散状态，这只是将位置放入这10个桶中的一个。这是在运行游戏。所以虽然我们还没有完成，但这基本上是一个非常重要的部分，需要理解。这个是epsilon的使用。Epsilon是一个值。1意味着让汽车完全不规则地移动，0意味着让汽车完全按照Q表移动。

5意味着做得有点一半一半。这个epsilon值一开始是非常随机的，然后我们在前进过程中逐渐减小，使其越来越接近零。最后，在最后部分，它完全从Q表中执行，并完全依赖于Q表。随机性迫使它探索并尝试激进的新想法。

然后一旦你锁定了一个相当好的整体技术，机器学习就可以接管并细化模拟，这与其他蒙特卡洛技术非常相似。我们通过调用环境获得奖励。将状态转化为离散值。我们检查是否达到了目标位置，如果达到了我们就完成了。

然后我们更新Q值。这是之前提到的大的Q值方程，用Python写的。接着我们将状态切换到我们移动到的新状态。这基本上是在运行游戏。这是游戏的一个步骤，所有这些都是超参数。学习率是算法的学习率。

我们更新Q值的速度。我之前告诉过你，这就是95%。我们想运行多少回合，多久更新一次。我把这个设置为每一千次离散网格大小。只使用10，因此两个山之间的整个左右区域有效地被划分为10个值，以保持Q学习的离散输入。

这就是关键学习通常是如何运作的。我们可以让Q学习在连续值上工作，但这涉及到后面章节中我们会看到的其他算法。这是我之前提到的epsilon衰减。因此，我们加载山车环境。我们设置epsilon变化，以便它最终能够在我们想要的回合中衰减到0。

我们将循环，直到回合结束。当我们每隔1000次显示一次时，它会告诉你发生了什么并运行一个游戏。只有在本地运行时，你才能看到游戏。我们统计成功次数并运行它。因此，你可以从前一千个回合中看到。

完全没有成功。我们在4000次之前没有任何成功。在很多情况下，由于没有反馈，它唯一真正的能力是尝试随机方法。最后，它取得了一些成功。这就是epsilon衰减的原因，因为我们希望随机性开始消失。

一旦它开始学习以精炼所学内容，你可以看到在这千个回合中，它最终是完全成功的。然而，环境中有很多随机性。因此，它还没有完全学习。我喜欢让它继续，直到它达到相对一致的成功，如此处所示。

你可以修改这个，使得代码实际上查看这个并根据回合的一致性停止。然而，你面临的问题是，你增加了总回合数，然后epsilon的衰减效果就不好了。

因为在开始时你不知道自己要走多深。现在运行它。我们可以在这里看到它运行，并且它表现得不错，虽然没有预编程的卡车好，但它确实运行了。现在让我们深入探讨一下Q学习的内部，看看这里发生了什么。我可以导出表格。速度和位置都被离散化。我们必须离散这两者。否则。

我们如何构建一个表呢？这里将有无限的值。现在，当我们进入深度 Q 学习时，我们可以轻松处理这两个连续值。然而，如果我们想要连续的动作，深度 Q 学习确实需要一些额外的算法，基本上我们可以将加速器应用到一半或三分之三的地方，或者类似的情况。现在，看看这个网格，这并没有告诉我很多，首先。

我觉得速度在这个问题中甚至不是一个很有用的输入。当我编写我的预编程汽车时，我只使用了位置。因此，我所做的是取这些值的平均值，这样我可以一次查看一行和一列，因为正如我所说，对于这个问题，我并没有看到速度的真正价值。你可以看到，当我取平均值时，这些值对齐了，你可以看到它几乎学习到了一个梯度，它学习了特别的这个是我更感兴趣的。

它正在学习如何在一个方向上应用更多，而在另一个方向上则较少，上面与下面的比较。现在，上面这最后两个有点异常，但这也可能是因为它已经达到了既定目标，已经撞上了山顶，此时它的行为可能并不重要。这就是 Q 学习，Q 学习是基于表格的，我们将在深度学习中更深入地探讨这个问题，在那里我们可以更好地处理连续值。

St，以及在动作方面。感谢您观看这个视频。在下一个视频中，我们将探讨如何将这个表扩展到深度 Q 学习，这样我们就不必逐一表示每种组合，而是让神经网络学习如何进行泛化。

T81-558 ｜ 深度神经网络应用-全案例实操系列(2021最新·完整版) - P64：L12.3- OpenAI Gym中的Keras Q-Learning - ShowMeAI - BV15f4y1w7b8

嗨，我是杰夫·希顿，欢迎来到华盛顿大学的深度神经网络应用。在这一部分，我们将研究如何使用深度Q神经网络。所以这是一个深度强化神经网络，它允许计算机学习玩游戏。我们将从一个相对简单的例子开始，我们将看到使用TF agents的Polcart。

然后在下一部分，我们将其扩展为更复杂的内容。我们将使用一个雅达利游戏。接下来，我们实际上会创建一种金融模拟。所以做一些甚至不是视频游戏的事情。要查看我所有关于Cale神经网络和其他人工智能主题的视频，请点击订阅按钮和旁边的铃铛，选择全部以便收到每个新视频的通知。

现在我们将看看如何使用OpenAI Gym进行Q学习。这次我们将使用汽车。因此，我们将使用TF agents。实际上我们现在正在使用深度神经网络来建立你之前看到的Q表。基本上在Q学习中，你会建立一个表，列出世界上所有可能的状态。

然后是你下一步的预期奖励。现在我将要在Coab中运行这个，因为GPU对这个很有用。我会选择。😊。

运行时和全部运行，因为至少在当前版本下，希望在你运行时有所改善。实际上，使用当前版本2.2的Tensorflow和谷歌Coab中安装的其他一些东西时，会出现错误。

所以你可以看到，这部分程序正在运行，这正好让我得到了我想要的Tensorflow的正确版本。这部分正在进行一些安装，以放入我们需要的各种软件，比如TF agents，其他软件让我可以捕捉正在进行的游戏作为视频，这样我可以在Coab中播放。如果你在自己的电脑上本地运行，可以使用这个，或者你可以省略这部分，它会弹出一个窗口，展示游戏是如何进行的，所以你通常会在这里遇到这个错误，我想向你解释一下，因为这几天才开始发生这种情况，当时谷歌升级了一些东西。

Lb 和 TF 代理也是如此。如果你遇到这个错误，基本上让我再解释一件事，如果你收到这样的错误，这个错误并没有告诉我太多。如果你谷歌一下，他们基本上会说重新安装 proto buff，但实际上这并不是所需的。因此这让我花了大约一个小时，我之所以搞清楚这一点，主要是通过逐一运行这些代码，然后查看哪个代码实际上引发了错误，当我单独运行它时。

我实际上找到了真正发生的错误，基本上是说由于我安装了上面所有的包，我需要重启我的运行环境，而我现在正这样做。现在我基本上可以执行一个运行并全部运行，它将顺利完成。

这是一个小小的技巧，如果你没有遇到错误，你可能不需要这样做，不用担心。自从我录制这个视频以来，他们已经修复了这个问题。现在在运行时，这需要一些时间。并且请注意，即使我重启了环境，它也显示“已经是最新版本”，这是我上次安装的版本。

所以如果我离开这个环境几个小时，Coab 会超时并带走我的环境，那么我就得从头开始重新运行它。但即使我重启了环境，我通过安装这些包对硬盘的更改仍然保持不变。这就是它的工作原理。现在这应该已经通过之前出错的部分了。

我当然希望在 Google Coab 和 Tensorflow 之间，他们经常让我回到起点。但这也是我制作这些视频的部分原因，展示给你们看这些东西是如何一起工作的。相信我，机器学习以光速变化，我一周前有效的代码可能现在还有效，也可能已经无效了。因此，这就是为什么你总是要检查我的 Github 仓库以获取这些内容的最新版本。

所以当我们逐步讲解我即将说明的这些代码时，它是训练的。这一切已经完全完成了。所以我将让你继续进行训练并运行，同时我解释一下这里发生了什么。这些都是你需要的导入内容。你只需使用这些即可。

这些是超参数。其中一些很重要，而有些则不那么重要。迭代次数是非常重要的。这是你将训练多长时间。在这个情况下，你实际上并没有使用提前停止，你只是选择迭代的次数。

我并没有设置这个以便它可以重启，这可能是一个非常好的改进，因为如果你在做一些非常复杂的事情，你可能会训练 20000 次，然后意识到我想再训练 20000 次。这是非常重要的，这将决定你项目的成功或失败，你需要足够的迭代。我收集步骤。这并不是那么重要。

至少我没有发现这个问题。这是你运行多少次回合以获取一些初始数据。用于训练神经网络的每次迭代的收集步骤。实际上这非常重要。对于像这样的简单模型，我设置为1，但你可能想在Atari上设置这个。我想我把它设置为大约10。训练时间会长得多，但你会得到更好的结果。

通常情况下，每次迭代的收集步骤和迭代次数本身是增加这些的唯一缺点，这会使训练时间变得很长。我通常会把它设置在1到10之间，不会设置得太高。

这是你的缓冲区大小。因此，基本上它是通过回合运行，并存储每局游戏的信息。最初在开始之前填充10个。这实际上是你愿意在这里存储的步骤数量。

这是批处理大小，这在机器学习中相当典型。你可能会发现稍微小一点的大小能获得更好的结果。你的学习率非常关键。我通常会将大部分调优时间用于调整学习率、每次迭代的收集数量和迭代次数。

基本上，你希望这个数字尽可能大。如果设置得太大，它会很快变得不稳定，负十次方的值对这个来说工作得相当好，但如果你发现它不稳定，可以改为负四、负五，依此类推。但如果你设置得像负三或负二，可能就无法达到，不过在那个范围内，它会训练得更快，并且需要的迭代次数更少。

这是我们希望日志报告的频率，这不会对你的训练产生太大影响，但它可以让你了解发生了什么。评估回合的数量也就是你希望基于多少个完整游戏回合进行评估，1个是个不错的数字，然后你希望多频繁进行评估，别设置得太低，因为这确实需要时间。

进行这些评估时，我们会看到在 Atari 游戏中，我让它进行得更远一些再进行评估，以保持效率。我们将要使用的环境是 cartpole，它基本上是在试图移动一个平衡杆的手推车，你不希望杆子倒下，所以基本上是要计算重力和角动量。我喜欢这里的代码，这让你能够渲染环境的样子，这是一种很好的可视化方式。这里是手推车，这里是杆子，杆子通过铰链连接到手推车，我打印出一些基本数据，因此你可以看到观察到的值基本上有四个，分别是手推车的速度、杆子的角度、杆子的角速度，以及杆子的位置，这样组合起来就是第四个观察值。奖励非常简单，只是一个基于如何的数字值。

你保持杆子直立的时间越长，这就描述了保持的值。让我们看看。我会提到这一点。你会看到我们处理 T F pi 环境和 T F Tensorflow 环境。有两种环境类型可以处理。通常你在处理 Python 环境，但 Tensorflow 环境完全是用 Tensorflow 编写的。

这意味着你可以将其与神经网络的整个执行树一起编译，它们会变得非常高效。然而，通常情况下，至少在这个例子中，Atari 游戏都是用 Python 编写的。或者至少是用其他非 Tensorflow 的语言编写的。所以我们几乎必须使用 Python 环境。我发现自己通常是在使用 Python 环境。

我并没有频繁使用 Tensorflow 环境。我敢打赌你会更快。😊。请访问这里。虽然有时候我更喜欢直接投入计算，因为我编程的越多与 Tensorflow 相关，如果我想尝试其他东西，比如 pytorch 并进行替换，就会有更多与特定平台相关的遗留代码。

在 Python 中操作让我保持相对中立。所以在这里有一些设计考虑，代理。我们将使用 DQN 来处理这个。DQN 在你的动作空间是布尔值或离散时表现很好。在这种情况下，你要么朝一个方向施加力，要么朝另一个方向，左或右。真或假。这不是施加多少力。如果你确实需要一个连续或数值的动作空间。

然后我推荐DDPG。抱歉，DDPG。这是我们将在模块的第五部分看到的内容，而不是下一部分。因为这让我们拥有连续的动作空间，而对于我正在运行的金融模拟，我希望是连续的，能够告诉我应该将收入的多少百分比投资于某个特定方向。因此，我们创建的代理的Q网络是基础的深度神经网络，然后我们将Q网络放入DQN网络。大部分代码供你自行使用。

你可以直接以这种形式使用它，因为它会根据环境所说的动作和观察空间进行调整。这些策略在代理内部使用，以确定你接下来要做什么。我们将在这里使用随机策略，以便能够填充那个初始缓冲区，以便神经网络可以开始训练。度量和评估方面，我喜欢计算平均回报，这来自TF代理示例，但这。

基本上是查看从每个episode中获得的奖励回报并进行求和。因此，这实际上是一个函数，整个拼车示例来自TF代理示例，然后我将其扩展以在下一部分中玩Atari游戏，但基本上只是查看在10个episode中他们的平均回报。我发现这是一种很好的衡量方式，因为代理操作的世界是随机的，所以每个episode的运行不会相同，并且随着这些随机性得到的平均值让你了解它的表现如何。你可以看到这里的注释，它在TF代理示例中，TF代理确实有一些内置的度量供你使用，我绝对鼓励你查看这些。我们计算随机策略的平均回报，仅仅是为了显示它有效的重放。

Buffer，这非常重要，基本上你是在通过这一切训练一个神经网络，这让你能够存储你正在训练神经网络的数据。因为神经网络的实际工作方式是你有一个状态，而在传统的强化学习中，每种状态的所有可能性都可以导致某个动作，我们只是为每个这些动作训练神经网络，以预测Q值和可能的奖励。因此，你将状态输入神经网络，它会返回所有动作的奖励。现在，这里是使用一个表格，所以表格的问题是你必须为每一个可能的状态都有一行，然后查找找到它。现在使用神经网络时，状态输入到输入神经元，然后神经网络通过神经网络的“魔法”为你预测你应该采取的动作，因此它给出所有可能的Q值。

而估计Q值最高的动作，你将选择那个动作。通常作为你要选择的行动。现在神经网络需要被训练。这就是重放缓冲区的作用，当你经历多个回合时。你将所有这些状态放入这里，看看你的奖励实际上是什么，这就成为重放缓冲区。

训练数据，因为你实际上会看到神经网络所做的奖励，这会添加额外的行。因此，神经网络帮助你达到某个状态。但接下来那个状态，你让神经网络告诉你该怎么做。但奖励是你根据那个奖励训练神经网络，以便它可以预测下一步应该采取什么。所以它不断获得这种强化，神经网络帮助你在游戏中逐渐达到这些状态，但你实际上是从视频游戏中馈送奖励。

得分还是被击杀，这些都要考虑到那些Q值中。这就是你教神经网络做的事情，因为这比使用表格更有效。你无法为每一种可能的组合创建一个表格。神经网络学习概括这个理论上的巨大高维表格，并基本上为你预测那些Q值。数据收集。这就是你生成那1000步的地方，以便获取一组随机数据。这就是我们基本上所做的。

我们有一个收集步骤，这是由主函数调用的，收集数据。这是直接来自示例和TF代理的。我们所做的就是计算时间步。我们希望预测多远，我们在那个时间步采取行动，然后我们获取所有数据，这些数据用于从那个步骤到达下一个动作的轨迹，并将其添加到训练批次中。

这就是我们如何逐步构建这些行，神经网络实际上是在学习训练，然后我们按照请求的步数进行处理。这实际上是我在TF代理代码中发现的一个bug，我就这样留着它，但他们确实在上面有一个超参数，允许你指定步数，而在这里却忽略它，仅做100。我实际上在下一个Atari示例中修复了这个问题，因为这很重要。然后我们将其转换为数据集，我们基本上准备好了。现在我们在训练代理，我早些时候启动了这个，并且幸运的是它完成了，这很好。我们基本上在这里经历一个循环，设置我们希望经过的迭代次数，所以从上面是20000，这是逐步构建我们拥有的数据集，以便我们继续根据实际看到的奖励训练神经网络。如果我们达到想要的日志间隔，那么我们就继续。

并打印出一些进度信息。如果我们达到了评估间隔，那么我们使用我之前给你展示的平均回报函数进行评估。在这里，你可以看到随着训练，平均回报趋向于不断增加。我认为最大可以达到200。现在，为了看到它实际运行，我们有视频代码。

我们之前见过这个。所以它逐渐增加，几乎达到最大值后停止。如果你想看到它实际运作，可以发现它在平衡那个杆子，做得相当不错，同时又在视野中移动。这比看起来要难得多。如果你尝试用随机方法运行，它会很快失效。

一旦重心消失，它就会停止，因为它会下落。没有理由继续。好的，这就是Q学习的基本介绍。😊。

感谢观看我的视频，接下来的部分我们将看看如何将相同的技术应用于一款Atari游戏。如果你对这类内容感兴趣，请订阅我的频道，非常感谢。

T81-558 ｜ 深度神经网络应用-全案例实操系列(2021最新·完整版) - P65：L12.4- 使用Keras TF- Agents的Atari游戏 - ShowMeAI - BV15f4y1w7b8

嗨，我是Jeff Heaton。欢迎来到华盛顿大学的深度神经网络应用课程。在这个视频中，我们将继续学习深度强化学习，我们将看到如何将基于TF agents的程序应用于Atari。我们将看看如何玩pong游戏。然而。

相同的技术几乎可以用于任何Atari游戏。接下来，我们将看看一些不是游戏的内容，以及如何将深度强化学习应用于金融模拟。要查看我关于Cale神经网络和其他人工智能主题的所有视频，请点击订阅按钮和旁边的铃铛，并选择所有以便接收每个新视频的通知。

所以让我们看看深度强化学习的一个最常见用途。至少是大多数人会接触的例子，即使他们不实际将其应用于自己的问题。这就是Atari游戏。现在，在下一个模块中，我将向你展示如何将其实际调整为你自己设计的问题。😊

并将创建一些在强化学习中不是开放AI的东西。但现在，让我们做一个必要的Atari示例。现在我几乎是从零开始构建大部分内容，市面上没有很多TF agent的Atari游戏示例。所以我花了相当多的时间来使其正常工作，去打开这个在Google CoLab上，因为我想使用GPU，所以要非常小心。

如果不使用GPU，速度会非常慢。现在我建议你进行全部运行，因为这里有很多代码，你可能会遇到错误。希望在你观看这个视频时他们能解决这个问题，但在当时你基本上会在安装所有必要软件的部分遇到错误，我会随着情况变化更新这个内容，因为机器学习的内容不断变化，然后一旦你下到这里尝试做所有操作。

这些导入，如果你在这个导入块中遇到错误，进行运行时重启，然后再次运行所有代码。重新启动运行时不会删除之前的安装。基本上，出现该错误的原因是，一旦你安装了TF agents，它会更新你电脑上安装的协议缓冲区版本，而Tensorflow本身需要重新启动Python环境，否则会在那时出现错误。

希望随着时间的推移，Google Coab。我真的希望他们能默认安装Tf agents。我想他们会的，这是谷歌的产品，只是一个相对较新的产品。那么让我们谈谈如何做到这一点。我们仍将使用DQN深度Q学习网络。这一切都是基于虚拟Atari，这是一个完全不相关的机器学习项目。

这只是一个模拟器，你可以玩旧的Atari 2600。

游戏现在我有点老了，但这其实在我的时代之前。这是2600s。这就是Atari 2600，在我年轻的时候出现。但这是当时的老游戏系统。我曾经在这个系统上玩过Pac-Man，那真的很有趣。我更喜欢大约在这个时期推出的另一个系统，叫做Intellivision，它比Atari 2600晚一点。

当然，我绝对真爱的就是Commodore 64。所以这是Atari 2600的规格。它并不是一台先进的机器。你的游戏场分辨率是40乘192像素。现在，他们通过一些创造性的编码来扩展这个分辨率，但你基本上可以将其直接输入到卷积神经网络中。

Atari中的内存量并不大。所以它是以千字节为单位进行测量的。

实际上，这并不是兆字节，我想它甚至小于一个千字节，因此你可以将游戏运行的活动内存推送到卷积神经网络中，160乘192是我认为你通常处理的分辨率，但你实际上可以查看游戏的即时内存，并将其用于状态空间，里面有很多信息，代理可以学习作弊，因为有些内存可能被对手的动作占用，所以计算机控制的NPC在游戏中。所以我们做所有的导入超参数，我调优了很多以适应Pong，还对Breakout和Space Invaders做了一些实验，你必须调整这些值以使它们适应你要进行的任何游戏的迭代次数。

这里几乎处理了25万个样本。所以我通常会整夜运行这个程序。训练需要一段时间，即使使用GPU。我每次迭代也进行10次收集步骤。重放缓冲区大小没有太大差别，但这个学习率，这个10的值和迭代次数，这些是我真正调优以期获得更好结果的参数。

我没有调整神经网络的形状，这也可以帮助你。调整不同的超参数确实需要很多时间，不仅仅是你的时间，还有计算时间。所以在Atari环境中，我们使用乒乓球，你可以看到我在这里玩的一些其他游戏。乒乓球相对简单，基本上是两个球拍在相互弹球。

现在，乒乓球是在我之前的时代。我从来没有真正玩过乒乓球。那应该是1970年代，稍早于我进入电子游戏的时期，我是在80年代中期开始接触这些东西的。所以帧跳过率，你不会查看Atari中每一帧的画面。这只是为了让计算时间变得合理，如果你处理每一帧，处理时间会非常长。TF agents提供了一个包装器来加载Atari游戏，我绝对推荐你这样做，因为它内置了一些必要或不必要的预处理。

但这确实有助于你的神经网络快速学习，因为问题在于，颜色信息真的能告诉你很多吗？这是一个将上下移动的面板，电脑NPC，顺便说一下是电脑控制的玩家。

NPC是非玩家角色，我想我从MMOG中得到了这个，OOGs这是对手的分数。这是你的分数，严格来说，神经网络在查看一切。我不知道它是否从分数中获得了很多，但这也可能是它使用的东西，可能在看到自己输的时候更努力。

我不知道我在开玩笑，它可能不会，它可能会学习到那些分数其实并不重要。所以我们加载了Atari环境，我们使用一个单独的环境进行训练和评估，这样如果你在那里面运行一个评估步骤，就不会改变训练的状态，这可能会让人困惑。

哦，这就像几乎有一次酒精失忆一样。你会跳过时间，但你不知道发生了什么。可能这不是一个很好的例子。但对我来说，这是一个视觉化的方式。现在，代理，这个我从TF agent的示例中得来的。这只是一个围绕正常代理的包装器。你可以看到我们在划分每个状态值。

但通过255。你在做的基本上是将0到255的RGB值转换为0到1之间的浮点值，神经网络对这个处理得更好。大多数示例都是这样做的。我通常在处理图像数据时这样做。不要将0到255的值输入卷积神经网络。

它可以应对得很好，但它确实更喜欢那些较小的值。这些信息很重要。这些实际上是超参数。我没有对这些进行太多调优。我只是取了示例值。但这里是完全连接层。所以这些是稠密层。

大多数卷积神经网络在最后都有稠密层。所以我们只有一层512。你可以添加多个层，如果你愿意。然后是卷积层。这里的通道数是32，以步幅4扫描8x8。这是基本的卷积信息。然后有几个这样的层。

我并没有真正提供一种方式来放置最大池化层，至少我没有看到，但这相对有效。我没有对其进行太多调优，实际上根本没有。然后你构建我们上面提到的 Atari Q 网络。这是神经网络的封装器。我有更多的文本描述我做了什么，因为这个示例我确实是从头开始构建的，除了我找到的 Q 网络封装器。我们将使用 RMS prop 优化器。

学习率和其他参数在这里非常重要。这些是你需要调优的超参数。我们使用全局步骤，以便我们有一个计数器来记录训练进展。在这里我们创建 DQN 代理。DQN 在你拥有时表现良好。

动作空间或离散动作空间，其中有单独的值，而不是一些连续的数值范围。在下一部分，下一个视频中，我们将看到如何处理连续范围的动作空间。你使用与 DQN 神经网络非常接近的一个变种。我使用的评估方式与 TF 代理中获得的相同。这是一个我复制的函数，基本上它的作用是进行10步评估，并计算10步的平均奖励。

Atari 游戏是随机的。它们有随机数。同样的策略在连续两局游戏中不一定有效。但他们认为如果你玩超过10局游戏，那将会是一个合理的重放缓冲区。我们使用的几乎是与我在其他 Tensorflow T 代理示例中使用的相同类型的重放缓冲区。在 Atari 中，你不需要做任何特别疯狂的事情，我使用的正是我在几个示例中用过的随机集合代码。

到目前为止的示例，以及我从 TF 代理示例中获得的代码，对于这个非常有效。这正是我在之前示例中使用的训练代理代码。在这里真的没有什么需要改变的。它是相当基础的。进行一些初始设置，然后我们将循环遍历迭代次数，这就是每次迭代的步骤。

所以将这个设置为10。每次迭代，我们将收集10步，并利用这些数据训练神经网络，以构建我们随机采样的数据，这里你可以看到它正在努力训练，现在是负20，负21。

我觉得这其实是你可能做得最糟糕的，如果你在乒乓球上表现不好，什么都没击中，就像冲锋队员一样。你根本没能把球送过去，反而是对方把球直接打回给你。

所以当我学习并在这个过程中时，我非常沮丧，无论我尝试什么，我的得分总是像负21一样，一直往下。四个小时后，还是负21。但当我开始调整一些东西时，我能够使这个表现显著改善，你可以看到这是一次不错的训练。我对此相当满意，它得分超过了零，你可以做得比这好多了。

这是我这里的一个相当平均的运行，我会给你展示我的表现。它得分，表现比随机代理好得多，但如果你想花很多时间优化超参数和进行可视化，你可以肯定地进行更好的调整。你可以看到不错的向上进展，可能更多的迭代会对我有帮助，然后你可以看到这里的视频，我让它播放，它不错但不算优秀。哦，我得了一分。

得分2，我领先，尽管我落后。所以它表现得不错。我从未真正深入玩过乒乓球，所以我不知道我会特别做得怎么样，但整体上肯定是输的。不过如果你尝试随机代理，哦，它正在追上，这太棒了，我领先了吗？是的。

所以这是。它绝对有一些技巧。它确实从这个游戏中学到了一些东西，并且现在领先。所以我不想看我录制的整整三分钟。谁知道呢？也许它真的会变得更好。但让我们看看随机代理，你会发现我花了一些时间优化的强化学习确实让它有所不同。我是说，它被击倒了。它得了一分。我是说，坏钟也一天对两次，对吧。

所以这就是游戏，它并没有花费太多时间。那是一个很好的例子。比如，在游戏结束之前，它能玩多久。我是说，当我在80年代去游戏厅时，我的2美元能用多少个季度，我妈妈给我的。

通常大约5分钟，我从来不太擅长视频游戏。真的很喜欢蜈蚣。这可能是我最喜欢的，龙之层可能是最糟糕的。你必须花，我认为，整整一美元，但我会在一分钟内就被杀掉。

感谢观看我的视频，接下来我们将探讨如何通过财务模拟做同样的事情。如果你觉得这类内容有趣，请订阅我的频道。非常感谢。

T81-558 ｜ 深度神经网络应用-全案例实操系列(2021最新·完整版) - P66：L12.5- 非游戏TF-Agent的强化学习 - ShowMeAI - BV15f4y1w7b8

嗨，我是Jeffine，欢迎来到华盛顿大学的深度神经网络应用课程。所以强化学习，你见过的大多数演示可能让你玩某种Atari游戏，或者把山地车开上山，或者平衡一个杆子之类的有趣事情。

我没有看到很多实例来说明如何将这一点实际应用于不是Atari游戏或者某种物理模拟的东西。在这个视频中，我将向你展示如何使用TF agents将强化学习应用于你自己设计的问题。

现在，强化学习超出了正常分类和回归的范围。实际上，这是一种你不断对某种环境执行动作并获取反馈的过程。我将在本节中展示的例子是如何创建一种金融模拟。我们将关注净财富的积累和个人理财。

这实际上是一个相当简单的金融模拟。这并不是为了指导你在现实生活中如何进行任何形式的真实投资，但它展示了如何将一些不是视频游戏的东西放入可以被解决和处理的上下文中。强化学习，你可以设计一个代理，真正学会如何做到这一点，看看我所有关于Cale的视频。

对于神经网络和其他人工智能主题，请点击订阅按钮及旁边的铃铛，并选择全部以便接收每个新视频的通知。那么现在，让我们尝试将强化学习应用于一些不仅仅是在OpenAI gym或Atari游戏中的东西。

我将从零开始创建这个问题。现在这并不是我将要应用的最深奥的问题。这个演示的真正目的是向你展示如何创建自己的环境，并将深度强化学习应用于其中。我们还将查看连续动作空间，并了解如何处理一个或多个数值动作。

像是你想把油门踏板踩多深，比如在车里，或者刹车要用多大的力，因为你可以同时进行这两项。对于我将要整合的这个例子，它将是一个个人理财的金融示例。😊

让代理成为一个试图投资和为退休储蓄的人，这将是一个相当简化的例子，他们可以选择把钱放入一个像美国IRA这样的税延账户，或者选择一个应税账户，并且有一定的限制，你只能在那个税延账户中放入这么多钱。你也可以选择，你是想为你的房子付款，还是想提前还清抵押贷款。

所有这些事情都是一步一步的动作，实际上对强化学习非常有利。如果我只是想让计算机查看一份股票列表并给出最佳投资分配，那更像是传统的神经网络。因此，我们将完全创建一个自己的环境。这是在TF Agents中的一个面向对象的类，以下是规则：你必须确保完成这些事情，否则将无法使用你的新类。它必须是Jim环境的子类，然后你必须。

实现一个种子函数，使你的环境能够被设定。如果你给它一个常量种子，那么你应该得到恒定的结果。你需要实现一个重置函数，基本上是重新启动你的环境，这通常是强化学习算法执行的操作。

它总是回到起点并重置，从头开始。这并不是特别关键，但你需要实现一个渲染函数。这绘制了模拟的一个帧。现在我们在这里做的是财务模拟，我保持得相当简单。我们只是向一个窗口输出文本。类似的步骤是一个函数，它会带你经历每一步，你对该步骤应用一个动作，然后你会看到环境的变化，我们稍后会讨论环境是什么。

你还需要注册你的环境，我们也可以看到用于此的代码。这样TF Agents才能在你想要启动时找到你的环境。因此，这里是将要生成的模拟。现在这是一个非常简单的模拟。

这只是为了向你展示如何让自己的环境启动和运行。我曾想简单地创建一个迷你视频游戏或类似的东西，但我可能会把这个留到未来的示例中。不过，已经有足够多的例子来做到这一点。我想要一些我们在进行财务模拟的东西，做个人理财有点像老迈尔顿·布拉德利的《人生游戏》，而且不要与康威的《生命游戏》混淆，那是另外一回事。

所以你的起始薪资在4万到6万美元之间，你有一个开始时的房贷，所以你必须买房，我把它简化为是1.5到4倍的起始薪资，所以也许你非常保守，或者有点疯狂，这里是看这个人可能负担得起多少房子，他们需要根据在房地产购买上花费的疯狂程度调整策略。房贷始终是一个30年固定利率的摊还贷款，固定的月供。

如果你不按时付款，坏事就会开始发生。支付高于房屋月供的金额会更快地偿还贷款，低于月供的支付会导致错过付款。当你达到某个付款次数时，我记得我设置在15次左右，他们会收走你的房子。你不会失去价值，但他们会在拍卖中出售，你会损失。

我认为你的一半资产可以分配在奢侈消费之间，而在这个游戏中这对你没有任何帮助，房屋支付无论高于还是低于支付金额，以及一个应税和一个税收优惠的储蓄账户。如果你在奢侈品上花费更多或更快乐，并因此活得更久，因此你有更长的时间投资，我不知道。可能这是一个有趣的转折，我可能会将这个生命游戏再深入一点，并在课程之外做一个单独的视频，看看一个相当复杂的金融模拟。因此，状态由以下值组成。

这是程序在查看以确定它应该做什么。人的年龄（月数），薪水。现在薪水相对于通货膨胀缓慢增长，没有晋升机会或其他类似的东西。所以这是一个相当简单的模拟。房屋价值，这将相对于通货膨胀增加。这是所需的房屋支付。

这基本上会保持不变，唯一会改变的情况是当你还清房贷时，它会变为零。这是税收优惠的账户余额，这类似于美国的个人退休账户（IRA），然后是应税账户，这类似于标准的货币市场储蓄账户。

它确实给你一些收益，实际上比货币市场的收益要好。因此这假设你可能将其投资于一个独立的经纪账户，自我管理的经纪账户，至少在美国他们称之为这样。然后是行动。因此，行动是浮动的，因为我们在做一个连续的行动空间。不像之前。

代理在这四个中输入一个数字。然后我对它们进行归一化，使它们的总和为1，以便得到百分比。所以如果你在所有这些上输入11,111，它将归一化为每个25%。所以这只是让你选择希望将工资的百分比分配给房贷、税收优惠储蓄账户、正常应税储蓄账户和奢侈品。现在这并不保证你能将所有这些百分比投入，因为这里有各种事情发生。

你的工资确实需要缴税。所以这会减少你可能仍在分配用于房贷的工资总额。但你可能已经还清了房子。因此，你在这里投入的任何价值基本上都会被忽略。它只会变成0。你可能在把工资投入应税账户或储蓄账户之前就已经用完了工资。此外，你只能在税收优惠账户中投入有限的金额。

至少在美国，这对IRA来说是一个难题。每年你可以投入的金额是有限的。每年你可以投入到401(k)的金额也是有限的，所有这些都有各种影响，我也尽量把一些放进去。

我为税收优惠账户设定的限额类似于401(k)。所以这里是程序，或者说是类。这是一个面向对象的类。它继承自gym环境元数据，你必须为显示呈现它，我几乎遵循了gym中大多数类的做法，每秒一个视频帧，绝对不是高端视频游戏，按任何标准来说，它将以RGB形式显示。

我们的状态元素数量是7，前七个是这些，几个是我添加到输出中的计算值，仅用于调试目的。你会发现，当你创建一个复杂环境时，会花很多时间调试环境，而不是直接连接到TensorFlow代理。所以这里是这些位置。

因此，状态本质上是一个向量。向量中的第一个元素是年龄，接下来是工资，依此类推。这也是我放入的另一个常数，以便于归一化。我将所有美元金额归一化为百万，尽管工资远远小于这个，它仍然是百万的一小部分。

这有助于保持这些数字不会大于神经网络可能想要处理的数字。这些是我为通货膨胀、利率、税率设定的值。其中一些是归一化的，或者说是除以12，因为它们是月度值。这是支出。你没有选择，你必须支付支出，那是你的食物、衣物。

水、电、网络连接和所有关键费用。然后是你的薪资范围的低值和高值，起始年龄和退休年龄，或者说是你去世的年龄。这是构造函数，我设置了verbo模式，默认的fall设置将ver most模式设为true，这只是导致我的程序打印出一些日志信息，以便你可以帮助调试。我定义了动作空间。

动作空间在0和1之间。重要的是你要定义这个空间，以便强化学习算法能够理解这些范围，并可以分配随机数和其他内容。这就是观察空间。我在这里设置了低值和高值。它可能会超过200万，可能会限制在那儿，最好将其设置为4、10或类似的值，但无论如何，这就是范围。

我们继续进行种子和重置，我设置了日志为空，日志是我自己的东西，基本上就是给我提供一些信息，以便我可以稍后将其转换为pandas数据框，从而进行调试，确保模拟在按我想要的方式运行。这是我编写的一个方便的函数，它计算个人的净资产，查看房屋价值。

仍然欠在房屋上的本金，所以你从房屋的价值中减去你所欠的金额，这样就得到净资产的一个组成部分，然后我们也加上税收优惠账户和应税账户的价值。我在这里做得很简单，主要是在账户里节省税收，而不是在取出时。

不像美国的RothRA。这是我们评估动作的地方。所以记得我说过，这四个返回的动作值只是数字。我不能强迫它们都必须总和为1.0（100%）。所以我在这里要做的是应用一些这个，我会查看家庭支付，如果接近0，我将进行计算，这就是总额，他们在这些所有请求了一个数字。

我需要将这些数字转换为百分比。所以我将它们相加，然后将每个值除以这个总金额。现在我不想导致除以零的情况。如果总金额降到或接近0，我就将这些全部返回为0。

这算是一种错误情况，但在评估不良策略时确实会发生。所以我们必须迅速将这些全部设为0，否则我们就将它们全部除以，这就是我们如何将其标准化为总和为1.0，然后返回这四个值。这些是真实的百分比，在我们将这些较大的数字转换为百分比后，TF代理给出的结果。

这是步骤函数。基本上，它执行模拟，所以我们有了行动。我们将使用传入的行动值，并将其传递给我们刚才看到的评估行动函数。我们还会分开状态向量中的值，这样我就不需要不断查找哈希映射，这会很烦人，因此我们首先处理支出。那是你必须支付的某个百分比，像互联网连接这样的必需品。

至少对我来说是这样。不过，食物、水等这些东西。我们首先处理税收优惠存款账户。我们首先处理这个账户，因为你在一年内对存款金额有限制。如果你开始超出这个限额，那么你就会被减少，直到不能再存。这就像401计划。

有公司配对。我们计算个人欠缴的税款，扣除住房付款。因为我们使用了摊销，所以这有点复杂。因此，我放入了摊销公式，使得你基本上拥有持续减少的利息支付和持续增加的本金支付金额。如果你有逾期付款，你就麻烦了，我们会将其统计起来。

如果逾期付款超过15次，他们将会止赎你，止赎基本上是他们把你的房子卖掉。你将损失20000元的费用，这只是为了卖掉房子所造成的麻烦，因此你将损失相当可观的金额。你不希望这样发生。否则，如果只是正常的逾期付款，你将根据付款金额收取10%的滞纳金。

不要基于本金价值收取10%的滞纳金，否则那将是可怕的。然后我们更新房屋价值以反映付款情况。我们将存款放入应税账户，并确保计算投资回报。投资回报大致相似，我们会随机稍微调整一下。

就像我们随机调整通货膨胀金额一样，这在游戏中增加了一些随机性。这使得游戏更具挑战性，但强化学习在处理随机数字方面非常擅长。我们处理年度事件，因此每当我们到达第12个月时就会发生每月事件。没什么特别的。我们只是让代理人老去一年。是时候退休了。我的意思是，他们在80岁时退休。

我想我可能应该说这更像是他们去世时的情况，我让每个人在同样的时间点退出。 但同时这个人工作到80岁，所以这又是一个简化的模拟器，然后我们归一化并结束。 所以在这个状态中，我将每个状态值除以百万的倍数，这样就会得到更小的值，并且这使得神经网络处理起来更容易。通常你不想把大额百万美元的数字丢进神经网络，这样效果不好。我们进行年度计算时，基本上是在计算投资回报率或通货膨胀率，我们在其中添加一些随机性，给他们薪水增加，按照通货膨胀的规定增加房屋价值，等等。这个是重置的，重新开始，可以说我们将计数器重置为0，所有这些值重置为0，以便从头开始。

我们在这些范围之间生成随机薪水。 我们计算这个随机房屋的倍数，介于1.5和4之间。 我们计算抵押贷款金额，以便知道本金的数量，那个著名的摊销公式，然后我们把这些都设置到状态中。 渲染相当简单。 Rler使用Pillow，所以基本上是返回一张图像，将所有这些值以绿色字体在黑色背景上显示出来。

我们稍后会看看那是什么样子，并打印出来。 到那时，你就有了一个环境。 现在你需要注册你的环境，以便能看到它，我把这个称为简单的生命游戏，而不是康威的生命游戏，我有点想起老牌桌游《生命》。

好的，让我们测试环境，确保它能正常工作。 我实例化并创建它，就像这样，我做一个重置，这里我只是玩生命游戏，用固定的值。 所以在这里，我基本上是在偿还房屋贷款并投资到税收优势账户，这实际上是一个非常好的策略，我没有做到这一点。

模拟器没有复杂到足以让深度强化学习学习大量内容。 但光是这点就表现得相当不错。 你可以看到到最后它生成了约800万美元的净资产，所以这很好。 另外，请记住这不是通货膨胀调整后的数值，因此在80年后这可能就没那么好。 我稍微调整了一下超参数，以使其学习相对较好。

你确实可以在这里做更多的工作。 我改变的主要内容是我们进行50000次迭代，并且在每次迭代中进行50次收集步骤。 所以这实际上运行了多少集，以便每次都有足够的数据来处理。批量大小为64。我们每2500次记录一次，每5000次评估一次。

如果我们只想渲染环境以便看到它，这就是我们环境的样子。这看起来是这样的。稍后我们会观看视频，看到这个人老到80岁时的状态，以及他们在做什么。我们创建了两个环境，以便同时评估和训练它。

互相踩踏。现在我们不再使用DQN。之前我们使用了深度Q学习网络，深度QN的问题在于它只支持离散动作空间。所以想象一下一个操纵杆，控制上下左右。

不是你施加的压力有多大，我们有这四个账户，我希望能够给这四个退休账户提供不同的金额。因此，我们需要使用一种新的基于神经网络的强化学习类型，称为DtPg算法。

深度确定性策略梯度算法，我不会深入讲解这个算法的工作原理，如果你想阅读原始论文，可以在这里找到。我自己还没有实现过这些，但它们在连续动作空间的强化学习中效果很好。这就是它的结构，你的环境是。

让你恢复你的状态，即X。那个状态进入评论者和行动者。所以这里有两个神经网络在发挥作用。这有点像对抗生成网络，基本上有一个神经网络生成图像，第二个则是在判断那些图像是否真实。这是相似的。

你有两个对抗性神经网络，行动者和彼此的真正对抗者。实际上，行动者在这种情况下返回浮点数，这些就是你将得到的动作。

像之前的深度Q网络之所以无法处理连续值，是因为你需要一个漂亮的表格，在每个动作中都有一个潜在的值。我们现在做的是输入当前状态，行动者返回想要采取的动作步骤，以及评论者。

评估行动者在选择连续值时的表现。因此，你选择这四个连续值，而不是选择哪个账户。你选择的是这四个连续值。这些连续值如何最大化最终奖励，这基本上就是行动者-评论者强化神经网络的工作原理。时序差分误差也很重要。这是时间差分误差，它只是看行动者对未来奖励的估计与环境实际给予的未来奖励之间的差异。

这就是目标函数试图最小化的内容。这两个神经网络的超参数，我们创建这两个神经网络，然后我们先创建演员，然后创建评论员，再将这两者结合成DDPG代理，初始化它，我们基本上就准备好了。

我们将使用之前例子中使用的相同指标。在这里，我们取一定数量的回合，并查看这些回合的平均回报。我们进行初步数据收集，就像之前的例子一样。我们必须通过模拟器运行几次。

在这种情况下，进行一千次，并根据这些动作和实际奖励获取一些样本环境变化。这就是我们将开始训练神经网络的内容。而且，这段代码与我在之前强化学习示例中展示的相同。这一例子的主要点是如何创建你自己的环境。

现在我们将再次训练代理，这与之前的代码相同。顺便提一下，这段代码的变化非常小，以至于你实际上可以替换掉我的简单生命游戏，放入山地车连续环境，这是他们在健身房里的一个连续环境，它也能正常工作。它会训练连续山地车。

所以回到这里，我们在训练代理。它完成了所有请求的迭代。😊。收集请求的数据量，这是输出。如果你想逐行查看我的TensorFlow代理学习的以前例子，它会准确地告诉你这是如何工作的，但这只是一个循环，遍历并打印出结果，因为它在训练，这个过程最多达到50000步，结果的可视化看起来像这样。所以它学习得非常快，然后达到一个平台，这对它来说不是一个很难的优化问题。如果我们播放这些视频中的一个，你基本上会看到它在计数21122，并且你可以看到它学会了应用。

这个代理实际上很无聊，它只是在房子被没收后放弃，然后就去投资于税收优惠储蓄。它没有弄明白这一点的限制，可能应该把剩余部分放在应税账户里，随着你重新训练它。

它学习。

不同的方法，所以我运行了几次。有一些更智能的代理在训练，这个还可以。我是说它在增加净资产，但你可能会因为出售而降到零。我确实用租金或者其他方式击中了它，但无论如何，它在创造你的。

T81-558 ｜ 深度神经网络应用-全案例实操系列(2021最新·完整版) - P67：L13.1- Flask与深度学习Keras／TensorFlow Web服务搭建 - ShowMeAI - BV15f4y1w7b8

嗨，我是Jeff Heaton，欢迎来到华盛顿大学的深度神经网络应用课程。在这个视频中，我们将看到如何使用Python中的Flask，这将允许你将用Keras创建的Psyit学习模型或神经网络部署到你自己的Web服务器，甚至是云端，获取我AI课程和项目的最新信息。

点击旁边的铃铛订阅，以便在每个新视频发布时收到通知。现在，Flask是那些在Jupyter Notebook中工作得不是特别好的东西，也不太适合Google Colab，因为Google Colab是基于Jupyter Notebook的。通常，你会通过命令提示符或类似的方式运行这些Flask应用。

这就是我们要做的案例。我将向你展示Flask的一个应用，我们实际上会在浏览器中运行它，但Flask的设计是为了接收浏览器的请求，而不是从浏览器中运行。所以Flask是一个Web服务器。基本上，它让你将Python应用程序转化为Web服务应用程序。在这个案例中，我们将创建一个API端点。所以应用程序编程接口API，我们将接收来自其他位置的请求。

这些可以是其他程序，也可以是网站本身。不论如何，你将获得一个HTTP请求。😊。

HTTP请求将会进来，你将用神经网络来处理它，并返回结果。现在，这展示了如何在Flask中做到这一点。Flask是一个开发平台，这意味着它并不真正适合生产环境。尽管如此，很多人确实在生产中使用Flask，但这并不是它的初衷。还有一个叫gunicorn的东西。

这是更适合生产环境的版本。所以如果你真的打算以某种方式部署它，我建议使用gunicorn，因为它能够很好地处理多个并发请求。所以如果你需要同时运行两个神经网络，因为你有两个不同客户的请求进来，你就不想等一个结束后再处理另一个，这样会因为Python固有的全局解释器锁而导致延迟。

如果你想阅读关于Flask快速入门的内容，我这里有一个链接。虽然这个并不是针对神经网络的。这是我们的第一个Flask应用。我将从Jupyter中运行它。这通常不是一个好主意，但它是一个很好的例子。如果我是一些疯狂的互联网频道，我可能会让事情失控。

我会说不要在家里尝试这个。但这样做你不会失去手指。我保证你创建一个新的 Flask 实例。这很重要。这意味着它将服务于 URL 的根。它将从本地主机运行。因此，如果你在生产环境中运行这个。

你可能有 W Wheton research co 或者你的名字。不管怎样，它应该在 80 而不是 9000 上运行。尽管通常你会将这些部署为 Docker 镜像。因此，通常你会在 9000 上继续，然后在运行时将其映射到你想要的实际端口。它将在这里运行。那么我们就运行它吧。现在注意小星星正在转动。

我可能应该等它完成。好吧，这会是个漫长的等待。它正坐在那里等待我们的连接。因此，这就是它不适合 Jupyter 笔记本的原因之一。我不能执行全部运行，只运行这里的所有单元，因为它会卡住并停在那里。

当你完成它后，只需点击框并停止。但我们继续看看实际运行的网络服务器。这里实际上是从这个标签发送了一个 HP 请求到那个标签，并得到了返回的结果。现在我们将看看如何将其实际部署到云端。

我真的可以将其作为可扩展的网络服务访问。但现在它仅在我的本地实例上运行。你可以看到日志正在进入。它只是说一个获取请求来了。除非你放了一个，我通常会在这里放一个收藏图标，以便浏览器不再烦我。但对于一个网络服务来说，这其实并不是必需的，因为在这一部分。

我们不会看到任何 Gi。稍后我们将创建一个网络应用程序，并反应来实际访问这个。但现在，这只是 API 端点。我们继续停止这个。现在我们将运行之前创建的每加仑多少英里的神经网络。我们将训练一个，将其保存到二进制文件 H5 文件中，然后加载它，我们将创建一个期望输入这样的 Flask 应用程序。

你提供气缸数量、排量和马力。它将预测那辆车的每加仑多少英里。现在，我将展示如何通过几种不同的方式访问这个网络服务。我们将看到如何在纯 Python 中访问它。

我们将看看如何从一个非常强大的工具 Postman 中访问它。让我直接复制并粘贴它，然后发送到网络服务。首先，让我们看看这个网络服务实际上是什么样子。现在，这是训练。通常你不会在网络服务中训练神经网络。永远不要说永远。

这是会有应用的，但通常你会在某个地方训练神经网络。然后将训练好的神经网络保存为H5文件或稍后协议缓冲区。我们也会看到这一点，实际上将其部署到云端或其他地方。这里你可以在Jupyter notebook中进行训练，没问题。这就像我们之前看到的。我实际上有autompg文件。

我们将加载它。我们将训练它。我们将训练它。我们处理马力中的缺失值。这一切只是训练。所以让我们继续训练。现在，如果你忘记停止上面的网络服务器。那将是一个无尽的星星，它训练完就结束了。所以我们现在基本上需要保存它。

这在这里完成。好吧，让我们做一个合理性检查，确保均方根误差在我们预期范围内，而我看到的并不好。3大约是你通常在这个上面得到的，但我不在乎，目标实际上是测试部署。

所以我们要把它保存到一个H5文件，放在我有的DNA文件夹里。那里保存了所有临时神经网络。不保存到tub里，所以你在那里不会看到任何东西。但这就是你放置所有神经网络的地方，至少在我的课程中是这样。

所以文件在那里。这也相当方便。所以我们将发帖并回到这里。我们将把这个发送到网络应用程序。那么，如果他们在这里放入一些不是数据集一部分的东西，比如车的颜色，那又怎样呢？车的颜色和每加仑多少英里无关，或者他们忘记告诉你一些非常重要的事情，比如重量。这些都是错误。还有如果重量超出这个范围会发生什么呢？

如果你给它一辆重50000的车，但它表现不佳怎么办？所以我们在这里进行数据的快速分析。让我运行一下。你看看它会产生什么。看看这个。这是一个不错的Python，还有这些字段的Json Matt。所以我们知道我们需要每一个字段。

这些是训练数据中的最小值和最大值。你不想超出训练数据集的大小。神经网络对此不太好。所以如果你给它一个气缸，它会变得全多项式化。你知道多项式在超出范围时是什么样子。它们很快就会变成正无穷和负无穷，取决于多项式。

神经网络做的事情很相似。所以你需要在神经网络的范围之外小心。这，我也用来测试它。所以让我们继续运行这个看看结果。所以这是我们将要测试的车。这就是我们的输出结果。我们希望能够通过网络应用程序得到相同的值。

我们将从命令提示符启动Web应用程序。但这就是它的样子。所以在这里是😊，预期的值。这是我们在源代码中生成的小地图。请注意，这里是路线。我们不把这个放在根目录。稍后，当我们创建一个完整的Web应用程序而不仅仅是API端点时。

我们将有几个这样的端点。一些将是Gi，一些将是后端API。这是计算每加仑多少英里。所以我们现在需要处理Json。Json本质上是JavaScript对象表示法。Python真正酷的地方在于它几乎使用与Json相同的语法。这基本上就是上面的Json。处理Json时唯一需要注意的是。

你不能在这里放单引号，Json要求使用双引号。因此，你可以在Python中创建地图和列表，本质上是JavaScript对象表示法，但这不是有效的Json。如果你使用单引号，我们加载模型。切勿在这里训练你的模型。这可能会花费太长时间。我的意思是，你不想在每次Web应用程序启动时重新训练模型。首先，神经网络是随机的。

每次你可能会得到不同的结果。这让你的客户困惑。为什么我每次得到的每加仑多少英里都不一样？哦，是的，我们一定是重启了服务器。不，不要这样做。相信我，我曾在寿险行业工作。我们的客户对此答案不会满意。现在。

当我们在API每加仑的请求中收到请求时，我通常把所有端点放在API下，并且我们只接受POST。我从中获取这个Json。我会保持一个错误列表，希望它能保持为空。但是现在我将逐个检查我在这里构建的预期地图，确保没有超出范围。

我还会寻找意外字段错误，如果缺少一个，我也会追踪这个。相信我。在你作为数据科学家或AI工程师部署这些应用程序时，尤其是在全球公司工作时，你会收到24小时的请求。你将会有IT专业人员，他们对数据科学或机器学习的了解不如你，接收请求。

如果你的程序因为某些客户发送的坏数字而崩溃，他们会打电话给你或打电话给你团队中的其他人。良好的错误信息是对抗深夜呼叫和手机电话的最佳解药。相信我，我在职业生涯中接到过许多这样的电话。

如果处理当晚生产支持的人在第30行看到越界的Ray，Python就会崩溃。他们会打电话给你，如果这是那些不喜欢Python、认为JS主宰世界的人，他们会特别尖刻。所以你会接到电话，你必须去调试它。

另一方面，如果你的程序产生了这个好的错误，提示说未定义字段，b bla blah，他们可以查看传入的Json消息，并进行处理。24小时错误支持的人可以处理这些，相信我，这通常是个好事，他们的时区通常和客户的时区匹配。因此，除非你希望错误传播看起来不专业，否则要尽量避免Python的硬错误，所以你要始终进行检查，这是一种良好的生产实践。

我检查我有多少个错误，如果有错误，我将把它们作为另一个Json消息返回。因此，你总是想在这里放一个ID。我只是放了一个网格。我们稍后看看那是什么样子，但每个事务都需要有一个全局唯一的ID，至少我认为这是个好主意。在这里，我们所做的就是创建一个非常简单的nuy数组，1行7列，这里有七个输入。

这实际上是，代替拥有一个CSV文件，我们是在动态创建这个，并输入所有这些值。所以这是第0行，因为只有一行，所有这些列。我知道这是我训练它们的顺序，这对应于我们在Jupyter笔记本中运行的最后一个示例。我填写所有这些值，调用模型预测，提取每加仑多少英里，并形成我的响应。

这将是I，注意这几乎是json。这是Python对象表示法，非常类似于JavaScript对象表示法。这一切都会被接收，你将把结果发送回用户，或者将其发送到其他机器。现在用户不会看到这个。

这可能会立即被放到一个网页应用程序中。这本质上就是软件即服务。因此现在让我们启动它，并尝试调用它。现在。这是我的Jupyter笔记本终端。我们让它保持运行。我再打开一个，并让它变大。我们有足够的屏幕空间。

所有的Python脚本都在我班级的一个名为Py的目录中。我们将运行MPG服务器。这些其他服务器会随着课程的进展而运行。现在这已经在运行了。你可能会遇到一些像这样的防火墙错误。Windows也会有类似的情况。我在使用Mac。😊 所以这个已经启动并运行。那么让我们用Postman来测试一下。现在。

Postman是一个很棒的小工具。我给你一个截图，基本上显示了你要发送的内容。因此，让我们将其更改为API MPG。你可以按照我在笔记本中的截图正确设置这个。我将移到这里的主体部分。现在我之前将其设置为图像。所以让我们将其设置为原始数据。更改为Json。我们回到这里。

这是我们想要发送的内容。这字面上就是跨网络传输的内容。我们输入这些然后点击发送，注意这个特定汽车的每加仑英里数是23。我们可以把它变成四缸车，看看会有什么变化。它会改变。我们可以做一些不好的事情，比如完全去掉重量。

然后你会得到其中一个错误。缺少值重量。总是给出描述性错误。不要给出微软式的错误，只是一串数字。好吧，现在。神经网络都是关于图像的。所以我必须向你展示如何将其中之一作为图像处理。让我们回到笔记本。我还会向你展示如何仅从Python完成其中之一。

所以我们将使用请求对象，让我们能够进行HP。注意，这就像我在Postman中所做的一样。所以现在我们将程序化地在Postman之外进行操作。现在我可以做无尽的事情。我可以教你如何用PHP做这个。我可以教你如何用Json做各种不同语言的操作。前提是我知道这种语言。

但让我们先运行它，你会看到结果返回是每加仑23英里。就像之前一样。那是我之前告诉你的唯一标识符。那么现在让我们将其作为图像处理。图像稍微复杂一点，但也没多少。所有内容都是相似的。我们将使用图像服务器。我们将字面上通过HTTP发布图像。

这样我们就在网站上接收它。所以在网站上。我确实在这里放入这一部分，这些是它接受的唯一有效格式。其实，我可能还可以把它缩小。我是说，真的，PG、Jpeg和J的格式。现在还有人用gs吗？我把图像的高度放了进去。

现在我们在Jupyter Notebook中训练这个神经网络。这是mobilenet。所以我们使用mobilenet。这是一个我们之前讨论过的预训练神经网络。它是一个非常常见的，只需在谷歌上搜索mobilenet，了解更多信息。它能够识别10种不同的图像。我在这里所做的基本上是启动mobilenet。

我实际上并没有加载一个已保存的神经网络。这实际上是在Kis内部，所以我们不需要训练这个网络。这是迁移学习。它已经为我们准备好了。路由将是API图像。我们将检查确保实际发布了图像。如果没有，我们就会出现错误。这是一个多部分上传。因此，如果你曾经做过HTTP编程。

网页编程时，每当你上传一个文件到一个网络应用程序，这就被称为多部分。这就是它所做的方法。我们使用完全相同的方式。我们确保它是被接受的文件格式之一。这是我们确保名称与我们认为的安全名称匹配的方式。你可以看到一些被注释掉的内容，如果你记录条目，那只是我调试时的情况。这部分相当重要。

这就是我如何将多部分上传桥接到神经网络实际上可以处理的 nuy 缓冲区。 然后我们将其调整为适当的大小，进行抗锯齿剪裁。 这还假设这些图像没有 alpha 通道。 如果你上传一个 alpha 通道，它将出现问题。

我稍后会告诉你如何处理这个问题。 我们会进行预处理，然后进行预测并解码预测结果。 我们将获取第一个项目，第一个名称，并返回一个包含所有预期概率的 Json。

在 Json 中，你会看到消息，稍后会显示，然后我们返回响应。 所以让我们让这个家伙开始运行。 我将退出 MPG 服务器，并运行图像服务器。 和 MPG 服务器一样的操作。 始终对防火墙说是。 除非是病毒在询问你，然后就说不。

问题是很难知道的。所以我们继续。 我将其更改为 API 图像。 我们将使用表单数据。 从我测试时就已经在这里了。 基本上，我使用的是你在 JP 的课堂页面中看到的我的狗的照片，它在图像目录中，我将继续运行这个，确保将其指定为进行多部分上传的文件，我们会点击发送，之前我展示过的预览，它认为他是一只拳击犬。

他是一只英国斗牛犬。 这不是我的神经网络，而是 Mobilenet 的创造者的错。 虽然拳击犬是斗牛犬，但他并不是这些犬种中的任何一种，他绝对不是法国斗牛犬。 他非常反感被误认为是较小的法国斗牛犬。 他是一只纯种的英国斗牛犬，没错，他绝对不是巨型的牛头犬。 所以基本上你就是这样做的。 你也可以用 Python 或任何编程语言发送这个图像请求，正如我所说的，这是相对简单的。

要做到这一点，你将把它发布到图像。这是关键部分，这就是你如何通过 Python 推送一个 JpeEg 并发送它，它被命名为图像，这是关键，因为这是我程序在接收端所期望的标签。所以让我们继续运行这个，类似的操作。因此，这就是你对 API 的介绍，我们将看看如何将这些 API 连接到其他事物，以及如何将它们放入云中以实现高可扩展性。 这个内容经常变化，所以请订阅频道，以保持对本课程和其他人工智能主题的最新了解。

T81-558 ｜ 深度神经网络应用-全案例实操系列(2021最新·完整版) - P68：L13.2- 在Python TensorFlow Keras中恢复训练和检查点 - ShowMeAI - BV15f4y1w7b8

嗨，我是杰夫·希顿，欢迎来到华盛顿大学的深度神经网络应用。在这个演示中，我将向你展示如何在Kis中进行检查点和继续模型。

🎼所以，我要做的第一件事是为这个课程笔记准备，这只是在我的Github仓库中。我在描述中有一个链接，你可以直接访问它。我将点击打开和collab。现在，当你训练大型复杂模型时，你通常会想要停止并重新开始训练，因为它们可能会持续几天。你不可避免地会被打断，不一定是故意的，但你需要一种继续的方式，这就是我将在本演示中展示的。继续放大一下，现在我们在collab中运行，我会将其复制到我的G驱动器，尽管我并不打算真正使用G驱动器上的实际文件。我会确保运行时类型是GPU，确实如此，即使你会看到我在运行coEpro，我会运行这个介绍性代码，它只是让你入门，这也定义了一个小函数，告诉你某事经过的时间以人类可读的形式。这个代码我。

这里是我在运行更大复杂项目时使用的代码，实际上这个代码基于NviDdia的styleganN2 ADA，他们有一些很好的代码来创建标签逐步递增的输出目录，并且还将标准输出捕获到日志文件中。因此，如果你使用过style GAN2，你之前可能见过一些这个代码，基本上它的工作方式是有这个logger函数，实际上是一个logger类。

这用于包装你的代码，以便任何输出到标准输出的内容也会记录到日志文件中。因此，这是一种方便的低级日志记录方式。如果你想要更高的生产级别，你可能会想使用Python的log或其他可用的库。但我会运行这个以便定义。好的，我们进入下一部分。

这里是我将存储检查点文件的地方。所以我在Kis上放置了一个回调，它将在每个周期结束时等待一定的步骤，实际上，它将保存你的神经网络的完整副本以及训练状态，以便你可以恢复训练，因为如果你不捕获训练状态以及神经网络，那么你的训练恢复将是低效的，想象一下你在大学学期中间，而生活发生了一些事情，你不得不退学，但你会回来，回来时你是想从深造课程的开始开始，还是想从你停止的地方开始，这就像你的训练目标，你的训练目标就像大学，你不想重复那些学期，因为这对你没有任何好处，你的脑海中仍然有所有的知识，就像神经网络一样，所以这就是为什么你想保存训练状态的原因，这就像你在大学的成绩单。

还有神经网络，这是它所学习的智慧，就像成绩单一样。你只会捕获那些课程到学期。因此，学期就像周期，在每个周期结束时，它将保存训练状态和神经网络的状态，你将失去在周期中间发生的任何事情，直到下一个周期。

这有点不同，但基本上就是这样。我将运行这段代码，它将存储在这个数据目录中，这只是一个位置。在我的coabab实例上，重启后它就会消失，但这只是一个示例。你可能会将其移动到其他地方，这只是批量大小。

我们进行的是分类，正在做经典的手写数字分类，因此我们教它对这些手写数字进行分类，有10个数字，所以有10个类别，结果将被保存，这就是我运行的实验的名称001测试训练，这只是一个不断增加的数字，用于将它们区分开，这样你可以快速回到以前的运行，由于我们将训练状态保存在JSON文件中，你将能够查看这些个别运行，这在研究类型的项目中非常有用，因此我们将定义这个名为my model checkpoint的类，这将作为你的检查点，在每个周期结束时调用它，并将存储你的神经网络和训练参数。

我们希望在每个epoC结束时调用这个，我们首先要调用我们所基于的前一个类。那就是模型检查点，由Kiris提供，所以你要确保内置的内容仍然被调用，这实际上保存了你的模型状态。我们要做的额外工作是保存优化器状态，所以我会获取文件路径，以便我知道存储模型的HD5名称，它是以二进制格式存储的，但我希望训练状态与模型同名，只是扩展名不同，将是PKL文件，因为我们要将其序列化，我会打开pickle文件，本质上向pickle文件写入一个字典。

这里面包含了所有信息，所以优化器基本上是我将调用模型正在使用的任何优化器，像是atom或其他形式的梯度提升算法，这就是它的优化方式，随机梯度下降也是另一种可能性。我们必须保存我们所处的epoch，因为我们也将进行学习率衰减，因此随着训练，学习率逐渐下降。你不希望在重新启动训练时改变这个，并且这是存储为pickle文件的。让我们继续运行，这样它就被定义了。这是衰减调度器，这是一个相当标准的衰减调度器，因此这是你的初始学习率1乘以10的负三次方，我们以75%的比例衰减，步长为10，它将逐渐衰减这个速率。

向下呈指数级，我们会继续运行，这样它就被定义了。这是构建模型的代码，这与你在本课程中之前看到的非常相似。这只是一个卷积神经网络。模型格式对这个例子并不重要。我们主要关心的是如何继续训练。

现在我们也要调用这个训练模型。这有点复杂，因为我们可能会恢复训练。我们将传入模型。第一次启动时的初始epoch将始终为零，因为你应该从零开始。然后Max Epos将是你希望训练的程度。所以当你第一次训练时。

我们将训练三个epoch。但你也可以随时中断。计算机可能会断电。狗可能会绊倒你的电源线。任何可能导致你失败的情况。你还可以在AWS上购买现货实例，这比正常的云实例便宜得多。但诀窍是，当有更高支付的客户出现时，亚马逊可以中断你。

所以在生产类型的情况下，这个检查点是非常重要的。所以我们创建检查点。它会有这个名称，因此模型纪元会嵌入其中，还有我们的损失，以便我们跟踪每个的有效性，我们将创建一个学习率计划。

这就是我们的两个回调，检查点和调度程序。我们将像对待其他训练操作那样调用 fit。在最后，我们将对其进行评估并打印出结果。我们还将跟踪这花了多少时间并打印出来，所以让我们运行这些东西，以便它可用。这是我们将实际运行的地方，所以我将继续启动它，因为这需要一点时间，不过不久。

我们将训练三次纪元，这并不算很多。我只是想在这里进行一次初步训练。我可以以某种方式强制中断，但这样做没问题，它在继续，你可以看到我们处于三次纪元中的第一纪元。这对于我们之前的内容来说都是标准操作，只是你现在会看到它在说将模型保存到这里，并且它还在说正在保存优化器。

如果我能拼写优化器，那对 pickle 文件和这两个文件会很好。你会想要这些文件名，并确保你正在运行 GPU 加速，否则这个训练过程会花费相当长的时间。它已经完成了，所以你有这两个文件名，你会想要这些，你会复制它们，这就是你拥有的两个文件。我不知道为什么它会智能地超链接它们，点击时会出现404错误，但如果我们列出目录，你将看到基本上这是它创建的目录。如果我们实际查看那个目录，你会看到所有文件，包括 log Txt 文件，它和你上面的控制台是一样的，这样你就有了记录，还有这些各种检查点，最后三个检查点中，第三个纪元的最后两个是你想要继续的，而顺便提一下，那就是 getconfig。

我们调用正在保存的优化器，这样我们就能继续使用优化器。你基本上可以看到它打印出的内容。现在让我们继续训练。这些名称可能与我之前的不同，所以我复制了它们，让我上去复制最后两个名称，我只是复制粘贴，这样就减少了我犯一些愚蠢错误的可能性。

我将删除这一点，我们将继续定义这两个，现在我们要运行这段代码。你会注意到我有加载模型数据，这正在加载这两个路径。你将这两个路径传递给它，它用一个非常简单的加载模型命令加载模型，然后打开pickle文件并提取其中的周期数量和训练选项。如果你要做更复杂的事情，需要存储的不仅仅是学习率，你会想要在此基础上进行添加。

我所使用的学习率完全由周期驱动。所以只要周期被保存，就可以继续进行。注意我们是如何编译它的，这有点不同。我正在从Aom创建一个新的优化器，因此我可能正在更改在调用构建模型时存在的优化器。

这构建了一个空的未训练模型。所以我在更换优化器，并从我们保存的那些选项中读取其配置。这将产生一些影响，我们稍后会看到。主要是我将不得不重新编译它。所以如果我运行这段代码，确保它正在进行，因为我想这是最后一步。你会注意到，我在这里调用它，训练模型。

我传入的初始周期是我加载的那个，最大周期是6。所以我们保存了一些更多的内容。再说一次，我在这里的编译步骤，是用新的优化器重新编译模型，这可能不是必要的，具体取决于你所使用的优化器，但编译模型并不会删除你的权重。

实际上是定义优化器并构建将要执行的整个图。你可以看到这已经完成。所以注意关键点，周期从四开始，结束于六。注意准确度，开始时是98，所以这是启动时的准确度，而之前的是94%准确度，因此不需要从头开始，你可以看到它实际上是从这里继续的。这就是你如何继续训练，或者也许你决定将神经网络送回进行额外的训练，这就是你该怎么做。谢谢观看这个视频，如果你对人工智能以及这个课程的更多内容感兴趣，请订阅频道。

感谢观看。

T81-558 ｜ 深度神经网络应用-全案例实操系列(2021最新·完整版) - P69：L13.3- 在Web应用程序中使用Keras深度神经网络 - ShowMeAI - BV15f4y1w7b8

嗨，我是Jeff Eaton。欢迎来到华盛顿大学的深度神经网络应用课程。在这段视频中，我们将看到如何将你的神经网络或学习模型部署到网页应用程序中。有关我AI课程和项目的最新信息。

点击旁边的铃铛订阅，以便收到每个新视频的通知。所以现在我们将看到如何实际制作一个网页应用程序。在之前的部分，我们看到如何创建一个flask网络服务，使我们能够将神经网络暴露为API。这是创建一个真正允许你与模型互动的网页应用程序的第一步。

你基本上要创建一个网页应用程序，并从用户表单获取数据，这个请求是一个API。将其发送到我们刚刚创建的同一个flask容器中，然后再呈现给用户。最终的应用程序在这里作为该课程笔记本的截图展示。见。😊。

确切地说，我们将如何运行它，并尝试使用一张图片。我们要做的就是使用一种叫做react JS的东西，react本质上是一个前端框架，允许你表示图形用户界面元素。多年来出现了很多这样的框架，比如JQury和Ar的多个迭代，还有一些更新的框架叫做view等。这是我使用的一个，看起来相当不错。

这是试图让你稍微脱离很多之前基于文档对象模型构建的内容，比如JQury。我不会深入讨论这个，因为那是更多的网页开发，而我绝对不是专家，但我做了足够的网页开发，让我的人工智能作品能够通过网站展示。我会给你一个博客文章的链接，我还借用了一个非AI示例和react的部分结构，但实际上只是为了上传一张图片，然后进行处理。

进一步进行图像识别。现在，你会注意到这个网页应用程序在笔记本中的内容并不多。这是因为你不会从笔记本运行它。所以你不能从coabab或你的笔记本运行，我们马上会去终端实际运行它。

但让我向你展示这里包含的主要文件。首先，我们将查看网络服务器本身。这是一个Python文件，实际上是在flask中运行的。这就是实际驱动它的部分。这是我们为了最初包装图像分类神经网络mobilenet而创建的flask API的确切副本，增加了一些功能。因此，我们在这里做的基本上与之前一样。

但我会进行回顾，以防你在这个时候跳入。我们现在将要做的是新的。我们将暴露 Www 目录。因此，这变得非常像 Web 服务器。我们将放置我们的 CSS 文件和任何图形文件，或者只是其他我们需要的静态文件，如 HTML。这个 Web 应用程序中的一切都是静态的，因为唯一动态的部分确实是 API，所以 React 基本上构建了我们看到的 JSON 请求并发送过来，以便我们可以对这个图像进行分类。

其他一切都是一样的，你可以使用早期版本中的确切相同的 API，并让它同时为试图访问的外部应用程序提供服务，以及我们在这里创建的 Web 应用程序。因此，这种开发的真正优势在于它被称为 API 优先。因此，基本上你设计你的 API，然后在其上做一个静态层，我们本质上是在呈现数据并获取结果。

在开发中，通常你会从表单直接发布某个请求，这个请求会发送到一个 CG 或其他能够处理它并为你重新渲染整个页面的东西。新的风格很大程度上是，你有前端代码，前端 JavaScript 收集这些数据并发送到外部应用程序所使用的同样类型的 API，我们在映射其他内容，以便我们能够获取默认值。

在 index HTML 和我们设置的其他内容中。我们将实际查询神经网络，我们会显示错误信息，比如如果你没有发送图像，那将会是一个错误，我们从发送给我们的数据包中提取图像，并尝试对其进行分类。我们获取文件名，确保你上传的是一个安全的文件名，以及我们预期的文件类型，然后我们将基本上。

现在打开图像。重要的是我们实际上并没有在任何地方保存图像。我们实际上是直接从 HTTP 流式传输到神经网络。因此，我们并不是创建临时文件或任何东西。我们将扩展维度，使其处于卷积神经网络所期望的形状，然后这里的代码非常有用。

我没有把这个放在之前的版本中，我可能会在某个时刻复制它，所以你可能会在之前的版本中看到。这基本上只是截断 alpha 通道，所以如果你处理的是一个有透明度的图像，并且它有一个 alpha 通道，这可能会让卷积神经网络感到困惑，因为这是第四个通道，因此这只是确保没有实际的透明度或 alpha 通道被上传给你。同时我们请求实际的预测并解码这些预测，解码后的预测让我们知道它实际上是什么，比如一辆车或一艘船。

我们将获得前五名的百分比。然后我们将这些信息发送出去。前端可能只会显示第一名或第二名之类的内容，但我们将所有五个发送过去，让前端决定该做什么。我们将这些基本上形成一个 JSON 包，并发送过去，与之前部分处理的 JSON 包相同。

所以这一切与我们看到的完全一样。这就是如何围绕神经网络构建 API。现在，让我们看看如何实际将其接口化为 Web 应用程序。所以你有样式和脚本 Js。我不会详细解释样式和 index.html，这些实际上非常简约。因为 Re 完全构建了一切。

这实际上只有 HTML 中的标题。其他一切将动态构建。所以让我们看看脚本文件，因为这将实际处理构建请求、将其发送到 API 并处理 GUI 元素。这都是客户端 JavaScript，因此在用户的浏览器中运行，以向你展示这里的一些情况。

这实际上分为三个部分。构造函数是这一部分，它基本上保持了在 React Js 程序中需要存储的状态。现在 React Js 处理状态，以便在需要时能够重新绘制整个页面，而状态本质上决定了它处于什么状态。现在我们需要知道上传了哪个文件和图像，以及我们在该图像上生成的任何消息，因为我们希望在图像下方放置一条消息。

当你点击按钮实际上传图像时，会发生这种情况。我们基本上让该事件上的默认行为发生，现在我们实际上获取要发送的图像数据，我们将直接将用户上传的图像发送到 API，然后再直接发送到神经网络。

一切都是流式的，因此我们不需要创建中间临时文件或任何麻烦的东西。我们将构建要发送的 HTTP 请求，并且基本上只将图像直接发送过去。

这非常简单。我的意思是，我们只是字面上将图像放到 API 端点上。我们在这里有这个图像是很重要的，因为这是图像实际嵌入的 HTML 表单元素，如果你调用这个图像。

然后我们不会找到它，因此你可以同时上传多个图像，如果需要发送几个过来。一旦我们发送这个，我们基本上就分配了一个回调函数。JavaScript 是非常响应式的，这意味着你不会阻塞，实际上不能阻塞并等待某个操作完成。因此，我们会将这个函数附加上去，它会等待该请求完成，然后我们立即退出。当我们从加载中获取结果时，我们检查状态是否正确，如果状态不好，那么我们可以拒绝这个 Promise，换句话说，拒绝回调，并表示我们没有获得良好的结果，我们将返回 HTTP 状态文本并记录它，这样我们就知道我们得到了什么，我们将获得概率，我会对概率进行四舍五入，以避免有恼人的尾随小数位，然后我们基本上构建出现在拥有的消息。

在 React 中，有一点是我们并不是仅仅在修改某个屏幕上的 DOM 元素。我们实际上是在改变状态，以便下次渲染时，这些元素会被重新渲染。通常你可能会使用 JSX，这样就会有非标准的 JavaScript，因为这里没有关于 React 的教程，所以我省略了这部分，基本上只用了标准的 JavaScript 代码，但如果使用 JSX，所有内容看起来会非常像 HTML。基本上，我在做的就是重新渲染这些元素，而无论消息如何返回，这里是关键点：我们将重新渲染用户上传的图像下方的消息，顺便提一下，当用户实际上传图像时，是通过这个处理图像变化的函数完成的，那是我们实际给出用户选择图像的预览。

你已经拥有这一切，你可以发送请求并从包含你的神经网络的 API 中获取结果。所有这一切的关键就在于实际调用 HTTP 请求并获取结果。你基本上在处理两种编程语言：前端使用 JavaScript，后端使用 Python。现在我们来运行一下，以便看看它的样子。你看到的就是我之前的笔记本，我们实际上不需要这个笔记本，所以这个会在我身后失败。我会进入我提供的 Python 目录，你可以看到图像 web 服务器 1。现在我们去运行它，运行需要一点时间来启动，确保你的防火墙允许它通过。现在你可以看到我们正在 HTTP 上运行，端口是 5000，所以我们继续执行这个，从网页上访问，这是我们的。

网页应用程序，所有这些 GUI 元素都是来自我之前讲解的那些 React 元素。我不会给你一个 React Js 教程，教你如何实际构建这样的东西，但里面的代码非常简单，所以如果你想了解更多关于网页开发的内容，可以阅读我提供的一些链接。外面已经有很多频道和其他资源了。

我绝对不会深入探讨网页开发，我们将会去看我班级网站上的照片。现在我将使用一台笔记本电脑，我们不会像 Yolo 那样处理多个图像，因此这里的多个图像中，至少会有一个占主导地位。这里是我和一只狗在笔记本电脑前，这对 Yolo 来说是很棒的，但它更喜欢这台笔记本电脑，而不是我，狗也没法责怪它，但笔记本电脑占45%。

这个内容经常更改，所以请订阅频道，以便及时了解该课程和其他人工智能主题的更新。

T81-558 ｜ 深度神经网络应用-全案例实操系列(2021最新·完整版) - P7：[讲座] 在 Mac OSX M1 中安装 TensorFlow 2.5、Keras 和 Python 3.9 - ShowMeAI - BV15f4y1w7b8

嗨，我是 Jeff Heaton，欢迎来到华盛顿大学的深度神经网络应用。在这个视频中，我将向你展示如何设置一台 Mac，特别是一台较新的 Mac，M1 系列，搭载苹果的硅芯片，而不是 Intel。使用 Keras 的 TensorFlow。

深度学习课程所需的一切。

🎼如果你有一台 Windows 计算机或一台较老的 Intel Mac，我有其他视频链接在描述中，建议你查看其中一个，过程有几个步骤，其实并没有那么复杂。我想解释一下你在此过程中会遇到的 miniforge 和 Minneconda 版本之间的一些区别。此外，如果你不想在计算机上安装实际软件，你可以通过 Google Coab 完成整个课程。如果你看过我其他一些视频，你会知道我使用 Minneconda 和 Anaconda 的频率相当高，这两者都是由同一组开发的 Python 平台。

你可以在几乎任何平台上使用它，无论是 Windows、Mac 还是 Linux。在这个视频中，我将向你展示如何使用 miniforge，miniforge 对我来说是一个新事物，它也支持多种平台，但我主要是在 Apple M1 上使用它。我建议尽量完全依赖 miniforge，而不必安装 Anaconda，因为如果你想使用 Anaconda，你需要同时安装这两者，如果你使用 Anaconda，你不会 necessarily 或者实际上根本不会。

能够访问苹果在这台计算机中内置的 GPU 加速。因此在这台机器上，我将向你展示如何安装 miniforge，它将仅仅是 miniforge，而不是 Anaconda。我实际上在我的 Mac 上同时运行这两者，如果你对如何并排运行它们感兴趣，我可能会做另一个视频。

让我知道。但是关键是 miniforge，如果你查看他们的理由，会强调支持各种 CPU 架构，包括 Apple M1。让我有点恼火的是，我不能通过 Minneconda 运行所有东西，必须在我的 Mac 上有两个完整的 Python 实例。

但他们就是想这样做，所以我们去我的课程网站，上面有各种关于如何操作的说明。我将带你通过一个我基于他人开发的过程，这与这里你看到的一些方法稍有不同，但我认为这是一个相对简化的过程，可以让你为我的课程安装所需的一切。如果你去 T81 深度学习，然后进入安装，那里有各种文件，因为他们不断更新这些平台，而我课程的安装说明自 2020 年初我发布第一个版本以来已经发生了很多变化，我不喜欢在旧的 YouTube 视频中留下失效链接，所以他们链接到各自的版本。

这个视频将使用 Tensorflowlow 安装 Mac Metal。2021 年 7 月，如果我对这个文件进行了一些修改，没有严重破坏视频的情况下，我会在这里放一个新版本的链接。如果没有破坏性更改，我可能会直接修改这个文件。所以这些是说明。我基本上谈到了如何处理多个版本和 miniForge。

我建议先安装 miniForge，我喜欢用 homebrew 来完成这个。我要告诉你如何安装 Homebrew。这与如果你习惯使用 Linux 的 yum 或 Appgi 类似。如果你想的话，它就像 Apple Store 的命令行版本。

为此，如果你去 Homebrew 的首页。这个命令就是安装命令。这就是所需的全部，所以我们复制它，然后打开一个终端。我实际上在这台 Mac 上还没有安装 Homebrew。

我刚买了这台 Mac，已经贴上了我的贴纸，所以我想这台电脑现在是我的了。不会再退回去了。我们继续把这个粘贴到这里。然后我们按下回车，它将运行。所以它显然需要以 root 身份运行。

所以我将输入我的密码，安装将开始，它还会安装 Xcode 命令行工具。你在 Mac 上需要很多东西，非常有用。如果你进行一些其他更手动的安装过程，你需要单独安装这个。所以我将继续按下回车键。

现在正在安装 Homebrew。我们就快进吧。顺便说一下，我可能需要在这台电脑上贴更多的贴纸。有建议吗？请在评论中告诉我。好吧，我还在继续等这个。让我再讨论一下其他一些注意事项。Apple Metal。

这几乎是苹果等同于Nvidia Kuda的内容不会在我课程中运行。我会说它能运行大约90%。但是我有一些高级代码，例如，Gs使用了。😊。

有两件事特别需要注意，一个是Pytororch，Pytorch目前在M1上运行起来要困难得多。目前有一些尚未解决的问题，希望这些能尽快改善，但我们在本课程中使用的stylegan to ADA实际使用了Kuda代码，这是一种C99类型的代码，实际上定义了自定义内核，所以显然这与Apple Metal并不兼容。你当然可以用Apple Metal编写这段代码，但Stgan2 AD就是没有那样写，因此在更高级的机器学习中，如果是自定义编写的内核，Mac M1非常出色，Metal也很棒，但其生态系统远没有Kuda大，所以兼容性也不会像那样好。现在本课程所需的一切。

在coab中可用，所以我建议如果你要在美国运行，就像我说的。这大约90%到95%的内容都能正常工作，但其中一些将无法工作。你对制作一个展示在Apple M1上什么能工作、什么不能工作的视频感兴趣吗？至少在我的经验中。请在评论中告诉我。另外。

这个视频是否帮助你安装？如果有的话，请给它点赞。非常感谢。让我们继续快速前进。我真的不喜欢那些让你输入相同密码几次的过程，这会让你无法在不监视每一步的情况下让它们运行。

😊，好的，所有这些都完成了，这是一个重要的步骤，你应该将homebrew添加到你的路径中。顺便说一下，这假设你正在使用Z shell。否则，某些内容可能会有所不同。Mac过去使用ba shell，但目前他们使用Z shell，除非你特别更改，否则情况就是这样，去运行它，它已被修改，运行这个只需重新加载shell。

我会退出终端并启动一个新的终端，因为我并不完全信任所有东西都会像应该的那样重新配置。现在我应该可以从命令行使用breww命令，我可以使用。所以这很像yum或appgi之类的东西。让我们回到我的说明中。所以我们安装了homebrew，按照了说明，他们还推荐安装这个，我认为基本上是通过brew完成的。

但我会继续执行那个，已经安装了，所以我们没问题，然后我们要执行brew install mini forge，有多种方法。

要做到这一点，你还可以下载一个 shell 命令。你可以在上面的安装过程中看到它，所以如果这对你不工作，你可能也想尝试这个，但我将复制这个，从这里运行它。所以这将利用 brew，并且它将安装 miniForge。我能想到这个可能失败的唯一原因是，如果 Apple metal 的新版本和 miniForge 的新版本不完全兼容。如果我遇到这个问题，我会确实发布一些信息，届时你需要请求安装一个非常特定版本的 miniForge。我们将快速前进，经过所有这些独特的基础，展示你当前所处的环境，我们现在在基础 Python 环境中。

如果我执行 which Python，将会验证这一点。所以看，我们正在运行来自 mini Forge3 Ben 的 Python。接下来的步骤是安装 Jupiter，Jupiter 是你在本课程中执行大部分代码时使用的 IDE，你也可以使用 Jupiter labb 或 Pchar。我们将继续执行这个，这已经安装好了，所以很方便。

现在我将让你做的事情。通常你需要安装几个东西。你需要安装 TensorFlow，然后是金属插件。我还准备了一些我喜欢在课程中安装的便捷机器学习库，它们都是通用的。我认为即使你不参加我的课程，安装它们也不会有什么坏处。

你可以在这里看到所有内容。Psychit Learn、pandas，都是非常标准的东西。你需要这个 TensorFlow Apple Yaml 文件，然后你会执行这个命令。我已经将其加载到我的系统上。所以我会进入我存放它的地方，因为我在我的课程上进行了克隆，你可以在那里看到 YaAml 文件。如果你不需要我课程的所有材料，只需下载 YaAMl 文件。

我那里有一个链接，确保在执行这个命令时你在同一目录下，你将需要我刚提到的 YamL 文件。如果你不需要我所有的课程材料，只需下载 AL 文件。我已经将我的课程材料加载好了，就在那儿。我将执行这个 Conda 环境创建命令。它将创建一个安装了所有这些包的 Tensorflow 环境，以及 Tensorflow 和金属插件，这将让你使用 M1 Mac 的 GPU 能力。我们将快进这部分，这通常需要一点时间。现在我们将进行下一步，即 Conda 激活 Tensorflow，这也在我的说明中，然后就这样。

现在我们在TensorFlow中，我将安装和连接conda。这让我可以将我创建的TensorFlow内核链接到Jupyter，它会完成所有这些步骤。是的，我们会快进。好的，我稍后会告诉你那是什么，我们需要在这里执行这个命令，这实际上是要链接它。你可以在Jupyter中安装多个这样的环境，这也是我常常这样做的。

对于我正在进行的不同项目，我不尝试创建一个包含所有所需的Python安装，因为这样会变得繁琐，我会失去追踪。我倾向于为每个项目创建一个环境，或者根据我在做什么，通常为每个项目创建一个Docker镜像。好的。

我们将进入它，现在它已经链接到Jupyter了。所以现在我们将继续运行Jupyter Notebook，这是下一步。在我的说明中。现在我们在Jupyter Notebook中，将创建一个新的笔记本，或者我可以直接加载之前运行的文件，如果你下载了它，但我将直接创建一个新的。

TensorFlow 39环境，这是我们刚刚创建的环境。选择这个环境非常重要，否则你可能没有安装TensorFlow。所以我们回到这里，将复制并粘贴这段代码，这会告诉你是否一切正常。这是你交叉手指的时刻。我将运行它，这需要一点时间。

我们将快进。你可以看到这里出现的三个，这是Apple Metal的一部分，这是一个好兆头。显示GPU可用是更好的兆头。所以我们完全安装好了，准备就绪。如果你想检查一下，加载任何使用TensorFlow的代码，就像你通常那样，训练ResNet会是我的材料中的一个很好的例子，继续运行它。

你会看到它启动。Metal设备设置为Apple M1，这都是很好的兆头。如果你查看活动监视器并看到GPU的使用百分比，那就可以了。启动需要一点时间，所以如果你一开始在GPU使用百分比上没有看到任何东西，不要惊慌，它可能也在下载中。所以我们在EpoC2 GPU上显示88%的使用率，这实际上是一个不错的迹象。

如果你正确看到这一点，恭喜你，GPU已经正常工作。感谢观看这个视频，请订阅我的频道，跟随课程，或者如果你是我的学生，欢迎参加课程，我们这个学期将一起享受深度学习的乐趣。

感谢观看这个视频，如果这个视频对你有帮助，请给视频点个赞。

T81-558 ｜ 深度神经网络应用-全案例实操系列(2021最新·完整版) - P70：L13.4- 何时重新训练您的神经网络 - ShowMeAI - BV15f4y1w7b8

嗨，我是杰夫·希顿。欢迎来到华盛顿大学的深度神经网络应用课程。在这个视频中，我们将看看你已投入生产的神经网络是否仍然高效。

我们将讨论模型漂移以及如何应对它。有关我最新的人工智能课程和项目，请点击铃铛旁的订阅，以便在每个新视频发布时收到通知，继续我们在本模块中关于部署的主题。我们将探讨何时应该重新训练神经网络。现在，如果你仅有像汽车每加仑英里数（Miles per gallon）或Iis等这些样本数据集，下载后进行处理。

😊。

你不会真的知道何时需要重新训练模型。例如，我们曾多次使用的每加仑英里数数据集，其中有关于汽车的统计数据，帮助你确定每加仑的行驶里程。该数据集的大部分数据来自1970年代末和1980年代初。是的，你几乎可以肯定需要使用现代数据来重新训练该模型，但对于该封闭数据集来说。

模型的性能已经达到了极限。问题在于，随着时间的推移，你的数据分布发生了变化，而你试图获得真实分数的新数据是不同的。这是一个非常普遍的问题，你需要在开发将在实际业务中持续应用的模型时处理。我在寿险行业工作，给你举个例子。

例如，我们正在试图确定个人的寿险风险。基本上，这是他们的死亡风险，我们通常称之为死亡率风险。如果这个人就像你提供的输入数据那样，算是比较普通的，不吸烟，身高、体重或体型都在平均范围内，那么你的神经网络会倾向于给出对这个人相对普通的预测。然而，随着健康趋势的变化，平均水平也在不断变化。

死亡率正在改善，越来越多的人倾向于活到老年。老年人的标准仍然与一段时间以来的范围相对一致，但越来越多的人活到这个范围的高端，吸烟率也在下降。所有这些因素随着时间的推移而变化，这影响了所谓的“真实情况”，你的神经网络的预测也随之调整。因此，随着真实情况的变化，你可能需要用更新的数据重新训练你的神经网络。

F年看看你如何确定何时发生这种情况。现在，当你在一个封闭的数据集中看到这一点时。也就是说，在一个你获取数据后再也不会看到新数据的数据集。这在商业中并不是一个现实的情况，尤其是在现实世界中。通常你建立模型是因为你预期会有新数据，如果你不预期有新数据。

那么你为什么要建立这个模型呢？预测封闭数据集是有趣的，但缺乏很多实际应用。现在，只有在你拥有一个明确的测试和训练集时，你才会在封闭数据上使用这些技术。

我们看到的一些数据集，尤其是一些学术数据集。它们定义了你的训练集和测试集的样子。所以你要观察你的训练和测试之间是否发生了任何变化。这通常在KLE中完成。让我们看看这个图表。

这是我给出的一个图表。我给出了来源，它来自于一篇专门研究数据和协方差变化的论文。这些是这种现象的两个名称，虽然有些不同，但绿色的部分是学习到的函数。因此这使用的是一个非常线性的模型。

因此，在这个非常线性的模型中你会有很多偏差，但没关系，真实的函数。所以它真正应该学习的是这个红色的部分。但看看随时间的推移发生了什么。不幸的是，测试样本出现在时间上比蓝色训练样本稍晚。所以你是在蓝点上学习这个函数。但现实是，甚至真实函数在这里的代表性也很少。

你在这里几乎没有任何代表性。因此你将学习这个非常线性的函数。现在这里确实有一些噪声。几乎没有一个点完全符合线性函数。但尽管如此，这仍在尽量最小化你的残差，使得每个点与线之间的距离大致平均，在线上方的点和下方的点之间。但是当你到达这里时。

你会发现这个函数的不同部分。出于某种原因，时间上通常是某个变量你没有捕获或者无法捕获。现在的趋势更多地朝这个方向发展，所以你可能需要收集更多数据，重新调整并使用非线性模型，以便将这种曲率融入模型中，从而获得更多的预测数据。因为如果你看看这条红线现在的走势，谁知道它是否会继续下降。

也许它会重新呈现这个形状。如果是这样，那么我们的第一个模型也许并不算太差。但你可能需要关注这个时间段内新的片段，因为真实情况已经发生了变化。那么我们如何衡量这种漂移呢？我给你提供了一系列不同的技术，但我不会在课程中逐一介绍这些。

但只是给你一个初步的文献综述，这些是一些可能值得关注的文献。这是一篇特别好的论文，尝试查看所有这些内容并总结出它们的共同点。

现在来看这个，因为我在课堂上做一个示例时真的很困难，我们获取训练集，然后收集新数据，考虑用 autompG 数据来做这个，我们可能会进入这个。所以我们将使用 Cagel 数据，分析并看看一些预测变量的分布在训练集和测试集之间如何变化，这在你参加 Cagel 竞赛时成为一个重要考虑因素。

我们将使用 sharebank 俄罗斯住房市场数据集，只是为了向你展示 kgle 实际上是在看你能否预测俄罗斯波动市场中的实际价格波动。如果你查看数据，他们给你提供了很多输入值。

它们在滚动。因此，这些就是分布中的所有列。我们将关注这些列。Hred 总列。所以你要处理的列很多。我总是喜欢查看概述，看看评估是什么。

他们使用 RMSLE RMS 对数误差。这是回归误差。它并不是一个常见的误差。我实际上必须去 Cagel 论坛查找这个。比赛中的链接实际上导致了一个 404 页面未找到。根据 Cagel 的定义，这个 RMSL 对低估的估计的惩罚大于对高估的惩罚。

所以它就像 RMS 更多是对数尺度，然后实际上不会太多处理它，因为我们只是看训练和测试之间的差异。因此，我们甚至不会真正关注目标。对于我将给你的示例来说，这个评估实际上并不重要。现在你必须下载这个数据，因为它来自 Cale。

我不能直接将其构建到课程的 GitHub 中。所以我将运行这个。我已经有我的。

训练和测试已加载。我实际上是直接从我的数学下载目录中提取的。这对我来说是一个临时位置，但它完成了我想做的事情。在这个特定的 kggle 上有很多预处理数据的示例，我做了一个相对基本的预处理。如果它是对象类型，那就意味着它是某种类别。因此，我将用众数或最常见的值填充缺失值。如果是整数或浮点数，我们将用中位数填充。中位数在均值上更好，因为中位数对异常值的敏感性较低。

然后我们将对所有类别进行标记和编码。因此我们并不创建虚拟变量，而是进行标签编码，以便最终得到一个整数值，指明它们的位置。我不会深入讨论为什么实际上选择了这个，但这些是这个特定竞赛中使用的常见编码。

我相信他们回避了虚拟变量，因为维度实在太多了。所以我们将运行这些函数以定义，然后进行数据预处理。我们将丢弃目标，因为此时我们并不想进行预测。接下来，我们将计算称为混沌统计量的东西。现在，当我第一次听到这个时。

我把混沌统计量想象成COS，但这是混沌Ks统计量，它基本上是在查看两个事物之间的分布有多相似。所以让我们做一个合理性检查。如果我仅运行这个，我在问厨房平方英尺与厨房平方英尺之间的混沌统计量是多少。那么它自身之间的混沌统计量是多少。P值必须低于某个阈值。

所以这并不低于0.05，这非常高。这意味着这两个分布之间几乎没有差异。是的，因为它们是相同的。然后这里的统计量。负零数学专业的学生总是喜欢负零，但计算机科学家却有它。所以这是0，两者之间没有差异，P值非常高。

这意味着在这种情况下无法拒绝零假设。现在让我们看看同一列，但我们查看训练集与测试集中的列。现在混沌统计量略有不同，我们的P值非常低，统计量显示它们之间有0.25的差异。因此，厨房平方英尺的分布在训练集和测试集之间有很大不同，这很有趣。

接下来我们要做的基本上是在所有列上运行这个，所以我们将对所有内容运行混沌统计量，只报告P值低于0.05且混沌统计量大于0.1的情况。现在这个统计量在某种程度上与测量单位有关，所以你必须相对于你实际测量的所有其他值来看这些，随着它的运行，如果我缩小字体大小可以看到这效果更好，但阅读起来就困难了，但这表明。

所有列以及那些差异显著的列。接下来，我们要看看如何检测漂移。现在，这是一种我在许多kaggle竞赛中看到的非常有趣的技术。我们要做的就是简单地将训练测试集采样成更小的集合。

我们将这些数据集进行处理，实际上添加一个在这里的另一列，告诉我们它们来自哪里。我们将看看能否拟合一个模型，这里是随机森林，可以在所有数据重新混合后进行预测。

它能否预测某个单独项是来自测试集还是训练集。如果这些值确实是均匀随机采样的，那么训练集和测试集之间就没有区别。我们只是那样划分的，如果你能预测出某一行来自哪里，那么在分布上就存在差异，这确实有助于锁定。

实际上这个设置来自哪里。让我们继续执行这个操作，这样我们就可以看到它的样子。我们将给这两个数据集贴上标签。我们将把它们组合在一起并重新随机化。现在我们需要分出 X 和 Y，以便准备训练。这是一个分类问题。所以我们使用曲线下面积。我们考虑任何超过 0.75 的值。那并不是一个真正好的 AU。

但这已经足够好，能够突破并确定它到底是什么。我们将使用每一列，以便我们可以以不同的方式评估错误。我们可以看到每一列在实际预测中有多好。所以我们逐列使用这些列来形成预测。当我们开始运行这个时。

我们将看到一些真的有很大差异的东西。现在有些东西确实很有道理。你不会用 I 来预测，因为 I 是不断增加的。所以是的，训练集和测试集之间会有很大差异。时间也是一样的，尤其是如果它们是在不同的时间段内采集的。

因此，时间戳的不同意味着它具有可预测性，这意味着它可能不是在整个时间范围内均匀采样的，我们看到这里的其他值也很容易预测，尤其是在训练集和测试集之间，这在某种程度上可以提供非常有用的信息。

但如果你在收集新数据时，这也非常有用。你不需要结果。你不需要新数据的目标，可以将其与原始数据集进行比较，看看随机森林是否能够预测它是旧数据还是新数据。

如果随机森林可以以不错的准确率预测，比如这里的 87 AUC。那么基础数据可能已经发生了变化，你需要重新训练你的模型。这种内容变化频繁。所以订阅这个频道以保持更新，了解这个课程和人工智能的其他主题。

T81-558 ｜ 深度神经网络应用-全案例实操系列(2021最新·完整版) - P71：L13.5- 用于IOS开发的TensorFlow Lite - ShowMeAI - BV15f4y1w7b8

嗨，我是杰夫·哈顿，欢迎来到华盛顿大学的深度神经网络应用课程。在这个视频中，我将谈论如何在边缘设备上创建神经网络，也就是在 iOS 设备上。在这种情况下，这意味着神经网络的评分或使用实际上将在移动设备上进行。请查看我所有关于 Cale 的视频。

有关神经网络和其他 AI 主题，请点击订阅按钮及其旁边的铃铛，选择全部，以便接收每个新视频的通知。这通常被称为边缘人工智能，因为你会想到云，然后想到围绕云边缘的设备，比如手机和其他类似设备。

这个想法是，我们可能不希望在云端进行神经网络的评分，因为你可能会用手机查看你的照片或其他想保留在手机上的东西，出于隐私限制或传输限制的原因。

你不一定希望云端做所有事情。在这个视频中，我将谈论如何在 iOS 设备上使用 Tensorflow Lite。我相信我会收到关于 Android 和其他内容的请求，但我并不专门从事移动应用开发。

所以我可能会只坚持使用 iOS，除非我收到很多其他平台的请求。但为了这门课程的目的，我们将只使用一个移动设备。我将使用跨平台版本的 Tensorflow，即 Tensorflow Lite，它在许多这些设备上可用。因此，如果 iOS 不是你的首选，这会增加你将这些知识转移到其他平台的机会。

现实情况是，如果你正在创建一种非常受欢迎的应用程序，你可能会将其移植到 iOS 和 Android。我不记得微软目前是否有第三个平台，或者他们是否终于放弃了这个，或者他们现在的状态如何。但这两个是主要的平台，Android 和 iOS，而我恰好拥有 iOS 硬件。

所以我将做这个。我们将创建的应用程序可以识别一些东西。我们稍后会深入了解。好的，现在让我们构建一个 iOS 应用程序。正如我所说，你可以用其他方式做这件事，你也可以为 Android 做这个。此外，我使用的是 Tensorflow Lite，因为这门课程主要集中在 Tensorflow 上。同时，Tensorflow Lite 是跨平台的，你可以在 Android 上使用。因此，如果你想在 Android 上做这件事也并非完全无望，你只需要学习其具体细节，但代码大体上是相同的，神经网络代码是一样的，但实际的应用开发内容，比如访问相机等，将会完全不同。所以他们有一个示例应用程序，你现在看到的就是它。

他们展示了一些iOS特定的代码，比如如何实际访问相机并逐个获取图像。我们将把这些图像发送给TensorFlow Lite，以便对它们进行分类，同时我们还在传递一个已经在图像上训练好的神经网络。

你很少在手机上进行实际训练，那里真的没有什么可以帮助你实际做到这一点的东西，你需要自己进行一些自定义编码，但实际上你不会在手机上训练，你只是使用手机进行分类。如果你真的在上面训练，你会消耗掉所有的电力，因为你的代码并没有经过优化。现在我在这里展示的基本上是他们的一些其他代码。

实际上是在查询神经网络模型，模型数据。这实际上是在查询它。所以我首先告诉你，这是Swift，我对Swift代码并不熟悉。因此，我完全使用Google提供的TensorFlow Lite应用程序，正如他们在示例中所提供的。这在一个包含许多其他示例的代码库中。我们要在这里进行。

实际的TensorFlow示例，你可以看到它是更大TensorFlow示例集的一部分。这个链接直接带我们进入iOS的图像分类。像你在这里看到的，你可以在此基础上深入。检查时，我们将不得不真正查看整个TensorFlow示例集。

这包含了相当多的内容。现在这里是你需要的前提条件，你需要一个拥有该版本或更高版本iOS的设备，这不应该太难，除非你正在处理一些非常旧的设备。你需要Xcode 10.0及以上，开发iOS应用你必须使用Mac，我已经安装了，所以我不打算展示如何安装Xcode，这很简单。你需要一个有效的苹果开发者账号。

这与你用来访问iTunes商店和其他类似服务的实际苹果ID相关。如果你付费，这实际上是一个相对较小的费用，我认为是每年100左右的费用，让你能将应用发布到商店，但在这个例子中不需要。

运行我之前给你展示过的那个应用程序，我不是一个付费的苹果开发者，原因是我并不真的需要那个能力，我不在苹果商店出售商品，至少在此时将来，谁知道呢。你确实需要Xcode命令行工具，我想我已经安装了这些，但我会运行那个命令以确保我里面没有这些。

运行与这些和CocoaPods相关的代码，CocoaPods有点像用于Cocoa应用的Pip，它将为我们安装TensorFlow Lite。所以你必须安装，让我们运行Xcode选择，以确保我们有这些。我已经安装了这些，正如你所看到的，所以继续运行，看你是否需要。现在我们要安装CocoaPods。

如我所说，CocoaPods有点像Pip，它将让你实际为Swift安装TensorFlow Lite包。让我们复制它，然后运行。我不想执行他们提供的bash命令，所以直接运行，不用bash。你确实需要输入密码，这需要一些安装时间，我会快进。现在已安装。这里的备注非常重要，这意味着你无法在模拟器上运行，你必须在实际的iOS设备上运行，因为它需要一个摄像头。

好的，现在我们要克隆那个仓库。我们将经历整个构建和运行部分。确保不要复制bash部分。我通常会将这些检出到我刚移动到的项目目录中，它将拉取所有的TensorFlow示例。

好吧，既然这些都完成了。我将分两个部分进行操作。他们有两个命令在这里合并在一起。首先。我将执行C命令，并移动到这些示例的适当部分。好的，现在我们在实际的iOS示例中。现在我将执行pod install。

这将安装TensorFlow Lite。这有点像Python中的Pip安装。好的，安装完成。现在我们将切换到Xcode来进行接下来的几个步骤。😊 好的，让我们进行第一步。进入Xcode。在你设置开发团队之前，如他们所说的。

你需要在两个层面上完成这个。首先，你必须告诉Xcode你有一个Apple开发者账号。为此，你进入偏好设置并点击账户。现在我这里没有任何账户。这是因为我删除了我的账户，以便演示这个。但你点击加号，我们将使用一个Apple ID。所以我的Apple开发者账号与我在iTunes上购买物品的普通Apple ID绑定。

所以我将点击继续。然后它要我输入这个，也就是我的电子邮件地址。这是我主要用于此的电子邮件地址。所以我已经把它屏蔽掉了。接着点击下一步。它想知道你的密码。显然。我把它屏蔽了，但它也会屏蔽。想知道它是否会让我进行两步验证。

对我来说没有双因素认证。所以，完成了。所以我将关闭这个窗口。接下来你要做的是打开项目的配置。现在你只需双击它，它就会打开。去签名和功能。这里实质上需要一个开发团队，而那就是我。

这是杰夫·希顿的个人团队。现在，这实际上是他们在谷歌的指引中告诉你的下一步，这个标识符必须是完全独特的。所以，我将切换过去做这个。所以让我去这里，这里是他们建议添加你的名字缩写。所以我们放上JH再试一次。哦，现在我们很高兴。

所以让我们。让我们这么做。现在，他们在说明中说的下一件事。这里是连接一个iOS设备，继续运行它。所以让我拿我的iPhone。好的。你可以告诉我的iPhone已连接，因为它想要运行iTunes。我不想运行它。我们回到Xcode。现在我们尝试运行它。我通常。

现在我不常用Xcode，我必须承认我觉得它非常繁琐，但我猜大的。

箭头是运行某个东西的。顺便说一下，它在模拟器中运行。这是你不想要的。所以让我来告诉你。如何正确做到这一点。

如果你运行那个，只需继续并停止它。应该能关闭模拟器。现在，2。正确运行这个。你想点击这里。那是，我的。这是我用来测试的iPhone。现在我应该能够点击大箭头，希望这能成功。好的，它需要这个密码。让我来提供一下。好的。

我发誓每次使用Xcode时，我都觉得这是一个我可悲地失败的智力测试。但是。我觉得所有在苹果工作的优秀用户界面设计师在做Xcode时都只是。休假。但是你在这里需要做的是输入你的用户ID。你不能选择允许。你必须总是选择为什么他们甚至会把那个按钮放在那里。谁知道呢。

如果你们两个尝试允许，它会一次又一次地问你，就像我之前做的那样。现在，它启动你的应用程序。现在，这又是一个你必须做的小事。现在。我明白这个应用程序安全性是个大问题。所以你基本上必须。告诉你的iPhone信任它。让我给你展示步骤。

所以他们甚至在这里给你提供了做这个的说明，你实际上要去设置。设备管理，允许它。好的，我现在告诉它信任那个应用程序。所以，它在信任。然后我应该能够再次运行它。但应用程序已经安装在我的。

iPhone。😊，好的，现在我切换到我的iPhone。我们需要做的第一件事是实际去设置。然后在常规标签下，有很多东西。在这里你想去设备管理。AppleDevelop。基本上之前这里有信任这个应用程序的选项，而不是删除这个应用程序。所以你可能会看到信任这个应用程序，我已经信任过它。我其实是单独录制这一部分。一旦你完成所有这些，你就在这里，可以看到TF分类。现在让我们先试验一下。

所以我们现在通过我的iPhone看世界，实际上它认为我是一种面具或浴帽，就这样。但我们会试试我这里的一些物品，它很容易就识别了咖啡杯。它识别出了足球。那是著名的红色订书机。那是波比滑雪。是的，真可悲。灰烬，停车计，油泵，好吧，它无法识别肥皂瓶，还有我这里这个非常奇怪的青蛙。

它的思维方式就像一个螺丝刀。青蛙实际上在拿着一个手机， Nope，它也没有搞明白这一点。那么，让我们看看还有哪些东西可以进行分类？

这是一个椅子。摇椅，我想如果你真的想的话，可以摇晃一下。波比滑雪，让我们看看它是否能识别Hickory。摇椅，摇椅，美国斯塔福德犬，法国斗牛犬，Hickory。我觉得你是法国的。没有对法国的偏见，但他是一个英语斗牛犬。哦，Hickory，我很抱歉。

我保证我会重新编程以识别英语斗牛犬。

感谢观看这个视频，这就是如何在iOS上使用TensorFlow开发一个简单应用程序的过程。如果你想将这些知识应用于其他平台， definitely 查看TensorFlow light网页，它会引导你到那些其他平台。

T81-558 ｜ 深度神经网络应用-全案例实操系列(2021最新·完整版) - P72：L14.1- 用于Keras和TensorFlow的自动机器学习(AutoML) - ShowMeAI - BV15f4y1w7b8

嗨，我是杰夫·伊顿，欢迎来到华盛顿大学的深度神经网络应用课程。那么，现在是按一下简单按钮的时候了，你可能会问我为什么把这个放在课程结束时或接近课程结束时。但我们将看一下Automl，这是最新的自动机器学习，关于我的AI课程和项目，请点击旁边的铃铛订阅，以便通知你每个新视频。现在我们来看看automl。

所以作为数据科学家，我经常被各种职业的人问到。你难道不是在试图让我失业，或者你在试图用人工智能取代我的工作？实际上，答案通常是否定的，我们在尝试给他们更好的增强工具，以帮助他们更好地完成工作。

但是如果我说是的，我正在试图让你失业，好吧。如果这让你感觉好一些，数据科学家们也在尽快尝试让自己失业。这就是Automl，我会给你所有这些超参数和你需要的其他东西。

调整你的模型，以便获得最佳性能。我给你所有这些数据类型，你必须使用虚拟变量和其他编码将数据转换为神经网络可以处理的形式，Automl会迅速完成这一切。

你给它一些数据，它就会自行决定如何编码一切。它会立即确定使用哪种神经网络，然后从那里开始。它主要使用机器学习来构建机器学习。这并不是世界上最复杂的事情，往往是依靠蛮力。

但有很多商业产品非常昂贵。你可以用这些东西的年费为每个用户购买高档跑车。所以我会在商业方面谈谈其中的一些。我们还将看到如何在本模块中实现一个非常简单的automl。

这是我创建的一个东西。它是我在kgular工具中拥有的一部分，这里会看到一些更简化的版本，但它可以处理原始数据，试图找出要做什么。至于😊，Autm。有Rapid Minr，有data coup。有data robot。有H2无驾驶。

老实说，我已经与这些都合作和评估过。我会在2019年给你我的看法。这变化迅速。Automl很庞大。有许多初创公司想要进入这个领域，从车库里成立的几个人的初创企业到相当大的第二轮和第三轮初创公司，正在做这些事情。Rapid miner是较老的一家，存在了很长时间。

我相信这三者中都有快速挖掘。我将实际展示它的免费版本。虽然这不是我最喜欢的，但它是存在的，而且你可以获得它的免费版本。如果你对某些自动机器学习感兴趣，可以看看数据合并（Data co），这是一个将自动机器学习作为其一部分的平台，你可以很好地使用它。

他们称之为低代码无代码，因此你并不需要进行很多编码，公民数据科学家（citizen data scientists）是指那些技术水平不高但仍希望进行数据科学相关工作的人。数据合并对他们来说非常好。数据合并真的努力想做到几乎所有事情，我认为这可能是他们的一个缺陷，因为他们试图成为自动机器学习，但并不是最好的自动机器学习。

他们试图进行数据预处理，但并不是最好的数据预处理。所以有很多公司专注于数据合并涉及的所有部分。在我看来，数据机器人（Data robot）是真正的自动机器学习的先驱之一，它们是由Kle Masters创办的，而那时候你并没有很多Kaggle大师，现在许多人都是大师，他们凭借Kaggle的奖金创办了公司，真酷！所以我对最后这两个公司，特别是数据机器人和H2O无驱动技术（driverless）非常喜欢，我认为这是两种最佳技术。

目前有一些解决方案用于Autom。就个人而言，它们相对来说都很贵。对于财富500强公司来说，可能还好，但这些都是商业闭源产品。谷歌也有云解决方案，Autom让我给你展示一下其中一个的样子。

所以我们将使用快速挖掘（rapid miner）。我选择快速挖掘并不是因为我特别喜欢它。还行，但他们有免费版本，而我将启动它，快速挖掘本身也挺贵。如果你付费的话，顺便说一下，你的快速挖掘工作室教育许可证将在65天后到期。我会续费我的许可证。所以，看看快速挖掘工作室要多少钱。

我认为每个用户每年5到10美元，快速挖掘服务器本地部署是每年36美元，这些程序并不便宜。而且还有一个聊天机器人，可以和你聊聊花大钱的事。如果你想和聊天机器人聊聊。那么，让我说，稍后提醒我。我们将要做的是点击这个自动模型。

所以我们选择自动模型，我需要将我的数据实际上传。所以我将进行本地仓库的导入新数据。数据在我的电脑上加载。我们将使用我的示例数据集。使用相同的数据作为另一个例子。这些都是我们要让数据符合预期格式的数据。

我们将尝试预测产品。所以我们会进行分类。在这里你选择，哦，它只是想知道不同的格式。所以没问题。我们导入数据。我们想预测产品。显示给你分布。我们点击下一步。它建议不使用I，这是相当聪明的。是的，I并不是那么有用。

我们将使用所有这些不同的机器学习模型类型。我们会运行它。实际上它现在是在疯狂地尝试找到最佳模型和最佳编码。让你知道它看到了什么。你可以在这里看到准确率百分比。还不错。它的准确率大约在70%。

我总是针对当前学期的Kaggle竞赛的一个子集运行这个程序，这样我可以看看当前的数据集是否有任何预测能力。也就是说，输入是否有可能预测目标。好了，完成了。

你可以看到不同的模型。看起来最佳准确率是通过深度学习获得的。是的，深度学习。所以它还显示了运行时间。这些中的一些训练所需的时间更长。所以你通常想在计算复杂性与其他因素之间平衡这两者。现在，一旦你有了它，你可以进入深度学习模型，查看模型。

这显示了它创建超参数的统计信息。这真是太酷了。你可以进入模拟器，它会告诉你这里的相关性。所以收入与预测产品B之间的相关性是相当负的。你可以看看。😊。这些数据真的可以让你对数据有一些解释。这是一个商业自动机器学习包。

现在我们来看看如何在Python中创建一个简单的自动机器学习系统。这是我的简单automl系统。我给你提供了一个相当简单的类。我非常喜欢这个类。我自己写的。它基本上允许你抽象来自网络或本地的Cv文件之间的差异。所以我会先运行它，以便定义它，因为我们将需要它，这一切都能运作。

这个automl，我给你提供的至少是分析。它通过流式传输工作，即使数据非常庞大，它也能处理大量记录并进行所需计算。这些是你可以提供的一些配置项，其中大部分你可以简单地保持不变。所以我会运行这个，只是为了把automl系统放进来。这段代码基于你提供的大小生成一个神经网络。

所以它会创建分类或回归，而这个则有助于交叉验证。😊。这是我们在本课程早些时候看到的相同代码，我们正在设置分类。所以请注意，如果你正在分类，它确实会将你的输出的虚拟变量转换为实际索引，因为那是你评估它所需的，我们还确保评估准确性，如果我们正在分类RMSs，如果没有，我们只构建自动样本并报告最终的准确性。

我们将继续运行它，以便加载。我给你几个不同的数据集，可以在上面运行automl，部分用于分类，部分用于回归。老实说，除了在这里指定之外，你不必太考虑这个。所以我将对我之前的那个简单数据集进行运行，它将作为类别进行运行，并尝试进行自动机器学习，就像Rapid Miner在做的那样。所以我做的第一部分分析数据集，并创建一个名为control csv的文件，我将向你展示control csv。

😊，这很重要，所以这是控制CSV。它实际上给你一个ID，建议我们对ID进行Z评分。它没有足够聪明地意识到有太多独特值。我将更改ID以忽略，我们不想对I做任何操作。它决定将其作为分类变量，这很好，它显示了各个类别的分布区域，也将被视为分类收入。它选择对这些进行Z评分，这很好。Subs也是虚拟分类Z评分，Z评分那些都很好。年龄有趣的是，它选择虚拟变量，仅仅是因为年龄不多，它认为这是一个类别，让我们对其进行Z评分，我认为这是个更好的决定。人口密度绝对是Z评分，最终的输出产品将被视为类别，所以我将继续保存，以便我们现在有一个修改后的控制文件版本，而下一部分基本上只是重新加载。

控制文件会根据控制文件转换输入数据。所以我们将运行它。它相当快速。它只是处理并转换，给出转换后的输出CV。让我们快速看一下这个文件。这有点乱。我是说，工作被替换为所有这些虚拟变量。你有各种各样的虚拟变量。

你有一些Z评分。但这不酷吗？这是你的特征向量，你通常会为之苦苦挣扎，试图自己创建，自动机器学习基本上就是为你搞定这一切。现在我们实际上将尝试将其拟合到一个，我们将预处理它，以便将其转化为X和Y，它确实做到了。

我检查确保没有缺失变量。没有缺失，我们将进行交叉验证。它将通过所有五个折叠进行训练和验证，我们将了解这个神经网络能够产生的结果。实际上还没有。一些准确性注意到第一个折叠并没有比Rapid Miner落后太多，我的版本是免费的F2大约在70左右。

所以我们的准确率仅比RapidMiner低几个百分点，最终准确率略低于70，所以非常接近，低于RapidMiner几分，但它是免费的，并且与RapidMiner的免费版本不同，你可以根据需要使用任意数量的玫瑰，但你仍然需要在内存中训练神经网络，因为这些内容经常变化，所以请订阅频道，以便随时了解本课程及其他人工智能主题的最新动态。

T81-558 ｜ 深度神经网络应用-全案例实操系列(2021最新·完整版) - P73：L14.2- 在Keras中使用去噪自动编码器 - ShowMeAI - BV15f4y1w7b8

嗨，我是杰夫·希顿，欢迎来到华盛顿大学的深度神经网络应用课程。在这个视频中，我们将看看自编码器，或具体来说是去噪自编码器。这些是可以用于重建被噪声模糊的数据的自编码器，获取我最新的AI课程和项目。

点击订阅并点击旁边的铃铛以获取每个新视频的通知。对于自编码器，我们首先将关注函数逼近。我们之前做过函数逼近，基本上是回归，但我将定义一个函数来进行逼近并绘制图表。😊。

现在我要创建一个简单的神经网络，基本上是正弦函数。我们将尝试预测正弦波。如果我运行它，它将进行训练。我们本质上只是训练它处理传入的正弦函数，快进一下。好的，它完成了。你可以看到它跟踪得相当不错。

现在我在期望值中加入了一些噪声，以使其不完全完美。你也可以看到实际值和预测值非常接近。接下来，我们将进行多输出回归。多输出回归对于自编码器至关重要。本质上，发生的事情是你有输入，就像之前的输入1、输入2、输入3、输入4。

但你可以拥有多个输出神经元。现在谈谈自编码器。通常，输入的数量与输出的数量相匹配。我们就直接运行这个。😊。它试图同时对正弦和余弦进行训练。我将快进直到它完成。好的，它完成了，均方根误差看起来不错。

你可以看到一些预测值和期望值。所以它在同时学习正弦和余弦。这是非常令人惊讶的。不过，其实并不太惊人。我是说，神经网络的多输出回归是相当常见的事情。尽管在其他类型的机器学习模型中不常见。现在，我们来做一个简单的自编码器。

注意这个自编码器，我们有五个输入和五个输出。你拥有的输入数量应该与输出数量相同。而我们本质上在做的事情，这有点迷人。这就是自编码器的作用。我们在这里输入。😊，基本上是随机数字。我们正在训练它。

期待我们得到的输出与最初输入的数字相同。这教会神经网络只使用这两个隐藏层。这两个隐藏神经元实际上将所有输入压缩成仅两个数值。因此，我们将训练之前相同的形状1。它训练得非常快。你可以看到我基本上输入了0，1，2，3，4，5，8，9。它基本上返回了接近相同的结果，0，1，2，3，4，5，6，7，8。并且很快就得到了那个，正确的。通常，这些自编码器用于图像。

所以，让我们加载一些可以利用的图像。我在这里基本上向你展示了我们是如何创建一个自编码器来编码华盛顿大学的这张图像。现在，如果你看这个定义。😊，它实际上是通过一个隐藏层进行高度压缩。因此，它教会自编码器如此高度压缩，以至于仅一个数值就能表示它。

当然，上下的隐藏层会对图像有一些了解。因此，你基本上可以将其压缩得如此小，仍然能够获得有意义的输出。让我们加载一些图像并进行标准化。我们将确保所有图像大小相同。我们还可以进行其他标准化。我们还可以确保光照量一致。

但目前它并没有做到。现在我们将尝试进行预测。因此，我们基本上循环这些128乘128的图像。😊。我们正在将它们压缩到这个大小，并将该值作为输入和输出。尝试让神经网络的输出看起来与训练数据一样。

这里我将快速前进。在这里，你可以看到它能够根据这些输入的向量重建图像。现在，让我们看一下去噪自编码器。这些非常有趣，所以。我们来运行一个，看看我们可以给图像添加噪声。我只是放了一些随机的框在那里。我们基本上现在可以进行训练。通常，自编码器。

你输入数据，期待得到相同的输出。但在这里，我们将输入被这些方框遮挡的图像，并期待尽可能接近原始图像。这教会自编码器去除噪声。我们可以运行它并观察输出。这些图像慢慢闪过。它们的所有像素都被框去除了。

但它们依然表现得很好。然后我们将基于这些我们创建的噪声图像训练神经网络，并进行10次随机试验。你可以看到，有噪声和没有噪声的情况下。它在去除噪声方面做得相当不错。

你会注意到一些失真。如果你放大框的位置。但这就是它的工作方式。你可以看到，它确实能够很好地去除噪声。这是一个自去噪。这是一个自去噪自编码器。现在，自编码器可以做各种各样的事情。我们将看到。😊。

在下一部分，我们将探讨如何利用它们来检测异常。因此，输入与我们之前见过的内容不同。这些内容经常变化，因此请订阅频道以获取本课程及其他人工智能主题的最新信息。

T81-558 ｜ 深度神经网络应用-全案例实操系列(2021最新·完整版) - P74：L14.3- 使用自动编码器在Keras中进行异常检测 - ShowMeAI - BV15f4y1w7b8

嗨，我是杰夫·希顿。欢迎来到华盛顿大学的深度神经网络应用。在这个视频中，我们将讨论异常检测。你如何检测不符合预期的情况。这在计算机安全方面有很大的应用，但在其他领域也一样。

我们将在这个视频中查看它，获取我AI课程和项目的最新动态。点击订阅并点击旁边的铃铛，以便接收每个新视频的通知。所以现在让我们看看自动编码器的用法。我们将看到如何将自动编码器应用于异常检测。我有几个关于在Keras中进行异常检测的其他教程的链接。

其中一些可能对你有用。我在这里使用的方法是使用自动编码器，并查看自动编码器的误差，以确定数据与我们之前看到的数据相比是否异常。我们将利用一个叫做KDd99数据集的东西。

我们将在本课程的两个部分中使用它。我们将在下一部分创建一个入侵检测系统。这是2019年的一个旧数据集。😊。

这已经快20年了。所以这是一个较旧的安全数据。它有足够的列和其他内容，使其有用。我不知道我是否会基于当前的研究，意味着试图创建基于20年旧数据的当前入侵检测或异常检测系统。

但这对于安全来说是一个不错的“你好，世界”，而且它并不简单。这是相当可观的。绝对不是所谓的大数据，但它很有用。所以我们在这里会看到它。这对示例来说很好。我不会把它用于当前研究。话虽如此，我看到有论文频繁使用它，但质量各异。

我没有把它包含在Github仓库中，因为它相对较大。不过这个命令可以让你下载它，我会先运行这个。它让你知道下载到哪里，担心coab。你可能需要把它放在你的某个驱动器上。我会尽量在这里提供具体的coabab指令。所以现在我们得到了数据。

我展示了前五行。你可以看到这是什么样的。这是网络类型数据。这是在一个模拟环境中为一个比赛创建的K种早期标签，并没有显示所有数据。其实还有相当多。但我将要做的是将这些数据按结果分组。所以这些结果包括缓冲区溢出、FTP、正确猜测密码。

这些都是在这个过程中模拟的不同类型的攻击。其中一些在今天仍然是攻击类型。有些在20年后可能已经相当罕见。我们特别关注的正常数据意味着没有任何事情发生。因此，我们将训练它，将正常数据视为正常，将其他数据视为异常。

所以我们将训练一个神经网络来检测那些不像正常的数据。我们将完全通过自编码器来实现这一点。我创建了两个函数来帮助我们预处理，一个用于编码z分数，一个用于编码虚拟变量。这是我的预处理表单。你可以看到这里有很多列。

我基本上在编码z分数和虚拟变量。这是我仅进行的两种转换类型，所以我保持事情相对简单。我们去掉任何包含NaN的行。包含NaN的行并不多。你可以看到这些行。你可以清楚地看到z分数的影响。

我们要做的是创建一个包含正常和攻击的掩码。这样我们能够将这些数据隔离开来。我们将去掉结果，因为我们并不是真的在结果上训练。这本质上是无监督学习，一旦你将数据分成这两个组。这样的自编码器的性质。我们将继续运行它，你可以看到。

正常计数大约是97K，攻击在这个数据集中更为常见。我们将其分开，以便我们拥有攻击的x和正常的x，然后我们将把这分成训练测试集，我们将使用正常数据来评估它。

我们要看看正常数据在它看来是否像正常数据，接下来我们将使用自编码器来完成这一点，我们之前讨论过自编码器。但为了让这些视频能够相对独立，我给你快速概述一下。自编码器本质上是一个具有“瘦”隐藏层结构的神经网络。它的想法是你有多个输入，对于这个特定的自编码器，你将拥有所有KDD99的输入，像大多数网络一样，你有偏置神经元，输出数量等于输入数量。

我们要做的基本上是训练自编码器，使其能够生成相同的输入作为输出。现在这似乎没什么用，但这本质上是在教它进行特征减少和简化，因此它教会它将所有这些输入，这五个输入是100，因为我们将可能使用KDD99，将其表示为输出到隐藏层1和隐藏层2的两个数字。现在，所有进入这里的权重都是编码权重，这些是解码权重，因此这些是它所学习的。

在这里，我们将构建我们的自编码器。我们的自编码器将比这里更复杂。因此，我们将基本上有25，25，3。我们仍然有这个非常细的区域，但有点像沙漏的形状。所以这里几乎有三个隐藏层，实际上为我们提供压缩能力。

所以我将继续运行这个程序。它实际上会适应这个神经网络。所以它需要一点时间来适应。我会快进这部分。好的，它训练完了，主要是为了阐述这里发生的理论。我们只在正常数据上进行训练，并且是无监督训练。

所以我们甚至不提供结果。给出结果是没有意义的，因为它们都是正常的。因此，结果会是一样的。由于它正在学习压缩以减少维度。维度减少或压缩的工作方式就是通过使用模式来表示数据的常见部分。

所以它在简化，只有在输入数据与之非常相似的情况下才能工作。现在，我将给你一个意外的异常检测器的完美例子。现在，手机在这方面做得好多了，但早期的手机。它们压缩的方式是因为它们对人声的特性了解很多，因此使用了人声通常在的音域。

它们只是压缩了数据，并以一种不会让人类声音感到烦恼的方式降低了质量，你仍然可以识别声音，仍然能够理解。然而，如果你尝试通过手机播放音乐或其他压缩算法根本不适合的音调，那就不行了。

它们的重现效果不会很好。会有静电和其他失真。因为使用这些与压缩算法构建时不同的音调就是不同的。它们是异常。而手机则检测到了这种异常。并不是特别设计的。这只是一个例子，但它通过失真来检测异常。

这就是我们将在这里看到的内容。我们将数据输入，并查看输出数据与输入数据的相似程度。因为自编码器是为了直接传递而设计，但在过程中会进行压缩。所以它先压缩再扩展。我们希望确保在这个过程中没有太多的失真。如果有，那么输入的数据可能就是不同的。

这是最初训练数据的基础。我们在课程早些时候看到，你可以使用混沌统计和其他方法来确定数据是否发生了变化，以至于你的神经网络可能需要重新训练。这是另一种很好的方法。异常检测和识别。如果你的数据与训练数据足够相似，就能知道何时更新你的神经网络。

让我们继续运行它并进行测试。因此，现在运行这个单元，我们将看到结果。首先，我会让它在正常测试上进行预测，然后我会评分，基本上是查看这些预测与它训练过的正常测试的吻合程度。

所以我们字面上看到了这一点。如果你看看这里，样本中的两个现在的正常攻击。这本质上是它所训练的数据。因此，你必须对这些保持警惕。这些是正常的数据，不在训练集中。

但是你可以看到这两个的RMSse大约是0.3。注意到攻击的RMSE较高，因为它们是异常，这些都相对简单。我们在X正常测试上进行预测，然后根据相同的内容评估误差。所以我们在看这能否通过自动编码器以最小失真流动。

你看到的失真越多，越可能是异常。该内容经常变化，所以请订阅频道以保持对该课程和其他人工智能主题的最新了解。

T81-558 ｜ 深度神经网络应用-全案例实操系列(2021最新·完整版) - P75：L14.4- 使用 Keras 训练入侵检测系统(KDD99) - ShowMeAI - BV15f4y1w7b8

嗨，我是 Jeffy，欢迎来到华盛顿大学的深度神经网络应用。 在这个视频中，我们将查看入侵检测系统，以及如何使用 KDD 99 数据集来实际训练其中一个，了解我 AI 课程和项目的最新动态。

点击订阅和旁边的铃铛，以便收到每个新视频的通知。我们将看看如何构建一个入侵检测系统。要做到这一点，我们需要一个数据集。我们将使用与异常检测相同的数据集。这是 KDD 99 数据。我会简要重新介绍这个数据，以便这些视频可以按任何顺序完成。

但这是 1999 年的数据。所以它已经 20 年了。请对此有所了解。这是一个很好的安全示例数据集。我不会在上面训练任何当前的安全检测系统，因为 20 年来攻击的性质可能已经有所改变，这真是年内的低调说法。

也许，但我们要做的是去。

继续读取 KDD 99 数据集，我们在这里完成了。我不能将这个数据直接构建到类中，因为我不拥有它，所以如果你在使用 Google Colab，你确实需要下载它。你可能会将它加载到你的 G 驱动器中。这些都是我们将要使用的数据列。让我继续运行这个。它会显示前几行。

你可以看出这是一种非常 TCPI 互联网类型的数据。我们可以运行我给你的这段代码，帮助你分析它。这只是让我初步了解这些数据，以便我知道如何编码它。好的，这里是这个的分析。我发现这对我查看的数据集非常有用。

你可以基本上看到像协议类型这样的内容。它显示了 57% 的 ICmpP，TCP 是 38% 等等。这让你对拥有多少相似值有了一个了解。这在创建分类变量与连续变量时为我提供了指导。因此，像下方的源字节为 0%。所以，0% 的重复真的没有看到任何真实的重复。

所以它无法在其他数据中找到分类值。一旦我有了这个。我继续使用我为异常检测展示的同样两个函数。我们将使用 Z 分数和虚拟变量来编码。因此，我确定为分类的所有值。

我将对所有连续值进行虚拟编码，我将编码 Z 分数。现在，如果你处理的是需要高准确度的东西，这通常只是第一步。你会在编码和特征工程上更加创新。因此，这基本上创建了特征向量。现在我准备在它上面实际训练神经网络了。

我正在训练它来预测结果。结果要么是正常，要么是可以发送的多种不同类型的攻击。现在我们使用的是分类交叉熵。因此我甚至在尝试预测攻击类型。它正在训练网络。我将快进这一部分。这个组我将展示我们可能获得的结果。

所以这些都是不同类型的攻击，例如Smurf在那时非常流行。😊。正常情况有97,000个，因此正常案例相当多。一些攻击类型非常罕见，比如pearin和spy。但这些基本上是我们现在试图分类的内容，现在神经网络已经训练完毕。我们可以测量它的准确性，准确率非常高，0.997。现在。

这也是使用KDD99数据集时需要记住的另一件事。它已经存在了一段时间。获得良好分数并不困难，因为数据在这些不同类别中分隔得非常好。一旦这个数据集经过研究并真正理解后，值得注意的是，即使在2019年，你仍然会看到一些论文讨论。

在这个特定数据集上达到99%的准确率就像是任何具有研究意义的东西。这在很大程度上是一个用于入侵检测和其他安全特征的示例数据集，至少在2019年，所以一定要意识到这一点，但它确实为这些类型的技术提供了很好的示例。此内容经常更改，因此请订阅频道以便及时了解本课程和其他人工智能主题。

T81-558 ｜ 深度神经网络应用-全案例实操系列(2021最新·完整版) - P76：L14.5- 新深度学习技术介绍 - ShowMeAI - BV15f4y1w7b8

嗨，我是杰夫·希顿，欢迎来到华盛顿大学的深度神经网络应用课程。恭喜你，你已经完成了这门课程的最后模块，在这个视频中，我将讨论接下来该做什么，你现在该如何利用你所学到的深度学习的精彩知识。

🎼首先，我非常鼓励你订阅我的YouTube频道。我知道每个YouTuber总是这么说，但在这种情况下，你已经完成了这门课程。你可以看到我发布的视频，这些视频确实以这门课程材料为基础。我将展示这些相同技术的更高级应用，并且我还会添加新视频，以替换课程的部分内容。

这是这门课程。因此，每当我更换一个视频时，你会收到更新通知，让你知道其中之一已经改变，你可以看到在我看来深度学习的新技术，我决定将其添加到课程的一部分中。

你可以在GitHub上关注我，或者直接在YouTube频道上关注我，任一都可以，嘿，两个都行。让我知道我何时进行更改或添加额外内容，我总是有我的所谓新技术雷达，而这一部分我每年至少重新录制一次。

这门课程运行两个学期，所以每隔一个学期我会尝试更新一下下一步是什么，以及我雷达上的技术，因为这些东西总是在变化，哪怕是两年，甚至一年，在深度学习中都是一个永恒的概念，因此目前在我雷达上的技术。

你在这里看到的变压器，更先进的迁移学习增强和强化学习，尤其是在TF代理之外。因此，在这门课程中，我对变压器的覆盖不够。这绝对是一项你想要熟悉的技术，尤其是如果你对自然语言处理感兴趣。

尽管它开始在计算机视觉领域取得了一些进展。变压器的真正标志是序列到序列。因此，模型接受一个序列并输出另一个序列。所以序列是这些可变长度的向量，可能是字符，可能是单词，可能是一系列图像，视频输入输出随着计算能力的不断增强而变得更强大。

我真的认为我们会看到视频对视频的转换。😊，变压器，深度伪造。虽然它们并不是完全使用变压器技术，但可以认为是那类技术。所以你基本上可以给这个变压器一份英语句子列表，一份法语句子列表。它将学习如何进行翻译。

更高级的迁移学习，因此本课程目前涉及迁移学习，这是一项非常非常重要的主题。通常至少在这门课程中，我谈论的是将一个神经网络引入，然后稍作微调，并在此基础上添加一些主题，特别是如何找到已经学习过的预训练神经网络，这样你就不必重新经历这个过程。

训练的费用，因为一些最先进的神经网络是在1024个GPU的GPU阵列上训练的。我前几天看到一个，训练这个东西要花25万美元。我是说，拜托。你想站在那些巨人的肩膀上，但特别有两个事情我建议你看看：一个是Hugging Face，这些是你可以使用的预训练模型，可以直接导入Python进行自然语言处理；另一个是在GC的NVIDIA GPU云中也包含了很多迁移学习，你可以用于各种用途，我在想象一种类似Jarvis的东西。

你知道的，钢铁侠，这个机器人会增加一些类似他的东西，因为有几个神经网络可以串联起来做一个个人助理。这种增强技术极大推动了计算机视觉的发展，你可以使用Keras中的生成器，基本上可以处理图像。

翻转它们，旋转它们，改变颜色，做各种事情来给你额外的训练数据，这在实际的训练集中并不存在。最近发布了一些东西，我实际上已经纳入了下学期的NVIDIA风格G2 AD，它使用增强技术为鉴别器提供更多的图像，以便在生成器学习创建假图像时使用，然后是强化学习，但超越TF代理，TF代理是我在这门课程中教授强化学习所使用的，我之所以选择它，主要是因为它与TensorFlow无缝连接。

我非常喜欢稳定基线，当你查看TF代理通常会出错的所有内容，比如他们的Atari示例，以及实验性示例。这些可能会或可能不会工作，稳定基线真的可以直接使用，给你一个很好的入门示例。

这里是如何玩Atari游戏的，这里是如何做其他事情的。接口要简单得多，不用暴露很多内部工作原理，而在这样一门入门课程中，我可能不想深入探讨，所以这也是我脑海中关于新技术的另一个考虑，编程语言。

现在这是一个关于Python没有很多竞争的领域。这门课程是基于Python的，Python在机器学习和深度学习方面确实占据了主导地位。数据科学也是如此，尽管在远处有其他语言在侵蚀Python的领域，请相信我。

我做这个已经很久了，Python 会落下。会有另一种语言变成时尚语言，而 Python 自从上升到现在的水平后。它会成为所谓的新 COBOL，正如 Java 目前享有的那样。所以还有其他语言。如果我必须说一种的话。

让我最感兴趣的是用 Go 替代 Python 在机器学习中的实际应用。Go 语言。但所有这些其他语言都在紧逼 Python，比如 Julia，甚至 Swift。信不信由你，我主要把它看作是一种移动语言。但我认为那里肯定有兴趣。我会说，Python 仍然会是核心的机器学习语言，持续一段时间，而在机器学习领域，这段时间大约是六个月。

两年，我不知道。所以你可能想考虑的其他语言是。iOS 应用开发，Defite Swift。Swift 是 iOS 应用编写的语言，Android 应用开发，Kotlin。我想这就是发音，Java。我对 Java 比对 Kotlin 更熟悉。基本上。

Kotlin 是建立在 Java 之上的一层，使其更现代化且减少打字。网页开发。Node.js 和 JavaScript。现在，你可以使用 Python 和 Django 进行网页开发，我之前使用过，但你无法逃避 JavaScript。JavaScript 是前端，你需要使用它，还有其他语言，比如 Ruby，可以让你稍微逃避一下。

但是，Java 有许多方言。Mac 应用开发。使用 Swift 或与 Electron 或 React Native 搭配的 JavaScript。如果你想创建一个真正的 Mac 应用，你会看到越来越少的应用。现在主要是移动或网页应用，但。有时你确实想要一个实际的应用，Windows 应用开发 C# 或使用 Electron 或 React Native 的 JavaScript。

你在这里看到了一种模式吗，Linux 应用开发。CC++ 搭配 TCL 或者使用 Electron 或 React Native 的 JavaScript。如果你使用过 VS Code，你就使用过 Electron。VS Code 在 Mac、Windows 和 Linux 上均可用。如果你想在这三种环境上创建应用，这是一个很好的方式。

因为你基本上可以只用 JavaScript。所以我会说在所有这些语言中，我对除了 Python 之外最感兴趣的是 JavaScript。这是我在 JavaScript 之外工作最多的语言，然后是 Python 之外的。😊然后还有 Node.js，本质上就是编译后的服务器端 JavaScript，这就是我对编程语言的看法，当我们开始 2021 年时，关于 PyTorch，这门课程是用 TensorFlow 和 Keras 教的，相信我，这是机器学习界的一个宗教辩论，我不妨问你有没有上帝，或者你投票给民主党还是共和党，自由派还是保守派。

这可能更符合美国的情况。而且在这个问题上我得到的回复相对较少。我经常收到邮件询问为什么不切换到 Pytorch，有些人甚至相当刻薄。因此人们对此非常激动。我创建这个 Kira 的 Tensorflow 课程的主要原因是。

其中有两个原因。首先，Pytorch 在我 2016 年创建这个课程时并不存在。我甚至没有听说过它。我听说过 torch，但那根本不是同一回事。另一个是，我喜欢 Pytorch，但它确实需要更多的输入，感觉就像机器学习框架中的 Java，这可能会让我受到一些批评和评论。但说实话，你必须为它添加更多的基础设施，并执行训练循环。

你可以做所有这些事情。然而，使用 Java 时，额外的层次让你的手指很痛，而 Pytorch 让你能够真正微调你所做的事情。这就是为什么 Pytorch 在研究领域取得了显著的进展。我认为这两者将继续竞争。而对我来说，切换到 Pytorch 意味着我觉得其中一个已经落后了，或者另一个。然而，当我在 2008 年首次接触机器学习时。

我当时非常坚定地选择 Java，后来我完全转向了 Python 等其他语言，接下来我建议你看看 Google Collab Pro。我有先进的 GPU，我也在云上使用 O。

但我仍然经常使用 Google Collab，因为 Google Collab Pro 让我可以使用 V100 NviDdia GPU。如果只是运行几个小时的任务，我常常喜欢这种灵活性，而不是打扰我的 R T X GPU，这可能正在进行长时间的训练任务，或者我可能只是想要这种灵活性。

谈到 Google Collab Pro，所以我非常喜欢 Google Collab Pro。我与 Google 完全没有关系。接下来你可能还想看看 Tensorflow 认证。我给你提供了一个链接，这样你就有东西可以展示了。向雇主展示你已经学习并掌握了这项技术，然后 Coursera 提到的其他可以放在你简历上的事情，现在你的简历上可以添加这些内容。

你的 LinkedIn 个人资料基本上需要建立起来。我想说的另一件事是，作为一个偶尔雇佣刚入职的大公司的人的人，获取实习机会，获得实际知识，参与项目，寻找你感兴趣的 Kaggle 竞赛，把你的作品推送到 GitHub，并获得一些领域知识。

有成千上万的人参加了Coursera的数据科学课程，他们中的许多人知道很多很多的东西。我和他们中的很多人交谈过，但许多人有时缺乏真正的世界经验。对我来说，真正有分量的是那些自己承担项目的人。Kaggle。

如果你想不到其他内容，可以研究一下这个领域，并学习如何将这些理论真正应用于现实数据。好的，我希望你真的喜欢这个课程。我知道我很享受准备这些视频和与你们的互动。

😊，Zoom用于Washo学生，其他互联网社区请留言。在这里给我评论，你想看到什么，我是不是疯了，是否应该将这个课程改为Pytorch，你最喜欢哪些新技术？在评论中告诉我，并一定要订阅频道。

在GitHub和Twitter上关注我，跟踪我正在进行的所有有趣的事情，至少对我来说是这样。感谢你跟随这个课程，不论你在深度学习和机器学习旅程中的下一步是什么。