首页 > 其他分享 >Transformer--详解

Transformer--详解

时间：2024-10-08 13:52:11浏览次数：3  
标签：Transformer num -- self attention 详解 tf model

Transformer旨在解决自然语言处理任务中的长依赖性问题。与传统的递归神经网络（如LSTM、GRU）不同，Transformer完全摒弃了递归结构，依赖自注意力机制（Self-Attention）来建模输入序列中的所有位置之间的关系。因此，Transformer能够并行处理整个序列，这极大地提高了训练速度和效率。

Transformer在许多自然语言处理任务（如机器翻译、文本生成、文本分类等）中表现优异，尤其是大规模语言模型（如BERT、GPT、T5等）的基础架构。

Transformer的基本结构

Transformer模型由编码器（Encoder）和解码器（Decoder）两个部分组成，二者都由堆叠的多层相似结构组成。以下是各部分的基本结构：

  1. 编码器（Encoder）：

    • 编码器由多个层堆叠组成，每一层包括两个子层：

      1. 多头自注意力机制（Multi-Head Self-Attention）：输入序列的所有位置之间进行相互注意，允许模型关注序列中不同部分的信息。

      2. 前馈神经网络（Feed-Forward Network）：独立应用于每个位置。

    • 每个子层后都有一个残差连接和层归一化（Layer Normalization），使得梯度传播更为稳定。

  2. 解码器（Decoder）：

    • 解码器也由多个层堆叠组成，但每层有三个子层：

      1. Masked 多头自注意力机制：确保模型在生成序列时，每个位置只能关注之前的位置。

      2. 编码器-解码器注意力：解码器关注编码器的输出。

      3. 前馈神经网络。

    • 同样每个子层后都有残差连接和层归一化。

  3. 注意力机制（Attention Mechanism）：

    • Transformer依赖于一种称为Scaled Dot-Product Attention的注意力机制。它通过计算查询（Query）、键（Key）和值（Value）之间的点积来生成注意力分数。

  4. 位置编码（Positional Encoding）：

    • Transformer没有递归结构，因此模型需要一种方式来捕捉序列中的位置信息。位置编码通过正弦和余弦函数添加到输入嵌入上，帮助模型捕获位置信息。

Transformer的经典代码

以下是使用Keras实现Transformer编码器的简化代码示例：

import numpy as np
import tensorflow as tf
from tensorflow.keras.layers import Dense, LayerNormalization, Dropout, Embedding
from tensorflow.keras.models import Model
​
# Scaled Dot-Product Attention
def scaled_dot_product_attention(query, key, value, mask=None):
    matmul_qk = tf.matmul(query, key, transpose_b=True)  # 计算Q和K的点积
    dk = tf.cast(tf.shape(key)[-1], tf.float32)
    scaled_attention_logits = matmul_qk / tf.math.sqrt(dk)  # 缩放
​
    if mask is not None:
        scaled_attention_logits += (mask * -1e9)  # 如果有mask，填充为负无穷
​
    attention_weights = tf.nn.softmax(scaled_attention_logits, axis=-1)  # 归一化
    output = tf.matmul(attention_weights, value)  # 计算权重与V的乘积
    return output, attention_weights
​
# Multi-head Attention Layer
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 = Dense(d_model)
        self.wk = Dense(d_model)
        self.wv = Dense(d_model)
        self.dense = 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=None):
        batch_size = tf.shape(q)[0]
​
        # 通过线性层获得Q, K, V
        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([
        Dense(dff, activation='relu'),  # 第一层
        Dense(d_model)  # 第二层
    ])
​
# Transformer Encoder Layer
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 = LayerNormalization(epsilon=1e-6)
        self.layernorm2 = LayerNormalization(epsilon=1e-6)
​
        self.dropout1 = Dropout(rate)
        self.dropout2 = Dropout(rate)
​
    def call(self, x, mask=None):
        attn_output, _ = self.mha(x, x, x, mask)  # 自注意力
        attn_output = self.dropout1(attn_output)
        out1 = self.layernorm1(x + attn_output)  # 残差连接 + LayerNorm
​
        ffn_output = self.ffn(out1)  # 前馈
        ffn_output = self.dropout2(ffn_output)
        out2 = self.layernorm2(out1 + ffn_output)  # 残差连接 + LayerNorm
​
        return out2
​
# Transformer Encoder
class Encoder(tf.keras.layers.Layer):
    def __init__(self, num_layers, d_model, num_heads, dff, input_vocab_size, maximum_position_encoding, rate=0.1):
        super(Encoder, self).__init__()
​
        self.d_model = d_model
        self.num_layers = num_layers
​
        self.embedding = Embedding(input_vocab_size, d_model)
        self.pos_encoding = positional_encoding(maximum_position_encoding, self.d_model)
​
        self.enc_layers = [EncoderLayer(d_model, num_heads, dff, rate) for _ in range(num_layers)]
​
        self.dropout = Dropout(rate)
​
    def call(self, x, mask=None):
        seq_len = tf.shape(x)[1]
​
        # 添加embedding和位置编码
        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)
​
        for i in range(self.num_layers):
            x = self.enc_layers[i](x, mask)
​
        return x
​
# 位置编码
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])  # apply sin to even indices in the array
    angle_rads[:, 1::2] = np.cos(angle_rads[:, 1::2])  # apply cos to odd indices in the array
    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

文本生成任务的示例代码

接下来是如何使用Transformer架构进行文本生成。这种生成任务可以视为基于语言模型的任务，即给定一部分文本，预测接下来的文本。

使用一个已经训练好的Transformer语言模型来生成文本，以下是简化的文本生成代码：

import numpy as np
import tensorflow as tf
from tensorflow.keras.preprocessing.sequence import pad_sequences
​
# 假设已经有了一个训练好的Transformer模型
# 为了生成文本，需要以下步骤：
​
def generate_text(model, tokenizer, seed_text, max_sequence_len, num_words):
    for _ in range(num_words):
        token_list = tokenizer.texts_to_sequences([seed_text])[0]  # 将种子文本转换为token序列
        token_list = pad_sequences([token_list], maxlen=max_sequence_len-1, padding='pre')  # 填充序列
        predicted = model.predict(token_list, verbose=0)  # 预测下一个单词
        predicted_word_index = np.argmax(predicted, axis=-1)  # 获取最大概率的单词索引
        output_word = ""
        for word, index in tokenizer.word_index.items():
            if index == predicted_word_index:
                output_word = word
                break
        seed_text += " " + output_word  # 更新种子文本
    return seed_text
​
# 使用示例：
seed_text = "The future of AI"
generated_text = generate_text(model, tokenizer, seed_text, max_sequence_len=10, num_words=50)
print(generated_text)

代码解释：

  1. 多头注意力机制：实现了Transformer中的核心模块——多头注意力机制，它可以让模型同时关注输入序列中的不同部分。

  2. 前馈神经网络：每一层中除了注意力机制外，还包含一个前馈网络以增强模型的表达能力。

  3. 位置编码：用于给Transformer提供序列位置信息。

  4. 文本生成函数：利用训练好的模型进行文本预测，逐步生成句子。

总结

Transformer凭借其并行化的结构、自注意力机制以及位置编码技术，能够非常有效地处理长距离依赖问题。它被广泛应用于各类自然语言处理任务，尤其是在大规模预训练语言模型中（如BERT、GPT等）。

标签：Transformer,num,--,self,attention,详解,tf,model
From： https://blog.csdn.net/GDHBFTGGG/article/details/142757895

相关文章

  • 深度除氟工艺-电化学法(学习笔记)
    电化学法通过以下操作达到深度除氟的目的：一、电化学原理应用电化学法主要利用电化学原理，在特定的电解装置中，通过电极的氧化还原反应，将废水中的氟离子进行转化和处理。这种转化可以是将氟离子转化为不溶性的氟化物，使其沉积在电极表面或通过其他方式从废水中分离出来。二、......
  • jsp城市旅游景点攻略系统g0921（程序+源码+数据库+调试部署+开发环境）
    本系统（程序+源码+数据库+调试部署+开发环境）带论文文档1万字以上，文末可获取，系统界面在最后面。系统程序文件列表用户,旅游线路,热门景点,风景图片,旅游攻略开题报告内容一、研究背景与意义随着旅游业的蓬勃发展，城市旅游景点攻略成为游客出行前的重要参考。然而，传统的攻略......
  • jsp城市公交查询系统455p7--（程序+源码+数据库+调试部署+开发环境）
    本系统（程序+源码+数据库+调试部署+开发环境）带论文文档1万字以上，文末可获取，系统界面在最后面。系统程序文件列表用户,站点查询,线路查询,站站查询开题报告内容一、课题背景及意义在快速发展的城市中，公共交通作为市民日常出行的重要方式，其便捷性和效率直接影响到市民的生活......
  • jsp城市公共广告位出租管理一体化项目的设计与实现6nma5
    本系统（程序+源码+数据库+调试部署+开发环境）带论文文档1万字以上，文末可获取，系统界面在最后面。系统程序文件列表开题报告内容一、研究背景随着城市化进程的加快，公共广告位作为城市商业活动的重要组成部分，其管理和出租效率直接影响到城市形象和商业活动的顺利进行。然而，传统......
  • jsp成都工业学院开放实验室预约系统ih8s7程序+源码+数据库+调试部署+开发环境
    本系统（程序+源码+数据库+调试部署+开发环境）带论文文档1万字以上，文末可获取，系统界面在最后面。系统程序文件列表用户,实验室,实验室预约,反馈信息,取消预约开题报告内容一、项目背景随着高校教育的不断发展和创新，实验室已成为教学和科研的重要场所。然而，传统的实验室预约......
  • 当代年轻人，都在利用AI实现婚纱照自由?
    随着国庆黄金假期的到来，一年一度的“全民结婚季”又将拉开序幕。准备婚服、婚车，宴请宾客和各种仪式流程，准新娘和新郎们忙得不可开交。一套精美的婚纱照，也是新人们的结婚必备。为什么一定要拍婚纱照？“婚纱照不仅仅是一个形式，还蕴含对美好生活的向往”、“记录会让回忆变......
  • CF708C Centroids [树形DP，换根DP]
    Description给定一棵树。至多进行一次操作：删去一条边，连接一条新边，保证操作完后仍是树。问每个点在进行操作后是否可以成为树的重心。Solution性质\(1\)：若一个点不是树的重心，则它的必然有一个大小大于\(\lfloorn/2\rfloor\)的子树。性质\(2\)：如果一个点合法，要么它本来......
  • Docker入门教程
    docker安装介绍"纸上得来终觉浅，绝知此事要躬行""天下没有难学的技术"docker简单介绍：Docker是什么？Docker其中包括，镜像、容器、仓库，很简单，目的就是通过对应用组件的封装、分发、部署、运行等生命周期的管理，使用户的产品（可以是web应用或者数据库应用）及其环境能够做到“一......
  • GUI图形界面 无代码开发 原理 - 属性标识链 | uiotos致敬amis、nodered、appsmith、co
    低代码饱受争议。也有例外：后端NodeRed，前端Amis。整体还是诟病为主：简单业务可以，复杂的是扯淡，不论前后端。这是一贯的认知。在GUI方面，UIOTOS发明的嵌套技术，为复杂前端的无代码开发，开辟了一条新的思路。往期文章：可视化拖拉拽？过时了！组态零代码，不能做复杂前端？嵌套原理一复杂交互......
  • 责任链模式
    简介责任链模式（ChainofResponsibilityPattern）将链中每一个节点都看作一个对象，每个节点处理的请求均不同，且内部自动维护下一个节点对象。当一个请求从链式的首端发出时，会沿着责任链预设的路径依次传递到每一个节点对象，直至被链中的某个对象处理为止，属于行为型设计模式。......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99