精华内容
下载资源
问答
  • 与传统的基于自身序列的预测模型相比,本研究将航空因素引入地面交通拥堵预测模型中,结果显示航空因素对于机场地面交通的预测具有重要影响,证实了机场地面交通预测的特殊性。与线性模型ARIMA和VAR模型相比,深度学习...
  • 交通拥堵预测是解决交通拥堵问题的重要步骤之一 。 为缓解交通拥堵 , 选取速度这一参数 建立交通拥堵预测模型 。 在对速度时间相关性和空间相关性分析的基础上 , 提出了基于时空特性和 径向基神经网络的速度预测...
  • 基于深度学习的交通拥堵预测模型研究.pdf
  • 基于BP神经网络的城市占道交通拥堵预测.pdf
  • 基于K-means聚类的交通拥堵预测系统.pdf
  • 极限学习机在大规模交通拥堵预测中的应用
  • 以成都市中心城区人民南路三段为例,进行了实例预测研究。预测结果为交 ...通拥堵预测的识别率为48%,误判率为16%,结果表明基于速度的拥堵预测模型能够对 城市主干道交通状态进行有效的预测分析。
  • 】随着城市交通的发展,道路网络越来越复杂,交通拥堵越来越严重,准确预测交通拥堵是城市缓堵保畅,提高 城市交通管理能力关键技术之一。传统马尔可夫预测模型中的单变量模型只能解决单个时间序列上的交通预测问题...
  • 针对城市道路交通拥堵预警问题,提出了一种基于深度学习的预测模型 。 通过归纳合并交通流参数 、 环境状态 、 时段等基础数据来构建交通流特征向量并确定四种预测状态 。 采用深度学习的自编码网络方法从无 标签...
  • 针对城市道路交通拥堵预警问题,提出了一种基于深度学习的预测模型。通过归纳合并交通流参数、环境状态、时段等基础数据来构建交通流特征向量并确定四种预测状态。采用深度学习的自编码网络方法从无标签数据集中学习...
  • 据统计,我国目前百万人口以上的城市中有80%的路段和90%的路口通行能力...所以随着交通拥堵问题的日益严重,能提前预测交通拥堵的程度是具有潜在价值的,这样司机和行人就可以通过预报尽可能地避免交通拥堵带来的不便。
  • 本文提出神经网络群组快速学习方法,将...盖的拥堵预测群组模型,充分发挥超限学习机算法在小规模子集上准确度高、 训练速度快、参数少、易于并行加速等优点,实现对大规模交通拥培数据的 高精度、高效率学习。
  • 本文旨在为基于物联网的智慧城市的交通拥堵提供机器学习模型。 我们假设城市在街道和城市的所有必要部分都配备了传感器。 卷积神经网络 (CNN) 和各种机器学习分类和预测算法用于检查哪种算法可以为生成的数据集提供...
  • 基于公共交通大数据的上海市居民出行时空特征研究_王宇 这篇论文内容并不很多,除了数据清洗和数据分类处理之外主要是讲了聚类的问题,核密度聚类: 是对于数据集中的每个点都进行计算,根据值的大小画热力图用的...

    上一篇的地址:https://blog.csdn.net/qq_43012160/article/details/103313749

    基于公共交通大数据的上海市居民出行时空特征研究_王宇

    这篇论文内容并不很多,除了数据清洗和数据分类处理之外主要是讲了聚类的问题,核密度聚类:
    在这里插入图片描述
    在这里插入图片描述
    是对于数据集中的每个点都进行计算,根据值的大小画热力图用的:
    在这里插入图片描述
    剩下的东西在上一篇张红的文章里基本上都详细提过了(数据清洗和数据分类处理)。

    面向交通拥堵预测大数据的神经网络群组快速学习_沈晴

    ELM

    这篇对于数据同样是按不同的特性(路段)进行划分时候进行的处理:
    在这里插入图片描述
    这篇文章主要用的模型是ELM,即超限学习机,是一种给神经网络的隐含层随机赋值权重然后把输入层和输出层直连的神经网络,他的理由是BP神经网络训练慢,且泛化性不强(因为会局部最优):
    在这里插入图片描述
    但是我觉得ELM这样搞肯定是以模型精度换泛化性啊,我觉得少量超限学习机的准确率肯定是不如BP神经网络来的好的,ELM也确实在局部精度上不如BP神经网络。
    所以他引入了bagging和boosting进行优化:
    在这里插入图片描述
    Boosting就是针对上一次迭代的错误数据更加“集中”的学习,来降低整体的错误率,类似于一种强化(权值调整)。更接近BP,不过BP是根据每条数据进行调整,而boosting是每次迭代之后进行调整。
    在这里插入图片描述
    我在这里总结过bagging和boosting:https://blog.csdn.net/qq_43012160/article/details/96303739
    在这里插入图片描述
    ELM隐含层权重是算出来的,不是通过梯度下降训练出来的,确实存在鲁棒性和局部精度的问题:

    在这里插入图片描述

    城市拥堵指标

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    数据分类处理

    有点张红那篇论文宏观上周期趋势,微观上时序非时序的意思了:
    在这里插入图片描述
    然后就讲到了数据子集的划分:聚类

    聚类

    在这里插入图片描述
    最后做出来聚类优化的结果确实好一点,但是考虑到其本身具有最优参数的性质,作者认为其提升空间有限,即聚类优化优秀在于其参数选择功能,而非其聚类的数据分布优化。
    在这里插入图片描述
    在这里插入图片描述
    然后就讲到了聚类划分数据子集进行群组学习:
    在这里插入图片描述
    附属特征类似于数据库里的主属性,按不同主属性拆分数据集
    在这里插入图片描述
    这个只训练输出层。。和fine-tune很相似啊。。
    最后的模型框架:
    在这里插入图片描述
    聚类的依据叫做变差系数:
    在这里插入图片描述
    但是聚类会带来一个问题,就是数据分布不均的问题,有的聚类样本多,有的聚类样本少。样本多的聚类会把整个模型带的往他那里偏,可能只是因为他样本多,并不代表他重要性大;样本少的不仅会对子模型的精度产生影响,也会导致其占总模型的权重下降,可能是很重要的属性但是不受重视。

    为此我们介绍过采样和疏采样:为解决数据分布不均问题,对大样本进行疏采样,聚类后只取中心点;对小样本进行过采样,选取临近点对生成虚样本(数据可以往上偏差自然就有可能往下偏差,我就参照往上偏差的点对称出一个往下偏差的点,这里偏差当然不能大,所以要强调临近点)。

    如果有理解不对的地方欢迎指正!

    展开全文
  • 行业资料-交通装置-一种桥下积水导致的交通拥堵蔓延预测技术方案.zip
  • 交通流参数短时预测进行深入研究,将常用的几种交通流参数短时预测方 法进行数据融合,建立了一种多模型融合预测方法,并且运用在西安市南二环中段实际 调查所得的交通流量数据,对常用的两种预测方法和建立的多...
  • 基于BP神经网络的城市交通拥堵情况预测.pdf
  • 采用机器学习技术预测交通拥堵态势.pdf
  • 通过网络物理链接优化识别和预测城市交通拥堵
  • 随着交通拥堵的现状越来越严重,如何准确预测交通拥堵的时间已经成为人们关注的焦点。 在本文中,我们将构建两个模型来更好地预测交通拥堵时间。 首先,我们使用方法收集所需的数据,并通过初步清理,处理,删除丢失...
  • 基于GA-BP神经网络的空中交通网络流系统拥堵预测.pdf
  • 交通拥堵预测是智慧交通一个重要组成部分,但是大量的交通数据无法以公开的方式获取。在不完全数据下,提出了一种基于时空相关性的交通拥堵预测方法。该方法采用改进的核密度估计法,使得预测过程中不依赖大量历史...
  • TranSEC是由美国能源部太平洋西北国家实验室(Pacific Northwest National Laboratory)开发的、旨在帮助城市交通工程师获取其所在城市交通模式信息的工具。 目前,以街道为单位的公开的交通信息并不完整,交通...

    TranSEC是由美国能源部太平洋西北国家实验室(Pacific Northwest National Laboratory)开发的、旨在帮助城市交通工程师获取其所在城市交通模式信息的工具。

    目前,以街道为单位的公开的交通信息并不完整,交通工程师通常依靠孤立的交通量观测值、碰撞和车速数据来确定交通状况。而TranSEC可以将这些交通数据进行整合,绘制出实时的街道级交通流。

    协助开发TranSEC的计算机科学家Arif Khan说:“它(TranSEC)的神奇之处在于,可以帮助交通工程师评估大城市的街道水平。”“不像其他的模型只能在某一特定区域工作,TranSEC是便携式的,可以应用到任何有交通流的城市区域。”

    在这里插入图片描述

    TranSEC能够绘制出实时的街道级交通流

    TranSEC是评估街道运输状态的工具,它优于其他交通监控设施的地方在于,能够将那些不完整、甚至是碎片的交通信息整合,并作出接近实际的实时街道运输水平的评估。

    利用1500平方英里洛杉矶市区的公共交通数据进行训练,该团队将创建交通拥堵模型所需的时间减少了一个数量级——从数小时缩短到几分钟,并通过PNNL的高性能计算资源的提速功能使得近实时的流量分析变得可行。

    利用PNNL的数据驱动方法,用户可以在运输控制中心定期上传实时数据并定期更新TranSEC。利用PNNL的数据驱动方法,人们还可以计算出天气等因素对道路状况的影响指数。

    在这里插入图片描述

    该队在今年8月的虚拟城市计算研讨会(SIGKDD)上分享了他们的研究成果。同为与会者的马里兰大学高级交通技术中心的研究工程师Mark Franz表示:“TranSEC可能会引发交通监测和预测系统移动性能的范式转变”。

    TranSEC的机器学习功能意味着,随着越来越多的数据将被获取和处理,其对街道级交通状况的评估和预测结果将变得更加精准。这种分析能力可以帮助交通工程师了解交通干扰因素是如何在网络中传播的,工程师也可借此做出正确决策并及时纠正决策。

    就像情景感知可以帮助驾驶员做出决策一样,TranSEC的方法也可以在系统范围内提供情景感知,以帮助减少城市交通拥堵。

    PNNL计算机科学家、TranSEC项目的首席研究员Robert Rallo说:“能够预测一个小时或更长时间内道路情况的能力非常有价值,因为它可以知道阻塞将在何处发生。”

    虽然运行整个国家所有城市的交通模型需要更高性能的计算资源,但TranSEC具有可扩展性。TranSEC项目经理Katherine Wolf说:“我们正在努力使TranSEC在全国各地都能使用。”

    参考:

    1.https://techxplore.com/news/2020-12-machine-tool-tracks-urban-traffic.html

    2.https://www.newswise.com/doescience/?article_id=742660&returnurl=aHR0cHM6Ly93d3cubmV3c3dpc2UuY29tL2FydGljbGVzL2xpc3Q

    展开全文
  • 拟议的概念证明,用于解决智​​能城市的交通拥堵预测问题。 二手-LSTM(用于将来的预测)+ CNN(用于检测流量密度)+实时推文将所有这三种方法结合起来以产生流量拥塞因子(TCF),并在将来的任何时候使用Google ...
  • GNN交通流量预测

    千次阅读 热门讨论 2020-11-25 17:14:51
    利用几种典型的图网络进行交通流量的预测

    简介

    随着图网络的发展,其在非欧氏数据上的应用被进一步开发,而交通预测就是图网络的一个主要应用领域。交通预测指的是根据历史交通数据和交通网络的拓扑结构来预测未来的交通状况,包括但不限于速度、流量、拥堵等。交通流量预测是其他上层任务如路径规划的基础,是工业界非常关心的任务。本文采用三种经典的图网络模型(GCN、ChebNet和GAT)进行图结构的交通流量预测,整个项目采用PyTorch实现,项目全部源码见文末Github地址。

    数据准备

    本文采用的是ASTGCN这篇采用图网络进行交通预测论文提供的数据集PEMS,包括PEMS04和PEMS08。其中PEMS04是2018年1月1日开始采集的连续59天的307的探测器获得的流量数据,每5分钟采集一次,所以原始流量数据data.npz读取后shape为(307, 16992, 3),其中3维特征为flow, occupy, speed,原始邻接矩阵数据是一个distance.csv文件,它包含是from,to,distance的格式,方便起见,本文距离(对应图上的边权)只要节点相连都取1。相似的是,PEMS08是2016年7月1日开始采集的连续62天170个节点的流量数据,其数据shape为(170, 17856, 3)

    可以理解,构建的Graph上每个节点就是一个探测器获得的流量数据,每条边就是两个节点连接的权重。下图是对PEMS04中224号节点一天内的三种采集数据的可视化,可以看到只有流量数据起伏比较大,因此本文也只采用流量数据进行预测。

    这里也给出PEMS的数据集百度云链接(code:zczc)。

    在这里插入图片描述

    关于数据读取方面的内容,这里不多提及,对这种时序数据读取和预处理包括划分不熟悉的可以查看我文末的Github。

    模型构建

    首先是ChebNet模型的构建,它将SCNN中的谱域图卷积核替换为了切比雪夫多项式,如下式,最终要学习的只有 K + 1 K+1 K+1个参数,大大减少了SCNN巨大的参数量(拉普拉斯矩阵特征分解求解特征向量)。

    x ⋆ G g θ = U g θ U T x = ∑ k = 0 K β k T k ( L ^ ) x x \star_{G} g_{\theta}=U g_{\theta} U^{T} x =\sum_{k=0}^{K} \beta_{k} T_{k}(\hat{L}) x xGgθ=UgθUTx=k=0KβkTk(L^)x

    ChebNet的代码实现如下,不过,虽然减少了参数量,但是卷积核有了严格的空间局限性, K K K就是卷积核的“感受野半径”,即将距离中心节点 k k k个节点作为邻域节点( k = 1 k = 1 k=1时便相当于普通的3x3卷积,邻域为1)。

    class ChebConv(nn.Module):
    
        def __init__(self, in_c, out_c, K, bias=True, normalize=True):
            """
            ChebNet conv
            :param in_c: input channels
            :param out_c:  output channels
            :param K: the order of Chebyshev Polynomial
            :param bias:  if use bias
            :param normalize:  if use norm
            """
            super(ChebConv, self).__init__()
            self.normalize = normalize
    
            self.weight = nn.Parameter(torch.Tensor(K + 1, 1, in_c, out_c))  # [K+1, 1, in_c, out_c]
            init.xavier_normal_(self.weight)
    
            if bias:
                self.bias = nn.Parameter(torch.Tensor(1, 1, out_c))
                init.zeros_(self.bias)
            else:
                self.register_parameter("bias", None)
    
            self.K = K + 1
    
        def forward(self, inputs, graph):
            """
    
            :param inputs: he input data, [B, N, C]
            :param graph: the graph structure, [N, N]
            :return: convolution result, [B, N, D]
            """
            L = ChebConv.get_laplacian(graph, self.normalize)  # [N, N]
            mul_L = self.cheb_polynomial(L).unsqueeze(1)  # [K, 1, N, N]
            result = torch.matmul(mul_L, inputs)  # [K, B, N, C]
            result = torch.matmul(result, self.weight)  # [K, B, N, D]
            result = torch.sum(result, dim=0) + self.bias  # [B, N, D]
    
            return result
    
        def cheb_polynomial(self, laplacian):
            """
            Compute the Chebyshev Polynomial, according to the graph laplacian
    
            :param laplacian: the multi order Chebyshev laplacian, [K, N, N]
            :return:
            """
            N = laplacian.size(0)  # [N, N]
            multi_order_laplacian = torch.zeros([self.K, N, N], device=laplacian.device, dtype=torch.float)  # [K, N, N]
            multi_order_laplacian[0] = torch.eye(N, device=laplacian.device, dtype=torch.float)
    
            if self.K == 1:
                return multi_order_laplacian
            else:
                multi_order_laplacian[1] = laplacian
                if self.K == 2:
                    return multi_order_laplacian
                else:
                    for k in range(2, self.K):
                        multi_order_laplacian[k] = 2 * torch.mm(laplacian, multi_order_laplacian[k - 1]) - \
                                                   multi_order_laplacian[k - 2]
    
            return multi_order_laplacian
    
        @staticmethod
        def get_laplacian(graph, normalize):
            """
            compute the laplacian of the graph
            :param graph: the graph structure without self loop, [N, N]
            :param normalize: whether to used the normalized laplacian
            :return:
            """
            if normalize:
                D = torch.diag(torch.sum(graph, dim=-1) ** (-1 / 2))
                L = torch.eye(graph.size(0), device=graph.device, dtype=graph.dtype) - torch.mm(torch.mm(D, graph), D)
            else:
                D = torch.diag(torch.sum(graph, dim=-1))
                L = D - graph
            return L
    
    
    class ChebNet(nn.Module):
    
        def __init__(self, in_c, hid_c, out_c, K):
            """
            :param in_c: int, number of input channels.
            :param hid_c: int, number of hidden channels.
            :param out_c: int, number of output channels.
            :param K:
            """
            super(ChebNet, self).__init__()
            self.conv1 = ChebConv(in_c=in_c, out_c=hid_c, K=K)
            self.conv2 = ChebConv(in_c=hid_c, out_c=out_c, K=K)
            self.act = nn.ReLU()
    
        def forward(self, data, device):
            graph_data = data["graph"].to(device)[0]  # [N, N]
            flow_x = data["flow_x"].to(device)  # [B, N, H, D]
    
            B, N = flow_x.size(0), flow_x.size(1)
    
            flow_x = flow_x.view(B, N, -1)  # [B, N, H*D]
    
            output_1 = self.act(self.conv1(flow_x, graph_data))
            output_2 = self.act(self.conv2(output_1, graph_data))
    
            return output_2.unsqueeze(2)
    
    

    接着是GCN模型的构建,按照下面的公式,先计算出标准化的拉普拉斯矩阵,再和 W W W X X X先后矩阵乘法,就得到了最后的输出。GCN是一个著名的谱域图卷积方法,它对ChebNet进行进一步简化,只采用一阶切比雪夫多项式,一个卷积核只有一个 θ \theta θ需要学习,虽然卷积核减小了,但是通过多层堆叠可以获得卷积神经网络类似的能力。因此,GCN也被认为是谱域到空域的一个过渡方法。

    x ⋆ G g θ = θ ( D ~ − 1 / 2 W ~ D ~ − 1 / 2 ) x x \star_{G} g_{\theta}=\theta\left(\tilde{D}^{-1 / 2} \tilde{W} \tilde{D}^{-1 / 2}\right) x xGgθ=θ(D~1/2W~D~1/2)x

    PyTorch实现GCN的源码如下。

    class GCN(nn.Module):
        def __init__(self, in_c, hid_c, out_c):
            """
            GCN
            :param in_c: input channels
            :param hid_c:  hidden nodes
            :param out_c:  output channels
            """
            super(GCN, self).__init__()
            self.linear_1 = nn.Linear(in_c, hid_c)
            self.linear_2 = nn.Linear(hid_c, out_c)
            self.act = nn.ReLU()
    
        def forward(self, data, device):
            graph_data = data["graph"].to(device)[0]  # [N, N]
            graph_data = self.process_graph(graph_data)
    
            flow_x = data["flow_x"].to(device)  # [B, N, H, D]
    
            B, N = flow_x.size(0), flow_x.size(1)
    
            flow_x = flow_x.view(B, N, -1)  # [B, N, H*D]  H = 6, D = 1
    
            output_1 = self.linear_1(flow_x)  # [B, N, hid_C]
            output_1 = self.act(torch.matmul(graph_data, output_1))  # [N, N], [B, N, Hid_C]
    
            output_2 = self.linear_2(output_1)
            output_2 = self.act(torch.matmul(graph_data, output_2))  # [B, N, 1, Out_C]
    
            return output_2.unsqueeze(2)
    
        @staticmethod
        def process_graph(graph_data):
            N = graph_data.size(0)
            matrix_i = torch.eye(N, dtype=graph_data.dtype, device=graph_data.device)
            graph_data += matrix_i  # A~ [N, N]
    
            degree_matrix = torch.sum(graph_data, dim=-1, keepdim=False)  # [N]
            degree_matrix = degree_matrix.pow(-1)
            degree_matrix[degree_matrix == float("inf")] = 0.  # [N]
    
            degree_matrix = torch.diag(degree_matrix)  # [N, N]
    
            return torch.mm(degree_matrix, graph_data)  # D^(-1) * A = \hat(A)
    

    最后,是空域里比较经典的图注意力网络GAT,它将注意力机制引入了图卷积模型之中。论文作者认为邻域中所有的节点共享一个相同的卷积核参数会限制模型的能力,因为邻域内每一个节点和中心节点的关联度是不一样的,所以在进行卷积操作时,需要对邻域节点“区别对待”,作者采用的是attention机制来对中心节点和邻域节点的关联度进行建模。它的具体步骤如下(详细算法流程请查看原文):

    1. 计算节点之间的关联度
      e i j = α ( w h ⃗ i , W h ⃗ j ) = a ⃗ T [ W h ⃗ i ∥ W h ⃗ j ] e_{i j}=\alpha\left(\mathbf{w} \vec{h}_{i}, \mathbf{W} \vec{h}_{j}\right)=\vec{a}^{T}\left[\mathbf{W} \vec{h}_{i} \| \mathbf{W} \vec{h}_{j}\right] eij=α(wh i,Wh j)=a T[Wh iWh j]
    2. 使用softmax函数对每个节点的注意力系数进行归一化
      α i j = softmax ⁡ j ( e i j ) = exp ⁡ ( e i j ) ∑ k ∈ N i exp ⁡ ( e i k ) \alpha_{i j}=\operatorname{softmax}_{j}\left(e_{i j}\right)=\frac{\exp \left(e_{i j}\right)}{\sum_{k \in \mathcal{N}_{i}} \exp \left(e_{i k}\right)} αij=softmaxj(eij)=kNiexp(eik)exp(eij)
    3. 利用上述得到的注意力系数对邻域节点进行有区别的信息聚合,其中, α i j \alpha_{ij} αij便是softmax归一化之后的注意力系数, W W W为共享的卷积核参数, h ⃗ j \vec{h}_{j} h j为节点特征。
      h ⃗ i ′ = f ( ∑ j ∈ N i α i j W h ⃗ j ) \vec{h}_{i}^{\prime}=f\left(\sum_{j \in \mathcal{N}_{i}} \alpha_{i j} \mathbf{W} \vec{h}_{j}\right) h i=fjNiαijWh j

    GAT的代码实现如下,我这里采用了多头注意力。

    class GraphAttentionLayer(nn.Module):
        def __init__(self, in_c, out_c, alpha=0.2):
            """
            graph attention layer
            :param in_c:
            :param out_c:
            :param alpha:
            """
            super(GraphAttentionLayer, self).__init__()
            self.in_c = in_c
            self.out_c = out_c
            self.alpha = alpha
    
            self.W = nn.Parameter(torch.empty(size=(in_c, out_c)))
            nn.init.xavier_uniform_(self.W.data, gain=1.414)
            self.a = nn.Parameter(torch.empty(size=(2 * out_c, 1)))
            nn.init.xavier_uniform_(self.a.data, gain=1.414)
            self.leakyrelu = nn.LeakyReLU(self.alpha)
    
        def forward(self, features, adj):
            B, N = features.size(0), features.size(1)
            adj = adj + torch.eye(N, dtype=adj.dtype).cuda()  # A+I
            h = torch.matmul(features, self.W)  # [B,N,out_features]
            # [B, N, N, 2 * out_features]
            a_input = torch.cat([h.repeat(1, 1, N).view(B, N * N, -1), h.repeat(1, N, 1)], dim=2).view(B, N, -1, 2 * self.out_c)
            e = self.leakyrelu(torch.matmul(a_input, self.a).squeeze(3))  # [B,N, N, 1] => [B, N, N]
            zero_vec = -1e12 * torch.ones_like(e)
            attention = torch.where(adj > 0, e, zero_vec)  # [B,N,N]
            attention = F.softmax(attention, dim=2)  # softmax [N, N]
            # attention = F.dropout(attention, 0.5)
            h_prime = torch.matmul(attention, h)  # [B,N, N]*[N, out_features] => [B,N, out_features]
            return h_prime
    
        def __repr__(self):
            return self.__class__.__name__ + ' (' + str(self.in_features) + ' -> ' + str(self.out_features) + ')'
    
    
    class GAT(nn.Module):
        def __init__(self, in_c, hid_c, out_c, n_heads=8):
            """
            :param in_c: int, number of input channels.
            :param hid_c: int, number of hidden channels.
            :param out_c: int, number of output channels.
            :param K:
            """
            super(GAT, self).__init__()
            self.attentions = nn.ModuleList([GraphAttentionLayer(in_c, hid_c) for _ in range(n_heads)])
            # self.conv1 = GraphAttentionLayer(in_c, hid_c)
            self.conv2 = GraphAttentionLayer(hid_c * n_heads, out_c)
            self.act = nn.ReLU()
    
        def forward(self, data):
            # data prepare
            adj = data["graph"][0]  # [N, N]
            x = data["flow_x"]  # [B, N, H, D]
            B, N = x.size(0), x.size(1)
            x = x.view(B, N, -1)  # [B, N, H*D]
    
            # forward
            outputs = torch.cat([attention(x, adj) for attention in self.attentions], dim=-1)
            outputs = self.act(outputs)
            # output_1 = self.act(self.conv1(flow_x, adj))
            output_2 = self.act(self.conv2(outputs, adj))
    
            return output_2.unsqueeze(2)  # [B,1,N,1]
    

    训练实验

    我这边当作一个回归任务来看,采用比较基础的MSE损失和Adam+SGD的训练策略,同等配置下训练并测试ChebNet、GCN和GAT,进行可视化,结果如下图。训练代码有点长,就不贴了,感兴趣的可以访问文末Github。

    在这里插入图片描述

    在这里插入图片描述

    在这里插入图片描述

    上图可以看到,ChebNet靠着较大的复杂性和理论基础,在这个任务取得了不错的效果。

    最后做个总结,本文只是对几个图卷积模型进行了简单的实验,事实上三个模型都有类似flow_x = flow_x.view(B, N, -1)的代码段,这代表我们将时序数据拼接到了一起,这就无疑等同于放弃了时间信息,实际上,对于这种时序任务,时间信息是至关重要的,像STGCN、ASTGCN、DCRNN等方法都是考虑时序特征才获得了很不错的效果。

    补充说明

    本文在PEMS数据集上进行了交通流量预测,项目和博客书写过程中参考了一篇博文,在他的基础上我进行了完善。完整的代码开放在Github上,欢迎star和fork。

    展开全文
  • 城市短时交通流预测可以帮助人们选择出行最优路线,提高出行效率,其研究在交通拥堵日益严重的今天十分必要.受天气等多种因素影响,短时交通流的精确预测比较困难,为改善短时交通流预测的精度,本文提出了一种基于...
  • 为减轻日益严重的交通拥堵问题,实现智能交通管控,给交通流诱导和交通出行提供准确实时的交通流预测数据,设计了基于长短时记忆神经网络(LSTM)和BP神经网络结合的LSTM-BP组合模型算法.挖掘已知交通流数据的特征...
  • 基于软件的信息系统,可减少交通拥堵,提供测量、管理和预测性交通分析,并提高地面交通系统的安全性。 该项目的目标是提供领先的智能交通管理信息系统,应用先进技术来规划、设计、集成和实现完整的解决方案,以...
  • 交通流精准预测对保障公共安全和解决交通拥堵具有重要的意义, 在城市交通规划、交通管理、交通控制等起着重要的作用. 交通预测由于其受限制于城市路网并且随着时间动态变化, 其中存在着空间依赖与时间依赖, 是近些年...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,183
精华内容 1,673
关键字:

交通拥堵预测