self-attention模型理解

Hailey的算法学习笔记

已于 2023-06-08 20:42:34 修改

阅读量880

点赞数

分类专栏：算法学习文章标签：深度学习人工智能机器学习

于 2023-06-07 19:24:08 首次发布

本文链接：https://blog.csdn.net/weixin_41168869/article/details/131073934

版权

算法学习专栏收录该内容

28 篇文章 0 订阅

订阅专栏

self-attention模型

SWOT分析

项目	要点	描述
优势	高效性	self-attention 模型具有高度的并行性，能够在短时间内处理大量的输入数据，因此在处理长序列数据时具有优势。
	灵活性	self-attention 模型可以适应不同类型的输入数据，包括文本、图像等多种形式，因此具有很强的适应性。
	鲁棒性	self-attention 模型在训练过程中可以有效地避免梯度消失或梯度爆炸等问题，因此在处理复杂问题时具有较强的鲁棒性。
劣势	可解释性	self-attention 模型的预测结果通常是基于整个输入序列的综合信息，因此对于具体的预测结果来说，可能难以解释每个输入元素的具体作用。
	训练复杂度	self-attention 模型通常需要大量的训练数据和计算资源，以便达到较好的性能，因此在训练过程中可能面临一定的困难。
机会	应用场景	self-attention 模型已经在自然语言处理、图像处理等多个领域得到应用，并且还有很多未开发的应用场景，包括语音处理、推荐系统等领域。
	发展趋势	随着深度学习技术的不断发展，self-attention 模型在未来可能会有更多的改进和优化，从而提高模型的性能和应用范围。
威胁	竞争压力	随着深度学习技术的不断发展，self-attention 模型可能会面临来自其他模型的竞争压力，例如卷积神经网络等模型。
	隐私问题	self-attention 模型通常需要处理大量的个人数据，例如文本、图像等数据，因此可能会面临隐私问题和数据泄露的风险。

self-attention 的原理

假设我们有一个由3个词向量组成的输入序列 $X$ ，每个词向量维度为 $d$ 。我们的任务是通过self-attention来对每个词向量赋予不同的权重，以便更好地表示输入序列中的关系。

我们首先将输入序列中的每个词向量都进行三次线性变换，以便转换到三个不同的空间：Query空间、Key空间和Value空间。我们可以使用权重矩阵 $W_Q$ 、 $W_K$ 和 $W_V$ 来进行这些变换，该矩阵的维度为 $d\times d$ 。

Query矩阵 $Q$ 由输入序列中的每个词向量进行 $W_Q$ 变换得到，其维度为 $\times d$ 。我们可以表示为：

$Q = XW_Q$

同样，Key矩阵 $K$ 和Value矩阵 $V$ 由输入序列中的每个词向量进行 $W_K$ 和 $W_V$ 变换得到，其维度均为 $\times d$ ：

$K = XW_K$ $V = XW_V$

下一步是计算每个词向量与其他词向量的相似性，这可以通过计算Query矩阵 $Q$ 和 Key矩阵 $K$ 的点积得到。点积的结果是一个大小为 $\times 3$ 的矩阵，我们将其记为 $S$ ，其公式如下：

$S = QK^T$

我们可以将 $S$ 看作是输入序列中每个词向量与其他词向量之间的相似性得分。在进行softmax操作之前，我们可以将 $S$ 矩阵中的每个元素除以 $\sqrt{d}$ ，以使得相似度的量级与向量空间的维度 $d$ 无关。然后，我们将 $S$ 矩阵的每一行通过softmax操作进行归一化，以便得到每个词向量在所有词向量中的权重分布。我们将这个矩阵记为 $A$ ，其公式如下：

$softmax(\frac{QK^T}{\sqrt{d}})$

最后，我们将每个词向量的权重与其对应的Value矩阵进行加权平均，以得到对输入序列进行self-attention后的表示。具体来说，我们可以将 $A$ 矩阵与 Value矩阵 $V$ 进行矩阵乘法，得到一个大小为 $\times d$ 的矩阵 $O$ ，其公式如下：

$O = A V$

最终， $O$ 矩阵的每一行就是对输入序列中对应词向量进行self-attention后得到的表示。
Self-attention 的原理是对输入的序列中每个元素，都计算一个权重向量，然后根据这个权重向量对所有元素进行加权平均，并得到一个新的表示向量。这个过程可以用以下公式表示：
$\text{SelfAttention}(Q,K,V) = \text{softmax}(\frac{QK^T}{\sqrt{d_k}})V$

其中， $Q$ ， $K$ ， $V$ 分别是输入序列的查询矩阵、键矩阵和值矩阵， $\text{softmax}$ 是 softmax 函数， $d_k$ 是 $K$ 矩阵的维度。

Self-attention是一种机器学习模型中的注意力机制，它能够使模型在处理序列数据时更加关注相关的部分。Self-attention的原理可以简单地描述为：对于一个输入序列中的每个元素，通过计算该元素与序列中所有其他元素的相似度，来确定该元素在模型中的重要程度。

Self-attention的计算公式如下：

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

其中， $Q$ 、 $K$ 和 $V$ 分别代表 query、key 和 value，均为形状为 $\times d_k)$ 的矩阵，其中 $n$ 是序列长度， $d_k$ 是每个元素的隐藏状态维度。Softmax 函数用于将相似度变成概率分布，其中被除数 $\sqrt{d_k}$ 是为了缩放相似度，防止在计算时出现梯度消失/爆炸的情况。

Self-attention 可以看作是一种在输入序列的不同位置之间分配"注意力权重"的机制，这使得模型能够在处理序列数据时更加关注相关的部分。
Self-attention是一种机制，用于计算序列中每个元素的重要性权重，这些权重可以用于加权计算序列中的元素，从而获得表示序列的向量。在自然语言处理中，这种机制已经被广泛应用于各种任务，例如机器翻译和文本分类等。

Self-attention的计算可以分为三个步骤：计算查询向量、计算注意力权重和加权求和。下面是Self-attention的数学原理和公式：

计算查询向量

首先，为了计算序列中每个元素的注意力权重，我们需要选择一个查询向量q，它将与序列中的每个元素进行比较。查询向量可以是序列中的任何元素的线性组合，通常是前一层的输出或者是该层的输出。假设我们的查询向量为 $q$ 。

计算注意力权重

接下来，我们计算序列中每个元素的注意力权重。这些权重表示每个元素对于计算查询向量q的重要性。注意力权重可以使用点积注意力、缩放点积注意力或其他注意力机制来计算，其中点积注意力是最常用的一种。点积注意力使用查询向量q和序列中每个元素的特征向量k进行点积，然后将结果进行缩放并应用softmax函数，得到注意力权重向量a。具体来说，我们使用以下公式计算注意力权重：

$a_i = \frac{\exp(e_i)}{\sum_{j=1}^{n} \exp(e_j)}$

其中， $e_i$ 表示查询向量q和特征向量 $k_i$ 的点积，可以表示为：

$e_i = q \cdot k_i$

加权求和

最后，我们将序列中的每个元素特征向量v与相应的注意力权重a_i相乘，并将所有加权元素求和，以获得最终的表示向量。具体来说，我们使用以下公式计算表示向量：

$\text{self-attention}(q, K, V) = \sum_{i=1}^{n} a_i \cdot v_i$

其中， $K$ 和 $V$ 分别表示序列中每个元素的特征向量和对应的值向量， $n$ 表示序列的长度。
我来给你举一个简单的例子来手推一下Self-Attention的过程。

假设我们有一个序列 $x=[x_1, x_2, x_3]$ ，其中每个元素都是一个长度为2的向量，即 $x_i=[x_{i1}, x_{i2}]$ ，如下所示：

$\begin{bmatrix} 1 & 2\\ 3 & 4\\ 5 & 6 \end{bmatrix}$

现在，我们想使用Self-Attention来计算该序列的表示向量。为了计算注意力权重，我们需要选择一个查询向量 $q$ ，假设我们的查询向量为 $q=[q_1, q_2]$ ，其中 $q_1$ 和 $q_2$ 是我们自己定义的两个数。

接下来，我们需要计算序列中每个元素的注意力权重。我们使用点积注意力来计算，即使用查询向量 $q$ 和序列中每个元素的特征向量 $k$ 进行点积，然后将结果进行缩放并应用softmax函数。注意力权重表示每个元素对于计算查询向量q的重要性。

我们先计算第一个元素 $x_1=[1,2]$ 与查询向量 $q$ 的点积，可以得到：

$e_1 = q \cdot x_1 = q_1 \cdot 1 + q_2 \cdot 2$

同样的，我们可以计算出序列中其他元素与查询向量 $q$ 的点积，得到：

$e_2 = q \cdot x_2 = q_1 \cdot 3 + q_2 \cdot 4$

$e_3 = q \cdot x_3 = q_1 \cdot 5 + q_2 \cdot 6$

接下来，我们将上述三个点积结果进行缩放并应用softmax函数，得到注意力权重向量 $a=[a_1, a_2, a_3]$ ，具体计算方法如下：

$a_i = \frac{\exp(e_i)}{\sum_{j=1}^{3} \exp(e_j)}$

例如，我们可以计算 $a_1$ 的值，具体如下：

$a_1 = \frac{\exp(e_1)}{\exp(e_1) + \exp(e_2) + \exp(e_3)}$

最后，我们将序列中的每个元素特征向量 $v$ 与相应的注意力权重 $a_i$ 相乘，并将所有加权元素求和，以获得最终的表示向量。具体来说，我们使用以下公式计算表示向量：

$\text{self-attention}(q, K, V) = \sum_{i=1}^{3} a_i \cdot x_i$

例如，我们可以计算表示向量的值，具体如下：

$\text{self-attention}(q, K, V) = a_1 \cdot x_1 + a_2 \cdot x_2 + a_3 \cdot x_3$

最终，我们将得到一个长度为2的表示向量，它是序列 $x$ 的加权平均值，其中每个元素的权重由Self-Attention计算得出。
好的，假设我们有一个句子“我爱自然语言处理”，我们想要计算其中每个词与其它词的相似度，可以使用self-attention来实现。

首先，我们需要将每个词的向量表示通过一个线性变换映射到三个不同的向量空间，分别用于计算该词的查询向量、键向量和值向量。具体地，我们可以使用三个不同的权重矩阵 $W_q$ 、 $W_k$ 、 $W_v$ 进行映射，如下所示：

$q_i = W_q x_i \ k_i = W_k x_i \ v_i = W_v x_i$

其中， $x_i$ 表示第 $i$ 个词的向量表示。

接下来，我们可以使用点积注意力（Dot-Product Attention）来计算每个词与其它词的相似度（或者说“重要性”）。具体地，对于第 $i$ 个词，我们可以通过将其查询向量 $q_i$ 与其它词的键向量 $k_j$ 进行点积运算，得到一个分数 $score_{ij}$ ：

$score_{ij} = q_i^T k_j$

然后，我们可以将所有分数进行softmax归一化，得到每个词对其它词的注意力分布：

$\alpha_{ij} = \frac{\exp{(score_{ij})}}{\sum_{k=1}^{n}\exp{(score_{ik})}}$

其中， $n$ 表示句子中的词数。注意力分布 $\alpha_{ij}$ 表示第 $i$ 个词对第 $j$ 个词的注意力权重，也可以看做是第 $i$ 个词与第 $j$ 个词的相似度（或者重要性）。

最后，我们可以将每个词的值向量 $v_i$ 与对应的注意力分布加权求和，得到该词的上下文向量表示：

$o_i = \sum_{j=1}^{n} \alpha_{ij} v_j$

这样，我们就可以通过self-attention计算出每个词的上下文向量表示，从而实现一些自然语言处理的任务，如情感分类、机器翻译、问答等。
注：
softmax函数是一种常用的激活函数，通常用于多分类问题中。softmax函数将一组任意实数转换为一个概率分布，其中每个数的概率等于它的指数除以所有数的指数之和。具体来说，给定一个实数向量 $\mathbf{z}=(z_1, z_2, ..., z_K)$ ，softmax函数可以定义为：

$\text{softmax}(\mathbf{z})_j = \frac{e^{z_j}}{\sum_{k=1}^K e^{z_k}}$

其中， $\text{softmax}(\mathbf{z})_j$ 表示 $\mathbf{z}$ 中第 $j$ 个元素的softmax值。因此，softmax函数将 $\mathbf{z}$ 中的每个元素转换为一个介于0和1之间的实数，并且所有softmax值之和为1，可以被解释为概率分布。

softmax函数的输出通常用于表示分类模型对于每个类别的预测概率，其中softmax值最大的类别被认为是模型的预测结果。

需要注意的是，softmax函数具有数值稳定性的问题，因为指数函数在输入较大时会产生数值溢出的问题。因此，通常使用一些技巧来缓解这个问题，例如将输入向量中的每个元素减去最大元素，以使输入向量的范围在一个合理的范围内。

pytorch self-attention 模型参数

参数	默认值	描述
input_dim	无默认值	输入张量的最后一维的维度。
num_heads	1	并行的头的数目。
bias	True	是否添加偏置项。
add_bias_kv	False	是否添加偏置项用于key和value的乘积。
add_zero_attn	False	是否添加一个全零的注意力权重，以便在序列长度不同时进行批处理。
dropout	0.0	Dropout概率。

pytorch self-attention 模型属性和方法

1.模型属性

属性	类型	描述
in_proj_weight	Tensor	输入变换的权重。
out_proj_weight	Tensor	输出变换的权重。
in_proj_bias	Tensor	输入变换的偏置项。
out_proj_bias	Tensor	输出变换的偏置项。
bias_k	Tensor	用于key的偏置项。
bias_v	Tensor	用于value的偏置项。

2.模型方法

方法	方法描述	参数描述	返回值
forward	计算自注意力	input (Tensor): 输入张量 attn_mask (Tensor, optional): 注意力掩码张量。 key_padding_mask (Tensor, optional): key张量的padding mask。 need_weights (bool, optional): 是否返回注意力权重张量。	输出张量和注意力权重张量（如果需要）。
reorder_cache	重新排列缓存	new_order (Tensor): 新的顺序。 incremental_state (List[Tensor]): 缓存。	重新排列后的缓存列表。
_get_input_buffer	获取输入缓存	incremental_state (List[Tensor]): 缓存。	输入缓存张量。
_set_input_buffer	设置输入缓存	incremental_state (List[Tensor]): 缓存。 buffer (Tensor): 输入缓存张量。	无返回值。
_reset_parameters	重置参数	无参数	无返回值。
setstate	设置状态	state (dict): 状态字典。	无返回值。
getstate	获取状态	无参数	状态字典。
prepare_for_onnx_export_	为ONNX导出准备	无参数	无返回值。
_prepare_for_onnx_export	为ONNX导出准备	无参数	无返回值。
from_pretrained	从预训练模型中加载权重	pretrained_dict (OrderedDict): 预训练模型的权重字典。	SelfAttention对象。
register_buffer	注册缓存张量	name (str): 缓存张量的名称。 tensor (Tensor): 缓存张量。	无返回值。
register_parameter	注册参数张量	name (str): 参数张量的名称。 param (Parameter): 参数张量。	无返回值。
named_parameters	返回参数张量的迭代器	prefix (str, optional): 名称前缀	参数张量的迭代器。
parameters	返回参数张量的迭代器	无参数	参数张量的迭代器。
named_buffers	返回缓存张量的迭代器	prefix (str, optional): 名称前缀	缓存张量的迭代器。
buffers	返回缓存张量的迭代器	无参数	缓存张量的迭代器。
train	设置模型为训练模式	mode (bool): 是否为训练模式	无返回值。
eval	设置模型为评估模式	无参数	无返回值。
zero_grad	将所有参数的梯度设置为0	无参数	无返回值。
state_dict	返回模型的状态字典	destination (str, optional): 目标设备	模型的状态字典。
load_state_dict	从状态字典中加载权重	state_dict (dict): 状态字典	无返回值。
cuda	将模型移动到CUDA设备	device (int, optional): 设备的索引号	移动后的模型。
to	将模型移动到指定设备	device (str, torch.device, optional): 目标设备	移动后的模型。
share_memory	使模型共享内存	无参数	无返回值。
extra_repr	返回模型的额外描述	无参数	模型的额外描述。
repr	返回模型的字符串表示	无参数	模型的字符串表示。
register_forward_pre_hook	注册前向传递的钩子函数	hook (Callable[…, None]) – 钩子函数	无返回值。
register_forward_hook	注册前向传递的钩子函数	hook (Callable[…, None]) – 钩子函数	无返回值。
register_backward_hook	注册反向传播的钩子函数	hook (Callable[…, None]) – 钩子函数	无返回值。
detach	返回一个新的没有梯度的张量	无参数	新的张量。
type_as	返回与输入张量类型相同的张量	tensor (Tensor) – 输入张量	新的张量。
size	返回张量的尺寸	dim (int, optional) – 维度	张量的尺寸。
numel	返回张量中元素的数量	无参数	张量中元素的数量。

损失函数

Self-attention 模型的损失函数通常是交叉熵损失函数或均方误差损失函数，具体取决于任务类型。

优化算法

优化算法可以采用常见的优化算法，如随机梯度下降（SGD）、Adam 等。

防止过拟合的措施

Self-attention 模型防止过拟合的措施包括正则化、dropout 和早停等方法。其中，正则化可以通过 L1 或 L2 约束模型参数的大小，dropout 可以随机删掉一些神经元，早停可以在验证集上监控模型的性能，当模型在验证集上的性能不再提升时就停止训练。

代码示例

import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np
import matplotlib.pyplot as plt

# 创建测试数据
n_samples = 200
x = np.linspace(0, 10*np.pi, n_samples)
y = np.sin(x) + 0.05*np.random.randn(n_samples)
plt.plot(x, y)
plt.show()

# 数据预处理
seq_len = 10
data = np.zeros((n_samples-seq_len, seq_len, 1))
target = np.zeros((n_samples-seq_len, 1))
for i in range(n_samples-seq_len):
    data[i,:,0] = y[i:i+seq_len]
    target[i,0] = y[i+seq_len]
train_data = torch.from_numpy(data).float()
train_target = torch.from_numpy(target).float()

# 模型搭建
class SelfAttention(nn.Module):
    def __init__(self, embed_dim):
        super(SelfAttention, self).__init__()
        self.embed_dim = embed_dim
        self.fc_query = nn.Linear(embed_dim, embed_dim)
        self.fc_key = nn.Linear(embed_dim, embed_dim)
        self.fc_value = nn.Linear(embed_dim, embed_dim)
        self.softmax = nn.Softmax(dim=-1)
        self.dropout = nn.Dropout(p=0.1)
    
    def forward(self, x):
        query = self.fc_query(x)
        key = self.fc_key(x)
        value = self.fc_value(x)
        attn_weights = torch.bmm(query, key.transpose(1,2))
        attn_weights = self.softmax(attn_weights)
        attn_weights = self.dropout(attn_weights)
        out = torch.bmm(attn_weights, value)
        return out

class Model(nn.Module):
    def __init__(self, seq_len, embed_dim, hidden_dim):
        super(Model, self).__init__()
        self.seq_len = seq_len
        self.embed_dim = embed_dim
        self.hidden_dim = hidden_dim
        self.attention = SelfAttention(embed_dim)
        self.fc1 = nn.Linear(embed_dim*seq_len, hidden_dim)
        self.fc2 = nn.Linear(hidden_dim, 1)
    
    def forward(self, x):
        x = self.attention(x)
        x = x.view(-1, self.embed_dim*self.seq_len)
        x = torch.relu(self.fc1(x))
        x = self.fc2(x)
        return x

# 模型参数设置
seq_len = 10
embed_dim = 8
hidden_dim = 64
lr = 0.01
epochs = 100

# 模型实例化
model = Model(seq_len, embed_dim, hidden_dim)

# 定义损失函数和优化器
criterion = nn.MSELoss()
optimizer = optim.Adam(model.parameters(), lr=lr)

# 训练模型
loss_history = []
for i in range(epochs):
    # 前向传播
    output = model(train_data)
    loss = criterion(output, train_target)
    # 反向传播
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
    # 保存loss
    loss_history.append(loss.item())
    # 打印loss
    if i % 10 == 0:
        print('Epoch [{}/{}], Loss: {:.4f}'.format(i+1, epochs, loss.item()))

# 可视化loss
plt.plot(loss_history)
plt.title('Training Loss')
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.show()

# 模型效果评估
model.eval()
test_data = train_data[:10,:,:]
pred = model(test_data).detach().numpy()
truth = train_target[:10,:].detach().numpy()
plt.plot(x[:10+seq_len], np.concatenate([test_data.squeeze(), truth.squeeze()]))
plt.plot(x[seq_len:10+seq_len], pred.squeeze(), label='Prediction')
plt.legend()
plt.show()

# 模型保存
torch.save(model.state_dict(), 'self_attention_model.pth')