Transformer介绍和代码示例_给我一个简单的transformer示例-CSDN博客

Transformer简介

Transformer是一种用于处理序列数据的深度学习模型，首次在2017年的论文《Attention is All You Need》中提出。与传统的RNN和LSTM不同，Transformer完全基于自注意力机制（self-attention），能够并行处理序列数据，从而显著提高训练效率。

Transformer的结构

Transformer模型主要由以下几个部分组成：

输入嵌入（Input Embedding）：
- 将输入序列转换为向量表示。
位置编码（Positional Encoding）：
- 由于Transformer没有循环结构，位置编码用于为输入序列提供位置信息，通常使用正弦和余弦函数。
编码器（Encoder）：
- 由多个相同的层堆叠而成，每层包含两个主要部分：
  - 自注意力机制（Self-Attention）：计算输入序列中每个位置对其他位置的关注程度。
  - 前馈神经网络（Feed-Forward Neural Network）：对自注意力的输出进行非线性变换。
解码器（Decoder）：
- 结构与编码器相似，但额外包含对编码器输出的自注意力机制，生成目标序列。
输出层（Output Layer）：
- 将解码器的输出转换为目标词汇的概率分布，通常使用softmax函数。

Transformer的优点

并行化：Transformer能够并行处理序列数据，显著提高训练速度。
长距离依赖：自注意力机制使得模型能够有效捕捉长距离的上下文信息。
灵活性：适用于多种任务，如机器翻译、文本生成、图像处理等。

Transformer的Python代码示例

以下是一个使用TensorFlow和Keras实现的简单Transformer模型的示例，用于文本分类任务。

import tensorflow as tf
from tensorflow.keras import layers, models

# 定义位置编码
def positional_encoding(max_position, d_model):
    pos = tf.arange(max_position, dtype=tf.float32)[:, tf.newaxis]
    i = tf.arange(d_model, dtype=tf.float32)[tf.newaxis, :]
    angle_rates = 1 / tf.pow(10000, (2 * (i // 2)) / tf.cast(d_model, tf.float32))
    angle_rads = pos * angle_rates
    angle_rads[:, 0::2] = tf.sin(angle_rads[:, 0::2])  # 偶数索引
    angle_rads[:, 1::2] = tf.cos(angle_rads[:, 1::2])  # 奇数索引
    return angle_rads

# 自注意力层
class MultiHeadAttention(layers.Layer):
    def __init__(self, num_heads, d_model):
        super(MultiHeadAttention, self).__init__()
        self.num_heads = num_heads
        self.d_model = d_model
        self.depth = d_model // num_heads
        self.wq = layers.Dense(d_model)
        self.wk = layers.Dense(d_model)
        self.wv = layers.Dense(d_model)
        self.dense = 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):
        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_logits = tf.matmul(q, k, transpose_b=True)
        scaled_attention_logits /= tf.sqrt(tf.cast(self.depth, tf.float32))
        attention_weights = tf.nn.softmax(scaled_attention_logits, axis=-1)
        output = tf.matmul(attention_weights, v)

        output = tf.transpose(output, perm=[0, 2, 1, 3])
        output = tf.reshape(output, (batch_size, -1, self.d_model))
        return self.dense(output)

# Transformer模型
def create_transformer_model(input_shape, num_classes):
    inputs = layers.Input(shape=input_shape)
    x = layers.Embedding(input_dim=10000, output_dim=64)(inputs)
    x += positional_encoding(100, 64)

    # 编码器
    x = MultiHeadAttention(num_heads=4, d_model=64)(x, x, x)
    x = layers.GlobalAveragePooling1D()(x)
    x = layers.Dense(32, activation='relu')(x)
    outputs = layers.Dense(num_classes, activation='softmax')(x)

    model = models.Model(inputs, outputs)
    return model

# 创建模型并编译
model = create_transformer_model((100,), num_classes=10)
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])

# 打印模型摘要
model.summary()

代码解释

位置编码：
- positional_encoding函数生成位置编码，使用正弦和余弦函数为每个位置生成唯一的表示。
自注意力层：
- MultiHeadAttention类实现了多头自注意力机制，包含输入的线性变换和注意力计算。
Transformer模型：
- create_transformer_model函数构建了一个简单的Transformer模型，包括嵌入层、位置编码、自注意力层和全连接层。
模型创建与编译：
- 使用create_transformer_model函数创建模型，并使用Adam优化器和稀疏分类交叉熵损失函数进行编译。