def __init__(self, n_class, graph, kernel_num, in_channels, edge_weight, lamda, graph_arg={}):
super().__init__()
self.n_class = n_class
Graph = import_class(graph)
self.graph = Graph(**graph_arg)
self.A = self.graph.A
kernel_size = self.A.shape[0]
t_kernel = 9
self.bn0 = nn.BatchNorm1d(in_channels*self.A.shape[1]) # for NTU, 3*25
# self.backBones = nn.ModuleList((
self.backBone1 = MuiltKernelGTCN(in_channels, 64, self.A, True, kernel_num, (t_kernel, kernel_size), edge_weight, lamda)
self.backBone2 = MuiltKernelGTCN(64, 64, self.A, True, kernel_num, (t_kernel, kernel_size), edge_weight, lamda)
self.backBone3 = MuiltKernelGTCN(64, 64, self.A, True, kernel_num, (t_kernel, kernel_size), edge_weight, lamda)
self.backBone4 = MuiltKernelGTCN(64, 64, self.A, True, kernel_num, (t_kernel, kernel_size), edge_weight, lamda)
self.backBone5 = MuiltKernelGTCN(64, 128, self.A, True, kernel_num, (t_kernel, kernel_size), edge_weight, lamda, stride=2)
self.backBone6 = MuiltKernelGTCN(128, 128, self.A, True, kernel_num, (t_kernel, kernel_size), edge_weight, lamda)
self.backBone7 = MuiltKernelGTCN(128, 128, self.A, True, kernel_num, (t_kernel, kernel_size), edge_weight, lamda)
self.backBone8 = MuiltKernelGTCN(128, 256, self.A, True, kernel_num, (t_kernel, kernel_size), edge_weight, lamda, stride=2)
self.backBone9 = MuiltKernelGTCN(256, 256, self.A, True, kernel_num, (t_kernel, kernel_size), edge_weight, lamda)
self.backBone10 = MuiltKernelGTCN(256, 256, self.A, True, kernel_num, (t_kernel, kernel_size), edge_weight, lamda)
# ))
self.fcn = nn.Conv2d(64, n_class, kernel_size=1) #
def load_data(self):
Feeder = import_class(self.args.feeder)
if "debug" not in self.args.test_feeder_args:
self.args.test_feeder_args["debug"] = self.args.debug
self.data_loader = {}
if self.args.phase == "train":
self.data_loader["train"] = torch.utils.data.DataLoader(
dataset=Feeder(**self.args.train_feeder_args),
batch_size=self.args.batch_size,
shuffle=True,
num_workers=self.args.num_workers,
drop_last=True)
self.data_loader["test"] = torch.utils.data.DataLoader(
dataset=Feeder(**self.args.test_feeder_args),
batch_size=self.args.batch_size,
shuffle=True,
num_workers=self.args.num_workers,
drop_last=True)
def __init__(self,
input_channel,
mid_channels: list,
layer_num,
position_encoding,
heads,
encode_size,
d_ff,
dropout,
attention_dropout,
position_encoding_dropout,
point_num=25,
n_classes=60):
super(Model, self).__init__()
self.point_num = point_num
self.input_channel = input_channel
self.mid_channels = mid_channels
self.data_bn = nn.BatchNorm1d(self.point_num * self.input_channel)
self.input_att = MultiHeadedGraphAttention(input_channel, heads,
mid_channels[0])
self.input_layer = nn.ModuleList([
MultiHeadedGraphAttention(mid_channels[i], heads,
mid_channels[i + 1])
for i in range(len(self.mid_channels) - 1)
])
self.position_encoding = import_class(position_encoding)
self.encoder = Encoder(
layer_num=layer_num,
position_encoding=self.position_encoding,
heads=heads,
size=encode_size,
d_ff=d_ff,
dropout=dropout,
attention_dropout=attention_dropout,
position_encoding_dropout=position_encoding_dropout)
self.average_pooling = nn.AdaptiveMaxPool2d((8, 8))
self.out_pooling = nn.AdaptiveMaxPool1d(20)
self.output_layer = nn.Linear(20 * 8 * 8, n_classes)
def __init__(self,
graph,
kernel_num,
edge_weight,
lamda,
input_channel,
mid_channels: list,
layer_num,
position_encoding,
heads,
encode_size,
d_ff,
dropout,
attention_dropout,
position_encoding_dropout,
point_num=25,
n_classes=60,
graph_arg={}):
super(Model, self).__init__()
self.point_num = point_num
self.input_channel = input_channel
self.mid_channels = mid_channels
self.data_bn = nn.BatchNorm1d(self.point_num * self.input_channel)
Graph = import_class(graph)
self.graph = Graph(**graph_arg)
self.A = self.graph.A
kernel_size = self.A.shape[0]
t_kernel = 9
self.backBone1 = MuiltKernelGTCN_(input_channel,
64,
self.A,
True,
kernel_num, (t_kernel, kernel_size),
edge_weight,
lamda,
dropout=dropout)
self.backBone2 = MuiltKernelGTCN_(64,
64,
self.A,
True,
kernel_num, (t_kernel, kernel_size),
edge_weight,
lamda,
stride=1,
dropout=dropout)
self.backBone3 = MuiltKernelGTCN_(64,
64,
self.A,
True,
kernel_num, (t_kernel, kernel_size),
edge_weight,
lamda,
dropout=dropout)
self.input_att = MultiHeadedGraphAttention(64, heads, mid_channels[0])
self.input_layer = nn.ModuleList([
MultiHeadedGraphAttention(mid_channels[i], heads,
mid_channels[i + 1])
for i in range(len(self.mid_channels) - 1)
])
self.position_encoding = import_class(position_encoding)
self.encoder = Encoder(
layer_num=layer_num,
position_encoding=self.position_encoding,
heads=heads,
size=encode_size,
d_ff=d_ff,
dropout=dropout,
attention_dropout=attention_dropout,
position_encoding_dropout=position_encoding_dropout)
self.average_pooling = nn.AdaptiveAvgPool2d((8, 8))
self.out_pooling = nn.AdaptiveAvgPool1d(20)
self.output_layer = nn.Linear(20 * 8 * 8, n_classes)
import torch.nn as nn
import torch
import numpy as np
import argparse
from processor.base_method import import_class
import sys
if __name__ == '__main__':
parser = argparse.ArgumentParser(description="MuiltKernelGTCN network")
processors = dict()
processors['recognition'] = import_class('processor.action_recognition.Recognition')
subparsers = parser.add_subparsers(dest='processor') #启动命名空间为processor的添加子命令，dest=‘’将存储子命令名称的属性的名称为processor
for k, p in processors.items(): #将字典中的每一对变成元组的形式（[name,zhang],[age,20]）
subparsers.add_parser(k, parents=[p.get_parser()]) #添加子命令K, 这个子命令K继承了p.get_paeser()中定义的所有的命令参数
# read arguments
arg = parser.parse_args() #开始读取命令行的数值并保存
# start
Processor = processors['recognition'] #读取arg的processor属性,取出processors字典中的key代表的元素
p = Processor(sys.argv[2:]) #sys.argv[0]指.py程序本身,argv[2:]指从命令行获取的第二个参数
print('start')
p.start()
def __init__(self,
graph,
kernel_num,
edge_weight,
lamda,
input_channel,
mid_channels: list,
layer_num,
heads,
encode_size,
d_ff,
dropout,
position_encoding_dropout,
point_num=25,
n_classes=60,
graph_arg={}):
super(Model, self).__init__()
self.point_num = point_num
self.input_channel = input_channel
self.mid_channels = mid_channels
self.data_bn = nn.BatchNorm1d(self.point_num * self.input_channel)
Graph = import_class(graph)
self.graph = Graph(**graph_arg)
self.A = self.graph.A
kernel_size = self.A.shape[0]
t_kernel = 9
self.backBone1 = MuiltKernelGTCN_(input_channel, 32, self.A, True,
kernel_num, (t_kernel, kernel_size),
edge_weight, lamda)
self.backBone2 = MuiltKernelGTCN_(32,
64,
self.A,
True,
kernel_num, (t_kernel, kernel_size),
edge_weight,
lamda,
stride=1)
self.backBone3 = MuiltKernelGTCN_(64, 64, self.A, True, kernel_num,
(t_kernel, kernel_size), edge_weight,
lamda)
self.input_att = MultiHeadedGraphAttention(64,
heads,
mid_channels[0],
dropout=dropout)
self.input_layer = nn.ModuleList([
MultiHeadedGraphAttention(mid_channels[i],
heads,
mid_channels[i + 1],
dropout=dropout)
for i in range(len(self.mid_channels) - 1)
])
self.pos_embedding = nn.Parameter(torch.randn(1, 150 + 1, encode_size))
self.cls_token = nn.Parameter(torch.randn(1, 1, encode_size))
self.transformer = Transformer(dim=encode_size,
depth=layer_num,
heads=heads,
dim_head=encode_size,
mlp_dim=d_ff,
dropout=dropout)
self.dropout = nn.Dropout(position_encoding_dropout)
self.to_latent = nn.Identity()
self.mlp_head = nn.Sequential(nn.LayerNorm(encode_size),
nn.Linear(encode_size, n_classes))