Transformer面试十问

news2024/11/24 18:30:24

1 Scaled Dot-Product Attention中为什么要除以 d k \sqrt{d_k} dk​ ​?

1. 从纯数学上考虑：对于输入均值为0,方差为1的分布，点乘后结果其方差为dk，所以需要缩放一下。下图为原论文注释。
Attention is all you need
2. 从神经网络上考虑：防止在计算点积时数值过大，导致后续应用 softmax 函数时出现梯度消失的问题。
在这里插入图片描述
计算点积时，如果Q K的元素值和dk的值都很大，那么点积的结果可能会非常大，导致 softmax 函数的输入变得非常大。
softmax 函数在处理很大的输入值时，会使输出的概率分布接近0或1，这会造成梯度非常小，难以通过梯度下降有效地训练模型，即出现梯度消失问题。
通过使用dk缩放点积的结果，可以使点积的数值范围被适当控制。

2 Transformer 的基本组成是什么？

在这里插入图片描述

Transformer分为encoder和decoder两个部分。
Encode包含self-attention和前馈神经网络，用于提取特征；
Decoder在自注意力和前馈神经网络中间多了一个cross-attention，用于和encoder的输出做交互。

3 多头注意力机制如何实现？

在这里插入图片描述

每个头独立地在相同的输入上计算注意力权重，最后把所有头的输出合并。每个头关注一部分的特征，类似于卷积中通道的作用。

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

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

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

        # Separate linear layers for values, keys, and queries for each head
        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):
        N = query.shape[0]  # Number of examples
        value_len, key_len, query_len = values.shape[1], keys.shape[1], query.shape[1]

        # Split embeddings into self.heads 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)

        # Apply linear transformation (separately for each head)
        values = self.values(values)
        keys = self.keys(keys)
        queries = self.queries(queries)

        # Attention mechanism (using torch.matmul for batch matrix multiplication)
        # Calculate attention score
        attention = torch.matmul(queries, keys.transpose(-2, -1)) / torch.sqrt(torch.tensor(self.head_dim, dtype=torch.float32))
        attention = F.softmax(attention, dim=-1)

        # Apply attention weights to values
        out = torch.matmul(attention, values)

        # Concatenate heads
        out = out.reshape(N, query_len, self.heads * self.head_dim)

        # Final linear layer
        out = self.fc_out(out)

        return out

# Example usage
embed_size = 256
heads = 8
N = 1  # Batch size
sentence_length = 5  # Length of the input sequence
model = MultiHeadAttention(embed_size, heads)

# Dummy input (batch size, sentence length, embedding size)
x = torch.rand((N, sentence_length, embed_size))

# Forward pass
out = model(x, x, x)  # In self-attention, queries, keys, values are all the same

print("Input shape:", x.shape)
print("Output shape:", out.shape)

4 训练过程为什么需要 Mask 机制？

两个原因。

  1. 屏蔽未来信息，防止未来帧参与训练。
  2. 处理不同长度的序列，在批处理时对较短的序列进行填充（padding），并确保这些填充不会影响到模型的输出。

5 mask机制如何实现？

  1. 屏蔽未来信息的 Mask：在自注意力层中，通过构造一个上三角矩阵（对于解码器），其中上三角部分（包括对角线，取决于具体实现）被设置为非常大的负数，这样在通过 softmax 层时，这些位置的权重接近于0，从而在计算加权和时不考虑未来的词。

  2. Padding Mask：将填充位置的值设置为一个大的负数，使得经过 softmax 层后，这些位置的权重接近于0。

6 Transformer 中的Positional Encoding有什么作用？

保证attention机制考虑序列的顺序，否则无法区分不同的位置的相同的输入。

7 Transformer 如何处理长距离依赖问题？

Transformer 通过自注意力机制直接计算序列中任意两个位置之间的依赖关系，从而有效地解决了长距离依赖问题。

8 Layer Normalization的作用是什么？

Layer Normalization有助于稳定深层网络的训练，通过对输入的每一层进行标准化处理（使输出均值为0，方差为1），可以加速训练过程并提高模型的稳定性。它通常在自注意力和前馈网络的输出上应用。

9 能否用Batch Normalizatioin?

在 Transformer 架构中，层归一化（Layer Normalization，简称 LayerNorm）是首选的归一化方法，主要用于模型内部的每一层之后。理论上，层归一化可以被批归一化（Batch Normalization，简称 BatchNorm）替换，但是这两种归一化技术在应用上有着本质的不同，这些差异导致了在 Transformer 中通常优先选择层归一化而不是批归一化。

层归一化（Layer Normalization）

  • 层归一化是对每个样本的所有特征执行归一化操作，独立于其他样本。这意味着，无论批次大小如何，LayerNorm 的行为都是一致的。
  • 在处理序列数据和自注意力机制时，LayerNorm 更加有效，因为它能够适应不同长度的输入，这在自然语言处理任务中尤为重要。
  • LayerNorm 直接在每个样本的维度上工作，使得它在序列长度变化的情况下更为稳定。

批归一化（Batch Normalization）

  • 批归一化是在一个小批量的维度上进行归一化，这意味着它依赖于批次中所有样本的统计信息。因此，BatchNorm的行为会随着批次大小和内容的变化而变化，这在训练和推理时可能导致不一致的表现。
  • 在处理变长序列和自注意力结构时，BatchNorm可能不如 LayerNorm 高效，因为变长输入使得批次间的统计信息更加不稳定。
  • BatchNorm在训练时计算当前批次的均值和方差，在推理时使用整个训练集的移动平均统计信息。这种依赖于批次统计信息的特性使得 BatchNorm在小批量或在线学习场景中表现不佳。

10 手写Transformer中的Encoder模块

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

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

        assert (
            self.head_dim * heads == embed_size
        ), "Embedding 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, queries):
        N = queries.shape[0]
        value_len, key_len, query_len = values.shape[1], keys.shape[1], queries.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 = queries.reshape(N, query_len, self.heads, self.head_dim)

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

        # Attention mechanism
        #attention = torch.einsum("nqhd,nkhd->nhqk", [queries, keys])
        attention = torch.matmul(queries, keys.transpose(-2, -1)) / torch.sqrt(torch.tensor(self.head_dim, dtype=torch.float32))

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

        out = self.fc_out(out)

        return out

class TransformerBlock(nn.Module):
    def __init__(self, embed_size, heads, dropout, forward_expansion):
        super(TransformerBlock, self).__init__()
        self.attention = MultiHeadSelfAttention(embed_size, heads)
        self.norm1 = nn.LayerNorm(embed_size)
        self.norm2 = nn.LayerNorm(embed_size)

        self.feed_forward = nn.Sequential(
            nn.Linear(embed_size, forward_expansion * embed_size),
            nn.ReLU(),
            nn.Linear(forward_expansion * embed_size, embed_size),
        )

        self.dropout = nn.Dropout(dropout)

    def forward(self, value, key, query):
        attention = self.attention(value, key, query)
        x = self.dropout(self.norm1(attention + query))
        forward = self.feed_forward(x)
        out = self.dropout(self.norm2(forward + x))
        return out

class Encoder(nn.Module):
    def __init__(
        self,
        embed_size,
        num_layers,
        heads,
        device,
        forward_expansion,
        dropout,
    ):

        super(Encoder, self).__init__()
        self.embed_size = embed_size
        self.device = device
        self.layers = nn.ModuleList(
            [
                TransformerBlock(
                    embed_size,
                    heads,
                    dropout=dropout,
                    forward_expansion=forward_expansion,
                )
                for _ in range(num_layers)
            ]
        )

        self.dropout = nn.Dropout(dropout)

    def forward(self, x):
        out = self.dropout(x)

        for layer in self.layers:
            out = layer(out, out, out)

        return out

# Hyperparameters
embed_size = 512
num_layers = 6
heads = 8
device = "cuda" if torch.cuda.is_available() else "cpu"
forward_expansion = 4
dropout = 0.1

# Example
encoder = Encoder(embed_size, num_layers, heads, device, forward_expansion, dropout).to(device)

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

【Linux】程序地址空间 -- 详解 Linux 2.6 内核进程调度队列 -- 了解

【Linux】程序地址空间 -- 详解 Linux 2.6 内核进程调度队列 -- 了解

一、程序地址空间回顾 在学习 C/C 时，我们知道内存会被分为几个区域：栈区、堆区、全局/静态区、代码区、字符常量区等。但这仅仅是在语言层面上的理解，是远远不够的。 如下空间布局图，请问这是物理内存吗？ 不是&…
阅读更多...
C语言scanf函数详解..

C语言scanf函数详解..

1.前言 前面说过了printf函数 他是将二进制表示的整数、浮点数、字符、字符串根据转换规范转换成字符或者字符串 并且打印到了控制台上 那么既然有了输出函数 那么肯定也有输入函数咯 的确如此 他就是scanf函数 他是将字符或者字符串根据转换规范转换成二进制表示的整数、浮点…
阅读更多...
Conda管理Python不同版本教程

Conda管理Python不同版本教程

Conda管理Python不同版本教程 目录 0.前提 1.conda常用命令 2.conda管理python库 不太推荐 pyenv管理Python不同版本教程（本人另一篇博客，姊妹篇） 0.前提 ①anaconda、miniconda在win上推荐前者，在linux上推荐后者&#xff0…
阅读更多...
随机过程及应用学习笔记（一）概率论（概要）

随机过程及应用学习笔记（一）概率论（概要）

概率是随机的基础，在【概率论（概要）】这个部分中仅记录学习随机过程及应用的基本定义和结果。 前言 首先，概率论研究的基础是概率空间。概率空间由一个样本空间和一个概率测度组成，样本空间包含了所有可能的结果&…
阅读更多...
LCR 127. 跳跃训练【简单】

LCR 127. 跳跃训练【简单】

LCR 127. 跳跃训练 题目描述： 今天的有氧运动训练内容是在一个长条形的平台上跳跃。平台有 num 个小格子，每次可以选择跳 一个格子 或者 两个格子。请返回在训练过程中，学员们共有多少种不同的跳跃方式。 结果可能过大，因此结果…
阅读更多...
Transformer——Attention 注意力机制

Transformer——Attention 注意力机制

注意力机制 Transformer的注意力机制借鉴了人类的注意力机制。人类通过眼睛的视觉单元去扫描图像，其中的重点区域会被大脑的神经元处理从而获得更多的信息，这是人类长期精华所获得的一种能力。 以论文中的例子来看，红色区域表示我们人脑视觉…
阅读更多...
linux内核模块find_module()函数详解--02

linux内核模块find_module()函数详解--02

亲爱的粉丝朋友们大家好，为了更好的服务大家，提升分析问题和解决问题的能力，先针对Linux内核里面的API函数进行详细分析，并利用案例进行说明，加强对内核API函数的认识。 第一：函数原型 //头文件包含 #incl…
阅读更多...
晨曦记账本，微信账单全解析，轻松掌握收支明细与总花销！

晨曦记账本，微信账单全解析，轻松掌握收支明细与总花销！

在这个数字化时代，微信已不仅仅是一个简单的社交工具，更是我们日常生活中不可或缺的支付与收款平台。从购买早餐、支付水电费到线上购物，微信支付已经渗透到我们生活的方方面面。然而，你是否曾经对自己的微信消费产生过疑惑&#…
阅读更多...
线程的状态与切换

线程的状态与切换

文章目录 线程的状态与切换一、线程的状态1、操作系统层面（5种）2、Java_API层面（6种） 二、让出时间片 - yield三、线程插队 - join1、源码分析2、应用1 - 等待线程结果3、应用2 - 控制执行顺序 四、计时等待 - sleep五、等待唤醒 …
阅读更多...
2024春节联欢晚会刘谦魔术分析

2024春节联欢晚会刘谦魔术分析

春晚已经越来越拉胯了，看着节目单没一个能打的，本来想说：办不起，就别办呗。 没想到第二天刘谦的魔术以一种很奇特的姿势火起来了，干脆蹭个热度，分析下魔术的原理。 魔术1 这个不算什么新奇的节目&#xf…
阅读更多...
老师的“神秘武器”——教育战线的宝藏工具

老师的“神秘武器”——教育战线的宝藏工具

每次考试成绩发布，是不是总让你头疼不已？面对一摞摞试卷，一个个需要手动输入的成绩，你是否也感到力不从心？别急，今天我就为大家揭秘老师们的“神秘武器”——那些在教育战线上，让老师们事半功倍…
阅读更多...
代码随想录刷题笔记-Day18

代码随想录刷题笔记-Day18

1. 合并二叉树 617. 合并二叉树https://leetcode.cn/problems/merge-two-binary-trees/ 给你两棵二叉树： root1 和 root2 。 想象一下，当你将其中一棵覆盖到另一棵之上时，两棵树上的一些节点将会重叠（而另一些不会）…
阅读更多...
【图像分割 2024】ParaTransCNN

【图像分割 2024】ParaTransCNN

【图像分割 2024】ParaTransCNN 论文题目：ParaTransCNN: Parallelized TransCNN Encoder for Medical Image Segmentation 中文题目：用于医学图像分割的并行TransCNN编码器 论文链接：https://arxiv.org/abs/2401.15307 论文代码：H…
阅读更多...
机器学习西瓜书之决策树

机器学习西瓜书之决策树

目录 算法原理剪枝处理连续值处理缺失值处理多变量决策树 算法原理 从逻辑角度：通过一系列if-else语句进行多重判断，比如白富美的判断条件（“白”“富”“美”）。 从几何角度：根据定义的标准进行样本空间的划分。 以二…
阅读更多...
应对DDoS攻击：快速恢复网站正常运行的关键步骤

应对DDoS攻击：快速恢复网站正常运行的关键步骤

当网站遭受DDoS（分布式拒绝服务）攻击时，可能会导致网站停机、性能下降和用户无法访问等问题，处理DDoS攻击需要采取一系列措施来应对和缓解攻击。 您的网站可能是今天的目标，因为面对DDoS（分布式拒绝服务&am…
阅读更多...
【Vue前端】vue使用笔记0基础到高手第2篇：Vue知识点介绍（附代码，已分享）

【Vue前端】vue使用笔记0基础到高手第2篇：Vue知识点介绍（附代码，已分享）

本系列文章md笔记（已分享）主要讨论vue相关知识。Vue.js是前端三大新框架：Angular.js、React.js、Vue.js之一，Vue.js目前的使用和关注程度在三大框架中稍微胜出，并且它的热度还在递增。Vue.js是一个轻巧、高性能、可组件…
阅读更多...
【制作100个unity游戏之25】3D背包、库存、制作、快捷栏、存储系统、砍伐树木获取资源、随机战利品宝箱2（附带项目源码）

【制作100个unity游戏之25】3D背包、库存、制作、快捷栏、存储系统、砍伐树木获取资源、随机战利品宝箱2（附带项目源码）

效果演示 文章目录 效果演示系列目录前言拖放、交换物品绘制拖拽物品插槽UI修改Inventory，控制拖放功能 源码完结 系列目录 前言 欢迎来到【制作100个Unity游戏】系列！本系列将引导您一步步学习如何使用Unity开发各种类型的游戏。在这第25篇中&#xf…
阅读更多...
C语言第二十六弹---字符串函数(下)

C语言第二十六弹---字符串函数(下)

✨个人主页： 熬夜学编程的小林 💗系列专栏： 【C语言详解】 【数据结构详解】 目录 1、strncat 函数的使用 2、strncmp 函数的使用 3、strstr 函数的使用和模拟实现 4、strtok 函数的使用 5、strerror 函数的使用 6、perror 函数的使用…
阅读更多...
CSS的注释:以“ /* ”开头，以“ */ ”结尾

CSS的注释:以“ /* ”开头，以“ */ ”结尾

CSS的注释:以“ /* ”开头，以“*/”结尾 CSS的注释: 以“ /* ”开头，以“ */ ”结尾 在CSS中，注释是一种非常重要的工具，它们可以帮助开发者记录代码的功能、用法或其他重要信息。这些信息对于理解代码、维护代码以及与他人合作都…
阅读更多...
【C++11】：unordered系列关联式容器

【C++11】：unordered系列关联式容器

朋友们、伙计们，我们又见面了，本期来给大家解读一下有关unordered系列关联式容器的知识点，如果看完之后对你有一定的启发，那么请留下你的三连，祝大家心想事成！ C 语 言 专 栏：C语言：…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023