def __init__(self, in_feats, n_classes, k, bias):
super(SGC, self).__init__()
self.net = SGConv(in_feats,
n_classes,
k=k,
cached=False,
bias=bias,
norm=None)
def __init__(self, in_features, out_features, k, is_out_layer=True):
super().__init__()
# Fixme: Deal zero degree
self.conv1 = SGConv(in_features,
out_features,
k,
cached=True,
allow_zero_in_degree=True)
self.is_out_layer = is_out_layer
def __init__(self, g, in_feats, n_classes, n_hidden, k, bias):
super(SGC, self).__init__()
self.g = g
self.net = SGConv(in_feats, n_classes, k=k, cached=True, bias=bias)
def __init__(self, k, feature_dims, emb_dims, output_classes, init_points = 512, input_dims=3,
dropout_prob=0.5, npart=1, id_skip=False, drop_connect_rate=0, res_scale = 1.0,
light = False, bias = False, cluster='xyz', conv='EdgeConv', use_xyz=True, use_se = True, graph_jitter = False):
super(Model, self).__init__()
self.npart = npart
self.graph_jitter = graph_jitter
self.res_scale = res_scale
self.id_skip = id_skip
self.drop_connect_rate = drop_connect_rate
self.nng = KNNGraphE(k) # with random neighbor
self.conv = nn.ModuleList()
self.conv_s1 = nn.ModuleList()
self.conv_s2 = nn.ModuleList()
self.bn = nn.ModuleList()
self.sa = nn.ModuleList()
self.cluster = cluster
self.feature_dims = feature_dims
self.conv_type = conv
self.init_points = init_points
self.k = k
#self.proj_in = nn.Linear(input_dims, input_dims)
self.num_layers = len(feature_dims)
npoint = init_points
for i in range(self.num_layers):
if k==1:
self.conv.append(nn.Linear(feature_dims[i-1] if i > 0 else input_dims,
feature_dims[i] ))
elif conv == 'EdgeConv':
if light:
self.conv.append(EdgeConv_Light(
feature_dims[i - 1] if i > 0 else input_dims,
feature_dims[i],
batch_norm=True))
else:
self.conv.append(EdgeConv(
feature_dims[i - 1] if i > 0 else input_dims,
feature_dims[i],
batch_norm=True))
elif conv == 'GATConv':
self.conv.append(GATConv(
feature_dims[i - 1] if i > 0 else input_dims,
feature_dims[i],
feat_drop=0.2, attn_drop=0.2,
residual=True,
num_heads=1))
elif conv == 'GraphConv':
self.conv.append( GraphConv(
feature_dims[i - 1] if i > 0 else input_dims,
feature_dims[i]))
elif conv == 'SAGEConv':
self.conv.append( SAGEConv(
feature_dims[i - 1] if i > 0 else input_dims,
feature_dims[i],
feat_drop=0.2,
aggregator_type='mean',
norm = nn.BatchNorm1d(feature_dims[i])
) )
elif conv == 'SGConv':
self.conv.append( SGConv(
feature_dims[i - 1] if i > 0 else input_dims,
feature_dims[i]) )
elif conv == 'GatedGCN': # missing etypes
self.conv.append( GatedGCNLayer(
feature_dims[i - 1] if i > 0 else input_dims,
feature_dims[i],
dropout=0.0,
graph_norm=True, batch_norm=True, residual=True)
)
if i>0 and feature_dims[i]>feature_dims[i-1]:
npoint = npoint//2
if id_skip and npoint <= self.init_points//4: # Only work on high level
self.conv_s2.append( nn.Linear(feature_dims[i-1], feature_dims[i] ))
self.sa.append(PointnetSAModule(
npoint=npoint,
radius=0.2,
nsample=64,
mlp=[feature_dims[i], feature_dims[i], feature_dims[i]],
fuse = 'add',
norml = 'bn',
activation = 'relu',
use_se = use_se,
use_xyz = use_xyz,
use_neighbor = False,
light = light
))
#if id_skip:
# self.conv_s1.append( nn.Linear(feature_dims[i], feature_dims[i] ))
self.embs = nn.ModuleList()
self.bn_embs = nn.ModuleList()
self.dropouts = nn.ModuleList()
self.partpool = nn.AdaptiveAvgPool1d(self.npart)
if self.npart == 1:
self.embs.append(nn.Linear(
# * 2 because of concatenation of max- and mean-pooling
feature_dims[-1]*2, emb_dims[0], bias=bias))
self.bn_embs.append(nn.BatchNorm1d(emb_dims[0]))
self.dropouts.append(nn.Dropout(dropout_prob, inplace=True))
self.proj_output = nn.Linear(emb_dims[0], output_classes)
self.proj_output.apply(weights_init_classifier)
else:
self.proj_outputs = nn.ModuleList()
for i in range(0, self.npart):
self.embs.append(nn.Linear(512, 512, bias=bias))
self.bn_embs.append(nn.BatchNorm1d(512))
self.dropouts.append(nn.Dropout(dropout_prob, inplace=True))
self.proj_outputs.append(nn.Linear(512, output_classes))
self.proj_outputs.apply(weights_init_classifier)
# initial
#self.proj_in.apply(weights_init_kaiming)
self.conv.apply(weights_init_kaiming)
self.conv_s1.apply(weights_init_kaiming)
self.conv_s2.apply(weights_init_kaiming)
weights_init_kaiming2 = lambda x:weights_init_kaiming(x,L=self.num_layers)
self.sa.apply(weights_init_kaiming2)
#self.proj.apply(weights_init_kaiming)
self.embs.apply(weights_init_kaiming)
self.bn.apply(weights_init_kaiming)
self.bn_embs.apply(weights_init_kaiming)
self.npart = npart