论文：FEED-FORWARD NETWORKS WITH ATTENTION CAN SOLVE SOME LONG-TERM MEMORY PROBLEMS

import torch
import torch.nn as nn

class LSTMModel(nn.Module):
    """Single task LSTM model with attention mechanism."""
    
    def __init__(self, cfg, lstmmodel_cfg):
        """
        Initialize the LSTM model with attention mechanism.
        
        Parameters:
        - cfg: A dictionary containing configuration such as dropout rate.
        - lstmmodel_cfg: A dictionary containing configuration for LSTM such as input_size, hidden_size, and out_size.
        """
        super(LSTMModel, self).__init__()
        self.lstm = nn.LSTM(
            input_size=lstmmodel_cfg["input_size"], 
            hidden_size=lstmmodel_cfg["hidden_size"], 
            batch_first=True
        )
        self.drop = nn.Dropout(p=cfg["dropout_rate"])
        self.dense = nn.Linear(lstmmodel_cfg["hidden_size"], lstmmodel_cfg["out_size"])
        self.attention_vector = nn.Parameter(torch.rand(lstmmodel_cfg["hidden_size"], 1))

    def attention(self, lstm_output):
        """
        Compute attention weights and apply to LSTM outputs.

        Parameters:
        - lstm_output: The output of the LSTM layer.

        Returns:
        - The context vector, attention weights.
        """
        attention_weights = torch.tanh(lstm_output) @ self.attention_vector
        attention_weights = torch.softmax(attention_weights.squeeze(2), dim=1)
        context_vector = torch.sum(lstm_output * attention_weights.unsqueeze(-1), dim=1)
        return context_vector, attention_weights

    def forward(self, inputs):
        """
        Forward pass for the LSTM model with attention mechanism.
        
        Parameters:
        - inputs: The input tensor to the LSTM.

        Returns:
        - The output of the model after applying LSTM, attention, dropout, and dense layer.
        """
        # Pass input through LSTM layer
        lstm_out, (hidden, cell) = self.lstm(inputs.float())
        
        # Compute attention
        context_vector, attention_weights = self.attention(lstm_out)
        
        # Apply dropout to the context vector
        context_vector = self.drop(context_vector)
        
        # Pass the context vector through the dense layer to get final output
        output = self.dense(context_vector)
        
        return output

# Example configuration
cfg = {
    "dropout_rate": 0.5
}

lstmmodel_cfg = {
    "input_size": 10,  # 10 features
    "hidden_size": 128, # size of LSTM hidden states
    "out_size": 1  # output size
}

# Instantiate the model
model = LSTMModel(cfg, lstmmodel_cfg)

# Print the model
print(model)

# Example input
inputs = torch.randn(64, 7, 10)  # 64 batches, 7 days, 10 features

# Forward pass
outputs = model(inputs)
print(outputs.shape)  # Expected shape: (64, 1) since we are predicting one output per batch

attention_weights = torch.tanh(lstm_output) @ self.attention_vector这里面的@ self.attention_vector是啥意思
在PyTorch中，符号 `@` 表示矩阵乘法。这是Python 3.5+ 引入的操作符，用于替代 `numpy` 和 `torch` 中的 `matmul` 函数。

在您提供的代码段：

```python
attention_weights = torch.tanh(lstm_output) @ self.attention_vector

lstm_output 通常是一个三维张量，其形状为 (batch_size, sequence_length, hidden_size)。self.attention_vector 是一个二维参数向量，其形状为 (hidden_size, 1)。在这里，torch.tanh(lstm_output) 对 lstm_output 的每个元素应用了双曲正切函数，这是一种激活函数，可以将输入值压缩到 ([-1, 1]) 的范围内。

@ 操作符执行矩阵乘法。在这个上下文中，它将 lstm_output 的每个时间步骤的输出与 attention_vector 相乘，结果是一个形状为 (batch_size, sequence_length, 1) 的张量，它表示每个时间步骤对于计算上下文向量 c 的重要性。这个权重随后会通过 softmax 函数标准化，以确定最终的注意力分布。

所以简而言之，这行代码计算了每个时间步的隐藏状态的加权和，其中权重由 attention_vector 决定，其结果是注意力权重，表示模型应该在序列的哪些部分集中注意力。

</details>


<details>
<summary>self.attention_vector = nn.Parameter(torch.rand(lstmmodel_cfg["hidden_size"], 1))，为啥有rand？论文里有？

</summary>

在您提供的代码段中：

self.attention_vector = nn.Parameter(torch.rand(lstmmodel_cfg["hidden_size"], 1))

这行代码创建了一个随机初始化的参数向量，它将被用作注意力机制中的权重。在PyTorch中，nn.Parameter是一种特殊类型的张量，它会自动被认为是模型的参数，因此在训练过程中会被优化。

使用torch.rand来初始化参数是一种常见的做法，它从一个均匀分布中随机生成数值，其值在0到1之间。这是为了打破对称性并允许梯度下降算法在训练过程中有效地工作。随机初始化可以帮助避免所有权重开始时具有相同的值，这可能导致优化过程陷入局部最小值。

关于论文内容，根据您引用的内容，论文中提出了一种简化的注意力机制，它可以用于生成整个序列的单个向量 ( c )，并且提到了权重 ( \alpha ) 是通过可学习的函数 ( a ) 来计算的【20†source】【21†source】。虽然论文中没有明确提到使用torch.rand初始化，但在实际应用中，参数的随机初始化是标准做法，特别是在没有先验信息指导初始化时。论文提出的模型框架是理论上的，而代码实现时的细节如参数初始化通常会在具体的实验设置中详细说明。

</details>

------------