深度学习---------------------------------自注意力和位置编码

news/2024/10/8 7:51:09/

目录

  • 自注意力
  • 跟CNN、RNN对比
  • 位置编码
    • 位置编码矩阵
  • 绝对位置信息
  • 相对位置信息
  • 总结
  • 自注意力和位置编码
    • 自注意力
      • 该部分总代码
    • 位置编码
      • 该部分总代码
    • 二进制表示
      • 在编码维度上降低频率
      • 该部分总代码

自注意力

给定一个由词元组成的输入序列 x 1 x_1 x1​,…, x n x_n xn​，∀ x i x_i xi​∈ R d R^d Rd

自注意力池化层将 x i x_i xi​当作key、value、query来对序列抽取特征得到 y 1 y_1 y1​,… y n y_n yn​，这里

在这里插入图片描述

在这里插入图片描述



跟CNN、RNN对比

在这里插入图片描述

CNN：k：窗口的大小（每次看一个k大小的东西）
     n：序列长度
     d：输入和输出的通道数量

并行度：每一个输出可以自己并行做运算.

最长路径：O(n/k)

在这里插入图片描述



RNN：
时间复杂度：序列长度为为n，当更新循环神经网络的隐状态时， d×d的权重矩阵和d维隐状态的乘法计算复杂度为O( d 2 d^2 d2)，所以复杂度为O(n d 2 d^2 d2)

并行度：每一个 y i y_i yi​的输出要等 y i − 1 y_{i-1} yi−1​算完

在这里插入图片描述

最长路径： x 1 x_1 x1​的信息要一直传递到 x n x_n xn​，需要经过一个O(n)的一个序列。

在这里插入图片描述



自注意力：在自注意力中，查询、键和值都是n×d矩阵。其中n×d矩阵乘以d×n矩阵，之后输出的n×n矩阵乘以n×d矩阵。因此，自注意力具有O( n 2 d n^2d n2d)计算复杂度。

并行度：O(n)

最长路径：O(1)，也就是说任何一个地方的信息要到任何一个输出的话，是可以直接过去的。

在这里插入图片描述
自注意力适合比较长的文本，因为能看的比较宽。但计算复杂度比较高。



位置编码

跟CNN/RNN不同，自注意力并没有记录位置信息。

如果纯用自注意力机制来做序列模型的话，那么没有位置信息，那肯定是有问题的。所以一个加入位置信息的办法是位置编码。
它不是把位置信息加入到模型里面，因为一旦位置信息加入到模型里面总会有各种问题，CNN的会导致每一次得看一个比较长的序列，RNN的话并行度就低了，所以不是改变注意力机制本身，然后就把位置编码信息放到输入里，让输入有位置信息。

    假设长度为n的序列是X∈ R n × d R^{n×d} Rn×d，那么使用位置编码矩阵P∈ R n × d R^{n×d} Rn×d来输出X+P作为自编码输入。

P的元素计算：

在这里插入图片描述


位置编码矩阵

在这里插入图片描述
X坐标是它的一个行数，就是说对第i个序列加的那个值是什么？然后四根曲线对应的是第6、7、8、9列

对每一个样本，它的维度每一个加的值是不一样的。样本和样本之间也是不一样的。

在这里插入图片描述
在这里插入图片描述



绝对位置信息

在这里插入图片描述



相对位置信息

在这里插入图片描述



总结

①自注意力池化层将 x i x_i xi​当做key、value、query来对序列抽取特征。

②完全并行、最长序列为1、但对长序列计算复杂度高。

③位置编码在输入中加入位置信息，使得自注意力能够记忆位置信息。



自注意力和位置编码

import math
import torch
from torch import nn
from d2l import torch as d2l


自注意力

from d2l import torch as d2lnum_hiddens, num_heads = 100, 5
# 创建多头注意力实例
# 输入参数为隐藏单元数量、查询维度、键维度、值维度、头的数量和dropout率
attention = d2l.MultiHeadAttention(num_hiddens, num_hiddens, num_hiddens,num_hiddens, num_heads, 0.5)
# 将多头注意力设置为评估模式，不进行训练
print(attention.eval())

在这里插入图片描述


# 设置批量大小、查询数和有效长度
batch_size, num_queries, valid_lens = 2, 4, torch.tensor([3, 2])
X = torch.ones((batch_size, num_queries, num_hiddens))
# 对输入张量X应用多头注意力机制，并获取输出的形状
print(attention(X, X, X, valid_lens).shape)

在这里插入图片描述


该部分总代码

from d2l import torch as d2lnum_hiddens, num_heads = 100, 5
# 创建多头注意力实例
# 输入参数为隐藏单元数量、查询维度、键维度、值维度、头的数量和dropout率
attention = d2l.MultiHeadAttention(num_hiddens, num_hiddens, num_hiddens,num_hiddens, num_heads, 0.5)
attention.eval()
# 设置批量大小、查询数和有效长度
batch_size, num_queries, valid_lens = 2, 4, torch.tensor([3, 2])
X = torch.ones((batch_size, num_queries, num_hiddens))
# 对输入张量X应用多头注意力机制，并获取输出的形状
print(attention(X, X, X, valid_lens).shape)


位置编码

class PositionalEncoding(nn.Module):# 初始化函数，接收隐藏单元数量、dropout率和最大序列长度作为输入def __init__(self, num_hiddens, dropout, max_len=1000):super(PositionalEncoding, self).__init__()self.dropout = nn.Dropout(dropout)# 创建一个形状为(batch_size, max_len, num_hiddens)的位置编码张量P，初始化为全0self.P = torch.zeros((1, max_len, num_hiddens))# 生成位置编码矩阵X，其中每一行表示一个位置的编码，编码方式采用sin和cos函数# 编码公式：X[i, j] = sin(i / 10000^(2j / num_hiddens)) 或 cos(i / 10000^(2j / num_hiddens))X = torch.arange(max_len, dtype=torch.float32).reshape(-1, 1) / torch.pow(10000, torch.arange(0, num_hiddens, 2,dtype=torch.float32) / num_hiddens)# 第一维度、第二维的所有元素，第三维将位置编码矩阵中的偶数维度的元素替换为sin函数的结果self.P[:, :, 0::2] = torch.sin(X)# 将位置编码矩阵中的奇数维度的元素替换为cos函数的结果self.P[:, :, 1::2] = torch.cos(X)def forward(self, X):# 将位置编码张量P与输入张量X相加，并将结果移动到与X相同的设备上# self.P[:, :X.shape[1], :]第二维从索引0到 X 的第二维大小的所有元素➡确保P的第二维和X的第二维一致，因为可能是不同的序列长度，为了动态的适应不同长度的输入X = X + self.P[:, :X.shape[1], :].to(X.device)# 对相加后的结果应用dropout，并返回结果return self.dropout(X)



该部分总代码

import torch
from torch import nn
from d2l import torch as d2l# 位置编码
class PositionalEncoding(nn.Module):# 初始化函数，接收隐藏单元数量、dropout率和最大序列长度作为输入def __init__(self, num_hiddens, dropout, max_len=1000):super(PositionalEncoding, self).__init__()self.dropout = nn.Dropout(dropout)# 创建一个形状为(batch_size, max_len, num_hiddens)的位置编码张量P，初始化为全0self.P = torch.zeros((1, max_len, num_hiddens))# 生成位置编码矩阵X，其中每一行表示一个位置的编码，编码方式采用sin和cos函数# 编码公式：X[i, j] = sin(i / 10000^(2j / num_hiddens)) 或 cos(i / 10000^(2j / num_hiddens))X = torch.arange(max_len, dtype=torch.float32).reshape(-1, 1) / torch.pow(10000, torch.arange(0, num_hiddens, 2,dtype=torch.float32) / num_hiddens)# 第一维度、第二维的所有元素，第三维将位置编码矩阵中的偶数维度的元素替换为sin函数的结果self.P[:, :, 0::2] = torch.sin(X)# 将位置编码矩阵中的奇数维度的元素替换为cos函数的结果self.P[:, :, 1::2] = torch.cos(X)def forward(self, X):# 将位置编码张量P与输入张量X相加，并将结果移动到与X相同的设备上# self.P[:, :X.shape[1], :]第二维从索引0到 X 的第二维大小的所有元素➡确保P的第二维和X的第二维一致，因为可能是不同的序列长度，为了动态的适应不同长度的输入X = X + self.P[:, :X.shape[1], :].to(X.device)# 对相加后的结果应用dropout，并返回结果return self.dropout(X)num_hiddens, num_heads = 100, 5
# 创建多头注意力实例
# 输入参数为隐藏单元数量、查询维度、键维度、值维度、头的数量和dropout率
attention = d2l.MultiHeadAttention(num_hiddens, num_hiddens, num_hiddens,num_hiddens, num_heads, 0.5)
# 将多头注意力设置为评估模式，不进行训练
attention.eval()# 设置批量大小、查询数和有效长度
batch_size, num_queries, valid_lens = 2, 4, torch.tensor([3, 2])
X = torch.ones((batch_size, num_queries, num_hiddens))
# 对输入张量X应用多头注意力机制，并获取输出的形状
print(attention(X, X, X, valid_lens).shape)


行代表标记在序列中的位置，列代表位置编码的不同维度。

import torch
from torch import nn
from d2l import torch as d2l# 位置编码
class PositionalEncoding(nn.Module):# 初始化函数，接收隐藏单元数量、dropout率和最大序列长度作为输入def __init__(self, num_hiddens, dropout, max_len=1000):super(PositionalEncoding, self).__init__()self.dropout = nn.Dropout(dropout)# 创建一个形状为(batch_size, max_len, num_hiddens)的位置编码张量P，初始化为全0self.P = torch.zeros((1, max_len, num_hiddens))# 生成位置编码矩阵X，其中每一行表示一个位置的编码，编码方式采用sin和cos函数# 编码公式：X[i, j] = sin(i / 10000^(2j / num_hiddens)) 或 cos(i / 10000^(2j / num_hiddens))X = torch.arange(max_len, dtype=torch.float32).reshape(-1, 1) / torch.pow(10000, torch.arange(0, num_hiddens, 2,dtype=torch.float32) / num_hiddens)# 第一维度、第二维的所有元素，第三维将位置编码矩阵中的偶数维度的元素替换为sin函数的结果self.P[:, :, 0::2] = torch.sin(X)# 将位置编码矩阵中的奇数维度的元素替换为cos函数的结果self.P[:, :, 1::2] = torch.cos(X)def forward(self, X):# 将位置编码张量P与输入张量X相加，并将结果移动到与X相同的设备上# self.P[:, :X.shape[1], :]第二维从索引0到 X 的第二维大小的所有元素➡确保P的第二维和X的第二维一致，因为可能是不同的序列长度，为了动态的适应不同长度的输入X = X + self.P[:, :X.shape[1], :].to(X.device)# 对相加后的结果应用dropout，并返回结果return self.dropout(X)# 设置位置编码的维度和序列的长度
encoding_dim, num_steps = 32, 60
pos_encoding = PositionalEncoding(encoding_dim, 0)
pos_encoding.eval()
# 应用位置编码器到全0张量上，得到位置编码后的张量X
X = pos_encoding(torch.zeros((1, num_steps, encoding_dim)))
# 获取位置编码器中的位置编码张量P，截取与X相同长度的部分
P = pos_encoding.P[:, :X.shape[1], :]
# 绘制位置编码张量P中特定维度的子集
d2l.plot(torch.arange(num_steps), P[0, :, 6:10].T, xlabel='Row (position)',figsize=(6, 2.5), legend=["Col %d" % d for d in torch.arange(6, 10)])
d2l.plt.show()

在这里插入图片描述



二进制表示

for i in range(8):# 打印当前数字的二进制表示，使用字符串格式化进行对齐和补零print(f'{i} in binary is {i:>03b}')

在这里插入图片描述


在编码维度上降低频率

# 在编码维度上降低频率
# 从位置编码张量P中获取第一个样本的编码部分，并添加两个维度
P = P[0, :, :].unsqueeze(0).unsqueeze(0)
# 显示热力图，以编码维度为x轴，位置为y轴
d2l.show_heatmaps(P, xlabel='Column (encoding dimension)',ylabel='Row (position)', figsize=(3.5, 4), cmap='Blues')

在这里插入图片描述



该部分总代码

import torch
from torch import nn
from d2l import torch as d2l# 位置编码
class PositionalEncoding(nn.Module):# 初始化函数，接收隐藏单元数量、dropout率和最大序列长度作为输入def __init__(self, num_hiddens, dropout, max_len=1000):super(PositionalEncoding, self).__init__()self.dropout = nn.Dropout(dropout)# 创建一个形状为(batch_size, max_len, num_hiddens)的位置编码张量P，初始化为全0self.P = torch.zeros((1, max_len, num_hiddens))# 生成位置编码矩阵X，其中每一行表示一个位置的编码，编码方式采用sin和cos函数# 编码公式：X[i, j] = sin(i / 10000^(2j / num_hiddens)) 或 cos(i / 10000^(2j / num_hiddens))X = torch.arange(max_len, dtype=torch.float32).reshape(-1, 1) / torch.pow(10000, torch.arange(0, num_hiddens, 2,dtype=torch.float32) / num_hiddens)# 第一维度、第二维的所有元素，第三维将位置编码矩阵中的偶数维度的元素替换为sin函数的结果self.P[:, :, 0::2] = torch.sin(X)# 将位置编码矩阵中的奇数维度的元素替换为cos函数的结果self.P[:, :, 1::2] = torch.cos(X)def forward(self, X):# 将位置编码张量P与输入张量X相加，并将结果移动到与X相同的设备上# self.P[:, :X.shape[1], :]第二维从索引0到 X 的第二维大小的所有元素➡确保P的第二维和X的第二维一致，因为可能是不同的序列长度，为了动态的适应不同长度的输入X = X + self.P[:, :X.shape[1], :].to(X.device)# 对相加后的结果应用dropout，并返回结果return self.dropout(X)# 设置位置编码的维度和序列的长度
encoding_dim, num_steps = 32, 60
pos_encoding = PositionalEncoding(encoding_dim, 0)
pos_encoding.eval()
# 应用位置编码器到全0张量上，得到位置编码后的张量X
X = pos_encoding(torch.zeros((1, num_steps, encoding_dim)))
# 获取位置编码器中的位置编码张量P，截取与X相同长度的部分
P = pos_encoding.P[:, :X.shape[1], :]
# 在编码维度上降低频率
# 从位置编码张量P中获取第一个样本的编码部分，并添加两个维度
P = P[0, :, :].unsqueeze(0).unsqueeze(0)
# 显示热力图，以编码维度为x轴，位置为y轴
d2l.show_heatmaps(P, xlabel='Column (encoding dimension)',ylabel='Row (position)', figsize=(3.5, 4), cmap='Blues')
d2l.plt.show()

http://www.ppmy.cn/news/1536025.html

相关文章

Steam Deck掌机可装“黑苹果” 开发者成功安装macOS 15 Sequoia

Steam Deck掌机可装“黑苹果” 开发者成功安装macOS 15 Sequoia

在Steam Deck掌机上运行Windows 11相对轻松，但要让其成功搭载“黑苹果”系统则颇具挑战性。近日，有博主勇于尝试，将macOS 15 Sequoia安装到了Steam Deck上。 开发者kaitlyn在X平台上分享道：“在朋友们的鼎力相助下，我…
阅读更多...
基于SpringBoot+Vue的科研课题项目管理系统源码

基于SpringBoot+Vue的科研课题项目管理系统源码

文章目录 1.技术架构2.主要功能3.获取方式 1.技术架构 后端：SpringBoot 前端：Vue – Element UI 2.主要功能 登录 /注销、 用户管理、项目管理、申报管理、变更管理、 结题管理、角色管理、权限管理、数据字典等功能 3.获取方式 点击下方名片&a…
阅读更多...
十大时间序列预测模型

十大时间序列预测模型

目录 1. 自回归模型 原理 核心公式 推导过程： 完整案例 2. 移动平均模型 原理 核心公式 推导过程： 完整案例 3. 自回归移动平均模型 原理 核心公式 推导过程： 完整案例 4. 自回归积分移动平均模型 原理 核心公式 推导过程 完整案例 5. 季节性自回归积分…
阅读更多...
keras yolo8目标检测

keras yolo8目标检测

是从coco数据集提取其中的veh_ids[3,6,8,10] labels[car,bus,truck,traffic light]来做目标检测,分别表示汽车,公交车，卡车，交通灯,用的backbone keras_cv.models.YOLOV8Backbone.from_preset( "yolo_v8_m_backbone_coco" ),不用预训练…
阅读更多...
React生命周期案例详解

React生命周期案例详解

React 组件的生命周期是指组件从创建、渲染、更新到卸载的整个过程。在 React 16 及之前的版本中，生命周期方法被分为几个不同的阶段：挂载（Mounting）、更新（Updating）、卸载（Unmounting&#xf…
阅读更多...
MobX-Miniprogram：微信小程序的状态管理利器

MobX-Miniprogram：微信小程序的状态管理利器

MobX-Miniprogram：微信小程序的状态管理利器 在开发微信小程序时，随着应用复杂度的提升，状态管理成为了一个不可忽视的问题。传统的通过全局变量或wx.setStorageSync/wx.getStorageSync进行状态管理的方式，不仅代码可读性差&…
阅读更多...
Node.JS 版本管理工具 Fnm 安装及配置（Windows）

Node.JS 版本管理工具 Fnm 安装及配置（Windows）

Fnm 安装及配置（Windows） Fnm（Fast Node Manager）🚀 一个快速而简单的 Node.js 版本管理工具，使用 Rust 编写。 1 安装 官网：Fnm（镜像网站 ）。下载：Fnm&a…
阅读更多...
【SQL】掌握SQL查询技巧：数据筛选与限制

【SQL】掌握SQL查询技巧：数据筛选与限制

目录 1. DISTINCT：避免重复记录1.1 示意图1.2 使用场景 2. LIMIT：控制查询结果的数量2.1 示意图2.2 使用场景 3. OFFSET：跳过前几行3.1 示意图3.2 使用场景 4. WHERE子句：精细控制数据过滤4.1 示意图4.2 运算符详细说明4.3 基本条…
阅读更多...
最新文章

Copyright @ 2022~2023