2023年的深度学习入门指南(25) - 通义千问7b
最近发生的两件事情都比较有意思，一个是连续开源了7b和13b模型的百川，对其53b闭源了；另一个是闭源项目通义千问开源了自己的7b模型。
下面我们就来研究下通义千问7b.
使用通义千问7b
首先安装依赖库：
pip install transformers==4.31.0 accelerate tiktoken einops transformers_stream_generator bitsandbytes
通义千问7b的开源做得还是不错的，不光在自家的魔搭平台上可以用，而且也开放在了huggingface上，所以我们可以直接用huggingface的API来调用。
我们按照官方的三轮对话的例子：
from transformers import AutoModelForCausalLM, AutoTokenizer
from transformers.generation import GenerationConfig
tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen-7B-Chat", trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen-7B-Chat", device_map="auto", trust_remote_code=True, bf16=True).eval()
model.generation_config = GenerationConfig.from_pretrained("Qwen/Qwen-7B-Chat", trust_remote_code=True) # 可指定不同的生成长度、top_p等相关超参
# 第一轮对话 1st dialogue turn
response, history = model.chat(tokenizer, "你好", history=None)
print(response)
# 第二轮对话 2nd dialogue turn
response, history = model.chat(tokenizer, "给我讲一个年轻人奋斗创业最终取得成功的故事。", history=history)
print(response)
# 第三轮对话 3rd dialogue turn
response, history = model.chat(tokenizer, "给这个故事起一个标题", history=history)
print(response)
运行结果如下：
你好！很高兴为你服务。
---
好的，这是一个关于一个年轻人奋斗创业最终取得成功的故事：
这是一个关于一个年轻人叫做杰克的故事。杰克是一个非常有抱负的年轻人，他一直梦想着自己能够成为一名成功的企业家。他从小就对商业和创业有着浓厚的兴趣，而且非常勤奋，总是努力学习和探索新的知识和技能。
在大学里，杰克学习了商业管理和创业课程，并且积极参加各种商业竞赛和实习项目。他通过自己的努力和聪明才智，赢得了很多奖项和机会，得到了很多宝贵的经验和知识。
毕业后，杰克决定开始自己的创业之路。他开始在市场上寻找机会，发现了一个非常有潜力的行业，并且决定在这个行业里创业。他面临着很多挑战和困难，但是他非常坚韧和有决心，不断努力和探索新的方法和思路，不断地学习和进步。
杰克和他的团队经历了许多困难和失败，但是他们一直保持着乐观和积极的态度，并且不断地学习和改进自己的方法和策略。最终，他们终于成功地推出了一款非常受欢迎的产品，并且在市场上获得了巨大的成功。
杰克的成功不仅仅是因为他的聪明才智和勤奋努力，更重要的是因为他具有坚定的信念和不屈不挠的精神。他不断地学习和进步，不断地尝试新的方法和思路，不断地克服困难和挑战，最终取得了成功。他的故事告诉我们，只要我们具有勇气和决心，就可以在创业的道路上取得成功。
---
这个故事的标题可以是：《杰克的创业之路》。
不知道千问7b所说的杰克，是不是姓马？：）
gradio
千问7b的Web demo用的是Gradio来实现的。与Streamlit类似，Gradio也是包含了简单的Web封装，加上前端的封装。
我们先看一个最简单的例子：
import gradio as gr
def greet(name):
return "Hello " + name + "!"
demo = gr.Interface(fn=greet, inputs="text", outputs="text")
if __name__ == "__main__":
demo.launch()
Gradio对Jupyter Notebook的支持相当好，我们可以直接在Jupyter Notebook中运行，既可以启动后端，也能展示前端。
Gradio通过Markdown方法来书写markdown文本，当然也支持html标签：
gr.Markdown("""<p align="center"><img src="https://modelscope.cn/api/v1/models/qwen/Qwen-7B-Chat/repo?Revision=master&FilePath=assets/logo.jpeg&View=true" style="height: 80px"/><p>""")
gr.Markdown("""<center><font size=8>Qwen-7B-Chat Bot</center>""")
gr.Markdown(
"""<center><font size=3>This WebUI is based on Qwen-7B-Chat, developed by Alibaba Cloud. (本WebUI基于Qwen-7B-Chat打造，实现聊天机器人功能。)</center>"""
)
gr.Markdown(
"""<center><font size=4>Qwen-7B <a href="https://modelscope.cn/models/qwen/Qwen-7B/summary">🤖 <a> | <a href="https://huggingface.co/Qwen/Qwen-7B">🤗</a>  ｜ Qwen-7B-Chat <a href="https://modelscope.cn/models/qwen/Qwen-7B-Chat/summary">🤖 <a>| <a href="https://huggingface.co/Qwen/Qwen-7B-Chat">🤗</a>  ｜  <a href="https://github.com/QwenLM/Qwen-7B">Github</a></center>"""
)
我们来看下效果：
Gradio支持TextBox用于输入，Button用于点击事件，而且支持ChatBot这样的复杂控件。还可以用Row来横向布局：
chatbot = gr.Chatbot(lines=10, label='Qwen-7B-Chat', elem_classes="control-height")
query = gr.Textbox(lines=2, label='Input')
with gr.Row():
emptyBtn = gr.Button("🧹 Clear History (清除历史)")
submitBtn = gr.Button("🚀 Submit (发送)")
regenBtn = gr.Button("🤔️ Regenerate (重试)")
效果如下：
完整代码如下，大家可以自己运行一下：
import gradio as gr
with gr.Blocks() as demo:
gr.Markdown("""<p align="center"><img src="https://modelscope.cn/api/v1/models/qwen/Qwen-7B-Chat/repo?Revision=master&FilePath=assets/logo.jpeg&View=true" style="height: 80px"/><p>""")
gr.Markdown("""<center><font size=8>Qwen-7B-Chat Bot</center>""")
gr.Markdown(
"""<center><font size=3>This WebUI is based on Qwen-7B-Chat, developed by Alibaba Cloud. (本WebUI基于Qwen-7B-Chat打造，实现聊天机器人功能。)</center>"""
)
gr.Markdown(
"""<center><font size=4>Qwen-7B <a href="https://modelscope.cn/models/qwen/Qwen-7B/summary">🤖 <a> | <a href="https://huggingface.co/Qwen/Qwen-7B">🤗</a>  ｜ Qwen-7B-Chat <a href="https://modelscope.cn/models/qwen/Qwen-7B-Chat/summary">🤖 <a>| <a href="https://huggingface.co/Qwen/Qwen-7B-Chat">🤗</a>  ｜  <a href="https://github.com/QwenLM/Qwen-7B">Github</a></center>"""
)
chatbot = gr.Chatbot(lines=10, label='Qwen-7B-Chat', elem_classes="control-height")
query = gr.Textbox(lines=2, label='Input')
with gr.Row():
emptyBtn = gr.Button("🧹 Clear History (清除历史)")
submitBtn = gr.Button("🚀 Submit (发送)")
regenBtn = gr.Button("🤔️ Regenerate (重试)")
gr.Markdown(
"""<font size=2>Note: This demo is governed by the original license of Qwen-7B. We strongly advise users not to knowingly generate or allow others to knowingly generate harmful content, including hate speech, violence, pornography, deception, etc. (注：本演示受Qwen-7B的许可协议限制。我们强烈建议，用户不应传播及不应允许他人传播以下内容，包括但不限于仇恨言论、暴力、色情、欺诈相关的有害信息。)"""
)
if __name__ == "__main__":
demo.launch()
再给三个Button配上响应函数，就可以响应功能了：
submitBtn.click(predict, [query, chatbot], [chatbot], show_progress=True)
submitBtn.click(reset_user_input, [], [query])
emptyBtn.click(reset_state, outputs=[chatbot], show_progress=True)
regenBtn.click(regenerate, [chatbot], [chatbot], show_progress=True)
其中reset_state只更新下内部状态就好：
def reset_state():
task_history.clear()
return []
reset_user_input需要通过update函数来刷新下状态，写过React的同学应该很熟悉，这其实是个异步操作哈：
def reset_user_input():
return gr.update(value="")
然后是需要处理下流状态的predict函数：
def predict(query, chatbot):
print("User: " + parse_text(query))
chatbot.append((parse_text(query), ""))
fullResponse = ""
for response in model.chat_stream(tokenizer, query, history=task_history):
chatbot[-1] = (parse_text(query), parse_text(response))
yield chatbot
fullResponse = parse_text(response)
task_history.append((query, fullResponse))
print("Qwen-7B-Chat: " + parse_text(fullResponse))
注意yield的用法，chatbot就是我们用gr.ChatBot生成的对话框控件。
regenerate仍然要注意下yield：
def regenerate(chatbot):
if not task_history:
yield chatbot
return
item = task_history.pop(-1)
chatbot.pop(-1)
yield from predict(item[0], chatbot)
代码超参数
下面我们来看下Qwen-7B-Chat的代码。
首先是支持了哪些配置项和超参数：
from transformers import PretrainedConfig
class QWenConfig(PretrainedConfig):
model_type = "qwen"
keys_to_ignore_at_inference = ["past_key_values"]
attribute_map = {
"hidden_size": "n_embd",
"num_attention_heads": "n_head",
"max_position_embeddings": "n_positions",
"num_hidden_layers": "n_layer",
}
def __init__(
self,
vocab_size=151851,
n_embd=4096,
n_layer=32,
n_head=32,
n_inner=None,
embd_pdrop=0.0,
attn_pdrop=0.0,
layer_norm_epsilon=1e-5,
initializer_range=0.02,
scale_attn_weights=True,
use_cache=True,
eos_token_id=151643,
apply_residual_connection_post_layernorm=False,
bf16=False,
fp16=False,
fp32=False,
kv_channels=128,
rotary_pct=1.0,
rotary_emb_base=10000,
use_dynamic_ntk=False,
use_logn_attn=False,
use_flash_attn=True,
ffn_hidden_size=22016,
no_bias=True,
tie_word_embeddings=False,
**kwargs,
):
self.eos_token_id = eos_token_id
super().__init__(
eos_token_id=eos_token_id, tie_word_embeddings=tie_word_embeddings, **kwargs
)
self.vocab_size = vocab_size
self.n_embd = n_embd
self.n_layer = n_layer
self.n_head = n_head
self.n_inner = n_inner
self.embd_pdrop = embd_pdrop
self.attn_pdrop = attn_pdrop
self.layer_norm_epsilon = layer_norm_epsilon
self.initializer_range = initializer_range
self.scale_attn_weights = scale_attn_weights
self.use_cache = use_cache
self.apply_residual_connection_post_layernorm = (
apply_residual_connection_post_layernorm
)
self.bf16 = bf16
self.fp16 = fp16
self.fp32 = fp32
self.kv_channels = kv_channels
self.rotary_pct = rotary_pct
self.rotary_emb_base = rotary_emb_base
self.use_dynamic_ntk = use_dynamic_ntk
self.use_logn_attn = use_logn_attn
self.use_flash_attn = use_flash_attn
self.ffn_hidden_size = ffn_hidden_size
self.no_bias = no_bias
self.tie_word_embeddings = tie_word_embeddings
我们来解释下这些参数：
- vocab_size：词汇表大小，即模型可以处理的不同单词的数量，默认为 151851
- n_embd： 嵌入层的维度，即每个单词或位置的向量表示的长度，默认为 4096
- n_layer： 编码器层的数量，即模型中重复堆叠的自注意力层和前馈层的数量，默认为 32
- n_head=32： 注意力头的数量，即每个编码器层中分割后的多头自注意力机制的数量，默认为 32
- n_inner： 前馈层的内部维度，即每个编码器层中全连接层的隐藏单元数，默认为 None，表示与嵌入层维度相同
- embd_pdrop： 嵌入层的丢弃概率，即在嵌入层后应用丢弃正则化时随机置零单元的概率，默认为 0.0，表示不使用丢弃正则化
- attn_pdrop： 注意力层的丢弃概率，即在注意力层后应用丢弃正则化时随机置零单元的概率，默认为 0.0，表示不使用丢弃正则化
- layer_norm_epsilon： 层归一化的 epsilon 值，即在计算层归一化时加到分母上的小量，防止除以零，默认为 1e-5
- initializer_range： 初始化范围，即在初始化模型参数时使用的均匀分布的上下界，默认为 0.02
- scale_attn_weights： 是否缩放注意力权重，即在计算多头自注意力机制时是否除以注意力头数的平方根，默认为 True
- use_cache： 是否使用缓存，即在解码时是否保存前面计算过的隐藏状态和注意力键值对，默认为 True
- eos_token_id：结束符号的 ID，即表示序列结束的特殊单词对应的整数编号，默认为 151643
- apply_residual_connection_post_layernorm：是否在层归一化后应用残差连接，即在每个编码器层中是否先进行层归一化再加上输入，默认为 False
- bf16：是否使用 bf16 格式，即是否使用 16 位浮点数来存储模型参数和计算梯度，默认为 False
- fp16：是否使用 fp16 格式，即是否使用 16 位浮点数来存储模型参数和计算梯度，默认为 False
- fp32：是否使用 fp32 格式，即是否使用 32 位浮点数来存储模型参数和计算梯度，默认为 False
- kv_channels： 键值通道数，即在计算注意力键值对时使用的线性变换的输出维度，默认为 128
- rotary_pct： 旋转百分比，即在嵌入层中使用旋转位置编码的比例，默认为 1.0，表示全部使用旋转位置编码
- rotary_emb_base： 旋转嵌入基数，即在计算旋转位置编码时使用的基数，默认为 10000
- use_dynamic_ntk：是否使用动态 NTK，即是否在计算注意力权重时使用动态神经切线核方法，默认为 False
- use_logn_attn： 是否使用对数注意力，即是否在计算注意力权重时使用对数函数来加速和压缩，默认为 False
- use_flash_attn： 是否使用闪存注意力，即是否在计算注意力权重时使用闪存变换来降低复杂度，默认为 True
- ffn_hidden_size： 前馈层的隐藏大小，即每个编码器层中全连接层的输出维度，默认为 22016
- no_bias： 是否不使用偏置，即在模型中的所有线性变换中是否不添加偏置向量，默认为 True
- tie_word_embeddings： 是否绑定词嵌入，即在模型中是否共享输入和输出的词嵌入矩阵，默认为 False
- kwargs： 其他参数，用于接收额外的配置信息或覆盖上面的默认值
Flash Attention
千问7b建议使用flash attention来进行加速。
Flash Attention 是一种新型的注意力算法，它可以快速和内存高效地计算精确的注意力权重，而不需要近似或压缩。它的主要思想是利用 GPU 的层次化内存结构，通过分块和重用的方法，减少从高带宽内存（HBM）到片上静态随机存储器（SRAM）的读写次数，从而提高计算速度和节省内存空间。Flash Attention 还可以扩展到块稀疏注意力，进一步降低计算复杂度和内存消耗。
Flash Attention 的主要优势有：
- 它可以实现与标准注意力相同的模型质量和精度，而不牺牲任何信息或引入任何噪声。
- 它可以在不同的序列长度、批量大小、模型大小和硬件配置下，都能达到显著的加速和内存节省效果。
- 它可以与其他优化技术如混合精度训练、激活检查点等兼容，进一步提升性能。
- 它可以支持更长的上下文长度，从而提高模型在长文本任务上的表现。
具体原理我们后面会分析到其论文和代码。
代码在：https://github.com/Dao-AILab/flash-attention。论文在：https://arxiv.org/abs/2205.14135
这里我们先看在千问7b中如何使用flash attention。
首先要把Flash attention的库加载进来：
def _import_flash_attn():
global apply_rotary_emb_func, rms_norm, flash_attn_unpadded_func
try:
from flash_attn.layers.rotary import apply_rotary_emb_func as __apply_rotary_emb_func
apply_rotary_emb_func = __apply_rotary_emb_func
except ImportError:
logger.warn(
"Warning: import flash_attn rotary fail, please install FlashAttention rotary to get higher efficiency "
"https://github.com/Dao-AILab/flash-attention/tree/main/csrc/rotary"
)
try:
from flash_attn.ops.rms_norm import rms_norm as __rms_norm
rms_norm = __rms_norm
except ImportError:
logger.warn(
"Warning: import flash_attn rms_norm fail, please install FlashAttention layer_norm to get higher efficiency "
"https://github.com/Dao-AILab/flash-attention/tree/main/csrc/layer_norm"
)
try:
import flash_attn
if not hasattr(flash_attn, '__version__'):
from flash_attn.flash_attn_interface import flash_attn_unpadded_func as __flash_attn_unpadded_func
else:
if int(flash_attn.__version__.split(".")[0]) >= 2:
from flash_attn.flash_attn_interface import flash_attn_varlen_func as __flash_attn_unpadded_func
else:
from flash_attn.flash_attn_interface import flash_attn_unpadded_func as __flash_attn_unpadded_func
flash_attn_unpadded_func = __flash_attn_unpadded_func
except ImportError:
logger.warn(
"Warning: import flash_attn fail, please install FlashAttention to get higher efficiency "
"https://github.com/Dao-AILab/flash-attention"
)
然后我们实现一个使用Flash Attention的自注意力模块：
class FlashSelfAttention(torch.nn.Module):
def __init__(
self,
causal=False,
softmax_scale=None,
attention_dropout=0.0,
):
super().__init__()
assert flash_attn_unpadded_func is not None, (
"Please install FlashAttention first, " "e.g., with pip install flash-attn"
)
assert (
rearrange is not None
), "Please install einops first, e.g., with pip install einops"
self.causal = causal
self.softmax_scale = softmax_scale
self.dropout_p = attention_dropout
def forward(self, q, k, v):
assert all((i.dtype in [torch.float16, torch.bfloat16] for i in (q, k, v)))
assert all((i.is_cuda for i in (q, k, v)))
batch_size, seqlen_q = q.shape[0], q.shape[1]
seqlen_k = k.shape[1]
q, k, v = [rearrange(x, "b s ... -> (b s) ...") for x in [q, k, v]]
cu_seqlens_q = torch.arange(
0,
(batch_size + 1) * seqlen_q,
step=seqlen_q,
dtype=torch.int32,
device=q.device,
)
if self.training:
assert seqlen_k == seqlen_q
is_causal = self.causal
cu_seqlens_k = cu_seqlens_q
else:
is_causal = seqlen_q == seqlen_k
cu_seqlens_k = torch.arange(
0,
(batch_size + 1) * seqlen_k,
step=seqlen_k,
dtype=torch.int32,
device=q.device,
)
self.dropout_p = 0
output = flash_attn_unpadded_func(
q,
k,
v,
cu_seqlens_q,
cu_seqlens_k,
seqlen_q,
seqlen_k,
self.dropout_p,
softmax_scale=self.softmax_scale,
causal=is_causal,
)
output = rearrange(output, "(b s) ... -> b s ...", b=batch_size)
return output
其主要步骤如下：
- 首先，检查q, k, v的数据类型是否为torch.float16或torch.bfloat16，以及是否在CUDA设备上运行。
- 然后，使用einops库的rearrange函数，将q, k, v的形状从"b s …“变为”(b s) …"，其中b是批次大小，s是序列长度。
- 接着，根据q和k的序列长度，生成两个整数张量cu_seqlens_q和cu_seqlens_k，它们表示每个批次中每个序列的起始位置。
- 再然后，根据是否处于训练模式和是否使用因果掩码，设置cu_seqlens_k和is_causal的值，以及注意力的dropout概率。
- 核心的Flash Attention来了，调用flash_attn_unpadded_func函数，它是FlashAttention库提供的一个核心函数，它可以快速计算未填充的自注意力矩阵，并返回输出张量。
- 最后，将输出张量的形状从"(b s) …“变回"b s …”，并返回。
RMSNorm层
通义千问的RMSNorm跟之前讲的基本一样，这里就不多解释了：
class RMSNorm(torch.nn.Module):
def __init__(self, dim: int, eps: float = 1e-6):
super().__init__()
self.eps = eps
self.weight = nn.Parameter(torch.ones(dim))
def _norm(self, x):
return x * torch.rsqrt(x.pow(2).mean(-1, keepdim=True) + self.eps)
def forward(self, x):
if rms_norm is not None and x.is_cuda:
return rms_norm(x, self.weight, self.eps)
else:
output = self._norm(x.float()).type_as(x)
return output * self.weight
位置编码
千问7b的位置编码是标准的Rotary Position Embedding。来自论文《RoFormer: Enhanced Transformer with Rotary Position Embedding》。
class RotaryEmbedding(torch.nn.Module):
def __init__(self, dim, base=10000):
super().__init__()
self.dim = dim
self.base = base
self.inv_freq = 1.0 / (base ** (torch.arange(0, dim, 2).float() / dim))
if importlib.util.find_spec("einops") is None:
raise RuntimeError("einops is required for Rotary Embedding")
self._rotary_pos_emb_cache = None
self._seq_len_cached = 0
self._ntk_alpha_cached = 1.0
def update_rotary_pos_emb_cache(self, max_seq_len, offset=0, ntk_alpha=1.0):
seqlen = max_seq_len + offset
if seqlen > self._seq_len_cached or ntk_alpha != self._ntk_alpha_cached:
base = self.base * ntk_alpha ** (self.dim / (self.dim - 2))
self.inv_freq = 1.0 / (
base
** (
torch.arange(0, self.dim, 2, device=self.inv_freq.device).float()
/ self.dim
)
)
self._seq_len_cached = max(2 * seqlen, 16)
self._ntk_alpha_cached = ntk_alpha
seq = torch.arange(self._seq_len_cached, device=self.inv_freq.device)
freqs = torch.outer(seq.type_as(self.inv_freq), self.inv_freq)
emb = torch.cat((freqs, freqs), dim=-1)
from einops import rearrange
self._rotary_pos_emb_cache = rearrange(emb, "n d -> 1 n 1 d")
def forward(self, max_seq_len, offset=0, ntk_alpha=1.0):
self.update_rotary_pos_emb_cache(max_seq_len, offset, ntk_alpha)
return self._rotary_pos_emb_cache[:, offset : offset + max_seq_len]
千问7b的_rotate_half使用了einops库来加速：
def _rotate_half(x):
from einops import rearrange
x = rearrange(x, "... (j d) -> ... j d", j=2)
x1, x2 = x.unbind(dim=-2)
return torch.cat((-x2, x1), dim=-1)
最后是apply_rotary_pos_emb的实现，使用了apply_rotary_emb_func来进行加速。
def apply_rotary_pos_emb(t, freqs):
if apply_rotary_emb_func is not None and t.is_cuda:
t_ = t.float()
freqs = freqs.squeeze(0).squeeze(1)
cos = freqs[:, : freqs.shape[-1] // 2].cos()
sin = freqs[:, : freqs.shape[-1] // 2].sin()
output = apply_rotary_emb_func(t_, cos, sin).type_as(t)
return output
else:
rot_dim = freqs.shape[-1]
t_, t_pass_ = t[..., :rot_dim], t[..., rot_dim:]
t_ = t_.float()
t_pass_ = t_pass_.float()
t_ = (t_ * freqs.cos()) + (_rotate_half(t_) * freqs.sin())
return torch.cat((t_, t_pass_), dim=-1).type_as(t)
千问7b的注意力结构
首先还是一堆变量定义：
class QWenAttention(nn.Module):
def __init__(self, config, layer_number=None):
super().__init__()
max_positions = config.max_position_embeddings
self.register_buffer(
"bias",
torch.tril(
torch.ones((max_positions, max_positions), dtype=torch.bool)
).view(1, 1, max_positions, max_positions),
persistent=False,
)
self.register_buffer("masked_bias", torch.tensor(-1e4), persistent=False)
self.layer_number = max(1, layer_number)
self.params_dtype = config.params_dtype
self.seq_length = config.seq_length
self.hidden_size = config.hidden_size
self.split_size = config.hidden_size
self.num_heads = config.num_attention_heads
self.head_dim = self.hidden_size // self.num_heads
self.use_flash_attn = config.use_flash_attn
self.scale_attn_weights = True
self.layer_idx = None
self.projection_size = config.kv_channels * config.num_attention_heads
assert self.projection_size % config.num_attention_heads == 0
self.hidden_size_per_attention_head = (
self.projection_size // config.num_attention_heads
)
self.c_attn = nn.Linear(config.hidden_size, 3 * self.projection_size)
self.c_proj = nn.Linear(
config.hidden_size, self.projection_size, bias=not config.no_bias
)
self.is_fp32 = not (config.bf16 or config.fp16)
if (
self.use_flash_attn
and flash_attn_unpadded_func is not None
and not self.is_fp32
):
self.core_attention_flash = FlashSelfAttention(
causal=True, attention_dropout=config.attn_pdrop
)
self.bf16 = config.bf16
if config.rotary_pct == 1.0:
self.rotary_ndims = None
else:
assert config.rotary_pct < 1
self.rotary_ndims = int(
self.hidden_size_per_attention_head * config.rotary_pct
)
dim = (
self.rotary_ndims
if self.rotary_ndims is not None
else self.hidden_size_per_attention_head
)
self.rotary_emb = RotaryEmbedding(dim, base=config.rotary_emb_base)
self.use_dynamic_ntk = config.use_dynamic_ntk
self.use_logn_attn = config.use_logn_attn
logn_list = [
math.log(i, self.seq_length) if i > self.seq_length else 1
for i in range(1, 32768)
]
self.logn_tensor = torch.tensor(logn_list)[None, :, None, None]
self._ntk_cached = 1.0
self.attn_dropout = nn.Dropout(config.attn_pdrop)
大致介绍一下这些变量，具体的含义我们在后面代码可以讲到：
- max_positions 定义了模型可以处理的最大位置数，它来自配置对象
- bias 是一个下三角矩阵，大小为 (max_positions, max_positions)，用于实现自注意力的屏蔽。它被注册为一个不需要持久化的缓冲区
- masked_bias 是一个具有大负值（-1e4）的张量，用于在注意力得分中屏蔽某些位置
- layer_number 是当前层的层数，至少为1
- params_dtype 是模型参数的数据类型
- seq_length 是输入序列的长度
- hidden_size、split_size、num_heads、head_dim 分别为隐藏层大小，分割大小，注意力头数和每个注意力头的维度
- use_flash_attn 是一个布尔标志，表示是否使用 Flash Attention
- scale_attn_weights 是一个布尔标志，表示是否对注意力权重进行缩放
- projection_size 定义了投影的大小，它等于 kv_channels 和 num_attention_heads 的乘积
- c_attn 和 c_proj 是两个线性层，用于计算注意力得分
- core_attention_flash 是一个 FlashSelfAttention 对象，只有在使用 Flash Attention 并且数据类型不是 fp32 时才会创建
- bf16 是一个布尔标志，表示是否使用 bf16 数据类型
- rotary_emb 是一个 RotaryEmbedding 对象，用于实现旋转位置编码
- use_dynamic_ntk 是一个布尔标志，表示是否使用动态 NTK
- use_logn_attn 是一个布尔标志，表示是否使用 logn 注意力
- logn_tensor 是一个张量，包含了一些预计算的 logn 值
- attn_dropout 是一个 Dropout 层，用于在注意力计算中添加随机性
下面我们来看注意力的计算：
def _attn(self, query, key, value, attention_mask=None, head_mask=None):
attn_weights = torch.matmul(query, key.transpose(-1, -2))
if self.scale_attn_weights:
attn_weights = attn_weights / torch.full(
[],
value.size(-1) ** 0.5,
dtype=attn_weights.dtype,
device=attn_weights.device,
)
query_length, key_length = query.size(-2), key.size(-2)
causal_mask = self.bias[
:, :, key_length - query_length : key_length, :key_length
]
mask_value = torch.finfo(attn_weights.dtype).min
mask_value = torch.full([], mask_value, dtype=attn_weights.dtype).to(
attn_weights.device
)
attn_weights = torch.where(
causal_mask, attn_weights.to(attn_weights.dtype), mask_value
)
attn_weights = nn.functional.softmax(attn_weights, dim=-1)
attn_weights = attn_weights.type(value.dtype)
attn_weights = self.attn_dropout(attn_weights)
if head_mask is not None:
attn_weights = attn_weights * head_mask
attn_output = torch.matmul(attn_weights, value)
attn_output = attn_output.transpose(1, 2)
return attn_output, attn_weights
其主要步骤如下：
- 使用 torch.matmul 计算查询（query）和键（key）的点积，得到注意力权重 attn_weights。
- 如果 self.scale_attn_weights 为 True，则将注意力权重除以值（value）的最后一个维度的平方根，这是一种常见的缩放操作，用于控制注意力权重的大小。
- 创建一个因果屏蔽 causal_mask，该屏蔽用于确保在自注意力计算中，任何位置只能注意到其之前的位置。其中 mask_value 是一个非常小的数，用于在注意力得分中屏蔽某些位置。
- 使用 torch.where 应用因果屏蔽。如果 causal_mask 中的某一位置为 True，那么在对应的 attn_weights 位置保持原值，否则用 mask_value 替换。
- 对注意力权重应用 softmax 函数，使得所有权重之和为1，这样可以将它们解释为概率。
- 使用 attn_dropout 对注意力权重应用 dropout 操作，以增加模型的泛化能力。
- 如果提供了 head_mask，则将其应用到注意力权重上，这可以用于屏蔽某些注意力头。
- 使用注意力权重和值（value）计算注意力输出 attn_output，并将其张量的第1维和第2维进行转置，以满足后续操作的需要。
为了提高计算精度，还有另一个Attention的计算函数：
def _upcast_and_reordered_attn(
self, query, key, value, attention_mask=None, head_mask=None
):
bsz, num_heads, q_seq_len, dk = query.size()
_, _, k_seq_len, _ = key.size()
attn_weights = torch.empty(
bsz * num_heads,
q_seq_len,
k_seq_len,
dtype=torch.float32,
device=query.device,
)
scale_factor = 1.0
if self.scale_attn_weights:
scale_factor /= float(value.size(-1)) ** 0.5
with autocast(enabled=False):
q, k = query.reshape(-1, q_seq_len, dk), key.transpose(-1, -2).reshape(
-1, dk, k_seq_len
)
attn_weights = torch.baddbmm(
attn_weights, q.float(), k.float(), beta=0, alpha=scale_factor
)
attn_weights = attn_weights.reshape(bsz, num_heads, q_seq_len, k_seq_len)
query_length, key_length = query.size(-2), key.size(-2)
causal_mask = self.bias[
:, :, key_length - query_length : key_length, :key_length
]
mask_value = torch.finfo(attn_weights.dtype).min
mask_value = torch.tensor(mask_value, dtype=attn_weights.dtype).to(
attn_weights.device
)
attn_weights = torch.where(causal_mask, attn_weights, mask_value)
if attention_mask is not None:
attn_weights = attn_weights + attention_mask
attn_weights = nn.functional.softmax(attn_weights, dim=-1)
if attn_weights.dtype != torch.float32:
raise RuntimeError(
"Error with upcasting, attn_weights does not have dtype torch.float32"
)
attn_weights = attn_weights.type(value.dtype)
attn_weights = self.attn_dropout(attn_weights)
if head_mask is not None:
attn_weights = attn_weights * head_mask
attn_output = torch.matmul(attn_weights, value)
return attn_output, attn_weights
_upcast_and_reordered_attn注意力权重计算使用float32精度。将query和key reshape成2D矩阵,然后使用torch.baddbmm进行高效的矩阵乘法。计算得到的attn_weights再reshape回原始的4D形状。同样应用因果遮掩矩阵和attention mask。
在softmax之前校验attn_weights是否是float32,如果不是会报错。softmax后再将attn_weights转回value的dtype。
最后得到attention输出和权重矩阵。
还有对头的拆分和组装的两个辅助函数：
def _split_heads(self, tensor, num_heads, attn_head_size):
new_shape = tensor.size()[:-1] + (num_heads, attn_head_size)
tensor = tensor.view(new_shape)
return tensor
def _merge_heads(self, tensor, num_heads, attn_head_size):
tensor = tensor.contiguous()
new_shape = tensor.size()[:-2] + (num_heads * attn_head_size,)
return tensor.view(new_shape)
_split_heads 函数的作用是将输入张量的最后一个维度分割成两个维度，其中一个是注意力头的数量（num_heads），另一个是每个注意力头的大小（attn_head_size）。函数首先创建了新的形状 new_shape，然后使用 view 函数将输入张量变形为这个新的形状。
_merge_heads 函数的作用是将 _split_heads 函数处理后的张量回归到原始的维度。首先，它会调用 contiguous 函数确保张量在内存中是连续的，这是因为在某些情况下，view 函数需要输入张量在内存中是连续的。然后，它创建了新的形状 new_shape，并使用 view 函数将输入张量变形为这个新的形状。
最后是前向计算。主要分为十步：
- 输入参数：hidden_states是输入的隐藏状态，layer_past是上一层的输出，attention_mask和head_mask分别是注意力掩码和头掩码，encoder_hidden_states和encoder_attention_mask是在编码器-解码器架构中使用的，output_attentions决定是否输出注意力权重，use_cache决定是否使用缓存。
- 计算 query、key 和 value：通过self.c_attn(hidden_states)计算混合层，然后将其拆分为查询、键和值。拆分后的大小是self.split_size。
- 分割多头注意力：使用_split_heads()函数对 query、key 和 value 进行拆分，将最后一个维度拆分为self.num_heads和self.head_dim。
- 处理旋转位置嵌入：根据kv_seq_len和ntk_alpha计算旋转位置嵌入。然后，对 query 和 key 应用旋转位置嵌入。
- 处理 past layer：如果layer_past存在，将其与当前的 key 和 value 连接起来。
- 处理缓存：如果use_cache为 True，则将当前的 key 和 value 存储到present中。
- 应用对数注意力：如果use_logn_attn为 True，并且当前不处于训练模式，那么将对 query 应用对数注意力。
- 应用 Flash Attention 或常规注意力：如果use_flash_attn为 True，并且满足一些其他条件，那么使用 Flash Attention 对 query、key 和 value 进行处理。否则，使用常规的注意力机制，并且将 query、key 和 value 的维度重新排列以符合_attn()函数的要求。
- 计算注意力输出并进行投影：使用self.c_proj()将注意力输出进行投影。
- 生成输出：如果output_attentions为 True，那么在输出中加入注意力权重。
def forward(
self,
hidden_states: Optional[Tuple[torch.FloatTensor]],
layer_past: Optional[Tuple[torch.Tensor]] = None,
attention_mask: Optional[torch.FloatTensor] = None,
head_mask: Optional[torch.FloatTensor] = None,
encoder_hidden_states: Optional[torch.Tensor] = None,
encoder_attention_mask: Optional[torch.FloatTensor] = None,
output_attentions: Optional[bool] = False,
use_cache: Optional[bool] = False,
):
mixed_x_layer = self.c_attn(hidden_states)
query, key, value = mixed_x_layer.split(self.split_size, dim=2)
query = self._split_heads(query, self.num_heads, self.head_dim)
key = self._split_heads(key, self.num_heads, self.head_dim)
value = self._split_heads(value, self.num_heads, self.head_dim)
kv_seq_len = hidden_states.size()[1]
if layer_past:
# layer past[0] shape: bs * seq_len * head_num * dim
kv_seq_len += layer_past[0].shape[1]
if (
self.use_dynamic_ntk
and kv_seq_len == hidden_states.size()[1]
and not self.training
):
context_value = math.log(kv_seq_len / self.seq_length, 2) + 1
ntk_alpha = 2 ** math.ceil(context_value) - 1
ntk_alpha = max(ntk_alpha, 1)
self._ntk_cached = ntk_alpha
else:
ntk_alpha = self._ntk_cached
rotary_pos_emb = self.rotary_emb(kv_seq_len, ntk_alpha=ntk_alpha).to(
hidden_states.device
)
if rotary_pos_emb is not None:
if isinstance(rotary_pos_emb, tuple):
rotary_pos_emb = rotary_pos_emb
else:
rotary_pos_emb = (rotary_pos_emb,) * 2
if rotary_pos_emb is not None:
q_pos_emb, k_pos_emb = rotary_pos_emb
# Slice the pos emb for current inference
cur_len = query.shape[1]
q_pos_emb = q_pos_emb[:, -cur_len:, :, :]
k_pos_emb = k_pos_emb[:, -cur_len:, :, :]
query = apply_rotary_pos_emb(query, q_pos_emb)
key = apply_rotary_pos_emb(key, k_pos_emb)
if layer_past is not None:
past_key, past_value = layer_past[0], layer_past[1]
key = torch.cat((past_key, key), dim=1)
value = torch.cat((past_value, value), dim=1)
if use_cache:
present = (key, value)
else:
present = None
if self.use_logn_attn and not self.training:
if self.logn_tensor.device != query.device or self.logn_tensor.dtype != query.dtype:
self.logn_tensor = self.logn_tensor.to(query.device).type_as(query)
seq_start = key.size(1) - query.size(1)
seq_end = key.size(1)
logn_tensor = self.logn_tensor[:, seq_start:seq_end, :, :]
query = query * logn_tensor.expand_as(query)
if (
self.use_flash_attn
and flash_attn_unpadded_func is not None
and not self.is_fp32
and query.is_cuda
):
q, k, v = query, key, value
context_layer = self.core_attention_flash(q, k, v)
context_layer = rearrange(
context_layer, "b s h d -> b s (h d)"
).contiguous()
else:
query = query.permute(0, 2, 1, 3)
key = key.permute(0, 2, 1, 3)
value = value.permute(0, 2, 1, 3)
attn_output, attn_weight = self._attn(
query, key, value, attention_mask, head_mask
)
context_layer = self._merge_heads(
attn_output, self.num_heads, self.head_dim
)
attn_output = self.c_proj(context_layer)
outputs = (attn_output, present)
if output_attentions:
if (
self.use_flash_attn
and flash_attn_unpadded_func is not None
and not self.is_fp32
):
raise ValueError("Cannot output attentions while using flash-attn")
else:
outputs += (attn_weight,)
return outputs
小结
千问7b的代码比较长，实现的接口也较多，下一节我们继续介绍将自注意力模块和组装成模型的代码。
1095
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
