一站式 LLM入门

1. Introduction：人工智能概述

#参考目录，这里非常非常基础。对于已经对人工智能有基本的了解的阅读者大可跳过。

1.1 人工智能概念与分支：

• 人工智能（Artificial Intelligence）是让各类机器载体上模拟并拥有类似生物的智能，让机器可以进行感知、学习、识别、推理等行为的计算机科学技术。

• 人工智能是计算机科学的分支，涉及领域包括计算机视觉（Computer Vision，CV）、自然语言处理（Natural Language Processing，NLP）、语音识别（Voice Recognition）、语音生成（Text to Speech，TTS）、知识图谱（Knowledge Graph）等。本文档系大语言模型入门材料，因此主要关注NLP领域的技术。

• 从学术角度来看，人工智能有三大学派：符号主义（Symbolicism）、联结主义（Connectionism）、行为主义（Actionism）。

• 机器学习是人工智能的核心，现在最前沿的AI技术的主流算法都是基于神经网络和强化学习。

学派分类	符号主义	连结主义	行为主义
思想起源	数理逻辑：基于统计方法，通过建模预测让机器通过计算来模拟人的智能，实现识别、预测等任务	仿生学：生物智能是由神经网络产生的，可以通过人工方式构造神经网络，训练神经网络产生智能。	生物的智能来自对外界的复杂环境进行感知和适应，通过与环境和其他生物之间的相互作用，产生更强的智能。
代表算法	朴素贝叶斯，逻辑回归，决策树，支持向量机	神经网络 Neural Network	强化学习 Reinforcement Learning

1.2 机器学习

• 机器学习（Machine Learning,ML)是实现人工智能的核心方法，是从有限的观测数据中“学习”（or“猜测”）出一个具有一般性的规律，并利用这些规律对未知数据进行预测的方法。

• 传统的机器学习主要关注如何学习一个预测模型，一般需要首先将数据表示为一组特征（Feature），特征的表示形式可以是连续的数值/离散的符号等形式。而后将这些特征输入到预测模型，并输出预测结果。这类机器学习可以看作是浅层学习（Shallow Learning），其重要特点是不涉及特征学习，其特征主要靠人工经验或者特征转换方法来提取。

1.3 机器学习的分类：根据学习范式分类

根据学习范式的不同，机器学习可分为有监督学习、无监督学习、自监督学习和强化学习

1.3.1 有监督学习 Supervised Learning

1.3.1.1 有监督学习的基本定义

• 有监督学习（Supervised Learning）：是机器学习中一种常见的学习范式，其基本思想是利用带有标签的训练数据来训练模型，从而使其能够从输入数据中学习到输入与输出之间的映射关系，然后可以利用这个映射关系对新的未标签数据进行预测。 <是不是很像人通过刷题的学习过程？用带了标准答案的习题集去刷题，如果做错了就根据错误的原因反思改进。当新的题目到来时，便可根据过去刷题的经验来去写新的题目。>

• 有监督学习的训练集要包括输入（特征）和输出（目标），其中，输出是人工标注的。

• 有监督学习的例子：训练一个模型用于识别一个公司的财务报表是否有财务舞弊：有1000份财务报表，每份报表上体现了资产负债率、现金流量等关键数据，我们用X指代。报表有500份舞弊的和500份没有舞弊的。

• 那么，我们就有一个1000个样本的训练数据集；X是每个训练样本的输入或者特征；该样本是否舞弊则是由人工标注的输出或者目标。对于每一份输入的训练数据，都是有一个确定的预期输出结果的，因此称为“有监督”。我们可以称这样的训练样本为“带标签的输入、输出对”。

• 利用这个训练数据集，我们对算法进行训练。整体而言，训练出了一个函数f(X)，他“学习”了训练集中f(X1) = 舞弊，f(X2) = 正常，f(X3)=正常，f(X4) = 舞弊， ……，f(X1000)=舞弊的信息。当我们给出一份新的报表时，他也可以帮我们判断这个报表是舞弊的还是正常的了。

• 有监督学习的步骤如下：

1.3.1.2 有监督学习的典型应用

1. 分类（Classification）：预测输入样本属于哪个类别或者类别的概率分布。典型的例子包括垃圾邮件分类、图像分类等。

2. 回归（Regression）：预测输入样本的数值输出，通常是连续的实数值。典型的例子包括房价预测、股票价格预测等。

3. 目标检测（Object Detection）：在图像或者视频中检测出目标物体的位置和类别。例如自动驾驶中识别出道路上的车辆、行人、交通标志等；或者人脸识别中判断出哪一部分是人脸。

4. 序列生成（Sequence Generation）：根据输入的序列生成输出的序列，如机器翻译、音乐生成等。

5. 序列标注（Sequence Labeling）：序列标注是一种常见的机器学习任务，其中输入数据通常是序列数据，例如文本、语音、生物信息学等。有监督学习可以对输入的序列中的每个元素进行标签预测，如命名实体识别（Named Entity Recognition，NER，指自然语言处理中，能从文本中提取如人名、地名、组织名、日期、时间、金额等具有特定意义的实体或实体类别）、语音识别（Speech Recognition）等。

1.3.1.3 常见的有监督学习的算法

• 常见的有监督学习算法包括线性回归（Linear Regression）、逻辑回归（Logistic Regression）、决策树（Decision Trees）、支持向量机（Support Vector Machines）、随机森林（Random Forests）等。

• 这里提到的大多数算法我们都不需要看，关注神经网络即可。

1.3.2 无监督学习 Unsupervised Learning

1.3.2.1 无监督学习的基本定义

• 无监督学习（Unsupervised Learning）是机器学习中一种常见的学习范式，其目标是从未标记的数据中自动地发现数据中的结构、模式、关联或者表示，而无需使用人工标签或者先验知识的指导。

• 在无监督学习中，算法需要从数据中自动地进行学习，无需先知道数据的标签或者类别信息。无监督学习面临的挑战在于缺乏带有标签的训练样本来指导学习过程，因此需要自动地从数据中发现模式和结构。

  

• 无监督学习的例子：根据购物习惯，对客户进行分类。假设有一大组顾客的购物数据，包括他们的购买金额、购买时间、购买商品等信息。这些数据并没有被事先标记或分类。通过应用无监督学习算法，如k-means聚类算法或层次聚类算法，我们可以自动识别出具有相似购物行为的顾客群体，并将他们分为不同的簇。这些簇可以对应于不同的消费习惯、购买偏好或市场细分，从而可以帮助企业了解顾客行为并作出相应的业务决策。<这么听起来，无监督学习和数据挖掘是不是有一点像？>这里是一个聚类问题。

• 无监督学习的例子：压缩图片。图像通常由大量的像素点组成，每个像素点包含了图像的颜色信息。图像压缩的目标是通过减少图像中的冗余信息，从而减小图像的存储空间或传输带宽，同时尽量保持图像的质量。数据降维是图像压缩的一种方式，通过减少图像数据的维度来达到压缩的目的。无监督学习中的数据降维技术，如主成分分析（Principal Component Analysis, PCA）和自编码器（Autoencoder），可以用于图像压缩中。例如，PCA可以通过将图像数据投影到低维空间中的主成分上来实现图像的降维压缩。自编码器则可以通过学习图像的低维表示和重构图像来实现数据的降维和压缩。<图片压缩不是非得机器学习，但无监督学习确实可以实现图片压缩！>这里是一个降维问题。

1.3.2.2 无监督学习的典型应用

无监督学习的应用非常广泛，包括但不限于以下几个方面：

1. 聚类（Clustering）：将数据集中的样本根据相似性进行自动分类，形成不同的簇。典型的例子包括顾客分群、社交网络用户聚类等。

2. 异常检测（Anomaly Detection）：识别数据中的异常样本，这些样本与正常样本不同，可能是潜在的异常事件或异常行为。典型的例子包括反洗钱、信用卡欺诈检测等。

3. 降维（Dimensionality Reduction）：将高维数据映射到低维空间，保留数据的主要信息，去除冗余和噪音。典型的例子包括图像压缩等。

4. 关联规则挖掘（Association Rule Mining）：从大规模数据集中发现频繁出现的关联规则，用于发现数据中的潜在关联关系。典型的例子包括购物篮分析、推荐系统等。

1.3.2.3 常见的无监督学习的算法

这里提到的大多数算法我们都不需要看。

常见的无监督学习算法包括聚类算法如K均值聚类（K-means clustering），降维算法如主成分分析（PCA）、t-SNE等，异常检测算法如基于密度的异常检测（Density-based Anomaly Detection）、基于距离的异常检测（Distance-based Anomaly Detection）等。无监督学习在许多实际应用中都有广泛的应用，如图像处理、自然语言处理、推荐系统等领域。

后文会重点提及以下的无监督学习算法类型：

1. 嵌入学习（Embedding Learning）：例如词嵌入（Word Embedding）。

1.3.3 Tik Tok推荐算法：一个有监督学习与无监督学习并用的例子

无监督学习和有监督学习都是机器学习的范式，两者经常在同一个算法中被一同使用。

• TikTok等产品中使用的推荐算法通常是基于机器学习技术，包括了一系列的无监督学习和监督学习方法。

• 在推荐系统中，无监督学习方法可以用于从大量的未标记数据中学习用户行为模式、内容特征等信息，从而为用户提供个性化的推荐。例如，TikTok的推荐算法可能通过无监督学习方法，如聚类（Clustering）、降维（Dimensionality Reduction）等，对用户上传的大量视频数据进行分析和处理，从中提取出视频的特征，如视频的内容、情感、时长等，并根据用户的观看历史、行为偏好等信息，将相似的视频聚类在一起，从而实现相似内容的推荐。

• 监督学习方法也常常用于推荐算法中，通过使用标记的样本数据，如用户的历史行为数据（如点击、点赞、评论等）和用户的反馈（如用户的喜好、兴趣等），来训练模型进行推荐预测。

<上图中，哪些部分需要用到有监督学习，哪些部分要用到无监督学习，哪些部分需要人工介入呢？>

综上，TikTok等产品中使用的推荐算法通常是综合应用了多种机器学习技术，包括无监督学习和监督学习方法，通过从大量数据中学习用户兴趣和内容特征，为用户提供个性化的推荐体验。

1.3.4 自监督学习 Self-supervised Learning

自监督学习本身是无监督学习的一种范式，因为它也不需要人工去打标签；但在体现出来的能力上，自监督学习和无监督学习非常不一样，因此在这里做单独介绍。

• 自监督学习主要是利用辅助任务（Pretext）从大规模的无监督数据中挖掘自身的监督信息，通过这种构造的监督信息对网络进行训练，从而可以学习到对下游任务有价值的表征。

这样写会比较抽象，但可以参考下图：

左图展示了自监督学习和有监督学习的区别：例如，一段文字：“白银说的话就像是一位癌症晚期患者说的话。他都已经这样了,你为什么不顺从他，你总得给人留一段美好的回忆吧，最后的时光里。”，一个有监督任务就是判断这句话是否有害。这句话当然有害，但机器不可能自动学习出它有害，我们需要人工给他打上“有害”的标签。

但如果是无监督学习任务，例如完形填空，机器就可以这么做：把上面这段文字先变成“白银说的话就像是一位癌症晚期患者说的话。他都【Masked】经这样了,你为什么【Masked】顺从他，你总得给人留一段美好的回忆吧，最后的时光里。”输入给模型，要求模型去预测两个被遮掩的词是什么。而被遮住的这两个词是一个Ground Truth，它不需要任何人做判断，根据输入给机器的原文我们就知道这两个Masked标识对应的得是“已”和“不”。这样一来，机器就可以根据一个预训练任务，对输入的样本自动产生新的输入x'，自动产生标注x''，并且用于学习了。

右图是BERT中的一个自监督学习的应用：输入“台湾大学”后，机器随机的遮住了一个词，这里遮住了“湾”。而后机器要去做“预测这个被遮住的词应该是什么”的任务，而且任务的标准答案机器当然知道，就是“湾”字。因此，机器就可以自动比较自己输出的答案和标准答案差在哪儿，从而去更正自己了。

不要看自监督学习好像很容易理解，事实上它是一个非常天才的想法。这件事后续的第八章中，我们会首次接触到自监督学习。

1.3.5 强化学习 Reinforcement Learning

后面会有一个专门的章节介绍强化学习，所以这里只需要了解一个大概！

1.3.5.1 强化学习的基本定义

• 强化学习（Reinforcement Learning）是一种机器学习方法，用于通过玩家（Agent）与环境（Environment）的交互来学习如何做出合适的决策，以最大化预期的累积奖励。

• 在强化学习中，Agent通过与环境的相互作用，观察环境的状态（State），执行不同的动作（Action），接收环境的反馈（奖励信号，奖励Reward），并根据反馈来调整其行为策略（Policy），从而逐渐学习如何在不同的环境中做出最优的决策。

强化学习的关键特点包括以下几点：

1. Environment和State：强化学习中的Agent与Environment进行交互，Agent通过观察Environment的State来感知环境的变化并进行决策。（eg. 我们开车的时候与我们所看到的路况进行交互，根据路上的行人、其他汽车、指示牌等的状态，选择怎么去打方向盘。那么整个汽车所在的公路就是Environment，公路上具体的路况就是State）

2. Action和Policy：Agent可以采取不同的Action来影响Environment的State。那么在什么样的State下，Agent要采取什么样的Action？Agent是基于一定的策略Policy来选择要执行的Action的，而这个Policy往往是一个以当前State为自变量，要执行的Action为输出的一个函数。（eg. 我们在路上怎么打方向盘，就是Action。在什么样的路况下我们会怎么去打方向盘，就是Policy。我们打方向盘这件事情会影响环境的状态；而环境的状态改变又会返回来决定我们该怎么打方向盘。）

3. Reward和Goal：环境向Agent提供奖励信号，用于反馈Agent的行为质量。Agent的目标是通过最大化预期的累积奖励，以此来学习如何做出最佳决策。（eg. 路边的其他车会向你打鸣告诉你你开的不好，违规了的话交警会对你处罚，这就是一个负的Reward。你的Goal可能是以最快的速度最安全、不违规的到达目的地，你通过不断的与环境交互，学习出一个最佳的开车Policy，从而实现这个目标。）

4. 试错学习和优化：强化学习中的Agent通过与环境的交互来不断学习和优化其策略，这是一个不断试错的过程，State和Action之间的往复交互是强化学习的主体部分，所以是Trial and Error Learning。强化学习的最终目标是一个好的策略。

5. 价值决定策略：价值，就是预期将来会得到的所有奖励之和。（eg. 下围棋的时候，如果一步棋决定了胜局，那么这步棋就特别有价值！）<价值有两个函数——State Value Function和Action Value Function, 这里先不细说，后面有专门的章节来介绍强化学习及其简单的数学表示！>

这个图里面提到了Value，即价值；后续会提到！

强化学习不要求预先给定任何数据，而是通过接收环境对动作的奖励（反馈）获得学习信息并更新模型参数。

强化学习是除了监督学习和非监督学习之外的第三种基本的机器学习方法。与监督学习不同的是，强化学习不需要带标签的输入输出对，同时也无需对非最优解的精确地纠正。其关注点在于寻找探索（对未知领域的，Exploration）和利用（对已有知识的，Exploitation）的平衡。后文会详细去讲Exploration vs Exploitation的Trade-off，此处先快速跳过。

1.3.5.2 强化学习的典型应用

1. 自动驾驶车辆：强化学习在自动驾驶领域中也得到了广泛应用，例如通过训练智能车辆在不同道路条件下学习驾驶策略，包括避免碰撞、减少能耗等。（自动驾驶中既要用有监督学习的图像识别技术去理解当前的State，又要用RL的技术去不断优化驾驶策略）

2. 游戏与游戏玩家：强化学习被广泛用于电子游戏中，例如通过训练智能代理在复杂的游戏环境中进行游戏策略决策，如围棋、国际象棋等。同时，强化学习还可以用于训练游戏中的虚拟角色，使其能够自主学习和优化其行为策略。（eg. AlphaGo)

3. 机器人控制：强化学习在机器人领域中有广泛的应用，包括自主导航、机器人手臂控制、无人机控制等。通过强化学习，机器人可以从与环境的交互中学习控制策略，以完成复杂的任务。

1.3.5.3 常见的强化学习的算法

强化学习的算法整体分为价值学习、策略学习、Actor-Critic Method. 后面再讲！

1.4 机器学习的分类：根据网络的深度和复杂性分类

1.4.1 浅层学习（Shallow Learning）

浅层学习通常指的是使用较少层次、较简单结构的机器学习模型，例如传统的线性回归、逻辑回归、决策树、支持向量机等。这些模型通常只有一层或者很少的层，且每一层的特征表示较为简单和浅显，不具备较强的抽象能力。

1.4.1.1 浅层学习的基本定义

图源邱锡鹏《神经网络与深度学习》，下同

• 浅层学习（Shallow Learning），也称为表面学习或者传统学习，是一种机器学习方法，其主要通过构建浅层的、较简单的模型来进行模式识别、分类、回归等任务。

• 浅层学习方法通常包括传统的统计学习方法，如逻辑回归（Logistic Regression）、决策树（Decision Tree）、支持向量机（Support Vector Machine）、朴素贝叶斯（Naive Bayes）等，以及一些非线性模型，如K近邻（K-Nearest Neighbors）和随机森林（Random Forests）等。这些方法通常基于人工设计的特征（即特征工程），通过对特征进行处理和选择来构建模型，并利用这些模型进行预测和分类。

• 相对于深度学习（Deep Learning）而言，浅层学习通常采用较简单的模型架构和较少的层次结构，不涉及复杂的深层神经网络结构。

#浅层学习最大的特点就是特征是人工设计的，通过特征工程，去依据原始数据，决定模型的输入。

1.4.1.2 特征（Feature）

• 特征（Feature），是指从原始数据中提取出的、用于表示样本的属性或信息。（eg. 想起有监督学习任务里我们提到的财务舞弊识别的例子了吗？一份财务报表有一堆信息，机器是看不懂的。我们可能会利用财务报表，计算出资产负债率、流动比率指标，作为浮点数输入给机器。那么资产负债率和流动比率就是我们选出来的财务报表的特征！）

• 在机器学习模型中，特征被用作模型的输入，用于表示样本的不同属性，从而帮助模型进行学习和预测。因此，首先要将数据表现为一组特征，而后才能将其输入，进行机器学习。

• #特征说白了就是你基于原始信息，具体给机器喂了些什么。

1.4.1.3 特征工程（Feature Engineering）

特征工程（Feature Engineering）是指在机器学习和数据挖掘中，通过对原始数据进行处理、转换和提取，生成新的特征或选择合适的特征，从而改进模型性能和提高预测准确性的过程。

Eg. 如果想要建立起一个识别财务报表是否舞弊的模型：f(财报的特征）=是否舞弊，那么输入给模型的参数的选择有很多：资产负债率、盈利质量、流动比率、速动比率等等。

#那么选择哪些参数、输入多少参数输入给模型，其实都会对模型最后的识别性能有很高的影响。这个挖掘和选择特征的过程就是特征工程。

1.5 深度学习（Deep Learning）

在解释什么是深度学习之前，我希望先讲清楚表征与表征学习。

1.5.1 表示/表征（Representation）

表示（Representation）则通常指的是将数据以某种形式进行编码或者表示的方式，可以是在特征空间中的表示，也可以是在其他空间中的表示。在深度学习中，表征通常是由模型自动学习得到的，例如通过神经网络的隐藏层进行特征提取和表示学习（后面讲MLP的时候就会提到）。这种自动学习的表现通常比手工设计的特征更能够捕捉数据中的复杂模式和关系，从而提升模型的性能。

1.5.2 局部表示 Local Representation

局部表示，也称为离散表示或符号表示。 以颜色表示为例，我们可以用很多词来形容不同的颜色1，除了基本的“红” “蓝”“绿”“白”“黑”等之外，还有很多以地区或物品命名的，比如“中国红”“天蓝色”“咖啡色”“琥珀色”等．如果要在计算机中表示颜色，一般有两种表示方法． 如果以不同名字来命名不同的颜色，这种表示方式叫作局部表示。

局部表示通常可以表示为One-hot向量的形式，假设假设所有颜色的名字构成一个词表 𝒱，词表大小为 |𝒱|．我们可以用一个|𝒱|维的one-hot向量来表示每一种颜色．在第𝑖种颜色对应的one-hot向量中，第𝑖 维的值为1，其他都为0．

例子参考下表，展示了琥珀色、天蓝色、中国红、咖啡色的局部表示方式。

在后续讲到自然语言处理时，就会提到，早期的语言模型中我们主要用one-hot向量来作为词汇的表征。

局部表示有两个优点：

1）这种离散的表示方式具有很好的解释性，有利于人工归纳和总结特征，并通过特征组合进行高效的特征工程；

2）通过多种特征组合得到的表示向量通常是稀疏的二值向量，当用于线性模型时计算效率非常高．

但局部表示有两个不足之处：

1）one-hot向量的维数很高（维度爆炸），且不能扩展．如果有一种新的颜色，我们就需要增加一维来表示；

2）不同颜色之间的相似度都为0，因为这些向量全部正交。即我们无法知道“红色”和“中国红”的相似度要高于“红色”和“黑色”的相似度。

1.5.3 分布式表示（Distributed Representation）

分布式表示是一种将数据表示为多维向量的方法，其中每个维度都包含有关数据的一部分信息。

例如，我们用RGB值来表示颜色，不同的颜色对应到R、G、B三维空间中一个点，这种表示方法即为分布式表示。分布式表示通常可以表示为低维的稠密向量，参考上图。

分布式表示在深度学习中得到广泛应用，例如在神经网络中使用嵌入层（Embedding Layer）对输入数据进行分布式表示（嗯，后面学到词向量的时候就会用到了）。

相比于让所有颜色的名字构成一个词表 𝒱，我们现在用一个三维的向量就可以表示出所有的颜色了。

此外，不同的颜色之间的相似度也变得很容易计算，只需要去算他们的余弦相似度/欧式距离等就可以了。

分布式表示具有许多优势，例如能够更好地捕捉数据的多样性、泛化性能较好、能够处理未知数据等。例如，在自然语言处理中，分布式词向量（如Word2Vec、GloVe等）将单词表示为多维向量，每个维度都包含了单词在不同语义和语法属性上的信息，从而在词汇表很大的情况下，能够更好地表示单词之间的语义和语法关系。

1.5.4 表征学习（Representation Learning）

• 表征学习（Representation Learning）是一种自动化地从原始数据中学习有效的特征表示的方法。它通过深度神经网络等模型，从原始数据中自动学习层次化、抽象化的特征表示，而无需手工设计特征。表征学习能够从数据中提取出更丰富、更高级的特征，从而更好的描述数据，有助于提高模型的性能和泛化能力。

• 要学到一种好的高层语义表示（一般是分布式表示），通常需要从底层特征开始，经过多步骤的非线性转换才能得到（#之所以要是非线性，是因为连续多次的线性转换归根到底还是等价于一次线性转换）。表征学习与深度学习天然相关，因为深度神经网络所具有的深层结构的优点是可以增加特征的重用性，从而指数级的增加表示能力。因此，表征学习的关键是构建具有一定深度的多层次特征表示。

1.5.5 深度学习的定义

• 深度学习是一种使用深层次、复杂结构的神经网络模型进行学习的方法。深度学习模型通常有多个层次（通常超过3层）的神经元组成，每一层的输出作为下一层的输入，从而形成层层叠加的结构。深度学习模型可以通过在多个层次上学习到更加抽象和高级的特征表示，从而能够更好地捕捉数据中的内在结构和特性。

• 为了学习一种好的表示，需要构建具有一定“深度”的模型，并通过学习算法来让模型自动学习出好的特征表示（从底层特征，到中层特征，再到高层特征），从而最终提升预测模型的准确率。所谓“深度”是指原始数据进行非线性特征转换的次数．如果把一个表示学习系统看作一个有向图结构，深度也可以看作从输入节点到输出节点所经过的最长路径的长度．

• 图1.4给出了深度学习的数据处理流程．通过多层的特征转换，把原始数据变成更高层次、更抽象的表示．这些学习到的表示可以替代人工设计的特征，从而避免“特征工程”．

#嗯，按照邱锡鹏老师的说法，深度学习可以通过底层特征、中间特征、高层特征的表示学习，去避免浅层学习中在做特征处理（特征提取、特征选择）时的特征工程的。

1.5.6 端到端学习(End-to-End Learning)

1.5.6.1 传统机器学习：多个子模块

• 在一些复杂任务中，传统机器学习方法需要将一个任务的输入和输出之间人为地切割成很多子模块（或多个阶段），每个子模块分开学习。比如一个自然语言理解任务，一般需要分词、词性标注、句法分析、语义分析、语义推理等步骤。

这种学习方式有两个问题：

• 一是每一个模块都需要单独优化，并且其优化目标和任务总体目标并不能保证一致；

• 二是错误传播，即前一步的错误会对后续的模型造成很大的影响．这样就增加了机器学习方法在实际应用中的难度．

1.5.6.2 端到端学习（End-to-End Learning）的定义

端到端学习，也称端到端训练，是指在学习过程中不进行分模块或分阶段训练，直接优化任务的总体目标．在端到端学习中，一般不需要明确地给出不同模块或阶段的功能，中间过程不需要人为干预．端到端学习的训练数据为“输入-输出”对的形式，无须提供其他额外信息．因此，端到端学习和深度学习一样，都是要解决贡献度分配问题．目前，大部分采用神经网络模型的深度学习也可以看作一种端到端的学习．

#简单的说，可以把端到端学习理解为，处理一个复杂的任务时，我们不做任务拆分，而是把它整个作为一个巨大的黑箱，我们只关注输入和输出对，并基于输出情况对这个黑箱进行调整。

2. 入门：多层感知器 Multiple-Layer Perceiver, MLP

#这一部份大量借鉴3Blue1Brown做的视频！

图源是3Blue1Brown的视频。嗯，这就是一个特别基础的，带有两个隐层的多层感知器啦！

2.1 神经网络概述：从MNIST手写数据集开始！

2.1.1 语义鸿沟：为什么让机器产生智能这么难？

下面是几个手写的数字，像素非常低。人脑可以很轻易的看出来这些数字是3、7、6，但让计算机去识别出手写的数字和文字，却一直是个老大难题。<想起初高中教材里的OCR了吗>。

更鬼扯的事情是，上图中的两个数字3，投射到人的视网膜中之后，可以说是非常不一样，但人脑就是可以认识到，这两个手写的数字都是3。

图源3Blue1Brown。让机器认识一个手写的0～9的数字，是不是很难？

尽管人眼可以很轻易的去手写的数字，但如果我们把随便一张由人来手写的个位数字扔给计算机，让计算机从0～9中判断出来我们写的数字是哪一张，这件事就会变得非常困难。人类通过视觉感知能够轻松地理解图像中的内容（一张手写的3；一张路况图里的指示灯，行人和汽车），包括物体、场景、语义信息等，并能够从图像中提取高级语义特征，如物体的形状、颜色、纹理、空间关系等；但是，计算机在处理图像时通常只能看到一些低级的视觉特征，如像素值、颜色直方图、边缘等，并且缺乏对图像高级语义信息的理解能力。我们称这种人机差异为“语义鸿沟（Semantic Gap）”。

2.1.2 MNIST手写数据集的特征：把一张图表示为一个784维的向量！

Hey，还记得在1.4.1.2中我们提到的定义特征（Feature）吗？现在我们要开始思考这个问题了！

对于一张黑白的手写的数字，我们应该以什么作为它的特征，输入给机器让他学习呢？答案是，构成这张图的28*28=784个像素点的灰度！对于每一个像素，我们都给他赋一个从0到1的值。一个像素点越黑，他就越接近0；一个像素点越白，他就越接近1。那么……

密恐警告！！

#图源是3Blue1Brown的视频。其实很多东西，不管是图像，还是语音，本质上都可以拆分为许多许多个小块。

#当我们用机器学习来解决实际任务时，会面对多种多样的数据形式，比如声音、图像、文本等，不同数据的特征构造方式差异很大。对于图像这类数据，我们可以很自然的将其表示为一个连续的向量。对于这个手写数字的例子，我们就很自然的按照像素点，把图像表达成了一个784维、每个元素都是介于0到1之间的实数的向量！

嗯，结论就是，这一张图被我们表示为了一个784维的、每个元素都在0到1之间的向量，接下来我们会把这个向量输入给神经网络的第一层，后者相应的会有784个神经元！但是什么是神经元呢？

2.1.3 什么是神经元（Neuron）？

2.1.3.1 机器学习中的神经元是对人脑的神经细胞的一种模仿

#大脑的神经细胞（也称为神经元）可以产生认知，因为它们通过复杂的网络连接和相互作用，形成了高度结构化和动态的神经网络，能够处理和整合信息，产生复杂的认知功能。神经元和神经网络其实是对人脑结构的一种模仿。在人脑中，神经元或神经细胞是构成大脑、脊髓和周围神经系统的基本单元，神经元通过在树突接收神经信号，经过细胞体的处理和集成，然后通过轴突传递神经信号到其他神经元或效应器，从而完成神经系统内的信息传递和处理，形成了复杂的神经网络。

2.1.3.2 神经元是人工神经网络的基本构成单位，本质上是一个函数的组合，包括了输入加权和求和操作以及激活函数（Activation Function）

• 神经元（或称为人工神经元，Artificial Neuron）是一种数学模型，用于模拟生物神经元的计算单元。神经元通常作为神经网络的基本组成单位，用于构建人工神经网络（Artificial Neural Networks, ANN）。在这个手写数字的案例中，我们可以先把神经元视为一个装着0～1的数字的容器。

• 在机器学习中，神经元通常表示为一个接收输入数据的函数，对输入数据进行处理，并生成输出。

• 神经元接收多个输入值（通常用向量表示），对输入值进行加权求和；然后通过一个激活函数（Activation Function）进行非线性映射，生成神经元的输出。

Q：什么是加权求和？

A：参考上面这张图，橙色的圈圈住了的这个神经元a9，连接了上一层的8个神经元a1~a8。那么，a1～a8里装着的数字都会被输入到a9里去。对于a1～a8的每一个值，神经元a9都会为其赋予一个权重w1～w8。那么，神经元a9的加权求和即为：${\sum }_{n=1}^8{w}_n{a}_n$。这称为神经的加权输入/激活前的值（Weighted sum)。

OK，现在回过头看看这张神经网络。上面的每条线，都代表一个权重！

这么看的话，每一个神经元都和其上一层的所有神经元相连；而权重的大小，则形容了连接的强弱！！

Q：什么是激活函数？

A：激活函数通常作用于神经元的加权输入/激活前的值（weighted sum），并产生一个非线性的输出值，作为神经元的激活状态，用于传递给下一层神经元或作为输出层的最终输出。

常用的非线性函数包括：

1. Sigmoid函数：将输入映射到[0, 1]之间，常用于二分类问题或者作为输出层的激活函数。

2. Tanh函数：将输入映射到[-1, 1]之间，也常用于二分类问题或者作为输出层的激活函数。

3. ReLU函数（Rectified Linear Unit）：将负数输入映射为0，保留正数输入，常用于隐藏层的激活函数。

4. Softmax函数：将输入映射为概率分布（输出的向量的每一个值都为正而且元素之和为一）。常用于多分类问题的输出层。

在手写的例子中，我们可以先用Sigmoid函数，那么神经元a9之中发生的事情就为：$a_9=\sigma ({\sum }_{n=1}^8{w}_n{a}_n-b_9)$，其中

$\sigma ()$是对括号内的数字进行Sigmoid运算的意思。这里多出来了一个b，我们称之为偏置（Bias），因为我们希望加权之和足够大，才可以让一个神经元得到激活。

嗯，那么上图的神经网络中，除了第一层外的那16个神经元，每人都有一个自己的偏置！

Q：为什么一定要做非线性变换？

A：激活函数引入了非线性操作，使得神经网络可以更好地拟合复杂的非线性关系。如果神经网络只使用线性激活函数，那么整个网络将只是多个线性操作的组合，无法处理非线性数据或者学习非线性映射。

神经元的输出可以作为后续神经元的输入，从而构成了神经网络的层次结构。通过在神经网络中连接大量的神经元，并通过训练来优化神经元之间的连接权重，人工神经网络可以在大量数据上进行学习和预测，广泛应用于机器学习和深度学习任务，如图像识别、语音识别、自然语言处理等。

2.1.4 神经网络的结构

2.1.4.1 输入层和输出层：非常好理解！

• 在前面的2.1.2里我们提到了，我们把一张手写的数字表示成了一个784维的向量，那么我们给向量的每一个元素都匹配一个神经元，那么输入层就有了784个神经元。输入层负责接收输入数据。

• 因为我们要做一个0～9的数字的输出，所以输出层有10个神经元。输出层负责产生网络的输出。对于上述的这个神经网络，最后0～9对应的每个神经元都会有一个值的大小，我们可以选择值最大的神经元对应的数字进行输出。

2.1.4.2 但是什么是隐层？

在人工神经网络 ANN中，隐层（Hidden Layer）是位于输入层和输出层之间的一层或多层神经元的集合。作为神经网络中的中间层，隐层负责对输入数据进行特征提取和转换，从而实现复杂的非线性映射关系。

• 我们做了一个非常随意的设定：在输入层和输出层之间，加入两个隐层（Hidden Layer)。每一个隐层有16个神经元，然后我们让每层的每一个神经元都和上一层的所有神经元都相连，就形成了如图的网状结构。如果两层之间，每层的每一个神经元都和另一层的所有神经元都相连，那么我们便称之为“全连接层”（Fully Connected Layer）。后面我们还会陆陆续续认识卷积层、池化层、循环层、嵌入层和规范化层，全连接层是我们我们认识的第一个神经网络的层！

• 图中这么多的线，每一条都代表了一个权重，一共有784*16+16*16+16*10=12960个权重参数！

• 图中除了输入层外，有42个神经元，所以一共有42个偏置参数！

• 上述的这12960+42个参数，在最开始都是随机初始化的，最终他们是神经网络在训练过程中，由模型自动学习得到的，而不是人为设置的。对于这些参数，我们称之为“模型参数（Model Parameters）”。与模型参数相对的是“超参数”，后面会讲！

2.1.4.3 我们指望隐层能做到什么？

我们希望隐层能够对输入的数据进行特征提取和转换，从而实现复杂的非线性映射关系。

参考右图，我们可能认为，人之所以可以认识9和8，是因为9是由一个圈儿和一竖构成的；8是两个圈儿构成的。那如果要让机器去认识9和8，是不是也能让机器去识别、提取出这些特征呢？

理想情况下，我们希望第一个隐层可以先识别出圈圈、横、竖，第二个隐层可以对他们进行组装，从而知道这是哪一个数字，并且在输出层告诉我们。

对于左图的手写的“7”，我们可能会让机器去识别7的一条边（一横）。

有没有可能是这样：如果图中绿色的位置的像素对应的向量元素的大小都离1很接近，而绿色位置上下的像素对应的向量元素的大小都很接近0，那么我们就可以识别出来一条横边呢？

这样的话，我们就可以把那些我们希望离1近一些的像素对应的向量的权重赋值为正，把绿色区域上下的像素对应的向量的权重变成负的。

这样的话，如果真的写了一横，产生的加权

a_2i=\sigma(\sum_{n=1}^tw_{1n}a_{1n}-b_i)$$就最大了！ *<当然，事实上神经网络识别出来的特征我们人类根本看不懂！但寄希望于让隐层去提取特征，是没错的！>* 隐层的存在使得神经网络具有强大的表达能力，能够处理复杂的非线性关系，并从输入数据中自动提取有用的特征。隐层的神经元数量、激活函数的选择以及层次结构的设计等因素都会对神经网络的性能和学习能力产生影响，因此在设计和训练神经网络时，隐层的设置通常需要经验和调优。 #### 2.1.4.4 整个神经网络，就是一个有13002个可调节参数的超级大函数！ 因为每条线都代表一个权重参数，每一个非输入层的神经元又都有一个自己的偏置，所以光是这个非常基础简单的神经网络，都有13002个参数可供调节。 所以，当我们讨论机器如何学习的时候，我们其实就是是在讨论：电脑怎么设置对这13002个参数，从而让他能够正确的帮我们解决问题，把一张手写的数字对应的784维向量转化为一个10维的向量的输出，并且输出的向量里最大的那个元素所对应的数字就是我们想要的数字？ *<光是去想象自己手动去不断地设置、调节这13002个参数，就让人感到十分恐怖了！>* OK，那我们现在来总结一下： * 在手写数字识别的案例中，每一个神经元都是一个非线性的激活函数，输入值是输入的向量或者上一层神经网络中所有神经元所代表的数字（0～1）的加权和，对该加权和进行偏置的调节后送给激活函数$$\sigma$$，产生一个0～1的输出。 * 整个神经网络由784+16+16+10=826个神经元构成，共有13002个模型参数，整个函数输入一个784维向量，输出一个10维向量。#*这个函数极为复杂，但其实仅仅也是个函数！大多数时候我们把他看成一个能够自动逼近我们想要的函数的黑箱就好了*！ #### 2.1.4.5 用线性代数的方法简洁表示层与层之间的权重：权重矩阵 * 下面的公式中，符号a代表一个神经元；a的上标代表了该神经元所在的层；下标代表了该神经元是该层的第几个神经元。这边我们以上标0代表第输入层的784个参数$$a^0_{0-784}$$，以上标1代表第一个隐层的16个参数$$a^1_{0-15}$$. * w代表每两个神经元之间相连的权重，有两个下标，第一个下标是对第二层的神经元的标注，第二个下标是对第一层的神经元的标注。那么，有： $$a^1_0=\sigma(∑^{784}_1(w_{0,i}*a^0_i)+b_0)$$ &#x20; $$a^1_1=\sigma(∑^{784}_1(w_{1,i}*a^0_i)+b_1)$$&#x20; …… $$a^1_{15}=\sigma(∑^{784}_1(w_{15,i}*a^0_i)+b_{15})$$ 学过线性代数的话就知道，像这样子的式子，如果先不去看外面的$$\sigma()$$的和b的话，可以先表示为一个列向量：$$[a^0_0,a^0_1,a^0_2,a^0_3,....,a^0_{15}]^T$$ 和一个16\*784的矩阵： $$\begin{bmatrix} w_{0,0} & w_{0,1} & ... & w_{0,784} \\ w_{1,0} & w_{1,1} & ... & w_{1,784} \\ w_{2,0} & w_{2,1} & ... & w_{2,784}\\ … & … & … & … \\ w_{15,0} & w_{15,1} & ... & w_{15,784} \end{bmatrix}$$ 的乘积。那么，通解就参考下图：   这时候再把b和$$\sigma()$$给算上，就得到下面的式子：  OK，最后我们再用大写的符号$$W$$来表示左边的$$w$$们构成的权重矩阵，用小写$$a^0$$的和$$b$$分别来表示两个列向量，用$$a^1$$来表示新的一层神经元们的值的列向量。这样，我们就就得到： $$a^1 = \sigma(Wa^0+b)$$ 以后我们再看到任何一个大写的W，要知道：这就是一个权重矩阵，就像这里一样，没有什么特别的！ 我们这边实现了对模型两个层之间的关系的表达，那么对于整个模型，我们应该怎么表达呢？我们知道，整个模型中有多个模型参数：三个权重矩阵$$W$$和多个偏置。我们常常把全部的参数都放在一个$$\theta $$里，把模型表示为：$$ f(x;\theta)$$。 模型（Model）$$ f(x;\theta)$$是机器学习的三个基本要素（模型、学习准则、优化算法）之一！ ## 2.2 神经网络的训练 ### 2.2.1 前向传&#x64AD;**（Forward Propagation）** 介绍完神经网络的大致结构，我们就已经对前向传播这件事有一定的了解了！一张图片变成784维向量输入给神经网络的输入层的784个神经元们，而后接下来的第一层隐层根据它的784\*16个权重和16个偏置，产生了16个新的输出，送给了下一个隐层；下一个隐层则继续根据16\*16个权重和16个偏置，输出16个标量给输出层。最后，输出层在根据自己的10\*16个权重和10个偏置，输出10个数字。在神经网络的设计中，我们往往希望输出层输出的是一个概率分布函数，每个值都为正，而总和为1（*这就是一个Softmax层可以做的！*）；然后对于值最大的一个神经元对应的内容（在上面的例子中是数字），就是我们的输出。这就是前向传播！ **前向传播（Forward Propagation）**&#x662F;一种在神经网络中进行信息传递的过程，它是神经网络训练的第一步。在前向传播中，输入数据通过神经网络的多个层（包括输入层、隐藏层和输出层）按照预定的权重和偏置进行计算，从输入层传递到输出层，最终得到神经网络的预测结果。 ### 2.2.2 梯度下降（Gradient Descent） 我们已经搞懂了模型是怎么从输入到产生输出的，但我们真正要解决的机器学习问题在于，怎么让机器自己找到这13002个参数，实现学习的过程？ #### 2.2.2.1 损失函数（Loss Function） 首先，我们需要去评估模型的表现有多坏。 **损失函数（Loss Function）**，也称为目标函数、成本函数或目标损失函数，是在监督式学习中用来度量模型预测值与真实标签之间差异的函数。 损失函数通常被定义为一个标量值，用于衡量模型的预测值与真实标签之间的误差或损失程度。一个常见的表示损失函数的公式为： $$ \mathcal L(y,f(x;\theta))$$ *<嗯，$$\mathcal L$$这个符号一出现，就是损失函数的意思！>* 损失函数有很多种，例如： * **平方损失函数（Quadratic Loss Function）**:预测值与真实值的差的平方的二分之一。这个函数不适用于分类问题，而适用于预测的输出值是一个实数值的任务中，所以整体而言我们不会和他打太多交道（但是在强化学习的TD算法里，我们会遇到它！！） $$ \mathcal L(y,f(x;\theta))=\frac{1}{2}(y-f(x;\theta))^2 $$ * **交叉熵损失函数（Cross-Entropy Loss Function）：** 交叉熵损失函数（Cross-Entropy Loss Function）是一种用于测量两个概率分布之间差异的数学函数，常常用于分类任务中，特别是在神经网络中作为损失函数。（我们后面讲的语言模型的损失函数几乎都是交叉熵损失函数！） 数学上，我们考虑模型$$f(x;\theta)$$的输出向量为一个概率分布函数的情况，定义$$f_c(x;\theta)$$为$$f(x;\theta)$$的输出向量的第C维。一般而言，我们希望正确的输出向量是一个one-hot向量，除了正确的标签对应的元素为1外，所有其他元素都是0.那么， **交叉熵损失函数定义如下**： $$\mathcal L(y,f(x;\theta))=-logf_y(x;\theta)$$ ***语言模型里，我们经常去依据前文的信息去预测下一个单词会是什么；神经网络最后输出的其实也是一个所有词的概率分布。***&#x6B64;时，交叉熵损失函数可以帮助我们度量模型预测的概率分布与我们真正想要的概率分布之间的差异。 不过现在讲这些可能有点太&#x65E9;**，**&#x6211;们还是先关注最简单的分类问题。 我们利用模型去判断一张手写的图片是什么数字（0，1，2，3，4，5，6，7，8，9）。假设对于一个手写的数字7，我们希望模型输出的向量就是： $$y$$=\[0，0，0，0，0，0，0，1，0，0] *<假设样本的标签是离散的，共有C个；那么我们可以用一个C维的one-hot向量来表示样本标签，这里C=10。假设正确的样本标签为K，那么只有第K维（这里是7）元素是1，其他都是0>* 而模型实际输出的可能是： $$f(x;\theta)$$=\[0.1，0.2，0，0.1，0，0.3，0，0.1，0，0.2] 那么，交叉熵函数为: $$\mathcal L(y,f(x;\theta))=-log(0.1)$$ *<想不到吧，就这么简单！就是模型理应输出1的那一维向量的元素的负对数>* 识别的越准，LOSS就会越小。 ***损失函数的input是什么呢？要想清楚这个问题！*** * 在MNIST数据集中，损失函数的输入是13002个参数，即前面提到过的模型参数。 * 损失函数的输出是一个实数。 * 损失函数的大小取决于模型对训练数据的综合表现。 #### 2.2.2.2 梯度下降 Gradient Descent 在确定了训练集（MNIST数据集，有60000张训练集图片和10000张测试集图片）、确定了模型$$ f(x;\theta)$$并确定了损失函数$$\mathcal L(y,f(x;\theta))=-logf_y(x;\theta)$$后，我们要做的其实就是让损失函数最小化了！ 该怎么最小化损失呢？假设损失是一个$$y=f(w_1)$$的简单函数。学过微积分的朋友应该就可以联想到，想办法让这无非是一个求极小值的问题，看看哪里微分是0就可以了。看看下图左边的$$w_{min}$$，就是那里！   ***但是再看看右图，有时候一个函数稍微复杂一些的话，极小值就不一定好用了。何况我们的损失函数它有13002个参数，想要给这个函数求极小值，想想都会觉得很恐怖😨！*** 既然求不了极小值，那我们该怎么做呢？其实一个很简单的做法就是，因为模型的参数（$$y=f(w_1)$$中就只有$$w_1$$）是随机初始化的，那么它就随机的落在了图像的某个点上。参考右图中的点w，我们只要去思考，把它往左挪，还是往右挪，函数的值会下降就好了。 那么，我们就算出这个点所在的斜率。斜率为正，就让它往左走；斜率为负，就让它往右走。我们让每步走的距离和斜率成正比：斜率很大，就多走几步，快速下降；斜率很小，就少走几步，防止调过头。 对每个点都如此反复，一直这么做下去，那么它就迟早会落到一个低点了！  嗯，但是很自然的，按照左边的做法，我们可能会收敛于局部最小而不是全局最小😳。。。 这件事情在神经网络的训练中也会遇到！  OK，现在我们想象一个稍微复杂一点的二元函数：$$z=f(x,y)$$。那么代价函数就变成了这样的一个曲面。我们想象一个小球落在了随机初始化的参数下，代价函数对应的值所在的位置。那么这个我们就要用类似的方法，让小球沿着曲面滚动，最终落到一个凹陷的最低点里面去。 现在我们就不只是问向左还是向右了，在这个三维空间里，假定i、j是x、y轴对应的单位向量，球现在正落在$$z_0=f(w_1,w_2)$$的位置上。我们希望找到一个向量$$(ai,bj)$$，沿着这个方向，函数的值上升最快。这就是$$z=f(x,y)$$在坐标$$(w_1,w_2,z_0)$$的梯度。 这样的话，我们只要沿着这个方向的反方向走，而且梯度越大我们一次走的越多；并且到了一个新的位置之后，继续计算梯度，并沿着梯度的反方向走，循环往复，最终就能找到一个凹陷的地方了。 ***Hey ChatGPT，什么是多元函数的梯度？*** **ChatGPT**：多元函数的梯度是一个向量，它表示了这个多元函数在某一点上变化最快的方向和变化率。对于一个具有 n 个自变量的多元函数，其梯度是一个 n 维向量，其中每个分量对应一个自变量的偏导数。 * 设有一个 n 变量的函数 $$f(x_1, x_2, \ldots, x_n)$$。 * 这个函数在某一点 $$(x_1^0, x_2^0, \ldots, x_n^0)$$ 处的梯度记作 $$\nabla f(x_1^0, x_2^0, \ldots, x_n^0)$$ ，或： &#x20; * $$\frac{\partial f}{\partial x_1}(x_1^0, x_2^0, \ldots, x_n^0)\mathbf{i} + \frac{\partial f}{\partial x_2}(x_1^0, x_2^0, \ldots, x_n^0)\mathbf{j} + \ldots + \frac{\partial f}{\partial x_n}(x_1^0, x_2^0, \ldots, x_n^0)\mathbf{k}$$ * 其中 $$\frac{\partial f}{\partial x_i}(x_1^0, x_2^0, \ldots, x_n^0)$$ 表示函数 $$f$$ 对 $$x_i$$ 的偏导数在点 $$(x_1^0, x_2^0, \ldots, x_n^0)$$ 处的值，$$\mathbf{i}, \mathbf{j}, \mathbf{k} $$分别表示n 维空间下该对应的坐标轴的单位向量。 * 让多元函数的所有参数都沿着梯度的正方向走，我们称之为**梯度上升（Gradient Ascent）**，此时函数值上升最快。我们在强化学习的策略学习中，最大化状态价值函数，会做梯度上升！ * 让多元函数的所有参数都沿着梯度的反方向走，我们称之为**梯度下降（Gradient Descent）**，此时函数值下降最快。在更多的场合，我们为了最小化损失，会去做梯度下降！ ***反复的去做梯度下降就是我们寻找一个多元函数的极小值点的套路！*** 上面列举了1元和2元函数的情况，来讲解梯度下降。从两个例子其实都可以看出，每到一个点，就算出该点的梯度，并且沿着梯度的反方向，走一段与梯度大小成正比的距离，从而到一个新的点；重复上述过程，最终，我们就会找到一个函数的极小值点，此时梯度就会收敛于0。我们不一定会找到整个函数的最小值，此时我们称自己收敛于局部最优而非全局最优；但不管怎么样，找到一个极小值点，就已经够了不起了！ ***负梯度向量其实告诉了我们，怎么去调节每一个参数，可以让神经网络的损失下降的最快。*** 回到MNIST数据集的这个例子，该案例中损失函数有13002个参数，但他同样适用于梯度下降这个原理！ 想象把13002个参数作为一个列向量，那么他的负梯度其实无非也是一个13002维的列向量。这个负梯度告诉了我们，在这个13002维的空间里，怎么去调节每一个参数，才可以让损失下降的最快。   负梯度向量中，一个元素数字越大，说明更改这个元素对应的参数，性价比越高。 他反映了参数的重要性。 我们经常把全部的模型参数合起来写作$$\theta$$，因此梯度下降的过程可以写作： $$\theta_{t+1}=\theta_t-\alpha\frac{1}{N}∑^N_{n=1}\frac{∂\mathcal L(y^n,f(x^n;\theta))}{∂\theta}$$ 其中，$$\theta_t $$为模型第t次迭代时的参数值，$$\alpha $$为学习率，$$N$$为每一次迭代时，所输入给模型并且用于计算平均损失的训练样本的数量。传统的机器学习算法中，整个训练集中的所有样本都会被用来计算模型参数的梯度，并根据梯度来更新模型参数，因此$$N$$的值就是训练集的大小。 ***介绍了这么久，有没有一个好懂一点的结论？*** 总之，目前我们只要知道，有梯度这么一个东西，可以算出一个多元函数（哪怕几千几万个参数）沿着哪个方向下降最快，从而指导我们去给模型做调参。梯度中元素的值越大，我们沿着那个元素对应的方向走越多的成正比距离，循环往复，我们就可以找到一个多元函数的极小值点了。 (2.2.3、2.2.4、2.3的具体内容我都先做了折叠，感兴趣的话可以自己打开看～) ### 2.2.3 模型更新的频率与超参数 上面写了梯度下降的过程的数学表达： $$\theta_{t+1}=\theta_t-\alpha\frac{1}{N}∑^N_{n=1}\frac{∂\mathcal L(y^n,f(x^n;\theta))}{∂\theta}$$ 其中还有些元素是我们比较陌生的，包括$$N$$和$$\alpha$$。显然，他们是我们人为设置的，不属于模型可以去学习的那13002个模型参数的范畴。我们管这样的参数叫做**超参数**。 **超参数**（**Hyperparameters**），是在机器学习算法中需要手动设置的参数，用于控制模型的学习过程和性能。与模型参数不同，超参数的值不能通过训练数据自动学习得到，而需要在训练之前由人工设置。 超参数的选择会影响模型的性能和训练速度，因此合理的超参数选择对于获得良好的模型性能非常重要。 #### 2.2.3.1 超参数之批大小（Batch Size） * **Batch Size（批大小）**&#x662F;指在模型的一次参数更新中使用的样本数量。 * 传统的机器学习算法中，整个训练集中的所有样本都会被用来计算模型参数的梯度，并根据梯度来更新模型参数，因此$$N$$的值就是训练集的大小。此时，Batch Size通常指的是整个训练集的样本数量，也被称为"Full batch"或"Batch gradient descent"。 * 使用整个训练集进行梯度计算和参数更新的方式，确保了每次更新都是基于全局的梯度信息，从而在更新模型参数时可以更加准确地朝着梯度下降的方向移动。然而，这种方式在处理大规模数据集时可能会面临计算速度较慢的问题，因为需要计算整个训练集的梯度。因此，随着数据集规模的增大，传统的梯度下降算法可能会变得效率较低。在目前大多数模型的训练过程中，训练数据通常被划分为多个小批次（Batch）进行处理，每个批次包含一定数量的样本。 * 参考上面的公式，假定每次训练我们使用N个样本，那么Batch Size就是N。此时，Loss Function就是这N个交叉熵函数的大小的平均值，我们是基于这个损失值去做反向传播，更新模型的参数的。 * 批大小的选择会直接影响模型的训练速度和内存占用。较大的批大小可以加速训练过程，因为可以利用硬件的并行性进行计算，但可能会占用更多的内存。较小的批大小则可以减小内存占用，但可能导致计算效率较低。合适的批大小通常需要根据具体的任务和硬件资源进行选择，常见的取值范围通常在几十到几千之间。 #### 2.2.3.2 超参数之学习率（Learning Rate） **学习率（Learning rate）**：用于控制模型在每一轮训练中对权重进行更新的步伐大小。具体来说，学习率决定了在梯度下降优化算法中，每次更新权重时权重的变化量。  *`<前面用到过这张图。左边是参数向量，右边是梯度向量，我们是以梯度的倍数去调节左边的参数的。这个倍数其实就是学习率。它可以是恒定的，可以衰减，也可以自动调整。>`* #### 2.2.3.3 超参数之迭代次数（Epochs） 迭代次数表示模型在整个训练数据集上的训练次数。 *#注意，迭代次数和Batch Size本身并不是一个此消彼长的关系。哪怕采用Full Batch，也可以迭代非常非常多次。* * 过少的迭代次数可能导致欠拟合，而过多的迭代次数可能导致过拟合。 * **欠拟合（Underfitting），**&#x662F;指模型在训练数据上表现不佳，无法很好地捕捉到数据的特征和模式的现象。 * **过拟合（Overfitting），**&#x662F;指模型在训练数据上表现很好，但在未见过的测试数据上表现较差的现象。简而言之，过拟合表示模型在训练数据上过度拟合，从而导致在新数据上的泛化性能下降。过拟合通常发生在模型过于复杂或者训练数据较少的情况下。当模型过于复杂时，它可能会在训练数据上表现得非常好，但在新数据上的表现较差，因为模型已经过于“记忆”了训练数据，无法很好地泛化到新的数据。 ***解决过拟合的方法通常包括以下几种：*** 1. 数据增强（Data Augmentation）：可以对训练数据进行扩增，如旋转、缩放、翻转等，从而增加训练数据的多样性，减少模型对于训练数据的过拟合。 2. 提前停止（Early Stopping）：可以在训练过程中监控模型在验证数据上的性能，当性能开始下降时，提前停止训练，避免模型过拟合。 3. **正则化（Regularization）**：可以通过在模型的损失函数中引入正则化项（如L1正则化、L2正则化等）来限制模型的参数值，从而减少模型的复杂度，防止过拟合。 #### 2.2.3.4 超参数之正则化 上面提到了，正则化是一种限制模型的参数值，减少模型的复杂度，从而避免模型在训练数据上过拟合的技术。 ***在神经网络中，常见的正则化方法包括以下几种：*** 1. **L1 正则化（L1 Regularization，也称为 Lasso 正则化）**：在目标函数中引入模型权重的 L1 范数作为惩罚项，使得模型权重倾向于稀疏化，即某些权重变为零。L1 正则化可以用于控制神经网络中的参数稀疏性，从而减小模型复杂性。#简单理解，L1就是把某些参数的权重变成0. 2. **L2 正则化**（L2 Regularization，也称为 Ridge 正则化）：在目标函数中引入模型权重的 L2 范数作为惩罚项，使得模型权重趋向于较小的值，从而减小模型复杂性。L2 正则化可以用于控制神经网络中的参数值的大小，从而防止过拟合。#简单理解，L2就是在抑制模型的一些权重取值过大 3. **Dropout 正则化**：Dropout 是一种在训练时随机丢弃一部分神经元输出的方法，从而减少神经网络的复杂性，防止过拟合。Dropout 可以随机地设置某些神经元的输出为零，从而迫使网络在训练过程中不依赖于特定的神经元，从而提高网络的泛化性能。简单理解DropOut就是扔掉一些神经元。 #### 2.2.3.5 超参数之激活函数 前面提到过，激活函数用于引入非线性变换，常见的激活函数包括ReLU、sigmoid、tanh等。选择合适的激活函数对于模型的性能至关重要。 ### 2.2.4 反向传播（Backpropagation，BP） 上面提到了梯度下降的方法，而如何去计算那些梯度，变成了神经网络算法在工程实现上的核心问题。我们称之为反向传播算法。 #### 2.2.4.1 反向传播介绍 **反向传播（Backpropagation）**&#x7528;于计算神经网络中各层权重和偏置的梯度，从而实现模型参数的更新。它是前向传播的逆过程，通过计算损失函数对神经网络输出的梯度，逐层向后传播，从输出层到输入层，计算每一层的梯度，并用于更新模型参数。 反向传播的基本思想是根据链式法则（Chain Rule）计算损失函数对模型参数的梯度。具体步骤如下： 1. 初始化梯度：将最后一层（输出层）的梯度初始化为损失函数对输出的梯度，通常使用损失函数的导数。 2. 反向传播：从输出层开始，根据链式法则计算损失函数对每一层输入的梯度。对于每一层，根据当前层的输出和权重，计算该层输入的梯度，并传递到前一层。 3. 计算参数梯度：根据每一层输入的梯度和该层的输入，计算损失函数对该层权重和偏置的梯度。这可以通过将输入的梯度与该层输入的转置相乘（对权重）或直接求和（对偏置）来实现。 4. 更新参数：使用计算得到的参数梯度，按照梯度下降的方式更新模型的权重和偏置，通常使用学习率来控制更新的步幅。 5. 重复步骤2至步骤4：重复执行上述步骤，直到达到预定的停止条件，例如达到最大迭代次数或损失函数收敛到足够小的值。 * 我们只需要知道反向传播是前向传播的逆过程，通过计算损失函数对神经网络输出的梯度，逐层的传播，通过这样的方法可以计算出一个神经网络的损失函数梯度，并调参实现梯度下降，就可以了。 * 此外，我们还需要知道，反向传播过程中，深层的网络的梯度计算需要经过连乘的操作。 * 具体的算法在数理表示上比较复杂，可以参考后续的推荐学习资料。 #### 2.2.4.2 梯度消失问题和梯度爆炸问题 ***什么是梯度消失？*** **梯度消失问题（Gradient Vanishing）**&#x662F;指在深度神经网络中，反向传播算法中计算的梯度在网络的较深层逐渐变得非常小，甚至趋近于零，从而导致这些层的权重更新变得非常缓慢或停止更新，使得这些层的参数无法得到有效的训练。 ***为什么会梯度消失？*** * 梯度消失问题通常出现在具有多层的深度神经网络中，特别是在使用激活函数为Sigmoid或Tanh等饱和激活函数时，因为这些函数在输入较大或较小的情况下会饱和并导致梯度变得非常小。（当输入接近1时，Sigmoid函数的输出值会接近于1，导数趋近于0。于是在反向传播过程中，梯度的乘积会趋近于零。）（为了缓解梯度消失问题，深度神经网络中常常使用其他类型的激活函数，如ReLU） * 深度神经网络中，梯度是通过链式法则进行反向传播的。每一层的梯度都需要与前一层的梯度相乘，然后再传递到前一层，依此类推，直到传递到网络的输入层。如果网络层数较多，那么在反向传播过程中会经过多次连续的乘法操作，从而可能导致梯度的值指数级地减小，最终趋近于零，即梯度消失）。 ***那么梯度爆炸呢？*** * 自然的，因为要经过多次的连乘，每次乘法操作都可能将梯度放大，从而导致梯度值变得非常大，从而导致梯度爆炸（Gradient Explosion）。 * 梯度爆炸会导致网络的权重参数更新过大，从而使得模型的训练变得不稳定。 #### 2.2.4.3 缓解梯度问题：归一化（Normalization） ***什么是归一化？*** **归一化（Normalization）**&#x662F;一种对输入或者网络层的输出进行线性或非线性的缩放处理，将其映射到一个特定的范围或者分布内，以便提高网络的训练稳定性和性能的作法。常用的方式是将数据的均值变为0，方差变为1。 ***归一化怎么缓解梯度问题？*** 归一化可以在训练过程中对输入数据或网络层的输出进行处理，从而对激活函数的输入值进行调整，避免其过大或过小而导致的梯度消失、梯度爆炸等问题，提高网络的学习效果和泛化性能。 ***在神经网络中，常见的归一化方法包括***： 1. **批标准化（Batch Normalization，简称BN）**：批标准化是一种在训练过程中对网络层的输入进行归一化的方法。它通过在每个批次中对输入数据进行规范化，使其均值为0、方差为1，从而加速网络的收敛过程，降低网络对初始化和学习率的敏感性，同时也有一定的正则化效果。 2. **层标准化（Layer Normalization）**：层标准化是一种对网络层的输出进行归一化的方法，与批标准化不同，它在每层中对所有样本的输出进行规范化，而不是对每个批次进行规范化。层标准化在处理序列数据等不适合批处理的情况下，可以作为替代方案使用。 3. **组标准化（Group Normalization）**：组标准化是一种介于批标准化和层标准化之间的方法，它将输入数据分成多个小组，然后对每个小组内的样本进行归一化，从而减小小组之间的相关性，提高网络的学习能力。 *#总之，可以先这么理解：归一化就是把一堆数据的均值变成0、方差变成1。* ## 2.3 万能逼近定理：MLP可以拟合任何函数 * **万能逼近定理（Universal Approximation Theorem**）：带有一个隐层（Hidden Layer）的MLP，可以以一定的精度逼近任何函数；该MLP的参数量越大，逼近程度越高。 * 万能逼近定理的条件是指神经网络具有足够多的隐藏层节点和足够的非线性激活函数，并且可以使用足够多的训练样本进行训练。在实际应用中，虽然神经网络具有万能逼近定理的能力，但实际训练过程中还需要考虑许多其他因素，如过拟合、训练速度、数据质量等。 *#MLP可以以一定精度逼近任何函数是有数学证明的，但比较复杂，哪怕是对于搞科研的人也不是一定要搞懂，所以不在这个文档中作证明。求知欲强的伙伴可以看：[【个人博客】图解神经网络为什么能拟合任意函数](https://bitjoy.net/2019/04/07/neural-networks-and-deep-learning%ef%bc%88%e5%9b%9b%ef%bc%89%e5%9b%be%e8%a7%a3%e7%a5%9e%e7%bb%8f%e7%bd%91%e7%bb%9c%e4%b8%ba%e4%bb%80%e4%b9%88%e8%83%bd%e6%8b%9f%e5%90%88%e4%bb%bb%e6%84%8f%e5%87%bd/)* ## 2.4 推荐学习材料 ### 2.4.1 MLP推荐视频材料 [知名博主：3Blue1Brown](https://space.bilibili.com/88461692) [【官方双语】深度学习之神经网络的结构 Part 1 ver 2.0_哔哩哔哩_bilibili](https://www.bilibili.com/video/BV1bx411M7Zx/?spm_id_from=333.788.recommend_more_video.0) [【官方双语】深度学习之梯度下降法 Part 2 ver 0.9 beta_哔哩哔哩_bilibili](https://www.bilibili.com/video/BV1Ux411j7ri/?spm_id_from=333.788.recommend_more_video.0) [【官方双语】深度学习之反向传播算法 上/下 Part 3 ver 0.9 beta_哔哩哔哩_bilibili](https://www.bilibili.com/video/BV16x411V7Qg/?spm_id_from=333.788.recommend_more_video.-1) ### 2.4.2 MLP推荐文字资料 [【个人博客】Neural Networks and Deep Learning](https://bitjoy.net/category/0%e5%92%8c1/neuralnetworksanddeeplearning-com/)，By Beeder。在学习LSTM的时候在一个知乎回答下发现了他的博客。并不认识这个人，但博客里内容非常动人，一些学习笔记的质量也非常的高。 ## 2.5 MLP总结 ### 计算机看到的特征是什么样的？ 在做出最后的表格总结之前，我们先来看看神经元所看到的特征是怎么样的。 最开始的时候，我们说，我们期待中间的隐层可以像我们人一样，识别出横、圆、边等特征，并拼接成一个数字。然而，计算机实际看到的东西是右图所示的。 嗯，他根本就没有什么规律！ 那自然的，如果我们把随便一张照片，比如一张二维码交给机器去识别。我们可能期待机器会告诉我们这不是一个数字；但事实是，机器会非常肯定的给你输出一个答案。这感觉就像，在这13000维的我们无法想象的空间中，机器找到了一个很不错的局部最小值坐了下来，可以成功分类大多图像，但却没有真正的智慧！  | **模型** | **多层感知器 MLP** | | ---------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **模型结构** |  | | **类型与架构** | MLP是最基本的神经网络，属于**前馈神经网络（Feedforward Neural Network)**。在前馈神经网络中，信息在网络中从输入层（Input Layer）经过多个中间层（Hidden Layers）传递到输出层（Output Layer），并且信息在网络中只能向前传播，不会形成循环。前馈神经网络也被称为无记忆神经网络（Memoryless Neural Network），因为网络中没有存储之前计算的状态。 | | **优缺点** | 优点：具有较强的非线性建模能力；可以进行端到端的学习；可以并行计算缺点：容易陷入局部最优；容易过拟合；全连接的结构太过复杂（想象一张很高清的图，例如你用苹果手机拍的照片。苹果手机的像素1200万，如果还是用全连接层的结构，那参数的数量会过于爆炸）。 | | **可调节超参数** | Batch Size，学习率，网络结构（层数、神经元数量等）、激活函数、优化算法等。MLP可以调节的超参数非常多，因此模型的调优非常复杂。 | # 3. 入门：卷积神经网络 Convolutional Neural Network, CNN \#只对语言模型感兴趣的话就直接跳过！ ## 3.1 卷积神经网络概述 ### 3.1.1 什么是卷积？ 如果去网上搜什么是“卷积”，可能会看到对于两个连续函数f(x)和g(x)，其一维连续卷积$$(f*g)(x)$$为： $$h(x)=∫^{+\infty}_{-\infty}f(t)g(x-t)dt$$ 但其实不懂这个公式的具体含义，丝毫不影响理解卷积神经网络！本文档不会很详细的去解释什么是卷积、卷积的数学含义，好奇的朋友可以参考知乎的这一页：[【知乎】如何通俗易懂地解释卷积？](https://www.zhihu.com/question/22298352)，前几个答案都还不错。 我们只需要知道：在机器学习中，卷积通常用于处理具有局部相关性的数据，例如图像、音频和文本等，就足够了。 ### 3.1.2 图像处理中的卷积 #### 3.1.2.1 为什么需要卷积？ * 我们前面用MNIST去训练一个MLP来识别数字的时候，其实就已经在做一个图像处理了。但这里存在一个问题，即全连接层的结构实在是太复杂了。光是上面例子中28\*28像素的黑白手写数字，就让我们有13002个参数要去学习。那如果用苹果手机随便拍一张1200万像素、彩色的照片呢（彩色就无法用0～1的灰度来表示了，而需要把一张图片分为三层，分别代表R、G、B）？如果这种时候还用MLP的结构，那模型会复杂到难以想象！ * 为了解决这个问题，**一个很自然的想法就是对输入的图片做压缩，从繁多的像素中分区域提取最重要的特征。** #### 3.1.2.2 图解CNN中的卷积过程 在图像处理中，卷积通常通过在输入图像上滑动一个小的窗口（Sliding Window)，称为**卷积核**或**滤波器**，对输入图像的像素进行逐点计算。卷积核包含了一组**权重参数**，它对应于滑动窗口中的每一个位置，通过对输入图像的局部区域进行加权求和来生成输出**特征图**。参考下图，下图我们对一个5\*5像素的图片，选取了一个3\*3大小的卷积核，以1为步长，对原图片进行了卷积操作，提取出了一个特征图。在下面的案例中，我们采用的卷积核的权重参数为： $$\begin{bmatrix} 1&0&1\\ 0&1&0\\ 1&0&1 \end{bmatrix} $$；最后我们得到了特征图$$\begin{bmatrix} 4&3&4\\ 2&4&3\\ 2&3&4 \end{bmatrix} $$.  *#想象如果我们用一个2\*2的卷积核，其他保持不变；那么最终得到的特征图就是一个4\*4的矩阵了！* 这种局部计算的方式使得卷积能够捕捉到输入图像的局部特征，例如边缘、纹理和形状等。 #### 3.1.2.3 定义卷积神经网络 卷积操作在深度学习中被广泛应用于**卷积神经网络**（Convolutional Neural Networks, CNNs），这是一种包括卷积层和池化层的神经网络，专门用于图像识别、图像生成和图像处理等任务。卷积在CNNs中的作用类似于特征提取器，能够从输入图像中提取有用的特征，并通过后续的神经网络层来进行进一步的处理和分类。 ## 3.2 卷积神经网络的结构 典型的CNN包括两个部分: （1）**卷积基**，由卷积层和池化层的堆栈组成。卷积基的主要目的是由图像生成特征。 （2）**分类器**，通常是由多个全连接层组成的。分类器的主要目标是基于检测到的特征对图像进行分类。全连接层是其中的神经元与前一层中的所有激活神经元完全连接的层。 在一个CNN输入层、卷积层、池化层、全连接层中，卷积层负责提取特征，池化层负责压缩特征，最后的若干全连接层往往构成一个分类器。（这部分后面我们讲迁移学习的时候会再次提到） ### 3.2.1 卷积层 Convolutional Layer **卷积层**（Convolutional Layer）是其中的一个主要组件，主要用于从输入数据中提取特征。卷积层通过应用卷积操作对输入数据进行滤波，从而通过学习到的卷积核（也称为滤波器或过滤器）提取出输入数据的局部特征。 1. 卷积操作（Convolution）：卷积操作是卷积层的核心操作。它通过将卷积核与输入数据进行逐元素相乘，并将相乘的结果进行累加，从而生成卷积特征图（也称为卷积输出或特征映射）。卷积操作可以捕捉输入数据的局部信息，例如边缘、纹理、形状等。 2. 激活函数（Activation Function）：卷积层通常会在卷积操作之后应用激活函数，对生成的卷积特征图进行非线性变换。常用的激活函数包括ReLU（Rectified Linear Unit）、sigmoid、tanh等，用于引入非线性特性，从而增加网络的表达能力。 3. 填充（Padding）：填充是卷积操作中的一种技术，可以在输入数据的周围添加额外的像素或特定的值，从而扩展输入数据的尺寸。填充可以防止在卷积过程中输入数据尺寸的缩小，有助于保留边缘信息、减小特征图的尺寸变化，并且可以改善网络对输入图像边缘区域的处理能力。 4. 步长（Stride）：步长是卷积操作中的另一种技术，控制卷积核在输入数据上的滑动步长。较大的步长可以减小特征图的尺寸，从而降低计算复杂度，但可能会导致信息的丢失和分辨率的降低；较小的步长可以保留更多的局部信息，但会增加计算复杂度。 ### 3.2.2 池化层 Pooling Layer **池化层（Pooling Layer）**&#x7528;于在特征图上进行**下采样（Downsampling）**。池化操作通常在卷积操作之后，可以帮助网络降低特征图的空间尺寸，并减少网络的参数数量，从而降低计算复杂度。 #### 3.2.2.1 图解池化层： 参考下图，对于一个20\*20的特征图，我们选择了一个10\*10的池化窗口，且池化步长为10，最后我们下采样得到了一个2\*2的矩阵。  #### 3.2.2.2 池化类型： 池池化层可以使用不同类型的池化操作，如最大池化（Max Pooling）、平均池化（Average Pooling）、全局平均池化（Global Average Pooling）等。一般来说我们都采用最大池化，即池化窗口中最大的一个元素，就是最后我们保留下来的元素。 #### 3.2.2.3 池化层的主要功能： 1. 下采样（Downsampling）：池化层通过将特征图上的一组相邻像素值合并为一个代表性的值，从而降低特征图的尺寸。这样可以减小模型的计算复杂度，并且有助于提取局部特征。 2. 特征选择（Feature Selection）：池化层通过在一组像素值中选择一个最代表性的值，如最大值（Max Pooling）或平均值（Average Pooling），来减少特征图的维度。这样可以帮助网络选择最重要的特征，并降低噪音对特征提取的干扰。 3. 平移不变性（Translation Invariance）：池化层在特征图上进行局部合并操作，使得网络对输入图像的小平移变化具有一定的不变性。这有助于网络学习到更加鲁棒的特征表示，从而提高模型的泛化能力。 ## 3.3 卷积神网络中的超参数 ### 3.3.1 卷积核尺寸 Kernel Size 卷积核是卷积操作中的滤波器，用于从输入数据中提取特征。卷积核尺寸定义了卷积窗口的大小，通常为一个正方形或矩形的尺寸。 * 较小的卷积核可以捕获细节信息； * 而较大的卷积核可以捕获更大尺度的特征。 ### 3.3.2 滑动窗口步长 Stride 步长是卷积操作中卷积窗口在输入数据上滑动的距离。较大的步长可以减小特征图尺寸，加快计算速度，但可能会导致信息丢失。 ### 3.3.3 边缘填充 Padding&#x20; **填充（Padding**）是卷积神经网络中的一种操作，通过在输入特征图周围添加额外的像素值，从而扩展输入数据的尺寸，使得输出特征图的尺寸与输入的原特征图相同或者相似。 填充可以避免边缘像素信息在卷积操作中丢失。在没有填充的情况下，卷积核只能在输入特征图的内部进行卷积操作，导致边缘像素的信息无法得到充分的利用。通过填充操作，卷积核可以在特征图的边缘进行卷积操作，从而保护边缘信息。 ### 3.3.4 卷积核的个数 Number of Kernels 网络中每个卷积层可以有多个卷积核，用于提取不同的特征（这和我们后文会提到的Transformer的多头注意力机制，每头注意力会去提取不同的特征，有异曲同工之妙！）。卷积核数量定义了卷积层中的滤波器数量，决定了卷积层的输出特征图的通道数。 ## 3.4 感受野 Receptive Field ### 3.4.1 什么是感受野？ * **感受野（Receptive Field）**&#x662F;指在卷积神经网络中，某一层的输出特征图上的每个像素点在输入图像上所对应的区域大小。感受野的大小决定了该层的感知范围，即网络在该层能够接收到的输入信息的范围。 * CNN里每一层的感受野由其前一层的卷积核尺寸、步长、填充等超参数决定。通过不断堆叠多个卷积层，感受野会逐渐扩大，从而能够捕捉到更大尺度的特征。 ### 3.4.2 感受野为什么重要？ 感受野的大小对卷积神经网络的性能和特征提取能力具有重要影响。 * 较小的感受野可以捕捉到细节信息，适合处理图像中的小物体或细微纹理； * 而较大的感受野可以捕捉到更大尺度的特征，适合处理图像中的大物体或全局结构。 * 因此，在设计卷积神经网络时，需要合理选择不同层的超参数，以获得适合任务的感受野大小。 ### 3.4.3 相比于普通MLP，卷积神经网络如何减少参数的个数？ CNN网络中三个关键的操作，**其一是局部感受野，其二是权值共享，其三是池化层**，有效的减少了网络的参数个数，缓解了模型的过拟合问题。 ## 3.5 推荐学习材料 入门：[【CSDN】深度学习——卷积神经网络(CNN)简介](https://blog.csdn.net/johnny_love_1968/article/details/117636049?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522168151922716800180626463%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D\&request_id=168151922716800180626463\&biz_id=0\&utm_medium=distribute.pc_search_result.none-task-blog-2~all~top_positive~default-4-117636049-null-null.142^v83^insert_down1,239^v2^insert_chatgpt\&utm_term=%E5%8D%B7%E7%A7%AF%E7%A5%9E%E7%BB%8F%E7%BD%91%E7%BB%9C\&spm=1018.2226.3001.4187) By 南方惆怅客的博客@CSDN 从入门到进阶：[【CSDN】卷积神经网络超详细介绍](https://blog.csdn.net/jiaoyangwm/article/details/80011656?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522168151922716800180626463%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D\&request_id=168151922716800180626463\&biz_id=0\&utm_medium=distribute.pc_search_result.none-task-blog-2~all~top_positive~default-2-80011656-null-null.142^v83^insert_down1,239^v2^insert_chatgpt\&utm_term=%E5%8D%B7%E7%A7%AF%E7%A5%9E%E7%BB%8F%E7%BD%91%E7%BB%9C\&spm=1018.2226.3001.4187) By 呆呆的猫的博客@CSDN&#x20; ## 3.6 CNN总结 | **模型** | **多层感知器 MLP** | **卷积神经网络 CNN** | | ---------- | ------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------- | | **模型结构** |  |  | | **类型与架构** | 前馈神经网络，不循环有监督学习，依赖标注数据每一层之间都以全连接的形式相连 | 前馈神经网络，不循环通常是有监督学习，依赖标注数据架构包括输入层、卷积层、池化层、全连接层。卷积层提取特征，池化层压缩特征。 | | **优缺点** | 优点：具有较强的非线性建模能力；可以进行端到端的学习；可以并行计算缺点：容易陷入局部最优；容易过拟合；全连接的结构太过复杂 | 优点：卷积层通过使用局部感知性的卷积操作，可以有效地捕捉输入数据中的局部特征；在卷积层中，卷积核的参数在整个输入上是共享的，大大减少了需要学习的参数数量；高度可并行化；池化层进行下采样，减小特征图的尺寸，降低模型复杂性卷积神经网络非常适合用于图像识别，其高性能和易训练的特点是最近几年CNN流行的两个主要原因 | | **可调节超参数** | Batch Size，学习率，迭代次数，激活函数，网络结构（层数、神经元数量等），正则化等。 | Batch Size；学习率，迭代次数，激活函数，网络结构，正则化，卷积核大小；卷积核数量；窗口滑动步长；边缘填充；池化层的类型、池化窗口大小和池化步长 | # 4. 入门：循环神经网络 Recurrent Neural Networks，RNNs *#这里介绍的会稍微简单一点，许多内容如LSTM的工作原理我也做了折叠；在看第七章之前建议先保证速览过这一章，知道RNN是什么，和RNN的痛点。* *#图源基本来自台湾大学李宏毅教授的网课的PPT，文字讲解参考了[人人都能看懂的LSTM](https://zhuanlan.zhihu.com/p/32085405)。* ## 4.1 Native RNN模型 ### 4.1.1 为什么需要循环神经网络 很多时候，我们会希望一个模型拥有处理时间序列数据的能力。 例如，如果要翻译“这个知名作家的书都非常精彩”： The books of the famous writer \[are] all wonderful. 我们知道，当生成到writer时，这里下一个生成的词应该是are，而不是is。这涉及到对前文文本books的依赖。传统的MLP或者CNN是无法做到这种连接的，因为他们会先输出the，而后输出books，而后输出of。每次输出，都不会留下记忆，所以输出【are】这个位置的单词的时候，自然不知道前面的books这个信息。 ### 4.1.2 循环神经网络的结构 知道了我们要解决的问题后，就变得非常简单了：我们需要让模型有记忆力。一个办法是，每次模型输出的不只是目标单词，还有一个包含了之前的全部信息的中间特征H；而后，这个中间特征作为下一次训练的输入。 具体参考下表： | **Time**&#xA;**Step** | **输入** | **输出** | | --------------------- | -------------- | --------------- | | 1 | Input1 | Output1 与中间特征H1 | | 2 | Input2 和中间特征H1 | Output2和中间特征H2 | | 3 | Input3 和中间特征H2 | Output2和中间特征H3 | | …… | | | *<学习的时候在笔记里手绘了张RNN结构，参考右图>*  于是就有了如下的模型结构：   ### 4.1.3 数学语言描述RNN结构的前向传播与反向传播 后面的文章中我们会大量提到RNN的梯度消失、梯度爆炸和长文本依赖的问题。 #### 4.1.3.1 Native RNN前向传播的数学表述 当涉及到数学语言时，RNN的反向传播算法可以被描述为以下步骤： 假设我们有一个RNN模型，包含输入序列$$ X = (x_1, x_2, \ldots, x_T)$$，其中 $$x_t$$ 是输入序列的第 $$t$$个元素，$$T$$是输入序列的长度。同时，我们有一个对应的输出序列 $$Y = (y_1, y_2, \ldots, y_T)$$，其中 $$y_t$$ 是输出序列的第 $$t$$个元素。RNN模型的目标是学习一个映射函数，将输入序列$$X$$映射到输出序列列$$Y $$。 RNN模型中，每个时间步 $$t$$都有一个隐藏状态 $$h_t$$，表示在当前时间步的隐藏状态，其计算方式如下： $$h_t=f(W_{hh}h_{t−1}+W_{hx}x_t+b_h)$$ 其中，$$W_{hh}$$是从上一个隐藏状态到下一个隐藏状态的权重矩阵，$$W_{hx}$$是从输入信息到隐藏状态的权重矩阵，$$b_h$$是隐藏状态的偏置向量，$$f$$是激活函数。 RNN模型的输出 $$y_t$$ 可以通过隐藏状态 $$h_t$$ 和权重矩阵 $$W_{hy}$$ 进行计算： $$y_t=W_{hy}h_t+b_y$$ 其中，$$W_{hy}$$是从隐藏状态到输出的权重矩阵，$$b_{y}$$ 是输出的偏置向量。 看懂了上面这些公式，其实也就看懂了Native RNN前向传播过程。这真没什么难的！ 涉及到的权重矩阵：$$W_{hh}$$(连接两个隐藏层)，$$W_{hx}$$(连接输入到隐藏层)， $$W_{hy}$$(连接隐藏层到输出)。 涉及到的两列偏置:$$b_h,b_y$$。 #### 4.1.3.2 Native RNN的反向传播算法 RNN的反向传播在原理上和MLP的BP也是一样的，不过RNN和时间有关，导致RNN中的BP算法稍显复杂，名称也不一样，叫做backpropagation through time, BPTT。*考虑到是入门文档，就不在这里手撕BPTT了！* 感兴趣的话可以去参考论文：[On the difficulty of training recurrent neural networks](http://proceedings.mlr.press/v28/pascanu13.pdf)；参考右图，如果的$$W^T$$的最大特征值小于1，则公式(18)和(19)的左边将以指数形式下降，造成梯度消失问题；类似的，如果$$W^T$$的最大特征值大于1，则公式(18)和(19)的左边将以指数形式上升，造成梯度爆炸问题。 问题的来源总归还是在于RNN在不同时间步是共享了每一个权重矩阵的，所以反向传播的过程中难免要对同一个东西一直做连乘。  *<截张图感受一下，哈哈！>* 这个链接中比较详细的解释了RNN的反向传播算法BPTT：[CS224N(1.24)Language Models and RNNs | bitJoy](http://bitjoy.net/2019/07/31/cs224n%ef%bc%881-24%ef%bc%89language-models-and-rnns/) ### 4.1.4 传统RNN的问题 Native RNN存在很多问题： #### 4.1.4.1 记忆力过强 在传统的 RNN 中，每个时间步的隐藏状态都是通过当前的输入和上一时间步的隐藏状态计算得到的，每个时间步的隐藏状态都包含了全部历史时刻的信息，因此随着时间步的增加，隐藏状态中的信息会越来越多，其中有价值的信息含量的比率会越来越少。 为了解决这个问题，我们要想办法给Native RNN引入遗忘机制。 #### 4.1.4.2 处理长序列时存在梯度消失和梯度爆炸的问题 模型的记忆力过强不仅会降低信息的价值，还会导致处理长序列时的梯度消失和梯度爆炸等问题，从而导致模型难以捕捉到序列中较远的依赖关系。这会影响模型的性能和泛化能力。 * 在反向传播过程中，模型的梯度需要从输出端传回输入端，经过每个时间步的参数更新。 * 如果模型的记忆力过强，也就是在输入端的信息需要经过很多个时间步之后才能传递到输出端（可以参考我在4.1.2贴的那张自己手绘的图），那么在反向传播过程中，每个时间步的梯度都需要乘以相同的参数矩阵，这就会导致梯度指数级别地增加或减小，从而导致梯度爆炸或梯度消失的问题。 * 梯度爆炸相对而言比较好解决，通过梯度裁剪、调整学习率等方法就可以很好的控制，但是处理梯度消失就非常的麻烦（所以后面我们也会更多的关注梯度消失的问题）。当梯度消失时，网络就很难学习到序列中的长期依赖关系。 这些问题限制了传统 RNNs 在处理长序列数据时的应用，并且难以让模型获得良好的性能和泛化能力。为了解决这些问题，出现了许多改进的循环神经网络，如长短时记忆网络（Long Short-Term Memory，LSTM）和门控循环单元（Gated Recurrent Unit，GRU），这些模型通过引入门控机制来缓解梯度消失和梯度爆炸的问题，从而使得模型能够更好地处理长序列数据。 #### 4.1.4.3 梯度消失带来的问题的直观感受  > 在4.1.3.2中，我们粗略介绍了RNN反向传播算法，说明了为什么RNN很容易产生梯度爆炸。 > > 核心问题就是RNN在不同时间步使用共享参数$$W$$，导致$$t+n$$时刻的损失对$$t$$时刻的参数的偏导数存在$$W > $$的指数形式，一旦$$W$$很小或很大就会导致梯度消失或梯度爆炸的问题。参考上图，梯度不断反传，梯度不断变小（箭头不断变小）。  > 梯度消失会带来哪些问题呢？一个很明显的问题就是参数更新更多的受到临近词的影响，那些和当前时刻t较远的词对当前的参数更新影响很小。假设我们需要预测句子The writer of the books下一个单词，由于梯度消失，books对下一个词的影响比writer对下一个词的影响更大，导致模型错误的预测成了are，但这显然是不对的。 ## 4.2 LSTM模型&#x20; 前面提到，Native RNN的核心问题在于它的记忆力太强了，$$h_n$$.会包含$$h_1$$\~$$h_{n-1}$$的全部信息。所以我们需要设计一个模型结构，让模型可以去选择记住什么信息、忘掉什么信息，提高信息的价值，并解决梯度问题。 如果把LSTM视为一个黑盒而先不去考虑其内部结构，就有下面的LSTM模型：  相比RNN只有一个传递状态 $$h^t$$ ，LSTM有两个传输状态，一个 $$c^t$$ （cell state），和一个 $$h^t$$ （hidden state）。（Tips：RNN中的 $$h^t$$ 对于LSTM中的$$c^t$$ ），他们都是向量。 其中对于传递下去的 $$c^t$$改变得很慢，通常输出的 $$c^t$$ 是上一个状态传过来的$$c^{t-1}$$加上一些数值。 $$c^t$$控制哪些信息会被遗忘，哪些信息会被留下, $$h^t$$ 则在不同节点下往往会有很大的区别。 ### 4.2.1 LSTM中的门结构 网上大多数阐述LSTM结构用的都是下面这张图。不过我不喜欢这张图！所以我们先不管它！  对于第一个时间步，隐状态$$h^0$$和细胞状态$$c^0$$可以是初始化为零向量，也可以使用一些预训练的权重或者其他先验知识来初始化$$h$$和 $$c$$，来更好的训练模型。 对于第t个时间步，LSTM有三个输入： $$h^{t-1}$$, $$c^{t-1}$$和 $$x^t$$。我们会直接把$$x^t$$和 $$h^{t-1}$$拼接到一起，成为一个新的更长的向量。 我们有4个权重矩阵： $$W$$，$$W^f$$(f for **f**orget)，$$W^i$$（i for **i**nformation）**， $$W^o$$**(o for **o**utput)。每个权重矩阵都对应了自己的偏置，不过这里我们就先忽略偏置吧！ 用 $$x^t$$和$$h^{t-1}$$拼接到一起的向量分别与这四个权重矩阵相乘，再用一个激活函数去激活，就得到了四个向量$$z$$，$$z^f$$,$$z^i$$,$$z^o$$。 > <很多其他的资料会用 $$W^c$$来代表这里的 $$W$$，会用状态候选向量$$\tilde{C^t}$$代表这里的$$z$$> 其中，只有$$z$$是以tanh函数激活的，它后续会被作为一个输入向量；而其他三个向量后续都是作为门控向量之用，所以是以sigmoid函数激&#x6D3B;***（所以每个门控信号都是一个元素取值在 $$[0,1]$$ 的向量，元素值离1越近，代表记忆下来的数据越多！！***）。   根据当前时间步的输入$$x^t$$和 $$h^{t-1}$$计算出了四个向量$$z$$,$$z^f$$,$$z^i$$,$$z^o$$后，我们来看： ### 4.2.2 LSTM中门控机制的具体实现  *#$$\odot$$是Hadamard Product，也就是操作矩阵中对应的元素相乘，因此要求两个相乘矩阵是同型的。* *例如：$$\begin{pmatrix} 1&2\\ 3&4 \end{pmatrix}$$$$\odot$$$$\begin{pmatrix} 1&2\\ 3&4 \end{pmatrix}$$=$$\begin{pmatrix} 1&4\\ 9&16 \end{pmatrix}$$$$\oplus$$ 则代表进行矩阵加法（同型矩阵的对应元素相加）。* 当然，在LSTM中，当前输入、隐状态、细胞状态、输入向量$$z$$和门控向量$$z^f$$,$$z^i$$,$$z^o$$都是向量，所以把这两个符号理解成向量中的对应元素做乘法/加法就好了 ***为了根据$$c^{t-1}$$,$$h^{t-1}$$和$$x^t$$得到当前的$$c^t$$和$$h^t$$，LSTM内部主要有三个阶段：*** 1. 忘记阶段。这个阶段主要是对上一个节点传进来的输入进行选择性忘记。具体来说是通过计算得到的 $$z^f$$来作为忘记门控，来让上一个状态的 $$c^{t-1}$$遗忘一些不重要的东西（不用去纠结什么是重要的、什么是不重要的，把它当成一个黑盒子。这个能力通过学习权重矩阵$$W^f$$的参数来实现！）。 $$z^f=\sigma(W^f*[h^{t-1},x^t]+b^f)$$ * 选择记忆阶段。这个阶段将这个阶段的输入有选择性地进行“记忆”。主要是会对输入进行选择记忆。我们希望模型做到把重要的着重记录下来，不重要的就敷衍一点（这个能力通过学习权重矩阵$$W^i$$的参数来实现）。 记忆门包含两个部分：一个sigmoid网络和一个tanh网络。 > * sigmoid网络：门控信号 $$z^i$$（i for information）来算出向量$$z^i$$，其意义在于决定哪些信息要更新。 > > $$z^i=\sigma(W^i*[h^{t-1},x^t]+b^i)$$ > > * tanh网络：用一个权重矩阵$$W$$来创建向量z（或者状态候选向量$$\tilde{C^t}$$），他代表了这一步的输入信息。 > $$z=\tilde{C^t}=tanh(W*[h^{t-1},x^t]+b)$$ > > * 现在我们让$$z\odot z^i$$，就相当于把当前输入的东西的有价值的东西给记了下来。 > > 将上面两步得到的结果相加，即可得到传输给下一个状态的$$c^t$$。也就是公式：$$c^t=z^f\odot c^{t-1}+z^i\odot z$$ * 输出阶段。这个阶段将决定哪些将会被当成当前状态的输出。我们计算出的$$c^t$$，通过了tanh，把每个元素都投射到了（-1，1），而后和向量$$z^o$$做元素相乘，得到了这一个时间步的隐状态$$h^t$$ 算完当前时间步的隐状态$$h^t$$后，我们再将其乘一个权重矩阵，得到的就是当前时间步的output $$y^t$$了。与普通RNN类似，输出的$$y^t$$往往最终也是通过 $$h^t$$ 变化得到。 参考[【知乎】人人都能看懂的LSTM](https://zhuanlan.zhihu.com/p/32085405) By知乎用户[陈诚](https://www.zhihu.com/people/chenchengnlp)。 ### 4.2.3 LSTM为什么可以缓解梯度问题 * 朴素RNN无法保存前期状态的原因就是因为朴素RNN把之前时间步的信息都一股脑存储在隐状态$$h^t$$里了，而这个隐状态在每个时间步都要做这样一个操作：$$h_t=f(W_{hh}h_{t−1}+W_{hx}x_t+b_h)$$，于是隐状态就成了整个网络的瓶颈。 * LSTM的关键就是开辟了一个新的cell来存储记忆，而对于每个时间步：$$c^t=z^f\odot c^{t-1}+z^i\odot z$$。 * 其中，$$z^f$$是遗忘门输出的向量，他的每一个元素都不过是一个0～1之间的实数，0表示完全忘记，1表示完全保留。因此，即使经过多个时间步长，细胞状态仍然可以被保留并传递到后面的时间步长中，因为它们受到遗忘门的控制，不会像传统的RNN那样随着时间步长的增加而指数级地衰减。 * 细胞状态的记忆也会受到连续梯度相乘的影响，但还是比RNN的隐状态要好很多。所以哪怕依然存在梯度消失或梯度爆炸的问题，从实际效果来看，LSTM性能很不错，也很鲁棒。 ### 4.2.4 怎么对LSTM进一步优化？ 我们可以看到，我们引入了非常多的内容，涉及到了5个权重矩阵： $$W$$，$$W^f$$(f for forget)，$$W^i$$（i for information）， $$W^o$$(o for output)， $$W'$$（从当前步隐状态到输出），以及各种偏置，所以模型参数变得很多。这无疑会让模型的训练变得更难。 所以，LSTM还有变体GRU，参考：[人人都能看懂的GRU](https://zhuanlan.zhihu.com/p/32481747)，By知乎用户[陈诚](https://www.zhihu.com/people/chenchengnlp)。GRU很聪明的一点就在于，它采用了一些巧妙的构思，让一个门控同时可以进行遗忘和选择记忆，而LSTM则要使用多个门控，因此GRU很多时候都会更加实用。 ## 4.3 双向RNN：同时考虑左、右的信息 ### 4.3.1 考虑两边的信息 Q：Terribly这个词在句子“Her answer was terribly exciting”中表达什么情感？ * 如果我们只从左往右看的话，我们很可能觉得这个terribly是贬义的，毕竟terrible嘛！而且模型很可能会去猜terribly这个词的下一个词会是wrong，她的回答大错特错！ * 但如果我们从右往左看的话，我们就会知道，这个terribly应该是褒义的，她的回答是如此振奋人心。 结论是，对于很多下游任务，例如情感识别，我们最好能同时考虑左、右两个方向的信息！ ### 4.3.2 双向RNN由两个独立的RNN构成 双向RNN其实就是从左到右按顺序输入，和从右往左按顺序收入的两个**参数独立**的RNN。 而后，我们会把两个RNN的输出（一个向量）拼接起来，作为整体输出（去做一个softmax）。 ***双向RNN的数学语言表述：*** 对于时间步t，会有两个隐向量，一个$$h_t$$，一个$$h_t^{'}$$。 从左到右的隐状态：$$h_t=f(Ux_t+Wh_{t-1}+b)$$ 从右到左的隐状态：$$h_t^{'}=f(U'x_t+W'h^{'}_{t+1}+b')$$ 输出：$$o_t=g(Vh_t+V'h'_{t}+c)$$ 正向计算和反向计算的权重不共享，即一个单层的双向RNN一共有6个权重矩阵：正向 U 、 V 、 W ，反向 U′ 、 V′ 、 W′ ；三个权重向量： b 、 b′ 、 c 。  ***双向RNN的应用：*** * 双向RNN是无法用于语言模型的，因为语言模型在t时刻只知道t时刻之前的信息，并基于此预测t时刻的单词。如果直接给了我们整个词序列，让我们可以做双向，那就不叫语言模型了！ * 但是对于一个包含完整序列的NLP任务，例如文本分类、情感识别，我们就应该默认使用双向RNN。 ## 4.4 多层RNN Deep RNNs：堆叠下去，增加深度 ### 4.4.1 多层RNN的结构 多层RNN其实也很简单，RNN Layer1的输出作为下一层RNN的输入。参考下图：  ### 4.4.2 Deep RNNs通常也不会很深 * 其实深度学习多多少少是一种炼丹+大力出奇迹，一般来说把模型堆叠下去，深度大一些，性能就会好一些（当然，我们得处理好梯度下降等问题）。 * 在处理视觉场景的时候，卷积神经网络动辄可以有几百层，通常会很深；但RNN往往是二层为主，最多也很少超过8层。原因其实在于RNN训练时是串行的，不易并行化。网络太深的话，训练起来会非常花时间。 ### 4.4.3 什么是串行和并行，训练深层的RNN为什么格外花时间？ RNN的强项在于处理时序数据，每个时间步的输出都会依赖前一个时间步产生的隐向量，那么对于第t步，它必须得等到t-1步算完才能开始，无法并行处理。 以下图为例： * 如果不是RNN的话，换点别的神经网络，对于输入W1、W2、W3、W4，各算各的，各自输出Y1、Y2、Y3、Y4，最后我们可以把Y1、Y2、Y3、Y4拼在一起。**并行**就是你干你的，我干我的，最后我们拼一起。 * 然而，对于RNN来说，参考下图： 1. 首先我们得算出了H(1,1)，才能去算H(1,2)；算出了H(1,3)，才能去算H(1,4)。 2. 其次，如果我们想算出H(2,2)，那么我们得把H(2,1)和H(1,2)都先算出来。想算出H(3,3)，那么就得把H(3,2)和H(2,3)也都算出来。 3. 我们假设向上箭头的计算速度和向右箭头的计算速度是一样的，矩形被运算完就会被填充，那么对于一个四层的神经网络，会按照颜色深浅的顺序，从浅到深一个一个填充完。 4. 情况还可以更糟糕：对于Generative的语言模型，我们常常采用自回归的形式，上一步最终的输出会作为下一步的输入。在可以可以考虑：W1一路运算到了H(4,1)，才输出了W2，而后W2再输入进去，算出H3的场景。 5. **串行**就是我干完了，你才能干。看上图其实我们也就能知道，如果输入序列非常长，例如一次翻译由几百个词的句子的话，RNN的训练速度极慢这件事情会格外的明显。 Note：RNN相较于CNN处理不能并行化，不是说无法同时进行多个“输入-输出”的样本批量处理，而是对于单个“输入”-“输出”的训练样本，其依赖于按照时间步顺序一个一个算，从而带来计算效率瓶颈。 GPU的牛逼之处在于超强的并行计算能力，RNN无法很好的并行，自然也就很难发挥GPU的优势，训练起来很难。 总之，深层的**RNN**训练需要很多计算资源，需要很长的时间，这就是为什么我们需要Transformer。 ## 4.5 RNN总结 <table> <thead> <tr> <th><strong>模型</strong></th> <th><strong>卷积神经网络 CNN</strong></th> <th><strong>循环神经网络 CNN</strong></th> </tr> </thead> <tbody> <tr> <td><strong>模型结构</strong></td> <td><img src="images/image-32.png" alt=""></td> <td><img src="images/%E6%88%AA%E5%B1%8F2023-04-16%20%E4%B8%8B%E5%8D%883.40.37.png" alt=""></td> </tr> <tr> <td><strong>类型与架构</strong></td> <td>前馈神经网络，不循环通常是有监督学习，依赖标注数据架构包括输入层、卷积层、池化层、全连接层。卷积层提取特征，池化层压缩特征。</td> <td>循环神经网络，有一个循环递归和递归参数，具有记忆特性，上一时刻的输出可以作为下一时刻的输入；当前时刻当同时接受前时刻的输入和上一时刻的输出如果没有那个循环的话就是个简单的MLP，但加上了这个循环后反向传播变得非常复杂</td> </tr> <tr> <td><strong>典型模型</strong></td> <td>LeNet；AlexNet；VGG；GoogleNet；ResNet</td> <td>最基础的RNN；LSTM；GRU</td> </tr> <tr> <td><strong>优缺点</strong></td> <td>优点：卷积层通过使用局部感知性的卷积操作，可以有效地捕捉输入数据中的局部特征；在卷积层中，卷积核的参数在整个输入上是共享的，大大减少了需要学习的参数数量；高度可并行化；池化层进行下采样，减小特征图的尺寸，降低模型复杂性卷积神经网络非常适合用于图像识别，其高性能和易训练的特点是最近几年CNN流行的两个主要原因</td> <td>优点：能够捕捉序列数据中的时序关系，通过循环连接使得网络可以记住之前时间步的信息，并在后续时间步中使用，从而能够处理具有长期依赖关系的序列数据。缺点：时序循环连接让BP非常复杂；时序循环可能导致梯度在反向传播过程中消失或爆炸；在处理长期依赖关系时可能面临梯度消失的问题，导致难以捕捉到远距离的时序关系。在处理长序列数据时，由于需要逐步进行时间步的计算，导致计算效率较低循环神经网络非常适合用于具有序列特征的数据的识别</td> </tr> <tr> <td><strong>模型参数</strong></td> <td>卷积核权重与偏置；全连接层权重与偏置</td> <td>以LSTM为例子：5个权重矩阵： W，W^f(f for forget)，W^i（i for information）， W^o(o for output)， W'（从当前步隐状态到输出），以及对应的各种偏置。</td> </tr> <tr> <td><strong>超参数</strong></td> <td>Batch Size；学习率，迭代次数，激活函数，网络结构，正则化；卷积核大小；卷积核数量；窗口滑动步长；边缘填充；池化层的类型、池化窗口大小和池化步长</td> <td>Batch Size；学习率，迭代次数，激活函数，网络结构，正则化；循环层的层数</td> </tr> </tbody> </table> # 5. 入门：强化学习 Reinforcement Learning, RL \#如果只关注语言模型，这里也可以先跳过，就像跳过CNN一样 ## 5.1 强化学习的三层结构 ### 5.1.1 基本元素：Environment, Agent & Goal 环境，玩家与目标 这一层包括Agent与其所处的环境（Environment）之间的交互。环境是Agent所面对的外部世界，可以是现实世界中的物理环境，也可以是虚拟环境中的计算机模拟环境。玩家（Agent）通过与环境交互来实现其目标，目标通常由任务或问题定义。Agent需要通过与环境的交互来获取反馈（如奖励信号）并不断优化其行为。 下围棋为例子，环境：棋盘；Agent：棋手；目标：赢得棋局。 玩马里奥为例子，环境：马里奥游戏的画面 Agent：操作的马里奥 目标：吃金币/通关救出公主 ### 5.1.2 主要元素：State & Action 状态与行为 在强化学习中，Agent通过感知环境获取当前的状态（State）信息，状态可以是环境的观测值或者内部的状态表示。Agent根据当前的状态选择合适的行为（Action）来与环境交互，行为是Agent在某个时刻从可能的动作集合中选择的具体动作。 下围棋为例子，状态：棋盘上目前的棋子分布情况。行为：要把这一步棋下在哪里。 玩马里奥为例子，状态：当前的画面，包括金币、怪物的分布 行为：马里奥向左、向右、向上 ### 5.1.3 核心元素：Policy & Value 策略与价值 策略（Policy）是Agent在特定状态下选择行为的策略，可以是确定性策略（确定性地选择一个行为）或者随机策略（根据概率分布选择行为）。价值（Value）是对不同状态或状态-行为对的评估，用于指导Agent的决策。 Agent根据策略和价值来选择行为，策略和价值的优化是强化学习中的重要任务。策略和价值的设计和更新会影响智能体的学习和决策过程。 下围棋为例子，Policy：棋谱告诉我们面对怎样的棋盘，我们应该怎么下；价值：如果下的某一步棋帮助我们奠定了胜局，那么它的价值就非常大。 马里奥游戏为例子，Policy就是根据当前的怪物、金币、机关分布，我们怎么操作马里奥任务。价值：如果走的某一步导致被怪物杀死了，价值就应该是一个非常大的负数。 ## 5.2 强化学习的核心内容 ### 5.2.1 学习一个好的价值函数，从而去决定一个好的策略 主流的RL算法一般是基于价值的。 ### 5.2.2 是试错学习，而非记忆学习 ### 5.2.3 具有延迟奖励的特点，贡献度分配很重要 例如，围棋的每一步棋对胜利都有贡献，但奖励一开始全都是0，得赢棋了才能兑现。那得到reward之后，之前每一步的value要怎么分配？ 这里涉及到贡献度分配的问题，复盘哪一步棋决定了胜势很关键。 ### 5.2.4 Exploitation VS Exploration&#x20; 以DQN的训练过程为例， **利用：**&#x91C7;用已有的价值函数，去选择价值最大的行动 **探索：**&#x4E0D;按照目前已有的价值函数给出的价值最大的行动来，而是尝试去优化价值函数本身，去探索一些其他的选择 一个很经典的例子是老虎机问题。上帝视角看，老虎机A的期望是100，B的期望是50，C的期望是0。那么显然我们应该一直玩老虎机A；但是在强化学习中，我们其实不知道老虎机A、B、C的期望函数，只能通过实践去猜测。 假设我们把A、B、C各尝试了10次，这10次中，A的均值为30，B的均值为35，C的均值为-10。那么此时我们可以有两种选择：1、继续选择B。如果我们无数次的去尝试B，最终B的均值会逼近真实期望50，而50无疑比20和-10都要大，那么我们的学习结果就是，三个老虎机中B是最好的。 2、尝试B之外的其他选项，例如尝试一次A，这次A输出了数字140，假设一下子把均值拉到了40，那么它就超过了35。最终，因为我们在遵循既有策略（B）的同时也兼顾探索了其他策略（A），发现了A其实是最好的，那么我们可能就会避免因为只去遵守策略，最终收敛于了局部最优解B。 ## 5.3 强学学习的数学表达 ### 5.3.1 Return 回报 回报的英文为Expected Cumulative Future Reward，即未来所有预期回报之和。 $$U_t = R_t+R_{t+1}+R_{t+2}+...$$ 因为未来的奖励的价值没有现在的高，例如相比于明年拿到100元，我可能更偏好现在就拿到95元。因此，对于未来的奖励，我们会给他打一个折扣，称为Discounted Return： $$U_t = R_t+\gamma R_{t+1}+\gamma^2 R_{t+2}+...$$ 其中，$$R_t$$为第t次Action时系统给的奖励，$$\gamma$$是折现率，是一个介入0～1的实数。 &#x20; $$P[S'=s'|S=s,A=a]=p(s'|s,a)$$ ### 5.3.2 State Value Function状态价值函数 ***#给状态s打分；也可评价政策π的好坏*** 状态价值函数，指的是在当前的状态和政策下，未来所有的奖励的折现值。 $$V_π(s_t)=E_A[Q_π(s_t,A)]=∫π(a|s_t)*Q_π(s_t,a)da$$ 状态价值函数只和π与s有关，告诉了我们在目前的政策下，当前我们的处境怎么样，我们的胜算有多少。 $$V_π$$是一个随机变量，随机的来源在于：状态的变化随机。 ### 5.3.3 Action-Value Function 行为价值函数 ***#给动作a打分*** 行为价值函数$$Q_π$$反映了：基于一个政策函数π，在一个状态$$s_t$$下，采取一个行动$$a_t$$的回报的期望值。 $$Q_π(s_t,a_t)=E[U_t|S_t=s_t,A_t=a_t]$$ $$Q_π$$是一个随机变量，随机的来源在于：1、基于Policy函数，Agent的行为随机；2、状态的变化随机。 最优行为价值函数 Optimal Action-Value Function：指的不管政策怎样，当前的一步行为可以产生的回报的上限。 $$Q^*_π(s_t,a_t)=\mathop{max}\limits_πQ_π(s_t,a_t)$$ $$Q^*_π$$的直观意义在于抛开政策的影响，对一个行为做评估。 ## 5.4 价值学习 价值学习的目的：去想办法近似出一个行为价值函数。 ### 5.4.1 Deep Q Network 我们用一个神经网络$$Q(s,a;w)$$去近似$$Q^*(s,a)$$。 我们知道$$Q^*_π(s_t,a_t)=\mathop{max}\limits_πQ_π(s_t,a_t)$$是抛开政策不谈，给一个动作打分用的。 这个神经网络的输入就是当前的状态，如果我们在玩游戏，那么状态就是当前游戏的画面，我们通过卷积层把当前游戏的画面变成特征向量输入给神经网络；神经网络的输出则是输出一个给动作打分用的向量。假设当前在当前状态下，有3种可能的动作（left, right ,up)，那么神经网络的输出就会是一个三维向量，每一维向量的元素就是根据$$Q^*(s,a)$$的思想对动作进行的打分。 自然的，系统应该去做打分最高的动作：$$a_t=argmax_aQ(s_t,a;w)$$。 而后根据该动作，系统自动根据状态迁移函数$$s_{t+1}~P(·|s_t,a_t)$$。***到了下一个状态后，继续往复上面的动作，用神经网络$$Q(s,a;w)$$给每一个动作打分，而后去做分数最高的动作。*** ### 5.4.2 强化学习中的梯度下降 上面讲清楚了DQN的基本思想，但问题在于，$$Q(s,a;w)$$的参数$$w$$一开始是随机初始化的，所以它是一个笨蛋裁判，根本就不懂怎么给动作打分。我们得想办法去训练这个网络，让这个裁判越来越专业，打分越来越准。 和前面的MLP等神经网络一样，用的其实也是梯度下降的算法。以下为例子： 从北京到深圳，模型Q(w)预计要q=1000分钟。实际旅程后，我发现只需要y=800分钟。误差200分钟，造成损失。 损失函数： $$Loss(L)=\frac{1}{2}(q-y)^2$$ *<（想起之前的$$ \mathcal L(y,f(x;\theta))=\frac{1}{2}(y-f(x;\theta))^2 $$了吗？就是他！）>* 对损失函数求梯度： $$\frac{∂L}{∂w}=\frac{∂q}{∂w}*\frac{∂L}{∂q}=(q-y)\frac{∂Q(w)}{∂w}$$ 而后对参数w进行梯度下降： $$w_{t+1}=w_t-\alpha\frac{∂L}{∂w}|_{w=w_t}$$ 其中，$$\alpha $$为学习率/步长。 ### 5.4.3 TD算法 Temporal Difference ***TD算法的直观感受*** 有没有这样一种算法，再让我还没有到达深圳的时候，就可以提前得到更好的估计呢？ 假设我们从北京先到上海再到深圳。我们经过了500分钟到了上海，此时模型预测还需要400分钟到深圳。 那么，最初的预测：Q（w）=1000分钟；最新的预测：y=500分钟（Actual）+400分钟（Estimate）=900分钟。 此时，新的预测：900分钟被我们称为TD Target。TD Target也是一种估计，但有事实的成分，显然比一开始的1000更可靠。用TD target的话，就可以实现无需跑完整个路程，就实时更新参数了。 损失函数： $$Loss(L)=\frac{1}{2}(Q(w)-y)^2$$ <我们称$$Q(w)-y$$为TD Error，这里为100> 对损失函数求梯度： $$\frac{∂L}{∂w}=$$$$(Q(w)-y)*\frac{∂Q(w)}{∂w}=TD Error*\frac{∂Q(w)}{∂w}$$ 而后梯度下降即可。 ***DQN中TD算法的数学表达*** > 公式：$$T_{BJ-SZ}(Estimate)\approx T_{BJ-SH}(Actual)+T_{SH-SZ}(New Estimate)$$ > > 我们知道，考虑折现率的回报函数为：$$U_t = R_t+\gamma R_{t+1}+\gamma^2 R_{t+2}+...=R_t+\gamma U_{t+1}$$ > > 其实就可以类推到：$$Q(s_t,a_t;w)\approx r_t+\gamma Q(s_{t+1},a_{t+1};w)$$ > > 其中，$$r_t$$就相当于在时间步t系统实际给的奖励；$$\gamma Q(s_{t+1},a_{t+1};w)$$就是新的估计。这是不是就跟上面的从北京到深圳的例子一样了？ > > 我们的目的是逼近最大价值函数$$Q^*(s,a;w)=\mathop{max}\limits_π Q_π(s_t,a_t)$$，那么TD Target体现在哪里呢？ > > TD Target是这一步的奖励加上新的预测： $$y_t=r_t+\gamma Q(s_{t+1},a_{t+1};w_t)=r_t+\gamma \mathop{max}\limits_aQ(s_{t+1},a;w_t)$$ > > 则根据TD Error我们有了损失函数：$$Loss=L_t=\frac{1}{2}[Q(s_{t},a_{t};w)-y_t]^2$$ > > 我们根据这个损失函数计算梯度并进行梯度下降。 ***DQN网络中TD算法步骤总结：*** 1. $$S_t=s_t, A_t=a_t$$ 2. 预测：$$q_t=Q(s_t,a_t;w)$$ 3. 求导：$$d_t=\frac{∂Q(s_t,a_t;w)}{∂w}|w=w_t$$ 4. 根据当前的状态，决定了一个action，得到了一个奖励$$r_t$$和新的状态$$s_{t+1}$$ 5. 既然有了新的State，我们就又可以用Q网络预测新状态下最优动作的预期回报：$$\mathop{max}\limits_aQ(s_{t+1},a;w_t)$$。从而我们可以计算TD Target：$$y_t=r_t+\gamma \mathop{max}\limits_aQ(s_{t+1},a;w_t)$$ 6. 有了TD Target自然就有了TD Error：$$q_t-y_t$$，我们据此做梯度下降：$$w_{t+1}=w_t-\alpha(q_t-y_t)dt$$ ## 5.5 策略学习 策略学习算法是用一个神经网络去近似策略函数，并且该策略函数可以让$$V_π$$尽可能得大。 具体略，因为文档是为语言模型服务的，学完价值学习、DQN和TD算法后，其实就已经对强化学习的基本原理有了解了。如果想要深入了解的话，去看下面推荐的王树森的课程自学就好了。 > 值得注意的是，在RL中，我们可以使用奖励函数而不使用价值函数来训练策略，从而实现策略梯度算法。这种方法被称为纯粹的策略梯度方法（pure policy gradient methods）。也就是说，上面提到的东西中，Value是可以不要的。 ## 5.6 Actor-Critic Method 略，理由同上。 ## 推荐学习材料 * 若想要在一个小时以内快速的对强化学习有一个初步的认知，推荐[PenicillinLP](https://space.bilibili.com/291907888)制作的《【强化学习】一小时完全入门》，视频做的非常有趣、易懂，而且也非常有条理的展现了强化学习思想的精髓。 [【B站】【强化学习】一小时完全入门](https://www.bilibili.com/video/BV13a4y1J7bw/?buvid=ZE4EBEE92994324F407089826EE9BEE9DE8E\&is_story_h5=false\&mid=jOTTvC9MAcEUtHyHp%2B%2B2ww%3D%3D\&p=1\&plat_id=114\&share_from=ugc\&share_medium=iphone\&share_plat=ios\&share_session_id=446FA03C-3D56-4181-A256-6FE0BB4B07FA\&share_source=WEIXIN\&share_tag=s_i\&timestamp=1680963987\&unique_k=SAYH66y\&up_id=291907888) * 若想要在数学语言推导上，对强化学习有较为完整的了解，愿意为此花时间，推荐王树森[Shusen Wang](https://www.youtube.com/@ShusenWang)的课程： [【B站】王树森： Deep Reinforcement Learning](https://www.bilibili.com/video/BV12o4y197US/?buvid=ZE4EBEE92994324F407089826EE9BEE9DE8E\&is_story_h5=false\&mid=jOTTvC9MAcEUtHyHp%2B%2B2ww%3D%3D\&p=1\&plat_id=114\&share_from=ugc\&share_medium=iphone\&share_plat=ios\&share_session_id=BC559497-28E3-42F7-8792-57408235B304\&share_source=WEIXIN\&share_tag=s_i\&timestamp=1680963976\&unique_k=wpm2mPl\&up_id=52065264) # 6. 入门：自然语言处理与语言模型 NLP & Language Model, LM **需要的先验知识：无，懂点基本的概率论即可。** ## 6.1 为什么机器这么难理解人类语言？ 可以去回想2.1.1中我们提到过的语义鸿沟的概念。 人类自然语言的多样性、灵活性、歧义性、上下文依赖性、语言的变化以及世界知识和常识的应用等因素都使得让机器难以理解人的自然语言： 1. 多样性和灵活性：包括语法、词汇、语义、上下文等方面。同一个词汇在不同语境中可能有不同的含义，例如“他被杀死了”的“死”和“笑死我了”的死完全是两个含义。人们还经常使用讽刺、隐喻、比喻、口语和俚语等非字面意义的表达方式，比如“潘帕斯雄鹰真是这场盛典中的一匹黑马”，潘帕斯雄鹰指的是阿根廷队而不是一个动物，盛典指的是世界杯，黑马是比喻阿根廷队取得了超乎我们预期的表现。人是可以理解这些语言的，但机器想理解这些就非常困难。 2. 语言的歧义性：自然语言中存在丰富的歧义现象，包括词义歧义、语法歧义、指代歧义等。例如，英语中的词汇"bank"可以表示银行，也可以表示河岸，其含义取决于上下文，这是词语歧义；The animal didn't cross the street because it was too tired，对于机器来说，这里的it可以指代animal，也可以指代street。这是一种指代歧义。这种歧义性对于机器来说是一个挑战，因为需要具有推理和语境理解能力才能够正确解析歧义。 3. 上下文依赖性：人类自然语言中的表达通常依赖于上下文信息。例如，尽管大多数时候terribly的意思是负面的，但The movie is terribly exciting中，terribly的意义就是积极的。 4. 世界知识和常识：人类在语言交流中经常依赖于世界知识和常识，即我们对世界的认知和经验。当我们说"我要花30元去伦敦看电影"时，我们知道电影是什么，知道伦敦是个地名，知道30是个数字而元是货币单位。这种世界知识和常识对于理解自然语言是至关重要的，但对于机器来说，获取和应用这些知识是一项复杂的任务。 ## 6.2 NLP的基本任务 ### 6.2.1 文本分类 Text Classification 将文本分为不同的预定义类别，例如情感分类（积极情感还是消极情感，是否具有攻击性和恶意）、主题分类、垃圾邮件分类等。 ### 6.2.2 命名实体识别 Named Entity Recognition, NER&#x20; 命名实体识别（Named Entity Recognition, NER）是自然语言处理（NLP）中的一种任务，旨在识别文本中具有特定命名实体的片段，如人名、地名、组织名、时间、日期、货币、数量等。（陈先生和陈醋和陈仓里的陈是不一样的，我们希望机器能知道陈先生是人名，陈醋是个物品，陈仓是个地名，这样模型去做自然语言任务的性能才会提高）NER是许多NLP应用中的重要预处理步骤。 ***NER通常可以分为以下几种类型：*** 1. 人名（Person）：识别文本中的人物名称，如"John Smith"、"张三"等。 2. 地名（Location）：识别文本中的地理位置名称，如"New York"、"北京市"等。 3. 组织名（Organization）：识别文本中的组织、公司、机构名称，如"Microsoft"、"中国科学院"等。 4. 时间（Time）：识别文本中的时间信息，包括日期、时间、季节等，如"2021年10月1日"、"下午3点"等。 5. 日期（Date）：识别文本中的日期信息，如"2021-10-01"、"10/01/2021"等。 6. 货币（Currency）：识别文本中的货币信息，如"100美元"、"500元人民币"等。 7. 数量（Quantity）：识别文本中的数量信息，如"3个苹果"、"10米长"等。 NER任务通常采用监督学习方法，其中标注了已知命名实体类型的大规模标注数据用于训练模型。 ### 6.2.3 句法分析 Dependency Parsing Dependency Parsing是指对句子进行语法分析并画出句子成分的依赖关系，比如对于句子“She saw the video lecture”，首先可以分析出主语、谓语、宾语等句子成分；其次可以分析出依赖关系，比如saw依赖于She等。这就是句法分析。  ### 6.2.4 语言生成 **Language Generation** * **语言生成（Language Generation）**&#x662F;自然语言处理（NLP）领域中的一种任务，指的是使用计算机生成自然语言文本的过程。 * 语言生成可以应用于多种应用场景，如机器翻译、文本摘要、对话系统、自动生成文章、生成代码、音乐和艺术创作等。 ***语言生成方法可以分为以下几种（**&#x6211;们主要涉及到3和&#x35;**）：*** 1. 基于规则（Rule-based）生成：通过预定义的规则和模板来生成文本。这种方法通常适用于生成简单的文本，如问候语、固定格式的消息等，但对于复杂的文本生成任务来说，Rule-based 方法的扩展性有限。 2. 基于统计（Statistical-based）生成：使用统计模型来生成文本，如n-gram语言模型、隐马尔可夫模型（HMM）等。这种方法通过统计文本数据中的频率和概率信息，生成文本序列，但可能会受限于数据的数量和质量。 3. 基于机器学习（Machine Learning-based）生成：使用机器学习算法来生成文本。例如，循环神经网络（Recurrent Neural Networks, RNNs）和变种（如长短时记忆网络，LSTM）被广泛用于生成文本，因为它们能够处理序列数据和捕捉上下文信息。 4. 基于深度学习（Deep Learning-based）生成：使用深度学习模型来生成文本，如变种的生成对抗网络（Generative Adversarial Networks, GANs）和变分自编码器（Variational Autoencoders, VAEs）。这些模型通常能够生成更复杂和高质量的文本，但需要大量的训练数据和计算资源。 5. 基于预训练模型（Pre-trained Model-based）生成：利用预训练的模型，如GPT-3、BERT等，来生成文本。这些模型通过大量的无监督训练从大规模文本数据中学习到了丰富的语言知识，可以生成高质量且多样性的文本。 ## 6.3 语言模型 Language Model 定义 在不同的文章和材料中会看到对语言模型的不同定义，这可能会让人有些疑惑，不过下面我们都会讲清楚的。 ### 6.3.1 估计一个给定词序列在语言上的合理性或者说概率 首先，对于任意的词序列，语言模型能够用计算出这个词序列是一句话的概率。 例如，对于: $$\left\{ \begin{aligned}s_1:武汉｜的｜天气｜真｜差\\ s_2：天气｜北京｜的｜差｜真 \\ \end{aligned} \right. $$,应该要有: $$\left\{ \begin{aligned} P(S_1）=1（或接近于1）\\ P(S_2）=0（或接近于0）\\ \end{aligned} \right. $$。 这其实是语言模型最早的功能，它的起源其实是Speech Recognition，即语音转文字！从音频转到文字的时候，会有很多个句子作为候选。那么哪个句子更合理？这种时候我们就可以用语言模型，对这些句子Make Sense的概率做一个排序。**这时候，对于语言模型的定义为：**&#x8BED;言模型（Language Model）是一种用于生成自然语言文本的概率模型。它可以估计一个给定文本序列（通常是一个句子或者一个短语）在语言上的合理性或者说概率： 给定一个词典$$V$$，可以计算对于任意单词$$w_i\in V$$，词序列$$w_1,w_2,w_3,....,w_n$$是一句Make Sense的句子的概率： $$P(S)=P（w_1,w_2,w_3,....,w_n）$$ ### 6.3.2 根据先前的文本序列预测下一个词，从而实现文本生成 当然，现在我们知道语言模型真正在做的事情是下一个词的预测和输出了。 > 最常见的的语言模型大概就是手机输入法，它能根据你当前输入的内容提示下一个字或者词。 不过这其实和上面的定义是一脉相承的。如果我们能预测词序列$$w_1,w_2,w_3,....,w_n$$是一句Make Sense的句子的概率，那么我们自然也可以去预测词序列$$w_1,w_2,w_3,....,w_n,w_{n+1}$$是一句Make Sense的话的概率。这样的话，已知$$w_1,w_2,w_3,....,w_n$$，不就可以去选择一个$$w_{n+1}$$了吗？ **我们这么补充语言模型的定义：**&#x8BED;言模型可以根据先前的文本序列预测下一个可能出现的词或者字符，从而生成新的文本。如果是以已有的全部词序列为预测依据，那么，语言模型就是在求：$$P(w_{i}|w_{1},w_{2},...,w_{i-1};\theta)$$ 那么，语言模型的目标函数（损失函数）就变成了一个我们非常熟悉的东西（2.2.2.1）： $$\mathcal L(\mathcal U)=-∑^i_1logP(w_{i}|w_{1},w_{2},...,w_{i-1};\theta)$$ *还记得交叉熵损失函数吗？它就是模型理应输出1的那一维向量的元素的负对数。* 其中，$$\mathcal U$$是巨大无比的**语料库（Corpus）**，$$ w$$是一个个的词语，$$\theta$$是模型的参数。我们训练语言模型的目的，就是在于调整参数$$\theta$$，让模型接受这段话前面的词语们，尽量根据语料库，输出下一个词语$$w_i$$。 所以，本质上语言模型就是一个基于概率的自回归填字游戏。 ### 6.3.3 我们期待语言模型能有怎样的表现？ 现在我们用V表示一个词典：$$V=\begin{bmatrix} 猫&狗&在&卧室&书房&吃&肉&鱼&黑&白&黄&紫 \end{bmatrix}$$，那么： 例如，对于: $$\left\{ \begin{aligned}s_1:猫｜在｜卧室｜吃｜鱼\\ s_2：狗｜在｜书房｜吃｜肉 \\ \end{aligned} \right. $$,应该要有: $$P(s_1)\approx P(s_2)$$，因为猫和狗是相似的，卧室和书房是相似的，鱼和肉也是相似的。 我们希望语言模型有足够的泛化能力。 对于: $$\left\{ \begin{aligned}s_1:猫｜在｜卧室｜吃｜鱼\\ s_2：猫｜在｜书房｜吃｜鱼 \\ \end{aligned} \right. $$，我们当然还是希望: $$P(s_1)\approx P(s_2)$$，因为没人规定猫只能在卧室，不能在书房。 对于: $$\left\{ \begin{aligned}s_1:黑｜猫\\ s_2：白｜猫 \\ \end{aligned} \right. $$，我们自然也希望: $$P(s_1)\approx P(s_2)$$，因为猫确实可以有很多颜色。 但是我们也不希望语言模型太过于“灵活”发散： 对于: $$\left\{ \begin{aligned}s_1:猫｜在｜卧室｜吃｜鱼\\ s_2：狗｜在｜书房｜吃｜鱼 \\ \end{aligned} \right. $$，我们就不希望: $$P(s_1)\approx P(s_2)$$了！！因为狗真的不至于吃鱼！*（有人跟我说他们家的狗就是爱吃鱼，但是无所谓了！！）* 对于: $$\left\{ \begin{aligned}s_1:黑｜猫\\ s_2：紫｜猫 \\ \end{aligned} \right. $$，我们就不希望: $$P(s_1)\approx P(s_2)$$了！！因为猫真的不大可能是紫色！ 我们希望语言模型可以根据上下文发现词汇之间是相似的。 * 如果“NLP”和“自然语言处理”在语料中的上下文很像，那么语言模型就应该能发现，NLP和自然语言处理是一个意思。人类很容易就可以理解NLP就是自然语言处理，但是对于机器来说，这必须得学习自他们相似的上下文。 * 同样的，如果我们已知了NLP和自然语言处理这两个词是一样的，那么它们的上下文应该也是相似的。 我们还可以做一些有意思的类比实验来测试语言模型的能力。 例如，如果我们用了词嵌入的方式来表示词汇，那么，应该有： $$\vec{国王}-\vec{王后}\approx\vec{男人}-\vec{女人}$$ *（嗯，这是word2vec刚出来的时候很震撼的原因之一，让人觉得woc还能这么玩——）* ## 6.4 词嵌入 Word Embedding 这里可以回想1.4.1.2中我们提到的特征，还有1.5.1～1.5.3中我们提到的表征、局部表征和分布式表征。 还记得这张图吗？颜色用RGB来表示很天经地义，让这个例子很好理解。其实对于词语来说，也一样的！  ### 6.4.1 One-hot向量 早期的NLP常用one-hot编码来表示词向量，假如词典中共有10000个词，则这个one-hot向量长度就是10000，该词在词典中所处位置对应的值为1，其他值为0。 在自然语言处理中，Token（词元）通常指的是将句子或文本拆分成单个独立的单词或标点符号。这个过程称为分词或标记化，它是自然语言处理中的一项重要预处理任务。 猫｜在｜卧室｜吃｜鱼 就是一个拆分成词元的过程。 在表示英文的时候，Token（词元）和单词不一样，Token是一个比单词更小的分割单位。 例如，如Her words interested me a lot，这里的word加了一个s就可以衍生出一个words，interest这个单词也可以变成过去式interested（这也可以是个形容词，of course），加了ing也可以变成进行时或者另一个形容词。如果给每一种衍生方式都单独编码，增加one-hot向量的维数，那么就太麻烦了。相比之下，不如只记录word，interest，s，ed，ing这几个Token。 具体可以参考：[【个人博客】CS224N(2.14)Subword Models | bitJoy](https://bitjoy.net/2020/02/17/cs224n%ef%bc%882-14%ef%bc%89subword-models/) By Beeder。Subword Model是一个挺有意思的NLP研究方向，不过我们这里不打算详细介绍，我们只要懂它的思想原理就行。 one-hot表示方法虽然简单，但其有诸多缺点： 1. &#x20;词典中的词是不断增多的，比如英语，通过对原有的词增加前缀和后缀，可以变换出很多不同的词，one-hot编码会导致向量维度非常大，且每个向量是稀疏的； 2. 不同词的one-hot编码向量是正交的，在向量空间中无法表示近似关系，即使两个含义相近的词，它们的词向量点积也为0。 ### 6.4.2 词嵌入 Embedding 词嵌入就和用RGB表示颜色一样，用维度有限的稠密的向量来表示所有的词汇。不过 词嵌入一般不会只用3维向量。传统的Transformer中，词嵌入有512维；BERT中，词嵌入有768维和1024维两个版本。 此外，词嵌入中的向量的元素数字好像会更加意义不明。RGB我们知道代表三种颜色各自的灰度，但是词向量中的数字，恐怕除了计算机外就没有人能看懂了。 我们通过把One-hot向量通过一个权重矩阵投射到词嵌入里。 例如，对于一个有3000个词汇量的词典V，每一个词都是3000维的一个稀疏向量。对于每一个词，我们给他乘一个3000\*512的权重矩阵，最终就得到一个512维的向量了。 > ***Hey ChatGPT,一个3000维的one-hot向量，我们乘以一个3000\*512的稠密的权重矩阵，会得到一个怎样的结果？*** > > **ChatGPT:&#x20;**&#x5982;果将一个3000维的one-hot向量乘以一个3000×512的稠密权重矩阵，得到的结果将是一个512维的向量。具体地说，one-hot向量是一个在3000维中只有一个元素为1，其余元素为0的向量。假设这个one-hot向量的第i维为1，那么乘以权重矩阵的结果将是该权重矩阵的第i列。"因此，乘法的结果将是权重矩阵中的第i列，是一个512维的向量。" > > 这样的操作通常被用于将离散的one-hot编码表示转换为连续的稠密向量表示，从而可以输入到深度学习模型等需要连续向量输入的场景中。这种转换可以帮助模型更好地学习特征和模式，并在许多自然语言处理（NLP）任务中得到广泛应用，例如词嵌入（word embeddings）、文本分类、语言生成等。" *<好啦，ChatGPT其实讲的很清楚了！权重矩阵本身是一个可以供One-hot向量查询的表，3000维的one-hot向量，每一个词对应3000行权重矩阵的一列，而权重矩阵的一列就是一个512维的列向量了～>* 下面这段文字可以让我们更好的理解这件事。以后我们经常会碰到几个Embedding相加的事情（BERT：谁cue我？），如果好奇为什么词嵌入可以相加，那就回来看看这里吧！ > “Embedding的数学本质，就是以one hot为输入的单层全连接。世界上本没什么Embedding，有的只是one hot。” > > [词向量与Embedding究竟是怎么回事? - 科学空间|Scientific Spaces](https://kexue.fm/archives/4122) By 苏剑林大佬 ### 6.4.3 Word2vec及其训练方式 Word2vec是2013年发表的一项可以实现从One-hot到词嵌入的自然语言处理技术，它使用一个两层的神经网络模型，从大型的文本语料库中学习单词关联，将自然语言中的单词转换为数学向量。它可以将单词之间的关系表示为向量空间中的距离和方向，从而使得单词的语义信息可以用数学方式表示和处理。 还记得6.3.3里，我们提到的对语言模型所有的期待吗？Word2Vec模型就是实现我们的期待的一种方式！Word2Vec能用向量来表示各种词元，可以用余弦相似度表明这些向量所代表的单词之间的语义相似程度、检测出同义词；可以为部分句子建议额外的词、捕捉到单词的语义和句法质量。 Word2vec的应用非常广泛，它获得单词级别的向量表示可以用于各种下游任务，例如用于语义分析、文本分类、机器翻译等NLP任务中。显然，单词级别的向量表示这件事情在各种NLP任务中都具有极高的通用性，训练出来的一个性能足够好的Word2vec并将其开源的话，大家就可以不用重复造轮子，而是一起用这个好用的模型了。 后面（8.1.5）会提到，word2vec可以说是NLP中的迁移学习的祖师爷！不过目前我们还没必要去管迁移学习这个名词，只要知道这是一个通用性非常强的工作，为各种NLP任务都提供了很好的帮助，就可以了！ > Word2vec的作者Tomas Mikolov在Google工作期间，将word2vec的代码公开发布在了Google Code上。随着时间的推移，word2vec代码也逐渐迁移至GitHub上，并成为了开源社区中的一个重要项目。现在，大部分深度学习框架都提供了对word2vec模型的支持，因此使用和实现word2vec已经变得非常方便。 ***Word2vec的训练方法有两种：CBOW和Skip-gram。*** > 前文提到： > > * 如果“NLP”和“自然语言处理”在语料中的上下文很像，那么就可以推理出，NLP和自然语言处理是相似的。 > > * 同样的，如果我们已知了NLP和自然语言处理这两个词是一样的，那么它们的上下文应该也是相似的。 > > * 这两种思维分别对应了CBOW和Skip-gram。 **连续词袋 CBOW Continuous Bag of Words：**&#x43;BOW模型根据上下文单词的平均向量来预测中心单词。不展开。 **Skip-gram&#x20;**：Skip-gram模型会根据一个中心单词来预测它周围的上下文单词。不展开。 根据论文的作者（[Distributed Representations of Words and Phrases and their Compositionality](https://proceedings.neurips.cc/paper/2013/file/9aa42b31882ec039965f3c4923ce901b-Paper.pdf)、[Efficient Estimation of Word Representations in Vector Space](https://arxiv.org/pdf/1301.3781.pdf%C3%AC%E2%80%94%20%C3%AC%E2%80%9E%C5%93)），CBOW训练速度更快，而Skip-gram在出现频率更少的单词上的预测上表现更好。 在Tomas Mikolov的工作下，从16亿个单词的数据集中学习高质量的单词向量只需要不到一天的时间。COOL！ ## 6.5 基于统计方法的语言生成：N-gram模型 ### 6.5.1 条件概率的链式展开 前面提到，语言模型要做到预测下一个词的生成概率$$P(w_{i}|w_{1},w_{2},...,w_{i-1})$$。这无疑是一个可以用链式展开的条件概率去求的东西： $$P(S)=P(w_1,w_2,w_3,....,w_i)=P(w_1)P(w_2|w_1)P(w_3|w_1,w_2) ...... P(wi|w_1,w_2,...,w_{i-1})$$ 而后，利用$$P(w_1,w_2,w_3,....,w_i)$$和$$P(w_1,w_2,w_3,....,w_{i-1})$$，我们就可以求出$$P(w_{i}|w_{1},w_{2},...,w_{i-1})$$了。好吧，这根本没法算！ ### 6.5.2 马尔科夫假设 一个简化的思路是去假设一个词的出现不依赖于前面的全部词，而是仅仅依赖它前面的几个词，我们称这样的假设为马尔科夫假设。以三元语言模型（Trigram）为例，如果一个词的出现仅依赖于它前面出现的两个词，那么我们就称之为三阶马尔科夫假设，对应的语言模型就是三元语言模型： $$P(S)=P(w_1)P(w_2|w_1)P(w_3|w_1,w_2) P(w_4|w_2,w_3)...P(wi|w_{i-2}w_{i-1})$$ 这样就好算很多了。实践中常用的是3、4元模型，因为n太大语言模型的效果提升不显著，可是模型的参数量却会指数暴增。 ### 6.5.3 n-gram语言模型的局限性 n-gram语言模型存在许多局限性： 1. 只能提取将要生成的词语的前2～3个词的信息，做不到更多。然而，整个文本序列中，对于预测下一个词重要的信息绝对不只是这2～3个词，很多时候一个句子里面都存在长距离依赖关系。例如，The books of the famous writer的下一个词应该是“are”，但是如果只看前面3个词：the famous writer，机器就很可能生成一个is。那可真蠢！ 2. 本质上还是基于词语在语料库Corpus里出现的频率做概率的预测，无法解决相似性的问题。例如，如果语料库里面，出现了100次我爱北京和1000次我爱厦门，那么，P(我爱厦门)会远大于P（我爱北京）。但两个句子无疑同样Make Sense。 3. 稀疏问题。因为完全基于Corpus，而Corpus里非常见词汇的出现频率是非常有限甚至没有出现的，于是在计算条件概率时，会出现大量的分母为0的情况。**稀疏问题**指的是由于语料库中非常见词汇的出现频率较低，甚至没有出现，导致计算条件概率时分母为0或者极小的情况，从而影响模型的性能。 4. n-gram模型会非常的死板。根据语料库，n-gram模型会知道有黑车，白车，但预测不出来语料库里没有出现过的黄车。不过死板也未必是坏事，因为它不会去瞎编，只会根据语料库输出黑马，白马，而不说绿马。 ## 6.6 基于前馈神经网络优化n-gram模型 通过词嵌入的方法，我们有了把文字转化为稠密的、维度有限的向量，从而输入给一个神经网络的能力。 根据MLP的万能逼近定理，我们知道，具有一个隐层的神经网络可以很好的逼近各种函数，非常适合用于拟合概率分布；而语言模型在做下一个词预测的时候，输出的其实也是一个概率分布。因此，神经网络非常适合用于语言模型。 现在我们用FFNN去优化一个5-gram模型，即以前4个单词为输入，预测下一个词的输出。假设词嵌入是512维，词典中有3000个Token。 图源CS224N，右图展示5-gram前馈神经语言模型。 1. Input Layer：输入的句子就是前五个词元构成的序列，每一个Token都对应一个稀疏的one-hot向量。 2. Projection Layer：我们把上一层输入每个one-hot向量通过乘一个权重矩阵$$W_e$$，映射到词嵌入$$\vec{e}$$，并且把这四个词嵌入给拼起来变成一个2048维的向量。 3. Hidden Layer：输入上一层拼出来的2048维向量，以一个权重矩阵$$W$$做一个全连接。 4. Output Layer: 是一个Softmax层，也是与上一个隐层的输出以矩阵$$U$$做全连接，输出一个3000维的、每个元素都为正值的、元素之和为1的向量，即下一个词的概率分布函数了。  <参数集$$\theta=(E,W,b_1,U,b_2)$$> 但只用FFNN去升级n-gram模型还是太low了，并没有克服一个本质缺点：他的窗口数是固定的，每次预测新词$$w_i$$都只依赖前n个词。 前面讲RNN的时候就天天拿语言模型来举例，所以接下来我们看看RNN模型怎么大展身手吧！ ## 6.7 基于循环神经网络的语言模型 > 从现在开始，直到第10章——Transformer过，我们都要不断和RNN打交道！ > > 因为第四章其实对RNN的介绍已经比较详尽了·，所以这里不会再很详细地讲模型的结构/前向传播/损失函数等内容。如果学习过程中觉得自己对RNN的理解不够扎实的话，那就回去看第四章吧！  *<参数集$$\theta=(E,W_h,W_e,b_1,U,b_2)$$>*  *做语言生成（LM）时，一般采用自回归的形式，上一步的输出作为下一步的输入！* ***RNN相比于固定窗口的神经网络，其优势是：*** 1. 不受输入长度限制，可以处理任意长度的序列 2. 状态$$h_t$$可以感知很久以前的输入的信息，因此理论上可以解决长文本依赖问题。 3. 模型大小是固定的，因为不同时刻的参数$$E,W_e,W_h,b_1,b_2,U$$都是共享的，不受输入长度的影响。 ***然而其劣势也很明显：*** 1. 虽然理论上t时刻可以感知很久以前的状态，但实际因为隐状态h的记忆力过强，存在梯度消失的问题，实际上效果远没有我们想的要好。`“`*`虽然RNN理论上能建立长距离依赖关系，但由于梯度爆炸或梯度消失问题，实际上学到的还是短期的依赖关系”`（这个可以用LSTM、GRU比较好的缓解）* 2. 因为无法并行计算而是串行计算，所以训练起来特别慢（*这个哪怕改用Fancy RNN也一样是个问题，解决不了）* ## 6.8 推荐学习材料 ### 6.8.1 视频材料 探讨NLP的视频介绍材料，无疑要拿出大名鼎鼎的NLP网课Stanford-CS224N。 [【Youtube】Stanford CS224N：NLP with Deep Learning](https://www.youtube.com/playlist?list=PLoROMvodv4rOSH4v6133s9LFPRHjEmbmJ) [【B站】Stanford CS224N：NLP with Deep Learning](https://www.bilibili.com/video/BV1ct4y157Uf/?spm_id_from=333.337.search-card.all.click) ### 6.8.2 文字材料 [【个人博客】Stanford-CS224N-NLP with deep learning](https://bitjoy.net/category/0%e5%92%8c1/stanford-cs224n-nlp-with-deep-learning/page/2/) By Beeder # 7. 开始进入正题！seq2seq模型与注意力机制Attention！（2014） **需要的先验知识：[MLP](https://s3tlxskbq3.feishu.cn/docx/NyPqdCKraoXz9gxNVCfcIFdnnAc#QK8CdMmuqowMeYxKUIrcHBpFnkf)，[RNN](https://s3tlxskbq3.feishu.cn/docx/NyPqdCKraoXz9gxNVCfcIFdnnAc#NOWid4QIOoSowwxm478cqce4nzd)，第六章的基本知识。** *#前面讲了那么多，终于我们开始学习一些和我们所能接触到的大语言模型更加接近的内容了！！读这一章前最好先弄明白什么是RNN噢。* 细讲seq2seq对了解大语言模型有重大的意义：它启发了序列自编码器，这对于后来出现的NLP的自监督学习很有意义。而且Encoder-Decoder的架构也在Transformer里出现。 *#Attention在一开始是一个对基于RNN的seq2seq模型的改进技巧。当然，后面出现了放弃了RNN，只保留了Attention的剧情，大家应该都提前知道了。* 主要参考资料： [【arxiv】Sequence to Sequence Learning with Neural Networks](https://arxiv.org/abs/1409.3215) [【知乎】CS224n笔记\[7\]:整理了12小时，只为让你20分钟搞懂Seq2seq](https://zhuanlan.zhihu.com/p/147310766) By 知乎用户[蝈蝈](https://www.zhihu.com/people/guo-bi-yang-78) [【个人博客】CS224N(1.31)Translation, Seq2Seq, Attention | bitJoy](https://bitjoy.net/2019/08/02/cs224n%ef%bc%881-31%ef%bc%89translation-seq2seq-attention/) By Beeder ## 7.1 seq2seq结构：以其在NMT中的应用为例 seq2seq是一个很强大的模型，不但可以用来做机器翻译，还可以用来做很多NLP任务，比如自动摘要、对话系统等。不过它最早是用来做机器翻译的，而且翻译确实是一个很经典的场景，所以这里我们先拿翻译举例。 神经机器翻译（NMT）用了seq2seq的结构，它的另一个常见的名字是编码-解码器（Encoder-Decoder）结构。 叫seq2seq的原因，在于其输入和输出都是一个词序列。那就是sequence to sequence，即seq2seq。<*所以正确读音是 /si:k-tu:-si:k/噢！不要读错了*>  * **编码器 Encoder：**&#x8BFB;取输入文本，将输入的文本（词序列）整体编码成一个表示向量，而后交给Decoder进行解码。在编码器中，输入的词会变成一个one-hot向量，而后经过Embedding层投射到一个（512维的）向量空间，随后输入到RNN的结构里面去（这个RNN一般是LSTM，而且可以是双向等结构，而且可以有很多层，即把神经网络搞的很深，从而可以去提取更高级的特征）。 * **Context Vector：**&#x7ECF;过了编码器中的RNN的一系列计算，输出来的对源文本整体的一个表示向量。 * **解码器Decoder：**&#x63A5;受编码器编码出的输入（以及标准答案的词序列），自行生成文&#x5B57;**。**&#x5728;NMT中，Decoder的输出是预测出的词的序列，但输入在训练和预测时有所不同。  *#Encoder RNN负责对源语言进行编码，学习源语言的隐含特征。Encoder RNN的最后一个神经元的隐状态作为Decoder RNN的初始隐状态。* 1. **训练时：**&#x63A5;受编码器给出的表示向量和“标准答案”作为输入。参考左图，根据第一个输入\<start>符号和编码器送来的表示向量，先生成了预测结果$$\hat{y_1}$$。而后，根据第二个输入符号$$y_1$$（而不是前一步的预测结果$$\hat{y_1}$$），我们生成预测结果$$\hat{y_2}$$. 很好理解，那么损失函数就是前一步最终生成的整个词表的概率分布与标准答案对应的one-hot向量的交叉熵函数，我们基于这个损失函数对RNN网络做梯度下降，从而让模型预测的越来越准。 2. **预测时：**&#x81EA;产自销，每一步预测的结果，都送给下一步作为输入。这样的输出方法我们称为**自回归（Auto-regressive）**。参考下图，根据第一个输入\<start>符号和编码器送来的表示向量，先生成了预测结果$$\hat{y_1}$$。而后，根据前一步的输出$$\hat{y_1}$$（而不是标准答案$$y_1$$），我们生成预测结果$$\hat{y_2}$$.后面我们会知道，GPT就是一个自回归的文本生成模型。自回归形式天然适合Generative的 场景，这不难理解，就像是我们写文章是从左往右边写边想的一样。  ***#Decoder的初始隐状态是基于Encoder RNN的输出，所以我们把Decoder称为一个条件语言模型。*** ## 7.2 详解Decoder：他就是个语言模型！ ### 7.2.1 为什么训练和预测时的Decoder不一样？ Decoder在训练时是根据标准答案做输出，而预测时则是在自产自销。为什么要做这种区分呢？ 这里其实涉及到两种不同的Decode方式： * 根据标准答案来Decode的方式，我们称为**Teacher Forcing。** * 根据上一步的输出作为下一步输入的Decode方式，**Free Running。** *`“其实，free running的模式真的不能在训练时使用吗？——当然是可以的！从理论上没有任何的问题，又不是不能跑。但是，在实践中人们发现，这样训练太南了。因为没有任何的引导，一开始会完全是瞎预测，正所谓“一步错，步步错”，而且越错越离谱，这样会导致训练时的累积损失太大（「误差爆炸」问题，exposure bias），训练起来就很费劲。这个时候，如果我们能够在每一步的预测时，让老师来指导一下，即提示一下上一个词的正确答案，decoder就可以快速步入正轨，训练过程也可以更快收敛。因此大家把这种方法称为teacher forcing。所以，这种操作的目的就是为了使得训练过程更容易。”By 知乎用户`[`蝈蝈`](https://www.zhihu.com/people/guo-bi-yang-78)* ### 7.2.2 计划采样 Scheduled Sampling Decoder一上来就瞎预测自己来跑，就像是我们高中盲目刷题，在完全没有老师指导的情况下不断积累自己瞎jb写题产生的经验，可能越走越偏；一直按照标准答案来训练，就像高中刷题时一直看着正确答案来写，如果真上了高考考场，没了标准答案，那就忽然蒙圈了。。 所以，更好的办法，也是更常用的办法，是老师只给适量的引导，学生也积极学习。 **计划采样**：我们设置一个概率p，每一步，以概率p靠自己上一步的输入来预测，以概率1-p根据标准答案来预测。  ### 7.2.3 贪心算法 VS Beam Search #### 7.2.3.1 Greedy Decoding 如果我们每一步都预测出概率最大的那个词，而后输入给下一步，那么这种方式我们就称之为Greedy Decoding。 但是Greedy Decoding这件事情肯定存在一些问题。 比如，你用你的手机输入法去打字的时候，它也是会猜你的下一个词，并且按概率排序的！那如果我们一直点击输入法给你推荐的第一个词…… eg.我用iPhone打了“不要”两个字，而后一直只点击苹果系统自带输入法推荐的第一个词。就有了下面这段文字： > 不要再来了，我们的生活方式是什么时候回来呢，我们的生活方式是什么时候回来呢，我们的生活方式是什么时候回来呢，我们的生活方式是什么时候回来呢，我们的生活方式 嗯，甚至还循环起来了。这可真蠢！ 这其实体现了贪心算法的一个问题：Greedy只能保证每一步是最优的，但却无法保证预测出来的句子整体是最优的。特别是如果在$$t$$时刻贪心选择的词不是全局最优，会导致$$t$$时刻往后的所有预测词都是错误的，这样就没有回头路了。为了解决局部最优$$\neq $$全局最优的问题，我们常常会采用Beam Search方案。 #### 7.2.3.2 Beam Search Beam Search的思想是每一步都**多选几个可能的序列**作为候选，最后综合考虑，选出最优组合。 具体方案如下： 1. 设定候选集大小 Beam size = k（右图中，k=2;实践中，k一般等于5～10） 2. 对于每一个时间步$$t$$，我们会以当前概率最高的k个序列集作为输入，各自预测概率top-k的下一个词，从而产生$$K^2$$个候选序列。在这$$K^2$$个候选中，我们留下k个概率上最有可能的序列集，作为下一步的输入。<一定要注意，这里的Top-k不仅是指一个序列集的k个最高概率的$$\hat{y_t}$$，还指最终会从$$K^2$$的序列集中留下k个得分最高的序列>（参考右图，t=3的时间步时，top2是\[he hit]和\[I was]，所以下一步时是这两个序列继续预测下一个词，并且产生四个概率最大的分支；\[he stuck]和\[I got]会被剪枝，保证beam search过程的复杂性不会指数放大）  * 在beam search的过程中，不同路径预测输出结束标志符\<END>的时间点可能不一样，有些路径可能提前结束了，称为完全路径。我们会暂时把这些完全路径放一边，其他路径接着beam search。 * Beam search的停止条件有很多种，可以设置一个最大的搜索时间步数，也可以设置收集到的最多的完全路径数。当beam search结束时，需要从n条完全路径中选一个打分最高的路径作为最终结果。 * 我们使用如下的score函数来定&#x4E49;**「序列得分」:**$$score(y_1,...,y_t)=∑^{t}_{i=1}logP(y_i|y_1,...,y_{i-1},x)$$。序列得分全都是负的，而且越高越好。Beam search打分是累加项，越长的序列会打分越低，所以在最终决定要选择哪一句时，需要用长度对打分进行归一化：$$score(y_1,...,y_t)=\frac{1}{t}∑^{t}_{i=1}logP(y_i|y_1,...,y_{i-1},x)$$。 * Beam search作为一种剪枝策略，并不能保证得到全局最优解，但它能以较大的概率得到全局最优解，同时相比于穷举搜索极大的提高了搜索效率。 ## 7.3 注意力机制 Attention ### 7.3.1 朴素seq2seq的信息瓶颈 朴素的seq2seq神经机器翻译模型中，我们用Encoder RNN的最后一个神经元的隐状态作为Decoder RNN的初始隐状态。这里存在一个问题：Encoder的最后一个隐状态（Context Vector）承载了源句子的所有信息，成为整个模型的“信息”瓶颈。 其实不妨去想一想，在Encoder的RNN中，编码完il、a、m'的时候，中间都是有隐向量$$h_1$$、$$h_2$$、$$h_3$$，但最后输入给解码器的只有最终的$$h_4$$。有没有这么一种可能，在解码器输出“hit”这个词的时候，相比于用被更新过的$$h_4$$，其实用原始的$$h_1$$或者$$h_2$$，效果反而会更好？  *注意力机制就是希望打破这个信息瓶颈。宏观来看，Attention直接把Decoder中的每一个隐层，和Encoder中的每一个隐层，都连接起来了！* ### 7.3.2 Attention机制的直观理解  *前面提到了，“Attention直接把Decoder中的每一个隐层，和Encoder中的每一个隐层，都连接起来了。”*&#x8FD9;样的话，Encoder RNN的最后一个隐状态就不再是“信息”瓶颈了。 我们在解码的时候，是一个词一个词生成的。对于每一个词，它不仅可以接受Context Vector作为辅助信息, 也可以通过“直连”线路去获取Encoder RNN中的其他的隐状态的信息，从而Decoder的解码进行辅助。 参考左图中的Decoder的第二个时间步，我们以he为输入，并且综合考虑了il、a、m'、entarte的隐状态。可见，"he"时刻的注意力主要分布在Encoder的第2和第4个词上，解码器最终做出了输出hit的决定。 ### 7.3.3 Attention机制的数学表达 #### 7.3.3.1 向量的点积操作 点积（Dot product）是线性代数中的一种运算，它是同维两个向量之间的一种运算方式，通常用符号“·”表示。 对于两个向量 $$\mathbf{a} = [a_1,a_2,\ldots,a_n]$$ 和$$\mathbf{b} = [b_1,b_2,\ldots,b_n]$$ ，它们的点积定义为：$$\mathbf{a}·\mathbf{b} = ∑_{i=1}^na_ib_i$$ ， 也就是说，点积将两个向量中对应位置的元素相乘后再求和。因此，点积的结果是一个标量（Scalar），表示两个向量的相似程度或者两个向量在同一方向上的投影长度。 总之，我们需要知道两件事：***1、点积的结果是一个标量 2、点积的结果反映了两个同维向量的相似程度&#x20;*** #### 7.3.3.2 Attention机制的步骤 1. 在时刻$$t$$, Decoder有隐状态$$s_t$$，同时也有Encoder所有时刻的隐状态$$h_1,h_2,...,h_N$$。我们将$$s_t$$和所有的编码器的隐状态分别做点积，得到N个**标量Attention score（注意力得分）***。<#这N个标量构成一个N维向量，它反映了解码器中当前时间步的隐状态与编码器中各个时间步的隐状态的相关性打分。>* $$\mathbf{e}^t=[s_t·h_1,s_t·h_2, ... ,s_th_N]$$ * 我们使用Softmax对这些权重进行归一化（这些隐状态的和为一），就得到**Attention distribution（注意力分布）**。就像任何通过Softmax函数得到的向量一样，Attention Distribution也是一个概率分布。这个Attention distribution告诉了Decoder在时刻$$t$$，更应该把“注意力”放在Encoder的哪些隐状态上。 $$\mathbf{\alpha}^t=softmax(\mathbf{e}^t)=[\alpha_1^t,\alpha_2^t,...,\alpha_N^t]$$ * 接下来，我们对Encoder所有隐状态使用Attention distribution进行加权求和，得到**Attention output（注意力输出）** $$a_t$$。<既然注意力分布是一个概率密度函数，那注意力输出$$a_t$$其实很类似数学期望>。 解码器t时刻的注意力输出：$$a_t=∑_{i=1}^N\mathbf{\alpha}_i^th_i$$ * 把注意力输出$$a_t$$把和该时刻的隐状态$$s_t$$拼起来，再进行非线性变换，就得到输出$$\hat{y_t}$$。 #### 7.3.3.3 Attention机制带来的好处 想象机器要翻译这么一句话：The animal didn't cross the street because it was too tired.&#x20; it指的是谁呢？是street，还是animal？根据下图，我们可以看到，解码器处理it这个词的时候，注意力机制能够让it和“The animal”关联起来，并将其融入到it的编码中。  *图源[Ann's Blog](https://lolitasian.blog.csdn.net/)* 在seq2seq架构中，Attention机制可以带来以下好处： 1. 解决了信息瓶颈问题：在传统的seq2seq模型中，编码器将整个源序列编码为一个固定长度的向量；而Attention机制可以让解码器在每个时间步上，根据源序列中不同位置的信息进行不同程度的“聚焦”，充分利用源序列中的信息，提高模型的表现。 2. 提高处理长序列的能力，提升模型的泛化性能：Attention机制可以使模型对输入序列的长度更加鲁棒，不会因为输入序列长度的变化而影响模型的性能。这是因为Attention机制会根据不同的输入序列长度自适应地调整“聚焦”的程度，使得模型可以有效地处理不同长度的输入序列。 3. 增加模型的可解释性：Attention机制可以让我们更加直观地理解模型在生成每个输出时“关注”了源序列中的哪些部分，并且可以通过可视化Attention权重来直观地观察模型的注意力分配情况，从而更好地调试和优化模型。例子可以参考上面的可视化图。 4. 提高翻译效果：在机器翻译任务中，Attention机制可以将源序列中与目标序列有关联的部分显式地“聚焦”，从而提高翻译效果。例子同样参考The animal didn't cross the street because it was too tired的翻译。 5. 有助于缓解梯度消失问题，因为Decoder的每一时间步都和所有Encoder的隐状态相连了。 > 自从seq2seq和NMT横空出世以来，机器翻译取得了巨大的进展。从前的机器翻译的至高点——SMT（统计机器翻译）都是极其复杂的，涉及到大量的特征工程，海量的专家知识，无数的资源积累，繁多的功能模块，还需要庞大的人力去维护。现在直接被一个很深很深的神经网络干翻在地！大量特征工程师&语言专家失业SOS  ## 7.4 还有一些想说的 ### 7.4.1 NMT确实牛逼，但还有一些问题 seq2seq用于神经翻译，在性能上肯定是非常优秀的，但它依然存在一些问题： > 1. 领域不匹配。很多时候，我们在Wikipedia、论文、新闻稿等这种比较正式的语料库中训练，那么用来翻译Twitter，甚至在游戏国际服里和外国人的交流这种口语或者非正式语料时，就会有问题。 > > 2. 长文本的翻译，目前介绍的都只是翻译一个句子，句子相对来说还是比较短的，如果要翻译一篇论文或一本书，那么怎样考虑非常长距离的上下文依赖关系？ > > 3. 对一些惯用语、俚语等翻译容易闹笑话（说曹操，曹操到；笑死我了；等等） > > **讲这些的目的其实还是想要铺垫后面的预训练大语言模型。** ### 7.4.2 Attention开始变为深度学习的一种通用技术 现在，Attention已经变成了DL的一个的通用技术，并不局限于seq2seq和机器翻译。其一般的定义是： 1. 给定一系列values集合$$H$$=\[$$h_1,h_2,...,h_N$$]，和一个查询向量$$q$$，用$$q$$和$$H$$中的每个向量做点积，得到$$q$$对$$H$$=\[$$h_1,h_2,...,h_N$$]的注意力得分； 2. 对得分向量进行softmax运算，得到注意力分布。 3. 用注意力分布对$$H$$=\[$$h_1,h_2,...,h_N$$]进行加权平均得到Attention output，它是$$H$$关于查询q的一个摘要summary。 4. Attention有很多变体，变体的关键在于注意力得分的计算机制。  \#我把Attention的矩阵运算给折叠了，因为基本是纯数学，感兴趣的话再自己打开看吧！ ### 7.4.3 Attention机制中点积操作的矩阵运算 7.3中，我们在seq2seq里首次提到了注意力机制，我们知道了在Attention机制中，点积操作用于计算输入序列和输出序列中每个位置的相关性得分。在seq2seq里参与点积的分别是Encoder中每个时间步的隐状态和Decoder中每个时间步的隐状态。 假设我们有两个矩阵：目标序列构成的矩阵 $$\mathbf{X} = [\mathbf{x}_1,\mathbf{x}_2,\ldots,\mathbf{x}_T]$$ 和查询序列构成的矩阵$$\mathbf{Y} = [\mathbf{y}_1,\mathbf{y}_2,\ldots,\mathbf{y}_J]$$，其中 $$\mathbf{x}_i$$ 和 $$\mathbf{y}_j$$ 分别表示两个序列中的向量。在更普遍的注意力机制中，我们需要计算每个查询向量 $$\mathbf{y}_j$$与目标序列中每个位置的相关性得分。为此，我们可以定义一个注意力得分矩阵 $$\mathbf{A} \in \mathbb{R}^{J \times T}$$ ： $$\begin{bmatrix} a_{1,1} & a_{1,2} & ... & a_{1,T} \\ a_{2,1} & a_{2,2} & ... & a_{2,T} \\ … & … & … & … \\ a_{J,1} & a_{j,2} & ... & a_{J,T} \end{bmatrix}$$ 其中，矩阵的第一行的每一个元素分别代表$$\mathbf{y}_1$$分别和 $$[\mathbf{x}_1,\mathbf{x}_2,\ldots,\mathbf{x}_T]$$ 中的每个元素做点积得到的标量，第k行的每一个元素就分别代表查询序列的$$\mathbf{y}_k$$分别和目标序列的元素们 $$[\mathbf{x}_1,\mathbf{x}_2,\ldots,\mathbf{x}_T]$$做点积得到的标量了。 $$\mathbf{A} \in \mathbb{R}^{J \times T}$$ = $$\mathbf{Y} $$ \* $$\mathbf{X}^T $$ 前面提到了，点积的结果反映了两个同维向量的相似程度。那如果对矩阵$$\mathbf{A} \in \mathbb{R}^{J \times T}$$ 的每一行都做Softmax，每一行其实就是“查询序列的$$\mathbf{y}_k$$和目标序列的某一个元素是相关的”的概率的分布。 $$softmax\begin{bmatrix} a_{1,1} & a_{1,2} & ... & a_{1,T} \\ a_{2,1} & a_{2,2} & ... & a_{2,T} \\ … & … & … & … \\ a_{J,1} & a_{j,2} & ... & a_{J,T} \end{bmatrix}=softmax（\mathbf{Y}*\mathbf{X}^T）$$ 因此注意力机制的计算过程其实很简单，就是两个矩阵的乘法运算。 后续在Transformer的自注意力层中，我们还会再见到类似的操作，他们发生在Key矩阵和Query矩阵之间。 *** # 8. RNN时代的BERT和GPT！Semi-Supervised Sequence Learning: 怎么用大量无标注样本去做自监督学习？（2015）  ***自监督学习：对于样本x，自动生成一个输入x'和该输入理应对应的输出x''（往往是Ground Truth）。模型根据x'输出了y，而后y和Ground Truth x''做交叉熵损失函数，而后反向传播。*** 在这一章中我们要介绍一篇很重要的论文。我们知道，GPT的全称是Generative **Pretrained** Transformer；2018，GPT和BERT的提出把NLP带入了**预训练**的时代。那么什么是预训练？什么是我们经常说的预训练+微调（Fine-tuning）的范式？在第8、第9章，我们会讲明白这些事。 用半监督学习/自监督学习去预训练一个语言模型是RNN时代NLP的一个非常天才的想法。具体论文参考：[半监督学习（Semi-supervised Sequence Learning)](https://arxiv.org/abs/1511.01432)。**下面这段是文章的摘要：** > We present two approaches that use unlabeled data to improve sequence learning with recurrent networks. The first approach is to predict what comes next in a sequence, which is a conventional language model in natural language processing. **The second approach is to use a sequence autoencoder, which reads the input sequence into a vector and predicts the input sequence again.** These two algorithms can be used as a "**pretraining**" step for a later supervised sequence learning algorithm. In other words, **the parameters obtained from the unsupervised step can be used as a starting point for other supervised training models.** In our experiments, we find that long short term memory recurrent networks after being **pretrained&#x20;**&#x77;ith the two approaches are more stable and generalize better. With **pretraining**, we are able to train long short term memory recurrent networks up to a few hundred timesteps, thereby achieving strong performance in many text classification tasks, such as IMDB, DBpedia and 20 Newsgroups. *#这篇论文的价值非常高，在那个Transformer模型还没有出现的2015年，RNN统治NLP的年代，它率先给出了基于无标签样本做自监督学习从而预训练一个RNN的范式。我认为它就是RNN时代的BERT和GPT。* ## 8.1 预训练模型（Pre-trained Model，PTM) *#Note：预训练不一定是无监督的，但通常情况下预训练是指在大规模数据集上进行无监督的预训练。* ### 8.1.1 迁移学习Transfer Learning * 迁移学习（Transfer Learning）是一种机器学习技术，通过将在一个领&#x57DF;**（源领域）**&#x4E2D;训练好的模型应用到另一个领&#x57DF;**（目标领域）**&#x4E2D;，从而改善另一个领域的学习性能，加速在新领域中的学习过程。 * 在传统机器学习中，通常需要在目标领域中收集大量的数据并训练针对目标场景模型，但目标场景的标注数据可能是稀缺的。迁移学习利用了在源领域中学到的知识，通过从一个领域向另一个领域传递知识，可以解决在目标领域数据稀缺、标注困难或者模型难以收敛等问题。 ### 8.1.2 为什么要有预训练？ *#迁移学习和预训练是密切相关的概念，预训练可以被视为是迁移学习的一种特定形式。* **预训练**是指在一个大规模的数据集上训练一个神经网络，并将训练好的模型参数作为下游任务的初始参数。 其中，在大规模的数据集上，我们可以让神经网络学到很多共性信息；而后，在这些共性信息的基础上（以之前用共性信息训练出来的模型的参数，对现在的下游任务的模型进行参数初始化），再学习一些小规模的垂直细分的数据，从而让模型能够去胜任一些特定的任务。 下面的文字引自：[【NLP预训练】深入理解“预训练”语言模型](https://zhuanlan.zhihu.com/p/159620066) By [潘小小](https://www.zhihu.com/people/pan-xiao-xiao-66-14) > 如果想用一句话讲清楚“预训练“做了一件什么事，那我想这句话应该是“使用尽可能多的训练数据，从中提取出尽可能多的共性特征，从而能让模型对特定任务的学习负担变轻。” > > 如果用一句话来概括“预训练”的思想，那么这句话可以是： > > 1. 模型参数不再是随机初始化，而是通过一些任务（如语言模型）进行预训练 > > 2. 将训练任务拆解成共性学习和特性学习两个步骤 ### 8.1.3 预训练模型用于下游任务的策略：固定特征提取器 *#将预训练好的模型用于下游任务通常有两种策略，一种是固定特征提取器，一种是基于微调。* * 固定特征提取器（Fixed Feature Extractor），即将预训练好的模型的权重冻结，只使用其特征提取器提取下游任务数据的特征，然后将这些特征输入到下游任务的模型中进行训练。总之，冻结原来的参数，只训练一个新的分类层。这种策略适用于下游任务的数据量较少的情况，可以避免过拟合。 在CV里，大家经常把预训练好的CNN作为特征提取器用于各种下游任务场景。第三章里提到，CNN是一种CV里非常常用的模型，通常使用大规模的有标注图像数据集（eg. ImageNet）进行预训练，从而学习到通用的特征表示。 预训练好的CNN模型可以作为一种通用的特征提取器。做法如下： 1. 在下游任务中，使用预训练好的CNN模型作为特征提取器，将输入图像经过CNN模型得到高维的特征向量。 2. 在特征向量的基础上，训练一个新的分类器、检测器或分割器等，以适应新的任务要求。 3. 对于图像分类任务，可以使用全连接层或者SVM等简单的分类器；对于目标检测任务，可以使用锚框（anchor）和区域提取网络（Region Proposal Network，RPN）等技术；对于图像生成任务，可以使用生成对抗网络（Generative Adversarial Networks，GAN）等模型对特征向量进行生成。 ### 8.1.4 预训练模型用于下游任务的策略：Fine-Tuning **微调（Fine-tuning)**&#x662F;一种迁移学习方法，指在预训练模型的基础上，对部分或全部的参数进行微小的修改，以适应新的任务。微调一般是在有监督学习的框架下进行的。 ***微调过程通常包括：*** 1. 预训练模型的参数通常被初始化为预训练时的值 2. 使用下游垂直任务的标注数据来对模型进行进一步的训练，并调整模型的超参数和学习率等参数。以适应特定的任务模型。*Note：这个过程中，我们会采用一些针对下游任务的目标函数。* 3. 在训练的过程中，逐步调整参数，以最小化下游任务的损失函数，从而在特定任务上表现更好。 预训练模型的权重在新数据上进行训练微调可以在整个神经网络上完成，也可以只在一部分神经网络层上完成。在这种情况下，我们称未被微调的层&#x88AB;**“冻结”（Frozen），**&#x5373;在反向传播步骤中不更新。 ***微调是一个比较复杂的工程，需要很多工程know-how：*** 1. 过拟合（主要挑战）：微调通常涉及到在相对较小的数据集上训练预训练模型，因此很容易发生过拟合，从而在未见过的数据上产生较差的性能。 2. 数据集：微调需要大量的标注数据，而这些数据应该具有代表性和多样性，能够充分反映下游任务的特征。 3. 超参数调整：微调需要对模型的各种超参数进行调整，例如学习率、batch size、正则化等，以适应下游任务。 4. 优化算法：优化算法就是决定在更新参数时如何调整步长、方向等因素，以最小化损失函数的值。随机梯度下降是最常见的优化算法。微调时，模型可以采用与预训练时相同的优化算法，或者根据下游任务的特点选择不同的优化算法。 ### 8.1.5 为什么在NLP中迟迟没有出现类似CV预训练的范式？ ***Q：2018年前，迁移学习在NLP中的运用情况如何？*** 我们知道，直到2018年，ULM-FiT、GPT和BERT模型的出现才开启了NLP预训练模型的时代，才真正实现了CV领域那样的迁移学习方法在NLP领域的应用。那么，是不是说2018年前NLP领域就没有迁移学习呢？ 答案是，这个说法是非常不准确的！就如我们在6.4.3里预告的，word2vec其实就是NLP中迁移学习运用的祖师爷，它可以利用大规模的未标注文本数据进行训练，从而可以学习到非常通用的单词向量表示。由于word2vec的成功，迁移学习范式已经成为了NLP领域的标配！ ***Q：那为什么我们会说，NLP一直没有一个类似CV的迁移学习范式？*** * 这是因为，虽然word2vec是将迁移学习引入NLP领域的先驱之一，但是它主要关注的是单词级别的表示学习，而不是针对具体任务的模型迁移。也就是说，在面对一个NLP任务的时候，word2vec可以让我们快速解决从词元到词嵌入的那两层神经网络（对于一个包含V个单词的词典，如果我们用N维稠密向量来表示每一个词，那么word2vec模型其实就是压迫去学习一个V×N的矩阵），但也仅此而已了。很长一段时间内，NLP研究者们依然需要针对每个具体的NLP任务训练不同的模型。 > NLP中虽然也有一些预训练模块，比如预训练词向量，然后用到具体的NLP任务中，但也仅仅是将词向量作为下游模型的输入。在NLP中，并没有一个基础模型（包括模型的结构、权重等），能把整个基础模型迁移到下游任务进行微调，现在都是针对不同的问题设计专门的网络结构，比如POS、NER、NMT等，处于不同任务各自为政的局面。——Beeder in [CS224N(3.5)Multitask Learning | bitJoy](https://bitjoy.net/2020/03/14/cs224n%ef%bc%883-5%ef%bc%89multitask-learning/) * 相比之下，在CV中，迁移学习经常是基于模型层级的。在解决一个新的CV任务时，大部分特征提取的工作都可以用以前预训练完的CNN做完，工程师只需要给原来的CNN加一层全连接层，或者做Fine-tuning，就可以了。像CV领域那样如此方便的使用预训练模型来进行迁移学习一直是NLP领域研究人员的一个愿望。 ***Q：那为什么模型迁移这件事在NLP迟迟没有发生？*** **CV：图像数据集巨大，而且任务几乎都是以分类为基础** * 在计算机视觉领域中，图像数据集非常大且丰富，例如ImageNet数据集就包含了数百万张图像。很多模型都会在ImageNet上预训练，然后迁移到具体的任务中进行微调。 * 这种方式能够成功的原因是很多CV任务几乎都是以分类为基础任务，分类相当于CV的积木（building block），所以在ImageNet上训练的CNN分类模型迁移到其他CV任务中能起到很好的提升效果 **NLP：预处理文本数据成本非常高，而且任务种类繁多** * 文本数据通常需要进行分词、词性标注、命名实体识别等预处理步骤，这成本实在是太高了，所以自然语言数据集往往都比较小。 * 语言本身的复杂性增加了预训练模型的训练难度。在6.2中我们提到了很多NLP的基本任务，在6.3.3中我们提出了对语言模型的诸多期待，这些都足以体现语言有多复杂，它不像CV一样几乎都以识别+分类为目的。 * 因此，在NLP领域中，早期的研究主要集中在手工设计特征和模型架构上，例如基于词袋模型和n-gram模型的文本分类方法，以及基于递归神经网络和长短时记忆网络的序列建模方法。由于没有一个普适的、可以即插即用的预训练模型，NLP的学者们花了很多时间重复造轮子，相较于CV，研究一直处在一个很初级的阶段。 ## 8.2 论文模型结构：序列自编码器和语言模型 在我们要介绍的这篇论文中，作者设计了两个方法来预训练一个LSTM网络。 > We present two approaches that use unlabeled data to improve sequence learning with recurrent networks. The first approach is to predict what comes next in a sequence, which is a conventional language model in natural language processing. The second approach is to use a sequence autoencoder, which reads the input sequence into a vector and predicts the input sequence again. 如果用语言模型的预训练参数来初始化LSTM，那么它就叫LM-LSTM；如果用序列自编码器的预训练参数来初始化LSTM，那么它就叫SA-LSTM。 *** ### 8.2.1 语言模型 LM-LSTM 语言模型非常好理解，无非是基于一个已有的词序列，做下一个词的预测。 > 希望大家在这里不要混淆一个概念，即语言模型。语言模型不只是一个最终的模型（Like GPT-3)，语言模型它就是预训练任务本身！**语言模型即“预测下一词”，它本身就是一个很重要的预训练任务。** * 一个标准的LSTM语言模型由三个部分组成：输入层、LSTM层和输出层。输入层接收输入序列，将其转换为嵌入向量。LSTM层是一个标准的LSTM单元，它接收输入向量序列，生成相应的隐藏状态序列。输出层将LSTM层的隐藏状态作为输入，并生成每个时刻的下一词预测。 * 与标准的LSTM模型不同的是，LM-LSTM还包括一个语言模型的部分，用于在无监督的方式下预测文本序列。因为是自监督学习，一开始就有一个完整的词序列，所以LM-LSTM使用双向了LSTM来生成每个时刻的上下文向量，然后使用这些向量作为输入来预测当前时刻的单词。这个语言模型可以被用于在半监督学习中，利用未标注的文本数据来预训练LM-LSTM模型。 ### 8.2.2 序列自编码器 Sequence Autoencoder #### 8.2.2.1 序列自编码受到了seq2seq的启发 序列自动编码方法受到seq2seq工作的启发。<前文提到了seq2seq在NMT的运用。事实上，seq2seq是一个很强大的方法，还可以用于文本解析、图像字幕、视频分析、语音识别和对话建模等等。> seq2seq方法的关键是使用递归网络作为编码器，将输入序列读入隐状态，作为预测输出序列的解码器递归网络的输入。在中译英的神经机器翻译中，编码器编码中文，解码器试图重构原序列为英文。***那么可不可以这样：不让解码器去生成一个新的东西，而是试图利用编码器编码的向量，去重构原来的序列自身呢？*** 序列自动编码器就是这样子的思路。相较于传统的seq2seq，序列自编码器是一个无监督的学习模型，其目的是重建输入序列本身（这样就可以在不需要任何额外标注的情况下计算出损失函数，进行梯度下降）。在序列自动编码器中，**解码器网络和编码器网络的权重参数是共享（相同）的**。 #### 8.2.2.2 序列自编码器的无监督特性 序列自动编码器的一个重要特性是它是无监督的，因此可以用大量的未标记的数据来训练以提高其质量。论文的结果是，额外的无标签数据可以提高递归网络的概括能力。  序列自编码器产生了怎么样的效果呢？参考下文： > We find that the weights obtained from the sequence autoencoder can be used as an initialization of another supervised network, one which tries to classify the sequence. We hypothesize that this is because the network can already memorize the input sequence.&#x20; 也就是说，通过无监督学习训练的序列自动编码器得到的权重，可以作为另一个基于有监督学习的序列分类网络的初始化参数，这可能是因为序列自编码器的RNN网络记住了喂给它的序列们。 ### 8.2.3 半监督预训练：利用有标注和无标注数据联合训练 * **半监督（Semi-supervised)预训练**，指同时利用有标注数据和无标注数据来进行预训练。半监督预训练的目标是利用有标注数据来辅助无标注数据的学习，从而提高模型的性能。 * 以LM-LSTM为例，LM-LSTM模型可以同时处理带标签和不带标签的数据，通过联合训练来提高模型性能。如果我们要训练一个用于序列标注的LSTM，那么LM-LSTM模型可以使用带标签的数据来训练序列标注任务，并使用未标注的数据来训练语言模型部分。通过联合训练，LM-LSTM模型可以从未标注的数据中学习到更多的特征表示，从而提高序列标注任务的性能。 *** # 9. 欢迎来到芝麻街家族！图解 ELMo：Embedding的新纪元（2018.2）  *图中这位就是大名鼎鼎的ELMo啦！这里是ELMo的诞生：[【arxiv】Deep contextualized word representations](https://arxiv.org/abs/1802.05365)。Hi ELMo！*  *ELMo是美国家喻户晓的动画Sesame Street（芝麻街）的角色。* *后续的BERT是芝麻街动画系列的另一个角色，他们开创了NLP的芝麻街系列文章，大家一起对着芝麻街的角色们**硬凑**模型名儿～* <那只蓝色的Cookie Monster目前还没有人凑出来，等你来凑🥳！不过这篇文档中，我们会用它来代表ULM-FiT。> ## 9.1 ELMo模型的意义 > 第二代预训练模型以context-aware为核心特征，也就是说“苹果”这个词在分别表示水果和公司时，对应output是不一样的，其中具有代表性的有ELMo, GPT, BERT等。 ELMo is short for **E**mbeddings from **L**anguage **Mo**del。这个名字看起来真的很像是在硬凑，还是论文的标题Deep contextualized word representations更可以体现它的真正意义。 > \#大量参考了CSDN用户@Anna翻译的这篇文章：[图解BERT、ELMo(NLP中的迁移学习)| The Illustrated BERT, ELMo, and co._nlp 迁移学习_Ann's Blog的博客-CSDN博客](https://blog.csdn.net/qq_36667170/article/details/125714948?spm=1001.2014.3001.5501) ### 9.1.1 word2vec的局限性 前文提到了word2vec模型是一种可以用于各种任务的单词级别的表示学习。类似的还有GloVe。 以单词`stick`为例子，它有非常非常多个意思：  如果我们使用word2vec、GloVe的那些词嵌入，那么不管stick的上下文是什么，单词`stick`都将由同一个向量表示。也就是说，我们对一个词只有一个词嵌入，哪怕这个词其实有超级多的意思。 这其实还挺蠢的。所以就有很多学者站出来说：*“stick有多种意思，而它的意思则取决于他的上下文。“Let's stick to”和“he pick up a stick so that”中的stick显然是两个意思，却用了同一个词向量。为什么我们不根据上下文语境进行embedding呢？这样既能捕捉该语境中的含义，又捕捉其他语境信息。”* ### 9.1.2 语境化词嵌入 语境化词嵌入可以根据词语在句子语境中的含义赋予词语不同的embedding。 在问ELMo，stick的词嵌入是什么的时候，ELMo是不会像word2vec一样给我们一个肯定的答案的，因为ELMo没有对每个单词使用固定的词嵌入，而是在为每个单词计算embedding之前考虑整个句子。  ELMo模型使用的是特定任务上训练好的双向LSTM（bi-LSTM）进行词嵌入。 ## 9.2 ELMo模型的结构 参考资料：[一个介绍ELMo论文的PPT](https://www.slideshare.net/shuntaroy/a-review-of-deep-contextualized-word-representations-peters-2018) [【自然语言处理】ELMo, GPT等经典模型的介绍与对比 ](https://blog.csdn.net/weixin_39574469/article/details/119741048?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522168208647816800186569091%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D\&request_id=168208647816800186569091\&biz_id=0\&utm_medium=distribute.pc_search_result.none-task-blog-2~all~top_positive~default-1-119741048-null-null.142^v86^control_2,239^v2^insert_chatgpt\&utm_term=ELMo\&spm=1018.2226.3001.4187) By CSDN用户 [张小猪的家](https://blog.csdn.net/weixin_39574469)&#x20;  > * 从上面的架构图中可以看到, 宏观上ELMo分三个主要模块： > > * 最底层黄色标记的Embedding模块. > > * 中间层蓝色标记的两部分双层LSTM模块. > > * 最上层绿色标记的词向量表征模块. ### 9.2.1 字符嵌入层（Character Embeddings Layer） ELMo模型使用字符嵌入来表示每个词语，这是通过卷积神经网络来实现的。 ELMo模型中的CNN主要用于从输入文本中提取字符级别的特征，这些特征可以捕捉到单词中的前缀和后缀信息，从而提高词向量的表达能力。具体来说，ELMo使用了一个具有多个卷积核的卷积层，每个卷积核对应一个不同的字符级别窗口大小，通过对输入文本进行卷积操作，可以提取出每个字符级别窗口中的特征。这些特征经过池化和拼接操作后，可以形成一个与输入文本相同长度的字符级别特征向量，作为LSTM网络的输入之一。 CNN在NLP中的应用可以见：[CS224N(2.12)Convolutional Networks for NLP | bitJoy](https://bitjoy.net/2019/08/05/cs224n%ef%bc%882-12%ef%bc%89convolutional-networks-for-nlp/) By Beeder。 ### 9.2.2 双向LSTM层（Bidirectional LSTM Layer） ELMo模型使用双向LSTM（Bi-LTSM）来捕捉词语在上下文中的语义信息。Bi-LSTM分别从左向右和从右向左对输入序列进行扫描，可以同时考虑到前向和后向的上下文信息，从而生成上下文相关的词向量。 *<注意，后面我们会提到的BERT也会是称为Bidirectional，但我们会发现这两者并不一样。>* 在ELMo模型中，Bi-LSTM层由两个独立的LSTM单元组成，分别从前向和后向两个方向对输入文本进行建模，形成了两个独立的隐藏状态序列。 > * ELMo的这一模块分为左右两部分, 本质上就是一个双向LM： > > * 对于左半部分, 给定了N个tokens\[t1, t2, …, tN]， Language Model通过前面k-1个位置的token序列来计算第k个token出现的概率, 构成前向双层LSTM模型. > > * 同理, 对于架构中的右半部分, 给定了N个tokens\[t(k+1), t(k+2), …, t(N)], Language Model通过后面N-k个位置的token序列来计算第k个token出现的概率, 构成后向双层LSTM模型. 而后，将前向和后向LSTM单元的隐藏状态序列进行合并，形成了一个包含了双向上下文信息的隐藏状态序列。 ### 9.2.3 上下文相关词向量层（Contextualized Word Embeddings Layer） ELMo模型通过将字符嵌入和双向LSTM层的输出进行拼接，并通过一个线性变换得到最终的上下文相关词向量。这些词向量可以根据输入句子的不同上下文进行调整，从而捕捉到不同上下文中词语的语义信息。 ### 9.2.4 输出层（Output Layer） ELMo模型可以通过在上下文相关词向量上添加任务特定的输出层，如全连接层、Softmax层等，来进行具体的NLP任务，如文本分类、命名实体识别等。 因为ELMo给下游提供的是每个单词的特征形式, 所以这一类预训练方法被称为"Feature-based Pre-Training". ## 9.3 总结ELMo ELMo的本质思想就是根据当前上下文对word embedding进行动态调整的语言模型。它总体上采用了双向双层LSTM的结构，而且用了一个两阶段过程来做预训练： 第一阶段: 利用语言模型进行预训练, 得到基础静态词向量和双向双层LSTM网络. 第二阶段: 在拥有上下文的环境中, 将上下文输入双向双层LSTM中, 得到动态调整后的word embedding, 等于将单词融合进了上下文的语义, 可以更准确的表达单词的真实含义。 > ELMo在传统静态word embedding方法(Word2Vec, GloVe)的基础上提升了很多, 但是依然存在缺陷, 有很大的改进余地。主要有以下两点： > > 第一点: 一个很明显的缺点在于特征提取器的选择上, ELMo使用了双向双层LSTM, 而不是现在横扫千军的Transformer, 在特征提取能力上肯定是要弱一些的. 设想如果ELMo的提升提取器选用Transformer, 那么后来的BERT的反响将远不如当时那么火爆了. > > 第二点: ELMo选用双向拼接的方式进行特征融合, 这种方法肯定不如BERT一体化的双向提取特征好. > > By CSDN用户 [张小猪的家](https://blog.csdn.net/weixin_39574469)&#x20; *** # 10. Attention is All You Need！大语言模型的基石Transformer（2017） ***需要的先验知识：[Seq2seq与Attention机制](https://s3tlxskbq3.feishu.cn/docx/NyPqdCKraoXz9gxNVCfcIFdnnAc#ZWSwdmWQaoGAQuxkOEHcuD5UnVl)*** *#多年以后，面对AGI时，NLP从业者们会想起Google带他们去看变形金刚的那个遥远的下午。* *#你说的对，但「Transformer」是谷歌自主研发的一款全新开放世界冒险游戏，中间忘了，总之就是被AGI选中的人要导引多头注意力之力，逐步发掘「大力出奇迹」的真相。* 说来，为什么发布Transformer的文章名字叫[Attention Is All You Need](https://arxiv.org/abs/1706.03762) 呢？这是因为，在seq2seq把Attention机制发扬光大后，NLP领域的模型的主流架构是递归神经网络（一般是LSTM）+注意力机制，后者起到一个辅助作用。然而，LSTM再怎么样都不过是一个变种RNN，难以并行训练、发挥GPU的优势这件事让他们训练效率很慢，自然不存在大力出奇迹造出一个超级大的语言模型的可能性。 Transformer模型非常非常的激进，他直接抛弃了作为模型主体的RNN，只保留了注意力机制。这就是这个标题的由来。*不得不说搞NLP的研究者们还是很笨蛋的，Attention is All You Need这篇文章牛逼了之后，大家纷纷蹭热度发文XX is All You Need，发表的论文只要采取了这个格式的标题，就很容易上热榜🤯。拒绝蹭热度从我做起！*  *你就是那个解决了RNN串行训练的效率问题，在深度学习领域横扫千军的Transformer？*（Google团队好像本来是想取变压器的意向。但是大家看到这词儿想到的都是变形金刚……）  *不好意思，打扰了，是这张！模型架构乍一看有点难懂，但是没关系，我们后面会把它给讲清楚的！* ## 10.1 Transformer的整体结构 上面那张图展示的就是Transformer的整体结构了，但乍一看会太过复杂。让我们先看下面这张图：  *图源[【知乎】Transformer模型详解（图解最完整版）](https://zhuanlan.zhihu.com/p/338817680)，By 知乎用户[初识CV](https://www.zhihu.com/people/AI_team-WSF)* 在万恶之源[Attention Is All You Need](https://arxiv.org/abs/1706.03762) 之中，原版的Transformer有六个编码器和六个解码器，是一个比较深的网络结构。可以看到，最开始的时候，Transformer主要用于神经翻译任务,所以这里先用神经翻译任务举例子。后面我们会看到对Transformer的一些魔改（Encoder-Only or Decoder-Only），从而将其用于文本生成（GPT）或者各种其他下游任务（ BERT）。 ### 10.1.1 编码器结构：Self-Attention层 + 前馈神经网络层 从这里开始，我们引用的图基本都来自[图解transformer | The Illustrated Transformer](http://t.csdn.cn/YFjLF) By Ann's Blog。  > 6个编码器组件的结构是相同的，但是他们之间的权重是不共享的，每个编码器都可以分为2个子层。 > > 编码器的输入($$x_i$$)首先会进入一个自注意力层，这个注意力层的作用是：当要编码某个特定的词汇的时候，它会帮助编码器关注句子中的其他词汇。之后会进行详细讲解。 > > 自注意力层的输出（$$z_i$$）会传递给一个前馈神经网络，每个编码器组件都是在相同的位置使用**结构相同（每个Encoder中的FFNN结构相同但参数不同）**&#x7684;前馈神经网络。 ### 10.1.2 解码器结构：带掩码的Self-Attention层 + Self-Attention 层+一个前馈神经网络 解码器组件也含有前面编码器中提到的两个层，区别在于这两个层之间还夹了一个注意力层，多出来的这个自注意力层的连接了编码器输出的隐状态，起到了和seq2seq中的attention一样的作用（如果忘了也不一定要回去复习，后面会图解的非常清楚滴）。  在解码器中，第一个Self-Attention和编码器的第一个自注意力层也是不同的。它是一个带掩码的自注意力层，带掩码的意思就是，对于一个总共有N个单词的词序列，在翻译到第K个单词时候，这个自注意力层只能注意到第1到第K个单词，而注意不到第K+1到第N个单词。后面我们会用一张图很清晰的展示什么是带掩码。 ## 10.2 编码器介绍 ### 10.2.1 Input Embedding: 怎么给Token进行编码？ #### 10.2.1.1 Word Embedding > 与其他的NLP项目一样，我们首先需要把输入的每个单词通过词嵌入（embedding）转化为对应的向量。 > > 在Attention is All You Need原文中，他们采用了512维的词嵌入，这里为了方便展示，我们用4个格子来代表512维的词向量们。  #### 10.2.1.2 Positional Encoding，PE Transformer中的编码器不只采用了词嵌入本身的Embedding，还为每个词基于位置额外增加了一个Embedding（Positional Encoding），它的维度和词嵌入是一样的。最终输入给Transformer的是两个嵌入向量的和。 这是因为Transformer激进地放弃了自带时序处理能力的RNN，而Attention本身又是不会有时序信息的（用自注意力实现全局，不等于拥有时序信息！全局不等于时序）。 > Transformer 不采用 RNN 的结构，使用全局信息，不能利用单词的顺序信息，而顺序信息对于 NLP 来说又非常重要。所以 Transformer 中使用位置 Embedding 保存单词在序列中的相对或绝对位置。 通过Positional Encoding，模型可以确定每个单词的位置或不同单词之间的距离。  位置编码需要做到：每个位置对应的编码唯一；不论句子有多长，每两个相邻位置之间的距离都一样；所有的编码都要在一个有限的区间内，编码用到的数字不能爆炸上升（这其实真的很难做到！）。 > 具体的，Transformer里的位置编码是这样做的： > >  > > 它是一个和词嵌入同维的、sin和cos交替的向量。 更详细的解释可参考：[【CSDN】Transforme 结构：位置编码详解](https://lolitasian.blog.csdn.net/article/details/124336971) By Anna's Blog。不过我觉得不是搞学术的人就没必要特地去学这个了。 ### 10.2.2 Self-Attention层：细说自注意力机制 7.3.3里，我们提到过注意力机制的作用。这里我们再提一次。 > Say the following sentence is an input sentence we want to translate: > > ”`The animal didn't cross the street because it was too tired`” > > What does “it” in this sentence refer to? Is it referring to the street or to the animal? It’s a simple question to a human, but not as simple to an algorithm. > > When the model is processing the word “it”, self-attention allows it to associate “it” with “animal”. > > As the model processes each word (each position in the input sequence), self attention allows it to look at other positions in the input sequence for clues that can help lead to a better encoding for this word. > > If you’re familiar with RNNs, think of how maintaining a hidden state allows an RNN to incorporate its representation of previous words/vectors it has processed with the current one it’s processing. Self-attention is the method the Transformer uses to bake the “understanding” of other relevant words into the one we’re currently processing. 为了与Jammar的科普文[The Illustrated Transformer](http://jalammar.github.io/illustrated-transformer/)保持同步（并且继续用它画的高质量的图❌），我们用原文举例子的短句（`Thinking Machine`）作为例子，看看在编码器的每个子层中发生了什么。 #### 10.2.2.1 对Encoder的每个输入矩阵都计算三个矩阵：Query， Key，Value 7.4.3中，我们介绍了注意力机制的点积操作本质上其实是两个矩阵的运算（而矩阵运算是高度并行的，在GPU上训练起来非常的快）。不过我们可以暂时忘掉矩阵的事情，先从向量层级去关注都发生了些什么。 *#自注意力层为什么叫自注意力层呢？* *在之前的seq2seq注意力机制里，两个做点积来计算Attention Score的向量分别在编码器和解码器里，而Transformer的自注意力层里，两个做点积的向量都是源自编码器（或者解码器）。* 对每一个输入的向量（512维），我们把它乘一个512\*64的权重矩阵，最后就会得到一个64维的向量。 （前面提到了，四个格子代表了512维的向量，这个习惯我们在后续也都会保持。如右图所示，Q、K、V中的向量都是三个格子，三个格子代表的就是一个64维的向量。后面都会是这样！） 在编码器的自注意力层中，我们训练三个权重不共享的512\*64的矩阵：$${W}^Q$$、$${W}^K$$、$${W}^V$$。对编码器的每个输入向量，都分别乘以这三个矩阵，计算出三个64维的向量：Query向量，Key向量和Value向量。  #### 10.2.2.2 计算注意力得分：Query和Key的点积  在Transformer的自注意力层里，假设输入的Embedding有N个：$$[x_1,x_2,...,x_N]$$，对于第k个输入$$x_k$$,进行点积的向量分别为：$$x_k$$对应的查询向量$$q_k$$,以及全部N个输入对应的向量：$$k_1，k_2,...,k_k,...,k_N$$。 以Thinking Machine个两个词的输入为例，Thinking的查询向量$$q_1$$会分别和句子中所有的输入（$$x_1$$、$$x_2$$）对应的Key向量（$$k_1$$、$$k_2$$）做点积，得到Thinking这个词对于句子中的每一个词的注意力得分。 #### 10.2.2.3 计算注意力分布 Attention Disrtibution 标准的计算注意力分布的方法就是对注意力得分做一个Softmax。不过在原版的Transformer中，作者们先把注意力得分除以了一个8（Q、K、V向量的维度的根号值）。这是因为两个64维向量做点积算出来的标量还是很大的，如果不做额外的处理就直接去softmax的话，会导致Attention Distribution高度集中于当前位置的单词，但这显然不是我们想要的，我们还是想知道当前的单词和其他各种单词的联系。总之，这里的除以8更多的其实是一种基于实践的工程经验。  #### 10.2.2.4 将Value矩阵与注意力分布矩阵相乘，得到最后的Output 7.3.3.2里我们提到过，既然注意力分布是一个概率密度函数，那注意力输出$$a_t$$其实很类似数学期望。 Transformer中的自注意力层也是一样，都是数学期望的思维。上一步我们计算出Attention Distribution为P(Thinking)=0.88、P(Machine)=0.12，在最后我们会用这个概率分布乘以对应的单词的Value向量。  最终单词 Thinking的输出 $$v_1$$等于所有单词 的值 $$v_1$$、$$v_2$$根据 attention 系数的比例加在一起得到： $$z_1=0.88v_1+0.12v_2$$ #### 10.2.2.5 利用矩阵快速并行计算整个输入的注意力分布 12.2.2.1～12.2.2.4中，我们用向量级别的运算来举例子，现在我们讲讲怎么快速用矩阵运算计算出整个输入序列的全部z向量。 参考下图，绿色的矩阵X的第一、第二行就分别是Thinking、Machine对应的Embedding。对于一个有N个Token的序列输入，相比于让一个一个512维的向量去乘以512\*64的权重矩阵，我们可以直接用N\*512的矩阵去和另一个512\*64的矩阵做乘法，最后得到一个N\*64的矩阵。 参考下图，紫色矩阵的第一、第二行分别是Thinking、Machine对应的Query。K和V都是同理。  *<这张图解决了10.2.2.1中的运算过程>* 7.4.3中，我们介绍了注意力机制的点积操作本质上其实是两个矩阵的运算，在seq2seq里我们用查询矩阵（解码器中每个时间步的隐状态 $$s$$）去和目标矩阵（编码器中所有时间步的隐状态 $$h$$）的转置做乘法运算，而后softmax一下（指的是对每一行都softmax），让每一层都是一个概率密度分布，而后再用这个softmax后得到的矩阵乘以目标矩阵自身（编码器中所有时间步的隐状态 $$h$$）。 Transformer中区别在于，查询矩阵$$Q$$和目标矩阵的转置$$K^T$$做了乘法，除以了8以后，再乘上每个单词对应的价值向量构成的矩阵$$V$$。最终得到的Z矩阵里，第一行、第二行就分别是Thinking和Machine的$$z_1$$、$$z_2$$了。  *<这张图解决了10.2.2.2～10.2.2.4中的全部运算过程>* 矩阵的乘法运算并行性非常强，训练起来是非常快的！ >  ### 10.2.3 图解多头自注意力机制 10.2.2里我们讲明白了Self-Attention，那什么是Multi-Head呢？ > The paper further refined the self-attention layer by adding a mechanism called “multi-headed” attention. This improves the performance of the attention layer in two ways: > > 1. It expands the model’s ability to focus on different positions. Yes, in the example above, z1 contains a little bit of every other encoding, but it could be dominated by the actual word itself. If we’re translating a sentence like “The animal didn’t cross the street because it was too tired”, it would be useful to know which word “it” refers to. > > 2. It gives the attention layer multiple “**representation subspaces**”. As we’ll see next, with multi-headed attention we have not only one, but multiple sets of Query/Key/Value weight matrices (the Transformer uses eight attention heads, so we end up with eight sets for each encoder/decoder). Each of these sets is randomly initialized. Then, after training, each set is used to project the input embeddings (or vectors from lower encoders/decoders) into a different representation subspace. 我对上面这段引用自[The Illustrated Transformer](http://jalammar.github.io/illustrated-transformer/)的话的理解：首先，在翻译一个特定单词的时候，模型的注意力肯定主要关注这个词自身。我们希望翻译这个词的时候模型多去关注上下文的其他词，但上下文联系其实也有很多种，有it这样的指代、are这样的单复数、were这样的时态，或者说基于不同的上下文，一个单词自身也会有不同的意义（想起ELMo还有Stick了吗？）。如果我们多训练几个不同的权重矩阵$${W}^Q$$、$${W}^K$$、$${W}^V$$的组合，让他们各司其职，有的负责指代任务，有的负责时态任务，有的负责基于全局语境搞清楚多义&#x8BCD;**（即去探索多个不同的表征子空间）**，那是不是模型就可以取得更好的效果？ 因此，简单来说，多头注意力就是我们多训练几个权重矩阵$${W}^Q$$、$${W}^K$$、$${W}^V$$。 Attention is All You Need原文中，Transformer用了8个Attention Heads。我们先用下图展示两头注意力：  对于同一个输入Thinking Machine，我们有8个权重矩阵组，因此最终会产生8个Z矩阵：  我们将这些矩阵连接起来，形成了一个2\*512维的矩阵；然后将其乘以一个产生最终输出的权重矩阵$${W}^O$$。 下面的例子中，$${W}^O$$是一个512\*512的矩阵，最后我们得到了一个2\*512的Z矩阵，他的形状和最开始的输入一样。  ### 10.2.4 总结：自注意力层中发生了什么？ * 输入：基于one-hot，假设字典大小是30,000,那么一个词的输入就是一个30K维的向量，对应该词汇的元素会是1，其他的全部都是0。 * Embedding层：把输入的one-hot向量乘以一个矩阵后，投影到512维的词向量里，再加上一个位置嵌入。 * 自注意力层：对输入的词嵌入，乘三个权重矩阵，投影出Q，K，V。输入每一个词Qk会和输入的全部词的K1、K2、K3….Kn向量做点积（向量点积得到的是标量），得到一个n维的新向量（n就是输入的句子的长度）。对向量的元素除以8（根号64），再做一个softmax，得到一个Attention Distribution，这个分布反映了当前输入的词对句子中每一个词的相关性。而后我们对V向量以Attention Distribution为权重做一个加权，得到向量Z。向量Z里就蕴含了当前timestep下来自整个句子的各种信息。 * 多头注意力机制：多训练几个不同的权重矩阵组合，把他们最后得到的结果拼接到一起，提高信息收集维度的数量和鲁棒性。  自注意力层最终输出的一个N\*512的矩阵会输入给前馈神经网络。**嗯，所以它的形状和最开始的时候输入的矩阵是一样的**。即：一个多头自注意力层并不改变输入的东西的形状。 FFNN就是一个平平无奇的全连接层，和2.1.4中介绍的东西没有什么区别，所以就不再专门做介绍了。 它也不改变输入的东西的形状。总之，输入一个（batchsize, seq_length, embed_dim）的张量到一个Encoder Block里去，输出的也是一个同维的张量。 ## 10.3 解码器介绍 解码器的结构在10.1.2里展示过，这里不再重复。 与seq2seq一样，Transformer中的解码器本质上也是一个语言模型，它做的事情就是综合考虑当前时间步的信息和Encoder给来的信息，进行一个词一个词的自回归的输出。 既然同样是一个自回归语言模型，那么7.2.2提到的Teaching Force和计划采样、7.2.3中提到的Beam Search在Decoder中都是同样适用的。这里也不重复介绍了。  Decoder模型中的一些细节可能需要更多的输入才能讲清楚，所以现在我们试图去翻译I have a cat为中文。 ### 10.3.1 解码器的第一层：带掩码的多头自注意力层 解码器中的自注意力层和编码器中的不太一样：在解码器中，自注意力层只允许关注已输出位置的信息。所以我们称之为“带掩码的自注意力层”。 > Decoder block 的第一个 Multi-Head Attention 采用了 Masked 操作，因为在翻译的过程中是顺序翻译的，即翻译完第 i 个单词，才可以翻译第 i+1 个单词。通过 Masked 操作可以防止第 i 个单词知道 i+1 个单词之后的信息。 Mask操作主要是在Softmax的时候实现的。 如果要翻译I have a cat为中文，我们依然可以做$$Q$$和$$K^T$$做矩阵乘法的操作，这样我们会得到一个4\*4的矩阵。  一般来说，对于我们这样得到的矩阵$$\begin{bmatrix} a_{I,I} & a_{I,Have} & a_{I,a} & a_{I,Cat} \\ a_{Have,I} & a_{Have,Have} & a_{Have,a} & a_{Have,Cat} \\ a_{a,I} & a_{a,Have} & a_{a,a} & a_{a,Cat}  \\ a_{Cat,I} & a_{Cat,Have} & a_{Cat,a}& a_{Cat,Cat} \end{bmatrix}$$，直接softmax就好了，参考10.2.2.5。但是在解码器里，我们要做这样一个操作：  自注意力层只允许关注已输出位置的信息，所以对于已输出位置和未输出的位置的点积（上图中的黑色的位置），我们在softmax时会给他加上一个巨大的负值（GPT中为负一亿），好让他们在softmax后得到的结果为0。这样，在输出当前时间步的时候，解码器就不会去关注后面的单词的信息了。 最终我们得到了一个4\*64的矩阵，它会作为Query矩阵直接被输入给解码器的下一层Encoder-Decoder Attention。矩阵的第一列（I的z向量，也是下一个注意力层中 I 的查询向量）就只包含了I的信息。   *<这张图也非常直观。>* **解码器中也是多头注意力机制，所以如果是8头注意力的话，最后会产生8个这样子的矩阵。他们会作为解码器的下一层要用到的8个Query矩阵。** ### 10.3.2 解码器的第二层：多头编码器-解码器注意力层 参考右图，红框内的部分即为解码器。我们假定N为6；八头注意力。 编码器首先处理输入序列，输入序列经过了6个Encoder之后，第六个编码器会输出一个张量。该张量会被平等的送给每个Decoder的第二个注意力层，并通过一个共享参数的权重矩阵C转为8个Key矩阵和8个Value矩阵。  在这一层中，解码器组件使用自己的带掩码的第一层自注意力层产生的8个Z矩阵作为8种Query矩阵，并使用编码器传过来的8个Key和Value矩阵，来做我们前面提到过的多头自注意力的运算。  *<因为在这一层中我们不仅用到了解码器上一层的输出，还用到了编码器的输出，所以就不能叫自注意力层了>* 在经过两个多头注意力层后，最后会经过一个全连接层，然后输出一个向量给最后的Linear和Softmax层。 ### 10.3.3 解码器的最后：下一词预测 > Decoder输出的是一个浮点型向量，如何把它变成一个词？这就是最后一个线性层和softmax要做的事情。 > > 线性层就是一个简单的全连接神经网络，它将解码器生成的向量映射到logits向量中。 > > 然后，softmax层将这些分数转化为概率（全部为正值，加起来等于1.0），选择其中概率最大的位置的词汇作为当前时间步的输出。 就像seq2seq一样，transformer的解码器中当前时间步的输出会作为下一个时间步的输入。  ## 10.4 Transformer模型总结 ### 10.4.1 模型可以去调的超参数 Transformer里可以调的参数其实并不多。 1. 词嵌入的向量有几维； 2. 编码器和解码器各自有多少层。如果没有编码器，那就是Decoder-Only（GPT）；如果没有解码器，那就是Encoder-Only（BERT） 3. 有多少个注意力头。 ### 10.4.2 模型整体的前向传播步骤 **编码器：** * 输入：基于one-hot，假设字典大小是30,000,那么一个词的输入就是一个30K维的向量，对应该词汇的元素会是1，其他的全部都是0；输入一个句子的话，那就是矩阵了。 * Word Embedding层：把输入的one-hot向量乘以一个矩阵后，投影到512维的词向量里。此外还要考虑位置编码，它是一个和词嵌入同维的、sin和cos交替的向量，两者可以直接相加作为最后的输入。 * 自注意力层：对输入的词向量，乘三个权重矩阵，投影出Q，K，V。输入的第k个词的查询向量Qk会和输入的全部词的K1、K2、K3….Kn向量做点积（向量点积得到的是标量），得到一个n维的新向量（n就是输入的句子的长度）。除以8，再做一个softmax，得到一个Attention Distribution，这个分布反映了当前输入的词对句子中的每一个词的相关性。而后我们对V向量以Attention Distribution为权重做一个加权，得到向量Z。向量Z里就蕴含了当前timestep下来自整个句子的各种信息。 * 多头注意力机制：多训练几个不同的自注意力层，最后拼接到一起，提高信息收集维度的数量和鲁棒性。 * 自注意力层的输出会经过一个全连接层，生成一个向量，而后传给下一个编码器。最后一个编码器输出的向量会与权重矩阵C相乘，生成价值矩阵V和钥匙矩阵K。 **解码器：** * 带掩码的多头自注意力层：Decoder的输入里，在自注意力层中，对于当前的time step之后的单词，在softmax之前都会加一个巨大的负数，让他们的attention distribution都会是0。最终输出的张量会作为下一层的查询矩阵。因为是8头注意力，所以最后会输出8个不同的查询矩阵， * 编码器-解码器注意力层：这一层中，会用来自编码器的8个K和来自上一层的8个Q做点积操作，计算出注意力分布后再和来自编码器的8个V矩阵做加权。 * 输出：解码器以自回归的形式一个一个输出，当前的输出成为下一个输入。输出的部分可以greedy，也可以做一个beam search。 损失函数和反向传播这里就跳过了。损失函数依然是交叉熵函数。 ### 10.4.3 Transformer的牛逼之处 * Transformer 与 RNN 不同，不论是自注意力层还是全连接层都是矩阵运算，可以比较好地并行训练。在做NLP的任务时，CNN、RNN和Transformer相比，并行程度CNN大于Transformer远大于RNN，信息糅合能力RNN大于Transformer远大于CNN。Transformer它没有被任何人远大于，可能这就是它为什么牛逼吧。 * Transformer 本身是不能利用单词的顺序信息的，因此需要在输入中添加位置 Embedding，否则 Transformer 就是一个词袋模型了。 * Transformer 的重点是 Self-Attention 结构，其中用到的 Q, K, V矩阵通过输出进行线性变换得到。这件事情还是挺天才的，正经人很难想到自己和自己做点积然后再和另一个自己相乘。 * Transformer 中 Multi-Head Attention 中有多个 Self-Attention，可以捕获单词之间多种维度上的相关系数。八个注意力头在8个不同的表征子空间横扫信息，让模型学习能力非常强。 ### 10.4.4 Transformer的评价 * 它几乎被用在所有的NLP任务上，产生了类似CNN对CV的改变。 * 几乎用在了每一个模态的机器学习上，文本、图片、视频，万物皆可Transformer。 * 想要让Transformer达到和CNN、RNN一样的效果，得给他喂多得多的数据量。基于Transformer的模型都很大、很贵，虽然它在刷SOTA上所向披靡，但是CV业内其实还是CNN用的更多。 * 事实上，Attention is NOT All You Need（*`就像The Document is NOT All You Need一样，没有其他的参考文献还是不可能去扎实的掌握LLM的技术原理`*）。后续的研究中发现，Transformer中的Resnet和MLP们都起到了很大的作用，缺一不可。如果只训练多头自注意力的话，最后的效果会非常糟糕。  *<后续出现了大量的魔改Transformer，有人抛弃了Encoder只留下Decoder，有人则只用了Encoder。但不论怎样，多头自注意力机制这样天才的想法还是被得以保留>* ## 推荐学习材料 ### 推荐视频材料 * [【B站】Transformer论文逐段精读【论文精读】](https://www.youtube.com/watch?v=ugWDIIOHtPA\&t=2s)By 李沐 * [【Youtube】Transformer](https://www.youtube.com/watch?v=ugWDIIOHtPA\&list=PLJV_el3uVTsOK_ZK5L0Iv_EQoL1JefRL4\&index=60) By Hung-yee Li 李宏毅 ### 推荐文字材料 * 论文地址：[Attention Is All You Need](https://arxiv.org/abs/1706.03762) 非常简短的一篇文章，一句废话都没有，甚至到了为了限制篇幅而有很多事情没有讲明白的程度。非常不建议一上来就直接啃Paper，建议的学习路径：先跟着李沐/李宏毅的视频一起把论文过一遍，而后再去看下面推荐的文字学习资料进行学习。 * 优质学习材料：[The Illustrated Transformer](http://jalammar.github.io/illustrated-transformer/) By Jay Alammar&#x20; * 优质翻译：[图解transformer | The Illustrated Transformer](http://t.csdn.cn/YFjLF) By Ann's Blog * 讲的非常清楚的一篇知乎文章：[Transformer模型详解（图解最完整版）](https://zhuanlan.zhihu.com/p/338817680)By 知乎用户@初识CV&#x20; *** *ULM-FiT是NLP领域首次实现类CV领域的迁移学习的一个伟大尝试。知道这点其实就够了，具体的内容我先折叠了，感兴趣的话可以打开来看。* # 11. ULM-FiT与多任务学习 Multitask Learning：NLP的ImageNet时刻（2018.5） *#我还是觉得ULM-FiT是NLP的ImageNet时刻，而不是Bert。ULM-FiT的出现，让那个时代的NLP终于有了一种像CV领域一样的迁移学习方法。* 论文地址：[Universal Language Model Fine-tuning for Text Classification](https://arxiv.org/abs/1801.06146) > Inductive transfer learning has greatly impacted computer vision, but existing approaches in NLP still require task-specific modifications and training from scratch. **We propose Universal Language Model Fine-tuning (ULMFiT), an effective transfer learning method that can be applied to any task in NLP, and introduce techniques that are key for fine-tuning a language model.** Our method significantly outperforms the state-of-the-art on six text classification tasks, reducing the error by 18-24% on the majority of datasets. Furthermore, with only 100 labeled examples, it matches the performance of training from scratch on 100x more data. We open-source our pretrained models and code.  *它是Cookie Monster。ULM-FiT其实和他没有任何关系，用它来代表ULM-FiT纯粹是为了好玩儿😘！* *每次都打ULM-FiT，属实有点累了。接下来都用Cookie Monster来表示ULM-FiT啦！* ## 11.1 回顾：NLP的预训练难题 11章的最开头我们引用了ULM-FiT的论文的摘要，其中就说到了，归纳迁移学习极大地影响了计算机视觉的发展，但现有的NLP方法仍然需要针对特定任务进行修改，并从头开始训练具体的模型。 在8.1.5中我们解释了NLP领域迟迟没有出现像CV一样的Inductive transfer learning的原因：一个是数据集太少（标注成本非常高；而且网络上的语言质量参差不齐，是一种挑战）；另一个是，CV的大多数任务基本都是基于分类的，而NLP领域却有很多任务，包括基本的命名实体识别任务和句法分析任务；包括基于分类的任务，如情感分析；以及基于序列的任务，如机器翻译和自然语言生成。这些任务涉及不同的数据结构和算法，很难用同一个模型、同一个权重全部概括。 * 对于数据集太少问题，可以用利用半监督学习（Semi-supervised Learning）：用少量的有标签数据和大量的无标签数据进行训练，以提高模型的性能。这可以参考8.2中提到的LM-LSTM和SA-LSTM。 * 对于任务太多的问题，一个重要的解决方案就是12.2中我们会介绍的Multitask Learning, 多任务学习。 ## 11.2 论文关键部分选读 ### 11.2.1 基于Fine-Tuning的迁移学习在NLP领域一直不成功 * 虽然深度学习模型在许多NLP任务上达到了SOTA，但这些模型都是从头开始训练的，需要大量的数据集，而且需要几天的时间来收敛。对比隔壁的CV，他们已经很少从头开始Train Model了，基本都是基于已有的预训练模型做fine-tuning，羡慕的NLP从业者口水都流下来了🥺 * 鉴于预训练的好处，NLP领域应该能够比每次做任务都随机初始化我们模型的参数要做得更好。然而，通过微调的归纳转移对于NLP来说是不成功的。2015年，Dai和Le首次提出对语言模型（LM）进行微调（就是我们在第八章介绍的论文Semi-supervised Sequence Learning噢！），但需要数百万的in-domain documents来实现良好的性能，这严重限制了其适用性。 * 此外，语言模型容易过拟合，而且在被微调时容易出现**灾难性遗忘（catastrophic forgetting）**。 ***Hey ChatGPT，为什么在ULM-FiT之前，在NLP中用fine-tuning做迁移学习的尝试都不算成功？*** > 在 ULM-FiT 提出之前，使用微调进行迁移学习在 NLP 中确实存在一些挑战和限制。主要有以下几个方面： > > **数据量问题：** > > 在 NLP 中，很多任务需要大量的标注数据才能达到较好的性能，但标注数据往往是非常昂贵和耗时的。因此，训练深度神经网络需要大量标注数据的限制是一个常见的问题。 > > **任务之间的差异：** > > 不同的 NLP 任务之间可能存在很大的差异，这意味着在微调模型时需要重新训练模型来适应新的任务，而这往往需要大量的标注数据和计算资源。 > > **神经网络的过拟合问题：** > > 微调的过程通常需要调整大量的参数，这可能导致神经网络过拟合训练数据，导致在测试数据上表现不佳。 > > 以上问题使得之前使用微调进行迁移学习的尝试在 NLP 领域中取得的效果并不理想。 > > 而 ULM-FiT 引入了一些新的方法来解决这些问题，包括：使用自然语言预训练模型来学习通用的语言知识，利用数据增强技术来扩大训练数据集的规模和多样性，使用迁移学习来将通用的语言知识应用于不同的 NLP 任务中。这些方法使得 ULM-FiT 取得了很好的效果，并在 NLP 领域中得到了广泛应用。 ### 11.2.2 但Fine-Tuning没错，我们的办法可以在NLP实现类CV的迁移学习 * ULM-FiT这篇文章的作者想说，错的不是对LM做微调，问题出在我们缺乏如何有效训练它们的知识。相比于CV，NLP模型往往更浅，所以需要不同的微调方案。 > - We propose a new method, Universal Language Model Fine-tuning (ULMFiT) that addresses these issues and enables robust inductive transfer learning for any NLP task, **akin to fine-tuning ImageNet models**: The same 3-layer LSTM architecture— with the same hyperparameters and no additions other than tuned dropout hyperparameters— outperforms highly engineered models and transfer learning approaches on six widely studied text classification tasks.&#x20; ### 11.2.3 Cookie Monster的使用步骤： #### 11.2.3.1 Cookie Monster提出的三个新的微调技术 * **Discriminative fine-tuning（‘Discr’）** 是指在深度学习中对预训练模型进行微调，以适应新任务或数据集的过程。在这个过程中，每层的学习率被设置为不同的值。 * **斜三角学习率（Slanted triangular learning rates，STLR）**&#x662F;一种用于训练神经网络的学习率策略，旨在加速训练过程并提高模型性能。 * 它首先线性增加学习率，然后根据右表线性衰减。 * \#横轴为迭代次数。  * **渐进式解冻（Progressive Unfreezing）**&#x662F;一种用于训练深度神经网络的技术，其利用了分阶段训练的方法，旨在缓解深度神经网络训练中的过拟合问题，并提高模型的性能。 * 在传统的深度神经网络训练中，通常是先对整个网络进行训练，然后再微调各个层，这种方式可能会导致网络过拟合，即模型对训练数据过于敏感，泛化能力较差。而渐进式解冻则是一种分阶段训练的方法，可以使得网络逐步地学习到数据的更多细节信息，从而降低过拟合的风险。 * 具体而言，渐进式解冻的步骤如下：1、将深度神经网络的所有层进行冻结，只训练最后一层。2、在最后一层训练收敛后，解冻前一层，继续训练倒数第二层。3、在两层训练收敛后，解冻前一层，继续训练倒数第三层。依次类推，直到所有层都被解冻并训练完成。 * 通过这种方式，渐进式解冻可以逐步增加网络的复杂度和容量，使得网络可以逐步学习到数据的更多细节信息，并逐渐适应数据的不同特征，从而提高模型的性能。此外，渐进式解冻还可以提高模型的泛化能力，并缩短训练时间，减少过拟合的风险。 #### 11.2.3.2 训练Cookie Monster的三步法  ULMFiT由三个阶段组成： a）在一般领域的Corpus上训练LM，以捕捉语言的一般特征（论文原作里，作者在Wikitext-103上预训练语言模型，前者由28,595篇预处理的维基百科文章和1.03亿个单词组成）。这个阶段是最昂贵的，但它只需要执行一次，并能提高下游模型的性能和收敛性。 b）在目标任务数据上使用Discr和STLR对完整的LM进行微调，以学习特定的任务特征。 * Discr背后的思想：由于不同的层捕获不同类型的信息，它们应该被微调到不同的程度。 * STLR的目的：希望模型在训练开始时能迅速收敛到参数空间的一个合适区域，然后完善其参数。 c) 分类器（Classifier）：在目标任务上使用**渐进式解冻**、"Discr "和STLR进行微调，以保留低级表征并适应高级表征（图中，阴影：解冻阶段；黑色：冻结）。 对目标分类器进行微调是迁移学习方法中最关键的部分。过于激进的微调会导致灾难性的遗忘，消除了通过语言建模捕获的信息的好处；过于谨慎的微调会导致缓慢的收敛（以及由此产生的过拟合）。在Cookie Monster里，作者采用了渐进式解冻的训练方法来避免过于激进的微调导致的灾难性遗忘，并辅以Discr和STLR，尽量实现激进和谨慎之间的折衷。 ## 11.3 总结 ULM-FiT是一种有效的、极其节省样本的迁移学习方法，可以应用于任何NLP任务。 ULM-FiT之前，NLP领域的Fine-tuning一直存在过拟合、灾难性遗忘、数据集不够等挑战，而ULM-FiT采用了多任务学习，提出了几种新的微调技术（11.3.3），有效防止了灾难性的遗忘，并在不同的任务中实现了稳健的学习。**NLP领域终于有了类似CV的迁移学习方法。** *** # 12. 它来了它来了，终于等到你！大篇幅详解GPT，GPT-2与GPT3！ **如果对Transformer还不熟悉，千万先回到第十章去把Transformer学明白！** ***#学GPT不懂Transformer，就像读四大名著不看红楼梦，说明这个人技术造诣和自我修养不足，他理解不了这种内在的阳春白雪的高雅艺术，他只能看到外表的辞藻堆砌，参不透其中深奥的精神内核，他整个人的层次就卡在这里了，只能度过一个相对失败的人生。*** *#GPT is short for **G**enerative **P**retrained **T**ransformer。其实GPT和BERT的区别就写在他们的脸上。GPT是Generative的，目的就是要生成。它是一个预训练的Transformer，因为目的就是要生成，所以是Decoder-Only的Auto-Regressive架构。相比之下，Bert的论文名字叫**BERT：Pre-training of Deep Bidirectional Transformers for Language Understanding。**&#x5B83;是很深很深的、双向的Transformer编码器的堆叠，目的是自然语言理解。*   *这个文档的读者可能是为了GPT而来，但是能够坚持看到这里的肯定寥寥无几了！铺垫了这么久，我们终于见到主角了。来看看OpenAI如何在世界更看好BERT的情况下，坚持用Decoder-only的自回归方法，不鸣则已，一鸣惊人！* **下表是本章节会涉及到的几个模型。** | 模型 | 论文 | 模型参数 | 范式与创新点 | 评价与意义 | | ----- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------- | ------------------------------------------------ | ------------------------------------------------------------------------------------------------------- | | GPT | [Improving Language Understanding by Generative Pre-Training](https://s3-us-west-2.amazonaws.com/openai-assets/research-covers/language-unsupervised/language_understanding_paper.pdf) | 12层解码器，768维词嵌入，12个注意力头 | 预训练+微调，创新点在于Task-specific input transformations。 | 很快被Encoder-only的BERT击败，但自回归的技术路线的选择注定了GPT的难度更大，但天花板会更高。 | | GPT-2 | [Language Models are Unsupervised Multitask Learners](https://cdn.openai.com/better-language-models/language_models_are_unsupervised_multitask_learners.pdf) | 15亿参数 | 预训练+Prompt+Predict，创新点在于**Zero-shot** | 被BERT Large横扫SOTA后，OpenAI未能给出很好的回应。Zero-shot新颖度拉满，但事实更像树模型性能拉胯，实用性低，只好以0S为卖点。 | | GPT-3 | [Language Models are Few-Shot Learners](https://arxiv.org/pdf/2005.14165.pdf) | 1750亿参数 | 预训练+Prompt+Predict，创新点在于**in-context learning** | 开创性提出**in-context learning**概念，是Prompting真正的祖师爷。**In-context learning（ICL）**&#x662F;Prompting范式发展的第一阶段。 | | Codex | [Evaluating Large Language Models Trained on Code](https://arxiv.org/abs/2107.03374) | 3亿参数和12亿参数 | 预训练+Fine-tuning。Fine-tune就是真香。 | 技术上没什么复杂的，爬完Github的代码用于训练更是极具争议。ChatGPT和GPT-4的代码生成能力很强，Codex功不可没。有人认为ChatGPT能进行复杂的reasoning是因为它学习了这些代码。 | ## 12.1 GPT的诞生（2018.6） ### 12.1.1 GPT是一个12层的Transformer解码器 ***12层解码器，768维词嵌入，12个注意力头*** 论文：[Improving Language Understanding by Generative Pre-Training](https://s3-us-west-2.amazonaws.com/openai-assets/research-covers/language-unsupervised/language_understanding_paper.pdf) 翻译：[梦开始的地方：GPT1论文翻译：Improving Language Understanding by Generative Pre-Training](https://zhuanlan.zhihu.com/p/619995186) By haidao 我们可能会觉得GPT这么牛逼，一定超级超级复杂。但其实不是这样的！**GPT其实并不是一种新型架构，他的结构类似于只有解码器的Transformer。**&#x4E8B;实上，它无非是堆叠了12个Transformer的解码器！  *上图截自发布GPT的论文，可以看到，GPT它就是一个12层解码器！* > OpenAI GPT模型是在Google BERT模型之前提出的, 与BERT最大的区别在于GPT采用了传统的语言模型方法进行预训练, 即使用单词的上文来预测单词, 而BERT是采用了双向上下文的信息共同来预测单词.正是因为训练方法上的区别, 使得GPT更擅长处理自然语言生成任务(NLG), 而BERT更擅长处理自然语言理解任务(NLU)。 如右图所示，我们知道， 经典的Transformer Decoder Block包含3个子层, 分别是Masked Multi-Head Attention层, Encoder-Decoder Attention层, 以及最后的一个全连接层。忘记了就回到10.3好好复习哈！ GPT是一个Decoder-Only的结构，他根本就没有编码器，自然无从从编码器中获得Key和Value啦～因此，在Decoder-Only的魔改Transformer中，我们往往会取消第二个Encoder-decoder Attention子层, 只保留Masked Multi-Head Attention层, 和Feed Forward层. 这样一来，其实Encoder和Decoder的唯一差别就是，第一个多头自注意力层有没有带掩码了。如果没带掩码那就是Encoder，如果带了掩码那就是Decoder。就这么简单捏（10.3.1讲带掩码自注意力讲的很清楚噢！） * Embedding：词嵌入+位置编码 * 带掩码的多头自注意力机制，让当前时间步和后续时间步的信息的点积在被softmax后都为零 * 输出的向量输入给一个全连接层，而后再输出给下一个Decoder。 * GPT有12个Decoder，经过他们后最终的向量经过一个logit的linear层、一个softmax层，就输出了一个下一个词的概率分布函数。 * 输出的词会作为下一个词的输入。  ### 12.1.2 GPT的训练范式是预训练+Fine-Tuning 在12.1.1里，我们知道了GPT本身无非是一个12层的Transformer解码器。所以接下来，我们不论说“预训练好的12层的Transformer”，还是GPT，我希望大家知道我指的是同一个东西。 #### 12.1.2.1 无监督预训练 Unsupervised pre-training **GPT模型的预训练任务为标准的n-gram语言模型任务。** Transformer的解码器本身就是一个语言模型。我们给定一个没有标注的语料库$$\mathcal U =[u_1,u_2,...,u_n]$$，让Transformer解码器去做下一个词预测。我们的目标函数/损失函数为： $$L_1(\mathcal U) =∑_ilogP(u_i|u_{i-k},u_{i-k+1}...,u_{i-1};\theta)$$ 这里可以回想6.5.3的n-gram语言模型，根据前面的k个&#x8BCD;*（k is the size of the context window）*&#x8F93;出下一个词的条件概率。k是一个超参数，而后面的$$\theta$$就是模型参数了。 其实对这里的k的更直观的理解方法是神经网络的输入序列的长度。序列越长，网络能看到的东西越多。把这个k堆的很大也是让模型变强的一个重要方式。 > 很多时候我们说BERT和GPT的区别在于编码器和解码器，其中编码器可以看到全部而解码器只能看到部分，这个说法其实非常不准确。真正不一样的地方在于预训练任务（以及其对应的目标函数）。GPT的预训练任务是下一个词预测，这比BERT的完形填空难得多，因为它要预测一个开放式的结局。 > > <给过去6天的股价，预测明天的股价 VS 给前后各三天的股价，预测中间的那一天股价> > > **“这是导致GPT在训练上和效果上比BERT差很多的重要原因。但如果你的模型真的能够预测未来的话，它的能力要比BERT这样的模型强大很多。这就是为什么作者要一直不断把模型做大，一直不断努力，最终造出了GPT-3那样子惊艳的东西。OpenAI选择了一个更难的技术路线，但可能它的天花板也就更高了。”——李沐** \#大佬这个判断真的超级准确 #### 12.1.2.2 微调的范式 An illustration of supervised fine-tuning OpenAI对预训练好的解码器们在多种有监督任务上进行实验，包括自然语言推理、问答、语义相似度和文本分类。 论文中讲述了把将预训练好的Transformers用于序列分类任务。 在预训练完了之后，我们得到了模型的参数，并将其用于针对下游任务的有监督训练。我们假设有一个标注好了的数据集$$\mathcal C$$，其中有词序列$$x^1,...,x^m$$，并且告诉了你这个词序列的标注是y。 > （例如，词序列\[$$x^1,x^2,x^3,x^4,x^5,x^6$$]为 \[原神,怎么,你,了,?,?]，它的标注$$y$$为“急”。 具体的做法是，把$$x^1,...,x^m$$输入到之前我们训练好的GPT模型里面里面；经过了12个Decoder Block后，输出了一个对应最后一个输入$$x^m$$的$$h^m_l$$（768维），然后利用这个张量乘一个权重矩阵$$W_y$$（768\*分类类目数），就得到了一个与分类的类目数字同维度的向量。对于这个向量我们做Softmax，就得到了y的概率分布： $$P(y｜x^1,...,x^m）=softmax(h^m_lW_y)$$ > （例如， “原神怎么你了？？”的标注的概率分布为P（崩）=10%，P(典)=30%，P(急）=25%，P(孝)=30%，P（麻）=5% 我们的目标是最大化以下目标函数： $$L_2(\mathcal C)=∑_{x,y}logP(y|x^1,...,x^m)$$ > 也就是说，我们希望模型判断出词序列“原神怎么你了”的标注为“急”的概率越高越好。 **这是一个非常标准的分类任务的目标函数。** **虽然在微调的时候只关心这个目标函数，但其实我们可以把分类任务和语言模型任务两个预训练任务一起做！** 也就是说，在微调的时候，我们同时根据$$L_1(\mathcal C)$$，$$L_2(\mathcal C)$$做优化。 > 输入序列：\[$$x^1,x^2,x^3$$]=\[卧|槽|，]。我们就希望GPT可以预测出下一个词“原”；给一个完整的序列\[卧|槽|，｜原｜！]，我们希望GPT觉得这句话的标注是“崩”的概率越高越好。两个任务我们都一起做。 OpenAI用一个可以去调的超参数$$\lambda$$来把这两个目标函数连在一起，而后一起优化做梯度下降： $$L_3(\mathcal C)=\lambda L_1(\mathcal C)+L_2(\mathcal C)$$ ### 12.1.3 GPT的创新点：Task-specific input transformations > For some tasks, like text classification, we can directly fine-tune our model as described above. Certain other tasks, like question answering or textual entailment, have structured inputs such as ordered sentence pairs, or triplets of document, question, and answers. Since our pre-trained model was trained on contiguous sequences of text, we require some modifications to apply it to these tasks. 在12.1.2.2中，我们讲了怎么去给GPT做微调：我们用了典型的分类任务，不过一个比较新的点是我们把两个预训练任务的目标函数组合起来。 **接下来我们的问题是怎么把NLP里面那些很不一样的各种子任务都去用这样的微调范式去表达，即序列+标注。**  这张图前面我们看过了，不过这里我们再放出来一次。这张图里放了四个常见的子任务： * **Classification 分类：**&#x53EF;以看到，有两个特殊符&#x53F7;*（Start和Extract）*&#x52A0;了一个线性层。 * **Entailment&#x20;**：这个很难翻译。大概的意思是：给一个前提（Premise），然后提出一个假设（Hypothesis），让模型去判断这个假设是和被前提蕴涵了、和前提冲突了还是和前提无关。看起来像是在玩逻辑推断，本质上其实是给你两段文&#x672C;*（用特殊符号分开）*，然后做一个三分类的问题。 > Premise：你说的对，但是《原神》是由米哈游自主研发的一款全新开放世界冒险游戏。游戏发生在一个被称作「提瓦特」的幻想世界，在这里，被神选中的人将被授予「神之眼」，导引元素之力。 > > Hypothesis：1、你是对的。2、你读四大名著不读红楼梦。3、游戏发生在海拉鲁王国。 > > Output：1、包含 2、中立 3、冲突。 * **Similarity 相似**：判断两段文字是不是相似。相似是一个对称关系，A和B相似，那么B和A也是相似的；所以参考那张图，先有Text1+分隔符+Text2，再有Text2+分隔符+Text1，两个序列分别经过Transformers后，各自得到输出的向量；我们把它按元素加到一起，然后送给一个线性层。这也是一个二分类问题。 * **Multiple Choice多选题**：多个序列，每个序列都由相同的问题Context和不同的Answer构成。如果有N个答案，就构造N个序列。每个QA序列都各自经过Transformers和线性层，对每个答案都计算出一个标量；最后经过softmax生成一个各个答案的概率密度分布。这是一个N分类问题。 通过这样的方法，这四个自任务就都变成了序列+标注的形式。尽管各自的形式还是稍微有一些不一样，**但不管输入形式如何、输出构造如何，中间的Transformer他是不会变的**。不管怎样，我们都不去改图中的Transformer的模型结构，这是GPT和之前工作的区别，也是这篇文章的一个核心卖点。 > &#x20;Previous work proposed learning task specific architectures on top of transferred representations . Such an approach re-introduces a significant amount of task-specific customization and does not use transfer learning for these additional architectural components. **Instead, we use a traversal-style approach, where we convert structured inputs into an ordered sequence that our pre-trained model can process. These input transformations allow us to avoid making extensive changes to the architecture across tasks.&#x20;** > 到这里过，你可能还是会觉得比较困惑——因为GPT好像没什么新的！真正的卖点无非是在于12.1.2.3中提到的Task-specific input transformations。那么它是怎么做到如今这么复杂的问答的？耐心继续看下去吧！ *** ## 12.2 GPT-2：语言模型是无监督的Multitask Learner！（2019.2） ***48层解码器，1600维词嵌入，15亿的参数*** \#我们知道，GPT模型在某种意义上被后于它发表的BERT给“打败”了，其中BERT Large更是层数翻了一倍（24个编码器）、宽度翻了1.3倍（1024维的词嵌入），以3倍的复杂度（用到了20亿的Wikipedia的数据集）被训练成了一个GPT3倍大的、拥有3.4亿的参数的模型，横扫了当时的SOTA。 > **Q：当你的解码器被别人用编码器、更大的模型、更大的数据打败时，你要如何做回应呢？** > > **A：换编码器是不可能换的，这辈子都不可能。我们要做的更大！** > > **Q：可是哪怕做的比别人更大，15亿参数的Decoder-only的效果还是没比3.4亿参数的BERT好诶🥺** > > **A：但是我们可以Zero-Shot！**   [论文原文：Language Models are Unsupervised Multitask Learners](https://cdn.openai.com/better-language-models/language_models_are_unsupervised_multitask_learners.pdf)。最大的GPT-2用了48个解码器。 ### 12.2.1 先谈谈多任务学习：NLP的众多子任务都可以转为问答任务 [Language Models are Unsupervised Multitask Learners](https://cdn.openai.com/better-language-models/language_models_are_unsupervised_multitask_learners.pdf)中提到，现在的语言模型泛化能力比较差，在一个训练集、一个训练任务上训练出来的参数很难直接用到下一个模型里。因此，目前大多数模型都是Narrow Expert，而不是Competent Generalists。**OpenAI希望朝着能够执行许多任务的更通用的系统发展--最终不需要为每个任务手动创建和标记训练数据集。**&#x8FD9;其实能让我们想到2000～2010年很火，但在NLP一直没什么应用的多任务学习。 #### 12.2.1.1 **多任务学习的定义** 多任务学习（Multi-Task Learning, MTL）是一种机器学习方法，它可以通过同时学习多个相关的任务来提高模型的性能和泛化能力。与单任务学习只针对单个任务进行模型训练不同，多任务学习通过共享模型的部分参数来同时学习多个任务，从而可以更有效地利用数据，提高模型的预测能力和效率。 #### 12.2.1.2 **自然语言十项全能竞赛 The Natural Language Decathlon（2018.6）** 重要文献：[The Natural Language Decathlon: Multitask Learning as Question Answering](https://arxiv.org/abs/1806.08730) > 在NLP中，一个统一的多任务基础模型可以很方便地进行模型迁移、模型部署，并且对这个基础模型的不断改进，可以不断提高下游模型的性能，有可能达到持续学习、持续提升的目的，而如果每个新的子模型都重新学习的话，相当于利用不到基础模型长期学习到的知识。 > > 但是，NLP领域有很多任务，比如序列标注、命名实体识别是一类；对整个句子的分类是一类；还有就是seq2seq的机器翻译、自动摘要等，要怎样将这些不同的任务统一到一个模型中呢？ > > 答案是，可以把所有NLP任务统一成QA任务！机器翻译转换为QA任务就是问这个句子翻译成另一种语言是什么句子，句子情感分类就是问这个句子表达的是积极还是消极的含义，自动摘要就是要求机器帮你写一段摘要。所有NLP任务都可以转换为QA任务。 > > ——引自[CS224N(3.5)Multitask Learning | bitJoy](https://bitjoy.net/2020/03/14/cs224n%ef%bc%883-5%ef%bc%89multitask-learning/) By Beeder 在文献[The Natural Language Decathlon: Multitask Learning as Question Answering](https://arxiv.org/abs/1806.08730)中，[Bryan McCann](https://arxiv.org/search/cs?searchtype=author\&query=McCann%2C+B)等人介绍了**自然语言十项全能竞赛（decaNLP）**，这是一项跨越十个任务的挑战：问题回答、机器翻译、摘要总结、自然语言推理、情感分析、语义角色标签、关系提取、面向目标的对话、语义解析和常识性代词解析。  怎么做到这件事呢？在上文引自Beeder的文章里已经透露了答案：**把所有的任务都归结为上下文的问题回答。** 具体的，我们应该满足如下的条件： > 1\. 必须对所有任务一视同仁，也就是喂给模型的数据不能包含这条数据具体是哪个任务，不能告诉模型这条数据是要做NMT，另一条数据要做情感分类。 > > 2\. 模型也不能包含针对不同任务的特殊模块。给模型输入一段词序列，**模型必须学会自己辨别这段词序列要求的不同的任务类型**，并且进行内部切换，执行不同的操作。 > > 3\. 此外，模型还应具备执行这10个任务之外的任务的能力，即zero shot learning。 因此，这篇论文的作者提出了一个新的多任务问题回答网络（Multitask Question Answering Network, MQAN），该网络**在没有任何特定任务模块或参数**的情况下**联合学习**decaNLP的所有任务。 MQAN具体是怎么做的这里先不展开讲了，但把各种下游子任务都转换为QA任务，并且让模型通过我们告诉他的自然语&#x8A00;**（Prompt！！！）**&#x53BB;自动执行不同的操作，从而完成任务的想法真的非常天才，也是GPT-2的关键。 \#这就是为什么提出GPT-2的论文的标题叫[Language Models are Unsupervised Multitask Learners](https://cdn.openai.com/better-language-models/language_models_are_unsupervised_multitask_learners.pdf)！非常应景。 ### 12.2.2 Zero-Shot：要不咱不去微调了？ > GPT-2 最大的改变是，OpenAI 抛弃了前面“无监督预训练+有监督微调”的模式，而是开创性地引入了 Zero-shot 的技术，即预训练结束后，不需要改变大模型参数即可让它完成各种各样的任务！ 不论是GPT还是BERT，他们都是预训练+针对具体下游任务做微调的范式。既然要做fine-tune，那就还是需要很多有标注的数据，还要去担心过拟合的问题。真麻烦啊。 **Zero-shot的含义在于，我们在预训练做下游任务时，不需要任何额外的标注信息，自然也不去改模型参数。这听起来非常离谱，自然也需要一些额外的细节。** 模型架构上，GPT-2和GPT其实没有区别，都是Transformer解码器的堆叠。所以对模型架构就不再做重复介绍。 **但我们要捋清楚一个逻辑：** #### 12.2.2.1 Zero-shot难在哪？ * 在12.1的GPT中，我们的模型在自然语言上进行预训练，到了给下游任务做微调的时候，我们是引入了很多模型之前从来没有见过的特殊符号的。参考下图，中间的Delim（间隔符，能够让模型知道这个符号前的是context而该符号之后的是Answer）就是一个特殊符号，是针对这个具体的任务我们专门设计的，模型之间在预训练的时候可是从来都没有见过。也就说，对于下游任务，我们给GPT的输入进行了特殊的构造，加入了开始符、结束符、分割符。这些符号，模型要在微调的过程中慢慢认识。  * 那么现在问题来了：如果我们想要做Zero-short Learning，即不做任何额外的下游任务训练的话，我们就没办法让模型去临时学习这些针对特定任务的构造了。因此，我们在构造下游任务的输入的时候，就不能引入特殊的符号，而是要让整个下游任务的输入和之前在预训练的时候看到的文本形式一样。**简言之，输入的形式应该更像自然语言。** #### 12.2.2.2 从Zero-shot到Prompting 既然输入的形式也要更像自然语言，那么我们有没有办法，让模型通过我们的自然语言，去知道现在要去执行什么任务呢？例如，我对模型说：***`把这段话翻译成英文：都什么年代，还在抽传统香烟。`***&#x7136;后模型就知道了，这是一个翻译任务，而且冒号后面的部分就是我想让他翻译的文本。这样就不需要让模型认识新的特殊符号了，模型只要能读懂我对他的指示就行。 那该怎么办？答案是站在巨人的肩膀上：12.2.1.2提到的[NLP十项全能竞赛](https://arxiv.org/abs/1806.08730)给我们带来了灵感！ > But as exemplified in McCann et al. (2018), language provides a flexible way to specify tasks, inputs, and outputs, all as a sequence of symbols. For example, a translation training example can be written as the sequence (**`translate to french`**`, english text, french text`). Likewise, a reading comprehension training example can be written as` (`**`answer the question`**`, document, question, answer)`。 **也就是说，实现Zero-shot learning的前提就是，我们得能够做到不需要针对下游的任务，给模型的输入结构做专门的设计；而是只需要给模型指示，也就是提示词（Prompt）就好了。**&#x8BFB;来是否心潮澎湃呢？期待了这么久，Prompt这个词终于出现了！！！鼓掌！！！！ #### 12.2.2.3 Why Prompt Works at All？ \#为什么只需要写Prompt就可以自动实现下游的任务的预测？这件事真的很邪门！下面给了个可能的解释： > Our speculation is that a language model with sufficient capacity will begin to learn to infer and perform the tasks demonstrated in natural language sequences in order to better predict them, regardless of their method of procurement.&#x20; > > ——Language Models are Unsupervised Multitask Learners，OpenAI OpenAI推测，当数据量足够大、模型能力足够强的时候，语言模型会学会推测并执行用自然语言提出的任务，**因为这样可以更好的实现下一词预测。** 参考右图。GPT-2的语料库中，其实本来就有非常多的英文翻译成法语的例子，它们是在语料库中被动存在的，不需要人为的去提出这样的要求；而机器学习过这些数据以后，可能就产生了理解自然语言所蕴含的“英法翻译”这个要求的能力。  #### 12.2.2.4 GPT-2的性能与对该模型的评价 GPT-2的性能如下图所示：  可以看到，在阅读理解上做得还行，在翻译和摘要总结上比较拉胯，Summarization甚至比不过平平无奇的seq2seq+Attention；Question Answering就别提了，弱得看不见上面其他的模型的车尾灯，直接和别人都没法放在一张图里了……GPT-2主要以Zero-shot为卖点还是有原因的，因为这个性能确实不大行，尤其是考虑到这般史无前例的参数规模的情况下，居然还是只交出这样的答卷。 GPT-2还是做了一个很有新意的工作的，即Zero-shot范式；但它的性能就非常差了。李沐大佬说过：一篇文章的贡献度=新意度\*有效性\*问题的大小。GPT-2在新意度上是很高的，但这个有效性，实在是很难评。 不过值得我们关注的一个点是，整体来看，模型的性能还是随着参数的增加在（类似线性地）上升的。因此， > 这还是给我们留下了想象空间：如果模型被搞得足够大，搞得大一点、再大一点的话，是不是我们离AGI，就真得更近了？粗略地说，这就是GPT-3将要做的事情！ *** ## 12.3 GPT-3：语言模型是Few-Shot Learner （2020.5） [论文原文：Language Models are Few-Shot Learners](https://arxiv.org/pdf/2005.14165.pdf) ### 12.3.1 GPT-3的意义 ***GPT-3有1750亿参数，模型参数实在大到恐怖，以至于用在子任务的时候也不大能去微调。因此GPT-3用于下游任务时，不做任何梯度更新。*** *#GPT模型指出，如果用Transformer的解码器和大量的无标签样本去预训练一个语言模型，然后在子任务上提供少量的标注样本做微调，就可以很大的提高模型的性能。GPT-2则是更往前走了一步，说在子任务上不去提供任何相关的训练样本，而是直接用一个足够大的预训练模型去理解用自然语言表达的子任务要求，并基于此做预测。但正如前面提到的，GPT-2的性能太差，新意度高而有效性低。* 自然的，GPT-3这篇文章其实就该来解决有效性低的问题。Zero-shot的概念很诱人，但是还是太苛刻了。别说人工智能了，哪怕是我们人，去学习一个任务也是需要样本的，不过我们学起来比较快罢了，而机器却往往需要大量的标注样本去fine-tune。人工智能人工智能，我们总归是想要让机器也有类似人类的智能，人看两三个例子就可以学会一件事了，机器却得需要大量“人工”才能有智能。太不好了。那有没有可能做到这样：我给预训练好的语言模型一点样本，但不多。用这有限的一丁点样本，我们的语言模型就可以迅速学会下游的任务？ 嗯，这就是GPT-3的工作。论文的名字是[Language Models are Few-Shot Learners](https://arxiv.org/pdf/2005.14165.pdf)，就是这个意思。 > **Note：哪怕在是Few-shot中，我们给了模型几个例子，模型也是不更新梯度的噢！GPT-3的工作非常强调不对模型的权重做更新，毕竟1750亿参数，实在是太大了。**  可以看到，从GPT2（1.3B）到GPT-3（175B），模型的精度翻了一倍。把模型做大确实行之有效。  横轴为在输入给模型的Context中提供的样本的数量。 ### 12.3.2 GPT-3的模型架构与工程细节  * *模型架构上，和GPT-2是一样的，都是解码器的堆积，不过用到了一个叫Sparse Transformer的架构。我不打算在这个文档里具体介绍Sparse Transformer；不过通过下面这段文字，我们就可以对它的作用和机制有一个大概的了解。**简言之，Sparse Transformer允许我们处理更长更稀疏的输入序列。*** > Sparse Transformer是一种旨在处理高维、稀疏和长序列数据的Transformer拓展版，由OpenAI团队在2019年提出。相比于传统的Transformer架构，Sparse Transformer通过在自注意力机制中引入稀疏性，减少了网络中计算的数量，从而可以处理更长的序列数据。 > > 在处理高维、稀疏数据时，Sparse Transformer可以避免对所有输入的位置进行计算，只计算与当前位置相关的位置，从而提高了计算效率。 * $$d_{model}=n_{heads}*d_{head}$$，$$n_{heads}$$代表多头注意力有几头，$$d_{heads}$$代表每头多头注意力的维数（就是我们前面提到的分别乘Q、K、W三个权重矩阵后得到的向量的维数。在原版Transformer中是64维）。 * *GPT-3的批大小达到了320万，这是一个非常巨大的批大小，对内存考验非常大。参考下公式：* *$$\theta_{t+1}=\theta_t-\alpha\frac{1}{N}∑^N_{n=1}\frac{∂\mathcal L(y^n,f(x^n;\theta))}{∂\theta}$$* * ***虽然批大小增加会导致梯度计算的时间复杂度增加，但是较大的批大小通常可以提高模型的训练效率和性能。***&#x8FD9;是因为较大的批大小可以利用现代硬件的并行计算能力，加速模型的训练过程，同时也可以通过减少梯度的方差来提高模型的稳定性。总之，选择一个如此之大的批大小，自然主要是因为工程经验。 * *还有一些很有意思的细节，例如模型变大、批大小提升的时候，OpenAI选择的学习率反而下降了。* * *在数据源上，一个模型的参数量越大，我们自然就需要更多的数据来去预训练它。* * GPT-2中OpenAI觉得Common Crawl的数据太脏了，所以用了karma值>3的Reddit文章作为训练数据；但是现在GPT-3的模型大小又翻了十几倍，所以就不得不考虑Common Craw&#x6C;*（一个数据量巨大无比的互联网页面爬虫集合，但数据巨大无比，自然伴随着数据非常脏）*&#x4E86;…… * 具体而言，OpenAI对Common Crawl做了三个工作：1、二分类。用Logit模型把Common Crawl的数据分为高质量的和低质量的，从而把不好的数据给过滤掉。2、去重（LSH算法）。3、而后再把之前GPT-2、BERT用到的数据集再都放进来。 * 此外，虽然用了很多Common Crawl爬来的数据，其在数据总量上对其他的数据集形成压倒性优势，但是在采样率上OpenAI还是对每种数据集都做了区别对待的。在每个Batch Size中，Open AI都控制了Common Crawl的权重为60%。具体是怎么做的论文没有讲，不过我们大概能懂这是什么意思。  > 总之，虽然模型架构部分我们只看了这么一张参数表，但参数表里也体现出了非常多的工程细节。**GPT在技术上没什么新的，可是想要大力出奇迹的话，算力规划、超参数的选择等工程know-how还是非常多的。** OpenAI在论文中几乎没怎么透露模型训练的具体细节，对超参数的选择、模型分割、数据分割、分布式训练的做法都披露的很少。所以哪怕我想详细的讲也不找到上哪找资料。*`大家都戏称OpenAI为ClosedAI是有原因的。你的开源之魂哪去了？？？`* ### 12.3.3 In Context Learning 上下文学习（ICL）  前面我们反复强调了GPT-3是不会做梯度下降、更改模型参数的。那么，它是怎么做的呢？——只做预测，不做训练！我们希望Transformer在做前向推理的时候，能够通过注意力机制，从我们给他的输入之中抽取出有用的信息，从而进行预测任务，而预测出来的结果其实也就是我们的任务指示了。**这就是上下文学习（In context learning）**。 **GPT-3的上下文学习能力究竟从何而来，在它刚发布的时候其实还是一个谜， [Tengyu Ma](https://arxiv.org/search/cs?searchtype=author\&query=Ma%2C+T)所在的Group曾发布若干论文致力于解释GPT-3出现的上下文学习能力。参考：** [【arxiv】An Explanation of In-context Learning as Implicit Bayesian Inference](https://arxiv.org/abs/2111.02080) [【arxiv】What learning algorithm is in-context learning? Investigations with linear models](https://arxiv.org/abs/2211.15661) 上述两篇论文都比较难懂，作为入门级，我们只需要知道当Train出一个GPT-3这么大的模型后，上下文学习能力就能被体现出来了，而且其是具有一定的科学解释。 **这么一来，GPT-3是一个1750亿参数的有ICL能力的模型。为了体现ICL，OpenAI用三个方法来评估他：** **1、Few Shot Learning（FS）：**&#x7528;自然语言告诉模型任务；对每个子任务，提供10～100个训练样本。 **2、One-shot Learning（1S）：**&#x7528;自然语言告诉模型任务，而后只给该任务提供1个样本。 **3、Zero-shot learning（0S）：**&#x7528;自然语言告诉模型任务，但一个样本都不给。**具体例子看下图。**  <图左为GPT-3提出的In context learning的三种范式，右边为传统的Fine-tunning> 这个模式其实也有好有坏： * **好处就是我们前面说的，它避免了对下游的任务做Fine-tune。**&#x54;une一个模型还是很麻烦的，对于每一个新任务，都需要准备足够的样本，调好超参数（批大小、学习率等），选择各种学习方法（想起Cookie Monster了吗？），而且训练模型这件事本身就要求得有GPU。相比之下，GPT-3的范式让我们面对新任务时，只需要去让模型做预测，即前向传播，就可以了，模型就会直接把结果返回给我们。这对新任务特别友好。 * 坏处也很明显： * 如果真的有很多训练样本，该怎么办？GPT-3的输入窗口长度毕竟是有限的，我们不可能无限的堆叠example的数量——例如，如果是训练翻译任务，我们随随便便就可以找到巨量的样本。这种时候Tune出来的模型效果就很可能会比我们在有限的窗口数内输入的few-shot examples差。简言之，有限的输入窗口限制了我们利用海量数据的能力。 > **Transformer 变得越来越深，越来越宽，但在长序列上训练它们仍然很困难。**&#x7814;究人员遇到的一个基本问题是，Transformer 的注意力层在序列长度方面是按二次方比例增长：就是说从 32k 长度增加到 64k 长度，成本不只增加 2 倍，而是增加了 4 倍。 > > 过去两年，斯坦福大学 Hazy Research 实验室一直在从事一项重要的工作：增加（LLM的输入）序列长度。&#x20; > > ——推荐阅读：[想把半本《红楼梦》搬进ChatGPT输入框？先把这个问题解决掉](https://mp.weixin.qq.com/s/idL7DyL7prhztvnMHBEl1g) By机器之心 > > [【arxiv】FlashAttention: Fast and Memory-Efficient Exact Attention with IO-Awareness](https://arxiv.org/abs/2205.14135) * 每次做一次新的预测，模型都要从输入的中间抓取有用的信息；可是我们做不到把从上一个输入中抓取到的信息存起来，存在模型中，用到下一次输入里。 * **这就是GPT-3明明早在2020年5月就已经用巨大参数取得了很好的效果，但是学界用Few-shot做上下文学习的热度好像还是不那么高的原因。** ### 12.3.4 GPT-3模型的局限性 Limitations 作者列举了非常多的局限性，但我这里主要讲一些我觉得最重要的。 ***首先，长文本生成能力还是很弱。*** **如果要让GPT-3生成长文本的话，可能写了几段后，再往后就又往回写第一第二段的重复的东西了。**&#x5982;果想要让GPT-3在无监督的情况下帮你写小说，可以说这压根就不可能，因为他没有不断的往前推剧情的能力。不过，如果你在输入中告诉了GPT你的上下文，让它来补全上下文中间的一段故事，他可能就会做的特别好。 > 在文本合成方面，虽然整体质量很高，但GPT-3样本有时仍会在文档层面上重复自己的语义，在足够长的段落中开始失去连贯性，自相矛盾，并偶尔包含非连续的句子或段落。 ***其次，GPT-3对 "如果我把奶酪放进冰箱，它会融化吗？"这类问题有困难。基于物理等世界尝试的逻辑推理能力可能还不够。*** 此外，还有如下局限性：： * **学习的时候做不到像我们人类这样盯着材料的重点学。**&#x4F8B;如，一句话中实词的占比可能很小，语言模型的大量学习都是去学习虚词，如“a”、“the”、“to”等，毕竟语言模型还是对所有词语都一视同仁的。 * **GPT-3还是单模态的，只能做文字。**&#x4F;penAI的梦想是实现多模态的AGI，不仅可以输出文字，也想进行多模态生成。这是后面GPT-4要做的事情。 * **可解释性差。**&#x4F60;不会知道从一个输入到一个漂亮的输出的过程中，是模型的哪些权重发挥了作用。 * **可能会输出有害的、有偏见的内容，和人类的价值观或者社会主义核心价值观不对齐**。OpenAI调查了GPT对性别的偏见、对种族的一些偏见等。例如，A man is ___的下一词预测，和A woman is ____的下一词预测的比较，可能会非常不一样。 ### 12.3.5 留下的疑问：GPT-3是怎么进化成ChatGPT的？ 在最开始的时候，GPT-3在一些任务上表现的还算OK，但还是远远没有现如今的ChatGPT体现出的惊艳水平的。我们知道，ChatGPT可以很好的理解并遵循人类的指令，在一个非常简洁没有任何条条框框的界面上和人类做真正的自然语言的交互，其能联系上下文，能解决几乎全部自然语言任务，能逻辑推理，还会写代码。 **所以，How did GPT-3 get there?? 在走向ChatGPT时代的过程中，人们对GPT-3都做了些什么？这是我们接下来要探索的问题**。具体的演化路径参考下图（引用自[Yao Fu](https://franxyao.github.io/)）。  在紧接着的12.4中，我们将收集解锁GPT-3能力的第一块拼图。 *** ## 12.4 Codex：用Github代码Fine-tune一个GPT模型（2021.6） \#2021年6月29日，GitHub首次发布了GitHub Copilot，后者是GitHub和OpenAI合作开发的一个人工智能工具，用户在使用Visual Studio Code、Microsoft Visual Studio、Vim、Cursor或JetBrains集成开发环境时可以通过GitHub Copilot自动补全代码。这是网址：[GitHub Copilot · Your AI pair programmer](https://github.com/features/copilot) \#感兴趣的可以参考Open AI给的一个Demo：[Creating a Space Game with OpenAI Codex](https://openai.com/blog/openai-codex)，其中展示了怎么用自然语言去开发一个小游戏。   \#“我OpenAI就是饿死，死外边，从这里跳下去，也不会用你们Fine-tuning一点东西。”———“真香！” GPT-3即使没有怎么被训练用于代码生成，依然可以输出一些简单的代码，不过整体性能非常低罢了。那么，如果说给模型数量可观的代码，是不是这个模型就可以在代码生成上取得比较好的效果，甚至实现帮助程序员完成代码，作为一个辅助工具的作用？Codex就是这个思想。OpenAI团队收集了Github上所有的不重复的python代码，总计179GB（这引起了广泛的抨击），并对收集的代码进行了简单过滤，去掉了过大的文件（>1MB）和过长的代码(>100行或单行超过1000个字符)，形成了一个数据集。利用这些数据集，他们Fine-tune了一个GPT3模型。 虽然说Codex看起来很牛逼很特别，但是介绍它并不需要讲更多的复杂的原理： > 我们只要知道它是一个用来自GitHub上的公开的代码作为训练数据集，对GPT-3做一个会改变权重的Fine-tuning，从而让他具有生成代码的能力的拓展版GPT-3模型好了。它生成代码的能力依然是来自于语言模型的下一词预测，它是预训练LM被fine-tune后实现的针对代码生成的下游应用。 Codex背后的论文：[【arxiv】Evaluating Large Language Models Trained on Code](https://arxiv.org/abs/2107.03374) > 我们介绍了Codex，一个在GitHub的公开代码上微调的GPT语言模型，并研究了它的Python代码编写能力。Codex的一个独特的生产版本为GitHub Copilot提供动力。在HumanEval上，我们发布了一个新的评估集，用于衡量从文档串合成程序的功能正确性，我们的模型解决了28.8%的问题，而GPT-3解决了0%，GPT-J解决了11.4%。此外，我们发现，从模型中反复取样是一个令人惊讶的有效策略，可以产生对困难提示的工作解决方案。使用这种方法，我们在每个问题100个样本的情况下解决了70.2%的问题。对我们模型的仔细调查揭示了它的局限性，包括在描述长操作链的文件串和将操作与变量绑定方面的困难。最后，我们讨论了部署强大的代码生成技术的潜在的更广泛的影响，包括安全性和经济。 *注：HumanEval是OpenAI自己收集的数据集，其中包含164个原创的编程问题，其中包含语言理解，算法，一些简单的数学和一些简单的软件面试的题目。它的作用是评估一个模型的代码生成能力。* [OpenAI Codex 论文精读【论文精读】_哔哩哔哩_bilibili](https://www.bilibili.com/video/BV1iY41137Zi/?buvid=ZE4EBEE92994324F407089826EE9BEE9DE8E\&is_story_h5=false\&mid=jOTTvC9MAcEUtHyHp%2B%2B2ww%3D%3D\&p=1\&plat_id=114\&share_from=ugc\&share_medium=iphone\&share_plat=ios\&share_session_id=410BD0A2-09B3-40DA-92AE-963B9EF201DF\&share_source=WEIXIN\&share_tag=s_i\&timestamp=1682615486\&unique_k=i6pA5Lz\&up_id=1567748478) By 李沐 > ***Tune GPT-3以让其学会代码是我们收集的通往ChatGPT的第一块拼图！*** > > 之所以要专门花篇幅介绍看起来没什么的CODEX，是因为有很多人推测（or认为）ChatGPT这样的大模型之所以涌现出了复杂的逻辑推理能力，多少是因为其学习了代码生成，在这个过程中大语言模型学会了Reasoning。参考：[How does GPT Obtain its Ability? Tracing Emergent Abilities of Language Models to their Sources](https://yaofu.notion.site/How-does-GPT-Obtain-its-Ability-Tracing-Emergent-Abilities-of-Language-Models-to-their-Sources-b9a57ac0fcf74f30a1ab9e3e36fa1dc1#929906a4292b4cceadabd92c47f3843f)，By [Yao Fu](https://franxyao.github.io/), [email protected] *** # 13. 预训练语言模型的新范式：Prompting！  参考*12.3*，GPT-3提出了一个重要的概念—***上下文学习（in-context learning, ICL）***。 > ICL其实就是Prompting的祖师爷，其一举把预语言模型实现下游任务应用的范式从Fine-Tuning时代引入到了Prompting时代。紧接着，面向超大预训练语言模型，Prompting出现了三个主要范式：上下文学习ICL，指令精调Instruction-tuning和思维链CoT。 > &#x20;Now, as of this writing in 2021, **we are in the middle of a second sea change, in which the “pre-train, fine-tune” procedure is replaced by one in which we dub “pre-train, prompt, and predict”.** In this paradigm, instead of adapting pre-trained LMs to downstream tasks via objective engineering, downstream tasks are reformulated to look more like those solved during the original LM training with the help of a textual prompt. > > ——[Pre-train, Prompt, and Predict: A Systematic Survey of Prompting Methods in Natural Language Processing](https://arxiv.org/pdf/2107.13586.pdf) **下表是本章节会涉及到的模型。** | **模型** | **论文** | **模型参数** | **范式与创新点** | **评价与意义** | | ------------------------------- | ----------------------------------------------------------------------------------------------------------- | -------- | ------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------- | | GPT-&#x33;*#仅提及，已在12.3讲完*2020.5 | [Language Models are Few-Shot Learners](https://arxiv.org/pdf/2005.14165.pdf) | 1750亿参数 | 预训练+Prompt+Predict，创新点在于**in-context learning** | 开创性提出**in-context learning**概念，是Prompting真正的祖师爷。**In-context learning（ICL）**&#x662F;第一类适用于大模型的Prompting范式。 | | InstructGPT2022.3 | [Training language models to follow instructions with human feedback](https://arxiv.org/pdf/2203.02155.pdf) | 13亿参数 | 预训练+SFT+RLHF，本质还是Fine-tune。RLHF应被理解为把生成式任务变成判别式任务的降低标注成本的Fine-tune。 | **Instruction-tuning**是第二类适用于大模型的Prompting范式。利用SFT+RLHF实现人类价值观的对齐时，可能教会了模型如何去遵循指示。 | | PaLM2022.4 | [PaLM: Scaling Language Modeling with Pathways](https://arxiv.org/abs/2204.02311) | 5400亿参数 | 验证了使用思维链提示能够显著提升模型在算数、常识推理（基于对世界的知识，例如“奶酪放在冰箱里会不会融化”）等挑战性的下游任务的性能 | PaLM的直接目的在于证明继续把参数做大，模型的性能还是可以进一步提升。**思维链提示（CoT）**&#x662F;第三类面向大模型的Prompting范式。 | *#我自己在学习的过程中会对Prompting、Prompt tuning还有Prompt Learning等概念感到混淆和困惑。***这就是为什么我想要在这一章的开头首先做概念辨析，区分清楚这三个Related concepts.** ## 13.1 概念辨析：Prompting、Prompt tuning还有Prompt Learning > Prompting，指的是给语言模型输入一段特定的文本（即提示词），从而引导模型去生成特定的我们想要的输出文本。*他其实就类似我们在ChatGPT里打字的过程啦。* > **Prompting refers to the process of giving a specific prompt or input text to a language model to guide its generation of a specific output text.** The prompt text can be in the form of a question, a sentence, or a few words that are related to the desired output. The language model then generates the output text based on the prompt and its own internal understanding of the language. > > In other words, Prompting is a technique used to guide the generation of specific output text using a language model, while Prompt Tuning is a technique used to adapt a pre-trained language model to a specific downstream task by fine-tuning it on task-specific data using prompts. > Prompting Tuning（提示微调），和微调会更接近，是自动化生成“软提示”的一种方法。具体怎么work后面会介绍，*不过在这里我们只需知道，Prompt tuning是微调的一种特殊形式，它是会改变模型的权重参数的，但它又比fine-tuning参数高效得多。* > **"Prompt tuning", a simple yet effective mechanism for learning "soft prompts" to condition frozen language models to perform specific downstream tasks.&#x20;**&#x55;nlike the discrete text prompts used by GPT-3, soft prompts are learned through backpropagation and can be tuned to incorporate signal from any number of labeled examples. ——[The Power of Scale for Parameter-Efficient Prompt Tuning](https://arxiv.org/abs/2104.08691) > 先用一个高亮块快速讲清楚提示学习的定义： > > > **提示学习（Prompt Learning）是一个非常General的术语，可以理解为涉及到提示词的机器学习范式都算是提示学习。**&#x7B80;单来说是通过一些方法编辑下游任务的输入，使其形式上模拟模型预训练过程使用的数据与任务。比如做情感分类任务时，监督学习的做法是输入“我今天考砸了”，模型输出分类的分数或分布，而提示学习的做法则是在“我今天考砸了”后拼接上自然语言描述“我感觉很 ____”，让模型生成后面的内容，再根据某种映射函数，将生成内容匹配到某一分类标签。&#x20; > > > > ——哈尔滨工业大学 ChatGPT调研报告 > > 再用这个高亮块快速讲清楚Prompt Learning范式的运作原理： > > **传统的预训练+微调**：预训练完后，利用有标签的下游数据集对模型做微调，这需要改变模型的权重与偏置参数。而后，基于下游任务输入x，模型预测输出y: P(y|x)。 > > **新范式预训练+Prompt+Predict**：基于输入x，根据模版（Template）将其转为特定的结构化提示x'，x'是一个具有一定格式但是不完整的句子，有一些字段还没有被填充。对于x'，模型会基于概率对其进行填充，得到完整的输入$$\hat x$$。基于这个$$\hat x$$，模型再预测输出y。 > Prompt learning is a general term that refers to the use of prompts in machine learning. In the context of natural language processing, prompt learning involves training a language model to understand and respond to a specific set of prompts.&#x20; 最后再额外提一嘴Prompt Engineering。语言的发展经历了四个范式：基于符号主义的全监督学习时代、基于神经网络的全监督学习时代、预训练+微调阶段和预训练+提示词+预测阶段，这四个阶段分别对应了四类工程：特征工程（手动提取特征）、结构工程（搭建更好的神经网络结构以更好的提取特征）、目标工程（选取好的目标函数）和提示工程。**提示工程**，指的是精心去设计提示词Prompt，以让语言模型可以生成我们想要的输出，最大的发挥语言模型的潜力。 ## 13.2 开端：当我们发现一个模型做的越大越好之后…… 我们在12.2.2.4中提到了，GPT-2模型的参数量达到了15.42亿，尽管其性能还不够好，但它确实证明了不断地去堆参数，把模型做的更大，模型性能还是可以继续上去的。但模型变大了以后，其他的问题就接踵而至。首先，有如下两个问题： * 预训练的模型大，所需要的预训练语料（数据量）就多。无监督预训练用的数据量多了，那么下游预训练的有标注数据相比之下就微不足道了。 * 预训练的模型大，参数量多，用反向传播算一次梯度的成本剧增。微调变得又贵又不可能。 * 此外，Fine-tuning毕竟是要基于有监督下游任务改变模型的Weights & biases的，所以很容易过拟合。 > 我们知道，GPT-2的模型参数为15亿，到了GPT-3就将达到1750亿个参数了。如此骇人听闻的参数规模，好不容易花了巨大成本预训练完，你再对他去做梯度下降，算反向传播算法，哪怕只是针对少量下游任务数据的fine-tuning，这个成本也是我们难以承受的。 > > 传统的解决方案是寻找参数高效（Parameter-Efficient）的迁移学习方法，即微调的时候不改变全部的参数，只去改变部分的参数就好了。能尽可能的少更新参数并尽可能保证任务性能，那也不错。 > > 但OpenAI团队不会只局限于此。他们的梦想是实现AGI，实现通用的、类似人的智能。人类可不会只擅长某一个具体的下游任务，参数高效的迁移学习再高效，毕竟也需要人为对任务做划分。因此，OpenAI更关注另一个的解决方案：能不能我们去把它应用于任何下游任务时，都不要去改模型的参数权重了，而是只需要用自然语言给模型一些提示词就可以？这就是Prompt。 > > **写这么多是希望大家可以知道：Prompt工程不只是工程师们的异想天开：这是让大力出奇迹的超大型模型能在多种场合都有所作为的前置要件，也是通往AGI的必由之路。** *** ## 13.3 前Prompt时代的尝试：参数高效学习 Parameter-Efficient Transfer Learning [【arxiv】Parameter-Efficient Transfer Learning for NLP](https://arxiv.org/pdf/1902.00751.pdf)&#x20; [参数高效微调指南](https://zhuanlan.zhihu.com/p/619583361) By [TimsonShi](https://www.zhihu.com/people/timsonshi) #### 13.3.1 参数高效的定义 * **全面微调：**&#x505A;针对下游任务的Fine-tuning时，更新模型的所有参数。这不可避免地导致模型对小的目标数据集过度拟合，继而在微调后不能用于其他任务。 * **参数高效微调（Parameter-Efficient Fine-tuning，PEFT）**：做针对下游任务的Fine-tuning时，不更新模型全部的参数。我们可能选择性的只更新模型最上面的几层权重，也可能只去更新偏置而不去改变神经元之间的连接强弱。我们的目的是在尽可能少更新参数的情况下尽可能保证模型的下游任务的性能。 #### 13.3.2 部分参数微调：选择法Selective Method 为了解决巨大的预训练模型的Fine-tune问题，研究人员们首先提出了部分参数微调/冻结部分参数的方法。 * **最早的一批工作是只微调网络的最上面几层。** * **后来人们认为可以根据人的经验和推理去微调网络中和下游任务最相关的部分。** 1. 首先，我们人类对模型的参数分布是有先验知识的。例如学完了第10章，我们就应该知道，Encoder部分负责编码语言为高维的向量，而Decoder负责生成目标的句子。 2. 有了类似这样的基于先验知识的假设之后，在微调模型的参数时，我们就可以更新和目标任务最相关的那部分。例如，如果要把一个用于生成摘要的Transformer转变为生成原文的Paraphrasing，那么可能我们就只需要改Decoder的参数就行了，而不去改Encoder。 * **更极端的做法是只微调模型偏置项或者某些行。** * **最极端的版本可能是稀疏地更新模型，无视模型结构，只更新某些参数。** #### 13.3.3 使用额外的参数增强现有预训练模型：附加法Additive Method **附加法的主要思路是使用额外参数或层增强现有预训练模型，它只训练这些新加入的参数。**&#x76EE;前这是最大、最广为应用的PEFT方法。附加法的实现方式为适配器（这里先不提软提示）。 **适配器 Adapter** **简单来说，就是在Transformer子层后面加入小的全连接网络。** > 在上述”部分参数微调“方法的基础之上，研究人员提出了Adapter方法，通过添加一个灵活的即插即用的可训练适配模块(Adaper Module)，我们可以改变模型某一层（或某几层）的数据分布，从而让模型可以适用于各种各样的任务和领域。典型的做法就是每一任务或者每一领域对应了一个Adapter Module，训练的时候只更新对应任务Adapter的参数，推理的时候激活对应任务/领域的Adapter，其它任务/领域的Adapter直接忽视。和”部分参数微调“方法相比，Adapter方法的优势有（1）更轻量级（2）同样比例的参数效果更好。 #### 13.3.4 基于重参数化的方法 Reparametrization-based PEFT [【arxiv】INTRINSIC DIMENSIONALITY EXPLAINS THE EFFECTIVENESS OF LANGUAGE MODEL FINE-TUNING](https://arxiv.org/pdf/2012.13255.pdf) 基于重参数化的PEFT方法（reparametrization-based PEFT）利用的是低秩矩阵表示来减少可训练参数数量。**目前使用最多的基于重参数化的方法是低秩适配（Low-Rank Adaptation, LoRA）**。LoRA这个名儿很多读者，尤其是关注Diffusion算法的读者肯定不会陌生！在很多应用中，Low-Rank Adaptation技术已经被证明非常有效。例如，在图像处理领域，利用低秩结构可以实现图像去噪、图像复原、图像分割等任务。在推荐系统中，Low-Rank Adaptation技术可以提高推荐算法的准确性和鲁棒性。不过我还没有想好要不要在这篇文章里介绍LoRA。 #### 13.3.5 对上述方法的评价 在12.3.2.2～12.3.2.4中，我们提到了很多参数高效的学习方法，他们用于解决LLM变得越来越大所以难以训练的问题。但是，我们可以看到，以上方法都是基于”预训练-微调“的范式的方法，无论多么轻量级，每个任务都还是有一套特定的参数（即使大部分参数可以共享）。 > 说到这里，大多数人其实并没有意识到，**它的致命缺点正是：任务本身需要人为进行定义**。但是现实生活中的知识，并不是完全地按照任务进行分类的，现实中大多数任务会涉及到多个任务的能力: 比如一个中国人阅读了一篇英文的文章，最后用中文写了个总结 --- 这就涉及到 翻译+总结 两个任务。**而Prompting可以做到模糊任务的界限---不需要人为对任务进行划分，相反，任务的描述会作为输入的一部分直接输入预训练模型。** > > 这其实就是为什么Prompting范式是“通往真正大一统语言模型的关键一步”。 *** ## 13.4 定义Prompting：通往真正大一统语言模型的关键一步  *图源: [Pre-train, Prompt, and Predict: A Systematic Survey of Prompting Methods in Natural Language Processing](https://arxiv.org/pdf/2107.13586.pdf)，这张图总结了NLP发展过程中出现的四种范式。右下角最后的两张图是Fine-tune范式和Prompt范式的鲜明对比：让预训练模型服从于下游任务，还是让下游任务服从于预训练模型。* ### 13.4.1 ***Prompting / Prompt Learning的定义*** 读完[*12.2.2.1*](https://s3tlxskbq3.feishu.cn/docx/NyPqdCKraoXz9gxNVCfcIFdnnAc#KUW4dyCAyo442wx04r0cAT6Fnvd)后，我们应该能够理解，Prompt的目的是将Fine-tuning的下游任务目标转换为Pre-training的任务，（即各种子任务都可以用基于下一词预测的Question Answering来表达）；且与此同时，我们不可以给下游任务构建特定的输入结构，不能添加额外的特殊符号。 提示学习这种方式拉近了测试分布与预训练分布的距离，进而可以利用大规模预训练语言模型在预训练过程中习得的强大语言建模能力，使其不经过微调就可以在各种下游任务上取得很好的结果。 采用Prompt的范式之后，Pre-train，Fine-tune的范式变成了Pre-train，prompt & predict。 > 融入了Prompt的新模式大致可以归纳成“pre-train, prompt, and predict”，在该模式中，下游任务被重新调整成类似预训练任务的形式。例如，对于一个预训练的GPT，我们在文本情感分类任务中，对于 "I love this movie." 这句输入，可以在后面加上prompt "The movie is ___" 这样的形式，然后让预训练语言模型用表示情感的答案填空如 "great"、"fantastic" 等等，最后再将该答案转化成情感分类的标&#x7B7E;**，这样一来，通过选取合适的prompt，我们可以控制模型预测输出，从而让一个完全无监督训练的PLM可以被用来解决各种各样的下游任务**。 > > ——[【知乎】NLP新宠——浅谈Prompt的前世今生](https://zhuanlan.zhihu.com/p/399295895) By [AI Box专栏](https://www.zhihu.com/people/dou-hong-jian-44)，作者：闵映乾@RUC&#x20; **在数学上区分fine-tune和prompt：** * 我们知道，Fine-tuning的过程是一个有监督学习的过程。基于输入$$x$$，以$$\theta$$为参数的模型会预测输出$$y$$的概率分布：$$P(y|x;\theta)$$，而后这个概率分布再会和我们标注的输出做比较，计算损失函数。 * 相比之下，Prompting的目的就是避开用标注数据做有监督的微调。因此，是没有输入输出pair（$$x$$与$$y$$）的。在数学上，它是这么做的：基于我们输入的input，模型会建模$$x$$的概率分布:$$P(x; \theta)$$*，*&#x800C;后用这个$$x$$的概率分布再去预&#x6D4B;**（Predict）**&#x6A21;型的输出y。 * 这样说话可能会比较Confusing。更清晰的说法我觉得是，模型能够做到理解我们的意图，并把我们输入的$$x$$稍加改造。被改造后的$$x$$，姑且称为$$\hat x$$吧，会是一个模型更熟悉的东西，模型基于$$\hat x$$去预测y。 * **可以看到，上述的过程是无监督的，而基于$$\hat x$$去预测y是语言模型本身就具有的能力。因此，关键在于怎么去设计把输入的$$x$$改造成$$\hat x$$的这个机制。** ### 13.4.2 ***Prompt最早还不叫Prompt，它只是一种模版（Template）*。** 13.2.2.1提到，关键在于怎么去设计把输入的$$x$$改造成$$\hat x$$的这个机制。这就让人不禁想到一个方法——用模版。 其实Prompt最早不叫这个名，他无非是一种模版。*所以我们可以看到，整个提出GPT-3的论文[Language Models are Few-Shot Learners](https://arxiv.org/pdf/2005.14165.pdf)（2020.5）里，Prompt这个词只出现了27词。但到了InstructGPT（2022.3）的时候，Prompt在论文中的词频就超过300次了。* Prompt最早是研究者们为了下游任务设计出来的一种输入形式或模板，它蕴含了不同的下游任务的信息，且输入形式和大语言模型进行预训练时的输入很像，因此能够帮助预训练语言模型“回忆”起自己在预训练时“学习”到的东西。 模版中有两个待填充的部分，一个叫input slot \[X]；一个叫answer slot \[Z]。 > 下表展示了一张基于预训练好的语言模型，在不做微调的情况下，利用模版与语言模型本身具有的下一词预测能力，完成各种下游任务的范例。 | **下游任务种类** | **任务** | **输入 Input \[X]****Input** | **模版 Template****把input映射成Prompt（1）** | **回答 Answer\[Z]****Predict（2）** | | ---------------- | ------------------------------- | ------------------------------------------------------------ | ------------------------------------------------------------ | ------------------------------------------ | | 文本分类 | 情感分类 | 这部电影真好看。 | \[X] 它是 \[Z]（这电影真好看。它是\[Z]？——>精彩的）*<再根据一个函数把“精彩的”三个字映射到积极含义>* | 精彩的（积极情感） | | | 主题分类 | 接下来我将批评一款游戏 | “\[X]”。这段话是关于\[Z]的话题。（“接下来我将批评一款游戏”。这段话是关于\[Z]？——>原神 | 原神 | | 文本对 | 自然语言推理（Entailment; NSP） | \[X1]故事发生在一个名叫提瓦特大陆的地方。\[X2]玩家在海拉鲁王国进行了一系列冒险。 | 我们知道，\[X1]。那么，“\[X2]”的说法是\[Z]的。（我们知道，故事发生在一个名叫提瓦特大陆的地方。那么，“玩家在海拉鲁王国进行了一系列冒险”的说法是\[]的。） | 正确错误无关 | | 文本生成 | 摘要 Summarization | 当年陈刀仔他能用20块赢到3700万，我用20万赢到500万不是问题。 | “\[X]”。这段话主要表达了\[Z]。 | 陈刀仔通过赌博巨量赚钱，我自然也能小赚一笔 | | | 翻译Translation | 看看你的。 | 中文：\[X]。英文：\[Z]（中文：看看你的。英文：_____）—> can can need | can can need | *\<Note：这个表格中的内容的目的是让一个已经预训练好的模型可以用于各种各样的下游任务，可能跟我们比较熟悉的ChatGPT还不那么relevant。毕竟在ChatGPT横空出世之前，大家训练LLM的目的不是为了ChatBot，而是各种自然语言的自任务啦。>* （1）在这里，我们把我们输入的词叫做Input。Input首先会被一个函数$$f_{prompt}$$映射成一个Prompt，映射函数的功能可以是基于我们的input去填充Template中\[X]的部分。Prompt是一个模版，也是一个不完整的句子，会有unfilled slot，即\[Z]的部分。这时候就有另一个函数——$$f_{fill}$$。 （2）$$f_{fill}（prompt）$$会计算出\[Z]中的内容的概率分布。Answer的就是往Z里面填充的**正确**的东西。在上面的例子中，语言模型的目的就是输出正确的Answer。 > **提示工程 Prompt Engineering：**&#x6307;设计提示函数$$f_{prompt}(x)$$，从而在下游任务中取得好的性能的过程。 > > **可以这么理解：Prompting范式的出现使得在面对下游任务时，我们不再需要像以前那样Fine-tune一个大型预训练模型，而是只需要训练一个好的把输入文本映射为模板的函数$$f_{prompt}$$就可以了。** > > 这样一来，怎么选好模版与映射函数就很重要。例如，在情感分类的示例里，这部电影真好看和那个模版是匹配的，但如果想要辨别“而你，我的朋友，你才是真正的英雄。”这句话的情感，那个模版就文不对题了。 ### 13.4.3 ***Prompt的一般工作模式（最General的一款）*** 13.2.2.2中其实已经讲明白了基于Template的Prompt具体是怎么工作的。现在我们来整理一下整个过程。  1. 首先我们基于海量的无标签数据通过自监督学习来预训练出一个语言模型。**（Pre-train）** 2. 向模型输入文本$$x$$。就像现在我们在给ChatGPT写输入一样，输入文本可以写的比较随意；但懂技术的我们肯定知道，不同的文本会有非常不同的效果，精心的、按照一定规则去写的prompt更能发挥模型的能力。 3. 对于$$x$$，我们针对具体的下游任务设计了一个以$$x$$为输入的函数$$f_{prompt}$$。我们规定，$$f_{prompt}(x)$$=$$x'$$。这一函数的作用就是让人输入的自然语言$$x$$可以转变为一个更能让机器“想起”在预训练的时候学习到的东西的输入模版$$x'$$。*\<Prompt之所以叫做Prompt（提示词），而不叫instruction（指令），就是因为它是一段能让机器回忆自己预训练所学的文字>。*&#x5177;体的，可以参考13.2.2.2中的表格。**（Prompt）** *(这里$$f_{prompt}$$本身也可以是一个语言模型，把我们的输入填到模版里这件事本身也可以是基于概率分布的。)* * 就像13.2.2.2中展示一样，$$x'$$中有两个待填充的槽（slot）：一个是输入填充槽（input slot）\[X]，一个是答案填充槽（answer slot）\[Z]。其中，\[X]是根据我们的input填充的。 * 对于$$f_{prompt}(x)$$=$$x'$$，我们已经通过$$f_{prompt}$$把input $$x$$填充到了模版中原有的unfilled slot \[X]里，产生了$$x'$$。$$x'$$中还是有unfilled slot ，即\[Z]。现在我们通过另一个函数$$f_{fill}(x',z)$$，试图生成一段文本把这个\[Z]给填充起来。**这个过程我们称为Predict，预测**。做“预测”这件事情的就是我们预训练好的大语言模型。**（Predict）** > **回答工程 Answer Engineering：**&#x6307;的是设计回答$$z\in \mathcal Z $$，以让z填充\[Z]的机制的工程。 > > 1、这里的$$z$$可以是一个有限的选择，尤其是在分类任务中，例如我们之前做情感分类时的崩、典、急、孝、麻五种。也可以生成任何文本用于填充\[Z]，尤其是在生成式任务中（like GPT）。 > > 2、语言模型可以做两件事。首先是它它老本行：判断一整句话Make sense的概率。这个功能可以用于给句子打分。例如，我们在填充\[Z]时，可以把崩、典、急、孝、麻五种都尝试一遍，对每一个都打分，然后选分数最高的一个。 > > 3、其次是下一词预测，它可以用来生成任意的填在\[Z]里的内容，而不需要人类去提前规制。 * 生成一段文本$$z$$来去填充\[Z]也是个概率采样的问题，会有不同的选择，因此会有很多种Filled Prompt。我们会选择打分最高的$$z$$，即图中的$$z*$$来作为输出。 * 最终，语言模型输出$$z*$$。这样，我们就在没有微调，而只是设计了模版和$$f_{prompt}$$的情况下完成了下游任务。 ## 13.5 Prompt Engineering & Prompt Tuning 设计指令和模版看起来很容易，但是在实际使用过程中，预训练模型很难“理解”这些指令。 > Prompt engineering is the process of creating a prompting function fprompt(x) that results in the most effective performance on the downstream task. In many previous works, this has involved prompt template engineering, where a human engineer or algorithm searches for the best template for each task the model is expected to perform.&#x20; **提示工程 Prompt Engineering：**&#x6307;设计提示函数$$f_{prompt}(x)$$，从而在下游任务中取得好的性能的过程。 ### 13.5.1 手动设计提示模版与自动模版学习 #### 13.5.1.1 手工Prompt * 在最开始的研究中，这涉及到提示模板工程，即由人类工程师或算法为模型预期执行的每项任务寻找最佳模板。背后的思维在于，人类有自己的先验知识，包括对模型的理解和对语言的理解，因此手动去设计模版是一件非常顺直觉的事。*（Perhaps the most natural way to create prompts is to manually create intuitive templates based on human introspection）[13.4.2](https://s3tlxskbq3.feishu.cn/docx/NyPqdCKraoXz9gxNVCfcIFdnnAc#GuCCdWSoQooEGexSu1zcN2eXntg)*&#x4E2D;的表格里的prompt都属于这一范畴。 \#参考下表，手动去设计一个`我们知道，[X1]。那么，“[X2]”的说法是[Z]的`这样的模版是完全顺直觉的，而且模版往往也由自然语言构成。 | 自然语言推理（Entailment; NSP） | \[X1]故事发生在一个名叫提瓦特大陆的地方。\[X2]玩家在海拉鲁王国进行了一系列冒险。 | 我们知道，\[X1]。那么，“\[X2]”的说法是\[Z]的。（我们知道，故事发生在一个名叫提瓦特大陆的地方。那么，“玩家在海拉鲁王国进行了一系列冒险”的说法是\[]的。） | 正确错误无关 | | ----------------------- | --------------------------------------------- | -------------------------------------------------------------------------------------- | ------ | > 但手动设计模版这件事还是存在很多局限性：首先，模版很难设计，背后需要工程经验甚至天马行空的沾点艺术的灵感，颇有些以往的“专家系统”的味道，从历史发展的角度看，这注定会被淘汰；其次，研究机器学习的人懂个屁的机器，符合人类直觉的提示词不一定是最能激发机器的潜能的。Optimal prompts可能是在人类看来很诡异的token组合，只靠人类自己拍脑袋的话，一辈子都想不出来。 > > > &#x20;(1) creating and experimenting with these prompts is an art that takes time and experience, particularly for some complicated tasks such as semantic parsing (Shin et al., 2021); (2) even experienced prompt designers may fail to manually discover optimal prompts (Jiang et al., 2020c).&#x20; #### 13.5.1.2 参数化Prompt/自动 Prompt \#哼哼，我们都有GPT-3这么牛逼的东西了，为什么不干脆让模版也由机器来写呢？ * 于是，就有了**自动模版学习（Automated Template Learning）**，也就是说不再由人类拍脑袋来设计Template，Template也由机器来自动生成，机器决定Template有哪些文字，input slot在哪，answer slot在哪。 * 一旦把格局打开，让语言模型去写模版后，就有了许多新的可能性：首先是可以发挥神经网络的优势，去做试错学习，不断挖掘、迭代和优化$$f_{prompt}(x)$$，让性能不断变好。其次是可以发挥人工智能具有的自动化的能力，例如实现为每个输入生成一个自定义模板，而不是一个模版走天下。从而，自动模版学习产生了两种分类方式： * 离散型提示（discrete prompts）和连续型提示（continuous prompts）。前者就是文本构成的模版，后者则还是在LLM嵌入层的向量空间里的向量组合。 * 静态提示Static Prompt和动态提示Dynamic Prompt。静态的Prompt对每个输入使用基本相同的提示模板，而动态的为每个输入生成一个自定义模板。静态和动态策略都被用于不同种类的离散和连续提示。 > &#x20;In particular, the automatically induced prompts can be further separated into discrete prompts, where the prompt is an actual text string, and continuous prompts, where the prompt is instead described directly in the embedding space of the underlying LM。 ### 13.5.2 离散提示/硬提示 Discrete Prompt a.k.a Hard Prompt **在自动模版学习中，离散提示或者硬提示，就是生成以自然语言的文本形式存在的提示模版的意思。** 叫这个名字是因为自然语言本质上是一个个one-hot向量的token构成的序列，处在一个离散的空间。相比之下，以稠密向量的形式在嵌入层存在的提示就是连续的。*（Works on discovering discrete prompts (a.k.a hard prompts) automatically search for templates described in a discrete space, usually corresponding to natural language phrases）*。 它主要有如下的生成方式： 1. **Prompt Mining 提示挖掘**：通过分析大量的文本数据，识别出其中的关键词、短语和句子，并将其组合成一系列简洁而有效的“prompt”作为自然语言模型的输入。 2. **Gradient-based Search 基于梯度的搜索**：梯度下降/上升是一种寻找极小值/极大值的方法，自然可以用这种方法来寻找最优的prompt。由于离散领域中没有可微函数，因此需要对梯度下降算法进行一些改进，导致基于梯度的搜索的硬提示生成比较复杂。 3. **Prompt Generation 提示词生成：**&#x5C06;提示词的生成视为一项文本生成任务，并使用标准的Generative自然语言模型来执行这项任务。例如基于seq2seq架构的T5模型 ### 13.5.3 连续提示/软提示 Continuous Prompt a.k.a Soft Prompt \#等等，我们真的在乎模版是不是“自然语言”构成的吗？——你的下一句提示词，又何必是提示词！ > 对于一些软提示方法，例如Prefix-Tuning和P-tuning，他们重新审视了关于模版的定义，放弃了“模版由自然语言构成”这一常规要求，从而将模版的构建转化为连续参数优化问题，虽然简单，但却有效。 > > ——[P-tuning:自动构建模版，释放语言模型潜能 - 科学空间|Scientific Spaces](https://spaces.ac.cn/archives/8295/comment-page-1) By 苏剑林大佬 > 因为构建提示的目的是找到一种能让LM有效执行任务的方法，而不是供人使用，所以没有必要将提示限定为人类可理解的自然语言。正因如此，学者们又提出了连续提示（又称软提示）的方法，**直接在模型的嵌入空间中进行提示。** > > （说是这么说，但实际操作起来其实就是冻结模型的大部分参数，而只去fine-tune一部分代表了下游任务的参数，这部分没有被冻结的参数就是软提示） > > Note：这一部分的数学推理如果要写出来会非常复杂，不符合入门文档的定位，所以基本上是在文字建模。论文原文的地址我基本都有放出来，感兴趣or功底好的朋友们可以去学。 #### 13.5.3.1 软提示为我们带来了什么：Template的的嵌入向量不再一定是自然语言的词嵌入 *连续 Prompt 允许使用任意词向量作为模板词的表示，这些构成Template的稠密向量不必来自于自然语言的词汇表中，可以不对应任何一个词典里的Token。* 这个限制的松散有以下几个意义： 1. **更灵活的模板表示方式：**&#x5728;某些任务中，自然语言词汇表中的词向量可能无法准确地表示模板中的单词。例如，对于一些特定的领域或术语，自然语言词汇表中可能没有对应的词汇，此时使用自然语言词汇表中的词向量表示模板中的单词可能会导致模板的表示不准确，从而影响模型的性能。因此，松散这个限制可以使得模板的表示更加灵活，可以更好地适应不同的任务和场景。 2. **更广泛的应用场景：**&#x677E;散这个限制可以使得模板可以适用于更广泛的应用场景。例如，对于一些非自然语言的任务，例如代码生成、机器翻译等，使用自然语言词汇表中的词向量来表示模板中的单词可能没有意义，因为这些任务需要的是代码或其他非自然语言的表示方式。 #### 13.5.3.2 软提示为我们带来了什么：取消了模板由预训练的LM的参数决定的限制。 模板不再受预训练语言模型参数的参数化限制的意义在于，现在我们可以使用独立的模板参数来定义模板，而不需要依赖预训练语言模型的参数。 这个意义主要有以下几点： 1. **更灵活的模板表示方式：**&#x5728;以前的方法中，模板的表示是由预训练语言模型的参数来决定的。这个限制会导致模板只能使用预训练模型中定义的参数，因此限制了模板的灵活性。而现在，模板不再受预训练模型的限制，可以根据具体任务的需求，定义适合该任务的模板参数，从而提高模板的灵活性和适用性。 2. **更精细的模板调整（Prompt-tuning）：** > 一旦将模版从离散的自然语言变成了连续的参数（稠密的嵌入向量），我们就可以用随机梯度下降等方式去优化它。 > > 使用独立的模板参数可以让我们更精细地调整模板，只需要精调模版的参数，而不需要去改变整个预训练大语言模型。这就引申出了Prompt-Tuning的概念：**Prompt tuning通常指微调模板中的参数，以适应特定的下游任务。**&#x5728;Prompt tuning中，整个预训练语言模型通常不会被微调，而只有模板的参数会被微调。 具体而言，Prompt tuning的目标是通过微调模板的参数，使得模板能够更好地与下游任务的输入相匹配，从而提高下游任务的性能。通常情况下，模板中的参数是在预训练模型的基础上学习得到的，因此模板的参数微调相当于是在原始的预训练模型上微调得到的模板。因此，尽管Prompt-tuning让我们不再需要去更改整个预训练LLM的参数，省下了大量功夫，但在微调模板时，预训练模型的知识和能力仍然发挥了重要作用。 #### 13.5.3.3 软提示的生成方法：从Prefix-Tuning到Prompt Tuning 1、软提示的第一阶段：Prefix-Tuning，***2021.1*** [【Arxiv】Prefix-Tuning: Optimizing Continuous Prompts for Generation](https://arxiv.org/abs/2101.00190) **Prefix-Tuning（前缀微调）**&#x662F;一种将连续的特定任务向量序列预加到输入之前的方法，通过在模型的输入前添加一个可训练的前缀（prefix），来调整模型的行为。 参考右图，**在Prefix Tuning中，模型的结构被略微的调整，它在input和每个hiddern layer前都加入了一个参数可调的前缀。**&#x524D;缀是可训练的，而后缀（预训练模型原有的结构）的参数通常是冻结的。 Prefix Tuning与传统的Fine-tuning方法不同，它只需要微调前缀的参数，而不需要微调整个模型。因此，它可以被看作是一种更轻量级的Fine-tuning方法。  为什么说这个方法其实就是一种软提示呢？这是因为，前缀的那些稠密的向量们（我们姑且称之为任务向量），它其实就是一种Prompt，意图是告诉模型现在该去做什么任务了，只不过用的不是自然语言，而是我们人类看不懂的一大串数字而已。它其实和前面参数高效微调PEFT中提到的[Adapter](https://s3tlxskbq3.feishu.cn/docx/NyPqdCKraoXz9gxNVCfcIFdnnAc#QQowdqICKoSqeQxKDZKcY6zXndb)的思路很像，都是增加额外参数的思路；但它不在模型的最后一层做一个全连接，而是在模型的嵌入层的时候就把一段特定的任务向量拼接给输入的词序列。 2、对前缀精调的第一次简化：P-Tuning（ Hard-Soft Prompt Hybrid Tuning，软硬混合的Tuning）**&#x20;*2021.3*** [【Arxiv】GPT Understands, Too](https://arxiv.org/abs/2103.10385)（P-Tuning V1） [【arxiv】P-Tuning v2: Prompt Tuning Can Be Comparable to Fine-tuning Universally Across Scales and Tasks](https://arxiv.org/abs/2110.07602)（P-Tuning V2） > 最近Arxiv上的论文[《GPT Understands, Too》](https://arxiv.org/abs/2103.10385)提出了名为P-tuning的方法，**成功地实现了模版的自动构建**。不仅如此，借助P-tuning，GPT在SuperGLUE上的成绩首次超过了同等级别的BERT模型，**这颠覆了一直以来“GPT不擅长NLU”的结论，也是该论文命名的缘由**。 > > ——[P-tuning:自动构建模版，释放语言模型潜能 - 科学空间|Scientific Spaces](https://spaces.ac.cn/archives/8295/comment-page-1) By 苏剑林大佬 Instead of using a purely learnable prompt template, hard-soft hybrid tuning methods insert some tunable embeddings into a hard prompt template.&#x20; > 简言之，软硬混合的提示调优指的是在离散的硬提示（构成的嵌入张量）中插入一些可以微调的任务嵌入。 P-tuning，即通过在嵌入输入中插入可训练、微调的变量来学习连续的提示语。  具体的，P-Tuning的运作原理大概可以归纳如下： 1. 输入一个句子，以及预先设计的一个离散的模板。以输入“`The Disney film is good`!”、模版：`[X],it was [Z]`为例，于是会有：`The Disney film is good！It was [MASK].`； 2. 对输入的template中，挑选一个（或多个）token作为pseudo token：`The Disney film is good! [pseudo] was [MASK]`.其初始化可以直接使用原本的token embedding。 3. 对所有的pseudo token $$\mathcal P_i$$ ，喂入一层LSTM，并获得每个pseudo token输出的隐状态向量 $$h_i$$。 4. 将整个句子喂入GPT的embedding layer，对于pseudo token部分的token embedding，就用$$h_i$$ 来替换。最后基于这样的张量，GPT就产生对应的输出。 3、对P-Tuning的进一步简化Prompt-Tuning ***2021.4/2021.8*** [【arxiv】The Power of Scale for Parameter-Efficient Prompt Tuning](https://arxiv.org/abs/2104.08691) > ***We freeze the entire pre-trained model and only allow an additional k tunable tokens per downstream task to be prepended to the input text.&#x20;*** * 在GPT-3中，Prompt Token $$P$$是模型的嵌入表(Embedding Table)的一部分，因此受模型的冻结参数$$\theta$$决定。由于参数是冻结的，所以找最优的Prompt一般需要人为搜索或者使用不可微自动化搜索方法（硬提示的问题） * Prompt Tuning依然冻结$$\theta$$，但消除了提示由$$\theta$$参数化的限制；相反，Prompt Tuning中的Prompt有自己的专用参数 $$\theta_P$$，可以通过反向传播算法更新。 Prompt Design（手动设计离散的template）可以看做从冻结嵌入的固定词汇表中选择Prompt Token，而Prompt Tuning可以看做token已经确定，但是embedding是可以学习的。 * 相较于Prefix Tuning，在Prompt-Tuning中，每个hidden layer不再需要对应添加相同长度的前缀，因此模型结构完全没有改变；只是让一些Token的Embedding参数变得可以微调，这部分参数大概占模型总参数的0.1%。Prompt Tuning也因此更加灵活。 #### 13.5.3.4 软提示真就一定比硬提示好吗？ 答案是未必。连续提示确实有*13.5.3.1*和*13.5.3.2*中提到的好处，但它最大的问题在于，它本质上还是一种类似前prompting时代的参数高效的fine-tune方法，只不过它的Adapter并不是在整个模型的输出之前加上的一个全连接层，而是放在了模型的嵌入层。于是从底层原理上，它就一样会发生类似于Fine-tuning的过拟合/任务性能不稳定等现象。此外，我们相信Soft prompting是参数高效、节约资源的，但不管怎么解释它依然需要靠反向传播去tune参数，而且还存在伪资源节约等问题。 **后面我们会看到，在2021年，软提示火了一整年，但后来谷歌依然用思维链提示，让硬提示狠狠的来了波文艺复兴。** ### 13.5.4 推荐文章： [【知乎】ChatGPT的前生: Prompting思想](https://zhuanlan.zhihu.com/p/608139212) By [潘小小](https://www.zhihu.com/people/pan-xiao-xiao-66-14)&#x20; [Fine-tune之后的NLP新范式：Prompt越来越火，CMU华人博士后出了篇综述文章](https://mp.weixin.qq.com/s/2eA4PBd-wr9tVyyuzJ66Bw) By 机器之心 [论文解读：Prefix-Tuning: Optimizing Continuous Prompts for Generation](https://blog.csdn.net/qq_36426650/article/details/120255851) By [华师数据学院·王嘉宁](https://wjn1996.blog.csdn.net/) [论文解读：GPT Understands, Too](https://wjn1996.blog.csdn.net/article/details/120802305) By [华师数据学院·王嘉宁](https://wjn1996.blog.csdn.net/) *** ## 13.6 ChatGPT/InstructGPT/GPT3.5：SFT（有监督微调）or Instruct-Tuning（指令精调），与RLHF（基于人类反馈的强化学习）（2022.3） 论文原文：[【Arxiv】Training language models to follow instructions with human feedback](https://arxiv.org/pdf/2203.02155.pdf) 根据 OpenAI 的博客，InstructGPT所用到的指令学习的方法和ChatGPT基本是一致的。所以这里就讲InstructGPT这篇文章,我们可以从中一窥ChatGPT的原理。 ### 13.6.1 摘要 Abstract > 让语言模型变得更大并不意味着它们能更好地遵循用户的意图。例如，大型语言模型可以产生不真实的、有毒的或根本对用户没有帮助的输出。换句话说，这些模型没有与用&#x6237;**“对齐”（Aligned，对齐是一个我比较喜欢的翻译）**。在本文中，我们展示了一个途径，通过人类反馈的微调，在广泛的任务中使语言模型与用户的意图保持一致。从一组标签员写的Prompt和通过OpenAI API提交的Prompt开始，我们收集了一组由Labeler人工去写的回答，作为我们希望的模型行为（desired model behavior）的数据集，我们使用监督学习来微调GPT-3。然后，我们收集模型输出的排名数据集，我们利用人类反馈的强化学习来进一步微调这个监督模型。我们把产生的模型称为InstructGPT。在人类对我们的提示分布的评估中，尽管参数少了100倍，但1.3B参数的InstructGPT模型的输出比175B的GPT-3的输出更好。此外，InstructGPT模型显示了真实性的改善和有毒输出生成的减少，同时在公共NLP数据集上，测试性能也没有降低太多。尽管InstructGPT仍然会犯一些简单的错误，但我们的结果表明，利用人类反馈进行微调是使语言模型与人类意图相一致的一个有希望的方向。 > > ——[【Arxiv】Training language models to follow instructions with human feedback](https://arxiv.org/pdf/2203.02155.pdf) ### 13.6.2 要解决的问题：Misaligned ***大语言模型存在哪些问题：*** 通过让模型更大，我们把更多的数据用Transformer压缩到了模型的权重、偏置等参数里，这可能会让模型更好的在各种任务场合下实现下一词预测，但不代表可以让模型更符合用户的意愿。例如： 1. **Simply not useful，即讲废话**。如果你问了模型一个具体的问题，但模型顾左右而言他，像写公文一样说了一堆看似有道理其实毫无价值的废话，那这个模型可能就是不够合格的。 2. **Untruthful Hallucinations：错误的、AI产生的幻觉**（在自然语言处理中，幻觉通常被定义为“生成的内容与提供的源内容无意义或不可信）。我们都知道，ChatGPT喜欢一本正经的胡说八道，一个很知名的梗就是向ChatGPT提问，林黛玉倒拔垂杨柳的事情。它回答的真的非常好（❌）  > ChatGPT 特别擅长编造东西，因为它必须处理的数据量非常大，而且它收集单词上下文的能力非常好，这有助于它将错误信息无缝地放置到周围的文本中。 * **Toxic：有害的内容**。例如，让GPT去帮人写假新闻、帮你大量的写垃圾邮件、写犯罪计划、写作为一个AI如何统治人类；或者让GPT输出侮辱性的、种族歧视的言论等等。 ***这样的问题为什么会存在：Misaligned*** > An Underlying Premise：我们反思这样的问题为什么会存在时，其实首先我们已经认可了一件前提：人工智能应该输出我们人类喜欢的、符合我们人类需求的东西，而不只是“精准”的下一词预测。 > This is because the language modeling objective used for many recent large LMs—predicting the next token on a webpage from the internet—is different from the objective “follow the user’s instructions helpfully and safely” (Radford et al., 2019; Brown et al., 2020; Fedus et al., 2021; Rae et al., 2021; Thoppilan et al., 2022). Thus, we say that the language modeling objective is misaligned. Averting these unintended behaviors is especially important for language models that are deployed and used in hundreds of applications. 我们每次向模型提一个问题，我们都期待模型给一个我们期待的，能够解决我们的问题而且安全无害的答案。这才是模型真正的目标函数。尽管LLM可以被以“Prompt”的输入来实现很多NLP任务，包括前面提到过的Zero-shot 0S、One-shot 1S、Few-shot FS，**但它的目标函数却很简单，无非是更好的去做下一词预测：** $$L_1(\mathcal U) =∑_ilogP(u_i|u_{i-k},u_{i-k+1}...,u_{i-1};\theta)$$ 这一目标函数当然和我们人类真正想要的helpful与safe等要求有很大的偏差。由此我们定义了Misalignment:LLM在训练时的目标函数和人类的真实意图存在很大的区别，很好的下一词预测不代表很好的符合用户需求。 ***这些问题严重吗：答案是，非常严重！*** **先不讲客户体验，我们直接看一些关乎一整个产品的生死存亡的问题。** * 首先美国是一个非常讲政治正确的国家，有一堆价值观要去遵循，挑剔的很。例如，你去让LLM做下一词预测，例如，A man is ___的下一词预测，和A woman is ____的下一词预测的比较，可能会非常不一样。哪怕预测下来，A man is最大可能输出Lazy，而A woman is最大可能输出Beautiful，也会有人指责你说这说明这个模型更加注重女性的外貌，还是一种Bias。总之，非常难伺候。 * 其次，舆论对于创业公司可能会好一些，但对于大公司真的是非常挑剔。参考文章：[Google apologises for Photos app's racist blunder](https://www.bbc.com/news/technology-33347866)，2015年Google上线了一款产品，可以去识别图像中的各种元素，例如Skycrapers、Cars等，结果把几个黑人识别成了Gorillas，即大猩猩。媒体们知道这件事后直接炸毛了，而Google也不得不疯狂道歉，后来甚至下架了产品。**好好的一款产品，就这么没了，嘻嘻**  * 中国和美国一样，也有很多不能碰的话题，而且一旦输出了非常不符合我们的核心价值观的内容、触痛到了一些不能碰的雷点，可能连产品带公司都给一次性封杀掉了。 **看完生死存亡后，我们再考虑客户体验。**&#x5728;一些应用场合，尤其是工业级应用场合，我们肯定还是希望模型的生成具有稳定的，not helpful甚至幻觉的输出可能会降低客户的付费意愿，甚至阻碍LLM的商业化落地。因此，我们确实需要想办法来解决Misaligned这个问题。 ### 13.6.3 解决该问题的方法：基于人类反馈的强化学习，Reinforcement Learning with Human Feedback, RLHF ***先验知识：基础的强化学习知识。见第五章，[这里是链接](https://s3tlxskbq3.feishu.cn/docx/NyPqdCKraoXz9gxNVCfcIFdnnAc#CqqQdmKS8o0yWuxc3hccrZXWnwh)。***&#x4F;penAI写RLHF的这个团队本身是做强化学习出家的，在这方面本来就很有一套。 看完论文的摘要和12.6.2提到的问题，我们肯定对Instruct GPT的目的有一个基本的了解了，即让语言模型和人类的Align做的更好一些，更helpful也更安全。**具体而言，他们采用的方法是RLHF，即基于人类反馈的强化学习。**  虽然对于很多读者来说这都是我们第一次接触到强化学习，但RLHF具体用到的思维和方法其实都相对比较简单。回到第五章大概理解强化学习的算法后，耐心的看下去就行。 *** #### 13.6.3.1 **Step1: Supervised Fine-tuning（SFT），基于监督的微调** > Collect demonstration data, and train a supervised policy 先不要去管什么Policy不Policy的，第一步其实就是一个很简单的用标注数据去给模型做微调的过程，如果没有后面两个步骤的话，这一步就根本算不上强化学习。 1. **收集Prompt。**&#x50;rompt有两个渠道来源：1、花钱雇人，人工来写。2、用户使用GPT产品时提交。 2. **对于收集来的Prompt，人工的给它写Output。**&#x4EBA;工给它写的output（OpenAI管它叫做**Demonstration Data or Labeler Demonstration**）自然得是desired output，如果模型能一直输出这种水平的答案那是最好。 3. **通过第一和第二步，其实我们就得到了一个标注数据集**。利用Prompt（输入）+Labeler Demonstration（标准输出），我们就可以用Fine-Tune的范式去微调GPT。  OpenAI把上述的这个微调GPT-3的流程称为**Supervised Fine-tuning，SFT**。原理上，它和微调别的东西其实没有什么区别。 ***#SFT又称Instruction-Tuning（指令精调）。它是我们通往ChatGPT之路的第二块拼图。*** ***那么它和强化学习有什么关系呢？一直用大量的人工标注去做Fine-tune，不就好了，为什么还要去用RLHF？*** 首先，可以这么去理解： > 整个被SFT后的GPT-3其实就是一个巨大的Policy函数，这个Policy函数以用户的输入（Prompt）为自己的状态State，并在该状态下采取Action，即输出一段回答。**这样一来，想要获取一个好的LLM模型，就不仅可以靠标注数据做Fine-tune实现梯度下降了，还可以通过策略梯度等算法去获取一个好的策略函数。** ***那么，用Labeler Demonstration不应该很香吗，为什么不全靠Fune-tune呢？*** * 首先，花钱雇人去帮你写desired output还是一件非常贵的事情。你得去专门的给人培训，告诉人家怎样的答案才是好的，要避开哪些不能提的东西，什么时候要直指要害而什么时候要圆滑。 * 此外，自然语言的Prompt有那么多，千奇百怪，我们很难用人工写答案的方式做一个全覆盖。 * 最后，也是前面在*12.3.1*中提到的，当一个语言模型变得越来越大，找到足够的标注数据集去Tune它就会变得又贵又不可能。 **因此，出于工作量还有成本的考虑，必须得想一个更聪明的方法，让模型和人类对齐。这个方法就是强化学习**。 *** #### 13.6.3.2 Step2: 训练一个奖励模型，Reward Model，RM > RM 的训练是 RLHF 区别于旧范式的开端。RM模型接收一系列文本并返回一个标量奖励，数值上对应人的偏好。其实在*6.3.1*里我们就提到过，语言模型LM的本质既可以是下一词预测，也可以是判断一句话是否Make Sense的概率；那自然，它也可以用于对一句话打分嘛。**因此，其实RM它也是一个语言模型。** 我们知道，让人去写一段desired output作为标签的话，成本会很贵，因为它是一个生成式的任务。相较而言，如果人类只需要去做判别式任务，那么工作量就会减小非常多。RLHF其实就是这个思想。 前面提到过了，整个被SFT后的GPT-3其实就是一个巨大的Policy函数，这个Policy函数以用户的输入（Prompt）为自己的状态State，并在该状态下采取Action，即输出一段回答。现在我们去回想强化学习的构成要素，即：基本元素层：【环境Environment、玩家Agent、目标Goal】；主要元素层：【状态State、行为Action、奖励Reward】；基本元素层：【策略Policy、价值Value】。 > 值得注意的是，在RL中，我们可以使用奖励函数而不使用价值函数来训练策略，从而实现策略梯度算法。这种方法被称为纯粹的策略梯度方法（pure policy gradient methods）。也就是说，上面提到的东西中，Value是可以不要的。 那么，为了训练出一个最佳的Policy函数，也就是能和我们的价值观对齐的LLM，目前还缺少的要素是奖励Reward。 Step2的目的就在于此，我们想要训练出来一个好的奖励模型，让他给模型输出的结果去打分。  **训练出一个奖励模型（Reward Model，即RM）的步骤如下：** 1. **采样一个Prompt，对模型输入该Prompt后，模型会给出多个不同的输出**。 > ***但是模型参数在推理的时候是不变的，为什么在推理的时候GPT还会有随机性？*** > > A：这是因为在生成文本时，GPT模型会采用一种称&#x4E3A;**“采样（Sampling）”**&#x7684;策略，该策略会引入一些随机性。 > > 具体来说，GPT模型在生成文本时，通常会根据前面的文本内容预测下一个单词或字符，并从预测的概率分布中进行采样。前面讲过Greedy Decoding和Beam Search，**不过ChatGPT它采用了Top-K Sampling的方法而非argmax做概率采样，即限制在预测的概率分布中只保留前K个最可能的单词或字符，然后从这K个单词或字符中随机采样**。自然的，这样的采样方法会让模型产生多种不同的输出， * **由人工Labeler来给模型的多种不同的输出做一个排序。**&#x4F8B;如，输出了A、B、C、D后，标注员认为，D>C>A=B。 * **通过1和2，我们得到了一组数据集，这组数据集的目的是训练出一个奖励函数，即RM。**&#x5177;体的路径为：RM也是一个神经网络，输入给RM的是模型给出的output，输出的RM对output的一个打分。我们首先随机初始化Reward Model，让他去给Prompt的输出打分；而这个打分的结果应该是要符合Labeler的排序的。如果不符合的话，我们就做一个梯度下降。总之，训练的目标函数就是让RM给模型的输出的打分符合Labeler给他做的一个排序。 我们可以看到，Train这个Reward Model的过程本身也不是一种强化学习，而是标准的有监督学习，监督信号是我们人工标注的打分排序。只不过这个reward model在后续会被用于强化学习而已。 *** #### 13.6.3.3 Step3：以大模型本身为策略函数，以训练出的RM为奖励函数，通过PPO算法去微调模型 > Optimize a policy against the reward model using reinforcement learning. 到这里过，整个要素就非常清楚了。我们要做的无非就是基于已有的奖励函数，去利用策略梯度算法去优化我们的策略函数，也就是LLM。 相信大家看完第五章后多少也理解强化学习的基本思想了，这篇文章不打算对PPO（近端策略优化 ，Proximal Policy Optimization）算法做细致的介绍。它真的没有什么难的，理解Train出来一个奖励模型后，我们就可以对策略函数不断更新梯度，从而让他表现的更好，就可以了！ （事实上，如果细讲技术原理和工程问题的话，这一步还是很复杂的。怎么将熟悉的RL算法应用于如此大的一个模型一直是一个挑战。）  Step3讲的其实非常简略，只是讲了算法思想的程度。如果想要了解更多，可以参考：[ChatGPT 背后的“功臣”——RLHF 技术详解 By HuggingFace](https://mp.weixin.qq.com/s/TLQ3TdrB5gLb697AFmjEYQ)。 虽然我们说这一步无非是个PPO而已，但仔细想的话可能会觉得语言模型的PPO和普通强化学习里的PPO不大一样。如果想到了这一步而且觉得好奇的话，可以参考：[详解大模型RLHF过程（配代码解读）](https://zhuanlan.zhihu.com/p/624589622?utm_medium=social\&utm_oi=1239682420452487168\&utm_psn=1635641325230948352\&utm_source=wechat_session)。这超出了本文档介绍的范畴，技术难度也会更大一些，所以这里就先不讲啦。 > **#RLHF是我们解锁GPT-3的能力，让它走向ChatGPT的最后一块拼图。** > > 一个大如GPT-3的语言模型，其初步具备了一些0S和FS的能力，*这可能是因为语料库中本来就有类似的指令，完成人类向他提出的下游任务要求可以帮助他更好的实现下一词预测*； > > 被Train on Code后,具备了代码生成能力，*而且可能从中学会了Reasoning，即逻辑推理。* > > 被Instruct-Tuning后，*学会了如何遵循人的指令，而且这件事具有很强的泛化能力*。 > > 被RLHF后，付出了一些性能作为代价（alignment tax），*进一步学会了遵循人的指令，输出Useful、relevant而且不toxic的内容，实现了与人类的价值观对齐* > > *#指令精调和RLHF本身并没有为模型注入新的能力，但它让模型通过千亿参数压缩了海量预料后具有的巨大潜能得以发挥，输出了我们想要的内容。* > > *#我们想看到的输出（desired output）它是可以解决我们提出的下游任务的，是有用的、正确的、有逻辑推理的。ChatGPT表现如此惊艳，个人推测一个极其重要的原因就是“对齐”的思想。模型展现出了极其强大的理解和推理能力，但这可能只是为了实现更好的、和我们对齐的【下一词预测】而已。* *** ### 13.6.4 模型的效果与评价 * **InstructGPT生成的答案明显比GPT-3更好（更能和人类的价值对齐）。哪怕在InstructGPT只有13亿参数，而GPT-3有1750亿参数的情况下，这一结论依然成立。** > On our test set, outputs from the 1.3B parameter InstructGPT model are preferred to outputs from the 175B GPT-3, despite having over 100x fewer parameters. These models have the same architecture, and differ only by the fact that InstructGPT is fine-tuned on our human data. This result holds true even when we add a few-shot prompt to GPT-3 to make it better at following instructions. > > &#x20;Outputs from our 175B InstructGPT are preferred to 175B GPT-3 outputs 85 ± 3% of the time, and preferred 71 ± 4% of the time to few-shot 175B GPT-3. InstructGPT models also generate more appropriate outputs according to our labelers, and more reliably follow explicit constraints in the instruction. * **&#x20;InstructGPT模型在真实性方面比GPT-3有所提高：** > On the TruthfulQA benchmark, InstructGPT generates truthful and informative answers about twice as often as GPT-3. Our results are equally strong on the subset of questions that were not adversarially selected against GPT-3. On “closed-domain” tasks from our API prompt distribution, where the output should not contain information that is not present in the input (e.g. summarization and closed-domain QA), InstructGPT models make up information not present in the input about half as often as GPT-3 (a 21% vs. 41% hallucination rate, respectively). * **&#x20;InstructGPT shows small improvements in toxicity over GPT-3, but not bias：减少了有害的信息，但在偏见上没有什么提升。**&#x65;g还是会默认司机都是男的；护士都是女的。 > &#x20;To measure toxicity, we use the RealToxicityPrompts dataset (Gehman et al., 2020) and conduct both automatic and human evaluations. InstructGPT models generate about 25% fewer toxic outputs than GPT-3 when prompted to be respectful. InstructGPT does not significantly improve over GPT-3 on the Winogender (Rudinger et al., 2018) and CrowSPairs (Nangia et al., 2020) datasets. * **在公有数据集上，InstructGPT的性能也没有下降太多。**&#x901A;过调整RLHF的微调的程序，可以实现对模型性能的伤害对最小化（We can minimize performance regressions on public NLP datasets by modifying our RLHF fine-tuning procedure）。具体的做法为，在基于RLHF做Fine-tune的时候，不仅通过PPO算法做参数更新，也引入最原始的交叉熵函数做参数更新。在思想上有点类似*12.1.2.2*里提到的把两个目标函数合起来一起训练。 * 这边介绍一个概念，叫**Alignment Tax，“对齐税”**。很多时候，解决模型的misalignment的问题会需要通过牺牲性能换取与人类的对齐（alignment），牺牲的这一部分性能就叫对齐税。 * OpenAI是想说，因为他们采用了上述的做法（绿底部分）我们在做完RLHF，让模型输出的东西更符合人的意愿之后，付出的对齐税其实还是比较少的。 > &#x20;During RLHF fine-tuning, we observe performance regressions compared to GPT-3 on certain public NLP datasets, notably SQuAD (Rajpurkar et al., 2018), DROP (Dua et al., 2019), HellaSwag (Zellers et al., 2019), and WMT 2015 French to English translation (Bojar et al., 2015). **This is an example of an “alignment tax” since our alignment procedure comes at the cost of lower performance on certain tasks that we may care about**. We can greatly reduce the performance regressions on these datasets by mixing PPO updates with updates that increase the log likelihood of the pretraining distribution (PPO-ptx), without compromising labeler preference scores. * **InstructGPT泛化到了没有产生任何训练数据的“搁置”标签者的偏好，即一类问题，哪怕没有被人工标注排序过答案，模型也可以生成更和人类对齐的回答（Our models generalize to the preferences of “held-out” labelers that did not produce any training data.）** > &#x20;To test the generalization of our models, we conduct a preliminary experiment with held-out labelers, and find that they prefer InstructGPT outputs to outputs from GPT-3 at about the same rate as our training labelers. However, more work is needed to study how these models perform on broader groups of users, and how they perform on inputs where humans disagree about the desired behavior. 泛化能力是个好东西，这说明我们的工作量可以被大幅减少。这个结论是完全符合常识的，但也是非常重要的。 * **InstructGPT models show promising generalization to instructions outside of the RLHF finetuning distribution.:泛化能力非常强，甚至可以从生成自然语言泛华到生成代码，从英语泛化到各种语言，哪怕代码生成、其他语言这些东西其实没有被RLHF微调过。**（相比之下，想要让GPT-3实现这些任务就更难，需要小心翼翼的去写prompt，而且哪怕这样有时候也会文不对题） > **We qualitatively probe InstructGPT’s capabilities, and find that it is able to follow instructions for summarizing code, answer questions about code, and sometimes follows instructions in different languages, despite these instructions being very rare in the fine-tuning distribution.&#x20;** > In contrast, GPT-3 can perform these tasks but requires more careful prompting, and does not usually follow instructions in these domains.**&#x20;This result is exciting because it suggests that our models are able to generalize the notion of “following instructions.”** They retain some alignment even on tasks for which they get very little direct supervision signal.&#x20; > 这一结论也非常重要、非常激动人心（exciting），因为OpenAI认为，这反映了**通过RLHF，InstructGPT不仅实现了更好的Alignment，它学到的东西可能还帮助他泛化到了“遵从指示”（ our models are able to generalize the notion of “following instructions”）**。现在再回想起文章的标题，[Training language models to follow instructions with human feedback](https://arxiv.org/pdf/2203.02155.pdf)，便能理解这个标题的真正含义了。 * **InstructGPT still makes simple mistakes：依然会犯一些无脑的错误，没有完全对齐**。不过这也正常啦，现在这样的效果已经很好了。 > For example, InstructGPT can still fail to follow instructions, make up facts, give long hedging answers to simple questions, or fail to detect instructions with false premises. *** ### 13.6.5 关于InstructGPT这篇论文的总结 从结果上看，在经过RLHF之后，一个13亿参数的InstructGPT的效果已经比175B的GPT-3还要来的好了，它更会遵循人的指令，有毒答案也更少，非要说缺点的话应该只有偏见问题还没解决。 13亿参数大小的大量人工介入的模型的效果好于参数1750亿的GPT-3，这个结果很好，但其实也不算意外： * **所谓有多少人工，就有多少智能。**&#x82B1;大钱雇人去写答案、打标签，成本无疑是很大的，这样产生的输入有两个好处：第一，信噪比更高。因为有些Prompt和Output是人工写的，噪音自然比爬虫爬到的东西少很多。第二是，标注信息，例如SFT中人工写的demonstration，肯定和模型的最终评估用的标准更接近，所以评估起来结果更好也是自然的。 * **这背后蕴涵着这样一种思考：没必要对人工标注数据抱有恶意，认为它是落后的东西。**&#x7528;无标注数据自监督训练出一个特别大的模型，一条路走到黑的话，计算量和数据需求都可能会吃不消。在一些我们很想要，但只靠堆叠海量数据让Transformer去压缩做不到的性能追求（例如无毒、相关、有用）上，可能多来点人工标注数据，性价比会高得多。 [参考：InstructGPT 论文精读【论文精读·48】](https://www.bilibili.com/video/BV1hd4y187CR/?buvid=ZE4EBEE92994324F407089826EE9BEE9DE8E\&is_story_h5=false\&mid=jOTTvC9MAcEUtHyHp%2B%2B2ww%3D%3D\&p=1\&plat_id=114\&share_from=ugc\&share_medium=iphone\&share_plat=ios\&share_session_id=AD8BBE31-8084-443E-99C6-F6936D247C54\&share_source=WEIXIN\&share_tag=s_i\&timestamp=1682653931\&unique_k=EPUNfG5\&up_id=1567748478) [参考：How does GPT Obtain its Ability? Tracing Emergent Abilities of Language Models to their Sources](https://yaofu.notion.site/How-does-GPT-Obtain-its-Ability-Tracing-Emergent-Abilities-of-Language-Models-to-their-Sources-b9a57ac0fcf74f30a1ab9e3e36fa1dc1#929906a4292b4cceadabd92c47f3843f) By [Yao Fu](https://franxyao.github.io/), [email protected] ### 13.6.6 所以指令微调都做了些什么 > * 指令微调**不会为模型注入新的能力** —— 所有的能力都已经存在了。指令微调的作用是**解锁 / 激发这些能力**。这主要是因为指令微调的数据量比预训练数据量少几个数量级（基础的能力是通过预训练注入的）。 > > * 指令微调**将 GPT-3.5 的分化到不同的技能树。**&#x6709;些更擅长上下文学习\*\*，如`text-davinci-003`，有些更擅长对话，如`ChatGPT`。 > > * 指令微调**通过牺牲性能换取与人类的对齐（alignment）**。OpenAI 的作者在他们的指令微调论文中称其为 “对齐税” (alignment tax)。许多论文都报道了`code-davinci-002`在基准测试中实现了最佳性能（但模型不一定符合人类期望）。在`code-davinci-002`上进行指令微调后，模型可以生成更加符合人类期待的反馈（或者说模型与人类对齐），例如：零样本问答、生成安全和公正的对话回复、拒绝超出模型它知识范围的问题。 > > ——[ChatGPT的前世今生](https://blog.csdn.net/CV_Autobot/article/details/128424961?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522168302340416800182779676%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D\&request_id=168302340416800182779676\&biz_id=0\&utm_medium=distribute.pc_search_result.none-task-blog-2~all~sobaiduend~default-1-128424961-null-null.142^v86^control_2,239^v2^insert_chatgpt\&utm_term=alignment%20tax\&spm=1018.2226.3001.4187) By 自动驾驶之心 *** ## 13.7 思维链 Chain of Thoughts, CoT（2022.1） ### 13.7.1 [开山之作：Chain-of-Thought Prompting Elicits Reasoning in Large Language Models](https://arxiv.org/pdf/2201.11903.pdf)  > Scaling up model size alone has not proved sufficient for achieving high performance on challenging tasks such as arithmetic, commonsense, and symbolic reasoning. ——[Self-consistency Improves Chain Of Thought Reasoning in Language Models](https://arxiv.org/abs/2203.11171) 思维链提示是一种针对大语言模型的Prompting方法。大语言模型彻底重塑了NLP领域的研究，但是单纯的把规模搞大无法解决所有问题：大语言模型依然很难在算术、常识和符号推理等具有挑战性的任务中体现出好的性能。 > 当我们做出了足够大的语言模型，把足够大的Corpus通过足够多层Transformer压缩到模型中后，**模型本身具有的“能量”可能是已经足够巨大的，足以去实现Zero-shot、few shot的预测（上下文学习）。我们要做的，就是找到更多的方法，把这些能量给激发出来**。 > > 正如前文中提到的，Instruct tuning和RLHF本身并没有给模型注入新的能力，所有的能力都是本来就有的；但他们很好的把模型蕴含的巨大潜能引导到了“遵循人类的指令并与人类对齐”上，于是就产生了极佳的效果。**思维链也是这个思维下的产物之一：不是模型推理能力不好，而是我们的prompt不能很好的引导他们。以往我们在ICL中只给模型input和output的demonstration让它学习，那对于需要推理的任务，我们能不能把reasoning path也给放到demonstration里，让模型去学呢？这其实就是CoT的思想。** 思维链是一种特殊的In-Context Learning，而且采用的不是连续提示，而是离散提示（在当时来看是文艺复兴，因为连续提示学习一时风头无两）。它和1S、FS的提示词很像，但我们除了给出Input-Output作为示范之外，还需要在输入和输出之前絮絮叨叨一阵子，给出一个推理过程，称为**Relationale或Reasoning Path**。因此，在使用CoT技术后，我们对模型的Prompt就是一个具有逻辑推理过程的短文本了，如章节开头的图中的蓝色部分。 *#2022年4月，Google发布了语言模型PaLM，它使用了Chain of Thoughts的技术后，以540B的参数规模（GPT-3的三倍左右），取得了数学问题的SOTA。*  > 这篇论文相对而言比较简单，就是讲述了一个絮絮叨叨给模型讲明白逻辑的Prompt方法，没有涉及到对模型结构的调整（还没有改代码）。但接下来我们就要将CoT与更多模型细节做结合了。 ### 13.7.2 经典CoT方法之改变解码策略：[Self-consistency Improves Chain Of Thought Reasoning in Language Models](https://arxiv.org/abs/2203.11171) > In this paper, we introduce a novel decoding strategy called self-consistency to replace the greedy decoding strategy used in chain-of-thought prompting (Wei et al., 2022), that further improves language models’ reasoning performance by a significant margin. Self-consistency leverages the intuition that complex reasoning tasks typically admit multiple reasoning paths that reach a correct answer (Stanovich & West, 2000). The more that deliberate thinking and analysis is required for a problem (Evans, 2010), the greater the diversity of reasoning paths that can recover the answer. > > 自我一致性利用了这样一种直觉，即一个复杂的推理问题通常会有多种不同的思维方式来通往其唯一的正确答案，而且一个问题越复杂，潜在的逻辑链就会越多。  我们知道，Decoder本身是一个自回归的语言模型，语言模型在输出的时候有许多策略： * **Greedy Decoding Strategy，贪婪策略**。即总是输出概率最高的那一个词语。 * **Beam-Search Strategy**。参考*7.2.3.2*。 * **Top-k Sampling**。即在概率最高的k个词语中，基于概率做随机采样。 Self-consistency就是一个基于思维链的思想，去改变解码策略的方法，其运作模式如上图所示。**基于我们的思维链提示的输入，模型可以用自己本来就具有的能力生成一组推理逻辑不同的Output，每个Output对应一个答案。这就像是给答案做投票一样，我们留下票数最多的答案，作为模型的最终输出。** ### 13.7.3 名扬四海的Let's Think Step by Step: [Large Language Models are Zero-Shot Reasoners](https://arxiv.org/abs/2205.11916) 一般来说，既然要用思维链，那必然是One-shot或者Few-shot，因为你要给模型一个推理案例（参考下图右上角）。但是这篇论文指出，CoT也可以是Zero-shot：在0S CoT下，我们不需要给模型例子，只需要告诉模型你给我一步一步的思考就行。  > While these successes are often attributed to LLMs’ ability for few-shot learning, we show that LLMs are decent zero-shot reasoners by simply adding “Let’s think step by step” before each answer. 只要在每个答案前加上 "Let's Think Step by Step"，LLMs就是一个体面的Zero-Shot推理者。参考上图的右下角，它是一个Zero-shot的算数应用，模型本来会输出错误的结果，但是在A：之后加上了这么一句话，模型就可以输出自己的推理过程并且输出正确的结果了。 ## 13.8 大语言模型的涌现 Emergent Abilities：我们仍未知道那天看到的大模型会推理的原因 [*关于涌现能力的介绍：【arxiv】Emergent Abilities of Large Language Models*](https://arxiv.org/pdf/2206.07682.pdf) ### 13.8.1 **什么是大语言模型的涌现**？——如果一种能力在较小的模型中不存在，但在较大的模型中存在，我们认为这种能力是涌现的。 > **Emergent abilities of LLMs&#x20;**&#x61;re formally defined as “the abilities that are not present in small models but arise in large models”, which is one of the most prominent features that distinguish LLMs from previous PLMs. It further introduces a notable characteristic when emergent abilities occur \[31]: performance rises significantly above random when the scale reaches a certain level. > > ——[【arxiv】A Survey of Large Language Models](https://arxiv.org/pdf/2303.18223.pdf) > >  > > 参考上图（来自[*【arxiv】Emergent Abilities of Large Language Models*](https://arxiv.org/pdf/2206.07682.pdf)）。涌现能力无法使用Scaling Law来从较小模型上进行预测。图中，我们让x轴是模型的参数量，y轴是某种能力的效果，那么涌现能力在图中会有一个清晰的Pattern：在某个阈值之前的效果接近随机（把模型做大，性能也只能在一个水准上随机波动，不会偏差太多），但是超过该阈值后效果将大大高于随机。 ### 13.8.2 涌现是敏锐且不可预测的 ***涌现能力具有不可预测性：*** * 我们无法预测涌现能力在模型规模达到多大时会涌现出来。 * **大多数学者在训练模型的时候，往往都没有采取最优的训练方案***（Today’s language models are likely not trained optimally (Hoffmann et al., 2022), and our understanding of how to best train models will evolve over time）***。**&#x6211;们知道，Train一个Model的工程细节太多，数据来源及质量把关（例如GPT-3对CommonCrawl数据集的处理）、超参数怎么选（批大小，学习率，迭代次数，怎么做梯度下降等）、算力如何规划等等都会影响一个模型的训练结果，我们也不知道怎么去Train并且Train到多大的时候会出现涌现。 ***涌现能力是敏锐的，一旦达到阈值，就会被激发出来：*** > 事实上，这些涌现能力非常令人惊讶，以至于「突然的、特定的能力扩展」已经被认为是 LLM 的两个最高定义特征之一。此外，「breakthrough capabilities」和「sharp left turns」等术语也被使用。 > > ——By [机器之心](https://mp.weixin.qq.com/s/tt9xYESUgw3V2c4XJu5ZVw) ***结合思维链、指令微调等技术，涌现能力会格外惊人*** 参考下图，在模型扩大到一定规模后，采用思维链和指令微调的方式，我们见到了更早出现的、更强大的涌现。  总之，把模型做的足够大、提供了足够多的数据后，模型出现了许多我们意想不到的特征，包括上下文学习，也包括模型涌现出的推理能力。**我们仍未知道那天看到的大模型会推理的原因**，很多人对大模型涌现出的推理能力的思考已经上升到了“什么是意识”“语言是对宇宙间一切事物的统一抽象解释”“通过压缩语言能否产生意识”的哲学层面…… ### 13.8.3 对涌现的批评 [【arxiv】Are Emergent Abilities of Large Language Models a Mirage?](https://arxiv.org/pdf/2304.15004.pdf) *尽管很多人通过将语言模型解释为一个复杂系统，认为LLM里的Transformer把足够多的信息在复杂系统里进行了极大程度的压缩，从而（在物理意义上）引发了相变（More is different）的角度去解释涌现，**但也有文章批评认为涌现是一个伪概念，涌现的出现取决于我们对模型的评价指标。*** * 我们知道，我们经常用GLUE基准数据集、HumanEval等数据集和一些评估指标去评价一个模型的能力。对模型能力的评估不会是绝对客观中立的，它取决于我们的度量指标。 * **斯坦福的研究者们质疑说，根本就不存在这么多奇迹，涌现的出现是度量选择的结果：**&#x7AE0;节最开始的图中忽然变得非常陡峭的曲线的出现是因为对模型的度量指标是非线性、不稳健的。更换一些更连续、平滑的指标后，涌现现象就不那么明显了，更接近线性，例如下图。  > 他们的怀疑基于以下观察：似乎只有在非线性或不连续地扩展任何模型的 per-token 错误率的度量下，模型才会出现涌现能力。例如，在 BIG-Bench 任务中，>92% 的涌现能力是这两个度量下出现的： > >  > > 这就为 LLMs 的涌现能力的起源提出了另一种解释的可能性：尽管模型族的 per-token 错误率会随着模型规模的增加进行平滑、持续且可预测地变化，但**看似尖锐和不可预测的变化可能是由研究者选择的测量方法引起的**。 > 也就是说，涌现能力可能是一种海市蜃楼，主要是由于研究者选择了一种非线性或不连续地改变 per-token 错误率的度量，部分原因是由于拥有太少的测试数据，不足以准确估计较小模型的性能（从而导致较小的模型看起来完全不能执行任务），另一部分原因是由于评估了太少的大规模模型。 > > 参考：[斯坦福最新研究警告：别太迷信大模型涌现能力，那是度量选择的结果](https://mp.weixin.qq.com/s/tt9xYESUgw3V2c4XJu5ZVw)，机器之心 > 也不要因为这篇文章就直接否定了涌现的存在，其实这篇文章也不完全严谨： > > 首先，许多任务指标的设计本来就无法是“线性”的，对于这类任务，不应该太强人所难。 > > 其次，NLP很多任务在使用不连续的度量时，其实也是在多个样本上的平均，整体数值其实是连续的。作者也给出了两个解释，试图说明此类度量下的涌现也是海市蜃楼，但也未能严谨证明。 > > ***最后的最后，不管怎样，作者也没有反对模型的性能会随着参数量的提高而上升，也没有反对LLM具有的推理能力。其实这就足够啦***。 *** # 14. 为什么它诞生之初远比GPT出风头？图解芝麻街家族新员BERT！（2018.10）  *BERT要出来装逼了，Hold My Beer!（可是前面先把GPT讲完了诶。。。就是说装的不是很逼）* [【arxiv】BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding](https://arxiv.org/abs/1810.04805) ## 14.1 站在巨人的肩膀上：NLP封神榜  *<图片是[Ann's Blog](https://lolitasian.blog.csdn.net/?type=blog)画的，怪好看的，就拿来用惹！>* BERT 是建立在NLP领域中涌现的许多聪明想法之上的，包括但不限于[半监督学习（Semi-supervised Sequence Learning)](https://arxiv.org/abs/1511.01432)、[ELMo(Deep contextualized word representations)](https://arxiv.org/abs/1802.05365)、[ULMFiT(Universal Language Model Fine-tuning for Text Classification)](https://arxiv.org/abs/1801.06146)、[GPT(Improving Language Understanding by Generative Pre-Training)](https://s3-us-west-2.amazonaws.com/openai-assets/research-covers/language-unsupervised/language_understanding_paper.pdf) 和[Transformer(Attention Is All You Need)](https://arxiv.org/abs/1706.03762v5)。 这群人的工作改变了我们所在的世界，我愿称这张图上的角色们为NLP封神榜！ 上面的所有论文或者相关的知识、模型，我应该都在前面讲过了，如果忘记了就回去复习！ ## 14.2 BERT的模型架构 ***Bert Base：12层编码器，768维词嵌入，12个注意力头（对标GPT）***  这张图讲的非常简单，对比了BERT、OpenAI和ELMo，其中ELMo是相对比较落后的，因为它没有用Transformer，而是只是用了双向的LSTM模型，把一个从左到右的RNN和一个从右到左的RNN拼接起来。GPT和BERT都是用了Transformer，但GPT用的是解码器，所以在当前时间步，“注意”不到后面时间步的信息。参考第二张图·，它是没有向左的箭头的。而BERT则是用了编码器，所以可以看到全部时间步的信息。这样一来，模型的训练会变得容易很多，让他去做判别式的任务（多分类），就容易以更小的数据集、更小的参数数量体现出更强的效果。 ## 14.3 BERT的使用范式：下载预训练模型+自行微调 参考下图，左边的自监督学习部分Google自己已经做完了，而且谷歌将其完全开源（BERT模型的开源包括了模型的源代码和预训练得到的权重参数） 后面我们会很详细的讲解如何Google具体是如何去基于大语料去做自监督学习的。  ## 14.4 BERT的词嵌入：是3个嵌入之和 **BERT的词嵌入由词元嵌入（Token Embedding）、片段嵌入（Segmentation Embedding）和位置嵌入（Position Embedding）合成得到**。其中词元嵌入还有位置嵌入我们都很熟，片段嵌入是更新的东西，但思想上与第九章中提到的ELMo类似。 上述三个嵌入分量都可以表达为one-hot编码表示输入与嵌入矩阵的乘积形式。One-hot向量和矩阵相乘的时候，它就像是一个查询，找到嵌入对应的那一列，那一列便是最终的结果。如果忘记了，可以回看6.4.2里中苏神的讲解。 ## 14.5 BERT的预训练任务：Masked Language Modeling（MLM） 引用自：[Prompt-Tuning——深度解读一种新的微调范式](https://wjn1996.blog.csdn.net/article/details/120607050) By [华师数据学院·王嘉宁](https://wjn1996.blog.csdn.net/) > MLM是一种自监督的训练方法，其先从大规模的无监督语料上通过固定的替换策略获得自监督语料，设计预训练的目标来训练模型，具体的可以描述为： > > * 替换策略：在所有语料中，随机抽取15%的文本。被选中的文本中，则有80%的文本中，随机挑选一个token并替换为 `[mask]`，10%的文本中则随机挑选一个token替换为其他token，10%的文本中保持不变。 > > * 训练目标：当模型遇见 `[mask]` token时，则根据学习得到的上下文语义去预测该位置可能的词，因此，训练的目标是对整个词表上的分类任务，可以使用交叉信息熵作为目标函数。 > >  > > 因此以BERT为例，首先喂入一个文本`It is very cold today, we need to wear more clothes.` ，然后随机mask掉一个token，并结合一些特殊标记得到：`[cls] It is very cold today, we need to [mask] more clothes. [sep]` ，喂入到多层的Transformer结构中，则可以得到最后一层每个token的隐状态向量。MLM则通过在`[mask]`头部添加一个MLP映射到词表上，得到所有词预测的概率分布。 总之，BERT的训练目标无非是一个完形填空，即挖掉一个词，让你根据上下文猜被挖掉的词应该是什么。显然，这个任务难度太小了。如果只有这么一个完形填空的话，那么虽然预训练起来容易收敛，但模型却根本学不到什么东西。因此，Google团队给这个任务再上了点难度，有时候被选中的Token不会换成\[mask]而是会随机换成另一个词，有时则会保持不变。 BERT其实还有另一个预训练任务，即下一句 at预测（Next Sentence Prediction，NSP）。虽然起了这么名字，但它和我们在[12.1.3中提到的Entailment](https://s3tlxskbq3.feishu.cn/docx/NyPqdCKraoXz9gxNVCfcIFdnnAc#CAuOdswgeoQ6i0xe60DcMGuCntd)是一样的。其主要目标是给定两个句子，来判断他们之间的关系，分别有： * entailment（isNext）：存在蕴含关系，NSP中则认为紧相邻的两个句子属于entailment，即isNext关系； * contradiction（isNotNext）：矛盾关系，NSP中则认为这两个句子不存在前后关系，例如两个句子来自于不同的文章； * Neutral：中性关系，NSP中认为当前的两个句子可能来自于同一篇文章，但是不属于isNext关系的 而显然，构建NSP语料也可以通过自监督的方法获得，首先给定一个大规模无监督语料，按照文章进行分类。在同一篇文章里，随机挑选一个句子作为premise，因此entailment类对应的则是其下一个句子，另外再随机挑选同一篇文章中的其他句子作为Neutral类，其他文章中的句子作为contradiction类。 在BERT中，NSP任务则视为sentence-pair任务，例如输入两个句子`S1：It is very cold today.` 和 `S2：We need to wear more clothes.`，通过拼接特殊字符后，得到：`[cls] It is very cold today. [sep] We need to wear more clothes. [sep]`，然后喂入到多层Transformer中，可以得到`[cls]`token的隐状态向量，同样通过MLP映射到一个3分类上获得各个类的概率分布：  **然而，NSP这个任务有点过于简单了，后续的研究中学者们发现NSP对实验的效果并没有太多正向影响，因此均删除了NSP的任务，在后续的预训练语言模型中，也纷纷提出其他的预训练目标。** ## 14.6 BERT的各种下游应用 > 也不想更新了，在Prompting时代看小模型的Fine-tune，意义不大捏 # 15. 回看波澜壮阔的语言模型乃至NLP的发展史！ 语言模型的发展历史分为三个阶段：全监督学习阶段、预训练+Fine-tuning阶段和预训练+Prompt+Predict阶段。 <table> <thead> <tr> <th><strong>范式</strong><strong>Paradigm</strong></th> <th><strong>阶段</strong><strong>Stage</strong></th> <th><strong>工程及探索</strong><strong>Engineering &#x26; Exploration</strong></th> <th><strong>代表模型</strong><strong>Models</strong></th> <th><strong>索引</strong><strong>Links</strong></th> </tr> </thead> <tbody> <tr> <td>全监督学习Fully-supervised Learning2017之前(1)</td> <td>前神经网络时代（eg. SVM；决策树；专家系统）</td> <td><strong>特征工程 Feature Engineering</strong>工程师们利用自己的知识手动从Raw Data中去提取简明的特征。</td> <td>n-gram语言模型</td> <td><a href="https://s3tlxskbq3.feishu.cn/docx/NyPqdCKraoXz9gxNVCfcIFdnnAc#CissdIqOUo6kuAx0a19cvwyMnDh">特征工程</a><a href="https://s3tlxskbq3.feishu.cn/docx/NyPqdCKraoXz9gxNVCfcIFdnnAc#ROEydsEmSo6u8Ox2tubcKif2nXe">n-gram模型</a></td> </tr> <tr> <td></td> <td>神经网络时代FFNN-CNN-RNN</td> <td><strong>结构工程 Architecture Engineering</strong>提取特征的工作交给了神经网络的隐层，实现了端到端学习，工程关键在于怎么设计一个好的网络结构，以更好的提取特征。这个时代的产物包括RNN及其变种，层归一化，Resnet，Attention机制等等（2）。此外，这一时代出现了利用语言模型与序列自编码器进行“半监督学习”的伟大探索。到了预训练时代，半监督学习的称谓终于逐渐演变成了自监督学习（3）。</td> <td>神经语言模型LSTMseq2seqLM-LSTM与SA-LSTM</td> <td><a href="https://s3tlxskbq3.feishu.cn/docx/NyPqdCKraoXz9gxNVCfcIFdnnAc#HeI2duSKKoMaYwx8rH1c5X2qnUc">LSTM</a><a href="https://s3tlxskbq3.feishu.cn/docx/NyPqdCKraoXz9gxNVCfcIFdnnAc#JmACdYYSAogGuwxyewBc0VqHn9g">神经语言模型</a><a href="https://s3tlxskbq3.feishu.cn/docx/NyPqdCKraoXz9gxNVCfcIFdnnAc#ZWSwdmWQaoGAQuxkOEHcuD5UnVl">Seq2Seq</a><a href="https://s3tlxskbq3.feishu.cn/docx/NyPqdCKraoXz9gxNVCfcIFdnnAc#KEcEdYK8ao48eExeypscRMkknog">探索：自监督学习</a></td> </tr> <tr> <td><strong>#备注：</strong>（1）哪怕在这个全监督学习时代，也是有利用无标注数据预训练的模型的，如Word2Vec、GloVe等。但他们只解决了嵌入层的问题，针对每一个具体的下游应用，彼时的工程师们依然要单独地搭一个新的模型去做全监督学习。这样的预训练我们称为Feature-based pretraining，because they are pre-trained to provide features of words for downstream tasks.（2）其中一些技术细节如层归一化、残差网络等这篇文档都没有涉及到，不过他们其实也是很重要的工作，在模型的结构中加入他们对提高模型的特征提取能力、缓解梯度问题等都至关重要。（3）最早的时候，学者们都管这种新范式叫Semi-supervised learning，这是因为当时学者们利用“<a href="https://s3tlxskbq3.feishu.cn/docx/NyPqdCKraoXz9gxNVCfcIFdnnAc#Wie8dwyUSoUAKcxucycc6Dtlnig">有标签数据和无标签数据联合训练、用有标签数据辅助无标签数据训练</a>”，因此部分有监督、部分无监督，故称作半监督学习。</td> <td></td> <td></td> <td></td> <td></td> </tr> <tr> <td>Transformer诞生2017.6<em>#解决RNN并行难题，预训练大模型出现曙光</em></td> <td>大事件Big Event</td> <td><strong>放弃RNN结构，采用位置偏码（Positional Encoding，PE）与自注意力机制，并且设计了多头注意力机制。</strong>Transformer在并行性上低于CNN而远高于RNN，在信息糅合能力上低于RNN而远高于CNN，不仅让大力出奇迹终于成为可能，在长距离依赖上也没有做出太多妥协，于是终于开始在NLP乃至CV领域横扫千军。</td> <td>Transformer</td> <td><a href="https://s3tlxskbq3.feishu.cn/docx/NyPqdCKraoXz9gxNVCfcIFdnnAc#YYoqdo6kUo2qI6xDA7OcjMEDnch">Attention is All You Need</a></td> </tr> <tr> <td>语境化词嵌入（过渡阶段）2018.2</td> <td>过渡阶段Transition stage</td> <td><strong>结构工程 Architecture Engineering</strong>也是基于特征的预训练范式。发现了一个单词有那么多词义却只有一个词嵌入这件事非常笨蛋，采用了双向LSTM，一正一反两个方向提取隐向量并拼在一起形成词嵌入。实现了水果Apple和手机Apple有不同的词嵌入。</td> <td>ELMo</td> <td><a href="https://s3tlxskbq3.feishu.cn/docx/NyPqdCKraoXz9gxNVCfcIFdnnAc#W2M0dOIgoo0mg0xa4rbcFfttnxb">ELMo</a></td> </tr> <tr> <td>预训练+Fine-tune2017～2019<em>#因为无标注文本数据比较充足和Transformer的出现，大力出奇迹成为可能</em></td> <td>Decoder-Only</td> <td><strong>目标工程 Objective Engineering</strong>数据相对来说不是问题了，我们基于大量的无监督语料去利用预训练任务预训练，而后针对具体下游任务的目标函数做fine-tune。选对一个好的目标函数可以让预训练效果大增（1）。<strong>GPT是一个只有解码器的Transformer，采用带有只能注意到已有信息的自回归架构，利用传统的下一词预测的语言模型作为预训练任务。</strong>这符合人们写东西的时候都是从左开始往右写的习惯。因为要只根据已有词汇预测下一词，其任务难度大、训练效果更差，但天花板自然更高。<strong>BERT是一个魔改的只有编码器的Transformer，编码器可以注意到全部时间步的信息，预训练任务为MLM，即完形填空。</strong>BERT的预训练任务是基于上下文，猜测被挖掉的词是什么。相较于“预测未来”的下一词预测，“根据未来和过去推测现在”这样的任务显然容易很多，因此训练效果非常好，横扫了当时的SOTA。<em>UniLM和T5先不介绍，可参考索引和批注（2）</em></td> <td>GPT</td> <td><a href="https://s3tlxskbq3.feishu.cn/docx/NyPqdCKraoXz9gxNVCfcIFdnnAc#CSiCdEm8koQi4mxAPQTckXC2n2e">GPT的诞生</a></td> </tr> <tr> <td></td> <td>Encoder-Only</td> <td></td> <td>BERT</td> <td><a href="https://s3tlxskbq3.feishu.cn/docx/NyPqdCKraoXz9gxNVCfcIFdnnAc#XwSYdQ6AMocmU0xcFtdcgORrnje">BERT</a></td> </tr> <tr> <td></td> <td>Prefix LM</td> <td></td> <td>UniLM</td> <td><a href="https://arxiv.org/pdf/1905.03197.pdf">论文地址</a><a href="https://zhuanlan.zhihu.com/p/584193190">参考文章-UniLM</a></td> </tr> <tr> <td></td> <td>Encoder-Decoder</td> <td></td> <td>T5</td> <td><a href="https://zhuanlan.zhihu.com/p/88438851">参考文章-T5</a></td> </tr> <tr> <td>#<strong>在预训练+微调阶段，Architecture Engineering逐渐消失</strong>。一个原因是直接照着Transformer堆编码器和解码器就OK了，不需要那么多花里胡哨的（当然，任何事都不绝对，也会有Sparse Transformer这样的新东西被提出）；另一个原因是预训练Transformer实在是太太太贵了，没有人有那么多时间和算力不断的对模型架构做尝试。<blockquote> <p>#（1）For example, Zhang et al. (2020a) show that introducing a loss function of predicting salient sentences from a document will lead to a better pre-trained model for text summarization. </p> <p>#（2）除了Encoder-Only和Decoder-Only外，也有各种其他结构，如Prefix和编码解码器。参考下图：</p> </blockquote><img src="images/%E6%88%AA%E5%B1%8F2023-05-05%20%E4%B8%8B%E5%8D%882.50.51.png" alt=""></td> <td></td> <td></td> <td></td> <td></td> </tr> <tr> <td>Zero-shot2019.2<em>#模型越来越大，微调变得又贵又不可能。必须寻找更加参数高效的办法</em></td> <td>过渡阶段Transition stage</td> <td>GPT-2是一个比GPT大很多的解码器。GPT-2放弃了微调的范式，<strong>在预训练做下游任务时，不需要任何额外的标注信息，也不去改模型参数。</strong>GPT-2是对BERT Large横扫SOTA的一种回应，但这个回应比较无力，因为模型参数做的非常大性能却还是很一般，只好以Zero-shot这一非常新颖的东西为卖点。但GPT-2还是证明了一件事，即把模型做的非常大后，性能总归是在增长的。</td> <td>GPT-2</td> <td><a href="https://s3tlxskbq3.feishu.cn/docx/NyPqdCKraoXz9gxNVCfcIFdnnAc#K8aydygeMoAiyUxa0ozc7M6dnlf">GPT-2</a></td> </tr> <tr> <td>预训练+Prompt+Predict</td> <td>In-context Learning 上下文学习</td> <td><strong>提示工程 Prompt Engineering</strong>不去调整模型的权重，而是在输入窗口给预训练语言模型一点样本，但不多。用这有限的样本输入，语言模型就可以实现下游的任务</td> <td>GPT-3</td> <td><a href="https://s3tlxskbq3.feishu.cn/docx/NyPqdCKraoXz9gxNVCfcIFdnnAc#XEUidaOmKouwWax2XHBcgBnWnkg">GPT-3</a></td> </tr> <tr> <td></td> <td>Instruction-Tuning基于指令的微调</td> <td><strong>提示工程 Prompt Engineering</strong>被Instruct-Tuning后，<em>学会了如何遵循人的指令，而且这件事具有很强的泛化能力</em>。被RLHF后，付出了一些性能作为代价（alignment tax），<em>进一步学会了遵循人的指令，输出Useful、relevant而且不toxic的内容，实现了与人类的价值观对齐。指令精调和RLHF本身并没有为模型注入新的能力，但它让模型通过千亿参数压缩了海量预料后具有的巨大潜能得以发挥，输出了我们想要的内容。</em></td> <td>FLANInstructGPT</td> <td><a href="https://arxiv.org/pdf/2109.01652.pdf">FLAN论文地址</a><a href="https://s3tlxskbq3.feishu.cn/docx/NyPqdCKraoXz9gxNVCfcIFdnnAc#EAq2d0GUqoIgcqxKWZlcjqxDnRH">InstructGPT</a></td> </tr> <tr> <td></td> <td>Chain of Thoughts思维链</td> <td><strong>提示工程 Prompt Engineering</strong>思维链是一种特殊的In-Context Learning，它和1S、FS的提示词很像，但我们除了给出Input-Output作为示范之外，还需要在输入和输出之间给出一个推理出答案的过程，称为<strong>Relationale或Reasoning Path。</strong></td> <td>PaLM</td> <td><a href="https://arxiv.org/abs/2204.02311">PaLM论文地址</a></td> </tr> </tbody> </table> 语言模型的发展历程其实也是NLP的发展历程。因为NLP原先有如此多的彼此割裂子任务，我们原先搞一个对话机器人，如微软小冰，会有一些极其复杂的中间任务。  大道至简，这些中间任务的存在本身就是NLP发展水平不够高的一种体现。随着语言模型的发展和人们对AGI的追求，模型逐渐从只能处理某一下游任务变成了一个通才。NLP十项全能竞赛与多任务学习让我们看到了培养通才LM的曙光，ULM-FiT让类似CV领域的迁移学习在NLP也成为可能。而到了GPT之后我们就都知道了，整个模型是端到端的，就是一个12/48/96层解码器的大号Transformer，没这些中间任务，就能很好的实现和人的对答。  > **截止23年3月底，语言模型发展走过了三个阶段：** > > 第一阶段：设计一系列的自监督训练目标（MLM、NSP等），设计新颖的模型架构（Transformer），遵循Pre-training和Fine-tuning范式。典型代表是BERT、GPT、XLNet等； > > 第二阶段：逐步扩大模型参数和训练语料规模，探索不同类型的架构。典型代表是BART、T5、GPT-3等； > > 第三阶段：走向AIGC（Artificial Intelligent Generated Content）时代，模型参数规模步入千万亿，模型架构为自回归架构，大模型走向对话式、生成式、多模态时代，更加注重与人类交互进行对齐，实现可靠、安全、无毒的模型。典型代表是InstructionGPT、ChatGPT、Bard、GPT-4等。 > > [原文](https://blog.csdn.net/qq_36426650/article/details/120607050)