深入解析ChatGPT公式：从原理到工程实践

1次阅读

共计 3162 个字符，预计需要花费 8 分钟才能阅读完成。

ChatGPT 作为当前最先进的对话生成模型之一，其核心技术基于 Transformer 架构。从 GPT- 1 到 GPT-3，再到如今的 ChatGPT，模型的规模和能力呈指数级增长。这一技术演进不仅推动了自然语言处理领域的进步，也在各行各业产生了深远影响，从客服机器人到内容创作，ChatGPT 类模型正在改变我们与机器交互的方式。

Transformer 是 ChatGPT 的基础架构，其核心思想是通过自注意力机制（Self-Attention）来捕捉输入序列中的长距离依赖关系。与传统的 RNN 或 LSTM 不同，Transformer 完全基于注意力机制，这使得它在处理长序列时表现更优。

自注意力机制的核心公式如下：

$$
\text{Attention}(Q, K, V) = \text{softmax}\left(\frac{QK^T}{\sqrt{d_k}}\right)V
$$

其中，Q（Query）、K（Key）、V（Value）分别代表查询、键和值矩阵，(d_k) 是键向量的维度。这个公式的作用是计算输入序列中每个位置与其他位置的关联程度，从而生成加权后的表示。

由于 Transformer 不包含递归或卷积结构，它需要通过位置编码（Positional Encoding）来引入序列的位置信息。位置编码的公式为：

$$
PE_{(pos, 2i)} = \sin\left(\frac{pos}{10000^{2i/d_{model}}}\right)
$$

$$
PE_{(pos, 2i+1)} = \cos\left(\frac{pos}{10000^{2i/d_{model}}}\right)
$$

其中，(pos) 是位置，(i) 是维度索引，(d_{model}) 是模型的维度。

import torch
import torch.nn as nn
import torch.nn.functional as F

class SelfAttention(nn.Module):
    def __init__(self, embed_size, heads):
        super(SelfAttention, self).__init__()
        self.embed_size = embed_size
        self.heads = heads
        self.head_dim = embed_size // heads

        assert self.head_dim * heads == embed_size, "Embed size needs to be divisible by heads"

        self.values = nn.Linear(self.head_dim, self.head_dim, bias=False)
        self.keys = nn.Linear(self.head_dim, self.head_dim, bias=False)
        self.queries = nn.Linear(self.head_dim, self.head_dim, bias=False)
        self.fc_out = nn.Linear(heads * self.head_dim, embed_size)

    def forward(self, values, keys, query, mask):
        N = query.shape[0]
        value_len, key_len, query_len = values.shape[1], keys.shape[1], query.shape[1]

        # Split the embedding into self.heads different pieces
        values = values.reshape(N, value_len, self.heads, self.head_dim)
        keys = keys.reshape(N, key_len, self.heads, self.head_dim)
        queries = query.reshape(N, query_len, self.heads, self.head_dim)

        values = self.values(values)
        keys = self.keys(keys)
        queries = self.queries(queries)

        energy = torch.einsum("nqhd,nkhd->nhqk", [queries, keys])
        if mask is not None:
            energy = energy.masked_fill(mask == 0, float("-1e20"))

        attention = F.softmax(energy / (self.embed_size ** (1/2)), dim=3)
        out = torch.einsum("nhql,nlhd->nqhd", [attention, values]).reshape(N, query_len, self.heads * self.head_dim)

        out = self.fc_out(out)
        return out

import math

def positional_encoding(max_len, d_model):
    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, d_model)
    pe[:, 0::2] = torch.sin(position * div_term)
    pe[:, 1::2] = torch.cos(position * div_term)
    return pe

在模型推理时，内存管理至关重要。以下是一些优化策略：