二、基于TrajGRU的短临预报实现：代码实现

最新推荐文章于 2023-11-14 21:32:47 发布
最新推荐文章于 2023-11-14 21:32:47 发布
阅读量1.4k 收藏 9
点赞数 1
分类专栏： 短临降水预报
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zshluckydogs/article/details/114957649
版权

前言

接上篇一、基于TrajGRU的短临预报实现：模型结构，本篇文章主要是关于代码实现以及训练时的一些调优技巧和经验型的错误。

本文分为以下几个部分：

一、雷达数据预处理

二、模型代码pytorch实现

三、训练参数设置

四、模型测试验证

五、部署推理模型

本文依次根据上述章节进行展开。

chapter1 雷达数据预处理

雷达基数据以二进制存储，需要按位读取并解码成十进制数据。目前使用的数据是S波段多普勒雷达数据，雷达扫描方式是VCP11或者VCP21，二者的区别是仰角不同。美国雷达的标准是VCP-11有14个仰角，仰角范围是0.5～19.5度，VCP-21有9个仰角，仰角范围是0.5～19.5度。我国S波段多普勒雷达使用CINRAD 标准，

11：降水模式，16层仰角
21：降水模式，14层仰角
31：晴空模式，8层仰角
32：晴空模式，7层仰角

class Radar(object):
    ## path + file_name
    ## 
    def __init__(self,*args):
        path,name = args
        self.AbsolutePath = os.path.join(path,name)
        file = open(self.AbsolutePath,'rb')
        file.seek(0)
        self.RawData = np.array([int(i) for i in file.read()])
        self.Name = name[:-4]
        self.Count = int(len(self.RawData)/2432) ## 总个数
        self.RawArray = self.RawData.reshape(self.Count,2432)
        _,_,_,self.Station,self.time = self.Name.split('_')[:5]
        
        
        self.time_ms = read_data(self.AbsolutePath)
        logger.info(f'ms {self.time_ms}')
        #self.Julian = [self.RawArray[i][32] + self.RawArray[i][33]*256 for i in range(0,self.Count)]#儒略日
        self.NumberofElevation = [self.RawArray[i][44] + self.RawArray[i][45]*256 for i in range(0,self.Count)]#层数
        self.StartOfReflectivity = [self.RawArray[i][46]+self.RawArray[i][47]*256 for i in range(0,self.Count)]#起始距离
        self.StartOfSpeed = [self.RawArray[i][48] + self.RawArray[i][49]*256 for i in range(0,self.Count)]
        self.StepOfReflectivity = [self.RawArray[i][50] + self.RawArray[i][51]*256 for i in range(0,self.Count)]#库长
        self.StepOfSpeed = [self.RawArray[i][52]+self.RawArray[i][53]*256 for i in range(0,self.Count)]
        self.NumberOfReflectivity = [self.RawArray[i][54] + self.RawArray[i][55]*256 for i in range(0,self.Count)]#反射率的距离库数
        self.NumberOfSpeed = [self.RawArray[i][56] + self.RawArray[i][57]*256 for i in range(0,self.Count)]
        self.PointerOfReflectivity = [self.RawArray[i][64]+self.RawArray[i][65]*256 for i in range(0,self.Count)]#数据位置指针
        self.PointerOfSpeed = [self.RawArray[i][66]+self.RawArray[i][67]*256 for i in range(0,self.Count)]
        self.PointerOfSpectralWidth = [self.RawArray[i][68]+self.RawArray[i][69]*256 for i in range(0,self.Count)] # 谱宽指针
        self.ResolutionOfSpeed = [self.RawArray[i][70]+self.RawArray[i][71]for i in range(0,self.Count)]#多普勒速度分辨率
        self.vcp = [self.RawArray[i][72]+self.RawArray[i][73]*256 for i in range(0,self.Count)]# 11:降水，16；21：降水，14；31：晴空，8；32：晴空，7.
        self.Elevation = [(self.RawArray[i][42]+256*self.RawArray[i][43])/8*180/4096 for i in range(0,self.Count)]#仰角
        self.Azimuth = [(self.RawArray[i][36]+256*self.RawArray[i][37])/8*180/4096 for i in range(0,self.Count)]#方位角
        self.Storage = self.getStorage()
        #self.AllInfo = self.getAllInfo()
        #self.x,self.y,self.z,self.r = self.getXyzr()
        #self.space_info = self.getAllInfo()
        #self.elevation_list = self.get_elevation_list()
        #self.grid_data = self.grid()
        file.close()

多普勒雷达每个仰角的扫描方式是PPI，每个仰角扫描得到的数据长度都是固定的，存储长度是2432个字节，数据格式如下：

字节顺序        双字节顺序        数据类型        说明
1-14        1-7                保留        雷达信息头
（28字节）
15-16        8        2字节        1-表示雷达数据        
17-28        9-14                保留        
29-32        15-16        4字节        径向数据收集时间(毫秒,自00:00开始)
33-34        17        2字节        儒略日（Julian）表示，自1970年1月1日开始
35-36        18        2字节        不模糊距离（表示：数值/10.=千米）
37-38        19        2字节        方位角（编码方式：[数值/8.]*[180./4096.]=度）
39-40        20        2字节        当前仰角内径向数据序号
41-42        21        2字节        径向数据状态 0：该仰角的第一条径向数据
1：该仰角中间的径向数据
2：该仰角的最后一条径向数据
3：体扫开始的第一条径向数据
4：体扫结束的最后一条径向数据
43-44        22        2字节        仰角 （编码方式：[数值/8.]*[180./4096.]=度）
45-46        23        2字节        体扫内的仰角数
47-48        24        2字节        反射率数据的第一个距离库的实际距离(单位:米)
49-50        25        2字节        多普勒数据的第一个距离库的实际距离(单位:米)
51-52        26        2字节        反射率数据的距离库长（单位：米）
53-54        27        2字节        多普勒数据的距离库长（单位：米）
55-56        28        2字节        反射率的距离库数
57-58        29        2字节        多普勒的距离库数
59-60        30        2字节        扇区号
61-64        31-32        4字节        系统订正常数
65-66        33        2字节        反射率数据指针（偏离雷达数据信息头的字节数）
表示第一个反射率数据的位置
67-68        34        2字节        速度数据指针（偏离雷达数据信息头的字节数）
表示第一个速度数据的位置
69-70        35        2字节        谱宽数据指针（偏离雷达数据信息头的字节数）
表示第一个谱宽数据的位置
71-72        36        2字节        多普勒速度分辨率。 2：表示0.5米/秒
                   4：表示1.0米/秒
73-74        37        2字节        体扫（VCP）模式   11：降水模式，16层仰角
                   21：降水模式，14层仰角
                   31：晴空模式，8层仰角
                   32：晴空模式，7层仰角
75-82        38-41                保留
83-84        42        2字节        用于回放的反射率数据指针，同33
85-86        43        2字节        用于回放的速度数据指针，同34
87-88        44        2字节        用于回放的谱宽数据指针，同35
89-90        45        2字节        Nyquist速度（表示：数值/100. = 米/秒）
91-128        46-64                保留
129-588        65-294        1字节        反射率
距离库数：0-460
编码方式：（数值-2）/2.-32 = DBZ
当数值为0时，表示无回波数据（低于信噪比阀值）
当数值为1时，表示距离模糊        基数据
部分
(2300字节)
129-1508        65-754        1字节        速度
距离库数：0-920
编码方式：
分辨率为0.5米/秒时
（数值-2）/2.-63.5 = 米/秒
分辨率为1.0米/秒时
（数值-2）-127 = 米/秒
当数值为0或1时，意义同上        
129-2428        65-1214        1字节        谱宽
距离库数：0-920
编码方式：
（数值-2）/2.-63.5 = 米/秒
当数值为0或1时，意义同上        
2429-2432        1215-1216                保留


说明：
1．        数据的存储方式
每个体扫存储为一个单独的文件
2．        数据的排列方式
按照径向数据的方式顺序排列，对于CINRAD SA/SB雷达，体扫数据排列自低仰角开始到高仰角结束。
3．        径向数据的长度
径向数据的长度固定，为2432字节。
4．        距离库长和库数
反射率距离库长为1000米，最大距离库数为460；
速度和谱宽距离库长为250米，最大距离库数为920。

经过上述方法解析，可以得到雷达在各个仰角的基本反射率数据。解析后的雷达反射率数据经过变换可以得到0-255范围内的可见光图像。

常用的转化公式

pixel = 255 * \frac{dbz+10}{70}+0.5

雷达组合反射率拼图

 

得到连续的雷达反射率拼图后，还需要对数据做进一步的处理。在晴天云量较少时，雷达反射率较小甚至没有，这一部分数据对于模型来说等同于噪声，所以需要剔除。

 

 

雷达组合反射率噪声

 

另外，在剔除数据值一定要注意保持数据时空连续性，比如十分钟一次的雷达反射率组合拼图，剔除噪声数据之后需要保证剩下的图像仍然是以十分钟为间隔的。

chapter2 模型代码pytorch实现

模型采用的是Encoder-Decoder架构，论文中叫Encoder-Forecaster，是相同的意思。前文已经提到过这个架构，这里主要是代码实现。

在论文中，Encoder阶段是通过卷积+trajGRU实现图像降采样和光流以及时序特征提取，Forecaster阶段相当于Encoder的镜像，即通过trajGRU+卷机实现光流以及时序特征提取和图像上采样，最终输出预测结果。

Encoder

Encoder由三层Conv+trajGRU堆叠而成。

conv -> rnn -> conv -> rnn -> conv -> rnn ->states

在卷积阶段通过设置卷积核尺寸步长和padding大小进行特征提取和图像降采样。

三层卷机的设置分别如下：

stage1

1,8,7,5,1 -> inputchannels,outputchannels,kernel-size,stride,padding

(N + 2*1 - 7)/5 + 1 = N' 

N' = N/5


stage2 

64,192,5,3,1

(N + 2*1 - 5)/3 + 1 = N' 

N' = N/3

stage3

192,192,3,2,1
(N + 2*1 - 3)/2 + 1 = N' 

N' = N/2

可以看到，经过第一次卷积之后，输出尺寸是输入的1/5，经过第二次卷积之后，输出尺寸是输入的1/3，经过第三次卷积之后，输出尺寸是输入的1/2。

基于torch的实现如下：

stage1

conv2d = nn.Conv2d(1,8,7,5,1)
relu = nn.LeakyReLU(negative_slope=0.2, inplace=True)

stage2

conv2d = nn.Conv2d(64,192,5,3,1)
relu = nn.LeakyReLU(negative_slope=0.2, inplace=True)

stage3 

conv2d = nn.Conv2d(192,192,3,2,1)
relu = nn.LeakyReLU(negative_slope=0.2, inplace=True)

 

rnn结构（TrajGRU）

这一部分可以说是整个模型架构的核心部分，也是能够成功实现外推的关键。

上篇已经分析过TrajGRU的网络结构，本文在这里结合代码实现进一步说明。

TrajGRU和GRU的区别主要有两点：一、前者使用卷积结构实现状态转移，后者使用全连接结构；二、前者比后者多了一个光流运动捕捉结构，即traj结构部分。

先来说一下traj结构，traj结构通过引入一层卷积结构，同时限制输出的维度，再经过不断的迭代调整卷积参数达到捕捉复杂光流运动的效果。需要注意的是，作者通过限制输出的维度是2维其实是模拟了经典光流算法的输出设置，所以traj结构的输出其实是前一帧加上光流矢量之后的效果，也即是某点在下一时刻图像中的位置。由于位置通常是离散不可微分，所以利用了一个插值方法取所在位置索引对应的特征值作为反馈学习的对象。

结构组成

1、input2hidden

2、inputs2flow

3、hidden2flow

4、flows_conv -->> wrap function -->> pixel value

5、ret（reset gate）

 trajGRU网络结构由上述5个部分组成，实现从输入到光流运动学习以及状态转移等。最终利用3个trajGRU的堆叠实现雷达回波外推。

需要注意的是，trajGRU结构不会改变输入输出的尺寸，即特征的宽和高不会被改变，只在卷积层改变特征的尺寸。一种合理的解释是类似LSTM和GRU这种含有记忆单元的结构，只是产生了状态转移，没有发生尺寸变换。

trajGRU代码实现

class TrajGRU(BaseConvRNN):
    # b_h_w: input feature map size
    def __init__(self, input_channel, num_filter,b_h_w,zoneout=0.2,L=5, 
                i2h_kernel=(3,3), i2h_stride=(1,1), i2h_pad=(1,1),
                h2h_kernel=(5,5), h2h_dilate=(1,1), prefix='BaseConvRNN'):
        super(TrajGRU,self).__init__(num_filter=num_filter,
                                b_h_w=b_h_w, 
                                h2h_kernel=h2h_kernel, 
                                h2h_dilate=h2h_dilate, 
                                i2h_kernel=i2h_kernel, 
                                i2h_stride=i2h_stride, 
                                i2h_pad=i2h_pad, 
                                prefix=prefix)
        self._L = L
        self._zoneout = zoneout
        #self._act_type = F.leaky_relu()
        # *3 according to 3 hidden states. t-1,t,t+1

        ## self.i2h -->> input2hidden
        self.i2h = nn.Conv2d(in_channels=input_channel,
                            out_channels=self._num_filter*3,
                            kernel_size=self._i2h_kernel,
                            stride=self._i2h_stride,
                            padding=self._i2h_pad,
                            dilation=self._i2h_dilate)
        
        # inputs to flow

        self.i2f_conv1 = nn.Conv2d(in_channels=input_channel,
                                out_channels=32,
                                kernel_size=(5,5),
                                stride=1,
                                padding=(2,2),
                                dilation=(1,1))

        # hidden to flow

        self.h2f_conv1 = nn.Conv2d(in_channels=self._num_filter,
                                out_channels=32,
                                kernel_size=(5,5),
                                stride=1,
                                padding=(2,2),
                                dilation=(1,1))

        # generate flow
        self.flows_conv = nn.Conv2d(in_channels=32,
                                out_channels=self._L*2,
                                kernel_size=(5,5),
                                stride=1,
                                padding=(2,2))
        # reset gate  hh,hz,hr,1*1 ks
        self.ret = nn.Conv2d(in_channels=self._num_filter*self._L,
                            out_channels=self._num_filter*3,
                            kernel_size=(1,1),
                            stride=1)
    # inputs: B C H W
    # flow comes from current inputs and forward states
    def _flow_generator(self,inputs,states):
        if inputs is not None:
            i2f_conv1  = self.i2f_conv1(inputs)

        else:
            i2f_conv1 = None 
        h2f_conv1  = self.h2f_conv1(states)
        f_conv1 = i2f_conv1 + h2f_conv1 if i2f_conv1 is not None else h2f_conv1
        f_conv1 = F.leaky_relu(f_conv1,0.2,inplace=True)

        flows = self.flows_conv(f_conv1)
        # channels L*2 ,split according to 2 
        # get L flow maps each have 2 channels
        flows = torch.split(flows,2,dim=1) 
        return flows
    
    # inputs states
    # inputs: S B C H W 
    def forward(self,inputs=None,states=None,seq_len=5):
        if states is None:
            states = torch.zeros((inputs.size(1),self._num_filter,self._state_height,
                                self._state_width),dtype= torch.float).cuda()
        if inputs is not None:
            S,B,C,H,W = inputs.size()
            i2h = self.i2h(torch.reshape(inputs,(-1,C,H,W)))
            i2h = torch.reshape(i2h,(S,B,i2h.size(1),i2h.size(2),i2h.size(3)))
            i2h_slice = torch.split(i2h,self._num_filter,dim=2)
        else:
            i2h_slice = None

        prev_h = states
        outputs = []
        for i in range(seq_len):
            if inputs is not None:
                flows = self._flow_generator(inputs[i,...],prev_h)
            else:
                flows = self._flow_generator(None,prev_h)

            wrapped_data = []

            for j in range(len(flows)):
                flow = flows[j]
                wrapped_data.append(wrap(prev_h,-flow))
            wrapped_data = torch.cat(wrapped_data,dim=1)
            h2h = self.ret(wrapped_data)
            h2h_slice = torch.split(h2h,self._num_filter,dim=1)
            if i2h_slice is not None:
                reset_gate = torch.sigmoid(i2h_slice[0][i,...]+h2h_slice[0])
                update_gate = torch.sigmoid(i2h_slice[1][i,...]+h2h_slice[1])
                new_mem = F.leaky_relu(i2h_slice[2][i, ...] + reset_gate * h2h_slice[2],0.2,inplace=True)
            
            else:
                reset_gate = torch.sigmoid(h2h_slice[0])
                update_gate = torch.sigmoid(h2h_slice[1])
                new_mem = F.leaky_relu(reset_gate * h2h_slice[2],0.2,inplace=True)
            
            next_h = update_gate * prev_h + (1-update_gate) * new_mem

            if self._zoneout > 0.0:
                mask = F.dropout2d(torch.zeros_like(prev_h),p=self._zoneout)
                next_h = torch.where(mask,next_h,prev_h)
            outputs.append(next_h)
            prev_h = next_h
        return torch.stack(outputs),next_h

整体的实现还是严格按照网络结构进行的，继承了一个BaseConvRNN类，用来计算网络特征转移中的特征尺寸以及padding设置等。

下一篇按照trajGRU的5个结构拆解开逐个分析。

 

 

 

 

 

nobrody
关注
  • 1
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
三、基于TrajGRU的短临预报实现：代码实现2
zshluckydogs的博客
06-20 1288
接上篇，本篇将继续结合算法结构进行代码实现。 首先，补充一下trajGRU继承的BaseConvRNN类。这个类用来计算状态转移过程中特征的宽、高、通道数以及不同padding设置下对应的
预测模型：时空预测模型PyTorch复现
02-04
预测模型：时空预测模型PyTorch复现 models 文件夹 在 models 目录中，每一个文件夹存储一个结构的完整模型代码，复现参照了论文中的公式、图示以及 GitHub 作者实现的代码（如果有的话） 这些模型均假定输入的 Tensor 的 shape 为 (batch, sequence, channel, height, width) 这里的目的是为了学习，尽可能内聚成一个个小的 Module 再组合的，应该效率很差 util 文件夹 patch 针对大尺寸数据进行 patch 分割的方法，不过这里要根据实际情况修改下，这里是针对五维数据的，如果针对四维，则参照逻辑修改下即可 TrainingTemplate 和 TestingTemplate 我自己写的训练过程的模板类，一般继承重写一些方法即可 content_tree 包含生成目录树的方法
论文研究 - 亚洲和非洲干旱地区降水循环的时空分布
05-25
陆地降水中水蒸气的循环利用程度仍然是有争议的话题，特别是在干旱地区。 在这里，我们调查了亚洲和非洲在1984-2013年期间通过水平衡方法[1]计算的蒸发的时空演变和使用水循环模型[2]计算的降水回收率。 结果表明，北非和中蒙地区夏季降水回收率较高，冬季较弱。 但是，西亚冬季和Spring较强，夏季较弱。 在干旱地区，蒸发占降水吸收的一小部分，外部水蒸气的输送对降水的循环产生主要影响。 在过去30年中，全球温度和蒸发潜能的增加驱使北非和西亚的实际蒸发和降水再循环率增加，而中国-蒙古相应减少。
时空预测模型PyTorch复现
01-20
时空预测模型PyTorch复现 models 文件夹 在 models 目录中，每一个文件夹存储一个结构的完整模型代码，复现参照了论文中的公式、图示以及 GitHub 作者实现的代码（如果有的话） 这些模型均假定输入的 Tensor 的 shape 为 (batch, sequence, channel, height, width) 这里的目的是为了学习，尽可能内聚成一个个小的 Module 再组合的，应该效率很差 util 文件夹 patch 针对大尺寸数据进行 patch 分割的方法，不过这里要根据实际情况修改下，这里是针对五维数据的，如果针对四维，则参照逻辑修改下即可 TrainingTemplate 和 TestingTemplate 我自己写的训练过程的模板类，一般继承重写一些方法即可 content_tree 包含生成目录树的方法
人工智能项目资料-基于深度学习的天气预报系统研究应用.zip
最新发布
02-03
【探索人工智能的宝藏之地】 无论您是计算机相关专业的在校学生、老师，还是企业界的探索者，这个项目都是为您量身打造的。无论您是初入此领域的小白，还是寻求更高层次进阶的资深人士，这里都有您需要的宝藏。不仅如此，它还可以作为毕设项目、课程设计、作业、甚至项目初期的立项演示。 【人工智能的深度探索】 人工智能——模拟人类智能的技术和理论，使其在计算机上展现出类似人类的思考、判断、决策、学习和交流能力。这不仅是一门技术，更是一种前沿的科学探索。 【实战项目与源码分享】 我们深入探讨了深度学习的基本原理、神经网络的应用、自然语言处理、语言模型、文本分类、信息检索等领域。更有深度学习、机器学习、自然语言处理和计算机视觉的实战项目源码，助您从理论走向实践，如果您已有一定基础，您可以基于这些源码进行修改和扩展，实现更多功能。 【期待与您同行】 我们真诚地邀请您下载并使用这些资源，与我们一起在人工智能的海洋中航行。同时，我们也期待与您的沟通交流，共同学习，共同进步。让我们在这个充满挑战和机遇的领域中共同探索未来！
(26) 降雨量预测-一个基准和一个新的模型
zuiyishihefang的博客
11-30 8428
交通预见未来(26): TrajGRU降雨量预测-一个基准和一个新的模型 1、文章信息 《Deep Learning for Precipitation Nowcasting: A Benchmark and A New Model》。 施行健的另外一篇降水量预测论文。 2、摘要 ConvLSTM模型被证明在短时预测方面优于传统的方法，这表明深度学习模型在解决这一问题上有巨大的潜力。然而...
一、基于TrajGRU的短临预报实现：模型结构
zshluckydogs的博客
03-18 2285
前言 参考基于基于CONVLSTM的短临预报实现，针对ConvLSTM模型存在的无法捕捉旋转和向四周耗散运动问题，提出了可以学习光流运动的TrajGRU模型。在继承时序卷积神经网络对时序和空间特征良好敏感性的基础上，又能学习到真实的光流运动，进而模拟自然界中云层的真实运动，提高模型外推的性能。 模型架构 一、GRU与LSTM LSTM有三个门，input、forget、output，GRU有两个门，reset、update。由于门的存在，LSTM和GRU都可以解决时序网络的长短时依赖问题，能够捕捉时
降水短临预报模型trajGRU简介
我不爱机器学习的博客
11-14 346
trajGRU 是在对 convLSTM 的改进，且这两个模型是同一个作者。convLSTM 在降水短临预报这块已经超越传统模型，但其是局部不变性的(location-invariant)，而自然的运动和转换(如旋转)是局部变化的(location-invariant)。作者为了能够使用递归连接的方式捕捉和学习这种局部变化结构构建了 trajGRU(the Trajectory GRU)。
论文阅读笔记_Deep Learning for Precipitation Nowcasting: A Benchmark and A New Model (TrajGRU)
gXh的博客
08-10 1372
ConLSTM：卷积递归结构是位置不变的的，但自然运动通常位置可变。 TrajGRU：修改递归结构本身，修改旋转和缩放等运动模式。 论文提出一个基准： 1.算法离线设置只能使用一个固定的窗口前的雷达回波地图。 2.在线设置是使用所有历史数据和在线学习算法。 TrajGRU使用子网，在状态转换前输出状态的连接结构。 降水预报问题：首先将雷达回波图中的反射率因子转化为灰度图像，然后将其输入到预报算法中。因此，降水临近预报可以看作是一种带有固定“摄像机”的视频预报问题，“摄像机”就是天气雷达。 TrajGRU的目
天池大赛｜2022江苏气象AI算法挑战赛亚军方案分享
Datawhale
01-23 1063
成员介绍团队：DontMind队队员：游枭雄，湘潭市气象局副研级高工队员：李扬，南京信息工程大学队员：梁钊明，中国气象科学研究院副研究员赛题解析本次比赛主要是针对大风/雷达回波/降水的短临预报，属于典型的时空序列预测问题，此类问题可以从分类和回归预测两个角度来解决。按照各气象要素阈值区间进行分类，可以转化为分类预测问题；从回归预测的角度又分为单变量回归预测和多变量回归预测。由于大风和降水预测很难转...
MindSpore AI科学计算系列 | 有效改善预报模糊问题，生成式模型在短临降水预报中大放异彩
Kenji_Shinji的博客
10-25 318
该模块着眼于平流运动等物理性质更显著的中尺度降水过程，用Intensity decoder和Motion decoder分别来模拟雨势的大小和对流趋势，生成对应的强度场(intensity)和移动场(motion)，然后通过Evolution operator(图1c)，基于物质连续性方程，将移动场作用在最后一帧雷达，并叠加强度场，从而生成大尺度下的预测结果。得益于上述融合设计，该模型兼具深度学习与物理建模的优势，在国际上首次将降水临近预报的时效延长至3小时，并弥补了极端降水预报的短板。
读论文：Convective precipitation nowcasting using U-Net Model
a44267113的博客
10-18 977
使用U-Net模型来提供更加详细的即时天气预报
软件学院王建民、龙明盛团队提出极端降水临近预报大模型
数据派THU
07-07 632
近日，清华大学软件学院王建民教授、龙明盛副教授团队提出了极端降水临近预报大模型，将数据驱动与物理驱动两大科学范式紧密结合，显著提高了公里尺度下0～3小时极端降水的预报能力，在全国62位气象预报专家的过程检验中大幅领先国际上的同类方法。目前该大模型已经在国家气象中心短临预报业务平台（SWAN 3.0）部署上线，将为全国极端降水天气短临预报业务提供支撑。近年来，受全球气候变化的影响，短时强降水、暴风...
Pytorch实现LSTM和GRU
热门推荐
winycg的博客
03-31 4万+
为了解决传统RNN无法长时依赖问题，RNN的两个变体LSTM和GRU被引入。 LSTM Long Short Term Memory，称为长短期记忆网络，意思就是长的短时记忆，其解决的仍然是短时记忆问题，这种短时记忆比较长，能一定程度上解决长时依赖。 ...
NIPS 2017 深度学习论文集锦 (5) 含部分代码
hestendelin的专栏
08-30 454
您可能感兴趣本篇文章基于上述四篇，故论文编号沿用上四篇的编号[81] Maximizing Subset Accuracy with Recurrent Neural N...
TrajGRU降雨量预测: 一个基准和一个新的模型
zuiyishihefang的博客
05-21 5608
前面看过ConvLSTM的文章:初识ConvLSTM, 这篇文章和ConvLSTM算是姊妹篇吧，先大概看看，后面有时间再仔细研读~1、文章信息《Deep Learning for Pr...
Trajectron++| 生成性的多智能体轨迹预测方法
CV_Autobot的博客
03-15 899
作者|浅笑 编辑|汽车人原文链接：https://zhuanlan.zhihu.com/p/513091095点击下方卡片，关注“自动驾驶之心”公众号ADAS巨卷干货，即可获取点击进入→自动驾驶之心【轨迹预测】技术交流群后台回复【轨迹预测综述】获取行人、车辆轨迹预测等相关最新论文！该方法在nuscenes行为预测榜单上排名第6，且是前6名中为数不多提供了开源代码、效果也可复现的方法。ht...
深度学习掩膜_交叉新趋势|采用神经网络与深度学习来预报降水、温度等案例(附代码/数据/文献)...
weixin_39522103的博客
11-21 1881
欢迎订阅微信公众号:『气象学家』阅读建议随着人工智能的发展，拥有了越来越丰富的应用场景，气象行业也不例外，在突破传统预报方法的情况下，神经网络与深度学习来预报气象要素也取得了不错的效果，下面就给出一些比较典型的开源案例，条件允许不妨按图索骥实践一下，代码、数据、文献都给各位客官老爷一一奉上，也欢迎大家在圈内转载和分享！内容目录ConvLSTM 和 TrajGRU降水预测“基于雷达图像...
视频物体检测文献阅读笔记
Wayne2019的博客
01-06 2991
Impression Network for Video Object Detection 基于印象机制的高效多帧特征融合，解决defocus and motion blur等问题（即视频中某帧的质量低的问题），同时提高速度和性能。 类似TSN，每个segment选一个key frame（注意，TSN做视频分类是在cnn最后才融合不同的segments）。特征融合前需要用Optical
trajgru代码实现
05-12
TrajGRU是一种用于序列建模的神经网络，它包含一个门控循环单元（GRU）和一个轨迹编码器。以下是用PyTorch实现TrajGRU的示例代码： ```python import torch import torch.nn as nn class TrajGRU(nn.Module): def __init__(self, input_size, hidden_size, num_layers, output_size): super(TrajGRU, self).__init__() self.input_size = input_size self.hidden_size = hidden_size self.num_layers = num_layers self.output_size = output_size self.gru = nn.GRU(input_size, hidden_size, num_layers, batch_first=True) self.linear = nn.Linear(hidden_size, output_size) def forward(self, x): # x: (batch_size, seq_len, input_size) h_0 = self._init_hidden(x.size(0)) # output: (batch_size, seq_len, hidden_size) output, h_n = self.gru(x, h_0) # output: (batch_size, hidden_size) output = output[:, -1, :] # output: (batch_size, output_size) output = self.linear(output) return output def _init_hidden(self, batch_size): hidden = torch.zeros(self.num_layers, batch_size, self.hidden_size) return hidden ``` 在上面的代码中，我们首先定义了TrajGRU类，并初始化了GRU和线性层。在前向传递中，我们首先使用GRU对输入序列进行编码，然后使用线性层将最后一个时间步的隐藏状态转换为输出。我们还定义了一个_init_hidden方法来初始化隐藏状态。 使用TrajGRU进行序列建模的示例代码如下： ```python # 构造一个TrajGRU模型 model = TrajGRU(input_size=10, hidden_size=32, num_layers=2, output_size=2) # 定义损失函数和优化器 criterion = nn.CrossEntropyLoss() optimizer = torch.optim.Adam(model.parameters(), lr=0.001) # 训练模型 for epoch in range(num_epochs): for i, (inputs, labels) in enumerate(train_loader): # 前向传播 outputs = model(inputs) loss = criterion(outputs, labels) # 反向传播和优化 optimizer.zero_grad() loss.backward() optimizer.step() if (i+1) % 100 == 0: print('Epoch [{}/{}], Step [{}/{}], Loss: {:.4f}'.format(epoch+1, num_epochs, i+1, total_step, loss.item())) ``` 在这个示例中，我们首先构建了一个TrajGRU模型，并定义了损失函数和优化器。然后我们使用训练集的数据迭代训练模型，并在每个epoch的末尾打印出当前的损失。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

nobrody

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值