ICC2：copy block方法

五）自注意力机制（Self-Attention）

        自注意力机制（Self-Attention）是一种用于建模序列数据的注意力机制，最常用于自然语言处理领域中的序列建模任务，如机器翻译和语言生成。

        自注意力机制的核心思想是，通过计算序列中各个位置之间的注意力权重，来动态地为每个位置分配不同的重要性。每个位置都可以同时作为查询（query）、键（key）和值（value）进行计算，以便捕捉到序列中不同位置之间的关联信息。

        自注意力机制在 Transformer 模型等领域中被广泛应用，可以捕捉序列数据中不同位置之间的依赖关系，提供了更全局的建模能力。        

以下是一个使用PyTorch实现自注意力（Self-Attention）的示例代码：

import torch
import torch.nn as nn

class SelfAttention(nn.Module):
    def __init__(self, input_dim, num_heads):
        super(SelfAttention, self).__init__()
        self.input_dim = input_dim
        self.num_heads = num_heads
        self.head_dim = input_dim // num_heads

        self.query_fc = nn.Linear(input_dim, input_dim)
        self.key_fc = nn.Linear(input_dim, input_dim)
        self.value_fc = nn.Linear(input_dim, input_dim)
        self.output_fc = nn.Linear(input_dim, input_dim)

    def forward(self, inputs):
        batch_size, seq_len, _ = inputs.size()

        # 将输入进行线性变换
        query = self.query_fc(inputs)
        key = self.key_fc(inputs)
        value = self.value_fc(inputs)

        # 将线性变换的结果划分为多个头
        query = query.view(batch_size, seq_len, self.num_heads, self.head_dim)
        key = key.view(batch_size, seq_len, self.num_heads, self.head_dim)
        value = value.view(batch_size, seq_len, self.num_heads, self.head_dim)

        # 将头进行维度置换
        query = query.permute(0, 2, 1, 3)
        key = key.permute(0, 2, 1, 3)
        value = value.permute(0, 2, 1, 3)

        # 计算注意力权重
        weights = torch.matmul(query, key.permute(0, 1, 3, 2))
        weights = torch.softmax(weights / torch.sqrt(torch.tensor(self.head_dim, dtype=torch.float)), dim=-1)

        # 加权求和
        outputs = torch.matmul(weights, value)

        # 将头维度和序列维度合并
        outputs = outputs.permute(0, 2, 1, 3).contiguous()
        outputs = outputs.view(batch_size, seq_len, self.input_dim)

        # 应用输出线性变换
        outputs = self.output_fc(outputs)

        return outputs, weights

# 示例用法
input_dim = 128
num_heads = 4
seq_len = 10
batch_size = 32

# 创建输入数据
inputs = torch.randn(batch_size, seq_len, input_dim)

# 创建自注意力机制实例
attention = SelfAttention(input_dim, num_heads)

# 前向传播
outputs, weights = attention(inputs)

print("输入数据形状:", inputs.shape)
print("输出数据形状:", outputs.shape)
print("注意力权重形状:", weights.shape)

        在上述代码中，SelfAttention 类表示一个自注意力机制模块。它接受输入数据作为输入，通过对输入进行线性变换和头的划分，计算注意力权重，并将注意力权重应用于输入的加权求和。最后，将多个头的输出进行合并，并通过输出线性变换获得最终的输出。在示例中，输入数据的形状为 (batch_size, seq_len, input_dim) ， input_dim 是输入的特征维度，num_heads 是头的数量。输出数据的形状与输入数据的形状相同，注意力权重形状为(batch_size, num_heads, seq_len, seq_len)。

六）局部注意力机制（Local Attention）   

        局部注意力机制（Local Attention Mechanism）是一种注意力机制的变体，用于在序列数据中建模局部依赖关系，相比于自注意力机制更加节约计算资源。

        在传统的自注意力机制中，每个位置的查询（query）都会与序列中的所有位置的键（key）进行计算相似度，从而获得全局的注意力权重。然而，在某些情况下，全局的注意力计算可能过于昂贵或不必要，特别是当输入序列非常长时。

        局部注意力机制通过限制注意力权重的计算范围，仅在局部窗口内计算注意力权重，从而减少计算开销。

        以下是一个使用 PyTorch 实现局部注意力（Local Attention）的示例代码：

import torch
import torch.nn as nn

class LocalAttention(nn.Module):
    def __init__(self, input_dim, window_size):
        super(LocalAttention, self).__init__()
        self.input_dim = input_dim
        self.window_size = window_size

        self.query_fc = nn.Linear(input_dim, input_dim)
        self.key_fc = nn.Linear(input_dim, input_dim)
        self.value_fc = nn.Linear(input_dim, input_dim)
        self.output_fc = nn.Linear(input_dim, input_dim)

    def forward(self, query, key, value):
        batch_size, seq_len, _ = query.size()

        # 计算窗口的起始和结束位置
        start = max(0, seq_len - self.window_size)
        end = seq_len

        # 截取窗口内的部分
        query = query[:, start:end, :]
        key = key[:, start:end, :]
        value = value[:, start:end, :]

        # 将输入进行线性变换
        query_proj = self.query_fc(query)
        key_proj = self.key_fc(key)
        value_proj = self.value_fc(value)

        # 计算注意力权重
        weights = torch.matmul(query_proj, key_proj.permute(0, 2, 1))
        weights = torch.softmax(weights, dim=-1)

        # 加权求和
        outputs = torch.matmul(weights, value_proj)

        # 应用输出线性变换
        outputs = self.output_fc(outputs)

        return outputs, weights

# 示例用法
input_dim = 128
window_size = 5
seq_len = 10
batch_size = 32

# 创建输入数据
query = torch.randn(batch_size, seq_len, input_dim)
key = torch.randn(batch_size, seq_len, input_dim)
value = torch.randn(batch_size, seq_len, input_dim)

# 创建局部注意力机制实例
attention = LocalAttention(input_dim, window_size)

# 前向传播
outputs, weights = attention(query, key, value)

print("查询数据形状:", query.shape)
print("键数据形状:", key.shape)
print("值数据形状:", value.shape)
print("输出数据形状:", outputs.shape)
print("注意力权重形状:", weights.shape)

        在上述代码中，LocalAttention 类表示一个局部注意力机制模块。它接受查询（query）、键（key）和值（value）作为输入，并根据窗口大小截取输入的一部分进行处理。然后，通过线性变换计算注意力权重，并将权重应用于值的加权求和。最后，通过输出线性变换获得最终的输出。在示例中，查询、键和值的形状都是(batch_size, seq_len, input_dim)，input_dim 是输入的特征维度，window_size 是窗口的大小。输出数据的形状与输入数据的形状相同，注意力权重的形状为(batch_size, seq_len, seq_len)。

        局部注意力机制通过引入窗口大小的限制，降低了计算复杂度，并且更加关注于局部的上下文信息。这使得它适用于处理长序列时的计算和内存效率问题，并且在一些任务中可能更能捕捉到重要的局部依赖关系。

七）基于内容的注意力机制（Content-based Attention）

        基于内容的注意力机制（Content-Based Attention Mechanism）是一种注意力机制的变体，用于在序列数据中根据内容的相似性来计算注意力权重。

        在传统的自注意力机制中，注意力权重的计算通常是基于查询（query）和键（key）之间的相似度，而与序列数据的内容无关。而基于内容的注意力机制则侧重于利用序列数据的内容信息来计算注意力权重。

        基于内容的注意力机制可以根据输入的内容信息计算注意力权重，突出与当前查询相关的重要部分。

        基于内容的注意力（Content-based Attention）通常与序列到序列（sequence-to-sequence）任务一起使用，例如机器翻译或文本摘要。下面是一个基于内容的注意力的简化示例代码：

import torch
import torch.nn as nn

class ContentBasedAttention(nn.Module):
    def __init__(self):
        super(ContentBasedAttention, self).__init__()

    def forward(self, query, key, value):
        # 计算相似性得分
        similarity = torch.matmul(query, key.transpose(-2, -1))

        # 计算注意力权重
        weights = torch.softmax(similarity, dim=-1)

        # 加权求和
        outputs = torch.matmul(weights, value)

        return outputs, weights

# 示例用法
input_dim = 128
seq_len = 10
batch_size = 32

# 创建输入数据
query = torch.randn(batch_size, seq_len, input_dim)
key = torch.randn(batch_size, seq_len, input_dim)
value = torch.randn(batch_size, seq_len, input_dim)

# 创建基于内容的注意力机制实例
attention = ContentBasedAttention()

# 前向传播
outputs, weights = attention(query, key, value)

print("查询数据形状:", query.shape)
print("键数据形状:", key.shape)
print("值数据形状:", value.shape)
print("输出数据形状:", outputs.shape)
print("注意力权重形状:", weights.shape)

        在上述代码中，ContentBasedAttention 类表示一个基于内容的注意力机制模块。它接受查询（query）、键（key）和值（value）作为输入，通过计算查询和键之间的相似性得分，然后使用 softmax 函数对得分进行归一化，得到注意力权重。最后，使用注意力权重对值进行加权求和。在示例中，查询、键和值的形状都是(batch_size, seq_len, input_dim)。输出数据的形状与值的形状相同，注意力权重的形状为(batch_size, seq_len, seq_len)。

        基于内容的注意力机制允许模型在计算注意力权重时考虑序列数据的内容相似性，更关注与查询内容相似的位置。这种机制有助于模型更好地理解和处理输入序列中的相关信息，并更好地捕捉到序列中的重要内容。

八）基于位置的注意力机制（Position-based Attention）

        基于位置的注意力机制（Position-Based Attention Mechanism）是一种注意力机制的变体，用于在序列数据中根据位置信息来计算注意力权重。

        在传统的自注意力机制中，注意力权重的计算通常是基于查询（query）和键（key）之间的相似度。而基于位置的注意力机制则侧重于根据位置的远近来计算注意力权重。

        基于位置的注意力机制可以根据序列中不同位置之间的相对位置信息计算注意力权重，捕捉到序列中的位置顺序和依赖关系。

        基于位置的注意力（Position-based Attention）通常与序列任务一起使用，例如自然语言处理中的语言建模或机器翻译。下面是一个基于位置的注意力的简化示例代码：

import torch
import torch.nn as nn

class PositionBasedAttention(nn.Module):
    def __init__(self):
        super(PositionBasedAttention, self).__init__()

    def forward(self, query, key, value):
        # 获取序列长度
        seq_len = query.size(1)

        # 计算位置编码
        position_encoding = torch.arange(seq_len, dtype=torch.float).unsqueeze(0).to(query.device)
        position_encoding = position_encoding.unsqueeze(-1)

        # 计算相似性得分
        similarity = torch.matmul(query + position_encoding, key.transpose(-2, -1))

        # 计算注意力权重
        weights = torch.softmax(similarity, dim=-1)

        # 加权求和
        outputs = torch.matmul(weights, value)

        return outputs, weights

# 示例用法
input_dim = 128
seq_len = 10
batch_size = 32

# 创建输入数据
query = torch.randn(batch_size, seq_len, input_dim)
key = torch.randn(batch_size, seq_len, input_dim)
value = torch.randn(batch_size, seq_len, input_dim)

# 创建基于位置的注意力机制实例
attention = PositionBasedAttention()

# 前向传播
outputs, weights = attention(query, key, value)

print("查询数据形状:", query.shape)
print("键数据形状:", key.shape)
print("值数据形状:", value.shape)
print("输出数据形状:", outputs.shape)
print("注意力权重形状:", weights.shape)

        在上述代码中，PositionBasedAttention 类表示一个基于位置的注意力机制模块。它接受查询（query）、键（key）和值（value）作为输入，并根据序列的位置编码计算相似性得分。然后，使用 softmax 函数对得分进行归一化，得到注意力权重。最后，使用注意力权重对值进行加权求和。在示例中，查询、键和值的形状都是(batch_size, seq_len, input_dim)。输出数据的形状与值的形状相同，注意力权重的形状为(batch_size, seq_len, seq_len)。

        基于位置的注意力机制允许模型根据位置的远近来调整注意力权重，更关注于相对位置较近的位置。这种机制有助于模型更好地理解和捕捉序列中的局部或全局依赖关系，并更好地处理序列数据。在处理长序列或需要考虑位置信息的任务中，基于位置的注意力机制可以提供更好的建模能力。