第6篇：Transformer架构详解（下）：多头注意力机制与位置编码

最新推荐文章于 2024-08-24 15:57:09 发布

Gemini技术窝

最新推荐文章于 2024-08-24 15:57:09 发布

阅读量90

点赞数 1

分类专栏：从零开始掌握ChatGPT：核心技术揭秘及项目实战文章标签： transformer 深度学习人工智能自然语言处理机器学习 chatgpt nlp

本文链接：https://blog.csdn.net/wjm1991/article/details/140082168

版权

从零开始掌握ChatGPT：核心技术揭秘及项目实战专栏收录该内容

55 篇文章 1 订阅 ¥29.90 ¥99.00

订阅专栏

超级会员免费看

Transformer模型自提出以来，已经在自然语言处理（NLP）领域取得了巨大的成功。其核心创新包括多头注意力机制和位置编码，这些技术使得Transformer能够高效处理长序列数据。本文将详细介绍多头注意力机制和位置编码的原理、作用及其实现，并通过Python代码示例和应用场景讲解，帮助零基础读者全面理解这些关键技术。我们还将使用幽默的比喻，使这些复杂的概念更加易懂。

多头注意力机制

基本原理

多头注意力机制是Transformer模型的核心组件，通过并行计算多个自注意力，将不同头的输出拼接在一起，增强模型的多样性和鲁棒性。简单来说，多头注意力机制让模型在同一时间内从不同的角度“看”数据，从而捕捉更多的信息。

比喻：多部门会议

想象一下，多头注意力机制就像是一个大型公司举行的多部门会议。每个部门（自注意力头）都有自己的关注点，他们分别讨论各自关注的问题。最终，各部门的讨论结果汇总在一起，形成一个全面的会议报告。

计算步骤

多个自注意力头：将输入序列分别通过多个查询、键和值的线性变换，得到多个自注意力头。
独立计算注意力：每个自注意力头独立地计算注意力分数和加权求和。
拼接与线性变换：将所有自注意力头的输出拼接起来，进行线性变换，得到最终输出。

具体公式如下：

多头自注意力机制：
$\text{MultiHead}(Q, K, V) = \text{Concat}(\text{head}_1, \text{head}_2, \ldots, \text{head}_h) W_O$
其中， $(\text{head}_i = \text{Attention}(QW_{Q_i}, KW_{K_i}, VW_{V_i}))，( W_O )$ 是拼接后的线性变换矩阵。

如何增强模型的多样性和鲁棒性

多样性

多头注意力机制通过并行计算多个注意力头，每个头独立地关注输入序列的不同部分，从而捕捉到更多的细节和信息。这种机制增强了模型的多样性，使得模型在处理复杂任务时能够考虑到更多的因素。

示例

考虑以下句子：

“小明喜欢吃苹果，因为苹果很甜。”

在这个句子中，多头注意力机制的不同头可以分别关注：

"小明"和"喜欢"之间的关系。
"苹果"和"甜"之间的关系。
"因为"和整个句子之间的因果关系。

这种多样性使得模型能够更全面地理解句子的含义，生成更加准确和连贯的文本。

鲁棒性

多头注意力机制通过独立计算多个注意力头，减少了单一注意力头对模型性能的影响。如果某个注意力头的计算出现偏差，其他注意力头可以补偿这个偏差，从而提高模型的鲁棒性。

示例

考虑以下句子：

“自然语言处理技术在各个领域取得了显著进展。”

在这个句子中，如果某个注意力头因为噪声或其他原因没有正确捕捉到"自然语言处理"和"技术"之间的关系，其他注意力头仍然可以通过捕捉到其他部分的信息来补偿这个偏差，确保模型能够正确理解句子的含义。

代码实现：多头注意力机制

以下是一个使用Python和TensorFlow实现多头注意力机制的简化示例代码，包含丰富的中文注释。

import numpy as np
import tensorflow as tf
from tensorflow.keras.layers import Dense, LayerNormalization

# 定义自注意力机制
class SelfAttention(tf.keras.layers.Layer):
    def __init__(self, d_model, num_heads):
        super(SelfAttention, 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):
        """
        将最后一个维度分割成 (num_heads, depth)
        返回的形状为: (batch_size, num_heads, seq_len, depth)
        """
        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)  # (batch_size, seq_len, d_model)
        k = self.wk(k)  # (batch_size, seq_len, d_model)
        v = self.wv(v)  # (batch_size, seq_len, d_model)

        q = self.split_heads(q, batch_size)  # (batch_size, num_heads, seq_len_q, depth)
        k = self.split_heads(k, batch_size)  # (batch_size, num_heads, seq_len_k, depth)
        v = self.split_heads(v, batch_size)  # (batch_size, num_heads, seq_len_v, depth)

        # 计算注意力分数
        matmul_qk = tf.matmul(q, k, transpose_b=True)  # (batch_size, num_heads, seq_len_q, seq_len_k)

        # 缩放 matmul_qk
        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)  # (batch_size, num_heads, seq_len_q, seq_len_k)

        # 计算注意力输出
        scaled_attention = tf.matmul(attention_weights, v)  # (batch_size, num_heads, seq_len_v, depth)

        scaled_attention = tf.transpose(scaled_attention, perm=[0, 2, 1, 3])  # (batch_size, seq_len_v, num_heads, depth)

        concat_attention = tf.reshape(scaled_attention, (batch_size, -1, self.d_model))  # (batch_size, seq_len_v, d_model)

        output = self.dense(concat_attention)  # (batch_size, seq_len_v, d_model)

        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

        self.self_attention = SelfAttention(d_model, num_heads)
        self.layernorm = LayerNormalization(epsilon=1e-6)

    def call(self, v, k, q, mask):
        attn_output, attention_weights = self.self_attention(v, k, q, mask)
        out = self.layernorm(attn_output + q)
        return out, attention_weights

# 测试多头注意力机制
sample_multi_head_attention = MultiHeadAttention(d_model=512, num_heads=8)
y = tf.random.uniform((1, 60, 512))  # 随机输入数据
out, attn = sample_multi_head_attention(y, y, y, None)
print(out.shape)  # 输出的形状
print(attn.shape)  # 注意力权重的形状

位置编码的作用与实现

位置编码的作用

Transformer模型不使用循环结构，因此无法直接捕捉序列中各元素的位置关系。为了弥补这一点，位置编码（Positional Encoding）被引入到Transformer模型中，帮助模型了解序列中各元素的位置。

比喻：队列中的人

想象一下，你和朋友在排队买票。每个人都有自己的队列位置，虽然你们的对话内容可以随意，但队列位置决定了每个人的先后顺序。位置编码就像给每个人发一个编号，这样即使不使用循环结构，模型也能知道每个词在序列中的位置。

位置编码的实现

位置编码的具体实现通过将位置编码与输入序列相加，位置编码可以是固定的，也可以是可训练的。本文主要介绍固定位置编码。

计算公式

位置编码通常使用正弦和余弦函数进行计算，其公式如下：

对于序列中的第 ( pos ) 个位置和第 ( i ) 个维度，位置编码的计算公式为：
$PE_{(pos, 2i)} = \sin\left(\frac{pos}{10000^{2i/d_{model}}}\right)$
$PE_{(pos, 2i+1)} = \cos\left(\frac{pos}{10000^{2i/d_{model}}}\right)$
其中，( pos ) 是位置，( i ) 是维度索引，( d_{model} ) 是模型的维度。

代码实现：位置编码

以下是一个使用Python和TensorFlow实现位置编码的简化示例代码，包含丰富的中文注释。

import numpy as np
import tensorflow as tf

# 定义位置编码层
class PositionalEncoding(tf.keras.layers.Layer):
    def __init__(self, position, d_model):
        super(PositionalEncoding, self).__init__()
        self.position = position
        self.d_model = d_model

        # 创建位置编码矩阵
        angle_rads = self.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])
        self.pos_encoding = angle_rads[np.newaxis, ...]

    def get_angles(self, pos, i, d_model):
        """
        计算位置编码的角度
        """
       

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

    def call(self, inputs):
        """
        在输入数据上添加位置编码
        """
        seq_len = tf.shape(inputs)[1]
        return inputs + tf.cast(self.pos_encoding[:, :seq_len, :], tf.float32)

# 测试位置编码层
sample_pos_encoding = PositionalEncoding(position=50, d_model=512)
y = tf.random.uniform((1, 50, 512))  # 随机输入数据
out = sample_pos_encoding(y)
print(out.shape)  # 输出的形状

位置编码在Transformer模型中的作用

提供位置信息

位置编码使得模型能够区分序列中不同位置的元素。通过将位置向量加到输入嵌入向量上，模型在处理序列数据时可以知道每个词的位置，从而捕捉到序列中的位置信息。

示例

考虑以下句子：

“我喜欢吃苹果。”

在这个句子中，每个词的位置信息非常重要。通过位置编码，模型能够区分出“我”在句子开头，“苹果”在句子末尾。这种位置信息对于理解句子的语义结构至关重要。

捕捉长距离依赖关系

位置编码帮助模型捕捉长距离依赖关系。由于自注意力机制可以直接计算序列中任意两个位置之间的相似度，位置编码进一步增强了这种能力，使得模型能够更好地理解句子中的长距离依赖关系。

示例

考虑以下句子：

“虽然今天下雨，但是小明还是决定去跑步。”

在这个句子中，“下雨”和“跑步”之间存在长距离依赖关系。位置编码使得模型在计算自注意力时能够考虑到这些依赖关系，从而更准确地理解句子的含义。

提升模型的表达能力

通过提供位置信息，位置编码提升了模型的表达能力，使得模型能够更好地捕捉序列中的结构和语义信息。这种能力对于生成高质量的文本至关重要。

应用场景

自然语言处理

位置编码在自然语言处理任务中发挥了重要作用，使Transformer模型能够捕捉序列中的位置关系。以下是一个使用位置编码和Transformer进行文本分类的简化示例代码。

import tensorflow as tf
from tensorflow.keras.layers import Dense, Embedding, LayerNormalization, Dropout, GlobalAveragePooling1D

# 定义Transformer块
class TransformerBlock(tf.keras.layers.Layer):
    def __init__(self, d_model, num_heads, dff, rate=0.1):
        super(TransformerBlock, self).__init__()
        self.mha = MultiHeadAttention(d_model, num_heads)
        self.ffn = tf.keras.Sequential([
            Dense(dff, activation='relu'),
            Dense(d_model)
        ])
        self.layernorm1 = LayerNormalization(epsilon=1e-6)
        self.layernorm2 = LayerNormalization(epsilon=1e-6)
        self.dropout1 = Dropout(rate)
        self.dropout2 = 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)
        return self.layernorm2(out1 + ffn_output)

# 定义文本分类模型
class TextClassificationModel(tf.keras.Model):
    def __init__(self, num_layers, d_model, num_heads, dff, input_vocab_size, target_vocab_size, max_positional_encoding, rate=0.1):
        super(TextClassificationModel, self).__init__()
        self.embedding = Embedding(input_vocab_size, d_model)
        self.pos_encoding = PositionalEncoding(max_positional_encoding, d_model)
        self.transformer_blocks = [TransformerBlock(d_model, num_heads, dff, rate) for _ in range(num_layers)]
        self.global_avg_pool = GlobalAveragePooling1D()
        self.dropout = Dropout(rate)
        self.final_layer = Dense(target_vocab_size, activation='softmax')

    def call(self, x, training, mask):
        x = self.embedding(x)
        x *= tf.math.sqrt(tf.cast(tf.shape(x)[-1], tf.float32))
        x = self.pos_encoding(x)
        for transformer_block in self.transformer_blocks:
            x = transformer_block(x, training, mask)
        x = self.global_avg_pool(x)
        x = self.dropout(x, training=training)
        return self.final_layer(x)

# 测试文本分类模型
sample_text_classification_model = TextClassificationModel(
    num_layers=2, d_model=512, num_heads=8, dff=2048,
    input_vocab_size=8500, target_vocab_size=2, max_positional_encoding=5000, rate=0.1)

temp_input = tf.random.uniform((64, 200), dtype=tf.int64, minval=0, maxval=200)
fn_out = sample_text_classification_model(temp_input, training=False, mask=None)
print(fn_out.shape)  # 输出的形状

时间序列分析

Transformer模型及其位置编码在时间序列分析中也具有广泛应用，如股票预测、气象数据分析等。位置编码使模型能够捕捉时间序列中的时序关系，提高预测性能。

代码示例：时间序列预测

以下是一个使用位置编码和Transformer进行时间序列预测的简化示例代码，包含丰富的中文注释。

import tensorflow as tf
from tensorflow.keras.layers import Dense, LayerNormalization, Dropout

# 定义位置编码层
class PositionalEncoding(tf.keras.layers.Layer):
    def __init__(self, position, d_model):
        super(PositionalEncoding, self).__init__()
        self.position = position
        self.d_model = d_model

        # 创建位置编码矩阵
        angle_rads = self.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])
        self.pos_encoding = angle_rads[np.newaxis, ...]

    def get_angles(self, pos, i, d_model):
        """
        计算位置编码的角度
        """
        angle_rates = 1 / np.power(10000, (2 * (i // 2)) / np.float32(d_model))
        return pos * angle_rates

    def call(self, inputs):
        """
        在输入数据上添加位置编码
        """
        seq_len = tf.shape(inputs)[1]
        return inputs + tf.cast(self.pos_encoding[:, :seq_len, :], tf.float32)

# 定义Transformer块
class TransformerBlock(tf.keras.layers.Layer):
    def __init__(self, d_model, num_heads, dff, rate=0.1):
        super(TransformerBlock, self).__init__()
        self.mha = MultiHeadAttention(d_model, num_heads)
        self.ffn = tf.keras.Sequential([
            Dense(dff, activation='relu'),
            Dense(d_model)
        ])
        self.layernorm1 = LayerNormalization(epsilon=1e-6)
        self.layernorm2 = LayerNormalization(epsilon=1e-6)
        self.dropout1 = Dropout(rate)
        self.dropout2 = 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)
        return self.layernorm2(out1 + ffn_output)

# 定义时间序列预测模型
class TimeSeriesPredictionModel(tf.keras.Model):
    def __init__(self, num_layers, d_model, num_heads, dff, input_vocab_size, max_positional_encoding, rate=0.1):
        super(TimeSeriesPredictionModel, self).__init__()
        self.embedding = Dense(d_model)
        self.pos_encoding = PositionalEncoding(max_positional_encoding, d_model)
        self.transformer_blocks = [TransformerBlock(d_model, num_heads, dff, rate) for _ in range(num_layers)]
        self.global_avg_pool = GlobalAveragePooling1D()
        self.dropout = Dropout(rate)
        self.final_layer = Dense(1)  # 输出为单个预测值

    def call(self, x, training, mask):
        x = self.embedding(x)
        x *= tf.math.sqrt(tf.cast(tf.shape(x)[-1], tf.float32))
        x = self.pos_encoding(x)
        for transformer_block in self.transformer_blocks:
            x = transformer_block(x, training, mask)
        x = self.global_avg_pool(x)
        x = self.dropout(x, training=training)
        return self.final_layer(x)

# 测试时间序列预测模型
sample_time_series_prediction_model = TimeSeriesPredictionModel(
    num_layers=2, d_model=512, num_heads=8, dff=2048,
    input_vocab_size=1, max_positional_encoding=200, rate=0.1)

temp_input = tf.random.uniform((64, 200, 1), dtype=tf.float32)
fn_out = sample_time_series_prediction_model(temp_input, training=False, mask=None)
print(fn_out.shape)  # 输出的形状

结论

Transformer模型通过自注意力机制和位置编码的引入，解决了传统序列模型在处理长序列时的效率和性能问题。多头注意力机制使得模型能够从多个角度同时关注数据，位置编码帮助模型捕捉序列中的位置信息。本文详细介绍了这些关键技术的原理、作用及其实现，并通过具体应用场景和Python代码示例展示了其应用。希望通过这些内容，能够帮助零基础的读者更好地理解和应用Transformer模型技术。

如果你喜欢这篇文章，别忘了收藏文章、关注作者、订阅专栏，感激不尽。

Gemini技术窝

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
第6篇：Transformer架构详解（下）：多头注意力机制与位置编码

Transformer模型自提出以来，已经在自然语言处理（NLP）领域取得了巨大的成功。其核心创新包括多头注意力机制和位置编码，这些技术使得Transformer能够高效处理长序列数据。本文将详细介绍多头注意力机制和位置编码的原理、作用及其实现，并通过Python代码示例和应用场景讲解，帮助零基础读者全面理解这些关键技术。我们还将使用幽默的比喻，使这些复杂的概念更加易懂。
复制链接

扫一扫