2023年的深度学习入门指南(5) – 动手写第一个言语模型

上一篇咱们介绍了openai的API，其实也便是给openai的API写前端。在其它各家的大模型跟gpt4还有代差的情况下，prompt工程是目前运用大模型的最好方法。

不过，许多编程身世的同学仍是关于prompt工程不以为然，以为编程完成才是王道。以为编程才干更好地理解原理，才干发掘出大模型的实在潜力。还有同学希望能用有限的算力希望挖掘出模型的潜力。

这当然不是坏事，缩放规律和现有模型的结构也并非是金科玉律，也还有不少不尽善尽美的地方，比如：

• 作为大模型根底单元的自注意力模型，复杂度是O(n2)O(n^2)O(n2)，是否有更好的结构？
• 这些单元之间，除了堆更多层之外，是否还有更有用的结构？
• 有什么方法能够优化大模型推理时所需的算力？
• 大模型的原理是个黑盒，有没有更白盒一些的方法，提升模型的可解释性？

这些问题构成咱们后边解说编程的主线：

• Transformer结构的根本单元是什么，怎么编程完成
• Transformer结构怎么优化
• 怎么用Transformer的编码器和解码器建立预练习模型
• 怎么经过剪枝、量化、蒸馏等方法让大模型的推理在小算力下跑起来
• 怎么用可解释的方法建立大模型

有了这些堆集之后，咱们再看一些干流的大模型是怎么完成的。

有志于用更少算力完成更多大模型才能的同学，咱们还得学习下相关加快器件的编程，比如GPGPU和XLA编程。

这还仅仅模型，还有数据。

咱们还要深化了解下目前大模型存在的幻觉问题，有毒有成见数据的研究成果。

最终，RLHF还触及强化学习的常识，咱们还得讲下强化学习，以及在Atari游戏和NLP中的用法。

上面编程的结束后，咱们再重新系统研究下prompt工程。

现在咱们回到故事的起点，从Transformer模型的根底：自注意力机制说起。

自注意力机制

这一部分值得有志于算法工作的同学好好学习下，由于这应该是算法同学面试必问的问题。不过，2017年的时分咱们由于用的经历少，所以只能照本宣科地讲《Attention Is All you need》中的内容。现在由于大模型的抢手，咱们对根底模块的研究也越来越深化了，没准儿你能够讲出点老一点的面试官也不知道的东西了。

注意力是咱们日常常用的词。人类的注意力便是从海量的信息中抓住要点。在人工神经网络中，为了模仿人类的机制，当时的词与其他每个词的联系，咱们都设置一个值，这就构成了算法中的注意力机制。

有了注意力机制之后，咱们经过练习，就能够让跟当时词相关的词的权重变高，而不相关的词的权重变低。

比如在机器翻译中，咱们能够经过注意力机制，让源言语与目标言语中相对应的词的注意力权重变高。常见的有加法注意力和乘法注意力等完成方法。

假如咱们不论与其他句子的注意力，只关注一句话或一段话中某个词与其他词之间的注意力联系，这被称为自注意力。

咱们看一个比如：

经过练习，咱们发现，句子中的making一词，跟后边的more和difficult之间的联系更紧密，所以它们之间的权重更高。

那么，怎么去完成句子中的自注意力呢？

为了减少核算量，咱们采用点积做为首要的算法，这种结构叫做缩放点积注意力模块：

如图所示，咱们把一个词变换成三种东西：Q, K, V. 其间Q代表Query查询，K代表Key键，它们先进行矩阵乘，然后进行缩放，再进行Softmask，所取得的结果再与V既Value之间再进行矩阵乘。

关于矩阵乘和Softmax不了解的同学不必急，我在后边会补充根底常识，咱们先理解自注意力模块的完成逻辑。

咱们用PyTorch能够这样写：

        # 核算注意力权重，运用缩放点积注意力
        A = torch.matmul(Q, K) / np.sqrt(self.head_dim) # (batch_size, num_heads, seq_len_q ,seq_len_k)
        A = torch.softmax(A ,dim=-1) # (batch_size,num_heads ,seq_len_q ,seq_len_k)
        # 核算注意力输出
        O = torch.matmul(A ,V) # (batch_size,num_heads ,seq_len_q ,head_dim)

咱们再用TensorFlow.js来看看怎么写：

    // 核算注意力分数
    const scores = tf.matMul(qHeads, kHeads, false, true).div(tf.sqrt(this.depth));
    // 运用softmax函数进行归一化
    const attentionWeights = tf.softmax(scores, -1);
    // 核算加权的Value向量
    const weightedValues = tf.matMul(attentionWeights, vHeads);

缩放点积注意力仅仅一个词对另一个词的注意力，要核算每一个词，咱们还得将其组合起来，变成一个更大的自注意力模块：多头自注意力模块。

所谓多头，便是有h个缩放点积注意力最终拼接在一起。

下面咱们用PyTorch来完成这个多头的拼接模块：

# 界说自注意力模型类
class SelfAttention(nn.Module):
    def __init__(self, input_dim, output_dim, num_heads):
        super(SelfAttention, self).__init__()
        # 参数检查
        assert output_dim % num_heads == 0, "output_dim must be divisible by num_heads"
        # 界说线性变换层
        self.W_q = nn.Linear(input_dim, output_dim)
        self.W_k = nn.Linear(input_dim, output_dim)
        self.W_v = nn.Linear(input_dim, output_dim)
        # 界说输出层
        self.W_o = nn.Linear(output_dim, output_dim)
        # 界说头数和头部维度
        self.num_heads = num_heads
        self.head_dim = output_dim // num_heads
    def forward(self, x):
        # x: (batch_size, seq_len, input_dim)
        # 核算Q,K,V
        Q = self.W_q(x) # (batch_size, seq_len, output_dim)
        K = self.W_k(x) # (batch_size, seq_len, output_dim)
        V = self.W_v(x) # (batch_size, seq_len, output_dim)
        # 将Q,K,V分割成多个头部
        Q = Q.view(Q.shape[0], Q.shape[1], self.num_heads, self.head_dim) # (batch_size, seq_len, num_heads, head_dim)
        K = K.view(K.shape[0], K.shape[1], self.num_heads, self.head_dim) # (batch_size, seq_len, num_heads, head_dim)
        V = V.view(V.shape[0], V.shape[1], self.num_heads, self.head_dim) # (batch_size, seq_len, num_heads, head_dim)
        # 调整维度次序，便于核算注意力权重
        Q = Q.permute(0, 2, 1, 3) # (batch_size, num_heads, seq_len, head_dim)
        K = K.permute(0, 2, 3, 1) # (batch_size, num_heads, head_dim, seq_len)
        V = V.permute(0, 2, 1, 3) # (batch_size, num_heads, seq_len, head_dim)
        # 核算注意力权重，运用缩放点积注意力
        A = torch.matmul(Q, K) / np.sqrt(self.head_dim) # (batch_size, num_heads, seq_len_q ,seq_len_k)
        A = torch.softmax(A ,dim=-1) # (batch_size,num_heads ,seq_len_q ,seq_len_k)
        # 核算注意力输出
        O = torch.matmul(A ,V) # (batch_size,num_heads ,seq_len_q ,head_dim)
        # 调整维度次序，便于拼接头部
        O = O.permute(0 ,2 ,1 ,3) # (batch_size ,seq_len_q ,num_heads ,head_dim)
        # 拼接头部，得到最终输出
        O = O.reshape(O.shape[0] ,O.shape[1] ,-1) # (batch_size ,seq_len_q ,output_dim)
        O = self.W_o(O) # (batch_size ,seq_len_q ,output_dim)
        return O

咱们能够写一段测试代码来跑一下：

# 测试代码
input_dim = 8
output_dim = 16
num_heads = 8
seq_len = 3
batch_size = 2
x = torch.randn(batch_size ,seq_len ,input_dim)
model = SelfAttention(input_dim ,output_dim ,num_heads)
y = model(x)
print(y.shape)

输出为：

torch.Size([2 ,3 ,16])

咱们再看看用TensorFlow.js怎么完成：

// 导入TensorFlow.js库
import * as tf from '@tensorflow/tfjs';
class SelfAttention {
  constructor(dModel, numHeads) {
    this.dModel = dModel;
    this.numHeads = numHeads;
    this.depth = dModel / numHeads;
    // 界说Q, K, V线性层的权重矩阵
    this.wq = tf.variable(tf.randomNormal([dModel, dModel]));
    this.wk = tf.variable(tf.randomNormal([dModel, dModel]));
    this.wv = tf.variable(tf.randomNormal([dModel, dModel]));
    // 界说输出线性层的权重矩阵
    this.wo = tf.variable(tf.randomNormal([dModel, dModel]));
  }
  // 自注意力核算进程
  async call(inputs) {
    const q = tf.matMul(inputs, this.wq);
    const k = tf.matMul(inputs, this.wk);
    const v = tf.matMul(inputs, this.wv);
    const batchSize = inputs.shape[0];
    const seqLen = inputs.shape[1];
    // 将Q, K, V分成多个头
    const qHeads = this.splitHeads(q, batchSize);
    const kHeads = this.splitHeads(k, batchSize);
    const vHeads = this.splitHeads(v, batchSize);
    // 核算注意力分数
    const scores = tf.matMul(qHeads, kHeads, false, true).div(tf.sqrt(this.depth));
    // 运用softmax函数进行归一化
    const attentionWeights = tf.softmax(scores, -1);
    // 核算加权的Value向量
    const weightedValues = tf.matMul(attentionWeights, vHeads);
    // 将多个头的输出重新组合
    const output = this.combineHeads(weightedValues, batchSize);
    // 运用输出线性层
    return tf.matMul(output, this.wo);
  }
  // 将张量分割为多个头
  splitHeads(tensor, batchSize) {
    return tensor.reshape([batchSize, -1, this.numHeads, this.depth]).transpose([0, 2, 1, 3]);
  }
  // 将多个头的输出重新组合
  combineHeads(tensor, batchSize) {
    return tensor.transpose([0, 2, 1, 3]).reshape([batchSize, -1, this.dModel]);
  }
}

来段调用让其跑起来：

// 运用示例
(async () => {
  const dModel = 64;
  const numHeads = 8;
  const inputShape = [1, 10, dModel]; // 假设输入序列有10个词，每个词的向量维度是64
  const inputs = tf.randomNormal(inputShape);
  const selfAttention = new SelfAttention(dModel, numHeads);
  const outputs = await selfAttention.call(inputs);
  outputs.print();
})();

Transformer

有了多头注意力模块，剩下便是搭积木的工作了，咱们看下面的图：

input上面是编码器，target上面的是解码器。能够两个一起用，也能够只用编码器或者只用解码器。

图中有一个新增的模块，便是方位嵌入层。由于自注意力机制只跟相关性有关，而跟方位远近无关。所以咱们需要一个别的的机制将方位信息编码进去。

关于偶数位，咱们运用sin函数来编码方位。关于奇数位，咱们采用cos函数来编码方位。 下面是用PyTorch的完成：

class PositionalEncoding(nn.Module):
    def __init__(self, d_model, dropout=0.1, max_len=5000):
        super(PositionalEncoding, self).__init__()
        self.dropout = nn.Dropout(p=dropout)
        position = torch.arange(max_len).unsqueeze(1)
        div_term = torch.exp(torch.arange(0, d_model, 2) * -(math.log(10000.0) / d_model))
        pe = torch.zeros(max_len, 1, d_model)
        pe[:, 0, 0::2] = torch.sin(position * div_term)
        pe[:, 0, 1::2] = torch.cos(position * div_term)
        self.register_buffer('pe', pe)
    def forward(self, x):
        x = x + self.pe[:x.size(0), :]
        return self.dropout(x)

咱们再来看下TensorFlow.js的完成：

class PositionalEncoding {
  constructor(dModel) {
    this.dModel = dModel;
  }
  call(x) {
    const pos = tf.range(0, x.shape[1]).reshape([-1, 1]);
    const divTerm = tf.range(0, this.dModel, 2).mul(-Math.log(10000) / this.dModel).exp();
    const pe = tf.zeros([x.shape[1], this.dModel]);
    const sinPos = tf.sin(pos.matMul(divTerm));
    const cosPos = tf.cos(pos.matMul(divTerm));
    const updatedPE = pe.bufferSync();
    for (let i = 0; i < pe.shape[1]; i += 2) {
      updatedPE.set(sinPos.dataSync()[Math.floor(i / 2)], 0, i);
      updatedPE.set(cosPos.dataSync()[Math.floor(i / 2)], 0, i + 1);
    }
    return x.add(updatedPE.toTensor());
  }
}

PyTorch为咱们封装好了Transformer的编码器和解码器的模块，咱们构成多层编码器和解码器组成的Transformers模型，就用封装好的模块就能够了，不需要再像上面相同自己手艺写了.

其间，编码器是nn.TransformerEncoder，它能够由多层nn.TransformerEncoderLayer拼装成。 同样，解码器是nn.TransformerDecoder，能够由一层或多层nn.TransformerDecoderLayer组成。

咱们来看个比如：

import torch
import torch.nn as nn
class TransformerModel(nn.Module):
    def __init__(self, vocab_size, d_model, nhead, num_layers, dim_feedforward):
        super(TransformerModel, self).__init__()
        # 词嵌入层
        self.embedding = nn.Embedding(vocab_size, d_model)
        # 方位编码层
        self.pos_encoder = PositionalEncoding(d_model)
        # Transformer编码器层
        encoder_layer = nn.TransformerEncoderLayer(d_model, nhead, dim_feedforward)
        self.transformer_encoder = nn.TransformerEncoder(encoder_layer, num_layers)
        # Transformer解码器层
        decoder_layer = nn.TransformerDecoderLayer(d_model, nhead, dim_feedforward)
        self.transformer_decoder = nn.TransformerDecoder(decoder_layer, num_layers)
        # 输出层
        self.linear = nn.Linear(d_model, vocab_size)
    def forward(self, src, tgt, src_mask=None, tgt_mask=None, memory_mask=None):
        # 输入嵌入
        src = self.embedding(src)
        tgt = self.embedding(tgt)
        # 方位编码
        src = self.pos_encoder(src)
        tgt = self.pos_encoder(tgt)
        # 经过Transformer编码器
        memory = self.transformer_encoder(src, src_mask)
        # 经过Transformer解码器
        output = self.transformer_decoder(tgt, memory, tgt_mask, memory_mask)
        # 输出层
        output = self.linear(output)
        return output

Torch.nn.Transformer默许是包含了6层编码器和6层解码器的结构，其间输入是512维，头有8个

torch.nn.Transformer(d_model=512, nhead=8, num_encoder_layers=6, num_decoder_layers=6, dim_feedforward=2048, dropout=0.1, activation=<function relu>, custom_encoder=None, custom_decoder=None, layer_norm_eps=1e-05, batch_first=False, norm_first=False, device=None, dtype=None)

咱们再看下用TensorFlow.js来完成Transformer.

这次用咱们运用封装的tf.layers.multiHeadAttention来构建编码器：

class EncoderLayer {
  constructor(dModel, nhead, ffDim) {
    this.multiHeadAttention = tf.layers.multiHeadAttention({headSize: nhead, numHeads: dModel / nhead, outputDim: dModel});
    this.ffn = tf.sequential();
    this.ffn.add(tf.layers.dense({units: ffDim, activation: 'relu'}));
    this.ffn.add(tf.layers.dense({units: dModel}));
    this.norm1 = tf.layers.layerNormalization();
    this.norm2 = tf.layers.layerNormalization();
  }
  call(x) {
    const attention = this.multiHeadAttention.apply([x, x, x]);
    const norm1 = this.norm1.apply(x.add(attention));
    const ffn = this.ffn.apply(norm1);
    const norm2 = this.norm2.apply(norm1.add(ffn));
    return norm2;
  }
}

解码器要复杂一点，由于还要有编码器的输入：

class DecoderLayer {
  constructor(dModel, nhead, ffDim) {
    this.multiHeadAttention1 = tf.layers.multiHeadAttention({headSize: nhead, numHeads: dModel / nhead, outputDim: dModel});
    this.multiHeadAttention2 = tf.layers.multiHeadAttention({headSize: nhead, numHeads: dModel / nhead, outputDim: dModel});
    this.ffn = tf.sequential();
    this.ffn.add(tf.layers.dense({units: ffDim, activation: 'relu'}));
    this.ffn.add(tf.layers.dense({units: dModel}));
    this.norm1 = tf.layers.layerNormalization();
    this.norm2 = tf.layers.layerNormalization();
    this.norm3 = tf.layers.layerNormalization();
  }
  call(inputs) {
    const [x, encOutput] = inputs;
    const attention1 = this.multiHeadAttention1.apply([x, x, x]);
    const norm1 = this.norm1.apply(x.add(attention1));
    const attention2 = this.multiHeadAttention2.apply([norm1, encOutput, encOutput]);
    const norm2 = this.norm2.apply(norm1.add(attention2));
    const ffn = this.ffn.apply(norm2);
    const norm3 = this.norm3.apply(norm2.add(ffn));
    return norm3;
  }
}

最终，咱们把方位嵌入、编码器、解码器都整合在一起：

class TransformerModel {
  constructor(vocabSize, dModel, nhead, numLayers, ffDim) {
    this.embedding = tf.layers.embedding({inputDim: vocabSize, outputDim: dModel});
    this.posEncoder = new PositionalEncoding(dModel);
    this.encoderLayer = new Array(numLayers).fill(null).map(() => new EncoderLayer(dModel, nhead, ffDim));
    this.decoderLayer = new Array(numLayers).fill(null).map(() => new DecoderLayer(dModel, nhead, ffDim));
    this.finalLayer = tf.layers.dense({units: vocabSize});
  }
  async call(src, tgt) {
    const srcEmbedding = this.embedding.apply(src);
    const tgtEmbedding = this.embedding.apply(tgt);
    const srcPos = this.posEncoder.call(srcEmbedding);
    const tgtPos = this.posEncoder.call(tgtEmbedding);
    let encOutput = srcPos;
    this.encoderLayer.forEach(layer => {
      encOutput = layer.call(encOutput);
    });
    let decOutput = tgtPos;
    this.decoderLayer.forEach(layer => {
      decOutput = layer.call([decOutput, encOutput]);
    });
    const finalOutput = this.finalLayer.apply(decOutput);
    return finalOutput;
  }
}

咱们的第一个言语模型

下面咱们来一个实在的用Transformer来学习wiki文本，然后依据学习的言语模型让它来生成胡言乱语的句子的比如。

咱们运用PyTorch官方的比如，由于它为咱们预备好了数据和脚本。blog也没有稿费，咱们不水这么多代码了。 下载方法：

git clone https://github.com/pytorch/examples

然后进入word_language_model目录，运行下面的指令：

python main.py --cuda --epochs 6 --model Transformer --lr 5

假如你没有GPU，就把–cuda去掉。

学习的数据在word_language_model\data\wikitext-2目录下面，练习数据都是从wiki里面提取的，开始是战场女武神3游戏的词条。

练习好之后，咱们就能够使用咱们刚才练习的言语模型因由AI生成句子啦。

指令为：

python .\generate.py --cuda --outf g2.txt

打开g2.txt，咱们就能看到咱们自己的小言语模型的作用啦。 我来几句话：

to every year was stabilized . From ( 1964 , it had undergone a viable against criminal @-@ architectural scholar
as Main Online , which was moved into Webster were contacted ;

跟现在尽管经常胡言乱语的gpt4比较，咱们的小小言语模型还处于人话都说不明白的阶段。

尽管十分十分小，但是咱们用的思想、原理和技能，跟gpt4是相同的。 咱们堆许多许多的文本，练习很大参数的模型，咱们也相同能够做成跟某些厂商水平差不多的大模型来。不过就算比gpt4的参数还多，文本用的还好，跟chatgpt仍是比不了的。还有好多的其他常识咱们需要学习的。

现在咱们回来看看这个能生成根本上词还算是正确的言语模型的源码，咱们先看它的方位嵌入层的：github.com/pytorch/exa…

class PositionalEncoding(nn.Module):
    def __init__(self, d_model, dropout=0.1, max_len=5000):
        super(PositionalEncoding, self).__init__()
        self.dropout = nn.Dropout(p=dropout)
        pe = torch.zeros(max_len, d_model)
        position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1)
        div_term = torch.exp(torch.arange(0, d_model, 2).float() * (-math.log(10000.0) / d_model))
        pe[:, 0::2] = torch.sin(position * div_term)
        pe[:, 1::2] = torch.cos(position * div_term)
        pe = pe.unsqueeze(0).transpose(0, 1)
        self.register_buffer('pe', pe)
    def forward(self, x):
        x = x + self.pe[:x.size(0), :]
        return self.dropout(x)

咱们看看是不是跟我上面写的根本相同？那就对了，我就根本上照这个抄的 ：）

咱们再看下它的TransformerModel的代码，我把mask部分删掉了，咱们看下是不是它就只用了TransformerEncoder，解码器用的是全衔接网络：

class TransformerModel(nn.Module):
    def __init__(self, ntoken, ninp, nhead, nhid, nlayers, dropout=0.5):
        super(TransformerModel, self).__init__()
        self.model_type = 'Transformer'
        self.src_mask = None
        self.pos_encoder = PositionalEncoding(ninp, dropout)
        encoder_layers = TransformerEncoderLayer(ninp, nhead, nhid, dropout)
        self.transformer_encoder = TransformerEncoder(encoder_layers, nlayers)
        self.encoder = nn.Embedding(ntoken, ninp)
        self.ninp = ninp
        self.decoder = nn.Linear(ninp, ntoken)
        self.init_weights()
    def init_weights(self):
        initrange = 0.1
        nn.init.uniform_(self.encoder.weight, -initrange, initrange)
        nn.init.zeros_(self.decoder.bias)
        nn.init.uniform_(self.decoder.weight, -initrange, initrange)
    def forward(self, src, has_mask=True):
        src = self.encoder(src) * math.sqrt(self.ninp)
        src = self.pos_encoder(src)
        output = self.transformer_encoder(src, self.src_mask)
        output = self.decoder(output)
        return F.log_softmax(output, dim=-1)

咱们最终再学习下调用言语模型生成文本的代码，这部分会了咱们就掌握了推理的才能：

with open(args.checkpoint, 'rb') as f:
    model = torch.load(f, map_location=device)
model.eval()
corpus = data.Corpus(args.data)
ntokens = len(corpus.dictionary)
input = torch.randint(ntokens, (1, 1), dtype=torch.long).to(device)
with open(args.outf, 'w') as outf:
    with torch.no_grad():  # no tracking history
        for i in range(args.words):
            output = model(input, False)
            word_weights = output[-1].squeeze().div(args.temperature).exp().cpu()
            word_idx = torch.multinomial(word_weights, 1)[0]
            word_tensor = torch.Tensor([[word_idx]]).long().to(device)
            input = torch.cat([input, word_tensor], 0)
            word = corpus.dictionary.idx2word[word_idx]
            outf.write(word + ('\n' if i % 20 == 19 else ' '))
            if i % args.log_interval == 0:
                print('| Generated {}/{} words'.format(i, args.words))

根本原理便是依据当时情况下的最大概率值来生成文本。

改进Transformer

刚刚入门就讲Transformer的变体实在是有点烧脑，但是咱们要知道，Transformer并不只要这一种方法，尽管干流编程库就支撑上面的这一种。

咱们从下面的图能够看到，Transformer这么根本的模块，研究者们动了各种脑筋试图去优化它。

小结

不论大规模预练习模型有多大，其根本原理跟咱们本节所学的言语模型是相同的。咱们都是堆Transformer，然后根据很多的文本进行练习，然后用练习好的言语模型进行生成。