devbox
酷酷是懒虫
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

CNN和LSTM的气象图降水预测_convlstm降雨预测

作者：酷酷是懒虫 | 2024-07-09 07:10:27

赞

踩

convlstm降雨预测

CNN和LSTM进行一个有趣的实验。

我们这里使用荷兰皇家气象研究所(也称为KNMI)提供的开放数据集和公共api，来获取数据集并且构建模型预测当地的降水量。

数据收集

KNMI提供的数据集，我们假设气象雷达产生的信号在反射时会被降水（雨、雪、冰雹等）反射。由雷达捕获的反射信号的强度称为反射率（以 dBZ 计算），我们可以粗略认为它与该点的降水强度成正比。当通过根据信号强度映射色标将此反射率数据转换为图像时（默认情况下，KNMI 提供的色标为“viridis”，紫色/深蓝色表示较低值，黄色表示较高值）产生 图像就像下图显示的那样。我们每 5 分钟通过 API 以原始格式获取这些数据。但是API 有一个配额，每小时只能获取 100 张图像。

定义问题

最原始的也是最简单的预测视频中的下一帧的内容的方法是使用CNN和LSTM。我们是否可以将预测天气雷达的下一个捕获信号的问题简化为预测视频中的下一帧的问题呢（雷达的讯号也是图像序列）。所以我收集了一些图像序列，并开始实验各种架构的卷积LSTM神经网络。每个训练数据点由36个连续的雷达原始文件(对应于间隔5分钟的3小时的测量)组成。然后将每个数据点分成两部分。前18帧用作“特征”(x)，后18帧是神经网络在给定前18帧的情况下试图预测的内容(y)。在天气预报方面，给定过去1.5小时的降水数据，未来1.5小时的降水情况(帧间隔为5分钟，因此18帧对应1.5小时)。

为什么是卷积LSTM

如果你对神经网络和深度学习有点熟悉，你可能知道卷积神经网络(CNN)在涉及分析或发现图像中的特定特征和形状的任务上表现非常好。而长短期记忆(LSTM)神经网络在涉及时间维度(如时间序列预测)和数据序列(如图像序列、特定时间范围内的信号序列等)的任务上表现非常好。这主要是因为它们有能力学习数据中的长期依赖关系。因此，研究人员在2015年首次提出了一种结合卷积和LSTM层的架构，这样可以预测一系列图像中的下一个图像(他们对其进行基准测试的应用之一是降水预测)，所以本文中也是用类似的模型。

数据预处理

我们使用了近160个连续的36次雷达扫描序列，我们使用h5py 库可以读取并轻松处理原始数据（如从 KNMI 接收的数据是这个格式）并对它们进行预处理。数据点是从 01-01-2019 到现在的随机日期和时间中挑选的。由于生成的图像的原始尺寸太大，所以将的图像从原始尺寸(700x765)缩小到(315x344)。这是模型可以在合理的时间内训练的最高分辨率，并且在过程中不会有任何的内存溢出问题。然后将每个序列分成两个相等的部分。前18帧用作“特征”(x)，后18帧是神经网络试图预测的帧(y)(给定前18帧)。最后，我将数据集分成两个单独的数据集，分别用于训练(80%)和验证(20%)。

执行上述所有任务的代码如下面的代码片段所示:

  1. def create_dataset_from_raw(directory_path, resize_to):
  2.      resize_width = resize_to[0]
  3.      resize_height = resize_to[1]
  4.      batch_names = [directory_path + name for name in os.listdir(directory_path) if os.path.isdir(os.path.join(directory_path, name))]
  5.      dataset = np.zeros(shape=(len(batch_names),36,resize_height,resize_width)) # (samples, filters, rows = height, cols = width)
  6.  
  7.      for batch_idx,batch in enumerate(batch_names):
  8.          files = [x for x in os.listdir(batch) if x != '.DS_Store']
  9.          files.sort()
  10.          crn_batch = np.zeros(shape=(36, resize_height, resize_width)) 
  11.          for (idx,raster) in enumerate(files):
  12.              fn = batch + '/' + raster
  13.              img = h5py.File(fn)
  14.              original_image = np.array(img["image1"]["image_data"]).astype(float)
  15.              img = Image.fromarray(original_image)
  16.              # note that here it is (width, heigh) while in the tensor is in (rows = height, cols = width)
  17.              img = img.resize(size=(resize_width, resize_height)) 
  18.              original_image = np.array(img)
  19.              original_image = original_image / 255.0
  20.              crn_batch[idx] = original_image
  21.          dataset[batch_idx] = crn_batch
  22.          print("Importing batch:" + str(batch_idx+1))
  23.      return dataset
  24.  
  25.  def split_data_xy(data):
  26.      x = data[:, 0 : 18, :, :]
  27.      y = data[:, 18 : 36, :, :]
  28.      return x, y
  29.  
  30.  dataset = create_dataset_from_raw('./data/raw/', resize_to=(315,344))
  31.  dataset = np.expand_dims(dataset, axis=-1)
  32.  dataset_x, dataset_y = split_data_xy(dataset)
  33.  X_train, X_val, y_train, y_val = sk.train_test_split(dataset_x,dataset_y,test_size=0.2, random_state = 42)

模型

我使用Tensorflow和Keras框架进行开发。模型基本上是一个自编码器。自编码器是一种神经网络，它试图降低训练数据的维度，对数据进行压缩，然后可以从压缩后潜在空间的分布的近似值中采样，以生成“新”数据。

我们的模型看起来像这样:

模型共包含9层(输入、输出和7个隐藏层)。隐藏层在ConvLSTM2D层和BatchNormalization层之间交换。ConvLSTM2D层就像简单的LSTM层，但是它们的输入和循环转换卷积。ConvLSTM2D层在保留输入维度的同时，随着时间的推移执行卷积运算。你可以把它想象成一个简单的卷积层，它的输出被压平，然后作为输入传递到一个简单的LSTM层。ConvLSTM2D层接收形式为(samples, time, channels, rows, cols)的张量作为输入，输出形式(samples, timesteps, filters, new_rows, new_cols)。所以它们在一段时间内对一系列帧进行运算。

ConvLSTM2D层之间的BatchNormalization层进行归一化操作

对于所有的层(除了输出层)，都使用LeakyRelu激活函数，他比ReLu好一些，并且和ReLu一样快。

该模型采用二元交叉熵损失函数和Adadelta梯度下降优化器进行拟合。由于数据的高维数，Adadelta会比经典Adam优化器有更好的结果。模型训练了25个epoch(之后开始过拟合)。

模型的代码如下所示:

  1. def create_model():
  2.      model = Sequential()
  3.      model.add(ConvLSTM2D(filters=64, kernel_size=(7, 7),
  4.                      input_shape=(18,344,315,1),
  5.                      padding='same',activation=LeakyReLU(alpha=0.01), return_sequences=True))
  6.      model.add(BatchNormalization())
  7.      model.add(ConvLSTM2D(filters=64, kernel_size=(5, 5),
  8.                      padding='same',activation=LeakyReLU(alpha=0.01), return_sequences=True))
  9.      model.add(BatchNormalization())
  10.      model.add(ConvLSTM2D(filters=64, kernel_size=(3, 3),
  11.                      padding='same',activation=LeakyReLU(alpha=0.01), return_sequences=True))
  12.      model.add(BatchNormalization())
  13.      model.add(ConvLSTM2D(filters=64, kernel_size=(1, 1),
  14.                      padding='same',activation=LeakyReLU(alpha=0.01), return_sequences=True))
  15.      model.add(Conv3D(filters=1, kernel_size=(3, 3, 3),
  16.                  activation='sigmoid',
  17.                  padding='same', data_format='channels_last'))
  18.      return model
  19.  
  20.  model = create_model()
  21.  
  22.  model.compile(loss='binary_crossentropy', optimizer='adadelta')
  23.  keras.utils.plot_model(model, to_file="model.png", show_dtype=True, show_layer_activations=True, show_shapes=True)
  24.  print(model.summary())
  25.  
  26.  epochs = 25
  27.  batch_size = 1
  28.  
  29.  #Fit the model
  30.  model.fit(
  31.      X_train,
  32.      y_train,
  33.      batch_size=batch_size,
  34.      epochs=epochs,
  35.      validation_data=(X_val, y_val),
  36.      verbose=1,
  37.  )
  1. import matplotlib
  2. import matplotlib.pyplot as plt
  3. import numpy as np
  4. import os
  5. import PIL
  6. import h5py
  7. import tensorflow as tf
  8. from tensorflow import keras
  9. from keras.models import Sequential
  10. from keras.layers.convolutional import Conv3D
  11. from keras.layers import ConvLSTM2D
  12. from keras.layers import BatchNormalization
  13. from keras.layers import LeakyReLU
  14. from PIL import Image
  15. import glob
  16. import matplotlib.animation as animation
  17. matplotlib.use("Agg")
  18. import io
  19. import imageio
  20. from PIL import Image
  21. import sklearn.model_selection as sk
  22.  
  23. try:
  24.     # Disable all GPUS
  25.     tf.config.set_visible_devices([], 'GPU')
  26.     visible_devices = tf.config.get_visible_devices()
  27.     for device in visible_devices:
  28.         assert device.device_type != 'GPU'
  29. except:
  30.     # Invalid device or cannot modify virtual devices once initialized.
  31.     pass
  32.  
  33. # larger possible dpi: 382x350
  34. def create_dataset_from_raw(directory_path, resize_to):
  35.     resize_width = resize_to[0]
  36.     resize_height = resize_to[1]
  37.     batch_names = [directory_path + name for name in os.listdir(directory_path) if os.path.isdir(os.path.join(directory_path, name))]
  38.     dataset = np.zeros(shape=(len(batch_names),36,resize_height,resize_width)) # (samples, filters, rows = height, cols = width)
  39.  
  40.     for batch_idx,batch in enumerate(batch_names):
  41.         files = [x for x in os.listdir(batch) if x != '.DS_Store']
  42.         files.sort()
  43.         crn_batch = np.zeros(shape=(36, resize_height, resize_width)) 
  44.         for (idx,raster) in enumerate(files):
  45.             fn = batch + '/' + raster
  46.             img = h5py.File(fn)
  47.             original_image = np.array(img["image1"]["image_data"]).astype(float)
  48.             img = Image.fromarray(original_image)
  49.             # note that here it is (width, heigh) while in the tensor is in (rows = height, cols = width)
  50.             img = img.resize(size=(resize_width, resize_height)) 
  51.             original_image = np.array(img)
  52.             original_image = original_image / 255.0
  53.             crn_batch[idx] = original_image
  54.         dataset[batch_idx] = crn_batch
  55.         print("Importing batch:" + str(batch_idx+1))
  56.     return dataset
  57.  
  58. def split_data_xy(data):
  59.     x = data[:, 0 : 18, :, :]
  60.     y = data[:, 18 : 36, :, :]
  61.     return x, y
  62.  
  63. dataset = create_dataset_from_raw('./data/raw/', resize_to=(315,344))
  64. dataset = np.expand_dims(dataset, axis=-1)
  65. dataset_x, dataset_y = split_data_xy(dataset)
  66. X_train, X_val, y_train, y_val = sk.train_test_split(dataset_x,dataset_y,test_size=0.2, random_state = 42)
  67.  
  68. def create_model():
  69.     model = Sequential()
  70.     model.add(ConvLSTM2D(filters=64, kernel_size=(7, 7),
  71.                     input_shape=(18,344,315,1),
  72.                     padding='same',activation=LeakyReLU(alpha=0.01), return_sequences=True))
  73.     model.add(BatchNormalization())
  74.     model.add(ConvLSTM2D(filters=64, kernel_size=(5, 5),
  75.                     padding='same',activation=LeakyReLU(alpha=0.01), return_sequences=True))
  76.     model.add(BatchNormalization())
  77.     model.add(ConvLSTM2D(filters=64, kernel_size=(3, 3),
  78.                     padding='same',activation=LeakyReLU(alpha=0.01), return_sequences=True))
  79.     model.add(BatchNormalization())
  80.     model.add(ConvLSTM2D(filters=64, kernel_size=(1, 1),
  81.                     padding='same',activation=LeakyReLU(alpha=0.01), return_sequences=True))
  82.     model.add(Conv3D(filters=1, kernel_size=(3, 3, 3),
  83.                 activation='sigmoid',
  84.                 padding='same', data_format='channels_last'))
  85.     return model
  86.  
  87. model = create_model()
  88.  
  89. model.compile(loss='binary_crossentropy', optimizer='adadelta')
  90. print(model.summary())
  91.  
  92. epochs = 25
  93. batch_size = 1
  94.  
  95. #Fit the model
  96. model.fit(
  97.     X_train,
  98.     y_train,
  99.     batch_size=batch_size,
  100.     epochs=epochs,
  101.     validation_data=(X_val, y_val),
  102.     verbose=1,
  103. )
  104. model.save('./model_saved')
  105.  
  106. # pick a random index from validation dataset
  107. random_index = np.random.choice(range(len(X_val)), size=1)
  108. test_serie_X = X_val[random_index[0]]
  109. test_serie_Y = y_val[random_index[0]]
  110.  
  111. first_frames = test_serie_X
  112. original_frames = test_serie_Y
  113.  
  114. # predict the next 18 fames
  115. new_prediction = model.predict(np.expand_dims(first_frames, axis=0))
  116. new_prediction = np.squeeze(new_prediction, axis=0)
  117.  
  118. fig, axes = plt.subplots(2, 18, figsize=(20, 4))
  119.  
  120. # Plot the original frames.
  121. for idx, ax in enumerate(axes[0]):
  122.     ax.imshow(np.squeeze(original_frames[idx]), cmap="viridis")
  123.     ax.set_title(f"Frame {idx + 18}")
  124.     ax.axis("off")
  125.  
  126. # Plot the predicted frames.
  127. for idx, ax in enumerate(axes[1]):
  128.     ax.imshow((new_prediction[idx]).reshape((344,315)), cmap="viridis")
  129.     ax.set_title(f"Frame {idx + 18}")
  130.     ax.axis("off")
  131.  
  132. plt.show()
  133.  
  134. def save_animation_original():
  135.     fig, ax = plt.subplots()
  136.     original_images = []
  137.     for f in original_frames:
  138.         ax.set_title(f"Ground Truth")
  139.         ax.axis("off")
  140.         crn_f = ax.imshow(np.squeeze(f),cmap='viridis', animated=False)
  141.         original_images.append([crn_f])
  142.     animation_originals = animation.ArtistAnimation(fig, original_images, 
  143.                                                     interval=100, blit=False, 
  144.                                                     repeat_delay=1000)
  145.     animation_originals.save('./ground_truth.gif', 
  146.                             writer=animation.PillowWriter(), dpi=100)
  147.  
  148. def save_animation_predicted():
  149.     fig, ax = plt.subplots()
  150.     predicted_images = []
  151.     for f in new_prediction:
  152.         ax.set_title(f"Ground Truth")
  153.         ax.axis("off")
  154.         crn_f = ax.imshow(np.squeeze(f),cmap='viridis', animated=False)
  155.         ax.set_title(f"Predicted frames")
  156.         predicted_images.append([crn_f])
  157.  
  158.     animation_predicted = animation.ArtistAnimation(fig, predicted_images, 
  159.                                                     interval=100, blit=False, 
  160.                                                     repeat_delay=1000)
  161.     animation_predicted.save('./predicted.gif', 
  162.                             writer=animation.PillowWriter(), dpi=100)
  163.     HTML(animation_predicted.to_html5_video())
  164.  
  165. save_animation_predicted()
  166. save_animation_original()

 

结果

在训练模型之后，使用来自验证数据集的示例数据进行测试。模型的输入是18个连续的帧(对应于雷达捕捉到的近1.5小时的信号)，它返回下一个18个预测帧(对应于接下来的1.5小时)。

  1.  # pick a random index from validation dataset
  2.  random_index = np.random.choice(range(len(X_val)), size=1)
  3.  test_serie_X = X_val[random_index[0]]
  4.  test_serie_Y = y_val[random_index[0]]
  5.  
  6.  first_frames = test_serie_X
  7.  original_frames = test_serie_Y
  8.  # predict the next 18 fames
  9.  new_prediction = model.predict(np.expand_dims(first_frames, axis=0))
  10.  new_prediction = np.squeeze(new_prediction, axis=0)
  11.  
  12.  fig, axes = plt.subplots(2, 18, figsize=(20, 4))
  13.  
  14.  # Plot the ground truth frames.
  15.  for idx, ax in enumerate(axes[0]):
  16.      ax.imshow(np.squeeze(original_frames[idx]), cmap="viridis")
  17.      ax.set_title(f"Frame {idx + 18}")
  18.      ax.axis("off")
  19.  
  20.  # Plot the predicted frames.
  21.  for idx, ax in enumerate(axes[1]):
  22.      ax.imshow((new_prediction[idx]).reshape((344,315)), cmap="viridis")
  23.      ax.set_title(f"Frame {idx + 18}")
  24.      ax.axis("off")
  25.  
  26.  plt.show()

将预测的帧与实际情况进行比较，结果如下图所示。

真实帧与预测帧非常接近。这种可视化并没有清楚地呈现降水系统移动的时间维度和方向，因此下面的两个GIF动画可以更好地解释模型的输出。

下面是真值的GIF

下面是预测GIF

两个动画也非常接近，模型正确地捕捉到了降水系统的移动方向和强度(黄色更强烈，紫色/深蓝色强度较低)。

总结

ConvLSTM将深度学习的两个核心概念结合起来，并获得了很好的效果。本文的完整项目的代码在这里：

GitHub - petrosDemetrakopoulos/LSTM-radar-precipitation-forecast: A model for short-term precipitation forecasting based on radar data

另外关于卷积和LSTM的论文请看这篇：Convolutional LSTM Network: A Machine LearningApproach for Precipitation Nowcasting (2015) https://arxiv.org/abs/1506.04214v2

最后就是 Keras 的 ConvLSTM2D API , ConvLSTM2D layer

作者：Petros Demetrakopoulos

环境：Tensorflow 2.0 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/酷酷是懒虫/article/detail/801758
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号