本文链接：https://blog.csdn.net/gldzkjdxwzs/article/details/129774150

2、ST-LSTM 的雷暴预测网络

摘要

本周在论文阅读上，阅读了一篇基于时空记忆解耦RNN的雷暴预测方法论文，ST-LSTM循环神经网络在雷暴预测方面的效果优于单体质心法和 MIM 网络。当加入记忆解耦结构时效果更好，尤其针对大片回波区域内部的强回波区，能更好地预测其发展趋势。在深度学习上，完成项目的部分demo和实现一个基于卷积神经网络的元胞自动机模型。

This week,in terms of thesis reading,perusaling a paper on thunderstorm prediction methods based on spatiotemporal memory decoupling RNN.The ST-LSTM recurrent neural network has better effects in thunderstorm prediction than the single body mental method and the MIM network.When adding a memory decoupling structure, the effect is better, especially for strong echo areas within large echo areas, which can better predict their development trend.In deep learning,completing part of the project's demo and implementing a cellular automata model based on convolutional neural networks.

论文阅读

1、题目和现存问题

题目：基于时空记忆解耦 RNN 的雷暴预测方法

现存问题：传统的雷暴预测方法主要有单体质心法、光流法和交叉相关法。这些方法仅利用若干个连续时刻的雷达回波图像推测下一时刻雷暴位置，忽略了在实际情况中雷暴的移动通常是非线性的，存在对历史雷达资料利用率不足和外推时效较短的局限。

解决方法：神经网络模型具有强大的非线性映射能力，且对数据的利用率大大提高。

2、ST-LSTM 的雷暴预测网络

循环神经网络是一类以时序数据作为输入，在序列演进方向进行递归且所有节点按链式连接的网络结构。雷暴的预测实质上是时间序列数据的外推问题，这很符合循环神经网络的特性。文章采用了带有记忆解耦结构的 ST-LSTM 单元组成的网络模型。

ST-LSTM 单元是在 LSTM 单元的基础上进行扩展，它包含两个记忆模块：时间记忆单元和空间记忆单元。时间记忆单元 C 也就是LSTM 单元中的结构，负责横向时间流的传递；空间记忆单元 M 负责层与层之间空间记忆的传递，它从同一时间步的l-1层垂直传递到当前节点。最后将这两个记忆单元的内容进行融合，并使用一个1*1卷积层进行降维，使得该单元的隐藏输出具有和任一记忆单元相同的维度。在雷暴预测中，ST-LSTM 单元的优势在于将状态之间的转化改为卷积形式，使得网络模型可以同时提取到时间信息以及空间特征，并且两种记忆类型使用共享输出门来实现无缝记忆融合，这可以有效地模拟雷暴时空序列的形状和运动轨迹信息。

文章在ST-LSTM单元的基础上加入了一种记忆解耦结构，以分离时间和空间记忆状态，避免由于记忆状态的纠缠导致网络参数的低效利用进而影响雷暴预测结果。

在每个ST-LSTM单元中，首先在每个时间步的时间记忆单元Ct和空间记忆单元Mt的增量上添加卷积层，并利用新的解耦损失来显式扩展二者在潜在空间的距离。通过这种方法，不同的记忆状态被训练成专注于雷暴时空变化的不同方面，而不会学习到冗余特征。

3、数据处理

文章数据来源为香港天文台 HKO-7 数据集，该数据集包含 2009—2015 年的雷达回波图像。选取符合条件的共计371天的数据组。

为保证样本数据质量，需要对雷达数据进行质量控制，包括孤立噪声点滤除、平滑滤波、构造高通滤波器滤除与降水无关的反射率因子值。

面积过小的回波一般较弱且演变较快，对预测结果正向影响较小，所以在数据集构造过程中还需要对裁剪后的灰度图像进行进一步筛选，只保留有效像素值占比超过 10%的图像。随后采用滑动窗口对连续序列雷达回波图像进行切片，此处连续的定义为间隔6分钟的连续扫描雷达数据，得到时间序列。每个序列包含20帧图像，其中10帧输入、10帧输出，涵盖了2小时的回波变化数据。

通过上述步骤对采样图像进行处理，得到共计279318张 128像素×128像素灰度图像。通过滑窗切片得到时间序列共11882组，采用8:2比例划分训练集及测试集。

4、模型评价指标

检验雷暴预测性能的指标为探测成功概率（POD）、虚警率(FAR)、临界成功指数(CSI)。考虑到雷暴这类天气系统的特殊性，所涉及反射率因子范围偏高，选取30dBz、40dBz、50dBz作为判别阈值，预测时长为1小时，每张预测图像间隔 6 分钟。其中 NA 为预报正确次数，NB 为空报次数，NC为漏报次数。

除上述预报因子外，在个例检验中还使用结构相似性（structural similarity index measure, SSIM）指标来衡量预测图像和真实图像之间的相似度。SSIM 是一种基于感知的模型指标，从亮度、对比度、结构三个方面评价两张图像的相似程度。

5、实验结果

下面给出了有记忆解耦结构和无记忆解耦结构的两种网络在测试集上的雷暴预测评分因子指标结果，分别给出在不同时间步长，6分钟、30 分钟、60 分钟情况下采用 30 dBz、40 dBz、50 dBz 为阈值的检验结果。

ST-LSTM+记忆解耦网络测试集指标检验结果：

ST-LSTM 网络测试集指标检验结果：

在相同检验条件下，有记忆解耦结构的网络效果优于常规 ST-LSTM，3 个预测评分因子 POD、CSI、FAR平均提升 0.05~0.1。随着预报时间的推移，两个网络均表现出临界成功指数、预测成功概率随时间延长而下降，虚警率随时间延长而上升的趋势。同时随着反射率阈值的增大，临界成功指数和探测成功概率有所下降，而虚警率上升。这是由于当阈值增大的时候，更着重于强回波区域的演变，但强回波区域相对变化更快且不确定性更强，所以会出现预报因子下降的情况。

不同预测方法 30min 预报评分因子结果：

上表给出了预报时间为 30 分钟时单体质心法、MIM 网络、ST-LSTM网络和有记忆解耦结构ST-LSTM网络的预报评分因子结果。可以看出对于 3 个评分因子，有记忆解耦结构和无记忆解耦结构的预测神经网络结果均明显优于单体质心法，并且也优于MIM 网络结果。

在特例分析上有记忆解耦结构的网络预测的反射率因子位置分布与真实回波基本一致，正确预报出自北向南的强回波带以及整个回波向西南方收缩移动的趋势，而常规ST-LSTM网络在预测时间较短时结果也基本一致，但随着预测时间的增加，预测的反射率因子区域相较于真实回波差距增大。通过对比可以看出，有记忆解耦结构ST-LSTM 网络在内部最强回波区域的预测上明显优于常规ST-LSTM网络，后者随着预测时间的增加，所预测的强回波区域越来越小。

深度学习

1、GNN_demo

本周将基金项目的demo模型做了一下，主要涉及到了数据的处理和模型的实现。

所用数据采取桂林市八种站点表格数据，将每个站点相互连接，构成全连接图，抓取表中id，SO2和CO数据，并以随机的方式位其添加Label、train_mask、test_mask用于计算损失和准确值。并只采取前两百行的数据进行demo实验，在神经网络的设置上，将输出结果设置为2类进行训练。

处理后的图数据格式：

demo代码：

import torch
import networkx as nx
import matplotlib.pyplot as plt
from torch_geometric.datasets import KarateClub
from torch_geometric.utils import to_networkx
from torch.nn import Linear
from torch_geometric.nn import GCNConv
import torch.nn.functional as F

def visualize_graph(G,color):
    plt.figure(figsize=(7,7))
    plt.xticks()
    plt.yticks()
    nx.draw_networkx(G,pos=nx.spring_layout(G,seed=42), with_labels=False,node_color=color,cmap="Set2")
    plt.show()

data = torch.load("处理好的GNN数据_demo\桂林市\八中data.pt")

x = data.x
y = data.y
train_mask = data.train_mask

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
x, y = x.to(device), y.to(device)
train_mask = train_mask.to(device)

class GCN(torch.nn.Module):
    def __init__(self, hidden_channels):
        super().__init__()
        torch.manual_seed(123)
        self.conv1 = GCNConv(data.num_features, hidden_channels)
        self.conv2 = GCNConv(hidden_channels, 2)

    def forward(self, x, edge_index):
        x = self.conv1(x, edge_index)
        x = x.relu()
        x = F.dropout(x,p=0.5, training=self.training)
        x = self.conv2(x, edge_index)
        return x

model = GCN(hidden_channels=16)
optimizer = torch.optim.Adam(model.parameters(), lr=0.01, weight_decay=5e-4)
criterion = torch.nn.CrossEntropyLoss()

def train():
    model.train()
    optimizer.zero_grad()  # 梯度清零
    out = model(data.x, data.edge_index)  # 通过模型前向传播得到输出值
    loss = criterion(out[data.train_mask], data.y[data.train_mask])  # 将输出值和标签做一个预测
    loss.backward()  # 反向传播
    optimizer.step()  # 梯度更新
    return loss

def test():
    model.eval()
    out = model(data.x, data.edge_index)
    pred = out.argmax(dim=1)
    test_correct = pred[data.test_mask] == data.y[data.test_mask]
    test_acc = int(test_correct.sum()) / int(data.test_mask.sum())
    return test_acc

for epoch in range(1,10):
    loss = train()
    print(f'Epoch:{epoch:03d}, Loss:{loss:.4f}')

test_acc = test()
print(f'Test Accuracy:{test_acc:.4f}')

model.eval()

2、元细胞自动机

实现一个基于卷积神经网络的元胞自动机模型:

随机生成一个100x100大小的二进制矩阵，作为初始的元胞自动机状态。
定义了一个继承了 nn.Module 的卷积神经网络模型 ECACNN，包含了四个卷积层和激活函数 ReLU。输入数据是 100x100 的二维矩阵，输出数据也是 100x100 的二维矩阵。
使用随机生成的元胞自动机状态作为训练和测试数据集，并将其转换为 PyTorch 的 Tensor 格式。
定义了损失函数 MSELos 和优化器 Adam，并设置学习率为 0.01。
在训练集上训练模型，共迭代 1000 次。每迭代 100 次输出一次损失函数值。
在测试集上测试模型，并输出测试集上的损失函数值。

import torch
import torch.nn as nn
import numpy as np

# 随机生成元胞自动机状态
state = np.random.randint(0, 2, size=(1, 1, 100, 100))

class ECACNN(nn.Module):
    def __init__(self):
        super(ECACNN, self).__init__()
        self.conv1 = nn.Conv2d(1, 16, kernel_size=3, padding=1)
        self.relu1 = nn.ReLU()
        self.conv2 = nn.Conv2d(16, 32, kernel_size=3, padding=1)
        self.relu2 = nn.ReLU()
        self.conv3 = nn.Conv2d(32, 64, kernel_size=3, padding=1)
        self.relu3 = nn.ReLU()
        self.conv4 = nn.Conv2d(64, 1, kernel_size=3, padding=1)

    def forward(self, x):
        x = self.conv1(x)
        x = self.relu1(x)
        x = self.conv2(x)
        x = self.relu2(x)
        x = self.conv3(x)
        x = self.relu3(x)
        x = self.conv4(x)
        return x

# 定义训练和测试数据集
train_data = torch.from_numpy(np.array(state)).float()
test_data = torch.from_numpy(np.array(state)).float()

# 定义模型、损失函数和优化器
model = ECACNN()
criterion = nn.MSELoss(reduction='mean')
optimizer = torch.optim.Adam(model.parameters(), lr=0.01)

# 训练模型
num_epochs = 1000
for epoch in range(num_epochs):
    # 前向传播
    outputs = model(train_data)
    # 计算损失函数
    loss = criterion(outputs, train_data)
    # 反向传播
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
    # 输出训练结果
    if epoch % 100 == 0:
        print('Epoch [{}/{}], Loss: {:.4f}'.format(epoch+1, num_epochs, loss.item()))

# 测试模型
with torch.no_grad():
    test_outputs = model(test_data)
    test_loss = criterion(test_outputs, test_data)
    print('Test Loss: {:.4f}'.format(test_loss.item()))