Attention相关问题笔试解析。

Attention相关问题笔试解析。

  • 题目描述一：【选择】
  • 题目描述二：【简答】
  • 题目描述三：【代码】
  • Scaled Dot-Product Attention：下面是用PyTorch实现的一个Attention机制的代码。这个实现包括一个简单的Scaled Dot-Product Attention机制和一个Multi-Head Attention机制。
  • Multi-Head Attention：
  • 无注释背诵版：

题目描述一：【选择】

Attention 机制中，输入QKV的shape为[N,L,D],请问 输出的shape和attention score 的shape分别是多少?
A. 输出:[N,L,D] attention score: [N,L,L,D]
B.输出:[N,L,D] attention score: [N,L,L]
C.输出:[N,L,L] attention score: [N,L,L,D]
D.输出:[N,L,L] attention score: [N,L,L]

正确答案是：B
在这里插入图片描述
在这里插入图片描述

题目描述二：【简答】

Transformer的核心思想是什么?它较之前的方法有什么优势(举例说明)?他和CNN有什么联系(开放问题)?

答：
Transformer的核心思想是使用自注意力机制（Self-Attention Mechanism）来建模序列数据中的依赖关系，取代传统的递归神经网络（RNN）和卷积神经网络（CNN）在处理序列任务时的局限性。具体来说，Transformer的架构主要由编码器（Encoder）和解码器（Decoder）组成，每个编码器和解码器模块由多头自注意力机制（Multi-Head Self-Attention Mechanism）和前馈神经网络（Feed-Forward Neural Network）组成。
在这里插入图片描述
在这里插入图片描述在这里插入图片描述
总结：
Transformer通过自注意力机制实现了高效的序列建模，克服了RNN在长距离依赖和并行处理上的局限性。它在自然语言处理（如机器翻译、文本生成）和其他序列任务中表现出色。虽然与CNN在结构上不同，但两者都能高效地进行特征提取和处理，并利用并行计算加速训练和推理过程。

题目描述三：【代码】

请使用torch 或者numpy 编写attention机制。QKV都是三维张量。

  • 实现一个attention 类
  • 需要说明函数入参含义、输入输出shape
  • 完成简单的scaled dot-product attention即可
  • 有把握的，可以实现multi-head attentlon

Scaled Dot-Product Attention：下面是用PyTorch实现的一个Attention机制的代码。这个实现包括一个简单的Scaled Dot-Product Attention机制和一个Multi-Head Attention机制。

首先，我们实现一个简单的Scaled Dot-Product Attention机制。

import torch
import torch.nn.functional as F

class ScaledDotProductAttention:
    def __init__(self, d_k):
        """
        初始化函数
        :param d_k: int, 每个attention头的维度
        """
        self.d_k = d_k

    def __call__(self, Q, K, V):
        """
        执行Scaled Dot-Product Attention
        :param Q: torch.Tensor, 形状为[N, L, D]
        :param K: torch.Tensor, 形状为[N, L, D]
        :param V: torch.Tensor, 形状为[N, L, D]
        :return: 输出张量的形状为[N, L, D], attention score的形状为[N, L, L]
        """
        # 计算注意力分数
        scores = torch.matmul(Q, K.transpose(-2, -1)) / torch.sqrt(torch.tensor(self.d_k, dtype=torch.float32))
        attention_scores = F.softmax(scores, dim=-1)
        
        # 计算注意力输出
        attention_output = torch.matmul(attention_scores, V)
        
        return attention_output, attention_scores

# 使用示例
N, L, D = 2, 5, 64
d_k = D

Q = torch.rand(N, L, D)
K = torch.rand(N, L, D)
V = torch.rand(N, L, D)

attention = ScaledDotProductAttention(d_k)
output, scores = attention(Q, K, V)

print(f"Output shape: {output.shape}")
print(f"Attention scores shape: {scores.shape}")

Multi-Head Attention：

接下来，我们实现一个Multi-Head Attention机制，它是基于多个Scaled Dot-Product Attention头的。

class MultiHeadAttention:
    def __init__(self, num_heads, d_model):
        """
        初始化函数
        :param num_heads: int, 注意力头的数量
        :param d_model: int, 输入的特征维度
        """
        assert d_model % num_heads == 0, "d_model必须是num_heads的整数倍"
        
        self.num_heads = num_heads
        self.d_model = d_model
        self.d_k = d_model // num_heads
        
        self.W_q = torch.nn.Linear(d_model, d_model)
        self.W_k = torch.nn.Linear(d_model, d_model)
        self.W_v = torch.nn.Linear(d_model, d_model)
        self.W_o = torch.nn.Linear(d_model, d_model)
        
        self.attention = ScaledDotProductAttention(self.d_k)

    def split_heads(self, x, batch_size):
        """
        将最后一维分裂成(num_heads, d_k)形状，并将张量重塑为(batch_size * num_heads, seq_length, d_k)
        :param x: torch.Tensor, 形状为(batch_size, seq_length, d_model)
        :param batch_size: int, batch大小
        :return: torch.Tensor, 形状为(batch_size * num_heads, seq_length, d_k)
        """
        x = x.view(batch_size, -1, self.num_heads, self.d_k)
        return x.transpose(1, 2).contiguous().view(batch_size * self.num_heads, -1, self.d_k)

    def __call__(self, Q, K, V):
        """
        执行Multi-Head Attention
        :param Q: torch.Tensor, 形状为[N, L, D]
        :param K: torch.Tensor, 形状为[N, L, D]
        :param V: torch.Tensor, 形状为[N, L, D]
        :return: 输出张量的形状为[N, L, D], attention score的形状为[N * num_heads, L, L]
        """
        batch_size = Q.size(0)
        
        Q = self.split_heads(self.W_q(Q), batch_size)
        K = self.split_heads(self.W_k(K), batch_size)
        V = self.split_heads(self.W_v(V), batch_size)
        
        attention_output, attention_scores = self.attention(Q, K, V)
        
        attention_output = attention_output.view(batch_size, self.num_heads, -1, self.d_k)
        attention_output = attention_output.transpose(1, 2).contiguous().view(batch_size, -1, self.d_model)
        
        return self.W_o(attention_output), attention_scores.view(batch_size, self.num_heads, -1, attention_scores.size(-1))

# 使用示例
N, L, D = 2, 5, 64
num_heads = 8
d_model = D

Q = torch.rand(N, L, D)
K = torch.rand(N, L, D)
V = torch.rand(N, L, D)

multi_head_attention = MultiHeadAttention(num_heads, d_model)
output, scores = multi_head_attention(Q, K, V)

print(f"Output shape: {output.shape}")
print(f"Attention scores shape: {scores.shape}")

在这里插入图片描述

以上实现了简单的Scaled Dot-Product Attention和Multi-Head Attention机制，并包含示例代码用于测试。

无注释背诵版：

  1. __init__是初始化d_k是每个向量的维度
  2. torch.matmul，转置K.transpose(-2, -1)，/根号sqrt(d_k)
  3. F.softmax(scores, dim=-1)得注意力分数
  4. torch.matmul与V乘得输出
import torch
import torch.nn.functional as F

class Attention:
    def __init__(self, d_k): 
        self.d_k = d_k
    def __call__(self, Q, K, V):
        scores = torch.matmul(Q, K.transpose(-2, -1)) / torch.sqrt(torch.tensor(self.d_k, dtype=torch.float32))
        attention_scores = F.softmax(scores, dim=-1)
        attention_output = torch.matmul(attention_scores, V)
        return attention_output, attention_scores
    
class MultiHeadAttention:
    def __init__(self, num_heads, d_model):
        assert d_model % num_heads == 0
        self.nums_heads = num_heads
        self.d_model = d_model
        self.d_k = d_model // num_heads
        self.W_q = torch.nn.Linear(d_model, d_model)
        self.W_k = torch.nn.Linear(d_model, d_model)
        self.W_v = torch.nn.Linear(d_model, d_model)
        self.W_o = torch.nn.Linear(d_model, d_model)
        self.attention = Attention(self.d_k)

    def split_heads(self, x, batch_size):
        x = x.view(batch_size, -1, self.nums_heads, self.d_k)
        return x.transpose(1, 2).contiguous().view(batch_size * self.nums_heads, -1, self.d_k)
    
    def __call__(self, Q, K, V):
        batch_size = Q.size(0)
        Q = self.split_heads(self.W_q(Q), batch_size)
        K = self.split_heads(self.W_k(K), batch_size)
        V = self.split_heads(self.W_v(V), batch_size)
        attention_output, attention_score = self.attention(Q, K, V)
        attention_output = attention_output.view(batch_size, self.nums_heads, -1, self.d_k)
        attention_output = attention_output.transpose(1, 2).contiguous().view(batch_size, -1, self.d_model)
        return self.W_o(attention_output), attention_score.view(batch_size, self.nums_heads, -1, attention_score.size(-1))

使用示例

N, L, D = 2, 5, 64
num_heads = 8
d_model = D

Q = torch.rand(N, L, D)
K = torch.rand(N, L, D)
V = torch.rand(N, L, D)

multi_head_attention = MultiHeadAttention(num_heads, d_model)
output, scores = multi_head_attention(Q, K, V)

print(f"Output shape: {output.shape}")
print(f"Attention scores shape: {scores.shape}")
创作不易，观众老爷们请留步… 动起可爱的小手，点个赞再走呗 (๑◕ܫ￩๑)
欢迎大家关注笔者，你的关注是我持续更博的最大动力


原创文章，转载告知，盗版必究

在这里插入图片描述

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

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/644894.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

【大模型部署】在C# Winform中使用文生图Stable Diffusion XL 模型

【大模型部署】在C# Winform中使用文生图Stable Diffusion XL 模型

【大模型部署】在C# Winform中使用文生图Stable Diffusion XL 模型 前言 整了一个在C# Winform中调用文生图Stable Diffusion XL的小程序，基于百度智能云千帆平台 步骤 如何注册百度智能云和创建应用，获取API 密钥等和在之前的博客中基本相同&#…
阅读更多...
P6160 [Cnoi2020] 向量

P6160 [Cnoi2020] 向量

[Cnoi2020] 向量 题目背景 向量(vector)，指具有大小(Magnitude)和方向(Direction) 的量。 与向量对应的量叫做数量(Scalar)，数量只有大小，没有方向。 对于 Cirno 来说，整天环绕氷屋的旋转 Sangetsusei 们是向量而不是数量。 Sun…
阅读更多...
spring模块（三）Spring AOP(2)使用

spring模块（三）Spring AOP(2)使用

一、demo 1、spring项目 &#xff08;1&#xff09;pom <dependencies><dependency><groupId>org.springframework</groupId><artifactId>spring-core</artifactId><version>4.3.13.RELEASE</version></dependency>&l…
阅读更多...
[数组查找]1.图解线性查找及其代码实现

[数组查找]1.图解线性查找及其代码实现

线性查找 线性查找是一种在数组中查找数据的算法。与二分查找不同&#xff0c;即便数据没有按顺序存储&#xff0c;也可以应用线性查找。线性查找的操作很简单&#xff0c;只要在数组中从头开始依次往下查找即可。虽然存储的数据类型没有限制&#xff0c;但为了便于理解&#x…
阅读更多...
CorelCAD v2022.5 解锁版 安装教程（2D制图 3D设计和打印的简化软件）

CorelCAD v2022.5 解锁版 安装教程（2D制图 3D设计和打印的简化软件）

前言 CorelCAD&#xff0c;加拿大Corel公司开发的一款适用于2D制图、3D设计和打印的简化版CAD软件。它是款专业的2D制图和3D设计软件&#xff0c;拥有行业标准文件兼容性&#xff0c;支持 .DWG、.STL、.PDF、 .CDR*等文件格式&#xff0c;轻松实现协作和项目共享&#xff0c;利…
阅读更多...
电商零基础的人，可以做抖音小店吗？它操作难度大吗？

电商零基础的人，可以做抖音小店吗？它操作难度大吗？

大家好&#xff0c;我是电商糖果 随着短视频电商的热度越来越大&#xff0c;很多消费者都有了抖音购物的习惯。 于是入驻抖音开店就成了很多人创业做电商的首选。 可是抖音推出的电商项目——抖音小店&#xff0c;出来的时间不是很久&#xff0c;很多人对它了解也不深&#…
阅读更多...
2024年5月LLM最新排名：GPT-4o出道即巅峰！国内3个大模型榜上有名！

2024年5月LLM最新排名：GPT-4o出道即巅峰！国内3个大模型榜上有名！

大家好&#xff0c;我是木易&#xff0c;一个持续关注AI领域的互联网技术产品经理&#xff0c;国内Top2本科&#xff0c;美国Top10 CS研究生&#xff0c;MBA。我坚信AI是普通人变强的“外挂”&#xff0c;所以创建了“AI信息Gap”这个公众号&#xff0c;专注于分享AI全维度知识…
阅读更多...
设计模式 17 组合模式 Composite Pattern

设计模式 17 组合模式 Composite Pattern

设计模式 17 组合模式 Composite Pattern 1.定义 组合模式&#xff08;Composite Pattern&#xff09;&#xff0c;又叫部分整体模式&#xff0c;是用于把一组相似的对象当作一个单一的对象。组合模式依据树形结构来组合对象&#xff0c;用来表示部分以及整体层次。这种类型的设…
阅读更多...
Java进阶学习笔记21——泛型概念、泛型类、泛型接口

Java进阶学习笔记21——泛型概念、泛型类、泛型接口

泛型&#xff1a; 定义类、接口、方法的时候&#xff0c;同时声明了一个或者多个类型变量&#xff08;如: <E>&#xff09;,称之为泛型类、泛型接口、泛型方法&#xff0c;我们统称之为泛型。 说明这是一个泛型类。 如果不使用泛型&#xff0c;我们可以往ArrayList中传…
阅读更多...
浅谈网络安全态势感知

浅谈网络安全态势感知

前言 网络空间环境日趋复杂&#xff0c;随着网络攻击种类和频次的增加&#xff0c;自建强有力的网络安全防御系统成为一个国家发展战略的一部分&#xff0c;而网络态势感知是实现网络安全主动防御的重要基础和前提。 什么是网络安全态势感知&#xff1f; 态势感知一词来源于对…
阅读更多...
文心智能体大赛：百度文心智能体平台初体验

文心智能体大赛：百度文心智能体平台初体验

写在前面 博文内容涉及&#xff1a;文心智能体大赛:文心智能体初体验理解不足小伙伴帮忙指正 &#x1f603;,生活加油 我徒然忘记了热闹&#xff0c;却来不及悟透真正的清冷(《四喜忧国》) 前言 徒然忘记了热闹&#xff0c;却来不及悟透真正的清冷(《四喜忧国》)&#xff0c;在…
阅读更多...
前端日志收集（monitor-report v1）

前端日志收集（monitor-report v1）

为什么 为什么自己封装而不是使用三方 类似 Sentry 这种比较全面的 因为 Sentry 很大我没安装成功&#xff0c;所有才自己去封装的 为什么使用 可以帮助你简单解决前端收集错误日志、收集当前页面访问量&#xff0c;网站日活跃&#xff0c;页面访问次数&#xff0c;用户行…
阅读更多...
Linux/Ubuntu 中安装 ZeroTier，实现内网穿透，2分钟搞定

Linux/Ubuntu 中安装 ZeroTier，实现内网穿透，2分钟搞定

相信很多人都有远程连接家中设备的需求&#xff0c;如远程连接家中的NAS、Windows等服务&#xff0c;所以会涉及到一个内网穿透工具的使用&#xff0c;如果没有公网IP的情况下&#xff0c;推荐大家使用ZeroTier&#xff0c;这是一款强大的内网穿透工具。 mac和windows版的操作…
阅读更多...
梦幻西游手游挂机脚本,搬砖挂机赚米项目,号称单窗口日收益60+（教程+软件）

梦幻西游手游挂机脚本,搬砖挂机赚米项目,号称单窗口日收益60+（教程+软件）

一、项目背景 随着智能手机的普及&#xff0c;手游市场逐渐成为人们娱乐生活的重要组成部分。其中&#xff0c;《梦幻西游》作为一款经典的国产手游&#xff0c;吸引了大量的玩家。然而&#xff0c;许多玩家因为工作、学习等原因&#xff0c;无法长时间在线游戏。因此&#xf…
阅读更多...
Autodl服务器中Faster-rcnn(jwyang)复现(一)

Autodl服务器中Faster-rcnn(jwyang)复现(一)

前言 在做实验时需要用到faster-rcnn做对比，本节首先完成代码复现，用的数据集是VOC2007~ 项目地址：https://github.com/jwyang/faster-rcnn.pytorch/tree/pytorch-1.0 复现环境：autodl服务器+python3.6+cuda11.3+Ubuntu20.04+Pytorch1.10.0 目录 一、环境配置二、编译cud…
阅读更多...
深度神经网络——什么是生成式人工智能？

深度神经网络——什么是生成式人工智能？

1.引言 生成式人工智能最近引起了很大的关注。 该术语用于指依赖无监督或半监督学习算法来创建新的数字图像、视频、音频和文本的任何类型的人工智能系统。 麻省理工学院表示&#xff0c;生成式人工智能是过去十年人工智能领域最有前途的进展之一。 通过生成式人工智能&#…
阅读更多...
【gradle】MAC下用gradle构建部署springboot项目

【gradle】MAC下用gradle构建部署springboot项目

MAC下用gradle构建部署springboot项目 前言下载安装配置gradle下载安装下载可能出现的问题 &#xff08;zsh: command not found: brew&#xff09; 配置环境变量配置国内下载源全局配置单个项目配置 通过idea构建项目构建后的项目结构 小结延伸 前言 好久以前就听说gradle了&…
阅读更多...
MongoDB（介绍，安装，操作，Springboot整合MonggoDB）

MongoDB（介绍，安装，操作，Springboot整合MonggoDB）

目录 MongoDB 1 MongoDB介绍 MongoDB简介 MongoDB的特点 MongoDB使用场景 小结 2 MongoDB安装 安装MongoDB 连接MongoDB MongoDB逻辑结构 MongoDB数据类型 小结 3 MongoDB操作 操作库和集合 操作文档-增删改 操作文档-查询 MongoDB索引 小结 4 SpringBoot整合…
阅读更多...
【竞技宝】英超:滕哈格命真硬!足总杯夺冠获欧联资格

【竞技宝】英超:滕哈格命真硬!足总杯夺冠获欧联资格

足总杯决赛结束,曼联爆冷2比1击败联赛冠军曼城夺冠,滕哈格再一次用顶级理解带队拿到杯赛冠军。赛前曼彻斯特当地有媒体爆料,曼联管理层已经决定要在足总杯决赛之后解雇滕哈格,这个消息让不少球迷都很担心滕哈格的状态。但是荷兰主帅凭借强大的内心,带领球队击败了不可一世的曼城…
阅读更多...
深度神经网络——什么是决策树？

深度神经网络——什么是决策树？

决策树 决策树是一种强大的机器学习算法&#xff0c;它通过模拟人类决策过程来解决分类和回归问题。这种算法的核心在于它如何将数据集细分&#xff0c;直至每个子集足够“纯净”&#xff0c;即包含的实例都属于同一类别或具有相似的数值范围。 开始于根节点&#xff1a;决策…
阅读更多...
最新文章

Copyright @ 2022~2023