gepc代码文件 graph.py_gepc文件编号

gepc.graph

1.graph.py：定义graph类，得到邻接矩阵A

graph.py 的思路为
1.初始化。得到布局、策略、有无头部关键点、节点之间的联系、按照策略获得邻接矩阵。
2.获取数据集的边界数据edge，输入为布局layout。

	获取布局(openpose or ntu 数据集节点信息)
	得到每个节点自身的link关系
	得到数据集中给出的关节点相互之间的link关系
	是否加入头部关键点
	edge=关节点自身link+ 关节点之间的link
	设置姿态中心关节点
1
2
3
4
5
6

3.获取关节点之间的距离

	建立一个 （节点数*节点数） 大小的零矩阵，并给矩阵中所有元素赋值为1
	计算关节点之间距离步数：
	节点之间的距离=零矩阵+正无穷。
	对a矩阵中的数值进行d次方运算，对d取遍从0到最大距离1.
	将新生成transermat进行堆叠。
	对d在1到-1之间以0个步长进行遍历，让d将arrivemat中的d进行赋值。
	返回hopdis。
1
2
3
4
5
6
7

4.获得邻接矩阵A

	关节之间的有效距离范围为（0，maxhop=1）。
	邻接矩阵=（顶点数目 * 顶点数目） 大小的零矩阵。
	在有效距离中进行遍历，得到能使hopdis与hop相等的邻接矩阵，并将这个矩阵赋值为1，下称“有效距离邻接矩阵”。
	对这个矩阵进行归一化。
	最终获得邻接矩阵A。
		如果在uniform策略下。建立一个 （1*顶点数目*顶点数目） 的零矩阵，将归一化的矩阵放在a（0）项，作为graph类的self.A。
		如果在distance策略下。建立一个 （有效距离*顶点数目*顶点数目）的零矩阵，把有效距离邻接矩阵放入。
		**如果在spatial策略下。把一个数组A放入。（在空间策略下，由于d的不同，对距离中心点远近不同的矩阵按照由近到远的顺序进行依次放入）**
				建立零矩阵root，建立零矩阵close，建立零矩阵further。
					如果hop为0，就在A数组后面添加root矩阵。
					否则，加入root+close矩阵。再加入further矩阵。
				对按照以上过程得到的A矩阵进行堆叠，得到邻接矩阵A。
1
2
3
4
5
6
7
8
9
10
11
12

最终返回邻接矩阵A：静态邻接矩阵：使用身体部位的连通性作为节点上的先验关系。
静态邻接A被固定，并由所有层共享。

"""
Graph definitions, based on awesome previous work by https://github.com/yysijie/st-gcn
图形定义，基于stgcn
"""
import numpy as np


class Graph:
    """ The Graph to models the skeletons extracted by the openpose   Graph：用于对openpose提取的骨骼进行建模

    Args:
        strategy (string): must be one of the follow candidates       策略（字符串）：必须为以下之一
        - uniform: Uniform Labeling                                   统一：统一标签
        - distance: Distance Partitioning                             距离：距离分区
        - spatial: Spatial Configuration                              空间：空间配置
        For more information, please refer to the section 'Partition Strategies'
            in our paper (https://arxiv.org/abs/1801.07455).

        layout (string): must be one of the follow candidates                        布局（字符串）：必须为以下候选者之一
        - openpose: Is consists of 18 joints. For more information, please
            refer to https://github.com/CMU-Perceptual-Computing-Lab/openpose#output
        - ntu-rgb+d: Is consists of 25 joints. For more information, please
            refer to https://github.com/shahroudy/NTURGB-D

        max_hop (int): the maximal distance between two connected nodes              两个连接的节点之间的最大距离

    """

    def __init__(self,
                 layout='openpose',
                 strategy='spatial',
                 headless=False,
                 max_hop=1):
        self.headless = headless
        self.max_hop = max_hop
        self.get_edge(layout)
        self.hop_dis = get_hop_distance(self.num_node, self.edge, max_hop=max_hop)
        self.get_adjacency(strategy)  # 按照策略获得邻接矩阵

    def __str__(self):
        return self.A  # a为（38行）得到邻接矩阵时创建的零矩阵

    def get_edge(self, layout):  # 获取数据集的边界edge
        if layout == 'openpose':
            self.num_node = 14  # openpose顶点node为14个（无头）
            self_link = [(i, i) for i in range(self.num_node)]  # 循环14次，得到关节自身的link
            neighbor_link = [(4, 3), (3, 2), (7, 6), (6, 5), (13, 12), (12, 11),
                             (10, 9), (9, 8), (11, 5), (8, 2), (5, 1), (2, 1), (0, 1)]  # openpose中关节之间的联系
            if not self.headless:  # if not= none，即headless=none，在有头部的情况下
                neighbor_link += [(15, 0), (14, 0), (17, 15), (16, 14)]  # 需要加入openpose中头部的关节联系
                self.num_node = 18  # openpose顶点node为18个（有头）
            self.edge = self_link + neighbor_link  # edge为关节自身edge加关节之间的联系
            self.center = 1  # 姿态中心节点为1
        elif layout == 'ntu-rgb+d':
            self.num_node = 25
            self_link = [(i, i) for i in range(self.num_node)]
            neighbor_1base = [(1, 2), (2, 21), (3, 21), (4, 3), (5, 21),
                              (6, 5), (7, 6), (8, 7), (9, 21), (10, 9),
                              (11, 10), (12, 11), (13, 1), (14, 13), (15, 14),
                              (16, 15), (17, 1), (18, 17), (19, 18), (20, 19),
                              (22, 23), (23, 8), (24, 25), (25, 12)]
            neighbor_link = [(i - 1, j - 1) for (i, j) in neighbor_1base]  # 由于不包含0节点
            self.edge = self_link + neighbor_link
            self.center = 21 - 1

        else:
            raise ValueError("Do Not Exist This Layout.")  # 如果不为这两个模型就输出 没有出现这个布局

    def get_adjacency(self, strategy):  # 邻接的获得
        valid_hop = range(0, self.max_hop + 1)  # 关节之间的有效距离为（0，两个节点的最大距离），从0开始计数到两个节点的最大距离
        adjacency = np.zeros((self.num_node, self.num_node))  # 生成一个顶点数目*顶点数目大小的零矩阵
        for hop in valid_hop:  # 在validhop中进行遍历
            adjacency[self.hop_dis == hop] = 1  # 得到maxhop数量的邻接矩阵=1
        normalize_adjacency = normalize_digraph(adjacency)  # 图像归一化

        if strategy == 'uniform':  # uniform策略下
            A = np.zeros((1, self.num_node, self.num_node))
            A[0] = normalize_adjacency
            self.A = A
        elif strategy == 'distance':  # 距离策略下
            A = np.zeros((len(valid_hop), self.num_node, self.num_node))
            for i, hop in enumerate(valid_hop):  # 获得索引和对应值的方法，索引为validhop
                A[i][self.hop_dis == hop] = normalize_adjacency[self.hop_dis == hop]  # 获得归一化邻接矩阵
            self.A = A
        elif strategy == 'spatial':  # 在空间策略下
            A = []
            for hop in valid_hop:  # 在validhop进行循环
                a_root = np.zeros((self.num_node, self.num_node))  # 建立零矩阵root
                a_close = np.zeros((self.num_node, self.num_node))  # 建立零矩阵close
                a_further = np.zeros((self.num_node, self.num_node))  # 建立零矩阵further
                for i in range(self.num_node):  # 在顶点数目-1循环
                    for j in range(self.num_node):
                        if self.hop_dis[j, i] == hop:
                            if self.hop_dis[j, self.center] == self.hop_dis[i, self.center]:
                                a_root[j, i] = normalize_adjacency[j, i]
                            elif self.hop_dis[j, self.center] > self.hop_dis[i, self.center]:
                                a_close[j, i] = normalize_adjacency[j, i]
                            else:
                                a_further[j, i] = normalize_adjacency[j, i]
                if hop == 0:
                    A.append(a_root)  # 在列表末尾添加新的对象，在a矩阵后面添加root矩阵
                else:
                    A.append(a_root + a_close)
                    A.append(a_further)
            A = np.stack(A)
            self.A = A
        else:
            raise ValueError("Do Not Exist This Strategy")


def get_hop_distance(num_node, edge, max_hop=1):  # 关节之间的距离
    A = np.zeros((num_node, num_node))  # 建立一个 节点*节点 大小的零矩阵
    for i, j in edge:  # 给矩阵进行赋值为1
        A[j, i] = 1
        A[i, j] = 1

    # compute hop steps  # 计算 关节之间距离的步数
    hop_dis = np.zeros((num_node, num_node)) + np.inf  # 节点之间的距离= 零矩阵+ 正无穷
    transfer_mat = [np.linalg.matrix_power(A, d) for d in range(max_hop + 1)]  # 对A矩阵中的数值进行d次方运算，d取遍0到最大距离
    arrive_mat = (np.stack(transfer_mat) > 0)  # 沿着新轴连接数组的序列，axis=0，增加第一个维度
    for d in range(max_hop, -1, -1):  # 在最大距离到0之间进行循环
        hop_dis[arrive_mat[d]] = d
    return hop_dis


def normalize_digraph(A):  # 图像归一化
    Dl = np.sum(A, 0)  # 按行相加
    num_node = A.shape[0]  # 维度归一
    Dn = np.zeros((num_node, num_node))
    for i in range(num_node):
        if Dl[i] > 0:
            Dn[i, i] = Dl[i]**(-1)
    AD = np.dot(A, Dn)
    return AD


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

2.sagc.py

sagc.py的主要思路为：
1.初始化sagc模块

	初始化及超类设置。按照stgcn的思想，将通道数划分为三个子集。
	对A矩阵设置默认值。
		使用nturgb或者open pose数据集布局。
		将graph类中的布局策略，strategy，layout，headless导入。
		把设定好的静态临界矩阵放入statadj变量中。
	建立global矩阵（B矩阵），以statadj矩阵为基础。
		将其转换为整型矩阵，将矩阵中0的元素填充为1e-6，属性为可进行梯度下降。
	将statadj转换为整形矩阵，属性为不进行梯度估计，子集数量为3。
	c矩阵的计算。
		设计a、b两个卷积模块，用3个2d卷积函数（in、inter、1）对两个卷积模块进行扩充。
		设计图卷积模块，用3个图卷积函数（out）进行扩充。
	残差层设计。
		如果输入输出通道数不相同，进行2d卷积操作和批量patch归一化。否则，x矩阵不变。
		批量归一化，求softmax，激活。
		取得statadj矩阵弟零项，并乘3作为卷积核大小。（每个单独通道的邻接矩阵不同）
		扩大卷积。2d卷积（in、out*卷积核、卷积核、步长=1、没有偏移）
		衰减卷积。2d卷积（3*out、out、步长=1、没有偏移）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

2.计算c矩阵

x矩阵尺寸输入。包括（n，chan，t，v）
建立一个数组C。
对卷积模块a中的值进行维度0123到0312的转换，再改变tensor的维度（n，v，中心通道数*t），达到转置的目的。
对卷积模块a和b之间进行点积运算，输入进softmax函数，并进行归一化，最后得到 inferred 邻接矩阵（c矩阵）。
1
2
3
4

3.前向传播

返回C矩阵。得到C矩阵的残差。对x矩阵进行扩大卷积。
把邻接矩阵adj赋值给A矩阵。提取输入x的大小（n，kc，t，v），并转变x矩阵的维度。
定义abc三个矩阵的获得方法。每个gconv获取outchannels作为输入，区别在于他们哦那个有不同的卷积核。
将这三个矩阵获得方法进行连接，步长为1，在给定维度上对输入的张量序列进行连续操作。得出的结果赋值给输入x。
执行衰减卷积。
输出y=x+x的残差。
1
2
3
4
5
6

全局卷积归一化和1*1卷积层

1.全局卷积：主要思想为，对bn和relu过程应用单个邻接图卷积
	初始化。定义bn为2d批量归一化函数，激活函数为relu，将计算得到的值直接覆盖之前得到的值。
	前向传播。
		全局邻接矩阵的情况下。如果邻接矩阵的尺寸长度为3，使用矩阵乘法，改变其维度为nctw。
		每个样本矩阵情况下。如果尺寸长度为4，改变维度。
		归一化之后进行激活，最终返回x。
2.1*1卷积层：能够将尺寸缩小3倍计算。
	初始化。定义组为输入通道数//邻接矩阵的类型数，并赋值给输出通道数。
		应用处理视频的3d卷积函数，提取时序信息。
	前向传播。
3.统计减少：通过汇总将尺寸减少3倍。
	组=输入通道数//邻接矩阵类型数。
	前向传播，提取输入矩阵的大小，改变其维度（第一维缩小一倍），去掉第二维。
1
2
3
4
5
6
7
8
9
10
11
12
13

import torch
import torch.nn as nn
import numpy as np
from models.graph.graph import Graph


class SAGC(nn.Module):
    """
    Spatial Attention Graph Convolution 空间注意力图卷积
    Applied to K_n adjacency subsets, each with K_a matrices 应用于K_n个邻接子集，每个子集都有K_a个矩阵
    Base class provides the data-based C matrix and returns  基类提供基于数据的C矩阵并返回
    K_n * K_a results.
    """
    def __init__(self, in_channels, out_channels,
                 stat_adj=None,
                 num_subset=3,
                 coff_embedding=4,
                 ntu=False,
                 headless=False):
        super().__init__()  # 初始化及超类设置
        inter_channels = out_channels // coff_embedding  # 划分子集的方式，按照stgcn方式。中心通道=输出通道//嵌入coff
        self.adj_types = 3  # 邻接矩阵的类型=3
        self.inter_c = inter_channels  # 按照stgcn，一共划分为三个子集
        if stat_adj is None:  # Default value for A: 对a矩阵设置默认值  如果没有静态临界矩阵
            layout = 'ntu-rgb+d' if ntu else 'openpose'  # 使用ntu数据集，否则openpose
            self.graph = Graph(strategy='spatial', layout=layout, headless=headless)  # 布局策略，空间、布局、无头
            stat_adj = self.graph.A  # 把设定好的邻接矩阵a矩阵放入stat（静态邻接）中

        self.g_adj = torch·.from_numpy(stat_adj.astype(np.float32))
        # 建立global矩阵。 astype是布尔类型，非零为true，零为false，即转换为整型矩阵
        nn.init.constant_(self.g_adj, 1e-6)  # 用1e-6填充向量，将0的位置填充为1e-6
        self.g_adj = nn.Parameter(self.g_adj, requires_grad=True)  # 转换gsdj的格式，判断条件为梯度需要

        self.stat_adj = torch.from_numpy(stat_adj.astype(np.float32))  # 转换为整型矩阵
        self.stat_adj.requires_grad = False  # 把stat邻接矩阵转换为不要梯度
        self.num_subset = num_subset  # 数据集的数量为3

        # Convolutions for calculating C adj matrix  计算C矩阵的卷积
        self.conv_a = nn.ModuleList()  # modulelist内部没有封装forward函数，只是使用append或者extend的操作对list进行扩充。
        self.conv_b = nn.ModuleList()
        for i in range(self.num_subset):  # 卷积三次
            self.conv_a.append(nn.Conv2d(in_channels, inter_channels, 1))
            # conv2d作为二位卷积的实现。先实例化再使用。卷积核大小为1*1
            self.conv_b.append(nn.Conv2d(in_channels, inter_channels, 1))

        self.gconv = nn.ModuleList()  # global矩阵
        for i in range(self.adj_types):
            self.gconv.append(GraphConvBR(out_channels))  # gconv后面加全局卷积生成的x

        # Residual Layer  残差层
        if in_channels != out_channels:  # 如果输入输出通道数不相同
            self.down = nn.Sequential(nn.Conv2d(in_channels, out_channels, 1),
                                      nn.BatchNorm2d(out_channels))
            # 进行卷积和批量归一化
            # sequential是一个有序的容器，神经网络模块将按照传入构造器的顺序一次被添加到计算图中执行，
            # 同时以神经网络模块为元素的有序字典也可以传入参数。
            # 根据自己的需求，把不同函数组合成一个小模块使用。
        else:
            self.down = lambda x: x  # 否则down等于x矩阵不变

        self.bn = nn.BatchNorm2d(out_channels)  # bn为批量标准化
        self.soft = nn.Softmax(-2)  # Cols sum to 1.0, perhaps rows should?  softmax函数
        self.relu = nn.CELU(0.01)  # nn.ReLU()

        self.kernel_size = self.stat_adj.size(0)  # Split to two different operators?  卷积核为stat邻接矩阵的第0项

        self.kernel_size *= 3  # Separate channels for each adj matrix  每个调整矩阵的单独通道
        self.expanding_conv = nn.Conv2d(in_channels,
                                        out_channels * self.kernel_size,
                                        kernel_size=(1, 1),
                                        padding=(0, 0),
                                        stride=(1, 1),
                                        dilation=(1, 1),
                                        bias=False)
        # 扩大卷积

        self.reduction_conv = nn.Conv2d(3 * out_channels, out_channels, 1, bias=False)  # 衰减卷积

    def forward(self, x, adj):  # 前向传播
        C = self.calc_C(x)  # 返回c矩阵
        x_residual = self.down(x)  # 剩余层的x矩阵的得到
        x = self.expanding_conv(x)  # 对x矩阵进行扩大卷积

        A = adj  # 把邻接矩阵赋给a
        N, KC, T, V = x.size()  # 提取x的大小
        x = x.view(N, self.kernel_size, KC//self.kernel_size, T, V)  # 转变x矩阵的维度

        # Each gconv gets out_channels as input, for sep_sum the channels
        # are from separate convolution kernels, otherwise they are the same inputs
        # 每个gconv获取out_channels作为输入，对于sep_sum，这些通道来自单独的卷积内核，否则它们是相同的输入
        x_A = self.gconv[0](x[:, 0:3], A)
        x_B = self.gconv[1](x[:, 3:6], self.g_adj)
        x_C = self.gconv[2](x[:, 6:9], C)

        # Summarize over A0,A1,A2, and conv-pool over x_A, x_B, x_C  汇总A0，A1，A2，并汇总x_A，x_B，x_C的转换池
        x = torch.cat((x_A, x_B, x_C), dim=1)  # 在给定维度上对输入的张量序列进行连接操作，输入为xabc，将这三个列表按照维度为一进行连接。
        x = self.reduction_conv(x)  # 执行衰减卷积
        y = x + x_residual  # 最终得到y
        return y, adj  # 返回y和连接

    def calc_C(self, x):  # c矩阵的计算
        N, chan, T, V = x.size()  # x矩阵的尺寸的输入
        # Calc C, the data-dependent adjacency matrix  数据相关的邻接矩阵
        C = []  # 建立一个数组
        for i in range(self.num_subset):  # （0，2）循环
            C1 = self.conv_a[i](x).permute(0, 3, 1, 2).contiguous().view(N, V, self.inter_c * T)
            # conva函数维度123交换位置。
            # 在使用peimute函数之后，数据不再连续，需要使用contiguous函数，在使用view函数改变tensor维度。否则会报错。
            C2 = self.conv_b[i](x).view(N, self.inter_c * T, V)
            C_curr = self.soft(torch.matmul(C1, C2))  # / C1.size(-1))  # N V V  矩阵乘法后，输入进softmax函数
            C.append(C_curr)  # c矩阵后加入currt函数
            del C1, C2

        C = torch.stack(C).permute(1, 0, 2, 3).contiguous()  # 最终得到c矩阵
        return C


class GraphConvBR(torch.nn.Module):  # 全局卷积
    def __init__(self, out_channels):
        """
        Applies a single adjacency graph convolution with BN and Relu 对BN和Relu应用单个邻接图卷积
        bn是批量标准化，在cnn中，batch就是训练网络所设定的图片数量batchsize
        对于输入的一个batch数据，先计算出每个维度的平均值和方差，
        对于一个2*2的灰度图像来说，那么就要计算一个batch内每个像素通道的平均值和方差（共计算四次，得到四个平均值和方差）。
        """
        super().__init__()
        self.bn = nn.BatchNorm2d(out_channels)
        #返回一个shape与num-feature相同的tensor，numfeature为输入batch中图像的Chanel数（按照每一个chanel来做归一化）
        self.act = nn.ReLU(inplace=True)  # 激活函数relu，inplace=true：是否将计算得到的值直接覆盖之前的值

    def forward(self, x, adj):  # 前向传播
        if len(adj.size()) == 3:  # Global adj matrix
            x = torch.einsum('nkctv,kvw->nctw', (x, adj))
        elif len(adj.size()) == 4:  # Per sample matrix
            x = torch.einsum('nkctv,nkvw->nctw', (x, adj))
        x = self.act(self.bn(x))  # 归一化之后进行激活
        return x


class Conv1x1(torch.nn.Module):  # 1*1卷积层
    def __init__(self, in_channels, adj_types=3):
        """
        An operation for reducing dimensions by a factor of 3 using 1x1 convs.     使用1x1转换将尺寸缩小3倍的运算。
        Reduces in groups of 3, i.e. (512, 3, 64, 12, 18) -> (512, 1, 64, 12, 18)
        and (512, 9, 64, 12, 18) -> (512, 3, 64, 12, 18) where channel i of the output 3 is
        a function of channels (3*i:3*i+2) of the input [Batch, adj, chan, time, vertices]
        """
        super().__init__()
        groups = in_channels // adj_types  # 组=输入通道//3
        out_channels = groups  # Each group reduces to a single channle 每组减少到一个通道
        self.conv = nn.Conv3d(in_channels, out_channels, kernel_size=1, groups=groups)
        # 在处理视频时使用，目的是为了提取时序信息。输入输出通道数、卷积核大小、group（步长/补位）。

    def forward(self, x):  # 前向传播
        x_out = self.conv(x)
        return x_out


class SumReduce(torch.nn.Module):
    def __init__(self, in_channels, adj_types=3):
        """
        An operation for reducing dimensions by a factor of 3 by summarizing.   通过汇总将尺寸减小三倍的操作。
        Reduces in groups of 3, i.e. (512, 3, 64, 12, 18) -> (512, 1, 64, 12, 18)
        and (512, 9, 64, 12, 18) -> (512, 3, 64, 12, 18) where channel i of the output 3 is
        a function of channels (3*i:3*i+2) of the input [Batch, adj, chan, time, vertices]
        """
        super().__init__()
        self.groups = in_channels // adj_types

    def forward(self, x):
        N, adj, Chan, T, V = x.size()  # I.e. [512, 6, 32, 12, 18]
        x = x.view(N, self.groups, adj // self.groups, Chan, T, V)  # I.e. [512, 3, 2, 32, 12, 18]
        x_out = x.sum(dim=2).contiguous()  # I.e. [512, 3, 32, 12, 18]
        return x_out
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174

3.pygeoconv.py

convtemporalgraphical类

	时域图像卷积：应用图卷积的基本模块。
	输入卷积核。
	通过2d卷积定义卷积内容。
	定义前向传播。
		确认邻接矩阵的第零项是否等于卷积核大小。
		进行卷积，并提取x的尺寸信息。
		改变输入矩阵的维度大小。
1
2
3
4
5
6
7

pygeoconv类

	初始化。输入为self类、输入输出通道数、卷积核、卷积操作模式、有无头和dropout。
		如果卷积操作为 sagc （2.空间注意力图像卷积），执行sagc.py中的sagc函数。
		如果卷积操作为 gcn （图卷积），执行本部分中的convtempral函数。
		进行前向传播，最终返回卷积结果。
1
2
3
4

import torch
import torch.nn as nn
from models.graph.sagc import SAGC


class PyGeoConv(nn.Module):
    def __init__(self,
                 in_channels,
                 out_channels,
                 kernel_size=1,
                 conv_oper='sagc',
                 headless=False,
                 dropout=0.0,
                 ):
        super().__init__()
        self.dropout = dropout
        self.kernel_size = kernel_size
        self.in_channels = in_channels
        self.out_channels = out_channels
        self.multi_adj = kernel_size > 1

        if conv_oper == 'sagc':  # 如果卷积操作为sagc
            self.g_conv = SAGC(in_channels, out_channels, headless=headless)
        elif conv_oper == 'gcn':  # 卷积操作为gcn
            self.g_conv = ConvTemporalGraphical(in_channels, out_channels, kernel_size)  # 使用下面的gcn图卷积基本方法
        else:
            raise Exception('No such Conv oper')

    def forward(self, inp, adj):  # 定义前向传播
        return self.g_conv(inp, adj)


class ConvTemporalGraphical(nn.Module):

    """
    The basic module for applying a graph convolution.  应用图卷积的基本模块
    Args:
        in_channels (int): Number of channels in the input sequence data  输入序列数据通道数
        out_channels (int): Number of channels produced by the convolution  卷积产生的通道数
        kernel_size (int): Size of the graph convolving kernel  图卷积核的大小
        t_kernel_size (int): Size of the temporal convolving kernel  时域卷积核的大小
        t_stride (int, optional): Stride of the temporal convolution. Default: 1  时域卷积的步长，默认为1
        t_padding (int, optional): Temporal zero-padding added to both sides of the input. Default: 0
        在输入两侧都添加了时域的零padding
        bias (bool, optional): If ``True``, adds a learnable bias to the output. Default: ``True``
        如果为真，给输出增加可学习的偏见
    """

    def __init__(self,
                 in_channels,
                 out_channels,
                 kernel_size,
                 t_kernel_size=1,
                 t_stride=1,
                 bias=True):
        super().__init__()

        self.kernel_size = kernel_size  # 输入卷积核
        self.conv = nn.Conv2d(  # 定义卷积，in，out，1*1的卷积核，步长为1，有偏见
            in_channels,
            out_channels * kernel_size,
            kernel_size=(t_kernel_size, 1),
            stride=(t_stride, 1),
            dilation=(1, 1),
            bias=bias)

    def forward(self, x, adj):  # 定义前向传播
        assert adj.size(0) == self.kernel_size

        x = self.conv(x)

        n, kc, t, v = x.size()
        x = x.view(n, self.kernel_size, kc//self.kernel_size, t, v)
        x = torch.einsum('nkctv,kvw->nctw', (x, adj))

        return x.contiguous(), adj


 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

4.st-graph-conv-block

时空图卷积块

	初始化。输入为：in/out chanels，kernel size，步长，dropout，卷积操作，是否激活，输出归一化，输出激活，残差，有无头。
	确定卷积核是否为2，确认卷积核的第零项%2==1.。设置padding的长度。
	将无头、输出激活、卷积操作、激活函数进行输入。
		然后执行上述pygeoconv模块，执行 sagc函数。进行空间注意力图卷积。
	进行输出批量归一化，否则，将函数输入进身份层。
    执行时域卷积网络函数（tcn）。
    	批量归一化，激活，卷积，进入归一化层，dropout（将所有元素中每个元素按照概率0.5更改为0，起到求均值的作用）。
    残差处理。
    	如果没有残差，设置残差=0.
    	如果有残差，且输出通道数==输出通道数，步长为1，那么就把残差保留。
    	否则，再次进行卷积核归一化操作。
	前向传播。
		得到残差。得到输入矩阵和邻接矩阵。
		将x输入tcn函数，得到结果+残差，返回输入x的值。
		再进行输出激活操作。最终返回x和adj。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

import torch.nn as nn
from models.graph.pygeoconv import PyGeoConv


class ConvBlock(nn.Module):  # 卷积块
    def __init__(self, in_channels, out_channels, kernel_size,
                 stride=1,
                 dropout=0,
                 conv_oper='sagc',
                 act=None,
                 out_bn=True,
                 out_act=True,
                 residual=True,
                 headless=False,):
        super().__init__()

        assert len(kernel_size) == 2  # 确认卷积核是否等于2
        assert kernel_size[0] % 2 == 1  # 确人卷积核大小是否
        padding = ((kernel_size[0] - 1) // 2, 0)  # padding:移动盒子的位置


        self.headless = headless  # 无头
        self.out_act = out_act  # 输出激活
        self.conv_oper = conv_oper  # 卷积操作
        self.act = nn.ReLU(inplace=True) if act is None else act  # 激活函数，替代原来的值
        self.gcn = PyGeoConv(in_channels, out_channels, kernel_size=kernel_size[1], dropout=dropout,
                             headless=self.headless, conv_oper=self.conv_oper)  # 执行sagc模块

        if out_bn:  # 如果存在输出批量归一化
            bn_layer = nn.BatchNorm2d(out_channels)  # 执行归一化层
        else:
            bn_layer = nn.Identity()
            # Identity layer shall no BN be used  身份层不能使用bn。
            # identify函数建立一个输入模块，什么都不做，通常用在神经网络的输入层。
            # 相当于一个容器，把输入保存下来


        self.tcn = nn.Sequential(nn.BatchNorm2d(out_channels),
                                 self.act,
                                 nn.Conv2d(out_channels,
                                           out_channels,
                                           (kernel_size[0], 1),
                                           (stride, 1),
                                           padding),
                                 bn_layer,
                                 nn.Dropout(dropout, inplace=True))
        # 时域卷积网络函数。
        # 执行如下操作：批量归一化，激活，卷积，进入归一化层，将所有元素中每个元素按照概率0.5更改为0

        if not residual:  # 如果没有残差
            self.residual = lambda x: 0  # 把残差设为0

        elif (in_channels == out_channels) and (stride == 1):  # 如果输入输出通道数相等且步长为1
            self.residual = lambda x: x  # 残差设为x

        else:
            self.residual = nn.Sequential(nn.Conv2d(in_channels,  # 否则再次进行卷积
                                          out_channels,
                                          kernel_size=1,
                                          stride=(stride, 1)),
                                          nn.BatchNorm2d(out_channels))

    def forward(self, x, adj):  # 前向传播
        res = self.residual(x)   
        x, adj = self.gcn(x, adj)
        x = self.tcn(x) + res
        if self.out_act:
            x = self.act(x)

        return x, adj

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71