[深度学习] Transformer

news2024/12/27 5:57:15

Transformer是一种深度学习模型，最早由Vaswani等人在2017年的论文《Attention is All You Need》中提出。它最初用于自然语言处理（NLP）任务，但其架构的灵活性使其在许多其他领域也表现出色，如计算机视觉、时间序列分析等。以下是对Transformer模型的详细介绍。

一、基本结构

Transformer模型主要由两个部分组成：编码器（Encoder）和解码器（Decoder）。

编码器（Encoder）
  • 输入嵌入（Input Embedding）：将输入的词汇转换为高维向量表示。
  • 位置编码（Positional Encoding）：由于Transformer没有循环结构或卷积结构，因此需要显式地加入位置信息。位置编码可以帮助模型了解序列中各个词汇的位置。
  • 多头自注意力机制（Multi-Head Self-Attention）：自注意力机制可以捕捉序列中不同位置之间的依赖关系。多头机制允许模型关注不同的子空间。
  • 前馈神经网络（Feed-Forward Neural Network）：两个线性变换和一个ReLU激活函数，独立地应用于每个位置。
  • 层归一化（Layer Normalization）和残差连接（Residual Connection）：每个子层的输出都进行层归一化，并通过残差连接加入子层输入。

编码器包含多个（通常是6个）这样的子层堆叠。

解码器（Decoder）

解码器的结构与编码器类似，但增加了一个用于接收编码器输出的注意力层。

  • 输入嵌入、位置编码、多头自注意力机制、前馈神经网络、层归一化和残差连接：与编码器相同。
  • 掩码多头自注意力机制（Masked Multi-Head Self-Attention）：防止解码器当前位置注意到未来位置的信息。
  • 编码器-解码器注意力机制（Encoder-Decoder Attention）：使解码器能关注编码器的输出，从而将编码器捕捉到的上下文信息用于生成目标序列。

解码器也包含多个（通常是6个）这样的子层堆叠。

在这里插入图片描述

二、详细机制

注意力机制（Attention Mechanism）

自注意力机制是Transformer的核心。它的计算过程如下：

  1. 计算查询（Query）、键（Key）、值（Value）矩阵：
    在这里插入图片描述
    其中，X 是输入序列，WQ、WK、WV是可训练的权重矩阵。

  2. 计算注意力分数：
    在这里插入图片描述
    其中：

    • dk是键向量的维度。
    • KT 是键矩阵的转置

  3. 多头机制：
    多头注意力机制将输入映射到多个子空间，通过多个注意力头来捕捉不同的特征。然后将这些头的输出连接起来：
    在这里插入图片描述
    其中，每个头是独立的注意力机制，WO 是可训练的线性变换矩阵。

三、Transformer的优点

  1. 并行计算：不同于RNN的序列处理方式，Transformer允许并行计算，提高了训练速度。
  2. 长程依赖：通过自注意力机制，Transformer能够直接捕捉序列中任意位置之间的依赖关系。
  3. 灵活性：Transformer架构可以轻松扩展到不同任务，如语言翻译、文本生成、图像处理等。

四、变种和改进

自从Transformer被提出以来，已经出现了许多改进和变种，例如：

  • BERT（Bidirectional Encoder Representations from Transformers）：双向编码器，适用于多种NLP任务。
  • GPT（Generative Pre-trained Transformer）：生成模型，专注于文本生成任务。
  • T5（Text-to-Text Transfer Transformer）：将所有NLP任务统一为文本到文本的形式。
  • Vision Transformer（ViT）：将Transformer应用于图像分类任务。

五、应用领域

Transformer模型在以下领域表现出色：

  1. 自然语言处理（NLP）：如机器翻译、文本生成、问答系统等。
  2. 计算机视觉：如图像分类、目标检测等。
  3. 时间序列分析：如股票预测、天气预报等。
  4. 推荐系统：通过捕捉用户与物品之间的复杂关系来提供个性化推荐。

六、代码示例

以下是一个使用TensorFlow实现简单Transformer的代码示例：

import tensorflow as tf
import numpy as np

# 注意力机制
def scaled_dot_product_attention(q, k, v, mask):
    matmul_qk = tf.matmul(q, k, transpose_b=True)
    dk = tf.cast(tf.shape(k)[-1], tf.float32)
    scaled_attention_logits = matmul_qk / tf.math.sqrt(dk)
    if mask is not None:
        scaled_attention_logits += (mask * -1e9)
    attention_weights = tf.nn.softmax(scaled_attention_logits, axis=-1)
    output = tf.matmul(attention_weights, v)
    return output, attention_weights

# 多头注意力
class MultiHeadAttention(tf.keras.layers.Layer):
    def __init__(self, d_model, num_heads):
        super(MultiHeadAttention, self).__init__()
        self.num_heads = num_heads
        self.d_model = d_model
        assert d_model % self.num_heads == 0
        self.depth = d_model // self.num_heads
        self.wq = tf.keras.layers.Dense(d_model)
        self.wk = tf.keras.layers.Dense(d_model)
        self.wv = tf.keras.layers.Dense(d_model)
        self.dense = tf.keras.layers.Dense(d_model)
        
    def split_heads(self, x, batch_size):
        x = tf.reshape(x, (batch_size, -1, self.num_heads, self.depth))
        return tf.transpose(x, perm=[0, 2, 1, 3])
    
    def call(self, v, k, q, mask):
        batch_size = tf.shape(q)[0]
        q = self.wq(q)
        k = self.wk(k)
        v = self.wv(v)
        q = self.split_heads(q, batch_size)
        k = self.split_heads(k, batch_size)
        v = self.split_heads(v, batch_size)
        scaled_attention, attention_weights = scaled_dot_product_attention(q, k, v, mask)
        scaled_attention = tf.transpose(scaled_attention, perm=[0, 2, 1, 3])
        concat_attention = tf.reshape(scaled_attention, (batch_size, -1, self.d_model))
        output = self.dense(concat_attention)
        return output, attention_weights

# 前馈神经网络
def point_wise_feed_forward_network(d_model, dff):
    return tf.keras.Sequential([
        tf.keras.layers.Dense(dff, activation='relu'),
        tf.keras.layers.Dense(d_model)
    ])

# 编码器层
class EncoderLayer(tf.keras.layers.Layer):
    def __init__(self, d_model, num_heads, dff, rate=0.1):
        super(EncoderLayer, self).__init__()
        self.mha = MultiHeadAttention(d_model, num_heads)
        self.ffn = point_wise_feed_forward_network(d_model, dff)
        self.layernorm1 = tf.keras.layers.LayerNormalization(epsilon=1e-6)
        self.layernorm2 = tf.keras.layers.LayerNormalization(epsilon=1e-6)
        self.dropout1 = tf.keras.layers.Dropout(rate)
        self.dropout2 = tf.keras.layers.Dropout(rate)
        
    def call(self, x, training, mask):
        attn_output, _ = self.mha(x, x, x, mask)
        attn_output = self.dropout1(attn_output, training=training)
        out1 = self.layernorm1(x + attn_output)
        ffn_output = self.ffn(out1)
        ffn_output = self.dropout2(ffn_output, training=training)
        out2 = self.layernorm2(out1 + ffn_output)
        return out2

# 解码器层
class DecoderLayer(tf.keras.layers.Layer):
    def __init__(self, d_model, num_heads, dff, rate=0.1):
        super(DecoderLayer, self).__init__()
        self.mha1 = MultiHeadAttention(d_model, num_heads)
        self.mha2 = MultiHeadAttention(d_model, num_heads)
        self.ffn = point_wise_feed_forward_network(d_model, dff)
        self.layernorm1 = tf.keras.layers.LayerNormalization(epsilon=1e-6)
        self.layernorm2 = tf.keras.layers.LayerNormalization(epsilon=1e-

6)
        self.layernorm3 = tf.keras.layers.LayerNormalization(epsilon=1e-6)
        self.dropout1 = tf.keras.layers.Dropout(rate)
        self.dropout2 = tf.keras.layers.Dropout(rate)
        self.dropout3 = tf.keras.layers.Dropout(rate)
        
    def call(self, x, enc_output, training, look_ahead_mask, padding_mask):
        attn1, attn_weights_block1 = self.mha1(x, x, x, look_ahead_mask)
        attn1 = self.dropout1(attn1, training=training)
        out1 = self.layernorm1(x + attn1)
        attn2, attn_weights_block2 = self.mha2(enc_output, enc_output, out1, padding_mask)
        attn2 = self.dropout2(attn2, training=training)
        out2 = self.layernorm2(out1 + attn2)
        ffn_output = self.ffn(out2)
        ffn_output = self.dropout3(ffn_output, training=training)
        out3 = self.layernorm3(out2 + ffn_output)
        return out3, attn_weights_block1, attn_weights_block2

# 编码器
class Encoder(tf.keras.layers.Layer):
    def __init__(self, num_layers, d_model, num_heads, dff, input_vocab_size, rate=0.1):
        super(Encoder, self).__init__()
        self.d_model = d_model
        self.num_layers = num_layers
        self.embedding = tf.keras.layers.Embedding(input_vocab_size, d_model)
        self.pos_encoding = positional_encoding(1000, self.d_model)
        self.enc_layers = [EncoderLayer(d_model, num_heads, dff, rate) for _ in range(num_layers)]
        self.dropout = tf.keras.layers.Dropout(rate)
        
    def call(self, x, training, mask):
        seq_len = tf.shape(x)[1]
        x = self.embedding(x)
        x *= tf.math.sqrt(tf.cast(self.d_model, tf.float32))
        x += self.pos_encoding[:, :seq_len, :]
        x = self.dropout(x, training=training)
        for i in range(self.num_layers):
            x = self.enc_layers[i](x, training, mask)
        return x

# 解码器
class Decoder(tf.keras.layers.Layer):
    def __init__(self, num_layers, d_model, num_heads, dff, target_vocab_size, rate=0.1):
        super(Decoder, self).__init__()
        self.d_model = d_model
        self.num_layers = num_layers
        self.embedding = tf.keras.layers.Embedding(target_vocab_size, d_model)
        self.pos_encoding = positional_encoding(1000, self.d_model)
        self.dec_layers = [DecoderLayer(d_model, num_heads, dff, rate) for _ in range(num_layers)]
        self.dropout = tf.keras.layers.Dropout(rate)
        
    def call(self, x, enc_output, training, look_ahead_mask, padding_mask):
        seq_len = tf.shape(x)[1]
        attention_weights = {}
        x = self.embedding(x)
        x *= tf.math.sqrt(tf.cast(self.d_model, tf.float32))
        x += self.pos_encoding[:, :seq_len, :]
        x = self.dropout(x, training=training)
        for i in range(self.num_layers):
            x, block1, block2 = self.dec_layers[i](x, enc_output, training, look_ahead_mask, padding_mask)
            attention_weights[f'decoder_layer{i+1}_block1'] = block1
            attention_weights[f'decoder_layer{i+1}_block2'] = block2
        return x, attention_weights

# Transformer模型
class Transformer(tf.keras.Model):
    def __init__(self, num_layers, d_model, num_heads, dff, input_vocab_size, target_vocab_size, rate=0.1):
        super(Transformer, self).__init__()
        self.encoder = Encoder(num_layers, d_model, num_heads, dff, input_vocab_size, rate)
        self.decoder = Decoder(num_layers, d_model, num_heads, dff, target_vocab_size, rate)
        self.final_layer = tf.keras.layers.Dense(target_vocab_size)
        
    def call(self, inp, tar, training, enc_padding_mask, look_ahead_mask, dec_padding_mask):
        enc_output = self.encoder(inp, training, enc_padding_mask)
        dec_output, attention_weights = self.decoder(tar, enc_output, training, look_ahead_mask, dec_padding_mask)
        final_output = self.final_layer(dec_output)
        return final_output, attention_weights

# 位置编码
def positional_encoding(position, d_model):
    angle_rads = get_angles(np.arange(position)[:, np.newaxis], np.arange(d_model)[np.newaxis, :], d_model)
    angle_rads[:, 0::2] = np.sin(angle_rads[:, 0::2])
    angle_rads[:, 1::2] = np.cos(angle_rads[:, 1::2])
    pos_encoding = angle_rads[np.newaxis, ...]
    return tf.cast(pos_encoding, dtype=tf.float32)

def get_angles(pos, i, d_model):
    angle_rates = 1 / np.power(10000, (2 * (i // 2)) / np.float32(d_model))
    return pos * angle_rates

# 掩码
def create_padding_mask(seq):
    seq = tf.cast(tf.math.equal(seq, 0), tf.float32)
    return seq[:, tf.newaxis, tf.newaxis, :]

def create_look_ahead_mask(size):
    mask = 1 - tf.linalg.band_part(tf.ones((size, size)), -1, 0)
    return mask

# 超参数
num_layers = 4
d_model = 128
dff = 512
num_heads = 8
input_vocab_size = 8500
target_vocab_size = 8000
dropout_rate = 0.1

# 创建Transformer模型
transformer = Transformer(num_layers, d_model, num_heads, dff, input_vocab_size, target_vocab_size, dropout_rate)

# 损失函数和优化器
loss_object = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True, reduction='none')
def loss_function(real, pred):
    mask = tf.math.logical_not(tf.math.equal(real, 0))
    loss_ = loss_object(real, pred)
    mask = tf.cast(mask, dtype=loss_.dtype)
    loss_ *= mask
    return tf.reduce_sum(loss_) / tf.reduce_sum(mask)

learning_rate = tf.keras.optimizers.schedules.ExponentialDecay(1e-4, decay_steps=100000, decay_rate=0.9, staircase=True)
optimizer = tf.keras.optimizers.Adam(learning_rate)

# 编译模型
transformer.compile(optimizer=optimizer, loss=loss_function)

# 示例输入
sample_input = tf.constant([[1, 2, 3, 4, 0, 0]])
sample_target = tf.constant([[1, 2, 3, 4, 0, 0]])

# 训练模型
transformer.fit([sample_input, sample_target], epochs=10)
解释
  1. 注意力机制：定义了计算注意力权重的函数和多头注意力机制。
  2. 前馈神经网络：实现了前馈神经网络的部分。
  3. 编码器和解码器层：定义了编码器和解码器的基本层。
  4. 编码器和解码器：实现了编码器和解码器的堆叠。
  5. Transformer模型：集成了编码器和解码器，定义了完整的Transformer模型。
  6. 位置编码：为输入序列添加位置信息。
  7. 掩码：定义了填充掩码和前瞻掩码，用于处理输入和目标序列中的填充和防止信息泄露。

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

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

相关文章

程序设计语言前言

程序设计语言前言

1.机器语言及特点 2.编译语言及特点 3.高级语言及特点 4.编译和解释 5.IPO编程方式 一、机器语言 机器语言，也被称为二进制代码语言，是计算机硬件能够直接识别的程序语言或指令代码。它是由一系列由0和1组成的二进制指令码构成，每一条指令码…
阅读更多...
分页组件 vue/uniapp

分页组件 vue/uniapp

失效如上图 1.父组件调用 <onion-pagination :page.sync="todusGameQuery.pageSize" @update:page="changeTodusLoadMore":pageSize="todusGameQuery.pageNum" :total="todusGameTotal"></onion-pagination> 2.组件封装…
阅读更多...
ios18开发者预览，Beta 2升级新增镜像等功能

ios18开发者预览，Beta 2升级新增镜像等功能

近日&#xff0c;苹果发布了 iOS 18 开发者预览版 Beta 2 升级&#xff0c;为 iPhone 用户带来了多项新功能。据了解&#xff0c;这些新功能包括 iPhone 镜像和 SharePlay 屏幕共享&#xff0c;以及其他新增功能。 据了解&#xff0c;iPhone镜像可以让Mac用户将iPhone屏幕镜像…
阅读更多...
flink 处理函数和流转换

flink 处理函数和流转换

目录 处理函数分类 概览介绍 KeydProcessFunction和ProcessFunction 定时器TimeService 窗口处理函数 多流转换 分流-侧输出流 合流 联合&#xff08;Uniion&#xff09; 连接&#xff08;connect&#xff09; 广播连接流&#xff08;BroadcatConnectedStream&#xf…
阅读更多...
【计算机毕业设计】基于Springboot的智能物流管理系统【源码+lw+部署文档】

【计算机毕业设计】基于Springboot的智能物流管理系统【源码+lw+部署文档】

包含论文源码的压缩包较大&#xff0c;请私信或者加我的绿色小软件获取 免责声明&#xff1a;资料部分来源于合法的互联网渠道收集和整理&#xff0c;部分自己学习积累成果&#xff0c;供大家学习参考与交流。收取的费用仅用于收集和整理资料耗费时间的酬劳。 本人尊重原创作者…
阅读更多...
JAVA【案例5-5】二月天

JAVA【案例5-5】二月天

【二月天】 1、案例描述 二月是一个有趣的月份&#xff0c;平年的二月有28天&#xff0c;闰年的二月由29天。闰年每四年一次&#xff0c;在判断闰年时&#xff0c;可以使用年份除于4&#xff0c;如果能够整除&#xff0c;则该年是闰年。 本案例要求编写一个程序&#xff0c;…
阅读更多...
Docker如何安装redis

Docker如何安装redis

目录 1. 拉取redis的镜像文件 2. 创建redis的容器卷 3. 准备reids的配置文件 4. 以配置文件启动redis 1. 拉取redis的镜像文件 # 默认安装最新版本 如果需要指定版本 docker pull redis:版本号 docker pull redis 详细版本请看dockerhub的官网&#xff1a; hub.docker…
阅读更多...
【Java面试场景题】如何解决高并发下的库存抢购超卖少买问题？

【Java面试场景题】如何解决高并发下的库存抢购超卖少买问题？

一、问题解析 我相信很多人都看到过相关资料&#xff0c;但是在实践过程中&#xff0c;仍然会碰到具体的实现无法满足需求的情况&#xff0c;比如说有的实现无法秒杀多个库存&#xff0c;有的实现新增库存操作缓慢&#xff0c;有的实现库存耗尽时会变慢等等。 这是因为对于不…
阅读更多...
只能在公司才能打开工作邮件

只能在公司才能打开工作邮件

工作中企业邮箱是常用的办公工具&#xff0c;有些企业邮箱限制了登录的网络范围&#xff0c;只能在公司才能打开&#xff0c;能够起到一定程度的防护作用。哪些工作邮箱能够实现呢&#xff1f;工作邮箱怎么才能设置成这样的访问模式呢&#xff1f;本篇文章将为您详细介绍。 一…
阅读更多...
尚硅谷vue2的todolist案例解析,基本概括了vue2所有知识点，结尾有具体代码，复制粘贴学习即可

尚硅谷vue2的todolist案例解析,基本概括了vue2所有知识点，结尾有具体代码，复制粘贴学习即可

脚手架搭建 1-初始化脚手架&#xff08;全局安装&#xff09; npm install -g vue/cli2-切换到创建项目的空目录下 vue create xxxx整体结构 整体思路 App定义所有回调方法 增删改查 还有统一存放最终数据&#xff0c;所有子组件不拿数据&#xff0c;由App下发数据&#xf…
阅读更多...
狗都能看懂的DBSCAN算法详解

狗都能看懂的DBSCAN算法详解

文章目录 DBSCAN简介DBSCAN算法流程运行机制举个实例 DBSCAN算法特点DBSCAN参数选取技巧 ϵ \epsilon ϵ的选取&#xff1a;找突变点MinPts的选取 DBSCAN简介 DBSCAN&#xff08;Density-Based Spatial Clustering of Applications with Noise&#xff0c;具有噪声的基于密度的…
阅读更多...
仿Photoshop利用曲线对图像调整亮度与色彩

仿Photoshop利用曲线对图像调整亮度与色彩

曲线调整是Photoshop的最常用的重要功能之一。对于一个RGB图像, 可以对R, G, B 通道进行独立的曲线调整&#xff0c;即&#xff0c;对三个通道分别使用三条曲线&#xff08;Curve&#xff09;。还可以再增加一条曲线对 三个通道进行整体调整。 因此&#xff0c;对一个图像&a…
阅读更多...
Blast L2空投教学,好用的Blast钱包推荐bitget

Blast L2空投教学,好用的Blast钱包推荐bitget

什么是 Blast L2&#xff1f; Blast&#xff08;web3.bitget.com/en/&#xff09;是一个与 EVM 兼容的第 2 层 (L2) 区块链网络&#xff0c;旨在通过原生收益产生收益。该项目由匿名联合创始人 PacmanBlur 领导&#xff0c;并已成功从 Paradigm 和 Standard Crypto 等知名投资…
阅读更多...
早餐店小程序开发

早餐店小程序开发

在快节奏的城市生活中&#xff0c;早餐对于许多人来说是一天中最重要的一餐。然而&#xff0c;传统的早餐店在经营过程中常常面临客流量不稳定、服务效率低下等问题。为了解决这些问题&#xff0c;越来越多的早餐店老板开始寻求利用科技手段提升经营效率。早餐店小程序作为一种…
阅读更多...
Energy-based PINN在固体力学中的运用

Energy-based PINN在固体力学中的运用

简介 物理信息神经网络&#xff08;Physic informed neural network&#xff0c;PINN&#xff09;已经成为在有限差分、有限体积和有限元之后的另一种求解偏微分方程组的范式&#xff0c;受到学者们广泛关注。 在固体力学领域有两类不同的PINN: &#xff08;1&#xff09;PDE…
阅读更多...
【D3.js in Action 3 精译】1.2 D3 生态系统——入门须知

【D3.js in Action 3 精译】1.2 D3 生态系统——入门须知

1.2 D3 生态系统——入门须知 D3.js 从不单打独斗&#xff0c;而是作为 D3 生态系统的一员&#xff0c;与生态内的一系列技术和工具相结合来创建丰富的 Web 界面。与其他网页一样&#xff0c;D3 项目也是充分利用 HTML5 的强大功能在 DOM 内构建出来的。尽管 D3 也可以创建并操…
阅读更多...
栈，ASCII编码

栈，ASCII编码

栈 LinkedList stack new LinkedList<>(); int i 0; while (i < s.length()) { char c s.charAt(i); if (c <) {if (stack.isEmpty()) {i;continue;}stack.removeLast(); //从栈的末尾移除一个元素} else {stack.addLast(c); //压入栈的末尾栈是只允许在一端…
阅读更多...
二叉树——另一颗树的子树

二叉树——另一颗树的子树

目录 1&#xff1a;题目分析及思路 2&#xff1a;代码实现和分析 1&#xff1a;代码 2&#xff1a;分析 1&#xff1a;题目分析及思路 给我们两棵二叉树&#xff0c;分别是 root 和 subRoot 。检验 root 中是否包含和 subRoot 具有相同结构和节点值的子树。如果存在&…
阅读更多...
ZGC垃圾收集的主要流程

ZGC垃圾收集的主要流程

值得说明的是&#xff0c;在执行就地迁移时&#xff0c;ZGC 必须首先压缩指定为对象迁移区域内的对象&#xff0c;这可能会对性能产生负面影响。增加堆大小可以帮助 ZGC 避免使用就地迁移。 如上图&#xff0c;ZGC 的工作流程主要包括以下几个步骤&#xff1a; &#xff08;STW…
阅读更多...
昇思25天学习打卡营第8天|保存与加载

昇思25天学习打卡营第8天|保存与加载

一、简介&#xff1a; 上一章节主要介绍了如何调整超参数&#xff0c;并进行网络模型训练。在训练网络模型的过程中&#xff0c;实际上我们希望保存中间和最后的结果&#xff0c;用于微调&#xff08;fine-tune&#xff09;和后续的模型推理与部署&#xff0c;本章节我们将介绍…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023