第一章 自然语言处理入门

什么是自然语言处理

【什么是人工智能，分别对应哪几个领域】

AI是模仿甚至超越人的某项机能，NLP、CV、ASR
NLP是机器理解并生成人类语言

自然语言处理的发展简史

1950 -- 图灵提出“机器能思考吗”，划时代性的话题
1956 -- 达特茅斯会议，提出人工智能（Artificial Intelligence），AI的元年，之前都是人类智能（Human Intelligence）
1957-1970 -- NLP开始出现两大阵营：规则 + 统计
1994-1999 -- 统计学开始占据主导地位
2000-2012 -- 机器学习开始盛行
2012-2022 -- 传统的深度学习占据主导地位
2023 -- 大模型时代

• 基于规则举例：设计语言学规则，解析句子结构，例如一个句子由主谓宾构成。
• 基于统计举例：统计机器翻译模型，收集大量平行语料库，例如中英互译，统计不同短语的分配概率，计算给定源语言翻译为目标语言的可能性。

自然语言处理的应用场景

语音助手：小爱同学
机器翻译：谷歌翻译
搜素引擎：百度翻译
智能对话：文心一言
推荐系统：短视频app推荐
。。。

第二章 文本预处理

认识文本预处理

• 文本预处理及作用

所处阶段：数据输入到模型之前
作用：数据清洗、指导超参数的确定

• 文本预处理的主要环节

1.文本处理的基本方法：分词、NER、POS
2.文本张量的表示方法：one-hot、word2vec、wordEmbedding
3.文本语料的数据分析：标签数量分析（类别不均衡问题）、句子长度分析、词频统计和关键词词云
4.文本特征处理：添加n-gram特征、文本长度规范
5.数据增强方法：回译数据增强

Anaconda沙箱/虚拟环境介绍
作用：同台电脑能够同时拥有多个不同的Python环境；因为实际工作中，偶尔会出现你参与的/维护项目使用的Python解释器版本的要求是不同的。

每个项目创建单独的虚拟环境
优点：各个项目间隔离开了，相互之间不影响；用到啥库就安装上，开发的时候效率比较高
缺点：需要根据开发需求一个个安装对应的第三方库

Anaconda沙箱/虚拟环境相关命令
    conda env list：查看当前有哪些虚拟环境
    conda create -n 虚拟环境名称 python==版本号：创建新的虚拟环境，注意虚拟环境的名称不要用中文
    conda activate 虚拟环境名称：进入指定的虚拟环境
    conda deactivate：退出当前的虚拟环境
    conda remove -n 虚拟环境名称 --all：彻底删除指定的虚拟环境


创建nlp_base虚拟环境的流程如下：
    1- 查看当前有没有nlp_base
        conda env list

    2- 如果没有，那么需要新建。按回车即可
        conda create -n nlp_base python==3.10

    3- 验证是否创建成功
        conda env list

    4- 进入nlp_base中查看有哪些工具包
        conda activate nlp_base
        conda list

    5- 安装jieba分词器
        pip install jieba -i https://mirrors.aliyun.com/pypi/simple/
        pip install torch -i https://mirrors.aliyun.com/pypi/simple/
        pip install tensorflow -i https://mirrors.aliyun.com/pypi/simple/
        pip install joblib -i https://mirrors.aliyun.com/pypi/simple/

        pip install fasttext -i https://mirrors.aliyun.com/pypi/simple/
        或者
        pip install fasttext-wheel -i https://mirrors.aliyun.com/pypi/simple/

        如果不管是安装fasttext还是fasttext-wheel都失败，那么原因是python版本过高。
        操作步骤如下：
        1- 先进入对应的虚拟环境
        2- 安装低版本的python解释器
            conda install python=3.10
        3- 安装fasttext
            pip install fasttext-wheel -i https://mirrors.aliyun.com/pypi/simple/



        pip install seaborn -i https://mirrors.aliyun.com/pypi/simple/
        pip install matplotlib==3.8.4 -i https://mirrors.aliyun.com/pypi/simple/

        如果运行matplotlib代码报错，依次执行如下两行命令：
        pip uninstall -y matplotlib
        pip install matplotlib==3.8.4 -i https://mirrors.aliyun.com/pypi/simple/

        pip install wordcloud -i https://mirrors.aliyun.com/pypi/simple/

文本处理的基本方法

分词器【掌握】

• 分词的意义

分词就是将连续的字序列，按照一定的规范，重新组合成词序列的过程
一般实现模型训练的时候，模型接受的文本基本最小单位是词语，因此我们需要对文本进行分词
词语是语意理解的基本单元
英文具有天然的空格分隔符，而中文分词的目的：寻找一个合适的分词边界，进行准确分词

• jieba分词工具

import jieba

# 1- 精确模式
def demo01():
    content = "传智教育是一家上市公司，旗下有黑马程序员品牌。我是在黑马这里学习人工智能"

    """
        sentence：要分词的内容
        cut_all：是否使用全词模式。默认是False
    """
    words = jieba.lcut(content,cut_all=False)
    print(type(words))
    print(words)

    print("-"*30)

    """
        lcut：返回结果类型是List列表，直接将所有的词全部返回
        cut：返回结果类型是生成器对象，不会直接将所有的词全部返回，需要真正用到的时候才一个个给你生成，非常节约内存
    """
    words2 = jieba.cut(content,cut_all=False)
    print(type(words2))
    print(words2)
    print("-" * 30)

# 2- 全（词）模式
def demo02():
    content = "传智教育是一家上市公司，旗下有黑马程序员品牌。我是在黑马这里学习人工智能"

    """
        sentence：要分词的内容
        cut_all：是否使用全词模式。如果是True，那么就是全词模式，也就是分的更加精细
    """
    words = jieba.lcut(content,cut_all=True)
    print(words)

# 3- 搜索引擎模式
def demo03():
    content = "传智教育是一家上市公司，旗下有黑马程序员品牌。我是在黑马这里学习人工智能"

    words = jieba.lcut_for_search(content)
    print(words)

if __name__ == '__main__':
    # 【掌握】1- 精确模式
    demo01()

    # 2- 全（词）模式
    demo02()

    # 3- 搜索引擎模式
    demo03()

• 支持用户自定义词典和繁体字分词

词典的意义

可以根据自定义词典，修改jieba分词方式，优先考虑词典里面的词来切分
格式：词语 词频（可省略） 词性（可省略）

自定义词典内容

# 格式：词 词频(可省略) 词性(可省略)
传智教育 10 n
黑马程序员 8
我是 1000000
旗下有

代码实现

import jieba

# 繁体字分词：正常分词即可
def demo1():
    content = "煩惱即是菩提，我暫且不提"
    print(jieba.lcut(content))

    content = "煩恼即是菩提，我暫且不提"
    print(jieba.lcut(content))

# 自定义字典
def demo2():
    content = "传智教育是一家上市公司，旗下有黑马程序员品牌。我是在黑马这里学习人工智能"

    # 默认不使用自定义指定的形式
    result = jieba.lcut(content)
    print(result)

    # 加载自定义字典
    # 字典中用来存放需要进行特殊关照的词。这些词会作为整体，不会被分词
    jieba.load_userdict("data/my_dict.txt")
    result = jieba.lcut(content)
    print(result)

if __name__ == '__main__':
    # 繁体字分词
    # demo1()

    # 用户自定义字典
    demo2()

命名实体识别

• 定义

命名实体：通常指人名、地名、机构名等专有名词
NER：从一段文本中识别出上述描述的命名实体
常见的7类命名实体：人名、地名、机构名、时间、日期、货币、百分比

• 作用

同词汇一样，命名实体也是人类理解文本的基础单元，也是AI解决NLP领域高阶任务的重要环节

词性标注（pos）

• 定义

对每个词语进行词性的标注：动词、名词、形容词等

• 实现方式

import jieba.posseg as pseg # POS词性标注

# POS词性
def demo1():
    content = "鲁迅爱北京天安门"
    result = pseg.lcut(content)

    for word,pos in result:
        print(word,"=",pos)

if __name__ == '__main__':
    # POS词性标注
    demo1()

文本张量的表示方法【熟悉】

文本张量的表示方法有几种

• onehot

• word2vec

• CBOW：连续词袋模式。使用两边的词预测中间的内容

• Skip-gram：跳词模式。使用中间的词预测两边的内容

• word embedding

One-Hot 词向量表示

• 介绍

针对每一个词汇，都会用一个向量表示，向量的长度是n（n就是词表大小）,n代表去重之后的词汇总量，而且向量中只有0和1两种数字
也称之为：独热编码、01编码

• 代码实现

import os
os.environ["TF_ENABLE_ONEDNN_OPTS"]="0"

import joblib
# from tensorflow.keras.preprocessing.text import Tokenizer   # 词汇映射器
from keras.src.legacy.preprocessing.text import Tokenizer   # 上面的替代方案

"""
    获得词向量的one-hot方式总结：
        优点：实现、理解简单
        缺点：
            1- 词向量是一个稀疏向量，会浪费存储和计算资源
            2- 对多义词的处理不好。例如：过过过过过过，中的3对过的词向量是同一个
"""

def demo01():
    # 1- 准备语料库
    vocabs = {"周杰伦", "陈奕迅", "王力宏", "李宗盛", "吴亦凡", "鹿晗"}

    # 2- 训练词汇映射器
    # 2.1- 创建映射器对象
    my_tokenizer = Tokenizer()
    # 2.2- 训练模型
    my_tokenizer.fit_on_texts(vocabs)
    # 2.3- 得到训练好的结果数据：词和索引的映射关系
    # 注意：1- word_index后面不要加小括号；2- 返回结果类型是普通的Python字典
    word_dict = my_tokenizer.word_index
    # print(type(word_dict))
    # print(word_dict)

    # 3- 得到每个词的one-hot词向量
    vocabs_len = len(vocabs)
    for word in vocabs:
        # 3.1- 初始化一个全0的词向量列表
        word_one_hot = [0]*vocabs_len   # 得到是[0,0,0,0,0,0]
        # 3.2- 获得词在词汇映射器中的索引。注意：索引是从1开始的
        index = word_dict[word]-1
        # 3.3- 将指定位置的值改为1即可
        word_one_hot[index] = 1

        print(f"{word}，对应的词向量是{word_one_hot}")

    # 4- 保存训练好的模型
    joblib.dump(my_tokenizer,"model/tokenizer.pkl")

def demo02():
    word = "王力宏"

    # 1- 加载训练好的模型
    my_tokenizer = joblib.load("model/tokenizer.pkl")

    # 2- 得到某个词的词向量
    # 2.1- 获得词汇映射器中词和索引的对应关系
    word_dict = my_tokenizer.word_index
    # 2.2- 初始化一个全0的列表
    word_one_hot = [0]*len(word_dict)
    # 2.3- 获得该词的索引
    index = word_dict[word]-1
    # 2.4- 将指定索引位置的值设置为1即可
    word_one_hot[index] = 1

    print(word_one_hot)

# 基于纯Python入门试学班的代码实现
def demo03():
    # 1- 准备语料库
    vocabs = ["周杰伦", "陈奕迅", "王力宏", "李宗盛", "吴亦凡", "鹿晗"]

    # 2- 得到每个词的one-hot词向量
    vocabs_len = len(vocabs)
    for word in vocabs:
        # 2.1- 初始化一个全0的词向量列表
        word_one_hot = [0] * vocabs_len  # 得到是[0,0,0,0,0,0]
        # 2.2- 获得词在语料库的索引
        index = vocabs.index(word)
        # 3.3- 将指定位置的值改为1即可
        word_one_hot[index] = 1

        print(f"{word}，对应的词向量是{word_one_hot}")


if __name__ == '__main__':
    # 1- 训练模型：也就是训练词汇映射器
    demo01()

    # 2- 使用训练好的模型
    demo02()

    # 3- 用最基本的方式实现
    demo03()

• One-hot总结

获得词向量的one-hot方式总结：
    优点：实现、理解简单
    缺点：
        1- 词向量是一个稀疏向量，会浪费存储和计算资源
        2- 对多义词的处理不好。例如：过过过过过过，中的3对过的词向量是同一个

Word2Vec模型

word2vec介绍
    1- 是将文本变成词向量张量的一种方法，是一种无监督（自监督）的训练方法，本质是训练一个模型，将模型的参数矩阵当作所有词汇的词向量表示。基于one-hot的形式进行优化改造
    2- 它又分为两种具体模式：
        CBOW：连续词袋模式。使用两边的词预测中间的内容
        Skip-gram：跳词模式。使用中间的词预测两边的内容

CBOW【了解】

properties 核心思想：给一段文本，选择一定的窗口，然后利用上下文预测中间目标词

• 实现过程

skip-gram【了解】

核心思想: 给出一段文本，选择一定窗口获取数据集，利用中间词来预测上下文

• 实现过程

Fasttext实现Word2Vec代码【掌握】

• 基本过程

1.获取数据
2.训练模型（训练词向量）  
    正常安装：pip install fasttext -i https://mirrors.aliyun.com/pypi/simple/
    如果失败：pip install fasttext-wheel -i https://mirrors.aliyun.com/pypi/simple/
3.向量的检验
4.超参数设定
5.模型的保存和加载

• 代码实现

"""
    如果不管是安装fasttext还是fasttext-wheel都失败，那么原因是python版本过高。
    操作步骤如下：
        1- 先进入对应的虚拟环境
        2- 安装低版本的python解释器
            conda install python=3.10
        3- 安装fasttext
            pip install fasttext-wheel -i https://mirrors.aliyun.com/pypi/simple/
"""
import fasttext

def demo01():
    # 1- 使用无监督学习训练模型
    """
        为什么这里只能使用无监督学习？
        答：因为数据中没有明确标记目标值。有监督学习对文件内容有严格要求，有__label__
    """
    # model = fasttext.train_unsupervised("data/fil9")
    model = fasttext.train_unsupervised("data/gz03ag")

    # 2- 保存训练好的模型
    model.save_model("model/word2vec.pkl")

def demo02():
    # 1- 加载训练好的模型
    model = fasttext.load_model("model/word2vec.pkl")

    # 2- 获得某个词的词向量
    word_vec = model.get_word_vector("hello")
    print(word_vec)

def demo03():
    # 1- 加载训练好的模型
    model = fasttext.load_model("model/word2vec.pkl")

    # 2- 获得相近的几个词
    # 会从词形、词义方面进行查找。
    # result_list = model.get_nearest_neighbors("dog")
    result_list = model.get_nearest_neighbors("cat")

    # 3- 输出
    print(result_list)

def demo04():

    """
        参数解释：
            input：训练集路径
            model：word2vec的模式。默认是skipgram，可以设置为cbow
            dim：词向量的维度
            epoch：训练的轮次
            lr：初始学习率
            thread：训练的线程个数
    """
    model = fasttext.train_unsupervised(
        input="data/gz03ag",
        model="cbow",
        dim=200,
        epoch=1,
        lr=0.1,
        thread=10
    )

    model.save_model("word2vec_better.pkl")

if __name__ == '__main__':
    # 1- 训练并保存模型
    # demo01()

    # 2- 获得词的词向量
    # demo02()

    # 3- 获得相近的词
    # demo03()

    # 4- 超参数调优设置【掌握】
    demo04()

词嵌入Word Embedding【复习】

word2vec缺点：静态的、固定的vec表示方法，对多义词处理效果不佳

• 实现过程

借助nn.Embedding(num_embeddings, embed_dim): 
    num_embeddings：代表词汇（去重之后）的总量
    embed_dim：是我们设定的词向量维度

• 代码实现

import os
import torch

os.environ['TF_ENABLE_ONEDNN_OPTS']='0'
from tensorflow.keras.preprocessing.text import Tokenizer # 词汇映射表
import jieba
import torch.nn as nn
from torch.utils.tensorboard import SummaryWriter # 词向量可视化化

if __name__ == '__main__':
    # 1- 准备文本数据
    sentence1 = '传智教育是一家上市公司，旗下有黑马程序员品牌。我是在黑马这里学习人工智能'
    sentence2 = "我爱自然语言处理"
    sentence_list = [sentence1,sentence2]

    # 2- 分词处理
    word_list = []
    for sen in sentence_list:
        word_list.append(jieba.lcut(sen))
    # print(word_list)

    # 3- 使用语料库对Tokenizer词汇映射器进行训练
    # 3.1- 创建Tokenizer实例对象
    my_token = Tokenizer()
    # 3.2- 模型训练
    my_token.fit_on_texts(word_list)
    # 3.3- 得到索引和词的映射关系，结果是一个字典。注意：索引从1开始
    # 【了解】1- 首先根据词在句子中的顺序来排序；2- 然后将出现频次高的词排在前面；3- 如果频次相同，那么按照首次出现的顺序排序
    index_word = my_token.index_word
    word_num = len(index_word)
    print(index_word)

    # 4- 创建词嵌入层
    """
        num_embeddings：去重后的词汇表中总共有多少个词
        embedding_dim：每个词的词向量维度（也就是向量中有多少个数字）
    """
    ebd = nn.Embedding(num_embeddings=word_num,embedding_dim=6)

    # 5- 得到词向量
    for i in range(word_num):
        # 5.1- 根据词索引得到词向量
        word_vector = ebd(torch.tensor(i))

        # 5.2- 打印输出
        print(f"索引是{i+1}，对应的词是 {index_word.get(i+1)}，词向量{word_vector}")

    # 6- 可视化展示：通过tensorboard（张量面板）观察词之间的相似性
    summary_obj = SummaryWriter(log_dir="./runs")
    summary_obj.add_embedding(ebd.weight.data,index_word.values())
    summary_obj.close()

• 结果可视化

• 命令：tensorboard --logdir=runs --host 127.0.0.1

• 截图

• 访问：使用Edge浏览器来访问。输入链接 http://127.0.0.1:6006

文本数据分析【理解】

文本数据分析有哪些方法
    1、标签数量分布
    2、句子长度分布
    3、词频统计和词云

文本数据分析的作用
    1、帮助我们理解语料
    2、帮助我们检查语料, 快速分析语料中可能存在的问题.
        例如:
            数据质量类: 错别字, 语法错误, 重复内容, 缺失值...
            数据均衡类: 标签分布不均, 句子长度不同...

标签数量分布

目的: 查询样本类别是否均衡，如果样本过大，需要减少数据；如果样本过少，需要增加数据

• 代码实现

import seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd
"""
    如果出现AttributeError: 'FigureCanvasInterAgg' object has no attribute 'tostring_rgb'. Did you mean: 'tostring_argb'?
    那么是matplotlib的版本过高导致的
    pip uninstall -y matplotlib
    pip install matplotlib==3.8.4 -i https://mirrors.aliyun.com/pypi/simple/
"""

if __name__ == '__main__':
    # 1- 读取文件
    """
        注意：需要指定具体的分隔符sep，否则会报错pandas.errors.ParserError: Error tokenizing data. C error: Expected 6 fields in line 12, saw 8
    """
    train_df = pd.read_csv("data/train.tsv",encoding="UTF-8",sep="\t")
    dev_df = pd.read_csv("data/dev.tsv",encoding="UTF-8",sep="\t")

    # 2- 展示训练集
    plt.style.use("fivethirtyeight")
    sns.countplot(x="label",data=train_df)
    plt.title("train")
    plt.show()

    # 3- 展示验证集
    sns.countplot(x="label", data=dev_df)
    plt.title("dev")
    plt.show()

句子长度分布

目的: 模型一般规定需要输入固定的尺寸，也就是长度统一，通过分析句子长度，可以明确大部分样本属于什么长度范围，然后进行句子的长短补齐或截断

• 解释list( map(lambda x: len(x), sentence_series))

if __name__ == '__main__':
    my_data = [11,22,33]
    map_result = map(lambda num:num*10, my_data) # 这里实际是得到了一个生成器对象
    # print(map_result) # 得到的是内存地址值

    # 取值方式一【推荐】：转成List列表
    # list_result = list(map_result)
    # print(list_result)

    print("-"*30)

    # 取值方式二：for循环
    # for i in map_result:
    #     print(i)

    print("-" * 30)

    # 取值方式三：next一个个取值
    print(next(map_result))
    print(next(map_result))
    print(next(map_result))

• 代码实现

import seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd

def demo01():
    # 1- 读取数据
    df = pd.read_csv("data/train.tsv",sep="\t",encoding="UTF-8")

    # 2- 统计句子长度
    # 2.1- 获得句子列
    sentence_series = df["sentence"]
    # 2.2- 计算句子长度
    # 方式一：list(map)
    # df["length"] = list(map(lambda line:len(line),sentence_series))

    # 方式二：apply
    df["length"] = sentence_series.apply(lambda line:len(line))
    # print(df.head())

    # 3- 绘制图形
    # 3.1- 绘制分布直方图
    plt.style.use("fivethirtyeight")
    sns.countplot(x="length",data=df)
    plt.xticks([])
    plt.title("length_dist")
    plt.show()

    # 3.2- 绘制趋势曲线
    # kde：让曲线更加平滑
    sns.displot(x="length",data=df,kde=True)
    plt.show()


def demo02():
    # 1- 读取数据
    df = pd.read_csv("data/train.tsv", sep="\t", encoding="UTF-8")

    # 2- 统计句子长度
    # 2.1- 获得句子列
    sentence_series = df["sentence"]
    # 2.2- 计算句子长度
    df["length"] = sentence_series.apply(lambda line: len(line))

    # 3- 绘制图形
    sns.stripplot(x="label",y="length",data=df,hue="label")
    plt.title("label_length")
    plt.show()

if __name__ == '__main__':
    # 句子长度分布
    demo01()

    # 好评差评的句子长度分布
    demo02()

词频和高频词云

词频: 这里指的是统计样本中词汇的总数量（需要去重）
高频词云目的: 可以方便我们查看数据集中是否存在脏数据，进而实现人工的审核和清洗

• 解释chain(*map())

chain的作用可以简单理解为和List.extend等价，但是有区别：chain返回一个的是一个迭代器，因此对内存的使用极低，而且不修改原始列表

# 导包
from itertools import chain
import jieba

def dm01():
    list1 = ['今天天很好', '今天天很热']
    # 对每个字符串进行分词处理
    tmp_result = map(lambda x: jieba.lcut(x), list1)
    print(list(tmp_result))
    print(*tmp_result)
    # 把上述结果合并, 不会去重.
    result = list(chain(*tmp_result))
    print(f'result: {result}')

    # 上述格式最终版写法, 即: 一行.
    result = list(chain(*map(lambda x: jieba.lcut(x), list1)))
    print(f'result: {result}')

if __name__ == '__main__':
    dm01()

• 词频_代码实现

# 导包
import jieba
import seaborn as sns
import pandas as pd
import matplotlib.pyplot as plt  # 推荐安装 pip install matplotlib==3.9
from itertools import chain  # 迭代器工具

# 解决Matplotlib绘图时 中文乱码问题.
plt.rcParams['font.sans-serif'] = ['SimHei']  # Mac本字体改为: ['Arial Unicode MS']
plt.rcParams['axes.unicode_minus'] = False

# 1. 词频统计.
def dm01_word_count():
    # 1. 读取数据.
    train_data = pd.read_csv('./data/train.tsv', sep='\t')
    test_data = pd.read_csv('./data/dev.tsv', sep='\t')

    # 2. 统计 训练集中 词汇总数.
    train_vocab = set(chain(*map(lambda x: jieba.lcut(x), train_data['sentence'])))

    # 3. 统计 测试集中 词汇总数.
    test_vocab = set(chain(*map(lambda x: jieba.lcut(x), test_data['sentence'])))

    # 4. 打印结果.
    print(f'训练集的 词汇总数: {len(train_vocab)}')
    print(f'测试集的 词汇总数: {len(test_vocab)}')

if __name__ == '__main__':
    # 词频统计
    dm01_word_count()

• 高频词云_代码实现

import pandas as pd
from itertools import chain
from wordcloud import WordCloud # 词云类
import jieba.posseg as pseg
import matplotlib.pyplot as plt

def get_a_word(line):
    # 分词并且标注词性
    word_dict = pseg.lcut(line)
    # print(word_dict)

    result_list = []

    # 过滤形容词
    for word,pos in word_dict:
        if pos=="a":
            result_list.append(word)

    return result_list

def show_cloud(a_word_list):
    # 1- 创建词云对象
    wordcloud_obj = WordCloud(font_path="data/SimHei.ttf",max_words=100,background_color="white")

    # 2- 词汇列表以空格分隔拼接成字符串
    words_str = " ".join(a_word_list)

    # 3- 绘制图形
    wordcloud_obj.generate(words_str)
    plt.figure()
    # bilinear：让文字边缘更加平滑
    plt.imshow(wordcloud_obj,interpolation="bilinear")
    plt.axis("off")
    plt.show()

def word_cloud():
    # 1- 读取文件，并且取出评价内容
    df = pd.read_csv("data/train.tsv",sep="\t",encoding="UTF-8")
    sentence_series = df["sentence"]

    # 2- 句子分词，过滤出形容词
    # 注意：map返回的是生成器，你要真的调用它，才会触发数据的产生
    a_word_list = list(chain(*map(get_a_word,sentence_series)))
    # a_word_list = list(chain(*map(lambda line: [word for word,pos in pseg.lcut(line) if pos=="a"],sentence_series)))
    # print(a_word_list)

    # 3- 绘制词云
    show_cloud(a_word_list)

if __name__ == '__main__':
    word_cloud()

文本特征处理【熟悉】

【介绍一下n-gram】

将n个连续相邻的token组合到一起，n-gram特征

【为什么要规范文本长度】

模型的输入需要【每个batch】或者【整个数据集】，统一句子长度

对语料添加普适性的特征：n-gram
对语料进行规范长度：适配模型的输入

添加N-Gram特征

n-gram介绍:
    概述:
        就是将连续的n个词组合到一块, 把这些连续片段当做1个新特征(小词组特征), 帮我们分析文本的规律.
    分析:
        uni-gram(1-gram): 把每个 词/字 拆出来.
        bi-gram(2-gram): 找连续2个词的组合.
        tri-gram(3-gram): 找连续3个词的组合.
    目的:
        让计算机更好的理解 文本规律，也就是上下文信息.

例如：
分词内容: 我｜ 爱｜ 黑马
uni-gram: 我｜ 爱｜ 黑马
bi-gram: 我爱｜爱黑马
tri—gram: 我爱黑马

• zip函数解释

if __name__ == '__main__':
    list1 = [1, 2, 3, 4, 5, 6]
    list2 = [2, 3, 4]

    result = list(zip(list1, list2))
    print(result)

• 代码实现

"""
    n-gram：指的是 将相邻的n个词拼接到一起成为新词的过程。其中n一般取值为1、2、3
        1：uni-gram，不进行拼接操作
        2：bi-gram，将相邻的2个词拼接到一起
        3：tri-gram，将相邻的3个词拼接到一起

    作用：通过拼接相邻词的过程，提升模型对语义上下文的理解
    注意：n的值实际工作中一般是3以内，大多数情况是2。如果n太大，会导致词汇表个数膨胀，太长的拼接没有意义
"""

def n_gram_fn(n_gram):
    # 1- 测试数据
    word_list = ["aa","bb","cc","dd"]

    # 2- 对相邻的词进行合并
    """
        2-gram：
            ["aa","bb","cc","dd"]
            ["bb","cc","dd"]

        3-gram：
            ["aa","bb","cc","dd"]
            ["bb","cc","dd"]
            ["cc","dd"]
    """
    lists = [word_list[i:] for i in range(n_gram)]
    print(lists)

    print(list(zip(*lists)))

if __name__ == '__main__':
    n_gram_fn(n_gram=1)
    n_gram_fn(n_gram=2)
    n_gram_fn(n_gram=3)

文本长度规范

意义: 一般模型的输入需要等尺寸大小的矩阵, 所以需要对超长文本做截断, 不足的做补齐。这就是文本长度规范.

• 代码实现

# from tensorflow.keras.preprocessing import sequence
from keras.preprocessing import sequence

sen_list = [
                [1, 23, 5, 32, 55, 63, 2, 21, 78, 32, 23, 1],
                [2, 32, 1, 23, 1]
        ]

# 用框架提供的方法实现句子长度的规范
def demo01():
    """
        sequences：要进行长度规范的句子列表
        maxlen：长度规范中的句子长度要求统一为多长，指的是词的个数
        truncating：截断的方向。默认是pre，从前面开始截断；post从后面开始截断
        padding：填充的方向。默认是pre，从前面开始填充；post从后面开始填充
        value：使用什么值进行填充。推荐使用默认的0，因为对原始数据的影响最小
    """
    result = sequence.pad_sequences(sen_list,maxlen=10,truncating="post",padding="post")
    # result = sequence.pad_sequences(sequences=sen_list,maxlen=10,truncating="pre",padding="pre")
    # result = sequence.pad_sequences(sequences=sen_list,maxlen=10,value=6666)
    print(result)

def demo02():
    # 1- 定义一个空列表用来存储规范化后的句子
    result_list = []

    maxlen = 10 # 句子的长度

    # 2- 分别对每条句子进行处理
    for sen in sen_list:
        if len(sen)>maxlen:
            # 超长的要截断
            result_list.append(sen[:maxlen])
        else:
            # 短的要填充
            result_list.append(sen + [0]*(maxlen-len(sen)))

    print(result_list)

if __name__ == '__main__':
    # 用框架提供的方法实现句子长度的规范
    demo01()

    # 使用最简单的python代码实现
    demo02()

第三章 RNN及其变体

认识RNN模型

• 定义

循环神经网络：一般接受的一序列进行输入，输出也是一个序列

• 作用和应用场景

RNN擅长处理连续语言文本，机器翻译、文本生成、文本分类、摘要生成

• RNN模型的分类

• 根据输入与输出结构

properties N Vs N : 输入和输出等长，应用场景：对联生成；词性标注；NER N Vs 1 : 输入N，输出为单值，应用场景：文本分类 1 Vs N : 输入是一个，输出为N，应用场景：图片文本生成 N Vs M : 输入和输出不等长，应用场景：文本翻译、摘要总结

• 根据RNN内部结构

properties 传统RNN LSTM BI-LSTM GRU BI-GRU

传统RNN模型【复习】

基本概念

RNN(Recurrent Neural Network), 中文称作循环神经网络, 它一般以序列数据为输入, 通过网络内部的结构设计有效捕捉序列之间的关系特征, 一般也是以序列形式进行输出.

参数解释：

内部结构

来源文章：https://colah.github.io/posts/2015-08-Understanding-LSTMs/

• 输入：当前时间步xt和上一时间步输出的ht-1
• 输出：ht和ot （一个时间步内：ht=ot）

• 多层RNN的解析

~~~properties
output记录的是 最后一层 在每个时间步的隐藏状态。
hidden 记录的是 每一层 在最后一个时间步的隐藏状态。
~~~

代码实现

import torch
import torch.nn as nn

def rnn_demo(num_layers):
    # 1- 创建RNN循环网络层
    rnn = nn.RNN(input_size=4,hidden_size=5,num_layers=num_layers,batch_first=False)

    # 2- 准备数据
    # 2.1- 上一个时间步的隐藏状态
    h0 = torch.randn(size=(num_layers,2,5))
    input = torch.randn(size=(3,2,4))

    # 3- 调用RNN网络
    """
        输入参数张量形状：
            上一个时间步的隐藏状态h0：[num_layers隐藏层层数,batch_size每个批次中样本的条数,hidden_size隐藏状态向量维度]
            本次输入数据input：[seq_len每条样本中词的个数,batch_size每个批次中样本的条数,input_size词向量维度]

        输出参数张量形状：
            更新后的隐藏状态hidden：[num_layers隐藏层层数,batch_size每个批次中样本的条数,hidden_size隐藏状态向量维度]
            本次预测结果output：[seq_len每条样本中词的个数,batch_size每个批次中样本的条数,hidden_size隐藏状态向量维度]
    """
    output,hidden = rnn(input, h0)

    print(f"output的形状-->{output.shape}")    # [3,2,5]
    print(f"hidden的形状-->{hidden.shape}")    # [num_layers,2,5]

    print(f"output的内容-->\n{output}")
    print(f"hidden的内容-->{hidden}")

if __name__ == '__main__':
    # rnn_demo(num_layers=1)
    rnn_demo(num_layers=2)

总结

传统RNN的优缺点：

优点:
    内部结构简单, 资源消耗相对较小.
缺点:
    处理长序列(一句话中词的个数很多)数据时, 因为 反向传播 结合 梯度连乘, 过大或者过小的w值都会导致 梯度爆炸或者梯度消失.

    梯度爆炸：梯度值越来越大，导致权重值越来越大偏离最优的结果
    梯度消失：梯度值越来越小，导致权重值更新非常缓慢甚至不更新
    梯度震荡：学习率设置的不合理，导致权重值在最优点附近来回横跳

LSTM模型

基本概念

LSTM（Long Short-Term Memory）也称长短时记忆结构, 它是传统RNN的变体, 与经典RNN相比能够有效捕捉长序列之间的语义关联, 缓解梯度消失或爆炸现象，处理长序列数据效果差的问题。同时LSTM的结构更复杂

LSTM由如下四个部分组成:

• 遗忘门
• 输入门
• 细胞状态
• 输出门

补充：【门】这个词的理解

它来自于电子工程，用来控制信号的输出。在NLP中，可以与生活中的门、音量按钮等进行类比理解

内部结构【理解】

• 细胞状态：是 LSTM 的记忆库，贯穿整个序列，用来解决长序列记忆问题

• 遗忘门：决定上一个时间步输出的细胞状态中，哪些内容需要丢弃掉

• 输入门：当前输入的数据中，哪些要记录到细胞状态中

• 输出门：决定本次隐藏状态要输出哪些信息

• 完整结构图解释

代码实现【掌握】

import torch
import torch.nn as nn

if __name__ == '__main__':
    # 1- 创建LSTM网络结构
    """
        参数解释：
            bidirectional：是否是双向的网络结构。默认是False，也就是单向的。如果设置为True，LSTM就变成Bi-LSTM
    """
    lstm = nn.LSTM(input_size=4,hidden_size=5,num_layers=1,bidirectional=False)

    # 2- 准备数据
    # input的形状：[seq_len句子中词的个数,batch_size每个批次句子的个数,input_size词向量的维度]
    input = torch.randn(size=(6,3,4))

    """
        因为最终的隐藏状态是根据细胞状态经过激活函数处理得到的，
        但是激活函数不会改变张量的形状，只会改变值
        因此：隐藏状态 和 细胞状态 的张量形状是相同的
        实际工作中，一般对隐藏状态 和 细胞状态全都使用全0初始化
    """
    h0 = torch.zeros(size=(1,3,5))
    c0 = torch.zeros(size=(1,3,5))

    # 3- 调用LSTM
    """
        output形状：[seq_len,batch_size,hidden_size]
        hidden形状：[num_layers,batch_size每个批次句子的个数,hidden_size]
    """

    # 注意：传递和接受结果，都需要将隐藏状态 和 细胞状态用元组包起来
    output,(hidden,c1) = lstm(input,(h0,c0))

    print(f"output形状-->{output.shape}") # 6,3,5
    print(f"hidden形状-->{hidden.shape}")
    print(f"c1形状-->{c1.shape}") # 1,3,5

    print(f"output-->{output}")
    print(f"hidden-->{hidden}")
    print(f"c1-->{c1}")

Bi-LSTM

定义: 不改变原始的LSTM模型内部结构，只是将文本从左到右计算一遍，再从右到左计算一遍，把最终的输出结果拼接得到模型的完整输出

import torch
import torch.nn as nn

if __name__ == '__main__':
    # 1- 创建LSTM
    """
        参数解释：
            bidirectional：LSTM循环网络层是否是双向的。如果为True，那就是Bi-LSTM
                        如果是双向的LSTM，那么隐藏状态 和 细胞状态 张量中第一个形状=num_layers*2
    """
    lstm = nn.LSTM(input_size=4,hidden_size=5,num_layers=2,batch_first=False,bidirectional=True)

    # 2- 准备数据
    # 2.1- 本次输入数据
    input = torch.randn(size=(3,2,4))

    # 2.2- 上一个时间步的隐藏状态。初始隐藏状态一般全0初始化
    h0 = torch.zeros(size=(4,2,5))

    # 2.3- 上一个时间步的细胞状态。初始细胞状态一般全0初始化，它的形状与隐藏状态的形状完全一样
    c0 = torch.zeros(size=(4, 2, 5))

    # 3- 调用LSTM
    """
        注意：隐藏状态  与  细胞状态  顺序，不能调整；并且这两个值要用小括号包起来
        输入参数：本次输入数据, (上一个时间步的隐藏状态, 上一个时间步的细胞状态)
        返回结果：本次预测结果, (更新后的本次时间步隐藏状态, 更新后的细胞状态)
    """
    output,(hidden,c) = lstm(input,(h0,c0))

    print(f"output的形状-->{output.shape}")  # [3,2,5]
    print(f"hidden的形状-->{hidden.shape}")  # [4,2,5]
    print(f"细胞状态的形状-->{c.shape}")  # [4,2,5]

    print(f"output的内容-->\n{output}")
    print(f"hidden的内容-->{hidden}")
    print(f"细胞状态的内容-->{c}")

总结

LSTM的优缺点是什么？

优点:
    1. 能够处理更长的句子
    2. 缓解梯度消失或爆炸的问题 -> 训练更稳定.
    3. 能够抓取复杂的特征.
缺点:
    1. 计算慢, 消耗资源大.
    2. 调参相对较难.
    3. 可解释性稍差.

GRU模型

基本概念

GRU（Gated Recurrent Unit）也称门控循环单元结构, 它也是传统RNN的变体, 同LSTM一样能够有效捕捉长序列之间的语义关联, 缓解梯度消失或爆炸现象. 同时它的结构和计算要比LSTM更简单, 它的核心结构可以分为两个部分去解析:

• 更新门
• 重置门

内部结构【理解】

代码实现【掌握】

import torch
import torch.nn as nn

def gru_demo(num_layers):
    # 1- 创建GRU循环网络层
    """
        参数解释：
            bidirectional：GRU循环网络层是否是双向的。如果为True，那就是Bi-GRU
                        如果是双向的GRU，那么隐藏状态 和 细胞状态 张量中第一个形状=num_layers*2
    """
    gru = nn.GRU(input_size=4,hidden_size=5,num_layers=num_layers,batch_first=False,bidirectional=False)

    # 2- 准备数据
    # 2.1- 上一个时间步的隐藏状态
    h0 = torch.randn(size=(num_layers,2,5))
    input = torch.randn(size=(3,2,4))

    # 3- 调用GRU网络
    """
        输入参数张量形状：
            上一个时间步的隐藏状态h0：[num_layers隐藏层层数,batch_size每个批次中样本的条数,hidden_size隐藏状态向量维度]
            本次输入数据input：[seq_len每条样本中词的个数,batch_size每个批次中样本的条数,input_size词向量维度]

        输出参数张量形状：
            更新后的隐藏状态hidden：[num_layers隐藏层层数,batch_size每个批次中样本的条数,hidden_size隐藏状态向量维度]
            本次预测结果output：[seq_len每条样本中词的个数,batch_size每个批次中样本的条数,hidden_size隐藏状态向量维度]
    """
    output,hidden = gru(input, h0)

    print(f"output的形状-->{output.shape}")    # [3,2,5]
    print(f"hidden的形状-->{hidden.shape}")    # [num_layers,2,5]

    print(f"output的内容-->\n{output}")
    print(f"hidden的内容-->{hidden}")

if __name__ == '__main__':
    # gru_demo(num_layers=1)
    gru_demo(num_layers=2)

Bi-GRU

定义: 不改变原始的GRU模型内部结构，只是将文本从左到右计算一遍，再从右到左计算一遍，把最终的输出结果拼接得到模型的完整输出

总结

GRU的优缺点是什么？

优点：相比LSTM，结构较为简单，能够和lstm一样缓解梯度消失问题
缺点：只能缓解了梯度消失和爆炸问题, 不能并行计算

RNN、LSTM、GRU使用总结:
    1- 如果项目、需求简单，短序列（<50）的时候使用RNN
    2- 如果是中等序列（50-200）的使用使用GRU
    3- 如果是长序列（>200）的时候使用LSTM
    4- 如果是计算资源充足，推荐使用LSTM、Bi-LSTM、Bi-GRU；如果资源紧张考虑GRU

注意力机制【理解】

基本概念

Seq2Seq是啥，它和RNN、LSTM、GRU的关系和区别是啥？

1- Seq2Seq是一种模型架构，用于将一个序列映射到另一个序列。典型结构是 Encoder-Decoder（编码器-解码器）
2- RNN、LSTM、GRU是神经元内部结构
3- Seq2Seq模型的编码器和解码器通常由 RNN、LSTM 或 GRU 构成
4- 可以将Seq2Seq理解为房子，RNN、LSTM、GRU理解为建房子的砖

什么是机器翻译？

A文字 -> B文字，语言一样，叫文本生成
A文字 -> B文字，语言不同，叫机器翻译

注意力机制是什么意思？

将人类对事物的观察的习惯、能力，迁移到神经网络中，让模型在进行机器翻译、文本生成的时候，重点关注原始数据中的什么内容。

注意力机制（Attention Mechanism）是深度学习中一种增强模型对输入数据中重要信息关注能力的技术
注意力机制让模型在处理序列数据时动态地赋予不同输入数据不同的权重

注意力机制的由来

没有注意力机制之前存在的弊端: 
    弊端1: 如果翻译的句子很长很复杂，比如直接一篇文章输进去，模型的计算量很大，并且模型的准确率下降严重
    弊端2: 没有考虑词与词之间的相关性，导致翻译效果比较差

什么是注意力机制

==注意力机制是将人的感知方式、注意力的行为应用在机器上，让机器学会去感知数据中的重要和不重要的部分。==

将人类对事物的观察的习惯、能力，迁移到神经网络中，让模型在进行机器翻译、文本生成的时候，重点关注原始数据中的什么内容。

注意力机制分类及其实现

基本概念

1、【重点】软注意力: 也称之为全局注意。注意力权重值分布在0-1之间，关注所有的词汇，但是不同词汇根据权重大小关注的程度不一样。
2、硬注意力: 也称之为局部注意。注意力权重值是0或者1，只关注哪些重要的部分，忽略次要的部分
3、自注意力: 也称之为内注意。通过输入项内部的"表决"来决定应该关注哪些输入项.

软注意力

没有加Attention的Encoder-Decoder框架

==这个图主要理解谁是Target，谁是Source==

加Attention的Encoder-Decoder框架

==专属信息包C如何来的：权重值和对应的隐藏状态进行乘法，然后累加求和==

如何得到注意力概率分布

为什么要计算注意力分配系数？
    在Decoder生成当前词时，该重点关注Encoder里哪些单词
    例如：生成 汤姆 时，该多关注Encoder中的Tom、还是Chase、还是Jerry


注意力分配权重的计算过程如下(面试时使用)
1-计算相似性
使用相似性计算公式，对比Decoder上一个时间步的隐藏状态和Encoder中每个单词的隐藏状态计算相似性，看谁更重要
2-将相似性转成权重矩阵
使用Softmax激活函数，将上面的相似性转成权重(概率)，并且权重值之和为1
3-加权求和
使用第2步的权重矩阵与Encoder中每个单词的隐藏状态进行乘法和加法运算，得到专属信息包C

Attention机制的本质思想

几个英文单词的关系：
    Encoder编码器：
        Source：
            Key
            Value

    Decoder解码器：
        Target：
            Query

以使用百度为例：
    搜索内容: 人工智能      -> Query
    匹配过程: 网页源代码    -> Key
    查看结果: 网页详情页面  -> Value

Seq2Seq+注意力机制的架构中：
    Query: 是解码器中上一个时间步中GRU隐藏层输出的隐藏状态
    Key: 是编码器中当前时间步中GRU隐藏层输出的隐藏状态的拼接
    Value: 与Key是完全相同的，是编码器中当前时间步中GRU隐藏层输出的隐藏状态的拼接

==计算的详细过程【掌握】==：

总结(面试使用):注意力分配权重的计算过程
1- 计算相似性
使用nn.Linear计算Decoder端上一个时间步隐藏状态Query 和 Encoder端各个时间步的隐藏状态Key计算相似性

2- 相似性转权重
使用Softmax激活函数，将相似性转成权重矩阵。权重和为1

3- 加权求和
权重矩阵与Encoder端各个时间步的隐藏状态Value加权求和

Key和Value大多数情况是完全相同，表示编码器端的词经过GRU以后得到的隐藏状态

硬注意力【了解】

硬性注意力: 根据注意力分布选择输入向量中的一个作为输出。这里有两种选择方式：
    1- 选择注意力分布中，分数最大的那一项对应的输入向量作为Attention机制的输出
    2- 根据注意力分布进行随机采样，采样结果作为Attention机制的输出
    只关注被选中的部分，那么权重就是1；没选中的不关注，那么权重就是0

硬性注意力通过以上两种方式选择Attention的输出，这会使得最终的损失函数与注意力分布之间的函数关系不可导，导致无法使用反向传播算法训练模型，硬性注意力通常需要使用强化学习来进行训练。因此，一般深度学习算法会使用软性注意力的方式进行计算。

自注意力

自注意力机制: 对每个输入项分配的权重取决于输入项之间的相互作用，即通过输入项内部的"表决"来决定应该关注哪些输入项。
也就是指的是Source内部元素之间或者Target内部元素之间发生的注意力机制，也可以理解为Target=Source这种特殊情况下的注意力机制。

和前两种相比，在处理很长的输入时，具有并行计算的优势。

Transformer框架内部用到了自注意力机制。

结论: query、key、value，如果相等，就是自注意力机制；否则就不是

注意力计算规则

Pytorch中注意力机制计算原理

以翻译得到单词to为例介绍完整的流程

Encoder编码器端：
    1: 欢迎、来、北京 经过词嵌入层的处理得到对应的词向量
    2: 再将词向量送入到GRU中，得到对应的隐藏状态。对应时间步的隐藏状态再经过线性变换得到Key和Value。具体请看下面的【问题二：K或者V的具体来源】
    3: 对编码器端所有词对应的Key、Value进行张量拼接，分别得到K、V
        例如：每个批次batch_size中有2条句子，seq_len每条句子中词的个数有5个，每个词的隐藏状态向量维度8
        那么K和V的张量形状是[2batch_size, 5seq_len, 8hidden_size]
    4: 最后一个时间步的隐藏状态Key3作为初始隐藏状态给到Decoder解码器使用


Decoder解码器端：
    1: 解码器初始输入GO作为翻译的起始标识，输入到GRU中，翻译得到第一个词Welcome和本次更新后的隐藏状态h1
    2: 将上一个时间步的隐藏状态h1作为Q
    3: Q和K进行张量concat拼接
    4: 通过nn.Linear计算Q和K的相似性得分
    5: 通过Softmax激活函数将相似性得分转成权重矩阵
    6: 权重矩阵和V进矩阵乘法运算，也就是加权求和得到专属信息包C，专属于to的信息包
    7: Q和专属信息包C进行张量concat拼接
    8: 通过nn.Linear对拼接后的张量形状进行调整，以满足GRU的输入要求

问题一：上面讲的是翻译to之前计算专属信息包，那翻译Welcome的时候，专属信息包如何计算的？也就是【编码器端最后一个时间步的隐藏状态Key3会作为解码器端的初始隐藏状态h0使用，会作为Q】，而Q第一步又会和K拼接以及算相似性，那么不会出现重点关注【北京】词，而不是【欢迎】词吗？

答：

​ 1- 编码器端最后一个时间步的隐藏状态Key3会作为解码器端的初始隐藏状态h0使用：并不是直接使用，中间会经过nn.Linear的线性变换，变换后Q和K的相似性就低了

​ 2- 前向传播看起来类似，但是不要忘记还有反向传播，通过让损失值减小，会让注意力重点关注【北京】词。在训练过程中，如果模型错误地关注了“北京”，导致翻译错误，损失函数会很大。反向传播会调整权重 W ，使得与“北京”相关的分数降低，与“欢迎”相关的分数升高。

问题二：K或者V的具体来源

答：原始输入词 -> 词嵌入层 -> 词向量 -> GRU循环神经元 -> ==当前时间步隐藏状态h -> 线性变化Wh -> 每个时间步的Key== -> 拼接 -> K和V。==K和V的张量形状[batch_size, seq_len, hidden_size]==

在编码器端，RNN按时间步处理输入序列，每个时间步的隐藏状态计算为：

$ h_t=tanh⁡(W^{xh}⋅x_t+W_{hh}⋅h_{t−1}+b_h) $

Key是由所有时间步的隐藏状态组成的矩阵，经过线性变换得到：

$ K=[h1,h2,...,hn]⋅W^K $

以上理论对应的大模型prompt如下：https://www.qianwen.com/share/chat/6502a8a327cc4bc8a457210bf71b5594

第一个：Seq2Seq+注意力机制中，Query、Key、Value的详细来源，以及专属信息包C的完整计算过程

第二个：K具体是如何来的，是直接来自于隐藏状态吗

计算公式

计算规则前提

1- 当Q、K、V相等, 称作自注意力
2- 当Q、K、V不相等时，称为一般注意力（包括软注意力、硬注意力）
3- 自注意力 和 一般注意力的区别，只是数据层面（也就是QKV是否相等）的区别
4- 具体计算得到 自注意力 和 一般注意力，有如下的3种公式。目前使用最多的是第1个和第3个。

注意: 
    1: 不要将注意力的三种类别（软注意力、硬注意力、自注意力） 和 注意力计算的3个公式搞混
    2: 也就是下面的3个公式，即能够算软注意力，也能够算自注意力
    3: Transformer框架中使用的是第3个公式算自注意力，原因是除以根号dk

三种规则方法

• 公式1: 将Q和K进行纵轴拼接，然后经过线性变换，再经过Softmax进行处理得到权重，最后和V进行相乘

• 【了解】公式2：将Q和K进行纵轴拼接，接着经过一次线性变化，然后进过tanh激活函数处理，再进行sum求和，再经过softmax进行处理得到权重，最后和V进行张量的乘法

• 公式3：将Q和K的转置进行点乘，然后除以一个缩放系数，再经过softmax进行处理得到权重，最后和V进行张量的乘法

==注意：dk是k的维度，等于词向量的维度 或者 隐藏状态维度==

常见面试题：为什么公式要除以根号dk

答：防止矩阵点乘运算结果过大，导致Softmax计算后概率值出现极端值，极大或极小。避免模型对这些极值学习的不好

【了解】K为什么要转置？

举例：

​ K和V的形状是相同的，假设K的形状是[N个词, M的隐藏状态]

​ Q是单个时间步的隐藏状态，形状是[1, M的隐藏状态]

​ 为了能和V进行矩阵乘法运算，那么K需要转置

bmm函数介绍：

import torch

"""
    bmm和matmul对比总结
        1- 都能够实现矩阵乘法运算。matmul是串行计算，效率低；bmm是并行计算，效率高
        2- 如果matmul的张量形状不等，会进行广播机制
        3- bmm的要求如下：
            3.1- 参与运算的两个张量的形状有且只能是三维。形状的含义(batch_size,行数,列数)
            3.2- 参与运算的两个张量的batch_size必须相等
            3.3- 参与运算的两个张量中，前一个张量的列数 与 后一个张量的行数 必须相同

    后面在计算注意力的时候，如果满足bmm的要求，推荐使用bmm；当然可以无脑使用matmul，因为兼容性更好
"""
if __name__ == '__main__':
    # 准备数据
    mat_1 = torch.randint(low=1,high=5,size=(10,3,4))
    # mat_1 = torch.randint(low=1,high=5,size=(1,3,4))
    mat_2 = torch.randint(low=1,high=5,size=(10,4,5))

    # matmul
    matmul_result = mat_1 @ mat_2
    print("matmul_result：",matmul_result.shape)

    # bmm
    bmm_result = torch.bmm(mat_1,mat_2)
    print("bmm_result：", bmm_result.shape)

注意力机制的作用

注意：编码器、解码器都可以选择是否要加注意力机制
1- 编码器、解码器【都不加】注意力机制，那么就是最初的Seq2Seq
2- 编码器、解码器【都加】注意力机制，那么就是后面要学的Transformer架构
3- 编码器不加注意力机制，而解码器加注意力机制，那么就是Seq2Seq+注意力
4- 编码器加注意力机制，而解码器不加注意力机制，这种情况很少见

实现注意力机制【掌握】

• 步骤

第一步: 按照注意力规则，对Q、K、V进行注意力的计算
第二步: 如果第一步是拼接操作，需要将Q和第一步计算的结果进行再次拼接，如果是点乘运算，Q和K、V相等，不需要拼接
第三步: 我们需要将第二步的结果，进行线性变化，按照指定输出维度进行结果的表示

• 原理图

• 代码实现

import torch
import torch.nn as nn
from torch import Tensor


class MyAtten(nn.Module):
    def __init__(self,query_size,key_size,c_size,output_size):
        """
        :param query_size: 张量Q最后一个维度的形状，目前这里就是8
        :param key_size: 张量K最后一个维度的形状，目前这里就是8
        :param c_size: 张量C最后一个维度的形状，目前这里就是8
        :param output_size: Q和C拼接后，并且经过线性调整形状后的张量中最后一个维度的形状，目前这里就是8
        """

        # 1- 初始化父类
        super().__init__()

        # 2- 设置属性值
        self.query_size = query_size
        self.key_size = key_size
        self.c_size = c_size
        self.output_size = output_size

        # 3- 搭建网络结构
        # 3.1- 计算QK相似性的线性层。对应原理图中的第2步
        self.score_linear = nn.Linear(in_features=self.query_size+self.key_size,out_features=1)
        # self.score_linear = nn.Linear(in_features=16,out_features=1)

        # 3.2- 调整Q和C拼接后的张量形状线性层。对应原理图中的第6步
        self.qc_linear = nn.Linear(in_features=self.query_size+self.c_size,out_features=self.output_size)
        # self.qc_linear = nn.Linear(in_features=16,out_features=8)

    def forward(self,Q:Tensor,K,V):
        """
        目前暂时不研究QKV如何来的。只计算数据准备好后的注意力的计算过程。对应原理图中中间的绿色框
        :param Q: query，张量形状[batch_size,num_layers,hidden_size] -> [2,1,8]
        :param K: key，张量形状[batch_size,seq_len,hidden_size] -> [2,5,8]
        :param V: value，与key完全一致，张量形状[batch_size,seq_len,hidden_size] -> [2,5,8]
        :return:
        """
        # 1- Q和K拼接
        # 1.1- Q和K目前不能直接拼接，需要将Q的形状 由 [2,1,8] -> [2,5,8]
        seq_len = K.shape[1]
        # expand：扩大张量的形状。-1表示调整前后对应位置的形状不变
        Q_expand = Q.expand(size=(-1,seq_len,-1))
        print(f"1-->{Q.shape}") # [2,1,8]
        print(f"2-->{Q_expand.shape}") # [2,5,8]

        # 1.2- 拼接：Q_expand [2,5,8] K [2,5,8] -> [2,5,16]
        qc_cat = torch.cat(tensors=(Q_expand,K), dim=-1)
        print(f"3-->{qc_cat.shape}") # [2,5,16]

        # 2- 使用线性层对QK拼接后的结果计算相似性
        score = self.score_linear(qc_cat)
        print(f"4-->{score.shape}") # [2,5,1]

        # 3- 将相似性转成权重矩阵
        # 3.1- 调整score的形状：由[2,5,1] -> [2,1,5]
        score = score.transpose(dim0=1,dim1=2)
        print(f"5-->{score.shape}") # [2,1,5]

        # 3.2- 调用Softmax
        weighted_mat = torch.softmax(score, dim=-1)
        print(f"6-->{weighted_mat.shape}") # [2,1,5]

        # 4- 加权求和：权重矩阵和V进行矩阵乘法。计算得到专属信息包
        # weighted_mat [2,1,5]；V [2,5,8] -> [2,1,8]
        C = torch.bmm(weighted_mat, V)
        print(f"7-->{C.shape}") # [2,1,8]

        # 5- Q和C拼接：Q [2,1,8]；C [2,1,8] -> [2,1,16]
        qc_cat = torch.cat(tensors=(Q,C), dim=-1)
        print(f"8-->{qc_cat.shape}") # [2,1,16]

        # 6- 对拼接后的张量进行形状调整，以满足Decoder端GRU输入数据的要求
        result = self.qc_linear(qc_cat)
        print(f"9-->{result.shape}") # [2,1,8]

        return result,weighted_mat

if __name__ == '__main__':
    # 因为只讲PyTorch中注意力是如何计算得到。因此拼接后的value、Q、V我们直接手动初始化

    # 1- 定义基础变量
    batch_size = 2      # 每个批次中句子的条数
    seq_len = 5         # 每个句子中词的个数
    hidden_size = 8     # 我们人为设置词向量维度和隐藏向量维度相同
    num_layers = 1      # 隐藏层层数为1

    # 2- 初始化Q、K、V
    """
        为什么Q的形状中间是1？
        答：当前只针对Decoder解码器端一个时间步。当前时刻拿一个Q，去和Encoder全部位置算相似性
    """
    Q = torch.randn(size=(batch_size,num_layers,hidden_size))   # Decoder端当前时间步的隐藏状态
    K = torch.randn(size=(batch_size,seq_len,hidden_size))      # Encoder端多个词的隐藏状态拼接后的
    V = torch.randn(size=(batch_size,seq_len,hidden_size))      # Encoder端多个词的隐藏状态拼接后的

    # 3- 计算注意力
    query_size = hidden_size
    key_size = hidden_size
    c_size = hidden_size
    output_size = hidden_size

    attn_model = MyAtten(query_size,key_size,c_size,output_size)
    output,attn_weight = attn_model(Q,K,V)

    print(f"权重值{attn_weight}")
    print(f"权重值和{attn_weight.sum()}")

运行结果：

让代码运行在GPU上

==Windows、Linux、Mac(M芯片)均可==

==Windows(无独显)、Mac(Intel芯片)不行==

• 步骤

1: 【推荐】创建新的虚拟环境进行操作
    conda create -n nlp_cuda python==3.10

2: 进入虚拟环境
    conda activate nlp_cuda

3: 去黑窗口查看你本机的CUDA版本。【推荐】先升级英伟达。【操作截图见下面】
    nvidia-smi

4: 去Pytorch官网找到对应你cuda版本的下载命令，【截图见下面】
    官网地址: https://pytorch.org

5: 安装对应版本的cuda。安装命令
    pip3 install torch torchvision --index-url https://download.pytorch.org/whl/cu130

6: 在PyCharm中关联新的沙箱, 运行下边的代码测试即可.

7: 如果不OK,大概率是 显卡驱动(Cuda版本) 和 你的PyTorch版本不兼容, 建议: 直接更新驱动.

8: 要安装的其他包，一个一个安装即可
    pip install jieba -i https://pypi.tuna.tsinghua.edu.cn/simple/
    pip install tensorflow -i https://pypi.tuna.tsinghua.edu.cn/simple/
    pip install joblib -i https://pypi.tuna.tsinghua.edu.cn/simple/
    pip install fasttext-wheel -i https://pypi.tuna.tsinghua.edu.cn/simple/
    pip install seaborn -i https://pypi.tuna.tsinghua.edu.cn/simple/
    pip install matplotlib==3.8.4 -i https://pypi.tuna.tsinghua.edu.cn/simple/
    pip install tqdm -i https://pypi.tuna.tsinghua.edu.cn/simple/

• 代码

import torch

# 设备选择，我们可以选择在cuda或者cpu上运行你的代码
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
# 如果是Mac M芯片, 写这个
# device = 'mps'

print(f'device: {device}')

Seq2Seq英译法案例【多练习】

任务目的

目的: 给定一段英文，翻译为法文
典型的文本分类任务: 每个时间步去预测应该属于哪个法文单词

数据格式

• 注意：两列数据，第一列是英文文本，第二列是法文文本，中间用制表符号"\t"隔开

i am from brazil .  je viens du bresil .
i am from france .  je viens de france .
i am from russia .  je viens de russie .
i am frying fish .  je fais frire du poisson .
i am not kidding .  je ne blague pas .

实现流程

1. 获取数据:案例中是直接给定的
2. 数据预处理: 脏数据清洗、数据格式转换、数据源Dataset的构造、数据迭代器Dataloader的构造
3. 模型搭建: 编码器和解码器等一系列模型
4. 模型评估
5. 模型上线

基础准备

import random
import re
import torch
import torch.nn as nn
from torch.utils.data import Dataset,DataLoader
from tqdm import tqdm
import matplotlib.pyplot as plt

# 1- 设置变量
# 运行设备
device = ("cuda" if torch.cuda.is_available() else "cpu")   # Windows的写法
# device = "mps"  # Mac的写法

# 数据文件路径
data_path = "data/eng-fra-v2.txt"

# 句子开始标识
SOS_TOKEN = 0

# 句子结束标识
EOS_TOKEN = 1

# 句子长度规范：长度的上限
MAX_LENGTH = 10

数据预处理

定义样本清洗函数和构建字典

• 目的

样本清洗函数: 将脏数据进行清洗，以免影响模型训练
构建字典:一方面是为了将文本进行数字表示，还有一方面进行解码的时候将预测索引数字映射为真实的文本

• 样本清洗函数代码实现

# 2- 数据清洗
def normalizeString(line):
    # 将文本全部转小写
    line = line.lower().strip()
    # print(f"-{line}-")

    # 在指定的标点符号的前面增加空格
    line = re.sub(pattern=r"([.!?])",repl=r" \1",string=line)

    # 去除除了26个小写、.!?以外的其他符号，全部替换成空格
    line = re.sub(pattern=r"[^a-z.!?]+", repl=r" ", string=line)

    return line

• 构建字典代码实现

# 3- 构建词汇表
def getdata():
    # 1- 读取文件
    with open(data_path,encoding="UTF-8",mode="r") as f:
        eng_fra_list = f.readlines()

    # 2- 划分得到英语和法语
    # eng_fra_pairs结构：[[英语句子1, 法语句子1], [英语句子2, 法语句子2]...]
    eng_fra_pairs = []
    for eng_fra_line in eng_fra_list:

        tmp_list = []
        for line in eng_fra_line.split("\t"):
            tmp_list.append(normalizeString(line))

        eng_fra_pairs.append(tmp_list)

    # 3- 分别得到英语词汇表和法语词汇表
    english_word2index = {"SOS":SOS_TOKEN,"EOS":EOS_TOKEN}
    english_word_cnt = 2

    franch_word2index = {"SOS":SOS_TOKEN,"EOS":EOS_TOKEN}
    franch_word_cnt = 2

    for eng_fra_list in eng_fra_pairs:
        # 英语句子处理：分词->去重->添加
        for eng_word in eng_fra_list[0].split(" "):
            if eng_word not in english_word2index:
                english_word2index[eng_word] = english_word_cnt
                english_word_cnt += 1

        # 法语句子处理：分词->去重->添加
        for fra_word in eng_fra_list[1].split(" "):
            if fra_word not in franch_word2index:
                franch_word2index[fra_word] = franch_word_cnt
                franch_word_cnt += 1

    # 4- 将法语字典中key和value的位置交换
    franch_index2word = {index:word for word,index in franch_word2index.items()}

    return english_word2index,english_word_cnt,franch_word2index,franch_word_cnt,eng_fra_pairs,franch_index2word

english_word2index,english_word_cnt,franch_word2index,franch_word_cnt,eng_fra_pairs,franch_index2word = getdata()

构建DataSet

• 目的

使用Pytorch框架，一般遵从一个规矩：使用DataSet方法构造数据源，来让模型进行使用
构造数据源的过程中:必须继承torch.utils.data.Dataset类，必须构造两个魔法方法：__len__(), __getitem__()
__len__(): 一般返回的是样本的总个数，我们可以直接len(dataset对象)直接就可以获得结果
__getitem__(): 可以根据某个索引取出样本值，我们可以直接用dataset对象[index]来直接获得结果

• 代码实现

# 4- 自定义Dataset
class MyPairsDataset(Dataset):
    def __init__(self,eng_fra_pairs):
        self.eng_fra_pairs = eng_fra_pairs
        self.sample_cnt = len(eng_fra_pairs)    # 样本条数

    def __len__(self):
        return self.sample_cnt

    def __getitem__(self, index):
        # 1- 防止索引为负数；防止索引越界
        index = min(max(index,0), self.sample_cnt - 1)

        # 2- 获得英语句子（特征数据）和法语句子（目标值）
        # 2.1- 获得句子。[英语句子1, 法语句子1]
        eng_fra_pair = self.eng_fra_pairs[index]

        # 句子 -> 分词 -> 变成索引
        """
            为什么只在句子的末尾增加结束标识EOS_TOKEN，而不增加SOS_TOKEN？
            答：
                1- Seq2Seq架构要求必须要有EOS_TOKEN，而SOS_TOKEN可选的
                2- SOS_TOKEN会在Decoder中进行数据处理的时候再增加
                3- Decoder端我们只能通过添加SOS_TOKEN告诉解码器开始进行翻译的工作；以及通过添加EOS_TOKEN告诉解码器翻译工作结束
        """
        # 2.2- 处理英语句子
        x = [english_word2index[word] for word in eng_fra_pair[0].split(" ")]
        # 所有的张量数据必须放在同一个硬件设备上，要么同时在GPU，要么同时在CPU
        x_tensor = torch.tensor(x,dtype=torch.long,device=device)
        # print(f"原始英语句子{eng_fra_pair[0]}，词索引向量{x_tensor}")

        # 2.3- 处理法语句子
        y = [franch_word2index[word] for word in eng_fra_pair[1].split(" ")]
        y.append(EOS_TOKEN)
        y_tensor = torch.tensor(y, dtype=torch.long, device=device)
        # print(f"原始法语句子{eng_fra_pair[1]}，词索引向量{y_tensor}")

        return x_tensor,y_tensor

构建Dataloader

• 目的

为了将Dataset我们上一步构建的数据源，进行再次封装，变成一个迭代器，可以进行for循环，而且，可以自动为我们dataset里面的数据进行增维（bath_size）,也可以随机打乱我们的取值顺序

• 代码实现

# 5- 创建DataLoader
def get_dataloader():
    # 1- 创建自定义Dataset实例对象
    dataset = MyPairsDataset(eng_fra_pairs)

    # 2- 创建数据加载器
    dataloader = DataLoader(dataset=dataset,batch_size=1,shuffle=True)

    return dataloader

模型搭建

搭建编码器GRU模型

• 代码实现

# 6- 无注意力机制的编码器
class Encoder(nn.Module):
    def __init__(self,eng_vocab_size,input_size,hidden_size):
        """
        :param eng_vocab_size: 英语词汇表大小
        :param input_size: 词向量维度
        :param hidden_size: 隐藏状态向量维度
        """

        # 1- 初始化父类
        super().__init__()

        # 2- 设置属性值
        self.eng_vocab_size = eng_vocab_size
        self.input_size = input_size
        self.hidden_size = hidden_size

        # 3- 搭建网络结构
        # 3.1- 词嵌入层
        self.ebd = nn.Embedding(num_embeddings=self.eng_vocab_size,embedding_dim=self.input_size)

        # 3.2- 循环网络层
        self.gru = nn.GRU(input_size=self.input_size,hidden_size=self.hidden_size,num_layers=1,batch_first=True)

    def forward(self,input,hidden):
        """
        Encoder端的前向传播：负责理解英语句子的语义信息
        :param input: 本次输入数据，张量形状：[batch_size每个批次中英语句子的条数,seq_len英语句子中词的个数]
        :param hidden: 上一个时间步的隐藏状态，张量形状：[num_layers,batch_size,hidden_size]
        :return:
        """
        # 1- 调用词嵌入层
        # embed形状：[batch_size每个批次中英语句子的条数,seq_len英语句子中词的个数,input_size词向量维度]
        # print(f"1--input-->{input.shape}")
        embed = self.ebd(input)
        # print(f"2--embed-->{embed.shape}")

        # 2- 调用GRU
        output,hidden = self.gru(embed,hidden)

        return output,hidden

    def init_hidden(self):
        # 隐藏状态张量形状：[num_layers,batch_size,hidden_size]
        # num_layers：目前手动指定为1层
        # batch_size：因为我们没有对英语句子进行长度规范的处理，因此只能设置为1
        return torch.zeros(size=(1,1,self.hidden_size)).to(device=device)

• 编码器模型测试

# 测试编码器
def use_encoder():
    # 1- 准备数据
    dataloader = get_dataloader()

    # 2- 创建编码器对象
    my_encoder = Encoder(eng_vocab_size=english_word_cnt,input_size=256,hidden_size=256)
    my_encoder.to(device=device)

    # 3- 遍历数据，前向传播
    for x,y in dataloader:
        # 3.1- 初始隐藏状态
        hidden = my_encoder.init_hidden()

        # 3.2- 前向传播
        output,hidden = my_encoder(x,hidden)

        print(f"output-->{output.shape}")
        print(f"hidden-->{hidden.shape}")

        break

搭建解码器无Attention模型

• 流程

• output[-1]和output[0]的区别

import torch

if __name__ == '__main__':
    # 3个词，2条句子，4隐藏状态向量维度
    output = torch.randn(size=(3,2,4))
    print(output)

    print("-"*30)

    output_1 = output[:,-1,:]
    print(output_1)
    print(output_1.shape) # [3,4]

    print("-" * 30)

    output_0 = output[:,0,:]
    print(output_0)
    print(output_0.shape) # [3,4]

• 代码实现

# 7- 解码器：无注意力机制
class Decoder(nn.Module):
    def __init__(self,fra_vocab_size,hidden_size):
        # 1- 初始化父类
        super().__init__()

        # 2- 设置属性值
        self.fra_vocab_size = fra_vocab_size
        self.hidden_size = hidden_size

        # 3- 搭建网络结构
        # 3.1- 词嵌入层
        self.ebd = nn.Embedding(num_embeddings=self.fra_vocab_size,embedding_dim=self.hidden_size)

        # 3.2- GRU层
        self.gru = nn.GRU(input_size=self.hidden_size,hidden_size=self.hidden_size,num_layers=1,batch_first=True)

        # 3.3- 输出层
        self.output_linear = nn.Linear(in_features=self.hidden_size,out_features=self.fra_vocab_size)

        # 4- 输出层的激活函数
        # CrossEntropyLoss = LogSoftmax + NLLLoss
        self.log_softmax = nn.LogSoftmax(dim=-1)

    def forward(self,input,hidden):
        """
        Decoder前向传播：负责翻译得到法语词
        :param input: 本次输入数据，每次只送一个法语词进来，张量形状：[batch_size,seq_len]，[[一个法语词的词索引]]
        :param hidden: 上一个时间步的隐藏状态，张量形状：[num_layers,batch_size,hidden_size]
        :return:
        """

        # 1- 调用词嵌入层
        embed = torch.relu(self.ebd(input))

        # 2- 调用GRU
        output,hidden = self.gru(embed,hidden)
        print(f"1-->output-->{output.shape}")

        # 3- 调用输出层
        # 3.1- 将output由3维变成2维，[batch_size,seq_len,hidden_size] -> [batch_size,hidden_size]
        """
            output[:,-1,:] 针对文本分类的业务场景。-1表示取最后一个时间步的隐藏状态，文本分类需要对一整条句子的完整信息理解完以后再做分类
            output[:,0,:]  针对文本翻译的业务场景。
        """
        output = output[:,0,:]
        print(f"2-->output[:,0,:]-->{output.shape}")

        # 3.2- 调用
        output = self.log_softmax(self.output_linear(output))
        print(f"3-->output-->{output.shape}")

        return output,hidden

    def init_hidden(self):
        return torch.zeros(size=(1,1,self.hidden_size)).to(device=device)

• 代码测试

# 测试解码器
def use_decoder():
    # 1- 准备数据
    dataloader = get_dataloader()

    # 2- 创建模型实例对象
    my_encoder = Encoder(eng_vocab_size=english_word_cnt,input_size=256,hidden_size=256).to(device=device)
    my_decoder = Decoder(fra_vocab_size=franch_word_cnt,hidden_size=256).to(device=device)

    # 3- 前向传播
    for x,y in dataloader:
        # x：一条英语句子，[[词索引1, 词索引2,... ]]
        # y：一条法语句子，[[词索引1, 词索引2,... ]]

        # 3.1- 调用编码器：让模型理解英语句子的完整含义
        h0 = my_encoder.init_hidden()
        encoder_output,hidden = my_encoder(x,h0)

        # 3.2- 调用解码器：每次送入一个词
        for index in range(y.shape[1]):
            # 3.3- 解码器前向传播
            fra_word = y[0][index].reshape(1,-1)
            decoder_output,hidden= my_decoder(fra_word, hidden)

            print(f"法语词词索引{fra_word}，隐藏状态信息{hidden.shape}")

        break

搭建解码器带Attention模型

• 流程

为什么这里的K来自【解码器上一个时间步隐藏状态】、Q来自【解码器上一个时间步预测结果】，与之前的又不一样？
答：
    1- 这是注意力的另外一种实现方式。该方式可以使用在文本翻译业务场景中
    2- Q、K的这种来源与前面【注意力计算规则】中不一样。但是这种形式可以计算得到注意力。这种机制的核心思想是：在生成当前词时，模型不仅要看“我上一步想到什么”（解码器状态），还要看“我现在要处理什么输入”（当前输入词），然后综合这两者去决定“我该关注编码器的哪个部分”。
    3- 这种设计在Seq2Seq机器翻译模型中非常经典，能同时考虑解码器状态和当前输入词的语义。

• 代码实现

# 8- 解码器：有注意力机制
class AttenDecoder(nn.Module):
    def __init__(self,fra_vocab_size,hidden_size):
        # 1- 初始化父类
        super().__init__()

        # 2- 设置属性值
        self.fra_vocab_size = fra_vocab_size
        self.hidden_size = hidden_size      # 有两个作用：1- 词向量维度；2- 隐藏状态向量维度

        # 3- 搭建网络结构
        # 3.1- 词嵌入层
        self.embedding = nn.Embedding(num_embeddings=self.fra_vocab_size,embedding_dim=self.hidden_size)

        # 3.2- Dropout随机失活层
        self.dropout = nn.Dropout(p=0.2)

        # 3.3- 线性层：用来计算QK的相似性
        self.attn = nn.Linear(in_features=self.hidden_size+self.hidden_size,out_features=MAX_LENGTH)

        # 3.4- 线性层：对Q和C拼接后的张量形状进行调整
        self.attn_combine = nn.Linear(in_features=self.hidden_size+self.hidden_size,out_features=self.hidden_size)

        # 3.5- GRU循环网络层
        self.gru = nn.GRU(input_size=self.hidden_size,hidden_size=self.hidden_size,num_layers=1,batch_first=True)

        # 3.6- 输出层
        self.out = nn.Linear(in_features=self.hidden_size,out_features=self.fra_vocab_size)

        # 激活函数
        self.log_softmax = nn.LogSoftmax(dim=-1)

    def forward(self, input, prev_hidden, encoder_outputs):
        """
        :param input: 解码器本次输入数据，也就是Q。张量形状 [batch_size,seq_len]，每次只传一个词进来
        :param prev_hidden: 解码器上一个时间步的隐藏状态，也就是K。张量形状 [num_layers,batch_size,hidden_size]
        :param encoder_outputs: 编码器端所有时间步隐藏状态的拼接，也就是V，而且还做了句子长度规范的处理。张量形状 [batch_size,MAX_LENGTH,hidden_size]
        :return:
        """

        # 1- 调用词嵌入层
        embedded = self.dropout(self.embedding(input))

        # 2- 计算注意力机制
        # 2.1- Q和K拼接
        # embedded就是Q
        # 如果不进行张量形状调整，那么就是num_layers与batch_size进行拼接，业务层面是不合理。
        # 调整K的形状 由 [num_layers,batch_size,hidden_size] -> [batch_size,num_layers,hidden_size]
        K = prev_hidden.transpose(dim0=0,dim1=1)
        # 拼接
        qk_cat = torch.cat(tensors=(embedded,K), dim=-1)

        # 2.2- 通过线性层算QK的相似性
        score = self.attn(qk_cat)

        # 2.3- 相似性转成权重
        attn_weights = torch.softmax(score, dim=-1)

        # 2.4- 得到专属信息包C：权重矩阵和V进行矩阵乘法运算
        # C对应原理图中的attn_applied
        C = torch.bmm(attn_weights, encoder_outputs)

        # 2.5- Q和C拼接
        qc_cat = torch.cat(tensors=(embedded,C),dim=-1)

        # 2.6- 通过线性层调整QC拼接后的张量
        qc_output = torch.relu(self.attn_combine(qc_cat))

        # 3- 调用GRU
        output,hidden = self.gru(qc_output,prev_hidden)

        # 4- 调用输出层
        output = output[:,0,:]
        output = self.log_softmax(self.out(output))

        return output,hidden,attn_weights

    def init_hidden(self):
        return torch.zeros(size=(1,1,self.hidden_size)).to(device=device)

模型训练

• 基本过程

整体流程：
    1. 获取数据集加载器对象
    2. 模型初始化
    3. 优化器初始化
    4. 损失函数初始化. 使用 NLLLoss() 负数对数似然损失
    5. 训练参数初始化
    6. 循环训练
        6.1 外层循环, 控制训练轮数
        6.2 内层循环, 遍历数据集的每个样本(即: 每轮具体的训练过程)
            具体训练过程看下面的步骤
        6.3 打印训练日志 (每1000个样本打印一次)
        6.4 记录损失用于绘图(每100个样本记录一次)
    7. 保存模型
    8. 训练结束后, 绘制损失曲线
    9. 训练结束, 返回结果

------------------------------------------------

具体训练过程（针对单条样本）：
    1. 编码阶段, 将输入的序列转换为上下文向量
    2. 解码参数准备
        2.1 构建编码器的输出张量, 用于注意力计算, 形状为: [10, 256]
        2.2 解码器初始化隐藏状态
        2.3 解码器的初始输入
    3. 初始化损失值
    4. 根据概率值决定是否用 Teacher forcing
        4.1 teacher forcing模型: 使用真实标签作为下一步的输入
        4.2 非Teacherforcing模型: 使用上一时间步的预测结果作为下一步的输入
    5. 反向传播 和 参数更新
    6. 返回平均损失

• 代码实现

# 9.2- 整体训练过程
def train():
    # 1- 准备数据
    dataloader = get_dataloader()

    # 2- 创建类的实例对象
    # 2.1- 模型实例对象
    my_encoder = Encoder(eng_vocab_size=english_word_cnt,input_size=256,hidden_size=256).to(device=device)
    my_decoder = AttenDecoder(fra_vocab_size=franch_word_cnt,hidden_size=256).to(device=device)
    # 2.2- 优化器实例对象：与具体的实例对象有关，因此要创建单独的两个
    encoder_adam = torch.optim.Adam(params=my_encoder.parameters(),lr=1e-4)
    decoder_adam = torch.optim.Adam(params=my_decoder.parameters(),lr=1e-4)
    # 2.3- 损失函数对象：与具体的实例对象无关，内部只是通过预测和真实值计算差值而已，因此只需要创建一个
    loss = nn.NLLLoss()

    # 3- 设置模式
    my_encoder.train()
    my_decoder.train()

    # 4- 模型训练
    epochs = 1

    avg_loss_list = []  # 用来存储平均损失

    for epoch in range(epochs):
        total_loss_value = 0.0  # 总损失值

        for i,(x_train,y_train) in enumerate(tqdm(dataloader), start=1):
            # 1- 单次训练得到损失值
            loss_value = train_iter(x_train,y_train,my_encoder,my_decoder,encoder_adam,decoder_adam,loss)

            # 2- 更新统计指标
            total_loss_value += loss_value

            # 3- 每隔100个批次记录并且输出一次信息
            if i%100==0:
                # 计算平均损失值
                avg_loss = total_loss_value / i

                avg_loss_list.append(avg_loss)
                print(f"第{epoch+1}轮次，平均损失{avg_loss}")

    # 5- 保存训练好的模型
    torch.save(my_encoder.state_dict(), "model/encoder.pkl")
    torch.save(my_decoder.state_dict(), "model/decoder.pkl")

    # 6- 绘制损失值变化曲线
    plt.plot(avg_loss_list)
    plt.show()

• 模型训练内部迭代函数代码实现

# 9.1- 单次训练过程
def train_iter(x,y,my_encoder,my_decoder,encoder_adam,decoder_adam,loss):
    """
    单次样本数据的训练过程
    :param x: 英语句子，张量形状[batch_size,seq_len]
    :param y: 法语句子，张量形状[batch_size,seq_len]
    :param my_encoder: 编码器对象
    :param my_decoder: 解码器对象
    :param encoder_adam: 编码器的优化器
    :param decoder_adam: 解码器的优化器
    :param loss: 损失函数对象
    :return: 平均损失值
    """

    # 1- 调用编码器
    encoder_hidden = my_encoder.init_hidden()
    encoder_output,encoder_hidden = my_encoder(x,encoder_hidden)

    # 2- 调用解码器之前的准备工作
    # 2.1- 句子长度规范化处理，同时也是合并得到V
    # 初始化一个形状[1,10,256]的全0张量
    V = torch.zeros(size=(1,MAX_LENGTH,256), device=device)
    copy_seq_len = min(MAX_LENGTH, x.shape[1])
    V[:, :copy_seq_len, :] = encoder_output[:, :copy_seq_len, :]

    # 2.2- 准备变量
    # 将编码器端最后一个时间步的隐藏状态作为 初始隐藏状态 给到解码器使用
    decoder_hidden = encoder_hidden
    # 损失值
    loss_value = 0.0
    # 获得法语句子中词的个数
    y_seq_len = y.shape[1]
    # 存储法语翻译结果，而且上个时间步的预测结果会作为本次输入数据使用，这称之为自回归
    input_y = torch.tensor([[SOS_TOKEN]], device=device)
    # 教师机制的标识。True：使用教师机制，也就是告诉下个时间步【真实】的法语词内容。反之，把【预测】结果给到下个时间步
    teacher_forcing_flag = True if random.random()<0.5 else False

    # 3- 调用解码器
    if teacher_forcing_flag:
        # 使用教师机制，也就是告诉下个时间步【真实】的法语词内容
        for i in range(y_seq_len):
            # 3.1- 前向传播
            pred_output,decoder_hidden,attn_weights = my_decoder(input=input_y, prev_hidden=decoder_hidden, encoder_outputs=V)

            # 3.2- 计算损失值
            # print(f"y-->{y.shape}")
            # print(f"y[0]-->{y[0].shape}")
            # print(f"y[0][i]-->{y[0][i]}")

            y_true = y[0][i].reshape(1)

            # print(f"y_true-->{y_true.shape}")

            loss_value += loss(pred_output,y_true)

            # 3.3- 告诉下个时间步【真实】的法语词内容
            input_y = y[0][i].reshape(1,-1) # [batch_size,seq_len]

    else:
        # 普通训练机制，把【预测】结果给到下个时间步
        for i in range(y_seq_len):
            # 3.1- 前向传播
            pred_output, decoder_hidden, attn_weights = my_decoder(input=input_y, prev_hidden=decoder_hidden,
                                                                   encoder_outputs=V)

            # 3.2- 计算损失值
            y_true = y[0][i].reshape(1)
            loss_value += loss(pred_output, y_true)

            # 3.3- 获得预测结果的词索引
            pred_word_index = torch.argmax(pred_output, dim=-1)

            # 3.4- 判断是否到了句子的结尾
            if pred_word_index == EOS_TOKEN:
                break

            # 3.5- 告诉下个时间步【预测】的法语词内容
            input_y = pred_word_index.reshape(1, -1)  # [batch_size,seq_len]

    # 4- 反向传播固定代码
    encoder_adam.zero_grad()
    decoder_adam.zero_grad()

    loss_value.sum().backward()

    encoder_adam.step()
    decoder_adam.step()

    return loss_value.item() / y_seq_len

模型预测

• 基本过程

1.获取数据
2.数据预处理
3.实例化模型: 编码器和解码器
4.加载模型训练好的参数: model.load_state_dict(torch.load("model_path"))
5.with torch.no_grad():
6.将数据送入模型进行预测（注意:张量的形状变换）

• 调用模型预测代码

# 10.2- 完整的预测流程
def use_seq2seq_evaluate():
    # 1- 手动准备未知数据
    my_samplepairs = [
        ['i m impressed with your french .', 'je suis impressionne par votre francais .'],
        ['i m more than a friend .', 'je suis plus qu une amie .'],
        ['she is beautiful like her mother .', 'elle est belle comme sa mere .']
    ]

    # 2- 加载训练好的模型
    my_encoder = Encoder(eng_vocab_size=english_word_cnt,input_size=256,hidden_size=256).to(device=device)
    my_encoder.load_state_dict(torch.load("model/encoder.pkl"))

    my_decoder = AttenDecoder(fra_vocab_size=franch_word_cnt,hidden_size=256).to(device=device)
    my_decoder.load_state_dict(torch.load("model/decoder.pkl"))

    # 3- 设置模式
    my_encoder.eval()
    my_decoder.eval()

    # 4- 预测
    for i,pair in enumerate(my_samplepairs):
        x = pair[0] # 英语句子
        y = pair[1] # 英语句子

        # 4.1- 英语句子转成张量
        x_list = [english_word2index[word] for word in x.split(" ")]
        # 所有的张量数据必须放在同一个硬件设备上，要么同时在GPU，要么同时在CPU
        x_tensor = torch.tensor(x_list, dtype=torch.long, device=device).reshape(1,-1)

        # 4.2- 对单条句子进行评估
        franch_word_list = seq2seq_evaluate(x_tensor,my_encoder,my_decoder)

        # 4.3- 输出结果
        print(f"英语句子 {x}，真实法语句子 {y}，翻译法语句子 {' '.join(franch_word_list)}")

• 预测的核心代码

# 10.1- 单条句子的翻译
def seq2seq_evaluate(x_tensor,my_encoder,my_decoder):
    """
    单条句子的翻译
    :param x_tensor: 一条处理后的英语句子，形状[batch_size,seq_len]
    :param my_encoder: 编码器
    :param my_decoder: 解码器
    :return: 翻译的法语词列表
    """

    with torch.no_grad():
        # 1- 调用编码器
        encoder_output,encoder_hidden = my_encoder(x_tensor,my_encoder.init_hidden())

        # 2- 调用解码器之前的准备工作
        # 2.1- 句子长度规范化处理，同时也是合并得到V
        # 初始化一个形状[1,10,256]的全0张量
        V = torch.zeros(size=(1,MAX_LENGTH,256), device=device)
        copy_seq_len = min(MAX_LENGTH, x_tensor.shape[1])
        V[:, :copy_seq_len, :] = encoder_output[:, :copy_seq_len, :]

        # 2.2- 准备变量
        # 将编码器端最后一个时间步的隐藏状态作为 初始隐藏状态 给到解码器使用
        decoder_hidden = encoder_hidden
        # 存储单次的法语翻译结果，而且上个时间步的预测结果会作为本次输入数据使用，这称之为自回归
        input_y = torch.tensor([[SOS_TOKEN]], device=device)
        # 存储所有的翻译法语词
        franch_word_list = []

        # 3- 评估/预测
        for i in range(MAX_LENGTH):
            # 3.1- 前向传播：调用解码器
            decoder_output,decoder_hidden,attn_weights = my_decoder(input=input_y, prev_hidden=decoder_hidden, encoder_outputs=V)

            # 3.2- 获得预测概率最高的那个词的词索引
            pred_fra_index = torch.argmax(decoder_output, dim=-1).item()

            # 3.3- 判断是否遇到了句子的结束标识
            if pred_fra_index == EOS_TOKEN:
                franch_word_list.append("EOS")
                break
            else:
                # 通过索引获得法语词的内容
                fra_word = franch_index2word[pred_fra_index]
                franch_word_list.append(fra_word)

            input_y = torch.tensor([[pred_fra_index]], device=device)

    return franch_word_list

第四章 Transformer模型

背景介绍【了解】

模型被提出时间

2017年提出，2018年google发表了BERT模型，使得Transformer架构流行起来，BERT在许多NLP任务上，取得了Soat的成就。

论文地址：https://arxiv.org/pdf/1706.03762

模型优势

1、能够实现并行计算，提高模型训练效率
2、更好的特征提取能力

思想间的关系：

Seq2Seq
Seq2Seq+注意力机制
Transformer
2017 《attention is all you need》
2018 Bert
2022 ChatGPT、T5

绝大多数大模型底层的原理都是Transformer

Transformer模型架构

整体架构【掌握】

组成部分：

1、输入部分
2、编码器部分
3、解码器部分
4、输出部分

架构概述：

总结流程：
输入文字 -> 嵌入 -> 位置编码 -> 编码器多层加工(注意力+前馈) -> 解码器多层加工(掩码注意力 + 关联编码器 + 前馈) -> 线性层 -> softmax -> 输出概率选词

整个架构的核心：
注意力机制抓关联，多层堆叠挖深度，残差归一化稳训练

输入部分

Positional Encoding：位置编码
作用：给词向量加'位置信息'
例如：Transformer本身不明白词的顺序，例如：我打你、你打我，所以得额外给每个词向量添加位置信息，告诉模型谁前谁后


Input Embedding：解码器端词嵌入层
作用：把输入的词转成词向量
例如：'你好'->[0.1，-0.3...]

输出部分

Softmax：激活层
作用：把线性层输出的数值转成概率，概率总和为1，模型就知道该选哪个词输出


Linear：线性层
作用：把解码器输出的向量，调整成'vocab size词汇表大小'维度，
例如：例如词汇表有1W个词，就把向量变成1W维，每个维度对应1个词的概率分数

编码器部分

Nx：重复堆叠
作用：把上面的'多头注意力 + Add&Norm + 前馈网络'重复N次(论文里是6次)
例如：一层不够深，多堆几层，让模型'层层递进'理解文本，从表面语义 ->深层逻辑


Feed Forward：前馈网络
作用：对每个位置的词向量"单独强化特征’
例如：经过注意力层后，再用全连接网络加工一下，给每个词'注入更多细节'，例如：'强化'猫的动物属性，追’的动作属性


Add & Norm：残差连接 + 层归一化
作用：让训练更稳，更高效。层归一化也称之为规范化层
例如：Add是把注意力层的输入和输出加一起，防止信息丢太多。Norm是把数据归一化(数值限制在某个范围)，避免训练时跑偏，梯度消失/爆炸


Multi-Head Attention：多头自注意力层
作用：让模型同时从多个角度关注句子里的词
例如：猫追老鼠'，既要关注'猫"和'追'的关系，也要关注'猫'和'老鼠'的关系，还能对比'猫' 和'老鼠'的关联.

解码器部分

Add & Norm + Feed Forward + Nx：
作用：和编码器里的逻辑一样，
     残差连接、归一化保证训练稳定；
     前馈网络强化特征；
     Nx重复堆叠加深模型


Multi-Head Attention：多头注意力层
作用：让解码器'关注编码器输出的内容'
例如：翻译时，解码器生成法语词，盯着处理后的英文词义，确保翻译准确，找对应关系


Masked Multi-Head Attention：掩码多头自注意力层
作用：防止'偷看未来的词'
例如：解码器是一步步生成输出的，只能用'已生成的词'，不能用未生成的词.

代码开发思路【了解】

重点组件

只需要搞清楚如下几个组件的功能、作用和代码开发

具体开发步骤

• 编码器

• 解码器

参考编码器的开发过程，大部分地方的功能直接复用。主要是开发【掩码多头自注意力层】

• 输出部分

非常简单，nn.Linear全连接层+Softmax激活函数

• 代码的作用和开发顺序

输入部分

词嵌入层

注意：为什么embedding之后要乘以根号下d_model
- 原因1：为了防止position encoding的信息覆盖我们的word embedding，也就是防止两者的值差距过大。所以进行一个数值增大
- 原因2：符合正态分布

• 代码实现

# 词嵌入层
class Embedding(nn.Module):
    def __init__(self,vocab_size,d_model):
        # 1- 初始化父类
        super().__init__()

        # 2- 设置属性值
        self.vocab_size = vocab_size    # 词汇表大小
        self.d_model = d_model          # 向量维度。本次这里表示 词向量维度

        # 3- 搭建网络结构
        self.ebd = nn.Embedding(num_embeddings=self.vocab_size,embedding_dim=self.d_model)

    def forward(self,input):
        """
            为什么要乘以根号d_model，也就是根号dk？
            答：为了对词向量中的数据进行放大。避免与位置编码的数据进张量加法运算以后，词向量的值过小导致占比少
            但是位置编码和词向量编码的数据地位应该是一样的，不应该出现谁重要而谁不重要的情况
            对应论文的内容：In the embedding layers, we multiply those weights by √dmodel.

            什么情况下词向量中会出现比较小的值？
            答：当d_model很大的时候
        """
        return self.ebd(input) * math.sqrt(self.d_model)

• 测试代码

# 测试词嵌入层
def use_embedding():
    # 1- 创建实例对象
    embedding = Embedding(vocab_size=1000,d_model=5)
    # embedding = Embedding(vocab_size=1000,d_model=10240)

    # 2- 准备数据
    # 一个批次中有2条句子，每条句子有3个词
    x = torch.tensor([
        [100, 3, 99],
        [888, 777, 5]
    ])

    # 3- 调用得到词向量
    text_tensor = embedding(x)
    print(f"文本张量的形状：{text_tensor.shape}")
    print(f"文本张量的内容：{text_tensor}")
    print(f"文本张量中绝对值的最小值：{text_tensor.abs().min()}")

位置编码

作用

Transformer编码器或解码器中缺乏位置信息，因此加入位置编码器，将词汇的位置可能代表的不同特征信息和word_embedding进行融合，以此来弥补位置信息的缺失。

位置编码器实现方式：三角函数来实现的，sin、cos函数

为什么使用三角函数来进行位置编码

1、保证同一词汇随着所在位置不同它对应位置嵌入向量会发生变化
2、正弦波和余弦波的值域范围都是1到-1这又很好的控制了嵌入数值的大小, 有助于梯度的快速计算

• 代码实现

class PositionalEncoding(nn.Module):
    def __init__(self,dropout_p,max_len,d_model):
        # 1- 初始化父类
        super().__init__()

        # 2- 设置属性值
        self.dropout_p = dropout_p  # 随机失活概率
        self.max_len = max_len      # 句子规范化处理的长度上限
        self.d_model = d_model      # 词向量维度

        # 3- 创建随机失活层
        self.dropout = nn.Dropout(p=self.dropout_p)

        # 4- 定义位置编码的计算规则：也就是实现公式
        # 4.1- 初始化pe：目前的形状是[60,5]
        pe = torch.zeros(size=(self.max_len,self.d_model))
        # 4.2- 得到pos的取值区间：arange是左闭右开的区间
        pos = torch.arange(start=0,end=max_len,step=1).unsqueeze(dim=-1) # 张量形状[60,1]
        # 4.3- 得到1/分母
        div_term = 1/(10000**(torch.arange(start=0,end=d_model,step=2).float()/self.d_model))
        # 4.4- 得到正弦和余弦里面的内容
        value = pos * div_term
        # 4.5- 分别计算：2i->正弦；2i+1->余弦
        pe[:, 0::2] = torch.sin(value)
        pe[:, 1::2] = torch.cos(value)

        # 4.6- 将pe升维为三维：也就是 [60,5]->[1,60,5]
        pe = pe.unsqueeze(dim=0)

        # 4.7- 将pe注册到缓存中，通过它来不断的更新计算得到每个词的位置编码信息，后面可以直接使用pe
        self.register_buffer("pe",pe)

    def forward(self,embed):
        """
        位置编码需要根据词向量来计算；然后再实现位置编码 加上 词向量
        :param embed: 词向量
        :return:
        """

        """
            为什么要对pe进行切片操作？
            答：因为传进来的embed中词的个数不一定够max_len的长度。举例如下：
            embeb中有10个词，词向量维度是5，句子的条数有2条，那么embed的形状[2,10,5]
            对应pe的形状[2,60,5]。它们两个的形状不相同，因此不能进行加法运算，所以需要
            将pe的形状进行切片操作，也就是将有意义的前10个词的位置编码信息取出来
        """
        seq_len = embed.shape[1]
        result = embed + self.pe[:, :seq_len, :]

        print(f"1--embed的内容-->{embed}")
        print(f"2--pe的内容-->{self.pe[:, :seq_len, :]}")
        return self.dropout(result)

• 测试代码

def use_positional_encoding():
    # 注意：词向量维度只能是偶数，这个与位置编码中i的取值区间有关

    # 1- 创建实例对象
    embedding = Embedding(vocab_size=1000, d_model=512)

    # 2- 准备数据
    # 一个批次中有2条句子，每条句子有3个词
    x = torch.tensor([
        [100, 3, 99, 666],
        [888, 777, 5, 555]
    ])

    # 3- 调用得到词向量
    text_tensor = embedding(x)

    # 4- 调用位置编码
    # 4.1- 创建类的实例对象
    pe_obj = PositionalEncoding(dropout_p=0.2,max_len=60,d_model=512)
    # 4.2- 调用
    pe_and_ebd = pe_obj(text_tensor)

    print(f"最终的形状：{pe_and_ebd.shape}")
    print(f"最终的内容：{pe_and_ebd}")

    return pe_and_ebd

# 可视化位置编码
def plot_position():
    # 1. 实例化位置编码器.
    my_position = PositionalEncoding(dropout_p=0, max_len=100, d_model=20)

    # 2. 生成全0的输入, 观察位置编码的模式.
    # (1, 100, 20) -> 批次大小, 句子长度, 词嵌入维度
    embed = torch.zeros(1, 100, 20)
    y = my_position(embed)

    # 3. 设置图表大小.
    plt.figure(figsize=(20, 15))
    # 绘制位置编码第4到第7列, 100个词的  [4, 5, 6, 7]
    """
        图形的信息解释：
            x轴：词的索引，目前总共有100个词
            y轴：位置编码值
    """
    plt.plot(np.arange(100), y[0, :, 4:8].detach().numpy())
    plt.legend([f'dim {p}' for p in [4, 5, 6, 7]])
    plt.show()

编码器部分

掩码张量

作用

掩码：掩就是遮掩、码就是张量。掩码本身需要一个掩码张量，掩码张量的作用是对另一个张量进行数据信息的掩盖。一般掩码张量是由0和1两种数字组成，至于是0对应位置或是1对应位置进行掩码，可以自己设定

• PyTorch版本

# 使用PyTorch实现掩码。【掌握】
"""
    总结：
        1- 上三角掩码：右上角的值为1，左下角的值为0
        2- 下三角掩码：右上角的值为0，左下角的值为1
        3- 相同的规律：对角线的时候diagonal为0；如果是正数，并且越来越大，那么往右上角移动；反之往左下角移动；diagonal的取值超过范围不会报错
        4- 【掌握】掩码的作用：为了防止解码器端当前时间步偷看后面时间步的数据，你只能看到你前面时间步已经预测出来的数据。核心是防止模型训练效果不好
        5- 【掌握】代码：torch.triu(t,diagonal=0)
"""

import torch
def torch_mask():
    # 创建初始张量
    t = torch.ones(size=(5,5))
    print(f"原始张量：{t}")

    # 进行掩码操作
    # 上三角掩码
    u_0_mask = torch.triu(t,diagonal=0)
    print(f"上三角掩码0：{u_0_mask}")

    u_1_mask = torch.triu(t, diagonal=1)
    print(f"上三角掩码1：{u_1_mask}")

    u__1_mask = torch.triu(t, diagonal=-1)
    print(f"上三角掩码_1：{u__1_mask}")

    u_n_mask = torch.triu(t, diagonal=1000)
    print(f"上三角掩码n：{u_n_mask}")

    print("-"*30)

    # 下三角掩码
    l_0_mask = torch.tril(t, diagonal=0)
    print(f"下三角掩码0：{l_0_mask}")

    l_1_mask = torch.tril(t, diagonal=1)
    print(f"下三角掩码1：{l_1_mask}")

    l__1_mask = torch.tril(t, diagonal=-1)
    print(f"下三角掩码-1：{l__1_mask}")

• numpy版本

import numpy as np
def np_mask():
    # 1- 准备数据
    arr = np.ones(shape=(5,5))

    # 2- 上三角掩码
    # k和PyTorch中diagonal参数的作用完全一样
    u_result = np.triu(arr,k=0)
    print(f"上三角掩码0：\n{u_result}")

    u_result = np.triu(arr, k=1)
    print(f"上三角掩码1：\n{u_result}")

    u_result = np.triu(arr, k=-1)
    print(f"上三角掩码-1：\n{u_result}")

    # 3- 下三角掩码
    l_result = 1 - u_result
    print(f"下三角掩码：\n{l_result}")

    l_result = np.tril(arr,k=0)
    print(f"下三角掩码0：\n{l_result}")

    l_result = np.tril(arr, k=1)
    print(f"下三角掩码1：\n{l_result}")

    l_result = np.tril(arr, k=-1)
    print(f"下三角掩码-1：\n{l_result}")

• 掩码张量的可视化

# 掩码张量的可视化.
def dm03_test_mask():
    # 简单说(总结): 纵向选'当前位置', 横向看'能看哪些位置', 0(黄色): 遮挡, 1(紫色): 不遮挡
    plt.figure(figsize=(5, 5))
    plt.imshow(demo2(20)[0])
    plt.show()

注意力机制【掌握】

计算规则

自注意力机制，规则：Q乘以K的转置，然后除以根号下d_k，然后再进行Softmax，最后和V进行张量矩阵相乘
如果是自注意力，那么Q、K、V的值完全相同

注意力计算

扩展知识：点积和点乘

点积：等同于矩阵乘法，可以使用matmul函数进行计算，也可以使用dot函数进行计算。在注意力机制场景下，一般使用matmul

点乘：两个张量的形状要完全一样。对应坐标位置元素相乘

• 代码实现

import copy
import math

import torch
from torch import Tensor
import torch.nn as nn
from demo01_input import *

# 根据注意力计算公式算注意力
def attention(query:Tensor,key:Tensor,value:Tensor,mask=None,dropout=None):
    """
    注意力计算方法
    该方法能够实现如下3种注意力的计算:
    1- 编码器端 多头自注意力：query=key=value，mask=None。编码器端大多数不需要掩码
    2- 解码器端 掩码多头自注意力：query=key=value，mask不为空的时候
    3- 解码器端 掩码多头注意力（交叉注意力）：query和key、value不相等，mask=None
    :param query: 查询张量，形状：[batch_size每个批次中有多少条句子,seq_len句子中词的个数,d_model向量维度]
    :param key: 键张量，形状：[batch_size,seq_len,d_model]
    :param value: 值张量，形状：[batch_size,seq_len,d_model]
    :param mask: 掩码张量，形状：[batch_size,seq_len,seq_len]，使用过程中会自动进行广播机制
    :param dropout: 随机失活层对象
    :return:
    """

    # 1- 获得dk，也就是d_model，也就是向量维度
    dk = query.shape[-1]

    # 2- Q和K的转置进行矩阵乘法运算，再除以根号下dk。得到了相似性得分
    # 注意：key.transpose需要交换的是张量中最后两个形状的位置，不要从左往右正着数索引，要倒着来
    scores = torch.matmul(query, key.transpose(dim0=-1,dim1=-2)) / math.sqrt(dk)

    # 3- 使用掩码
    if mask is not None:
        # 为什么要使用-1e9次方对掩码的地方进行填充呢？因为为了让后面计算softmax权重值的时候，掩码地方的权重被计算为0
        scores = scores.masked_fill(mask==1, value=-1e9)

    # 4- 将相似性得分转成权重矩阵
    weighted = torch.softmax(scores, dim=-1)

    # 5- 【可选】随机失活
    if dropout is not None:
        weighted = dropout(weighted)

    # 6- 权重矩阵和V进行矩阵乘法，得到专属信息包C
    C = torch.matmul(weighted,value)

    return C,weighted

• 测试代码

# 注意力计算测试
def use_attention():
    # 1- 输入数据，得到经过词嵌入层和位置编码以后的数据
    pe_ebd = use_positional_encoding()

    dropout = nn.Dropout(p=0.2)

    # 2- 测试：编码器端 多头自注意力机制
    query=key=value=pe_ebd
    C,weighted = attention(query,key,value,dropout=dropout)
    print(f"编码器端 多头自注意力机制C：{C.shape}")
    print(f"编码器端 多头自注意力机制weighted：{weighted.shape}")
    print(f"编码器端 多头自注意力机制weighted：{weighted.sum()}")


    # 3- 测试：解码器端 掩码多头自注意力机制
    mask = torch.triu(torch.ones(size=(2,4,4)), diagonal=1)
    query=key=value=pe_ebd
    C,weighted = attention(query,key,value,mask=mask,dropout=dropout)
    print(f"解码器端 多头自注意力机制C：{C.shape}")
    print(f"解码器端 多头自注意力机制weighted：{weighted.shape}")
    print(f"解码器端 多头自注意力机制weighted：{weighted.sum()}")

多头注意力机制【掌握】

概念

多头的好处：
    1- 能够让模型进行并行计算，提高运行效率
    2- 多个头来同时处理数据，那么模型对数据的理解、学习会更好，模型整体效果会更好

• 多头注意力机制原理图

• 代码实现

def clones(module_obj, cnt):
    """
    创建指定个数的实例对象，对象之间是深拷贝的关系
    :param module_obj: 需要拷贝的对象
    :param cnt: 拷贝的个数
    :return:
    """
    # 语法格式  nn.ModuleList([copy.deepcopy(拷贝对象) for _ in range(拷贝个数)])
    return nn.ModuleList([copy.deepcopy(module_obj) for _ in range(cnt)])

# 多头注意力
class MultiHeadAttention(nn.Module):
    def __init__(self,d_model,head,dropout_p=0.1):
        # 1- 确保张量维度能够被头数整除
        assert d_model%head==0

        # 2- 初始化父类
        super().__init__()

        # 3- 设置属性值
        self.d_model = d_model  # 向量维度
        self.head = head        # 多头的头数
        self.head_dim = d_model // head # 每个头要各自处理的向量维度。例如：512//8=64
        self.dropout = nn.Dropout(p=dropout_p)
        self.weighted = None    # 权重矩阵

        # 4- 创建线性网络结构
        """
            创建的4个线性层的作用：
                第1个线性层：分头行动前，专门用来处理query数据
                第2个线性层：分头行动前，专门用来处理key数据
                第3个线性层：分头行动前，专门用来处理value数据
                第4个线性层：分头行动后，对多个头拼接后的张量数据进行线性调整，对形状、元素值进行调整，避免出现异常值，让模型训练更加稳定
        """
        self.linear_list = clones(nn.Linear(in_features=d_model,out_features=d_model), 4)

    def forward(self,query,key,value,mask:Tensor=None):
        """
        先分头，然后再调用注意力计算方法
        :param query: 查询张量，形状：[batch_size每个批次中有多少条句子,seq_len句子中词的个数,d_model向量维度]
        :param key: 键张量，形状：[batch_size,seq_len,d_model]
        :param value: 值张量，形状：[batch_size,seq_len,d_model]
        :param mask: 掩码张量，形状：[head,seq_len,seq_len]。注意第一个维度代表的是头数，使用过程中会自动进行广播机制
        :return:
        """

        # 1- 掩码升维处理：[batch_size,seq_len,seq_len] -> [1,batch_size,seq_len,seq_len]
        # 添加的形状虽然是1，但是内部可以自动进行广播机制
        if mask is not None:
            mask.unsqueeze_(dim=0)

        # 2- 获得batch_size的值
        batch_size = query.shape[0]

        # 3- 前3个线性层分别用来处理query、key、value
        # 方式一：分开版的写法
        # 格式[(第1个线性层, query), (第2个线性层, key), (第3个线性层, value)]
        # model_and_data_pair = list(zip(self.linear_list, (query,key,value)))
        # transpose_output_list = []
        # for model,data in model_and_data_pair:
        #     # 线性层对对应的数据进行处理
        #     model_output = model(data)
        #
        #     # 调整形状：先分头，然后交换位置
        #     # [2,4,512] -> [2,4,8,64] -> [2,8,4,64]
        #     transpose_output = model_output.reshape(batch_size,-1,self.head,self.head_dim).transpose(1,2)
        #     transpose_output_list.append(transpose_output)
        #
        # new_query, new_key, new_value = transpose_output_list

        # 方式二：合并版的写法
        new_query, new_key, new_value = [
            model(data).reshape(batch_size,-1,self.head,self.head_dim).transpose(1,2)
            for model,data in list(zip(self.linear_list, (query,key,value)))
        ]

        # 4- 多个头分别计算注意力
        C,weighted = attention(new_query, new_key, new_value, mask, dropout=self.dropout)
        self.weighted = weighted

        # 5- 对多个计算后的结果进行”拼接“，实际也就是要将张量的形状重新调整回[2,4,512]
        # [2,8,4,64] -> [2,4,8,64] -> [2,4,512]
        result = C.transpose(1,2).reshape(batch_size,-1,self.head*self.head_dim)

        # 6- 使用最后一个线性层对多头拼接后的数据进行调整
        return self.linear_list[-1](result)

• 测试代码

def use_multi_head_attention():
    # 1- 调用词嵌入层和位置编码的数据
    pe_ebd = use_positional_encoding()

    multi_head_atten = MultiHeadAttention(d_model=512,head=8)

    # 2- 测试：编码器端 多头自注意力机制
    query=key=value=pe_ebd
    encoder_result = multi_head_atten(query,key,value)
    print(f"编码器端 多头自注意力机制：{encoder_result.shape}")

    # 3- 测试：解码器端 掩码多头自注意力机制
    query = key = value = pe_ebd
    mask = torch.triu(torch.ones(size=(8,4,4)), diagonal=1)
    decoder_result = multi_head_atten(query, key, value, mask)
    print(f"解码器端 掩码多头自注意力机制：{decoder_result.shape}")

前馈网络

概念：前馈网络用来增强模型的拟合能力，内部包含两个全连接层

• 代码实现

# 前馈网络
class FeedForward(nn.Module):
    def __init__(self,d_model,enlarge_dim,dropout_p=0.1):
        # 1- 初始化父类
        super().__init__()

        # 2- 设置属性值
        self.d_model = d_model  # 输入和输出的向量维度
        self.enlarge_dim = enlarge_dim    # 放大的向量维度
        self.dropout_p = dropout_p    # 随机失活概率

        # 3- 搭建网络结构
        # 3.1- 第1层线性层：用来将输入的向量放大。例如：512->1024
        self.linear_1 = nn.Linear(in_features=self.d_model,out_features=self.enlarge_dim)

        # 3.2- Dropout随机失活层
        self.dropout = nn.Dropout(p=self.dropout_p)

        # 3.3- 第2层线性层：用来将放大后的向量进行浓缩变小。例如：1024->512
        self.linear_2 = nn.Linear(in_features=self.enlarge_dim,out_features=self.d_model)

    def forward(self,data):
        """
        不管传进来的是什么数据，只关心将数据先放大再缩小
        :param data:
        :return:
        """
        """
            为什么使用ReLU激活函数？
            答：
                1- 不是必须要使用ReLU，可以使用其他的
                2- 原始的Transformer论文中用的是ReLU，因为正半轴的导数值固定为1，计算公式简单效率高
        """
        return self.linear_2(self.dropout(torch.relu(self.linear_1(data))))

层归一化

作用

随着网络深度的增加，模型参数会出现过大或过小的情况，进而可能影响模型的收敛，因此进行规范化，将参数规范致某个特征范围内，辅助模型快速收敛。

代码实现

# 层归一化/规范化层：数据经过多层的处理以后，会出现异常值，可能会导致梯度消失或梯度爆炸。
# 因此通过层归一化的处理，将数据调整到正态（高斯）分布的情况，让模型训练稳定
class LayerNorm(nn.Module):
    def __init__(self,d_model):
        # 1- 初始化父类
        super().__init__()

        # 2- 设置属性值
        self.d_model = d_model  # 向量维度

        # 3- 定义线性回归公式y=kx+b中的k和b
        """
            1- 为什么k和b的个数与向量维度d_model相同？
            答：d_model表示的是向量维度，而向量维度中每个元素代表一个特征值，而每列特征有自己的权重，因此个数要相同

            2- 为什么要用nn.Parameter()包起来？
            答：
                2.1- 如果不用nn.Parameter()包起来，那么变量的值永远不会发生变化
                2.2- 如果用nn.Parameter()包起来，会受到optimizer.step()代码的更新，值会受到反向传播的调整
        """
        self.k = nn.Parameter(torch.ones(self.d_model))
        self.b = nn.Parameter(torch.zeros(self.d_model))

        # 4- 定义小常数：为了防止分母为0
        self.eps = 1e-6

    def forward(self,data:Tensor):
        """
        不关心传进来的data数据来自哪里，只负责对数据进行标准化处理
        :param data:
        :return:
        """
        # 1- 计算均值
        """
            参数解释：
                dim=-1：对最后一个维度进行计算
                keepdim=True：计算后的张量维度数不变。例如：之前是3维，那么计算后也是3维，举例：[2,4,512] -> [2,4,1]
        """
        mean = data.mean(dim=-1,keepdim=True)

        # 2- 计算标准差
        std = data.std(dim=-1,keepdim=True)

        # 3- 对数据进行标准化处理：也就是实现 y=k((x-mean)/std)+b
        """
            为什么要自己实现线性回归的过程，而不使用nn.Linear来实现？
            答：因为我们是对每个批次的数据进行单独的线性回归的处理，然后每个批次数据的权重k和偏置b是不相同的
            这块内容的依据：https://arxiv.org/pdf/1607.06450论文的【3 Layer normalization】
        """
        return self.k * ((data-mean)/(std+self.eps)) + self.b

子层连接结构

• 代码实现

# 子层连接对象
"""
    覆盖的组合有如下这些：
        编码器端
            多头自注意力子层
                sublayer_obj多头注意力类的实例对象 + 残差连接 + 层归一化
            前馈网络子层
                sublayer_obj前馈网络类的实例对象 + 残差连接 + 层归一化

        解码器端
            掩码多头自注意力子层
                sublayer_obj多头注意力类的实例对象 + 残差连接 + 层归一化
            多头注意力子层
                sublayer_obj多头注意力类的实例对象 + 残差连接 + 层归一化
            前馈网络子层
                sublayer_obj前馈网络类的实例对象 + 残差连接 + 层归一化
"""
class SublayerConnection(nn.Module):
    def __init__(self,d_model,dropout_p=0.2):
        # 1- 初始化父类
        super().__init__()

        # 2- 设置属性值
        self.d_model = d_model
        self.dropout_p = dropout_p

        # 3- 创建层归一化对象
        """
            为什么要创建层归一化对象？
            答：因为每个子层都需要有层归一化对象
        """
        self.layer_norm = LayerNorm(d_model=self.d_model)

        # 4- 创建随机失活层
        self.dropout = nn.Dropout(p=self.dropout_p)

    def forward(self, data, sublayer):
        """
        :param data: 子层需要处理的数据
        :param sublayer: 子层中具体的处理对象的前向传播，例如：多头注意力类的实例对象、前馈网络类的实例对象
        :return:
        """

        # 写法一：Transformer原版论文中的写法， 子组件处理 -> 随机失活层 -> 残差连接 -> 层归一化
        """
            子组件处理：sublayer_obj(data)，底层自动调用我们自己写的forward前向传播方法
            随机失活层：self.dropout(sublayer_obj(data))
            残差连接：+ data
            层归一化：self.layer_norm
        """
        # result = self.layer_norm(self.dropout(sublayer_obj(data)) + data)

        # 写法二：推荐。目前主流大模型中的写法， 层归一化 -> 子组件处理 -> 随机失活层 -> 残差连接
        """
            层归一化：self.layer_norm(data)
            子组件处理：sublayer_obj(self.layer_norm(data))，底层自动调用我们自己写的forward前向传播方法
            随机失活层：self.dropout
            残差连接：+ data

            为什么目前主流大模型将层归一化放在了最前面？
            答：放在最前面是为了将之前处理得到的数据调整到符合正态分布的情况，避免出现异常值，让模型训练稳定
        """
        result = self.dropout(sublayer(self.layer_norm(data))) + data

        return result

• 子层测试代码

# 测试子层连接对象
def use_SublayerConnection():
    # 1- 数据首先经过词嵌入层和位置编码的处理
    data = use_positional_encoding()
    d_model = 512
    # 2- 多头注意力子层测试
    # 2.1- 创建子组件类的实例对象，并且调用forward前向传播方法。也就是创建sublayer_obj
    # 方式一：使用自定义函数的方式实现
    def sublayer_forward_fn(input_data):
        # 创建子组件类的实例对象
        atten_obj = MultiHeadAttention(d_model,head=8)
        # 调用forward前向传播方法
        return atten_obj(query=input_data,key=input_data,value=input_data)

    # 2.2- 创建SublayerConnection类的实例对象
    sublayerConnection = SublayerConnection(d_model)

    # 2.3- 调用SublayerConnection中的前向传播方法
    # 注意：只能传递方法名称，不能带小括号
    atten_result = sublayerConnection(data, sublayer_forward_fn)
    print(f"演示 编码器端 多头自注意力子层：{atten_result.shape}")

    # 3- 前馈网络子层测试
    # 3.1- 创建SublayerConnection类的实例对象
    sublayerConnection = SublayerConnection(d_model)

    # 3.2- 调用SublayerConnection中的前向传播方法
    # 方式二：使用lambda表达式的方式实现
    ff_result = sublayerConnection(atten_result, lambda input_data:FeedForward(d_model,enlarge_dim=1024)(data=input_data))
    print(f"演示 编码器端 前馈网站子层：{ff_result.shape}")

编码器层

作用

每个编码器层完成一次对输入的特征提取过程, 即编码过程.

代码实现

"""
    编码器 由 6层编码器层 组成，就是隐藏层有6层，它们的关系是串行的关系
        每个编码器层由如下的2个子层组成
            多头自注意力子层：多头自注意力 + 残差连接 + 层归一化
            前馈网络子层：前馈网络 + 残差连接 + 层归一化
"""

from demo02_component import *

class EncoderLayer(nn.Module):
    def __init__(self,d_model,dropout_p,feed_forward_obj, multi_head_self_atten_obj):
        # 1- 初始化父类
        super().__init__()

        # 2- 设置属性值
        self.d_model = d_model
        self.dropout_p = dropout_p
        self.feed_forward_obj = feed_forward_obj                    # FeedForward类的实例对象
        self.multi_head_self_atten_obj = multi_head_self_atten_obj  # MultiHeadAttention类的实例对象

        # 3- 创建 多头自注意力子层：多头自注意力 + 残差连接 + 层归一化
        self.multi_head_self_atten_sublayer = SublayerConnection(d_model=self.d_model, dropout_p=self.dropout_p)

        # 4- 创建 前馈网络子层：前馈网络 + 残差连接 + 层归一化
        self.feed_forward_sublayer = SublayerConnection(d_model=self.d_model, dropout_p=self.dropout_p)

    def forward(self, data):

        # 1- 先调用 多头自注意力子层
        atten_result = self.multi_head_self_atten_sublayer(
            data,
            lambda input_data: self.multi_head_self_atten_obj(query=input_data,key=input_data,value=input_data)
        )

        # 2- 再调用 前馈网络子层
        ff_result = self.feed_forward_sublayer(
            atten_result,
            lambda input_data: self.feed_forward_obj(data=input_data)
        )

        return ff_result

编码器

• 代码实现

class Encoder(nn.Module):
    def __init__(self,encoder_layer_obj,N=6):
        # 1- 初始化父类
        super().__init__()

        # 2- 设置属性值
        self.encoder_layer_obj = encoder_layer_obj  # EncoderLayer类的实例对象
        self.N = N  # 编码器层堆叠N层，默认是6

        # 3- 创建N个编码器层
        self.encoder_layer_list = clones(self.encoder_layer_obj, self.N)

        # 4- 【可选】创建层归一化：防止前面的网络层处理以后出现异常值
        self.layer_norm = LayerNorm(d_model=encoder_layer_obj.d_model)

    def forward(self,data):

        # 1- 依次也就是串行调用6层编码器层
        for layer_obj in self.encoder_layer_list:
            # 注意：处理前后的数据变量名称【必须】保持一致，如果不一致，那么6层编码器层只有最后一层才有价值
            data = layer_obj(data)

        # 2- 调用层归一化
        result = self.layer_norm(data)

        return result

• 编码器完整测试代码

# 测试编码器
def use_encoder():
    # 1- 调用词嵌入层和位置编码
    pe_ebd = use_positional_encoding()

    d_model = 512
    dropout_p = 0.1

    # 2- 创建编码器实例对象
    # 2.1- 创建 多头自注意力 实例对象
    atten_obj = MultiHeadAttention(d_model=d_model,head=8,dropout_p=dropout_p)
    # 2.2- 创建 前馈网络 实例对象
    ff_obj = FeedForward(d_model=d_model,enlarge_dim=1024,dropout_p=dropout_p)
    # 2.3- 创建 编码器层 实例对象
    encoder_layer_obj = EncoderLayer(d_model=d_model,dropout_p=dropout_p,feed_forward_obj=ff_obj,multi_head_self_atten_obj=atten_obj)
    # 2.4- 创建 编码器 实例对象
    encoder_obj = Encoder(encoder_layer_obj=encoder_layer_obj, N=6)

    # 3- 调用编码器的前向传播
    result = encoder_obj(data=pe_ebd)

    print(f"编码器处理后的结果：{result.shape}")

    return result

解码器部分

解码器层

作用

作为解码器的组成单元, 每个解码器层根据给定的输入向目标方向进行特征提取操作

代码实现

"""
    解码器 由 6层解码器层 组成。6层解码器层之间是串行的关系

    解码器层由如下3个子层组成
        掩码多头自注意力子层：掩码多头自注意力mask_multi_head_self_atten_obj + 残差连接 + 层归一化
        多头注意力子层（交叉注意力子层）：多头注意力multi_head_atten_obj + 残差连接 + 层归一化
        前馈网络子层：前馈网络feed_forward_obj + 残差连接 + 层归一化
"""

from demo03_encoder import *

# 解码器层
class DecoderLayer(nn.Module):
    def __init__(self,d_model, dropout_p, mask_multi_head_self_atten_obj, multi_head_atten_obj, feed_forward_obj):
        # 1- 初始化父类
        super().__init__()

        # 2- 设置属性值
        self.d_model = d_model
        self.dropout_p = dropout_p
        self.mask_multi_head_self_atten_obj = mask_multi_head_self_atten_obj    # MultiHeadAttention类的实例对象，掩码多头自注意力
        self.multi_head_atten_obj = multi_head_atten_obj                        # MultiHeadAttention类的实例对象，多头注意力
        self.feed_forward_obj = feed_forward_obj                                # FeedForward类的实例对象

        # 3- 创建 掩码多头自注意力子层：多头自注意力 + 残差连接 + 层归一化
        self.mask_multi_head_self_atten_sublayer = SublayerConnection(d_model=self.d_model, dropout_p=self.dropout_p)

        # 4- 创建 多头注意力子层（交叉注意力子层）：多头注意力multi_head_atten_obj + 残差连接 + 层归一化
        self.multi_head_atten_sublayer = SublayerConnection(d_model=self.d_model, dropout_p=self.dropout_p)

        # 5- 创建 前馈网络子层：前馈网络 + 残差连接 + 层归一化
        self.feed_forward_sublayer = SublayerConnection(d_model=self.d_model, dropout_p=self.dropout_p)

    def forward(self, data, mask, encoder_output):
        """
        :param data: 经过Decoder解码器中词嵌入和位置编码处理后的数据
        :param mask: 掩码张量，形状[head, seq_len, seq_len]
        :param encoder_output: 编码器（也就是由6层编码器层组成）最终的输出结果
        :return:
        """

        # 1- 先调用 掩码多头自注意力子层
        mask_atten_result = self.mask_multi_head_self_atten_sublayer(
            data,
            lambda input_data: self.mask_multi_head_self_atten_obj(query=input_data,key=input_data,value=input_data,mask=mask)
        )

        # 2- 再调用 多头注意力子层
        atten_result = self.multi_head_atten_sublayer(
            mask_atten_result,
            lambda input_data: self.multi_head_atten_obj(query=input_data, key=encoder_output, value=encoder_output)
        )

        # 3- 最后调用 前馈网络子层
        ff_result = self.feed_forward_sublayer(
            atten_result,
            lambda input_data: self.feed_forward_obj(data=input_data)
        )

        return ff_result

解码器

作用

根据编码器的结果以及上一次预测的结果, 对下一次可能出现的'值'进行特征表示

• 代码实现

# 解码器
class Decoder(nn.Module):
    def __init__(self,decoder_layer_obj,N=6):
        # 1- 初始化父类
        super().__init__()

        # 2- 设置属性值
        self.decoder_layer_obj = decoder_layer_obj  # DecoderLayer类的实例对象
        self.N = N  # 解码器层堆叠N层，默认是6

        # 3- 创建N个解码器层
        self.decoder_layer_list = clones(self.decoder_layer_obj, self.N)

        # 4- 【可选】创建层归一化：防止前面的网络层处理以后出现异常值
        self.layer_norm = LayerNorm(d_model=decoder_layer_obj.d_model)

    def forward(self,data):

        # 1- 依次也就是串行调用6层解码器层
        for layer_obj in self.decoder_layer_list:
            # 注意：处理前后的数据变量名称【必须】保持一致，如果不一致，那么6层解码器层只有最后一层才有价值
            data = layer_obj(data)

        # 2- 调用层归一化
        result = self.layer_norm(data)

        return result

• 解码器完整测试代码

def use_decoder():
    # 1- 调用编码器
    encoder_output = use_encoder()

    d_model = 512
    dropout_p = 0.1

    # 2- 准备解码器端的数据，例如：英译法中法语句子
    # 当前批次中有2条法语句子，每条法语句子中有5个法语词
    y = torch.tensor([
        [1,2,3,4,9],
        [5,6,7,8,9]
    ])

    # 3- 创建解码器端各个类的实例对象
    # 3.1- 词嵌入层
    embed = Embedding(vocab_size=1200,d_model=d_model)
    # 3.2- 位置编码
    pe = PositionalEncoding(dropout_p=dropout_p,max_len=60,d_model=d_model)
    # 3.3- 掩码多头自注意力
    mask_self_atten = MultiHeadAttention(d_model=d_model,head=8,dropout_p=dropout_p)
    # 3.4- 多头注意力
    atten = MultiHeadAttention(d_model=d_model,head=8,dropout_p=dropout_p)
    # 3.5- 前馈网络
    feedforward = FeedForward(d_model=d_model,enlarge_dim=1024,dropout_p=dropout_p)

    # 3.6- 组装得到解码器层
    decoer_layer = DecoderLayer(
        d_model=d_model,
        dropout_p=dropout_p,
        mask_multi_head_self_atten_obj=mask_self_atten,
        multi_head_atten_obj=atten,
        feed_forward_obj=feedforward
    )

    # 3.7- 解码器层堆叠6层得到解码器
    decoder = Decoder(decoder_layer_obj=decoer_layer, N=6)

    # 4- 调用解码器的前向传播
    # 4.1- 准备数据
    # 解码器端的数据 经过词嵌入层、位置编码的处理
    pe_ebd = pe(embed(y))
    # 掩码张量
    mask = torch.triu(torch.ones(size=(8,5,5)), diagonal=1)

    # 4.2- 前向传播
    decoder_result = decoder(pe_ebd,mask,encoder_output)

    print(f"解码器最终输出结果：{decoder_result.shape}")

输出部分

作用：通过线性变化得到指定维度的输出

• 代码实现

"""
    Transformer的输出部分：
        Linear线性层和Softmax激活函数
"""
import torch
import torch.nn as nn

class Output(nn.Module):
    def __init__(self,d_model,vocab_size):
        # 1- 初始化父类
        super().__init__()

        # 2- 搭建神经网络结构
        self.linear = nn.Linear(in_features=d_model,out_features=vocab_size)

    def forward(self,data):
        """
        :param data: 解码器最终的输出结果，形状[batch_size,seq_len,d_model]
        :return:
        """

        return torch.softmax(self.linear(data),dim=-1)

模型搭建

• 自定义的Transformer模型搭建代码

import torch

from demo04_decoder import *
from demo05_output import *

class MyTransformer(nn.Module):
    def __init__(self, encoder_ebd_pos, encoder, decoder_ebd_pos, decoder, output):
        # 1- 初始化父类
        super().__init__()

        # 2- 设置属性值
        self.encoder_ebd_pos = encoder_ebd_pos
        self.encoder = encoder
        self.decoder_ebd_pos = decoder_ebd_pos
        self.decoder = decoder
        self.output = output

    def forward(self, encoder_input, decoder_input, mask):
        # 1- 编码器端_输入部分：encoder_ebd_pos
        encoder_data = self.encoder_ebd_pos(encoder_input)
        # 2- 编码器：encoder
        encoder_data = self.encoder(encoder_data)

        # 3- 解码器端_输入部分：decoder_ebd_pos
        decoder_data = self.decoder_ebd_pos(decoder_input)
        # 4- 解码器：decoder
        decoder_data = self.decoder(data=decoder_data, mask=mask, encoder_output=encoder_data)

        # 5- 输出部分：output
        return self.output(decoder_data)

• 调用Transformer模型框架

# 调用Transformer框架
def get_mytransformer():
    # 基础变量
    d_model = 512
    dropout_p = 0.1
    encoder_vocab_size = 1000   # 编码器端的词汇表大小
    decoder_vocab_size = 4345   # 解码器端的词汇表大小

    # 1------------------------------ 编码器 ------------------------------
    # 1.1- 词嵌入层 实例对象
    encoder_ebd = Embedding(vocab_size=encoder_vocab_size,d_model=d_model)
    # 1.2- 位置编码 实例对象
    encoder_pe = PositionalEncoding(dropout_p=dropout_p,max_len=60,d_model=d_model)
    # 1.3- 多头自注意力机制 实例对象
    encoder_multi_head_self_atten = MultiHeadAttention(d_model=d_model,head=8,dropout_p=dropout_p)
    # 1.4- 前馈网络 实例对象
    encoder_ff = FeedForward(d_model=d_model,enlarge_dim=1024,dropout_p=dropout_p)
    # 1.5- 编码器层 实例对象
    encoder_layer = EncoderLayer(
        d_model=d_model,
        dropout_p=dropout_p,
        feed_forward_obj=encoder_ff,
        multi_head_self_atten_obj=encoder_multi_head_self_atten
    )
    # 1.6- 编码器 实例对象
    encoder = Encoder(encoder_layer_obj=encoder_layer, N=6)

    # 2------------------------------ 解码器 ------------------------------
    # 2.1- 词嵌入层 实例对象
    decoder_ebd = Embedding(vocab_size=decoder_vocab_size,d_model=d_model)
    # 2.2- 位置编码 实例对象
    decoder_pe = PositionalEncoding(dropout_p=dropout_p,max_len=60,d_model=d_model)
    # 2.3- 掩码多头自注意力机制 实例对象
    decoder_mask_multi_head_self_atten = MultiHeadAttention(d_model=d_model,head=8,dropout_p=dropout_p)
    # 2.4- 多头注意力机制 实例对象
    decoder_multi_head_atten = MultiHeadAttention(d_model=d_model,head=8,dropout_p=dropout_p)
    # 2.5- 前馈网络 实例对象
    decoder_ff = FeedForward(d_model=d_model,enlarge_dim=1024,dropout_p=dropout_p)
    # 2.6- 解码器层 实例对象
    decoder_layer = DecoderLayer(
        d_model=d_model,
        dropout_p=dropout_p,
        mask_multi_head_self_atten_obj=decoder_mask_multi_head_self_atten,
        multi_head_atten_obj=decoder_multi_head_atten,
        feed_forward_obj=decoder_ff
    )
    # 2.7- 解码器 实例对象
    decoder = Decoder(decoder_layer_obj=decoder_layer, N=6)

    # 3------------------------------ 输出端 ------------------------------
    output = Output(d_model=d_model,vocab_size=decoder_vocab_size)

    # 4--------------------------- Transformer ---------------------------
    """
        nn.Sequential：按顺序执行。可以将多个实例对象，而且这些实例对象之间如果有串行执行的关系，才能够放进去
        另外，这里你可以不使用nn.Sequential，可以拆解为多个变量传进去
    """
    my_transformer = MyTransformer(
        encoder_ebd_pos=nn.Sequential(encoder_ebd, encoder_pe),
        encoder=encoder,
        decoder_ebd_pos=nn.Sequential(decoder_ebd, decoder_pe),
        decoder=decoder,
        output=output
    )

    return my_transformer

• 测试Transformer模型架构

# 测试Transformer模型架构
def use_my_transformer():
    # 1- 创建MyTransformer
    my_transformer = get_mytransformer()
    print("模型内部结构：",my_transformer)

    # 2- 准备数据
    # 2.1- 编码器端数据
    x = torch.tensor([
        [11, 22, 33, 44],
        [1, 2, 3, 4]
    ])

    # 2.2- 解码器端数据
    y = torch.tensor([
        [134,3546,2455,234],
        [435,2345,578,23]
    ])

    # 2.3- 掩码
    mask = torch.triu(torch.ones(size=(8,4,4)), diagonal=1)

    # 3- 调用前向传播
    result = my_transformer(encoder_input=x, decoder_input=y, mask=mask)
    print(f"Transformer最终结果：{result.shape}")
    print(f"Transformer最终结果：{result.sum()}")