皮尔逊相关系数，LSTM

皮尔逊相关系数是一种用于衡量两个变量之间线性关系强度的统计量。它的取值范围在-1到1之间，其中1表示完全正相关，-1表示完全负相关，0表示没有线性关系。

LSTM（长短期记忆网络）是一种常用的循环神经网络（RNN）架构，用于处理序列数据。LSTM通过使用门控机制来捕捉长期依赖关系，可以有效地处理时间序列数据。

以下是皮尔逊相关系数和LSTM的介绍和演示：

1. 皮尔逊相关系数的介绍：
皮尔逊相关系数是一种常用的统计量，用于衡量两个变量之间的线性关系强度。它可以通过以下公式计算：

import numpy as np

# 计算皮尔逊相关系数
def pearson_correlation_coefficient(x, y):
    # 计算均值
    mean_x = np.mean(x)
    mean_y = np.mean(y)
    
    # 计算标准差
    std_x = np.std(x)
    std_y = np.std(y)
    
    # 计算协方差
    cov = np.cov(x, y)[0, 1]
    
    # 计算皮尔逊相关系数
    pearson_coefficient = cov / (std_x * std_y)
    
    return pearson_coefficient

# 示例数据
x = [1, 2, 3, 4, 5]
y = [2, 4, 6, 8, 10]

# 计算皮尔逊相关系数
pearson_coefficient = pearson_correlation_coefficient(x, y)
print("Pearson correlation coefficient:", pearson_coefficient)

2. LSTM的介绍：
LSTM是一种循环神经网络架构，用于处理序列数据。它通过使用门控机制来捕捉长期依赖关系，可以有效地处理时间序列数据。以下是一个简单的LSTM模型的示例代码：

import torch
import torch.nn as nn

# 定义LSTM模型
class LSTMModel(nn.Module):
    def __init__(self, input_size, hidden_size, num_layers, output_size):
        super(LSTMModel, self).__init__()
        self.hidden_size = hidden_size
        self.num_layers = num_layers
        self.lstm = nn.LSTM(input_size, hidden_size, num_layers, batch_first=True)
        self.fc = nn.Linear(hidden_size, output_size)
        
    def forward(self, x):
        h0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size).to(x.device)
        c0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size).to(x.device)
        
        out, _ = self.lstm(x, (h0, c0))
        out = self.fc(out[:, -1, :])
        
        return out

# 示例数据
input_size = 1
hidden_size = 32
num_layers = 2
output_size = 1
seq_length = 5
batch_size = 1

x = torch.tensor([[1], [2], [3], [4], [5]]).float()
y = torch.tensor([[2], [4], [6], [8], [10]]).float()

# 创建LSTM模型
model = LSTMModel(input_size, hidden_size, num_layers, output_size)

# 定义损失函数和优化器
criterion = nn.MSELoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)

# 训练模型
for epoch in range(100):
    outputs = model(x)
    loss = criterion(outputs, y)
    
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

# 预测结果
predicted = model(x)
print("Predicted values:", predicted.detach().numpy())