def __init__(self, num_layers=2, hidden=16, features_num=16, num_class=2, droprate=0.5, dim=1, kernel_size=2, edge_droprate=0.0, fea_norm="no_norm", K=20, alpha=0.5): super(SplineGCN, self).__init__() self.droprate = droprate self.edge_droprate = edge_droprate if fea_norm == "no_norm": self.fea_norm_layer = None elif fea_norm == "graph_size_norm": self.fea_norm_layer = GraphSizeNorm() else: raise ValueError("your fea_norm is un-defined: %s") % fea_norm self.convs = torch.nn.ModuleList() self.convs.append(SplineConv(features_num, hidden, dim, kernel_size)) for i in range(num_layers - 2): self.convs.append(SplineConv(hidden, hidden, dim, kernel_size)) self.convs.append(SplineConv(hidden, num_class, dim, kernel_size)) self.appnp = APPNP(K, alpha)
def __init__(self, num_features, num_classes, training_method='dfa'): super(DFASplineNet, self).__init__() self.conv1 = SplineConv(num_features, 16, dim=1, kernel_size=2) self.dfa_1 = DFALayer() self.conv2 = SplineConv(16, num_classes, dim=1, kernel_size=2) self.dfa = DFA(dfa_layers=[self.dfa_1], no_training=training_method != 'dfa')
def __init__(self, num_in_features, num_outp_features, mid_features, kernel=3, dim=3, batchnorm1=True): super(SplineBlock, self).__init__() self.batchnorm1 = batchnorm1 self.conv1 = SplineConv(num_in_features, mid_features, dim, kernel, is_open_spline=False) if self.batchnorm1: self.batchnorm1 = torch.nn.BatchNorm1d(mid_features) self.conv2 = SplineConv(mid_features, 2 * mid_features, dim, kernel, is_open_spline=False) self.batchnorm2 = torch.nn.BatchNorm1d(2 * mid_features) self.conv3 = SplineConv(2 * mid_features + 3, num_outp_features, dim, kernel, is_open_spline=False)
def layers(self): # TODO adapt to per-layer configurability self.layers_list = torch.nn.ModuleList() conv_in = SplineConv(in_channels=self.config.feature_dimensionality, out_channels=self.config.hidden_units, dim=self.config.pseudo_dimensionality, kernel_size=self.config.kernel_size, norm=False, root_weight=False, bias=self.config.use_bias) self.layers_list.append(conv_in) for i in range(self.config.hidden_layers): l = SplineConv(in_channels=self.config.hidden_units, out_channels=self.config.hidden_units, dim=self.config.pseudo_dimensionality, kernel_size=self.config.kernel_size, norm=False, root_weight=False, bias=self.config.use_bias) self.layers_list.append(l) conv_out = SplineConv(in_channels=self.config.hidden_units, out_channels=self.model_type.out_channels, dim=self.config.pseudo_dimensionality, kernel_size=self.config.kernel_size, norm=False, root_weight=False, bias=self.config.use_bias) self.layers_list.append(conv_out)
def __init__(self): super(Net, self).__init__() self.conv1 = SplineConv(1, 32, dim=2, kernel_size=5) self.conv2 = SplineConv(32, 64, dim=2, kernel_size=5) self.conv3 = SplineConv(64, 64, dim=2, kernel_size=5) self.fc1 = torch.nn.Linear(4 * 64, 128) self.fc2 = torch.nn.Linear(128, 10)
def __init__(self): super(Net, self).__init__() self.conv1 = SplineConv(d.num_features, 32, dim=2, kernel_size=5) self.conv2 = SplineConv(32, 64, dim=2, kernel_size=5) self.conv3 = SplineConv(64, 64, dim=2, kernel_size=5) self.fc1 = torch.nn.Linear(4 * 64, 128) self.fc2 = torch.nn.Linear(128, d.num_classes)
def __init__(self, prune=False): super(Net, self).__init__() self.conv1 = SplineConv(dataset.num_features, 16, dim=1, kernel_size=2) self.conv2 = SplineConv(16, dataset.num_classes, dim=1, kernel_size=2) self.prune = prune if prune == 'data': self.prunedata()
def __init__(self, numFeatures, numClasses): super().__init__() self.conv1 = SplineConv(numFeatures, 32, 3, 5) self.conv2 = SplineConv(32, 64, 3, 5) self.fc1 = torch.nn.Linear(768, 128) self.fc2 = torch.nn.Linear(128, numClasses * 1)
def __init__(self): super(Net, self).__init__() self.func = GCNLayer(input_size=64, output_size=64) self.conv1 = SplineConv(dataset.num_features, 64, dim=1, kernel_size=2).to(device) self.neuralDE = NeuralDE(self.func, solver='rk4', s_span=torch.linspace(0, 1, 3)).to(device) self.conv2 = SplineConv(64, dataset.num_classes, dim=1, kernel_size=2).to(device)
def __init__(self, input_size, output_size): super(GCNLayer, self).__init__() if input_size != output_size: raise AttributeError('input size must equal output size') self.conv1 = SplineConv(input_size, output_size, dim=1, kernel_size=2).to(device) self.conv2 = SplineConv(input_size, output_size, dim=1, kernel_size=2).to(device)
def __init__(self, datasetroot, width): super(SPlineNet, self).__init__() self.conv1 = SplineConv(datasetroot.num_features, 32, dim=2, kernel_size=5) self.conv2 = SplineConv(32, 64, dim=2, kernel_size=5) self.lin1 = torch.nn.Linear(64, width[0]) self.lin2 = torch.nn.Linear(width[0], width[1]) self.lin3 = torch.nn.Linear(width[1], datasetroot.num_classes)
def __init__(self, num_classes): super().__init__() self.conv1 = SplineConv(1, 64, dim=3, kernel_size=5) self.conv2 = SplineConv(64, 64, dim=3, kernel_size=5) self.conv3 = SplineConv(64, 128, dim=3, kernel_size=5) self.lin1 = Lin(128, 256) self.lin2 = Lin(256, 256) self.lin3 = Lin(256, num_classes)
def __init__(self,num_features,num_classes, width): super(SplineNet, self).__init__() self.NumLayers=len(width) self.layers = nn.ModuleList() self.layers.append(SplineConv(num_features, width[0], dim=1, kernel_size=2)) for i in range(self.NumLayers-1): layer=SplineConv(width[i],width[i+1], dim=1, kernel_size=2) nn.init.xavier_uniform_(layer.weight) self.layers.append(layer) self.layers.append(SplineConv(width[-1],num_classes, dim=1, kernel_size=2))
def __init__(self): super(Net, self).__init__() self.conv1 = SplineConv(1, 64, dim=2, kernel_size=5) self.bn1 = torch.nn.BatchNorm1d(64) self.conv2 = SplineConv(64, 128, dim=2, kernel_size=5) self.bn2 = torch.nn.BatchNorm1d(128) self.conv3 = SplineConv(128, 256, dim=2, kernel_size=5) self.bn3 = torch.nn.BatchNorm1d(256) self.conv4 = SplineConv(256, 512, dim=2, kernel_size=5) self.bn4 = torch.nn.BatchNorm1d(512) self.fc1 = torch.nn.Linear(64 * 512, 1024) self.fc2 = torch.nn.Linear(1024, 10)
def __init__(self, input_planes, planes, stride=1, dim_change=None): super(bottleNeck, self).__init__() self.conv1 = SplineConv(input_planes, planes, dim=2, kernel_size=1) self.bn1 = torch.nn.BatchNorm1d(planes) self.conv2 = SplineConv(planes, planes, dim=2, kernel_size=3) self.bn2 = torch.nn.BatchNorm1d(planes) self.conv3 = SplineConv(planes, planes * self.expansion, dim=2, kernel_size=1) self.bn3 = torch.nn.BatchNorm1d(planes * self.expansion) self.dim_change = dim_change
def test_spline_conv(): warnings.filterwarnings('ignore', '.*non-optimized CPU version.*') x1 = torch.randn(4, 8) x2 = torch.randn(2, 16) edge_index = torch.tensor([[0, 1, 2, 3], [0, 0, 1, 1]]) row, col = edge_index value = torch.rand(row.size(0), 3) adj = SparseTensor(row=row, col=col, value=value, sparse_sizes=(4, 4)) conv = SplineConv(8, 32, dim=3, kernel_size=5) assert conv.__repr__() == 'SplineConv(8, 32, dim=3)' out = conv(x1, edge_index, value) assert out.size() == (4, 32) assert torch.allclose(conv(x1, edge_index, value, size=(4, 4)), out) assert torch.allclose(conv(x1, adj.t()), out) if is_full_test(): t = '(Tensor, Tensor, OptTensor, Size) -> Tensor' jit = torch.jit.script(conv.jittable(t)) assert torch.allclose(jit(x1, edge_index, value), out) assert torch.allclose(jit(x1, edge_index, value, size=(4, 4)), out) t = '(Tensor, SparseTensor, OptTensor, Size) -> Tensor' jit = torch.jit.script(conv.jittable(t)) assert torch.allclose(jit(x1, adj.t()), out) adj = adj.sparse_resize((4, 2)) conv = SplineConv((8, 16), 32, dim=3, kernel_size=5) assert conv.__repr__() == 'SplineConv((8, 16), 32, dim=3)' out1 = conv((x1, x2), edge_index, value) out2 = conv((x1, None), edge_index, value, (4, 2)) assert out1.size() == (2, 32) assert out2.size() == (2, 32) assert torch.allclose(conv((x1, x2), edge_index, value, (4, 2)), out1) assert torch.allclose(conv((x1, x2), adj.t()), out1) assert torch.allclose(conv((x1, None), adj.t()), out2) if is_full_test(): t = '(OptPairTensor, Tensor, OptTensor, Size) -> Tensor' jit = torch.jit.script(conv.jittable(t)) assert torch.allclose(jit((x1, x2), edge_index, value), out1) assert torch.allclose(jit((x1, x2), edge_index, value, size=(4, 2)), out1) assert torch.allclose(jit((x1, None), edge_index, value, size=(4, 2)), out2) t = '(OptPairTensor, SparseTensor, OptTensor, Size) -> Tensor' jit = torch.jit.script(conv.jittable(t)) assert torch.allclose(jit((x1, x2), adj.t()), out1) assert torch.allclose(jit((x1, None), adj.t()), out2)
def __init__(self): super(Net, self).__init__() if model_name == 'GCN': self.conv1 = GCNConv(dataset_train.num_node_features, 16) self.conv2 = GCNConv(16, dataset_train.num_node_labels) elif model_name == 'Spline': self.conv1 = SplineConv(dataset_train.num_node_features, 16, dim=1, kernel_size=2) self.conv2 = SplineConv(16, dataset_train.num_node_labels, dim=1, kernel_size=2)
def test_lazy_spline_conv(): x1 = torch.randn(4, 8) x2 = torch.randn(2, 16) edge_index = torch.tensor([[0, 1, 2, 3], [0, 0, 1, 1]]) value = torch.rand(edge_index.size(1), 3) conv = SplineConv(-1, 32, dim=3, kernel_size=5) assert conv.__repr__() == 'SplineConv(-1, 32, dim=3)' out = conv(x1, edge_index, value) assert out.size() == (4, 32) conv = SplineConv((-1, -1), 32, dim=3, kernel_size=5) assert conv.__repr__() == 'SplineConv((-1, -1), 32, dim=3)' out = conv((x1, x2), edge_index, value) assert out.size() == (2, 32)
def __init__(self, in_channels, out_channels, dim, num_layers, cat=True, lin=True, dropout=0.0): super(SplineCNN, self).__init__() self.in_channels = in_channels self.dim = dim self.num_layers = num_layers self.cat = cat self.lin = lin self.dropout = dropout self.convs = torch.nn.ModuleList() for _ in range(num_layers): conv = SplineConv(in_channels, out_channels, dim, kernel_size=5) self.convs.append(conv) in_channels = out_channels if self.cat: in_channels = self.in_channels + num_layers * out_channels else: in_channels = out_channels if self.lin: self.out_channels = out_channels self.final = Lin(in_channels, out_channels) else: self.out_channels = in_channels self.reset_parameters()
def test_spline_conv(): x1 = torch.randn(4, 8) x2 = torch.randn(2, 16) edge_index = torch.tensor([[0, 1, 2, 3], [0, 0, 1, 1]]) row, col = edge_index value = torch.rand(row.size(0), 3) adj = SparseTensor(row=row, col=col, value=value, sparse_sizes=(4, 4)) conv = SplineConv(8, 32, dim=3, kernel_size=5) assert conv.__repr__() == 'SplineConv(8, 32, dim=3)' out = conv(x1, edge_index, value) assert out.size() == (4, 32) assert conv(x1, edge_index, value, size=(4, 4)).tolist() == out.tolist() assert conv(x1, adj.t()).tolist() == out.tolist() t = '(Tensor, Tensor, OptTensor, Size) -> Tensor' jit = torch.jit.script(conv.jittable(t)) assert jit(x1, edge_index, value).tolist() == out.tolist() assert jit(x1, edge_index, value, size=(4, 4)).tolist() == out.tolist() t = '(Tensor, SparseTensor, OptTensor, Size) -> Tensor' jit = torch.jit.script(conv.jittable(t)) assert jit(x1, adj.t()).tolist() == out.tolist() adj = adj.sparse_resize((4, 2)) conv = SplineConv((8, 16), 32, dim=3, kernel_size=5) assert conv.__repr__() == 'SplineConv((8, 16), 32, dim=3)' out1 = conv((x1, x2), edge_index, value) out2 = conv((x1, None), edge_index, value, (4, 2)) assert out1.size() == (2, 32) assert out2.size() == (2, 32) assert conv((x1, x2), edge_index, value, (4, 2)).tolist() == out1.tolist() assert conv((x1, x2), adj.t()).tolist() == out1.tolist() assert conv((x1, None), adj.t()).tolist() == out2.tolist() t = '(OptPairTensor, Tensor, OptTensor, Size) -> Tensor' jit = torch.jit.script(conv.jittable(t)) assert jit((x1, x2), edge_index, value).tolist() == out1.tolist() assert jit((x1, x2), edge_index, value, size=(4, 2)).tolist() == out1.tolist() assert jit((x1, None), edge_index, value, size=(4, 2)).tolist() == out2.tolist() t = '(OptPairTensor, SparseTensor, OptTensor, Size) -> Tensor' jit = torch.jit.script(conv.jittable(t)) assert jit((x1, x2), adj.t()).tolist() == out1.tolist() assert jit((x1, None), adj.t()).tolist() == out2.tolist()
def test_lazy_spline_conv(): warnings.filterwarnings('ignore', '.*non-optimized CPU version.*') x1 = torch.randn(4, 8) x2 = torch.randn(2, 16) edge_index = torch.tensor([[0, 1, 2, 3], [0, 0, 1, 1]]) value = torch.rand(edge_index.size(1), 3) conv = SplineConv(-1, 32, dim=3, kernel_size=5) assert conv.__repr__() == 'SplineConv(-1, 32, dim=3)' out = conv(x1, edge_index, value) assert out.size() == (4, 32) conv = SplineConv((-1, -1), 32, dim=3, kernel_size=5) assert conv.__repr__() == 'SplineConv((-1, -1), 32, dim=3)' out = conv((x1, x2), edge_index, value) assert out.size() == (2, 32)
def __init__(self, D, C, G=0, task='graph'): super(SplineNet, self).__init__() self.D = D self.C = C self.G = G self.conv1 = SplineConv(self.D, self.D, dim=1, degree=1, kernel_size=3) self.conv2 = SplineConv(self.D, self.D, dim=1, degree=1, kernel_size=5) if (self.G > 0): self.Z = self.D + self.G else: self.Z = self.D self.mlp1 = Linear(self.Z, self.Z) self.mlp2 = Linear(self.Z, self.C)
def __init__(self, ratio, r, in_channels, out_channels, dim, kernel_size): super(Downsampling, self).__init__() self.ratio = ratio self.r = r self.conv = SplineConv(in_channels, out_channels, dim=dim, kernel_size=kernel_size)
def __init__(self, filter_nr, l, k, activation, nr_points): super(DirectionalSplineConvNoF, self).__init__() self.nr_points = nr_points self.k = k self.l = l if l <= k else k self.activation = activation self.filter_nr = filter_nr self.conv = SplineConv(1, self.filter_nr, dim=3, kernel_size=15) self.bn = BatchNorm1d(self.filter_nr)
def __init__(self, in_channel, out_channel): super(ResidualBlock, self).__init__() self.left_conv1 = SplineConv(in_channel, out_channel, dim=2, kernel_size=5) self.left_bn1 = torch.nn.BatchNorm1d(out_channel) self.left_conv2 = SplineConv(out_channel, out_channel, dim=2, kernel_size=5) self.left_bn2 = torch.nn.BatchNorm1d(out_channel) self.shortcut_conv = SplineConv(in_channel, out_channel, dim=2, kernel_size=1) self.shortcut_bn = torch.nn.BatchNorm1d(out_channel)
def test_spline_conv(): in_channels, out_channels = (16, 32) edge_index = torch.tensor([[0, 0, 0, 1, 2, 3], [1, 2, 3, 0, 0, 0]]) num_nodes = edge_index.max().item() + 1 x = torch.randn((num_nodes, in_channels)) pseudo = torch.rand((edge_index.size(1), 3)) conv = SplineConv(in_channels, out_channels, dim=3, kernel_size=5) assert conv.__repr__() == 'SplineConv(16, 32)' assert conv(x, edge_index, pseudo).size() == (num_nodes, out_channels)
def __init__(self): super(GFCND, self).__init__() self.down1 = Downsampling(k_range=32, ratio=0.5, in_channels=1, out_channels=32, dim=2, kernel_size=5, batch_norm=False) self.down2 = Downsampling(k_range=64, ratio=0.5, in_channels=32, out_channels=64, dim=2, kernel_size=3) self.down3 = Downsampling(k_range=128, ratio=0.5, in_channels=64, out_channels=128, dim=2, kernel_size=3) self.up1 = Upsampling(k=3, in_channels=128, out_channels=64, dim=2, kernel_size=3) self.score_fs = SplineConv(64, 32, dim=2, kernel_size=3) self.up2 = Upsampling(k=3, in_channels=32, out_channels=32, dim=2, kernel_size=5, conv_layer=False) self.up3 = Upsampling(k=3, in_channels=32, out_channels=32, dim=2, kernel_size=5, conv_layer=False) self.score_pool2 = SplineConv(64, 32, dim=2, kernel_size=3) self.convout = SplineConv(32, 1, dim=2, kernel_size=5)
def __init__(self): super(GFCN, self).__init__() self.conv1a = SplineConv(1, 32, dim=2, kernel_size=5) self.conv1b = SplineConv(32, 32, dim=2, kernel_size=5) # self.bn1 = torch.nn.BatchNorm1d(32) self.conv2a = SplineConv(32, 64, dim=2, kernel_size=3) self.conv2b = SplineConv(64, 64, dim=2, kernel_size=3) self.bn2 = torch.nn.BatchNorm1d(64) self.conv3a = SplineConv(64, 128, dim=2, kernel_size=3) self.conv3b = SplineConv(128, 128, dim=2, kernel_size=1) self.bn3 = torch.nn.BatchNorm1d(128) self.score_fr1 = SplineConv(128, 64, dim=2, kernel_size=1) self.score_fr2 = SplineConv(64, 32, dim=2, kernel_size=1) self.score_pool2 = SplineConv(64, 32, dim=2, kernel_size=3) self.convout = SplineConv(32, 1, dim=2, kernel_size=5)
def __init__(self): super(Net, self).__init__() self.conv1 = SplineConv(1, 64, dim=2, kernel_size=5) self.bn1 = torch.nn.BatchNorm1d(64) self.block1 = ResidualBlock(64, 128) self.block2 = ResidualBlock(128, 256) self.block3 = ResidualBlock(256, 512) self.fc1 = torch.nn.Linear(64 * 512, 1024) self.fc2 = torch.nn.Linear(1024, 10)
def makeConv(self, nin, nout, conv_args): # FeaStConv if(conv_args['name'] == 'FeaSt'): return FeaStConv(nin, nout, conv_args["num_heads"]) # SplineConv if(conv_args['name'] == 'Spline'): return SplineConv(nin, nout, self.edge_dim, conv_args["kernel_size"], is_open_spline=conv_args["open_spline"], degree=conv_args["degree"] ) # GMMConv if(conv_args['name'] == "GMM"): return GMMConv(nin, nout, self.edge_dim, conv_args["kernel_size"] ) # NNConv if(conv_args["name"] == "NN"): h = nn.Sequential( nn.Linear(self.edge_dim, nin*nout), nn.ReLU() #nn.Linear(int(nin*nout/2), nin*nout) ) return NNConv(nin, nout, h) # PPFConv if(conv_args["name"] == "PPF"): cin = nin+4 hl = nn.Sequential( nn.Linear(cin, conv_args['nhidden']), nn.ReLU() ) hg = nn.Linear(conv_args['nhidden'], nout) #hl = nn.Sequential( #nn.Linear(cin, int(conv_args['nhidden']/2)), #nn.ReLU(), #nn.Linear(int(conv_args['nhidden']/2), conv_args['nhidden']) #) #hg = nn.Sequential( #nn.Linear(conv_args['nhidden'], nout), #nn.ReLU(), #nn.Linear(nout, nout) #) return PPFConv(hl, hg) # CGConv if(conv_args["name"] == "CG"): return CGConv(nin, self.edge_dim)