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

ShowMeAI 人工智能工具笔记(十二)

使用 Scikit-learn 进行机器学习,4小时实战视角刷新知识框架,初学者进阶必备!<实战教程系列> - P8:8)混淆矩阵 - ShowMeAI - BV16u41127nr

嗨,在这个视频中,我可能会谈谈如何在训练数据上给我们的模型打分,打分将涉及学习一些新的指标和术语。事实证明有不同种类的错误,有时我们可能会更关心某种错误而不是另一种。

我们可能想用不同的指标来处理这个问题。为此,我有一些非常简单的虚拟数据。基本上我有这个数据框,其中有一列 x,x 列是数字,然后 y 列是布尔值,当 x 为正时为真,当 x 为负时为假,所以数据不多。为了简化,我试图将其分成前半部分和后半部分,我通常不会这样做,因为数据可能没有洗牌,可能我在尝试获取两半非常不同的数据,所以这只是一个示例,我得到了我的训练数据。

我在这里有我的测试数据,如果我想弄清楚 Y 和 x 之间的关系,然后衡量模型对该关系的理解,我将使用某种打分函数。对,我会做整个逻辑回归,记住这实际上并不是回归。

这实际上是一个分类器,因为我有这类分类数据要预测。所以我会训练其中一个,然后我想给它打分。第一步,没错,我会说 LR 等于逻辑回归。

对,然后我们说 Lr.t fit。当我拟合时,让我尝试运行这个。

一旦我运行,我实际上可以按 Shift + Tab 来获取提示。

我需要给它 X 数据和 y 数据,所以我会先从训练数据中提供这两样东西。

所以我会说训练数据,然后我想要的列就是 acts。然后我想要预测的其他东西就是为什么,哇,简直就是这样。

然后在我做完这些之后,我基本上可以运行一个很相似的命令,这个命令就是 score。我可以评估它在测试数据上的表现,得分是 0.75。那么这个 score 函数到底在做什么呢?事实证明它是一个快捷方式,我将给你展示一下文档里它的作用。我在这里看到 score 函数。

逻辑回归给了我平均准确率。如果你查看其他估计器,它们可能会使用其他类型的指标来评分。好的,所以平均准确率是这里的默认值,但实际上我们可以使用很多不同的指标,所以如果我去PsyKt学习的指标页面,我可以看到有一堆与分类聚类相关的指标,我们还没有讨论过,还有一堆与回归相关的指标,所以我现在使用的默认是准确率分数,你看到它是如何说的,我们只是得到了准确率,准确率很简单,就是在多少情况下?

我们做对了吗?所以我当然可以不用那个评分函数,我可以自己使用这个函数,我认为现在这样做是个好主意,因为一旦你理解如何手动使用这个而不依赖快捷方式,那么我们也将理解如何使用其他函数。好的,所以我可以看到这是我的指标子模块,因此当我回到这里时,我将这样做。

这是我刚才所在的页面。我将从SK学习指标开始导入。

准确率分数。好的,让我来运行一下我称之为准确率分数的内容。我在这里按下shift和tab。基本上,我在问,真正的值是什么?

我的模型预测了什么。好的,所以我可以用不同的方式来做这件事。我可以说,真正的值是A和B,但我实际预测了A和C。如果我这样做,结果我只对了50%。这是我的实际值和预测值。所以让我从上面获取这些值,之前我在尝试这个评分的东西。

然后我给出了我的x值和y值,所以我要从中提取一些内容。我将做的第一件事是确定预测值是什么。所以这些将是我实际必须调用的预测值,而不是评分。当我在预测时,我没有给它任何y值,预测告诉我y值是什么。

然后我还必须有我的实际值,对吧,我的实际值。刚好是之前的第二部分。在那一列。所以也许让我就这样做,我要看一下实际值和预测值。作为最后一步。好的。我可以看到实际是正确的,正确的,错误的,错误的。但我实际上得到的是正确的,错误的,错误的。

错误。所以第二个是错误,对吧,我将错误25%的时间。因此,准确率实际上将是70.5%,这就是我们之前看到的,当我们实际传入这些东西时。我传入了实际值和那些预测值。我得到的是75%。

好的,现在这样运作得很好,但有些情况下,我们不仅想知道自己对的频率,还想知道我们犯了什么样的错误。因此,举个例子,让我们想象这个Y列可能代表的不同事物,假设这个Y列意味着这是一个好的投资。

也许这是关于某个股票或其他东西。我不需要了解每一个好的投资。但如果我有某种系统,能告诉我“嘿,这些是一些不错的投资”,而且它总是正确的,尽管不告诉我每一个好的投资,那就是一个相当不错的系统。

也许这在告诉我,我不知道某人是否感染了新冠病毒之类的。在这种情况下,错误地说他们是感染者会更安全,即使他们实际上不是。因此,有不同类型的错误,假阳性和假阴性。因此,有许多基于此的指标,最简单的地方是从叫做混淆矩阵的东西开始,混淆矩阵。

显示了事物实际上属于的类别,以及它们是如何被错误分类为其他事物的。😊。

就像之前一样,我们有实际列表和预测列表,并且有混淆矩阵,我们将做同样的事情。想象一下,我有动物的图片,我有四只狗,三只猫和两只老鼠。但我有一些机器学习系统正在查看这些图片。

也许在预测这些其他事物时,我可以使用Psyit learn读取混淆矩阵,对吧,这也在指标下,和准确度分数一样。因此,我可以创建一个这样的矩阵。和准确度分数一样,我可以放入真实值和预测值,有时我说实际。

并且预测。这有点令人困惑,因为这些值每一个都在告诉我们,有多少类别落入特定的实际类别和预测类别中。并且不太清楚如何对齐,对吧,第一只狗是错的,还是猫?因此,人们通常会这样做,即他们会说标签。

并且为了控制顺序。例如,我想说像“狗”。“鼠标”,就这样。如果我传入这些标签,结果会有一点不同,对吧?而如果我说“狗”,你会看到这些数字稍微切换了一下,除了控制顺序以外,另一个原因是,我可能知道一些存在但在数据中没有出现的东西,对吧,比如没有马。

对吧?

所以,让我实际上。我真的想谈谈这些数字的含义,我觉得把它放入数据框会简单一些,我将把这放入混淆矩阵中。现在我需要将其放入数据框。一个PD数据框。混淆矩阵。

然后,当我从中打印数据框时,索引和列标签将是相同的,对吧,我将会有。E就像这样。

当我查看这个混淆矩阵时,这是什么意思呢?行表示实际情况。

而列将是它被分类的结果,所以我可以看到这里。对,有四只狗。在这四只狗中,它正确分类了三只,但其中一只狗被错误地识别为猫。好的。看起来系统中有三只猫,其中两只被正确识别为猫。

一只被认为是狗。我可以看到其他情况,比如系统对老鼠非常准确,它总是正确识别老鼠,而不会与其他任何东西混淆,所以这很有用。对,当我有这个时间矩阵时,我可以看到分类器在哪些方面存在混淆,因为它被称为混淆矩阵,显示了模型如何混淆。

好的,希望这对你有帮助,现在我们经常会遇到这些混淆矩阵。😊。

当类别不是不同的动物时,而是可能只是对和错,这将是二进制类别的火焰,我只有这些真实和虚假的值,所以让我回到之前计算准确性得分的内容。

让我在这里创建一个混淆矩阵,也许我只需复制一些内容。

在这里,你可能会抓住这个。

在这种情况下,标签是虚假和真实的。

这没有什么用,我有不同的类别,就像之前一样。我觉得将其放入数据框会很有帮助。

对。

我将这里放入一个数据框,就像这样。所以这里再次,行告诉我实际是什么,列告诉我这些是如何被分类的,理想情况下在完美的世界中,一切都将在对角线上,对吧,这意味着没有错误,也没有混淆。

好的,我有这些信息,结果这四个值各有特定名称,所以我会快速浏览一下。

呃。左上角的那个,实际上,让我们从右下角开始,所以如果我去,我去。让我把这个放在一个真实的数据框中。我的混淆矩阵现在是一个数据框。

好的,我去,我喜欢。1,1,这将是右下角。

这将被称为通过。你在实践中记住这些词的积极方面是重要术语。所以我将这样做,如果我在这个例子中聪明一点,我会确保所有这些数字都是不同的,这样我们可以更容易地识别。对,还有一个数字在左上角,那些是真阴性。对。

所以“真”意味着模型在正确地执行这个任务,好的,在这种情况下,我有。一个。你知道我真正应该做的是这样做。通过积极的。通过阴性。对,人们通常这样简写。然后是错误,好的。错误是假的,对,所以我会说是假。和假。

那么这些被称为什么?假阳性?好吧,那些在哪里?所以假阳性意味着。这一列是正确的,所以它应该是假的,这实际上在数据中是这样的。但是它被分类为真的,所以这意味着我在第0行第1列。然后我坐在这里,好的?有时。它实际上是真的,但模型说它是假的。

这是一个假阴性。

而且假阴性就是这样,所以这些是我会有的四种不同情况,接下来我们要看的很多统计数据是这些的组合,我会更多地讨论它们为什么有意义。

使用 Scikit-learn 进行机器学习,4小时实战视角刷新知识框架,初学者进阶必备!<实战教程系列> - P9:9)召回率和精度 - ShowMeAI - BV16u41127nr

在上一个视频中,我们学习了一些关于混淆矩阵的知识,混淆矩阵为我们提供了全貌。但我们常常希望用一两个数字来总结,而我们已经看到的最重要的数字之一是准确率。

准确率告诉我们模型出错的百分比。但当它出错时,它并没有真正告诉我们错误的类型。因此,我们将学习两个指标:召回率和精度,可以认为是数据子集上的准确率。它们的值仍会在0到1之间,但能帮助我们 pinpoint 实际出错的地方。

好的,回顾一下,这里是一个混淆矩阵。行表示数据的真实情况,列表示模型的预测情况。目前这些地方的值都是零。如果我看到一只真正的老鼠,而模型预测它是老鼠,我会在老鼠的行和老鼠的列将那个数字加一。

每当我们在混淆矩阵的对角线上增加数字时,这意味着我们做出了正确的决策。这里有一个错误决策的例子:如果我们的模型看到一张明显是狗的图片,但预测为猫,那我们会在狗的列和猫的列分别增加一次计数,这样我们可以在整个数据集上进行相同的操作。

从中,我们可能想要计算准确率,准确率就是我们正确的次数占总次数的百分比。我认为的计算方式是把对角线上的所有数字相加,那就是我们正确的数量,然后除以矩阵中的所有数字。结果是8除以10,即80%。值得注意的是,这个数字是部分占整体的比例,总是会在0到1之间,而准确率总是在分子中,所以1是最好的数字。精度和召回率具有相同的特性,但它们针对的是矩阵的不同子集,我们不会将整个对角线除以整个矩阵。

所以,精度和召回率实际上可以为每个类别计算这些指标。我有六个不同的指标,分别是狗的召回率、猫的召回率、老鼠的召回率,以及相应的狗的精度、猫的精度和老鼠的精度。有趣的是,我会查看这些指标中的几个,所以当我问猫的召回率是什么时。

我想知道的是,当我们实际有一只猫时,模型正确的概率是多少?

所以因为我在问实际情况是什么。我真正做的是在按行数字的总和进行分割。对吧,因为每一行代表了什么。数据实际上是什么。在这种情况下,分母将是这一行的总和,而分子将只是一个单一的数字,即在这个例子中我们到底多少次把猫称作猫,我们将得到2除以4,因此这实际上是记住召回率和精确度的一种更简单的方法,因为召回率有一个R,而行也有一个R。

如果我在看狗的召回率,好的,那么当我们实际上有一只狗时,模型正确的比例是多少,我只是在看那条顶部的狗行,并将狗的数量除以其他所有的总和,在这种情况下,当我们看到狗时,我们总是做得对,所以4除以4是100%的狗召回率。

精确度的问题问的是一些稍微不同的内容,我们这里问的是,假设对于狗的精确度,当模型预测它是一只狗时,正确的比例是多少?所以当我们查看所有预测时,我们实际上在谈论列,因为每个预测都沿着一列,在这种情况下我们在分割狗的左上方。

在狗的列中,我有我们预测的所有不同内容,当我们得到4除以6时。对于猫的精确度,我们通过猫的列进行分割,我们看到这里有完美的精确度,希望你能看到它们犯了不同种类的错误。对于猫,我们在精确度上表现很好,但我们有召回率问题;对于狗,则相反,我们有完美的召回率但较差的精确度,因此这两种指标实际上都展示了同一个问题,有时我们看到一只猫却认为它是一只狗。

相反的情况并不成立。我在这里不想多谈,但我只是想让你接触到这个。人们常常试图将这些数字简化为一个单一的分数。例如,有一种流行的机器学习方法叫做F1分数,许多这样的简单分数实际上只是其他指标(如精确度和召回率)的组合,因此这些可以看作是其他指标的基础构件。

让我去写一些代码。到Jupyter笔记本块。🤧。在这种情况下。

我将混淆矩阵转换为数据框,并在这里展示。

所以我和幻灯片中的一个有点相似,但现在数字更大了,我还有一匹马。所以对角线是好的,对吧?我可以看到这实际上做得还不错,对吧?我在对角线上有很多大数字。我看到有一个马的问题。当我看到一匹马时,它实际上90%的时间认为那是一只狗。这是我面临的另一个问题。

对,我看到的那个不在对角线上的大数字就在这里。大约一半的猫被错误分类为狗。

好吧,这有问题,所以我打算看看我已经生成的混淆矩阵。我想查看准确率、召回率和精确率,然后最后介绍这个新的指标——平衡得分。😊,所以首先,让我们看看准确率。我将运行准确率。

我需要输入实际值和预测值。所以我会使用实际值和预测值,这两份列表是我用来构建混淆矩阵的。我看到,哦,让我再运行一次。我看到准确率是78,嗯,大约是80%。这看起来相当不错,关键要注意的是,当我们有这么多不同的类别时,整体上似乎表现良好。

但可能会有一些情况我们犯了很多错误,比如当我们看到猫时,我们一半的时间是错的,尤其是当我们看到马时,我们90%的时间是错的,因此这些其他指标将帮助我们再次深入分析并识别这些问题。好吧,所以假设我想查看马的召回率。

我期待看到马时的准确率是10%。所以我们只知道10%的时间。可以这样做:我可以从混淆矩阵中获取马的值。对,从右下角的值。然后我可以将其除以马行中的所有值之和。对,我可以这样做。

我得到了10%,正如我预期的那样,正确的方法是使用这个精确率函数,它实际上是内置于K学习中的。对。我将调用这个函数。所以我有真实值和预测值。我会说实际值和预测值。然后我在这里实际上得到了一个错误。

它在抱怨所谓的多类与二类的问题。这些指标是为简单情况设置的,其中我们的两个类只是假和真,而不是像狗、猫、马这样的四个类别。所以我需要稍微清理一下。我可能会这样做。哦,首先。

让我稍微扩展一下,我需要更改这个平均值。有几种方式来总结信息。我将平均设置为无。我理解这样做的一些效果。与上面可能不一样。然后它实际上给了我四个召回值。每个分类一个。顺序可能与这里的不一样。

所以我实际上也要传入这些标签,以确保我可以将这些数字与不同的值进行比较。好的,我在这里看到的是,实际上我想先计算召回率,抱歉。我先计算召回率。因此,对于这个召回率,逐行检查,我发现狗的召回率是完美的,我看到一只狗。模型把它识别为狗,老鼠也是完美的,看到老鼠时,它会将其识别为老鼠。

对于猫来说,如果它看到一只猫,50% 的概率能正确识别,然后对于马,只有10%的概率能正确识别。好的,这就是我的四个召回率数字。有时我想做的是计算一个总的平均值,以了解我的整体表现。我得到65%的结果。结果发现,这个召回得分的平均值有一个特殊的名称。

这个特殊的名称是平衡准确率。对了。在这之前,准确率显示我们做得很好,达到了80%。但现在我实际上计算这个平衡准确率,它只有65%,差得多,从某种意义上说,这更有意义。我们之前的高准确率唯一的原因是我们看到的马非常少,即使我们的模型对马的识别效果很差。

我们可以简单地说,在模型中马并不多,所以当我们使用这些平衡指标时,它试图考虑到这一点。虽然我们有更多的狗,但我们实际上会把这四个类别视为同等重要,以得出我们的评分。

如果你的数据集中存在较大的不平衡,这将是一个很好的指标。在这种情况下,准确率可能会有些误导。好的,那是召回得分。让我类似地处理一下。所以我实际上要计算精确度。我想我之前已经在做了,哦。早些时候不小心这样做了。发生了什么呢?好了。

所以我将粘贴这个,然后我会得到这个精确度得分。

现在我看到一些不同的情况,没错,我发现实际上在所有方面我们都做得很好。除了狗。为什么会这样呢?当我谈论精确度时,我实际上是逐列检查的,我看到的确是很不错,除了对角线,我在每一列中只看到零。

这意味着如果这个模型预测的是猫、老鼠或马,它可能只在预测狗时才正确。在这种情况下,它只有三分之二的概率确实是狗。因此,这个模型非常喜欢预测狗。😊如果它预测其他东西,确保它预测的是狗,它的把握只有三分之二。

好的,所以我们谈到了准确率、召回率和平衡准确率。平衡准确率是召回率的平均值,然后是精确度。

我想谈的最后一件事是二元分类,对于二元分类,我们只需使用,而不是猫、狗和老鼠。

所以我在这里计算混淆矩阵,如果我想,我可以。

我可以像以前一样计算这些相同的指标,所以例如,如果我计算召回率。

在这里,我可以将作为我的标签传入。

为什么那样不高兴,可能是因为我还没有运行这个,好了,我可以运行它,它告诉我,好的,逐行来看,第一行。

三分之一是轨道,对吧,所以第二个是70%正确,对吧,这就是我的两个召回率,所以我可以像以前一样做,但事实证明在处理二元分类指标时,人们常常只谈论预测,我很抱歉。

他们通常只谈论召回率和精确率,而没有具体说明他们指的是什么类,而当他们这样做时,他们所谈论的是正类。所以如果我仅仅谈论召回率,总的来说,哦,我不想那样,我只是想谈论召回率,总的来说看,我在谈论正类,精确率也是如此,实际上这可能是你看到的召回率和精确率的大多数特殊情况。

在进行二元分类时,请知道我们是在谈论正类。

使用Scikit-learn进行机器学习,4小时实战视角刷新知识框架,初学者进阶必备!<实战教程系列> - P7:7)决策边界 - ShowMeAI - BV16u41127nr

是的。大家好,在这个视频中,我想谈谈如何可视化分类器在进行回归时所做的决策或预测。我们通常通过绘制拟合线来可视化,而这里的等效方法是,当我们有两个特征时,我们通常会在X轴和Y轴上绘制这两个特征,然后将区域分成两个不同的区域,一个是我们预测为真的区域,另一个是我们预测为假的区域。因此,我们在Mapllib中使用的函数叫做contour F,它可以做到这种绘图,因此我们想要评估CLS,想法是我们想要输入一些不同的值。

对于Sepple a,我会把它放在y轴上,而SPL宽度则放在X轴上。因此,获取每种组合的最简单方法可能是使用numpy的网格。

我使用meshcr的原因是它创建了一些不同组合的数组,正好是我稍后需要的形式。因此,创建了数组并为Contour ath所需的形式做好准备。所以让我在这里留个评论。它将返回什么呢?它试图返回两个数组。它将返回一个。即。

我其中一个变量将在另一个变量中。所以也许我会先把sel宽度放在前面,然后是sepel长度。然后我在这里要做的是需要一个范围,所以我会有range1和range2。实际上,网格代码将给我这两个范围的每种组合。

所以在这里我会说NP范围。也许它们会从0到10,可能是0.1的步长。然后这里也是同样的情况。好的,我有这两个,让我看看这些东西的样子。

我看到这两个都是一个2x2的矩阵,显示每种组合。所以让我再看看另一个。这些形状完全相同,其中的值只是给出坐标,因此第一个给我的是x坐标,基本上是Sepple宽度,另一个则是y坐标或sepple长度。

如果我想的话,我可以调用Plt。cont F。

这涉及到三个方面,它必须有我的x坐标矩阵,并且必须有我的y坐标矩阵。然后有一个指示颜色的变量。这样可以作为某种替代表达。因此我可以说,如果我想要sple W,这将显示从左到右的一些条纹。

或者我可以做SL,这将向我显示垂直,或者我可以有某种数学表达式,就像这样。

在每一个点上,它向我展示如果我将其中一个值与另一个值相乘会发生什么。所以我可以得到这些漂亮的轮廓图。现在我真正想做的是只拥有两个级别,两个数字。我想让我给你展示一下现在的情况。

哦。很多不同的数字,我只想在这里有两个数字。基本上是一个和零,分别对应于预测。所以我的x轴将是宽度,y轴将是长度。

所以我必须将所有这些数据放入一个格式中,以便我可以进行一些预测。让我暂时把这留在这里,可能会回来看看。这是我努力的目标。

哦。

我想做的是将这些东西放入一个数据框中。所以我将说这将是我的轮廓数据框,我将说PD数据框。我的数据框必须包含所有这些内容。因为我想对它进行预测,这些是我的X列。

而且有人会为此准备一些东西。哦。让我为此准备一些东西。然后我先处理我的内容,这很简单,只有一个。这些值。我可以从这些中提取,所以我可以把它放在这里。然后我可以把它放在这里。如果我想的话,我可以放上Sap W。现在这并不太有效,因为这些是那些。

基本上是平方矩阵。在这里,我要把所有这些放入数据框中,以便可以进行预测。它必须只是一个简单的列,所以我需要将其展平。所以这只是某种一维的,我可以这样做,然后我可以查看我的CDF。如果我愿意的话。我可以看到这里发生的事情是我确实拥有每个长度和宽度的组合。

然后我有我的常量列。所以这并不是一个适合我进行预测的格式,因为我可以说它包含了我预测所需的所有内容。我可以说CLS。predict。就这样。然后我会得到所有这些值。

如果我愿意,我也可以将它们添加到那个数据框中,我可以说CDF。我可以说预测,也许我只会说一个预测。我记得那是我试图预测的踏板湿度。我可以说,或者对不起,那是类别,它是Sentosa还是不是,对吧,所以这就是我试图做的。好的。

所以我有了这个。现在我想继续进行我的工作。

哦。在我下面的轮廓图中,对吧,所以我可以这样。让我仔细想一下,所以如果我有我的集W。让我看看这些的形状。

这是一个100乘100的矩阵。因为这是我绘制超过100个数字的范围。这个100乘100的矩阵,这个100乘100的矩阵现在只是一个长列,所以就像我必须把这些矩阵转换成列一样,现在我必须朝相反的方向进行,我必须提取值并重塑它。

为了与这些格式匹配,正确,所以我实际上可以直接使用这些。并且说,我的预测应该与我的x值的形状一致,我会很好地对齐。所以我可以这样做,现在我可以看到这两侧都对应于它是全为sattosa或非sattosa的预测。

让我在这里的顶部用散点图绘制这些。

我这里有我的所有原始花朵的数据框,我可以绘制所有这些。理想情况下,我只会在此基础上绘制训练数据,这样我可以更好地了解出现的错误。但是我只有大约10行的测试数据,所以我将绘制整个内容。因此,我将说点绘制散点图,实际上我想做的是将其分开,所以我将会有像sattosa。点绘图。tcatter,然后我将会有像其他点绘图。散点图。

然后我可以通过一些过滤器获得这些。现在,我会说Sotosa等于数据框。我们的数据框的种类。R等于Ctosa。然后我的其他项基本上是那些不是的。所以我会说它不是sattosa。好的,我将在这里做什么呢?好吧,我可以说我的x值将会是。哦。好吧。

我在这里放了sple宽度,所以我最好在我的X轴上放这个。然后我的Y轴应该是sepple长度。好的,我将这样做,并且我将对这里的同样事情做一会儿,我看到好吧,我有我的决策边界,然后我在下面有两个单独的图。

我希望这些都在同一个图上。通常我们处理这种情况的方法是,我们会说AI X等于这个,然后把它传递下去。让我快速展示一下,如果我这样做,Ax的类型会是什么。这就是这里的东西。这种四重轮廓集,我们可以在其上绘图。所以如果我想重复使用相同的aupplot区域,我实际上可以说matplotlib执行当前坐标轴,这将给我一个我可以在其他地方传递的子图。

好吧,我可以在这里说,我可以说。啊。也许我会继续下一行,说 AX 等于那个和。

这里也是一样,所以它们都会进入同一区域。让我这样做,所以我有了所有这些点。

和。

现在我喜欢做的事情是,嗯,奇怪的是它没有重叠。

那个边界。

我搞混了我的坐标轴吗?我确实搞混了。所以这里是一个带有分隔光的示例。好的,很好。那么让我把这个切换回来。

所以这应该是 Sple A,而这应该是 Sple width。

现在我实际上可以看到如何尝试分开那些与那些不同的东西,所以为了让这个工作,我应该让颜色在某种程度上有所不同,所以我会让 Sattosa 为 R。

然后也许我会让其他的变成。我不知道,也许它可以很好。

就这样,现在我可以开始看到会犯哪些错误。我可以看到有一个 Sattosa 不会被识别为 Sattosa,因为它在这个边界的错误一侧。我可能还应该在这里加上一些标签,所以我们可以说像 label 等于 Sattosa,然后在这里我可能会说 label 等于。

Equs 其他。

就这样,我现在可以看到这里发生了什么,所以这有几个步骤,也许我可以删除这些额外的东西,这样我可以有一个最小的示例。我必须创建一个网格。

基本上,对于每个点,一个网格有 x 值,另一个有 y 值。我必须把它们重新形状并转换成数据框列。到那时,我实际上在某一行中有这些的每一种组合。一旦我这样做了,我可以为我们的推荐系统添加预测。

然后,如果我把我的预测转换回网格公式,就像这两个有的那样。我就可以进行我的等高线绘制。

这就是我如何创建这个地图的方式。然后在这之上,我可以绘制我的散点图,看看发生了什么。我想做的最后一件事是,我想尝试做一些多项式特征。所以就像我们可以使用多项式特征一样。

或者常规回归,我也可以将它们用于分类。所以让我导入一些。我可能会说,从SK学习。

Dot pipeline导入pipeline,我可能会说从SKL做预处理。我将说导入多项式特征。

好的,那么之前我有什么呢,我有,我只是有一个这样的逻辑回归。嗯。好吧,那是什么呢,之前是什么。

我只是想在之前的页面中搜索一下,我想那是一个拟合截距的东西。

我把它都关闭了,抱歉。所以我之前的模型是这样的。这将是管道的一部分,对吧?所以现在我要说pipe。等于pipeline。而管道将是这组阶段的列表。就像这样。因此,这将是第一阶段。抱歉,这将是最后阶段,然后在那之前我想要我的多项式特征。

就这样。然后另一个技巧是,我的管道每个状态都必须是一个元组。之所以必须是元组,是因为我必须给它一个名字,对吧。所以我想我就叫它polyly。然后我会叫这个LR。所以我就把它直观化了。因此,就像之前一样,我可以有我的,之前我有类似于F的东西。然后我有。

X列的训练,然后训练我的Y列,我想那是。

我想这将是我的花瓣宽度,所以让我就复制给你。

就是这样,但它是petedal we。这是我之前做的。我可以把我的逻辑回归替换为这个管道。让我试试这个,我得到了某种错误。

未知标签类型为连续。哦,抱歉。我正在尝试预测它是否是Sctosa。对,它抱怨是因为它是连续的。所以它在说,嘿,你在试图做分类。

在一个我们不进行分类的量上,我们对数量进行回归。所以我想说的是Ctosa,它是sattosa吗,这正是我关心的。

然后我训练它,这一切都很好。现在如果我想的话,我可以回到这里,重复这些步骤,所以如果我愿意,可能我只是想把这一切都移动到这里。

然后当我绘制这个图时,当我想查看那些带有决策边界的图时,不再使用我之前简单的分类器,而是可以使用我的管道分类器。而且这条边界线在它们之间只是稍微弯曲了一些。

这并没有太大帮助,因为红点仍在错误的一侧。

但是你可以看到,依据模型的复杂性和我之前的流程,我可以得到不同的形状。

官方教程来了!5 位 Hugging Face 工程师带你了解 Transformers 原理细节及 NLP 任务应用!<官方教程系列> - P1:L1.1 - 欢迎来到 Hugging Face 课程 - ShowMeAI - BV1Jm4y1X7UL

欢迎来到 Aing F 课程。该课程旨在教你关于 Uface 生态系统的所有知识。我们将其用作 Se Me 中心,以及开源库。以下是目录。正如你所见,课程分为三个部分,难度逐渐增加。目前,只有第一部分已发布。

这将教你如何使用变换器模型的基础知识,如何在自己的数据集上微调,并将结果分享给社区。我们正在积极工作于接下来的两个部分。我们心中的大致时间线是计划在 2021 年秋季发布第二部分,最后一部分在 2021 年底和 2022 年初发布。希望这只是预计,所以不要准备得太早。

第一章不需要技术知识,是了解迁移模型能做什么以及它们如何对你或你的公司有用的良好介绍。接下来的几章需要良好的 Python 知识,以及基本的机器学习和深度学习知识。

如果你不知道训练集和验证集是什么,或者什么是梯度下降,你应该看看一些入门课程,比如由深度学习研究院发布的课程。最好如果你对某个深度学习框架(如 PyTorch 或 TensorFlow)有一些基础知识。这门课程中介绍的每一部分材料在这两个框架中都有对应版本。

所以我们能够选择你最熟悉的那一个。这是开发本课程的团队。现在我将让每位讲者简要自我介绍。

嗨,我叫马修,我是 Hugging Face 的机器学习工程师。我在开源团队工作,负责维护那里的 TensorFlow 代码。之前,我在 Parsley 担任机器学习工程师,该公司最近被 Auto 收购。在那之前,我是在爱尔兰都柏林三一学院的博士后研究员,研究计算遗传学和视网膜疾病。

😊,嗨,我是亚历山大,我是 Hugging Face 的机器工程师。我专门在开源团队工作。我在 Hugging Face 工作了几年,和我的团队成员一起开发了本课程中大部分工具。😊,嗨,我是西尔万,我是 TechFase 的研究工程师,也是 Transformers 库的主要维护者之一。之前,我在 FAA AI 工作,帮助开发 FastAI 库以及在线 M。

在此之前,我是一名在法国教授数学和计算机科学的老师。是的。

官方教程来了!5 位 Hugging Face 工程师带你了解 Transformers 原理细节及 NLP 任务应用!<官方教程系列> - P8:L2.1- 管道函数内部会发生什么?(PyTorch) - ShowMeAI - BV1Jm4y1X7UL

函数内部发生了什么?在这个视频中,我们将看看当使用 Transforms 库的管道函数时实际发生了什么。现在特别地,我们将看看情感分析管道,然后它从以下两个句子中得出正负标签的相应分数。

正如我们在管道计划演示中看到的,管道中有三个阶段。首先,我们将一个顶点转换为模型可以使用的数字,通过 tokenizer。然后这些数字通过模型输出。最后,第一处理步骤将 Vo gate 转换为标签和分数。

让我们详细看看这三步以及如何复制它们在 Transformers 库中的音乐。首先从第一个阶段的标记化开始。所以组织过程有几个步骤,首先将文本拆分为称为标记的小块。它们可以是单词、单词的一部分或标点符号。然后,tokenizer 如果模型预期会添加一些特殊标记。

模型期待在句子的开头有一个 seal token,在句子的结尾有一个 sep token 进行分类。最后,tokenazer 将每个 token 匹配到所描绘模型词汇中的唯一 ID。要加载这样的 tokenizer,Transformers 库提供了 Utokenizer API。这个类最重要的方法是 from Pretrained。

这将下载并缓存与给定检查点相关的配置和词汇。这里,情感分析管道默认使用的检查点是基于 distber 的微调 SS2 英文。这有点冗长。我们实例化与检查点相关的 token,并将其输入到两个句子中。由于这两个句子的大小不同。

我们需要填充最后一个以便能够构建一个数组。这是通过 tokenizer 完成的,选项填充为 true。通过 truation 等于 2,我们确保任何比最大中间长度长的句子都会被截断。最后,返回 tensil 选项告诉 tokenizer 返回批处理 tensil。看结果。

我们看到我们有一个包含两个键的字典,输入 ID 包含两个句子的想法,填充应用的位置为零。第二个键注意掩码指示了填充的位置,以便模型不关注它。这就是标记步骤中的所有内容。现在让我们看看第二步。三もど。也如同一个。

有一个 notomod API,使用 pretrain 方法。它将下载并缓存模型的配置以及预训练权重。然而,Automod API 只会实例化模型的主体,也就是在去掉预训练头之后剩下的部分。

它将输出一个高维张量,即句子过去的表示,但对于我们的分类程序来说并不直接有用。在这里,张量包含两个句子,每个句子有16个标记,最后一个维度是我们模型的印度大小,768。为了得到与我们的分类问题相关的输出。

我们需要使用Automodal进行序列分类类。它的工作方式与模型类完全相同,除了它构建了一个带有分类头的模型。😊在transformers库中,每个常见的NLP任务都有一个自动类。在这里,在给出两个句子的所有模型后,我们得到一个大小为2乘2的张量。

每个句子和每个可能级别的一个结果。这些输出尚未是概率,我们可以看到它们的总和不为1。这是因为每个transformers库的模型返回的是这样的结果。要理解这些结果,我们需要深入探讨管道的第三个也是最后一个步骤,处理。为了将其转化为概率,我们需要对它们应用softmax层。

正如我们所看到的,这将它们转换为正数,最多为1。最后一步是知道其中哪个对应于正标签或负标签。这是通过模型的I2lipol字段给出的。第一个概率ba的索引0对应于负级别,第二个索引1对应于正级别。

这就是我们的分类器如何通过管道函数构建,带有标签并计算这些分数。😊现在你知道每个步骤是如何工作的,你可以轻松调整它们以满足你的需求。

官方教程来了!5位 Hugging Face 工程师带你了解 Transformers 原理细节及 NLP 任务应用!<官方教程系列> - P29:L4.6- TensorFlow 预测和评估指标 - ShowMeAI - BV1Jm4y1X7UL

在我们其他的视频中,和往常一样,如果你想查看这些,下面会有链接。我们展示了如何在 Tensorflow 中初始化和微调一个 transformer 模型。那么现在的问题是,训练后我们可以用这个模型做什么?显然要尝试的是用它对新数据进行预测。那么让我们看看怎么做,再次,如果你熟悉 Kais。

好消息是,因为这些只是标准 caris 模型,我们可以使用标准的 Keis 预测方法,如此处所示。😊。你只需将标记化的文本传递给这个方法,就像你从标记器中得到的结果一样,你就能获得你的结果。我们的模型可以根据你设置的选项输出几种不同的内容。

但大多数时候,你想要的东西是输出 logts。如果你之前没有遇到过,它们有时被称为 logits,因为没有人确定,它们是网络最后一层的输出,因为在应用 softm 之前。所以如果你想将 logics 转换为模型的概率输出。

你只需像这样应用一个 softm。那么如果我们想把这些概率转化为类预测呢?再次,这非常简单。我们只需为每个输出选择最大的概率,并且你可以立即通过 Argm 函数获得这一结果。Argmax 将返回每一行中最大概率的索引。

这意味着它将得到一个整数向量,如果最大概率在第零位置,则为 0,在第一位置则为 1,依此类推。因此这些是我们的类预测,表示类 0,类 1 等。实际上,如果你只想要类预测,你可以完全跳过 softm 步骤,因为最大 logits 总是最大概率。

😊,所以如果你只想要概率和类预测,那么此时你已经看到了所有需要的内容。但如果你对基准测试你的模型或用于研究感兴趣,你可能想深入探讨一下你得到的结果,计算模型预测的一些指标是一种方法。

如果你正在跟随我们数据集和微调视频,我们的数据来自 MRRPC 数据集,它是 blue 基准的一部分。每个 blue 数据集,以及我们数据集灯塔中的许多其他数据集都有一些预定义的指标,我们可以使用数据集的加载指标函数轻松加载它们。

对于 M 或 PC 数据集,内置指标是准确率,衡量模型预测正确的时间百分比,以及 F1 分数,这是一种稍微复杂的度量,衡量模型在精确率和召回率之间的权衡。为了计算这些指标来基准我们的模型,我们只需将模型的预测与真实标签进行对比,便能简单地得到结果。

😊,不过如果你熟悉 Keras,你可能会注意到,这是一种计算指标的稍微奇怪的方法,因为我们只在训练结束时计算指标。但在 Keras 中,你可以在训练过程中实时计算多种指标。

这让你对训练进展有非常有用的洞察。所以如果你想使用内置指标,这非常简单,你再次使用标准的 Keras 方法。你只需将指标参数传递给编译方法。与损失和优化器类似,你可以通过字符串指定所需的指标,或者导入实际的指标对象并传递具体参数给它们。

但请注意,与损失和准确率不同,你必须将指标作为列表提供。即使你只想要一个指标。一旦模型编译了一个指标,它将报告该指标用于训练、验证和预测。假设有标签传递给预测,你甚至可以编写自己的指标类。

虽然这有点超出本课程的范围,但我会在下面链接相关的 TensorFlow 文档,因为如果你想要一个在 Caris 中不受支持的指标(如 F1 分数),这将非常方便。

官方教程来了!5位 Hugging Face 工程师带你了解 Transformers 原理细节及 NLP 任务应用!<官方教程系列> - P34:L6.2- Lewis 的在线直播讲解 - ShowMeAI - BV1Jm4y1X7UL

所以这次会议的基本目标是一起阅读第二章,在这一章中,我们将深入探讨变换器库的内部,特别是我们将关注模型的类型。有一组模型 API 我们将要查看,同时也会看到我们在将文本转换为模型可以处理的格式时所依赖的分词器。

在第一课中你看到我们有一个管道 API。这个管道 API 基本上封装了文本的预处理和后处理的所有复杂性,同时也将其适配到模型中,这样你只需要简单地给它一句话,然后就可以进行分类。

比如情感分析。今天我们希望解读这个函数内部发生了什么,并理解你可以采用的一些不同方法来对文本进行分词,以及如何保存和加载模型和标记。

我们将通过查看在处理长度不同的句子或文本时需要做的事情来结束这节课。因为在 pytorch 和 Tensorflow 以及大多数深度学习框架中,我们需要一种标准化的矩形输入格式供我们的模型使用。基本上我们将通过讲解各个部分然后暂停提问来进行。

但在此期间,如果你有一些非常紧急的问题想要询问,Omar 会在这里提供指导。所以让我给你一个高层次的概念,展示我们将要覆盖的内容。变换器库中的每一个模型都有一个相应的建模文件。例如,我现在查看的是 BERT 的建模文件。

这个文件包含了所有不同任务的源代码,你可以使用 BRT。例如,如果我查找 Vt 模型,这就是我们今天要关注的基本类,它负责基本上创建输入的上下文嵌入。那么我们如何创建一些具有意义的文本的数值表示呢?这个类相对简单,它只有嵌入层,你在第一章看到过,所以我们在进入变换器堆栈之前传递的内容,然后我们有一个编码器,这个编码器本质上负责将这些标记或标记嵌入转换为这些上下文化的表示。

我建议你对这些代码进行一些研究,因此今天我们使用的任何类,例如BERT模型,都可以查看其源代码,这真的有助于理解transformers的工作原理。对我来说,只有逐步了解所有输入如何通过前向传递,才能真正理解transformer的所有工作机制。

这只是一个小插曲。因此,为了开始,或许我们可以看看在pipeline后面实际发生了什么,来启动这个视频。

pipelinebra函数内部发生了什么?在这个视频中,我们将深入探讨使用transformers库的pipeline函数时实际发生的事情。我们将特别关注情感分析pipeline。它的正面和负面标签对应于以下两个句子的分数。

正如我们在演示中所说,pipeline中有三个阶段。首先,我们使用分词器将词汇转换为模型可以理解的数字。然后,这些数字通过模型输出。最后,第一步处理将输出转换为标签和分数。

让我们详细了解这三个步骤以及如何使用Transformers库复制它们,首先是分词阶段。该过程有几个步骤,首先将文本拆分为称为tokens的小块。这些可以是单词、单词的一部分或标点符号,如果模型预期的话,分词器会添加一些特殊的tokens。

这里,中间模型期望在句子开头有一个起始token,句子末尾有一个分隔token。最后,分词器将每个token映射到其在模型词汇中的唯一ID。要加载分词器,transformers库提供了Utokenizer API。这个类中最重要的方法是from_pretrained。

它将下载并缓存与给定检查点相关的配置和词汇。在这里,情感分析pipeline默认使用的检查点是distilbert-base-uncased-finetuned-sst-2-english,听起来有点复杂。我们实例化与检查点相关的token,并将其输入到两个句子中。由于这两个句子大小不同,我们需要对较小的句子进行填充,以便构建数组。

这是通过分词器以padding选项完成的。使用truncation=2,我们确保任何超过模型最大处理能力的句子都会被截断。最后,return_tensors选项告诉分词器返回批次张量。结果,我们看到我们有一个字典,其中两个键input_ids包含了两个句子的ID,零则是填充的位置。

第二个关键注意力掩码指示已经应用了哪种处理,以便模型不对其进行关注。这就是took步骤中的所有内容。现在我们来看看第二步。三ほど。作为一个提供预训练方法的notomodal API,它将下载lu并缓存模型的配置。

以及pertrain权重。然而,Automod API只会实例化模型的主体。即在去除pro traininging头后剩下的模型部分。它将输出一个高维张量,表示句子的过去,但对于我们的分类产品并没有直接用处。这里的张量有两个句子。

每个16个标记,最后一个维度是我们模型的印度大小768。为了获得与我们的分类问题相关的输出链接,我们需要使用Automodal进行序列分类类。它的工作方式与您使用的模型类完全相同,只是构建了一个带分类头的模型。😊。

对于transformers库中每个常见的NLP任务,赞扬一个自动分类。在这里,给出两个句子的所有模型后,我们得到一个2x2的结果,每个句子和每个可能的级别。这些输出还不是概率,我们可以看到它们的总和不为1。这是因为transformers库中的每个模型返回的是look it。

要理解look it,我们需要深入管道的第三个也是最后一个步骤。加上处理。要将LoAT转化为概率,我们需要对它们应用softmax层。正如我们所见,这将它们转化为一个正数,总和为1。所以最后一步是知道这些对应于正标签还是负标签。

这是由模型conflictg的IT2lipal字段给出的。第一个概率是index0,对应负标签,第二个index1对应正标签。这就是我们构建的分类器如何使用管道函数与标签进行交互并计算这些分数。😊,现在您知道每个步骤是如何工作的,您可以轻松地根据需要进行调整。

那么。让我们看看。好的,所以在这个阶段我们对管道还有什么问题吗?

所以我们看到的一件事是有这三种成分。这里有一个预处理阶段。好的,太好了,所以我们第一个问题是能否请您解释一下BRT SST2英语检查点背后的直觉是什么,以及有哪些不同类型的检查点可以使用,为什么我们选择SST2。好的,总的来说,每个transformer模型。

他们有预训练的基础或预训练的骨干,我想你在第一章看到了。然后我们通常会对像BERT和GP这样的模型进行下游任务的微调。所以基本思路是,你拿例如在维基百科和书籍语料库上进行预训练的BERT,然后说。好的,我现在想进行分类,所以我将基本上使用原始模型中的这些权重,然后添加一个分类头,它基本上是一个线性层,可以让我们进行分类任务,然后我们在特定任务上进行微调。

所以如果你想了解一下如何进行。

模型的工作原理或模型的描述。如果我们看看Bert,这家伙叫什么来着。这是Bt。三八八八。无大小写,微调。无大小写。未微调。嗯。那么它是S。那是什么。微调的distber,好吧。仍然是无大小写,微调。我这里漏掉了什么?😔。Distill B面和大小写功能指示。如果我们看看这个。

然后我们可以看到这是一个在特定任务上进行微调的检查点。所以这个任务叫做T bank任务。

二元分类基准,我记得这就像一个情感分析任务,只有两个标签,如正面或负面。我们选择这个的基本原因是,我们只是想展示情感分析的管道如何工作,这是一个非常适合该任务的模型。

所以我希望这能回答你的问题,DK creative。然后我们还有另一个问题,就是在这种情况下。我们假设只有两个类别用于分类。我们如何指定多类别问题,以及会使用什么检查点?好的,很好。这是一个非常好的问题。所以也许我们可以看看这一章的内容。

在这里,我们有一个情感分析管道。显然,它只会预测两个类别。现在我将实例化分词器。下面是模型。好的,如果我们看看模型。😊,每个模型都有一个配置。这个配置告诉你一些信息,例如类别数量。

所以你可以看到这里有两个类别。当你实例化模型时,可以定义你希望的类别数量,用于文本分类。为了给你一个例子。假设我使用一个多类别的检查点。现在我要做两件事,我将首先展示给你。

我们如何让模型以便我们能够自己微调。然后我会展示一个更简单的案例,即我们有一个现有的预训练模型。如果我没有,假设我只有自己的数据集,而在中心没有适合我想做的模型。那我可能会说,好吧,我要使用distillbert base uncased。

这只是预训练模型,没有什么特别之处。我仍然需要做一些工作。然后我可以说,好吧,我要做的第一件事是从transformers导入一个自动模型,但现在我要为序列分类来做。

所以在处理文本分类或多类多标签时,这是一个序列分类任务。接下来我会使用我的序列分类模型。然后我可以从预训练开始。我拿到我的检查点,现在是这个新的模型。

然后我可以传递关键字参数,这将指定我正在处理多少个标签,所以想象一下我的数据集有六个类别。我可以说标签的数量是六。那么接下来会发生什么呢?

它会下载distillvert的基础模型或预训练模型,然后在这个模型上添加一个分类头,并用正确的类别数量进行配置,以便我们能够适当地进行微调。所以现在如果我们查看配置,你会发现它已经用六个不同的类别初始化了模型。

我们还不知道标签,因为我们还没有提供自己的数据集和标签约定。但我们可以做到这一点。然后从这里我们可以微调和训练模型,就像我们已经做的那样,或者在下一章中我们将要做的那样,所以这是一种方法。现在,问题的另一部分是,我如何从中心获取一个预训练模型或微调模型?

这就有点难以弄清楚,哪个模型适合你的任务。所以我通常的方法是,举个例子,查看文本分类。所以我在这里对文本分类进行过滤。然后我问自己,好吧,也许我正在处理,让我们看看。现在,这不是那么容易找到一个多类的例子,所以。我想。

一般来说。是的,所以。实际上,找到适合你任务的多类模型需要一些工作。我是说,也许奥马尔已经知道一种快速获取的方法,但一般来说,我们这里所有的模型在某种意义上都是针对一个任务进行了微调的。例如,这个德国情感Bt,可能有两个类别,一种快速检查的方法是查看文件和版本,看看配置中有多少个标签,在这个案例中有三个标签。

但实际上在 H 上有效地搜索这个,我不确定,也许有办法做到这一点。或者也许这是我们应该在中心添加的一个好功能。我是霍姆斯,我希望这部分回答了你的问题。如果没有,那就请随时在聊天中写下你的问题。是的,没错,我们应该添加一个功能,基本上我认为我们想要的是一个过滤器,可以在二元分类、多类和多级之间进行过滤,这样我们就能更好地细化内容,问题很好,太棒了。

😊 好的,在我们更深入地看一下代码之前,还有关于管道的其他问题吗?

好的,在这种情况下,让我们通过这个管道的示例来更深入地理解发生了什么。所以我们有了这个示例,我们基本上正在下载情感分析管道。

现在我们有了分类器,可以将你在前面的章节中看到的这两段文本输入进去。但现在我们想做的是理解到底发生了什么,所以请记住,我们需要处理或预处理这些原始文本,因为。

基本上所有神经网络都无法对原始文本进行操作,想象一下,你想进行矩阵乘法。你如何在字符串上做到这一点?所以我们可以用分词器来解决这个问题。

你应该记住的一个关键点是,如果你正在进行任何形式的微调,或者任何推断或预测,确保你在这里使用的检查点与分词器和模型是相同的,这很重要。因为当这些变换器在一个大型语料库上进行预训练时,会有一个相应的分词器,也在某种意义上进行微调以学习该语料库的词汇,所以如果你混合使用一个分词器的检查点和模型的不同检查点。

基本上你会在词汇表中遇到不匹配,然后你的输出中会出现一些垃圾信息,所以这是需要注意的一点。好的,我们有了一个分词器。😊 现在我们得到了这些相同的原始输入。如果我们将这两句话输入到分词器中,通常有两件事情你需要记住。

你将会得到一个叫做输入 Is 的东西。这些输入 Is 基本上是将我们序列中的每一个标记映射到一个唯一的数字,或者更准确地说是一个唯一的整数。这基本上是在词汇表中的一种映射,所以想象一下我在思考整个英语语言时,只是在处理单词,那么我可能会在我的词汇中有好几十万个单词或标记,然后如果我得到像“whole”这样的词。

我希望能够将其与词汇表中对应于此映射的数字进行匹配。但正如我们在第一章中看到的,实际上我们今天可能也会看到,这种按词进行的标记化并不是很高效,因此我们通常会做一些更聪明的事情。但基本的想法是,输入中的每一个标记都将映射到一个数字,然后这些数字使我们能够区分序列中的不同标记。

所以这就是输入 ID 的含义。今天你将更详细地看到的另一件事是被称为注意力掩码的东西。我稍后会更详细地解释这实际上是做什么的。但你可以已经看到,它在序列的某些部分放置了一堆一,而在序列的末尾放置了一堆零。这一点稍后会变得更清晰。好的,我们有了分词器。

所以我们现在已经将原始文本转换成了这些可以操作的数字。然后让我确保我在这里加载了正确的检查点。现在我们要加载模型,这将处理这些输入。让我先删除这个。好的,那么问题是,如何将输入传递给模型,最简单的方法就是直接使用我们这里的这个字典。

它有两个键,分别是输入 ID 和注意力掩码。然后我们可以使用标准的 Python 解包操作符将所有的键和值传递给模型。当我们这样做时,基本上会将输入传递到模型的前向传播中以生成输出。我认为我们可以这样来看这个问题,如果我们查看前向传播。

你可以在 CoLab 中看到,它基本上向我们展示了这个前向传播可以接受的参数。因此,它告诉我们可以接受输入 ID,可以有注意力掩码,然后还有一些更复杂或高级的东西我们也可以提供,但今天我们不需要处理这些,不过请你知道,还有其他你可以做的事情。

所以你可以看到,我们需要提供至少这些输入 ID 和注意力掩码。😊。因此,当我们像这里那样进行解包时,这基本上会运行前向传播并生成一些输出。正如我们在视频中看到的,这些输出基本上被称为隐藏状态,而这些隐藏状态只是某种压缩的文本表示。所以我们先将原始文本转换为数字,然后将这些数字再转换为密集向量,因此每个标记现在都与一个向量相关联。

在这种情况下,我们每个句子有16个向量,每个向量有768维。这只是因为Bt或Distill Bert的预训练方式。所以让我们看一下这些向量之一,我们得到了输出。所以我将取第一句话,这就是第一个索引。

我将查看这个句子的第一个标记,所以如果你看这个。它们必须是切片或整数。我需要处理最后的隐藏状态。好的,很好。实际上,让我们退一步,如果我们只看原始输出。你可以看到在变压器中,模型的所有输出通常都是包装在一个对象中的,这个对象我们可以根据属性名称进行索引。在这里,我们有一个叫做基础模型输出的东西,在这种情况下,它有一个属性叫做最后的隐藏状态和张量。

所以如果我想访问这个最后的隐藏状态。现在我得到了一个张量。它包含我想要做的东西。所以我要获取第一句话。我将获取第一个向量或第一个标记。抱歉,是对应于第一个标记的向量。现在这个就是,你知道的。

你知道的,这是一大堆数字,从负到正。这应该有768的大小,我们在哪里?是的。所以这基本上是我们传入的第一个序列或第一句话中第一个标记的数值表示。好的,让我们检查一下是否有任何问题?好的,很好,继续。好的。这基本上是模型生成的数值表示。

然后正如我们在视频中看到的,这些数值表示本身并不能让我们进行文本分类。它们只是说这个标记的数值表示是 blah。如果我们想进行分类,我们需要将那个向量或这些特征向量与分类头进行相加或结合。因此,整个Transer库就是围绕着像这样将任务X的模型进行构建,而任务X可以是诸如序列分类这样的事情。

问答、摘要、翻译等等。在这种情况下,当我们实例化一个序列分类模型时,正如我们之前看到的,这现在将创建一个模型。它有多个标签。因此你可以看到这里我们现在有一个有两个标签的模型,因为这就是这个预训练检查点所具备的。

然后当我们查看输出时。我们现在得到的不是仅有这些最后的隐藏状态。我们得到了logits。这些logits基本上是将这些特征向量输入到这个线性层后的结果,这将把这些768维的向量压缩为两个数字,或投影为两个数字。这些就是我们可以用来推导概率的东西,例如。

哪个类最有可能,所以你可以看到这里这个比这个更可能,反之亦然,因为我认为第二个示例像是负面情绪。好的,所以这就是我们如何看待模型输出与带有分类头的模型之间的关系。

在这里我们可以看到,如果我们想将我们的逻辑转换为概率。我们可以直接对它们进行 softmax,你可能还记得 softmax 基本上处理所有输入。它对它们进行指数运算,然后通过所有指数的总和来标准化,所以你最终得到的范围是从零到一。所以它是一个很好的概率候选。如果我们这样做。

然后我们得到每个情绪的概率。现在我们也可以看到这是我们可以在标签 ID 之间映射的方式,它表示。你知道零在某种更有意义的东西中是什么意思?好的。那么我们来看一下。好的,太好了,我们有一个来自 SRM Sumya 的问题。

这表示分类模型应该接受来自蒸馏模型的输出,这正是正确的,实际上我们来看看这个。如果我们看一下。类,我为 Bert 做这个,但对于 dist Bt 也是一样。所以如果我们拿 Bt 模型。全序列分类。所以如果你看看这个模型实际包含什么,它包含我们在示例中看到的 BRT 模型或蒸馏的 Bt 模型。

然后它只需应用 dropout 和线性层。线性层的维度是 768 的隐藏大小。然后它将把这个压缩成仅由标签数量定义的两个数字。因此,如果我们往下看,在前向传递中发生了什么。

我们首先得到 BRT 模型的输出。这些只是特征向量,这些 768 维的向量。然后你可以跳过大部分这样的内容。主要的观点是。在这里。我们。但是不用担心端口输出,主要是我们将这些输出输入到分类头中以产生逻辑。

这是个好问题。是的。嗯。这这。好的,我们有一个来自 Platin Chiba 的问题。我们如何查看标记表示在文本中的意义?所以。很好,或许只是为了展示给你。比如。我们可能有点急于求成,但这没关系,好的。我们有这些原始输入,它们由这些字符串给出。

然后我们得到这些输入 ID,就像这样,对吧?所以我们可以做一件事。如果你想要回退,我们稍后会看到这一点。但我可以这样做。我可以说好吧。Tokenizer,我要解码,所以我要做我之前所做的事情的相反。现在我要拿我的输入 ID。希望能成功。这需要输入。Hies。

现在你可以看到,通过使用这个解码方法,我们能够逆转广泛文本的过程。但它的作用是引入一些特殊的标记,其中一个称为 CLS 标记,它表示句子的开始。然后我们有一个 Sep 标记,它基本上用于区分句子对之间的区别。

所以这是一个可以回到你开始的地方的模型。如果你有更多问题,我们可以在进行时解决。好的,酷,所以这就是关于管道如何在内部工作的初步观察。现在我们可以做的,是更详细地看看模型。所以我将开始观看这个视频,然后我们将暂停以提问,再看看一些代码。

如何实例化一个变换模型。在这个视频中,我们将看看如何从 Transformers 库创建和使用模型。正如我们之前看到的,Automod 类允许你从 I face 应用的任何检查点实例化一个预训练模型。它会从库中选择正确的模型类,以实例化适当的架构,并加载预训练模型的权重。

正如我们所见,当给定一个鸟类检查点时,我们最终得到了一个鸟类模型,对于 GPT2 或 part 也是类似的。在后台,这个 API 可以接收地球上的检查点名称,在这种情况下,它将下载并缓存配置文件以及模型权重文件。你还可以指定包含有效配置文件和模型权重文件的本地文件夹路径。

要实例化之间模型,Automodal API 首先会打开配置文件,以查看应使用的配置类。配置类依赖于模型类型,例如 B、GPT2 或 part。一旦有了合适的配置类,它就可以实例化该配置,这是一种知道如何创建模型的蓝图。

它还使用这个配置类来找到适当的模型类。然后将其与加载的配置相结合,以加载模型。它的模型尚未成为预训练模型,因为它刚刚用随机权重初始化。最后一步是从模型文件中加载权重到该模型中。

为了轻松加载来自任何检查点或包含配置文件的文件夹的模型配置,我们可以使用 autoconfig 类。像 Automod 类一样,它将从库中选择正确的配置类。我们还可以使用与检查点对应的特定类,这样每次想尝试不同的模型架构时,我们就需要更改代码。

正如我们之前所说,模型的配置是一个蓝图,包含创建模型架构所需的所有信息。例如,与基于鸟的案例检查点相关的鸟模型有12层,隐藏层大小为768,词汇量大小为28996。一旦我们添加了配置,我们可以创建一个与检查点具有相同架构但随机初始化的模型。

我们可以像任何其他模型一样从头开始训练它。我们还可以通过使用关键字参数更改配置的任何部分。因此,这段代码片段实例化了一个随机初始化的具有10层的布局模型,而不是12层。一旦模型经过微调,保存它是非常简单的。我们只需使用保存方法。

在这里,模型将保存在当前工作目录中的名为My beltt model的文件夹内。这样一个模型可以通过from between方法重新使用。要了解如何轻松访问这个模型,请查看推送到视频。

到目前为止关于模型加载和保存模型的任何问题吗,在我们深入一些代码之前?

所以,为了总结一下我们在视频中看到的内容。每当我们使用预训练的方法时,我们首先需要获取一个配置,然后我们刚刚看到的配置在几分钟前定义了标签到标识符的映射、模型的标签数量以及所有相关信息。

多少层等等,然后该配置用于加载模型的权重,以确保一切以正确的方式配置。然后,一旦我们有了这个模型,我们就可以保存它并用于其他事情。所以。

如果现在没有什么紧急的问题,我来看看模型的代码。正如我提到的,你可以在自己的时间观看这些视频,并通过这类文本进行学习。但我认为如果我们直接看一下可能更有用。

在代码处,嗯,但让我们检查一下,我可以运行transformers。好的,所。一件值得提及的事情是,你可能会发现自己处于一种非常常见的情况:基本上你已经训练了一个模型,现在想以某种方式分享它,而这种分享通常是在我之前工作的公司中。

这更多是关于部署这个模型,以便你可以为其他服务提供服务或生成预测。因此,一旦你保存了模型,问题是,好的,我到底该如何处理这个东西?😊。正如我们所看到的,这个保存功能基本上会保存两个对象。它会保存一个配置JO文件,并且还会保存一个Pytorch模型的do bin文件。

这在 Pytorrch 中被称为状态字典,它提供了所有层和权重的信息。因此,如果我们想用这个来生成预测,我们需要做的第一件事就是像以前一样获取输入文本,将其转换为输入 ID,然后将这些输入 ID 转换为张量。

然后我们可以将这些张量提供给模型。之前我们使用的是分词器,这正是你在实际中会做的。但在这个例子中,我们只是展示了分词器的输出。让我们看看代码中那是什么样子。检查一下有没有问题,好吗?好的,嗯。😊,嗯。😊。

也许快速总结一下,我们可以使用两种不同的方式加载配置。你可以直接从库中的默认配置加载模型,这将为你提供有关隐藏层大小等的摘要

但是如果你这样做,模型将会完全随机初始化,这意味着所有权重都是随机的,这个模型将毫无用处,它不会帮助你做出任何好的预测。实际上,这是你在想要对模型进行预训练或者从头开始训练模型时所做的事情。嗯。因此在实践中,大多数时候,你真正做的是使用预训练的模型,这将用预训练权重和需要的正确头初始化模型。

如果我们想进行预测,我先实例化一下。假设我已经有了我的模型并且对它满意,因此我想保存它以便可以部署到某处。让我们等待模型下载。好的,好的。那么我可以做的就是保存我的模型,这只是你机器上的一个路径。

如果我们现在查看文件系统,可以看到我计算机上有一个名为 directory 的目录。那么现在如果我查看那个目录里面有什么,我有这两个文件,一个是 config Jason,另一个是一个名为 Pythtorage model 的二进制文件。因此,我们现在可以把那个文件夹打包,压缩。

放到一台机器上。如果我们想获得新的预测,那么我们要做的是获取我们的分词输入,然后将这些输入转换为张量,因为所有的 ptorch 模型都期望输入张量。所以如果我们查看这个模型输入,它只是一个张量。然后我们将这些输入提供给模型,这样就构成了一个预测。

然后你可以对这个预测做任何想做的事情,可能用它来做某种决策,或者用来输入到仪表板。基本上是没有限制的。这就是生成预测的过程,非常简单。所以让我们来看看。

我们这里有一个问题。出于兴趣,从头训练Bert需要多长时间?你可以在coab上做到吗?

好的,所以我认为这真的取决于你想使用的语料库的大小。例如,如果我没记错的话,Bert是在整个英语维基百科和一个称为Books corpus的语料库上训练的,后者是扫描过的图书馆书籍。而且。我想想。所以,你知道,让我们这样做,为什么不现场找到答案,因为我不记得他们花了多长时间去做这个。

没有什么比现场阅读论文更好的了。

好的。😊那么,这是书籍论文。让我们来看一下,我猜他们使用TPU。好的,他们在这里说他们在四个云TPU上训练了BERT基础版,所以这就是16个TPU芯片。每次预训练需要四天才能完成。所以。我记得,coabab上的云TPU只是一个TPU芯片。因此,大致来说。

这可能需要你大约16天,16乘以4。所以64天,在curtL上训练。你知道的。嗯。😊但是。我不这么认为。是的,我不确定是否有快速的Bt训练。不过,我会给你展示一些东西。

Hugging Face有一篇关于训练的博客文章。让我们看看。

一个关于世界语的模型,所以我把这个扔进聊天中。那么。我可以这样做吗?好的,这篇博客文章。它使用了稍旧的API,但基本的想法是告诉你,只要你的语料库不是太大,你实际上可以在coab上训练一个BERT模型。所以这是世界语,它是一种特殊的语言,文本量远少于英语。但我记得,这是在一个半小时内训练完成的,也许几个小时。所以让我们看看。

ちて。好的,也许我们在这里看不到。我们只需查看coab。嗯。让我们看看。那么这个模型的训练。好的。所以是的,这次训练花了将近三个小时。所以这真的取决于你的语料库的大小,所以原则上你可以。但如果你想做一些像Bert那么强大的事情。

那么你将需要一些更强大的硬件。好的。嗯。还有另一个问题,我明白迁移学习或使用预训练模型是更好的选择,是的。这正是正确的,所以像如今的变压器和自然语言处理的真正力量在于,我们并不想自己进行预训练,因为这既昂贵又耗时,因此我几乎总是会使用预训练模型,如果可以的话。

你真正可能会陷入困境的唯一时刻是当你处理的领域与任何现有的预训练模型非常不同的时候。例如,假设我试图在源代码上训练模型。你知道,在转换器的早期阶段,没有任何预训练的源代码模型。例如,理解Python语言,那么你知道在英文的BERT基础上进行转移到源代码可能会有点棘手,可能不会给你非常好的结果,因此如果你在源代码语料库上训练,会得到更好的结果。

另一个通常需要寻找替代方案的例子是当你处理一种不常见的语言时。例如,我了解到非洲有许多语言在维基百科上并没有得到很高的代表性,因此这让人们训练模型或转换器时变得困难,通常需要一些技巧,比如使用多语言的BERT版本,试图以某种方式将其适配到你的语言,但这些通常是更高级的内容,我们可以稍后讨论。

好的。那么。我们来看看。那么我们到哪儿了?我们已经看过了另一个问题。我们可以更改预训练模型的配置参数并使用它吗?诶。可以,但有一些注意事项。所以。比如说。让我们想想我们能改变什么,不能改变什么?嗯。我想确保我不会说一些愚蠢的话。让我们看看我们这里的模型配置。

这是与Bert Bates相关的配置。这里可以看到一堆与该模型预训练相关的超参数。所以。例如。让我们看看。所以我怀疑如果我们更改许多这些东西。

我们将以一种非平凡的方式打破模型。不过,让我想想。如果我们改变隐藏层的数量会发生什么?😔,所以你知道吗?让我们尝试一下深度学习中的常规做法,就是试试。因此,我打算进行更改。Bt有多个注意力头。

所以我想看看会发生什么。如果我将注意力头的数量从12减少到6。让我们看看。如果这能工作。让我们查看配置,确保更改成功。所以现在我们有六个注意力头。那么,如果我们尝试给这个模型输入一些内容,会发生什么呢?

好的。😊,好的,所以。有趣。好的,所以。似乎我们可以更改配置,且一切都能正常工作,意味着没有错误。但我怀疑在预训练模型中进行这种黑客行为会以某种非平凡的方式影响性能,因为。

如果我们思考一下做文本分类时发生了什么,我们就会把整个BRT基础模型拿来,然后在上面叠加分类头。如果我开始分解Bt成不同的部分,减少注意力头或改变变压器层的数量。

所以Bert有12个编码层。我怀疑这可能会对我想要微调的下游任务(如分类)产生一些非平凡或负面的影响。但也许Omar在这方面有不同的见解。好的。这是个好问题,我实际上从未以这种方式破解过预训练模型。也许你可以试试看,做一些实验,比如如果我完全改变层的数量、注意力头的数量,尝试进行分类,比如情感分析,会发生什么。

我的性能会更好还是更差?我感觉可能会更差,但这确实是个很酷的事情。如果你检查了,请在论坛上分享。好的。这是我们如何生成预测的回顾。现在让我们更详细地看看分词器。希望互联网仍然有效。

好的。

在接下来的视频中,我们将关注令牌。在自然语言处理过程中,我们处理的大多数数据由原始文本组成。然而,机器学习模型无法以原始形式读取或理解文本。它们只能处理数字。因此,分词器的目标是将文本转换为数字。

有几种可能的转换方法,目标是找到最有意义的表示。我们将查看三种不同的组织算法,逐一比较。我们建议你按以下顺序观看视频,首先是基于词的。

接下来是基于字符的,最后是基于子词的。😊。

是的。

嗯,好吧,所以。这是我们讨论的高层次概述,关于将文本转换为数字的过程。这一部分有许多视频展示不同的分词方式。嗯。😊,我没问题吧。你们能看到我吗?可以吗。好的,很好。哦,太好了。是的。😊,在家办公的乐趣,好的。😊。

我所说的是,有不同的分词策略,优缺点取决于你感兴趣的应用。所以我不会逐个视频讲解,你们可以自己观看。

但让我们快速看看三种最流行的方法。首先,我可能会想象,如果我有一段文本,比如“吉姆·亨森是一个木偶师”。然后我可能会说,好吧,我只想把这段文本拆分成单词。在英语中,简单的方法就是在空格上拆分。因此,在英语中大多数时候。

如果有空格,那就是单词之间的边界。然后这会转换。例如,吉姆·亨森是一个木偶师,将其分为这五个标记,因此在这种情况下,单词就是一个标记。但是在几种语言中,这种方法是个糟糕的主意,例如,如果你学习过日语,你会发现汉字没有空格的任何单词,只是一系列的汉字,并且通常是从上到下书写,而不是从左到右。

因此,这种基于空格的拆分或标记化根本无法实现。另一种替代方法是尝试字符基础的方法。所以想象一下,你将英文序列中的每个字母拆分成自己的标记。这样做对日语也很有效,因为每个字符都是一个汉字,我们可以用标记来表示。

你可以看到的事情是,标记化策略确实似乎依赖于我们研究的语言。因此,许多研究致力于寻找一种在单词标记化和字符标记化这两种极端之间提供良好折衷的方法。

在我们深入讨论之前,我还应该提到几个缺点。因此,基于单词标记化的一个缺点是,这将创建一个词汇表,其大小等于我们语言中的单词数量。因此,如果我们假设只标记英语,那么我们需要为每个英语单词创建一个标记,这通常是几十万个标记,这在计算上非常昂贵。

但另一个不太理想的地方是,它没有区分类似的词,比如狗和狗狗,这些词是相似的,而我们现在将它们表示为两个独立的标记。

这是基于单词的方法的缺点,而基于字符的方法的缺点是模型必须学习一个单词实际意味着什么,因为它得到的只有字符或字符标记。然后,它必须通过训练弄清楚,好的。

如果我将这些字符按这个顺序组合起来,这似乎代表了一个更抽象的对象,比如一个单词。因此,至少对于英语来说,这不是一个好的策略。大多数分词器使用一种称为子词分词的方法。基本的想法是,不仅仅在单词边界或字符上进行分割,而是将一个单词分解为子词。这里的一个例子是。

我们以“annoyingly”为例,“annoyingly”可以表示为可能两个子词。 “annoying”和“ly”。然后我们可以收集这些子词的频率,然后用这些频率来基本上找出语言中最常用的子词,然后我们可以用这些子词重新构建完整的单词。

所以如果你知道你有“annoying”和“ly”,那么你可以从这两个组成部分重新构建“annoyingly”。我想这里有个例子,你可以将分词分成这些子词,这样你可以看到这是一种单词与子词混合的情况。而且我们还将感叹号视为一个单独的标记。

你会看到的最常见的分词器,大概有一个好问题。我会提到的有称为 word piece 的方法,这是 Bert 使用的,或者是 sentence piece,这是 GT 和 GPT 模型通常使用的。所以这是个很好的问题。你如何设计子词边界,是手动的吗?

所以这在某种程度上是由你选择使用的算法决定的。我认为。一般来说,这是一种手动规则与从语料库学习的结合。所以我们快速看一下。

让我看看,我认为这是 sentence piece 论文。

这这这。所以这是,我要把这个放在聊天中。好的。这是关于分词的最著名论文之一。我们快速看一下。那么这些边界是怎样的。好的。嗯。是的,没错。😊这是我从这篇论文中记得的。所以他们说,从历史上看,大多数分词算法。

他们使用了手动规则,这个问题当然在于,对于每种语言,你都需要一套规则,这真的是个麻烦事。要维护和扩展这些规则。如果我没记错的话,sentence piece 就像是一个学习的分词器。

所以你实际上有一个优化目标,然后你就像训练模型一样训练这个模型,通过在你的语料库上进行训练。你实际上学会了单词的边界。嗯。😊但是我已经好几年没看过这个了。可能会忘记一些东西,但。是的,这是个好问题,我认为这可能是我们可以在未来版本中添加的内容。好的。😊那么。我们在哪儿?我们在看这些不同的分词策略。

那么我们也许可以看看 CoLab。嗯。所以。我经常喜欢做的一件事是捕获我在 CoLab 中的管道工具的输出,这样我就不需要有这个巨大的。没。安装的内容。好的,所以你在这里看到的是我们之前讨论的内容。

这是如果你只是进行单词的词块分割,哦,对不起,是将文本切分成单词,现在我们可以看看 BERT 分词器是如何工作的。有两种方式可以在 transformers 中做到这一点。你可以指定你想要使用的具体类用于 tokennova。如果你恰好在做一些非常特定的事情,并且你真的想确保你获得了合适的组织者。

但我个人一直使用的方式是自动分词器,因为这会自动将分词器转换为这个类。所以如果我提供一个检查点,并且它能够识别出来,它就会以这种方式自动加载。

好的,所以如果我们获取一个分词器。它将文本转换为这些输入 ID。但现在让我们看看这里的某些内容。那么我们为什么要做两次?😔,好的。好的。那么我们在这里做的只是获取一段文本,然后将其提取为一个标记列表,所以你可以在这里看到。在 BERT 的情况下,它使用这个 word piece 分词算法。

它区分单词和子词的方式是使用这个双哈希符号。所以你可以在 BERT 分词器的词汇表中看到,它已经学会了在 trans 和其他内容之间分割单词,如果我们想要重建这两个单词,我们只需要知道这个双哈希意味着前面的内容属于 trans,以构建 transformer。

因此,重建句子的一种方式是你可以获取你的标记,并将它们转换回输入 ID,像这样。所以这将创建这些 ID,然后你可以解码这些输入 ID 以重建原始字符串。另一种方法是让我们看看我们有的输入。とて 왜。好的。那么另一种方法是如果我获取我的分词器。我只是对我的序列进行分词。

然后这会产生我们之前看到的内容。接下来我可以做的是使用 tokenizer.decode。我输入我的输入,而我的输入是。这应该返回我们之前看到的内容。现在你可以看到这种方法和这里的方法之间的区别是我们没有这些特殊标记,所以如果你不希望这些存在,我认为我们可以将 skip special tokens 设置为 true。

然后这将给我们返回原始序列。酷。这基本上就是对分词器的一种深入探讨。嗯。😊。也许值得提到的一件事是,让我们看看另一个分词器,这样你就能对你可能看到的内容有个了解。那么让我们找一个不会阻止 colab 的 GPT 模型。所以,G to。

那么我们做这个吧。我将只是拿一个小的GPT。你也可以复制检查点的名称,这很方便,所以我们在这里。那么我想做的就是展示GPT模型与它的分词方式之间的区别。希望这样能成功。是的,GPT有一种非常古怪的处理方式。

分词器使用这个奇怪的符号,就像一个上面有小思考的G。它用来表示这个标记与那个标记之间有空格。所以你可以看到它在说,好的,使用,然后有空格,然后是R,然后有空格,然后是trans,但是former没有空格,因此如果我们想重构这个。

我们只需将其拼接回去。但是那样网络之间有空格等等。所以你可以看到这与Bt模型有很大不同,后者基本上将每个标记视为有相应的空格,除非我们有两个井号。

而GPT2则是另一种情况。假设没有空格,除非我放入这样的特殊符号。好的。那么关于分词器有什么问题吗?好的,好的,现在我们来看看如何处理多个序列。我将开始这个视频。

如何将输入批量处理在这个视频中,我们还会看到如何将两个批量输入序列结合在一起。我们想通过模型传递的所有句子并不都具有相同的长度。这里我们使用在情感分析管道中看到的模型,并希望对两个句子进行分类。当对它们进行分词并将每个标记映射到其对应的输入ID时。

我们得到两个不同长度的列表。尝试从列表创建一个密集数组或Mbi数组会导致错误,因为所有数组和密集数组应该是矩形的。克服这个限制的一种方法是通过添加一个特殊标记,使第二个句子的长度与第一个句子相同,添加必要的次数。

另一种方法是将第一个序列截断到第二个的长度。但是你会失去很多可能对正确分类句子必要的信息。一般来说,只有当句子超过模型能处理的最大长度时,我们才会截断句子。用来填充句子的值不应该随机选择。

模型已被描绘为具有特定的填充ID,你可以在tokenazizer中找到。现在我们有了p个句子,我们可以用它们创建一个批次。如果我们单独将两个句子传递给模型并进行拼接,我们会注意到,对于填充的句子,第二个句子得到的结果不一样。这是变换器库中的一个bug吗?现在如果你记得,变换器会让用户轻松使用注意力层。

这应该并不令人完全惊讶。当计算每个标记的上下文表示时,注意力层会查看句子中的所有其他单词。如果你只有一个句子或者句子中有几个填充标记,那逻辑上我们不会得到相同的值。为了获得相同的结果,无论有无填充。

我们需要向注意力层指示应该忽略那些填充目标。这是通过创建一个注意力掩码来完成的,该掩码与输入 ID 具有相同的形状,里面是系列的 0 和 1。1 表示注意力层应该在上下文中考虑的标记,而 0 表示我们应该忽略的标记。现在,将这个注意力掩码与输入 ID 一起传递,将给我们与将两个句子单独发送给模型时相同的结果。

这一切都是由标记器在你将多个句子应用于填充标志时在后台完成的。它将为较小的句子应用适当的填充值,并创建相应的注意力掩码。

是的。好的,我看到我们有几个问题,所以第一个问题来自 IM homesmes。我不明白为什么我们需要额外的维度。根据返回的错误消息,你会如何排查以确定你需要另一个维度?好的。所以我认为查看这个的最佳方式可能是一些代码,所以我们去这里。😔,并。

安装 transformers。

好吧,所以。如果我理解 O homes 的问题,你在谈论这个错误消息。让我们看看它是否可以重现。好的,很好。所以我想你在谈论这个索引错误。我们在这里得到的。让我们看看我们可能如何调试这个。错误是说维度超出范围。我们预计它应该在 -1 到 0 的范围内。

但是得到了一个。所以让我们看看我们的输入是什么形状。这大概是我调试这个消息的方式,所以。好的,我们可以看到。输入 ID 的大小只有 14,这仅仅表示在对序列进行标记时我们获得的 14 个标记。嗯。😊,所以我将向你展示大多数软件工程师调试内容的一个小秘密。

所以你拿这个。然后你在谷歌上查一下。然后你就会说,啊,这看起来像个 PyTorch。然后我们看看有没有人能解释发生了什么。抱歉。你可以看到一些消息,有人这里有个东西,遇到了一些维度范围错误。嗯。然后好吧,这看起来像是在 PyTorch 中的一个更深层次的问题,可能会有帮助。

但也许让我们看一下堆栈溢出,这通常是你能找到好答案的地方。有人遇到了同样的错误,让我们看看别人给他们的答案。他们说你给了这个东西一个1D张量,但它期望这种类型的对象。让我们看看这是否和我们正在做的相关。所以。如果我们查看这里的错误。

它说在堆栈跟踪的某个点。我们试图通过获取输入的大小来计算序列长度。然后我们实际上试图访问输入ID的第二个维度。所以如果你看一下。我们提供的大小,它只有一个维度。因此,基本上。我可以访问。大小0,因为那是可用的第一个维度。

我不知道为什么coab这么慢。然而,如果我尝试访问一维对象的第二个维度,那么这是不可能的,所以它会抛出这种错误。不知道为什么。CoAab的反应真的很慢,我就要重启它。看看能不能做到。这更有趣。让我们看看,这是否有意图。很有趣,所以coabab,好的。让我们看看。我再启动一次curl。

也许我打开了太多颜色。好吧,再试一次。所以。你去。Andst这个,好吧。祝好运,希望这能奏效。抱歉,好的。我们正在尝试调试这个错误,我们看到堆栈跟踪告诉我们是在这里。问题是我们正在尝试确定大小,或者基本上我们在尝试挑选输入ID第二个组件的维度的大小。

但我们面临的问题是输入是。我只有一个维度。所以它们的大小是14。如果我们访问第一个元素,我们得到14,这很好。但如果我们访问第二个,我们会得到相同的错误。因此,我们看到的问题是,我们基本上需要提供一个批处理维度,说明我们正在处理一个句子。

这两个序列的长度都是14。所以基本上大多数输入。输入是。ID应该有。形状。匹配大小。然后像这样的秘密。没有。这回答了问题吗,我是霍姆斯?

我认为这是一种有点复杂的调试方式,但这大致就是我会怎么做。嗯。很好,还有一个来自SRM Sma的问题,关于我们是否可以修改填充技术?

所以答案是肯定的,让我们看看在哪里进行填充。啊,好的。我只是随便想的。好吧,让我们看看。我有一个分词器。如果我只取这样一个序列,我会得到这些输入ID。那么问题可能是,如果我添加一些填充。

那么,我的输入会发生什么,基本上在这种情况下,这应该不提供任何填充标记。所以我将创建两个序列。我的狗叫照片。然后另一个序列,像我的猫是。是冷的。真的很酷,比如。我知道,伊丽莎。所以现在我有这两个序列。

一条比另一条短。所以现在如果我将这些传递给我的分词器并设置填充为真。你可以看到发生的情况是,在第一个序列中,它采用了正常的标记。然后在末尾添加了一堆零。它添加的零的数量正是为了匹配输入中最长序列的长度。现在问题是,我们可以采取什么策略?来做到这一点。

让我们看看,我想我们可以做到。

所以我接下来要做的就是找到我需要的实际参数,我将去transformformers。

我将查看填充,因为我不记得我是如何在左侧进行填充的。那么也许是。预训练的填充参数。去。好吧。看看源代码。好的。所以我可以做最长最大长度。有趣,所以好的,这只会给我们选项。例如,如果我做。最大长度。那么这将填充到整个模型的最大长度,也就是Bt模型。

可以处理512个标记。所以这将处理大量的零,一直到512的长度。我们在这里的另一个选项是最长,这就是输入中最长示例的默认值。但是让我们看看我们是如何在左侧填充的。嗯。我记得。我们可以做到。うん。好的,所以。让我们看看。所以我们可以输入。填充策略。和。多个。嗯嗯。我之前是。

我很确定我可以在两侧进行填充。所以,让我们看看。谢谢,Oma给出了答案,太好了。😊,所以。那么我们可以这样做。我们做填充为真。然后,填充侧。等于左侧。有趣。我做错了吗?也许这仅适用于某些。分词器,我们可以做到。好的,所以填充侧。在这里我们可以看到,默认值应该填充为右侧或左侧。

这是针对预训练的分词器。有趣,好的,让我们这样做。让我们看看。抱歉进行现场黑客。让我们看一下。如果我们查看分词器的一个属性。它被称为填充侧。在这里默认是右侧。所以我可以通过设置为左侧来覆盖这个属性。所以这不是一个关键字参数。

这是分词器的一个属性,这正是我所缺少的。所以现在你确实可以看到。我们可以在左侧填充。因此,我认为这应该回答SRM游泳者的问题。非常感谢你的帮助。嗯。😊,嗯。谢谢Dk,疯狂,你是否看到现实世界的真实样子,好吧,所以让我们看看,后续问题是它会对注意机制产生影响吗?这是个非常好的问题,所以。

😊,我们有的原因是,这里有两件事情发生,一方面。嗯。😊。有填充,我们需要这样做,以确保所有输入基本上是一个矩形数组。这就是我们需要进行矩阵修改等操作的方式。在网络中。所以一旦我们引入了填充。

我们介绍了Sylvan在视频中提到的问题。即注意力掩码,或者说一般的注意力将关注输入中的每一个标记。所以在这种情况下,这里的每一个零原则上都是一个具有自己嵌入的标记,然后当我们计算注意力时,基本上是将每个标记与序列中的每个其他标记进行成对相乘。这将是一个问题,因为这会对模型说,嘿。

我有这三个标记,它们似乎彼此相关,然后当我在编码器末尾构建我的表示时,这将有一些填充的人工信息,而我们并不希望这样,因为填充是我们人为注入的东西。

所以Sylvan提到的事情是我们通常会得到一个叫做注意力掩码的东西。所以我就叫它我的分词过的输入。对的。所以如果我看我的输入,我有输入ID,还有一个注意力掩码。这个注意力掩码在我们内部计算注意力时会使用。

它会说每当你看到一个零时,完全忽略那个标记。所以你可以看到分词器正确地意识到,如果我说左边的pat,那么确保对前三个元素或前三个填充标记有一个掩码。因此,这些零基本上会对注意力计算说,忽略这个。

只计算我们关心的实际单词的注意力。回答你的问题,Sm Ser。它没有影响,因为注意力掩码处理了这一切,都是通过分词器自动完成的。谢谢你,Hol,真好。我下周还有一个,所以我认为第三节你可以来参加。😊好的,让我们看看。

我认为我们这里有最后几节的内容。把它全部结合起来,所以。嗯。让我们看一下这一节的代码,这将把我们在本节中学到的所有内容结合起来。我将逐步浏览代码。所以,想法是。

只要记住我们在这一章中做的事情,我们在解构管道,查看所有组成部分。现在我们将把这一切结合起来,构建自己的自定义管道。第一件事是加载检查点、分词器并提供一些输入。事实上,我要做的这个将生成两个序列。

现在我们可以看看不同的填充方式。所以这是。我想我们之前见过这个。模型输入现在将有填充标记,直到最长序列匹配。所以在这种情况下,这是最长的输入。第一个没有填充标记,但第二个则得到所有这些额外的零。

正如我们之前看到的。注意掩码会添加所有这些额外的零,表示。不要关注那些文档。然后,正如我们之前看到的。我们可以设置最大长度。然后这将。至外交。这现在将。给所有东西加上一堆零。所以我们看到的所有这些零。所以这上升到512个额外零用于bird。M长度。

然后你还可以配置你想要添加填充的距离,如果你想的话。到目前为止,我没有真正提到的另一件事是截断的概念。所以让我们看看这如何工作,基本上。通常会发生的事情,除非你在处理像推文那样的内容。

很短的文本,很多时候你的输入将超过变换器可以处理的最大长度。因此,这实际上是变换器的主要挑战之一,因为它们在处理短到中等长度的输入时表现非常好。

但是当我们处理非常长的序列时,会有两个问题。第一个是注意力计算密集且昂贵,第二个是大多数模型在预训练阶段只预定义输入的最大长度,一旦你定义了,就不能超过它。

在这种情况下,我想给你展示如果我们这样做会发生什么。所以我将取一个序列,然后说我不知道。让我们拿这个家伙。然后,我要尝试打破这个,所以我将其乘以。'这里有这个Pro 14个标记。让我们乘以1000。所以现在我有了一个非常长的序列。我想看看。

如果我尝试传递。这个序列。哎呀。给我的分词器。你知道的。如果我什么都不做,会发生什么?好的,所以现在你可以看到我们得到了一个警告。序列中的标记长度超过了该模型的最大序列长度。在哪里的消息。它在说,我们有。你知道,远远超过我们拥有的标记。

然后你会说,哦,好吧,我不在乎警告。所以我将说。谁在乎。我将尝试返回张量。好的,所以这似乎有效。那么如果我。拿一个。我们有模型吗,不好。所以从transformers导入自动模型。那么如果我尝试。我们有检查点吗?😔

我的检查点在哪里?是的,我检查过了。让我们尝试加载我的模型。所以我在这里想做的是,我想看看。如果我们天真地尝试传递一个14000。长序列给两者。现在,如果我没搞错,我们的输入。应该打破模型。确实。

在这里,我们可以看到我们遇到了索引错误,索引错误超出范围。基本上这是在告诉我们,看,你试图在代码的某个地方执行这个嵌入操作。你正在尝试传递一个违反模型约束的输入。因此,这是一个例子,我们就这样打破了模型,因为我们给了它过长的东西。

解决方案是使用截断父参数并将其设置为true。这样做将会处理我们的输入并进行截断。所以我们先获取输入ID,然后是大小。现在这已经将它们转换为模型的最大大小或截断到最大大小。因此我可以将其输入到我的模型中,它会很高兴。

这是一种处理文本过长问题的方法。你可以直接截断它。根据我的经验,截断通常对分类任务效果不错。所以如果你做的是多类任务,通常很多信息实际上在评论或推文的开头。但对于问答这类任务就不应该这样做,因为答案可能在文本的后面,如果截断了就会丢失,之后我们可能会在其他地方看到。

课程的迭代,你是如何处理的?还有在总结时。这有点取决于具体情况,有时我能截断文本并得到不错的结果,但有时你需要做一些巧妙的事情,比如把文本分成不同的部分。截断这些部分,然后再汇总结果。好的。

所以这是截断和填充。嗯。是的,我认为。这基本上是我们需要做的。那么这个阶段有没有问题?好的。我想提到的一件事是。

你可能已经看到我们有论坛,在论坛上,我们有一个课程分类。

所以如果你在这次会议后想到任何问题,或者一般关于变压器的问题,可以在这里询问,我们中的一个人会回复你。如果你有时间,分享你的项目是一个很酷的事情。实际上,我们可以看到DK Cr De在这里分享他出色的数据集,用于模型中心。

当你开始学习变压器时,获得反馈的一种很酷的方法就是分享你的工作,至少对我个人而言,我来自非计算机科学背景,我学习了物理,然后决定转向机器学习。

这种分享是一种非常有效的方式,可以获得社区的反馈,同时也在学习如何沟通。这是进行任何数据科学工作非常重要的一部分。所以,比如,今天汤姆被问到的一个有趣实验是,改变模型的配置会发生什么,它会出错吗。

这是一个展示的酷点,或者一般来说。你知道,任何你进行的训练实验都会揭示出非常棒的内容。继续。好的,还有一个来自拉什·马希克的最后一个问题,如何检查默认模型。好的。我们来看一下这个。好的,所以让我们拿一个管道。

所以我可能需要从transformers导入管道。然后我将创建一个情感分析的管道。例如。问题是,我们如何检查正在使用的模型,因此管道对象有许多不同的属性,而有趣的属性是模型。在这种情况下,所以如果我们看看这个,它会告诉我们,好的,输出是这样的。

但也许我们可以先查看模型的配置。然后我们可以看到,在这种情况下,默认用于情感分析的模型是distillbert,这正是我们在课堂上看到的那个检查点。所以我希望这能回答拉什·马希克的问题,你可以对任何其他管道做这个。我们快速看看如果我进行问答会发生什么。ううい。

所以在问答中的默认模型将是Distillber基于squad的案例。这就是我们所拥有的。酷,所以还有另一个问题,西尔万的第一场会议的录音是否可用。我在YouTube频道上找不到它,我相信。😊,会有的。但我想我得稍后和西尔文确认。所以我很确定我们尽量将能放上YouTube的内容都放上去。

所以,我会让你知道这个情况。所以非常感谢你们提出的非常酷的问题。能够与大家互动真是一种快乐,否则我就只能一个人对着屏幕说话。感谢你的参与。我们下次见。所以西尔万明天会进行会议,这和今天是一样的,下周我们将开始第三章。

아。

官方教程来了!5位 Hugging Face 工程师带你了解 Transformers 原理细节及NLP任务应用!<官方教程系列> - P3:L1.3- 什么是迁移学习? - ShowMeAI - BV1Jm4y1X7UL

什么是迁移学习?迁移学习的理念是利用在另一个任务上用大量数据训练的模型所获得的知识。模型A将专门为任务A进行训练。现在假设你想为不同的任务B训练它。一种选择是从头开始训练模型,这可能需要大量计算。

时间和数据。相反,我们可以用与模型A相同的权重初始化模型B,从而将模型A在TP上的知识转移过来。从头开始训练时,所有的中间权重都是随机初始化的。在这个例子中,我们在识别两个句子是否相似的任务上训练一个模型。

左边是从头开始训练,右边是微调的预训练模型。可以看到,在预训练模型上使用迁移学习能取得更好的结果。而且无论我们训练多久,从头开始的训练保持在70%的准确率,而微调的模型则能轻松达到86%。这是因为预训练模型通常是在大量数据上训练的。

但提供一个模型对在预训练期间使用的语言有统计理解。在计算机视觉中,迁移学习已经成功应用了近10年。模型通常在一个包含120万张照片的ImageNet数据集上进行微调,每张图像被分类为1000个类别之一。这样的训练方式。

无标签数据称为监督学习。在自然语言处理领域,迁移学习相对较新。与ImageNet的一个关键区别在于,训练通常是自监督的,这意味着不需要人工标注。一个很常见的预训练目标是猜测句子中的下一个单词。

这只需要大量的文本。例如,GPT2就是这样使用用户在read上发布的4500万个链接的内容来表现的。另一个自监督预训练目标的例子是预测随机掩蔽的词汇,这类似于你在学校做的血液B测试。

这是通过使用英语维基百科和1,000本已出版的书籍之间的方式。在实践中,迁移学习是通过抛弃一个给定模型的头部来应用的,即其最后几层专注于预训练目标。然后我们用一个新随机初始化的模型进行适配。例如。

当你早些时候在构建模型时,我们移除了分类Mque的部分,并用具有两个输出的分类器替换它,因为我们的任务是两个层次的。为了尽可能高效,所用的预训练模型应该与其微调的任务尽可能相似。

例如,如果问题是对德语句子进行分类,最好使用德语模型。但好的东西也会带来坏处。这个模型不仅传递其知识,还传递它可能包含的任何偏见。ImageNe主要包含来自美国和西欧的图像。

因此,用它微调的模型通常在这些国家的图像上表现更好。但Beni也研究了其Gpyy3预测中的偏见,这涉及到使用猜测和X世界目标之间的关系。将性别从E Westbury改为she Westbury改变了大部分中立目标的预测。

几乎仅限于物理模型。在GT2 Mor的模型代码中,Open AI也承认其偏见,并不鼓励在与人类互动的系统中使用它。

是的。

官方教程来了!5位Hugging Face工程师带你了解Transformers原理细节及NLP任务应用!<官方教程系列> - P31:L5.2- 推送(模型)到hub API - ShowMeAI - BV1Jm4y1X7UL

让我们来看看推送到每个API。就在录制这个视频之前,我提到了坏模型和C M PCC数据集。我们在这里不会详细讨论代码,因为你可以在任何Transformers教程中找到它,或者查看下面的视频链接。我们关心的是当训练结束且我们得到了满意的指标时会发生什么。

这个视频要求你首先在Hugging Face网站上注册一个账户,其次,你需要将你的身份验证令牌存储到该网站,这可以通过在终端中输入huggingface-cli login或在Colab笔记本中使用感叹号的方式轻松完成。

如果你使用的是常规的Jupyter笔记本,该命令将不起作用。因此,如果你在使用它且没有访问终端的权限,你需要将你的访问令牌从Hugging Face网站复制到训练参数中。我稍后会告诉你确切的位置。完成后。

推送API将允许我们将模型及其配置和相关的tokenizer推送到hub。要在训练器中使用它,必须确保将push2设置为训练参数中的equal2。如果不指定Mo ID,默认将使用输出的名称。

只要我们是该组织的成员,就可以推送到组织。如果需要,这里应该是你的Hugging Face账户所在的位置。推送完成后,我们可以在训练结束时调用Twinner来执行推送。未来的发展中,我们将添加在每个epoch结束或每给定步数后自动推送到应用的功能。

所以请继续关注。该命令返回特定提交的URL,我们可以在浏览器中检查,如果我们在检查之前复制它。请注意,如果你不使用训练器API,你可以通过使用push方法直接推送模型和tokenizer。

通过在浏览器中访问该提交,我可以访问名为Fine-tuned MPC的仓库,并看到已添加的文件。包括模型计数、模型配置、模型权重、运行的日志以及tokenizer所需的所有文件。训练器草拟的模型卡包含了评估集上的最终结果。

训练输出参数、中间训练结果以及我使用的框架。如果我点击编辑模型卡以查看原始内容,可以看到训练器还生成了一张元数据表,Hugging Face网站将使用这些数据来正确应用领域到我的模型中。我还可以通过点击这里的训练指标直接访问模型库中的运行情况。

现在模型已经开发完成,我们可以通过from betweentrain方法从任何地方使用它。我们只需使用E中的标识符,就可以看到模型配置和权重会自动下载。我们可以像使用任何变换器模型一样使用这个模型,例如,通过在管道中读取它。由于MRPC数据集是一组平行句子。

任务是确定两个句子是否相互为段落。我们在两个句子之间用S进行操作。看到它预测标签为零有点令人失望。这是因为我在创建模型配置时没有指定任何标签。修复这个问题通过推送到APIP是非常简单的。首先。

我们可以通过将标签设置为AD并用适当的值添加到标签,来在本地修复配置。然后我们可以通过推送到某个方法,将修复后的内容推送到我们的报告中。再一次,请返回一个提交的URL,以便我们可以检查并查看配置的具体内容。请注意,由于我使用的是之前的相同本地文件夹,命令执行得非常快。

我报告的克隆已经完成。一旦完成并创建新的管道,我们可以看到新的配置会自动下载,这要感谢构建追踪系统,并且我们得到了新的标签。我们也可以直接在模型卡上与模型进行互动。通过使用文本并点击Comp。我只需等一段时间,直到模型在推理API上加载并显示结果。

当模型加载完成后,我们可以进行双重检查,确认我们得到的结果与之前相同,直接在Wiidget上!

尝试今天将模型推送到VPA上!

是的。

官方教程来啦!5位 Hugging Face 工程师带你了解 Transformers 原理细节及 NLP 任务应用!<官方教程系列> - P10:L2.3- 实例化 transformer 模型 (PyTorch) - ShowMeAI - BV1Jm4y1X7UL

如何实例化一个变换模型。在这个视频中,我们将看看如何从 Transformers 库创建和使用模型。

正如我们之前所见,Automodal 类允许你从 I face 应用程序中的任何检查点实例化一个表现出的模型。它会从库中选择正确的模型类,以即时构建合适的架构并加载预训练模型的权重。

正如我们所见,当给定一个鸟类检查点时,我们最终得到一个鸟类模型,GPT2 或其他模型也是如此!

在幕后,这个 API 可以接受地球上检查点的名称,在这种情况下,它将下载并缓存配置文件以及模型权重文件。你还可以指定包含有效配置文件和模型权重文件的本地文件夹路径。要实例化模型,Automodal API 将首先打开配置文件,查看应该使用的配置类。

配置类依赖于模型的类型,比如 B、GPT2 或 Bt。一旦有了合适的配置类,它就可以实例化该配置,作为创建模型的蓝图。它还使用这个配置类来找到合适的模型类。

当与加载的配置结合时,就可以加载模型。它的模型还不是专业模型,因为它刚刚用随机权重初始化。最后一步是从模型文件中加载权重到这个模型中。

为了轻松地从任何检查点或包含配置文件的文件夹加载模型的配置,我们可以使用 autoconfig 类。像 Automod 类一样,它将从库中选择正确的配置类。

我们还可以使用一个特定的类,针对一个检查点,每次想尝试不同的模型架构时都需要更改代码。

正如我们之前所说,模型的配置是一个包含创建模型架构所需的所有信息的蓝图。例如,与基于鸟类检查点相关的鸟类模型有 12 层,隐藏层大小为 768,词汇量大小为 28996。

一旦我们添加了配置,就可以创建一个具有与检查点相同架构的模型,但它是随机初始化的。我们可以像任何其他模型一样从头开始训练它。我们还可以通过使用关键字参数来更改配置的任何部分。因此,这段代码片段会即时生成一个具有 10 层而不是 12 层的随机初始化布局模型。

一旦模型的趋势微调完成,保存模型非常简单。我们只需使用“Sa between”方法。在这里,模型将保存在当前工作目录下名为“My beltt model”的文件夹中。这样的模型可以通过“from between”方法重新使用。要了解如何轻松将该模型接入网络,请查看“push to video”。

官方教程来啦!5位 Hugging Face 工程师带你了解 Transformers 原理细节及 NLP 任务应用!<官方教程系列> - P12:L2.5 - Tokenizers 分词器概述 - ShowMeAI - BV1Jm4y1X7UL

在接下来的几段视频中,我们将查看令牌。在自然语言处理领域,我们处理的大部分数据由原始文本组成。然而,机器学习模型无法以原始形式读取或理解文本。它们只能处理数字。因此,分词器的目标是将文本转换为数字。

有几种可能的方法来进行这种转换,目标是找到最有意义的表示。我们将查看三种不同的组织算法。我们将逐一进行比较。因此,我们建议你按以下顺序观看视频。首先,基于词的。

然后是基于字符的,最后是基于子词的。😊!

官方教程来啦!5位 Hugging Face 工程师带你了解 Transformers 原理细节及 NLP 任务应用!<官方教程系列> - P17:L2.10- 批处理输入(PyTorch) - ShowMeAI - BV1Jm4y1X7UL

如何将输入批处理在这个视频中,我们还看到如何将输入序列批处理在一起。一般来说,我们想传递给模型的所有句子长度都不会相同。在这里,我们使用了在情感分析管道中看到的模型,想要对两个句子进行分类。当对它们进行标记并将每个标记映射到其对应的输入 ID 时。

我们得到两个长度不同的列表。试图从这两个列表创建一个张量或 Mbi 数组将导致错误,因为所有数组和张量都应该是规则的。克服这个限制的一种方法是通过添加特殊标记,将第二个句子的长度调整到第一个句子的长度,直到必要的次数。

另一种方法是将第一个序列的长度调整到第二个序列的长度。但是你将会失去很多可能对于正确分类句子必要的信息。一般来说,当句子的长度超过模型可以处理的最大长度时,我们才会截断句子。用于填充句子的值不应随机选择。

模型使用了某个填充 ID,你可以在 tokenazizerpa token8 中找到。现在我们有了更好的句子,我们可以将它们组合成一个批次。如果我们单独将这两个句子传递给模型,但将它们拼接在一起,我们会注意到填充在这里的第二个句子得不到相同的结果,这在 transformers 库中算不算一个 bug 呢?如果你还记得,transformers 会很方便地使用注意力层。

这不应该是一个完全意外的事情。当计算是每个标记的上下文表示时。注意力层会查看句子中的所有其他单词。如果你只有一个句子或几个填充标记的句子,那么,我们得不到相同的值是合乎逻辑的。为了获得有无填充的相同结果。

我们需要向注意力层指示,我们应该忽略那些填充目标。这是通过创建一个注意力掩码来完成的,它与输入 ID 具有相同的形状,并包含一系列的 0 和 1。1 表示注意力层在上下文中应该考虑的标记,而 0 表示应该忽略的标记。现在,将这个注意力掩码与输入 ID 一起传递,将会给我们与单独发送两个句子给模型时相同的结果。

这一切都是在后台由 tokenizer 完成的,当你将它应用于多个句子并将填充标志设置为时。它会将适当的值应用于较小的句子,并创建相应的注意力掩码。

官方教程来啦!5位 Hugging Face 工程师带你了解 Transformers 原理细节及 NLP 任务应用!<官方教程系列> - P22:L3.5- 使用 PyTorch 编写训练流程 - ShowMeAI - BV1Jm4y1X7UL

按部就班地编写你自己的训练循环。在这个视频中,沿着 Kaar 的思路,我们可以实现与训练视频中相同的功能,但不依赖于网络课堂。这样,你将能够轻松定制每种类型的训练循环,以满足你的需求。这对于手动调试训练 API 中出现的问题也非常有用。

在我们深入代码之前,这里是一个训练循环的草图。我们取一批训练数据并将其馈送给模型。通过标签,我们可以计算出较少的值。这个数字本身并没有用处,但用于计算我们模型权重的梯度;

这是关于每个模型权重的导数。这些梯度随后被优化器用来更新模型权重,使其变得更好。然后我们用一批新的训练数据重复这个过程。如果其中任何一项出现问题,请不要犹豫,重新复习你的深度学习课程。

我们将在这里再次使用 G MRRPC 数据集,并建议使用动态填充的数据集库来处理数据。如果你还没有看过,请查看下面的视频链接。完成这些后,我们只需要定义 PyTorch 数据加载器,它将负责将数据集的元素转换为补丁。我们使用我们的数据填充器作为正确函数,并对训练集进行处理,以确保我们不会按照便宜的顺序遍历样本。

为了检查一切是否按预期工作,我们尝试抓取一批数据并进行检查。就像该资产集元素一样,它是一个字典。但这次值不是单一的整数列表,而是按序列长度划分的形状大小。

下一步是将训练数据发送到我们的模型中。现在需要实际创建一个模型。正如在模型 API 视频中所见,我们使用前训练的方法,并将标签的数量调整为该数据集中的类别数量。同样,为了确保一切顺利,我们将批次传递给我们的模型,并检查是否没有错误。

如果提供了标签,Transence 库的模型总是会直接返回列表。我们将能够进行更少的步骤来计算所有的梯度。然后我们需要优化器来进行训练步骤。我们在这里使用 Adam W 优化器,它是具有适当权重衰减的 Adam 变体。

但是你可以选择任何你喜欢的优化器。利用之前的损失并计算我们所列出的梯度反向传播,我们检查能否在没有错误的情况下执行优化器步骤。不要忘记在之后将梯度归零,否则下一步将会加到你计算的梯度上。我们已经有了基本的训练循环,但我们添加了两项内容,使其尽可能完善。

第一个是学习率调度器,用于逐步降低学习率到0。Transformer库中的GtSched函数只是一个便利函数,用于轻松构建搜索器Sch。你也可以使用任何Pythto学习权重调度器。最后,如果我们希望训练持续几分钟而不是几个小时,我们需要使用GPU,第一步是通过使用协作书籍来获取一个实例。

然后你需要实际发送你的模型,并使用一个dashch设备进行训练。请检查以下几行,以确保你有好的数据库,或者准备好你的训练时间超过一个小时。我们无法将所有内容组合在一起。首先,我们将模型置于训练模式。这将激活一些层的训练行为,比如dropout。

然后,我们通过所选择的报告书数量和训练数据中的所有数据。接着,我们回顾我们已经看到的所有步骤,将数据发送到GPU,计算模型输出,特别是损失。使用列表来计算梯度,然后使用优化器进行训练步骤。更新包括学习率和我们下一个迭代的调度误差,以及优化器的梯度。

一旦完成,我们可以很容易地使用数据集库中的metric来评估我们的模型。😊首先,我们将模型置于评估模式,以停用像dropout这样的层。然后进行所有评估步骤。如我们在训练视频中看到的,模型输出的是logggets,我们需要应用Agm函数将其转换为预测。

然后,metric对象有一个net batch方法,我们可以用来发送中间预测。一旦评估循环结束,你只需调用compute方法以获取最终结果。恭喜你,你已经独立找到模型。

官方教程来啦!5位 Hugging Face 工程师带你了解 Transformers 原理细节及 NLP 任务应用!<官方教程系列> - P28:L4.5- 使用 TensorFlow 进行学习率调度 - ShowMeAI - BV1Jm4y1X7UL

在我们其他的视频中,我们谈到了如何使用 Tensorflow 微调语言模型的基础知识。每当我提到视频时,我会在下面链接它们。但仍然,我们能做得更好吗?所以这是我们模型微调视频中的代码。虽然它能工作,但我们绝对可以调整几个地方。

最重要的是学习率。在这个视频中,我们将讨论如何改变它,这将使你的训练更加一致成功。😊实际上,我们想改变默认学习率的两个方面。首先,对于我们的模型来说,它的值太高了。因此默认情况下。

Adam 使用的学习率是 10 的 -3 次方,对于训练变换器来说非常高。我们将从 5 乘以 10 的 -5 次方开始,比默认值低 20 倍。其次,我们不仅仅想要一个恒定的学习率。如果我们将学习率逐渐降低到一个很小的值,甚至在训练过程中降到 0,我们可以获得更好的性能。所以这就是这个多项式衰减调度的作用。

所以这个名称可能让人望而生畏,特别是如果你只模糊地记得来自 Atslas 的多项式是什么样子。那么我会在稍后给你展示这个衰减的样子。但首先我们需要告诉调度器训练将持续多长时间,以便它以正确的速度衰减,这就是这段代码的作用。😊

因此,我们在计算模型在整个训练过程中将看到多少个小批次。为此,我们取训练集的大小,除以批次大小,得到每个 epoch 的批次数,然后将其乘以 epoch 数,以获得整个训练过程中的总批次数。😊所以一旦我们知道了多少批次。

我们要进行的训练步骤数量,我们只需将所有这些信息传递给调度器,就准备好了。那么多项式衰减调度看起来是什么样的?使用默认选项时,它实际上只是一个线性调度,因此看起来像这样。它从我们的初始值开始,即 5 乘以 10 的 -5 次方,或者 5 e -5,然后以恒定速率衰减,直到在训练结束时达到 0。那么为什么叫它多项式而不是线性呢?如果你调整选项,可以得到一个更高阶的真正多项式衰减调度,但现在没有必要这样做,默认情况下。

你会得到一个线性调度,如果你知道线性函数是多项式的特殊情况,你可以感到骄傲。😊那么,撇开这些,我们如何实际使用调度器呢?我们只需将其传递给 Adam。你会注意到第一次我们编译模型时,我们仅仅传递了字符串。Curris 会识别常见优化器和损失函数的名称,所以用字符串传递可以节省时间,避免导入。

如果你只想要默认设置。但我们现在是专业的机器学习者,拥有自己的学习率调度,所以我们必须做好事情。我们做的第一件事是导入优化器。然后用学习率参数初始化它。接着,我们使用新的优化器和你想要的任何损失函数编译模型。

我们将保持不变。这将是稀疏分类交叉熵。如果你在观看微调视频时长时间跟随。但它可以是你自己使用的任何东西。😊。所以现在我们有一个准备好的高性能模型。剩下的就是像之前一样拟合模型。请记住,因为我们已经用新的优化器和新的学习率编译了模型。我们实际上不需要对调用的拟合做任何更改。我们只需在这里调用与之前视频中使用的完全相同的命令。😊。

但是现在我们得到了一个美丽的训练,顺畅而良好。一个好的初始学习率和稳定的学习率衰减。因此你将获得更好的性能。

官方教程来啦!5位 Hugging Face 工程师带你了解 Transformers 原理细节及 NLP 任务应用!<官方教程系列> - P4:L1.4- Transformer架构 - ShowMeAI - BV1Jm4y1X7UL

让我们研究 Transformer 架构。这个视频是关于编码器、解码器和编码器解码器系列视频的介绍视频。在这个系列中,我们将尝试理解 Transformer 网络的组成,并努力以简单的高级术语进行解释。无需对神经网络有深入理解。

但理解基本的向量和张量可能会有所帮助。为了开始,我们将从Pawa的原始论文《注意力是你所需要的一切》中提取此图。正如我们在这里看到的,我们可以根据我们要做的事情,利用其中的一些部分。我们想深入探讨具体的层,构建该架构。

但我们会尝试理解这架构可以被使用的不同方式。首先,让我们将该架构分为左侧的编码器和右侧的解码器。这两个部分可以一起使用,但也可以独立使用。让我们理解这些是如何工作的。

编码器接受代表文本的输入,并将这些文本转换为数字表示。这些数字表示也可以称为嵌入或特征。我们将看到,它使用自注意力机制作为其主要组件。我们建议你特别查看关于编码器的视频,以了解这些数字表示是什么,以及它是如何工作的。

😊我们将更详细地研究自注意力机制及其双向特性。😊解码器类似于编码器,也可以接受文本输入。它使用与编码器相似的机制,即被掩蔽的自注意力。由于其单向特性,它与编码器有所不同,通常以自回归方式使用。

在这里,我们也建议你查看关于解码器的视频,特别是为了理解这一切是如何工作的。将两个部分结合在一起形成了所谓的锚解码器或序列到序列变换。编码器接受输入并计算这些输入的高级表示。这些输出随后被传递给解码器。解码器使用编码器的输出和其他输入来生成预测。

然后预测一个输出,这将在未来的迭代中重用,因此称为自回归。最后,为了全面理解编码器-解码器,我们建议你查看关于编码器-解码器的视频。

是的。

官方教程来啦!5位 Hugging Face 工程师带你了解 Transformers 原理细节及 NLP 任务应用!<官方教程系列> - P7:L1.7- Transformer:编码器-解码器 - ShowMeAI - BV1Jm4y1X7UL

在这个视频中,我们将研究编码器-解码器架构。一个流行的编码器-解码器模型的例子是 T5。为了理解编码器-解码器的工作原理,我们建议您查看关于编码器和解码器的独立模型视频。

理解它们各自的工作原理将有助于理解编码器-解码器的工作原理。让我们从我们所了解的编码器开始。编码器将单词作为输入,经过编码器处理,并为每个经过的单词检索一个数值表示。我们现在知道这个数值表示包含关于序列意义的信息。

让我们把这个放到一边,给图表添加解码器。在这种情况下。我们以一种前所未见的方式使用解码器。我们将编码器的输出直接传递给它。此外,除了编码器输出之外,我们还给解码器一个序列。当请求解码器输出没有初始序列时。

我们可以给它一个表示序列开始的值。😊。这就是锚点装饰魔法发生的地方。😊,编码器接受一个序列作为输入。它计算一个预测并输出一个数值表示。😊。然后将其发送给解码器。从某种意义上说,它已经对该序列进行了编码。然后解码器。

反过来,使用这个输入和它通常的序列输入将尝试解码序列。解码器解码一个序列,并输出一个单词。到目前为止,我们不需要真正理解那个单词,但我们可以理解解码器本质上是在解码编码器的输出。这里的开始序列,这里启动序列的单词表明它应该开始解码序列。

现在我们有了编码器的数值表示和一个初始生成的单词。我们不再需要编码器。正如我们之前看到的,解码器可以以自回归的方式工作。它刚刚输出的单词现在可以用作输入。这与编码器输出的数值表示相结合。

现在可以用来生成第二个单词。请注意,第一个单词仍然存在,因为模型仍然输出它。然而,我们已将其灰化,因为我们不再需要它。😊,我们可以继续下去。例如,直到解码器输出我们认为的停止值,比如一个句号,表示序列的结束。在这里,我们看到了编码器-解码器变换器的完整机制。

我们再回顾一次。我们有一个发送到编码器的初始序列。😊。然后,该编码器输出被发送到解码器进行解码。虽然在单次使用后它可以丢弃编码器,但解码器将被多次使用,直到生成所需的每一个单词。

让我们来看一个具体的例子,关于翻译语言建模,也称为转导。这是翻译一个序列的行为。在这里,我们想把这句英语序列“welcome to NYYC”翻译成法语。我们使用一个专门为这个任务训练的变换器模型。我们使用编码器来创建英语句子的表示。

我们通过使用起始序列单词将其传递给解码器。我们请它输出第一个单词。它输出“B avenue”,这意味着欢迎。然后我们将“B avenue”作为解码器的输入序列。这个与编码器的数值表示结合,允许解码器预测第二个单词“a”。

在英语中,这是两个单词。😊 最后,我们请解码器预测第三个单词,它预测了“NYC”。这是正确的,我们已经翻译了这个句子。编码器和解码器真正出色的地方在于,我们有一个编码器和一个解码器,它们通常不共享权重。因此,我们有一个完整的块,即编码器,可以被训练来理解序列并提取相关信息。

对于我们之前看到的翻译场景,例如,这意味着解析和理解用英语说的内容。这将意味着从该语言中提取信息,并将所有这些信息放入一个信息密集的向量中。😊 另一方面,我们有解码器,其唯一目的是解码编码器输出的数值表示。

这个解码器可以专门用于完全不同的语言,甚至是图像或语音等模态。编码器和解码器有几个特别的原因。首先,它们能够管理像我们刚刚看到的翻译这样的序列到序列的任务。其次,编码器和解码器部分之间的权重不一定是共享的。

让我们再举一个翻译的例子。在这里,翻译变换器在法语中很强大。首先,这意味着从三个单词的序列中,我们能够生成四个单词的序列。有人可能会争辩说,这可以通过一个以自回归方式生成翻译的解码器来处理。他们是对的。另一个序列到序列变换器出色的例子是摘要生成。

在这里,我们有非常非常长的序列,一般是一整篇文本,我们想要对其进行总结。由于编码器和解码器是分开的,我们可以有不同的上下文长度,例如,编码器处理文本时的非常长的上下文,以及解码器处理摘要序列时的较小上下文。序列到序列模型有很多。

这包含了一些在变换器库中流行的编码器-解码器模型的示例。此外,你可以在编码器-解码器模型中加载编码器和解码器。😊 因此,根据你所针对的特定任务,你可以选择使用在这些特定任务上证明其价值的特定编码器和解码器。

官方教程来啦!5位 Hugging Face 工程师带你了解 Transformers 原理细节及NLP任务应用!<官方教程系列> - P13:L2.6- 基于词的分词器 - ShowMeAI - BV1Jm4y1X7UL

是的。让我们来看看基于词的分词。基于词的组织思想是通过在空格或其他特定规则(如标点符号)处分割原始文本来将其拆分成单词。在这个算法中,每个单词都有一个特定的编号或ID。

这里有 VI 250,Du 有 861,带有感叹号的分词是 345。😊。这个方法很有趣,因为模型的表示是基于整个单词的。单个数字所承载的信息量很大,因为一个单词包含了很多上下文和语义信息。然而,这种方法确实有其局限性。😊,例如。

单词 dog 和单词 dogs 非常相似,且它们的含义相近。然而,基于词的分词器会对这两个词赋予完全不同的概念。因此,模型将为这两个词学习到两个不同的嵌入。这是非常遗憾的,因为我们希望模型理解这两个词确实是相关的。

而 dogs 仅仅是单词 dog 的复数形式。这个方法的另一个问题是,语言中有很多不同的单词。如果我们希望模型理解该语言中的所有可能句子,那么我们需要为每个不同的单词分配一个ID。总的单词数量。

这也被称为词汇大小,可以迅速变得非常庞大。这是个问题,因为每个ID都映射到一个大型向量,该向量表示单词的含义。跟踪这些映射需要大量的权重。当词汇大小非常大时。😊,如果我们希望我们的模型保持简洁。

我们可以选择让分词器忽略某些我们不一定需要的单词。例如,在训练我们的分词器时,我们可能只想取文本中最常见的10,000个单词,而不是从文本中取所有单词或所有语言的单词。以创建我们的基础词汇。分词器会知道如何将这10个词转换为数字。

000个单词被转换为数字,但任何其他单词将被转换为超出词汇表的词。或者像这里所示,未知词。不幸的是,这是一种折衷。模型对所有它不知道的单词将具有完全相同的表示。😊。如果存在许多未知词,可能会导致大量信息的丢失。

是的。

官方教程来啦!5位 Hugging Face 工程师带你了解 Transformers 原理细节及NLP任务应用!<官方教程系列> - P14:L2.7- 基于字符的分词器 - ShowMeAI - BV1Jm4y1X7UL

在深入了解基于字符的分词之前,理解这种分词的有趣之处需要了解基于词的分词的缺陷。如果你还没有看到关于基于词的组织的第一部视频,建议你在观看这个视频之前先去看看。😊好的,让我们看看基于字符的分词。😊

我们现在将文本拆分为单个字符而不是单词。😊一般来说,有很多不同的单词和语言,而字符的数量相对较少。首先,让我们看看英语。它估计有170,000个不同的单词,因此我们需要一个非常大的词汇来涵盖所有单词。😊

在基于字符的词汇中,我们只需256个字符即可,这包括字母、数字和特殊字符。即使是字符众多的语言,如汉语,也可以拥有多达20,000个不同字符的字典,但不同的单词超过375,000个。

所以基于字符的词汇让我们使用比基于词的分词字典更少的不同令牌。😊这些词汇也比它们的基于词的词汇更完整,因为我们的词汇包含了语言中使用的所有字符,甚至在分词器训练期间未见过的单词仍然可以被分词。

所以我们的词汇令牌会更少出现。😊这包括正确标记拼写错误的单词的能力,而不是立即将其视为未知。😊然而,这个算法也并不完美。😊直观地说,字符单独所承载的信息不如一个单词所承载的信息多。😊例如,让我们持有比其首个数据L更多的信息。当然,这并不适用于所有语言。

因为一些语言(如表意文字语言)在单个字符中承载了很多信息。😊但对于像罗马字母这样的语言,模型必须同时理解多个令牌才能获取原本在单词中承载的信息。

这导致了基于字符的分词器的另一个问题。它们的序列被转换为大量的令牌供模型处理。这可能会影响模型携带的上下文大小,并减少我们可以用作模型输入的文本大小,这通常是有限的。😊

这个组织虽然有一些问题,但在过去取得了一些非常好的结果。因此,在面对新问题时,应考虑它,因为它解决了基于词的算法中遇到的问题。

嗯。

官方教程来啦!5位 Hugging Face 工程师带你了解 Transformers 原理细节及NLP任务应用!<官方教程系列> - P16:L2.9- Tokenizer流水线处理 - ShowMeAI - BV1Jm4y1X7UL

所以有了一个良好的流水线。在这个视频中,我们将看看标记器如何将文本转换为模型可以理解的数字,就像当我们执行这个好的例子时。这里是Tokener对象内部发生事情的快速概述。首先,文本被拆分成单元,这些单元可以是单词、词的一部分或标点符号。然后标记器添加潜在的特殊标记,并将每个标记转换为我们唯一的各自ID。

正如标记器的词汇所定义的。正如我们将看到的,这个顺序并不是完全如此,但这样做对她的理解更好。第一步是将输入文本拆分为标记,我们使用标记化方法来实现这一点。为此,标记器可能首先执行一些操作,比如小写或处理单词。

并遵循一套规则将结果拆分成小块文本。大多数转换模型使用子词组织算法。这意味着一个给定的单词可以拆分为多个标记,就像这里的标记。有关更多信息,请查看下面链接的标记化算法视频。

我们在“Is”前面看到的ash ash前缀是鸟类用来表示其标记不是世界开始的一个约定。然而,其他标记器可能使用不同的约定。例如,Albert标记器将在所有其前面有空格的标记前添加一个长下划线。这是所有句子最佳标记器共享的约定。

标记化流水线的第二步是将这些标记映射到各自的ID,正如标记器的词汇所定义的。这就是为什么当我们瞬时使用某种形式的方法接触标记器时需要下载一个文件。我们必须确保使用与模型展示时相同的映射。为此,我们使用将转换为ID的方法。你可能已经注意到,我们没有得到与第一张幻灯片完全相同的结果。

这看起来像是一串随机数字。在这种情况下,请让我提醒你一下。我们缺少的在开头和结尾的数字。那些就是特殊标记。特殊标记是通过适当的形式化方法添加的,该方法知道词汇中标记的索引,并在输入ID列表中添加适当的数字。

你可以查看特殊标记,更一般地说,通过使用deco方法和标记器对象的输出来观察标记器如何改变了你的文本。至于“世界”部分的前缀,特殊标记是否会因你使用的标记器而有所不同。B标记器在集合上使用CLS,但Robertta标记器在调用S和/lash S时使用HTML Tml。

现在你知道了分词器的工作原理,你可以忘记所有中间的内容,只需记住你只需在输入文本上调用它。分词器的输出不仅仅包含输入ID,然而。有关注意力掩码的位置,请查看批量输入视频。要了解分词类型的想法,请查看过程、句子视频。

官方教程来啦!5位 Hugging Face 工程师带你了解 Transformers 原理细节及NLP任务应用!<官方教程系列> - P18:L2.11- 批处理输入(TensorFlow) - ShowMeAI - BV1Jm4y1X7UL

在这个视频中,我们将看到如何将两个批量输入序列结合在一起。一般来说,我们希望传递给模型的句子都具有相同的长度。这里我们使用的是在情感分析管道中看到的模型,想要对两个句子进行分类。当对它们进行标记并将每个标记映射到其对应的输入 ID 时。

我们得到两个不同长度的列表。尝试从这两个列表创建一个张量将导致错误,因为所有数组和张量应该是矩形的。克服这个限制的一种方法是通过添加一个特殊标记,使第二个句子的长度与第一个相同,必要时可以添加多次。

另一种方法是将第一个序列截断到第二个的长度,但这样我们将失去很多可能对正确分类句子必要的信息。一般来说,只有当句子超过模型可以处理的最大长度时,我们才会截断句子。用于填充序列的值不应随意选择。

模型已经用某个填充 ID 进行训练,你可以在 tokenizer 的 tokenid 中找到。现在我们填充了句子,可以用它们创建一个批次。如果我们单独或批量传递两个句子到模型中,我们会注意到有效句子(这里是第二个)并没有得到相同的结果。

所以,这就是变压器库的最佳表现,如果你记得变压器模型轻松使用注意力层。这不应该让人感到惊讶。当计算每个标记的上下文表示时,注意力层会查看句子中的所有其他单词。如果我们只有一个句子或带有多个填充标记的句子,我做的事情是外科手术。

我们得到的值并不相同。为了在有或没有填充的情况下得到相同的结果,我们需要告诉注意力层忽略填充标记。这是通过创建一个注意力掩码来完成的,该张量与输入 ID 具有相同的形状,包含零和其他值。一旦指示注意力层在上下文中应考虑的标记和应忽略的零标记。

现在,传递这个注意力掩码和输入 ID,将给我们与将两个句子单独发送到模型时相同的结果。 tokenizer 在你将它应用于多个句子时,会在幕后完成这一切,使用标志 padding equal through。

它将以适当的值对较小的句子应用填充,并创建适当的注意力掩码。

官方教程来啦!5位 Hugging Face 工程师带你了解 Transformers 原理细节及NLP任务应用!<官方教程系列> - P19:L3.2- 预处理句对数据(PyTorch) - ShowMeAI - BV1Jm4y1X7UL

如何提出句子对。我们已经见识了如何对单句进行分词并将其拼接到覆盖输入中。如果这段代码对你来说有些陌生,请务必再次查看视频。在这里,我们专注于任务,但分类个人句子。例如,我们可能想要判断我们的两个文本是否是相同的。

这是从Qa问题P数据集中提取的示例,专注于识别重复问题。在第一对中,这两个问题在第二种格式下是重复的。

另一个分类问题是我们想知道两个句子是否在逻辑上相关。这是一个称为自然语言推理的问题。在这个从multiana数据集中提取的例子中,我们为每个可能的标签准备了一对句子,矛盾、网络或确证。

这是一种华丽的说法,意味着第一句暗示第二句。

所以,某些配对分类确实是一个值得讨论的问题。实际上,在群体基准中,这是一个文本验证的学术基准。10个数据集中的8个专注于使用句子对的任务。这就是为什么像Bt这样的模型通常采用双重目标。

除了语言建模目标外,我们通常还有与句子对相关的目标。例如,在共同训练过程中,B展示了一对句子,并必须预测随机掩盖的标记的值以及第二句是否从第一句引出。

幸运的是,transformer库中的Tukenezer有一个不错的API来处理句子对。你只需将它们作为两个参数传递给分词器。在我们已经学习的输入ID和附加掩码之上,它返回一个新字段,称为token type 8s,这告诉模型哪个可以映射到第一句。

哪些属于第二句?稍微放大一下,这里有与我们各自的标记类型ID和注意力掩码对应的输入ID。我们可以看到分词器也添加了特殊标记。所以我们有一个C S标记,来自第一句的标记,还有一个来自第二句的septukin标记。

以及一个最终的septuken。如果我们有多个句子对,可以通过传递第一句的列表,然后是某些句子的列表,以及我们已经学习的所有关键字参数,如填充选项,来整合它们。

放大后,我们可以看到分词器如何为第二对句子添加填充,以使两个输出具有相同的长度,并正确处理两个句子的标记类型ID和注意力掩码。这已经是一个2次传递的模型。

官方教程来啦!5位 Hugging Face 工程师带你了解 Transformers 原理细节及NLP任务应用!<官方教程系列> - P20:L3.3- 什么是动态填充? - ShowMeAI - BV1Jm4y1X7UL

什么是动态填充?在将输入批量组合的视频中,我们看到能够将不同长度的输入分组到同一批次中。我们需要为所有较短的输入添加填充标记,直到它们都相同。例如,这里最长的句子是第三个,我们需要添加五个填充标记。

两个或七个填充标记到其他句子中,以使四个句子具有相同的长度。在处理单词数据集时,我们可以应用一些有价值的策略。因此,我们大多数情况下使用的一个策略是将数据集的所有元素填充到相同的长度,即最长样本的长度。这将使我们得到的补丁都具有由最大序列长度决定的相同形状。

所以缺点是补丁由短句组成,我们有很多填充标记。这会引入模型中我们最终不需要的更多计算。为避免这种情况,另一种策略是将元素拼接到批次中最长的句子上。这样,批次就由短输入电压组成,且小于包含数据集中最长句子的批次。

这将在CPU和GPU上带来不错的速度。因此缺点是所有批次将具有不同的形状,这会在像TPU这样的加速器上减慢速度。让我们在实践中应用这两种策略。我们实际上已经看到在我们提出的Ar PCC数据集中应用了固定填充,在对数据集进行分词后,我们对整个数据集应用了带填充的分词,使所有样本的长度为128。

因此,如果我们将此数据集传递给一个批次数据,我们得到的补丁形状为补丁大小,这里是16和528。要应用动态填充,我们必须推迟填充到批次准备中。所以我们从分词函数中移除那部分。我们仍然保留合并部分,以便处理大于模型通常接受的最大长度(通常为512)的输入,这些输入会被截断到该长度。然后我们通过使用数据策展人动态填充一些填充标记。

转换库中的这些类负责在形成批次之前应用所有最终的预处理。在这里,带填充的解码器将所有样本填充到补丁中的最大长度。我们将其传递给Pyth的拼接函数,并观察到批次生成的长度各不相同,远低于之前的128。动态填充在CPU和GPU上几乎总是更快,因此如果可以的话,您应该应用它。

但是,请记住,如果您在TU上运行训练脚本或需要固定批次,请切换回固定填充!

官方教程来啦!5位 Hugging Face 工程师带你了解 Transformers 原理细节及NLP任务应用!<官方教程系列> - P25:L4.2- 预处理句对数据集(TensorFlow) - ShowMeAI - BV1Jm4y1X7UL

如何处理句子对?我们看到将单个句子进行归类并在批量输入视频中一起批量处理。如果这段代码对你来说不熟悉,一定要再看一遍视频。这里我们将专注于分类句子对的任务。例如,我们可能想要澄清两个文本是否是短语。

这是来自Q问题P状态Det的一个示例,专注于识别重复问题。在第一个对中,这两个问题是重复的,在第二个面板中。

词分类问题是当我们想知道两个句子在逻辑上是否相关。一个名为自然语言推理(natural language inference,NI)的程序。在这个例子中,取自多分析数据集,判断每对句子是否符合可能的标签:矛盾、无关或蕴涵,这是一种 fancy 的说法,表示第一个句子暗示第二个句子。

因此,分类句子对是一个值得研究的问题。实际上,在小组基准测试中,这是一个学术性文本分类基准,10个数据集中的8个集中在使用句子对的任务上。这就是为什么像Pert这样的模型通常呈现出双重目标。

在作为语言建模目标的顶层,它们通常在句子拼写方面有一个目标。例如,在对比过程中,B会被展示一对句子,并必须预测随机新掩码的值,以及第二个句子是否从第一个句子推导而来。幸运的是,取自Toms库作为ICPI来处理句子对。

你只需将它们作为两个参数传递给分词器。而作为输入的 top 和我们已经研究过的注意力掩码,它会返回一个名为 token type ID 的新字段,告诉模型哪些 token 属于第一个句子,哪些属于第二个句子?在这里稍微看看输入 ID 如何与我们对应的 token type ID 对齐。

以及注意力掩码。我们可以看到分词器还添加了特殊 tokens,所以我们有 CS token,从第一个句子的 su tokens,一个步骤 token,来自第二个句子的 token,以及最后的步骤 token。如果我们有多个句子对,可以通过传递第一个句子列表和第二个句子列表将它们一起处理。

同时,关键词参数我们已经研究过,比如填充等于。

放大后,我们可以看到分词器如何为特定的句子对添加填充,使两个输出系统长度一致。它还恰当地处理了AD Ds和关注机制,以适应这两个句子。

这就已经可以从模型中传递出去。

。是的。

官方教程来啦!5位 Hugging Face 工程师带你了解 Transformers 原理细节及NLP任务应用!<官方教程系列> - P26:L4.3- Keras介绍 - ShowMeAI - BV1Jm4y1X7UL

在这个视频中,我将给你一个关于我们的 Transformer 模型如何与 TensorFlow 和 Keras 协同工作 的简要介绍。非常简单的解释是,我们所有的 TensorFlow 模型也是 Keras 模型对象,因此它们拥有标准的 Keras 模型 API。😊 如果你是一个有经验的机器学习工程师,已经频繁使用 Keras,那可能这就是你开始与之合作所需知道的一切,但对于其他人来说。

包括那些回归的浪子 PyTorch 工程师。我将迅速介绍 Keras 模型以及我们如何与它们合作。在我下面链接的其他视频中,我将更详细地讲解 Keras 模型的训练,但首先,从高层次上看,Keras 模型是什么?

因此,你的模型基本上包含了整个网络。它包含这些层和层的权重,并且还告诉模型如何处理这些权重。因此,它定义了从输入到输出的整个路径。如果你以前使用过 Keras,可能是通过手动构建模型对象来开始的。

你可以一个层一个层地添加,也许使用 model.dot.add 或功能性方法。这没什么错,很多出色的模型都是这样构建的。但你也可以一次性加载整个模型,包括权重。这非常有帮助,因为如你所见。

如果你尝试阅读论文或查看代码,你会发现 Transformer 的内部结构相当复杂,从头开始编写并准确实现这一切对于一位有经验的机器学习工程师来说也是一项艰巨的任务。但因为这一切都打包在模型内部,如果你不想担心那种复杂性,你就不需要担心。如果你是一名研究人员,想深入探讨,当然可以。

你还可以仅用一行代码加载一个预训练的、预配置的 Transformer 模型。😊。

当我早些时候提到 Keras API 时,它的优势在于,无论你是从头开始编写自己的模型,还是加载一个预训练的模型,你都通过相同的 API 与模型互动,因此你使用的正是那些少数相同的方法,你会一次又一次地看到这些方法,比如 fit。

编译和预测,正如我提到的,我们将看到具体的示例,展示如何在我下面链接的视频中使用这些方法。现在,要从这个视频中带走的关键点是,如果你以前从未见过Keras,那么这种整洁的封装意味着庞大的神经网络的所有复杂性变得可管理,因为你以完全相同的方式与之互动,使用完全相同的方法。

无论是一个巨大的预训练语言模型,还是你手动编写的简单模型。

官方教程来啦!5位 Hugging Face 工程师带你了解 Transformers 原理细节及NLP任务应用!<官方教程系列> - P30:L5.1- 模型Hub中心速览 - ShowMeAI - BV1Jm4y1X7UL

在这个视频中,我们将介绍 Huging F 模型 H 的导航。这是 Huging Face 的主页。要访问模型库,请点击右上角的模型选项卡。你应该会看到这个网页界面,可以分为几个部分。

在左侧,你会找到可以用来调整模型搜索的类别。第一类是任务。模型库中的模型可用于多种任务,包括自然语言处理任务,如问答或文本分类,但不仅限于此。其他领域的任务也可用。

如计算机视觉中的图像分类或语音中的自动语音识别。第二类是库。模型库中的模型通常共享三种骨干网之一:pytorrch、Tensorflowlow或jacks。然而,其他骨干网,如rust或onyx,也存在。最后,此选项卡也可用于指定模型来自哪个高层框架。

这包括变压器,但不局限于此。模型库用于托管许多不同框架的模型,我们也在积极寻找托管其他框架模型的机会。第三类是数据集选项卡。从该选项卡中选择数据集意味着过滤出在特定数据集上训练的模型。

第四类是语言选项卡。从此选项卡中选择一种语言意味着过滤出处理所选语言的模型。最后,最后一类允许选择与模型共享的许可证。

在右侧,你会找到可在模型H上使用的模型。

模型默认按下载量排序。点击一个模型后,你将看到其模型卡。模型卡包含有关模型的信息,包括其描述、预期用途、限制和偏见。它还可以显示如何使用模型的代码片段及任何相关信息,训练情况。

过程、数据处理、评估结果或版权。这些信息对模型的使用至关重要,越精心制作的模型卡,其他用户就越容易利用你的模型及其应用。

模型卡的右侧是推理API。这个推理API可以直接与模型进行交互。可以随意修改文本并点击Comp,查看模型对你输入的反应。

在屏幕顶部是模型标签。😊这些标签包括模型任务以及与我们刚才看到的类别相关的其他标签。😊。

文件和版本选项卡显示了该模型的仓库架构。这里我们可以看到定义该模型的所有文件。你将看到 getT 仓库的所有常规功能,包含可用的分支、提交历史以及提交的差异。

模型卡的顶部有三个不同的按钮。第一个展示了如何以编程方式使用推理 API。

第二个展示了如何在 SageMaker 中训练这个模型。最后一个展示了如何在适当的库中加载该模型,适用于 Bt。这就是 transformers。

嗯。

官方教程来啦!5位 Hugging Face 工程师带你了解 Transformers 原理细节及NLP任务应用!<官方教程系列> - P33:L6.1- Sylvain的在线直播讲解 - ShowMeAI - BV1Jm4y1X7UL

不过我觉得是时候开始了,欢迎来到这个课程,我们将一起学习第一章,这里是提问的最佳场所,请在聊天中提问,我会每五到十分钟查看一次聊天,阅读问题并尽量回答。

这个课程的目的如我所说,这一节将涵盖第一章,这一章旨在非常一般性地介绍变换模型的功能,所以你不需要担心目前的设置,几个好的样本将展示如何在coab中直接运行它们。

另一个是Greenface网站。我不会再看介绍视频,因为你可以在自己的时间里观看,视频内容没有什么信息。第一部分的目标,可能就是现在这个粉色部分,是为了向你介绍变换模型,今天的网络结构,并教你如何从Eb下载预训练模型,找出自己的数据以进行文本分类任务。

然后将结果传回模型。在第二部分,我们将更深入探讨所有NLP任务如何调整文本分类,而课程的最后一部分将进一步深入。因此第二部分将在秋季发布,第三部分将在明年初发布。

一旦你完成了这部分课程,你应该能够下载该模型,并在自己的问题上进行使用。然后,创建一个较小的上传,结果将传回中心。因此你应该查看论坛,我将展示如何讨论这个阶段。

接下来,你将在这个直播结束后,可以在课程类别中提出任何问题,每章都有一个讨论区供你提问,并且我会密切关注另一个讨论区,所以请分享你的项目主题,确保分享在学习课程第一部分后所做的任何构建。

嗯,好的。那么让我们深入探讨吧。如果现在没有任何一般性问题,我们就开始第一章。变换模型主要用于处理NLP任务,而NLP代表自然语言处理,这是一个与语言相关的领域。因此,NLP任务的目标是对一些文本进行分类。

例如,获取评论的情感,检测邮件是否为垃圾邮件,判断某个在线评论是友好还是不友好,判断句子是否语法正确,等等。我们的任务可以是对文本中的词汇进行分类,例如,能够解析语法成分,以判断这个词是人名、地点还是组织。

另一种NLP任务是生成文本内容。因此,完成一个提示是Jo smartF在你尝试撰写消息时所做的。通常它会建议使用X,甚至Gmail现在在邮件中也这样做。嗯。填充B syn文本,这是另一种文本生成。另一种任务是从文本中提取答案。

因此,给定一个非常长的文本,然后一个问题,模型能够提取该问题的答案。答案是从上下文中提取,或根据输入文本生成这些新句子。例如,生成文本的翻译,总结我最近看到的一个新文本的内容。

例如,一种随意风格或更正式的风格。所以这些都是课程中,特别是第2部分将要处理的各种enLP任务。而且这相当具有挑战性,因为计算机处理信息的方式与我们不同。因此,一个新的变换模型让你可以深入学习。

能够从你有标签的几个样本中恰当地进行概括,而不需要你去创建。例如,在深度学习盛行之前,一件事情是解析文本并有一些特殊规则,如果我看到这个词,也许意味着这是积极的;如果我看到这个词,也许意味着这是消极的,等等。对吧。所以这不是现在所做的,主要是使用可变换模型和再次使用face库。

这些模型,如果你还没有,你应该跟随一个深度学习课程的介绍。这些模型通常是经过训练的,并不遵循人类编写的一组特定规则。它们有权重,遵循一种称为梯度下降的算法,并根据输入的训练数据,它们在每一步使损失函数或指标变得更好,因此我们最终得到的模型有点像一个黑匣子。但我们可以使用并在数据上进行良好的概括,但看起来与训练集的数据相似。

所以让我们看看这个模型在实践中能做什么。因此,我们有两种方式可以做到这一点,第一种方式是点击这个“在颜色中打开”按钮。所以Collab是由谷歌维护的平台,提供免费的资源访问,例如在Jupyter Notebook环境中的GPU或TPU。

所以,你可以直接执行。好。

在其中。因此,第一个单元需要执行以安装我将要使用的所有库。我会让它运行,我们会稍微了解一下课程,然后我们就能运行其他好的样本,我稍后会回到那个窗口。所以变换模型无处不在,现在许多公司都在使用它们,这些是使用Gface模型的公司的示例,我们有预训练的模型,并可能在内部使用它们。

Transformers 库是提供访问这些模型的主要接口库。我们将快速浏览一下。稍后模型应用是所有后训练模型的所在,它是整个生态系统的一部分,我们将能够在稍后的模型应用中运行与在 Coab 笔记本上尝试的相同代码。您需要做的事情是访问论坛并能够玩弄所有模型,点击章节 1 中的链接。

所以我们首先来看更高层次的 API 对象,称为管道计划函数。

我会给大家几分钟时间。只是想给视频一些加载时间,并且回答你们在聊天中提出的任何问题。所以,我看到的第一个问题是,LSTM 模型(如 OMF)是否仍然有用?如果有,它们在哪些方面优于变压器模型,或者至少应该被考虑?这是一个非常好的问题。

非常好的问题,确实仍然有 LSTM 模型的应用。当前变压器模型被广泛使用的主要原因是计算效率更高,尤其是在硬件 TPU 和 GPU 上,因为 LSTM 依赖于递归机制,而这种机制的优化相对较难。不过,例如,LSTM 在 EMDB 数据集上取得了非常好的先进结果,该数据集用于电影评论分类。最近才发现变压器模型在该任务上的表现,我认为这与 EMDB 评论非常长有关,而变压器模型在处理较长序列时表现良好。

通常来说,它是 512,但对于 12 来说,如果有超过这个长度的内容,似乎 LSTM 模型可以看到。这将是一个非常好的选择。另一个问题,我会在这个视频之后回答,因为它是关于管道的。所以,嗯,让我们先看视频,我会从屏幕上消失,这样你们可以不受干扰地观看,视频结束后我会回来。

这是管道结束函数。管道函数是 Transformers 库中最高层次的 API。它将所有步骤组合在一起,从文本到可用的预测。使用的模型本质上是一个管道,但管道还包含所有必要的预处理,因为模型并不期望文本,而是数字。同时还包括一些后处理,使模型的输出易于人类理解。

让我们看一下保罗与情感分析管道的第一阶段。该管道对给定输入执行文本分类,并确定它是正面还是负面。这里它将正面标签归因于给定文本,置信度为 95%。你可以将多个文本传递给同一管道,这些文本将作为批处理一起处理并传递给模型。

输出是与输入文本顺序相同的个别结果列表。这里我们发现第一个文本的分数标签相同。第二个文本的标签是 church negative,置信度为 99.9%。零-shot 分类管道是一种更通用的文本分类管道。

它允许你提供想要的标签。这里我们想沿着教育、政治和商业的标签对输入文本进行分类。管道成功识别出它与教育标签的关系比与瑜伽标签更密切,置信度为 84%。接下来,我们的任务是文本生成管道,它将完成给定提示。输出是带有一点随机性的生成,因此每次在给定提示上调用生成器对象时都会有所不同。

直到现在,我们一直使用与每个任务相关的默认模型的 Biman APIpi。但你可以使用任何已经经过自由训练或微调的模型。哦。继续使用模型 H,再次是 F dogo slash models。你可以按任务过滤可用模型。我们之前示例中使用的默认成人模型是 GPT2。

但还有许多其他可用模型,而不仅仅是英文。让我们回到下一个生成管道,并用另一个模型 distill JPT2 加载它。这是由 Eingface 团队创建的 GT2 的轻量版本。将管道应用于给定提示时,我们可以指定多个参数。

例如生成文本的最大长度,以及我们想返回的句子数,因为生成中存在一些随机性。通过猜测 X12 生成文本是强度很大的,这也是 GPT2 的预训练目标。领域质量管道是 Bro 的一个预训练目标,目的是猜测质量的值。在这种情况下,我们根据模型询问两个最可能缺失单词的值。

并尽可能获得数学或计算方面的答案。任务转换模型的形式是对句子中的每个单词进行分类,而不是将整个句子作为一个整体。例如,这就是命名实体识别,它的任务是在句子中识别如人、组织或地点等实体。这里,模型正确识别了人,sva。

组织 Gface 以及输入文本中的布鲁克林位置。该组实体 equal2 参数的使用是将与同一实体相关的不同墙壁聚集在一起,例如这里的 eggging 和 face。通过 byg API 提供的新任务是提取式问题和对不起。提供一个上下文和一个问题,模型将识别上下文中包含答案的文本范围。

获取非常长文本的简短摘要也是Transformers库可以帮助的,特别是在摘要方面。最后,B API支持的最后一个任务是翻译。在这里,我们使用一个法英模型,从Mo Hub找到,用于获取我们快速文本的英文版本。这里是我们在这个视频中研究的所有任务的简要总结,可以通过现代Hub中的影响切换进行尝试。

是的。抱歉一开始的歌曲,我试着让自己更好,我不能在播放视频的同时专心,所以那部分似乎已经处理过了,对于延迟的问题,我尝试找到解决方案,但我不知道可能是什么,所以下一个视频可能会更好,我试着最小化操作系统,画面可能会更好。

所以我在视频前跳过的问题是,当你进行管道情感分析时,如何确定使用的是哪个模型,狗字符串并没有太大帮助。确实,它没有在文档中,我们可能应该努力使其更好地记录,最好的方法是检查源代码,现在我将给你展示这一点。所以,你需要继续。

进入管道,这是个很好的问题,实际上我们使其更易于访问和查看,但你需要进入管道模块的源代码,在文件中,你会看到每个管道所使用的默认模型,所以在这里我们使用文本分类和情感分析的默认模型是基于SS2英语的。

不知道为什么那个人没有选择一个短名字,但这就是它的名字。让我看看还有没有其他问题。是的,我会在聊天中发送下一个视频的链接,或者你可以同时在课程章节中跟随并直接查看它们,好的,看起来有很多其他问题,所以让我们继续。那么这一章。

所以本节的其余部分只是视频中展示的良好示例。所以我不打算详细介绍,而是要看看我的调用,希望。应该是。

我需要重启自己的时间,所有都是美好的。

希望重新安装所有内容不会花太长时间。好好好。你为什么要和我在一起?好的。这样对你会更顺畅一点。一旦我们安装了Transformers库,我们可以运行第一个单元,例如。与视频中的内容相同,没错。V是刚发布的最新版本的书。

所以我们无法在Collab上运行任何东西。这也很棒。不确定我们能否以某种方式获取你的版本。あ。好的,所以希望Pytoch的工作人员能尽快修复这个bug,你们都能在此期间轻松运行所有的collapse。

我将尝试在tripyter笔记本中向你展示同样的事情,我不打算做可以运行的事情。Ge。所以让我去。我不会在这里。所以如果你更喜欢在本地赢得笔记本。所有内容都在名为Notes的报告中,里面有一个Eing F Or,使用这个笔记本你有一个课程子文件夹,当你按章节或直接用于视频时。所以让我们看看。我们尝试在Collab中运行的同一个笔记本。放大一点。

让我们减少一点,好吗。所以在运行安装后。我不需要这样做,因为我已经安装好一切。你可以运行我们在视频中看到的代码,可以随意更改,试试其他句子,同时尝试多个句子。两次那里写的分类管道,和我们在视频中看到的所有管道。

😊,接下来。你可以尝试所有这些的另一种方式是模型。嗯。规范教育。不得有你怎么样。诶。你可以去的地方,所以模型会出现,你可以点击任何模型。例如,如果我们去,并将蒸馏基于案例好的转成英语。这是我们看到的情感分析管道的默认模型。

我们可以去那里,在一个小湿地方,我们可以。在任何句子上试试。并得到相同的结果。所以。你有哦元表。所以你至少有三种不同的方法来尝试所有的好样本。在推理API和网站上,有时当你尝试一个模型时,你会看到小进度条在加载,然后你可以在b或句子中试试。

所以。让我们。回到课程。下一部分。关于变换器模型如何工作的,变换器模型是相当新的。所以架构本身是在2017年的一篇论文中发布的,第一个预训练模型是G。由Open AI在2018年6月发布,第二个预训练模型Westbro在2018年10月由谷歌发布,然后它有点加速了,这里只是几个模型的示例。

但还有很多,很多更多。那些已经发布,尽管如此,我们至少需要这个图像变成两倍或三倍大,以便能够放下自2019年至今发布的每一个模型。真的很难跟上发布的基础。

但我认为变压器库现在有大约60种不同的架构,并在论文发布后尽快添加新模型。因此我们将在这里讨论的不是变压器模型内部的细节,而是一个概览。在本节中,我们将探讨三种类型的变压器模型,包括被称为自回归模型的GT模型。

这些变压器模型基本上是用于生成文本的。例如,当你的手机试图建议你可以在后续句子中使用的单词时,之前讨论的内容就是这种情况。另一种类型的变压器模型是类似于GT的模型,抱歉,不是编码器模型,而是解码器模型,抱歉,是自回归或解码器模型。

所以这些模型最适合分类事物,生成句子的a9表示,使你能够分类整个句子或句子中的每个单词,它们在我们之前讨论的提取式问答任务中也非常有效。

最后一种模型是序列到序列的变压器模型,即编码解码模型,它更适合处理序列到序列的文本,如翻译、摘要,基本上是从输入文本写出新的文本。因此,所有这些变压器模型都是语言模型,而前两种类型之间的主要区别在于。

编码器和解码器的区别在于解码器通过预测下一个单词来进行操作。这就是我们在生成文本方面表现出色的原因,因为这就是它们的运作方式。而编码器模型通常是通过在句子中填充一些随机掩码来进行训练。因此我们这里有两个例子。这些变压器模型非常庞大,我们最开始的开放AGTD模型仅有数百万个参数,而现在我们有数十亿或数百亿个参数的模型。

这就是为什么重用这个模型非常重要的原因,这就是迁移学习的全部意义。迁移学习是指你使用一个训练好的大模型,该模型在大量数据上进行训练,这需要消耗大量计算资源,排放了大量二氧化碳,然后重用该模型来解决新的任务。你希望处理的任务。因此,通过减少模型,而不是从头开始训练一个新的模型。

你节省了计算资源,节省了金钱,并且需要的数据比模型训练时所需的少。让我们来看一下我们新的问题。第一个问题是GT3是否是唯一允许零样本学习的模型?

这就是这个模型的推广方式,但并不是唯一的,因为 T5 也有类似的提示,例如让你总结这段文本或将这段文本从一种语言翻译成另一种语言,因此它也可以进行某种零学习。链接已经被回答过,所以让我们去看迁移学习的视频,希望这次比之前的要好一些,如果你想直接观看,我会在聊天中分享链接。

什么是迁移学习?迁移学习的理念是利用在另一个任务上通过大量数据训练的模型所获得的知识。模型 A 将专门为任务 A 进行训练。现在假设你想为不同的任务训练模型 B,一个选择是从头开始训练模型。这可能需要大量计算。

时间和数据。相反,我们可以用与模型 A 相同的权重初始化模型 B,从而转移模型 A 在 T P 上的知识。当从头开始训练时,所有中间的权重都是随机初始化的。在这个例子中,我们正在训练一个模型,以识别两个句子是否相似。

左侧是从头开始训练的模型,右侧是经过预训练的模型。可以看出,使用迁移学习的预训练模型产生了更好的结果。无论我们训练多长时间,从头训练的模型保持在 70% 的准确率,而经过迁移学习的模型轻松超过 86%。

这是因为预训练模型通常在大量数据上进行训练,但为模型提供了对训练期间使用的语言的统计理解。在计算机视觉领域,迁移学习成功应用了近 10 年。

模型经常在 ImageNet 上经过训练,该数据集包含 120 万张照片。每张图像被分类为 1000 个级别之一。这样的训练方法被称为监督学习,而在自然语言处理领域,迁移学习则相对较新。与 ImageNet 的一个关键区别在于,训练通常是自我监督的。

这意味着它不需要人工标注标签。一个非常常见的目标是预测句子中的下一个单词,这只需要大量文本。例如,GPT-2 就是通过使用用户在网络上发布的 4500 万个链接的内容进行训练的。

另一个自我监督预训练目标的例子是预测随机掩盖的单词。这类似于你在学校中可能做过的血液测试。这种方法使用了英文维基百科和 100 本已出版的书籍进行训练。在实践中,通过抛弃给定模型的头部来应用迁移学习。

其最后的层专注于预训练目标。并且使用一个新的随机初始化的适合任务的模型。例如,在之前构建模型时,我们移除了分类Mque的层,并用一个有两个输出的分类器替换,因为我们的任务在两个层面上。为了尽可能高效,使用的预训练模型应与其微调的任务尽可能相似。

例如,如果问题是对德语句子进行分类,最好使用一个德语模型。但好事与坏事相伴,预训练模型不仅转移了它的知识,还包括它可能包含的任何偏见。ImageNe主要包含来自美国和西欧的图像。

因此,使用微调模型通常会在这些国家的图像上表现更好。但是贝尼也研究了其Gpyy3预测中的偏差,涉及使用猜测和X世界目标。将E Westbury的性别从“他”更改为“她”会改变预测结果,主要为中立目标。

几乎只针对物理模型。在GT2 Mor的模型代码中,OpenAI也承认其偏见,并不鼓励在与人类互动的系统中使用它。

嗯。

好吧,让我看看视频上是否有任何问题。😔 我认为没有。好的,这就是迁移学习的非常高层次的介绍,这通常是用变换器模型完成的。例如,我们之前使用的模型distill B,它在62数据集上进行了微调,这个数据集包含句子,你需要将它们分类为正面或负面。

除非有新的问题,否则我认为我们已经可以稍微深入探讨变换器架构,因此奥马尔将在聊天中发布该视频的链接。我希望这次不会再卡顿,因此这个视频将介绍我们之前简要讨论过的Odo解码器序列到序列变换器模型之间的区别。

让我们研究变换器架构。这个视频是关于Ens解码器Ender解码器系列视频的介绍。在这一系列中,我们将尝试理解变换器网络的构成,并试图用简单的高层次术语进行解释。对神经网络的深入理解并不是必要的。

但对基本向量和张量的理解可能会有所帮助。为了开始,我们将引用原始变换器论文中的这一图表,题为“注意力即一切”,通过对其进行阐述。如我们所见,我们只能根据我们的目标利用其中的部分内容。我们希望深入探讨这些特定的层,构建出该架构。

但我们将尝试理解这种架构的不同使用方式。让我们首先将架构分为两部分,左边是编码器,右边是解码器。这两者可以一起使用,但也可以独立使用。让我们理解它们是如何工作的。编码器接受表示文本的输入。

它将这些文本,这些词转换为数值表示。这些数值表示也可以称为嵌入或特征。我们将看到它使用自注意力机制作为其主要组件。我们建议你专门查看关于编码器的视频,以理解这种数值表示是什么以及它是如何运作的。

😊,我们将更详细地研究自注意力机制及其双向特性。😊。解码器与编码器类似,它也可以接受文本输入。它使用与编码器相似的机制,即掩蔽自注意力。由于其单向特性,它与编码器有所不同,传统上以自回归方式使用。

在这里,我们也建议你查看关于解码器的视频,特别是为了理解这一切是如何运作的。将这两个部分结合起来,形成了所谓的锚解码器或序列到序列转换。编码器接受输入并计算这些输入的高级表示。这些输出随后传递给解码器。解码器使用编码器的输出和其他输入来生成预测。

然后预测一个输出,这将在未来的迭代中重用,因此称为自回归。最后,为了全面理解编码器解码器,我们建议你查看关于编码器解码器的视频。

好吧,这就是一般介绍,基本上这是你需要记住的关于一般变换器架构的图表。那么什么是编码解码器或编码解码器模型呢?在深入了解之前,我们稍微讨论了注意力的内容。

原始论文的图表,所以架构的核心,变换器模型是这个称为多头注意力的层。这一层基本上表明了基本注意力。因此,它将查看你的整个句子。输入序列中的每个词都将计算一个分数,以关注这个词或其他词。这是因为变换器架构最初是为翻译设计的,当你翻译一个特定的词时,你需要这个词,但你需要理解其周围的上下文。例如,你可能需要在词的性别上下文中,如果词是名词,你可能需要其性别,即前一个词,或者后面的某些词。

所以注意力层是计算给定世界的一些上下文表示的地方。它用于告诉所有与这个特定单词相关的内容,尤其是这个单词,虽然这个世界不太有用,但这个你真的应该关注,它将在第2节和第3节中有视频,详细讲解注意力层是什么,但这就是我对第一层的介绍。

编码器和解码器之间的关键区别在于,编码器的注意力机制可以查看句子中的每个单词。因此,前面的单词和后面的单词,因为像鸟模型那样,当你需要检测时。

抱歉,要猜测一个掩码词的值,查看前面的内容以及后面的内容是有用的。解码器模型如GT必须预测下一个单词。所以如果它们被允许查看后面的单词,那将是作弊。因此在这些模型中,注意力层只允许查看句子中前面的内容。例如,当试图猜测“银”时,注意力层只能查看“我的名字”,而不能查看句子中的后面内容。

是的,我们将切换到本章关于Ocuoss模型的下一节,但在此之前,让我看看是否有任何问题。在解码器图中,输出右移指的是什么,请问。让我检查一下那个图。这里。因为我们正在训练一个翻译模型,请记住这是变换器模型的原始架构,所以当你翻译一个英文短语句子时,输出是一个法语句子。因此,这里的标签你这个变换器模型的部分是解码器,它会尝试猜测下一个单词,所以它会从无开始,然后尝试开始句子的第一个单词,然后它将有句子的第一个单词来尝试获取句子的第二个单词,然后它将有句子的第一个单词来获取句子的第三个单词。

等等,所以右移的意思是我们有输出,即所需语言的文本右移一个标记。还有另一个问题,你能否提供一个快速的直观概述,说明数字版本的模型如distber如何在显著减轻的情况下保持准确性。

快速概述直观。好的。一般来说,变换器模型或深度学习模型有很多参数,数百万个。但其中很多参数要么是冗余的,要么并不一定真正有用,因此例如有很多研究致力于修剪变换器网络,修剪意味着移除一些权重以便能够更快,尤其是在每个时刻。

蒸馏是另一种减少模型大小的方法,其过程是让一个较小的模型尝试输出一个较大模型的结果,并且它的性能仍然相当不错。因此,这背后的直觉是,一个非常大的模型有很多参数。

但并不是所有这些参数都真的有用。因此,让我们深入探讨编码器模型,我们还有三段视频,编码器、解码器,然后是序列到序列模型。

我们将其置于全屏并进行设计。

在这个视频中,我们将研究编码器架构。一个流行的仅编码器架构的例子是Bt,这是同类中最受欢迎的模型。让我们首先了解它是如何工作的。我们将使用三个单词的小示例,将它们作为输入并传递给编码器。

我们检索每个单词的数值表示。例如,这里的编码器将三个单词“欢迎”、“到”、“NYC”转换为这三个数字序列。编码器对每个输入单词输出恰好一个数字序列。这个数值表示也可以称为特征向量或特征张量。

让我们深入探讨这个表示。它包含一个经过编码器处理的每个单词的向量。每个向量是该单词的数值表示。该向量的维度由基础鸟模型的架构定义,维度为768。这些表示包含了一个单词的值,但具有上下文化。例如。

与单词2相关的向量不仅是两个单词的表示。它还考虑了周围的单词,我们称之为上下文。例如,它查看左侧上下文,即我们正在研究的单词左边的单词;听到单词“欢迎”,以及右侧的上下文,这里是单词“NYC”。

它输出一个值,用于给定上下文中的单词。因此,这是一个上下文化的值。😊可以说,768个值的向量在文本中承载了单词的含义。它依赖于自注意力机制。自注意力机制与单个序列中的不同位置或不同单词相关,以便计算该序列的表示。

正如我们之前所见,这意味着一个单词的原始表示受到序列中其他单词的影响。我们在这里不会深入这些细节,但如果你想更好地理解幕后发生了什么,我们会提供一些进一步的阅读材料。

那么什么时候应该使用编码器?编码器可以作为独立模型在多种任务中使用。例如,Bert,无疑是最著名的变换模型,是一个独立的锚定模型。在发布时,它在许多序列分类任务、问答任务和掩码语言建模中是最先进的,仅举几例。😊

这个想法是编码器在提取携带有意义信息的向量方面非常强大。这个向量可以通过额外的神经元进一步处理,以使其有意义。让我们来看一些编码器真正闪光的例子。首先是掩码语言建模或MLM。这是预测序列中隐藏词的任务。在这里。

例如,我们隐藏了“my”和“is”之间的词。这是Bert训练的目标之一。它的训练目的是预测序列中的隐藏词。编码器在这种情况下特别出色,因为双向信息在这里至关重要。

如果我们没有右边的词,是Silva和点。那Bt几乎没有机会将名称识别为正确的词。编码器需要对序列有很好的理解,以便预测被掩盖的词,因为即使文本在语法上是正确的,也不一定在序列的上下文中有意义。

如前所述,编码器擅长进行序列分类。😊情感分析就是序列分类的一个例子。模型的目标是识别序列的情感。它可以为序列评分,从一到五颗星,或者为序列给予正面或负面的评分。

这就是这里所展示的。例如,给定这两个序列。我们使用模型来计算预测,并将这两个序列分类为正类和负类。虽然这两个序列非常相似,包含相同的单词,但含义完全不同,而编码模型能够把握这种差异。

嗯。这就是forcodo模型,一些例子是Albertt、Bt、distill Bt、Elect、Roberta。我们来看看下一部分,将讨论解码器。在此之前,让我检查一下是否有任何问题。聊天中没有看到新的问题,别忘了你可以在聊天中提出任何问题,这正是直播会议的目的。

是的。

在这个视频中,我们将研究解码器架构。一个流行的仅解码器架构的例子是GPT2。为了理解解码器是如何工作的,我们建议观看关于编码器的视频,它们与解码器非常相似。解码器可以用于大多数与编码器相同的任务。

尽管通常性能会稍有损失。让我们采取与编码器相同的方法,尝试理解编码器和ID解码器之间的架构差异。我们将使用一个包含三个单词的小例子。我们将它们传递给解码器。我们为每个单词检索一个数值表示。在这里,例如。

解码器将“welcomee to NYC”这三个词转换为三个数字序列。解码器每个输入词准确输出一个数字序列。这个数值表示也可以称为特征向量或特征张量。让我们深入研究这个表示。它包含通过解码器传递的每个词的一个向量。

这些向量中的每一个都是相关词的数值表示。😊该向量的维度由模型的架构决定。解码器与编码器的主要区别在于其自注意力机制。它使用被称为掩蔽自注意力的机制。在这里,例如,如果我们专注于词“2”。

我们会看到这个向量在纽约市的词汇中完全没有被修改。这是因为右侧的所有词语,也称为该词的右上下文,都被屏蔽了。因此,解码器并没有利用左右两侧的所有词语,也就是双向上下文。解码器只能访问单一的上下文,可以是左上下文或右上下文。

掩蔽自注意力机制与自注意力机制的不同之处在于使用了额外的掩蔽,以隐藏词语两侧的上下文。词语的数值表示不会受到隐藏上下文中词语的影响。那么,何时使用解码器呢?解码器可以像编码器一样作为独立模型使用。因为它们生成数值表示,也可以用于各种任务。

然而,解码器的强大之处在于词语只能访问其左侧的上下文。仅访问左侧上下文,使它们在文本生成方面具有天生的优势。给定一个已知的词序列,生成一个词或一系列词的能力。😊这被称为因果语言建模或自然语言生成。

这是一个因果语言建模如何工作的例子。我们以初始词“my”开始。我们将其用作解码器的输入。😊,模型输出一个数字向量。这个向量包含有关序列的信息,这里是一个单词。我们对该向量应用一个小的变换,以使其映射到模型已知的所有词。

这是我们稍后将看到的一个映射,称为语言模型头。我们识别出模型认为最可能的下一个词是“name”。然后,我们将这个新词添加到初始序列中。从“my”开始,我们现在得到了“my name”。这就是自回归特性的体现。😊

自回归模型将过去的输出重用为输入和后续步骤。再一次,我们执行完全相同的操作。我们通过解码器处理该序列,并检索出最可能的下一个词。在这种情况下,它是“is”这个词。我们重复这个操作,直到满意为止。从一个单词开始,我们现在生成了一个完整的句子。我们决定在此停止。

但我们可以继续一段时间。比如说,GPT-2 的最大上下文大小是 1024。我们最终可以生成多达 1024 个单词,而解码器仍然会记住它们的前几个单词和那个序列。😊,是的。游戏。让我看看关于解码器模型的一些问题。哦,有一个问题是,是否可以使用超过 512 个单词的较长句子作为编码器的输入。好问题,这取决于情况,但大多数时候不行。例如,spt 的最大长度是 512,因此您不能使用比这更长的句子。

一些较新的模型,比如 Longformer,可以接受更长的上下文。因此,您应该查看文档,但首先要对代码非常具体,比如并不是所有的模型都能做到这一点。您可以做的另一件事是将句子拆分成几个部分,每部分 512 个单词,然后如果您获得了一个表示,您就将这些片段传递给模型,这样您就能获得每个片段的表示。

例如,您最终在尝试为较长的句子训练分类器时的平均情况。但这大概是唯一的方式,要么是经过特定训练的模型,可以处理较长的输入,比如 Longformer,要么是将输入拆分成多个部分。

另一个问题是,掩码语言建模目标如何处理长灰色单词,这最终会成为一个多令牌单词。例如,海上飞机与管道结合时会变成 Ci。😊,AshAsh plane。对于那些初学者,您将在下一个章节的视频中看到关于这种分离的内容。

如果不使用全掩码,那么模型就会作弊,看到较长单词的部分。因此,这是绝对正确的,这就是为什么您会看到有多个版本的 PE,其中一个经过全掩码预训练,而另一个则没有。如果模型看到 ash ash plane,那就会作弊。

我的意思是,如果我们在上下文中猜测 ash ash plane,这就是作弊,抱歉,因为您有 ash ash plane 的上下文。当您尝试猜测 ash ash plane 时,您得到的是上下文中的转移,因为这算是较少的作弊,因为模型必须猜测,而模型并没有提前知道。

但确实,使用全掩码会消除我们所看到的特定偏见和作弊情况。我们已经到了上层。好吧,让我们看看最后一个视频,然后我会在最后一个关于序列到序列的变换模型的视频中回答更多问题,这种模型结合了编码器和解码器。

在这个视频中,我们将研究编码器-解码器架构。一个流行的编码器-解码器模型的例子是 T5。为了理解编码器-解码器是如何工作的,我们建议您查看有关编码器和解码器的独立模型视频。

了解它们如何单独工作将有助于理解编码器-解码器的工作原理。让我们从我们对编码器的了解开始。编码器以单词作为输入,通过编码器进行处理,并为每个经过它的单词检索出数值表示。我们现在知道,这个数值表示包含了序列的意义信息。

让我们将其搁置,并将解码器添加到图表中。在这种情况下,我们以一种前所未见的方式使用解码器。我们直接将编码器的输出传递给它。除了编码器的输出外,我们还给解码器一个序列。在没有初始序列的情况下提示解码器输出。

我们可以给它一个值,以指示序列的开始。😊。而这就是解码魔法的锚点所在。😊,编码器将一个序列作为输入。它计算一个预测并输出一个数值表示。😊。然后将其发送给解码器。可以说,它已经对该序列进行了编码。而解码器。

反过来,使用这个输入与它通常的序列输入一起,解码器将尝试解码这个序列。解码器解码一个序列并输出一个单词。到目前为止,我们并不需要理解这个单词,但我们可以理解解码器实际上是在解码编码器的输出。这里的启动序列,启动序列单词表明它应该开始解码这个序列。

现在我们有了编码器的数值表示和一个初始生成的单词。我们不再需要编码器。正如我们之前看到的,解码器可以以自回归的方式进行工作。它刚刚输出的单词现在可以用作输入。这与编码器输出的数值表示结合在一起。

现在可以用来生成第二个单词。请注意,第一个单词仍然在这里,因为模型仍然输出它。然而,我们将其标记为无效,因为我们不再需要它。😊,我们可以继续进行。例如,当解码器输出一个我们认为是停止值的值时,比如一个点,表示序列的结束。这里我们已经看到了编码器-解码器变换器的完整机制。

让我们再复习一次。我们有一个初始序列发送给编码器。😊。该编码器的输出然后被发送给解码器进行解码。虽然在单次使用后可以丢弃编码器,但解码器将被多次使用,直到我们生成所需的每个单词。

让我们看一个具体的例子,涉及翻译语言建模,也称为转导。这是将一个序列翻译的行为。在这里,我们想将这个英文序列"We"翻译成法语的"NOIC"。我们使用一个专门为此任务训练的变换器模型。我们使用编码器来创建英文句子的表示。

我们将其传递给解码器,使用开始序列词。我们要求它输出第一个词。它输出了“avenue”,这意味着“欢迎”。然后我们使用“B avenue”作为解码器的输入序列。这与编码器的数值表示相结合,使解码器能够预测第二个词“a”。

这在英语中是两个。😊最后,我们要求解码器预测第三个词,它预测了NYC,这是正确的,我们已经翻译了句子。编码器-解码器真正闪光的地方在于我们有一个编码器和一个解码器,通常不共享权重。因此,我们有一个完整的块,编码器可以训练以理解序列并提取相关信息。

在我们之前看到的翻译场景中,例如,这意味着解析和理解英语中所说的话。这意味着从该语言中提取信息,并将所有信息放入信息密集的向量中。😊另一方面,我们有解码器,其唯一目的是解码编码器输出的数值表示。

这个解码器可以专门用于完全不同的语言,甚至是图像或语音等模态。😊编码器和解码器在几个方面是特殊的。首先,它们能够处理像我们刚刚看到的翻译这样的序列到序列任务。其次,编码器和解码器部分之间的权重不一定是共享的。

让我们再看一个翻译的例子。在这里,翻译变换器在法语中非常强大。首先,这意味着从三个词的序列中,我们能够生成四个词的序列。可以说,这可以由一个以自回归方式生成翻译的解码器来处理。他们是对的。另一个序列到序列变换器发光的例子是摘要。

😊在这里我们有非常非常长的序列,通常是一整篇文本,我们想要总结它。由于编码器和解码器是分开的,我们可以有不同的上下文长度,例如。编码器处理文本的非常长的上下文和解码器处理摘要序列的小上下文。有很多序列到序列模型。

这包含了一些在Transformers库中可用的流行编码器-解码器模型的示例。此外,你可以在编码器-解码器模型中加载一个编码器和一个解码器。😊因此,根据你针对的具体任务,你可以选择在这些特定任务中已证明其价值的特定编码器和解码器。

是的。好的,那我们来看看有没有问题。哦,好的。是段落解码器问题还是编码器解码器问题?

是否有任何可用的管道来实现同样的功能?所以改写生成与输入类似的任务,更像是一个编码器或解码器原型。然而,似乎在这个特定任务上训练模型会非常困难,因为它倾向于想要包含接收到的相同内容。

除非你想以另一种风格进行改写,例如从正式风格到非常随意的风格。目前在变换器库中没有提供实现该任务的管道。所以让我们进入 Cha1 的下一部分,这是这一章的最后一部分,谈谈变换器模型的偏见和局限性。像任何深度学习模型一样,变换器只是一个特定的案例。

但这确实是所有深度模型面临的问题,所以有强大的工具,正如你可能知道的,如果你参加深度学习入门课程,你会接触到这些强大的工具,但你并不能真正控制输入到输出的过程,这主要是通过他们接受的训练数据和训练方式来控制的,但如果你不采取任何预防措施,这些模型可能会做出你并不希望在应用中部署的预测。

让我们快速看一下经过重新训练的 B 模型,其目标是 thin maskQu,并且有一个类似于我们在 GPT 的迁移学习视频中看到的例子,我们只需改变句子的性别,所以如果你说“这个男人作为一个工作”。

猜这个词或“这个女人作为一个”猜“男人”的词。我们得到一些中性的工作。可能更符合刻板印象的是男性的工作,而女性则得到非常刻板印象的女性工作,甚至是性工作者。这显然不是我们希望模型输出的前五个可能性之一。

所以该模型并不是在数据上训练的,但被特别标记为有问题的。更像是通常被认为是中立的,只有维基百科和一些未出版的书籍。所以你必须像 GBT 一样,举例来说,因其在互联网的墙上训练而更为知名,这被认为有点性别歧视或排外的倾向,所以你必须非常小心,因为这种偏见存在于预训练模型中,因此这次是使用 bird paste 和 case checkpoint 特别完成的,并且是完全可重现的,因为在预测中没有随机性,所以如果你在 tris 上运行一个笔记本,你将得到这些结果。

所以在某种程度上,这在任何模型中都是存在的,或者说是新的,并且在你的微调后也会持续存在。因此你总是必须非常小心,当你在训练数据中微调模型时,必须确保你希望看到的输出有足够的样本,并且你应该始终在将模型投入生产时认真分析你得到的结果,如果你看到一些预测你希望避免的,尝试纠正你的训练数据以添加更多样本。

添加更多样本以纠正你模型的偏差。这就是第一章的内容。让我看看还有没有更多问题。在聊天中,否则我们就准备结束了,所以一旦你完成了这个视频,不要犹豫,去做个测验,我不会在视频中进行,以确保你理解了所有术语和内容,但我们在这一章中看到的还有两个左侧会议。

你可以在论坛上再次找到。这已经不是论坛了。下周有两个关于第2章的直播会议,请务必尝试参与,另外一个会是我,期待下周三希望所有技术问题都能得到解决,因为我会稍微关注一下,确保它运作得更好,尤其是视频方面。

第一个会议将是与Lewis在欧洲时间周三的早晨,第二个会议将在下周四的同一时间进行。请花时间在那里创建一个账户,如果hub上有问题,希望codeab的bug能很快解决,你也可以在那个平台上进行代码实验。

否则你总是可以使用网站上的推理API,并考虑一个你想要运行的项目。在你学习课程的过程中,尝试你的技能,因此与文本分类相关的任何内容,因为这部分课程将集中于此。但试着想想你想构建什么样的模型,做一些你可以分享给社区的事情,然后在接下来的几周内,这将帮助你在实践中完成课程。

让我检查一下上次我们有什么问题。嗯,我想这大概就是全部了。好的,非常感谢你的关注,下周见!

嗯。

官方教程来啦!5位 Hugging Face 工程师带你了解 Transformers 原理细节及NLP任务应用!<官方教程系列> - P35:L6.3- Sylvain的在线直播讲解 - ShowMeAI - BV1Jm4y1X7UL

是的,欢迎来到直播环节,我们将讨论本课程的第二章。我和聊天中的路易斯一起,他会比我更快回答你的所有问题,不要犹豫,尽量问出你的问题,因为我会在直播中阅读并回答它们,这也是跟随这个直播而不是自己观看课程的主要优势。

在第二章中,我们将详细查看在第一章中用于所有 NLP 任务的管道对象。我们将确切了解它是如何工作的,如何加载模型,如何使用分词器预处理输入,以及如何处理输出以获取我们在第一章中得到的预测和概率。因此,我们将观看一些视频,回答你所有的问题,并且我们会比第一章进行更多的现场编码。

因为第一章只是一个总体介绍,第二章包含了更多的代码。所以作为一个介绍,正如你所知,Hugging Face 主要以其 Transformers 库而闻名。这是一个包含众多变换模型的库,它提供了一个简单的 API 来下载预训练模型并使用不同的架构。

我认为现在库中可用的架构超过60个。它全部暴露了统一的 API,并提供了一个 torch 模块或大量的 Flu Care 模型,供你自行使用或通过库提供的 API 进行训练。目标是实现灵活性和简单性,库中没有任何抽象。

这不是一个由构建模块组成的库,每个模型、我提到的60个架构中的每一个都是在自己的建模文件中完全定义的。因此我们可以快速查看建模 B 文件,它也包含库内鸟模型的代码。如果你查看输入,你会发现只是一些 torch 导入,然后是它使用的一些内部类,但我们在所有模型中共享的主要是我们使用的输出类型。我们稍后会确切看到输出,但没有其他输入,像重用的注意力模块对于 B 模型的注意力块是在这个建模文件内部定义的,所以我们有 B 构建,你有 B 自注意力等等。

等等!

这个想法是,如果你想玩弄模型并修改模型内部的代码行,你不需要学习50个不同的文件。并不是要进行多重继承,每一层都要继承,我突然意识到我隐藏了一些东西,看来我只是要更快地滚动。你在建模带文件中拥有所有内容,可以随意玩弄和修改,如果你想实验的话。

这正是transformers库的一个优势,我们的用户表示这个功能非常准确。

这就是我想简要展示给你的原因。所以,是的,我们将看看管道API如何加载B模型。实际上,这是我们在第一章中使用的数字B模型及相应的分词器。并且如何手动执行这个管道函数所做的一切,以便你可以在自己的任务中调整这些步骤。

所以让我们开始第一部分,以及我们要观看的第一段视频,这段介绍视频将展示管道背后发生的事情。我不会直接从YouTube播放,因为这会使直播变得很复杂,我已经拥有所有视频。如果你给我一分钟时间。

我要提取它。

从我的电脑播放。

是的,管道函数内部发生了什么?在这个视频中,我们将看看使用transformers库的管道函数时实际上发生了什么。现在具体来说,我们将查看情感分析管道,然后我们将从以下两个句子获得相应的正面和负面标签及其分数。正如我们在管道演示中看到的,管道有三个阶段。首先。

我们将重写表达式转换为模型可以使用的数字,并通过分词器进行处理。然后,这些数字经过模型,输出大量内容。最后,最佳处理步骤将这些代表转化为标签和分数。让我们详细了解这三个步骤,以及如何使用Transform库复制它们。

从第一阶段的分词开始。这个处理过程有几个步骤,首先,文本被拆分成称为令牌的小块。它们可以是单词、单词的一部分或标点符号,然后分词器将添加一些模型所期望的特殊令牌。在这里,中间使用的模型在句子开始时期望一个CLS令牌,在句子结束时期望一个S令牌,以进行分类。

最后,令牌将每个令牌映射到专业模型词汇中的唯一ID。要加载分词器,transformers库提供了autotokenizer API。这个类中最重要的方法是from Pretrained,它会下载并缓存与给定检查点相关的配置和词汇。

在这里,补充分析管道默认使用的检查点是 distillbel baseline case5 tune SS2 English。这有点拗口。我们将实例化为 token,作为一个检查点,并将其输入到两个句子中。由于这两个句子大小不同,我们需要对较小的句子进行填充,以便构建一个数组。

这是通过将 padding 选项设置为 true 的 tokenizer 完成的。通过将 truncation 设置为 true,我们确保任何超过模型最大处理能力的句子都会被截断。最后,返回张量选项允许 tokenizer 返回批处理张量。最终结果显示,我们得到了一个包含两个键的字典,input ID 包含两个句子的 ID,并在填充应用的地方用零替代。

第二个关键注意力掩码指示了应用了填充的位置,以便模型不关注它。这始终是在 token 步骤内部。现在让我们来看第二步。这有点不明白。至于 tokenizer,或者说是一个基于预训练方法的 nottomod API,它将下载并缓存模型的配置以及预训练权重。

然而,autotomodl API 只会实例化模型的主体部分,也就是移除预训练头后的模型部分。它将输出一个高维张量,即句子的过去表示,但这对于分类问题并不直接有用。在这里,张量包含两个句子。

每个 16 个 tokens,最后一个维度是我们模型的输入大小,768。要获取与我们的分类问题相关的输出链接,我们需要使用用于序列分类的 Automodal 类。它的工作方式与 zero 到模型类完全相同,只是构建了一个带有分类头的模型。😊

在 transformformers 库中为每个常见的 NLP 任务表扬一个自动类。在这里,在给我们的模型两个句子后,我们得到了一个大小为 2x2 的张量,每个句子和每个可能的级别都有一个结果。这些输出尚未是概率,我们可以看到它们的总和不为一。这是因为 transformformers 库中的每个模型返回的是 logits。

为了理解这些 logits,我们需要深入分析管道处理的第三步和最后一步。为了将 logits 转换为概率,我们需要对它们应用 softmax 层。正如我们所看到的,这将它们转变为正数,总和为 1。最后一步是确定哪些对应于正标签或负标签。

这是由模型冲突的 ID2lipal 字段给出的。第一个概率是索引 0,代表负级别,第二个索引 1 代表正级别。这就是我们的分类器如何通过管道函数与标签结合并计算这些分数。😊 现在你知道每一步是如何运作的,你可以轻松调整它们以满足你的需求。

嗯。

是的。

嗯,对。哎呀。回来了。嗯。我觉得摄像头出了点问题。让我再检查一下。好的,我的头不见了。我不知道为什么。如果你能看到,请在聊天中告诉我。与此同时,有一个问题。来自“从激活导入 act 到 function”中的三重符号表示什么,在这些 PY 文件中展示?

很好的问题,这在构建包时是标准的 Python。在 Python 中,你尝试导入东西时,有几个层级。这是因为 transformer 仓库的结构。让我试着拉回去,退出我的 VS Code。

但是。好的,我们来了。所以你有一个 transformers 文件夹,然后里面是 transformer models,你有一个模型子文件夹,然后是 bird 子文件夹,模型文件就在这里。由于我们将代码组织成这样,以避免所有文件直接放在 transformers 文件夹中,因为正如我所说,我们有大约 60 种不同的架构。

所以这些文件的组织方式是这样的,当你尝试导入时,使用“from dot”是为了回到结构内部。因此,从“import blah blah blah”会在 bird 文件夹中,位于模型文件夹中,然后再返回到 transformers 文件夹。

所以这只是一种回到帖子目录根目录的方式。嗯。我没有看到任何问题,但在聊天中随时提问,我会尽力回答。而且正如我预期的,我的摄像头不再显示,我也不知道为什么。

我刚才看了这个视频,但它没有工作。让我尝试一下。这里我们来了,抱歉,刚刚把摄像头关掉再重启。所以我们可以继续讨论管道函数背后的表达式,我们将稍微查看一下视频中正在做的代码。我不会从代码部分展示,但请记住,在大多数部分,所有部分都有一个开放的按钮在顶部,就像这个,我稍早打开过,以执行第一个单元,安装所有内容,这可能需要一点时间,然后第二个单元是下载模型,我已经执行过了,所以我们这里有结果,我们准备查看笔记本的其余部分。就像在视频中一样,让我把自己移到屏幕的另一侧,因为代码。

大部分内容在左侧。所以像视频中一样,我们都准确查看了在对两句话使用情感分析管道时执行的代码。看看我们如何得到这些标签的结果。正如我们在视频中看到的。

第一步,预处理由令牌器完成,所以我们稍后将详细查看令牌,但你只需知道令牌器处理输入文本。这两句话是“我等着你面对我自己的生活”,我编辑了很多,它将这两句话转换成数字,因为模型不理解文本,它理解数字。所以在幕后,它将文本拆分成我们称之为令牌的小块,然后令牌器将每个令牌与一个唯一ID关联,这些数字就是我们将要看到的。

要加载令牌器,我们需要知道令牌器的标识符。所以这里是默认用于情感分析管道的模型标识符。然后我们只需调用autotokenize,顺序来自预训练的模型。如果你已经下载了文件,因为我执行了这个步骤,它会下载。

但是如果这是你第一次执行,它将下载令牌器的文件,特别是包含令牌与唯一ID映射的词汇表,并实例化它。一旦你有了那个目标,就可以像这样直接处理输入,将原始输入放入令牌器,我们将确切解释“spaing”和“tru”的含义。

有点不同,我们告诉它返回张量,由于我们在这里使用Pytoch,所以我们告诉它返回Pytoch张量和viPT。你也可以说TF,表示大量的张量。N表示N个数组,或者Fl表示flex,我想对于Fl,它也是N个数组。如果我们执行它,我们可以看到输出是一个字典,包含输入ID和注意力掩码,我们将在课程中稍后解释注意力掩码的含义。

在最后一个会话中,抱歉,输入的“I”是我所提到的唯一数字。所以它把文本转换成小块的petaccle令牌,每个令牌都被关联到唯一的数字。一旦我们有了这个,我们就可以作为模型使用这个输入。只要我们想回顾一下,为什么你要烦我,如果我们想回顾一下这些与一开始的文本是如何对应的。

我们可以使用autotokenizer的decocode方法,所以我输入tokenizer的Decode。然后,我将获取我的输入,抓取关键输入I。Ohello。D di。像这样,所以这是一个张量。我将其转换为列表。因为我在张量中有两个句子,所以这是一个列表的列表。举个例子,我只是获取第一个句子,如果我执行这个,抱歉,我可以看到我的原始文本经过了一些预处理。

现在“我”不再是大写字母了。例如,令牌器在开头和结尾添加了一些内容。这是完全合乎逻辑的,因为令牌器正在添加这些。令牌总是为令牌添加,因为模型期待它们。

在进入代码的模型部分之前,我将在这里暂停以便提问。Ututuanizer是什么意思?使用了什么类型的tokenizer?auto tokenizer类中的auto意味着你可以使用该API加载任何对应于任何架构的tokenizer。例如。

这里我们的模型是一个蒸馏鸟模型。所以tokenizer将是一个蒸馏鸟tokenizer,可以通过添加控制台进行双重检查。如果我输入tokenizer并打印输出,它会告诉我这是一个假tokenizer fast,这并不是特别有用。但表示形式不是可用的,类型应该是蒸馏鸟tokenizer fast。如果我使用了鸟checkpoint。

如果我使用了鸟tokenizer,我会有一个快速的tokenizer,不知道关于checkpoint的事。我会有一个糟糕的快速tokenizer等等。所以自动tokenizer中的U意味着该类将自动选择与使用的checkpoint对应的正确tokenizer子类。因此,你的代码这里tokenizer等于auto tokenizer,这将适用于任何checkpoint模型,只要它是transformers中实现的模型类。

而如果你在这里使用Distill B tokenizer,改变checkpoint类型时,你就需要更改使用的类。例如,如果你使用的是belt模型,你需要将其更改为鸟tokenizer;如果你使用GT2 checkpoint,则需要更改为GT2 tokenizer,等等。

我会被分解成I和M吗?答案是肯定的,我们稍后会看到一点。我将稍后更完整地推送答案,届时我们会看到不同类型的tokenizer。快速tokenizer和标准tokenizer之间有什么区别?非常好的问题。每个模型通常有两个token,一个叫慢token或突出token,另一个叫快速token。快速tokenizer基于cookingface tokenizer库,它不是用Python编写的,而是用Rust编写的。因为你可能知道,Python是一种较慢的语言,所以如果在纯Python中进行整个tokenization,当文本量非常大时,会稍显缓慢,而基于Rust的快速tokenizer则会非常快速。

主要区别在于,如果你只是处理一段文本,你不会看到任何差别,但如果你同时处理10000段文本,快速tokenizer将比Python tokenizer快得多。

这也是目前我们的问题。我将继续并查看模型。与我们有nout to kal API的方式一样,我们有一个新模型API,同样,automod API中的auto意味着这个类将选择正确的子类模型。

GT2模型、蒸馏模型等,具体取决于接收到的检查点,因此这里由于是蒸馏检查点,它会。我会放置蒸馏模型,我可以在这里给你展示。那个模型,它应该。我们可以看到这个蒸馏模型。嗯。我会删除那个单元,因为有点烦人。谢谢你。嗯。所以,那个模型。

再次说明,我们没有下载任何文件,因为当我们在一开始执行管道指令时,我们下载了所需的一切。所以模型已经被缓存。这就是为什么我们在这里看不到任何下载,以及我将要解释的警告,原因是这个automod类将给我们提供基础预训练模型。

这个空间预训练模型不输出句子的正负分类。它输出的是预训练模型的隐藏状态,维度为168。所以这里有一个警告,因为该模型的自动模型缺少分类头,正如警告所说,某些检查点的权重在初始化模型时未被使用。

特别是分类器偏置、分类器权重等,这些都是分类头的所有权重。因此,如果你只想获取预模型输出的张量或隐藏特征,Automod是有用的,但我们想将句子分类为正面或负面,因此我们需要一个带有分类头的模型,而这正是由用于序列分类的automod提供的。当我执行这个单元时,不会输出任何警告,因为所有权重都会被使用,检查点时不会出现任何问题。

如果我们将输入传递给该模型并查看形状,我们可以看到它将是一个2x2的大小。关于输出的小评论是,变换器模型的输出。那是我们在建模文件开头导入的内容。如果你还记得,我们从模型输出中进行了很多导入。

所以这些输出在名称和字典之间有点混合,因此你可以通过这样做来访问一切,即输出点logits。你也可以通过键来访问。嗯。通过问。使用键。所以,输出。当我们请求逻辑密钥时。

就像字典一样,这也能正常工作。嗯。如果我们只是请求基本表示,我们可以看到它是一个序列分类器的输出,包含Lu表和这个张量。因此这里只包含一项,但大多数变换器模型可以返回许多输出。例如,如果我在这里添加标签,它将返回损失。

我们也可以要求模型返回所有隐藏状态或所有注意力结果,这样我们的输出就变得有些冗长。这就是为什么它被组织为这种像 EDT 和一个 IMable 的规格类。所以那些合法性。因为我们得到的名称是一些看起来有些随机的数字。它们并不真正像概率,我们需要进行最后一步后处理,如视频中所示,将它们转换为概率。

这是应用 softmax。如果我们只是从 torturer 导入 softmax 函数板块。我们可以看到,现在得到的分数与一开始的完全相同。例如,对于第二个句子,我们得到了 0.99,即 99.95%。如果我们回顾管道的结果,可以看到我们得到了 99。

是的,确切的分数。所以要知道哪个是负面标签,哪个是正面标签。管道使用模型配置中的那个字段,因此对于每个模型,关联的配置文件可以通过配置属性访问,ID2级字段包含整数与级别之间的对应关系。那我们看看有没有问题。哎呀,第一个问题是。

使用标准 Python 有什么理由吗?

我在游戏阶段工作,所以我有点偏见,我要说不,使用快速的分词器总是更好。所以即使你没有很多文本,它的速度也至少与标准 Python 分词器相同,甚至可能更快。此外,它还有更多功能,我们将在课程的第二部分主要讨论这些功能,这些功能专门为像标记分类或问答这样的任务设计,让你知道例如。

token 来源于哪个单词,或两个 token 在原始文本中分别代表哪个文本跨度,这些功能的设计是为了克服慢速分词器的一些限制。另一个问题是,有没有类似的教程或资源用于多标签情感分析或序列的回归任务?现在没有,这是个非常好的问题,所以现在没有,我们确实应该对此进行一些工作。你需要改变的主要内容是最后的处理,而不是应用 softmax,对于回归来说,你可能不需要应用任何东西。对于多标签,每个句子可能有多个标签,你可能需要对结果应用一个 sigmoid

最后一个问题是前两个输入ID,这两行是相同的,但单词不同,为什么会这样呢?我们需要回头看看解码,因为这两个词确实相同,因此这里的句子以101和101开始,这是CSO的概念。这就是为什么你有前两个输入ID相同,然后1045对应于I,因为这两个句子都以I开头,然后开始不同,因为你有两个句子的ver或8。

还有另一个问题,是否有可能做一个视频,解释库的代码结构和背后的ID,这样可能会更容易贡献?非常好的问题,实际上这已安排在课程的最后部分,在课程的一部分中,我们有一个章节将专门讨论如何为againface库贡献,特别是transformers库,然后我们将有视频解释again phase生态系统中所有库的良好结构。

再次,请不要犹豫,随时提问,我将定期提出问题来回答。所以,这就是管道背后的所有内容,我们在代码中详细看过了。现在,让我们看一下管道内的主要对象,也就是模型。所以,我们还有一个短视频,我将从我的电脑上展示,然后我们将详细查看代码,如果你有问题。

我可以回答这些问题并与你实时编程。让我先找一下视频。呃,当然,我找不到很容易,不然太简单了。为什么它消失了。还有一个是ver poormiss。我刚刚移动了它。最近。

而且。

如何实例化变换模型。在这个视频中,我们将探讨如何创建和使用来自Transformers库的模型。正如我们之前看到的,Automodal类允许你从I face应用中的任何检查点实例化一个表现模型。它会从库中选择合适的模型类以即时调整正确的架构,并加载预训练模型的权重。

正如我们所看到的,当给定一个bird检查点时,我们最终得到了一个bird模型,对于GPT2或part也是如此。在幕后,这个API可以接受U上的检查点名称,在这种情况下,它将下载并缓存配置文件以及模型权重文件。你还可以指定包含有效配置文件和模型权重文件的本地文件夹的路径。

为了实例化between模型,Automodal API将首先打开配置文件,以查看应该使用的配置类。配置类取决于模型的类型,比如B,GPPT2或Bt等。一旦有了合适的配置类,就可以实例化该配置,这是一种了解如何创建模型的蓝图。

它还使用这个配置类找到合适的模型类,当与根配置结合时加载模型。这个模型尚未是可训练模型,因为它只是用随机权重初始化的。最后一步是从模型文件中加载权重。

为了轻松从任何检查点或包含配置文件的文件夹加载模型的配置,我们可以使用自动配置类。就像自动模型类一样,它将从库中选择正确的配置类。我们也可以使用与检查点对应的特定类。

但是每次我们想尝试不同的模型架构时,都需要更改你的代码。正如我们之前所说,模型的配置是一个蓝图,包含创建模型架构所需的所有信息。例如,鸟类模型与基于出生的案例检查点相关联,具有12层,隐藏层为768,词汇表大小为28996。一旦我们添加了配置。

我们可以创建一个与检查点具有相同架构的模型,但它是随机初始化的。我们可以像任何标准模型一样,从头开始进行训练。我们还可以通过使用关键字参数更改配置的任何部分。因此,序列中的一段代码,瞬间生成一个随机初始化的B模型,层数为10,而不是12。

一旦模型的趋势稳定,保存模型非常简单。我们只需使用保存方法。在这里,模型将保存在当前工作目录中的名为“My belt model”的文件夹中。这样的模型可以通过使用从文件中加载的方法重新使用。要了解如何轻松将此模型推送到网络,请查看推送视频。

嗯。

好的,那么我们来看一下是否有任何问题,目前还没有。请随时在聊天中提问,我会定期回答。为了这个,我们打开代码应用程序,稍微看一下Automod API背后的代码。特别是,我们会看到,例如,我早些时候告诉过你,我们的模型可以返回更多的潜在结果,并且可以返回。

例如,所有的隐藏状态或类似的东西,我们将在这里看到如何做到这一点。

是的。

所以,如果你有任何问题,那将是非常必要的,因为我没有提前执行这个笔记本。因此,我们需要等它安装所有内容。好的,我不这样认为。嗯。所以,要创建一个看起来与之前模型完全相同的随机模型,我们只需实例化默认配置,并在模型中使用该配置。

就像我们在视频中看到的,配置包含许多与模型内部发生的事情相关的字段。例如,我们有配置好的隐藏层大小,我们有模型可以接受的单词数量,还有词汇表大小。模型类型,构建时使用的激活函数是Kiu,等等。嗯。所以,这个模型。

使用随机配置时,配置将被随机初始化,并且那里没有任何下载。如果我们想使用预训练模型,我们必须使用 from pretrained 方法。这将下载确切的配置和模型权重,正如我们在视频中看到的,它将首先使用配置来实例化一个随机初始化的模型,然后从我们拥有的那个检查点加载权重。

如果我们想要更改任何内容。更具体地说是在其配置中。我们可以在多个地方说出来。例如,我们可以从一个配置开始。呃。这个配置与鸟类完全相同。我们要从预训练的B pesquiist中获取,这个配置会下载,而且这里已经下载过了。

你是说 two configurefig 没有定义。哦,是的,我只使用了B配置。那我们继续这个。所以,B从 between 来的配置,将会重用这里下载的配置。这是每个模型的配置。如果我们想更改其中的任何内容,我们在视频中看到了,例如。

更改某些隐藏层的数量。但假设我想更改我希望我的模型返回所有隐藏状态的事实。我会用 outputsstates 等于某个值来实现。所以我可以在配置中做到这一点,然后用 model 等于 bad model config 来实例化我的模型。当我执行从 betweentrained 这里的模型时,我也可以直接更改这个。

因为如果我在这里更改隐藏层的数量,它将不再有效。命令会失败,因为我试图加载一个定义了12层的检查点,而模型只有10层。所以bytoch可能会工作,但我会收到警告,提示未使用的宽度,模型可能不会得到非常有用的结果。不过对于像 outputed in states 这样不真正改变预训练模型方式的内容,这将非常有效。

如果我尝试输入一些内容。那我们先定义一些随机输入,然后传递给分词器。我要使用部分分词器,然后用一个形式的 betweentrain 方法实例化它。嗯,应该是这里在找到它。应该执行先前的那个。

我不需要放置之前看到的填充和位置,因为这里只有一句话。我稍早一点会解释原因。所以一旦我完成了这一步,我就可以查看我的输出。现在应该有两个键。仍然是一个键。是的,多出了一点,因为鸟模型在luggit顶部有一个输出,但哦,不再是luets了,抱歉,隐藏状态更少,因为这不是分类模型,而是我使用的基础模型。我使用的是be模型,这与使用automod不一样,不是用于第二次分类的be模型,所以我得到的是最后的隐藏状态,而不是看键,puller输出是特定于B的,所以它总是这样,然后我可以说有一个最后的键,包含隐藏状态和与我的模型的所有隐藏状态对应的结果列表,这就是如何在创建配置时实时更改模型配置的方式,如果你尝试初始化一个随机初始化的模型,或者使用预训练的版本,如果你尝试使用。

特别是如果你使用的是分类模型,例如序列分类模型,你可以指定最重要的参数,即nu levels。因为当你添加分类头时,你想控制这个分类头有多少个输出。所以你可以通过new labels参数来实现。这样模型。

一旦你完成了训练或微调你的模型,你可以使用safe pretrain将其保存在你的硬盘上,并且你可以使用Pushtb。我们今天刚发布的实际上。所以在你的模型上直接上传到Higing face hub,以便全世界的人都可以使用它。如果还有其他问题,欢迎随时提问。

我会定期回答这些问题。这就是我们所需要的。关于模型的各种交叉点,然后我们来看一下负责处理输入的标记器,我将移动自己,哦,不要看屏幕。

回来吧。我要移动自己。回到左边。因为。我们。我们看看这里这一部分,并看看代码应用中的代码。嗯。所以标记器。哦,是的,我们先看一下带有标记的视频,然后我会评论这一部分发生的所有事情。这可以作为介绍视频。

是的。在接下来的几分钟里,我们将查看标记。😊 在自然语言处理领域,我们处理的大多数数据都是原始文本;然而,机器学习模型无法以原始形式读取或理解文本。它们只能处理数字。因此,标记器的目标是将文本转换为数字。

有几种可能的方法来进行此转换,目标是找到最有意义的表示。😊 我们将查看三种不同的组织算法,逐一比较,因此我们建议你按以下顺序查看视频,首先是基于单词的。

接下来是基于字符的,最后是基于子词的。

是的。所以我们不会看视频。实际上,我们将直接查看课程中的文本,我会进行评论,因为我们没有时间观看所有这些幻灯片中的视频。所以基于单词的标记器,你可以在闲暇时观看视频,但我们将更深入地解释我要做的事情。基于单词的标记器只是将你的句子按单词分割,因此最简单的方法是取所有空格,然后按这些空格拆分文本,更高级的方式是包括一些墙壁来分割和标点符号,例如感叹号将其从标记化中分离,或者在这里我们将其分割为“let”和“aworth”。

我们可以在这个例子中看到“Chi”和“Sun weather Preter”,它被分成了五个单词。所以基于单词的组织者是。之前在变换器中使用得很多,主要的优点是。你自然地将文本拆分成空格和标点,缺点是你最终会有相当大的词汇量,因为英语中有很多不同的单词,每次有人在某个单词中打错字,你就会在词汇表中增加一个新单词。

因此,每个单词从0开始分配一个ID,直到词汇表的大小,然后由于我们不能保证用户永远不会犯错,因此有一个特殊规则,如果我们遇到一个在词汇表中不存在的标记。

它通常被称为未知标记来替代,通常看起来像这样,并在括号中。因此,这是基于单词的标记器的另一个缺点,第一个是我们有非常大的词汇量,第二个是我们需要学习“Do”和“Dos”这两个单词非常相似。

他们不知道从头开始,因为模型是随机初始化的。它将有一组针对那个单词“dos”的约束,还有另一组针对“dogss”的约束,并且它需要通过看到大量数据来学习这两个词看起来有点相似。

最后一个缺点是Ung token,所以每个单词最终都会这样,更多的是在你的表示中学习。它的意思是,如果你删除句子中的某个单词会怎样。另一种方式是按所有字符来分割文本,这就是字符最佳组织的方式。在这种情况下,你的词汇量不会很大,因为只有256个字符。例如,如果你处理更大的词汇。

但你不会得到一个模型,其词汇量达到300,000或类似的数量。因此,这对于词汇量更好,你可能不会得到未知的token,因为你会看到所有可能的不同字符。但缺点是,现在表示基于字符,因此模型必须适应这一点。

例如,字母E在字母T之间的含义与字母E在字母K和N旁边的“组织”中的含义不同。因此,每个字母的表示意义较弱,这就是我想表达的。

与我们所拥有的相比,我们的工作有了进展。整体的缺点是句子变得非常长。例如,基于词的分词法将其分为五个词,而基于字符的分词法则分得更多,通常在15到20之间。

假设我们最终得到更长的句子,而我们的变换模型通常受到最大长度的限制。例如,构建的模型一次只能处理512个token。因此,使用基于字符的分词算法将确保最大句子长度相对较短。这就是为什么变换技术通常在基于词和基于字符的分词之间找到折衷。

这是tokenization。子组织,如其名称所示,会将你的文本拆分成子词,因此仍然在词之间拆分。但是某些词会被拆分,例如这里的lets do,然后token和Iization被分开。注意到你得到了小写的和。像动物在英语中会这样说。

但在较小和较大的符号之间有个特殊的符号斜杠W,表示这是一个单词的结尾。因此,token没有这个,因为我们希望模型能够区分单个单词的token和后面跟着其他东西的token,例如tokenization。所以Iization作为特定的表示,在其他单词中token并没有。

这取决于分词器使用的约定。有些token在单词的开头,有些则在单词的末尾。因此,这种方法允许你拥有一个不会太庞大的词汇,同时仍能保持某种语义上的意义,超过单纯的字符。

最后一点是,对于基于世界的令牌,例如,Doug和dogs。这两个单词应该被分开,Do和dogs可能会被拆分为Do和nest。令牌化的方式与token和Iization之间的分割类似,因此它可以学习它们具有相同的前缀,然后sization将在另一个词中使用,如modernization。模型可以理解后缀,并学习它们总是某种相同的。

在课程的下一部分,我们将详细查看不同的算法,因为有三种不同的子组织算法,按级别的word piece和sentence piece将在课程的下一部分中准确解释它们之间的差异。

在我们看看令牌器在实践中的工作之前,让我们看看是否有任何问题。是的。我只是想好好把自己放在这里。令牌器将句子分解为令牌,但在学习之前不会进行词形还原或stemming。嗯。你知道。是的。让我们不扯淡。我会说没有,但你应该向那些比我更有能力的人提问,因为我不完全确定。

你能提供关于word piece和sentence piece类型的直观理解吗?我可以。但这会花一点时间,所以我再次会引导你去那个可以让我好好回答你的地方,或许Louisis可以在这里分享他的tokenizer总结,以及在变换文档中解释word piece和sentence piece之间区别的内容,后者在后台使用Uniigram,二者之间的关键区别。

W slash W标签在子令牌化中添加了任何信息吗?是的。正如我所说的,这使得所有人都知道单个单词之间的区别,例如token作为单个单词或token在一个单词内部,如tokenization或tokenizer。

然后让我们看看令牌器在实践中的工作。呃。因此我们已经看到使用form预训练方法加载令牌器。它返回的内容是什么。现在我们将快速查看有关令牌化管道的视频,它将解释当我们像这样输入令牌序列时发生了什么,以及它如何返回那些数字。

让我从我的电脑上抓取一下,然后我将继续回答问题。嗯。因此,这是一个不错的管道。在这个视频中,我们将看看令牌器如何将文本转换为变换模型可以理解的数字。例如,当我们执行这个时。这里是令牌器对象内部发生的事情的快速概述。首先,文本被拆分成tuets,通常是单词、单词的一部分或标点符号。

然后tokenizer添加潜在的特殊token并将每个token转换为我们独特的相应ID,正如tokenizer的词汇所定义的。正如我们将看到的,这个过程并不是严格按照这个顺序进行的,但这样做更有利于理解。第一步是将我们的输入文本拆分成tokens,我们为此使用tokenized方法。

为此,tokenizer可能首先执行一些操作,比如小写或单词,然后遵循一套规则将结果拆分成小块文本。大多数可转换模型使用单词组织算法。这意味着一个给定的单词可以被拆分成几个tokens,像这里的tokens一样。

请查看下面链接的Tokenization算法视频以获取更多信息。我们在“I”前看到的ash ash前缀是鸟类用来指示该token不是单词开头的惯例。其他组织可能使用不同的惯例。举例来说,阿尔伯特tokenizers会在所有前面有空格的token前加一个长的结束分数。

这是一个所有基于句子的tors共享的惯例。tokenization管道的第二步是将这些token映射到相应的ID,正如tokenizer的词汇所定义的。这就是为什么当我们用form pre方法即时调用tokenizer时需要下载文件。我们必须确保使用与模型展现时相同的映射。为此。

我们使用converttugans到IDs的方法。你可能注意到我们与第一张幻灯片的结果不完全相同。或者说这看起来像是一串随机数字。在这种情况下,请允许我刷新你的记忆。缺失的就是开头和结尾的数字。那些是特殊的token。所以特殊token是通过适当的formalal方法添加的。

它知道token在词汇中的索引,并在输入ID列表中添加适当的数字。你可以使用decocode方法查看特殊tokens,以及更一般地查看tokenizer如何改变你的文本,借助tokenizer对象的输出。

至于单词开始部分的前缀,两个特殊token会根据你使用的tor而有所不同。所以belt tokener使用CLS,而Robertta tokener则使用类似于HTML的S和/lash S。现在你知道tokenizer是如何工作的,你可以忘记所有中间步骤,并记住必须在输入文本上调用它。

然而,decokenizer的输出不仅仅包含输入ID。要了解注意力掩码的位置,请查看batch input Together视频。要了解targettype的想法,你可以获得start视频的处理拼写。

是的。所以我们有一个问题,和我们在视频之前看到的有关,标记/ W和标记会有单独的表示ID吗?是的。我们会有单独的表示ID,因为我们不是同一个标记。正如所说的。

这整个可分割的意思是你能。对不起,具体一点。所以标记器或标记化管道,我不会实时编码,因为你实际上不应该学习它们。我们只是展示它们,以便你看到管道内部的步骤,记住的主要内容是你只需要像这样在输入上调用你的标记器,因为这是主要的E,这是最有用的。现在我们来看看什么是注意力掩码,填充和Fun意味着什么,这些都是我们在最开始时提到的参数,这样我们就可以完全解释所有标记器内部发生的事情。

哦,还有一个问题,你是否有理由保存一个项目组织者,或者说最好只是保留一个本地副本。非常好的问题。所以,是的,如果你不需要,实际上没有理由保存你的项目组织者。如果你没有对它做任何更改,并且你总是会有一个本地副本,因为自动标记器会从预训练中缓存文件,以避免你再次下载它们,因此没有理由去保存。唯一的例外是当你创建一个文件夹并希望推送到模型库时,在这种情况下,你应该将你的标记器保存在该文件夹中,这样当你推送用户时,你推送的是你的模型、配置和与之使用的标记器,我们有所有这三者。

A面网站将能够在你的模型前应用API,你将能够在线玩Wichat。除此之外,你真的不需要在标记器上使用安全预训练方法。这主要是针对将非常有用的模型,我们将在稍后接近此部分时看到。如果你从头开始训练标记器,因为你正在预训练一个模型,比如说在一种新语言中,那么你需要使用安全预训练方法来保存你的标记器结果。

所以我们将观看今天的最后一个视频,关于批处理输入的现场会议,然后我们将更仔细地看一下好的部分。让我先启动协作工具,这样我们就不用在视频之后等待,然后我们一起观看视频。

嗯。来吧。某些事情。是的,我想运行它。让我抓取视频、打补丁并整理在一起。

嗯。是的。在这个视频中,如何将输入一起批处理,我们将看到如何将输入序列批处理在一起。一般来说,我们希望通过模型传递的所有句子不会都是相同的长度。这里我们使用的是我们在情感分析管道中看到的模型,并希望对两个句子进行分类。当对它们进行标记化并将每个标记映射到其对应的输入时。

我们得到两个不同长度的列表。从这两个列表创建一个张量或新的数组将导致错误,因为所有数组和张量应是规则的。克服此限制的一种方法是通过添加特殊标记使第二个句子的长度与第一个句子相同,直到需要的次数。

另一种方法是将第一个序列截断到第二个的长度。但这样我们将失去许多可能对正确分类句子至关重要的信息。一般来说,我们只在句子超过模型能够处理的最大长度时才会截断句子。用于填充的值不应随意选择。

模型已经被描绘为具有特定的填充 ID,你可以在 tokenizer 中找到。现在我们有了更好的句子,我们可以用它们创建一个批次。如果我们单独将两个句子传递给模型并合并在一起,我们会注意到,对于填充的句子,即第二个句子,我们没有得到相同的结果,这是 transformer 库中的一个错误。如果你记得,transformers 会轻松使用注意力层。

这不应让人感到完全意外。当计算每个标记的上下文表示时,注意力层会查看句子中的所有其他单词。如果你只有一个句子或句子与填充标记,每个逻辑标记都不会获得相同的值。要获得相同的结果,无论是否有填充。

我们需要向注意力层指示忽略那些填充标记。这是通过创建一个注意力掩码完成的,该掩码与输入 ID 具有相同的形状,包含零和一。一旦指示了注意力层应考虑的标记,以及应忽略的标记。现在,将此注意力掩码与输入 ID 一起传递将给我们与单独将两个句子发送给模型时相同的结果。

这一切都是由 tokenizer 在后台完成的,当你将几个句子应用于标志填充等于真时。它会为较小的句子应用适当的填充值,并创建适当的注意力掩码。

。所以,让我们。看看在协作中的相同内容。有什么问题请问。没有,我没有看到任何问题。请随时在聊天中再次提出你的问题。接下来,让我们再次看看我们需要关注的代码,具体来说是什么填充和注意力掩码。正如我们在视频中看到的,如果我们尝试。直接应用我们的模型。

哦,不,它并没有像视频中那样精确。如果我们直接在一个被识别并转换为 ID 的句子上应用我们的模型,使用与前一个视频相同的代码,它会失败,因为模型想要输入的批次。因此,实际上即使你只有一个句子,tokenizer 也会添加一个维度。

你可以看到有两个括号包围着这个,所以这里是一个形状为1乘60的张量。如果你想将手动处理的单个句子传递给模型,你需要增加一个维度,例如,在这里添加一对括号。这是一个单独的示例,现在来看两个句子一起,所以如果我们有两个列表。

假设我们同时有id和ID,并且想要形成一对句子。我们可以创建一个列表的列表,但不能创建一个包含这两个句子的数组,因为它们的形状不一致。所以我们需要添加一个填充索引,这样我们就可以在开头隐藏它。大多数Transal模型期望填充应用在右侧,ExcelNe则期望在开头。

但tokenizer应该负责应用填充,因为tokenizer知道模型需要什么,并将其应用在右侧。所以一旦你有了这些pat I,你就可以创建。对不起,从中创建源,然后传递给模型。如果我们像在视频中看到的那样查看输出。

如果我们分别传递句子,仍然需要添加括号,如果我们希望模型对它们进行处理,因为模型期望一个批次。因此,批次内部可以只有一项,但它需要是具有两个维度的东西。

因此,如果我们传递sequence1和sequence2,就会得到这两个结果;如果我们传递这两个句子的patch,第一次句子的结果是相同的,但第二句的结果不同。我们可以看到这里的Ph2有所不同,这是由于填充的上下文。如果我们不做特别处理,模型不会计算出相同的结果,它不会正确忽略填充。所以在视频中提到的就是由于注意力层,注意力层被称为transformers模型,我们在第一章详细解释过。这些层不仅计算单词的表示,还计算单词在其上下文中的表示,因为transformer模型一开始就是为翻译设计的。如果我们想翻译一个单词,就不仅需要关注那个单词,还需要关注周围的所有单词,例如了解“hard”的性别。

它是一个单一的或已知的符号之类的东西。因此,如果我们不告诉注意力层这不是一个真实的标记,而仅仅是一个影响标记,我们需要一个矩形来形成一个批次,注意力层将会关注这个标记并计算上下文表示,这样就考虑了该标记。为了告诉注意力层这不是一个真实的标记,不要关注它,我们必须创建所谓的注意力掩码,因此在这里,我们在想要注意力层关注的地方放置1,而在想要注意力层忽略的地方放置0,因此它与我们使用的批次的形状相同,而0放置在我们有标记ID的地方。

如果我们这样做并将这些传递给模型,现在我们看到我们得到了相同的输出。因此,第一个句子仍然是相同的,因为没有填充,但这里的输出与这里的输出是相同的,后者是模型处理第二个句子的输出。这就是标记器所完成的工作。

如果你还记得我们传递的两个句子,它返回了带有两个键的内容。一个是输入,它对应于这里的内容,另一个是注意力掩码,它对应于这里的内容。截断参数,因此当我们将这两个句子传递给自动模型时,正是这样。

我们说填充为真,截断为2,所以截断为真将会截断非常非常长的句子,因为对于模型来说,例如,只能处理长度最大为512的序列。因此,如果我们有一个比这更长的序列,模型将会失败,我们需要截断它。在使输入短于模型能够处理的最大长度时,不应该因为其他原因而进行截断,因为当你截断时,会丢失信息;而对于填充,我们是添加一些东西,并且可以告诉注意力层忽略它,因此最后我们得到的结果与是否填充是完全相同的。通过截断,你是在忽略信息,但你无法恢复,所以没有截断的情况下,你将永远无法得到相同的结果。

但遗憾的是,这是必要的,因为变压器有最大长度。因此,如果你有非常长的输入超过最大长度,你需要将其定位。如果我们回到课程中并查看“把所有东西放在一起”的部分,我们有各种填充策略。因此在这里。

所以如果我们回到一开始这段对话中使用的两个句子并传递它们,我们可以将它们传递给筛选器,它将输出一个列表的列表,但我们无法将它们拼接在一起而不应用填充。因此,我们有各种策略来应用填充。当我们填充为真时,它与填充为最长是一样的,都是将序列填充到你所传递的样本中的最大长度。

我们有两个序列,填充等于最长,这会将第二个句子添加到较长句子的长度。如果我们回到管道后面的笔记本,我们可以看到这里。所有这些零被添加,以确保批处理中的句子长度与第一个句子完全相同。

你还可以说填充等于最大长度,最大长度指的是模型的最大长度,所以例如,对于be或distber,它是512,因此这会将每个句子添加到模型的最大长度512。对于短句子而言,模型的采用不应被视为固定形状,通常最好是添加到你拥有的最长句子,除非出于某种原因需要使用固定形状。例如,TPU更喜欢固定形状,在这种情况下你会使用最大长度选项,尽管这有点低效,但对于TPU加速器而言是如此。

这是获得真实速度的唯一方法,因为它们需要所有输入具有完全相同的形状。你也可以指定一个你想要的最大长度,所以例如,如果你知道在你的数据集中,所有句子都短于大约28,你可以说填充等于最大长度,最大长度等于1028。因此,你还应该使用截断。

正如我们所说,因为当输入超过模型可以处理的最大长度时,你需要进行截断。你也可以指定希望截断输入的最大长度。所以关于填充就这些。我们有任何问题吗?嗯,没有问题,Lewis分享了一些小链接。所以,最后一件事是,正如我们之前看到的,你可以告诉你的标记返回bytoch张量和软流张量在整个数组上。

正如我们在其中一个视频中看到的,特别是tokenizer视频,tokenizer会在句子的开始和结束添加特殊标记。因此,这完全取决于你使用的模型,但tokenizer会知道模型期望的特殊标记,并将它们放在句子的开始和结束。为总结这一章节,这里是代码,只是缺少后处理。

但这是管道后台执行的代码。嗯。所以你导入用于序列分类的auto tokenizer和automod。auto beam意味着你可以从中心使用任何检查点。它会为你选择正确的架构。

管道使用的检查点是this1。你可以使用我们模型中心上任何对应于情感分析任务的检查点。我们可以通过betweentrain方法加载tokenizer。我们可以通过betweenttrain方法加载模型,如果我们有两个句子。

我们可以将它们与填充一起标记为equal2 con equal2,这在张量源上等于piy toch,如果我们使用py toch张量流,然后将标记传递给模型以获得加法过程的结果,这里只是缺少soft max,以便得到与管道完全相同的结果。

最后一个问题,我对你提到的最长填充和动态填充感到困惑。它们相似吗?是的,非常相似。我们将在下一章中学习动态填充的内容,但对于那些不知道它是什么的人来说,动态填充是在你遍历训练数据时进行的。

动态填充意味着每次你需要构建一个批次时,你将句子填充到该批次内的最大长度。因此,如果你传递一小批句子,填充equal longest将会创建一个包含例如八个句子的批次,第二个维度将是该批次内的最大长度。而填充equal max length则会将所有内容填充到一个固定的最大长度。

这个最大长度可以是模型所能处理的最大长度,也可以是你传递给解码器的最大长度。这就是模型和标记器的基本用法。感谢你关注这次直播,现在我们一起看完这一章后,你应该能够完成手头的问卷,然后在进入第三章之前,如果你尝试再次运行我们一起看到的批处理输入的pipeline colab,并试着理解每个单元的功能,甚至尝试自己重新做一遍,那将是很有用的。

然后尝试想一个你想要解决的分类问题,特别是文本分类问题,并尝试在该问题上使用基本模型和组织器,以便从一些输入中获得输出。我们将在下一章中实际找到适合你给定问题的模型,并在第四章中看到如何将结果上传到bundle hub,以便你能与社区其他成员分享该模型,并在线使用推理API的小部件进行演示。

关于你的模型。在我们结束这次直播之前,让我看看问题。哦,接着上一个关于填充equal whole longest的问题。我们不需要在填充时使用那个装饰器。这并不完全正确。我们将在下一章中确切地看到原因。

我们需要处于训练模型的动态中,但如果你在整个数据集上执行最长填充时进行标记化,它将增加数据集中的最长元素。所以这与动态填充并不完全相同。

不过,我们将在下一章深入探讨这个问题。谢谢大家关注这个直播,下一周在Cha 3将有四个不同的直播,因为Cha 3对于Pytch和Tensorflow非常不同,主要是关于训练和功能。到目前为止,代码有一些小差异,你可以看到这里有一个切换选项,可以在Pytch和Tensorflow之间切换,如果你想了解它们的具体区别。不过下一章将会非常不同,所以会有专门针对Pytch的直播和专门针对Tensorflow的直播,务必查看一下表格,选择你想参加的课程,并记在你的日历上。

嗯,让我们先结束这一段。非常感谢大家的到来,再见!

官方教程来啦!5位 Hugging Face 工程师带你了解 Transformers 原理细节及NLP任务应用!<官方教程系列> - P36:L6.4- Lewis的在线直播讲解 - ShowMeAI - BV1Jm4y1X7UL

好的,也许我们可以开始了。那么,今天我们要看的是 Hugging Face 课程的第三章。这一章将把我们在前两章中看到的所有组件结合起来。作为回顾,在第一章中,我们探讨了与 transformer 相关的概念,以及与分词和预训练相关的一些概念。在第二章中,我们开始深入了解我们在第一章中大量使用的这个管道 API 实际上发生了什么,并试图真正解析如何训练一个模型,或者至少如何理解模型的输入和输出。

还有分词器的输入和输出。所以今天我们将把这一切结合起来,做几件事情。我们将查看数据集库,这是 Hugging Face 开发的一个非常方便的库,用于处理各种规模的数据集。

然后,我们将使用一个叫做训练器的东西来训练我们的第一个模型。训练器是一个 API,基本上封装了在 Pytorch 或 TensorFlow 中编写自己训练循环的许多复杂性。然后我们将尝试解析这个训练器中发生的事情,通过编写我们自己的训练循环来实现。

在 Pytorch 中,这将是一个很好的机会来介绍一个非常酷的库,Sylvanna 开发的 Hugging Face Accelerate。这个库旨在进行所谓的分布式训练。也就是说,当你有多个 GPU 或者甚至 TPU 时,如何加快训练速度。今天我们将在 Google Colab 中看到这一点。当然,如果有任何问题。

随时在聊天中问我问题,我会在不同的时刻暂停来回答。现在是回答问题的时候。所以,也许我们可以先开始。我们目前的生态系统大致围绕这些组件展开。因此,我们有中心,这一点我们已经看过好几次了。

我们使用中心来加载 transformers 中的模型,加载分词器,以及加载数据集。然后,transformers 与数据集库进行交互。正如我们今天将看到的,这是训练我们模型的一种方式。模型训练完成后,我们可以将其推送回中心,以便与同事分享,并使用 Hugging Face 团队开发的一些小部件与之互动。

所以,话不多说,让我们快速看看数据集库。数据集库是一种通用库,用于处理几乎任何类型的数据集。最初,它是专门针对 NLP 的文本数据集。但此后,它逐渐发展成可以处理图像、音频等多种类型的数据集。

我们将会有时间序列等功能。这个库的主要优势在于它提供了一种统一的API用于处理数据,对我个人而言,这在我作为数据科学家的职业生涯中是最大的生产力提升之一,因为以前我总是需要处理不同类型的数据。

CSV、JSON文本等,每次处理这些数据类型时总是有点独特,你必须为处理所有这些数据类型编写自己的自定义函数,而数据集库提供了一个非常简单的API,你基本上可以在一行代码中加载数据集。

然后你可以使用一个叫做map函数来处理它。我们今天会更详细地讨论这个函数。大致上,使用这个map函数,你可以对大型数据集进行极其快速和疯狂的处理,即使数据集的大小达到一TB。

你实际上可以在笔记本电脑上处理这个,因为它使用一种叫做Apache Arrow的聪明懒加载内存的方式。好的,让我快速看一下。太好了。😊,酷。也许我们可以从看这个DiocS库的介绍视频开始。

我要播放这个视频,如果你听不见,请告诉我。Egen F数据集库的快速概述。Eing F数据集库是一个提供API的库,可以快速下载许多公共数据集并进行预处理。这个视频将探讨如何做到这一点。加载数据集的资产功能使这部分变得简单。你可以直接从数据集应用中根据其标识符下载和缓存数据集。

在这里我们从G基准测试中获取M PC数据集,这个数据集包含句子对,任务是确定相似度。Lo数据集函数返回的对象是数据集字典,它是一种包含数据集每个分片的字典。

可以通过名称索引访问每个分片。这个分片是在数据集类的一个实例中,列有时为1,有时为2,标签为IDX和root。我们可以通过索引访问给定元素。Ugen Phase数据库的惊人之处在于,所有内容都使用Apache Arrow保存到磁盘。这意味着即使你的数据集很大,也不会耗尽R的内存。

只有你请求的这些元素会在内存中。访问数据集的一部分就像访问一个元素一样简单。因此结果是一个字典,其中包含每个案例的值列表,这里是标签列表、第一句话列表和上下文句子列表。数据的特征属性为我们提供了关于其列的更多信息。

具体来看,我们可以看到这里给出了整数与标签名称之间的对应关系。0代表不等价,1代表等价。为了处理我们数据集中的所有元素,我们需要对它们进行标记。查看视频中预处理的句子对以获取更多回顾,但你只需将这两个句子发送到解码器,并附上其他一些关键字参数。

在这里,我们指定最大长度为128,并且对比输入长度较短的进行截断处理。我们将这一切放在tokenized函数中,但我们可以直接应用到数据集的所有拆分上,使用map方法。只要函数返回一个字典类型的对象,map模式就会根据需要添加新列或更新现有列。

为了加速预处理,并利用所有tokenizer是由rust支持的这一事实,得益于Eging phase tokenos库。我们可以在autokenized函数中使用batch equal2参数同时处理多个元素。由于tokenizer可以处理第一句的列表和第二句的列表,因此tokenized函数不需要对此进行更改。

你还可以使用MA方法进行打印处理,查看下面的文档链接。一旦完成,我们几乎可以准备进行训练。我们只需使用remove columns方法删除不再需要的列。我们将label命名为labels,因为Uing phase transformforms库中的模型期望这样。

并设置所需的输出格式,dorch,流动性转换为imp。如果需要,我们还可以使用select方法生成数据集的短样本。

很好,这就是Do库的快速介绍。在我们深入代码之前,这个阶段有没有什么问题?好的,请随时在聊天中提出问题,我想提到的一点是,这可能会有用,在Hi phase hub中。我们在上一课中看过模型。

今天我们将更仔细地查看数据集。上周有一个问题,关于如何选择模型,比如多类与多标签?当时我们意识到没有简单的方法来筛选这些类型的模型,但事实证明,对于数据集来说,有一些更好的搜索方法,比如说。

如果我在进行一个新项目,获得早期结果的最快方法之一是基本上使用一些公共数据构建一个基线或原型。这通常比等待获得公司数据访问权限或等待一些领域专家帮助你进行标注便宜得多且快得多。

例如,如果我们正在查看多类的内容。也许我会选择文本分类。然后这里有其他标签可以进行过滤。所以如果我对问答感兴趣,我可以选择它。在文本分类中,我们可以查看一组子任务。例如。

在这里,我可以选择多标签分类。这将返回一系列数据集,作为多标签案例的候选项。因此,也许我正在处理假新闻,那么我可以查看一个名为假新闻英语的数据集,反之亦然,因此数据集中心是启动工作中机器学习项目的好方法。我发现这也是寻找一些有趣的数据集的好方法,可能超出你在NLP中常见的标准数据集。

几乎每个人都使用IMDB电影评论来展示他们的训练,但这里有很多额外的东西非常有趣和具有挑战性,因为许多数据集是社区提供的。顺便说一下,如果你有一个有趣的数据集。

如果你认为对社区有价值,你可以直接将其贡献给数据集库。因此,在数据集库内部,我们有一个数据集文件夹,里面有数百个基本上由Hugging Face团队审核和策划的数据集,你可以打开一个拉取请求,文档中有关于如何做到这一点的说明。

或者如果你想提供一个社区数据集,基本上是你不需要直接将其集成到库中。你也可以这样做,文档中有一些链接关于如何提交数据集到中心。

那么让我们看看到目前为止是否有任何问题。太好了。也许Oma可以将一些链接放到那个社区。诶。与规范的des相比。好吧,SRM sumUma有个问题,数据集库看起来非常具体于NLP,我找不到很多与视觉相关的数据集。是否有托管视觉相关数据的限制?简短的回答是没有。

库中没有限制,只是我们尚未投入大量精力整合视觉数据集,如果你有一些想添加的视觉数据集的想法,请随意在数据集库中打开一个拉取请求。

或者基本上在论坛上联系。在此时,如果我查看这里,看看。我能找到视觉吗?我们有标签修订吗?让我们看看。所以我不认为我们还有视觉标签。但我知道我们有,让我看看。我想我们有CFAR。我们没有CFfa,可能是imt。很有趣。

我相当确定我们有这些数据集。好的,那么。也许一些视觉数据集还未上线,因为我这好吧。CA,是的,好的。所以我们有CF 10,CF 100,这些数据集可以使用数据库。还有其他的,我想我很确定mnes也在这里。所以有时尚mnesist。

mist等等。所以这是个好问题。我想我可以在聊天中分享链接。这是。这个是Mist的链接。让我们放在这里。😔,酷。希望这能回答你的问题,消费者。嗯。😊,好的。现在我们可以做的事情是先看看数据集库的coabab。

所以我们开始动手操作。和往常一样,我想做的第一件事是安装数据集和变换器。我将使用捕获。

魔法命令来捕获所有输出的Pip垃圾。嗯。😊,所以这将花费几分钟。请记住,变换器工作流中的基本过程是,我们首先需要一个分词器来将原始文本转换为输入ID。然后我们需要一个模型来处理这些输入ID并将其转换为我们可以构建预测的数值输出。因此,在这里,我只是实例化了一个分词器和一个模型。

所以这将是基于Bt的无大小写模型,这是一个用于序列分类的自动模型。因此,这是我们在预训练模型上添加的文本分类头。这只是一个小代码片段,展示了如何处理基本的原始序列,将其转换为输入ID。然后通过模型传递这些和标签。好的。

但我们上周已经看过了,所以今天对我们更有趣的事情是开始查看它们读取的数据集。你将遇到的第一件事或最常见的事情是加载数据集函数?

如果我们看一下这个加载。哎呀。加载数据集函数。你可以看到它有很多不同的参数,你可以提供,我使用的最常见的参数是路径。它本质上是数据集的名称,这就是你在中心看到的内容,所以在这个案例中我们有glue,但它可以是MNIST,或者其他任何东西。

在中心上,许多数据集通常有配置,就像细分子集。例如,glue是一个基准,它有许多不同的任务,每个任务都有一个名称,这里我们有微软的同义句理解任务。如果你想访问给定数据集中的子任务或子集,你使用这个名称参数。然后我们将看到的另一个非常常见的参数是指定拆分。

所以很多时候默认情况下,它将返回库中定义的所有拆分。在这里,我们得到了训练、验证和测试拆分。但有时你只想要训练拆分,因此可以明确指定这些,我会告诉你怎么做。好的,现在当我们加载数据集时,我们得到一个数据集对象,通常你会看到两种类型的对象,最常见的是称为数据集的东西。

你可以把它想象成一个字典,键是对应于划分的字符串,值是称为数据集对象的东西。让我们来看看这里的一个示例。所以如果我索引训练键或训练集,我现在将得到一个数据集对象。

如果我查看该数据对象中的第一个元素,我有一个ID,一个标签,以及我需要判断一个句子是否是另一个句子的同义改写的两个句子。在这种情况下,我们可以看到第一个句子说“阿姆罗西指控他称为证人的兄弟故意歪曲证据”。而第二个句子则说,称他为仅仅是证人,阿姆罗西指控他的兄弟故意销毁证据。

所以这是一个相当好的例子,第二个句子是第一个句子的同义改写,或者也许第一个是第二个的同义改写。所以它稍微短一点,捕捉到了相同的信息。我们可以看到这里的标签是1,作为一个猜测,可能表示这是真的。它是可以改写的。好,所以为了稍微拆解一下这个数据集字典和数据集对象的区别,因为第一次看到这个时我觉得有点困惑。

所以我们知道原始数据集是由这个数据集字典对象给出的。这个数据集对象有这些键,对吧,所以我们有训练、验证和测试。如果我们像查看普通的Python字典那样查看它的值,那么我们现在得到的是一个字典,或者我们得到不同值的列表。

所以把数据集想象成一个字典,将键或划分映射到数据集,而你几乎所有的工作或重工作都是在数据集对象上进行的,所以如果我们查看一个数据集对象。这些原始训练数据,这个数据对象有很多操作可以执行。

今天我们将看到其中的一些内容。所以我们可以添加列。我们可以进行过滤。我们可以从不同格式加载数据。我们可以提取一些关于数据的信息。所以也许我们来看看这个。如果我们查看数据集的信息属性,这通常会告诉我们,也许我们可以打印出来。这就可以了,就这样。

所以这将告诉我们一些关于数据集本身的描述。还有关于数据类型等的信息。所以,是的,基本上只需记住数据集是我们将要做大部分工作的地方,而数据D只是收集所有划分在一起的一种方式。所以我们来看看有没有问题,暂时没有,好。

所以数据集的一个重要方面是它本质上有类型,所以你在工作中可能经历过的大部分数据是非常混乱的,或者也许它像一个CSV文件,里面混合了字符串、数字等等。

数据集库所做的就是明确地定义每一列在数据集中的类型。这非常有用,因为它允许你更早地捕捉错误,同时也能进行一些非常快速的处理。因此,如果你查看数据集的特征属性,你会得到一个字典,基本上显示列名作为键,然后是该列的数据类型,所以我们可以看到,确实,句子一是一个字符串。

我们得到一个叫做值类型的东西,这里它指定为字符串。但另一个有趣的可能是标签,因此这里的标签列不仅仅是一个整数,虽然它可以是一个整数,但数据集提供了一种叫做类标签类型的东西,这个类标签类型包含我们拥有的类别数量或唯一标签的数量的信息,以及这些标签的名称。这基本上就是你需要了解的两个要点:标签的名称和类别的数量。

然后我们可以看到,例如,ID的数据显示类型为整数32。因此,你可以对这些特征做的一件事情是,特征只是一个字典,所以我们可以通过键访问值。如果我们获取标签,这将给我们这个类标签类型。这个类标签类型有几个方便的功能。

所以我经常使用的一个功能是如何将我的数值特征转换为类似于人类可读的形式,所以我可以使用一个整数转字符串的函数。如果我在这里放入标签一,它应该告诉我,确实,它对应于等效值。

这意味着一句话是另一个的同义句。作为一个简单的检查,如果我们使用零,那么对于非等效的情况,它应该是相同的。因此,这个类标签特征在中心有一些文档以及其他你可以查看的功能,但我发现这是一个非常强大的方法,可以快速在数字标签和字符串标签之间切换,以便你能理解你的数据集中的内容。

那么我们来看看,有没有问题。好的,IM homess提了一个问题,是否有办法利用数据集库的便利,但使用可能是私有的数据集,例如客户数据?是的,这是个好问题,答案是可以的,所以之前在我加入Hugging Face之前,我为一家电信公司工作,一切都是完全封闭的,我们无法使用Hugging Face hub,因此我实际上必须解决这个问题。我通常使用的方式是利用pandas。

所以我会导入 pandas 为 PD。然后我会创建我的数据框。所以假设我打算创建一个虚拟的数据框。比如说我有。哎呀。我的数据框如下,我要说,好的。我们称之为文本。然后我会写。你好,世界。然后可能再添加另一个元素,今天。好的,然后我会添加另一列。

这可能是标签。然后这可能是正面的,正面的。所以这是一个超级简单的数据框,但这是我会本地加载的东西。当然,pandas 对数据处理非常棒。但如果你想使用数据集功能,你可以创建自己的数据集,自己的自定义数据集。所以从数据集开始。

你可以导入。数据集的目标本身。然后我们可以创建。数据集。我们看看,我想这是来自于 pandas,是吗?

然后这应该,祝好运,现在创建一个数据集对象。它具有文本和标签的特征,包含两行。如果我们现在,例如,查看所有元素,我们可以看到确实得到了我们自己的自定义数据集。所以这大致就是我工作 90% 的方式。

我希望这能回答你的问题,我想还有其他加载数据的方法。你可以从 CSV 加载,可以从 JSON 加载。我认为这大致涵盖了大部分用例。唯一让事情有点痛苦的情况是当你处理非常大的数据集时。

你知道,有些东西可能不适合放入 pandas 数据框中,但数据集库中刚刚实现了流式功能。所以是的,我认为这样可以基本覆盖几乎所有的用例。好的,酷,所以。嗯。到目前为止,我们只加载了我们的原始数据集。

我们希望做的事情是对其进行标记化,所以到目前为止我们在所有课程中基本上都是逐个字符串或者字符串列表进行标记化,如果我们看看这里的这个例子。

然后当我们进行标记化时。你可以看到。标记化第一句列现在给我们带来了一个输入 ID 的列表。所以我们现在基本上有一组输入 ID,嗯。是的。我们得到了一个与第一句和第二句对应的大输入 ID 列表。请记住,这些 ID 是我们用于输入到变换器的。

这些是进入嵌入层然后进入变换器堆栈的东西。最后,我们得到一些预算,可以用来进行预测。好的,所以。这就是我们一直在做的事情,你也可以,正如我想我们可能看到的那样,可以使用将 ID 转换为标记的功能。

但可能最有趣或最常见的事情是你如何基本上对整个数据集进行标记化?

最常见的做法是定义一个函数。你可以随意命名。在这里它被称为标记化函数。这个函数会在数据集的每一行上进行操作,并应用你在函数中定义的操作。

一旦你定义了你的函数,你就可以。对你的数据集应用映射。这将自动对你数据中的每一行进行标记。因此我们得到了所有的原始字符串,句子一,句子二。它们被自动转换为输入ID,以及我们上周看到的这个注意力掩码,我们需要找出如何禁用填充标记以适应注意力机制。

所以。😊这是一个非常强大的方法,可以在大约一到两行代码中,自动对数据集中每一个示例进行标记,速度非常快,基本上可以进行多进程处理,并且也可以在GPU上批量运行,以更快的速度处理。

但也许我们来看看一个非常简单的示例,以便更好地理解这里发生的事情。假设我想做一些比较常见的事情。也许添加一个列,现在在数据集中有更快的方法来做到这一点。但我将向你展示如何用一个函数来做到这一点。我们来添加一个列。

而这个列应该期望的是一个示例,或者说让我们假设这是一行。它是我们数据集中的一行。而这个函数主要需要返回的是,它必须返回一个字典。这样做的原因是,如果你查看。我们的训练集中的一个示例。你会看到它有点像一个字典,对吧,我们有列名的键和实际元素的值,或者说如果这是一个表格中的单元格。

所以我们需要做的是返回。奇怪。似乎协同应用了两次。所以我们需要返回一个字典,假设我随便编造一个。我将说这是一个新列。并且我会把新列的所有值都设置为。只是一个单词,hello,好吗。如果我们这样做。那么如果我拿我的原始数据集。

好吧,我们就用原始训练数据集来进行示范。为了简化起见。当我们应用映射时,我们只需要在这个函数中提供输入。然后它会自动创建一个新列。并将其添加到我们的原始数据集中。现在你需要注意的一点是,这个操作不是就地进行的。

如果你熟悉pandas,通常会有就地操作。这意味着你只需运行这一行,然后它会改变数据集对象的状态。大多数情况下,所有操作都不是就地进行的,这意味着如果你想将该列存储在内存中。你需要创建一个包含额外列的数据集,比如说“额外列一”。

你知道,这等于映射。然后,当你查看这个时。你现在会看到我们有一个新的列Ho。因此,这现在在这个新数据集对象的内存中存储了。好的,总结一下,你有一个函数,而这个函数必须始终返回一个字典,其中键是列的名称,值是你想要的那一行的值。好吧,让我们看看一个小的例子。我是Homemes,只是在询问。

请你再解释一下注意力掩码的作用,好吗?很好,非常好的问题。让我们看看这个例子。在这个例子中,我们有两个句子。我们可以看到,这可能不是一个好的例子,也许我们来添加一些填充。嗯。好的,实际上。我需要做的是给你展示一个例子。我要。是的,我要这样做。

所以我要在我的函数中应用截断,并且我要添加一些填充。然后这只是为了向你展示我们在这里讨论的内容。好的。在这里,我只是对原始数据集进行了分词,得到了这个分词数据集对象。然后列表。获取第一个元素,希望能显示给我们。哈哈。嗯。好的,这个有点混乱。好的。

但让我尝试总结一下,所以记住在上一章,我们看到了填充的概念,而我们需要填充的原因是我们在变换器内部进行的所有操作基本上都是矩阵乘法。当你进行矩阵乘法时,你想确保你操作的矩阵大致是方形的。所以如果我有一个句子,并且我将其表示为一个向量。

然后,为了比较一个句子和另一个句子,如果这些数组或向量的大小相同会更有帮助。因此,填充是一种技术,基本上在最简单的情况下,你可以查看批次中最长的句子,然后在每个其他句子的末尾加一个零,这样就填充到最长句子的长度,从而保证你的句子或批次中所有向量的大小相同。

然后,当你将它们堆叠在一起时,你会注意到它呈矩形。现在这就是填充,我们这样做多多少少是出于计算的原因。但它带来的问题是你可能还记得之前章节提到的注意力机制。它基本上取一个嵌入,也就是我们对序列的数值表示,然后更新它们以创建称为上下文化嵌入的东西,而这些上下文化嵌入本质上为序列中的每个标记包含信息。

它们包含与该标记相对于整个序列的意义相关的信息。例如,如果我有一个句子,比如,我不知道,时间像箭一样飞逝。然后在这种情况下,“飞”是一个动词。但如果我有另一个句子,比如“果蝇像香蕉一样飞”,那么“飞”就是一种昆虫。

因此,注意力机制使我们能够区分这两种情况,因为代表飞行的上下文化嵌入在这两种情况下是不同的,并且它使用整个序列来发展该表示。现在,由于注意力在序列中的每个单个标记上进行操作。

它也会作用于填充标记,这可能会有些问题,因为这些填充标记就像是我们注入的人工东西,以确保所有矩阵是方形的。因此,注意力掩码是一种告诉注意力机制的方法。

不要关注填充标记。那么注意力掩码看起来会是什么样子?在这里。它会有一堆一,所以这些将是序列开头的所有标记,这些正是我们希望开发上下文化嵌入的内容。

然后在某个时刻,你会达到填充序列的开始。所以你已经有了所有的单词,现在只是在你的标记嵌入中添加零。此时,注意力掩码将切换为零,这样它通过注意力层时。

它将禁用该部分的注意力计算。所以我希望这解释了你的问题,我的朋友。这个问题有点长。而且所有输入ID是完全正确的。没错,所有不为零的输入ID会是1,而所有为零的输入ID会是0,我们可以在这里查看。

所有输入ID为零,现在我们有了填充。嗯。好的,接下来有个问题来自Resh Mecheik,我们能否做map函数的反向操作?嗯。让我想想我是否理解你的意思。😔,那么你心中有什么样的例子,Rash?

我不确定我理解这个问题,但也许你可以把它写在聊天中,我稍后再回到这个问题。好的,所以。我们已经看到如何使用map函数对整个数据集进行标记化。我认为这大致是这个课程的主要内容。所以我将删除这一部分。还有另一件值得指出的事情是,有两种方法可以进行填充。

一种方法是在标记化步骤中明确定义填充。所以你可以设置填充为真,或者按你想要的方式实现它。当你用mat函数进行标记化时,它会根据你的定义自动填充所有序列。现在。

这样做的缺点是,当你进行训练时。也许你的填充,例如这里,选择了整个数据集中最长的句子,然后填充到整个数据集中的内容。但是当我们进行训练时,我们实际上是在对批次进行训练,因此常见的一种做法是进行动态填充。我们很快就会看到这是一种在运行时添加填充标记的方法,这让我们可以更有效地进行计算。

所以我想现在来看一下那个视频。

那么让我们看看如何在流上进行填充。

什么是动态填充?在批处理输入的同时,我们发现能够将不同长度的输入分组到同一个批次中。我们需要为所有短输入添加填充,直到所有样本都达到最长的长度。例如,这里最长的句子是第三个句子,我们需要添加五个填充。

为其他句子添加两个或七个填充,以使四个句子具有相同的长度。在处理词数据集时,有一些我们可以应用的策略。因此,最常见的一种是将数据集的所有元素调整为相同的长度,即最长样本的长度,这样就会得到所有形状相同的块,形状由最大序列长度决定。

缺点是由短句子组成的块中有很多填充标记,这会在模型中引入更多不必要的计算。为了避免这种情况,另一种策略是在将元素批处理在一起时,使用批次中的最长句子进行填充。这样,由短输入组成的批次体积变小,而包含数据集中最长句子的批次则保持较大。

这将提高 CPU 和 GPU 的速度。因此,缺点是所有批次将具有不同的形状,这会在像 TUs 这样的加速器上导致速度变慢。我们确实需要在实践中同时应用这两种策略。实际上,在我们提出 R PCC 数据集时,我们在一段视频的数据集中应用了固定填充,在处理数据集时,我们对所有数据集进行了带填充的标记化,并确保所有样本的长度为 128。

结果是,如果我们将这个数据集传递给一个 byy toch 数据,我们会得到形状为 patch size 的块,这里是 16 x 128。为了应用动态填充,我们必须将填充推迟到批次准备中。因此,我们将这一部分从标记化函数中移除,但仍然保留转换部分,以确保大于模型接受的最大长度(通常为 512)的输入被截断到该长度。然后我们通过使用数据策划者动态填充样本。

Tos 库中的这些类负责在形成批次之前进行所有最终的预处理。这里,带填充的装饰器将通过句子的最大长度传递样本。我们将其作为聚合函数传递给 Pythto,并观察到生成的各种长度的批次都低于之前的 128。动态填充几乎总是在 CPU 和 GPU 上更快,因此如果可以的话,你应该应用它。

记得如果你在TU上运行训练脚本或需要固定芯片批次,还是要切换回固定竞标模式。好的,刚才对动态填充的解释很好,所以总结一下。如果我有一个数据集,比如说一千个例子。假设其中一个例子的长度远远超过其他例子。也许是有错误或者其他原因。那么如果我只是对这个数据集进行了标记化。嗯。

就像我们之前在colaab中做的那样。我们只对最长例子的最大长度进行了填充。然后所有样本都会被推送到这个很长的例子上。因此我们会在需要计算的地方有很多零,这样会变得更慢。因此,替代方案是因为我们大部分训练都是以批次进行的,所以我们在批次级别进行填充。

所以,我们不是对整个数据集进行填充,而是只查看一个批次中的元素,并对该批次中最长的例子进行填充。这样做的结果是将需要更少的计算,因此会更快。

但正如Svan所解释的那样,每个批次的大小会有所不同。所以我们可能在一个批次中,最长的句子只有10个标记。因此所有的句子都是10个标记,也许第二个批次是30个,以此类推。在Transformers库中,我们有所谓的数据整理器。这些数据整理器基本上是允许我们聪明地将这些不同大小的批次打包在一起,以便我们可以高效地进行训练的函数。

所以让我们看看一些问题,然后再回到这个col datac的内容。有一个问题是,让我看看。好的,我们收到了一个问题,内容是“嗨,有一些有限的标注数据集不是英文的。将数据集机器翻译成某种语言或特定领域的类型进行微调是否合理?”是的,这是一个非常好的问题,通常是强烈推荐的。

一个很好的例子是有一个数据集叫做MLQA。

这是一个多语言问答数据集,该数据集的作者基本上将英语的S数据集翻译成了几种语言,所以我认为他们有德语、西班牙语、印地语、越南语和简体中文。这是创建你所在领域或语言数据的一种方式,你可以在其上构建模型。唯一的缺点是,如果你在训练非常大的变换模型时,通常会被认为有问题。

他们总能以某种方式学习到这一点。已经有一个翻译被做过,他们会采取捷径来获得良好的表现,因此最终你在翻译文本中得到的模型可能在翻译的上下文中表现良好。但如果你将其用于真实的人际交互,这可能就会超出领域,或许模型只是学会了检测出这是翻译过的,而不是如何真正解决你关心的任务。

所以你要对此稍微小心一些,但这值得尝试,我在瑞士住的时候也用过这一点。那里有四种国家语言加上英语,因此大部分情况下你没有英语的数据,都是意大利语或法语,因此你需要进行一些翻译技巧。

嗯。😊 最近出现的一件事情,我认为挺酷的是,Facebook发布了一个叫M2M 100的模型。这是一个翻译模型。所以它是一个序列或者是我们在第一章看到的编码解码变换器,它可以基本上进行100种不同语言之间的翻译。所以你可以想象,你有一个100乘100的所有语言的矩阵,对于每一个语言对你都可以进行翻译。

所以这给你提供了9900对可以翻译的内容,而且这是一个非常好的模型。如果你正在寻找翻译,我建议你使用这个,如果你的语言在他们涵盖的1000种语言中。好的,接下来也许可以回到俄罗斯的问题,如何恢复在地图中之前创建的列?

现在我明白你在问什么,所以问题是,假设我们添加了这一列。现在我们有一个数据集,新增了一列,显示“hello”。我会给你展示一个具体的例子,比如如果我想删除这一列。那么我可以移除列。接着在这里我只需提供一个列名的列表,所以我可以提供“new column”。

然后这将删除。新列,并恢复到我们原来的数据集。差不多,我认为这涵盖了你想要撤销映射操作的大多数情况。唯一的情况是如果你对数据集进行了其他操作。也许你改变了这些原始列的内容,那么你知道,撤销这一步就不那么容易了。

好的,然后我们有另一个问题,来自SRM Zuma,问题是。为什么在TUs上动态填充比在GPU上慢?这背后有什么直觉吗?好的,所以这考验我的有限TPU知识,但我的理解是,这是一种从根本上不同的架构,主要用于进行数值、数值线性代数或代数方程,或者矩阵的乘法。

我认为这仅仅是由于芯片设计的方式。如果所有内容都是固定大小的矩阵,它们会更有效,而不是试图对数据进行洗牌以进行聚合。但是在聊天中以Haka Lama身份出现的Omar曾在谷歌工作,所以他或许可以在聊天中提供一个更好的答案。😊,嗯。所以,是的,这是一个很好的问题。我也想知道详细的答案。

所以这里有几点需要注意。😊,好的,我想在开始训练模型之前,快速看一下这个数据聚合器在做什么。在transformers中,有不同的数据聚合器来处理这种动态填充。

而我们大多数时间使用的是带填充的数据聚合器。这将会……让我看看。我可以看到它吗?是的,如果我从数据集中获取几个样本,我这里的样本只是一个标记化输入的列表,它们的输入长度是相同的。

所以他们可能是因为我加了填充,抱歉,让我把这里的填充去掉。所以我只是想在分词器中对数据进行重新分词,而不加填充。因为我们想要做动态填充。有一件非常酷的事情我没有提到,就是在数据中你所做的所有操作都是缓存的,因此它们基本上是作为箭头表存储在你的硬盘上,所以当你想要重新处理时,它基本上会检查我是否之前做过这个计算,如果做过,它会直接加载缓存版本,这样非常快,你会看到这只用了大约一秒钟,如果你处理过像一百万个示例,然后重新启动笔记本,你就不必再等待重新处理它们。

缓存会瞬间完成这一切。好的,所以现在我已经对数据进行了分词,没有填充,因此所有示例的长度各不相同。那么,当我将数据传递给这些样本时,数据创建器会自动将该批次中所有样本调整为该批次中的最长长度。

你可以看到,最长的示例有67个标记。因此现在它创建了张量,每个张量本质上有67列,你知道的,针对每个最长的标记,其中一些会有填充。这就是数据聚合器为我们做的。当我们进行训练时。

它会为我们即时处理所有这些。嗯,没错,SRum问TPU的问题是,平方矩阵也是GPU喜欢的,是的,没错。所以如果我没记错的话,TPU的上下文是与动态填充的区别有关,而使用动态填充时,我们实际上是在创建平方矩阵。

在批处理级别上,我们还在移动数据,因此我们必须动态创建不同形状的数据。我怀疑这可能是减慢速度的原因,但这是个好问题,我应该在某个时候查看答案。

很好,你提出了一个非常好的问题,这让课程中的两位老师感到困惑。他们很棒。谢谢。😊 好吧,很好,这差不多就是数据集的分词处理。😊 现在让我们看看训练。我们要做的是查看训练器 API。我们将启动视频。Sotrino API。Transforms 库提供了一个训练器 API,允许你轻松地转换模型和数据集。

训练器类确保你的模型以及训练 IP 参数,并可以在任何设置上执行训练,包括 CPU、GPU、多 GPU、TPU。也可以在任何数据集上计算预测,如果你提供矩阵,可以在任何数据集上评估你的模型。

你也可以进行最终的数据处理,例如动态填充,只要你提供一个分词器或在 MRRPC 数据集中给定的数据计算器 World5 CP,因为它相对较小且易于预处理。正如我们在数据集中的视频集中看到的那样,我们可以提出这些。

你在预处理过程中不应用填充,因为我们将在填充数据器之前使用动态填充。请注意,我们不会进行最终步骤的重命名、删除或设置格式为 torch 张量。训练器将通过分析模型签名自动完成所有这些工作。在创建训练器之前的最后一步是定义模型和一些训练的超参数。

我们首先在模型 API 视频中进行了第一步。对于第二步,我们使用了训练参数类。它只需要一个文件夹路径来保存结果和检查点,但你也可以自定义训练器将使用的所有参数,例如学习率、训练次数等。创建一个训练器并启动训练非常简单。

这应该会显示你的属性栏,如果你在使用 GPU,过几分钟你应该就能完成训练。然而,结果可能会让人感到意外,因为你只会得到一个训练类别,这并不能真正告诉你模型表现得如何。这是因为我们没有指定任何评估指标来获取这些指标。

我们首先使用预测方法对墙评估集进行了预测。它返回一个名称,包含三个字段:预测,包含模型预测;级别 ID,包含级别;如果你让我们添加网络和矩阵,这里是空的。我们正在尝试做到这一点。预测是模型对数据集中所有句子的输出。

因此,有一个形状为408x2的数组。为了将它们与我们的标签匹配,我们需要对每个预测取最大值,以了解预测的是两个类中的哪一个,我们用max函数完成这一点。然后,我们可以使用数据集库中的矩阵,它可以像加载数据集一样轻松加载。

它返回用于数据集的评估指标。我们可以看到我们的模型确实学习了一些东西,准确率为85.7%。为了在训练过程中监控评估矩阵,我们需要定义一个计算矩阵函数。它的步骤与之前相同,接受一个名称来保存对标签的预测,并且必须返回一个包含我们想要跟踪的指标的字典。

通过将epoC评估策略传递给我们的训练参数,我们告诉训练器在每个epoch结束时进行评估。在你的笔记本中启动训练将显示进度条,并在每个周期结束时完成你在这里看到的表格。

好吧,这信息量很大,如果你从未见过训练器,这可能一下子有太多内容,所以我们将一起走过这个过程,希望到最后你将拥有开始训练自己模型所需的所有工具。

解决你自己的问题。因此,在Google CoLab中有不同的运行时可用。通常情况下,默认是CPU,没有加速,因此你需要做的是点击运行时,选择运行时类型,对于这个笔记本,我们将稍后使用GPU,看看如何使用GPU。

然后我们保存这个。现在这将在Google Coab中启动一种具有GPU的机器。你可以做的一件事。

检查你正在运行哪种GP的方法是执行NviDdia SMI。

让我们看看我们得到什么。如果它醒来。这里我们得到了Tesla Kaie,这些通常是你得到的默认GPU,虽然不是特别好,但如果你在网上查找,通常可以找到有人保存了像P100这样的协作状态,你可以直接使用它们,非常快。当然,如果你重置运行时,有时这是一个小技巧。

尝试获得更好的GP。你可以进行出厂重置。

然后这将清除整个后端,希望现在仍然是GPU。也许我们会得到一些与K有点不同的东西,看看我们得到什么。好的,我仍然卡在Katie,但有时如果你运气好,它会给你一个P100或甚至是Tesla。好的。😊,所以我们把我们的GPU恢复到coab了。再一次。

我们做同样的事情,安装我们的依赖项。我们在这段代码中所做的就是之前做过的事情。所以我们加载数据集。然后我们从检查点定义一个分词器,因此我们使用B basincased。我们有我们的分词函数。这个分词函数的作用是获取这两个句子。记住,这个数据集是关于尝试预测一个句子是否是另一个句子的释义。

所以我们将这两个句子传递给分词器。我们使用截断为真,这样如果其中一个句子超过了最大序列长度Bt(512个标记),它会将其截断为512。然后我们对所有内容进行分词,并定义这个数据集,以便我们可以进行动态填充。所以我就要运行这个了,应该会非常快。😔,好的,所以在它运行的时候。

我们先来看一下训练参数。这是你与训练师接触的第一件事,所以训练参数。你可以把它看作是一个配置,它基本上是一个类,你可以在其中定义各种超参数用于训练。你需要指定的唯一内容是一个输出目录,所有训练的信息都会存储在这里。

如果你保存模型,它将存放在这里,因此如果我们查看训练参数,我们可以看到,让我们看看,我们能否透过这里看到。你可以看到我们有这个输出目录,还有许多内容,确实很多。你可以指定学习率,也可以指定优化器的参数。

你可以定义优化器,你可以定义类似于fast AI的回调。这并不奇怪,因为Sil开发了这个训练器。这些回调可以以聪明的方式控制训练,例如提前停止等。所以我不会详细介绍所有这些,但基本上你可以设置大量参数,你可以在训练器的文档中找到。

并且它提供了一些相当不错的默认值,所以大多数时候它会直接开箱即用。现在我们需要加载模型,并且我们指定两个标签,因为我们只有两个类别。它是一个释义还是不是。再次强调,这是一个序列分类模型,因为我们正在进行文本分类。接下来是下一个阶段,这可能是更复杂的部分。

所以我们需要实例化一个训练器,一个训练器至少需要一些东西。它需要一个模型。这是我们要训练的模型,它需要训练参数。这些是定义训练如何运行的内容。它需要一些数据集,因此需要一个训练数据集或评估数据集或测试集,你可以有一个,而没有其他的。

但它至少需要一件事,基本上至少需要一个你想要训练的数据集。你可以在没有它的情况下实例化,但一般来说你想要指定一个。所以在这里我们传递了分词后的数据,这很重要,因为你不想将原始数据传递给你的训练器,因为它会将其喂给模型,然后模型就会开始处理。

我不知道你在做什么,我该如何处理这些字符串。还有另外两件有趣的事是传递数据协调器和分词器,因此提供这两个参数将实现动态填充,这样训练会更快。它的工作方式是你要求给我一个协调器。

数据协调器有不同类型,但我们使用的是最常见的一种。同时它也需要分词器,因此数据协调器的工作方式是将分词器与批处理结合起来,以确定如何安排输入。

因此,通过提供这两个参数,我们将会加快训练速度。嗯。这样就会实例化训练器。让我们看看它是否有效。好的,一切正常,所以在我启动训练之前,通常我会进行一个理智检查,确保我可以运行评估函数,因为很多时候发生的情况是,当你运行训练时,你会训练若干步,然后在一个周期结束时进行评估,这基本上是默认策略之一。

但如果你的评估,可能你的指标实现得不正确或者其他原因。如果评估失败,那么你在等待整个一个周期的训练后也会失败,这真的很让人烦恼。因此,我做的一个理智检查就是确保我可以运行评估。

如果这样有效,我相对有信心训练过程会成功,你可以看到这个评估提供了关于验证集中示例数量的信息,并且给出了损失值和一些运行时指标。

这种处理批次的性能如何?显然,目前这是一个随机模型。我们只是初始化了Bert作为骨干网络,然后堆叠了一个带有随机权重的线性层,所以这算是一个无用的损失,目标是在训练后使其下降。酷,所以我现在要运行训练。这需要几分钟。因此在它运行时。

然后我们会观看加速视频,它会向我们展示如何。嗯,也许不是。也许我会先运行这个,然后看看是否有任何问题。好的。DK crazy diviv问。我们正在使用Bt base uncased,文章提到Bt使用的是WordPiece,但我们通过pip安装了transformers的sentence piece,我们在这里使用它吗?

如果我想反向工程,我该如何以编程方式从检查点获取并弄清楚使用哪个分词器。这是个好问题。所以。我们的问题是。为什么我们要进行Pip安装transformers sentence piece?这是一个可选依赖项,它是XLM Robbaa等模型使用的不同分词算法。

它被列为可选依赖项,因为它有点重。因此,如果你不想使用任何不需要句子分片进行分词的模型,可以直接不安装,它仍然会正常工作。所以例如,如果我们仅通过transformers进行Pip安装,我们将免费获得wordpiece。

它会作为一部分,但如果我们想使用其他模型,就必须明确地定义句子分片依赖项。所以这可能澄清了问题的第一部分。我们始终与Bt一起使用wordpiece,仅在需要时才为模型安装句子分片。我们在课程中包含它的原因是,因为在未来的某些部分中,我们会使用句子分片分词器,因此如果我们始终能够访问它会很有用。

好的,如果我想反向工程,我该如何以编程方式从检查点弄清楚使用哪个分词器?

好的,所以也许我们可以。我将用两种方式来回答这个问题。所以最简单的方法如下,在transformers中。我们有一个自动模型。适用于不同类型模型的AClas,因此这个自动模型将进行编码,我们也有自动分词器。哦,哎呀。输入。这些类会进行配对。所以如果我从自动分词器获取。

预训练。我放入B基础。无大小写。它会自动分配与该检查点关联的分词器,然后加载到我的分词器对象的分词中。同样,如果我做自动模型。从预训练。然后我做同样的。嗯。检查点。

它会自动确定对于该检查点我需要这组权重。所以你需要知道的最重要的事情就是确保在使用from pretrained时,分词器和模型使用相同的检查点。因此,我在代码中经常会有一个显式变量。

这是Bt基础无大小写的内容。像这样,然后我会将这个变量加载到我的所有预训练调用中,这样我就知道它们是匹配的。🤧啊。好的,这就是我们将这些东西连接在一起的标准方法。嗯。😊,现在你在问。我们如何以编程方式从检查点获取到分词器?让我们看看里面有什么。

这些模型文件之一。这这这。让我们检查一下我的训练是否正常。😔,好的,很好。好的。在模型中,我们有一个配置。这个配置。让我们看看。好的。这个配置告诉我们检查点的名称。嗯。所以。如果你想以编程方式确保,我的意思是。

假设你从配置开始。我想你可以把这个属性用作传递给分词器的内容。因此,例如,我可以这样做:tokenizer 等于 auto tokenizer from pretrain。然后我会拿我的模型,我会拿我的配置,然后我会访问它是什么?

是名字吗?哦。我可以把这个当作一个属性吗?是的,我可以这样做。所以我可以这样加载我的分词器,这样可以保证检查点匹配。但老实说,这有点复杂,所以我更倾向于定义一个变量来保存检查点,然后把这个变量传递给分词器模型。我希望这能回答你的问题,D,crazyative。😔,但如果不清楚,请随时问。

我们的模型接近完成训练,你可以看到在训练器中默认每 500 步,模型将在验证集上进行评估并记录损失。默认情况下。这只是训练损失。但 Sylvan 在视频中解释的事情是我们真正想做的是计算像准确率或 F1 分数这样的指标。因此,实际上你这样做的方式是定义一个名为 compute metrics 的函数。

这个指标函数基本上必须返回一个字典,其中包含与指标名称对应的键,以及你从预测中计算出的值。因此在这里的这个例子中,Sylvan 利用 Datas 库,该库也有自己的指标。一旦你加载了该任务在 glue 中的指标。

你只需要提取预测和真实标签。然后你只需调用 metric.compute,这将自动为你创建这个字典,然后你可以将其传递给训练器,如下所示,因此你可以像这样计算指标,这样默认情况下每 500 步就会计算一次指标,除了训练损失之外,这非常方便,因为这就是你在训练时跟踪模型在验证集上表现的方法,从而做出决策。

是在变好还是?啊,这个。好的,我们来看看这个。所以,好吧,模型已经训练好了。嗯。你可以看到这里的训练损失大约是 0.35。当我们进行评估时,损失大约是双倍,并且那是随机权重。所以现在,如果我再运行评估,希望损失能降低。好的。

它升高了,这很有趣。😊,我不确定为什么会这样。所以我只能说这是演示之神在捉弄我。一般来说,这应该是降低的,反常,可能只是我们所做的随机波动。好的。为了深入探讨我们是如何构建这个指标函数的。

训练器有一个预测方法,您可以将数据集输入到该预测方法中。这个预测方法将返回一个名为predictions的对象。这个对象看起来是这样的。这个predictions是一个预测输出对象,就像一个具有属性的数据类,具有的属性是预测。因此,如果我们查看预测。哎呀,这不行。

这基本上是模型中所有逻辑单位的数组,我们也有真实标签。标签以ID的形式列出,因此这是你知道的同义句、非同义句、非同义句,等等。因此,构建计算指标函数时,您通常需要做的主要工作是将逻辑单位转换为整数或标签ID,因为这是您希望进行比较的内容。

所以,有一种方法是计算AGmax,这基本上会说,对于每个预测的逻辑,找到最大的或最高的逻辑索引。因此,一旦我们应用这个,我们的预测现在是一个整数张量。然后我可以将这些预测输入到我的数据集指标中。

然后我可以在此基础上运行计算,它应该希望给我们这些值。那么关于计算指标有什么问题吗?好的。😊,所以我不打算运行最后一个单元,它只是我们之前做的同样的事情,它将运行训练,但不是显示训练损失,而是显示我们使用的验证指标。不过,我鼓励您自己尝试一下,可能使用一个新的数据集,以便理解它是如何真正工作的。

好的,这就是训练器API,这大约是我90%的时间所使用的,它非常方便,能够正常工作,这意味着我不必过多考虑编写自己的低级训练脚本或训练代码,这通常容易出错。因此,使用像训练器、fast AI或Pytorch lightning这样的高级API的一个好理由是,它们抽象掉了很多模板代码,如果自己做可能会有错误。

而且这经过数千名用户的实际检验。好的,结束本次会议,我想现在看看一些对我来说非常令人兴奋的事情。至少是Silvan开发的一个库可以加速,说明,有时我真的需要控制训练循环。您可以在这些方面进行操作。

CPU和GPU的使用相对简单。有很多教程可以做到这一点。但在过去几年中,有一种趋势是访问多GPU或TU机器,这些机器原则上可以提供很多加速,因为您可以分配训练,从而将批次分配到这些设备上。

在这些设备上进行计算,然后在整个设备集群中进行反向传播。但实际上,作为初学者做到这一点非常困难,因为你需要理解PyTorch或TensorFlow中的所有分布式设置,再加上容易出错的多种方式,跟踪数据如何在节点之间并行分配也有点麻烦。

因此,这个加速库旨在让我们简单化,让我们看看最后的视频。是这个吗?Ter。通过Egging Face加速你的PyTorch训练循环。有多个设置可以运行你的训练,可能是在CPU、GPU或多个GPU上。分布在一台机器上或甚至多台机器上。

通常被称为具有多个设备的节点。此外,还有新的调整可以使你的训练更快或更高效,比如混合精度和dip速度。每个设置或训练技巧都需要你以某种方式更改训练循环的代码,并学习新的API。所有的设置都由训练器API管理,还有各种第三方库可以提供帮助。

这些的一个问题是,它可能会让人感觉像一个黑箱,且实现你所需的训练循环调整可能不容易。Accelerate被特别设计成让你保持对训练循环的完全控制,并尽可能不干扰,只需向你的训练循环添加四行代码,你可以在训练循环视频的示例中看到。

Accelerate将会在第一张幻灯片上安装所有的步骤和训练技巧。只需学习一个API,而不是10个不同的。更具体地说,你必须导入并即时创建一个加速器对象,它将处理你特定设置所需的所有代码。然后,你需要将其发送到模型、优化器和你在prepare方法中使用的数据。

记住这是主要的方法。Accelerate处理设备放置,因此你不需要将你的批量放置在你正在使用的特定设备上。最后,你需要用Ac tall dot backward loss替换丢失的dot backward行。就这样。加速器还涉及分布式评估。你仍然可以使用经典的评估循环。

就像我们在训练组视频中看到的那样,在这种情况下,所有过程将执行完整评估。要使用分布式评估,你只需将评估循环调整如下,沿着评估将错误传递给加速器,或像训练一样。然后你可以省略将批量放置在适当设备上的那一行。

在将你的预测和标签传递给你的指标之前,使用加速器来收集每个过程的预测和标签。一个分布式训练脚本必须在不同的进程上多次启动,例如,每个GPU一个,如果你熟悉它们,可以使用PyTorch工具来实现。

Acrate还提供了一个简单的API来配置你的设置并启动你的训练脚本。在终端中,运行accelerate config并回答一个小问卷,以生成包含所有相关信息的配置文件。然后你可以运行accelerate launch,后面跟上你的训练脚本。在笔记本中,你可以使用笔记本启动函数来启动训练。

好的。在我们查看Pytorch和加速器中的低级训练循环之前,有个问题来自EBtan,他问,我可以找出需要多少标记样本才能在迁移学习和微调中获得好结果吗?

这里有没有经验法则?这是个非常,非常好的问题。😊,至少在我看来,答案真的取决于你想要解决的任务,所以一般来说,你需要考虑你所处理的语言和领域,这些都是需要考虑的因素。从我的角度来看,粗略的层次结构是文本分类通常是最简单的任务之一,在标准文本分类的背景下,你可能只需要大约100个样本,通过迁移学习可以获得相当不错的结果。

当然,你应该始终做的事情是建立基准,因此构建一个非常,非常简单的模型,不要使用变换器,做一些像朴素贝叶斯或逻辑回归之类的事情。仅仅作为一个理智检查,看看在你的小数据集上,当你的结果是否能从训练集转移到验证集,因为确实存在。

这里有很大的过拟合风险。所以大致上,几百个样本对于文本分类来说至少对我来说效果很好,但随着你处理不同的任务,这会变得有点困难,比如如果你转向问答。

这里有两种策略可以选择。其中一种策略,可能是开始时的第一种,就是如果你在进行问答或抽取式问答,比如S,那么要寻找一个在你所在领域的SQUAD上已经训练好的模型。假设我在做德语的SQUAD,这与标准情况有些不同。

也许我在这里寻找SQUAD。让我们看看。我相信有一个德语SQUAD,也许我可以将语言指定为德语。好的,我们没有那个。让我们看看,我相信,有一家公司叫Deepset做了这个,它叫Quad,好的。所以德语在这里基本上是一个在德语版本的S上微调的语言模型。

这使你能够用德语回答问题。嗯,所以。😊。然后我会拿这个模型,如果我的语料库是德语,但它是定制的,可能是我的商业数据,我会尝试看看这个模型在那个数据集上的表现。通常,你会发现它的表现不如原始的SQUAD模型。

然后你将会从S模型到你的领域进行一些领域适配。所以你基本上只是对你的领域进行一些微调,通常你会看到模型适应你的语料库,并且你会获得更好的表现。在这个背景下,比如问答任务,通常你需要大约几千个示例,大约一千到几千个示例才能获得至少不错的结果。

但你必须非常小心,因为有时候在将一个模型的领域适配到另一个模型时,如果你过度拟合你的领域,你将会忘记微调模型起初具备的所有优良特征,因此在这个意义上通常是很棘手的。

嗯。😊 然后对于其他任务,比如命名实体识别,我认为这是非常问题特定的,真的取决于你拥有的实体,以及这些实体的频率,我觉得你可能需要几千个示例才能获得还不错的结果。

所以总结一下。😊 嗯。😊 好吧,简单总结一下我的回答。我们在谈论的可能是几百个标记示例用于像文本分类这样简单的问题,或者几千个。在标记的情况下,如果你做的事情非常小众,甚至可能需要更多。

我的意思是,如果我在做法律合同的法律分析,可能这个领域与现有的预训练模型有很大不同,我实际上需要对一个看起来像我拥有的法律语料库进行某种微调,因此你不需要标记数据,你只需要大量的未标记法律合同,然后可以微调一个语言模型,接着转移到你的领域。

好的,所以有一个后续问题,感谢你的回答。如果我有几百个以上的任务类别,好的,是的。那么这就变得非常困难。我认为这可以归入文本分类的复杂性层次中,最简单的情况是二分类,接着可能是多分类,然后是有很多标签的多分类,比如一百或一千个不同的标签或类别,然后多标签大致在这个范围内,所以我认为总体上会更难。如果你有一个数据集,有一千个或更多类别,你会发现模型会对主要类别非常自信,通常在这些类别中总会有一种分布,而大多数情况下是幂律分布,所以你会有一些非常常见的类别,还有一些非常稀有的类别,只因为这些标签或者其他人不常用。

所以模型在那些稀有任务、稀有标签或稀有标签上会遇到很多困难。因此,我建议你集中精力处理困难示例,尽量收集更多稀有示例的数据,以增强模型的信号。因此,你可能不需要多收集10个常见类别的示例。

你需要多100个稀有示例。但一般来说,只要在标签上有良好的覆盖,它应该就能工作,只是会比较困难,因为你知道,有100个选项,模型犯错误的几率更高。事实上,有一个很好的技巧我应该提到。

训练模型时,你可以提取或计算模型在每个样本上的损失。如果你这样做,这将大致告诉你模型在哪些示例上最困惑,而这实际上是FastAo中的一种技术。

嗯,我不知道他们是否已经输入了,但至少这是我第一次看到它的地方。

那么,让我们看看fast AI。如果我们看看。嗯。我想,叫做“最困惑的”。😔,但让我们看看。好的,V2中情况有所变化。😔,好的,我找不到它。但基本上在FAA库中,他们有一个功能,可以绘制模型遇到困难的最困惑示例,然后通过这些你可以找出需要收集更多数据的地方。但大致来说,发生的情况是它会混淆验证集中每个示例的损失,然后对它们进行排序,所以如果你手动这样做,你将能看到需要改进的地方。

好的,我们来总结一下,深入了解Acelerate库。所以这里的区别是,不是使用。

GPPU,我们将使用后端的TPU硬件。所以我们以这种方式激活它。

我们像往常一样安装transformers和数据集。

你现在需要做的主要事情是安装一些加速和TPU特定的库。因此,为了在TPU上运行PyTorch,我们需要一些特殊的轮子,他们基本上称之为二进制文件,我们可以在这里安装。

这将允许我们在TPU上运行PyTorch。我们要做的第一件事总是一样的,就像我们只是对数据进行分词。这现在已经很熟悉了。Sylvan在这里做的一件事是移除所有文本列或我们在训练时不需要的列。明确来说,这是为了让训练者在接收原始文本时不至于混淆。

他还将标签列重命名为 labels,这有助于训练器自动检测应该在哪一列计算指标。另一件他正在做的事情是将数据集中元素的格式设置为 Pytorch 张量。因此,我只是想快速给你展示一下。如果我们查看我们的标记化数据集,训练 oops。😔,我们查看一个元素。嗯m。现在,我们在今天的会议中看到的一切都只是一个 Python 列表。

但是你可以将数据集的格式从列表更改为张量。但你也可以将它们设置为 TensorFlow 张量,如果你运行 TensorFlow,甚至我认为你可以为 nu 数组执行此操作。因此,这实际上取决于你想要操作和修改的内容,但这是一个非常方便的切换格式的方法。哎呀,所以,是的,逼迫,真的不?

好吧,因为我们不使用训练器,而是使用自己的训练循环,我们需要被称为数据加载器的东西,所以在 Pytorch 中,有两个重要的概念,一个是数据集的概念。这些都是我们到目前为止大部分时间所做的事情。

不过,当你想要向模型输入批次时,有一个叫做数据加载器的 API,它会自动从数据集中抽样,然后将这些样本提供给模型,因此你基本上只需输入你关心的数据集,然后可以指定是否想要随机打乱元素,这对训练很重要,以防数据中有一些人为的顺序,你还可以指定批次以及动态填充的汇总方式。

好吧,你可以创建一个数据加载器,然后如果你查看数据加载器的一个元素,它基本上将是与每个批次关联的一组张量。然后我们像往常一样在这里站着我们的模型。一旦加载完成,我们可以做一个 sanity check,如果我们输入一个只有输入 ID 的单一批次。

注意掩码标签,以及我想谈论的其他想法。它返回一个张量,这是损失,因此这就像是一个 sanity check,确保我们的模型在工作。而且,因为我们进入训练循环的低层次,现在我们还必须指定优化算法,以基本上最小化损失函数。

所以我会说默认情况下,一个非常好的默认值是使用这个修改过的 Adam W,并且你可以使用默认的学习率。你只需传递你想要优化的模型参数。因此,只是为了快速展示,如果我们看看这个,这是一个生成器。所以我需要创建一个列表。如果我查看其中一个元素。

你可以看到模型的参数由张量组成。因此,这些就像我们的权重和偏置。还有一个名称告诉我们你知道我们在看哪个层,因此通过将这些传递给Adam,我们基本上是在说这是我想要你优化的权重和偏置的指令,然后在我们进行训练时它将继续进行优化。

还有一些额外的东西需要指定,比如epochs的数量、训练步骤的数量,以及我们想要控制训练期间学习率的调度器。因此,如果这些概念是你第一次见到,我们在课程笔记中提供了信息来帮助你理解。

但基本上说,在整个训练过程中使用恒定学习率是次优的,无论是在速度上还是在获得良好局部最小值方面,因此我们有调度器,基本上控制学习率在训练期间如何增加和减少。

因此我们可以定义调度器。我没有定义优化器吗?好的。那么,我只是要加载这个,这只是你在GPU上进行操作时的一个示例。你需要指定设备。这大致就是在Pytage中训练循环的样子。因此你说我们现在要进行训练,所以我们将在模型中激活dropout。

然后我们对每个epoch循环,对于每个epoch,我们将循环遍历训练数据加载器中的每一个batch,然后我们将这些张量设置到我们关心的设备上,我们将计算损失,然后我们将在Pywch中执行反向传播,然后我们基本上会与优化器和调度器一起采取一步,现在我们更新,这将以正常方式在GPU上进行训练。

或者是CPU。但有趣的是我们正在使用TPU,因此在TPU中,我们在coLab上有八个核心,因此我们想要基本上以这种方式进行分布式训练。这有一个关于分布式训练中发生的事情的不错的示意图。

我会把这个放在聊天中,你可以拥有一堆不同的机器,每台机器都有自己的进程,因此你可以把每个进程想象成一个处理数据的小控制器。因此,我们可以将TPU视为拥有八个不同进程,我们需要进行权重共享的通信。

本质上,我们如何在这些进程中进行反向传播。而accelerate库使我们能够非常简单地做到这一点。嗯。基本上,我们定义了一种叫做加速器的东西。然后我们必须使用这个加速器API准备数据加载器、评估数据加载器和模型。

这将自动计算我正在运行的硬件。我有多少核心,应该如何分配数据。我基本上应该如何在这些节点或设备之间复制模型,之后的其他一切与我们之前看到的完全相同。所以你实际上不需要更改。你的训练脚本基本上保持不变,只是准备数据的方式有所不同。

训练循环。所以如果你这样运行,这不会生效。我们需要做的是将所有的加速器代码包装在一个训练函数内。所以如果我们这样做。我们只需要。把这一切。放在一个训练函数里。而我昨天发现的一件事是,我们需要确保我们在这里使用的数据加载器。诶诶。

先快速看一下。嗯。你没有全局变量。这就是我想我该怎么做。好的。😊。所以在这里我只是初始化一个模型,初始化我们之前做的优化器,而这里“加速”的魔力基本上会为我们做这个分布式放置,所以它将给我们数据加载器、模型和优化器,然后其他一切正常运行,这也是为什么关于标记化数据的问题很重要,我们之前所做的是使用动态填充,因此我们在标记化器中并不直接使用填充。

事实上,在这里,如果你查看我标记化数据的时刻。在哪里。这里在我的标记化函数中,我只使用了截断。但是因为我们在TPU上运行。我想要激活填充,所以我需要设置padding equals true。我将指定我想要填充的最大长度,而不是整个模型的最大长度,因为那太大了。

我将任意指定为128个标记。所以一旦你填充了所有输入,我们就可以进行包装。我们需要在这里重新实例化数据加载器。现在,我们可以。创建一个训练函数。希望这样能让我们启动。TPU训练。

好的,在这进行的同时,我们快速看看问题。嗯。好的。那么有一个来自“I am Home”的问题。今天和明天都有一个关于Titch的拥抱会,所有标签都是第三章。主要的区别在于时区。所以我们尝试捕捉居住在地球东西两侧的人们。今晚还有一个与Matt Carrigan的TensorFlow会议。

所以这是为所有TensorFficionados准备的。嗯。有一个来自Uns的问题,关于文本分类的领域特定案例,在我为下游任务训练模型之前,预先微调语言建模以更好地理解上下文是否有意义?是的,通常来说,这是非常好的做法,你在性能上获得的提升与领域转移密切相关,因此如果我有一个在维基百科上预训练的Bt,而我的文本又有点像说事实性或类似于维基百科的内容,那么我从微调我的语料库中获得的提升就不会那么大,但如果我的语料库在领域上非常不同,比如可能是源代码之类的,那么通常会看到性能的更大提升。

所以这总是值得去做,并且通常比较容易做到。有一个问题是,如果我想对文章而不是句子进行分类,Bert和相关模型是否仍然有效,或者我是否应该考虑像长文本这样的模型,这个问题非常好。因此,Bert基本上是有限的,或者说大多数这种普通模型的限制是512个标记,如果你的文档长度超过这个,你将不得不做一两件事,使用一个可以处理更长序列的模型,比如longform或big bird,记得它们可以处理4096个标记,所以它们要大得多,大约是Bert的八倍。

但是如果这还不够,你就需要将文档基本上分块或拆分成多个段落,然后将这些段落输入到模型中,再进行一些聚合,以便构建出一个可以输入到分类头的完整文档的表示。

有一个问题是关于如何改进基线模型,使用Roberta模型进行训练。是的,没错,正是这样。我是Holmes,问道使用P Toch的默认Adam W和transformers的版本有什么区别?

这是个好问题,按理说我不太确定,我猜是有一些,我的意思是Adam有很长的历史,可能没有被正确实现。所以,😊,对,我的直觉是transformers的版本可能是正确的,而P Toch的那个可能不太准确,但。

也许做一些实验,找出答案,抱歉,我当下不太清楚。好的,酷。这些问题大致上就是这些。让我们看看出了什么问题。这时我可以进行一些调试。让我们看看。我收到了一个错误,提示你可能应该激活截断或填充,并将填充设置为true。

为了批处理具有相同长度的张量。好吧,所以我显然在数据加载器时做错了什么。让我们看看出了什么问题。首先,我对我的数据进行了标记,这是好的。然后我需要设置格式。啊。我想摆脱这个clay函数。这个co函数将是导致我们问题的所在。好吧,现在应该是我。

启动TPU训练。好的,现在在这八个TPU核心上启动。希望不会出错。谢谢你的反馈。我是Homeme和DK creativezative。希望你喜欢这个,谢谢你的提问。😊,所以这看起来在训练中。是的,太好了。哦不,没问题。好的,那么。Stack期望张量大小相等,但有96。😔。

好的,所以。嗯。好的,在这里我将进行一些,我知道我们超时了。对此我感到抱歉。我会看看,看看能否快速调试。如果不能。那我稍后会修复笔记本。好的,基本上我遇到了一个错误,这是一个很好的方式来看到TPU比其他的更有趣。它说堆栈期望每个张量大小相等,但在entry0有96,在entry1有100。所以这让我觉得我在分词时搞错了。因此,原本应该是相同形状的,现在却出现了一些问题。

好像出错了。让我们看看。我的数据加载器。好的,所以。我们先看看我的分词。当我进行分词时。我设置了padding为true和最大长度。所以现在。当我查看我的分词数据集。让我们看看。这这这。所以也许让我们看看输入是。输入ID。

我们希望它们都是相同形状。我会直接取。嗯。我们就取,比如说10个。然后我将说张量大小。对于这个张量。所以让我们看看得到的结果。好的,这告诉我所有的张量都有相同的大小。这很好。嗯。我们再做个完整性检查,如果我。从末尾开始。是的,这很好。好的。

所以我的张量都是相同大小的。应该再做一次。让我们看看。现在。关于这点有什么抱怨?😔,无效类型。吓。因为我需要。返回张量等于。相当恼人。好的,别这样做。太过麻烦。然后我们去掉这一列。设置格式,好的。😊,现在让我们看看这里得到的是什么。好的。

所以我们已经看到有个问题。有趣,所以。嗯。😊,呵呵。😊,很好,好的。所以我们要尝试调试这个,实际上,如果有人看到我做错了什么。这将很棒,所以这是一个问题,问题是我创建了一个数据加载器。😊,在这里。训练数据加载器,它抱怨当我尝试把张量放在一起时。

它们的形状似乎不一样。所以。让我们看看我做错了什么?好的,所以。我们来试试。😔。那么,让我们。看看第一批。然后我们来看。好的,看看我输入的内容。我,然后看看每个张量的大小。在这里。啊哈。😊,所以。看来我的分词数据集不是。我想要的那些。

那么让我们看看发生了什么。如果我查看的话。我们之前看到这些应该是89的大小。让我们看看这个。然后我们这里使用T.dot.size或T。嗯。好的。所以。你可以看到在我的分词数据集中,所有输入的大小都是89。但是。出于某种原因。在训练加载器的批次中,一切都是71。嗯。😊,所以让我们看看。Wch。

为什么会不同,为什么批次会不同。嗯。对对都。嗯。😊。别告诉我我需要这个合并函数。😔,不,这不是我想要的,因为现在。😔。它们将动态填充。嗯。😊,这很有趣,我要看看。う。所以,让我们看看我们有没有。就只是告诉你我做了什么。

所以我重新引入了一个合并函数到数据加载中。在这里。我相当确定我们不想这样做,因为我们想要固定的大小。但是,让我们看看。这是否有某种魔力来调试这个问题。好的,所以出于我不明白的原因,向数据加载器添加合并函数似乎是重要的。

让我们进行训练。你可以看到在一个TPU核心上,我正在运行。训练。所有这些消息对吧。你可以看到这些是你在实例化模型时经常收到的警告消息,所以加速器所做的就是将模型复制到八个TPU核心,但以相同的方式进行初始化,所以我们一开始得到了相同的模型。

然后它应该实例化另外七个并行训练。所以现在我们在八个核心上训练复制的模型,每个核心都会获得自己的数据批次,然后反向传播将被同步,这样当我们更新模型时,我们是基于每个设备计算的损失进行更新。

嗯。😊,所以这显然有点小技巧,我有点不高兴的是,我所说的需要使用填充的内容似乎和合并函数混淆在一起,但这就是生活编码的乐趣,也许你可以自己深入了解并尝试理解究竟如何设置这个,我脑中仍然有一些东西缺失。

😊,但是无论如何,那是一些。我们可以说在TPU上训练,我推荐你做的一个家庭作业是尝试在新的数据集上处理这些训练笔记本。所以你可以在中心找到许多选项,如果你去数据集。

你可以看看文本分类,大部分时间这将涵盖你现在学习这一切所需的所有内容。而你可以做的另一件事是,比如说,我们正在进行同义句检测。我们正在检查两个句子是否是彼此的同义句。另一个例子是Corera数据集。这是像Stack Overflow或Q&A网站上非常常见的问题,因为有人在提问,有时问题是重复的,你通常依赖社区标记问题是否重复。因此,这将是一个不错的数据集,可以使用,与我们做的非常相似,但会让你体验到处理不同列和不同输入的不同风格,所以我会把这个建议放在聊天中。

而且我也建议你看看能否让TPU训练运行起来。我认为TPU是一个非常令人兴奋的发展,因为它们原则上提供八倍的加速,但实际上大约是三倍。与传统的GPU训练相比,它们在Colab上是免费的。因此,现在你可以使用TPU来比正常情况下更快地训练,并进行非常酷的分布式操作。

好的,这有点长,对此我感到抱歉,这都是我没有调试代码造成的,希望你喜欢今晚的内容,Matt将做TensorFlow,如果你对此感兴趣,而我认为明天Sil将进行下一轮的讲解。

😊,下周我们将深入库的更高级部分。我们下周要做的事情是如何在中心共享模型,如何将所有内容推送到中心,以及如何共享指标。因此,这将是我们所做的一切的点睛之笔。

所以我还没回到第四章,但Omar回来了,Omar很棒。他现在在聊天中,所以你绝对应该来。我实际上也会在聊天中,所以这就像换身体一样。希望你们到时候能见到我。😊。好的,所以我现在要停止录制和直播,如果你有任何问题。

把它们放在论坛上,我们下次见。

posted @   绝不原创的飞龙  阅读(21)  评论(0编辑  收藏  举报
相关博文:
阅读排行:
· 一个费力不讨好的项目,让我损失了近一半的绩效!
· 清华大学推出第四讲使用 DeepSeek + DeepResearch 让科研像聊天一样简单!
· 实操Deepseek接入个人知识库
· CSnakes vs Python.NET:高效嵌入与灵活互通的跨语言方案对比
· Plotly.NET 一个为 .NET 打造的强大开源交互式图表库
点击右上角即可分享
微信分享提示